public async Task TakeVideoAndStoreTimestamps()
{
TestHelper.BeginTest("Video - TakeVideoAndStoreTimestamps");
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "h264", true))
using (var preview = new MMALVideoRenderer())
using (var vidEncoder = new MMALVideoEncoder())
{
Fixture.MMALCamera.ConfigureCameraSettings();
var portConfig = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, bitrate: MMALVideoEncoder.MaxBitrateLevel4);
vidEncoder.ConfigureOutputPort(portConfig, vidCaptureHandler);
// Create our component pipeline.
Fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
Fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(preview);
// Camera warm up time
await Task.Delay(2000);
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
// Record video for 15 seconds
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
Fixture.CheckAndAssertFilepath(vidCaptureHandler.GetFilepath());
Fixture.CheckAndAssertFilepath($"{vidCaptureHandler.Directory}/{vidCaptureHandler.CurrentFilename}.pts");
}
}
public void StartStreamingAsync(string url, string streamName, TimeSpan duration)
{
var camera = MMALCamera.Instance;
AsyncContext.Run(async() =>
{
using (var ffCaptureHandler = new FFmpegCaptureHandler($"-i - -vcodec copy -an -f flv {url}{streamName}"))
using (var vidEncoder = new MMALVideoEncoder(ffCaptureHandler, new MMAL_RATIONAL_T(25, 1), DateTime.Now.Add(duration)))
using (var renderer = new MMALVideoRenderer())
{
camera.ConfigureCameraSettings();
//Create our component pipeline. Here we are using the H.264 standard with a YUV420 pixel format. The video will be taken at 25mb/s at the highest quality setting (10).
vidEncoder.ConfigureOutputPort(0, MMALEncoding.H264, MMALEncoding.I420, 0, 25000000);
camera.Camera.VideoPort.ConnectTo(vidEncoder);
camera.Camera.PreviewPort.ConnectTo(renderer);
//Camera warm up time
await Task.Delay(2000);
//Take video for 3 minutes.
await camera.BeginProcessing(camera.Camera.VideoPort);
}
});
camera.Cleanup();
}
private async Task Runner()
{
Logger.LogInformation("Starting video stream");
var camera = MMALCamera.Instance;
try
{
using (var streamHandler = new CircularStreamHandler(_stream))
using (var videoEncoder = new MMALVideoEncoder(streamHandler))
{
camera.ConfigureCameraSettings();
videoEncoder.ConfigureOutputPort(0, MMALEncoding.H264, MMALEncoding.I420, 0);
camera.Camera.VideoPort.ConnectTo(videoEncoder);
await Task.Delay(2000); // warm up
Logger.LogInformation("Ready to stream");
await camera.ProcessAsync(camera.Camera.VideoPort, Lifetime.ApplicationStopping);
}
}
catch (Exception ex)
{
Logger.LogError(ex, "Error getting video stream: {Exception}", ex.Message);
throw;
}
finally
{
camera.Cleanup();
}
}
public async Task TakeVideo(string extension, MMALEncoding encodingType, MMALEncoding pixelFormat)
{
TestHelper.BeginTest("TakeVideo", encodingType.EncodingName, pixelFormat.EncodingName);
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", extension))
using (var preview = new MMALVideoRenderer())
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler))
{
Fixture.MMALCamera.ConfigureCameraSettings();
var portConfig = new MMALPortConfig(encodingType, pixelFormat, 25, 10, 25000000, null);
vidEncoder.ConfigureOutputPort(portConfig);
// Create our component pipeline.
Fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
Fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(preview);
// Camera warm up time
await Task.Delay(2000);
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
// Record video for 20 seconds
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
Fixture.CheckAndAssertFilepath(vidCaptureHandler.GetFilepath());
}
}
public async Task TakeVideoWithCircularBuffer(string extension, MMALEncoding encodingType, MMALEncoding pixelFormat)
{
TestHelper.BeginTest("TakeVideoWithCircularBuffer", encodingType.EncodingName, pixelFormat.EncodingName);
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var circularBufferHandler = new CircularBufferCaptureHandler(4096, "/home/pi/videos/tests", extension))
using (var preview = new MMALVideoRenderer())
using (var vidEncoder = new MMALVideoEncoder())
{
Fixture.MMALCamera.ConfigureCameraSettings();
var portConfig = new MMALPortConfig(encodingType, pixelFormat, 10, 25000000, null, storeMotionVectors: true);
vidEncoder.ConfigureOutputPort(portConfig, circularBufferHandler);
// Create our component pipeline.
Fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
Fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(preview);
// Camera warm up time
await Task.Delay(2000);
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
// Record video for 10 seconds
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
// Check that the circular buffer has stored some data during the recording operation.
Assert.True(circularBufferHandler.Buffer.Size > 0);
}
}
public static void TakeVideoManualMode()
{
MMALCamera cam = MMALCamera.Instance;
AsyncContext.Run(async() =>
{
//using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/", "mjpeg"))
using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/", "avi"))
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler))
//using (var ffCaptureHandler = FFmpegCaptureHandler.RawVideoToAvi("/home/pi/videos/", "testing1234"))
//using (var vidEncoder = new MMALVideoEncoder(ffCaptureHandler))
using (var renderer = new MMALVideoRenderer())
{
cam.ConfigureCameraSettings();
// Create our component pipeline. Here we are using the H.264 standard with a YUV420 pixel format. The video will be taken at 25Mb/s.
vidEncoder.ConfigureOutputPort(0, MMALEncoding.MJPEG, MMALEncoding.I420, 90, 25000000);
cam.Camera.VideoPort.ConnectTo(vidEncoder);
cam.Camera.PreviewPort.ConnectTo(renderer);
// Camera warm up time
await Task.Delay(2000);
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
// Take video for 3 minutes.
await cam.ProcessAsync(cam.Camera.VideoPort, cts.Token);
}
});
cam.Cleanup();
}
/// <summary>
/// Self-contained method for recording H.264 video for a specified amount of time. Records at 30fps, 25Mb/s at the highest quality.
/// </summary>
/// <param name="handler">The video capture handler to apply to the encoder.</param>
/// <param name="cancellationToken">A cancellationToken to signal when to stop video capture.</param>
/// <param name="split">Used for Segmented video mode.</param>
/// <returns>The awaitable Task.</returns>
public async Task TakeVideo(VideoStreamCaptureHandler handler, CancellationToken cancellationToken, Split split = null)
{
if (split != null && !MMALCameraConfig.InlineHeaders)
{
MMALLog.Logger.Warn("Inline headers not enabled. Split mode not supported when this is disabled.");
split = null;
}
using (var vidEncoder = new MMALVideoEncoder(handler, null, split))
using (var renderer = new MMALVideoRenderer())
{
this.ConfigureCameraSettings();
vidEncoder.ConfigureOutputPort(MMALEncoding.H264, MMALEncoding.I420, 0, MMALVideoEncoder.MaxBitrateLevel4);
// Create our component pipeline.
this.Camera.VideoPort.ConnectTo(vidEncoder);
this.Camera.PreviewPort.ConnectTo(renderer);
MMALLog.Logger.Info($"Preparing to take video. Resolution: {vidEncoder.Width} x {vidEncoder.Height}. " +
$"Encoder: {vidEncoder.Outputs[0].EncodingType.EncodingName}. Pixel Format: {vidEncoder.Outputs[0].PixelFormat.EncodingName}.");
// Camera warm up time
await Task.Delay(2000);
await this.ProcessAsync(this.Camera.VideoPort, cancellationToken);
}
}
public async Task AnnotateVideoRefreshSeconds()
{
TestHelper.BeginTest("Video - AnnotateVideo");
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
MMALCameraConfig.Annotate = new AnnotateImage();
MMALCameraConfig.Annotate.RefreshRate = DateTimeTextRefreshRate.Seconds;
MMALCameraConfig.Annotate.TimeFormat = "HH:mm:ss";
using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "h264"))
using (var vidEncoder = new MMALVideoEncoder())
using (var renderer = new MMALVideoRenderer())
{
Fixture.MMALCamera.ConfigureCameraSettings();
var portConfig = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, quality: 10, bitrate: MMALVideoEncoder.MaxBitrateLevel4);
// Create our component pipeline. Here we are using the H.264 standard with a YUV420 pixel format. The video will be taken at 25Mb/s.
vidEncoder.ConfigureOutputPort(portConfig, vidCaptureHandler);
Fixture.MMALCamera.Camera.VideoPort.ConnectTo(vidEncoder);
Fixture.MMALCamera.Camera.PreviewPort.ConnectTo(renderer);
// Camera warm up time
await Task.Delay(2000);
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
// Take video for 30 seconds.
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
Fixture.CheckAndAssertFilepath(vidCaptureHandler.GetFilepath());
}
}
public void TakeVideoSplit(string extension, MMALEncoding encodingType, MMALEncoding pixelFormat)
{
TestHelper.SetConfigurationDefaults();
MMALCameraConfig.InlineHeaders = true;
AsyncContext.Run(async() =>
{
var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests/split_test", extension);
TestHelper.CleanDirectory("/home/pi/videos/tests/split_test");
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler, new MMAL_RATIONAL_T(25, 1),
DateTime.Now.AddSeconds(30), new Split {
Mode = TimelapseMode.Second, Value = 15
}))
{
vidEncoder.ConfigureOutputPort(0, encodingType, pixelFormat, 10, 25000000);
//Create our component pipeline.
fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(new MMALVideoRenderer());
fixture.MMALCamera.ConfigureCameraSettings();
//2 files should be created from this test.
await fixture.MMALCamera.BeginProcessing(fixture.MMALCamera.Camera.VideoPort, vidEncoder);
Assert.True(Directory.GetFiles("/home/pi/videos/tests/split_test").Length == 2);
}
});
}
public async Task RawVideoConvert()
{
TestHelper.BeginTest("RawVideoConvert");
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var ffCaptureHandler = FFmpegCaptureHandler.RawVideoToAvi("/home/pi/videos/tests", "testing1234"))
using (var vidEncoder = new MMALVideoEncoder())
using (var renderer = new MMALVideoRenderer())
{
Fixture.MMALCamera.ConfigureCameraSettings();
var portConfig = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 10, 25000000, null);
vidEncoder.ConfigureOutputPort(portConfig, ffCaptureHandler);
Fixture.MMALCamera.Camera.VideoPort.ConnectTo(vidEncoder);
Fixture.MMALCamera.Camera.PreviewPort.ConnectTo(renderer);
// Camera warm up time
await Task.Delay(2000);
var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
// Take video for 1 minute.
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
Fixture.CheckAndAssertFilepath("/home/pi/videos/tests/testing1234.avi");
}
}
static async Task fragmp4(int seconds)
{
// This generates a "fragmented" MP4 which should be larger than an MP4
// with a normal single MOOV atom trailer at the end of the file. See:
// https://superuser.com/a/1530949/143047
// 10 seconds of "-badmp4" is 34MB
// 10 seconds of "-fragmp4" is 26MB regardless of the other options described in the link
// 60 seconds (bad) is 219MB versus 208MB (frag) and again we lose 2 seconds
// -g is keyframe rate, default is 250
// -flush_packets 1 flushes the I/O stream after each packet, decreasing latency (apparently)
// adding two seconds to the requested duration approximates the regular file size (10s = 33MB, 60s = 218MB)
seconds += 2; // HACK! see above
var cam = GetConfiguredCamera();
var pathname = ramdiskPath + "video.mp4";
Directory.CreateDirectory(ramdiskPath);
File.Delete(pathname);
Console.WriteLine("Preparing pipeline...");
cam.ConfigureCameraSettings();
using (var ffmpeg = new ExternalProcessCaptureHandler(
new ExternalProcessCaptureHandlerOptions
{
Filename = "ffmpeg",
Arguments = $"-framerate 24 -i - -b:v 2500k -c copy -movflags +frag_keyframe+separate_moof+omit_tfhd_offset+empty_moov {pathname}",
EchoOutput = true,
DrainOutputDelayMs = 500, // default
TerminationSignals = new[] { Signum.SIGINT, Signum.SIGQUIT }, // not the supposedly-correct SIGINT+SIGINT but this produces some exit output
}))
{
// quality arg-help says set bitrate zero to use quality for VBR
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);
Console.WriteLine("Camera warmup...");
await Task.Delay(2000);
Console.WriteLine($"Capturing MP4: {pathname}");
var timerToken = new CancellationTokenSource(TimeSpan.FromSeconds(seconds));
await Task.WhenAll(new Task[] {
ffmpeg.ManageProcessLifecycleAsync(timerToken.Token),
cam.ProcessAsync(cam.Camera.VideoPort, timerToken.Token),
}).ConfigureAwait(false);
}
// can't use the convenient fall-through using or MMALCamera.Cleanup
// throws: Argument is invalid. Unable to destroy component
cam.Cleanup();
Console.WriteLine("Exiting.");
}
public async Task ImageFxComponentFromCameraVideoPortWithSplitterAndEncoder(MMAL_PARAM_IMAGEFX_T effect, bool throwsException)
{
TestHelper.BeginTest($"Video - ImageFxComponentFromCameraVideoPortWithSplitterAndEncoder - {effect}");
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "h264"))
using (var preview = new MMALNullSinkComponent())
using (var imageFx = new MMALImageFxComponent())
using (var splitter = new MMALSplitterComponent())
using (var vidEncoder = new MMALVideoEncoder())
{
Fixture.MMALCamera.ConfigureCameraSettings();
var vidEncoderConfig = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420);
var splitterConfig = new MMALPortConfig(MMALEncoding.I420, MMALEncoding.I420);
var fxConfig = new MMALPortConfig(MMALEncoding.I420, MMALEncoding.I420);
imageFx.ConfigureOutputPort <VideoPort>(0, fxConfig, null);
splitter.ConfigureInputPort(new MMALPortConfig(MMALEncoding.I420, MMALEncoding.I420), imageFx.Outputs[0], null);
splitter.ConfigureOutputPort <VideoPort>(0, splitterConfig, null);
vidEncoder.ConfigureInputPort(new MMALPortConfig(MMALEncoding.I420, MMALEncoding.I420), splitter.Outputs[0], null);
vidEncoder.ConfigureOutputPort(0, vidEncoderConfig, vidCaptureHandler);
if (throwsException)
{
Assert.Throws <MMALInvalidException>(() =>
{
imageFx.ImageEffect = effect;
});
}
else
{
imageFx.ImageEffect = effect;
}
// Create our component pipeline.
Fixture.MMALCamera.Camera.VideoPort
.ConnectTo(imageFx);
Fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(preview);
imageFx.Outputs[0].ConnectTo(splitter);
splitter.Outputs[0].ConnectTo(vidEncoder);
// Camera warm up time
await Task.Delay(2000);
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
Fixture.CheckAndAssertFilepath(vidCaptureHandler.GetFilepath());
}
}
public async Task ChangeEncoderType()
{
TestHelper.BeginTest("Video - ChangeEncoderType");
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "h264"))
using (var preview = new MMALVideoRenderer())
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler))
{
Fixture.MMALCamera.ConfigureCameraSettings();
var portConfig = new MMALPortConfig(MMALEncoding.MJPEG, MMALEncoding.I420, 25, 10, 25000000, null);
vidEncoder.ConfigureOutputPort(portConfig);
// Create our component pipeline.
Fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
Fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(preview);
// Camera warm up time
await Task.Delay(2000);
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
// Record video for 20 seconds
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
Fixture.CheckAndAssertFilepath(vidCaptureHandler.GetFilepath());
}
using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "mjpeg"))
using (var preview = new MMALVideoRenderer())
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler))
{
Fixture.MMALCamera.ConfigureCameraSettings();
var portConfig = new MMALPortConfig(MMALEncoding.MJPEG, MMALEncoding.I420, 25, 10, 25000000, null);
vidEncoder.ConfigureOutputPort(portConfig);
// Create our component pipeline.
Fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
Fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(preview);
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
// Record video for 20 seconds
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
Fixture.CheckAndAssertFilepath(vidCaptureHandler.GetFilepath());
}
}
static async Task badmp4(int seconds)
{
Console.WriteLine("\n\nWARNING:\nffmpeg can't create a valid MP4 when running as a child process.\nSee repository README. This code is here for reference only.\n\nPress any key...");
Console.ReadKey(true);
var cam = GetConfiguredCamera();
var pathname = ramdiskPath + "video.mp4";
Directory.CreateDirectory(ramdiskPath);
File.Delete(pathname);
Console.WriteLine("Preparing pipeline...");
cam.ConfigureCameraSettings();
using (var ffmpeg = new ExternalProcessCaptureHandler(
new ExternalProcessCaptureHandlerOptions
{
Filename = "ffmpeg",
Arguments = $"-framerate 24 -i - -b:v 2500k -c copy {pathname}",
EchoOutput = true,
DrainOutputDelayMs = 500, // default
TerminationSignals = new[] { Signum.SIGINT, Signum.SIGQUIT }, // not the supposedly-correct SIGINT+SIGINT but this produces some exit output
}))
{
// quality arg-help says set bitrate zero to use quality for VBR
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);
Console.WriteLine("Camera warmup...");
await Task.Delay(2000);
Console.WriteLine($"Capturing MP4: {pathname}");
var timerToken = new CancellationTokenSource(TimeSpan.FromSeconds(seconds));
await Task.WhenAll(new Task[] {
ffmpeg.ManageProcessLifecycleAsync(timerToken.Token),
cam.ProcessAsync(cam.Camera.VideoPort, timerToken.Token),
}).ConfigureAwait(false);
}
// can't use the convenient fall-through using or MMALCamera.Cleanup
// throws: Argument is invalid. Unable to destroy component
cam.Cleanup();
Console.WriteLine("Exiting. Remember, video.mp4 is not valid.");
}
static async Task stream(int seconds)
{
var cam = GetConfiguredCamera();
MMALCameraConfig.VideoResolution = new MMALSharp.Common.Utility.Resolution(640, 480);
MMALCameraConfig.SensorMode = MMALSensorMode.Mode7; // for some reason mode 6 has a pinkish tinge
MMALCameraConfig.VideoFramerate = new MMAL_RATIONAL_T(20, 1);
Console.WriteLine("Preparing pipeline...");
cam.ConfigureCameraSettings();
// note cvlc requires real quotes even though we used apostrophes for the command line equivalent
using (var vlc = new ExternalProcessCaptureHandler(
new ExternalProcessCaptureHandlerOptions
{
Filename = "cvlc",
Arguments = @"stream:///dev/stdin --sout ""#transcode{vcodec=mjpg,vb=2500,fps=20,acodec=none}:standard{access=http{mime=multipart/x-mixed-replace;boundary=7b3cc56e5f51db803f790dad720ed50a},mux=mpjpeg,dst=:8554/}"" :demux=h264",
EchoOutput = true,
DrainOutputDelayMs = 500, // default
TerminationSignals = ExternalProcessCaptureHandlerOptions.signalsVLC
}))
{
var portCfg = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, quality: 0, bitrate: MMALVideoEncoder.MaxBitrateMJPEG, timeout: null);
using var encoder = new MMALVideoEncoder();
using var renderer = new MMALVideoRenderer();
encoder.ConfigureOutputPort(portCfg, vlc);
cam.Camera.VideoPort.ConnectTo(encoder);
cam.Camera.PreviewPort.ConnectTo(renderer);
Console.WriteLine("Camera warmup...");
await Task.Delay(2000);
Console.WriteLine($"Streaming MJPEG for {seconds} sec to:");
Console.WriteLine($"http://{Environment.MachineName}.local:8554/");
var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(seconds));
await Task.WhenAll(new Task[] {
vlc.ManageProcessLifecycleAsync(timeout.Token),
cam.ProcessAsync(cam.Camera.VideoPort, timeout.Token),
}).ConfigureAwait(false);
}
// can't use the convenient fall-through using or MMALCamera.Cleanup
// throws: Argument is invalid. Unable to destroy component
cam.Cleanup();
Console.WriteLine("Exiting.");
}
public async Task TakeVideoSplit()
{
TestHelper.BeginTest("TakeVideoSplit");
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests/split_test");
MMALCameraConfig.InlineHeaders = true;
using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests/split_test", "h264"))
using (var preview = new MMALVideoRenderer())
using (var vidEncoder = new MMALVideoEncoder())
{
Fixture.MMALCamera.ConfigureCameraSettings();
var split = new Split
{
Mode = TimelapseMode.Second,
Value = 15
};
var portConfig = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 10, 25000000, null, split);
vidEncoder.ConfigureOutputPort(portConfig, vidCaptureHandler);
// Create our component pipeline.
Fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
Fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(preview);
// Camera warm up time
await Task.Delay(2000);
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
// 2 files should be created from this test.
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
Assert.True(Directory.GetFiles("/home/pi/videos/tests/split_test").Length == 2);
}
}
public async Task TakeVideoAndStoreMotionVectors(string extension, MMALEncoding encodingType, MMALEncoding pixelFormat)
{
TestHelper.BeginTest("TakeVideoAndStoreMotionVectors", encodingType.EncodingName, pixelFormat.EncodingName);
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
// Ensure inline motion vectors are enabled.
MMALCameraConfig.InlineMotionVectors = true;
using (var motionVectorStore = File.Create("/home/pi/videos/tests/motion.dat"))
using (var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", extension))
using (var preview = new MMALVideoRenderer())
using (var vidEncoder = new MMALVideoEncoder())
{
Fixture.MMALCamera.ConfigureCameraSettings();
var portConfig = new MMALPortConfig(encodingType, pixelFormat, 10, 25000000, null, storeMotionVectors: true);
vidEncoder.ConfigureOutputPort(portConfig, vidCaptureHandler);
// Initialise the motion vector stream.
vidCaptureHandler.InitialiseMotionStore(motionVectorStore);
// Create our component pipeline.
Fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
Fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(preview);
// Camera warm up time
await Task.Delay(2000);
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
// Record video for 10 seconds
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort, cts.Token);
Fixture.CheckAndAssertFilepath(vidCaptureHandler.GetFilepath());
}
}
public void TakeVideo(string extension, MMALEncoding encodingType, MMALEncoding pixelFormat)
{
TestHelper.SetConfigurationDefaults();
AsyncContext.Run(async() =>
{
var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", extension);
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler, new MMAL_RATIONAL_T(25, 1), DateTime.Now.AddSeconds(20)))
{
fixture.MMALCamera.ConfigureCameraSettings();
vidEncoder.ConfigureOutputPort(0, encodingType, pixelFormat, 10, 25000000);
//Create our component pipeline.
fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(new MMALVideoRenderer());
//Camera warm up time
await Task.Delay(2000);
//Record video for 20 seconds
await fixture.MMALCamera.BeginProcessing(fixture.MMALCamera.Camera.VideoPort);
if (System.IO.File.Exists(vidCaptureHandler.GetFilepath()))
{
var length = new System.IO.FileInfo(vidCaptureHandler.GetFilepath()).Length;
Assert.True(length > 0);
}
else
{
Assert.True(false, $"File {vidCaptureHandler.GetFilepath()} was not created");
}
}
});
}
private async Task TakeVideoManual(string extension, MMALEncoding encoding, MMALEncoding pixelFormat, int bitrate, int seconds)
{
using (var vidCaptureHandler = new VideoStreamCaptureHandler($"/home/pi/videos/", extension))
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler))
using (var renderer = new MMALVideoRenderer())
{
this.Cam.ConfigureCameraSettings();
vidEncoder.ConfigureOutputPort(0, encoding, pixelFormat, 0, bitrate);
this.Cam.Camera.VideoPort.ConnectTo(vidEncoder);
this.Cam.Camera.PreviewPort.ConnectTo(renderer);
// Camera warm up time
await Task.Delay(2000);
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(seconds));
// Take video for 3 minutes.
await this.Cam.ProcessAsync(this.Cam.Camera.VideoPort, cts.Token);
}
}
public Camera(NetworkStream outputStream, Vector2 resolution, int bitrate = 1300000, int frameRate = 25, int quality = 0, EventHandler <byte[]> frameCaptured = null)
{
OnFrameCaptured = frameCaptured;
MMALCameraConfig.VideoResolution = new Resolution((int)resolution.X, (int)resolution.Y);
MMALCameraConfig.VideoFramerate = new MMAL_RATIONAL_T(frameRate, 1);
OutputHandler = new NetworkStreamCaptureHandler(outputStream);
VideoEncoder = new MMALVideoEncoder();
// Create our component pipeline. Here we are using the H.264 standard with a YUV420 pixel format. The video will be taken at 25Mb/s.
Instance = MMALCamera.Instance;
Instance.ConfigureCameraSettings();
MMALPortConfig portConfig = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, quality, bitrate, null);
VideoEncoder.ConfigureOutputPort(portConfig, OutputHandler);
nullSink = new MMALNullSinkComponent();
Instance.Camera.PreviewPort.ConnectTo(nullSink);
Instance.Camera.VideoPort.ConnectTo(VideoEncoder);
}
public void StartStreaming(string url, string streamName, TimeSpan duration)
{
var camera = MMALCamera.Instance;
var task = Task.Run(async() =>
{
using (var ffCaptureHandler = new FFmpegCaptureHandler($"-i - -vcodec copy -an -f flv {url}{streamName}"))
using (var vidEncoder = new MMALVideoEncoder(ffCaptureHandler, new MMAL_RATIONAL_T(25, 1), DateTime.Now.Add(duration)))
using (var renderer = new MMALVideoRenderer())
{
vidEncoder.ConfigureOutputPort(0, MMALEncoding.H264, MMALEncoding.I420, 0, 25000000);
camera.Camera.VideoPort.ConnectTo(vidEncoder);
camera.Camera.PreviewPort.ConnectTo(renderer);
camera.ConfigureCameraSettings();
await camera.BeginProcessing(camera.Camera.VideoPort);
}
});
//TODO: Improve Woopsa error to display AggregateException
task.Wait();
camera.Cleanup();
}
/// <summary>
/// Wires up the various image processing components.
/// </summary>
protected virtual void ConfigurePipeline()
{
Console.WriteLine("Preparing pipeline.");
VideoCaptureHandler = new CircularBufferCaptureHandler(4000000, AppConfig.Get.LocalPath, "h264");
MotionCaptureHandler = new FrameBufferCaptureHandler();
SnapshotCaptureHandler = new FrameBufferCaptureHandler(directory: AppConfig.Get.LocalPath, extension: "jpg", fileDateTimeFormat: Program.FILENAME_DATE_FORMAT);
Splitter = new MMALSplitterComponent();
Resizer = new MMALIspComponent();
VideoEncoder = new MMALVideoEncoder();
SnapshotEncoder = new MMALImageEncoder(continuousCapture: true);
Resizer.ConfigureOutputPort <VideoPort>(0, new MMALPortConfig(MMALEncoding.RGB24, MMALEncoding.RGB24, width: 640, height: 480), MotionCaptureHandler);
VideoEncoder.ConfigureOutputPort(new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, quality: 10, MMALVideoEncoder.MaxBitrateLevel4), VideoCaptureHandler);
SnapshotEncoder.ConfigureOutputPort(new MMALPortConfig(MMALEncoding.JPEG, MMALEncoding.I420, quality: 90), SnapshotCaptureHandler);
Cam.Camera.VideoPort.ConnectTo(Splitter);
Splitter.Outputs[0].ConnectTo(Resizer);
Splitter.Outputs[1].ConnectTo(VideoEncoder);
Splitter.Outputs[2].ConnectTo(SnapshotEncoder);
}
public async Task TakeVideo(CancellationToken cancellationToken)
{
var cam = MMALCamera.Instance;
Console.WriteLine($"Video path: {_videoSavePath}Millie{DateTime.Now:s}");
try {
using (var ffCaptureHandler = FFmpegCaptureHandler.RawVideoToAvi(_videoSavePath, $"Millie{DateTime.Now:s}"))
using (var vidEncoder = new MMALVideoEncoder(ffCaptureHandler))
using (var renderer = new MMALVideoRenderer())
{
cam.ConfigureCameraSettings();
MMALCameraConfig.Rotation = 270;
var portConfig = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 10, MMALVideoEncoder.MaxBitrateLevel4, null);
// Create our component pipeline. Here we are using the H.264 standard with a YUV420 pixel format. The video will be taken at 25Mb/s.
vidEncoder.ConfigureOutputPort(portConfig);
cam.Camera.VideoPort.ConnectTo(vidEncoder);
cam.Camera.PreviewPort.ConnectTo(renderer);
// Camera warm up time
await Task.Delay(2000, cancellationToken);
await cam.ProcessAsync(cam.Camera.VideoPort, cancellationToken);
}
}
catch (Exception ex) {
Console.WriteLine(ex);
}
finally {
// Only call when you no longer require the camera, i.e. on app shutdown.
cam.Cleanup();
}
}
/// <summary>
/// Self-contained method for recording H.264 video for a specified amount of time. Records at 30fps, 25Mb/s at the highest quality.
/// </summary>
/// <param name="handler">The video capture handler to apply to the encoder.</param>
/// <param name="timeout">A timeout to stop the video capture</param>
/// <param name="split">Used for Segmented video mode</param>
/// <returns>The awaitable Task</returns>
public async Task TakeVideo(VideoStreamCaptureHandler handler, DateTime?timeout = null, Split split = null)
{
if (split != null && !MMALCameraConfig.InlineHeaders)
{
MMALLog.Logger.Warn("Inline headers not enabled. Split mode not supported when this is disabled.");
split = null;
}
using (var vidEncoder = new MMALVideoEncoder(handler, new MMAL_RATIONAL_T(30, 1), timeout, split))
using (var renderer = new MMALVideoRenderer())
{
vidEncoder.ConfigureOutputPort(0, MMALEncoding.H264, MMALEncoding.I420, 10, 25000000);
//Create our component pipeline.
this.Camera.VideoPort.ConnectTo(vidEncoder);
this.Camera.PreviewPort.ConnectTo(renderer);
this.ConfigureCameraSettings();
MMALLog.Logger.Info($"Preparing to take video. Resolution: {vidEncoder.Width} x {vidEncoder.Height}. " +
$"Encoder: {vidEncoder.Outputs[0].EncodingType.EncodingName}. Pixel Format: {vidEncoder.Outputs[0].PixelFormat.EncodingName}.");
await BeginProcessing(this.Camera.VideoPort, vidEncoder);
}
}
public void GrabVideo(TimeSpan duration)
{
var camera = MMALCamera.Instance;
var task = Task.Run(async() =>
{
using (var vidCaptureHandler = new VideoStreamCaptureHandler(Path.Combine(Folder, Video), "avi"))
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler, new MMAL_RATIONAL_T(25, 1), DateTime.Now.Add(duration)))
using (var renderer = new MMALVideoRenderer())
{
vidEncoder.ConfigureOutputPort(0, MMALEncoding.H264, MMALEncoding.I420, 0, 25000000);
camera.Camera.VideoPort.ConnectTo(vidEncoder);
camera.Camera.PreviewPort.ConnectTo(renderer);
camera.ConfigureCameraSettings();
await camera.BeginProcessing(camera.Camera.VideoPort);
}
});
//TODO: Improve Woopsa error to display AggregateException
task.Wait();
camera.Cleanup();
LastVideoFilename = Path.Combine(Image, GetLastFile(Path.Combine(Folder, Video)).Name);
}
public void ChangeEncoderType()
{
TestHelper.SetConfigurationDefaults();
AsyncContext.Run(async() =>
{
var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "avi");
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler, new MMAL_RATIONAL_T(25, 1), DateTime.Now.AddSeconds(20)))
{
vidEncoder.ConfigureOutputPort(0, MMALEncoding.MJPEG, MMALEncoding.I420, 10, 25000000);
//Create our component pipeline.
fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(new MMALVideoRenderer());
fixture.MMALCamera.ConfigureCameraSettings();
//Record video for 20 seconds
await fixture.MMALCamera.BeginProcessing(fixture.MMALCamera.Camera.VideoPort, vidEncoder);
if (System.IO.File.Exists(vidCaptureHandler.GetFilepath()))
{
var length = new System.IO.FileInfo(vidCaptureHandler.GetFilepath()).Length;
Assert.True(length > 0);
}
else
{
Assert.True(false, $"File {vidCaptureHandler.GetFilepath()} was not created");
}
}
vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "mjpeg");
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler, new MMAL_RATIONAL_T(25, 1), DateTime.Now.AddSeconds(20)))
{
vidEncoder.ConfigureOutputPort(0, MMALEncoding.MJPEG, MMALEncoding.I420, 90, 25000000);
//Create our component pipeline.
fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(new MMALVideoRenderer());
fixture.MMALCamera.ConfigureCameraSettings();
//Record video for 20 seconds
await fixture.MMALCamera.BeginProcessing(fixture.MMALCamera.Camera.VideoPort, vidEncoder);
if (System.IO.File.Exists(vidCaptureHandler.GetFilepath()))
{
var length = new System.IO.FileInfo(vidCaptureHandler.GetFilepath()).Length;
Assert.True(length > 0);
}
else
{
Assert.True(false, $"File {vidCaptureHandler.GetFilepath()} was not created");
}
}
});
}
// motion without raw recording, decouple from onDetect event
static async Task motion(int totalSeconds, int recordSeconds, int sensitivity)
{
DeleteFiles(ramdiskPath, "*.h264");
DeleteFiles(ramdiskPath, "*.raw");
var cam = GetConfiguredCamera();
// No longer cut-and-paste from the MMALSharp wiki:
// The built-in MotionConfig "recordingTime" argument only applies to calling StartRecording
// on the motion buffer, which is RAW (and huge). That also means the onStopDetect action
// for cam.WithMotionDetection is not especially useful. So this variation doesn't record the
// RAW stream and instead uses a token timeout to terminate the recording.
// When using H.264 encoding we require key frames to be generated for the Circular buffer capture handler.
MMALCameraConfig.InlineHeaders = true;
Console.WriteLine("Preparing pipeline...");
using (var splitter = new MMALSplitterComponent())
{
// Two capture handlers are being used here, one for motion detection and the other to record a H.264 stream.
using var vidCaptureHandler = new CircularBufferCaptureHandler(4000000, "/media/ramdisk", "h264");
using var motionCircularBufferCaptureHandler = new CircularBufferCaptureHandler(4000000, "/media/ramdisk", "raw");
using var resizer = new MMALIspComponent();
using var vidEncoder = new MMALVideoEncoder();
using var renderer = new MMALVideoRenderer();
cam.ConfigureCameraSettings();
var splitterPortConfig = new MMALPortConfig(MMALEncoding.OPAQUE, MMALEncoding.I420, 0, 0, null);
var vidEncoderPortConfig = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 0, MMALVideoEncoder.MaxBitrateLevel4, null);
// The ISP resizer is being used for better performance. Frame difference motion detection will only work if using raw video data. Do not encode to H.264/MJPEG.
// Resizing to a smaller image may improve performance, but ensure that the width/height are multiples of 32 and 16 respectively to avoid cropping.
var resizerPortConfig = new MMALPortConfig(MMALEncoding.RGB24, MMALEncoding.RGB24, 640, 480, 0, 0, 0, false, null);
splitter.ConfigureInputPort(new MMALPortConfig(MMALEncoding.OPAQUE, MMALEncoding.I420), cam.Camera.VideoPort, null);
splitter.ConfigureOutputPort(0, splitterPortConfig, null);
splitter.ConfigureOutputPort(1, splitterPortConfig, null);
resizer.ConfigureOutputPort <VideoPort>(0, resizerPortConfig, motionCircularBufferCaptureHandler);
vidEncoder.ConfigureInputPort(new MMALPortConfig(MMALEncoding.OPAQUE, MMALEncoding.I420), splitter.Outputs[1], null);
vidEncoder.ConfigureOutputPort(vidEncoderPortConfig, vidCaptureHandler);
cam.Camera.VideoPort.ConnectTo(splitter);
cam.Camera.PreviewPort.ConnectTo(renderer);
splitter.Outputs[0].ConnectTo(resizer);
splitter.Outputs[1].ConnectTo(vidEncoder);
Console.WriteLine("Camera warmup...");
await Task.Delay(2000);
Console.WriteLine($"Detecting motion for {totalSeconds} seconds with sensitivity threshold {sensitivity}...");
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(totalSeconds));
// The recording duration doesn't matter; see notes at top of this method.
var motionConfig = new MotionConfig(TimeSpan.FromSeconds(10), sensitivity);
// Stephen Cleary says CTS disposal is unnecessary as long as you cancel! https://stackoverflow.com/a/19005066/152997
var startRecordingCTS = LocalPrepareToRecord();
await cam.WithMotionDetection(
motionCircularBufferCaptureHandler,
motionConfig,
// This callback will be invoked when motion has been detected.
() => {
// This has no effect if the token is already cancelled.
startRecordingCTS.Cancel();
})
.ProcessAsync(cam.Camera.VideoPort, cts.Token);
CancellationTokenSource LocalPrepareToRecord()
{
var cts = new CancellationTokenSource();
cts.Token.Register(LocalStartRecording);
return(cts);
}
async void LocalStartRecording()
{
Console.WriteLine($"Motion detected, recording {recordSeconds} seconds...");
motionCircularBufferCaptureHandler.DisableMotionDetection();
vidCaptureHandler.StartRecording();
vidEncoder.RequestIFrame();
// Prepare to record
// Stephen Cleary says CTS disposal is unnecessary as long as you cancel! https://stackoverflow.com/a/19005066/152997
var recordingCTS = new CancellationTokenSource();
// When the token expires, stop recording and re-enable capture
recordingCTS.Token.Register(LocalEndRecording);
// Start the clock
recordingCTS.CancelAfter(recordSeconds * 1000);
// Record until the duration passes or the overall motion detection token expires
await Task.WhenAny(new Task[]
{
cts.Token.AsTask(),
recordingCTS.Token.AsTask()
});
if (!recordingCTS.IsCancellationRequested)
{
recordingCTS.Cancel();
}
}
void LocalEndRecording()
{
Console.WriteLine("...recording stopped.");
startRecordingCTS = LocalPrepareToRecord();
motionCircularBufferCaptureHandler.EnableMotionDetection();
vidCaptureHandler.StopRecording();
vidCaptureHandler.Split();
}
}
// can't use the convenient fall-through using or MMALCamera.Cleanup
// throws: Argument is invalid. Unable to destroy component
cam.Cleanup();
Console.WriteLine("Exiting.");
}
public async Task VideoSplitterComponent()
{
TestHelper.BeginTest("VideoSplitterComponent");
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var handler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "h264"))
using (var handler2 = new VideoStreamCaptureHandler("/home/pi/videos/tests", "h264"))
using (var handler3 = new VideoStreamCaptureHandler("/home/pi/videos/tests", "h264"))
using (var handler4 = new VideoStreamCaptureHandler("/home/pi/videos/tests", "h264"))
using (var splitter = new MMALSplitterComponent(null))
using (var vidEncoder = new MMALVideoEncoder(handler))
using (var vidEncoder2 = new MMALVideoEncoder(handler2))
using (var vidEncoder3 = new MMALVideoEncoder(handler3))
using (var vidEncoder4 = new MMALVideoEncoder(handler4))
using (var renderer = new MMALNullSinkComponent())
{
Fixture.MMALCamera.ConfigureCameraSettings();
var splitterPortConfig = new MMALPortConfig(MMALEncoding.OPAQUE, MMALEncoding.I420, 10, 0, 13000000, null);
var portConfig1 = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 10, 10, 13000000, DateTime.Now.AddSeconds(20));
var portConfig2 = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 10, 20, 13000000, DateTime.Now.AddSeconds(15));
var portConfig3 = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 25, 30, 13000000, DateTime.Now.AddSeconds(10));
var portConfig4 = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 25, 40, 13000000, DateTime.Now.AddSeconds(10));
// Create our component pipeline.
splitter.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, Fixture.MMALCamera.Camera.VideoPort);
splitter.ConfigureOutputPort(0, splitterPortConfig);
splitter.ConfigureOutputPort(1, splitterPortConfig);
splitter.ConfigureOutputPort(2, splitterPortConfig);
splitter.ConfigureOutputPort(3, splitterPortConfig);
vidEncoder.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, splitter.Outputs[0]);
vidEncoder.ConfigureOutputPort(0, portConfig1);
vidEncoder2.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, splitter.Outputs[1]);
vidEncoder2.ConfigureOutputPort(0, portConfig2);
vidEncoder3.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, splitter.Outputs[2]);
vidEncoder3.ConfigureOutputPort(0, portConfig3);
vidEncoder4.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, splitter.Outputs[3]);
vidEncoder4.ConfigureOutputPort(0, portConfig4);
Fixture.MMALCamera.Camera.VideoPort.ConnectTo(splitter);
splitter.Outputs[0].ConnectTo(vidEncoder);
splitter.Outputs[1].ConnectTo(vidEncoder2);
splitter.Outputs[2].ConnectTo(vidEncoder3);
splitter.Outputs[3].ConnectTo(vidEncoder4);
Fixture.MMALCamera.Camera.PreviewPort.ConnectTo(renderer);
// Camera warm up time
await Task.Delay(2000);
await Fixture.MMALCamera.ProcessAsync(Fixture.MMALCamera.Camera.VideoPort);
Fixture.CheckAndAssertFilepath(handler.GetFilepath());
Fixture.CheckAndAssertFilepath(handler2.GetFilepath());
Fixture.CheckAndAssertFilepath(handler3.GetFilepath());
Fixture.CheckAndAssertFilepath(handler4.GetFilepath());
}
}
// motion as in the wiki (records raw file)
static async Task motion_record_raw(int totalSeconds, int recordSeconds, int sensitivity)
{
DeleteFiles(ramdiskPath, "*.h264");
DeleteFiles(ramdiskPath, "*.raw");
var cam = GetConfiguredCamera();
// When using H.264 encoding we require key frames to be generated for the Circular buffer capture handler.
MMALCameraConfig.InlineHeaders = true;
Console.WriteLine("Preparing pipeline...");
using (var splitter = new MMALSplitterComponent())
{
// Two capture handlers are being used here, one for motion detection and the other to record a H.264 stream.
using var vidCaptureHandler = new CircularBufferCaptureHandler(4000000, "/media/ramdisk", "h264");
using var motionCircularBufferCaptureHandler = new CircularBufferCaptureHandler(4000000, "/media/ramdisk", "raw");
using var resizer = new MMALIspComponent();
using var vidEncoder = new MMALVideoEncoder();
using var renderer = new MMALVideoRenderer();
cam.ConfigureCameraSettings();
// The ISP resizer is being used for better performance. Frame difference motion detection will only work if using raw video data. Do not encode to H.264/MJPEG.
// Resizing to a smaller image may improve performance, but ensure that the width/height are multiples of 32 and 16 respectively to avoid cropping.
var resizerPortConfig = new MMALPortConfig(MMALEncoding.RGB24, MMALEncoding.RGB24, 640, 480, 0, 0, 0, false, null);
var vidEncoderPortConfig = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 0, MMALVideoEncoder.MaxBitrateLevel4, null);
var splitterPortConfig = new MMALPortConfig(MMALEncoding.OPAQUE, MMALEncoding.I420, 0, 0, null);
splitter.ConfigureInputPort(new MMALPortConfig(MMALEncoding.OPAQUE, MMALEncoding.I420), cam.Camera.VideoPort, null);
splitter.ConfigureOutputPort(0, splitterPortConfig, null);
splitter.ConfigureOutputPort(1, splitterPortConfig, null);
resizer.ConfigureOutputPort <VideoPort>(0, resizerPortConfig, motionCircularBufferCaptureHandler);
vidEncoder.ConfigureInputPort(new MMALPortConfig(MMALEncoding.OPAQUE, MMALEncoding.I420), splitter.Outputs[1], null);
vidEncoder.ConfigureOutputPort(vidEncoderPortConfig, vidCaptureHandler);
cam.Camera.VideoPort.ConnectTo(splitter);
cam.Camera.PreviewPort.ConnectTo(renderer);
splitter.Outputs[0].ConnectTo(resizer);
splitter.Outputs[1].ConnectTo(vidEncoder);
Console.WriteLine("Camera warmup...");
await Task.Delay(2000);
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(totalSeconds));
var motionConfig = new MotionConfig(TimeSpan.FromSeconds(recordSeconds), sensitivity);
Console.WriteLine($"Detecting motion for {totalSeconds} seconds with sensitivity threshold {sensitivity}...");
await cam.WithMotionDetection(
motionCircularBufferCaptureHandler,
motionConfig,
// This callback will be invoked when motion has been detected.
() =>
{
Console.WriteLine($"Motion detected, recording {recordSeconds} seconds...");
// Stop motion detection while we are recording.
motionCircularBufferCaptureHandler.DisableMotionDetection();
// Start recording our H.264 video.
vidCaptureHandler.StartRecording();
motionCircularBufferCaptureHandler.StartRecording();
// Request a key frame to be immediately generated by the h.264 encoder.
vidEncoder.RequestIFrame();
},
// Invoked when motion handler recording-time expires
() =>
{
// We want to re-enable the motion detection.
motionCircularBufferCaptureHandler.EnableMotionDetection();
// Stop recording on our capture handlers.
motionCircularBufferCaptureHandler.StopRecording();
vidCaptureHandler.StopRecording();
// Optionally create new file for our next recording run (don't do the RAW file, we don't want it).
vidCaptureHandler.Split();
Console.WriteLine("...recording stopped.");
})
.ProcessAsync(cam.Camera.VideoPort, cts.Token);
}
// can't use the convenient fall-through using or MMALCamera.Cleanup
// throws: Argument is invalid. Unable to destroy component
cam.Cleanup();
Console.WriteLine("Exiting.");
}
public void ChangeColorSpace()
{
TestHelper.BeginTest("ChangeColorSpace");
TestHelper.SetConfigurationDefaults();
TestHelper.CleanDirectory("/home/pi/videos/tests");
MMALCameraConfig.VideoColorSpace = MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601;
using (var handler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "h264"))
using (var handler2 = new VideoStreamCaptureHandler("/home/pi/video/tests", "h264"))
using (var handler3 = new VideoStreamCaptureHandler("/home/pi/video/tests", "h264"))
using (var handler4 = new VideoStreamCaptureHandler("/home/pi/video/tests", "h264"))
using (var splitter = new MMALSplitterComponent(null))
using (var vidEncoder = new MMALVideoEncoder(handler))
using (var vidEncoder2 = new MMALVideoEncoder(handler2))
using (var vidEncoder3 = new MMALVideoEncoder(handler3))
using (var vidEncoder4 = new MMALVideoEncoder(handler4))
using (var renderer = new MMALVideoRenderer())
{
Fixture.MMALCamera.ConfigureCameraSettings();
var splitterPortConfig = new MMALPortConfig(MMALEncoding.OPAQUE, MMALEncoding.I420, 10, 0, 13000000, null);
var portConfig1 = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 10, 10, 13000000, DateTime.Now.AddSeconds(20));
var portConfig2 = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 10, 20, 13000000, DateTime.Now.AddSeconds(15));
var portConfig3 = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 25, 30, 13000000, DateTime.Now.AddSeconds(10));
var portConfig4 = new MMALPortConfig(MMALEncoding.H264, MMALEncoding.I420, 25, 40, 13000000, DateTime.Now.AddSeconds(10));
// Create our component pipeline.
splitter.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, Fixture.MMALCamera.Camera.VideoPort);
splitter.ConfigureOutputPort(0, splitterPortConfig);
splitter.ConfigureOutputPort(1, splitterPortConfig);
splitter.ConfigureOutputPort(2, splitterPortConfig);
splitter.ConfigureOutputPort(3, splitterPortConfig);
vidEncoder.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, splitter.Outputs[0]);
vidEncoder.ConfigureOutputPort(0, portConfig1);
vidEncoder2.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, splitter.Outputs[1]);
vidEncoder2.ConfigureOutputPort(0, portConfig2);
vidEncoder3.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, splitter.Outputs[2]);
vidEncoder3.ConfigureOutputPort(0, portConfig3);
vidEncoder4.ConfigureInputPort(MMALEncoding.OPAQUE, MMALEncoding.I420, splitter.Outputs[3]);
vidEncoder4.ConfigureOutputPort(0, portConfig4);
Fixture.MMALCamera.Camera.VideoPort.ConnectTo(splitter);
splitter.Outputs[0].ConnectTo(vidEncoder);
splitter.Outputs[1].ConnectTo(vidEncoder2);
splitter.Outputs[2].ConnectTo(vidEncoder3);
splitter.Outputs[3].ConnectTo(vidEncoder4);
Fixture.MMALCamera.Camera.PreviewPort.ConnectTo(renderer);
// Assert that all output ports have the same video color space.
Assert.True(Fixture.MMALCamera.Camera.VideoPort.VideoColorSpace.EncodingVal == MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601.EncodingVal);
Assert.True(splitter.Outputs[0].VideoColorSpace.EncodingVal == MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601.EncodingVal);
Assert.True(splitter.Outputs[1].VideoColorSpace.EncodingVal == MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601.EncodingVal);
Assert.True(splitter.Outputs[2].VideoColorSpace.EncodingVal == MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601.EncodingVal);
Assert.True(splitter.Outputs[3].VideoColorSpace.EncodingVal == MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601.EncodingVal);
Assert.True(vidEncoder.Outputs[0].VideoColorSpace.EncodingVal == MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601.EncodingVal);
Assert.True(vidEncoder2.Outputs[0].VideoColorSpace.EncodingVal == MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601.EncodingVal);
Assert.True(vidEncoder3.Outputs[0].VideoColorSpace.EncodingVal == MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601.EncodingVal);
Assert.True(vidEncoder4.Outputs[0].VideoColorSpace.EncodingVal == MMALEncoding.MMAL_COLOR_SPACE_ITUR_BT601.EncodingVal);
}
}
