public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
this.TrackId = reader.ReadUInt32();
if (EnumUtils.IsBitSet <TrackFragmentHeaderBoxFlags>((TrackFragmentHeaderBoxFlags)base.Flags, TrackFragmentHeaderBoxFlags.BaseDataOffsetPresent))
{
this._baseDataOffset = reader.ReadUInt64();
}
if (EnumUtils.IsBitSet <TrackFragmentHeaderBoxFlags>((TrackFragmentHeaderBoxFlags)base.Flags, TrackFragmentHeaderBoxFlags.SampleDescriptionIndexPresent))
{
this._sampleDescriptionIndex = reader.ReadUInt32();
}
if (EnumUtils.IsBitSet <TrackFragmentHeaderBoxFlags>((TrackFragmentHeaderBoxFlags)base.Flags, TrackFragmentHeaderBoxFlags.DefaultSampleDurationPresent))
{
this._defaultSampleDuration = reader.ReadUInt32();
}
if (EnumUtils.IsBitSet <TrackFragmentHeaderBoxFlags>((TrackFragmentHeaderBoxFlags)base.Flags, TrackFragmentHeaderBoxFlags.DefaultSampleSizePresent))
{
this._defaultSampleSize = reader.ReadUInt32();
}
if (EnumUtils.IsBitSet <TrackFragmentHeaderBoxFlags>((TrackFragmentHeaderBoxFlags)base.Flags, TrackFragmentHeaderBoxFlags.DefaultSampleFlagsPresent))
{
this._defaultSampleFlags = reader.ReadUInt32();
}
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
TrackHeaderBox.Read(reader);
while (this.Size > (ulong)(reader.BaseStream.Position - (long)this.Offset))
{
long pos = reader.BaseStream.Position;
BoxType next = reader.PeekNextBoxType();
if (next == BoxTypes.Edts)
{
EdtsBox = new EdtsBox();
EdtsBox.movieTimeScale = movieTimeScale;
EdtsBox.Read(reader);
}
else if (next == BoxTypes.TrackReference)
{
TrackReferenceBox = new TrackReferenceBox();
TrackReferenceBox.Read(reader);
}
else if (next == BoxTypes.Media)
{
MediaBox = new MediaBox(this);
MediaBox.Read(reader);
}
else
{
Box unknown = new Box(BoxTypes.Any);
unknown.Read(reader);
Debug.WriteLine(string.Format("Unknow box type {0} in Trak box, skipped", next.ToString()));
}
}
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
DataReferenceBox.Read(reader);
}
}
public void Read(BoxReader reader)
{
uint num = reader.ReadByte();
this.SampleDependsOn = (uint) ((num & 12) >> 2);
this.SampleIsDependedOn = (uint) ((num & 0x30) >> 4);
this.SampleHasRedundancy = (uint) ((num & 0xc0) >> 6);
}
public override void Read(BoxReader reader)
{
using (SizeChecker checker = new SizeChecker(this, reader)) {
base.Read(reader);
this.TrackFragmentHeaderBox.Read(reader);
this.TrackFragmentRunBox.Read(reader);
while (checker.DataLeft() > 8) {
// it appears that Independent and Disposable Sample Box is optional
BoxType nextbox = reader.PeekNextBoxType();
if (nextbox == BoxTypes.IndependentAndDisposableSamplesBox) {
this.IndependentAndDisposableSamplesBox = new IndependentAndDisposableSamplesBox(this.TrackFragmentRunBox.Samples.Count);
this.IndependentAndDisposableSamplesBox.Read(reader);
continue;
}
if (nextbox == BoxTypes.UUID) {
UserUniqueIDBox = new UserUniqueIDBox();
UserUniqueIDBox.Read(reader);
continue;
}
break; // this shouldn't happen, and it should force the SizeChecker to throw an exception as it means we didn't read everything...
}
}
}
public override void Read(BoxReader reader)
{
long pos = reader.BaseStream.Position;
base.Read(reader);
data = new byte[base.Size - 8];
reader.Read(data, 0, data.Length); // FIXME: useless all-zero data - should we even read?
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
if (Version == 1)
{
creationTime = reader.ReadUInt64();
modificationTime = reader.ReadUInt64();
TrackID = reader.ReadUInt32();
UInt32 reserved = reader.ReadUInt32(); // reserved = 0
Duration = reader.ReadUInt64();
}
else
{
creationTime = (UInt32)reader.ReadUInt32();
modificationTime = (UInt32)reader.ReadUInt32();
TrackID = reader.ReadUInt32();
reader.ReadUInt32(); // reserved = 0
Duration = (UInt32)reader.ReadUInt32();
}
for (int x = 0; x < 2; x++)
{
reader.ReadUInt32(); // int(32)[2] - reserved = 0 - 40 bytes
}
Layer = reader.ReadUInt16(); // layer = 0
AlternateGroup = reader.ReadUInt16(); // alternate_group = 0
_volume = reader.ReadUInt16();
reader.ReadUInt16(); // reserved = 0 - 48 bytes
this.Matrix.Read(reader);
_width = reader.ReadUInt32();
_height = reader.ReadUInt32();
}
}
public virtual void Read(BoxReader reader)
{
this.Offset = (ulong)reader.BaseStream.Position;
this.size = reader.ReadUInt32();
if (size == 0) {
this.type = BoxTypes.Error;
return;
}
this.type = reader.ReadBoxType();
if (this.size == 1) {
this.largeSize = reader.ReadUInt64();
}
if (this.expectedType == BoxTypes.Any)
{
reader.BaseStream.Seek((long) (this.size - 8), SeekOrigin.Current);
}
else if (this.expectedType == BoxTypes.AnyDescription)
{
return;
}
else if (this.type != this.expectedType)
{
throw new UnexpectedBoxException(this.expectedType, this.type);
}
}
/// <summary>
/// Edit List Container Box
/// Kludge: we don't process this box. All we do is store it away in RawTrackInfo
/// for passing to the stream writer when recoding.
/// </summary>
/// <param name="reader"></param>
public override void Read(BoxReader reader)
{
//mp4Stream.ReadChildBoxes(boxes, (offset + (long)size));
base.Read(reader);
elstBox = new ElstBox();
elstBox.Read(reader);
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
}
}
public void Read(BoxReader reader)
{
for (int i = 0; i < 9; i++)
{
matrix[i] = reader.ReadUInt32(); // int(32)[9] - matrix
}
}
/// <summary>
/// Edit List Container Box
/// Kludge: we don't process this box. All we do is store it away in RawTrackInfo
/// for passing to the stream writer when recoding.
/// </summary>
/// <param name="reader"></param>
public override void Read(BoxReader reader)
{
//mp4Stream.ReadChildBoxes(boxes, (offset + (long)size));
base.Read(reader);
elstBox = new ElstBox();
elstBox.Read(reader);
}
public override void Read(BoxReader reader)
{
using (SizeChecker checker = new SizeChecker(this, reader)) {
base.Read(reader);
this.TrackFragmentHeaderBox.Read(reader);
this.TrackFragmentRunBox.Read(reader);
while (checker.DataLeft() > 8)
{
// it appears that Independent and Disposable Sample Box is optional
BoxType nextbox = reader.PeekNextBoxType();
if (nextbox == BoxTypes.IndependentAndDisposableSamplesBox)
{
this.IndependentAndDisposableSamplesBox = new IndependentAndDisposableSamplesBox(this.TrackFragmentRunBox.Samples.Count);
this.IndependentAndDisposableSamplesBox.Read(reader);
continue;
}
if (nextbox == BoxTypes.UUID)
{
UserUniqueIDBox = new UserUniqueIDBox();
UserUniqueIDBox.Read(reader);
continue;
}
break; // this shouldn't happen, and it should force the SizeChecker to throw an exception as it means we didn't read everything...
}
}
}
public virtual void Read(BoxReader reader)
{
this.Offset = (ulong)reader.BaseStream.Position;
this.size = reader.ReadUInt32();
if (size == 0)
{
this.type = BoxTypes.Error;
return;
}
this.type = reader.ReadBoxType();
if (this.size == 1)
{
this.largeSize = reader.ReadUInt64();
}
if (this.expectedType == BoxTypes.Any)
{
reader.BaseStream.Seek((long)(this.size - 8), SeekOrigin.Current);
}
else if (this.expectedType == BoxTypes.AnyDescription)
{
return;
}
else if (this.type != this.expectedType)
{
throw new UnexpectedBoxException(this.expectedType, this.type);
}
}
public void Close()
{
if (this.m_reader != null)
{
this.m_reader.Close(); this.m_reader = null;
}
//base.EOF = false;
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
Name = reader.ReadNullTerminatedString();
Location = reader.ReadNullTerminatedString();
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
Balance = reader.ReadUInt16();
reader.ReadUInt16(); // reserved = 0
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
this.MfraSize = reader.ReadUInt32();
}
}
public override void Read(BoxReader reader)
{
base.Read(reader);
trackID = new uint[(int)((long)Size - (reader.BaseStream.Position - (long)Offset)) / 4];
for (int i = 0; i < trackID.Length; i++) {
trackID[i] = reader.ReadUInt32();
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
this.SequenceNumber = reader.ReadUInt32();
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
Balance = reader.ReadUInt16();
reader.ReadUInt16(); // reserved = 0
}
}
public override void Read(BoxReader reader)
{
long pos = reader.BaseStream.Position;
base.Read(reader);
data = new byte[base.Size - 8];
reader.Read(data, 0, data.Length); // FIXME: useless all-zero data - should we even read?
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
this.MfraSize = reader.ReadUInt32();
}
}
public void Read(BoxReader reader)
{
uint num = reader.ReadByte();
this.SampleDependsOn = (uint)((num & 12) >> 2);
this.SampleIsDependedOn = (uint)((num & 0x30) >> 4);
this.SampleHasRedundancy = (uint)((num & 0xc0) >> 6);
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
Name = reader.ReadNullTerminatedString();
Location = reader.ReadNullTerminatedString();
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
this.SequenceNumber = reader.ReadUInt32();
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
this.MovieFragmentHeaderBox.Read(reader);
this.TrackFragmentBox.Read(reader);
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
_contents = new byte[base.Size - 8UL];
reader.Read(_contents, 0, _contents.Length);
}
}
public override void Read(BoxReader reader)
{
using (SizeChecker checker = new SizeChecker(this, reader))
{
base.Read(reader);
UserType = reader.ReadBytes(4);
UserData = reader.ReadBytes((int)checker.DataLeft());
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
_data = new byte[base.Size - 8];
reader.Read(_data, 0, _data.Length);
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
_data = new byte[base.Size - 8];
reader.Read(_data, 0, _data.Length);
}
}
public override void Read(BoxReader reader)
{
using (SizeChecker checker = new SizeChecker(this, reader))
{
base.Read(reader);
UserType = reader.ReadBytes(4);
UserData = reader.ReadBytes((int)checker.DataLeft());
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
codecPrivateData = new byte[Size - 8L];
reader.Read(codecPrivateData, 0, codecPrivateData.Length);
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
this.MovieFragmentHeaderBox.Read(reader);
this.TrackFragmentBox.Read(reader);
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
_contents = new byte[base.Size - 8UL];
reader.Read(_contents, 0, _contents.Length);
}
}
public override void Read(BoxReader reader)
{
base.Read(reader);
trackID = new uint[(int)((long)Size - (reader.BaseStream.Position - (long)Offset)) / 4];
for (int i = 0; i < trackID.Length; i++)
{
trackID[i] = reader.ReadUInt32();
}
}
/// <summary>
/// GetMP4TrackID
/// Get the track ID without reading all of the fragment. Instead of calling Read above, use this if all that is needed is the TrackID.
/// If this fragment belongs to a track that in turn belongs to a Microsoft ISM smooth stream, then this method gets the LOCAL track ID
/// within the ISMV file.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public int GetMP4TrackID(BoxReader reader)
{
long pos = reader.BaseStream.Position;
_trackID = (int)this.MovieFragmentBox.GetTrackID(reader);
// we advance to the next box after this fragment
reader.BaseStream.Position = pos + (long)this.MovieFragmentBox.Size;
this.MediaDataBox.Read(reader);
return(_trackID);
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
GraphicsMode = reader.ReadUInt16();
OpColor[0] = reader.ReadUInt16();
OpColor[1] = reader.ReadUInt16();
OpColor[2] = reader.ReadUInt16();
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
GraphicsMode = reader.ReadUInt16();
OpColor[0] = reader.ReadUInt16();
OpColor[1] = reader.ReadUInt16();
OpColor[2] = reader.ReadUInt16();
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
TrackID = reader.ReadUInt32();
DefaultSampleDescriptionIndex = reader.ReadUInt32();
DefaultSampleDuration = reader.ReadUInt32();
DefaultSampleSize = reader.ReadUInt32();
DefaultSampleFlags = reader.ReadUInt32();
}
}
//public override void Read()
//{
// //base.Read();
// BoxReader boxReader = new BoxReader(readStream);
// this.Read(boxReader);
//}
/// <summary>
/// Read
/// Read just the header boxes of a fragment, not the MDAT box data bits yet.
/// </summary>
/// <param name="reader"></param>
public void Read(BoxReader inBoxReader)
{
// now we can once again read everything, but using our own reader...
this._reader = inBoxReader;
this.MovieFragmentBox.Read(_reader);
this.MediaDataBox.Read(_reader);
this._baseDataOffset = this.MediaDataBox.PayloadOffset;
this._trackID = (int)this.MovieFragmentBox.TrackFragmentBox.TrackFragmentHeaderBox.TrackId;
base.Length = (int)this.MovieFragmentBox.TrackFragmentBox.TrackFragmentRunBox.SampleCount;
CollectSampleInfoStream(); // pre-assemble list of sample info blocks
}
public ISMVFile(string inDir, string inFileName)
{
strDir = inDir;
strFileName = inFileName;
boxReader = new BoxReader(File.Open(Path.Combine(inDir, inFileName), FileMode.Open, FileAccess.Read, FileShare.Read));
boxReader2 = new BoxReader(File.Open(Path.Combine(inDir, inFileName), FileMode.Open, FileAccess.Read, FileShare.Read));
ftb.Read(boxReader);
mmb.Read(boxReader);
BoxType nextType = boxReader.PeekNextBoxType();
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
TrackID = reader.ReadUInt32();
DefaultSampleDescriptionIndex = reader.ReadUInt32();
DefaultSampleDuration = reader.ReadUInt32();
DefaultSampleSize = reader.ReadUInt32();
DefaultSampleFlags = reader.ReadUInt32();
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
if (Version == 1) {
FragmentDuration = reader.ReadUInt64();
} else {
FragmentDuration = (UInt64)reader.ReadUInt32();
}
}
}
/// <summary>
/// Constructor to use when reading.
/// </summary>
/// <param name="inDir">Folder path</param>
/// <param name="inFileName">ISMV file name</param>
public ISMVTrackFormat(string inDir, string inFileName)
{
strDir = inDir;
strFileName = inFileName;
boxReader = new BoxReader(File.Open(Path.Combine(inDir, inFileName), FileMode.Open, FileAccess.Read, FileShare.Read));
ftb.Read(boxReader);
mmb.Read(boxReader);
//BoxType nextType = boxReader.PeekNextBoxType();
//ReadMP4Headers(); // just read the rest?
_frameSize = new Size();
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
MaxPDUSize = reader.ReadUInt16();
AvgPDUSize = reader.ReadUInt16();
MaxBitrate = reader.ReadUInt16();
AvgBitrate = reader.ReadUInt16();
reader.ReadUInt16(); // reserved = 0
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
MaxPDUSize = reader.ReadUInt16();
AvgPDUSize = reader.ReadUInt16();
MaxBitrate = reader.ReadUInt16();
AvgBitrate = reader.ReadUInt16();
reader.ReadUInt16(); // reserved = 0
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
for (int i = 0; i < this.m_numSamples; i++)
{
IndependentAndDisposableSample item = new IndependentAndDisposableSample();
item.Read(reader);
this.Samples.Add(item);
}
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
for (int i = 0; i < this.m_numSamples; i++)
{
IndependentAndDisposableSample item = new IndependentAndDisposableSample();
item.Read(reader);
this.Samples.Add(item);
}
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
long headerSize = reader.BaseStream.Position - (long)this.Offset;
//if (LargeSize > 0) headerSize += 8;
PayloadOffset = (ulong)reader.BaseStream.Position;
// Why are we not looking at LargeSize for other types of boxes? It's really only mdat that can grow in size larger than max long int.
// Note that we don't ever load the data into MediaData. However, we do write it out from MediaData. See Write below.
reader.BaseStream.Seek((long)Size - headerSize, SeekOrigin.Current);
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
long headerSize = reader.BaseStream.Position - (long)this.Offset;
//if (LargeSize > 0) headerSize += 8;
PayloadOffset = (ulong)reader.BaseStream.Position;
// Why are we not looking at LargeSize for other types of boxes? It's really only mdat that can grow in size larger than max long int.
// Note that we don't ever load the data into MediaData. However, we do write it out from MediaData. See Write below.
reader.BaseStream.Seek((long)Size - headerSize, SeekOrigin.Current);
}
}
/// <summary>
/// Read - read a MediaInformationBox
/// We go in a loop with an if-else statement, so ordering of sub-boxes does not matter.
/// </summary>
/// <param name="reader"></param>
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
while (reader.BaseStream.Position < (long)(this.Size + this.Offset))
{
long pos = reader.BaseStream.Position;
Box test = new Box(BoxTypes.Any);
test.Read(reader);
reader.BaseStream.Seek(pos, System.IO.SeekOrigin.Begin);
pos = reader.BaseStream.Position;
if (test.Type == BoxTypes.SoundMediaHeader)
{
this.SoundMediaHeaderBox = new SoundMediaHeaderBox();
SoundMediaHeaderBox.Read(reader);
}
else if (test.Type == BoxTypes.VideoMediaHeader)
{
this.VideoMediaHeaderBox = new VideoMediaHeaderBox();
VideoMediaHeaderBox.Read(reader);
}
else if (test.Type == BoxTypes.DataInformation)
{
this.DataInformationBox = new DataInformationBox();
DataInformationBox.Read(reader);
}
else if (test.Type == BoxTypes.SampleTable)
{
this.SampleTableBox = new SampleTableBox(this);
SampleTableBox.Read(reader);
}
else if (test.Type == BoxTypes.NullMediaHeader)
{
this.NullMediaHeaderBox = new NullMediaHeaderBox();
NullMediaHeaderBox.Read(reader);
}
else
{
test.Read(reader);
Debug.WriteLine(string.Format("Unknown box type {0} in MediaInformationBox (minf)", test.Type.ToString()));
}
}
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
EntryCount = reader.ReadUInt32();
SampleCount = new uint[EntryCount];
SampleDelta = new uint[EntryCount];
for (int i=0; i<EntryCount; i++) {
SampleCount[i] = reader.ReadUInt32();
SampleDelta[i] = reader.ReadUInt32();
}
}
}
/// <summary>
/// Read - read chunk offset box from input MP4 stream.
/// </summary>
/// <param name="reader">BoxReader</param>
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
entryCount = reader.ReadUInt32();
chunkOffsetArray = new uint[entryCount];
for (int i = 0; i < entryCount; i++) {
chunkOffsetArray[i] = reader.ReadUInt32();
}
}
if (parent.SampleToChunkBox != null)
parent.SampleToChunkBox.TotalChunks = entryCount;
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
MediaHeaderBox = new MediaHeaderBox(this);
HandlerReferenceBox = new HandlerReferenceBox(this);
MediaInformationBox = new MediaInformationBox(this);
MediaHeaderBox.Read(reader);
HandlerReferenceBox.Read(reader);
MediaInformationBox.Read(reader);
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
EntryCount = reader.ReadUInt32();
SampleNumbers = new uint[EntryCount];
for (int i = 0; i < EntryCount; i++)
{
SampleNumbers[i] = reader.ReadUInt32();
}
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
long pos = reader.BaseStream.Position;
base.Read(reader);
// if (reader.BaseStream.Position - pos == this.Size) {
// BUG!!!, Microsoft says the size is X, but it needs one more byte for the null terminated string!!!
// this.Size += 1;
// bBug = true;
// }
if (EnumUtils.IsBitSet<DataEntryFlags>((DataEntryFlags)base.Flags, DataEntryFlags.MediaDataSameFile) == false)
Location = reader.ReadNullTerminatedString();
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
if (Version == 1)
{
FragmentDuration = reader.ReadUInt64();
}
else
{
FragmentDuration = (UInt64)reader.ReadUInt32();
}
}
}
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader))
{
base.Read(reader);
this.TrackFragmentRandomAccessBoxes = new List<TrackFragmentRandomAccessBox>();
while (reader.PeekNextBoxType() == BoxTypes.TrackFragmentRandomAccess) {
TrackFragmentRandomAccessBox item = new TrackFragmentRandomAccessBox();
item.Read(reader);
this.TrackFragmentRandomAccessBoxes.Add(item);
}
this.MovieFragmentRandomAccessOffsetBox = new MovieFragmentRandomAccessOffsetBox();
this.MovieFragmentRandomAccessOffsetBox.Read(reader);
}
}
/// <summary>
/// Read - read a MediaInformationBox
/// We go in a loop with an if-else statement, so ordering of sub-boxes does not matter.
/// </summary>
/// <param name="reader"></param>
public override void Read(BoxReader reader)
{
using (new SizeChecker(this, reader)) {
base.Read(reader);
while (reader.BaseStream.Position < (long)(this.Size + this.Offset)) {
long pos = reader.BaseStream.Position;
Box test = new Box(BoxTypes.Any);
test.Read(reader);
reader.BaseStream.Seek(pos, System.IO.SeekOrigin.Begin);
pos = reader.BaseStream.Position;
if (test.Type == BoxTypes.SoundMediaHeader) {
this.SoundMediaHeaderBox = new SoundMediaHeaderBox();
SoundMediaHeaderBox.Read(reader);
}
else if (test.Type == BoxTypes.VideoMediaHeader) {
this.VideoMediaHeaderBox = new VideoMediaHeaderBox();
VideoMediaHeaderBox.Read(reader);
}
else if (test.Type == BoxTypes.DataInformation) {
this.DataInformationBox = new DataInformationBox();
DataInformationBox.Read(reader);
}
else if (test.Type == BoxTypes.SampleTable) {
this.SampleTableBox = new SampleTableBox(this);
SampleTableBox.Read(reader);
}
else if (test.Type == BoxTypes.NullMediaHeader)
{
this.NullMediaHeaderBox = new NullMediaHeaderBox();
NullMediaHeaderBox.Read(reader);
}
else
{
test.Read(reader);
Debug.WriteLine(string.Format("Unknown box type {0} in MediaInformationBox (minf)", test.Type.ToString()));
}
}
}
}
