source: trunk/third/jpeg/jpeglib.h @ 15227

Revision 15227, 45.1 KB checked in by ghudson, 24 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r15226, which included commits to RCS files with non-trunk default branches.
Line 
1/*
2 * jpeglib.h
3 *
4 * Copyright (C) 1991-1998, Thomas G. Lane.
5 * This file is part of the Independent JPEG Group's software.
6 * For conditions of distribution and use, see the accompanying README file.
7 *
8 * This file defines the application interface for the JPEG library.
9 * Most applications using the library need only include this file,
10 * and perhaps jerror.h if they want to know the exact error codes.
11 */
12
13#ifndef JPEGLIB_H
14#define JPEGLIB_H
15
16/*
17 * First we include the configuration files that record how this
18 * installation of the JPEG library is set up.  jconfig.h can be
19 * generated automatically for many systems.  jmorecfg.h contains
20 * manual configuration options that most people need not worry about.
21 */
22
23#ifndef JCONFIG_INCLUDED        /* in case jinclude.h already did */
24#include "jconfig.h"            /* widely used configuration options */
25#endif
26#include "jmorecfg.h"           /* seldom changed options */
27
28
29/* Version ID for the JPEG library.
30 * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
31 */
32
33#define JPEG_LIB_VERSION  62    /* Version 6b */
34
35
36/* Various constants determining the sizes of things.
37 * All of these are specified by the JPEG standard, so don't change them
38 * if you want to be compatible.
39 */
40
41#define DCTSIZE             8   /* The basic DCT block is 8x8 samples */
42#define DCTSIZE2            64  /* DCTSIZE squared; # of elements in a block */
43#define NUM_QUANT_TBLS      4   /* Quantization tables are numbered 0..3 */
44#define NUM_HUFF_TBLS       4   /* Huffman tables are numbered 0..3 */
45#define NUM_ARITH_TBLS      16  /* Arith-coding tables are numbered 0..15 */
46#define MAX_COMPS_IN_SCAN   4   /* JPEG limit on # of components in one scan */
47#define MAX_SAMP_FACTOR     4   /* JPEG limit on sampling factors */
48/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
49 * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
50 * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
51 * to handle it.  We even let you do this from the jconfig.h file.  However,
52 * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
53 * sometimes emits noncompliant files doesn't mean you should too.
54 */
55#define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
56#ifndef D_MAX_BLOCKS_IN_MCU
57#define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
58#endif
59
60
61/* Data structures for images (arrays of samples and of DCT coefficients).
62 * On 80x86 machines, the image arrays are too big for near pointers,
63 * but the pointer arrays can fit in near memory.
64 */
65
66typedef JSAMPLE FAR *JSAMPROW;  /* ptr to one image row of pixel samples. */
67typedef JSAMPROW *JSAMPARRAY;   /* ptr to some rows (a 2-D sample array) */
68typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */
69
70typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
71typedef JBLOCK FAR *JBLOCKROW;  /* pointer to one row of coefficient blocks */
72typedef JBLOCKROW *JBLOCKARRAY;         /* a 2-D array of coefficient blocks */
73typedef JBLOCKARRAY *JBLOCKIMAGE;       /* a 3-D array of coefficient blocks */
74
75typedef JCOEF FAR *JCOEFPTR;    /* useful in a couple of places */
76
77
78/* Types for JPEG compression parameters and working tables. */
79
80
81/* DCT coefficient quantization tables. */
82
83typedef struct {
84  /* This array gives the coefficient quantizers in natural array order
85   * (not the zigzag order in which they are stored in a JPEG DQT marker).
86   * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
87   */
88  UINT16 quantval[DCTSIZE2];    /* quantization step for each coefficient */
89  /* This field is used only during compression.  It's initialized FALSE when
90   * the table is created, and set TRUE when it's been output to the file.
91   * You could suppress output of a table by setting this to TRUE.
92   * (See jpeg_suppress_tables for an example.)
93   */
94  boolean sent_table;           /* TRUE when table has been output */
95} JQUANT_TBL;
96
97
98/* Huffman coding tables. */
99
100typedef struct {
101  /* These two fields directly represent the contents of a JPEG DHT marker */
102  UINT8 bits[17];               /* bits[k] = # of symbols with codes of */
103                                /* length k bits; bits[0] is unused */
104  UINT8 huffval[256];           /* The symbols, in order of incr code length */
105  /* This field is used only during compression.  It's initialized FALSE when
106   * the table is created, and set TRUE when it's been output to the file.
107   * You could suppress output of a table by setting this to TRUE.
108   * (See jpeg_suppress_tables for an example.)
109   */
110  boolean sent_table;           /* TRUE when table has been output */
111} JHUFF_TBL;
112
113
114/* Basic info about one component (color channel). */
115
116typedef struct {
117  /* These values are fixed over the whole image. */
118  /* For compression, they must be supplied by parameter setup; */
119  /* for decompression, they are read from the SOF marker. */
120  int component_id;             /* identifier for this component (0..255) */
121  int component_index;          /* its index in SOF or cinfo->comp_info[] */
122  int h_samp_factor;            /* horizontal sampling factor (1..4) */
123  int v_samp_factor;            /* vertical sampling factor (1..4) */
124  int quant_tbl_no;             /* quantization table selector (0..3) */
125  /* These values may vary between scans. */
126  /* For compression, they must be supplied by parameter setup; */
127  /* for decompression, they are read from the SOS marker. */
128  /* The decompressor output side may not use these variables. */
129  int dc_tbl_no;                /* DC entropy table selector (0..3) */
130  int ac_tbl_no;                /* AC entropy table selector (0..3) */
131 
132  /* Remaining fields should be treated as private by applications. */
133 
134  /* These values are computed during compression or decompression startup: */
135  /* Component's size in DCT blocks.
136   * Any dummy blocks added to complete an MCU are not counted; therefore
137   * these values do not depend on whether a scan is interleaved or not.
138   */
139  JDIMENSION width_in_blocks;
140  JDIMENSION height_in_blocks;
141  /* Size of a DCT block in samples.  Always DCTSIZE for compression.
142   * For decompression this is the size of the output from one DCT block,
143   * reflecting any scaling we choose to apply during the IDCT step.
144   * Values of 1,2,4,8 are likely to be supported.  Note that different
145   * components may receive different IDCT scalings.
146   */
147  int DCT_scaled_size;
148  /* The downsampled dimensions are the component's actual, unpadded number
149   * of samples at the main buffer (preprocessing/compression interface), thus
150   * downsampled_width = ceil(image_width * Hi/Hmax)
151   * and similarly for height.  For decompression, IDCT scaling is included, so
152   * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
153   */
154  JDIMENSION downsampled_width;  /* actual width in samples */
155  JDIMENSION downsampled_height; /* actual height in samples */
156  /* This flag is used only for decompression.  In cases where some of the
157   * components will be ignored (eg grayscale output from YCbCr image),
158   * we can skip most computations for the unused components.
159   */
160  boolean component_needed;     /* do we need the value of this component? */
161
162  /* These values are computed before starting a scan of the component. */
163  /* The decompressor output side may not use these variables. */
164  int MCU_width;                /* number of blocks per MCU, horizontally */
165  int MCU_height;               /* number of blocks per MCU, vertically */
166  int MCU_blocks;               /* MCU_width * MCU_height */
167  int MCU_sample_width;         /* MCU width in samples, MCU_width*DCT_scaled_size */
168  int last_col_width;           /* # of non-dummy blocks across in last MCU */
169  int last_row_height;          /* # of non-dummy blocks down in last MCU */
170
171  /* Saved quantization table for component; NULL if none yet saved.
172   * See jdinput.c comments about the need for this information.
173   * This field is currently used only for decompression.
174   */
175  JQUANT_TBL * quant_table;
176
177  /* Private per-component storage for DCT or IDCT subsystem. */
178  void * dct_table;
179} jpeg_component_info;
180
181
182/* The script for encoding a multiple-scan file is an array of these: */
183
184typedef struct {
185  int comps_in_scan;            /* number of components encoded in this scan */
186  int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
187  int Ss, Se;                   /* progressive JPEG spectral selection parms */
188  int Ah, Al;                   /* progressive JPEG successive approx. parms */
189} jpeg_scan_info;
190
191/* The decompressor can save APPn and COM markers in a list of these: */
192
193typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr;
194
195struct jpeg_marker_struct {
196  jpeg_saved_marker_ptr next;   /* next in list, or NULL */
197  UINT8 marker;                 /* marker code: JPEG_COM, or JPEG_APP0+n */
198  unsigned int original_length; /* # bytes of data in the file */
199  unsigned int data_length;     /* # bytes of data saved at data[] */
200  JOCTET FAR * data;            /* the data contained in the marker */
201  /* the marker length word is not counted in data_length or original_length */
202};
203
204/* Known color spaces. */
205
206typedef enum {
207        JCS_UNKNOWN,            /* error/unspecified */
208        JCS_GRAYSCALE,          /* monochrome */
209        JCS_RGB,                /* red/green/blue */
210        JCS_YCbCr,              /* Y/Cb/Cr (also known as YUV) */
211        JCS_CMYK,               /* C/M/Y/K */
212        JCS_YCCK                /* Y/Cb/Cr/K */
213} J_COLOR_SPACE;
214
215/* DCT/IDCT algorithm options. */
216
217typedef enum {
218        JDCT_ISLOW,             /* slow but accurate integer algorithm */
219        JDCT_IFAST,             /* faster, less accurate integer method */
220        JDCT_FLOAT              /* floating-point: accurate, fast on fast HW */
221} J_DCT_METHOD;
222
223#ifndef JDCT_DEFAULT            /* may be overridden in jconfig.h */
224#define JDCT_DEFAULT  JDCT_ISLOW
225#endif
226#ifndef JDCT_FASTEST            /* may be overridden in jconfig.h */
227#define JDCT_FASTEST  JDCT_IFAST
228#endif
229
230/* Dithering options for decompression. */
231
232typedef enum {
233        JDITHER_NONE,           /* no dithering */
234        JDITHER_ORDERED,        /* simple ordered dither */
235        JDITHER_FS              /* Floyd-Steinberg error diffusion dither */
236} J_DITHER_MODE;
237
238
239/* Common fields between JPEG compression and decompression master structs. */
240
241#define jpeg_common_fields \
242  struct jpeg_error_mgr * err;  /* Error handler module */\
243  struct jpeg_memory_mgr * mem; /* Memory manager module */\
244  struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
245  void * client_data;           /* Available for use by application */\
246  boolean is_decompressor;      /* So common code can tell which is which */\
247  int global_state              /* For checking call sequence validity */
248
249/* Routines that are to be used by both halves of the library are declared
250 * to receive a pointer to this structure.  There are no actual instances of
251 * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
252 */
253struct jpeg_common_struct {
254  jpeg_common_fields;           /* Fields common to both master struct types */
255  /* Additional fields follow in an actual jpeg_compress_struct or
256   * jpeg_decompress_struct.  All three structs must agree on these
257   * initial fields!  (This would be a lot cleaner in C++.)
258   */
259};
260
261typedef struct jpeg_common_struct * j_common_ptr;
262typedef struct jpeg_compress_struct * j_compress_ptr;
263typedef struct jpeg_decompress_struct * j_decompress_ptr;
264
265
266/* Master record for a compression instance */
267
268struct jpeg_compress_struct {
269  jpeg_common_fields;           /* Fields shared with jpeg_decompress_struct */
270
271  /* Destination for compressed data */
272  struct jpeg_destination_mgr * dest;
273
274  /* Description of source image --- these fields must be filled in by
275   * outer application before starting compression.  in_color_space must
276   * be correct before you can even call jpeg_set_defaults().
277   */
278
279  JDIMENSION image_width;       /* input image width */
280  JDIMENSION image_height;      /* input image height */
281  int input_components;         /* # of color components in input image */
282  J_COLOR_SPACE in_color_space; /* colorspace of input image */
283
284  double input_gamma;           /* image gamma of input image */
285
286  /* Compression parameters --- these fields must be set before calling
287   * jpeg_start_compress().  We recommend calling jpeg_set_defaults() to
288   * initialize everything to reasonable defaults, then changing anything
289   * the application specifically wants to change.  That way you won't get
290   * burnt when new parameters are added.  Also note that there are several
291   * helper routines to simplify changing parameters.
292   */
293
294  int data_precision;           /* bits of precision in image data */
295
296  int num_components;           /* # of color components in JPEG image */
297  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
298
299  jpeg_component_info * comp_info;
300  /* comp_info[i] describes component that appears i'th in SOF */
301 
302  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
303  /* ptrs to coefficient quantization tables, or NULL if not defined */
304 
305  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
306  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
307  /* ptrs to Huffman coding tables, or NULL if not defined */
308 
309  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
310  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
311  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
312
313  int num_scans;                /* # of entries in scan_info array */
314  const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
315  /* The default value of scan_info is NULL, which causes a single-scan
316   * sequential JPEG file to be emitted.  To create a multi-scan file,
317   * set num_scans and scan_info to point to an array of scan definitions.
318   */
319
320  boolean raw_data_in;          /* TRUE=caller supplies downsampled data */
321  boolean arith_code;           /* TRUE=arithmetic coding, FALSE=Huffman */
322  boolean optimize_coding;      /* TRUE=optimize entropy encoding parms */
323  boolean CCIR601_sampling;     /* TRUE=first samples are cosited */
324  int smoothing_factor;         /* 1..100, or 0 for no input smoothing */
325  J_DCT_METHOD dct_method;      /* DCT algorithm selector */
326
327  /* The restart interval can be specified in absolute MCUs by setting
328   * restart_interval, or in MCU rows by setting restart_in_rows
329   * (in which case the correct restart_interval will be figured
330   * for each scan).
331   */
332  unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
333  int restart_in_rows;          /* if > 0, MCU rows per restart interval */
334
335  /* Parameters controlling emission of special markers. */
336
337  boolean write_JFIF_header;    /* should a JFIF marker be written? */
338  UINT8 JFIF_major_version;     /* What to write for the JFIF version number */
339  UINT8 JFIF_minor_version;
340  /* These three values are not used by the JPEG code, merely copied */
341  /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
342  /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
343  /* ratio is defined by X_density/Y_density even when density_unit=0. */
344  UINT8 density_unit;           /* JFIF code for pixel size units */
345  UINT16 X_density;             /* Horizontal pixel density */
346  UINT16 Y_density;             /* Vertical pixel density */
347  boolean write_Adobe_marker;   /* should an Adobe marker be written? */
348 
349  /* State variable: index of next scanline to be written to
350   * jpeg_write_scanlines().  Application may use this to control its
351   * processing loop, e.g., "while (next_scanline < image_height)".
352   */
353
354  JDIMENSION next_scanline;     /* 0 .. image_height-1  */
355
356  /* Remaining fields are known throughout compressor, but generally
357   * should not be touched by a surrounding application.
358   */
359
360  /*
361   * These fields are computed during compression startup
362   */
363  boolean progressive_mode;     /* TRUE if scan script uses progressive mode */
364  int max_h_samp_factor;        /* largest h_samp_factor */
365  int max_v_samp_factor;        /* largest v_samp_factor */
366
367  JDIMENSION total_iMCU_rows;   /* # of iMCU rows to be input to coef ctlr */
368  /* The coefficient controller receives data in units of MCU rows as defined
369   * for fully interleaved scans (whether the JPEG file is interleaved or not).
370   * There are v_samp_factor * DCTSIZE sample rows of each component in an
371   * "iMCU" (interleaved MCU) row.
372   */
373 
374  /*
375   * These fields are valid during any one scan.
376   * They describe the components and MCUs actually appearing in the scan.
377   */
378  int comps_in_scan;            /* # of JPEG components in this scan */
379  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
380  /* *cur_comp_info[i] describes component that appears i'th in SOS */
381 
382  JDIMENSION MCUs_per_row;      /* # of MCUs across the image */
383  JDIMENSION MCU_rows_in_scan;  /* # of MCU rows in the image */
384 
385  int blocks_in_MCU;            /* # of DCT blocks per MCU */
386  int MCU_membership[C_MAX_BLOCKS_IN_MCU];
387  /* MCU_membership[i] is index in cur_comp_info of component owning */
388  /* i'th block in an MCU */
389
390  int Ss, Se, Ah, Al;           /* progressive JPEG parameters for scan */
391
392  /*
393   * Links to compression subobjects (methods and private variables of modules)
394   */
395  struct jpeg_comp_master * master;
396  struct jpeg_c_main_controller * main;
397  struct jpeg_c_prep_controller * prep;
398  struct jpeg_c_coef_controller * coef;
399  struct jpeg_marker_writer * marker;
400  struct jpeg_color_converter * cconvert;
401  struct jpeg_downsampler * downsample;
402  struct jpeg_forward_dct * fdct;
403  struct jpeg_entropy_encoder * entropy;
404  jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */
405  int script_space_size;
406};
407
408
409/* Master record for a decompression instance */
410
411struct jpeg_decompress_struct {
412  jpeg_common_fields;           /* Fields shared with jpeg_compress_struct */
413
414  /* Source of compressed data */
415  struct jpeg_source_mgr * src;
416
417  /* Basic description of image --- filled in by jpeg_read_header(). */
418  /* Application may inspect these values to decide how to process image. */
419
420  JDIMENSION image_width;       /* nominal image width (from SOF marker) */
421  JDIMENSION image_height;      /* nominal image height */
422  int num_components;           /* # of color components in JPEG image */
423  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
424
425  /* Decompression processing parameters --- these fields must be set before
426   * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
427   * them to default values.
428   */
429
430  J_COLOR_SPACE out_color_space; /* colorspace for output */
431
432  unsigned int scale_num, scale_denom; /* fraction by which to scale image */
433
434  double output_gamma;          /* image gamma wanted in output */
435
436  boolean buffered_image;       /* TRUE=multiple output passes */
437  boolean raw_data_out;         /* TRUE=downsampled data wanted */
438
439  J_DCT_METHOD dct_method;      /* IDCT algorithm selector */
440  boolean do_fancy_upsampling;  /* TRUE=apply fancy upsampling */
441  boolean do_block_smoothing;   /* TRUE=apply interblock smoothing */
442
443  boolean quantize_colors;      /* TRUE=colormapped output wanted */
444  /* the following are ignored if not quantize_colors: */
445  J_DITHER_MODE dither_mode;    /* type of color dithering to use */
446  boolean two_pass_quantize;    /* TRUE=use two-pass color quantization */
447  int desired_number_of_colors; /* max # colors to use in created colormap */
448  /* these are significant only in buffered-image mode: */
449  boolean enable_1pass_quant;   /* enable future use of 1-pass quantizer */
450  boolean enable_external_quant;/* enable future use of external colormap */
451  boolean enable_2pass_quant;   /* enable future use of 2-pass quantizer */
452
453  /* Description of actual output image that will be returned to application.
454   * These fields are computed by jpeg_start_decompress().
455   * You can also use jpeg_calc_output_dimensions() to determine these values
456   * in advance of calling jpeg_start_decompress().
457   */
458
459  JDIMENSION output_width;      /* scaled image width */
460  JDIMENSION output_height;     /* scaled image height */
461  int out_color_components;     /* # of color components in out_color_space */
462  int output_components;        /* # of color components returned */
463  /* output_components is 1 (a colormap index) when quantizing colors;
464   * otherwise it equals out_color_components.
465   */
466  int rec_outbuf_height;        /* min recommended height of scanline buffer */
467  /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
468   * high, space and time will be wasted due to unnecessary data copying.
469   * Usually rec_outbuf_height will be 1 or 2, at most 4.
470   */
471
472  /* When quantizing colors, the output colormap is described by these fields.
473   * The application can supply a colormap by setting colormap non-NULL before
474   * calling jpeg_start_decompress; otherwise a colormap is created during
475   * jpeg_start_decompress or jpeg_start_output.
476   * The map has out_color_components rows and actual_number_of_colors columns.
477   */
478  int actual_number_of_colors;  /* number of entries in use */
479  JSAMPARRAY colormap;          /* The color map as a 2-D pixel array */
480
481  /* State variables: these variables indicate the progress of decompression.
482   * The application may examine these but must not modify them.
483   */
484
485  /* Row index of next scanline to be read from jpeg_read_scanlines().
486   * Application may use this to control its processing loop, e.g.,
487   * "while (output_scanline < output_height)".
488   */
489  JDIMENSION output_scanline;   /* 0 .. output_height-1  */
490
491  /* Current input scan number and number of iMCU rows completed in scan.
492   * These indicate the progress of the decompressor input side.
493   */
494  int input_scan_number;        /* Number of SOS markers seen so far */
495  JDIMENSION input_iMCU_row;    /* Number of iMCU rows completed */
496
497  /* The "output scan number" is the notional scan being displayed by the
498   * output side.  The decompressor will not allow output scan/row number
499   * to get ahead of input scan/row, but it can fall arbitrarily far behind.
500   */
501  int output_scan_number;       /* Nominal scan number being displayed */
502  JDIMENSION output_iMCU_row;   /* Number of iMCU rows read */
503
504  /* Current progression status.  coef_bits[c][i] indicates the precision
505   * with which component c's DCT coefficient i (in zigzag order) is known.
506   * It is -1 when no data has yet been received, otherwise it is the point
507   * transform (shift) value for the most recent scan of the coefficient
508   * (thus, 0 at completion of the progression).
509   * This pointer is NULL when reading a non-progressive file.
510   */
511  int (*coef_bits)[DCTSIZE2];   /* -1 or current Al value for each coef */
512
513  /* Internal JPEG parameters --- the application usually need not look at
514   * these fields.  Note that the decompressor output side may not use
515   * any parameters that can change between scans.
516   */
517
518  /* Quantization and Huffman tables are carried forward across input
519   * datastreams when processing abbreviated JPEG datastreams.
520   */
521
522  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
523  /* ptrs to coefficient quantization tables, or NULL if not defined */
524
525  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
526  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
527  /* ptrs to Huffman coding tables, or NULL if not defined */
528
529  /* These parameters are never carried across datastreams, since they
530   * are given in SOF/SOS markers or defined to be reset by SOI.
531   */
532
533  int data_precision;           /* bits of precision in image data */
534
535  jpeg_component_info * comp_info;
536  /* comp_info[i] describes component that appears i'th in SOF */
537
538  boolean progressive_mode;     /* TRUE if SOFn specifies progressive mode */
539  boolean arith_code;           /* TRUE=arithmetic coding, FALSE=Huffman */
540
541  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
542  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
543  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
544
545  unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
546
547  /* These fields record data obtained from optional markers recognized by
548   * the JPEG library.
549   */
550  boolean saw_JFIF_marker;      /* TRUE iff a JFIF APP0 marker was found */
551  /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
552  UINT8 JFIF_major_version;     /* JFIF version number */
553  UINT8 JFIF_minor_version;
554  UINT8 density_unit;           /* JFIF code for pixel size units */
555  UINT16 X_density;             /* Horizontal pixel density */
556  UINT16 Y_density;             /* Vertical pixel density */
557  boolean saw_Adobe_marker;     /* TRUE iff an Adobe APP14 marker was found */
558  UINT8 Adobe_transform;        /* Color transform code from Adobe marker */
559
560  boolean CCIR601_sampling;     /* TRUE=first samples are cosited */
561
562  /* Aside from the specific data retained from APPn markers known to the
563   * library, the uninterpreted contents of any or all APPn and COM markers
564   * can be saved in a list for examination by the application.
565   */
566  jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
567
568  /* Remaining fields are known throughout decompressor, but generally
569   * should not be touched by a surrounding application.
570   */
571
572  /*
573   * These fields are computed during decompression startup
574   */
575  int max_h_samp_factor;        /* largest h_samp_factor */
576  int max_v_samp_factor;        /* largest v_samp_factor */
577
578  int min_DCT_scaled_size;      /* smallest DCT_scaled_size of any component */
579
580  JDIMENSION total_iMCU_rows;   /* # of iMCU rows in image */
581  /* The coefficient controller's input and output progress is measured in
582   * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
583   * in fully interleaved JPEG scans, but are used whether the scan is
584   * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
585   * rows of each component.  Therefore, the IDCT output contains
586   * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
587   */
588
589  JSAMPLE * sample_range_limit; /* table for fast range-limiting */
590
591  /*
592   * These fields are valid during any one scan.
593   * They describe the components and MCUs actually appearing in the scan.
594   * Note that the decompressor output side must not use these fields.
595   */
596  int comps_in_scan;            /* # of JPEG components in this scan */
597  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
598  /* *cur_comp_info[i] describes component that appears i'th in SOS */
599
600  JDIMENSION MCUs_per_row;      /* # of MCUs across the image */
601  JDIMENSION MCU_rows_in_scan;  /* # of MCU rows in the image */
602
603  int blocks_in_MCU;            /* # of DCT blocks per MCU */
604  int MCU_membership[D_MAX_BLOCKS_IN_MCU];
605  /* MCU_membership[i] is index in cur_comp_info of component owning */
606  /* i'th block in an MCU */
607
608  int Ss, Se, Ah, Al;           /* progressive JPEG parameters for scan */
609
610  /* This field is shared between entropy decoder and marker parser.
611   * It is either zero or the code of a JPEG marker that has been
612   * read from the data source, but has not yet been processed.
613   */
614  int unread_marker;
615
616  /*
617   * Links to decompression subobjects (methods, private variables of modules)
618   */
619  struct jpeg_decomp_master * master;
620  struct jpeg_d_main_controller * main;
621  struct jpeg_d_coef_controller * coef;
622  struct jpeg_d_post_controller * post;
623  struct jpeg_input_controller * inputctl;
624  struct jpeg_marker_reader * marker;
625  struct jpeg_entropy_decoder * entropy;
626  struct jpeg_inverse_dct * idct;
627  struct jpeg_upsampler * upsample;
628  struct jpeg_color_deconverter * cconvert;
629  struct jpeg_color_quantizer * cquantize;
630};
631
632
633/* "Object" declarations for JPEG modules that may be supplied or called
634 * directly by the surrounding application.
635 * As with all objects in the JPEG library, these structs only define the
636 * publicly visible methods and state variables of a module.  Additional
637 * private fields may exist after the public ones.
638 */
639
640
641/* Error handler object */
642
643struct jpeg_error_mgr {
644  /* Error exit handler: does not return to caller */
645  JMETHOD(void, error_exit, (j_common_ptr cinfo));
646  /* Conditionally emit a trace or warning message */
647  JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
648  /* Routine that actually outputs a trace or error message */
649  JMETHOD(void, output_message, (j_common_ptr cinfo));
650  /* Format a message string for the most recent JPEG error or message */
651  JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
652#define JMSG_LENGTH_MAX  200    /* recommended size of format_message buffer */
653  /* Reset error state variables at start of a new image */
654  JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
655 
656  /* The message ID code and any parameters are saved here.
657   * A message can have one string parameter or up to 8 int parameters.
658   */
659  int msg_code;
660#define JMSG_STR_PARM_MAX  80
661  union {
662    int i[8];
663    char s[JMSG_STR_PARM_MAX];
664  } msg_parm;
665 
666  /* Standard state variables for error facility */
667 
668  int trace_level;              /* max msg_level that will be displayed */
669 
670  /* For recoverable corrupt-data errors, we emit a warning message,
671   * but keep going unless emit_message chooses to abort.  emit_message
672   * should count warnings in num_warnings.  The surrounding application
673   * can check for bad data by seeing if num_warnings is nonzero at the
674   * end of processing.
675   */
676  long num_warnings;            /* number of corrupt-data warnings */
677
678  /* These fields point to the table(s) of error message strings.
679   * An application can change the table pointer to switch to a different
680   * message list (typically, to change the language in which errors are
681   * reported).  Some applications may wish to add additional error codes
682   * that will be handled by the JPEG library error mechanism; the second
683   * table pointer is used for this purpose.
684   *
685   * First table includes all errors generated by JPEG library itself.
686   * Error code 0 is reserved for a "no such error string" message.
687   */
688  const char * const * jpeg_message_table; /* Library errors */
689  int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */
690  /* Second table can be added by application (see cjpeg/djpeg for example).
691   * It contains strings numbered first_addon_message..last_addon_message.
692   */
693  const char * const * addon_message_table; /* Non-library errors */
694  int first_addon_message;      /* code for first string in addon table */
695  int last_addon_message;       /* code for last string in addon table */
696};
697
698
699/* Progress monitor object */
700
701struct jpeg_progress_mgr {
702  JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
703
704  long pass_counter;            /* work units completed in this pass */
705  long pass_limit;              /* total number of work units in this pass */
706  int completed_passes;         /* passes completed so far */
707  int total_passes;             /* total number of passes expected */
708};
709
710
711/* Data destination object for compression */
712
713struct jpeg_destination_mgr {
714  JOCTET * next_output_byte;    /* => next byte to write in buffer */
715  size_t free_in_buffer;        /* # of byte spaces remaining in buffer */
716
717  JMETHOD(void, init_destination, (j_compress_ptr cinfo));
718  JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
719  JMETHOD(void, term_destination, (j_compress_ptr cinfo));
720};
721
722
723/* Data source object for decompression */
724
725struct jpeg_source_mgr {
726  const JOCTET * next_input_byte; /* => next byte to read from buffer */
727  size_t bytes_in_buffer;       /* # of bytes remaining in buffer */
728
729  JMETHOD(void, init_source, (j_decompress_ptr cinfo));
730  JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
731  JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
732  JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
733  JMETHOD(void, term_source, (j_decompress_ptr cinfo));
734};
735
736
737/* Memory manager object.
738 * Allocates "small" objects (a few K total), "large" objects (tens of K),
739 * and "really big" objects (virtual arrays with backing store if needed).
740 * The memory manager does not allow individual objects to be freed; rather,
741 * each created object is assigned to a pool, and whole pools can be freed
742 * at once.  This is faster and more convenient than remembering exactly what
743 * to free, especially where malloc()/free() are not too speedy.
744 * NB: alloc routines never return NULL.  They exit to error_exit if not
745 * successful.
746 */
747
748#define JPOOL_PERMANENT 0       /* lasts until master record is destroyed */
749#define JPOOL_IMAGE     1       /* lasts until done with image/datastream */
750#define JPOOL_NUMPOOLS  2
751
752typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
753typedef struct jvirt_barray_control * jvirt_barray_ptr;
754
755
756struct jpeg_memory_mgr {
757  /* Method pointers */
758  JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
759                                size_t sizeofobject));
760  JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
761                                     size_t sizeofobject));
762  JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
763                                     JDIMENSION samplesperrow,
764                                     JDIMENSION numrows));
765  JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
766                                      JDIMENSION blocksperrow,
767                                      JDIMENSION numrows));
768  JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
769                                                  int pool_id,
770                                                  boolean pre_zero,
771                                                  JDIMENSION samplesperrow,
772                                                  JDIMENSION numrows,
773                                                  JDIMENSION maxaccess));
774  JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
775                                                  int pool_id,
776                                                  boolean pre_zero,
777                                                  JDIMENSION blocksperrow,
778                                                  JDIMENSION numrows,
779                                                  JDIMENSION maxaccess));
780  JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
781  JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
782                                           jvirt_sarray_ptr ptr,
783                                           JDIMENSION start_row,
784                                           JDIMENSION num_rows,
785                                           boolean writable));
786  JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
787                                            jvirt_barray_ptr ptr,
788                                            JDIMENSION start_row,
789                                            JDIMENSION num_rows,
790                                            boolean writable));
791  JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
792  JMETHOD(void, self_destruct, (j_common_ptr cinfo));
793
794  /* Limit on memory allocation for this JPEG object.  (Note that this is
795   * merely advisory, not a guaranteed maximum; it only affects the space
796   * used for virtual-array buffers.)  May be changed by outer application
797   * after creating the JPEG object.
798   */
799  long max_memory_to_use;
800
801  /* Maximum allocation request accepted by alloc_large. */
802  long max_alloc_chunk;
803};
804
805
806/* Routine signature for application-supplied marker processing methods.
807 * Need not pass marker code since it is stored in cinfo->unread_marker.
808 */
809typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
810
811
812/* Declarations for routines called by application.
813 * The JPP macro hides prototype parameters from compilers that can't cope.
814 * Note JPP requires double parentheses.
815 */
816
817#ifdef HAVE_PROTOTYPES
818#define JPP(arglist)    arglist
819#else
820#define JPP(arglist)    ()
821#endif
822
823
824/* Short forms of external names for systems with brain-damaged linkers.
825 * We shorten external names to be unique in the first six letters, which
826 * is good enough for all known systems.
827 * (If your compiler itself needs names to be unique in less than 15
828 * characters, you are out of luck.  Get a better compiler.)
829 */
830
831#ifdef NEED_SHORT_EXTERNAL_NAMES
832#define jpeg_std_error          jStdError
833#define jpeg_CreateCompress     jCreaCompress
834#define jpeg_CreateDecompress   jCreaDecompress
835#define jpeg_destroy_compress   jDestCompress
836#define jpeg_destroy_decompress jDestDecompress
837#define jpeg_stdio_dest         jStdDest
838#define jpeg_stdio_src          jStdSrc
839#define jpeg_set_defaults       jSetDefaults
840#define jpeg_set_colorspace     jSetColorspace
841#define jpeg_default_colorspace jDefColorspace
842#define jpeg_set_quality        jSetQuality
843#define jpeg_set_linear_quality jSetLQuality
844#define jpeg_add_quant_table    jAddQuantTable
845#define jpeg_quality_scaling    jQualityScaling
846#define jpeg_simple_progression jSimProgress
847#define jpeg_suppress_tables    jSuppressTables
848#define jpeg_alloc_quant_table  jAlcQTable
849#define jpeg_alloc_huff_table   jAlcHTable
850#define jpeg_start_compress     jStrtCompress
851#define jpeg_write_scanlines    jWrtScanlines
852#define jpeg_finish_compress    jFinCompress
853#define jpeg_write_raw_data     jWrtRawData
854#define jpeg_write_marker       jWrtMarker
855#define jpeg_write_m_header     jWrtMHeader
856#define jpeg_write_m_byte       jWrtMByte
857#define jpeg_write_tables       jWrtTables
858#define jpeg_read_header        jReadHeader
859#define jpeg_start_decompress   jStrtDecompress
860#define jpeg_read_scanlines     jReadScanlines
861#define jpeg_finish_decompress  jFinDecompress
862#define jpeg_read_raw_data      jReadRawData
863#define jpeg_has_multiple_scans jHasMultScn
864#define jpeg_start_output       jStrtOutput
865#define jpeg_finish_output      jFinOutput
866#define jpeg_input_complete     jInComplete
867#define jpeg_new_colormap       jNewCMap
868#define jpeg_consume_input      jConsumeInput
869#define jpeg_calc_output_dimensions     jCalcDimensions
870#define jpeg_save_markers       jSaveMarkers
871#define jpeg_set_marker_processor       jSetMarker
872#define jpeg_read_coefficients  jReadCoefs
873#define jpeg_write_coefficients jWrtCoefs
874#define jpeg_copy_critical_parameters   jCopyCrit
875#define jpeg_abort_compress     jAbrtCompress
876#define jpeg_abort_decompress   jAbrtDecompress
877#define jpeg_abort              jAbort
878#define jpeg_destroy            jDestroy
879#define jpeg_resync_to_restart  jResyncRestart
880#endif /* NEED_SHORT_EXTERNAL_NAMES */
881
882
883/* Default error-management setup */
884EXTERN(struct jpeg_error_mgr *) jpeg_std_error
885        JPP((struct jpeg_error_mgr * err));
886
887/* Initialization of JPEG compression objects.
888 * jpeg_create_compress() and jpeg_create_decompress() are the exported
889 * names that applications should call.  These expand to calls on
890 * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
891 * passed for version mismatch checking.
892 * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
893 */
894#define jpeg_create_compress(cinfo) \
895    jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
896                        (size_t) sizeof(struct jpeg_compress_struct))
897#define jpeg_create_decompress(cinfo) \
898    jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
899                          (size_t) sizeof(struct jpeg_decompress_struct))
900EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo,
901                                      int version, size_t structsize));
902EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo,
903                                        int version, size_t structsize));
904/* Destruction of JPEG compression objects */
905EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo));
906EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
907
908/* Standard data source and destination managers: stdio streams. */
909/* Caller is responsible for opening the file before and closing after. */
910EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
911EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));
912
913/* Default parameter setup for compression */
914EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo));
915/* Compression parameter setup aids */
916EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo,
917                                      J_COLOR_SPACE colorspace));
918EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo));
919EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
920                                   boolean force_baseline));
921EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
922                                          int scale_factor,
923                                          boolean force_baseline));
924EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
925                                       const unsigned int *basic_table,
926                                       int scale_factor,
927                                       boolean force_baseline));
928EXTERN(int) jpeg_quality_scaling JPP((int quality));
929EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo));
930EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo,
931                                       boolean suppress));
932EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
933EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
934
935/* Main entry points for compression */
936EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,
937                                      boolean write_all_tables));
938EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,
939                                             JSAMPARRAY scanlines,
940                                             JDIMENSION num_lines));
941EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo));
942
943/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
944EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo,
945                                            JSAMPIMAGE data,
946                                            JDIMENSION num_lines));
947
948/* Write a special marker.  See libjpeg.doc concerning safe usage. */
949EXTERN(void) jpeg_write_marker
950        JPP((j_compress_ptr cinfo, int marker,
951             const JOCTET * dataptr, unsigned int datalen));
952/* Same, but piecemeal. */
953EXTERN(void) jpeg_write_m_header
954        JPP((j_compress_ptr cinfo, int marker, unsigned int datalen));
955EXTERN(void) jpeg_write_m_byte
956        JPP((j_compress_ptr cinfo, int val));
957
958/* Alternate compression function: just write an abbreviated table file */
959EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo));
960
961/* Decompression startup: read start of JPEG datastream to see what's there */
962EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,
963                                  boolean require_image));
964/* Return value is one of: */
965#define JPEG_SUSPENDED          0 /* Suspended due to lack of input data */
966#define JPEG_HEADER_OK          1 /* Found valid image datastream */
967#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
968/* If you pass require_image = TRUE (normal case), you need not check for
969 * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
970 * JPEG_SUSPENDED is only possible if you use a data source module that can
971 * give a suspension return (the stdio source module doesn't).
972 */
973
974/* Main entry points for decompression */
975EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo));
976EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
977                                            JSAMPARRAY scanlines,
978                                            JDIMENSION max_lines));
979EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
980
981/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
982EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
983                                           JSAMPIMAGE data,
984                                           JDIMENSION max_lines));
985
986/* Additional entry points for buffered-image mode. */
987EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
988EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo,
989                                       int scan_number));
990EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo));
991EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo));
992EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo));
993EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
994/* Return value is one of: */
995/* #define JPEG_SUSPENDED       0    Suspended due to lack of input data */
996#define JPEG_REACHED_SOS        1 /* Reached start of new scan */
997#define JPEG_REACHED_EOI        2 /* Reached end of image */
998#define JPEG_ROW_COMPLETED      3 /* Completed one iMCU row */
999#define JPEG_SCAN_COMPLETED     4 /* Completed last iMCU row of a scan */
1000
1001/* Precalculate output dimensions for current decompression parameters. */
1002EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
1003
1004/* Control saving of COM and APPn markers into marker_list. */
1005EXTERN(void) jpeg_save_markers
1006        JPP((j_decompress_ptr cinfo, int marker_code,
1007             unsigned int length_limit));
1008
1009/* Install a special processing method for COM or APPn markers. */
1010EXTERN(void) jpeg_set_marker_processor
1011        JPP((j_decompress_ptr cinfo, int marker_code,
1012             jpeg_marker_parser_method routine));
1013
1014/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
1015EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
1016EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo,
1017                                          jvirt_barray_ptr * coef_arrays));
1018EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
1019                                                j_compress_ptr dstinfo));
1020
1021/* If you choose to abort compression or decompression before completing
1022 * jpeg_finish_(de)compress, then you need to clean up to release memory,
1023 * temporary files, etc.  You can just call jpeg_destroy_(de)compress
1024 * if you're done with the JPEG object, but if you want to clean it up and
1025 * reuse it, call this:
1026 */
1027EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo));
1028EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
1029
1030/* Generic versions of jpeg_abort and jpeg_destroy that work on either
1031 * flavor of JPEG object.  These may be more convenient in some places.
1032 */
1033EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo));
1034EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo));
1035
1036/* Default restart-marker-resync procedure for use by data source modules */
1037EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
1038                                            int desired));
1039
1040
1041/* These marker codes are exported since applications and data source modules
1042 * are likely to want to use them.
1043 */
1044
1045#define JPEG_RST0       0xD0    /* RST0 marker code */
1046#define JPEG_EOI        0xD9    /* EOI marker code */
1047#define JPEG_APP0       0xE0    /* APP0 marker code */
1048#define JPEG_COM        0xFE    /* COM marker code */
1049
1050
1051/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
1052 * for structure definitions that are never filled in, keep it quiet by
1053 * supplying dummy definitions for the various substructures.
1054 */
1055
1056#ifdef INCOMPLETE_TYPES_BROKEN
1057#ifndef JPEG_INTERNALS          /* will be defined in jpegint.h */
1058struct jvirt_sarray_control { long dummy; };
1059struct jvirt_barray_control { long dummy; };
1060struct jpeg_comp_master { long dummy; };
1061struct jpeg_c_main_controller { long dummy; };
1062struct jpeg_c_prep_controller { long dummy; };
1063struct jpeg_c_coef_controller { long dummy; };
1064struct jpeg_marker_writer { long dummy; };
1065struct jpeg_color_converter { long dummy; };
1066struct jpeg_downsampler { long dummy; };
1067struct jpeg_forward_dct { long dummy; };
1068struct jpeg_entropy_encoder { long dummy; };
1069struct jpeg_decomp_master { long dummy; };
1070struct jpeg_d_main_controller { long dummy; };
1071struct jpeg_d_coef_controller { long dummy; };
1072struct jpeg_d_post_controller { long dummy; };
1073struct jpeg_input_controller { long dummy; };
1074struct jpeg_marker_reader { long dummy; };
1075struct jpeg_entropy_decoder { long dummy; };
1076struct jpeg_inverse_dct { long dummy; };
1077struct jpeg_upsampler { long dummy; };
1078struct jpeg_color_deconverter { long dummy; };
1079struct jpeg_color_quantizer { long dummy; };
1080#endif /* JPEG_INTERNALS */
1081#endif /* INCOMPLETE_TYPES_BROKEN */
1082
1083
1084/*
1085 * The JPEG library modules define JPEG_INTERNALS before including this file.
1086 * The internal structure declarations are read only when that is true.
1087 * Applications using the library should not include jpegint.h, but may wish
1088 * to include jerror.h.
1089 */
1090
1091#ifdef JPEG_INTERNALS
1092#include "jpegint.h"            /* fetch private declarations */
1093#include "jerror.h"             /* fetch error codes too */
1094#endif
1095
1096#endif /* JPEGLIB_H */
Note: See TracBrowser for help on using the repository browser.