/// <summary> Constructs a new 'GuardBitsSpec' for the specified number of components
/// and tiles and the arguments of "-Qguard_bits" option.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="pl">The ParameterList
///
/// </param>
public GuardBitsSpec(int nt, int nc, byte type, ParameterList pl):base(nt, nc, type)
{
System.String param = pl.getParameter("Qguard_bits");
if (param == null)
{
throw new System.ArgumentException("Qguard_bits option not " + "specified");
}
// Parse argument
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
System.String word; // current word
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
bool[] compSpec = null; // Components concerned by the specification
System.Int32 value_Renamed; // value of the guard bits
while (stk.HasMoreTokens())
{
word = stk.NextToken().ToLower();
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
curSpecType = SPEC_TILE_COMP;
else
curSpecType = SPEC_TILE_DEF;
break;
case 'c': // Components specification
compSpec = parseIdx(word, nComp);
if (curSpecType == SPEC_TILE_DEF)
curSpecType = SPEC_TILE_COMP;
else
curSpecType = SPEC_COMP_DEF;
break;
default: // Step size value
try
{
value_Renamed = System.Int32.Parse(word);
}
catch (System.FormatException)
{
throw new System.ArgumentException("Bad parameter for " + "-Qguard_bits option" + " : " + word);
}
if ((float) value_Renamed <= 0.0f)
{
throw new System.ArgumentException("Guard bits value " + "must be positive : " + value_Renamed);
}
if (curSpecType == SPEC_DEF)
{
setDefault((System.Object) value_Renamed);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
if (tileSpec[i])
{
setTileDef(i, (System.Object) value_Renamed);
}
}
else if (curSpecType == SPEC_COMP_DEF)
{
for (int i = compSpec.Length - 1; i >= 0; i--)
if (compSpec[i])
{
setCompDef(i, (System.Object) value_Renamed);
}
}
else
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
for (int j = compSpec.Length - 1; j >= 0; j--)
{
if (tileSpec[i] && compSpec[j])
{
setTileCompVal(i, j, (System.Object) value_Renamed);
}
}
}
}
// Re-initialize
curSpecType = SPEC_DEF;
tileSpec = null;
compSpec = null;
break;
}
}
// Check that default value has been specified
if (getDefault() == null)
{
int ndefspec = 0;
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[t][c] == SPEC_DEF)
{
ndefspec++;
}
}
}
// If some tile-component have received no specification, it takes
// the default value defined in ParameterList
if (ndefspec != 0)
{
setDefault((System.Object) System.Int32.Parse(pl.DefaultParameterList.getParameter("Qguard_bits")));
}
else
{
// All tile-component have been specified, takes the first
// tile-component value as default.
setDefault(getTileCompVal(0, 0));
switch (specValType[0][0])
{
case SPEC_TILE_DEF:
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[0][c] == SPEC_TILE_DEF)
specValType[0][c] = SPEC_DEF;
}
tileDef[0] = null;
break;
case SPEC_COMP_DEF:
for (int t = nt - 1; t >= 0; t--)
{
if (specValType[t][0] == SPEC_COMP_DEF)
specValType[t][0] = SPEC_DEF;
}
compDef[0] = null;
break;
case SPEC_TILE_COMP:
specValType[0][0] = SPEC_DEF;
tileCompVal["t0c0"] = null;
break;
}
}
}
}
/// <summary> Creates a ROIDeScaler object. The information needed to create the
/// object is the Entropy decoder used and the parameters.
///
/// </summary>
/// <param name="src">The source of data that is to be descaled
///
/// </param>
/// <param name="pl">The parameter list (or options).
///
/// </param>
/// <param name="decSpec">The decoding specifications
///
/// </param>
/// <exception cref="IllegalArgumentException">If an error occurs while parsing
/// the options in 'pl'
///
/// </exception>
public static ROIDeScaler createInstance(CBlkQuantDataSrcDec src, ParameterList pl, DecoderSpecs decSpec)
{
System.String noRoi;
//int i;
// Check parameters
pl.checkList(OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(pinfo));
// Check if no_roi specified in command line or no roi signalled
// in bit stream
noRoi = pl.getParameter("Rno_roi");
if (noRoi != null || decSpec.rois == null)
{
// no_roi specified in commandline!
return new ROIDeScaler(src, null);
}
return new ROIDeScaler(src, decSpec.rois);
}
/// <summary> Constructs a new 'IntegerSpec' for the specified number of tiles and
/// components, the allowed specifications type and the ParameterList
/// instance. This constructor is normally called at encoder side and parse
/// arguments of specified option.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">The allowed specifications type
///
/// </param>
/// <param name="pl">The ParameterList instance
///
/// </param>
/// <param name="optName">The name of the option to process
///
/// </param>
public IntegerSpec(int nt, int nc, byte type, ParameterList pl, System.String optName):base(nt, nc, type)
{
System.Int32 value_Renamed;
System.String param = pl.getParameter(optName);
if (param == null)
{
// No parameter specified
param = pl.DefaultParameterList.getParameter(optName);
try
{
setDefault((System.Object) System.Int32.Parse(param));
}
catch (System.FormatException)
{
throw new System.ArgumentException("Non recognized value" + " for option -" + optName + ": " + param);
}
return ;
}
// Parse argument
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
System.String word; // current word
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
bool[] compSpec = null; // Components concerned by the specification
while (stk.HasMoreTokens())
{
word = stk.NextToken();
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_TILE_DEF;
}
break;
case 'c': // Components specification
compSpec = parseIdx(word, nComp);
if (curSpecType == SPEC_TILE_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_COMP_DEF;
}
break;
default:
try
{
value_Renamed = System.Int32.Parse(word);
}
catch (System.FormatException)
{
throw new System.ArgumentException("Non recognized value" + " for option -" + optName + ": " + word);
}
if (curSpecType == SPEC_DEF)
{
setDefault((System.Object) value_Renamed);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
if (tileSpec[i])
{
setTileDef(i, (System.Object) value_Renamed);
}
}
else if (curSpecType == SPEC_COMP_DEF)
{
for (int i = compSpec.Length - 1; i >= 0; i--)
if (compSpec[i])
{
setCompDef(i, (System.Object) value_Renamed);
}
}
else
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
for (int j = compSpec.Length - 1; j >= 0; j--)
{
if (tileSpec[i] && compSpec[j])
{
setTileCompVal(i, j, (System.Object) value_Renamed);
}
}
}
}
// Re-initialize
curSpecType = SPEC_DEF;
tileSpec = null;
compSpec = null;
break;
}
}
// Check that default value has been specified
if (getDefault() == null)
{
int ndefspec = 0;
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[t][c] == SPEC_DEF)
{
ndefspec++;
}
}
}
// If some tile-component have received no specification, it takes
// the default value defined in ParameterList
if (ndefspec != 0)
{
param = pl.DefaultParameterList.getParameter(optName);
try
{
setDefault((System.Object) System.Int32.Parse(param));
}
catch (System.FormatException)
{
throw new System.ArgumentException("Non recognized value" + " for option -" + optName + ": " + param);
}
}
else
{
// All tile-component have been specified, takes the first
// tile-component value as default.
setDefault(getTileCompVal(0, 0));
switch (specValType[0][0])
{
case SPEC_TILE_DEF:
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[0][c] == SPEC_TILE_DEF)
specValType[0][c] = SPEC_DEF;
}
tileDef[0] = null;
break;
case SPEC_COMP_DEF:
for (int t = nt - 1; t >= 0; t--)
{
if (specValType[t][0] == SPEC_COMP_DEF)
specValType[t][0] = SPEC_DEF;
}
compDef[0] = null;
break;
case SPEC_TILE_COMP:
specValType[0][0] = SPEC_DEF;
tileCompVal["t0c0"] = null;
break;
}
}
}
}
/// <summary> Constructs a new 'QuantTypeSpec' for the specified number of components
/// and tiles and the arguments of "-Qtype" option. This constructor is
/// called by the encoder.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="pl">The ParameterList
///
/// </param>
public QuantTypeSpec(int nt, int nc, byte type, ParameterList pl):base(nt, nc, type)
{
System.String param = pl.getParameter("Qtype");
if (param == null)
{
if (pl.getBooleanParameter("lossless"))
{
setDefault("reversible");
}
else
{
setDefault("expounded");
}
return ;
}
// Parse argument
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
System.String word; // current word
byte curSpecValType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
bool[] compSpec = null; // Components concerned by the specification
while (stk.HasMoreTokens())
{
word = stk.NextToken().ToLower();
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecValType == SPEC_COMP_DEF)
{
curSpecValType = SPEC_TILE_COMP;
}
else
{
curSpecValType = SPEC_TILE_DEF;
}
break;
case 'c': // Components specification
compSpec = parseIdx(word, nComp);
if (curSpecValType == SPEC_TILE_DEF)
{
curSpecValType = SPEC_TILE_COMP;
}
else
{
curSpecValType = SPEC_COMP_DEF;
}
break;
case 'r':
// reversible specification
case 'd':
// derived quantization step size specification
case 'e': // expounded quantization step size specification
if (!word.ToUpper().Equals("reversible".ToUpper()) && !word.ToUpper().Equals("derived".ToUpper()) && !word.ToUpper().Equals("expounded".ToUpper()))
{
throw new System.ArgumentException("Unknown parameter " + "for " + "'-Qtype' option: " + word);
}
if (pl.getBooleanParameter("lossless") && (word.ToUpper().Equals("derived".ToUpper()) || word.ToUpper().Equals("expounded".ToUpper())))
{
throw new System.ArgumentException("Cannot use non " + "reversible " + "quantization with " + "'-lossless' option");
}
if (curSpecValType == SPEC_DEF)
{
// Default specification
setDefault(word);
}
else if (curSpecValType == SPEC_TILE_DEF)
{
// Tile default specification
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
if (tileSpec[i])
{
setTileDef(i, word);
}
}
}
else if (curSpecValType == SPEC_COMP_DEF)
{
// Component default specification
for (int i = compSpec.Length - 1; i >= 0; i--)
if (compSpec[i])
{
setCompDef(i, word);
}
}
else
{
// Tile-component specification
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
for (int j = compSpec.Length - 1; j >= 0; j--)
{
if (tileSpec[i] && compSpec[j])
{
setTileCompVal(i, j, word);
}
}
}
}
// Re-initialize
curSpecValType = SPEC_DEF;
tileSpec = null;
compSpec = null;
break;
default:
throw new System.ArgumentException("Unknown parameter for " + "'-Qtype' option: " + word);
}
}
// Check that default value has been specified
if (getDefault() == null)
{
int ndefspec = 0;
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[t][c] == SPEC_DEF)
{
ndefspec++;
}
}
}
// If some tile-component have received no specification, the
// quantization type is 'reversible' (if '-lossless' is specified)
// or 'expounded' (if not).
if (ndefspec != 0)
{
if (pl.getBooleanParameter("lossless"))
{
setDefault("reversible");
}
else
{
setDefault("expounded");
}
}
else
{
// All tile-component have been specified, takes arbitrarily
// the first tile-component value as default and modifies the
// specification type of all tile-component sharing this
// value.
setDefault(getTileCompVal(0, 0));
switch (specValType[0][0])
{
case SPEC_TILE_DEF:
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[0][c] == SPEC_TILE_DEF)
specValType[0][c] = SPEC_DEF;
}
tileDef[0] = null;
break;
case SPEC_COMP_DEF:
for (int t = nt - 1; t >= 0; t--)
{
if (specValType[t][0] == SPEC_COMP_DEF)
specValType[t][0] = SPEC_DEF;
}
compDef[0] = null;
break;
case SPEC_TILE_COMP:
specValType[0][0] = SPEC_DEF;
tileCompVal["t0c0"] = null;
break;
}
}
}
}
public static Image FromStream(Stream stream)
{
RandomAccessIO in_stream = new ISRandomAccessIO(stream);
// Initialize default parameters
ParameterList defpl = GetDefaultParameterList(decoder_pinfo);
// Create parameter list using defaults
ParameterList pl = new ParameterList(defpl);
// **** File Format ****
// If the codestream is wrapped in the jp2 fileformat, Read the
// file format wrapper
FileFormatReader ff = new FileFormatReader(in_stream);
ff.readFileFormat();
if (ff.JP2FFUsed)
{
in_stream.seek(ff.FirstCodeStreamPos);
}
// +----------------------------+
// | Instantiate decoding chain |
// +----------------------------+
// **** Header decoder ****
// Instantiate header decoder and read main header
HeaderInfo hi = new HeaderInfo();
HeaderDecoder hd;
try
{
hd = new HeaderDecoder(in_stream, pl, hi);
}
catch (EndOfStreamException e)
{
throw new ApplicationException("Codestream too short or bad header, unable to decode.", e);
}
int nCompCod = hd.NumComps;
int nTiles = hi.sizValue.NumTiles;
DecoderSpecs decSpec = hd.DecoderSpecs;
// Get demixed bitdepths
int[] depth = new int[nCompCod];
for (int i = 0; i < nCompCod; i++)
{
depth[i] = hd.getOriginalBitDepth(i);
}
// **** Bit stream reader ****
BitstreamReaderAgent breader;
try
{
breader = BitstreamReaderAgent.
createInstance(in_stream, hd, pl, decSpec,
false, hi);
}
catch (IOException e)
{
throw new ApplicationException("Error while reading bit stream header or parsing packets.", e);
}
catch (ArgumentException e)
{
throw new ApplicationException("Cannot instantiate bit stream reader.", e);
}
// **** Entropy decoder ****
EntropyDecoder entdec;
try
{
entdec = hd.createEntropyDecoder(breader, pl);
}
catch (ArgumentException e)
{
throw new ApplicationException("Cannot instantiate entropy decoder.", e);
}
// **** ROI de-scaler ****
ROIDeScaler roids;
try
{
roids = hd.createROIDeScaler(entdec, pl, decSpec);
}
catch (ArgumentException e)
{
throw new ApplicationException("Cannot instantiate roi de-scaler.", e);
}
// **** Dequantizer ****
Dequantizer deq;
try
{
deq = hd.createDequantizer(roids, depth, decSpec);
}
catch (ArgumentException e)
{
throw new ApplicationException("Cannot instantiate dequantizer.", e);
}
// **** Inverse wavelet transform ***
InverseWT invWT;
try
{
// full page inverse wavelet transform
invWT = InverseWT.createInstance(deq, decSpec);
}
catch (ArgumentException e)
{
throw new ApplicationException("Cannot instantiate inverse wavelet transform.", e);
}
int res = breader.ImgRes;
invWT.ImgResLevel = res;
// **** Data converter **** (after inverse transform module)
ImgDataConverter converter = new ImgDataConverter(invWT, 0);
// **** Inverse component transformation ****
InvCompTransf ictransf = new InvCompTransf(converter, decSpec, depth, pl);
// **** Color space mapping ****
BlkImgDataSrc color;
if (ff.JP2FFUsed && pl.getParameter("nocolorspace").Equals("off"))
{
try
{
ColorSpace csMap = new ColorSpace(in_stream, hd, pl);
BlkImgDataSrc channels = hd.createChannelDefinitionMapper(ictransf, csMap);
BlkImgDataSrc resampled = hd.createResampler(channels, csMap);
BlkImgDataSrc palettized = hd.createPalettizedColorSpaceMapper(resampled, csMap);
color = hd.createColorSpaceMapper(palettized, csMap);
}
catch (ArgumentException e)
{
throw new ApplicationException("Could not instantiate ICC profiler.", e);
}
catch (ColorSpaceException e)
{
throw new ApplicationException("Error processing ColorSpace information.", e);
}
}
else
{ // Skip colorspace mapping
color = ictransf;
}
// This is the last image in the decoding chain and should be
// assigned by the last transformation:
BlkImgDataSrc decodedImage = color;
if (color == null)
{
decodedImage = ictransf;
}
int numComps = decodedImage.NumComps;
int bytesPerPixel = (numComps == 4 ? 4 : 3);
// **** Copy to Bitmap ****
PixelFormat pixelFormat;
switch (numComps)
{
case 1:
pixelFormat = PixelFormat.Format24bppRgb; break;
case 3:
pixelFormat = PixelFormat.Format24bppRgb; break;
case 4:
pixelFormat = PixelFormat.Format32bppArgb; break;
default:
throw new ApplicationException("Unsupported PixelFormat. " + numComps + " components.");
}
Bitmap dst = new Bitmap(decodedImage.ImgWidth, decodedImage.ImgHeight, pixelFormat);
Coord numTiles = decodedImage.getNumTiles(null);
int tIdx = 0;
for (int y = 0; y < numTiles.y; y++)
{
// Loop on horizontal tiles
for (int x = 0; x < numTiles.x; x++, tIdx++)
{
decodedImage.setTile(x, y);
int height = decodedImage.getTileCompHeight(tIdx, 0);
int width = decodedImage.getTileCompWidth(tIdx, 0);
int tOffx = decodedImage.getCompULX(0) -
(int)Math.Ceiling(decodedImage.ImgULX /
(double)decodedImage.getCompSubsX(0));
int tOffy = decodedImage.getCompULY(0) -
(int)Math.Ceiling(decodedImage.ImgULY /
(double)decodedImage.getCompSubsY(0));
DataBlkInt[] db = new DataBlkInt[numComps];
int[] ls = new int[numComps];
int[] mv = new int[numComps];
int[] fb = new int[numComps];
for (int i = 0; i < numComps; i++)
{
db[i] = new DataBlkInt();
ls[i] = 1 << (decodedImage.getNomRangeBits(0) - 1);
mv[i] = (1 << decodedImage.getNomRangeBits(0)) - 1;
fb[i] = decodedImage.getFixedPoint(0);
}
for (int l = 0; l < height; l++)
{
for (int i = numComps - 1; i >= 0; i--)
{
db[i].ulx = 0;
db[i].uly = l;
db[i].w = width;
db[i].h = 1;
decodedImage.getInternCompData(db[i], i);
}
int[] k = new int[numComps];
for (int i = numComps - 1; i >= 0; i--) k[i] = db[i].offset + width - 1;
byte[] rowvalues = new byte[width * bytesPerPixel];
for (int i = width - 1; i >= 0; i--)
{
int[] tmp = new int[numComps];
for (int j = numComps - 1; j >= 0; j--)
{
tmp[j] = (db[j].data_array[k[j]--] >> fb[j]) + ls[j];
tmp[j] = (tmp[j] < 0) ? 0 : ((tmp[j] > mv[j]) ? mv[j] : tmp[j]);
if (decodedImage.getNomRangeBits(j) != 8)
tmp[j] = (int)Math.Round(((double)tmp[j] / Math.Pow(2D, (double)decodedImage.getNomRangeBits(j))) * 255D);
}
int offset = i * bytesPerPixel;
switch (numComps)
{
case 1:
rowvalues[offset + 0] = (byte)tmp[0];
rowvalues[offset + 1] = (byte)tmp[0];
rowvalues[offset + 2] = (byte)tmp[0];
break;
case 3:
rowvalues[offset + 0] = (byte)tmp[2];
rowvalues[offset + 1] = (byte)tmp[1];
rowvalues[offset + 2] = (byte)tmp[0];
break;
case 4:
rowvalues[offset + 0] = (byte)tmp[3];
rowvalues[offset + 1] = (byte)tmp[2];
rowvalues[offset + 2] = (byte)tmp[1];
rowvalues[offset + 3] = (byte)tmp[0];
break;
}
}
BitmapData dstdata = dst.LockBits(
new System.Drawing.Rectangle(tOffx, tOffy + l, width, 1),
ImageLockMode.ReadWrite, pixelFormat);
IntPtr ptr = dstdata.Scan0;
System.Runtime.InteropServices.Marshal.Copy(rowvalues, 0, ptr, rowvalues.Length);
dst.UnlockBits(dstdata);
}
}
}
return dst;
}
/// <summary> Constructs a new 'AnWTFilterSpec' for the specified number of
/// components and tiles.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="qts">Quantization specifications
///
/// </param>
/// <param name="pl">The ParameterList
///
/// </param>
public AnWTFilterSpec(int nt, int nc, byte type, QuantTypeSpec qts, ParameterList pl):base(nt, nc, type)
{
// Check parameters
pl.checkList(AnWTFilter.OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(AnWTFilter.ParameterInfo));
System.String param = pl.getParameter("Ffilters");
bool isFilterSpecified = true;
// No parameter specified
if (param == null)
{
isFilterSpecified = false;
// If lossless compression, uses the reversible filters in each
// tile-components
if (pl.getBooleanParameter("lossless"))
{
setDefault(parseFilters(REV_FILTER_STR));
return ;
}
// If no filter is specified through the command-line, use
// REV_FILTER_STR or NON_REV_FILTER_STR according to the
// quantization type
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
switch (qts.getSpecValType(t, c))
{
case SPEC_DEF:
if (getDefault() == null)
{
if (pl.getBooleanParameter("lossless"))
setDefault(parseFilters(REV_FILTER_STR));
if (((System.String) qts.getDefault()).Equals("reversible"))
{
setDefault(parseFilters(REV_FILTER_STR));
}
else
{
setDefault(parseFilters(NON_REV_FILTER_STR));
}
}
specValType[t][c] = SPEC_DEF;
break;
case SPEC_COMP_DEF:
if (!isCompSpecified(c))
{
if (((System.String) qts.getCompDef(c)).Equals("reversible"))
{
setCompDef(c, parseFilters(REV_FILTER_STR));
}
else
{
setCompDef(c, parseFilters(NON_REV_FILTER_STR));
}
}
specValType[t][c] = SPEC_COMP_DEF;
break;
case SPEC_TILE_DEF:
if (!isTileSpecified(t))
{
if (((System.String) qts.getTileDef(t)).Equals("reversible"))
{
setTileDef(t, parseFilters(REV_FILTER_STR));
}
else
{
setTileDef(t, parseFilters(NON_REV_FILTER_STR));
}
}
specValType[t][c] = SPEC_TILE_DEF;
break;
case SPEC_TILE_COMP:
if (!isTileCompSpecified(t, c))
{
if (((System.String) qts.getTileCompVal(t, c)).Equals("reversible"))
{
setTileCompVal(t, c, parseFilters(REV_FILTER_STR));
}
else
{
setTileCompVal(t, c, parseFilters(NON_REV_FILTER_STR));
}
}
specValType[t][c] = SPEC_TILE_COMP;
break;
default:
throw new System.ArgumentException("Unsupported " + "specification " + "type");
}
}
}
return ;
}
// Parse argument
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
System.String word; // current word
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
bool[] compSpec = null; // Components concerned by the specification
AnWTFilter[][] filter;
while (stk.HasMoreTokens())
{
word = stk.NextToken();
switch (word[0])
{
case 't':
// Tiles specification
case 'T': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
curSpecType = SPEC_TILE_COMP;
else
curSpecType = SPEC_TILE_DEF;
break;
case 'c':
// Components specification
case 'C': // Components specification
compSpec = parseIdx(word, nComp);
if (curSpecType == SPEC_TILE_DEF)
curSpecType = SPEC_TILE_COMP;
else
curSpecType = SPEC_COMP_DEF;
break;
case 'w':
// WT filters specification
case 'W': // WT filters specification
if (pl.getBooleanParameter("lossless") && word.ToUpper().Equals("w9x7".ToUpper()))
{
throw new System.ArgumentException("Cannot use non " + "reversible " + "wavelet transform with" + " '-lossless' option");
}
filter = parseFilters(word);
if (curSpecType == SPEC_DEF)
{
setDefault(filter);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
if (tileSpec[i])
{
setTileDef(i, filter);
}
}
else if (curSpecType == SPEC_COMP_DEF)
{
for (int i = compSpec.Length - 1; i >= 0; i--)
if (compSpec[i])
{
setCompDef(i, filter);
}
}
else
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
for (int j = compSpec.Length - 1; j >= 0; j--)
{
if (tileSpec[i] && compSpec[j])
{
setTileCompVal(i, j, filter);
}
}
}
}
// Re-initialize
curSpecType = SPEC_DEF;
tileSpec = null;
compSpec = null;
break;
default:
throw new System.ArgumentException("Bad construction for " + "parameter: " + word);
}
}
// Check that default value has been specified
if (getDefault() == null)
{
int ndefspec = 0;
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[t][c] == SPEC_DEF)
{
ndefspec++;
}
}
}
// If some tile-component have received no specification, it takes
// the default value defined in ParameterList
if (ndefspec != 0)
{
if (((System.String) qts.getDefault()).Equals("reversible"))
setDefault(parseFilters(REV_FILTER_STR));
else
setDefault(parseFilters(NON_REV_FILTER_STR));
}
else
{
// All tile-component have been specified, takes the first
// tile-component value as default.
setDefault(getTileCompVal(0, 0));
switch (specValType[0][0])
{
case SPEC_TILE_DEF:
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[0][c] == SPEC_TILE_DEF)
specValType[0][c] = SPEC_DEF;
}
tileDef[0] = null;
break;
case SPEC_COMP_DEF:
for (int t = nt - 1; t >= 0; t--)
{
if (specValType[t][0] == SPEC_COMP_DEF)
specValType[t][0] = SPEC_DEF;
}
compDef[0] = null;
break;
case SPEC_TILE_COMP:
specValType[0][0] = SPEC_DEF;
tileCompVal["t0c0"] = null;
break;
}
}
}
// Check consistency between filter and quantization type
// specification
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
// Reversible quantization
if (((System.String) qts.getTileCompVal(t, c)).Equals("reversible"))
{
// If filter is reversible, it is OK
if (isReversible(t, c))
continue;
// If no filter has been defined, use reversible filter
if (!isFilterSpecified)
{
setTileCompVal(t, c, parseFilters(REV_FILTER_STR));
}
else
{
// Non reversible filter specified -> Error
throw new System.ArgumentException("Filter of " + "tile-component" + " (" + t + "," + c + ") does" + " not allow " + "reversible " + "quantization. " + "Specify '-Qtype " + "expounded' or " + "'-Qtype derived'" + "in " + "the command line.");
}
}
else
{
// No reversible quantization
// No reversible filter -> OK
if (!isReversible(t, c))
continue;
// If no filter has been specified, use non-reversible
// filter
if (!isFilterSpecified)
{
setTileCompVal(t, c, parseFilters(NON_REV_FILTER_STR));
}
else
{
// Reversible filter specified -> Error
throw new System.ArgumentException("Filter of " + "tile-component" + " (" + t + "," + c + ") does" + " not allow " + "non-reversible " + "quantization. " + "Specify '-Qtype " + "reversible' in " + "the command line");
}
}
}
}
}
/// <summary> Constructs a new 'ForwCompTransfSpec' for the specified number of
/// components and tiles, the wavelet filters type and the parameter of the
/// option 'Mct'. This constructor is called by the encoder. It also checks
/// that the arguments belong to the recognized arguments list.
///
/// <p>This constructor chose the component transformation type depending
/// on the wavelet filters : RCT with w5x3 filter and ICT with w9x7
/// filter. Note: All filters must use the same data type.</p>
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="wfs">The wavelet filter specifications
///
/// </param>
/// <param name="pl">The ParameterList
///
/// </param>
public ForwCompTransfSpec(int nt, int nc, byte type, AnWTFilterSpec wfs, ParameterList pl):base(nt, nc, type)
{
System.String param = pl.getParameter("Mct");
if (param == null)
{
// The option has not been specified
// If less than three component, do not use any component
// transformation
if (nc < 3)
{
setDefault("none");
return ;
}
// If the compression is lossless, uses RCT
else if (pl.getBooleanParameter("lossless"))
{
setDefault("rct");
return ;
}
else
{
AnWTFilter[][] anfilt;
int[] filtType = new int[nComp];
for (int c = 0; c < 3; c++)
{
anfilt = (AnWTFilter[][]) wfs.getCompDef(c);
filtType[c] = anfilt[0][0].FilterType;
}
// Check that the three first components use the same filters
bool reject = false;
for (int c = 1; c < 3; c++)
{
if (filtType[c] != filtType[0])
reject = true;
}
if (reject)
{
setDefault("none");
}
else
{
anfilt = (AnWTFilter[][]) wfs.getCompDef(0);
if (anfilt[0][0].FilterType == CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7)
{
setDefault("ict");
}
else
{
setDefault("rct");
}
}
}
// Each tile receives a component transform specification
// according the type of wavelet filters that are used by the
// three first components
for (int t = 0; t < nt; t++)
{
AnWTFilter[][] anfilt;
int[] filtType = new int[nComp];
for (int c = 0; c < 3; c++)
{
anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, c);
filtType[c] = anfilt[0][0].FilterType;
}
// Check that the three components use the same filters
bool reject = false;
for (int c = 1; c < nComp; c++)
{
if (filtType[c] != filtType[0])
reject = true;
}
if (reject)
{
setTileDef(t, "none");
}
else
{
anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, 0);
if (anfilt[0][0].FilterType == CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7)
{
setTileDef(t, "ict");
}
else
{
setTileDef(t, "rct");
}
}
}
return ;
}
// Parse argument
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
System.String word; // current word
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the
// specification
//System.Boolean value_Renamed;
while (stk.HasMoreTokens())
{
word = stk.NextToken();
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_TILE_DEF;
}
break;
case 'c': // Components specification
throw new System.ArgumentException("Component specific " + " parameters" + " not allowed with " + "'-Mct' option");
default:
if (word.Equals("off"))
{
if (curSpecType == SPEC_DEF)
{
setDefault("none");
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
if (tileSpec[i])
{
setTileDef(i, "none");
}
}
}
else if (word.Equals("on"))
{
if (nc < 3)
{
throw new System.ArgumentException("Cannot use component" + " transformation on a " + "image with less than " + "three components");
}
if (curSpecType == SPEC_DEF)
{
// Set arbitrarily the default
// value to RCT (later will be found the suitable
// component transform for each tile)
setDefault("rct");
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
if (tileSpec[i])
{
if (getFilterType(i, wfs) == CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3)
{
setTileDef(i, "rct");
}
else
{
setTileDef(i, "ict");
}
}
}
}
}
else
{
throw new System.ArgumentException("Default parameter of " + "option Mct not" + " recognized: " + param);
}
// Re-initialize
curSpecType = SPEC_DEF;
tileSpec = null;
break;
}
}
// Check that default value has been specified
if (getDefault() == null)
{
// If not, set arbitrarily the default value to 'none' but
// specifies explicitely a default value for each tile depending
// on the wavelet transform that is used
setDefault("none");
for (int t = 0; t < nt; t++)
{
if (isTileSpecified(t))
{
continue;
}
AnWTFilter[][] anfilt;
int[] filtType = new int[nComp];
for (int c = 0; c < 3; c++)
{
anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, c);
filtType[c] = anfilt[0][0].FilterType;
}
// Check that the three components use the same filters
bool reject = false;
for (int c = 1; c < nComp; c++)
{
if (filtType[c] != filtType[0])
reject = true;
}
if (reject)
{
setTileDef(t, "none");
}
else
{
anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, 0);
if (anfilt[0][0].FilterType == CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7)
{
setTileDef(t, "ict");
}
else
{
setTileDef(t, "rct");
}
}
}
}
// Check validity of component transformation of each tile compared to
// the filter used.
for (int t = nt - 1; t >= 0; t--)
{
if (((System.String) getTileDef(t)).Equals("none"))
{
// No comp. transf is used. No check is needed
continue;
}
else if (((System.String) getTileDef(t)).Equals("rct"))
{
// Tile is using Reversible component transform
int filterType = getFilterType(t, wfs);
switch (filterType)
{
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3: // OK
break;
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7: // Must use ICT
if (isTileSpecified(t))
{
// User has requested RCT -> Error
throw new System.ArgumentException("Cannot use RCT " + "with 9x7 filter " + "in tile " + t);
}
else
{
// Specify ICT for this tile
setTileDef(t, "ict");
}
break;
default:
throw new System.ArgumentException("Default filter is " + "not JPEG 2000 part" + " I compliant");
}
}
else
{
// ICT
int filterType = getFilterType(t, wfs);
switch (filterType)
{
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3: // Must use RCT
if (isTileSpecified(t))
{
// User has requested ICT -> Error
throw new System.ArgumentException("Cannot use ICT " + "with filter 5x3 " + "in tile " + t);
}
else
{
setTileDef(t, "rct");
}
break;
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7: // OK
break;
default:
throw new System.ArgumentException("Default filter is " + "not JPEG 2000 part" + " I compliant");
}
}
}
}
/// <summary> Creates a new CBlkSizeSpec object for the specified number of tiles and
/// components and the ParameterList instance.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="imgsrc">The image source (used to get the image size)
///
/// </param>
/// <param name="pl">The ParameterList instance
///
/// </param>
public CBlkSizeSpec(int nt, int nc, byte type, ParameterList pl):base(nt, nc, type)
{
bool firstVal = true;
System.String param = pl.getParameter(optName);
// Precinct partition is used : parse arguments
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
bool[] compSpec = null; // Components concerned by the specification
int ci, ti; // i, xIdx removed
System.String word = null; // current word
System.String errMsg = null;
while (stk.HasMoreTokens())
{
word = stk.NextToken();
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_TILE_DEF;
}
break;
case 'c': // Components specification
compSpec = parseIdx(word, nComp);
if (curSpecType == SPEC_TILE_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_COMP_DEF;
}
break;
default:
if (!System.Char.IsDigit(word[0]))
{
errMsg = "Bad construction for parameter: " + word;
throw new System.ArgumentException(errMsg);
}
System.Int32[] dim = new System.Int32[2];
// Get code-block's width
try
{
dim[0] = System.Int32.Parse(word);
// Check that width is not >
// StdEntropyCoderOptions.MAX_CB_DIM
if (dim[0] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM)
{
errMsg = "'" + optName + "' option : the code-block's " + "width cannot be greater than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM;
throw new System.ArgumentException(errMsg);
}
// Check that width is not <
// StdEntropyCoderOptions.MIN_CB_DIM
if (dim[0] < CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM)
{
errMsg = "'" + optName + "' option : the code-block's " + "width cannot be less than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM;
throw new System.ArgumentException(errMsg);
}
// Check that width is a power of 2
if (dim[0] != (1 << MathUtil.log2(dim[0])))
{
errMsg = "'" + optName + "' option : the code-block's " + "width must be a power of 2";
throw new System.ArgumentException(errMsg);
}
}
catch (System.FormatException)
{
errMsg = "'" + optName + "' option : the code-block's " + "width could not be parsed.";
throw new System.ArgumentException(errMsg);
}
// Get the next word in option
try
{
word = stk.NextToken();
}
catch (System.ArgumentOutOfRangeException)
{
errMsg = "'" + optName + "' option : could not parse the " + "code-block's height";
throw new System.ArgumentException(errMsg);
}
// Get the code-block's height
try
{
dim[1] = System.Int32.Parse(word);
// Check that height is not >
// StdEntropyCoderOptions.MAX_CB_DIM
if (dim[1] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM)
{
errMsg = "'" + optName + "' option : the code-block's " + "height cannot be greater than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM;
throw new System.ArgumentException(errMsg);
}
// Check that height is not <
// StdEntropyCoderOptions.MIN_CB_DIM
if (dim[1] < CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM)
{
errMsg = "'" + optName + "' option : the code-block's " + "height cannot be less than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM;
throw new System.ArgumentException(errMsg);
}
// Check that height is a power of 2
if (dim[1] != (1 << MathUtil.log2(dim[1])))
{
errMsg = "'" + optName + "' option : the code-block's " + "height must be a power of 2";
throw new System.ArgumentException(errMsg);
}
// Check that the code-block 'area' (i.e. width*height) is
// not greater than StdEntropyCoderOptions.MAX_CB_AREA
if (dim[0] * dim[1] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_AREA)
{
errMsg = "'" + optName + "' option : The " + "code-block's area (i.e. width*height) " + "cannot be greater than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_AREA;
throw new System.ArgumentException(errMsg);
}
}
catch (System.FormatException)
{
errMsg = "'" + optName + "' option : the code-block's height " + "could not be parsed.";
throw new System.ArgumentException(errMsg);
}
// Store the maximum dimensions if necessary
if (dim[0] > maxCBlkWidth)
{
maxCBlkWidth = dim[0];
}
if (dim[1] > maxCBlkHeight)
{
maxCBlkHeight = dim[1];
}
if (firstVal)
{
// This is the first time a value is given so we set it as
// the default one
setDefault((System.Object) (dim));
firstVal = false;
}
switch (curSpecType)
{
case SPEC_DEF:
setDefault((System.Object) (dim));
break;
case SPEC_TILE_DEF:
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
if (tileSpec[ti])
{
setTileDef(ti, (System.Object) (dim));
}
}
break;
case SPEC_COMP_DEF:
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (compSpec[ci])
{
setCompDef(ci, (System.Object) (dim));
}
}
break;
default:
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (tileSpec[ti] && compSpec[ci])
{
setTileCompVal(ti, ci, (System.Object) (dim));
}
}
}
break;
}
break;
} // end switch
}
}
/// <summary> Creates a ForwardWT object with the specified filters, and with other
/// options specified in the parameter list 'pl'.
///
/// </summary>
/// <param name="src">The source of data to be transformed
///
/// </param>
/// <param name="pl">The parameter list (or options).
///
/// </param>
/// <param name="kers">The encoder specifications.
///
/// </param>
/// <returns> A new ForwardWT object with the specified filters and options
/// from 'pl'.
///
/// </returns>
/// <exception cref="IllegalArgumentException">If mandatory parameters are missing
/// or if invalid values are given.
///
/// </exception>
public static ForwardWT createInstance(BlkImgDataSrc src, ParameterList pl, EncoderSpecs encSpec)
{
int deflev; // defdec removed
//System.String decompstr;
//System.String wtstr;
//System.String pstr;
//SupportClass.StreamTokenizerSupport stok;
//SupportClass.Tokenizer strtok;
//int prefx, prefy; // Partitioning reference point coordinates
// Check parameters
pl.checkList(OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(pinfo));
deflev = ((System.Int32) encSpec.dls.getDefault());
// Code-block partition origin
System.String str = "";
if (pl.getParameter("Wcboff") == null)
{
throw new System.ApplicationException("You must specify an argument to the '-Wcboff' " + "option. See usage with the '-u' option");
}
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(pl.getParameter("Wcboff"));
if (stk.Count != 2)
{
throw new System.ArgumentException("'-Wcboff' option needs two" + " arguments. See usage with " + "the '-u' option.");
}
int cb0x = 0;
str = stk.NextToken();
try
{
cb0x = (System.Int32.Parse(str));
}
catch (System.FormatException)
{
throw new System.ArgumentException("Bad first parameter for the " + "'-Wcboff' option: " + str);
}
if (cb0x < 0 || cb0x > 1)
{
throw new System.ArgumentException("Invalid horizontal " + "code-block partition origin.");
}
int cb0y = 0;
str = stk.NextToken();
try
{
cb0y = (System.Int32.Parse(str));
}
catch (System.FormatException)
{
throw new System.ArgumentException("Bad second parameter for the " + "'-Wcboff' option: " + str);
}
if (cb0y < 0 || cb0y > 1)
{
throw new System.ArgumentException("Invalid vertical " + "code-block partition origin.");
}
if (cb0x != 0 || cb0y != 0)
{
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Code-blocks partition origin is " + "different from (0,0). This is defined in JPEG 2000" + " part 2 and may be not supported by all JPEG 2000 " + "decoders.");
}
return new ForwWTFull(src, encSpec, cb0x, cb0y);
}
/// <summary> Creates a new ProgressionSpec object for the specified number of tiles,
/// components and the ParameterList instance.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="nl">The number of layer
///
/// </param>
/// <param name="dls">The number of decomposition levels specifications
///
/// </param>
/// <param name="type">the type of the specification module. The ProgressionSpec
/// class should only be used only with the type ModuleSpec.SPEC_TYPE_TILE.
///
/// </param>
/// <param name="pl">The ParameterList instance
///
/// </param>
public ProgressionSpec(int nt, int nc, int nl, IntegerSpec dls, byte type, ParameterList pl)
: base(nt, nc, type)
{
System.String param = pl.getParameter("Aptype");
Progression[] prog;
int mode = - 1;
if (param == null)
{
// No parameter specified
if (pl.getParameter("Rroi") == null)
{
mode = checkProgMode("res");
}
else
{
mode = checkProgMode("layer");
}
if (mode == - 1)
{
System.String errMsg = "Unknown progression type : '" + param + "'";
throw new System.ArgumentException(errMsg);
}
prog = new Progression[1];
prog[0] = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
setDefault(prog);
return ;
}
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
System.String word = null; // current word
System.String errMsg2 = null; // Error message
bool needInteger = false; // True if an integer value is expected
int intType = 0; // Type of read integer value (0=index of first
// resolution level, 1= index of first component, 2=index of first
// layer not included, 3= index of first resolution level not
// included, 4= index of first component not included
System.Collections.Generic.List<Progression> progression = new List<Progression>(10);
int tmp = 0;
Progression curProg = null;
while (stk.HasMoreTokens())
{
word = stk.NextToken();
switch (word[0])
{
case 't':
// If progression were previously found, store them
if (progression.Count > 0)
{
// Ensure that all information has been taken
curProg.ce = nc;
curProg.lye = nl;
curProg.re = dls.Max + 1;
prog = new Progression[progression.Count];
progression.CopyTo(prog);
if (curSpecType == SPEC_DEF)
{
setDefault(prog);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
if (tileSpec[i])
{
setTileDef(i, prog);
}
}
}
progression.Clear();
intType = - 1;
needInteger = false;
// Tiles specification
tileSpec = parseIdx(word, nTiles);
curSpecType = SPEC_TILE_DEF;
break;
default:
// Here, words is either a Integer (progression bound index)
// or a String (progression order type). This is determined by
// the value of needInteger.
if (needInteger)
{
// Progression bound info
try
{
tmp = (System.Int32.Parse(word));
}
catch (System.FormatException e)
{
// Progression has missing parameters
throw new System.ArgumentException("Progression " + "order" + " specification " + "has missing " + "parameters: " + param);
}
switch (intType)
{
case 0: // cs
if (tmp < 0 || tmp > (dls.Max + 1))
throw new System.ArgumentException("Invalid res_start " + "in '-Aptype'" + " option: " + tmp);
curProg.rs = tmp; break;
case 1: // rs
if (tmp < 0 || tmp > nc)
{
throw new System.ArgumentException("Invalid comp_start " + "in '-Aptype' " + "option: " + tmp);
}
curProg.cs = tmp; break;
case 2: // lye
if (tmp < 0)
throw new System.ArgumentException("Invalid layer_end " + "in '-Aptype'" + " option: " + tmp);
if (tmp > nl)
{
tmp = nl;
}
curProg.lye = tmp; break;
case 3: // ce
if (tmp < 0)
throw new System.ArgumentException("Invalid res_end " + "in '-Aptype'" + " option: " + tmp);
if (tmp > (dls.Max + 1))
{
tmp = dls.Max + 1;
}
curProg.re = tmp; break;
case 4: // re
if (tmp < 0)
throw new System.ArgumentException("Invalid comp_end " + "in '-Aptype'" + " option: " + tmp);
if (tmp > nc)
{
tmp = nc;
}
curProg.ce = tmp; break;
}
if (intType < 4)
{
intType++;
needInteger = true;
break;
}
else if (intType == 4)
{
intType = 0;
needInteger = false;
break;
}
else
{
throw new System.InvalidOperationException("Error in usage of 'Aptype' " + "option: " + param);
}
}
if (!needInteger)
{
// Progression type info
mode = checkProgMode(word);
if (mode == - 1)
{
errMsg2 = "Unknown progression type : '" + word + "'";
throw new System.ArgumentException(errMsg2);
}
needInteger = true;
intType = 0;
if (progression.Count == 0)
{
curProg = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
}
else
{
curProg = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
}
progression.Add(curProg);
}
break;
} // switch
} // while
if (progression.Count == 0)
{
// No progression defined
if (pl.getParameter("Rroi") == null)
{
mode = checkProgMode("res");
}
else
{
mode = checkProgMode("layer");
}
if (mode == - 1)
{
errMsg2 = "Unknown progression type : '" + param + "'";
throw new System.ArgumentException(errMsg2);
}
prog = new Progression[1];
prog[0] = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
setDefault(prog);
return ;
}
// Ensure that all information has been taken
curProg.ce = nc;
curProg.lye = nl;
curProg.re = dls.Max + 1;
// Store found progression
prog = new Progression[progression.Count];
progression.CopyTo(prog);
if (curSpecType == SPEC_DEF)
{
setDefault(prog);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
if (tileSpec[i])
{
setTileDef(i, prog);
}
}
// Check that default value has been specified
if (getDefault() == null)
{
int ndefspec = 0;
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[t][c] == SPEC_DEF)
{
ndefspec++;
}
}
}
// If some tile-component have received no specification, they
// receive the default progressiveness.
if (ndefspec != 0)
{
if (pl.getParameter("Rroi") == null)
{
mode = checkProgMode("res");
}
else
{
mode = checkProgMode("layer");
}
if (mode == - 1)
{
errMsg2 = "Unknown progression type : '" + param + "'";
throw new System.ArgumentException(errMsg2);
}
prog = new Progression[1];
prog[0] = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
setDefault(prog);
}
else
{
// All tile-component have been specified, takes the first
// tile-component value as default.
setDefault(getTileCompVal(0, 0));
switch (specValType[0][0])
{
case SPEC_TILE_DEF:
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[0][c] == SPEC_TILE_DEF)
specValType[0][c] = SPEC_DEF;
}
tileDef[0] = null;
break;
case SPEC_COMP_DEF:
for (int t = nt - 1; t >= 0; t--)
{
if (specValType[t][0] == SPEC_COMP_DEF)
specValType[t][0] = SPEC_DEF;
}
compDef[0] = null;
break;
case SPEC_TILE_COMP:
specValType[0][0] = SPEC_DEF;
tileCompVal["t0c0"] = null;
break;
}
}
}
}
/// <summary> Creates a ROIScaler object. The Quantizer is the source of data to
/// scale.
///
/// <p>The ROI Scaler creates a ROIMaskGenerator depending on what ROI
/// information is in the ParameterList. If only rectangular ROI are used,
/// the fast mask generator for rectangular ROI can be used.</p>
///
/// </summary>
/// <param name="src">The source of data to scale
///
/// </param>
/// <param name="pl">The parameter list (or options).
///
/// </param>
/// <param name="encSpec">The encoder specifications for addition of roi specs
///
/// </param>
/// <exception cref="IllegalArgumentException">If an error occurs while parsing
/// the options in 'pl'
///
/// </exception>
public static ROIScaler createInstance(Quantizer src, ParameterList pl, EncoderSpecs encSpec)
{
System.Collections.ArrayList roiVector = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
ROIMaskGenerator maskGen = null;
// Check parameters
pl.checkList(OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(pinfo));
// Get parameters and check if there are and ROIs specified
System.String roiopt = pl.getParameter("Rroi");
if (roiopt == null)
{
// No ROIs specified! Create ROIScaler with no mask generator
return new ROIScaler(src, null, false, - 1, false, encSpec);
}
// Check if the lowest resolution levels should belong to the ROI
int sLev = pl.getIntParameter("Rstart_level");
// Check if the ROIs are block-aligned
bool useBlockAligned = pl.getBooleanParameter("Ralign");
// Check if generic mask generation is specified
bool onlyRect = !pl.getBooleanParameter("Rno_rect");
// Parse the ROIs
parseROIs(roiopt, src.NumComps, roiVector);
ROI[] roiArray = new ROI[roiVector.Count];
roiVector.CopyTo(roiArray);
// If onlyRect has been forced, check if there are any non-rectangular
// ROIs specified. Currently, only the presence of circular ROIs will
// make this false
if (onlyRect)
{
for (int i = roiArray.Length - 1; i >= 0; i--)
if (!roiArray[i].rect)
{
onlyRect = false;
break;
}
}
if (onlyRect)
{
// It's possible to use the fast ROI mask generation when only
// rectangular ROIs are specified.
maskGen = new RectROIMaskGenerator(roiArray, src.NumComps);
}
else
{
// It's necessary to use the generic mask generation
maskGen = new ArbROIMaskGenerator(roiArray, src.NumComps, src);
}
return new ROIScaler(src, maskGen, true, sLev, useBlockAligned, encSpec);
}
/// <summary> Constructs a new 'QuantStepSizeSpec' for the specified number of
/// components and tiles and the arguments of "-Qstep" option.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="pl">The ParameterList
///
/// </param>
public QuantStepSizeSpec(int nt, int nc, byte type, ParameterList pl)
: base(nt, nc, type)
{
System.String param = pl.getParameter("Qstep");
if (param == null)
{
throw new System.ArgumentException("Qstep option not specified");
}
// Parse argument
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
System.String word; // current word
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
bool[] compSpec = null; // Components concerned by the specification
System.Single value_Renamed; // value of the current step size
while (stk.HasMoreTokens())
{
word = stk.NextToken().ToLower();
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
curSpecType = SPEC_TILE_COMP;
else
curSpecType = SPEC_TILE_DEF;
break;
case 'c': // Components specification
compSpec = parseIdx(word, nComp);
if (curSpecType == SPEC_TILE_DEF)
curSpecType = SPEC_TILE_COMP;
else
curSpecType = SPEC_COMP_DEF;
break;
default: // Step size value
try
{
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
value_Renamed = System.Single.Parse(word);
}
catch (System.FormatException e)
{
throw new System.ArgumentException("Bad parameter for " + "-Qstep option : " + word);
}
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Float.floatValue' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
if ((float) value_Renamed <= 0.0f)
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Float.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
throw new System.ArgumentException("Normalized base step " + "must be positive : " + value_Renamed);
}
if (curSpecType == SPEC_DEF)
{
setDefault((System.Object) value_Renamed);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
if (tileSpec[i])
{
setTileDef(i, (System.Object) value_Renamed);
}
}
else if (curSpecType == SPEC_COMP_DEF)
{
for (int i = compSpec.Length - 1; i >= 0; i--)
if (compSpec[i])
{
setCompDef(i, (System.Object) value_Renamed);
}
}
else
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
for (int j = compSpec.Length - 1; j >= 0; j--)
{
if (tileSpec[i] && compSpec[j])
{
setTileCompVal(i, j, (System.Object) value_Renamed);
}
}
}
}
// Re-initialize
curSpecType = SPEC_DEF;
tileSpec = null;
compSpec = null;
break;
}
}
// Check that default value has been specified
if (getDefault() == null)
{
int ndefspec = 0;
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[t][c] == SPEC_DEF)
{
ndefspec++;
}
}
}
// If some tile-component have received no specification, it takes
// the default value defined in ParameterList
if (ndefspec != 0)
{
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
setDefault((System.Object) System.Single.Parse(pl.DefaultParameterList.getParameter("Qstep")));
}
else
{
// All tile-component have been specified, takes the first
// tile-component value as default.
setDefault(getTileCompVal(0, 0));
switch (specValType[0][0])
{
case SPEC_TILE_DEF:
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[0][c] == SPEC_TILE_DEF)
specValType[0][c] = SPEC_DEF;
}
tileDef[0] = null;
break;
case SPEC_COMP_DEF:
for (int t = nt - 1; t >= 0; t--)
{
if (specValType[t][0] == SPEC_COMP_DEF)
specValType[t][0] = SPEC_DEF;
}
compDef[0] = null;
break;
case SPEC_TILE_COMP:
specValType[0][0] = SPEC_DEF;
tileCompVal["t0c0"] = null;
break;
}
}
}
}
/// <summary> Creates a PostCompRateAllocator object for the appropriate rate
/// allocation parameters in the parameter list 'pl', having 'src' as the
/// source of entropy coded data, 'rate' as the target bitrate and 'bw' as
/// the bit stream writer object.
///
/// </summary>
/// <param name="src">The source of entropy coded data.
///
/// </param>
/// <param name="pl">The parameter lis (or options).
///
/// </param>
/// <param name="rate">The target bitrate for the rate allocation
///
/// </param>
/// <param name="bw">The bit stream writer object, where the bit stream data will
/// be written.
///
/// </param>
public static PostCompRateAllocator createInstance(CodedCBlkDataSrcEnc src, ParameterList pl, float rate, CodestreamWriter bw, EncoderSpecs encSpec)
{
// Check parameters
pl.checkList(OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(pinfo));
// Construct the layer specification from the 'Alayers' option
LayersInfo lyrs = parseAlayers(pl.getParameter("Alayers"), rate);
int nTiles = encSpec.nTiles;
int nComp = encSpec.nComp;
int numLayers = lyrs.TotNumLayers;
// Parse the progressive type
encSpec.pocs = new ProgressionSpec(nTiles, nComp, numLayers, encSpec.dls, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
return new EBCOTRateAllocator(src, lyrs, bw, encSpec, pl);
}
/// <summary> Creates a new PrecinctSizeSpec object for the specified number of tiles
/// and components and the ParameterList instance.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="imgsrc">The image source (used to get the image size)
///
/// </param>
/// <param name="pl">The ParameterList instance
///
/// </param>
public PrecinctSizeSpec(int nt, int nc, byte type, BlkImgDataSrc imgsrc, IntegerSpec dls, ParameterList pl):base(nt, nc, type)
{
this.dls = dls;
// The precinct sizes are stored in a 2 elements vector array, the
// first element containing a vector for the precincts width for each
// resolution level and the second element containing a vector for the
// precincts height for each resolution level. The precincts sizes are
// specified from the highest resolution level to the lowest one
// (i.e. 0). If there are less elements than the number of
// decomposition levels, the last element is used for all remaining
// resolution levels (i.e. if the precincts sizes are specified only
// for resolutions levels 5, 4 and 3, then the precincts size for
// resolution levels 2, 1 and 0 will be the same as the size used for
// resolution level 3).
// Boolean used to know if we were previously reading a precinct's
// size or if we were reading something else.
bool wasReadingPrecinctSize = false;
System.String param = pl.getParameter(optName);
// Set precinct sizes to default i.e. 2^15 =
// Markers.PRECINCT_PARTITION_DEF_SIZE
System.Collections.ArrayList[] tmpv = new System.Collections.ArrayList[2];
tmpv[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppx
tmpv[0].Add((System.Int32) CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE);
tmpv[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppy
tmpv[1].Add((System.Int32) CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE);
setDefault(tmpv);
if (param == null)
{
// No precinct size specified in the command line so we do not try
// to parse it.
return ;
}
// Precinct partition is used : parse arguments
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
bool[] compSpec = null; // Components concerned by the specification
int ci, ti; //i, xIdx removed
bool endOfParamList = false;
System.String word = null; // current word
System.Int32 w, h;
System.String errMsg = null;
while ((stk.HasMoreTokens() || wasReadingPrecinctSize) && !endOfParamList)
{
System.Collections.ArrayList[] v = new System.Collections.ArrayList[2]; // v[0] : ppx, v[1] : ppy
// We do not read the next token if we were reading a precinct's
// size argument as we have already read the next token into word.
if (!wasReadingPrecinctSize)
{
word = stk.NextToken();
}
wasReadingPrecinctSize = false;
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_TILE_DEF;
}
break;
case 'c': // Components specification
compSpec = parseIdx(word, nComp);
if (curSpecType == SPEC_TILE_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_COMP_DEF;
}
break;
default:
if (!System.Char.IsDigit(word[0]))
{
errMsg = "Bad construction for parameter: " + word;
throw new System.ArgumentException(errMsg);
}
// Initialises Vector objects
v[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppx
v[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppy
while (true)
{
// Now get the precinct dimensions
try
{
// Get precinct width
w = System.Int32.Parse(word);
// Get next word in argument list
try
{
word = stk.NextToken();
}
catch (System.ArgumentOutOfRangeException)
{
errMsg = "'" + optName + "' option : could not " + "parse the precinct's width";
throw new System.ArgumentException(errMsg);
}
// Get precinct height
h = System.Int32.Parse(word);
if (w != (1 << MathUtil.log2(w)) || h != (1 << MathUtil.log2(h)))
{
errMsg = "Precinct dimensions must be powers of 2";
throw new System.ArgumentException(errMsg);
}
}
catch (System.FormatException)
{
errMsg = "'" + optName + "' option : the argument '" + word + "' could not be parsed.";
throw new System.ArgumentException(errMsg);
}
// Store packet's dimensions in Vector arrays
v[0].Add(w);
v[1].Add(h);
// Try to get the next token
if (stk.HasMoreTokens())
{
word = stk.NextToken();
if (!System.Char.IsDigit(word[0]))
{
// The next token does not start with a digit so
// it is not a precinct's size argument. We set
// the wasReadingPrecinctSize booleen such that we
// know that we don't have to read another token
// and check for the end of the parameters list.
wasReadingPrecinctSize = true;
if (curSpecType == SPEC_DEF)
{
setDefault(v);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
if (tileSpec[ti])
{
setTileDef(ti, v);
}
}
}
else if (curSpecType == SPEC_COMP_DEF)
{
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (compSpec[ci])
{
setCompDef(ci, v);
}
}
}
else
{
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (tileSpec[ti] && compSpec[ci])
{
setTileCompVal(ti, ci, v);
}
}
}
}
// Re-initialize
curSpecType = SPEC_DEF;
tileSpec = null;
compSpec = null;
// Go back to 'normal' parsing
break;
}
else
{
// Next token starts with a digit so read it
}
}
else
{
// We have reached the end of the parameters list so
// we store the last precinct's sizes and we stop
if (curSpecType == SPEC_DEF)
{
setDefault(v);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
if (tileSpec[ti])
{
setTileDef(ti, v);
}
}
}
else if (curSpecType == SPEC_COMP_DEF)
{
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (compSpec[ci])
{
setCompDef(ci, v);
}
}
}
else
{
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (tileSpec[ti] && compSpec[ci])
{
setTileCompVal(ti, ci, v);
}
}
}
}
endOfParamList = true;
break;
}
} // while (true)
break;
} // switch
} // while
}
/// <summary> Initializes the header writer with the references to the coding chain.
///
/// </summary>
/// <param name="origsrc">The original image data (before any component mixing,
/// tiling, etc.)
///
/// </param>
/// <param name="isorigsig">An array specifying for each component if it was
/// originally signed or not.
///
/// </param>
/// <param name="dwt">The discrete wavelet transform module.
///
/// </param>
/// <param name="tiler">The tiler module.
///
/// </param>
/// <param name="encSpec">The encoder specifications
///
/// </param>
/// <param name="roiSc">The ROI scaler module.
///
/// </param>
/// <param name="ralloc">The post compression rate allocator.
///
/// </param>
/// <param name="pl">ParameterList instance.
///
/// </param>
public HeaderEncoder(ImgData origsrc, bool[] isorigsig, ForwardWT dwt, Tiler tiler, EncoderSpecs encSpec, ROIScaler roiSc, PostCompRateAllocator ralloc, ParameterList pl)
{
pl.checkList(OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(pinfo));
if (origsrc.NumComps != isorigsig.Length)
{
throw new System.ArgumentException();
}
this.origSrc = origsrc;
this.isOrigSig = isorigsig;
this.dwt = dwt;
this.tiler = tiler;
this.encSpec = encSpec;
this.roiSc = roiSc;
this.ralloc = ralloc;
baos = new System.IO.MemoryStream();
//UPGRADE_TODO: Class 'java.io.DataOutputStream' was converted to 'System.IO.BinaryWriter' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javaioDataOutputStream'"
hbuf = new CSJ2K.Util.EndianBinaryWriter(baos, true);
nComp = origsrc.NumComps;
enJJ2KMarkSeg = pl.getBooleanParameter("Hjj2000_COM");
otherCOMMarkSeg = pl.getParameter("HCOM");
}
/// <summary> Reads all tiles headers and keep offset of their first
/// packet. Finally it calls the rate allocation method.
///
/// </summary>
/// <param name="hd">HeaderDecoder of the codestream.
///
/// </param>
/// <param name="ehs">The input stream where to read bit-stream.
///
/// </param>
/// <param name="decSpec">The decoder specifications
///
/// </param>
/// <param name="pl">The ParameterList instance created from the
/// command-line arguments.
///
/// </param>
/// <param name="cdstrInfo">Whether or not to print information found in
/// codestream.
///
/// </param>
/// <seealso cref="allocateRate">
///
/// </seealso>
public FileBitstreamReaderAgent(HeaderDecoder hd, RandomAccessIO ehs, DecoderSpecs decSpec, ParameterList pl, bool cdstrInfo, HeaderInfo hi):base(hd, decSpec)
{
this.pl = pl;
this.printInfo = cdstrInfo;
this.hi = hi;
// Check whether quit conditiosn used
usePOCQuit = pl.getBooleanParameter("poc_quit");
// Get decoding rate
bool rateInBytes;
bool parsing = pl.getBooleanParameter("parsing");
try
{
trate = pl.getFloatParameter("rate");
if (trate == - 1)
{
trate = System.Single.MaxValue;
}
}
catch (System.FormatException)
{
throw new System.ApplicationException("Invalid value in 'rate' option: " + pl.getParameter("rate"));
}
catch (System.ArgumentException)
{
throw new System.ApplicationException("'rate' option is missing");
}
try
{
tnbytes = pl.getIntParameter("nbytes");
}
catch (System.FormatException)
{
throw new System.ApplicationException("Invalid value in 'nbytes' option: " + pl.getParameter("nbytes"));
}
catch (System.ArgumentException)
{
throw new System.ApplicationException("'nbytes' option is missing");
}
// Check that '-rate' and '-nbytes' are not used at the same time
ParameterList defaults = pl.DefaultParameterList;
if (tnbytes != defaults.getFloatParameter("nbytes"))
{
rateInBytes = true;
}
else
{
rateInBytes = false;
}
if (rateInBytes)
{
trate = tnbytes * 8f / hd.MaxCompImgWidth / hd.MaxCompImgHeight;
}
else
{
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
tnbytes = (int) (trate * hd.MaxCompImgWidth * hd.MaxCompImgHeight) / 8;
if (tnbytes < 0) tnbytes = int.MaxValue;
}
isTruncMode = !pl.getBooleanParameter("parsing");
// Check if quit conditions are being used
int ncbQuit;
try
{
ncbQuit = pl.getIntParameter("ncb_quit");
}
catch (System.FormatException)
{
throw new System.ApplicationException("Invalid value in 'ncb_quit' option: " + pl.getParameter("ncb_quit"));
}
catch (System.ArgumentException)
{
throw new System.ApplicationException("'ncb_quit' option is missing");
}
if (ncbQuit != - 1 && !isTruncMode)
{
throw new System.ApplicationException("Cannot use -parsing and -ncb_quit condition at " + "the same time.");
}
try
{
lQuit = pl.getIntParameter("l_quit");
}
catch (System.FormatException)
{
throw new System.ApplicationException("Invalid value in 'l_quit' option: " + pl.getParameter("l_quit"));
}
catch (System.ArgumentException)
{
throw new System.ApplicationException("'l_quit' option is missing");
}
// initializations
in_Renamed = ehs;
pktDec = new PktDecoder(decSpec, hd, ehs, this, isTruncMode, ncbQuit);
tileParts = new int[nt];
totTileLen = new int[nt];
tilePartLen = new int[nt][];
tilePartNum = new int[nt][];
firstPackOff = new int[nt][];
tilePartsRead = new int[nt];
totTileHeadLen = new int[nt];
tilePartHeadLen = new int[nt][];
nBytes = new int[nt];
baknBytes = new int[nt];
hd.nTileParts = new int[nt];
// CONVERSION PROBLEM?
//this.isTruncMode = isTruncMode;
int t = 0, pos, tp = 0, tptot = 0;
// Keeps main header's length, takes file format overhead into account
int cdstreamStart = hd.mainHeadOff; // Codestream offset in the file
mainHeadLen = in_Renamed.Pos - cdstreamStart;
headLen = mainHeadLen;
// If ncb and lbody quit conditions are used, headers are not counted
if (ncbQuit == - 1)
{
anbytes = mainHeadLen;
}
else
{
anbytes = 0;
}
// If cannot even read the first tile-part
if (anbytes > tnbytes)
{
throw new System.ApplicationException("Requested bitrate is too small.");
}
// Read all tile-part headers from all tiles.
int tilePartStart;
bool rateReached = false;
int mdl;
//int numtp = 0;
totAllTileLen = 0;
remainingTileParts = nt; // at least as many tile-parts as tiles
int maxTP = nt; // If maximum 1 tile part per tile specified
try
{
while (remainingTileParts != 0)
{
tilePartStart = in_Renamed.Pos;
// Read tile-part header
try
{
t = readTilePartHeader();
if (isEOCFound)
{
// Some tiles are missing but the
// codestream is OK
break;
}
tp = tilePartsRead[t];
if (isPsotEqualsZero)
{
// Psot may equals zero for the
// last tile-part: it is assumed that this tile-part
// contain all data until EOC
tilePartLen[t][tp] = in_Renamed.length() - 2 - tilePartStart;
}
}
catch (System.IO.EndOfStreamException e)
{
firstPackOff[t][tp] = in_Renamed.length();
throw e;
}
pos = in_Renamed.Pos;
// In truncation mode, if target decoding rate is reached in
// tile-part header, skips the tile-part and stop reading
// unless the ncb and lbody quit condition is in use
if (isTruncMode && ncbQuit == - 1)
{
if ((pos - cdstreamStart) > tnbytes)
{
firstPackOff[t][tp] = in_Renamed.length();
rateReached = true;
break;
}
}
// Set tile part position and header length
firstPackOff[t][tp] = pos;
tilePartHeadLen[t][tp] = (pos - tilePartStart);
// Update length counters
totTileLen[t] += tilePartLen[t][tp];
totTileHeadLen[t] += tilePartHeadLen[t][tp];
totAllTileLen += tilePartLen[t][tp];
if (isTruncMode)
{
if (anbytes + tilePartLen[t][tp] > tnbytes)
{
anbytes += tilePartHeadLen[t][tp];
headLen += tilePartHeadLen[t][tp];
rateReached = true;
nBytes[t] += (tnbytes - anbytes);
break;
}
else
{
anbytes += tilePartHeadLen[t][tp];
headLen += tilePartHeadLen[t][tp];
nBytes[t] += (tilePartLen[t][tp] - tilePartHeadLen[t][tp]);
}
}
else
{
if (anbytes + tilePartHeadLen[t][tp] > tnbytes)
{
break;
}
else
{
anbytes += tilePartHeadLen[t][tp];
headLen += tilePartHeadLen[t][tp];
}
}
// If this is first tile-part, remember header length
if (tptot == 0)
firstTilePartHeadLen = tilePartHeadLen[t][tp];
// Go to the beginning of next tile part
tilePartsRead[t]++;
in_Renamed.seek(tilePartStart + tilePartLen[t][tp]);
remainingTileParts--;
maxTP--;
tptot++;
// If Psot of the current tile-part was equal to zero, it is
// assumed that it contains all data until the EOC marker
if (isPsotEqualsZero)
{
if (remainingTileParts != 0)
{
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Some tile-parts have not " + "been found. The codestream may be corrupted.");
}
break;
}
}
}
catch (System.IO.EndOfStreamException)
{
if (printInfo)
{
}
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Codestream truncated in tile " + t);
// Set specified rate to end of file if valid
int fileLen = in_Renamed.length();
if (fileLen < tnbytes)
{
tnbytes = fileLen;
trate = tnbytes * 8f / hd.MaxCompImgWidth / hd.MaxCompImgHeight;
}
// Bit-rate allocation
if (!isTruncMode)
{
allocateRate();
}
// Update 'res' value once all tile-part headers are read
if (pl.getParameter("res") == null)
{
targetRes = decSpec.dls.Min;
}
else
{
try
{
targetRes = pl.getIntParameter("res");
if (targetRes < 0)
{
throw new System.ArgumentException("Specified negative " + "resolution level " + "index: " + targetRes);
}
}
catch (System.FormatException)
{
throw new System.ArgumentException("Invalid resolution level " + "index ('-res' option) " + pl.getParameter("res"));
}
}
// Verify reduction in resolution level
mdl = decSpec.dls.Min;
if (targetRes > mdl)
{
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Specified resolution level (" + targetRes + ") is larger" + " than the maximum value. Setting it to " + mdl + " (maximum value)");
targetRes = mdl;
}
// Backup nBytes
for (int tIdx = 0; tIdx < nt; tIdx++)
{
baknBytes[tIdx] = nBytes[tIdx];
}
return ;
}
remainingTileParts = 0;
// Update 'res' value once all tile-part headers are read
if (pl.getParameter("res") == null)
{
targetRes = decSpec.dls.Min;
}
else
{
try
{
targetRes = pl.getIntParameter("res");
if (targetRes < 0)
{
throw new System.ArgumentException("Specified negative " + "resolution level index: " + targetRes);
}
}
catch (System.FormatException)
{
throw new System.ArgumentException("Invalid resolution level " + "index ('-res' option) " + pl.getParameter("res"));
}
}
// Verify reduction in resolution level
mdl = decSpec.dls.Min;
if (targetRes > mdl)
{
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Specified resolution level (" + targetRes + ") is larger" + " than the maximum possible. Setting it to " + mdl + " (maximum possible)");
targetRes = mdl;
}
if (printInfo)
{
}
// Check presence of EOC marker is decoding rate not reached or if
// this marker has not been found yet
if (!isEOCFound && !isPsotEqualsZero)
{
try
{
short eocCheck = 0;
if (in_Renamed.Pos + sizeof(short) <= in_Renamed.length())
eocCheck = in_Renamed.readShort();
if (!rateReached && !isPsotEqualsZero && eocCheck != CSJ2K.j2k.codestream.Markers.EOC)
{
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "EOC marker not found. " + "Codestream is corrupted.");
}
}
catch (System.IO.EndOfStreamException)
{
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "EOC marker is missing");
}
}
// Bit-rate allocation
if (!isTruncMode)
{
allocateRate();
}
else
{
// Take EOC into account if rate is not reached
if (in_Renamed.Pos >= tnbytes)
anbytes += 2;
}
// Backup nBytes
for (int tIdx = 0; tIdx < nt; tIdx++)
{
baknBytes[tIdx] = nBytes[tIdx];
if (printInfo)
{
FacilityManager.getMsgLogger().println("" + hi.toStringTileHeader(tIdx, tilePartLen[tIdx].Length), 2, 2);
}
}
}
/// <summary> Constructs a new 'StringSpec' for the specified number of
/// components:tiles and the arguments of <tt>optName</tt>
/// option. This constructor is called by the encoder. It also
/// checks that the arguments belongs to the recognized arguments
/// list.
///
/// <P><u>Note:</u> The arguments must not start with 't' or 'c'
/// since it is reserved for respectively tile and components
/// indexes specification.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="name">of the option using boolean spec.
///
/// </param>
/// <param name="list">The list of all recognized argument in a String array
///
/// </param>
/// <param name="pl">The ParameterList
///
/// </param>
public StringSpec(int nt, int nc, byte type, System.String optName, System.String[] list, ParameterList pl):base(nt, nc, type)
{
System.String param = pl.getParameter(optName);
bool recognized = false;
if (param == null)
{
param = pl.DefaultParameterList.getParameter(optName);
for (int i = list.Length - 1; i >= 0; i--)
if (param.ToUpper().Equals(list[i].ToUpper()))
recognized = true;
if (!recognized)
throw new System.ArgumentException("Default parameter of " + "option -" + optName + " not" + " recognized: " + param);
setDefault(param);
return ;
}
// Parse argument
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
System.String word; // current word
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the
// specification
bool[] compSpec = null; // Components concerned by the specification
//System.Boolean value_Renamed;
while (stk.HasMoreTokens())
{
word = stk.NextToken();
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_TILE_DEF;
}
break;
case 'c': // Components specification
compSpec = parseIdx(word, nComp);
if (curSpecType == SPEC_TILE_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
curSpecType = SPEC_COMP_DEF;
break;
default:
recognized = false;
for (int i = list.Length - 1; i >= 0; i--)
if (word.ToUpper().Equals(list[i].ToUpper()))
recognized = true;
if (!recognized)
throw new System.ArgumentException("Default parameter of " + "option -" + optName + " not" + " recognized: " + word);
if (curSpecType == SPEC_DEF)
{
setDefault(word);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
if (tileSpec[i])
{
setTileDef(i, word);
}
}
else if (curSpecType == SPEC_COMP_DEF)
{
for (int i = compSpec.Length - 1; i >= 0; i--)
if (compSpec[i])
{
setCompDef(i, word);
}
}
else
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
for (int j = compSpec.Length - 1; j >= 0; j--)
{
if (tileSpec[i] && compSpec[j])
{
setTileCompVal(i, j, word);
}
}
}
}
// Re-initialize
curSpecType = SPEC_DEF;
tileSpec = null;
compSpec = null;
break;
}
}
// Check that default value has been specified
if (getDefault() == null)
{
int ndefspec = 0;
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[t][c] == SPEC_DEF)
{
ndefspec++;
}
}
}
// If some tile-component have received no specification, it takes
// the default value defined in ParameterList
if (ndefspec != 0)
{
param = pl.DefaultParameterList.getParameter(optName);
for (int i = list.Length - 1; i >= 0; i--)
if (param.ToUpper().Equals(list[i].ToUpper()))
recognized = true;
if (!recognized)
throw new System.ArgumentException("Default parameter of " + "option -" + optName + " not" + " recognized: " + param);
setDefault(param);
}
else
{
// All tile-component have been specified, takes the first
// tile-component value as default.
setDefault(getSpec(0, 0));
switch (specValType[0][0])
{
case SPEC_TILE_DEF:
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[0][c] == SPEC_TILE_DEF)
specValType[0][c] = SPEC_DEF;
}
tileDef[0] = null;
break;
case SPEC_COMP_DEF:
for (int t = nt - 1; t >= 0; t--)
{
if (specValType[t][0] == SPEC_COMP_DEF)
specValType[t][0] = SPEC_DEF;
}
compDef[0] = null;
break;
case SPEC_TILE_COMP:
specValType[0][0] = SPEC_DEF;
tileCompVal["t0c0"] = null;
break;
}
}
}
}
