Se quita repeticion de pagesize en cada bloque comprimido, grabandose una sola vez...

diff --git a/src/blocksorting/bs.c b/src/blocksorting/bs.c
index fa1415253f979ef07453d44358a123aefa06f14d..fb13e55655037acfa078922a4f94d0f8ddc72d37 100644 (file)
--- a/src/blocksorting/bs.c
+++ b/src/blocksorting/bs.c
@@ -71,8 +71,8 @@ int generar_salida(char *data, t_BlockSort *bs, char *salida)
        Uint32 i, k;
        char *out;
 
-       /* Dejo lugar para guardar el k y el tamaño de este bloque */
-       out = salida + sizeof(Uint32)*2;
+       /* Dejo lugar para guardar el K */
+       out = salida + sizeof(Uint32);
 
        k=-1;
        for(i=0; i<bs->len; i++) {
@@ -94,9 +94,8 @@ void bs_solve(char *in, char *out, t_BlockSort *bs, Uint32 *k, Uint32 leido)
        ordenar_array(in, bs);
        (*k) = generar_salida(in, bs, out);
 
-       /* Guardo el k y el tamaño en el array */
-       memcpy(out, &leido, sizeof(Uint32));
-       memcpy(out+sizeof(Uint32), k, sizeof(Uint32));
+       /* Guardo el k y el tamaño en el array */       
+       memcpy(out, k, sizeof(Uint32));
        bs->len = l;
 }
 
@@ -140,4 +139,3 @@ void bs_destroy(t_BlockSort *bs)
        free(bs->array);
        free(bs);
 }
-

diff --git a/src/jacu.c b/src/jacu.c
index baf28da868b9a2b4648060b70da3482fcede6f66..ab4c79d7e8330f74df6d111f0cb728bdb59d7732 100644 (file)
--- a/src/jacu.c
+++ b/src/jacu.c
@@ -106,16 +106,19 @@ int main(int argc, char* argv[])
                int z_len;
                
                /* Preparo el compresor huffman */
-               if ((shuff = shuff_init_encoder_bychunk(argv[optind+1],volumesize*1024)) == NULL) return 0;
+               if ((shuff = shuff_init_encoder_bychunk(argv[optind+1],volumesize*1024)) == NULL) return 1;
                if (mflag == 1) shuff_loadmodel(shuff,staticmodel);
                
-               /* Preparo el BS alocando mem para el K, el Block y su Size */
+               /* Preparo el BS alocando mem para la Salida: V(vector) + K(colnum) */
                data = malloc(sizeof(unsigned char)*pagesize);
-               salida = malloc(sizeof(unsigned char)*pagesize+sizeof(Uint32)*2);
+               salida = malloc(sizeof(unsigned char)*pagesize+sizeof(Uint32));
                bs = bs_create(pagesize);
 
                /* Abrimos el archivo a comprimir y encodeamos bloques */
