/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C O M P R E S S I O N   E T   I N V E R S E  :                                                                             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/Compression.11$vv$c' :                                                                                     */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20151224100234).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   G E N E R A L E S  :                                                                                 */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  "INCLUDES.01.I"
#include  "Compression.11.vv.I"

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F O N C T I O N   D E   C O M P R E S S I O N  :                                                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
int       Complexite_K__globale;
int       Complexite_LD_globale;
int       Complexite_K__locale_;
int       Complexite_LD_locale_;
                                        /* Mesures de 'K' et de 'LD'...                                                              */

void      MesureLocaleDe_K_EtDe_LD(CHAR *ChaineAMesurer,int LongueurDeChaineAMesurer)
          {
          Complexite_K__locale_=0;
          Complexite_LD_locale_=0;

          Compression_InitialisationChaineATraiter(Compression_ChaineACompresser
                                                  ,ChaineAMesurer
                                                  ,LongueurDeChaineAMesurer
                                                   );

          TransformationDeBurrowsWheeler_InitialisationChaineATraiter(TransformationDeBurrowsWheeler_ChaineAPermuter
                                                                     ,Compression_ChaineACompresser
                                                                     ,Compression_LongueurDeToutesLesChaines
                                                                      );

          Compression_LongueurDeToutesLesChaines = LongueurDeChaineAMesurer;

          TransformationDeBurrowsWheeler_InitialisationTransformationDirecte(TransformationDeBurrowsWheeler_ChainePermutee);
          TransformationDeBurrowsWheeler_TransformationDirecte(TransformationDeBurrowsWheeler_ChainePermutee
                                                              ,TransformationDeBurrowsWheeler_ChaineAPermuter
                                                               );

          Complexite_K__locale_ = Complexite_K__locale_+SIZE_IndexDeLaChaineAPermuterDansLaMatrice;

          TransformationDeBurrowsWheeler_DesinitialisationsTransformationDirecte();
          RunLengthEncoding_InitialisationChaineATraiter(RunLengthEncoding_ChaineACompresser
                                                        ,TransformationDeBurrowsWheeler_ChainePermutee
                                                        ,TransformationDeBurrowsWheeler_LongueurDeToutesLesChaines
                                                         );

          RunLengthEncoding_InitialisationTransformationDirecte(RunLengthEncoding_ChaineCompressee);
          RunLengthEncoding_TransformationDirecte(RunLengthEncoding_ChaineCompressee,RunLengthEncoding_ChaineACompresser);
          RunLengthEncoding_DesinitialisationsTransformationDirecte();

          {
          CHAR      *CodageDeHuffman_ChaineB;
          CHAR      *CodageDeHuffman_ChaineR;

          CodageDeHuffman_InitialisationChaines(CodageDeHuffman_ChaineB
                                               ,CodageDeHuffman_ChaineR
                                               ,RunLengthEncoding_ChaineCompressee,RunLengthEncoding_LongueurDeChaineCompressee
                                                );
          CodageDeHuffman_Initialisations();
          CodageDeHuffman_GenerationFrequences(RunLengthEncoding_ChaineCompressee,RunLengthEncoding_LongueurDeChaineCompressee);
          CodageDeHuffman_GenerationDeLArbre();
          CodageDeHuffman_EditionDeLArbre();
          CodageDeHuffman_ParcoursRecursifDeLArbre(CodageDeHuffman_RacineDeLArbre,0,0);
          CodageDeHuffman_EditionDesCodesDeHuffman();
          CodageDeHuffman_CompactageChaine(CodageDeHuffman_ChaineB
                                          ,RunLengthEncoding_ChaineCompressee
                                          ,RunLengthEncoding_LongueurDeChaineCompressee
                                           );

          Complexite_K__locale_ = Complexite_K__locale_+SIZE_IdentiteDuNoeudCourantDeLArbre;
          Complexite_K__locale_ = Complexite_K__locale_+SIZE_CodageDeHuffman_Arbre;
          Complexite_K__locale_ = Complexite_K__locale_+SIZE_CodageDeHuffman_CodeBinaire;
          Complexite_K__locale_ = Complexite_K__locale_+CodageDeHuffman_NombreDeBitsApresCodage;

          CodageDeHuffman_DeCompactageChaine(CodageDeHuffman_ChaineR
                                            ,CodageDeHuffman_ChaineB
                                            ,CodageDeHuffman_NombreDeBitsApresCodage
                                             );
          CodageDeHuffman_Verifications(RunLengthEncoding_ChaineCompressee
                                       ,RunLengthEncoding_LongueurDeChaineCompressee
                                       ,CodageDeHuffman_ChaineR
                                       ,CodageDeHuffman_NombreDOctetsApresDecodage
                                        );

          if        (Compression_EditerCompressionBits == VRAI)
                    {
                    printf("\nLes %"For10" octets (=%"For10" bits) ont ete compactes en %"For10" octets (=%"For10" bits).\n"
                          ,(Entier)LongueurDeChaineAMesurer,((Entier)LongueurDeChaineAMesurer)*NBITOC
                          ,(CodageDeHuffman_NombreDeBitsApresCodage+NBITOC-1)/NBITOC,CodageDeHuffman_NombreDeBitsApresCodage
                           );
                    }
          else
                    {
                    }

          RunLengthEncoding_InitialisationTransformationInverse(RunLengthEncoding_ChaineDecompressee);
          RunLengthEncoding_TransformationInverse(RunLengthEncoding_ChaineDecompressee,CodageDeHuffman_ChaineR);

          CodageDeHuffman_DesinitialisationChaines(CodageDeHuffman_ChaineB,CodageDeHuffman_ChaineR);
          }
          RunLengthEncoding_Verifications(RunLengthEncoding_ChaineDecompressee,RunLengthEncoding_ChaineACompresser);

          TransformationDeBurrowsWheeler_InitialisationTransformationInverse(TransformationDeBurrowsWheeler_ChaineRetablie);
          TransformationDeBurrowsWheeler_TransformationInverse(TransformationDeBurrowsWheeler_ChaineRetablie
                                                              ,RunLengthEncoding_ChaineDecompressee
                                                               );
          TransformationDeBurrowsWheeler_Verifications(TransformationDeBurrowsWheeler_ChaineRetablie
                                                      ,TransformationDeBurrowsWheeler_ChaineAPermuter
                                                       );

          Compression_Verifications(ChaineAMesurer,TransformationDeBurrowsWheeler_ChaineRetablie);


          RunLengthEncoding_DesinitialisationsTransformationInverse(RunLengthEncoding_ChaineDecompressee
                                                                   ,RunLengthEncoding_ChaineCompressee
                                                                    );
          TransformationDeBurrowsWheeler_DesinitialisationsTransformationInverse(TransformationDeBurrowsWheeler_ChaineRetablie
                                                                                ,TransformationDeBurrowsWheeler_ChainePermutee
                                                                                 );

          RunLengthEncoding_DesinitialisationChaineATraiter(RunLengthEncoding_ChaineACompresser);
          TransformationDeBurrowsWheeler_DesinitialisationChaineATraiter(TransformationDeBurrowsWheeler_ChaineAPermuter);
          Compression_DesinitialisationChaineATraiter(Compression_ChaineACompresser);

          Complexite_K__globale = Complexite_K__globale+Complexite_K__locale_;

          printf("\nLocal : K=%d (bits)     Global : K=%d (bits)\n",Complexite_K__locale_,Complexite_K__globale);
          }

