qtmd.c File Reference

#include <system.h>
#include <qtm.h>
#include <readbits.h>

Go to the source code of this file.

Macros
#define	BITS_TYPE   struct qtmd_stream
#define	BITS_VAR   qtm
#define	BITS_ORDER_MSB
#define	READ_BYTES
#define	GET_SYMBOL(model, var)

Functions
static void	qtmd_update_model (struct qtmd_model *model)
static void	qtmd_init_model (struct qtmd_model *model, struct qtmd_modelsym *syms, int start, int len)
struct qtmd_stream *	qtmd_init (struct mspack_system *system, struct mspack_file *input, struct mspack_file *output, int window_bits, int input_buffer_size)
int	qtmd_decompress (struct qtmd_stream *qtm, off_t out_bytes)
void	qtmd_free (struct qtmd_stream *qtm)

Variables
static const unsigned int	position_base [42]
static const unsigned char	extra_bits [42]
static const unsigned char	length_base [27]
static const unsigned char	length_extra [27]

Macro Definition Documentation

BITS_ORDER_MSB

#define BITS_ORDER_MSB

Definition at line 29 of file qtmd.c.

BITS_TYPE

#define BITS_TYPE   struct qtmd_stream

Definition at line 27 of file qtmd.c.

BITS_VAR

#define BITS_VAR   qtm

Definition at line 28 of file qtmd.c.

GET_SYMBOL

#define GET_SYMBOL	(		model,
			var
	)

Definition at line 92 of file qtmd.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((b0 << 8) | b1, 16);    \
} while (0)

Definition at line 30 of file qtmd.c.

Function Documentation

qtmd_decompress()

int qtmd_decompress	(	struct qtmd_stream *	qtm,
		off_t	out_bytes
	)

