lzxd.c File Reference

#include <system.h>
#include <lzx.h>
#include <readbits.h>
#include <readhuff.h>

Go to the source code of this file.

Macros
#define	BITS_TYPE   struct lzxd_stream
#define	BITS_VAR   lzx
#define	BITS_ORDER_MSB
#define	READ_BYTES
#define	TABLEBITS(tbl)   LZX_##tbl##_TABLEBITS
#define	MAXSYMBOLS(tbl)   LZX_##tbl##_MAXSYMBOLS
#define	HUFF_TABLE(tbl, idx)   lzx->tbl##_table[idx]
#define	HUFF_LEN(tbl, idx)   lzx->tbl##_len[idx]
#define	HUFF_ERROR   return lzx->error = MSPACK_ERR_DECRUNCH
#define	BUILD_TABLE(tbl)
#define	BUILD_TABLE_MAYBE_EMPTY(tbl)
#define	READ_LENGTHS(tbl, first, last)

Functions
static int	lzxd_read_lens (struct lzxd_stream *lzx, unsigned char *lens, unsigned int first, unsigned int last)
static void	lzxd_reset_state (struct lzxd_stream *lzx)
struct lzxd_stream *	lzxd_init (struct mspack_system *system, struct mspack_file *input, struct mspack_file *output, int window_bits, int reset_interval, int input_buffer_size, off_t output_length, char is_delta)
int	lzxd_set_reference_data (struct lzxd_stream *lzx, struct mspack_system *system, struct mspack_file *input, unsigned int length)
void	lzxd_set_output_length (struct lzxd_stream *lzx, off_t out_bytes)
int	lzxd_decompress (struct lzxd_stream *lzx, off_t out_bytes)
void	lzxd_free (struct lzxd_stream *lzx)

Variables
static const unsigned int	position_slots [11]
static const unsigned char	extra_bits [36]
static const unsigned int	position_base [290]

Macro Definition Documentation

BITS_ORDER_MSB

#define BITS_ORDER_MSB

Definition at line 85 of file lzxd.c.

BITS_TYPE

#define BITS_TYPE   struct lzxd_stream

Definition at line 83 of file lzxd.c.

BITS_VAR

#define BITS_VAR   lzx

Definition at line 84 of file lzxd.c.

BUILD_TABLE

#define BUILD_TABLE

(

tbl

)

