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 IList <DataBlockVerification> VerifyScanOfFragmented(string fileName) { if (String.IsNullOrEmpty(_fileNameProject)) { Assert.Fail("Incorrect Test Setup:WithProjectFile has not been called."); } if (!File.Exists(fileName)) { Assert.Fail("Incorrect Test Setup:No file exists at " + Path.GetFullPath(fileName)); } if (_videoDetector == null) { Assert.Fail("Incorrect Test Setup:WithDetector has not been called."); } File.Delete(_fileNameProject); // Scan test file IInputFile scannedFile = ScanFile(fileName); var blocks = _project.GetDataBlocks(scannedFile); var verifyers = new List <IDataBlock>(blocks).ConvertAll(block => { var result = TestFramework.GetResults(block); var descr = TestFramework.GetDescriptionText(result); return(new DataBlockVerification(block, result, "fragment " + block.FragmentIndex + " detected using " + (_systemDetector == null ? "" : _systemDetector.Name + " and ") + _videoDetector.Name + ", containing Results:" + descr)); }); return(verifyers); }
public void SetUp() { File.Delete(ProjectPath); _mockRepository = new MockRepository(); _inputFile1 = MockRepository.GenerateStub <IInputFile>(); _inputFile2 = MockRepository.GenerateStub <IInputFile>(); _detector1 = MockRepository.GenerateStub <IDetector>(); _detector2 = MockRepository.GenerateStub <IDetector>(); _dataBlock1 = MockRepository.GenerateStub <IDataBlock>(); _dataBlock2 = MockRepository.GenerateStub <IDataBlock>(); _dataBlock3 = MockRepository.GenerateStub <IDataBlock>(); _columnInfo1 = MockRepository.GenerateStub <IColumnInfo>(); _columnInfo2 = MockRepository.GenerateStub <IColumnInfo>(); _updatedColumnInfo = MockRepository.GenerateStub <IColumnInfo>(); _createInputFile = MockRepository.GenerateStub <Creator <IInputFile, IProject, string> >(); _inputFile1.Stub(x => x.Name).Return(DummyFileName); _inputFile1.Stub(x => x.Length).Return(DummyFileLength); _inputFile2.Stub(x => x.Name).Return(EmptyFileName); _inputFile2.Stub(x => x.Length).Return(EmptyFileLength); _dataBlock1.Stub(x => x.InputFile).Return(_inputFile1); _dataBlock2.Stub(x => x.InputFile).Return(_inputFile2); _dataBlock3.Stub(x => x.InputFile).Return(_inputFile2); _columnInfo1.Stub(x => x.Name).Return(ColumnName1); _columnInfo1.Stub(x => x.Width).Return(ColumnWidth1); _columnInfo2.Stub(x => x.Name).Return(ColumnName2); _columnInfo2.Stub(x => x.Width).Return(ColumnWidth2); _project = new Project(_createInputFile, ProjectPath); _createInputFile.Stub(x => x(_project, FileName1)).Return(_inputFile1); _createInputFile.Stub(x => x(_project, FileName2)).Return(_inputFile2); }
public void TestReaderGetDataBlocksVerifyContents() { IInputFile inputFile = _project.GetInputFiles()[0]; IList <IDataBlock> dataBlocks = _project.GetDataBlocks(inputFile); Assert.AreEqual(inputFile, dataBlocks[0].InputFile, "DataBlock.InputFile"); Assert.AreEqual(0, dataBlocks[0].StartOffset, "DataBlock.StartOffset"); Assert.AreEqual(268, dataBlocks[0].Length, "DataBlock.Length"); Assert.AreEqual(false, dataBlocks[0].IsFullFile, "DataBlock.IsFullFile"); IResultNode results = TestFramework.GetResults(dataBlocks[0]); Assert.AreEqual(1, results.Children[0].Length, "DataBlock.StartResult.Length"); Assert.AreEqual("correct type 1", results.Children[0].Name, "DataBlock.StartResult.Name"); Assert.AreEqual(true, results.Children[0].Children != null && results.Children[0].Children.Count > 0, "DataBlock.StartResult.HasChildren"); Assert.AreEqual(2, results.Children[0].Attributes.Count, "DataBlock.StartResult.Attributes.Count"); Assert.AreEqual(inputFile, dataBlocks[1].InputFile, "DataBlock.InputFile"); Assert.AreEqual(517, dataBlocks[1].StartOffset, "DataBlock.StartOffset"); Assert.AreEqual(1, dataBlocks[1].Length, "DataBlock.Length"); Assert.AreEqual(true, dataBlocks[1].IsFullFile, "DataBlock.IsFullFile"); results = TestFramework.GetResults(dataBlocks[1]); Assert.AreEqual(1, results.Children[0].Length, "DataBlock.StartResult.Length"); Assert.AreEqual("correct type 1", results.Children[0].Name, "DataBlock.StartResult.Name"); Assert.AreEqual(false, results.Children[0].Children != null && results.Children[0].Children.Count > 0, "DataBlock.StartResult.HasChildren"); Assert.AreEqual(2, results.Children[0].Attributes.Count, "DataBlock.StartResult.Attributes.Count"); }
public void TestWriteDataBlockFile1() { string outputFilePath = string.Format("{0}{1}", _testDataFile1, @"_TestDefraser.MockDetectorSave_0000000000000000-0000000000000033.dat"); try { IInputFile inputFile = Util.FindInputFile(_project1.GetInputFiles(), _testDataFile1); IList <IDataBlock> dataBlocks = _project1.GetDataBlocks(inputFile); TestFramework.SaveAsSeparateFiles(new List <object> { dataBlocks[0] }, TestFilesPath); byte[] contents = new byte[51]; Array.Copy(_fullFile1, contents, 51); foreach (FileInfo fi in new DirectoryInfo(TestFilesPath).GetFiles()) { Console.WriteLine(fi); } Util.AssertArrayEqualsFile(contents, outputFilePath); } finally { if (File.Exists(outputFilePath)) { File.Delete(outputFilePath); } } }
public async Task <IUpdates> SendUploadedDocument( IInputPeer peer, IInputFile file, string caption, string mimeType, TVector <IDocumentAttribute> attributes) { EnsureUserAuthorized(); return(await SenderService.SendRequestAsync(new RequestSendMedia { RandomId = TlHelpers.GenerateRandomLong(), Background = false, ClearDraft = false, Media = new TInputMediaUploadedDocument { File = file, Caption = caption, MimeType = mimeType, Attributes = attributes }, Peer = peer }).ConfigureAwait(false)); }
public static async Task <string> UploadFileAsync(IInputFile file) { if (file == null || string.IsNullOrEmpty(file.Path)) { _logger.Error("The file or the path of the file does not exist."); Environment.Exit(0); } string responseJson = string.Empty; try { using (var client = new HttpClient()) using (var fileStream = File.Open(file.Path, FileMode.Open, FileAccess.Read)) { client.DefaultRequestHeaders.Add("apikey", _apikey); var response = await client.PostAsync(_fileUrl, new StreamContent(fileStream)); response.EnsureSuccessStatusCode(); responseJson = await response.Content.ReadAsStringAsync(); } } catch (Exception ex) { _logger.Error(ex.Message); Environment.Exit(0); } return(responseJson); }
public static async Task <string> CheckHashAsync(IInputFile file) { if (file == null || string.IsNullOrEmpty(file.Hash)) { _logger.Error("The file or the hash value of the file does not exist."); Environment.Exit(0); } string responseJson = string.Empty; using (var client = new HttpClient()) { client.DefaultRequestHeaders.Add("apikey", _apikey); var url = Path.Combine(_hashLookupUrl, file.Hash); try { var response = await client.GetAsync(url); //Exception will be thrown when status codes do not represent success. response.EnsureSuccessStatusCode(); responseJson = await response.Content.ReadAsStringAsync(); } catch (Exception ex) { _logger.Error(ex.Message); Environment.Exit(0); } } return(responseJson); }
private static double GetScanRate(IInputFile inputFile) { double fileSizeInMbs = (double)inputFile.Length / (1024 * 1024); double seconds = 0.001 * GetScanDuration(inputFile).TotalMilliseconds; return(fileSizeInMbs / seconds); }
private int SaveItem(object item, IDataReaderPool dataReaderPool, string path, OverallProgressReporter overallProgressReporter, HandledContainers handledContainers, bool createForensicIntegrityLog) { IInputFile inputFile = item as IInputFile; if (inputFile != null) { return(SaveInputFile(inputFile, dataReaderPool, path, overallProgressReporter, handledContainers, createForensicIntegrityLog)); } IDataBlock dataBlock = item as IDataBlock; if (dataBlock != null) { return(SaveDataBlock(dataBlock, dataReaderPool, path, overallProgressReporter, handledContainers, createForensicIntegrityLog)); } ICodecStream codecStream = item as ICodecStream; if (codecStream != null) { path = string.Format("{0}__{1}", path, ReplaceIllegalPathCharactersByUnderscore(codecStream.Name)); return(SaveCodecStream(codecStream, dataReaderPool, path, overallProgressReporter, handledContainers, createForensicIntegrityLog)); } return(0); // TODO: is this an error? }
internal DataBlock(DataBlockBuilder builder) { _appendDataPackets = builder._appendDataPackets; _dataFormat = builder.DataFormat; _detectors = builder.Detectors; _inputFile = builder.InputFile; _startOffset = builder.StartOffset; _endOffset = builder.EndOffset; _isFullFile = builder.IsFullFile; _referenceHeaderOffset = builder.ReferenceHeaderOffset; _referenceHeader = builder.ReferenceHeader; _codecStreams = builder.BuildCodecStreams(this); IsFragmented = builder.IsFragmented; // Check for previous fragment and connect if one exists IFragment previousFragment = builder.PreviousFragment; if ((previousFragment != null) && previousFragment.IsFragmented) { if (previousFragment.FragmentContainer == null) { previousFragment.FragmentContainer = new FragmentContainer(); previousFragment.FragmentContainer.Add(previousFragment); } FragmentContainer = previousFragment.FragmentContainer; FragmentContainer.Add(this); FragmentIndex = previousFragment.FragmentIndex + 1; } }
/// <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 void ScanFile(string codecDetector) { // Locate detectors TestFramework.DetectorFactory.Initialize("."); IDetector[] containerDetectors = new IDetector[] { Util.FindDetector(TestFramework.DetectorFactory.ContainerDetectors, "MPEG-1/2 Systems"), Util.FindDetector(TestFramework.DetectorFactory.ContainerDetectors, "3GPP/QT/MP4") }; IDetector[] codecDetectors = new IDetector[] { Util.FindDetector(TestFramework.DetectorFactory.CodecDetectors, codecDetector) }; List <IDetector> detectors = new List <IDetector>(); detectors.AddRange(containerDetectors); detectors.AddRange(codecDetectors); // Scan test file (1) _testFile1 = TestFramework.DetectData(containerDetectors, codecDetectors, _testProject1, FileName3GP); Array.Reverse(containerDetectors); // Scan test file (2) _testFile2 = TestFramework.DetectData(containerDetectors, codecDetectors, _testProject2, FileName3GP); }
private static bool CheckCodecDetectorResultForFile(IInputFile detectedFile, CodecID selectedCodec) { IList <IDataBlock> dataBlocks = detectedFile.Project.GetDataBlocks(detectedFile); foreach (IDataBlock fileDataBlock in dataBlocks) { if (fileDataBlock.CodecStreams.Count > 0) { foreach (ICodecStream codecStream in fileDataBlock.CodecStreams) { if (codecStream.DataFormat != CodecID.Unknown) { if (CheckDetectors(codecStream.Detectors, selectedCodec)) { return(true); } } } } else if (fileDataBlock.DataFormat != CodecID.Unknown) { if (CheckDetectors(fileDataBlock.Detectors, selectedCodec)) { return(true); } } } return(false); }
public IDataReader GetDataReader(IInputFile inputFile) { if (inputFile == null) { throw new ArgumentNullException("inputFile"); } IDataReader dataReader; if (_dataReaders.TryGetValue(inputFile, out dataReader)) { return(dataReader); } dataReader = new FileDataReader(new DataPacket(inputFile)); // Add buffering decorator dataReader = new BufferedDataReader(dataReader, BufferSize); // Add progress reporting decorator IProgressReporter progressReporter = new FileScannerProgressReporter(_fileScanner, dataReader.Length); dataReader = new ProgressDataReader(dataReader, progressReporter); _dataReaders.Add(inputFile, dataReader); return(dataReader); }
private IDataPacket CreateH264StartCodePrefixDataPacket(IProject project) { string defraserDirectory = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location); IInputFile inputFile = _createInputFile(project, Path.Combine(defraserDirectory, "StartCodePrefix.h264")); return(inputFile.CreateDataPacket()); }
/// <inheritdoc /> public async Task <IUpdates> SendUploadedDocumentAsync(IInputPeer peer, IInputFile document, string mimeType, IReadOnlyList <IDocumentAttribute> attributes, string message, [AllowNull] IInputFile thumb = null, CancellationToken cancellationToken = default(CancellationToken)) { ClientSettings.EnsureUserAuthorized(); var request = new RequestSendMedia { RandomId = Random.NextLong(), Background = false, ClearDraft = false, Message = message, Media = new TInputMediaUploadedDocument { File = document, MimeType = mimeType, Thumb = thumb, Attributes = new TVector <IDocumentAttribute>(attributes.ToArray()) }, Peer = peer }; return(await RequestSender.SendRequestAsync(request, cancellationToken).ConfigureAwait(false)); }
public void SetUp() { File.Delete(ProjectPath); _mockRepository = new MockRepository(); _inputFile1 = MockRepository.GenerateStub <IInputFile>(); _inputFile2 = MockRepository.GenerateStub <IInputFile>(); _detector1 = MockRepository.GenerateStub <IDetector>(); _detector2 = MockRepository.GenerateStub <IDetector>(); _dataBlock1 = MockRepository.GenerateStub <IDataBlock>(); _dataBlock2 = MockRepository.GenerateStub <IDataBlock>(); _dataBlock3 = MockRepository.GenerateStub <IDataBlock>(); _columnInfo1 = MockRepository.GenerateStub <IColumnInfo>(); _columnInfo2 = MockRepository.GenerateStub <IColumnInfo>(); _updatedColumnInfo = MockRepository.GenerateStub <IColumnInfo>(); _projectChangedEventHandler = _mockRepository.StrictMock <EventHandler <ProjectChangedEventArgs> >(); _propertyChangedEventHandler = _mockRepository.StrictMock <PropertyChangedEventHandler>(); _createInputFile = MockRepository.GenerateStub <Creator <IInputFile, IProject, string> >(); _inputFile1.Stub(x => x.Name).Return(FileName1); _inputFile2.Stub(x => x.Name).Return(FileName2); _dataBlock1.Stub(x => x.InputFile).Return(_inputFile1); _dataBlock2.Stub(x => x.InputFile).Return(_inputFile2); _dataBlock3.Stub(x => x.InputFile).Return(_inputFile2); _columnInfo1.Stub(x => x.Name).Return(ColumnName1); _columnInfo1.Stub(x => x.Width).Return(ColumnWidth1); _columnInfo2.Stub(x => x.Name).Return(ColumnName2); _columnInfo2.Stub(x => x.Width).Return(ColumnWidth2); _project = new Project(_createInputFile, ProjectPath); _createInputFile.Stub(x => x(_project, FileName1)).Return(_inputFile1); _createInputFile.Stub(x => x(_project, FileName2)).Return(_inputFile2); }
public void TestSaveRandomResultsMultiProject() { IInputFile inputFile1 = Util.FindInputFile(_project1.GetInputFiles(), _testDataFile1); IInputFile inputFile2 = Util.FindInputFile(_project1.GetInputFiles(), _testDataFile2); IInputFile inputFile3 = Util.FindInputFile(_project2.GetInputFiles(), _testDataFile3); IList <IDataBlock> dataBlocks1 = _project1.GetDataBlocks(inputFile1); IList <IDataBlock> dataBlocks2 = _project1.GetDataBlocks(inputFile2); IList <IDataBlock> dataBlocks3 = _project2.GetDataBlocks(inputFile3); IResultNode results12 = TestFramework.GetResults(dataBlocks1[2]); IResultNode results20 = TestFramework.GetResults(dataBlocks2[0]); IResultNode results30 = TestFramework.GetResults(dataBlocks3[0]); IResultNode[] results = new IResultNode[5]; results[0] = results30.Children[4].ShallowCopy(); results[1] = results20.Children[0].ShallowCopy(); results[2] = results12.Children[0].ShallowCopy(); results[3] = results30.Children[1].ShallowCopy(); results[4] = results20.Children[0].ShallowCopy(); TestFramework.WriteResults(results, _testOutputFile); byte[] contents = new byte[57]; Array.Copy(_fullFile3, 60, contents, 0, 15); Array.Copy(_fullFile2, 0, contents, 15, 5); Array.Copy(_fullFile1, 102, contents, 20, 17); Array.Copy(_fullFile3, 15, contents, 37, 15); Array.Copy(_fullFile2, 0, contents, 52, 5); Util.AssertArrayEqualsFile(contents, _testOutputFile); }
private static string GetFileName(object item) { IInputFile inputFile = item as IInputFile; if (inputFile != null) { return(Path.GetFileName(inputFile.Name)); } IDataBlock containerStream = item as IDataBlock; if (containerStream != null) { return(Path.GetFileName(containerStream.InputFile.Name)); } ICodecStream codecStream = item as ICodecStream; if (codecStream != null) { return(Path.GetFileName(codecStream.InputFile.Name)); } Debug.Fail("item should be of type IInputFile, IDataBlock or ICodecStream"); return(string.Empty); }
public void TestWriteRandomResultsFile1() { IInputFile inputFile = Util.FindInputFile(_project1.GetInputFiles(), _testDataFile1); IList <IDataBlock> dataBlocks = _project1.GetDataBlocks(inputFile); IResultNode results0 = TestFramework.GetResults(dataBlocks[0]); IResultNode results1 = TestFramework.GetResults(dataBlocks[1]); IResultNode results2 = TestFramework.GetResults(dataBlocks[2]); IResultNode results3 = TestFramework.GetResults(dataBlocks[3]); IResultNode results4 = TestFramework.GetResults(dataBlocks[4]); IResultNode[] results = new IResultNode[5]; results[0] = results0.Children[0].ShallowCopy(); results[1] = results2.Children[0].ShallowCopy(); results[2] = results4.Children[0].ShallowCopy(); results[3] = results3.Children[0].ShallowCopy(); results[4] = results1.Children[0].ShallowCopy(); TestFramework.WriteResults(results, _testOutputFile); byte[] contents = new byte[85]; Array.Copy(_fullFile1, 0, contents, 0, 17); Array.Copy(_fullFile1, 102, contents, 17, 17); Array.Copy(_fullFile1, 204, contents, 34, 17); Array.Copy(_fullFile1, 153, contents, 51, 17); Array.Copy(_fullFile1, 51, contents, 68, 17); Util.AssertArrayEqualsFile(contents, _testOutputFile); }
private void ProjectManager_ProjectChanged(object sender, ProjectChangedEventArgs e) { switch (e.Type) { case ProjectChangedType.Closed: ClearDefaultCodecHeaders(); break; case ProjectChangedType.FileDeleted: IInputFile inputFile = e.Item as InputFile; if (inputFile != null) { List <CodecID> toRemoveKeys = new List <CodecID>(); foreach (KeyValuePair <CodecID, IResultNode> keyPair in _codecHeaderSource) { if (keyPair.Value != null && keyPair.Value.InputFile == inputFile) { toRemoveKeys.Add(keyPair.Key); } } foreach (CodecID codecId in toRemoveKeys) { RemoveDefaultCodecHeader(codecId); } } break; } }
public static void DetectFile(string filePath, string projectFileName) { var builder = new ContainerBuilder(); builder.RegisterModule(new FrameworkModule()); builder.RegisterModule(new DataContractSerializerModule()); using (var container = builder.Build()) { string detectorPath = ConfigurationManager.AppSettings.Get("Defraser.DetectorPath") ?? AppDomain.CurrentDomain.BaseDirectory; IDetectorFactory detectorFactory = container.Resolve <IDetectorFactory>(); detectorFactory.Initialize(detectorPath); File.Delete(projectFileName); ProjectManager projectManager = container.Resolve <ProjectManager>(); IProject project = projectManager.CreateProject(projectFileName, "Console", DateTime.Now, "Batch process"); IInputFile inputFile = project.AddFile(filePath, detectorFactory.ContainerDetectors.Union(detectorFactory.CodecDetectors)); IFileScanner fileScanner = container.Resolve <IFileScanner>(); fileScanner.ContainerDetectors = detectorFactory.ContainerDetectors; fileScanner.CodecDetectors = detectorFactory.CodecDetectors; fileScanner.DataBlockDetected += (s, e) => project.AddDataBlock(e.DataBlock); fileScanner.Scan(inputFile, container.Resolve <IProgressReporter>()); projectManager.SaveProject(project); projectManager.CloseProject(project); } }
public bool RunSearchHeader(IInputFile inputFile, CodecID codecId) { IProject project = inputFile.Project; IList <IDataBlock> dataBlocks = project.GetDataBlocks(inputFile); if (dataBlocks.Count > 0) { foreach (IDataBlock dataBlock in dataBlocks) { if (DataBlockHasCodec(dataBlock, codecId)) { if (dataBlock.CodecStreams.Count > 0) { return(SearchBlockOrStream(dataBlock.CodecStreams, SearchMode.CodecStream)); } else { return(SearchBlockOrStream(dataBlock, SearchMode.DataBlock)); } } } MessageBox.Show(this, "Selected codec stream was not found in file. Please select a different header source.", "Couldn't find detector.", MessageBoxButtons.OK, MessageBoxIcon.Error); Close(); } else { MessageBox.Show(this, "No datablocks are available. Please select a different header source.", "Couldn't detect keyframe.", MessageBoxButtons.OK, MessageBoxIcon.Error); Close(); } return(false); }
public virtual void TestFixtureSetup() { File.Delete(DataFileName); _fibonacci = new byte[DataFileSize]; Buffer = new byte[ReadBufferSize]; InputFile = MockRepository.GenerateStub <IInputFile>(); InputFile.Stub(x => x.Name).Return(DataFileName); InputFile.Stub(x => x.Length).Return(DataFileSize); // Generate fibonacci numbers (periodic function) _fibonacci[0] = 0; _fibonacci[1] = 1; for (int i = 2; i < _fibonacci.Length; i++) { _fibonacci[i] = (byte)(_fibonacci[i - 1] + _fibonacci[i - 2]); } // Write test data to file using (FileStream fileStream = new FileStream(DataFileName, FileMode.Create, FileAccess.Write, FileShare.None)) { fileStream.Write(_fibonacci, 0, _fibonacci.Length); fileStream.Flush(); } }
public void CountNumberOfParts(IEnumerable <object> items) { int codecStreamCount = 0; int containerStreamCount = 0; int uniqueStreamCount = 0; HashSet <IFragmentContainer> handledFragmentContainers = new HashSet <IFragmentContainer>(); HashSet <Pair <IFragmentContainer, string> > handledFragmentContainerStreams = new HashSet <Pair <IFragmentContainer, string> >(); foreach (object item in items) { IInputFile inputFile = item as IInputFile; IDataBlock containerStream = item as IDataBlock; ICodecStream codecStream = item as ICodecStream; if (inputFile != null) { IList <IDataBlock> dataBlocks = inputFile.Project.GetDataBlocks(inputFile); containerStreamCount += dataBlocks.Count; foreach (IDataBlock dataBlock in dataBlocks) { codecStreamCount += dataBlock.CodecStreams.Count; uniqueStreamCount += CountUniqueStreams(handledFragmentContainers, handledFragmentContainerStreams, dataBlock); } } else if (containerStream != null) { containerStreamCount++; codecStreamCount += containerStream.CodecStreams.Count; uniqueStreamCount += CountUniqueStreams(handledFragmentContainers, handledFragmentContainerStreams, containerStream); } else if (codecStream != null) { // Count the number of fragments for this codecStream. // The codec stream can be part of a fragmented codec stream // which on its turn can be part of a fragmented container stream if (codecStream.DataBlock.FragmentContainer != null) { foreach (IDataBlock containerFragment in codecStream.DataBlock.FragmentContainer) { codecStreamCount += CountCodecStreamFragments(containerFragment, codecStream.Name); } } else { codecStreamCount += CountCodecStreamFragments(codecStream.DataBlock, codecStream.Name); } if (FragmentedStreamAlreadySaved(handledFragmentContainers, handledFragmentContainerStreams, codecStream) == false) { uniqueStreamCount++; } } } // Progress is reported for each: // - codec stream (twice, once during DetectData and once during GetDataPacket) // - container stream and codec stream that is saved _partCount = codecStreamCount * 2 + containerStreamCount + uniqueStreamCount; }
public virtual void TestFixtureTeardown() { File.Delete(DataFileName); _fibonacci = null; Buffer = null; InputFile = null; }
private IDataBlockBuilder CreateBuilder(IInputFile file) { IDataBlockBuilder builder = TestFramework.CreateDataBlockBuilder(); builder.Detectors = new[] { _detector }; builder.InputFile = file; return(builder); }
private void ResetAllScanAttributes() { _activeScanFile = null; _currentDataBlocks = null; _currentDataBlockIndex = -1; _currentValidCodecStreams = null; _currentCodecStreamIndex = -1; }
public void TearDown() { _inputFile = null; _dataReader = null; _root = null; _header = null; _childHeader = null; _lastHeader = null; }
private async Task SetProfilePhoto(Telegram service, TelegramClient client, IInputFile inputFile) { var iPhoto = await client.Methods.PhotosUploadProfilePhotoAsync(new PhotosUploadProfilePhotoArgs { Caption = "", Crop = new InputPhotoCropAuto(), File = inputFile, GeoPoint = new InputGeoPointEmpty() }); var photo = iPhoto as PhotosPhoto; if (photo != null) { service.Dialogs.AddUsers(photo.Users); } var photoObj = photo.Photo as Photo; if (photoObj == null) { return; } await client.Methods.PhotosUpdateProfilePhotoAsync(new PhotosUpdateProfilePhotoArgs { Id = new InputPhoto { Id = photoObj.Id, }, Crop = new InputPhotoCropAuto() }); }
private void SendFile(VisualBubble bubble, IInputFile inputFile) { var inputPeer = GetInputPeer(bubble.Address, bubble.Party, bubble.ExtendedParty); var imageBubble = bubble as ImageBubble; var fileBubble = bubble as FileBubble; var audioBubble = bubble as AudioBubble; using (var client = new FullClientDisposable(this)) { if (imageBubble != null) { var iUpdates = TelegramUtils.RunSynchronously( client.Client.Methods.MessagesSendMediaAsync(new MessagesSendMediaArgs { Flags = 0, Peer = inputPeer, Media = new InputMediaUploadedPhoto { Caption = "", File = inputFile, }, RandomId = GenerateRandomId(), })); var messageId = GetMessageId(iUpdates); imageBubble.IdService = messageId; var updates = iUpdates as Updates; SendToResponseDispatcher(iUpdates, client.Client); } else if (fileBubble != null) { var documentAttributes = new List<IDocumentAttribute> { new DocumentAttributeFilename { FileName = fileBubble.FileName } }; var iUpdates = TelegramUtils.RunSynchronously( client.Client.Methods.MessagesSendMediaAsync(new MessagesSendMediaArgs { Flags = 0, Peer = inputPeer, Media = new InputMediaUploadedDocument { Attributes = documentAttributes, Caption = "", File = inputFile, MimeType = fileBubble.MimeType, }, RandomId = GenerateRandomId(), })); var messageId = GetMessageId(iUpdates); fileBubble.IdService = messageId; SendToResponseDispatcher(iUpdates, client.Client); } else if (audioBubble != null) { var documentAttributes = new List<IDocumentAttribute>(); if (audioBubble.Recording) { documentAttributes.Add(new DocumentAttributeAudio { Flags = 1024, Duration = (uint)audioBubble.Seconds, Voice = new True() }); } else if (audioBubble.FileName != null) { documentAttributes.Add(new DocumentAttributeAudio { Flags = 1, Duration = (uint)audioBubble.Seconds, Title = audioBubble.FileName }); } else { documentAttributes.Add(new DocumentAttributeAudio { Flags = 0, Duration = (uint)audioBubble.Seconds }); } var mimeType = Platform.GetMimeTypeFromPath(audioBubble.AudioPath); var inputMedia = new InputMediaUploadedDocument { Attributes = documentAttributes, Caption = "", File = inputFile, MimeType = mimeType, }; var media = new MessagesSendMediaArgs { Flags = 0, Media = inputMedia, Peer = inputPeer, RandomId = GenerateRandomId(), }; var iUpdates = TelegramUtils.RunSynchronously( client.Client.Methods.MessagesSendMediaAsync(media)); var messageId = GetMessageId(iUpdates); audioBubble.IdService = messageId; SendToResponseDispatcher(iUpdates, client.Client); } } }