/// <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 '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> Creates a EntropyCoder object for the appropriate entropy coding
/// parameters in the parameter list 'pl', and having 'src' as the source
/// of quantized data.
///
/// </summary>
/// <param name="src">The source of data to be entropy coded
///
/// </param>
/// <param name="pl">The parameter list (or options).
///
/// </param>
/// <param name="cbks">Code-block size specifications
///
/// </param>
/// <param name="pss">Precinct partition specifications
///
/// </param>
/// <param name="bms">By-pass mode specifications
///
/// </param>
/// <param name="mqrs">MQ-reset specifications
///
/// </param>
/// <param name="rts">Regular termination specifications
///
/// </param>
/// <param name="css">Causal stripes specifications
///
/// </param>
/// <param name="sss">Error resolution segment symbol use specifications
///
/// </param>
/// <param name="lcs">Length computation specifications
///
/// </param>
/// <param name="tts">Termination type specifications
///
/// </param>
/// <exception cref="IllegalArgumentException">If an error occurs while parsing
/// the options in 'pl'
///
/// </exception>
public static EntropyCoder createInstance(CBlkQuantDataSrcEnc src, ParameterList pl, CBlkSizeSpec cblks, PrecinctSizeSpec pss, StringSpec bms, StringSpec mqrs, StringSpec rts, StringSpec css, StringSpec sss, StringSpec lcs, StringSpec tts)
{
// Check parameters
pl.checkList(OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(pinfo));
return new StdEntropyCoder(src, cblks, pss, bms, mqrs, rts, css, sss, lcs, tts);
}
/// <summary> Initialize all members with the given number of tiles and components
/// and the command-line arguments stored in a ParameterList instance
///
/// </summary>
/// <param name="nt">Number of tiles
///
/// </param>
/// <param name="nc">Number of components
///
/// </param>
/// <param name="imgsrc">The image source (used to get the image size)
///
/// </param>
/// <param name="pl">The ParameterList instance
///
/// </param>
public EncoderSpecs(int nt, int nc, BlkImgDataSrc imgsrc, ParameterList pl)
{
nTiles = nt;
nComp = nc;
// ROI
rois = new MaxShiftSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Quantization
pl.checkList(Quantizer.OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(Quantizer.ParameterInfo));
qts = new QuantTypeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
qsss = new QuantStepSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
gbs = new GuardBitsSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
// Wavelet transform
wfs = new AnWTFilterSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, qts, pl);
dls = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl, "Wlev");
// Component transformation
cts = new ForwCompTransfSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE, wfs, pl);
// Entropy coder
System.String[] strLcs = new System.String[]{"near_opt", "lazy_good", "lazy"};
lcs = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Clen_calc", strLcs, pl);
System.String[] strTerm = new System.String[]{"near_opt", "easy", "predict", "full"};
tts = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cterm_type", strTerm, pl);
System.String[] strBoolean = new System.String[]{"on", "off"};
sss = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cseg_symbol", strBoolean, pl);
css = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Ccausal", strBoolean, pl);
rts = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cterminate", strBoolean, pl);
mqrs = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "CresetMQ", strBoolean, pl);
bms = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cbypass", strBoolean, pl);
cblks = new CBlkSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
// Precinct partition
pss = new PrecinctSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, imgsrc, dls, pl);
// Codestream
sops = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE, "Psop", strBoolean, pl);
ephs = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE, "Peph", strBoolean, pl);
}
/// <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> Creates a HeaderDecoder instance and read in two passes the main header
/// of the codestream. The first and last marker segments shall be
/// respectively SOC and SOT.
///
/// </summary>
/// <param name="ehs">The encoded header stream where marker segments are
/// extracted.
///
/// </param>
/// <param name="pl">The ParameterList object of the decoder
///
/// </param>
/// <param name="hi">The HeaderInfo holding information found in marker segments
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoded header stream.
/// </exception>
/// <exception cref="EOFException">If the end of the encoded header stream is
/// reached before getting all the data.
/// </exception>
/// <exception cref="CorruptedCodestreamException">If invalid data is found in the
/// codestream main header.
///
/// </exception>
public HeaderDecoder(RandomAccessIO ehs, ParameterList pl, HeaderInfo hi)
{
this.hi = hi;
// CONVERSION PROBLEM?
//this.verbose = verbose;
pl.checkList(OPT_PREFIX, ParameterList.toNameArray(pinfo));
mainHeadOff = ehs.Pos;
if (((short) ehs.readShort()) != CSJ2K.j2k.codestream.Markers.SOC)
{
throw new CorruptedCodestreamException("SOC marker segment not " + " found at the " + "beginning of the " + "codestream.");
}
// First Pass: Decode and store main header information until the SOT
// marker segment is found
nfMarkSeg = 0;
do
{
extractMainMarkSeg(ehs.readShort(), ehs);
}
while ((nfMarkSeg & SOT_FOUND) == 0); //Stop when SOT is found
ehs.seek(ehs.Pos - 2); // Realign codestream on SOT marker
// Second pass: Read each marker segment previously found
readFoundMainMarkSeg();
}
/// <summary> Creates and returns the entropy decoder corresponding to the
/// information read from the codestream header and with the special
/// additional parameters from the parameter list.
///
/// </summary>
/// <param name="src">The bit stream reader agent where to get code-block data
/// from.
///
/// </param>
/// <param name="pl">The parameter list containing parameters applicable to the
/// entropy decoder (other parameters can also be present).
///
/// </param>
/// <returns> The entropy decoder
///
/// </returns>
public virtual EntropyDecoder createEntropyDecoder(CodedCBlkDataSrcDec src, ParameterList pl)
{
bool doer;
bool verber;
int mMax;
// Check parameters
pl.checkList(EntropyDecoder.OPT_PREFIX, ParameterList.toNameArray(EntropyDecoder.ParameterInfo));
// Get error detection option
doer = pl.getBooleanParameter("Cer");
// Get verbose error detection option
verber = pl.getBooleanParameter("Cverber");
// Get maximum number of bit planes from m quit condition
mMax = pl.getIntParameter("m_quit");
return new StdEntropyDecoder(src, decSpec, doer, verber, mMax);
}
/// <summary> Creates a new packet encoder object, using the information from the
/// 'infoSrc' object.
///
/// </summary>
/// <param name="infoSrc">The source of information to construct the object.
///
/// </param>
/// <param name="encSpec">The encoding parameters.
///
/// </param>
/// <param name="numPrec">Maximum number of precincts in each tile, component
/// and resolution level.
///
/// </param>
/// <param name="pl">ParameterList instance that holds command line options
///
/// </param>
public PktEncoder(CodedCBlkDataSrcEnc infoSrc, EncoderSpecs encSpec, Coord[][][] numPrec, ParameterList pl)
{
this.infoSrc = infoSrc;
this.encSpec = encSpec;
// Check parameters
pl.checkList(OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(pinfo));
// Get number of components and tiles
int nc = infoSrc.NumComps;
int nt = infoSrc.getNumTiles();
// Do initial allocation
ttIncl = new TagTreeEncoder[nt][][][][];
for (int i = 0; i < nt; i++)
{
ttIncl[i] = new TagTreeEncoder[nc][][][];
}
ttMaxBP = new TagTreeEncoder[nt][][][][];
for (int i2 = 0; i2 < nt; i2++)
{
ttMaxBP[i2] = new TagTreeEncoder[nc][][][];
}
lblock = new int[nt][][][][];
for (int i3 = 0; i3 < nt; i3++)
{
lblock[i3] = new int[nc][][][];
}
prevtIdxs = new int[nt][][][][];
for (int i4 = 0; i4 < nt; i4++)
{
prevtIdxs[i4] = new int[nc][][][];
}
ppinfo = new PrecInfo[nt][][][];
for (int i5 = 0; i5 < nt; i5++)
{
ppinfo[i5] = new PrecInfo[nc][][];
}
// Finish allocation
SubbandAn root, sb;
int maxs, mins;
int mrl;
//Coord tmpCoord = null;
int numcb; // Number of code-blocks
//System.Collections.ArrayList cblks = null;
infoSrc.setTile(0, 0);
for (int t = 0; t < nt; t++)
{
// Loop on tiles
for (int c = 0; c < nc; c++)
{
// Loop on components
// Get number of resolution levels
root = infoSrc.getAnSubbandTree(t, c);
mrl = root.resLvl;
lblock[t][c] = new int[mrl + 1][][];
ttIncl[t][c] = new TagTreeEncoder[mrl + 1][][];
ttMaxBP[t][c] = new TagTreeEncoder[mrl + 1][][];
prevtIdxs[t][c] = new int[mrl + 1][][];
ppinfo[t][c] = new PrecInfo[mrl + 1][];
for (int r = 0; r <= mrl; r++)
{
// Loop on resolution levels
mins = (r == 0)?0:1;
maxs = (r == 0)?1:4;
int maxPrec = numPrec[t][c][r].x * numPrec[t][c][r].y;
ttIncl[t][c][r] = new TagTreeEncoder[maxPrec][];
for (int i6 = 0; i6 < maxPrec; i6++)
{
ttIncl[t][c][r][i6] = new TagTreeEncoder[maxs];
}
ttMaxBP[t][c][r] = new TagTreeEncoder[maxPrec][];
for (int i7 = 0; i7 < maxPrec; i7++)
{
ttMaxBP[t][c][r][i7] = new TagTreeEncoder[maxs];
}
prevtIdxs[t][c][r] = new int[maxs][];
lblock[t][c][r] = new int[maxs][];
// Precincts and code-blocks
ppinfo[t][c][r] = new PrecInfo[maxPrec];
fillPrecInfo(t, c, r);
for (int s = mins; s < maxs; s++)
{
// Loop on subbands
sb = (SubbandAn) root.getSubbandByIdx(r, s);
numcb = sb.numCb.x * sb.numCb.y;
lblock[t][c][r][s] = new int[numcb];
ArrayUtil.intArraySet(lblock[t][c][r][s], INIT_LBLOCK);
prevtIdxs[t][c][r][s] = new int[numcb];
ArrayUtil.intArraySet(prevtIdxs[t][c][r][s], - 1);
}
}
}
if (t != nt - 1)
infoSrc.nextTile();
}
}
/// <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 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> 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 bit stream reader of the correct type that works on the
/// provided RandomAccessIO, with the special parameters from the parameter
/// list.
///
/// </summary>
/// <param name="in">The RandomAccessIO source from which to read the bit stream.
///
/// </param>
/// <param name="hd">Header of the codestream.
///
/// </param>
/// <param name="pl">The parameter list containing parameters applicable to the
/// bit stream read (other parameters may also be present).
///
/// </param>
/// <param name="decSpec">The decoder specifications
///
/// </param>
/// <param name="cdstrInfo">Whether or not to print information found in
/// codestream.
///
/// </param>
/// <param name="hi">Reference to the HeaderInfo instance.
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading initial
/// data from the bit stream.
/// </exception>
/// <exception cref="IllegalArgumentException">If an unrecognised bit stream
/// reader option is present.
///
/// </exception>
public static BitstreamReaderAgent createInstance(RandomAccessIO in_Renamed, HeaderDecoder hd, ParameterList pl, DecoderSpecs decSpec, bool cdstrInfo, HeaderInfo hi)
{
// Check parameters
pl.checkList(BitstreamReaderAgent.OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(BitstreamReaderAgent.ParameterInfo));
return new FileBitstreamReaderAgent(hd, in_Renamed, decSpec, pl, cdstrInfo, hi);
}
