New Video Format - Squashed & memory management

FlashCap.Core/CaptureDevice.cs

@@ -33,7 +33,7 @@ protected CaptureDevice(object identity, string name)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
     public void Dispose() =>
-        _ = this.DisposeAsync().ConfigureAwait(false);
+        _ = this.DisposeAsync().ConfigureAwait(true);
 
 #if NETCOREAPP3_0_OR_GREATER || NETSTANDARD2_1
     ValueTask IAsyncDisposable.DisposeAsync() =>
@@ -43,10 +43,10 @@ ValueTask IAsyncDisposable.DisposeAsync() =>
     public async Task DisposeAsync()
     {
         using var _ = await locker.LockAsync(default).
-            ConfigureAwait(false);
+            ConfigureAwait(true);
 
         await this.OnDisposeAsync().
-            ConfigureAwait(false);
+            ConfigureAwait(true);
     }
 
     protected virtual Task OnDisposeAsync() =>
@@ -87,18 +87,22 @@ internal Task InternalInitializeAsync(
 
     internal async Task InternalStartAsync(CancellationToken ct)
     {
+
         using var _ = await locker.LockAsync(ct).
             ConfigureAwait(false);
 
         await this.OnStartAsync(ct);
+
     }
 
     internal async Task InternalStopAsync(CancellationToken ct)
     {
+
         using var _ = await locker.LockAsync(ct).
             ConfigureAwait(false);
 
         await this.OnStopAsync(ct);
+
     }
 
 #if NET45_OR_GREATER || NETSTANDARD || NETCOREAPP

FlashCap.Core/Devices/AVFoundationDevice.cs

@@ -34,6 +34,9 @@ public sealed class AVFoundationDevice : CaptureDevice
     private AVCaptureSession? session;
     private FrameProcessor? frameProcessor;
     private IntPtr bitmapHeader;
+    private VideoBufferHandler? videoBufferHandler;
+
+    private GCHandle? videoBufferHandlerHandle;
 
     public AVFoundationDevice(string uniqueID, string modelID) :
         base(uniqueID, modelID)
@@ -43,25 +46,49 @@ public AVFoundationDevice(string uniqueID, string modelID) :
 
     protected override async Task OnDisposeAsync()
     {
-        if (this.session != null)
+        try
         {
-            this.session.StopRunning();
-            this.session.Dispose();
-        }
-
-        this.device?.Dispose();
-        this.deviceInput?.Dispose();
-        this.deviceOutput?.Dispose();
-        this.queue?.Dispose();
+            // Ensure that we stop the session if it's running
+            if (session != null && IsRunning)
+            {
+                session.StopRunning();
+                IsRunning = false;
+            }
+
+            // Clean up the video buffer handler if it exists
+            if (videoBufferHandlerHandle.HasValue)
+            {
+                videoBufferHandlerHandle.Value.Free();
+                videoBufferHandlerHandle = null;
+            }
+
+            // Now dispose of the session and other resources
+            if (session != null)
+            {
+                session.Dispose();
+                session = null;
+            }
+            device?.Dispose(); device = null;
+            deviceInput?.Dispose(); deviceInput = null;
+            deviceOutput?.Dispose(); deviceOutput = null;
+            queue?.Dispose(); queue = null;
 
-        Marshal.FreeHGlobal(this.bitmapHeader);
+            if (bitmapHeader != IntPtr.Zero)
+            {
+                NativeMethods.FreeMemory(bitmapHeader);
+                bitmapHeader = IntPtr.Zero;
+            }
 
-        if (frameProcessor is not null)
+            if (frameProcessor != null)
+            {
+                await frameProcessor.DisposeAsync().ConfigureAwait(false);
+                frameProcessor = null;
+            }
+        }
+        finally
         {
-            await frameProcessor.DisposeAsync().ConfigureAwait(false);
+            await base.OnDisposeAsync().ConfigureAwait(false);
         }
-
-        await base.OnDisposeAsync().ConfigureAwait(false);
     }
 
     protected override Task OnInitializeAsync(VideoCharacteristics characteristics, TranscodeFormats transcodeFormat,
@@ -124,19 +151,27 @@ format.FormatDescription.Dimensions is var dimensions &&
                 this.deviceInput = new AVCaptureDeviceInput(device);
 
                 this.deviceOutput = new AVCaptureVideoDataOutput();
+
 
                 if (this.deviceOutput.AvailableVideoCVPixelFormatTypes?.Any() == true)
                 {
                     var validPixelFormat = this.deviceOutput.AvailableVideoCVPixelFormatTypes.FirstOrDefault(p => p == pixelFormatType);
                     this.deviceOutput.SetPixelFormatType(validPixelFormat);
+                    this.deviceOutput.SetVideoOutputSize(characteristics.Width, characteristics.Height, validPixelFormat);
                 }
                 else
                 {
                     // Fallback to the mapped pixel format if no available list is provided
                     this.deviceOutput.SetPixelFormatType(pixelFormatType);
                 }
-
-                this.deviceOutput.SetSampleBufferDelegate(new VideoBufferHandler(this), this.queue);
+
+                videoBufferHandler = new VideoBufferHandler(this);
+
+                this.deviceOutput.SetSampleBufferDelegate(videoBufferHandler, this.queue);
+
+                // Protect against GC moving the delegate
+                videoBufferHandlerHandle = GCHandle.Alloc(videoBufferHandler);
+
                 this.deviceOutput.AlwaysDiscardsLateVideoFrames = true;
             }
             finally