Definition at line 256 of file qtmd.c.

                                                              {
  unsigned int frame_todo, frame_end, window_posn, match_offset, range;
  unsigned char *window, *i_ptr, *i_end, *runsrc, *rundest;
  int i, j, selector, extra, sym, match_length;
  unsigned short H, L, C, symf;
 
  register unsigned int bit_buffer;
  register unsigned char bits_left;
 
  /* easy answers */
  if (!qtm || (out_bytes < 0)) return MSPACK_ERR_ARGS;
  if (qtm->error) return qtm->error;
 
  /* flush out any stored-up bytes before we begin */
  i = qtm->o_end - qtm->o_ptr;
  if ((off_t) i > out_bytes) i = (int) out_bytes;
  if (i) {
    if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
      return qtm->error = MSPACK_ERR_WRITE;
    }
    qtm->o_ptr  += i;
    out_bytes   -= i;
  }
  if (out_bytes == 0) return MSPACK_ERR_OK;
 
  /* restore local state */
  RESTORE_BITS;
  window = qtm->window;
  window_posn = qtm->window_posn;
  frame_todo = qtm->frame_todo;
  H = qtm->H;
  L = qtm->L;
  C = qtm->C;
 
  /* while we do not have enough decoded bytes in reserve: */
  while ((qtm->o_end - qtm->o_ptr) < out_bytes) {
    /* read header if necessary. Initialises H, L and C */
    if (!qtm->header_read) {
      H = 0xFFFF; L = 0; READ_BITS(C, 16);
      qtm->header_read = 1;
    }
 
    /* decode more, up to the number of bytes needed, the frame boundary,
     * or the window boundary, whichever comes first */
    frame_end = window_posn + (out_bytes - (qtm->o_end - qtm->o_ptr));
    if ((window_posn + frame_todo) < frame_end) {
      frame_end = window_posn + frame_todo;
    }
    if (frame_end > qtm->window_size) {
      frame_end = qtm->window_size;
    }
 
    while (window_posn < frame_end) {
      GET_SYMBOL(qtm->model7, selector);
      if (selector < 4) {
        /* literal byte */
        struct qtmd_model *mdl = (selector == 0) ? &qtm->model0 :
                                ((selector == 1) ? &qtm->model1 :
                                ((selector == 2) ? &qtm->model2 :
                                                   &qtm->model3));
        GET_SYMBOL((*mdl), sym);
        window[window_posn++] = sym;
        frame_todo--;
      }
      else {
        /* match repeated string */
        switch (selector) {
        case 4: /* selector 4 = fixed length match (3 bytes) */
          GET_SYMBOL(qtm->model4, sym);
          READ_MANY_BITS(extra, extra_bits[sym]);
          match_offset = position_base[sym] + extra + 1;
          match_length = 3;
          break;
 
        case 5: /* selector 5 = fixed length match (4 bytes) */
          GET_SYMBOL(qtm->model5, sym);
          READ_MANY_BITS(extra, extra_bits[sym]);
          match_offset = position_base[sym] + extra + 1;
          match_length = 4;
          break;
 
        case 6: /* selector 6 = variable length match */
          GET_SYMBOL(qtm->model6len, sym);
          READ_MANY_BITS(extra, length_extra[sym]);
          match_length = length_base[sym] + extra + 5;
 
          GET_SYMBOL(qtm->model6, sym);
          READ_MANY_BITS(extra, extra_bits[sym]);
          match_offset = position_base[sym] + extra + 1;
          break;
 
        default:
          /* should be impossible, model7 can only return 0-6 */
          D(("got %d from selector", selector))
          return qtm->error = MSPACK_ERR_DECRUNCH;
        }
 
        rundest = &window[window_posn];
        frame_todo -= match_length;
 
        /* does match destination wrap the window? This situation is possible
         * where the window size is less than the 32k frame size, but matches
         * must not go beyond a frame boundary */
        if ((window_posn + match_length) > qtm->window_size) {
          /* copy first part of match, before window end */
          i = qtm->window_size - window_posn;
          j = window_posn - match_offset;
          while (i--) *rundest++ = window[j++ & (qtm->window_size - 1)];
 
          /* flush currently stored data */
          i = (&window[qtm->window_size] - qtm->o_ptr);
 
          /* this should not happen, but if it does then this code
           * can't handle the situation (can't flush up to the end of
           * the window, but can't break out either because we haven't
           * finished writing the match). bail out in this case */
          if (i > out_bytes) {
            D(("during window-wrap match; %d bytes to flush but only need %d",
               i, (int) out_bytes))
            return qtm->error = MSPACK_ERR_DECRUNCH;
          }
          if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
            return qtm->error = MSPACK_ERR_WRITE;
          }
          out_bytes -= i;
          qtm->o_ptr = &window[0];
          qtm->o_end = &window[0]; 
 
          /* copy second part of match, after window wrap */
          rundest = &window[0];
          i = match_length - (qtm->window_size - window_posn);
          while (i--) *rundest++ = window[j++ & (qtm->window_size - 1)];
          window_posn = window_posn + match_length - qtm->window_size;
 
          break; /* because "window_posn < frame_end" has now failed */
        }
        else {
          /* normal match - output won't wrap window or frame end */
          i = match_length;
 
          /* does match _offset_ wrap the window? */
          if (match_offset > window_posn) {
            /* j = length from match offset to end of window */
            j = match_offset - window_posn;
            if (j > (int) qtm->window_size) {
              D(("match offset beyond window boundaries"))
              return qtm->error = MSPACK_ERR_DECRUNCH;
            }
            runsrc = &window[qtm->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++;
          }
          window_posn += match_length;
        }
      } /* if (window_posn+match_length > frame_end) */
    } /* while (window_posn < frame_end) */
 
    qtm->o_end = &window[window_posn];
 
   /* if we subtracted too much from frame_todo, it will
    * wrap around past zero and go above its max value */
   if (frame_todo > QTM_FRAME_SIZE) {
     D(("overshot frame alignment"))
     return qtm->error = MSPACK_ERR_DECRUNCH;
   }
 
    /* another frame completed? */
    if (frame_todo == 0) {
      /* re-align input */
      if (bits_left & 7) REMOVE_BITS(bits_left & 7);
 
      /* special Quantum hack -- cabd.c injects a trailer byte to allow the
       * decompressor to realign itself. CAB Quantum blocks, unlike LZX
       * blocks, can have anything from 0 to 4 trailing null bytes. */
      do { READ_BITS(i, 8); } while (i != 0xFF);
 
      qtm->header_read = 0;
 
      frame_todo = QTM_FRAME_SIZE;
    }
 
    /* window wrap? */
    if (window_posn == qtm->window_size) {
      /* flush all currently stored data */
      i = (qtm->o_end - qtm->o_ptr);
      /* break out if we have more than enough to finish this request */
      if (i >= out_bytes) break;
      if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
        return qtm->error = MSPACK_ERR_WRITE;
      }
      out_bytes -= i;
      qtm->o_ptr = &window[0];
      qtm->o_end = &window[0]; 
      window_posn = 0;
   }
 
  } /* while (more bytes needed) */
 
  if (out_bytes) {
    i = (int) out_bytes;
    if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
      return qtm->error = MSPACK_ERR_WRITE;
    }
    qtm->o_ptr += i;
  }
 
  /* store local state */
 
  STORE_BITS;
  qtm->window_posn = window_posn;
  qtm->frame_todo = frame_todo;
  qtm->H = H;
  qtm->L = L;
  qtm->C = C;
 
  return MSPACK_ERR_OK;
}

