CompressJpeg.cpp

/*
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
*/

#ifdef WIN32
#  include <windows.h>
#  ifdef BIAS_HAVE_WXWIDGETS
#    include <wx/msw/winundef.h>
#  endif
#endif
#include "CompressJpeg.hh"
#include <Base/Image/MetaData.hh>

/*
 * Include file for users of JPEG library.
 * You will need to have included system headers that define at least
 * the typedefs FILE and size_t before you can include jpeglib.h.
 * (stdio.h is sufficient on ANSI-conforming systems.)
 * You may also wish to include "jerror.h".
 */

#ifdef WIN32
// undef backward compatibility define - not needed
#  undef FAR
#endif

extern "C" {
#include "jpeglib.h"
}

#ifdef WIN32
//Disable warning for setjmp can't interact with C++ Dtors, which is not
//the case here (no Dtors interact with setjmp)
#pragma warning(disable:4611)
//disable padding warng (structure padding unknown)
#pragma warning(disable:4324)
#endif /* WIN32 */

/*
 * <setjmp.h> is used for the optional error recovery mechanism shown in
 * the second part of the example.
 */

#include <setjmp.h>

/*
 * include memory-system-funcs
 */
#ifdef WIN32 
#include <io.h>
#else
#include <sys/mman.h>
#endif
#include <fcntl.h>
#include <sys/types.h>

/*
 * global vars for jpeg-library
 */
extern "C" {
  JSAMPLE * image_buffer;    /* Points to large array of R,G,B-order data */
  int image_height;          /* Number of rows in image */
  int image_width;           /* Number of columns in image */
  int image_channels;        /* Number of channels in image */
}

using namespace std;
using namespace BIAS;

/** \cond HIDDEN_SYMBOLS
 * Some stuff for decompressor-method
 */
struct my_error_mgr {
  struct jpeg_error_mgr pub;    /* "public" fields */
  jmp_buf setjmp_buffer;    /* for return to caller */
};

typedef struct my_error_mgr * my_error_ptr;
/** \endcond */

/*
 * Here are routines that will replace the standard error_exit method:
 */
METHODDEF(void)
my_error_exit (j_common_ptr cinfo)
{
  /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
  my_error_ptr myerr = (my_error_ptr) cinfo->err;

  /* Always display the message. */
  /* We could postpone this until after returning, if we chose. */
  (*cinfo->err->output_message) (cinfo);

  /* Return control to the setjmp point */
  longjmp(myerr->setjmp_buffer, 1);
}

METHODDEF(void)
silent_error_exit (j_common_ptr cinfo)
{
  /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
  my_error_ptr myerr = (my_error_ptr) cinfo->err;

  /* Return control to the setjmp point */
  longjmp(myerr->setjmp_buffer, 1);
}

/**
   Routines for source (data array) managing
*/
METHODDEF(void)
init_source (j_decompress_ptr /*cinfo*/)
{
  /* no work necessary here */
}

METHODDEF(boolean)
fill_input_buffer (j_decompress_ptr cinfo)
{
  static JOCTET dummy[] = { (JOCTET) 0xFF, (JOCTET) JPEG_EOI };

  // WARNMS(cinfo, JWRN_JPEG_EOF);

  /* Insert a fake EOI marker */

  cinfo->src->next_input_byte = dummy;
  cinfo->src->bytes_in_buffer = 2;

  return TRUE;
}

METHODDEF(void)
skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
  if (num_bytes > 0) {
    while (num_bytes > (long) cinfo->src->bytes_in_buffer) {
      num_bytes -= (long) cinfo->src->bytes_in_buffer;
      (void) fill_input_buffer(cinfo);
    }
    cinfo->src->next_input_byte += (size_t) num_bytes;
    cinfo->src->bytes_in_buffer -= (size_t) num_bytes;
  }

}

METHODDEF(void)
term_source (j_decompress_ptr /* cinfo*/)
{
  /* no work necessary here */
} 

/**
   Routines for destination (data array) managing
*/
METHODDEF(void)
init_destination (j_compress_ptr /*cinfo*/)
{ /* initialize destination */
  /* no work necessary here (buffer = data) */
}

METHODDEF(boolean)
empty_output_buffer (j_compress_ptr cinfo)
{
  BIASERR("JPEG-buffer is too small!!!");
  cinfo->dest->next_output_byte = NULL;
  cinfo->dest->free_in_buffer = 0;
  return true;
} 

METHODDEF(void)
term_destination (j_compress_ptr /*cinfo*/)
{
  /* no work necessary here */
} 

