yvachot/Projet-C-Huffman
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Yûki - No MakeFile

Browse source
This commit is contained in:
name 2019-12-15 16:06:48 +01:00
parent 35865485a0
commit e7305b7ab8
No known key found for this signature in database
GPG key ID: 03E8F3CF3183323A
8 changed files with 532 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

425
Compress.c Normal file
View file

@ -0,0 +1,425 @@
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include<stdlib.h>
#include "gestion_des_fichiers/gestion_fichiers.h"
#include "main_compress.h"
#include "arbre_de_codage/arbre_binaire.h"
#ifdef DEBUG
#define DEBUG 1
#endif
#define ASCII_EXT 256
// main_compress.c [nom_du_fichier_a_compresser]
/*#########################################################################################################*/
/* Partie Fonction pour compression */
/*#########################################################################################################*/
void init_tab(arbre T[], int n){
int i;
for(i=0;i<n;i++){
T[i]=creer_feuille(-1,-1);
}
}
void frequence(arbre T[], FILE *file){
int c;
while((c=fgetc(file))!=EOF){
if(T[c]->poids!=-1){
T[c]->poids++;
}
else{
T[c]->elt=c;
T[c]->poids=1;
}
}
}
void tri_tab(arbre T[],int n){
int i,j;
arbre tmp;
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
if(T[i]->poids>T[j]->poids){
tmp=T[i];
T[i]=T[j];
T[j]=tmp;
}
}
}
}
int compteur_tab(arbre T[], int n){
int i,compteur;
compteur=0;
for(i=0;i<n;i++){
if(T[i]->poids != -1){
compteur++;
}
}
return compteur;
}
void afficher_tab(arbre T[], int n){
printf("\n");
int i;
for (i=0;i<n;i++){
printf("T[%d] = %d (%c)\n",i,T[i]->poids,T[i]->elt);
}
}
arbre huffman(arbre T[]){
// Création de l'arbre de codage de Huffman en considérant une liste avec les fréquences d'apparition des caractères ordonnée croissante
// récupérer les deux plus petits poids (cf : deux premieres occurences)
arbre H = malloc(sizeof(arbre));
H=creer_arbre_vide();
int i;
i=0;
while(T[i]->poids==-1){
i++;
}
int Index;
Index=i;
while(Index<ASCII_EXT-1){
arbre tmp=malloc(sizeof(noeud*));
tmp->elt=NULL;
tmp->fils_gauche=T[Index];
tmp->fils_droit=T[Index+1];
tmp->poids=T[Index]->poids +T[Index+1]->poids;
T[Index+1]=tmp;
printf("%d (%c | %c)\n",tmp->poids,tmp->fils_gauche->elt,tmp->fils_droit->elt);
Index++;
tri_tab(T,ASCII_EXT);
}
return T[Index];
}
void get_lexique(FILE *file, plex Code[], arbre huff){
int c_int;
char c_char;
rewind(file);
while((c_int=fgetc(file))!=EOF){
c_char = c_int;
if(Code[c_int]->lettre!=c_char){
Code[c_int]->lettre=c_char;
char s[9]="";
int f[1]={0};
arbre_rechercher(huff,c_char,s,0,f);
printf("Code %c : %s\n",c_int,s);
Code[c_int]->code=s;
}
}
}
void init_codage(plex Code[], int n){
int i;
for(i=0;i<n;i++){
lex * tmp = malloc(sizeof(lex));
tmp->code=NULL;
tmp->lettre=NULL;
Code[i]=tmp;
}
}
/*#########################################################################################################*/
/* Partie Gestion de fichiers */
/*#########################################################################################################*/
Bin_file *Ouv_Bit(char *p,char mode)
{
Bin_file *A;
A=malloc(sizeof(Bin_file)); //On libère l'espace suffisant pour un élèment de type Bin_files
A->mode=mode; //On récupére le mode d'ouverture du fichier et on le rentre dansle struct
if(mode=='r') //suivant le mode (écriturer w ou lecture r) on va ouvrir le fichier a l'aide de fopen et on
{ //enregistre cela dans lestruct Bin_files
A->file=fopen(p,"rb");
}
else
{
A->file=fopen(p,"wb");
}
A->record_length=0; //On va ensuite initialiser tous les élèments du struct.
A->i_record=0;
A->i_octet=0;
A->nb_octets=0;
return A;
}
void Ec_Bit(Bin_file *output,char bit) // On veux une fonction capable d'écrire un bit dans un fichier
{
unsigned char octet,b; // On utilise deux variables octet et b qui vont permettre de récupérer les élèmets a écrire.
int i;
output->octet[output->i_octet]=bit; // On va mettre le premier élèment du tableau octet de la struct Bin_file a la valeur de bit
output->i_octet++; //On incremente aussi i_octet pour ne pas réecrire surcette valeur
if (output->i_octet==8) //Si le tableau octet est plein on va aller écire dans le tableau record
{
octet=0; //on passe octet a 0 et b a 0x80 soit 1000 0000
b=0x80; // cela permet de toujoursgarder 1 en bit de poids fort dans b apre les décalages a droite
for(i=0;i<8;i++)
{
if(output->octet[i]=='1') //si on a un '1' dans le tableau octet on va mettre dans octet le résultats de octet ou b
{
octet=octet|b; // On va alors creer une "copie" du tableau octet dans octet
}
b=b>>1;
}
output->i_octet=0;
output->record[output->i_record]=octet; // On va apres le for remetre i_octet a 0 puis on passe dans record la valeur du char octet pour conserver
output->i_record++; //ce que l'on veut écrire
output->nb_octets++; //On incrémente aussi i record pour passer a l'élèment suivant et nb_octets car on en a traiter un autre
if(output->i_record==BLOCK_SIZE) //On vérifie ensuite que record qui sert de buffer soit plein avant d'écrire sont contenue.
{
fwrite(output->record,1,BLOCK_SIZE,output->file);
output->i_record=0; //si on éceit on reinitialise i record pour passer auxélèments suivant
}
}
}
char Lec_Bit(Bin_file*input)
{
char bit; //On veut lire un fichier bit a bit. Pourcela on va vérifier si la record length est nul ou non
unsigned char x, b=0x80; // Ici on déclare de char, x va permettre de récupérer un octet de record
// b vas servir de masque. Il nous permettra de savoir quelle valeur possède les bits des élèment de record
int i; //i est un compteur utiliser pour les boucles for
if (input->record_length==0){ // Si le buffer (record),est vide on va aller chercher lesélèments du fichier
input->record_length = fread(input->record,1,BLOCK_SIZE,input->file); //Pour cela on récupère dans record_length le nombre d'élèment de input-file et on les écrit dans record
input->i_record=0; //On réinitialise l'indice de record pour recommencerdepuis le début.
x = input->record[input->i_record] ; //On réupère la valeurde record[i_record] dans x
for(i=0;i<8;i++) {
if(x&b) input->octet[i]='1'; //On va alors tester les bits de x grace a x&b. Cela permet de renvoyer 1 si lesdeux bits sont a 1
else input->octet[i]='0'; // si le test est vrai on ajoute le char 1 dans octet sinon 0
b=b>>1; //On décale ensuite b de 1 bit a droite pourconserver le 1 a l'endroit que l'on veut tester
}
input->octet[8]=0; //On passe le derneir élèment de octet a 0 pour marquer la fin de chaine de caractère
input->i_record++; //on incrémente i record pour aller a l'élèment suivant on réinitialise i_octet et
input->i_octet=0;
input->nb_octets=input->nb_octets+input->record_length; //On ajoute la taille du record dans nb_octets pour conserver le bon nombred'élèment traité
}
bit=input->octet[input->i_octet]; //On passe alors bit a la valeur de octet[0]
input->i_octet++; //on incrémente ensuite le compteur
if(input->i_octet==8){ // Si on a écrit huit bit dans octet on va aller tester l'élèment suivant de record
x = input->record[input->i_record] ;
for(i=0;i<8;i++) {
if(x&b) input->octet[i]='1';
else input->octet[i]='0';
b=b>>1;
}
input->octet[8]=0;
input->i_record++;
input->i_octet=0;;
if(input->i_record==BLOCK_SIZE){ //si on a parcouru tous le buffer on repasse a 0 la longueur
input->record_length=0;
}
}
return bit; // on renvoie le bit
}
int Ferm_Bit(Bin_file *fichier)
{
unsigned char octet,b; // On déclare deux unsigned char octet et b qui auront la même utilité que dans Ec_Bit
int nb_octets=fichier->nb_octets;
if(fichier->mode="w") // Si le fichier a été ouvert en mode écriture on va aller écrire la fin du buffer
{ // dans le fichier.
if(fichier->i_octet!=0) //Pour cela on répète le même principe que dans Ec_Bit
{
octet=0;
b=0x80;
int i;
for(i=0;i<fichier->i_octet;i++)
{
if(fichier->octet[i]=='1')
{
octet=octet|b;
}
b=b>>1;
}
fichier->record[fichier->i_record]=octet;
fichier->i_record++;
nb_octets++;
}
if(fichier->i_record!=0)
{
fwrite(fichier->record,1,BLOCK_SIZE,fichier->file);
}
}
fclose(fichier->file); //On ferme ensuite le fichier et on libère l'espace occupé par le srtuct Bin_File.
free(fichier);
return nb_octets;
}
/*#########################################################################################################*/
/* Partie Arbre binaire */
/*#########################################################################################################*/
arbre creer_arbre_vide (void)
{
return NULL ;
}
arbre creer_arbre_huffman(Elt e, int p, arbre fg, arbre fd)
{
noeud * tmp = malloc(sizeof(noeud));
tmp->elt=e;
tmp->poids=p;
tmp->fils_gauche=fg;
tmp->fils_droit=fd;
return tmp;
}
arbre fils_gauche(arbre a)
{
assert(!est_arbre_vide(a));
return a->fils_gauche;
}
arbre fils_droit(arbre b)
{
assert(!est_arbre_vide(b));
return b->fils_droit;
}
Elt racine(arbre a)
{
assert(!est_arbre_vide(a));
return a->elt;
}
bool est_arbre_vide(arbre a)
{
return (a == NULL) ;
}
arbre creer_feuille(Elt e, int p)
{
return creer_arbre_huffman(e, p, creer_arbre_vide(), creer_arbre_vide()) ;
}
bool est_feuille(arbre a)
{
if (est_arbre_vide(a))
return 0 ;
return (est_arbre_vide(a->fils_gauche) && est_arbre_vide(a->fils_droit)) ;
}
void free_noeud(arbre a)
{
assert(!est_arbre_vide(a));
free(a);
}
void free_arbre(arbre a)
{
if(!est_arbre_vide(a)){
free_arbre(fils_gauche(a));
free_arbre(fils_droit(a));
free(a);
}
}
void arbre_rechercher(arbre a, Elt c, char s[], int s_len, int found[]){
/*
De ce que j'ai testé, ça marche de temps en temps même en ne changeant pas le caractère recherché, je pense qu'il y a un problème avec VSCode encore une fois LOL (Yûki)
*/
#ifdef DEBUG
printf("\nDEBUG ARBRE RECHERCHER : \n");
printf(" est_arbre_vide(a) : %d\n",est_arbre_vide(a));
printf(" est_feuille(a) : %d\n",est_feuille(a));
printf(" racine(a) : %c\n",racine(a));
printf(" c : %c\n",c);
printf(" est_arbre_vide(fils_gauche(a)) : %d\n",est_arbre_vide(fils_gauche(a)));
printf(" est_arbre_vide(fils_droit(a)) : %d\n",est_arbre_vide(fils_droit(a)));
printf(" S : %s\n",s);
printf("--FIN DEBUG ARBRE RECHERCHER--\n");
#endif
if(!est_arbre_vide(a)){
if((a->fils_gauche==NULL)&&(a->fils_droit==NULL)&&(racine(a)==c)){
found[0]=1;
s[s_len]='\0';
return ;
}
if(!est_arbre_vide(fils_gauche(a))&&(found[0]==0)){
s[s_len]='0';
arbre_rechercher(fils_gauche(a),c,s,s_len+1,found);
}
if(!est_arbre_vide(fils_droit(a))&&(found[0]==0)){
s[s_len]='1';
arbre_rechercher(fils_droit(a),c,s,s_len+1,found);
}
}
}
/*#########################################################################################################*/
/* Main */
/*#########################################################################################################*/
int main(int argc, char **argv){
Bin_file *p;
char *filename = argv[1];
char mode= 'r';
// Vérification de l'existance du second argument (Nom du fichier à compresser)
printf("Argc : %d\n",argc);
if(argc != 2){
printf("\nErreur : Veuillez mettre en argument un nom de fichier à compresser (Ex: %s text.txt)\n",argv[0]);
return -1;
}
// Vérification de l'ouverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
else if(!(p=Ouv_Bit(filename,mode))){
printf("\nErreur : Fichier %s inexistant\n",filename);
return -2;
}
printf("Tableau : \n");
arbre N[ASCII_EXT]; // Initialisation de l'arbre
printf("Tableau initialisé -1: \n");
init_tab(N,ASCII_EXT); // On initialise l'arbre avec des poids de -1
printf("Tableau get freq : \n");
frequence(N,p->file); // On récupère la fréquence d'apparition des lettres du fichiers
printf("Tableau tri : \n");
tri_tab(N,ASCII_EXT); // On fait un tri à bulle sur ce tableau
printf("Tableau affichage : \n");
afficher_tab(N,ASCII_EXT);
arbre huff;
printf("Huffman : \n");
huff = huffman(N);
printf("Arbre :\n");
int found[1]={0};
plex Codage[ASCII_EXT];
init_codage(Codage,ASCII_EXT);
get_lexique(p->file, Codage,huff);
Ferm_Bit(p);
return 0;
}

