inflate.c

ADS下的bios工程

/*       NAME                 DATE            REMARKS                       */
/*                                                                          */
/*       yskim              20-06-2000    Created initial version 1.0       */
/*                                                                          */
/****************************************************************************/
static int inflate_fixed()
{
  int i;                /* temporary variable */
  struct huft *tl;      /* literal/length code table */
  struct huft *td;      /* distance code table */
  int bl;               /* lookup bits for tl */
  int bd;               /* lookup bits for td */
  unsigned l[288];      /* length list for huft_build */

DEBUG_ZIP("<fix ");

  /* set up literal table */
  for (i = 0; i < 144; i++)
    l[i] = 8;
  for (; i < 256; i++)
    l[i] = 9;
  for (; i < 280; i++)
    l[i] = 7;
  for (; i < 288; i++)          /* make a complete, but wrong code set */
    l[i] = 8;
  bl = 7;
  if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0)
    return i;


  /* set up distance table */
  for (i = 0; i < 30; i++)      /* make an incomplete code set */
    l[i] = 5;
  bd = 5;
  if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1)
  {
    huft_free(tl);

    DEBUG_ZIP("> ");
    return i;
  }


  /* decompress until an end-of-block code */
  if (inflate_codes(tl, td, bl, bd))
    return 1;


  /* free the decoding tables, return */
  huft_free(tl);
  huft_free(td);
  return 0;
}


/****************************************************************************/
/* FUNCTION                                                                 */
/*                                                                          */
/*    inflate_dynamic                                                       */
/*                                                                          */
/* DESCRIPTION                                                              */
/*               decompress an inflated type 2 (dynamic Huffman codes)      */
/*    block.                                                                */
/*                                                                          */
/* CALLED BY                                                                */
/*                                                                          */
/* CALLS                                                                    */
/*                                                                          */
/* INPUTS                                                                   */
/*                                                                          */
/* OUTPUTS                                                                  */
/*                                                                          */
/*    STATUS                                                                */
/*                                                                          */
/* HISTORY                                                                  */
/*                                                                          */
/*       NAME                 DATE            REMARKS                       */
/*                                                                          */
/*       yskim              20-06-2000    Created initial version 1.0       */
/*                                                                          */
/****************************************************************************/
static int inflate_dynamic(void)
{
  int i;                /* temporary variables */
  unsigned j;
  unsigned l;           /* last length */
  unsigned m;           /* mask for bit lengths table */
  unsigned n;           /* number of lengths to get */
  struct huft *tl;      /* literal/length code table */
  struct huft *td;      /* distance code table */
  int bl;               /* lookup bits for tl */
  int bd;               /* lookup bits for td */
  unsigned nb;          /* number of bit length codes */
  unsigned nl;          /* number of literal/length codes */
  unsigned nd;          /* number of distance codes */
#ifdef PKZIP_BUG_WORKAROUND
  unsigned ll[288+32];  /* literal/length and distance code lengths */
#else
  unsigned ll[286+30];  /* literal/length and distance code lengths */
#endif
  register u32 b;       /* bit buffer */
  register unsigned k;  /* number of bits in bit buffer */

DEBUG_ZIP("<dyn ");

  /* make local bit buffer */
  b = bb;
  k = bk;

  /* read in table lengths */
  NEEDBITS(5)
  nl = 257 + ((unsigned)b & 0x1f);      /* number of literal/length codes */
  DUMPBITS(5)
  NEEDBITS(5)
  nd = 1 + ((unsigned)b & 0x1f);        /* number of distance codes */
  DUMPBITS(5)
  NEEDBITS(4)
  nb = 4 + ((unsigned)b & 0xf);         /* number of bit length codes */
  DUMPBITS(4)
#ifdef PKZIP_BUG_WORKAROUND
  if (nl > 288 || nd > 32)
#else
  if (nl > 286 || nd > 30)
#endif
    return 1;                   /* bad lengths */

DEBUG_ZIP("dyn1 ");

  /* read in bit-length-code lengths */
  for (j = 0; j < nb; j++)
  {
    NEEDBITS(3)
    ll[border[j]] = (unsigned)b & 7;
    DUMPBITS(3)
  }
  for (; j < 19; j++)
    ll[border[j]] = 0;

DEBUG_ZIP("dyn2 ");

  /* build decoding table for trees--single level, 7 bit lookup */
  bl = 7;
  if ((i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl)) != 0)
  {
    if (i == 1) 
      huft_free(tl);

    return i;                   /* incomplete code set */
  }

