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;
 
        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++) {
 
        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);
 
        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;
 }
 
        bs->len = l;
 }
 


@@ -140,4 +139,3 @@ void bs_destroy(t_BlockSort *bs)
        free(bs->array);
        free(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 */
                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);
                
                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);
                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 */
                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)) {
 
                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--;
 
                        /* 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);
 
                        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) {
                        
                        /* 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);
                                /* 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);                                                            
 
                                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);
                                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;*/
                /* 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;
                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");
                                
                /* 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 */
 
                /* 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) {
                        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,(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);                          
                                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));
 
                                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);
                        }
                                free(mtf);
                                free(z);
                        }

+                       else return 1;

                } while (moredata);             
                
                } while (moredata);             
                

-               /* Close up files */
+               /* Close up files and free mem */

                fclose(fp_out);
                fclose(fp_out);

+               free(block);
+               free(orig);

                
                /* Shutdown Huffman */
                shuff_deinit_decoder(shuff);
                
                /* Shutdown Huffman */
                shuff_deinit_decoder(shuff);