-               fp = fopen(argv[optind], "rb");                                         
+               fp = fopen(argv[optind], "rb");
+
+               /* Guardamos el pagesize como header (huffencoded) */
+               shuff_scanfreq_chunk(shuff,(char*)&pagesize,sizeof(size_t));
 
                total = 0;
                while (!feof(fp)) {
@@ -128,11 +131,11 @@ int main(int argc, char* argv[])
                        /* Saco un EOF que lee de mas */
                        if (i<pagesize) i--;
 
-                       /* Aplico el BlockSorting */
+                       /* Aplico BS guardando su resultado + el K en salida */
                        bs_solve(data, salida, bs, &k, i);
 
-                       /* Le aplico el MTF, salteo el tamaño del bloque para que no se pierda. */
-                       mtf = jacu_mtf(salida+sizeof(Uint32), i+sizeof(Uint32), &z, &z_len);
+                       /* Le aplico el MTF a salida */
+                       mtf = jacu_mtf(salida, i+sizeof(Uint32), &z, &z_len);
                        
                        /* Si me lo piden, aplico ZG. */
                        if (zflag) {
@@ -143,15 +146,12 @@ int main(int argc, char* argv[])
                                /* TODO HACER LO MISMO QUE EN EL ELSE XXX */
                                for (j = 0; j < i; ++j)
                                        if ((len = zg_group(&zg, buff, mtf[j]))) shuff_scanfreq_chunk(shuff,buff,len);
-                       } else {
-                               /* Guardo el PageSize */
-                               shuff_scanfreq_chunk(shuff,salida,sizeof(Uint32));
-                               
-                               /* Guardo el Z len y el Z */
+                       } else {                        
+                               /* Comprimo el Z len y el Z */
                                shuff_scanfreq_chunk(shuff,(char*)&z_len,sizeof(int));
                                shuff_scanfreq_chunk(shuff,z,z_len);                                                            
 
-                               /* Guardo la salida del MTF */                          
+                               /* Comprimo la salida del MTF */                                
                                shuff_scanfreq_chunk(shuff,mtf,i+sizeof(Uint32));                               
                        }
                        free(mtf);
@@ -178,7 +178,7 @@ int main(int argc, char* argv[])
                /* Descomprimo */
                FILE *fp_out;
                /*FILE *fp_in;*/
-               Uint32 block_size, k;
+               Uint32 block_size = 0, k;
                unsigned char *block, *mtf, *orig;
                unsigned char *z;
                int z_len,moredata = 0,decoded = 0;
@@ -188,38 +188,41 @@ int main(int argc, char* argv[])
                                
                /* Abrimos el archivo de salida */
                fp_out = fopen(argv[optind+1], "wb");
+               
+               /* Descomprimo primero que nada el pagesize utilizado para comprimir */
+               if (!(moredata = shuff_decode_chunk(shuff,(char*)&block_size,sizeof(Uint32),&decoded))) return 1;
+               block = malloc(block_size*sizeof(unsigned char)+sizeof(Uint32));
+               orig = malloc(block_size*sizeof(unsigned char));
 
                /* Descomprimimos de a chunks segun convenga */
-               do {
-                       block_size = 0;                                         
-                       moredata = shuff_decode_chunk(shuff,(char*)&block_size,sizeof(Uint32),&decoded);
+               do {                    
                        if (block_size > 0) {
+                               /* 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);                          
-
-                               block = malloc(block_size*sizeof(unsigned char)+sizeof(Uint32));
-                               orig = malloc(block_size*sizeof(unsigned char));
+                               moredata = shuff_decode_chunk(shuff,z,z_len,&decoded);
+                               
+                               /* Levanto una salida de MTF y le aplico MTF Inverso */
                                moredata = shuff_decode_chunk(shuff,block,block_size+sizeof(Uint32),&decoded);                          
+                               mtf = jacu_mtf_inv(z, block, decoded);
 
-                               mtf = jacu_mtf_inv(z, block, block_size*sizeof(unsigned char)+sizeof(Uint32));
-
-                               /* Luego de hacer el MTF inverso ya puedo recuperar el k */
+                               /* Ya tengo la salida del BS, tonces levanto su K */
                                memcpy(&k, mtf, sizeof(Uint32));
 
-                               /*printf("Restored : k=%ld\n", k);*/
-                               bs_restore(orig, mtf+sizeof(Uint32), k, block_size);
+                               /* Obtengo el chunk original aplicando BS Inverso */
+                               bs_restore(orig, mtf+sizeof(Uint32), k, decoded - sizeof(Uint32));
 
-                               fwrite(orig, block_size, sizeof(unsigned char), fp_out);
-                               free(block);
-                               free(orig);
+                               fwrite(orig, decoded - sizeof(Uint32), sizeof(unsigned char), fp_out);
                                free(mtf);
                                free(z);
                        }
+                       else return 1;
                } while (moredata);             
                
-               /* Close up files */
+               /* Close up files and free mem */
                fclose(fp_out);
+               free(block);
+               free(orig);
                
                /* Shutdown Huffman */
                shuff_deinit_decoder(shuff);