ReactOS 0.4.15-dev-8127-g6338913
jdapimin.c
Go to the documentation of this file.
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
30GLOBAL(void)
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 */
38 ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
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 */
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 */
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;
78
79 /* And initialize the overall input controller. */
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
91GLOBAL(void)
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
103GLOBAL(void)
105{
106 jpeg_abort((j_common_ptr) cinfo); /* use common routine */
107}
108
109
110/*
111 * Set default decompression parameters.
112 */
113
114LOCAL(void)
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
244GLOBAL(int)
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
290GLOBAL(int)
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 */
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
337GLOBAL(boolean)
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
352GLOBAL(boolean)
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
372GLOBAL(boolean)
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}
#define SIZEOF(_ar)
Definition: calc.h:97
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
static const WCHAR version[]
Definition: asmname.c:66
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
jpeg_abort(j_common_ptr cinfo)
Definition: jcomapi.c:30
jpeg_destroy(j_common_ptr cinfo)
Definition: jcomapi.c:70
jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
Definition: jdapimin.c:31
default_decompress_parms(j_decompress_ptr cinfo)
Definition: jdapimin.c:115
jpeg_abort_decompress(j_decompress_ptr cinfo)
Definition: jdapimin.c:104
jpeg_consume_input(j_decompress_ptr cinfo)
Definition: jdapimin.c:291
jpeg_destroy_decompress(j_decompress_ptr cinfo)
Definition: jdapimin.c:92
jpeg_has_multiple_scans(j_decompress_ptr cinfo)
Definition: jdapimin.c:353
jpeg_finish_decompress(j_decompress_ptr cinfo)
Definition: jdapimin.c:373
jpeg_read_header(j_decompress_ptr cinfo, boolean require_image)
Definition: jdapimin.c:245
jpeg_input_complete(j_decompress_ptr cinfo)
Definition: jdapimin.c:338
jinit_input_controller(j_decompress_ptr cinfo)
Definition: jdinput.c:642
jinit_marker_reader(j_decompress_ptr cinfo)
Definition: jdmarker.c:1408
#define WARNMS1(cinfo, code, p1)
Definition: jerror.h:254
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
#define ERREXIT2(cinfo, code, p1, p2)
Definition: jerror.h:216
#define TRACEMS3(cinfo, lvl, code, p1, p2, p3)
Definition: jerror.h:277
jinit_memory_mgr(j_common_ptr cinfo)
Definition: jmemmgr.c:1025
#define LOCAL(type)
Definition: jmorecfg.h:289
#define GLOBAL(type)
Definition: jmorecfg.h:291
#define DSTATE_BUFIMAGE
Definition: jpegint.h:37
#define DSTATE_INHEADER
Definition: jpegint.h:31
#define DSTATE_READY
Definition: jpegint.h:32
#define DSTATE_START
Definition: jpegint.h:30
#define DSTATE_PRELOAD
Definition: jpegint.h:33
#define DSTATE_PRESCAN
Definition: jpegint.h:34
#define DSTATE_SCANNING
Definition: jpegint.h:35
#define DSTATE_RAW_OK
Definition: jpegint.h:36
#define DSTATE_BUFPOST
Definition: jpegint.h:38
#define DSTATE_STOPPING
Definition: jpegint.h:40
#define JPEG_HEADER_TABLES_ONLY
Definition: jpeglib.h:1047
#define JDCT_DEFAULT
Definition: jpeglib.h:247
@ JDITHER_FS
Definition: jpeglib.h:258
#define JPEG_REACHED_SOS
Definition: jpeglib.h:1076
#define NUM_HUFF_TBLS
Definition: jpeglib.h:53
@ JCS_YCCK
Definition: jpeglib.h:226
@ JCS_BG_RGB
Definition: jpeglib.h:227
@ JCS_BG_YCC
Definition: jpeglib.h:228
@ JCS_UNKNOWN
Definition: jpeglib.h:221
@ JCS_YCbCr
Definition: jpeglib.h:224
@ JCS_CMYK
Definition: jpeglib.h:225
@ JCS_GRAYSCALE
Definition: jpeglib.h:222
@ JCS_RGB
Definition: jpeglib.h:223
int size_t structsize
Definition: jpeglib.h:966
boolean require_image
Definition: jpeglib.h:1043
#define JPEG_REACHED_EOI
Definition: jpeglib.h:1077
#define NUM_QUANT_TBLS
Definition: jpeglib.h:52
#define JPEG_LIB_VERSION
Definition: jpeglib.h:40
#define JPEG_HEADER_OK
Definition: jpeglib.h:1046
#define JPEG_SUSPENDED
Definition: jpeglib.h:1045
#define for
Definition: utility.h:88
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define err(...)
#define MEMZERO(addr, type, size)
Definition: svc_dg.c:324