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 } }
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 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); 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); codecPrivateData = new byte[Size - 8L]; reader.Read(codecPrivateData, 0, codecPrivateData.Length); } }
/// <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); 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); 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); 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); } }
/// <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); 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); } }