Subo para que ayuden a descular el porque me detona el ZG. Hay un par de printfs...

diff --git a/src/jacu.c b/src/jacu.c
index 599d63630d8a06067a2c3d0eb47ee80bce4a7e9b..ccd68aec2fc8d9db50a9675c4226b62471e764f5 100644 (file)
--- a/src/jacu.c
+++ b/src/jacu.c
@@ -22,7 +22,7 @@ int main(int argc, char* argv[])
        int sflag = 0;
        int mflag = 0;
        long int volumesize = 0;
-       size_t pagesize = 32768; /* 32KB */
+       Uint32 pagesize = 32768; /* 32KB */
        int ch;
        t_BlockSort *bs;
        HUFF_STATE *shuff;
@@ -118,11 +118,11 @@ int main(int argc, char* argv[])
                fp = fopen(argv[optind], "rb");
 
                /* Guardamos el pagesize como header (huffencoded) */
-               shuff_scanfreq_chunk(shuff,(char*)&pagesize,sizeof(size_t));
+               shuff_scanfreq_chunk(shuff,(char*)&pagesize,sizeof(Uint32));
 
                /* Guardamos cabecera para indicar si usamos ZG (huffencoded) */
                if (zflag) shuff_scanfreq_chunk(shuff, "\001", 1);
-               else       shuff_scanfreq_chunk(shuff, "\000", 1);
+               else shuff_scanfreq_chunk(shuff, "\000", 1);
 
                total = 0;
                while (!feof(fp)) {
@@ -140,25 +140,33 @@ int main(int argc, char* argv[])
 
                        /* Le aplico el MTF a salida */
                        mtf = jacu_mtf(salida, i+sizeof(Uint32), &z, &z_len);
-
+                       
                        /* Guardo el z_len y el Z */
                        shuff_scanfreq_chunk(shuff,(char*)&z_len,sizeof(int));
-                       shuff_scanfreq_chunk(shuff,z,z_len);
+                       shuff_scanfreq_chunk(shuff,z,z_len);                    
                        
                        /* Si me lo piden, aplico ZG. */
                        if (zflag) {
-                               size_t len;
+                               Uint32 len,total_len = 0;
                                char buff[2];
                                Uint32 total_size = i + sizeof(Uint32);
-                               ZG zg;
+                               ZG zg;                          
+                               /* Guardo la salida del MTF con ceros agrupados (ZG) */                         
                                zg_init(&zg);
-                               /* Guardo la salida del MTF con ceros agrupados (ZG) */
                                for (j = 0; j < total_size; ++j)
-                                       if ((len = zg_group(&zg, buff, mtf[j])))
+                                       if ((len = zg_group(&zg, buff, mtf[j]))) {
                                                shuff_scanfreq_chunk(shuff, buff, len);
+                                               total_len += len;
+                                       }
+                                       /* Flusheo ultimo zgrouping */
+                                       if ((len = zg_group_finish(&zg,buff))) {
+                                               shuff_scanfreq_chunk(shuff, buff, len);
+                                               total_len += len;
+                                       }
+                                       printf ("Saved %ld zgbytes\n",total_len);
                        } else {
                                /* Comprimo la salida del MTF */                                
-                               shuff_scanfreq_chunk(shuff,mtf,i+sizeof(Uint32));
+                               shuff_scanfreq_chunk(shuff,mtf,i+sizeof(Uint32));                               
                        }
                        free(mtf);
                        free(z);
@@ -183,12 +191,12 @@ int main(int argc, char* argv[])
        if (dflag == 1) { 
                /* Descomprimo */
                FILE *fp_out;
-               /*FILE *fp_in;*/
-               Uint32 block_size = 0, k;
+               Uint32 block_size = 0,zgungrouped = 0, zgread = 0,k;
                unsigned char *block, *mtf, *orig;
-               unsigned char *z;
-               int z_len,moredata = 0,decoded = 0;
-               char use_zg;
+               unsigned char *z, *zgbuffer;
+               int zgmoved = 0,z_len=0,moredata = 0,decoded = 0;
+               unsigned char use_zg = 0,zgbyte = 0,retbytes = 0;
+               ZG zg;
 
                /* Inicializo el descompresor */
                if ((shuff = shuff_init_decoder(argv[optind],NULL)) == NULL) return 1;
@@ -201,21 +209,52 @@ int main(int argc, char* argv[])
 
                /* 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));
 
                /* Descomprimimos de a chunks segun convenga */
                do {                    
                        if (block_size > 0) {
-                               /* Descomprimo el Zlen y el Z del MTF */
-                               moredata = shuff_decode_chunk(shuff,(char*)&z_len,sizeof(int),&decoded);                                
+                               /* Descomprimo el Zlen y el Z del MTF*/
+                               moredata = shuff_decode_chunk(shuff,(char*)&z_len,sizeof(int),&decoded);                                        
                                z = malloc(sizeof(unsigned char)*z_len);
-                               moredata = shuff_decode_chunk(shuff,z,z_len,&decoded);
+                               moredata = shuff_decode_chunk(shuff,z,z_len,&decoded);                          
+                               
+                               /* Veo si se uso Zero Grouping para comprimir */
+                               if (use_zg) {                                                                                                                                                           
+                                       zgungrouped = 0;
+                                       zgread = 0;                             
+                                       /* Me fijo si tengo que copiar leftovers del zgbuffer anterior DEPRECATED? */                                   
+                                       while (zgmoved < retbytes) block[zgungrouped++] = zgbuffer[zgmoved++];
+                                       /* Desagrupo bytes hasta completar la pagina or End of Source File */
+                                       do {                                                                                                                                    
+                                               /* Levanto un byte zerogrouped y lo paso por el zg_ungroup */
+                                               zgmoved = 0;                            
+                                               moredata = shuff_decode_chunk(shuff,&zgbyte,1,&decoded);                                                                                                                                                                                                                                                
+                                               ++zgread;
+                                               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++];
+                                                       /*if ((zgungrouped % 500) == 0) printf("At source byte %ld we have processed %ld zgbytes\n",zgungrouped,zgread);*/
+                                               }
+                                               /*if ((zgungrouped % 500) == 0) printf("At source byte %ld we have processed %ld zgbytes\n",zgungrouped,zgread);*/
+                                       } while ((moredata) && (zgungrouped < block_size+sizeof(Uint32)));
+                                                                                                                       
+                                       /* Normalizo variables para continuar en common code */                                 
+                                       printf("At source byte %ld we have processed %ld zgbytes\n",zgungrouped,zgread);
+                                       decoded = zgungrouped;                                  
+                               }
+                               else {
+                                       /* Levanto una salida de MTF */
+                                       moredata = shuff_decode_chunk(shuff,block,block_size+sizeof(Uint32),&decoded);
+                               }
                                
-                               /* Levanto una salida de MTF y le aplico MTF Inverso */
-                               moredata = shuff_decode_chunk(shuff,block,block_size+sizeof(Uint32),&decoded);                          
+                               /* 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 */
@@ -226,7 +265,7 @@ int main(int argc, char* argv[])
 
                                fwrite(orig, decoded - sizeof(Uint32), sizeof(unsigned char), fp_out);
                                free(mtf);
-                               free(z);
+                               free(z);                                
                        }
                        else return 1;
                } while (moredata);             
