Merge adfc781e4c into fc5e8a66e3

FFMpegCore.Test/AudioTest.cs

@@ -9,10 +9,6 @@ namespace FFMpegCore.Test;
 [TestClass]
 public class AudioTest
 {
-    private const int BaseTimeoutMilliseconds = 30_000;
-
-    public TestContext TestContext { get; set; }
-
     [TestMethod]
     public void Audio_Remove()
     {
@@ -45,7 +41,6 @@ public class AudioTest
         await FFMpegArguments
             .FromPipeInput(new StreamPipeSource(file), options => options.ForceFormat("s16le"))
             .OutputToPipe(new StreamPipeSink(memoryStream), options => options.ForceFormat("mp3"))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously();
     }
 
@@ -75,7 +70,7 @@ public class AudioTest
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_ToAAC_Args_Pipe()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -88,13 +83,12 @@ public class AudioTest
             .FromPipeInput(audioSamplesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithAudioCodec(AudioCodec.Aac))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_ToLibVorbis_Args_Pipe()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -107,13 +101,12 @@ public class AudioTest
             .FromPipeInput(audioSamplesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithAudioCodec(AudioCodec.LibVorbis))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public async Task Audio_ToAAC_Args_Pipe_Async()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -126,13 +119,12 @@ public class AudioTest
             .FromPipeInput(audioSamplesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithAudioCodec(AudioCodec.Aac))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously();
         Assert.IsTrue(success);
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_ToAAC_Args_Pipe_ValidDefaultConfiguration()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -145,13 +137,12 @@ public class AudioTest
             .FromPipeInput(audioSamplesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithAudioCodec(AudioCodec.Aac))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_ToAAC_Args_Pipe_InvalidChannels()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -162,12 +153,11 @@ public class AudioTest
             .FromPipeInput(audioSamplesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithAudioCodec(AudioCodec.Aac))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously());
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_ToAAC_Args_Pipe_InvalidFormat()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -178,12 +168,11 @@ public class AudioTest
             .FromPipeInput(audioSamplesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithAudioCodec(AudioCodec.Aac))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously());
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_ToAAC_Args_Pipe_InvalidSampleRate()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -194,12 +183,11 @@ public class AudioTest
             .FromPipeInput(audioSamplesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithAudioCodec(AudioCodec.Aac))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously());
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_Pan_ToMono()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -208,7 +196,6 @@ public class AudioTest
             .OutputToFile(outputFile, true,
                 argumentOptions => argumentOptions
                     .WithAudioFilters(filter => filter.Pan(1, "c0 < 0.9 * c0 + 0.1 * c1")))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         var mediaAnalysis = FFProbe.Analyse(outputFile);
@@ -219,7 +206,7 @@ public class AudioTest
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_Pan_ToMonoNoDefinitions()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -228,7 +215,6 @@ public class AudioTest
             .OutputToFile(outputFile, true,
                 argumentOptions => argumentOptions
                     .WithAudioFilters(filter => filter.Pan(1)))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         var mediaAnalysis = FFProbe.Analyse(outputFile);
@@ -239,7 +225,7 @@ public class AudioTest
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_Pan_ToMonoChannelsToOutputDefinitionsMismatch()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -248,12 +234,11 @@ public class AudioTest
             .OutputToFile(outputFile, true,
                 argumentOptions => argumentOptions
                     .WithAudioFilters(filter => filter.Pan(1, "c0=c0", "c1=c1")))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously());
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_Pan_ToMonoChannelsLayoutToOutputDefinitionsMismatch()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -262,12 +247,11 @@ public class AudioTest
             .OutputToFile(outputFile, true,
                 argumentOptions => argumentOptions
                     .WithAudioFilters(filter => filter.Pan("mono", "c0=c0", "c1=c1")))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously());
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_DynamicNormalizer_WithDefaultValues()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -276,14 +260,13 @@ public class AudioTest
             .OutputToFile(outputFile, true,
                 argumentOptions => argumentOptions
                     .WithAudioFilters(filter => filter.DynamicNormalizer()))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         Assert.IsTrue(success);
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     public void Audio_DynamicNormalizer_WithNonDefaultValues()
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@@ -292,14 +275,13 @@ public class AudioTest
             .OutputToFile(outputFile, true,
                 argumentOptions => argumentOptions
                     .WithAudioFilters(filter => filter.DynamicNormalizer(250, 7, 0.9, 2, 1, false, true, true, 0.5)))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         Assert.IsTrue(success);
     }
 
     [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    [Timeout(10000, CooperativeCancellation = true)]
     [DataRow(2)]
     [DataRow(32)]
     [DataRow(8)]
@@ -312,7 +294,6 @@ public class AudioTest
             .OutputToFile(outputFile, true,
                 argumentOptions => argumentOptions
                     .WithAudioFilters(filter => filter.DynamicNormalizer(filterWindow: filterWindow)))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously());
     }
 }

FFMpegCore.Test/VideoTest.cs

@@ -17,7 +17,7 @@ namespace FFMpegCore.Test;
 [TestClass]
 public class VideoTest
 {
-    private const int BaseTimeoutMilliseconds = 60_000;
+    private const int BaseTimeoutMilliseconds = 15_000;
 
     private string _segmentPathSource = "";
 
@@ -47,7 +47,6 @@ public class VideoTest
         var success = FFMpegArguments
             .FromFileInput(TestResources.WebmVideo)
             .OutputToFile(outputFile, false)
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -61,7 +60,6 @@ public class VideoTest
         var success = FFMpegArguments
             .FromFileInput(TestResources.WebmVideo)
             .OutputToFile(outputFile, false)
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -77,7 +75,6 @@ public class VideoTest
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264)
                 .ForcePixelFormat("yuv444p"))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
         var analysis = FFProbe.Analyse(outputFile);
@@ -94,7 +91,6 @@ public class VideoTest
             .FromFileInput(TestResources.WebmVideo)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -109,7 +105,6 @@ public class VideoTest
             .FromFileInput(TestResources.WebmVideo)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX265))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -121,7 +116,7 @@ public class VideoTest
     [DataRow(PixelFormat.Format32bppArgb)]
     public void Video_ToMP4_Args_Pipe_WindowsOnly(PixelFormat pixelFormat)
     {
-        Video_ToMP4_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
+        Video_ToMP4_Args_Pipe_Internal(pixelFormat);
     }
 
     [TestMethod]
@@ -130,10 +125,10 @@ public class VideoTest
     [DataRow(SKColorType.Bgra8888)]
     public void Video_ToMP4_Args_Pipe(SKColorType pixelFormat)
     {
-        Video_ToMP4_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
+        Video_ToMP4_Args_Pipe_Internal(pixelFormat);
     }
 
-    private static void Video_ToMP4_Args_Pipe_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
+    private static void Video_ToMP4_Args_Pipe_Internal(dynamic pixelFormat)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -142,7 +137,6 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
-            .CancellableThrough(cancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -152,17 +146,17 @@ public class VideoTest
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_ToMP4_Args_Pipe_DifferentImageSizes_WindowsOnly()
     {
-        Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(PixelFormat.Format24bppRgb, TestContext.CancellationToken);
+        Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(PixelFormat.Format24bppRgb);
     }
 
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_ToMP4_Args_Pipe_DifferentImageSizes()
     {
-        Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(SKColorType.Rgb565, TestContext.CancellationToken);
+        Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(SKColorType.Rgb565);
     }
 
-    private static void Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
+    private static void Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(dynamic pixelFormat)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -176,7 +170,6 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
-            .CancellableThrough(cancellationToken)
             .ProcessSynchronously());
     }
 
@@ -185,17 +178,17 @@ public class VideoTest
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_WindowsOnly_Async()
     {
-        await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(PixelFormat.Format24bppRgb, TestContext.CancellationToken);
+        await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(PixelFormat.Format24bppRgb);
     }
 
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Async()
     {
-        await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(SKColorType.Rgb565, TestContext.CancellationToken);
+        await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(SKColorType.Rgb565);
     }
 
-    private static async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(dynamic pixelFormat, CancellationToken cancellationToken)
+    private static async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(dynamic pixelFormat)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -209,7 +202,6 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
-            .CancellableThrough(cancellationToken)
             .ProcessAsynchronously());
     }
 
@@ -219,18 +211,17 @@ public class VideoTest
     public void Video_ToMP4_Args_Pipe_DifferentPixelFormats_WindowsOnly()
     {
         Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(PixelFormat.Format24bppRgb,
-            PixelFormat.Format32bppRgb, TestContext.CancellationToken);
+            PixelFormat.Format32bppRgb);
     }
 
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_ToMP4_Args_Pipe_DifferentPixelFormats()
     {
-        Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(SKColorType.Rgb565, SKColorType.Bgra8888, TestContext.CancellationToken);
+        Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(SKColorType.Rgb565, SKColorType.Bgra8888);
     }
 
-    private static void Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2,
-        CancellationToken cancellationToken)
+    private static void Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -244,7 +235,6 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
-            .CancellableThrough(cancellationToken)
             .ProcessSynchronously());
     }
 
@@ -254,18 +244,17 @@ public class VideoTest
     public async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_WindowsOnly_Async()
     {
         await Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(PixelFormat.Format24bppRgb,
-            PixelFormat.Format32bppRgb, TestContext.CancellationToken);
+            PixelFormat.Format32bppRgb);
     }
 
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_Async()
     {
-        await Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(SKColorType.Rgb565, SKColorType.Bgra8888, TestContext.CancellationToken);
+        await Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(SKColorType.Rgb565, SKColorType.Bgra8888);
     }
 
-    private static async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2,
-        CancellationToken cancellationToken)
+    private static async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -279,7 +268,6 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
-            .CancellableThrough(cancellationToken)
             .ProcessAsynchronously());
     }
 
@@ -294,7 +282,6 @@ public class VideoTest
             .FromPipeInput(new StreamPipeSource(input))
             .OutputToFile(output, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -310,7 +297,6 @@ public class VideoTest
             await FFMpegArguments
                 .FromFileInput(TestResources.Mp4Video)
                 .OutputToPipe(pipeSource, opt => opt.ForceFormat("mp4"))
-                .CancellableThrough(TestContext.CancellationToken)
                 .ProcessAsynchronously();
         });
     }
@@ -326,7 +312,6 @@ public class VideoTest
                 .ForceFormat("webm"))
             .OutputToPipe(new StreamPipeSink(output), opt => opt
                 .ForceFormat("mpegts"))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         output.Position = 0;
@@ -345,7 +330,6 @@ public class VideoTest
                 .FromFileInput(TestResources.Mp4Video)
                 .OutputToPipe(new StreamPipeSink(ms), opt => opt
                     .ForceFormat("mkv"))
-                .CancellableThrough(TestContext.CancellationToken)
                 .ProcessSynchronously();
         });
     }
@@ -361,7 +345,6 @@ public class VideoTest
             .OutputToPipe(pipeSource, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264)
                 .ForceFormat("matroska"))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously();
     }
 
@@ -372,13 +355,11 @@ public class VideoTest
         FFMpegArguments
             .FromFileInput(TestResources.Mp4Video)
             .OutputToFile("temporary.mp4")
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         await FFMpegArguments
             .FromFileInput(TestResources.Mp4Video)
             .OutputToFile("temporary.mp4")
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously();
 
         File.Delete("temporary.mp4");
@@ -394,7 +375,6 @@ public class VideoTest
             .OutputToPipe(new StreamPipeSink(output), opt => opt
                 .WithVideoCodec(VideoCodec.LibVpx)
                 .ForceFormat("matroska"))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
 
@@ -413,7 +393,6 @@ public class VideoTest
         var success = FFMpegArguments
             .FromFileInput(TestResources.Mp4Video)
             .OutputToFile(outputFile, false)
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -430,7 +409,6 @@ public class VideoTest
                 .CopyChannel()
                 .WithBitStreamFilter(Channel.Video, Filter.H264_Mp4ToAnnexB)
                 .ForceFormat(VideoType.MpegTs))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -442,7 +420,7 @@ public class VideoTest
     [DataRow(PixelFormat.Format32bppArgb)]
     public async Task Video_ToTS_Args_Pipe_WindowsOnly(PixelFormat pixelFormat)
     {
-        await Video_ToTS_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
+        await Video_ToTS_Args_Pipe_Internal(pixelFormat);
     }
 
     [TestMethod]
