Stability improved.

Andrey Kalugin · Andrey Kalugin · commit ce639ea5405e · 2024-12-30T21:04:03.000+02:00
diff --git a/CameraLib/FlashCap/UsbCameraFc.cs b/CameraLib/FlashCap/UsbCameraFc.cs
@@ -28,7 +28,7 @@ public class UsbCameraFc : ICamera
         private readonly object _getPictureThreadLock = new();
         private readonly Stopwatch _fpsTimer = new();
         private byte _frameCount;
-        private readonly System.Timers.Timer _keepAliveTimer = new System.Timers.Timer();
+        private readonly System.Timers.Timer _keepAliveTimer = new();
         private int _width = 0;
         private int _height = 0;
         private string _format = string.Empty;
@@ -53,10 +53,10 @@ public UsbCameraFc(string path, string name = "")
             Description = new CameraDescription(CameraType.USB_FC, path, name, GetAllAvailableResolution(_usbCamera));
             CurrentFps = Description.FrameFormats.FirstOrDefault()?.Fps ?? 10;
 
-            _keepAliveTimer.Elapsed += CameraDisconnected;
+            _keepAliveTimer.Elapsed += CheckCameraDisconnected;
         }
 
-        private async void CameraDisconnected(object? sender, ElapsedEventArgs e)
+        private async void CheckCameraDisconnected(object? sender, ElapsedEventArgs e)
         {
             if (_fpsTimer.ElapsedMilliseconds > FrameTimeout)
             {
@@ -88,7 +88,7 @@ public static List<CameraDescription> DiscoverUsbCameras()
             return result;
         }
 
-        private static IEnumerable<FrameFormat> GetAllAvailableResolution(CaptureDeviceDescriptor usbCamera)
+        private static List<FrameFormat> GetAllAvailableResolution(CaptureDeviceDescriptor usbCamera)
         {
             var formats = new List<FrameFormat>();
             foreach (var cameraCharacteristic in usbCamera.Characteristics)
@@ -167,14 +167,14 @@ public async Task<bool> Start(int width, int height, string format, Cancellation
             }
             else
             {
-                characteristics = new List<VideoCharacteristics>(){
+                characteristics = [
                     characteristics.Aggregate((n, m) =>
                     {
                         if (n.Width * n.Height > m.Width * m.Height)
                             return n;
                         else
                             return m;
-                    })};
+                    })];
             }
 
             return characteristics.FirstOrDefault();
