The Tor Browser / file comparison
comparison: media/libjpeg/jdmaster.c
media/libjpeg/jdmaster.c
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:1bc6d505a712 |
|---|---|
| 1 /* | |
| 2 * jdmaster.c | |
| 3 * | |
| 4 * This file was part of the Independent JPEG Group's software: | |
| 5 * Copyright (C) 1991-1997, Thomas G. Lane. | |
| 6 * Modified 2002-2009 by Guido Vollbeding. | |
| 7 * libjpeg-turbo Modifications: | |
| 8 * Copyright (C) 2009-2011, D. R. Commander. | |
| 9 * For conditions of distribution and use, see the accompanying README file. | |
| 10 * | |
| 11 * This file contains master control logic for the JPEG decompressor. | |
| 12 * These routines are concerned with selecting the modules to be executed | |
| 13 * and with determining the number of passes and the work to be done in each | |
| 14 * pass. | |
| 15 */ | |
| 16 | |
| 17 #define JPEG_INTERNALS | |
| 18 #include "jinclude.h" | |
| 19 #include "jpeglib.h" | |
| 20 #include "jpegcomp.h" | |
| 21 | |
| 22 | |
| 23 /* Private state */ | |
| 24 | |
| 25 typedef struct { | |
| 26 struct jpeg_decomp_master pub; /* public fields */ | |
| 27 | |
| 28 int pass_number; /* # of passes completed */ | |
| 29 | |
| 30 boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */ | |
| 31 | |
| 32 /* Saved references to initialized quantizer modules, | |
| 33 * in case we need to switch modes. | |
| 34 */ | |
| 35 struct jpeg_color_quantizer * quantizer_1pass; | |
| 36 struct jpeg_color_quantizer * quantizer_2pass; | |
| 37 } my_decomp_master; | |
| 38 | |
| 39 typedef my_decomp_master * my_master_ptr; | |
| 40 | |
| 41 | |
| 42 /* | |
| 43 * Determine whether merged upsample/color conversion should be used. | |
| 44 * CRUCIAL: this must match the actual capabilities of jdmerge.c! | |
| 45 */ | |
| 46 | |
| 47 LOCAL(boolean) | |
| 48 use_merged_upsample (j_decompress_ptr cinfo) | |
| 49 { | |
| 50 #ifdef UPSAMPLE_MERGING_SUPPORTED | |
| 51 /* Merging is the equivalent of plain box-filter upsampling */ | |
| 52 if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling) | |
| 53 return FALSE; | |
| 54 /* jdmerge.c only supports YCC=>RGB color conversion */ | |
| 55 if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 || | |
| 56 (cinfo->out_color_space != JCS_RGB && | |
| 57 cinfo->out_color_space != JCS_EXT_RGB && | |
| 58 cinfo->out_color_space != JCS_EXT_RGBX && | |
| 59 cinfo->out_color_space != JCS_EXT_BGR && | |
| 60 cinfo->out_color_space != JCS_EXT_BGRX && | |
| 61 cinfo->out_color_space != JCS_EXT_XBGR && | |
| 62 cinfo->out_color_space != JCS_EXT_XRGB && | |
| 63 cinfo->out_color_space != JCS_EXT_RGBA && | |
| 64 cinfo->out_color_space != JCS_EXT_BGRA && | |
| 65 cinfo->out_color_space != JCS_EXT_ABGR && | |
| 66 cinfo->out_color_space != JCS_EXT_ARGB) || | |
| 67 cinfo->out_color_components != rgb_pixelsize[cinfo->out_color_space]) | |
| 68 return FALSE; | |
| 69 /* and it only handles 2h1v or 2h2v sampling ratios */ | |
| 70 if (cinfo->comp_info[0].h_samp_factor != 2 || | |
| 71 cinfo->comp_info[1].h_samp_factor != 1 || | |
| 72 cinfo->comp_info[2].h_samp_factor != 1 || | |
| 73 cinfo->comp_info[0].v_samp_factor > 2 || | |
| 74 cinfo->comp_info[1].v_samp_factor != 1 || | |
| 75 cinfo->comp_info[2].v_samp_factor != 1) | |
| 76 return FALSE; | |
| 77 /* furthermore, it doesn't work if we've scaled the IDCTs differently */ | |
| 78 if (cinfo->comp_info[0]._DCT_scaled_size != cinfo->_min_DCT_scaled_size || | |
| 79 cinfo->comp_info[1]._DCT_scaled_size != cinfo->_min_DCT_scaled_size || | |
| 80 cinfo->comp_info[2]._DCT_scaled_size != cinfo->_min_DCT_scaled_size) | |
| 81 return FALSE; | |
| 82 /* ??? also need to test for upsample-time rescaling, when & if supported */ | |
| 83 return TRUE; /* by golly, it'll work... */ | |
| 84 #else | |
| 85 return FALSE; | |
| 86 #endif | |
| 87 } | |
| 88 | |
| 89 | |
| 90 /* | |
| 91 * Compute output image dimensions and related values. | |
| 92 * NOTE: this is exported for possible use by application. | |
| 93 * Hence it mustn't do anything that can't be done twice. | |
| 94 */ | |
| 95 | |
| 96 #if JPEG_LIB_VERSION >= 80 | |
| 97 GLOBAL(void) | |
| 98 #else | |
| 99 LOCAL(void) | |
| 100 #endif | |
| 101 jpeg_core_output_dimensions (j_decompress_ptr cinfo) | |
| 102 /* Do computations that are needed before master selection phase. | |
| 103 * This function is used for transcoding and full decompression. | |
| 104 */ | |
| 105 { | |
| 106 #ifdef IDCT_SCALING_SUPPORTED | |
| 107 int ci; | |
| 108 jpeg_component_info *compptr; | |
| 109 | |
| 110 /* Compute actual output image dimensions and DCT scaling choices. */ | |
| 111 if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom) { | |
| 112 /* Provide 1/block_size scaling */ | |
| 113 cinfo->output_width = (JDIMENSION) | |
| 114 jdiv_round_up((long) cinfo->image_width, (long) DCTSIZE); | |
| 115 cinfo->output_height = (JDIMENSION) | |
| 116 jdiv_round_up((long) cinfo->image_height, (long) DCTSIZE); | |
| 117 cinfo->_min_DCT_h_scaled_size = 1; | |
| 118 cinfo->_min_DCT_v_scaled_size = 1; | |
| 119 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 2) { | |
| 120 /* Provide 2/block_size scaling */ | |
| 121 cinfo->output_width = (JDIMENSION) | |
| 122 jdiv_round_up((long) cinfo->image_width * 2L, (long) DCTSIZE); | |
| 123 cinfo->output_height = (JDIMENSION) | |
| 124 jdiv_round_up((long) cinfo->image_height * 2L, (long) DCTSIZE); | |
| 125 cinfo->_min_DCT_h_scaled_size = 2; | |
| 126 cinfo->_min_DCT_v_scaled_size = 2; | |
| 127 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 3) { | |
| 128 /* Provide 3/block_size scaling */ | |
| 129 cinfo->output_width = (JDIMENSION) | |
| 130 jdiv_round_up((long) cinfo->image_width * 3L, (long) DCTSIZE); | |
| 131 cinfo->output_height = (JDIMENSION) | |
| 132 jdiv_round_up((long) cinfo->image_height * 3L, (long) DCTSIZE); | |
| 133 cinfo->_min_DCT_h_scaled_size = 3; | |
| 134 cinfo->_min_DCT_v_scaled_size = 3; | |
| 135 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 4) { | |
| 136 /* Provide 4/block_size scaling */ | |
| 137 cinfo->output_width = (JDIMENSION) | |
| 138 jdiv_round_up((long) cinfo->image_width * 4L, (long) DCTSIZE); | |
| 139 cinfo->output_height = (JDIMENSION) | |
| 140 jdiv_round_up((long) cinfo->image_height * 4L, (long) DCTSIZE); | |
| 141 cinfo->_min_DCT_h_scaled_size = 4; | |
| 142 cinfo->_min_DCT_v_scaled_size = 4; | |
| 143 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 5) { | |
| 144 /* Provide 5/block_size scaling */ | |
| 145 cinfo->output_width = (JDIMENSION) | |
| 146 jdiv_round_up((long) cinfo->image_width * 5L, (long) DCTSIZE); | |
| 147 cinfo->output_height = (JDIMENSION) | |
| 148 jdiv_round_up((long) cinfo->image_height * 5L, (long) DCTSIZE); | |
| 149 cinfo->_min_DCT_h_scaled_size = 5; | |
| 150 cinfo->_min_DCT_v_scaled_size = 5; | |
| 151 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 6) { | |
| 152 /* Provide 6/block_size scaling */ | |
| 153 cinfo->output_width = (JDIMENSION) | |
| 154 jdiv_round_up((long) cinfo->image_width * 6L, (long) DCTSIZE); | |
| 155 cinfo->output_height = (JDIMENSION) | |
| 156 jdiv_round_up((long) cinfo->image_height * 6L, (long) DCTSIZE); | |
| 157 cinfo->_min_DCT_h_scaled_size = 6; | |
| 158 cinfo->_min_DCT_v_scaled_size = 6; | |
| 159 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 7) { | |
| 160 /* Provide 7/block_size scaling */ | |
| 161 cinfo->output_width = (JDIMENSION) | |
| 162 jdiv_round_up((long) cinfo->image_width * 7L, (long) DCTSIZE); | |
| 163 cinfo->output_height = (JDIMENSION) | |
| 164 jdiv_round_up((long) cinfo->image_height * 7L, (long) DCTSIZE); | |
| 165 cinfo->_min_DCT_h_scaled_size = 7; | |
| 166 cinfo->_min_DCT_v_scaled_size = 7; | |
| 167 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 8) { | |
| 168 /* Provide 8/block_size scaling */ | |
| 169 cinfo->output_width = (JDIMENSION) | |
| 170 jdiv_round_up((long) cinfo->image_width * 8L, (long) DCTSIZE); | |
| 171 cinfo->output_height = (JDIMENSION) | |
| 172 jdiv_round_up((long) cinfo->image_height * 8L, (long) DCTSIZE); | |
| 173 cinfo->_min_DCT_h_scaled_size = 8; | |
| 174 cinfo->_min_DCT_v_scaled_size = 8; | |
| 175 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 9) { | |
| 176 /* Provide 9/block_size scaling */ | |
| 177 cinfo->output_width = (JDIMENSION) | |
| 178 jdiv_round_up((long) cinfo->image_width * 9L, (long) DCTSIZE); | |
| 179 cinfo->output_height = (JDIMENSION) | |
| 180 jdiv_round_up((long) cinfo->image_height * 9L, (long) DCTSIZE); | |
| 181 cinfo->_min_DCT_h_scaled_size = 9; | |
| 182 cinfo->_min_DCT_v_scaled_size = 9; | |
| 183 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 10) { | |
| 184 /* Provide 10/block_size scaling */ | |
| 185 cinfo->output_width = (JDIMENSION) | |
| 186 jdiv_round_up((long) cinfo->image_width * 10L, (long) DCTSIZE); | |
| 187 cinfo->output_height = (JDIMENSION) | |
| 188 jdiv_round_up((long) cinfo->image_height * 10L, (long) DCTSIZE); | |
| 189 cinfo->_min_DCT_h_scaled_size = 10; | |
| 190 cinfo->_min_DCT_v_scaled_size = 10; | |
| 191 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 11) { | |
| 192 /* Provide 11/block_size scaling */ | |
| 193 cinfo->output_width = (JDIMENSION) | |
| 194 jdiv_round_up((long) cinfo->image_width * 11L, (long) DCTSIZE); | |
| 195 cinfo->output_height = (JDIMENSION) | |
| 196 jdiv_round_up((long) cinfo->image_height * 11L, (long) DCTSIZE); | |
| 197 cinfo->_min_DCT_h_scaled_size = 11; | |
| 198 cinfo->_min_DCT_v_scaled_size = 11; | |
| 199 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 12) { | |
| 200 /* Provide 12/block_size scaling */ | |
| 201 cinfo->output_width = (JDIMENSION) | |
| 202 jdiv_round_up((long) cinfo->image_width * 12L, (long) DCTSIZE); | |
| 203 cinfo->output_height = (JDIMENSION) | |
| 204 jdiv_round_up((long) cinfo->image_height * 12L, (long) DCTSIZE); | |
| 205 cinfo->_min_DCT_h_scaled_size = 12; | |
| 206 cinfo->_min_DCT_v_scaled_size = 12; | |
| 207 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 13) { | |
| 208 /* Provide 13/block_size scaling */ | |
| 209 cinfo->output_width = (JDIMENSION) | |
| 210 jdiv_round_up((long) cinfo->image_width * 13L, (long) DCTSIZE); | |
| 211 cinfo->output_height = (JDIMENSION) | |
| 212 jdiv_round_up((long) cinfo->image_height * 13L, (long) DCTSIZE); | |
| 213 cinfo->_min_DCT_h_scaled_size = 13; | |
| 214 cinfo->_min_DCT_v_scaled_size = 13; | |
| 215 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 14) { | |
| 216 /* Provide 14/block_size scaling */ | |
| 217 cinfo->output_width = (JDIMENSION) | |
| 218 jdiv_round_up((long) cinfo->image_width * 14L, (long) DCTSIZE); | |
| 219 cinfo->output_height = (JDIMENSION) | |
| 220 jdiv_round_up((long) cinfo->image_height * 14L, (long) DCTSIZE); | |
| 221 cinfo->_min_DCT_h_scaled_size = 14; | |
| 222 cinfo->_min_DCT_v_scaled_size = 14; | |
| 223 } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 15) { | |
| 224 /* Provide 15/block_size scaling */ | |
| 225 cinfo->output_width = (JDIMENSION) | |
| 226 jdiv_round_up((long) cinfo->image_width * 15L, (long) DCTSIZE); | |
| 227 cinfo->output_height = (JDIMENSION) | |
| 228 jdiv_round_up((long) cinfo->image_height * 15L, (long) DCTSIZE); | |
| 229 cinfo->_min_DCT_h_scaled_size = 15; | |
| 230 cinfo->_min_DCT_v_scaled_size = 15; | |
| 231 } else { | |
| 232 /* Provide 16/block_size scaling */ | |
| 233 cinfo->output_width = (JDIMENSION) | |
| 234 jdiv_round_up((long) cinfo->image_width * 16L, (long) DCTSIZE); | |
| 235 cinfo->output_height = (JDIMENSION) | |
| 236 jdiv_round_up((long) cinfo->image_height * 16L, (long) DCTSIZE); | |
| 237 cinfo->_min_DCT_h_scaled_size = 16; | |
| 238 cinfo->_min_DCT_v_scaled_size = 16; | |
| 239 } | |
| 240 | |
| 241 /* Recompute dimensions of components */ | |
| 242 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | |
| 243 ci++, compptr++) { | |
| 244 compptr->_DCT_h_scaled_size = cinfo->_min_DCT_h_scaled_size; | |
| 245 compptr->_DCT_v_scaled_size = cinfo->_min_DCT_v_scaled_size; | |
| 246 } | |
| 247 | |
| 248 #else /* !IDCT_SCALING_SUPPORTED */ | |
| 249 | |
| 250 /* Hardwire it to "no scaling" */ | |
| 251 cinfo->output_width = cinfo->image_width; | |
| 252 cinfo->output_height = cinfo->image_height; | |
| 253 /* jdinput.c has already initialized DCT_scaled_size, | |
| 254 * and has computed unscaled downsampled_width and downsampled_height. | |
| 255 */ | |
| 256 | |
| 257 #endif /* IDCT_SCALING_SUPPORTED */ | |
| 258 } | |
| 259 | |
| 260 | |
| 261 /* | |
| 262 * Compute output image dimensions and related values. | |
| 263 * NOTE: this is exported for possible use by application. | |
| 264 * Hence it mustn't do anything that can't be done twice. | |
| 265 * Also note that it may be called before the master module is initialized! | |
| 266 */ | |
| 267 | |
| 268 GLOBAL(void) | |
| 269 jpeg_calc_output_dimensions (j_decompress_ptr cinfo) | |
| 270 /* Do computations that are needed before master selection phase */ | |
| 271 { | |
| 272 #ifdef IDCT_SCALING_SUPPORTED | |
| 273 int ci; | |
| 274 jpeg_component_info *compptr; | |
| 275 #endif | |
| 276 | |
| 277 /* Prevent application from calling me at wrong times */ | |
| 278 if (cinfo->global_state != DSTATE_READY) | |
| 279 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); | |
| 280 | |
| 281 /* Compute core output image dimensions and DCT scaling choices. */ | |
| 282 jpeg_core_output_dimensions(cinfo); | |
| 283 | |
| 284 #ifdef IDCT_SCALING_SUPPORTED | |
| 285 | |
| 286 /* In selecting the actual DCT scaling for each component, we try to | |
| 287 * scale up the chroma components via IDCT scaling rather than upsampling. | |
| 288 * This saves time if the upsampler gets to use 1:1 scaling. | |
| 289 * Note this code adapts subsampling ratios which are powers of 2. | |
| 290 */ | |
| 291 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | |
| 292 ci++, compptr++) { | |
| 293 int ssize = cinfo->_min_DCT_scaled_size; | |
| 294 while (ssize < DCTSIZE && | |
| 295 ((cinfo->max_h_samp_factor * cinfo->_min_DCT_scaled_size) % | |
| 296 (compptr->h_samp_factor * ssize * 2) == 0) && | |
| 297 ((cinfo->max_v_samp_factor * cinfo->_min_DCT_scaled_size) % | |
| 298 (compptr->v_samp_factor * ssize * 2) == 0)) { | |
| 299 ssize = ssize * 2; | |
| 300 } | |
| 301 #if JPEG_LIB_VERSION >= 70 | |
| 302 compptr->DCT_h_scaled_size = compptr->DCT_v_scaled_size = ssize; | |
| 303 #else | |
| 304 compptr->DCT_scaled_size = ssize; | |
| 305 #endif | |
| 306 } | |
| 307 | |
| 308 /* Recompute downsampled dimensions of components; | |
| 309 * application needs to know these if using raw downsampled data. | |
| 310 */ | |
| 311 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | |
| 312 ci++, compptr++) { | |
| 313 /* Size in samples, after IDCT scaling */ | |
| 314 compptr->downsampled_width = (JDIMENSION) | |
| 315 jdiv_round_up((long) cinfo->image_width * | |
| 316 (long) (compptr->h_samp_factor * compptr->_DCT_scaled_size), | |
| 317 (long) (cinfo->max_h_samp_factor * DCTSIZE)); | |
| 318 compptr->downsampled_height = (JDIMENSION) | |
| 319 jdiv_round_up((long) cinfo->image_height * | |
| 320 (long) (compptr->v_samp_factor * compptr->_DCT_scaled_size), | |
| 321 (long) (cinfo->max_v_samp_factor * DCTSIZE)); | |
| 322 } | |
| 323 | |
| 324 #else /* !IDCT_SCALING_SUPPORTED */ | |
| 325 | |
| 326 /* Hardwire it to "no scaling" */ | |
| 327 cinfo->output_width = cinfo->image_width; | |
| 328 cinfo->output_height = cinfo->image_height; | |
| 329 /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE, | |
| 330 * and has computed unscaled downsampled_width and downsampled_height. | |
| 331 */ | |
| 332 | |
| 333 #endif /* IDCT_SCALING_SUPPORTED */ | |
| 334 | |
| 335 /* Report number of components in selected colorspace. */ | |
| 336 /* Probably this should be in the color conversion module... */ | |
| 337 switch (cinfo->out_color_space) { | |
| 338 case JCS_GRAYSCALE: | |
| 339 cinfo->out_color_components = 1; | |
| 340 break; | |
| 341 case JCS_RGB: | |
| 342 case JCS_EXT_RGB: | |
| 343 case JCS_EXT_RGBX: | |
| 344 case JCS_EXT_BGR: | |
| 345 case JCS_EXT_BGRX: | |
| 346 case JCS_EXT_XBGR: | |
| 347 case JCS_EXT_XRGB: | |
| 348 case JCS_EXT_RGBA: | |
| 349 case JCS_EXT_BGRA: | |
| 350 case JCS_EXT_ABGR: | |
| 351 case JCS_EXT_ARGB: | |
| 352 cinfo->out_color_components = rgb_pixelsize[cinfo->out_color_space]; | |
| 353 break; | |
| 354 case JCS_YCbCr: | |
| 355 cinfo->out_color_components = 3; | |
| 356 break; | |
| 357 case JCS_CMYK: | |
| 358 case JCS_YCCK: | |
| 359 cinfo->out_color_components = 4; | |
| 360 break; | |
| 361 default: /* else must be same colorspace as in file */ | |
| 362 cinfo->out_color_components = cinfo->num_components; | |
| 363 break; | |
| 364 } | |
| 365 cinfo->output_components = (cinfo->quantize_colors ? 1 : | |
| 366 cinfo->out_color_components); | |
| 367 | |
| 368 /* See if upsampler will want to emit more than one row at a time */ | |
| 369 if (use_merged_upsample(cinfo)) | |
| 370 cinfo->rec_outbuf_height = cinfo->max_v_samp_factor; | |
| 371 else | |
| 372 cinfo->rec_outbuf_height = 1; | |
| 373 } | |
| 374 | |
| 375 | |
| 376 /* | |
| 377 * Several decompression processes need to range-limit values to the range | |
| 378 * 0..MAXJSAMPLE; the input value may fall somewhat outside this range | |
| 379 * due to noise introduced by quantization, roundoff error, etc. These | |
| 380 * processes are inner loops and need to be as fast as possible. On most | |
| 381 * machines, particularly CPUs with pipelines or instruction prefetch, | |
| 382 * a (subscript-check-less) C table lookup | |
| 383 * x = sample_range_limit[x]; | |
| 384 * is faster than explicit tests | |
| 385 * if (x < 0) x = 0; | |
| 386 * else if (x > MAXJSAMPLE) x = MAXJSAMPLE; | |
| 387 * These processes all use a common table prepared by the routine below. | |
| 388 * | |
| 389 * For most steps we can mathematically guarantee that the initial value | |
| 390 * of x is within MAXJSAMPLE+1 of the legal range, so a table running from | |
| 391 * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient. But for the initial | |
| 392 * limiting step (just after the IDCT), a wildly out-of-range value is | |
| 393 * possible if the input data is corrupt. To avoid any chance of indexing | |
| 394 * off the end of memory and getting a bad-pointer trap, we perform the | |
| 395 * post-IDCT limiting thus: | |
| 396 * x = range_limit[x & MASK]; | |
| 397 * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit | |
| 398 * samples. Under normal circumstances this is more than enough range and | |
| 399 * a correct output will be generated; with bogus input data the mask will | |
| 400 * cause wraparound, and we will safely generate a bogus-but-in-range output. | |
| 401 * For the post-IDCT step, we want to convert the data from signed to unsigned | |
| 402 * representation by adding CENTERJSAMPLE at the same time that we limit it. | |
| 403 * So the post-IDCT limiting table ends up looking like this: | |
| 404 * CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE, | |
| 405 * MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times), | |
| 406 * 0 (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times), | |
| 407 * 0,1,...,CENTERJSAMPLE-1 | |
| 408 * Negative inputs select values from the upper half of the table after | |
| 409 * masking. | |
| 410 * | |
| 411 * We can save some space by overlapping the start of the post-IDCT table | |
| 412 * with the simpler range limiting table. The post-IDCT table begins at | |
| 413 * sample_range_limit + CENTERJSAMPLE. | |
| 414 * | |
| 415 * Note that the table is allocated in near data space on PCs; it's small | |
| 416 * enough and used often enough to justify this. | |
| 417 */ | |
| 418 | |
| 419 LOCAL(void) | |
| 420 prepare_range_limit_table (j_decompress_ptr cinfo) | |
| 421 /* Allocate and fill in the sample_range_limit table */ | |
| 422 { | |
| 423 JSAMPLE * table; | |
| 424 int i; | |
| 425 | |
| 426 table = (JSAMPLE *) | |
| 427 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | |
| 428 (5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE)); | |
| 429 table += (MAXJSAMPLE+1); /* allow negative subscripts of simple table */ | |
| 430 cinfo->sample_range_limit = table; | |
| 431 /* First segment of "simple" table: limit[x] = 0 for x < 0 */ | |
| 432 MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE)); | |
| 433 /* Main part of "simple" table: limit[x] = x */ | |
| 434 for (i = 0; i <= MAXJSAMPLE; i++) | |
| 435 table[i] = (JSAMPLE) i; | |
| 436 table += CENTERJSAMPLE; /* Point to where post-IDCT table starts */ | |
| 437 /* End of simple table, rest of first half of post-IDCT table */ | |
| 438 for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++) | |
| 439 table[i] = MAXJSAMPLE; | |
| 440 /* Second half of post-IDCT table */ | |
| 441 MEMZERO(table + (2 * (MAXJSAMPLE+1)), | |
| 442 (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE)); | |
| 443 MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE), | |
| 444 cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE)); | |
| 445 } | |
| 446 | |
| 447 | |
| 448 /* | |
| 449 * Master selection of decompression modules. | |
| 450 * This is done once at jpeg_start_decompress time. We determine | |
| 451 * which modules will be used and give them appropriate initialization calls. | |
| 452 * We also initialize the decompressor input side to begin consuming data. | |
| 453 * | |
| 454 * Since jpeg_read_header has finished, we know what is in the SOF | |
| 455 * and (first) SOS markers. We also have all the application parameter | |
| 456 * settings. | |
| 457 */ | |
| 458 | |
| 459 LOCAL(void) | |
| 460 master_selection (j_decompress_ptr cinfo) | |
| 461 { | |
| 462 my_master_ptr master = (my_master_ptr) cinfo->master; | |
| 463 boolean use_c_buffer; | |
| 464 long samplesperrow; | |
| 465 JDIMENSION jd_samplesperrow; | |
| 466 | |
| 467 /* Initialize dimensions and other stuff */ | |
| 468 jpeg_calc_output_dimensions(cinfo); | |
| 469 prepare_range_limit_table(cinfo); | |
| 470 | |
| 471 /* Width of an output scanline must be representable as JDIMENSION. */ | |
| 472 samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components; | |
| 473 jd_samplesperrow = (JDIMENSION) samplesperrow; | |
| 474 if ((long) jd_samplesperrow != samplesperrow) | |
| 475 ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); | |
| 476 | |
| 477 /* Initialize my private state */ | |
| 478 master->pass_number = 0; | |
| 479 master->using_merged_upsample = use_merged_upsample(cinfo); | |
| 480 | |
| 481 /* Color quantizer selection */ | |
| 482 master->quantizer_1pass = NULL; | |
| 483 master->quantizer_2pass = NULL; | |
| 484 /* No mode changes if not using buffered-image mode. */ | |
| 485 if (! cinfo->quantize_colors || ! cinfo->buffered_image) { | |
| 486 cinfo->enable_1pass_quant = FALSE; | |
| 487 cinfo->enable_external_quant = FALSE; | |
| 488 cinfo->enable_2pass_quant = FALSE; | |
| 489 } | |
| 490 if (cinfo->quantize_colors) { | |
| 491 if (cinfo->raw_data_out) | |
| 492 ERREXIT(cinfo, JERR_NOTIMPL); | |
| 493 /* 2-pass quantizer only works in 3-component color space. */ | |
| 494 if (cinfo->out_color_components != 3) { | |
| 495 cinfo->enable_1pass_quant = TRUE; | |
| 496 cinfo->enable_external_quant = FALSE; | |
| 497 cinfo->enable_2pass_quant = FALSE; | |
| 498 cinfo->colormap = NULL; | |
| 499 } else if (cinfo->colormap != NULL) { | |
| 500 cinfo->enable_external_quant = TRUE; | |
| 501 } else if (cinfo->two_pass_quantize) { | |
| 502 cinfo->enable_2pass_quant = TRUE; | |
| 503 } else { | |
| 504 cinfo->enable_1pass_quant = TRUE; | |
| 505 } | |
| 506 | |
| 507 if (cinfo->enable_1pass_quant) { | |
| 508 #ifdef QUANT_1PASS_SUPPORTED | |
| 509 jinit_1pass_quantizer(cinfo); | |
| 510 master->quantizer_1pass = cinfo->cquantize; | |
| 511 #else | |
| 512 ERREXIT(cinfo, JERR_NOT_COMPILED); | |
| 513 #endif | |
| 514 } | |
| 515 | |
| 516 /* We use the 2-pass code to map to external colormaps. */ | |
| 517 if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) { | |
| 518 #ifdef QUANT_2PASS_SUPPORTED | |
| 519 jinit_2pass_quantizer(cinfo); | |
| 520 master->quantizer_2pass = cinfo->cquantize; | |
| 521 #else | |
| 522 ERREXIT(cinfo, JERR_NOT_COMPILED); | |
| 523 #endif | |
| 524 } | |
| 525 /* If both quantizers are initialized, the 2-pass one is left active; | |
| 526 * this is necessary for starting with quantization to an external map. | |
| 527 */ | |
| 528 } | |
| 529 | |
| 530 /* Post-processing: in particular, color conversion first */ | |
| 531 if (! cinfo->raw_data_out) { | |
| 532 if (master->using_merged_upsample) { | |
| 533 #ifdef UPSAMPLE_MERGING_SUPPORTED | |
| 534 jinit_merged_upsampler(cinfo); /* does color conversion too */ | |
| 535 #else | |
| 536 ERREXIT(cinfo, JERR_NOT_COMPILED); | |
| 537 #endif | |
| 538 } else { | |
| 539 jinit_color_deconverter(cinfo); | |
| 540 jinit_upsampler(cinfo); | |
| 541 } | |
| 542 jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant); | |
| 543 } | |
| 544 /* Inverse DCT */ | |
| 545 jinit_inverse_dct(cinfo); | |
| 546 /* Entropy decoding: either Huffman or arithmetic coding. */ | |
| 547 if (cinfo->arith_code) { | |
| 548 #ifdef D_ARITH_CODING_SUPPORTED | |
| 549 jinit_arith_decoder(cinfo); | |
| 550 #else | |
| 551 ERREXIT(cinfo, JERR_ARITH_NOTIMPL); | |
| 552 #endif | |
| 553 } else { | |
| 554 if (cinfo->progressive_mode) { | |
| 555 #ifdef D_PROGRESSIVE_SUPPORTED | |
| 556 jinit_phuff_decoder(cinfo); | |
| 557 #else | |
| 558 ERREXIT(cinfo, JERR_NOT_COMPILED); | |
| 559 #endif | |
| 560 } else | |
| 561 jinit_huff_decoder(cinfo); | |
| 562 } | |
| 563 | |
| 564 /* Initialize principal buffer controllers. */ | |
| 565 use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image; | |
| 566 jinit_d_coef_controller(cinfo, use_c_buffer); | |
| 567 | |
| 568 if (! cinfo->raw_data_out) | |
| 569 jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */); | |
| 570 | |
| 571 /* We can now tell the memory manager to allocate virtual arrays. */ | |
| 572 (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo); | |
| 573 | |
| 574 /* Initialize input side of decompressor to consume first scan. */ | |
| 575 (*cinfo->inputctl->start_input_pass) (cinfo); | |
| 576 | |
| 577 #ifdef D_MULTISCAN_FILES_SUPPORTED | |
| 578 /* If jpeg_start_decompress will read the whole file, initialize | |
| 579 * progress monitoring appropriately. The input step is counted | |
| 580 * as one pass. | |
| 581 */ | |
| 582 if (cinfo->progress != NULL && ! cinfo->buffered_image && | |
| 583 cinfo->inputctl->has_multiple_scans) { | |
| 584 int nscans; | |
| 585 /* Estimate number of scans to set pass_limit. */ | |
| 586 if (cinfo->progressive_mode) { | |
| 587 /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */ | |
| 588 nscans = 2 + 3 * cinfo->num_components; | |
| 589 } else { | |
| 590 /* For a nonprogressive multiscan file, estimate 1 scan per component. */ | |
| 591 nscans = cinfo->num_components; | |
| 592 } | |
| 593 cinfo->progress->pass_counter = 0L; | |
| 594 cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans; | |
| 595 cinfo->progress->completed_passes = 0; | |
| 596 cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2); | |
| 597 /* Count the input pass as done */ | |
| 598 master->pass_number++; | |
| 599 } | |
| 600 #endif /* D_MULTISCAN_FILES_SUPPORTED */ | |
| 601 } | |
| 602 | |
| 603 | |
| 604 /* | |
| 605 * Per-pass setup. | |
| 606 * This is called at the beginning of each output pass. We determine which | |
| 607 * modules will be active during this pass and give them appropriate | |
| 608 * start_pass calls. We also set is_dummy_pass to indicate whether this | |
| 609 * is a "real" output pass or a dummy pass for color quantization. | |
| 610 * (In the latter case, jdapistd.c will crank the pass to completion.) | |
| 611 */ | |
| 612 | |
| 613 METHODDEF(void) | |
| 614 prepare_for_output_pass (j_decompress_ptr cinfo) | |
| 615 { | |
| 616 my_master_ptr master = (my_master_ptr) cinfo->master; | |
| 617 | |
| 618 if (master->pub.is_dummy_pass) { | |
| 619 #ifdef QUANT_2PASS_SUPPORTED | |
| 620 /* Final pass of 2-pass quantization */ | |
| 621 master->pub.is_dummy_pass = FALSE; | |
| 622 (*cinfo->cquantize->start_pass) (cinfo, FALSE); | |
| 623 (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST); | |
| 624 (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST); | |
| 625 #else | |
| 626 ERREXIT(cinfo, JERR_NOT_COMPILED); | |
| 627 #endif /* QUANT_2PASS_SUPPORTED */ | |
| 628 } else { | |
| 629 if (cinfo->quantize_colors && cinfo->colormap == NULL) { | |
| 630 /* Select new quantization method */ | |
| 631 if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) { | |
| 632 cinfo->cquantize = master->quantizer_2pass; | |
| 633 master->pub.is_dummy_pass = TRUE; | |
| 634 } else if (cinfo->enable_1pass_quant) { | |
| 635 cinfo->cquantize = master->quantizer_1pass; | |
| 636 } else { | |
| 637 ERREXIT(cinfo, JERR_MODE_CHANGE); | |
| 638 } | |
| 639 } | |
| 640 (*cinfo->idct->start_pass) (cinfo); | |
| 641 (*cinfo->coef->start_output_pass) (cinfo); | |
| 642 if (! cinfo->raw_data_out) { | |
| 643 if (! master->using_merged_upsample) | |
| 644 (*cinfo->cconvert->start_pass) (cinfo); | |
| 645 (*cinfo->upsample->start_pass) (cinfo); | |
| 646 if (cinfo->quantize_colors) | |
| 647 (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass); | |
| 648 (*cinfo->post->start_pass) (cinfo, | |
| 649 (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU)); | |
| 650 (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU); | |
| 651 } | |
| 652 } | |
| 653 | |
| 654 /* Set up progress monitor's pass info if present */ | |
| 655 if (cinfo->progress != NULL) { | |
| 656 cinfo->progress->completed_passes = master->pass_number; | |
| 657 cinfo->progress->total_passes = master->pass_number + | |
| 658 (master->pub.is_dummy_pass ? 2 : 1); | |
| 659 /* In buffered-image mode, we assume one more output pass if EOI not | |
| 660 * yet reached, but no more passes if EOI has been reached. | |
| 661 */ | |
| 662 if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) { | |
| 663 cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1); | |
| 664 } | |
| 665 } | |
| 666 } | |
| 667 | |
| 668 | |
| 669 /* | |
| 670 * Finish up at end of an output pass. | |
| 671 */ | |
| 672 | |
| 673 METHODDEF(void) | |
| 674 finish_output_pass (j_decompress_ptr cinfo) | |
| 675 { | |
| 676 my_master_ptr master = (my_master_ptr) cinfo->master; | |
| 677 | |
| 678 if (cinfo->quantize_colors) | |
| 679 (*cinfo->cquantize->finish_pass) (cinfo); | |
| 680 master->pass_number++; | |
| 681 } | |
| 682 | |
| 683 | |
| 684 #ifdef D_MULTISCAN_FILES_SUPPORTED | |
| 685 | |
| 686 /* | |
| 687 * Switch to a new external colormap between output passes. | |
| 688 */ | |
| 689 | |
| 690 GLOBAL(void) | |
| 691 jpeg_new_colormap (j_decompress_ptr cinfo) | |
| 692 { | |
| 693 my_master_ptr master = (my_master_ptr) cinfo->master; | |
| 694 | |
| 695 /* Prevent application from calling me at wrong times */ | |
| 696 if (cinfo->global_state != DSTATE_BUFIMAGE) | |
| 697 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); | |
| 698 | |
| 699 if (cinfo->quantize_colors && cinfo->enable_external_quant && | |
| 700 cinfo->colormap != NULL) { | |
| 701 /* Select 2-pass quantizer for external colormap use */ | |
| 702 cinfo->cquantize = master->quantizer_2pass; | |
| 703 /* Notify quantizer of colormap change */ | |
| 704 (*cinfo->cquantize->new_color_map) (cinfo); | |
| 705 master->pub.is_dummy_pass = FALSE; /* just in case */ | |
| 706 } else | |
| 707 ERREXIT(cinfo, JERR_MODE_CHANGE); | |
| 708 } | |
| 709 | |
| 710 #endif /* D_MULTISCAN_FILES_SUPPORTED */ | |
| 711 | |
| 712 | |
| 713 /* | |
| 714 * Initialize master decompression control and select active modules. | |
| 715 * This is performed at the start of jpeg_start_decompress. | |
| 716 */ | |
| 717 | |
| 718 GLOBAL(void) | |
| 719 jinit_master_decompress (j_decompress_ptr cinfo) | |
| 720 { | |
| 721 my_master_ptr master; | |
| 722 | |
| 723 master = (my_master_ptr) | |
| 724 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | |
| 725 SIZEOF(my_decomp_master)); | |
| 726 cinfo->master = (struct jpeg_decomp_master *) master; | |
| 727 master->pub.prepare_for_output_pass = prepare_for_output_pass; | |
| 728 master->pub.finish_output_pass = finish_output_pass; | |
| 729 | |
| 730 master->pub.is_dummy_pass = FALSE; | |
| 731 | |
| 732 master_selection(cinfo); | |
| 733 } |
