mszip.h File Reference

Go to the source code of this file.

Classes
struct	mszipd_stream

Macros
#define	MSZIP_FRAME_SIZE   (32768) /* size of LZ history window */
#define	MSZIP_LITERAL_MAXSYMBOLS   (288) /* literal/length huffman tree */
#define	MSZIP_LITERAL_TABLEBITS   (9)
#define	MSZIP_DISTANCE_MAXSYMBOLS   (32) /* distance huffman tree */
#define	MSZIP_DISTANCE_TABLEBITS   (6)
#define	MSZIP_LITERAL_TABLESIZE   (MSZIP_LITERAL_MAXSYMBOLS * 4)
#define	MSZIP_DISTANCE_TABLESIZE

Functions
struct mszipd_stream *	mszipd_init (struct mspack_system *system, struct mspack_file *input, struct mspack_file *output, int input_buffer_size, int repair_mode)
int	mszipd_decompress (struct mszipd_stream *zip, off_t out_bytes)
int	mszipd_decompress_kwaj (struct mszipd_stream *zip)
void	mszipd_free (struct mszipd_stream *zip)

Macro Definition Documentation

MSZIP_DISTANCE_MAXSYMBOLS

#define MSZIP_DISTANCE_MAXSYMBOLS   (32) /* distance huffman tree */

Definition at line 25 of file mszip.h.

MSZIP_DISTANCE_TABLEBITS

#define MSZIP_DISTANCE_TABLEBITS   (6)

Definition at line 26 of file mszip.h.

MSZIP_DISTANCE_TABLESIZE

#define MSZIP_DISTANCE_TABLESIZE

Value:

                                  ((1 << MSZIP_DISTANCE_TABLEBITS) + \
                                  (MSZIP_DISTANCE_MAXSYMBOLS * 2))

Definition at line 41 of file mszip.h.

MSZIP_FRAME_SIZE

#define MSZIP_FRAME_SIZE   (32768) /* size of LZ history window */

Definition at line 22 of file mszip.h.

MSZIP_LITERAL_MAXSYMBOLS

#define MSZIP_LITERAL_MAXSYMBOLS   (288) /* literal/length huffman tree */

Definition at line 23 of file mszip.h.

MSZIP_LITERAL_TABLEBITS

#define MSZIP_LITERAL_TABLEBITS   (9)

Definition at line 24 of file mszip.h.

MSZIP_LITERAL_TABLESIZE

#define MSZIP_LITERAL_TABLESIZE   (MSZIP_LITERAL_MAXSYMBOLS * 4)

Definition at line 32 of file mszip.h.

Function Documentation

mszipd_decompress()

int mszipd_decompress	(	struct mszipd_stream *	zip,
		off_t	out_bytes
	)

Definition at line 384 of file mszipd.c.

                                                                  {
  /* for the bit buffer */
  register unsigned int bit_buffer;
  register int bits_left;
  unsigned char *i_ptr, *i_end;
 
  int i, state, error;
 
  /* easy answers */
  if (!zip || (out_bytes < 0)) return MSPACK_ERR_ARGS;
  if (zip->error) return zip->error;
 
  /* flush out any stored-up bytes before we begin */
  i = zip->o_end - zip->o_ptr;
  if ((off_t) i > out_bytes) i = (int) out_bytes;
  if (i) {
    if (zip->sys->write(zip->output, zip->o_ptr, i) != i) {
      return zip->error = MSPACK_ERR_WRITE;
    }
    zip->o_ptr  += i;
    out_bytes   -= i;
  }
  if (out_bytes == 0) return MSPACK_ERR_OK;
 
 
  while (out_bytes > 0) {
    /* unpack another block */
    RESTORE_BITS;
 
    /* skip to next read 'CK' header */
    i = bits_left & 7; REMOVE_BITS(i); /* align to bytestream */
    state = 0;
    do {
      READ_BITS(i, 8);
      if (i == 'C') state = 1;
      else if ((state == 1) && (i == 'K')) state = 2;
      else state = 0;
    } while (state != 2);
 
    /* inflate a block, repair and realign if necessary */
    zip->window_posn = 0;
    zip->bytes_output = 0;
    STORE_BITS;
    if ((error = inflate(zip))) {
      D(("inflate error %d", error))
      if (zip->repair_mode) {
        /* recover partially-inflated buffers */
        if (zip->bytes_output == 0 && zip->window_posn > 0) {
          zip->flush_window(zip, zip->window_posn);
        }
        zip->sys->message(NULL, "MSZIP error, %u bytes of data lost.",
                          MSZIP_FRAME_SIZE - zip->bytes_output);
        for (i = zip->bytes_output; i < MSZIP_FRAME_SIZE; i++) {
          zip->window[i] = '\0';
        }
        zip->bytes_output = MSZIP_FRAME_SIZE;
      }
      else {
        return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH;
      }
    }
    zip->o_ptr = &zip->window[0];
    zip->o_end = &zip->o_ptr[zip->bytes_output];
 
    /* write a frame */
    i = (out_bytes < (off_t)zip->bytes_output) ?
      (int)out_bytes : zip->bytes_output;
    if (zip->sys->write(zip->output, zip->o_ptr, i) != i) {
      return zip->error = MSPACK_ERR_WRITE;
    }
 
    /* mspack errors (i.e. read errors) are fatal and can't be recovered */
    if ((error > 0) && zip->repair_mode) return error;
 
    zip->o_ptr  += i;
    out_bytes   -= i;
  }
 
  if (out_bytes) {
    D(("bytes left to output"))
    return zip->error = MSPACK_ERR_DECRUNCH;
  }
  return MSPACK_ERR_OK;
}

