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