@@ -451,10 +429,10 @@ public class VideoTest
     [DataRow(SKColorType.Bgra8888)]
     public async Task Video_ToTS_Args_Pipe(SKColorType pixelFormat)
     {
-        await Video_ToTS_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
+        await Video_ToTS_Args_Pipe_Internal(pixelFormat);
     }
 
-    private static async Task Video_ToTS_Args_Pipe_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
+    private static async Task Video_ToTS_Args_Pipe_Internal(dynamic pixelFormat)
     {
         using var output = new TemporaryFile($"out{VideoType.Ts.Extension}");
         var input = new RawVideoPipeSource(BitmapSource.CreateBitmaps(128, pixelFormat, 256, 256));
@@ -463,7 +441,6 @@ public class VideoTest
             .FromPipeInput(input)
             .OutputToFile(output, false, opt => opt
                 .ForceFormat(VideoType.Ts))
-            .CancellableThrough(cancellationToken)
             .ProcessAsynchronously();
         Assert.IsTrue(success);
 
@@ -481,7 +458,6 @@ public class VideoTest
             .OutputToFile(outputFile, false, opt => opt
                 .Resize(200, 200)
                 .WithVideoCodec(VideoCodec.LibTheora))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously();
         Assert.IsTrue(success);
     }
@@ -502,7 +478,6 @@ public class VideoTest
                 .WithVideoFilters(filterOptions => filterOptions
                     .Scale(VideoSize.Ed))
                 .WithVideoCodec(VideoCodec.LibTheora))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         var analysis = FFProbe.Analyse(outputFile);
@@ -520,7 +495,6 @@ public class VideoTest
             .OutputToFile(outputFile, false, opt => opt
                 .UsingMultithreading(true)
                 .WithVideoCodec(VideoCodec.LibX264))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -533,7 +507,7 @@ public class VideoTest
     // [DataRow(PixelFormat.Format48bppRgb)]
     public void Video_ToMP4_Resize_Args_Pipe(PixelFormat pixelFormat)
     {
-        Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
+        Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat);
     }
 
     [TestMethod]
@@ -542,10 +516,10 @@ public class VideoTest
     [DataRow(SKColorType.Bgra8888)]
     public void Video_ToMP4_Resize_Args_Pipe(SKColorType pixelFormat)
     {
-        Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
+        Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat);
     }
 
-    private static void Video_ToMP4_Resize_Args_Pipe_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
+    private static void Video_ToMP4_Resize_Args_Pipe_Internal(dynamic pixelFormat)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
         var videoFramesSource = new RawVideoPipeSource(BitmapSource.CreateBitmaps(128, pixelFormat, 256, 256));
@@ -554,7 +528,6 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
-            .CancellableThrough(cancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -783,7 +756,7 @@ public class VideoTest
         Assert.IsTrue(success);
         var result = FFProbe.Analyse(outputFile);
 
-        Assert.AreEqual(3, result.Duration.Seconds);
+        Assert.AreEqual(1, result.Duration.Seconds);
         Assert.AreEqual(imageAnalysis.PrimaryVideoStream!.Width, result.PrimaryVideoStream!.Width);
         Assert.AreEqual(imageAnalysis.PrimaryVideoStream!.Height, result.PrimaryVideoStream.Height);
     }
@@ -808,7 +781,6 @@ public class VideoTest
         FFMpegArguments
             .FromFileInput(TestResources.Mp4Video)
             .OutputToFile(outputFile, false, opt => opt.WithDuration(TimeSpan.FromSeconds(video.Duration.TotalSeconds - 2)))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         Assert.IsTrue(File.Exists(outputFile));
@@ -830,13 +802,13 @@ public class VideoTest
         var timeDone = TimeSpan.Zero;
         var analysis = FFProbe.Analyse(TestResources.Mp4Video);
 
-        var events = new List<double>();
-
         void OnPercentageProgess(double percentage)
         {
-            events.Add(percentage);
+            if (percentage < 100)
+            {
                 percentageDone = percentage;
             }
+        }
 
         void OnTimeProgess(TimeSpan time)
         {
@@ -852,16 +824,12 @@ public class VideoTest
                 .WithDuration(analysis.Duration))
             .NotifyOnProgress(OnPercentageProgess, analysis.Duration)
             .NotifyOnProgress(OnTimeProgess)
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         Assert.IsTrue(success);
         Assert.IsTrue(File.Exists(outputFile));
         Assert.AreNotEqual(0.0, percentageDone);
