Merge branch 'main' into bugfix/ensure-ffmpeg-not-found-throws-ffmpegexception

2025-01-18 04:26:44 +00:00 · 2024-12-04 20:55:04 +01:00 · 2024-12-04 20:55:04 +01:00 · d43ea98e0e
commit d43ea98e0e
parent 508cce8827 0a3be1e78c
36 changed files with 568 additions and 76 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -22,23 +22,23 @@ jobs:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
-        os: [windows-latest, ubuntu-latest, macos-latest]
+        os: [windows-latest, ubuntu-latest, macos-13]
    timeout-minutes: 7
    steps:

    - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4

    - name: Prepare .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
      with:
-        dotnet-version: '7.0.x'
+        dotnet-version: '8.0.x'

    - name: Lint with dotnet
      run: dotnet format FFMpegCore.sln --severity warn --verify-no-changes

    - name: Prepare FFMpeg
-      uses: FedericoCarboni/setup-ffmpeg@v2
+      uses: FedericoCarboni/setup-ffmpeg@v3
      with:
        token: ${{ secrets.GITHUB_TOKEN }}

@ -47,7 +47,8 @@ jobs:

    - if: matrix.os == 'windows-latest'
      name: Upload coverage reports to Codecov
-      uses: codecov/codecov-action@v3
+      uses: codecov/codecov-action@v5
      with:
+        fail_ci_if_error: true
        directory: FFMpegCore.Test/TestResults
-        fail_ci_if_error: true
+        token: ${{ secrets.CODECOV_TOKEN }}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -8,12 +8,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
      
    - name: Prepare .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
      with:
-        dotnet-version: '7.0.x'
+        dotnet-version: '8.0.x'
        
    - name: Build solution
      run: dotnet pack FFMpegCore.sln -c Release
--- a/FFMpegCore.Examples/FFMpegCore.Examples.csproj
+++ b/FFMpegCore.Examples/FFMpegCore.Examples.csproj
@ -2,7 +2,7 @@

  <PropertyGroup>
    <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
    <IsPackable>false</IsPackable>
  </PropertyGroup>

--- a/FFMpegCore.Extensions.SkiaSharp/FFMpegCore.Extensions.SkiaSharp.csproj
+++ b/FFMpegCore.Extensions.SkiaSharp/FFMpegCore.Extensions.SkiaSharp.csproj
@ -9,11 +9,12 @@
        </PackageReleaseNotes>
        <PackageTags>ffmpeg ffprobe convert video audio mediafile resize analyze muxing skiasharp</PackageTags>
        <Authors>Malte Rosenbjerg, Vlad Jerca, Max Bagryantsev, Dimitri Vranken</Authors>
+        <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
    </PropertyGroup>

    <ItemGroup>
-      <PackageReference Include="SkiaSharp" Version="2.88.3" />
-      <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.3" />
+      <PackageReference Include="SkiaSharp" Version="2.88.6" />
+      <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.6" />
    </ItemGroup>

    <ItemGroup>
--- a/FFMpegCore.Extensions.System.Drawing.Common/FFMpegCore.Extensions.System.Drawing.Common.csproj
+++ b/FFMpegCore.Extensions.System.Drawing.Common/FFMpegCore.Extensions.System.Drawing.Common.csproj
@ -9,6 +9,7 @@
    </PackageReleaseNotes>
    <PackageTags>ffmpeg ffprobe convert video audio mediafile resize analyze muxing</PackageTags>
    <Authors>Malte Rosenbjerg, Vlad Jerca, Max Bagryantsev</Authors>
+    <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
  </PropertyGroup>

  <ItemGroup>
--- a/FFMpegCore.Test/ArgumentBuilderTest.cs
+++ b/FFMpegCore.Test/ArgumentBuilderTest.cs
@ -1,4 +1,5 @@
-using FFMpegCore.Arguments;
+using System.Drawing;
+using FFMpegCore.Arguments;
 using FFMpegCore.Enums;
 using Microsoft.VisualStudio.TestTools.UnitTesting;

@ -537,5 +538,78 @@ public void Builder_BuildString_PadFilter_Alt()
                "-i \"input.mp4\" -vf \"pad=aspect=4/3:x=(ow-iw)/2:y=(oh-ih)/2:color=violet:eval=frame\" \"output.mp4\"",
                str);
        }
+
+        [TestMethod]
+        public void Builder_BuildString_GifPalette()
+        {
+            var streamIndex = 0;
+            var size = new Size(640, 480);
+
+            var str = FFMpegArguments
+                .FromFileInput("input.mp4")
+                .OutputToFile("output.gif", false, opt => opt
+                    .WithGifPaletteArgument(streamIndex, size))
+                .Arguments;
+
+            Assert.AreEqual($"""
+                -i "input.mp4" -filter_complex "[0:v] fps=12,scale=w={size.Width}:h={size.Height},split [a][b];[a] palettegen=max_colors=32 [p];[b][p] paletteuse=dither=bayer" "output.gif"
+                """, str);
+        }
+
+        [TestMethod]
+        public void Builder_BuildString_GifPalette_NullSize_FpsSupplied()
+        {
+            var streamIndex = 1;
+
+            var str = FFMpegArguments
+                .FromFileInput("input.mp4")
+                .OutputToFile("output.gif", false, opt => opt
+                    .WithGifPaletteArgument(streamIndex, null, 10))
+                .Arguments;
+
+            Assert.AreEqual($"""
+                -i "input.mp4" -filter_complex "[{streamIndex}:v] fps=10,split [a][b];[a] palettegen=max_colors=32 [p];[b][p] paletteuse=dither=bayer" "output.gif"
+                """, str);
+        }
+
+        [TestMethod]
+        public void Builder_BuildString_MultiOutput()
+        {
+            var str = FFMpegArguments.FromFileInput("input.mp4")
+                .MultiOutput(args => args
+                    .OutputToFile("output.mp4", overwrite: true, args => args.CopyChannel())
+                    .OutputToFile("output.ts", overwrite: false, args => args.CopyChannel().ForceFormat("mpegts"))
+                    .OutputToUrl("http://server/path", options => options.ForceFormat("webm")))
+                    .Arguments;
+            Assert.AreEqual($"""
+                -i "input.mp4" -c:a copy -c:v copy "output.mp4" -y -c:a copy -c:v copy -f mpegts "output.ts" -f webm http://server/path
+                """, str);
+        }
+
+        [TestMethod]
+        public void Builder_BuildString_MBROutput()
+        {
+            var str = FFMpegArguments.FromFileInput("input.mp4")
+                .MultiOutput(args => args
+                    .OutputToFile("sd.mp4", overwrite: true, args => args.Resize(1200, 720))
+                    .OutputToFile("hd.mp4", overwrite: false, args => args.Resize(1920, 1080)))
+                    .Arguments;
+            Assert.AreEqual($"""
+                -i "input.mp4" -s 1200x720 "sd.mp4" -y -s 1920x1080 "hd.mp4"
+                """, str);
+        }
+
+        [TestMethod]
+        public void Builder_BuildString_TeeOutput()
+        {
+            var str = FFMpegArguments.FromFileInput("input.mp4")
+                .OutputToTee(args => args
+                    .OutputToFile("output.mp4", overwrite: false, args => args.WithFastStart())
+                    .OutputToUrl("http://server/path", options => options.ForceFormat("mpegts").SelectStream(0, channel: Channel.Video)))
+                    .Arguments;
+            Assert.AreEqual($"""
+                -i "input.mp4" -f tee "[movflags=faststart]output.mp4|[f=mpegts:select=\'0:v:0\']http://server/path"
+                """, str);
+        }
    }
 }
