]> Creatis software - gdcm.git/blob - src/gdcmjpeg/jcparam.c
Default Pixel Spacing to 1.0\1.0 when writing an image ex nihilo
[gdcm.git] / src / gdcmjpeg / jcparam.c
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 LOCAL(void)
182 std_huff_tables (j_compress_ptr cinfo)
183 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
184 /* IMPORTANT: these are only valid for 8-bit data precision! */
185 {
186   static const UINT8 bits_dc_luminance[17] =
187     { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
188   static const UINT8 val_dc_luminance[] =
189     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
190   
191   static const UINT8 bits_dc_chrominance[17] =
192     { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
193   static const UINT8 val_dc_chrominance[] =
194     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
195   
196   static const UINT8 bits_ac_luminance[17] =
197     { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
198   static const UINT8 val_ac_luminance[] =
199     { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
200       0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
201       0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
202       0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
203       0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
204       0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
205       0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
206       0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
207       0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
208       0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
209       0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
210       0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
211       0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
212       0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
213       0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
214       0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
215       0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
216       0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
217       0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
218       0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
219       0xf9, 0xfa };
220   
221   static const UINT8 bits_ac_chrominance[17] =
222     { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
223   static const UINT8 val_ac_chrominance[] =
224     { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
225       0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
226       0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
227       0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
228       0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
229       0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
230       0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
231       0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
232       0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
233       0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
234       0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
235       0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
236       0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
237       0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
238       0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
239       0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
240       0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
241       0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
242       0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
243       0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
244       0xf9, 0xfa };
245   
246   add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
247      bits_dc_luminance, val_dc_luminance);
248   add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
249      bits_ac_luminance, val_ac_luminance);
250   add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
251      bits_dc_chrominance, val_dc_chrominance);
252   add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
253      bits_ac_chrominance, val_ac_chrominance);
254 }
255
256
257 /*
258  * Default parameter setup for compression.
259  *
260  * Applications that don't choose to use this routine must do their
261  * own setup of all these parameters.  Alternately, you can call this
262  * to establish defaults and then alter parameters selectively.  This
263  * is the recommended approach since, if we add any new parameters,
264  * your code will still work (they'll be set to reasonable defaults).
265  */
266
267 GLOBAL(void)
268 jpeg_set_defaults (j_compress_ptr cinfo)
269 {
270   int i;
271
272   /* Safety check to ensure start_compress not called yet. */
273   if (cinfo->global_state != CSTATE_START)
274     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
275
276   /* Allocate comp_info array large enough for maximum component count.
277    * Array is made permanent in case application wants to compress
278    * multiple images at same param settings.
279    */
280   if (cinfo->comp_info == NULL)
281     cinfo->comp_info = (jpeg_component_info *)
282       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
283           MAX_COMPONENTS * SIZEOF(jpeg_component_info));
284
285   /* Initialize everything not dependent on the color space */
286
287   cinfo->lossless = FALSE;
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   if (cinfo->lossless)
363     jpeg_set_colorspace(cinfo, cinfo->in_color_space);
364   else { /* lossy */
365     switch (cinfo->in_color_space) {
366     case JCS_GRAYSCALE:
367       jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
368       break;
369     case JCS_RGB:
370       jpeg_set_colorspace(cinfo, JCS_YCbCr);
371       break;
372     case JCS_YCbCr:
373       jpeg_set_colorspace(cinfo, JCS_YCbCr);
374       break;
375     case JCS_CMYK:
376       jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
377       break;
378     case JCS_YCCK:
379       jpeg_set_colorspace(cinfo, JCS_YCCK);
380       break;
381     case JCS_UNKNOWN:
382       jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
383       break;
384     default:
385       ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
386     }
387   }
388 }
389
390
391 /*
392  * Set the JPEG colorspace, and choose colorspace-dependent default values.
393  */
394
395 GLOBAL(void)
396 jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
397 {
398   jpeg_component_info * compptr;
399   int ci;
400
401 #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl)  \
402   (compptr = &cinfo->comp_info[index], \
403    compptr->component_id = (id), \
404    compptr->h_samp_factor = (hsamp), \
405    compptr->v_samp_factor = (vsamp), \
406    compptr->quant_tbl_no = (quant), \
407    compptr->dc_tbl_no = (dctbl), \
408    compptr->ac_tbl_no = (actbl) )
409
410   /* Safety check to ensure start_compress not called yet. */
411   if (cinfo->global_state != CSTATE_START)
412     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
413
414   /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
415    * tables 1 for chrominance components.
416    */
417
418   cinfo->jpeg_color_space = colorspace;
419
420   cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
421   cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
422
423   switch (colorspace) {
424   case JCS_GRAYSCALE:
425     cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
426     cinfo->num_components = 1;
427     /* JFIF specifies component ID 1 */
428     SET_COMP(0, 1, 1,1, 0, 0,0);
429     break;
430   case JCS_RGB:
431     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
432     cinfo->num_components = 3;
433     SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
434     SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
435     SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
436     break;
437   case JCS_YCbCr:
438     cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
439     cinfo->num_components = 3;
440     /* JFIF specifies component IDs 1,2,3 */
441     if (cinfo->lossless) {
442       SET_COMP(0, 1, 1,1, 0, 0,0);
443       SET_COMP(1, 2, 1,1, 1, 1,1);
444       SET_COMP(2, 3, 1,1, 1, 1,1);
445     } else { /* lossy */
446       /* We default to 2x2 subsamples of chrominance */
447       SET_COMP(0, 1, 2,2, 0, 0,0);
448       SET_COMP(1, 2, 1,1, 1, 1,1);
449       SET_COMP(2, 3, 1,1, 1, 1,1);
450     }
451     break;
452   case JCS_CMYK:
453     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
454     cinfo->num_components = 4;
455     SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
456     SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
457     SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
458     SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
459     break;
460   case JCS_YCCK:
461     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
462     cinfo->num_components = 4;
463     if (cinfo->lossless) {
464       SET_COMP(0, 1, 1,1, 0, 0,0);
465       SET_COMP(1, 2, 1,1, 1, 1,1);
466       SET_COMP(2, 3, 1,1, 1, 1,1);
467       SET_COMP(3, 4, 1,1, 0, 0,0);
468     } else { /* lossy */
469       SET_COMP(0, 1, 2,2, 0, 0,0);
470       SET_COMP(1, 2, 1,1, 1, 1,1);
471       SET_COMP(2, 3, 1,1, 1, 1,1);
472       SET_COMP(3, 4, 2,2, 0, 0,0);
473     }
474     break;
475   case JCS_UNKNOWN:
476     cinfo->num_components = cinfo->input_components;
477     if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
478       ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
479          MAX_COMPONENTS);
480     for (ci = 0; ci < cinfo->num_components; ci++) {
481       SET_COMP(ci, ci, 1,1, 0, 0,0);
482     }
483     break;
484   default:
485     ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
486   }
487 }
488
489
490 #ifdef C_PROGRESSIVE_SUPPORTED
491
492 LOCAL(jpeg_scan_info *)
493 fill_scans (jpeg_scan_info * scanptr, int ncomps,
494       int Ss, int Se, int Ah, int Al)
495 /* Support routine: generate one scan for each component */
496 {
497   int ci;
498
499   for (ci = 0; ci < ncomps; ci++) {
500     scanptr->comps_in_scan = 1;
501     scanptr->component_index[0] = ci;
502     scanptr->Ss = Ss;
503     scanptr->Se = Se;
504     scanptr->Ah = Ah;
505     scanptr->Al = Al;
506     scanptr++;
507   }
508   return scanptr;
509 }
510
511
512 LOCAL(jpeg_scan_info *)
513 fill_a_scan (jpeg_scan_info * scanptr, int ci,
514        int Ss, int Se, int Ah, int Al)
515 /* Support routine: generate one scan for specified component */
516 {
517   scanptr->comps_in_scan = 1;
518   scanptr->component_index[0] = ci;
519   scanptr->Ss = Ss;
520   scanptr->Se = Se;
521   scanptr->Ah = Ah;
522   scanptr->Al = Al;
523   scanptr++;
524   return scanptr;
525 }
526
527 LOCAL(jpeg_scan_info *)
528 fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
529 /* Support routine: generate interleaved DC scan if possible, else N scans */
530 {
531   int ci;
532
533   if (ncomps <= MAX_COMPS_IN_SCAN) {
534     /* Single interleaved DC scan */
535     scanptr->comps_in_scan = ncomps;
536     for (ci = 0; ci < ncomps; ci++)
537       scanptr->component_index[ci] = ci;
538     scanptr->Ss = scanptr->Se = 0;
539     scanptr->Ah = Ah;
540     scanptr->Al = Al;
541     scanptr++;
542   } else {
543     /* Noninterleaved DC scan for each component */
544     scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
545   }
546   return scanptr;
547 }
548
549
550 /*
551  * Create a recommended progressive-JPEG script.
552  * cinfo->num_components and cinfo->jpeg_color_space must be correct.
553  */
554
555 GLOBAL(void)
556 jpeg_simple_progression (j_compress_ptr cinfo)
557 {
558   int ncomps = cinfo->num_components;
559   int nscans;
560   jpeg_scan_info * scanptr;
561
562   /* Safety check to ensure start_compress not called yet. */
563   if (cinfo->global_state != CSTATE_START)
564     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
565
566   /* Figure space needed for script.  Calculation must match code below! */
567   if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
568     /* Custom script for YCbCr color images. */
569     nscans = 10;
570   } else {
571     /* All-purpose script for other color spaces. */
572     if (ncomps > MAX_COMPS_IN_SCAN)
573       nscans = 6 * ncomps;  /* 2 DC + 4 AC scans per component */
574     else
575       nscans = 2 + 4 * ncomps;  /* 2 DC scans; 4 AC scans per component */
576   }
577
578   /* Allocate space for script.
579    * We need to put it in the permanent pool in case the application performs
580    * multiple compressions without changing the settings.  To avoid a memory
581    * leak if jpeg_simple_progression is called repeatedly for the same JPEG
582    * object, we try to re-use previously allocated space, and we allocate
583    * enough space to handle YCbCr even if initially asked for grayscale.
584    */
585   if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
586     cinfo->script_space_size = MAX(nscans, 10);
587     cinfo->script_space = (jpeg_scan_info *)
588       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
589       cinfo->script_space_size * SIZEOF(jpeg_scan_info));
590   }
591   scanptr = cinfo->script_space;
592   cinfo->scan_info = scanptr;
593   cinfo->num_scans = nscans;
594
595   if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
596     /* Custom script for YCbCr color images. */
597     /* Initial DC scan */
598     scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
599     /* Initial AC scan: get some luma data out in a hurry */
600     scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
601     /* Chroma data is too small to be worth expending many scans on */
602     scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
603     scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
604     /* Complete spectral selection for luma AC */
605     scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
606     /* Refine next bit of luma AC */
607     scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
608     /* Finish DC successive approximation */
609     scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
610     /* Finish AC successive approximation */
611     scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
612     scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
613     /* Luma bottom bit comes last since it's usually largest scan */
614     scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
615   } else {
616     /* All-purpose script for other color spaces. */
617     /* Successive approximation first pass */
618     scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
619     scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
620     scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
621     /* Successive approximation second pass */
622     scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
623     /* Successive approximation final pass */
624     scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
625     scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
626   }
627 }
628
629 #endif /* C_PROGRESSIVE_SUPPORTED */
630
631
632 #ifdef C_LOSSLESS_SUPPORTED
633
634 /*
635  * Create a single-entry lossless-JPEG script containing all components.
636  * cinfo->num_components must be correct.
637  */
638
639 GLOBAL(void)
640 jpeg_simple_lossless (j_compress_ptr cinfo, int predictor, int point_transform)
641 {
642   int ncomps = cinfo->num_components;
643   int nscans = 1;
644   int ci;
645   jpeg_scan_info * scanptr;
646
647   /* Safety check to ensure start_compress not called yet. */
648   if (cinfo->global_state != CSTATE_START)
649     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
650
651   cinfo->lossless = TRUE;
652
653   /* Set jpeg_color_space. */
654   jpeg_default_colorspace(cinfo);
655
656   /* Check to ensure that all components will fit in one scan. */
657   if (cinfo->num_components > MAX_COMPS_IN_SCAN)
658     ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
659        MAX_COMPS_IN_SCAN);
660
661   /* Allocate space for script.
662    * We need to put it in the permanent pool in case the application performs
663    * multiple compressions without changing the settings.  To avoid a memory
664    * leak if jpeg_simple_lossless is called repeatedly for the same JPEG
665    * object, we try to re-use previously allocated space.
666    */
667   if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
668     cinfo->script_space_size = nscans;
669     cinfo->script_space = (jpeg_scan_info *)
670       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
671       cinfo->script_space_size * SIZEOF(jpeg_scan_info));
672   }
673   scanptr = cinfo->script_space;
674   cinfo->scan_info = scanptr;
675   cinfo->num_scans = nscans;
676
677   /* Fill the script. */
678   scanptr->comps_in_scan = ncomps;
679   for (ci = 0; ci < ncomps; ci++)
680     scanptr->component_index[ci] = ci;
681   scanptr->Ss = predictor;
682   scanptr->Se = 0;
683   scanptr->Ah = 0;
684   scanptr->Al = point_transform;
685 }
686
687 #endif /* C_LOSSLESS_SUPPORTED */