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

---

ReadJpg.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_ReadJpg_h
#define Impala_Core_Array_ReadJpg_h

#include <string>
#include "Basis/Timer.h"
#include "Persistency/File.h"
#include "Core/Array/Arrays.h"
#ifdef JPG_USED
#include "Link/Jpeg/CxJpegLink.h"
#endif

namespace Impala
{
namespace Core
{
namespace Array
{


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

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

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

#ifdef JPG_USED

static jmp_buf gReadJpgJmpbuf;
static char gJpgErrorBuffer[JMSG_LENGTH_MAX];

static inline void 
JpgLinkErrorFunc(j_common_ptr cinfo)
{
    /* Create the message */
    (*cinfo->err->format_message) (cinfo, gJpgErrorBuffer);
    longjmp(gReadJpgJmpbuf, 1);
}

String
JpgColorSpace2String(J_COLOR_SPACE cSpace)
{
    switch (cSpace)
    {
    case JCS_UNKNOWN: return "JCS_UNKNOWN";
    case JCS_GRAYSCALE: return "JCS_GRAYSCALE";
    case JCS_RGB: return "JCS_RGB";
    case JCS_YCbCr: return "JCS_YCbCr";
    case JCS_CMYK: return "JCS_CMYK";
    case JCS_YCCK: return "JCS_YCCK";
    }
    return "NO_JCS_VALUE";
}

template <class ArrayT>
inline void
ReadJpgFromMemory(ArrayT*& dst, char *buf, int bufsize)
{
    ILOG_VAR(Impala.Core.Array.ReadJpgFromMemory);
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr pub;
    cinfo.err = jpeg_std_error(&pub);
    pub.error_exit = JpgLinkErrorFunc;
    sprintf(gJpgErrorBuffer, "Something is wrong");
    if (setjmp(gReadJpgJmpbuf))
    {
        //ILOG_ERROR("jmp: " << String(gJpgErrorBuffer));
        ILOG_WARN("jmp: " << String(gJpgErrorBuffer));
        jpeg_destroy_decompress(&cinfo);
        return;
    }
    jpeg_create_decompress(&cinfo);
    jpeg_memory_src(&cinfo, (const JOCTET *)buf, bufsize);
    jpeg_read_header(&cinfo, TRUE);

    if (cinfo.num_components == 4)
        cinfo.out_color_space = JCS_CMYK;
    jpeg_calc_output_dimensions(&cinfo);
    jpeg_start_decompress(&cinfo);

    ILOG_DEBUG("color_space = " << JpgColorSpace2String(cinfo.jpeg_color_space));
    ILOG_DEBUG("MAXJSAMPLE = " << MAXJSAMPLE);
    ILOG_DEBUG("CENTERJSAMPLE = " << CENTERJSAMPLE);

    if ((cinfo.num_components == 4) && (!cinfo.saw_Adobe_marker))
        ILOG_WARN("Never tested non-inverted CMYK format");

    int width = cinfo.output_width;
    int height = cinfo.output_height;
    int row_stride = cinfo.output_width * cinfo.output_components;
    bool gray = (cinfo.output_components == 1) ? true : false;
    UInt8* c4Buf = (cinfo.output_components == 4) ? new UInt8[row_stride] : 0;
    if (dst == 0)
        dst = ArrayCreate<ArrayT>(width, height);

    while (cinfo.output_scanline < cinfo.output_height)
    {
        UInt8* dataPtr = dst->CPB(0, cinfo.output_scanline);
        UInt8* bufPtr = (c4Buf) ? c4Buf : dataPtr;
        int nrRead = jpeg_read_scanlines(&cinfo, &bufPtr, 1);
        if (nrRead != 1)
            ILOG_ERROR("jpeg_read_scanlines couldn't read line");
        if (c4Buf)
        {
            if (cinfo.saw_Adobe_marker)
            {
                for (int i=0 ; i<width ; i++)
                {
                    int k = 255 - bufPtr[3];

                    int val = bufPtr[0] - k;
                    dataPtr[0] = (val < 0) ? 0 : val;
                    val = bufPtr[1] - k;
                    dataPtr[1] = (val < 0) ? 0 : val;
                    val = bufPtr[2] - k;
                    dataPtr[2] = (val < 0) ? 0 : val;

                    dataPtr += 3;
                    bufPtr += 4;
                }
            }
            else
            {
                for (int i=0 ; i<width ; i++)
                {
                    int k = 255 - bufPtr[3];

                    int val = k - bufPtr[0];
                    dataPtr[0] = (val < 0) ? 0 : val;
                    val = k - bufPtr[1];
                    dataPtr[1] = (val < 0) ? 0 : val;
                    val = k - bufPtr[2];
                    dataPtr[2] = (val < 0) ? 0 : val;

                    dataPtr += 3;
                    bufPtr += 4;
                }
            }
        }
        if (gray)
        {
            UInt8* endLine = dataPtr + width * 3 - 1;
            UInt8* endData = dataPtr + width - 1;
            for (int i=0 ; i<width ; i++)
            {
                *endLine-- = *endData;
                *endLine-- = *endData;
                *endLine-- = *endData--;
            }
        }
    }
    if (c4Buf)
        delete c4Buf;
    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);
}

#else

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

#endif // JPG_USED

template <class ArrayT>
inline void
ReadJpg(ArrayT*& dst, Util::IOBuffer* buffer)
{
    ILOG_VAR(Impala.Core.Array.ReadJpg);
    size_t memBufSize = buffer->Size();
    char* buf = new char[memBufSize];
    size_t nrRead = buffer->Read(buf, memBufSize);
    if (nrRead != memBufSize)
    {
        ILOG_ERROR("Buffer read failed");
        delete buf;
        return;
    }
    ReadJpgFromMemory(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
ReadJpg(ArrayT*& dst, String fileName, Util::Database* db)
{
    Util::IOBuffer* buf = db->GetIOBuffer(fileName, true, false, "");
    if (buf)
    {
        ReadJpg(dst, buf);
        delete buf;
    }
}
#endif // REPOSITORY_USED

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

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

#endif

---