--- a/FFMpegCore.Test/FFMpegCore.Test.csproj
+++ b/FFMpegCore.Test/FFMpegCore.Test.csproj
@ -1,26 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
    <IsPackable>false</IsPackable>
    <Nullable>disable</Nullable>
    <LangVersion>default</LangVersion>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="3.2.0">
+    <PackageReference Include="coverlet.collector" Version="6.0.2">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
-    <PackageReference Include="FluentAssertions" Version="6.10.0" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.1">
+    <PackageReference Include="FluentAssertions" Version="7.0.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.4.1">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.0.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.0.2" />
-    <PackageReference Include="SkiaSharp" Version="2.88.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.6.4" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.6.4" />
+    <PackageReference Include="SkiaSharp" Version="2.88.6" />
  </ItemGroup>

  <ItemGroup>
@ -51,9 +51,15 @@
    <None Update="Resources\input_3sec_rotation_90deg.mp4">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
+    <None Update="Resources\input_3sec_rotation_negative_90deg.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
    <None Update="Resources\input_audio_only_10sec.mp4">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
+    <None Update="Resources\input_hdr.mov">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
    <None Update="Resources\input_video_only_3sec.mp4">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
--- a/FFMpegCore.Test/FFProbeTests.cs
+++ b/FFMpegCore.Test/FFProbeTests.cs
@ -46,7 +46,7 @@ public async Task PacketAnalysis_Async()
            var packets = packetAnalysis.Packets;
            Assert.AreEqual(96, packets.Count);
            Assert.IsTrue(packets.All(f => f.CodecType == "video"));
-            Assert.AreEqual("K_", packets[0].Flags);
+            Assert.IsTrue(packets[0].Flags.StartsWith("K_"));
            Assert.AreEqual(1362, packets.Last().Size);
        }

@ -57,7 +57,7 @@ public void PacketAnalysis_Sync()

            Assert.AreEqual(96, packets.Count);
            Assert.IsTrue(packets.All(f => f.CodecType == "video"));
-            Assert.AreEqual("K_", packets[0].Flags);
+            Assert.IsTrue(packets[0].Flags.StartsWith("K_"));
            Assert.AreEqual(1362, packets.Last().Size);
        }

@ -70,7 +70,7 @@ public void PacketAnalysisAudioVideo_Sync()
            var actual = packets.Select(f => f.CodecType).Distinct().ToList();
            var expected = new List<string> { "audio", "video" };
            CollectionAssert.AreEquivalent(expected, actual);
-            Assert.IsTrue(packets.Where(t => t.CodecType == "audio").All(f => f.Flags == "K_"));
+            Assert.IsTrue(packets.Where(t => t.CodecType == "audio").All(f => f.Flags.StartsWith("K_")));
            Assert.AreEqual(75, packets.Count(t => t.CodecType == "video"));
            Assert.AreEqual(141, packets.Count(t => t.CodecType == "audio"));
        }
@ -105,6 +105,7 @@ public void Probe_Success()
        {
            var info = FFProbe.Analyse(TestResources.Mp4Video);
            Assert.AreEqual(3, info.Duration.Seconds);
+            Assert.AreEqual(0, info.Chapters.Count);

            Assert.AreEqual("5.1", info.PrimaryAudioStream!.ChannelLayout);
            Assert.AreEqual(6, info.PrimaryAudioStream.Channels);
@ -122,6 +123,7 @@ public void Probe_Success()
            Assert.AreEqual(1, info.PrimaryVideoStream.SampleAspectRatio.Width);
            Assert.AreEqual(1, info.PrimaryVideoStream.SampleAspectRatio.Height);
            Assert.AreEqual("yuv420p", info.PrimaryVideoStream.PixelFormat);
+            Assert.AreEqual(31, info.PrimaryVideoStream.Level);
            Assert.AreEqual(1280, info.PrimaryVideoStream.Width);
            Assert.AreEqual(720, info.PrimaryVideoStream.Height);
            Assert.AreEqual(25, info.PrimaryVideoStream.AvgFrameRate);
@ -144,6 +146,13 @@ public void Probe_Rotation()
            Assert.AreEqual(90, info.PrimaryVideoStream.Rotation);
        }

+        [TestMethod]
+        public void Probe_Rotation_Negative_Value()
+        {
+            var info = FFProbe.Analyse(TestResources.Mp4VideoRotationNegative);
+            Assert.AreEqual(-90, info.PrimaryVideoStream.Rotation);
+        }
+
        [TestMethod, Timeout(10000)]
        public async Task Probe_Async_Success()
        {
@ -172,6 +181,18 @@ public async Task Probe_Success_FromStream_Async()
            Assert.AreEqual(3, info.Duration.Seconds);
        }

+        [TestMethod, Timeout(10000)]
+        public void Probe_HDR()
+        {
+            var info = FFProbe.Analyse(TestResources.HdrVideo);
+
+            Assert.IsNotNull(info.PrimaryVideoStream);
+            Assert.AreEqual("tv", info.PrimaryVideoStream.ColorRange);
+            Assert.AreEqual("bt2020nc", info.PrimaryVideoStream.ColorSpace);
+            Assert.AreEqual("arib-std-b67", info.PrimaryVideoStream.ColorTransfer);
+            Assert.AreEqual("bt2020", info.PrimaryVideoStream.ColorPrimaries);
+        }
+
        [TestMethod, Timeout(10000)]
        public async Task Probe_Success_Subtitle_Async()
        {
@ -235,5 +256,12 @@ public async Task Probe_Success_32BitWavBitDepth_Async()
            Assert.IsNotNull(info.PrimaryAudioStream);
            Assert.AreEqual(32, info.PrimaryAudioStream.BitDepth);
        }
+
+        [TestMethod]
+        public void Probe_Success_Custom_Arguments()
+        {
+            var info = FFProbe.Analyse(TestResources.Mp4Video, customArguments: "-headers \"Hello: World\"");
+            Assert.AreEqual(3, info.Duration.Seconds);
+        }
    }
 }
