| public jpeg_set_colorspace ( J_COLOR_SPACE colorspace ) : void | ||
| colorspace | J_COLOR_SPACE | The required colorspace. |
| return | void | |
/// <summary>
/// Initializes the compression object with default parameters, then copy from the source object
/// all parameters needed for lossless transcoding.
/// </summary>
/// <param name="dstinfo">Target JPEG compression object.</param>
/// <remarks>Parameters that can be varied without loss (such as scan script and
/// Huffman optimization) are left in their default states.</remarks>
public void jpeg_copy_critical_parameters(jpeg_compress_struct dstinfo)
{
/* Safety check to ensure start_compress not called yet. */
if (dstinfo.m_global_state != JpegState.CSTATE_START)
ERREXIT(J_MESSAGE_CODE.JERR_BAD_STATE, (int)dstinfo.m_global_state);
/* Copy fundamental image dimensions */
dstinfo.m_image_width = m_image_width;
dstinfo.m_image_height = m_image_height;
dstinfo.m_input_components = m_num_components;
dstinfo.m_in_color_space = m_jpeg_color_space;
/* Initialize all parameters to default values */
dstinfo.jpeg_set_defaults();
/* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
* Fix it to get the right header markers for the image colorspace.
*/
dstinfo.jpeg_set_colorspace(m_jpeg_color_space);
dstinfo.m_data_precision = m_data_precision;
dstinfo.m_CCIR601_sampling = m_CCIR601_sampling;
/* Copy the source's quantization tables. */
for (int tblno = 0; tblno < JpegConstants.NUM_QUANT_TBLS; tblno++)
{
if (m_quant_tbl_ptrs[tblno] != null)
{
if (dstinfo.m_quant_tbl_ptrs[tblno] == null)
dstinfo.m_quant_tbl_ptrs[tblno] = new JQUANT_TBL();
Buffer.BlockCopy(m_quant_tbl_ptrs[tblno].quantval, 0,
dstinfo.m_quant_tbl_ptrs[tblno].quantval, 0,
dstinfo.m_quant_tbl_ptrs[tblno].quantval.Length * sizeof(short));
dstinfo.m_quant_tbl_ptrs[tblno].Sent_table = false;
}
}
/* Copy the source's per-component info.
* Note we assume jpeg_set_defaults has allocated the dest comp_info array.
*/
dstinfo.m_num_components = m_num_components;
if (dstinfo.m_num_components < 1 || dstinfo.m_num_components> JpegConstants.MAX_COMPONENTS)
ERREXIT(J_MESSAGE_CODE.JERR_COMPONENT_COUNT, dstinfo.m_num_components, JpegConstants.MAX_COMPONENTS);
for (int ci = 0; ci < dstinfo.m_num_components; ci++)
{
dstinfo.Component_info[ci].Component_id = m_comp_info[ci].Component_id;
dstinfo.Component_info[ci].H_samp_factor = m_comp_info[ci].H_samp_factor;
dstinfo.Component_info[ci].V_samp_factor = m_comp_info[ci].V_samp_factor;
dstinfo.Component_info[ci].Quant_tbl_no = m_comp_info[ci].Quant_tbl_no;
/* Make sure saved quantization table for component matches the qtable
* slot. If not, the input file re-used this qtable slot.
* IJG encoder currently cannot duplicate this.
*/
int tblno = dstinfo.Component_info[ci].Quant_tbl_no;
if (tblno < 0 || tblno >= JpegConstants.NUM_QUANT_TBLS || m_quant_tbl_ptrs[tblno] == null)
ERREXIT(J_MESSAGE_CODE.JERR_NO_QUANT_TABLE, tblno);
JQUANT_TBL c_quant = m_comp_info[ci].quant_table;
if (c_quant != null)
{
JQUANT_TBL slot_quant = m_quant_tbl_ptrs[tblno];
for (int coefi = 0; coefi < JpegConstants.DCTSIZE2; coefi++)
{
if (c_quant.quantval[coefi] != slot_quant.quantval[coefi])
ERREXIT(J_MESSAGE_CODE.JERR_MISMATCHED_QUANT_TABLE, tblno);
}
}
/* Note: we do not copy the source's Huffman table assignments;
* instead we rely on jpeg_set_colorspace to have made a suitable choice.
*/
}
/* Also copy JFIF version and resolution information, if available.
* Strictly speaking this isn't "critical" info, but it's nearly
* always appropriate to copy it if available. In particular,
* if the application chooses to copy JFIF 1.02 extension markers from
* the source file, we need to copy the version to make sure we don't
* emit a file that has 1.02 extensions but a claimed version of 1.01.
* We will *not*, however, copy version info from mislabeled "2.01" files.
*/
if (m_saw_JFIF_marker)
{
if (m_JFIF_major_version == 1)
{
dstinfo.m_JFIF_major_version = m_JFIF_major_version;
dstinfo.m_JFIF_minor_version = m_JFIF_minor_version;
}
dstinfo.m_density_unit = m_density_unit;
dstinfo.m_X_density = (short)m_X_density;
dstinfo.m_Y_density = (short)m_Y_density;
}
}
private static bool applyOptions(jpeg_compress_struct compressor, CompressOptions options)
{
compressor.jpeg_set_quality(options.Quality, options.ForceBaseline);
compressor.Dct_method = options.DCTMethod;
if (options.Debug)
compressor.Err.Trace_level = 1;
if (options.Grayscale)
compressor.jpeg_set_colorspace(J_COLOR_SPACE.JCS_GRAYSCALE);
if (options.Optimize)
compressor.Optimize_coding = true;
compressor.Restart_interval = options.RestartInterval;
compressor.Restart_in_rows = options.RestartInRows;
compressor.Smoothing_factor = options.SmoothingFactor;
int q_scale_factor = 100;
if (options.Quality != 75)
q_scale_factor = jpeg_compress_struct.jpeg_quality_scaling(options.Quality);
/* Set quantization tables for selected quality. */
/* Some or all may be overridden if -qtables is present. */
if (options.Qtables != "") /* process -qtables if it was present */
{
if (!read_quant_tables(compressor, options.Qtables, q_scale_factor, options.ForceBaseline))
return false;
}
if (options.Qslots != "") /* process -qslots if it was present */
{
if (!set_quant_slots(compressor, options.Qslots))
return false;
}
if (options.Sample != "") /* process -sample if it was present */
{
if (!set_sample_factors(compressor, options.Sample))
return false;
}
if (options.Progressive) /* process -progressive; -scans can override */
compressor.jpeg_simple_progression();
return true;
}
/// <summary>
/// Parse optional switches.
/// Returns true if switches were parsed successfully; false otherwise.
/// fileIndex receives index of first file-name argument (== -1 if none).
/// for_real is false on the first (dummy) pass; we may skip any expensive
/// processing.
/// </summary>
static bool parse_switches(jpeg_compress_struct cinfo, string[] argv, bool for_real, out int fileIndex)
{
/* Set up default JPEG parameters. */
/* Note that default -quality level need not, and does not,
* match the default scaling for an explicit -qtables argument.
*/
int quality = 75; /* default -quality value */
int q_scale_factor = 100; /* default to no scaling for -qtables */
bool force_baseline = false; /* by default, allow 16-bit quantizers */
bool simple_progressive = false;
string qtablefile = null; /* saves -qtables filename if any */
string qslotsarg = null; /* saves -qslots parm if any */
string samplearg = null; /* saves -sample parm if any */
outfilename = null;
fileIndex = -1;
cinfo.Err.Trace_level = 0;
/* Scan command line options, adjust parameters */
int argn = 0;
for ( ; argn < argv.Length; argn++)
{
string arg = argv[argn];
if (string.IsNullOrEmpty(arg) || arg[0] != '-')
{
/* Not a switch, must be a file name argument */
fileIndex = argn;
break;
}
arg = arg.Substring(1);
if (cdjpeg_utils.keymatch(arg, "baseline", 1))
{
/* Force baseline-compatible output (8-bit quantizer values). */
force_baseline = true;
}
else if (cdjpeg_utils.keymatch(arg, "dct", 2))
{
/* Select DCT algorithm. */
argn++; /* advance to next argument */
if (argn >= argv.Length)
return false;
if (cdjpeg_utils.keymatch(argv[argn], "int", 1))
cinfo.Dct_method = J_DCT_METHOD.JDCT_ISLOW;
else if (cdjpeg_utils.keymatch(argv[argn], "fast", 2))
cinfo.Dct_method = J_DCT_METHOD.JDCT_IFAST;
else if (cdjpeg_utils.keymatch(argv[argn], "float", 2))
cinfo.Dct_method = J_DCT_METHOD.JDCT_FLOAT;
else
return false;
}
else if (cdjpeg_utils.keymatch(arg, "debug", 1) || cdjpeg_utils.keymatch(arg, "verbose", 1))
{
/* Enable debug printouts. */
/* On first -d, print version identification */
if (!printed_version)
{
Console.Write(string.Format("Bit Miracle's CJPEG, version {0}\n{1}\n", jpeg_common_struct.Version, jpeg_common_struct.Copyright));
printed_version = true;
}
cinfo.Err.Trace_level++;
}
else if (cdjpeg_utils.keymatch(arg, "grayscale", 2) || cdjpeg_utils.keymatch(arg, "greyscale", 2))
{
/* Force a monochrome JPEG file to be generated. */
cinfo.jpeg_set_colorspace(J_COLOR_SPACE.JCS_GRAYSCALE);
}
else if (cdjpeg_utils.keymatch(arg, "optimize", 1) || cdjpeg_utils.keymatch(arg, "optimise", 1))
{
/* Enable entropy parm optimization. */
cinfo.Optimize_coding = true;
}
else if (cdjpeg_utils.keymatch(arg, "outfile", 4))
{
/* Set output file name. */
argn++;/* advance to next argument */
if (argn >= argv.Length)
return false;
outfilename = argv[argn]; /* save it away for later use */
}
else if (cdjpeg_utils.keymatch(arg, "progressive", 1))
{
/* Select simple progressive mode. */
simple_progressive = true;
/* We must postpone execution until num_components is known. */
}
else if (cdjpeg_utils.keymatch(arg, "quality", 1))
{
/* Quality factor (quantization table scaling factor). */
argn++;/* advance to next argument */
if (argn >= argv.Length)
return false;
try
{
quality = int.Parse(argv[argn]);
/* Change scale factor in case -qtables is present. */
q_scale_factor = jpeg_compress_struct.jpeg_quality_scaling(quality);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return false;
}
}
else if (cdjpeg_utils.keymatch(arg, "qslots", 2))
{
/* Quantization table slot numbers. */
argn++; /* advance to next argument */
if (argn >= argv.Length)
return false;
qslotsarg = argv[argn];
/* Must delay setting qslots until after we have processed any
* colorspace-determining switches, since jpeg_set_colorspace sets
* default quant table numbers.
*/
}
else if (cdjpeg_utils.keymatch(arg, "qtables", 2))
{
/* Quantization tables fetched from file. */
argn++; /* advance to next argument */
if (argn >= argv.Length)
return false;
qtablefile = argv[argn];
/* We postpone actually reading the file in case -quality comes later. */
}
else if (cdjpeg_utils.keymatch(arg, "restart", 1))
{
/* Restart interval in MCU rows (or in MCUs with 'b'). */
argn++; /* advance to next argument */
if (argn >= argv.Length)
return false;
bool inBlocks = false;
if (argv[argn].EndsWith("b") || argv[argn].EndsWith("B"))
inBlocks = true;
string parsee = argv[argn];
if (inBlocks)
parsee = parsee.Remove(parsee.Length - 1);
try
{
int val = int.Parse(parsee);
if (val < 0 || val > 65535)
return false;
if (inBlocks)
{
cinfo.Restart_interval = val;
cinfo.Restart_in_rows = 0; /* else prior '-restart n' overrides me */
}
else
{
cinfo.Restart_in_rows = val;
/* restart_interval will be computed during startup */
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return false;
}
}
else if (cdjpeg_utils.keymatch(arg, "sample", 2))
{
/* Set sampling factors. */
argn++; /* advance to next argument */
if (argn >= argv.Length)
return false;
samplearg = argv[argn];
/* Must delay setting sample factors until after we have processed any
* colorspace-determining switches, since jpeg_set_colorspace sets
* default sampling factors.
*/
}
else if (cdjpeg_utils.keymatch(arg, "smooth", 2))
{
/* Set input smoothing factor. */
argn++; /* advance to next argument */
if (argn >= argv.Length)
return false;
try
{
int val = int.Parse(argv[argn]);
if (val < 0 || val > 100)
return false;
cinfo.Smoothing_factor = val;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return false;
}
}
else
{
/* bogus switch */
return false;
}
}
/* Post-switch-scanning cleanup */
if (for_real)
{
/* Set quantization tables for selected quality. */
/* Some or all may be overridden if -qtables is present. */
cinfo.jpeg_set_quality(quality, force_baseline);
if (qtablefile != null) /* process -qtables if it was present */
{
if (!read_quant_tables(cinfo, qtablefile, q_scale_factor, force_baseline))
return false;
}
if (qslotsarg != null) /* process -qslots if it was present */
{
if (!set_quant_slots(cinfo, qslotsarg))
return false;
}
if (samplearg != null) /* process -sample if it was present */
{
if (!set_sample_factors(cinfo, samplearg))
return false;
}
if (simple_progressive) /* process -progressive; -scans can override */
cinfo.jpeg_simple_progression();
}
return true;
}
