lzx.h File Reference

Go to the source code of this file.

Classes
struct	lzxd_stream

Macros
#define	LZX_MIN_MATCH   (2)
#define	LZX_MAX_MATCH   (257)
#define	LZX_NUM_CHARS   (256)
#define	LZX_BLOCKTYPE_INVALID   (0) /* also blocktypes 4-7 invalid */
#define	LZX_BLOCKTYPE_VERBATIM   (1)
#define	LZX_BLOCKTYPE_ALIGNED   (2)
#define	LZX_BLOCKTYPE_UNCOMPRESSED   (3)
#define	LZX_PRETREE_NUM_ELEMENTS   (20)
#define	LZX_ALIGNED_NUM_ELEMENTS   (8) /* aligned offset tree #elements */
#define	LZX_NUM_PRIMARY_LENGTHS   (7) /* this one missing from spec! */
#define	LZX_NUM_SECONDARY_LENGTHS   (249) /* length tree #elements */
#define	LZX_PRETREE_MAXSYMBOLS   (LZX_PRETREE_NUM_ELEMENTS)
#define	LZX_PRETREE_TABLEBITS   (6)
#define	LZX_MAINTREE_MAXSYMBOLS   (LZX_NUM_CHARS + 290*8)
#define	LZX_MAINTREE_TABLEBITS   (12)
#define	LZX_LENGTH_MAXSYMBOLS   (LZX_NUM_SECONDARY_LENGTHS+1)
#define	LZX_LENGTH_TABLEBITS   (12)
#define	LZX_ALIGNED_MAXSYMBOLS   (LZX_ALIGNED_NUM_ELEMENTS)
#define	LZX_ALIGNED_TABLEBITS   (7)
#define	LZX_LENTABLE_SAFETY   (64) /* table decoding overruns are allowed */
#define	LZX_FRAME_SIZE   (32768) /* the size of a frame in LZX */

Functions
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)
void	lzxd_set_output_length (struct lzxd_stream *lzx, off_t output_length)
int	lzxd_set_reference_data (struct lzxd_stream *lzx, struct mspack_system *system, struct mspack_file *input, unsigned int length)
int	lzxd_decompress (struct lzxd_stream *lzx, off_t out_bytes)
void	lzxd_free (struct lzxd_stream *lzx)

Macro Definition Documentation

LZX_ALIGNED_MAXSYMBOLS

#define LZX_ALIGNED_MAXSYMBOLS   (LZX_ALIGNED_NUM_ELEMENTS)

Definition at line 42 of file lzx.h.

LZX_ALIGNED_NUM_ELEMENTS

#define LZX_ALIGNED_NUM_ELEMENTS   (8) /* aligned offset tree #elements */

Definition at line 31 of file lzx.h.

LZX_ALIGNED_TABLEBITS

#define LZX_ALIGNED_TABLEBITS   (7)

Definition at line 43 of file lzx.h.

LZX_BLOCKTYPE_ALIGNED

#define LZX_BLOCKTYPE_ALIGNED   (2)

Definition at line 28 of file lzx.h.

LZX_BLOCKTYPE_INVALID

#define LZX_BLOCKTYPE_INVALID   (0) /* also blocktypes 4-7 invalid */

Definition at line 26 of file lzx.h.

LZX_BLOCKTYPE_UNCOMPRESSED

#define LZX_BLOCKTYPE_UNCOMPRESSED   (3)

Definition at line 29 of file lzx.h.

LZX_BLOCKTYPE_VERBATIM

#define LZX_BLOCKTYPE_VERBATIM   (1)

Definition at line 27 of file lzx.h.

LZX_FRAME_SIZE

#define LZX_FRAME_SIZE   (32768) /* the size of a frame in LZX */

Definition at line 46 of file lzx.h.

LZX_LENGTH_MAXSYMBOLS

#define LZX_LENGTH_MAXSYMBOLS   (LZX_NUM_SECONDARY_LENGTHS+1)

Definition at line 40 of file lzx.h.

LZX_LENGTH_TABLEBITS

#define LZX_LENGTH_TABLEBITS   (12)

Definition at line 41 of file lzx.h.

LZX_LENTABLE_SAFETY

#define LZX_LENTABLE_SAFETY   (64) /* table decoding overruns are allowed */

Definition at line 44 of file lzx.h.

LZX_MAINTREE_MAXSYMBOLS

#define LZX_MAINTREE_MAXSYMBOLS   (LZX_NUM_CHARS + 290*8)

Definition at line 38 of file lzx.h.

LZX_MAINTREE_TABLEBITS

#define LZX_MAINTREE_TABLEBITS   (12)

Definition at line 39 of file lzx.h.

LZX_MAX_MATCH

#define LZX_MAX_MATCH   (257)

Definition at line 24 of file lzx.h.

LZX_MIN_MATCH

