# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: address@hidden
# target_branch: http://bzr.savannah.gnu.org/r/pdf/libgnupdf/branches\
#   /trunk/
# testament_sha1: ed00cb2617d1e88a5dd39df7539d8409fa3ffc5f
# timestamp: 2008-12-22 23:30:55 +0800
# base_revision_id: address@hidden
# 
# Begin patch
=== modified file 'configure.ac'
--- configure.ac	2008-12-01 23:55:12 +0000
+++ configure.ac	2008-12-14 05:27:04 +0000
@@ -51,6 +51,15 @@
 AM_CONDITIONAL([ZLIB], [test "x$have_zlib" = "xyes"])
 AC_CHECK_LIB(m,exp,,,)
 
+have_jpeglib=no
+AC_CHECK_LIB([jpeg],[jpeg_std_error],[have_jpeglib=yes],,)
+
+if test "x$have_jpeglib" = "xyes"; then
+   LIBS="-ljpeg $LIBS"
+   AC_DEFINE([HAVE_JPEGLIB], [1], [The jpeglib library is available])
+fi
+AM_CONDITIONAL([JPEGLIB], [test "x$have_jpeglib" = "xyes"])
+
 have_jbig2dec=no
 AC_CHECK_LIB([jbig2dec],[jbig2_ctx_new],[have_jbig2dec=yes],,)
 
@@ -297,6 +306,7 @@
   Compilation level:                        ${PDFLIB_LEVEL} (${PDFLIB_LEVEL_DESCR})
   Using FlateDecode filter?                 ${have_zlib}
   Using JBIG2 decoder filter?               ${have_jbig2dec}
+  Using JPEG filter?                        ${have_jpeglib}
   With unit tests support?                  ${ut_support} ${ut_framework}
   Program to build html manuals             ${texihtmlprogram}
   Build project management resources?       ${prmgt_mode}

=== added file 'lib/jconfig.h'
--- lib/jconfig.h	1970-01-01 00:00:00 +0000
+++ lib/jconfig.h	2008-12-18 13:52:38 +0000
@@ -0,0 +1,45 @@
+/* jconfig.h.  Generated automatically by configure.  */
+/* jconfig.cfg --- source file edited by configure script */
+/* see jconfig.doc for explanations */
+
+#define HAVE_PROTOTYPES 
+#define HAVE_UNSIGNED_CHAR 
+#define HAVE_UNSIGNED_SHORT 
+#undef void
+#undef const
+#undef CHAR_IS_UNSIGNED
+#define HAVE_STDDEF_H 
+#define HAVE_STDLIB_H 
+#undef NEED_BSD_STRINGS
+#undef NEED_SYS_TYPES_H
+#undef NEED_FAR_POINTERS
+#undef NEED_SHORT_EXTERNAL_NAMES
+/* Define this if you get warnings about undefined structures. */
+#undef INCOMPLETE_TYPES_BROKEN
+
+#ifdef JPEG_INTERNALS
+
+#undef RIGHT_SHIFT_IS_UNSIGNED
+#define INLINE __inline__
+/* These are for configuring the JPEG memory manager. */
+#undef DEFAULT_MAX_MEM
+#undef NO_MKTEMP
+
+#endif /* JPEG_INTERNALS */
+
+#ifdef JPEG_CJPEG_DJPEG
+
+#define BMP_SUPPORTED		/* BMP image file format */
+#define GIF_SUPPORTED		/* GIF image file format */
+#define PPM_SUPPORTED		/* PBMPLUS PPM/PGM image file format */
+#undef RLE_SUPPORTED		/* Utah RLE image file format */
+#define TARGA_SUPPORTED		/* Targa image file format */
+
+#undef TWO_FILE_COMMANDLINE
+#undef NEED_SIGNAL_CATCHER
+#undef DONT_USE_B_MODE
+
+/* Define this if you want percent-done progress reports from cjpeg/djpeg. */
+#undef PROGRESS_REPORT
+
+#endif /* JPEG_CJPEG_DJPEG */

=== added file 'lib/jmorecfg.h'
--- lib/jmorecfg.h	1970-01-01 00:00:00 +0000
+++ lib/jmorecfg.h	2008-12-18 13:52:38 +0000
@@ -0,0 +1,363 @@
+/*
+ * jmorecfg.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains additional configuration options that customize the
+ * JPEG software for special applications or support machine-dependent
+ * optimizations.  Most users will not need to touch this file.
+ */
+
+
+/*
+ * Define BITS_IN_JSAMPLE as either
+ *   8   for 8-bit sample values (the usual setting)
+ *   12  for 12-bit sample values
+ * Only 8 and 12 are legal data precisions for lossy JPEG according to the
+ * JPEG standard, and the IJG code does not support anything else!
+ * We do not support run-time selection of data precision, sorry.
+ */
+
+#define BITS_IN_JSAMPLE  8	/* use 8 or 12 */
+
+
+/*
+ * Maximum number of components (color channels) allowed in JPEG image.
+ * To meet the letter of the JPEG spec, set this to 255.  However, darn
+ * few applications need more than 4 channels (maybe 5 for CMYK + alpha
+ * mask).  We recommend 10 as a reasonable compromise; use 4 if you are
+ * really short on memory.  (Each allowed component costs a hundred or so
+ * bytes of storage, whether actually used in an image or not.)
+ */
+
+#define MAX_COMPONENTS  10	/* maximum number of image components */
+
+
+/*
+ * Basic data types.
+ * You may need to change these if you have a machine with unusual data
+ * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
+ * or "long" not 32 bits.  We don't care whether "int" is 16 or 32 bits,
+ * but it had better be at least 16.
+ */
+
+/* Representation of a single sample (pixel element value).
+ * We frequently allocate large arrays of these, so it's important to keep
+ * them small.  But if you have memory to burn and access to char or short
+ * arrays is very slow on your hardware, you might want to change these.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+/* JSAMPLE should be the smallest type that will hold the values 0..255.
+ * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JSAMPLE;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJSAMPLE(value)  ((int) (value))
+#else
+#define GETJSAMPLE(value)  ((int) (value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+#define MAXJSAMPLE	255
+#define CENTERJSAMPLE	128
+
+#endif /* BITS_IN_JSAMPLE == 8 */
+
+
+#if BITS_IN_JSAMPLE == 12
+/* JSAMPLE should be the smallest type that will hold the values 0..4095.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#define MAXJSAMPLE	4095
+#define CENTERJSAMPLE	2048
+
+#endif /* BITS_IN_JSAMPLE == 12 */
+
+
+/* Representation of a DCT frequency coefficient.
+ * This should be a signed value of at least 16 bits; "short" is usually OK.
+ * Again, we allocate large arrays of these, but you can change to int
+ * if you have memory to burn and "short" is really slow.
+ */
+
+typedef short JCOEF;
+
+
+/* Compressed datastreams are represented as arrays of JOCTET.
+ * These must be EXACTLY 8 bits wide, at least once they are written to
+ * external storage.  Note that when using the stdio data source/destination
+ * managers, this is also the data type passed to fread/fwrite.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JOCTET;
+#define GETJOCTET(value)  (value)
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JOCTET;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJOCTET(value)  (value)
+#else
+#define GETJOCTET(value)  ((value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+
+/* These typedefs are used for various table entries and so forth.
+ * They must be at least as wide as specified; but making them too big
+ * won't cost a huge amount of memory, so we don't provide special
+ * extraction code like we did for JSAMPLE.  (In other words, these
+ * typedefs live at a different point on the speed/space tradeoff curve.)
+ */
+
+/* UINT8 must hold at least the values 0..255. */
+
+#ifdef HAVE_UNSIGNED_CHAR
+typedef unsigned char UINT8;
+#else /* not HAVE_UNSIGNED_CHAR */
+#ifdef CHAR_IS_UNSIGNED
+typedef char UINT8;
+#else /* not CHAR_IS_UNSIGNED */
+typedef short UINT8;
+#endif /* CHAR_IS_UNSIGNED */
+#endif /* HAVE_UNSIGNED_CHAR */
+
+/* UINT16 must hold at least the values 0..65535. */
+
+#ifdef HAVE_UNSIGNED_SHORT
+typedef unsigned short UINT16;
+#else /* not HAVE_UNSIGNED_SHORT */
+typedef unsigned int UINT16;
+#endif /* HAVE_UNSIGNED_SHORT */
+
+/* INT16 must hold at least the values -32768..32767. */
+
+#ifndef XMD_H			/* X11/xmd.h correctly defines INT16 */
+typedef short INT16;
+#endif
+
+/* INT32 must hold at least signed 32-bit values. */
+
+#ifndef XMD_H			/* X11/xmd.h correctly defines INT32 */
+typedef long INT32;
+#endif
+
+/* Datatype used for image dimensions.  The JPEG standard only supports
+ * images up to 64K*64K due to 16-bit fields in SOF markers.  Therefore
+ * "unsigned int" is sufficient on all machines.  However, if you need to
+ * handle larger images and you don't mind deviating from the spec, you
+ * can change this datatype.
+ */
+
+typedef unsigned int JDIMENSION;
+
+#define JPEG_MAX_DIMENSION  65500L  /* a tad under 64K to prevent overflows */
+
+
+/* These macros are used in all function definitions and extern declarations.
+ * You could modify them if you need to change function linkage conventions;
+ * in particular, you'll need to do that to make the library a Windows DLL.
+ * Another application is to make all functions global for use with debuggers
+ * or code profilers that require it.
+ */
+
+/* a function called through method pointers: */
+#define METHODDEF(type)		static type
+/* a function used only in its module: */
+#define LOCAL(type)		static type
+/* a function referenced thru EXTERNs: */
+#define GLOBAL(type)		type
+/* a reference to a GLOBAL function: */
+#define EXTERN(type)		extern type
+
+
+/* This macro is used to declare a "method", that is, a function pointer.
+ * We want to supply prototype parameters if the compiler can cope.
+ * Note that the arglist parameter must be parenthesized!
+ * Again, you can customize this if you need special linkage keywords.
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JMETHOD(type,methodname,arglist)  type (*methodname) arglist
+#else
+#define JMETHOD(type,methodname,arglist)  type (*methodname) ()
+#endif
+
+
+/* Here is the pseudo-keyword for declaring pointers that must be "far"
+ * on 80x86 machines.  Most of the specialized coding for 80x86 is handled
+ * by just saying "FAR *" where such a pointer is needed.  In a few places
+ * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
+ */
+
+#ifdef NEED_FAR_POINTERS
+#define FAR  far
+#else
+#define FAR
+#endif
+
+
+/*
+ * On a few systems, type boolean and/or its values FALSE, TRUE may appear
+ * in standard header files.  Or you may have conflicts with application-
+ * specific header files that you want to include together with these files.
+ * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
+ */
+
+#ifndef HAVE_BOOLEAN
+typedef int boolean;
+#endif
+#ifndef FALSE			/* in case these macros already exist */
+#define FALSE	0		/* values of boolean */
+#endif
+#ifndef TRUE
+#define TRUE	1
+#endif
+
+
+/*
+ * The remaining options affect code selection within the JPEG library,
+ * but they don't need to be visible to most applications using the library.
+ * To minimize application namespace pollution, the symbols won't be
+ * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
+ */
+
+#ifdef JPEG_INTERNALS
+#define JPEG_INTERNAL_OPTIONS
+#endif
+
+#ifdef JPEG_INTERNAL_OPTIONS
+
+
+/*
+ * These defines indicate whether to include various optional functions.
+ * Undefining some of these symbols will produce a smaller but less capable
+ * library.  Note that you can leave certain source files out of the
+ * compilation/linking process if you've #undef'd the corresponding symbols.
+ * (You may HAVE to do that if your compiler doesn't like null source files.)
+ */
+
+/* Arithmetic coding is unsupported for legal reasons.  Complaints to IBM. */
+
+/* Capability options common to encoder and decoder: */
+
+#define DCT_ISLOW_SUPPORTED	/* slow but accurate integer algorithm */
+#define DCT_IFAST_SUPPORTED	/* faster, less accurate integer method */
+#define DCT_FLOAT_SUPPORTED	/* floating-point: accurate, fast on fast HW */
+
+/* Encoder capability options: */
+
+#undef  C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
+#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define C_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
+#define ENTROPY_OPT_SUPPORTED	    /* Optimization of entropy coding parms? */
+/* Note: if you selected 12-bit data precision, it is dangerous to turn off
+ * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit
+ * precision, so jchuff.c normally uses entropy optimization to compute
+ * usable tables for higher precision.  If you don't want to do optimization,
+ * you'll have to supply different default Huffman tables.
+ * The exact same statements apply for progressive JPEG: the default tables
+ * don't work for progressive mode.  (This may get fixed, however.)
+ */
+#define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */
+
+/* Decoder capability options: */
+
+#undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
+#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define D_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
+#define SAVE_MARKERS_SUPPORTED	    /* jpeg_save_markers() needed? */
+#define BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
+#define IDCT_SCALING_SUPPORTED	    /* Output rescaling via IDCT? */
+#undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
+#define UPSAMPLE_MERGING_SUPPORTED  /* Fast path for sloppy upsampling? */
+#define QUANT_1PASS_SUPPORTED	    /* 1-pass color quantization? */
+#define QUANT_2PASS_SUPPORTED	    /* 2-pass color quantization? */
+
+/* more capability options later, no doubt */
+
+
+/*
+ * Ordering of RGB data in scanlines passed to or from the application.
+ * If your application wants to deal with data in the order B,G,R, just
+ * change these macros.  You can also deal with formats such as R,G,B,X
+ * (one extra byte per pixel) by changing RGB_PIXELSIZE.  Note that changing
+ * the offsets will also change the order in which colormap data is organized.
+ * RESTRICTIONS:
+ * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
+ * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
+ *    useful if you are using JPEG color spaces other than YCbCr or grayscale.
+ * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
+ *    is not 3 (they don't understand about dummy color components!).  So you
+ *    can't use color quantization if you change that value.
+ */
+
+#define RGB_RED		0	/* Offset of Red in an RGB scanline element */
+#define RGB_GREEN	1	/* Offset of Green */
+#define RGB_BLUE	2	/* Offset of Blue */
+#define RGB_PIXELSIZE	3	/* JSAMPLEs per RGB scanline element */
+
+
+/* Definitions for speed-related optimizations. */
+
+
+/* If your compiler supports inline functions, define INLINE
+ * as the inline keyword; otherwise define it as empty.
+ */
+
+#ifndef INLINE
+#ifdef __GNUC__			/* for instance, GNU C knows about inline */
+#define INLINE __inline__
+#endif
+#ifndef INLINE
+#define INLINE			/* default is to define it as empty */
+#endif
+#endif
+
+
+/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
+ * two 16-bit shorts is faster than multiplying two ints.  Define MULTIPLIER
+ * as short on such a machine.  MULTIPLIER must be at least 16 bits wide.
+ */
+
+#ifndef MULTIPLIER
+#define MULTIPLIER  int		/* type for fastest integer multiply */
+#endif
+
+
+/* FAST_FLOAT should be either float or double, whichever is done faster
+ * by your compiler.  (Note that this type is only used in the floating point
+ * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
+ * Typically, float is faster in ANSI C compilers, while double is faster in
+ * pre-ANSI compilers (because they insist on converting to double anyway).
+ * The code below therefore chooses float if we have ANSI-style prototypes.
+ */
+
+#ifndef FAST_FLOAT
+#ifdef HAVE_PROTOTYPES
+#define FAST_FLOAT  float
+#else
+#define FAST_FLOAT  double
+#endif
+#endif
+
+#endif /* JPEG_INTERNAL_OPTIONS */

=== added file 'lib/jpeglib.h'
--- lib/jpeglib.h	1970-01-01 00:00:00 +0000
+++ lib/jpeglib.h	2008-12-18 13:52:38 +0000
@@ -0,0 +1,1096 @@
+/*
+ * jpeglib.h
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the application interface for the JPEG library.
+ * Most applications using the library need only include this file,
+ * and perhaps jerror.h if they want to know the exact error codes.
+ */
+
+#ifndef JPEGLIB_H
+#define JPEGLIB_H
+
+/*
+ * First we include the configuration files that record how this
+ * installation of the JPEG library is set up.  jconfig.h can be
+ * generated automatically for many systems.  jmorecfg.h contains
+ * manual configuration options that most people need not worry about.
+ */
+
+#ifndef JCONFIG_INCLUDED	/* in case jinclude.h already did */
+#include "jconfig.h"		/* widely used configuration options */
+#endif
+#include "jmorecfg.h"		/* seldom changed options */
+
+
+/* Version ID for the JPEG library.
+ * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
+ */
+
+#define JPEG_LIB_VERSION  62	/* Version 6b */
+
+
+/* Various constants determining the sizes of things.
+ * All of these are specified by the JPEG standard, so don't change them
+ * if you want to be compatible.
+ */
+
+#define DCTSIZE		    8	/* The basic DCT block is 8x8 samples */
+#define DCTSIZE2	    64	/* DCTSIZE squared; # of elements in a block */
+#define NUM_QUANT_TBLS      4	/* Quantization tables are numbered 0..3 */
+#define NUM_HUFF_TBLS       4	/* Huffman tables are numbered 0..3 */
+#define NUM_ARITH_TBLS      16	/* Arith-coding tables are numbered 0..15 */
+#define MAX_COMPS_IN_SCAN   4	/* JPEG limit on # of components in one scan */
+#define MAX_SAMP_FACTOR     4	/* JPEG limit on sampling factors */
+/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
+ * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
+ * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
+ * to handle it.  We even let you do this from the jconfig.h file.  However,
+ * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
+ * sometimes emits noncompliant files doesn't mean you should too.
+ */
+#define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
+#ifndef D_MAX_BLOCKS_IN_MCU
+#define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
+#endif
+
+
+/* Data structures for images (arrays of samples and of DCT coefficients).
+ * On 80x86 machines, the image arrays are too big for near pointers,
+ * but the pointer arrays can fit in near memory.
+ */
+
+typedef JSAMPLE FAR *JSAMPROW;	/* ptr to one image row of pixel samples. */
+typedef JSAMPROW *JSAMPARRAY;	/* ptr to some rows (a 2-D sample array) */
+typedef JSAMPARRAY *JSAMPIMAGE;	/* a 3-D sample array: top index is color */
+
+typedef JCOEF JBLOCK[DCTSIZE2];	/* one block of coefficients */
+typedef JBLOCK FAR *JBLOCKROW;	/* pointer to one row of coefficient blocks */
+typedef JBLOCKROW *JBLOCKARRAY;		/* a 2-D array of coefficient blocks */
+typedef JBLOCKARRAY *JBLOCKIMAGE;	/* a 3-D array of coefficient blocks */
+
+typedef JCOEF FAR *JCOEFPTR;	/* useful in a couple of places */
+
+
+/* Types for JPEG compression parameters and working tables. */
+
+
+/* DCT coefficient quantization tables. */
+
+typedef struct {
+  /* This array gives the coefficient quantizers in natural array order
+   * (not the zigzag order in which they are stored in a JPEG DQT marker).
+   * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
+   */
+  UINT16 quantval[DCTSIZE2];	/* quantization step for each coefficient */
+  /* This field is used only during compression.  It's initialized FALSE when
+   * the table is created, and set TRUE when it's been output to the file.
+   * You could suppress output of a table by setting this to TRUE.
+   * (See jpeg_suppress_tables for an example.)
+   */
+  boolean sent_table;		/* TRUE when table has been output */
+} JQUANT_TBL;
+
+
+/* Huffman coding tables. */
+
+typedef struct {
+  /* These two fields directly represent the contents of a JPEG DHT marker */
+  UINT8 bits[17];		/* bits[k] = # of symbols with codes of */
+				/* length k bits; bits[0] is unused */
+  UINT8 huffval[256];		/* The symbols, in order of incr code length */
+  /* This field is used only during compression.  It's initialized FALSE when
+   * the table is created, and set TRUE when it's been output to the file.
+   * You could suppress output of a table by setting this to TRUE.
+   * (See jpeg_suppress_tables for an example.)
+   */
+  boolean sent_table;		/* TRUE when table has been output */
+} JHUFF_TBL;
+
+
+/* Basic info about one component (color channel). */
+
+typedef struct {
+  /* These values are fixed over the whole image. */
+  /* For compression, they must be supplied by parameter setup; */
+  /* for decompression, they are read from the SOF marker. */
+  int component_id;		/* identifier for this component (0..255) */
+  int component_index;		/* its index in SOF or cinfo->comp_info[] */
+  int h_samp_factor;		/* horizontal sampling factor (1..4) */
+  int v_samp_factor;		/* vertical sampling factor (1..4) */
+  int quant_tbl_no;		/* quantization table selector (0..3) */
+  /* These values may vary between scans. */
+  /* For compression, they must be supplied by parameter setup; */
+  /* for decompression, they are read from the SOS marker. */
+  /* The decompressor output side may not use these variables. */
+  int dc_tbl_no;		/* DC entropy table selector (0..3) */
+  int ac_tbl_no;		/* AC entropy table selector (0..3) */
+  
+  /* Remaining fields should be treated as private by applications. */
+  
+  /* These values are computed during compression or decompression startup: */
+  /* Component's size in DCT blocks.
+   * Any dummy blocks added to complete an MCU are not counted; therefore
+   * these values do not depend on whether a scan is interleaved or not.
+   */
+  JDIMENSION width_in_blocks;
+  JDIMENSION height_in_blocks;
+  /* Size of a DCT block in samples.  Always DCTSIZE for compression.
+   * For decompression this is the size of the output from one DCT block,
+   * reflecting any scaling we choose to apply during the IDCT step.
+   * Values of 1,2,4,8 are likely to be supported.  Note that different
+   * components may receive different IDCT scalings.
+   */
+  int DCT_scaled_size;
+  /* The downsampled dimensions are the component's actual, unpadded number
+   * of samples at the main buffer (preprocessing/compression interface), thus
+   * downsampled_width = ceil(image_width * Hi/Hmax)
+   * and similarly for height.  For decompression, IDCT scaling is included, so
+   * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
+   */
+  JDIMENSION downsampled_width;	 /* actual width in samples */
+  JDIMENSION downsampled_height; /* actual height in samples */
+  /* This flag is used only for decompression.  In cases where some of the
+   * components will be ignored (eg grayscale output from YCbCr image),
+   * we can skip most computations for the unused components.
+   */
+  boolean component_needed;	/* do we need the value of this component? */
+
+  /* These values are computed before starting a scan of the component. */
+  /* The decompressor output side may not use these variables. */
+  int MCU_width;		/* number of blocks per MCU, horizontally */
+  int MCU_height;		/* number of blocks per MCU, vertically */
+  int MCU_blocks;		/* MCU_width * MCU_height */
+  int MCU_sample_width;		/* MCU width in samples, MCU_width*DCT_scaled_size */
+  int last_col_width;		/* # of non-dummy blocks across in last MCU */
+  int last_row_height;		/* # of non-dummy blocks down in last MCU */
+
+  /* Saved quantization table for component; NULL if none yet saved.
+   * See jdinput.c comments about the need for this information.
+   * This field is currently used only for decompression.
+   */
+  JQUANT_TBL * quant_table;
+
+  /* Private per-component storage for DCT or IDCT subsystem. */
+  void * dct_table;
+} jpeg_component_info;
+
+
+/* The script for encoding a multiple-scan file is an array of these: */
+
+typedef struct {
+  int comps_in_scan;		/* number of components encoded in this scan */
+  int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
+  int Ss, Se;			/* progressive JPEG spectral selection parms */
+  int Ah, Al;			/* progressive JPEG successive approx. parms */
+} jpeg_scan_info;
+
+/* The decompressor can save APPn and COM markers in a list of these: */
+
+typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr;
+
+struct jpeg_marker_struct {
+  jpeg_saved_marker_ptr next;	/* next in list, or NULL */
+  UINT8 marker;			/* marker code: JPEG_COM, or JPEG_APP0+n */
+  unsigned int original_length;	/* # bytes of data in the file */
+  unsigned int data_length;	/* # bytes of data saved at data[] */
+  JOCTET FAR * data;		/* the data contained in the marker */
+  /* the marker length word is not counted in data_length or original_length */
+};
+
+/* Known color spaces. */
+
+typedef enum {
+	JCS_UNKNOWN,		/* error/unspecified */
+	JCS_GRAYSCALE,		/* monochrome */
+	JCS_RGB,		/* red/green/blue */
+	JCS_YCbCr,		/* Y/Cb/Cr (also known as YUV) */
+	JCS_CMYK,		/* C/M/Y/K */
+	JCS_YCCK		/* Y/Cb/Cr/K */
+} J_COLOR_SPACE;
+
+/* DCT/IDCT algorithm options. */
+
+typedef enum {
+	JDCT_ISLOW,		/* slow but accurate integer algorithm */
+	JDCT_IFAST,		/* faster, less accurate integer method */
+	JDCT_FLOAT		/* floating-point: accurate, fast on fast HW */
+} J_DCT_METHOD;
+
+#ifndef JDCT_DEFAULT		/* may be overridden in jconfig.h */
+#define JDCT_DEFAULT  JDCT_ISLOW
+#endif
+#ifndef JDCT_FASTEST		/* may be overridden in jconfig.h */
+#define JDCT_FASTEST  JDCT_IFAST
+#endif
+
+/* Dithering options for decompression. */
+
+typedef enum {
+	JDITHER_NONE,		/* no dithering */
+	JDITHER_ORDERED,	/* simple ordered dither */
+	JDITHER_FS		/* Floyd-Steinberg error diffusion dither */
+} J_DITHER_MODE;
+
+
+/* Common fields between JPEG compression and decompression master structs. */
+
+#define jpeg_common_fields \
+  struct jpeg_error_mgr * err;	/* Error handler module */\
+  struct jpeg_memory_mgr * mem;	/* Memory manager module */\
+  struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
+  void * client_data;		/* Available for use by application */\
+  boolean is_decompressor;	/* So common code can tell which is which */\
+  int global_state		/* For checking call sequence validity */
+
+/* Routines that are to be used by both halves of the library are declared
+ * to receive a pointer to this structure.  There are no actual instances of
+ * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
+ */
+struct jpeg_common_struct {
+  jpeg_common_fields;		/* Fields common to both master struct types */
+  /* Additional fields follow in an actual jpeg_compress_struct or
+   * jpeg_decompress_struct.  All three structs must agree on these
+   * initial fields!  (This would be a lot cleaner in C++.)
+   */
+};
+
+typedef struct jpeg_common_struct * j_common_ptr;
+typedef struct jpeg_compress_struct * j_compress_ptr;
+typedef struct jpeg_decompress_struct * j_decompress_ptr;
+
+
+/* Master record for a compression instance */
+
+struct jpeg_compress_struct {
+  jpeg_common_fields;		/* Fields shared with jpeg_decompress_struct */
+
+  /* Destination for compressed data */
+  struct jpeg_destination_mgr * dest;
+
+  /* Description of source image --- these fields must be filled in by
+   * outer application before starting compression.  in_color_space must
+   * be correct before you can even call jpeg_set_defaults().
+   */
+
+  JDIMENSION image_width;	/* input image width */
+  JDIMENSION image_height;	/* input image height */
+  int input_components;		/* # of color components in input image */
+  J_COLOR_SPACE in_color_space;	/* colorspace of input image */
+
+  double input_gamma;		/* image gamma of input image */
+
+  /* Compression parameters --- these fields must be set before calling
+   * jpeg_start_compress().  We recommend calling jpeg_set_defaults() to
+   * initialize everything to reasonable defaults, then changing anything
+   * the application specifically wants to change.  That way you won't get
+   * burnt when new parameters are added.  Also note that there are several
+   * helper routines to simplify changing parameters.
+   */
+
+  int data_precision;		/* bits of precision in image data */
+
+  int num_components;		/* # of color components in JPEG image */
+  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+  jpeg_component_info * comp_info;
+  /* comp_info[i] describes component that appears i'th in SOF */
+  
+  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+  /* ptrs to coefficient quantization tables, or NULL if not defined */
+  
+  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  /* ptrs to Huffman coding tables, or NULL if not defined */
+  
+  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+  int num_scans;		/* # of entries in scan_info array */
+  const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
+  /* The default value of scan_info is NULL, which causes a single-scan
+   * sequential JPEG file to be emitted.  To create a multi-scan file,
+   * set num_scans and scan_info to point to an array of scan definitions.
+   */
+
+  boolean raw_data_in;		/* TRUE=caller supplies downsampled data */
+  boolean arith_code;		/* TRUE=arithmetic coding, FALSE=Huffman */
+  boolean optimize_coding;	/* TRUE=optimize entropy encoding parms */
+  boolean CCIR601_sampling;	/* TRUE=first samples are cosited */
+  int smoothing_factor;		/* 1..100, or 0 for no input smoothing */
+  J_DCT_METHOD dct_method;	/* DCT algorithm selector */
+
+  /* The restart interval can be specified in absolute MCUs by setting
+   * restart_interval, or in MCU rows by setting restart_in_rows
+   * (in which case the correct restart_interval will be figured
+   * for each scan).
+   */
+  unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
+  int restart_in_rows;		/* if > 0, MCU rows per restart interval */
+
+  /* Parameters controlling emission of special markers. */
+
+  boolean write_JFIF_header;	/* should a JFIF marker be written? */
+  UINT8 JFIF_major_version;	/* What to write for the JFIF version number */
+  UINT8 JFIF_minor_version;
+  /* These three values are not used by the JPEG code, merely copied */
+  /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
+  /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
+  /* ratio is defined by X_density/Y_density even when density_unit=0. */
+  UINT8 density_unit;		/* JFIF code for pixel size units */
+  UINT16 X_density;		/* Horizontal pixel density */
+  UINT16 Y_density;		/* Vertical pixel density */
+  boolean write_Adobe_marker;	/* should an Adobe marker be written? */
+  
+  /* State variable: index of next scanline to be written to
+   * jpeg_write_scanlines().  Application may use this to control its
+   * processing loop, e.g., "while (next_scanline < image_height)".
+   */
+
+  JDIMENSION next_scanline;	/* 0 .. image_height-1  */
+
+  /* Remaining fields are known throughout compressor, but generally
+   * should not be touched by a surrounding application.
+   */
+
+  /*
+   * These fields are computed during compression startup
+   */
+  boolean progressive_mode;	/* TRUE if scan script uses progressive mode */
+  int max_h_samp_factor;	/* largest h_samp_factor */
+  int max_v_samp_factor;	/* largest v_samp_factor */
+
+  JDIMENSION total_iMCU_rows;	/* # of iMCU rows to be input to coef ctlr */
+  /* The coefficient controller receives data in units of MCU rows as defined
+   * for fully interleaved scans (whether the JPEG file is interleaved or not).
+   * There are v_samp_factor * DCTSIZE sample rows of each component in an
+   * "iMCU" (interleaved MCU) row.
+   */
+  
+  /*
+   * These fields are valid during any one scan.
+   * They describe the components and MCUs actually appearing in the scan.
+   */
+  int comps_in_scan;		/* # of JPEG components in this scan */
+  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+  /* *cur_comp_info[i] describes component that appears i'th in SOS */
+  
+  JDIMENSION MCUs_per_row;	/* # of MCUs across the image */
+  JDIMENSION MCU_rows_in_scan;	/* # of MCU rows in the image */
+  
+  int blocks_in_MCU;		/* # of DCT blocks per MCU */
+  int MCU_membership[C_MAX_BLOCKS_IN_MCU];
+  /* MCU_membership[i] is index in cur_comp_info of component owning */
+  /* i'th block in an MCU */
+
+  int Ss, Se, Ah, Al;		/* progressive JPEG parameters for scan */
+
+  /*
+   * Links to compression subobjects (methods and private variables of modules)
+   */
+  struct jpeg_comp_master * master;
+  struct jpeg_c_main_controller * main;
+  struct jpeg_c_prep_controller * prep;
+  struct jpeg_c_coef_controller * coef;
+  struct jpeg_marker_writer * marker;
+  struct jpeg_color_converter * cconvert;
+  struct jpeg_downsampler * downsample;
+  struct jpeg_forward_dct * fdct;
+  struct jpeg_entropy_encoder * entropy;
+  jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */
+  int script_space_size;
+};
+
+
+/* Master record for a decompression instance */
+
+struct jpeg_decompress_struct {
+  jpeg_common_fields;		/* Fields shared with jpeg_compress_struct */
+
+  /* Source of compressed data */
+  struct jpeg_source_mgr * src;
+
+  /* Basic description of image --- filled in by jpeg_read_header(). */
+  /* Application may inspect these values to decide how to process image. */
+
+  JDIMENSION image_width;	/* nominal image width (from SOF marker) */
+  JDIMENSION image_height;	/* nominal image height */
+  int num_components;		/* # of color components in JPEG image */
+  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+  /* Decompression processing parameters --- these fields must be set before
+   * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
+   * them to default values.
+   */
+
+  J_COLOR_SPACE out_color_space; /* colorspace for output */
+
+  unsigned int scale_num, scale_denom; /* fraction by which to scale image */
+
+  double output_gamma;		/* image gamma wanted in output */
+
+  boolean buffered_image;	/* TRUE=multiple output passes */
+  boolean raw_data_out;		/* TRUE=downsampled data wanted */
+
+  J_DCT_METHOD dct_method;	/* IDCT algorithm selector */
+  boolean do_fancy_upsampling;	/* TRUE=apply fancy upsampling */
+  boolean do_block_smoothing;	/* TRUE=apply interblock smoothing */
+
+  boolean quantize_colors;	/* TRUE=colormapped output wanted */
+  /* the following are ignored if not quantize_colors: */
+  J_DITHER_MODE dither_mode;	/* type of color dithering to use */
+  boolean two_pass_quantize;	/* TRUE=use two-pass color quantization */
+  int desired_number_of_colors;	/* max # colors to use in created colormap */
+  /* these are significant only in buffered-image mode: */
+  boolean enable_1pass_quant;	/* enable future use of 1-pass quantizer */
+  boolean enable_external_quant;/* enable future use of external colormap */
+  boolean enable_2pass_quant;	/* enable future use of 2-pass quantizer */
+
+  /* Description of actual output image that will be returned to application.
+   * These fields are computed by jpeg_start_decompress().
+   * You can also use jpeg_calc_output_dimensions() to determine these values
+   * in advance of calling jpeg_start_decompress().
+   */
+
+  JDIMENSION output_width;	/* scaled image width */
+  JDIMENSION output_height;	/* scaled image height */
+  int out_color_components;	/* # of color components in out_color_space */
+  int output_components;	/* # of color components returned */
+  /* output_components is 1 (a colormap index) when quantizing colors;
+   * otherwise it equals out_color_components.
+   */
+  int rec_outbuf_height;	/* min recommended height of scanline buffer */
+  /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
+   * high, space and time will be wasted due to unnecessary data copying.
+   * Usually rec_outbuf_height will be 1 or 2, at most 4.
+   */
+
+  /* When quantizing colors, the output colormap is described by these fields.
+   * The application can supply a colormap by setting colormap non-NULL before
+   * calling jpeg_start_decompress; otherwise a colormap is created during
+   * jpeg_start_decompress or jpeg_start_output.
+   * The map has out_color_components rows and actual_number_of_colors columns.
+   */
+  int actual_number_of_colors;	/* number of entries in use */
+  JSAMPARRAY colormap;		/* The color map as a 2-D pixel array */
+
+  /* State variables: these variables indicate the progress of decompression.
+   * The application may examine these but must not modify them.
+   */
+
+  /* Row index of next scanline to be read from jpeg_read_scanlines().
+   * Application may use this to control its processing loop, e.g.,
+   * "while (output_scanline < output_height)".
+   */
+  JDIMENSION output_scanline;	/* 0 .. output_height-1  */
+
+  /* Current input scan number and number of iMCU rows completed in scan.
+   * These indicate the progress of the decompressor input side.
+   */
+  int input_scan_number;	/* Number of SOS markers seen so far */
+  JDIMENSION input_iMCU_row;	/* Number of iMCU rows completed */
+
+  /* The "output scan number" is the notional scan being displayed by the
+   * output side.  The decompressor will not allow output scan/row number
+   * to get ahead of input scan/row, but it can fall arbitrarily far behind.
+   */
+  int output_scan_number;	/* Nominal scan number being displayed */
+  JDIMENSION output_iMCU_row;	/* Number of iMCU rows read */
+
+  /* Current progression status.  coef_bits[c][i] indicates the precision
+   * with which component c's DCT coefficient i (in zigzag order) is known.
+   * It is -1 when no data has yet been received, otherwise it is the point
+   * transform (shift) value for the most recent scan of the coefficient
+   * (thus, 0 at completion of the progression).
+   * This pointer is NULL when reading a non-progressive file.
+   */
+  int (*coef_bits)[DCTSIZE2];	/* -1 or current Al value for each coef */
+
+  /* Internal JPEG parameters --- the application usually need not look at
+   * these fields.  Note that the decompressor output side may not use
+   * any parameters that can change between scans.
+   */
+
+  /* Quantization and Huffman tables are carried forward across input
+   * datastreams when processing abbreviated JPEG datastreams.
+   */
+
+  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+  /* ptrs to coefficient quantization tables, or NULL if not defined */
+
+  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  /* ptrs to Huffman coding tables, or NULL if not defined */
+
+  /* These parameters are never carried across datastreams, since they
+   * are given in SOF/SOS markers or defined to be reset by SOI.
+   */
+
+  int data_precision;		/* bits of precision in image data */
+
+  jpeg_component_info * comp_info;
+  /* comp_info[i] describes component that appears i'th in SOF */
+
+  boolean progressive_mode;	/* TRUE if SOFn specifies progressive mode */
+  boolean arith_code;		/* TRUE=arithmetic coding, FALSE=Huffman */
+
+  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+  unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
+
+  /* These fields record data obtained from optional markers recognized by
+   * the JPEG library.
+   */
+  boolean saw_JFIF_marker;	/* TRUE iff a JFIF APP0 marker was found */
+  /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
+  UINT8 JFIF_major_version;	/* JFIF version number */
+  UINT8 JFIF_minor_version;
+  UINT8 density_unit;		/* JFIF code for pixel size units */
+  UINT16 X_density;		/* Horizontal pixel density */
+  UINT16 Y_density;		/* Vertical pixel density */
+  boolean saw_Adobe_marker;	/* TRUE iff an Adobe APP14 marker was found */
+  UINT8 Adobe_transform;	/* Color transform code from Adobe marker */
+
+  boolean CCIR601_sampling;	/* TRUE=first samples are cosited */
+
+  /* Aside from the specific data retained from APPn markers known to the
+   * library, the uninterpreted contents of any or all APPn and COM markers
+   * can be saved in a list for examination by the application.
+   */
+  jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
+
+  /* Remaining fields are known throughout decompressor, but generally
+   * should not be touched by a surrounding application.
+   */
+
+  /*
+   * These fields are computed during decompression startup
+   */
+  int max_h_samp_factor;	/* largest h_samp_factor */
+  int max_v_samp_factor;	/* largest v_samp_factor */
+
+  int min_DCT_scaled_size;	/* smallest DCT_scaled_size of any component */
+
+  JDIMENSION total_iMCU_rows;	/* # of iMCU rows in image */
+  /* The coefficient controller's input and output progress is measured in
+   * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
+   * in fully interleaved JPEG scans, but are used whether the scan is
+   * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
+   * rows of each component.  Therefore, the IDCT output contains
+   * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
+   */
+
+  JSAMPLE * sample_range_limit; /* table for fast range-limiting */
+
+  /*
+   * These fields are valid during any one scan.
+   * They describe the components and MCUs actually appearing in the scan.
+   * Note that the decompressor output side must not use these fields.
+   */
+  int comps_in_scan;		/* # of JPEG components in this scan */
+  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+  /* *cur_comp_info[i] describes component that appears i'th in SOS */
+
+  JDIMENSION MCUs_per_row;	/* # of MCUs across the image */
+  JDIMENSION MCU_rows_in_scan;	/* # of MCU rows in the image */
+
+  int blocks_in_MCU;		/* # of DCT blocks per MCU */
+  int MCU_membership[D_MAX_BLOCKS_IN_MCU];
+  /* MCU_membership[i] is index in cur_comp_info of component owning */
+  /* i'th block in an MCU */
+
+  int Ss, Se, Ah, Al;		/* progressive JPEG parameters for scan */
+
+  /* This field is shared between entropy decoder and marker parser.
+   * It is either zero or the code of a JPEG marker that has been
+   * read from the data source, but has not yet been processed.
+   */
+  int unread_marker;
+
+  /*
+   * Links to decompression subobjects (methods, private variables of modules)
+   */
+  struct jpeg_decomp_master * master;
+  struct jpeg_d_main_controller * main;
+  struct jpeg_d_coef_controller * coef;
+  struct jpeg_d_post_controller * post;
+  struct jpeg_input_controller * inputctl;
+  struct jpeg_marker_reader * marker;
+  struct jpeg_entropy_decoder * entropy;
+  struct jpeg_inverse_dct * idct;
+  struct jpeg_upsampler * upsample;
+  struct jpeg_color_deconverter * cconvert;
+  struct jpeg_color_quantizer * cquantize;
+};
+
+
+/* "Object" declarations for JPEG modules that may be supplied or called
+ * directly by the surrounding application.
+ * As with all objects in the JPEG library, these structs only define the
+ * publicly visible methods and state variables of a module.  Additional
+ * private fields may exist after the public ones.
+ */
+
+
+/* Error handler object */
+
+struct jpeg_error_mgr {
+  /* Error exit handler: does not return to caller */
+  JMETHOD(void, error_exit, (j_common_ptr cinfo));
+  /* Conditionally emit a trace or warning message */
+  JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
+  /* Routine that actually outputs a trace or error message */
+  JMETHOD(void, output_message, (j_common_ptr cinfo));
+  /* Format a message string for the most recent JPEG error or message */
+  JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
+#define JMSG_LENGTH_MAX  200	/* recommended size of format_message buffer */
+  /* Reset error state variables at start of a new image */
+  JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
+  
+  /* The message ID code and any parameters are saved here.
+   * A message can have one string parameter or up to 8 int parameters.
+   */
+  int msg_code;
+#define JMSG_STR_PARM_MAX  80
+  union {
+    int i[8];
+    char s[JMSG_STR_PARM_MAX];
+  } msg_parm;
+  
+  /* Standard state variables for error facility */
+  
+  int trace_level;		/* max msg_level that will be displayed */
+  
+  /* For recoverable corrupt-data errors, we emit a warning message,
+   * but keep going unless emit_message chooses to abort.  emit_message
+   * should count warnings in num_warnings.  The surrounding application
+   * can check for bad data by seeing if num_warnings is nonzero at the
+   * end of processing.
+   */
+  long num_warnings;		/* number of corrupt-data warnings */
+
+  /* These fields point to the table(s) of error message strings.
+   * An application can change the table pointer to switch to a different
+   * message list (typically, to change the language in which errors are
+   * reported).  Some applications may wish to add additional error codes
+   * that will be handled by the JPEG library error mechanism; the second
+   * table pointer is used for this purpose.
+   *
+   * First table includes all errors generated by JPEG library itself.
+   * Error code 0 is reserved for a "no such error string" message.
+   */
+  const char * const * jpeg_message_table; /* Library errors */
+  int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */
+  /* Second table can be added by application (see cjpeg/djpeg for example).
+   * It contains strings numbered first_addon_message..last_addon_message.
+   */
+  const char * const * addon_message_table; /* Non-library errors */
+  int first_addon_message;	/* code for first string in addon table */
+  int last_addon_message;	/* code for last string in addon table */
+};
+
+
+/* Progress monitor object */
+
+struct jpeg_progress_mgr {
+  JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
+
+  long pass_counter;		/* work units completed in this pass */
+  long pass_limit;		/* total number of work units in this pass */
+  int completed_passes;		/* passes completed so far */
+  int total_passes;		/* total number of passes expected */
+};
+
+
+/* Data destination object for compression */
+
+struct jpeg_destination_mgr {
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+
+  JMETHOD(void, init_destination, (j_compress_ptr cinfo));
+  JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
+  JMETHOD(void, term_destination, (j_compress_ptr cinfo));
+};
+
+
+/* Data source object for decompression */
+
+struct jpeg_source_mgr {
+  const JOCTET * next_input_byte; /* => next byte to read from buffer */
+  size_t bytes_in_buffer;	/* # of bytes remaining in buffer */
+
+  JMETHOD(void, init_source, (j_decompress_ptr cinfo));
+  JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
+  JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
+  JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
+  JMETHOD(void, term_source, (j_decompress_ptr cinfo));
+};
+
+
+/* Memory manager object.
+ * Allocates "small" objects (a few K total), "large" objects (tens of K),
+ * and "really big" objects (virtual arrays with backing store if needed).
+ * The memory manager does not allow individual objects to be freed; rather,
+ * each created object is assigned to a pool, and whole pools can be freed
+ * at once.  This is faster and more convenient than remembering exactly what
+ * to free, especially where malloc()/free() are not too speedy.
+ * NB: alloc routines never return NULL.  They exit to error_exit if not
+ * successful.
+ */
+
+#define JPOOL_PERMANENT	0	/* lasts until master record is destroyed */
+#define JPOOL_IMAGE	1	/* lasts until done with image/datastream */
+#define JPOOL_NUMPOOLS	2
+
+typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
+typedef struct jvirt_barray_control * jvirt_barray_ptr;
+
+
+struct jpeg_memory_mgr {
+  /* Method pointers */
+  JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
+				size_t sizeofobject));
+  JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
+				     size_t sizeofobject));
+  JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
+				     JDIMENSION samplesperrow,
+				     JDIMENSION numrows));
+  JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
+				      JDIMENSION blocksperrow,
+				      JDIMENSION numrows));
+  JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
+						  int pool_id,
+						  boolean pre_zero,
+						  JDIMENSION samplesperrow,
+						  JDIMENSION numrows,
+						  JDIMENSION maxaccess));
+  JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
+						  int pool_id,
+						  boolean pre_zero,
+						  JDIMENSION blocksperrow,
+						  JDIMENSION numrows,
+						  JDIMENSION maxaccess));
+  JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
+  JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
+					   jvirt_sarray_ptr ptr,
+					   JDIMENSION start_row,
+					   JDIMENSION num_rows,
+					   boolean writable));
+  JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
+					    jvirt_barray_ptr ptr,
+					    JDIMENSION start_row,
+					    JDIMENSION num_rows,
+					    boolean writable));
+  JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
+  JMETHOD(void, self_destruct, (j_common_ptr cinfo));
+
+  /* Limit on memory allocation for this JPEG object.  (Note that this is
+   * merely advisory, not a guaranteed maximum; it only affects the space
+   * used for virtual-array buffers.)  May be changed by outer application
+   * after creating the JPEG object.
+   */
+  long max_memory_to_use;
+
+  /* Maximum allocation request accepted by alloc_large. */
+  long max_alloc_chunk;
+};
+
+
+/* Routine signature for application-supplied marker processing methods.
+ * Need not pass marker code since it is stored in cinfo->unread_marker.
+ */
+typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
+
+
+/* Declarations for routines called by application.
+ * The JPP macro hides prototype parameters from compilers that can't cope.
+ * Note JPP requires double parentheses.
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JPP(arglist)	arglist
+#else
+#define JPP(arglist)	()
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers.
+ * We shorten external names to be unique in the first six letters, which
+ * is good enough for all known systems.
+ * (If your compiler itself needs names to be unique in less than 15 
+ * characters, you are out of luck.  Get a better compiler.)
+ */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_std_error		jStdError
+#define jpeg_CreateCompress	jCreaCompress
+#define jpeg_CreateDecompress	jCreaDecompress
+#define jpeg_destroy_compress	jDestCompress
+#define jpeg_destroy_decompress	jDestDecompress
+#define jpeg_stdio_dest		jStdDest
+#define jpeg_stdio_src		jStdSrc
+#define jpeg_set_defaults	jSetDefaults
+#define jpeg_set_colorspace	jSetColorspace
+#define jpeg_default_colorspace	jDefColorspace
+#define jpeg_set_quality	jSetQuality
+#define jpeg_set_linear_quality	jSetLQuality
+#define jpeg_add_quant_table	jAddQuantTable
+#define jpeg_quality_scaling	jQualityScaling
+#define jpeg_simple_progression	jSimProgress
+#define jpeg_suppress_tables	jSuppressTables
+#define jpeg_alloc_quant_table	jAlcQTable
+#define jpeg_alloc_huff_table	jAlcHTable
+#define jpeg_start_compress	jStrtCompress
+#define jpeg_write_scanlines	jWrtScanlines
+#define jpeg_finish_compress	jFinCompress
+#define jpeg_write_raw_data	jWrtRawData
+#define jpeg_write_marker	jWrtMarker
+#define jpeg_write_m_header	jWrtMHeader
+#define jpeg_write_m_byte	jWrtMByte
+#define jpeg_write_tables	jWrtTables
+#define jpeg_read_header	jReadHeader
+#define jpeg_start_decompress	jStrtDecompress
+#define jpeg_read_scanlines	jReadScanlines
+#define jpeg_finish_decompress	jFinDecompress
+#define jpeg_read_raw_data	jReadRawData
+#define jpeg_has_multiple_scans	jHasMultScn
+#define jpeg_start_output	jStrtOutput
+#define jpeg_finish_output	jFinOutput
+#define jpeg_input_complete	jInComplete
+#define jpeg_new_colormap	jNewCMap
+#define jpeg_consume_input	jConsumeInput
+#define jpeg_calc_output_dimensions	jCalcDimensions
+#define jpeg_save_markers	jSaveMarkers
+#define jpeg_set_marker_processor	jSetMarker
+#define jpeg_read_coefficients	jReadCoefs
+#define jpeg_write_coefficients	jWrtCoefs
+#define jpeg_copy_critical_parameters	jCopyCrit
+#define jpeg_abort_compress	jAbrtCompress
+#define jpeg_abort_decompress	jAbrtDecompress
+#define jpeg_abort		jAbort
+#define jpeg_destroy		jDestroy
+#define jpeg_resync_to_restart	jResyncRestart
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Default error-management setup */
+EXTERN(struct jpeg_error_mgr *) jpeg_std_error
+	JPP((struct jpeg_error_mgr * err));
+
+/* Initialization of JPEG compression objects.
+ * jpeg_create_compress() and jpeg_create_decompress() are the exported
+ * names that applications should call.  These expand to calls on
+ * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
+ * passed for version mismatch checking.
+ * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
+ */
+#define jpeg_create_compress(cinfo) \
+    jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
+			(size_t) sizeof(struct jpeg_compress_struct))
+#define jpeg_create_decompress(cinfo) \
+    jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
+			  (size_t) sizeof(struct jpeg_decompress_struct))
+EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo,
+				      int version, size_t structsize));
+EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo,
+					int version, size_t structsize));
+/* Destruction of JPEG compression objects */
+EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
+
+/* Standard data source and destination managers: stdio streams. */
+/* Caller is responsible for opening the file before and closing after. */
+EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
+EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));
+
+/* Default parameter setup for compression */
+EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo));
+/* Compression parameter setup aids */
+EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo,
+				      J_COLOR_SPACE colorspace));
+EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
+				   boolean force_baseline));
+EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
+					  int scale_factor,
+					  boolean force_baseline));
+EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
+				       const unsigned int *basic_table,
+				       int scale_factor,
+				       boolean force_baseline));
+EXTERN(int) jpeg_quality_scaling JPP((int quality));
+EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo,
+				       boolean suppress));
+EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
+EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
+
+/* Main entry points for compression */
+EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,
+				      boolean write_all_tables));
+EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,
+					     JSAMPARRAY scanlines,
+					     JDIMENSION num_lines));
+EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo));
+
+/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
+EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo,
+					    JSAMPIMAGE data,
+					    JDIMENSION num_lines));
+
+/* Write a special marker.  See libjpeg.doc concerning safe usage. */
+EXTERN(void) jpeg_write_marker
+	JPP((j_compress_ptr cinfo, int marker,
+	     const JOCTET * dataptr, unsigned int datalen));
+/* Same, but piecemeal. */
+EXTERN(void) jpeg_write_m_header
+	JPP((j_compress_ptr cinfo, int marker, unsigned int datalen));
+EXTERN(void) jpeg_write_m_byte
+	JPP((j_compress_ptr cinfo, int val));
+
+/* Alternate compression function: just write an abbreviated table file */
+EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo));
+
+/* Decompression startup: read start of JPEG datastream to see what's there */
+EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,
+				  boolean require_image));
+/* Return value is one of: */
+#define JPEG_SUSPENDED		0 /* Suspended due to lack of input data */
+#define JPEG_HEADER_OK		1 /* Found valid image datastream */
+#define JPEG_HEADER_TABLES_ONLY	2 /* Found valid table-specs-only datastream */
+/* If you pass require_image = TRUE (normal case), you need not check for
+ * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
+ * JPEG_SUSPENDED is only possible if you use a data source module that can
+ * give a suspension return (the stdio source module doesn't).
+ */
+
+/* Main entry points for decompression */
+EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo));
+EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
+					    JSAMPARRAY scanlines,
+					    JDIMENSION max_lines));
+EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
+
+/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
+EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
+					   JSAMPIMAGE data,
+					   JDIMENSION max_lines));
+
+/* Additional entry points for buffered-image mode. */
+EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
+EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo,
+				       int scan_number));
+EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo));
+EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo));
+EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo));
+EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
+/* Return value is one of: */
+/* #define JPEG_SUSPENDED	0    Suspended due to lack of input data */
+#define JPEG_REACHED_SOS	1 /* Reached start of new scan */
+#define JPEG_REACHED_EOI	2 /* Reached end of image */
+#define JPEG_ROW_COMPLETED	3 /* Completed one iMCU row */
+#define JPEG_SCAN_COMPLETED	4 /* Completed last iMCU row of a scan */
+
+/* Precalculate output dimensions for current decompression parameters. */
+EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
+
+/* Control saving of COM and APPn markers into marker_list. */
+EXTERN(void) jpeg_save_markers
+	JPP((j_decompress_ptr cinfo, int marker_code,
+	     unsigned int length_limit));
+
+/* Install a special processing method for COM or APPn markers. */
+EXTERN(void) jpeg_set_marker_processor
+	JPP((j_decompress_ptr cinfo, int marker_code,
+	     jpeg_marker_parser_method routine));
+
+/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
+EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
+EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo,
+					  jvirt_barray_ptr * coef_arrays));
+EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
+						j_compress_ptr dstinfo));
+
+/* If you choose to abort compression or decompression before completing
+ * jpeg_finish_(de)compress, then you need to clean up to release memory,
+ * temporary files, etc.  You can just call jpeg_destroy_(de)compress
+ * if you're done with the JPEG object, but if you want to clean it up and
+ * reuse it, call this:
+ */
+EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
+
+/* Generic versions of jpeg_abort and jpeg_destroy that work on either
+ * flavor of JPEG object.  These may be more convenient in some places.
+ */
+EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo));
+EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo));
+
+/* Default restart-marker-resync procedure for use by data source modules */
+EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
+					    int desired));
+
+
+/* These marker codes are exported since applications and data source modules
+ * are likely to want to use them.
+ */
+
+#define JPEG_RST0	0xD0	/* RST0 marker code */
+#define JPEG_EOI	0xD9	/* EOI marker code */
+#define JPEG_APP0	0xE0	/* APP0 marker code */
+#define JPEG_COM	0xFE	/* COM marker code */
+
+
+/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
+ * for structure definitions that are never filled in, keep it quiet by
+ * supplying dummy definitions for the various substructures.
+ */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef JPEG_INTERNALS		/* will be defined in jpegint.h */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+struct jpeg_comp_master { long dummy; };
+struct jpeg_c_main_controller { long dummy; };
+struct jpeg_c_prep_controller { long dummy; };
+struct jpeg_c_coef_controller { long dummy; };
+struct jpeg_marker_writer { long dummy; };
+struct jpeg_color_converter { long dummy; };
+struct jpeg_downsampler { long dummy; };
+struct jpeg_forward_dct { long dummy; };
+struct jpeg_entropy_encoder { long dummy; };
+struct jpeg_decomp_master { long dummy; };
+struct jpeg_d_main_controller { long dummy; };
+struct jpeg_d_coef_controller { long dummy; };
+struct jpeg_d_post_controller { long dummy; };
+struct jpeg_input_controller { long dummy; };
+struct jpeg_marker_reader { long dummy; };
+struct jpeg_entropy_decoder { long dummy; };
+struct jpeg_inverse_dct { long dummy; };
+struct jpeg_upsampler { long dummy; };
+struct jpeg_color_deconverter { long dummy; };
+struct jpeg_color_quantizer { long dummy; };
+#endif /* JPEG_INTERNALS */
+#endif /* INCOMPLETE_TYPES_BROKEN */
+
+
+/*
+ * The JPEG library modules define JPEG_INTERNALS before including this file.
+ * The internal structure declarations are read only when that is true.
+ * Applications using the library should not include jpegint.h, but may wish
+ * to include jerror.h.
+ */
+
+#ifdef JPEG_INTERNALS
+#include "jpegint.h"		/* fetch private declarations */
+#include "jerror.h"		/* fetch error codes too */
+#endif
+
+#endif /* JPEGLIB_H */

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2008-11-30 20:15:05 +0000
+++ src/Makefile.am	2008-12-14 05:27:04 +0000
@@ -44,7 +44,8 @@
                      base/pdf-stm-filter.h base/pdf-stm-filter.c \
                      base/pdf-stm-f-null.h base/pdf-stm-f-null.c \
                      base/pdf-stm-f-ahex.h base/pdf-stm-f-ahex.c \
-                     base/pdf-stm-f-rl.h base/pdf-stm-f-rl.c
+                     base/pdf-stm-f-rl.h base/pdf-stm-f-rl.c \
+                     base/pdf-stm-f-rl.h base/pdf-stm-f-dct.c
 
 if ZLIB
   STM_MODULE_SOURCES += base/pdf-stm-f-flate.c base/pdf-stm-f-flate.h

=== added file 'src/base/pdf-stm-f-dct.c'
--- src/base/pdf-stm-f-dct.c	1970-01-01 00:00:00 +0000
+++ src/base/pdf-stm-f-dct.c	2008-12-19 14:47:04 +0000
@@ -0,0 +1,451 @@
+/* -*- mode: C -*- Time-stamp: "08/11/24 15:50:21 yangchanghua"
+ imagetojpeg_dst_term*
+ *       File:         pdf-stm-f-dct.c
+ *       Date:         Fri Jul 13 17:08:41 2007
+ *
+ *       GNU PDF Library - DCT decoder filter
+ *
+ */
+
+/* Copyright (C) 2007, 2008 Free Software Foundation, Inc. */
+
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <pdf-stm-f-dct.h>
+#include <jerror.h>
+#include <memory.h>
+
+#define PPM_MAXVAL 255
+
+static void         pdf_stm_f_dctdec_jpeg_cache_src (j_decompress_ptr cinfo, pdf_stm_buffer_t cache);
+static pdf_status_t pdf_stm_f_dctdec_src_fill(j_decompress_ptr cinfo, pdf_stm_buffer_t in);
+static pdf_status_t pdf_stm_f_dctdec_write_ppm_header(j_decompress_ptr cinfo, pdf_stm_buffer_t out);
+
+
+pdf_status_t
+pdf_stm_f_dctenc_init (pdf_hash_t params,
+                        void **state)
+{
+  return PDF_OK;
+}
+
+pdf_status_t
+pdf_stm_f_dctenc_apply (pdf_hash_t params,
+                         void *state,
+                         pdf_stm_buffer_t in,
+                         pdf_stm_buffer_t out,
+                         pdf_bool_t finish_p)
+{
+  pdf_status_t ret = PDF_OK;
+  return ret;
+}
+
+pdf_status_t
+pdf_stm_f_dctenc_dealloc_state (void *state)
+{
+  return PDF_OK;
+}
+
+pdf_status_t
+pdf_stm_f_dctdec_init (pdf_hash_t params,
+                        void **state)
+{
+  pdf_stm_f_dctdec_t dctdec_state;
+  pdf_status_t ret;
+
+  /* Allocate the internal state structure */
+  dctdec_state = pdf_alloc (sizeof(struct pdf_stm_f_dctdec_s));
+  memset(dctdec_state, 0, sizeof(struct pdf_stm_f_dctdec_s));
+  if (dctdec_state != NULL)
+    {
+      dctdec_state->cinfo.err = jpeg_std_error(&dctdec_state->jerr);
+      jpeg_create_decompress(&dctdec_state->cinfo);
+
+      dctdec_state->state = DCTDEC_STATE_INIT;
+      *state = dctdec_state;
+      ret = PDF_OK;
+    }
+  else
+    {
+      ret = PDF_ERROR;
+    }
+
+  return ret;
+}
+
+#define PDF_DJPEG_CACHE_SIZE (1024)
+
+pdf_status_t
+pdf_stm_f_dctdec_apply (pdf_hash_t params,
+                         void *state,
+                         pdf_stm_buffer_t in,
+                         pdf_stm_buffer_t out,
+                         pdf_bool_t finish_p)
+{
+  pdf_i32_t    loop_end = 0;
+  pdf_status_t ret = PDF_OK;
+  pdf_i32_t iret;
+  pdf_stm_f_dctdec_t filter_state = (pdf_stm_f_dctdec_t)state;
+  struct jpeg_decompress_struct *pcinfo = &filter_state->cinfo;
+
+  if(finish_p 
+      && in->wp - in->rp < 1 
+      && pcinfo->output_scanline == pcinfo->output_height 
+      && 0 == filter_state->row_valid_size - filter_state->row_copy_index )
+  {
+    return PDF_EEOF;
+  }
+
+  while(!loop_end && ret == PDF_OK)
+  {
+    if(DCTDEC_STATE_INIT == filter_state->state)
+    {
+      if(!filter_state->djpeg_in)
+      {
+        filter_state->djpeg_in = pdf_stm_buffer_new(PDF_DJPEG_CACHE_SIZE);
+        if(!filter_state->djpeg_in)
+        {
+          ret = PDF_ERROR;
+          break;
+        }
+      }
+      pdf_stm_f_dctdec_jpeg_cache_src(pcinfo, filter_state->djpeg_in);
+      filter_state->backup_state = DCTDEC_STATE_READHDR;
+      filter_state->state = DCTDEC_STATE_CACHE;
+    }
+    if(DCTDEC_STATE_CACHE == filter_state->state)
+    {
+      if(pdf_stm_buffer_eob_p(in))
+      {
+        ret = PDF_ENINPUT;
+        break;
+      }
+      ret = pdf_stm_f_dctdec_src_fill(pcinfo, in);
+      if(PDF_OK != ret)
+      {
+        break;
+      }
+      filter_state->state = filter_state->backup_state;
+    }
+    if( DCTDEC_STATE_READHDR == filter_state->state)
+    {
+      iret = jpeg_read_header(&filter_state->cinfo, TRUE);
+      if(iret == JPEG_SUSPENDED)
+      {
+        /* continue the loop, go into the "cache state" */
+        ret = PDF_OK;
+        filter_state->backup_state = filter_state->state;
+        filter_state->state = DCTDEC_STATE_CACHE;
+        continue;
+      }
+
+      if(iret != JPEG_HEADER_OK)
+      {
+        ret = PDF_ERROR;
+        break;
+      }
+      filter_state->state = DCTDEC_STATE_STARTDJP;
+    }
+    if(DCTDEC_STATE_WRITEHDR == filter_state->state)
+    {
+      ret = pdf_stm_f_dctdec_write_ppm_header( pcinfo, out);
+      if(PDF_OK != ret) 
+      {
+        break;
+      }
+      filter_state->state = DCTDEC_STATE_SCANLINE;
+    }
+    
+    if(DCTDEC_STATE_STARTDJP == filter_state->state)
+    {
+      iret = jpeg_start_decompress(&filter_state->cinfo);
+      if(iret == FALSE)
+      {
+        /* continue the loop, go into the "cache state" */
+        ret = PDF_OK;
+        filter_state->backup_state = filter_state->state;
+        filter_state->state = DCTDEC_STATE_CACHE;
+        continue;
+      }
+      /* here we know the output size, so allocate memory for them. */
+      filter_state->row_stride = pcinfo->output_width * pcinfo->output_components;
+
+      /* Make a one-row-high sample array that will go away when done with image */
+      filter_state->row_buf = (*pcinfo->mem->alloc_sarray)
+            ((j_common_ptr) pcinfo, JPOOL_IMAGE, filter_state->row_stride, 1);
+      filter_state->row_valid_size = 0;
+      filter_state->row_copy_index = 0;
+      filter_state->state = DCTDEC_STATE_WRITEHDR;  
+    }
+    if(DCTDEC_STATE_SCANLINE == filter_state->state)
+    {
+      if(!filter_state->djpeg_out)
+      {
+        filter_state->djpeg_out = pdf_stm_buffer_new(pcinfo->output_width * pcinfo->output_height * 3);
+        if(!filter_state->djpeg_out)
+        {
+          return PDF_ERROR;
+        }
+      }
+      while(pcinfo->output_scanline < pcinfo->output_height || filter_state->row_valid_size > filter_state->row_copy_index)
+      {
+        ret = PDF_OK;
+        if(filter_state->row_valid_size <= filter_state->row_copy_index)
+        {
+          pdf_i32_t scannum = 0;
+          scannum = jpeg_read_scanlines(pcinfo, filter_state->row_buf, 1);  //pcinfo->output_height);
+          if(scannum == 0)
+          {
+            ret = PDF_OK;
+            filter_state->backup_state = filter_state->state;
+            filter_state->state = DCTDEC_STATE_CACHE;
+            break;
+          }
+          if(scannum != 1)
+          {
+            ret = PDF_ERROR;
+            break;
+            loop_end = 1;
+          }
+          filter_state->num_scanlines += scannum;
+          filter_state->row_valid_size = scannum * filter_state->row_stride;
+          filter_state->row_copy_index = 0;
+        }
+    
+        if(pdf_stm_buffer_full_p(out))
+        {
+          ret = PDF_ENOUTPUT;
+          break;
+          loop_end = 1;
+        }
+        else
+        {
+          pdf_size_t bytes_to_copy = PDF_MIN(filter_state->row_valid_size - filter_state->row_copy_index, out->size - out->wp);
+          if(bytes_to_copy > 0)
+          {
+            memcpy(out->data+out->wp, filter_state->row_buf[0]+filter_state->row_copy_index, bytes_to_copy);
+            out->wp += bytes_to_copy;
+          }
+          filter_state->row_copy_index += bytes_to_copy;
+          if(filter_state->row_copy_index != filter_state->row_valid_size)
+          {
+            ret = PDF_ENOUTPUT;
+            break;
+            loop_end = 1;
+          }
+        }
+        if(PDF_OK == ret && pcinfo->output_scanline == pcinfo->output_height)
+        {
+          ret = PDF_EEOF;
+          break;
+          loop_end = 1;
+        }
+      }
+    }
+  }
+  if(PDF_OK == ret)
+  {
+    ret = PDF_EEOF;
+  }
+  return ret;
+}
+
+pdf_status_t
+pdf_stm_f_dctdec_dealloc_state (void *state)
+{
+  pdf_stm_f_dctdec_t dctdec_state = (pdf_stm_f_dctdec_t) state;
+
+  jpeg_finish_decompress(&dctdec_state->cinfo);
+  jpeg_destroy_decompress(&dctdec_state->cinfo);
+
+  pdf_dealloc (dctdec_state);
+
+  return PDF_OK;
+}
+
+/* Private functions */
+
+/* source manager for decompress */
+struct pdf_stm_f_dct_cache_source_mgr_s{
+  struct jpeg_source_mgr pub; /* public fields */
+
+  pdf_stm_buffer_t cache;
+  pdf_size_t size_to_skip;
+};
+
+typedef struct pdf_stm_f_dct_cache_source_mgr_s *pdf_stm_f_dct_cache_source_mgr_t;
+
+static void
+pdf_stm_f_dctdec_init_source (j_decompress_ptr cinfo)
+{
+}
+
+static boolean
+pdf_stm_f_dctdec_fill_input_buffer (j_decompress_ptr cinfo)
+{
+  /* suspending mode, just return false.*/
+  return FALSE;
+}
+
+static void
+pdf_stm_f_dctdec_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+  if (num_bytes > 0) 
+  {
+    pdf_stm_f_dct_cache_source_mgr_t src = (pdf_stm_f_dct_cache_source_mgr_t ) cinfo->src;
+    long sz_skiped = src->cache->wp - src->cache->rp;
+    if(sz_skiped > num_bytes)
+    {
+      sz_skiped = num_bytes;
+      src->size_to_skip = 0;
+    }
+    src->cache->rp += (pdf_size_t)sz_skiped;
+    src->size_to_skip = num_bytes - sz_skiped;
+    
+    src->pub.next_input_byte = src->cache->data + src->cache->rp;
+    src->pub.bytes_in_buffer = src->cache->wp - src->cache->rp;
+  }
+}
+
+static void
+pdf_stm_f_dctdec_term_source (j_decompress_ptr cinfo)
+{
+}
+
+pdf_status_t
+pdf_stm_f_dctdec_src_fill(j_decompress_ptr cinfo, pdf_stm_buffer_t in)
+{
+  pdf_stm_f_dct_cache_source_mgr_t src = (pdf_stm_f_dct_cache_source_mgr_t ) cinfo->src;
+
+  pdf_size_t bytes_to_copy; 
+
+  if(src->size_to_skip > in->wp - in->rp)
+  {
+    src->size_to_skip -= in->wp - in->rp;
+    in->rp = in->wp;
+    return PDF_ENINPUT;
+  }
+  else
+  {
+    in->rp += src->size_to_skip;
+    src->size_to_skip = 0;
+  }
+
+  bytes_to_copy = src->pub.bytes_in_buffer;
+  if(bytes_to_copy > 0)
+  {
+    /* shift the backtrack data when suspension happens. */
+    memmove(src->cache->data, src->pub.next_input_byte, bytes_to_copy);
+    src->cache->rp = 0;
+    src->cache->wp = bytes_to_copy;
+  }
+
+  bytes_to_copy = PDF_MIN(in->wp - in->rp, src->cache->size - src->cache->wp);
+  if(bytes_to_copy > 0)
+  {
+    memcpy(src->cache->data + src->cache->wp, in->data + in->rp, bytes_to_copy);
+    in->rp += bytes_to_copy;
+    src->cache->wp += bytes_to_copy;
+  }
+
+  src->pub.bytes_in_buffer = src->cache->wp - src->cache->rp;
+  src->pub.next_input_byte = src->cache->data + src->cache->rp;
+  return PDF_OK;
+}
+
+void 
+pdf_stm_f_dctdec_src_fill_eoi(j_decompress_ptr cinfo)
+{
+  pdf_stm_f_dct_cache_source_mgr_t src = (pdf_stm_f_dct_cache_source_mgr_t ) cinfo->src;
+  if (pdf_stm_buffer_eob_p(src->cache) && src->cache->size > 1) 
+  {
+    /* Insert a fake EOI marker */
+    src->cache->rp = 0;
+    src->cache->wp = 2;
+    src->cache->data[0] = (JOCTET) 0xFF;
+    src->cache->data[1] = (JOCTET) JPEG_EOI;
+  }
+  src->pub.bytes_in_buffer = src->cache->wp - src->cache->rp;
+  src->pub.next_input_byte = src->cache->data + src->cache->rp;
+}
+
+static void
+pdf_stm_f_dctdec_jpeg_cache_src (j_decompress_ptr cinfo, pdf_stm_buffer_t cache)
+{
+  pdf_stm_f_dct_cache_source_mgr_t src = (pdf_stm_f_dct_cache_source_mgr_t ) cinfo->src;
+
+  if (cinfo->src == NULL) 
+  {
+    /* first time for this JPEG object? */
+    cinfo->src = (struct jpeg_source_mgr *)
+        (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(struct pdf_stm_f_dct_cache_source_mgr_s));
+    src = (pdf_stm_f_dct_cache_source_mgr_t) cinfo->src;
+  }
+
+  src->cache = cache;
+
+  src->pub.init_source = pdf_stm_f_dctdec_init_source;
+  src->pub.fill_input_buffer = pdf_stm_f_dctdec_fill_input_buffer;
+  src->pub.skip_input_data = pdf_stm_f_dctdec_skip_input_data;
+  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+  src->pub.term_source = pdf_stm_f_dctdec_term_source;
+  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+  src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
+
+static pdf_status_t 
+pdf_stm_f_dctdec_write_ppm_header(j_decompress_ptr cinfo, pdf_stm_buffer_t out)
+{
+  pdf_char_t header[64];
+  pdf_i32_t hlen;
+
+  if(out->size - out->wp < 64)
+  {
+    return PDF_ENOUTPUT;
+  }
+    /* Emit file header */
+  switch (cinfo->out_color_space) {
+    case JCS_GRAYSCALE:
+      /* emit header for raw PGM format */
+
+      sprintf(header, "P5\n%ld %ld\n%d\n",
+          (long) cinfo->output_width, (long) cinfo->output_height,
+          PPM_MAXVAL);
+      break;
+    case JCS_RGB:
+      /* emit header for raw PPM format */
+      sprintf(header, "P6\n%ld %ld\n%d\n",
+             (long) cinfo->output_width, (long) cinfo->output_height,
+             PPM_MAXVAL);
+     break;
+    default:
+     return PDF_ERROR;
+  }
+  hlen = strlen(header);
+  if(hlen > out->size-out->wp)
+  {
+    return PDF_ENOUTPUT;
+  }
+#if 0
+  fwrite(header, hlen, 1, stdout);
+#else
+  memcpy(out->data + out->wp, header, hlen); 
+  out->wp += hlen; 
+#endif
+  return PDF_OK;
+}
+
+/* End of pdf_stm_f_ahex.c */

=== added file 'src/base/pdf-stm-f-dct.h'
--- src/base/pdf-stm-f-dct.h	1970-01-01 00:00:00 +0000
+++ src/base/pdf-stm-f-dct.h	2008-12-19 14:47:04 +0000
@@ -0,0 +1,97 @@
+/* -*- mode: C -*- Time-stamp: "08/11/26 21:21:35 yangchanghua"
+ *
+ *       File:         pdf-stm-f-dct.h
+ *       Date:         Fri Jul 13 17:04:29 2007
+ *
+ *       GNU PDF Library - DCT encoder/decoder
+ *
+ */
+
+/* Copyright (C) 2007, 2008 Free Software Foundation, Inc. */
+
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PDF_STM_F_DCT_H
+#define PDF_STM_F_DCT_H
+
+#include <config.h>
+#include <pdf-types.h>
+#include <pdf-hash.h>
+#include <pdf-stm-buffer.h>
+#include <jpeglib.h>
+
+enum pdf_stm_f_dctstate_t
+{
+  DCTDEC_STATE_INIT,
+  DCTDEC_STATE_CACHE,
+  DCTDEC_STATE_READHDR,
+  DCTDEC_STATE_WRITEHDR,
+  DCTDEC_STATE_STARTDJP,
+  DCTDEC_STATE_SCANLINE,
+  DCTDEC_STATE_FINISHDJP,
+  DCTDEC_STATE_ERROR
+};
+/* Internal state */
+struct pdf_stm_f_dctenc_s
+{
+};
+
+typedef struct pdf_stm_f_dctenc_s *pdf_stm_f_dctenc_t;
+
+struct pdf_stm_f_dctdec_s
+{
+  struct jpeg_decompress_struct cinfo;
+  struct jpeg_error_mgr jerr;
+
+  enum pdf_stm_f_dctstate_t  state;
+  enum pdf_stm_f_dctstate_t  backup_state;
+
+  /* image cache for input data */
+  pdf_stm_buffer_t djpeg_in;
+  pdf_stm_buffer_t djpeg_out;
+
+  /* cache for output data */
+  pdf_size_t row_stride;
+  pdf_char_t **row_buf;
+  pdf_size_t row_valid_size;
+  pdf_size_t row_copy_index;
+  pdf_u32_t num_scanlines;
+};
+
+typedef struct pdf_stm_f_dctdec_s *pdf_stm_f_dctdec_t;
+
+/* Filters implementation API */
+
+pdf_status_t pdf_stm_f_dctdec_init (pdf_hash_t params,
+                                     void **state);
+pdf_status_t pdf_stm_f_dctdec_apply (pdf_hash_t params,
+                                      void *state,
+                                      pdf_stm_buffer_t in,
+                                      pdf_stm_buffer_t out,
+                                      pdf_bool_t finish_p);
+pdf_status_t pdf_stm_f_dctdec_dealloc_state (void *state);
+
+pdf_status_t pdf_stm_f_dctenc_init (pdf_hash_t params,
+                                     void **state);
+pdf_status_t pdf_stm_f_dctenc_apply (pdf_hash_t params,
+                                      void *state,
+                                      pdf_stm_buffer_t in,
+                                      pdf_stm_buffer_t out,
+                                      pdf_bool_t finish_p);
+pdf_status_t pdf_stm_f_dctenc_dealloc_state (void *state);
+
+#endif /* pdf_stm_f_dct.h */
+
+/* End of pdf_stm_f_dct.h */

=== modified file 'src/base/pdf-stm-filter.c'
--- src/base/pdf-stm-filter.c	2008-12-08 19:03:28 +0000
+++ src/base/pdf-stm-filter.c	2008-12-14 05:27:04 +0000
@@ -126,6 +126,15 @@
         break;
       }
 #endif /* HAVE_JBIG2DEC */
+#if defined(HAVE_JPEGLIB)
+    case PDF_STM_FILTER_DCT_DEC:
+      {
+        new->impl.init_fn = pdf_stm_f_dctdec_init;
+        new->impl.apply_fn = pdf_stm_f_dctdec_apply;
+        new->impl.dealloc_state_fn = pdf_stm_f_dctdec_dealloc_state;
+        break;
+      }
+#endif /* HAVE_JPEGLIB */
     default:
       {
         /* Shall not be reached, but makes the compiler happy */

=== modified file 'src/base/pdf-stm-filter.h'
--- src/base/pdf-stm-filter.h	2008-11-29 16:21:37 +0000
+++ src/base/pdf-stm-filter.h	2008-12-14 05:27:04 +0000
@@ -43,6 +43,9 @@
 #if defined(HAVE_JBIG2DEC)
 #  include <pdf-stm-f-jbig2.h>
 #endif /* HAVE_JBIG2DEC */
+#if defined(HAVE_JPEGLIB)
+#  include <pdf-stm-f-dct.h>
+#endif /* HAVE_JPEGLIB */
 
 /* BEGIN PUBLIC */
 
@@ -56,7 +59,8 @@
   PDF_STM_FILTER_RL_DEC,
   PDF_STM_FILTER_FLATE_ENC,
   PDF_STM_FILTER_FLATE_DEC,
-  PDF_STM_FILTER_JBIG2_DEC
+  PDF_STM_FILTER_JBIG2_DEC,
+  PDF_STM_FILTER_DCT_DEC
 };
 
 /* END PUBLIC */