Value:

    if (make_decode_table(MAXSYMBOLS(tbl), TABLEBITS(tbl),              \
                          &HUFF_LEN(tbl,0), &HUFF_TABLE(tbl,0)))        \
    {                                                                   \
        D(("failed to build %s table", #tbl))                           \
        return lzx->error = MSPACK_ERR_DECRUNCH;                        \
    }

Definition at line 103 of file lzxd.c.

BUILD_TABLE_MAYBE_EMPTY

#define BUILD_TABLE_MAYBE_EMPTY

(

tbl

)

Value:

    do {                               \
    lzx->tbl##_empty = 0;                                               \
    if (make_decode_table(MAXSYMBOLS(tbl), TABLEBITS(tbl),              \
                          &HUFF_LEN(tbl,0), &HUFF_TABLE(tbl,0)))        \
    {                                                                   \
        for (i = 0; i < MAXSYMBOLS(tbl); i++) {                         \
            if (HUFF_LEN(tbl, i) > 0) {                                 \
                D(("failed to build %s table", #tbl))                   \
                return lzx->error = MSPACK_ERR_DECRUNCH;                \
            }                                                           \
        }                                                               \
        /* empty tree - allow it, but don't decode symbols with it */   \
        lzx->tbl##_empty = 1;                                           \
    }                                                                   \
} while (0)

Definition at line 111 of file lzxd.c.

HUFF_ERROR

#define HUFF_ERROR   return lzx->error = MSPACK_ERR_DECRUNCH

Definition at line 99 of file lzxd.c.

HUFF_LEN

#define HUFF_LEN	(		tbl,
			idx
	)		lzx->tbl##_len[idx]

Definition at line 98 of file lzxd.c.

HUFF_TABLE

#define HUFF_TABLE	(		tbl,
			idx
	)		lzx->tbl##_table[idx]

Definition at line 97 of file lzxd.c.

MAXSYMBOLS

#define MAXSYMBOLS

(

tbl

)

LZX_##tbl##_MAXSYMBOLS

Definition at line 96 of file lzxd.c.

READ_BYTES

#define READ_BYTES

Value:

    do {                 \
    unsigned char b0, b1;               \
    READ_IF_NEEDED; b0 = *i_ptr++;      \
    READ_IF_NEEDED; b1 = *i_ptr++;      \
    INJECT_BITS((b1 << 8) | b0, 16);    \
} while (0)

Definition at line 86 of file lzxd.c.

READ_LENGTHS

#define READ_LENGTHS	(		tbl,
			first,
			last
	)

Value:

  do {             \
  STORE_BITS;                                           \
  if (lzxd_read_lens(lzx, &HUFF_LEN(tbl, 0), (first),   \
    (unsigned int)(last))) return lzx->error;           \
  RESTORE_BITS;                                         \
} while (0)

Definition at line 131 of file lzxd.c.

TABLEBITS

#define TABLEBITS

(

tbl

)

LZX_##tbl##_TABLEBITS

Definition at line 95 of file lzxd.c.

Function Documentation

lzxd_decompress()

int lzxd_decompress	(	struct lzxd_stream *	lzx,
		off_t	out_bytes
	)

Decompresses entire or partial LZX streams.

The number of bytes of data that should be decompressed is given as the out_bytes parameter. If more bytes are decoded than are needed, they will be kept over for a later invocation.

The output bytes will be passed to the system->write() function given in lzxd_init(), using the output file handle given in lzxd_init(). More than one call may be made to system->write().

Input bytes will be read in as necessary using the system->read() function given in lzxd_init(), using the input file handle given in lzxd_init(). This will continue until system->read() returns 0 bytes, or an error. Errors will be passed out of the function as MSPACK_ERR_READ errors. Input streams should convey an "end of input stream" by refusing to supply all the bytes that LZX asks for when they reach the end of the stream, rather than return an error code.

If any error code other than MSPACK_ERR_OK is returned, the stream should be considered unusable and lzxd_decompress() should not be called again on this stream.

Parameters

lzx	LZX decompression state, as allocated by lzxd_init().
out_bytes	the number of bytes of data to decompress.

Returns

an error code, or MSPACK_ERR_OK if successful

Definition at line 393 of file lzxd.c.

                                                              {
  /* bitstream and huffman reading variables */
  register unsigned int bit_buffer;
  register int bits_left, i=0;
  unsigned char *i_ptr, *i_end;
  register unsigned short sym;
 
  int match_length, length_footer, extra, verbatim_bits, bytes_todo;
  int this_run, main_element, aligned_bits, j, warned = 0;
  unsigned char *window, *runsrc, *rundest, buf[12];
  unsigned int frame_size=0, end_frame, match_offset, window_posn;
  unsigned int R0, R1, R2;
 
  /* easy answers */
  if (!lzx || (out_bytes < 0)) return MSPACK_ERR_ARGS;
  if (lzx->error) return lzx->error;
 
  /* flush out any stored-up bytes before we begin */
  i = lzx->o_end - lzx->o_ptr;
  if ((off_t) i > out_bytes) i = (int) out_bytes;
  if (i) {
    if (lzx->sys->write(lzx->output, lzx->o_ptr, i) != i) {
      return lzx->error = MSPACK_ERR_WRITE;
    }
    lzx->o_ptr  += i;
    lzx->offset += i;
    out_bytes   -= i;
  }
  if (out_bytes == 0) return MSPACK_ERR_OK;
 
  /* restore local state */
  RESTORE_BITS;
  window = lzx->window;
  window_posn = lzx->window_posn;
  R0 = lzx->R0;
  R1 = lzx->R1;
  R2 = lzx->R2;
 
  end_frame = (unsigned int)((lzx->offset + out_bytes) / LZX_FRAME_SIZE) + 1;
 
  while (lzx->frame < end_frame) {
    /* have we reached the reset interval? (if there is one?) */
    if (lzx->reset_interval && ((lzx->frame % lzx->reset_interval) == 0)) {
      if (lzx->block_remaining) {
        /* this is a file format error, we can make a best effort to extract what we can */
        D(("%d bytes remaining at reset interval", lzx->block_remaining))
        if (!warned) {
          lzx->sys->message(NULL, "WARNING; invalid reset interval detected during LZX decompression");
          warned++;
        }
      }
 
      /* re-read the intel header and reset the huffman lengths */
      lzxd_reset_state(lzx);
      R0 = lzx->R0;
      R1 = lzx->R1;
      R2 = lzx->R2;
    }
 
    /* LZX DELTA format has chunk_size, not present in LZX format */
    if (lzx->is_delta) {
      ENSURE_BITS(16);
      REMOVE_BITS(16);
    }
 
    /* read header if necessary */
    if (!lzx->header_read) {
      /* read 1 bit. if bit=0, intel filesize = 0.
       * if bit=1, read intel filesize (32 bits) */
      j = 0; READ_BITS(i, 1); if (i) { READ_BITS(i, 16); READ_BITS(j, 16); }
      lzx->intel_filesize = (i << 16) | j;
      lzx->header_read = 1;
    } 
 
    /* calculate size of frame: all frames are 32k except the final frame
     * which is 32kb or less. this can only be calculated when lzx->length
     * has been filled in. */
    frame_size = LZX_FRAME_SIZE;
    if (lzx->length && (lzx->length - lzx->offset) < (off_t)frame_size) {
      frame_size = lzx->length - lzx->offset;
    }
 
    /* decode until one more frame is available */
    bytes_todo = lzx->frame_posn + frame_size - window_posn;
    while (bytes_todo > 0) {
      /* initialise new block, if one is needed */
      if (lzx->block_remaining == 0) {
        /* realign if previous block was an odd-sized UNCOMPRESSED block */
        if ((lzx->block_type == LZX_BLOCKTYPE_UNCOMPRESSED) &&
            (lzx->block_length & 1))
        {
          READ_IF_NEEDED;
          i_ptr++;
        }
 
        /* read block type (3 bits) and block length (24 bits) */
        READ_BITS(lzx->block_type, 3);
        READ_BITS(i, 16); READ_BITS(j, 8);
        lzx->block_remaining = lzx->block_length = (i << 8) | j;
        /*D(("new block t%d len %u", lzx->block_type, lzx->block_length))*/
 
        /* read individual block headers */
        switch (lzx->block_type) {
        case LZX_BLOCKTYPE_ALIGNED:
          /* read lengths of and build aligned huffman decoding tree */
          for (i = 0; i < 8; i++) { READ_BITS(j, 3); lzx->ALIGNED_len[i] = j; }
          BUILD_TABLE(ALIGNED);
          /* rest of aligned header is same as verbatim */ /*@fallthrough@*/
        case LZX_BLOCKTYPE_VERBATIM:
          /* read lengths of and build main huffman decoding tree */
          READ_LENGTHS(MAINTREE, 0, 256);
          READ_LENGTHS(MAINTREE, 256, LZX_NUM_CHARS + lzx->num_offsets);
          BUILD_TABLE(MAINTREE);
          /* if the literal 0xE8 is anywhere in the block... */
          if (lzx->MAINTREE_len[0xE8] != 0) lzx->intel_started = 1;
          /* read lengths of and build lengths huffman decoding tree */
          READ_LENGTHS(LENGTH, 0, LZX_NUM_SECONDARY_LENGTHS);
          BUILD_TABLE_MAYBE_EMPTY(LENGTH);
          break;
 
        case LZX_BLOCKTYPE_UNCOMPRESSED:
          /* because we can't assume otherwise */
          lzx->intel_started = 1;
 
          /* read 1-16 (not 0-15) bits to align to bytes */
          if (bits_left == 0) ENSURE_BITS(16);
          bits_left = 0; bit_buffer = 0;
 
          /* read 12 bytes of stored R0 / R1 / R2 values */
          for (rundest = &buf[0], i = 0; i < 12; i++) {
            READ_IF_NEEDED;
            *rundest++ = *i_ptr++;
          }
          R0 = buf[0] | (buf[1] << 8) | (buf[2]  << 16) | (buf[3]  << 24);
          R1 = buf[4] | (buf[5] << 8) | (buf[6]  << 16) | (buf[7]  << 24);
          R2 = buf[8] | (buf[9] << 8) | (buf[10] << 16) | (buf[11] << 24);
          break;
 
        default:
          D(("bad block type"))
          return lzx->error = MSPACK_ERR_DECRUNCH;
        }
      }
 
      /* decode more of the block:
       * run = min(what's available, what's needed) */
      this_run = lzx->block_remaining;
      if (this_run > bytes_todo) this_run = bytes_todo;
 
      /* assume we decode exactly this_run bytes, for now */
      bytes_todo           -= this_run;
      lzx->block_remaining -= this_run;
 
      /* decode at least this_run bytes */
      switch (lzx->block_type) {
      case LZX_BLOCKTYPE_ALIGNED:
      case LZX_BLOCKTYPE_VERBATIM:
        while (this_run > 0) {
          READ_HUFFSYM(MAINTREE, main_element);
          if (main_element < LZX_NUM_CHARS) {
            /* literal: 0 to LZX_NUM_CHARS-1 */
            window[window_posn++] = main_element;
            this_run--;
          }
          else {
            /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
            main_element -= LZX_NUM_CHARS;
 
            /* get match length */
            match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
            if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
              if (lzx->LENGTH_empty) {
                D(("LENGTH symbol needed but tree is empty"))
                return lzx->error = MSPACK_ERR_DECRUNCH;
              }
              READ_HUFFSYM(LENGTH, length_footer);
              match_length += length_footer;
            }
            match_length += LZX_MIN_MATCH;
 
            /* get match offset */
            switch ((match_offset = (main_element >> 3))) {
            case 0: match_offset = R0; break;
            case 1: match_offset = R1; R1=R0; R0 = match_offset; break;
            case 2: match_offset = R2; R2=R0; R0 = match_offset; break;
            default:
              if (lzx->block_type == LZX_BLOCKTYPE_VERBATIM) {
                if (match_offset == 3) {
                  match_offset = 1;
                }
                else {
                  extra = (match_offset >= 36) ? 17 : extra_bits[match_offset];
                  READ_BITS(verbatim_bits, extra);
                  match_offset = position_base[match_offset] - 2 + verbatim_bits;
                }
              }
              else { /* LZX_BLOCKTYPE_ALIGNED */
                extra = (match_offset >= 36) ? 17 : extra_bits[match_offset];
                match_offset = position_base[match_offset] - 2;
                if (extra > 3) { /* >3: verbatim and aligned bits */
                  extra -= 3;
                  READ_BITS(verbatim_bits, extra);
                  match_offset += (verbatim_bits << 3);
                  READ_HUFFSYM(ALIGNED, aligned_bits);
                  match_offset += aligned_bits;
                }
                else if (extra == 3) { /* 3: aligned bits only */
                  READ_HUFFSYM(ALIGNED, aligned_bits);
                  match_offset += aligned_bits;
                }
                else if (extra > 0) { /* 1-2: verbatim bits only */
                  READ_BITS(verbatim_bits, extra);
                  match_offset += verbatim_bits;
                }
                else { /* 0: not defined in LZX specification! */
                  match_offset = 1;
                }
              }
              /* update repeated offset LRU queue */
              R2 = R1; R1 = R0; R0 = match_offset;
            }
 
            /* LZX DELTA uses max match length to signal even longer match */
            if (match_length == LZX_MAX_MATCH && lzx->is_delta) {
                int extra_len = 0;
                ENSURE_BITS(3); /* 4 entry huffman tree */
                if (PEEK_BITS(1) == 0) {
                    REMOVE_BITS(1); /* '0' -> 8 extra length bits */
                    READ_BITS(extra_len, 8);
                }
                else if (PEEK_BITS(2) == 2) {
                    REMOVE_BITS(2); /* '10' -> 10 extra length bits + 0x100 */
                    READ_BITS(extra_len, 10);
                    extra_len += 0x100;
                }
                else if (PEEK_BITS(3) == 6) {
                    REMOVE_BITS(3); /* '110' -> 12 extra length bits + 0x500 */
                    READ_BITS(extra_len, 12);
                    extra_len += 0x500;
                }
                else {
                    REMOVE_BITS(3); /* '111' -> 15 extra length bits */
                    READ_BITS(extra_len, 15);
                }
                match_length += extra_len;
            }
 
            if ((window_posn + match_length) > lzx->window_size) {
              D(("match ran over window wrap"))
              return lzx->error = MSPACK_ERR_DECRUNCH;
            }
 
            /* copy match */
            rundest = &window[window_posn];
            i = match_length;
            /* does match offset wrap the window? */
            if (match_offset > window_posn) {
              if (match_offset > lzx->offset &&
                  (match_offset - window_posn) > lzx->ref_data_size)
              {
                D(("match offset beyond LZX stream"))
                return lzx->error = MSPACK_ERR_DECRUNCH;
              }
              /* j = length from match offset to end of window */
              j = match_offset - window_posn;
              if (j > (int) lzx->window_size) {
                D(("match offset beyond window boundaries"))
                return lzx->error = MSPACK_ERR_DECRUNCH;
              }
              runsrc = &window[lzx->window_size - j];
              if (j < i) {
                /* if match goes over the window edge, do two copy runs */
                i -= j; while (j-- > 0) *rundest++ = *runsrc++;
                runsrc = window;
              }
              while (i-- > 0) *rundest++ = *runsrc++;
            }
            else {
              runsrc = rundest - match_offset;
              while (i-- > 0) *rundest++ = *runsrc++;
            }
 
            this_run    -= match_length;
            window_posn += match_length;
          }
        } /* while (this_run > 0) */
        break;
 
      case LZX_BLOCKTYPE_UNCOMPRESSED:
        /* as this_run is limited not to wrap a frame, this also means it
         * won't wrap the window (as the window is a multiple of 32k) */
        rundest = &window[window_posn];
        window_posn += this_run;
        while (this_run > 0) {
          if ((i = i_end - i_ptr) == 0) {
            READ_IF_NEEDED;
          }
          else {
            if (i > this_run) i = this_run;
            lzx->sys->copy(i_ptr, rundest, (size_t) i);
            rundest  += i;
            i_ptr    += i;
            this_run -= i;
          }
        }
        break;
 
      default:
        return lzx->error = MSPACK_ERR_DECRUNCH; /* might as well */
      }
 
      /* did the final match overrun our desired this_run length? */
      if (this_run < 0) {
        if ((unsigned int)(-this_run) > lzx->block_remaining) {
          D(("overrun went past end of block by %d (%d remaining)",
             -this_run, lzx->block_remaining ))
          return lzx->error = MSPACK_ERR_DECRUNCH;
        }
        lzx->block_remaining -= -this_run;
      }
    } /* while (bytes_todo > 0) */
 
    /* streams don't extend over frame boundaries */
    if ((window_posn - lzx->frame_posn) != frame_size) {
      D(("decode beyond output frame limits! %d != %d",
         window_posn - lzx->frame_posn, frame_size))
      return lzx->error = MSPACK_ERR_DECRUNCH;
    }
 
    /* re-align input bitstream */
    if (bits_left > 0) ENSURE_BITS(16);
    if (bits_left & 15) REMOVE_BITS(bits_left & 15);
 
    /* check that we've used all of the previous frame first */
    if (lzx->o_ptr != lzx->o_end) {
      D(("%ld avail bytes, new %d frame",
          (long)(lzx->o_end - lzx->o_ptr), frame_size))
      return lzx->error = MSPACK_ERR_DECRUNCH;
    }
 
    /* does this intel block _really_ need decoding? */
    if (lzx->intel_started && lzx->intel_filesize &&
        (lzx->frame < 32768) && (frame_size > 10))
    {
      unsigned char *data    = &lzx->e8_buf[0];
      unsigned char *dataend = &lzx->e8_buf[frame_size - 10];
      signed int curpos      = (int) lzx->offset;
      signed int filesize    = lzx->intel_filesize;
      signed int abs_off, rel_off;
 
      /* copy e8 block to the e8 buffer and tweak if needed */
      lzx->o_ptr = data;
      lzx->sys->copy(&lzx->window[lzx->frame_posn], data, frame_size);
 
      while (data < dataend) {
        if (*data++ != 0xE8) { curpos++; continue; }
        abs_off = data[0] | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);
        if ((abs_off >= -curpos) && (abs_off < filesize)) {
          rel_off = (abs_off >= 0) ? abs_off - curpos : abs_off + filesize;
          data[0] = (unsigned char) rel_off;
          data[1] = (unsigned char) (rel_off >> 8);
          data[2] = (unsigned char) (rel_off >> 16);
          data[3] = (unsigned char) (rel_off >> 24);
        }
        data += 4;
        curpos += 5;
      }
    }
    else {
      lzx->o_ptr = &lzx->window[lzx->frame_posn];
    }
    lzx->o_end = &lzx->o_ptr[frame_size];
 
    /* write a frame */
    i = (out_bytes < (off_t)frame_size) ? (unsigned int)out_bytes : frame_size;
    if (lzx->sys->write(lzx->output, lzx->o_ptr, i) != i) {
      return lzx->error = MSPACK_ERR_WRITE;
    }
    lzx->o_ptr  += i;
    lzx->offset += i;
    out_bytes   -= i;
 
    /* advance frame start position */
    lzx->frame_posn += frame_size;
    lzx->frame++;
 
    /* wrap window / frame position pointers */
    if (window_posn == lzx->window_size)     window_posn = 0;
    if (lzx->frame_posn == lzx->window_size) lzx->frame_posn = 0;
 
  } /* while (lzx->frame < end_frame) */
 
  if (out_bytes) {
    D(("bytes left to output"))
    return lzx->error = MSPACK_ERR_DECRUNCH;
  }
 
  /* store local state */
  STORE_BITS;
  lzx->window_posn = window_posn;
  lzx->R0 = R0;
  lzx->R1 = R1;
  lzx->R2 = R2;
 
  return MSPACK_ERR_OK;
}

