vcl/source/filter/igif/decode.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "decode.hxx"
  22
  23 // ------------------------------------------------------------------------
  24
  25 struct GIFLZWTableEntry
  26 {
  27     GIFLZWTableEntry*   pPrev;
  28     GIFLZWTableEntry*   pFirst;
  29     sal_uInt8               nData;
  30 };
  31
  32 // ------------------------------------------------------------------------
  33
  34 GIFLZWDecompressor::GIFLZWDecompressor( sal_uInt8 cDataSize ) :
  35             nInputBitsBuf       ( 0 ),
  36             nOutBufDataLen      ( 0 ),
  37             nInputBitsBufSize   ( 0 ),
  38             bEOIFound           ( sal_False ),
  39             nDataSize           ( cDataSize )
  40 {
  41     pOutBuf = new sal_uInt8[ 4096 ];
  42
  43     nClearCode = 1 << nDataSize;
  44     nEOICode = nClearCode + 1;
  45     nTableSize = nEOICode + 1;
  46     nCodeSize = nDataSize + 1;
  47     nOldCode = 0xffff;
  48     pOutBufData = pOutBuf + 4096;
  49
  50     pTable = new GIFLZWTableEntry[ 4098 ];
  51
  52     for( sal_uInt16 i = 0; i < nTableSize; i++ )
  53     {
  54         pTable[i].pPrev = NULL;
  55         pTable[i].pFirst = pTable + i;
  56         pTable[i].nData = (sal_uInt8) i;
  57     }
  58 }
  59
  60 // ------------------------------------------------------------------------
  61
  62 GIFLZWDecompressor::~GIFLZWDecompressor()
  63 {
  64     delete[] pOutBuf;
  65     delete[] pTable;
  66 }
  67
  68 // ------------------------------------------------------------------------
  69
  70 HPBYTE GIFLZWDecompressor::DecompressBlock( HPBYTE pSrc, sal_uInt8 cBufSize,
  71                                             sal_uLong& rCount, sal_Bool& rEOI )
  72 {
  73     sal_uLong   nTargetSize = 4096;
  74     sal_uLong   nCount = 0;
  75     HPBYTE  pTarget = (HPBYTE) rtl_allocateMemory( nTargetSize );
  76     HPBYTE  pTmpTarget = pTarget;
  77
  78     nBlockBufSize = cBufSize;
  79     nBlockBufPos = 0;
  80     pBlockBuf = pSrc;
  81
  82     while( ProcessOneCode() )
  83     {
  84         nCount += nOutBufDataLen;
  85
  86         if( nCount > nTargetSize )
  87         {
  88             sal_uLong   nNewSize = nTargetSize << 1;
  89             sal_uLong   nOffset = pTmpTarget - pTarget;
  90             HPBYTE  pTmp = (HPBYTE) rtl_allocateMemory( nNewSize );
  91
  92             memcpy( pTmp, pTarget, nTargetSize );
  93             rtl_freeMemory( pTarget );
  94
  95             nTargetSize = nNewSize;
  96             pTmpTarget = ( pTarget = pTmp ) + nOffset;
  97         }
  98
  99         memcpy( pTmpTarget, pOutBufData, nOutBufDataLen );
 100         pTmpTarget += nOutBufDataLen;
 101         pOutBufData += nOutBufDataLen;
 102         nOutBufDataLen = 0;
 103
 104         if ( bEOIFound )
 105             break;
 106     }
 107
 108     rCount = nCount;
 109     rEOI = bEOIFound;
 110
 111     return pTarget;
 112 }
 113
 114 // ------------------------------------------------------------------------
 115
 116 void GIFLZWDecompressor::AddToTable( sal_uInt16 nPrevCode, sal_uInt16 nCodeFirstData )
 117 {
 118     GIFLZWTableEntry* pE;
 119
 120     if( nTableSize < 4096 )
 121     {
 122         pE = pTable + nTableSize;
 123         pE->pPrev = pTable + nPrevCode;
 124         pE->pFirst = pE->pPrev->pFirst;
 125         pE->nData = pTable[ nCodeFirstData ].pFirst->nData;
 126         nTableSize++;
 127
 128         if ( ( nTableSize == (sal_uInt16) (1 << nCodeSize) ) && ( nTableSize < 4096 ) )
 129             nCodeSize++;
 130     }
 131 }
 132
 133 // ------------------------------------------------------------------------
 134
 135 sal_Bool GIFLZWDecompressor::ProcessOneCode()
 136 {
 137     GIFLZWTableEntry*   pE;
 138     sal_uInt16              nCode;
 139     sal_Bool                bRet = sal_False;
 140     sal_Bool                bEndOfBlock = sal_False;
 141
 142     while( nInputBitsBufSize < nCodeSize )
 143     {
 144         if( nBlockBufPos >= nBlockBufSize )
 145         {
 146             bEndOfBlock = sal_True;
 147             break;
 148         }
 149
 150         nInputBitsBuf |= ( (sal_uLong) pBlockBuf[ nBlockBufPos++ ] ) << nInputBitsBufSize;
 151         nInputBitsBufSize += 8;
 152     }
 153
 154     if ( !bEndOfBlock )
 155     {
 156         // Einen Code aus dem Eingabe-Buffer holen:
 157         nCode = sal::static_int_cast< sal_uInt16 >(
 158             ( (sal_uInt16) nInputBitsBuf ) & ( ~( 0xffff << nCodeSize ) ));
 159         nInputBitsBuf >>= nCodeSize;
 160         nInputBitsBufSize = nInputBitsBufSize - nCodeSize;
 161
 162         if ( nCode < nClearCode )
 163         {
 164             if ( nOldCode != 0xffff )
 165                 AddToTable( nOldCode, nCode );
 166         }
 167         else if ( ( nCode > nEOICode ) && ( nCode <= nTableSize ) )
 168         {
 169             if ( nCode == nTableSize )
 170                 AddToTable( nOldCode, nOldCode );
 171             else
 172                 AddToTable( nOldCode, nCode );
 173         }
 174         else
 175         {
 176             if ( nCode == nClearCode )
 177             {
 178                 nTableSize = nEOICode + 1;
 179                 nCodeSize = nDataSize + 1;
 180                 nOldCode = 0xffff;
 181                 nOutBufDataLen = 0;
 182             }
 183             else
 184                 bEOIFound = sal_True;
 185
 186             return sal_True;
 187         }
 188
 189         nOldCode = nCode;
 190
 191         // Zeichen(/-folge) des Codes nCode in den Ausgabe-Buffer schreiben:
 192         pE = pTable + nCode;
 193         do
 194         {
 195             nOutBufDataLen++;
 196             *(--pOutBufData) = pE->nData;
 197             pE = pE->pPrev;
 198         }
 199         while( pE );
 200
 201         bRet = sal_True;
 202     }
 203
 204     return bRet;
 205 }
 206
 207 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */