ReactOS 0.4.15-dev-8236-g99f0937
jdmainct.c
Go to the documentation of this file.
1/*
2 * jdmainct.c
3 *
4 * Copyright (C) 1994-1996, Thomas G. Lane.
5 * Modified 2002-2016 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 main buffer controller for decompression.
10 * The main buffer lies between the JPEG decompressor proper and the
11 * post-processor; it holds downsampled data in the JPEG colorspace.
12 *
13 * Note that this code is bypassed in raw-data mode, since the application
14 * supplies the equivalent of the main buffer in that case.
15 */
16
17#define JPEG_INTERNALS
18#include "jinclude.h"
19#include "jpeglib.h"
20
21
22/*
23 * In the current system design, the main buffer need never be a full-image
24 * buffer; any full-height buffers will be found inside the coefficient or
25 * postprocessing controllers. Nonetheless, the main controller is not
26 * trivial. Its responsibility is to provide context rows for upsampling/
27 * rescaling, and doing this in an efficient fashion is a bit tricky.
28 *
29 * Postprocessor input data is counted in "row groups". A row group is
30 * defined to be (v_samp_factor * DCT_v_scaled_size / min_DCT_v_scaled_size)
31 * sample rows of each component. (We require DCT_scaled_size values to be
32 * chosen such that these numbers are integers. In practice DCT_scaled_size
33 * values will likely be powers of two, so we actually have the stronger
34 * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
35 * Upsampling will typically produce max_v_samp_factor pixel rows from each
36 * row group (times any additional scale factor that the upsampler is
37 * applying).
38 *
39 * The coefficient controller will deliver data to us one iMCU row at a time;
40 * each iMCU row contains v_samp_factor * DCT_v_scaled_size sample rows, or
41 * exactly min_DCT_v_scaled_size row groups. (This amount of data corresponds
42 * to one row of MCUs when the image is fully interleaved.) Note that the
43 * number of sample rows varies across components, but the number of row
44 * groups does not. Some garbage sample rows may be included in the last iMCU
45 * row at the bottom of the image.
46 *
47 * Depending on the vertical scaling algorithm used, the upsampler may need
48 * access to the sample row(s) above and below its current input row group.
49 * The upsampler is required to set need_context_rows TRUE at global selection
50 * time if so. When need_context_rows is FALSE, this controller can simply
51 * obtain one iMCU row at a time from the coefficient controller and dole it
52 * out as row groups to the postprocessor.
53 *
54 * When need_context_rows is TRUE, this controller guarantees that the buffer
55 * passed to postprocessing contains at least one row group's worth of samples
56 * above and below the row group(s) being processed. Note that the context
57 * rows "above" the first passed row group appear at negative row offsets in
58 * the passed buffer. At the top and bottom of the image, the required
59 * context rows are manufactured by duplicating the first or last real sample
60 * row; this avoids having special cases in the upsampling inner loops.
61 *
62 * The amount of context is fixed at one row group just because that's a
63 * convenient number for this controller to work with. The existing
64 * upsamplers really only need one sample row of context. An upsampler
65 * supporting arbitrary output rescaling might wish for more than one row
66 * group of context when shrinking the image; tough, we don't handle that.
67 * (This is justified by the assumption that downsizing will be handled mostly
68 * by adjusting the DCT_scaled_size values, so that the actual scale factor at
69 * the upsample step needn't be much less than one.)
70 *
71 * To provide the desired context, we have to retain the last two row groups
72 * of one iMCU row while reading in the next iMCU row. (The last row group
73 * can't be processed until we have another row group for its below-context,
74 * and so we have to save the next-to-last group too for its above-context.)
75 * We could do this most simply by copying data around in our buffer, but
76 * that'd be very slow. We can avoid copying any data by creating a rather
77 * strange pointer structure. Here's how it works. We allocate a workspace
78 * consisting of M+2 row groups (where M = min_DCT_v_scaled_size is the number
79 * of row groups per iMCU row). We create two sets of redundant pointers to
80 * the workspace. Labeling the physical row groups 0 to M+1, the synthesized
81 * pointer lists look like this:
82 * M+1 M-1
83 * master pointer --> 0 master pointer --> 0
84 * 1 1
85 * ... ...
86 * M-3 M-3
87 * M-2 M
88 * M-1 M+1
89 * M M-2
90 * M+1 M-1
91 * 0 0
92 * We read alternate iMCU rows using each master pointer; thus the last two
93 * row groups of the previous iMCU row remain un-overwritten in the workspace.
94 * The pointer lists are set up so that the required context rows appear to
95 * be adjacent to the proper places when we pass the pointer lists to the
96 * upsampler.
97 *
98 * The above pictures describe the normal state of the pointer lists.
99 * At top and bottom of the image, we diddle the pointer lists to duplicate
100 * the first or last sample row as necessary (this is cheaper than copying
101 * sample rows around).
102 *
103 * This scheme breaks down if M < 2, ie, min_DCT_v_scaled_size is 1. In that
104 * situation each iMCU row provides only one row group so the buffering logic
105 * must be different (eg, we must read two iMCU rows before we can emit the
106 * first row group). For now, we simply do not support providing context
107 * rows when min_DCT_v_scaled_size is 1. That combination seems unlikely to
108 * be worth providing --- if someone wants a 1/8th-size preview, they probably
109 * want it quick and dirty, so a context-free upsampler is sufficient.
110 */
111
112
113/* Private buffer controller object */
114
115typedef struct {
116 struct jpeg_d_main_controller pub; /* public fields */
117
118 /* Pointer to allocated workspace (M or M+2 row groups). */
120
121 JDIMENSION rowgroup_ctr; /* counts row groups output to postprocessor */
122 JDIMENSION rowgroups_avail; /* row groups available to postprocessor */
123
124 /* Remaining fields are only used in the context case. */
125
126 boolean buffer_full; /* Have we gotten an iMCU row from decoder? */
127
128 /* These are the master pointers to the funny-order pointer lists. */
129 JSAMPIMAGE xbuffer[2]; /* pointers to weird pointer lists */
130
131 int whichptr; /* indicates which pointer set is now in use */
132 int context_state; /* process_data state machine status */
133 JDIMENSION iMCU_row_ctr; /* counts iMCU rows to detect image top/bot */
135
137
138/* context_state values: */
139#define CTX_PREPARE_FOR_IMCU 0 /* need to prepare for MCU row */
140#define CTX_PROCESS_IMCU 1 /* feeding iMCU to postprocessor */
141#define CTX_POSTPONED_ROW 2 /* feeding postponed row group */
142
143
144/* Forward declarations */
147 JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
150 JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
151#ifdef QUANT_2PASS_SUPPORTED
152METHODDEF(void) process_data_crank_post
154 JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
155#endif
156
157
158LOCAL(void)
159alloc_funny_pointers (j_decompress_ptr cinfo)
160/* Allocate space for the funny pointer lists.
161 * This is done only once, not once per pass.
162 */
163{
164 my_main_ptr mainp = (my_main_ptr) cinfo->main;
165 int ci, rgroup;
166 int M = cinfo->min_DCT_v_scaled_size;
168 JSAMPARRAY xbuf;
169
170 /* Get top-level space for component array pointers.
171 * We alloc both arrays with one call to save a few cycles.
172 */
173 mainp->xbuffer[0] = (JSAMPIMAGE)
174 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
175 cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
176 mainp->xbuffer[1] = mainp->xbuffer[0] + cinfo->num_components;
177
178 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
179 ci++, compptr++) {
181 cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
182 /* Get space for pointer lists --- M+4 row groups in each list.
183 * We alloc both pointer lists with one call to save a few cycles.
184 */
185 xbuf = (JSAMPARRAY)
186 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
187 2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
188 xbuf += rgroup; /* want one row group at negative offsets */
189 mainp->xbuffer[0][ci] = xbuf;
190 xbuf += rgroup * (M + 4);
191 mainp->xbuffer[1][ci] = xbuf;
192 }
193}
194
195
196LOCAL(void)
198/* Create the funny pointer lists discussed in the comments above.
199 * The actual workspace is already allocated (in mainp->buffer),
200 * and the space for the pointer lists is allocated too.
201 * This routine just fills in the curiously ordered lists.
202 * This will be repeated at the beginning of each pass.
203 */
204{
205 my_main_ptr mainp = (my_main_ptr) cinfo->main;
206 int ci, i, rgroup;
207 int M = cinfo->min_DCT_v_scaled_size;
209 JSAMPARRAY buf, xbuf0, xbuf1;
210
211 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
212 ci++, compptr++) {
214 cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
215 xbuf0 = mainp->xbuffer[0][ci];
216 xbuf1 = mainp->xbuffer[1][ci];
217 /* First copy the workspace pointers as-is */
218 buf = mainp->buffer[ci];
219 for (i = 0; i < rgroup * (M + 2); i++) {
220 xbuf0[i] = xbuf1[i] = buf[i];
221 }
222 /* In the second list, put the last four row groups in swapped order */
223 for (i = 0; i < rgroup * 2; i++) {
224 xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i];
225 xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i];
226 }
227 /* The wraparound pointers at top and bottom will be filled later
228 * (see set_wraparound_pointers, below). Initially we want the "above"
229 * pointers to duplicate the first actual data line. This only needs
230 * to happen in xbuffer[0].
231 */
232 for (i = 0; i < rgroup; i++) {
233 xbuf0[i - rgroup] = xbuf0[0];
234 }
235 }
236}
237
238
239LOCAL(void)
241/* Set up the "wraparound" pointers at top and bottom of the pointer lists.
242 * This changes the pointer list state from top-of-image to the normal state.
243 */
244{
245 my_main_ptr mainp = (my_main_ptr) cinfo->main;
246 int ci, i, rgroup;
247 int M = cinfo->min_DCT_v_scaled_size;
249 JSAMPARRAY xbuf0, xbuf1;
250
251 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
252 ci++, compptr++) {
254 cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
255 xbuf0 = mainp->xbuffer[0][ci];
256 xbuf1 = mainp->xbuffer[1][ci];
257 for (i = 0; i < rgroup; i++) {
258 xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];
259 xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];
260 xbuf0[rgroup*(M+2) + i] = xbuf0[i];
261 xbuf1[rgroup*(M+2) + i] = xbuf1[i];
262 }
263 }
264}
265
266
267LOCAL(void)
269/* Change the pointer lists to duplicate the last sample row at the bottom
270 * of the image. whichptr indicates which xbuffer holds the final iMCU row.
271 * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
272 */
273{
274 my_main_ptr mainp = (my_main_ptr) cinfo->main;
275 int ci, i, rgroup, iMCUheight, rows_left;
277 JSAMPARRAY xbuf;
278
279 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
280 ci++, compptr++) {
281 /* Count sample rows in one iMCU row and in one row group */
283 rgroup = iMCUheight / cinfo->min_DCT_v_scaled_size;
284 /* Count nondummy sample rows remaining for this component */
285 rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
286 if (rows_left == 0) rows_left = iMCUheight;
287 /* Count nondummy row groups. Should get same answer for each component,
288 * so we need only do it once.
289 */
290 if (ci == 0) {
291 mainp->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
292 }
293 /* Duplicate the last real sample row rgroup*2 times; this pads out the
294 * last partial rowgroup and ensures at least one full rowgroup of context.
295 */
296 xbuf = mainp->xbuffer[mainp->whichptr][ci];
297 for (i = 0; i < rgroup * 2; i++) {
298 xbuf[rows_left + i] = xbuf[rows_left-1];
299 }
300 }
301}
302
303
304/*
305 * Initialize for a processing pass.
306 */
307
308METHODDEF(void)
310{
311 my_main_ptr mainp = (my_main_ptr) cinfo->main;
312
313 switch (pass_mode) {
314 case JBUF_PASS_THRU:
315 if (cinfo->upsample->need_context_rows) {
316 mainp->pub.process_data = process_data_context_main;
317 make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
318 mainp->whichptr = 0; /* Read first iMCU row into xbuffer[0] */
320 mainp->iMCU_row_ctr = 0;
321 mainp->buffer_full = FALSE; /* Mark buffer empty */
322 } else {
323 /* Simple case with no context needed */
324 mainp->pub.process_data = process_data_simple_main;
325 mainp->rowgroup_ctr = mainp->rowgroups_avail; /* Mark buffer empty */
326 }
327 break;
328#ifdef QUANT_2PASS_SUPPORTED
329 case JBUF_CRANK_DEST:
330 /* For last pass of 2-pass quantization, just crank the postprocessor */
331 mainp->pub.process_data = process_data_crank_post;
332 break;
333#endif
334 default:
335 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
336 break;
337 }
338}
339
340
341/*
342 * Process some data.
343 * This handles the simple case where no context is required.
344 */
345
346METHODDEF(void)
348 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
349 JDIMENSION out_rows_avail)
350{
351 my_main_ptr mainp = (my_main_ptr) cinfo->main;
352
353 /* Read input data if we haven't filled the main buffer yet */
354 if (mainp->rowgroup_ctr >= mainp->rowgroups_avail) {
355 if (! (*cinfo->coef->decompress_data) (cinfo, mainp->buffer))
356 return; /* suspension forced, can do nothing more */
357 mainp->rowgroup_ctr = 0; /* OK, we have an iMCU row to work with */
358 }
359
360 /* Note: at the bottom of the image, we may pass extra garbage row groups
361 * to the postprocessor. The postprocessor has to check for bottom
362 * of image anyway (at row resolution), so no point in us doing it too.
363 */
364
365 /* Feed the postprocessor */
366 (*cinfo->post->post_process_data) (cinfo, mainp->buffer,
367 &mainp->rowgroup_ctr, mainp->rowgroups_avail,
368 output_buf, out_row_ctr, out_rows_avail);
369}
370
371
372/*
373 * Process some data.
374 * This handles the case where context rows must be provided.
375 */
376
377METHODDEF(void)
379 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
380 JDIMENSION out_rows_avail)
381{
382 my_main_ptr mainp = (my_main_ptr) cinfo->main;
383
384 /* Read input data if we haven't filled the main buffer yet */
385 if (! mainp->buffer_full) {
386 if (! (*cinfo->coef->decompress_data) (cinfo,
387 mainp->xbuffer[mainp->whichptr]))
388 return; /* suspension forced, can do nothing more */
389 mainp->buffer_full = TRUE; /* OK, we have an iMCU row to work with */
390 mainp->iMCU_row_ctr++; /* count rows received */
391 }
392
393 /* Postprocessor typically will not swallow all the input data it is handed
394 * in one call (due to filling the output buffer first). Must be prepared
395 * to exit and restart. This switch lets us keep track of how far we got.
396 * Note that each case falls through to the next on successful completion.
397 */
398 switch (mainp->context_state) {
400 /* Call postprocessor using previously set pointers for postponed row */
401 (*cinfo->post->post_process_data) (cinfo, mainp->xbuffer[mainp->whichptr],
402 &mainp->rowgroup_ctr, mainp->rowgroups_avail,
403 output_buf, out_row_ctr, out_rows_avail);
404 if (mainp->rowgroup_ctr < mainp->rowgroups_avail)
405 return; /* Need to suspend */
407 if (*out_row_ctr >= out_rows_avail)
408 return; /* Postprocessor exactly filled output buf */
409 /*FALLTHROUGH*/
411 /* Prepare to process first M-1 row groups of this iMCU row */
412 mainp->rowgroup_ctr = 0;
413 mainp->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_v_scaled_size - 1);
414 /* Check for bottom of image: if so, tweak pointers to "duplicate"
415 * the last sample row, and adjust rowgroups_avail to ignore padding rows.
416 */
417 if (mainp->iMCU_row_ctr == cinfo->total_iMCU_rows)
418 set_bottom_pointers(cinfo);
420 /*FALLTHROUGH*/
421 case CTX_PROCESS_IMCU:
422 /* Call postprocessor using previously set pointers */
423 (*cinfo->post->post_process_data) (cinfo, mainp->xbuffer[mainp->whichptr],
424 &mainp->rowgroup_ctr, mainp->rowgroups_avail,
425 output_buf, out_row_ctr, out_rows_avail);
426 if (mainp->rowgroup_ctr < mainp->rowgroups_avail)
427 return; /* Need to suspend */
428 /* After the first iMCU, change wraparound pointers to normal state */
429 if (mainp->iMCU_row_ctr == 1)
431 /* Prepare to load new iMCU row using other xbuffer list */
432 mainp->whichptr ^= 1; /* 0=>1 or 1=>0 */
433 mainp->buffer_full = FALSE;
434 /* Still need to process last row group of this iMCU row, */
435 /* which is saved at index M+1 of the other xbuffer */
436 mainp->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_v_scaled_size + 1);
437 mainp->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_v_scaled_size + 2);
439 }
440}
441
442
443/*
444 * Process some data.
445 * Final pass of two-pass quantization: just call the postprocessor.
446 * Source data will be the postprocessor controller's internal buffer.
447 */
448
449#ifdef QUANT_2PASS_SUPPORTED
450
451METHODDEF(void)
452process_data_crank_post (j_decompress_ptr cinfo,
453 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
454 JDIMENSION out_rows_avail)
455{
456 (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
457 (JDIMENSION *) NULL, (JDIMENSION) 0,
458 output_buf, out_row_ctr, out_rows_avail);
459}
460
461#endif /* QUANT_2PASS_SUPPORTED */
462
463
464/*
465 * Initialize main buffer controller.
466 */
467
468GLOBAL(void)
470{
471 my_main_ptr mainp;
472 int ci, rgroup, ngroups;
474
475 mainp = (my_main_ptr)
476 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
478 cinfo->main = &mainp->pub;
479 mainp->pub.start_pass = start_pass_main;
480
481 if (need_full_buffer) /* shouldn't happen */
482 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
483
484 /* Allocate the workspace.
485 * ngroups is the number of row groups we need.
486 */
487 if (cinfo->upsample->need_context_rows) {
488 if (cinfo->min_DCT_v_scaled_size < 2) /* unsupported, see comments above */
489 ERREXIT(cinfo, JERR_NOTIMPL);
490 alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
491 ngroups = cinfo->min_DCT_v_scaled_size + 2;
492 } else {
493 /* There are always min_DCT_v_scaled_size row groups in an iMCU row. */
494 ngroups = cinfo->min_DCT_v_scaled_size;
495 mainp->rowgroups_avail = (JDIMENSION) ngroups;
496 }
497
498 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
499 ci++, compptr++) {
501 cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
502 mainp->buffer[ci] = (*cinfo->mem->alloc_sarray)
503 ((j_common_ptr) cinfo, JPOOL_IMAGE,
505 (JDIMENSION) (rgroup * ngroups));
506 }
507}
#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 M(row, col)
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
switch(r->id)
Definition: btrfs.c:3046
GLuint buffer
Definition: glext.h:5915
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
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
jpeg_component_info * compptr
Definition: jdct.h:238
jpeg_component_info JCOEFPTR JSAMPARRAY output_buf
Definition: jdct.h:239
set_bottom_pointers(j_decompress_ptr cinfo)
Definition: jdmainct.c:268
METHODDEF(void)
Definition: jdmainct.c:145
my_main_controller * my_main_ptr
Definition: jdmainct.c:136
jinit_d_main_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
Definition: jdmainct.c:469
set_wraparound_pointers(j_decompress_ptr cinfo)
Definition: jdmainct.c:240
start_pass_main(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
Definition: jdmainct.c:309
#define CTX_PREPARE_FOR_IMCU
Definition: jdmainct.c:139
process_data_context_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
Definition: jdmainct.c:378
make_funny_pointers(j_decompress_ptr cinfo)
Definition: jdmainct.c:197
process_data_simple_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
Definition: jdmainct.c:347
#define CTX_PROCESS_IMCU
Definition: jdmainct.c:140
#define CTX_POSTPONED_ROW
Definition: jdmainct.c:141
unsigned int JDIMENSION
Definition: jmorecfg.h:229
#define MAX_COMPONENTS
Definition: jmorecfg.h:45
#define LOCAL(type)
Definition: jmorecfg.h:289
#define GLOBAL(type)
Definition: jmorecfg.h:291
J_BUF_MODE
Definition: jpegint.h:17
@ JBUF_PASS_THRU
Definition: jpegint.h:18
@ JBUF_CRANK_DEST
Definition: jpegint.h:21
boolean need_full_buffer
Definition: jpegint.h:384
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
#define JPP(arglist)
Definition: jpeglib.h:877
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:77
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:76
JSAMPLE FAR * JSAMPROW
Definition: jpeglib.h:75
#define JPOOL_IMAGE
Definition: jpeglib.h:808
if(dx< 0)
Definition: linetemp.h:194
#define for
Definition: utility.h:88
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
JDIMENSION downsampled_height
Definition: jpeglib.h:165
JDIMENSION width_in_blocks
Definition: jpeglib.h:148
struct jpeg_d_post_controller * post
Definition: jpeglib.h:681
struct jpeg_d_main_controller * main
Definition: jpeglib.h:679
jpeg_component_info * comp_info
Definition: jpeglib.h:583
JDIMENSION iMCU_row_ctr
Definition: jdmainct.c:133
JSAMPIMAGE xbuffer[2]
Definition: jdmainct.c:129
JDIMENSION rowgroup_ctr
Definition: jcmainct.c:33
JSAMPARRAY buffer[MAX_COMPONENTS]
Definition: jcmainct.c:41
boolean buffer_full
Definition: jdmainct.c:126
JDIMENSION rowgroups_avail
Definition: jdmainct.c:122
struct jpeg_c_main_controller pub
Definition: jcmainct.c:30