qtmd_free()

void qtmd_free

(

struct qtmd_stream *

qtm

)

Definition at line 482 of file qtmd.c.

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

qtmd_init()

struct qtmd_stream* qtmd_init	(	struct mspack_system *	system,
		struct mspack_file *	input,
		struct mspack_file *	output,
		int	window_bits,
		int	input_buffer_size
	)

Definition at line 186 of file qtmd.c.

{
  unsigned int window_size = 1 << window_bits;
  struct qtmd_stream *qtm;
  int i;
 
  if (!system) return NULL;
 
  /* Quantum supports window sizes of 2^10 (1Kb) through 2^21 (2Mb) */
  if (window_bits < 10 || window_bits > 21) 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 (!(qtm = (struct qtmd_stream *) system->alloc(system, sizeof(struct qtmd_stream)))) {
    return NULL;
  }
 
  /* allocate decompression window and input buffer */
  qtm->window = (unsigned char *) system->alloc(system, (size_t) window_size);
  qtm->inbuf  = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
  if (!qtm->window || !qtm->inbuf) {
    system->free(qtm->window);
    system->free(qtm->inbuf);
    system->free(qtm);
    return NULL;
  }
 
  /* initialise decompression state */
  qtm->sys         = system;
  qtm->input       = input;
  qtm->output      = output;
  qtm->inbuf_size  = input_buffer_size;
  qtm->window_size = window_size;
  qtm->window_posn = 0;
  qtm->frame_todo  = QTM_FRAME_SIZE;
  qtm->header_read = 0;
  qtm->error       = MSPACK_ERR_OK;
 
  qtm->i_ptr = qtm->i_end = &qtm->inbuf[0];
  qtm->o_ptr = qtm->o_end = &qtm->window[0];
  qtm->input_end = 0;
  qtm->bits_left = 0;
  qtm->bit_buffer = 0;
 
  /* initialise arithmetic coding models
   * - model 4    depends on window size, ranges from 20 to 24
   * - model 5    depends on window size, ranges from 20 to 36
   * - model 6pos depends on window size, ranges from 20 to 42
   */
  i = window_bits * 2;
  qtmd_init_model(&qtm->model0,    &qtm->m0sym[0],   0, 64);
  qtmd_init_model(&qtm->model1,    &qtm->m1sym[0],  64, 64);
  qtmd_init_model(&qtm->model2,    &qtm->m2sym[0], 128, 64);
  qtmd_init_model(&qtm->model3,    &qtm->m3sym[0], 192, 64);
  qtmd_init_model(&qtm->model4,    &qtm->m4sym[0],   0, (i > 24) ? 24 : i);
  qtmd_init_model(&qtm->model5,    &qtm->m5sym[0],   0, (i > 36) ? 36 : i);
  qtmd_init_model(&qtm->model6,    &qtm->m6sym[0],   0, i);
  qtmd_init_model(&qtm->model6len, &qtm->m6lsym[0],  0, 27);
  qtmd_init_model(&qtm->model7,    &qtm->m7sym[0],   0, 7);
 
  /* all ok */
  return qtm;
}

