Logo Search packages:      
Sourcecode: macutils version File versions  Download package

de_lzah.c

#include "macunpack.h"
#ifdef SIT
#define DELZAH
#endif /* SIT */
#ifdef LZH
#define DELZAH
#endif /* LZH */
#ifdef DELZAH
#include "globals.h"
#include "../util/masks.h"
#include "../fileio/wrfile.h"

/* Note: compare with LZSS decoding in lharc! */

#define N   314
#define T   (2*N-1)

/*    Huffman table used for first 6 bits of offset:
      #bits codes
      3     0x000
      4     0x040-0x080
      5     0x100-0x2c0
      6     0x300-0x5c0
      7     0x600-0xbc0
      8     0xc00-0xfc0
*/

static unsigned short HuffCode[] = {
    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
    0x040, 0x040, 0x040, 0x040, 0x040, 0x040, 0x040, 0x040,
    0x040, 0x040, 0x040, 0x040, 0x040, 0x040, 0x040, 0x040,
    0x080, 0x080, 0x080, 0x080, 0x080, 0x080, 0x080, 0x080,
    0x080, 0x080, 0x080, 0x080, 0x080, 0x080, 0x080, 0x080,
    0x0c0, 0x0c0, 0x0c0, 0x0c0, 0x0c0, 0x0c0, 0x0c0, 0x0c0,
    0x0c0, 0x0c0, 0x0c0, 0x0c0, 0x0c0, 0x0c0, 0x0c0, 0x0c0,
    0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100,
    0x140, 0x140, 0x140, 0x140, 0x140, 0x140, 0x140, 0x140,
    0x180, 0x180, 0x180, 0x180, 0x180, 0x180, 0x180, 0x180,
    0x1c0, 0x1c0, 0x1c0, 0x1c0, 0x1c0, 0x1c0, 0x1c0, 0x1c0,
    0x200, 0x200, 0x200, 0x200, 0x200, 0x200, 0x200, 0x200,
    0x240, 0x240, 0x240, 0x240, 0x240, 0x240, 0x240, 0x240,
    0x280, 0x280, 0x280, 0x280, 0x280, 0x280, 0x280, 0x280,
    0x2c0, 0x2c0, 0x2c0, 0x2c0, 0x2c0, 0x2c0, 0x2c0, 0x2c0,
    0x300, 0x300, 0x300, 0x300, 0x340, 0x340, 0x340, 0x340,
    0x380, 0x380, 0x380, 0x380, 0x3c0, 0x3c0, 0x3c0, 0x3c0,
    0x400, 0x400, 0x400, 0x400, 0x440, 0x440, 0x440, 0x440,
    0x480, 0x480, 0x480, 0x480, 0x4c0, 0x4c0, 0x4c0, 0x4c0,
    0x500, 0x500, 0x500, 0x500, 0x540, 0x540, 0x540, 0x540,
    0x580, 0x580, 0x580, 0x580, 0x5c0, 0x5c0, 0x5c0, 0x5c0,
    0x600, 0x600, 0x640, 0x640, 0x680, 0x680, 0x6c0, 0x6c0,
    0x700, 0x700, 0x740, 0x740, 0x780, 0x780, 0x7c0, 0x7c0,
    0x800, 0x800, 0x840, 0x840, 0x880, 0x880, 0x8c0, 0x8c0,
    0x900, 0x900, 0x940, 0x940, 0x980, 0x980, 0x9c0, 0x9c0,
    0xa00, 0xa00, 0xa40, 0xa40, 0xa80, 0xa80, 0xac0, 0xac0,
    0xb00, 0xb00, 0xb40, 0xb40, 0xb80, 0xb80, 0xbc0, 0xbc0,
    0xc00, 0xc40, 0xc80, 0xcc0, 0xd00, 0xd40, 0xd80, 0xdc0,
    0xe00, 0xe40, 0xe80, 0xec0, 0xf00, 0xf40, 0xf80, 0xfc0};

static short HuffLength[] = {
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8};

unsigned char (*lzah_getbyte)();

static void lzah_inithuf();
static void lzah_reorder();
static void lzah_move();
static void lzah_getbit();
static void lzah_outchar();

static char lzah_buf[4096];
static int lzah_bufptr;
static int lzah_bitsavail;
static int lzah_bits;
static int Frequ[1000];
static int ForwTree[1000];
static int BackTree[1000];

