jcparam.c

JPEG Image compression using IJG standards followed

      0x08, 0x09, 0x0a, 0x13, 0x12, 0x14, 0x11, 0x15, 
      0x16, 0x17, 0x23, 0x22, 0x24, 0x21, 0x25, 0x26,
      0x33, 0x32, 0x34, 0x31, 0x35, 0x18, 0x19, 0x0b, 
	  0x0c, 0x0d, 0x0e, 0x0f, 0x1a, 0x1b, 0x1c, 0x1d,
	  0x1e, 0x1f, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c,
	  0x2d, 0x2e, 0x2f, 0x36, 0x37, 0x38, 
	  0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 
	  0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 
	  0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
	  0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 
	  0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
	  0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 
	  0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0xf0
	};
*/

/*
  These tables are designed for the binDCT coef generated by the
  unnormalized Harr, according to Trac's paper.

  static const UINT8 bits_dc_luminance_lossless[17] =
    { 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 };
  static const UINT8 val_dc_luminance_lossless[] =
    { 7, 9, 8, 10, 6, 5, 11, 4, 3, 2, 1, 0, 12, 13, 14, 15};

  static const UINT8 bits_dc_chrominance_lossless[17] =
    { 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 };
  static const UINT8 val_dc_chrominance_lossless[] =
    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };

  //These tbles are designed for unnormalized butterflies.
  static const UINT8 bits_ac_luminance_lossless[17] =
  { 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 114};

  static const UINT8 val_ac_luminance_lossless[] =
    { 0x02, 0x01, 0x03, 0x00, 0x04, 0x05, 0x06, 0x12,
      0x11, 0x13, 0x07, 0x14, 0x08, 0x21, 0x22, 0x09, 
      0x23, 0x15, 0x0a, 0x31, 0x32, 0x24, 0x16, 0x33, 
	  0x17, 0x41, 0x42, 0x34, 0x25, 0x0b, 0x18, 0xf0,
	  0x43, 0x51, 0x52, 0x26, 0x53, 0x44, 0x35, 0x62, 
	  0x61, 0x63, 0x54, 0x45, 0x19, 0x71, 0x72, 0x27, 
	  0x36, 0x73, 0x81, 0x82, 0x91, 0x92, 0x55, 
	  0xa1, 0xa2, 0xb1, 0xb2, 0xc1, 0xc2, 
	  0x0c, 0x0d, 0x1a, 0x1b, 0x28, 0x29, 0x37, 0x38,
	  0x46, 0x47, 0x56, 0x57, 0x64, 0x65, 0x74, 0x75,
	  0x84, 0x85, 0x93, 0x94, 0xa3, 0xa4, 0xb3, 0xb4, 
	  0xc3, 0xc4, 
	  0x0e, 0x0f, 0x1c, 0x1d, 0x1e, 0x1f, 0x2a, 0x2b, 
	  0x2c, 0x2d, 0x2e, 0x2f, 0x39, 0x3a, 0x3b, 0x3c, 
	  0x3d, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x58, 0x59, 
	  0x5a, 0x5b, 0x5c, 0x66, 0x67, 0x68, 0x69, 0x6a, 
	  0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x86, 0x87, 
	  0x88, 0x89, 0x95, 0x96, 0x97, 0x98, 0xa5, 0xa6, 
	  0xb5, 0xb6, 0xc5, 0xc6, 0xd1, 0xd2, 0xd3, 0xd4, 
	  0xe1, 0xe2, 0xe3, 0xe4, 0xf1, 0xf2, 0xf3, 0xf4
	};
	    	    	    
  static const UINT8 bits_ac_chrominance_lossless[17] =
    { 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
  static const UINT8 val_ac_chrominance_lossless[] =
    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
      0xf9, 0xfa };
*/

  //New Huff table, after optimizing the unnormalized Harr.

  static const UINT8 bits_dc_luminance_lossless[17] =
    { 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 };
  static const UINT8 val_dc_luminance_lossless[] =
	{ 3, 4, 2, 5, 6, 1, 7, 0, 8, 9, 10, 11, 12, 13, 14, 15};

  static const UINT8 bits_dc_chrominance_lossless[17] =
    { 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 };
  static const UINT8 val_dc_chrominance_lossless[] =
    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };

  //These tbles are designed for unnormalized butterflies.
  static const UINT8 bits_ac_luminance_lossless[17] =
  { 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 109};

  /*
  static const UINT8 val_ac_luminance_lossless[] =
    { 0x02, 0x01, 0x03, 0x04, 0x05, 0x12, 0x11,
      0x13, 0x06, 0x14, 0x00, 0x07, 0x22, 0x21, 0x15, 0x23, 
	  0x24, 0x08, 0x16, 0x32, 0x31, 0x33, 0x34, 0x25,
	  0x17, 0x42, 0x41, 0x35, 0x43, 0x26, 0x51, 
	  0x44, 0x53, 0x52, 0x09, 0x61, 0x45, 0x36, 0x18,
	  0x64, 0x73, 0x27, 0x37, 0x0a, 0xf0,
	  0x19, 0x28, 0x38, 0x46, 0x54, 0x62, 0x63, 0x71, 
	  0x72, 0x81, 0x91, 0x82, 0x92, 0x0b, 0x1a, 0x29, 
	  0x39, 0x47, 0x55, 0x65, 0x74,
	  0x0c, 0x0d, 0x1b, 0x1c, 0x2a, 0x2b, 0x3a, 0x3b,
	  0x48, 0x49, 0x4a, 0x56, 0x57, 0x58, 0x66, 0x67,
	  0x68, 0x75, 0x76, 0x77, 0x78, 0x83, 0x84, 0x85,
	  0x86, 0x87, 0x88, 0x93, 0x94, 0x95, 0x96, 0x97, 
	  0x98, 0xa1, 0xa2, 0xb1, 0xb2, 0xc1, 0xc2, 0xa3, 
	  0xa4, 0xb3, 0xb4, 0xc3, 0xc4,   
	  0x0e, 0x0f, 0x1d, 0x1e, 0x1f, 0x2c, 0x2d, 0x3c, 
	  0x3d, 0x4b, 0x4c, 0x59, 0x69, 0x89, 0x8a, 0x99, 
	  0x9a, 0xa5, 0xa6, 0xb5, 0xb6, 0xc5, 
	  0xc6, 0xd1, 0xd2, 0xd3, 0xd4, 0xe1, 0xe2, 0xe3, 
	  0xe4, 0xf1, 0xf2, 0xf3, 0xf4
	};
  */

  static const UINT8 val_ac_luminance_lossless[] =
    { 0x02, 0x01, 0x03, 0x04, 0x05, 0x12, 0x11, 0x13, 
	  0x06, 0x14, 0x00, 0x07, 0x22, 0x21, 0x15, 0x23, 
	  0x24, 0x08, 0x16, 0x32, 0x31, 0x33, 0x34, 0x25,
	  0x17, 0x42, 0x41, 0x43, 0x35, 0x51, 0x26, 0x44,
	  0x09, 0x52, 0x18, 0x36, 0x45, 0x53, 0x62, 0x61, 0x46,
	  0x0a, 0x27, 0x19, 0x54, 0x1a, 0x55, 0x64, 0x73, 
	  0x37, 0xf0, 0x28, 0x38, 0x63, 0x71, 

	  0x72, 0x81, 0x91, 0x82, 0x92, 0x0b, 0x29, 
	  0x39, 0x47, 0x65, 0x74,
	  0x0c, 0x0d, 0x1b, 0x1c, 0x2a, 0x2b, 0x3a, 0x3b,
	  0x48, 0x49, 0x4a, 0x56, 0x57, 0x58, 0x66, 0x67,
	  0x68, 0x75, 0x76, 0x77, 0x78, 0x83, 0x84, 0x85,
	  0x86, 0x87, 0x88, 0x93, 0x94, 0x95, 0x96, 0x97, 
	  0x98, 0xa1, 0xa2, 0xb1, 0xb2, 0xc1, 0xc2, 0xa3, 
	  0xa4, 0xb3, 0xb4, 0xc3, 0xc4,   
	  0x0e, 0x0f, 0x1d, 0x1e, 0x1f, 0x2c, 0x2d, 0x3c, 
	  0x3d, 0x4b, 0x4c, 0x59, 0x69, 0x89, 0x8a, 0x99, 
	  0x9a, 0xa5, 0xa6, 0xb5, 0xb6, 0xc5, 
	  0xc6, 0xd1, 0xd2, 0xd3, 0xd4, 0xe1, 0xe2, 0xe3, 
	  0xe4, 0xf1, 0xf2, 0xf3, 0xf4
	};

  static const UINT8 bits_ac_chrominance_lossless[17] =
    { 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
  static const UINT8 val_ac_chrominance_lossless[] =
    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
      0xf9, 0xfa };


