Mini emprolijamiento.

diff --git a/src/jacu.c b/src/jacu.c
index 4171d02a879b2f2500df47d7f8da3f81e9707262..75ca87ccadfeccf070a53fdaf7b7194be5ed85f3 100644 (file)
--- a/src/jacu.c
+++ b/src/jacu.c
@@ -180,8 +180,8 @@ int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags
                        Uint32 len;
                        unsigned char buff[2];
                        Uint32 total_size = i + sizeof(Uint32);
-                       ZG zg;                          
-                       /* Guardo la salida del MTF con ceros agrupados (ZG) */                         
+                       ZG zg;
+                       /* Guardo la salida del MTF con ceros agrupados (ZG) */
                        zg_init(&zg);
                        for (j = 0; j < total_size; ++j)
                                if ((len = zg_group(&zg, buff, mtf[j])))
@@ -189,10 +189,10 @@ int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags
 
                                /* Flusheo ultimo zgrouping */
                                if ((len = zg_group_finish(&zg,buff)))
-                                       shuff_scanfreq_chunk(shuff, buff, len);                         
+                                       shuff_scanfreq_chunk(shuff, buff, len);
                } else {
-                       /* Comprimo la salida del MTF */                                
-                       shuff_scanfreq_chunk(shuff,mtf,i+sizeof(Uint32));                               
+                       /* Comprimo la salida del MTF */
+                       shuff_scanfreq_chunk(shuff,mtf,i+sizeof(Uint32));
                }
                free(mtf);
                free(z);
@@ -220,13 +220,12 @@ int descomprimir(char *src, char *dst)
 {
        /* Descomprimo */
        FILE *fp_out;
-       Uint32 block_size = 0,zgungrouped = 0, k;
+       Uint32 block_size = 0, k;
        unsigned char *block, *mtf, *orig;
-       unsigned char *z, *zgbuffer;
-       int zgmoved = 0,z_len=0,moredata = 0,decoded = 0;
-       unsigned char use_zg = 0,zgbyte = 0,retbytes = 0;
+       unsigned char *z;
+       int z_len=0,moredata = 0,decoded = 0;
+       unsigned char use_zg = 0,retbytes = 0;
        HUFF_STATE *shuff;
-       ZG zg;
 
        /* Inicializo el descompresor */
        if ((shuff = shuff_init_decoder(src, NULL)) == NULL) return 1;
@@ -239,10 +238,8 @@ int descomprimir(char *src, char *dst)
 
        /* Descomprimo byte que indica si se usa ZG */
        if (!(moredata = shuff_decode_chunk(shuff, &use_zg, 1, &decoded))) return 1;
-       if (use_zg) zg_init(&zg);
 
        /* Creo buffers */
-       zgbuffer = malloc(sizeof(unsigned char)*256);
        block = malloc(block_size*sizeof(unsigned char)+sizeof(Uint32));
        orig = malloc(block_size*sizeof(unsigned char));
 
@@ -255,17 +252,22 @@ int descomprimir(char *src, char *dst)
                        moredata = shuff_decode_chunk(shuff,z,z_len,&decoded);                          
                        
                        /* Veo si se uso Zero Grouping para comprimir */
-                       if (use_zg) {                                                                                                                                                           
+                       if (use_zg) {
+                               ZG zg;
+                               unsigned char zgbuffer[255];
+                               unsigned char zgbyte = 0;
+                               int zgmoved = 0;
+                               Uint32 zgungrouped = 0;
                                /* Desagrupo bytes hasta completar la pagina or End of Source File */
-                               zgungrouped = 0;                                        
-                               do {                                                                                                                                    
+                               zg_init(&zg);
+                               do {
                                        /* Levanto un byte zerogrouped y lo paso por el zg_ungroup */
                                        zgmoved = 0;
-                                       moredata = shuff_decode_chunk(shuff,&zgbyte,1,&decoded);                                                                                                                                                                                                                                                                                                
+                                       moredata = shuff_decode_chunk(shuff,&zgbyte,1,&decoded);
                                        retbytes = zg_ungroup(&zg,zgbuffer,zgbyte);
-                                       /* Muevo del zgbuffer a mi bloque lo que corresponda */                                         
-                                       while ((zgmoved < retbytes) && (zgungrouped < block_size+sizeof(Uint32))) {                                                     
-                                               block[zgungrouped++] = zgbuffer[zgmoved++];                                                     
+                                       /* Muevo del zgbuffer a mi bloque lo que corresponda */
+                                       while ((zgmoved < retbytes) && (zgungrouped < block_size+sizeof(Uint32))) {
+                                               block[zgungrouped++] = zgbuffer[zgmoved++];
                                        }
                                } while ((moredata) && (zgungrouped < block_size+sizeof(Uint32)));
 
@@ -274,17 +276,17 @@ int descomprimir(char *src, char *dst)
                                        /* Leo un byte mas (un 0 seguro) y zg_ungroup cambiara su estado */
                                        moredata = shuff_decode_chunk(shuff,&zgbyte,1,&decoded);
                                        zg_ungroup(&zg,zgbuffer,zgbyte);
-                               }                                               
+                               }
 
                                /* Normalizo variables para continuar en common code */
-                               decoded = zgungrouped;                                  
+                               decoded = zgungrouped;
                        }
                        else {
                                /* Levanto una salida de MTF */
                                moredata = shuff_decode_chunk(shuff,block,block_size+sizeof(Uint32),&decoded);
                        }
                        
-                       /* Le aplico MTF inverso a la salida de MTF levantada previamente */    
+                       /* Le aplico MTF inverso a la salida de MTF levantada previamente */
                        mtf = jacu_mtf_inv(z, block, decoded);
 
                        /* Ya tengo la salida del BS, tonces levanto su K */
@@ -295,17 +297,16 @@ int descomprimir(char *src, char *dst)
 
                        fwrite(orig, decoded - sizeof(Uint32), sizeof(unsigned char), fp_out);
                        free(mtf);
-                       free(z);                                
+                       free(z);
                }
                else return 1;
-       } while (moredata);             
+       } while (moredata);
        
        /* Close up files and free mem */
        fclose(fp_out);
        free(block);
        free(orig);
-       free(zgbuffer);
-       
+
        /* Shutdown Huffman */
        shuff_deinit_decoder(shuff);
        free(shuff);