From: Alan Kennedy <kennedya@3dgames.com.ar>
Date: Fri, 25 Jun 2004 15:09:14 +0000 (+0000)
Subject: Se quita repeticion de pagesize en cada bloque comprimido, grabandose una sola vez... 
X-Git-Tag: svn_import~58
X-Git-Url: https://git.llucax.com/z.facultad/75.06/jacu.git/commitdiff_plain/cb53166758c12a09e9911769ce89c94cee4cc0f0?hp=eb5347f4df35aaa5266fcbd04112ae4cc1cf41b1

Se quita repeticion de pagesize en cada bloque comprimido, grabandose una sola vez como header comprimido por huffman.
---

diff --git a/src/blocksorting/bs.c b/src/blocksorting/bs.c
index fa14152..fb13e55 100644
--- 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 baf28da..ab4c79d 100644
--- 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);