lzxd_free()

void lzxd_free

(

struct lzxd_stream *

lzx

)

Frees all state associated with an LZX data stream. This will call system->free() using the system pointer given in lzxd_init().

Parameters

lzx	LZX decompression state to free.

Definition at line 800 of file lzxd.c.

                                        {
  struct mspack_system *sys;
  if (lzx) {
    sys = lzx->sys;
    sys->free(lzx->inbuf);
    sys->free(lzx->window);
    sys->free(lzx);
  }
}

lzxd_init()

struct lzxd_stream* lzxd_init	(	struct mspack_system *	system,
		struct mspack_file *	input,
		struct mspack_file *	output,
		int	window_bits,
		int	reset_interval,
		int	input_buffer_size,
		off_t	output_length,
		char	is_delta
	)

Allocates and initialises LZX decompression state for decoding an LZX stream.

This routine uses system->alloc() to allocate memory. If memory allocation fails, or the parameters to this function are invalid, NULL is returned.

Parameters

system	an mspack_system structure used to read from the input stream and write to the output stream, also to allocate and free memory.
input	an input stream with the LZX data.
output	an output stream to write the decoded data to.
window_bits	the size of the decoding window, which must be between 15 and 21 inclusive for regular LZX data, or between 17 and 25 inclusive for LZX DELTA data.
reset_interval	the interval at which the LZX bitstream is reset, in multiples of LZX frames (32678 bytes), e.g. a value of 2 indicates the input stream resets after every 65536 output bytes. A value of 0 indicates that the bitstream never resets, such as in CAB LZX streams.
input_buffer_size	the number of bytes to use as an input bitstream buffer.
output_length	the length in bytes of the entirely decompressed output stream, if known in advance. It is used to correctly perform the Intel E8 transformation, which must stop 6 bytes before the very end of the decompressed stream. It is not otherwise used or adhered to. If the full decompressed length is known in advance, set it here. If it is NOT known, use the value 0, and call lzxd_set_output_length() once it is known. If never set, 4 of the final 6 bytes of the output stream may be incorrect.
is_delta	should be zero for all regular LZX data, non-zero for LZX DELTA encoded data.

