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



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: 3316834cb Wed Aug 21 11:42:56 2019 +0200 at miƩ ago 21 11:50:11 CEST 2019