ReactOS 0.4.15-dev-7670-g69b08be
jcapimin.c
Go to the documentation of this file.
1/*
2 * jcapimin.c
3 *
4 * Copyright (C) 1994-1998, Thomas G. Lane.
5 * Modified 2003-2010 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 compression half
10 * of the JPEG library. These are the "minimum" API routines that may be
11 * needed in either the normal full-compression case or the transcoding-only
12 * case.
13 *
14 * Most of the routines intended to be called directly by an application
15 * are in this file or in jcapistd.c. But also see jcparam.c for
16 * parameter-setup helper routines, jcomapi.c for routines shared by
17 * compression and decompression, and jctrans.c for the transcoding case.
18 */
19
20#define JPEG_INTERNALS
21#include "jinclude.h"
22#include "jpeglib.h"
23
24
25/*
26 * Initialization of a JPEG compression 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_compress_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_compress_struct));
53 cinfo->err = err;
54 cinfo->client_data = client_data;
55 }
56 cinfo->is_decompressor = FALSE;
57
58 /* Initialize a memory manager instance for this object */
60
61 /* Zero out pointers to permanent structures. */
62 cinfo->progress = NULL;
63 cinfo->dest = NULL;
64
65 cinfo->comp_info = NULL;
66
67 for (i = 0; i < NUM_QUANT_TBLS; i++) {
68 cinfo->quant_tbl_ptrs[i] = NULL;
69 cinfo->q_scale_factor[i] = 100;
70 }
71
72 for (i = 0; i < NUM_HUFF_TBLS; i++) {
73 cinfo->dc_huff_tbl_ptrs[i] = NULL;
74 cinfo->ac_huff_tbl_ptrs[i] = NULL;
75 }
76
77 /* Must do it here for emit_dqt in case jpeg_write_tables is used */
78 cinfo->block_size = DCTSIZE;
79 cinfo->natural_order = jpeg_natural_order;
80 cinfo->lim_Se = DCTSIZE2-1;
81
82 cinfo->script_space = NULL;
83
84 cinfo->input_gamma = 1.0; /* in case application forgets */
85
86 /* OK, I'm ready */
87 cinfo->global_state = CSTATE_START;
88}
89
90
91/*
92 * Destruction of a JPEG compression object
93 */
94
95GLOBAL(void)
97{
98 jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
99}
100
101
102/*
103 * Abort processing of a JPEG compression operation,
104 * but don't destroy the object itself.
105 */
106
107GLOBAL(void)
109{
110 jpeg_abort((j_common_ptr) cinfo); /* use common routine */
111}
112
113
114/*
115 * Forcibly suppress or un-suppress all quantization and Huffman tables.
116 * Marks all currently defined tables as already written (if suppress)
117 * or not written (if !suppress). This will control whether they get emitted
118 * by a subsequent jpeg_start_compress call.
119 *
120 * This routine is exported for use by applications that want to produce
121 * abbreviated JPEG datastreams. It logically belongs in jcparam.c, but
122 * since it is called by jpeg_start_compress, we put it here --- otherwise
123 * jcparam.o would be linked whether the application used it or not.
124 */
125
126GLOBAL(void)
128{
129 int i;
130 JQUANT_TBL * qtbl;
131 JHUFF_TBL * htbl;
132
133 for (i = 0; i < NUM_QUANT_TBLS; i++) {
134 if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL)
135 qtbl->sent_table = suppress;
136 }
137
138 for (i = 0; i < NUM_HUFF_TBLS; i++) {
139 if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL)
140 htbl->sent_table = suppress;
141 if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL)
142 htbl->sent_table = suppress;
143 }
144}
145
146
147/*
148 * Finish JPEG compression.
149 *
150 * If a multipass operating mode was selected, this may do a great deal of
151 * work including most of the actual output.
152 */
153
154GLOBAL(void)
156{
157 JDIMENSION iMCU_row;
158
159 if (cinfo->global_state == CSTATE_SCANNING ||
160 cinfo->global_state == CSTATE_RAW_OK) {
161 /* Terminate first pass */
162 if (cinfo->next_scanline < cinfo->image_height)
163 ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
164 (*cinfo->master->finish_pass) (cinfo);
165 } else if (cinfo->global_state != CSTATE_WRCOEFS)
166 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
167 /* Perform any remaining passes */
168 while (! cinfo->master->is_last_pass) {
169 (*cinfo->master->prepare_for_pass) (cinfo);
170 for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
171 if (cinfo->progress != NULL) {
172 cinfo->progress->pass_counter = (long) iMCU_row;
173 cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
174 (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
175 }
176 /* We bypass the main controller and invoke coef controller directly;
177 * all work is being done from the coefficient buffer.
178 */
179 if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL))
180 ERREXIT(cinfo, JERR_CANT_SUSPEND);
181 }
182 (*cinfo->master->finish_pass) (cinfo);
183 }
184 /* Write EOI, do final cleanup */
185 (*cinfo->marker->write_file_trailer) (cinfo);
186 (*cinfo->dest->term_destination) (cinfo);
187 /* We can use jpeg_abort to release memory and reset global_state */
188 jpeg_abort((j_common_ptr) cinfo);
189}
190
191
192/*
193 * Write a special marker.
194 * This is only recommended for writing COM or APPn markers.
195 * Must be called after jpeg_start_compress() and before
196 * first call to jpeg_write_scanlines() or jpeg_write_raw_data().
197 */
198
199GLOBAL(void)
201 const JOCTET *dataptr, unsigned int datalen)
202{
204
205 if (cinfo->next_scanline != 0 ||
206 (cinfo->global_state != CSTATE_SCANNING &&
207 cinfo->global_state != CSTATE_RAW_OK &&
208 cinfo->global_state != CSTATE_WRCOEFS))
209 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
210
211 (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
212 write_marker_byte = cinfo->marker->write_marker_byte; /* copy for speed */
213 while (datalen--) {
214 (*write_marker_byte) (cinfo, *dataptr);
215 dataptr++;
216 }
217}
218
219/* Same, but piecemeal. */
220
221GLOBAL(void)
223{
224 if (cinfo->next_scanline != 0 ||
225 (cinfo->global_state != CSTATE_SCANNING &&
226 cinfo->global_state != CSTATE_RAW_OK &&
227 cinfo->global_state != CSTATE_WRCOEFS))
228 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
229
230 (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
231}
232
233GLOBAL(void)
235{
236 (*cinfo->marker->write_marker_byte) (cinfo, val);
237}
238
239
240/*
241 * Alternate compression function: just write an abbreviated table file.
242 * Before calling this, all parameters and a data destination must be set up.
243 *
244 * To produce a pair of files containing abbreviated tables and abbreviated
245 * image data, one would proceed as follows:
246 *
247 * initialize JPEG object
248 * set JPEG parameters
249 * set destination to table file
250 * jpeg_write_tables(cinfo);
251 * set destination to image file
252 * jpeg_start_compress(cinfo, FALSE);
253 * write data...
254 * jpeg_finish_compress(cinfo);
255 *
256 * jpeg_write_tables has the side effect of marking all tables written
257 * (same as jpeg_suppress_tables(..., TRUE)). Thus a subsequent start_compress
258 * will not re-emit the tables unless it is passed write_all_tables=TRUE.
259 */
260
261GLOBAL(void)
263{
264 if (cinfo->global_state != CSTATE_START)
265 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
266
267 /* (Re)initialize error mgr and destination modules */
268 (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
269 (*cinfo->dest->init_destination) (cinfo);
270 /* Initialize the marker writer ... bit of a crock to do it here. */
271 jinit_marker_writer(cinfo);
272 /* Write them tables! */
273 (*cinfo->marker->write_tables_only) (cinfo);
274 /* And clean up. */
275 (*cinfo->dest->term_destination) (cinfo);
276 /*
277 * In library releases up through v6a, we called jpeg_abort() here to free
278 * any working memory allocated by the destination manager and marker
279 * writer. Some applications had a problem with that: they allocated space
280 * of their own from the library memory manager, and didn't want it to go
281 * away during write_tables. So now we do nothing. This will cause a
282 * memory leak if an app calls write_tables repeatedly without doing a full
283 * compression cycle or otherwise resetting the JPEG object. However, that
284 * seems less bad than unexpectedly freeing memory in the normal case.
285 * An app that prefers the old behavior can call jpeg_abort for itself after
286 * each call to jpeg_write_tables().
287 */
288}
#define SIZEOF(_ar)
Definition: calc.h:97
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
static const WCHAR version[]
Definition: asmname.c:66
GLuint GLfloat * val
Definition: glext.h:7180
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_write_m_byte(j_compress_ptr cinfo, int val)
Definition: jcapimin.c:234
jpeg_destroy_compress(j_compress_ptr cinfo)
Definition: jcapimin.c:96
jpeg_write_m_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
Definition: jcapimin.c:222
jpeg_finish_compress(j_compress_ptr cinfo)
Definition: jcapimin.c:155
jpeg_write_tables(j_compress_ptr cinfo)
Definition: jcapimin.c:262
jpeg_write_marker(j_compress_ptr cinfo, int marker, const JOCTET *dataptr, unsigned int datalen)
Definition: jcapimin.c:200
jpeg_suppress_tables(j_compress_ptr cinfo, boolean suppress)
Definition: jcapimin.c:127
jpeg_CreateCompress(j_compress_ptr cinfo, int version, size_t structsize)
Definition: jcapimin.c:31
jpeg_abort_compress(j_compress_ptr cinfo)
Definition: jcapimin.c:108
write_marker_byte(j_compress_ptr cinfo, int val)
Definition: jcmarker.c:499
jinit_marker_writer(j_compress_ptr cinfo)
Definition: jcmarker.c:699
jpeg_abort(j_common_ptr cinfo)
Definition: jcomapi.c:30
jpeg_destroy(j_common_ptr cinfo)
Definition: jcomapi.c:70
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
#define ERREXIT2(cinfo, code, p1, p2)
Definition: jerror.h:216
jinit_memory_mgr(j_common_ptr cinfo)
Definition: jmemmgr.c:1025
unsigned int JDIMENSION
Definition: jmorecfg.h:229
char JOCTET
Definition: jmorecfg.h:167
#define JMETHOD(type, methodname, arglist)
Definition: jmorecfg.h:308
#define GLOBAL(type)
Definition: jmorecfg.h:291
#define CSTATE_RAW_OK
Definition: jpegint.h:28
#define CSTATE_WRCOEFS
Definition: jpegint.h:29
#define CSTATE_START
Definition: jpegint.h:26
#define CSTATE_SCANNING
Definition: jpegint.h:27
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
int const JOCTET unsigned int datalen
Definition: jpeglib.h:1031
#define DCTSIZE
Definition: jpeglib.h:50
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:77
boolean suppress
Definition: jpeglib.h:1006
int marker
Definition: jpeglib.h:1030
#define NUM_HUFF_TBLS
Definition: jpeglib.h:53
int size_t structsize
Definition: jpeglib.h:966
#define NUM_QUANT_TBLS
Definition: jpeglib.h:52
#define JPEG_LIB_VERSION
Definition: jpeglib.h:40
int const JOCTET * dataptr
Definition: jpeglib.h:1031
#define DCTSIZE2
Definition: jpeglib.h:51
const int jpeg_natural_order[DCTSIZE2+16]
Definition: jutils.c:54
#define long
Definition: qsort.c:33
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define err(...)
boolean sent_table
Definition: jpeglib.h:119
boolean sent_table
Definition: jpeglib.h:103
#define MEMZERO(addr, type, size)
Definition: svc_dg.c:324
#define const
Definition: zconf.h:233