The Independent JPEG Group's JPEG software v3

1 files changed, 624 insertions, 0 deletions

diff --git a/example.c b/example.c
new file mode 100644
index 00000000..2cd3afb7
--- /dev/null
+++ b/example.c
@@ -0,0 +1,624 @@
+/*
+ * example.c
+ *
+ * This file is not actually part of the JPEG software.  Rather, it provides
+ * a skeleton that may be useful for constructing applications that use the
+ * JPEG software as subroutines.  This code will NOT do anything useful as is.
+ *
+ * This file illustrates how to use the JPEG code as a subroutine library
+ * to read or write JPEG image files.  We assume here that you are not
+ * merely interested in converting the image to yet another image file format
+ * (if you are, you should be adding another I/O module to cjpeg/djpeg, not
+ * constructing a new application).  Instead, we show how to pass the
+ * decompressed image data into or out of routines that you provide.  For
+ * example, a viewer program might use the JPEG decompressor together with
+ * routines that write the decompressed image directly to a display.
+ *
+ * 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 file for declaring JPEG data structures.
+ * This file also includes some system headers like <stdio.h>;
+ * if you prefer, you can include "jconfig.h" and "jpegdata.h" instead.
+ */
+
+#include "jinclude.h"
+
+/*
+ * <setjmp.h> is used for the optional error recovery mechanism shown in
+ * the second part of the example.
+ */
+
+#include <setjmp.h>
+
+
+
+/******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/
+
+/* This half of the example shows how to feed data into the JPEG compressor.
+ * We present a minimal version that does not worry about refinements such
+ * as error recovery (the JPEG code will just exit() if it gets an error).
+ */
+
+
+/*
+ * To supply the image data for compression, you must define three routines
+ * input_init, get_input_row, and input_term.  These routines will be called
+ * from the JPEG compressor via function pointer values that you store in the
+ * cinfo data structure; hence they need not be globally visible and the exact
+ * names don't matter.  (In fact, the "METHODDEF" macro expands to "static" if
+ * you use the unmodified JPEG include files.)
+ *
+ * The input file reading modules (jrdppm.c, jrdgif.c, jrdtarga.c, etc) may be
+ * useful examples of what these routines should actually do, although each of
+ * them is encrusted with a lot of specialized code for its own file format.
+ */
+
+
+METHODDEF void
+input_init (compress_info_ptr cinfo)
+/* Initialize for input; return image size and component data. */
+{
+  /* This routine must return five pieces of information about the incoming
+   * image, and must do any setup needed for the get_input_row routine.
+   * The image information is returned in fields of the cinfo struct.
+   * (If you don't care about modularity, you could initialize these fields
+   * in the main JPEG calling routine, and make this routine be a no-op.)
+   * We show some example values here.
+   */
+  cinfo->image_width = 640;		/* width in pixels */
+  cinfo->image_height = 480;		/* height in pixels */
+  /* JPEG views an image as being a rectangular array of pixels, with each
+   * pixel having the same number of "component" values (color channels).
+   * You must specify how many components there are and the colorspace
+   * interpretation of the components.  Most applications will use RGB data or
+   * grayscale data.  If you want to use something else, you'll need to study
+   * and perhaps modify jcdeflts.c, jccolor.c, and jdcolor.c.
+   */
+  cinfo->input_components = 3;		/* or 1 for grayscale */
+  cinfo->in_color_space = CS_RGB;	/* or CS_GRAYSCALE for grayscale */
+  cinfo->data_precision = 8;		/* bits per pixel component value */
+  /* In the current JPEG software, data_precision must be set equal to
+   * BITS_IN_JSAMPLE, which is 8 unless you twiddle jconfig.h.  Future
+   * versions might allow you to say either 8 or 12 if compiled with
+   * 12-bit JSAMPLEs, or up to 16 in lossless mode.  In any case,
+   * it is up to you to scale incoming pixel values to the range
+   *   0 .. (1<<data_precision)-1.
+   * If your image data format is fixed at a byte per component,
+   * then saying "8" is probably the best long-term solution.
+   */
+}
+
+
+/*
+ * This function is called repeatedly and must supply the next row of pixels
+ * on each call.  The rows MUST be returned in top-to-bottom order if you want
+ * your JPEG files to be compatible with everyone else's.  (If you cannot
+ * readily read your data in that order, you'll need an intermediate array to
+ * hold the image.  See jrdtarga.c or jrdrle.c for examples of handling
+ * bottom-to-top source data using the JPEG code's portable mechanisms.)
+ * The data is to be returned into a 2-D array of JSAMPLEs, indexed as
+ *		JSAMPLE pixel_row[component][column]
+ * where component runs from 0 to cinfo->input_components-1, and column runs
+ * from 0 to cinfo->image_width-1 (column 0 is left edge of image).  Note that
+ * this is actually an array of pointers to arrays rather than a true 2D array,
+ * since C does not support variable-size multidimensional arrays.
+ * JSAMPLE is typically typedef'd as "unsigned char".
+ */
+
+
+METHODDEF void
+get_input_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
+/* Read next row of pixels into pixel_row[][] */
+{
+  /* This example shows how you might read RGB data (3 components)
+   * from an input file in which the data is stored 3 bytes per pixel
+   * in left-to-right, top-to-bottom order.
+   */
+  register FILE * infile = cinfo->input_file;
+  register JSAMPROW ptr0, ptr1, ptr2;
+  register long col;
+  
+  ptr0 = pixel_row[0];
+  ptr1 = pixel_row[1];
+  ptr2 = pixel_row[2];
+  for (col = 0; col < cinfo->image_width; col++) {
+    *ptr0++ = (JSAMPLE) getc(infile); /* red */
+    *ptr1++ = (JSAMPLE) getc(infile); /* green */
+    *ptr2++ = (JSAMPLE) getc(infile); /* blue */
+  }
+}
+
+
+METHODDEF void
+input_term (compress_info_ptr cinfo)
+/* Finish up at the end of the input */
+{
+  /* This termination routine will very often have no work to do, */
+  /* but you must provide it anyway. */
+  /* Note that the JPEG code will only call it during successful exit; */
+  /* if you want it called during error exit, you gotta do that yourself. */
+}
+
+
+/*
+ * That's it for the routines that deal with reading the input image data.
+ * Now we have overall control and parameter selection routines.
+ */
+
+
+/*
+ * This routine must determine what output JPEG file format is to be written,
+ * and make any other compression parameter changes that are desirable.
+ * This routine gets control after the input file header has been read
+ * (i.e., right after input_init has been called).  You could combine its
+ * functions into input_init, or even into the main control routine, but
+ * if you have several different input_init routines, it's a definite win
+ * to keep this separate.  You MUST supply this routine even if it's a no-op.
+ */
+
+METHODDEF void
+c_ui_method_selection (compress_info_ptr cinfo)
+{
+  /* If the input is gray scale, generate a monochrome JPEG file. */
+  if (cinfo->in_color_space == CS_GRAYSCALE)
+    j_monochrome_default(cinfo);
+  /* For now, always select JFIF output format. */
+  jselwjfif(cinfo);
+}
+
+
+/*
+ * OK, here is the main function that actually causes everything to happen.
+ * We assume here that the target filename is supplied by the caller of this
+ * routine, and that all JPEG compression parameters can be default values.
+ */
+
+GLOBAL void
+write_JPEG_file (char * filename)
+{
+  /* These three structs contain JPEG parameters and working data.
+   * They must survive for the duration of parameter setup and one
+   * call to jpeg_compress; typically, making them local data in the
+   * calling routine is the best strategy.
+   */
+  struct compress_info_struct cinfo;
+  struct compress_methods_struct c_methods;
+  struct external_methods_struct e_methods;
+
+  /* Initialize the system-dependent method pointers. */
+  cinfo.methods = &c_methods;	/* links to method structs */
+  cinfo.emethods = &e_methods;
+  /* Here we use the default JPEG error handler, which will just print
+   * an error message on stderr and call exit().  See the second half of
+   * this file for an example of more graceful error recovery.
+   */
+  jselerror(&e_methods);	/* select std error/trace message routines */
+  /* Here we use the standard memory manager provided with the JPEG code.
+   * In some cases you might want to replace the memory manager, or at
+   * least the system-dependent part of it, with your own code.
+   */
+  jselmemmgr(&e_methods);	/* select std memory allocation routines */
+  /* If the compressor requires full-image buffers (for entropy-coding
+   * optimization or a noninterleaved JPEG file), it will create temporary
+   * files for anything that doesn't fit within the maximum-memory setting.
+   * (Note that temp files are NOT needed if you use the default parameters.)
+   * You can change the default maximum-memory setting by changing
+   * e_methods.max_memory_to_use after jselmemmgr returns.
+   * On some systems you may also need to set up a signal handler to
+   * ensure that temporary files are deleted if the program is interrupted.
+   * (This is most important if you are on MS-DOS and use the jmemdos.c
+   * memory manager back end; it will try to grab extended memory for
+   * temp files, and that space will NOT be freed automatically.)
+   * See jcmain.c or jdmain.c for an example signal handler.
+   */
+
+  /* Here, set up pointers to your own routines for input data handling
+   * and post-init parameter selection.
+   */
+  c_methods.input_init = input_init;
+  c_methods.get_input_row = get_input_row;
+  c_methods.input_term = input_term;
+  c_methods.c_ui_method_selection = c_ui_method_selection;
+
+  /* Set up default JPEG parameters in the cinfo data structure. */
+  j_c_defaults(&cinfo, 75, FALSE);
+  /* Note: 75 is the recommended default quality level; you may instead pass
+   * a user-specified quality level.  Be aware that values below 25 will cause
+   * non-baseline JPEG files to be created (and a warning message to that
+   * effect to be emitted on stderr).  This won't bother our decoder, but some
+   * commercial JPEG implementations may choke on non-baseline JPEG files.
+   * If you want to force baseline compatibility, pass TRUE instead of FALSE.
+   * (If non-baseline files are fine, but you could do without that warning
+   * message, set e_methods.trace_level to -1.)
+   */
+
+  /* At this point you can modify the default parameters set by j_c_defaults
+   * as needed.  For a minimal implementation, you shouldn't need to change
+   * anything.  See jcmain.c for some examples of what you might change.
+   */
+
+  /* Select the input and output files.
+   * Note that cinfo.input_file is only used if your input reading routines
+   * use it; otherwise, you can just make it NULL.
+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+   * requires it in order to write binary files.
+   */
+
+  cinfo.input_file = NULL;	/* if no actual input file involved */
+
+  if ((cinfo.output_file = fopen(filename, "wb")) == NULL) {
+    fprintf(stderr, "can't open %s\n", filename);
+    exit(1);
+  }
+
+  /* Here we go! */
+  jpeg_compress(&cinfo);
+
+  /* That's it, son.  Nothin' else to do, except close files. */
+  /* Here we assume only the output file need be closed. */
+  fclose(cinfo.output_file);
+
+  /* Note: if you want to compress more than one image, we recommend you
+   * repeat this whole routine.  You MUST repeat the j_c_defaults()/alter
+   * parameters/jpeg_compress() sequence, as some data structures allocated
+   * in j_c_defaults are freed upon exit from jpeg_compress.
+   */
+}
+
+
+
+/******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/
+
+/* This half of the example shows how to read data from the JPEG decompressor.
+ * It's a little more refined than the above in that we show how to do your
+ * own error recovery.  If you don't care about that, you don't need these
+ * next two routines.
+ */
+
+
+/*
+ * These routines replace the default trace/error routines included with the
+ * JPEG code.  The example trace_message routine shown here is actually the
+ * same as the standard one, but you could modify it if you don't want messages
+ * sent to stderr.  The example error_exit routine is set up to return
+ * control to read_JPEG_file() rather than calling exit().  You can use the
+ * same routines for both compression and decompression error recovery.
+ */
+
+/* These static variables are needed by the error routines. */
+static jmp_buf setjmp_buffer;	/* for return to caller */
+static external_methods_ptr emethods; /* needed for access to message_parm */
+
+
+/* This routine is used for any and all trace, debug, or error printouts
+ * from the JPEG code.  The parameter is a printf format string; up to 8
+ * integer data values for the format string have been stored in the
+ * message_parm[] field of the external_methods struct.
+ */
+
+METHODDEF void
+trace_message (const char *msgtext)
+{
+  fprintf(stderr, msgtext,
+	  emethods->message_parm[0], emethods->message_parm[1],
+	  emethods->message_parm[2], emethods->message_parm[3],
+	  emethods->message_parm[4], emethods->message_parm[5],
+	  emethods->message_parm[6], emethods->message_parm[7]);
+  fprintf(stderr, "\n");	/* there is no \n in the format string! */
+}
+
+/*
+ * The error_exit() routine should not return to its caller.  The default
+ * routine calls exit(), but here we assume that we want to return to
+ * read_JPEG_data, which has set up a setjmp context for the purpose.
+ * You should make sure that the free_all method is called, either within
+ * error_exit or after the return to the outer-level routine.
+ */
+
+METHODDEF void
+error_exit (const char *msgtext)
+{
+  trace_message(msgtext);	/* report the error message */
+  (*emethods->free_all) ();	/* clean up memory allocation & temp files */
+  longjmp(setjmp_buffer, 1);	/* return control to outer routine */
+}
+
+
+
+/*
+ * To accept the image data from decompression, you must define four routines
+ * output_init, put_color_map, put_pixel_rows, and output_term.
+ *
+ * You must understand the distinction between full color output mode
+ * (N independent color components) and colormapped output mode (a single
+ * output component representing an index into a color map).  You should use
+ * colormapped mode to write to a colormapped display screen or output file.
+ * Colormapped mode is also useful for reducing grayscale output to a small
+ * number of gray levels: when using the 1-pass quantizer on grayscale data,
+ * the colormap entries will be evenly spaced from 0 to MAX_JSAMPLE, so you
+ * can regard the indexes are directly representing gray levels at reduced
+ * precision.  In any other case, you should not depend on the colormap
+ * entries having any particular order.
+ * To get colormapped output, set cinfo->quantize_colors to TRUE and set
+ * cinfo->desired_number_of_colors to the maximum number of entries in the
+ * colormap.  This can be done either in your main routine or in
+ * d_ui_method_selection.  For grayscale quantization, also set
+ * cinfo->two_pass_quantize to FALSE to ensure the 1-pass quantizer is used
+ * (presently this is the default, but it may not be so in the future).
+ *
+ * The output file writing modules (jwrppm.c, jwrgif.c, jwrtarga.c, etc) may be
+ * useful examples of what these routines should actually do, although each of
+ * them is encrusted with a lot of specialized code for its own file format.
+ */
+
+
+METHODDEF void
+output_init (decompress_info_ptr cinfo)
+/* This routine should do any setup required */
+{
+  /* This routine can initialize for output based on the data passed in cinfo.
+   * Useful fields include:
+   *	image_width, image_height	Pretty obvious, I hope.
+   *	data_precision			bits per pixel value; typically 8.
+   *	out_color_space			output colorspace previously requested
+   *	color_out_comps			number of color components in same
+   *	final_out_comps			number of components actually output
+   * final_out_comps is 1 if quantize_colors is true, else it is equal to
+   * color_out_comps.
+   *
+   * If you have requested color quantization, the colormap is NOT yet set.
+   * You may wish to defer output initialization until put_color_map is called.
+   */
+}
+
+
+/*
+ * This routine is called if and only if you have set cinfo->quantize_colors
+ * to TRUE.  It is given the selected colormap and can complete any required
+ * initialization.  This call will occur after output_init and before any
+ * calls to put_pixel_rows.  Note that the colormap pointer is also placed
+ * in a cinfo field, whence it can be used by put_pixel_rows or output_term.
+ * num_colors will be less than or equal to desired_number_of_colors.
+ *
+ * The colormap data is supplied as a 2-D array of JSAMPLEs, indexed as
+ *		JSAMPLE colormap[component][indexvalue]
+ * where component runs from 0 to cinfo->color_out_comps-1, and indexvalue
+ * runs from 0 to num_colors-1.  Note that this is actually an array of
+ * pointers to arrays rather than a true 2D array, since C does not support
+ * variable-size multidimensional arrays.
+ * JSAMPLE is typically typedef'd as "unsigned char".  If you want your code
+ * to be as portable as the JPEG code proper, you should always access JSAMPLE
+ * values with the GETJSAMPLE() macro, which will do the right thing if the
+ * machine has only signed chars.
+ */
+
+METHODDEF void
+put_color_map (decompress_info_ptr cinfo, int num_colors, JSAMPARRAY colormap)
+/* Write the color map */
+{
+  /* You need not provide this routine if you always set cinfo->quantize_colors
+   * FALSE; but a safer practice is to provide it and have it just print an
+   * error message, like this:
+   */
+  fprintf(stderr, "put_color_map called: there's a bug here somewhere!\n");
+}
+
+
+/*
+ * This function is called repeatedly, with a few more rows of pixels supplied
+ * on each call.  With the current JPEG code, some multiple of 8 rows will be
+ * passed on each call except the last, but it is extremely bad form to depend
+ * on this.  You CAN assume num_rows > 0.
+ * The data is supplied in top-to-bottom row order (the standard order within
+ * a JPEG file).  If you cannot readily use the data in that order, you'll
+ * need an intermediate array to hold the image.  See jwrrle.c for an example
+ * of outputting data in bottom-to-top order.
+ *
+ * The data is supplied as a 3-D array of JSAMPLEs, indexed as
+ *		JSAMPLE pixel_data[component][row][column]
+ * where component runs from 0 to cinfo->final_out_comps-1, row runs from 0 to
+ * num_rows-1, and column runs from 0 to cinfo->image_width-1 (column 0 is
+ * left edge of image).  Note that this is actually an array of pointers to
+ * pointers to arrays rather than a true 3D array, since C does not support
+ * variable-size multidimensional arrays.
+ * JSAMPLE is typically typedef'd as "unsigned char".  If you want your code
+ * to be as portable as the JPEG code proper, you should always access JSAMPLE
+ * values with the GETJSAMPLE() macro, which will do the right thing if the
+ * machine has only signed chars.
+ *
+ * If quantize_colors is true, then there is only one component, and its values
+ * are indexes into the previously supplied colormap.  Otherwise the values
+ * are actual data in your selected output colorspace.
+ */
+
+
+METHODDEF void
+put_pixel_rows (decompress_info_ptr cinfo, int num_rows, JSAMPIMAGE pixel_data)
+/* Write some rows of output data */
+{
+  /* This example shows how you might write full-color RGB data (3 components)
+   * to an output file in which the data is stored 3 bytes per pixel.
+   */
+  register FILE * outfile = cinfo->output_file;
+  register JSAMPROW ptr0, ptr1, ptr2;
+  register long col;
+  register int row;
+  
+  for (row = 0; row < num_rows; row++) {
+    ptr0 = pixel_data[0][row];
+    ptr1 = pixel_data[1][row];
+    ptr2 = pixel_data[2][row];
+    for (col = 0; col < cinfo->image_width; col++) {
+      putc(GETJSAMPLE(*ptr0), outfile);	/* red */
+      ptr0++;
+      putc(GETJSAMPLE(*ptr1), outfile);	/* green */
+      ptr1++;
+      putc(GETJSAMPLE(*ptr2), outfile);	/* blue */
+      ptr2++;
+    }
+  }
+}
+
+
+METHODDEF void
+output_term (decompress_info_ptr cinfo)
+/* Finish up at the end of the output */
+{
+  /* This termination routine may not need to do anything. */
+  /* Note that the JPEG code will only call it during successful exit; */
+  /* if you want it called during error exit, you gotta do that yourself. */
+}
+
+
+/*
+ * That's it for the routines that deal with writing the output image.
+ * Now we have overall control and parameter selection routines.
+ */
+
+
+/*
+ * This routine gets control after the JPEG file header has been read;
+ * at this point the image size and colorspace are known.
+ * The routine must determine what output routines are to be used, and make
+ * any decompression parameter changes that are desirable.  For example,
+ * if it is found that the JPEG file is grayscale, you might want to do
+ * things differently than if it is color.  You can also delay setting
+ * quantize_colors and associated options until this point. 
+ *
+ * j_d_defaults initializes out_color_space to CS_RGB.  If you want grayscale
+ * output you should set out_color_space to CS_GRAYSCALE.  Note that you can
+ * force grayscale output from a color JPEG file (though not vice versa).
+ */
+
+METHODDEF void
+d_ui_method_selection (decompress_info_ptr cinfo)
+{
+  /* if grayscale input, force grayscale output; */
+  /* else leave the output colorspace as set by main routine. */
+  if (cinfo->jpeg_color_space == CS_GRAYSCALE)
+    cinfo->out_color_space = CS_GRAYSCALE;
+
+  /* select output routines */
+  cinfo->methods->output_init = output_init;
+  cinfo->methods->put_color_map = put_color_map;
+  cinfo->methods->put_pixel_rows = put_pixel_rows;
+  cinfo->methods->output_term = output_term;
+}
+
+
+/*
+ * OK, here is the main function that actually causes everything to happen.
+ * We assume here that the JPEG filename is supplied by the caller of this
+ * routine, and that all decompression parameters can be default values.
+ * The routine returns 1 if successful, 0 if not.
+ */
+
+GLOBAL int
+read_JPEG_file (char * filename)
+{
+  /* These three structs contain JPEG parameters and working data.
+   * They must survive for the duration of parameter setup and one
+   * call to jpeg_decompress; typically, making them local data in the
+   * calling routine is the best strategy.
+   */
+  struct decompress_info_struct cinfo;
+  struct decompress_methods_struct dc_methods;
+  struct external_methods_struct e_methods;
+
+  /* Select the input and output files.
+   * 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.
+   * Note that cinfo.output_file is only used if your output handling routines
+   * use it; otherwise, you can just make it NULL.
+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+   * requires it in order to read binary files.
+   */
+
+  if ((cinfo.input_file = fopen(filename, "rb")) == NULL) {
+    fprintf(stderr, "can't open %s\n", filename);
+    return 0;
+  }
+
+  cinfo.output_file = NULL;	/* if no actual output file involved */
+
+  /* Initialize the system-dependent method pointers. */
+  cinfo.methods = &dc_methods;	/* links to method structs */
+  cinfo.emethods = &e_methods;
+  /* Here we supply our own error handler; compare to use of standard error
+   * handler in the previous write_JPEG_file example.
+   */
+  emethods = &e_methods;	/* save struct addr for possible access */
+  e_methods.error_exit = error_exit; /* supply error-exit routine */
+  e_methods.trace_message = trace_message; /* supply trace-message routine */
+
+  /* prepare setjmp context for possible exit from error_exit */
+  if (setjmp(setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error.
+     * Memory allocation has already been cleaned up (see free_all call in
+     * error_exit), but we need to close the input file before returning.
+     * You might also need to close an output file, etc.
+     */
+    fclose(cinfo.input_file);
+    return 0;
+  }
+
+  /* Here we use the standard memory manager provided with the JPEG code.
+   * In some cases you might want to replace the memory manager, or at
+   * least the system-dependent part of it, with your own code.
+   */
+  jselmemmgr(&e_methods);	/* select std memory allocation routines */
+  /* If the decompressor requires full-image buffers (for two-pass color
+   * quantization or a noninterleaved JPEG file), it will create temporary
+   * files for anything that doesn't fit within the maximum-memory setting.
+   * You can change the default maximum-memory setting by changing
+   * e_methods.max_memory_to_use after jselmemmgr returns.
+   * On some systems you may also need to set up a signal handler to
+   * ensure that temporary files are deleted if the program is interrupted.
+   * (This is most important if you are on MS-DOS and use the jmemdos.c
+   * memory manager back end; it will try to grab extended memory for
+   * temp files, and that space will NOT be freed automatically.)
+   * See jcmain.c or jdmain.c for an example signal handler.
+   */
+
+  /* Here, set up the pointer to your own routine for post-header-reading
+   * parameter selection.  You could also initialize the pointers to the
+   * output data handling routines here, if they are not dependent on the
+   * image type.
+   */
+  dc_methods.d_ui_method_selection = d_ui_method_selection;
+
+  /* Set up default decompression parameters. */
+  j_d_defaults(&cinfo, TRUE);
+  /* TRUE indicates that an input buffer should be allocated.
+   * In unusual cases you may want to allocate the input buffer yourself;
+   * see jddeflts.c for commentary.
+   */
+
+  /* At this point you can modify the default parameters set by j_d_defaults
+   * as needed; for example, you can request color quantization or force
+   * grayscale output.  See jdmain.c for examples of what you might change.
+   */
+
+  /* Set up to read a JFIF or baseline-JPEG file. */
+  /* This is the only JPEG file format currently supported. */
+  jselrjfif(&cinfo);
+
+  /* Here we go! */
+  jpeg_decompress(&cinfo);
+
+  /* That's it, son.  Nothin' else to do, except close files. */
+  /* Here we assume only the input file need be closed. */
+  fclose(cinfo.input_file);
+
+  return 1;			/* indicate success */
+
+  /* Note: if you want to decompress more than one image, we recommend you
+   * repeat this whole routine.  You MUST repeat the j_d_defaults()/alter
+   * parameters/jpeg_decompress() sequence, as some data structures allocated
+   * in j_d_defaults are freed upon exit from jpeg_decompress.
+   */
+}