/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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   02 "                         */
/*        E N   L O N G U E U R   V A R I A B L E  :                                                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/CompressionDeCompressionRunLengthEncoding.02$vv$I' :                                                       */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130926151747).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "CompressionDeCompressionRunLengthEncodingGeneral.01.vv.I"

#define   ENREGISTREMENT_D_UNE_SUITE_DE_REPETITIONS                                                                                     \
                    {                                                                                                                   \
                    int       iterer=VRAI;                                                                                              \
                    int       CompteurRepetitionsCourant=CompteurRepetitions;                                                           \
                    int       TableauCompteurRepetitions[NOMBRE_D_OCTETS_PAR_MOT];                                                      \
                    int       IndiceTableau=0;                                                                                          \
                    int       IndiceMaximalTableau;                                                                                     \
                                                                                                                                        \
                    while     (iterer == VRAI)                                                                                          \
                              {                                                                                                         \
                              int       quotient=CompteurRepetitionsCourant/COULEURS;                                                   \
                              int       reste=CompteurRepetitionsCourant%COULEURS;                                                      \
                                                                                                                                        \
                              TableauCompteurRepetitions[IndiceTableau]=reste;                                                          \
                              IndiceTableau++;                                                                                          \
                                                                                                                                        \
                              if        ((quotient == 0) || (IndiceTableau == NOMBRE_D_OCTETS_PAR_MOT))                                 \
                                        {                                                                                               \
                                        iterer=FAUX;                                                                                    \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        CompteurRepetitionsCourant=quotient;                                                            \
                                        }                                                                                               \
                              }                                                                                                         \
                                                                                                                                        \
                    ImageCompactee[JImageCompactee]=IndiceTableau;                                                                      \
                    JImageCompactee++;                                                                                                  \
                                                                                                                                        \
                    IndiceMaximalTableau=IndiceTableau-1;                                                                               \
                                                                                                                                        \
                    for       (IndiceTableau=IndiceMaximalTableau ; IndiceTableau >=0 ; IndiceTableau--)                                \
                              {                                                                                                         \
                              ImageCompactee[JImageCompactee]=TableauCompteurRepetitions[IndiceTableau];                                \
                              JImageCompactee++;                                                                                        \
                              }                                                                                                         \
                                                                                                                                        \
                    ImageCompactee[JImageCompactee]=CaracterePrecedent;                                                                 \
                    JImageCompactee++;                                                                                                  \
                    }

#define   COMPRESSION_RUN_LENGTH_ENCODING_02_DU_FICHIER_R                                                                               \
                    {                                                                                                                   \
                    COMPRESSION_RUN_LENGTH_ENCODING_DU_FICHIER_R(3,(VRAI == VRAI));                                                     \
                    }

#define   DECOMPRESSION_RUN_LENGTH_ENCODING_02_DU_FICHIER_R                                                                             \
                    {                                                                                                                   \
                    TypeImage *ImageCompactee=malloc(longueur);                                                                         \
                    TypeImage DEFINITION_IMAGE(ImageDecompactee,dimY,dimX);                                                             \
                                                                                                                                        \
                    long      int       DimensionImageEffective=0;                                                                      \
                    long      int       JImageADeCompacter;                                                                             \
                                                                                                                                        \
                    LECTURE_FICHIER(ImageCompactee,longueur);                                                                           \
                                                                                                                                        \
                    x=Xmin;                                                                                                             \
                    y=Ymin;                                                                                                             \
                                                                                                                                        \
                    JImageADeCompacter=0;                                                                                               \
                                                                                                                                        \
                    while     (JImageADeCompacter < NombreOctetsLus)                                                                    \
                              {                                                                                                         \
                              int       CompteurRepetitions=0;                                                                          \
                              int       IndiceTableau=0;                                                                                \
                              int       IndiceMaximalTableau;                                                                           \
                              long      int       compteur;                                                                             \
                                                                                                                                        \
                              IndiceMaximalTableau=ImageCompactee[JImageADeCompacter]-1;                                                \
                                        /* Recuperation du nombre d'octets utiles pour le compteur de repetitions...                 */ \
                              JImageADeCompacter++;                                                                                     \
                                                                                                                                        \
                              for       (IndiceTableau=IndiceMaximalTableau ; IndiceTableau >=0 ; IndiceTableau--)                      \
                                        {                                                                                               \
                                        CompteurRepetitions = (CompteurRepetitions*COULEURS)+ImageCompactee[JImageADeCompacter];        \
                                        /* Reconstitution du compteur de repetitions par concatenation de plusieurs octets.          */ \
                                        JImageADeCompacter++;                                                                           \
                                        }                                                                                               \
                                                                                                                                        \
                              for       (compteur=1 ; compteur <= CompteurRepetitions ; compteur++)                                     \
                                        {                                                                                               \
                                        GENERATION_D_UNE_SUITE_DE_REPETITIONS(ImageCompactee[JImageADeCompacter]);                      \
                                        }                                                                                               \
                                                                                                                                        \
                              JImageADeCompacter++;                                                                                     \
                              }                                                                                                         \
                                                                                                                                        \
                    if        (DimensionImageEffective > DimImages)                                                                     \
                              {                                                                                                         \
                              fprintf(stderr,"Trop de points generes lors du decompactage RLE2.\n");                                    \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                                                                                                                                        \
                    ECRITURE_FICHIER(ImageDecompactee,DimensionImageEffective);                                                         \
                                                                                                                                        \
                    free(ImageCompactee);                                                                                               \
                    }