jpeg_conversion.hpp

Go to the documentation of this file.

/*
 * \file    jpeg_conversion.hpp
 *  
 * \brief   Jpeg-frame conversion using the IJG library.
 *
 * \details Converts MODE_JPEG to MODE_GRAYSCALE, MODE_RGB or MODE_BGR and vice versa.
 *          
 *          German Research Center for Artificial Intelligence\n
 *          Project: Rimres
 *
 * \date    07.12.11
 *
 * \author  Stefan.Haase@dfki.de
 */

#ifndef _JPEG_CONVERSION_H_
#define _JPEG_CONVERSION_H_

#include <iostream>
#include <exception>
#include <stdexcept>
#include <string>

#include "jpeglib.h"

#include <base/samples/Frame.hpp>

#include <base-logging/Logging.hpp>

namespace conversion {

class JpegConversion {

 public: // STATICs
    const static int JPEG_QUALITY = 80;

 public:
    JpegConversion() : mBuffer(NULL), mBufferSize(0), mFlipBuffer(NULL), mFlipBufferSize(0),
            mJpegQuality(JPEG_QUALITY) { 
    }

    JpegConversion(unsigned int jpeg_quality) : mBuffer(NULL), mBufferSize(0), 
            mFlipBuffer(NULL), mFlipBufferSize(0), mJpegQuality(jpeg_quality){
        if(mJpegQuality > 100)
            mJpegQuality = 100;
    }

    ~JpegConversion() {
        if(mBuffer != NULL) {
            delete mBuffer;
            mBuffer = NULL;
        }
    }

    void compress(base::samples::frame::Frame const& frame_input, base::samples::frame::Frame& frame_output);

    void decompress(base::samples::frame::Frame const& frame_input, 
            base::samples::frame::frame_mode_t const decompress_to,
             base::samples::frame::Frame& frame_output);

    void decompress(uint8_t const* src, 
            size_t src_size,
            int width, 
            int height,
            base::samples::frame::frame_mode_t const decompress_to,  
            uint8_t* dst);

    J_COLOR_SPACE getJpegColorspace(base::samples::frame::frame_mode_t const frame_mode, 
            bool& flip_rgb, bool& is_jpeg);

    bool storeFrame(std::string filename, base::samples::frame::Frame const& frame,
            std::string* used_filename=NULL);

    bool loadJpeg(std::string const& filename, uint32_t const width, uint32_t const height,
            base::samples::frame::Frame& frame);

 private:
    void switchRB(uint32_t const img_size, uint8_t const* input_img, 
            uint8_t* output_img);

    void switchRB(uint32_t const img_size, uint8_t* input_img);

 private: // REQUIRED jpeg methods.
    // COMPRESS
    static void init_buffer(jpeg_compress_struct* cinfo) {}
     
    static boolean empty_buffer(jpeg_compress_struct* cinfo) {
            return TRUE;
    }

    static void term_buffer(jpeg_compress_struct* cinfo) {}

    // DECOMPRESS
    static void my_init_source(jpeg_decompress_struct* cinfo) {
        LOG_DEBUG("jpeg my_init_source()");
    }
    static boolean my_fill_input_buffer(jpeg_decompress_struct* cinfo) {
        LOG_DEBUG("jpeg my_fill_input_buffer");
        return true;
    }
    static void my_skip_input_data(jpeg_decompress_struct* cinfo, long num_bytes) {
        LOG_DEBUG("jpeg my_skip_input_data");
    }
    static boolean my_resync_to_restart(jpeg_decompress_struct* cinfo, int desired) {
        LOG_DEBUG("jpeg my_resync_to_restart");
        return true;
    }
    static void my_term_source(jpeg_decompress_struct* cinfo) {
        LOG_DEBUG("jpeg my_term_source");
    }

 private:
    unsigned char* mBuffer;
    unsigned int mBufferSize;

    unsigned char* mFlipBuffer; // Used to convert BGR to RGB.
    unsigned int mFlipBufferSize;

    int mJpegQuality;
};
} // end namespace conversion
#endif