Returns

a pointer to an initialised lzxd_stream structure, or NULL if there was not enough memory or parameters to the function were wrong.

Definition at line 279 of file lzxd.c.

{
  unsigned int window_size = 1 << window_bits;
  struct lzxd_stream *lzx;
 
  if (!system) return NULL;
 
  /* LZX DELTA window sizes are between 2^17 (128KiB) and 2^25 (32MiB),
   * regular LZX windows are between 2^15 (32KiB) and 2^21 (2MiB)
   */
  if (is_delta) {
      if (window_bits < 17 || window_bits > 25) return NULL;
  }
  else {
      if (window_bits < 15 || window_bits > 21) return NULL;
  }
 
  if (reset_interval < 0 || output_length < 0) {
      D(("reset interval or output length < 0"))
      return NULL;
  }
 
  /* round up input buffer size to multiple of two */
  input_buffer_size = (input_buffer_size + 1) & -2;
  if (input_buffer_size < 2) return NULL;
 
  /* allocate decompression state */
  if (!(lzx = (struct lzxd_stream *) system->alloc(system, sizeof(struct lzxd_stream)))) {
    return NULL;
  }
 
  /* allocate decompression window and input buffer */
  lzx->window = (unsigned char *) system->alloc(system, (size_t) window_size);
  lzx->inbuf  = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
  if (!lzx->window || !lzx->inbuf) {
    system->free(lzx->window);
    system->free(lzx->inbuf);
    system->free(lzx);
    return NULL;
  }
 
  /* initialise decompression state */
  lzx->sys             = system;
  lzx->input           = input;
  lzx->output          = output;
  lzx->offset          = 0;
  lzx->length          = output_length;
 
  lzx->inbuf_size      = input_buffer_size;
  lzx->window_size     = 1 << window_bits;
  lzx->ref_data_size   = 0;
  lzx->window_posn     = 0;
  lzx->frame_posn      = 0;
  lzx->frame           = 0;
  lzx->reset_interval  = reset_interval;
  lzx->intel_filesize  = 0;
  lzx->intel_started   = 0;
  lzx->error           = MSPACK_ERR_OK;
  lzx->num_offsets     = position_slots[window_bits - 15] << 3;
  lzx->is_delta        = is_delta;
 
  lzx->o_ptr = lzx->o_end = &lzx->e8_buf[0];
  lzxd_reset_state(lzx);
  INIT_BITS;
  return lzx;
}