20
Makefile
View file

@ -1,19 +1,19 @@
CC = gcc
CCOPTS = -Wall
all: main
all: main_compress
arbre_naire.o: arbre_naire.c arbre_naire.h
${CC} ${CCOPTS} -c arbre_naire.c
arbre_binaire.o: arbre_de_codage/arbre_binaire.c arbre_de_codage/arbre_binaire.h
${CC} ${CCOPTS} -c arbre_de_codage/arbre_binaire.c
arbre_binaire.o: arbre_binaire.c arbre_binaire.h
${CC} ${CCOPTS} -c arbre_binaire.c
gestion_fichiers.o: gestion_des_fichiers/gestion_fichiers.c gestion_des_fichiers/gestion_fichiers.h
${CC} ${CCOPTS} -c gestion_des_fichiers/gestion_fichiers.c
main.o: main.c
${CC} ${CCOPTS} -c main.c
main_compress.o: main_compress.c
${CC} ${CCOPTS} -c main_compress.c
main: main.o arbre_naire.o arbre_binaire.o
${CC} ${CCOPTS} -o main main.o arbre_naire.o arbre_binaire.o
main_compress: main_compress.o arbre_binaire.o gestion_fichiers.o
${CC} ${CCOPTS} -o main_compress main_compress.o arbre_binaire.o gestion_fichiers.o
clean:
rm *.o ; rm main
rm *.o ; rm main_compress

