IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

aide à propos de l'algorithme LZW


Sujet :

C

  1. #1
    Candidat au Club
    Inscrit en
    Décembre 2010
    Messages
    2
    Détails du profil
    Informations forums :
    Inscription : Décembre 2010
    Messages : 2
    Par défaut aide à propos de l'algorithme LZW
    bonjour
    j'ai des difficultés dans l'algorithme de LZW
    bon concernant la compression c'est bon ça marche.
    en fait j'ai pas pu faire une fct dans la partie du décompression c'est lire_x_bit qui me retourne le code du chaine compressée voilà mon code source é si vous pouvez m'aidez
    merci
    DICO.C
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
      #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <stdbool.h>
    #include "dico.h"
     
     
    t_Liste * Creer_liste(void) {
         return (t_Liste*) malloc(sizeof(t_Liste));
         }
     
    int Hacher(char* i_Sequence) {
        int Cle = (unsigned char) i_Sequence[0] + (unsigned char) i_Sequence[strlen(i_Sequence)] + strlen(i_Sequence);
        return Cle % MODULO_HACH;
    }
     
    void Apprendre_sequence (char* i_Sequence, int i_Code, t_Liste* io_Dico[]) {
         //On calcul la clé
         int Cle=Hacher(i_Sequence);
         t_Liste* Cellule;
         //on créé la cellule
         Cellule = Creer_liste();
         Cellule -> Code = i_Code;
         Cellule -> Sequence = (char *) malloc((strlen(i_Sequence) +1 ) * sizeof(char));
         strcpy(Cellule -> Sequence, i_Sequence);
         //On rajoute cette cellule en debut de la liste correspondante
         Cellule -> Suiv = io_Dico[Cle];
         io_Dico[Cle] = Cellule;
         }
     
    int Est_apprise(char* i_Sequence, t_Liste* io_Dico[])
    //renvoie le code de la chaine m si elle est deja aprise, -1 sinon
     {
         int Cle = Hacher(i_Sequence);
         int Code;
         bool Ok = false;
         t_Liste* Temp = io_Dico[Cle];//Pointeur sur la liste où doit se trouver la sequence si on la connais
         //si la Sequence n'est qu'un seul charactere, son code est le code ascii.
         if (strlen(i_Sequence) == 1)
         	{return (unsigned char) i_Sequence[0];}
         else { //tant qu'on a pas parcouru toute la liste et qu'on n'a pas trouvé la sequence
                while ((Temp != NULL) && !(Ok))
         		   {
    		    Ok = (strcmp(i_Sequence, Temp -> Sequence) == 0);
          	            Code = Temp -> Code;
         		    Temp = Temp -> Suiv;
                       }
    	  }
        if (Ok) return Code;
        else return -1;
    }
    void Vider_liste(t_Liste * io_Liste)
    {
     if (io_Liste != NULL)
        {
    	if (io_Liste->Suiv == NULL)
           	   {free(io_Liste->Sequence);
                free(io_Liste);}
        	else {Vider_liste(io_Liste->Suiv);
                free(io_Liste->Sequence);
                free(io_Liste);}
        }
    }
    void Vider_dico( t_Liste * io_Dico[])
    {int i;
     for (i=0; i<MODULO_HACH; i++)
    { Vider_liste(io_Dico[i]);
      io_Dico[i]=NULL;}
    }
     
    void afficher_dico(t_Liste * Dico[]){
    int i;
    t_Liste * temp;
     for (i=0; i<MODULO_HACH; i++)
       {temp=Dico[i];
       if (Dico[i] != NULL)
       {printf("[%d] :\n",i);
       while (temp != NULL)
         {printf(" (%s) ", temp->Sequence);
         temp=temp->Suiv;}printf("\n");}
       }
    }

    DICO.H

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    #define CODE_FIN 256
    #define CODE_RAZ 259
    #define CODE_BIT_SUP 258
    #define CODE_DEBUT 256
    #define TAILLE_MAX 65536 //2^16
    #define TAILLE_DEBUT 512 //2^9
    #define MODULO_HACH 3200
    #define NB_BIT_DEBUT 9
     
     
    typedef struct Liste  {
    			char* Sequence;
    			int Code;
    			struct Liste * Suiv;
    			}t_Liste;
     
    //creer une cellule d'une liste
    t_Liste * Creer_liste();
     
    //Donne une cle pour une Sequence (toujours la même clé pour la même sequence).
    int Hacher(char* i_Sequence);
     
    //rajoute la sequence et son code dans le Dictionnaire grace à la Clé
    void Apprendre_sequence (char* i_Sequence, int i_Cle, t_Liste* io_Dico[]);
     
    //si une séquence se trouve dans le dictionnaire elle renvoie son code, -1 sinon
    int Est_apprise(char* i_Sequence, t_Liste* io_Dico[]);
     
    //reinitialise le dictionnaire.
    void Vider_dico( t_Liste * io_Dico[]);
     
    //affiche les sequence présentes dans le dictionnaire.
    void afficher_dico(t_Liste * Dico[]);

    compression.c

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "dico.h"
    #include"compression.h"
     
    int Calculer_nb_bit(int i_Code)
    {
        if (i_Code <= 511) return 9;
        else if (i_Code <= 1023) return 10;
        else if (i_Code <= 2047) return 11;
        else if (i_Code <= 4095) return 12;
        else if (i_Code <= 8191) return 13;
        else if (i_Code <= 16383) return 14;
        else if (i_Code <= 32767) return 15;
        else return 16;
    }
     
    void Compresser_lzw(char * i_Nom_fichier_in, char* i_Nom_fichier_out)
    {
     
         FILE * Fichier_compresse;
         FILE * Curseur;
         char * Sequence = (char *) malloc(sizeof(char));
         char * Attente = (char *) malloc(sizeof(char));
         char  Lu;
         t_Liste * Dico[MODULO_HACH] = {NULL};
         int Code = CODE_DEBUT;
         //code==256=>fin de compression
         //code==257=>raz
         //code=258=>Nb_bit++
         int Code_Attente;
         int Code_Seq;
         int Nb_bit;
     
     
         Fichier_compresse = fopen(i_Nom_fichier_out, "wb");
         Curseur = fopen(i_Nom_fichier_in, "rb");
         Attente[0] = '\0';
         Sequence[0] = '\0';
         while (fread(&Lu, sizeof(char), 1, Curseur) == 1)
           {    free(Sequence);
                Sequence=(char *) malloc((strlen(Attente) + 2) * sizeof(char));
                strcpy(Sequence, Attente);
                strncat(Sequence, &Lu, 1);
    	    Code_Seq = Est_apprise(Sequence, Dico);
    	    //printf("Est_apprise\n");
                Nb_bit = Calculer_nb_bit(Code);
                if  (Code_Seq != -1)
    //si on connais la sequence, on la met en Attente.
    	      {
    	        free(Attente);
                    Attente = (char *) malloc((strlen(Sequence)+1) * sizeof(char));
    		strcpy(Attente, Sequence);
                     Code_Attente = Code_Seq;
                     }
                else
                    {
         //sinon on l'apprend.
    		//printf("code :%d\n",Code);
    		Apprendre_sequence(Sequence, Code, Dico);
                    ecrire_x_bit(Code_Attente, Nb_bit, Fichier_compresse);
                    //printf("ecrit : %d\n",Code_Attente);
                    Code++;
                    if (Nb_bit != Calculer_nb_bit(Code))
                       {
    			ecrire_x_bit (CODE_BIT_SUP, Nb_bit, Fichier_compresse);
                            Nb_bit = Calculer_nb_bit(Code);
                        }
             	free(Attente);
                    Attente=(char *) malloc(sizeof(char) + 1);
                    Attente[0] = Lu;
                    Attente[1] = '\0';
                    Code_Attente = (unsigned char) Lu;
    		if (Code == TAILLE_MAX) {
                               printf("Raz Dico\n");
    			   ecrire_x_bit(Code_Attente, Nb_bit, Fichier_compresse);
    			   ecrire_x_bit(CODE_RAZ, Nb_bit, Fichier_compresse);
                               Vider_dico(Dico);
                               Code = CODE_DEBUT;
    			   free(Attente);
    			   Attente = (char *) malloc(sizeof(char));
    			   Attente[0] = '\0';
                               }
     
     
                    }
         }
    //a la fin, il reste encore le dernier caractere Lu en Attente
          ecrire_x_bit(Code_Attente, Nb_bit, Fichier_compresse);
          ecrire_x_bit(CODE_FIN, Nb_bit, Fichier_compresse);
          fclose(Fichier_compresse);
          fclose(Curseur);
         free(Sequence);
         free(Attente);
    Vider_dico(Dico);
    }
    compression.h
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <stdbool.h>
     
    void ecrire_x_bit(int nb, int nbbit, FILE * Fic);
     
    void Compresser_lzw(char * i_Nom_fichier_in, char * i_Nom_fichier_out);
    void Decompresser_lzw(char * i_Nom_fichier_lzw);
     
    typedef struct Seq_Taille
    {
        char* Sequence;
        int Taille;
    } t_Seq_Taille;
    ecrire.c
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    #include<stdio.h>
    #include <math.h>
     
    static int t[8];//buffer
    static int position=0;
     
     
    void ecrire_x_bit(int nb, int nbbit, FILE * Fic)
    {int c=nb,i=position,codeascii=0,cptb=0; int x;
      int m,k=0;
    while (c!=0)
      {    t[i]=c%2;
           cptb++;
           i++;
           c=c/2;
           if (i==8) {
    	          for (m=0;m<8;m++)
    		    {
    		      codeascii=codeascii+t[m]*pow(2,(7-m));
    		    }
    		  x=(int)codeascii;
                      codeascii=0;
                      fwrite(&x,sizeof(char),1,Fic);
    		  i=0;
                     }
           }
    position=i;
    while (cptb!=nbbit)
          {
          i=position;
          t[i]=0;
          cptb++;
          i++;
          m=0;
          if (i==8) { for (m=0;m<8;m++)
                         {codeascii=codeascii+t[m]*pow(2,(7-m));}
                      x=(int)codeascii;
                      codeascii=0;
                      fwrite(&x,sizeof(char),1,Fic);
                      position=0;
                     }
                     else {position=i; }
          }
     
    if (nb==256 && position!=0)
      {
        for (k=position;k<8;k++)
             {t[k]=0;}
        for (i=0;i<8;i++)
                 {codeascii=codeascii+t[i]*pow(2,(7-i));}
        x=codeascii;
        fwrite(&x,sizeof(char),1,Fic);
        }
     
    }
    decompression.c
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <stdbool.h>
    #include"compression.h"
    #include "dico.h"
    #include "math.h"
    
    
    void Decompresser_lzw(char * i_Nom_fichier_lzw)
    {
    
         FILE * Curseur;
         FILE * Fichier_decompresse;
         int Code_lu;
         int Nb_bit=NB_BIT_DEBUT;
         t_Seq_Taille * Dico=(t_Seq_Taille *)malloc(pow(2,16)*sizeof(t_Seq_Taille));
         int i;
         int Codec=CODE_DEBUT;
         int Taille;
         //initialisation du dictionnaire sur les 256 premier caractères
         for (i=0;i<256;i++)
         {
    	Dico[i].Sequence=(char *)malloc(sizeof(char));
         	Dico[i].Sequence[0]=i;
         	//Dico[i].Sequence[1]='\0';
    	Dico[i].Taille=1;
         }
    
         for (i=256;i<pow(2,16);i++)
         {
    	Dico[i].Sequence=NULL;
    	Dico[i].Taille=0;
         }
         Curseur=fopen(i_Nom_fichier_lzw,"r");
         Fichier_decompresse=fopen("decompression.txt","w");
         Code_lu=lire_x_bit(NB_BIT_DEBUT,Curseur);
         //on verifie qu'on a pas compresse un fichier vide
         if (Code_lu != CODE_FIN)
    	{
            fread(&Code_lu,sizeof(char),1,Fichier_decompresse);
            Dico[Codec].Sequence=(char *)malloc(sizeof(char));
    	Dico[Codec].Sequence[0]=Code_lu;
    	//Dico[Codec].Sequence[1]='\0';
    	Dico[Codec].Taille=1;
    	}
    	Code_lu=lire_x_bit(Nb_bit,Curseur);
         //tant qu'on est pas arrive au Code de fin de compression.
         while (Code_lu != CODE_FIN )
         {
    	//si c'est le Code de r.a.z
               if (Code_lu==CODE_RAZ)
                  {
    		printf("R.A.Z\n");
    		for(i=0;i<pow(2,Nb_bit);i++)
    		{
    		  if (Dico[i].Sequence != NULL)
    			{free(Dico[i].Sequence);}
    		  Dico[i].Taille=0;
    		}
                    Codec=CODE_DEBUT;
    		Nb_bit=NB_BIT_DEBUT;
    		Code_lu=lire_x_bit(NB_BIT_DEBUT,Curseur);
    		if (Code_lu != CODE_FIN)
            	{
             		fread(&Code_lu,sizeof(char),1,Fichier_decompresse);
             		Dico[Codec].Sequence=(char *)malloc(sizeof(char));
    			Dico[Codec].Sequence[0]=Code_lu;
    			Dico[Codec].Taille=1;
    			//Dico[Codec].Sequence[1]='\0';
    		}
    		printf("fin R.A.Z\n");
    
                  }
                //si c'est le Code de lecture sur un bit suplémentaire on double le dico
               else if (Code_lu==CODE_BIT_SUP)
                    	{
                                Nb_bit++;
                                //Dico=(t_Seq_Taille*)realloc(Dico,pow(2,Nb_bit)*sizeof(t_Seq_Taille));
                                }
               else
         	   {
    	    Taille=Dico[Codec].Taille;
    	    Dico[Codec].Sequence[Taille]=Dico[Code_lu].Sequence[0];
    	    //Dico[Codec].Sequence[Taille+1]='\0';
    	    Dico[Codec].Taille++;
    	    for(i=0;i<Dico[Code_lu].Taille;i++)
    		{fputc(Dico[Code_lu].Sequence[i],Fichier_decompresse);}
    	    Codec++;
    	    Dico[Codec].Sequence=(char *)malloc(sizeof(char)*(Dico[Code_lu].Taille));
    	    Dico[Codec].Sequence=memcpy(Dico[Codec].Sequence,Dico[Code_lu].Sequence,Dico[Code_lu].Taille);
    	    Dico[Codec].Taille=Dico[Code_lu].Taille;
         	  }
         Code_lu=lire_x_bit(Nb_bit,Curseur);
         }
         fclose(Curseur);
         fclose(Fichier_decompresse);
    }

  2. #2
    Membre Expert
    Profil pro
    Inscrit en
    Août 2006
    Messages
    1 104
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2006
    Messages : 1 104
    Par défaut
    Salut

    Utilise les balises CODE. C'est illisible.

Discussions similaires

  1. [Débutant] Aide à propos de la Sérialisation
    Par dinver dans le forum Entrée/Sortie
    Réponses: 3
    Dernier message: 27/01/2007, 15h03
  2. Besoin d'aide à propos de JSF
    Par mejri dans le forum JSF
    Réponses: 1
    Dernier message: 29/06/2006, 14h35
  3. Aide à propos des strings
    Par Invité dans le forum Général Python
    Réponses: 2
    Dernier message: 26/06/2006, 09h43
  4. algorithme lzw
    Par star_light dans le forum Algorithmes et structures de données
    Réponses: 7
    Dernier message: 06/06/2004, 15h02
  5. algorithme lzw
    Par black_night_leader dans le forum Algorithmes et structures de données
    Réponses: 2
    Dernier message: 03/05/2004, 19h58

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo