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