ReactOS 0.4.15-dev-8390-g075894b
jcparam.c
Go to the documentation of this file.
1/*
2 * jcparam.c
3 *
4 * Copyright (C) 1991-1998, Thomas G. Lane.
5 * Modified 2003-2019 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 optional default-setting code for the JPEG compressor.
10 * Applications do not have to use this file, but those that don't use it
11 * must know a lot more about the innards of the JPEG code.
12 */
13
14#define JPEG_INTERNALS
15#include "jinclude.h"
16#include "jpeglib.h"
17
18
19/*
20 * Quantization table setup routines
21 */
22
23GLOBAL(void)
25 const unsigned int *basic_table,
26 int scale_factor, boolean force_baseline)
27/* Define a quantization table equal to the basic_table times
28 * a scale factor (given as a percentage).
29 * If force_baseline is TRUE, the computed quantization table entries
30 * are limited to 1..255 for JPEG baseline compatibility.
31 */
32{
33 JQUANT_TBL ** qtblptr;
34 int i;
35 long temp;
36
37 /* Safety check to ensure start_compress not called yet. */
38 if (cinfo->global_state != CSTATE_START)
39 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
40
41 if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
42 ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
43
44 qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
45
46 if (*qtblptr == NULL)
47 *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
48
49 for (i = 0; i < DCTSIZE2; i++) {
50 temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
51 /* limit the values to the valid range */
52 if (temp <= 0L) temp = 1L;
53 if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
54 if (force_baseline && temp > 255L)
55 temp = 255L; /* limit to baseline range if requested */
56 (*qtblptr)->quantval[i] = (UINT16) temp;
57 }
58
59 /* Initialize sent_table FALSE so table will be written to JPEG file. */
60 (*qtblptr)->sent_table = FALSE;
61}
62
63
64/* These are the sample quantization tables given in JPEG spec section K.1.
65 * The spec says that the values given produce "good" quality, and
66 * when divided by 2, "very good" quality.
67 */
68static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
69 16, 11, 10, 16, 24, 40, 51, 61,
70 12, 12, 14, 19, 26, 58, 60, 55,
71 14, 13, 16, 24, 40, 57, 69, 56,
72 14, 17, 22, 29, 51, 87, 80, 62,
73 18, 22, 37, 56, 68, 109, 103, 77,
74 24, 35, 55, 64, 81, 104, 113, 92,
75 49, 64, 78, 87, 103, 121, 120, 101,
76 72, 92, 95, 98, 112, 100, 103, 99
77};
78static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
79 17, 18, 24, 47, 99, 99, 99, 99,
80 18, 21, 26, 66, 99, 99, 99, 99,
81 24, 26, 56, 99, 99, 99, 99, 99,
82 47, 66, 99, 99, 99, 99, 99, 99,
83 99, 99, 99, 99, 99, 99, 99, 99,
84 99, 99, 99, 99, 99, 99, 99, 99,
85 99, 99, 99, 99, 99, 99, 99, 99,
86 99, 99, 99, 99, 99, 99, 99, 99
87};
88
89
90GLOBAL(void)
92/* Set or change the 'quality' (quantization) setting, using default tables
93 * and straight percentage-scaling quality scales.
94 * This entry point allows different scalings for luminance and chrominance.
95 */
96{
97 /* Set up two quantization tables using the specified scaling */
99 cinfo->q_scale_factor[0], force_baseline);
101 cinfo->q_scale_factor[1], force_baseline);
102}
103
104
105GLOBAL(void)
107 boolean force_baseline)
108/* Set or change the 'quality' (quantization) setting, using default tables
109 * and a straight percentage-scaling quality scale. In most cases it's better
110 * to use jpeg_set_quality (below); this entry point is provided for
111 * applications that insist on a linear percentage scaling.
112 */
113{
114 /* Set up two quantization tables using the specified scaling */
119}
120
121
122GLOBAL(int)
124/* Convert a user-specified quality rating to a percentage scaling factor
125 * for an underlying quantization table, using our recommended scaling curve.
126 * The input 'quality' factor should be 0 (terrible) to 100 (very good).
127 */
128{
129 /* Safety limit on quality factor. Convert 0 to 1 to avoid zero divide. */
130 if (quality <= 0) quality = 1;
131 if (quality > 100) quality = 100;
132
133 /* The basic table is used as-is (scaling 100) for a quality of 50.
134 * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
135 * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
136 * to make all the table entries 1 (hence, minimum quantization loss).
137 * Qualities 1..50 are converted to scaling percentage 5000/Q.
138 */
139 if (quality < 50)
140 quality = 5000 / quality;
141 else
142 quality = 200 - quality*2;
143
144 return quality;
145}
146
147
148GLOBAL(void)
150/* Set or change the 'quality' (quantization) setting, using default tables.
151 * This is the standard quality-adjusting entry point for typical user
152 * interfaces; only those who want detailed control over quantization tables
153 * would use the preceding routines directly.
154 */
155{
156 /* Convert user 0-100 rating to percentage scaling */
158
159 /* Set up standard quality tables */
161}
162
163
164/*
165 * Reset standard Huffman tables
166 */
167
168LOCAL(void)
170{
171 if (cinfo->dc_huff_tbl_ptrs[0] != NULL)
173
174 if (cinfo->ac_huff_tbl_ptrs[0] != NULL)
176
177 if (cinfo->dc_huff_tbl_ptrs[1] != NULL)
179
180 if (cinfo->ac_huff_tbl_ptrs[1] != NULL)
182}
183
184
185/*
186 * Default parameter setup for compression.
187 *
188 * Applications that don't choose to use this routine must do their
189 * own setup of all these parameters. Alternately, you can call this
190 * to establish defaults and then alter parameters selectively. This
191 * is the recommended approach since, if we add any new parameters,
192 * your code will still work (they'll be set to reasonable defaults).
193 */
194
195GLOBAL(void)
197{
198 int i;
199
200 /* Safety check to ensure start_compress not called yet. */
201 if (cinfo->global_state != CSTATE_START)
202 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
203
204 /* Allocate comp_info array large enough for maximum component count.
205 * Array is made permanent in case application wants to compress
206 * multiple images at same param settings.
207 */
208 if (cinfo->comp_info == NULL)
209 cinfo->comp_info = (jpeg_component_info *)
210 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
212
213 /* Initialize everything not dependent on the color space */
214
215 cinfo->scale_num = 1; /* 1:1 scaling */
216 cinfo->scale_denom = 1;
217 cinfo->data_precision = BITS_IN_JSAMPLE;
218 /* Set up two quantization tables using default quality of 75 */
219 jpeg_set_quality(cinfo, 75, TRUE);
220 /* Reset standard Huffman tables */
221 std_huff_tables(cinfo);
222
223 /* Initialize default arithmetic coding conditioning */
224 for (i = 0; i < NUM_ARITH_TBLS; i++) {
225 cinfo->arith_dc_L[i] = 0;
226 cinfo->arith_dc_U[i] = 1;
227 cinfo->arith_ac_K[i] = 5;
228 }
229
230 /* Default is no multiple-scan output */
231 cinfo->scan_info = NULL;
232 cinfo->num_scans = 0;
233
234 /* Expect normal source image, not raw downsampled data */
235 cinfo->raw_data_in = FALSE;
236
237 /* The standard Huffman tables are only valid for 8-bit data precision.
238 * If the precision is higher, use arithmetic coding.
239 * (Alternatively, using Huffman coding would be possible with forcing
240 * optimization on so that usable tables will be computed, or by
241 * supplying default tables that are valid for the desired precision.)
242 * Otherwise, use Huffman coding by default.
243 */
244 cinfo->arith_code = cinfo->data_precision > 8 ? TRUE : FALSE;
245
246 /* By default, don't do extra passes to optimize entropy coding */
247 cinfo->optimize_coding = FALSE;
248
249 /* By default, use the simpler non-cosited sampling alignment */
250 cinfo->CCIR601_sampling = FALSE;
251
252 /* By default, apply fancy downsampling */
253 cinfo->do_fancy_downsampling = TRUE;
254
255 /* No input smoothing */
256 cinfo->smoothing_factor = 0;
257
258 /* DCT algorithm preference */
259 cinfo->dct_method = JDCT_DEFAULT;
260
261 /* No restart markers */
262 cinfo->restart_interval = 0;
263 cinfo->restart_in_rows = 0;
264
265 /* Fill in default JFIF marker parameters. Note that whether the marker
266 * will actually be written is determined by jpeg_set_colorspace.
267 *
268 * By default, the library emits JFIF version code 1.01.
269 * An application that wants to emit JFIF 1.02 extension markers should set
270 * JFIF_minor_version to 2. We could probably get away with just defaulting
271 * to 1.02, but there may still be some decoders in use that will complain
272 * about that; saying 1.01 should minimize compatibility problems.
273 *
274 * For wide gamut colorspaces (BG_RGB and BG_YCC), the major version will be
275 * overridden by jpeg_set_colorspace and set to 2.
276 */
277 cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
278 cinfo->JFIF_minor_version = 1;
279 cinfo->density_unit = 0; /* Pixel size is unknown by default */
280 cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
281 cinfo->Y_density = 1;
282
283 /* No color transform */
284 cinfo->color_transform = JCT_NONE;
285
286 /* Choose JPEG colorspace based on input space, set defaults accordingly */
287
289}
290
291
292/*
293 * Select an appropriate JPEG colorspace for in_color_space.
294 */
295
296GLOBAL(void)
298{
299 switch (cinfo->in_color_space) {
300 case JCS_UNKNOWN:
302 break;
303 case JCS_GRAYSCALE:
305 break;
306 case JCS_RGB:
308 break;
309 case JCS_YCbCr:
311 break;
312 case JCS_CMYK:
313 jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
314 break;
315 case JCS_YCCK:
317 break;
318 case JCS_BG_RGB:
319 /* No translation for now -- conversion to BG_YCC not yet supportet */
321 break;
322 case JCS_BG_YCC:
324 break;
325 default:
326 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
327 }
328}
329
330
331/*
332 * Set the JPEG colorspace, and choose colorspace-dependent default values.
333 */
334
335GLOBAL(void)
337{
339 int ci;
340
341#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
342 (compptr = &cinfo->comp_info[index], \
343 compptr->component_id = (id), \
344 compptr->h_samp_factor = (hsamp), \
345 compptr->v_samp_factor = (vsamp), \
346 compptr->quant_tbl_no = (quant), \
347 compptr->dc_tbl_no = (dctbl), \
348 compptr->ac_tbl_no = (actbl) )
349
350 /* Safety check to ensure start_compress not called yet. */
351 if (cinfo->global_state != CSTATE_START)
352 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
353
354 /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
355 * tables 1 for chrominance components.
356 */
357
358 cinfo->jpeg_color_space = colorspace;
359
360 cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
361 cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
362
363 switch (colorspace) {
364 case JCS_UNKNOWN:
365 cinfo->num_components = cinfo->input_components;
366 if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
367 ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
369 for (ci = 0; ci < cinfo->num_components; ci++) {
370 SET_COMP(ci, ci, 1,1, 0, 0,0);
371 }
372 break;
373 case JCS_GRAYSCALE:
374 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
375 cinfo->num_components = 1;
376 /* JFIF specifies component ID 1 */
377 SET_COMP(0, 0x01, 1,1, 0, 0,0);
378 break;
379 case JCS_RGB:
380 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
381 cinfo->num_components = 3;
382 SET_COMP(0, 0x52 /* 'R' */, 1,1, 0,
383 cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
384 cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
385 SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
386 SET_COMP(2, 0x42 /* 'B' */, 1,1, 0,
387 cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
388 cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
389 break;
390 case JCS_YCbCr:
391 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
392 cinfo->num_components = 3;
393 /* JFIF specifies component IDs 1,2,3 */
394 /* We default to 2x2 subsamples of chrominance */
395 SET_COMP(0, 0x01, 2,2, 0, 0,0);
396 SET_COMP(1, 0x02, 1,1, 1, 1,1);
397 SET_COMP(2, 0x03, 1,1, 1, 1,1);
398 break;
399 case JCS_CMYK:
400 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
401 cinfo->num_components = 4;
402 SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
403 SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
404 SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
405 SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
406 break;
407 case JCS_YCCK:
408 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
409 cinfo->num_components = 4;
410 SET_COMP(0, 0x01, 2,2, 0, 0,0);
411 SET_COMP(1, 0x02, 1,1, 1, 1,1);
412 SET_COMP(2, 0x03, 1,1, 1, 1,1);
413 SET_COMP(3, 0x04, 2,2, 0, 0,0);
414 break;
415 case JCS_BG_RGB:
416 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
417 cinfo->JFIF_major_version = 2; /* Set JFIF major version = 2 */
418 cinfo->num_components = 3;
419 /* Add offset 0x20 to the normal R/G/B component IDs */
420 SET_COMP(0, 0x72 /* 'r' */, 1,1, 0,
421 cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
422 cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
423 SET_COMP(1, 0x67 /* 'g' */, 1,1, 0, 0,0);
424 SET_COMP(2, 0x62 /* 'b' */, 1,1, 0,
425 cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
426 cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
427 break;
428 case JCS_BG_YCC:
429 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
430 cinfo->JFIF_major_version = 2; /* Set JFIF major version = 2 */
431 cinfo->num_components = 3;
432 /* Add offset 0x20 to the normal Cb/Cr component IDs */
433 /* We default to 2x2 subsamples of chrominance */
434 SET_COMP(0, 0x01, 2,2, 0, 0,0);
435 SET_COMP(1, 0x22, 1,1, 1, 1,1);
436 SET_COMP(2, 0x23, 1,1, 1, 1,1);
437 break;
438 default:
439 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
440 }
441}
442
443
444#ifdef C_PROGRESSIVE_SUPPORTED
445
447fill_a_scan (jpeg_scan_info * scanptr, int ci,
448 int Ss, int Se, int Ah, int Al)
449/* Support routine: generate one scan for specified component */
450{
451 scanptr->comps_in_scan = 1;
452 scanptr->component_index[0] = ci;
453 scanptr->Ss = Ss;
454 scanptr->Se = Se;
455 scanptr->Ah = Ah;
456 scanptr->Al = Al;
457 scanptr++;
458 return scanptr;
459}
460
462fill_scans (jpeg_scan_info * scanptr, int ncomps,
463 int Ss, int Se, int Ah, int Al)
464/* Support routine: generate one scan for each component */
465{
466 int ci;
467
468 for (ci = 0; ci < ncomps; ci++) {
469 scanptr->comps_in_scan = 1;
470 scanptr->component_index[0] = ci;
471 scanptr->Ss = Ss;
472 scanptr->Se = Se;
473 scanptr->Ah = Ah;
474 scanptr->Al = Al;
475 scanptr++;
476 }
477 return scanptr;
478}
479
481fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
482/* Support routine: generate interleaved DC scan if possible, else N scans */
483{
484 int ci;
485
486 if (ncomps <= MAX_COMPS_IN_SCAN) {
487 /* Single interleaved DC scan */
488 scanptr->comps_in_scan = ncomps;
489 for (ci = 0; ci < ncomps; ci++)
490 scanptr->component_index[ci] = ci;
491 scanptr->Ss = scanptr->Se = 0;
492 scanptr->Ah = Ah;
493 scanptr->Al = Al;
494 scanptr++;
495 } else {
496 /* Noninterleaved DC scan for each component */
497 scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
498 }
499 return scanptr;
500}
501
502
503/*
504 * Create a recommended progressive-JPEG script.
505 * cinfo->num_components and cinfo->jpeg_color_space must be correct.
506 */
507
508GLOBAL(void)
509jpeg_simple_progression (j_compress_ptr cinfo)
510{
511 int ncomps = cinfo->num_components;
512 int nscans;
513 jpeg_scan_info * scanptr;
514
515 /* Safety check to ensure start_compress not called yet. */
516 if (cinfo->global_state != CSTATE_START)
517 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
518
519 /* Figure space needed for script. Calculation must match code below! */
520 if (ncomps == 3 &&
521 (cinfo->jpeg_color_space == JCS_YCbCr ||
522 cinfo->jpeg_color_space == JCS_BG_YCC)) {
523 /* Custom script for YCC color images. */
524 nscans = 10;
525 } else {
526 /* All-purpose script for other color spaces. */
527 if (ncomps > MAX_COMPS_IN_SCAN)
528 nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
529 else
530 nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
531 }
532
533 /* Allocate space for script.
534 * We need to put it in the permanent pool in case the application performs
535 * multiple compressions without changing the settings. To avoid a memory
536 * leak if jpeg_simple_progression is called repeatedly for the same JPEG
537 * object, we try to re-use previously allocated space, and we allocate
538 * enough space to handle YCC even if initially asked for grayscale.
539 */
540 if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
541 cinfo->script_space_size = MAX(nscans, 10);
542 cinfo->script_space = (jpeg_scan_info *)
543 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
545 }
546 scanptr = cinfo->script_space;
547 cinfo->scan_info = scanptr;
548 cinfo->num_scans = nscans;
549
550 if (ncomps == 3 &&
551 (cinfo->jpeg_color_space == JCS_YCbCr ||
552 cinfo->jpeg_color_space == JCS_BG_YCC)) {
553 /* Custom script for YCC color images. */
554 /* Initial DC scan */
555 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
556 /* Initial AC scan: get some luma data out in a hurry */
557 scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
558 /* Chroma data is too small to be worth expending many scans on */
559 scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
560 scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
561 /* Complete spectral selection for luma AC */
562 scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
563 /* Refine next bit of luma AC */
564 scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
565 /* Finish DC successive approximation */
566 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
567 /* Finish AC successive approximation */
568 scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
569 scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
570 /* Luma bottom bit comes last since it's usually largest scan */
571 scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
572 } else {
573 /* All-purpose script for other color spaces. */
574 /* Successive approximation first pass */
575 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
576 scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
577 scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
578 /* Successive approximation second pass */
579 scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
580 /* Successive approximation final pass */
581 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
582 scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
583 }
584}
585
586#endif /* C_PROGRESSIVE_SUPPORTED */
unsigned short UINT16
#define MAX(x, y)
Definition: rdesktop.h:175
#define SIZEOF(_ar)
Definition: calc.h:97
char boolean force_baseline
Definition: cdjpeg.h:137
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
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_alloc_quant_table(j_common_ptr cinfo)
Definition: jcomapi.c:87
jpeg_std_huff_table(j_common_ptr cinfo, boolean isDC, int tblno)
Definition: jcomapi.c:117
#define SET_COMP(index, id, hsamp, vsamp, quant, dctbl, actbl)
jpeg_default_qtables(j_compress_ptr cinfo, boolean force_baseline)
Definition: jcparam.c:91
jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
Definition: jcparam.c:336
std_huff_tables(j_compress_ptr cinfo)
Definition: jcparam.c:169
jpeg_set_quality(j_compress_ptr cinfo, int quality, boolean force_baseline)
Definition: jcparam.c:149
jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor, boolean force_baseline)
Definition: jcparam.c:106
static const unsigned int std_luminance_quant_tbl[DCTSIZE2]
Definition: jcparam.c:68
jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl, const unsigned int *basic_table, int scale_factor, boolean force_baseline)
Definition: jcparam.c:24
jpeg_set_defaults(j_compress_ptr cinfo)
Definition: jcparam.c:196
static const unsigned int std_chrominance_quant_tbl[DCTSIZE2]
Definition: jcparam.c:78
jpeg_default_colorspace(j_compress_ptr cinfo)
Definition: jcparam.c:297
jpeg_quality_scaling(int quality)
Definition: jcparam.c:123
jpeg_component_info * compptr
Definition: jdct.h:238
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
#define ERREXIT2(cinfo, code, p1, p2)
Definition: jerror.h:216
#define MAX_COMPONENTS
Definition: jmorecfg.h:45
#define LOCAL(type)
Definition: jmorecfg.h:289
#define BITS_IN_JSAMPLE
Definition: jmorecfg.h:33
#define GLOBAL(type)
Definition: jmorecfg.h:291
#define CSTATE_START
Definition: jpegint.h:26
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
#define JDCT_DEFAULT
Definition: jpeglib.h:247
@ JCT_NONE
Definition: jpeglib.h:234
@ JCT_SUBTRACT_GREEN
Definition: jpeglib.h:235
#define NUM_ARITH_TBLS
Definition: jpeglib.h:54
int const unsigned int * basic_table
Definition: jpeglib.h:1000
J_COLOR_SPACE colorspace
Definition: jpeglib.h:990
J_COLOR_SPACE
Definition: jpeglib.h:220
@ 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 scale_factor
Definition: jpeglib.h:995
#define NUM_QUANT_TBLS
Definition: jpeglib.h:52
int which_tbl
Definition: jpeglib.h:999
int quality
Definition: jpeglib.h:992
#define JPOOL_PERMANENT
Definition: jpeglib.h:807
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:55
#define DCTSIZE2
Definition: jpeglib.h:51
#define L(x)
Definition: ntvdm.h:50
#define long
Definition: qsort.c:33
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
static calc_node_t temp
Definition: rpn_ieee.c:38
const jpeg_scan_info * scan_info
Definition: jpeglib.h:351
J_COLOR_SPACE jpeg_color_space
Definition: jpeglib.h:331
jpeg_scan_info * script_space
Definition: jpeglib.h:452
int component_index[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:200
int comps_in_scan
Definition: jpeglib.h:199
#define const
Definition: zconf.h:233