Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(110)

Side by Side Diff: third_party/libjpeg_turbo/jcparam.c

Issue 4134011: Adds libjpeg-turbo to deps... (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/
Patch Set: Created 10 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « third_party/libjpeg_turbo/jcomapi.c ('k') | third_party/libjpeg_turbo/jcphuff.c » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 /*
2 * jcparam.c
3 *
4 * Copyright (C) 1991-1998, Thomas G. Lane.
5 * Copyright (C) 2009, D. R. Commander.
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
23 GLOBAL(void)
24 jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
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 GLOBAL(void)
65 jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
66 boolean force_baseline)
67 /* Set or change the 'quality' (quantization) setting, using default tables
68 * and a straight percentage-scaling quality scale. In most cases it's better
69 * to use jpeg_set_quality (below); this entry point is provided for
70 * applications that insist on a linear percentage scaling.
71 */
72 {
73 /* These are the sample quantization tables given in JPEG spec section K.1.
74 * The spec says that the values given produce "good" quality, and
75 * when divided by 2, "very good" quality.
76 */
77 static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
78 16, 11, 10, 16, 24, 40, 51, 61,
79 12, 12, 14, 19, 26, 58, 60, 55,
80 14, 13, 16, 24, 40, 57, 69, 56,
81 14, 17, 22, 29, 51, 87, 80, 62,
82 18, 22, 37, 56, 68, 109, 103, 77,
83 24, 35, 55, 64, 81, 104, 113, 92,
84 49, 64, 78, 87, 103, 121, 120, 101,
85 72, 92, 95, 98, 112, 100, 103, 99
86 };
87 static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
88 17, 18, 24, 47, 99, 99, 99, 99,
89 18, 21, 26, 66, 99, 99, 99, 99,
90 24, 26, 56, 99, 99, 99, 99, 99,
91 47, 66, 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 99, 99, 99, 99, 99, 99, 99, 99
96 };
97
98 /* Set up two quantization tables using the specified scaling */
99 jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
100 scale_factor, force_baseline);
101 jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
102 scale_factor, force_baseline);
103 }
104
105
106 GLOBAL(int)
107 jpeg_quality_scaling (int quality)
108 /* Convert a user-specified quality rating to a percentage scaling factor
109 * for an underlying quantization table, using our recommended scaling curve.
110 * The input 'quality' factor should be 0 (terrible) to 100 (very good).
111 */
112 {
113 /* Safety limit on quality factor. Convert 0 to 1 to avoid zero divide. */
114 if (quality <= 0) quality = 1;
115 if (quality > 100) quality = 100;
116
117 /* The basic table is used as-is (scaling 100) for a quality of 50.
118 * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
119 * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
120 * to make all the table entries 1 (hence, minimum quantization loss).
121 * Qualities 1..50 are converted to scaling percentage 5000/Q.
122 */
123 if (quality < 50)
124 quality = 5000 / quality;
125 else
126 quality = 200 - quality*2;
127
128 return quality;
129 }
130
131
132 GLOBAL(void)
133 jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
134 /* Set or change the 'quality' (quantization) setting, using default tables.
135 * This is the standard quality-adjusting entry point for typical user
136 * interfaces; only those who want detailed control over quantization tables
137 * would use the preceding three routines directly.
138 */
139 {
140 /* Convert user 0-100 rating to percentage scaling */
141 quality = jpeg_quality_scaling(quality);
142
143 /* Set up standard quality tables */
144 jpeg_set_linear_quality(cinfo, quality, force_baseline);
145 }
146
147
148 /*
149 * Huffman table setup routines
150 */
151
152 LOCAL(void)
153 add_huff_table (j_compress_ptr cinfo,
154 JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
155 /* Define a Huffman table */
156 {
157 int nsymbols, len;
158
159 if (*htblptr == NULL)
160 *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
161
162 /* Copy the number-of-symbols-of-each-code-length counts */
163 MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
164
165 /* Validate the counts. We do this here mainly so we can copy the right
166 * number of symbols from the val[] array, without risking marching off
167 * the end of memory. jchuff.c will do a more thorough test later.
168 */
169 nsymbols = 0;
170 for (len = 1; len <= 16; len++)
171 nsymbols += bits[len];
172 if (nsymbols < 1 || nsymbols > 256)
173 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
174
175 MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
176
177 /* Initialize sent_table FALSE so table will be written to JPEG file. */
178 (*htblptr)->sent_table = FALSE;
179 }
180
181
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
257
258 /*
259 * Default parameter setup for compression.
260 *
261 * Applications that don't choose to use this routine must do their
262 * own setup of all these parameters. Alternately, you can call this
263 * to establish defaults and then alter parameters selectively. This
264 * is the recommended approach since, if we add any new parameters,
265 * your code will still work (they'll be set to reasonable defaults).
266 */
267
268 GLOBAL(void)
269 jpeg_set_defaults (j_compress_ptr cinfo)
270 {
271 int i;
272
273 /* Safety check to ensure start_compress not called yet. */
274 if (cinfo->global_state != CSTATE_START)
275 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
276
277 /* Allocate comp_info array large enough for maximum component count.
278 * Array is made permanent in case application wants to compress
279 * multiple images at same param settings.
280 */
281 if (cinfo->comp_info == NULL)
282 cinfo->comp_info = (jpeg_component_info *)
283 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
284 MAX_COMPONENTS * SIZEOF(jpeg_component_info));
285
286 /* Initialize everything not dependent on the color space */
287
288 cinfo->data_precision = BITS_IN_JSAMPLE;
289 /* Set up two quantization tables using default quality of 75 */
290 jpeg_set_quality(cinfo, 75, TRUE);
291 /* Set up two Huffman tables */
292 std_huff_tables(cinfo);
293
294 /* Initialize default arithmetic coding conditioning */
295 for (i = 0; i < NUM_ARITH_TBLS; i++) {
296 cinfo->arith_dc_L[i] = 0;
297 cinfo->arith_dc_U[i] = 1;
298 cinfo->arith_ac_K[i] = 5;
299 }
300
301 /* Default is no multiple-scan output */
302 cinfo->scan_info = NULL;
303 cinfo->num_scans = 0;
304
305 /* Expect normal source image, not raw downsampled data */
306 cinfo->raw_data_in = FALSE;
307
308 /* Use Huffman coding, not arithmetic coding, by default */
309 cinfo->arith_code = FALSE;
310
311 /* By default, don't do extra passes to optimize entropy coding */
312 cinfo->optimize_coding = FALSE;
313 /* The standard Huffman tables are only valid for 8-bit data precision.
314 * If the precision is higher, force optimization on so that usable
315 * tables will be computed. This test can be removed if default tables
316 * are supplied that are valid for the desired precision.
317 */
318 if (cinfo->data_precision > 8)
319 cinfo->optimize_coding = TRUE;
320
321 /* By default, use the simpler non-cosited sampling alignment */
322 cinfo->CCIR601_sampling = FALSE;
323
324 /* No input smoothing */
325 cinfo->smoothing_factor = 0;
326
327 /* DCT algorithm preference */
328 cinfo->dct_method = JDCT_DEFAULT;
329
330 /* No restart markers */
331 cinfo->restart_interval = 0;
332 cinfo->restart_in_rows = 0;
333
334 /* Fill in default JFIF marker parameters. Note that whether the marker
335 * will actually be written is determined by jpeg_set_colorspace.
336 *
337 * By default, the library emits JFIF version code 1.01.
338 * An application that wants to emit JFIF 1.02 extension markers should set
339 * JFIF_minor_version to 2. We could probably get away with just defaulting
340 * to 1.02, but there may still be some decoders in use that will complain
341 * about that; saying 1.01 should minimize compatibility problems.
342 */
343 cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
344 cinfo->JFIF_minor_version = 1;
345 cinfo->density_unit = 0; /* Pixel size is unknown by default */
346 cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
347 cinfo->Y_density = 1;
348
349 /* Choose JPEG colorspace based on input space, set defaults accordingly */
350
351 jpeg_default_colorspace(cinfo);
352 }
353
354
355 /*
356 * Select an appropriate JPEG colorspace for in_color_space.
357 */
358
359 GLOBAL(void)
360 jpeg_default_colorspace (j_compress_ptr cinfo)
361 {
362 switch (cinfo->in_color_space) {
363 case JCS_GRAYSCALE:
364 jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
365 break;
366 case JCS_RGB:
367 case JCS_EXT_RGB:
368 case JCS_EXT_RGBX:
369 case JCS_EXT_BGR:
370 case JCS_EXT_BGRX:
371 case JCS_EXT_XBGR:
372 case JCS_EXT_XRGB:
373 jpeg_set_colorspace(cinfo, JCS_YCbCr);
374 break;
375 case JCS_YCbCr:
376 jpeg_set_colorspace(cinfo, JCS_YCbCr);
377 break;
378 case JCS_CMYK:
379 jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
380 break;
381 case JCS_YCCK:
382 jpeg_set_colorspace(cinfo, JCS_YCCK);
383 break;
384 case JCS_UNKNOWN:
385 jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
386 break;
387 default:
388 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
389 }
390 }
391
392
393 /*
394 * Set the JPEG colorspace, and choose colorspace-dependent default values.
395 */
396
397 GLOBAL(void)
398 jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
399 {
400 jpeg_component_info * compptr;
401 int ci;
402
403 #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
404 (compptr = &cinfo->comp_info[index], \
405 compptr->component_id = (id), \
406 compptr->h_samp_factor = (hsamp), \
407 compptr->v_samp_factor = (vsamp), \
408 compptr->quant_tbl_no = (quant), \
409 compptr->dc_tbl_no = (dctbl), \
410 compptr->ac_tbl_no = (actbl) )
411
412 /* Safety check to ensure start_compress not called yet. */
413 if (cinfo->global_state != CSTATE_START)
414 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
415
416 /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
417 * tables 1 for chrominance components.
418 */
419
420 cinfo->jpeg_color_space = colorspace;
421
422 cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
423 cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
424
425 switch (colorspace) {
426 case JCS_GRAYSCALE:
427 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
428 cinfo->num_components = 1;
429 /* JFIF specifies component ID 1 */
430 SET_COMP(0, 1, 1,1, 0, 0,0);
431 break;
432 case JCS_RGB:
433 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
434 cinfo->num_components = 3;
435 SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
436 SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
437 SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
438 break;
439 case JCS_YCbCr:
440 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
441 cinfo->num_components = 3;
442 /* JFIF specifies component IDs 1,2,3 */
443 /* We default to 2x2 subsamples of chrominance */
444 SET_COMP(0, 1, 2,2, 0, 0,0);
445 SET_COMP(1, 2, 1,1, 1, 1,1);
446 SET_COMP(2, 3, 1,1, 1, 1,1);
447 break;
448 case JCS_CMYK:
449 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
450 cinfo->num_components = 4;
451 SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
452 SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
453 SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
454 SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
455 break;
456 case JCS_YCCK:
457 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
458 cinfo->num_components = 4;
459 SET_COMP(0, 1, 2,2, 0, 0,0);
460 SET_COMP(1, 2, 1,1, 1, 1,1);
461 SET_COMP(2, 3, 1,1, 1, 1,1);
462 SET_COMP(3, 4, 2,2, 0, 0,0);
463 break;
464 case JCS_UNKNOWN:
465 cinfo->num_components = cinfo->input_components;
466 if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
467 ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
468 MAX_COMPONENTS);
469 for (ci = 0; ci < cinfo->num_components; ci++) {
470 SET_COMP(ci, ci, 1,1, 0, 0,0);
471 }
472 break;
473 default:
474 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
475 }
476 }
477
478
479 #ifdef C_PROGRESSIVE_SUPPORTED
480
481 LOCAL(jpeg_scan_info *)
482 fill_a_scan (jpeg_scan_info * scanptr, int ci,
483 int Ss, int Se, int Ah, int Al)
484 /* Support routine: generate one scan for specified component */
485 {
486 scanptr->comps_in_scan = 1;
487 scanptr->component_index[0] = ci;
488 scanptr->Ss = Ss;
489 scanptr->Se = Se;
490 scanptr->Ah = Ah;
491 scanptr->Al = Al;
492 scanptr++;
493 return scanptr;
494 }
495
496 LOCAL(jpeg_scan_info *)
497 fill_scans (jpeg_scan_info * scanptr, int ncomps,
498 int Ss, int Se, int Ah, int Al)
499 /* Support routine: generate one scan for each component */
500 {
501 int ci;
502
503 for (ci = 0; ci < ncomps; ci++) {
504 scanptr->comps_in_scan = 1;
505 scanptr->component_index[0] = ci;
506 scanptr->Ss = Ss;
507 scanptr->Se = Se;
508 scanptr->Ah = Ah;
509 scanptr->Al = Al;
510 scanptr++;
511 }
512 return scanptr;
513 }
514
515 LOCAL(jpeg_scan_info *)
516 fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
517 /* Support routine: generate interleaved DC scan if possible, else N scans */
518 {
519 int ci;
520
521 if (ncomps <= MAX_COMPS_IN_SCAN) {
522 /* Single interleaved DC scan */
523 scanptr->comps_in_scan = ncomps;
524 for (ci = 0; ci < ncomps; ci++)
525 scanptr->component_index[ci] = ci;
526 scanptr->Ss = scanptr->Se = 0;
527 scanptr->Ah = Ah;
528 scanptr->Al = Al;
529 scanptr++;
530 } else {
531 /* Noninterleaved DC scan for each component */
532 scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
533 }
534 return scanptr;
535 }
536
537
538 /*
539 * Create a recommended progressive-JPEG script.
540 * cinfo->num_components and cinfo->jpeg_color_space must be correct.
541 */
542
543 GLOBAL(void)
544 jpeg_simple_progression (j_compress_ptr cinfo)
545 {
546 int ncomps = cinfo->num_components;
547 int nscans;
548 jpeg_scan_info * scanptr;
549
550 /* Safety check to ensure start_compress not called yet. */
551 if (cinfo->global_state != CSTATE_START)
552 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
553
554 /* Figure space needed for script. Calculation must match code below! */
555 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
556 /* Custom script for YCbCr color images. */
557 nscans = 10;
558 } else {
559 /* All-purpose script for other color spaces. */
560 if (ncomps > MAX_COMPS_IN_SCAN)
561 nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
562 else
563 nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
564 }
565
566 /* Allocate space for script.
567 * We need to put it in the permanent pool in case the application performs
568 * multiple compressions without changing the settings. To avoid a memory
569 * leak if jpeg_simple_progression is called repeatedly for the same JPEG
570 * object, we try to re-use previously allocated space, and we allocate
571 * enough space to handle YCbCr even if initially asked for grayscale.
572 */
573 if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
574 cinfo->script_space_size = MAX(nscans, 10);
575 cinfo->script_space = (jpeg_scan_info *)
576 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
577 cinfo->script_space_size * SIZEOF(jpeg_scan_info));
578 }
579 scanptr = cinfo->script_space;
580 cinfo->scan_info = scanptr;
581 cinfo->num_scans = nscans;
582
583 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
584 /* Custom script for YCbCr color images. */
585 /* Initial DC scan */
586 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
587 /* Initial AC scan: get some luma data out in a hurry */
588 scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
589 /* Chroma data is too small to be worth expending many scans on */
590 scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
591 scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
592 /* Complete spectral selection for luma AC */
593 scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
594 /* Refine next bit of luma AC */
595 scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
596 /* Finish DC successive approximation */
597 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
598 /* Finish AC successive approximation */
599 scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
600 scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
601 /* Luma bottom bit comes last since it's usually largest scan */
602 scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
603 } else {
604 /* All-purpose script for other color spaces. */
605 /* Successive approximation first pass */
606 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
607 scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
608 scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
609 /* Successive approximation second pass */
610 scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
611 /* Successive approximation final pass */
612 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
613 scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
614 }
615 }
616
617 #endif /* C_PROGRESSIVE_SUPPORTED */
OLDNEW
« no previous file with comments | « third_party/libjpeg_turbo/jcomapi.c ('k') | third_party/libjpeg_turbo/jcphuff.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698