first commit

CS4210/Project 3/jpeg_resizer/jpeg-6b/lowres-write.c

@@ -0,0 +1,202 @@
+/* Just a part of the lowres functionality. It has to be in a separate
+   file, otherwise the data destination manager routines would conflict
+   with the ones used for decompression. Someone needs to write an
+   object-oriented extension for C. ;-))) 
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+/* YANNIS: This _fine_ library wants me to define a data destination
+   manager just to be able to write compressed data in memory. */
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  size_t   total_size;
+  JOCTET * output;        /* target stream */
+} my_destination_mgr;
+
+typedef my_destination_mgr * my_dest_ptr;
+
+METHODDEF(void)
+init_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr this_obj = (my_dest_ptr) cinfo->dest;
+  
+  this_obj->total_size = cinfo->image_width * cinfo->input_components * 
+    cinfo->image_height;
+  /* Probably too much space, but let's be conservative */
+  this_obj->output = (JOCTET *) malloc(this_obj->total_size * sizeof(JOCTET));
+  this_obj->pub.next_output_byte = this_obj->output;
+  this_obj->pub.free_in_buffer = this_obj->total_size;
+}
+
+/* The following routine contributed by Ilya Bagrak (Spring'03) */
+METHODDEF(boolean)
+empty_output_buffer (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+  unsigned char* ret;
+
+  ret = realloc(dest->output, dest->total_size + 1024);
+  dest->output = ret;
+  dest->total_size += 1024;
+  dest->pub.next_output_byte = dest->output + dest->total_size - 1024;
+  dest->pub.free_in_buffer = 1024;
+
+  fprintf(stderr, "ASSERTION FAILURE\n");
+  return TRUE;  /* This shouldn't happen */
+}
+
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written.  Usually needs to flush buffer.
+ */
+
+METHODDEF(void)
+term_destination (j_compress_ptr cinfo)
+{
+  return;   /* No need to do anything */
+}
+
+
+GLOBAL(void)
+jpeg_mem_dest (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest;
+
+  if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+                           SIZEOF(my_destination_mgr));
+  }
+
+  dest = (my_dest_ptr) cinfo->dest;
+  dest->pub.init_destination = init_destination;
+  dest->pub.empty_output_buffer = empty_output_buffer;
+  dest->pub.term_destination = term_destination;
+}
+
+
+
+GLOBAL(void)
+write_JPEG_file (JSAMPARRAY buffer, int image_width, int image_height,
+		 int color_comp, J_COLOR_SPACE color_space,
+		 int quality, JOCTET **output, int *output_size)
+{
+  /* 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;
+  /* 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: 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 = color_comp;	/* # of color components per pixel */
+  cinfo.in_color_space = color_space; 	/* colorspace of input image */
+
+  /* Step 3: specify data destination (eg, a file) */
+
+  jpeg_mem_dest(&cinfo);
+
+  /* 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 * 3;	/* JSAMPLEs 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] = buffer[cinfo.next_scanline];
+
+    (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
+  }
+
+  /* Step 6: Finish compression */
+
+  jpeg_finish_compress(&cinfo);
+
+  {
+    my_dest_ptr this_obj = (my_dest_ptr) cinfo.dest;
+    *output = this_obj->output;
+    *output_size = this_obj->total_size - this_obj->pub.free_in_buffer;
+    
+    /* We destroy that pointer so that it is not used to deallocate the
+       output data */
+    this_obj->output = NULL;
+  }
+
+  /* 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! */
+}
+
+#ifdef __cplusplus
+}
+#endif