src/statichuff/statichuff.h

   1
   2 #ifndef _STATICHUFF_H_
   3 #define _STATICHUFF_H_
   4
   5 #include <stdio.h>
   6 #include <unistd.h>
   7 #include "../vfile/vfile.h"
   8
   9 /** \file
  10  * Compresor Huffman Estático
  11  *
  12  * <b>Interfaz del compresor Huffman Estático</b>
  13  *
  14  * El siguiente compresor permite la compresión/descompresión estadística de un
  15  * archivo o bien chunks de datos. Posee tambien como feature opcional, el grabado
  16  * y carga de un modelo estadístico (Tabla de Frecuencias), conocido como Huffman Canonico.
  17  *
  18  */
  19
  20 /** Tipo que representa una frecuencia de un símbolo */
  21 typedef unsigned long int t_freq;
  22
  23 /** Estructura que representa un nodo de un árbol y/o inputlist de huffman */
  24 typedef struct t_freqnode {
  25         unsigned short int symbol; /**< Símbolo que representa el nodo */
  26         t_freq freq; /**< Frecuencia del nodo */
  27         struct t_freqnode *lchild; /**< Hijo izquierdo del nodo */
  28         struct t_freqnode *rchild; /**< Hijo derecho del nodo */
  29 } SHUFFNODE;
  30
  31 /** Estructura que representa un código prefijo generado con el árbol de huffman */
  32 typedef struct t_code {
  33         unsigned long int code; /**< Codigo prefijo de algún símbolo */
  34         unsigned char codelength; /**< Longitud en bits del código prefijo */
  35 } SHUFFCODE;
  36
  37 /** Estructura que representa el estado del compresor Huffman Estático */
  38 typedef struct t_huff {
  39         FILE *coderfp; /**< FPointer usado en el coder de bychunk para el temp */
  40         VFILE *decoderfp; /**< FPointer al archivo a descomrimir */
  41         char *sourcefile; /**< Nombre del archivo a comprimir o a descomprimir */
  42         char *targetfile; /**< Nombre del archivo comprimido o descomprimido */
  43         long volsize; /**< Tamanio de volumen para multivol */
  44         char bychunk; /**< 0 works byfile, 1 works bychunk */
  45         char canonic; /**< 1 Huffman Canonico con preloaded freqtable */
  46         t_freq *freqtable; /**< Tabla de frecuencias */
  47         t_freq sumfreq; /**< Frecuencia total acumulada */
  48         SHUFFNODE *codetree; /**< Puntero al arbol de codigos prefijos */
  49         unsigned long int bytesleft; /**< Cuanto falta descomprimir en un bychunk */
  50         unsigned long int codebuffer; /**< Buffer de descompresion para bychunk */
  51         int bitsleft; /**< Posicion en el buffer de descompresion para bychunk */
  52 } HUFF_STATE;
  53
  54 /** Crea una estructura <em>HUFF_STATE<em> y la inicializa para utilizarla
  55  * para comprimir archivos.
  56  *
  57  * \param inputfile Archivo a comprimir.
  58  * \param outputfile Archivo destino de la compresión.
  59  * \param volsize Size del volumen en caso de compresión multivolumen.
  60  * \return \b HUFF_STATE* Puntero a estructura creada e inicializada.
  61  */
  62 HUFF_STATE *shuff_init_encoder_byfile(char *inputfile, char *outputfile, long volsize);
  63
  64 /** Crea una estructura <em>HUFF_STATE<em> y la inicializa para utilizarla
  65  * para comprimir una secuencia de chunks de datos.
  66  *
  67  * \param outputfile Archivo destino de la compresión.
  68  * \param volsize Size del volumen en caso de compresión multivolumen.
  69  * \return \b HUFF_STATE* Puntero a estructura creada e inicializada.
  70  */
  71 HUFF_STATE *shuff_init_encoder_bychunk(char *outputfile, long volsize);
  72
  73 /** Crea una estructura <em>HUFF_STATE<em> y la inicializa para utilizarla
  74  * en la descompresión de un archivo.
  75  *
  76  * \param inputfile Archivo a descomprimir.
  77  * \param outputfile Archivo destino de la descompresión.
  78  * \return \b HUFF_STATE* Puntero a estructura creada e inicializada.
  79  */
  80 HUFF_STATE *shuff_init_decoder(char *inputfile, char *outputfile);
  81
  82 /** Desinicializa el compresor Huffman, cerrando files y liberando memoria.
  83  *
  84  * \param shuff Puntero a la estructura usada para el estado del compresor.
  85  */
  86 void shuff_deinit_encoder(HUFF_STATE *shuff);
  87
  88 /** Desinicializa el compresor Huffman, cerrando files y liberando memoria.
  89  *
  90  * \param shuff Puntero a la estructura usada para el estado del compresor.
  91  */
  92 void shuff_deinit_decoder(HUFF_STATE *shuff);
  93
  94 /** Ejecuta la compresión de un archivo previamente indicado a través de
  95  * las rutinas de inicializacion de Huffman.
  96  *
  97  * \param shuff Puntero a la estructura usada para el estado del compresor.
  98  * \return \b int Indica éxito de la operacion. (1 Exito, 0 Error)
  99  */
 100 int shuff_encode_file(HUFF_STATE *shuff);
 101
 102 /** Ejecuta la descompresión de un archivo previamente indicado a través de
 103  * las rutinas de inicializacion de Huffman.
 104  *
 105  * \param shuff Puntero a la estructura usada para el estado del compresor.
 106  * \return \b int Indica éxito de la operacion. (1 Exito, 0 Error)
 107  */
 108 int shuff_decode_file(HUFF_STATE *shuff);
 109
 110 /** Recibe un chunk de datos y analiza la frecuencia de sus caracteres
 111  * actualizando el modelo de frecuencias en consecuencia.
 112  *
 113  * \param chunkshuff Puntero a la estructura usada para el estado del compresor.
 114  * \param chunk Puntero al chunk de datos.
 115  * \param chunksize Size del chunk de datos.
 116  * \return \b int Indica éxito de la operacion. (1 Exito, 0 Error)
 117  */
 118 int shuff_scanfreq_chunk(HUFF_STATE *shuff, char* chunk, int chunksize);
 119
 120 /** Descomprime un chunk de datos cuyo size es especificado en la rutina.
 121  *
 122  * \param shuff Puntero a la estructura usada para el estado del compresor.
 123  * \param chunk Puntero al buffer donde se decodificara el chunk.
 124  * \param chunksize Size del buffer o chunk que se quiere obtener.
 125  * \return \b int Indica si hay mas datos a descomprimir o no (1 hay, 0 no hay)
 126  */
 127 int shuff_decode_chunk(HUFF_STATE *shuff, char *chunk, int chunksize, unsigned long int *decodedbytes);
 128
 129 /** Graba el modelo de un archivo que se ha comprimido. (Tabla de Freq)
 130  *
 131  * \param shuff Puntero a la estructura usada para el estado del compresor.
 132  * \return \b int Indica éxito de la operación. (1 Exito, 0 Error);
 133  */
 134 int shuff_savemodel(HUFF_STATE *shuff);
 135
 136 /** Carga un modelo de huffman (Tabla de Freq) para ser usando en Huff Canonico
 137  *
 138  * \param shuff Puntero a la estructura usada para el estado del compresor.
 139  * \param modelfile Nombre del archivo que posee el modelo a cargar.
 140  * \return \b int Indica éxito de la operación. (1 Exito, 0 Error);
 141  */
 142 int shuff_loadmodel(HUFF_STATE *shuff, char *modelfile);
 143
 144 #endif /* _STATICHUFF_H_ */