corrade-vassal – Rev 1
?pathlinks?
/*
* CVS identifier:
*
* $Id: HeaderDecoder.java,v 1.61 2002/07/25 15:01:00 grosbois Exp $
*
* Class: HeaderDecoder
*
* Description: Reads main and tile-part headers.
*
*
*
* COPYRIGHT:
*
* This software module was originally developed by Raphaël Grosbois and
* Diego Santa Cruz (Swiss Federal Institute of Technology-EPFL); Joel
* Askelöf (Ericsson Radio Systems AB); and Bertrand Berthelot, David
* Bouchard, Félix Henry, Gerard Mozelle and Patrice Onno (Canon Research
* Centre France S.A) in the course of development of the JPEG2000
* standard as specified by ISO/IEC 15444 (JPEG 2000 Standard). This
* software module is an implementation of a part of the JPEG 2000
* Standard. Swiss Federal Institute of Technology-EPFL, Ericsson Radio
* Systems AB and Canon Research Centre France S.A (collectively JJ2000
* Partners) agree not to assert against ISO/IEC and users of the JPEG
* 2000 Standard (Users) any of their rights under the copyright, not
* including other intellectual property rights, for this software module
* with respect to the usage by ISO/IEC and Users of this software module
* or modifications thereof for use in hardware or software products
* claiming conformance to the JPEG 2000 Standard. Those intending to use
* this software module in hardware or software products are advised that
* their use may infringe existing patents. The original developers of
* this software module, JJ2000 Partners and ISO/IEC assume no liability
* for use of this software module or modifications thereof. No license
* or right to this software module is granted for non JPEG 2000 Standard
* conforming products. JJ2000 Partners have full right to use this
* software module for his/her own purpose, assign or donate this
* software module to any third party and to inhibit third parties from
* using this software module for non JPEG 2000 Standard conforming
* products. This copyright notice must be included in all copies or
* derivative works of this software module.
*
* Copyright (c) 1999/2000 JJ2000 Partners.
* */
using System;
using CSJ2K.j2k.quantization.dequantizer;
using CSJ2K.j2k.wavelet.synthesis;
using CSJ2K.j2k.entropy.decoder;
using CSJ2K.j2k.quantization;
using CSJ2K.j2k.codestream;
using CSJ2K.j2k.wavelet;
using CSJ2K.j2k.entropy;
using CSJ2K.j2k.decoder;
using CSJ2K.j2k.image;
using CSJ2K.j2k.util;
using CSJ2K.j2k.roi;
using CSJ2K.j2k.io;
using CSJ2K.j2k;
using CSJ2K.Color;
using CSJ2K.Icc;
namespace CSJ2K.j2k.codestream.reader
{
/// <summary> This class reads main and tile-part headers from the codestream given a
/// RandomAccessIO instance located at the beginning of the codestream (i.e
/// just before the SOC marker) or at the beginning of a tile-part (i.e. just
/// before a SOT marker segment) respectively.
///
/// <p>A marker segment includes a marker and eventually marker segment
/// parameters. It is designed by the three letters code of the marker
/// associated with the marker segment. JPEG 2000 part 1 defines 6 types of
/// markers segments:
///
/// <ul>
/// <li> Delimiting : SOC, SOT, SOD, EOC</li>
///
/// <li> Fixed information: SIZ.</li>
///
/// <li> Functional: COD, COC, RGN, QCD, QCC,POC.</li>
///
/// <li> In bit-stream: SOP, EPH.</li>
///
/// <li> Pointer: TLM, PLM, PLT, PPM, PPT.</li>
///
/// <li> Informational: CRG, COM.</li>
/// </ul></p>
///
/// <p>The main header is read when the constructor is called whereas tile-part
/// headers are read when the FileBitstreamReaderAgent instance is created. The
/// reading is done in 2 passes:
///
/// <ol>
/// <li>All marker segments are buffered and their corresponding flag is
/// activated (extractMainMarkSeg and extractTilePartMarkSeg methods).</li>
///
/// <li>Buffered marker segment are analyzed in a logical way and
/// specifications are stored in appropriate member of DecoderSpecs instance
/// (readFoundMainMarkSeg and readFoundTilePartMarkSeg methods).</li>
/// </ol></p>
///
/// <p>Whenever a marker segment is not recognized a warning message is
/// displayed and its length parameter is used to skip it.</p>
///
/// <p>The information found in this header is stored in HeaderInfo and
/// DecoderSpecs instances.</p>
///
/// </summary>
/// <seealso cref="DecoderSpecs">
/// </seealso>
/// <seealso cref="HeaderInfo">
/// </seealso>
/// <seealso cref="Decoder">
/// </seealso>
/// <seealso cref="FileBitstreamReaderAgent">
///
/// </seealso>
public class HeaderDecoder
{
/// <summary> Return the maximum height among all components
///
/// </summary>
/// <returns> Maximum component height
///
/// </returns>
virtual public int MaxCompImgHeight
{
get
{
return hi.sizValue.MaxCompHeight;
}
}
/// <summary> Return the maximum width among all components
///
/// </summary>
/// <returns> Maximum component width
///
/// </returns>
virtual public int MaxCompImgWidth
{
get
{
return hi.sizValue.MaxCompWidth;
}
}
/// <summary> Returns the image width in the reference grid.
///
/// </summary>
/// <returns> The image width in the reference grid
///
/// </returns>
virtual public int ImgWidth
{
get
{
return hi.sizValue.xsiz - hi.sizValue.x0siz;
}
}
/// <summary> Returns the image height in the reference grid.
///
/// </summary>
/// <returns> The image height in the reference grid
///
/// </returns>
virtual public int ImgHeight
{
get
{
return hi.sizValue.ysiz - hi.sizValue.y0siz;
}
}
/// <summary> Return the horizontal upper-left coordinate of the image in the
/// reference grid.
///
/// </summary>
/// <returns> The horizontal coordinate of the image origin.
///
/// </returns>
virtual public int ImgULX
{
get
{
return hi.sizValue.x0siz;
}
}
/// <summary> Return the vertical upper-left coordinate of the image in the reference
/// grid.
///
/// </summary>
/// <returns> The vertical coordinate of the image origin.
///
/// </returns>
virtual public int ImgULY
{
get
{
return hi.sizValue.y0siz;
}
}
/// <summary> Returns the nominal width of the tiles in the reference grid.
///
/// </summary>
/// <returns> The nominal tile width, in the reference grid.
///
/// </returns>
virtual public int NomTileWidth
{
get
{
return hi.sizValue.xtsiz;
}
}
/// <summary> Returns the nominal width of the tiles in the reference grid.
///
/// </summary>
/// <returns> The nominal tile width, in the reference grid.
///
/// </returns>
virtual public int NomTileHeight
{
get
{
return hi.sizValue.ytsiz;
}
}
/// <summary> Returns the number of components in the image.
///
/// </summary>
/// <returns> The number of components in the image.
///
/// </returns>
virtual public int NumComps
{
get
{
return nComp;
}
}
/// <summary> Returns the horizontal code-block partition origin.Allowable values are
/// 0 and 1, nothing else.
///
/// </summary>
virtual public int CbULX
{
get
{
return cb0x;
}
}
/// <summary> Returns the vertical code-block partition origin. Allowable values are
/// 0 and 1, nothing else.
///
/// </summary>
virtual public int CbULY
{
get
{
return cb0y;
}
}
/// <summary> Return the DecoderSpecs instance filled when reading the headers
///
/// </summary>
/// <returns> The DecoderSpecs of the decoder
///
/// </returns>
virtual public DecoderSpecs DecoderSpecs
{
get
{
return decSpec;
}
}
/// <summary> Returns the parameters that are used in this class. It returns a 2D
/// String array. Each of the 1D arrays is for a different option, and they
/// have 3 elements. The first element is the option name, the second one
/// is the synopsis and the third one is a long description of what the
/// parameter is. The synopsis or description may be 'null', in which case
/// it is assumed that there is no synopsis or description of the option,
/// respectively.
///
/// </summary>
/// <returns> the options name, their synopsis and their explanation.
///
/// </returns>
public static System.String[][] ParameterInfo
{
get
{
return pinfo;
}
}
/// <summary> Return the number of tiles in the image
///
/// </summary>
/// <returns> The number of tiles
///
/// </returns>
virtual public int NumTiles
{
get
{
return nTiles;
}
}
/// <summary> Sets the tile of each tile part in order. This information is needed
/// for identifying which packet header belongs to which tile when using
/// the PPM marker.
///
/// </summary>
/// <param name="tile">The tile number that the present tile part belongs to.
///
/// </param>
virtual public int TileOfTileParts
{
set
{
if (nPPMMarkSeg != 0)
{
tileOfTileParts.Add((System.Int32) value);
}
}
}
/// <summary> Returns the number of found marker segments in the current header.
///
/// </summary>
/// <returns> The number of marker segments found in the current header.
///
/// </returns>
virtual public int NumFoundMarkSeg
{
get
{
return nfMarkSeg;
}
}
/// <summary>The prefix for header decoder options: 'H' </summary>
public const char OPT_PREFIX = 'H';
/// <summary>The list of parameters that is accepted for quantization. Options
/// for quantization start with 'Q'.
/// </summary>
//UPGRADE_NOTE: Final was removed from the declaration of 'pinfo'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
private static readonly System.String[][] pinfo = null;
/// <summary>The reference to the HeaderInfo instance holding the information found
/// in headers
/// </summary>
private HeaderInfo hi;
/// <summary>Whether or not to display general information </summary>
//private bool verbose;
/// <summary>Current header information in a string </summary>
private System.String hdStr = "";
/// <summary>The number of tiles within the image </summary>
private int nTiles;
/// <summary>The number of tile parts in each tile </summary>
public int[] nTileParts;
/// <summary>Used to store which markers have been already read, by using flag
/// bits. The different markers are marked with XXX_FOUND flags, such as
/// SIZ_FOUND
/// </summary>
private int nfMarkSeg = 0;
/// <summary>Counts number of COC markers found in the header </summary>
private int nCOCMarkSeg = 0;
/// <summary>Counts number of QCC markers found in the header </summary>
private int nQCCMarkSeg = 0;
/// <summary>Counts number of COM markers found in the header </summary>
private int nCOMMarkSeg = 0;
/// <summary>Counts number of RGN markers found in the header </summary>
private int nRGNMarkSeg = 0;
/// <summary>Counts number of PPM markers found in the header </summary>
private int nPPMMarkSeg = 0;
/// <summary>Counts number of PPT markers found in the header </summary>
private int[][] nPPTMarkSeg = null;
/// <summary>Flag bit for SIZ marker segment found </summary>
private const int SIZ_FOUND = 1;
/// <summary>Flag bit for COD marker segment found </summary>
private const int COD_FOUND = 1 << 1;
/// <summary>Flag bit for COC marker segment found </summary>
private const int COC_FOUND = 1 << 2;
/// <summary>Flag bit for QCD marker segment found </summary>
private const int QCD_FOUND = 1 << 3;
/// <summary>Flag bit for TLM marker segment found </summary>
private const int TLM_FOUND = 1 << 4;
/// <summary>Flag bit for PLM marker segment found </summary>
private const int PLM_FOUND = 1 << 5;
/// <summary>Flag bit for SOT marker segment found </summary>
private const int SOT_FOUND = 1 << 6;
/// <summary>Flag bit for PLT marker segment found </summary>
private const int PLT_FOUND = 1 << 7;
/// <summary>Flag bit for QCC marker segment found </summary>
private const int QCC_FOUND = 1 << 8;
/// <summary>Flag bit for RGN marker segment found </summary>
private const int RGN_FOUND = 1 << 9;
/// <summary>Flag bit for POC marker segment found </summary>
private const int POC_FOUND = 1 << 10;
/// <summary>Flag bit for COM marker segment found </summary>
private const int COM_FOUND = 1 << 11;
/// <summary>Flag bit for SOD marker segment found </summary>
public const int SOD_FOUND = 1 << 13;
/// <summary>Flag bit for SOD marker segment found </summary>
public const int PPM_FOUND = 1 << 14;
/// <summary>Flag bit for SOD marker segment found </summary>
public const int PPT_FOUND = 1 << 15;
/// <summary>Flag bit for CRG marker segment found </summary>
public const int CRG_FOUND = 1 << 16;
/// <summary>The reset mask for new tiles </summary>
//UPGRADE_NOTE: Final was removed from the declaration of 'TILE_RESET '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
//private static readonly int TILE_RESET = ~ (PLM_FOUND | SIZ_FOUND | RGN_FOUND);
/// <summary>HashTable used to store temporary marker segment byte buffers </summary>
private System.Collections.Hashtable ht = null;
/// <summary>The number of components in the image </summary>
private int nComp;
/// <summary>The horizontal code-block partition origin </summary>
private int cb0x = - 1;
/// <summary>The vertical code-block partition origin </summary>
private int cb0y = - 1;
/// <summary>The decoder specifications </summary>
private DecoderSpecs decSpec;
/// <summary>Is the precinct partition used </summary>
internal bool precinctPartitionIsUsed;
/// <summary>The offset of the main header in the input stream </summary>
public int mainHeadOff;
/// <summary>Vector containing info as to which tile each tilepart belong </summary>
private System.Collections.ArrayList tileOfTileParts;
/// <summary>Array containing the Nppm and Ippm fields of the PPM marker segments</summary>
private byte[][] pPMMarkerData;
/// <summary>Array containing the Ippm fields of the PPT marker segments </summary>
private byte[][][][] tilePartPkdPktHeaders;
/// <summary>The packed packet headers if the PPM or PPT markers are used </summary>
private System.IO.MemoryStream[] pkdPktHeaders;
/// <summary> Returns the tiling origin, referred to as '(Px,Py)' in the 'ImgData'
/// interface.
///
/// </summary>
/// <param name="co">If not null this object is used to return the information. If
/// null a new one is created and returned.
///
/// </param>
/// <returns> The coordinate of the tiling origin, in the canvas system, on
/// the reference grid.
///
/// </returns>
/// <seealso cref="jj2000.j2k.image.ImgData">
///
/// </seealso>
public Coord getTilingOrigin(Coord co)
{
if (co != null)
{
co.x = hi.sizValue.xt0siz;
co.y = hi.sizValue.yt0siz;
return co;
}
else
{
return new Coord(hi.sizValue.xt0siz, hi.sizValue.yt0siz);
}
}
/// <summary> Returns true if the original data of the specified component was
/// signed. If the data was not signed a level shift has to be applied at
/// the end of the decompression chain.
///
/// </summary>
/// <param name="c">The index of the component
///
/// </param>
/// <returns> True if the original image component was signed.
///
/// </returns>
public bool isOriginalSigned(int c)
{
return hi.sizValue.isOrigSigned(c);
}
/// <summary> Returns the original bitdepth of the specified component.
///
/// </summary>
/// <param name="c">The index of the component
///
/// </param>
/// <returns> The bitdepth of the component
///
/// </returns>
public int getOriginalBitDepth(int c)
{
return hi.sizValue.getOrigBitDepth(c);
}
/// <summary> Returns the component sub-sampling factor, with respect to the
/// reference grid, along the horizontal direction for the specified
/// component.
///
/// </summary>
/// <param name="c">The index of the component
///
/// </param>
/// <returns> The component sub-sampling factor X-wise.
///
/// </returns>
public int getCompSubsX(int c)
{
return hi.sizValue.xrsiz[c];
}
/// <summary> Returns the component sub-sampling factor, with respect to the
/// reference grid, along the vertical direction for the specified
/// component.
///
/// </summary>
/// <param name="c">The index of the component
///
/// </param>
/// <returns> The component sub-sampling factor Y-wise.
///
/// </returns>
public int getCompSubsY(int c)
{
return hi.sizValue.yrsiz[c];
}
/// <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> Returns the precinct partition width for the specified tile-component
/// and resolution level.
///
/// </summary>
/// <param name="c">the component index
///
/// </param>
/// <param name="t">the tile index
///
/// </param>
/// <param name="rl">the resolution level
///
/// </param>
/// <returns> The precinct partition width for the specified tile-component
/// and resolution level
///
/// </returns>
public int getPPX(int t, int c, int rl)
{
return decSpec.pss.getPPX(t, c, rl);
}
/// <summary> Returns the precinct partition height for the specified tile-component
/// and resolution level.
///
/// </summary>
/// <param name="c">the component index
///
/// </param>
/// <param name="t">the tile index
///
/// </param>
/// <param name="rl">the resolution level
///
/// </param>
/// <returns> The precinct partition height for the specified tile-component
/// and resolution level
///
/// </returns>
public int getPPY(int t, int c, int rl)
{
return decSpec.pss.getPPY(t, c, rl);
}
/// <summary> Returns the boolean used to know if the precinct partition is used
///
/// </summary>
public bool precinctPartitionUsed()
{
return precinctPartitionIsUsed;
}
/// <summary> Reads a wavelet filter from the codestream and returns the filter
/// object that implements it.
///
/// </summary>
/// <param name="ehs">The encoded header stream from where to read the info
///
/// </param>
/// <param name="filtIdx">Int array of one element to return the type of the
/// wavelet filter.
///
/// </param>
//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 SynWTFilter readFilter(System.IO.BinaryReader ehs, int[] filtIdx)
{
int kid; // the filter id
kid = filtIdx[0] = ehs.ReadByte();
if (kid >= (1 << 7))
{
throw new NotImplementedException("Custom filters not supported");
}
// Return filter based on ID
switch (kid)
{
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7:
return new SynWTFilterFloatLift9x7();
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3:
return new SynWTFilterIntLift5x3();
default:
throw new CorruptedCodestreamException("Specified wavelet filter " + "not" + " JPEG 2000 part I " + "compliant");
}
}
/// <summary> Checks that the marker segment length is correct.
///
/// </summary>
/// <param name="ehs">The encoded header stream
///
/// </param>
/// <param name="str">The string identifying the marker, such as "SIZ marker"
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs
///
/// </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'"
public virtual void checkMarkerLength(System.IO.BinaryReader ehs, System.String str)
{
long available;
available = ehs.BaseStream.Length - ehs.BaseStream.Position;
if ((int) available != 0)
{
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, str + " length was short, attempting to resync.");
}
}
/// <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> Reads a CRG marker segment and checks its length. CRG is an
/// informational marker segment that allows specific registration of
/// components with respect to each other.
///
/// </summary>
/// <param name="ehs">The encoded header stream
///
/// </param>
//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 readCRG(System.IO.BinaryReader ehs)
{
HeaderInfo.CRG ms = hi.NewCRG;
hi.crgValue = ms;
ms.lcrg = ehs.ReadUInt16();
ms.xcrg = new int[nComp];
ms.ycrg = new int[nComp];
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Information in CRG marker segment " + "not taken into account. This may affect the display " + "of the decoded image.");
for (int c = 0; c < nComp; c++)
{
ms.xcrg[c] = ehs.ReadUInt16();
ms.ycrg[c] = ehs.ReadUInt16();
}
// Check marker length
checkMarkerLength(ehs, "CRG marker");
}
/// <summary> Reads a COM marker segments and realigns the bit stream at the point
/// where the next marker segment should be found. COM is an informational
/// marker segment that allows to include unstructured data in the main and
/// tile-part headers.
///
/// </summary>
/// <param name="ehs">The encoded header stream
///
/// </param>
/// <param name="mainh">Flag indicating whether or not this marker segment is read
/// from the main header.
///
/// </param>
/// <param name="tileIdx">The index of the current tile
///
/// </param>
/// <param name="comIdx">Occurence of this COM marker in eith main or tile-part
/// header
///
/// </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 readCOM(System.IO.BinaryReader ehs, bool mainh, int tileIdx, int comIdx)
{
HeaderInfo.COM ms = hi.NewCOM;
// Read length of COM field
ms.lcom = ehs.ReadUInt16();
// Read the registration value of the COM marker segment
ms.rcom = ehs.ReadUInt16();
switch (ms.rcom)
{
case CSJ2K.j2k.codestream.Markers.RCOM_BINARY:
case CSJ2K.j2k.codestream.Markers.RCOM_LATIN:
ms.ccom = new byte[ms.lcom - 4];
for (int i = 0; i < ms.lcom - 4; i++)
{
ms.ccom[i] = ehs.ReadByte();
}
break;
default:
// --- Unknown or unsupported markers ---
// (skip them and see if we can get way with it)
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "COM marker registered as " + ms.rcom + " unknown, ignoring (this might crash the " + "decoder or decode a quality degraded or even " + "useless image)");
System.IO.BinaryReader temp_BinaryReader;
System.Int64 temp_Int64;
temp_BinaryReader = ehs;
temp_Int64 = temp_BinaryReader.BaseStream.Position;
temp_Int64 = temp_BinaryReader.BaseStream.Seek(ms.lcom - 4, System.IO.SeekOrigin.Current) - temp_Int64;
// CONVERSION PROBLEM?
int generatedAux2 = (int)temp_Int64; //Ignore this field for the moment
break;
}
if (mainh)
{
hi.comValue["main_" + comIdx] = ms;
}
else
{
hi.comValue["t" + tileIdx + "_" + comIdx] = ms;
}
// Check marker length
checkMarkerLength(ehs, "COM marker");
}
/// <summary> Reads a QCD marker segment and realigns the codestream at the point
/// where the next marker should be found. QCD is a functional marker
/// segment that describes the quantization default.
///
/// </summary>
/// <param name="ehs">The encoded stream.
///
/// </param>
/// <param name="mainh">Flag indicating whether or not this marker segment is read
/// from the main header.
///
/// </param>
/// <param name="tileIdx">The index of the current tile
///
/// </param>
/// <param name="tpIdx">Tile-part index
///
/// </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 readQCD(System.IO.BinaryReader ehs, bool mainh, int tileIdx, int tpIdx)
{
StdDequantizerParams qParms;
int guardBits;
int[][] exp;
float[][] nStep = null;
HeaderInfo.QCD ms = hi.NewQCD;
// Lqcd (length of QCD field)
ms.lqcd = ehs.ReadUInt16();
// Sqcd (quantization style)
ms.sqcd = ehs.ReadByte();
guardBits = ms.NumGuardBits;
int qType = ms.QuantType;
if (mainh)
{
hi.qcdValue["main"] = ms;
// If the main header is being read set default value of
// dequantization spec
switch (qType)
{
case CSJ2K.j2k.codestream.Markers.SQCX_NO_QUANTIZATION:
decSpec.qts.setDefault("reversible");
break;
case CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_DERIVED:
decSpec.qts.setDefault("derived");
break;
case CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_EXPOUNDED:
decSpec.qts.setDefault("expounded");
break;
default:
throw new CorruptedCodestreamException("Unknown or " + "unsupported " + "quantization style " + "in Sqcd field, QCD " + "marker main header");
}
}
else
{
hi.qcdValue["t" + tileIdx] = ms;
// If the tile header is being read set default value of
// dequantization spec for tile
switch (qType)
{
case CSJ2K.j2k.codestream.Markers.SQCX_NO_QUANTIZATION:
decSpec.qts.setTileDef(tileIdx, "reversible");
break;
case CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_DERIVED:
decSpec.qts.setTileDef(tileIdx, "derived");
break;
case CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_EXPOUNDED:
decSpec.qts.setTileDef(tileIdx, "expounded");
break;
default:
throw new CorruptedCodestreamException("Unknown or " + "unsupported " + "quantization style " + "in Sqcd field, QCD " + "marker, tile header");
}
}
qParms = new StdDequantizerParams();
if (qType == CSJ2K.j2k.codestream.Markers.SQCX_NO_QUANTIZATION)
{
int maxrl = (mainh?((System.Int32) decSpec.dls.getDefault()):((System.Int32) decSpec.dls.getTileDef(tileIdx)));
int j, rl; // i removed
int minb, maxb, hpd;
int tmp;
exp = qParms.exp = new int[maxrl + 1][];
int[][] tmpArray = new int[maxrl + 1][];
for (int i2 = 0; i2 < maxrl + 1; i2++)
{
tmpArray[i2] = new int[4];
}
ms.spqcd = tmpArray;
for (rl = 0; rl <= maxrl; rl++)
{
// Loop on resolution levels
// Find the number of subbands in the resolution level
if (rl == 0)
{
// Only the LL subband
minb = 0;
maxb = 1;
}
else
{
// Dyadic decomposition
hpd = 1;
// Adapt hpd to resolution level
if (hpd > maxrl - rl)
{
hpd -= (maxrl - rl);
}
else
{
hpd = 1;
}
// Determine max and min subband index
minb = 1 << ((hpd - 1) << 1); // minb = 4^(hpd-1)
maxb = 1 << (hpd << 1); // maxb = 4^hpd
}
// Allocate array for subbands in resolution level
exp[rl] = new int[maxb];
for (j = minb; j < maxb; j++)
{
tmp = ms.spqcd[rl][j] = ehs.ReadByte();
exp[rl][j] = (tmp >> CSJ2K.j2k.codestream.Markers.SQCX_EXP_SHIFT) & CSJ2K.j2k.codestream.Markers.SQCX_EXP_MASK;
}
} // end for rl
}
else
{
int maxrl = (qType == CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_DERIVED)?0:(mainh?((System.Int32) decSpec.dls.getDefault()):((System.Int32) decSpec.dls.getTileDef(tileIdx)));
int j, rl; // i removed
int minb, maxb, hpd;
int tmp;
exp = qParms.exp = new int[maxrl + 1][];
nStep = qParms.nStep = new float[maxrl + 1][];
int[][] tmpArray2 = new int[maxrl + 1][];
for (int i3 = 0; i3 < maxrl + 1; i3++)
{
tmpArray2[i3] = new int[4];
}
ms.spqcd = tmpArray2;
for (rl = 0; rl <= maxrl; rl++)
{
// Loop on resolution levels
// Find the number of subbands in the resolution level
if (rl == 0)
{
// Only the LL subband
minb = 0;
maxb = 1;
}
else
{
// Dyadic decomposition
hpd = 1;
// Adapt hpd to resolution level
if (hpd > maxrl - rl)
{
hpd -= (maxrl - rl);
}
else
{
hpd = 1;
}
// Determine max and min subband index
minb = 1 << ((hpd - 1) << 1); // minb = 4^(hpd-1)
maxb = 1 << (hpd << 1); // maxb = 4^hpd
}
// Allocate array for subbands in resolution level
exp[rl] = new int[maxb];
nStep[rl] = new float[maxb];
for (j = minb; j < maxb; j++)
{
tmp = ms.spqcd[rl][j] = ehs.ReadUInt16();
exp[rl][j] = (tmp >> 11) & 0x1f;
// NOTE: the formula below does not support more than 5
// bits for the exponent, otherwise (-1<<exp) might
// overflow (the - is used to be able to represent 2**31)
//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'"
nStep[rl][j] = (- 1f - ((float) (tmp & 0x07ff)) / (1 << 11)) / (- 1 << exp[rl][j]);
}
} // end for rl
} // end if (qType != SQCX_NO_QUANTIZATION)
// Fill qsss, gbs
if (mainh)
{
decSpec.qsss.setDefault(qParms);
decSpec.gbs.setDefault((System.Object) guardBits);
}
else
{
decSpec.qsss.setTileDef(tileIdx, qParms);
decSpec.gbs.setTileDef(tileIdx, (System.Object) guardBits);
}
// Check marker length
checkMarkerLength(ehs, "QCD marker");
}
/// <summary> Reads a QCC marker segment and realigns the codestream at the point
/// where the next marker should be found. QCC is a functional marker
/// segment that describes the quantization of one component.
///
/// </summary>
/// <param name="ehs">The encoded stream.
///
/// </param>
/// <param name="mainh">Flag indicating whether or not this marker segment is read
/// from the main header.
///
/// </param>
/// <param name="tileIdx">The index of the current tile
///
/// </param>
/// <param name="tpIdx">Tile-part index
///
/// </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 readQCC(System.IO.BinaryReader ehs, bool mainh, int tileIdx, int tpIdx)
{
int cComp; // current component
int tmp;
StdDequantizerParams qParms;
int[][] expC;
float[][] nStepC = null;
HeaderInfo.QCC ms = hi.NewQCC;
// Lqcc (length of QCC field)
ms.lqcc = ehs.ReadUInt16();
// Cqcc
if (nComp < 257)
{
cComp = ms.cqcc = ehs.ReadByte();
}
else
{
cComp = ms.cqcc = ehs.ReadUInt16();
}
if (cComp >= nComp)
{
throw new CorruptedCodestreamException("Invalid component " + "index in QCC marker");
}
// Sqcc (quantization style)
ms.sqcc = ehs.ReadByte();
int guardBits = ms.NumGuardBits;
int qType = ms.QuantType;
if (mainh)
{
hi.qccValue["main_c" + cComp] = ms;
// If main header is being read, set default for component in all
// tiles
switch (qType)
{
case CSJ2K.j2k.codestream.Markers.SQCX_NO_QUANTIZATION:
decSpec.qts.setCompDef(cComp, "reversible");
break;
case CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_DERIVED:
decSpec.qts.setCompDef(cComp, "derived");
break;
case CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_EXPOUNDED:
decSpec.qts.setCompDef(cComp, "expounded");
break;
default:
throw new CorruptedCodestreamException("Unknown or " + "unsupported " + "quantization style " + "in Sqcd field, QCD " + "marker, main header");
}
}
else
{
hi.qccValue["t" + tileIdx + "_c" + cComp] = ms;
// If tile header is being read, set value for component in
// this tiles
switch (qType)
{
case CSJ2K.j2k.codestream.Markers.SQCX_NO_QUANTIZATION:
decSpec.qts.setTileCompVal(tileIdx, cComp, "reversible");
break;
case CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_DERIVED:
decSpec.qts.setTileCompVal(tileIdx, cComp, "derived");
break;
case CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_EXPOUNDED:
decSpec.qts.setTileCompVal(tileIdx, cComp, "expounded");
break;
default:
throw new CorruptedCodestreamException("Unknown or " + "unsupported " + "quantization style " + "in Sqcd field, QCD " + "marker, main header");
}
}
// Decode all dequantizer params
qParms = new StdDequantizerParams();
if (qType == CSJ2K.j2k.codestream.Markers.SQCX_NO_QUANTIZATION)
{
int maxrl = (mainh?((System.Int32) decSpec.dls.getCompDef(cComp)):((System.Int32) decSpec.dls.getTileCompVal(tileIdx, cComp)));
int j, rl; // i removed
int minb, maxb, hpd;
expC = qParms.exp = new int[maxrl + 1][];
int[][] tmpArray = new int[maxrl + 1][];
for (int i2 = 0; i2 < maxrl + 1; i2++)
{
tmpArray[i2] = new int[4];
}
ms.spqcc = tmpArray;
for (rl = 0; rl <= maxrl; rl++)
{
// Loop on resolution levels
// Find the number of subbands in the resolution level
if (rl == 0)
{
// Only the LL subband
minb = 0;
maxb = 1;
}
else
{
// Dyadic decomposition
hpd = 1;
// Adapt hpd to resolution level
if (hpd > maxrl - rl)
{
hpd -= (maxrl - rl);
}
else
{
hpd = 1;
}
// Determine max and min subband index
minb = 1 << ((hpd - 1) << 1); // minb = 4^(hpd-1)
maxb = 1 << (hpd << 1); // maxb = 4^hpd
}
// Allocate array for subbands in resolution level
expC[rl] = new int[maxb];
for (j = minb; j < maxb; j++)
{
tmp = ms.spqcc[rl][j] = ehs.ReadByte();
expC[rl][j] = (tmp >> CSJ2K.j2k.codestream.Markers.SQCX_EXP_SHIFT) & CSJ2K.j2k.codestream.Markers.SQCX_EXP_MASK;
}
} // end for rl
}
else
{
int maxrl = (qType == CSJ2K.j2k.codestream.Markers.SQCX_SCALAR_DERIVED)?0:(mainh?((System.Int32) decSpec.dls.getCompDef(cComp)):((System.Int32) decSpec.dls.getTileCompVal(tileIdx, cComp)));
int j, rl; // i removed
int minb, maxb, hpd;
nStepC = qParms.nStep = new float[maxrl + 1][];
expC = qParms.exp = new int[maxrl + 1][];
int[][] tmpArray2 = new int[maxrl + 1][];
for (int i3 = 0; i3 < maxrl + 1; i3++)
{
tmpArray2[i3] = new int[4];
}
ms.spqcc = tmpArray2;
for (rl = 0; rl <= maxrl; rl++)
{
// Loop on resolution levels
// Find the number of subbands in the resolution level
if (rl == 0)
{
// Only the LL subband
minb = 0;
maxb = 1;
}
else
{
// Dyadic decomposition
hpd = 1;
// Adapt hpd to resolution level
if (hpd > maxrl - rl)
{
hpd -= (maxrl - rl);
}
else
{
hpd = 1;
}
// Determine max and min subband index
minb = 1 << ((hpd - 1) << 1); // minb = 4^(hpd-1)
maxb = 1 << (hpd << 1); // maxb = 4^hpd
}
// Allocate array for subbands in resolution level
expC[rl] = new int[maxb];
nStepC[rl] = new float[maxb];
for (j = minb; j < maxb; j++)
{
tmp = ms.spqcc[rl][j] = ehs.ReadUInt16();
expC[rl][j] = (tmp >> 11) & 0x1f;
// NOTE: the formula below does not support more than 5
// bits for the exponent, otherwise (-1<<exp) might
// overflow (the - is used to be able to represent 2**31)
//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'"
nStepC[rl][j] = (- 1f - ((float) (tmp & 0x07ff)) / (1 << 11)) / (- 1 << expC[rl][j]);
}
} // end for rl
} // end if (qType != SQCX_NO_QUANTIZATION)
// Fill qsss, gbs
if (mainh)
{
decSpec.qsss.setCompDef(cComp, qParms);
decSpec.gbs.setCompDef(cComp, (System.Object) guardBits);
}
else
{
decSpec.qsss.setTileCompVal(tileIdx, cComp, qParms);
decSpec.gbs.setTileCompVal(tileIdx, cComp, (System.Object) guardBits);
}
// Check marker length
checkMarkerLength(ehs, "QCC marker");
}
/// <summary> Reads a COD marker segment and realigns the codestream where the next
/// marker should be found.
///
/// </summary>
/// <param name="ehs">The encoder header stream.
///
/// </param>
/// <param name="mainh">Flag indicating whether or not this marker segment is read
/// from the main header.
///
/// </param>
/// <param name="tileIdx">The index of the current tile
///
/// </param>
/// <param name="tpIdx">Tile-part index
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder 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 readCOD(System.IO.BinaryReader ehs, bool mainh, int tileIdx, int tpIdx)
{
int cstyle; // The block style
SynWTFilter[] hfilters, vfilters;
//int l;
System.Int32[] cblk;
System.String errMsg;
//bool sopUsed = false;
//bool ephUsed = false;
HeaderInfo.COD ms = hi.NewCOD;
// Lcod (marker length)
ms.lcod = ehs.ReadUInt16();
// Scod (block style)
// We only support wavelet transformed data
cstyle = ms.scod = ehs.ReadByte();
if ((cstyle & CSJ2K.j2k.codestream.Markers.SCOX_PRECINCT_PARTITION) != 0)
{
precinctPartitionIsUsed = true;
// Remove flag
cstyle &= ~ (CSJ2K.j2k.codestream.Markers.SCOX_PRECINCT_PARTITION);
}
else
{
precinctPartitionIsUsed = false;
}
// SOP markers
if (mainh)
{
hi.codValue["main"] = ms;
if ((cstyle & CSJ2K.j2k.codestream.Markers.SCOX_USE_SOP) != 0)
{
// SOP markers are used
decSpec.sops.setDefault((System.Object) "true".ToUpper().Equals("TRUE"));
//sopUsed = true;
// Remove flag
cstyle &= ~ (CSJ2K.j2k.codestream.Markers.SCOX_USE_SOP);
}
else
{
// SOP markers are not used
decSpec.sops.setDefault((System.Object) "false".ToUpper().Equals("TRUE"));
}
}
else
{
hi.codValue["t" + tileIdx] = ms;
if ((cstyle & CSJ2K.j2k.codestream.Markers.SCOX_USE_SOP) != 0)
{
// SOP markers are used
decSpec.sops.setTileDef(tileIdx, (System.Object) "true".ToUpper().Equals("TRUE"));
//sopUsed = true;
// Remove flag
cstyle &= ~ (CSJ2K.j2k.codestream.Markers.SCOX_USE_SOP);
}
else
{
// SOP markers are not used
decSpec.sops.setTileDef(tileIdx, (System.Object) "false".ToUpper().Equals("TRUE"));
}
}
// EPH markers
if (mainh)
{
if ((cstyle & CSJ2K.j2k.codestream.Markers.SCOX_USE_EPH) != 0)
{
// EPH markers are used
decSpec.ephs.setDefault((System.Object) "true".ToUpper().Equals("TRUE"));
//ephUsed = true;
// Remove flag
cstyle &= ~ (CSJ2K.j2k.codestream.Markers.SCOX_USE_EPH);
}
else
{
// EPH markers are not used
decSpec.ephs.setDefault((System.Object) "false".ToUpper().Equals("TRUE"));
}
}
else
{
if ((cstyle & CSJ2K.j2k.codestream.Markers.SCOX_USE_EPH) != 0)
{
// EPH markers are used
decSpec.ephs.setTileDef(tileIdx, (System.Object) "true".ToUpper().Equals("TRUE"));
//ephUsed = true;
// Remove flag
cstyle &= ~ (CSJ2K.j2k.codestream.Markers.SCOX_USE_EPH);
}
else
{
// EPH markers are not used
decSpec.ephs.setTileDef(tileIdx, (System.Object) "false".ToUpper().Equals("TRUE"));
}
}
// Code-block partition origin
if ((cstyle & (CSJ2K.j2k.codestream.Markers.SCOX_HOR_CB_PART | CSJ2K.j2k.codestream.Markers.SCOX_VER_CB_PART)) != 0)
{
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Code-block partition origin " + "different from (0,0). This is defined in JPEG 2000" + " part 2 and may not be supported by all JPEG " + "2000 decoders.");
}
if ((cstyle & CSJ2K.j2k.codestream.Markers.SCOX_HOR_CB_PART) != 0)
{
if (cb0x != - 1 && cb0x == 0)
{
throw new System.ArgumentException("Code-block partition " + "origin redefined in new" + " COD marker segment. Not" + " supported by JJ2000");
}
cb0x = 1;
cstyle &= ~ (CSJ2K.j2k.codestream.Markers.SCOX_HOR_CB_PART);
}
else
{
if (cb0x != - 1 && cb0x == 1)
{
throw new System.ArgumentException("Code-block partition " + "origin redefined in new" + " COD marker segment. Not" + " supported by JJ2000");
}
cb0x = 0;
}
if ((cstyle & CSJ2K.j2k.codestream.Markers.SCOX_VER_CB_PART) != 0)
{
if (cb0y != - 1 && cb0y == 0)
{
throw new System.ArgumentException("Code-block partition " + "origin redefined in new" + " COD marker segment. Not" + " supported by JJ2000");
}
cb0y = 1;
cstyle &= ~ (CSJ2K.j2k.codestream.Markers.SCOX_VER_CB_PART);
}
else
{
if (cb0y != - 1 && cb0y == 1)
{
throw new System.ArgumentException("Code-block partition " + "origin redefined in new" + " COD marker segment. Not" + " supported by JJ2000");
}
cb0y = 0;
}
// SGcod
// Read the progressive order
ms.sgcod_po = ehs.ReadByte();
// Read the number of layers
ms.sgcod_nl = ehs.ReadUInt16();
if (ms.sgcod_nl <= 0 || ms.sgcod_nl > 65535)
{
throw new CorruptedCodestreamException("Number of layers out of " + "range: 1--65535");
}
// Multiple component transform
ms.sgcod_mct = ehs.ReadByte();
// SPcod
// decomposition levels
int mrl = ms.spcod_ndl = ehs.ReadByte();
if (mrl > 32)
{
throw new CorruptedCodestreamException("Number of decomposition " + "levels out of range: " + "0--32");
}
// Read the code-blocks dimensions
cblk = new System.Int32[2];
ms.spcod_cw = ehs.ReadByte();
cblk[0] = (System.Int32) (1 << (ms.spcod_cw + 2));
if (cblk[0] < CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM || cblk[0] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM)
{
errMsg = "Non-valid code-block width in SPcod field, " + "COD marker";
throw new CorruptedCodestreamException(errMsg);
}
ms.spcod_ch = ehs.ReadByte();
cblk[1] = (System.Int32) (1 << (ms.spcod_ch + 2));
if (cblk[1] < CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM || cblk[1] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM)
{
errMsg = "Non-valid code-block height in SPcod field, " + "COD marker";
throw new CorruptedCodestreamException(errMsg);
}
if ((cblk[0] * cblk[1]) > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_AREA)
{
errMsg = "Non-valid code-block area in SPcod field, " + "COD marker";
throw new CorruptedCodestreamException(errMsg);
}
if (mainh)
{
decSpec.cblks.setDefault((System.Object) (cblk));
}
else
{
decSpec.cblks.setTileDef(tileIdx, (System.Object) (cblk));
}
// Style of the code-block coding passes
int ecOptions = ms.spcod_cs = ehs.ReadByte();
if ((ecOptions & ~ (CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_BYPASS | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_RESET_MQ | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_VERT_STR_CAUSAL | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_PRED_TERM | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_SEG_SYMBOLS)) != 0)
{
throw new CorruptedCodestreamException("Unknown \"code-block " + "style\" in SPcod field, " + "COD marker: 0x" + System.Convert.ToString(ecOptions, 16));
}
// Read wavelet filter for tile or image
hfilters = new SynWTFilter[1];
vfilters = new SynWTFilter[1];
hfilters[0] = readFilter(ehs, ms.spcod_t);
vfilters[0] = hfilters[0];
// Fill the filter spec
// If this is the main header, set the default value, if it is the
// tile header, set default for this tile
SynWTFilter[][] hvfilters = new SynWTFilter[2][];
hvfilters[0] = hfilters;
hvfilters[1] = vfilters;
// Get precinct partition sizes
System.Collections.ArrayList[] v = new System.Collections.ArrayList[2];
v[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
v[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
int val = CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE;
if (!precinctPartitionIsUsed)
{
System.Int32 w, h;
w = (System.Int32) (1 << (val & 0x000F));
v[0].Add(w);
h = (System.Int32) (1 << (((val & 0x00F0) >> 4)));
v[1].Add(h);
}
else
{
ms.spcod_ps = new int[mrl + 1];
for (int rl = mrl; rl >= 0; rl--)
{
System.Int32 w, h;
val = ms.spcod_ps[mrl - rl] = ehs.ReadByte();
w = (System.Int32) (1 << (val & 0x000F));
v[0].Insert(0, w);
h = (System.Int32) (1 << (((val & 0x00F0) >> 4)));
v[1].Insert(0, h);
}
}
if (mainh)
{
decSpec.pss.setDefault(v);
}
else
{
decSpec.pss.setTileDef(tileIdx, v);
}
precinctPartitionIsUsed = true;
// Check marker length
checkMarkerLength(ehs, "COD marker");
// Store specifications in decSpec
if (mainh)
{
decSpec.wfs.setDefault(hvfilters);
decSpec.dls.setDefault((System.Object) mrl);
decSpec.ecopts.setDefault((System.Object) ecOptions);
decSpec.cts.setDefault((System.Object) ms.sgcod_mct);
decSpec.nls.setDefault((System.Object) ms.sgcod_nl);
decSpec.pos.setDefault((System.Object) ms.sgcod_po);
}
else
{
decSpec.wfs.setTileDef(tileIdx, hvfilters);
decSpec.dls.setTileDef(tileIdx, (System.Object) mrl);
decSpec.ecopts.setTileDef(tileIdx, (System.Object) ecOptions);
decSpec.cts.setTileDef(tileIdx, (System.Object) ms.sgcod_mct);
decSpec.nls.setTileDef(tileIdx, (System.Object) ms.sgcod_nl);
decSpec.pos.setTileDef(tileIdx, (System.Object) ms.sgcod_po);
}
}
/// <summary> Reads the COC marker segment and realigns the codestream where the next
/// marker should be found.
///
/// </summary>
/// <param name="ehs">The encoder header stream.
///
/// </param>
/// <param name="mainh">Flag indicating whether or not this marker segment is read
/// from the main header.
///
/// </param>
/// <param name="tileIdx">The index of the current tile
///
/// </param>
/// <param name="tpIdx">Tile-part index
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder 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 readCOC(System.IO.BinaryReader ehs, bool mainh, int tileIdx, int tpIdx)
{
int cComp; // current component
SynWTFilter[] hfilters, vfilters;
//int tmp, l;
int ecOptions;
System.Int32[] cblk;
System.String errMsg;
HeaderInfo.COC ms = hi.NewCOC;
// Lcoc (marker length)
ms.lcoc = ehs.ReadUInt16();
// Ccoc
if (nComp < 257)
{
cComp = ms.ccoc = ehs.ReadByte();
}
else
{
cComp = ms.ccoc = ehs.ReadUInt16();
}
if (cComp >= nComp)
{
throw new CorruptedCodestreamException("Invalid component index " + "in QCC marker");
}
// Scoc (block style)
int cstyle = ms.scoc = ehs.ReadByte();
if ((cstyle & CSJ2K.j2k.codestream.Markers.SCOX_PRECINCT_PARTITION) != 0)
{
precinctPartitionIsUsed = true;
// Remove flag
cstyle &= ~ (CSJ2K.j2k.codestream.Markers.SCOX_PRECINCT_PARTITION);
}
else
{
precinctPartitionIsUsed = false;
}
// SPcoc
// decomposition levels
int mrl = ms.spcoc_ndl = ehs.ReadByte();
// Read the code-blocks dimensions
cblk = new System.Int32[2];
ms.spcoc_cw = ehs.ReadByte();
cblk[0] = (System.Int32) (1 << (ms.spcoc_cw + 2));
if (cblk[0] < CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM || cblk[0] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM)
{
errMsg = "Non-valid code-block width in SPcod field, " + "COC marker";
throw new CorruptedCodestreamException(errMsg);
}
ms.spcoc_ch = ehs.ReadByte();
cblk[1] = (System.Int32) (1 << (ms.spcoc_ch + 2));
if (cblk[1] < CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM || cblk[1] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM)
{
errMsg = "Non-valid code-block height in SPcod field, " + "COC marker";
throw new CorruptedCodestreamException(errMsg);
}
if ((cblk[0] * cblk[1]) > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_AREA)
{
errMsg = "Non-valid code-block area in SPcod field, " + "COC marker";
throw new CorruptedCodestreamException(errMsg);
}
if (mainh)
{
decSpec.cblks.setCompDef(cComp, (System.Object) (cblk));
}
else
{
decSpec.cblks.setTileCompVal(tileIdx, cComp, (System.Object) (cblk));
}
// Read entropy block mode options
// NOTE: currently OPT_SEG_SYMBOLS is not included here
ecOptions = ms.spcoc_cs = ehs.ReadByte();
if ((ecOptions & ~ (CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_BYPASS | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_RESET_MQ | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_VERT_STR_CAUSAL | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_PRED_TERM | CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_SEG_SYMBOLS)) != 0)
{
throw new CorruptedCodestreamException("Unknown \"code-block " + "context\" in SPcoc field, " + "COC marker: 0x" + System.Convert.ToString(ecOptions, 16));
}
// Read wavelet filter for tile or image
hfilters = new SynWTFilter[1];
vfilters = new SynWTFilter[1];
hfilters[0] = readFilter(ehs, ms.spcoc_t);
vfilters[0] = hfilters[0];
// Fill the filter spec
// If this is the main header, set the default value, if it is the
// tile header, set default for this tile
SynWTFilter[][] hvfilters = new SynWTFilter[2][];
hvfilters[0] = hfilters;
hvfilters[1] = vfilters;
// Get precinct partition sizes
System.Collections.ArrayList[] v = new System.Collections.ArrayList[2];
v[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
v[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
int val = CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE;
if (!precinctPartitionIsUsed)
{
System.Int32 w, h;
w = (System.Int32) (1 << (val & 0x000F));
v[0].Add(w);
h = (System.Int32) (1 << (((val & 0x00F0) >> 4)));
v[1].Add(h);
}
else
{
ms.spcoc_ps = new int[mrl + 1];
for (int rl = mrl; rl >= 0; rl--)
{
System.Int32 w, h;
val = ms.spcoc_ps[rl] = ehs.ReadByte();
w = (System.Int32) (1 << (val & 0x000F));
v[0].Insert(0, w);
h = (System.Int32) (1 << (((val & 0x00F0) >> 4)));
v[1].Insert(0, h);
}
}
if (mainh)
{
decSpec.pss.setCompDef(cComp, v);
}
else
{
decSpec.pss.setTileCompVal(tileIdx, cComp, v);
}
precinctPartitionIsUsed = true;
// Check marker length
checkMarkerLength(ehs, "COD marker");
if (mainh)
{
hi.cocValue["main_c" + cComp] = ms;
decSpec.wfs.setCompDef(cComp, hvfilters);
decSpec.dls.setCompDef(cComp, (System.Object) mrl);
decSpec.ecopts.setCompDef(cComp, (System.Object) ecOptions);
}
else
{
hi.cocValue["t" + tileIdx + "_c" + cComp] = ms;
decSpec.wfs.setTileCompVal(tileIdx, cComp, hvfilters);
decSpec.dls.setTileCompVal(tileIdx, cComp, (System.Object) mrl);
decSpec.ecopts.setTileCompVal(tileIdx, cComp, (System.Object) ecOptions);
}
}
/// <summary> Reads the POC marker segment and realigns the codestream where the next
/// marker should be found.
///
/// </summary>
/// <param name="ehs">The encoder header stream.
///
/// </param>
/// <param name="mainh">Flag indicating whether or not this marker segment is read
/// from the main header.
///
/// </param>
/// <param name="t">The index of the current tile
///
/// </param>
/// <param name="tpIdx">Tile-part index
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder 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 readPOC(System.IO.BinaryReader ehs, bool mainh, int t, int tpIdx)
{
bool useShort = (nComp >= 256)?true:false;
int tmp;
int nOldChg = 0;
HeaderInfo.POC ms;
if (mainh || hi.pocValue["t" + t] == null)
{
ms = hi.NewPOC;
}
else
{
ms = (HeaderInfo.POC) hi.pocValue["t" + t];
nOldChg = ms.rspoc.Length;
}
// Lpoc
ms.lpoc = ehs.ReadUInt16();
// Compute the number of new progression changes
// newChg = (lpoc - Lpoc(2)) / (RSpoc(1) + CSpoc(2) +
// LYEpoc(2) + REpoc(1) + CEpoc(2) + Ppoc (1) )
int newChg = (ms.lpoc - 2) / (5 + (useShort?4:2));
int ntotChg = nOldChg + newChg;
int[][] change;
if (nOldChg != 0)
{
// Creates new arrays
int[][] tmpArray = new int[ntotChg][];
for (int i = 0; i < ntotChg; i++)
{
tmpArray[i] = new int[6];
}
change = tmpArray;
int[] tmprspoc = new int[ntotChg];
int[] tmpcspoc = new int[ntotChg];
int[] tmplyepoc = new int[ntotChg];
int[] tmprepoc = new int[ntotChg];
int[] tmpcepoc = new int[ntotChg];
int[] tmpppoc = new int[ntotChg];
// Copy old values
int[][] prevChg = (int[][]) decSpec.pcs.getTileDef(t);
for (int chg = 0; chg < nOldChg; chg++)
{
change[chg] = prevChg[chg];
tmprspoc[chg] = ms.rspoc[chg];
tmpcspoc[chg] = ms.cspoc[chg];
tmplyepoc[chg] = ms.lyepoc[chg];
tmprepoc[chg] = ms.repoc[chg];
tmpcepoc[chg] = ms.cepoc[chg];
tmpppoc[chg] = ms.ppoc[chg];
}
ms.rspoc = tmprspoc;
ms.cspoc = tmpcspoc;
ms.lyepoc = tmplyepoc;
ms.repoc = tmprepoc;
ms.cepoc = tmpcepoc;
ms.ppoc = tmpppoc;
}
else
{
int[][] tmpArray2 = new int[newChg][];
for (int i2 = 0; i2 < newChg; i2++)
{
tmpArray2[i2] = new int[6];
}
change = tmpArray2;
ms.rspoc = new int[newChg];
ms.cspoc = new int[newChg];
ms.lyepoc = new int[newChg];
ms.repoc = new int[newChg];
ms.cepoc = new int[newChg];
ms.ppoc = new int[newChg];
}
for (int chg = nOldChg; chg < ntotChg; chg++)
{
// RSpoc
change[chg][0] = ms.rspoc[chg] = ehs.ReadByte();
// CSpoc
if (useShort)
{
change[chg][1] = ms.cspoc[chg] = ehs.ReadUInt16();
}
else
{
change[chg][1] = ms.cspoc[chg] = ehs.ReadByte();
}
// LYEpoc
change[chg][2] = ms.lyepoc[chg] = ehs.ReadUInt16();
if (change[chg][2] < 1)
{
throw new CorruptedCodestreamException("LYEpoc value must be greater than 1 in POC marker " + "segment of tile " + t + ", tile-part " + tpIdx);
}
// REpoc
change[chg][3] = ms.repoc[chg] = ehs.ReadByte();
if (change[chg][3] <= change[chg][0])
{
throw new CorruptedCodestreamException("REpoc value must be greater than RSpoc in POC marker " + "segment of tile " + t + ", tile-part " + tpIdx);
}
// CEpoc
if (useShort)
{
change[chg][4] = ms.cepoc[chg] = ehs.ReadUInt16();
}
else
{
tmp = ms.cepoc[chg] = ehs.ReadByte();
if (tmp == 0)
{
change[chg][4] = 0;
}
else
{
change[chg][4] = tmp;
}
}
if (change[chg][4] <= change[chg][1])
{
throw new CorruptedCodestreamException("CEpoc value must be greater than CSpoc in POC marker " + "segment of tile " + t + ", tile-part " + tpIdx);
}
// Ppoc
change[chg][5] = ms.ppoc[chg] = ehs.ReadByte();
}
// Check marker length
checkMarkerLength(ehs, "POC marker");
// Register specifications
if (mainh)
{
hi.pocValue["main"] = ms;
decSpec.pcs.setDefault(change);
}
else
{
hi.pocValue["t" + t] = ms;
decSpec.pcs.setTileDef(t, change);
}
}
/// <summary> Reads TLM marker segment and realigns the codestream where the next
/// marker should be found. Informations stored in these fields are
/// currently NOT taken into account.
///
/// </summary>
/// <param name="ehs">The encoder header stream.
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder 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 readTLM(System.IO.BinaryReader ehs)
{
int length;
length = ehs.ReadUInt16();
//Ignore all informations contained
System.IO.BinaryReader temp_BinaryReader;
System.Int64 temp_Int64;
temp_BinaryReader = ehs;
temp_Int64 = temp_BinaryReader.BaseStream.Position;
temp_Int64 = temp_BinaryReader.BaseStream.Seek(length - 2, System.IO.SeekOrigin.Current) - temp_Int64;
// CONVERSION PROBLEM?
int generatedAux = (int)temp_Int64;
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.INFO, "Skipping unsupported TLM marker");
}
/// <summary> Reads PLM marker segment and realigns the codestream where the next
/// marker should be found. Informations stored in these fields are
/// currently not taken into account.
///
/// </summary>
/// <param name="ehs">The encoder header stream.
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder 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 readPLM(System.IO.BinaryReader ehs)
{
int length;
length = ehs.ReadUInt16();
//Ignore all informations contained
System.IO.BinaryReader temp_BinaryReader;
System.Int64 temp_Int64;
temp_BinaryReader = ehs;
temp_Int64 = temp_BinaryReader.BaseStream.Position;
temp_Int64 = temp_BinaryReader.BaseStream.Seek(length - 2, System.IO.SeekOrigin.Current) - temp_Int64;
// CONVERSION PROBLEM?
int generatedAux = (int)temp_Int64;
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.INFO, "Skipping unsupported PLM marker");
}
/// <summary> Reads the PLT fields and realigns the codestream where the next marker
/// should be found. Informations stored in these fields are currently NOT
/// taken into account.
///
/// </summary>
/// <param name="ehs">The encoder header stream.
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder 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 readPLTFields(System.IO.BinaryReader ehs)
{
int length;
length = ehs.ReadUInt16();
//Ignore all informations contained
System.IO.BinaryReader temp_BinaryReader;
System.Int64 temp_Int64;
temp_BinaryReader = ehs;
temp_Int64 = temp_BinaryReader.BaseStream.Position;
temp_Int64 = temp_BinaryReader.BaseStream.Seek(length - 2, System.IO.SeekOrigin.Current) - temp_Int64;
// CONVERSION PROBLEM?
int generatedAux = (int)temp_Int64;
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.INFO, "Skipping unsupported PLT marker");
}
/// <summary> Reads the RGN marker segment of the codestream header.
///
/// <p>May be used in tile or main header. If used in main header, it
/// refers to the maxshift value of a component in all tiles. When used in
/// tile header, only the particular tile-component is affected.</p>
///
/// </summary>
/// <param name="ehs">The encoder header stream.
///
/// </param>
/// <param name="mainh">Flag indicating whether or not this marker segment is read
/// from the main header.
///
/// </param>
/// <param name="tileIdx">The index of the current tile
///
/// </param>
/// <param name="tpIdx">Tile-part index
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder 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 readRGN(System.IO.BinaryReader ehs, bool mainh, int tileIdx, int tpIdx)
{
int comp; // ROI component
//int i; // loop variable
//int tempComp; // Component for
HeaderInfo.RGN ms = hi.NewRGN;
// Lrgn (marker length)
ms.lrgn = ehs.ReadUInt16();
// Read component
ms.crgn = comp = (nComp < 257)?ehs.ReadByte():ehs.ReadUInt16();
if (comp >= nComp)
{
throw new CorruptedCodestreamException("Invalid component " + "index in RGN marker" + comp);
}
// Read type of RGN.(Srgn)
ms.srgn = ehs.ReadByte();
// Check that we can handle it.
if (ms.srgn != CSJ2K.j2k.codestream.Markers.SRGN_IMPLICIT)
throw new CorruptedCodestreamException("Unknown or unsupported " + "Srgn parameter in ROI " + "marker");
if (decSpec.rois == null)
{
// No maxshift spec defined
// Create needed ModuleSpec
decSpec.rois = new MaxShiftSpec(nTiles, nComp, ModuleSpec.SPEC_TYPE_TILE_COMP);
}
// SPrgn
ms.sprgn = ehs.ReadByte();
if (mainh)
{
hi.rgnValue["main_c" + comp] = ms;
decSpec.rois.setCompDef(comp, (System.Object) ms.sprgn);
}
else
{
hi.rgnValue["t" + tileIdx + "_c" + comp] = ms;
decSpec.rois.setTileCompVal(tileIdx, comp, (System.Object) ms.sprgn);
}
// Check marker length
checkMarkerLength(ehs, "RGN marker");
}
/// <summary> Reads the PPM marker segment of the main header.
///
/// </summary>
/// <param name="ehs">The encoder header stream.
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder 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 readPPM(System.IO.BinaryReader ehs)
{
int curMarkSegLen;
int indx; // i, len, off removed
int remSegLen;
//byte[] b;
// If first time readPPM method is called allocate arrays for packed
// packet data
if (pPMMarkerData == null)
{
pPMMarkerData = new byte[nPPMMarkSeg][];
tileOfTileParts = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
decSpec.pphs.setDefault((System.Object) true);
}
// Lppm (marker length)
curMarkSegLen = ehs.ReadUInt16();
remSegLen = curMarkSegLen - 3;
// Zppm (index of PPM marker)
indx = ehs.ReadByte();
// Read Nppm and Ippm data
pPMMarkerData[indx] = new byte[remSegLen];
ehs.BaseStream.Read(pPMMarkerData[indx], 0, remSegLen); //SupportClass.ReadInput(ehs.BaseStream, pPMMarkerData[indx], 0, remSegLen);
// Check marker length
checkMarkerLength(ehs, "PPM marker");
}
/// <summary> Reads the PPT marker segment of the main header.
///
/// </summary>
/// <param name="ehs">The encoder header stream.
///
/// </param>
/// <param name="tile">The tile to which the current tile part belongs
///
/// </param>
/// <param name="tpIdx">Tile-part index
///
/// </param>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder 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 readPPT(System.IO.BinaryReader ehs, int tile, int tpIdx)
{
int curMarkSegLen;
int indx; // len = 0; removed
byte[] temp;
if (tilePartPkdPktHeaders == null)
{
tilePartPkdPktHeaders = new byte[nTiles][][][];
}
if (tilePartPkdPktHeaders[tile] == null)
{
tilePartPkdPktHeaders[tile] = new byte[nTileParts[tile]][][];
}
if (tilePartPkdPktHeaders[tile][tpIdx] == null)
{
tilePartPkdPktHeaders[tile][tpIdx] = new byte[nPPTMarkSeg[tile][tpIdx]][];
}
// Lppt (marker length)
curMarkSegLen = ehs.ReadUInt16();
// Zppt (index of PPT marker)
indx = ehs.ReadByte();
// Ippt (packed packet headers)
temp = new byte[curMarkSegLen - 3];
ehs.BaseStream.Read(temp, 0, temp.Length); //SupportClass.ReadInput(ehs.BaseStream, temp, 0, temp.Length);
tilePartPkdPktHeaders[tile][tpIdx][indx] = temp;
// Check marker length
checkMarkerLength(ehs, "PPT marker");
decSpec.pphs.setTileDef(tile, (System.Object) true);
}
/// <summary> This method extract a marker segment from the main header and stores it
/// into a byte buffer for the second pass. The marker segment is first
/// identified. Then its flag is activated. Finally, its content is
/// buffered into a byte array stored in an hashTable.
///
/// <p>If the marker is not recognized, it prints a warning and skips it
/// according to its length.</p>
///
/// <p>SIZ marker segment shall be the first encountered marker segment.</p>
///
/// </summary>
/// <param name="marker">The marker segment to process
///
/// </param>
/// <param name="ehs">The encoded header stream
///
/// </param>
private void extractMainMarkSeg(short marker, RandomAccessIO ehs)
{
if (nfMarkSeg == 0)
{
// First non-delimiting marker of the header
// JPEG 2000 part 1 specify that it must be SIZ
if (marker != CSJ2K.j2k.codestream.Markers.SIZ)
{
throw new CorruptedCodestreamException("First marker after " + "SOC " + "must be SIZ " + System.Convert.ToString(marker, 16));
}
}
System.String htKey = ""; // Name used as a key for the hash-table
if (ht == null)
{
ht = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
}
switch (marker)
{
case CSJ2K.j2k.codestream.Markers.SIZ:
if ((nfMarkSeg & SIZ_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one SIZ marker " + "segment found in main " + "header");
}
nfMarkSeg |= SIZ_FOUND;
htKey = "SIZ";
break;
case CSJ2K.j2k.codestream.Markers.SOD:
throw new CorruptedCodestreamException("SOD found in main header");
case CSJ2K.j2k.codestream.Markers.EOC:
throw new CorruptedCodestreamException("EOC found in main header");
case CSJ2K.j2k.codestream.Markers.SOT:
if ((nfMarkSeg & SOT_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one SOT " + "marker " + "found right after " + "main " + "or tile header");
}
nfMarkSeg |= SOT_FOUND;
return ;
case CSJ2K.j2k.codestream.Markers.COD:
if ((nfMarkSeg & COD_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one COD " + "marker " + "found in main header");
}
nfMarkSeg |= COD_FOUND;
htKey = "COD";
break;
case CSJ2K.j2k.codestream.Markers.COC:
nfMarkSeg |= COC_FOUND;
htKey = "COC" + (nCOCMarkSeg++);
break;
case CSJ2K.j2k.codestream.Markers.QCD:
if ((nfMarkSeg & QCD_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one QCD " + "marker " + "found in main header");
}
nfMarkSeg |= QCD_FOUND;
htKey = "QCD";
break;
case CSJ2K.j2k.codestream.Markers.QCC:
nfMarkSeg |= QCC_FOUND;
htKey = "QCC" + (nQCCMarkSeg++);
break;
case CSJ2K.j2k.codestream.Markers.RGN:
nfMarkSeg |= RGN_FOUND;
htKey = "RGN" + (nRGNMarkSeg++);
break;
case CSJ2K.j2k.codestream.Markers.COM:
nfMarkSeg |= COM_FOUND;
htKey = "COM" + (nCOMMarkSeg++);
break;
case CSJ2K.j2k.codestream.Markers.CRG:
if ((nfMarkSeg & CRG_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one CRG " + "marker " + "found in main header");
}
nfMarkSeg |= CRG_FOUND;
htKey = "CRG";
break;
case CSJ2K.j2k.codestream.Markers.PPM:
nfMarkSeg |= PPM_FOUND;
htKey = "PPM" + (nPPMMarkSeg++);
break;
case CSJ2K.j2k.codestream.Markers.TLM:
if ((nfMarkSeg & TLM_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one TLM " + "marker " + "found in main header");
}
nfMarkSeg |= TLM_FOUND;
break;
case CSJ2K.j2k.codestream.Markers.PLM:
if ((nfMarkSeg & PLM_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one PLM " + "marker " + "found in main header");
}
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "PLM marker segment found but " + "not used by by JJ2000 decoder.");
nfMarkSeg |= PLM_FOUND;
htKey = "PLM";
break;
case CSJ2K.j2k.codestream.Markers.POC:
if ((nfMarkSeg & POC_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one POC " + "marker segment found " + "in main header");
}
nfMarkSeg |= POC_FOUND;
htKey = "POC";
break;
case CSJ2K.j2k.codestream.Markers.PLT:
throw new CorruptedCodestreamException("PLT found in main header");
case CSJ2K.j2k.codestream.Markers.PPT:
throw new CorruptedCodestreamException("PPT found in main header");
default:
htKey = "UNKNOWN";
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Non recognized marker segment (0x" + System.Convert.ToString(marker, 16) + ") in main header!");
break;
}
if (marker < unchecked((short)0xffffff30) || marker > unchecked((short)0xffffff3f))
{
// Read marker segment length and create corresponding byte buffer
int markSegLen = ehs.readUnsignedShort();
byte[] buf = new byte[markSegLen];
// Copy data (after re-insertion of the marker segment length);
buf[0] = (byte) ((markSegLen >> 8) & 0xFF);
buf[1] = (byte) (markSegLen & 0xFF);
ehs.readFully(buf, 2, markSegLen - 2);
if (!htKey.Equals("UNKNOWN"))
{
// Store array in hashTable
ht[htKey] = buf;
}
}
}
/// <summary> This method extracts a marker segment in a tile-part header and stores
/// it into a byte buffer for the second pass. The marker is first
/// recognized, then its flag is activated and, finally, its content is
/// buffered in an element of byte arrays accessible thanks to a hashTable.
/// If a marker segment is not recognized, it prints a warning and skip it
/// according to its length.
///
/// </summary>
/// <param name="marker">The marker to process
///
/// </param>
/// <param name="ehs">The encoded header stream
///
/// </param>
/// <param name="tileIdx">The index of the current tile
///
/// </param>
/// <param name="tilePartIdx">The index of the current tile part
///
/// </param>
public virtual void extractTilePartMarkSeg(short marker, RandomAccessIO ehs, int tileIdx, int tilePartIdx)
{
System.String htKey = ""; // Name used as a hash-table key
if (ht == null)
{
ht = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
}
switch (marker)
{
case CSJ2K.j2k.codestream.Markers.SOT:
throw new CorruptedCodestreamException("Second SOT marker " + "segment found in tile-" + "part header");
case CSJ2K.j2k.codestream.Markers.SIZ:
throw new CorruptedCodestreamException("SIZ found in tile-part" + " header");
case CSJ2K.j2k.codestream.Markers.EOC:
throw new CorruptedCodestreamException("EOC found in tile-part" + " header");
case CSJ2K.j2k.codestream.Markers.TLM:
throw new CorruptedCodestreamException("TLM found in tile-part" + " header");
case CSJ2K.j2k.codestream.Markers.PLM:
throw new CorruptedCodestreamException("PLM found in tile-part" + " header");
case CSJ2K.j2k.codestream.Markers.PPM:
throw new CorruptedCodestreamException("PPM found in tile-part" + " header");
case CSJ2K.j2k.codestream.Markers.COD:
if ((nfMarkSeg & COD_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one COD " + "marker " + "found in tile-part" + " header");
}
nfMarkSeg |= COD_FOUND;
htKey = "COD";
break;
case CSJ2K.j2k.codestream.Markers.COC:
nfMarkSeg |= COC_FOUND;
htKey = "COC" + (nCOCMarkSeg++);
break;
case CSJ2K.j2k.codestream.Markers.QCD:
if ((nfMarkSeg & QCD_FOUND) != 0)
{
throw new CorruptedCodestreamException("More than one QCD " + "marker " + "found in tile-part" + " header");
}
nfMarkSeg |= QCD_FOUND;
htKey = "QCD";
break;
case CSJ2K.j2k.codestream.Markers.QCC:
nfMarkSeg |= QCC_FOUND;
htKey = "QCC" + (nQCCMarkSeg++);
break;
case CSJ2K.j2k.codestream.Markers.RGN:
nfMarkSeg |= RGN_FOUND;
htKey = "RGN" + (nRGNMarkSeg++);
break;
case CSJ2K.j2k.codestream.Markers.COM:
nfMarkSeg |= COM_FOUND;
htKey = "COM" + (nCOMMarkSeg++);
break;
case CSJ2K.j2k.codestream.Markers.CRG:
throw new CorruptedCodestreamException("CRG marker found in " + "tile-part header");
case CSJ2K.j2k.codestream.Markers.PPT:
nfMarkSeg |= PPT_FOUND;
if (nPPTMarkSeg == null)
{
nPPTMarkSeg = new int[nTiles][];
}
if (nPPTMarkSeg[tileIdx] == null)
{
nPPTMarkSeg[tileIdx] = new int[nTileParts[tileIdx]];
}
htKey = "PPT" + (nPPTMarkSeg[tileIdx][tilePartIdx]++);
break;
case CSJ2K.j2k.codestream.Markers.SOD:
nfMarkSeg |= SOD_FOUND;
return ;
case CSJ2K.j2k.codestream.Markers.POC:
if ((nfMarkSeg & POC_FOUND) != 0)
throw new CorruptedCodestreamException("More than one POC " + "marker segment found " + "in tile-part" + " header");
nfMarkSeg |= POC_FOUND;
htKey = "POC";
break;
case CSJ2K.j2k.codestream.Markers.PLT:
if ((nfMarkSeg & PLM_FOUND) != 0)
{
throw new CorruptedCodestreamException("PLT marker found even" + "though PLM marker " + "found in main header");
}
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "PLT marker segment found but " + "not used by JJ2000 decoder.");
htKey = "UNKNOWN";
break;
default:
htKey = "UNKNOWN";
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Non recognized marker segment (0x" + System.Convert.ToString(marker, 16) + ") in tile-part header" + " of tile " + tileIdx + " !");
break;
}
// Read marker segment length and create corresponding byte buffer
int markSegLen = ehs.readUnsignedShort();
byte[] buf = new byte[markSegLen];
// Copy data (after re-insertion of marker segment length);
buf[0] = (byte) ((markSegLen >> 8) & 0xFF);
buf[1] = (byte) (markSegLen & 0xFF);
ehs.readFully(buf, 2, markSegLen - 2);
if (!htKey.Equals("UNKNOWN"))
{
// Store array in hashTable
ht[htKey] = buf;
}
}
/// <summary> Retrieves and reads all marker segments found in the main header during
/// the first pass.
///
/// </summary>
private void readFoundMainMarkSeg()
{
//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'"
//System.IO.BinaryReader dis;
System.IO.MemoryStream bais;
// SIZ marker segment
if ((nfMarkSeg & SIZ_FOUND) != 0)
{
bais = new System.IO.MemoryStream((byte[])ht["SIZ"]);
readSIZ(new CSJ2K.Util.EndianBinaryReader(bais, true));
bais.Dispose();
}
// COM marker segments
if ((nfMarkSeg & COM_FOUND) != 0)
{
for (int i = 0; i < nCOMMarkSeg; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["COM" + i]);
readCOM(new CSJ2K.Util.EndianBinaryReader(bais, true), true, 0, i);
bais.Dispose();
}
}
// CRG marker segment
if ((nfMarkSeg & CRG_FOUND) != 0)
{
bais = new System.IO.MemoryStream((byte[])ht["CRG"]);
readCRG(new CSJ2K.Util.EndianBinaryReader(bais, true));
bais.Dispose();
}
// COD marker segment
if ((nfMarkSeg & COD_FOUND) != 0)
{
bais = new System.IO.MemoryStream((byte[])ht["COD"]);
readCOD(new CSJ2K.Util.EndianBinaryReader(bais, true), true, 0, 0);
bais.Dispose();
}
// COC marker segments
if ((nfMarkSeg & COC_FOUND) != 0)
{
for (int i = 0; i < nCOCMarkSeg; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["COC" + i]);
readCOC(new CSJ2K.Util.EndianBinaryReader(bais, true), true, 0, 0);
bais.Dispose();
}
}
// RGN marker segment
if ((nfMarkSeg & RGN_FOUND) != 0)
{
for (int i = 0; i < nRGNMarkSeg; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["RGN" + i]);
readRGN(new CSJ2K.Util.EndianBinaryReader(bais, true), true, 0, 0);
bais.Dispose();
}
}
// QCD marker segment
if ((nfMarkSeg & QCD_FOUND) != 0)
{
bais = new System.IO.MemoryStream((byte[])ht["QCD"]);
readQCD(new CSJ2K.Util.EndianBinaryReader(bais, true), true, 0, 0);
bais.Dispose();
}
// QCC marker segments
if ((nfMarkSeg & QCC_FOUND) != 0)
{
for (int i = 0; i < nQCCMarkSeg; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["QCC" + i]);
readQCC(new CSJ2K.Util.EndianBinaryReader(bais, true), true, 0, 0);
bais.Dispose();
}
}
// POC marker segment
if ((nfMarkSeg & POC_FOUND) != 0)
{
bais = new System.IO.MemoryStream((byte[])ht["POC"]);
readPOC(new CSJ2K.Util.EndianBinaryReader(bais, true), true, 0, 0);
bais.Dispose();
}
// PPM marker segments
if ((nfMarkSeg & PPM_FOUND) != 0)
{
for (int i = 0; i < nPPMMarkSeg; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["PPM" + i]);
readPPM(new CSJ2K.Util.EndianBinaryReader(bais));
bais.Dispose();
}
}
// Reset the hashtable
ht = null;
}
/// <summary> Retrieves and reads all marker segments previously found in the
/// tile-part header.
///
/// </summary>
/// <param name="tileIdx">The index of the current tile
///
/// </param>
/// <param name="tpIdx">Index of the current tile-part
///
/// </param>
public virtual void readFoundTilePartMarkSeg(int tileIdx, int tpIdx)
{
//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'"
//CSJ2K.EndianBinaryReader dis;
System.IO.MemoryStream bais;
// COD marker segment
if ((nfMarkSeg & COD_FOUND) != 0)
{
bais = new System.IO.MemoryStream((byte[])ht["COD"]);
readCOD(new CSJ2K.Util.EndianBinaryReader(bais, true), false, tileIdx, tpIdx);
}
// COC marker segments
if ((nfMarkSeg & COC_FOUND) != 0)
{
for (int i = 0; i < nCOCMarkSeg; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["COC" + i]);
readCOC(new CSJ2K.Util.EndianBinaryReader(bais, true), false, tileIdx, tpIdx);
}
}
// RGN marker segment
if ((nfMarkSeg & RGN_FOUND) != 0)
{
for (int i = 0; i < nRGNMarkSeg; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["RGN" + i]);
readRGN(new CSJ2K.Util.EndianBinaryReader(bais, true), false, tileIdx, tpIdx);
}
}
// QCD marker segment
if ((nfMarkSeg & QCD_FOUND) != 0)
{
bais = new System.IO.MemoryStream((byte[])ht["QCD"]);
readQCD(new CSJ2K.Util.EndianBinaryReader(bais, true), false, tileIdx, tpIdx);
}
// QCC marker segments
if ((nfMarkSeg & QCC_FOUND) != 0)
{
for (int i = 0; i < nQCCMarkSeg; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["QCC" + i]);
readQCC(new CSJ2K.Util.EndianBinaryReader(bais, true), false, tileIdx, tpIdx);
}
}
// POC marker segment
if ((nfMarkSeg & POC_FOUND) != 0)
{
bais = new System.IO.MemoryStream((byte[])ht["POC"]);
readPOC(new CSJ2K.Util.EndianBinaryReader(bais, true), false, tileIdx, tpIdx);
}
// COM marker segments
if ((nfMarkSeg & COM_FOUND) != 0)
{
for (int i = 0; i < nCOMMarkSeg; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["COM" + i]);
readCOM(new CSJ2K.Util.EndianBinaryReader(bais, true), false, tileIdx, i);
}
}
// PPT marker segments
if ((nfMarkSeg & PPT_FOUND) != 0)
{
for (int i = 0; i < nPPTMarkSeg[tileIdx][tpIdx]; i++)
{
bais = new System.IO.MemoryStream((byte[])ht["PPT" + i]);
readPPT(new CSJ2K.Util.EndianBinaryReader(bais, true), tileIdx, tpIdx);
}
}
// Reset ht
ht = null;
}
/// <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 and returns the EnumeratedColorSpaceMapper
/// corresponding to the information read from the JP2 image file
/// via the ColorSpace parameter.
///
/// </summary>
/// <param name="src">The bit stream reader agent where to get code-block
/// data from.
/// </param>
/// <param name="csMap">provides color space information from the image file
///
/// </param>
/// <returns> The color space mapping object
/// </returns>
/// <exception cref="IOException">image access exception
/// </exception>
/// <exception cref="ICCProfileException">if image contains a bad icc profile
/// </exception>
/// <exception cref="ColorSpaceException">if image contains a bad colorspace box
///
/// </exception>
public virtual BlkImgDataSrc createColorSpaceMapper(BlkImgDataSrc src, CSJ2K.Color.ColorSpace csMap)
{
return ColorSpaceMapper.createInstance(src, csMap);
}
/// <summary> Creates and returns the ChannelDefinitonMapper which maps the
/// input channels to the channel definition for the appropriate
/// colorspace.
///
/// </summary>
/// <param name="src">The bit stream reader agent where to get code-block
/// data from.
/// </param>
/// <param name="csMap">provides color space information from the image file
///
/// </param>
/// <returns> The channel definition mapping object
/// </returns>
/// <exception cref="IOException">image access exception
/// </exception>
/// <exception cref="ColorSpaceException">if image contains a bad colorspace box
///
/// </exception>
public virtual BlkImgDataSrc createChannelDefinitionMapper(BlkImgDataSrc src, CSJ2K.Color.ColorSpace csMap)
{
return ChannelDefinitionMapper.createInstance(src, csMap);
}
/// <summary> Creates and returns the PalettizedColorSpaceMapper which uses
/// the input samples as indicies into a sample palette to
/// construct the output.
///
/// </summary>
/// <param name="src">The bit stream reader agent where to get code-block
/// data from.
/// </param>
/// <param name="csMap">provides color space information from the image file
///
/// </param>
/// <returns> a PalettizedColorSpaceMapper instance
/// </returns>
/// <exception cref="IOException">image access exception
/// </exception>
/// <exception cref="ColorSpaceException">if image contains a bad colorspace box
///
/// </exception>
public virtual BlkImgDataSrc createPalettizedColorSpaceMapper(BlkImgDataSrc src, CSJ2K.Color.ColorSpace csMap)
{
return PalettizedColorSpaceMapper.createInstance(src, csMap);
}
/// <summary> Creates and returns the Resampler which converts the input
/// source to one in which all channels have the same number of
/// samples. This is required for colorspace conversions.
///
/// </summary>
/// <param name="src">The bit stream reader agent where to get code-block
/// data from.
/// </param>
/// <param name="csMap">provides color space information from the image file
///
/// </param>
/// <returns> The resampled BlkImgDataSrc
/// </returns>
/// <exception cref="IOException">image access exception
/// </exception>
/// <exception cref="ColorSpaceException">if image contains a bad colorspace box
///
/// </exception>
public virtual BlkImgDataSrc createResampler(BlkImgDataSrc src, CSJ2K.Color.ColorSpace csMap)
{
return Resampler.createInstance(src, csMap);
}
/// <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> Method that resets members indicating which markers have already been
/// found
///
/// </summary>
public virtual void resetHeaderMarkers()
{
// The found status of PLM remains since only PLM OR PLT allowed
// Same goes for PPM and PPT
nfMarkSeg = nfMarkSeg & (PLM_FOUND | PPM_FOUND);
nCOCMarkSeg = 0;
nQCCMarkSeg = 0;
nCOMMarkSeg = 0;
nRGNMarkSeg = 0;
}
/// <summary> Print information about the current header.
///
/// </summary>
/// <returns> Information in a String
///
/// </returns>
public override System.String ToString()
{
return hdStr;
}
/// <summary> Return the packed packet headers for a given tile.
///
/// </summary>
/// <returns> An input stream containing the packed packet headers for a
/// particular tile
///
/// </returns>
/// <exception cref="IOException">If an I/O error occurs while reading from the
/// encoder header stream
///
/// </exception>
public virtual System.IO.MemoryStream getPackedPktHead(int tile)
{
if (pkdPktHeaders == null)
{
int i, t;
pkdPktHeaders = new System.IO.MemoryStream[nTiles];
for (i = nTiles - 1; i >= 0; i--)
{
pkdPktHeaders[i] = new System.IO.MemoryStream();
}
if (nPPMMarkSeg != 0)
{
// If this is first time packed packet headers are requested,
// create packed packet headers from Nppm and Ippm fields
int nppm;
int nTileParts = tileOfTileParts.Count;
byte[] temp;
System.IO.MemoryStream pph;
System.IO.MemoryStream allNppmIppm = new System.IO.MemoryStream();
// Concatenate all Nppm and Ippm fields
for (i = 0; i < nPPMMarkSeg; i++)
{
byte[] temp_byteArray;
temp_byteArray = pPMMarkerData[i];
allNppmIppm.Write(temp_byteArray, 0, temp_byteArray.Length);
}
pph = new System.IO.MemoryStream(allNppmIppm.ToArray());
// Read all packed packet headers and concatenate for each
// tile part
for (i = 0; i < nTileParts; i++)
{
t = ((System.Int32) tileOfTileParts[i]);
// get Nppm value
nppm = (pph.ReadByte() << 24) | (pph.ReadByte() << 16) | (pph.ReadByte() << 8) | (pph.ReadByte());
temp = new byte[nppm];
// get ippm field
pph.Read(temp, 0, temp.Length); //SupportClass.ReadInput(pph, temp, 0, temp.Length);
byte[] temp_byteArray2;
temp_byteArray2 = temp;
pkdPktHeaders[t].Write(temp_byteArray2, 0, temp_byteArray2.Length);
}
}
else
{
int tp;
// Write all packed packet headers to pkdPktHeaders
for (t = nTiles - 1; t >= 0; t--)
{
for (tp = 0; tp < nTileParts[t]; tp++)
{
for (i = 0; i < nPPTMarkSeg[t][tp]; i++)
{
byte[] temp_byteArray3;
temp_byteArray3 = tilePartPkdPktHeaders[t][tp][i];
pkdPktHeaders[t].Write(temp_byteArray3, 0, temp_byteArray3.Length);
}
}
}
}
}
return new System.IO.MemoryStream(pkdPktHeaders[tile].ToArray());
}
}
}
Generated by GNU Enscript 1.6.5.90.