butterflow-ui/butterflow-ui/ButterflowWrapper.cs

382 lines
15 KiB
C#

using csmic;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace butterflow_ui
{
/// <summary> A butterflow wrapper. Provides interaction with the butterflow executable. </summary>
public class ButterflowWrapper : PropertyChangedAlerter
{
#region Members
/// <summary> The RegEx string for matching probed resolution. </summary>
private const string REGEX_RESOLUTION = @"Resolution\s*:\s(?<Width>\d+)x(?<Height>\d+)";
/// <summary> The RegEx string for matching the probed playback rate. </summary>
private const string REGEX_RATE = @"Rate\s*:\s(?<Rate>\d+\.\d+) fps";
/// <summary> The RegEx string for detecting progress made when rendering a video. </summary>
private const string REGEX_PROGRESS = @"To write\:\s*\w*\s*\w*\,*\w*\s*(?<Progress>\d+\.*\d*)%";
/// <summary> An alternative RegEx string for detecting progress made when rendering a video. </summary>
private const string REGEX_PROGRESS_ALT = @"\<Rendering progress\:\s*(?<Progress>\d+\.*\d*)%\>";
/// <summary> The RegEx string for determining available processing devices in butterflow.. </summary>
private const string REGEX_DEVICE = @"\*\s*Device\s*(?<DeviceID>\d+)\s*\:\s*(?<DeviceName>(\w*\s*)*)";
/// <summary> Full pathname of the butterflow executable file. </summary>
private Lazy<string> executablePath = new Lazy<string>(() => Path.Combine(Directory.GetCurrentDirectory(), "ThirdPartyCompiled", "butterflow.exe"));
/// <summary> Queue of butterflow commands to run. </summary>
private Queue<string> runQueue = new Queue<string>();
/// <summary> The console output from butterflow. </summary>
private string consoleOutput = string.Empty;
/// <summary> True if butterflow is running, false if not. </summary>
private bool isRunning;
/// <summary> The progress percentage as reported by butterflow. </summary>
private double progressPercentage;
/// <summary> The running butterflow process. </summary>
private Process runningProcess;
/// <summary> An input interpreter used for converting string values to numeric values. </summary>
private InputInterpreter interpreter = new InputInterpreter();
/// <summary> Event queue for all listeners interested in ParsedConsoleOutputRecieved events. </summary>
public event EventHandler<ButterflowOutputArgs> ParsedConsoleOutputRecieved;
/// <summary> Event queue for all listeners interested in ButterflowExited events. </summary>
public event EventHandler<ButterflowExitArgs> ButterflowExited;
#endregion
#region Properties
/// <summary> Gets the console output from butterflow. </summary>
/// <value> The console output from butterflow. </value>
public string ConsoleOutput
{
get
{
return this.consoleOutput;
}
private set
{
this.consoleOutput = value;
OnPropertyChanged();
}
}
/// <summary> Gets a value indicating whether butterflow is currently running. </summary>
/// <value> True if butterflow is running, false if not. </value>
public bool IsRunning
{
get
{
return this.isRunning;
}
private set
{
this.isRunning = value;
OnPropertyChanged();
}
}
/// <summary> Gets the progress percentage as reported by butterflow. </summary>
/// <value> The progress percentage as reported by butterflow. </value>
public double ProgressPercentage
{
get
{
return this.progressPercentage;
}
private set
{
this.progressPercentage = value;
OnPropertyChanged();
}
}
/// <summary> Gets or sets the list of devices available for butterflow processing. </summary>
/// <value> The devices available for butterflow processing. </value>
public Dictionary<int, string> Devices { get; private set; } = new Dictionary<int, string>() { { 0, Localization.Localization.ForceCPU } };
#endregion
#region Methods
/// <summary> Runs butterflow with the given <paramref name="optionsConfiguration"/> by adding it to the queue. </summary>
/// <param name="optionsConfiguration"> The options configuration. </param>
public void Run(OptionsConfiguration optionsConfiguration)
{
for (int i = 0; i < optionsConfiguration.VideoInput.Count(); i++)
{
var arguments = optionsConfiguration.ToButterflowArguments(i);
this.runQueue.Enqueue(arguments);
}
ProcessQueue();
}
/// <summary> Process the queue of butterflow arguments. </summary>
public void ProcessQueue()
{
if (!this.IsRunning && this.runQueue.Any())
{
var arguments = this.runQueue.Dequeue();
var process = new Process();
process.StartInfo = new ProcessStartInfo(executablePath.Value, arguments);
process.StartInfo.CreateNoWindow = true;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.EnableRaisingEvents = true;
process.OutputDataReceived += Process_OutputDataReceived;
process.ErrorDataReceived += Process_OutputDataReceived;
process.Exited += Process_Exited;
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
this.IsRunning = true;
this.runningProcess = process;
}
}
/// <summary> Kills the running instance of butterflow, cancelling its current operation. </summary>
public void Cancel()
{
if (this.IsRunning && this.runningProcess != null)
{
this.runningProcess.Kill();
}
this.runQueue.Clear();
}
/// <summary> Probes a video file. </summary>
/// <param name="videoFile"> The video file to be probed. </param>
public void Probe(string videoFile)
{
string arguments = string.Format("-prb \"{0}\"", videoFile);
Run(arguments);
}
/// <summary> Gets the devices available for butterflow processing. </summary>
public void GetDevices()
{
string arguments = "--show-devices";
Run(arguments);
}
/// <summary> Runs butterflow with the given <paramref name="arguments"/> by adding it to the queue. </summary>
/// <param name="arguments"> Options for controlling the operation. </param>
private void Run(string arguments)
{
this.runQueue.Enqueue(arguments);
ProcessQueue();
}
/// <summary> Event handler. Called by Process for exited events. </summary>
/// <param name="sender"> Source of the event. </param>
/// <param name="e"> Event information. </param>
private void Process_Exited(object sender, EventArgs e)
{
this.IsRunning = false;
this.runningProcess = null;
OnButterflowExited();
ProcessQueue();
}
/// <summary>
/// Parses console output and attempts to find known values. If a known value is found, the
/// <seealso cref="ParsedConsoleOutputRecieved"/> event is triggered.
/// </summary>
/// <param name="consoleOutput"> The console output from butterflow. </param>
private void ParseConsoleOutput(string consoleOutput)
{
if (string.IsNullOrWhiteSpace(consoleOutput))
{
//Ignore null content and just escape.
return;
}
// Test for resolution
var regex = new Regex(REGEX_RESOLUTION);
foreach (Match match in regex.Matches(consoleOutput))
{
var width = match.Groups["Width"].Value;
var height = match.Groups["Height"].Value;
OnParsedConsoleOutputRecieved(ButterflowOutputType.Width, width, consoleOutput);
OnParsedConsoleOutputRecieved(ButterflowOutputType.Height, height, consoleOutput);
}
// Test for playback rate
regex = new Regex(REGEX_RATE);
foreach (Match match in regex.Matches(consoleOutput))
{
var rate = match.Groups["Rate"].Value;
OnParsedConsoleOutputRecieved(ButterflowOutputType.Rate, rate, consoleOutput);
}
// Test for progress being made when rendering a video
regex = new Regex(REGEX_PROGRESS);
foreach (Match match in regex.Matches(consoleOutput))
{
var progress = match.Groups["Progress"].Value;
this.interpreter.Interpret(progress);
this.ProgressPercentage = this.interpreter.Double;
OnParsedConsoleOutputRecieved(ButterflowOutputType.Progress, progress, consoleOutput);
}
// An alternate test for progression on a rendering video
regex = new Regex(REGEX_PROGRESS_ALT);
foreach (Match match in regex.Matches(consoleOutput))
{
var progress = match.Groups["Progress"].Value;
this.interpreter.Interpret(progress);
this.ProgressPercentage = this.interpreter.Double;
OnParsedConsoleOutputRecieved(ButterflowOutputType.Progress, progress, consoleOutput);
}
// Test for device declaration
regex = new Regex(REGEX_DEVICE);
foreach (Match match in regex.Matches(consoleOutput))
{
var deviceID = match.Groups["DeviceID"].Value;
var deviceName = match.Groups["DeviceName"].Value.Trim();
//Add 1 to the index count. This accounts for the 0 index of the "Force CPU" option in the options window.
this.interpreter.Interpret(string.Concat(deviceID,"+1"));
if (!this.Devices.ContainsKey(this.interpreter.Int))
{
this.Devices.Add(this.interpreter.Int, deviceName);
OnPropertyChanged("Devices");
}
OnParsedConsoleOutputRecieved(ButterflowOutputType.Device, deviceName, consoleOutput);
}
}
/// <summary> Executes the parsed console output recieved action. </summary>
/// <param name="outputType"> Type of the output. </param>
/// <param name="value"> The value. </param>
/// <param name="consoleOutput"> The console output from butterflow. </param>
private void OnParsedConsoleOutputRecieved(ButterflowOutputType outputType, string value, string consoleOutput)
{
this.ParsedConsoleOutputRecieved?.Invoke(this, new ButterflowOutputArgs(outputType, value, consoleOutput));
}
/// <summary> Executes the butterflow exited action. </summary>
private void OnButterflowExited()
{
this.ButterflowExited?.Invoke(this, new ButterflowExitArgs());
}
/// <summary> Event handler. Called by Process for output data received events. </summary>
/// <param name="sender"> Source of the event. </param>
/// <param name="e"> Data received event information. </param>
private void Process_OutputDataReceived(object sender, DataReceivedEventArgs e)
{
this.ConsoleOutput += string.Format("{0}{1}", e.Data, Environment.NewLine);
ParseConsoleOutput(e.Data);
}
#endregion
#region Subclasses
/// <summary> Arguments for butterflow output events where a known value of type <seealso cref="ButterflowOutputType"/> can be parsed. </summary>
public class ButterflowOutputArgs : ButterflowConsoleOutputArgs
{
#region Properties
/// <summary> Gets or sets the type of the output detected from butterflow. </summary>
/// <value> The type of the output detected from butterflow. </value>
public ButterflowOutputType OutputType { get; private set; }
/// <summary> Gets or sets the value detected from butterflow. </summary>
/// <value> The value detected from butterflow. </value>
public string Value { get; private set; }
#endregion
/// <summary> Constructor. </summary>
/// <param name="outputType"> The type of the output detected from butterflow. </param>
/// <param name="value"> The value detected from butterflow. </param>
/// <param name="consoleOutput"> The console output. </param>
public ButterflowOutputArgs(ButterflowOutputType outputType, string value, string consoleOutput)
: base(consoleOutput)
{
this.OutputType = outputType;
this.Value = value;
}
}
/// <summary> Arguments for butterflow console output events. </summary>
public class ButterflowConsoleOutputArgs : EventArgs
{
#region Properties
/// <summary> Gets the console output. </summary>
/// <value> The console output. </value>
public string ConsoleOutput { get; private set; }
#endregion
#region Constructors
/// <summary> Constructor. </summary>
/// <param name="consoleOutput"> The console output. </param>
public ButterflowConsoleOutputArgs(string consoleOutput)
{
this.ConsoleOutput = consoleOutput;
}
#endregion
}
/// <summary> Arguments for butterflow exiting. </summary>
public class ButterflowExitArgs : EventArgs
{
#region Constructors
public ButterflowExitArgs()
{
//
}
#endregion
}
/// <summary> Values that represent butterflow output types. </summary>
public enum ButterflowOutputType
{
/// <summary> Video Width. </summary>
Width,
/// <summary> Video Height. </summary>
Height,
/// <summary> Video playback rate. </summary>
Rate,
/// <summary> Video processing progress. </summary>
Progress,
/// <summary> An available processing device. </summary>
Device
}
#endregion
}
}