lzw.cpp
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:10k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: lzw.cpp,v 1.2.24.1 2004/07/09 01:54:29 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. #include <hlxclib/memory.h>
  50. #include <string.h>
  51. #include "lzw.h"
  52. #include "hxheap.h"
  53. #ifdef _DEBUG
  54. #undef HX_THIS_FILE
  55. static char HX_THIS_FILE[] = __FILE__;
  56. #endif
  57. LZWCodec::LZWCodec()
  58. {
  59.     /* Initialize all member variables */
  60.     m_bFresh                   = TRUE;
  61.     m_bPostClearCode           = FALSE;
  62.     m_lCodeSize                = 0;
  63.     m_lSetCodeSize             = 0;
  64.     m_lMaxCode                 = 0;
  65.     m_lMaxCodeSize             = 0;
  66.     m_lFirstCode               = 0;
  67.     m_lOldCode                 = 0;
  68.     m_lClearCode               = 0;
  69.     m_lEndCode                 = 0;
  70.     m_pCurByte                 = NULL;
  71.     m_lCurBit                  = 0;
  72.     m_lBytesInBuffer           = -1;
  73.     m_bFinished                = FALSE;
  74.     m_bSuspended               = TRUE;
  75.     m_bAllCompressedDataCopied = FALSE;
  76.     m_pCompressedBuffer        = NULL;
  77.     m_lCompressedBufferSize    = 0;
  78.     m_lCompressedBytesCopied   = 0;
  79.     /* Clear the tables */
  80.     ClearTables();
  81.     /* Reset the stack */
  82.     m_plStackPtr = m_lStack;
  83. };
  84. LZWCodec::~LZWCodec()
  85. {
  86.     if (m_pCompressedBuffer)
  87.     {
  88.         delete [] m_pCompressedBuffer;
  89.         m_pCompressedBuffer = NULL;
  90.     }
  91. };
  92. HX_RESULT LZWCodec::SetCompressedBufferSize(INT32 lSize)
  93. {
  94.     /* Check for input error conditions */
  95.     if (lSize < 1)
  96.     {
  97.         return HXR_INVALID_PARAMETER;
  98.     }
  99.     /* Allocate space for the compressed buffer */
  100.     if (m_pCompressedBuffer)
  101.     {
  102.         delete [] m_pCompressedBuffer;
  103.         m_pCompressedBuffer = NULL;
  104.     }
  105.     m_pCompressedBuffer = new BYTE [lSize];
  106.     if (!m_pCompressedBuffer)
  107.     {
  108.         return HXR_OUTOFMEMORY;
  109.     }
  110.     /* Set the size */
  111.     m_lCompressedBufferSize  = lSize;
  112.     m_lCompressedBytesCopied = 0;
  113.     /* Initialize the state variables */
  114.     m_pCurByte                 = m_pCompressedBuffer;
  115.     m_lBytesInBuffer           = -1;
  116.     m_bAllCompressedDataCopied = FALSE;
  117.     m_bSuspended               = TRUE;
  118.     return HXR_OK;
  119. }
  120. HX_RESULT LZWCodec::InitDecompress(INT32 lMinCodeBits)
  121. {
  122.     /* Check for input error conditions */
  123.     if (lMinCodeBits < 1 || lMinCodeBits >  kMaxLZWBits)
  124.     {
  125.         return HXR_INVALID_PARAMETER;
  126.     }
  127.     /* Set up code size parameters */
  128.     m_lSetCodeSize = lMinCodeBits;
  129.     m_lCodeSize    = m_lSetCodeSize + 1;
  130.     m_lClearCode   = 1 << m_lSetCodeSize;
  131.     m_lEndCode     = m_lClearCode + 1;
  132.     m_lMaxCodeSize = m_lClearCode << 1;
  133.     m_lMaxCode     = m_lClearCode + 2;
  134.     /* This says to look for clear codes */
  135.     m_bFresh = TRUE;
  136.     /* Clear out all table entries */
  137.     ClearTables();
  138.     /* Reset the stack pointer */
  139.     m_plStackPtr = m_lStack;
  140.     return HXR_OK;
  141. }
  142. HX_RESULT LZWCodec::AppendCompressedBuffer(BYTE *pBuffer, INT32 lBufLen)
  143. {
  144.     /* Check for input error conditions */
  145.     if (pBuffer == NULL || lBufLen < 1)
  146.     {
  147.         return HXR_INVALID_PARAMETER;
  148.     }
  149.     /* Make sure we're not called after we should be */
  150.     if (m_bAllCompressedDataCopied == TRUE)
  151.     {
  152.         return HXR_OK;
  153.     }
  154.     /* Make sure we don't copy off the end of the buffer */
  155.     INT32 lBytesToCopy;
  156.     if (m_lCompressedBytesCopied + lBufLen <= m_lCompressedBufferSize)
  157.     {
  158.         lBytesToCopy = lBufLen;
  159.     }
  160.     else
  161.     {
  162.         lBytesToCopy = m_lCompressedBufferSize - m_lCompressedBytesCopied;
  163.     }
  164.     /* Do the copy */
  165.     memcpy(&m_pCompressedBuffer[m_lCompressedBytesCopied], pBuffer, lBytesToCopy); /* Flawfinder: ignore */
  166.     /* Update the member variables */
  167.     m_lCompressedBytesCopied += lBufLen;
  168.     m_lBytesInBuffer         += lBufLen;
  169.     m_bSuspended              = FALSE;
  170.     /* Check if we've received all data */
  171.     if (m_lCompressedBytesCopied >= m_lCompressedBufferSize)
  172.     {
  173.         m_bAllCompressedDataCopied = TRUE;
  174.     }
  175.     return HXR_OK;
  176. }
  177. HX_RESULT LZWCodec::LZWReadByte(INT32 &rlSymbol)
  178. {
  179.     /* Are we still suspended? */
  180.     if (m_bSuspended == TRUE)
  181.     {
  182.         rlSymbol = -1;
  183.         return HXR_OK;
  184.     }
  185.     INT32 lCode;
  186.     /* If this flag is set, it means skip all clear codes at the current point */
  187.     if (m_bFresh == TRUE)
  188.     {
  189.         do
  190.         {
  191.             lCode = GetCode();
  192.             if (lCode < 0)
  193.             {
  194.                 rlSymbol     = -1;
  195.                 m_bSuspended = TRUE;
  196.                 return HXR_OK;
  197.             }
  198.             m_lFirstCode = m_lOldCode = lCode;
  199.         }
  200.         while (m_lFirstCode == m_lClearCode);
  201.         m_bFresh = FALSE;
  202.         rlSymbol = m_lFirstCode;
  203.         return HXR_OK;
  204.     }
  205.     /* If we're currently copying off the stack, then return the stack values */
  206.     if (m_plStackPtr > m_lStack)
  207.     {
  208.         rlSymbol = *--m_plStackPtr;
  209.         return HXR_OK;
  210.     }
  211.     /* Read values until we're done or we suspend */
  212.     while (1)
  213.     {
  214.         /* Get a code */
  215.         lCode = GetCode();
  216.         if (lCode < 0)
  217.         {
  218.             rlSymbol     = -1;
  219.             m_bSuspended = TRUE;
  220.             return HXR_OK;
  221.         }
  222.         /* Is this a code just after a clear code? */
  223.         if (m_bPostClearCode == TRUE)
  224.         {
  225.             m_bPostClearCode = FALSE;
  226.             m_lFirstCode     = m_lOldCode = rlSymbol = lCode;
  227.             return HXR_OK;
  228.         }
  229.         /* We got a valid code, so now take action based on that code */
  230.         if (lCode == m_lClearCode)
  231.         {
  232.             /* We got a clear code, so we clear the tables and reset everything */
  233.             ClearTables();
  234.             m_lCodeSize    = m_lSetCodeSize + 1;
  235.             m_lMaxCodeSize = m_lClearCode << 1;
  236.             m_lMaxCode     = m_lClearCode + 2;
  237.             m_plStackPtr   = m_lStack;
  238.             /* Set the flag which says we just got a clear code */
  239.             m_bPostClearCode = TRUE;
  240.         }
  241.         else if (lCode == m_lEndCode)
  242.         {
  243.             rlSymbol     = lCode;
  244.             m_bFinished  = TRUE;
  245.             m_bSuspended = FALSE;
  246.             return HXR_OK;
  247.         }
  248.         else
  249.         {
  250.             INT32 lInCode = lCode;
  251.             if (lCode >= m_lMaxCode)
  252.             {
  253.                 *m_plStackPtr++ = m_lFirstCode;
  254.                 lCode           = m_lOldCode;
  255.             }
  256.             INT32* pStackLimit = &m_lStack[0] + (kMaxLZWVal << 1);
  257.             while (lCode >= m_lClearCode)
  258.             {
  259.                 if (m_plStackPtr >= pStackLimit)
  260.                 {
  261.                     // We've blown our code stack, so we have a corrupt
  262.                     // GIF image. In this case, we need to error out.
  263.                     return HXR_FAIL;
  264.                 }
  265.                 *m_plStackPtr++ = m_lTable[1][lCode];
  266.                 if (lCode == m_lTable[0][lCode])
  267.                 {
  268.                     /* Tables have a circular reference in them - corrupt file */
  269.                     return HXR_FAILED;
  270.                 }
  271.                 lCode = m_lTable[0][lCode];
  272.             }
  273.             *m_plStackPtr++ = m_lFirstCode = m_lTable[1][lCode];
  274.             lCode = m_lMaxCode;
  275.             if (lCode < kMaxLZWVal)
  276.             {
  277.                 m_lTable[0][lCode] = m_lOldCode;
  278.                 m_lTable[1][lCode] = m_lFirstCode;
  279.                 m_lMaxCode++;
  280.                 if (m_lMaxCode     >= m_lMaxCodeSize &&
  281.                     m_lMaxCodeSize <  kMaxLZWVal)
  282.                 {
  283.                     m_lMaxCodeSize <<= 1;
  284.                     m_lCodeSize++;
  285.                 }
  286.             }
  287.             m_lOldCode = lInCode;
  288.             if (m_plStackPtr > m_lStack)
  289.             {
  290.                 rlSymbol = *--m_plStackPtr;
  291.                 return HXR_OK;
  292.             }
  293.         }
  294.     }
  295.     rlSymbol = 0;
  296.     return HXR_OK;
  297. }