public void InitializeVideoRecorder() { if (captureSource == null) { // Create the VideoRecorder objects. captureSource = new CaptureSource(); fileSink = new FileSink(); videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); captureSource.CaptureImageCompleted += captureSource_CaptureImageCompleted; // Add eventhandlers for captureSource. captureSource.CaptureFailed += new EventHandler <ExceptionRoutedEventArgs>(OnCaptureFailed); // Initialize the camera if it exists on the device. if (videoCaptureDevice != null) { // Create the VideoBrush for the viewfinder. videoRecorderBrush = new VideoBrush(); videoRecorderBrush.SetSource(captureSource); // Display the viewfinder image on the rectangle. viewfinderRectangle.Fill = videoRecorderBrush; // Start video capture and display it on the viewfinder. captureSource.Start(); // Set the button state and the message. UpdateUI(ButtonState.Initialized, "Tap record to start recording..."); } else { // Disable buttons when the camera is not supported by the device. UpdateUI(ButtonState.CameraNotSupported, "A camera is not supported on this device."); } } }
void InitializeVideoRecorder(Rectangle viewfinderRectangle) { if (captureSource == null) { // Create the VideoRecorder objects. captureSource = new CaptureSource(); fileSink = new FileSink(); videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); // Add eventhandlers for captureSource. captureSource.CaptureFailed += new EventHandler<ExceptionRoutedEventArgs>(OnCaptureFailed); // Initialize the camera if it exists on the device. if (videoCaptureDevice != null) { // Create the VideoBrush for the viewfinder. videoRecorderBrush = new VideoBrush(); videoRecorderBrush.SetSource(captureSource); // Display the viewfinder image on the rectangle. viewfinderRectangle.Fill = videoRecorderBrush; // Start video capture and display it on the viewfinder. captureSource.Start(); } else { // A camera is not supported on this device } } }
public JLogger Build() { EnsureDirectory(Path.GetDirectoryName(Configuration.FilePath)); var fileController = new FileController(Configuration.FilePath); ISink sink = new FileSink(fileController); if (Configuration.FileSplitting) { sink = new BundleSink( sink, new SplitterSink(fileController, Configuration.SplittingDirectory, Configuration.MaxFileSize) ); EnsureDirectory(Configuration.SplittingDirectory); } if (Configuration.MinimumLogLevel > LogLevel.Trace || Configuration.MaximumLogLevel < LogLevel.Fatal) { sink = new FilterSink(sink, Configuration.MinimumLogLevel, Configuration.MaximumLogLevel); } if (Configuration.Backtrackng) { sink = new BundleSink( sink, new BacktrackSink(new FileSink(fileController), Configuration.MinimumLevelForBacktracking, Configuration.TriggeringLevelForBacktracking, Configuration.BacktrackingTime) ); } return(new JLogger(sink, new EntryFormatter(new DataFormatter()))); }
public static void OnOpenedLifecycleHookCanWriteFileHeader() { using (var tmp = TempFolder.ForCaller()) { var headerWriter = new FileHeaderWriter("This is the file header"); var path = tmp.AllocateFilename("txt"); using (new FileSink(path, new JsonFormatter(), null, new UTF8Encoding(false), false, headerWriter)) { // Open and write header } using (var sink = new FileSink(path, new JsonFormatter(), null, new UTF8Encoding(false), false, headerWriter)) { // Length check should prevent duplicate header here sink.Emit(Some.LogEvent()); } var lines = System.IO.File.ReadAllLines(path); Assert.Equal(2, lines.Length); Assert.Equal(headerWriter.Header, lines[0]); Assert.Equal('{', lines[1][0]); } }
public void start() { if (captureSource == null) { // Create the VideoRecorder objects. captureSource = new CaptureSource(); fileSink = new FileSink(); videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); // Add eventhandlers for captureSource. captureSource.CaptureFailed += new EventHandler<ExceptionRoutedEventArgs>(OnCaptureFailed); // Initialize the camera if it exists on the device. if (videoCaptureDevice != null) { // Create the VideoBrush for the viewfinder. videoRecorderBrush = new VideoBrush(); videoRecorderBrush.SetSource(captureSource); videoRecorderBrush.RelativeTransform = new CompositeTransform() { CenterX = 0.5, CenterY = 0.5, Rotation = 90 }; viewfinderRectangle.Fill = videoRecorderBrush; // Start video capture and display it on the viewfinder. captureSource.Start(); System.Diagnostics.Debug.WriteLine("Started"); _isRunning = true; } } }
static OtelLogging() { ISink sink = null; try { var logDirectory = GetLogDirectory(); if (logDirectory != null) { var fileName = GetLogFileName(); var logPath = Path.Combine(logDirectory, fileName); sink = new FileSink(logPath); } } catch (Exception) { // unable to configure logging to a file } if (sink == null) { sink = new NoopSink(); } Logger = new Logger(sink); }
public VideoService( Rectangle viewFinder, MediaElement player ) { // Initial State _State = PlayState.Paused; _CanRecord = false; _Record = new SwitchableCommand(OnRecord); _Play = new SwitchableCommand(OnPlay); _Stop = new SwitchableCommand(OnPause); _ViewFinder = viewFinder; _Player = player; _Player.MediaEnded += MediaEnded; _CaptureSource = new CaptureSource(); _CaptureSource.CaptureFailed += CaptureFailed; _FileSink = new FileSink(); _Brush = new VideoBrush(); _HasRecording = new BehaviorSubject<bool>(false); }
static void WriteTwoEventsAndCheckOutputFileLength(long?maxBytes, Encoding encoding) { using (var tmp = TempFolder.ForCaller()) { var path = tmp.AllocateFilename("txt"); var evt = Some.LogEvent("Irrelevant as it will be replaced by the formatter"); var actualEventOutput = "x"; var formatter = new FixedOutputFormatter(actualEventOutput); var eventOuputLength = encoding.GetByteCount(actualEventOutput); using (var sink = new FileSink(path, formatter, maxBytes, encoding: encoding)) { sink.Emit(evt); } var size = new FileInfo(path).Length; Assert.Equal(encoding.GetPreamble().Length + eventOuputLength, size); //write a second event to the same file using (var sink = new FileSink(path, formatter, maxBytes, encoding: encoding)) { sink.Emit(evt); } size = new FileInfo(path).Length; Assert.Equal(encoding.GetPreamble().Length + eventOuputLength * 2, size); } }
public void OnOpenedLifecycleHookCanWrapUnderlyingStream() { var gzipWrapper = new GZipHooks(); using (var tmp = TempFolder.ForCaller()) { var path = tmp.AllocateFilename("txt"); var evt = Some.LogEvent("Hello, world!"); using (var sink = new FileSink(path, new JsonFormatter(), null, null, false, gzipWrapper)) { sink.Emit(evt); sink.Emit(evt); } // Ensure the data was written through the wrapping GZipStream, by decompressing and comparing against // what we wrote List <string> lines; using (var textStream = new MemoryStream()) { using (var fs = System.IO.File.OpenRead(path)) using (var decompressStream = new GZipStream(fs, CompressionMode.Decompress)) { decompressStream.CopyTo(textStream); } textStream.Position = 0; lines = textStream.ReadAllLines(); } Assert.Equal(2, lines.Count); Assert.Contains("Hello, world!", lines[0]); } }
void InitializeVideoRecorder(Rectangle viewfinderRectangle) { if (captureSource == null) { // Create the VideoRecorder objects. captureSource = new CaptureSource(); fileSink = new FileSink(); videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); // Add eventhandlers for captureSource. captureSource.CaptureFailed += new EventHandler <ExceptionRoutedEventArgs>(OnCaptureFailed); // Initialize the camera if it exists on the device. if (videoCaptureDevice != null) { // Create the VideoBrush for the viewfinder. videoRecorderBrush = new VideoBrush(); videoRecorderBrush.SetSource(captureSource); // Display the viewfinder image on the rectangle. viewfinderRectangle.Fill = videoRecorderBrush; // Start video capture and display it on the viewfinder. captureSource.Start(); } else { // A camera is not supported on this device } } }
public void start() { if (captureSource == null) { // Create the VideoRecorder objects. captureSource = new CaptureSource(); fileSink = new FileSink(); videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); // Add eventhandlers for captureSource. captureSource.CaptureFailed += new EventHandler <ExceptionRoutedEventArgs>(OnCaptureFailed); // Initialize the camera if it exists on the device. if (videoCaptureDevice != null) { // Create the VideoBrush for the viewfinder. videoRecorderBrush = new VideoBrush(); videoRecorderBrush.SetSource(captureSource); videoRecorderBrush.RelativeTransform = new CompositeTransform() { CenterX = 0.5, CenterY = 0.5, Rotation = 90 }; viewfinderRectangle.Fill = videoRecorderBrush; // Start video capture and display it on the viewfinder. captureSource.Start(); System.Diagnostics.Debug.WriteLine("Started"); _isRunning = true; } } }
public void Can_Create_New_File_When_Midnight_Is_Crossed() { var beforeMidnight = DateTime.ParseExact("9/29/2020 11:51:58 PM", "M/d/yyyy h:mm:ss tt", CultureInfo.InvariantCulture); var afterMidnight = DateTime.ParseExact("9/30/2020 00:00:58 AM", "M/d/yyyy h:mm:ss tt", CultureInfo.InvariantCulture); var timeServer = new TestDateTimeServer(beforeMidnight); var fileSink = new FileSink(timeServer); using (var sut = new SimplerAsyncLog(fileSink)) { sut.Write("before midnight"); Thread.Sleep(200); timeServer.ChangeTestTime(() => afterMidnight); sut.Write("after midnight"); sut.StopWithFlush(); } var resultBeforeMidnight = File.ReadAllText(beforeMidnight.LogPath()); var resultAfterMidnight = File.ReadAllText(afterMidnight.LogPath()); Assert.Contains("before midnight", resultBeforeMidnight); Assert.Contains("after midnight", resultAfterMidnight); File.Delete(beforeMidnight.LogPath()); File.Delete(afterMidnight.LogPath()); }
public static void Log(string message, params object[] args) { try { if (StartupLogFilePath != null) { try { using (var fileSink = new FileSink(StartupLogFilePath)) { fileSink.Info($"[{DateTime.UtcNow:O}] {message}{Environment.NewLine}", args); } return; } catch (Exception ex) { Console.Error.WriteLine($"Log: Exception creating FileSink {ex}"); } } Console.Error.WriteLine(message, args); } catch (Exception ex) { Console.Error.WriteLine($"Log: Global exception: {ex}"); } }
string GetJsonEventFile(Event <LogEventData> evt, string issueNumber) { var parser = new MessageTemplateParser(); var properties = (evt.Data.Properties ?? new Dictionary <string, object>()).Select( kvp => CreateProperty(kvp.Key, kvp.Value)); var logEvent = new LogEvent( evt.Data.LocalTimestamp, (Serilog.Events.LogEventLevel)Enum.Parse(typeof(Serilog.Events.LogEventLevel), evt.Data.Level.ToString()), evt.Data.Exception != null ? new WrappedException(evt.Data.Exception) : null, parser.Parse(evt.Data.MessageTemplate), properties); string logFilePath = Path.Combine(App.StoragePath, string.Format($"SeqAppYouTrack-{issueNumber}.json")); using (var jsonSink = new FileSink(logFilePath, new JsonFormatter(), null)) { var logger = new LoggerConfiguration().WriteTo.Sink(jsonSink, Serilog.Events.LogEventLevel.Verbose) .CreateLogger(); logger.Write(logEvent); } return(logFilePath); }
/// <summary> /// Write log events to the specified file. /// </summary> /// <param name="sinkConfiguration">Logger sink configuration.</param> /// <param name="path">Path to the file.</param> /// <param name="restrictedToMinimumLevel">The minimum level for /// events passed through the sink.</param> /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param> /// <param name="outputTemplate">A message template describing the format used to write to the sink. /// the default is "{Timestamp} [{Level}] {Message}{NewLine}{Exception}".</param> /// <param name="fileSizeLimitBytes">The maximum size, in bytes, to which a log file will be allowed to grow. /// For unrestricted growth, pass null. The default is 1 GB.</param> /// <returns>Configuration object allowing method chaining.</returns> /// <remarks>The file will be written using the UTF-8 character set.</remarks> public static LoggerConfiguration File( this LoggerSinkConfiguration sinkConfiguration, string path, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, string outputTemplate = DefaultOutputTemplate, IFormatProvider formatProvider = null, long? fileSizeLimitBytes = DefaultFileSizeLimitBytes) { if (sinkConfiguration == null) throw new ArgumentNullException("sinkConfiguration"); if (outputTemplate == null) throw new ArgumentNullException("outputTemplate"); var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider); FileSink sink; try { sink = new FileSink(path, formatter, fileSizeLimitBytes); } catch (ArgumentException) { throw; } catch (Exception ex) { SelfLog.WriteLine("Unable to open file sink for {0}: {1}", path, ex); return sinkConfiguration.Sink(new NullSink()); } return sinkConfiguration.Sink(sink, restrictedToMinimumLevel); }
void OpenFile(DateTimeOffset timeStamp) { var limit = timeStamp.Date.AddDays(1); var path = string.Format(_pathFormat, timeStamp.Date.ToString("yyyy-MM-dd")); _currentFile = new FileSink(path, _textFormatter); _limitOfCurrentFile = limit; }
public void Attach(FileSink sink) { Host = sink; RefreshArchiveLocation(); Host.BeforeInitialized += Host_BeforeInitialized; Host.BeforeWrite += Host_BeforeWrite; }
private void stop_Click(object sender, EventArgs e) { if (videoRecorder != null && videoRecorder.State == CaptureState.Started) { videoRecorder.Stop(); videoRecorder = null; fileWriter = null; videoContainer.Fill = new SolidColorBrush(Colors.Gray); } }
void CloseFile() { if (_currentFile != null) { _currentFile.Dispose(); _currentFile = null; } _nextCheckpoint = null; }
void OpenFile(DateTime now) { string path; DateTime nextCheckpoint; _roller.GetLogFilePath(now, out path, out nextCheckpoint); _nextCheckpoint = nextCheckpoint; _currentFile = new FileSink(path, _textFormatter, _fileSizeLimitBytes); ApplyRetentionPolicy(path); }
void OpenFile(DateTime now) { var date = now.Date; // We only take one attempt at it because repeated failures // to open log files REALLY slow an app down. _nextCheckpoint = date.AddDays(1); var existingFiles = Enumerable.Empty <string>(); try { existingFiles = Directory.GetFiles(_roller.LogFileDirectory, _roller.DirectorySearchPattern) .Select(Path.GetFileName); } catch (DirectoryNotFoundException) { } var latestForThisDate = _roller .SelectMatches(existingFiles) .Where(m => m.Date == date) .OrderByDescending(m => m.SequenceNumber) .FirstOrDefault(); var sequence = latestForThisDate != null ? latestForThisDate.SequenceNumber : 0; const int maxAttempts = 3; for (var attempt = 0; attempt < maxAttempts; attempt++) { string path; _roller.GetLogFilePath(now, sequence, out path); try { _currentFile = new FileSink(path, _textFormatter, _fileSizeLimitBytes); } catch (IOException ex) { var errorCode = Marshal.GetHRForException(ex) & ((1 << 16) - 1); if (errorCode == 32 || errorCode == 33) { SelfLog.WriteLine("Rolling file target {0} was locked, attempting to open next in sequence (attempt {1})", path, attempt + 1); sequence++; continue; } throw; } ApplyRetentionPolicy(path); return; } }
private void DisposeVideoRecorder() { if (_captureSource != null) { if (_captureSource.VideoCaptureDevice != null && _captureSource.State == CaptureState.Started) _captureSource.Stop(); _captureSource.CaptureFailed -= OnCaptureSourceOnCaptureFailed; _captureSource = null; _videoCaptureDevice = null; _fileSink = null; _videoBrush = null; } }
/// <summary> /// Releases resources /// </summary> private void DisposeVideoRecorder() { if (captureSource != null) { if ((captureSource.VideoCaptureDevice != null) && (captureSource.State == CaptureState.Started)) { captureSource.Stop(); } captureSource = null; videoCaptureDevice = null; fileSink = null; videoRecorderBrush = null; } }
/// <summary> /// Initializes a new instance of <see cref="AsyncSingleFileSink"/>. /// </summary> /// <param name="formatter">Log formatter.</param> /// <param name="renderer">Renderer factory method.</param> /// <param name="logFilePath">Log file path.</param> /// <param name="encoding">File encoding. The default is UTF8.</param> /// <param name="bufferSize">Buffer size to be used. The default is 4096.</param> public AsyncSingleFileSink(ILogFormatter formatter, Func <IDataRenderer> renderer, string logFilePath, Encoding encoding = null, int bufferSize = 4096) { Formatter = formatter; this.renderer = renderer; sink = new FileSink(Formatter, renderer, logFilePath, encoding, bufferSize); asyncWriter = new AsyncWriter((level, entries) => { sink.Write(level, entries); }); asyncWriter.Start(); }
public void FileIsWrittenIfNonexistent() { using (var tmp = TempFolder.ForCaller()) { var nonexistent = tmp.AllocateFilename("txt"); var evt = Some.LogEvent("Hello, world!"); using (var sink = new FileSink(nonexistent, new JsonFormatter(), null)) { sink.Emit(evt); } var lines = System.IO.File.ReadAllLines(nonexistent); Assert.Contains("Hello, world!", lines[0]); } }
public void InitializeVideoRecorder() { try { //fileName = string.Format(@"\Purposecode\Video{0}.mp4", DateTime.Now.ToString("yyyyMMddHHmmss")); fileName = string.Format("Video{0}.mp4", DateTime.Now.ToString("yyyyMMddHHmmss")); if (captureSource == null) { // Create the VideoRecorder objects. captureSource = new CaptureSource(); fileSink = new FileSink(); videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); // Add eventhandlers for captureSource. captureSource.CaptureFailed += new EventHandler<ExceptionRoutedEventArgs>(OnCaptureFailed); // Initialize the camera if it exists on the device. if (videoCaptureDevice != null) { // Create the VideoBrush for the viewfinder. videoRecorderBrush = new VideoBrush(); videoRecorderBrush.SetSource(captureSource); // Display the viewfinder image on the rectangle. viewfinderRectangle.Fill = videoRecorderBrush; StopPlaybackRecording.IsEnabled = false; // Start video capture and display it on the viewfinder. captureSource.Start(); // Set the button state and the message. UpdateUI(ButtonState.Initialized, "Tap record to start recording..."); } else { // Disable buttons when the camera is not supported by the device. UpdateUI(ButtonState.CameraNotSupported, "Camera is not supported.."); } } } catch (Exception ex) { var test = ex.Message; } } //InitializeVideoRecorder()
/// <summary> /// Creates a new recoding pipeline with the best (by user preference) available encoder and attaches it /// to the audiotee /// </summary> /// <returns> /// A <see cref="System.Boolean"/>, true if the pipeline was successfully created, false otherwise. /// </returns> public bool Create() { string bin_description = BuildPipeline(); try { audiotee = new PlayerAudioTee(ServiceManager.PlayerEngine.ActiveEngine.GetBaseElements()[2]); if (bin_description.Equals("")) { return(false); } encoder_bin = Parse.BinFromDescription(bin_description, true); // Hyena.Log.Debug ("DEBUG bin to string: " + encoder_bin.ToString()); tagger = new TagSetter(encoder_bin.GetByInterface(TagSetter.GetType())); file_sink = encoder_bin.GetByName("file_sink").ToFileSink(); file_sink.Location = empty_file; file_sink.SetBooleanProperty("sync", true); file_sink.SetBooleanProperty("async", false); OldGLib.Object.GetObject(file_sink.ToIntPtr()).AddNotification("allow-overwrite", OnAllowOverwrite); ghost_pad = encoder_bin.GetStaticPad("sink").ToGhostPad(); outputselector = encoder_bin.GetByName("sel"); Pad filesinkpad = file_sink.GetStaticPad("sink"); selector_filepad = filesinkpad.GetPeer(); Element fake_sink = encoder_bin.GetByName("fake_sink"); Pad fakesinkpad = fake_sink.GetStaticPad("sink"); selector_fakepad = fakesinkpad.GetPeer(); audiotee.AddBin(encoder_bin, ServiceManager.PlayerEngine.CurrentState == PlayerState.Playing); Hyena.Log.Debug("[Recorder] Recorder attached"); } catch (Exception e) { Hyena.Log.InformationFormat("[Streamrecorder] An exception occurred during pipeline construction: {0}", bin_description); Hyena.Log.Debug(e.Message); Hyena.Log.Debug(e.StackTrace); return(false); } return(true); }
protected override void OnNavigatedFrom(NavigationEventArgs e) { if (captureSource != null) { captureSource.CaptureImageCompleted -= captureSource_CaptureImageCompleted; if (captureSource.VideoCaptureDevice != null && captureSource.State == CaptureState.Started) { captureSource.Stop(); } captureSource = null; fileSink = null; videoCaptureDevice = null; } base.OnNavigatedFrom(e); }
public void FileControllerGetsCorrectString() { bool fileControllerGotLog = false; var fileController = new Mock <IFileController>(); fileController.Setup(f => f.AppendLogEntry("this is correct log")) .Callback(() => fileControllerGotLog = true); var sink = new FileSink(fileController.Object); sink.Emit("this is not correct log", Enums.LogLevel.Critical); Assert.False(fileControllerGotLog); sink.Emit("this is correct log", Enums.LogLevel.Trace); Assert.True(fileControllerGotLog); }
private void StartRecordig() { if (m_captureSource == null) { m_captureSource = new CaptureSource(); m_captureSource.VideoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); m_captureSource.AudioCaptureDevice = CaptureDeviceConfiguration.GetDefaultAudioCaptureDevice(); m_sink = new FileSink(); m_sink.CaptureSource = m_captureSource; m_sink.IsolatedStorageFileName = m_capturedFileName; } VideoBrush brush = new VideoBrush(); brush.SetSource(m_captureSource); CameraPreview.Fill = brush; m_captureSource.Start(); }
private void ConstructPipeline() { pipeline = new Pipeline("pipeline"); filesrc = ElementFactory.Make("filesrc", "filesrc") as FileSrc; filesink = ElementFactory.Make("filesink", "filesink") as FileSink; audioconvert = ElementFactory.Make("audioconvert", "audioconvert"); encoder = ElementFactory.Make("wavenc", "wavenc"); decodebin = ElementFactory.Make("decodebin2", "decodebin") as DecodeBin2; decodebin.NewDecodedPad += OnNewDecodedPad; pipeline.Add(filesrc, decodebin, audioconvert, encoder, filesink); filesrc.Link(decodebin); audioconvert.Link(encoder); encoder.Link(filesink); pipeline.Bus.AddWatch(new BusFunc(OnBusMessage)); }
/// <summary> /// Write log events as JSON to the specified file. /// </summary> /// <param name="sinkConfiguration">Logger sink configuration.</param> /// <param name="path">Path to the file.</param> /// <param name="restrictedToMinimumLevel">The minimum level for /// events passed through the sink. Ignored when <paramref name="levelSwitch"/> is specified.</param> /// <param name="levelSwitch">A switch allowing the pass-through minimum level /// to be changed at runtime.</param> /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param> /// <param name="fileSizeLimitBytes">The maximum size, in bytes, to which a log file will be allowed to grow. /// For unrestricted growth, pass null. The default is 1 GB.</param> /// <param name="buffered">Indicates if flushing to the output file can be buffered or not. The default /// is false.</param> /// <returns>Configuration object allowing method chaining.</returns> /// <remarks>The file will be written using the UTF-8 character set.</remarks> public static LoggerConfiguration JsonFile( this LoggerSinkConfiguration sinkConfiguration, string path, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, IFormatProvider formatProvider = null, long?fileSizeLimitBytes = DefaultFileSizeLimitBytes, LoggingLevelSwitch levelSwitch = null, bool buffered = false) { if (sinkConfiguration == null) { throw new ArgumentNullException(nameof(sinkConfiguration)); } var formatter = new JsonFormatter(formatProvider: formatProvider); FileSink sink; try { sink = new FileSink(path, formatter, fileSizeLimitBytes #if BUFFERING_CONTROL , buffered: buffered #endif ); } catch (ArgumentException) { throw; } catch (Exception ex) { SelfLog.WriteLine("Unable to open file sink for {0}: {1}", path, ex); return(sinkConfiguration.Sink(new NullSink())); } return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel #if LEVEL_SWITCH , levelSwitch #endif )); }
protected override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); if (captureSource == null) { captureSource = new CaptureSource(); captureSource.CaptureImageCompleted += captureSource_CaptureImageCompleted; fileSink = new FileSink(); videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); if (videoCaptureDevice != null) { videoBrush.SetSource(captureSource); videoBrush.RelativeTransform = new CompositeTransform() { CenterX = 0.5, CenterY = 0.5, Rotation = 90 }; captureSource.Start(); } } }
public void Can_Write_To_Log() { var expected = "test write"; var testTime = DateTime.Now - TimeSpan.FromDays(1); var fileSink = new FileSink(new TestDateTimeServer(testTime)); using (var sut = new SimplerAsyncLog(fileSink)) { sut.Write(expected); sut.StopWithFlush(); } var result = File.ReadAllText(testTime.LogPath()); Assert.Contains(expected, result); File.Delete(testTime.LogPath()); }
private void DisposeVideoRecorder() { if (captureSource != null) { if (captureSource.VideoCaptureDevice != null && captureSource.State == CaptureState.Started) { captureSource.Stop(); } // Remove the event handler for captureSource. captureSource.CaptureFailed -= captureSource_CaptureFailed; // Remove the video recording objects. captureSource = null; videoCaptureDevice = null; fileSink = null; videoRecorderBrush = null; } }
private void InitializeVideoRecorder() { if (captureSource == null) { captureSource = new CaptureSource(); fileSink = new FileSink(); var devices = CaptureDeviceConfiguration.GetAvailableVideoCaptureDevices(); captureSource.VideoCaptureDevice = devices[0]; captureSource.CaptureFailed += captureSource_CaptureFailed; if (videoCaptureDevice != null) { videoRecorderBrush = new VideoBrush(); videoRecorderBrush.SetSource(captureSource); ViewfinderRectangle.Fill = videoRecorderBrush; captureSource.Start(); } } }
private void DisposeVideoRecorder() { if (_captureSource != null) { // Stop captureSource if it is running. if (_captureSource.VideoCaptureDevice != null && _captureSource.State == CaptureState.Started) { _captureSource.Stop(); } // Remove the event handler for captureSource. _captureSource.CaptureFailed -= OnCaptureFailed; // Remove the video recording objects. _captureSource = null; _videoCaptureDevice = null; _fileSink = null; _videoRecorderBrush = null; } }
private void InitializeVideoRecorder() { if (_captureSource == null) { _captureSource = new CaptureSource(); _fileSink = new FileSink(); _videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); _captureSource.CaptureFailed += OnCaptureSourceOnCaptureFailed; _captureSource.CaptureImageCompleted += CaptureSourceOnCaptureImageCompleted; if (_videoCaptureDevice != null) { _videoBrush = new VideoBrush(); _videoBrush.SetSource(_captureSource); ViewFinderRectangle.Fill = _videoBrush; _captureSource.Start(); } } }
private void DisposeVideoRecorder() { if (_captureSource != null) { // Stop _captureSource if it is running. if (_captureSource.VideoCaptureDevice != null && _captureSource.State == CaptureState.Started) { _captureSource.Stop(); } // Remove the event handlers for capturesource and the shutter button. _captureSource.CaptureFailed -= OnCaptureFailed; _captureSource.CaptureImageCompleted -= OnThumbCompleted; // Remove the video recording objects. _captureSource = null; _videoCaptureDevice = null; _fileSink = null; ViewfinderBrush = null; } }
public void StopRecording() { if (captureSource != null) { // Stop captureSource if it is running. if (captureSource.VideoCaptureDevice != null && captureSource.State == CaptureState.Started) { captureSource.Stop(); } // Remove the event handlers for capturesource and the shutter button. captureSource.CaptureFailed -= OnCaptureFailed; // Remove the video recording objects. captureSource = null; videoCaptureDevice = null; fileSink = null; videoRecorderBrush = null; } }
private void DisposeVideoRecorder() { if (captureSource != null) { // Stop captureSource if it is running. if (captureSource.VideoCaptureDevice != null && captureSource.State == CaptureState.Started) { captureSource.Stop(); } // Remove the event handlers for capturesource and the shutter button. captureSource.CaptureFailed -= OnCaptureFailed; // Remove the video recording objects. captureSource = null; videoCaptureDevice = null; fileSink = null; videoRecorderBrush = null; } }
/// <summary> /// Initialize the Capture Device /// </summary> private void InitializeCaptureDevice() { //set the video capture device if (captureSource == null) { captureSource = new CaptureSource(); captureSource.VideoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); captureSource.AudioCaptureDevice = CaptureDeviceConfiguration.GetDefaultAudioCaptureDevice(); sink = new FileSink(); sink.CaptureSource = captureSource; sink.IsolatedStorageFileName = m_capturedFileName; } //set the video preview var brush = new VideoBrush(); brush.SetSource(captureSource); cameraPreview.Fill = brush; }
public void InitializeVideoRecorder() { if (_captureSource == null) { // Create the VideoRecorder objects. _captureSource = new CaptureSource(); _fileSink = new FileSink(); _videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); // Add eventhandlers for captureSource. _captureSource.CaptureFailed += OnCaptureFailed; // Initialize the camera if it exists on the phone. if (_videoCaptureDevice != null) { // Create the VideoBrush for the viewfinder. _videoRecorderBrush = new VideoBrush(); _videoRecorderBrush.SetSource(_captureSource); // Display the viewfinder image on the rectangle. viewfinderRectangle.Fill = _videoRecorderBrush; // Start video capture and display it on the viewfinder. _captureSource.Start(); // Set the button state and the message. UpdateUI(ButtonState.Initialized, "Tap record to start recording..."); } else { // Disable buttons when the camera is not supported by the phone. UpdateUI(ButtonState.NoChange, "Camera Not Supported."); } } }
void TryArchive(FileSink sink, bool isStartup, long? messageSize = null) { try { using (var lockToken = sink.FileLockingStrategy.AcquireLock(sink.LogFile.FullName)) { // double check if archive is still needed now that we have lock if (!CheckArchiveNeeded(sink, isStartup, messageSize)) return; EnsureFreeSlotInArchive(); // todo: support different archive naming strategies (e.g. numeric prefix indicating slot number in the archive) var newFileName = "[{0}] {1}" .FormatWith( DateTime.UtcNow.ToString("yyyy-MM-dd HH-mm-ss").ToValidFileName(), sink.LogFile.Name); var newFileFullPath = Path.Combine(ArchiveLocation.FullName, newFileName); lockToken.CloseFileIfNeeded(); System.IO.File.Move(sink.LogFile.FullName, newFileFullPath); } } catch(Exception ex) { // todo: internal log warning } }
void Host_BeforeWrite(object sender, FileSink.BeforeWriteEventArgs e) { ArchiveIfNeeded((FileSink)sender, isStartup: false, messageSize: e.MessageSize); }
bool CheckArchiveNeeded(FileSink sink, bool isStartup, long? messageSize = null) { sink.LogFile.Refresh(); if (!sink.LogFile.Exists) return false; if (isStartup && TriggerOnStartup && sink.LogFile.Length > 0) { return true; } if (TriggerOnFileSize.HasValue && messageSize.HasValue) { if (sink.LogFile.Length + messageSize.Value >= TriggerOnFileSize.Value) { return true; } } if (TriggerOnFileAge.HasValue) { if ((sink.LogFile.CreationTimeUtc - DateTime.UtcNow) >= TriggerOnFileAge.Value) { return true; } } // NOTE: use current machine time, not UTC // assumption is that local time is to be used always // this may cause different behavior on days when local time changes // Example: // British Summer Time (BST) ends at 01:00 GMT when clock is moved back 1 hour. // If TriggerOnTime is set to 01:00 then log can be archive twice within 1 hour period // instead of expected once within 24 hour period if (TriggerOnTime.HasValue && DateTime.Now.TimeOfDay >= TriggerOnTime.Value && sink.LogFile.CreationTime.TimeOfDay < TriggerOnTime.Value) { return true; } return false; }
void ArchiveIfNeeded(FileSink sink, bool isStartup, long? messageSize = null) { if(CheckArchiveNeeded(sink, isStartup, messageSize)) { TryArchive(sink, isStartup, messageSize); } }
public void stop() { if (captureSource != null) { // Stop captureSource if it is running. if (captureSource.VideoCaptureDevice != null && captureSource.State == CaptureState.Started) { captureSource.Stop(); } // Remove the event handler for captureSource. captureSource.CaptureFailed -= OnCaptureFailed; // Remove the video recording objects. captureSource = null; videoCaptureDevice = null; fileSink = null; videoRecorderBrush = null; System.Diagnostics.Debug.WriteLine("Stopped"); _isRunning = false; } }
private void StartCapture(VideoCaptureDevice videoDevice) { if (videoRecorder == null || videoRecorder.State != CaptureState.Started) { videoRecorder = new CaptureSource { VideoCaptureDevice = videoDevice, AudioCaptureDevice = CaptureDeviceConfiguration.GetDefaultAudioCaptureDevice() }; var brush = new VideoBrush(); brush.SetSource(videoRecorder); videoContainer.Fill = brush; fileWriter = new FileSink { CaptureSource = videoRecorder, IsolatedStorageFileName = "video-recording.mp4", }; videoRecorder.Start(); } }
private void DisposeVideoRecorder() { try { if (captureSource != null) { if (captureSource.VideoCaptureDevice != null && captureSource.State == CaptureState.Started) { captureSource.Stop(); } captureSource.CaptureFailed -= OnCaptureFailed; captureSource = null; } videoCaptureDevice = null; fileSink = null; videoRecorderBrush = null; isoVideoFile = null; GC.Collect(); } catch (Exception ex) { var test = ex.Message; } }
public void InitializeVideoRecorder() { if (captureSource == null) { // Create the VideoRecorder objects. captureSource = new CaptureSource(); fileSink = new FileSink(); videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); // Add eventhandlers for captureSource. captureSource.CaptureFailed += new EventHandler<ExceptionRoutedEventArgs>(OnCaptureFailed); // Initialize the camera if it exists on the device. if (videoCaptureDevice != null) { // Create the VideoBrush for the viewfinder. videoRecorderBrush = new VideoBrush(); videoRecorderBrush.SetSource(captureSource); // Display the viewfinder image on the rectangle. viewfinderRectangle.Fill = videoRecorderBrush; // Start video capture and display it on the viewfinder. captureSource.Start(); // Set the button state and the message. UpdateUI(ButtonState.Initialized, "Tap record to start recording..."); } else { // Disable buttons when the camera is not supported by the device. UpdateUI(ButtonState.CameraNotSupported, "A camera is not supported on this device."); } } }
/// <summary> /// Initializes VideoRecorder /// </summary> public void InitializeVideoRecorder() { if (captureSource == null) { captureSource = new CaptureSource(); fileSink = new FileSink(); videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice(); if (videoCaptureDevice != null) { videoRecorderBrush = new VideoBrush(); videoRecorderBrush.SetSource(captureSource); viewfinderRectangle.Fill = videoRecorderBrush; captureSource.Start(); this.UpdateUI(VideoState.Initialized); } else { this.UpdateUI(VideoState.CameraNotSupported); } } }
/// <summary> /// Create file sink /// </summary> private void createFile() { videoSink = new FileSink(); }
/// <summary> /// Save video capture to an MP4 file in order to play back at a later time, using FileSink /// </summary> /// <param name="fileName">The file name (without extention!)</param> /// <param name="captureSource">The video capture source</param> public static void SaveVideoCaptureFile(string fileName, CaptureSource captureSource) { var sink = new FileSink(); sink.CaptureSource = captureSource; //TODO: Nitzo, pay attention that the captured file is mp4 sink.IsolatedStorageFileName = fileName + ".mp4"; }