C:/Active/libraries/cxutils/2.0/src/cxutils/images/png/png.cpp

Go to the documentation of this file.

#include "cxutils/images/png/png.h"
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>

extern "C"
{
#include <png.h>
}

#ifdef WIN32

#define XMD_H // prevent redefinition of INT32
#undef FAR    // prevent FAR redefinition

#endif

namespace CxUtils
{
    namespace PNG
    {
        struct InputSource
        {
            unsigned char* mpImage;                       
            unsigned int mImageSize;                      
            unsigned int mNumBytesRead;                   
        };

        // Function to read data for PNG library.
        void ReadData(png_structp png_ptr, png_bytep data, png_size_t length)
        {
            unsigned int bytesToRead = (unsigned int)length;
            struct InputSource* input = (struct InputSource*)png_ptr->io_ptr;

            if(bytesToRead > input->mImageSize - input->mNumBytesRead)
            {
                bytesToRead = input->mImageSize - input->mNumBytesRead;
            }
            if(bytesToRead > 0)
            {
                memcpy(data, &input->mpImage[input->mNumBytesRead], bytesToRead);
                input->mNumBytesRead += bytesToRead;
            }
        }
    }
}

int CxUtils::PNG::DecompressImage(const unsigned char* png,
                                  const unsigned int pngSize,
                                  unsigned char** image,
                                  unsigned short* width,
                                  unsigned short* height,
                                  unsigned char* channels)
{
    png_structp      png_ptr = NULL;
    png_infop        info_ptr = NULL;
    png_byte *ptr = (png_byte *)png;

    int is_png = !png_sig_cmp(ptr, 0, 8);

    if (is_png)
    {
        png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
        if(png_ptr)
        {
            info_ptr = png_create_info_struct(png_ptr);
        }
        else
        {
            return 0;
        }
    }
    else 
    {
        return 0;
    }

    if (info_ptr)
    {   
        // Create an input structure and
        // assign it and read method to 
        // the png decompressor structure.
        struct InputSource input;

        input.mImageSize = pngSize;
        input.mpImage = (unsigned char *)png;
        input.mNumBytesRead = 0;

        png_ptr->io_ptr = &input;
        png_ptr->read_data_fn = ReadData;

        png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_BGR, NULL);

        // Calculate size of output image in bytes.
        unsigned int outputSize;
        outputSize = info_ptr->width*info_ptr->height*info_ptr->channels;

        // Allocate memory to store the decompressed image.
        if(*image != NULL)
        {
            // See if we need to re-allocate. 
            if(outputSize >= (unsigned int)(*width)*(*height)*(*channels))
            {
                delete[] *image;
                *image = new unsigned char[outputSize + 100];
            }
        }
        else
        {
            *image = new unsigned char[outputSize + 100];
        }

        *width = (unsigned short)info_ptr->width;
        *height = (unsigned short)info_ptr->height;
        *channels = (unsigned char)info_ptr->channels;

        png_bytep * row_pointers = NULL;
        row_pointers = NULL;

        int row_stride = (*width)*(*channels)*sizeof(unsigned char);
        if (info_ptr->color_type == PNG_COLOR_TYPE_RGB || info_ptr->color_type == PNG_COLOR_TYPE_GRAY)
        {
            row_pointers = png_get_rows(png_ptr, info_ptr);

            for (unsigned int i = 0; i < *height; i++)
            {
                memcpy( *image + i*row_stride, row_pointers[i], row_stride);
            }
        }

        if(png_ptr && info_ptr)
        {
            png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
        }
        else if(png_ptr)
        {
            png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
        }

        return 1;
    }
    
    return 0;
}

namespace CxUtils
{
    namespace PNG
    {
        struct OutputSource
        {
            unsigned char* mpCompressedPNG;             
            unsigned int mCompressedBufferSize;         
            unsigned int mNumBytesCompressed;           
        };

        // Function to read data for PNG library.
        void WriteData(png_structp png_ptr, png_bytep data, png_size_t length)
        {
            struct OutputSource* output = (struct OutputSource*)png_ptr->io_ptr;
            
            if(output->mNumBytesCompressed + length > output->mCompressedBufferSize)
            {
                unsigned char* temp = new unsigned char[output->mCompressedBufferSize + length];
                memcpy(temp, output->mpCompressedPNG, output->mNumBytesCompressed);
                delete[] output->mpCompressedPNG;
                output->mpCompressedPNG = temp;
                output->mCompressedBufferSize += (unsigned int)length;        
            }
            memcpy(&output->mpCompressedPNG[output->mNumBytesCompressed], data, length);
            output->mNumBytesCompressed += (unsigned int)length;
        }
    }
}

int CxUtils::PNG::CompressImage(const unsigned short width,
                                const unsigned short height,
                                const unsigned char channels,
                                const unsigned char* image,
                                unsigned char** png,
                                unsigned int* pngBufferSize,
                                unsigned int* pngSize)
{
    int result = 0;

    if( width == 0 || 
        height == 0 || 
        !(channels == 1 || channels == 3) ||
        image == NULL || 
        png == NULL ) 
    {
        return result;
    }

    if( channels == 3 || channels == 1 )
    {
        if(*pngBufferSize == 0 || *png == NULL)
        {
            // Delete memory if it already exists
            if( (*png) )
            {
                delete[] *png;
                *png = NULL;
            }
            *png = new unsigned char[4096];
            *pngBufferSize = 4096;
        }
        *pngSize = 0;

        png_structp     png_ptr = NULL;
        png_bytep     * row_pointers = NULL;

        png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
        png_infop       info_ptr = png_create_info_struct(png_ptr);

        // Initialize the output devices and function
        // for png compression
        struct OutputSource output;
        output.mCompressedBufferSize = *pngBufferSize;
        output.mNumBytesCompressed = 0;
        output.mpCompressedPNG = *png;

        png_ptr->io_ptr = &output;
        png_ptr->write_data_fn = WriteData;

        png_byte color;
        if (channels == 1)
        {
            color = PNG_COLOR_TYPE_GRAY;
        }
        else if (channels == 3)
        {
            color = PNG_COLOR_TYPE_RGB;
        }
        else
        {
            color = PNG_COLOR_TYPE_RGB;
        }


        png_set_IHDR(png_ptr, info_ptr, width, height,
                8, color, PNG_INTERLACE_NONE,
                PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

        row_pointers = (png_bytep*)malloc(height*sizeof(png_bytep));
        int row_stride = width*channels*sizeof(unsigned char);
        // Go and assign row pointers.
        for (int i=0 ; i< height; i++)
        {
            row_pointers[i] = (png_byte*)&image[i*row_stride];

        }

        png_set_rows(png_ptr, info_ptr, row_pointers);
        png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_BGR, NULL);

        free(row_pointers);

        *png = output.mpCompressedPNG;
        *pngBufferSize = output.mCompressedBufferSize;
        *pngSize = output.mNumBytesCompressed;

        png_destroy_write_struct(&png_ptr, &info_ptr);

        result = 1;

    }

    return result;
}


/*  End of File */