/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C O M P R E S S I O N / D E C O M P R E S S I O N   " R U N - L E N G T H   E N C O D I N G   12 "                         */
/*        E N   L O N G U E U R   V A R I A B L E  :                                                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Nota :                                                                                                                     */
/*                                                                                                                                   */
/*                    Ce programme est inspire de 'v $xtc/CompressionDecompression_RLE_1D.01$c'.                                     */
/*                  Il y a une petite difference au sujet du compte des repetitions :                                                */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                                      $xtc/CompressionDecompression_RLE_1D.01$c                                                    */
/*                                                                                                                                   */
/*                                                          Kc                  --> K                                                */
/*                                                          -                                                                        */
/*                                                                                                                                   */
/*                                                          KKc                 --> KK                                               */
/*                                                          --                                                                       */
/*                                                                                                                                   */
/*                                                          KKKc                --> KKK                                              */
/*                                                          ---                                                                      */
/*                                                                                                                                   */
/*                                                          KKKKc               --> KKKK[4]                                          */
/*                                                          ----                                                                     */
/*                                                                                                                                   */
/*                                                          KKKKKc              --> KKKK[5]                                          */
/*                                                          ----                                                                     */
/*                                                                                                                                   */
/*                                                          KKKKKKc             --> KKKK[6]                                          */
/*                                                          ----                                                                     */
/*                                                                                                                                   */
/*                                                          (...)                                                                    */
/*                                                                                                                                   */
/*                                                          KKKKK(...)K         --> KKKK[255]                                        */
/*                                                          ----                                                                     */
/*                                                          -----------                                                              */
/*                                                              /|\                                                                  */
/*                                                               |                                                                   */
/*                                                               |                                                                   */
/*                                                                ------------- il n'y a que 255 caracteres 'K'.                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  alors que :                                                                                                      */
/*                                                                                                                                   */
/*                                      $KrC/CompressionDeCompressionRunLengthEncoding.11$vv$I                                       */
/*                                                                                                                                   */
/*                                                          Kc                  --> K                                                */
/*                                                          -                                                                        */
/*                                                                                                                                   */
/*                                                          KKc                 --> KK                                               */
/*                                                          --                                                                       */
/*                                                                                                                                   */
/*                                                          KKKc                --> KKK                                              */
/*                                                          ---                                                                      */
/*                                                                                                                                   */
/*                                                          KKKKc               --> KKKK[0]                                          */
/*                                                          ----                                                                     */
/*                                                                                                                                   */
/*                                                          KKKKKc              --> KKKK[1]                                          */
/*                                                          ----                                                                     */
/*                                                                                                                                   */
/*                                                          KKKKKKc             --> KKKK[2]                                          */
/*                                                                                                                                   */
/*                                                          (...)                                                                    */
/*                                                                                                                                   */
/*                                                          KKKKK(...)K         --> KKKK[255]                                        */
/*                                                          ----                                                                     */
/*                                                          -----------                                                              */
/*                                                              /|\                                                                  */
/*                                                               |                                                                   */
/*                                                               |                                                                   */
/*                                                                ------------- il y a au total 4+255=259 caracteres 'K'.            */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  (ou [n] represente un octet contenant en binaire                                                                 */
/*                  la valeur n comprise entre 0 et 255) ce qui est donc                                                             */
/*                  plus optimise. Enfin, 'c' represente un caractere                                                                */
/*                  different de 'K' (on notera au passage que ce caractere                                                          */
/*                  'c' n'apparait pas apres une chaine de 'K's de longueur                                                          */
/*                  maximale car, en effet, le caractere suivant le dernier                                                          */
/*                  'K' peut etre un autre caractere 'K'...).                                                                        */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/CompressionDeCompressionRunLengthEncoding.12$vv$I' :                                                       */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20151119073056).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "CompressionDeCompressionRunLengthEncoding.11.vv.I"
#include  "OperateursComptage.vv.I"

#define   COMPRESSION_RUN_LENGTH_ENCODING_12_DU_FICHIER_R                                                                               \
                                        /* Procedure introduite le 20151118104757...                                                 */ \
                    {                                                                                                                   \
                    COMPRESSION_RUN_LENGTH_ENCODING_11_DU_FICHIER_R;                                                                    \
                    }

#define   PROGRESSION_DES_COORDONNEES_12                                                                                                \
                    {                                                                                                                   \
                    Test(IFLT(x,Xmax))                                                                                                  \
                              {                                                                                                         \
                              mINCR(&x);                                                                                                \
                              }                                                                                                         \
                    ATes                                                                                                                \
                              {                                                                                                         \
                              x=Xmin;                                                                                                   \
                                                                                                                                        \
                              Test(IFLT(y,Ymax))                                                                                        \
                                        {                                                                                               \
                                        mINCR(&y);                                                                                      \
                                        }                                                                                               \
                              ATes                                                                                                      \
                                        {                                                                                               \
                                        }                                                                                               \
                              ETes                                                                                                      \
                              }                                                                                                         \
                    ETes                                                                                                                \
                    }
#ifndef   define_dimX_dimY
                                        /* Introduit le 20141024150620 pour accelerer la decompression utilisant le programme        */
                                        /* 'v .xrC.EffectuerCompilations.01.vv.Z DeCompressionRunLengthEncoding.02$vv'...            */
#else
#         if        (dimX == 1)
#                   undef     PROGRESSION_DES_COORDONNEES_12

#                   define    PROGRESSION_DES_COORDONNEES_12                                                                            \
                              {                                                                                                         \
                              mINCR(&y);                                                                                                \
                              }
#         else
#                   if        (dimY == 1)
#                             undef     PROGRESSION_DES_COORDONNEES_12

#                             define    PROGRESSION_DES_COORDONNEES_12                                                                  \
                                        {                                                                                               \
                                        mINCR(&x);                                                                                      \
                                        }
#                   else
#                   endif
#         endif
#endif

#define   STORE_DECOMPRESSION_12(valeur)                                                                                                \
                                        /* Procedure introduite le 20151118104757...                                                 */ \
                    {                                                                                                                   \
                    mgSTORE_IMAGE_PLAN(ImageDecompactee,x,y,valeur);                                                                    \
                                                                                                                                        \
                    mINCR(&DimensionImageEffective);                                                                                    \
                                                                                                                                        \
                    PROGRESSION_DES_COORDONNEES_12;                                                                                     \
                    }
#define   GET_REPETITION_12(NombreDeCaracteres)                                                                                         \
                                        /* Procedure introduite le 20151118104757...                                                 */ \
                    {                                                                                                                   \
                    LongInt   compteur;                                                                                                 \
                    LongInt   facteur;                                                                                                  \
                                                                                                                                        \
                    mEGALs(facteur,1);                                                                                                  \
                    mEGALs(NombreDeCaracteres,0);                                                                                       \
                                                                                                                                        \
                    DoIn(compteur,1,NOMBRE_D_OCTETS_POUR_LES_NOMBRES_DE_REPETITIONS)                                                    \
                              {                                                                                                         \
                              TypeImage caractere;                                                                                      \
                              mEGALv(caractere,mINDXi(ImageCompactee,JImageADeCompacter));                                              \
                              mEGALs(NombreDeCaracteres,ADD2(NombreDeCaracteres,MUL2(caractere,facteur)));                              \
                              mEGALs(facteur,MUL2(BASE_DE_NUMERATION_DES_NOMBRES_DE_REPETITIONS,facteur));                              \
                                                                                                                                        \
                              Test(mIFLT(compteur,NOMBRE_D_OCTETS_POUR_LES_NOMBRES_DE_REPETITIONS))                                     \
                                        {                                                                                               \
                                        mINCR(&JImageADeCompacter);                                                                     \
                                        }                                                                                               \
                              ATes                                                                                                      \
                                        {                                                                                               \
                                        }                                                                                               \
                              ETes                                                                                                      \
                              }                                                                                                         \
                    EDoI                                                                                                                \
                                                                                                                                        \
                    mEGALs(NombreDeCaracteres,NombreDeCaracteres);                                                                      \
                    }
#define   REPEAT_STORE_DECOMPRESSION_12(valeur)                                                                                         \
                                        /* Procedure introduite le 20151118104757...                                                 */ \
                    {                                                                                                                   \
                    LongInt   nombre;                                                                                                   \
                                                                                                                                        \
                    LongInt   NombreDeCaracteres_ADupliquer;                                                                            \
                    GET_REPETITION_12(NombreDeCaracteres_ADupliquer);                                                                   \
                                                                                                                                        \
                    DoIn(nombre,1,NombreDeCaracteres_ADupliquer)                                                                        \
                              {                                                                                                         \
                              STORE_DECOMPRESSION_12(valeur);                                                                           \
                              }                                                                                                         \
                    EDoI                                                                                                                \
                    }
#define   DECOMPRESSION_RUN_LENGTH_ENCODING_12_DU_FICHIER_R                                                                             \
                                        /* Procedure introduite le 20151118104757...                                                 */ \
                    {                                                                                                                   \
                    TypeImage *ImageCompactee=malloc(longueur);                                                                         \
                    TypeImage DEFINITION_IMAGE(ImageDecompactee,dimY,dimX);                                                             \
                                                                                                                                        \
                    LongInt   x,y;                                                                                                      \
                                        /* En fait {x,y} sont deja definis dans 'v $xrC/images.01$vv$I int.................x,y.',    */ \
                                        /* mais avec le type 'int...                                                                 */ \
                                                                                                                                        \
                    LongInt   iterer;                                                                                                   \
                    LongInt   CaracterePrecedent;                                                                                       \
                                        /* ATTENTION : doit etre un 'int' et non pas un 'CHAR' a cause de la valeur 'INFINI'...      */ \
                    LongInt   CompteurDeRepetitions;                                                                                    \
                    LongInt   DimensionImageEffective;                                                                                  \
                    LongInt   JImageADeCompacter;                                                                                       \
                                                                                                                                        \
                    mEGALs(iterer,VRAI);                                                                                                \
                    mEGALs(CaracterePrecedent,CARACTERE_PRECEDENT_INDEFINI);                                                            \
                                                                                                                                        \
                    mEGALs(CompteurDeRepetitions,1);                                                                                    \
                    mEGALs(DimensionImageEffective,0);                                                                                  \
                    mEGALs(JImageADeCompacter,0);                                                                                       \
                                                                                                                                        \
                    LECTURE_FICHIER(ImageCompactee,longueur);                                                                           \
                                                                                                                                        \
                    mEGALs(x,Xmin);                                                                                                     \
                    mEGALs(y,Ymin);                                                                                                     \
                                                                                                                                        \
                    mEGALs(JImageADeCompacter,INDEX0);                                                                                  \
                    Tant(mIFEQ(iterer,VRAI))                                                                                            \
                              {                                                                                                         \
                              TypeImage CaractereCourant;                                                                               \
                              mEGALv(CaractereCourant,mINDXi(ImageCompactee,JImageADeCompacter));                                       \
                                                                                                                                        \
                              Test(mIFLE(CompteurDeRepetitions,BORNE_INFERIEURE_DE_REPETITIONS))                                        \
                                        {                                                                                               \
                                        Test(mIFEQ(CompteurDeRepetitions,BORNE_INFERIEURE_DE_REPETITIONS))                              \
                                                  {                                                                                     \
                                                  REPEAT_STORE_DECOMPRESSION_12(CaracterePrecedent);                                    \
                                                  mEGALs(CaracterePrecedent,CARACTERE_PRECEDENT_INDEFINI);                              \
                                                  mEGALs(CompteurDeRepetitions,1);                                                      \
                                                  }                                                                                     \
                                        ATes                                                                                            \
                                                  {                                                                                     \
                                                  Test(mIFEQ(CaractereCourant,CaracterePrecedent))                                      \
                                                            {                                                                           \
                                                            mINCR(&CompteurDeRepetitions);                                              \
                                                            }                                                                           \
                                                  ATes                                                                                  \
                                                            {                                                                           \
                                                            mEGALs(CaracterePrecedent,CaractereCourant);                                \
                                                            mEGALs(CompteurDeRepetitions,1);                                            \
                                                            }                                                                           \
                                                  ETes                                                                                  \
                                                                                                                                        \
                                                  STORE_DECOMPRESSION_12(CaractereCourant);                                             \
                                                  }                                                                                     \
                                        ETes                                                                                            \
                                        }                                                                                               \
                              ATes                                                                                                      \
                                        {                                                                                               \
                                        fprintf(stderr,"Erreur de decompression -1-\n");                                                \
                                        }                                                                                               \
                              ETes                                                                                                      \
                                                                                                                                        \
                              mINCR(&JImageADeCompacter);                                                                               \
                              Test(mIFLE(JImageADeCompacter,NombreVersIndex(NombreOctetsLus)))                                          \
                                        {                                                                                               \
                                        }                                                                                               \
                              ATes                                                                                                      \
                                        {                                                                                               \
                                        mEGALs(iterer,FAUX);                                                                            \
                                        }                                                                                               \
                              ETes                                                                                                      \
                              }                                                                                                         \
                    ETan                                                                                                                \
                                                                                                                                        \
                    ECRITURE_FICHIER(ImageDecompactee,DimensionImageEffective);                                                         \
                                                                                                                                        \
                    free(ImageCompactee);                                                                                               \
                                                                                                                                        \
                    EDITION_DES_COMPTEURS;                                                                                              \
                    }



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