@@ -244,6 +244,7 @@ private void Stop(bool cancellation)
 
             lock (_getPictureThreadLock)
             {
+                IsRunning = false;
                 _keepAliveTimer.Stop();
 
                 if (cancellation)
diff --git a/CameraLib/IP/IpCamera.cs b/CameraLib/IP/IpCamera.cs
@@ -161,10 +161,10 @@ public IpCamera(string path,
             Description = new CameraDescription(CameraType.IP, path, name, frameFormats);
             CurrentFps = Description.FrameFormats.FirstOrDefault()?.Fps ?? 10;
 
-            _keepAliveTimer.Elapsed += CameraDisconnected;
+            _keepAliveTimer.Elapsed += CheckCameraDisconnected;
         }
 
-        private async void CameraDisconnected(object? sender, ElapsedEventArgs e)
+        private async void CheckCameraDisconnected(object? sender, ElapsedEventArgs e)
         {
             if (_fpsTimer.ElapsedMilliseconds > FrameTimeout)
             {
@@ -229,7 +229,8 @@ public async Task<bool> Start(int width, int height, string format, Cancellation
                 catch (Exception ex)
                 {
                     Console.WriteLine($"Error getting image from camera: {ex}");
-                    await Task.Delay(1000);
+                    Stop();
+                    //await Task.Delay(1000);
                 }
 
                 IsRunning = false;
@@ -309,14 +310,15 @@ private void Stop(bool cancellation)
 
             lock (_getPictureThreadLock)
             {
+                IsRunning = false;
                 _keepAliveTimer.Stop();
 
                 if (_captureDevice != null)
                 {
                     _cancellationTokenSourceCameraGrabber?.Cancel();
-                    _captureTask?.Wait(5000);
                     try
                     {
+                        _captureTask?.Wait(5000);
                         _captureDevice?.Release();
                     }
                     catch (Exception ex)
@@ -449,6 +451,7 @@ protected virtual void Dispose(bool disposing)
                     _keepAliveTimer.Dispose();
                     _captureDevice?.Dispose();
                     _cancellationTokenSource?.Dispose();
+                    _cancellationTokenSourceCameraGrabber?.Dispose();
                 }
 
                 _disposedValue = true;
diff --git a/CameraLib/MJPEG/MjpegCamera.cs b/CameraLib/MJPEG/MjpegCamera.cs
@@ -36,9 +36,9 @@ public class MjpegCamera : ICamera
         public CancellationToken CancellationToken => _cancellationTokenSource?.Token ?? CancellationToken.None;
 
         private CancellationTokenSource? _cancellationTokenSource;
-        private readonly object _getPictureThreadLock = new();
+        private CancellationTokenSource? _cancellationTokenSourceCameraGrabber;
+        private readonly object _getPictureThreadLock = new object();
         private Task? _imageGrabber;
-        private volatile bool _stopCapture = false;
         private readonly Stopwatch _fpsTimer = new();
         private volatile byte _frameCount;
         private readonly System.Timers.Timer _keepAliveTimer = new();
@@ -93,10 +93,10 @@ public MjpegCamera(string path,
             Description = new CameraDescription(CameraType.IP, path, name, frameFormats);
             CurrentFps = Description.FrameFormats.FirstOrDefault()?.Fps ?? 10;
 
-            _keepAliveTimer.Elapsed += CameraDisconnected;
+            _keepAliveTimer.Elapsed += CheckCameraDisconnected;
         }
 
-        private async void CameraDisconnected(object? sender, ElapsedEventArgs e)
+        private async void CheckCameraDisconnected(object? sender, ElapsedEventArgs e)
         {
             if (_fpsTimer.ElapsedMilliseconds > FrameTimeout)
             {
@@ -135,17 +135,20 @@ public async Task<bool> Start(int width, int height, string format, Cancellation
             _height = height;
             _format = format;
 
+            _cancellationTokenSource?.Dispose();
             _cancellationTokenSource = new CancellationTokenSource();
+            _cancellationTokenSourceCameraGrabber?.Dispose();
+            _cancellationTokenSourceCameraGrabber = new CancellationTokenSource();
+
             _frameCount = 0;
             _fpsTimer.Reset();
             _keepAliveTimer.Interval = FrameTimeout;
             _keepAliveTimer.Start();
 
-            _stopCapture = false;
             try
             {
                 _imageGrabber?.Dispose();
-                _imageGrabber = StartAsync(Description.Path, AuthenicationType, Login, Password, token).WaitAsync(TimeSpan.FromMilliseconds(FrameTimeout), token);
+                _imageGrabber = StartAsync(Description.Path, AuthenicationType, _cancellationTokenSourceCameraGrabber.Token, Login, Password).WaitAsync(TimeSpan.FromMilliseconds(FrameTimeout), token);
             }
             catch (Exception ex)
             {
@@ -172,11 +175,18 @@ private void Stop(bool cancellation)
 
             lock (_getPictureThreadLock)
             {
+                IsRunning = false;
                 _keepAliveTimer.Stop();
 
-                _stopCapture = true;
-                var timeOut = DateTime.Now.AddSeconds(100);
-                _imageGrabber?.Wait(5000);
+                _cancellationTokenSourceCameraGrabber?.Cancel();
+                try
+                {
+                    _imageGrabber?.Wait(5000);
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Camera Stop() failed: {ex}");
+                }
 
                 if (cancellation)
                     _cancellationTokenSource?.Cancel();
@@ -247,18 +257,16 @@ public async IAsyncEnumerable<Mat> GrabFrames([EnumeratorCancellation] Cancellat
         /// <param name="chunkMaxSize">Max chunk byte size when reading stream</param>
         /// <param name="frameBufferSize">Maximum frame byte size</param>
         /// <returns></returns>
-        private async Task StartAsync(string url, AuthType authenicationType, string login = "", string password = "", CancellationToken? token = null, int chunkMaxSize = 1024, int frameBufferSize = 1024 * 1024)
+        private async Task StartAsync(string url, AuthType authenicationType, CancellationToken token, string login = "", string password = "", int chunkMaxSize = 1024, int frameBufferSize = 1024 * 1024)
         {
-            var tokenLocal = token ?? CancellationToken.None;
-
             using (var httpClient = new HttpClient())
             {
                 if (authenicationType == AuthType.Basic)
                     httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
                         "Basic",
                         Convert.ToBase64String(Encoding.ASCII.GetBytes($"{login}:{password}")));
 
-                await using (var stream = await httpClient.GetStreamAsync(url, tokenLocal).ConfigureAwait(false))
+                await using (var stream = await httpClient.GetStreamAsync(url, token).ConfigureAwait(false))
                 {
                     var streamBuffer = new byte[chunkMaxSize];      // Stream chunk read
                     var frameBuffer = new byte[frameBufferSize];    // Frame buffer
@@ -272,17 +280,18 @@ private async Task StartAsync(string url, AuthType authenicationType, string log
                     IsRunning = true;
                     try
                     {
-                        while (!_stopCapture && !tokenLocal.IsCancellationRequested)
+                        while (!token.IsCancellationRequested)
                         {
-                            var streamLength = await stream.ReadAsync(streamBuffer.AsMemory(0, chunkMaxSize), tokenLocal)
+                            var streamLength = await stream.ReadAsync(streamBuffer.AsMemory(0, chunkMaxSize), token)
                                 .ConfigureAwait(false);
 
                             ParseStreamBuffer(frameBuffer, ref frameIdx, streamLength, streamBuffer, ref inPicture,
-                                ref previous, ref current, tokenLocal);
+                                ref previous, ref current, token);
                         }
                     }
                     catch (Exception ex)
                     {
+                        Stop();
                         Console.WriteLine(ex);
                     }
 
@@ -295,7 +304,7 @@ private async Task StartAsync(string url, AuthType authenicationType, string log
         private void ParseStreamBuffer(byte[] frameBuffer, ref int frameIdx, int streamLength, byte[] streamBuffer, ref bool inPicture, ref byte previous, ref byte current, CancellationToken token)
         {
             var idx = 0;
-            while (idx < streamLength && !_stopCapture && !token.IsCancellationRequested)
+            while (idx < streamLength && !token.IsCancellationRequested)
             {
                 if (inPicture)
                 {
@@ -325,7 +334,7 @@ private void SearchPicture(byte[] frameBuffer, ref int frameIdx, ref int streamL
                     inPicture = true;
                     return;
                 }
-            } while (idx < streamLength && !_stopCapture && !token.IsCancellationRequested);
+            } while (idx < streamLength && !token.IsCancellationRequested);
         }
 
         // While we are parsing a picture, fill the frame buffer until a FFD9 is reach.
@@ -384,7 +393,7 @@ private void ParsePicture(byte[] frameBuffer, ref int frameIdx, ref int streamLe
 
                     return;
                 }
-            } while (idx < streamLength && !_stopCapture && !token.IsCancellationRequested);
+            } while (idx < streamLength && !token.IsCancellationRequested);
         }
 
         #endregion
@@ -437,11 +446,11 @@ protected virtual void Dispose(bool disposing)
                 if (disposing)
                 {
                     Stop();
-                    _imageGrabber?.Wait(5000);
                     _imageGrabber?.Dispose();
                     _keepAliveTimer.Close();
                     _keepAliveTimer.Dispose();
                     _cancellationTokenSource?.Dispose();
+                    _cancellationTokenSourceCameraGrabber?.Dispose();
                 }
 
                 _disposedValue = true;
diff --git a/CameraLib/USB/UsbCamera.cs b/CameraLib/USB/UsbCamera.cs
@@ -53,10 +53,10 @@ public UsbCamera(string path, string name = "")
             Description = new CameraDescription(CameraType.USB, path, name, GetAllAvailableResolution(_usbCamera));
             CurrentFps = Description.FrameFormats.FirstOrDefault()?.Fps ?? 10;
 
-            _keepAliveTimer.Elapsed += CameraDisconnected;
+            _keepAliveTimer.Elapsed += CheckCameraDisconnected;
         }
 
-        private async void CameraDisconnected(object? sender, ElapsedEventArgs e)
+        private async void CheckCameraDisconnected(object? sender, ElapsedEventArgs e)
         {
             if (_fpsTimer.ElapsedMilliseconds > FrameTimeout)
             {
@@ -282,6 +282,7 @@ private void Stop(bool cancellation)
 
             lock (_getPictureThreadLock)
             {
+                IsRunning = false;
                 _keepAliveTimer.Stop();
 
                 if (cancellation)

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public class UsbCameraFc : ICamera`
`28`	`28`	`private readonly object _getPictureThreadLock = new();`
`29`	`29`	`private readonly Stopwatch _fpsTimer = new();`
`30`	`30`	`private byte _frameCount;`
`31`		`- private readonly System.Timers.Timer _keepAliveTimer = new System.Timers.Timer();`
	`31`	`+ private readonly System.Timers.Timer _keepAliveTimer = new();`
`32`	`32`	`private int _width = 0;`
`33`	`33`	`private int _height = 0;`
`34`	`34`	`private string _format = string.Empty;`
`@@ -53,10 +53,10 @@ public UsbCameraFc(string path, string name = "")`
`53`	`53`	`Description = new CameraDescription(CameraType.USB_FC, path, name, GetAllAvailableResolution(_usbCamera));`
`54`	`54`	`CurrentFps = Description.FrameFormats.FirstOrDefault()?.Fps ?? 10;`
`55`	`55`
`56`		`- _keepAliveTimer.Elapsed += CameraDisconnected;`
	`56`	`+ _keepAliveTimer.Elapsed += CheckCameraDisconnected;`
`57`	`57`	`}`
`58`	`58`
`59`		`- private async void CameraDisconnected(object? sender, ElapsedEventArgs e)`
	`59`	`+ private async void CheckCameraDisconnected(object? sender, ElapsedEventArgs e)`
`60`	`60`	`{`
`61`	`61`	`if (_fpsTimer.ElapsedMilliseconds > FrameTimeout)`
`62`	`62`	`{`
`@@ -88,7 +88,7 @@ public static List<CameraDescription> DiscoverUsbCameras()`
`88`	`88`	`return result;`
`89`	`89`	`}`
`90`	`90`
`91`		`- private static IEnumerable<FrameFormat> GetAllAvailableResolution(CaptureDeviceDescriptor usbCamera)`
	`91`	`+ private static List<FrameFormat> GetAllAvailableResolution(CaptureDeviceDescriptor usbCamera)`
`92`	`92`	`{`
`93`	`93`	`var formats = new List<FrameFormat>();`
`94`	`94`	`foreach (var cameraCharacteristic in usbCamera.Characteristics)`
`@@ -167,14 +167,14 @@ public async Task<bool> Start(int width, int height, string format, Cancellation`
`167`	`167`	`}`
`168`	`168`	`else`
`169`	`169`	`{`
`170`		`- characteristics = new List<VideoCharacteristics>(){`
	`170`	`+ characteristics = [`
`171`	`171`	`characteristics.Aggregate((n, m) =>`
`172`	`172`	`{`
`173`	`173`	`if (n.Width * n.Height > m.Width * m.Height)`
`174`	`174`	`return n;`
`175`	`175`	`else`
`176`	`176`	`return m;`
`177`		`- })};`
	`177`	`+ })];`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`return characteristics.FirstOrDefault();`
`@@ -244,6 +244,7 @@ private void Stop(bool cancellation)`
`244`	`244`
`245`	`245`	`lock (_getPictureThreadLock)`
`246`	`246`	`{`
	`247`	`+ IsRunning = false;`
`247`	`248`	`_keepAliveTimer.Stop();`
`248`	`249`
`249`	`250`	`if (cancellation)`
Original file line number	Diff line number	Diff line change
`@@ -161,10 +161,10 @@ public IpCamera(string path,`
`161`	`161`	`Description = new CameraDescription(CameraType.IP, path, name, frameFormats);`
`162`	`162`	`CurrentFps = Description.FrameFormats.FirstOrDefault()?.Fps ?? 10;`
`163`	`163`
`164`		`- _keepAliveTimer.Elapsed += CameraDisconnected;`
	`164`	`+ _keepAliveTimer.Elapsed += CheckCameraDisconnected;`
`165`	`165`	`}`
`166`	`166`
`167`		`- private async void CameraDisconnected(object? sender, ElapsedEventArgs e)`
	`167`	`+ private async void CheckCameraDisconnected(object? sender, ElapsedEventArgs e)`
`168`	`168`	`{`
`169`	`169`	`if (_fpsTimer.ElapsedMilliseconds > FrameTimeout)`
`170`	`170`	`{`
`@@ -229,7 +229,8 @@ public async Task<bool> Start(int width, int height, string format, Cancellation`
`229`	`229`	`catch (Exception ex)`
`230`	`230`	`{`
`231`	`231`	`Console.WriteLine($"Error getting image from camera: {ex}");`
`232`		`- await Task.Delay(1000);`
	`232`	`+ Stop();`
	`233`	`+ //await Task.Delay(1000);`
`233`	`234`	`}`
`234`	`235`
`235`	`236`	`IsRunning = false;`
`@@ -309,14 +310,15 @@ private void Stop(bool cancellation)`
`309`	`310`
`310`	`311`	`lock (_getPictureThreadLock)`
`311`	`312`	`{`
	`313`	`+ IsRunning = false;`
`312`	`314`	`_keepAliveTimer.Stop();`
`313`	`315`
`314`	`316`	`if (_captureDevice != null)`
`315`	`317`	`{`
`316`	`318`	`_cancellationTokenSourceCameraGrabber?.Cancel();`
`317`		`- _captureTask?.Wait(5000);`
`318`	`319`	`try`
`319`	`320`	`{`
	`321`	`+ _captureTask?.Wait(5000);`
`320`	`322`	`_captureDevice?.Release();`
`321`	`323`	`}`
`322`	`324`	`catch (Exception ex)`
`@@ -449,6 +451,7 @@ protected virtual void Dispose(bool disposing)`
`449`	`451`	`_keepAliveTimer.Dispose();`
`450`	`452`	`_captureDevice?.Dispose();`
`451`	`453`	`_cancellationTokenSource?.Dispose();`
	`454`	`+ _cancellationTokenSourceCameraGrabber?.Dispose();`
`452`	`455`	`}`
`453`	`456`
`454`	`457`	`_disposedValue = true;`
Original file line number	Diff line number	Diff line change
`@@ -36,9 +36,9 @@ public class MjpegCamera : ICamera`
`36`	`36`	`public CancellationToken CancellationToken => _cancellationTokenSource?.Token ?? CancellationToken.None;`
`37`	`37`
`38`	`38`	`private CancellationTokenSource? _cancellationTokenSource;`
`39`		`- private readonly object _getPictureThreadLock = new();`
	`39`	`+ private CancellationTokenSource? _cancellationTokenSourceCameraGrabber;`
	`40`	`+ private readonly object _getPictureThreadLock = new object();`
`40`	`41`	`private Task? _imageGrabber;`
`41`		`- private volatile bool _stopCapture = false;`
`42`	`42`	`private readonly Stopwatch _fpsTimer = new();`
`43`	`43`	`private volatile byte _frameCount;`
`44`	`44`	`private readonly System.Timers.Timer _keepAliveTimer = new();`
`@@ -93,10 +93,10 @@ public MjpegCamera(string path,`
`93`	`93`	`Description = new CameraDescription(CameraType.IP, path, name, frameFormats);`
`94`	`94`	`CurrentFps = Description.FrameFormats.FirstOrDefault()?.Fps ?? 10;`
`95`	`95`
`96`		`- _keepAliveTimer.Elapsed += CameraDisconnected;`
	`96`	`+ _keepAliveTimer.Elapsed += CheckCameraDisconnected;`
`97`	`97`	`}`
`98`	`98`
`99`		`- private async void CameraDisconnected(object? sender, ElapsedEventArgs e)`
	`99`	`+ private async void CheckCameraDisconnected(object? sender, ElapsedEventArgs e)`
`100`	`100`	`{`
`101`	`101`	`if (_fpsTimer.ElapsedMilliseconds > FrameTimeout)`
`102`	`102`	`{`
`@@ -135,17 +135,20 @@ public async Task<bool> Start(int width, int height, string format, Cancellation`
`135`	`135`	`_height = height;`
`136`	`136`	`_format = format;`
`137`	`137`
	`138`	`+ _cancellationTokenSource?.Dispose();`
`138`	`139`	`_cancellationTokenSource = new CancellationTokenSource();`
	`140`	`+ _cancellationTokenSourceCameraGrabber?.Dispose();`
	`141`	`+ _cancellationTokenSourceCameraGrabber = new CancellationTokenSource();`
	`142`	`+`
`139`	`143`	`_frameCount = 0;`
`140`	`144`	`_fpsTimer.Reset();`
`141`	`145`	`_keepAliveTimer.Interval = FrameTimeout;`
`142`	`146`	`_keepAliveTimer.Start();`
`143`	`147`
`144`		`- _stopCapture = false;`
`145`	`148`	`try`
`146`	`149`	`{`
`147`	`150`	`_imageGrabber?.Dispose();`
`148`		`- _imageGrabber = StartAsync(Description.Path, AuthenicationType, Login, Password, token).WaitAsync(TimeSpan.FromMilliseconds(FrameTimeout), token);`
	`151`	`+ _imageGrabber = StartAsync(Description.Path, AuthenicationType, _cancellationTokenSourceCameraGrabber.Token, Login, Password).WaitAsync(TimeSpan.FromMilliseconds(FrameTimeout), token);`
`149`	`152`	`}`
`150`	`153`	`catch (Exception ex)`
`151`	`154`	`{`
`@@ -172,11 +175,18 @@ private void Stop(bool cancellation)`
`172`	`175`
`173`	`176`	`lock (_getPictureThreadLock)`
`174`	`177`	`{`
	`178`	`+ IsRunning = false;`
`175`	`179`	`_keepAliveTimer.Stop();`
`176`	`180`
`177`		`- _stopCapture = true;`
`178`		`- var timeOut = DateTime.Now.AddSeconds(100);`
`179`		`- _imageGrabber?.Wait(5000);`
	`181`	`+ _cancellationTokenSourceCameraGrabber?.Cancel();`
	`182`	`+ try`
	`183`	`+ {`
	`184`	`+ _imageGrabber?.Wait(5000);`
	`185`	`+ }`
	`186`	`+ catch (Exception ex)`
	`187`	`+ {`
	`188`	`+ Console.WriteLine($"Camera Stop() failed: {ex}");`
	`189`	`+ }`
`180`	`190`
`181`	`191`	`if (cancellation)`
`182`	`192`	`_cancellationTokenSource?.Cancel();`
`@@ -247,18 +257,16 @@ public async IAsyncEnumerable<Mat> GrabFrames([EnumeratorCancellation] Cancellat`
`247`	`257`	`/// <param name="chunkMaxSize">Max chunk byte size when reading stream</param>`
`248`	`258`	`/// <param name="frameBufferSize">Maximum frame byte size</param>`
`249`	`259`	`/// <returns></returns>`
`250`		`- private async Task StartAsync(string url, AuthType authenicationType, string login = "", string password = "", CancellationToken? token = null, int chunkMaxSize = 1024, int frameBufferSize = 1024 * 1024)`
	`260`	`+ private async Task StartAsync(string url, AuthType authenicationType, CancellationToken token, string login = "", string password = "", int chunkMaxSize = 1024, int frameBufferSize = 1024 * 1024)`
`251`	`261`	`{`
`252`		`- var tokenLocal = token ?? CancellationToken.None;`
`253`		`-`
`254`	`262`	`using (var httpClient = new HttpClient())`
`255`	`263`	`{`
`256`	`264`	`if (authenicationType == AuthType.Basic)`
`257`	`265`	`httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(`
`258`	`266`	`"Basic",`
`259`	`267`	`Convert.ToBase64String(Encoding.ASCII.GetBytes($"{login}:{password}")));`
`260`	`268`
`261`		`- await using (var stream = await httpClient.GetStreamAsync(url, tokenLocal).ConfigureAwait(false))`
	`269`	`+ await using (var stream = await httpClient.GetStreamAsync(url, token).ConfigureAwait(false))`
`262`	`270`	`{`
`263`	`271`	`var streamBuffer = new byte[chunkMaxSize]; // Stream chunk read`
`264`	`272`	`var frameBuffer = new byte[frameBufferSize]; // Frame buffer`
`@@ -272,17 +280,18 @@ private async Task StartAsync(string url, AuthType authenicationType, string log`
`272`	`280`	`IsRunning = true;`
`273`	`281`	`try`
`274`	`282`	`{`
`275`		`- while (!_stopCapture && !tokenLocal.IsCancellationRequested)`
	`283`	`+ while (!token.IsCancellationRequested)`
`276`	`284`	`{`
`277`		`- var streamLength = await stream.ReadAsync(streamBuffer.AsMemory(0, chunkMaxSize), tokenLocal)`
	`285`	`+ var streamLength = await stream.ReadAsync(streamBuffer.AsMemory(0, chunkMaxSize), token)`
`278`	`286`	`.ConfigureAwait(false);`
`279`	`287`
`280`	`288`	`ParseStreamBuffer(frameBuffer, ref frameIdx, streamLength, streamBuffer, ref inPicture,`
`281`		`- ref previous, ref current, tokenLocal);`
	`289`	`+ ref previous, ref current, token);`
`282`	`290`	`}`
`283`	`291`	`}`
`284`	`292`	`catch (Exception ex)`
`285`	`293`	`{`
	`294`	`+ Stop();`
`286`	`295`	`Console.WriteLine(ex);`
`287`	`296`	`}`
`288`	`297`
`@@ -295,7 +304,7 @@ private async Task StartAsync(string url, AuthType authenicationType, string log`
`295`	`304`	`private void ParseStreamBuffer(byte[] frameBuffer, ref int frameIdx, int streamLength, byte[] streamBuffer, ref bool inPicture, ref byte previous, ref byte current, CancellationToken token)`
`296`	`305`	`{`
`297`	`306`	`var idx = 0;`
`298`		`- while (idx < streamLength && !_stopCapture && !token.IsCancellationRequested)`
	`307`	`+ while (idx < streamLength && !token.IsCancellationRequested)`
`299`	`308`	`{`
`300`	`309`	`if (inPicture)`
`301`	`310`	`{`
`@@ -325,7 +334,7 @@ private void SearchPicture(byte[] frameBuffer, ref int frameIdx, ref int streamL`
`325`	`334`	`inPicture = true;`
`326`	`335`	`return;`
`327`	`336`	`}`
`328`		`- } while (idx < streamLength && !_stopCapture && !token.IsCancellationRequested);`
	`337`	`+ } while (idx < streamLength && !token.IsCancellationRequested);`
`329`	`338`	`}`
`330`	`339`
`331`	`340`	`// While we are parsing a picture, fill the frame buffer until a FFD9 is reach.`
`@@ -384,7 +393,7 @@ private void ParsePicture(byte[] frameBuffer, ref int frameIdx, ref int streamLe`
`384`	`393`
`385`	`394`	`return;`
`386`	`395`	`}`
`387`		`- } while (idx < streamLength && !_stopCapture && !token.IsCancellationRequested);`
	`396`	`+ } while (idx < streamLength && !token.IsCancellationRequested);`
`388`	`397`	`}`
`389`	`398`
`390`	`399`	`#endregion`
`@@ -437,11 +446,11 @@ protected virtual void Dispose(bool disposing)`
`437`	`446`	`if (disposing)`
`438`	`447`	`{`
`439`	`448`	`Stop();`
`440`		`- _imageGrabber?.Wait(5000);`
`441`	`449`	`_imageGrabber?.Dispose();`
`442`	`450`	`_keepAliveTimer.Close();`
`443`	`451`	`_keepAliveTimer.Dispose();`
`444`	`452`	`_cancellationTokenSource?.Dispose();`
	`453`	`+ _cancellationTokenSourceCameraGrabber?.Dispose();`
`445`	`454`	`}`
`446`	`455`
`447`	`456`	`_disposedValue = true;`
Original file line number	Diff line number	Diff line change
`@@ -53,10 +53,10 @@ public UsbCamera(string path, string name = "")`
`53`	`53`	`Description = new CameraDescription(CameraType.USB, path, name, GetAllAvailableResolution(_usbCamera));`
`54`	`54`	`CurrentFps = Description.FrameFormats.FirstOrDefault()?.Fps ?? 10;`
`55`	`55`
`56`		`- _keepAliveTimer.Elapsed += CameraDisconnected;`
	`56`	`+ _keepAliveTimer.Elapsed += CheckCameraDisconnected;`
`57`	`57`	`}`
`58`	`58`
`59`		`- private async void CameraDisconnected(object? sender, ElapsedEventArgs e)`
	`59`	`+ private async void CheckCameraDisconnected(object? sender, ElapsedEventArgs e)`
`60`	`60`	`{`
`61`	`61`	`if (_fpsTimer.ElapsedMilliseconds > FrameTimeout)`
`62`	`62`	`{`
`@@ -282,6 +282,7 @@ private void Stop(bool cancellation)`
`282`	`282`
`283`	`283`	`lock (_getPictureThreadLock)`
`284`	`284`	`{`
	`285`	`+ IsRunning = false;`
`285`	`286`	`_keepAliveTimer.Stop();`
`286`	`287`
`287`	`288`	`if (cancellation)`