lzxd_read_lens()

static int lzxd_read_lens ( struct lzxd_stream *  lzx, unsigned char *  lens, unsigned int  first, unsigned int  last  )

static

Definition at line 138 of file lzxd.c.

{
  /* bit buffer and huffman symbol decode variables */
  register unsigned int bit_buffer;
  register int bits_left, i;
  register unsigned short sym;
  unsigned char *i_ptr, *i_end;
 
  unsigned int x, y;
  int z;
 
  RESTORE_BITS;
  
  /* read lengths for pretree (20 symbols, lengths stored in fixed 4 bits) */
  for (x = 0; x < 20; x++) {
    READ_BITS(y, 4);
    lzx->PRETREE_len[x] = y;
  }
  BUILD_TABLE(PRETREE);
 
  for (x = first; x < last; ) {
    READ_HUFFSYM(PRETREE, z);
    if (z == 17) {
      /* code = 17, run of ([read 4 bits]+4) zeros */
      READ_BITS(y, 4); y += 4;
      while (y--) lens[x++] = 0;
    }
    else if (z == 18) {
      /* code = 18, run of ([read 5 bits]+20) zeros */
      READ_BITS(y, 5); y += 20;
      while (y--) lens[x++] = 0;
    }
    else if (z == 19) {
      /* code = 19, run of ([read 1 bit]+4) [read huffman symbol] */
      READ_BITS(y, 1); y += 4;
      READ_HUFFSYM(PRETREE, z);
      z = lens[x] - z; if (z < 0) z += 17;
      while (y--) lens[x++] = z;
    }
    else {
      /* code = 0 to 16, delta current length entry */
      z = lens[x] - z; if (z < 0) z += 17;
      lens[x++] = z;
    }
  }
 
  STORE_BITS;
 
  return MSPACK_ERR_OK;
}