22
arbre_de_codage/arbre_binaire.c
View file

@ -3,9 +3,8 @@
#include <assert.h>
#include <string.h>
#include "arbre_binaire.h"
#ifdef DEBUG
#define DEBUG 1
#endif
arbre creer_arbre_vide (void)
{
return NULL ;
@ -51,8 +50,9 @@ arbre creer_feuille(Elt e, int p)
bool est_feuille(arbre a)
{
if (est_arbre_vide(a))
return 0 ;
if(est_arbre_vide(a)){
return 0;
}
return (est_arbre_vide(a->fils_gauche) && est_arbre_vide(a->fils_droit)) ;
}
@ -75,21 +75,29 @@ void arbre_rechercher(arbre a, Elt c, char s[], int s_len, int found[]){
/*
De ce que j'ai testé, ça marche de temps en temps même en ne changeant pas le caractère recherché, je pense qu'il y a un problème avec VSCode encore une fois LOL (Yûki)
*/
/*
#ifdef DEBUG
printf("\nDEBUG ARBRE RECHERCHER : \n");
printf(" est_arbre_vide(a) : %d\n",est_arbre_vide(a));
printf(" est_feuille(a) : %d\n",est_feuille(a));
if(!est_arbre_vide(a)){
printf(" est_feuille(a) : %d\n",(est_feuille(a)));
printf(" racine(a) : %c\n",racine(a));
printf(" c : %c\n",c);
printf(" est_arbre_vide(fils_gauche(a)) : %d\n",est_arbre_vide(fils_gauche(a)));
printf(" est_arbre_vide(fils_droit(a)) : %d\n",est_arbre_vide(fils_droit(a)));
printf(" S : %s\n",s);
printf("--FIN DEBUG ARBRE RECHERCHER--\n");
}
else{
printf("ARBRE VIDE\n");
}
#endif
*/
if(!est_arbre_vide(a)){
if((a->fils_gauche==NULL&&a->fils_droit==NULL)&&racine(a)==c){
printf("Racine : %c",racine(a));
if(racine(a)==c){
found[0]=1;
s[s_len]='\0';
return ;
}
if(!est_arbre_vide(fils_gauche(a))&&(found[0]==0)){

2
arbre_de_codage/arbre_binaire.h
View file

@ -1,7 +1,7 @@
#ifndef __ARBRE_BINAIRE__
#define __ARBRE_BINAIRE__
typedef char Elt;
typedef int Elt;
typedef int bool;
struct znoeud {
char elt ;

9
gestion_des_fichiers/gestion_fichiers.h
View file

@ -6,9 +6,8 @@
#include <stdio.h>
#define BLOCK_SIZE 128 //il faut changer sa valeur pour les tests avec blocsize = nb d'octet qu'on veut écrire
typedef struct
{
FILE*file; // Identificateur fichier
struct zBin_file{
FILE *file; // Identificateur fichier
char mode; //Mode de lecture r ou w
unsigned char record[BLOCK_SIZE]; //Tampon pour lire ou écrire
int record_length; //nombre d'élèments du tampon
@ -17,7 +16,9 @@ typedef struct
int i_octet; //indice dansl'octet
int nb_octets; //Nb octet lis/écrit
}Bin_file;
};
typedef struct zBin_file Bin_file;
typedef struct zBin_file pBin_file;
Bin_file *Ouv_bit(char *p,char mode);

2
gestion_des_fichiers/test.txt
View file

@ -1 +1 @@
mon code C est le meilleure : int myfunction(arbre ahah){printf("coucou");pointeur->quipointe;}
abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ1234567890-_()[]{},.

52
main_compress.c
View file

@ -1,12 +1,11 @@
#include <stdio.h>
#include <string.h>
#include "arbre_de_codage/arbre_binaire.c"
#include "main_compress.h"
#define ASCII_EXT 256
arbre huffman(arbre T[]);
void frequence(arbre T[], FILE *file);
void tri_tab(arbre T[],int n);
void afficher_tab(arbre T[], int n);
void init_tab(arbre T[], int n);
// main_compress.c [nom_du_fichier_a_compresser]
int main(int argc, char **argv){
@ -19,7 +18,7 @@ int main(int argc, char **argv){
printf("\nErreur : Veuillez mettre en argument un nom de fichier à compresser (Ex: %s text.txt)\n",argv[0]);
return -1;
}
// Vérification de l'o(uverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
// Vérification de l'ouverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
else if(!(file=fopen(filename,mode))){
printf("\nErreur : Fichier %s inexistant\n",filename);
return -2;
@ -41,7 +40,7 @@ int main(int argc, char **argv){
// Récupération du code de chaque charactere
printf("Code : \n");
char s[80]="";
char s[10]="";
int f[1]={0};
char search='-';
arbre_rechercher(huff,search,s,0,f);
@ -51,7 +50,14 @@ int main(int argc, char **argv){
else{
printf("\nPas Trouve\n");
}
plex Codage[ASCII_EXT];
rewind(file);
init_codage(Codage,ASCII_EXT);
get_lexique(file, Codage,huff);
printf("\nFIN TEST\n");
return 0;
}
@ -62,6 +68,16 @@ void init_tab(arbre T[], int n){
}
}
void init_codage(plex Code[], int n){
int i;
for(i=0;i<n;i++){
lex * tmp = malloc(sizeof(lex));
tmp->code=NULL;
tmp->lettre=0;
Code[i]=tmp;
}
}
void frequence(arbre T[], FILE *file){
int c;
while((c=fgetc(file))!=EOF){
@ -104,7 +120,7 @@ void afficher_tab(arbre T[], int n){
printf("\n");
int i;
for (i=0;i<n;i++){
printf("T[%d] = %d (%d)\n",i,T[i]->poids,T[i]->elt);
printf("T[%d] = %d (%c)\n",i,T[i]->poids,T[i]->elt);
}
}
@ -123,14 +139,30 @@ arbre huffman(arbre T[]){
Index=i;
while(Index<ASCII_EXT-1){
arbre tmp=malloc(sizeof(noeud*));
tmp->elt=-1;
tmp->elt=0;
tmp->fils_gauche=T[Index];
tmp->fils_droit=T[Index+1];
tmp->poids=T[Index]->poids +T[Index+1]->poids;
T[Index+1]=tmp;
printf("%d %c %c\n",tmp->poids,tmp->fils_gauche->elt,tmp->fils_droit->elt);
printf("%d (%c | %c)\n",tmp->poids,tmp->fils_gauche->elt,tmp->fils_droit->elt);
Index++;
tri_tab(T,ASCII_EXT);
}
return T[Index];
}
void get_lexique(FILE *file, plex Code[], arbre huff){
int c_int;
char c_char;
while((c_int=fgetc(file))!=EOF){
c_char = c_int;
if(Code[c_int]->lettre!=c_char){
Code[c_int]->lettre=c_char;
char s[9]="";
int f[1]={0};
arbre_rechercher(huff,c_char,s,0,f);
printf("Code %c : %s\n",c_int,s);
Code[c_int]->code=s;
}
}
}

21
main_compress.h Normal file
View file

@ -0,0 +1,21 @@
#ifndef __MAIN_COMPRESS__
#define __MAIN_COMPRESS__
#include "arbre_de_codage/arbre_binaire.h"
#include <stdio.h>
struct lexique{
char lettre;
char *code;
};
typedef struct lexique lex;
typedef struct lexique* plex;
arbre huffman(arbre T[]);
void frequence(arbre T[], FILE *file);
void tri_tab(arbre T[],int n);
void afficher_tab(arbre T[], int n);
void init_tab(arbre T[], int n);
void init_codage(plex Code[], int n);
void get_lexique(FILE *file, plex Code[], arbre huff);
#endif