public static string Serialize(EngineParameters engineParameters) { switch (engineParameters.Task) { case FFmpegTask.Storyboard: return(GetStoryboard(engineParameters)); case FFmpegTask.Check: return(GetHealthCheck(engineParameters)); case FFmpegTask.GIF: return(GetGIF(engineParameters)); case FFmpegTask.GenerateHLS: return(GetHLS(engineParameters)); case FFmpegTask.Convert: return(Convert(engineParameters.InputFile, engineParameters.OutputFile, engineParameters.ConversionOptions)); case FFmpegTask.GetMetaData: return(GetMetadata(engineParameters.InputFile)); case FFmpegTask.GetThumbnail: return(GetThumbnail(engineParameters.ThumbnailOptions)); default: throw new ArgumentOutOfRangeException(); } }
private void HandleOutput(EngineParameters engineParameters, DataReceivedEventArgs received, List <string> receivedMessagesLog, ref Exception caughtException) { if (received.Data == null) { return; } var totalMediaDuration = new TimeSpan(); try { receivedMessagesLog.Insert(0, received.Data); SetMetadata(engineParameters, received, totalMediaDuration); HandleProgressResult(received, totalMediaDuration); HandleConversionResult(engineParameters, received, totalMediaDuration); } catch (Exception ex) { Console.WriteLine(ex.Message); // catch the exception and kill the process since we're in a faulted state caughtException = ex; try { this.FFmpegProcess.Kill(); } catch { // swallow exceptions that are thrown when killing the process, // one possible candidate is the application ending naturally before we get a chance to kill it } } }
/// <summary> /// <para> Retrieve media metadata</para> /// </summary> /// <param name="inputFile">Retrieves the metadata for the input file. </param> public void GetMetadata(MediaFile inputFile) { var engineParams = new EngineParameters { InputFile = inputFile, Task = FFmpegTask.GetMetaData }; this.FFmpegEngine(engineParams); }
/// ------------------------------------------------------------------------------------------------- /// <summary> Extracts all frames from a video. </summary> /// <param name="inputFile"> Video file. </param> public void ExtractFrames(MediaFile inputFile) { EngineParameters engineParams = new EngineParameters { InputFile = inputFile, Task = FFmpegTask.ExtractFrames }; this.FFmpegEngine(engineParams); }
public void CustomCommand(string ffmpegCommand) { if (ffmpegCommand.IsNullOrWhiteSpace()) { throw new ArgumentNullException("ffmpegCommand"); } EngineParameters engineParameters = new EngineParameters { CustomArguments = ffmpegCommand }; this.StartFFmpegProcess(engineParameters); }
/// <summary> Retrieve a thumbnail image from a video file. </summary> /// <param name="inputFile"> Video file. </param> /// <param name="outputFile"> Image file. </param> /// <param name="options"> Conversion options. </param> public void GetThumbnail(ThumbnailOptions options) { var engineParams = new EngineParameters { InputFile = new MediaFile(options.InputFile), ThumbnailOptions = options, Task = FFmpegTask.GetThumbnail }; this.FFmpegEngine(engineParams); }
/// <summary> /// <para> Converts media with default options</para> /// </summary> /// <param name="inputFile"> Input file. </param> /// <param name="outputFile"> Output file. </param> public void Convert(MediaFile inputFile, MediaFile outputFile) { var engineParams = new EngineParameters { InputFile = inputFile, OutputFile = outputFile, Task = FFmpegTask.Convert }; this.FFmpegEngine(engineParams); }
/// ------------------------------------------------------------------------------------------------- /// <summary> /// <para> ---</para> /// <para> Converts media with default options</para> /// </summary> /// <param name="inputFile"> Input file. </param> /// <param name="outputFile"> Output file. </param> public void Convert(MediaFile inputFile, MediaFile outputFile) { EngineParameters engineParams = new EngineParameters { InputFile = inputFile, OutputFile = outputFile, Task = FFmpegTask.Convert }; this.FFmpegEngine(engineParams); }
/// ------------------------------------------------------------------------------------------------- /// <summary> /// <para> ---</para> /// <para> Converts media with conversion options</para> /// </summary> /// <param name="inputFile"> Input file. </param> /// <param name="outputFile"> Output file. </param> /// <param name="options"> Conversion options. </param> public void Convert(MediaFile inputFile, MediaFile outputFile, ConversionOptions options) { var engineParams = new EngineParameters { InputFile = inputFile, OutputFile = outputFile, ConversionOptions = options, Task = FFmpegTask.Convert }; FFmpegEngine(engineParams); }
public static string GetGIF(EngineParameters engineParameters) { if (!(engineParameters is GIFParameters gif)) { throw new ArgumentException("Paramters must be of type GIfParamters"); } return(string.Concat($"-i {engineParameters.InputFile.Filename}", gif.GifOptions.Serialize(), " ", gif.OutputFile.Filename)); }
/// ------------------------------------------------------------------------------------------------- /// <summary> Retrieve a thumbnail image from a video file. </summary> /// <param name="inputFile"> Video file. </param> /// <param name="outputFile"> Image file. </param> /// <param name="options"> Conversion options. </param> public void GetThumbnail(MediaFile inputFile, MediaFile outputFile, ConversionOptions options) { EngineParameters engineParams = new EngineParameters { InputFile = inputFile, OutputFile = outputFile, ConversionOptions = options, Task = FFmpegTask.GetThumbnail }; this.FFmpegEngine(engineParams); }
public byte[] GetThumbnail(MediaFile inputFile, ConversionOptions options) { EngineParameters engineParams = new EngineParameters { InputFile = inputFile, ConversionOptions = options, Task = FFmpegTask.GetThumbnailStream, ReturningStandardOutput = true }; this.FFmpegEngine(engineParams); return(this.thumbnailByteArray); }
private void HandleConversionResult(EngineParameters engineParameters, DataReceivedEventArgs received, TimeSpan totalMediaDuration) { if (engineParameters.Task != FFmpegTask.Convert) { return; } if (RegexEngine.IsConvertCompleteData(received.Data, out ConversionCompleteEventArgs convertCompleteEvent)) { convertCompleteEvent.TotalDuration = totalMediaDuration; this.OnConversionComplete(convertCompleteEvent); } }
public void CustomCommand(string ffmpegCommand) { if (ffmpegCommand.IsNullOrWhiteSpace()) { throw new ArgumentNullException(nameof(ffmpegCommand)); } var engineParameters = new EngineParameters { CustomArguments = ffmpegCommand }; this.StartFFmpegProcess(engineParameters); }
internal static string Serialize(EngineParameters engineParameters) { switch (engineParameters.Task) { case FFmpegTask.Convert: return Convert(engineParameters.InputFile, engineParameters.OutputFile, engineParameters.ConversionOptions); case FFmpegTask.GetMetaData: return GetMetadata(engineParameters.InputFile); case FFmpegTask.GetThumbnail: return GetThumbnail(engineParameters.InputFile, engineParameters.OutputFile, engineParameters.ConversionOptions); } return null; }
internal static string Serialize(EngineParameters engineParameters) { switch (engineParameters.Task) { case FFmpegTask.Convert: return(Convert(engineParameters.InputFile, engineParameters.OutputFile, engineParameters.ConversionOptions)); case FFmpegTask.GetMetaData: return(GetMetadata(engineParameters.InputFile)); case FFmpegTask.GetThumbnail: return(GetThumbnail(engineParameters.InputFile, engineParameters.OutputFile, engineParameters.ConversionOptions)); } return(null); }
internal static string Serialize(EngineParameters engineParameters) { switch (engineParameters.Task) { case FFmpegTask.Convert: return Convert(engineParameters.InputFile, engineParameters.OutputFile, engineParameters.ConversionOptions); case FFmpegTask.GetMetaData: return GetMetadata(engineParameters.InputFile); case FFmpegTask.GetThumbnail: return GetThumbnail(engineParameters.InputFile, engineParameters.OutputFile, engineParameters.ConversionOptions); default: throw new ArgumentOutOfRangeException(); } }
private void FFmpegEngine(EngineParameters engineParameters) { if (!engineParameters.InputFile.Filename.StartsWith("http://") && !File.Exists(engineParameters.InputFile.Filename)) { throw new FileNotFoundException(Strings.Exception_Media_Input_File_Not_Found, engineParameters.InputFile.Filename); } try { this.Mutex.WaitOne(); this.StartFFmpegProcess(engineParameters); } finally { this.Mutex.ReleaseMutex(); } }
internal static string Serialize(EngineParameters engineParameters) { switch (engineParameters.Task) { case FFmpegTask.Convert: return(Convert(engineParameters.InputFile, engineParameters.OutputFile, engineParameters.ConversionOptions)); case FFmpegTask.GetMetaData: return(GetMetadata(engineParameters.InputFile)); case FFmpegTask.GetThumbnail: return(GetThumbnail(engineParameters.InputFile, engineParameters.OutputFile, engineParameters.ConversionOptions)); default: throw new ArgumentOutOfRangeException(); } }
public static string GetHLS(EngineParameters engineParameters) { var o = engineParameters.HLSOptions; return(string.Concat( "-hide_banner -y ", $"-i {engineParameters.InputFile.Filename}", o.DefaultParams, o.SerializeSpeed(), o.SerializeAudio(), o.SerializeVideo(), o.SerializeScale(), o.SerializeBitrate(), o.SerializeCRF(), o.SerializeKeyframes(), o.SerializeHLSConfig())); }
private static void SetMetadata(EngineParameters engineParameters, DataReceivedEventArgs received, TimeSpan totalMediaDuration) { if (engineParameters.InputFile != null) { RegexEngine.TestVideo(received.Data, engineParameters); RegexEngine.TestAudio(received.Data, engineParameters); Match matchDuration = RegexEngine.Index[RegexEngine.Find.Duration].Match(received.Data); if (matchDuration.Success) { if (engineParameters.InputFile.Metadata == null) { engineParameters.InputFile.Metadata = new Metadata(); } TimeSpan.TryParse(matchDuration.Groups[1].Value, out totalMediaDuration); engineParameters.InputFile.Metadata.Duration = totalMediaDuration; } } }
/// <summary> Starts FFmpeg process. </summary> /// <exception cref="InvalidOperationException"> /// Thrown when the requested operation is /// invalid. /// </exception> /// <exception cref="Exception"> /// Thrown when an exception error condition /// occurs. /// </exception> /// <param name="engineParameters"> The engine parameters. </param> private void StartFFmpegProcess(EngineParameters engineParameters) { var receivedMessagesLog = new List <string>(); var processStartInfo = engineParameters.HasCustomArguments ? this.GenerateStartInfo(engineParameters.CustomArguments) : this.GenerateStartInfo(engineParameters); using (this.FFmpegProcess = Process.Start(processStartInfo)) { Exception caughtException = null; if (this.FFmpegProcess == null) { throw new InvalidOperationException(Strings.Exceptions_FFmpeg_Process_Not_Running); } //FFMPEG outputs to "sterr" to keep "stdout" for redirecting to other apps this.FFmpegProcess.ErrorDataReceived += (sender, received) => HandleOutput(engineParameters, received, receivedMessagesLog, ref caughtException); this.FFmpegProcess.BeginErrorReadLine(); this.FFmpegProcess.WaitForExit(); if ((this.FFmpegProcess.ExitCode != 0) || caughtException != null) { // If we are checking the file, do not throw if (engineParameters.Task == FFmpegTask.Check) { HandleCheckResult(engineParameters.InputFile, receivedMessagesLog); } else { throw new Exception( this.FFmpegProcess.ExitCode + ": " + receivedMessagesLog[1] + receivedMessagesLog[0], caughtException); } } } }
/// ------------------------------------------------------------------------------------------------- /// <summary> Starts FFmpeg process. </summary> /// <exception cref="InvalidOperationException"> /// Thrown when the requested operation is /// invalid. /// </exception> /// <exception cref="Exception"> /// Thrown when an exception error condition /// occurs. /// </exception> /// <param name="engineParameters"> The engine parameters. </param> private void StartFFmpegProcess(EngineParameters engineParameters) { List<string> receivedMessagesLog = new List<string>(); TimeSpan totalMediaDuration = new TimeSpan(); ProcessStartInfo processStartInfo = engineParameters.HasCustomArguments ? this.GenerateStartInfo(engineParameters.CustomArguments) : this.GenerateStartInfo(engineParameters); using (this.FFmpegProcess = Process.Start(processStartInfo)) { Exception caughtException = null; if (this.FFmpegProcess == null) { throw new InvalidOperationException(Resources.Exceptions_FFmpeg_Process_Not_Running); } this.FFmpegProcess.ErrorDataReceived += (sender, received) => { if (received.Data == null) return; #if (DebugToConsole) Console.WriteLine(received.Data); #endif try { receivedMessagesLog.Insert(0, received.Data); if (engineParameters.InputFile != null) { RegexEngine.TestVideo(received.Data, engineParameters); RegexEngine.TestAudio(received.Data, engineParameters); Match matchDuration = RegexEngine.Index[RegexEngine.Find.Duration].Match(received.Data); if (matchDuration.Success) { if (engineParameters.InputFile.Metadata == null) { engineParameters.InputFile.Metadata = new Metadata(); } TimeSpan.TryParse(matchDuration.Groups[1].Value, out totalMediaDuration); engineParameters.InputFile.Metadata.Duration = totalMediaDuration; } } ConversionCompleteEventArgs convertCompleteEvent; ConvertProgressEventArgs progressEvent; if (RegexEngine.IsProgressData(received.Data, out progressEvent)) { progressEvent.TotalDuration = totalMediaDuration; this.OnProgressChanged(progressEvent); } else if (RegexEngine.IsConvertCompleteData(received.Data, out convertCompleteEvent)) { convertCompleteEvent.TotalDuration = totalMediaDuration; this.OnConversionComplete(convertCompleteEvent); } } catch (Exception ex) { // catch the exception and kill the process since we're in a faulted state caughtException = ex; try { this.FFmpegProcess.Kill(); } catch (InvalidOperationException) { // swallow exceptions that are thrown when killing the process, // one possible candidate is the application ending naturally before we get a chance to kill it } } }; this.FFmpegProcess.BeginErrorReadLine(); this.FFmpegProcess.WaitForExit(); if ((this.FFmpegProcess.ExitCode != 0 && this.FFmpegProcess.ExitCode != 1) || caughtException != null) { throw new Exception( this.FFmpegProcess.ExitCode + ": " + receivedMessagesLog[1] + receivedMessagesLog[0], caughtException); } } }
/// ------------------------------------------------------------------------------------------------- /// <summary> Starts FFmpeg process. </summary> /// <exception cref="InvalidOperationException"> /// Thrown when the requested operation is /// invalid. /// </exception> /// <exception cref="Exception"> /// Thrown when an exception error condition /// occurs. /// </exception> /// <param name="engineParameters"> The engine parameters. </param> private void StartFFmpegProcess(EngineParameters engineParameters) { var receivedMessagesLog = new List <string>(); var totalMediaDuration = new TimeSpan(); var processStartInfo = engineParameters.HasCustomArguments ? GenerateStartInfo(engineParameters.CustomArguments) : GenerateStartInfo(engineParameters); using (FFmpegProcess = Process.Start(processStartInfo)) { Exception caughtException = null; if (FFmpegProcess == null) { throw new InvalidOperationException(Resources.Exceptions_FFmpeg_Process_Not_Running); } FFmpegProcess.ErrorDataReceived += (sender, received) => { if (received.Data == null) { return; } #if (DebugToConsole) Console.WriteLine(received.Data); #endif try { receivedMessagesLog.Insert(0, received.Data); if (engineParameters.InputFile != null) { RegexEngine.TestVideo(received.Data, engineParameters); RegexEngine.TestAudio(received.Data, engineParameters); var matchDuration = RegexEngine.Index[RegexEngine.Find.Duration].Match(received.Data); if (matchDuration.Success) { if (engineParameters.InputFile.Metadata == null) { engineParameters.InputFile.Metadata = new Metadata(); } TimeSpan.TryParse(matchDuration.Groups[1].Value, out totalMediaDuration); engineParameters.InputFile.Metadata.Duration = totalMediaDuration; } } if (RegexEngine.IsProgressData(received.Data, out ConvertProgressEventArgs progressEvent)) { progressEvent.TotalDuration = totalMediaDuration; OnProgressChanged(progressEvent); } else if (RegexEngine.IsConvertCompleteData(received.Data, out ConversionCompleteEventArgs convertCompleteEvent)) { convertCompleteEvent.TotalDuration = totalMediaDuration; OnConversionComplete(convertCompleteEvent); } } catch (Exception ex) { // catch the exception and kill the process since we're in a faulted state caughtException = ex; try { FFmpegProcess.Kill(); } catch (InvalidOperationException) { // swallow exceptions that are thrown when killing the process, // one possible candidate is the application ending naturally before we get a chance to kill it } } }; FFmpegProcess.BeginErrorReadLine(); FFmpegProcess.WaitForExit(); if (FFmpegProcess.ExitCode != 0 && FFmpegProcess.ExitCode != 1 || caughtException != null) { throw new Exception( FFmpegProcess.ExitCode + ": " + receivedMessagesLog[1] + receivedMessagesLog[0], caughtException); } } }
private ProcessStartInfo GenerateStartInfo(EngineParameters engineParameters) { string ffmpegCommand = CommandBuilder.Serialize(engineParameters); return new ProcessStartInfo { Arguments = "-nostdin -y -loglevel info " + ffmpegCommand, FileName = FFmpegFilePath, CreateNoWindow = true, RedirectStandardInput = false, RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false, WindowStyle = ProcessWindowStyle.Hidden, WorkingDirectory = Path.GetTempPath() }; }
private ProcessStartInfo GenerateStartInfo(EngineParameters engineParameters) { var arguments = CommandBuilder.Serialize(engineParameters); return(this.GenerateStartInfo(arguments)); }
/// <summary> /// <para> ---</para> /// <para> Converts media with conversion options</para> /// </summary> /// <param name="inputFile">Input file</param> /// <param name="outputFile">Output file</param> /// <param name="options">Conversion options</param> public void Convert(MediaFile inputFile, MediaFile outputFile, ConversionOptions options) { var engineParams = new EngineParameters { InputFile = inputFile, OutputFile = outputFile, ConversionOptions = options, Task = FFmpegTask.Convert }; FFmpegEngine(engineParams); }
public void GenerateGIF(EngineParameters paramters) { paramters.Task = FFmpegTask.GIF; this.FFmpegEngine(paramters); }
private void FFmpegEngine(EngineParameters engineParameters) { if (!engineParameters.InputFile.Filename.StartsWith("http://") && !File.Exists(engineParameters.InputFile.Filename)) { throw new FileNotFoundException(Resources.Exception_Media_Input_File_Not_Found, engineParameters.InputFile.Filename); } try { this.Mutex.WaitOne(); this.StartFFmpegProcess(engineParameters); } finally { this.Mutex.ReleaseMutex(); } }
/// ------------------------------------------------------------------------------------------------- /// <summary> /// <para> Retrieve media metadata</para> /// </summary> /// <param name="inputFile"> Retrieves the metadata for the input file. </param> public void GetMetadata(MediaFile inputFile) { EngineParameters engineParams = new EngineParameters { InputFile = inputFile, Task = FFmpegTask.GetMetaData }; this.FFmpegEngine(engineParams); }
/// ------------------------------------------------------------------------------------------------- /// <summary> Starts FFmpeg process. </summary> /// <exception cref="InvalidOperationException"> /// Thrown when the requested operation is /// invalid. /// </exception> /// <exception cref="Exception"> /// Thrown when an exception error condition /// occurs. /// </exception> /// <param name="engineParameters"> The engine parameters. </param> private void StartFFmpegProcess(EngineParameters engineParameters) { List <string> receivedMessagesLog = new List <string>(); TimeSpan totalMediaDuration = new TimeSpan(); ProcessStartInfo processStartInfo = engineParameters.HasCustomArguments ? this.GenerateStartInfo(engineParameters.CustomArguments) : this.GenerateStartInfo(engineParameters); using (this.FFmpegProcess = Process.Start(processStartInfo)) { Exception caughtException = null; if (this.FFmpegProcess == null) { throw new InvalidOperationException(Resources.Exceptions_FFmpeg_Process_Not_Running); } this.FFmpegProcess.ErrorDataReceived += (sender, received) => { if (received.Data == null) { return; } #if (DebugToConsole) Console.WriteLine(received.Data); #endif try { receivedMessagesLog.Insert(0, received.Data); if (engineParameters.InputFile != null) { RegexEngine.TestVideo(received.Data, engineParameters); RegexEngine.TestAudio(received.Data, engineParameters); Match matchDuration = RegexEngine.Index[RegexEngine.Find.Duration].Match(received.Data); if (matchDuration.Success) { if (engineParameters.InputFile.Metadata == null) { engineParameters.InputFile.Metadata = new Metadata(); } TimeSpan.TryParse(matchDuration.Groups[1].Value, out totalMediaDuration); engineParameters.InputFile.Metadata.Duration = totalMediaDuration; } } ConversionCompleteEventArgs convertCompleteEvent; ConvertProgressEventArgs progressEvent; if (RegexEngine.IsProgressData(received.Data, out progressEvent)) { progressEvent.TotalDuration = totalMediaDuration; this.OnProgressChanged(progressEvent); } else if (RegexEngine.IsConvertCompleteData(received.Data, out convertCompleteEvent)) { convertCompleteEvent.TotalDuration = totalMediaDuration; this.OnConversionComplete(convertCompleteEvent); } } catch (Exception ex) { // catch the exception and kill the process since we're in a faulted state caughtException = ex; try { this.FFmpegProcess.Kill(); } catch (InvalidOperationException) { // swallow exceptions that are thrown when killing the process, // one possible candidate is the application ending naturally before we get a chance to kill it } } }; if (engineParameters.ReturningStandardOutput) { FileStream baseStream = this.FFmpegProcess.StandardOutput.BaseStream as FileStream; this.thumbnailByteArray = null; using (MemoryStream ms = new MemoryStream()) { baseStream.CopyTo(ms); this.thumbnailByteArray = ms.ToArray(); } } this.FFmpegProcess.BeginErrorReadLine(); this.FFmpegProcess.WaitForExit(); if ((this.FFmpegProcess.ExitCode != 0 && this.FFmpegProcess.ExitCode != 1) || caughtException != null) { throw new Exception( this.FFmpegProcess.ExitCode + ": " + receivedMessagesLog[1] + receivedMessagesLog[0], caughtException); } } }
private ProcessStartInfo GenerateStartInfo(EngineParameters engineParameters) { string arguments = CommandBuilder.Serialize(engineParameters); return this.GenerateStartInfo(arguments); }
/// <summary> /// Where the magic happens /// </summary> /// <param name="engineParameters">The engine parameters</param> private void FFmpegEngine(EngineParameters engineParameters) { if (!File.Exists(engineParameters.InputFile.Filename)) throw new FileNotFoundException("Input file not found", engineParameters.InputFile.Filename); // Locking the process to ensure FFmpeg is used by one thread at a time. lock (Lock) { //Initialize(); var receivedMessagesLog = new List<string>(); var totalMediaDuration = new TimeSpan(); ProcessStartInfo processStartInfo = GenerateStartInfo(engineParameters); using (_ffmpegProcess = Process.Start(processStartInfo)) { if (_ffmpegProcess == null) throw new InvalidOperationException("FFmpeg process is not running."); _ffmpegProcess.ErrorDataReceived += delegate(object sender, DataReceivedEventArgs received) { if (received.Data == null) return; #if (DebugToConsole) Console.WriteLine(received.Data); #endif receivedMessagesLog.Insert(0, received.Data); RegexEngine.TestVideo(received.Data, engineParameters); RegexEngine.TestAudio(received.Data, engineParameters); Match matchDuration = RegexEngine.Index[RegexEngine.Find.Duration].Match(received.Data); if (matchDuration.Success) { if (engineParameters.InputFile.Metadata == null) engineParameters.InputFile.Metadata = new Metadata(); TimeSpan.TryParse(matchDuration.Groups[1].Value, out totalMediaDuration); engineParameters.InputFile.Metadata.Duration = totalMediaDuration; } ConversionCompleteEventArgs convertCompleteEvent; ConvertProgressEventArgs progressEvent; if (RegexEngine.IsProgressData(received.Data, out progressEvent)) { progressEvent.TotalDuration = totalMediaDuration; OnProgressChanged(progressEvent); } else if (RegexEngine.IsConvertCompleteData(received.Data, out convertCompleteEvent)) { convertCompleteEvent.TotalDuration = totalMediaDuration; OnConversionComplete(convertCompleteEvent); } }; _ffmpegProcess.BeginErrorReadLine(); _ffmpegProcess.WaitForExit(); if (_ffmpegProcess.ExitCode != 0 && _ffmpegProcess.ExitCode != 1) throw new Exception(_ffmpegProcess.ExitCode + ": " + receivedMessagesLog[1] + receivedMessagesLog[0]); } } }
private static string GetStoryboard(EngineParameters engineParameters) { var result = $"-hide_banner -y -i {engineParameters.InputFile.Filename} {engineParameters.StoryBoardOptions.Serialize()}"; return(result); }
public static string GetHealthCheck(EngineParameters engineParameters) { return($"-hide_banner -y -i {engineParameters.InputFile.Filename} -v error -f null 2>&1"); }
public void GenerateHLS(EngineParameters parameters) { parameters.Task = FFmpegTask.GenerateHLS; this.FFmpegEngine(parameters); }
/// ------------------------------------------------------------------------------------------------- /// <summary> Retrieve a thumbnail image from a video file. </summary> /// <param name="inputFile"> Video file. </param> /// <param name="outputFile"> Image file. </param> /// <param name="options"> Conversion options. </param> public void GetThumbnail(MediaFile inputFile, MediaFile outputFile, ConversionOptions options) { EngineParameters engineParams = new EngineParameters { InputFile = inputFile, OutputFile = outputFile, ConversionOptions = options, Task = FFmpegTask.GetThumbnail }; this.FFmpegEngine(engineParams); }