--- a/FFMpegCore.Test/Resources/TestResources.cs
+++ b/FFMpegCore.Test/Resources/TestResources.cs
@ -4,7 +4,9 @@ public static class TestResources
    {
        public static readonly string Mp4Video = "./Resources/input_3sec.mp4";
        public static readonly string Mp4VideoRotation = "./Resources/input_3sec_rotation_90deg.mp4";
+        public static readonly string Mp4VideoRotationNegative = "./Resources/input_3sec_rotation_negative_90deg.mp4";
        public static readonly string WebmVideo = "./Resources/input_3sec.webm";
+        public static readonly string HdrVideo = "./Resources/input_hdr.mov";
        public static readonly string Mp4WithoutVideo = "./Resources/input_audio_only_10sec.mp4";
        public static readonly string Mp4WithoutAudio = "./Resources/input_video_only_3sec.mp4";
        public static readonly string RawAudio = "./Resources/audio.raw";
--- a/FFMpegCore.Test/Resources/input_3sec_rotation_negative_90deg.mp4
+++ b/FFMpegCore.Test/Resources/input_3sec_rotation_negative_90deg.mp4
--- a/FFMpegCore.Test/Resources/input_hdr.mov
+++ b/FFMpegCore.Test/Resources/input_hdr.mov
--- a/FFMpegCore.Test/VideoTest.cs
+++ b/FFMpegCore.Test/VideoTest.cs
@ -1,4 +1,5 @@
-using System.Drawing.Imaging;
+using System.Drawing;
+using System.Drawing.Imaging;
 using System.Runtime.Versioning;
 using System.Text;
 using FFMpegCore.Arguments;
@ -479,6 +480,79 @@ public void Video_Snapshot_PersistSnapshot()
            Assert.AreEqual("png", analysis.PrimaryVideoStream!.CodecName);
        }

+        [TestMethod, Timeout(BaseTimeoutMilliseconds)]
+        public void Video_Snapshot_Rotated_PersistSnapshot()
+        {
+            using var outputPath = new TemporaryFile("out.png");
+
+            var size = new Size(360, 0); // half the size of original video, keeping height 0 for keeping aspect ratio
+            FFMpeg.Snapshot(TestResources.Mp4VideoRotationNegative, outputPath, size);
+
+            var analysis = FFProbe.Analyse(outputPath);
+            Assert.AreEqual(size.Width, analysis.PrimaryVideoStream!.Width);
+            Assert.AreEqual(1280 / 2, analysis.PrimaryVideoStream!.Height);
+            Assert.AreEqual(0, analysis.PrimaryVideoStream!.Rotation);
+            Assert.AreEqual("png", analysis.PrimaryVideoStream!.CodecName);
+        }
+
+        [TestMethod, Timeout(BaseTimeoutMilliseconds)]
+        public void Video_GifSnapshot_PersistSnapshot()
+        {
+            using var outputPath = new TemporaryFile("out.gif");
+            var input = FFProbe.Analyse(TestResources.Mp4Video);
+
+            FFMpeg.GifSnapshot(TestResources.Mp4Video, outputPath, captureTime: TimeSpan.FromSeconds(0));
+
+            var analysis = FFProbe.Analyse(outputPath);
+            Assert.AreNotEqual(input.PrimaryVideoStream!.Width, analysis.PrimaryVideoStream!.Width);
+            Assert.AreNotEqual(input.PrimaryVideoStream.Height, analysis.PrimaryVideoStream!.Height);
+            Assert.AreEqual("gif", analysis.PrimaryVideoStream!.CodecName);
+        }
+
+        [TestMethod, Timeout(BaseTimeoutMilliseconds)]
+        public void Video_GifSnapshot_PersistSnapshot_SizeSupplied()
+        {
+            using var outputPath = new TemporaryFile("out.gif");
+            var input = FFProbe.Analyse(TestResources.Mp4Video);
+            var desiredGifSize = new Size(320, 240);
+
+            FFMpeg.GifSnapshot(TestResources.Mp4Video, outputPath, desiredGifSize, captureTime: TimeSpan.FromSeconds(0));
+
+            var analysis = FFProbe.Analyse(outputPath);
+            Assert.AreNotEqual(input.PrimaryVideoStream!.Width, desiredGifSize.Width);
+            Assert.AreNotEqual(input.PrimaryVideoStream.Height, desiredGifSize.Height);
+            Assert.AreEqual("gif", analysis.PrimaryVideoStream!.CodecName);
+        }
+
+        [TestMethod, Timeout(BaseTimeoutMilliseconds)]
+        public async Task Video_GifSnapshot_PersistSnapshotAsync()
+        {
+            using var outputPath = new TemporaryFile("out.gif");
+            var input = FFProbe.Analyse(TestResources.Mp4Video);
+
+            await FFMpeg.GifSnapshotAsync(TestResources.Mp4Video, outputPath, captureTime: TimeSpan.FromSeconds(0));
+
+            var analysis = FFProbe.Analyse(outputPath);
+            Assert.AreNotEqual(input.PrimaryVideoStream!.Width, analysis.PrimaryVideoStream!.Width);
+            Assert.AreNotEqual(input.PrimaryVideoStream.Height, analysis.PrimaryVideoStream!.Height);
+            Assert.AreEqual("gif", analysis.PrimaryVideoStream!.CodecName);
+        }
+
+        [TestMethod, Timeout(BaseTimeoutMilliseconds)]
+        public async Task Video_GifSnapshot_PersistSnapshotAsync_SizeSupplied()
+        {
+            using var outputPath = new TemporaryFile("out.gif");
+            var input = FFProbe.Analyse(TestResources.Mp4Video);
+            var desiredGifSize = new Size(320, 240);
+
+            await FFMpeg.GifSnapshotAsync(TestResources.Mp4Video, outputPath, desiredGifSize, captureTime: TimeSpan.FromSeconds(0));
+
+            var analysis = FFProbe.Analyse(outputPath);
+            Assert.AreNotEqual(input.PrimaryVideoStream!.Width, desiredGifSize.Width);
+            Assert.AreNotEqual(input.PrimaryVideoStream.Height, desiredGifSize.Height);
+            Assert.AreEqual("gif", analysis.PrimaryVideoStream!.CodecName);
+        }
+
        [TestMethod, Timeout(BaseTimeoutMilliseconds)]
        public void Video_Join()
        {
--- a/FFMpegCore/FFMpeg/Arguments/CopyCodecArgument.cs
+++ b/FFMpegCore/FFMpeg/Arguments/CopyCodecArgument.cs
@ -0,0 +1,10 @@
+namespace FFMpegCore.Arguments
+{
+    /// <summary>
+    /// Represents a copy codec parameter
+    /// </summary>
+    public class CopyCodecArgument : IArgument
+    {
+        public string Text => $"-codec copy";
+    }
+}
--- a/FFMpegCore/FFMpeg/Arguments/GifPaletteArgument.cs
+++ b/FFMpegCore/FFMpeg/Arguments/GifPaletteArgument.cs
@ -0,0 +1,24 @@
+using System.Drawing;
+
+namespace FFMpegCore.Arguments
+{
+    public class GifPaletteArgument : IArgument
+    {
+        private readonly int _streamIndex;
+
+        private readonly int _fps;
+
+        private readonly Size? _size;
+
+        public GifPaletteArgument(int streamIndex, int fps, Size? size)
+        {
+            _streamIndex = streamIndex;
+            _fps = fps;
+            _size = size;
+        }
+
+        private string ScaleText => _size.HasValue ? $"scale=w={_size.Value.Width}:h={_size.Value.Height}," : string.Empty;
+
+        public string Text => $"-filter_complex \"[{_streamIndex}:v] fps={_fps},{ScaleText}split [a][b];[a] palettegen=max_colors=32 [p];[b][p] paletteuse=dither=bayer\"";
+    }
+}
--- a/FFMpegCore/FFMpeg/Arguments/OutputTeeArgument.cs
+++ b/FFMpegCore/FFMpeg/Arguments/OutputTeeArgument.cs
@ -0,0 +1,57 @@
+
+namespace FFMpegCore.Arguments
+{
+    internal class OutputTeeArgument : IOutputArgument
+    {
+        private readonly FFMpegMultiOutputOptions _options;
+
+        public OutputTeeArgument(FFMpegMultiOutputOptions options)
+        {
+            if (options.Outputs.Count == 0)
+            {
+                throw new ArgumentException("Atleast one output must be specified.", nameof(options));
+            }
+
+            _options = options;
+        }
+
+        public string Text => $"-f tee \"{string.Join("|", _options.Outputs.Select(MapOptions))}\"";
+
+        public Task During(CancellationToken cancellationToken = default) => Task.CompletedTask;
+
+        public void Post()
+        {
+        }
+
+        public void Pre()
+        {
+        }
+
+        private static string MapOptions(FFMpegArgumentOptions option)
+        {
+            var optionPrefix = string.Empty;
+            if (option.Arguments.Count > 1)
+            {
+                var options = option.Arguments.Take(option.Arguments.Count - 1);
+                optionPrefix = $"[{string.Join(":", options.Select(MapArgument))}]";
+            }
+
+            var output = option.Arguments.OfType<IOutputArgument>().Single();
+            return $"{optionPrefix}{output.Text.Trim('"')}";
+        }
+
+        private static string MapArgument(IArgument argument)
+        {
+            if (argument is MapStreamArgument map)
+            {
+                return map.Text.Replace("-map ", "select=\\'") + "\\'";
+            }
+            else if (argument is BitStreamFilterArgument bitstreamFilter)
+            {
+                return bitstreamFilter.Text.Replace("-bsf:", "bsfs/").Replace(' ', '=');
+            }
+
+            return argument.Text.TrimStart('-').Replace(' ', '=');
+        }
+    }
+}
--- a/FFMpegCore/FFMpeg/Builders/MetaData/ChapterData.cs
+++ b/FFMpegCore/FFMpeg/Builders/MetaData/ChapterData.cs
@ -6,6 +6,8 @@ public class ChapterData
        public TimeSpan Start { get; private set; }
        public TimeSpan End { get; private set; }

+        public TimeSpan Duration => End - Start;
+
        public ChapterData(string title, TimeSpan start, TimeSpan end)
        {
            Title = title;
--- a/FFMpegCore/FFMpeg/Enums/Enums.cs
+++ b/FFMpegCore/FFMpeg/Enums/Enums.cs
@ -17,6 +17,7 @@ public static class VideoCodec
        public static Codec LibTheora => FFMpeg.GetCodec("libtheora");
        public static Codec Png => FFMpeg.GetCodec("png");
        public static Codec MpegTs => FFMpeg.GetCodec("mpegts");
+        public static Codec LibaomAv1 => FFMpeg.GetCodec("libaom-av1");
    }

    public static class AudioCodec
--- a/FFMpegCore/FFMpeg/Enums/FileExtension.cs
+++ b/FFMpegCore/FFMpeg/Enums/FileExtension.cs
@ -20,5 +20,6 @@ public static string Extension(this Codec type)
        public static readonly string WebM = VideoType.WebM.Extension;
        public static readonly string Png = ".png";
        public static readonly string Mp3 = ".mp3";
+        public static readonly string Gif = ".gif";
    }
 }
