Merge pull request #598 from rosenbjerg/main

V.5.4.0

FFMpegCore.Extensions.SkiaSharp/FFMpegImage.cs

@@ -39,18 +39,21 @@ public static class FFMpegImage
     /// <param name="size">Thumbnail size. If width or height equal 0, the other will be computed automatically.</param>
     /// <param name="streamIndex">Selected video stream index.</param>
     /// <param name="inputFileIndex">Input file index</param>
+    /// <param name="cancellationToken">Cancellation token</param>
     /// <returns>Bitmap with the requested snapshot.</returns>
     public static async Task<SKBitmap> SnapshotAsync(string input, Size? size = null, TimeSpan? captureTime = null, int? streamIndex = null,
-        int inputFileIndex = 0)
+        int inputFileIndex = 0, CancellationToken cancellationToken = default)
     {
-        var source = await FFProbe.AnalyseAsync(input).ConfigureAwait(false);
+        var source = await FFProbe.AnalyseAsync(input, cancellationToken: cancellationToken).ConfigureAwait(false);
         var (arguments, outputOptions) = SnapshotArgumentBuilder.BuildSnapshotArguments(input, source, size, captureTime, streamIndex, inputFileIndex);
         using var ms = new MemoryStream();
 
         await arguments
             .OutputToPipe(new StreamPipeSink(ms), options => outputOptions(options
                 .ForceFormat("rawvideo")))
-            .ProcessAsynchronously();
+            .CancellableThrough(cancellationToken)
+            .ProcessAsynchronously()
+            .ConfigureAwait(false);
 
         ms.Position = 0;
         return SKBitmap.Decode(ms);

FFMpegCore.Extensions.System.Drawing.Common/FFMpegImage.cs

@@ -38,18 +38,21 @@ public static class FFMpegImage
     /// <param name="size">Thumbnail size. If width or height equal 0, the other will be computed automatically.</param>
     /// <param name="streamIndex">Selected video stream index.</param>
     /// <param name="inputFileIndex">Input file index</param>
+    /// <param name="cancellationToken">Cancellation token</param>
     /// <returns>Bitmap with the requested snapshot.</returns>
     public static async Task<Bitmap> SnapshotAsync(string input, Size? size = null, TimeSpan? captureTime = null, int? streamIndex = null,
-        int inputFileIndex = 0)
+        int inputFileIndex = 0, CancellationToken cancellationToken = default)
     {
-        var source = await FFProbe.AnalyseAsync(input).ConfigureAwait(false);
+        var source = await FFProbe.AnalyseAsync(input, cancellationToken: cancellationToken).ConfigureAwait(false);
         var (arguments, outputOptions) = SnapshotArgumentBuilder.BuildSnapshotArguments(input, source, size, captureTime, streamIndex, inputFileIndex);
         using var ms = new MemoryStream();
 
         await arguments
             .OutputToPipe(new StreamPipeSink(ms), options => outputOptions(options
                 .ForceFormat("rawvideo")))
-            .ProcessAsynchronously();
+            .CancellableThrough(cancellationToken)
+            .ProcessAsynchronously()
+            .ConfigureAwait(false);
 
         ms.Position = 0;
         return new Bitmap(ms);

FFMpegCore.Test/AudioTest.cs

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

FFMpegCore.Test/FFProbeTests.cs

@@ -1,4 +1,6 @@
-using FFMpegCore.Test.Resources;
+using FFMpegCore.Exceptions;
+using FFMpegCore.Helpers;
+using FFMpegCore.Test.Resources;
 
 namespace FFMpegCore.Test;
 
@@ -285,4 +287,68 @@ public class FFProbeTests
         var info = FFProbe.Analyse(TestResources.Mp4Video, customArguments: "-headers \"Hello: World\"");
         Assert.AreEqual(3, info.Duration.Seconds);
     }
