MV10
commented
4 years ago I've just hacked together an async Channel<string> buffering setup and performance is equivalent to suppressing console output. I did a quick-and-dirty test by "buffering" to a public string in Program.cs, and only dumping that after the recording stopped. With buffering, ffmpeg settled at a comfortable 1.23x speed across just about any duration of recording. The channel approach shown below yields the same results but you still get realtime console output during recording.
With Console.WriteLine in the mix, ffmpeg often dropped to about 1.13x on a static scene and dipped below 1.0x with a lot of motion (which is when you lose recording time vs requested duration). It also dropped frames a lot more often, probably thanks to Console.WriteLine's blocking behavior.
Here's what I did in a local copy of the ffmpeg handler. There's probably architecturally better ways to fit this into your project but this works as a proof of concept.
First, a helper function to create the channel:
/// <summary>
/// Convenience method for creating the Channel used to buffer console output. Pass
/// this to the constructor, then await Task.WhenAll for both MMALCamera.ProcessAsync
/// and EmitStdOutBuffer.
/// </summary>
/// <returns>A new unbounded Channel object.</returns>
public static Channel<string> CreateStdOutBuffer()
=> Channel.CreateUnbounded<string>(new UnboundedChannelOptions { SingleReader = true, SingleWriter = true });Modify the constructor and save to an instance variable. If the buffer argument is null, output is completely suppressed. The output events are wired up to a helper method:
private Channel<string> outputBuffer;
public BasicFFMpegCaptureHandler(string argument, Channel<string> stdoutBuffer = null)
{
outputBuffer = stdoutBuffer;
// ...etc
_process.EnableRaisingEvents = true;
_process.OutputDataReceived += WriteToStdOut;
_process.ErrorDataReceived += WriteToStdOut;
// ...etc
}
// Using "async void" is ok for an event-handler. The purpose of a Task is to communicate the
// result of an operation to some external "observer" -- but by definition the caller that fires
// an event doesn't care about the result of the operation. The only caveat is that you get no
// exception handling; an unhandled exception would terminate the process.
private async void WriteToStdOut(object sendingProcess, DataReceivedEventArgs e)
{
try
{
if (outputBuffer != null && e.Data != null)
await outputBuffer.Writer.WriteAsync(e.Data);
}
catch
{ }
}Another helper method to process the buffer:
/// <summary>
/// When console output is buffered, this asynchronously read/writes the buffer contents
/// without blocking ffmpeg, as a raw Console.WriteLine would in response to process output.
/// </summary>
public static async Task EmitStdOutBuffer(Channel<string> stdoutBuffer, CancellationToken cancellationToken)
{
try
{
while (await stdoutBuffer.Reader.WaitToReadAsync(cancellationToken))
Console.WriteLine(await stdoutBuffer.Reader.ReadAsync());
}
catch(OperationCanceledException)
{
// token cancellation, disregard
}
}Then in the application code:
static async Task mp4(int seconds)
{
// routine
MMALCameraConfig.SensorMode = MMALSensorMode.Mode4; // 1296 x 972 with 2x2 binning
var cam = MMALCamera.Instance;
var pathname = "/media/ramdisk/video.mp4";
File.Delete(pathname);
cam.ConfigureCameraSettings();
// get a buffer and pass it to the capture handler
var stdout = BasicFFMpegCaptureHandler.CreateStdOutBuffer();
var ffmpeg = new FFMpegCaptureHandler($"-framerate 24 -i - -b:v 2500k -c copy {pathname}", stdout);
// all of this is routine
var portCfg = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, quality: 10, bitrate: 0, timeout: null);
using var encoder = new MMALVideoEncoder();
using var renderer = new MMALVideoRenderer();
encoder.ConfigureOutputPort(portCfg, ffmpeg);
cam.Camera.VideoPort.ConnectTo(encoder);
cam.Camera.PreviewPort.ConnectTo(renderer);
await Task.Delay(2000);
var token = new CancellationTokenSource(TimeSpan.FromSeconds(seconds));
// concurrently process the video capture and buffered console output
await Task.WhenAll(new Task[]{
cam.ProcessAsync(cam.Camera.VideoPort, token.Token),
BasicFFMpegCaptureHandler.EmitStdOutBuffer(stdout, token.Token)
});
}
If you saw the noise of my earlier posts to this topic -- my apologies, I went from playing with raspivid command lines to using your library -- which is excellent by the way -- and forgot to set a binning mode so I thought I was seeing hard-to-believe overhead. But it did lead me to the console output which is still a small issue.
I've done quite a bit of testing and calling
Console.WriteLinemeasurably degrades ffmpeg performance in the FFmpegCaptureHandler. Not surprisingly, this gets even worse if you're watching that output on a remote terminal. I propose a simple constructor switch to disable that output for running headless, where it wouldn't ever be seen or be useful anyway.Additionally, I don't think Dispose is being called in the handler. For one of my tests I simply buffered the output to a string, then wrote that to the console in the Dispose. It was never output. I backtracked through ProcessAsync and I see where it ought to be called in all the output component code, but it isn't.Edit: This ended up being my fault (forgot the using statement).Also, in addition to
Process.Kill, outside that if-block Dispose should also callProcess.ClosethenProcess.Dispose. Also the catch-block for theProcessmethod in the ffmpeg handler should call Dispoe rather than directly killing the process.I'd be happy to PR some of this but I'm not sure how to track down the Dispose problem yet.