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

---

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
{

#ifdef JPG_USED
static jmp_buf gReadJpgJmpbuf;

static inline void 
JpgLinkErrorFunc(j_common_ptr cinfo)
{
    (*cinfo->err->output_message) (cinfo);    
    longjmp(gReadJpgJmpbuf, 1);
}
#endif

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
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;
    if (setjmp(gReadJpgJmpbuf))
    {
        ILOG_ERROR("setjmp");
        jpeg_destroy_decompress(&cinfo);
        return;
    }
    jpeg_create_decompress(&cinfo);
    jpeg_memory_src(&cinfo, (const JOCTET *)buf, bufsize);
    jpeg_read_header(&cinfo, TRUE);
    jpeg_start_decompress(&cinfo);

    if (cinfo.output_components == 4)
    {
        ILOG_ERROR("CMYK images not supported");
        jpeg_abort_decompress(&cinfo);
        jpeg_destroy_decompress(&cinfo);
        return;
    }

    int width = cinfo.output_width;
    int height = cinfo.output_height;
    int row_stride = cinfo.output_width * cinfo.output_components;
    JSAMPARRAY jpgdata = 
        (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE,
                                    row_stride, 1);
    //int nPix = width * height;
    bool gray = (cinfo.output_components == 1) ? true : false;
    if (dst == 0)
        dst = ArrayCreate<ArrayT>(width, height);

    UInt8* dataPtr;
    while (cinfo.output_scanline < cinfo.output_height)
    {
        dataPtr = dst->CPB(0, cinfo.output_scanline);
        int nrRead = jpeg_read_scanlines(&cinfo, &dataPtr, 1);
        if (nrRead != 1)
            ILOG_ERROR("jpeg_read_scanlines couldn't read line");
        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--;
            }
        }
    }

    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, int memBufSize = 10000000)
{
    ILOG_VAR(Impala.Core.Array.ReadJpg);
    char* buf = new char[memBufSize];
    size_t nrRead = buffer->Read(buf, memBufSize);
    if (nrRead >= memBufSize)
    {
        ILOG_ERROR("Buffer to small");
        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,
        int memBufSize = 10000000)
{
    Util::IOBuffer* buf = db->GetIOBuffer(fileName, true, false, "");
    if (buf)
    {
        ReadJpg(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
ReadJpg(ArrayT*& dst, Persistency::File file, int memBufSize = 10000000)
{
    Util::IOBuffer* buf = file.GetReadBuffer();
    if (buf)
    {
        ReadJpg(dst, buf, memBufSize);
        delete buf;
    }
}

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

#endif

---