@@ -235,6 +274,7 @@ int main(int argc, char* argv[])
                fclose(fp_out);
                free(block);
                free(orig);
+               free(zgbuffer);
                
                /* Shutdown Huffman */
                shuff_deinit_decoder(shuff);

diff --git a/src/statichuff/statichuff.c b/src/statichuff/statichuff.c
index 000f0bab7f1c0820f1555f75e420c2d172e19d32..0632e361aac65a3782bea43d65b8c974c755ebdf 100644 (file)
--- a/src/statichuff/statichuff.c
+++ b/src/statichuff/statichuff.c
@@ -70,7 +70,7 @@ int shuff_scanfreq_chunk(HUFF_STATE *chunkshuff, char* chunk, int chunksize)
        int i = 0;
        unsigned char symbol = 0;       
                
-       /* Contamos las frecuencias del chunk a menos que se use un canonico */ 
+       /* Contamos las frecuencias del chunk a menos que se use un canonico */                 
        if (!chunkshuff->canonic) {
                for (i = 0; i < chunksize; ++i) {                               
                        symbol = chunk[i];              
@@ -189,7 +189,7 @@ void shuff_printcodes(SHUFFCODE *codetable,t_freq *freqtable)
        for (i = 0; i < 256; ++i) {
                if (codetable[i].codelength > 0) {
                        auxcode = codetable[i].code;                    
-                       printf("Symbol:%i  Freq: %li  Code:",i,freqtable[i]);
+                       printf("Symbol:%i  Freq: %lu  Code:",i,freqtable[i]);
                        for (j = codetable[i].codelength-1; j >= 0; --j) {
                                auxcode = codetable[i].code;                    
                                auxcode = auxcode >> j;