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)  

jdcoefct.c
Go to the documentation of this file.
1 /*
2  * jdcoefct.c
3  *
4  * Copyright (C) 1994-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 the coefficient buffer controller for decompression.
9  * This controller is the top level of the JPEG decompressor proper.
10  * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
11  *
12  * In buffered-image mode, this controller is the interface between
13  * input-oriented processing and output-oriented processing.
14  * Also, the input side (only) is used when reading a file for transcoding.
15  */
16 
17 #define JPEG_INTERNALS
18 #include "jinclude.h"
19 #include "jpeglib.h"
20 
21 /* Block smoothing is only applicable for progressive JPEG, so: */
22 #ifndef D_PROGRESSIVE_SUPPORTED
23 #undef BLOCK_SMOOTHING_SUPPORTED
24 #endif
25 
26 /* Private buffer controller object */
27 
28 typedef struct {
29  struct jpeg_d_coef_controller pub; /* public fields */
30 
31  /* These variables keep track of the current location of the input side. */
32  /* cinfo->input_iMCU_row is also used for this. */
33  JDIMENSION MCU_ctr; /* counts MCUs processed in current row */
34  int MCU_vert_offset; /* counts MCU rows within iMCU row */
35  int MCU_rows_per_iMCU_row; /* number of such rows needed */
36 
37  /* The output side's location is represented by cinfo->output_iMCU_row. */
38 
39  /* In single-pass modes, it's sufficient to buffer just one MCU.
40  * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
41  * and let the entropy decoder write into that workspace each time.
42  * (On 80x86, the workspace is FAR even though it's not really very big;
43  * this is to keep the module interfaces unchanged when a large coefficient
44  * buffer is necessary.)
45  * In multi-pass modes, this array points to the current MCU's blocks
46  * within the virtual arrays; it is used only by the input side.
47  */
48  JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
49 
50 #ifdef D_MULTISCAN_FILES_SUPPORTED
51  /* In multi-pass modes, we need a virtual block array for each component. */
52  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
53 #endif
54 
55 #ifdef BLOCK_SMOOTHING_SUPPORTED
56  /* When doing block smoothing, we latch coefficient Al values here */
58 #define SAVED_COEFS 6 /* we save coef_bits[0..5] */
59 #endif
61 
63 
64 /* Forward declarations */
67 #ifdef D_MULTISCAN_FILES_SUPPORTED
70 #endif
71 #ifdef BLOCK_SMOOTHING_SUPPORTED
72 LOCAL(boolean) smoothing_ok JPP((j_decompress_ptr cinfo));
75 #endif
76 
77 
78 LOCAL(void)
80 /* Reset within-iMCU-row counters for a new row (input side) */
81 {
82  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
83 
84  /* In an interleaved scan, an MCU row is the same as an iMCU row.
85  * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
86  * But at the bottom of the image, process only what's left.
87  */
88  if (cinfo->comps_in_scan > 1) {
89  coef->MCU_rows_per_iMCU_row = 1;
90  } else {
91  if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
92  coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
93  else
94  coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
95  }
96 
97  coef->MCU_ctr = 0;
98  coef->MCU_vert_offset = 0;
99 }
100 
101 
102 /*
103  * Initialize for an input processing pass.
104  */
105 
106 METHODDEF(void)
108 {
109  cinfo->input_iMCU_row = 0;
110  start_iMCU_row(cinfo);
111 }
112 
113 
114 /*
115  * Initialize for an output processing pass.
116  */
117 
118 METHODDEF(void)
120 {
121 #ifdef BLOCK_SMOOTHING_SUPPORTED
122  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
123 
124  /* If multipass, check to see whether to use block smoothing on this pass */
125  if (coef->pub.coef_arrays != NULL) {
126  if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
127  coef->pub.decompress_data = decompress_smooth_data;
128  else
129  coef->pub.decompress_data = decompress_data;
130  }
131 #endif
132  cinfo->output_iMCU_row = 0;
133 }
134 
135 
136 /*
137  * Decompress and return some data in the single-pass case.
138  * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
139  * Input and output must run in lockstep since we have only a one-MCU buffer.
140  * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
141  *
142  * NB: output_buf contains a plane for each component in image,
143  * which we index according to the component's SOF position.
144  */
145 
146 METHODDEF(int)
148 {
149  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
150  JDIMENSION MCU_col_num; /* index of current MCU within row */
151  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
152  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
153  int blkn, ci, xindex, yindex, yoffset, useful_width;
154  JSAMPARRAY output_ptr;
155  JDIMENSION start_col, output_col;
157  inverse_DCT_method_ptr inverse_DCT;
158 
159  /* Loop to process as much as one whole iMCU row */
160  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
161  yoffset++) {
162  for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
163  MCU_col_num++) {
164  /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */
165  jzero_far((void FAR *) coef->MCU_buffer[0],
166  (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
167  if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
168  /* Suspension forced; update state counters and exit */
169  coef->MCU_vert_offset = yoffset;
170  coef->MCU_ctr = MCU_col_num;
171  return JPEG_SUSPENDED;
172  }
173  /* Determine where data should go in output_buf and do the IDCT thing.
174  * We skip dummy blocks at the right and bottom edges (but blkn gets
175  * incremented past them!). Note the inner loop relies on having
176  * allocated the MCU_buffer[] blocks sequentially.
177  */
178  blkn = 0; /* index of current DCT block within MCU */
179  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
180  compptr = cinfo->cur_comp_info[ci];
181  /* Don't bother to IDCT an uninteresting component. */
182  if (! compptr->component_needed) {
183  blkn += compptr->MCU_blocks;
184  continue;
185  }
186  inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
187  useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
189  output_ptr = output_buf[compptr->component_index] +
191  start_col = MCU_col_num * compptr->MCU_sample_width;
192  for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
193  if (cinfo->input_iMCU_row < last_iMCU_row ||
194  yoffset+yindex < compptr->last_row_height) {
195  output_col = start_col;
196  for (xindex = 0; xindex < useful_width; xindex++) {
197  (*inverse_DCT) (cinfo, compptr,
198  (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
199  output_ptr, output_col);
201  }
202  }
203  blkn += compptr->MCU_width;
204  output_ptr += compptr->DCT_scaled_size;
205  }
206  }
207  }
208  /* Completed an MCU row, but perhaps not an iMCU row */
209  coef->MCU_ctr = 0;
210  }
211  /* Completed the iMCU row, advance counters for next one */
212  cinfo->output_iMCU_row++;
213  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
214  start_iMCU_row(cinfo);
215  return JPEG_ROW_COMPLETED;
216  }
217  /* Completed the scan */
218  (*cinfo->inputctl->finish_input_pass) (cinfo);
219  return JPEG_SCAN_COMPLETED;
220 }
221 
222 
223 /*
224  * Dummy consume-input routine for single-pass operation.
225  */
226 
227 METHODDEF(int)
229 {
230  return JPEG_SUSPENDED; /* Always indicate nothing was done */
231 }
232 
233 
234 #ifdef D_MULTISCAN_FILES_SUPPORTED
235 
236 /*
237  * Consume input data and store it in the full-image coefficient buffer.
238  * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
239  * ie, v_samp_factor block rows for each component in the scan.
240  * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
241  */
242 
243 METHODDEF(int)
245 {
246  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
247  JDIMENSION MCU_col_num; /* index of current MCU within row */
248  int blkn, ci, xindex, yindex, yoffset;
249  JDIMENSION start_col;
251  JBLOCKROW buffer_ptr;
253 
254  /* Align the virtual buffers for the components used in this scan. */
255  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
256  compptr = cinfo->cur_comp_info[ci];
257  buffer[ci] = (*cinfo->mem->access_virt_barray)
259  cinfo->input_iMCU_row * compptr->v_samp_factor,
261  /* Note: entropy decoder expects buffer to be zeroed,
262  * but this is handled automatically by the memory manager
263  * because we requested a pre-zeroed array.
264  */
265  }
266 
267  /* Loop to process one whole iMCU row */
268  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
269  yoffset++) {
270  for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
271  MCU_col_num++) {
272  /* Construct list of pointers to DCT blocks belonging to this MCU */
273  blkn = 0; /* index of current DCT block within MCU */
274  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
275  compptr = cinfo->cur_comp_info[ci];
276  start_col = MCU_col_num * compptr->MCU_width;
277  for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
278  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
279  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
280  coef->MCU_buffer[blkn++] = buffer_ptr++;
281  }
282  }
283  }
284  /* Try to fetch the MCU. */
285  if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
286  /* Suspension forced; update state counters and exit */
287  coef->MCU_vert_offset = yoffset;
288  coef->MCU_ctr = MCU_col_num;
289  return JPEG_SUSPENDED;
290  }
291  }
292  /* Completed an MCU row, but perhaps not an iMCU row */
293  coef->MCU_ctr = 0;
294  }
295  /* Completed the iMCU row, advance counters for next one */
296  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
297  start_iMCU_row(cinfo);
298  return JPEG_ROW_COMPLETED;
299  }
300  /* Completed the scan */
301  (*cinfo->inputctl->finish_input_pass) (cinfo);
302  return JPEG_SCAN_COMPLETED;
303 }
304 
305 
306 /*
307  * Decompress and return some data in the multi-pass case.
308  * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
309  * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
310  *
311  * NB: output_buf contains a plane for each component in image.
312  */
313 
314 METHODDEF(int)
316 {
317  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
318  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
319  JDIMENSION block_num;
320  int ci, block_row, block_rows;
322  JBLOCKROW buffer_ptr;
323  JSAMPARRAY output_ptr;
326  inverse_DCT_method_ptr inverse_DCT;
327 
328  /* Force some input to be done if we are getting ahead of the input. */
329  while (cinfo->input_scan_number < cinfo->output_scan_number ||
330  (cinfo->input_scan_number == cinfo->output_scan_number &&
331  cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
332  if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
333  return JPEG_SUSPENDED;
334  }
335 
336  /* OK, output from the virtual arrays. */
337  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
338  ci++, compptr++) {
339  /* Don't bother to IDCT an uninteresting component. */
340  if (! compptr->component_needed)
341  continue;
342  /* Align the virtual buffer for this component. */
343  buffer = (*cinfo->mem->access_virt_barray)
344  ((j_common_ptr) cinfo, coef->whole_image[ci],
345  cinfo->output_iMCU_row * compptr->v_samp_factor,
347  /* Count non-dummy DCT block rows in this iMCU row. */
348  if (cinfo->output_iMCU_row < last_iMCU_row)
349  block_rows = compptr->v_samp_factor;
350  else {
351  /* NB: can't use last_row_height here; it is input-side-dependent! */
352  block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
353  if (block_rows == 0) block_rows = compptr->v_samp_factor;
354  }
355  inverse_DCT = cinfo->idct->inverse_DCT[ci];
356  output_ptr = output_buf[ci];
357  /* Loop over all DCT blocks to be processed. */
358  for (block_row = 0; block_row < block_rows; block_row++) {
359  buffer_ptr = buffer[block_row];
360  output_col = 0;
361  for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) {
362  (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
363  output_ptr, output_col);
364  buffer_ptr++;
366  }
367  output_ptr += compptr->DCT_scaled_size;
368  }
369  }
370 
371  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
372  return JPEG_ROW_COMPLETED;
373  return JPEG_SCAN_COMPLETED;
374 }
375 
376 #endif /* D_MULTISCAN_FILES_SUPPORTED */
377 
378 
379 #ifdef BLOCK_SMOOTHING_SUPPORTED
380 
381 /*
382  * This code applies interblock smoothing as described by section K.8
383  * of the JPEG standard: the first 5 AC coefficients are estimated from
384  * the DC values of a DCT block and its 8 neighboring blocks.
385  * We apply smoothing only for progressive JPEG decoding, and only if
386  * the coefficients it can estimate are not yet known to full precision.
387  */
388 
389 /* Natural-order array positions of the first 5 zigzag-order coefficients */
390 #define Q01_POS 1
391 #define Q10_POS 8
392 #define Q20_POS 16
393 #define Q11_POS 9
394 #define Q02_POS 2
395 
396 /*
397  * Determine whether block smoothing is applicable and safe.
398  * We also latch the current states of the coef_bits[] entries for the
399  * AC coefficients; otherwise, if the input side of the decompressor
400  * advances into a new scan, we might think the coefficients are known
401  * more accurately than they really are.
402  */
403 
404 LOCAL(boolean)
406 {
407  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
408  boolean smoothing_useful = FALSE;
409  int ci, coefi;
411  JQUANT_TBL * qtable;
412  int * coef_bits;
413  int * coef_bits_latch;
414 
415  if (! cinfo->progressive_mode || cinfo->coef_bits == NULL)
416  return FALSE;
417 
418  /* Allocate latch area if not already done */
419  if (coef->coef_bits_latch == NULL)
420  coef->coef_bits_latch = (int *)
421  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
422  cinfo->num_components *
423  (SAVED_COEFS * SIZEOF(int)));
424  coef_bits_latch = coef->coef_bits_latch;
425 
426  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
427  ci++, compptr++) {
428  /* All components' quantization values must already be latched. */
429  if ((qtable = compptr->quant_table) == NULL)
430  return FALSE;
431  /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
432  if (qtable->quantval[0] == 0 ||
433  qtable->quantval[Q01_POS] == 0 ||
434  qtable->quantval[Q10_POS] == 0 ||
435  qtable->quantval[Q20_POS] == 0 ||
436  qtable->quantval[Q11_POS] == 0 ||
437  qtable->quantval[Q02_POS] == 0)
438  return FALSE;
439  /* DC values must be at least partly known for all components. */
440  coef_bits = cinfo->coef_bits[ci];
441  if (coef_bits[0] < 0)
442  return FALSE;
443  /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
444  for (coefi = 1; coefi <= 5; coefi++) {
445  coef_bits_latch[coefi] = coef_bits[coefi];
446  if (coef_bits[coefi] != 0)
447  smoothing_useful = TRUE;
448  }
449  coef_bits_latch += SAVED_COEFS;
450  }
451 
452  return smoothing_useful;
453 }
454 
455 
456 /*
457  * Variant of decompress_data for use when doing block smoothing.
458  */
459 
460 METHODDEF(int)
462 {
463  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
464  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
465  JDIMENSION block_num, last_block_column;
466  int ci, block_row, block_rows, access_rows;
468  JBLOCKROW buffer_ptr, prev_block_row, next_block_row;
469  JSAMPARRAY output_ptr;
472  inverse_DCT_method_ptr inverse_DCT;
473  boolean first_row, last_row;
474  JBLOCK workspace;
475  int *coef_bits;
476  JQUANT_TBL *quanttbl;
477  INT32 Q00,Q01,Q02,Q10,Q11,Q20, num;
478  int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9;
479  int Al, pred;
480 
481  /* Force some input to be done if we are getting ahead of the input. */
482  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
483  ! cinfo->inputctl->eoi_reached) {
484  if (cinfo->input_scan_number == cinfo->output_scan_number) {
485  /* If input is working on current scan, we ordinarily want it to
486  * have completed the current row. But if input scan is DC,
487  * we want it to keep one row ahead so that next block row's DC
488  * values are up to date.
489  */
490  JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
491  if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
492  break;
493  }
494  if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
495  return JPEG_SUSPENDED;
496  }
497 
498  /* OK, output from the virtual arrays. */
499  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
500  ci++, compptr++) {
501  /* Don't bother to IDCT an uninteresting component. */
502  if (! compptr->component_needed)
503  continue;
504  /* Count non-dummy DCT block rows in this iMCU row. */
505  if (cinfo->output_iMCU_row < last_iMCU_row) {
506  block_rows = compptr->v_samp_factor;
507  access_rows = block_rows * 2; /* this and next iMCU row */
508  last_row = FALSE;
509  } else {
510  /* NB: can't use last_row_height here; it is input-side-dependent! */
511  block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
512  if (block_rows == 0) block_rows = compptr->v_samp_factor;
513  access_rows = block_rows; /* this iMCU row only */
514  last_row = TRUE;
515  }
516  /* Align the virtual buffer for this component. */
517  if (cinfo->output_iMCU_row > 0) {
518  access_rows += compptr->v_samp_factor; /* prior iMCU row too */
519  buffer = (*cinfo->mem->access_virt_barray)
520  ((j_common_ptr) cinfo, coef->whole_image[ci],
521  (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
522  (JDIMENSION) access_rows, FALSE);
523  buffer += compptr->v_samp_factor; /* point to current iMCU row */
524  first_row = FALSE;
525  } else {
526  buffer = (*cinfo->mem->access_virt_barray)
527  ((j_common_ptr) cinfo, coef->whole_image[ci],
528  (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
529  first_row = TRUE;
530  }
531  /* Fetch component-dependent info */
532  coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
533  quanttbl = compptr->quant_table;
534  Q00 = quanttbl->quantval[0];
535  Q01 = quanttbl->quantval[Q01_POS];
536  Q10 = quanttbl->quantval[Q10_POS];
537  Q20 = quanttbl->quantval[Q20_POS];
538  Q11 = quanttbl->quantval[Q11_POS];
539  Q02 = quanttbl->quantval[Q02_POS];
540  inverse_DCT = cinfo->idct->inverse_DCT[ci];
541  output_ptr = output_buf[ci];
542  /* Loop over all DCT blocks to be processed. */
543  for (block_row = 0; block_row < block_rows; block_row++) {
544  buffer_ptr = buffer[block_row];
545  if (first_row && block_row == 0)
546  prev_block_row = buffer_ptr;
547  else
548  prev_block_row = buffer[block_row-1];
549  if (last_row && block_row == block_rows-1)
550  next_block_row = buffer_ptr;
551  else
552  next_block_row = buffer[block_row+1];
553  /* We fetch the surrounding DC values using a sliding-register approach.
554  * Initialize all nine here so as to do the right thing on narrow pics.
555  */
556  DC1 = DC2 = DC3 = (int) prev_block_row[0][0];
557  DC4 = DC5 = DC6 = (int) buffer_ptr[0][0];
558  DC7 = DC8 = DC9 = (int) next_block_row[0][0];
559  output_col = 0;
560  last_block_column = compptr->width_in_blocks - 1;
561  for (block_num = 0; block_num <= last_block_column; block_num++) {
562  /* Fetch current DCT block into workspace so we can modify it. */
563  jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
564  /* Update DC values */
565  if (block_num < last_block_column) {
566  DC3 = (int) prev_block_row[1][0];
567  DC6 = (int) buffer_ptr[1][0];
568  DC9 = (int) next_block_row[1][0];
569  }
570  /* Compute coefficient estimates per K.8.
571  * An estimate is applied only if coefficient is still zero,
572  * and is not known to be fully accurate.
573  */
574  /* AC01 */
575  if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
576  num = 36 * Q00 * (DC4 - DC6);
577  if (num >= 0) {
578  pred = (int) (((Q01<<7) + num) / (Q01<<8));
579  if (Al > 0 && pred >= (1<<Al))
580  pred = (1<<Al)-1;
581  } else {
582  pred = (int) (((Q01<<7) - num) / (Q01<<8));
583  if (Al > 0 && pred >= (1<<Al))
584  pred = (1<<Al)-1;
585  pred = -pred;
586  }
587  workspace[1] = (JCOEF) pred;
588  }
589  /* AC10 */
590  if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
591  num = 36 * Q00 * (DC2 - DC8);
592  if (num >= 0) {
593  pred = (int) (((Q10<<7) + num) / (Q10<<8));
594  if (Al > 0 && pred >= (1<<Al))
595  pred = (1<<Al)-1;
596  } else {
597  pred = (int) (((Q10<<7) - num) / (Q10<<8));
598  if (Al > 0 && pred >= (1<<Al))
599  pred = (1<<Al)-1;
600  pred = -pred;
601  }
602  workspace[8] = (JCOEF) pred;
603  }
604  /* AC20 */
605  if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
606  num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
607  if (num >= 0) {
608  pred = (int) (((Q20<<7) + num) / (Q20<<8));
609  if (Al > 0 && pred >= (1<<Al))
610  pred = (1<<Al)-1;
611  } else {
612  pred = (int) (((Q20<<7) - num) / (Q20<<8));
613  if (Al > 0 && pred >= (1<<Al))
614  pred = (1<<Al)-1;
615  pred = -pred;
616  }
617  workspace[16] = (JCOEF) pred;
618  }
619  /* AC11 */
620  if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
621  num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
622  if (num >= 0) {
623  pred = (int) (((Q11<<7) + num) / (Q11<<8));
624  if (Al > 0 && pred >= (1<<Al))
625  pred = (1<<Al)-1;
626  } else {
627  pred = (int) (((Q11<<7) - num) / (Q11<<8));
628  if (Al > 0 && pred >= (1<<Al))
629  pred = (1<<Al)-1;
630  pred = -pred;
631  }
632  workspace[9] = (JCOEF) pred;
633  }
634  /* AC02 */
635  if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
636  num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
637  if (num >= 0) {
638  pred = (int) (((Q02<<7) + num) / (Q02<<8));
639  if (Al > 0 && pred >= (1<<Al))
640  pred = (1<<Al)-1;
641  } else {
642  pred = (int) (((Q02<<7) - num) / (Q02<<8));
643  if (Al > 0 && pred >= (1<<Al))
644  pred = (1<<Al)-1;
645  pred = -pred;
646  }
647  workspace[2] = (JCOEF) pred;
648  }
649  /* OK, do the IDCT */
650  (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
651  output_ptr, output_col);
652  /* Advance for next column */
653  DC1 = DC2; DC2 = DC3;
654  DC4 = DC5; DC5 = DC6;
655  DC7 = DC8; DC8 = DC9;
656  buffer_ptr++, prev_block_row++, next_block_row++;
658  }
659  output_ptr += compptr->DCT_scaled_size;
660  }
661  }
662 
663  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
664  return JPEG_ROW_COMPLETED;
665  return JPEG_SCAN_COMPLETED;
666 }
667 
668 #endif /* BLOCK_SMOOTHING_SUPPORTED */
669 
670 
671 /*
672  * Initialize coefficient buffer controller.
673  */
674 
675 GLOBAL(void)
677 {
678  my_coef_ptr coef;
679 
680  coef = (my_coef_ptr)
681  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
683  cinfo->coef = (struct jpeg_d_coef_controller *) coef;
684  coef->pub.start_input_pass = start_input_pass;
685  coef->pub.start_output_pass = start_output_pass;
686 #ifdef BLOCK_SMOOTHING_SUPPORTED
687  coef->coef_bits_latch = NULL;
688 #endif
689 
690  /* Create the coefficient buffer. */
691  if (need_full_buffer) {
692 #ifdef D_MULTISCAN_FILES_SUPPORTED
693  /* Allocate a full-image virtual array for each component, */
694  /* padded to a multiple of samp_factor DCT blocks in each direction. */
695  /* Note we ask for a pre-zeroed array. */
696  int ci, access_rows;
698 
699  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
700  ci++, compptr++) {
701  access_rows = compptr->v_samp_factor;
702 #ifdef BLOCK_SMOOTHING_SUPPORTED
703  /* If block smoothing could be used, need a bigger window */
704  if (cinfo->progressive_mode)
705  access_rows *= 3;
706 #endif
707  coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
708  ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
710  (long) compptr->h_samp_factor),
712  (long) compptr->v_samp_factor),
713  (JDIMENSION) access_rows);
714  }
715  coef->pub.consume_data = consume_data;
716  coef->pub.decompress_data = decompress_data;
717  coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
718 #else
719  ERREXIT(cinfo, JERR_NOT_COMPILED);
720 #endif
721  } else {
722  /* We only need a single-MCU buffer. */
724  int i;
725 
726  buffer = (JBLOCKROW)
727  (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
729  for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
730  coef->MCU_buffer[i] = buffer + i;
731  }
732  coef->pub.consume_data = dummy_consume_data;
733  coef->pub.decompress_data = decompress_onepass;
734  coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
735  }
736 }
@ FALSE
Definition: dd.h:101
@ TRUE
Definition: dd.h:102
#define Q01_POS
Definition: jdcoefct.c:390
static int consume_data(j_decompress_ptr cinfo)
Definition: jdcoefct.c:244
#define Q10_POS
Definition: jdcoefct.c:391
my_coef_controller * my_coef_ptr
Definition: jdcoefct.c:62
static int dummy_consume_data(j_decompress_ptr cinfo)
Definition: jdcoefct.c:228
#define Q20_POS
Definition: jdcoefct.c:392
static void start_output_pass(j_decompress_ptr cinfo)
Definition: jdcoefct.c:119
#define SAVED_COEFS
Definition: jdcoefct.c:58
static void start_iMCU_row(j_decompress_ptr cinfo)
Definition: jdcoefct.c:79
void jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
Definition: jdcoefct.c:676
static void start_input_pass(j_decompress_ptr cinfo)
Definition: jdcoefct.c:107
#define Q02_POS
Definition: jdcoefct.c:394
static boolean smoothing_ok(j_decompress_ptr cinfo)
Definition: jdcoefct.c:405
#define Q11_POS
Definition: jdcoefct.c:393
static int decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
Definition: jdcoefct.c:461
static int decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
Definition: jdcoefct.c:315
static int decompress_onepass(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
Definition: jdcoefct.c:147
jpeg_component_info JCOEFPTR JSAMPARRAY JDIMENSION output_col
Definition: jdct.h:103
jpeg_component_info * compptr
Definition: jdct.h:102
#define ERREXIT(cinfo, code)
Definition: jerror.h:205
@ JERR_NOT_COMPILED
Definition: jerror.h:95
#define SIZEOF(object)
Definition: jinclude.h:80
unsigned int JDIMENSION
Definition: jmorecfg.h:171
long INT32
Definition: jmorecfg.h:161
#define MAX_COMPONENTS
Definition: jmorecfg.h:35
#define LOCAL(type)
Definition: jmorecfg.h:186
#define METHODDEF(type)
Definition: jmorecfg.h:184
short JCOEF
Definition: jmorecfg.h:99
#define FAR
Definition: jmorecfg.h:217
#define GLOBAL(type)
Definition: jmorecfg.h:188
boolean need_full_buffer
Definition: jpegint.h:338
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:261
#define JPP(arglist)
Definition: jpeglib.h:818
#define JPEG_SCAN_COMPLETED
Definition: jpeglib.h:999
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:68
JCOEF * JCOEFPTR
Definition: jpeglib.h:75
#define JPEG_ROW_COMPLETED
Definition: jpeglib.h:998
JBLOCKROW * JBLOCKARRAY
Definition: jpeglib.h:72
JCOEF JBLOCK[64]
Definition: jpeglib.h:70
JBLOCK * JBLOCKROW
Definition: jpeglib.h:71
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:67
#define JPOOL_IMAGE
Definition: jpeglib.h:749
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:46
#define JPEG_SUSPENDED
Definition: jpeglib.h:965
#define D_MAX_BLOCKS_IN_MCU
Definition: jpeglib.h:57
long jround_up(long a, long b)
Definition: jutils.c:81
void jcopy_block_row(JBLOCKROW input_row, JBLOCKROW output_row, JDIMENSION num_blocks)
Definition: jutils.c:145
void jzero_far(void *target, size_t bytestozero)
Definition: jutils.c:165
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific i
Definition: afcover.h:80
for(n=0;n< outline->n_points;n++)
Definition: ftbbox.c:494
#define JDIMENSION
Definition: gd_topal.c:67
#define output_buf
Definition: gd_topal.c:130
int num
Definition: disdvi.c:621
int32 qtable[]
Definition: postdct.c:145
static int delta
Definition: pbmtolj.c:36
integer yoffset[256]
Definition: pbmtopk.c:49
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
static void yindex(LexState *ls, expdesc *v)
Definition: lparser.c:622
UINT16 quantval[64]
Definition: jpeglib.h:88
Definition: utils.c:300
JDIMENSION width_in_blocks
Definition: jpeglib.h:139
JDIMENSION height_in_blocks
Definition: jpeglib.h:140
boolean component_needed
Definition: jpeglib.h:160
JQUANT_TBL * quant_table
Definition: jpeglib.h:175
struct jpeg_c_coef_controller pub
Definition: jccoefct.c:35
JBLOCKROW MCU_buffer[10]
Definition: jccoefct.c:51
int MCU_rows_per_iMCU_row
Definition: jccoefct.c:40
JDIMENSION MCU_ctr
Definition: jdcoefct.c:33
jvirt_barray_ptr whole_image[10]
Definition: jccoefct.c:54
int * coef_bits_latch
Definition: jdcoefct.c:57
while(temp)
Definition: t4ht.c:858
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)
#define buffer
Definition: xmlparse.c:611