src/pngHelper.h

Go to the documentation of this file.

#ifndef __LIBPNG_HELPERS__
#define __LIBPNG_HELPERS__

// prevent c-style cast warnings in png.h
#define PNG_NO_TYPECAST_NULL

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

static unsigned const int   PNG_BYTES_TO_CHECK = 8;

// TODO make a OO class out of this crap

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, static_cast<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;
    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, 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_get_rows(png_ptr, info_ptr);

    // allocate buffer
    const int c = width*channels*bit_depth/8;
    buffer = new unsigned char[channels * width * height * bit_depth / 8];

    if (!flip_vert)
    {
        for (int y = 0;y<height;++y)
        {
            memcpy(static_cast<void*>(&(buffer[y*c])), static_cast<void*>(row_pointers[y]), c);
        }
    }
    else
    {
        for (int y = 0;y<height;++y)
        {
            memcpy(static_cast<void*>(&(buffer[(height-1-y)*c])), static_cast<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,
                    static_cast<png_uint_32>(width), static_cast<png_uint_32>(height),
                    static_cast<png_byte>(bit_depth), static_cast<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 = new png_bytep[height];
    const int c = width * channels * bit_depth / 8;
    if (!flip_vert)
    {
        for (int y = 0;y<height;++y)
        {
            row_pointers[y] = static_cast<png_bytep>(&(buffer[y*c]));
        }
    }
    else
    {
        for (int y = 0;y<height;++y)
        {
            row_pointers[height-1-y] = static_cast<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);
    delete [] row_pointers;
    fclose(fp);
}

#endif

---