/// <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> Initialize all members with the given number of tiles and components. /// /// </summary> /// <param name="nt">Number of tiles /// /// </param> /// <param name="nc">Number of components /// /// </param> public DecoderSpecs(int nt, int nc) { // Quantization qts = new QuantTypeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP); qsss = new QuantStepSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP); gbs = new GuardBitsSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP); // Wavelet transform wfs = new SynWTFilterSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP); dls = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP); // Component transformation cts = new CompTransfSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP); // Entropy decoder ecopts = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP); ers = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP); cblks = new CBlkSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP); // Precinct partition pss = new PrecinctSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, dls); // Codestream nls = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE); pos = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE); pcs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE); sops = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE); ephs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE); pphs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE); iccs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE); pphs.setDefault((System.Object) false); }
/// <summary> Initializes the source of wavelet transform coefficients. The /// constructor takes information on whether the quantizer is in /// reversible, derived or expounded mode. If the quantizer is reversible /// the value of 'derived' is ignored. If the source data is not integer /// (int) then the quantizer can not be reversible. /// /// <p>After initializing member attributes, getAnSubbandTree is called for /// all components setting the 'stepWMSE' for all subbands in the current /// tile.</p> /// /// </summary> /// <param name="src">The source of wavelet transform coefficients. /// /// </param> /// <param name="encSpec">The encoder specifications /// /// </param> public StdQuantizer(CBlkWTDataSrc src, EncoderSpecs encSpec):base(src) { qts = encSpec.qts; qsss = encSpec.qsss; gbs = encSpec.gbs; }
/// <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 source of compressed data. And sets the number of range /// bits and fraction bits and receives the parameters for the dequantizer. /// /// </summary> /// <param name="src">From where to obtain the quantized data. /// /// </param> /// <param name="rb">The number of "range bits" (bitdepth) for each component /// (must be the "range bits" of the un-transformed components). For a /// definition of "range bits" see the getNomRangeBits() method. /// /// </param> /// <param name="qts">The quantizer type spec /// /// </param> /// <param name="qsss">The dequantizer step sizes spec /// /// </param> /// <seealso cref="Dequantizer.getNomRangeBits"> /// /// </seealso> /// <exception cref="IllegalArgumentException">Thrown if 'outdt' is neither /// TYPE_FLOAT nor TYPE_INT, or if 'param' specify reversible quantization /// and 'outdt' is not TYPE_INT or 'fp' has non-zero values, or if 'outdt' /// is TYPE_FLOAT and 'fp' has non-zero values. /// /// </exception> public StdDequantizer(CBlkQuantDataSrcDec src, int[] utrb, DecoderSpecs decSpec):base(src, utrb, decSpec) { if (utrb.Length != src.NumComps) { throw new System.ArgumentException("Invalid rb argument"); } this.qsss = decSpec.qsss; this.qts = decSpec.qts; this.gbs = decSpec.gbs; }