/**
   Routine for using libjpeg compression-methods 
   (borrowed from libjpeg-example, with litle changes)
*/
int create_JPEG_file (void * outfile, long length, int quality)
{
  /* This struct contains the JPEG compression parameters and pointers to
   * working space (which is allocated as needed by the JPEG library).
   * It is possible to have several such structures, representing multiple
   * compression/decompression processes, in existence at once.  We refer
   * to any one struct (and its associated working data) as a "JPEG object".
   */
  struct jpeg_compress_struct cinfo;
  /* This struct represents a JPEG error handler.  It is declared separately
   * because applications often want to supply a specialized error handler
   * (see the second half of this file for an example).  But here we just
   * take the easy way out and use the standard error handler, which will
   * print a message on stderr and call exit() if compression fails.
   * Note that this struct must live as long as the main JPEG parameter
   * struct, to avoid dangling-pointer problems.
   */
  struct jpeg_error_mgr jerr;
  struct jpeg_destination_mgr jdest;
  /* More stuff */
  JSAMPROW row_pointer[1];  /* pointer to JSAMPLE row[s] */
  int row_stride;       /* physical row width in image buffer */

  /* Step 1: allocate and initialize JPEG compression object */

  /* We have to set up the error handler first, in case the initialization
   * step fails.  (Unlikely, but it could happen if you are out of memory.)
   * This routine fills in the contents of struct jerr, and returns jerr's
   * address which we place into the link field in cinfo.
   */
  cinfo.err = jpeg_std_error(&jerr);
  /* Now we can initialize the JPEG compression object. */
  jpeg_create_compress(&cinfo);

  /* Step 2: specify data destination (eg, a file) */
  /* Note: steps 2 and 3 can be done in either order. */

  /* Here we use the library-supplied code to send compressed data to a
   * stdio stream.  You can also write your own code to do something else.
   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
   * requires it in order to write binary files.
   */
  //no more files
  //   if (outfile == NULL) {
  //     fprintf(stderr, "can't open \n");
  //     return -1;
  //   }
  //   jpeg_stdio_dest(&cinfo, outfile);
  //init destination mgr
  cinfo.dest = &jdest;
  jdest.init_destination = init_destination;
  jdest.empty_output_buffer = empty_output_buffer;
  jdest.term_destination = term_destination;
  jdest.free_in_buffer = length;
  jdest.next_output_byte = (JOCTET *) outfile; 

  /* Step 3: set parameters for compression */

  /* First we supply a description of the input image.
   * Four fields of the cinfo struct must be filled in:
   */
  cinfo.image_width = image_width;  /* image width and height, in pixels */
  cinfo.image_height = image_height;
  cinfo.input_components = image_channels;/* # of color components per pixel */
  if (image_channels == 1) {
    cinfo.in_color_space = JCS_GRAYSCALE;   /* colorspace of input image */
  } else if (image_channels == 3) {
    cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
  } else {
    BIASERR("Compression not implemented for images with channels != 1,3");
    return -1;
  }
  /* Now use the library's routine to set default compression parameters.
   * (You must set at least cinfo.in_color_space before calling this,
   * since the defaults depend on the source color space.)
   */
  jpeg_set_defaults(&cinfo);
  /* Now you can set any non-default parameters you wish to.
   * Here we just illustrate the use of quality (quantization table) scaling:
   */
  jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);

  /* Step 4: Start compressor */

  /* TRUE ensures that we will write a complete interchange-JPEG file.
   * Pass TRUE unless you are very sure of what you're doing.
   */
  jpeg_start_compress(&cinfo, TRUE);

  /* Step 5: while (scan lines remain to be written) */
  /*           jpeg_write_scanlines(...); */

  /* Here we use the library's state variable cinfo.next_scanline as the
   * loop counter, so that we don't have to keep track ourselves.
   * To keep things simple, we pass one scanline per call; you can pass
   * more if you wish, though.
   */
  row_stride = image_width * image_channels;/*SAMPLEs per row in image_buffer*/

  while (cinfo.next_scanline < cinfo.image_height) {
    /* jpeg_write_scanlines expects an array of pointers to scanlines.
     * Here the array is only one element long, but you could pass
     * more than one scanline at a time if that's more convenient.
     */
    row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride];
    (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
  }

  /* Step 6: Finish compression */

  jpeg_finish_compress(&cinfo);

  int res = int(length - cinfo.dest->free_in_buffer);
  /* After finish_compress, we can close the output file. */
  // fclose(outfile); NOT closed -> needed for next cicle and filelength

  /* Step 7: release JPEG compression object */

  /* This is an important step since it will release a good deal of memory. */
  jpeg_destroy_compress(&cinfo);

  /* And we're done! */
  return res;
}


