lotuswordpro/source/filter/lwpobjstrm.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  The Contents of this file are made available subject to the terms of
   5  *  either of the following licenses
   6  *
   7  *         - GNU Lesser General Public License Version 2.1
   8  *         - Sun Industry Standards Source License Version 1.1
   9  *
  10  *  Sun Microsystems Inc., October, 2000
  11  *
  12  *  GNU Lesser General Public License Version 2.1
  13  *  =============================================
  14  *  Copyright 2000 by Sun Microsystems, Inc.
  15  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  16  *
  17  *  This library is free software; you can redistribute it and/or
  18  *  modify it under the terms of the GNU Lesser General Public
  19  *  License version 2.1, as published by the Free Software Foundation.
  20  *
  21  *  This library is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  *  Lesser General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU Lesser General Public
  27  *  License along with this library; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  29  *  MA  02111-1307  USA
  30  *
  31  *
  32  *  Sun Industry Standards Source License Version 1.1
  33  *  =================================================
  34  *  The contents of this file are subject to the Sun Industry Standards
  35  *  Source License Version 1.1 (the "License"); You may not use this file
  36  *  except in compliance with the License. You may obtain a copy of the
  37  *  License at http://www.openoffice.org/license.html.
  38  *
  39  *  Software provided under this License is provided on an "AS IS" basis,
  40  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  41  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  42  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  43  *  See the License for the specific provisions governing your rights and
  44  *  obligations concerning the Software.
  45  *
  46  *  The Initial Developer of the Original Code is: IBM Corporation
  47  *
  48  *  Copyright: 2008 by IBM Corporation
  49  *
  50  *  All Rights Reserved.
  51  *
  52  *  Contributor(s): _______________________________________
  53  *
  54  *
  55  ************************************************************************/
  56 /*************************************************************************
  57  * Change History
  58  Jan 2005           Created
  59  ************************************************************************/
  60
  61 #include "lwpobjstrm.hxx"
  62 #include "lwptools.hxx"
  63 #include <boost/scoped_array.hpp>
  64
  65 /**
  66  * @descr  ctor() from LwpSvStream
  67  */
  68 LwpObjectStream::LwpObjectStream(LwpSvStream *pStrm, bool isCompressed, sal_uInt16 size)
  69     :m_pContentBuf(NULL), m_nBufSize(size), m_nReadPos(0),
  70     m_pStrm(pStrm), m_bCompressed(isCompressed)
  71 {
  72     assert(size<IO_BUFFERSIZE);
  73     ReadStream();
  74 }
  75 /**
  76  * @descr  read object data from stream
  77  */
  78 void LwpObjectStream::ReadStream()
  79 {
  80     if(m_nBufSize == 0)
  81     {
  82         m_pContentBuf = NULL;
  83     }
  84     else
  85     {
  86         Read2Buffer();
  87     }
  88 }
  89 /**
  90  * @descr  read object data from stream to buffer
  91  */
  92 void LwpObjectStream::Read2Buffer()
  93 {
  94     if( m_pContentBuf )
  95     {
  96         ReleaseBuffer();
  97     }
  98
  99     m_nReadPos = 0;
 100
 101     if( m_bCompressed )
 102     {
 103         boost::scoped_array<sal_uInt8> xCompressBuf(new sal_uInt8[m_nBufSize]);
 104
 105         sal_uInt8* pCompressBuffer = xCompressBuf.get();
 106         memset(pCompressBuffer, 0, m_nBufSize);
 107         m_pStrm->Read(pCompressBuffer, m_nBufSize);
 108
 109         sal_uInt8 pTempDst[IO_BUFFERSIZE];
 110         m_nBufSize = DecompressBuffer(pTempDst, pCompressBuffer, m_nBufSize);
 111         assert( m_nBufSize < IO_BUFFERSIZE);
 112
 113         m_pContentBuf = AllocBuffer(m_nBufSize);
 114         memcpy(m_pContentBuf, pTempDst, m_nBufSize);
 115         //delete [] pTempDst;
 116
 117     }
 118     else
 119     {
 120         m_pContentBuf = AllocBuffer(m_nBufSize);
 121         m_pStrm->Read(m_pContentBuf, m_nBufSize);
 122     }
 123 }
 124 /**
 125  * @descr  alloc size of buffer
 126  */
 127 sal_uInt8* LwpObjectStream::AllocBuffer(sal_uInt16 size)
 128 {
 129     if(size<=100)
 130     {
 131         return m_SmallBuffer;
 132     }
 133     else
 134     {
 135         return new sal_uInt8[size];
 136     }
 137 }
 138 /**
 139  * @descr  signal complete to release object buffer
 140  */
 141 void LwpObjectStream::ReadComplete()
 142 {
 143     ReleaseBuffer();
 144 }
 145
 146 LwpObjectStream::~LwpObjectStream()
 147 {
 148     ReleaseBuffer();
 149 }
 150 /**
 151  * @descr  release object buffer
 152  */
 153 void LwpObjectStream::ReleaseBuffer()
 154 {
 155
 156     if(m_nBufSize>100)
 157     {
 158         if(m_pContentBuf)
 159         {
 160             delete [] m_pContentBuf;
 161             m_pContentBuf = NULL;
 162         }
 163     }
 164 }
 165 /**
 166  * @descr  read len bytes from object stream to buffer
 167  */
 168 sal_uInt16 LwpObjectStream::QuickRead(void* buf, sal_uInt16 len)
 169 {
 170     memset(buf, 0, len);
 171     if( len > m_nBufSize - m_nReadPos )
 172     {
 173         assert(false);
 174         len = m_nBufSize - m_nReadPos;
 175     }
 176     if( m_pContentBuf && len)
 177     {
 178         memcpy(buf, m_pContentBuf+m_nReadPos, len);
 179         m_nReadPos += len;
 180     }
 181     return len;
 182 }
 183 /**
 184  * @descr  SeekRel pos in object stream/buffer
 185  */
 186 void LwpObjectStream::SeekRel(sal_uInt16 pos)
 187 {
 188     if( pos > m_nBufSize - m_nReadPos)
 189         pos = m_nBufSize - m_nReadPos;
 190     m_nReadPos +=pos;
 191 }
 192 /**
 193  * @descr  Seek to pos in object buffer/buffer
 194  */
 195 bool LwpObjectStream::Seek( sal_uInt16 pos)
 196 {
 197     if (pos < m_nBufSize)
 198     {
 199         m_nReadPos = pos;
 200         return true;
 201     }
 202     return false;
 203 }
 204
 205 /**
 206  * @descr  Quick read sal_Bool
 207  */
 208 bool LwpObjectStream::QuickReadBool(bool *pFailure)
 209 {
 210     SVBT16 aValue = {0};
 211     sal_uInt16 nRead = QuickRead(aValue, sizeof(aValue));
 212     if (pFailure)
 213         *pFailure = (nRead != sizeof(aValue));
 214     return static_cast<bool>(SVBT16ToShort(aValue));
 215 }
 216 /**
 217  * @descr  Quick read sal_uInt32
 218  */
 219 sal_uInt32 LwpObjectStream::QuickReaduInt32(bool *pFailure)
 220 {
 221     SVBT32 aValue = {0};
 222     sal_uInt16 nRead = QuickRead(aValue, sizeof(aValue));
 223     if (pFailure)
 224         *pFailure = (nRead != sizeof(aValue));
 225     return SVBT32ToUInt32(aValue);
 226 }
 227 /**
 228  * @descr  Quick read sal_uInt32
 229  */
 230 sal_uInt16 LwpObjectStream::QuickReaduInt16(bool *pFailure)
 231 {
 232     SVBT16 aValue = {0};
 233     sal_uInt16 nRead = QuickRead(aValue, sizeof(aValue));
 234     if (pFailure)
 235         *pFailure = (nRead != sizeof(aValue));
 236     return SVBT16ToShort(aValue);
 237 }
 238 /**
 239  * @descr  Quick read sal_Int32
 240  */
 241 sal_Int32 LwpObjectStream::QuickReadInt32(bool *pFailure)
 242 {
 243     SVBT32 aValue = {0};
 244     sal_uInt16 nRead = QuickRead(aValue, sizeof(aValue));
 245     if (pFailure)
 246         *pFailure = (nRead != sizeof(aValue));
 247     return static_cast<sal_Int32>(SVBT32ToUInt32(aValue));
 248 }
 249 /**
 250  * @descr  Quick read sal_Int16
 251  */
 252 sal_Int16 LwpObjectStream::QuickReadInt16(bool *pFailure)
 253 {
 254     SVBT16 aValue = {0};
 255     sal_uInt16 nRead = QuickRead(aValue, sizeof(aValue));
 256     if (pFailure)
 257         *pFailure = (nRead != sizeof(aValue));
 258
 259     return static_cast<sal_Int16>(SVBT16ToShort(aValue));
 260 }
 261 /**
 262  * @descr  Quick read sal_uInt8
 263  */
 264 sal_uInt8 LwpObjectStream::QuickReaduInt8(bool *pFailure)
 265 {
 266     sal_uInt8 aValue = 0;
 267     sal_uInt16 nRead = QuickRead(&aValue, sizeof(aValue));
 268     if (pFailure)
 269         *pFailure = (nRead != sizeof(aValue));
 270     return aValue;
 271 }
 272 /**
 273  * @descr  Quick read double
 274  */
 275 double LwpObjectStream::QuickReadDouble(bool *pFailure)
 276 {
 277     union
 278     {
 279         double d;
 280         sal_uInt8 c[8];
 281     } s;
 282     memset(s.c, 0, sizeof(s.c));
 283     sal_uInt16 nRead = QuickRead(s.c, sizeof(s.c));
 284     if (pFailure)
 285         *pFailure = (nRead != sizeof(s.c));
 286 #if defined(OSL_BIGENDIAN)
 287     for (size_t i = 0; i < 4; ++i)
 288         std::swap(s.c[i], s.c[7-i]);
 289 #endif
 290     return s.d;
 291 }
 292 /**
 293  * @descr  skip extra bytes
 294  */
 295 void LwpObjectStream::SkipExtra()
 296 {
 297     sal_uInt16 extra = QuickReaduInt16();
 298     while (extra != 0)
 299         extra = QuickReaduInt16();
 300 }
 301 /**
 302  * @descr  check if extra bytes
 303  */
 304 sal_uInt16 LwpObjectStream::CheckExtra()
 305 {
 306     return QuickReaduInt16();
 307 }
 308 /**
 309  * @descr  decompress data buffer from pSrc to pDst
 310  *        Refer to the CAmiPro40File::DecompressObject(~) in LWP
 311  */
 312 sal_uInt16 LwpObjectStream::DecompressBuffer(sal_uInt8* pDst, sal_uInt8* pSrc, sal_uInt16 Size)
 313 {
 314     sal_uInt16 Cnt;
 315     sal_uInt32 DstSize = 0;
 316
 317     while (Size)
 318     {
 319         switch (*pSrc & 0xC0)
 320         {
 321             case 0x00:
 322                 // 1 - 64 bytes of 0
 323                 // Code 00zzzzzz
 324                 // where zzzzzz is the count - 1 of compressed 0 bytes
 325
 326                 Cnt = (*pSrc++ & 0x3F) + 1;
 327                 if (DstSize+Cnt >= IO_BUFFERSIZE)
 328                     throw BadDecompress();
 329                 memset(pDst, 0, Cnt);
 330                 pDst += Cnt;
 331                 DstSize += Cnt;
 332                 Size--;
 333                 break;
 334
 335             case 0x40:
 336                 // 1 - 8 zeros followed by 1 - 8 non-zero
 337                 // Code 01zzznnn binary
 338                 // where zzz is the count - 1 of compressed zero bytes
 339                 // and nnn is the count - 1 of following non-zero bytes
 340
 341                 Cnt = ((*pSrc & 0x38) >> 3) + 1;
 342                 if (DstSize+Cnt >= IO_BUFFERSIZE)
 343                     throw BadDecompress();
 344                 memset(pDst, 0, Cnt);
 345                 pDst += Cnt;
 346                 DstSize += Cnt;
 347                 Cnt = (*pSrc++ & 0x07) + 1;
 348                 if (Size < Cnt + 1)
 349                     throw BadDecompress();
 350                 Size -= Cnt + 1;
 351                 if (DstSize+Cnt >= IO_BUFFERSIZE)
 352                     throw BadDecompress();
 353                 memcpy(pDst, pSrc, Cnt);
 354                 pDst += Cnt;
 355                 DstSize += Cnt;
 356                 pSrc += Cnt;
 357                 break;
 358
 359             case 0x80:
 360                 // 1 0 followed by 1 - 64 bytes of non-zero
 361                 // Code 0x80 (or 0x40 if 8 or less non-zero)
 362                 // Code 10nnnnnn binary
 363                 // where nnnnnn is the count - 1 of following non-zero bytes
 364
 365                 *pDst++ = 0;
 366                 DstSize++;
 367                 // fall through into next case!
 368
 369             case 0xC0:
 370                 // 1 - 64 bytes of non-zero
 371                 // Code = 11nnnnnn binary
 372                 // nnnnnn is the count less 1 of following non-zero bytes
 373
 374                 Cnt = (*pSrc++ & 0x3F) + 1;
 375                 if (Size < Cnt + 1)
 376                     throw BadDecompress();
 377                 Size -= Cnt + 1;
 378                 if (DstSize+Cnt >= IO_BUFFERSIZE)
 379                     throw BadDecompress();
 380                 memcpy(pDst, pSrc, Cnt);
 381                 pDst += Cnt;
 382                 DstSize += Cnt;
 383                 pSrc += Cnt;
 384                 break;
 385         }
 386         assert(DstSize < IO_BUFFERSIZE);
 387         if (DstSize >= IO_BUFFERSIZE)
 388             throw BadDecompress();
 389
 390     }
 391     return static_cast<sal_uInt16>(DstSize);
 392 }
 393 /**
 394  * @descr  quick read string with 1252
 395  */
 396 OUString LwpObjectStream::QuickReadStringPtr()
 397 {
 398     sal_uInt16 diskSize;
 399
 400     diskSize = QuickReaduInt16();
 401     QuickReaduInt16(); //len
 402
 403     OUString str;
 404     rtl_TextEncoding rEncode =  RTL_TEXTENCODING_MS_1252;
 405     LwpTools::QuickReadUnicode(this, str, diskSize-sizeof(diskSize), rEncode);
 406     return str;
 407 }
 408
 409 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */