/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C O M P R E S S I O N / D E C O M P R E S S I O N   " PNG "  :                                                             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/CompressionDeCompressionPNG.01$vv$I' :                                                                     */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20131002093741).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "CompressionDeCompression.01.vv.I"

#include  <png.h>

#define   COMPRESSION_PNG_DU_FICHIER_R                                                                                                  \
                    {                                                                                                                   \
                    int                 dimensionX=dimX;                                                                                \
                    int                 dimensionY=dimY;                                                                                \
                                        /* Les images '$TypeBit__' seront considerees comme des images '$TypeOctet', mais avec une   */ \
                                        /* dimension en 'Y' 8 fois moindre. Ceci a ete mis en place le 20131017105351 car, d'une     */ \
                                        /* part le '$TypeBit__' posait un probleme de decompression et d'autre part, les autres      */ \
                                        /* compresseurs/decompresseurs utilises travaillent eux-aussi avec comme unite d'information */ \
                                        /* l'octet...                                                                                */ \
                                                                                                                                        \
                    TypeImage           *ImageACompacter=malloc(DimImages);                                                             \
                                                                                                                                        \
                    png_structp         StructureImage;                                                                                 \
                    png_infop           StructureInformations;                                                                          \
                    int                 NombreDeBitsParPoint=NBITOC;                                                                    \
                                                                                                                                        \
                    size_t              NombreDOctetsLus=fread(ImageACompacter,1,longueur,DescripteurFichierA);                         \
                                        /* Introduit le 20131014101526 a cause de 'v $xrC/EffectuerCompilations.01$vv$Z OpTiOnS'     */ \
                                        /* dans le cas ou une optimisation est demandee...                                           */ \
                                                                                                                                        \
                    if        (longueur < DimImages)                                                                                    \
                              {                                                                                                         \
                              dimensionY=dimY/NBITOC;                                                                                   \
                                                                                                                                        \
                              if        ((dimensionY*NBITOC) != dimY)                                                                   \
                                        {                                                                                               \
                                        fprintf(stderr,"La dimension en 'Y' n'est pas divisible par %d.\n",NBITOC);                     \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        }                                                                                               \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                                                                                                                                        \
                    StructureImage = png_create_write_struct(PNG_LIBPNG_VER_STRING,(png_voidp)PointeurNULL,PointeurNULL,PointeurNULL);  \
                    if        (StructureImage == PointeurNULL)                                                                          \
                              {                                                                                                         \
                              fprintf(stderr,"La structure d'ecriture 'PNG' n'a pu etre creee.\n");                                     \
                              exit(NOK);                                                                                                \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                                                                                                                                        \
                    StructureInformations = png_create_info_struct(StructureImage);                                                     \
                    if        (StructureInformations == PointeurNULL)                                                                   \
                              {                                                                                                         \
                              fprintf(stderr,"La structure d'informations 'PNG' n'a pu etre creee.\n");                                 \
                              exit(NOK);                                                                                                \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                                                                                                                                        \
                    if        (setjmp(png_jmpbuf(StructureImage)))                                                                      \
                              {                                                                                                         \
                              fprintf(stderr,"Erreur 'PNG'.\n");                                                                        \
                              exit(NOK);                                                                                                \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                                                                                                                                        \
                    png_init_io(StructureImage,DescripteurFichierR);                                                                    \
                    png_set_compression_level(StructureImage,Z_BEST_COMPRESSION);                                                       \
                    png_set_IHDR(StructureImage                                                                                         \
                                ,StructureInformations                                                                                  \
                                ,dimensionX                                                                                             \
                                ,dimensionY                                                                                             \
                                ,NombreDeBitsParPoint                                                                                   \
                                ,PNG_COLOR_TYPE_GRAY                                                                                    \
                                ,PNG_INTERLACE_NONE                                                                                     \
                                ,PNG_COMPRESSION_TYPE_DEFAULT                                                                           \
                                ,PNG_FILTER_TYPE_DEFAULT                                                                                \
                                 );                                                                                                     \
                                                                                                                                        \
                    png_write_info(StructureImage,StructureInformations);                                                               \
                                                                                                                                        \
                    for      (y=0 ; y < dimensionY ; y++)                                                                               \
                              {                                                                                                         \
                              png_write_row(StructureImage,(png_bytep)(ImageACompacter+(dimensionX*y)));                                \
                              }                                                                                                         \
                                                                                                                                        \
                    png_write_end(StructureImage,StructureInformations);                                                                \
                                                                                                                                        \
                    png_destroy_write_struct(&StructureImage,&StructureInformations);                                                   \
                                                                                                                                        \
                    free(ImageACompacter);                                                                                              \
                    }

FILE      *DescripteurFichier;
                                        /* Ce descripteur de fichier intermediaire est rendu necessaire a cause de la fonction       */
                                        /* 'png_read(...)' qui suit, alors que 'DescripteurFichierA' n'a pas encore ete defini...    */

void      png_read(png_struct *png,png_byte *donnees,png_size_t longueur)
          {
          ssize_t   NombreDOctetsLus=read(fileno(DescripteurFichier),donnees,longueur);
                                        /* Introduit le 20131014101526 a cause de 'v $xrC/EffectuerCompilations.01$vv$Z OpTiOnS'     */
                                        /* dans le cas ou une optimisation est demandee...                                           */
          }

#define   DECOMPRESSION_PNG_DU_FICHIER_R                                                                                                \
                    {                                                                                                                   \
                    TypeImage *ImageDecompactee=malloc(DimImages);                                                                      \
                                                                                                                                        \
                    long      int       DimensionImageEffective=DimImages;                                                              \
                                                                                                                                        \
                                                                                                                                        \
                                                                                                                                        \
                              {                                                                                                         \
                              png_struct          *StructureImage=png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);                  \
                              png_info            *StructureInformations=png_create_info_struct(StructureImage);                        \
                                                                                                                                        \
                                        {                                                                                               \
                                        struct stat         StatistiquesFichierA;                                                       \
                                        DescripteurFichier=DescripteurFichierA;                                                         \
                                        png_set_read_fn(StructureImage,0,png_read);                                                     \
                                        fstat(fileno(DescripteurFichierA),&StatistiquesFichierA);                                       \
                                        png_read_info(StructureImage,StructureInformations);                                            \
                                                                                                                                        \
                                                  {                                                                                     \
                                                  int       dimXc=png_get_image_width(StructureImage,StructureInformations);            \
                                                  int       dimYc=png_get_image_height(StructureImage,StructureInformations);           \
                                                  int       NombreDeCanaux=png_get_channels(StructureImage,StructureInformations);      \
                                                  int       NombreDeBitsParPoint=png_get_bit_depth(StructureImage                       \
                                                                                                  ,StructureInformations                \
                                                                                                   );                                   \
                                                  png_byte  **ligne=malloc(sizeof(*ligne)*dimYc);                                       \
                                                                                                                                        \
                                                  if        (dimXc != dimX)                                                             \
                                                            {                                                                           \
                                                            fprintf(stderr,"Les dimensions en 'X' de l'image sont incorrectes.\n");     \
                                                            exit(NOK);                                                                  \
                                                            }                                                                           \
                                                  else                                                                                  \
                                                            {                                                                           \
                                                            }                                                                           \
                                                                                                                                        \
                                                  if        ((dimYc != dimY) && (dimYc != (dimY/NBITOC)))                               \
                                                            {                                                                           \
                                                            fprintf(stderr,"Les dimensions en 'Y' de l'image sont incorrectes.\n");     \
                                                            exit(NOK);                                                                  \
                                                            }                                                                           \
                                                  else                                                                                  \
                                                            {                                                                           \
                                                            }                                                                           \
                                                                                                                                        \
                                                  if        (NombreDeCanaux != 1)                                                       \
                                                            {                                                                           \
                                                            fprintf(stderr,"L'image n'est pas en fausses couleurs.\n");                 \
                                                            exit(NOK);                                                                  \
                                                            }                                                                           \
                                                  else                                                                                  \
                                                            {                                                                           \
                                                            }                                                                           \
                                                                                                                                        \
                                                  for       (y=0 ; y < dimYc ; y++)                                                     \
                                                            {                                                                           \
                                                            ligne[y]=ImageDecompactee+(dimXc*y*NombreDeCanaux);                         \
                                                            }                                                                           \
                                                                                                                                        \
                                                  png_read_image(StructureImage,(png_byte**)ligne);                                     \
                                                                                                                                        \
                                                  if        (dimYc == (dimY/NBITOC))                                                    \
                                                            {                                                                           \
                                                            DimensionImageEffective=(DimensionImageEffective/NBITOC);                   \
                                                            }                                                                           \
                                                  else                                                                                  \
                                                            {                                                                           \
                                                            }                                                                           \
                                                                                                                                        \
                                                  fwrite(ImageDecompactee,1,DimensionImageEffective,DescripteurFichierR);               \
                                                  }                                                                                     \
                                        }                                                                                               \
                              }                                                                                                         \
                                                                                                                                        \
                    free(ImageDecompactee);                                                                                             \
                    }