jpeg.c

Go to the documentation of this file.

/* Simple JPEG load/save interface,
 * based on examplecode in IJG's JPEG-library
 *
 * Author Fredrik Orderud, 2005
 */

/*
 * example.c
 *
 * This file illustrates how to use the IJG code as a subroutine library
 * to read or write JPEG image files.  You should look at this code in
 * conjunction with the documentation file libjpeg.doc.
 *
 * This code will not do anything useful as-is, but it may be helpful as a
 * skeleton for constructing routines that call the JPEG library.
 *
 * We present these routines in the same coding style used in the JPEG code
 * (ANSI function definitions, etc); but you are of course free to code your
 * routines in a different style if you prefer.
 */

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

#include "jpeg.h"

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

#include <setjmp.h>

#ifdef __cplusplus
 extern "C" {  // stupid JPEG library
#endif
#include <jpeglib.h>
#ifdef __cplusplus
 }
#endif





namespace HAIR
{
/****************************************************************************
//*!TYPE........: Function
 * NAME........: write_JPEG_file
 * CREATED.....: 24-Jan-2006
 * MODIFIED....: 24-Jan-2005
 *****************************************************************************/
//GLOBAL(void) write_JPEG_file (char * filename, int quality, imageRGB img) 
bool write_JPEG_file (char * filename, int quality, imageRGB img) 
{

        int image_width      = img.width;
        int image_height     = img.height;
        unsigned char* image = img.data;
   int ltrysave         = 0;
   bool booltrysave     = true;
   bool boolreturn      = false;


        JSAMPLE * image_buffer = (JSAMPLE *) image;
   struct jpeg_compress_struct cinfo;
   struct jpeg_error_mgr jerr;
   /* More stuff */
   FILE * outfile;               /* target file */
   JSAMPROW row_pointer[1];      /* pointer to JSAMPLE row[s] */
   int row_stride;               /* physical row width in image buffer */

   cinfo.err = jpeg_std_error(&jerr);
   jpeg_create_compress(&cinfo);

   while(booltrysave)
   {  
      ltrysave++;
      if ((outfile = fopen(filename, "wb")) == NULL) 
      {
         fprintf(stderr, " > can't open %s %d/4\n", filename,ltrysave);
      }
      else
      booltrysave = false;

      if(ltrysave == 4)
      return false;
   }

   jpeg_stdio_dest(&cinfo, outfile);

   cinfo.image_width = image_width;      /* image width and height, in pixels */
   cinfo.image_height = image_height;
   cinfo.input_components = 3;           /* # of color components per pixel */
   cinfo.in_color_space = JCS_RGB;       /* colorspace of input image */
   jpeg_set_defaults(&cinfo);
   jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);

   jpeg_start_compress(&cinfo, TRUE);

   row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */

   while (cinfo.next_scanline < cinfo.image_height) 
   {
      row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride];
      (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
   }

   jpeg_finish_compress(&cinfo);
   fclose(outfile);
   jpeg_destroy_compress(&cinfo);
 
   return true;

}


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;

METHODDEF(void) my_error_exit (j_common_ptr cinfo)
{
  my_error_ptr myerr = (my_error_ptr) cinfo->err;

  (*cinfo->err->output_message) (cinfo);

  longjmp(myerr->setjmp_buffer, 1);
}

/****************************************************************************
//*!TYPE........: Function
 * NAME........: read_JPEG_file
 * CREATED.....: 24-Jan-2006
 * MODIFIED....: 24-Jan-2005
 *****************************************************************************/
GLOBAL(imageRGB) read_JPEG_file (char * filename)
{
   struct jpeg_decompress_struct cinfo;
   struct my_error_mgr jerr;
   FILE * infile;                /* source file */
   JSAMPARRAY buffer;            /* Output row buffer */
   int row_stride;               /* physical row width in output buffer */

   if ((infile = fopen(filename, "rb")) == NULL) 
   {
      fprintf(stderr, "can't open %s\n", filename);
      imageRGB zero = {0,0,0};
      return zero;
   }

   cinfo.err = jpeg_std_error(&jerr.pub);
   jerr.pub.error_exit = my_error_exit;
   if (setjmp(jerr.setjmp_buffer)) 
   {
      jpeg_destroy_decompress(&cinfo);
      fclose(infile);
      imageRGB zero = {0,0,0};
      return zero;
  }

  jpeg_create_decompress(&cinfo);
  jpeg_stdio_src(&cinfo, infile);
  (void) jpeg_read_header(&cinfo, TRUE);
  (void) jpeg_start_decompress(&cinfo);
  row_stride = cinfo.output_width * cinfo.output_components;
  buffer = (*cinfo.mem->alloc_sarray)
                ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
        imageRGB img;
        img.width  = cinfo.output_width;
        img.height = cinfo.output_height;

        img.data = (unsigned char*)malloc(cinfo.output_components * img.width * img.height);
        unsigned char* ptr = img.data;
   while (cinfo.output_scanline < cinfo.output_height) 
   {
      (void) jpeg_read_scanlines(&cinfo, buffer, 1);
      memcpy(ptr, buffer[0], row_stride); ptr += row_stride;
   }

   (void) jpeg_finish_decompress(&cinfo);
   jpeg_destroy_decompress(&cinfo);

   fclose(infile);

   return img;
}

}

---