DEBUG_ZIP("dyn3 ");

  /* read in literal and distance code lengths */
  n = nl + nd;
  m = mask_bits[bl];
  i = l = 0;
  while ((unsigned)i < n)
  {
    NEEDBITS((unsigned)bl)
    j = (td = tl + ((unsigned)b & m))->b;
    DUMPBITS(j)
    j = td->v.n;
    if (j < 16)                 /* length of code in bits (0..15) */
      ll[i++] = l = j;          /* save last length in l */
    else if (j == 16)           /* repeat last length 3 to 6 times */
    {
      NEEDBITS(2)
      j = 3 + ((unsigned)b & 3);
      DUMPBITS(2)
      if ((unsigned)i + j > n)
        return 1;
      while (j--)
        ll[i++] = l;
    }
    else if (j == 17)           /* 3 to 10 zero length codes */
    {
      NEEDBITS(3)
      j = 3 + ((unsigned)b & 7);
      DUMPBITS(3)
      if ((unsigned)i + j > n)
        return 1;
      while (j--)
        ll[i++] = 0;
      l = 0;
    }
    else                        /* j == 18: 11 to 138 zero length codes */
    {
      NEEDBITS(7)
      j = 11 + ((unsigned)b & 0x7f);
      DUMPBITS(7)
      if ((unsigned)i + j > n)
        return 1;
      while (j--)
        ll[i++] = 0;
      l = 0;
    }
  }

DEBUG_ZIP("dyn4 ");

  /* free decoding table for trees */
  huft_free(tl);

DEBUG_ZIP("dyn5 ");

  /* restore the global bit buffer */
  bb = b;
  bk = k;

DEBUG_ZIP("dyn5a ");

  /* build the decoding tables for literal/length and distance codes */
  bl = lbits;
DEBUG_ZIP("\nBuild decoding tables for literal,length tree\n");
  if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0)
  {
DEBUG_ZIP("dyn5b ");
    if (i == 1) {
      error(" incomplete literal tree\n");
      huft_free(tl);
    }
    return i;                   /* incomplete code set */
  }
DEBUG_ZIP("dyn5c ");
  bd = dbits;
DEBUG_ZIP("\nBuild decoding tables for distance tree\n");
  if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0)
  {
DEBUG_ZIP("dyn5d ");
    if (i == 1) {
      error(" incomplete distance tree\n");
#ifdef PKZIP_BUG_WORKAROUND
      i = 0;
    }
#else
      huft_free(td);
    }
    huft_free(tl);
    return i;                   /* incomplete code set */
#endif
  }

DEBUG_ZIP("dyn6 ");

  /* decompress until an end-of-block code */
  if (inflate_codes(tl, td, bl, bd))
    return 1;

DEBUG_ZIP("dyn7 ");

  /* free the decoding tables, return */
  huft_free(tl);
  huft_free(td);

  DEBUG_ZIP(">");
  return 0;
}


/****************************************************************************/
/* FUNCTION                                                                 */
/*                                                                          */
/*    inflate_block                                                         */
/*                                                                          */
/* DESCRIPTION                                                              */
/*               decompress an inflated block                               */
/*                                                                          */
/* CALLED BY                                                                */
/*                                                                          */
/* CALLS                                                                    */
/*                                                                          */
/* INPUTS                                                                   */
/*                                                                          */
/* OUTPUTS                                                                  */
/*                                                                          */
/*    STATUS                                                                */
/*                                                                          */
/* HISTORY                                                                  */
/*                                                                          */
/*       NAME                 DATE            REMARKS                       */
/*                                                                          */
/*       yskim              20-06-2000    Created initial version 1.0       */
/*                                                                          */
/****************************************************************************/
static int inflate_block(e)
int *e;                 /* last block flag */
{
	unsigned t;           /* block type */
	register u32 b;       /* bit buffer */
	register unsigned k;  /* number of bits in bit buffer */

DEBUG_ZIP("<blk ");

	/* make local bit buffer */
	b = bb;
	k = bk;


	/* read in last block bit */
	NEEDBITS(1)
	*e = (int)b & 1;
	DUMPBITS(1)


	/* read in block type */
	NEEDBITS(2)
	t = (unsigned)b & 3;
	DUMPBITS(2)
  
	/* restore the global bit buffer */
	bb = b;
	bk = k;

DEBUG_ZIP("block type(t) = %d\n",t);