OLD | NEW |
1 /* | 1 /* |
2 * jdmainct.c | 2 * jdmainct.c |
3 * | 3 * |
4 * Copyright (C) 1994-1996, Thomas G. Lane. | 4 * Copyright (C) 1994-1996, Thomas G. Lane. |
5 * Copyright (C) 2010, D. R. Commander. | 5 * Copyright (C) 2010, D. R. Commander. |
6 * This file is part of the Independent JPEG Group's software. | 6 * This file is part of the Independent JPEG Group's software. |
7 * For conditions of distribution and use, see the accompanying README file. | 7 * For conditions of distribution and use, see the accompanying README file. |
8 * | 8 * |
9 * This file contains the main buffer controller for decompression. | 9 * This file contains the main buffer controller for decompression. |
10 * The main buffer lies between the JPEG decompressor proper and the | 10 * The main buffer lies between the JPEG decompressor proper and the |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
154 JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); | 154 JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); |
155 #endif | 155 #endif |
156 | 156 |
157 | 157 |
158 LOCAL(void) | 158 LOCAL(void) |
159 alloc_funny_pointers (j_decompress_ptr cinfo) | 159 alloc_funny_pointers (j_decompress_ptr cinfo) |
160 /* Allocate space for the funny pointer lists. | 160 /* Allocate space for the funny pointer lists. |
161 * This is done only once, not once per pass. | 161 * This is done only once, not once per pass. |
162 */ | 162 */ |
163 { | 163 { |
164 my_main_ptr main = (my_main_ptr) cinfo->main; | 164 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; |
165 int ci, rgroup; | 165 int ci, rgroup; |
166 int M = cinfo->_min_DCT_scaled_size; | 166 int M = cinfo->_min_DCT_scaled_size; |
167 jpeg_component_info *compptr; | 167 jpeg_component_info *compptr; |
168 JSAMPARRAY xbuf; | 168 JSAMPARRAY xbuf; |
169 | 169 |
170 /* Get top-level space for component array pointers. | 170 /* Get top-level space for component array pointers. |
171 * We alloc both arrays with one call to save a few cycles. | 171 * We alloc both arrays with one call to save a few cycles. |
172 */ | 172 */ |
173 main->xbuffer[0] = (JSAMPIMAGE) | 173 main_ptr->xbuffer[0] = (JSAMPIMAGE) |
174 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | 174 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
175 cinfo->num_components * 2 * SIZEOF(JSAMPARRAY)); | 175 cinfo->num_components * 2 * SIZEOF(JSAMPARRAY)); |
176 main->xbuffer[1] = main->xbuffer[0] + cinfo->num_components; | 176 main_ptr->xbuffer[1] = main_ptr->xbuffer[0] + cinfo->num_components; |
177 | 177 |
178 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 178 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
179 ci++, compptr++) { | 179 ci++, compptr++) { |
180 rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) / | 180 rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) / |
181 cinfo->_min_DCT_scaled_size; /* height of a row group of component */ | 181 cinfo->_min_DCT_scaled_size; /* height of a row group of component */ |
182 /* Get space for pointer lists --- M+4 row groups in each list. | 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. | 183 * We alloc both pointer lists with one call to save a few cycles. |
184 */ | 184 */ |
185 xbuf = (JSAMPARRAY) | 185 xbuf = (JSAMPARRAY) |
186 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | 186 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
187 2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW)); | 187 2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW)); |
188 xbuf += rgroup; /* want one row group at negative offsets */ | 188 xbuf += rgroup; /* want one row group at negative offsets */ |
189 main->xbuffer[0][ci] = xbuf; | 189 main_ptr->xbuffer[0][ci] = xbuf; |
190 xbuf += rgroup * (M + 4); | 190 xbuf += rgroup * (M + 4); |
191 main->xbuffer[1][ci] = xbuf; | 191 main_ptr->xbuffer[1][ci] = xbuf; |
192 } | 192 } |
193 } | 193 } |
194 | 194 |
195 | 195 |
196 LOCAL(void) | 196 LOCAL(void) |
197 make_funny_pointers (j_decompress_ptr cinfo) | 197 make_funny_pointers (j_decompress_ptr cinfo) |
198 /* Create the funny pointer lists discussed in the comments above. | 198 /* Create the funny pointer lists discussed in the comments above. |
199 * The actual workspace is already allocated (in main->buffer), | 199 * The actual workspace is already allocated (in main_ptr->buffer), |
200 * and the space for the pointer lists is allocated too. | 200 * and the space for the pointer lists is allocated too. |
201 * This routine just fills in the curiously ordered lists. | 201 * This routine just fills in the curiously ordered lists. |
202 * This will be repeated at the beginning of each pass. | 202 * This will be repeated at the beginning of each pass. |
203 */ | 203 */ |
204 { | 204 { |
205 my_main_ptr main = (my_main_ptr) cinfo->main; | 205 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; |
206 int ci, i, rgroup; | 206 int ci, i, rgroup; |
207 int M = cinfo->_min_DCT_scaled_size; | 207 int M = cinfo->_min_DCT_scaled_size; |
208 jpeg_component_info *compptr; | 208 jpeg_component_info *compptr; |
209 JSAMPARRAY buf, xbuf0, xbuf1; | 209 JSAMPARRAY buf, xbuf0, xbuf1; |
210 | 210 |
211 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 211 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
212 ci++, compptr++) { | 212 ci++, compptr++) { |
213 rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) / | 213 rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) / |
214 cinfo->_min_DCT_scaled_size; /* height of a row group of component */ | 214 cinfo->_min_DCT_scaled_size; /* height of a row group of component */ |
215 xbuf0 = main->xbuffer[0][ci]; | 215 xbuf0 = main_ptr->xbuffer[0][ci]; |
216 xbuf1 = main->xbuffer[1][ci]; | 216 xbuf1 = main_ptr->xbuffer[1][ci]; |
217 /* First copy the workspace pointers as-is */ | 217 /* First copy the workspace pointers as-is */ |
218 buf = main->buffer[ci]; | 218 buf = main_ptr->buffer[ci]; |
219 for (i = 0; i < rgroup * (M + 2); i++) { | 219 for (i = 0; i < rgroup * (M + 2); i++) { |
220 xbuf0[i] = xbuf1[i] = buf[i]; | 220 xbuf0[i] = xbuf1[i] = buf[i]; |
221 } | 221 } |
222 /* In the second list, put the last four row groups in swapped order */ | 222 /* In the second list, put the last four row groups in swapped order */ |
223 for (i = 0; i < rgroup * 2; i++) { | 223 for (i = 0; i < rgroup * 2; i++) { |
224 xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i]; | 224 xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i]; |
225 xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i]; | 225 xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i]; |
226 } | 226 } |
227 /* The wraparound pointers at top and bottom will be filled later | 227 /* The wraparound pointers at top and bottom will be filled later |
228 * (see set_wraparound_pointers, below). Initially we want the "above" | 228 * (see set_wraparound_pointers, below). Initially we want the "above" |
229 * pointers to duplicate the first actual data line. This only needs | 229 * pointers to duplicate the first actual data line. This only needs |
230 * to happen in xbuffer[0]. | 230 * to happen in xbuffer[0]. |
231 */ | 231 */ |
232 for (i = 0; i < rgroup; i++) { | 232 for (i = 0; i < rgroup; i++) { |
233 xbuf0[i - rgroup] = xbuf0[0]; | 233 xbuf0[i - rgroup] = xbuf0[0]; |
234 } | 234 } |
235 } | 235 } |
236 } | 236 } |
237 | 237 |
238 | 238 |
239 LOCAL(void) | 239 LOCAL(void) |
240 set_wraparound_pointers (j_decompress_ptr cinfo) | 240 set_wraparound_pointers (j_decompress_ptr cinfo) |
241 /* Set up the "wraparound" pointers at top and bottom of the pointer lists. | 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. | 242 * This changes the pointer list state from top-of-image to the normal state. |
243 */ | 243 */ |
244 { | 244 { |
245 my_main_ptr main = (my_main_ptr) cinfo->main; | 245 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; |
246 int ci, i, rgroup; | 246 int ci, i, rgroup; |
247 int M = cinfo->_min_DCT_scaled_size; | 247 int M = cinfo->_min_DCT_scaled_size; |
248 jpeg_component_info *compptr; | 248 jpeg_component_info *compptr; |
249 JSAMPARRAY xbuf0, xbuf1; | 249 JSAMPARRAY xbuf0, xbuf1; |
250 | 250 |
251 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 251 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
252 ci++, compptr++) { | 252 ci++, compptr++) { |
253 rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) / | 253 rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) / |
254 cinfo->_min_DCT_scaled_size; /* height of a row group of component */ | 254 cinfo->_min_DCT_scaled_size; /* height of a row group of component */ |
255 xbuf0 = main->xbuffer[0][ci]; | 255 xbuf0 = main_ptr->xbuffer[0][ci]; |
256 xbuf1 = main->xbuffer[1][ci]; | 256 xbuf1 = main_ptr->xbuffer[1][ci]; |
257 for (i = 0; i < rgroup; i++) { | 257 for (i = 0; i < rgroup; i++) { |
258 xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i]; | 258 xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i]; |
259 xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i]; | 259 xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i]; |
260 xbuf0[rgroup*(M+2) + i] = xbuf0[i]; | 260 xbuf0[rgroup*(M+2) + i] = xbuf0[i]; |
261 xbuf1[rgroup*(M+2) + i] = xbuf1[i]; | 261 xbuf1[rgroup*(M+2) + i] = xbuf1[i]; |
262 } | 262 } |
263 } | 263 } |
264 } | 264 } |
265 | 265 |
266 | 266 |
267 LOCAL(void) | 267 LOCAL(void) |
268 set_bottom_pointers (j_decompress_ptr cinfo) | 268 set_bottom_pointers (j_decompress_ptr cinfo) |
269 /* Change the pointer lists to duplicate the last sample row at the bottom | 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. | 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. | 271 * Also sets rowgroups_avail to indicate number of nondummy row groups in row. |
272 */ | 272 */ |
273 { | 273 { |
274 my_main_ptr main = (my_main_ptr) cinfo->main; | 274 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; |
275 int ci, i, rgroup, iMCUheight, rows_left; | 275 int ci, i, rgroup, iMCUheight, rows_left; |
276 jpeg_component_info *compptr; | 276 jpeg_component_info *compptr; |
277 JSAMPARRAY xbuf; | 277 JSAMPARRAY xbuf; |
278 | 278 |
279 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 279 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
280 ci++, compptr++) { | 280 ci++, compptr++) { |
281 /* Count sample rows in one iMCU row and in one row group */ | 281 /* Count sample rows in one iMCU row and in one row group */ |
282 iMCUheight = compptr->v_samp_factor * compptr->_DCT_scaled_size; | 282 iMCUheight = compptr->v_samp_factor * compptr->_DCT_scaled_size; |
283 rgroup = iMCUheight / cinfo->_min_DCT_scaled_size; | 283 rgroup = iMCUheight / cinfo->_min_DCT_scaled_size; |
284 /* Count nondummy sample rows remaining for this component */ | 284 /* Count nondummy sample rows remaining for this component */ |
285 rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight); | 285 rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight); |
286 if (rows_left == 0) rows_left = iMCUheight; | 286 if (rows_left == 0) rows_left = iMCUheight; |
287 /* Count nondummy row groups. Should get same answer for each component, | 287 /* Count nondummy row groups. Should get same answer for each component, |
288 * so we need only do it once. | 288 * so we need only do it once. |
289 */ | 289 */ |
290 if (ci == 0) { | 290 if (ci == 0) { |
291 main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1); | 291 main_ptr->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1); |
292 } | 292 } |
293 /* Duplicate the last real sample row rgroup*2 times; this pads out the | 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. | 294 * last partial rowgroup and ensures at least one full rowgroup of context. |
295 */ | 295 */ |
296 xbuf = main->xbuffer[main->whichptr][ci]; | 296 xbuf = main_ptr->xbuffer[main_ptr->whichptr][ci]; |
297 for (i = 0; i < rgroup * 2; i++) { | 297 for (i = 0; i < rgroup * 2; i++) { |
298 xbuf[rows_left + i] = xbuf[rows_left-1]; | 298 xbuf[rows_left + i] = xbuf[rows_left-1]; |
299 } | 299 } |
300 } | 300 } |
301 } | 301 } |
302 | 302 |
303 | 303 |
304 /* | 304 /* |
305 * Initialize for a processing pass. | 305 * Initialize for a processing pass. |
306 */ | 306 */ |
307 | 307 |
308 METHODDEF(void) | 308 METHODDEF(void) |
309 start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode) | 309 start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode) |
310 { | 310 { |
311 my_main_ptr main = (my_main_ptr) cinfo->main; | 311 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; |
312 | 312 |
313 switch (pass_mode) { | 313 switch (pass_mode) { |
314 case JBUF_PASS_THRU: | 314 case JBUF_PASS_THRU: |
315 if (cinfo->upsample->need_context_rows) { | 315 if (cinfo->upsample->need_context_rows) { |
316 main->pub.process_data = process_data_context_main; | 316 main_ptr->pub.process_data = process_data_context_main; |
317 make_funny_pointers(cinfo); /* Create the xbuffer[] lists */ | 317 make_funny_pointers(cinfo); /* Create the xbuffer[] lists */ |
318 main->whichptr = 0;» /* Read first iMCU row into xbuffer[0] */ | 318 main_ptr->whichptr = 0;» /* Read first iMCU row into xbuffer[0] */ |
319 main->context_state = CTX_PREPARE_FOR_IMCU; | 319 main_ptr->context_state = CTX_PREPARE_FOR_IMCU; |
320 main->iMCU_row_ctr = 0; | 320 main_ptr->iMCU_row_ctr = 0; |
321 } else { | 321 } else { |
322 /* Simple case with no context needed */ | 322 /* Simple case with no context needed */ |
323 main->pub.process_data = process_data_simple_main; | 323 main_ptr->pub.process_data = process_data_simple_main; |
324 } | 324 } |
325 main->buffer_full = FALSE;» /* Mark buffer empty */ | 325 main_ptr->buffer_full = FALSE;» /* Mark buffer empty */ |
326 main->rowgroup_ctr = 0; | 326 main_ptr->rowgroup_ctr = 0; |
327 break; | 327 break; |
328 #ifdef QUANT_2PASS_SUPPORTED | 328 #ifdef QUANT_2PASS_SUPPORTED |
329 case JBUF_CRANK_DEST: | 329 case JBUF_CRANK_DEST: |
330 /* For last pass of 2-pass quantization, just crank the postprocessor */ | 330 /* For last pass of 2-pass quantization, just crank the postprocessor */ |
331 main->pub.process_data = process_data_crank_post; | 331 main_ptr->pub.process_data = process_data_crank_post; |
332 break; | 332 break; |
333 #endif | 333 #endif |
334 default: | 334 default: |
335 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); | 335 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); |
336 break; | 336 break; |
337 } | 337 } |
338 } | 338 } |
339 | 339 |
340 | 340 |
341 /* | 341 /* |
342 * Process some data. | 342 * Process some data. |
343 * This handles the simple case where no context is required. | 343 * This handles the simple case where no context is required. |
344 */ | 344 */ |
345 | 345 |
346 METHODDEF(void) | 346 METHODDEF(void) |
347 process_data_simple_main (j_decompress_ptr cinfo, | 347 process_data_simple_main (j_decompress_ptr cinfo, |
348 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, | 348 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, |
349 JDIMENSION out_rows_avail) | 349 JDIMENSION out_rows_avail) |
350 { | 350 { |
351 my_main_ptr main = (my_main_ptr) cinfo->main; | 351 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; |
352 JDIMENSION rowgroups_avail; | 352 JDIMENSION rowgroups_avail; |
353 | 353 |
354 /* Read input data if we haven't filled the main buffer yet */ | 354 /* Read input data if we haven't filled the main buffer yet */ |
355 if (! main->buffer_full) { | 355 if (! main_ptr->buffer_full) { |
356 if (! (*cinfo->coef->decompress_data) (cinfo, main->buffer)) | 356 if (! (*cinfo->coef->decompress_data) (cinfo, main_ptr->buffer)) |
357 return; /* suspension forced, can do nothing more */ | 357 return; /* suspension forced, can do nothing more */ |
358 main->buffer_full = TRUE;» /* OK, we have an iMCU row to work with */ | 358 main_ptr->buffer_full = TRUE;» /* OK, we have an iMCU row to work with
*/ |
359 } | 359 } |
360 | 360 |
361 /* There are always min_DCT_scaled_size row groups in an iMCU row. */ | 361 /* There are always min_DCT_scaled_size row groups in an iMCU row. */ |
362 rowgroups_avail = (JDIMENSION) cinfo->_min_DCT_scaled_size; | 362 rowgroups_avail = (JDIMENSION) cinfo->_min_DCT_scaled_size; |
363 /* Note: at the bottom of the image, we may pass extra garbage row groups | 363 /* Note: at the bottom of the image, we may pass extra garbage row groups |
364 * to the postprocessor. The postprocessor has to check for bottom | 364 * to the postprocessor. The postprocessor has to check for bottom |
365 * of image anyway (at row resolution), so no point in us doing it too. | 365 * of image anyway (at row resolution), so no point in us doing it too. |
366 */ | 366 */ |
367 | 367 |
368 /* Feed the postprocessor */ | 368 /* Feed the postprocessor */ |
369 (*cinfo->post->post_process_data) (cinfo, main->buffer, | 369 (*cinfo->post->post_process_data) (cinfo, main_ptr->buffer, |
370 » » » » &main->rowgroup_ctr, rowgroups_avail, | 370 » » » » &main_ptr->rowgroup_ctr, rowgroups_avail, |
371 output_buf, out_row_ctr, out_rows_avail); | 371 output_buf, out_row_ctr, out_rows_avail); |
372 | 372 |
373 /* Has postprocessor consumed all the data yet? If so, mark buffer empty */ | 373 /* Has postprocessor consumed all the data yet? If so, mark buffer empty */ |
374 if (main->rowgroup_ctr >= rowgroups_avail) { | 374 if (main_ptr->rowgroup_ctr >= rowgroups_avail) { |
375 main->buffer_full = FALSE; | 375 main_ptr->buffer_full = FALSE; |
376 main->rowgroup_ctr = 0; | 376 main_ptr->rowgroup_ctr = 0; |
377 } | 377 } |
378 } | 378 } |
379 | 379 |
380 | 380 |
381 /* | 381 /* |
382 * Process some data. | 382 * Process some data. |
383 * This handles the case where context rows must be provided. | 383 * This handles the case where context rows must be provided. |
384 */ | 384 */ |
385 | 385 |
386 METHODDEF(void) | 386 METHODDEF(void) |
387 process_data_context_main (j_decompress_ptr cinfo, | 387 process_data_context_main (j_decompress_ptr cinfo, |
388 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, | 388 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, |
389 JDIMENSION out_rows_avail) | 389 JDIMENSION out_rows_avail) |
390 { | 390 { |
391 my_main_ptr main = (my_main_ptr) cinfo->main; | 391 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; |
392 | 392 |
393 /* Read input data if we haven't filled the main buffer yet */ | 393 /* Read input data if we haven't filled the main buffer yet */ |
394 if (! main->buffer_full) { | 394 if (! main_ptr->buffer_full) { |
395 if (! (*cinfo->coef->decompress_data) (cinfo, | 395 if (! (*cinfo->coef->decompress_data) (cinfo, |
396 » » » » » main->xbuffer[main->whichptr])) | 396 » » » » » main_ptr->xbuffer[main_ptr->whichptr]
)) |
397 return; /* suspension forced, can do nothing more */ | 397 return; /* suspension forced, can do nothing more */ |
398 main->buffer_full = TRUE;» /* OK, we have an iMCU row to work with */ | 398 main_ptr->buffer_full = TRUE;» /* OK, we have an iMCU row to work with
*/ |
399 main->iMCU_row_ctr++;» /* count rows received */ | 399 main_ptr->iMCU_row_ctr++;» /* count rows received */ |
400 } | 400 } |
401 | 401 |
402 /* Postprocessor typically will not swallow all the input data it is handed | 402 /* Postprocessor typically will not swallow all the input data it is handed |
403 * in one call (due to filling the output buffer first). Must be prepared | 403 * in one call (due to filling the output buffer first). Must be prepared |
404 * to exit and restart. This switch lets us keep track of how far we got. | 404 * to exit and restart. This switch lets us keep track of how far we got. |
405 * Note that each case falls through to the next on successful completion. | 405 * Note that each case falls through to the next on successful completion. |
406 */ | 406 */ |
407 switch (main->context_state) { | 407 switch (main_ptr->context_state) { |
408 case CTX_POSTPONED_ROW: | 408 case CTX_POSTPONED_ROW: |
409 /* Call postprocessor using previously set pointers for postponed row */ | 409 /* Call postprocessor using previously set pointers for postponed row */ |
410 (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr], | 410 (*cinfo->post->post_process_data) (cinfo, main_ptr->xbuffer[main_ptr->whichp
tr], |
411 » » » &main->rowgroup_ctr, main->rowgroups_avail, | 411 » » » &main_ptr->rowgroup_ctr, main_ptr->rowgroups_avail, |
412 output_buf, out_row_ctr, out_rows_avail); | 412 output_buf, out_row_ctr, out_rows_avail); |
413 if (main->rowgroup_ctr < main->rowgroups_avail) | 413 if (main_ptr->rowgroup_ctr < main_ptr->rowgroups_avail) |
414 return; /* Need to suspend */ | 414 return; /* Need to suspend */ |
415 main->context_state = CTX_PREPARE_FOR_IMCU; | 415 main_ptr->context_state = CTX_PREPARE_FOR_IMCU; |
416 if (*out_row_ctr >= out_rows_avail) | 416 if (*out_row_ctr >= out_rows_avail) |
417 return; /* Postprocessor exactly filled output buf */ | 417 return; /* Postprocessor exactly filled output buf */ |
418 /*FALLTHROUGH*/ | 418 /*FALLTHROUGH*/ |
419 case CTX_PREPARE_FOR_IMCU: | 419 case CTX_PREPARE_FOR_IMCU: |
420 /* Prepare to process first M-1 row groups of this iMCU row */ | 420 /* Prepare to process first M-1 row groups of this iMCU row */ |
421 main->rowgroup_ctr = 0; | 421 main_ptr->rowgroup_ctr = 0; |
422 main->rowgroups_avail = (JDIMENSION) (cinfo->_min_DCT_scaled_size - 1); | 422 main_ptr->rowgroups_avail = (JDIMENSION) (cinfo->_min_DCT_scaled_size - 1); |
423 /* Check for bottom of image: if so, tweak pointers to "duplicate" | 423 /* Check for bottom of image: if so, tweak pointers to "duplicate" |
424 * the last sample row, and adjust rowgroups_avail to ignore padding rows. | 424 * the last sample row, and adjust rowgroups_avail to ignore padding rows. |
425 */ | 425 */ |
426 if (main->iMCU_row_ctr == cinfo->total_iMCU_rows) | 426 if (main_ptr->iMCU_row_ctr == cinfo->total_iMCU_rows) |
427 set_bottom_pointers(cinfo); | 427 set_bottom_pointers(cinfo); |
428 main->context_state = CTX_PROCESS_IMCU; | 428 main_ptr->context_state = CTX_PROCESS_IMCU; |
429 /*FALLTHROUGH*/ | 429 /*FALLTHROUGH*/ |
430 case CTX_PROCESS_IMCU: | 430 case CTX_PROCESS_IMCU: |
431 /* Call postprocessor using previously set pointers */ | 431 /* Call postprocessor using previously set pointers */ |
432 (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr], | 432 (*cinfo->post->post_process_data) (cinfo, main_ptr->xbuffer[main_ptr->whichp
tr], |
433 » » » &main->rowgroup_ctr, main->rowgroups_avail, | 433 » » » &main_ptr->rowgroup_ctr, main_ptr->rowgroups_avail, |
434 output_buf, out_row_ctr, out_rows_avail); | 434 output_buf, out_row_ctr, out_rows_avail); |
435 if (main->rowgroup_ctr < main->rowgroups_avail) | 435 if (main_ptr->rowgroup_ctr < main_ptr->rowgroups_avail) |
436 return; /* Need to suspend */ | 436 return; /* Need to suspend */ |
437 /* After the first iMCU, change wraparound pointers to normal state */ | 437 /* After the first iMCU, change wraparound pointers to normal state */ |
438 if (main->iMCU_row_ctr == 1) | 438 if (main_ptr->iMCU_row_ctr == 1) |
439 set_wraparound_pointers(cinfo); | 439 set_wraparound_pointers(cinfo); |
440 /* Prepare to load new iMCU row using other xbuffer list */ | 440 /* Prepare to load new iMCU row using other xbuffer list */ |
441 main->whichptr ^= 1;» /* 0=>1 or 1=>0 */ | 441 main_ptr->whichptr ^= 1;» /* 0=>1 or 1=>0 */ |
442 main->buffer_full = FALSE; | 442 main_ptr->buffer_full = FALSE; |
443 /* Still need to process last row group of this iMCU row, */ | 443 /* Still need to process last row group of this iMCU row, */ |
444 /* which is saved at index M+1 of the other xbuffer */ | 444 /* which is saved at index M+1 of the other xbuffer */ |
445 main->rowgroup_ctr = (JDIMENSION) (cinfo->_min_DCT_scaled_size + 1); | 445 main_ptr->rowgroup_ctr = (JDIMENSION) (cinfo->_min_DCT_scaled_size + 1); |
446 main->rowgroups_avail = (JDIMENSION) (cinfo->_min_DCT_scaled_size + 2); | 446 main_ptr->rowgroups_avail = (JDIMENSION) (cinfo->_min_DCT_scaled_size + 2); |
447 main->context_state = CTX_POSTPONED_ROW; | 447 main_ptr->context_state = CTX_POSTPONED_ROW; |
448 } | 448 } |
449 } | 449 } |
450 | 450 |
451 | 451 |
452 /* | 452 /* |
453 * Process some data. | 453 * Process some data. |
454 * Final pass of two-pass quantization: just call the postprocessor. | 454 * Final pass of two-pass quantization: just call the postprocessor. |
455 * Source data will be the postprocessor controller's internal buffer. | 455 * Source data will be the postprocessor controller's internal buffer. |
456 */ | 456 */ |
457 | 457 |
(...skipping 12 matching lines...) Expand all Loading... |
470 #endif /* QUANT_2PASS_SUPPORTED */ | 470 #endif /* QUANT_2PASS_SUPPORTED */ |
471 | 471 |
472 | 472 |
473 /* | 473 /* |
474 * Initialize main buffer controller. | 474 * Initialize main buffer controller. |
475 */ | 475 */ |
476 | 476 |
477 GLOBAL(void) | 477 GLOBAL(void) |
478 jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer) | 478 jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer) |
479 { | 479 { |
480 my_main_ptr main; | 480 my_main_ptr main_ptr; |
481 int ci, rgroup, ngroups; | 481 int ci, rgroup, ngroups; |
482 jpeg_component_info *compptr; | 482 jpeg_component_info *compptr; |
483 | 483 |
484 main = (my_main_ptr) | 484 main_ptr = (my_main_ptr) |
485 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | 485 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
486 SIZEOF(my_main_controller)); | 486 SIZEOF(my_main_controller)); |
487 cinfo->main = (struct jpeg_d_main_controller *) main; | 487 cinfo->main = (struct jpeg_d_main_controller *) main_ptr; |
488 main->pub.start_pass = start_pass_main; | 488 main_ptr->pub.start_pass = start_pass_main; |
489 | 489 |
490 if (need_full_buffer) /* shouldn't happen */ | 490 if (need_full_buffer) /* shouldn't happen */ |
491 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); | 491 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); |
492 | 492 |
493 /* Allocate the workspace. | 493 /* Allocate the workspace. |
494 * ngroups is the number of row groups we need. | 494 * ngroups is the number of row groups we need. |
495 */ | 495 */ |
496 if (cinfo->upsample->need_context_rows) { | 496 if (cinfo->upsample->need_context_rows) { |
497 if (cinfo->_min_DCT_scaled_size < 2) /* unsupported, see comments above */ | 497 if (cinfo->_min_DCT_scaled_size < 2) /* unsupported, see comments above */ |
498 ERREXIT(cinfo, JERR_NOTIMPL); | 498 ERREXIT(cinfo, JERR_NOTIMPL); |
499 alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */ | 499 alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */ |
500 ngroups = cinfo->_min_DCT_scaled_size + 2; | 500 ngroups = cinfo->_min_DCT_scaled_size + 2; |
501 } else { | 501 } else { |
502 ngroups = cinfo->_min_DCT_scaled_size; | 502 ngroups = cinfo->_min_DCT_scaled_size; |
503 } | 503 } |
504 | 504 |
505 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 505 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
506 ci++, compptr++) { | 506 ci++, compptr++) { |
507 rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) / | 507 rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) / |
508 cinfo->_min_DCT_scaled_size; /* height of a row group of component */ | 508 cinfo->_min_DCT_scaled_size; /* height of a row group of component */ |
509 main->buffer[ci] = (*cinfo->mem->alloc_sarray) | 509 main_ptr->buffer[ci] = (*cinfo->mem->alloc_sarray) |
510 ((j_common_ptr) cinfo, JPOOL_IMAGE, | 510 ((j_common_ptr) cinfo, JPOOL_IMAGE, |
511 compptr->width_in_blocks * compptr->_DCT_scaled_size, | 511 compptr->width_in_blocks * compptr->_DCT_scaled_size, |
512 (JDIMENSION) (rgroup * ngroups)); | 512 (JDIMENSION) (rgroup * ngroups)); |
513 } | 513 } |
514 } | 514 } |
OLD | NEW |