Representations/Perception/JPEGImage.cpp

Go to the documentation of this file.

/**
 * @file JPEGImage.cpp
 * 
 * Implementation of class JPEGImage
 */ 

#include "Platform/GTAssert.h"
#include "JPEGImage.h"

JPEGImage::JPEGImage(const Image& image)
{
  *this = image;
}

JPEGImage& JPEGImage::operator=(const Image& src)
{
  cameraInfo = src.cameraInfo;
  frameNumber = src.frameNumber;

  jpeg_compress_struct cInfo;
  jpeg_error_mgr jem;
  cInfo.err = jpeg_std_error(&jem);
  jpeg_create_compress(&cInfo);

  if(!cInfo.dest)
    cInfo.dest = (jpeg_destination_mgr*)
      (*cInfo.mem->alloc_small) ((j_common_ptr) &cInfo,JPOOL_PERMANENT,
                                 sizeof(DestDescriptor));
  cInfo.dest->init_destination = onDestInit;
  cInfo.dest->empty_output_buffer = onDestEmpty;
  cInfo.dest->term_destination = onDestTerm;
  ((DestDescriptor*) cInfo.dest)->theObject = this;

  cInfo.image_width = cameraInfo.resolutionWidth;
  cInfo.image_height = cameraInfo.resolutionHeight * 3;
  cInfo.input_components = 1;
  cInfo.in_color_space = JCS_GRAYSCALE;
  jpeg_set_defaults(&cInfo);
  cInfo.dct_method = JDCT_FASTEST;
  jpeg_set_quality(&cInfo,75,true);

  jpeg_start_compress(&cInfo,true);

  while(cInfo.next_scanline < cInfo.image_height) 
  {
    JSAMPROW rowPointer = const_cast<JSAMPROW>(&src.image[cInfo.next_scanline % src.cameraInfo.resolutionHeight]
                                                         [cInfo.next_scanline / src.cameraInfo.resolutionHeight][0]);
    jpeg_write_scanlines(&cInfo,&rowPointer,1);
  }

  jpeg_finish_compress(&cInfo);
  jpeg_destroy_compress(&cInfo);
  return *this;
}

void JPEGImage::toImage(Image& dest) const
{
  dest.cameraInfo = cameraInfo;
  dest.frameNumber = frameNumber;

  jpeg_decompress_struct cInfo;
  jpeg_error_mgr jem;
  cInfo.err = jpeg_std_error(&jem);

  jpeg_create_decompress(&cInfo);

  if(!cInfo.src)
    cInfo.src = (jpeg_source_mgr *)
      (*cInfo.mem->alloc_small)((j_common_ptr) &cInfo,JPOOL_PERMANENT,
                                 sizeof(jpeg_source_mgr));
  cInfo.src->init_source       = onSrcIgnore;
  cInfo.src->fill_input_buffer = onSrcEmpty;
  cInfo.src->skip_input_data   = onSrcSkip;
  cInfo.src->resync_to_restart = jpeg_resync_to_restart;
  cInfo.src->term_source       = onSrcIgnore;
  cInfo.src->bytes_in_buffer = size;
  cInfo.src->next_input_byte = (const JOCTET*) image;

  jpeg_read_header(&cInfo,true);
  jpeg_start_decompress(&cInfo);

  // setup rows
  while (cInfo.output_scanline < cInfo.output_height) 
  {
    JSAMPROW rowPointer = (unsigned char*) (cInfo.output_height == (unsigned) cameraResolutionHeight_ERS210
                          ? &dest.image[cInfo.output_scanline][0][0]
                          : &dest.image[cInfo.output_scanline % dest.cameraInfo.resolutionHeight]
                                       [cInfo.output_scanline / dest.cameraInfo.resolutionHeight][0]);
    (void) jpeg_read_scanlines(&cInfo,&rowPointer,1);
  }

  // decompress
  jpeg_finish_decompress(&cInfo);
  jpeg_destroy_decompress(&cInfo);

  // compatibility with old format: move to correct positions
  if(cInfo.output_height == (unsigned) cameraResolutionHeight_ERS210)
    for(unsigned i = 0; i < cInfo.output_height; ++i)
      for(unsigned c = 2; c > 0; --c)
        memmove(&dest.image[i][c][0], 
                &dest.image[i][0][c * cameraResolutionWidth_ERS210], 
                cameraResolutionWidth_ERS210);

  // clear high resolution y channels
  for(int y = 0; y < dest.cameraInfo.resolutionHeight; ++y)
    for(int c = 3; c < 6; ++c)
      memset(&dest.image[y][c][0], 128, dest.cameraInfo.resolutionWidth);
}

void JPEGImage::onDestInit(j_compress_ptr cInfo)
{
  JPEGImage& image = *((DestDescriptor*) cInfo->dest)->theObject;
  cInfo->dest->next_output_byte = (JOCTET*) image.image;
  cInfo->dest->free_in_buffer = image.cameraInfo.resolutionWidth * image.cameraInfo.resolutionHeight * 3;
}

int JPEGImage::onDestEmpty(j_compress_ptr)
{
  ASSERT(false);
  return false;
}

void JPEGImage::onDestTerm(j_compress_ptr cInfo)
{
  JPEGImage& image = *((DestDescriptor*) cInfo->dest)->theObject;
  image.size = (char*) cInfo->dest->next_output_byte - (char*) image.image;
}

void JPEGImage::onSrcSkip(j_decompress_ptr,long)
{
}

int JPEGImage::onSrcEmpty(j_decompress_ptr)
{
  ASSERT(false);
  return false;
}

void JPEGImage::onSrcIgnore(j_decompress_ptr)
{
}

Out& operator<<(Out& stream,const JPEGImage& image)
{
  ASSERT(image.size);
  stream << image.cameraInfo.resolutionWidth << image.cameraInfo.resolutionHeight << image.frameNumber << image.size;
  stream.write(&image.image,image.size);
  return stream;
}

In& operator>>(In& stream,JPEGImage& image)
{
  stream >> image.cameraInfo.resolutionWidth >> image.cameraInfo.resolutionHeight >> image.frameNumber >> image.size;
  image.setCameraInfo();
  stream.read(&image.image,image.size);
  return stream;
}

---