Yûki - Compress working

Compress.c

@@ -125,6 +125,21 @@ void init_codage(plex Code[], int n){
   }
 }
 
+void compression(plex *Code,int n){
+  Bin_file *cmp;
+  cmp=Ouv_Bit("cmp.txt",'w');
+  printf("%s",(Code[0]->code)[0]);
+  int i;
+  for(i=0;i<n;i++){
+    char *s;
+    s=Code[i]->code;
+    while(s!='\0'){
+      Ec_Bit(cmp,s);
+      s++;
+    } 
+  }
+}
+
 /*#########################################################################################################*/
 
 /*                                  Partie Gestion de fichiers                                             */

arbre_de_codage/arbre_binaire.c

@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <string.h>
 #include "arbre_binaire.h"
-#define DEBUG 1
 
 arbre creer_arbre_vide (void)
 {
@@ -50,9 +49,8 @@ arbre creer_feuille(Elt e, int p)
 
 bool est_feuille(arbre a)
 {
-  if(est_arbre_vide(a)){
+  if (est_arbre_vide(a))
     return 0 ;
-  }
   return (est_arbre_vide(a->fils_gauche) && est_arbre_vide(a->fils_droit)) ;
 }
 
@@ -72,30 +70,8 @@ void free_arbre(arbre 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));
   if(!est_arbre_vide(a)){
-      printf("  est_feuille(a) : %d\n",(est_feuille(a)));
+    if((a->fils_gauche==NULL)&&(a->fils_droit==NULL)&&(racine(a)==c)){
-      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)){
-    printf("Racine : %c",racine(a));
-    if(racine(a)==c){
       found[0]=1;
       s[s_len]='\0';
       return ;

arbre_de_codage/arbre_binaire.h

@@ -1,10 +1,10 @@
 #ifndef __ARBRE_BINAIRE__
 #define __ARBRE_BINAIRE__
 
-typedef int Elt;
+typedef char Elt;
 typedef int bool;
 struct znoeud {
-  char elt ;
+  Elt elt ;
   int poids;
   struct znoeud *fils_gauche;
   struct znoeud *fils_droit; 
@@ -12,19 +12,15 @@ struct znoeud {
 typedef struct znoeud noeud ;
 typedef struct znoeud * arbre;
 
-typedef struct zcode{
-  int lettre;
-  char *s;
-} codage;
-typedef struct zcode * code;
-
 arbre creer_arbre_vide(void);
 arbre creer_arbre_huffman(Elt e, int p, arbre fg, arbre fd);
 arbre fils_gauche(arbre a);
 arbre fils_droit(arbre a);
 Elt racine(arbre a);
 bool est_arbre_vide(arbre a);
+
 arbre creer_feuille(Elt e, int p) ;
 bool est_feuille(arbre a) ;
 void arbre_rechercher(arbre a, Elt c, char s[], int s_len, int found[]);
+void serialisation(arbre a,FILE *file);
 #endif

gestion_des_fichiers/gestion_fichiers.c

@@ -7,9 +7,6 @@
 #include <string.h>
 #include "gestion_fichiers.h"
 
-
-
-
 Bin_file *Ouv_Bit(char *p,char mode)
 {
     Bin_file *A;
@@ -52,9 +49,11 @@ void Ec_Bit(Bin_file *output,char bit)                              // On veux u
         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
+        output->nb_octets++; 
+        printf("ouput : %d %d\n",output->i_record,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.
         {
+          printf("test\n");
           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
         }
@@ -113,7 +112,7 @@ 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  
+    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
         {
@@ -141,31 +140,3 @@ int Ferm_Bit(Bin_file *fichier)
     free(fichier);
     return nb_octets;
 }
-
-/*
-void main()
-{ 
-    Bin_file *p;
-    char s[16];
-    int i;
-    p=Ouv_Bit("test.txt",'r');
-    printf("%i\n",p->record_length);
-    for (i=0;i<16;i++){
-        s[i]=Lec_Bit(p);
-    }
-    for(i=0;i<16;i++){
-        printf("%c",s[i]);
-    }
-    Ferm_Bit(p);
-    p=Ouv_Bit("test.txt","w");
-    Ec_Bit(p,'0');
-    Ec_Bit(p,'1');
-    Ec_Bit(p,'1');
-    Ec_Bit(p,'0');
-    Ec_Bit(p,'0');
-    Ec_Bit(p,'1');
-    Ec_Bit(p,'1');
-    Ec_Bit(p,'0');
-    Ferm_Bit(p);
-}
-*/

gestion_des_fichiers/gestion_fichiers.h

@@ -3,10 +3,10 @@
 */
 #ifndef __GESTION_FICHIERS__
 #define __GESTION_FICHIERS__
-#include <stdio.h>
+#define BLOCK_SIZE 1                  //il faut changer sa valeur pour les tests avec blocsize = nb d'octet qu'on veut écrire
-#define BLOCK_SIZE 128                  //il faut changer sa valeur pour les tests avec blocsize = nb d'octet qu'on veut écrire
 
-struct zBin_file{
+typedef struct
+{
     FILE *file;                         // Identificateur fichier
     char mode;                          //Mode de lecture r ou w
     unsigned char record[BLOCK_SIZE];   //Tampon pour lire ou écrire
@@ -16,16 +16,11 @@ struct zBin_file{
     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);
-
 void Ec_Bit(Bin_file *output,char bit);
-
 char Lec_Bit(Bin_file*input);
-
 int Ferm_Bit(Bin_file *fichier);
 
 #endif

main_compress.c

@@ -1,17 +1,18 @@
 #include <stdio.h>
 #include <string.h>
-#include "arbre_de_codage/arbre_binaire.c"
+#include <assert.h>
+#include <stdlib.h>
+#include "gestion_des_fichiers/gestion_fichiers.h"
 #include "main_compress.h"
+#include "arbre_de_codage/arbre_binaire.h"
+
 #define ASCII_EXT 256
 
-
-
-
 // main_compress.c [nom_du_fichier_a_compresser]
 int main(int argc, char **argv){
-  FILE *file;
+  Bin_file *p;
-  const char *filename = argv[1];
+  char *filename = argv[1];
-  const char *mode= "rb";
+  char mode= 'r';
   // Vérification de l'existance du second argument (Nom du fichier à compresser)
   printf("Argc : %d\n",argc);
   if(argc != 2){
@@ -19,7 +20,7 @@ int main(int argc, char **argv){
     return -1;
   }
   // Vérification de l'ouverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
-  else if(!(file=fopen(filename,mode))){
+  else if(!(p=Ouv_Bit(filename,mode))){
     printf("\nErreur : Fichier %s inexistant\n",filename);
     return -2;
   }
@@ -28,36 +29,25 @@ int main(int argc, char **argv){
   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,file);          // On récupère la fréquence d'apparition des lettres du fichiers
+  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");
- // Récupération du code de chaque charactere
+  int found[1]={0};
-  printf("Code : \n");
+  int taille=huff->poids;
-  char s[10]="";
+  plex Codage[taille];
-  int f[1]={0};
+  init_codage(Codage,taille);
-  char search='-';
+  printf("Lexique:\n");
-  arbre_rechercher(huff,search,s,0,f);
+  get_lexique(p->file, Codage,huff);
-  if(f[0]==1){
+  printf("Compression %s : \n",Codage[0]->code);
-    printf("\nTrouve : %s\n",s);
+  compression(Codage,taille,huff);
-  }
+  printf("Fermeture:\n");
-  else{
+  Ferm_Bit(p);
-    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;
 }
 
@@ -68,16 +58,6 @@ 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){
@@ -126,8 +106,6 @@ void afficher_tab(arbre T[], int n){
 
 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;
@@ -151,18 +129,50 @@ arbre huffman(arbre T[]){
   return T[Index];
 }
 
+void init_codage(plex Code[], int n){
+  int i;
+  int j;
+  for(i=0;i<n;i++){
+    lex * tmp = malloc(sizeof(lex));
+    for(j=0;j<ASCII_EXT;j++){
+        tmp->code[j]=0;
+    }
+    tmp->lettre=0;
+    Code[i]=tmp;
+  }
+}
+
 void get_lexique(FILE *file, plex Code[], arbre huff){
-  int c_int;
+  int i;
   char c_char;
-  while((c_int=fgetc(file))!=EOF){
+  rewind(file);
-    c_char = c_int;
+  i=0;
-    if(Code[c_int]->lettre!=c_char){
+  char s[ASCII_EXT]="";
-      Code[c_int]->lettre=c_char;
+  while((c_char=fgetc(file))!=EOF){
-      char s[9]="";
+    Code[i]->lettre=c_char;
     int f[1]={0};
     arbre_rechercher(huff,c_char,s,0,f);
-      printf("Code %c : %s\n",c_int,s);
+    strcpy(Code[i]->code,s);
-      Code[c_int]->code=s;
+    printf("Code %c : %s\n",c_char,Code[i]->code);
+    i++;
   }
 }
+
+void compression(plex Code[],int n, arbre H){
+  Bin_file* cmp;
+  cmp=Ouv_Bit("cmp.txt",'w');
+  serialisation(H,cmp->file);
+  fwrite("123",3,1,cmp->file);
+  int i;
+  int j;
+  char tmp;
+  for(i=0;i<n;i++){
+    j=0;
+    while(Code[i]->code[j]!='\0'){
+      printf("  %s %c\n",Code[i]->code,Code[i]->code[j]);
+      Ec_Bit(cmp,Code[i]->code[j]);
+      j++;
+    }
+    printf("\n");
+  }
 }

main_compress.h

@@ -1,11 +1,12 @@
 #ifndef __MAIN_COMPRESS__
 #define __MAIN_COMPRESS__
-#include "arbre_de_codage/arbre_binaire.h"
 #include <stdio.h>
+#include "arbre_de_codage/arbre_binaire.h"
+#include "gestion_des_fichiers/gestion_fichiers.h"
 
 struct lexique{
     char lettre;
-    char *code;
+    char code[256];
 };
 typedef struct lexique lex;
 typedef struct lexique* plex;
@@ -15,7 +16,7 @@ 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);
+void init_codage(plex Code[], int n);
 
 #endif