src/statichuff/statichuff.h

   1 /*----------------------------------------------------------------------------
   2  *                   jacu - Just Another Compression Utility
   3  *----------------------------------------------------------------------------
   4  * This file is part of jacu.
   5  *
   6  * jacu is free software; you can redistribute it and/or modify it under the
   7  * terms of the GNU General Public License as published by the Free Software
   8  * Foundation; either version 2 of the License, or (at your option) any later
   9  * version.
  10  *
  11  * jacu is distributed in the hope that it will be useful, but WITHOUT ANY
  12  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  14  * details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with jacu; if not, write to the Free Software Foundation, Inc., 59 Temple
  18  * Place, Suite 330, Boston, MA  02111-1307  USA
  19  *----------------------------------------------------------------------------
  20  */
  21
  22
  23 #ifndef _STATICHUFF_H_
  24 #define _STATICHUFF_H_
  25
  26 #include <stdio.h>
  27 #include <unistd.h>
  28 #include "../vfile/vfile.h"
  29
  30 /** \file
  31  * Compresor Huffman Estático
  32  *
  33  * <b>Interfaz del compresor Huffman Estático</b>
  34  *
  35  * El siguiente compresor permite la compresión/descompresión estadística de un
  36  * archivo o bien chunks de datos. Posee tambien como feature opcional, el grabado
  37  * y carga de un modelo estadístico (Tabla de Frecuencias), conocido como Huffman Canonico.
  38  *
  39  */
  40
  41 /** Tipo que representa una frecuencia de un símbolo */
  42 typedef unsigned long int t_freq;
  43
  44 /** Estructura que representa un nodo de un árbol y/o inputlist de huffman */
  45 typedef struct t_freqnode {
  46         unsigned short int symbol; /**< Símbolo que representa el nodo */
  47         t_freq freq; /**< Frecuencia del nodo */
  48         struct t_freqnode *lchild; /**< Hijo izquierdo del nodo */
  49         struct t_freqnode *rchild; /**< Hijo derecho del nodo */
  50 } SHUFFNODE;
  51
  52 /** Estructura que representa un código prefijo generado con el árbol de huffman */
  53 typedef struct t_code {
  54         unsigned long int code; /**< Codigo prefijo de algún símbolo */
  55         unsigned char codelength; /**< Longitud en bits del código prefijo */
  56 } SHUFFCODE;
  57
  58 /** Estructura que representa el estado del compresor Huffman Estático */
  59 typedef struct t_huff {
  60         FILE *coderfp; /**< FPointer usado en el coder de bychunk para el temp */
  61         VFILE *decoderfp; /**< FPointer al archivo a descomrimir */
  62         char *sourcefile; /**< Nombre del archivo a comprimir o a descomprimir */
  63         char *targetfile; /**< Nombre del archivo comprimido o descomprimido */
  64         long volsize; /**< Tamanio de volumen para multivol */
  65         char bychunk; /**< 0 works byfile, 1 works bychunk */
  66         char canonic; /**< 1 Huffman Canonico con preloaded freqtable */
  67         t_freq *freqtable; /**< Tabla de frecuencias */
  68         t_freq sumfreq; /**< Frecuencia total acumulada */
  69         SHUFFNODE *codetree; /**< Puntero al arbol de codigos prefijos */
  70         unsigned long int bytesleft; /**< Cuanto falta descomprimir en un bychunk */
  71         unsigned long int codebuffer; /**< Buffer de descompresion para bychunk */
  72         int bitsleft; /**< Posicion en el buffer de descompresion para bychunk */
  73 } HUFF_STATE;
  74
  75 /** Crea una estructura <em>HUFF_STATE<em> y la inicializa para utilizarla
  76  * para comprimir archivos.
  77  *
  78  * \param inputfile Archivo a comprimir.
  79  * \param outputfile Archivo destino de la compresión.
  80  * \param volsize Size del volumen en caso de compresión multivolumen.
  81  * \return \b HUFF_STATE* Puntero a estructura creada e inicializada.
  82  */
  83 HUFF_STATE *shuff_init_encoder_byfile(char *inputfile, char *outputfile, long volsize);
  84
  85 /** Crea una estructura <em>HUFF_STATE<em> y la inicializa para utilizarla
  86  * para comprimir una secuencia de chunks de datos.
  87  *
  88  * \param outputfile Archivo destino de la compresión.
  89  * \param volsize Size del volumen en caso de compresión multivolumen.
  90  * \return \b HUFF_STATE* Puntero a estructura creada e inicializada.
  91  */
  92 HUFF_STATE *shuff_init_encoder_bychunk(char *outputfile, long volsize);
  93
  94 /** Crea una estructura <em>HUFF_STATE<em> y la inicializa para utilizarla
  95  * en la descompresión de un archivo.
  96  *
  97  * \param inputfile Archivo a descomprimir.
  98  * \param outputfile Archivo destino de la descompresión.
  99  * \return \b HUFF_STATE* Puntero a estructura creada e inicializada.
 100  */
 101 HUFF_STATE *shuff_init_decoder(char *inputfile, char *outputfile);
 102
 103 /** Desinicializa el compresor Huffman, cerrando files y liberando memoria.
 104  *
 105  * \param shuff Puntero a la estructura usada para el estado del compresor.
 106  */
 107 void shuff_deinit_encoder(HUFF_STATE *shuff);
 108
 109 /** Desinicializa el compresor Huffman, cerrando files y liberando memoria.
 110  *
 111  * \param shuff Puntero a la estructura usada para el estado del compresor.
 112  */
 113 void shuff_deinit_decoder(HUFF_STATE *shuff);
 114
 115 /** Ejecuta la compresión de un archivo previamente indicado a través de
 116  * las rutinas de inicializacion de Huffman.
 117  *
 118  * \param shuff Puntero a la estructura usada para el estado del compresor.
 119  * \return \b int Indica éxito de la operacion. (1 Exito, 0 Error)
 120  */
 121 int shuff_encode_file(HUFF_STATE *shuff);
 122
 123 /** Ejecuta la descompresión de un archivo previamente indicado a través de
 124  * las rutinas de inicializacion de Huffman.
 125  *
 126  * \param shuff Puntero a la estructura usada para el estado del compresor.
 127  * \return \b int Indica éxito de la operacion. (1 Exito, 0 Error)
 128  */
 129 int shuff_decode_file(HUFF_STATE *shuff);
 130
 131 /** Recibe un chunk de datos y analiza la frecuencia de sus caracteres
 132  * actualizando el modelo de frecuencias en consecuencia.
 133  *
 134  * \param chunkshuff Puntero a la estructura usada para el estado del compresor.
 135  * \param chunk Puntero al chunk de datos.
 136  * \param chunksize Size del chunk de datos.
 137  * \return \b int Indica éxito de la operacion. (1 Exito, 0 Error)
 138  */
 139 int shuff_scanfreq_chunk(HUFF_STATE *shuff, char* chunk, int chunksize);
 140
 141 /** Descomprime un chunk de datos cuyo size es especificado en la rutina.
 142  *
 143  * \param shuff Puntero a la estructura usada para el estado del compresor.
 144  * \param chunk Puntero al buffer donde se decodificara el chunk.
 145  * \param chunksize Size del buffer o chunk que se quiere obtener.
 146  * \return \b int Indica si hay mas datos a descomprimir o no (1 hay, 0 no hay)
 147  */
 148 int shuff_decode_chunk(HUFF_STATE *shuff, char *chunk, int chunksize, unsigned long int *decodedbytes);
 149
 150 /** Graba el modelo de un archivo que se ha comprimido. (Tabla de Freq)
 151  *
 152  * \param shuff Puntero a la estructura usada para el estado del compresor.
 153  * \return \b int Indica éxito de la operación. (1 Exito, 0 Error);
 154  */
 155 int shuff_savemodel(HUFF_STATE *shuff);
 156
 157 /** Carga un modelo de huffman (Tabla de Freq) para ser usando en Huff Canonico
 158  *
 159  * \param shuff Puntero a la estructura usada para el estado del compresor.
 160  * \param modelfile Nombre del archivo que posee el modelo a cargar.
 161  * \return \b int Indica éxito de la operación. (1 Exito, 0 Error);
 162  */
 163 int shuff_loadmodel(HUFF_STATE *shuff, char *modelfile);
 164
 165 #endif /* _STATICHUFF_H_ */