/// <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> Instantiates the 'InvWTAdapter' object using the specified /// 'MultiResImgData' source. The reconstruction resolution level is set to /// full resolution (i.e. the maximum resolution level). /// /// </summary> /// <param name="src">From where to obtain the values to return /// /// </param> /// <param name="decSpec">The decoder specifications /// /// </param> protected internal InvWTAdapter(MultiResImgData src, DecoderSpecs decSpec) { mressrc = src; this.decSpec = decSpec; maxImgRes = decSpec.dls.Min; }
/// <summary> Constructs a new ForwCompTransf object that operates on the /// specified source of image data. /// /// </summary> /// <param name="imgSrc">The source from where to get the data to be /// transformed /// /// </param> /// <param name="decSpec">The decoder specifications /// /// </param> /// <param name="utdepth">The bit depth of the un-transformed components /// /// </param> /// <param name="pl">The command line optinons of the decoder /// /// </param> /// <seealso cref="BlkImgDataSrc"> /// /// </seealso> public InvCompTransf(BlkImgDataSrc imgSrc, DecoderSpecs decSpec, int[] utdepth, ParameterList pl):base(imgSrc) { this.cts = decSpec.cts; this.wfs = decSpec.wfs; src = imgSrc; this.utdepth = utdepth; noCompTransf = !(pl.getBooleanParameter("comp_transf")); }
//private bool[][] reversible; /// <summary> Initializes this object with the given source of wavelet /// coefficients. It initializes the resolution level for full resolutioin /// reconstruction. /// /// </summary> /// <param name="src">from where the wavelet coefficinets should be obtained. /// /// </param> /// <param name="decSpec">The decoder specifications /// /// </param> public InvWTFull(CBlkWTDataSrcDec src, DecoderSpecs decSpec) : base(src, decSpec) { this.src = src; int nc = src.NumComps; reconstructedComps = new DataBlk[nc]; ndl = new int[nc]; }
/// <summary> Returns the dequantizer parameters. Dequantizer parameters normally are /// the quantization step sizes, see DequantizerParams. /// /// </summary> /// <param name="src">The source of data for the dequantizer. /// /// </param> /// <param name="rb">The number of range bits for each component. Must be /// the number of range bits of the mixed components. /// /// </param> /// <param name="decSpec2">The DecoderSpecs instance after any image manipulation. /// /// </param> /// <returns> The dequantizer /// /// </returns> public Dequantizer createDequantizer(CBlkQuantDataSrcDec src, int[] rb, DecoderSpecs decSpec2) { return new StdDequantizer(src, rb, decSpec2); }
/// <summary> Reads the SIZ marker segment and realigns the codestream at the point /// where the next marker segment should be found. /// /// <p>SIZ is a fixed information marker segment containing informations /// about image and tile sizes. It is required in the main header /// immediately after SOC.</p> /// /// </summary> /// <param name="ehs">The encoded header stream /// /// </param> /// <exception cref="IOException">If an I/O error occurs while reading from the /// encoded header stream /// /// </exception> //UPGRADE_TODO: Class 'java.io.DataInputStream' was converted to 'System.IO.BinaryReader' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javaioDataInputStream'" private void readSIZ(System.IO.BinaryReader ehs) { HeaderInfo.SIZ ms = hi.NewSIZ; hi.sizValue = ms; // Read the length of SIZ marker segment (Lsiz) ms.lsiz = ehs.ReadUInt16(); // Read the capability of the codestream (Rsiz) ms.rsiz = ehs.ReadUInt16(); if (ms.rsiz > 2) { throw new System.ApplicationException("Codestream capabiities not JPEG 2000 - Part I" + " compliant"); } // Read image size ms.xsiz = ehs.ReadInt32(); ms.ysiz = ehs.ReadInt32(); if (ms.xsiz <= 0 || ms.ysiz <= 0) { throw new System.IO.IOException("JJ2000 does not support images whose " + "width and/or height not in the " + "range: 1 -- (2^31)-1"); } // Read image offset ms.x0siz = ehs.ReadInt32(); ms.y0siz = ehs.ReadInt32(); if (ms.x0siz < 0 || ms.y0siz < 0) { throw new System.IO.IOException("JJ2000 does not support images offset " + "not in the range: 0 -- (2^31)-1"); } // Read size of tile ms.xtsiz = ehs.ReadInt32(); ms.ytsiz = ehs.ReadInt32(); if (ms.xtsiz <= 0 || ms.ytsiz <= 0) { throw new System.IO.IOException("JJ2000 does not support tiles whose " + "width and/or height are not in " + "the range: 1 -- (2^31)-1"); } // Read upper-left tile offset ms.xt0siz = ehs.ReadInt32(); ms.yt0siz = ehs.ReadInt32(); if (ms.xt0siz < 0 || ms.yt0siz < 0) { throw new System.IO.IOException("JJ2000 does not support tiles whose " + "offset is not in " + "the range: 0 -- (2^31)-1"); } // Read number of components and initialize related arrays nComp = ms.csiz = ehs.ReadUInt16(); if (nComp < 1 || nComp > 16384) { throw new System.ArgumentException("Number of component out of " + "range 1--16384: " + nComp); } ms.ssiz = new int[nComp]; ms.xrsiz = new int[nComp]; ms.yrsiz = new int[nComp]; // Read bit-depth and down-sampling factors of each component for (int i = 0; i < nComp; i++) { ms.ssiz[i] = ehs.ReadByte(); ms.xrsiz[i] = ehs.ReadByte(); ms.yrsiz[i] = ehs.ReadByte(); } // Check marker length checkMarkerLength(ehs, "SIZ marker"); // Create needed ModuleSpec nTiles = ms.NumTiles; // Finish initialization of decSpec decSpec = new DecoderSpecs(nTiles, nComp); }
/// <summary> Creates an empty PktDecoder object associated with given decoder /// specifications and HeaderDecoder. This object must be initialized /// thanks to the restart method before being used. /// /// </summary> /// <param name="decSpec">The decoder specifications. /// /// </param> /// <param name="hd">The HeaderDecoder instance. /// /// </param> /// <param name="ehs">The stream where to read data from. /// /// </param> /// <param name="src">The bit stream reader agent. /// /// </param> /// <param name="isTruncMode">Whether or not truncation mode is required. /// /// </param> /// <param name="maxCB">The maximum number of code-blocks to read before ncbquit /// /// /// </param> public PktDecoder(DecoderSpecs decSpec, HeaderDecoder hd, RandomAccessIO ehs, BitstreamReaderAgent src, bool isTruncMode, int maxCB) { this.decSpec = decSpec; this.hd = hd; this.ehs = ehs; this.isTruncMode = isTruncMode; bin = new PktHeaderBitReader(ehs); this.src = src; ncb = 0; ncbQuit = false; this.maxCB = maxCB; }
/// <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; }
/// <summary> Initializes members of this class. This constructor takes a /// HeaderDecoder object. This object must be initialized by the /// constructor of the implementing class from the header of the bit /// stream. /// /// </summary> /// <param name="hd">The decoded header of the bit stream from where to initialize /// the values. /// /// </param> /// <param name="decSpec">The decoder specifications /// /// </param> protected internal BitstreamReaderAgent(HeaderDecoder hd, DecoderSpecs decSpec) { Coord co; //int i, j, max; this.decSpec = decSpec; this.hd = hd; // Number of components nc = hd.NumComps; offX = new int[nc]; offY = new int[nc]; culx = new int[nc]; culy = new int[nc]; // Image size and origin imgW = hd.ImgWidth; imgH = hd.ImgHeight; ax = hd.ImgULX; ay = hd.ImgULY; // Tiles co = hd.getTilingOrigin(null); px = co.x; py = co.y; ntW = hd.NomTileWidth; ntH = hd.NomTileHeight; ntX = (ax + imgW - px + ntW - 1) / ntW; ntY = (ay + imgH - py + ntH - 1) / ntH; nt = ntX * ntY; }
/// <summary> Instantiates a new entropy decoder engine, with the specified source of /// data, nominal block width and height. /// /// </summary> /// <param name="src">The source of data /// /// </param> /// <param name="opt">The options to use for this encoder. It is a mix of the /// 'OPT_TERM_PASS', 'OPT_RESET_MQ', 'OPT_VERT_STR_CAUSAL', 'OPT_BYPASS' /// and 'OPT_SEG_SYMBOLS' option flags. /// /// </param> /// <param name="doer">If true error detection will be performed, if any error /// detection features have been enabled. /// /// </param> /// <param name="verber">This flag indicates if the entropy decoder should be /// verbose about bit stream errors that are detected and concealed. /// /// </param> /// <param name="mQuit">the maximum number of bit planes to decode according to /// the m quit condition /// /// </param> public StdEntropyDecoder(CodedCBlkDataSrcDec src, DecoderSpecs decSpec, bool doer, bool verber, int mQuit):base(src) { this.decSpec = decSpec; this.doer = doer; this.verber = verber; this.mQuit = mQuit; // If we do timing create necessary structures #if DO_TIMING time = new long[src.NumComps]; // If we are timing make sure that 'finalize' gets called. //UPGRADE_ISSUE: Method 'java.lang.System.runFinalizersOnExit' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javalangSystem'" // CONVERSION PROBLEM? //System_Renamed.runFinalizersOnExit(true); #endif // Initialize internal variables state = new int[(decSpec.cblks.MaxCBlkWidth + 2) * ((decSpec.cblks.MaxCBlkHeight + 1) / 2 + 2)]; }
/// <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); }
/// <summary> Initializes this object with the given source of wavelet /// coefficients. It initializes the resolution level for full resolutioin /// reconstruction (i.e. the maximum resolution available from the 'src' /// source). /// /// <p>It is assumed here that all tiles and components have the same /// reconstruction resolution level. If that was not the case it should be /// the value for the current tile of the source.</p> /// /// </summary> /// <param name="src">from where the wavelet coefficinets should be obtained. /// /// </param> /// <param name="decSpec">The decoder specifications /// /// </param> public InverseWT(MultiResImgData src, DecoderSpecs decSpec) : base(src, decSpec) { }
/// <summary> Creates an InverseWT object that works on the data type of the source, /// with the special additional parameters from the parameter /// list. Currently the parameter list is ignored since no special /// parameters can be specified for the inverse wavelet transform yet. /// /// </summary> /// <param name="src">The source of data for the inverse wavelet /// transform. /// /// </param> /// <param name="pl">The parameter list containing parameters applicable to the /// inverse wavelet transform (other parameters can also be present). /// /// </param> public static InverseWT createInstance(CBlkWTDataSrcDec src, DecoderSpecs decSpec) { // full page wavelet transform return new InvWTFull(src, decSpec); }
/// <summary> Initializes the source of compressed data. /// /// </summary> /// <param name="src">From where to obtain the quantized data. /// /// </param> /// <param name="rb">The number of "range bits" for each component (must be the /// "range bits" of the un-transformed components. For a definition of /// "range bits" see the getNomRangeBits() method. /// /// </param> /// <seealso cref="getNomRangeBits"> /// /// </seealso> public Dequantizer(CBlkQuantDataSrcDec src, int[] utrb, DecoderSpecs decSpec):base(src) { if (utrb.Length != src.NumComps) { throw new System.ArgumentException(); } this.src = src; this.utrb = utrb; this.cts = decSpec.cts; this.wfs = decSpec.wfs; }
/// <summary> Creates and returns the ROIDeScaler 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> /// <param name="decSpec2">The DecoderSpecs instance after any image manipulation. /// /// </param> /// <returns> The ROI descaler. /// /// </returns> public virtual ROIDeScaler createROIDeScaler(CBlkQuantDataSrcDec src, ParameterList pl, DecoderSpecs decSpec2) { return ROIDeScaler.createInstance(src, pl, decSpec2); }
/// <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); } } }
//private bool[][] reversible; /// <summary> Initializes this object with the given source of wavelet /// coefficients. It initializes the resolution level for full resolutioin /// reconstruction. /// /// </summary> /// <param name="src">from where the wavelet coefficinets should be obtained. /// /// </param> /// <param name="decSpec">The decoder specifications /// /// </param> public InvWTFull(CBlkWTDataSrcDec src, DecoderSpecs decSpec):base(src, decSpec) { this.src = src; int nc = src.NumComps; reconstructedComps = new DataBlk[nc]; ndl = new int[nc]; pw = FacilityManager.ProgressWatch; }