Hago que se genere el symlink de jacu a grupo11 en el make all :)

[z.facultad/75.06/jacu.git] / src / jacu.c

diff --git a/src/jacu.c b/src/jacu.c
index 4b35832d14a3a0035f6e969a7db1a09b887f4e04..1648e82eb0b6599a62c98fcf1e861af59f6ef9ed 100644 (file)
--- a/src/jacu.c
+++ b/src/jacu.c
@@ -20,9 +20,10 @@ typedef struct _flags_ {
        int qflag;
        int sflag;
        int mflag;
        int qflag;
        int sflag;
        int mflag;

+       int rflag; /* Richard Dictionary :-) */

 } t_Flags;
 
 } t_Flags;
 

-int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumensize, t_Flags *flags, char *staticmodel);
+int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags *flags, char *staticmodel);

 int descomprimir(char *src, char *dst);
 
 int main(int argc, char* argv[])
 int descomprimir(char *src, char *dst);
 
 int main(int argc, char* argv[])


@@ -35,7 +36,7 @@ int main(int argc, char* argv[])
                        
        memset(&flags, 0, sizeof(t_Flags));
 
                        
        memset(&flags, 0, sizeof(t_Flags));
 

-       while ((ch = getopt(argc, argv, "scdzm:t:q:")) != -1) { 
+       while ((ch = getopt(argc, argv, "rscdzm:t:q:")) != -1) { 

                 
                switch (ch) { 
                        case 'c': flags.cflag = 1; 
                 
                switch (ch) { 
                        case 'c': flags.cflag = 1; 


@@ -58,6 +59,8 @@ int main(int argc, char* argv[])
                                volumesize = atol(optarg);
                                break; 
 
                                volumesize = atol(optarg);
                                break; 
 

+                       case 'r': flags.rflag = 1;
+                               break;

                        case 'q': flags.qflag = 1; 
                                switch (atoi(optarg))
                                {
                        case 'q': flags.qflag = 1; 
                                switch (atoi(optarg))
                                {


@@ -85,13 +88,13 @@ int main(int argc, char* argv[])
                                }
                                break; 
 
                                }
                                break; 
 

-                       default: fprintf(stderr, "Usage: %s [-cdzs][-q blksize][-t volsize][-m modeldumpfile] source target\n", argv[0]); 
+                       default: fprintf(stderr, "Usage: %s [-cdzsr][-q blksize][-t volsize][-m modeldumpfile] source target\n", argv[0]); 

                                         return(2);
                }
        }
                
        if ( (argc == 1) || (flags.cflag & flags.dflag) || !(flags.cflag | flags.dflag) || ((argc - optind) < 2) || (flags.mflag & flags.sflag)) {
                                         return(2);
                }
        }
                
        if ( (argc == 1) || (flags.cflag & flags.dflag) || !(flags.cflag | flags.dflag) || ((argc - optind) < 2) || (flags.mflag & flags.sflag)) {

-               fprintf(stderr, "Usage: %s [-cdzs][-q compressionquality][-t volsize][-m modeldumpfile] source target\n", argv[0]); 
+               fprintf(stderr, "Usage: %s [-cdzsr][-q compressionquality][-t volsize][-m modeldumpfile] source target\n", argv[0]); 

                return (3);
        }
        if ((flags.tflag) && (volumesize <= 0l)) {
                return (3);
        }
        if ((flags.tflag) && (volumesize <= 0l)) {


@@ -119,7 +122,7 @@ long fsize(const char* filename)
        FILE* file;
        long  file_size;
 
        FILE* file;
        long  file_size;
 

-       if (!(file = fopen(filename, "r"))) return -1;
+       if (!(file = fopen(filename, "ab"))) return -1;

        file_size = ftell(file);
        fclose(file);
        return file_size;
        file_size = ftell(file);
        fclose(file);
        return file_size;


@@ -137,6 +140,9 @@ int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags
        unsigned char *z;
        int z_len;
        
        unsigned char *z;
        int z_len;
        

+       /* Abrimos el archivo a comprimir y encodeamos bloques */
+       if ((fp = fopen(src, "rb")) == NULL) return 1;
+       

        /* Preparo el compresor huffman */
        if ((shuff = shuff_init_encoder_bychunk(dst, volumesize*1024)) == NULL) return 1;
        if (flags->mflag == 1) shuff_loadmodel(shuff, staticmodel);
        /* Preparo el compresor huffman */
        if ((shuff = shuff_init_encoder_bychunk(dst, volumesize*1024)) == NULL) return 1;
        if (flags->mflag == 1) shuff_loadmodel(shuff, staticmodel);


@@ -146,9 +152,6 @@ int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags
        salida = malloc(sizeof(unsigned char)*pagesize+sizeof(Uint32));
        bs = bs_create(pagesize);
 
        salida = malloc(sizeof(unsigned char)*pagesize+sizeof(Uint32));
        bs = bs_create(pagesize);
 

-       /* Abrimos el archivo a comprimir y encodeamos bloques */
-       fp = fopen(src, "rb");
-

        /* Guardamos el pagesize como header (huffencoded) */
        shuff_scanfreq_chunk(shuff,(char*)&pagesize,sizeof(Uint32));
 
        /* Guardamos el pagesize como header (huffencoded) */
        shuff_scanfreq_chunk(shuff,(char*)&pagesize,sizeof(Uint32));
 


@@ -161,13 +164,9 @@ int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags
        total = 0;
        while (!feof(fp)) {
                i = 0;
        total = 0;
        while (!feof(fp)) {
                i = 0;

-               while ((!feof(fp)) && (i < pagesize)) {
-                       data[i++] = fgetc(fp);
-                       total++;
-               }
+               i = bs_readblock(fp, data, pagesize, flags->rflag);
+               total += i;

 
 

-               /* Saco un EOF que lee de mas */
-               if (i<pagesize) i--;

 
                /* Aplico BS guardando su resultado + el K en salida */
                bs_solve(data, salida, bs, &k, i);
 
                /* Aplico BS guardando su resultado + el K en salida */
                bs_solve(data, salida, bs, &k, i);


@@ -184,8 +183,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);
                        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])))
                        zg_init(&zg);
                        for (j = 0; j < total_size; ++j)
                                if ((len = zg_group(&zg, buff, mtf[j])))