-        Assert.IsGreaterThan(1, events.Count);
-        CollectionAssert.AllItemsAreUnique(events);
-        Assert.AreNotEqual(100.0, events.First());
-        Assert.AreEqual(100.0, events.Last(), 0.001);
+        Assert.AreNotEqual(100.0, percentageDone);
         Assert.AreNotEqual(TimeSpan.Zero, timeDone);
         Assert.AreNotEqual(analysis.Duration, timeDone);
     }
@@ -881,7 +849,6 @@ public class VideoTest
                 .WithDuration(TimeSpan.FromSeconds(2)))
             .NotifyOnError(_ => dataReceived = true)
             .Configure(opt => opt.Encoding = Encoding.UTF8)
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         Assert.IsTrue(dataReceived);
@@ -894,17 +861,17 @@ public class VideoTest
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_TranscodeInMemory_WindowsOnly()
     {
-        Video_TranscodeInMemory_Internal(PixelFormat.Format24bppRgb, TestContext.CancellationToken);
+        Video_TranscodeInMemory_Internal(PixelFormat.Format24bppRgb);
     }
 
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_TranscodeInMemory()
     {
-        Video_TranscodeInMemory_Internal(SKColorType.Rgb565, TestContext.CancellationToken);
+        Video_TranscodeInMemory_Internal(SKColorType.Rgb565);
     }
 
-    private static void Video_TranscodeInMemory_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
+    private static void Video_TranscodeInMemory_Internal(dynamic pixelFormat)
     {
         using var resStream = new MemoryStream();
         var reader = new StreamPipeSink(resStream);
@@ -915,7 +882,6 @@ public class VideoTest
             .OutputToPipe(reader, opt => opt
                 .WithVideoCodec("vp9")
                 .ForceFormat("webm"))
-            .CancellableThrough(cancellationToken)
             .ProcessSynchronously();
 
         resStream.Position = 0;
@@ -935,7 +901,6 @@ public class VideoTest
             .OutputToPipe(new StreamPipeSink(memoryStream), opt => opt
                 .WithVideoCodec("vp9")
                 .ForceFormat("webm"))
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         memoryStream.Position = 0;
@@ -959,8 +924,6 @@ public class VideoTest
                 .WithVideoCodec(VideoCodec.LibX264)
                 .WithSpeedPreset(Speed.VeryFast))
             .CancellableThrough(out var cancel)
-            .CancellableThrough(TestContext.CancellationToken)
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously(false);
 
         await Task.Delay(300, TestContext.CancellationToken);
@@ -984,13 +947,11 @@ public class VideoTest
                 .WithAudioCodec(AudioCodec.Aac)
                 .WithVideoCodec(VideoCodec.LibX264)
                 .WithSpeedPreset(Speed.VeryFast))
-            .CancellableThrough(out var cancel)
-            .CancellableThrough(TestContext.CancellationToken);
+            .CancellableThrough(out var cancel);
 
         Task.Delay(300, TestContext.CancellationToken).ContinueWith(_ => cancel(), TestContext.CancellationToken);
 
-        var result = task.CancellableThrough(TestContext.CancellationToken)
-            .ProcessSynchronously(false);
+        var result = task.ProcessSynchronously(false);
 
         Assert.IsFalse(result);
     }
@@ -1010,7 +971,6 @@ public class VideoTest
                 .WithVideoCodec(VideoCodec.LibX264)
                 .WithSpeedPreset(Speed.VeryFast))
             .CancellableThrough(out var cancel, 10000)
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously(false);
 
         await Task.Delay(300, TestContext.CancellationToken);
@@ -1044,7 +1004,6 @@ public class VideoTest
                 .WithVideoCodec(VideoCodec.LibX264)
                 .WithSpeedPreset(Speed.VeryFast))
             .CancellableThrough(cts.Token)
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously(false);
 
         cts.CancelAfter(300);
