lzx_compress.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	lzx_results

Typedefs
typedef struct lzx_data	lzx_data
typedef int(*	lzx_get_bytes_t) (void *arg, int n, void *buf)
typedef int(*	lzx_put_bytes_t) (void *arg, int n, void *buf)
typedef void(*	lzx_mark_frame_t) (void *arg, uint32_t uncomp, uint32_t comp)
typedef int(*	lzx_at_eof_t) (void *arg)
typedef struct lzx_results	lzx_results

Functions
int	lzx_init (struct lzx_data **lzxdp, int wsize_code, lzx_get_bytes_t get_bytes, void *get_bytes_arg, lzx_at_eof_t at_eof, lzx_put_bytes_t put_bytes, void *put_bytes_arg, lzx_mark_frame_t mark_frame, void *mark_frame_arg)
void	lzx_reset (lzx_data *lzxd)
int	lzx_compress_block (lzx_data *lzxd, int block_size, int subdivide)
int	lzx_finish (struct lzx_data *lzxd, struct lzx_results *lzxr)

Typedef Documentation

lzx_at_eof_t

typedef int(* lzx_at_eof_t) (void *arg)

Definition at line 22 of file lzx_compress.h.

lzx_data

typedef struct lzx_data lzx_data

Definition at line 18 of file lzx_compress.h.

lzx_get_bytes_t

typedef int(* lzx_get_bytes_t) (void *arg, int n, void *buf)

Definition at line 19 of file lzx_compress.h.

lzx_mark_frame_t

typedef void(* lzx_mark_frame_t) (void *arg, uint32_t uncomp, uint32_t comp)

Definition at line 21 of file lzx_compress.h.

lzx_put_bytes_t

typedef int(* lzx_put_bytes_t) (void *arg, int n, void *buf)

Definition at line 20 of file lzx_compress.h.

lzx_results

typedef struct lzx_results lzx_results

Function Documentation

lzx_compress_block()

int lzx_compress_block	(	lzx_data *	lzxd,
		int	block_size,
		int	subdivide
	)

Definition at line 1062 of file lzx_layer.c.

