ReactOS 0.4.15-dev-7705-g2320c37
jccoefct.c
Go to the documentation of this file.
1/*
2 * jccoefct.c
3 *
4 * Copyright (C) 1994-1997, Thomas G. Lane.
5 * Modified 2003-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 compression.
10 * This controller is the top level of the JPEG compressor proper.
11 * The coefficient buffer lies between forward-DCT and entropy encoding steps.
12 */
13
14#define JPEG_INTERNALS
15#include "jinclude.h"
16#include "jpeglib.h"
17
18
19/* We use a full-image coefficient buffer when doing Huffman optimization,
20 * and also for writing multiple-scan JPEG files. In all cases, the DCT
21 * step is run during the first pass, and subsequent passes need only read
22 * the buffered coefficients.
23 */
24#ifdef ENTROPY_OPT_SUPPORTED
25#define FULL_COEF_BUFFER_SUPPORTED
26#else
27#ifdef C_MULTISCAN_FILES_SUPPORTED
28#define FULL_COEF_BUFFER_SUPPORTED
29#endif
30#endif
31
32
33/* Private buffer controller object */
34
35typedef struct {
36 struct jpeg_c_coef_controller pub; /* public fields */
37
38 JDIMENSION iMCU_row_num; /* iMCU row # within image */
39 JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
40 int MCU_vert_offset; /* counts MCU rows within iMCU row */
41 int MCU_rows_per_iMCU_row; /* number of such rows needed */
42
43 /* For single-pass compression, it's sufficient to buffer just one MCU
44 * (although this may prove a bit slow in practice). We allocate a
45 * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
46 * MCU constructed and sent. (On 80x86, the workspace is FAR even though
47 * it's not really very big; this is to keep the module interfaces unchanged
48 * when a large coefficient buffer is necessary.)
49 * In multi-pass modes, this array points to the current MCU's blocks
50 * within the virtual arrays.
51 */
53
54 /* In multi-pass modes, we need a virtual block array for each component. */
57
59
60
61/* Forward declarations */
63 JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
64#ifdef FULL_COEF_BUFFER_SUPPORTED
65METHODDEF(boolean) compress_first_pass
66 JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
68 JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
69#endif
70
71
72LOCAL(void)
74/* Reset within-iMCU-row counters for a new row */
75{
76 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
77
78 /* In an interleaved scan, an MCU row is the same as an iMCU row.
79 * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
80 * But at the bottom of the image, process only what's left.
81 */
82 if (cinfo->comps_in_scan > 1) {
83 coef->MCU_rows_per_iMCU_row = 1;
84 } else {
85 if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
87 else
89 }
90
91 coef->mcu_ctr = 0;
92 coef->MCU_vert_offset = 0;
93}
94
95
96/*
97 * Initialize for a processing pass.
98 */
99
100METHODDEF(void)
102{
103 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
104
105 coef->iMCU_row_num = 0;
106 start_iMCU_row(cinfo);
107
108 switch (pass_mode) {
109 case JBUF_PASS_THRU:
110 if (coef->whole_image[0] != NULL)
111 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
112 coef->pub.compress_data = compress_data;
113 break;
114#ifdef FULL_COEF_BUFFER_SUPPORTED
116 if (coef->whole_image[0] == NULL)
117 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
118 coef->pub.compress_data = compress_first_pass;
119 break;
120 case JBUF_CRANK_DEST:
121 if (coef->whole_image[0] == NULL)
122 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
123 coef->pub.compress_data = compress_output;
124 break;
125#endif
126 default:
127 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
128 break;
129 }
130}
131
132
133/*
134 * Process some data in the single-pass case.
135 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
136 * per call, ie, v_samp_factor block rows for each component in the image.
137 * Returns TRUE if the iMCU row is completed, FALSE if suspended.
138 *
139 * NB: input_buf contains a plane for each component in image,
140 * which we index according to the component's SOF position.
141 */
142
143METHODDEF(boolean)
145{
146 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
147 JDIMENSION MCU_col_num; /* index of current MCU within row */
148 JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
149 JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
150 int blkn, bi, ci, yindex, yoffset, blockcnt;
151 JDIMENSION ypos, xpos;
153 forward_DCT_ptr forward_DCT;
154
155 /* Loop to write as much as one whole iMCU row */
156 for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
157 yoffset++) {
158 for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
159 MCU_col_num++) {
160 /* Determine where data comes from in input_buf and do the DCT thing.
161 * Each call on forward_DCT processes a horizontal row of DCT blocks
162 * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
163 * sequentially. Dummy blocks at the right or bottom edge are filled in
164 * specially. The data in them does not matter for image reconstruction,
165 * so we fill them with values that will encode to the smallest amount of
166 * data, viz: all zeroes in the AC entries, DC entries equal to previous
167 * block's DC value. (Thanks to Thomas Kinsman for this idea.)
168 */
169 blkn = 0;
170 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
171 compptr = cinfo->cur_comp_info[ci];
172 forward_DCT = cinfo->fdct->forward_DCT[compptr->component_index];
173 blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
175 xpos = MCU_col_num * compptr->MCU_sample_width;
177 /* ypos == (yoffset+yindex) * DCTSIZE */
178 for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
179 if (coef->iMCU_row_num < last_iMCU_row ||
180 yoffset+yindex < compptr->last_row_height) {
181 (*forward_DCT) (cinfo, compptr,
182 input_buf[compptr->component_index],
183 coef->MCU_buffer[blkn],
184 ypos, xpos, (JDIMENSION) blockcnt);
185 if (blockcnt < compptr->MCU_width) {
186 /* Create some dummy blocks at the right edge of the image. */
187 FMEMZERO((void FAR *) coef->MCU_buffer[blkn + blockcnt],
188 (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
189 for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
190 coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
191 }
192 }
193 } else {
194 /* Create a row of dummy blocks at the bottom of the image. */
195 FMEMZERO((void FAR *) coef->MCU_buffer[blkn],
197 for (bi = 0; bi < compptr->MCU_width; bi++) {
198 coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
199 }
200 }
201 blkn += compptr->MCU_width;
202 ypos += compptr->DCT_v_scaled_size;
203 }
204 }
205 /* Try to write the MCU. In event of a suspension failure, we will
206 * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
207 */
208 if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
209 /* Suspension forced; update state counters and exit */
210 coef->MCU_vert_offset = yoffset;
211 coef->mcu_ctr = MCU_col_num;
212 return FALSE;
213 }
214 }
215 /* Completed an MCU row, but perhaps not an iMCU row */
216 coef->mcu_ctr = 0;
217 }
218 /* Completed the iMCU row, advance counters for next one */
219 coef->iMCU_row_num++;
220 start_iMCU_row(cinfo);
221 return TRUE;
222}
223
224
225#ifdef FULL_COEF_BUFFER_SUPPORTED
226
227/*
228 * Process some data in the first pass of a multi-pass case.
229 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
230 * per call, ie, v_samp_factor block rows for each component in the image.
231 * This amount of data is read from the source buffer, DCT'd and quantized,
232 * and saved into the virtual arrays. We also generate suitable dummy blocks
233 * as needed at the right and lower edges. (The dummy blocks are constructed
234 * in the virtual arrays, which have been padded appropriately.) This makes
235 * it possible for subsequent passes not to worry about real vs. dummy blocks.
236 *
237 * We must also emit the data to the entropy encoder. This is conveniently
238 * done by calling compress_output() after we've loaded the current strip
239 * of the virtual arrays.
240 *
241 * NB: input_buf contains a plane for each component in image. All
242 * components are DCT'd and loaded into the virtual arrays in this pass.
243 * However, it may be that only a subset of the components are emitted to
244 * the entropy encoder during this first pass; be careful about looking
245 * at the scan-dependent variables (MCU dimensions, etc).
246 */
247
248METHODDEF(boolean)
249compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
250{
251 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
252 JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
253 JDIMENSION blocks_across, MCUs_across, MCUindex;
254 int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
255 JCOEF lastDC;
258 JBLOCKROW thisblockrow, lastblockrow;
259 forward_DCT_ptr forward_DCT;
260
261 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
262 ci++, compptr++) {
263 /* Align the virtual buffer for this component. */
264 buffer = (*cinfo->mem->access_virt_barray)
265 ((j_common_ptr) cinfo, coef->whole_image[ci],
268 /* Count non-dummy DCT block rows in this iMCU row. */
269 if (coef->iMCU_row_num < last_iMCU_row)
270 block_rows = compptr->v_samp_factor;
271 else {
272 /* NB: can't use last_row_height here, since may not be set! */
273 block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
274 if (block_rows == 0) block_rows = compptr->v_samp_factor;
275 }
276 blocks_across = compptr->width_in_blocks;
277 h_samp_factor = compptr->h_samp_factor;
278 /* Count number of dummy blocks to be added at the right margin. */
279 ndummy = (int) (blocks_across % h_samp_factor);
280 if (ndummy > 0)
281 ndummy = h_samp_factor - ndummy;
282 forward_DCT = cinfo->fdct->forward_DCT[ci];
283 /* Perform DCT for all non-dummy blocks in this iMCU row. Each call
284 * on forward_DCT processes a complete horizontal row of DCT blocks.
285 */
286 for (block_row = 0; block_row < block_rows; block_row++) {
287 thisblockrow = buffer[block_row];
288 (*forward_DCT) (cinfo, compptr, input_buf[ci], thisblockrow,
289 (JDIMENSION) (block_row * compptr->DCT_v_scaled_size),
290 (JDIMENSION) 0, blocks_across);
291 if (ndummy > 0) {
292 /* Create dummy blocks at the right edge of the image. */
293 thisblockrow += blocks_across; /* => first dummy block */
294 FMEMZERO((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
295 lastDC = thisblockrow[-1][0];
296 for (bi = 0; bi < ndummy; bi++) {
297 thisblockrow[bi][0] = lastDC;
298 }
299 }
300 }
301 /* If at end of image, create dummy block rows as needed.
302 * The tricky part here is that within each MCU, we want the DC values
303 * of the dummy blocks to match the last real block's DC value.
304 * This squeezes a few more bytes out of the resulting file...
305 */
306 if (coef->iMCU_row_num == last_iMCU_row) {
307 blocks_across += ndummy; /* include lower right corner */
308 MCUs_across = blocks_across / h_samp_factor;
309 for (block_row = block_rows; block_row < compptr->v_samp_factor;
310 block_row++) {
311 thisblockrow = buffer[block_row];
312 lastblockrow = buffer[block_row-1];
313 FMEMZERO((void FAR *) thisblockrow,
314 (size_t) (blocks_across * SIZEOF(JBLOCK)));
315 for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
316 lastDC = lastblockrow[h_samp_factor-1][0];
317 for (bi = 0; bi < h_samp_factor; bi++) {
318 thisblockrow[bi][0] = lastDC;
319 }
320 thisblockrow += h_samp_factor; /* advance to next MCU in row */
321 lastblockrow += h_samp_factor;
322 }
323 }
324 }
325 }
326 /* NB: compress_output will increment iMCU_row_num if successful.
327 * A suspension return will result in redoing all the work above next time.
328 */
329
330 /* Emit data to the entropy encoder, sharing code with subsequent passes */
331 return compress_output(cinfo, input_buf);
332}
333
334
335/*
336 * Process some data in subsequent passes of a multi-pass case.
337 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
338 * per call, ie, v_samp_factor block rows for each component in the scan.
339 * The data is obtained from the virtual arrays and fed to the entropy coder.
340 * Returns TRUE if the iMCU row is completed, FALSE if suspended.
341 *
342 * NB: input_buf is ignored; it is likely to be a NULL pointer.
343 */
344
345METHODDEF(boolean)
347{
348 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
349 JDIMENSION MCU_col_num; /* index of current MCU within row */
350 int blkn, ci, xindex, yindex, yoffset;
353 JBLOCKROW buffer_ptr;
355
356 /* Align the virtual buffers for the components used in this scan.
357 * NB: during first pass, this is safe only because the buffers will
358 * already be aligned properly, so jmemmgr.c won't need to do any I/O.
359 */
360 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
361 compptr = cinfo->cur_comp_info[ci];
362 buffer[ci] = (*cinfo->mem->access_virt_barray)
366 }
367
368 /* Loop to process one whole iMCU row */
369 for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
370 yoffset++) {
371 for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
372 MCU_col_num++) {
373 /* Construct list of pointers to DCT blocks belonging to this MCU */
374 blkn = 0; /* index of current DCT block within MCU */
375 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
376 compptr = cinfo->cur_comp_info[ci];
377 start_col = MCU_col_num * compptr->MCU_width;
378 for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
379 buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
380 for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
381 coef->MCU_buffer[blkn++] = buffer_ptr++;
382 }
383 }
384 }
385 /* Try to write the MCU. */
386 if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
387 /* Suspension forced; update state counters and exit */
388 coef->MCU_vert_offset = yoffset;
389 coef->mcu_ctr = MCU_col_num;
390 return FALSE;
391 }
392 }
393 /* Completed an MCU row, but perhaps not an iMCU row */
394 coef->mcu_ctr = 0;
395 }
396 /* Completed the iMCU row, advance counters for next one */
397 coef->iMCU_row_num++;
398 start_iMCU_row(cinfo);
399 return TRUE;
400}
401
402#endif /* FULL_COEF_BUFFER_SUPPORTED */
403
404
405/*
406 * Initialize coefficient buffer controller.
407 */
408
409GLOBAL(void)
411{
412 my_coef_ptr coef;
413
414 coef = (my_coef_ptr)
415 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
417 cinfo->coef = (struct jpeg_c_coef_controller *) coef;
418 coef->pub.start_pass = start_pass_coef;
419
420 /* Create the coefficient buffer. */
421 if (need_full_buffer) {
422#ifdef FULL_COEF_BUFFER_SUPPORTED
423 /* Allocate a full-image virtual array for each component, */
424 /* padded to a multiple of samp_factor DCT blocks in each direction. */
425 int ci;
427
428 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
429 ci++, compptr++) {
430 coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
431 ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
437 }
438#else
439 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
440#endif
441 } else {
442 /* We only need a single-MCU buffer. */
444 int i;
445
446 buffer = (JBLOCKROW)
447 (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
449 for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
450 coef->MCU_buffer[i] = buffer + i;
451 }
452 coef->whole_image[0] = NULL; /* flag for no virtual arrays */
453 }
454}
#define SIZEOF(_ar)
Definition: calc.h:97
#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
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
jinit_c_coef_controller(j_compress_ptr cinfo, boolean need_full_buffer)
Definition: jccoefct.c:410
compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
Definition: jccoefct.c:144
start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
Definition: jccoefct.c:101
my_coef_controller * my_coef_ptr
Definition: jccoefct.c:58
forward_DCT(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks)
Definition: jcdctmgr.c:74
start_iMCU_row(j_compress_ptr cinfo)
Definition: jctrans.c:242
compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
Definition: jctrans.c:293
JSAMPARRAY JDIMENSION start_col
Definition: jdct.h:169
jpeg_component_info * compptr
Definition: jdct.h:238
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
J_BUF_MODE
Definition: jpegint.h:17
@ JBUF_PASS_THRU
Definition: jpegint.h:18
@ JBUF_SAVE_AND_PASS
Definition: jpegint.h:22
@ JBUF_CRANK_DEST
Definition: jpegint.h:21
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
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:77
#define C_MAX_BLOCKS_IN_MCU
Definition: jpeglib.h:64
JCOEF JBLOCK[DCTSIZE2]
Definition: jpeglib.h:79
JBLOCKROW * JBLOCKARRAY
Definition: jpeglib.h:81
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:55
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
JDIMENSION width_in_blocks
Definition: jpeglib.h:148
JDIMENSION height_in_blocks
Definition: jpeglib.h:149
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:423
struct jpeg_entropy_encoder * entropy
Definition: jpeglib.h:451
jpeg_component_info * comp_info
Definition: jpeglib.h:333
struct jpeg_forward_dct * fdct
Definition: jpeglib.h:450
struct jpeg_c_coef_controller * coef
Definition: jpeglib.h:446
JDIMENSION total_iMCU_rows
Definition: jpeglib.h:411
int MCU_rows_per_iMCU_row
Definition: jccoefct.c:41
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
JDIMENSION mcu_ctr
Definition: jccoefct.c:39
JDIMENSION iMCU_row_num
Definition: jccoefct.c:38