@@ -1071,7 +1030,6 @@ public class VideoTest
                 .WithVideoCodec(VideoCodec.LibX264)
                 .WithSpeedPreset(Speed.VeryFast))
             .CancellableThrough(cts.Token)
-            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously();
 
         cts.CancelAfter(300);
@@ -1099,31 +1057,7 @@ public class VideoTest
 
         cts.CancelAfter(300);
 
-        Assert.ThrowsExactly<OperationCanceledException>(() => task.CancellableThrough(TestContext.CancellationToken)
-            .ProcessSynchronously());
-    }
-
-    [TestMethod]
-    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
-    public void Video_Cancel_CancellationToken_Before_Throws()
-    {
-        using var outputFile = new TemporaryFile("out.mp4");
-
-        var cts = new CancellationTokenSource();
-
-        cts.Cancel();
-        var task = FFMpegArguments
-            .FromFileInput("testsrc2=size=320x240[out0]; sine[out1]", false, args => args
-                .WithCustomArgument("-re")
-                .ForceFormat("lavfi"))
-            .OutputToFile(outputFile, false, opt => opt
-                .WithAudioCodec(AudioCodec.Aac)
-                .WithVideoCodec(VideoCodec.LibX264)
-                .WithSpeedPreset(Speed.VeryFast))
-            .CancellableThrough(cts.Token);
-
-        Assert.ThrowsExactly<OperationCanceledException>(() => task.CancellableThrough(TestContext.CancellationToken)
-            .ProcessSynchronously());
+        Assert.ThrowsExactly<OperationCanceledException>(() => task.ProcessSynchronously());
     }
 
     [TestMethod]

FFMpegCore/FFMpeg/Arguments/GifPaletteArgument.cs

@@ -4,11 +4,12 @@ namespace FFMpegCore.Arguments;
 
 public class GifPaletteArgument : IArgument
 {
-    private readonly double _fps;
+    private readonly int _fps;
+
     private readonly Size? _size;
     private readonly int _streamIndex;
 
-    public GifPaletteArgument(int streamIndex, double fps, Size? size)
+    public GifPaletteArgument(int streamIndex, int fps, Size? size)
     {
         _streamIndex = streamIndex;
         _fps = fps;

FFMpegCore/FFMpeg/FFMpeg.cs

@@ -132,8 +132,7 @@ public static class FFMpeg
             }
 
             return FFMpegArguments
-                .FromFileInput(Path.Combine(tempFolderName, $"%09d{fileExtension}"), false, options => options
-                    .WithFramerate(frameRate))
+                .FromFileInput(Path.Combine(tempFolderName, $"%09d{fileExtension}"), false)
                 .OutputToFile(output, true, options => options
                     .ForcePixelFormat("yuv420p")
                     .Resize(width!.Value, height!.Value)

FFMpegCore/FFMpeg/FFMpegArgumentOptions.cs

@@ -258,7 +258,7 @@ public class FFMpegArgumentOptions : FFMpegArgumentsBase
         return WithArgument(new ID3V2VersionArgument(id3v2Version));
     }
 
-    public FFMpegArgumentOptions WithGifPaletteArgument(int streamIndex, Size? size, double fps = 12)
+    public FFMpegArgumentOptions WithGifPaletteArgument(int streamIndex, Size? size, int fps = 12)
     {
         return WithArgument(new GifPaletteArgument(streamIndex, fps, size));
     }

FFMpegCore/FFMpeg/FFMpegArgumentProcessor.cs

@@ -12,8 +12,6 @@ public class FFMpegArgumentProcessor
     private static readonly Regex ProgressRegex = new(@"time=(\d\d:\d\d:\d\d.\d\d?)", RegexOptions.Compiled);
     private readonly List<Action<FFOptions>> _configurations;
     private readonly FFMpegArguments _ffMpegArguments;
-    private CancellationTokenRegistration? _cancellationTokenRegistration;
-    private bool _cancelled;
     private FFMpegLogLevel? _logLevel;
     private Action<string>? _onError;
     private Action<string>? _onOutput;
@@ -71,22 +69,15 @@ public class FFMpegArgumentProcessor
         return this;
     }
 
