[C] compressione-decompressione

[tenbota87]

Ciao a tutti!
vi spiego il mio problema: prendo in input un file con estensione .txt e lo comprimo utilizzando il metodo RLE (conto il numero di lettere uguali che si susseguono e lo salvo sul file che avrà estensione .rle).
Il problema si presenta con un file che contiene 269 milioni di 'a'; il problema sta nel fatto che me lo comprime praticamente solo per metà.. e dovrebbe trovarsi nel
while(!feof(fileTesto)) {..}

grazie a tutti

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <assert.h>


// definizione della funzione ASSERT()  con stampa di un messaggio di errore 
#define ASSERT( condizionedaverificare, cosafare )	{ if ( !(condizionedaverificare) ) { printf cosafare; printf("\n"); assert( condizionedaverificare ); } }


//Definizione della lunghezza del buffer di lettura
#define LUNGHEZZA_BUFFER_LETTURA 1000000

/* Funzione scritturaFileCompresso() 
Viene chiamata all'interno della funzione comprimi()
E' la funzione che serve per scrivere il file compresso.
La scrittura è di tipo binaria.
Se il numero delle occorrenze di una lettera è minore di 8 allora in un byte verranno scritti 
lettera e numero di occorrenze (5 bit per la lettera,3 per il numero di occorrenze),
altrimenti un byte verrà usato per la lettera,uno per memorizzare il numero di byte utilizzati
per memorizzare le occorrenze e nei byte successivi vi sarà la memorizzazione del numero di occorrenze.
*/

void scritturaFileCompresso(unsigned char lettera,int contatore,FILE *ilfile)
	{		
		unsigned char *bufferScrittura;
		int fileScritto=0; 
		int numeroByte=0;								
		int resto=0;
		int i=0;
		
		numeroByte=contatore/256;
		resto=contatore%256;
		
		if(numeroByte==0)		//il numero di ripetizioni è minore di 256
		{
			bufferScrittura=(unsigned char*)malloc(2*sizeof(char));		//allocazione della memoria per bufferScrittura
			bufferScrittura[0]=resto;
			bufferScrittura[1]=lettera;
			fileScritto=fwrite(bufferScrittura,1,2,ilfile);
			
		}
		else	//se entro qui ho almeno 256 ripetizioni
		{
		
			if(resto==0)
			{
				bufferScrittura=(unsigned char*)malloc((2*numeroByte)*sizeof(char));		//allocazione della memoria per bufferScrittura
				i=0;
				while(i<(numeroByte*2))
				{
					bufferScrittura[i]='*';
					bufferScrittura[i+1]=lettera;
					i+=2;
				}
				
				fileScritto=fwrite(bufferScrittura,1,(2*numeroByte),ilfile);
			}
			else		//il numero di ripetizioni non è un multiplo di 256
			{
				bufferScrittura=(unsigned char*)malloc(((2*numeroByte)+2)*sizeof(char));		//allocazione della memoria per bufferScrittura
				i=0;
				while(i<(numeroByte*2))
				{
					bufferScrittura[i]='*';
					bufferScrittura[i+1]=lettera;
					i+=2;
				}
					bufferScrittura[i]=resto;
					bufferScrittura[i+1]=lettera;
					
				fileScritto=fwrite(bufferScrittura,1,((2*numeroByte)+2),ilfile);
			}
		}
	}
	
	
	

/*Funzione comprimi()
E' la funzione che viene chiamata nel caso che il file passato al programma sia di tipo .txt .
Essa creerà un nuovo file di tipo .rle .
La funzione scorre tutto il bufferLettura, su cui è caricato il file di testo,  e conteggia il numero di occorrenze di ogni lettera
finchè non viene incontrata una lettera diversa.In tal caso verrà chiamata la funzione scritturaFileCompresso() che scriverà 
lettera e numero di occorenze nel file binario.
*/

