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