int deflate_JPEG_file (void * infile, long length,
                       BIAS::Image<unsigned char> &destImg,
                       bool readComment, bool verbose = true)
{
  /* This struct contains the JPEG decompression parameters and pointers to
   * working space (which is allocated as needed by the JPEG library).
   */
  struct jpeg_decompress_struct cinfo;
  /* We use our protected extension JPEG error handler.
   * Note that this struct must live as long as the main JPEG parameter
   * struct, to avoid dangling-pointer problems.
   */
  struct my_error_mgr jerr;
  //hanlder for datasource
  struct jpeg_source_mgr jsrc; 
  /* More stuff */
  JSAMPARRAY buffer;        /* Output row buffer */
  int row_stride;       /* physical row width in output buffer */

  /* In this example we want to open the input file before doing anything else,
   * so that the setjmp() error recovery below can assume the file is open.
   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
   * requires it in order to read binary files.
   */

  if (infile == NULL) {
    BIASERR("No source JPEG given!");
    return -1;
  }

  /* Step 1: allocate and initialize JPEG decompression object */

  /* We set up the normal JPEG error routines, then override error_exit. */
  cinfo.err = jpeg_std_error(&jerr.pub);
  if (verbose) {
    jerr.pub.error_exit = my_error_exit;
  } else {
    jerr.pub.error_exit = silent_error_exit;
  }
  /* Establish the setjmp return context for my_error_exit to use. */
  if (setjmp(jerr.setjmp_buffer)) {
    /* If we get here, the JPEG code has signaled an error.
     * We need to clean up the JPEG object, close the input file, and return.
     */
    jpeg_destroy_decompress(&cinfo);
    return -1;
  }
  /* Now we can initialize the JPEG decompression object. */
  jpeg_create_decompress(&cinfo);

  /* Step 2: specify data source (eg, a file) */

  // No longer from file
  //  jpeg_stdio_src(&cinfo, infile);
  if (length == 0) {
    /* Treat empty input data as fatal error */
    jpeg_destroy_decompress(&cinfo);
    return -1;
  }
  //set function pointers for source-mgr
  cinfo.src = &jsrc;
  jsrc.init_source = init_source;
  jsrc.fill_input_buffer = fill_input_buffer;
  jsrc.skip_input_data = skip_input_data;
  jsrc.resync_to_restart = jpeg_resync_to_restart; /* use default method */
  jsrc.term_source = term_source;
  jsrc.bytes_in_buffer = length;
  jsrc.next_input_byte = (JOCTET *) infile; 

  // Enable reading comment metadata during decompression (opt.)
  if (readComment) {
    jpeg_save_markers(&cinfo, JPEG_COM, 0xFFFF);
  }

  /* Step 3: read file parameters with jpeg_read_header() */

  (void) jpeg_read_header(&cinfo, TRUE);
  /* We can ignore the return value from jpeg_read_header since
   *   (a) suspension is not possible with the stdio data source, and
   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
   * See libjpeg.doc for more info.
   */

  // Read comment metadata from JPEG image (opt.)
  std::string comment("");
  if (readComment) {
    jpeg_marker_struct* marker_ptr = cinfo.marker_list;
    while (marker_ptr) {
      if (marker_ptr->marker == JPEG_COM) {
        unsigned char *c_ptr = marker_ptr->data;
        unsigned int c_len = marker_ptr->data_length;
        comment += std::string((char*)c_ptr, c_len);
      }
      marker_ptr = marker_ptr->next;
    }
  }

  /* Step 4: set parameters for decompression */

  /* In this example, we don't need to change any of the defaults set by
   * jpeg_read_header(), so we do nothing here.
   */

  /* Step 5: Start decompressor */

  (void) jpeg_start_decompress(&cinfo);
  /* We can ignore the return value since suspension is not possible
   * with the stdio data source.
   */

  /* We may need to do some setup of our own at this point before reading
   * the data.  After jpeg_start_decompress() we have the correct scaled
   * output image dimensions available, as well as the output colormap
   * if we asked for color quantization.
   * In this example, we need to make an output work buffer of the right size.
   */
  if (destImg.IsEmpty()) {
    destImg.Init(cinfo.output_width, cinfo.output_height,
                 cinfo.output_components);
  }
  //#ifdef BIAS_DEBUG
  if ((destImg.GetWidth() != (unsigned int) cinfo.output_width)||
      (destImg.GetHeight() != (unsigned int) cinfo.output_height)||
      (destImg.GetChannelCount() != (unsigned int) cinfo.output_components)) {
    BIASWARN("Given image has wrong format (height, width, ...) but is now initialized correctly!");
    destImg.Release();
    destImg.Init(cinfo.output_width, cinfo.output_height,
                 cinfo.output_components);
  }
  //#endif //BIAS_DEBUG

  unsigned char** img_data = destImg.GetImageDataArray();
  /* JSAMPLEs per row in output buffer */
  row_stride = cinfo.output_width * cinfo.output_components;
  /* Make a one-row-high sample array that will go away when done with image */
  buffer = (*cinfo.mem->alloc_sarray)
    ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); 


  /* Step 6: while (scan lines remain to be read) */
  /*           jpeg_read_scanlines(...); */

  /* Here we use the library's state variable cinfo.output_scanline as the
   * loop counter, so that we don't have to keep track ourselves.
   */
  while (cinfo.output_scanline < cinfo.output_height) {
    /* jpeg_read_scanlines expects an array of pointers to scanlines.
     * Here the array is only one element long, but you could ask for
     * more than one scanline at a time if that's more convenient.
     */
    (void) jpeg_read_scanlines(&cinfo, buffer, 1);
    /* Assume put_scanline_someplace wants a pointer and sample count. 
       canceld for use directly with img_data
       put_scanline_someplace(buffer[0], row_stride);
    */
    memcpy(img_data[cinfo.output_scanline-1],buffer[0],row_stride);
  }

  /* Step 7: Finish decompression */

  (void) jpeg_finish_decompress(&cinfo);
  /* We can ignore the return value since suspension is not possible
   * with the stdio data source.
   */

  /* Step 8: Release JPEG decompression object */

  /* This is an important step since it will release a good deal of memory. */
  jpeg_destroy_decompress(&cinfo);

  /* After finish_decompress, we can close the input file.
   * Here we postpone it until after no more JPEG errors are possible,
   * so as to simplify the setjmp error logic above.  (Actually, I don't
   * think that jpeg_destroy can do an error exit, but why assume anything...)
   */
  // will be done outside fclose(infile);

  /* At this point you may want to check to see whether any corrupt-data
   * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
   */

  // Add metadata to destination image (opt.)
  if (readComment && comment != "") {
    BIAS::MetaData metadata;
    metadata.Add("#[Comment]", comment);
    destImg.SetMetaData(metadata);
  }

  /* And we're done! */
  return 0;
}

