172 lines
6.5 KiB
C
172 lines
6.5 KiB
C
/*
|
|
|
|
$Log: S:\jpeg32\src2\jddeflts.c_v $
|
|
*
|
|
* Rev 1.0 03 May 1995 08:45:54 JAR
|
|
* Initial entry
|
|
|
|
*/
|
|
/*
|
|
* jddeflts.c
|
|
*
|
|
* Copyright (C) 1991, 1992, Thomas G. Lane.
|
|
* This file is part of the Independent JPEG Group's software.
|
|
* For conditions of distribution and use, see the accompanying README file.
|
|
*
|
|
* This file contains optional default-setting code for the JPEG decompressor.
|
|
* User interfaces do not have to use this file, but those that don't use it
|
|
* must know more about the innards of the JPEG code.
|
|
*/
|
|
|
|
#include "jinclude.h"
|
|
|
|
|
|
/* Default do-nothing progress monitoring routine.
|
|
* This can be overridden by a user interface that wishes to
|
|
* provide progress monitoring; just set methods->progress_monitor
|
|
* after j_d_defaults is done. The routine will be called periodically
|
|
* during the decompression process.
|
|
*
|
|
* During any one pass, loopcounter increases from 0 up to (not including)
|
|
* looplimit; the step size is not necessarily 1. Both the step size and
|
|
* the limit may differ between passes. The expected total number of passes
|
|
* is in cinfo->total_passes, and the number of passes already completed is
|
|
* in cinfo->completed_passes. Thus the fraction of work completed may be
|
|
* estimated as
|
|
* completed_passes + (loopcounter/looplimit)
|
|
* ------------------------------------------
|
|
* total_passes
|
|
* ignoring the fact that the passes may not be equal amounts of work.
|
|
*
|
|
* When decompressing, the total_passes figure is an estimate that may be
|
|
* on the high side; completed_passes will jump by more than one if some
|
|
* passes are skipped.
|
|
*/
|
|
METHODDEF void
|
|
progress_monitor (decompress_info_ptr cinfo, long loopcounter, long looplimit)
|
|
{
|
|
/* do nothing */
|
|
}
|
|
|
|
|
|
/*
|
|
* Reload the input buffer after it's been emptied, and return the next byte.
|
|
* See the JGETC macro for calling conditions. Note in particular that
|
|
* read_jpeg_data may NOT return EOF. If no more data is available, it must
|
|
* exit via ERREXIT, or perhaps synthesize fake data (such as an RST marker).
|
|
* In the present implementation, we insert an EOI marker; this might not be
|
|
* appropriate for non-JFIF file formats, but it usually allows us to handle
|
|
* a truncated JFIF file.
|
|
*
|
|
* This routine can be overridden by the system-dependent user interface,
|
|
* in case the data source is not a stdio stream or some other special
|
|
* condition applies. Note, however, that this capability only applies for
|
|
* JFIF or similar serial-access JPEG file formats. The input file control
|
|
* module for a random-access format such as TIFF/JPEG would most likely
|
|
* override the read_jpeg_data method with its own routine.
|
|
*/
|
|
/*
|
|
METHODDEF int
|
|
read_jpeg_data (decompress_info_ptr cinfo)
|
|
{
|
|
cinfo->next_input_byte = cinfo->input_buffer + MIN_UNGET;
|
|
|
|
cinfo->bytes_in_buffer = (int) JFREAD(cinfo->input_file,
|
|
cinfo->next_input_byte,
|
|
JPEG_BUF_SIZE);
|
|
|
|
if (cinfo->bytes_in_buffer <= 0) {
|
|
WARNMS(cinfo->emethods, "Premature EOF in JPEG file");
|
|
cinfo->next_input_byte[0] = (char) 0xFF;
|
|
cinfo->next_input_byte[1] = (char) 0xD9; EOI marker
|
|
cinfo->bytes_in_buffer = 2;
|
|
}
|
|
|
|
return JGETC(cinfo);
|
|
}
|
|
|
|
*/
|
|
|
|
/* Default parameter setup for decompression.
|
|
*
|
|
* User interfaces that don't choose to use this routine must do their
|
|
* own setup of all these parameters. Alternately, you can call this
|
|
* to establish defaults and then alter parameters selectively. This
|
|
* is the recommended approach since, if we add any new parameters,
|
|
* your code will still work (they'll be set to reasonable defaults).
|
|
*
|
|
* standard_buffering should be TRUE to cause an input buffer to be allocated
|
|
* (the normal case); if FALSE, the user interface must provide a buffer.
|
|
* This option is most useful in the case that the buffer must not be freed
|
|
* at the end of an image. (For example, when reading a sequence of images
|
|
* from a single file, the remaining data in the buffer represents the
|
|
* start of the next image and mustn't be discarded.) To handle this,
|
|
* allocate the input buffer yourself at startup, WITHOUT using alloc_small
|
|
* (probably a direct call to malloc() instead). Then pass FALSE on each
|
|
* call to j_d_defaults to ensure the buffer state is not modified.
|
|
*
|
|
* If the source of the JPEG data is not a stdio stream, override the
|
|
* read_jpeg_data method with your own routine after calling j_d_defaults.
|
|
* You can still use the standard buffer if it's appropriate.
|
|
*
|
|
* CAUTION: if you want to decompress multiple images per run, it's necessary
|
|
* to call j_d_defaults before *each* call to jpeg_decompress, since subsidiary
|
|
* structures like the quantization tables are automatically freed during
|
|
* cleanup.
|
|
*/
|
|
|
|
GLOBAL void
|
|
j_d_defaults (decompress_info_ptr cinfo, boolean standard_buffering)
|
|
/* NB: the external methods must already be set up. */
|
|
{
|
|
short i;
|
|
|
|
/* Initialize pointers as needed to mark stuff unallocated. */
|
|
/* Outer application may fill in default tables for abbreviated files... */
|
|
cinfo->comp_info = NULL;
|
|
for (i = 0; i < NUM_QUANT_TBLS; i++)
|
|
cinfo->quant_tbl_ptrs[i] = NULL;
|
|
for (i = 0; i < NUM_HUFF_TBLS; i++) {
|
|
cinfo->dc_huff_tbl_ptrs[i] = NULL;
|
|
cinfo->ac_huff_tbl_ptrs[i] = NULL;
|
|
}
|
|
cinfo->colormap = NULL;
|
|
|
|
/* Default to RGB output */
|
|
/* UI can override by changing out_color_space */
|
|
cinfo->out_color_space = CS_RGB;
|
|
cinfo->jpeg_color_space = CS_UNKNOWN;
|
|
/* Setting any other value in jpeg_color_space overrides heuristics in */
|
|
/* jrdjfif.c. That might be useful when reading non-JFIF JPEG files, */
|
|
/* but ordinarily the UI shouldn't change it. */
|
|
|
|
/* Default to no gamma correction of output */
|
|
cinfo->output_gamma = 1.0;
|
|
|
|
/* Default to no color quantization */
|
|
cinfo->quantize_colors = FALSE;
|
|
/* but set reasonable default parameters for quantization, */
|
|
/* so that turning on quantize_colors is sufficient to do something useful */
|
|
cinfo->two_pass_quantize = TRUE;
|
|
cinfo->use_dithering = TRUE;
|
|
cinfo->desired_number_of_colors = 256;
|
|
|
|
/* Default to no smoothing */
|
|
cinfo->do_block_smoothing = FALSE;
|
|
cinfo->do_pixel_smoothing = FALSE;
|
|
|
|
/* Allocate memory for input buffer, unless outer application provides it. */
|
|
if (standard_buffering)
|
|
cinfo->input_buffer = (char *) (*cinfo->emethods->alloc_small)
|
|
((size_t) (JPEG_BUF_SIZE + MIN_UNGET));
|
|
|
|
cinfo->bytes_in_buffer = 0; /* initialize buffer to empty */
|
|
|
|
|
|
/* Install standard buffer-reloading method (outer code may override). */
|
|
/* cinfo->methods->read_jpeg_data = read_jpeg_data; */
|
|
|
|
/* Install default do-nothing progress monitoring method. */
|
|
cinfo->methods->progress_monitor = progress_monitor;
|
|
}
|