References BUILD_TABLE, i, MSPACK_ERR_OK, lzxd_stream::PRETREE_len, READ_BITS, READ_HUFFSYM, RESTORE_BITS, STORE_BITS, and x.

lzxd_reset_state()

static void lzxd_reset_state ( struct lzxd_stream *  lzx )

static

Definition at line 262 of file lzxd.c.

                                                      {
  int i;
 
  lzx->R0              = 1;
  lzx->R1              = 1;
  lzx->R2              = 1;
  lzx->header_read     = 0;
  lzx->block_remaining = 0;
  lzx->block_type      = LZX_BLOCKTYPE_INVALID;
 
  /* initialise tables to 0 (because deltas will be applied to them) */
  for (i = 0; i < LZX_MAINTREE_MAXSYMBOLS; i++) lzx->MAINTREE_len[i] = 0;
  for (i = 0; i < LZX_LENGTH_MAXSYMBOLS; i++)   lzx->LENGTH_len[i]   = 0;
}

References lzxd_stream::block_remaining, lzxd_stream::block_type, lzxd_stream::header_read, i, lzxd_stream::LENGTH_len, LZX_BLOCKTYPE_INVALID, LZX_LENGTH_MAXSYMBOLS, LZX_MAINTREE_MAXSYMBOLS, lzxd_stream::MAINTREE_len, lzxd_stream::R0, lzxd_stream::R1, and lzxd_stream::R2.