#define   TAILLE_DES_PAQUETS                                                                                                            \
                    10000

void      MesureDe_K_EtDe_LD_Globale(CHAR *ChaineAMesurer,int LongueurDeChaineAMesurer)
          {
          CHAR      *SousChaineAMesurer=ChaineAMesurer;
          int       NombreDOctetsEncoreATraiter=LongueurDeChaineAMesurer;

          Complexite_K__globale=0;
          Complexite_LD_globale=0;

          while     (NombreDOctetsEncoreATraiter > 0)
                    {
                    int       LongueurDeSousChaineAMesurer=MIN2(TAILLE_DES_PAQUETS,NombreDOctetsEncoreATraiter);

                    MesureLocaleDe_K_EtDe_LD(SousChaineAMesurer,LongueurDeSousChaineAMesurer);

                    SousChaineAMesurer = SousChaineAMesurer+LongueurDeSousChaineAMesurer;
                    NombreDOctetsEncoreATraiter = NombreDOctetsEncoreATraiter-LongueurDeSousChaineAMesurer;
                    }
          }

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P R O G R A M M E   P R I N C I P A L  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOM_DU_FICHIER                                                                                                                \
                    argv[1]

main(int argc,CHAR *argv[])
          {
          int                 DescripteurDuFichier=open(NOM_DU_FICHIER,O_RDONLY);;
          int                 etat_fichier;
          struct    stat      EtatDuFichier;

          if        (DescripteurDuFichier >= 0)
                    {
                    int       TailleDuFichier;
                    char      *BufferDuFichier;

                    if        (fstat(DescripteurDuFichier,&EtatDuFichier) >= 0)
                              {
                              TailleDuFichier = EtatDuFichier.st_size;
                              BufferDuFichier = malloc(TailleDuFichier);

                              read(DescripteurDuFichier,BufferDuFichier,TailleDuFichier);

                              MesureDe_K_EtDe_LD_Globale(BufferDuFichier,TailleDuFichier);
                              }
                    else
                              {
                              fprintf(stderr,"ERREUR : Probleme avec le fichier '%s'.\n",NOM_DU_FICHIER);
                              }
                    close(DescripteurDuFichier);
                    }
          else
                    {
                    fprintf(stderr,"ERREUR : Le fichier '%s' n'existe pas.\n",NOM_DU_FICHIER);
                    }
          }



Copyright © Jean-François Colonna, 2021-2021.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2021-2021.