{

// Quantization table setup routines

// Define a quantization table equal to the basic_table times

// a scale factor (given as a percentage).

// If force_baseline is true, the computed quantization table entries

// are limited to 1..255 for JPEG baseline compatibility.

public static void jpeg_add_quant_table(jpeg_compress cinfo, int which_tbl, uint[] basic_table, int scale_factor, bool force_baseline)

{

// Safety check to ensure start_compress not called yet.

if(cinfo.global_state!=STATE.CSTART) ERREXIT1(cinfo, J_MESSAGE_CODE.JERR_BAD_STATE, cinfo.global_state);

if(which_tbl<0||which_tbl>=NUM_QUANT_TBLS) ERREXIT1(cinfo, J_MESSAGE_CODE.JERR_DQT_INDEX, which_tbl);

if(cinfo.quant_tbl_ptrs[which_tbl]==null) cinfo.quant_tbl_ptrs[which_tbl]=jpeg_alloc_quant_table(cinfo);

for(int i=0; i<DCTSIZE2; i++)

{

int temp=((int)basic_table[i]*scale_factor+50)/100;

// limit the values to the valid range

if(temp<=0) temp=1;

if(temp>32767) temp=32767; // max quantizer needed for 12 bits

if(force_baseline&&temp>255) temp=255; // limit to baseline range if requested

cinfo.quant_tbl_ptrs[which_tbl].quantval[i]=(ushort)temp;

}

// Initialize sent_table false so table will be written to JPEG file.

cinfo.quant_tbl_ptrs[which_tbl].sent_table=false;

}

// These are the sample quantization tables given in JPEG spec section K.1.

// The spec says that the values given produce "good" quality, and

// when divided by 2, "very good" quality.

static readonly uint[] std_luminance_quant_tbl=new uint[DCTSIZE2]

{

16, 11, 10, 16, 24, 40, 51, 61,

12, 12, 14, 19, 26, 58, 60, 55,

14, 13, 16, 24, 40, 57, 69, 56,

14, 17, 22, 29, 51, 87, 80, 62,

18, 22, 37, 56, 68, 109, 103, 77,

24, 35, 55, 64, 81, 104, 113, 92,

49, 64, 78, 87, 103, 121, 120, 101,

72, 92, 95, 98, 112, 100, 103, 99

};

static readonly uint[] std_chrominance_quant_tbl=new uint[DCTSIZE2]

{

17, 18, 24, 47, 99, 99, 99, 99,

18, 21, 26, 66, 99, 99, 99, 99,

24, 26, 56, 99, 99, 99, 99, 99,

47, 66, 99, 99, 99, 99, 99, 99,

99, 99, 99, 99, 99, 99, 99, 99,

99, 99, 99, 99, 99, 99, 99, 99,

99, 99, 99, 99, 99, 99, 99, 99,

99, 99, 99, 99, 99, 99, 99, 99

};

// Set or change the 'quality' (quantization) setting, using default tables

// and a straight percentage-scaling quality scale. In most cases it's better

// to use jpeg_set_quality (below); this entry point is provided for

// applications that insist on a linear percentage scaling.

public static void jpeg_set_linear_quality(jpeg_compress cinfo, int scale_factor, bool force_baseline)

{

// Set up two quantization tables using the specified scaling

jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl, scale_factor, force_baseline);

jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl, scale_factor, force_baseline);

}

// Convert a user-specified quality rating to a percentage scaling factor

// for an underlying quantization table, using our recommended scaling curve.

// The input 'quality' factor should be 0 (terrible) to 100 (very good).

public static int jpeg_quality_scaling(int quality)

{

// Safety limit on quality factor. Convert 0 to 1 to avoid zero divide.

if(quality<=0) quality=1;

if(quality>100) quality=100;

// The basic table is used as-is (scaling 100) for a quality of 50.

// Qualities 50..100 are converted to scaling percentage 200 - 2*Q;

// note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table

// to make all the table entries 1 (hence, minimum quantization loss).

// Qualities 1..50 are converted to scaling percentage 5000/Q.

if(quality<50) quality=5000/quality;

else quality=200-quality*2;

return quality;

}

