src/lzo2a_d.ch

   1 /* lzo2a_d.ch -- implementation of the LZO2A decompression algorithm
   2
   3    This file is part of the LZO real-time data compression library.
   4
   5    Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
   6    Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
   7    Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
   8    Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
   9    Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
  10    Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
  11    Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
  12    Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
  13    Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
  14    Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
  15    Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
  16    Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
  17    Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
  18    All Rights Reserved.
  19
  20    The LZO library is free software; you can redistribute it and/or
  21    modify it under the terms of the GNU General Public License as
  22    published by the Free Software Foundation; either version 2 of
  23    the License, or (at your option) any later version.
  24
  25    The LZO library is distributed in the hope that it will be useful,
  26    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28    GNU General Public License for more details.
  29
  30    You should have received a copy of the GNU General Public License
  31    along with the LZO library; see the file COPYING.
  32    If not, write to the Free Software Foundation, Inc.,
  33    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  34
  35    Markus F.X.J. Oberhumer
  36    <markus@oberhumer.com>
  37    http://www.oberhumer.com/opensource/lzo/
  38  */
  39
  40
  41 #include "lzo1_d.ch"
  42
  43
  44 /***********************************************************************
  45 // decompress a block of data.
  46 ************************************************************************/
  47
  48 #define _NEEDBYTE   NEED_IP(1)
  49 #define _NEXTBYTE   (*ip++)
  50
  51 LZO_PUBLIC(int)
  52 DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
  53                          lzo_bytep out, lzo_uintp out_len,
  54                          lzo_voidp wrkmem )
  55 {
  56     register lzo_bytep op;
  57     register const lzo_bytep ip;
  58     register const lzo_bytep m_pos;
  59
  60     lzo_uint t;
  61     const lzo_bytep const ip_end = in + in_len;
  62 #if defined(HAVE_ANY_OP)
  63     lzo_bytep const op_end = out + *out_len;
  64 #endif
  65
  66     lzo_uint32 b = 0;       /* bit buffer */
  67     unsigned k = 0;         /* bits in bit buffer */
  68
  69     LZO_UNUSED(wrkmem);
  70
  71     op = out;
  72     ip = in;
  73
  74     while (TEST_IP && TEST_OP)
  75     {
  76         NEEDBITS(1);
  77         if (MASKBITS(1) == 0)
  78         {
  79             DUMPBITS(1);
  80             /* a literal */
  81             NEED_IP(1); NEED_OP(1);
  82             *op++ = *ip++;
  83             continue;
  84         }
  85         DUMPBITS(1);
  86
  87         NEEDBITS(1);
  88         if (MASKBITS(1) == 0)
  89         {
  90             DUMPBITS(1);
  91             /* a M1 match */
  92             NEEDBITS(2);
  93             t = M1_MIN_LEN + (lzo_uint) MASKBITS(2);
  94             DUMPBITS(2);
  95             NEED_IP(1); NEED_OP(t);
  96             m_pos = op - 1 - *ip++;
  97             assert(m_pos >= out); assert(m_pos < op);
  98             TEST_LB(m_pos);
  99             MEMCPY_DS(op,m_pos,t);
 100             continue;
 101         }
 102         DUMPBITS(1);
 103
 104         NEED_IP(2);
 105         t = *ip++;
 106         m_pos = op;
 107         m_pos -= (t & 31) | (((lzo_uint) *ip++) << 5);
 108         t >>= 5;
 109         if (t == 0)
 110         {
 111 #if (N >= 8192)
 112             NEEDBITS(1);
 113             t = MASKBITS(1);
 114             DUMPBITS(1);
 115             if (t == 0)
 116                 t = 10 - 1;
 117             else
 118             {
 119                 /* a M3 match */
 120                 m_pos -= 8192;      /* t << 13 */
 121                 t = M3_MIN_LEN - 1;
 122             }
 123 #else
 124             t = 10 - 1;
 125 #endif
 126             NEED_IP(1);
 127             while (*ip == 0)
 128             {
 129                 t += 255;
 130                 ip++;
 131                 NEED_IP(1);
 132             }
 133             t += *ip++;
 134         }
 135         else
 136         {
 137 #if defined(LZO_EOF_CODE)
 138             if (m_pos == op)
 139                 goto eof_found;
 140 #endif
 141             t += 2;
 142         }
 143         assert(m_pos >= out); assert(m_pos < op);
 144         TEST_LB(m_pos);
 145         NEED_OP(t);
 146         MEMCPY_DS(op,m_pos,t);
 147     }
 148
 149
 150 #if defined(LZO_EOF_CODE)
 151 #if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
 152     /* no EOF code was found */
 153     *out_len = pd(op, out);
 154     return LZO_E_EOF_NOT_FOUND;
 155 #endif
 156
 157 eof_found:
 158     assert(t == 1);
 159 #endif
 160     *out_len = pd(op, out);
 161     return (ip == ip_end ? LZO_E_OK :
 162            (ip < ip_end  ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
 163
 164
 165 #if defined(HAVE_NEED_IP)
 166 input_overrun:
 167     *out_len = pd(op, out);
 168     return LZO_E_INPUT_OVERRUN;
 169 #endif
 170
 171 #if defined(HAVE_NEED_OP)
 172 output_overrun:
 173     *out_len = pd(op, out);
 174     return LZO_E_OUTPUT_OVERRUN;
 175 #endif
 176
 177 #if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
 178 lookbehind_overrun:
 179     *out_len = pd(op, out);
 180     return LZO_E_LOOKBEHIND_OVERRUN;
 181 #endif
 182 }
 183
 184
 185 /*
 186 vi:ts=4:et
 187 */
 188