+
+    [TestMethod]
+    [Timeout(10000, CooperativeCancellation = true)]
+    public async Task Parallel_FFProbe_Cancellation_Should_Throw_Only_OperationCanceledException()
+    {
+        // Warm up FFMpegCore environment
+        FFProbeHelper.VerifyFFProbeExists(GlobalFFOptions.Current);
+
+        var mp4 = TestResources.Mp4Video;
+        if (!File.Exists(mp4))
+        {
+            Assert.Inconclusive($"Test video not found: {mp4}");
+            return;
+        }
+
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.CancellationToken);
+        using var semaphore = new SemaphoreSlim(Environment.ProcessorCount, Environment.ProcessorCount);
+        var tasks = Enumerable.Range(0, 50).Select(x => Task.Run(async () =>
+        {
+            await semaphore.WaitAsync(cts.Token);
+            try
+            {
+                var analysis = await FFProbe.AnalyseAsync(mp4, cancellationToken: cts.Token);
+                return analysis;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }, cts.Token)).ToList();
+
+        // Wait for 2 tasks to finish, then cancel all
+        await Task.WhenAny(tasks);
+        await Task.WhenAny(tasks);
+        await cts.CancelAsync();
+
+        var exceptions = new List<Exception>();
+        foreach (var task in tasks)
+        {
+            try
+            {
+                await task;
+            }
+            catch (Exception e)
+            {
+                exceptions.Add(e);
+            }
+        }
+
+        Assert.IsNotEmpty(exceptions, "No exceptions were thrown on cancellation. Test was useless. " +
+                                      ".Try adjust cancellation timings to make cancellation at the moment, when ffprobe is still running.");
+
+        // Check that all exceptions are OperationCanceledException
+        CollectionAssert.AllItemsAreInstancesOfType(exceptions, typeof(OperationCanceledException));
+    }
+
+    [TestMethod]
+    [Timeout(10000, CooperativeCancellation = true)]
+    public async Task FFProbe_Should_Throw_FFMpegException_When_Exits_With_Non_Zero_Code()
+    {
+        var input = TestResources.SrtSubtitle; //non media file
+        await Assert.ThrowsAsync<FFMpegException>(async () => await FFProbe.AnalyseAsync(input,
+            cancellationToken: TestContext.CancellationToken, customArguments: "--some-invalid-argument"));
+    }
 }

FFMpegCore.Test/VideoTest.cs

@@ -17,7 +17,7 @@ namespace FFMpegCore.Test;
 [TestClass]
 public class VideoTest
 {
-    private const int BaseTimeoutMilliseconds = 15_000;
+    private const int BaseTimeoutMilliseconds = 60_000;
 
     public TestContext TestContext { get; set; }
 
@@ -30,6 +30,7 @@ public class VideoTest
         var success = FFMpegArguments
             .FromFileInput(TestResources.WebmVideo)
             .OutputToFile(outputFile, false)
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -43,6 +44,7 @@ public class VideoTest
         var success = FFMpegArguments
             .FromFileInput(TestResources.WebmVideo)
             .OutputToFile(outputFile, false)
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -58,6 +60,7 @@ 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);
@@ -74,10 +77,45 @@ public class VideoTest
             .FromFileInput(TestResources.WebmVideo)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
 
+    [TestMethod]
+    [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
+    public async Task Video_MetadataBuilder()
+    {
+        using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
+
+        await FFMpegArguments
+            .FromFileInput(TestResources.WebmVideo)
+            .AddMetaData(FFMetadataBuilder.Empty()
+                .WithTag("title", "noname")
+                .WithTag("artist", "unknown")
+                .WithChapter("Chapter 1", 1.1)
+                .WithChapter("Chapter 2", 1.23))
+            .OutputToFile(outputFile, false, opt => opt
+                .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(TestContext.CancellationToken)
+            .ProcessAsynchronously();
+
+        var analysis = await FFProbe.AnalyseAsync(outputFile, cancellationToken: TestContext.CancellationToken);
+        Assert.IsTrue(analysis.Format.Tags!.TryGetValue("title", out var title));
+        Assert.IsTrue(analysis.Format.Tags!.TryGetValue("artist", out var artist));
+        Assert.AreEqual("noname", title);
+        Assert.AreEqual("unknown", artist);
+
+        Assert.HasCount(2, analysis.Chapters);
+        Assert.AreEqual("Chapter 1", analysis.Chapters.First().Title);
+        Assert.AreEqual(1.1, analysis.Chapters.First().Duration.TotalSeconds);
+        Assert.AreEqual(1.1, analysis.Chapters.First().End.TotalSeconds);
+
+        Assert.AreEqual("Chapter 2", analysis.Chapters.Last().Title);
+        Assert.AreEqual(1.23, analysis.Chapters.Last().Duration.TotalSeconds);
+        Assert.AreEqual(1.1 + 1.23, analysis.Chapters.Last().End.TotalSeconds);
+    }
+
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_ToH265_MKV_Args()
@@ -88,6 +126,7 @@ public class VideoTest
             .FromFileInput(TestResources.WebmVideo)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX265))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -99,7 +138,7 @@ public class VideoTest
     [DataRow(PixelFormat.Format32bppArgb)]
     public void Video_ToMP4_Args_Pipe_WindowsOnly(PixelFormat pixelFormat)
     {
-        Video_ToMP4_Args_Pipe_Internal(pixelFormat);
+        Video_ToMP4_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
     }
 
     [TestMethod]
@@ -108,10 +147,10 @@ public class VideoTest
     [DataRow(SKColorType.Bgra8888)]
     public void Video_ToMP4_Args_Pipe(SKColorType pixelFormat)
     {
-        Video_ToMP4_Args_Pipe_Internal(pixelFormat);
+        Video_ToMP4_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
     }
 
