internal CodecStream(IDataReader dataReader, IDataBlockBuilder dataBlockBuilder, QtAtom root) { if (dataReader == null) { throw new ArgumentNullException("dataReader"); } if (dataBlockBuilder == null) { throw new ArgumentNullException("dataBlockBuilder"); } if (root == null) { throw new ArgumentNullException("root"); } _dataReader = dataReader; _dataBlockBuilder = dataBlockBuilder; _root = root; _moov = _root.FindChild(AtomName.Movie); _mdat = _root.FindChild(AtomName.MediaData); _fileOffset = _root.FirstChild.Offset; if (_mdat == null) { _mdatChunk = new Chunk(((QtAtom)_root.GetLastDescendant()).Offset - _fileOffset, 0); } else { _mdatChunk = new Chunk(_mdat.Offset - _fileOffset + 8, (_mdat.Length - 8)); } _mdatMaxUnparsedBytes = (uint)QtDetector.Configurable[QtDetector.ConfigurationKey.MediaDateMaxUnparsedBytes]; }
public void BuildEndOffsetNegative() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.EndOffset = -1; dataBlockBuilder.Build(); }
public IDataBlock DetectData(IDataReader dataReader, IDataBlockBuilder dataBlockBuilder, IScanContext context) { if (dataReader.State != DataReaderState.Ready) { return(null); } try { long startPosition = dataReader.Position; IDataBlock dataBlock = _detector.DetectData(dataReader, dataBlockBuilder, context); if (dataReader.State == DataReaderState.Cancelled) { dataReader.Position = dataReader.Length; } else if (dataReader.Position <= startPosition) { // Force advance stream reader one byte Log.Error(string.Format("Detector {0} did not advance the stream reader position.", _detector.Name)); dataReader.Position = startPosition + 1; } return(dataBlock); } catch (OutOfMemoryException) { // TODO improve out of memory exception handling and remove reference to System.Windows.Forms System.Windows.Forms.MessageBox.Show("There is not enough memory available to continue scanning current data block (2); Position: " + dataReader.Position + "; Detector: " + _detector.Name + "; Header count: ?", "Out Of Memory"); // Skip rest of the stream dataReader.Position = dataReader.Length; return(null); } }
public void BuildEndOffsetAfterEndOfFile() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.EndOffset = (FileLength1 + 1); dataBlockBuilder.Build(); }
public void EqualsDifferentDetector() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.Detectors = new[] { _detector2 }; Assert.IsFalse(_dataBlock1.Equals(dataBlockBuilder.Build())); }
public void BuildEndOffsetEqualToStartOffset() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.EndOffset = StartOffset1; dataBlockBuilder.Build(); }
public void BuildInputFileNull() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.InputFile = null; dataBlockBuilder.Build(); }
public IDataBlock DetectData(IDataReader dataReader, IDataBlockBuilder dataBlockBuilder, IScanContext context) { bool isFragmented = context.IsFragmented; if (ReferenceHeaders != null) { var referenceHeaders = new Dictionary <IDataPacket, ISequenceState>(); foreach (IReferenceHeader header in ReferenceHeaders) { IInputFile headerFile = context.CreateReferenceHeaderFile(header); using (var reader = headerFile.CreateDataReader()) { var headerDataBlock = _carver.Carve(new BitStreamDataReader(reader), dataBlockBuilder, context); if (headerDataBlock != null) { referenceHeaders[headerFile.CreateDataPacket()] = context.ReferenceHeader as ISequenceState; } } } context.ReferenceHeader = referenceHeaders; } // Restore scan context context.Results = null; context.IsFragmented = isFragmented; // context.ReferenceHeader return(_carver.Carve(new BitStreamDataReader(dataReader), dataBlockBuilder, context)); }
public bool ValidateDataBlock(IDataBlockBuilder dataBlockBuilder, long startOffset, long endOffset) { if (!IsValidResult()) { return(false); } dataBlockBuilder.DataFormat = _state.IsMpeg2() ? CodecID.Mpeg2Video : CodecID.Mpeg1Video; dataBlockBuilder.IsFullFile = IsFullFile(); dataBlockBuilder.IsFragmented = _state.IsFragmented; // Trim zero byte stuffing from last header (if any) if (_state.LastHeaderZeroByteStuffing > 0) { dataBlockBuilder.EndOffset = endOffset - _state.LastHeaderZeroByteStuffing; } if (_state.ReferenceHeader != null) { dataBlockBuilder.ReferenceHeaderOffset = _state.ReferenceHeaderPosition - startOffset; dataBlockBuilder.ReferenceHeader = _state.ReferenceHeader; } if (_state.Sequence.Initialized) { var sequenceState = new SequenceState(); _state.Sequence.CopyTo(sequenceState); _scanContext.ReferenceHeader = sequenceState; } return(true); }
public void BuildDetectorNull() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.Detectors = null; dataBlockBuilder.Build(); }
public bool ValidateDataBlock(IDataBlockBuilder dataBlockBuilder, long startOffset, long endOffset) { if (!IsValidResult(_scanContext.Results)) { return(false); } endOffset += TrimResult(); dataBlockBuilder.DataFormat = CodecID.H264; dataBlockBuilder.StartOffset = startOffset; dataBlockBuilder.EndOffset = endOffset; // TODO: _dataBlockBuilder.IsFullFile = false; if (_state.ReferenceHeader != null) { dataBlockBuilder.ReferenceHeaderOffset = _state.ReferenceHeaderPosition - startOffset; dataBlockBuilder.ReferenceHeader = _state.ReferenceHeader; } if (_state.PictureStates.Initialized) { // TODO: make a defensive copy of the picture state var pictureParameterSetId = _state.PictureStates.First(); _scanContext.ReferenceHeader = _state.PictureStates[pictureParameterSetId]; } return(true); }
public void EqualsDifferentInputFile() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.InputFile = _inputFile2; Assert.IsFalse(_dataBlock1.Equals(dataBlockBuilder.Build())); }
public void EqualsDifferentIsFullFile() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.IsFullFile = true; Assert.IsFalse(_dataBlock1.Equals(dataBlockBuilder.Build())); }
public void EqualsDifferentEndOffset() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.EndOffset = (EndOffset1 + 1); Assert.IsFalse(_dataBlock1.Equals(dataBlockBuilder.Build())); }
public bool ValidateDataBlock(IDataBlockBuilder dataBlockBuilder, long startOffset, long endOffset) { if (!IsValidResult()) { return(false); } dataBlockBuilder.DataFormat = _state.IsMpeg2() ? CodecID.Mpeg2System : CodecID.Mpeg1System; dataBlockBuilder.IsFullFile = IsFullFile(); dataBlockBuilder.IsFragmented = _state.IsFragmented; // Trim zero byte stuffing from last header (if any) if (_state.LastHeaderZeroByteStuffing > 0) { dataBlockBuilder.EndOffset = endOffset - _state.LastHeaderZeroByteStuffing; } foreach (ushort streamId in _state.Streams.StreamIds) { IDataPacket streamData = _state.Streams[streamId].GetStreamData(); if (streamData != null) { string name = GetStreamName(streamId); if (name != null) { ICodecStreamBuilder codecStreamBuilder = dataBlockBuilder.AddCodecStream(); codecStreamBuilder.Name = name; codecStreamBuilder.DataFormat = name.StartsWith("Video") ? CodecID.Mpeg2Video : CodecID.Unknown; codecStreamBuilder.StreamNumber = streamId; codecStreamBuilder.Data = streamData; codecStreamBuilder.AbsoluteStartOffset = codecStreamBuilder.Data.StartOffset; } } } return(true); }
/// <summary> /// This method looks for the beginning of an MPEG-4 header and if one is found it will parse it /// by calling Parser.Parse(). /// </summary> override public IDataBlock DetectData(IDataReader dataReader, IDataBlockBuilder dataBlockBuilder, IScanContext context) { if (ReferenceHeaders != null) { var referenceHeaders = new Dictionary <IDataPacket, VideoObjectLayer>(); foreach (IReferenceHeader header in ReferenceHeaders) { IInputFile headerFile = context.CreateReferenceHeaderFile(header); using (var parser = new Mpeg4Parser(new BitStreamDataReader(headerFile.CreateDataReader()))) { Mpeg4Header root; while (parser.ParseRoot(root = new Mpeg4Header(context.Detectors), parser.Length)) { VideoObjectLayer vol = root.FindChild(Mpeg4HeaderName.VideoObjectLayer, true) as VideoObjectLayer; if (vol != null) { referenceHeaders[headerFile.CreateDataPacket()] = vol; } } } } context.ReferenceHeader = referenceHeaders; } return(Carve(dataReader, dataBlockBuilder, context)); }
private IDataBlock DetectData1(IDataReader dataReader, IDataBlockBuilder dataBlockBuilder, IScanContext context) { if ((dataReader.Position + 51) > dataReader.Length) { return(null); } IResultNode root = new MockResult(this); IResultNode parent = root; int i = (int)(dataReader.GetDataPacket(0, 1).StartOffset + (dataReader.Position) / 51); for (int j = 0; j < 3; j++) { long offset = dataReader.Position; const long length = 17; parent = new MockResult(parent, dataReader, offset, length, "result: " + i + ", " + j); dataReader.Position += length; } context.Results = root; var firstChild = ((MockResult)context.Results.Children[0]); dataBlockBuilder.StartOffset = firstChild.Offset; var lastChild = ((MockResult)context.Results.GetLastDescendant()); dataBlockBuilder.EndOffset = (lastChild.Offset + lastChild.Length); return(dataBlockBuilder.Build()); }
public void EqualsDifferentDataFormat() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.DataFormat = CodecID.Mpeg1System; Assert.IsFalse(_dataBlock1.Equals(dataBlockBuilder.Build())); }
public void BuildEndOffsetBeforeStartOffset() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); dataBlockBuilder.EndOffset = (StartOffset1 - 1); dataBlockBuilder.Build(); }
override public IDataBlock DetectData(IDataReader dataReader, IDataBlockBuilder dataBlockBuilder, IScanContext context) { AsfObject root = new AsfObject(context.Detectors); // Try to parse a contiguous block of ASF objects using (AsfParser parser = new AsfParser(new ByteStreamDataReader(dataReader, Endianness.Little))) { if (!parser.ParseRoot(root, dataReader.Length)) { dataReader.Position = dataReader.Length; return(null); } // Synchronize the position of the data reader dataReader.Position = parser.Position; } // Trim trailing unknown, padding byte or large unparsable ASF objects AsfObject lastAsfObject = root.LastHeader; while (lastAsfObject.IsUnknown && lastAsfObject.Parent != null) { if (lastAsfObject.RelativeEndOffset == ((AsfObject)lastAsfObject.Parent).RelativeEndOffset) { break; // Last child perfectly aligned with parent object } lastAsfObject.Parent.RemoveChild(lastAsfObject); lastAsfObject = root.LastHeader; } if ((dataReader.State == DataReaderState.Cancelled) || (root.Children.Count == 0) || (root.Children.Count == 1 && !root.FirstChild.HasChildren())) // Discard data blocks of only 1 ASF object { // Rewind data reader dataReader.Position = lastAsfObject.Offset + lastAsfObject.Length; // != lastHeader.RelativeEndOffset; !!! return(null); } context.Results = root; dataBlockBuilder.DataFormat = root.DataFormat; var firstChild = ((AsfObject)root.Children[0]); dataBlockBuilder.StartOffset = firstChild.Offset; var lastChild = ((AsfObject)root.GetLastDescendant()); var endOffset = (lastChild.Offset + lastChild.Length); dataBlockBuilder.EndOffset = endOffset; CodecStream codecStream = new CodecStream(root); codecStream.CreateCodecStreams(dataBlockBuilder); dataReader.Position = endOffset; return(dataBlockBuilder.Build()); }
public CarverState(IReaderState readerState, IDataBlockCarver dataBlockCarver, IResultMetadata resultMetadata, IDataReader dataReader, IDataBlockBuilder dataBlockBuilder) { _readerState = readerState; _dataBlockCarver = dataBlockCarver; _resultMetadata = resultMetadata; _dataReader = dataReader; _dataBlockBuilder = dataBlockBuilder; }
/// <summary> /// This method looks for the beginning of an NAL unit and if one is found it will parse it /// by calling Parser.Parse(). /// </summary> public IDataBlock DetectData(IDataReader dataReader, IDataBlockBuilder dataBlockBuilder, IScanContext context) { if (ReferenceHeaders != null) { BuildReferenceHeaders(context, dataBlockBuilder); } return(_carver.Carve(new BitStreamDataReader(dataReader), dataBlockBuilder, context)); }
private IDataBlockBuilder CreateBuilder(IInputFile file) { IDataBlockBuilder builder = TestFramework.CreateDataBlockBuilder(); builder.Detectors = new[] { _detector }; builder.InputFile = file; return(builder); }
public void Equals() { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder1(); Assert.IsTrue(_dataBlock1.Equals(dataBlockBuilder.Build())); Assert.IsFalse(_dataBlock1.Equals(_dataBlock2)); Assert.IsFalse(_dataBlock2.Equals(_dataBlock1)); }
private IDataBlockBuilder CreateDataBlockBuilder2() { IDataBlockBuilder dataBlockBuilder2 = TestFramework.CreateDataBlockBuilder(); dataBlockBuilder2.DataFormat = CodecID.Avi; dataBlockBuilder2.Detectors = new[] { _detector2 }; dataBlockBuilder2.InputFile = _inputFile2; dataBlockBuilder2.StartOffset = StartOffset2; dataBlockBuilder2.EndOffset = EndOffset2; dataBlockBuilder2.IsFullFile = true; return(dataBlockBuilder2); }
private IDataBlockBuilder CreateDataBlockBuilder1() { IDataBlockBuilder dataBlockBuilder1 = TestFramework.CreateDataBlockBuilder(); dataBlockBuilder1.DataFormat = CodecID.Mpeg2System; dataBlockBuilder1.Detectors = new[] { _detector1 }; dataBlockBuilder1.InputFile = _inputFile1; dataBlockBuilder1.StartOffset = StartOffset1; dataBlockBuilder1.EndOffset = EndOffset1; dataBlockBuilder1.IsFullFile = false; return(dataBlockBuilder1); }
private static void AddUnknownCodecStream(IDataBlockBuilder dataBlockBuilder, ICodecStream completeCodecStream) { ICodecStreamBuilder relativeCodecStreamBuilder = dataBlockBuilder.AddCodecStream(); relativeCodecStreamBuilder.StreamNumber = completeCodecStream.StreamNumber; relativeCodecStreamBuilder.Name = completeCodecStream.Name; relativeCodecStreamBuilder.DataFormat = CodecID.Unknown; relativeCodecStreamBuilder.Detector = new UnknownFormatDetector(); relativeCodecStreamBuilder.Data = completeCodecStream.InputFile.CreateDataPacket().GetSubPacket(0L, completeCodecStream.Length); relativeCodecStreamBuilder.IsFragmented = false; relativeCodecStreamBuilder.AbsoluteStartOffset = completeCodecStream.AbsoluteStartOffset; }
internal static IDataBlock CreateDataBlock(IDetector detector, IDataPacket data, bool isFullFile, IDataBlock lastDataBlock) { IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder(); dataBlockBuilder.DataFormat = CodecID.Unknown; dataBlockBuilder.Detectors = new[] { detector }; dataBlockBuilder.InputFile = data.InputFile; dataBlockBuilder.StartOffset = data.StartOffset; dataBlockBuilder.EndOffset = data.EndOffset; dataBlockBuilder.IsFullFile = isFullFile; dataBlockBuilder.IsFragmented = false; return(dataBlockBuilder.Build()); }
private static IDataBlock Carve(IDataReader dataReader, IDataBlockBuilder dataBlockBuilder, IScanContext context) { // Try to parse a contiguous block of headers using (var parser = new Mpeg4Parser(new BitStreamDataReader(dataReader))) { if (context.ReferenceHeader is Dictionary <IDataPacket, VideoObjectLayer> ) { parser.ReferenceHeaders = context.ReferenceHeader as Dictionary <IDataPacket, VideoObjectLayer>; } Mpeg4Header root; while (parser.ParseRoot(root = new Mpeg4Header(context.Detectors), dataReader.Length)) { Mpeg4Header lastHeader = root.LastHeader; if (lastHeader.ZeroByteStuffing > 0) { lastHeader.TrimZeroByteStuffing(parser); } // Discard results that do not contain a VOP, short video VOP or VOL. // Discard data blocks of only one header that is not a H.263 Short Header VOP. // The Short Header VOP counts for two headers because it is hard to correctly // parse a Short Header VOP from random bits. var requiredMpeg4Headers = new[] { Mpeg4HeaderName.VideoObjectLayer, Mpeg4HeaderName.Vop, Mpeg4HeaderName.VopWithShortHeader }; if (RequiredHeaderCount(root) && root.ContainsChildren(requiredMpeg4Headers, true) && RequiredShortHeaderCount(root)) { context.Results = root; dataBlockBuilder.DataFormat = root.DataFormat; var firstChild = ((Mpeg4Header)root.Children[0]); dataBlockBuilder.StartOffset = firstChild.Offset; var lastChild = ((Mpeg4Header)root.GetLastDescendant()); var endOffset = (lastChild.Offset + lastChild.Length); dataBlockBuilder.EndOffset = endOffset; dataReader.Position = endOffset; if (parser.ReferenceHeader != null) { dataBlockBuilder.ReferenceHeaderOffset = parser.ReferenceHeaderPosition - firstChild.Offset; dataBlockBuilder.ReferenceHeader = parser.ReferenceHeader; } return(dataBlockBuilder.Build()); } RewindParser(parser, lastHeader); } } dataReader.Position = dataReader.Length; return(null); // Nothing detected! }
private void AddRelativeCodecStream(IDataBlockBuilder dataBlockBuilder, IFragment codecStreamFragment) { ICodecStreamBuilder relativeCodecStreamBuilder = dataBlockBuilder.AddCodecStream(); relativeCodecStreamBuilder.StreamNumber = _completeCodecStream.StreamNumber; relativeCodecStreamBuilder.Name = _completeCodecStream.Name; relativeCodecStreamBuilder.DataFormat = codecStreamFragment.DataFormat; relativeCodecStreamBuilder.Detector = codecStreamFragment.Detectors.FirstOrDefault(); relativeCodecStreamBuilder.Data = _completeCodecStream.InputFile.CreateDataPacket().GetSubPacket(codecStreamFragment.StartOffset, codecStreamFragment.Length); relativeCodecStreamBuilder.IsFragmented = codecStreamFragment.IsFragmented; relativeCodecStreamBuilder.AbsoluteStartOffset = _completeCodecStream.AbsoluteStartOffset + codecStreamFragment.StartOffset; relativeCodecStreamBuilder.ReferenceHeaderOffset = codecStreamFragment.ReferenceHeaderOffset; relativeCodecStreamBuilder.ReferenceHeader = codecStreamFragment.ReferenceHeader; }