/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C O M P R E S S I O N / D E C O M P R E S S I O N   N E U T R E  :                                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/CompressionDeCompressionNeutre.01$vv$I' :                                                                  */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130717133223).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "CompressionDeCompression.01.vv.I"

#define   GENERATION_NEUTRE_DU_FICHIER_R                                                                                                \
                    {                                                                                                                   \
                    TypeImage *bufferA=malloc(longueur);                                                                                \
                    TypeImage *bufferR=malloc(longueur);                                                                                \
                                                                                                                                        \
                    long      int       IndexDeplacement;                                                                               \
                                                                                                                                        \
                    LECTURE_FICHIER(bufferA,longueur);                                                                                  \
                                                                                                                                        \
                    for       (IndexDeplacement=0 ; IndexDeplacement < NombreOctetsLus ; IndexDeplacement++)                            \
                              {                                                                                                         \
                              *(bufferR+IndexDeplacement)=*(bufferA+IndexDeplacement);                                                  \
                                        /* Ce deplacement apparemment inutile (il suffirait en fait de confondre les deux buffers    */ \
                                        /* 'bufferA' et 'bufferR') a ete (re)introduit le 20131014164438 afin que les compresseur    */ \
                                        /* et decompresseur "neutre" fasse malgre tout quelque chose les rendant ainsi "comparables" */ \
                                        /* aux autres...                                                                             */ \
                                        /*                                                                                           */ \
                                        /* Le 20131015164800, je note que l'on pourrait introduire ici quelque chose qui ralentirait */ \
                                        /* le processus (et ce de facon lineaire, c'est-a-dire proportionnellement a 'longueur').    */ \
                                        /* Pour etalonner ce ralentissement on pourrait noter qu'il suffirait que les durees de      */ \
                                        /* decompression de :                                                                        */ \
                                        /*                                                                                           */ \
                                        /*                  $xrC/DeCompressionNeutre.01$vv$X                                         */ \
                                        /*                                                                                           */ \
                                        /* et de :                                                                                   */ \
                                        /*                                                                                           */ \
                                        /*                  $xrC/DeCompressionRunLengthEncoding.02$vv$X                              */ \
                                        /*                                                                                           */ \
                                        /* soient comparables pour une image uniforme telle 'v $xiirC/OBJC.21_22.11'. A ce propos,   */ \
                                        /* 'v $xtc/ralentissement.01$c' qui propose une methode...                                   */ \
                              }                                                                                                         \
                                                                                                                                        \
                    ECRITURE_FICHIER(bufferR,NombreOctetsLus);                                                                          \
                                                                                                                                        \
                    free(bufferR);                                                                                                      \
                    free(bufferA);                                                                                                      \
                    }