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

---

WriteJpg.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_WriteJpg_h
#define Impala_Core_Array_WriteJpg_h

#include "Core/Array/Arrays.h"
#include "Persistency/File.h"
#ifdef JPG_USED
#include "Link/Jpeg/CxJpegLink.h"
#endif

namespace Impala
{
namespace Core
{
namespace Array
{


static int gWriteJpgQuality = 90;

#ifdef JPG_USED
static jmp_buf gWriteJpgJmpbuf;

static inline void 
errorFuncWriteJpg(j_common_ptr cinfo)
{
    (*cinfo->err->output_message) (cinfo);
//    std::cerr << "Jpeg Error: " << msg << std::endl;
    longjmp(gWriteJpgJmpbuf, 1);
}


template <class ArrayT>
inline bool
WriteJpgToMemory(ArrayT* src, char* buf, size_t memBufSize, size_t* outSize)
{
    ILOG_VAR(Impala.Core.Array.WriteJpg);
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr pub;
    cinfo.err = jpeg_std_error(&pub);
    pub.error_exit = errorFuncWriteJpg;
    if (setjmp(gWriteJpgJmpbuf))
    {
        ILOG_ERROR("setjmp");
        jpeg_destroy_compress(&cinfo);
        return false;
    }
    jpeg_create_compress(&cinfo);
    jpeg_memory_dest(&cinfo, &buf, outSize);

    int elemSize = ArrayT::ElemSize();
    if (elemSize == 1)
    {
        cinfo.input_components = 1;
        cinfo.in_color_space = JCS_GRAYSCALE;
    }
    else if (elemSize == 3)
    {
        cinfo.input_components = 3;
        cinfo.in_color_space = JCS_RGB;
    }

    cinfo.image_width = src->CW();
    cinfo.image_height = src->CH();

    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, gWriteJpgQuality,
                     TRUE/* limit to baseline-JPEG values */);

    jpeg_start_compress(&cinfo, TRUE);
    JSAMPROW row_pointer[1];
    while (cinfo.next_scanline < cinfo.image_height)
    {
        row_pointer[0] = src->CPB(0, cinfo.next_scanline);
        jpeg_write_scanlines(&cinfo, row_pointer, 1);
    }

    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);
    return true;
}

#else

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

#endif // JPG_USED

template <class ArrayT>
inline bool
WriteJpg(ArrayT* src, Util::IOBuffer* buffer, size_t memBufSize = 10000000)
{
    char* buf = new char[memBufSize];
    size_t outSize;
    if (!WriteJpgToMemory(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
WriteJpg(ArrayT* src, String fileName, Util::Database* db,
         size_t memBufSize = 10000000)
{
    Util::IOBuffer* buf = db->GetIOBuffer(fileName, false, false, "tmp");
    if (!buf)
        return false;
    bool res = WriteJpg(src, buf, memBufSize);
    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
WriteJpg(ArrayT* src, Persistency::File file, size_t memBufSize = 10000000)
{
    Util::IOBuffer* buf = file.GetWriteBuffer();
    if (!buf)
        return false;
    bool res = WriteJpg(src, buf, memBufSize);
    delete buf;
    return res;
}

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

#endif

---