X-Git-Url: https://git.llucax.com/z.facultad/75.06/jacu.git/blobdiff_plain/eb5347f4df35aaa5266fcbd04112ae4cc1cf41b1..4249df7029fe40e0514b547c35e3c81a767d4dcb:/src/jacu.c diff --git a/src/jacu.c b/src/jacu.c index baf28da..8b6dcd7 100644 --- a/src/jacu.c +++ b/src/jacu.c @@ -10,48 +10,55 @@ #include #include -long get_file_size(const char* filename); +long fsize(const char* filename); + +typedef struct _flags_ { + int cflag; + int dflag; + int zflag; + int tflag; + int qflag; + int sflag; + int mflag; +} t_Flags; + +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 cflag = 0; - int dflag = 0; - int zflag = 0; - int tflag = 0; - int qflag = 0; - 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; + t_Flags flags; char *staticmodel = NULL; + memset(&flags, 0, sizeof(t_Flags)); + while ((ch = getopt(argc, argv, "scdzm:t:q:")) != -1) { switch (ch) { - case 'c': cflag = 1; + case 'c': flags.cflag = 1; break; - case 'd': dflag = 1; + case 'd': flags.dflag = 1; break; - case 'z': zflag = 1; + case 'z': flags.zflag = 1; break; - case 'm': mflag = 1; + case 'm': flags.mflag = 1; staticmodel = optarg; break; - case 's': sflag = 1; + case 's': flags.sflag = 1; break; - case 't': tflag = 1; + case 't': flags.tflag = 1; volumesize = atol(optarg); break; - case 'q': qflag = 1; + case 'q': flags.qflag = 1; switch (atoi(optarg)) { case 0: pagesize = 1024; /* 1K */ @@ -83,159 +90,224 @@ int main(int argc, char* argv[]) } } - if ( (argc == 1) || (cflag & dflag) || !(cflag | dflag) || ((argc - optind) < 2) || (mflag & sflag)) { - fprintf(stderr, "Usage: %s [-cdzs][-q blksize][-t volsize][-m modeldumpfile] source target\n", argv[0]); + 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]); return (3); } - if ((tflag) && (volumesize <= 0l)) { + if ((flags.tflag) && (volumesize <= 0l)) { fprintf(stderr,"Error: The volume size must be a non-zero value\n"); return (4); } - if ((qflag) && (pagesize <= 1u)) { + if ((flags.qflag) && (pagesize <= 1u)) { fprintf(stderr,"Error: El nivel de compresión debe ser entre 0 (menor) y 9 (mayor).\n"); return (5); } - if (cflag == 1) { - /* Comprimo */ - FILE *fp; - Uint32 i, j, total, k; - unsigned char *mtf; - unsigned char *salida, *data; - unsigned char *z; - int z_len; - - /* Preparo el compresor huffman */ - if ((shuff = shuff_init_encoder_bychunk(argv[optind+1],volumesize*1024)) == NULL) return 0; - if (mflag == 1) shuff_loadmodel(shuff,staticmodel); - - /* Preparo el BS alocando mem para el K, el Block y su Size */ - data = malloc(sizeof(unsigned char)*pagesize); - salida = malloc(sizeof(unsigned char)*pagesize+sizeof(Uint32)*2); - bs = bs_create(pagesize); - - /* Abrimos el archivo a comprimir y encodeamos bloques */ - fp = fopen(argv[optind], "rb"); - - total = 0; - while (!feof(fp)) { - i = 0; - while ((!feof(fp)) && (i < pagesize)) { - data[i++] = fgetc(fp); - total++; - } + if (flags.cflag == 1) { + return comprimir(argv[optind], argv[optind+1], pagesize, volumesize, &flags, staticmodel); + } + + if (flags.dflag == 1) { + return descomprimir(argv[optind], argv[optind+1]); + } - /* Saco un EOF que lee de mas */ - if (imflag == 1) shuff_loadmodel(shuff, staticmodel); + + /* 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)); + bs = bs_create(pagesize); - /* Limpiando */ - fclose(fp); - bs_destroy(bs); + /* Abrimos el archivo a comprimir y encodeamos bloques */ + if ((fp = fopen(src, "rb")) == NULL) return 1; - /* Comprimo con Huffman */ - shuff_encode_file(shuff); - if (sflag == 1) shuff_savemodel(shuff); - /* Shutdown Huffman */ - shuff_deinit_encoder(shuff); - free(shuff); + /* Guardamos el pagesize como header (huffencoded) */ + shuff_scanfreq_chunk(shuff,(char*)&pagesize,sizeof(Uint32)); - /* Muestro bpb */ - printf("Comprimido a %.04f bpb.\n", get_file_size(argv[optind+1])*8.0/get_file_size(argv[optind])); - return 0; - } - - if (dflag == 1) { - /* Descomprimo */ - FILE *fp_out; - /*FILE *fp_in;*/ - Uint32 block_size, k; - unsigned char *block, *mtf, *orig; - unsigned char *z; - int z_len,moredata = 0,decoded = 0; - - /* Inicializo el descompresor */ - if ((shuff = shuff_init_decoder(argv[optind],NULL)) == NULL) return 1; + /* Guardamos cabecera para indicar si usamos ZG (huffencoded) */ + if (flags->zflag) + shuff_scanfreq_chunk(shuff, "\001", 1); + else + shuff_scanfreq_chunk(shuff, "\000", 1); + + total = 0; + while (!feof(fp)) { + i = 0; + i = bs_readblock(fp, data, pagesize); + total += i; + + + /* Aplico BS guardando su resultado + el K en salida */ + bs_solve(data, salida, bs, &k, i); + + /* Le aplico el MTF a salida */ + mtf = jacu_mtf(salida, i+sizeof(Uint32), &z, &z_len); - /* Abrimos el archivo de salida */ - fp_out = fopen(argv[optind+1], "wb"); - - /* Descomprimimos de a chunks segun convenga */ - do { - block_size = 0; - moredata = shuff_decode_chunk(shuff,(char*)&block_size,sizeof(Uint32),&decoded); - if (block_size > 0) { - 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,block,block_size+sizeof(Uint32),&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 */ - memcpy(&k, mtf, sizeof(Uint32)); - - /*printf("Restored : k=%ld\n", k);*/ - bs_restore(orig, mtf+sizeof(Uint32), k, block_size); - - fwrite(orig, block_size, sizeof(unsigned char), fp_out); - free(block); - free(orig); - free(mtf); - free(z); - } - } while (moredata); + /* Guardo el z_len y el Z */ + shuff_scanfreq_chunk(shuff,(char*)&z_len,sizeof(int)); + shuff_scanfreq_chunk(shuff,z,z_len); - /* Close up files */ - fclose(fp_out); - - /* Shutdown Huffman */ - shuff_deinit_decoder(shuff); - free(shuff); + /* Si me lo piden, aplico ZG. */ + if (flags->zflag) { + Uint32 len; + unsigned char buff[2]; + Uint32 total_size = i + sizeof(Uint32); + 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]))) + shuff_scanfreq_chunk(shuff, buff, len); + + /* Flusheo ultimo zgrouping */ + if ((len = zg_group_finish(&zg,buff))) + shuff_scanfreq_chunk(shuff, buff, len); + } else { + /* Comprimo la salida del MTF */ + shuff_scanfreq_chunk(shuff,mtf,i+sizeof(Uint32)); + } + free(mtf); + free(z); } + /* Limpiando */ + if (fclose(fp)) fprintf(stderr, "Error al cerrar archivo de entrada!\n"); + bs_destroy(bs); + free(data); + free(salida); + + /* Comprimo con Huffman */ + shuff_encode_file(shuff); + if (flags->sflag == 1) shuff_savemodel(shuff); + /* Shutdown Huffman */ + shuff_deinit_encoder(shuff); + free(shuff); + + /* Muestro bpb */ + printf("%s: %.04f bits/byte.\n", dst, vfsize(dst)*8.0f/fsize(src)); return 0; } -long get_file_size(const char* filename) +int descomprimir(char *src, char *dst) { - FILE* file; - long file_size; + /* Descomprimo */ + FILE *fp_out; + Uint32 block_size = 0,zgungrouped = 0, k; + 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; + HUFF_STATE *shuff; + ZG zg; - if (!(file = fopen(filename, "ab"))) return -1; - file_size = ftell(file); - fclose(file); - return file_size; + /* Inicializo el descompresor */ + if ((shuff = shuff_init_decoder(src, NULL)) == NULL) return 1; + + /* Abrimos el archivo de salida */ + fp_out = fopen(dst, "wb"); + + /* Descomprimo primero que nada el pagesize utilizado para comprimir */ + 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); + + /* 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); + z = malloc(sizeof(unsigned char)*z_len); + moredata = shuff_decode_chunk(shuff,z,z_len,&decoded); + + /* Veo si se uso Zero Grouping para comprimir */ + if (use_zg) { + /* Desagrupo bytes hasta completar la pagina or End of Source File */ + zgungrouped = 0; + do { + /* Levanto un byte zerogrouped y lo paso por el zg_ungroup */ + zgmoved = 0; + moredata = shuff_decode_chunk(shuff,&zgbyte,1,&decoded); + 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++]; + } + } while ((moredata) && (zgungrouped < block_size+sizeof(Uint32))); + + /* Me fijo si el ultimo byte procesado que me completo la pagina fue un 0 */ + if (zgbyte == 0) { + /* 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 */ + decoded = zgungrouped; + } + 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 */ + mtf = jacu_mtf_inv(z, block, decoded); + + /* Ya tengo la salida del BS, tonces levanto su K */ + memcpy(&k, mtf, 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); + free(mtf); + free(z); + } + else return 1; + } while (moredata); + + /* 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; }