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)  

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