Referenced by lzxd_decompress(), and lzxd_init().

lzxd_set_output_length()

void lzxd_set_output_length	(	struct lzxd_stream *	lzx,
		off_t	out_bytes
	)

Definition at line 389 of file lzxd.c.

                                                                      {
  if (lzx && out_bytes > 0) lzx->length = out_bytes;
}

lzxd_set_reference_data()

int lzxd_set_reference_data	(	struct lzxd_stream *	lzx,
		struct mspack_system *	system,
		struct mspack_file *	input,
		unsigned int	length
	)

Reads LZX DELTA reference data into the window and allows lzxd_decompress() to reference it.

Call this before the first call to lzxd_decompress().

Parameters

lzx	the LZX stream to apply this reference data to
system	an mspack_system implementation to use with the input param. Only read() will be called.
input	an input file handle to read reference data using system->read().
length	the length of the reference data. Cannot be longer than the LZX window size.

Returns

an error code, or MSPACK_ERR_OK if successful

Definition at line 353 of file lzxd.c.

{
    if (!lzx) return MSPACK_ERR_ARGS;
 
    if (!lzx->is_delta) {
        D(("only LZX DELTA streams support reference data"))
        return MSPACK_ERR_ARGS;
    }
    if (lzx->offset) {
        D(("too late to set reference data after decoding starts"))
        return MSPACK_ERR_ARGS;
    }
    if (length > lzx->window_size) {
        D(("reference length (%u) is longer than the window", length))
        return MSPACK_ERR_ARGS;
    }
    if (length > 0 && (!system || !input)) {
        D(("length > 0 but no system or input"))
        return MSPACK_ERR_ARGS;
    }
 
    lzx->ref_data_size = length;
    if (length > 0) {
        /* copy reference data */
        unsigned char *pos = &lzx->window[lzx->window_size - length];
        int bytes = system->read(input, pos, length);
        /* length can't be more than 2^25, so no signedness problem */
        if (bytes < (int)length) return MSPACK_ERR_READ;
    }
    lzx->ref_data_size = length;
    return MSPACK_ERR_OK;
}

Variable Documentation

extra_bits

const unsigned char extra_bits[36]

static

Initial value:

= {
    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
    9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16
}

Definition at line 217 of file lzxd.c.

Referenced by lzxd_decompress().

position_base

const unsigned int position_base[290]

static

Definition at line 221 of file lzxd.c.

Referenced by lzxd_decompress().

position_slots

const unsigned int position_slots[11]

static

Initial value:

= {
    30, 32, 34, 36, 38, 42, 50, 66, 98, 162, 290
}

Definition at line 214 of file lzxd.c.

Referenced by lzxd_init().