/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/libjpeg/jcparam.c
ViewVC logotype

Annotation of /branch/r3113_0.9.7_beta/3rdparty/libjpeg/jcparam.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (hide annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 7 months ago) by william
Original Path: trunk/3rdparty/libjpeg/jcparam.c
File MIME type: text/plain
File size: 22001 byte(s)
committing r3113 initial commit again...
1 william 31 /*
2     * jcparam.c
3     *
4     * Copyright (C) 1991-1998, Thomas G. Lane.
5     * Modified 2003-2008 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    
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     /* 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     */
68     static 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     };
78     static 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    
90     GLOBAL(void)
91     jpeg_default_qtables (j_compress_ptr cinfo, boolean force_baseline)
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 */
98     jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
99     cinfo->q_scale_factor[0], force_baseline);
100     jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
101     cinfo->q_scale_factor[1], force_baseline);
102     }
103    
104    
105     GLOBAL(void)
106     jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
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 */
115     jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
116     scale_factor, force_baseline);
117     jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
118     scale_factor, force_baseline);
119     }
120    
121    
122     GLOBAL(int)
123     jpeg_quality_scaling (int quality)
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    
148     GLOBAL(void)
149     jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
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 three routines directly.
154     */
155     {
156     /* Convert user 0-100 rating to percentage scaling */
157     quality = jpeg_quality_scaling(quality);
158    
159     /* Set up standard quality tables */
160     jpeg_set_linear_quality(cinfo, quality, force_baseline);
161     }
162    
163    
164     /*
165     * Huffman table setup routines
166     */
167    
168     LOCAL(void)
169     add_huff_table (j_compress_ptr cinfo,
170     JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
171     /* Define a Huffman table */
172     {
173     int nsymbols, len;
174    
175     if (*htblptr == NULL)
176     *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
177    
178     /* Copy the number-of-symbols-of-each-code-length counts */
179     MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
180    
181     /* Validate the counts. We do this here mainly so we can copy the right
182     * number of symbols from the val[] array, without risking marching off
183     * the end of memory. jchuff.c will do a more thorough test later.
184     */
185     nsymbols = 0;
186     for (len = 1; len <= 16; len++)
187     nsymbols += bits[len];
188     if (nsymbols < 1 || nsymbols > 256)
189     ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
190    
191     MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
192    
193     /* Initialize sent_table FALSE so table will be written to JPEG file. */
194     (*htblptr)->sent_table = FALSE;
195     }
196    
197    
198     LOCAL(void)
199     std_huff_tables (j_compress_ptr cinfo)
200     /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
201     /* IMPORTANT: these are only valid for 8-bit data precision! */
202     {
203     static const UINT8 bits_dc_luminance[17] =
204     { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
205     static const UINT8 val_dc_luminance[] =
206     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
207    
208     static const UINT8 bits_dc_chrominance[17] =
209     { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
210     static const UINT8 val_dc_chrominance[] =
211     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
212    
213     static const UINT8 bits_ac_luminance[17] =
214     { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
215     static const UINT8 val_ac_luminance[] =
216     { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
217     0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
218     0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
219     0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
220     0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
221     0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
222     0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
223     0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
224     0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
225     0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
226     0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
227     0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
228     0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
229     0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
230     0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
231     0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
232     0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
233     0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
234     0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
235     0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
236     0xf9, 0xfa };
237    
238     static const UINT8 bits_ac_chrominance[17] =
239     { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
240     static const UINT8 val_ac_chrominance[] =
241     { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
242     0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
243     0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
244     0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
245     0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
246     0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
247     0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
248     0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
249     0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
250     0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
251     0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
252     0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
253     0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
254     0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
255     0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
256     0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
257     0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
258     0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
259     0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
260     0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
261     0xf9, 0xfa };
262    
263     add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
264     bits_dc_luminance, val_dc_luminance);
265     add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
266     bits_ac_luminance, val_ac_luminance);
267     add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
268     bits_dc_chrominance, val_dc_chrominance);
269     add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
270     bits_ac_chrominance, val_ac_chrominance);
271     }
272    
273    
274     /*
275     * Default parameter setup for compression.
276     *
277     * Applications that don't choose to use this routine must do their
278     * own setup of all these parameters. Alternately, you can call this
279     * to establish defaults and then alter parameters selectively. This
280     * is the recommended approach since, if we add any new parameters,
281     * your code will still work (they'll be set to reasonable defaults).
282     */
283    
284     GLOBAL(void)
285     jpeg_set_defaults (j_compress_ptr cinfo)
286     {
287     int i;
288    
289     /* Safety check to ensure start_compress not called yet. */
290     if (cinfo->global_state != CSTATE_START)
291     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
292    
293     /* Allocate comp_info array large enough for maximum component count.
294     * Array is made permanent in case application wants to compress
295     * multiple images at same param settings.
296     */
297     if (cinfo->comp_info == NULL)
298     cinfo->comp_info = (jpeg_component_info *)
299     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
300     MAX_COMPONENTS * SIZEOF(jpeg_component_info));
301    
302     /* Initialize everything not dependent on the color space */
303    
304     cinfo->scale_num = 1; /* 1:1 scaling */
305     cinfo->scale_denom = 1;
306     cinfo->data_precision = BITS_IN_JSAMPLE;
307     /* Set up two quantization tables using default quality of 75 */
308     jpeg_set_quality(cinfo, 75, TRUE);
309     /* Set up two Huffman tables */
310     std_huff_tables(cinfo);
311    
312     /* Initialize default arithmetic coding conditioning */
313     for (i = 0; i < NUM_ARITH_TBLS; i++) {
314     cinfo->arith_dc_L[i] = 0;
315     cinfo->arith_dc_U[i] = 1;
316     cinfo->arith_ac_K[i] = 5;
317     }
318    
319     /* Default is no multiple-scan output */
320     cinfo->scan_info = NULL;
321     cinfo->num_scans = 0;
322    
323     /* Expect normal source image, not raw downsampled data */
324     cinfo->raw_data_in = FALSE;
325    
326     /* Use Huffman coding, not arithmetic coding, by default */
327     cinfo->arith_code = FALSE;
328    
329     /* By default, don't do extra passes to optimize entropy coding */
330     cinfo->optimize_coding = FALSE;
331     /* The standard Huffman tables are only valid for 8-bit data precision.
332     * If the precision is higher, force optimization on so that usable
333     * tables will be computed. This test can be removed if default tables
334     * are supplied that are valid for the desired precision.
335     */
336     if (cinfo->data_precision > 8)
337     cinfo->optimize_coding = TRUE;
338    
339     /* By default, use the simpler non-cosited sampling alignment */
340     cinfo->CCIR601_sampling = FALSE;
341    
342     /* By default, apply fancy downsampling */
343     cinfo->do_fancy_downsampling = TRUE;
344    
345     /* No input smoothing */
346     cinfo->smoothing_factor = 0;
347    
348     /* DCT algorithm preference */
349     cinfo->dct_method = JDCT_DEFAULT;
350    
351     /* No restart markers */
352     cinfo->restart_interval = 0;
353     cinfo->restart_in_rows = 0;
354    
355     /* Fill in default JFIF marker parameters. Note that whether the marker
356     * will actually be written is determined by jpeg_set_colorspace.
357     *
358     * By default, the library emits JFIF version code 1.01.
359     * An application that wants to emit JFIF 1.02 extension markers should set
360     * JFIF_minor_version to 2. We could probably get away with just defaulting
361     * to 1.02, but there may still be some decoders in use that will complain
362     * about that; saying 1.01 should minimize compatibility problems.
363     */
364     cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
365     cinfo->JFIF_minor_version = 1;
366     cinfo->density_unit = 0; /* Pixel size is unknown by default */
367     cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
368     cinfo->Y_density = 1;
369    
370     /* Choose JPEG colorspace based on input space, set defaults accordingly */
371    
372     jpeg_default_colorspace(cinfo);
373     }
374    
375    
376     /*
377     * Select an appropriate JPEG colorspace for in_color_space.
378     */
379    
380     GLOBAL(void)
381     jpeg_default_colorspace (j_compress_ptr cinfo)
382     {
383     switch (cinfo->in_color_space) {
384     case JCS_GRAYSCALE:
385     jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
386     break;
387     case JCS_RGB:
388     jpeg_set_colorspace(cinfo, JCS_YCbCr);
389     break;
390     case JCS_YCbCr:
391     jpeg_set_colorspace(cinfo, JCS_YCbCr);
392     break;
393     case JCS_CMYK:
394     jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
395     break;
396     case JCS_YCCK:
397     jpeg_set_colorspace(cinfo, JCS_YCCK);
398     break;
399     case JCS_UNKNOWN:
400     jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
401     break;
402     default:
403     ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
404     }
405     }
406    
407    
408     /*
409     * Set the JPEG colorspace, and choose colorspace-dependent default values.
410     */
411    
412     GLOBAL(void)
413     jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
414     {
415     jpeg_component_info * compptr;
416     int ci;
417    
418     #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
419     (compptr = &cinfo->comp_info[index], \
420     compptr->component_id = (id), \
421     compptr->h_samp_factor = (hsamp), \
422     compptr->v_samp_factor = (vsamp), \
423     compptr->quant_tbl_no = (quant), \
424     compptr->dc_tbl_no = (dctbl), \
425     compptr->ac_tbl_no = (actbl) )
426    
427     /* Safety check to ensure start_compress not called yet. */
428     if (cinfo->global_state != CSTATE_START)
429     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
430    
431     /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
432     * tables 1 for chrominance components.
433     */
434    
435     cinfo->jpeg_color_space = colorspace;
436    
437     cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
438     cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
439    
440     switch (colorspace) {
441     case JCS_GRAYSCALE:
442     cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
443     cinfo->num_components = 1;
444     /* JFIF specifies component ID 1 */
445     SET_COMP(0, 1, 1,1, 0, 0,0);
446     break;
447     case JCS_RGB:
448     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
449     cinfo->num_components = 3;
450     SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
451     SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
452     SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
453     break;
454     case JCS_YCbCr:
455     cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
456     cinfo->num_components = 3;
457     /* JFIF specifies component IDs 1,2,3 */
458     /* We default to 2x2 subsamples of chrominance */
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     break;
463     case JCS_CMYK:
464     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
465     cinfo->num_components = 4;
466     SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
467     SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
468     SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
469     SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
470     break;
471     case JCS_YCCK:
472     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
473     cinfo->num_components = 4;
474     SET_COMP(0, 1, 2,2, 0, 0,0);
475     SET_COMP(1, 2, 1,1, 1, 1,1);
476     SET_COMP(2, 3, 1,1, 1, 1,1);
477     SET_COMP(3, 4, 2,2, 0, 0,0);
478     break;
479     case JCS_UNKNOWN:
480     cinfo->num_components = cinfo->input_components;
481     if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
482     ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
483     MAX_COMPONENTS);
484     for (ci = 0; ci < cinfo->num_components; ci++) {
485     SET_COMP(ci, ci, 1,1, 0, 0,0);
486     }
487     break;
488     default:
489     ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
490     }
491     }
492    
493    
494     #ifdef C_PROGRESSIVE_SUPPORTED
495    
496     LOCAL(jpeg_scan_info *)
497     fill_a_scan (jpeg_scan_info * scanptr, int ci,
498     int Ss, int Se, int Ah, int Al)
499     /* Support routine: generate one scan for specified component */
500     {
501     scanptr->comps_in_scan = 1;
502     scanptr->component_index[0] = ci;
503     scanptr->Ss = Ss;
504     scanptr->Se = Se;
505     scanptr->Ah = Ah;
506     scanptr->Al = Al;
507     scanptr++;
508     return scanptr;
509     }
510    
511     LOCAL(jpeg_scan_info *)
512     fill_scans (jpeg_scan_info * scanptr, int ncomps,
513     int Ss, int Se, int Ah, int Al)
514     /* Support routine: generate one scan for each component */
515     {
516     int ci;
517    
518     for (ci = 0; ci < ncomps; ci++) {
519     scanptr->comps_in_scan = 1;
520     scanptr->component_index[0] = ci;
521     scanptr->Ss = Ss;
522     scanptr->Se = Se;
523     scanptr->Ah = Ah;
524     scanptr->Al = Al;
525     scanptr++;
526     }
527     return scanptr;
528     }
529    
530     LOCAL(jpeg_scan_info *)
531     fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
532     /* Support routine: generate interleaved DC scan if possible, else N scans */
533     {
534     int ci;
535    
536     if (ncomps <= MAX_COMPS_IN_SCAN) {
537     /* Single interleaved DC scan */
538     scanptr->comps_in_scan = ncomps;
539     for (ci = 0; ci < ncomps; ci++)
540     scanptr->component_index[ci] = ci;
541     scanptr->Ss = scanptr->Se = 0;
542     scanptr->Ah = Ah;
543     scanptr->Al = Al;
544     scanptr++;
545     } else {
546     /* Noninterleaved DC scan for each component */
547     scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
548     }
549     return scanptr;
550     }
551    
552    
553     /*
554     * Create a recommended progressive-JPEG script.
555     * cinfo->num_components and cinfo->jpeg_color_space must be correct.
556     */
557    
558     GLOBAL(void)
559     jpeg_simple_progression (j_compress_ptr cinfo)
560     {
561     int ncomps = cinfo->num_components;
562     int nscans;
563     jpeg_scan_info * scanptr;
564    
565     /* Safety check to ensure start_compress not called yet. */
566     if (cinfo->global_state != CSTATE_START)
567     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
568    
569     /* Figure space needed for script. Calculation must match code below! */
570     if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
571     /* Custom script for YCbCr color images. */
572     nscans = 10;
573     } else {
574     /* All-purpose script for other color spaces. */
575     if (ncomps > MAX_COMPS_IN_SCAN)
576     nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
577     else
578     nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
579     }
580    
581     /* Allocate space for script.
582     * We need to put it in the permanent pool in case the application performs
583     * multiple compressions without changing the settings. To avoid a memory
584     * leak if jpeg_simple_progression is called repeatedly for the same JPEG
585     * object, we try to re-use previously allocated space, and we allocate
586     * enough space to handle YCbCr even if initially asked for grayscale.
587     */
588     if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
589     cinfo->script_space_size = MAX(nscans, 10);
590     cinfo->script_space = (jpeg_scan_info *)
591     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
592     cinfo->script_space_size * SIZEOF(jpeg_scan_info));
593     }
594     scanptr = cinfo->script_space;
595     cinfo->scan_info = scanptr;
596     cinfo->num_scans = nscans;
597    
598     if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
599     /* Custom script for YCbCr color images. */
600     /* Initial DC scan */
601     scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
602     /* Initial AC scan: get some luma data out in a hurry */
603     scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
604     /* Chroma data is too small to be worth expending many scans on */
605     scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
606     scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
607     /* Complete spectral selection for luma AC */
608     scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
609     /* Refine next bit of luma AC */
610     scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
611     /* Finish DC successive approximation */
612     scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
613     /* Finish AC successive approximation */
614     scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
615     scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
616     /* Luma bottom bit comes last since it's usually largest scan */
617     scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
618     } else {
619     /* All-purpose script for other color spaces. */
620     /* Successive approximation first pass */
621     scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
622     scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
623     scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
624     /* Successive approximation second pass */
625     scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
626     /* Successive approximation final pass */
627     scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
628     scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
629     }
630     }
631    
632     #endif /* C_PROGRESSIVE_SUPPORTED */

  ViewVC Help
Powered by ViewVC 1.1.22