|| || || || || || || ||

---

ReadPng.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_ReadPng_h
#define Impala_Core_Array_ReadPng_h

#include <string>
#include "Basis/ILog.h"
#include "Persistency/File.h"
#include "Util/Database.h"
#include "Core/Array/Arrays.h"
#ifdef PNG_USED
#include "Link/Png/CxPngLink.h"
#endif

namespace Impala
{
namespace Core
{
namespace Array
{


#ifdef PNG_USED
static jmp_buf gReadPngJmpbuf;

static inline void 
ReadPngErrorFunc(png_structp png_ptr, png_const_charp msg)
{
    std::cerr << "PNG Error: " << msg << std::endl;    
    //longjmp(png_ptr->jmpbuf, 1);
    longjmp(gReadPngJmpbuf, 1);
}

static inline void 
ReadPngWarnFunc(png_structp png_ptr, png_const_charp msg)
{
    std::cerr << "PNG Warning: " << msg << std::endl;
}

static inline void
ReadPngDataFunc(png_structp png_ptr, png_bytep data, png_size_t length)
{
    char* buf = (char*) png_ptr->io_ptr;
    memcpy(data, png_ptr->io_ptr, length);
    buf += length;
    png_ptr->io_ptr = buf;
}
#endif


inline void
ReadPngFromMemory(Array2dScalarInt32*& dst, char *buf, int bufsize)
{
    ILOG_VAR(Impala.Core.Array.ReadPngFromMemory);
    ILOG_ERROR("array type not supported");
}

inline void
ReadPngFromMemory(Array2dScalarReal64*& dst, char *buf, int bufsize)
{
    ILOG_VAR(Impala.Core.Array.ReadPngFromMemory);
    ILOG_ERROR("array type not supported");
}

inline void
ReadPngFromMemory(Array2dVec3Real64*& dst, char *buf, int bufsize)
{
    ILOG_VAR(Impala.Core.Array.ReadPngFromMemory);
    ILOG_ERROR("array type not supported");
}

#ifdef PNG_USED

template <class ArrayT>
inline void
ReadPngFromMemory(ArrayT*& dst, char *buf, int bufsize)
{
    ILOG_VAR(Impala.Core.Array.ReadPng);
    png_structp png;
    png_infop   pngInfo;
    const int HEADER_SIZE = 8;

    int is_png = (png_sig_cmp((png_bytep)buf, 0, HEADER_SIZE) == 0);
    buf += HEADER_SIZE;
    if (!is_png)
    {
        ILOG_ERROR("Not in PNG format");
        return;
    }

    png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, ReadPngErrorFunc,
                                 ReadPngWarnFunc);
    if (!png)
    {
        ILOG_ERROR("png_create_read_struct error");
        return;
    }

    pngInfo = png_create_info_struct(png);
    if (!pngInfo)
    {
        ILOG_ERROR("png_create_info_struct error");
        png_destroy_read_struct(&png, NULL, NULL);
        return;
    }
    //if (setjmp(png->jmpbuf)) {
    if (setjmp(gReadPngJmpbuf))
    {
        ILOG_INFO("setjmp");
        png_destroy_read_struct(&png, &pngInfo, NULL);
        return;
    }

    png_set_read_fn(png, buf, ReadPngDataFunc);
    png->io_ptr = buf; // This should have been done by png_set_read_fn ?!?

    png_set_sig_bytes(png, HEADER_SIZE);

    //Image info

    png_read_info(png, pngInfo);

    png_uint_32 width;
    png_uint_32 height;
    int bit_depth, color_type;
    int interlace_type, compression_type, filter_type;
    png_get_IHDR(png, pngInfo, &width, &height, &bit_depth, &color_type,
                 &interlace_type, &compression_type, &filter_type);

    if (interlace_type == PNG_INTERLACE_ADAM7)
    {
        ILOG_ERROR("Interlaced PNG's not supported yet.");
        png_destroy_read_struct(&png, &pngInfo, NULL);
        return;
    }
    if (bit_depth > 8)
    {
        ILOG_ERROR("Bit depths bigger than 8 not supported yet.");
        png_destroy_read_struct(&png, &pngInfo, NULL);
        return;
    }
    if (color_type == PNG_COLOR_TYPE_PALETTE)
        png_set_palette_to_rgb(png);
    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) 
        png_set_gray_1_2_4_to_8(png);
    if (color_type & PNG_COLOR_MASK_ALPHA)
        png_set_strip_alpha(png); //ignore alpha & backround
    bool gray = !(color_type & PNG_COLOR_MASK_COLOR);
    png_read_update_info(png, pngInfo);

    if (dst == 0)
        dst = ArrayCreate<ArrayT>(width, height);

    UInt8* dataPtr;
    png_uint_32 row = 0;
    while (row < height)
    {
        dataPtr = dst->CPB(0, row);
        //if (setjmp(png->jmpbuf)) {
        /*
        if (setjmp(gReadPngJmpbuf))
        {
            std::cout << "setjmp" << std::endl;
            return;
        }
        */
        png_read_row(png, dataPtr, NULL);
        row++;
        if (gray && (ArrayT::ElemSize() == 3))
        {
            UInt8* endLine = dataPtr + width * 3 - 1;
            UInt8* endData = dataPtr + width - 1;
            for (png_uint_32 i=0 ; i<width ; i++)
            {
                *endLine-- = *endData;
                *endLine-- = *endData;
                *endLine-- = *endData--;
            }
        }
    }

    // This produces "Read errors" on some files and is not needed anyway
    //png_read_end(png, pngInfo);

    png_destroy_read_struct(&png, &pngInfo, NULL);
}

#else

template <class ArrayT>
inline void
ReadPngFromMemory(ArrayT*& dst, char *buf, int bufsize)
{
    ILOG_VAR(Impala.Core.Array.ReadPngFromMemory);
    ILOG_ERROR("ReadPng not available");
}

#endif // PNG_USED


// TODO : not really a template function since ArrayT has to be UInt8 based.
template <class ArrayT>
inline void
ReadPng(ArrayT*& dst, Util::IOBuffer* buffer, size_t memBufSize = 10000000)
{
    ILOG_VAR(Impala.Core.Array.ReadPng);
    char* buf = new char[memBufSize];
    size_t nrRead = buffer->Read(buf, memBufSize);
    if (nrRead >= memBufSize)
    {
        ILOG_WARN("ReadPng: buffer to small");
        delete buf;
        return;
    }
    ReadPngFromMemory(dst, buf, memBufSize);
    delete buf;
}

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
// TODO : not really a template function since ArrayT has to be UInt8 based.
template <class ArrayT>
inline void
ReadPng(ArrayT*& dst, String fileName, Util::Database* db,
        int memBufSize = 10000000)
{
    Util::IOBuffer* buf = db->GetIOBuffer(fileName, true, false, "");
    if (buf)
    {
        ReadPng(dst, buf, memBufSize);
        delete buf;
    }
}
#endif // REPOSITORY_USED

// TODO : not really a template function since ArrayT has to be UInt8 based.
template <class ArrayT>
inline void
ReadPng(ArrayT*& dst, Persistency::File file, int memBufSize = 10000000)
{
    Util::IOBuffer* buf = file.GetReadBuffer();
    if (buf)
    {
        ReadPng(dst, buf, memBufSize);
        delete buf;
    }
}

} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---