void de_lzah(obytes)
unsigned long obytes;
{
    int i, i1, j, ch, byte, offs, skip;

    lzah_inithuf();
    lzah_bitsavail = 0;
    for(i = 0; i < 4036; i++) {
      lzah_buf[i] = ' ';
    }
    lzah_bufptr = 4036;
    while(obytes != 0) {
      ch = ForwTree[T - 1];
      while(ch < T) {
          lzah_getbit();
          if(lzah_bits & 0x80) {
            ch = ch + 1;
          }
          ch = ForwTree[ch];
      }
      ch -= T;
      if(Frequ[T - 1] >= 0x8000) {
          lzah_reorder();
      }

      i = BackTree[ch + T];
      do {
          j = ++Frequ[i];
          i1 = i + 1;
          if(Frequ[i1] < j) {
            while(Frequ[++i1] < j) ;
            i1--;
            Frequ[i] = Frequ[i1];
            Frequ[i1] = j;

            j = ForwTree[i];
            BackTree[j] = i1;
            if(j < T) {
                BackTree[j + 1] = i1;
            }
            ForwTree[i] = ForwTree[i1];
            ForwTree[i1] = j;
            j = ForwTree[i];
            BackTree[j] = i;
            if(j < T) {
                BackTree[j + 1] = i;
            }
            i = i1;
          }
          i = BackTree[i];
      } while(i != 0);

      if(ch < 256) {
          lzah_outchar((char)ch);
          obytes--;
      } else {
          if(lzah_bitsavail != 0) {
            byte = (lzah_bits << 1) & BYTEMASK;
            lzah_bits = (*lzah_getbyte)() & BYTEMASK;
            byte |= (lzah_bits >> lzah_bitsavail);
            lzah_bits = lzah_bits << (7 - lzah_bitsavail);
          } else {
            byte = (*lzah_getbyte)() & BYTEMASK;
          }
          offs = HuffCode[byte];
          skip = HuffLength[byte] - 2;
          while(skip-- != 0) {
            byte = byte + byte;
            lzah_getbit();
            if(lzah_bits & 0x80) {
                byte++;
            }
          }
          offs |= (byte & 0x3f);
          offs = ((lzah_bufptr - offs - 1) & 0xfff);
          ch = ch - 253;
          while(ch-- > 0) {
            lzah_outchar(lzah_buf[offs++ & 0xfff]);
            obytes--;
            if(obytes == 0) {
                break;
            }
          }
      }
    }
}

static void lzah_inithuf()
{
    int i, j;

    for(i = 0; i < N; i++) {
      Frequ[i] = 1;
      ForwTree[i] = i + T;
      BackTree[i + T] = i;
    }
    for(i = 0, j = N; j < T; i += 2, j++) {
      Frequ[j] = Frequ[i] + Frequ[i + 1];
      ForwTree[j] = i;
      BackTree[i] = j;
      BackTree[i + 1] = j;
    }
    Frequ[T] = 0xffff;
    BackTree[T - 1] = 0;
}

static void lzah_reorder()
{
    int i, j, k, l;

    j = 0;
    for(i = 0; i < T; i++) {
      if(ForwTree[i] >= T) {
          Frequ[j] = ((Frequ[i] + 1) >> 1);
          ForwTree[j] = ForwTree[i];
          j++;
      }
    }
    for(i = 0, j = N; i < T; i += 2, j++) {
      k = i + 1;
      l = Frequ[i] + Frequ[k];
      Frequ[j] = l;
      k = j - 1;
      while(l < Frequ[k]) {
          k--;
      }
      k = k + 1;
      lzah_move(Frequ + k, Frequ + k + 1, j - k);
      Frequ[k] = l;
      lzah_move(ForwTree + k, ForwTree + k + 1, j - k);
      ForwTree[k] = i;
    }
    for(i = 0; i < T; i++) {
      k = ForwTree[i];
      if(k >= T) {
          BackTree[k] = i;
      } else {
          BackTree[k] = i;
          BackTree[k + 1] = i;
      }
    }
}

static void lzah_move(p, q, n)
int *p, *q, n;
{
    if(p > q) {
      while(n-- > 0) {
          *q++ = *p++;
      }
    } else {
      p += n;
      q += n;
      while(n-- > 0) {
          *--q = *--p;
      }
    }
}

static void lzah_getbit()
{
    if(lzah_bitsavail != 0) {
      lzah_bits = lzah_bits + lzah_bits;
      lzah_bitsavail--;
    } else {
      lzah_bits = (*lzah_getbyte)() & BYTEMASK;
      lzah_bitsavail = 7;
    }
}

static void lzah_outchar(ch)
char ch;
{
    *out_ptr++ = ch;
    lzah_buf[lzah_bufptr++] = ch;
    lzah_bufptr &= 0xfff;
}
#else /* DELZAH */
int delzah; /* keep lint and some compilers happy */
#endif /* DELZAH */


Generated by  Doxygen 1.6.0   Back to index