CompressJpeg.hh

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef __JPEGHANDLER_HH__
#define __JPEGHANDLER_HH__

// Include I/O handling and streams
#include <stdio.h>
#include <sstream>
#include <string.h>

// Include BIAS image handling
#include <Base/Image/ImageIO.hh>
#include <Base/Image/ImageConvert.hh>

namespace BIAS {

  /**
     @class JpegHandler

     @brief Wrapper for fast libjpeg methods

     Class for memory-to-memory JPEG compression. Compress a given BIAS::Image
     (unsigned char) to data array in shared memory or decompress a given JPEG
     file located in user memory into a BIAS::Image (unsigned char).

     @author Arne Petersen
     @date  15/08/2005
  */
  class BIASImageBase_EXPORT JpegHandler
  {
  public:

    /** @brief Constructor with empty internal buffer */
    JpegHandler();

    /** @brief Constructor with initialized internal buffer */
    JpegHandler(long size);

    /** @brief Destructor releases internal buffer */
    virtual ~JpegHandler();

    /**
       @brief Initialize object with standard values and limit shared
              memory area to given size (in byte, default is 10 MByte).
              Re-initialization is only required for changing buffer size.
       @attention Initialize buffer before first use!
       @return Returns < 0 in case of errors, 0 otherwise.
    */
    int Init(long size = 10485760);

    /**
       @brief Returns if an internal buffer has been initialized.
    */
    bool IsInitialized() { return data_ != NULL; }

    /**
       @brief Releases allocated memory. Use it to regain memory but call
              Init() again bevor using object afterwards!
    */
    void Release();

    /**
       @brief Start compression for given BIAS::Image into buffer.
       @return Returns < 0 in case of errors, 0 otherwise.
    */
    int Compress(BIAS::Image<unsigned char> &srcImg, int quality = 60);

    /**
       @brief Start compression for given image data from buffer.
       @return Returns < 0 in case of errors, 0 otherwise.
    */
    int Compress(unsigned int width, unsigned int height, unsigned int channels,
                 unsigned char* data, int quality = 60);

    /**
       @brief Start decompression of previously given data (from ReadJPEG() or
              SetCompressedData()), results will be stored in destination image.
              Decompress() will initialize destination image properly if needed.
       @return Returns < 0 in case of errors, 0 otherwise.
    */
    int Decompress(BIAS::Image<unsigned char> &destImg, bool readComment = false);

    /**
       @brief Start decompression of previously given data (from ReadJPEG() or
              SetCompressedData()), results will be stored in data, width, ...
              New memory for data will only be allocated if data == NULL, else
              old allocated memory will be used, so set data = NULL if you're
              not sure about it's size!
       @return Returns < 0 in case of errors, 0 otherwise.
    */
    int Decompress(unsigned int &width, unsigned int &height,
                   unsigned int &channels, unsigned char* &data);

    /**
       @brief Start compression for given image data to given output buffer.
              The internal buffer is not used here, hence it is allowed to be
              uninitialized.
       @return Returns < 0 in case of errors, 0 otherwise.
    */
    int Compress(unsigned int width, unsigned int height, unsigned int channels,
                 unsigned char* inData, unsigned char *outData, long &outBytes,
                 int quality = 60);

    /**
       @brief Start decompression of given data and write result to given output
              buffer. The internal buffer is not used here, hence it is allowed
              to be uninitialized.
       @return Returns < 0 in case of errors, 0 otherwise.
    */
    int Decompress(unsigned int &width, unsigned int &height, unsigned int &channels,
                   unsigned char* inData, long inBytes, unsigned char* outData);

    /**
       @brief Get pointer to memory where to find compressed data and
              its length in byte.
       @attention No copy will be used, so make sure it's still valid when
                  starting Decompress() or reusing this!
    */
    inline void GetCompressedData(void* &data, long &length) {
      data = data_;
      length = dataLength_;
    }

    /**
       @brief Return compressed data length in bytes.
     */
    inline long GetCompressedDataSize() { return dataLength_; }

    /**
       @brief Copy memory area in which compressed data can be found
              and set its length in byte.
    */
    inline void SetCompressedData(void* data, long length) {
      dataLength_ = length;
      memcpy(data_, data, dataLength_);
    }

    /**
       @brief Write previously compressed data to file named filename.
       @return Returns < 0 in case of errors, 0 otherwise.
    */
    int WriteJPEG(const std::string &filename);

    /**
       @brief Read JPEG file named filename and store its informations in
              compressed data field.
       @return Returns < 0 in case of errors, 0 otherwise.
    */
    int ReadJPEG(const std::string &filename);

    /**
       @brief Print error messages to standard output or keep quiet?
    */
    void SetVerbose(const bool verbose) { verbose_ = verbose; }

  protected:

    /** @brief Pointer to compression buffer (compressed data) */
    void* data_;

    /** @brief Length in byte of compressed data */
    long dataLength_;

    /** @brief Length in byte of compression buffer (max. data size) */
    long bufferSize_;

    /** @brief Print error messages or keep quiet? */
    bool verbose_;

  };

}

#endif //__JPEGHANDLER_HH__