--- a/FFMpegCore/FFMpeg/FFMpeg.cs
+++ b/FFMpegCore/FFMpeg/FFMpeg.cs
@ -57,6 +57,36 @@ public static async Task<bool> SnapshotAsync(string input, string output, Size?
                .ProcessAsynchronously();
        }

+        public static bool GifSnapshot(string input, string output, Size? size = null, TimeSpan? captureTime = null, TimeSpan? duration = null, int? streamIndex = null)
+        {
+            if (Path.GetExtension(output)?.ToLower() != FileExtension.Gif)
+            {
+                output = Path.Combine(Path.GetDirectoryName(output), Path.GetFileNameWithoutExtension(output) + FileExtension.Gif);
+            }
+
+            var source = FFProbe.Analyse(input);
+            var (arguments, outputOptions) = SnapshotArgumentBuilder.BuildGifSnapshotArguments(input, source, size, captureTime, duration, streamIndex);
+
+            return arguments
+                .OutputToFile(output, true, outputOptions)
+                .ProcessSynchronously();
+        }
+
+        public static async Task<bool> GifSnapshotAsync(string input, string output, Size? size = null, TimeSpan? captureTime = null, TimeSpan? duration = null, int? streamIndex = null)
+        {
+            if (Path.GetExtension(output)?.ToLower() != FileExtension.Gif)
+            {
+                output = Path.Combine(Path.GetDirectoryName(output), Path.GetFileNameWithoutExtension(output) + FileExtension.Gif);
+            }
+
+            var source = await FFProbe.AnalyseAsync(input).ConfigureAwait(false);
+            var (arguments, outputOptions) = SnapshotArgumentBuilder.BuildGifSnapshotArguments(input, source, size, captureTime, duration, streamIndex);
+
+            return await arguments
+                .OutputToFile(output, true, outputOptions)
+                .ProcessAsynchronously();
+        }
+
        /// <summary>
        /// Converts an image sequence to a video.
        /// </summary>
@ -303,7 +333,10 @@ public static bool SaveM3U8Stream(Uri uri, string output)
            }

            return FFMpegArguments
-                .FromUrlInput(uri)
+                .FromUrlInput(uri, options =>
+                {
+                    options.WithCopyCodec();
+                })
                .OutputToFile(output)
                .ProcessSynchronously();
        }