qtmd_init_model()

static void qtmd_init_model ( struct qtmd_model *  model, struct qtmd_modelsym *  syms, int  start, int  len  )

static

Definition at line 168 of file qtmd.c.

{
  int i;
 
  model->shiftsleft = 4;
  model->entries    = len;
  model->syms       = syms;
 
  for (i = 0; i <= len; i++) {
    syms[i].sym     = start + i; /* actual symbol */
    syms[i].cumfreq = len - i;   /* current frequency of that symbol */
  }
}

References qtmd_modelsym::cumfreq, qtmd_model::entries, i, len, qtmd_model::shiftsleft, start, qtmd_modelsym::sym, and qtmd_model::syms.

Referenced by qtmd_init().

qtmd_update_model()

static void qtmd_update_model ( struct qtmd_model *  model )

static

Definition at line 124 of file qtmd.c.

                                                        {
  struct qtmd_modelsym tmp;
  int i, j;
 
  if (--model->shiftsleft) {
    for (i = model->entries - 1; i >= 0; i--) {
      /* -1, not -2; the 0 entry saves this */
      model->syms[i].cumfreq >>= 1;
      if (model->syms[i].cumfreq <= model->syms[i+1].cumfreq) {
        model->syms[i].cumfreq = model->syms[i+1].cumfreq + 1;
      }
    }
  }
  else {
    model->shiftsleft = 50;
    for (i = 0; i < model->entries; i++) {
      /* no -1, want to include the 0 entry */
      /* this converts cumfreqs into frequencies, then shifts right */
      model->syms[i].cumfreq -= model->syms[i+1].cumfreq;
      model->syms[i].cumfreq++; /* avoid losing things entirely */
      model->syms[i].cumfreq >>= 1;
    }
 
    /* now sort by frequencies, decreasing order -- this must be an
     * inplace selection sort, or a sort with the same (in)stability
     * characteristics */
    for (i = 0; i < model->entries - 1; i++) {
      for (j = i + 1; j < model->entries; j++) {
        if (model->syms[i].cumfreq < model->syms[j].cumfreq) {
          tmp = model->syms[i];
          model->syms[i] = model->syms[j];
          model->syms[j] = tmp;
        }
      }
    }
 
    /* then convert frequencies back to cumfreq */
    for (i = model->entries - 1; i >= 0; i--) {
      model->syms[i].cumfreq += model->syms[i+1].cumfreq;
    }
  }
}

References qtmd_modelsym::cumfreq, qtmd_model::entries, i, qtmd_model::shiftsleft, qtmd_model::syms, and autogen_x86imm::tmp.

Variable Documentation

extra_bits

const unsigned char extra_bits[42]

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, 17, 17, 18, 18, 19, 19
}

Definition at line 71 of file qtmd.c.

Referenced by qtmd_decompress().

length_base

const unsigned char length_base[27]

static

Initial value:

= {
  0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 14, 18, 22, 26,
  30, 38, 46, 54, 62, 78, 94, 110, 126, 158, 190, 222, 254
}

Definition at line 75 of file qtmd.c.

Referenced by qtmd_decompress().

length_extra

const unsigned char length_extra[27]

static

Initial value:

= {
  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
  3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
}

Definition at line 79 of file qtmd.c.

Referenced by qtmd_decompress().

position_base

const unsigned int position_base[42]

static

Initial value:

= {
  0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
  1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576, 32768, 49152,
  65536, 98304, 131072, 196608, 262144, 393216, 524288, 786432, 1048576, 1572864
}

Definition at line 66 of file qtmd.c.

Referenced by qtmd_decompress().