Agrego manejo de flags en el header, en total se puden usar hasta 8 flahs. 2 usadas

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

diff --git a/src/jacu.c b/src/jacu.c
index 556f621a58f7a3c2d54e7c6a4a32b8d45e58fb80..042a332cae0f1613bd1ec976a730ce4c44443543 100644 (file)
--- a/src/jacu.c
+++ b/src/jacu.c
@@ -12,6 +12,16 @@
 
 long fsize(const char* filename);
 
 
 long fsize(const char* filename);
 

+/* Flags del archivo comprimido */
+#define FLAGS_ZG 0x1
+#define FLAGS_WS 0x2
+#define FLAGS_RESERVED_1 0x4
+#define FLAGS_RESERVED_2 0x8
+#define FLAGS_RESERVED_3 0x16
+#define FLAGS_RESERVED_4 0x64
+#define FLAGS_RESERVED_5 0x128
+#define FLAGS_RESERVED_6 0x255
+

 typedef struct _flags_ {
        int cflag;
        int dflag;
 typedef struct _flags_ {
        int cflag;
        int dflag;


@@ -20,11 +30,27 @@ 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 descomprimir(char *src, char *dst);
 

+char is_flags_on(unsigned char flags, unsigned char flag)
+{
+       return (flags & flag);
+}
+
+char flag_on(unsigned char flags, unsigned char flag)
+{
+       return (flags | flag);
+}
+
+char flag_off(unsigned char flags, unsigned char flag)
+{
+       return (flags & (~flag));
+}
+

 int main(int argc, char* argv[])
 {      
        long int volumesize = 0;
 int main(int argc, char* argv[])
 {      
        long int volumesize = 0;


@@ -35,7 +61,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 +84,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 +113,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 +147,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;


@@ -135,8 +163,12 @@ int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags
        unsigned char *mtf;
        unsigned char *salida, *data;
        unsigned char *z;
        unsigned char *mtf;
        unsigned char *salida, *data;
        unsigned char *z;

+       unsigned char file_flags = 0;

        int z_len;
        
        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,22 +178,21 @@ 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 cabecera para indicar si usamos ZG (huffencoded) */
        if (flags->zflag)
        /* Guardamos el pagesize como header (huffencoded) */
        shuff_scanfreq_chunk(shuff,(char*)&pagesize,sizeof(Uint32));
 
        /* Guardamos cabecera para indicar si usamos ZG (huffencoded) */
        if (flags->zflag)

-               shuff_scanfreq_chunk(shuff, "\001", 1);
-       else
-               shuff_scanfreq_chunk(shuff, "\000", 1);
+               file_flags = flag_on(file_flags, FLAGS_ZG);
+       if (flags->rflag)
+               file_flags = flag_on(file_flags, FLAGS_WS);
+
+       shuff_scanfreq_chunk(shuff, &file_flags, 1);

 
        total = 0;
        while (!feof(fp)) {
                i = 0;
 
        total = 0;
        while (!feof(fp)) {
                i = 0;

-               i = bs_readblock(fp, data, pagesize);
+               i = bs_readblock(fp, data, pagesize, flags->rflag);

                total += i;
 
 
                total += i;
 
 


@@ -180,8 +211,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])))


@@ -189,18 +220,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);


@@ -218,13 +251,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;
+       Uint32 z_len=0,moredata = 0,decoded = 0;
+       unsigned char file_flags = 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;


@@ -236,11 +268,9 @@ int descomprimir(char *src, char *dst)
        if (!(moredata = shuff_decode_chunk(shuff,(char*)&block_size,sizeof(Uint32),&decoded))) return 1;
 
        /* Descomprimo byte que indica si se usa ZG */
        if (!(moredata = shuff_decode_chunk(shuff,(char*)&block_size,sizeof(Uint32),&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);
+       if (!(moredata = shuff_decode_chunk(shuff, &file_flags, 1, &decoded))) return 1;

 
        /* 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));
 


@@ -253,17 +283,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 (is_flags_on(file_flags, FLAGS_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)));
 


@@ -272,17 +307,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 */


@@ -291,22 +326,25 @@ int descomprimir(char *src, char *dst)
                        /* Obtengo el chunk original aplicando BS Inverso */
                        bs_restore(orig, mtf+sizeof(Uint32), k, decoded - sizeof(Uint32));
 
                        /* Obtengo el chunk original aplicando BS Inverso */
                        bs_restore(orig, mtf+sizeof(Uint32), k, decoded - sizeof(Uint32));
 

-                       fwrite(orig, decoded - sizeof(Uint32), sizeof(unsigned char), fp_out);
+                       decoded -= sizeof(Uint32);
+                       if (is_flags_on(file_flags, FLAGS_WS)) {
+                               orig = bs_finalblock(orig, decoded, &decoded);
+                       }
+
+                       fwrite(orig, decoded, sizeof(unsigned char), fp_out);

                        free(mtf);
                        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;
 }

-