-    private static void Video_ToMP4_Args_Pipe_Internal(dynamic pixelFormat)
+    private static void Video_ToMP4_Args_Pipe_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -120,6 +159,7 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(cancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -129,17 +169,17 @@ public class VideoTest
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_ToMP4_Args_Pipe_DifferentImageSizes_WindowsOnly()
     {
-        Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(PixelFormat.Format24bppRgb);
+        Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(PixelFormat.Format24bppRgb, TestContext.CancellationToken);
     }
 
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_ToMP4_Args_Pipe_DifferentImageSizes()
     {
-        Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(SKColorType.Rgb565);
+        Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(SKColorType.Rgb565, TestContext.CancellationToken);
     }
 
-    private static void Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(dynamic pixelFormat)
+    private static void Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -153,6 +193,7 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(cancellationToken)
             .ProcessSynchronously());
     }
 
@@ -161,17 +202,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);
+        await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(PixelFormat.Format24bppRgb, TestContext.CancellationToken);
     }
 
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Async()
     {
-        await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(SKColorType.Rgb565);
+        await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(SKColorType.Rgb565, TestContext.CancellationToken);
     }
 
-    private static async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(dynamic pixelFormat)
+    private static async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(dynamic pixelFormat, CancellationToken cancellationToken)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -185,6 +226,7 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(cancellationToken)
             .ProcessAsynchronously());
     }
 
@@ -194,17 +236,18 @@ public class VideoTest
     public void Video_ToMP4_Args_Pipe_DifferentPixelFormats_WindowsOnly()
     {
         Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(PixelFormat.Format24bppRgb,
-            PixelFormat.Format32bppRgb);
+            PixelFormat.Format32bppRgb, TestContext.CancellationToken);
     }
 
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_ToMP4_Args_Pipe_DifferentPixelFormats()
     {
-        Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(SKColorType.Rgb565, SKColorType.Bgra8888);
+        Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(SKColorType.Rgb565, SKColorType.Bgra8888, TestContext.CancellationToken);
     }
 
-    private static void Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2)
+    private static void Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2,
+        CancellationToken cancellationToken)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -218,6 +261,7 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(cancellationToken)
             .ProcessSynchronously());
     }
 
@@ -227,17 +271,18 @@ 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);
+            PixelFormat.Format32bppRgb, TestContext.CancellationToken);
     }
 
     [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);
+        await Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(SKColorType.Rgb565, SKColorType.Bgra8888, TestContext.CancellationToken);
     }
 
-    private static async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2)
+    private static async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2,
+        CancellationToken cancellationToken)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
 
@@ -251,6 +296,7 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(cancellationToken)
             .ProcessAsynchronously());
     }
 
@@ -265,6 +311,7 @@ public class VideoTest
             .FromPipeInput(new StreamPipeSource(input))
             .OutputToFile(output, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -280,6 +327,7 @@ public class VideoTest
             await FFMpegArguments
                 .FromFileInput(TestResources.Mp4Video)
                 .OutputToPipe(pipeSource, opt => opt.ForceFormat("mp4"))
+                .CancellableThrough(TestContext.CancellationToken)
                 .ProcessAsynchronously();
         });
     }
@@ -295,6 +343,7 @@ public class VideoTest
                 .ForceFormat("webm"))
             .OutputToPipe(new StreamPipeSink(output), opt => opt
                 .ForceFormat("mpegts"))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         output.Position = 0;
@@ -313,6 +362,7 @@ public class VideoTest
                 .FromFileInput(TestResources.Mp4Video)
                 .OutputToPipe(new StreamPipeSink(ms), opt => opt
                     .ForceFormat("mkv"))
+                .CancellableThrough(TestContext.CancellationToken)
                 .ProcessSynchronously();
         });
     }
@@ -328,6 +378,7 @@ public class VideoTest
             .OutputToPipe(pipeSource, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264)
                 .ForceFormat("matroska"))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously();
     }
 
@@ -338,11 +389,13 @@ 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");
@@ -358,6 +411,7 @@ public class VideoTest
             .OutputToPipe(new StreamPipeSink(output), opt => opt
                 .WithVideoCodec(VideoCodec.LibVpx)
                 .ForceFormat("matroska"))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
 
@@ -376,6 +430,7 @@ public class VideoTest
         var success = FFMpegArguments
             .FromFileInput(TestResources.Mp4Video)
             .OutputToFile(outputFile, false)
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -392,6 +447,7 @@ public class VideoTest
                 .CopyChannel()
                 .WithBitStreamFilter(Channel.Video, Filter.H264_Mp4ToAnnexB)
                 .ForceFormat(VideoType.MpegTs))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -403,7 +459,7 @@ public class VideoTest
     [DataRow(PixelFormat.Format32bppArgb)]
     public async Task Video_ToTS_Args_Pipe_WindowsOnly(PixelFormat pixelFormat)
     {
-        await Video_ToTS_Args_Pipe_Internal(pixelFormat);
+        await Video_ToTS_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
     }
 
     [TestMethod]
