src/rcrt/textures/pngHelper.hxx

Go to the documentation of this file.

#ifndef __LIBPNG_HELPERS__
#define __LIBPNG_HELPERS__

#include <png.h>
#include <cstdio>
#include <iostream>
#include <fstream>

#define PNG_BYTES_TO_CHECK 8

using namespace std;


int check_if_png(const char *file_name, FILE **fp)
{
   png_byte buf[PNG_BYTES_TO_CHECK];

   /* Open the prospective PNG file. */
   if ((*fp = fopen(file_name, "rb")) == NULL)
      return 0;

   /* Read in some of the signature bytes */
   if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK)
      return 0;

   /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.
      Return nonzero (true) if they match */

   bool res = (!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK));
   fclose(*fp);
   return res;
}

void read_png(const char* file_name, 
              unsigned char*& buffer,
              int& width,
              int& height,
              int& channels,
              int& bit_depth, 
              int& color_type,
              bool flip_vert)
  
{
   png_structp png_ptr;
   png_infop info_ptr;
   //   int interlace_type;

   FILE *fp;
   bool check=check_if_png(file_name,&fp);

   if (!check)
     {
       std::cerr << "This is not a PNG file !!" << endl;
       exit(1);
    }
   
  fp=fopen(file_name, "rb");
   
  
  
  /* Create and initialize the png_struct with the desired error handler
   * functions.  If you want to use the default stderr and longjump method,
   * you can supply NULL for the last three parameters.  We also supply the
   * the compiler header file version, so that we know if the application
   * was compiled with a compatible version of the library.  REQUIRED
   */
  //png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
  //   png_voidp user_error_ptr, user_error_fn, user_warning_fn);
  png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
                                   NULL, NULL, NULL);
  
  if (png_ptr == NULL)
    {
      fclose(fp);
      std::cerr << "Error initializing png_ptr !" << endl;
      exit(1);
    }
  
   /* Allocate/initialize the memory for image information.  REQUIRED. */
   info_ptr = png_create_info_struct(png_ptr);
   if (info_ptr == NULL)
   {
      fclose(fp);
      png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
      std::cerr << "Error initializing info_ptr !" << endl;
      exit(1);
   }

   /* Set error handling if you are using the setjmp/longjmp method (this is
    * the normal method of doing things with libpng).  REQUIRED unless you
    * set up your own error handlers in the png_create_read_struct() earlier.
    */

   if (setjmp(png_jmpbuf(png_ptr)))
   {
      /* Free all of the memory associated with the png_ptr and info_ptr */
      png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
      fclose(fp);
      /* If we get here, we had a problem reading the file */
      std::cerr << "Error initializing png_ptr !" << endl;
      exit(1);
   }

   png_init_io(png_ptr, fp);

   /* If we have already read some of the signature */
   png_set_sig_bytes(png_ptr,0);

   /*
    * If you have enough memory to read in the entire image at once,
    * and you need to specify only transforms that can be controlled
    * with one of the PNG_TRANSFORM_* bits (this presently excludes
    * dithering, filling, setting background, and doing gamma
    * adjustment), then you can read the entire image (including
    * pixels) into the info structure with this call:
    */
   png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, png_voidp_NULL);   

   width            = png_get_image_width(png_ptr,
                                          info_ptr);
   height           = png_get_image_height(png_ptr,
                                           info_ptr);
   channels         = png_get_channels(png_ptr,
                                       info_ptr);
   bit_depth = png_get_bit_depth(png_ptr,info_ptr);
   color_type = png_get_color_type(png_ptr,info_ptr);
   png_uint_32 valid = 0;
   png_get_valid(png_ptr,info_ptr,valid);

   png_bytep* row_pointers=(png_bytep*)malloc(height*sizeof(png_bytep));
   row_pointers=png_get_rows(png_ptr, info_ptr);

   //allocate buffer
   const int c=width*channels*bit_depth/8;
   buffer=(unsigned char*)malloc(sizeof(unsigned char)*channels*width*height*bit_depth/8);

   if (!flip_vert)
     {
       for (int y=0;y<height;++y)
         memcpy((void*)&(buffer[y*c]),(void*)(row_pointers[y]),c);
     }
   else
     {
       for (int y=0;y<height;++y)
         memcpy((void*)&(buffer[(height-1-y)*c]),(void*)(row_pointers[y]),c);
     }
   
   png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
   fclose(fp);
}


/* write a png file */

void write_png(const char *file_name, unsigned char* buffer, 
               int width, int height, int channels, 
               int bit_depth, png_uint_32 color_type,
               bool flip_vert)
{
   FILE *fp;
   png_structp png_ptr;
   png_infop info_ptr;
   //   png_colorp palette;

   /* open the file */
   fp = fopen(file_name, "wb");
   if (fp == NULL)
     {
       std::cerr << "Error opening file " << endl;
     }

   /* Create and initialize the png_struct with the desired error handler
    * functions.  If you want to use the default stderr and longjump method,
    * you can supply NULL for the last three parameters.  We also check that
    * the library version is compatible with the one used at compile time,
    * in case we are using dynamically linked libraries.  REQUIRED.
    */
   png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
                                     NULL,NULL,NULL);

   if (png_ptr == NULL)
   {
      fclose(fp);
      std::cerr << "Error allocating png_ptr !!" << endl;
      exit(1);
   }

   /* Allocate/initialize the image information data.  REQUIRED */
   info_ptr = png_create_info_struct(png_ptr);
   if (info_ptr == NULL)
   {
      fclose(fp);
      png_destroy_write_struct(&png_ptr,  png_infopp_NULL);
      std::cerr << "Error allocating info ptr !!" << endl;
      exit(1);
   }

   /* Set error handling.  REQUIRED if you aren't supplying your own
    * error handling functions in the png_create_write_struct() call.
    */
   if (setjmp(png_jmpbuf(png_ptr)))
   {
      /* If we get here, we had a problem reading the file */
      fclose(fp);
      png_destroy_write_struct(&png_ptr, &info_ptr);
      exit(1);
   }

   png_init_io(png_ptr, fp);

   png_set_IHDR(png_ptr, info_ptr, (png_uint_32)width, (png_uint_32) height,
                (png_byte) bit_depth, (png_byte) color_type, PNG_INTERLACE_NONE,
                PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT );

   //setup row data structure from buffer
   
   png_bytep row_pointers[height];
   const int c=width*channels*bit_depth/8;
   if (!flip_vert)
     {
       for (int y=0;y<height;++y)
         {
           row_pointers[y]=(png_bytep) &(buffer[y*c]);
         }
     }
   else
     {
       for (int y=0;y<height;++y)
         {
           row_pointers[height-1-y]=(png_bytep) &(buffer[y*c]);
         }
     }
   //raise(5);
   
   png_set_rows(png_ptr, info_ptr, row_pointers);
   png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, png_voidp_NULL);

   png_destroy_write_struct(&png_ptr, &info_ptr);
   fclose(fp);
}

#endif

---