int deflate_JPEG_file (void * infile, long length, unsigned int &width,
                       unsigned int &height, unsigned int &channels, 
                       unsigned char* &data, bool verbose = true)
{
  /* This struct contains the JPEG decompression parameters and pointers to
   * working space (which is allocated as needed by the JPEG library).
   */
  struct jpeg_decompress_struct cinfo;
  /* We use our protected extension JPEG error handler.
   * Note that this struct must live as long as the main JPEG parameter
   * struct, to avoid dangling-pointer problems.
   */
  struct my_error_mgr jerr;
  //hanlder for datasource
  struct jpeg_source_mgr jsrc; 
  /* More stuff */
  JSAMPARRAY buffer;        /* Output row buffer */
  int row_stride;       /* physical row width in output buffer */

  /* In this example we want to open the input file before doing anything else,
   * so that the setjmp() error recovery below can assume the file is open.
   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
   * requires it in order to read binary files.
   */

  if (infile == NULL) {
    BIASERR("No source JPEG given!!!");
    return -1;
  }

  /* Step 1: allocate and initialize JPEG decompression object */

  /* We set up the normal JPEG error routines, then override error_exit. */
  cinfo.err = jpeg_std_error(&jerr.pub);
  if (verbose) {
    jerr.pub.error_exit = my_error_exit;
  } else {
    jerr.pub.error_exit = silent_error_exit;
  }
  /* Establish the setjmp return context for my_error_exit to use. */
  if (setjmp(jerr.setjmp_buffer)) {
    /* If we get here, the JPEG code has signaled an error.
     * We need to clean up the JPEG object, close the input file, and return.
     */
    jpeg_destroy_decompress(&cinfo);
    return -1;
  }
  /* Now we can initialize the JPEG decompression object. */
  jpeg_create_decompress(&cinfo);

  /* Step 2: specify data source (eg, a file) */

  // No longer from file
  //  jpeg_stdio_src(&cinfo, infile);
  if (length == 0) {
    /* Treat empty input data as fatal error */
    jpeg_destroy_decompress(&cinfo);
    return -1;
  }
  //set function pointers for source-mgr
  cinfo.src = &jsrc;
  jsrc.init_source = init_source;
  jsrc.fill_input_buffer = fill_input_buffer;
  jsrc.skip_input_data = skip_input_data;
  jsrc.resync_to_restart = jpeg_resync_to_restart; /* use default method */
  jsrc.term_source = term_source;
  jsrc.bytes_in_buffer = length;
  jsrc.next_input_byte = (JOCTET *) infile; 

  /* Step 3: read file parameters with jpeg_read_header() */

  (void) jpeg_read_header(&cinfo, TRUE);
  /* We can ignore the return value from jpeg_read_header since
   *   (a) suspension is not possible with the stdio data source, and
   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
   * See libjpeg.doc for more info.
   */

  /* Step 4: set parameters for decompression */

  /* In this example, we don't need to change any of the defaults set by
   * jpeg_read_header(), so we do nothing here.
   */

  /* Step 5: Start decompressor */

  (void) jpeg_start_decompress(&cinfo);
  /* We can ignore the return value since suspension is not possible
   * with the stdio data source.
   */

  /* We may need to do some setup of our own at this point before reading
   * the data.  After jpeg_start_decompress() we have the correct scaled
   * output image dimensions available, as well as the output colormap
   * if we asked for color quantization.
   * In this example, we need to make an output work buffer of the right size.
   */
  width = cinfo.output_width;
  height = cinfo.output_height;
  channels = cinfo.output_components;

  if (data == NULL) {
    BIASWARN("Allocating " << width * height * channels << " bytes of mem for"
             << " returned datafield!!!\n");
    data = new unsigned char[width * height * channels];
  }

  /* JSAMPLEs per row in output buffer */
  row_stride = cinfo.output_width * cinfo.output_components;
  /* Make a one-row-high sample array that will go away when done with image */
  buffer = (*cinfo.mem->alloc_sarray)
    ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);

  /* Step 6: while (scan lines remain to be read) */
  /*           jpeg_read_scanlines(...); */

  /* Here we use the library's state variable cinfo.output_scanline as the
   * loop counter, so that we don't have to keep track ourselves.
   */
  while (cinfo.output_scanline < cinfo.output_height) {
    /* jpeg_read_scanlines expects an array of pointers to scanlines.
     * Here the array is only one element long, but you could ask for
     * more than one scanline at a time if that's more convenient.
     */
    (void) jpeg_read_scanlines(&cinfo, buffer, 1);
    /* Assume put_scanline_someplace wants a pointer and sample count. 
       canceld for use directly with img_data
       put_scanline_someplace(buffer[0], row_stride);
    */
    memcpy(data + (cinfo.output_scanline-1)*width*channels, buffer[0], row_stride);
  }

  /* Step 7: Finish decompression */

  (void) jpeg_finish_decompress(&cinfo);
  /* We can ignore the return value since suspension is not possible
   * with the stdio data source.
   */

  /* Step 8: Release JPEG decompression object */

  /* This is an important step since it will release a good deal of memory. */
  jpeg_destroy_decompress(&cinfo);

  /* After finish_decompress, we can close the input file.
   * Here we postpone it until after no more JPEG errors are possible,
   * so as to simplify the setjmp error logic above.  (Actually, I don't
   * think that jpeg_destroy can do an error exit, but why assume anything...)
   */
  // will be done outside fclose(infile);

  /* At this point you may want to check to see whether any corrupt-data
   * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
   */

  /* And we're done! */
  return 0;
}