// Set or change the 'quality' (quantization) setting, using default tables.

// This is the standard quality-adjusting entry point for typical user

// interfaces; only those who want detailed control over quantization tables

// would use the preceding three routines directly.

public static void jpeg_set_quality(jpeg_compress cinfo, int quality, bool force_baseline)

{

// Convert user 0-100 rating to percentage scaling

quality=jpeg_quality_scaling(quality);

// Set up standard quality tables

jpeg_set_linear_quality(cinfo, quality, force_baseline);

}

// Huffman table setup routines

// Define a Huffman table

static void add_huff_table(jpeg_compress cinfo, ref JHUFF_TBL htblptr, byte[] bits, byte[] val)

{

if(htblptr==null) htblptr=jpeg_alloc_huff_table(cinfo);

// Copy the number-of-symbols-of-each-code-length counts

Array.Copy(bits, htblptr.bits, htblptr.bits.Length);

// Validate the counts. We do this here mainly so we can copy the right

// number of symbols from the val[] array, without risking marching off

// the end of memory. jchuff.cs will do a more thorough test later.

int nsymbols=0;

for(int len=1; len<=16; len++) nsymbols+=bits[len];

if(nsymbols<1||nsymbols>256) ERREXIT(cinfo, J_MESSAGE_CODE.JERR_BAD_HUFF_TABLE);

Array.Copy(val, htblptr.huffval, nsymbols);

// Initialize sent_table false so table will be written to JPEG file.

htblptr.sent_table=false;

}

static readonly byte[] bits_dc_luminance=new byte[17] { 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };

static readonly byte[] val_dc_luminance=new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

static readonly byte[] bits_dc_chrominance=new byte[17] { 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };

static readonly byte[] val_dc_chrominance=new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

static readonly byte[] bits_ac_luminance=new byte[17] { 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };

static readonly byte[] val_ac_luminance=new byte[]

{

0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,

0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,

0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,

0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,

0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,

0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,

0x29, 0x2a, 0x34, 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, 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, 0xe1, 0xe2,

0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,

0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,

0xf9, 0xfa

};

static readonly byte[] bits_ac_chrominance=new byte[17] { 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };

static readonly byte[] val_ac_chrominance=new byte[]

{

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

};

// Set up the standard Huffman tables (cf. JPEG standard section K.3)

// IMPORTANT: these are only valid for 8-bit data precision!

static void std_huff_tables(jpeg_compress cinfo)