-    private void Cancel(int timeout)
-    {
-        _cancelled = true;
-        CancelEvent?.Invoke(this, timeout);
-    }
-
     public FFMpegArgumentProcessor CancellableThrough(out Action cancel, int timeout = 0)
     {
-        cancel = () => Cancel(timeout);
+        cancel = () => CancelEvent?.Invoke(this, timeout);
         return this;
     }
 
     public FFMpegArgumentProcessor CancellableThrough(CancellationToken token, int timeout = 0)
     {
-        _cancellationTokenRegistration?.Dispose();
-        _cancellationTokenRegistration = token.Register(() => Cancel(timeout));
+        token.Register(() => CancelEvent?.Invoke(this, timeout));
         return this;
     }
 
@@ -110,8 +101,7 @@ public class FFMpegArgumentProcessor
     public bool ProcessSynchronously(bool throwOnError = true, FFOptions? ffMpegOptions = null)
     {
         var options = GetConfiguredOptions(ffMpegOptions);
-        var processArguments = PrepareProcessArguments(options);
-        using var cancellationTokenSource = new CancellationTokenSource();
+        var processArguments = PrepareProcessArguments(options, out var cancellationTokenSource);
 
         IProcessResult? processResult = null;
         try
@@ -132,8 +122,7 @@ public class FFMpegArgumentProcessor
     public async Task<bool> ProcessAsynchronously(bool throwOnError = true, FFOptions? ffMpegOptions = null)
     {
         var options = GetConfiguredOptions(ffMpegOptions);
-        var processArguments = PrepareProcessArguments(options);
-        using var cancellationTokenSource = new CancellationTokenSource();
+        var processArguments = PrepareProcessArguments(options, out var cancellationTokenSource);
 
         IProcessResult? processResult = null;
         try
@@ -154,18 +143,15 @@ public class FFMpegArgumentProcessor
     private async Task<IProcessResult> Process(ProcessArguments processArguments, CancellationTokenSource cancellationTokenSource)
     {
         IProcessResult processResult = null!;
-        if (_cancelled)
-        {
-            _cancellationTokenRegistration?.Dispose();
-            throw new OperationCanceledException("cancelled before starting processing");
-        }
 
         _ffMpegArguments.Pre();
 
         using var instance = processArguments.Start();
+        var cancelled = false;
 
         void OnCancelEvent(object sender, int timeout)
         {
+            cancelled = true;
             instance.SendInput("q");
 
             if (!cancellationTokenSource.Token.WaitHandle.WaitOne(timeout, true))
@@ -186,9 +172,8 @@ public class FFMpegArgumentProcessor
                 _ffMpegArguments.Post();
             }), _ffMpegArguments.During(cancellationTokenSource.Token)).ConfigureAwait(false);
 
-            if (_cancelled)
+            if (cancelled)
             {
-                _cancellationTokenRegistration?.Dispose();
                 throw new OperationCanceledException("ffmpeg processing was cancelled");
             }
 
@@ -197,7 +182,6 @@ public class FFMpegArgumentProcessor
         finally
         {
             CancelEvent -= OnCancelEvent;
-            _cancellationTokenRegistration?.Dispose();
         }
     }
 
@@ -230,7 +214,8 @@ public class FFMpegArgumentProcessor
         return options;
     }
 
-    private ProcessArguments PrepareProcessArguments(FFOptions ffOptions)
+    private ProcessArguments PrepareProcessArguments(FFOptions ffOptions,
+        out CancellationTokenSource cancellationTokenSource)
     {
         FFMpegHelper.RootExceptionCheck();
         FFMpegHelper.VerifyFFMpegExists(ffOptions);
@@ -260,6 +245,7 @@ public class FFMpegArgumentProcessor
             WorkingDirectory = ffOptions.WorkingDirectory
         };
         var processArguments = new ProcessArguments(startInfo);
+        cancellationTokenSource = new CancellationTokenSource();
 
         if (_onOutput != null)
         {

FFMpegCore/FFMpeg/SnapshotArgumentBuilder.cs

@@ -62,7 +62,7 @@ public static class SnapshotArgumentBuilder
         TimeSpan? captureTime = null,
         TimeSpan? duration = null,
         int? streamIndex = null,
-        double fps = 12)
+        int fps = 12)
     {
         var defaultGifOutputSize = new Size(480, -1);