hits_compress.cpp File Reference

#include <stdio.h>
#include <assert.h>
#include "midas.h"
#include "mucap_compress.h"
#include "mucap_structures.h"

Go to the source code of this file.

Functions
void	hits_optimize ()
void	hits_load ()
int	encode_hits (channel_hit *input, int input_size, io_buffer *output, int *uncompressed_size_p)
int	hits_compress (channel_hit *input, int input_size, unsigned char *output, int userParam)
void	decode_hits (io_buffer *input, channel_hit *output)
int	hits_expand (unsigned char *input, int input_size, channel_hit *output, int userParam)

Variables
huffman_table	hits_parameter_huffman
BOOL	should_compress_hits = TRUE

Function Documentation

void decode_hits	(	io_buffer *	input,
		channel_hit *	output
	)

Definition at line 106 of file hits_compress.cpp.

References huffman_get_symbol(), i, io_buffer_get(), parameter, channel_hit::parameter, and channel_hit::time.

Referenced by hits_expand().

{
  int prev_time = 0;
  int prev_parameter = 0;

  int i = 0;
  while (1) {

    int parameter = 0;
    int parameter_diff = huffman_get_symbol(&hits_parameter_huffman, input);
    if (parameter_diff < 0) {
      break;
    } else if(parameter_diff == 0) {
      parameter = io_buffer_get(input, 13);
    } else {
      parameter = prev_parameter + parameter_diff - 161;
    }
    output[i].parameter = parameter;

    int time_length_flag1 = io_buffer_get(input, 1);
    int time_diff;
    if (time_length_flag1 == 0) {
        time_diff = io_buffer_get(input, 6);
    } else {
        int time_length_flag2 = io_buffer_get(input, 1);
        if (time_length_flag2 == 0) {
          time_diff = io_buffer_get(input, 12);
        } else {
          time_diff = io_buffer_get(input, 29);
        }
    }

    output[i].time = (prev_time + time_diff) * 1.25;
    prev_time = prev_time + time_diff;
    prev_parameter = parameter;

    //printf("par %d time %f\n", output[i].parameter, output[i].time);

    i++;
  }
}

int encode_hits	(	channel_hit *	input,
		int	input_size,
		io_buffer *	output,
		int *	uncompressed_size_p
	)

Definition at line 34 of file hits_compress.cpp.

References flush_output_buffer(), huffman_put_symbol(), i, io_buffer_put(), parameter, channel_hit::parameter, and time.

Referenced by hits_compress().

{
  int prev_time = 0;
  int prev_parameter = 0;

  for (int i = 0; i < input_size; i++) {
    //printf("par %d time %f\n", input[i].parameter, input[i].time);

    int parameter = input[i].parameter;
    int parameter_diff = parameter - prev_parameter + 161;
    if(parameter_diff <= 0 || parameter_diff >= 322) {
      parameter_diff = 0;
    }
    huffman_put_symbol(&hits_parameter_huffman, output, parameter_diff);
    if(parameter_diff == 0) {
      io_buffer_put(output, parameter, 13);      
    }

    int time = (int) ((input[i].time+0.01)/1.25);
    int time_diff = time - prev_time;
    assert (time_diff >= 0);

    if (time_diff < 64) {
        io_buffer_put(output, 0, 1);
        io_buffer_put(output, time_diff & 0x3f, 6);
    } else if (time_diff < 4096) {
        io_buffer_put(output, 2, 2);
        io_buffer_put(output, time_diff & 0xfff, 12);
    } else {
        io_buffer_put(output, 3, 2);
        io_buffer_put(output, time_diff, 29);
    }

    prev_time = time;
    prev_parameter = parameter;
  }

  *uncompressed_size_p = input_size;

  return flush_output_buffer(output);
}

int hits_compress	(	channel_hit *	input,
		int	input_size,
		unsigned char *	output,
		int	userParam
	)

Definition at line 77 of file hits_compress.cpp.

References encode_hits(), rle_bits_setup(), and start_output_buffer().

Referenced by compress_event_skim().

{
  input_size /= sizeof(channel_hit);

  rle_bits_setup();

  io_buffer output_buffer;

  // reserve space for size of uncompressed data (may be different from
  // input size, since some hits may be stripped)
  int *uncompressed_size_p = (int *) output;
  output += sizeof(int);

  // reserve space for the size of the compressed data
  int *compressed_time_size_p = (int *) output;
  output += sizeof(int);

  // compress times
  start_output_buffer(&output_buffer, output);
  int compressed_time_size =
      encode_hits(input, input_size, &output_buffer, uncompressed_size_p);
  output += compressed_time_size;

  // store size of compressed times
  *compressed_time_size_p = compressed_time_size;

  return compressed_time_size + 2 * sizeof(int);
}

int hits_expand	(	unsigned char *	input,
		int	input_size,
		channel_hit *	output,
		int	userParam
	)

Definition at line 148 of file hits_compress.cpp.

References decode_hits(), rle_bits_setup(), and start_input_buffer().

Referenced by expand_event().

{
  // 
  // Uncompress the data produced by hits_compress().
  // 

  rle_bits_setup();

  // Get uncompressed data size
  int *uncompressed_size_p = (int *) input;
  int uncompressed_size = *uncompressed_size_p;
  input += sizeof(int);
  input_size -= sizeof(int);

  // Get size of compressed time data
  int *compressed_time_size_p = (int *) input;
  int compressed_time_size = *compressed_time_size_p;
  input += sizeof(int);
  input_size -= sizeof(int);

  // Uncompress times
  io_buffer input_buffer;
  start_input_buffer(&input_buffer, input);
  decode_hits(&input_buffer, output);
  input += compressed_time_size;
  input_size -= compressed_time_size;

  return uncompressed_size * sizeof(channel_hit);
}

void hits_load

(

)

Definition at line 24 of file hits_compress.cpp.

References hDB, huffman_init_default(), load_huffman(), should_compress_hits, size, and TRUE.

Referenced by compress_load_all().

{
  huffman_init_default(&hits_parameter_huffman, 322);
  load_huffman("/Compression/Lossless/HITS/Huffman/Parameter", &hits_parameter_huffman);

  int size = sizeof(BOOL);
  db_get_value(hDB, 0, "/Compression/Lossless/HITS/Enabled", &should_compress_hits, 
    &size, TID_BOOL, TRUE);
}

void hits_optimize

(

)

Definition at line 18 of file hits_compress.cpp.

References huffman_optimize_tree(), and save_huffman().

Referenced by compress_optimize_skim().

{
  huffman_optimize_tree(&hits_parameter_huffman);
  save_huffman("/Compression/Lossless/HITS/Huffman/Parameter", &hits_parameter_huffman);
}

Variable Documentation

huffman_table hits_parameter_huffman

Definition at line 15 of file hits_compress.cpp.

BOOL should_compress_hits = TRUE

Definition at line 16 of file hits_compress.cpp.

Referenced by hits_load().