References mszipd_stream::bit_buffer, mszipd_stream::bits_left, D, zip::error, error(), i, mszipd_stream::i_end, mszipd_stream::i_ptr, if(), inflate(), int, MSPACK_ERR_ARGS, MSPACK_ERR_DECRUNCH, MSPACK_ERR_OK, MSPACK_ERR_WRITE, MSZIP_FRAME_SIZE, NULL, READ_BITS, REMOVE_BITS, RESTORE_BITS, and STORE_BITS.

mszipd_decompress_kwaj()

int mszipd_decompress_kwaj

(

struct mszipd_stream *

zip

)

Definition at line 469 of file mszipd.c.

                                                      {
    /* for the bit buffer */
    register unsigned int bit_buffer;
    register int bits_left;
    unsigned char *i_ptr, *i_end;
 
    int i, error, block_len;
 
    /* unpack blocks until block_len == 0 */
    for (;;) {
        RESTORE_BITS;
 
        /* align to bytestream, read block_len */
        i = bits_left & 7; REMOVE_BITS(i);
        READ_BITS(block_len, 8);
        READ_BITS(i, 8); block_len |= i << 8;
 
        if (block_len == 0) break;
 
        /* read "CK" header */
        READ_BITS(i, 8); if (i != 'C') return MSPACK_ERR_DATAFORMAT;
        READ_BITS(i, 8); if (i != 'K') return MSPACK_ERR_DATAFORMAT;
 
        /* inflate block */
        zip->window_posn = 0;
        zip->bytes_output = 0;
        STORE_BITS;
        if ((error = inflate(zip))) {
            D(("inflate error %d", error))
            return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH;
        }
 
        /* write inflated block */
        if (zip->sys->write(zip->output, &zip->window[0], zip->bytes_output)
            != zip->bytes_output) return zip->error = MSPACK_ERR_WRITE;
    }
    return MSPACK_ERR_OK;
}

References mszipd_stream::bit_buffer, mszipd_stream::bits_left, D, zip::error, error(), i, mszipd_stream::i_end, mszipd_stream::i_ptr, inflate(), MSPACK_ERR_DATAFORMAT, MSPACK_ERR_DECRUNCH, MSPACK_ERR_OK, MSPACK_ERR_WRITE, READ_BITS, REMOVE_BITS, RESTORE_BITS, and STORE_BITS.

mszipd_free()

void mszipd_free

(

struct mszipd_stream *

zip

)

Definition at line 508 of file mszipd.c.

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

References mspack_system::free.

mszipd_init()

struct mszipd_stream* mszipd_init	(	struct mspack_system *	system,
		struct mspack_file *	input,
		struct mspack_file *	output,
		int	input_buffer_size,
		int	repair_mode
	)

Definition at line 342 of file mszipd.c.

{
  struct mszipd_stream *zip;
 
  if (!system) 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 (!(zip = (struct mszipd_stream *) system->alloc(system, sizeof(struct mszipd_stream)))) {
    return NULL;
  }
 
  /* allocate input buffer */
  zip->inbuf  = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
  if (!zip->inbuf) {
    system->free(zip);
    return NULL;
  }
 
  /* initialise decompression state */
  zip->sys             = system;
  zip->input           = input;
  zip->output          = output;
  zip->inbuf_size      = input_buffer_size;
  zip->input_end       = 0;
  zip->error           = MSPACK_ERR_OK;
  zip->repair_mode     = repair_mode;
  zip->flush_window    = &mszipd_flush_window;
 
  zip->i_ptr = zip->i_end = &zip->inbuf[0];
  zip->o_ptr = zip->o_end = NULL;
  zip->bit_buffer = 0; zip->bits_left = 0;
  return zip;
}

References mspack_system::alloc, zip::error, mspack_system::free, input(), MSPACK_ERR_OK, mszipd_flush_window(), NULL, output, and mszipd_stream::repair_mode.