{
  int i;
  uint32_t written_sofar = 0;
  int block_type;
  long uncomp_bits;
  long comp_bits;
  long comp_bits_ovh;
  long uncomp_length;
 
  if ((lzxd->block_size != block_size) || (lzxd->block_codes == NULL)) {
    if (lzxd->block_codes != NULL) free(lzxd->block_codes);
    lzxd->block_size = block_size;
    lzxd->block_codes =  malloc(block_size * sizeof(uint32_t));
  }
  lzxd->subdivide = subdivide?1:0;
 
  lzxd->left_in_block = block_size;
  lzxd->left_in_frame = LZX_FRAME_SIZE;
  lzxd->main_entropy = 0.0;
  lzxd->last_ratio = 9999999.0;
  lzxd->block_codesp = lzxd->block_codes;
 
  memset(lzxd->length_freq_table, 0, NUM_SECONDARY_LENGTHS * sizeof(int));
  memset(lzxd->main_freq_table, 0, lzxd->main_tree_size * sizeof(int));
  memset(lzxd->aligned_freq_table, 0, LZX_ALIGNED_SIZE * sizeof(int));
  do {
    lz_compress(lzxd->lzi, lzxd->left_in_block);
    if (lzxd->left_in_frame == 0)
      lzxd->left_in_frame = LZX_FRAME_SIZE;
 
    if ((lzxd->subdivide<0) || !lzxd->left_in_block ||
    (!lz_left_to_process(lzxd->lzi) && lzxd->at_eof(lzxd->in_arg))) {
      /* now one block is LZ-analyzed. */
      /* time to write it out */
      uncomp_length = lzxd->block_size - lzxd->left_in_block - written_sofar;
      /* uncomp_length will sometimes be 0 when input length is
     an exact multiple of frame size */
      if (uncomp_length == 0)
      continue;
      if (lzxd->subdivide < 0) {
#ifdef DEBUG_ENTROPY
    fprintf(stderr, "subdivided\n");
#endif
    lzxd->subdivide = 1;
      }
 
      if (lzxd->need_1bit_header) {
    /* one bit Intel preprocessing header */
    /* always 0 because this implementation doesn't do Intel preprocessing */
    lzx_write_bits(lzxd, 1, 0);
    lzxd->need_1bit_header = 0;
      }
 
      /* handle extra bits */
      uncomp_bits = comp_bits = 0;
      build_huffman_tree(LZX_ALIGNED_SIZE, 7, lzxd->aligned_freq_table, lzxd->aligned_tree);
      for (i = 0; i < LZX_ALIGNED_SIZE; i++) {
    uncomp_bits += lzxd->aligned_freq_table[i]* 3;
    comp_bits += lzxd->aligned_freq_table[i]* lzxd->aligned_tree[i].codelength;
      }
      comp_bits_ovh = comp_bits + LZX_ALIGNED_SIZE * 3;
      if (comp_bits_ovh < uncomp_bits)
        block_type = LZX_ALIGNED_OFFSET_BLOCK;
      else
    block_type = LZX_VERBATIM_BLOCK;
 
#ifdef DEBUG_EXTRA_BITS
      fprintf(stderr, "Extra bits uncompressed: %5d  compressed:  %5d  compressed w/overhead %5d gain/loss %5d\n", uncomp_bits, comp_bits, comp_bits_ovh, uncomp_bits - comp_bits_ovh);
#endif
 
      /* block type */
      lzx_write_bits(lzxd, 3, block_type);
      /* uncompressed length */
      lzx_write_bits(lzxd, 24, uncomp_length);
 
      written_sofar = lzxd->block_size - lzxd->left_in_block;
 
      /* now write out the aligned offset trees if present */
      if (block_type == LZX_ALIGNED_OFFSET_BLOCK) {
    for (i = 0; i < LZX_ALIGNED_SIZE; i++) {
      lzx_write_bits(lzxd, 3, lzxd->aligned_tree[i].codelength);
    }
      }
      /* end extra bits */
      build_huffman_tree(lzxd->main_tree_size, LZX_MAX_CODE_LENGTH,
             lzxd->main_freq_table, lzxd->main_tree);
      build_huffman_tree(NUM_SECONDARY_LENGTHS, 16,
             lzxd->length_freq_table, lzxd->length_tree);
 
 
 
      /* now write the pre-tree and tree for main 1 */
      lzx_write_compressed_tree(lzxd, lzxd->main_tree, lzxd->prev_main_treelengths, NUM_CHARS);
 
      /* now write the pre-tree and tree for main 2*/
      lzx_write_compressed_tree(lzxd, lzxd->main_tree + NUM_CHARS,
                lzxd->prev_main_treelengths + NUM_CHARS,
                lzxd->main_tree_size - NUM_CHARS);
 
      /* now write the pre tree and tree for length */
      lzx_write_compressed_tree(lzxd, lzxd->length_tree, lzxd->prev_length_treelengths,
                NUM_SECONDARY_LENGTHS);
 
      /* now write literals */
      lzx_write_compressed_literals(lzxd, block_type);
 
      /* copy treelengths somewhere safe to do delta compression */
      for (i = 0; i < lzxd->main_tree_size; i++) {
    lzxd->prev_main_treelengths[i] = lzxd->main_tree[i].codelength;
      }
      for (i = 0; i < NUM_SECONDARY_LENGTHS; i++) {
    lzxd->prev_length_treelengths[i] = lzxd->length_tree[i].codelength;
      }
      lzxd->main_entropy = 0.0;
      lzxd->last_ratio = 9999999.0;
      lzxd->block_codesp = lzxd->block_codes;
 
      memset(lzxd->length_freq_table, 0, NUM_SECONDARY_LENGTHS * sizeof(int));
      memset(lzxd->main_freq_table, 0, lzxd->main_tree_size * sizeof(int));
      memset(lzxd->aligned_freq_table, 0, LZX_ALIGNED_SIZE * sizeof(int));
    }
  }
  while (lzxd->left_in_block && (lz_left_to_process(lzxd->lzi) || !lzxd->at_eof(lzxd->in_arg)));
  return 0;
}

