filter/source/graphicfilter/egif/giflzwc.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 <tools/stream.hxx>
  22 #include "giflzwc.hxx"
  23
  24 // ----------------------------
  25 // - GIFImageDataOutputStream -
  26 // ----------------------------
  27
  28 class GIFImageDataOutputStream
  29 {
  30 private:
  31
  32     void        FlushBlockBuf();
  33     inline void FlushBitsBufsFullBytes();
  34
  35     SvStream&   rStream;
  36     sal_uInt8*      pBlockBuf;
  37     sal_uInt8       nBlockBufSize;
  38     sal_uLong       nBitsBuf;
  39     sal_uInt16      nBitsBufSize;
  40
  41 public:
  42
  43                 GIFImageDataOutputStream( SvStream & rGIF, sal_uInt8 nLZWDataSize );
  44                 ~GIFImageDataOutputStream();
  45
  46     inline void WriteBits( sal_uInt16 nCode, sal_uInt16 nCodeLen );
  47 };
  48
  49 // ------------------------------------------------------------------------
  50
  51 inline void GIFImageDataOutputStream::FlushBitsBufsFullBytes()
  52 {
  53     while (nBitsBufSize>=8)
  54     {
  55         if( nBlockBufSize==255 )
  56             FlushBlockBuf();
  57
  58         pBlockBuf[nBlockBufSize++] = (sal_uInt8) nBitsBuf;
  59         nBitsBuf >>= 8;
  60         nBitsBufSize -= 8;
  61     }
  62 }
  63
  64 // ------------------------------------------------------------------------
  65
  66 inline void GIFImageDataOutputStream::WriteBits( sal_uInt16 nCode, sal_uInt16 nCodeLen )
  67 {
  68     if( nBitsBufSize+nCodeLen>32 )
  69         FlushBitsBufsFullBytes();
  70
  71     nBitsBuf |= (sal_uLong) nCode << nBitsBufSize;
  72     nBitsBufSize = nBitsBufSize + nCodeLen;
  73 }
  74
  75 // ------------------------------------------------------------------------
  76
  77 GIFImageDataOutputStream::GIFImageDataOutputStream( SvStream & rGIF, sal_uInt8 nLZWDataSize ) :
  78         rStream(rGIF)
  79 {
  80     pBlockBuf = new sal_uInt8[ 255 ];
  81     nBlockBufSize = 0;
  82     nBitsBufSize = 0;
  83     nBitsBuf = 0;
  84     rStream << nLZWDataSize;
  85 }
  86
  87 // ------------------------------------------------------------------------
  88
  89
  90 GIFImageDataOutputStream::~GIFImageDataOutputStream()
  91 {
  92     WriteBits(0,7);
  93     FlushBitsBufsFullBytes();
  94     FlushBlockBuf();
  95     rStream << (sal_uInt8)0;
  96     delete[] pBlockBuf;
  97 }
  98
  99 // ------------------------------------------------------------------------
 100
 101 void GIFImageDataOutputStream::FlushBlockBuf()
 102 {
 103     if( nBlockBufSize )
 104     {
 105         rStream << (sal_uInt8) nBlockBufSize;
 106         rStream.Write( pBlockBuf,nBlockBufSize );
 107         nBlockBufSize = 0;
 108     }
 109 }
 110
 111 // -------------------
 112 // - GIFLZWCTreeNode -
 113 // -------------------
 114
 115 struct GIFLZWCTreeNode
 116 {
 117
 118     GIFLZWCTreeNode*    pBrother;       // next node which has the same father
 119     GIFLZWCTreeNode*    pFirstChild;    // first
 120     sal_uInt16              nCode;          // the code for the string of pixel values which comes about
 121     sal_uInt16              nValue;         // the pixel value
 122 };
 123
 124 // --------------------
 125 // - GIFLZWCompressor -
 126 // --------------------
 127
 128 GIFLZWCompressor::GIFLZWCompressor()
 129 {
 130     pIDOS=NULL;
 131 }
 132
 133 // ------------------------------------------------------------------------
 134
 135 GIFLZWCompressor::~GIFLZWCompressor()
 136 {
 137     if (pIDOS!=NULL) EndCompression();
 138 }
 139
 140 // ------------------------------------------------------------------------
 141
 142 void GIFLZWCompressor::StartCompression( SvStream& rGIF, sal_uInt16 nPixelSize )
 143 {
 144     if( !pIDOS )
 145     {
 146         sal_uInt16 i;
 147
 148         nDataSize = nPixelSize;
 149
 150         if( nDataSize < 2 )
 151             nDataSize=2;
 152
 153         nClearCode=1<<nDataSize;
 154         nEOICode=nClearCode+1;
 155         nTableSize=nEOICode+1;
 156         nCodeSize=nDataSize+1;
 157
 158         pIDOS=new GIFImageDataOutputStream(rGIF,(sal_uInt8)nDataSize);
 159         pTable=new GIFLZWCTreeNode[4096];
 160
 161         for (i=0; i<4096; i++)
 162         {
 163             pTable[i].pBrother = pTable[i].pFirstChild = NULL;
 164             pTable[i].nValue = (sal_uInt8) ( pTable[i].nCode = i );
 165         }
 166
 167         pPrefix = NULL;
 168         pIDOS->WriteBits( nClearCode,nCodeSize );
 169     }
 170 }
 171
 172 // ------------------------------------------------------------------------
 173
 174 void GIFLZWCompressor::Compress( HPBYTE pSrc, sal_uLong nSize )
 175 {
 176     if( pIDOS )
 177     {
 178         GIFLZWCTreeNode*    p;
 179         sal_uInt16              i;
 180         sal_uInt8               nV;
 181
 182         if( !pPrefix && nSize )
 183         {
 184             pPrefix=pTable+(*pSrc++);
 185             nSize--;
 186         }
 187
 188         while( nSize )
 189         {
 190             nSize--;
 191             nV=*pSrc++;
 192             for( p=pPrefix->pFirstChild; p!=NULL; p=p->pBrother )
 193             {
 194                 if (p->nValue==nV)
 195                     break;
 196             }
 197
 198             if( p)
 199                 pPrefix=p;
 200             else
 201             {
 202                 pIDOS->WriteBits(pPrefix->nCode,nCodeSize);
 203
 204                 if (nTableSize==4096)
 205                 {
 206                     pIDOS->WriteBits(nClearCode,nCodeSize);
 207
 208                     for (i=0; i<nClearCode; i++)
 209                         pTable[i].pFirstChild=NULL;
 210
 211                     nCodeSize=nDataSize+1;
 212                     nTableSize=nEOICode+1;
 213                 }
 214                 else
 215                 {
 216                     if(nTableSize==(sal_uInt16)(1<<nCodeSize))
 217                         nCodeSize++;
 218
 219                     p=pTable+(nTableSize++);
 220                     p->pBrother=pPrefix->pFirstChild;
 221                     pPrefix->pFirstChild=p;
 222                     p->nValue=nV;
 223                     p->pFirstChild=NULL;
 224                 }
 225
 226                 pPrefix=pTable+nV;
 227             }
 228         }
 229     }
 230 }
 231
 232 // ------------------------------------------------------------------------
 233
 234 void GIFLZWCompressor::EndCompression()
 235 {
 236     if( pIDOS )
 237     {
 238         if( pPrefix )
 239             pIDOS->WriteBits(pPrefix->nCode,nCodeSize);
 240
 241         pIDOS->WriteBits( nEOICode,nCodeSize );
 242         delete[] pTable;
 243         delete pIDOS;
 244         pIDOS=NULL;
 245     }
 246 }
 247
 248 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */