Page principale   Liste des namespaces   Hiérarchie des classes   Liste par ordre alphabétique   Liste des composants   Liste des fichiers   Membres des namespaces   Composants   Déclarations  

jpeglib.h

Aller à la documentation de ce fichier.
00001 /*
00002  * jpeglib.h
00003  *
00004  * Copyright (C) 1991-1998, Thomas G. Lane.
00005  * This file is part of the Independent JPEG Group's software.
00006  * For conditions of distribution and use, see the accompanying README file.
00007  * Visit the website at: http://www.ijg.org/
00008  *
00009  * This file defines the application interface for the JPEG library.
00010  * Most applications using the library need only include this file,
00011  * and perhaps jerror.h if they want to know the exact error codes.
00012  */
00013 
00014 #ifndef JPEGLIB_H
00015 #define JPEGLIB_H
00016 
00017 
00018 /*
00019  * First we include the configuration files that record how this
00020  * installation of the JPEG library is set up.  jconfig.h can be
00021  * generated automatically for many systems.  jmorecfg.h contains
00022  * manual configuration options that most people need not worry about.
00023  */
00024 
00025 #ifndef JCONFIG_INCLUDED        /* in case jinclude.h already did */
00026 
00027 #include <stdio.h>
00028 #include <stdlib.h>
00029 #include <iostream.h>
00030 #include <string.h>
00031 #include <stdarg.h>
00032 #include <math.h>
00033 #include <malloc.h>
00034 #include <string.h>
00035 #include <tchar.h>
00036 #include <windows.h>
00037 /*
00038  * jconfig.doc
00039  *
00040  * Copyright (C) 1991-1994, Thomas G. Lane.
00041  * This file is part of the Independent JPEG Group's software.
00042  * For conditions of distribution and use, see the accompanying README file.
00043  *
00044  * This file documents the configuration options that are required to
00045  * customize the JPEG software for a particular system.
00046  *
00047  * The actual configuration options for a particular installation are stored
00048  * in jconfig.h.  On many machines, jconfig.h can be generated automatically
00049  * or copied from one of the "canned" jconfig files that we supply.  But if
00050  * you need to generate a jconfig.h file by hand, this file tells you how.
00051  *
00052  * DO NOT EDIT THIS FILE --- IT WON'T ACCOMPLISH ANYTHING.
00053  * EDIT A COPY NAMED JCONFIG.H.
00054  */
00055 
00056 
00057 /*
00058  * These symbols indicate the properties of your machine or compiler.
00059  * #define the symbol if yes, #undef it if no.
00060  */
00061 
00062 /* Does your compiler support function prototypes?
00063  * (If not, you also need to use ansi2knr, see install.doc)
00064  */
00065 #define HAVE_PROTOTYPES
00066 
00067 /* Does your compiler support the declaration "unsigned char" ?
00068  * How about "unsigned short" ?
00069  */
00070 #define HAVE_UNSIGNED_CHAR
00071 #define HAVE_UNSIGNED_SHORT
00072 
00073 /* Define "void" as "char" if your compiler doesn't know about type void.
00074  * NOTE: be sure to define void such that "void *" represents the most general
00075  * pointer type, e.g., that returned by malloc().
00076  */
00077 /* #define void char */
00078 
00079 /* Define "const" as empty if your compiler doesn't know the "const" keyword.
00080  */
00081 /* #define const */
00082 
00083 /* Define this if an ordinary "char" type is unsigned.
00084  * If you're not sure, leaving it undefined will work at some cost in speed.
00085  * If you defined HAVE_UNSIGNED_CHAR then the speed difference is minimal.
00086  */
00087 #undef CHAR_IS_UNSIGNED
00088 
00089 /* Define this if your system has an ANSI-conforming <stddef.h> file.
00090  */
00091 #define HAVE_STDDEF_H
00092 
00093 /* Define this if your system has an ANSI-conforming <stdlib.h> file.
00094  */
00095 #define HAVE_STDLIB_H
00096 
00097 /* Define this if your system does not have an ANSI/SysV <string.h>,
00098  * but does have a BSD-style <strings.h>.
00099  */
00100 #undef NEED_BSD_STRINGS
00101 
00102 /* Define this if your system does not provide typedef size_t in any of the
00103  * ANSI-standard places (stddef.h, stdlib.h, or stdio.h), but places it in
00104  * <sys/types.h> instead.
00105  */
00106 #undef NEED_SYS_TYPES_H
00107 
00108 /* For 80x86 machines, you need to define NEED_FAR_POINTERS,
00109  * unless you are using a large-data memory model or 80386 flat-memory mode.
00110  * On less brain-damaged CPUs this symbol must not be defined.
00111  * (Defining this symbol causes large data structures to be referenced through
00112  * "far" pointers and to be allocated with a special version of malloc.)
00113  */
00114 #undef NEED_FAR_POINTERS
00115 
00116 /* Define this if your linker needs global names to be unique in less
00117  * than the first 15 characters.
00118  */
00119 #undef NEED_SHORT_EXTERNAL_NAMES
00120 
00121 /* Although a real ANSI C compiler can deal perfectly well with pointers to
00122  * unspecified structures (see "incomplete types" in the spec), a few pre-ANSI
00123  * and pseudo-ANSI compilers get confused.  To keep one of these bozos happy,
00124  * define INCOMPLETE_TYPES_BROKEN.  This is not recommended unless you
00125  * actually get "missing structure definition" warnings or errors while
00126  * compiling the JPEG code.
00127  */
00128 #undef INCOMPLETE_TYPES_BROKEN
00129 
00130 
00131 /*
00132  * The following options affect code selection within the JPEG library,
00133  * but they don't need to be visible to applications using the library.
00134  * To minimize application namespace pollution, the symbols won't be
00135  * defined unless JPEG_INTERNALS has been defined.
00136  */
00137 
00138 #ifdef JPEG_INTERNALS
00139 
00140 /* Define this if your compiler implements ">>" on signed values as a logical
00141  * (unsigned) shift; leave it undefined if ">>" is a signed (arithmetic) shift,
00142  * which is the normal and rational definition.
00143  */
00144 #undef RIGHT_SHIFT_IS_UNSIGNED
00145 
00146 
00147 #endif /* JPEG_INTERNALS */
00148 
00149 
00150 /*
00151  * The remaining options do not affect the JPEG library proper,
00152  * but only the sample applications cjpeg/djpeg (see cjpeg.c, djpeg.c).
00153  * Other applications can ignore these.
00154  */
00155 
00156 #ifdef JPEG_CJPEG_DJPEG
00157 
00158 /* These defines indicate which image (non-JPEG) file formats are allowed. */
00159 
00160 #define BMP_SUPPORTED           /* BMP image file format */
00161 #define GIF_SUPPORTED           /* GIF image file format */
00162 #define PPM_SUPPORTED           /* PBMPLUS PPM/PGM image file format */
00163 #undef RLE_SUPPORTED            /* Utah RLE image file format */
00164 #define TARGA_SUPPORTED         /* Targa image file format */
00165 
00166 /* Define this if you want to name both input and output files on the command
00167  * line, rather than using stdout and optionally stdin.  You MUST do this if
00168  * your system can't cope with binary I/O to stdin/stdout.  See comments at
00169  * head of cjpeg.c or djpeg.c.
00170  */
00171 #undef TWO_FILE_COMMANDLINE
00172 
00173 /* Define this if your system needs explicit cleanup of temporary files.
00174  * This is crucial under MS-DOS, where the temporary "files" may be areas
00175  * of extended memory; on most other systems it's not as important.
00176  */
00177 #undef NEED_SIGNAL_CATCHER
00178 
00179 /* By default, we open image files with fopen(...,"rb") or fopen(...,"wb").
00180  * This is necessary on systems that distinguish text files from binary files,
00181  * and is harmless on most systems that don't.  If you have one of the rare
00182  * systems that complains about the "b" spec, define this symbol.
00183  */
00184 #undef DONT_USE_B_MODE
00185 
00186 /* Define this if you want percent-done progress reports from cjpeg/djpeg.
00187  */
00188 #undef PROGRESS_REPORT
00189 
00190 #define HAVE_BOOLEAN
00191 
00192 #endif /* JPEG_CJPEG_DJPEG */
00193 
00194 #endif /* ifndef JCONFIG_INCLUDED */
00195 
00196 /*
00197  * Define BITS_IN_JSAMPLE as either
00198  *   8   for 8-bit sample values (the usual setting)
00199  *   12  for 12-bit sample values
00200  * Only 8 and 12 are legal data precisions for lossy JPEG according to the
00201  * JPEG standard, and the IJG code does not support anything else!
00202  * We do not support run-time selection of data precision, sorry.
00203  */
00204 
00205 #define BITS_IN_JSAMPLE  8      /* use 8 or 12 */
00206 
00207 
00208 /*
00209  * Maximum number of components (color channels) allowed in JPEG image.
00210  * To meet the letter of the JPEG spec, set this to 255.  However, darn
00211  * few applications need more than 4 channels (maybe 5 for CMYK + alpha
00212  * mask).  We recommend 10 as a reasonable compromise; use 4 if you are
00213  * really short on memory.  (Each allowed component costs a hundred or so
00214  * bytes of storage, whether actually used in an image or not.)
00215  */
00216 
00217 #define MAX_COMPONENTS  10      /* maximum number of image components */
00218 
00219 
00220 /*
00221  * Basic data types.
00222  * You may need to change these if you have a machine with unusual data
00223  * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
00224  * or "long" not 32 bits.  We don't care whether "int" is 16 or 32 bits,
00225  * but it had better be at least 16.
00226  */
00227 
00228 /* Representation of a single sample (pixel element value).
00229  * We frequently allocate large arrays of these, so it's important to keep
00230  * them small.  But if you have memory to burn and access to char or short
00231  * arrays is very slow on your hardware, you might want to change these.
00232  */
00233 
00234 #if BITS_IN_JSAMPLE == 8
00235 /* JSAMPLE should be the smallest type that will hold the values 0..255.
00236  * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
00237  */
00238 
00239 #ifdef HAVE_UNSIGNED_CHAR
00240 
00241 typedef unsigned char JSAMPLE;
00242 #define GETJSAMPLE(value)  ((int) (value))
00243 
00244 #else /* not HAVE_UNSIGNED_CHAR */
00245 
00246 typedef char JSAMPLE;
00247 #ifdef CHAR_IS_UNSIGNED
00248 #define GETJSAMPLE(value)  ((int) (value))
00249 #else
00250 #define GETJSAMPLE(value)  ((int) (value) & 0xFF)
00251 #endif /* CHAR_IS_UNSIGNED */
00252 
00253 #endif /* HAVE_UNSIGNED_CHAR */
00254 
00255 #define MAXJSAMPLE      255
00256 #define CENTERJSAMPLE   128
00257 
00258 #endif /* BITS_IN_JSAMPLE == 8 */
00259 
00260 
00261 #if BITS_IN_JSAMPLE == 12
00262 /* JSAMPLE should be the smallest type that will hold the values 0..4095.
00263  * On nearly all machines "short" will do nicely.
00264  */
00265 
00266 typedef short JSAMPLE;
00267 #define GETJSAMPLE(value)  ((int) (value))
00268 
00269 #define MAXJSAMPLE      4095
00270 #define CENTERJSAMPLE   2048
00271 
00272 #endif /* BITS_IN_JSAMPLE == 12 */
00273 
00274 
00275 /* Representation of a DCT frequency coefficient.
00276  * This should be a signed value of at least 16 bits; "short" is usually OK.
00277  * Again, we allocate large arrays of these, but you can change to int
00278  * if you have memory to burn and "short" is really slow.
00279  */
00280 
00281 typedef short JCOEF;
00282 
00283 
00284 /* Compressed datastreams are represented as arrays of JOCTET.
00285  * These must be EXACTLY 8 bits wide, at least once they are written to
00286  * external storage.  Note that when using the stdio data source/destination
00287  * managers, this is also the data type passed to fread/fwrite.
00288  */
00289 
00290 #ifdef HAVE_UNSIGNED_CHAR
00291 
00292 typedef unsigned char JOCTET;
00293 #define GETJOCTET(value)  (value)
00294 
00295 #else /* not HAVE_UNSIGNED_CHAR */
00296 
00297 typedef char JOCTET;
00298 #ifdef CHAR_IS_UNSIGNED
00299 #define GETJOCTET(value)  (value)
00300 #else
00301 #define GETJOCTET(value)  ((value) & 0xFF)
00302 #endif /* CHAR_IS_UNSIGNED */
00303 
00304 #endif /* HAVE_UNSIGNED_CHAR */
00305 
00306 
00307 /* These typedefs are used for various table entries and so forth.
00308  * They must be at least as wide as specified; but making them too big
00309  * won't cost a huge amount of memory, so we don't provide special
00310  * extraction code like we did for JSAMPLE.  (In other words, these
00311  * typedefs live at a different point on the speed/space tradeoff curve.)
00312  */
00313 
00314 /* UINT8 must hold at least the values 0..255. */
00315 
00316 #ifdef HAVE_UNSIGNED_CHAR
00317 typedef unsigned char UINT8;
00318 #else /* not HAVE_UNSIGNED_CHAR */
00319 #ifdef CHAR_IS_UNSIGNED
00320 typedef char UINT8;
00321 #else /* not CHAR_IS_UNSIGNED */
00322 typedef short UINT8;
00323 #endif /* CHAR_IS_UNSIGNED */
00324 #endif /* HAVE_UNSIGNED_CHAR */
00325 
00326 /* UINT16 must hold at least the values 0..65535. */
00327 
00328 #ifdef HAVE_UNSIGNED_SHORT
00329 typedef unsigned short UINT16;
00330 #else /* not HAVE_UNSIGNED_SHORT */
00331 typedef unsigned int UINT16;
00332 #endif /* HAVE_UNSIGNED_SHORT */
00333 
00334 /* INT16 must hold at least the values -32768..32767. */
00335 
00336 #ifndef XMD_H                   /* X11/xmd.h correctly defines INT16 */
00337 typedef short INT16;
00338 #endif
00339 
00340 /* INT32 must hold at least signed 32-bit values. */
00341 
00342 #ifdef NEED_INT32                       /* X11/xmd.h correctly defines INT32 */
00343 typedef long INT32;
00344 #endif
00345 
00346 /* Datatype used for image dimensions.  The JPEG standard only supports
00347  * images up to 64K*64K due to 16-bit fields in SOF markers.  Therefore
00348  * "unsigned int" is sufficient on all machines.  However, if you need to
00349  * handle larger images and you don't mind deviating from the spec, you
00350  * can change this datatype.
00351  */
00352 
00353 typedef unsigned int JDIMENSION;
00354 
00355 #define JPEG_MAX_DIMENSION  65500L  /* a tad under 64K to prevent overflows */
00356 
00357 
00358 /* These macros are used in all function definitions and extern declarations.
00359  * You could modify them if you need to change function linkage conventions;
00360  * in particular, you'll need to do that to make the library a Windows DLL.
00361  * Another application is to make all functions global for use with debuggers
00362  * or code profilers that require it.
00363  */
00364 
00365 /* a function called through method pointers: */
00366 #define METHODDEF(type)         static type
00367 /* a function used only in its module: */
00368 #define LOCAL(type)             static type
00369 /* a function referenced thru EXTERNs: */
00370 #define GLOBAL(type)            type
00371 /* a reference to a GLOBAL function: */
00372 #define EXTERN(type)            extern type
00373 
00374 
00375 /* This macro is used to declare a "method", that is, a function pointer.
00376  * We want to supply prototype parameters if the compiler can cope.
00377  * Note that the arglist parameter must be parenthesized!
00378  * Again, you can customize this if you need special linkage keywords.
00379  */
00380 
00381 #ifdef HAVE_PROTOTYPES
00382 #define JMETHOD(type,methodname,arglist)  type (*methodname) arglist
00383 #else
00384 #define JMETHOD(type,methodname,arglist)  type (*methodname) ()
00385 #endif
00386 
00387 
00388 /* Here is the pseudo-keyword for declaring pointers that must be "far"
00389  * on 80x86 machines.  Most of the specialized coding for 80x86 is handled
00390  * by just saying "FAR *" where such a pointer is needed.  In a few places
00391  * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
00392  */
00393 
00394 #ifdef NEED_FAR_POINTERS
00395 #define FAR  far
00396 #else
00397 //#define FAR
00398 #endif
00399 
00400 
00401 /*
00402  * On a few systems, type boolean and/or its values FALSE, TRUE may appear
00403  * in standard header files.  Or you may have conflicts with application-
00404  * specific header files that you want to include together with these files.
00405  * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
00406  */
00407 
00408 #ifndef HAVE_BOOLEAN
00409 //typedef int boolean;
00410 #endif
00411 #ifndef FALSE                   /* in case these macros already exist */
00412 #define FALSE   0               /* values of boolean */
00413 #endif
00414 #ifndef TRUE
00415 #define TRUE    1
00416 #endif
00417 
00418 
00419 /*
00420  * The remaining options affect code selection within the JPEG library,
00421  * but they don't need to be visible to most applications using the library.
00422  * To minimize application namespace pollution, the symbols won't be
00423  * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
00424  */
00425 
00426 #ifdef JPEG_INTERNALS
00427 #define JPEG_INTERNAL_OPTIONS
00428 #endif
00429 
00430 #ifdef JPEG_INTERNAL_OPTIONS
00431 
00432 
00433 /*
00434  * These defines indicate whether to include various optional functions.
00435  * Undefining some of these symbols will produce a smaller but less capable
00436  * library.  Note that you can leave certain source files out of the
00437  * compilation/linking process if you've #undef'd the corresponding symbols.
00438  * (You may HAVE to do that if your compiler doesn't like null source files.)
00439  */
00440 
00441 /* Arithmetic coding is unsupported for legal reasons.  Complaints to IBM. */
00442 
00443 /* Capability options common to encoder and decoder: */
00444 
00445 #define DCT_ISLOW_SUPPORTED     /* slow but accurate integer algorithm */
00446 #define DCT_IFAST_SUPPORTED     /* faster, less accurate integer method */
00447 #define DCT_FLOAT_SUPPORTED     /* floating-point: accurate, fast on fast HW */
00448 
00449 /* Encoder capability options: */
00450 
00451 #undef  C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
00452 #define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
00453 #define C_PROGRESSIVE_SUPPORTED     /* Progressive JPEG? (Requires MULTISCAN)*/
00454 #define ENTROPY_OPT_SUPPORTED       /* Optimization of entropy coding parms? */
00455 /* Note: if you selected 12-bit data precision, it is dangerous to turn off
00456  * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit
00457  * precision, so jchuff.c normally uses entropy optimization to compute
00458  * usable tables for higher precision.  If you don't want to do optimization,
00459  * you'll have to supply different default Huffman tables.
00460  * The exact same statements apply for progressive JPEG: the default tables
00461  * don't work for progressive mode.  (This may get fixed, however.)
00462  */
00463 #define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */
00464 
00465 /* Decoder capability options: */
00466 
00467 #undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
00468 #define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
00469 #define D_PROGRESSIVE_SUPPORTED     /* Progressive JPEG? (Requires MULTISCAN)*/
00470 #define SAVE_MARKERS_SUPPORTED      /* jpeg_save_markers() needed? */
00471 #define BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
00472 #define IDCT_SCALING_SUPPORTED      /* Output rescaling via IDCT? */
00473 #undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
00474 #define UPSAMPLE_MERGING_SUPPORTED  /* Fast path for sloppy upsampling? */
00475 #define QUANT_1PASS_SUPPORTED       /* 1-pass color quantization? */
00476 #define QUANT_2PASS_SUPPORTED       /* 2-pass color quantization? */
00477 
00478 /* more capability options later, no doubt */
00479 
00480 
00481 /*
00482  * Ordering of RGB data in scanlines passed to or from the application.
00483  * If your application wants to deal with data in the order B,G,R, just
00484  * change these macros.  You can also deal with formats such as R,G,B,X
00485  * (one extra byte per pixel) by changing RGB_PIXELSIZE.  Note that changing
00486  * the offsets will also change the order in which colormap data is organized.
00487  * RESTRICTIONS:
00488  * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
00489  * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
00490  *    useful if you are using JPEG color spaces other than YCbCr or grayscale.
00491  * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
00492  *    is not 3 (they don't understand about dummy color components!).  So you
00493  *    can't use color quantization if you change that value.
00494  */
00495 
00496 #define RGB_RED         0       /* Offset of Red in an RGB scanline element */
00497 #define RGB_GREEN       1       /* Offset of Green */
00498 #define RGB_BLUE        2       /* Offset of Blue */
00499 #define RGB_PIXELSIZE   3       /* JSAMPLEs per RGB scanline element */
00500 
00501 
00502 /* Definitions for speed-related optimizations. */
00503 
00504 
00505 /* If your compiler supports inline functions, define INLINE
00506  * as the inline keyword; otherwise define it as empty.
00507  */
00508 
00509 #ifndef INLINE
00510 #ifdef __GNUC__                 /* for instance, GNU C knows about inline */
00511 #define INLINE __inline__
00512 #endif
00513 #ifndef INLINE
00514 #define INLINE                  /* default is to define it as empty */
00515 #endif
00516 #endif
00517 
00518 
00519 /* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
00520  * two 16-bit shorts is faster than multiplying two ints.  Define MULTIPLIER
00521  * as short on such a machine.  MULTIPLIER must be at least 16 bits wide.
00522  */
00523 
00524 #ifndef MULTIPLIER
00525 #define MULTIPLIER  int         /* type for fastest integer multiply */
00526 #endif
00527 
00528 
00529 /* FAST_FLOAT should be either float or double, whichever is done faster
00530  * by your compiler.  (Note that this type is only used in the floating point
00531  * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
00532  * Typically, float is faster in ANSI C compilers, while double is faster in
00533  * pre-ANSI compilers (because they insist on converting to double anyway).
00534  * The code below therefore chooses float if we have ANSI-style prototypes.
00535  */
00536 
00537 #ifndef FAST_FLOAT
00538 #ifdef HAVE_PROTOTYPES
00539 #define FAST_FLOAT  float
00540 #else
00541 #define FAST_FLOAT  double
00542 #endif
00543 #endif
00544 
00545 #endif /* JPEG_INTERNAL_OPTIONS */
00546 
00547 
00548 #if defined(__cplusplus)
00549 extern "C" {
00550 #endif
00551 
00552 
00553 /* Version ID for the JPEG library.
00554  * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
00555  */
00556 
00557 #define JPEG_LIB_VERSION  62    /* Version 6b */
00558 
00559 
00560 /* Various constants determining the sizes of things.
00561  * All of these are specified by the JPEG standard, so don't change them
00562  * if you want to be compatible.
00563  */
00564 
00565 #define DCTSIZE             8   /* The basic DCT block is 8x8 samples */
00566 #define DCTSIZE2            64  /* DCTSIZE squared; # of elements in a block */
00567 #define NUM_QUANT_TBLS      4   /* Quantization tables are numbered 0..3 */
00568 #define NUM_HUFF_TBLS       4   /* Huffman tables are numbered 0..3 */
00569 #define NUM_ARITH_TBLS      16  /* Arith-coding tables are numbered 0..15 */
00570 #define MAX_COMPS_IN_SCAN   4   /* JPEG limit on # of components in one scan */
00571 #define MAX_SAMP_FACTOR     4   /* JPEG limit on sampling factors */
00572 /* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
00573  * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
00574  * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
00575  * to handle it.  We even let you do this from the jconfig.h file.  However,
00576  * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
00577  * sometimes emits noncompliant files doesn't mean you should too.
00578  */
00579 #define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
00580 #ifndef D_MAX_BLOCKS_IN_MCU
00581 #define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
00582 #endif
00583 
00584 
00585 /* Data structures for images (arrays of samples and of DCT coefficients).
00586  * On 80x86 machines, the image arrays are too big for near pointers,
00587  * but the pointer arrays can fit in near memory.
00588  */
00589 
00590 typedef JSAMPLE FAR *JSAMPROW;  /* ptr to one image row of pixel samples. */
00591 typedef JSAMPROW *JSAMPARRAY;   /* ptr to some rows (a 2-D sample array) */
00592 typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */
00593 
00594 typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
00595 typedef JBLOCK FAR *JBLOCKROW;  /* pointer to one row of coefficient blocks */
00596 typedef JBLOCKROW *JBLOCKARRAY;         /* a 2-D array of coefficient blocks */
00597 typedef JBLOCKARRAY *JBLOCKIMAGE;       /* a 3-D array of coefficient blocks */
00598 
00599 typedef JCOEF FAR *JCOEFPTR;    /* useful in a couple of places */
00600 
00601 
00602 /* Types for JPEG compression parameters and working tables. */
00603 
00604 
00605 /* DCT coefficient quantization tables. */
00606 
00607 typedef struct {
00608   /* This array gives the coefficient quantizers in natural array order
00609    * (not the zigzag order in which they are stored in a JPEG DQT marker).
00610    * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
00611    */
00612   UINT16 quantval[DCTSIZE2];    /* quantization step for each coefficient */
00613   /* This field is used only during compression.  It's initialized FALSE when
00614    * the table is created, and set TRUE when it's been output to the file.
00615    * You could suppress output of a table by setting this to TRUE.
00616    * (See jpeg_suppress_tables for an example.)
00617    */
00618   boolean sent_table;           /* TRUE when table has been output */
00619 } JQUANT_TBL;
00620 
00621 
00622 /* Huffman coding tables. */
00623 
00624 typedef struct {
00625   /* These two fields directly represent the contents of a JPEG DHT marker */
00626   UINT8 bits[17];               /* bits[k] = # of symbols with codes of */
00627                                 /* length k bits; bits[0] is unused */
00628   UINT8 huffval[256];           /* The symbols, in order of incr code length */
00629   /* This field is used only during compression.  It's initialized FALSE when
00630    * the table is created, and set TRUE when it's been output to the file.
00631    * You could suppress output of a table by setting this to TRUE.
00632    * (See jpeg_suppress_tables for an example.)
00633    */
00634   boolean sent_table;           /* TRUE when table has been output */
00635 } JHUFF_TBL;
00636 
00637 
00638 /* Basic info about one component (color channel). */
00639 
00640 typedef struct {
00641   /* These values are fixed over the whole image. */
00642   /* For compression, they must be supplied by parameter setup; */
00643   /* for decompression, they are read from the SOF marker. */
00644   int component_id;             /* identifier for this component (0..255) */
00645   int component_index;          /* its index in SOF or cinfo->comp_info[] */
00646   int h_samp_factor;            /* horizontal sampling factor (1..4) */
00647   int v_samp_factor;            /* vertical sampling factor (1..4) */
00648   int quant_tbl_no;             /* quantization table selector (0..3) */
00649   /* These values may vary between scans. */
00650   /* For compression, they must be supplied by parameter setup; */
00651   /* for decompression, they are read from the SOS marker. */
00652   /* The decompressor output side may not use these variables. */
00653   int dc_tbl_no;                /* DC entropy table selector (0..3) */
00654   int ac_tbl_no;                /* AC entropy table selector (0..3) */
00655   
00656   /* Remaining fields should be treated as private by applications. */
00657   
00658   /* These values are computed during compression or decompression startup: */
00659   /* Component's size in DCT blocks.
00660    * Any dummy blocks added to complete an MCU are not counted; therefore
00661    * these values do not depend on whether a scan is interleaved or not.
00662    */
00663   JDIMENSION width_in_blocks;
00664   JDIMENSION height_in_blocks;
00665   /* Size of a DCT block in samples.  Always DCTSIZE for compression.
00666    * For decompression this is the size of the output from one DCT block,
00667    * reflecting any scaling we choose to apply during the IDCT step.
00668    * Values of 1,2,4,8 are likely to be supported.  Note that different
00669    * components may receive different IDCT scalings.
00670    */
00671   int DCT_scaled_size;
00672   /* The downsampled dimensions are the component's actual, unpadded number
00673    * of samples at the main buffer (preprocessing/compression interface), thus
00674    * downsampled_width = ceil(image_width * Hi/Hmax)
00675    * and similarly for height.  For decompression, IDCT scaling is included, so
00676    * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
00677    */
00678   JDIMENSION downsampled_width;  /* actual width in samples */
00679   JDIMENSION downsampled_height; /* actual height in samples */
00680   /* This flag is used only for decompression.  In cases where some of the
00681    * components will be ignored (eg grayscale output from YCbCr image),
00682    * we can skip most computations for the unused components.
00683    */
00684   boolean component_needed;     /* do we need the value of this component? */
00685 
00686   /* These values are computed before starting a scan of the component. */
00687   /* The decompressor output side may not use these variables. */
00688   int MCU_width;                /* number of blocks per MCU, horizontally */
00689   int MCU_height;               /* number of blocks per MCU, vertically */
00690   int MCU_blocks;               /* MCU_width * MCU_height */
00691   int MCU_sample_width;         /* MCU width in samples, MCU_width*DCT_scaled_size */
00692   int last_col_width;           /* # of non-dummy blocks across in last MCU */
00693   int last_row_height;          /* # of non-dummy blocks down in last MCU */
00694 
00695   /* Saved quantization table for component; NULL if none yet saved.
00696    * See jdinput.c comments about the need for this information.
00697    * This field is currently used only for decompression.
00698    */
00699   JQUANT_TBL * quant_table;
00700 
00701   /* Private per-component storage for DCT or IDCT subsystem. */
00702   void * dct_table;
00703 } jpeg_component_info;
00704 
00705 
00706 /* The script for encoding a multiple-scan file is an array of these: */
00707 
00708 typedef struct {
00709   int comps_in_scan;            /* number of components encoded in this scan */
00710   int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
00711   int Ss, Se;                   /* progressive JPEG spectral selection parms */
00712   int Ah, Al;                   /* progressive JPEG successive approx. parms */
00713 } jpeg_scan_info;
00714 
00715 /* The decompressor can save APPn and COM markers in a list of these: */
00716 
00717 typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr;
00718 
00719 struct jpeg_marker_struct {
00720   jpeg_saved_marker_ptr next;   /* next in list, or NULL */
00721   UINT8 marker;                 /* marker code: JPEG_COM, or JPEG_APP0+n */
00722   unsigned int original_length; /* # bytes of data in the file */
00723   unsigned int data_length;     /* # bytes of data saved at data[] */
00724   JOCTET FAR * data;            /* the data contained in the marker */
00725   /* the marker length word is not counted in data_length or original_length */
00726 };
00727 
00728 /* Known color spaces. */
00729 
00730 typedef enum {
00731         JCS_UNKNOWN,            /* error/unspecified */
00732         JCS_GRAYSCALE,          /* monochrome */
00733         JCS_RGB,                /* red/green/blue */
00734         JCS_YCbCr,              /* Y/Cb/Cr (also known as YUV) */
00735         JCS_CMYK,               /* C/M/Y/K */
00736         JCS_YCCK                /* Y/Cb/Cr/K */
00737 } J_COLOR_SPACE;
00738 
00739 /* DCT/IDCT algorithm options. */
00740 
00741 typedef enum {
00742         JDCT_ISLOW,             /* slow but accurate integer algorithm */
00743         JDCT_IFAST,             /* faster, less accurate integer method */
00744         JDCT_FLOAT              /* floating-point: accurate, fast on fast HW */
00745 } J_DCT_METHOD;
00746 
00747 #ifndef JDCT_DEFAULT            /* may be overridden in jconfig.h */
00748 #define JDCT_DEFAULT  JDCT_ISLOW
00749 #endif
00750 #ifndef JDCT_FASTEST            /* may be overridden in jconfig.h */
00751 #define JDCT_FASTEST  JDCT_IFAST
00752 #endif
00753 
00754 /* Dithering options for decompression. */
00755 
00756 typedef enum {
00757         JDITHER_NONE,           /* no dithering */
00758         JDITHER_ORDERED,        /* simple ordered dither */
00759         JDITHER_FS              /* Floyd-Steinberg error diffusion dither */
00760 } J_DITHER_MODE;
00761 
00762 
00763 /* Common fields between JPEG compression and decompression master structs. */
00764 
00765 #define jpeg_common_fields \
00766   struct jpeg_error_mgr * err;  /* Error handler module */\
00767   struct jpeg_memory_mgr * mem; /* Memory manager module */\
00768   struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
00769   void * client_data;           /* Available for use by application */\
00770   boolean is_decompressor;      /* So common code can tell which is which */\
00771   int global_state              /* For checking call sequence validity */
00772 
00773 /* Routines that are to be used by both halves of the library are declared
00774  * to receive a pointer to this structure.  There are no actual instances of
00775  * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
00776  */
00777 struct jpeg_common_struct {
00778   jpeg_common_fields;           /* Fields common to both master struct types */
00779   /* Additional fields follow in an actual jpeg_compress_struct or
00780    * jpeg_decompress_struct.  All three structs must agree on these
00781    * initial fields!  (This would be a lot cleaner in C++.)
00782    */
00783 };
00784 
00785 typedef struct jpeg_common_struct * j_common_ptr;
00786 typedef struct jpeg_compress_struct * j_compress_ptr;
00787 typedef struct jpeg_decompress_struct * j_decompress_ptr;
00788 
00789 
00790 /* Master record for a compression instance */
00791 
00792 struct jpeg_compress_struct 
00793 {
00794   jpeg_common_fields;           /* Fields shared with jpeg_decompress_struct */
00795 
00796   /* Destination for compressed data */
00797   struct jpeg_destination_mgr * dest;
00798 
00799   /* Description of source image --- these fields must be filled in by
00800    * outer application before starting compression.  in_color_space must
00801    * be correct before you can even call jpeg_set_defaults().
00802    */
00803 
00804   JDIMENSION image_width;       /* input image width */
00805   JDIMENSION image_height;      /* input image height */
00806   int input_components;         /* # of color components in input image */
00807   J_COLOR_SPACE in_color_space; /* colorspace of input image */
00808 
00809   double input_gamma;           /* image gamma of input image */
00810 
00811   /* Compression parameters --- these fields must be set before calling
00812    * jpeg_start_compress().  We recommend calling jpeg_set_defaults() to
00813    * initialize everything to reasonable defaults, then changing anything
00814    * the application specifically wants to change.  That way you won't get
00815    * burnt when new parameters are added.  Also note that there are several
00816    * helper routines to simplify changing parameters.
00817    */
00818 
00819   int data_precision;           /* bits of precision in image data */
00820 
00821   int num_components;           /* # of color components in JPEG image */
00822   J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
00823 
00824   jpeg_component_info * comp_info;
00825   /* comp_info[i] describes component that appears i'th in SOF */
00826   
00827   JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
00828   /* ptrs to coefficient quantization tables, or NULL if not defined */
00829   
00830   JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
00831   JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
00832   /* ptrs to Huffman coding tables, or NULL if not defined */
00833   
00834   UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
00835   UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
00836   UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
00837 
00838   int num_scans;                /* # of entries in scan_info array */
00839   const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
00840   /* The default value of scan_info is NULL, which causes a single-scan
00841    * sequential JPEG file to be emitted.  To create a multi-scan file,
00842    * set num_scans and scan_info to point to an array of scan definitions.
00843    */
00844 
00845   boolean raw_data_in;          /* TRUE=caller supplies downsampled data */
00846   boolean arith_code;           /* TRUE=arithmetic coding, FALSE=Huffman */
00847   boolean optimize_coding;      /* TRUE=optimize entropy encoding parms */
00848   boolean CCIR601_sampling;     /* TRUE=first samples are cosited */
00849   int smoothing_factor;         /* 1..100, or 0 for no input smoothing */
00850   J_DCT_METHOD dct_method;      /* DCT algorithm selector */
00851 
00852   /* The restart interval can be specified in absolute MCUs by setting
00853    * restart_interval, or in MCU rows by setting restart_in_rows
00854    * (in which case the correct restart_interval will be figured
00855    * for each scan).
00856    */
00857   unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
00858   int restart_in_rows;          /* if > 0, MCU rows per restart interval */
00859 
00860   /* Parameters controlling emission of special markers. */
00861 
00862   boolean write_JFIF_header;    /* should a JFIF marker be written? */
00863   UINT8 JFIF_major_version;     /* What to write for the JFIF version number */
00864   UINT8 JFIF_minor_version;
00865   /* These three values are not used by the JPEG code, merely copied */
00866   /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
00867   /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
00868   /* ratio is defined by X_density/Y_density even when density_unit=0. */
00869   UINT8 density_unit;           /* JFIF code for pixel size units */
00870   UINT16 X_density;             /* Horizontal pixel density */
00871   UINT16 Y_density;             /* Vertical pixel density */
00872   boolean write_Adobe_marker;   /* should an Adobe marker be written? */
00873   
00874   /* State variable: index of next scanline to be written to
00875    * jpeg_write_scanlines().  Application may use this to control its
00876    * processing loop, e.g., "while (next_scanline < image_height)".
00877    */
00878 
00879   JDIMENSION next_scanline;     /* 0 .. image_height-1  */
00880 
00881   /* Remaining fields are known throughout compressor, but generally
00882    * should not be touched by a surrounding application.
00883    */
00884 
00885   /*
00886    * These fields are computed during compression startup
00887    */
00888   boolean progressive_mode;     /* TRUE if scan script uses progressive mode */
00889   int max_h_samp_factor;        /* largest h_samp_factor */
00890   int max_v_samp_factor;        /* largest v_samp_factor */
00891 
00892   JDIMENSION total_iMCU_rows;   /* # of iMCU rows to be input to coef ctlr */
00893   /* The coefficient controller receives data in units of MCU rows as defined
00894    * for fully interleaved scans (whether the JPEG file is interleaved or not).
00895    * There are v_samp_factor * DCTSIZE sample rows of each component in an
00896    * "iMCU" (interleaved MCU) row.
00897    */
00898   
00899   /*
00900    * These fields are valid during any one scan.
00901    * They describe the components and MCUs actually appearing in the scan.
00902    */
00903   int comps_in_scan;            /* # of JPEG components in this scan */
00904   jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
00905   /* *cur_comp_info[i] describes component that appears i'th in SOS */
00906   
00907   JDIMENSION MCUs_per_row;      /* # of MCUs across the image */
00908   JDIMENSION MCU_rows_in_scan;  /* # of MCU rows in the image */
00909   
00910   int blocks_in_MCU;            /* # of DCT blocks per MCU */
00911   int MCU_membership[C_MAX_BLOCKS_IN_MCU];
00912   /* MCU_membership[i] is index in cur_comp_info of component owning */
00913   /* i'th block in an MCU */
00914 
00915   int Ss, Se, Ah, Al;           /* progressive JPEG parameters for scan */
00916 
00917   /*
00918    * Links to compression subobjects (methods and private variables of modules)
00919    */
00920   struct jpeg_comp_master * master;
00921   struct jpeg_c_main_controller * main;
00922   struct jpeg_c_prep_controller * prep;
00923   struct jpeg_c_coef_controller * coef;
00924   struct jpeg_marker_writer * marker;
00925   struct jpeg_color_converter * cconvert;
00926   struct jpeg_downsampler * downsample;
00927   struct jpeg_forward_dct * fdct;
00928   struct jpeg_entropy_encoder * entropy;
00929   jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */
00930   int script_space_size;
00931 };
00932 
00933 
00934 /* Master record for a decompression instance */
00935 
00936 struct jpeg_decompress_struct 
00937 {
00938   jpeg_common_fields;           /* Fields shared with jpeg_compress_struct */
00939 
00940   /* Source of compressed data */
00941   struct jpeg_source_mgr * src;
00942 
00943   /* Basic description of image --- filled in by jpeg_read_header(). */
00944   /* Application may inspect these values to decide how to process image. */
00945 
00946   JDIMENSION image_width;       /* nominal image width (from SOF marker) */
00947   JDIMENSION image_height;      /* nominal image height */
00948   int num_components;           /* # of color components in JPEG image */
00949   J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
00950 
00951   /* Decompression processing parameters --- these fields must be set before
00952    * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
00953    * them to default values.
00954    */
00955 
00956   J_COLOR_SPACE out_color_space; /* colorspace for output */
00957 
00958   unsigned int scale_num, scale_denom; /* fraction by which to scale image */
00959 
00960   double output_gamma;          /* image gamma wanted in output */
00961 
00962   boolean buffered_image;       /* TRUE=multiple output passes */
00963   boolean raw_data_out;         /* TRUE=downsampled data wanted */
00964 
00965   J_DCT_METHOD dct_method;      /* IDCT algorithm selector */
00966   boolean do_fancy_upsampling;  /* TRUE=apply fancy upsampling */
00967   boolean do_block_smoothing;   /* TRUE=apply interblock smoothing */
00968 
00969   boolean quantize_colors;      /* TRUE=colormapped output wanted */
00970   /* the following are ignored if not quantize_colors: */
00971   J_DITHER_MODE dither_mode;    /* type of color dithering to use */
00972   boolean two_pass_quantize;    /* TRUE=use two-pass color quantization */
00973   int desired_number_of_colors; /* max # colors to use in created colormap */
00974   /* these are significant only in buffered-image mode: */
00975   boolean enable_1pass_quant;   /* enable future use of 1-pass quantizer */
00976   boolean enable_external_quant;/* enable future use of external colormap */
00977   boolean enable_2pass_quant;   /* enable future use of 2-pass quantizer */
00978 
00979   /* Description of actual output image that will be returned to application.
00980    * These fields are computed by jpeg_start_decompress().
00981    * You can also use jpeg_calc_output_dimensions() to determine these values
00982    * in advance of calling jpeg_start_decompress().
00983    */
00984 
00985   JDIMENSION output_width;      /* scaled image width */
00986   JDIMENSION output_height;     /* scaled image height */
00987   int out_color_components;     /* # of color components in out_color_space */
00988   int output_components;        /* # of color components returned */
00989   /* output_components is 1 (a colormap index) when quantizing colors;
00990    * otherwise it equals out_color_components.
00991    */
00992   int rec_outbuf_height;        /* min recommended height of scanline buffer */
00993   /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
00994    * high, space and time will be wasted due to unnecessary data copying.
00995    * Usually rec_outbuf_height will be 1 or 2, at most 4.
00996    */
00997 
00998   /* When quantizing colors, the output colormap is described by these fields.
00999    * The application can supply a colormap by setting colormap non-NULL before
01000    * calling jpeg_start_decompress; otherwise a colormap is created during
01001    * jpeg_start_decompress or jpeg_start_output.
01002    * The map has out_color_components rows and actual_number_of_colors columns.
01003    */
01004   int actual_number_of_colors;  /* number of entries in use */
01005   JSAMPARRAY colormap;          /* The color map as a 2-D pixel array */
01006 
01007   /* State variables: these variables indicate the progress of decompression.
01008    * The application may examine these but must not modify them.
01009    */
01010 
01011   /* Row index of next scanline to be read from jpeg_read_scanlines().
01012    * Application may use this to control its processing loop, e.g.,
01013    * "while (output_scanline < output_height)".
01014    */
01015   JDIMENSION output_scanline;   /* 0 .. output_height-1  */
01016 
01017   /* Current input scan number and number of iMCU rows completed in scan.
01018    * These indicate the progress of the decompressor input side.
01019    */
01020   int input_scan_number;        /* Number of SOS markers seen so far */
01021   JDIMENSION input_iMCU_row;    /* Number of iMCU rows completed */
01022 
01023   /* The "output scan number" is the notional scan being displayed by the
01024    * output side.  The decompressor will not allow output scan/row number
01025    * to get ahead of input scan/row, but it can fall arbitrarily far behind.
01026    */
01027   int output_scan_number;       /* Nominal scan number being displayed */
01028   JDIMENSION output_iMCU_row;   /* Number of iMCU rows read */
01029 
01030   /* Current progression status.  coef_bits[c][i] indicates the precision
01031    * with which component c's DCT coefficient i (in zigzag order) is known.
01032    * It is -1 when no data has yet been received, otherwise it is the point
01033    * transform (shift) value for the most recent scan of the coefficient
01034    * (thus, 0 at completion of the progression).
01035    * This pointer is NULL when reading a non-progressive file.
01036    */
01037   int (*coef_bits)[DCTSIZE2];   /* -1 or current Al value for each coef */
01038 
01039   /* Internal JPEG parameters --- the application usually need not look at
01040    * these fields.  Note that the decompressor output side may not use
01041    * any parameters that can change between scans.
01042    */
01043 
01044   /* Quantization and Huffman tables are carried forward across input
01045    * datastreams when processing abbreviated JPEG datastreams.
01046    */
01047 
01048   JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
01049   /* ptrs to coefficient quantization tables, or NULL if not defined */
01050 
01051   JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
01052   JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
01053   /* ptrs to Huffman coding tables, or NULL if not defined */
01054 
01055   /* These parameters are never carried across datastreams, since they
01056    * are given in SOF/SOS markers or defined to be reset by SOI.
01057    */
01058 
01059   int data_precision;           /* bits of precision in image data */
01060 
01061   jpeg_component_info * comp_info;
01062   /* comp_info[i] describes component that appears i'th in SOF */
01063 
01064   boolean progressive_mode;     /* TRUE if SOFn specifies progressive mode */
01065   boolean arith_code;           /* TRUE=arithmetic coding, FALSE=Huffman */
01066 
01067   UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
01068   UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
01069   UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
01070 
01071   unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
01072 
01073   /* These fields record data obtained from optional markers recognized by
01074    * the JPEG library.
01075    */
01076   boolean saw_JFIF_marker;      /* TRUE iff a JFIF APP0 marker was found */
01077   /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
01078   UINT8 JFIF_major_version;     /* JFIF version number */
01079   UINT8 JFIF_minor_version;
01080   UINT8 density_unit;           /* JFIF code for pixel size units */
01081   UINT16 X_density;             /* Horizontal pixel density */
01082   UINT16 Y_density;             /* Vertical pixel density */
01083   boolean saw_Adobe_marker;     /* TRUE iff an Adobe APP14 marker was found */
01084   UINT8 Adobe_transform;        /* Color transform code from Adobe marker */
01085 
01086   boolean CCIR601_sampling;     /* TRUE=first samples are cosited */
01087 
01088   /* Aside from the specific data retained from APPn markers known to the
01089    * library, the uninterpreted contents of any or all APPn and COM markers
01090    * can be saved in a list for examination by the application.
01091    */
01092   jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
01093 
01094   /* Remaining fields are known throughout decompressor, but generally
01095    * should not be touched by a surrounding application.
01096    */
01097 
01098   /*
01099    * These fields are computed during decompression startup
01100    */
01101   int max_h_samp_factor;        /* largest h_samp_factor */
01102   int max_v_samp_factor;        /* largest v_samp_factor */
01103 
01104   int min_DCT_scaled_size;      /* smallest DCT_scaled_size of any component */
01105 
01106   JDIMENSION total_iMCU_rows;   /* # of iMCU rows in image */
01107   /* The coefficient controller's input and output progress is measured in
01108    * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
01109    * in fully interleaved JPEG scans, but are used whether the scan is
01110    * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
01111    * rows of each component.  Therefore, the IDCT output contains
01112    * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
01113    */
01114 
01115   JSAMPLE * sample_range_limit; /* table for fast range-limiting */
01116 
01117   /*
01118    * These fields are valid during any one scan.
01119    * They describe the components and MCUs actually appearing in the scan.
01120    * Note that the decompressor output side must not use these fields.
01121    */
01122   int comps_in_scan;            /* # of JPEG components in this scan */
01123   jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
01124   /* *cur_comp_info[i] describes component that appears i'th in SOS */
01125 
01126   JDIMENSION MCUs_per_row;      /* # of MCUs across the image */
01127   JDIMENSION MCU_rows_in_scan;  /* # of MCU rows in the image */
01128 
01129   int blocks_in_MCU;            /* # of DCT blocks per MCU */
01130   int MCU_membership[D_MAX_BLOCKS_IN_MCU];
01131   /* MCU_membership[i] is index in cur_comp_info of component owning */
01132   /* i'th block in an MCU */
01133 
01134   int Ss, Se, Ah, Al;           /* progressive JPEG parameters for scan */
01135 
01136   /* This field is shared between entropy decoder and marker parser.
01137    * It is either zero or the code of a JPEG marker that has been
01138    * read from the data source, but has not yet been processed.
01139    */
01140   int unread_marker;
01141 
01142   /*
01143    * Links to decompression subobjects (methods, private variables of modules)
01144    */
01145   struct jpeg_decomp_master * master;
01146   struct jpeg_d_main_controller * main;
01147   struct jpeg_d_coef_controller * coef;
01148   struct jpeg_d_post_controller * post;
01149   struct jpeg_input_controller * inputctl;
01150   struct jpeg_marker_reader * marker;
01151   struct jpeg_entropy_decoder * entropy;
01152   struct jpeg_inverse_dct * idct;
01153   struct jpeg_upsampler * upsample;
01154   struct jpeg_color_deconverter * cconvert;
01155   struct jpeg_color_quantizer * cquantize;
01156 };
01157 
01158 
01159 /* "Object" declarations for JPEG modules that may be supplied or called
01160  * directly by the surrounding application.
01161  * As with all objects in the JPEG library, these structs only define the
01162  * publicly visible methods and state variables of a module.  Additional
01163  * private fields may exist after the public ones.
01164  */
01165 
01166 
01167 /* Error handler object */
01168 
01169 struct jpeg_error_mgr {
01170   /* Error exit handler: does not return to caller */
01171   JMETHOD(void, error_exit, (j_common_ptr cinfo));
01172   /* Conditionally emit a trace or warning message */
01173   JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
01174   /* Routine that actually outputs a trace or error message */
01175   JMETHOD(void, output_message, (j_common_ptr cinfo));
01176   /* Format a message string for the most recent JPEG error or message */
01177   JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
01178 #define JMSG_LENGTH_MAX  200    /* recommended size of format_message buffer */
01179   /* Reset error state variables at start of a new image */
01180   JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
01181   
01182   /* The message ID code and any parameters are saved here.
01183    * A message can have one string parameter or up to 8 int parameters.
01184    */
01185   int msg_code;
01186 #define JMSG_STR_PARM_MAX  80
01187   union {
01188     int i[8];
01189     char s[JMSG_STR_PARM_MAX];
01190   } msg_parm;
01191   
01192   /* Standard state variables for error facility */
01193   
01194   int trace_level;              /* max msg_level that will be displayed */
01195   
01196   /* For recoverable corrupt-data errors, we emit a warning message,
01197    * but keep going unless emit_message chooses to abort.  emit_message
01198    * should count warnings in num_warnings.  The surrounding application
01199    * can check for bad data by seeing if num_warnings is nonzero at the
01200    * end of processing.
01201    */
01202   long num_warnings;            /* number of corrupt-data warnings */
01203 
01204   /* These fields point to the table(s) of error message strings.
01205    * An application can change the table pointer to switch to a different
01206    * message list (typically, to change the language in which errors are
01207    * reported).  Some applications may wish to add additional error codes
01208    * that will be handled by the JPEG library error mechanism; the second
01209    * table pointer is used for this purpose.
01210    *
01211    * First table includes all errors generated by JPEG library itself.
01212    * Error code 0 is reserved for a "no such error string" message.
01213    */
01214   const char * const * jpeg_message_table; /* Library errors */
01215   int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */
01216   /* Second table can be added by application (see cjpeg/djpeg for example).
01217    * It contains strings numbered first_addon_message..last_addon_message.
01218    */
01219   const char * const * addon_message_table; /* Non-library errors */
01220   int first_addon_message;      /* code for first string in addon table */
01221   int last_addon_message;       /* code for last string in addon table */
01222 };
01223 
01224 
01225 /* Progress monitor object */
01226 
01227 struct jpeg_progress_mgr {
01228   JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
01229 
01230   long pass_counter;            /* work units completed in this pass */
01231   long pass_limit;              /* total number of work units in this pass */
01232   int completed_passes;         /* passes completed so far */
01233   int total_passes;             /* total number of passes expected */
01234 };
01235 
01236 
01237 /* Data destination object for compression */
01238 
01239 struct jpeg_destination_mgr {
01240   JOCTET * next_output_byte;    /* => next byte to write in buffer */
01241   size_t free_in_buffer;        /* # of byte spaces remaining in buffer */
01242 
01243   JMETHOD(void, init_destination, (j_compress_ptr cinfo));
01244   JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
01245   JMETHOD(void, term_destination, (j_compress_ptr cinfo));
01246 };
01247 
01248 
01249 /* Data source object for decompression */
01250 
01251 typedef struct jpeg_source_mgr 
01252 {
01253   FILE * infile;                /* source stream */
01254   JOCTET * buffer;              /* start of buffer */
01255   boolean start_of_file;        /* have we gotten any data yet? */
01256   
01257   const JOCTET * next_input_byte; /* => next byte to read from buffer */
01258   size_t bytes_in_buffer;       /* # of bytes remaining in buffer */
01259 
01260   JMETHOD(void, init_source, (j_decompress_ptr cinfo));
01261   JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
01262   JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
01263   JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
01264   JMETHOD(void, term_source, (j_decompress_ptr cinfo));
01265 } jpeg_source_mgr;
01266 
01267 
01268 /* Memory manager object.
01269  * Allocates "small" objects (a few K total), "large" objects (tens of K),
01270  * and "really big" objects (virtual arrays with backing store if needed).
01271  * The memory manager does not allow individual objects to be freed; rather,
01272  * each created object is assigned to a pool, and whole pools can be freed
01273  * at once.  This is faster and more convenient than remembering exactly what
01274  * to free, especially where malloc()/free() are not too speedy.
01275  * NB: alloc routines never return NULL.  They exit to error_exit if not
01276  * successful.
01277  */
01278 
01279 #define JPOOL_PERMANENT 0       /* lasts until master record is destroyed */
01280 #define JPOOL_IMAGE     1       /* lasts until done with image/datastream */
01281 #define JPOOL_NUMPOOLS  2
01282 
01283 typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
01284 typedef struct jvirt_barray_control * jvirt_barray_ptr;
01285 
01286 
01287 struct jpeg_memory_mgr {
01288   /* Method pointers */
01289   JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
01290                                 size_t sizeofobject));
01291   JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
01292                                      size_t sizeofobject));
01293   JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
01294                                      JDIMENSION samplesperrow,
01295                                      JDIMENSION numrows));
01296   JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
01297                                       JDIMENSION blocksperrow,
01298                                       JDIMENSION numrows));
01299   JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
01300                                                   int pool_id,
01301                                                   boolean pre_zero,
01302                                                   JDIMENSION samplesperrow,
01303                                                   JDIMENSION numrows,
01304                                                   JDIMENSION maxaccess));
01305   JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
01306                                                   int pool_id,
01307                                                   boolean pre_zero,
01308                                                   JDIMENSION blocksperrow,
01309                                                   JDIMENSION numrows,
01310                                                   JDIMENSION maxaccess));
01311   JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
01312   JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
01313                                            jvirt_sarray_ptr ptr,
01314                                            JDIMENSION start_row,
01315                                            JDIMENSION num_rows,
01316                                            boolean writable));
01317   JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
01318                                             jvirt_barray_ptr ptr,
01319                                             JDIMENSION start_row,
01320                                             JDIMENSION num_rows,
01321                                             boolean writable));
01322   JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
01323   JMETHOD(void, self_destruct, (j_common_ptr cinfo));
01324 
01325   /* Limit on memory allocation for this JPEG object.  (Note that this is
01326    * merely advisory, not a guaranteed maximum; it only affects the space
01327    * used for virtual-array buffers.)  May be changed by outer application
01328    * after creating the JPEG object.
01329    */
01330   long max_memory_to_use;
01331 
01332   /* Maximum allocation request accepted by alloc_large. */
01333   long max_alloc_chunk;
01334 };
01335 
01336 
01337 /* Routine signature for application-supplied marker processing methods.
01338  * Need not pass marker code since it is stored in cinfo->unread_marker.
01339  */
01340 typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
01341 
01342 
01343 /* Declarations for routines called by application.
01344  * The JPP macro hides prototype parameters from compilers that can't cope.
01345  * Note JPP requires double parentheses.
01346  */
01347 
01348 #ifdef HAVE_PROTOTYPES
01349 #define JPP(arglist)    arglist
01350 #else
01351 #define JPP(arglist)    ()
01352 #endif
01353 
01354 
01355 /* Short forms of external names for systems with brain-damaged linkers.
01356  * We shorten external names to be unique in the first six letters, which
01357  * is good enough for all known systems.
01358  * (If your compiler itself needs names to be unique in less than 15 
01359  * characters, you are out of luck.  Get a better compiler.)
01360  */
01361 
01362 #ifdef NEED_SHORT_EXTERNAL_NAMES
01363 #define jpeg_std_error          jStdError
01364 #define jpeg_CreateCompress     jCreaCompress
01365 #define jpeg_CreateDecompress   jCreaDecompress
01366 #define jpeg_destroy_compress   jDestCompress
01367 #define jpeg_destroy_decompress jDestDecompress
01368 #define jpeg_stdio_dest         jStdDest
01369 #define jpeg_stdio_src          jStdSrc
01370 #define jpeg_set_defaults       jSetDefaults
01371 #define jpeg_set_colorspace     jSetColorspace
01372 #define jpeg_default_colorspace jDefColorspace
01373 #define jpeg_set_quality        jSetQuality
01374 #define jpeg_set_linear_quality jSetLQuality
01375 #define jpeg_add_quant_table    jAddQuantTable
01376 #define jpeg_quality_scaling    jQualityScaling
01377 #define jpeg_simple_progression jSimProgress
01378 #define jpeg_suppress_tables    jSuppressTables
01379 #define jpeg_alloc_quant_table  jAlcQTable
01380 #define jpeg_alloc_huff_table   jAlcHTable
01381 #define jpeg_start_compress     jStrtCompress
01382 #define jpeg_write_scanlines    jWrtScanlines
01383 #define jpeg_finish_compress    jFinCompress
01384 #define jpeg_write_raw_data     jWrtRawData
01385 #define jpeg_write_marker       jWrtMarker
01386 #define jpeg_write_m_header     jWrtMHeader
01387 #define jpeg_write_m_byte       jWrtMByte
01388 #define jpeg_write_tables       jWrtTables
01389 #define jpeg_read_header        jReadHeader
01390 #define jpeg_start_decompress   jStrtDecompress
01391 #define jpeg_read_scanlines     jReadScanlines
01392 #define jpeg_finish_decompress  jFinDecompress
01393 #define jpeg_read_raw_data      jReadRawData
01394 #define jpeg_has_multiple_scans jHasMultScn
01395 #define jpeg_start_output       jStrtOutput
01396 #define jpeg_finish_output      jFinOutput
01397 #define jpeg_input_complete     jInComplete
01398 #define jpeg_new_colormap       jNewCMap
01399 #define jpeg_consume_input      jConsumeInput
01400 #define jpeg_calc_output_dimensions     jCalcDimensions
01401 #define jpeg_save_markers       jSaveMarkers
01402 #define jpeg_set_marker_processor       jSetMarker
01403 #define jpeg_read_coefficients  jReadCoefs
01404 #define jpeg_write_coefficients jWrtCoefs
01405 #define jpeg_copy_critical_parameters   jCopyCrit
01406 #define jpeg_abort_compress     jAbrtCompress
01407 #define jpeg_abort_decompress   jAbrtDecompress
01408 #define jpeg_abort              jAbort
01409 #define jpeg_destroy            jDestroy
01410 #define jpeg_resync_to_restart  jResyncRestart
01411 #endif /* NEED_SHORT_EXTERNAL_NAMES */
01412 
01413 
01414 /* Default error-management setup */
01415 EXTERN(struct jpeg_error_mgr *) jpeg_std_error
01416         JPP((struct jpeg_error_mgr * err));
01417 
01418 /* Initialization of JPEG compression objects.
01419  * jpeg_create_compress() and jpeg_create_decompress() are the exported
01420  * names that applications should call.  These expand to calls on
01421  * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
01422  * passed for version mismatch checking.
01423  * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
01424  */
01425 #define jpeg_create_compress(cinfo) \
01426     jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
01427                         (size_t) sizeof(struct jpeg_compress_struct))
01428 #define jpeg_create_decompress(cinfo) \
01429     jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
01430                           (size_t) sizeof(struct jpeg_decompress_struct))
01431 EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo,
01432                                       int version, size_t structsize));
01433 EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo,
01434                                         int version, size_t structsize));
01435 /* Destruction of JPEG compression objects */
01436 EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo));
01437 EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
01438 
01439 /* Standard data source and destination managers: stdio streams. */
01440 /* Caller is responsible for opening the file before and closing after. */
01441 EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
01442 EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));
01443 
01444 /* Default parameter setup for compression */
01445 EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo));
01446 /* Compression parameter setup aids */
01447 EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo,
01448                                       J_COLOR_SPACE colorspace));
01449 EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo));
01450 EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
01451                                    boolean force_baseline));
01452 EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
01453                                           int scale_factor,
01454                                           boolean force_baseline));
01455 EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
01456                                        const unsigned int *basic_table,
01457                                        int scale_factor,
01458                                        boolean force_baseline));
01459 EXTERN(int) jpeg_quality_scaling JPP((int quality));
01460 EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo));
01461 EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo,
01462                                        boolean suppress));
01463 EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
01464 EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
01465 
01466 /* Main entry points for compression */
01467 EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,
01468                                       boolean write_all_tables));
01469 EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,
01470                                              JSAMPARRAY scanlines,
01471                                              JDIMENSION num_lines));
01472 EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo));
01473 
01474 /* Replaces jpeg_write_scanlines when writing raw downsampled data. */
01475 EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo,
01476                                             JSAMPIMAGE data,
01477                                             JDIMENSION num_lines));
01478 
01479 /* Write a special marker.  See libjpeg.doc concerning safe usage. */
01480 EXTERN(void) jpeg_write_marker
01481         JPP((j_compress_ptr cinfo, int marker,
01482              const JOCTET * dataptr, unsigned int datalen));
01483 /* Same, but piecemeal. */
01484 EXTERN(void) jpeg_write_m_header
01485         JPP((j_compress_ptr cinfo, int marker, unsigned int datalen));
01486 EXTERN(void) jpeg_write_m_byte
01487         JPP((j_compress_ptr cinfo, int val));
01488 
01489 /* Alternate compression function: just write an abbreviated table file */
01490 EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo));
01491 
01492 /* Decompression startup: read start of JPEG datastream to see what's there */
01493 EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,
01494                                   boolean require_image));
01495 /* Return value is one of: */
01496 #define JPEG_SUSPENDED          0 /* Suspended due to lack of input data */
01497 #define JPEG_HEADER_OK          1 /* Found valid image datastream */
01498 #define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
01499 /* If you pass require_image = TRUE (normal case), you need not check for
01500  * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
01501  * JPEG_SUSPENDED is only possible if you use a data source module that can
01502  * give a suspension return (the stdio source module doesn't).
01503  */
01504 
01505 /* Main entry points for decompression */
01506 EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo));
01507 EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
01508                                             JSAMPARRAY scanlines,
01509                                             JDIMENSION max_lines));
01510 EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
01511 
01512 /* Replaces jpeg_read_scanlines when reading raw downsampled data. */
01513 EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
01514                                            JSAMPIMAGE data,
01515                                            JDIMENSION max_lines));
01516 
01517 /* Additional entry points for buffered-image mode. */
01518 EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
01519 EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo,
01520                                        int scan_number));
01521 EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo));
01522 EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo));
01523 EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo));
01524 EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
01525 /* Return value is one of: */
01526 /* #define JPEG_SUSPENDED       0    Suspended due to lack of input data */
01527 #define JPEG_REACHED_SOS        1 /* Reached start of new scan */
01528 #define JPEG_REACHED_EOI        2 /* Reached end of image */
01529 #define JPEG_ROW_COMPLETED      3 /* Completed one iMCU row */
01530 #define JPEG_SCAN_COMPLETED     4 /* Completed last iMCU row of a scan */
01531 
01532 /* Precalculate output dimensions for current decompression parameters. */
01533 EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
01534 
01535 /* Control saving of COM and APPn markers into marker_list. */
01536 EXTERN(void) jpeg_save_markers
01537         JPP((j_decompress_ptr cinfo, int marker_code,
01538              unsigned int length_limit));
01539 
01540 /* Install a special processing method for COM or APPn markers. */
01541 EXTERN(void) jpeg_set_marker_processor
01542         JPP((j_decompress_ptr cinfo, int marker_code,
01543              jpeg_marker_parser_method routine));
01544 
01545 /* Read or write raw DCT coefficients --- useful for lossless transcoding. */
01546 EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
01547 EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo,
01548                                           jvirt_barray_ptr * coef_arrays));
01549 EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
01550                                                 j_compress_ptr dstinfo));
01551 
01552 /* If you choose to abort compression or decompression before completing
01553  * jpeg_finish_(de)compress, then you need to clean up to release memory,
01554  * temporary files, etc.  You can just call jpeg_destroy_(de)compress
01555  * if you're done with the JPEG object, but if you want to clean it up and
01556  * reuse it, call this:
01557  */
01558 EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo));
01559 EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
01560 
01561 EXTERN(void)default_decompress_parms JPP((j_decompress_ptr cinfo));
01562 
01563 /* Generic versions of jpeg_abort and jpeg_destroy that work on either
01564  * flavor of JPEG object.  These may be more convenient in some places.
01565  */
01566 EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo));
01567 EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo));
01568 
01569 /* Default restart-marker-resync procedure for use by data source modules */
01570 EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
01571                                             int desired));
01572 
01573 
01574 /* These marker codes are exported since applications and data source modules
01575  * are likely to want to use them.
01576  */
01577 
01578 #define JPEG_RST0       0xD0    /* RST0 marker code */
01579 #define JPEG_EOI        0xD9    /* EOI marker code */
01580 #define JPEG_APP0       0xE0    /* APP0 marker code */
01581 #define JPEG_COM        0xFE    /* COM marker code */
01582 
01583 
01584 /* If we have a brain-damaged compiler that emits warnings (or worse, errors)
01585  * for structure definitions that are never filled in, keep it quiet by
01586  * supplying dummy definitions for the various substructures.
01587  */
01588 
01589 #ifdef INCOMPLETE_TYPES_BROKEN
01590 #ifndef JPEG_INTERNALS          /* will be defined in jpegint.h */
01591 struct jvirt_sarray_control { long dummy; };
01592 struct jvirt_barray_control { long dummy; };
01593 struct jpeg_comp_master { long dummy; };
01594 struct jpeg_c_main_controller { long dummy; };
01595 struct jpeg_c_prep_controller { long dummy; };
01596 struct jpeg_c_coef_controller { long dummy; };
01597 struct jpeg_marker_writer { long dummy; };
01598 struct jpeg_color_converter { long dummy; };
01599 struct jpeg_downsampler { long dummy; };
01600 struct jpeg_forward_dct { long dummy; };
01601 struct jpeg_entropy_encoder { long dummy; };
01602 struct jpeg_decomp_master { long dummy; };
01603 struct jpeg_d_main_controller { long dummy; };
01604 struct jpeg_d_coef_controller { long dummy; };
01605 struct jpeg_d_post_controller { long dummy; };
01606 struct jpeg_input_controller { long dummy; };
01607 struct jpeg_marker_reader { long dummy; };
01608 struct jpeg_entropy_decoder { long dummy; };
01609 struct jpeg_inverse_dct { long dummy; };
01610 struct jpeg_upsampler { long dummy; };
01611 struct jpeg_color_deconverter { long dummy; };
01612 struct jpeg_color_quantizer { long dummy; };
01613 #endif /* JPEG_INTERNALS */
01614 #endif /* INCOMPLETE_TYPES_BROKEN */
01615 
01616 
01617 /*
01618  * The JPEG library modules define JPEG_INTERNALS before including this file.
01619  * The internal structure declarations are read only when that is true.
01620  * Applications using the library should not include jpegint.h, but may wish
01621  * to include jerror.h.
01622  */
01623 
01624 #ifdef JPEG_INTERNALS
01625 #include "jpegint.h"            /* fetch private declarations */
01626 #include "jerror.h"             /* fetch error codes too */
01627 #endif
01628 
01629 #if defined(__cplusplus)
01630 };
01631 #endif
01632 
01633 #endif /* JPEGLIB_H */

Généré le Tue Dec 10 18:18:13 2002 pour ExNihilo par doxygen1.3-rc1