1 /*

     2  * jdapimin.c

     3  *

     4  * Copyright (C) 1994-1998, Thomas G. Lane.

     5  * This file is part of the Independent JPEG Group's software.

     6  * For conditions of distribution and use, see the accompanying README file.

     7  *

     8  * This file contains application interface code for the decompression half

     9  * of the JPEG library.  These are the "minimum" API routines that may be

    10  * needed in either the normal full-decompression case or the

    11  * transcoding-only case.

    12  *

    13  * Most of the routines intended to be called directly by an application

    14  * are in this file or in jdapistd.c.  But also see jcomapi.c for routines

    15  * shared by compression and decompression, and jdtrans.c for the transcoding

    16  * case.

    17  */

    18 

    19 #define JPEG_INTERNALS

    20 #include "jinclude.h"

    21 #include "jpeglib.h"

    22 

    23 

    24 /*

    25  * Initialization of a JPEG decompression object.

    26  * The error manager must already be set up (in case memory manager fails).

    27  */

    28 

    29 GLOBAL(void)

    30 jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize)

    31 {

    32   int i;

    33 

    34   /* Guard against version mismatches between library and caller. */

    35   cinfo->mem = NULL;		/* so jpeg_destroy knows mem mgr not called */

    36   if (version != JPEG_LIB_VERSION)

    37     ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);

    38   if (structsize != SIZEOF(struct jpeg_decompress_struct))

    39     ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, 

    40 	     (int) SIZEOF(struct jpeg_decompress_struct), (int) structsize);

    41 

    42   /* For debugging purposes, we zero the whole master structure.

    43    * But the application has already set the err pointer, and may have set

    44    * client_data, so we have to save and restore those fields.

    45    * Note: if application hasn't set client_data, tools like Purify may

    46    * complain here.

    47    */

    48   {

    49     struct jpeg_error_mgr * err = cinfo->err;

    50     void * client_data = cinfo->client_data; /* ignore Purify complaint here */

    51     MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct));

    52     cinfo->err = err;

    53     cinfo->client_data = client_data;

    54   }

    55   cinfo->is_decompressor = TRUE;

    56 

    57   /* Initialize a memory manager instance for this object */

    58   jinit_memory_mgr((j_common_ptr) cinfo);

    59 

    60   /* Zero out pointers to permanent structures. */

    61   cinfo->progress = NULL;

    62   cinfo->src = NULL;

    63 

    64   for (i = 0; i < NUM_QUANT_TBLS; i++)

    65     cinfo->quant_tbl_ptrs[i] = NULL;

    66 

    67   for (i = 0; i < NUM_HUFF_TBLS; i++) {

    68     cinfo->dc_huff_tbl_ptrs[i] = NULL;

    69     cinfo->ac_huff_tbl_ptrs[i] = NULL;

    70   }

    71 

    72   /* Initialize marker processor so application can override methods

    73    * for COM, APPn markers before calling jpeg_read_header.

    74    */

    75   cinfo->marker_list = NULL;

    76   jinit_marker_reader(cinfo);

    77 

    78   /* And initialize the overall input controller. */

    79   jinit_input_controller(cinfo);

    80 

    81   /* OK, I'm ready */

    82   cinfo->global_state = DSTATE_START;

    83 }

    84 

    85 

    86 /*

    87  * Destruction of a JPEG decompression object

    88  */

    89 

    90 GLOBAL(void)

    91 jpeg_destroy_decompress (j_decompress_ptr cinfo)

    92 {

    93   jpeg_destroy((j_common_ptr) cinfo); /* use common routine */

    94 }

    95 

    96 

    97 /*

    98  * Abort processing of a JPEG decompression operation,

    99  * but don't destroy the object itself.

   100  */

   101 

   102 GLOBAL(void)

   103 jpeg_abort_decompress (j_decompress_ptr cinfo)

   104 {

   105   jpeg_abort((j_common_ptr) cinfo); /* use common routine */

   106 }

   107 

   108 

   109 /*

   110  * Set default decompression parameters.

   111  */

   112 

   113 LOCAL(void)

   114 default_decompress_parms (j_decompress_ptr cinfo)

   115 {

   116   /* Guess the input colorspace, and set output colorspace accordingly. */

   117   /* (Wish JPEG committee had provided a real way to specify this...) */

   118   /* Note application may override our guesses. */

   119   switch (cinfo->num_components) {

   120   case 1:

   121     cinfo->jpeg_color_space = JCS_GRAYSCALE;

   122     cinfo->out_color_space = JCS_GRAYSCALE;

   123     break;

   124     

   125   case 3:

   126     if (cinfo->saw_JFIF_marker) {

   127       cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */

   128     } else if (cinfo->saw_Adobe_marker) {

   129       switch (cinfo->Adobe_transform) {

   130       case 0:

   131 	cinfo->jpeg_color_space = JCS_RGB;

   132 	break;

   133       case 1:

   134 	cinfo->jpeg_color_space = JCS_YCbCr;

   135 	break;

   136       default:

   137 	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);

   138 	cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */

   139 	break;

   140       }

   141     } else {

   142       /* Saw no special markers, try to guess from the component IDs */

   143       int cid0 = cinfo->comp_info[0].component_id;

   144       int cid1 = cinfo->comp_info[1].component_id;

   145       int cid2 = cinfo->comp_info[2].component_id;

   146 

   147       if (cid0 == 1 && cid1 == 2 && cid2 == 3)

   148 	cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */

   149       else if (cid0 == 82 && cid1 == 71 && cid2 == 66)

   150 	cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */

   151       else {

   152 	TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);

   153 	cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */

   154       }

   155     }

   156     /* Always guess RGB is proper output colorspace. */

   157     cinfo->out_color_space = JCS_RGB;

   158     break;

   159     

   160   case 4:

   161     if (cinfo->saw_Adobe_marker) {

   162       switch (cinfo->Adobe_transform) {

   163       case 0:

   164 	cinfo->jpeg_color_space = JCS_CMYK;

   165 	break;

   166       case 2:

   167 	cinfo->jpeg_color_space = JCS_YCCK;

   168 	break;

   169       default:

   170 	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);

   171 	cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */

   172 	break;

   173       }

   174     } else {

   175       /* No special markers, assume straight CMYK. */

   176       cinfo->jpeg_color_space = JCS_CMYK;

   177     }

   178     cinfo->out_color_space = JCS_CMYK;

   179     break;

   180     

   181   default:

   182     cinfo->jpeg_color_space = JCS_UNKNOWN;

   183     cinfo->out_color_space = JCS_UNKNOWN;

   184     break;

   185   }

   186 

   187   /* Set defaults for other decompression parameters. */

   188   cinfo->scale_num = 1;		/* 1:1 scaling */

   189   cinfo->scale_denom = 1;

   190   cinfo->output_gamma = 1.0;

   191   cinfo->buffered_image = FALSE;

   192   cinfo->raw_data_out = FALSE;

   193   cinfo->dct_method = JDCT_DEFAULT;

   194   cinfo->do_fancy_upsampling = TRUE;

   195   cinfo->do_block_smoothing = TRUE;

   196   cinfo->quantize_colors = FALSE;

   197   /* We set these in case application only sets quantize_colors. */

   198   cinfo->dither_mode = JDITHER_FS;

   199 #ifdef QUANT_2PASS_SUPPORTED

   200   cinfo->two_pass_quantize = TRUE;

   201 #else

   202   cinfo->two_pass_quantize = FALSE;

   203 #endif

   204   cinfo->desired_number_of_colors = 256;

   205   cinfo->colormap = NULL;

   206   /* Initialize for no mode change in buffered-image mode. */

   207   cinfo->enable_1pass_quant = FALSE;

   208   cinfo->enable_external_quant = FALSE;

   209   cinfo->enable_2pass_quant = FALSE;

   210 }

   211 

   212 

   213 /*

   214  * Decompression startup: read start of JPEG datastream to see what's there.

   215  * Need only initialize JPEG object and supply a data source before calling.

   216  *

   217  * This routine will read as far as the first SOS marker (ie, actual start of

   218  * compressed data), and will save all tables and parameters in the JPEG

   219  * object.  It will also initialize the decompression parameters to default

   220  * values, and finally return JPEG_HEADER_OK.  On return, the application may

   221  * adjust the decompression parameters and then call jpeg_start_decompress.

   222  * (Or, if the application only wanted to determine the image parameters,

   223  * the data need not be decompressed.  In that case, call jpeg_abort or

   224  * jpeg_destroy to release any temporary space.)

   225  * If an abbreviated (tables only) datastream is presented, the routine will

   226  * return JPEG_HEADER_TABLES_ONLY upon reaching EOI.  The application may then

   227  * re-use the JPEG object to read the abbreviated image datastream(s).

   228  * It is unnecessary (but OK) to call jpeg_abort in this case.

   229  * The JPEG_SUSPENDED return code only occurs if the data source module

   230  * requests suspension of the decompressor.  In this case the application

   231  * should load more source data and then re-call jpeg_read_header to resume

   232  * processing.

   233  * If a non-suspending data source is used and require_image is TRUE, then the

   234  * return code need not be inspected since only JPEG_HEADER_OK is possible.

   235  *

   236  * This routine is now just a front end to jpeg_consume_input, with some

   237  * extra error checking.

   238  */

   239 

   240 GLOBAL(int)

   241 jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)

   242 {

   243   int retcode;

   244 

   245   if (cinfo->global_state != DSTATE_START &&

   246       cinfo->global_state != DSTATE_INHEADER)

   247     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

   248 

   249   retcode = jpeg_consume_input(cinfo);

   250 

   251   switch (retcode) {

   252   case JPEG_REACHED_SOS:

   253     retcode = JPEG_HEADER_OK;

   254     break;

   255   case JPEG_REACHED_EOI:

   256     if (require_image)		/* Complain if application wanted an image */

   257       ERREXIT(cinfo, JERR_NO_IMAGE);

   258     /* Reset to start state; it would be safer to require the application to

   259      * call jpeg_abort, but we can't change it now for compatibility reasons.

   260      * A side effect is to free any temporary memory (there shouldn't be any).

   261      */

   262     jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */

   263     retcode = JPEG_HEADER_TABLES_ONLY;

   264     break;

   265   case JPEG_SUSPENDED:

   266     /* no work */

   267     break;

   268   }

   269 

   270   return retcode;

   271 }

   272 

   273 

   274 /*

   275  * Consume data in advance of what the decompressor requires.

   276  * This can be called at any time once the decompressor object has

   277  * been created and a data source has been set up.

   278  *

   279  * This routine is essentially a state machine that handles a couple

   280  * of critical state-transition actions, namely initial setup and

   281  * transition from header scanning to ready-for-start_decompress.

   282  * All the actual input is done via the input controller's consume_input

   283  * method.

   284  */

   285 

   286 GLOBAL(int)

   287 jpeg_consume_input (j_decompress_ptr cinfo)

   288 {

   289   int retcode = JPEG_SUSPENDED;

   290 

   291   /* NB: every possible DSTATE value should be listed in this switch */

   292   switch (cinfo->global_state) {

   293   case DSTATE_START:

   294     /* Start-of-datastream actions: reset appropriate modules */

   295     (*cinfo->inputctl->reset_input_controller) (cinfo);

   296     /* Initialize application's data source module */

   297     (*cinfo->src->init_source) (cinfo);

   298     cinfo->global_state = DSTATE_INHEADER;

   299     /*FALLTHROUGH*/

   300   case DSTATE_INHEADER:

   301     retcode = (*cinfo->inputctl->consume_input) (cinfo);

   302     if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */

   303       /* Set up default parameters based on header data */

   304       default_decompress_parms(cinfo);

   305       /* Set global state: ready for start_decompress */

   306       cinfo->global_state = DSTATE_READY;

   307     }

   308     break;

   309   case DSTATE_READY:

   310     /* Can't advance past first SOS until start_decompress is called */

   311     retcode = JPEG_REACHED_SOS;

   312     break;

   313   case DSTATE_PRELOAD:

   314   case DSTATE_PRESCAN:

   315   case DSTATE_SCANNING:

   316   case DSTATE_RAW_OK:

   317   case DSTATE_BUFIMAGE:

   318   case DSTATE_BUFPOST:

   319   case DSTATE_STOPPING:

   320     retcode = (*cinfo->inputctl->consume_input) (cinfo);

   321     break;

   322   default:

   323     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

   324   }

   325   return retcode;

   326 }

   327 

   328 

   329 /*

   330  * Have we finished reading the input file?

   331  */

   332 

   333 GLOBAL(boolean)

   334 jpeg_input_complete (j_decompress_ptr cinfo)

   335 {

   336   /* Check for valid jpeg object */

   337   if (cinfo->global_state < DSTATE_START ||

   338       cinfo->global_state > DSTATE_STOPPING)

   339     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

   340   return cinfo->inputctl->eoi_reached;

   341 }

   342 

   343 

   344 /*

   345  * Is there more than one scan?

   346  */

   347 

   348 GLOBAL(boolean)

   349 jpeg_has_multiple_scans (j_decompress_ptr cinfo)

   350 {

   351   /* Only valid after jpeg_read_header completes */

   352   if (cinfo->global_state < DSTATE_READY ||

   353       cinfo->global_state > DSTATE_STOPPING)

   354     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

   355   return cinfo->inputctl->has_multiple_scans;

   356 }

   357 

   358 

   359 /*

   360  * Finish JPEG decompression.

   361  *

   362  * This will normally just verify the file trailer and release temp storage.

   363  *

   364  * Returns FALSE if suspended.  The return value need be inspected only if

   365  * a suspending data source is used.

   366  */

   367 

   368 GLOBAL(boolean)

   369 jpeg_finish_decompress (j_decompress_ptr cinfo)

   370 {

   371   if ((cinfo->global_state == DSTATE_SCANNING ||

   372        cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {

   373     /* Terminate final pass of non-buffered mode */

   374     if (cinfo->output_scanline < cinfo->output_height)

   375       ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);

   376     (*cinfo->master->finish_output_pass) (cinfo);

   377     cinfo->global_state = DSTATE_STOPPING;

   378   } else if (cinfo->global_state == DSTATE_BUFIMAGE) {

   379     /* Finishing after a buffered-image operation */

   380     cinfo->global_state = DSTATE_STOPPING;

   381   } else if (cinfo->global_state != DSTATE_STOPPING) {

   382     /* STOPPING = repeat call after a suspension, anything else is error */

   383     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

   384   }

   385   /* Read until EOI */

   386   while (! cinfo->inputctl->eoi_reached) {

   387     if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)

   388       return FALSE;		/* Suspend, come back later */

   389   }

   390   /* Do final cleanup */

   391   (*cinfo->src->term_source) (cinfo);

   392   /* We can use jpeg_abort to release memory and reset global_state */

   393   jpeg_abort((j_common_ptr) cinfo);

   394   return TRUE;

   395 }