home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / CODECS.ZIP / codecs / francais / codrle1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-13  |  6.4 KB  |  157 lines
  1. /* Fichier: codrle1.c
  2.    Auteur: David Bourgin
  3.    Date de creation: 28/1/94
  4.    Date de derniere mise a jour: 22/5/94
  5.    Dessein: Exemple de codage RLE type 1 avec comme donnees a compresser le contenu d'un fichier.
  6. */
  7.  
  8. #include <stdio.h>
  9. /* Pour les routines printf,fgetc,fputc et fwrite */
  10. #include <stdlib.h>
  11. /* Pour la routine exit */
  12.  
  13. /* Codes d'erreur renvoyes a l'appelant */
  14. #define NO_ERROR      0
  15. #define BAD_FILE_NAME 1
  16. #define BAD_ARGUMENT  2
  17.  
  18. /* Constantes pratiques */
  19. #define FALSE 0
  20. #define TRUE  1
  21.  
  22. /* Variables globales */
  23. FILE *f_source,*f_dest;
  24.  
  25.                              /* Puisque fgetc=EOF uniquement apres un acces
  26.                                 alors statut_octet_stocke vaut TRUE si un octet a ete engrange par fgetc
  27.                                 ou FALSE s'il n'y aucun octet valide, deja lu et non traite dans val_octet_stocke */
  28. int statut_octet_stocke=FALSE;
  29. int val_octet_stocke;
  30.  
  31. /* Pseudo procedures */
  32. #define fin_des_donnees() (statut_octet_stocke?FALSE:!(statut_octet_stocke=((val_octet_stocke=fgetc(f_source))!=EOF)))
  33. #define lire_octet()  (statut_octet_stocke?statut_octet_stocke=FALSE,(unsigned char)val_octet_stocke:(unsigned char)fgetc(f_source))
  34. #define ecrire_octet(octet)  ((void)fputc((octet),f_dest))
  35. #define ecrire_tableau(tableau,nb_octets_a_ecrire)  ((void)fwrite((tableau),1,(nb_octets_a_ecrire),f_dest))
  36.  
  37. void codagerle1()
  38. /* Parametres en sortie: Aucun
  39.    Action: Compresse suivant la methode RLE type 1 tous les octets lus par la fonction lire_octet
  40.    Erreurs: Une erreur d'entree/sortie peut perturber le deroulement de l'algorithme
  41. */
  42. { register unsigned char octet1,octet2,taille_trame,
  43.                          tableau[129];
  44.  
  45.   if (!fin_des_donnees())
  46.      { octet1=lire_octet();  /* Y a-t-il au moins 1 octet a analyser? */
  47.        taille_trame=1;
  48.        if (!fin_des_donnees())
  49.                              /* Y a-t-il au moins 2 octets a analyser? */
  50.           { octet2=lire_octet();
  51.             taille_trame=2;
  52.             do { if (octet1==octet2)
  53.                              /* Y a-t-il repetition? */
  54.                     { while ((!fin_des_donnees())&&(octet1==octet2)&&(taille_trame<129))
  55.                             { octet2=lire_octet();
  56.                               taille_trame++;
  57.                             }
  58.                       if (octet1==octet2)
  59.                              /* N'a-t-on rencontre qu'une sequence d'octets identiques? */
  60.                         { ecrire_octet(126+taille_trame);
  61.                           ecrire_octet(octet1);
  62.                           if (!fin_des_donnees())
  63.                              { octet1=lire_octet();
  64.                                taille_trame=1;
  65.                              }
  66.                           else taille_trame=0;
  67.                         }
  68.                       else   /* Non, alors ne pas prendre en compte le dernier octet */
  69.                            { ecrire_octet(125+taille_trame);
  70.                              ecrire_octet(octet1);
  71.                              octet1=octet2;
  72.                              taille_trame=1;
  73.                            }
  74.                       if (!fin_des_donnees())
  75.                          { octet2=lire_octet();
  76.                            taille_trame=2;
  77.                          }
  78.                     }
  79.                  else        /* Preparer le tableau de comparaisons
  80.                                 ou seront stockes tous les octets non identiques */
  81.                       { *tableau=octet1;
  82.                         tableau[1]=octet2;
  83.                         while ((!fin_des_donnees())&&(tableau[taille_trame-2]!=tableau[taille_trame-1])&&(taille_trame<128))
  84.                               { tableau[taille_trame]=lire_octet();
  85.                                 taille_trame++;
  86.                               }
  87.                         if (tableau[taille_trame-2]==tableau[taille_trame-1])
  88.                              /* A-t-on rencontre une sequence d'octets tous differents suivie d'octets identiques? */
  89.                            { /* Oui, alors decompter les deux derniers octets */
  90.                              ecrire_octet(taille_trame-3);
  91.                              ecrire_tableau(tableau,taille_trame-2);
  92.                              octet1=tableau[taille_trame-2];
  93.                              octet2=octet1;
  94.                              taille_trame=2;
  95.                            }
  96.                         else { ecrire_octet(taille_trame-1);
  97.                                ecrire_tableau(tableau,taille_trame);
  98.                                if (fin_des_donnees())
  99.                                   taille_trame=0;
  100.                                else { octet1=lire_octet();
  101.                                       if (fin_des_donnees())
  102.                                          taille_trame=1;
  103.                                       else { octet2=lire_octet();
  104.                                              taille_trame=2;
  105.                                            }
  106.                                     }
  107.                              }
  108.                       }
  109.                }
  110.             while ((!fin_des_donnees())||(taille_trame>=2));
  111.           }
  112.        if (taille_trame==1)
  113.           { ecrire_octet(0);
  114.             ecrire_octet(octet1);
  115.           }
  116.      }
  117. }
  118.  
  119. void aide()
  120. /* Parametres en sortie: Aucun
  121.    Action: Affiche l'aide du programme et termine son execution
  122.    Erreurs: Aucune
  123. */
  124. { printf("Cet utilitaire permet de compresser un fichier par la methode RLE type 1\n");
  125.   printf("telle qu'elle est exposee dans 'La Video et Les Imprimantes sur PC'\n");
  126.   printf("\nUsage: codrle1 source destination\n");
  127.   printf("source: Nom du fichier a compresser\n");
  128.   printf("destination: Nom du fichier compresse\n");
  129. }
  130.  
  131. int main(argc,argv)
  132. /* Parametres en sortie: Renvoie un code d'erreur (0=Aucune)
  133.    Action: Procedure principale
  134.    Erreurs: Detectee, traitee et un code d'erreur est renvoye si necessaire
  135. */
  136. int argc;
  137. char *argv[];
  138. { if (argc!=3)
  139.      { aide();
  140.        exit(BAD_ARGUMENT);
  141.      }
  142.   else if ((f_source=fopen(argv[1],"rb"))==NULL)
  143.           { aide();
  144.             exit(BAD_FILE_NAME);
  145.           }
  146.        else if ((f_dest=fopen(argv[2],"wb"))==NULL)
  147.                { aide();
  148.                  exit(BAD_FILE_NAME);
  149.                }
  150.             else { codagerle1();
  151.                    fclose(f_source);
  152.                    fclose(f_dest);
  153.                  }
  154.   printf("Execution de codrle1 achevee.\n");
  155.   return (NO_ERROR);
  156. }
  157.