Referenced by chmc_crunch_lzx().

lzx_finish()

int lzx_finish	(	struct lzx_data *	lzxd,
		struct lzx_results *	lzxr
	)

Definition at line 1236 of file lzx_layer.c.

{
  /*  lzx_align_output(lzxd);  Not needed as long as frame padding is in place */
  if (lzxr) {
    lzxr->len_compressed_output = lzxd->len_compressed_output;
    lzxr->len_uncompressed_input = lzxd->len_uncompressed_input;
  }
  lz_release(lzxd->lzi);
  free(lzxd->lzi);
  free(lzxd->prev_main_treelengths);
  free(lzxd->main_tree);
  free(lzxd->main_freq_table);
  free(lzxd);
  return 0;
}

Referenced by chmc_crunch_lzx().

lzx_init()

int lzx_init	(	struct lzx_data **	lzxdp,
		int	wsize_code,
		lzx_get_bytes_t	get_bytes,
		void *	get_bytes_arg,
		lzx_at_eof_t	at_eof,
		lzx_put_bytes_t	put_bytes,
		void *	put_bytes_arg,
		lzx_mark_frame_t	mark_frame,
		void *	mark_frame_arg
	)

Definition at line 1189 of file lzx_layer.c.

{
  int wsize;
  struct lzx_data *lzxd;
 
  if ((wsize_code < 15) || (wsize_code > 21)) {
    return -1;
  }
  lzx_init_static();
 
  *lzxdp = lzxd = malloc(sizeof(*lzxd));
  if (lzxd == 0)
    return -2;
 
  lzxd->in_arg = get_bytes_arg;
  lzxd->out_arg = put_bytes_arg;
  lzxd->mark_frame_arg = mark_frame_arg;
  lzxd->get_bytes = get_bytes;
  lzxd->put_bytes = put_bytes;
  lzxd->at_eof = at_eof;
  lzxd->mark_frame = mark_frame;
 
  wsize = 1 << (wsize_code);
 
  lzxd->bits_in_buf = 0;
  lzxd->block_codes = NULL;
  lzxd->num_position_slots = num_position_slots[wsize_code-15];
  lzxd->main_tree_size = (NUM_CHARS + 8 * lzxd->num_position_slots);
 
  lzxd->main_freq_table = malloc(sizeof(int) * lzxd->main_tree_size);
  lzxd->main_tree = malloc(sizeof(huff_entry)* lzxd->main_tree_size);
  lzxd->prev_main_treelengths = malloc(sizeof(uint8_t)*lzxd->main_tree_size);
 
  lzxd->lzi = malloc(sizeof (*lzxd->lzi));
  /* the -3 prevents matches at wsize, wsize-1, wsize-2, all of which are illegal */
  lz_init(lzxd->lzi, wsize, wsize - 3, MAX_MATCH, MIN_MATCH, LZX_FRAME_SIZE,
      lzx_get_chars, lzx_output_match, lzx_output_literal,lzxd);
  lzxd->len_uncompressed_input = 0;
  lzxd->len_compressed_output = 0;
  lzx_reset(lzxd);
  return 0;
}

Referenced by chmc_crunch_lzx().

lzx_reset()

void lzx_reset

(

lzx_data *

lzxd

)

Definition at line 1053 of file lzx_layer.c.

{
  lzxd->need_1bit_header = 1;
  lzxd->R0 = lzxd->R1 = lzxd->R2 = 1;
  memset(lzxd->prev_main_treelengths, 0, lzxd->main_tree_size * sizeof(uint8_t));
  memset(lzxd->prev_length_treelengths, 0, NUM_SECONDARY_LENGTHS * sizeof(uint8_t));
  lz_reset(lzxd->lzi);
}

Referenced by chmc_crunch_lzx(), and lzx_init().