@@ -161,31 +196,80 @@ format.FormatDescription.Dimensions is var dimensions &&
         catch
         {
             NativeMethods.FreeMemory(this.bitmapHeader);
+            this.bitmapHeader = IntPtr.Zero;
+
+            this.queue?.Dispose();
+            this.queue = null;
+            this.device?.Dispose();
+            this.device = null;
+            this.deviceInput?.Dispose();
+            this.deviceInput = null;
+            this.deviceOutput?.Dispose();
+            this.deviceOutput = null;
+
             throw;
         }
     }
 
     protected override Task OnStartAsync(CancellationToken ct)
     {
-        this.session?.StartRunning();
-        return TaskCompat.CompletedTask;
+        try
+        {
+            if(session== null) 
+                throw new InvalidOperationException("Session is null");
+            this.session?.StartRunning();
+            this.IsRunning = true;
+            return TaskCompat.CompletedTask;
+        }catch (Exception ex)
+        {
+            Debug.WriteLine($"Error starting session: {ex.Message}");
+            throw new InvalidOperationException("Failed to start the capture session.", ex);
+        }
+
     }
 
     protected override Task OnStopAsync(CancellationToken ct)
     {
-        this.session?.StopRunning();
+        try
+        {
+            if(session== null) 
+                throw new InvalidOperationException("Session is null");
+            if (this.IsRunning)
+            {
+                this.session?.StopRunning();
+                this.IsRunning = false;
+
+            }
+
+        }catch (Exception ex)
+        {
+            Debug.WriteLine($"Error stopping session: {ex.Message}");
+            throw new InvalidOperationException("Failed to stop the capture session.", ex);
+        }
         return TaskCompat.CompletedTask;
     }
 
     protected override void OnCapture(IntPtr pData, int size, long timestampMicroseconds, long frameIndex, PixelBuffer buffer)
     {
-        buffer.CopyIn(this.bitmapHeader, pData, size, timestampMicroseconds, frameIndex, TranscodeFormats.Auto);
+        try
+        {
+            if (this.bitmapHeader == IntPtr.Zero) return;
+            if (pData == IntPtr.Zero || size <= 0)
+            {
+                throw new ArgumentException("Invalid pixel data or size.");
+            }
+            buffer.CopyIn(this.bitmapHeader, pData, size, timestampMicroseconds, frameIndex, TranscodeFormats.Auto);
+        }catch (Exception ex)
+        {
+            Debug.WriteLine($"Error capturing frame: {ex.Message}");
+            throw new InvalidOperationException("Failed to capture frame.", ex);
+        }
     }
 
     internal sealed class VideoBufferHandler : AVCaptureVideoDataOutputSampleBuffer
     {
         private readonly AVFoundationDevice device;
-        private int frameIndex;
+        private int frameIndex = 0;
 
         public VideoBufferHandler(AVFoundationDevice device)
         {
@@ -194,7 +278,7 @@ public VideoBufferHandler(AVFoundationDevice device)
 
         public override void DidDropSampleBuffer(IntPtr captureOutput, IntPtr sampleBuffer, IntPtr connection)
         {
-            Debug.WriteLine("Dropped");
+            //Debug.WriteLine("Dropped");
             var valid = CMSampleBufferIsValid(sampleBuffer);
         }
 

FlashCap.Core/FlashCap.Core.csproj

@@ -5,6 +5,7 @@
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
     <NoWarn>$(NoWarn);CS0649</NoWarn>
     <IsPackable>true</IsPackable>
+    <Version>1.0.0</Version>
   </PropertyGroup>
 
   <ItemGroup>