private void LoadTemplates() { if (CaptureSettings.Instance().DEFAULT_TEMPLATE_PATH == "") { System.Windows.MessageBox.Show("No template path configured!"); } else { string fileName = CaptureSettings.Instance().DEFAULT_TEMPLATE_PATH; try { if (!File.Exists(fileName)) { System.Windows.MessageBox.Show("There is no file with templates for stones! Create one in contour settings!"); } else { using (FileStream fs = new FileStream(fileName, FileMode.Open)) CommonAttribService.DEFAULT_TEMPLATES = (Templates) new BinaryFormatter().Deserialize(fs); } } catch { System.Windows.MessageBox.Show("An error ocurred during template initialization"); } } }
/// <summary> /// Loads gradient colors /// </summary> private void LoadFadeColors() { // fade color path if (CaptureSettings.Instance().DEFAULT_FADECOLOR_PATH == "") { CaptureSettings.Instance().DEFAULT_FADECOLOR_PATH = "colors.xml"; } string fadeName = CaptureSettings.Instance().DEFAULT_FADECOLOR_PATH; try { XmlSerializer serializer = new XmlSerializer(typeof(HashSet <FadeColor>), new Type[] { typeof(FadeColor) }); StreamReader reader = new StreamReader(fadeName); // we need to order the colors as they are not serialized in order LinkedList <FadeColor> output = new LinkedList <FadeColor>(); HashSet <FadeColor> temp = (HashSet <FadeColor>)serializer.Deserialize(reader); foreach (FadeColor fade in temp.OrderBy(fadec => fadec.position)) { output.AddLast(fade); } CommonAttribService.DEFAULT_FADE_COLORS = output; reader.Close(); } catch { System.Windows.MessageBox.Show("An error ocurred during loading of color gradients"); } }
private CaptureSettings GetSettings() { var ret = new CaptureSettings(); ret.Inject = InjectMode; ret.AutoStart = AutoStart.Checked; ret.Executable = exePath.Text; ret.WorkingDir = RealWorkDir; ret.CmdLine = cmdline.Text; ret.Options.AllowFullscreen = AllowFullscreen.Checked; ret.Options.AllowVSync = AllowVSync.Checked; ret.Options.HookIntoChildren = HookIntoChildren.Checked; ret.Options.CaptureCallstacks = CaptureCallstacks.Checked; ret.Options.CaptureCallstacksOnlyDraws = CaptureCallstacksOnlyDraws.Checked; ret.Options.APIValidation = APIValidation.Checked; ret.Options.RefAllResources = RefAllResources.Checked; ret.Options.SaveAllInitials = SaveAllInitials.Checked; ret.Options.CaptureAllCmdLists = CaptureAllCmdLists.Checked; ret.Options.DelayForDebugger = (uint)DelayForDebugger.Value; ret.Options.VerifyMapWrites = VerifyMapWrites.Checked; return(ret); }
/// <summary> /// Click on openIcon will open a template from a file /// </summary> private void openTemplateImage_MouseUp(object sender, System.Windows.Input.MouseButtonEventArgs e) { OpenFileDialog ofd = new OpenFileDialog(); ofd.Filter = "Templates(*.bin)|*.bin"; if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK) { string fileName = ofd.FileName; CaptureSettings.Instance().DEFAULT_TEMPLATE_PATH = fileName; try { using (FileStream fs = new FileStream(fileName, FileMode.Open)) { // WARNING: here a default path and also a default template will change, if we open a new template Templates tmp = (Templates) new BinaryFormatter().Deserialize(fs); CommonAttribService.DEFAULT_TEMPLATES = tmp; captureWindow.Processor.templates = tmp; } } catch (Exception ex) { System.Windows.MessageBox.Show(ex.Message); } } }
private void SetSettings(CaptureSettings settings) { InjectMode = settings.Inject; workDirPath_Enter(null, null); exePath.Text = settings.Executable; workDirPath.Text = settings.WorkingDir; cmdline.Text = settings.CmdLine; workDirPath_Leave(null, null); AllowFullscreen.Checked = settings.Options.AllowFullscreen; AllowVSync.Checked = settings.Options.AllowVSync; HookIntoChildren.Checked = settings.Options.HookIntoChildren; CaptureCallstacks.Checked = settings.Options.CaptureCallstacks; CaptureCallstacksOnlyDraws.Checked = settings.Options.CaptureCallstacksOnlyDraws; APIValidation.Checked = settings.Options.APIValidation; RefAllResources.Checked = settings.Options.RefAllResources; SaveAllInitials.Checked = settings.Options.SaveAllInitials; DelayForDebugger.Value = settings.Options.DelayForDebugger; VerifyMapWrites.Checked = settings.Options.VerifyMapWrites; AutoStart.Checked = settings.AutoStart; if (settings.AutoStart) { TriggerCapture(); } }
public CaptureDialog(Core core, OnCaptureMethod captureCallback, OnInjectMethod injectCallback) { InitializeComponent(); exePath.Font = workDirPath.Font = cmdline.Font = pidList.Font = core.Config.PreferredFont; Icon = global::renderdocui.Properties.Resources.icon; vulkanLayerWarn.Visible = !Helpers.CheckVulkanLayerRegistration(); var defaults = new CaptureSettings(); defaults.Inject = false; m_CaptureCallback = captureCallback; m_InjectCallback = injectCallback; m_Core = core; workDirHint = true; workDirPath.ForeColor = SystemColors.GrayText; SetSettings(defaults); UpdateGlobalHook(); }
void InternalRun(CaptureSettings captureSettings, MediaFile outFile) { Reset(); if (type == CapturerType.Live) { ReadyToCapture = false; videowindow.Message = Catalog.GetString("Loading"); Capturer = App.Current.MultimediaToolkit.GetCapturer(); outputFile = outFile; settings = captureSettings; videowindow.Ratio = (float)outputFile.VideoWidth / outputFile.VideoHeight; Capturer.Error += OnError; Capturer.MediaInfo += HandleMediaInfo; Capturer.DeviceChange += OnDeviceChange; Capturer.ReadyToCapture += HandleReadyToCapture; Periods = new List <Period> (); if (videowindow.Ready) { Configure(); } else { delayStart = true; } } else { ReadyToCapture = true; } }
private void SetSettings(CaptureSettings settings) { InjectMode = settings.Inject; workDirPath_Enter(null, null); exePath.Text = settings.Executable; workDirPath.Text = settings.WorkingDir; cmdline.Text = settings.CmdLine; workDirPath_Leave(null, null); AllowFullscreen.Checked = settings.Options.AllowFullscreen; AllowVSync.Checked = settings.Options.AllowVSync; HookIntoChildren.Checked = settings.Options.HookIntoChildren; CaptureCallstacks.Checked = settings.Options.CaptureCallstacks; CaptureCallstacksOnlyDraws.Checked = settings.Options.CaptureCallstacksOnlyDraws; DebugDeviceMode.Checked = settings.Options.DebugDeviceMode; RefAllResources.Checked = settings.Options.RefAllResources; SaveAllInitials.Checked = settings.Options.SaveAllInitials; DelayForDebugger.Value = settings.Options.DelayForDebugger; VerifyMapWrites.Checked = settings.Options.VerifyMapWrites; AutoStart.Checked = settings.AutoStart; if (settings.AutoStart) { TriggerCapture(); } }
/// <summary> /// Po nacteni hlavniho okna se inicializuje hlavni manazer, ktery se postara /// o zbytek inicializace; take se inicializuje manazer kamery /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Window_Loaded(object sender, RoutedEventArgs e) { // pokud loading timer uz nebezi, zrus loading okno if (!loadingTimer.Enabled) { loadingWindow.Close(); } // nacteni veskereho nastaveni z XML souboru CalibrationSettings.Instance().Load(); CaptureSettings.Instance().Load(); GraphicsSettings.Instance().Load(); PhysicSettings.Instance().Load(); CommonAttribService.mainWindow = this; // vytvoreni manazeru, ktery propoji funkcionalitu VSEM hlavnim modelum myManager = new WindowManager(); myManager.MyWindow = this; myManager.LoadDefaultValues(); myManager.ManageMainWindow(); CameraManager.Reinitialize(); }
public static void OpenProject(ProjectVM project, CaptureSettings props = null) { Log.Information($"Open project {project.ProjectType}"); dynamic settings = new ExpandoObject(); settings.Project = project; settings.CaptureSettings = props; if (project.ProjectType == ProjectType.FakeCaptureProject) { App.Current.StateController.MoveTo(FakeLiveProjectAnalysisState.NAME, settings, true); } else if (project.Model.IsFakeCapture) { App.Current.StateController.MoveTo(NewProjectState.NAME, project); } else if (project.ProjectType == ProjectType.FileProject || project.ProjectType == ProjectType.EditProject) { App.Current.StateController.MoveTo(ProjectAnalysisState.NAME, settings, true); } else { App.Current.StateController.MoveTo(LiveProjectAnalysisState.NAME, settings, true); } App.Current.EventsBroker.Publish(new OpenedProjectEvent { Project = project.Model }); }
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e) { CalibrationSettings.Instance().Save(); CaptureSettings.Instance().Save(); GraphicsSettings.Instance().Save(); PhysicSettings.Instance().Save(); }
public CameraCollectionViewCellDelegate(Func <CameraCollectionViewCell> getCameraCellFunc, CaptureSession captureSession, CaptureSettings captureSettings) { _getCameraCellFunc = getCameraCellFunc; _captureSession = captureSession; _captureSettings = captureSettings; }
public void OpenProject(Project project, ProjectType projectType, CaptureSettings props, EventsFilter filter, out IAnalysisWindow analysisWindow) { Log.Information("Open project"); analysisWindow = mainWindow.SetProject(project, projectType, props, filter); }
private void SetSettings(CaptureSettings settings) { InjectMode = settings.Inject; exePath.Text = settings.Executable; workDirPath.Text = settings.WorkingDir; cmdline.Text = settings.CmdLine; AllowFullscreen.Checked = settings.Options.AllowFullscreen; AllowVSync.Checked = settings.Options.AllowVSync; CacheStateObjects.Checked = settings.Options.CacheStateObjects; HookIntoChildren.Checked = settings.Options.HookIntoChildren; CaptureCallstacks.Checked = settings.Options.CaptureCallstacks; CaptureCallstacksOnlyDraws.Checked = settings.Options.CaptureCallstacksOnlyDraws; DebugDeviceMode.Checked = settings.Options.DebugDeviceMode; RefAllResources.Checked = settings.Options.RefAllResources; SaveAllInitials.Checked = settings.Options.SaveAllInitials; DelayForDebugger.Value = settings.Options.DelayForDebugger; AutoStart.Checked = settings.AutoStart; if (settings.AutoStart) { TriggerCapture(); } }
/// <summary> /// Reset of al settings /// </summary> private void resetBut_Click(object sender, RoutedEventArgs e) { CalibrationSettings.Instance().Restart(); CaptureSettings.Instance().Restart(); GraphicsSettings.Instance().Restart(); PhysicSettings.Instance().Restart(); }
#pragma warning restore 0169 public void Configure(CaptureSettings settings, IntPtr window_handle) { IntPtr err = IntPtr.Zero; EncodingQuality qual = settings.EncodingSettings.EncodingQuality; Device device = settings.Device; DeviceVideoFormat format = settings.Format; EncodingProfile enc; VideoStandard std; IntPtr outFile, sourceElement, deviceID; enc = settings.EncodingSettings.EncodingProfile; std = settings.EncodingSettings.VideoStandard; outFile = Marshaller.StringToPtrGStrdup(settings.EncodingSettings.OutputFile); sourceElement = Marshaller.StringToPtrGStrdup(device.SourceElement); deviceID = Marshaller.StringToPtrGStrdup(device.ID); gst_camera_capturer_configure(Handle, outFile, (int)settings.Device.DeviceType, sourceElement, deviceID, format.width, format.height, format.fps_n, format.fps_d, (int)enc.VideoEncoder, (int)enc.AudioEncoder, (int)enc.Muxer, qual.VideoQuality, qual.AudioQuality, settings.EncodingSettings.EnableAudio, std.Width, std.Height, window_handle, out err); Marshaller.Free(outFile); Marshaller.Free(sourceElement); Marshaller.Free(deviceID); if (err != IntPtr.Zero) { throw new GLib.GException(err); } }
/// <summary> /// Click on RESET - resets all settings /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void resetButton_Click(object sender, System.Windows.RoutedEventArgs e) { settingsLock = true; CaptureSettings.Instance().Restart(); SetDefaultValues(); settingsLock = false; }
public IAnalysisWindow SetProject(Project project, ProjectType projectType, CaptureSettings props, EventsFilter filter) { ExportProjectAction1.Sensitive = true; this.projectType = projectType; openedProject = project; if (projectType == ProjectType.FileProject) { Title = openedProject.Description.Title + " - " + Constants.SOFTWARE_NAME; } else { Title = Constants.SOFTWARE_NAME; } MakeActionsSensitive(true, projectType); if (projectType == ProjectType.FakeCaptureProject) { analysisWindow = new FakeAnalysisComponent(); } else { analysisWindow = new AnalysisComponent(); } SetPanel(analysisWindow as Widget); analysisWindow.SetProject(project, projectType, props, filter); return(analysisWindow); }
public CaptureSettings GetSettings() { CaptureSettings settings = CaptureSettings.Instance(); settings.Mode = (Mode.INSTRUMENTATION_CATEGORIES | Mode.INSTRUMENTATION_EVENTS); foreach (Flag flag in FlagSettings) { if (flag.IsEnabled) { settings.Mode = settings.Mode | flag.Mask; } } settings.SamplingFrequencyHz = (uint)SamplingFrequencyHz; settings.CpuGranularityLv = (uint)CpuGranularityLv; settings.GpuGranularityLv = (uint)GpuGranularityLv; settings.FrameLimit = (uint)FrameCountLimit.Value; settings.TimeLimitUs = (uint)(TimeLimitSec.Value * 1000000); settings.MaxSpikeLimitUs = (uint)(MaxSpikeLimitMs.Value * 1000); settings.MinFilterLimitUs = (uint)(MinFilterLimitMs.Value); settings.MaxFilterLimitUs = (uint)(MaxFilterLimitMs.Value); settings.MemoryLimitMb = 0; return(settings); }
public void SetCaptureSettings( CaptureSettings settings ) { Client.SetActiveChannels( settings.ActiveDigitalChannels.ToArray(), settings.ActiveAnalogChannels.ToArray() ); var all_sample_rates = GetAllSampleRates(); SampleRate target_sample_rate = new SampleRate() { DigitalSampleRate = settings.DigitalSampleRateHz, AnalogSampleRate = settings.AnalogSampleRateHz }; var found_sample_rate_pair = all_sample_rates.FirstOrDefault( x => x.Value.Any( y => y == target_sample_rate ) ); if( found_sample_rate_pair.Equals( default( KeyValuePair<PerformanceOption, List<SampleRate>> ) ) ) throw new Exception( "sample rate not possible" ); PerformanceOption perfomance_option = found_sample_rate_pair.Key; Client.SetPerformanceOption( perfomance_option ); Client.SetSampleRate( target_sample_rate ); Client.SetCaptureSeconds( settings.CaptureDurationS ); //trigger configure. List<Trigger> trigger_settings = new List<Trigger>(); settings.ActiveDigitalChannels.Sort(); // lowest to largest. foreach( int channel in settings.ActiveDigitalChannels ) { Trigger channel_trigger_setting = Trigger.None; if( settings.TriggerSettings.ContainsKey( channel ) ) channel_trigger_setting = settings.TriggerSettings[ channel ]; trigger_settings.Add( channel_trigger_setting ); } Client.SetTrigger( trigger_settings.ToArray(), settings.TriggerMinTimeS, settings.TriggerMaxTimeS ); //TODO: voltage level }
public Camera([NotNull] ILogger <Camera> logger, [NotNull] ILogger <CameraStream> streamLogger, [NotNull] CaptureSettings settings, [NotNull] Func <CaptureSettings, VideoCapture> createVideoCaptureFunc) { this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.streamLogger = streamLogger ?? throw new ArgumentNullException(nameof(streamLogger)); this.settings = settings ?? throw new ArgumentNullException(nameof(settings)); this.createVideoCaptureFunc = createVideoCaptureFunc ?? throw new ArgumentNullException(nameof(createVideoCaptureFunc)); this.errorObserver = new ErrorObserver(this); }
void OpenNewProject(Project project, ProjectType projectType, CaptureSettings captureSettings) { if (project != null) { Config.DatabaseManager.ActiveDB.AddProject(project); SetProject(project, projectType, captureSettings); } }
public void FixtureSetup() { mockList = new List <Mock> (); settings = new CaptureSettings(); settings.EncodingSettings = new EncodingSettings(); settings.EncodingSettings.EncodingProfile = EncodingProfiles.MP4; App.Current.HotkeysService = new HotkeysService(); GeneralUIHotkeys.RegisterDefaultHotkeys(); LMGeneralUIHotkeys.RegisterDefaultHotkeys(); var playerMock = new Mock <IVideoPlayer> (); playerMock.SetupAllProperties(); mockList.Add(playerMock); capturerMock = new Mock <ICapturer> (); capturerMock.SetupAllProperties(); mockList.Add(capturerMock); mtkMock = new Mock <IMultimediaToolkit> (); mtkMock.Setup(m => m.GetPlayer()).Returns(playerMock.Object); mtkMock.Setup(m => m.GetMultiPlayer()).Throws(new Exception()); mtkMock.Setup(m => m.GetCapturer()).Returns(capturerMock.Object); mtkMock.Setup(m => m.DiscoverFile(It.IsAny <string> (), It.IsAny <bool> ())) .Returns((string s, bool b) => new MediaFile { FilePath = s }); App.Current.MultimediaToolkit = mtkMock.Object; mockList.Add(mtkMock); gtkMock = new Mock <IGUIToolkit> (); gtkMock.SetupGet(o => o.DeviceScaleFactor).Returns(1.0f); gtkMock.Setup(m => m.Invoke(It.IsAny <EventHandler> ())).Callback <EventHandler> (e => e(null, null)); gtkMock.Setup(g => g.RemuxFile(It.IsAny <string> (), It.IsAny <string> (), It.IsAny <VideoMuxerType> ())) .Returns(() => settings.EncodingSettings.OutputFile) .Callback((string s, string d, VideoMuxerType m) => File.Copy(s, d)); gtkMock.Setup(g => g.EndCapture(true)).Returns(EndCaptureResponse.Save); App.Current.GUIToolkit = gtkMock.Object; mockList.Add(gtkMock); capturerBinMock = new Mock <ICapturerBin> (); capturerBinMock.Setup(w => w.Capturer).Returns(capturerMock.Object); capturerBinMock.Setup(w => w.CaptureSettings).Returns(() => settings); capturerBinMock.Setup(w => w.Periods).Returns(() => new List <Period> ()); mockList.Add(capturerBinMock); player = new VideoPlayerController(); videoPlayerVM = new VideoPlayerVM(); videoPlayerVM.Player = player; player.SetViewModel(videoPlayerVM); currentService = App.Current.LicenseLimitationsService; stateControllerMock = new Mock <IStateController> (); App.Current.StateController = stateControllerMock.Object; }
public void Run(CaptureSettings settings, MediaFile outputFile) { if (!capturerBinReady) { delayedRun = () => InternalRun(settings, outputFile); return; } InternalRun(settings, outputFile); }
bool SetProject(Project project, ProjectType projectType, CaptureSettings props) { if (OpenedProject != null) { CloseOpenedProject(true); } Log.Debug("Loading project " + project.ID + " " + projectType); PlaysFilter = new EventsFilter(project); project.CleanupTimers(); guiToolkit.OpenProject(project, projectType, props, PlaysFilter, out analysisWindow); Player = analysisWindow.Player; Capturer = analysisWindow.Capturer; OpenedProject = project; OpenedProjectType = projectType; if (projectType == ProjectType.FileProject) { // Check if the file associated to the project exists if (!project.Description.FileSet.CheckFiles()) { if (!guiToolkit.SelectMediaFiles(project)) { CloseOpenedProject(true); return(false); } } try { Player.Open(project.Description.FileSet); } catch (Exception ex) { Log.Exception(ex); guiToolkit.ErrorMessage(Catalog.GetString("An error occurred opening this project:") + "\n" + ex.Message); CloseOpenedProject(false); return(false); } } else if (projectType == ProjectType.CaptureProject || projectType == ProjectType.URICaptureProject || projectType == ProjectType.FakeCaptureProject) { try { Capturer.Run(props, project.Description.FileSet.First()); } catch (Exception ex) { Log.Exception(ex); guiToolkit.ErrorMessage(ex.Message); CloseOpenedProject(false); return(false); } } EmitProjectChanged(); return(true); }
private bool SetProject(Project project, ProjectType projectType, CaptureSettings props) { if (OpenedProject != null) { CloseOpenedProject(true); } if (projectType == ProjectType.FileProject) { // Check if the file associated to the project exists if (!File.Exists(project.Description.File.FilePath)) { guiToolkit.WarningMessage(Catalog.GetString("The file associated to this project doesn't exist.") + "\n" + Catalog.GetString("If the location of the file has changed try to edit it with the database manager.")); CloseOpenedProject(true); return(false); } try { Player.Open(project.Description.File.FilePath); } catch (Exception ex) { guiToolkit.ErrorMessage(Catalog.GetString("An error occurred opening this project:") + "\n" + ex.Message); CloseOpenedProject(true); return(false); } } else { if (projectType == ProjectType.CaptureProject || projectType == ProjectType.URICaptureProject) { Capturer.CaptureProperties = props; try { Capturer.Type = CapturerType.Live; } catch (Exception ex) { guiToolkit.ErrorMessage(ex.Message); CloseOpenedProject(false); return(false); } } else { Capturer.Type = CapturerType.Fake; } Capturer.Run(); } OpenedProject = project; OpenedProjectType = projectType; PlaysFilter = new PlaysFilter(project); mainWindow.SetProject(project, projectType, props, PlaysFilter); EmitProjectChanged(); return(true); }
private void captureWindow(object sender, EventArgs e) { var settings = new CaptureSettings(); feeble = new Feeble.Feeble(); settings.ffmpegLocation = ffmpegLocation.Text; settings.recordingRegionType = RecordingRegionType.window; settings.fileName = cdOutputFile.Text; settings.saveLocation = saveLocation.Text; settings.windowTitle = cwWindowTitle.Text; var temp = Task.Run(() => feeble.Capture(settings)); }
/// <summary> /// Load all values from storage /// </summary> public void LoadValues() { contourPathTbx.Text = CaptureSettings.Instance().DEFAULT_TEMPLATE_PATH; camIndexCombo.SelectedIndex = CaptureSettings.Instance().DEFAULT_CAMERA_INDEX; dependOutputSizeChck.IsChecked = GraphicsSettings.Instance().OUTPUT_TABLE_SIZE_DEPENDENT; contourPathTbx.IsEnabled = GraphicsSettings.Instance().OUTPUT_TABLE_SIZE_DEPENDENT; dependOutputSizeTbx.Text = CommonAttribService.ACTUAL_OUTPUT_WIDTH.ToString(); partColorRedTbx.Text = GraphicsSettings.Instance().DEFAULT_PARTICLE_COLOR_R.ToString(); partColorGreenTbx.Text = GraphicsSettings.Instance().DEFAULT_PARTICLE_COLOR_G.ToString(); partColorBlueTbx.Text = GraphicsSettings.Instance().DEFAULT_PARTICLE_COLOR_B.ToString(); motionDetectionChck.IsChecked = CaptureSettings.Instance().MOTION_DETECTION; detectionThreshold.Text = CaptureSettings.Instance().MOTION_TOLERANCE.ToString(); }
protected virtual void NewProject() { Project project; ProjectType projectType; CaptureSettings captureSettings = new CaptureSettings(); Log.Debug("Creating new project"); /* Show the project selection dialog */ projectType = guiToolkit.SelectNewProjectType(); if (projectType == ProjectType.CaptureProject) { List <Device> devices = multimediaToolkit.VideoDevices; if (devices.Count == 0) { guiToolkit.ErrorMessage(Catalog.GetString("No capture devices were found.")); return; } project = guiToolkit.NewCaptureProject(Core.DB, Core.TemplatesService, devices, out captureSettings); } else if (projectType == ProjectType.FakeCaptureProject) { project = guiToolkit.NewFakeProject(Core.DB, Core.TemplatesService); } else if (projectType == ProjectType.FileProject) { project = guiToolkit.NewFileProject(Core.DB, Core.TemplatesService); if (project != null) { Core.DB.AddProject(project); } } else if (projectType == ProjectType.URICaptureProject) { project = guiToolkit.NewURICaptureProject(Core.DB, Core.TemplatesService, out captureSettings); } else { project = null; } if (project != null) { SetProject(project, projectType, captureSettings); } }
public void FixtureSetup () { mockList = new List<Mock> (); settings = new CaptureSettings (); settings.EncodingSettings = new EncodingSettings (); settings.EncodingSettings.EncodingProfile = EncodingProfiles.MP4; var playerMock = new Mock<IPlayer> (); playerMock.SetupAllProperties (); mockList.Add (playerMock); capturerMock = new Mock<ICapturer> (); capturerMock.SetupAllProperties (); mockList.Add (capturerMock); winMock = new Mock<IAnalysisWindow> (); winMock.SetupAllProperties (); IAnalysisWindowBase win = winMock.Object; mockList.Add (winMock); mtkMock = new Mock<IMultimediaToolkit> (); mtkMock.Setup (m => m.GetPlayer ()).Returns (playerMock.Object); mtkMock.Setup (m => m.GetMultiPlayer ()).Throws (new Exception ()); mtkMock.Setup (m => m.GetCapturer ()).Returns (capturerMock.Object); mtkMock.Setup (m => m.DiscoverFile (It.IsAny<string> (), It.IsAny<bool> ())) .Returns ((string s, bool b) => new MediaFile { FilePath = s }); App.Current.MultimediaToolkit = mtkMock.Object; mockList.Add (mtkMock); gtkMock = new Mock<IGUIToolkit> (); gtkMock.Setup (m => m.Invoke (It.IsAny<EventHandler> ())).Callback<EventHandler> (e => e (null, null)); gtkMock.Setup (m => m.OpenProject (It.IsAny<ProjectLongoMatch> (), It.IsAny<ProjectType> (), It.IsAny<CaptureSettings> (), It.IsAny<EventsFilter> (), out win)); gtkMock.Setup (g => g.RemuxFile (It.IsAny<string> (), It.IsAny<string> (), It.IsAny<VideoMuxerType> ())) .Returns (() => settings.EncodingSettings.OutputFile) .Callback ((string s, string d, VideoMuxerType m) => File.Copy (s, d)); gtkMock.Setup (g => g.EndCapture (true)).Returns (EndCaptureResponse.Save); App.Current.GUIToolkit = gtkMock.Object; mockList.Add (gtkMock); capturerBinMock = new Mock<ICapturerBin> (); capturerBinMock.Setup (w => w.Capturer).Returns (capturerMock.Object); capturerBinMock.Setup (w => w.CaptureSettings).Returns (() => settings); capturerBinMock.Setup (w => w.Periods).Returns (() => new List<Period> ()); mockList.Add (capturerBinMock); player = new PlayerController (); winMock.Setup (w => w.Capturer).Returns (capturerBinMock.Object); winMock.Setup (w => w.Player).Returns (player); }
public CaptureDialog(Core core, OnCaptureMethod captureCallback, OnInjectMethod injectCallback) { InitializeComponent(); Icon = global::renderdocui.Properties.Resources.icon; var defaults = new CaptureSettings(); defaults.Inject = false; m_CaptureCallback = captureCallback; m_InjectCallback = injectCallback; m_Core = core; SetSettings(defaults); }
//private void FrameFilterSlider_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e) //{ // ICollectionView view = CollectionViewSource.GetDefaultView(frameList.ItemsSource); // view.Filter = new Predicate<object>((item) => { return (item is Frame) ? (item as Frame).Duration >= FrameFilterSlider.Value : true; }); //} public void StartCapture(IPAddress address, UInt16 port, CaptureSettings settings, SecureString password) { ProfilerClient.Get().IpAddress = address; ProfilerClient.Get().Port = port; Application.Current.Dispatcher.BeginInvoke(new Action(() => { StatusText.Text = "Connecting..."; StatusText.Visibility = System.Windows.Visibility.Visible; })); Task.Run(() => { ProfilerClient.Get().SendMessage(new StartMessage() { Settings = settings, Password = password }, true); }); }
public bool SetProject(Project project, ProjectType projectType, CaptureSettings props) { bool isLive = false; /* Update tabs labels */ var desc = project.Description; visitorteamlabel.Text = desc.VisitorName; localteamlabel.Text = desc.LocalName; if (projectType == ProjectType.FileProject) { Title = System.IO.Path.GetFileNameWithoutExtension(desc.File.FilePath) + " - " + Constants.SOFTWARE_NAME; player.LogoMode = false; timeline.Project = project; guTimeline.Project = project; } else { Title = Constants.SOFTWARE_NAME; isLive = true; if (projectType == ProjectType.FakeCaptureProject) { capturer.Type = CapturerType.Fake; } player.Visible = false; capturer.Visible = true; TaggingViewAction.Active = true; } openedProject = project; this.projectType = projectType; playsList.ProjectIsLive = isLive; localPlayersList.ProjectIsLive = isLive; visitorPlayersList.ProjectIsLive = isLive; tagsList.ProjectIsLive = isLive; playsList.Project = project; tagsList.Project = project; UpdateTeamsModels(project); buttonswidget.Categories = project.Categories; MakeActionsSensitive(true, projectType); ShowWidgets(); return(true); }
bool CreateProject() { TreeIter iter; MediaFile file; if (projectType == ProjectType.FileProject || projectType == ProjectType.EditProject) { if (!mediafilesetselection1.FileSet.CheckFiles ()) { gtoolkit.WarningMessage (Catalog.GetString ("You need at least 1 video file for the main angle")); return false; } } if (project != null) { /* Make sure event types and timers are updated in case we are importing * a project without dashboard */ project.UpdateEventTypesAndTimers (); return true; } if (projectType == ProjectType.CaptureProject || projectType == ProjectType.URICaptureProject) { if (String.IsNullOrEmpty (capturemediafilechooser.CurrentPath)) { gtoolkit.WarningMessage (Catalog.GetString ("No output video file")); return false; } } if (projectType == ProjectType.URICaptureProject) { if (urientry.Text == "") { gtoolkit.WarningMessage (Catalog.GetString ("No input URI")); return false; } } project = new Project (); project.Dashboard = analysisTemplate; project.LocalTeamTemplate = hometemplate; project.VisitorTeamTemplate = awaytemplate; project.Description = new ProjectDescription (); project.Description.Competition = competitionentry.Text; project.Description.MatchDate = datepicker1.Date; project.Description.Description = desctextview.Buffer.GetText (desctextview.Buffer.StartIter, desctextview.Buffer.EndIter, true); project.Description.Season = seasonentry.Text; project.Description.LocalName = project.LocalTeamTemplate.TeamName; project.Description.VisitorName = project.VisitorTeamTemplate.TeamName; project.Description.FileSet = mediafilesetselection1.FileSet; project.UpdateEventTypesAndTimers (); encSettings = new EncodingSettings (); captureSettings = new CaptureSettings (); encSettings.OutputFile = capturemediafilechooser.CurrentPath; /* Get quality info */ qualitycombobox.GetActiveIter (out iter); encSettings.EncodingQuality = (EncodingQuality)qualList.GetValue (iter, 1); /* Get size info */ imagecombobox.GetActiveIter (out iter); encSettings.VideoStandard = (VideoStandard)videoStandardList.GetValue (iter, 1); /* Get encoding profile info */ encodingcombobox.GetActiveIter (out iter); encSettings.EncodingProfile = (EncodingProfile)encProfileList.GetValue (iter, 1); encSettings.Framerate_n = Config.FPS_N; encSettings.Framerate_d = Config.FPS_D; captureSettings.EncodingSettings = encSettings; file = project.Description.FileSet.FirstOrDefault (); if (file == null) { file = new MediaFile () { Name = Catalog.GetString ("Main camera angle") }; file.FilePath = capturemediafilechooser.CurrentPath; file.Fps = (ushort)(Config.FPS_N / Config.FPS_D); file.Par = 1; project.Description.FileSet.Add (file); } if (projectType == ProjectType.CaptureProject) { captureSettings.Device = videoDevices [devicecombobox.Active]; captureSettings.Format = captureSettings.Device.Formats [deviceformatcombobox.Active]; file.VideoHeight = encSettings.VideoStandard.Height; file.VideoWidth = encSettings.VideoStandard.Width; } else if (projectType == ProjectType.URICaptureProject) { captureSettings.Device = new Device {DeviceType = CaptureSourceType.URI, ID = urientry.Text }; file.VideoHeight = encSettings.VideoStandard.Height; file.VideoWidth = encSettings.VideoStandard.Width; } else if (projectType == ProjectType.FakeCaptureProject) { file.FilePath = Constants.FAKE_PROJECT; } return true; }
public IAnalysisWindow SetProject(Project project, ProjectType projectType, CaptureSettings props, EventsFilter filter) { ExportProjectAction1.Sensitive = true; this.projectType = projectType; openedProject = project; if (projectType == ProjectType.FileProject) { Title = openedProject.Description.Title + " - " + Constants.SOFTWARE_NAME; } else { Title = Constants.SOFTWARE_NAME; } MakeActionsSensitive (true, projectType); if (projectType == ProjectType.FakeCaptureProject) { analysisWindow = new FakeAnalysisComponent (); } else { analysisWindow = new AnalysisComponent (); } SetPanel (analysisWindow as Widget); analysisWindow.SetProject (project, projectType, props, filter); return analysisWindow; }
bool SetProject(ProjectLongoMatch project, ProjectType projectType, CaptureSettings props) { if (OpenedProject != null) { CloseOpenedProject (true); } Log.Debug ("Loading project " + project.ID + " " + projectType); PlaysFilter = new EventsFilter (project); project.CleanupTimers (); project.ProjectType = projectType; guiToolkit.OpenProject (project, projectType, props, PlaysFilter, out analysisWindow); Player = analysisWindow.Player; Capturer = analysisWindow.Capturer; OpenedProject = project; OpenedProjectType = projectType; if (projectType == ProjectType.FileProject) { // Check if the file associated to the project exists if (!project.Description.FileSet.CheckFiles ()) { if (!guiToolkit.SelectMediaFiles (project.Description.FileSet)) { CloseOpenedProject (true); return false; } } try { Player.Open (project.Description.FileSet); } catch (Exception ex) { Log.Exception (ex); App.Current.Dialogs.ErrorMessage (Catalog.GetString ("An error occurred opening this project:") + "\n" + ex.Message); CloseOpenedProject (false); return false; } } else if (projectType == ProjectType.CaptureProject || projectType == ProjectType.URICaptureProject || projectType == ProjectType.FakeCaptureProject) { try { Capturer.Run (props, project.Description.FileSet.First ()); } catch (Exception ex) { Log.Exception (ex); App.Current.Dialogs.ErrorMessage (ex.Message); CloseOpenedProject (false); return false; } } EmitProjectChanged (); return true; }
private CaptureSettings GetSettings() { var ret = new CaptureSettings(); ret.Inject = InjectMode; ret.AutoStart = AutoStart.Checked; ret.Executable = exePath.Text; ret.WorkingDir = RealWorkDir; ret.CmdLine = cmdline.Text; ret.Options.AllowFullscreen = AllowFullscreen.Checked; ret.Options.AllowVSync = AllowVSync.Checked; ret.Options.HookIntoChildren = HookIntoChildren.Checked; ret.Options.CaptureCallstacks = CaptureCallstacks.Checked; ret.Options.CaptureCallstacksOnlyDraws = CaptureCallstacksOnlyDraws.Checked; ret.Options.DebugDeviceMode = DebugDeviceMode.Checked; ret.Options.RefAllResources = RefAllResources.Checked; ret.Options.SaveAllInitials = SaveAllInitials.Checked; ret.Options.CaptureAllCmdLists = CaptureAllCmdLists.Checked; ret.Options.DelayForDebugger = (uint)DelayForDebugger.Value; ret.Options.VerifyMapWrites = VerifyMapWrites.Checked; return ret; }
public void SetProject(Project project, ProjectType projectType, CaptureSettings props, EventsFilter filter) { this.project = (ProjectLongoMatch)project; codingwidget1.SetProject (this.project, projectType, (LMFilters.EventsFilter)filter); }
public CaptureDialog(Core core, OnCaptureMethod captureCallback, OnInjectMethod injectCallback) { InitializeComponent(); exePath.Font = workDirPath.Font = cmdline.Font = pidList.Font = core.Config.PreferredFont; Icon = global::renderdocui.Properties.Resources.icon; var defaults = new CaptureSettings(); defaults.Inject = false; m_CaptureCallback = captureCallback; m_InjectCallback = injectCallback; m_Core = core; workDirHint = true; workDirPath.ForeColor = SystemColors.GrayText; SetSettings(defaults); UpdateGlobalHook(); }
public void EmitOpenNewProject(Project project, ProjectType projectType, CaptureSettings captureSettings) { if (OpenNewProjectEvent != null) { OpenNewProjectEvent (project, projectType, captureSettings); } }
public void Run(CaptureSettings settings, MediaFile outputFile) { Reset (); if (type == CapturerType.Live) { Capturer = Config.MultimediaToolkit.GetCapturer (); this.outputFile = outputFile; this.settings = settings; videowindow.Ratio = (float)outputFile.VideoWidth / outputFile.VideoHeight; Capturer.Error += OnError; Capturer.MediaInfo += HandleMediaInfo; Capturer.DeviceChange += OnDeviceChange; Periods = new List<Period> (); if (videowindow.Ready) { Configure (); } else { delayStart = true; } } }
public CaptureDialog(Core core, OnCaptureMethod captureCallback, OnInjectMethod injectCallback) { InitializeComponent(); exePath.Font = workDirPath.Font = cmdline.Font = pidList.Font = core.Config.PreferredFont; Icon = global::renderdocui.Properties.Resources.icon; vulkanLayerWarn.Visible = !Helpers.CheckVulkanLayerRegistration(); var defaults = new CaptureSettings(); defaults.Inject = false; m_CaptureCallback = captureCallback; m_InjectCallback = injectCallback; m_Core = core; workDirHint = true; workDirPath.ForeColor = SystemColors.GrayText; processFilterHint = true; processFilter.ForeColor = SystemColors.GrayText; processFilter_Leave(processFilter, new EventArgs()); m_ProcessSorter.Sorting = SortOrder.Ascending; pidList.ListViewItemSorter = m_ProcessSorter; SetSettings(defaults); UpdateGlobalHook(); }
public void Configure(CaptureSettings settings, IntPtr window_handle) { }
public void SetProject(Project project, ProjectType projectType, CaptureSettings props, EventsFilter filter) { codingwidget1.SetProject (project, projectType, filter); }
public CaptureDialog(Core core, OnCaptureMethod captureCallback, OnInjectMethod injectCallback) { InitializeComponent(); Icon = global::renderdocui.Properties.Resources.icon; var defaults = new CaptureSettings(); defaults.Inject = false; m_CaptureCallback = captureCallback; m_InjectCallback = injectCallback; m_Core = core; workDirHint = true; workDirPath.ForeColor = SystemColors.GrayText; SetSettings(defaults); }
public void SetProject(Project project, ProjectType projectType, CaptureSettings props, EventsFilter filter) { openedProject = project; this.projectType = projectType; this.filter = filter; codingwidget.SetProject (project, projectType, filter); playsSelection.SetProject (project, filter); if (projectType == ProjectType.FileProject) { playercapturer.Mode = PlayerViewOperationMode.Analysis; } else { playercapturer.Mode = playercapturer.Mode = PlayerViewOperationMode.LiveAnalysisReview; Capturer.PeriodsNames = project.Dashboard.GamePeriods; Capturer.Periods = project.Periods; } }
#pragma warning restore 0169 public void Configure (CaptureSettings settings, IntPtr window_handle) { IntPtr err = IntPtr.Zero; EncodingQuality qual = settings.EncodingSettings.EncodingQuality; Device device = settings.Device; DeviceVideoFormat format = settings.Format; EncodingProfile enc; VideoStandard std; IntPtr outFile, sourceElement, deviceID; enc = settings.EncodingSettings.EncodingProfile; std = settings.EncodingSettings.VideoStandard; outFile = Marshaller.StringToPtrGStrdup (settings.EncodingSettings.OutputFile); sourceElement = Marshaller.StringToPtrGStrdup (device.SourceElement); deviceID = Marshaller.StringToPtrGStrdup (device.ID); gst_camera_capturer_configure (Handle, outFile, (int)settings.Device.DeviceType, sourceElement, deviceID, format.width, format.height, format.fps_n, format.fps_d, (int)enc.VideoEncoder, (int)enc.AudioEncoder, (int)enc.Muxer, qual.VideoQuality, qual.AudioQuality, settings.EncodingSettings.EnableAudio, std.Width, std.Height, window_handle, out err); Marshaller.Free (outFile); Marshaller.Free (sourceElement); Marshaller.Free (deviceID); if (err != IntPtr.Zero) throw new GLib.GException (err); }