@@ -412,10 +468,10 @@ public class VideoTest
     [DataRow(SKColorType.Bgra8888)]
     public async Task Video_ToTS_Args_Pipe(SKColorType pixelFormat)
     {
-        await Video_ToTS_Args_Pipe_Internal(pixelFormat);
+        await Video_ToTS_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
     }
 
-    private static async Task Video_ToTS_Args_Pipe_Internal(dynamic pixelFormat)
+    private static async Task Video_ToTS_Args_Pipe_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
     {
         using var output = new TemporaryFile($"out{VideoType.Ts.Extension}");
         var input = new RawVideoPipeSource(BitmapSource.CreateBitmaps(128, pixelFormat, 256, 256));
@@ -424,6 +480,7 @@ public class VideoTest
             .FromPipeInput(input)
             .OutputToFile(output, false, opt => opt
                 .ForceFormat(VideoType.Ts))
+            .CancellableThrough(cancellationToken)
             .ProcessAsynchronously();
         Assert.IsTrue(success);
 
@@ -441,6 +498,7 @@ public class VideoTest
             .OutputToFile(outputFile, false, opt => opt
                 .Resize(200, 200)
                 .WithVideoCodec(VideoCodec.LibTheora))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessAsynchronously();
         Assert.IsTrue(success);
     }
@@ -461,6 +519,7 @@ public class VideoTest
                 .WithVideoFilters(filterOptions => filterOptions
                     .Scale(VideoSize.Ed))
                 .WithVideoCodec(VideoCodec.LibTheora))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         var analysis = FFProbe.Analyse(outputFile);
@@ -478,6 +537,7 @@ public class VideoTest
             .OutputToFile(outputFile, false, opt => opt
                 .UsingMultithreading(true)
                 .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -490,7 +550,7 @@ public class VideoTest
     // [DataRow(PixelFormat.Format48bppRgb)]
     public void Video_ToMP4_Resize_Args_Pipe(PixelFormat pixelFormat)
     {
-        Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat);
+        Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
     }
 
     [TestMethod]
@@ -499,10 +559,10 @@ public class VideoTest
     [DataRow(SKColorType.Bgra8888)]
     public void Video_ToMP4_Resize_Args_Pipe(SKColorType pixelFormat)
     {
-        Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat);
+        Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken);
     }
 
-    private static void Video_ToMP4_Resize_Args_Pipe_Internal(dynamic pixelFormat)
+    private static void Video_ToMP4_Resize_Args_Pipe_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
     {
         using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
         var videoFramesSource = new RawVideoPipeSource(BitmapSource.CreateBitmaps(128, pixelFormat, 256, 256));
@@ -511,6 +571,7 @@ public class VideoTest
             .FromPipeInput(videoFramesSource)
             .OutputToFile(outputFile, false, opt => opt
                 .WithVideoCodec(VideoCodec.LibX264))
+            .CancellableThrough(cancellationToken)
             .ProcessSynchronously();
         Assert.IsTrue(success);
     }
@@ -671,7 +732,8 @@ public class VideoTest
         using var outputPath = new TemporaryFile("out.gif");
         var input = FFProbe.Analyse(TestResources.Mp4Video);
 
-        await FFMpeg.GifSnapshotAsync(TestResources.Mp4Video, outputPath, captureTime: TimeSpan.FromSeconds(0));
+        await FFMpeg.GifSnapshotAsync(TestResources.Mp4Video, outputPath, captureTime: TimeSpan.FromSeconds(0),
+            cancellationToken: TestContext.CancellationToken);
 
         var analysis = FFProbe.Analyse(outputPath);
         Assert.AreNotEqual(input.PrimaryVideoStream!.Width, analysis.PrimaryVideoStream!.Width);
@@ -687,7 +749,8 @@ public class VideoTest
         var input = FFProbe.Analyse(TestResources.Mp4Video);
         var desiredGifSize = new Size(320, 240);
 
-        await FFMpeg.GifSnapshotAsync(TestResources.Mp4Video, outputPath, desiredGifSize, TimeSpan.FromSeconds(0));
+        await FFMpeg.GifSnapshotAsync(TestResources.Mp4Video, outputPath, desiredGifSize, TimeSpan.FromSeconds(0),
+            cancellationToken: TestContext.CancellationToken);
 
         var analysis = FFProbe.Analyse(outputPath);
         Assert.AreNotEqual(input.PrimaryVideoStream!.Width, desiredGifSize.Width);
@@ -739,7 +802,7 @@ public class VideoTest
         Assert.IsTrue(success);
         var result = FFProbe.Analyse(outputFile);
 
