Initial checkin for typhoon chess engine.

1 files changed, 1038 insertions, 0 deletions

diff --git a/src/tbdecode.h b/src/tbdecode.h
new file mode 100644
index 0000000..22bd5a0
--- /dev/null
+++ b/src/tbdecode.h
@@ -0,0 +1,1038 @@
+#ifndef TBDECODE
+#define	TBDECODE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#ifndef CLOCKS_PER_SEC
+#define CLOCKS_PER_SEC CLK_TCK
+#endif
+
+/* ---------------------------- Error codes --------------------------- */
+/*                              -----------                             */
+
+#define COMP_ERR_NONE     0     /* everything is OK                     */
+#define COMP_ERR_READ     2     /* input file read error                */
+#define COMP_ERR_NOMEM    5     /* no enough memory                     */
+#define COMP_ERR_BROKEN   6     /* damaged compressed data              */
+#define COMP_ERR_PARAM    7     /* incorrect function parameter         */
+#define COMP_ERR_INTERNAL 9     /* everything else is internal error    */
+                                /* hopefully it should never happen     */
+
+/* Almost all  functions listed further return one as  its result on of */
+/* codes given  above: if no  error occured then COMP_ERR_NONE (i.e. 0) */
+/* is returned, otherwise functions return  error  code  plus number of */
+/* line in "comp.c"  where the error  was detected multiplied  by  256; */
+/* line number may  be  used for exact specification  of  a place where */
+/* error was detected thus making debugging slightly simpler.           */
+/*                                                                      */
+/* Thus, "(code &  0xff)"  gives proper error code,  and  "(code >> 8)" */
+/* gives number of line where the error was raised.                     */
+
+/* -------------------------------------------------------------------- */
+/*                                                                      */
+/*                Compress/decompress some chess tables                 */
+/*                                                                      */
+/*               Copyright (c) 1991--1998 Andrew Kadatch                */
+/*                                                                      */
+/* The Limited-Reference  variant  of  Lempel-Ziv algorithm implemented */
+/* here was first described in  my  B.Sc.  thesis "Efficient algorithms */
+/* for image  compression",  Novosibirsk  State  University,  1992, and */
+/* cannot be  used in any product distributed in  Russia or CIS without */
+/* written permission from the author.                                  */
+/*                                                                      */
+/* Most of the code listed below is significantly  simplified code from  */
+/* the PRS data compression library and therefore it should not be used */
+/* in any product (software or hardware, commercial or not, and  so on) */
+/* without written permission from the author.                          */
+/*                                                                      */
+/* -------------------------------------------------------------------- */
+
+/* ---------------------------- Debugging ----------------------------- */
+/*                              ---------                               */
+
+#ifndef DEBUG
+#define DEBUG	0
+#endif
+
+#if DEBUG
+#define assert(cond) ((cond) ? (void) 0 : _local_assert (__LINE__))
+static void _local_assert(int lineno)
+{
+  fprintf(stderr, "assertion at line %u failed\n", lineno);
+  exit(33);
+}
+
+#define debug(x) x
+#define dprintf(x) printf x
+#else
+#if !defined (assert)
+#define assert(cond) ((void) 0)
+#endif
+#define debug(x)     ((void) 0)
+#define dprintf(x)   ((void) 0)
+#endif
+
+/* mob_pach */
+#ifndef  __cplusplus
+int       cbEGTBCompBytes = 0;
+#else
+extern    "C" {
+  int       cbEGTBCompBytes = 0;
+}
+#endif
+/* --------------------- Constants, types, etc. ----------------------- */
+/*                       ----------------------                         */
+#define MIN_BLOCK_BITS	8       /* LOG2 (min size of block to compress) */
+#define MAX_BLOCK_BITS	16      /* LOG2 (max size of block to compress) */
+                        /* max. integer we can take LOG2 by table       */
+#define MAX_BITS_HALF	((MAX_BLOCK_BITS + 1) >> 1)
+#define MAX_BITS	(MAX_BITS_HALF * 2)
+/* assume that integer is at least 32 bits wide */
+#ifndef uint
+#define uint unsigned
+#endif
+#ifndef uchar
+#define uchar unsigned char
+#endif
+#define HEADER_SIZE		80      /* number of reserved bytes     */
+#define STOP_SEARCH_LENGTH	256     /* terminate search if match    */
+                                        /* length exceeds that value    */
+#define MAX_LENGTH_BITS		5
+#define MAX_LENGTH              (1 << MAX_LENGTH_BITS)
+#define LONG_BITS               1
+#define LONG_LENGTH		(MAX_BLOCK_BITS - LONG_BITS)
+#define LONG_QUICK		(MAX_LENGTH - LONG_LENGTH)
+#if LONG_LENGTH > (MAX_BLOCK_BITS - LONG_BITS)
+#  undef LONG_LENGTH
+#  define LONG_LENGTH		(MAX_BLOCK_BITS - LONG_BITS)
+#endif
+#if LONG_LENGTH >= MAX_LENGTH || LONG_LENGTH <= 0
+#error LONG_LENGTH is out of range
+#endif
+#if LONG_BITS <= 0
+#error LONG_BITS must be positive
+#endif
+#define DELTA	(LONG_BITS + LONG_QUICK - 1)
+#if (MAX_LENGTH - 1) - (LONG_LENGTH - LONG_BITS) != DELTA
+#error Hmmm
+#endif
+#define MAX_DISTANCES		24
+#define LOG_MAX_DISTANCES	6       /* see check below      */
+#if MAX_DISTANCES > (1 << LOG_MAX_DISTANCES)
+#error MAX_DISTANCES should not exceed (1 << LOG_MAX_DISTANCES)
+#endif
+#define ALPHABET_SIZE		(256 + (MAX_DISTANCES << MAX_LENGTH_BITS))
+#define MAX_ALPHABET	ALPHABET_SIZE   /* max. alphabet handled by     */
+                                        /* Huffman coding routines      */
+#define USE_CRC32		1
+/* 0 - use Fletcher's checksum, != 0 - use proper CRC32                 */
+    static uchar header_title[64] =
+    "Compressed by DATACOMP v 1.0 (c) 1991--1998 Andrew Kadatch\r\n\0";
+
+#define RET(n) ((n) + __LINE__ * 256)
+
+/* ------------------------- CRC32 routines --------------------------- */
+/*                           --------------                             */
+
+#if USE_CRC32
+
+static unsigned CRC32_table[256];
+static int CRC32_initialized = 0;
+
+static void CRC32_init(void)
+{
+  int       i, j;
+  unsigned  k, m = (unsigned) 0xedb88320L;
+
+  if (CRC32_initialized)
+    return;
+  for (i = 0; i < 256; ++i) {
+    k = i;
+    j = 8;
+    do {
+      if ((k & 1) != 0)
+        k >>= 1;
+      else {
+        k >>= 1;
+        k ^= m;
+      };
+    }
+    while (--j);
+    CRC32_table[i] = k;
+  }
+  CRC32_initialized = 1;
+}
+
+static unsigned CRC32(uchar * p, int n, unsigned k)
+{
+  unsigned *table = CRC32_table;
+  uchar    *e = p + n;
+
+  while (p + 16 < e) {
+#   define X(i) k = table[((uchar) k) ^ p[i]] ^ (k >> 8)
+    X(0);
+    X(1);
+    X(2);
+    X(3);
+    X(4);
+    X(5);
+    X(6);
+    X(7);
+    X(8);
+    X(9);
+    X(10);
+    X(11);
+    X(12);
+    X(13);
+    X(14);
+    X(15);
+#   undef X
+    p += 16;
+  }
+  while (p < e)
+    k = table[((uchar) k) ^ *p++] ^ (k >> 8);
+  return (k);
+}
+
+#else
+
+#define CRC32_init()
+
+static unsigned CRC32(uchar * p, int n, unsigned k1)
+{
+  unsigned  k0 = k1 & 0xffff;
+  uchar    *e = p + n;
+
+  k1 = (k1 >> 16) & 0xffff;
+  while (p + 16 < e) {
+#   define X(i) k0 += p[i]; k1 += k0;
+    X(0);
+    X(1);
+    X(2);
+    X(3);
+    X(4);
+    X(5);
+    X(6);
+    X(7);
+    X(8);
+    X(9);
+    X(10);
+    X(11);
+    X(12);
+    X(13);
+    X(14);
+    X(15);
+#   undef X
+    k0 = (k0 & 0xffff) + (k0 >> 16);
+    k1 = (k1 & 0xffff) + (k1 >> 16);
+    p += 16;
+  }
+  while (p < e) {
+    k0 += *p++;
+    k1 += k0;
+  }
+  k0 = (k0 & 0xffff) + (k0 >> 16);
+  k1 = (k1 & 0xffff) + (k1 >> 16);
+  k0 = (k0 & 0xffff) + (k0 >> 16);
+  k1 = (k1 & 0xffff) + (k1 >> 16);
+  assert(((k0 | k1) >> 16) == 0);
+  return (k0 + (k1 << 16));
+}
+
+#endif                          /* USE_CRC32    */
+
+/* ------------------------ Bit IO interface -------------------------- */
+/*                          ----------------                            */
+
+#define BITIO_LOCALS	\
+  uint   _mask;         \
+  int    _bits;         \
+  uchar *_ptr
+
+typedef struct {
+  BITIO_LOCALS;
+} bitio_t;
+
+#define BITIO_ENTER(p) do {     \
+  _mask = (p)._mask;            \
+  _bits = (p)._bits;            \
+  _ptr  = (p)._ptr;             \
+} while (0)
+
+#define BITIO_LEAVE(p) do {     \
+  (p)._mask = _mask;            \
+  (p)._bits = _bits;            \
+  (p)._ptr  = _ptr;             \
+} while (0)
+
+#define BIORD_START(from) do {		\
+  _ptr = (uchar *) (from);              \
+  _bits = sizeof (_mask);               \
+  _mask = 0;                            \
+  do                                    \
+    _mask = (_mask << 8) | *_ptr++;     \
+  while (--_bits != 0);                 \
+  _bits = 16;                           \
+} while (0)
+
+/* read [1, 17] bits at once */
+#define BIORD(bits)      \
+  (_mask >> (8 * sizeof (_mask) - (bits)))
+
+#define BIORD_MORE(bits) do {		\
+  _mask <<= (bits);			\
+  if ((_bits -= (bits)) <= 0)           \
+  {                                     \
+    _mask |= ((_ptr[0] << 8) + _ptr[1]) << (-_bits);	\
+    _ptr += 2; _bits += 16;		\
+  }					\
+} while (0)
+
+/* ------------------------ Huffman coding ---------------------------- */
+/*                          --------------                              */
+
+#if MAX_ALPHABET <= 0xffff
+#  if MAX_ALPHABET <= 1024
+/* positive value takes 15 bits => symbol number occupies <= 10 bits    */
+#    define huffman_decode_t	short
+#  else
+#    define huffman_decode_t	int
+#  endif
+#else
+#  define huffman_decode_t	int
+#endif
+
+#define HUFFMAN_DECODE(ch,table,start_bits) do {	\
+  (ch) = table[BIORD (start_bits)];                     \
+  if (((int) (ch)) >= 0)                                \
+  {                                                     \
+    BIORD_MORE ((ch) & 31);                             \
+    (ch) >>= 5;                                         \
+    break;                                              \
+  }                                                     \
+  BIORD_MORE (start_bits);                              \
+  do                                                    \
+  {                                                     \
+    (ch) = table[BIORD (1) - (ch)];                     \
+    BIORD_MORE (1);                                     \
+  }                                                     \
+  while (((int) (ch)) < 0);                             \
+} while (0)
+
+#define HUFFMAN_TABLE_SIZE(n,start_bits) \
+  ((1 << (start_bits)) + ((n) << 1))
+
+static int huffman_decode_create(huffman_decode_t * table, uchar * length,
+                                 int n, int start_bits)
+{
+  int       i, j, k, last, freq[32], sum[32];
+
+ /* calculate number of codewords                                      */
+  memset(freq, 0, sizeof(freq));
+  for (i = 0; i < n; ++i) {
+    if ((k = length[i]) > 31)
+      return RET(COMP_ERR_BROKEN);
+    ++freq[k];
+  }
+
+ /* handle special case(s) -- 0 and 1 symbols in alphabet              */
+  if (freq[0] == n) {
+    memset(table, 0, sizeof(table[0]) << start_bits);
+    return (0);
+  }
+  if (freq[0] == n - 1) {
+    if (freq[1] != 1)
+      return RET(COMP_ERR_BROKEN);
+    for (i = 0; length[i] == 0;)
+      ++i;
+    i <<= 5;
+    for (k = 1 << start_bits; --k >= 0;)
+      *table++ = (huffman_decode_t) i;
+    return (0);
+  }
+
+ /* save frequences                    */
+  memcpy(sum, freq, sizeof(sum));
+
+ /* check code correctness             */
+  k = 0;
+  for (i = 32; --i != 0;) {
+    if ((k += freq[i]) & 1)
+      return RET(COMP_ERR_BROKEN);
+    k >>= 1;
+  }
+  if (k != 1)
+    return RET(COMP_ERR_BROKEN);
+
+ /* sort symbols               */
+  k = 0;
+  for (i = 1; i < 32; ++i)
+    freq[i] = (k += freq[i]);
+  last = freq[31];      /* preserve number of symbols in alphabet       */
+  for (i = n; --i >= 0;) {
+    if ((k = length[i]) != 0)
+      table[--freq[k]] = (huffman_decode_t) i;
+  }
+
+ /* now create decoding table  */
+  k = i = (1 << start_bits) + (n << 1);
+  for (n = 32; --n > start_bits;) {
+    j = i;
+    while (k > j)
+      table[--i] = (huffman_decode_t) - (k -= 2);
+    for (k = sum[n]; --k >= 0;)
+      table[--i] = table[--last];
+    k = j;
+  }
+
+  j = i;
+  i = 1 << start_bits;
+  while (k > j)
+    table[--i] = (huffman_decode_t) - (k -= 2);
+
+  for (; n > 0; --n) {
+    for (k = sum[n]; --k >= 0;) {
+      assert(last <= i && last > 0);
+      j = i - (1 << (start_bits - n));
+      n |= table[--last] << 5;
+      do
+        table[--i] = (huffman_decode_t) n;
+      while (i != j);
+      n &= 31;
+    }
+  }
+  assert((i | last) == 0);
+
+  return (0);
+}
+
+/* -------------------- Read/write Huffman code ----------------------- */
+/*                      -----------------------                         */
+
+#define MIN_REPT	2
+
+#if MIN_REPT <= 1
+#error MIN_REPT must exceed 1
+#endif
+
+#define TEMP_TABLE_BITS 8
+
+static int huffman_read_length(bitio_t * bitio, uchar * length, int n)
+{
+  BITIO_LOCALS;
+  huffman_decode_t table[2][HUFFMAN_TABLE_SIZE(64, TEMP_TABLE_BITS)];
+  uchar     bits[128];
+  int       i, j, k;
+
+  BITIO_ENTER(*bitio);
+  k = BIORD(1);
+  BIORD_MORE(1);
+  if (k != 0) {
+    memset(length, 0, n);
+    goto ret;
+  }
+
+  if (n <= 128) {
+    k = BIORD(5);
+    BIORD_MORE(5);
+    for (i = 0; i < n;) {
+      length[i] = (uchar) BIORD(k);
+      BIORD_MORE(k);
+      if (length[i++] == 0) {
+        j = i + BIORD(4);
+        BIORD_MORE(4);
+        if (j > n)
+          return RET(COMP_ERR_BROKEN);
+        while (i != j)
+          length[i++] = 0;
+      }
+    }
+    goto ret;
+  }
+
+  BITIO_LEAVE(*bitio);
+  i = huffman_read_length(bitio, bits, 128);
+  if (i != 0)
+    return (i);
+  i = huffman_decode_create(table[0], bits, 64, TEMP_TABLE_BITS);
+  if (i != 0)
+    return (i);
+  i = huffman_decode_create(table[1], bits + 64, 64, TEMP_TABLE_BITS);
+  if (i != 0)
+    return (i);
+  BITIO_ENTER(*bitio);
+
+  for (i = 0; i < n;) {
+    HUFFMAN_DECODE(k, table[0], TEMP_TABLE_BITS);
+    if (k <= 31) {
+      length[i++] = (uchar) k;
+      continue;
+    }
+    k &= 31;
+    HUFFMAN_DECODE(j, table[1], TEMP_TABLE_BITS);
+    if (j > 31) {
+      int       jj = j - 32;
+
+      j = 1 << jj;
+      if (jj != 0) {
+        if (jj > 16) {
+          j += BIORD(16) << (jj - 16);
+          BIORD_MORE(16);
+        }
+        j += BIORD(jj);
+        BIORD_MORE(jj);
+      }
+      j += 31;
+    }
+    j += MIN_REPT + i;
+    if (j > n)
+      return RET(COMP_ERR_BROKEN);
+    do
+      length[i] = (uchar) k;
+    while (++i != j);
+  }
+
+ret:
+  BITIO_LEAVE(*bitio);
+  return (0);
+}
+
+/* ----------------------- Proper compression ------------------------- */
+/*                         ------------------                           */
+
+#if MIN_BLOCK_BITS > MAX_BLOCK_BITS || MAX_BLOCK_BITS > MAX_BITS_HALF*2
+#error condition MIN_BLOCK_BITS <= MAX_BLOCK_BITS <= MAX_BITS_HALF*2 failed
+#endif
+
+#define DECODE_MAGIC    ((int) 0x5abc947fL)
+#define BLOCK_MAGIC     ((int) 0x79a3f29dL)
+
+#define START_BITS      13
+
+#define SHORT_INDEX     8u
+
+typedef struct {
+  huffman_decode_t table[HUFFMAN_TABLE_SIZE(ALPHABET_SIZE, START_BITS)];
+  int       distance[MAX_DISTANCES];
+  unsigned *crc, *blk_u;
+  unsigned short *blk_s;
+  int       block_size_log,     /* block_size is integral power of 2    */
+            block_size,         /* 1 << block_size_log                  */
+            last_block_size,    /* [original] size of last block        */
+            n_blk,              /* total number of blocks               */
+            comp_block_size,    /* size of largest compressed block+32  */
+            check_crc;          /* check CRC32?                         */
+  uchar    *comp;
+  int       magic;
+} decode_info;
+
+typedef struct {
+  unsigned char *ptr;           /* pointer to the first decoded byte */
+  int       decoded;            /* number of bytes decoded so far    */
+  int       total;              /* total number of bytes in block    */
+  int       number;             /* number of this block              */
+} COMP_BLOCK_T;
+
+/* Pointer to compressed data block                                     */
+
+typedef struct {
+  COMP_BLOCK_T b;
+  struct {
+    uchar    *first;
+    int       size;
+  } orig   , comp;
+  struct {
+    uchar    *ptr, *src;
+    int       rept;
+  } emit;
+  bitio_t   bitio;
+  int       n;
+  int       magic;
+} decode_block;
+
+static int calculate_offset(decode_info * info, unsigned n)
+{
+  unsigned  i;
+
+  i = n / (2 * SHORT_INDEX);
+  if (n & SHORT_INDEX)
+    return info->blk_u[i + 1] - info->blk_s[n];
+  else
+    return info->blk_u[i] + info->blk_s[n];
+}
+
+static void do_decode(decode_info * info, decode_block * block, uchar * e)
+{
+  BITIO_LOCALS;
+  uchar    *p, *s = 0;
+  int       ch;
+
+  if ((p = block->emit.ptr) >= e)
+    return;
+  if (p == block->orig.first) {
+    BIORD_START(block->comp.first);
+    block->emit.rept = 0;
+  } else {
+    BITIO_ENTER(block->bitio);
+    if ((ch = block->emit.rept) != 0) {
+      block->emit.rept = 0;
+      s = block->emit.src;
+      goto copy;
+    }
+  }
+#define OVER if (p < e) goto over; break
+  do {
+  over:
+    HUFFMAN_DECODE(ch, info->table, START_BITS);
+    if ((ch -= 256) < 0) {
+      *p++ = (uchar) ch;
+      OVER;
+    }
+
+    s = p + info->distance[ch >> MAX_LENGTH_BITS];
+
+    ch &= MAX_LENGTH - 1;
+    if (ch <= 3) {
+      p[0] = s[0];
+      p[1] = s[1];
+      p[2] = s[2];
+      p[3] = s[3];
+      p += ch + 1;
+      OVER;
+    } else if (ch >= LONG_LENGTH) {
+      ch -= LONG_LENGTH - LONG_BITS;
+#if (MAX_BLOCK_BITS - 1) + (LONG_LENGTH - LONG_BITS) >= MAX_LENGTH
+      if (ch == DELTA) {
+        ch = BIORD(5);
+        BIORD_MORE(5);
+        ch += DELTA;
+      }
+#endif
+      {
+        int       n = 1 << ch;
+
+        if (ch > 16) {
+          n += BIORD(16) << (ch -= 16);
+          BIORD_MORE(16);
+        }
+        n += BIORD(ch);
+        BIORD_MORE(ch);
+        ch = n;
+      }
+      ch += LONG_LENGTH - (1 << LONG_BITS);
+    }
+    ++ch;
+  copy:
+    if (ch > 16) {
+      if (p + ch > e) {
+        block->emit.rept = ch - (int) (e - p);
+        ch = (int) (e - p);
+        goto copy;
+      }
+      do {
+#       define X(i) p[i] = s[i]
+        X(0);
+        X(1);
+        X(2);
+        X(3);
+        X(4);
+        X(5);
+        X(6);
+        X(7);
+        X(8);
+        X(9);
+        X(10);
+        X(11);
+        X(12);
+        X(13);
+        X(14);
+        X(15);
+#       undef X
+        p += 16;
+        s += 16;
+      }
+      while ((ch -= 16) > 16);
+    }
+    p += ch;
+    s += ch;
+    switch (ch) {
+#     define X(i) case i: p[-i] = s[-i]
+      X(16);
+      X(15);
+      X(14);
+      X(13);
+      X(12);
+      X(11);
+      X(10);
+      X(9);
+      X(8);
+      X(7);
+      X(6);
+      X(5);
+      X(4);
+      X(3);
+      X(2);
+#     undef X
+    }
+    p[-1] = s[-1];
+  }
+  while (p < e);
+#undef OVER
+  block->emit.ptr = p;
+  block->emit.src = s;
+  BITIO_LEAVE(block->bitio);
+}
+
+/* pretty ugly */
+static int comp_open_file(decode_info ** res, FILE * fd, int check_crc)
+{
+  BITIO_LOCALS;
+  bitio_t   Bitio;
+  uchar     temp[ALPHABET_SIZE >= HEADER_SIZE ? ALPHABET_SIZE : HEADER_SIZE];
+  uchar    *ptr;
+  int       header_size, block_size, block_size_log, n_blk, i, n, n_s, n_u;
+  unsigned *blk_u, *blk;
+  unsigned short *blk_s;
+  decode_info *info;
+
+  if (res == 0)
+    return RET(COMP_ERR_PARAM);
+
+  CRC32_init();
+
+  *res = 0;
+
+  if (fread(temp, 1, HEADER_SIZE, fd) != HEADER_SIZE)
+    return RET(COMP_ERR_READ);
+
+  if (memcmp(temp, header_title, 64) != 0)
+    return RET(COMP_ERR_READ);
+
+  ptr = temp;
+#define R4(i) \
+  ((ptr[i] << 24) + (ptr[(i) + 1] << 16) + (ptr[(i) + 2] << 8) + (ptr[(i) + 3]))
+
+  header_size = R4(64);
+  block_size_log = ptr[70];
+  if (block_size_log > MAX_BITS || header_size < 84)
+    return RET(COMP_ERR_BROKEN);
+  block_size = 1 << block_size_log;
+  if (ptr[71] != MAX_DISTANCES)
+    return RET(COMP_ERR_BROKEN);
+  n_blk = R4(72);
+  if (R4(76) !=
+      (ALPHABET_SIZE << 12) + (LONG_BITS << 8) + (LONG_LENGTH << 4) +
+      MAX_LENGTH_BITS)
+    return RET(COMP_ERR_BROKEN);
+
+  if ((ptr = (uchar *) malloc(header_size)) == 0)
+    return RET(COMP_ERR_NOMEM);
+
+  if (fread(ptr + HEADER_SIZE, 1, header_size - HEADER_SIZE, fd) !=
+      (size_t) (header_size - HEADER_SIZE)) {
+    free(ptr);
+    return RET(COMP_ERR_NOMEM);
+  }
+  memcpy(ptr, temp, HEADER_SIZE);
+  header_size -= 4;
+  if (CRC32(ptr, header_size, 0) != (unsigned) R4(header_size)) {
+    free(ptr);
+    return RET(COMP_ERR_BROKEN);
+  }
+  header_size += 4;
+
+ /*
+    blk = (unsigned *) malloc (sizeof (unsigned) * (1 + n_blk));
+  */
+  n = sizeof(unsigned) * (1 + n_blk);
+  if (n < 4 * 1024 * 1024)
+    n = 4 * 1024 * 1024;
+  blk = (unsigned *) malloc(n);
+
+  if (blk == 0) {
+    free(ptr);
+    return RET(COMP_ERR_NOMEM);
+  }
+  n = sizeof(info->crc[0]) * (1 + (check_crc ? (2 * n_blk) : 0));
+  n_u = sizeof(unsigned) * (2 + n_blk / (2 * SHORT_INDEX));
+  n_s = sizeof(unsigned short) * (1 + n_blk);
+  if ((info = (decode_info *) malloc(sizeof(*info) + n + n_u + n_s)) == 0) {
+    free(ptr);
+    free(blk);
+    return RET(COMP_ERR_NOMEM);
+  }
+  cbEGTBCompBytes += sizeof(*info) + n + n_s + n_u;
+  info->crc = (unsigned *) (info + 1);
+  if (check_crc)
+    blk_u = info->blk_u = info->crc + 2 * n_blk;
+  else
+    blk_u = info->blk_u = info->crc;
+  blk_s = info->blk_s =
+      (unsigned short *) (blk_u + 2 + n_blk / (2 * SHORT_INDEX));
+
+  info->check_crc = check_crc;
+  info->block_size_log = block_size_log;
+  info->block_size = block_size;
+  info->n_blk = n_blk;
+
+  if (check_crc) {
+    n_blk <<= 1;
+    i = HEADER_SIZE;
+    for (n = 0; n < n_blk; ++n) {
+      info->crc[n] = R4(i);
+      i += 4;
+    }
+    n_blk >>= 1;
+  }
+
+  i = HEADER_SIZE + (n_blk << 3);
+  BIORD_START(ptr + i);
+
+  info->comp_block_size = 0;
+  for (n = 0; n <= n_blk; ++n) {
+    if ((blk[n] = BIORD(block_size_log)) == 0)
+      blk[n] = block_size;
+    if (info->comp_block_size < (int) (blk[n]))
+      info->comp_block_size = (int) (blk[n]);
+    BIORD_MORE(block_size_log);
+  }
+  info->comp_block_size += 32;
+
+  for (n = 0; n < MAX_DISTANCES; ++n) {
+    info->distance[n] = -((int) BIORD(block_size_log));
+    BIORD_MORE(block_size_log);
+  }
+
+  i += ((n_blk + 1 + MAX_DISTANCES) * block_size_log + 7) >> 3;
+  BIORD_START(ptr + i);
+  BITIO_LEAVE(Bitio);
+  if (huffman_read_length(&Bitio, temp, ALPHABET_SIZE) != 0) {
+    free(blk);
+    free(info);
+    free(ptr);
+    return RET(COMP_ERR_BROKEN);
+  }
+
+  if (huffman_decode_create(info->table, temp, ALPHABET_SIZE, START_BITS) != 0) {
+    free(blk);
+    free(info);
+    free(ptr);
+    return RET(COMP_ERR_BROKEN);
+  }
+
+  info->last_block_size = blk[n_blk];
+  blk[n_blk] = 0;
+  for (n = 0; n <= n_blk; ++n) {
+    i = blk[n];
+    blk[n] = header_size;
+    header_size += i;
+    if (0 == n % (2 * SHORT_INDEX))
+      blk_u[n / (2 * SHORT_INDEX)] = blk[n];
+  }
+  blk_u[n_blk / (2 * SHORT_INDEX) + 1] = blk[n_blk];
+
+  for (n = 0; n <= n_blk; ++n) {
+    i = n / (2 * SHORT_INDEX);
+    if (n & SHORT_INDEX)
+      blk_s[n] = blk_u[i + 1] - blk[n];
+    else
+      blk_s[n] = blk[n] - blk_u[i];
+  }
+
+  free(blk);
+  free(ptr);
+  info->comp = 0;
+  info->magic = DECODE_MAGIC;
+  *res = info;
+
+  return (COMP_ERR_NONE);
+}
+
+static int comp_tell_blocks(decode_info * info)
+{
+  if (info == 0 || info->magic != DECODE_MAGIC)
+    return (-1);
+  return (info->n_blk);
+}
+
+static int comp_init_block(decode_block * block, int block_size, uchar * orig)
+{
+  if (block == 0)
+    return RET(COMP_ERR_PARAM);
+  block->orig.first = orig;
+  block->comp.first = (uchar *) (block + 1);
+  block->b.ptr = 0;
+  block->b.decoded = -1;
+  block->b.total = -1;
+  block->b.number = -1;
+  block->n = -1;
+  block->magic = BLOCK_MAGIC;
+  return (COMP_ERR_NONE);
+}
+
+static int comp_alloc_block(decode_block ** ret_block, int block_size)
+{
+  decode_block *block;
+
+  if (ret_block == 0)
+    return RET(COMP_ERR_PARAM);
+  *ret_block = 0;
+  if ((block = (decode_block *) malloc(sizeof(*block) + block_size)) == 0)
+    return RET(COMP_ERR_NOMEM);
+  cbEGTBCompBytes += sizeof(*block) + block_size;
+  if (0 != comp_init_block(block, block_size, NULL))
+    return RET(COMP_ERR_PARAM);
+  *ret_block = block;
+  return (COMP_ERR_NONE);
+}
+
+#define RETURN(n) \
+  return ((n) == COMP_ERR_NONE ? COMP_ERR_NONE : RET (n));
+
+static int comp_read_block(decode_block * block, decode_info * info, FILE * fd,
+                           int n)
+{
+  int       comp_size, orig_size, comp_start;
+  uchar    *comp, *orig;
+
+  if (block == 0 || block->magic != BLOCK_MAGIC)
+    return RET(COMP_ERR_PARAM);
+  assert(info->magic == DECODE_MAGIC);
+  if ((unsigned) n >= (unsigned) info->n_blk)
+    RETURN(COMP_ERR_PARAM);
+  comp = block->comp.first;
+  block->n = n;
+  orig = block->orig.first;
+  orig_size = info->block_size;
+  if (n == info->n_blk - 1)
+    orig_size = info->last_block_size;
+  block->orig.size = orig_size;
+  comp_start = calculate_offset(info, n);
+  block->comp.size = comp_size = calculate_offset(info, n + 1) - comp_start;
+  if (fseek(fd, comp_start, SEEK_SET) != 0)
+    RETURN(COMP_ERR_READ);
+  if (fread(comp, 1, comp_size, fd) != (size_t) comp_size)
+    RETURN(COMP_ERR_READ);
+  if (info->check_crc
+      && info->crc[(n << 1) + 1] != CRC32(block->comp.first, comp_size, 0))
+    RETURN(COMP_ERR_BROKEN);
+  block->emit.rept = 0;
+  if (comp_size == orig_size) {
+    memcpy(orig, comp, comp_size);
+    block->emit.ptr = orig + comp_size;
+    block->b.decoded = comp_size;
+  } else {
+    block->emit.ptr = orig;
+    block->b.decoded = 0;
+  }
+  block->b.number = n;
+  block->b.ptr = orig;
+  block->b.total = orig_size;
+
+  RETURN(COMP_ERR_NONE);
+}
+
+static int comp_decode_and_check_crc(decode_block * block, decode_info * info,
+                                     int n, int check_crc)
+{
+  if (block == 0 || block->magic != BLOCK_MAGIC)
+    return RET(COMP_ERR_PARAM);
+  assert(info->magic == DECODE_MAGIC);
+  if ((unsigned) (n - 1) > (unsigned) (block->orig.size - 1))
+    RETURN(COMP_ERR_PARAM);
+  if (check_crc)
+    n = block->orig.size;
+  do_decode(info, block, block->orig.first + n);
+  block->b.ptr = block->orig.first;
+  block->b.total = block->orig.size;
+  if (block->b.decoded >= block->b.total) {
+    if (block->b.decoded > block->b.total)
+      RETURN(COMP_ERR_BROKEN);
+    if (block->emit.rept != 0)
+      RETURN(COMP_ERR_BROKEN);
+  }
+  if (check_crc && info->check_crc
+      && info->crc[block->n << 1] != CRC32(block->orig.first, block->orig.size,
+                                           0))
+    RETURN(COMP_ERR_BROKEN);
+
+  RETURN(COMP_ERR_NONE);
+}
+
+#if !defined (COLOR_DECLARED)
+
+/*
+   Test driver
+ */
+
+#define	CRC_CHECK	1
+
+int main(int argc, char *argv[])
+{
+  int       i;
+  int       size;
+  int       result;
+  FILE     *fp;
+  decode_info *comp_info;
+  decode_block *comp_block;
+  clock_t   tStart, tEnd;
+  double    dSeconds;
+  uchar     rgbBuf[8192 + 32];
+
+  if (2 != argc) {
+    printf("Invalid arguments\n");
+    exit(1);
+  }
+  fp = fopen(argv[1], "rb");
+  if (0 == fp) {
+    printf("Unable to open file\n");
+    exit(1);
+  }
+  result = comp_open_file(&comp_info, fp, CRC_CHECK);
+  if (0 != result) {
+    printf("Unable to read file (1): %d\n", result);
+    exit(1);
+  }
+  if (8192 != comp_info->block_size) {
+    printf("Invalid block size: %d\n", comp_info->block_size);
+    exit(1);
+  }
+  result = comp_alloc_block(&comp_block, comp_info->block_size);
+  if (0 != result) {
+    printf("Unable to allocate block: %d\n", result);
+    exit(1);
+  }
+
+  size = 0;
+  tStart = clock();
+  for (i = 0; i < comp_info->n_blk; i++) {
+    if (0 !=
+        (result = comp_init_block(comp_block, comp_info->block_size, rgbBuf))) {
+      printf("Unable to init block: %d\n", result);
+      exit(1);
+    }
+    if (0 != (result = comp_read_block(comp_block, comp_info, fp, i))) {
+      printf("Unable to read block: %d\n", result);
+      exit(1);
+    }
+    size += comp_block->orig.size;
+    if (0 !=
+        (result =
+         comp_decode_and_check_crc(comp_block, comp_info, comp_block->orig.size,
+                                   CRC_CHECK))) {
+      printf("Unable to decode block: %d\n", result);
+      exit(1);
+    }
+  }
+  tEnd = clock();
+  dSeconds = (double) (tEnd - tStart) / CLOCKS_PER_SEC;
+  printf("Total memory allocated: %dKb\n", (cbEGTBCompBytes + 1023) / 1024);
+  printf("%g seconds, %dMb, %gMb/sec)\n", dSeconds, size / (1024 * 1024),
+         size / (1024 * 1024) / dSeconds);
+  return 0;
+}
+
+#endif
+#endif