libs/jpeg6/jdapimin.cpp

   1 /*\r
   2 \r
   3  * jdapimin.c\r
   4 \r
   5  *\r
   6 \r
   7  * Copyright (C) 1994-1995, Thomas G. Lane.\r
   8 \r
   9  * This file is part of the Independent JPEG Group's software.\r
  10 \r
  11  * For conditions of distribution and use, see the accompanying README file.\r
  12 \r
  13  *\r
  14 \r
  15  * This file contains application interface code for the decompression half\r
  16 \r
  17  * of the JPEG library.  These are the "minimum" API routines that may be\r
  18 \r
  19  * needed in either the normal full-decompression case or the\r
  20 \r
  21  * transcoding-only case.\r
  22 \r
  23  *\r
  24 \r
  25  * Most of the routines intended to be called directly by an application\r
  26 \r
  27  * are in this file or in jdapistd.c.  But also see jcomapi.c for routines\r
  28 \r
  29  * shared by compression and decompression, and jdtrans.c for the transcoding\r
  30 \r
  31  * case.\r
  32 \r
  33  */\r
  34 \r
  35 \r
  36 \r
  37 #define JPEG_INTERNALS\r
  38 \r
  39 #include "jinclude.h"\r
  40 \r
  41 #include "radiant_jpeglib.h"\r
  42 \r
  43 \r
  44 \r
  45 \r
  46 \r
  47 /*\r
  48 \r
  49  * Initialization of a JPEG decompression object.\r
  50 \r
  51  * The error manager must already be set up (in case memory manager fails).\r
  52 \r
  53  */\r
  54 \r
  55 \r
  56 \r
  57 GLOBAL void\r
  58 \r
  59 jpeg_create_decompress (j_decompress_ptr cinfo)\r
  60 \r
  61 {\r
  62 \r
  63   int i;\r
  64 \r
  65 \r
  66 \r
  67   /* For debugging purposes, zero the whole master structure.\r
  68 \r
  69    * But error manager pointer is already there, so save and restore it.\r
  70 \r
  71    */\r
  72 \r
  73   {\r
  74 \r
  75     struct jpeg_error_mgr * err = cinfo->err;\r
  76 \r
  77     i = sizeof(struct jpeg_decompress_struct);\r
  78 \r
  79     i = SIZEOF(struct jpeg_decompress_struct);\r
  80 \r
  81     MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct));\r
  82 \r
  83     cinfo->err = err;\r
  84 \r
  85   }\r
  86 \r
  87   cinfo->is_decompressor = TRUE;\r
  88 \r
  89 \r
  90 \r
  91   /* Initialize a memory manager instance for this object */\r
  92 \r
  93   jinit_memory_mgr((j_common_ptr) cinfo);\r
  94 \r
  95 \r
  96 \r
  97   /* Zero out pointers to permanent structures. */\r
  98 \r
  99   cinfo->progress = NULL;\r
 100 \r
 101   cinfo->src = NULL;\r
 102 \r
 103 \r
 104 \r
 105   for (i = 0; i < NUM_QUANT_TBLS; i++)\r
 106 \r
 107     cinfo->quant_tbl_ptrs[i] = NULL;\r
 108 \r
 109 \r
 110 \r
 111   for (i = 0; i < NUM_HUFF_TBLS; i++) {\r
 112 \r
 113     cinfo->dc_huff_tbl_ptrs[i] = NULL;\r
 114 \r
 115     cinfo->ac_huff_tbl_ptrs[i] = NULL;\r
 116 \r
 117   }\r
 118 \r
 119 \r
 120 \r
 121   /* Initialize marker processor so application can override methods\r
 122 \r
 123    * for COM, APPn markers before calling jpeg_read_header.\r
 124 \r
 125    */\r
 126 \r
 127   jinit_marker_reader(cinfo);\r
 128 \r
 129 \r
 130 \r
 131   /* And initialize the overall input controller. */\r
 132 \r
 133   jinit_input_controller(cinfo);\r
 134 \r
 135 \r
 136 \r
 137   /* OK, I'm ready */\r
 138 \r
 139   cinfo->global_state = DSTATE_START;\r
 140 \r
 141 }\r
 142 \r
 143 \r
 144 \r
 145 \r
 146 \r
 147 /*\r
 148 \r
 149  * Destruction of a JPEG decompression object\r
 150 \r
 151  */\r
 152 \r
 153 \r
 154 \r
 155 GLOBAL void\r
 156 \r
 157 jpeg_destroy_decompress (j_decompress_ptr cinfo)\r
 158 \r
 159 {\r
 160 \r
 161   jpeg_destroy((j_common_ptr) cinfo); /* use common routine */\r
 162 \r
 163 }\r
 164 \r
 165 \r
 166 \r
 167 \r
 168 \r
 169 /*\r
 170 \r
 171  * Abort processing of a JPEG decompression operation,\r
 172 \r
 173  * but don't destroy the object itself.\r
 174 \r
 175  */\r
 176 \r
 177 \r
 178 \r
 179 GLOBAL void\r
 180 \r
 181 jpeg_abort_decompress (j_decompress_ptr cinfo)\r
 182 \r
 183 {\r
 184 \r
 185   jpeg_abort((j_common_ptr) cinfo); /* use common routine */\r
 186 \r
 187 }\r
 188 \r
 189 \r
 190 \r
 191 \r
 192 \r
 193 /*\r
 194 \r
 195  * Install a special processing method for COM or APPn markers.\r
 196 \r
 197  */\r
 198 \r
 199 \r
 200 \r
 201 GLOBAL void\r
 202 \r
 203 jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code,\r
 204 \r
 205                            jpeg_marker_parser_method routine)\r
 206 \r
 207 {\r
 208 \r
 209   if (marker_code == JPEG_COM)\r
 210 \r
 211     cinfo->marker->process_COM = routine;\r
 212 \r
 213   else if (marker_code >= JPEG_APP0 && marker_code <= JPEG_APP0+15)\r
 214 \r
 215     cinfo->marker->process_APPn[marker_code-JPEG_APP0] = routine;\r
 216 \r
 217   else\r
 218 \r
 219     ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);\r
 220 \r
 221 }\r
 222 \r
 223 \r
 224 \r
 225 \r
 226 \r
 227 /*\r
 228 \r
 229  * Set default decompression parameters.\r
 230 \r
 231  */\r
 232 \r
 233 \r
 234 \r
 235 LOCAL void\r
 236 \r
 237 default_decompress_parms (j_decompress_ptr cinfo)\r
 238 \r
 239 {\r
 240 \r
 241   /* Guess the input colorspace, and set output colorspace accordingly. */\r
 242 \r
 243   /* (Wish JPEG committee had provided a real way to specify this...) */\r
 244 \r
 245   /* Note application may override our guesses. */\r
 246 \r
 247   switch (cinfo->num_components) {\r
 248 \r
 249   case 1:\r
 250 \r
 251     cinfo->jpeg_color_space = JCS_GRAYSCALE;\r
 252 \r
 253     cinfo->out_color_space = JCS_GRAYSCALE;\r
 254 \r
 255     break;\r
 256 \r
 257     \r
 258 \r
 259   case 3:\r
 260 \r
 261     if (cinfo->saw_JFIF_marker) {\r
 262 \r
 263       cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */\r
 264 \r
 265     } else if (cinfo->saw_Adobe_marker) {\r
 266 \r
 267       switch (cinfo->Adobe_transform) {\r
 268 \r
 269       case 0:\r
 270 \r
 271         cinfo->jpeg_color_space = JCS_RGB;\r
 272 \r
 273         break;\r
 274 \r
 275       case 1:\r
 276 \r
 277         cinfo->jpeg_color_space = JCS_YCbCr;\r
 278 \r
 279         break;\r
 280 \r
 281       default:\r
 282 \r
 283         WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);\r
 284 \r
 285         cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */\r
 286 \r
 287         break;\r
 288 \r
 289       }\r
 290 \r
 291     } else {\r
 292 \r
 293       /* Saw no special markers, try to guess from the component IDs */\r
 294 \r
 295       int cid0 = cinfo->comp_info[0].component_id;\r
 296 \r
 297       int cid1 = cinfo->comp_info[1].component_id;\r
 298 \r
 299       int cid2 = cinfo->comp_info[2].component_id;\r
 300 \r
 301 \r
 302 \r
 303       if (cid0 == 1 && cid1 == 2 && cid2 == 3)\r
 304 \r
 305         cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */\r
 306 \r
 307       else if (cid0 == 82 && cid1 == 71 && cid2 == 66)\r
 308 \r
 309         cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */\r
 310 \r
 311       else {\r
 312 \r
 313         TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);\r
 314 \r
 315         cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */\r
 316 \r
 317       }\r
 318 \r
 319     }\r
 320 \r
 321     /* Always guess RGB is proper output colorspace. */\r
 322 \r
 323     cinfo->out_color_space = JCS_RGB;\r
 324 \r
 325     break;\r
 326 \r
 327     \r
 328 \r
 329   case 4:\r
 330 \r
 331     if (cinfo->saw_Adobe_marker) {\r
 332 \r
 333       switch (cinfo->Adobe_transform) {\r
 334 \r
 335       case 0:\r
 336 \r
 337         cinfo->jpeg_color_space = JCS_CMYK;\r
 338 \r
 339         break;\r
 340 \r
 341       case 2:\r
 342 \r
 343         cinfo->jpeg_color_space = JCS_YCCK;\r
 344 \r
 345         break;\r
 346 \r
 347       default:\r
 348 \r
 349         WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);\r
 350 \r
 351         cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */\r
 352 \r
 353         break;\r
 354 \r
 355       }\r
 356 \r
 357     } else {\r
 358 \r
 359       /* No special markers, assume straight CMYK. */\r
 360 \r
 361       cinfo->jpeg_color_space = JCS_CMYK;\r
 362 \r
 363     }\r
 364 \r
 365     cinfo->out_color_space = JCS_CMYK;\r
 366 \r
 367     break;\r
 368 \r
 369     \r
 370 \r
 371   default:\r
 372 \r
 373     cinfo->jpeg_color_space = JCS_UNKNOWN;\r
 374 \r
 375     cinfo->out_color_space = JCS_UNKNOWN;\r
 376 \r
 377     break;\r
 378 \r
 379   }\r
 380 \r
 381 \r
 382 \r
 383   /* Set defaults for other decompression parameters. */\r
 384 \r
 385   cinfo->scale_num = 1;         /* 1:1 scaling */\r
 386 \r
 387   cinfo->scale_denom = 1;\r
 388 \r
 389   cinfo->output_gamma = 1.0;\r
 390 \r
 391   cinfo->buffered_image = FALSE;\r
 392 \r
 393   cinfo->raw_data_out = FALSE;\r
 394 \r
 395   cinfo->dct_method = JDCT_DEFAULT;\r
 396 \r
 397   cinfo->do_fancy_upsampling = TRUE;\r
 398 \r
 399   cinfo->do_block_smoothing = TRUE;\r
 400 \r
 401   cinfo->quantize_colors = FALSE;\r
 402 \r
 403   /* We set these in case application only sets quantize_colors. */\r
 404 \r
 405   cinfo->dither_mode = JDITHER_FS;\r
 406 \r
 407 #ifdef QUANT_2PASS_SUPPORTED\r
 408 \r
 409   cinfo->two_pass_quantize = TRUE;\r
 410 \r
 411 #else\r
 412 \r
 413   cinfo->two_pass_quantize = FALSE;\r
 414 \r
 415 #endif\r
 416 \r
 417   cinfo->desired_number_of_colors = 256;\r
 418 \r
 419   cinfo->colormap = NULL;\r
 420 \r
 421   /* Initialize for no mode change in buffered-image mode. */\r
 422 \r
 423   cinfo->enable_1pass_quant = FALSE;\r
 424 \r
 425   cinfo->enable_external_quant = FALSE;\r
 426 \r
 427   cinfo->enable_2pass_quant = FALSE;\r
 428 \r
 429 }\r
 430 \r
 431 \r
 432 \r
 433 \r
 434 \r
 435 /*\r
 436 \r
 437  * Decompression startup: read start of JPEG datastream to see what's there.\r
 438 \r
 439  * Need only initialize JPEG object and supply a data source before calling.\r
 440 \r
 441  *\r
 442 \r
 443  * This routine will read as far as the first SOS marker (ie, actual start of\r
 444 \r
 445  * compressed data), and will save all tables and parameters in the JPEG\r
 446 \r
 447  * object.  It will also initialize the decompression parameters to default\r
 448 \r
 449  * values, and finally return JPEG_HEADER_OK.  On return, the application may\r
 450 \r
 451  * adjust the decompression parameters and then call jpeg_start_decompress.\r
 452 \r
 453  * (Or, if the application only wanted to determine the image parameters,\r
 454 \r
 455  * the data need not be decompressed.  In that case, call jpeg_abort or\r
 456 \r
 457  * jpeg_destroy to release any temporary space.)\r
 458 \r
 459  * If an abbreviated (tables only) datastream is presented, the routine will\r
 460 \r
 461  * return JPEG_HEADER_TABLES_ONLY upon reaching EOI.  The application may then\r
 462 \r
 463  * re-use the JPEG object to read the abbreviated image datastream(s).\r
 464 \r
 465  * It is unnecessary (but OK) to call jpeg_abort in this case.\r
 466 \r
 467  * The JPEG_SUSPENDED return code only occurs if the data source module\r
 468 \r
 469  * requests suspension of the decompressor.  In this case the application\r
 470 \r
 471  * should load more source data and then re-call jpeg_read_header to resume\r
 472 \r
 473  * processing.\r
 474 \r
 475  * If a non-suspending data source is used and require_image is TRUE, then the\r
 476 \r
 477  * return code need not be inspected since only JPEG_HEADER_OK is possible.\r
 478 \r
 479  *\r
 480 \r
 481  * This routine is now just a front end to jpeg_consume_input, with some\r
 482 \r
 483  * extra error checking.\r
 484 \r
 485  */\r
 486 \r
 487 \r
 488 \r
 489 GLOBAL int\r
 490 \r
 491 jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)\r
 492 \r
 493 {\r
 494 \r
 495   int retcode;\r
 496 \r
 497 \r
 498 \r
 499   if (cinfo->global_state != DSTATE_START &&\r
 500 \r
 501       cinfo->global_state != DSTATE_INHEADER)\r
 502 \r
 503     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
 504 \r
 505 \r
 506 \r
 507   retcode = jpeg_consume_input(cinfo);\r
 508 \r
 509 \r
 510 \r
 511   switch (retcode) {\r
 512 \r
 513   case JPEG_REACHED_SOS:\r
 514 \r
 515     retcode = JPEG_HEADER_OK;\r
 516 \r
 517     break;\r
 518 \r
 519   case JPEG_REACHED_EOI:\r
 520 \r
 521     if (require_image)          /* Complain if application wanted an image */\r
 522 \r
 523       ERREXIT(cinfo, JERR_NO_IMAGE);\r
 524 \r
 525     /* Reset to start state; it would be safer to require the application to\r
 526 \r
 527      * call jpeg_abort, but we can't change it now for compatibility reasons.\r
 528 \r
 529      * A side effect is to free any temporary memory (there shouldn't be any).\r
 530 \r
 531      */\r
 532 \r
 533     jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */\r
 534 \r
 535     retcode = JPEG_HEADER_TABLES_ONLY;\r
 536 \r
 537     break;\r
 538 \r
 539   case JPEG_SUSPENDED:\r
 540 \r
 541     /* no work */\r
 542 \r
 543     break;\r
 544 \r
 545   }\r
 546 \r
 547 \r
 548 \r
 549   return retcode;\r
 550 \r
 551 }\r
 552 \r
 553 \r
 554 \r
 555 \r
 556 \r
 557 /*\r
 558 \r
 559  * Consume data in advance of what the decompressor requires.\r
 560 \r
 561  * This can be called at any time once the decompressor object has\r
 562 \r
 563  * been created and a data source has been set up.\r
 564 \r
 565  *\r
 566 \r
 567  * This routine is essentially a state machine that handles a couple\r
 568 \r
 569  * of critical state-transition actions, namely initial setup and\r
 570 \r
 571  * transition from header scanning to ready-for-start_decompress.\r
 572 \r
 573  * All the actual input is done via the input controller's consume_input\r
 574 \r
 575  * method.\r
 576 \r
 577  */\r
 578 \r
 579 \r
 580 \r
 581 GLOBAL int\r
 582 \r
 583 jpeg_consume_input (j_decompress_ptr cinfo)\r
 584 \r
 585 {\r
 586 \r
 587   int retcode = JPEG_SUSPENDED;\r
 588 \r
 589 \r
 590 \r
 591   /* NB: every possible DSTATE value should be listed in this switch */\r
 592 \r
 593   switch (cinfo->global_state) {\r
 594 \r
 595   case DSTATE_START:\r
 596 \r
 597     /* Start-of-datastream actions: reset appropriate modules */\r
 598 \r
 599     (*cinfo->inputctl->reset_input_controller) (cinfo);\r
 600 \r
 601     /* Initialize application's data source module */\r
 602 \r
 603     (*cinfo->src->init_source) (cinfo);\r
 604 \r
 605     cinfo->global_state = DSTATE_INHEADER;\r
 606 \r
 607     /*FALLTHROUGH*/\r
 608 \r
 609   case DSTATE_INHEADER:\r
 610 \r
 611     retcode = (*cinfo->inputctl->consume_input) (cinfo);\r
 612 \r
 613     if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */\r
 614 \r
 615       /* Set up default parameters based on header data */\r
 616 \r
 617       default_decompress_parms(cinfo);\r
 618 \r
 619       /* Set global state: ready for start_decompress */\r
 620 \r
 621       cinfo->global_state = DSTATE_READY;\r
 622 \r
 623     }\r
 624 \r
 625     break;\r
 626 \r
 627   case DSTATE_READY:\r
 628 \r
 629     /* Can't advance past first SOS until start_decompress is called */\r
 630 \r
 631     retcode = JPEG_REACHED_SOS;\r
 632 \r
 633     break;\r
 634 \r
 635   case DSTATE_PRELOAD:\r
 636 \r
 637   case DSTATE_PRESCAN:\r
 638 \r
 639   case DSTATE_SCANNING:\r
 640 \r
 641   case DSTATE_RAW_OK:\r
 642 \r
 643   case DSTATE_BUFIMAGE:\r
 644 \r
 645   case DSTATE_BUFPOST:\r
 646 \r
 647   case DSTATE_STOPPING:\r
 648 \r
 649     retcode = (*cinfo->inputctl->consume_input) (cinfo);\r
 650 \r
 651     break;\r
 652 \r
 653   default:\r
 654 \r
 655     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
 656 \r
 657   }\r
 658 \r
 659   return retcode;\r
 660 \r
 661 }\r
 662 \r
 663 \r
 664 \r
 665 \r
 666 \r
 667 /*\r
 668 \r
 669  * Have we finished reading the input file?\r
 670 \r
 671  */\r
 672 \r
 673 \r
 674 \r
 675 GLOBAL boolean\r
 676 \r
 677 jpeg_input_complete (j_decompress_ptr cinfo)\r
 678 \r
 679 {\r
 680 \r
 681   /* Check for valid jpeg object */\r
 682 \r
 683   if (cinfo->global_state < DSTATE_START ||\r
 684 \r
 685       cinfo->global_state > DSTATE_STOPPING)\r
 686 \r
 687     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
 688 \r
 689   return cinfo->inputctl->eoi_reached;\r
 690 \r
 691 }\r
 692 \r
 693 \r
 694 \r
 695 \r
 696 \r
 697 /*\r
 698 \r
 699  * Is there more than one scan?\r
 700 \r
 701  */\r
 702 \r
 703 \r
 704 \r
 705 GLOBAL boolean\r
 706 \r
 707 jpeg_has_multiple_scans (j_decompress_ptr cinfo)\r
 708 \r
 709 {\r
 710 \r
 711   /* Only valid after jpeg_read_header completes */\r
 712 \r
 713   if (cinfo->global_state < DSTATE_READY ||\r
 714 \r
 715       cinfo->global_state > DSTATE_STOPPING)\r
 716 \r
 717     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
 718 \r
 719   return cinfo->inputctl->has_multiple_scans;\r
 720 \r
 721 }\r
 722 \r
 723 \r
 724 \r
 725 \r
 726 \r
 727 /*\r
 728 \r
 729  * Finish JPEG decompression.\r
 730 \r
 731  *\r
 732 \r
 733  * This will normally just verify the file trailer and release temp storage.\r
 734 \r
 735  *\r
 736 \r
 737  * Returns FALSE if suspended.  The return value need be inspected only if\r
 738 \r
 739  * a suspending data source is used.\r
 740 \r
 741  */\r
 742 \r
 743 \r
 744 \r
 745 GLOBAL boolean\r
 746 \r
 747 jpeg_finish_decompress (j_decompress_ptr cinfo)\r
 748 \r
 749 {\r
 750 \r
 751   if ((cinfo->global_state == DSTATE_SCANNING ||\r
 752 \r
 753        cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {\r
 754 \r
 755     /* Terminate final pass of non-buffered mode */\r
 756 \r
 757     if (cinfo->output_scanline < cinfo->output_height)\r
 758 \r
 759       ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);\r
 760 \r
 761     (*cinfo->master->finish_output_pass) (cinfo);\r
 762 \r
 763     cinfo->global_state = DSTATE_STOPPING;\r
 764 \r
 765   } else if (cinfo->global_state == DSTATE_BUFIMAGE) {\r
 766 \r
 767     /* Finishing after a buffered-image operation */\r
 768 \r
 769     cinfo->global_state = DSTATE_STOPPING;\r
 770 \r
 771   } else if (cinfo->global_state != DSTATE_STOPPING) {\r
 772 \r
 773     /* STOPPING = repeat call after a suspension, anything else is error */\r
 774 \r
 775     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
 776 \r
 777   }\r
 778 \r
 779   /* Read until EOI */\r
 780 \r
 781   while (! cinfo->inputctl->eoi_reached) {\r
 782 \r
 783     if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)\r
 784 \r
 785       return FALSE;             /* Suspend, come back later */\r
 786 \r
 787   }\r
 788 \r
 789   /* Do final cleanup */\r
 790 \r
 791   (*cinfo->src->term_source) (cinfo);\r
 792 \r
 793   /* We can use jpeg_abort to release memory and reset global_state */\r
 794 \r
 795   jpeg_abort((j_common_ptr) cinfo);\r
 796 \r
 797   return TRUE;\r
 798 \r
 799 }\r
 800 \r