//******************************************************	    

  if ( has_losslessBinDCT_switches() ) {

	// use new Huff table for lossless binDCT.
    add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
		 bits_dc_luminance_lossless, val_dc_luminance_lossless);
	
    add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
		 bits_ac_luminance_lossless, val_ac_luminance_lossless);

	add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
		 bits_dc_chrominance_lossless, val_dc_chrominance_lossless);
	add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
		 bits_ac_chrominance_lossless, val_ac_chrominance_lossless);  

  } else {

    add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
		 bits_dc_luminance, val_dc_luminance);

	add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
		 bits_ac_luminance, val_ac_luminance);

	add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
		 bits_dc_chrominance, val_dc_chrominance);
	add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
		 bits_ac_chrominance, val_ac_chrominance);  
  }




}
  

/*
 * Default parameter setup for compression.
 *
 * Applications that don't choose to use this routine must do their
 * own setup of all these parameters.  Alternately, you can call this
 * to establish defaults and then alter parameters selectively.  This
 * is the recommended approach since, if we add any new parameters,
 * your code will still work (they'll be set to reasonable defaults).
 */

GLOBAL(void)
jpeg_set_defaults (j_compress_ptr cinfo)
{
  int i;

  /* Safety check to ensure start_compress not called yet. */
  if (cinfo->global_state != CSTATE_START)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

  /* Allocate comp_info array large enough for maximum component count.
   * Array is made permanent in case application wants to compress
   * multiple images at same param settings.
   */
  if (cinfo->comp_info == NULL)
    cinfo->comp_info = (jpeg_component_info *)
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
				  MAX_COMPONENTS * SIZEOF(jpeg_component_info));

  /* Initialize everything not dependent on the color space */

  cinfo->data_precision = BITS_IN_JSAMPLE;
  /* Set up two quantization tables using default quality of 75 */
  jpeg_set_quality(cinfo, 75, TRUE);
  /* Set up two Huffman tables */
  std_huff_tables(cinfo);

  /* Initialize default arithmetic coding conditioning */
  for (i = 0; i < NUM_ARITH_TBLS; i++) {
    cinfo->arith_dc_L[i] = 0;
    cinfo->arith_dc_U[i] = 1;
    cinfo->arith_ac_K[i] = 5;
  }

  /* Default is no multiple-scan output */
  cinfo->scan_info = NULL;
  cinfo->num_scans = 0;

  /* Expect normal source image, not raw downsampled data */
  cinfo->raw_data_in = FALSE;

  /* Use Huffman coding, not arithmetic coding, by default */
  cinfo->arith_code = FALSE;

  /* By default, don't do extra passes to optimize entropy coding */
  cinfo->optimize_coding = FALSE;
  /* The standard Huffman tables are only valid for 8-bit data precision.
   * If the precision is higher, force optimization on so that usable
   * tables will be computed.  This test can be removed if default tables
   * are supplied that are valid for the desired precision.
   */
  if (cinfo->data_precision > 8)
    cinfo->optimize_coding = TRUE;

  /* By default, use the simpler non-cosited sampling alignment */
  cinfo->CCIR601_sampling = FALSE;

  /* No input smoothing */
  cinfo->smoothing_factor = 0;

  /* DCT algorithm preference */
  cinfo->dct_method = JDCT_DEFAULT;

  /* No restart markers */