-        Assert.AreEqual(1, result.Duration.Seconds);
+        Assert.AreEqual(3, result.Duration.Seconds);
         Assert.AreEqual(imageAnalysis.PrimaryVideoStream!.Width, result.PrimaryVideoStream!.Width);
         Assert.AreEqual(imageAnalysis.PrimaryVideoStream!.Height, result.PrimaryVideoStream.Height);
     }
@@ -764,6 +827,7 @@ 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));
@@ -785,13 +849,13 @@ public class VideoTest
         var timeDone = TimeSpan.Zero;
         var analysis = FFProbe.Analyse(TestResources.Mp4Video);
 
+        var events = new List<double>();
+
         void OnPercentageProgess(double percentage)
         {
-            if (percentage < 100)
+            events.Add(percentage);
-            {
             percentageDone = percentage;
         }
-        }
 
         void OnTimeProgess(TimeSpan time)
         {
@@ -807,12 +871,16 @@ 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.AreNotEqual(100.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(TimeSpan.Zero, timeDone);
         Assert.AreNotEqual(analysis.Duration, timeDone);
     }
@@ -832,6 +900,7 @@ public class VideoTest
                 .WithDuration(TimeSpan.FromSeconds(2)))
             .NotifyOnError(_ => dataReceived = true)
             .Configure(opt => opt.Encoding = Encoding.UTF8)
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         Assert.IsTrue(dataReceived);
@@ -844,17 +913,17 @@ public class VideoTest
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_TranscodeInMemory_WindowsOnly()
     {
-        Video_TranscodeInMemory_Internal(PixelFormat.Format24bppRgb);
+        Video_TranscodeInMemory_Internal(PixelFormat.Format24bppRgb, TestContext.CancellationToken);
     }
 
     [TestMethod]
     [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
     public void Video_TranscodeInMemory()
     {
-        Video_TranscodeInMemory_Internal(SKColorType.Rgb565);
+        Video_TranscodeInMemory_Internal(SKColorType.Rgb565, TestContext.CancellationToken);
     }
 
-    private static void Video_TranscodeInMemory_Internal(dynamic pixelFormat)
+    private static void Video_TranscodeInMemory_Internal(dynamic pixelFormat, CancellationToken cancellationToken)
     {
         using var resStream = new MemoryStream();
         var reader = new StreamPipeSink(resStream);
@@ -865,6 +934,7 @@ public class VideoTest
             .OutputToPipe(reader, opt => opt
                 .WithVideoCodec("vp9")
                 .ForceFormat("webm"))
+            .CancellableThrough(cancellationToken)
             .ProcessSynchronously();
 
         resStream.Position = 0;
@@ -884,6 +954,7 @@ public class VideoTest
             .OutputToPipe(new StreamPipeSink(memoryStream), opt => opt
                 .WithVideoCodec("vp9")
                 .ForceFormat("webm"))
+            .CancellableThrough(TestContext.CancellationToken)
             .ProcessSynchronously();
 
         memoryStream.Position = 0;
@@ -907,6 +978,8 @@ 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);
@@ -930,11 +1003,13 @@ public class VideoTest
                 .WithAudioCodec(AudioCodec.Aac)
                 .WithVideoCodec(VideoCodec.LibX264)
                 .WithSpeedPreset(Speed.VeryFast))
-            .CancellableThrough(out var cancel);
+            .CancellableThrough(out var cancel)
+            .CancellableThrough(TestContext.CancellationToken);
 
         Task.Delay(300, TestContext.CancellationToken).ContinueWith(_ => cancel(), TestContext.CancellationToken);
 
-        var result = task.ProcessSynchronously(false);
+        var result = task.CancellableThrough(TestContext.CancellationToken)
+            .ProcessSynchronously(false);
 
         Assert.IsFalse(result);
     }
@@ -954,6 +1029,7 @@ 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);
@@ -976,7 +1052,7 @@ public class VideoTest
     {
         using var outputFile = new TemporaryFile("out.mp4");
 
-        var cts = new CancellationTokenSource();
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.CancellationToken);
 
         var task = FFMpegArguments
             .FromFileInput("testsrc2=size=320x240[out0]; sine[out1]", false, args => args
@@ -1002,7 +1078,7 @@ public class VideoTest
     {
         using var outputFile = new TemporaryFile("out.mp4");
 
-        var cts = new CancellationTokenSource();
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.CancellationToken);
 
         var task = FFMpegArguments
             .FromFileInput("testsrc2=size=320x240[out0]; sine[out1]", false, args => args
@@ -1026,7 +1102,7 @@ public class VideoTest
     {
         using var outputFile = new TemporaryFile("out.mp4");
 
-        var cts = new CancellationTokenSource();
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.CancellationToken);
 
         var task = FFMpegArguments
             .FromFileInput("testsrc2=size=320x240[out0]; sine[out1]", false, args => args
@@ -1040,7 +1116,31 @@ public class VideoTest
 
         cts.CancelAfter(300);
 
-        Assert.ThrowsExactly<OperationCanceledException>(() => task.ProcessSynchronously());
+        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");
+
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.CancellationToken);
+
+        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());
     }
 
     [TestMethod]