JpegHandler::JpegHandler()
{
  data_ = NULL;
  dataLength_ = 0;
  bufferSize_ = 0;
  verbose_ = false;
}

JpegHandler::JpegHandler(long size)
{
  data_ = NULL;
  dataLength_ = 0;
  bufferSize_ = 0;
  verbose_ = false;
  Init(size);
}

JpegHandler::~JpegHandler()
{
  Release();
}

int JpegHandler::Init(long size)
{
  Release();

  // create buffer
  data_ = (void *) new unsigned char[size];

  if (data_ == NULL) {
    BIASERR("Could not create buffer!");
    return -1;
  } else {
    bufferSize_ = size;
    return 0;
  }
}

void JpegHandler::Release()
{
  if (data_ != NULL) {
    delete[] ((unsigned char *) data_);
  }
  data_ = NULL;
  bufferSize_ = 0;
}

int JpegHandler::
Compress(BIAS::Image<unsigned char> &srcImg, int quality)
{
  if (!data_) {
    BIASERR("Data buffer has not been set up. Call Init() first!");
    return -1;
  }

  image_height = srcImg.GetHeight();
  image_width = srcImg.GetWidth();
  image_channels = srcImg.GetChannelCount();
  image_buffer = srcImg.GetImageData();

  dataLength_ = create_JPEG_file(data_, bufferSize_, quality);

  if (dataLength_ < 0) {
    BIASERR("Error crunching JPEG image!");
    dataLength_ = 0;
    return -1;
  }

  return 0;
}

