jcparam.c

00001 /*
00002  * jcparam.c
00003  *
00004  * Copyright (C) 1991-1998, Thomas G. Lane.
00005  * Modified 2003-2013 by Guido Vollbeding.
00006  * This file is part of the Independent JPEG Group's software.
00007  * For conditions of distribution and use, see the accompanying README file.
00008  *
00009  * This file contains optional default-setting code for the JPEG compressor.
00010  * Applications do not have to use this file, but those that don't use it
00011  * must know a lot more about the innards of the JPEG code.
00012  */
00013 
00014 #define JPEG_INTERNALS
00015 #include "jinclude.h"
00016 #include "jpeglib.h"
00017 
00018 
00019 /*
00020  * Quantization table setup routines
00021  */
00022 
00023 GLOBAL(void)
00024 jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
00025               const unsigned int *basic_table,
00026               int scale_factor, boolean force_baseline)
00027 /* Define a quantization table equal to the basic_table times
00028  * a scale factor (given as a percentage).
00029  * If force_baseline is TRUE, the computed quantization table entries
00030  * are limited to 1..255 for JPEG baseline compatibility.
00031  */
00032 {
00033   JQUANT_TBL ** qtblptr;
00034   int i;
00035   long temp;
00036 
00037   /* Safety check to ensure start_compress not called yet. */
00038   if (cinfo->global_state != CSTATE_START)
00039     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
00040 
00041   if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
00042     ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
00043 
00044   qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
00045 
00046   if (*qtblptr == NULL)
00047     *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
00048 
00049   for (i = 0; i < DCTSIZE2; i++) {
00050     temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
00051     /* limit the values to the valid range */
00052     if (temp <= 0L) temp = 1L;
00053     if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
00054     if (force_baseline && temp > 255L)
00055       temp = 255L;      /* limit to baseline range if requested */
00056     (*qtblptr)->quantval[i] = (UINT16) temp;
00057   }
00058 
00059   /* Initialize sent_table FALSE so table will be written to JPEG file. */
00060   (*qtblptr)->sent_table = FALSE;
00061 }
00062 
00063 
00064 /* These are the sample quantization tables given in JPEG spec section K.1.
00065  * The spec says that the values given produce "good" quality, and
00066  * when divided by 2, "very good" quality.
00067  */
00068 static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
00069   16,  11,  10,  16,  24,  40,  51,  61,
00070   12,  12,  14,  19,  26,  58,  60,  55,
00071   14,  13,  16,  24,  40,  57,  69,  56,
00072   14,  17,  22,  29,  51,  87,  80,  62,
00073   18,  22,  37,  56,  68, 109, 103,  77,
00074   24,  35,  55,  64,  81, 104, 113,  92,
00075   49,  64,  78,  87, 103, 121, 120, 101,
00076   72,  92,  95,  98, 112, 100, 103,  99
00077 };
00078 static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
00079   17,  18,  24,  47,  99,  99,  99,  99,
00080   18,  21,  26,  66,  99,  99,  99,  99,
00081   24,  26,  56,  99,  99,  99,  99,  99,
00082   47,  66,  99,  99,  99,  99,  99,  99,
00083   99,  99,  99,  99,  99,  99,  99,  99,
00084   99,  99,  99,  99,  99,  99,  99,  99,
00085   99,  99,  99,  99,  99,  99,  99,  99,
00086   99,  99,  99,  99,  99,  99,  99,  99
00087 };
00088 
00089 
00090 GLOBAL(void)
00091 jpeg_default_qtables (j_compress_ptr cinfo, boolean force_baseline)
00092 /* Set or change the 'quality' (quantization) setting, using default tables
00093  * and straight percentage-scaling quality scales.
00094  * This entry point allows different scalings for luminance and chrominance.
00095  */
00096 {
00097   /* Set up two quantization tables using the specified scaling */
00098   jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
00099                cinfo->q_scale_factor[0], force_baseline);
00100   jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
00101                cinfo->q_scale_factor[1], force_baseline);
00102 }
00103 
00104 
00105 GLOBAL(void)
00106 jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
00107              boolean force_baseline)
00108 /* Set or change the 'quality' (quantization) setting, using default tables
00109  * and a straight percentage-scaling quality scale.  In most cases it's better
00110  * to use jpeg_set_quality (below); this entry point is provided for
00111  * applications that insist on a linear percentage scaling.
00112  */
00113 {
00114   /* Set up two quantization tables using the specified scaling */
00115   jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
00116                scale_factor, force_baseline);
00117   jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
00118                scale_factor, force_baseline);
00119 }
00120 
00121 
00122 GLOBAL(int)
00123 jpeg_quality_scaling (int quality)
00124 /* Convert a user-specified quality rating to a percentage scaling factor
00125  * for an underlying quantization table, using our recommended scaling curve.
00126  * The input 'quality' factor should be 0 (terrible) to 100 (very good).
00127  */
00128 {
00129   /* Safety limit on quality factor.  Convert 0 to 1 to avoid zero divide. */
00130   if (quality <= 0) quality = 1;
00131   if (quality > 100) quality = 100;
00132 
00133   /* The basic table is used as-is (scaling 100) for a quality of 50.
00134    * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
00135    * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
00136    * to make all the table entries 1 (hence, minimum quantization loss).
00137    * Qualities 1..50 are converted to scaling percentage 5000/Q.
00138    */
00139   if (quality < 50)
00140     quality = 5000 / quality;
00141   else
00142     quality = 200 - quality*2;
00143 
00144   return quality;
00145 }
00146 
00147 
00148 GLOBAL(void)
00149 jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
00150 /* Set or change the 'quality' (quantization) setting, using default tables.
00151  * This is the standard quality-adjusting entry point for typical user
00152  * interfaces; only those who want detailed control over quantization tables
00153  * would use the preceding routines directly.
00154  */
00155 {
00156   /* Convert user 0-100 rating to percentage scaling */
00157   quality = jpeg_quality_scaling(quality);
00158 
00159   /* Set up standard quality tables */
00160   jpeg_set_linear_quality(cinfo, quality, force_baseline);
00161 }
00162 
00163 
00164 /*
00165  * Huffman table setup routines
00166  */
00167 
00168 LOCAL(void)
00169 add_huff_table (j_compress_ptr cinfo,
00170         JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
00171 /* Define a Huffman table */
00172 {
00173   int nsymbols, len;
00174 
00175   if (*htblptr == NULL)
00176     *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
00177 
00178   /* Copy the number-of-symbols-of-each-code-length counts */
00179   MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
00180 
00181   /* Validate the counts.  We do this here mainly so we can copy the right
00182    * number of symbols from the val[] array, without risking marching off
00183    * the end of memory.  jchuff.c will do a more thorough test later.
00184    */
00185   nsymbols = 0;
00186   for (len = 1; len <= 16; len++)
00187     nsymbols += bits[len];
00188   if (nsymbols < 1 || nsymbols > 256)
00189     ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
00190 
00191   MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
00192 
00193   /* Initialize sent_table FALSE so table will be written to JPEG file. */
00194   (*htblptr)->sent_table = FALSE;
00195 }
00196 
00197 
00198 LOCAL(void)
00199 std_huff_tables (j_compress_ptr cinfo)
00200 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
00201 /* IMPORTANT: these are only valid for 8-bit data precision! */
00202 {
00203   static const UINT8 bits_dc_luminance[17] =
00204     { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
00205   static const UINT8 val_dc_luminance[] =
00206     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
00207   
00208   static const UINT8 bits_dc_chrominance[17] =
00209     { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
00210   static const UINT8 val_dc_chrominance[] =
00211     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
00212   
00213   static const UINT8 bits_ac_luminance[17] =
00214     { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
00215   static const UINT8 val_ac_luminance[] =
00216     { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
00217       0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
00218       0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
00219       0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
00220       0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
00221       0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
00222       0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
00223       0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
00224       0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
00225       0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
00226       0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
00227       0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
00228       0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
00229       0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
00230       0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
00231       0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
00232       0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
00233       0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
00234       0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
00235       0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
00236       0xf9, 0xfa };
00237   
00238   static const UINT8 bits_ac_chrominance[17] =
00239     { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
00240   static const UINT8 val_ac_chrominance[] =
00241     { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
00242       0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
00243       0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
00244       0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
00245       0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
00246       0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
00247       0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
00248       0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
00249       0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
00250       0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
00251       0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
00252       0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
00253       0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
00254       0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
00255       0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
00256       0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
00257       0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
00258       0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
00259       0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
00260       0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
00261       0xf9, 0xfa };
00262   
00263   add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
00264          bits_dc_luminance, val_dc_luminance);
00265   add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
00266          bits_ac_luminance, val_ac_luminance);
00267   add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
00268          bits_dc_chrominance, val_dc_chrominance);
00269   add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
00270          bits_ac_chrominance, val_ac_chrominance);
00271 }
00272 
00273 
00274 /*
00275  * Default parameter setup for compression.
00276  *
00277  * Applications that don't choose to use this routine must do their
00278  * own setup of all these parameters.  Alternately, you can call this
00279  * to establish defaults and then alter parameters selectively.  This
00280  * is the recommended approach since, if we add any new parameters,
00281  * your code will still work (they'll be set to reasonable defaults).
00282  */
00283 
00284 GLOBAL(void)
00285 jpeg_set_defaults (j_compress_ptr cinfo)
00286 {
00287   int i;
00288 
00289   /* Safety check to ensure start_compress not called yet. */
00290   if (cinfo->global_state != CSTATE_START)
00291     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
00292 
00293   /* Allocate comp_info array large enough for maximum component count.
00294    * Array is made permanent in case application wants to compress
00295    * multiple images at same param settings.
00296    */
00297   if (cinfo->comp_info == NULL)
00298     cinfo->comp_info = (jpeg_component_info *)
00299       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
00300                   MAX_COMPONENTS * SIZEOF(jpeg_component_info));
00301 
00302   /* Initialize everything not dependent on the color space */
00303 
00304   cinfo->scale_num = 1;     /* 1:1 scaling */
00305   cinfo->scale_denom = 1;
00306   cinfo->data_precision = BITS_IN_JSAMPLE;
00307   /* Set up two quantization tables using default quality of 75 */
00308   jpeg_set_quality(cinfo, 75, TRUE);
00309   /* Set up two Huffman tables */
00310   std_huff_tables(cinfo);
00311 
00312   /* Initialize default arithmetic coding conditioning */
00313   for (i = 0; i < NUM_ARITH_TBLS; i++) {
00314     cinfo->arith_dc_L[i] = 0;
00315     cinfo->arith_dc_U[i] = 1;
00316     cinfo->arith_ac_K[i] = 5;
00317   }
00318 
00319   /* Default is no multiple-scan output */
00320   cinfo->scan_info = NULL;
00321   cinfo->num_scans = 0;
00322 
00323   /* Expect normal source image, not raw downsampled data */
00324   cinfo->raw_data_in = FALSE;
00325 
00326   /* The standard Huffman tables are only valid for 8-bit data precision.
00327    * If the precision is higher, use arithmetic coding.
00328    * (Alternatively, using Huffman coding would be possible with forcing
00329    * optimization on so that usable tables will be computed, or by
00330    * supplying default tables that are valid for the desired precision.)
00331    * Otherwise, use Huffman coding by default.
00332    */
00333   cinfo->arith_code = cinfo->data_precision > 8 ? TRUE : FALSE;
00334 
00335   /* By default, don't do extra passes to optimize entropy coding */
00336   cinfo->optimize_coding = FALSE;
00337 
00338   /* By default, use the simpler non-cosited sampling alignment */
00339   cinfo->CCIR601_sampling = FALSE;
00340 
00341   /* By default, apply fancy downsampling */
00342   cinfo->do_fancy_downsampling = TRUE;
00343 
00344   /* No input smoothing */
00345   cinfo->smoothing_factor = 0;
00346 
00347   /* DCT algorithm preference */
00348   cinfo->dct_method = JDCT_DEFAULT;
00349 
00350   /* No restart markers */
00351   cinfo->restart_interval = 0;
00352   cinfo->restart_in_rows = 0;
00353 
00354   /* Fill in default JFIF marker parameters.  Note that whether the marker
00355    * will actually be written is determined by jpeg_set_colorspace.
00356    *
00357    * By default, the library emits JFIF version code 1.01.
00358    * An application that wants to emit JFIF 1.02 extension markers should set
00359    * JFIF_minor_version to 2.  We could probably get away with just defaulting
00360    * to 1.02, but there may still be some decoders in use that will complain
00361    * about that; saying 1.01 should minimize compatibility problems.
00362    *
00363    * For wide gamut colorspaces (BG_RGB and BG_YCC), the major version will be
00364    * overridden by jpeg_set_colorspace and set to 2.
00365    */
00366   cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
00367   cinfo->JFIF_minor_version = 1;
00368   cinfo->density_unit = 0;  /* Pixel size is unknown by default */
00369   cinfo->X_density = 1;     /* Pixel aspect ratio is square by default */
00370   cinfo->Y_density = 1;
00371 
00372   /* No color transform */
00373   cinfo->color_transform = JCT_NONE;
00374 
00375   /* Choose JPEG colorspace based on input space, set defaults accordingly */
00376 
00377   jpeg_default_colorspace(cinfo);
00378 }
00379 
00380 
00381 /*
00382  * Select an appropriate JPEG colorspace for in_color_space.
00383  */
00384 
00385 GLOBAL(void)
00386 jpeg_default_colorspace (j_compress_ptr cinfo)
00387 {
00388   switch (cinfo->in_color_space) {
00389   case JCS_UNKNOWN:
00390     jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
00391     break;
00392   case JCS_GRAYSCALE:
00393     jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
00394     break;
00395   case JCS_RGB:
00396     jpeg_set_colorspace(cinfo, JCS_YCbCr);
00397     break;
00398   case JCS_YCbCr:
00399     jpeg_set_colorspace(cinfo, JCS_YCbCr);
00400     break;
00401   case JCS_CMYK:
00402     jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
00403     break;
00404   case JCS_YCCK:
00405     jpeg_set_colorspace(cinfo, JCS_YCCK);
00406     break;
00407   case JCS_BG_RGB:
00408     /* No translation for now -- conversion to BG_YCC not yet supportet */
00409     jpeg_set_colorspace(cinfo, JCS_BG_RGB);
00410     break;
00411   case JCS_BG_YCC:
00412     jpeg_set_colorspace(cinfo, JCS_BG_YCC);
00413     break;
00414   default:
00415     ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
00416   }
00417 }
00418 
00419 
00420 /*
00421  * Set the JPEG colorspace, and choose colorspace-dependent default values.
00422  */
00423 
00424 GLOBAL(void)
00425 jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
00426 {
00427   jpeg_component_info * compptr;
00428   int ci;
00429 
00430 #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl)  \
00431   (compptr = &cinfo->comp_info[index], \
00432    compptr->component_id = (id), \
00433    compptr->h_samp_factor = (hsamp), \
00434    compptr->v_samp_factor = (vsamp), \
00435    compptr->quant_tbl_no = (quant), \
00436    compptr->dc_tbl_no = (dctbl), \
00437    compptr->ac_tbl_no = (actbl) )
00438 
00439   /* Safety check to ensure start_compress not called yet. */
00440   if (cinfo->global_state != CSTATE_START)
00441     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
00442 
00443   /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
00444    * tables 1 for chrominance components.
00445    */
00446 
00447   cinfo->jpeg_color_space = colorspace;
00448 
00449   cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
00450   cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
00451 
00452   switch (colorspace) {
00453   case JCS_UNKNOWN:
00454     cinfo->num_components = cinfo->input_components;
00455     if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
00456       ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
00457            MAX_COMPONENTS);
00458     for (ci = 0; ci < cinfo->num_components; ci++) {
00459       SET_COMP(ci, ci, 1,1, 0, 0,0);
00460     }
00461     break;
00462   case JCS_GRAYSCALE:
00463     cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
00464     cinfo->num_components = 1;
00465     /* JFIF specifies component ID 1 */
00466     SET_COMP(0, 0x01, 1,1, 0, 0,0);
00467     break;
00468   case JCS_RGB:
00469     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
00470     cinfo->num_components = 3;
00471     SET_COMP(0, 0x52 /* 'R' */, 1,1, 0,
00472         cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
00473         cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
00474     SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
00475     SET_COMP(2, 0x42 /* 'B' */, 1,1, 0,
00476         cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
00477         cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
00478     break;
00479   case JCS_YCbCr:
00480     cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
00481     cinfo->num_components = 3;
00482     /* JFIF specifies component IDs 1,2,3 */
00483     /* We default to 2x2 subsamples of chrominance */
00484     SET_COMP(0, 0x01, 2,2, 0, 0,0);
00485     SET_COMP(1, 0x02, 1,1, 1, 1,1);
00486     SET_COMP(2, 0x03, 1,1, 1, 1,1);
00487     break;
00488   case JCS_CMYK:
00489     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
00490     cinfo->num_components = 4;
00491     SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
00492     SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
00493     SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
00494     SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
00495     break;
00496   case JCS_YCCK:
00497     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
00498     cinfo->num_components = 4;
00499     SET_COMP(0, 0x01, 2,2, 0, 0,0);
00500     SET_COMP(1, 0x02, 1,1, 1, 1,1);
00501     SET_COMP(2, 0x03, 1,1, 1, 1,1);
00502     SET_COMP(3, 0x04, 2,2, 0, 0,0);
00503     break;
00504   case JCS_BG_RGB:
00505     cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
00506     cinfo->JFIF_major_version = 2;   /* Set JFIF major version = 2 */
00507     cinfo->num_components = 3;
00508     /* Add offset 0x20 to the normal R/G/B component IDs */
00509     SET_COMP(0, 0x72 /* 'r' */, 1,1, 0,
00510         cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
00511         cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
00512     SET_COMP(1, 0x67 /* 'g' */, 1,1, 0, 0,0);
00513     SET_COMP(2, 0x62 /* 'b' */, 1,1, 0,
00514         cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
00515         cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
00516     break;
00517   case JCS_BG_YCC:
00518     cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
00519     cinfo->JFIF_major_version = 2;   /* Set JFIF major version = 2 */
00520     cinfo->num_components = 3;
00521     /* Add offset 0x20 to the normal Cb/Cr component IDs */
00522     /* We default to 2x2 subsamples of chrominance */
00523     SET_COMP(0, 0x01, 2,2, 0, 0,0);
00524     SET_COMP(1, 0x22, 1,1, 1, 1,1);
00525     SET_COMP(2, 0x23, 1,1, 1, 1,1);
00526     break;
00527   default:
00528     ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
00529   }
00530 }
00531 
00532 
00533 #ifdef C_PROGRESSIVE_SUPPORTED
00534 
00535 LOCAL(jpeg_scan_info *)
00536 fill_a_scan (jpeg_scan_info * scanptr, int ci,
00537          int Ss, int Se, int Ah, int Al)
00538 /* Support routine: generate one scan for specified component */
00539 {
00540   scanptr->comps_in_scan = 1;
00541   scanptr->component_index[0] = ci;
00542   scanptr->Ss = Ss;
00543   scanptr->Se = Se;
00544   scanptr->Ah = Ah;
00545   scanptr->Al = Al;
00546   scanptr++;
00547   return scanptr;
00548 }
00549 
00550 LOCAL(jpeg_scan_info *)
00551 fill_scans (jpeg_scan_info * scanptr, int ncomps,
00552         int Ss, int Se, int Ah, int Al)
00553 /* Support routine: generate one scan for each component */
00554 {
00555   int ci;
00556 
00557   for (ci = 0; ci < ncomps; ci++) {
00558     scanptr->comps_in_scan = 1;
00559     scanptr->component_index[0] = ci;
00560     scanptr->Ss = Ss;
00561     scanptr->Se = Se;
00562     scanptr->Ah = Ah;
00563     scanptr->Al = Al;
00564     scanptr++;
00565   }
00566   return scanptr;
00567 }
00568 
00569 LOCAL(jpeg_scan_info *)
00570 fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
00571 /* Support routine: generate interleaved DC scan if possible, else N scans */
00572 {
00573   int ci;
00574 
00575   if (ncomps <= MAX_COMPS_IN_SCAN) {
00576     /* Single interleaved DC scan */
00577     scanptr->comps_in_scan = ncomps;
00578     for (ci = 0; ci < ncomps; ci++)
00579       scanptr->component_index[ci] = ci;
00580     scanptr->Ss = scanptr->Se = 0;
00581     scanptr->Ah = Ah;
00582     scanptr->Al = Al;
00583     scanptr++;
00584   } else {
00585     /* Noninterleaved DC scan for each component */
00586     scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
00587   }
00588   return scanptr;
00589 }
00590 
00591 
00592 /*
00593  * Create a recommended progressive-JPEG script.
00594  * cinfo->num_components and cinfo->jpeg_color_space must be correct.
00595  */
00596 
00597 GLOBAL(void)
00598 jpeg_simple_progression (j_compress_ptr cinfo)
00599 {
00600   int ncomps = cinfo->num_components;
00601   int nscans;
00602   jpeg_scan_info * scanptr;
00603 
00604   /* Safety check to ensure start_compress not called yet. */
00605   if (cinfo->global_state != CSTATE_START)
00606     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
00607 
00608   /* Figure space needed for script.  Calculation must match code below! */
00609   if (ncomps == 3 &&
00610       (cinfo->jpeg_color_space == JCS_YCbCr ||
00611        cinfo->jpeg_color_space == JCS_BG_YCC)) {
00612     /* Custom script for YCC color images. */
00613     nscans = 10;
00614   } else {
00615     /* All-purpose script for other color spaces. */
00616     if (ncomps > MAX_COMPS_IN_SCAN)
00617       nscans = 6 * ncomps;  /* 2 DC + 4 AC scans per component */
00618     else
00619       nscans = 2 + 4 * ncomps;  /* 2 DC scans; 4 AC scans per component */
00620   }
00621 
00622   /* Allocate space for script.
00623    * We need to put it in the permanent pool in case the application performs
00624    * multiple compressions without changing the settings.  To avoid a memory
00625    * leak if jpeg_simple_progression is called repeatedly for the same JPEG
00626    * object, we try to re-use previously allocated space, and we allocate
00627    * enough space to handle YCC even if initially asked for grayscale.
00628    */
00629   if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
00630     cinfo->script_space_size = MAX(nscans, 10);
00631     cinfo->script_space = (jpeg_scan_info *)
00632       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
00633             cinfo->script_space_size * SIZEOF(jpeg_scan_info));
00634   }
00635   scanptr = cinfo->script_space;
00636   cinfo->scan_info = scanptr;
00637   cinfo->num_scans = nscans;
00638 
00639   if (ncomps == 3 &&
00640       (cinfo->jpeg_color_space == JCS_YCbCr ||
00641        cinfo->jpeg_color_space == JCS_BG_YCC)) {
00642     /* Custom script for YCC color images. */
00643     /* Initial DC scan */
00644     scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
00645     /* Initial AC scan: get some luma data out in a hurry */
00646     scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
00647     /* Chroma data is too small to be worth expending many scans on */
00648     scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
00649     scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
00650     /* Complete spectral selection for luma AC */
00651     scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
00652     /* Refine next bit of luma AC */
00653     scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
00654     /* Finish DC successive approximation */
00655     scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
00656     /* Finish AC successive approximation */
00657     scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
00658     scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
00659     /* Luma bottom bit comes last since it's usually largest scan */
00660     scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
00661   } else {
00662     /* All-purpose script for other color spaces. */
00663     /* Successive approximation first pass */
00664     scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
00665     scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
00666     scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
00667     /* Successive approximation second pass */
00668     scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
00669     /* Successive approximation final pass */
00670     scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
00671     scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
00672   }
00673 }
00674 
00675 #endif /* C_PROGRESSIVE_SUPPORTED */