@@ -1049,7 +1149,7 @@ public class VideoTest
     {
         using var outputFile = new TemporaryFile("out.mp4");
 
-        var cts = new CancellationTokenSource();
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.CancellationToken);
 
         var task = FFMpegArguments
             .FromFileInput("testsrc2=size=320x240[out0]; sine[out1]", false, args => args

FFMpegCore/FFMetadataInputArgument.cs

@@ -0,0 +1,62 @@
+using System.Text;
+
+namespace FFMpegCore;
+
+public class FFMetadataBuilder
+{
+    private Dictionary<string, string> Tags { get; } = new();
+    private List<FFMetadataChapter> Chapters { get; } = [];
+
+    public static FFMetadataBuilder Empty()
+    {
+        return new FFMetadataBuilder();
+    }
+
+    public FFMetadataBuilder WithTag(string key, string value)
+    {
+        Tags.Add(key, value);
+        return this;
+    }
+
+    public FFMetadataBuilder WithChapter(string title, long durationMs)
+    {
+        Chapters.Add(new FFMetadataChapter(title, durationMs));
+        return this;
+    }
+
+    public FFMetadataBuilder WithChapter(string title, double durationSeconds)
+    {
+        Chapters.Add(new FFMetadataChapter(title, Convert.ToInt64(durationSeconds * 1000)));
+        return this;
+    }
+
+    public string GetMetadataFileContent()
+    {
+        var sb = new StringBuilder();
+        sb.AppendLine(";FFMETADATA1");
+
+        foreach (var tag in Tags)
+        {
+            sb.AppendLine($"{tag.Key}={tag.Value}");
+        }
+
+        long totalDurationMs = 0;
+        foreach (var chapter in Chapters)
+        {
+            sb.AppendLine("[CHAPTER]");
+            sb.AppendLine("TIMEBASE=1/1000");
+            sb.AppendLine($"START={totalDurationMs}");
+            sb.AppendLine($"END={totalDurationMs + chapter.DurationMs}");
+            sb.AppendLine($"title={chapter.Title}");
+            totalDurationMs += chapter.DurationMs;
+        }
+
+        return sb.ToString();
+    }
+
+    private class FFMetadataChapter(string title, long durationMs)
+    {
+        public string Title { get; } = title;
+        public long DurationMs { get; } = durationMs;
+    }
+}

FFMpegCore/FFMpeg/Arguments/GifPaletteArgument.cs

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

FFMpegCore/FFMpeg/FFMpeg.cs

@@ -37,16 +37,19 @@ public static class FFMpeg
     /// <param name="size">Thumbnail size. If width or height equal 0, the other will be computed automatically.</param>
     /// <param name="streamIndex">Selected video stream index.</param>
     /// <param name="inputFileIndex">Input file index</param>
+    /// <param name="cancellationToken">Cancellation token</param>
     /// <returns>Bitmap with the requested snapshot.</returns>
     public static async Task<bool> SnapshotAsync(string input, string output, Size? size = null, TimeSpan? captureTime = null, int? streamIndex = null,
-        int inputFileIndex = 0)
+        int inputFileIndex = 0, CancellationToken cancellationToken = default)
     {
         CheckSnapshotOutputExtension(output, FileExtension.Image.All);
 
-        var source = await FFProbe.AnalyseAsync(input).ConfigureAwait(false);
+        var source = await FFProbe.AnalyseAsync(input, cancellationToken: cancellationToken).ConfigureAwait(false);
 
         return await SnapshotProcess(input, output, source, size, captureTime, streamIndex, inputFileIndex)
-            .ProcessAsynchronously();
+            .CancellableThrough(cancellationToken)
+            .ProcessAsynchronously()
+            .ConfigureAwait(false);
     }
 
     public static bool GifSnapshot(string input, string output, Size? size = null, TimeSpan? captureTime = null, TimeSpan? duration = null,
@@ -61,14 +64,16 @@ public static class FFMpeg
     }
 
     public static async Task<bool> GifSnapshotAsync(string input, string output, Size? size = null, TimeSpan? captureTime = null, TimeSpan? duration = null,
-        int? streamIndex = null)
+        int? streamIndex = null, CancellationToken cancellationToken = default)
     {
         CheckSnapshotOutputExtension(output, [FileExtension.Gif]);
 
-        var source = await FFProbe.AnalyseAsync(input).ConfigureAwait(false);
+        var source = await FFProbe.AnalyseAsync(input, cancellationToken: cancellationToken).ConfigureAwait(false);
 
         return await GifSnapshotProcess(input, output, source, size, captureTime, duration, streamIndex)
-            .ProcessAsynchronously();
+            .CancellableThrough(cancellationToken)
+            .ProcessAsynchronously()
+            .ConfigureAwait(false);
     }
 
     private static FFMpegArgumentProcessor SnapshotProcess(string input, string output, IMediaAnalysis source, Size? size = null, TimeSpan? captureTime = null,
@@ -132,7 +137,8 @@ public static class FFMpeg
             }
 
             return FFMpegArguments