@@ -193,18 +192,20 @@ int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags
 
                                /* Flusheo ultimo zgrouping */
                                if ((len = zg_group_finish(&zg,buff)))
 
                                /* Flusheo ultimo zgrouping */
                                if ((len = zg_group_finish(&zg,buff)))

-                                       shuff_scanfreq_chunk(shuff, buff, len);                         
+                                       shuff_scanfreq_chunk(shuff, buff, len);

                } else {
                } 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);
        }
 
        /* Limpiando */
                }
                free(mtf);
                free(z);
        }
 
        /* Limpiando */

-       fclose(fp);             
+       if (fclose(fp)) fprintf(stderr, "Error al cerrar archivo de entrada!\n");

        bs_destroy(bs);
        bs_destroy(bs);

+       free(data);
+       free(salida);

 
        /* Comprimo con Huffman */              
        shuff_encode_file(shuff);
 
        /* Comprimo con Huffman */              
        shuff_encode_file(shuff);


@@ -222,13 +223,12 @@ int descomprimir(char *src, char *dst)
 {
        /* Descomprimo */
        FILE *fp_out;
 {
        /* Descomprimo */
        FILE *fp_out;

-       Uint32 block_size = 0,zgungrouped = 0, k;
+       Uint32 block_size = 0, k;

        unsigned char *block, *mtf, *orig;
        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;
        HUFF_STATE *shuff;

-       ZG zg;

 
        /* Inicializo el descompresor */
        if ((shuff = shuff_init_decoder(src, NULL)) == NULL) return 1;
 
        /* Inicializo el descompresor */
        if ((shuff = shuff_init_decoder(src, NULL)) == NULL) return 1;


@@ -241,10 +241,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;
 
        /* 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 */
 
        /* Creo buffers */

-       zgbuffer = malloc(sizeof(unsigned char)*256);

        block = malloc(block_size*sizeof(unsigned char)+sizeof(Uint32));
        orig = malloc(block_size*sizeof(unsigned char));
 
        block = malloc(block_size*sizeof(unsigned char)+sizeof(Uint32));
        orig = malloc(block_size*sizeof(unsigned char));
 


@@ -257,17 +255,22 @@ int descomprimir(char *src, char *dst)
                        moredata = shuff_decode_chunk(shuff,z,z_len,&decoded);                          
                        
                        /* Veo si se uso Zero Grouping para comprimir */
                        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 */
                                /* 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;
                                        /* 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);
                                        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)));
 
                                        }
                                } while ((moredata) && (zgungrouped < block_size+sizeof(Uint32)));
 


@@ -276,17 +279,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);
                                        /* 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 */
 
                                /* 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);
                        }
                        
                        }
                        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 */
                        mtf = jacu_mtf_inv(z, block, decoded);
 
                        /* Ya tengo la salida del BS, tonces levanto su K */


@@ -297,20 +300,18 @@ int descomprimir(char *src, char *dst)
 
                        fwrite(orig, decoded - sizeof(Uint32), sizeof(unsigned char), fp_out);
                        free(mtf);
 
                        fwrite(orig, decoded - sizeof(Uint32), sizeof(unsigned char), fp_out);
                        free(mtf);

-                       free(z);                                
+                       free(z);

                }
                else return 1;
                }
                else return 1;

-       } while (moredata);             
+       } while (moredata);

        
        /* Close up files and free mem */
        fclose(fp_out);
        free(block);
        free(orig);
        
        /* Close up files and free mem */
        fclose(fp_out);
        free(block);
        free(orig);

-       free(zgbuffer);
-       
+

        /* Shutdown Huffman */
        shuff_deinit_decoder(shuff);
        free(shuff);
        return 0;
 }
        /* Shutdown Huffman */
        shuff_deinit_decoder(shuff);
        free(shuff);
        return 0;
 }

-