1 /* 2 * jdapimin.c 3 * 4 * Copyright (C) 1994-1998, Thomas G. Lane. 5 * Modified 2009-2013 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 application interface code for the decompression half 10 * of the JPEG library. These are the "minimum" API routines that may be 11 * needed in either the normal full-decompression case or the 12 * transcoding-only case. 13 * 14 * Most of the routines intended to be called directly by an application 15 * are in this file or in jdapistd.c. But also see jcomapi.c for routines 16 * shared by compression and decompression, and jdtrans.c for the transcoding 17 * case. 18 */ 19 20 #define JPEG_INTERNALS 21 #include "jinclude.h" 22 #include "jpeglib.h" 23 24 25 /* 26 * Initialization of a JPEG decompression object. 27 * The error manager must already be set up (in case memory manager fails). 28 */ 29 30 GLOBAL(void) 31 jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize) 32 { 33 int i; 34 35 /* Guard against version mismatches between library and caller. */ 36 cinfo->mem = NULL; /* so jpeg_destroy knows mem mgr not called */ 37 if (version != JPEG_LIB_VERSION) 38 ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version); 39 if (structsize != SIZEOF(struct jpeg_decompress_struct)) 40 ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, 41 (int) SIZEOF(struct jpeg_decompress_struct), (int) structsize); 42 43 /* For debugging purposes, we zero the whole master structure. 44 * But the application has already set the err pointer, and may have set 45 * client_data, so we have to save and restore those fields. 46 * Note: if application hasn't set client_data, tools like Purify may 47 * complain here. 48 */ 49 { 50 struct jpeg_error_mgr * err = cinfo->err; 51 void * client_data = cinfo->client_data; /* ignore Purify complaint here */ 52 MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct)); 53 cinfo->err = err; 54 cinfo->client_data = client_data; 55 } 56 cinfo->is_decompressor = TRUE; 57 58 /* Initialize a memory manager instance for this object */ 59 jinit_memory_mgr((j_common_ptr) cinfo); 60 61 /* Zero out pointers to permanent structures. */ 62 cinfo->progress = NULL; 63 cinfo->src = NULL; 64 65 for (i = 0; i < NUM_QUANT_TBLS; i++) 66 cinfo->quant_tbl_ptrs[i] = NULL; 67 68 for (i = 0; i < NUM_HUFF_TBLS; i++) { 69 cinfo->dc_huff_tbl_ptrs[i] = NULL; 70 cinfo->ac_huff_tbl_ptrs[i] = NULL; 71 } 72 73 /* Initialize marker processor so application can override methods 74 * for COM, APPn markers before calling jpeg_read_header. 75 */ 76 cinfo->marker_list = NULL; 77 jinit_marker_reader(cinfo); 78 79 /* And initialize the overall input controller. */ 80 jinit_input_controller(cinfo); 81 82 /* OK, I'm ready */ 83 cinfo->global_state = DSTATE_START; 84 } 85 86 87 /* 88 * Destruction of a JPEG decompression object 89 */ 90 91 GLOBAL(void) 92 jpeg_destroy_decompress (j_decompress_ptr cinfo) 93 { 94 jpeg_destroy((j_common_ptr) cinfo); /* use common routine */ 95 } 96 97 98 /* 99 * Abort processing of a JPEG decompression operation, 100 * but don't destroy the object itself. 101 */ 102 103 GLOBAL(void) 104 jpeg_abort_decompress (j_decompress_ptr cinfo) 105 { 106 jpeg_abort((j_common_ptr) cinfo); /* use common routine */ 107 } 108 109 110 /* 111 * Set default decompression parameters. 112 */ 113 114 LOCAL(void) 115 default_decompress_parms (j_decompress_ptr cinfo) 116 { 117 int cid0, cid1, cid2; 118 119 /* Guess the input colorspace, and set output colorspace accordingly. */ 120 /* Note application may override our guesses. */ 121 switch (cinfo->num_components) { 122 case 1: 123 cinfo->jpeg_color_space = JCS_GRAYSCALE; 124 cinfo->out_color_space = JCS_GRAYSCALE; 125 break; 126 127 case 3: 128 cid0 = cinfo->comp_info[0].component_id; 129 cid1 = cinfo->comp_info[1].component_id; 130 cid2 = cinfo->comp_info[2].component_id; 131 132 /* First try to guess from the component IDs */ 133 if (cid0 == 0x01 && cid1 == 0x02 && cid2 == 0x03) 134 cinfo->jpeg_color_space = JCS_YCbCr; 135 else if (cid0 == 0x01 && cid1 == 0x22 && cid2 == 0x23) 136 cinfo->jpeg_color_space = JCS_BG_YCC; 137 else if (cid0 == 0x52 && cid1 == 0x47 && cid2 == 0x42) 138 cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */ 139 else if (cid0 == 0x72 && cid1 == 0x67 && cid2 == 0x62) 140 cinfo->jpeg_color_space = JCS_BG_RGB; /* ASCII 'r', 'g', 'b' */ 141 else if (cinfo->saw_JFIF_marker) 142 cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */ 143 else if (cinfo->saw_Adobe_marker) { 144 switch (cinfo->Adobe_transform) { 145 case 0: 146 cinfo->jpeg_color_space = JCS_RGB; 147 break; 148 case 1: 149 cinfo->jpeg_color_space = JCS_YCbCr; 150 break; 151 default: 152 WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform); 153 cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */ 154 break; 155 } 156 } else { 157 TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2); 158 cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */ 159 } 160 /* Always guess RGB is proper output colorspace. */ 161 cinfo->out_color_space = JCS_RGB; 162 break; 163 164 case 4: 165 if (cinfo->saw_Adobe_marker) { 166 switch (cinfo->Adobe_transform) { 167 case 0: 168 cinfo->jpeg_color_space = JCS_CMYK; 169 break; 170 case 2: 171 cinfo->jpeg_color_space = JCS_YCCK; 172 break; 173 default: 174 WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform); 175 cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */ 176 break; 177 } 178 } else { 179 /* No special markers, assume straight CMYK. */ 180 cinfo->jpeg_color_space = JCS_CMYK; 181 } 182 cinfo->out_color_space = JCS_CMYK; 183 break; 184 185 default: 186 cinfo->jpeg_color_space = JCS_UNKNOWN; 187 cinfo->out_color_space = JCS_UNKNOWN; 188 break; 189 } 190 191 /* Set defaults for other decompression parameters. */ 192 cinfo->scale_num = cinfo->block_size; /* 1:1 scaling */ 193 cinfo->scale_denom = cinfo->block_size; 194 cinfo->output_gamma = 1.0; 195 cinfo->buffered_image = FALSE; 196 cinfo->raw_data_out = FALSE; 197 cinfo->dct_method = JDCT_DEFAULT; 198 cinfo->do_fancy_upsampling = TRUE; 199 cinfo->do_block_smoothing = TRUE; 200 cinfo->quantize_colors = FALSE; 201 /* We set these in case application only sets quantize_colors. */ 202 cinfo->dither_mode = JDITHER_FS; 203 #ifdef QUANT_2PASS_SUPPORTED 204 cinfo->two_pass_quantize = TRUE; 205 #else 206 cinfo->two_pass_quantize = FALSE; 207 #endif 208 cinfo->desired_number_of_colors = 256; 209 cinfo->colormap = NULL; 210 /* Initialize for no mode change in buffered-image mode. */ 211 cinfo->enable_1pass_quant = FALSE; 212 cinfo->enable_external_quant = FALSE; 213 cinfo->enable_2pass_quant = FALSE; 214 } 215 216 217 /* 218 * Decompression startup: read start of JPEG datastream to see what's there. 219 * Need only initialize JPEG object and supply a data source before calling. 220 * 221 * This routine will read as far as the first SOS marker (ie, actual start of 222 * compressed data), and will save all tables and parameters in the JPEG 223 * object. It will also initialize the decompression parameters to default 224 * values, and finally return JPEG_HEADER_OK. On return, the application may 225 * adjust the decompression parameters and then call jpeg_start_decompress. 226 * (Or, if the application only wanted to determine the image parameters, 227 * the data need not be decompressed. In that case, call jpeg_abort or 228 * jpeg_destroy to release any temporary space.) 229 * If an abbreviated (tables only) datastream is presented, the routine will 230 * return JPEG_HEADER_TABLES_ONLY upon reaching EOI. The application may then 231 * re-use the JPEG object to read the abbreviated image datastream(s). 232 * It is unnecessary (but OK) to call jpeg_abort in this case. 233 * The JPEG_SUSPENDED return code only occurs if the data source module 234 * requests suspension of the decompressor. In this case the application 235 * should load more source data and then re-call jpeg_read_header to resume 236 * processing. 237 * If a non-suspending data source is used and require_image is TRUE, then the 238 * return code need not be inspected since only JPEG_HEADER_OK is possible. 239 * 240 * This routine is now just a front end to jpeg_consume_input, with some 241 * extra error checking. 242 */ 243 244 GLOBAL(int) 245 jpeg_read_header (j_decompress_ptr cinfo, boolean require_image) 246 { 247 int retcode; 248 249 if (cinfo->global_state != DSTATE_START && 250 cinfo->global_state != DSTATE_INHEADER) 251 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 252 253 retcode = jpeg_consume_input(cinfo); 254 255 switch (retcode) { 256 case JPEG_REACHED_SOS: 257 retcode = JPEG_HEADER_OK; 258 break; 259 case JPEG_REACHED_EOI: 260 if (require_image) /* Complain if application wanted an image */ 261 ERREXIT(cinfo, JERR_NO_IMAGE); 262 /* Reset to start state; it would be safer to require the application to 263 * call jpeg_abort, but we can't change it now for compatibility reasons. 264 * A side effect is to free any temporary memory (there shouldn't be any). 265 */ 266 jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */ 267 retcode = JPEG_HEADER_TABLES_ONLY; 268 break; 269 case JPEG_SUSPENDED: 270 /* no work */ 271 break; 272 } 273 274 return retcode; 275 } 276 277 278 /* 279 * Consume data in advance of what the decompressor requires. 280 * This can be called at any time once the decompressor object has 281 * been created and a data source has been set up. 282 * 283 * This routine is essentially a state machine that handles a couple 284 * of critical state-transition actions, namely initial setup and 285 * transition from header scanning to ready-for-start_decompress. 286 * All the actual input is done via the input controller's consume_input 287 * method. 288 */ 289 290 GLOBAL(int) 291 jpeg_consume_input (j_decompress_ptr cinfo) 292 { 293 int retcode = JPEG_SUSPENDED; 294 295 /* NB: every possible DSTATE value should be listed in this switch */ 296 switch (cinfo->global_state) { 297 case DSTATE_START: 298 /* Start-of-datastream actions: reset appropriate modules */ 299 (*cinfo->inputctl->reset_input_controller) (cinfo); 300 /* Initialize application's data source module */ 301 (*cinfo->src->init_source) (cinfo); 302 cinfo->global_state = DSTATE_INHEADER; 303 /*FALLTHROUGH*/ 304 case DSTATE_INHEADER: 305 retcode = (*cinfo->inputctl->consume_input) (cinfo); 306 if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */ 307 /* Set up default parameters based on header data */ 308 default_decompress_parms(cinfo); 309 /* Set global state: ready for start_decompress */ 310 cinfo->global_state = DSTATE_READY; 311 } 312 break; 313 case DSTATE_READY: 314 /* Can't advance past first SOS until start_decompress is called */ 315 retcode = JPEG_REACHED_SOS; 316 break; 317 case DSTATE_PRELOAD: 318 case DSTATE_PRESCAN: 319 case DSTATE_SCANNING: 320 case DSTATE_RAW_OK: 321 case DSTATE_BUFIMAGE: 322 case DSTATE_BUFPOST: 323 case DSTATE_STOPPING: 324 retcode = (*cinfo->inputctl->consume_input) (cinfo); 325 break; 326 default: 327 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 328 } 329 return retcode; 330 } 331 332 333 /* 334 * Have we finished reading the input file? 335 */ 336 337 GLOBAL(boolean) 338 jpeg_input_complete (j_decompress_ptr cinfo) 339 { 340 /* Check for valid jpeg object */ 341 if (cinfo->global_state < DSTATE_START || 342 cinfo->global_state > DSTATE_STOPPING) 343 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 344 return cinfo->inputctl->eoi_reached; 345 } 346 347 348 /* 349 * Is there more than one scan? 350 */ 351 352 GLOBAL(boolean) 353 jpeg_has_multiple_scans (j_decompress_ptr cinfo) 354 { 355 /* Only valid after jpeg_read_header completes */ 356 if (cinfo->global_state < DSTATE_READY || 357 cinfo->global_state > DSTATE_STOPPING) 358 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 359 return cinfo->inputctl->has_multiple_scans; 360 } 361 362 363 /* 364 * Finish JPEG decompression. 365 * 366 * This will normally just verify the file trailer and release temp storage. 367 * 368 * Returns FALSE if suspended. The return value need be inspected only if 369 * a suspending data source is used. 370 */ 371 372 GLOBAL(boolean) 373 jpeg_finish_decompress (j_decompress_ptr cinfo) 374 { 375 if ((cinfo->global_state == DSTATE_SCANNING || 376 cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) { 377 /* Terminate final pass of non-buffered mode */ 378 if (cinfo->output_scanline < cinfo->output_height) 379 ERREXIT(cinfo, JERR_TOO_LITTLE_DATA); 380 (*cinfo->master->finish_output_pass) (cinfo); 381 cinfo->global_state = DSTATE_STOPPING; 382 } else if (cinfo->global_state == DSTATE_BUFIMAGE) { 383 /* Finishing after a buffered-image operation */ 384 cinfo->global_state = DSTATE_STOPPING; 385 } else if (cinfo->global_state != DSTATE_STOPPING) { 386 /* STOPPING = repeat call after a suspension, anything else is error */ 387 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 388 } 389 /* Read until EOI */ 390 while (! cinfo->inputctl->eoi_reached) { 391 if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) 392 return FALSE; /* Suspend, come back later */ 393 } 394 /* Do final cleanup */ 395 (*cinfo->src->term_source) (cinfo); 396 /* We can use jpeg_abort to release memory and reset global_state */ 397 jpeg_abort((j_common_ptr) cinfo); 398 return TRUE; 399 }