-                .FromFileInput(Path.Combine(tempFolderName, $"%09d{fileExtension}"), false)
+                .FromFileInput(Path.Combine(tempFolderName, $"%09d{fileExtension}"), false, options => options
+                    .WithFramerate(frameRate))
                 .OutputToFile(output, true, options => options
                     .ForcePixelFormat("yuv420p")
                     .Resize(width!.Value, height!.Value)
@@ -320,11 +326,15 @@ public static class FFMpeg
     /// <param name="output">Output video file.</param>
     /// <param name="startTime">The start time of when the sub video needs to start</param>
     /// <param name="endTime">The end time of where the sub video needs to  end</param>
+    /// <param name="cancellationToken">Cancellation token</param>
     /// <returns>Output video information.</returns>
-    public static async Task<bool> SubVideoAsync(string input, string output, TimeSpan startTime, TimeSpan endTime)
+    public static async Task<bool> SubVideoAsync(string input, string output, TimeSpan startTime, TimeSpan endTime,
+        CancellationToken cancellationToken = default)
     {
         return await BaseSubVideo(input, output, startTime, endTime)
-            .ProcessAsynchronously();
+            .CancellableThrough(cancellationToken)
+            .ProcessAsynchronously()
+            .ConfigureAwait(false);
     }
 
     /// <summary>

FFMpegCore/FFMpeg/FFMpegArgumentOptions.cs

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

FFMpegCore/FFMpeg/FFMpegArgumentProcessor.cs

@@ -12,6 +12,8 @@ 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;
@@ -69,15 +71,22 @@ 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 = () => CancelEvent?.Invoke(this, timeout);
+        cancel = () => Cancel(timeout);
         return this;
     }
 
     public FFMpegArgumentProcessor CancellableThrough(CancellationToken token, int timeout = 0)
     {
-        token.Register(() => CancelEvent?.Invoke(this, timeout));
+        _cancellationTokenRegistration?.Dispose();
+        _cancellationTokenRegistration = token.Register(() => Cancel(timeout));
         return this;
     }
 
@@ -101,7 +110,8 @@ public class FFMpegArgumentProcessor
     public bool ProcessSynchronously(bool throwOnError = true, FFOptions? ffMpegOptions = null)
     {
         var options = GetConfiguredOptions(ffMpegOptions);
-        var processArguments = PrepareProcessArguments(options, out var cancellationTokenSource);
+        var processArguments = PrepareProcessArguments(options);
+        using var cancellationTokenSource = new CancellationTokenSource();
 
         IProcessResult? processResult = null;
         try
@@ -122,7 +132,8 @@ public class FFMpegArgumentProcessor
     public async Task<bool> ProcessAsynchronously(bool throwOnError = true, FFOptions? ffMpegOptions = null)
     {
         var options = GetConfiguredOptions(ffMpegOptions);
-        var processArguments = PrepareProcessArguments(options, out var cancellationTokenSource);
+        var processArguments = PrepareProcessArguments(options);
+        using var cancellationTokenSource = new CancellationTokenSource();
 
         IProcessResult? processResult = null;
         try
@@ -143,21 +154,40 @@ 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;
+            ExecuteIgnoringFinishedProcessExceptions(() => instance.SendInput("q"));
-            instance.SendInput("q");
 
             if (!cancellationTokenSource.Token.WaitHandle.WaitOne(timeout, true))
             {
                 cancellationTokenSource.Cancel();
-                instance.Kill();
+                ExecuteIgnoringFinishedProcessExceptions(() => instance.Kill());
+            }
+
+            static void ExecuteIgnoringFinishedProcessExceptions(Action action)
+            {
+                try
+                {
+                    action();
+                }
+                catch (Instances.Exceptions.InstanceProcessAlreadyExitedException)
+                {
+                    //ignore
+                }
+                catch (ObjectDisposedException)
+                {
+                    //ignore
+                }
             }
         }
 
@@ -172,8 +202,9 @@ public class FFMpegArgumentProcessor
                 _ffMpegArguments.Post();
             }), _ffMpegArguments.During(cancellationTokenSource.Token)).ConfigureAwait(false);
 
-            if (cancelled)
+            if (_cancelled)
             {
+                _cancellationTokenRegistration?.Dispose();
                 throw new OperationCanceledException("ffmpeg processing was cancelled");
             }
 
@@ -182,6 +213,7 @@ public class FFMpegArgumentProcessor
         finally
         {
             CancelEvent -= OnCancelEvent;
+            _cancellationTokenRegistration?.Dispose();
         }
     }
 
