w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

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