ReactOS  0.4.14-dev-323-g6fe6a88
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 
35 typedef 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
65 METHODDEF(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 
72 LOCAL(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 
100 METHODDEF(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
115  case JBUF_SAVE_AND_PASS:
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 
143 METHODDEF(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 
248 METHODDEF(boolean)
249 compress_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 
345 METHODDEF(boolean)
346 compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
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 
409 GLOBAL(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 TRUE
Definition: types.h:120
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
struct jpeg_forward_dct * fdct
Definition: jpeglib.h:450
JSAMPARRAY JDIMENSION start_col
Definition: jdct.h:169
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
JCOEF JBLOCK[DCTSIZE2]
Definition: jpeglib.h:79
compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
Definition: jccoefct.c:144
JBLOCKROW * JBLOCKARRAY
Definition: jpeglib.h:81
#define MAX_COMPONENTS
Definition: jmorecfg.h:45
GLuint buffer
Definition: glext.h:5915
JDIMENSION mcu_ctr
Definition: jccoefct.c:39
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
boolean need_full_buffer
Definition: jpegint.h:377
GLint GLint GLint yoffset
Definition: gl.h:1547
short JCOEF
Definition: jmorecfg.h:151
struct jpeg_entropy_encoder * entropy
Definition: jpeglib.h:451
jpeg_component_info * compptr
Definition: jdct.h:238
JDIMENSION width_in_blocks
Definition: jpeglib.h:148
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define FAR
Definition: guiddef.h:36
struct jpeg_c_coef_controller pub
Definition: jccoefct.c:36
jround_up(long a, long b)
Definition: jutils.c:133
compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
Definition: jctrans.c:293
smooth NULL
Definition: ftsmooth.c:416
JDIMENSION height_in_blocks
Definition: jpeglib.h:149
struct jpeg_c_coef_controller * coef
Definition: jpeglib.h:446
my_coef_controller * my_coef_ptr
Definition: jccoefct.c:58
#define LOCAL(type)
Definition: jmorecfg.h:289
JDIMENSION total_iMCU_rows
Definition: jpeglib.h:411
JDIMENSION iMCU_row_num
Definition: jccoefct.c:38
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define C_MAX_BLOCKS_IN_MCU
Definition: jpeglib.h:64
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:80
#define for
Definition: utility.h:88
#define JPP(arglist)
Definition: jpeglib.h:877
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:77
METHODDEF(boolean)
Definition: jccoefct.c:62
#define GLOBAL(type)
Definition: jmorecfg.h:291
start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
Definition: jccoefct.c:101
start_iMCU_row(j_compress_ptr cinfo)
Definition: jctrans.c:242
#define long
Definition: qsort.c:33
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:423
J_BUF_MODE
Definition: jpegint.h:17
jvirt_barray_ptr whole_image[MAX_COMPONENTS]
Definition: jccoefct.c:55
unsigned int JDIMENSION
Definition: jmorecfg.h:229
jinit_c_coef_controller(j_compress_ptr cinfo, boolean need_full_buffer)
Definition: jccoefct.c:410
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:55
jpeg_component_info * comp_info
Definition: jpeglib.h:333
JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU]
Definition: jccoefct.c:52
int MCU_rows_per_iMCU_row
Definition: jccoefct.c:41
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define FMEMZERO(target, size)
Definition: jpegint.h:361