cimg.cxx 3.6.3

package/plugins/jpeg_buffer.h

@@ -0,0 +1,377 @@
+/*
+ #
+ #  File        : jpeg_buffer.h
+ #                ( C++ header file - CImg plug-in )
+ #
+ #  Description : This CImg plug-in provide functions to load and save jpeg images
+ #                directly from/to memory buffers of JOCTET buffers, using the
+ #                JPEG library (required to compile !)
+ #                This file is a part of the CImg Library project.
+ #                ( http://cimg.eu )
+ #
+ #  Copyright   : Paolo Prete
+ #                ( p4olo_prete@yahoo.it )
+ #
+ #  License     : CeCILL v2.0
+ #                ( http://www.cecill.info/licences/Licence_CeCILL_V2-en.html )
+ #
+ #  This software is governed by the CeCILL  license under French law and
+ #  abiding by the rules of distribution of free software.  You can  use,
+ #  modify and/ or redistribute the software under the terms of the CeCILL
+ #  license as circulated by CEA, CNRS and INRIA at the following URL
+ #  "http://www.cecill.info".
+ #
+ #  As a counterpart to the access to the source code and  rights to copy,
+ #  modify and redistribute granted by the license, users are provided only
+ #  with a limited warranty  and the software's author,  the holder of the
+ #  economic rights,  and the successive licensors  have only  limited
+ #  liability.
+ #
+ #  In this respect, the user's attention is drawn to the risks associated
+ #  with loading,  using,  modifying and/or developing or reproducing the
+ #  software by the user in light of its specific status of free software,
+ #  that may mean  that it is complicated to manipulate,  and  that  also
+ #  therefore means  that it is reserved for developers  and  experienced
+ #  professionals having in-depth computer knowledge. Users are therefore
+ #  encouraged to load and test the software's suitability as regards their
+ #  requirements in conditions enabling the security of their systems and/or
+ #  data to be ensured and,  more generally, to use and operate it in the
+ #  same conditions as regards security.
+ #
+ #  The fact that you are presently reading this means that you have had
+ #  knowledge of the CeCILL license and that you accept its terms.
+ #
+*/
+
+/*-----------------------------------------------------------------------------------
+
+ IMPORTANT NOTE :
+
+ You *need* to include the following lines in your own code to use this plugin :
+
+ #include <cstdio>
+ #include <jpeglib.h>
+ #include <jerror.h>
+
+ (see example file provided in examples/use_jpeg_buffer.cpp).
+
+------------------------------------------------------------------------------------*/
+
+#ifndef cimg_plugin_jpeg_buffer
+#define cimg_plugin_jpeg_buffer
+
+///////////////////////////////////////////////////////////////////////////////////////
+//
+//    extension of libjpeg (helper functions for loading images from JOCTET arrays)
+//					hacked from
+//	http://www.koders.com/cpp/fidB5A4549ABB5CB01824058F57A43D095D3F95AB40.aspx
+//
+///////////////////////////////////////////////////////////////////////////////////////
+
+#define INPUT_BUF_SIZE 4096
+
+struct my_source_mem {
+  struct jpeg_source_mgr pub; // Public fields
+  int indexinmem;
+  JOCTET *inmem;              // Source stream
+  JOCTET *buffer;             // Start of buffer
+  int lenght;                 // Size of buffer in memory
+  boolean start_of_file;      // Have we gotten any data yet?
+};
+
+struct my_source_mgr {
+  struct jpeg_source_mgr pub; // public fields
+  FILE *infile;               // source stream
+  JOCTET *buffer;             // start of buffer
+  boolean start_of_file;      // have we gotten any data yet?
+};
+
+typedef my_source_mem *my_src_mptr;
+typedef my_source_mgr *my_src_ptr;
+
+static boolean fill_minput_buffer(j_decompress_ptr cinfo) {
+  my_src_mptr src = (my_src_mptr) cinfo->src;
+  size_t nbytes;
+  if (src->indexinmem + INPUT_BUF_SIZE>src->lenght) nbytes=src->lenght - src->indexinmem;
+  else nbytes = INPUT_BUF_SIZE;
+  std::memcpy(src->buffer,src->inmem,nbytes);
+  src->inmem += nbytes;
+  src->indexinmem += (int)nbytes;
+  src->pub.next_input_byte = src->buffer;
+  src->pub.bytes_in_buffer = INPUT_BUF_SIZE;
+  src->start_of_file = FALSE;
+  return TRUE;
+}
+
+static void skip_minput_data(j_decompress_ptr cinfo, long num_bytes) {
+  my_src_ptr src = (my_src_ptr)cinfo->src;
+  if (num_bytes > 0) {
+    while (num_bytes > (long) src->pub.bytes_in_buffer) {
+      num_bytes -= (long) src->pub.bytes_in_buffer;
+      fill_minput_buffer(cinfo);
+      // note we assume that fill_input_buffer will never return FALSE,
+      // so suspension need not be handled.
+      //
+    }
+    src->pub.next_input_byte += (size_t) num_bytes;
+    src->pub.bytes_in_buffer -= (size_t) num_bytes;
+  }
+}
+
+static void init_msource(j_decompress_ptr cinfo) {
+  my_src_mptr src = (my_src_mptr)cinfo->src;
+  src->start_of_file = TRUE;
+}
+
+static void term_source(j_decompress_ptr) {
+  // no work necessary here
+}
+
+static void jpeg_mem_src(j_decompress_ptr cinfo, JOCTET * memptr,int lenght) {
+  my_src_mptr src;
+
+  // The source object and input buffer are made permanent so that a series
+  //of JPEG images can be read from the same file by calling jpeg_stdio_src
+  // only before the first one.  (If we discarded the buffer at the end of
+  // one image, we'd likely lose the start of the next one.)
+  // This makes it unsafe to use this manager and a different source
+  // manager serially with the same JPEG object.  Caveat programmer.
+  //
+
+  // first time for this JPEG object?
+  if (cinfo->src == NULL) {
+    cinfo->src = (struct jpeg_source_mgr*)(*cinfo->mem->alloc_small)((j_common_ptr) cinfo,
+                                                                     JPOOL_PERMANENT,sizeof(my_source_mem));
+    src = (my_src_mptr) cinfo->src;
+    src->buffer = (JOCTET *)(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo,
+                                                        JPOOL_PERMANENT,INPUT_BUF_SIZE * sizeof(JOCTET));
+  }
+
+  src = (my_src_mptr) cinfo->src;
+  src->pub.init_source = init_msource;
+  src->pub.fill_input_buffer = fill_minput_buffer;
+  src->pub.skip_input_data = skip_minput_data;
+  //src->pub.resync_to_restart = jpeg_resync_to_restart; // use default method
+  src->pub.term_source = term_source;
+  src->inmem = memptr;
+  src->indexinmem = 0;
+  src->lenght = lenght;
+  src->pub.bytes_in_buffer = 0; // forces fill_input_buffer on first read
+  src->pub.next_input_byte = NULL; // until buffer loaded
+}
+
+// The following declarations and 5 functions are jpeg related
+// functions used by put_jpeg_grey_memory and put_jpeg_yuv420p_memory
+//
+struct mem_destination_mgr {
+  struct jpeg_destination_mgr pub;
+  JOCTET *buf;
+  size_t bufsize;
+  size_t jpegsize;
+};
+
+typedef mem_destination_mgr *mem_dest_ptr;
+
+static void init_destination(j_compress_ptr cinfo) {
+  mem_dest_ptr dest = (mem_dest_ptr) cinfo->dest;
+  dest->pub.next_output_byte = dest->buf;
+  dest->pub.free_in_buffer = dest->bufsize;
+  dest->jpegsize = 0;
+}
+
+static boolean empty_output_buffer(j_compress_ptr cinfo) {
+  mem_dest_ptr dest = (mem_dest_ptr) cinfo->dest;
+  dest->pub.next_output_byte = dest->buf;
+  dest->pub.free_in_buffer = dest->bufsize;
+  return FALSE;
+  ERREXIT(cinfo, JERR_BUFFER_SIZE);
+}
+
+static void term_destination(j_compress_ptr cinfo) {
+  mem_dest_ptr dest = (mem_dest_ptr) cinfo->dest;
+  dest->jpegsize = dest->bufsize - dest->pub.free_in_buffer;
+}
+
+static void jpeg_mem_dest(j_compress_ptr cinfo, JOCTET* buf, size_t bufsize) {
+  mem_dest_ptr dest;
+  if (cinfo->dest == NULL) {
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small)((j_common_ptr)cinfo,JPOOL_PERMANENT,sizeof(mem_destination_mgr));
+  }
+  dest = (mem_dest_ptr) cinfo->dest;
+  dest->pub.init_destination = init_destination;
+  dest->pub.empty_output_buffer = empty_output_buffer;
+  dest->pub.term_destination = term_destination;
+  dest->buf = buf;
+  dest->bufsize = bufsize;
+  dest->jpegsize = 0;
+}
+
+static unsigned jpeg_mem_size(j_compress_ptr cinfo) {
+  mem_dest_ptr dest = (mem_dest_ptr) cinfo->dest;
+  return dest->jpegsize;
+}
+
+/////////////////////////////////////////////////////////////////
+//
+//    Define main CImg plugin functions.
+//    (you should use these functions only in your own code)
+//
+/////////////////////////////////////////////////////////////////
+
+//! Load image from a jpeg-coded memory buffer.
+/**
+   \param buffer Memory buffer containing the jpeg-coded image data.
+   \param buffer_size Size of the memory buffer, in bytes.
+**/
+static CImg get_load_jpeg_buffer(const JOCTET *const buffer, const unsigned buffer_size) {
+  struct jpeg_decompress_struct cinfo;
+  struct jpeg_error_mgr jerr;
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_decompress(&cinfo);
+  jpeg_mem_src(&cinfo,const_cast<JOCTET*>(buffer),buffer_size);
+  jpeg_read_header(&cinfo,TRUE);
+  jpeg_start_decompress(&cinfo);
+
+  const unsigned int row_stride = cinfo.output_width * cinfo.output_components;
+  const size_t siz = safe_size(cinfo.output_width,cinfo.output_height,1,cinfo.output_components);
+  JOCTET *buf = new JOCTET[siz];
+  const JOCTET *buf2 = buf;
+  JSAMPROW row_pointer[1];
+  while (cinfo.output_scanline < cinfo.output_height) {
+    row_pointer[0] = buf + cinfo.output_scanline*row_stride;
+    jpeg_read_scanlines(&cinfo,row_pointer,1);
+  }
+  jpeg_finish_decompress(&cinfo);
+  jpeg_destroy_decompress(&cinfo);
+
+  CImg<T> dest(cinfo.output_width,cinfo.output_height,1,cinfo.output_components);
+  switch (dest.spectrum()) {
+  case 1: {
+    T *ptr_g = dest.data(0,0,0,0);
+    cimg_foroff(dest,off) *(ptr_g++) = (T)*(buf2++);
+  } break;
+  case 3: {
+    T
+      *ptr_r = dest.data(0,0,0,0),
+      *ptr_g = dest.data(0,0,0,1),
+      *ptr_b = dest.data(0,0,0,2);
+    cimg_forXY(dest,x,y) {
+      *(ptr_r++) = (T)*(buf2++);
+      *(ptr_g++) = (T)*(buf2++);
+      *(ptr_b++) = (T)*(buf2++);
+    }
+  } break;
+  case 4: {
+    T
+      *ptr_r = dest.data(0,0,0,0),
+      *ptr_g = dest.data(0,0,0,1),
+      *ptr_b = dest.data(0,0,0,2),
+      *ptr_a = dest.data(0,0,0,3);
+    cimg_forXY(dest,x,y) {
+      *(ptr_r++) = (T)*(buf2++);
+      *(ptr_g++) = (T)*(buf2++);
+      *(ptr_b++) = (T)*(buf2++);
+      *(ptr_a++) = (T)*(buf2++);
+    }
+  } break;
+  }
+  delete[] buf;
+
+  return dest;
+}
+
+//! Load image from a jpeg-coded memory buffer (in-place version)
+/**
+   \param buffer Memory buffer containing the jpeg-coded image data.
+   \param buffer_size Size of the memory buffer, in bytes.
+**/
+CImg& load_jpeg_buffer(const JOCTET *const buffer, const unsigned buffer_size) {
+  return get_load_jpeg_buffer(buffer,buffer_size).move_to(*this);
+}
+
+//! Save image in a memory buffer, directly as a jpeg-coded file
+/**
+   \param buffer Memory buffer that will be written with the jpeg-coded image data.
+   \param buffer_size Initial size of the memory buffer. When the function returns, the variable
+   contains the effective length needed to fill the buffer.
+   \param quality Quality of the jpeg compression.
+**/
+const CImg& save_jpeg_buffer(JOCTET *const buffer, unsigned int &buffer_size, const int quality=100) const {
+
+  // Fill pixel buffer
+  JOCTET *buf;
+  unsigned int dimbuf=0;
+  J_COLOR_SPACE colortype=JCS_RGB;
+  switch (spectrum()) {
+  case 1: {
+    // Greyscale images
+    JOCTET *buf2 = buf = new JOCTET[width()*height()*(dimbuf=1)];
+    const T
+      *ptr_g = data();
+    colortype = JCS_GRAYSCALE;
+    cimg_foroff(*this,off) *(buf2++) = (JOCTET)*(ptr_g++);
+  } break;
+  case 2:
+  case 3: {
+    // RGB images
+    JOCTET *buf2 = buf = new JOCTET[width()*height()*(dimbuf=3)];
+    const T
+      *ptr_r = data(0,0,0,0),
+      *ptr_g = data(0,0,0,1),
+      *ptr_b = data(0,0,0,spectrum()>2?2:0);
+    colortype = JCS_RGB;
+    cimg_forXY(*this,x,y) {
+      *(buf2++) = (JOCTET)*(ptr_r++);
+      *(buf2++) = (JOCTET)*(ptr_g++);
+      *(buf2++) = (JOCTET)*(ptr_b++);
+    }
+  } break;
+  default: {
+    // YCMYK images
+    JOCTET *buf2 = buf = new JOCTET[width()*height()*(dimbuf=4)];
+    const T
+      *ptr_r = data(0,0,0,0),
+      *ptr_g = data(0,0,0,1),
+      *ptr_b = data(0,0,0,2),
+      *ptr_a = data(0,0,0,3);
+    colortype = JCS_CMYK;
+    cimg_forXY(*this,x,y) {
+      *(buf2++) = (JOCTET)*(ptr_r++);
+      *(buf2++) = (JOCTET)*(ptr_g++);
+      *(buf2++) = (JOCTET)*(ptr_b++);
+      *(buf2++) = (JOCTET)*(ptr_a++);
+    }
+  } break;
+  }
+
+  // Call libjpeg functions
+  struct jpeg_compress_struct cinfo;
+  struct jpeg_error_mgr jerr;
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_compress(&cinfo);
+  jpeg_mem_dest(&cinfo, buffer, buffer_size);
+  cinfo.image_width = width();
+  cinfo.image_height = height();
+  cinfo.input_components = dimbuf;
+  cinfo.in_color_space = colortype;
+  jpeg_set_defaults(&cinfo);
+  jpeg_set_quality(&cinfo,quality<100?quality:100,TRUE);
+  jpeg_start_compress(&cinfo,TRUE);
+
+  const unsigned int row_stride = width()*dimbuf;
+  JSAMPROW row_pointer[1];
+  while (cinfo.next_scanline < cinfo.image_height) {
+    row_pointer[0] = &buf[cinfo.next_scanline*row_stride];
+    jpeg_write_scanlines(&cinfo,row_pointer,1);
+  }
+  jpeg_finish_compress(&cinfo);
+  delete[] buf;
+  buffer_size = jpeg_mem_size(&cinfo);
+  jpeg_destroy_compress(&cinfo);
+  return *this;
+}
+
+// End of the plug-in
+//-------------------
+#endif /* cimg_plugin_jpeg_buffer */