public static void readExtension(MemoryStream bb, SequenceHeader sh)
{
m_hasExtensions = true;
BitReader inb = new BitReader(bb);
int extType = inb.readNBit(4);
switch (extType)
{
case Sequence_Extension:
sh.sequenceExtension = SequenceExtension.read(inb);
break;
case Sequence_Scalable_Extension:
sh.sequenceScalableExtension = SequenceScalableExtension.read(inb);
break;
case Sequence_Display_Extension:
sh.sequenceDisplayExtension = SequenceDisplayExtension.read(inb);
break;
default:
throw new Exception("Unsupported extension: " + extType);
}
}
public static SequenceHeader read(MemoryStream bb)
{
BitReader inb = new BitReader(bb);
SequenceHeader sh = new SequenceHeader();
sh.horizontal_size = inb.readNBit(12);
sh.vertical_size = inb.readNBit(12);
sh.aspect_ratio_information = inb.readNBit(4);
sh.frame_rate_code = inb.readNBit(4);
sh.bit_rate = inb.readNBit(18);
sh.marker_bit = inb.read1Bit();
sh.vbv_buffer_size_value = inb.readNBit(10);
sh.constrained_parameters_flag = inb.read1Bit();
if (inb.read1Bit() != 0)
{
sh.intra_quantiser_matrix = new int[64];
for (int i = 0; i < 64; i++)
{
sh.intra_quantiser_matrix[i] = inb.readNBit(8);
}
}
if (inb.read1Bit() != 0)
{
sh.non_intra_quantiser_matrix = new int[64];
for (int i = 0; i < 64; i++)
{
sh.non_intra_quantiser_matrix[i] = inb.readNBit(8);
}
}
return(sh);
}
private PictureHeader readHeader(MemoryStream buffer)
{
PictureHeader ph = null;
MemoryStream segment;
MemoryStream fork = buffer.duplicate();
while ((segment = MPEGUtil.nextSegment(fork)) != null)
{
int code = segment.getInt() & 0xff;
if (code == MPEGConst.SEQUENCE_HEADER_CODE)
{
SequenceHeader newSh = SequenceHeader.read(segment);
if (sh != null)
{
newSh.copyExtensions(sh);
}
sh = newSh;
}
else if (code == MPEGConst.GROUP_START_CODE)
{
gh = GOPHeader.read(segment);
}
else if (code == MPEGConst.PICTURE_START_CODE)
{
ph = PictureHeader.read(segment);
}
else if (code == MPEGConst.EXTENSION_START_CODE)
{
int extType = segment.get(4) >> 4;
if (extType == SequenceHeader.Sequence_Extension || extType == SequenceHeader.Sequence_Scalable_Extension ||
extType == SequenceHeader.Sequence_Display_Extension)
{
SequenceHeader.readExtension(segment, sh);
}
else
{
PictureHeader.readExtension(segment, ph, sh);
}
}
else if (code == MPEGConst.USER_DATA_START_CODE)
{
// do nothing
}
else
{
break;
}
buffer.position(fork.position());
}
return(ph);
}
protected Context initContext(SequenceHeader sh, PictureHeader ph)
{
Context context = new Context();
context.codedWidth = (sh.horizontal_size + 15) & ~0xf;
context.codedHeight = getCodedHeight(sh, ph);
context.mbWidth = (sh.horizontal_size + 15) >> 4;
context.mbHeight = (sh.vertical_size + 15) >> 4;
context.picWidth = sh.horizontal_size;
context.picHeight = sh.vertical_size;
int chromaFormat = SequenceExtension.Chroma420;
if (sh.sequenceExtension != null)
{
chromaFormat = sh.sequenceExtension.chroma_format;
}
context.color = getColor(chromaFormat);
context.scan = MPEGConst.scan[ph.pictureCodingExtension == null ? 0 : ph.pictureCodingExtension.alternate_scan];
int[] inter = sh.non_intra_quantiser_matrix == null?zigzag(MPEGConst.defaultQMatInter, context.scan)
: sh.non_intra_quantiser_matrix;
int[] intra = sh.intra_quantiser_matrix == null?zigzag(MPEGConst.defaultQMatIntra, context.scan)
: sh.intra_quantiser_matrix;
context.qMats = new int[][] { inter, inter, intra, intra };
if (ph.quantMatrixExtension != null)
{
if (ph.quantMatrixExtension.non_intra_quantiser_matrix != null)
{
context.qMats[0] = ph.quantMatrixExtension.non_intra_quantiser_matrix;
}
if (ph.quantMatrixExtension.chroma_non_intra_quantiser_matrix != null)
{
context.qMats[1] = ph.quantMatrixExtension.chroma_non_intra_quantiser_matrix;
}
if (ph.quantMatrixExtension.intra_quantiser_matrix != null)
{
context.qMats[2] = ph.quantMatrixExtension.intra_quantiser_matrix;
}
if (ph.quantMatrixExtension.chroma_intra_quantiser_matrix != null)
{
context.qMats[3] = ph.quantMatrixExtension.chroma_intra_quantiser_matrix;
}
}
return(context);
}
private static SequenceHeader getSequenceHeader(MemoryStream data)
{
MemoryStream segment = MPEGUtil.nextSegment(data);
while (segment != null)
{
int marker = segment.getInt();
if (marker == (0x100 | MPEGConst.SEQUENCE_HEADER_CODE))
{
return(SequenceHeader.read(segment));
}
segment = MPEGUtil.nextSegment(data);
}
return(null);
}
public static void readExtension(MemoryStream bb, PictureHeader ph, SequenceHeader sh)
{
ph.m_hasExtensions = true;
BitReader inb = new BitReader(bb);
int extType = inb.readNBit(4);
switch (extType)
{
case Quant_Matrix_Extension:
ph.quantMatrixExtension = QuantMatrixExtension.read(inb);
break;
case Copyright_Extension:
ph.copyrightExtension = CopyrightExtension.read(inb);
break;
case Picture_Display_Extension:
ph.pictureDisplayExtension = PictureDisplayExtension.read(inb, sh.sequenceExtension,
ph.pictureCodingExtension);
break;
case Picture_Coding_Extension:
ph.pictureCodingExtension = PictureCodingExtension.read(inb);
break;
case Picture_Spatial_Scalable_Extension:
ph.pictureSpatialScalableExtension = PictureSpatialScalableExtension.read(inb);
break;
case Picture_Temporal_Scalable_Extension:
ph.pictureTemporalScalableExtension = PictureTemporalScalableExtension.read(inb);
break;
default:
throw new Exception("Unsupported extension: " + extType);
}
}
public static Size getSize(MemoryStream data)
{
SequenceHeader sh = getSequenceHeader(data.duplicate());
return(new Size(sh.horizontal_size, sh.vertical_size));
}
public static int getCodedHeight(SequenceHeader sh, PictureHeader ph)
{
int field = ph.pictureCodingExtension != null && ph.pictureCodingExtension.picture_structure != PictureCodingExtension.Frame ? 1 : 0;
return((((sh.vertical_size >> field) + 15) & ~0xf) << field);
}
public MPEGDecoder(SequenceHeader sh, GOPHeader gh, string name, Media.Common.Binary.ByteOrder byteOrder, int defaultComponentCount, int defaultBitsPerComponent)
: this(name, byteOrder, defaultComponentCount, defaultBitsPerComponent)
{
this.sh = sh;
this.gh = gh;
}
public void copyExtensions(SequenceHeader sh)
{
sequenceExtension = sh.sequenceExtension;
sequenceScalableExtension = sh.sequenceScalableExtension;
sequenceDisplayExtension = sh.sequenceDisplayExtension;
}