--- a/FFMpegCore/FFMpeg/FFMpegArgumentOptions.cs
+++ b/FFMpegCore/FFMpeg/FFMpegArgumentOptions.cs
@ -76,6 +76,8 @@ public FFMpegArgumentOptions DeselectStreams(IEnumerable<int> streamIndices, int
        public FFMpegArgumentOptions WithAudibleEncryptionKeys(string key, string iv) => WithArgument(new AudibleEncryptionKeyArgument(key, iv));
        public FFMpegArgumentOptions WithAudibleActivationBytes(string activationBytes) => WithArgument(new AudibleEncryptionKeyArgument(activationBytes));
        public FFMpegArgumentOptions WithTagVersion(int id3v2Version = 3) => WithArgument(new ID3V2VersionArgument(id3v2Version));
+        public FFMpegArgumentOptions WithGifPaletteArgument(int streamIndex, Size? size, int fps = 12) => WithArgument(new GifPaletteArgument(streamIndex, fps, size));
+        public FFMpegArgumentOptions WithCopyCodec() => WithArgument(new CopyCodecArgument());

        public FFMpegArgumentOptions WithArgument(IArgument argument)
        {
--- a/FFMpegCore/FFMpeg/FFMpegArgumentProcessor.cs
+++ b/FFMpegCore/FFMpeg/FFMpegArgumentProcessor.cs
@ -1,5 +1,4 @@
 using System.Diagnostics;
-using System.Globalization;
 using System.Text.RegularExpressions;
 using FFMpegCore.Enums;
 using FFMpegCore.Exceptions;
@ -263,7 +262,7 @@ private void ErrorData(object sender, string msg)
                return;
            }

-            var processed = TimeSpan.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
+            var processed = MediaAnalysisUtils.ParseDuration(match.Groups[1].Value);
            _onTimeProgress?.Invoke(processed);

            if (_onPercentageProgress == null || _totalTimespan == null)
--- a/FFMpegCore/FFMpeg/FFMpegArguments.cs
+++ b/FFMpegCore/FFMpeg/FFMpegArguments.cs
@ -71,6 +71,21 @@ private FFMpegArgumentProcessor ToProcessor(IOutputArgument argument, Action<FFM
            return new FFMpegArgumentProcessor(this);
        }

+        public FFMpegArgumentProcessor OutputToTee(Action<FFMpegMultiOutputOptions> addOutputs, Action<FFMpegArgumentOptions>? addArguments = null)
+        {
+            var outputs = new FFMpegMultiOutputOptions();
+            addOutputs(outputs);
+            return ToProcessor(new OutputTeeArgument(outputs), addArguments);
+        }
+
+        public FFMpegArgumentProcessor MultiOutput(Action<FFMpegMultiOutputOptions> addOutputs)
+        {
+            var args = new FFMpegMultiOutputOptions();
+            addOutputs(args);
+            Arguments.AddRange(args.Arguments);
+            return new FFMpegArgumentProcessor(this);
+        }
+
        internal void Pre()
        {
            foreach (var argument in Arguments.OfType<IInputOutputArgument>())
--- a/FFMpegCore/FFMpeg/FFMpegMultiOutputOptions.cs
+++ b/FFMpegCore/FFMpeg/FFMpegMultiOutputOptions.cs
@ -0,0 +1,29 @@
+using FFMpegCore.Arguments;
+using FFMpegCore.Pipes;
+
+namespace FFMpegCore
+{
+    public class FFMpegMultiOutputOptions
+    {
+        internal readonly List<FFMpegArgumentOptions> Outputs = new();
+
+        public IEnumerable<IArgument> Arguments => Outputs.SelectMany(o => o.Arguments);
+
+        public FFMpegMultiOutputOptions OutputToFile(string file, bool overwrite = true, Action<FFMpegArgumentOptions>? addArguments = null) => AddOutput(new OutputArgument(file, overwrite), addArguments);
+
+        public FFMpegMultiOutputOptions OutputToUrl(string uri, Action<FFMpegArgumentOptions>? addArguments = null) => AddOutput(new OutputUrlArgument(uri), addArguments);
+
+        public FFMpegMultiOutputOptions OutputToUrl(Uri uri, Action<FFMpegArgumentOptions>? addArguments = null) => AddOutput(new OutputUrlArgument(uri.ToString()), addArguments);
+
+        public FFMpegMultiOutputOptions OutputToPipe(IPipeSink reader, Action<FFMpegArgumentOptions>? addArguments = null) => AddOutput(new OutputPipeArgument(reader), addArguments);
+
+        public FFMpegMultiOutputOptions AddOutput(IOutputArgument argument, Action<FFMpegArgumentOptions>? addArguments)
+        {
+            var args = new FFMpegArgumentOptions();
+            addArguments?.Invoke(args);
+            args.Arguments.Add(argument);
+            Outputs.Add(args);
+            return this;
+        }
+    }
+}
--- a/FFMpegCore/FFMpeg/Pipes/RawAudioPipeSource.cs
+++ b/FFMpegCore/FFMpeg/Pipes/RawAudioPipeSource.cs
@ -27,7 +27,7 @@ public string GetStreamArguments()

        public async Task WriteAsync(Stream outputStream, CancellationToken cancellationToken)
        {
-            if (_sampleEnumerator.Current != null)
+            if (_sampleEnumerator.MoveNext() && _sampleEnumerator.Current != null)
            {
                await _sampleEnumerator.Current.SerializeAsync(outputStream, cancellationToken).ConfigureAwait(false);
            }
--- a/FFMpegCore/FFMpeg/SnapshotArgumentBuilder.cs
+++ b/FFMpegCore/FFMpeg/SnapshotArgumentBuilder.cs
@ -31,6 +31,31 @@ public static (FFMpegArguments, Action<FFMpegArgumentOptions> outputOptions) Bui
                .Resize(size));
    }

+    public static (FFMpegArguments, Action<FFMpegArgumentOptions> outputOptions) BuildGifSnapshotArguments(
+        string input,
+        IMediaAnalysis source,
+        Size? size = null,
+        TimeSpan? captureTime = null,
+        TimeSpan? duration = null,
+        int? streamIndex = null,
+        int fps = 12)
+    {
+        var defaultGifOutputSize = new Size(480, -1);
+
+        captureTime ??= TimeSpan.FromSeconds(source.Duration.TotalSeconds / 3);
+        size = PrepareSnapshotSize(source, size) ?? defaultGifOutputSize;
+        streamIndex ??= source.PrimaryVideoStream?.Index
+                        ?? source.VideoStreams.FirstOrDefault()?.Index
+                        ?? 0;
+
+        return (FFMpegArguments
+                .FromFileInput(input, false, options => options
+                    .Seek(captureTime)
+                    .WithDuration(duration)),
+            options => options
+                .WithGifPaletteArgument((int)streamIndex, size, fps));
+    }
+
    private static Size? PrepareSnapshotSize(IMediaAnalysis source, Size? wantedSize)
    {
        if (wantedSize == null || (wantedSize.Value.Height <= 0 && wantedSize.Value.Width <= 0) || source.PrimaryVideoStream == null)
@ -39,7 +64,7 @@ public static (FFMpegArguments, Action<FFMpegArgumentOptions> outputOptions) Bui
        }

        var currentSize = new Size(source.PrimaryVideoStream.Width, source.PrimaryVideoStream.Height);
-        if (source.PrimaryVideoStream.Rotation == 90 || source.PrimaryVideoStream.Rotation == 180)
+        if (IsRotated(source.PrimaryVideoStream.Rotation))
        {
            currentSize = new Size(source.PrimaryVideoStream.Height, source.PrimaryVideoStream.Width);
        }
@ -63,4 +88,10 @@ public static (FFMpegArguments, Action<FFMpegArgumentOptions> outputOptions) Bui

        return null;
    }
+
+    private static bool IsRotated(int rotation)
+    {
+        var absRotation = Math.Abs(rotation);
+        return absRotation == 90 || absRotation == 180;
+    }
 }
--- a/FFMpegCore/FFMpegCore.csproj
+++ b/FFMpegCore/FFMpegCore.csproj
@ -3,7 +3,7 @@
  <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.0.2</PackageVersion>
+    <PackageVersion>5.1.0</PackageVersion>
    <PackageOutputPath>../nupkg</PackageOutputPath>
    <PackageReleaseNotes>
    </PackageReleaseNotes>
@ -18,7 +18,7 @@

  <ItemGroup>
    <PackageReference Include="Instances" Version="3.0.0" />
-    <PackageReference Include="System.Text.Json" Version="7.0.2" />
+    <PackageReference Include="System.Text.Json" Version="9.0.0" />
  </ItemGroup>

 </Project>
--- a/FFMpegCore/FFOptions.cs
+++ b/FFMpegCore/FFOptions.cs
@ -1,4 +1,5 @@
 using System.Text;
+using System.Text.Json.Serialization;
 using FFMpegCore.Enums;

 namespace FFMpegCore