{

add_huff_table(cinfo, ref cinfo.dc_huff_tbl_ptrs[0], bits_dc_luminance, val_dc_luminance);

add_huff_table(cinfo, ref cinfo.ac_huff_tbl_ptrs[0], bits_ac_luminance, val_ac_luminance);

add_huff_table(cinfo, ref cinfo.dc_huff_tbl_ptrs[1], bits_dc_chrominance, val_dc_chrominance);

add_huff_table(cinfo, ref 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).

public static void jpeg_set_defaults(jpeg_compress cinfo)

{

// Safety check to ensure start_compress not called yet.

if(cinfo.global_state!=STATE.CSTART) ERREXIT1(cinfo, J_MESSAGE_CODE.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)

{

try

{

cinfo.comp_info=new jpeg_component_info[MAX_COMPONENTS];

for(int i=0; i<MAX_COMPONENTS; i++) cinfo.comp_info[i]=new jpeg_component_info();

}

catch

{

ERREXIT1(cinfo, J_MESSAGE_CODE.JERR_OUT_OF_MEMORY, 4);

}

}

// Initialize everything not dependent on the color space

cinfo.lossless=false;

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(int 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;

#if DCT_FLOAT_SUPPORTED

// Use integer DCT

cinfo.useFloatDCT=false;

#endif

// No restart markers

cinfo.restart_interval=0;

cinfo.restart_in_rows=0;

// Fill in default JFIF marker parameters. Note that whether the marker

// will actually be written is determined by jpeg_set_colorspace.

//

// By default, the library emits JFIF version code 1.01.

// An application that wants to emit JFIF 1.02 extension markers should set

// JFIF_minor_version to 2. We could probably get away with just defaulting

// to 1.02, but there may still be some decoders in use that will complain

// about that; saying 1.01 should minimize compatibility problems.

cinfo.JFIF_major_version=1; // Default JFIF version = 1.01

cinfo.JFIF_minor_version=1;

cinfo.density_unit=0; // Pixel size is unknown by default

cinfo.X_density=1; // Pixel aspect ratio is square by default

cinfo.Y_density=1;

// Choose JPEG colorspace based on input space, set defaults accordingly

jpeg_default_colorspace(cinfo);

}

// Select an appropriate JPEG colorspace for in_color_space.

public static void jpeg_default_colorspace(jpeg_compress cinfo)

{

if(cinfo.lossless) jpeg_set_colorspace(cinfo, cinfo.in_color_space);

else

{ // lossy

switch(cinfo.in_color_space)

{

case J_COLOR_SPACE.JCS_GRAYSCALE: jpeg_set_colorspace(cinfo, J_COLOR_SPACE.JCS_GRAYSCALE); break;

case J_COLOR_SPACE.JCS_RGB: jpeg_set_colorspace(cinfo, J_COLOR_SPACE.JCS_YCbCr); break;

case J_COLOR_SPACE.JCS_YCbCr: jpeg_set_colorspace(cinfo, J_COLOR_SPACE.JCS_YCbCr); break;

case J_COLOR_SPACE.JCS_CMYK: jpeg_set_colorspace(cinfo, J_COLOR_SPACE.JCS_CMYK); break; // By default, no translation

case J_COLOR_SPACE.JCS_YCCK: jpeg_set_colorspace(cinfo, J_COLOR_SPACE.JCS_YCCK); break;

case J_COLOR_SPACE.JCS_UNKNOWN: jpeg_set_colorspace(cinfo, J_COLOR_SPACE.JCS_UNKNOWN); break;

default: ERREXIT(cinfo, J_MESSAGE_CODE.JERR_BAD_IN_COLORSPACE); break;

}

}

}

static void SET_COMP(jpeg_compress cinfo, int index, int id, int hsamp, int vsamp, int quant, int dctbl, int actbl)

{

jpeg_component_info compptr=cinfo.comp_info[index];

compptr.component_id=id;

compptr.h_samp_factor=hsamp;

compptr.v_samp_factor=vsamp;

compptr.quant_tbl_no=quant;

compptr.dc_tbl_no=dctbl;

compptr.ac_tbl_no=actbl;

}

// Set the JPEG colorspace, and choose colorspace-dependent default values.

public static void jpeg_set_colorspace(jpeg_compress cinfo, J_COLOR_SPACE colorspace)

{

jpeg_set_colorspace(cinfo, colorspace, J_SUBSAMPLING.JPEG420);

}

// Set the JPEG colorspace, and choose colorspace-dependent default values.

public static void jpeg_set_colorspace(jpeg_compress cinfo, J_COLOR_SPACE colorspace, J_SUBSAMPLING subsampling)

{

// Safety check to ensure start_compress not called yet.

if(cinfo.global_state!=STATE.CSTART) ERREXIT1(cinfo, J_MESSAGE_CODE.JERR_BAD_STATE, cinfo.global_state);

// For all colorspaces, we use Q and Huff tables 0 for luminance components,

// tables 1 for chrominance components.

cinfo.jpeg_color_space=colorspace;

cinfo.write_JFIF_header=false; // No marker for non-JFIF colorspaces

cinfo.write_Adobe_marker=false; // write no Adobe marker by default

switch(colorspace)

{

case J_COLOR_SPACE.JCS_GRAYSCALE:

cinfo.write_JFIF_header=true; // Write a JFIF marker

cinfo.num_components=1;

// JFIF specifies component ID 1

SET_COMP(cinfo, 0, 1, 1, 1, 0, 0, 0);

break;

case J_COLOR_SPACE.JCS_RGB:

cinfo.write_Adobe_marker=true; // write Adobe marker to flag RGB

cinfo.num_components=3;

SET_COMP(cinfo, 0, 0x52, 1, 1, 0, 0, 0); // 0x52 = 'R'

SET_COMP(cinfo, 1, 0x47, 1, 1, 0, 0, 0); // 0x47 = 'G'

SET_COMP(cinfo, 2, 0x42, 1, 1, 0, 0, 0); // 0x42 = 'B'

break;

case J_COLOR_SPACE.JCS_YCbCr:

cinfo.write_JFIF_header=true; // Write a JFIF marker

cinfo.num_components=3;

// JFIF specifies component IDs 1,2,3

if(cinfo.lossless||subsampling==J_SUBSAMPLING.JPEG444)

{

SET_COMP(cinfo, 0, 1, 1, 1, 0, 0, 0);

SET_COMP(cinfo, 1, 2, 1, 1, 1, 1, 1);

SET_COMP(cinfo, 2, 3, 1, 1, 1, 1, 1);

}

else if(subsampling==J_SUBSAMPLING.JPEG422)

{

// We default to 2x1 subsamples of chrominance

SET_COMP(cinfo, 0, 1, 2, 1, 0, 0, 0);

SET_COMP(cinfo, 1, 2, 1, 1, 1, 1, 1);

SET_COMP(cinfo, 2, 3, 1, 1, 1, 1, 1);

}

else

{

// We default to 2x2 subsamples of chrominance

SET_COMP(cinfo, 0, 1, 2, 2, 0, 0, 0);

SET_COMP(cinfo, 1, 2, 1, 1, 1, 1, 1);

SET_COMP(cinfo, 2, 3, 1, 1, 1, 1, 1);

}

break;

case J_COLOR_SPACE.JCS_CMYK:

cinfo.write_Adobe_marker=true; // write Adobe marker to flag CMYK

cinfo.num_components=4;

SET_COMP(cinfo, 0, 0x43, 1, 1, 0, 0, 0); // 0x43 = 'C'

SET_COMP(cinfo, 1, 0x4D, 1, 1, 0, 0, 0); // 0x4D = 'M'

SET_COMP(cinfo, 2, 0x59, 1, 1, 0, 0, 0); // 0x59 = 'Y'

SET_COMP(cinfo, 3, 0x4B, 1, 1, 0, 0, 0); // 0x4B = 'K'

break;

case J_COLOR_SPACE.JCS_YCCK:

cinfo.write_Adobe_marker=true; // write Adobe marker to flag YCCK

cinfo.num_components=4;

if(cinfo.lossless)

{

SET_COMP(cinfo, 0, 1, 1, 1, 0, 0, 0);

SET_COMP(cinfo, 1, 2, 1, 1, 1, 1, 1);

SET_COMP(cinfo, 2, 3, 1, 1, 1, 1, 1);

SET_COMP(cinfo, 3, 4, 1, 1, 0, 0, 0);

}

else

{

SET_COMP(cinfo, 0, 1, 2, 2, 0, 0, 0);

SET_COMP(cinfo, 1, 2, 1, 1, 1, 1, 1);

SET_COMP(cinfo, 2, 3, 1, 1, 1, 1, 1);

SET_COMP(cinfo, 3, 4, 2, 2, 0, 0, 0);

}

break;

case J_COLOR_SPACE.JCS_UNKNOWN:

cinfo.num_components=cinfo.input_components;

if(cinfo.num_components<1||cinfo.num_components>MAX_COMPONENTS) ERREXIT2(cinfo, J_MESSAGE_CODE.JERR_COMPONENT_COUNT, cinfo.num_components, MAX_COMPONENTS);

for(int ci=0; ci<cinfo.num_components; ci++) SET_COMP(cinfo, ci, ci, 1, 1, 0, 0, 0);

break;

default: ERREXIT(cinfo, J_MESSAGE_CODE.JERR_BAD_J_COLORSPACE); break;

}

}

#if C_PROGRESSIVE_SUPPORTED

// Support routine: generate one scan for each component

static int fill_scans(jpeg_scan_info[] scanptr, int scanptr_ind, int ncomps, int Ss, int Se, int Ah, int Al)

{

for(int ci=0; ci<ncomps; ci++)

{

jpeg_scan_info scan=scanptr[scanptr_ind];

scan.comps_in_scan=1;

scan.component_index[0]=ci;

scan.Ss=Ss;

scan.Se=Se;

scan.Ah=Ah;

scan.Al=Al;

scanptr_ind++;

}

return scanptr_ind;

}

// Support routine: generate one scan for specified component

static int fill_a_scan(jpeg_scan_info[] scanptr, int scanptr_ind, int ci, int Ss, int Se, int Ah, int Al)

{

jpeg_scan_info scan=scanptr[scanptr_ind];

scan.comps_in_scan=1;

scan.component_index[0]=ci;

scan.Ss=Ss;

scan.Se=Se;

scan.Ah=Ah;

scan.Al=Al;

scanptr_ind++;

return scanptr_ind;

}

// Support routine: generate interleaved DC scan if possible, else N scans

static int fill_dc_scans(jpeg_scan_info[] scanptr, int scanptr_ind, int ncomps, int Ah, int Al)

{

if(ncomps<=MAX_COMPS_IN_SCAN)

{

jpeg_scan_info scan=scanptr[scanptr_ind];

// Single interleaved DC scan

scan.comps_in_scan=ncomps;

for(int ci=0; ci<ncomps; ci++) scan.component_index[ci]=ci;

scan.Ss=scan.Se=0;

scan.Ah=Ah;

scan.Al=Al;

scanptr_ind++;

}

else

{

// Noninterleaved DC scan for each component

scanptr_ind=fill_scans(scanptr, scanptr_ind, ncomps, 0, 0, Ah, Al);

}

return scanptr_ind;

}

// Create a recommended progressive-JPEG script.

// cinfo.num_components and cinfo.jpeg_color_space must be correct.

public static void jpeg_simple_progression(jpeg_compress cinfo)

{

int ncomps=cinfo.num_components;

// Safety check to ensure start_compress not called yet.

if(cinfo.global_state!=STATE.CSTART) ERREXIT1(cinfo, J_MESSAGE_CODE.JERR_BAD_STATE, cinfo.global_state);

// Figure space needed for script. Calculation must match code below!

int nscans;

if(ncomps==3&&cinfo.jpeg_color_space==J_COLOR_SPACE.JCS_YCbCr)

{ // Custom script for YCbCr color images.

nscans=10;

}

else

{

// All-purpose script for other color spaces.

if(ncomps>MAX_COMPS_IN_SCAN) nscans=6*ncomps; // 2 DC + 4 AC scans per component

else nscans=2+4*ncomps; // 2 DC scans; 4 AC scans per component

}

// Allocate space for script.

// We need to put it in the permanent pool in case the application performs

// multiple compressions without changing the settings. To avoid a memory

// leak if jpeg_simple_progression is called repeatedly for the same JPEG

// object, we try to re-use previously allocated space, and we allocate

// enough space to handle YCbCr even if initially asked for grayscale.

if(cinfo.script_space==null||cinfo.script_space_size<nscans)

{

cinfo.script_space_size=Math.Max(nscans, 10);

try

{

cinfo.script_space=new jpeg_scan_info[cinfo.script_space_size];

for(int i=0; i<cinfo.script_space_size; i++) cinfo.script_space[i]=new jpeg_scan_info();

}

catch

{

ERREXIT1(cinfo, J_MESSAGE_CODE.JERR_OUT_OF_MEMORY, 4);

}

}

jpeg_scan_info[] scanptr=cinfo.script_space;

int scanptr_ind=0;

cinfo.scan_info=scanptr;

cinfo.num_scans=nscans;

if(ncomps==3&&cinfo.jpeg_color_space==J_COLOR_SPACE.JCS_YCbCr)

{

// Custom script for YCbCr color images.

// Initial DC scan

scanptr_ind=fill_dc_scans(scanptr, scanptr_ind, ncomps, 0, 1);

// Initial AC scan: get some luma data out in a hurry

scanptr_ind=fill_a_scan(scanptr, scanptr_ind, 0, 1, 5, 0, 2);

// Chroma data is too small to be worth expending many scans on

scanptr_ind=fill_a_scan(scanptr, scanptr_ind, 2, 1, 63, 0, 1);

scanptr_ind=fill_a_scan(scanptr, scanptr_ind, 1, 1, 63, 0, 1);

// Complete spectral selection for luma AC

scanptr_ind=fill_a_scan(scanptr, scanptr_ind, 0, 6, 63, 0, 2);

// Refine next bit of luma AC

scanptr_ind=fill_a_scan(scanptr, scanptr_ind, 0, 1, 63, 2, 1);

// Finish DC successive approximation

scanptr_ind=fill_dc_scans(scanptr, scanptr_ind, ncomps, 1, 0);

// Finish AC successive approximation

scanptr_ind=fill_a_scan(scanptr, scanptr_ind, 2, 1, 63, 1, 0);

scanptr_ind=fill_a_scan(scanptr, scanptr_ind, 1, 1, 63, 1, 0);

// Luma bottom bit comes last since it's usually largest scan

scanptr_ind=fill_a_scan(scanptr, scanptr_ind, 0, 1, 63, 1, 0);

}

else

{

// All-purpose script for other color spaces.

// Successive approximation first pass

scanptr_ind=fill_dc_scans(scanptr, scanptr_ind, ncomps, 0, 1);

scanptr_ind=fill_scans(scanptr, scanptr_ind, ncomps, 1, 5, 0, 2);

scanptr_ind=fill_scans(scanptr, scanptr_ind, ncomps, 6, 63, 0, 2);

// Successive approximation second pass

scanptr_ind=fill_scans(scanptr, scanptr_ind, ncomps, 1, 63, 2, 1);

// Successive approximation final pass

scanptr_ind=fill_dc_scans(scanptr, scanptr_ind, ncomps, 1, 0);

scanptr_ind=fill_scans(scanptr, scanptr_ind, ncomps, 1, 63, 1, 0);

}

}

#endif // C_PROGRESSIVE_SUPPORTED

#if C_LOSSLESS_SUPPORTED

// Create a single-entry lossless-JPEG script containing all components.

// cinfo.num_components must be correct.

// predictor: 1..7

// point_transform: 0..data_precision(usally 8) // reduction of colors

public static void jpeg_simple_lossless(jpeg_compress cinfo, int predictor, int point_transform)

{

int ncomps=cinfo.num_components;

// Safety check to ensure start_compress not called yet.

if(cinfo.global_state!=STATE.CSTART) ERREXIT1(cinfo, J_MESSAGE_CODE.JERR_BAD_STATE, cinfo.global_state);

cinfo.lossless=true;

// Set jpeg_color_space.

jpeg_default_colorspace(cinfo);

// Check to ensure that all components will fit in one scan.

if(cinfo.num_components>MAX_COMPS_IN_SCAN) ERREXIT2(cinfo, J_MESSAGE_CODE.JERR_COMPONENT_COUNT, cinfo.num_components, MAX_COMPS_IN_SCAN);

// Allocate space for script.

// We need to put it in the permanent pool in case the application performs

// multiple compressions without changing the settings. To avoid a memory

// leak if jpeg_simple_lossless is called repeatedly for the same JPEG

// object, we try to re-use previously allocated space.

int nscans=1;

if(cinfo.script_space==null||cinfo.script_space_size<nscans)

{

cinfo.script_space_size=nscans;

try

{

cinfo.script_space=new jpeg_scan_info[cinfo.script_space_size];

for(int i=0; i<cinfo.script_space_size; i++) cinfo.script_space[i]=new jpeg_scan_info();

}

catch

{

ERREXIT1(cinfo, J_MESSAGE_CODE.JERR_OUT_OF_MEMORY, 4);

}

}

jpeg_scan_info scanptr=cinfo.script_space[0];

cinfo.scan_info=cinfo.script_space;

cinfo.num_scans=nscans;

// Fill the script.

scanptr.comps_in_scan=ncomps;

for(int ci=0; ci<ncomps; ci++) scanptr.component_index[ci]=ci;

scanptr.Ss=predictor;

scanptr.Se=0;

scanptr.Ah=0;

scanptr.Al=point_transform;

}

#endif // C_LOSSLESS_SUPPORTED