imageFilePNG.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <png.h>

#include "imageFilePNG.hpp"

//------------------------------------------------------------------------
void pngError(png_structp png_ptr, png_const_charp msg)
//------------------------------------------------------------------------
{
    if(png_ptr)
    {
        printf("libpng error: %s\n", msg);
    }   
}

//------------------------------------------------------------------------
void pngWarning(png_structp png_ptr, png_const_charp msg)
//------------------------------------------------------------------------
{
    if(png_ptr)
    {
        printf("libpng warning: %s\n", msg);
    }   
}

//------------------------------------------------------------------------
imageFilePNG::imageFilePNG() 
//------------------------------------------------------------------------
{
}

//------------------------------------------------------------------------
imageFilePNG::~imageFilePNG()
//------------------------------------------------------------------------
{
}

//------------------------------------------------------------------------
bool imageFilePNG::loadImage(String filename)
//------------------------------------------------------------------------
{
    FILE * fp;
    png_structp pngRead;
    png_infop pngInfo;
    UInt8 pngHeader[8];
    bool res = true;
    Int32 i;

    // open the PNG input file
    if (!(fp = fopen(filename, "rb")))
    {
        return false;
    }
    
    fread(pngHeader, 1, 8, fp);
    if (0 != png_sig_cmp(pngHeader, 0, 8))
    {
        printf(__FILE__"This is not a valid PNG\n");
        return false;
    }

    // create the two png(-info) structures
    pngRead = png_create_read_struct(PNG_LIBPNG_VER_STRING, (void *)this, (png_error_ptr)pngError, (png_error_ptr)pngWarning);
    if(0 == pngRead)
    {
        return false;
    }

    pngInfo = png_create_info_struct(pngRead);
    if(0 == pngInfo)
    {
        png_destroy_read_struct(&pngRead, NULL, NULL);
        return false;
    }  

    do {
    
        png_init_io(pngRead, fp);
        png_set_sig_bytes(pngRead, 8);
    
        // read all PNG info up to image data  
        png_read_info(pngRead, pngInfo);
    
        Int32 bitWidth;
        Int32 colorType;
        Int32 width;
        Int32 height;
        
        // get width, height, bit-depth and color-type
        png_get_IHDR(pngRead, pngInfo, (unsigned long *)&width, (unsigned long *)&height, &bitWidth, &colorType, NULL, NULL, NULL);
    
        //We support only 8 pit per Pixel        
        if (8 != bitWidth)
        {
            printf(__FILE__"Bitwidths other than 8 are not supported\n");
            res = false;
            break;
        }
        
        Int32 numberOfBytes = 0;
        Int32 bytesPerRow = 0;
        imageFile::ePixelFormat pixelFormat = imageFile::NONE;

        //Check for supported color types
        if ((PNG_COLOR_TYPE_GRAY == colorType) || (PNG_COLOR_TYPE_GRAY == colorType))
        {
            pixelFormat = imageFile::G8;
            numberOfBytes = width * height;
            bytesPerRow = width;
        }
        else if (PNG_COLOR_TYPE_RGB == colorType)
        {
            pixelFormat = imageFile::RGB888;
            numberOfBytes = width * height * 3;
            bytesPerRow = width * 3;
        }
        else if (PNG_COLOR_TYPE_RGB_ALPHA == colorType)
        {
            pixelFormat = imageFile::RGBA8888;
            numberOfBytes = width * height * 4;
            bytesPerRow = width * 4;
        }
        else
        {
            printf(__FILE__"Color type not supported\n");
            res = false;
            break;
        }

         //Throw away old content before loading the new image data
        cleanup();
        
        mPixelFormat = pixelFormat;
        mWidth = width;
        mHeight = height;

        //allocate image data
        mPixels = new UInt8[numberOfBytes];

        //allocate row pointers
        UInt8 ** rowPointers = new UInt8*[height];
            
        //Initialize row pointers    
        for (i = 0; i < height; i++)
        {
            rowPointers[i] = mPixels + i * bytesPerRow;
        }
    
        // now we can go ahead and just read the whole image    
        png_read_image(pngRead, rowPointers);
    
        // read the additional chunks in the PNG file (not really needed)    
        png_read_end(pngRead, NULL);
    
        // and we're done
    
        delete [] rowPointers;

    }while(0);

    png_destroy_read_struct(&pngRead, &pngInfo, NULL);
       
    fclose(fp);
   
    return res;
}

//------------------------------------------------------------------------
bool imageFilePNG::writeImage(String filename)
//------------------------------------------------------------------------
{
    FILE * fp;
    png_structp pngWrite;
    png_infop pngInfo;
    bool res = true;
    Int32 i;

    // open the PNG output file
    if (!(fp = fopen(filename, "wb")))
    {
        return false;
    }

    // prepare the standard PNG structures

    pngWrite = png_create_write_struct(PNG_LIBPNG_VER_STRING, (void *)this, (png_error_ptr)pngError, (png_error_ptr)pngWarning);
    if (0 == pngWrite)
    {
        fclose(fp);
        return false;
    }

    pngInfo = png_create_info_struct(pngWrite);
    if (0 == pngInfo) 
    {
        fclose(fp);
        png_destroy_write_struct(&pngWrite, (png_infopp) NULL);
        return false;
    }

    do
    {
        png_init_io(pngWrite, fp);

        Int32 colorType = 0;
        Int32 channels = 0;

        if(imageFile::RGB888 == mPixelFormat)
        {
            colorType = PNG_COLOR_TYPE_RGB;
            channels = 3;
        }
        else if(imageFile::RGBA8888 == mPixelFormat)
        {
            colorType = PNG_COLOR_TYPE_RGBA;
            channels = 4;
        }
        else if(imageFile::G8== mPixelFormat)
        {
            colorType = PNG_COLOR_TYPE_GRAY;
            channels = 1;
        }
        else
        {
            res = false;
            break;
        }
        
        // we're going to write a very simple 3x8 bit RGB image
        png_set_IHDR(pngWrite, pngInfo, mWidth, mHeight, 8, colorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
        
        // write the file header information
        png_write_info(pngWrite, pngInfo);
               
        // row_bytes is the width x number of channels
        UInt32 bytesPerRow = mWidth * channels;
        
        // we can allocate memory for an array of row-pointers
        
        png_bytepp ppbRowPointers = new png_bytep[mHeight];
        
        // set the individual row-pointers to point at the correct offsets  
        for (i = 0; i < mHeight; i++)
        {
            ppbRowPointers[i] = mPixels + i * bytesPerRow;
        }
        
        // write out the entire image data in one call
        
        png_write_image (pngWrite, ppbRowPointers);
        
        // write the additional chunks to the PNG file (not really needed)
        
        png_write_end(pngWrite, pngInfo);
        
        // and we're done
        
        delete [] ppbRowPointers;

            
    }while(0);
    
    png_destroy_write_struct(&pngWrite, (png_infopp) NULL);

    fclose(fp);
    return res;
}

---