bsp
jpeglib.h
00001 /*
00002  * jpeglib.h
00003  *
00004  * Copyright (C) 1991-1995, 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  *
00008  * This file defines the application interface for the JPEG library.
00009  * Most applications using the library need only include this file,
00010  * and perhaps jerror.h if they want to know the exact error codes.
00011  */
00012 
00013 #ifndef JPEGLIB_H
00014 #define JPEGLIB_H
00015 
00016 #ifdef __cplusplus
00017 extern "C"
00018 {
00019 #endif
00020 
00021 
00022 
00023 #ifdef __MACOS__
00024 
00025 // JDC: stuff to make mac version compile
00026 #define boolean qboolean
00027 #define register
00028 #define INT32   int
00029 
00030 #endif
00031 
00032 // rad additions
00033 // 11.29.99
00034 
00035 //#include "cmdlib.h"
00036 #ifdef _WIN32
00037 #include "windows.h"
00038 #include "stdio.h"
00039 #endif
00040 
00041 #ifndef INT32
00042 #define INT32   int
00043 #endif
00044 
00045 
00046     /*
00047      * First we include the configuration files that record how this
00048      * installation of the JPEG library is set up.  jconfig.h can be
00049      * generated automatically for many systems.  jmorecfg.h contains
00050      * manual configuration options that most people need not worry about.
00051      */
00052 
00053 #ifndef JCONFIG_INCLUDED        /* in case jinclude.h already did */
00054 #include "jconfig.h"            /* widely used configuration options */
00055 #endif
00056 #include "jmorecfg.h"           /* seldom changed options */
00057 
00058 
00059     /* Version ID for the JPEG library.
00060      * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
00061      */
00062 
00063 #define JPEG_LIB_VERSION  60    /* Version 6 */
00064 
00065 
00066     /* Various constants determining the sizes of things.
00067      * All of these are specified by the JPEG standard, so don't change them
00068      * if you want to be compatible.
00069      */
00070 
00071 #define DCTSIZE             8   /* The basic DCT block is 8x8 samples */
00072 #define DCTSIZE2            64  /* DCTSIZE squared; # of elements in a block */
00073 #define NUM_QUANT_TBLS      4   /* Quantization tables are numbered 0..3 */
00074 #define NUM_HUFF_TBLS       4   /* Huffman tables are numbered 0..3 */
00075 #define NUM_ARITH_TBLS      16  /* Arith-coding tables are numbered 0..15 */
00076 #define MAX_COMPS_IN_SCAN   4   /* JPEG limit on # of components in one scan */
00077 #define MAX_SAMP_FACTOR     4   /* JPEG limit on sampling factors */
00078     /* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
00079      * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
00080      * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
00081      * to handle it.  We even let you do this from the jconfig.h file.  However,
00082      * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
00083      * sometimes emits noncompliant files doesn't mean you should too.
00084      */
00085 #define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
00086 #ifndef D_MAX_BLOCKS_IN_MCU
00087 #define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
00088 #endif
00089 
00090 
00091     /* This macro is used to declare a "method", that is, a function pointer.
00092      * We want to supply prototype parameters if the compiler can cope.
00093      * Note that the arglist parameter must be parenthesized!
00094      */
00095 
00096 #ifdef HAVE_PROTOTYPES
00097 #define JMETHOD(type,methodname,arglist)  type (*methodname) arglist
00098 #else
00099 #define JMETHOD(type,methodname,arglist)  type (*methodname) ()
00100 #endif
00101 
00102 
00103     /* Data structures for images (arrays of samples and of DCT coefficients).
00104      * On 80x86 machines, the image arrays are too big for near pointers,
00105      * but the pointer arrays can fit in near memory.
00106      */
00107 
00108     typedef JSAMPLE FAR *JSAMPROW;      /* ptr to one image row of pixel samples. */
00109     typedef JSAMPROW *JSAMPARRAY;       /* ptr to some rows (a 2-D sample array) */
00110     typedef JSAMPARRAY *JSAMPIMAGE;     /* a 3-D sample array: top index is color */
00111 
00112     typedef JCOEF JBLOCK[DCTSIZE2];     /* one block of coefficients */
00113     typedef JBLOCK FAR *JBLOCKROW;      /* pointer to one row of coefficient blocks */
00114     typedef JBLOCKROW *JBLOCKARRAY;             /* a 2-D array of coefficient blocks */
00115     typedef JBLOCKARRAY *JBLOCKIMAGE;   /* a 3-D array of coefficient blocks */
00116 
00117     typedef JCOEF FAR *JCOEFPTR;        /* useful in a couple of places */
00118 
00119 
00120     /* Types for JPEG compression parameters and working tables. */
00121 
00122 
00123     /* DCT coefficient quantization tables. */
00124 
00125     typedef struct
00126     {
00127         /* This field directly represents the contents of a JPEG DQT marker.
00128          * Note: the values are always given in zigzag order.
00129          */
00130         UINT16 quantval[DCTSIZE2];      /* quantization step for each coefficient */
00131         /* This field is used only during compression.  It's initialized FALSE when
00132          * the table is created, and set TRUE when it's been output to the file.
00133          * You could suppress output of a table by setting this to TRUE.
00134          * (See jpeg_suppress_tables for an example.)
00135          */
00136         boolean sent_table;             /* TRUE when table has been output */
00137     } JQUANT_TBL;
00138 
00139 
00140     /* Huffman coding tables. */
00141 
00142     typedef struct
00143     {
00144         /* These two fields directly represent the contents of a JPEG DHT marker */
00145         UINT8 bits[17];         /* bits[k] = # of symbols with codes of */
00146         /* length k bits; bits[0] is unused */
00147         UINT8 huffval[256];             /* The symbols, in order of incr code length */
00148         /* This field is used only during compression.  It's initialized FALSE when
00149          * the table is created, and set TRUE when it's been output to the file.
00150          * You could suppress output of a table by setting this to TRUE.
00151          * (See jpeg_suppress_tables for an example.)
00152          */
00153         boolean sent_table;             /* TRUE when table has been output */
00154     } JHUFF_TBL;
00155 
00156 
00157     /* Basic info about one component (color channel). */
00158 
00159     typedef struct
00160     {
00161         /* These values are fixed over the whole image. */
00162         /* For compression, they must be supplied by parameter setup; */
00163         /* for decompression, they are read from the SOF marker. */
00164         int component_id;               /* identifier for this component (0..255) */
00165         int component_index;            /* its index in SOF or cinfo->comp_info[] */
00166         int h_samp_factor;              /* horizontal sampling factor (1..4) */
00167         int v_samp_factor;              /* vertical sampling factor (1..4) */
00168         int quant_tbl_no;               /* quantization table selector (0..3) */
00169         /* These values may vary between scans. */
00170         /* For compression, they must be supplied by parameter setup; */
00171         /* for decompression, they are read from the SOS marker. */
00172         /* The decompressor output side may not use these variables. */
00173         int dc_tbl_no;          /* DC entropy table selector (0..3) */
00174         int ac_tbl_no;          /* AC entropy table selector (0..3) */
00175 
00176         /* Remaining fields should be treated as private by applications. */
00177 
00178         /* These values are computed during compression or decompression startup: */
00179         /* Component's size in DCT blocks.
00180          * Any dummy blocks added to complete an MCU are not counted; therefore
00181          * these values do not depend on whether a scan is interleaved or not.
00182          */
00183         JDIMENSION width_in_blocks;
00184         JDIMENSION height_in_blocks;
00185         /* Size of a DCT block in samples.  Always DCTSIZE for compression.
00186          * For decompression this is the size of the output from one DCT block,
00187          * reflecting any scaling we choose to apply during the IDCT step.
00188          * Values of 1,2,4,8 are likely to be supported.  Note that different
00189          * components may receive different IDCT scalings.
00190          */
00191         int DCT_scaled_size;
00192         /* The downsampled dimensions are the component's actual, unpadded number
00193          * of samples at the main buffer (preprocessing/compression interface), thus
00194          * downsampled_width = ceil(image_width * Hi/Hmax)
00195          * and similarly for height.  For decompression, IDCT scaling is included, so
00196          * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
00197          */
00198         JDIMENSION downsampled_width;    /* actual width in samples */
00199         JDIMENSION downsampled_height; /* actual height in samples */
00200         /* This flag is used only for decompression.  In cases where some of the
00201          * components will be ignored (eg grayscale output from YCbCr image),
00202          * we can skip most computations for the unused components.
00203          */
00204         boolean component_needed;       /* do we need the value of this component? */
00205 
00206         /* These values are computed before starting a scan of the component. */
00207         /* The decompressor output side may not use these variables. */
00208         int MCU_width;          /* number of blocks per MCU, horizontally */
00209         int MCU_height;         /* number of blocks per MCU, vertically */
00210         int MCU_blocks;         /* MCU_width * MCU_height */
00211         int MCU_sample_width;           /* MCU width in samples, MCU_width*DCT_scaled_size */
00212         int last_col_width;             /* # of non-dummy blocks across in last MCU */
00213         int last_row_height;            /* # of non-dummy blocks down in last MCU */
00214 
00215         /* Saved quantization table for component; NULL if none yet saved.
00216          * See jdinput.c comments about the need for this information.
00217          * This field is not currently used by the compressor.
00218          */
00219         JQUANT_TBL * quant_table;
00220 
00221         /* Private per-component storage for DCT or IDCT subsystem. */
00222         void * dct_table;
00223     } jpeg_component_info;
00224 
00225 
00226     /* The script for encoding a multiple-scan file is an array of these: */
00227 
00228     typedef struct
00229     {
00230         int comps_in_scan;              /* number of components encoded in this scan */
00231         int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
00232         int Ss, Se;                     /* progressive JPEG spectral selection parms */
00233         int Ah, Al;                     /* progressive JPEG successive approx. parms */
00234     } jpeg_scan_info;
00235 
00236 
00237     /* Known color spaces. */
00238 
00239     typedef enum
00240     {
00241         JCS_UNKNOWN,            /* error/unspecified */
00242         JCS_GRAYSCALE,          /* monochrome */
00243         JCS_RGB,                /* red/green/blue */
00244         JCS_YCbCr,              /* Y/Cb/Cr (also known as YUV) */
00245         JCS_CMYK,               /* C/M/Y/K */
00246         JCS_YCCK                /* Y/Cb/Cr/K */
00247     } J_COLOR_SPACE;
00248 
00249     /* DCT/IDCT algorithm options. */
00250 
00251     typedef enum
00252     {
00253         JDCT_ISLOW,             /* slow but accurate integer algorithm */
00254         JDCT_IFAST,             /* faster, less accurate integer method */
00255         JDCT_FLOAT              /* floating-point: accurate, fast on fast HW */
00256     } J_DCT_METHOD;
00257 
00258 #ifndef JDCT_DEFAULT            /* may be overridden in jconfig.h */
00259 #define JDCT_DEFAULT  JDCT_ISLOW
00260 #endif
00261 #ifndef JDCT_FASTEST            /* may be overridden in jconfig.h */
00262 #define JDCT_FASTEST  JDCT_IFAST
00263 #endif
00264 
00265     /* Dithering options for decompression. */
00266 
00267     typedef enum
00268     {
00269         JDITHER_NONE,           /* no dithering */
00270         JDITHER_ORDERED,        /* simple ordered dither */
00271         JDITHER_FS              /* Floyd-Steinberg error diffusion dither */
00272     } J_DITHER_MODE;
00273 
00274 
00275     /* Common fields between JPEG compression and decompression master structs. */
00276 
00277 #define jpeg_common_fields \
00278   struct jpeg_error_mgr * err;  /* Error handler module */\
00279   struct jpeg_memory_mgr * mem; /* Memory manager module */\
00280   struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
00281   boolean is_decompressor;      /* so common code can tell which is which */\
00282   int global_state              /* for checking call sequence validity */
00283 
00284     /* Routines that are to be used by both halves of the library are declared
00285      * to receive a pointer to this structure.  There are no actual instances of
00286      * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
00287      */
00288     struct jpeg_common_struct
00289     {
00290         jpeg_common_fields;             /* Fields common to both master struct types */
00291         /* Additional fields follow in an actual jpeg_compress_struct or
00292          * jpeg_decompress_struct.  All three structs must agree on these
00293          * initial fields!  (This would be a lot cleaner in C++.)
00294          */
00295     };
00296 
00297     typedef struct jpeg_common_struct * j_common_ptr;
00298     typedef struct jpeg_compress_struct * j_compress_ptr;
00299     typedef struct jpeg_decompress_struct * j_decompress_ptr;
00300 
00301 
00302     /* Master record for a compression instance */
00303 
00304     struct jpeg_compress_struct
00305     {
00306         jpeg_common_fields;             /* Fields shared with jpeg_decompress_struct */
00307 
00308         /* Destination for compressed data */
00309         struct jpeg_destination_mgr * dest;
00310 
00311         /* Description of source image --- these fields must be filled in by
00312          * outer application before starting compression.  in_color_space must
00313          * be correct before you can even call jpeg_set_defaults().
00314          */
00315 
00316         JDIMENSION image_width; /* input image width */
00317         JDIMENSION image_height;        /* input image height */
00318         int input_components;           /* # of color components in input image */
00319         J_COLOR_SPACE in_color_space;   /* colorspace of input image */
00320 
00321         double input_gamma;             /* image gamma of input image */
00322 
00323         /* Compression parameters --- these fields must be set before calling
00324          * jpeg_start_compress().  We recommend calling jpeg_set_defaults() to
00325          * initialize everything to reasonable defaults, then changing anything
00326          * the application specifically wants to change.  That way you won't get
00327          * burnt when new parameters are added.  Also note that there are several
00328          * helper routines to simplify changing parameters.
00329          */
00330 
00331         int data_precision;             /* bits of precision in image data */
00332 
00333         int num_components;             /* # of color components in JPEG image */
00334         J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
00335 
00336         jpeg_component_info * comp_info;
00337         /* comp_info[i] describes component that appears i'th in SOF */
00338 
00339         JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
00340         /* ptrs to coefficient quantization tables, or NULL if not defined */
00341 
00342         JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
00343         JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
00344         /* ptrs to Huffman coding tables, or NULL if not defined */
00345 
00346         UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
00347         UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
00348         UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
00349 
00350         int num_scans;          /* # of entries in scan_info array */
00351         const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
00352         /* The default value of scan_info is NULL, which causes a single-scan
00353          * sequential JPEG file to be emitted.  To create a multi-scan file,
00354          * set num_scans and scan_info to point to an array of scan definitions.
00355          */
00356 
00357         boolean raw_data_in;            /* TRUE=caller supplies downsampled data */
00358         boolean arith_code;             /* TRUE=arithmetic coding, FALSE=Huffman */
00359         boolean optimize_coding;        /* TRUE=optimize entropy encoding parms */
00360         boolean CCIR601_sampling;       /* TRUE=first samples are cosited */
00361         int smoothing_factor;           /* 1..100, or 0 for no input smoothing */
00362         J_DCT_METHOD dct_method;        /* DCT algorithm selector */
00363 
00364         /* The restart interval can be specified in absolute MCUs by setting
00365          * restart_interval, or in MCU rows by setting restart_in_rows
00366          * (in which case the correct restart_interval will be figured
00367          * for each scan).
00368          */
00369         unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
00370         int restart_in_rows;            /* if > 0, MCU rows per restart interval */
00371 
00372         /* Parameters controlling emission of special markers. */
00373 
00374         boolean write_JFIF_header;      /* should a JFIF marker be written? */
00375         /* These three values are not used by the JPEG code, merely copied */
00376         /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
00377         /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
00378         /* ratio is defined by X_density/Y_density even when density_unit=0. */
00379         UINT8 density_unit;             /* JFIF code for pixel size units */
00380         UINT16 X_density;               /* Horizontal pixel density */
00381         UINT16 Y_density;               /* Vertical pixel density */
00382         boolean write_Adobe_marker;     /* should an Adobe marker be written? */
00383 
00384         /* State variable: index of next scanline to be written to
00385          * jpeg_write_scanlines().  Application may use this to control its
00386          * processing loop, e.g., "while (next_scanline < image_height)".
00387          */
00388 
00389         JDIMENSION next_scanline;       /* 0 .. image_height-1  */
00390 
00391         /* Remaining fields are known throughout compressor, but generally
00392          * should not be touched by a surrounding application.
00393          */
00394 
00395         /*
00396          * These fields are computed during compression startup
00397          */
00398         boolean progressive_mode;       /* TRUE if scan script uses progressive mode */
00399         int max_h_samp_factor;  /* largest h_samp_factor */
00400         int max_v_samp_factor;  /* largest v_samp_factor */
00401 
00402         JDIMENSION total_iMCU_rows;     /* # of iMCU rows to be input to coef ctlr */
00403         /* The coefficient controller receives data in units of MCU rows as defined
00404          * for fully interleaved scans (whether the JPEG file is interleaved or not).
00405          * There are v_samp_factor * DCTSIZE sample rows of each component in an
00406          * "iMCU" (interleaved MCU) row.
00407          */
00408 
00409         /*
00410          * These fields are valid during any one scan.
00411          * They describe the components and MCUs actually appearing in the scan.
00412          */
00413         int comps_in_scan;              /* # of JPEG components in this scan */
00414         jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
00415         /* *cur_comp_info[i] describes component that appears i'th in SOS */
00416 
00417         JDIMENSION MCUs_per_row;        /* # of MCUs across the image */
00418         JDIMENSION MCU_rows_in_scan;    /* # of MCU rows in the image */
00419 
00420         int blocks_in_MCU;              /* # of DCT blocks per MCU */
00421         int MCU_membership[C_MAX_BLOCKS_IN_MCU];
00422         /* MCU_membership[i] is index in cur_comp_info of component owning */
00423         /* i'th block in an MCU */
00424 
00425         int Ss, Se, Ah, Al;             /* progressive JPEG parameters for scan */
00426 
00427         /*
00428          * Links to compression subobjects (methods and private variables of modules)
00429          */
00430         struct jpeg_comp_master * master;
00431         struct jpeg_c_main_controller * main;
00432         struct jpeg_c_prep_controller * prep;
00433         struct jpeg_c_coef_controller * coef;
00434         struct jpeg_marker_writer * marker;
00435         struct jpeg_color_converter * cconvert;
00436         struct jpeg_downsampler * downsample;
00437         struct jpeg_forward_dct * fdct;
00438         struct jpeg_entropy_encoder * entropy;
00439     };
00440 
00441 
00442     /* Master record for a decompression instance */
00443 
00444     struct jpeg_decompress_struct
00445     {
00446         jpeg_common_fields;             /* Fields shared with jpeg_compress_struct */
00447 
00448         /* Source of compressed data */
00449         struct jpeg_source_mgr * src;
00450 
00451         /* Basic description of image --- filled in by jpeg_read_header(). */
00452         /* Application may inspect these values to decide how to process image. */
00453 
00454         JDIMENSION image_width; /* nominal image width (from SOF marker) */
00455         JDIMENSION image_height;        /* nominal image height */
00456         int num_components;             /* # of color components in JPEG image */
00457         J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
00458 
00459         /* Decompression processing parameters --- these fields must be set before
00460          * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
00461          * them to default values.
00462          */
00463 
00464         J_COLOR_SPACE out_color_space; /* colorspace for output */
00465 
00466         unsigned int scale_num, scale_denom; /* fraction by which to scale image */
00467 
00468         double output_gamma;            /* image gamma wanted in output */
00469 
00470         boolean buffered_image; /* TRUE=multiple output passes */
00471         boolean raw_data_out;           /* TRUE=downsampled data wanted */
00472 
00473         J_DCT_METHOD dct_method;        /* IDCT algorithm selector */
00474         boolean do_fancy_upsampling;    /* TRUE=apply fancy upsampling */
00475         boolean do_block_smoothing;     /* TRUE=apply interblock smoothing */
00476 
00477         boolean quantize_colors;        /* TRUE=colormapped output wanted */
00478         /* the following are ignored if not quantize_colors: */
00479         J_DITHER_MODE dither_mode;      /* type of color dithering to use */
00480         boolean two_pass_quantize;      /* TRUE=use two-pass color quantization */
00481         int desired_number_of_colors;   /* max # colors to use in created colormap */
00482         /* these are significant only in buffered-image mode: */
00483         boolean enable_1pass_quant;     /* enable future use of 1-pass quantizer */
00484         boolean enable_external_quant;/* enable future use of external colormap */
00485         boolean enable_2pass_quant;     /* enable future use of 2-pass quantizer */
00486 
00487         /* Description of actual output image that will be returned to application.
00488          * These fields are computed by jpeg_start_decompress().
00489          * You can also use jpeg_calc_output_dimensions() to determine these values
00490          * in advance of calling jpeg_start_decompress().
00491          */
00492 
00493         JDIMENSION output_width;        /* scaled image width */
00494         JDIMENSION output_height;       /* scaled image height */
00495         int out_color_components;       /* # of color components in out_color_space */
00496         int output_components;  /* # of color components returned */
00497         /* output_components is 1 (a colormap index) when quantizing colors;
00498          * otherwise it equals out_color_components.
00499          */
00500         int rec_outbuf_height;  /* min recommended height of scanline buffer */
00501         /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
00502          * high, space and time will be wasted due to unnecessary data copying.
00503          * Usually rec_outbuf_height will be 1 or 2, at most 4.
00504          */
00505 
00506         /* When quantizing colors, the output colormap is described by these fields.
00507          * The application can supply a colormap by setting colormap non-NULL before
00508          * calling jpeg_start_decompress; otherwise a colormap is created during
00509          * jpeg_start_decompress or jpeg_start_output.
00510          * The map has out_color_components rows and actual_number_of_colors columns.
00511          */
00512         int actual_number_of_colors;    /* number of entries in use */
00513         JSAMPARRAY colormap;            /* The color map as a 2-D pixel array */
00514 
00515         /* State variables: these variables indicate the progress of decompression.
00516          * The application may examine these but must not modify them.
00517          */
00518 
00519         /* Row index of next scanline to be read from jpeg_read_scanlines().
00520          * Application may use this to control its processing loop, e.g.,
00521          * "while (output_scanline < output_height)".
00522          */
00523         JDIMENSION output_scanline;     /* 0 .. output_height-1  */
00524 
00525         /* Current input scan number and number of iMCU rows completed in scan.
00526          * These indicate the progress of the decompressor input side.
00527          */
00528         int input_scan_number;  /* Number of SOS markers seen so far */
00529         JDIMENSION input_iMCU_row;      /* Number of iMCU rows completed */
00530 
00531         /* The "output scan number" is the notional scan being displayed by the
00532          * output side.  The decompressor will not allow output scan/row number
00533          * to get ahead of input scan/row, but it can fall arbitrarily far behind.
00534          */
00535         int output_scan_number; /* Nominal scan number being displayed */
00536         JDIMENSION output_iMCU_row;     /* Number of iMCU rows read */
00537 
00538         /* Current progression status.  coef_bits[c][i] indicates the precision
00539          * with which component c's DCT coefficient i (in zigzag order) is known.
00540          * It is -1 when no data has yet been received, otherwise it is the point
00541          * transform (shift) value for the most recent scan of the coefficient
00542          * (thus, 0 at completion of the progression).
00543          * This pointer is NULL when reading a non-progressive file.
00544          */
00545         int (*coef_bits)[DCTSIZE2];     /* -1 or current Al value for each coef */
00546 
00547         /* Internal JPEG parameters --- the application usually need not look at
00548          * these fields.  Note that the decompressor output side may not use
00549          * any parameters that can change between scans.
00550          */
00551 
00552         /* Quantization and Huffman tables are carried forward across input
00553          * datastreams when processing abbreviated JPEG datastreams.
00554          */
00555 
00556         JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
00557         /* ptrs to coefficient quantization tables, or NULL if not defined */
00558 
00559         JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
00560         JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
00561         /* ptrs to Huffman coding tables, or NULL if not defined */
00562 
00563         /* These parameters are never carried across datastreams, since they
00564          * are given in SOF/SOS markers or defined to be reset by SOI.
00565          */
00566 
00567         int data_precision;             /* bits of precision in image data */
00568 
00569         jpeg_component_info * comp_info;
00570         /* comp_info[i] describes component that appears i'th in SOF */
00571 
00572         boolean progressive_mode;       /* TRUE if SOFn specifies progressive mode */
00573         boolean arith_code;             /* TRUE=arithmetic coding, FALSE=Huffman */
00574 
00575         UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
00576         UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
00577         UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
00578 
00579         unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
00580 
00581         /* These fields record data obtained from optional markers recognized by
00582          * the JPEG library.
00583          */
00584         boolean saw_JFIF_marker;        /* TRUE iff a JFIF APP0 marker was found */
00585         /* Data copied from JFIF marker: */
00586         UINT8 density_unit;             /* JFIF code for pixel size units */
00587         UINT16 X_density;               /* Horizontal pixel density */
00588         UINT16 Y_density;               /* Vertical pixel density */
00589         boolean saw_Adobe_marker;       /* TRUE iff an Adobe APP14 marker was found */
00590         UINT8 Adobe_transform;  /* Color transform code from Adobe marker */
00591 
00592         boolean CCIR601_sampling;       /* TRUE=first samples are cosited */
00593 
00594         /* Remaining fields are known throughout decompressor, but generally
00595          * should not be touched by a surrounding application.
00596          */
00597 
00598         /*
00599          * These fields are computed during decompression startup
00600          */
00601         int max_h_samp_factor;  /* largest h_samp_factor */
00602         int max_v_samp_factor;  /* largest v_samp_factor */
00603 
00604         int min_DCT_scaled_size;        /* smallest DCT_scaled_size of any component */
00605 
00606         JDIMENSION total_iMCU_rows;     /* # of iMCU rows in image */
00607         /* The coefficient controller's input and output progress is measured in
00608          * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
00609          * in fully interleaved JPEG scans, but are used whether the scan is
00610          * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
00611          * rows of each component.  Therefore, the IDCT output contains
00612          * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
00613          */
00614 
00615         JSAMPLE * sample_range_limit; /* table for fast range-limiting */
00616 
00617         /*
00618          * These fields are valid during any one scan.
00619          * They describe the components and MCUs actually appearing in the scan.
00620          * Note that the decompressor output side must not use these fields.
00621          */
00622         int comps_in_scan;              /* # of JPEG components in this scan */
00623         jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
00624         /* *cur_comp_info[i] describes component that appears i'th in SOS */
00625 
00626         JDIMENSION MCUs_per_row;        /* # of MCUs across the image */
00627         JDIMENSION MCU_rows_in_scan;    /* # of MCU rows in the image */
00628 
00629         int blocks_in_MCU;              /* # of DCT blocks per MCU */
00630         int MCU_membership[D_MAX_BLOCKS_IN_MCU];
00631         /* MCU_membership[i] is index in cur_comp_info of component owning */
00632         /* i'th block in an MCU */
00633 
00634         int Ss, Se, Ah, Al;             /* progressive JPEG parameters for scan */
00635 
00636         /* This field is shared between entropy decoder and marker parser.
00637          * It is either zero or the code of a JPEG marker that has been
00638          * read from the data source, but has not yet been processed.
00639          */
00640         int unread_marker;
00641 
00642         /*
00643          * Links to decompression subobjects (methods, private variables of modules)
00644          */
00645         struct jpeg_decomp_master * master;
00646         struct jpeg_d_main_controller * main;
00647         struct jpeg_d_coef_controller * coef;
00648         struct jpeg_d_post_controller * post;
00649         struct jpeg_input_controller * inputctl;
00650         struct jpeg_marker_reader * marker;
00651         struct jpeg_entropy_decoder * entropy;
00652         struct jpeg_inverse_dct * idct;
00653         struct jpeg_upsampler * upsample;
00654         struct jpeg_color_deconverter * cconvert;
00655         struct jpeg_color_quantizer * cquantize;
00656     };
00657 
00658 
00659     /* "Object" declarations for JPEG modules that may be supplied or called
00660      * directly by the surrounding application.
00661      * As with all objects in the JPEG library, these structs only define the
00662      * publicly visible methods and state variables of a module.  Additional
00663      * private fields may exist after the public ones.
00664      */
00665 
00666 
00667     /* Error handler object */
00668 
00669     struct jpeg_error_mgr
00670     {
00671         /* Error exit handler: does not return to caller */
00672         JMETHOD(void, error_exit, (j_common_ptr cinfo));
00673         /* Conditionally emit a trace or warning message */
00674         JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
00675         /* Routine that actually outputs a trace or error message */
00676         JMETHOD(void, output_message, (j_common_ptr cinfo));
00677         /* Format a message string for the most recent JPEG error or message */
00678         JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
00679 #define JMSG_LENGTH_MAX  200    /* recommended size of format_message buffer */
00680         /* Reset error state variables at start of a new image */
00681         JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
00682 
00683         /* The message ID code and any parameters are saved here.
00684          * A message can have one string parameter or up to 8 int parameters.
00685          */
00686         int msg_code;
00687 #define JMSG_STR_PARM_MAX  80
00688         union
00689         {
00690             int i[8];
00691             char s[JMSG_STR_PARM_MAX];
00692         } msg_parm;
00693 
00694         /* Standard state variables for error facility */
00695 
00696         int trace_level;                /* max msg_level that will be displayed */
00697 
00698         /* For recoverable corrupt-data errors, we emit a warning message,
00699          * but keep going unless emit_message chooses to abort.  emit_message
00700          * should count warnings in num_warnings.  The surrounding application
00701          * can check for bad data by seeing if num_warnings is nonzero at the
00702          * end of processing.
00703          */
00704         long num_warnings;              /* number of corrupt-data warnings */
00705 
00706         /* These fields point to the table(s) of error message strings.
00707          * An application can change the table pointer to switch to a different
00708          * message list (typically, to change the language in which errors are
00709          * reported).  Some applications may wish to add additional error codes
00710          * that will be handled by the JPEG library error mechanism; the second
00711          * table pointer is used for this purpose.
00712          *
00713          * First table includes all errors generated by JPEG library itself.
00714          * Error code 0 is reserved for a "no such error string" message.
00715          */
00716         const char * const * jpeg_message_table; /* Library errors */
00717         int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */
00718         /* Second table can be added by application (see cjpeg/djpeg for example).
00719          * It contains strings numbered first_addon_message..last_addon_message.
00720          */
00721         const char * const * addon_message_table; /* Non-library errors */
00722         int first_addon_message;        /* code for first string in addon table */
00723         int last_addon_message; /* code for last string in addon table */
00724     };
00725 
00726 
00727     /* Progress monitor object */
00728 
00729     struct jpeg_progress_mgr
00730     {
00731         JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
00732 
00733         long pass_counter;              /* work units completed in this pass */
00734         long pass_limit;                /* total number of work units in this pass */
00735         int completed_passes;           /* passes completed so far */
00736         int total_passes;               /* total number of passes expected */
00737     };
00738 
00739 
00740     /* Data destination object for compression */
00741 
00742     struct jpeg_destination_mgr
00743     {
00744         JOCTET * next_output_byte;      /* => next byte to write in buffer */
00745         size_t free_in_buffer;  /* # of byte spaces remaining in buffer */
00746 
00747         JMETHOD(void, init_destination, (j_compress_ptr cinfo));
00748         JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
00749         JMETHOD(void, term_destination, (j_compress_ptr cinfo));
00750     };
00751 
00752 
00753     /* Data source object for decompression */
00754 
00755     struct jpeg_source_mgr
00756     {
00757         const JOCTET * next_input_byte; /* => next byte to read from buffer */
00758         size_t bytes_in_buffer; /* # of bytes remaining in buffer */
00759 
00760         JMETHOD(void, init_source, (j_decompress_ptr cinfo));
00761         JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
00762         JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
00763         JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
00764         JMETHOD(void, term_source, (j_decompress_ptr cinfo));
00765     };
00766 
00767 
00768     /* Memory manager object.
00769      * Allocates "small" objects (a few K total), "large" objects (tens of K),
00770      * and "really big" objects (virtual arrays with backing store if needed).
00771      * The memory manager does not allow individual objects to be freed; rather,
00772      * each created object is assigned to a pool, and whole pools can be freed
00773      * at once.  This is faster and more convenient than remembering exactly what
00774      * to free, especially where malloc()/free() are not too speedy.
00775      * NB: alloc routines never return NULL.  They exit to error_exit if not
00776      * successful.
00777      */
00778 
00779 #define JPOOL_PERMANENT 0       /* lasts until master record is destroyed */
00780 #define JPOOL_IMAGE     1       /* lasts until done with image/datastream */
00781 #define JPOOL_NUMPOOLS  2
00782 
00783     typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
00784     typedef struct jvirt_barray_control * jvirt_barray_ptr;
00785 
00786 
00787     struct jpeg_memory_mgr
00788     {
00789         /* Method pointers */
00790         JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
00791                                       size_t sizeofobject));
00792         JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
00793                                           size_t sizeofobject));
00794         JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
00795                                            JDIMENSION samplesperrow,
00796                                            JDIMENSION numrows));
00797         JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
00798                                             JDIMENSION blocksperrow,
00799                                             JDIMENSION numrows));
00800         JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
00801                 int pool_id,
00802                 boolean pre_zero,
00803                 JDIMENSION samplesperrow,
00804                 JDIMENSION numrows,
00805                 JDIMENSION maxaccess));
00806         JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
00807                 int pool_id,
00808                 boolean pre_zero,
00809                 JDIMENSION blocksperrow,
00810                 JDIMENSION numrows,
00811                 JDIMENSION maxaccess));
00812         JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
00813         JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
00814                 jvirt_sarray_ptr ptr,
00815                 JDIMENSION start_row,
00816                 JDIMENSION num_rows,
00817                 boolean writable));
00818         JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
00819                 jvirt_barray_ptr ptr,
00820                 JDIMENSION start_row,
00821                 JDIMENSION num_rows,
00822                 boolean writable));
00823         JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
00824         JMETHOD(void, self_destruct, (j_common_ptr cinfo));
00825 
00826         /* Limit on memory allocation for this JPEG object.  (Note that this is
00827          * merely advisory, not a guaranteed maximum; it only affects the space
00828          * used for virtual-array buffers.)  May be changed by outer application
00829          * after creating the JPEG object.
00830          */
00831         long max_memory_to_use;
00832     };
00833 
00834 
00835     /* Routine signature for application-supplied marker processing methods.
00836      * Need not pass marker code since it is stored in cinfo->unread_marker.
00837      */
00838     typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
00839 
00840 
00841     /* Declarations for routines called by application.
00842      * The JPP macro hides prototype parameters from compilers that can't cope.
00843      * Note JPP requires double parentheses.
00844      */
00845 
00846 #ifdef HAVE_PROTOTYPES
00847 #define JPP(arglist)    arglist
00848 #else
00849 #define JPP(arglist)    ()
00850 #endif
00851 
00852 
00853     /* Short forms of external names for systems with brain-damaged linkers.
00854      * We shorten external names to be unique in the first six letters, which
00855      * is good enough for all known systems.
00856      * (If your compiler itself needs names to be unique in less than 15
00857      * characters, you are out of luck.  Get a better compiler.)
00858      */
00859 
00860 #ifdef NEED_SHORT_EXTERNAL_NAMES
00861 #define jpeg_std_error          jStdError
00862 #define jpeg_create_compress    jCreaCompress
00863 #define jpeg_create_decompress  jCreaDecompress
00864 #define jpeg_destroy_compress   jDestCompress
00865 #define jpeg_destroy_decompress jDestDecompress
00866 #define jpeg_stdio_dest         jStdDest
00867 #define jpeg_stdio_src          jStdSrc
00868 #define jpeg_set_defaults       jSetDefaults
00869 #define jpeg_set_colorspace     jSetColorspace
00870 #define jpeg_default_colorspace jDefColorspace
00871 #define jpeg_set_quality        jSetQuality
00872 #define jpeg_set_linear_quality jSetLQuality
00873 #define jpeg_add_quant_table    jAddQuantTable
00874 #define jpeg_quality_scaling    jQualityScaling
00875 #define jpeg_simple_progression jSimProgress
00876 #define jpeg_suppress_tables    jSuppressTables
00877 #define jpeg_alloc_quant_table  jAlcQTable
00878 #define jpeg_alloc_huff_table   jAlcHTable
00879 #define jpeg_start_compress     jStrtCompress
00880 #define jpeg_write_scanlines    jWrtScanlines
00881 #define jpeg_finish_compress    jFinCompress
00882 #define jpeg_write_raw_data     jWrtRawData
00883 #define jpeg_write_marker       jWrtMarker
00884 #define jpeg_write_tables       jWrtTables
00885 #define jpeg_read_header        jReadHeader
00886 #define jpeg_start_decompress   jStrtDecompress
00887 #define jpeg_read_scanlines     jReadScanlines
00888 #define jpeg_finish_decompress  jFinDecompress
00889 #define jpeg_read_raw_data      jReadRawData
00890 #define jpeg_has_multiple_scans jHasMultScn
00891 #define jpeg_start_output       jStrtOutput
00892 #define jpeg_finish_output      jFinOutput
00893 #define jpeg_input_complete     jInComplete
00894 #define jpeg_new_colormap       jNewCMap
00895 #define jpeg_consume_input      jConsumeInput
00896 #define jpeg_calc_output_dimensions     jCalcDimensions
00897 #define jpeg_set_marker_processor       jSetMarker
00898 #define jpeg_read_coefficients  jReadCoefs
00899 #define jpeg_write_coefficients jWrtCoefs
00900 #define jpeg_copy_critical_parameters   jCopyCrit
00901 #define jpeg_abort_compress     jAbrtCompress
00902 #define jpeg_abort_decompress   jAbrtDecompress
00903 #define jpeg_abort              jAbort
00904 #define jpeg_destroy            jDestroy
00905 #define jpeg_resync_to_restart  jResyncRestart
00906 #endif /* NEED_SHORT_EXTERNAL_NAMES */
00907 
00908 
00909     /* Default error-management setup */
00910     EXTERN struct jpeg_error_mgr *jpeg_std_error JPP((struct jpeg_error_mgr *err));
00911 
00912     /* Initialization and destruction of JPEG compression objects */
00913     /* NB: you must set up the error-manager BEFORE calling jpeg_create_xxx */
00914     EXTERN void jpeg_create_compress JPP((j_compress_ptr cinfo));
00915     EXTERN void jpeg_create_decompress JPP((j_decompress_ptr cinfo));
00916     EXTERN void jpeg_destroy_compress JPP((j_compress_ptr cinfo));
00917     EXTERN void jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
00918 
00919     /* Standard data source and destination managers: stdio streams. */
00920     /* Caller is responsible for opening the file before and closing after. */
00921     EXTERN void jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
00922     EXTERN void jpeg_stdio_src JPP((j_decompress_ptr cinfo, unsigned char *infile));
00923 
00924     /* Default parameter setup for compression */
00925     EXTERN void jpeg_set_defaults JPP((j_compress_ptr cinfo));
00926     /* Compression parameter setup aids */
00927     EXTERN void jpeg_set_colorspace JPP((j_compress_ptr cinfo,
00928                                          J_COLOR_SPACE colorspace));
00929     EXTERN void jpeg_default_colorspace JPP((j_compress_ptr cinfo));
00930     EXTERN void jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
00931                                       boolean force_baseline));
00932     EXTERN void jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
00933                                             int scale_factor,
00934                                             boolean force_baseline));
00935     EXTERN void jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
00936                                           const unsigned int *basic_table,
00937                                           int scale_factor,
00938                                           boolean force_baseline));
00939     EXTERN int jpeg_quality_scaling JPP((int quality));
00940     EXTERN void jpeg_simple_progression JPP((j_compress_ptr cinfo));
00941     EXTERN void jpeg_suppress_tables JPP((j_compress_ptr cinfo,
00942                                           boolean suppress));
00943     EXTERN JQUANT_TBL * jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
00944     EXTERN JHUFF_TBL * jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
00945 
00946     /* Main entry points for compression */
00947     EXTERN void jpeg_start_compress JPP((j_compress_ptr cinfo,
00948                                          boolean write_all_tables));
00949     EXTERN JDIMENSION jpeg_write_scanlines JPP((j_compress_ptr cinfo,
00950             JSAMPARRAY scanlines,
00951             JDIMENSION num_lines));
00952     EXTERN void jpeg_finish_compress JPP((j_compress_ptr cinfo));
00953 
00954     /* Replaces jpeg_write_scanlines when writing raw downsampled data. */
00955     EXTERN JDIMENSION jpeg_write_raw_data JPP((j_compress_ptr cinfo,
00956             JSAMPIMAGE data,
00957             JDIMENSION num_lines));
00958 
00959     /* Write a special marker.  See libjpeg.doc concerning safe usage. */
00960     EXTERN void jpeg_write_marker JPP((j_compress_ptr cinfo, int marker,
00961                                        const JOCTET *dataptr, unsigned int datalen));
00962 
00963     /* Alternate compression function: just write an abbreviated table file */
00964     EXTERN void jpeg_write_tables JPP((j_compress_ptr cinfo));
00965 
00966     /* Decompression startup: read start of JPEG datastream to see what's there */
00967     EXTERN int jpeg_read_header JPP((j_decompress_ptr cinfo,
00968                                      boolean require_image));
00969     /* Return value is one of: */
00970 #define JPEG_SUSPENDED          0 /* Suspended due to lack of input data */
00971 #define JPEG_HEADER_OK          1 /* Found valid image datastream */
00972 #define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
00973     /* If you pass require_image = TRUE (normal case), you need not check for
00974      * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
00975      * JPEG_SUSPENDED is only possible if you use a data source module that can
00976      * give a suspension return (the stdio source module doesn't).
00977      */
00978 
00979     /* Main entry points for decompression */
00980     EXTERN boolean jpeg_start_decompress JPP((j_decompress_ptr cinfo));
00981     EXTERN JDIMENSION jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
00982             JSAMPARRAY scanlines,
00983             JDIMENSION max_lines));
00984     EXTERN boolean jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
00985 
00986     /* Replaces jpeg_read_scanlines when reading raw downsampled data. */
00987     EXTERN JDIMENSION jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
00988             JSAMPIMAGE data,
00989             JDIMENSION max_lines));
00990 
00991     /* Additional entry points for buffered-image mode. */
00992     EXTERN boolean jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
00993     EXTERN boolean jpeg_start_output JPP((j_decompress_ptr cinfo,
00994                                           int scan_number));
00995     EXTERN boolean jpeg_finish_output JPP((j_decompress_ptr cinfo));
00996     EXTERN boolean jpeg_input_complete JPP((j_decompress_ptr cinfo));
00997     EXTERN void jpeg_new_colormap JPP((j_decompress_ptr cinfo));
00998     EXTERN int jpeg_consume_input JPP((j_decompress_ptr cinfo));
00999     /* Return value is one of: */
01000     /* #define JPEG_SUSPENDED   0    Suspended due to lack of input data */
01001 #define JPEG_REACHED_SOS        1 /* Reached start of new scan */
01002 #define JPEG_REACHED_EOI        2 /* Reached end of image */
01003 #define JPEG_ROW_COMPLETED      3 /* Completed one iMCU row */
01004 #define JPEG_SCAN_COMPLETED     4 /* Completed last iMCU row of a scan */
01005 
01006     /* Precalculate output dimensions for current decompression parameters. */
01007     EXTERN void jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
01008 
01009     /* Install a special processing method for COM or APPn markers. */
01010     EXTERN void jpeg_set_marker_processor JPP((j_decompress_ptr cinfo,
01011             int marker_code,
01012             jpeg_marker_parser_method routine));
01013 
01014     /* Read or write raw DCT coefficients --- useful for lossless transcoding. */
01015     EXTERN jvirt_barray_ptr * jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
01016     EXTERN void jpeg_write_coefficients JPP((j_compress_ptr cinfo,
01017                                             jvirt_barray_ptr * coef_arrays));
01018     EXTERN void jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
01019             j_compress_ptr dstinfo));
01020 
01021     /* If you choose to abort compression or decompression before completing
01022      * jpeg_finish_(de)compress, then you need to clean up to release memory,
01023      * temporary files, etc.  You can just call jpeg_destroy_(de)compress
01024      * if you're done with the JPEG object, but if you want to clean it up and
01025      * reuse it, call this:
01026      */
01027     EXTERN void jpeg_abort_compress JPP((j_compress_ptr cinfo));
01028     EXTERN void jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
01029 
01030     /* Generic versions of jpeg_abort and jpeg_destroy that work on either
01031      * flavor of JPEG object.  These may be more convenient in some places.
01032      */
01033     EXTERN void jpeg_abort JPP((j_common_ptr cinfo));
01034     EXTERN void jpeg_destroy JPP((j_common_ptr cinfo));
01035 
01036     /* Default restart-marker-resync procedure for use by data source modules */
01037     EXTERN boolean jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
01038             int desired));
01039 
01040 
01041     /* These marker codes are exported since applications and data source modules
01042      * are likely to want to use them.
01043      */
01044 
01045 #define JPEG_RST0       0xD0    /* RST0 marker code */
01046 #define JPEG_EOI        0xD9    /* EOI marker code */
01047 #define JPEG_APP0       0xE0    /* APP0 marker code */
01048 #define JPEG_COM        0xFE    /* COM marker code */
01049 
01050 
01051     /* If we have a brain-damaged compiler that emits warnings (or worse, errors)
01052      * for structure definitions that are never filled in, keep it quiet by
01053      * supplying dummy definitions for the various substructures.
01054      */
01055 
01056 #ifdef INCOMPLETE_TYPES_BROKEN
01057 #ifndef JPEG_INTERNALS          /* will be defined in jpegint.h */
01058     struct jvirt_sarray_control
01059     {
01060         long dummy;
01061     };
01062     struct jvirt_barray_control
01063     {
01064         long dummy;
01065     };
01066     struct jpeg_comp_master
01067     {
01068         long dummy;
01069     };
01070     struct jpeg_c_main_controller
01071     {
01072         long dummy;
01073     };
01074     struct jpeg_c_prep_controller
01075     {
01076         long dummy;
01077     };
01078     struct jpeg_c_coef_controller
01079     {
01080         long dummy;
01081     };
01082     struct jpeg_marker_writer
01083     {
01084         long dummy;
01085     };
01086     struct jpeg_color_converter
01087     {
01088         long dummy;
01089     };
01090     struct jpeg_downsampler
01091     {
01092         long dummy;
01093     };
01094     struct jpeg_forward_dct
01095     {
01096         long dummy;
01097     };
01098     struct jpeg_entropy_encoder
01099     {
01100         long dummy;
01101     };
01102     struct jpeg_decomp_master
01103     {
01104         long dummy;
01105     };
01106     struct jpeg_d_main_controller
01107     {
01108         long dummy;
01109     };
01110     struct jpeg_d_coef_controller
01111     {
01112         long dummy;
01113     };
01114     struct jpeg_d_post_controller
01115     {
01116         long dummy;
01117     };
01118     struct jpeg_input_controller
01119     {
01120         long dummy;
01121     };
01122     struct jpeg_marker_reader
01123     {
01124         long dummy;
01125     };
01126     struct jpeg_entropy_decoder
01127     {
01128         long dummy;
01129     };
01130     struct jpeg_inverse_dct
01131     {
01132         long dummy;
01133     };
01134     struct jpeg_upsampler
01135     {
01136         long dummy;
01137     };
01138     struct jpeg_color_deconverter
01139     {
01140         long dummy;
01141     };
01142     struct jpeg_color_quantizer
01143     {
01144         long dummy;
01145     };
01146 #endif /* JPEG_INTERNALS */
01147 #endif /* INCOMPLETE_TYPES_BROKEN */
01148 
01149 
01150     /*
01151      * The JPEG library modules define JPEG_INTERNALS before including this file.
01152      * The internal structure declarations are read only when that is true.
01153      * Applications using the library should not include jpegint.h, but may wish
01154      * to include jerror.h.
01155      */
01156 
01157 #ifdef JPEG_INTERNALS
01158 #include "jpegint.h"            /* fetch private declarations */
01159 #include "jerror.h"             /* fetch error codes too */
01160 #endif
01161 
01162 #ifdef __cplusplus
01163 }
01164 #endif
01165 
01166 #endif /* JPEGLIB_H */
 All Classes Functions