int JpegHandler::
Compress(unsigned int width, unsigned int height, unsigned int channels,
         unsigned char* data, int quality)
{
  if (!data_) {
    BIASERR("Data buffer has not been set up. Call Init() first!");
    return -1;
  }

  image_height = height;
  image_width = width;
  image_channels = channels;
  image_buffer = data;

  dataLength_ = create_JPEG_file(data_, bufferSize_, quality);

  if (dataLength_ < 0) {
    BIASERR("Error crunching JPEG image!");
    dataLength_ = 0;
    return -1;
  }

  return 0;
}

int JpegHandler::
Decompress(BIAS::Image<unsigned char> &destImg, bool readComment)
{
  if (!data_) {
    BIASERR("Data buffer has not been set up. Call Init() first!");
    return -1;
  }

  return deflate_JPEG_file(data_, dataLength_, destImg, readComment, verbose_);
}

int JpegHandler::
Decompress(unsigned int &width, unsigned int &height,
           unsigned int &channels, unsigned char* &data) 
{
  if (!data_) {
    BIASERR("Data buffer has not been set up. Call Init() first!");
    return -1;
  }

  return deflate_JPEG_file(data_, dataLength_, width, height,
                           channels, data, verbose_);
}

int JpegHandler::
Compress(unsigned int width, unsigned int height, unsigned int channels,
         unsigned char* inData, unsigned char *outData, long &outBytes,
         int quality)
{
  image_height = height;
  image_width = width;
  image_channels = channels;
  image_buffer = inData;

  outBytes = create_JPEG_file(outData, width * height * channels, quality);

  if (outBytes < 0) {
    BIASERR("Error crunching JPEG image!");
    outBytes = 0;
    return -1;
  }
  return 0;
}

int JpegHandler::
Decompress(unsigned int &width, unsigned int &height, unsigned int &channels,
           unsigned char* inData, long inBytes, unsigned char* outData)
{
  return deflate_JPEG_file(inData, inBytes, width, height, channels, outData, verbose_);
}

int JpegHandler::WriteJPEG(const string &filename) {

  if (!data_) {
    BIASERR("Data buffer has not been set up. Call Init() first!");
    return -1;
  }

#ifdef WIN32
  FILE * output;
  fopen_s(&output, filename.c_str(), "wb");
#else
  FILE * output = fopen(filename.c_str(), "wb");
#endif

  if (output == NULL) {
    BIASERR("Could not open output file" << filename << "!");
    return -1;
  }

  if (long(fwrite(data_,  1,  dataLength_,  output)) != dataLength_) {
    BIASERR("Could not write data to file " << filename << " completely!");
    return -1;
  }

  fclose (output);

  return 0;
}

int JpegHandler::ReadJPEG(const string &filename) {

  if (!data_) {
    BIASERR("Data buffer has not been set up. Call Init() first!");
    return -1;
  }

#ifdef WIN32
  FILE * input;
  fopen_s(&input, filename.c_str(), "rb");
#else
  FILE * input = fopen(filename.c_str(), "rb");
#endif

  if (input == NULL) {
    BIASERR("Could not read file " << filename << "!");
    return -1;
  }

  dataLength_ = 0;
  fseek(input, 0L, SEEK_END);
  dataLength_ = ftell(input);
  rewind(input);

  if (data_ == NULL || bufferSize_ < dataLength_) {
    BIASWARN("File (" << dataLength_ << " bytes) is too large for internal "
             "buffer (" << bufferSize_ << " bytes), re-initialising buffer...");
    if (Init(dataLength_) < 0)
      return -1;
  }

  if (long(fread(data_, 1, dataLength_, input)) != dataLength_) {
    BIASERR("Failed to load file " << filename <<" completely!");
    return -1;
  }

  fclose (input);

  return 0;
}