=== modified file 'utils/pdf-filter.c'
--- utils/pdf-filter.c	2008-11-24 16:08:33 +0000
+++ utils/pdf-filter.c	2008-12-14 05:27:04 +0000
@@ -474,6 +474,40 @@
 #endif /* HAVE_JBIG2DEC */
         case DCTDEC_FILTER_ARG:
           {
+            ret = pdf_hash_new (NULL, &filter_params);
+            if (ret != PDF_OK)
+              {
+                pdf_error (ret, stderr, "while creating the dctdec filter parameters hash table");
+                exit (1);
+              }
+
+            if (jbig2dec_global_segments != NULL)
+              {
+                pdf_size_t *size;
+
+                pdf_hash_add (filter_params,
+                              "GlobalStreamsBuffer",
+                              (const void *) &jbig2dec_global_segments,
+                              NULL);
+
+                size = pdf_alloc (sizeof(pdf_size_t));
+                *size = jbig2dec_global_segments_size;
+                pdf_hash_add (filter_params,
+                              "GlobalStreamsSize",
+                              (const void *) size,
+                              NULL);
+              }
+
+
+            pdf_stm_install_filter (stm,
+                                    PDF_STM_FILTER_DCT_DEC,
+                                    filter_params);
+
+            /* Note that a reference to this memory remains into the
+               stream */
+            jbig2dec_global_segments = NULL;
+            jbig2dec_global_segments_size = 0;
+
             break;
           }
         case JXPDEC_FILTER_ARG:

# Begin bundle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