@@ -214,8 +246,7 @@ public class FFMpegArgumentProcessor
         return options;
     }
 
-    private ProcessArguments PrepareProcessArguments(FFOptions ffOptions,
+    private ProcessArguments PrepareProcessArguments(FFOptions ffOptions)
-        out CancellationTokenSource cancellationTokenSource)
     {
         FFMpegHelper.RootExceptionCheck();
         FFMpegHelper.VerifyFFMpegExists(ffOptions);
@@ -245,7 +276,6 @@ public class FFMpegArgumentProcessor
             WorkingDirectory = ffOptions.WorkingDirectory
         };
         var processArguments = new ProcessArguments(startInfo);
-        cancellationTokenSource = new CancellationTokenSource();
 
         if (_onOutput != null)
         {

FFMpegCore/FFMpeg/FFMpegArguments.cs

@@ -109,6 +109,11 @@ public sealed class FFMpegArguments : FFMpegArgumentsBase
         return WithInput(new MetaDataArgument(content), addArguments);
     }
 
+    public FFMpegArguments AddMetaData(FFMetadataBuilder metaDataBuilder, Action<FFMpegArgumentOptions>? addArguments = null)
+    {
+        return WithInput(new MetaDataArgument(metaDataBuilder.GetMetadataFileContent()), addArguments);
+    }
+
     public FFMpegArguments AddMetaData(IReadOnlyMetaData metaData, Action<FFMpegArgumentOptions>? addArguments = null)
     {
         return WithInput(new MetaDataArgument(MetaDataSerializer.Instance.Serialize(metaData)), addArguments);

FFMpegCore/FFMpeg/SnapshotArgumentBuilder.cs

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

FFMpegCore/FFMpegCore.csproj

@@ -3,13 +3,15 @@
   <PropertyGroup>
     <IsPackable>true</IsPackable>
     <Description>A .NET Standard FFMpeg/FFProbe wrapper for easily integrating media analysis and conversion into your .NET applications</Description>
-    <PackageVersion>5.3.0</PackageVersion>
+    <PackageVersion>5.4.0</PackageVersion>
     <PackageOutputPath>../nupkg</PackageOutputPath>
     <PackageReleaseNotes>
-      - **Fixed race condition on Named pipe dispose/disconnect** by techtel-pstevens
+      - Fixed exception thrown on cancelling ffprobe analysis - by snechaev
-      - **More extensions for snapshot function(jpg, bmp, webp)** by GorobVictor
+      - Support for cancellationtoken in SnapsnotAsync methods - by snechaev
-      - **Include more GUID characters in pipe path** by reima, rosenbjerg
+      - Added FFMetadataBuilder - by rosenbjerg
-      - **Updated dependencies and minor cleanup**: by rosenbjerg
+      - Fix JoinImageSequence by passing framerate argument to input as well as output - by rosenbjerg
+      - Change fps input from int to double - by rosenbjerg
+      - Fix GetCreationTime method on ITagsContainer - by rosenbjerg
     </PackageReleaseNotes>
     <PackageTags>ffmpeg ffprobe convert video audio mediafile resize analyze muxing</PackageTags>
     <Authors>Malte Rosenbjerg, Vlad Jerca, Max Bagryantsev</Authors>

FFMpegCore/FFProbe/FFProbe.cs

@@ -84,6 +84,7 @@ public static class FFProbe
 
         var instance = PrepareStreamAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current, customArguments);
         var result = await instance.StartAndWaitForExitAsync(cancellationToken).ConfigureAwait(false);
+        cancellationToken.ThrowIfCancellationRequested();
         ThrowIfExitCodeNotZero(result);
 
         return ParseOutput(result);
@@ -123,6 +124,7 @@ public static class FFProbe
     {
         var instance = PrepareStreamAnalysisInstance(uri.AbsoluteUri, ffOptions ?? GlobalFFOptions.Current, customArguments);
         var result = await instance.StartAndWaitForExitAsync(cancellationToken).ConfigureAwait(false);
+        cancellationToken.ThrowIfCancellationRequested();
         ThrowIfExitCodeNotZero(result);
 
         return ParseOutput(result);
@@ -150,6 +152,7 @@ public static class FFProbe
         }
 
         var result = await task.ConfigureAwait(false);
+        cancellationToken.ThrowIfCancellationRequested();
         ThrowIfExitCodeNotZero(result);
 
         pipeArgument.Post();

FFMpegCore/FFProbe/ProcessArgumentsExtensions.cs

@@ -13,6 +13,6 @@ public static class ProcessArgumentsExtensions
     public static async Task<IProcessResult> StartAndWaitForExitAsync(this ProcessArguments processArguments, CancellationToken cancellationToken = default)
     {
         using var instance = processArguments.Start();
-        return await instance.WaitForExitAsync(cancellationToken);
+        return await instance.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
     }
 }