Debian Codegraph @

frmts/jpeg/libjpeg/jcparam.c

raw
1 /*
2 * jcparam.c
3 *
4 * Copyright (C) 1991-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 optional default-setting code for the JPEG compressor.
9 * Applications do not have to use this file, but those that don't use it
10 * must know a lot more about the innards of the JPEG code.
11 */
12
13 #define JPEG_INTERNALS
14 #include "jinclude.h"
15 #include "jpeglib.h"
16
17
18 /*
19 * Quantization table setup routines
20 */
21
22 GLOBAL(void)
23 jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
24 const unsigned int *basic_table,
25 int scale_factor, boolean force_baseline)
26 /* Define a quantization table equal to the basic_table times
27 * a scale factor (given as a percentage).
28 * If force_baseline is TRUE, the computed quantization table entries
29 * are limited to 1..255 for JPEG baseline compatibility.
30 */
31 {
32 JQUANT_TBL ** qtblptr;
33 int i;
34 long temp;
35
36 /* Safety check to ensure start_compress not called yet. */
37 if (cinfo->global_state != CSTATE_START)
38 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
39
40 if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
41 ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
42
43 qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
44
45 if (*qtblptr == NULL)
46 *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
47
48 for (i = 0; i < DCTSIZE2; i++) {
49 temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
50 /* limit the values to the valid range */
51 if (temp <= 0L) temp = 1L;
52 if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
53 if (force_baseline && temp > 255L)
54 temp = 255L; /* limit to baseline range if requested */
55 (*qtblptr)->quantval[i] = (UINT16) temp;
56 }
57
58 /* Initialize sent_table FALSE so table will be written to JPEG file. */
59 (*qtblptr)->sent_table = FALSE;
60 }
61
62
63 GLOBAL(void)
64 jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
65 boolean force_baseline)
66 /* Set or change the 'quality' (quantization) setting, using default tables
67 * and a straight percentage-scaling quality scale. In most cases it's better
68 * to use jpeg_set_quality (below); this entry point is provided for
69 * applications that insist on a linear percentage scaling.
70 */
71 {
72 /* These are the sample quantization tables given in JPEG spec section K.1.
73 * The spec says that the values given produce "good" quality, and
74 * when divided by 2, "very good" quality.
75 */
76 static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
77 16, 11, 10, 16, 24, 40, 51, 61,
78 12, 12, 14, 19, 26, 58, 60, 55,
79 14, 13, 16, 24, 40, 57, 69, 56,
80 14, 17, 22, 29, 51, 87, 80, 62,
81 18, 22, 37, 56, 68, 109, 103, 77,
82 24, 35, 55, 64, 81, 104, 113, 92,
83 49, 64, 78, 87, 103, 121, 120, 101,
84 72, 92, 95, 98, 112, 100, 103, 99
85 };
86 static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
87 17, 18, 24, 47, 99, 99, 99, 99,
88 18, 21, 26, 66, 99, 99, 99, 99,
89 24, 26, 56, 99, 99, 99, 99, 99,
90 47, 66, 99, 99, 99, 99, 99, 99,
91 99, 99, 99, 99, 99, 99, 99, 99,
92 99, 99, 99, 99, 99, 99, 99, 99,
93 99, 99, 99, 99, 99, 99, 99, 99,
94 99, 99, 99, 99, 99, 99, 99, 99
95 };
96
97 /* Set up two quantization tables using the specified scaling */
98 jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
99 scale_factor, force_baseline);
100 jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
101 scale_factor, force_baseline);
102 }
103
104
105 GLOBAL(int)
106 jpeg_quality_scaling (int quality)
107 /* Convert a user-specified quality rating to a percentage scaling factor
108 * for an underlying quantization table, using our recommended scaling curve.
109 * The input 'quality' factor should be 0 (terrible) to 100 (very good).
110 */
111 {
112 /* Safety limit on quality factor. Convert 0 to 1 to avoid zero divide. */
113 if (quality <= 0) quality = 1;
114 if (quality > 100) quality = 100;
115
116 /* The basic table is used as-is (scaling 100) for a quality of 50.
117 * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
118 * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
119 * to make all the table entries 1 (hence, minimum quantization loss).
120 * Qualities 1..50 are converted to scaling percentage 5000/Q.
121 */
122 if (quality < 50)
123 quality = 5000 / quality;
124 else
125 quality = 200 - quality*2;
126
127 return quality;
128 }
129
130
131 GLOBAL(void)
132 jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
133 /* Set or change the 'quality' (quantization) setting, using default tables.
134 * This is the standard quality-adjusting entry point for typical user
135 * interfaces; only those who want detailed control over quantization tables
136 * would use the preceding three routines directly.
137 */
138 {
139 /* Convert user 0-100 rating to percentage scaling */
140 quality = jpeg_quality_scaling(quality);
141
142 /* Set up standard quality tables */
143 jpeg_set_linear_quality(cinfo, quality, force_baseline);
144 }
145
146
147 /*
148 * Huffman table setup routines
149 */
150
151 LOCAL(void)
152 add_huff_table (j_compress_ptr cinfo,
153 JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
154 /* Define a Huffman table */
155 {
156 int nsymbols, len;
157
158 if (*htblptr == NULL)
159 *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
160
161 /* Copy the number-of-symbols-of-each-code-length counts */
162 MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
163
164 /* Validate the counts. We do this here mainly so we can copy the right
165 * number of symbols from the val[] array, without risking marching off
166 * the end of memory. jchuff.c will do a more thorough test later.
167 */
168 nsymbols = 0;
169 for (len = 1; len <= 16; len++)
170 nsymbols += bits[len];
171 if (nsymbols < 1 || nsymbols > 256)
172 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
173
174 MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
175
176 /* Initialize sent_table FALSE so table will be written to JPEG file. */
177 (*htblptr)->sent_table = FALSE;
178 }
179
180
181 #if BITS_IN_JSAMPLE == 8
182 LOCAL(void)
183 std_huff_tables (j_compress_ptr cinfo)
184 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
185 /* IMPORTANT: these are only valid for 8-bit data precision! */
186 {
187 static const UINT8 bits_dc_luminance[17] =
188 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
189 static const UINT8 val_dc_luminance[] =
190 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
191
192 static const UINT8 bits_dc_chrominance[17] =
193 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
194 static const UINT8 val_dc_chrominance[] =
195 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
196
197 static const UINT8 bits_ac_luminance[17] =
198 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
199 static const UINT8 val_ac_luminance[] =
200 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
201 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
202 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
203 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
204 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
205 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
206 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
207 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
208 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
209 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
210 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
211 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
212 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
213 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
214 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
215 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
216 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
217 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
218 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
219 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
220 0xf9, 0xfa };
221
222 static const UINT8 bits_ac_chrominance[17] =
223 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
224 static const UINT8 val_ac_chrominance[] =
225 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
226 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
227 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
228 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
229 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
230 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
231 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
232 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
233 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
234 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
235 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
236 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
237 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
238 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
239 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
240 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
241 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
242 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
243 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
244 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
245 0xf9, 0xfa };
246
247 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
248 bits_dc_luminance, val_dc_luminance);
249 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
250 bits_ac_luminance, val_ac_luminance);
251 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
252 bits_dc_chrominance, val_dc_chrominance);
253 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
254 bits_ac_chrominance, val_ac_chrominance);
255 }
256 #endif /* BITS_IN_JSAMPLE == 8 */
257
258 #if BITS_IN_JSAMPLE == 12
259 LOCAL(void)
260 std_huff_tables (j_compress_ptr cinfo)
261 /*
262 * Note: these are not really "standard" since the specification includes
263 * no 12bit tables. But they should work with any image, and at least
264 * moderately adequate as default tables.
265 * https://sourceforge.net/tracker/?func=detail&aid=2809979&group_id=159521&atid=812162
266 */
267 {
268 static const UINT8 bits_dc_luminance[17] =
269 { 0, 0, 2, 3, 1, 0, 3, 1, 0, 3, 1, 1, 1, 0, 0, 0 };
270 static const UINT8 val_dc_luminance[] =
271 { 11, 12, 9, 10, 13, 8, 6, 7, 14, 5, 0, 3, 4, 1, 15, 2 };
272
273 static const UINT8 bits_dc_chrominance[17] =
274 { 0, 0, 2, 2, 2, 3, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 };
275 static const UINT8 val_dc_chrominance[] =
276 { 9, 10, 8, 11, 7, 12, 5, 6, 13, 14, 4, 3, 2, 1, 0, 15 };
277
278 static const UINT8 bits_ac_luminance[17] =
279 { 0, 0, 1, 4, 2, 2, 2, 1, 4, 1, 2, 0, 1, 0, 1, 0, 235 };
280
281 static const UINT8 val_ac_luminance[] =
282 {
283 0x02,0x01,0x03,0x04,0x05,0x06,0x07,0x08,0x12,0x09,0x11,0x13,0x00,0x14,0x21,0x22
284 ,0x15,0x0a,0x23,0x31,0x16,0x32,0x17,0x24,0x33,0x41,0x18,0x25,0x42,0x51,0x0b,0x26
285 ,0x19,0x43,0x52,0x61,0x35,0x62,0x71,0x0c,0x0d,0x0e,0x0f,0x10,0x1a,0x1b,0x1c,0x1d
286 ,0x1e,0x1f,0x20,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x34,0x36,0x37
287 ,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x44,0x45,0x46,0x47,0x48,0x49,0x4a
288 ,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c
289 ,0x5d,0x5e,0x5f,0x60,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e
290 ,0x6f,0x70,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f
291 ,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f
292 ,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f
293 ,0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf
294 ,0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf
295 ,0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf
296 ,0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xdf
297 ,0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xeb,0xec,0xed,0xee,0xef
298 ,0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff
299 };
300
301 static const UINT8 bits_ac_chrominance[17] =
302 { 0, 0, 1, 3, 2, 5, 1, 5, 5, 3, 7, 4, 4, 3, 4, 6, 203 };
303 static const UINT8 val_ac_chrominance[] =
304 {
305 0x01,0x02,0x03,0x11,0x04,0x21,0x00,0x05,0x06,0x12,0x31,0x41,0x07,0x13,0x22,0x51
306 ,0x61,0x08,0x14,0x32,0x71,0x81,0x42,0x91,0xa1,0x09,0x15,0x23,0x52,0xb1,0xc1,0xf0
307 ,0x16,0x62,0xd1,0xe1,0x0a,0x24,0x72,0xf1,0x17,0x82,0x92,0x33,0x43,0x53,0xb2,0x0b
308 ,0x0c,0x18,0x35,0xa2,0xc2,0x0d,0x0e,0x0f,0x10,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f
309 ,0x20,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x34,0x36,0x37
310 ,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x44,0x45,0x46,0x47,0x48,0x49,0x4a
311 ,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5d
312 ,0x5e,0x5f,0x60,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f
313 ,0x70,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f,0x80,0x83
314 ,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x93,0x94,0x95
315 ,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,0xa0,0xa3,0xa4,0xa5,0xa6,0xa7
316 ,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9
317 ,0xba,0xbb,0xbc,0xbd,0xbe,0xbf,0xc0,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb
318 ,0xcc,0xcd,0xce,0xcf,0xd0,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc
319 ,0xdd,0xde,0xdf,0xe0,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xeb,0xec,0xed
320 ,0xee,0xef,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff
321 };
322
323 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
324 bits_dc_luminance, val_dc_luminance);
325 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
326 bits_ac_luminance, val_ac_luminance);
327 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
328 bits_dc_chrominance, val_dc_chrominance);
329 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
330 bits_ac_chrominance, val_ac_chrominance);
331 }
332 #endif /* BITS_IN_JSAMPLE == 12 */
333
334
335 /*
336 * Default parameter setup for compression.
337 *
338 * Applications that don't choose to use this routine must do their
339 * own setup of all these parameters. Alternately, you can call this
340 * to establish defaults and then alter parameters selectively. This
341 * is the recommended approach since, if we add any new parameters,
342 * your code will still work (they'll be set to reasonable defaults).
343 */
344
345 GLOBAL(void)
346 jpeg_set_defaults (j_compress_ptr cinfo)
347 {
348 int i;
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 /* Allocate comp_info array large enough for maximum component count.
355 * Array is made permanent in case application wants to compress
356 * multiple images at same param settings.
357 */
358 if (cinfo->comp_info == NULL)
359 cinfo->comp_info = (jpeg_component_info *)
360 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
361 MAX_COMPONENTS * SIZEOF(jpeg_component_info));
362
363 /* Initialize everything not dependent on the color space */
364
365 cinfo->data_precision = BITS_IN_JSAMPLE;
366 /* Set up two quantization tables using default quality of 75 */
367 jpeg_set_quality(cinfo, 75, TRUE);
368 /* Set up two Huffman tables */
369 std_huff_tables(cinfo);
370
371 /* Initialize default arithmetic coding conditioning */
372 for (i = 0; i < NUM_ARITH_TBLS; i++) {
373 cinfo->arith_dc_L[i] = 0;
374 cinfo->arith_dc_U[i] = 1;
375 cinfo->arith_ac_K[i] = 5;
376 }
377
378 /* Default is no multiple-scan output */
379 cinfo->scan_info = NULL;
380 cinfo->num_scans = 0;
381
382 /* Expect normal source image, not raw downsampled data */
383 cinfo->raw_data_in = FALSE;
384
385 /* Use Huffman coding, not arithmetic coding, by default */
386 cinfo->arith_code = FALSE;
387
388 /* By default, don't do extra passes to optimize entropy coding */
389 cinfo->optimize_coding = FALSE;
390 /* The standard Huffman tables are only valid for 8-bit data precision.
391 * If the precision is higher, force optimization on so that usable
392 * tables will be computed. This test can be removed if default tables
393 * are supplied that are valid for the desired precision.
394 */
395 if (cinfo->data_precision > 8)
396 cinfo->optimize_coding = TRUE;
397
398 /* By default, use the simpler non-cosited sampling alignment */
399 cinfo->CCIR601_sampling = FALSE;
400
401 /* No input smoothing */
402 cinfo->smoothing_factor = 0;
403
404 /* DCT algorithm preference */
405 cinfo->dct_method = JDCT_DEFAULT;
406
407 /* No restart markers */
408 cinfo->restart_interval = 0;
409 cinfo->restart_in_rows = 0;
410
411 /* Fill in default JFIF marker parameters. Note that whether the marker
412 * will actually be written is determined by jpeg_set_colorspace.
413 *
414 * By default, the library emits JFIF version code 1.01.
415 * An application that wants to emit JFIF 1.02 extension markers should set
416 * JFIF_minor_version to 2. We could probably get away with just defaulting
417 * to 1.02, but there may still be some decoders in use that will complain
418 * about that; saying 1.01 should minimize compatibility problems.
419 */
420 cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
421 cinfo->JFIF_minor_version = 1;
422 cinfo->density_unit = 0; /* Pixel size is unknown by default */
423 cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
424 cinfo->Y_density = 1;
425
426 /* Choose JPEG colorspace based on input space, set defaults accordingly */
427
428 jpeg_default_colorspace(cinfo);
429 }
430
431
432 /*
433 * Select an appropriate JPEG colorspace for in_color_space.
434 */
435
436 GLOBAL(void)
437 jpeg_default_colorspace (j_compress_ptr cinfo)
438 {
439 switch (cinfo->in_color_space) {
440 case JCS_GRAYSCALE:
441 jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
442 break;
443 case JCS_RGB:
444 jpeg_set_colorspace(cinfo, JCS_YCbCr);
445 break;
446 case JCS_YCbCr:
447 jpeg_set_colorspace(cinfo, JCS_YCbCr);
448 break;
449 case JCS_CMYK:
450 jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
451 break;
452 case JCS_YCCK:
453 jpeg_set_colorspace(cinfo, JCS_YCCK);
454 break;
455 case JCS_UNKNOWN:
456 jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
457 break;
458 default:
459 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
460 }
461 }
462
463
464 /*
465 * Set the JPEG colorspace, and choose colorspace-dependent default values.
466 */
467
468 GLOBAL(void)
469 jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
470 {
471 jpeg_component_info * compptr;
472 int ci;
473
474 #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
475 (compptr = &cinfo->comp_info[index], \
476 compptr->component_id = (id), \
477 compptr->h_samp_factor = (hsamp), \
478 compptr->v_samp_factor = (vsamp), \
479 compptr->quant_tbl_no = (quant), \
480 compptr->dc_tbl_no = (dctbl), \
481 compptr->ac_tbl_no = (actbl) )
482
483 /* Safety check to ensure start_compress not called yet. */
484 if (cinfo->global_state != CSTATE_START)
485 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
486
487 /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
488 * tables 1 for chrominance components.
489 */
490
491 cinfo->jpeg_color_space = colorspace;
492
493 cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
494 cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
495
496 switch (colorspace) {
497 case JCS_GRAYSCALE:
498 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
499 cinfo->num_components = 1;
500 /* JFIF specifies component ID 1 */
501 SET_COMP(0, 1, 1,1, 0, 0,0);
502 break;
503 case JCS_RGB:
504 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
505 cinfo->num_components = 3;
506 SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
507 SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
508 SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
509 break;
510 case JCS_YCbCr:
511 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
512 cinfo->num_components = 3;
513 /* JFIF specifies component IDs 1,2,3 */
514 /* We default to 2x2 subsamples of chrominance */
515 SET_COMP(0, 1, 2,2, 0, 0,0);
516 SET_COMP(1, 2, 1,1, 1, 1,1);
517 SET_COMP(2, 3, 1,1, 1, 1,1);
518 break;
519 case JCS_CMYK:
520 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
521 cinfo->num_components = 4;
522 SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
523 SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
524 SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
525 SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
526 break;
527 case JCS_YCCK:
528 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
529 cinfo->num_components = 4;
530 SET_COMP(0, 1, 2,2, 0, 0,0);
531 SET_COMP(1, 2, 1,1, 1, 1,1);
532 SET_COMP(2, 3, 1,1, 1, 1,1);
533 SET_COMP(3, 4, 2,2, 0, 0,0);
534 break;
535 case JCS_UNKNOWN:
536 cinfo->num_components = cinfo->input_components;
537 if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
538 ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
539 MAX_COMPONENTS);
540 for (ci = 0; ci < cinfo->num_components; ci++) {
541 SET_COMP(ci, ci, 1,1, 0, 0,0);
542 }
543 break;
544 default:
545 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
546 }
547 }
548
549
550 #ifdef C_PROGRESSIVE_SUPPORTED
551
552 LOCAL(jpeg_scan_info *)
553 fill_a_scan (jpeg_scan_info * scanptr, int ci,
554 int Ss, int Se, int Ah, int Al)
555 /* Support routine: generate one scan for specified component */
556 {
557 scanptr->comps_in_scan = 1;
558 scanptr->component_index[0] = ci;
559 scanptr->Ss = Ss;
560 scanptr->Se = Se;
561 scanptr->Ah = Ah;
562 scanptr->Al = Al;
563 scanptr++;
564 return scanptr;
565 }
566
567 LOCAL(jpeg_scan_info *)
568 fill_scans (jpeg_scan_info * scanptr, int ncomps,
569 int Ss, int Se, int Ah, int Al)
570 /* Support routine: generate one scan for each component */
571 {
572 int ci;
573
574 for (ci = 0; ci < ncomps; ci++) {
575 scanptr->comps_in_scan = 1;
576 scanptr->component_index[0] = ci;
577 scanptr->Ss = Ss;
578 scanptr->Se = Se;
579 scanptr->Ah = Ah;
580 scanptr->Al = Al;
581 scanptr++;
582 }
583 return scanptr;
584 }
585
586 LOCAL(jpeg_scan_info *)
587 fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
588 /* Support routine: generate interleaved DC scan if possible, else N scans */
589 {
590 int ci;
591
592 if (ncomps <= MAX_COMPS_IN_SCAN) {
593 /* Single interleaved DC scan */
594 scanptr->comps_in_scan = ncomps;
595 for (ci = 0; ci < ncomps; ci++)
596 scanptr->component_index[ci] = ci;
597 scanptr->Ss = scanptr->Se = 0;
598 scanptr->Ah = Ah;
599 scanptr->Al = Al;
600 scanptr++;
601 } else {
602 /* Noninterleaved DC scan for each component */
603 scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
604 }
605 return scanptr;
606 }
607
608
609 /*
610 * Create a recommended progressive-JPEG script.
611 * cinfo->num_components and cinfo->jpeg_color_space must be correct.
612 */
613
614 GLOBAL(void)
615 jpeg_simple_progression (j_compress_ptr cinfo)
616 {
617 int ncomps = cinfo->num_components;
618 int nscans;
619 jpeg_scan_info * scanptr;
620
621 /* Safety check to ensure start_compress not called yet. */
622 if (cinfo->global_state != CSTATE_START)
623 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
624
625 /* Figure space needed for script. Calculation must match code below! */
626 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
627 /* Custom script for YCbCr color images. */
628 nscans = 10;
629 } else {
630 /* All-purpose script for other color spaces. */
631 if (ncomps > MAX_COMPS_IN_SCAN)
632 nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
633 else
634 nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
635 }
636
637 /* Allocate space for script.
638 * We need to put it in the permanent pool in case the application performs
639 * multiple compressions without changing the settings. To avoid a memory
640 * leak if jpeg_simple_progression is called repeatedly for the same JPEG
641 * object, we try to re-use previously allocated space, and we allocate
642 * enough space to handle YCbCr even if initially asked for grayscale.
643 */
644 if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
645 cinfo->script_space_size = MAX(nscans, 10);
646 cinfo->script_space = (jpeg_scan_info *)
647 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
648 cinfo->script_space_size * SIZEOF(jpeg_scan_info));
649 }
650 scanptr = cinfo->script_space;
651 cinfo->scan_info = scanptr;
652 cinfo->num_scans = nscans;
653
654 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
655 /* Custom script for YCbCr color images. */
656 /* Initial DC scan */
657 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
658 /* Initial AC scan: get some luma data out in a hurry */
659 scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
660 /* Chroma data is too small to be worth expending many scans on */
661 scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
662 scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
663 /* Complete spectral selection for luma AC */
664 scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
665 /* Refine next bit of luma AC */
666 scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
667 /* Finish DC successive approximation */
668 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
669 /* Finish AC successive approximation */
670 scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
671 scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
672 /* Luma bottom bit comes last since it's usually largest scan */
673 /*scanptr = */fill_a_scan(scanptr, 0, 1, 63, 1, 0);
674 } else {
675 /* All-purpose script for other color spaces. */
676 /* Successive approximation first pass */
677 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
678 scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
679 scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
680 /* Successive approximation second pass */
681 scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
682 /* Successive approximation final pass */
683 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
684 /*scanptr = */fill_scans(scanptr, ncomps, 1, 63, 1, 0);
685 }
686 }
687
688 #endif /* C_PROGRESSIVE_SUPPORTED */