ReactOS  0.4.14-dev-342-gdc047f9
jdmaster.c
Go to the documentation of this file.
1 /*
2  * jdmaster.c
3  *
4  * Copyright (C) 1991-1997, Thomas G. Lane.
5  * Modified 2002-2017 by Guido Vollbeding.
6  * This file is part of the Independent JPEG Group's software.
7  * For conditions of distribution and use, see the accompanying README file.
8  *
9  * This file contains master control logic for the JPEG decompressor.
10  * These routines are concerned with selecting the modules to be executed
11  * and with determining the number of passes and the work to be done in each
12  * pass.
13  */
14 
15 #define JPEG_INTERNALS
16 #include "jinclude.h"
17 #include "jpeglib.h"
18 
19 
20 /* Private state */
21 
22 typedef struct {
23  struct jpeg_decomp_master pub; /* public fields */
24 
25  int pass_number; /* # of passes completed */
26 
27  boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */
28 
29  /* Saved references to initialized quantizer modules,
30  * in case we need to switch modes.
31  */
35 
37 
38 
39 /*
40  * Determine whether merged upsample/color conversion should be used.
41  * CRUCIAL: this must match the actual capabilities of jdmerge.c!
42  */
43 
44 LOCAL(boolean)
46 {
47 #ifdef UPSAMPLE_MERGING_SUPPORTED
48  /* Merging is the equivalent of plain box-filter upsampling. */
49  /* The following condition is only needed if fancy shall select
50  * a different upsampling method. In our current implementation
51  * fancy only affects the DCT scaling, thus we can use fancy
52  * upsampling and merged upsample simultaneously, in particular
53  * with scaled DCT sizes larger than the default DCTSIZE.
54  */
55 #if 0
56  if (cinfo->do_fancy_upsampling)
57  return FALSE;
58 #endif
59  if (cinfo->CCIR601_sampling)
60  return FALSE;
61  /* jdmerge.c only supports YCC=>RGB color conversion */
62  if ((cinfo->jpeg_color_space != JCS_YCbCr &&
63  cinfo->jpeg_color_space != JCS_BG_YCC) ||
64  cinfo->num_components != 3 ||
65  cinfo->out_color_space != JCS_RGB ||
66  cinfo->out_color_components != RGB_PIXELSIZE ||
67  cinfo->color_transform)
68  return FALSE;
69  /* and it only handles 2h1v or 2h2v sampling ratios */
70  if (cinfo->comp_info[0].h_samp_factor != 2 ||
71  cinfo->comp_info[1].h_samp_factor != 1 ||
72  cinfo->comp_info[2].h_samp_factor != 1 ||
73  cinfo->comp_info[0].v_samp_factor > 2 ||
74  cinfo->comp_info[1].v_samp_factor != 1 ||
75  cinfo->comp_info[2].v_samp_factor != 1)
76  return FALSE;
77  /* furthermore, it doesn't work if we've scaled the IDCTs differently */
78  if (cinfo->comp_info[0].DCT_h_scaled_size != cinfo->min_DCT_h_scaled_size ||
79  cinfo->comp_info[1].DCT_h_scaled_size != cinfo->min_DCT_h_scaled_size ||
80  cinfo->comp_info[2].DCT_h_scaled_size != cinfo->min_DCT_h_scaled_size ||
81  cinfo->comp_info[0].DCT_v_scaled_size != cinfo->min_DCT_v_scaled_size ||
82  cinfo->comp_info[1].DCT_v_scaled_size != cinfo->min_DCT_v_scaled_size ||
83  cinfo->comp_info[2].DCT_v_scaled_size != cinfo->min_DCT_v_scaled_size)
84  return FALSE;
85  /* ??? also need to test for upsample-time rescaling, when & if supported */
86  return TRUE; /* by golly, it'll work... */
87 #else
88  return FALSE;
89 #endif
90 }
91 
92 
93 /*
94  * Compute output image dimensions and related values.
95  * NOTE: this is exported for possible use by application.
96  * Hence it mustn't do anything that can't be done twice.
97  * Also note that it may be called before the master module is initialized!
98  */
99 
100 GLOBAL(void)
102 /* Do computations that are needed before master selection phase.
103  * This function is used for full decompression.
104  */
105 {
106 #ifdef IDCT_SCALING_SUPPORTED
107  int ci;
109 #endif
110 
111  /* Prevent application from calling me at wrong times */
112  if (cinfo->global_state != DSTATE_READY)
113  ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
114 
115  /* Compute core output image dimensions and DCT scaling choices. */
116  jpeg_core_output_dimensions(cinfo);
117 
118 #ifdef IDCT_SCALING_SUPPORTED
119 
120  /* In selecting the actual DCT scaling for each component, we try to
121  * scale up the chroma components via IDCT scaling rather than upsampling.
122  * This saves time if the upsampler gets to use 1:1 scaling.
123  * Note this code adapts subsampling ratios which are powers of 2.
124  */
125  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
126  ci++, compptr++) {
127  int ssize = 1;
128  while (cinfo->min_DCT_h_scaled_size * ssize <=
129  (cinfo->do_fancy_upsampling ? DCTSIZE : DCTSIZE / 2) &&
130  (cinfo->max_h_samp_factor % (compptr->h_samp_factor * ssize * 2)) == 0) {
131  ssize = ssize * 2;
132  }
133  compptr->DCT_h_scaled_size = cinfo->min_DCT_h_scaled_size * ssize;
134  ssize = 1;
135  while (cinfo->min_DCT_v_scaled_size * ssize <=
136  (cinfo->do_fancy_upsampling ? DCTSIZE : DCTSIZE / 2) &&
137  (cinfo->max_v_samp_factor % (compptr->v_samp_factor * ssize * 2)) == 0) {
138  ssize = ssize * 2;
139  }
140  compptr->DCT_v_scaled_size = cinfo->min_DCT_v_scaled_size * ssize;
141 
142  /* We don't support IDCT ratios larger than 2. */
147  }
148 
149  /* Recompute downsampled dimensions of components;
150  * application needs to know these if using raw downsampled data.
151  */
152  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
153  ci++, compptr++) {
154  /* Size in samples, after IDCT scaling */
156  jdiv_round_up((long) cinfo->image_width *
158  (long) (cinfo->max_h_samp_factor * cinfo->block_size));
160  jdiv_round_up((long) cinfo->image_height *
162  (long) (cinfo->max_v_samp_factor * cinfo->block_size));
163  }
164 
165 #endif /* IDCT_SCALING_SUPPORTED */
166 
167  /* Report number of components in selected colorspace. */
168  /* Probably this should be in the color conversion module... */
169  switch (cinfo->out_color_space) {
170  case JCS_GRAYSCALE:
171  cinfo->out_color_components = 1;
172  break;
173  case JCS_RGB:
174  case JCS_BG_RGB:
175  cinfo->out_color_components = RGB_PIXELSIZE;
176  break;
177  case JCS_YCbCr:
178  case JCS_BG_YCC:
179  cinfo->out_color_components = 3;
180  break;
181  case JCS_CMYK:
182  case JCS_YCCK:
183  cinfo->out_color_components = 4;
184  break;
185  default: /* else must be same colorspace as in file */
186  cinfo->out_color_components = cinfo->num_components;
187  break;
188  }
189  cinfo->output_components = (cinfo->quantize_colors ? 1 :
190  cinfo->out_color_components);
191 
192  /* See if upsampler will want to emit more than one row at a time */
193  if (use_merged_upsample(cinfo))
194  cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
195  else
196  cinfo->rec_outbuf_height = 1;
197 }
198 
199 
200 /*
201  * Several decompression processes need to range-limit values to the range
202  * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
203  * due to noise introduced by quantization, roundoff error, etc. These
204  * processes are inner loops and need to be as fast as possible. On most
205  * machines, particularly CPUs with pipelines or instruction prefetch,
206  * a (subscript-check-less) C table lookup
207  * x = sample_range_limit[x];
208  * is faster than explicit tests
209  * if (x < 0) x = 0;
210  * else if (x > MAXJSAMPLE) x = MAXJSAMPLE;
211  * These processes all use a common table prepared by the routine below.
212  *
213  * For most steps we can mathematically guarantee that the initial value
214  * of x is within 2*(MAXJSAMPLE+1) of the legal range, so a table running
215  * from -2*(MAXJSAMPLE+1) to 3*MAXJSAMPLE+2 is sufficient. But for the
216  * initial limiting step (just after the IDCT), a wildly out-of-range value
217  * is possible if the input data is corrupt. To avoid any chance of indexing
218  * off the end of memory and getting a bad-pointer trap, we perform the
219  * post-IDCT limiting thus:
220  * x = (sample_range_limit - SUBSET)[(x + CENTER) & MASK];
221  * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
222  * samples. Under normal circumstances this is more than enough range and
223  * a correct output will be generated; with bogus input data the mask will
224  * cause wraparound, and we will safely generate a bogus-but-in-range output.
225  * For the post-IDCT step, we want to convert the data from signed to unsigned
226  * representation by adding CENTERJSAMPLE at the same time that we limit it.
227  * This is accomplished with SUBSET = CENTER - CENTERJSAMPLE.
228  *
229  * Note that the table is allocated in near data space on PCs; it's small
230  * enough and used often enough to justify this.
231  */
232 
233 LOCAL(void)
235 /* Allocate and fill in the sample_range_limit table */
236 {
237  JSAMPLE * table;
238  int i;
239 
240  table = (JSAMPLE *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo,
242  /* First segment of range limit table: limit[x] = 0 for x < 0 */
244  table += RANGE_CENTER; /* allow negative subscripts of table */
245  cinfo->sample_range_limit = table;
246  /* Main part of range limit table: limit[x] = x */
247  for (i = 0; i <= MAXJSAMPLE; i++)
248  table[i] = (JSAMPLE) i;
249  /* End of range limit table: limit[x] = MAXJSAMPLE for x > MAXJSAMPLE */
250  for (; i <= MAXJSAMPLE + RANGE_CENTER; i++)
251  table[i] = MAXJSAMPLE;
252 }
253 
254 
255 /*
256  * Master selection of decompression modules.
257  * This is done once at jpeg_start_decompress time. We determine
258  * which modules will be used and give them appropriate initialization calls.
259  * We also initialize the decompressor input side to begin consuming data.
260  *
261  * Since jpeg_read_header has finished, we know what is in the SOF
262  * and (first) SOS markers. We also have all the application parameter
263  * settings.
264  */
265 
266 LOCAL(void)
268 {
269  my_master_ptr master = (my_master_ptr) cinfo->master;
270  boolean use_c_buffer;
271  long samplesperrow;
272  JDIMENSION jd_samplesperrow;
273 
274  /* For now, precision must match compiled-in value... */
275  if (cinfo->data_precision != BITS_IN_JSAMPLE)
276  ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
277 
278  /* Initialize dimensions and other stuff */
281 
282  /* Sanity check on image dimensions */
283  if (cinfo->output_height <= 0 || cinfo->output_width <= 0 ||
284  cinfo->out_color_components <= 0)
285  ERREXIT(cinfo, JERR_EMPTY_IMAGE);
286 
287  /* Width of an output scanline must be representable as JDIMENSION. */
288  samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components;
289  jd_samplesperrow = (JDIMENSION) samplesperrow;
290  if ((long) jd_samplesperrow != samplesperrow)
291  ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
292 
293  /* Initialize my private state */
294  master->pass_number = 0;
295  master->using_merged_upsample = use_merged_upsample(cinfo);
296 
297  /* Color quantizer selection */
298  master->quantizer_1pass = NULL;
299  master->quantizer_2pass = NULL;
300  /* No mode changes if not using buffered-image mode. */
301  if (! cinfo->quantize_colors || ! cinfo->buffered_image) {
302  cinfo->enable_1pass_quant = FALSE;
303  cinfo->enable_external_quant = FALSE;
304  cinfo->enable_2pass_quant = FALSE;
305  }
306  if (cinfo->quantize_colors) {
307  if (cinfo->raw_data_out)
308  ERREXIT(cinfo, JERR_NOTIMPL);
309  /* 2-pass quantizer only works in 3-component color space. */
310  if (cinfo->out_color_components != 3) {
311  cinfo->enable_1pass_quant = TRUE;
312  cinfo->enable_external_quant = FALSE;
313  cinfo->enable_2pass_quant = FALSE;
314  cinfo->colormap = NULL;
315  } else if (cinfo->colormap != NULL) {
316  cinfo->enable_external_quant = TRUE;
317  } else if (cinfo->two_pass_quantize) {
318  cinfo->enable_2pass_quant = TRUE;
319  } else {
320  cinfo->enable_1pass_quant = TRUE;
321  }
322 
323  if (cinfo->enable_1pass_quant) {
324 #ifdef QUANT_1PASS_SUPPORTED
325  jinit_1pass_quantizer(cinfo);
326  master->quantizer_1pass = cinfo->cquantize;
327 #else
328  ERREXIT(cinfo, JERR_NOT_COMPILED);
329 #endif
330  }
331 
332  /* We use the 2-pass code to map to external colormaps. */
333  if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
334 #ifdef QUANT_2PASS_SUPPORTED
335  jinit_2pass_quantizer(cinfo);
336  master->quantizer_2pass = cinfo->cquantize;
337 #else
338  ERREXIT(cinfo, JERR_NOT_COMPILED);
339 #endif
340  }
341  /* If both quantizers are initialized, the 2-pass one is left active;
342  * this is necessary for starting with quantization to an external map.
343  */
344  }
345 
346  /* Post-processing: in particular, color conversion first */
347  if (! cinfo->raw_data_out) {
348  if (master->using_merged_upsample) {
349 #ifdef UPSAMPLE_MERGING_SUPPORTED
350  jinit_merged_upsampler(cinfo); /* does color conversion too */
351 #else
352  ERREXIT(cinfo, JERR_NOT_COMPILED);
353 #endif
354  } else {
356  jinit_upsampler(cinfo);
357  }
358  jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
359  }
360  /* Inverse DCT */
361  jinit_inverse_dct(cinfo);
362  /* Entropy decoding: either Huffman or arithmetic coding. */
363  if (cinfo->arith_code)
364  jinit_arith_decoder(cinfo);
365  else {
366  jinit_huff_decoder(cinfo);
367  }
368 
369  /* Initialize principal buffer controllers. */
370  use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
371  jinit_d_coef_controller(cinfo, use_c_buffer);
372 
373  if (! cinfo->raw_data_out)
374  jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
375 
376  /* We can now tell the memory manager to allocate virtual arrays. */
377  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
378 
379  /* Initialize input side of decompressor to consume first scan. */
380  (*cinfo->inputctl->start_input_pass) (cinfo);
381 
382 #ifdef D_MULTISCAN_FILES_SUPPORTED
383  /* If jpeg_start_decompress will read the whole file, initialize
384  * progress monitoring appropriately. The input step is counted
385  * as one pass.
386  */
387  if (cinfo->progress != NULL && ! cinfo->buffered_image &&
388  cinfo->inputctl->has_multiple_scans) {
389  int nscans;
390  /* Estimate number of scans to set pass_limit. */
391  if (cinfo->progressive_mode) {
392  /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
393  nscans = 2 + 3 * cinfo->num_components;
394  } else {
395  /* For a nonprogressive multiscan file, estimate 1 scan per component. */
396  nscans = cinfo->num_components;
397  }
398  cinfo->progress->pass_counter = 0L;
399  cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
400  cinfo->progress->completed_passes = 0;
401  cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
402  /* Count the input pass as done */
403  master->pass_number++;
404  }
405 #endif /* D_MULTISCAN_FILES_SUPPORTED */
406 }
407 
408 
409 /*
410  * Per-pass setup.
411  * This is called at the beginning of each output pass. We determine which
412  * modules will be active during this pass and give them appropriate
413  * start_pass calls. We also set is_dummy_pass to indicate whether this
414  * is a "real" output pass or a dummy pass for color quantization.
415  * (In the latter case, jdapistd.c will crank the pass to completion.)
416  */
417 
418 METHODDEF(void)
420 {
421  my_master_ptr master = (my_master_ptr) cinfo->master;
422 
423  if (master->pub.is_dummy_pass) {
424 #ifdef QUANT_2PASS_SUPPORTED
425  /* Final pass of 2-pass quantization */
426  master->pub.is_dummy_pass = FALSE;
427  (*cinfo->cquantize->start_pass) (cinfo, FALSE);
428  (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
429  (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
430 #else
431  ERREXIT(cinfo, JERR_NOT_COMPILED);
432 #endif /* QUANT_2PASS_SUPPORTED */
433  } else {
434  if (cinfo->quantize_colors && cinfo->colormap == NULL) {
435  /* Select new quantization method */
436  if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
437  cinfo->cquantize = master->quantizer_2pass;
438  master->pub.is_dummy_pass = TRUE;
439  } else if (cinfo->enable_1pass_quant) {
440  cinfo->cquantize = master->quantizer_1pass;
441  } else {
442  ERREXIT(cinfo, JERR_MODE_CHANGE);
443  }
444  }
445  (*cinfo->idct->start_pass) (cinfo);
446  (*cinfo->coef->start_output_pass) (cinfo);
447  if (! cinfo->raw_data_out) {
448  if (! master->using_merged_upsample)
449  (*cinfo->cconvert->start_pass) (cinfo);
450  (*cinfo->upsample->start_pass) (cinfo);
451  if (cinfo->quantize_colors)
452  (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
453  (*cinfo->post->start_pass) (cinfo,
454  (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
455  (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
456  }
457  }
458 
459  /* Set up progress monitor's pass info if present */
460  if (cinfo->progress != NULL) {
461  cinfo->progress->completed_passes = master->pass_number;
462  cinfo->progress->total_passes = master->pass_number +
463  (master->pub.is_dummy_pass ? 2 : 1);
464  /* In buffered-image mode, we assume one more output pass if EOI not
465  * yet reached, but no more passes if EOI has been reached.
466  */
467  if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) {
468  cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
469  }
470  }
471 }
472 
473 
474 /*
475  * Finish up at end of an output pass.
476  */
477 
478 METHODDEF(void)
480 {
481  my_master_ptr master = (my_master_ptr) cinfo->master;
482 
483  if (cinfo->quantize_colors)
484  (*cinfo->cquantize->finish_pass) (cinfo);
485  master->pass_number++;
486 }
487 
488 
489 #ifdef D_MULTISCAN_FILES_SUPPORTED
490 
491 /*
492  * Switch to a new external colormap between output passes.
493  */
494 
495 GLOBAL(void)
496 jpeg_new_colormap (j_decompress_ptr cinfo)
497 {
498  my_master_ptr master = (my_master_ptr) cinfo->master;
499 
500  /* Prevent application from calling me at wrong times */
501  if (cinfo->global_state != DSTATE_BUFIMAGE)
502  ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
503 
504  if (cinfo->quantize_colors && cinfo->enable_external_quant &&
505  cinfo->colormap != NULL) {
506  /* Select 2-pass quantizer for external colormap use */
507  cinfo->cquantize = master->quantizer_2pass;
508  /* Notify quantizer of colormap change */
509  (*cinfo->cquantize->new_color_map) (cinfo);
510  master->pub.is_dummy_pass = FALSE; /* just in case */
511  } else
512  ERREXIT(cinfo, JERR_MODE_CHANGE);
513 }
514 
515 #endif /* D_MULTISCAN_FILES_SUPPORTED */
516 
517 
518 /*
519  * Initialize master decompression control and select active modules.
520  * This is performed at the start of jpeg_start_decompress.
521  */
522 
523 GLOBAL(void)
525 {
526  my_master_ptr master;
527 
528  master = (my_master_ptr)
529  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
531  cinfo->master = &master->pub;
532  master->pub.prepare_for_output_pass = prepare_for_output_pass;
533  master->pub.finish_output_pass = finish_output_pass;
534 
535  master->pub.is_dummy_pass = FALSE;
536 
537  master_selection(cinfo);
538 }
#define BITS_IN_JSAMPLE
Definition: jmorecfg.h:33
jinit_d_main_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
Definition: jdmainct.c:469
#define TRUE
Definition: types.h:120
char JSAMPLE
Definition: jmorecfg.h:74
JDIMENSION downsampled_width
Definition: jpeglib.h:164
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define DSTATE_BUFIMAGE
Definition: jpegint.h:37
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
boolean quantize_colors
Definition: jpeglib.h:491
jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
Definition: jdcoefct.c:678
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
boolean enable_external_quant
Definition: jpeglib.h:498
#define MEMZERO(addr, type, size)
Definition: svc_dg.c:324
struct jpeg_color_quantizer * quantizer_1pass
Definition: jdmaster.c:32
#define MAXJSAMPLE
Definition: jmorecfg.h:83
jinit_d_post_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
Definition: jdpostct.c:250
jinit_upsampler(j_decompress_ptr cinfo)
Definition: jdsample.c:294
jinit_color_deconverter(j_decompress_ptr cinfo)
Definition: jdcolor.c:575
jpeg_component_info * compptr
Definition: jdct.h:238
int pass_number
Definition: jcmaster.c:33
boolean using_merged_upsample
Definition: jdmaster.c:27
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SIZEOF(_ar)
Definition: calc.h:97
jpeg_calc_output_dimensions(j_decompress_ptr cinfo)
Definition: jdmaster.c:101
#define JPOOL_IMAGE
Definition: jpeglib.h:808
struct jpeg_comp_master pub
Definition: jcmaster.c:29
smooth NULL
Definition: ftsmooth.c:416
prepare_range_limit_table(j_decompress_ptr cinfo)
Definition: jdmaster.c:234
finish_output_pass(j_decompress_ptr cinfo)
Definition: jdmaster.c:479
use_merged_upsample(j_decompress_ptr cinfo)
Definition: jdmaster.c:45
#define LOCAL(type)
Definition: jmorecfg.h:289
#define DSTATE_READY
Definition: jpegint.h:32
struct jpeg_color_quantizer * cquantize
Definition: jpeglib.h:688
if(!(yy_init))
Definition: macro.lex.yy.c:714
jinit_arith_decoder(j_decompress_ptr cinfo)
Definition: jdarith.c:764
jdiv_round_up(long a, long b)
Definition: jutils.c:124
struct jpeg_decomp_master * master
Definition: jpeglib.h:678
#define RANGE_CENTER
Definition: jpegint.h:273
jinit_master_decompress(j_decompress_ptr cinfo)
Definition: jdmaster.c:524
static const WCHAR L[]
Definition: oid.c:1250
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
struct jpeg_color_quantizer * quantizer_2pass
Definition: jdmaster.c:33
JSAMPARRAY colormap
Definition: jpeglib.h:527
master_selection(j_decompress_ptr cinfo)
Definition: jdmaster.c:267
#define GLOBAL(type)
Definition: jmorecfg.h:291
#define METHODDEF(type)
Definition: jmorecfg.h:287
my_decomp_master * my_master_ptr
Definition: jdmaster.c:36
#define long
Definition: qsort.c:33
#define DCTSIZE
Definition: jpeglib.h:50
unsigned int JDIMENSION
Definition: jmorecfg.h:229
jinit_inverse_dct(j_decompress_ptr cinfo)
Definition: jddctmgr.c:362
prepare_for_output_pass(j_decompress_ptr cinfo)
Definition: jdmaster.c:419
JDIMENSION downsampled_height
Definition: jpeglib.h:165
jinit_huff_decoder(j_decompress_ptr cinfo)
Definition: jdhuff.c:1520