void comprimi(unsigned char *nomeDelFile) 
{
	FILE *fileTesto;   										//puntatore al file di testo
	FILE *fileBinario;   									//puntatore al  file binaro
	FILE *fileWorld;										//puntatore al file .world per la scrittura delle 100 parole più frequenti
	unsigned char bufferLettura[LUNGHEZZA_BUFFER_LETTURA];	//buffer in cui è contenuto il file di testo da cui leggeremo i caratteri
	unsigned char test;										//carattere d'appoggio utilizzato per confrontare le lettere
	unsigned char *nomeCompresso;							//puntatore usato per scrivere l'estensione .rle del file compresso	
	unsigned char *nomeWorld;								//puntatore usato per scrivere l'estensione .world del file contenente le 100 parole
	int lunghezzaNomeFile=0;								//conterrà la lunghezza del nome del file da comprimere
	int contaLettere=0;										//contatore delle occorrenze delle lettere	
	int numeroByte=0;										//conterrà il numero dei byte letti dalla fread
	int primaLettera=0;										//controllo sulla lettura della prima lettera dal bufferLettura
	int j=0,k=0;											//contatori usati nei cicli
	

	
	lunghezzaNomeFile=strlen(nomeDelFile);
	
	nomeCompresso=(unsigned char*)malloc((lunghezzaNomeFile+4)*(sizeof(char)));
	
	ASSERT((nomeCompresso!=NULL),("\nErrore nell'allocazione di nomeCompresso!\n"));	

	
	strcpy(nomeCompresso,nomeDelFile);
	strcat(nomeCompresso,".rle");			
	
	fileBinario=fopen(nomeCompresso,"wb");  //apertura del file binario in modalità scrittura binaria

	ASSERT((fileBinario!=NULL),("\nErrore nell' apertura del file binario!\n"));	

	fileTesto=fopen(nomeDelFile,"r");		//apertura del file di testo in modalità lettura
	
	
	ASSERT((fileTesto!=NULL),("\nErrore nell' apertura del file di testo!\n"));
	
	
	//controllo se il file di testo è vuoto	
	test=fgetc(fileTesto);
	if(feof(fileTesto))
	{
		printf("\nFile vuoto!\n");
		
		lunghezzaNomeFile=strlen(nomeDelFile);												//creazione dell'estenzione .world per il file delle 100 parole
		nomeWorld=(unsigned char*)malloc((lunghezzaNomeFile+6)*(sizeof(char)));				
		ASSERT((nomeWorld!=NULL),("\nErrore nell'allocazione di memoria di nomeWorld!\n"));	//controllo sulla corretta creazione dell'area di memoria dedicata all'estenzione .world
		strcpy(nomeWorld,nomeDelFile);
		strcat(nomeWorld,".world");
		fileWorld=fopen(nomeWorld,"w");														//apertura del file .world in modalità scrittura
		ASSERT((fileWorld!=NULL),("\nErrore nell'apertura del file .world!\n"));			//controllo sulla corretta apertura del file di testo
		fclose(fileTesto);																	//chiusura del file di testo
		fclose(fileBinario);																//chiusura del file binario
		fclose(fileWorld);																	//chiusura del file .world
		exit(1);
	}
	rewind(fileTesto);			
	
	printf("\nCompressione..\n");
	fflush(stdout);
	
	//memorizzo dentro bufferLettura tutti i caratteri presenti sul fileTesto fino ad arrivare ad End Of File
while(!feof(fileTesto))
{
	numeroByte=fread(bufferLettura,1,LUNGHEZZA_BUFFER_LETTURA,fileTesto); 	//numeroByte indica quanti byte sono stati effettivamente letti con la fread
	
		if(!primaLettera)
		{													//controllo sulla lettura della prima lettera			
			test=bufferLettura[0];
			primaLettera=1;		
		}	
		
		j=0;
		
		for(k=0;k<numeroByte;k++)										//lettura di tutti i numeroByte caricati in bufferLettura	
		{																//conto le occorrenze della lettera finchè non ne trovo una differente
			if(bufferLettura[j]==test)									
			{
				
				contaLettere++;				
				j++;
				
			}	
		else
		{
			if(test==' ')					
			{								
				
				test=64;							//se la lettera è uno spazio,le verrà assegnato il valore 96 che utilizzerò per salvarlo come 0 sul file compresso
			}
				
				scritturaFileCompresso(test,contaLettere,fileBinario); //chiamata a funzione per la scrittura del file compresso   
																	   
					
				test=bufferLettura[j];					//ora test sarà uguale alla nuova lettera da contare
				k--;									//k viene decrementato per non perdere la lettura di caratteri
				contaLettere=0;							//azzero il contatore delle occorrenze
		
		}			
	}
}	
			//richiamo la funzione scritturaFileCompresso() per poter scrivere sul file binario anche l'ultima lettera
		
		if(test==' ')					
			{								
				
				test=64;							//se la lettera è uno spazio,le verrà assegnato il valore 96 che utilizzerò per salvarlo come 0 sul file compresso
			}
	scritturaFileCompresso(test,contaLettere,fileBinario);
	
	printf("\nScrittura file compresso!\n");
	
	fflush(stdout);
	
	

	/*chiusura dei file aperti*/
	fclose(fileBinario);	
	fclose(fileTesto);
	
	/*deallocazione la memoria*/
	free(nomeCompresso);

}



/*  Funzione main()
	all'interno della funzione main identifico il tipo di file e, se mi viene passato un file .txt, lo devo comprimere o, se mi viene passato un file .rle, lo devo decomprimere .
*/		
	int main(int argc, char *argv[])
{
	char *nomeDelFile;						//puntatore al nome del file da comprimere o decomprimere
	int dimensioneNomeFile=0;				//conterrà la dimensione del nome del file da comprimere o decomprimere
	time_t inizio;							//variabile utilizzata per segnare il tempo di inizio di compressione/decompressione e del conteggio delle cento parole più frequenti
	time_t fine;							//variabile utilizzata per segnare il tempo di fine di compressione/decompressione e del conteggio delle cento parole più frequenti
	double tempoTotale;						//variabile per calcolare il tempo totale della compressione/decompressione e del conteggio delle cento parole più frequenti

	if(argc!=2)								//controllo sul numero di parametri per far partire il programma che devono essere: <nome programma> <nome file>
	{							
		printf("\nErrore!Indicare il nome del file da comprimere o da decomprimere\n");
		exit(1);
	}	
	
	nomeDelFile=argv[1];					//copio il contenuto di argv[1] che contiene il nome del file da comprimere/decomprimere
	
	dimensioneNomeFile=strlen(argv[1]);		//misuro la lunghezza del nome del file
	
//identifico se il file è da comprimere o decomprimere,analizzando la sua estensione
if((nomeDelFile[dimensioneNomeFile-1]=='t')&&(nomeDelFile[dimensioneNomeFile-2]=='x')&&(nomeDelFile[dimensioneNomeFile-3]=='t'))
{			inizio=time(NULL);
			comprimi(nomeDelFile);			//parte in esecuzione la funzione comprimi 
			fine=time(NULL);
			tempoTotale=fine-inizio;
			printf("\nCompressione avvenuta in %f secondi\n",tempoTotale);
			fflush(stdout);			
					
}
else
{
		//Errore sul metodo di avvio del programma per la compressione/decompressione di un testo
	printf("\nErrore!Il file da comprimere o da decomprimere deve avere estenzione .txt oppure .rle!\n");	
}


return 0;
}