@ -20,10 +21,20 @@ public class FFOptions : ICloneable
        /// </summary>
        public string TemporaryFilesFolder { get; set; } = Path.GetTempPath();

+        /// <summary>
+        /// Encoding web name used to persist encoding <see cref="Encoding"/>
+        /// </summary>
+        public string EncodingWebName { get; set; } = Encoding.Default.WebName;
+
        /// <summary>
        /// Encoding used for parsing stdout/stderr on ffmpeg and ffprobe processes
        /// </summary>
-        public Encoding Encoding { get; set; } = Encoding.Default;
+        [JsonIgnore]
+        public Encoding Encoding
+        {
+            get => Encoding.GetEncoding(EncodingWebName);
+            set => EncodingWebName = value?.WebName ?? Encoding.Default.WebName;
+        }

        /// <summary>
        /// The log level to use when calling of the ffmpeg executable.
--- a/FFMpegCore/FFProbe/FFProbe.cs
+++ b/FFMpegCore/FFProbe/FFProbe.cs
@ -10,52 +10,52 @@ namespace FFMpegCore
 {
    public static class FFProbe
    {
-        public static IMediaAnalysis Analyse(string filePath, FFOptions? ffOptions = null)
+        public static IMediaAnalysis Analyse(string filePath, FFOptions? ffOptions = null, string? customArguments = null)
        {
            ThrowIfInputFileDoesNotExist(filePath);

-            var processArguments = PrepareStreamAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current);
+            var processArguments = PrepareStreamAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = processArguments.StartAndWaitForExit();
            ThrowIfExitCodeNotZero(result);

            return ParseOutput(result);
        }

-        public static FFProbeFrames GetFrames(string filePath, FFOptions? ffOptions = null)
+        public static FFProbeFrames GetFrames(string filePath, FFOptions? ffOptions = null, string? customArguments = null)
        {
            ThrowIfInputFileDoesNotExist(filePath);

-            var instance = PrepareFrameAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PrepareFrameAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = instance.StartAndWaitForExit();
            ThrowIfExitCodeNotZero(result);

            return ParseFramesOutput(result);
        }

-        public static FFProbePackets GetPackets(string filePath, FFOptions? ffOptions = null)
+        public static FFProbePackets GetPackets(string filePath, FFOptions? ffOptions = null, string? customArguments = null)
        {
            ThrowIfInputFileDoesNotExist(filePath);

-            var instance = PreparePacketAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PreparePacketAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = instance.StartAndWaitForExit();
            ThrowIfExitCodeNotZero(result);

            return ParsePacketsOutput(result);
        }

-        public static IMediaAnalysis Analyse(Uri uri, FFOptions? ffOptions = null)
+        public static IMediaAnalysis Analyse(Uri uri, FFOptions? ffOptions = null, string? customArguments = null)
        {
-            var instance = PrepareStreamAnalysisInstance(uri.AbsoluteUri, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PrepareStreamAnalysisInstance(uri.AbsoluteUri, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = instance.StartAndWaitForExit();
            ThrowIfExitCodeNotZero(result);

            return ParseOutput(result);
        }
-        public static IMediaAnalysis Analyse(Stream stream, FFOptions? ffOptions = null)
+        public static IMediaAnalysis Analyse(Stream stream, FFOptions? ffOptions = null, string? customArguments = null)
        {
            var streamPipeSource = new StreamPipeSource(stream);
            var pipeArgument = new InputPipeArgument(streamPipeSource);
-            var instance = PrepareStreamAnalysisInstance(pipeArgument.PipePath, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PrepareStreamAnalysisInstance(pipeArgument.PipePath, ffOptions ?? GlobalFFOptions.Current, customArguments);
            pipeArgument.Pre();

            var task = instance.StartAndWaitForExitAsync();
@ -75,57 +75,57 @@ public static IMediaAnalysis Analyse(Stream stream, FFOptions? ffOptions = null)
            return ParseOutput(result);
        }

-        public static async Task<IMediaAnalysis> AnalyseAsync(string filePath, FFOptions? ffOptions = null, CancellationToken cancellationToken = default)
+        public static async Task<IMediaAnalysis> AnalyseAsync(string filePath, FFOptions? ffOptions = null, CancellationToken cancellationToken = default, string? customArguments = null)
        {
            ThrowIfInputFileDoesNotExist(filePath);

-            var instance = PrepareStreamAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PrepareStreamAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = await instance.StartAndWaitForExitAsync(cancellationToken).ConfigureAwait(false);
            ThrowIfExitCodeNotZero(result);

            return ParseOutput(result);
        }

-        public static FFProbeFrames GetFrames(Uri uri, FFOptions? ffOptions = null)
+        public static FFProbeFrames GetFrames(Uri uri, FFOptions? ffOptions = null, string? customArguments = null)
        {
-            var instance = PrepareFrameAnalysisInstance(uri.AbsoluteUri, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PrepareFrameAnalysisInstance(uri.AbsoluteUri, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = instance.StartAndWaitForExit();
            ThrowIfExitCodeNotZero(result);

            return ParseFramesOutput(result);
        }

-        public static async Task<FFProbeFrames> GetFramesAsync(string filePath, FFOptions? ffOptions = null, CancellationToken cancellationToken = default)
+        public static async Task<FFProbeFrames> GetFramesAsync(string filePath, FFOptions? ffOptions = null, CancellationToken cancellationToken = default, string? customArguments = null)
        {
            ThrowIfInputFileDoesNotExist(filePath);

-            var instance = PrepareFrameAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PrepareFrameAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = await instance.StartAndWaitForExitAsync(cancellationToken).ConfigureAwait(false);
            return ParseFramesOutput(result);
        }

-        public static async Task<FFProbePackets> GetPacketsAsync(string filePath, FFOptions? ffOptions = null, CancellationToken cancellationToken = default)
+        public static async Task<FFProbePackets> GetPacketsAsync(string filePath, FFOptions? ffOptions = null, CancellationToken cancellationToken = default, string? customArguments = null)
        {
            ThrowIfInputFileDoesNotExist(filePath);

-            var instance = PreparePacketAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PreparePacketAnalysisInstance(filePath, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = await instance.StartAndWaitForExitAsync(cancellationToken).ConfigureAwait(false);
            return ParsePacketsOutput(result);
        }

-        public static async Task<IMediaAnalysis> AnalyseAsync(Uri uri, FFOptions? ffOptions = null, CancellationToken cancellationToken = default)
+        public static async Task<IMediaAnalysis> AnalyseAsync(Uri uri, FFOptions? ffOptions = null, CancellationToken cancellationToken = default, string? customArguments = null)
        {
-            var instance = PrepareStreamAnalysisInstance(uri.AbsoluteUri, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PrepareStreamAnalysisInstance(uri.AbsoluteUri, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = await instance.StartAndWaitForExitAsync(cancellationToken).ConfigureAwait(false);
            ThrowIfExitCodeNotZero(result);

            return ParseOutput(result);
        }
-        public static async Task<IMediaAnalysis> AnalyseAsync(Stream stream, FFOptions? ffOptions = null, CancellationToken cancellationToken = default)
+        public static async Task<IMediaAnalysis> AnalyseAsync(Stream stream, FFOptions? ffOptions = null, CancellationToken cancellationToken = default, string? customArguments = null)
        {
            var streamPipeSource = new StreamPipeSource(stream);
            var pipeArgument = new InputPipeArgument(streamPipeSource);
-            var instance = PrepareStreamAnalysisInstance(pipeArgument.PipePath, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PrepareStreamAnalysisInstance(pipeArgument.PipePath, ffOptions ?? GlobalFFOptions.Current, customArguments);
            pipeArgument.Pre();

            var task = instance.StartAndWaitForExitAsync(cancellationToken);
@ -148,9 +148,9 @@ public static async Task<IMediaAnalysis> AnalyseAsync(Stream stream, FFOptions?
            return ParseOutput(result);
        }

-        public static async Task<FFProbeFrames> GetFramesAsync(Uri uri, FFOptions? ffOptions = null, CancellationToken cancellationToken = default)
+        public static async Task<FFProbeFrames> GetFramesAsync(Uri uri, FFOptions? ffOptions = null, CancellationToken cancellationToken = default, string? customArguments = null)
        {
-            var instance = PrepareFrameAnalysisInstance(uri.AbsoluteUri, ffOptions ?? GlobalFFOptions.Current);
+            var instance = PrepareFrameAnalysisInstance(uri.AbsoluteUri, ffOptions ?? GlobalFFOptions.Current, customArguments);
            var result = await instance.StartAndWaitForExitAsync(cancellationToken).ConfigureAwait(false);
            return ParseFramesOutput(result);
        }
@ -212,18 +212,18 @@ private static void ThrowIfExitCodeNotZero(IProcessResult result)
            }
        }

-        private static ProcessArguments PrepareStreamAnalysisInstance(string filePath, FFOptions ffOptions)
-            => PrepareInstance($"-loglevel error -print_format json -show_format -sexagesimal -show_streams \"{filePath}\"", ffOptions);
-        private static ProcessArguments PrepareFrameAnalysisInstance(string filePath, FFOptions ffOptions)
-            => PrepareInstance($"-loglevel error -print_format json -show_frames -v quiet -sexagesimal \"{filePath}\"", ffOptions);
-        private static ProcessArguments PreparePacketAnalysisInstance(string filePath, FFOptions ffOptions)
-            => PrepareInstance($"-loglevel error -print_format json -show_packets -v quiet -sexagesimal \"{filePath}\"", ffOptions);
+        private static ProcessArguments PrepareStreamAnalysisInstance(string filePath, FFOptions ffOptions, string? customArguments)
+            => PrepareInstance($"-loglevel error -print_format json -show_format -sexagesimal -show_streams -show_chapters \"{filePath}\"", ffOptions, customArguments);
+        private static ProcessArguments PrepareFrameAnalysisInstance(string filePath, FFOptions ffOptions, string? customArguments)
+            => PrepareInstance($"-loglevel error -print_format json -show_frames -v quiet -sexagesimal \"{filePath}\"", ffOptions, customArguments);
+        private static ProcessArguments PreparePacketAnalysisInstance(string filePath, FFOptions ffOptions, string? customArguments)
+            => PrepareInstance($"-loglevel error -print_format json -show_packets -v quiet -sexagesimal \"{filePath}\"", ffOptions, customArguments);

-        private static ProcessArguments PrepareInstance(string arguments, FFOptions ffOptions)
+        private static ProcessArguments PrepareInstance(string arguments, FFOptions ffOptions, string? customArguments)
        {
            FFProbeHelper.RootExceptionCheck();
            FFProbeHelper.VerifyFFProbeExists(ffOptions);
-            var startInfo = new ProcessStartInfo(GlobalFFOptions.GetFFProbeBinaryPath(ffOptions), arguments)
+            var startInfo = new ProcessStartInfo(GlobalFFOptions.GetFFProbeBinaryPath(ffOptions), $"{arguments} {customArguments}")
            {
                StandardOutputEncoding = ffOptions.Encoding,
                StandardErrorEncoding = ffOptions.Encoding,
--- a/FFMpegCore/FFProbe/FFProbeAnalysis.cs
+++ b/FFMpegCore/FFProbe/FFProbeAnalysis.cs
@ -11,6 +11,9 @@ public class FFProbeAnalysis
        [JsonPropertyName("format")]
        public Format Format { get; set; } = null!;

+        [JsonPropertyName("chapters")]
+        public List<Chapter> Chapters { get; set; } = null!;
+
        [JsonIgnore]
        public IReadOnlyList<string> ErrorData { get; set; } = new List<string>();
    }
@ -80,6 +83,9 @@ public class FFProbeStream : ITagsContainer, IDispositionContainer
        [JsonPropertyName("pix_fmt")]
        public string PixelFormat { get; set; } = null!;

+        [JsonPropertyName("level")]
+        public int Level { get; set; }
+
        [JsonPropertyName("sample_rate")]
        public string SampleRate { get; set; } = null!;

@ -87,10 +93,22 @@ public class FFProbeStream : ITagsContainer, IDispositionContainer
        public Dictionary<string, int> Disposition { get; set; } = null!;

        [JsonPropertyName("tags")]
-        public Dictionary<string, string> Tags { get; set; } = null!;
+        public Dictionary<string, string>? Tags { get; set; }

        [JsonPropertyName("side_data_list")]
        public List<Dictionary<string, JsonValue>> SideData { get; set; } = null!;
+
+        [JsonPropertyName("color_range")]
+        public string ColorRange { get; set; } = null!;
+
+        [JsonPropertyName("color_space")]
+        public string ColorSpace { get; set; } = null!;
+
+        [JsonPropertyName("color_transfer")]
+        public string ColorTransfer { get; set; } = null!;
+
+        [JsonPropertyName("color_primaries")]
+        public string ColorPrimaries { get; set; } = null!;
    }

    public class Format : ITagsContainer
@ -126,7 +144,31 @@ public class Format : ITagsContainer
        public int ProbeScore { get; set; }

        [JsonPropertyName("tags")]
-        public Dictionary<string, string> Tags { get; set; } = null!;
+        public Dictionary<string, string>? Tags { get; set; }
+    }
+
+    public class Chapter : ITagsContainer
+    {
+        [JsonPropertyName("id")]
+        public long Id { get; set; }
+
+        [JsonPropertyName("time_base")]
+        public string TimeBase { get; set; } = null!;
+
+        [JsonPropertyName("start")]
+        public long Start { get; set; }
+
+        [JsonPropertyName("start_time")]
+        public string StartTime { get; set; } = null!;
+
+        [JsonPropertyName("end")]
+        public long End { get; set; }
+
+        [JsonPropertyName("end_time")]
+        public string EndTime { get; set; } = null!;
+
+        [JsonPropertyName("tags")]
+        public Dictionary<string, string>? Tags { get; set; }
    }

    public interface IDispositionContainer
@ -136,7 +178,7 @@ public interface IDispositionContainer

    public interface ITagsContainer
    {
-        Dictionary<string, string> Tags { get; set; }
+        Dictionary<string, string>? Tags { get; set; }
    }

    public static class TagExtensions
--- a/FFMpegCore/FFProbe/IMediaAnalysis.cs
+++ b/FFMpegCore/FFProbe/IMediaAnalysis.cs
@ -1,9 +1,12 @@
-namespace FFMpegCore
+using FFMpegCore.Builders.MetaData;
+
+namespace FFMpegCore
 {
    public interface IMediaAnalysis
    {
        TimeSpan Duration { get; }
        MediaFormat Format { get; }
+        List<ChapterData> Chapters { get; }
        AudioStream? PrimaryAudioStream { get; }
        VideoStream? PrimaryVideoStream { get; }
        SubtitleStream? PrimarySubtitleStream { get; }
--- a/FFMpegCore/FFProbe/MediaAnalysis.cs
+++ b/FFMpegCore/FFProbe/MediaAnalysis.cs
@ -1,4 +1,5 @@
 using System.Text.RegularExpressions;
+using FFMpegCore.Builders.MetaData;

 namespace FFMpegCore
 {
@ -7,6 +8,7 @@ internal class MediaAnalysis : IMediaAnalysis
        internal MediaAnalysis(FFProbeAnalysis analysis)
        {
            Format = ParseFormat(analysis.Format);
+            Chapters = analysis.Chapters.Select(c => ParseChapter(c)).ToList();
            VideoStreams = analysis.Streams.Where(stream => stream.CodecType == "video").Select(ParseVideoStream).ToList();
            AudioStreams = analysis.Streams.Where(stream => stream.CodecType == "audio").Select(ParseAudioStream).ToList();
            SubtitleStreams = analysis.Streams.Where(stream => stream.CodecType == "subtitle").Select(ParseSubtitleStream).ToList();
@ -28,6 +30,15 @@ private MediaFormat ParseFormat(Format analysisFormat)
            };
        }

+        private ChapterData ParseChapter(Chapter analysisChapter)
+        {
+            var title = analysisChapter.Tags.FirstOrDefault(t => t.Key == "title").Value;
+            var start = MediaAnalysisUtils.ParseDuration(analysisChapter.StartTime);
+            var end = MediaAnalysisUtils.ParseDuration(analysisChapter.EndTime);
+
+            return new ChapterData(title, start, end);
+        }
+
        public TimeSpan Duration => new[]
        {
            Format.Duration,
@ -37,6 +48,8 @@ private MediaFormat ParseFormat(Format analysisFormat)

        public MediaFormat Format { get; }

+        public List<ChapterData> Chapters { get; }
+
        public AudioStream? PrimaryAudioStream => AudioStreams.OrderBy(stream => stream.Index).FirstOrDefault();
        public VideoStream? PrimaryVideoStream => VideoStreams.OrderBy(stream => stream.Index).FirstOrDefault();
        public SubtitleStream? PrimarySubtitleStream => SubtitleStreams.OrderBy(stream => stream.Index).FirstOrDefault();
@ -74,6 +87,11 @@ private VideoStream ParseVideoStream(FFProbeStream stream)
                Width = stream.Width ?? 0,
                Profile = stream.Profile,
                PixelFormat = stream.PixelFormat,
+                Level = stream.Level,
+                ColorRange = stream.ColorRange,
+                ColorSpace = stream.ColorSpace,
+                ColorTransfer = stream.ColorTransfer,
+                ColorPrimaries = stream.ColorPrimaries,
                Rotation = MediaAnalysisUtils.ParseRotation(stream),
                Language = stream.GetLanguage(),
                Disposition = MediaAnalysisUtils.FormatDisposition(stream.Disposition),
--- a/FFMpegCore/FFProbe/MediaFormat.cs
+++ b/FFMpegCore/FFProbe/MediaFormat.cs
@ -1,6 +1,6 @@
 namespace FFMpegCore
 {
-    public class MediaFormat
+    public class MediaFormat : ITagsContainer
    {
        public TimeSpan Duration { get; set; }
        public TimeSpan StartTime { get; set; }
--- a/FFMpegCore/FFProbe/MediaStream.cs
+++ b/FFMpegCore/FFProbe/MediaStream.cs
@ -2,7 +2,7 @@

 namespace FFMpegCore
 {
-    public abstract class MediaStream
+    public abstract class MediaStream : ITagsContainer
    {
        public int Index { get; set; }
        public string CodecName { get; set; } = null!;
--- a/FFMpegCore/FFProbe/VideoStream.cs
+++ b/FFMpegCore/FFProbe/VideoStream.cs
@ -13,8 +13,13 @@ public class VideoStream : MediaStream
        public int Height { get; set; }
        public double FrameRate { get; set; }
        public string PixelFormat { get; set; } = null!;
+        public int Level { get; set; }
        public int Rotation { get; set; }
        public double AverageFrameRate { get; set; }
+        public string ColorRange { get; set; } = null!;
+        public string ColorSpace { get; set; } = null!;
+        public string ColorTransfer { get; set; } = null!;
+        public string ColorPrimaries { get; set; } = null!;

        public PixelFormat GetPixelFormatInfo() => FFMpeg.GetPixelFormat(PixelFormat);
    }
--- a/FFMpegCore/GlobalFFOptions.cs
+++ b/FFMpegCore/GlobalFFOptions.cs
@ -30,12 +30,23 @@ private static string GetFFBinaryPath(string name, FFOptions ffOptions)
            }

            var target = Environment.Is64BitProcess ? "x64" : "x86";
-            if (Directory.Exists(Path.Combine(ffOptions.BinaryFolder, target)))
+            var possiblePaths = new List<string>()
            {
-                ffName = Path.Combine(target, ffName);
+                Path.Combine(ffOptions.BinaryFolder, target),
+                ffOptions.BinaryFolder
+            };
+
+            foreach (var possiblePath in possiblePaths)
+            {
+                var possibleFFMpegPath = Path.Combine(possiblePath, ffName);
+                if (File.Exists(possibleFFMpegPath))
+                {
+                    return possibleFFMpegPath;
+                }
            }

-            return Path.Combine(ffOptions.BinaryFolder, ffName);
+            //Fall back to the assumption this tool exists in the PATH
+            return ffName;
        }

        private static FFOptions LoadFFOptions()
--- a/README.md
+++ b/README.md
@ -63,6 +63,17 @@ var bitmap = FFMpeg.Snapshot(inputPath, new Size(200, 400), TimeSpan.FromMinutes
 FFMpeg.Snapshot(inputPath, outputPath, new Size(200, 400), TimeSpan.FromMinutes(1));
 ```

+### You can also capture GIF snapshots from a video file:
+```csharp
+FFMpeg.GifSnapshot(inputPath, outputPath, new Size(200, 400), TimeSpan.FromSeconds(10));
+
+// or async
+await FFMpeg.GifSnapshotAsync(inputPath, outputPath, new Size(200, 400), TimeSpan.FromSeconds(10));
+
+// you can also supply -1 to either one of Width/Height Size properties if you'd like FFMPEG to resize while maintaining the aspect ratio
+await FFMpeg.GifSnapshotAsync(inputPath, outputPath, new Size(480, -1), TimeSpan.FromSeconds(10));
+```
+
 ### Join video parts into one single file:
 ```csharp
 FFMpeg.Join(@"..\joined_video.mp4",
@ -76,7 +87,7 @@ FFMpeg.Join(@"..\joined_video.mp4",
 ``` csharp
 FFMpeg.SubVideo(inputPath, 
    outputPath,
-    TimeSpan.FromSeconds(0)
+    TimeSpan.FromSeconds(0),
    TimeSpan.FromSeconds(30)
 );
 ```