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

---

WritePng.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_WritePng_h
#define Impala_Core_Array_WritePng_h

#include "Core/Array/Arrays.h"
#include "Core/Array/MakeFromData.h"
#include "Persistency/File.h"

#ifdef PNG_USED
#include "Link/Png/CxPngLink.h"
#endif

namespace Impala
{
namespace Core
{
namespace Array
{


#ifdef PNG_USED
static jmp_buf gWritePngJmpbuf;

static inline void 
errorFuncWritePng(png_structp png_ptr, png_const_charp msg)
{
    ILOG_VAR(Impala.Core.Array.WritePng);
    ILOG_ERROR("PNG Error: " << msg);    
    //longjmp(png_ptr->jmpbuf, 1);
    longjmp(gWritePngJmpbuf, 1);
}

static inline void 
warnFuncWritePng(png_structp png_ptr, png_const_charp msg)
{
    ILOG_VAR(Impala.Core.Array.WritePng);
    ILOG_WARN("PNG Warning: " << msg);
}

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

static inline void
FlushPngDataFunc(png_structp png_ptr)
{
}


template <class ArrayT>
inline bool
WritePngToMemory(ArrayT* src, char* buf, size_t memBufSize, size_t* outSize)
{
    ILOG_VAR(Impala.Core.Array.WritePngToMemory);
    png_structp png;
    png_infop   pngInfo;
    png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
                                  errorFuncWritePng, warnFuncWritePng);
    if (!png)
    {
        ILOG_ERROR("png_create_write_struct error");
        return false;
    }

    pngInfo = png_create_info_struct(png);
    if (!pngInfo)
    {
        ILOG_ERROR("png_create_info_struct error");
        png_destroy_write_struct(&png, NULL);
        return false;
    }

    if (setjmp(gWritePngJmpbuf))
    {
        ILOG_ERROR("setjmp");
        png_destroy_write_struct(&png, &pngInfo);
        return false;
    }

    png_set_write_fn(png, buf, WritePngDataFunc, FlushPngDataFunc);
    png->io_ptr = buf; // This should have been done by png_set_write_fn ?!?

    int colorType;
    if (ArrayT::ElemSize() == 1)
        colorType = PNG_COLOR_TYPE_GRAY;
    else
        colorType = PNG_COLOR_TYPE_RGB;
    int bitDepth = 8;
    png_uint_32 width = src->CW();
    png_uint_32 height = src->CH();

    png_set_IHDR(png, pngInfo, width, height, bitDepth, colorType,
                 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
                 PNG_FILTER_TYPE_BASE);
    png_write_info(png, pngInfo);

    for (int row=0 ; row<src->CH() ; row++)
    {
        UInt8* dataPtr = src->CPB(0, row);
        //if (setjmp(png->jmpbuf)) {
        if (setjmp(gWritePngJmpbuf))
        {
            ILOG_ERROR("Error writing png data");
            return false;
        }
        png_write_row(png, dataPtr);
    }
    png_write_end(png, pngInfo);
    char* endBuf = (char*) png->io_ptr;
    *outSize = (endBuf - buf);
    png_destroy_write_struct(&png, &pngInfo);
    return true;
}

#else

template <class ArrayT>
inline bool
WritePngToMemory(ArrayT* src, char* buf, size_t memBufSize, size_t* outSize)
{
    ILOG_VAR(Impala.Core.Array.WritePngToMemory);
    ILOG_ERROR("WritePng not available.");
    return false;
}

#endif // PNG_USED

template <class ArrayT>
inline Array2dScalarUInt8*
WritePng(ArrayT* src)
{
    Array2dScalarUInt8* res = 0;
    size_t bufSize = src->CW() * src->CH() * 3 + 1024;
    char* buf = new char[bufSize];
    size_t outSize;
    if (!WritePngToMemory(src, buf, bufSize, &outSize))
    {
        delete buf;
        return res;
    }
    res = MakeFromData<Array2dScalarUInt8>((UInt8*) buf, bufSize, 1);
    delete buf;
    return res;
}

template <class ArrayT>
inline bool
WritePng(ArrayT* src, Util::IOBuffer* buffer)
{
    size_t memBufSize = src->CW() * src->CH() * 3 + 1024;
    char* buf = new char[memBufSize];
    size_t outSize;
    if (!WritePngToMemory(src, buf, memBufSize, &outSize))
    {
        delete buf;
        return false;
    }
    buffer->Write(buf, outSize);
    delete buf;
    return true;
}

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
template <class ArrayT>
inline bool
WritePng(ArrayT* src, String fileName, Util::Database* db)
{
    Util::IOBuffer* buf = db->GetIOBuffer(fileName, false, false, "tmp");
    if (!buf)
        return false;
    bool res = WritePng(src, buf);
    delete buf;
    return res;
}
#endif // REPOSITORY_USED

// TODO : not really a template function since ArrayT has to be UInt8 based.
// Handles Vec3UInt8 images only
template <class ArrayT>
inline bool
WritePng(ArrayT* src, Persistency::File file)
{
    Util::IOBuffer* buf = file.GetWriteBuffer();
    if (!buf)
        return false;
    bool res = WritePng(src, buf);
    delete buf;
    return res;
}

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

#endif

---