#define LZX_MIN_MATCH   (2)

Definition at line 23 of file lzx.h.

LZX_NUM_CHARS

#define LZX_NUM_CHARS   (256)

Definition at line 25 of file lzx.h.

LZX_NUM_PRIMARY_LENGTHS

#define LZX_NUM_PRIMARY_LENGTHS   (7) /* this one missing from spec! */

Definition at line 32 of file lzx.h.

LZX_NUM_SECONDARY_LENGTHS

#define LZX_NUM_SECONDARY_LENGTHS   (249) /* length tree #elements */

Definition at line 33 of file lzx.h.

LZX_PRETREE_MAXSYMBOLS

#define LZX_PRETREE_MAXSYMBOLS   (LZX_PRETREE_NUM_ELEMENTS)

Definition at line 36 of file lzx.h.

LZX_PRETREE_NUM_ELEMENTS

#define LZX_PRETREE_NUM_ELEMENTS   (20)

Definition at line 30 of file lzx.h.

LZX_PRETREE_TABLEBITS

#define LZX_PRETREE_TABLEBITS   (6)

Definition at line 37 of file lzx.h.

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;
}

References lzxd_stream::ALIGNED_len, lzxd_stream::bit_buffer, lzxd_stream::bits_left, lzxd_stream::block_length, lzxd_stream::block_remaining, lzxd_stream::block_type, BUILD_TABLE, BUILD_TABLE_MAYBE_EMPTY, mspack_system::copy, D, lzxd_stream::e8_buf, ENSURE_BITS, lzxd_stream::error, extra_bits, lzxd_stream::frame, lzxd_stream::frame_posn, lzxd_stream::header_read, i, lzxd_stream::i_end, lzxd_stream::i_ptr, int, lzxd_stream::intel_filesize, lzxd_stream::intel_started, lzxd_stream::is_delta, lzxd_stream::length, LENGTH, lzxd_stream::LENGTH_empty, LZX_BLOCKTYPE_ALIGNED, LZX_BLOCKTYPE_UNCOMPRESSED, LZX_BLOCKTYPE_VERBATIM, LZX_FRAME_SIZE, LZX_MAX_MATCH, LZX_MIN_MATCH, LZX_NUM_CHARS, LZX_NUM_PRIMARY_LENGTHS, LZX_NUM_SECONDARY_LENGTHS, lzxd_reset_state(), lzxd_stream::MAINTREE_len, mspack_system::message, MSPACK_ERR_ARGS, MSPACK_ERR_DECRUNCH, MSPACK_ERR_OK, MSPACK_ERR_WRITE, NULL, lzxd_stream::num_offsets, lzxd_stream::o_end, lzxd_stream::o_ptr, lzxd_stream::offset, lzxd_stream::output, PEEK_BITS, position_base, lzxd_stream::R0, R0, lzxd_stream::R1, lzxd_stream::R2, R2, READ_BITS, READ_HUFFSYM, READ_IF_NEEDED, READ_LENGTHS, lzxd_stream::ref_data_size, REMOVE_BITS, lzxd_stream::reset_interval, RESTORE_BITS, STORE_BITS, lzxd_stream::sys, lzxd_stream::window, lzxd_stream::window_posn, lzxd_stream::window_size, and mspack_system::write.

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);
  }
}

References mspack_system::free, lzxd_stream::inbuf, lzxd_stream::sys, and lzxd_stream::window.

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;
}

References mspack_system::alloc, D, lzxd_stream::e8_buf, lzxd_stream::error, lzxd_stream::frame, lzxd_stream::frame_posn, mspack_system::free, lzxd_stream::inbuf, lzxd_stream::inbuf_size, INIT_BITS, lzxd_stream::input, input(), lzxd_stream::intel_filesize, lzxd_stream::intel_started, lzxd_stream::is_delta, lzxd_stream::length, lzxd_reset_state(), MSPACK_ERR_OK, NULL, lzxd_stream::num_offsets, lzxd_stream::o_end, lzxd_stream::o_ptr, lzxd_stream::offset, lzxd_stream::output, output, position_slots, lzxd_stream::ref_data_size, lzxd_stream::reset_interval, lzxd_stream::sys, lzxd_stream::window, lzxd_stream::window_posn, and lzxd_stream::window_size.

lzxd_set_output_length()

void lzxd_set_output_length	(	struct lzxd_stream *	lzx,
		off_t	output_length
	)

Definition at line 389 of file lzxd.c.

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

References lzxd_stream::length.

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;
}

References bytes, D, input(), lzxd_stream::is_delta, length, MSPACK_ERR_ARGS, MSPACK_ERR_OK, MSPACK_ERR_READ, lzxd_stream::offset, pos, mspack_system::read, lzxd_stream::ref_data_size, lzxd_stream::window, and lzxd_stream::window_size.