Alex/FFMpegCore
1
0
Fork 0
mirror of https://github.com/rosenbjerg/FFMpegCore.git synced 2025-12-16 19:15:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Compare commits

base: Alex:a599c48511cb9ba059b00e3c3a4276650388ec4b
Branches Tags
Alex:main
Alex:add-more-missing-tests
Alex:Delegate-WithChapter-overload-with-double-argument-to-long-overload-to-reduce-code
Alex:ensure-cancellationtoken-passed-to-cancellablethrough-is-not-already-cancelled
Alex:fix-changing-of-output-extension-in-BaseSubVideo
Alex:release
Alex:improve-tests-usage-of-cancellation-token
Alex:add-metadata-builder-class
Alex:fix-fps-handling-in-join-image-sequence
Alex:improve-percentage-progress-test
Alex:ensure-test-context-cancellationtoken-is-used
Alex:improve-cancellation-handling
Alex:fix-GetCreationTime-function
Alex:include-more-guid-chars-in-pipe-path
Alex:bugfix/ensure-ffmpeg-not-found-throws-ffmpegexception
Alex:cleanup-tests
Alex:clean-up-unit-tests
Alex:update-nuget-dependencies
Alex:migrate-to-macos-latest-test-runner-instead-of-macos-13
Alex:chore/deterministic-dotnet-builds
Alex:Fix-release-pipeline
Alex:feature/only-upload-coverage-on-one-os-in-matrix
Alex:release-archived
Alex:legacy
Alex:1.1.0
Alex:v1.0.11
Alex:v1.0.10
Alex:v1.0.9
Alex:v1.0.8
Alex:v1.0.7
Alex:v1.0.6
Alex:v1.0.5
Alex:v1.0.4
Alex:v1.0.3
Alex:v1.0.2
Alex:v1.0.1
Alex:v1.0.0
..
compare: Alex:0d07456c6e158122fbf82c9e75255a4688b89ee9
Branches Tags
Alex:main
Alex:add-more-missing-tests
Alex:Delegate-WithChapter-overload-with-double-argument-to-long-overload-to-reduce-code
Alex:ensure-cancellationtoken-passed-to-cancellablethrough-is-not-already-cancelled
Alex:fix-changing-of-output-extension-in-BaseSubVideo
Alex:release
Alex:improve-tests-usage-of-cancellation-token
Alex:add-metadata-builder-class
Alex:fix-fps-handling-in-join-image-sequence
Alex:improve-percentage-progress-test
Alex:ensure-test-context-cancellationtoken-is-used
Alex:improve-cancellation-handling
Alex:fix-GetCreationTime-function
Alex:include-more-guid-chars-in-pipe-path
Alex:bugfix/ensure-ffmpeg-not-found-throws-ffmpegexception
Alex:cleanup-tests
Alex:clean-up-unit-tests
Alex:update-nuget-dependencies
Alex:migrate-to-macos-latest-test-runner-instead-of-macos-13
Alex:chore/deterministic-dotnet-builds
Alex:Fix-release-pipeline
Alex:feature/only-upload-coverage-on-one-os-in-matrix
Alex:release-archived
Alex:legacy
Alex:1.1.0
Alex:v1.0.11
Alex:v1.0.10
Alex:v1.0.9
Alex:v1.0.8
Alex:v1.0.7
Alex:v1.0.6
Alex:v1.0.5
Alex:v1.0.4
Alex:v1.0.3
Alex:v1.0.2
Alex:v1.0.1
Alex:v1.0.0

No commits in common. "a599c48511cb9ba059b00e3c3a4276650388ec4b" and "0d07456c6e158122fbf82c9e75255a4688b89ee9" have entirely different histories.
a599c48511 ... 0d07456c6e

7 changed files with 69 additions and 131 deletions
Show stats Expand all files Collapse all files

47
FFMpegCore.Test/AudioTest.cs
View file

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

112
FFMpegCore.Test/VideoTest.cs
View file

@ -17,7 +17,7 @@ namespace FFMpegCore.Test;
[TestClass] [TestClass]
public class VideoTest public class VideoTest
{ {
private const int BaseTimeoutMilliseconds = 60_000; private const int BaseTimeoutMilliseconds = 15_000;
public TestContext TestContext { get; set; } public TestContext TestContext { get; set; }
@ -30,7 +30,6 @@ public class VideoTest
var success = FFMpegArguments var success = FFMpegArguments
.FromFileInput(TestResources.WebmVideo) .FromFileInput(TestResources.WebmVideo)
.OutputToFile(outputFile, false) .OutputToFile(outputFile, false)
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -44,7 +43,6 @@ public class VideoTest
var success = FFMpegArguments var success = FFMpegArguments
.FromFileInput(TestResources.WebmVideo) .FromFileInput(TestResources.WebmVideo)
.OutputToFile(outputFile, false) .OutputToFile(outputFile, false)
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -60,7 +58,6 @@ public class VideoTest
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.WithVideoCodec(VideoCodec.LibX264) .WithVideoCodec(VideoCodec.LibX264)
.ForcePixelFormat("yuv444p")) .ForcePixelFormat("yuv444p"))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
var analysis = FFProbe.Analyse(outputFile); var analysis = FFProbe.Analyse(outputFile);
@ -77,7 +74,6 @@ public class VideoTest
.FromFileInput(TestResources.WebmVideo) .FromFileInput(TestResources.WebmVideo)
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.WithVideoCodec(VideoCodec.LibX264)) .WithVideoCodec(VideoCodec.LibX264))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -92,7 +88,6 @@ public class VideoTest
.FromFileInput(TestResources.WebmVideo) .FromFileInput(TestResources.WebmVideo)
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.WithVideoCodec(VideoCodec.LibX265)) .WithVideoCodec(VideoCodec.LibX265))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -104,7 +99,7 @@ public class VideoTest
[DataRow(PixelFormat.Format32bppArgb)] [DataRow(PixelFormat.Format32bppArgb)]
public void Video_ToMP4_Args_Pipe_WindowsOnly(PixelFormat pixelFormat) public void Video_ToMP4_Args_Pipe_WindowsOnly(PixelFormat pixelFormat)
{ {
Video_ToMP4_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken); Video_ToMP4_Args_Pipe_Internal(pixelFormat);
} }
[TestMethod] [TestMethod]
@ -113,10 +108,10 @@ public class VideoTest
[DataRow(SKColorType.Bgra8888)] [DataRow(SKColorType.Bgra8888)]
public void Video_ToMP4_Args_Pipe(SKColorType pixelFormat) public void Video_ToMP4_Args_Pipe(SKColorType pixelFormat)
{ {
Video_ToMP4_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken); Video_ToMP4_Args_Pipe_Internal(pixelFormat);
} }
private static void Video_ToMP4_Args_Pipe_Internal(dynamic pixelFormat, CancellationToken cancellationToken) private static void Video_ToMP4_Args_Pipe_Internal(dynamic pixelFormat)
{ {
using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}"); using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@ -125,7 +120,6 @@ public class VideoTest
.FromPipeInput(videoFramesSource) .FromPipeInput(videoFramesSource)
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.WithVideoCodec(VideoCodec.LibX264)) .WithVideoCodec(VideoCodec.LibX264))
.CancellableThrough(cancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -135,17 +129,17 @@ public class VideoTest
[Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)] [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
public void Video_ToMP4_Args_Pipe_DifferentImageSizes_WindowsOnly() public void Video_ToMP4_Args_Pipe_DifferentImageSizes_WindowsOnly()
{ {
Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(PixelFormat.Format24bppRgb, TestContext.CancellationToken); Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(PixelFormat.Format24bppRgb);
} }
[TestMethod] [TestMethod]
[Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)] [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
public void Video_ToMP4_Args_Pipe_DifferentImageSizes() public void Video_ToMP4_Args_Pipe_DifferentImageSizes()
{ {
Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(SKColorType.Rgb565, TestContext.CancellationToken); Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(SKColorType.Rgb565);
} }
private static void Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(dynamic pixelFormat, CancellationToken cancellationToken) private static void Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal(dynamic pixelFormat)
{ {
using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}"); using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@ -159,7 +153,6 @@ public class VideoTest
.FromPipeInput(videoFramesSource) .FromPipeInput(videoFramesSource)
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.WithVideoCodec(VideoCodec.LibX264)) .WithVideoCodec(VideoCodec.LibX264))
.CancellableThrough(cancellationToken)
.ProcessSynchronously()); .ProcessSynchronously());
} }
@ -168,17 +161,17 @@ public class VideoTest
[Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)] [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
public async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_WindowsOnly_Async() public async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_WindowsOnly_Async()
{ {
await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(PixelFormat.Format24bppRgb, TestContext.CancellationToken); await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(PixelFormat.Format24bppRgb);
} }
[TestMethod] [TestMethod]
[Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)] [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
public async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Async() public async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Async()
{ {
await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(SKColorType.Rgb565, TestContext.CancellationToken); await Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(SKColorType.Rgb565);
} }
private static async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(dynamic pixelFormat, CancellationToken cancellationToken) private static async Task Video_ToMP4_Args_Pipe_DifferentImageSizes_Internal_Async(dynamic pixelFormat)
{ {
using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}"); using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@ -192,7 +185,6 @@ public class VideoTest
.FromPipeInput(videoFramesSource) .FromPipeInput(videoFramesSource)
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.WithVideoCodec(VideoCodec.LibX264)) .WithVideoCodec(VideoCodec.LibX264))
.CancellableThrough(cancellationToken)
.ProcessAsynchronously()); .ProcessAsynchronously());
} }
@ -202,18 +194,17 @@ public class VideoTest
public void Video_ToMP4_Args_Pipe_DifferentPixelFormats_WindowsOnly() public void Video_ToMP4_Args_Pipe_DifferentPixelFormats_WindowsOnly()
{ {
Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(PixelFormat.Format24bppRgb, Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(PixelFormat.Format24bppRgb,
PixelFormat.Format32bppRgb, TestContext.CancellationToken); PixelFormat.Format32bppRgb);
} }
[TestMethod] [TestMethod]
[Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)] [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
public void Video_ToMP4_Args_Pipe_DifferentPixelFormats() public void Video_ToMP4_Args_Pipe_DifferentPixelFormats()
{ {
Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(SKColorType.Rgb565, SKColorType.Bgra8888, TestContext.CancellationToken); Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(SKColorType.Rgb565, SKColorType.Bgra8888);
} }
private static void Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2, private static void Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2)
CancellationToken cancellationToken)
{ {
using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}"); using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@ -227,7 +218,6 @@ public class VideoTest
.FromPipeInput(videoFramesSource) .FromPipeInput(videoFramesSource)
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.WithVideoCodec(VideoCodec.LibX264)) .WithVideoCodec(VideoCodec.LibX264))
.CancellableThrough(cancellationToken)
.ProcessSynchronously()); .ProcessSynchronously());
} }
@ -237,18 +227,17 @@ public class VideoTest
public async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_WindowsOnly_Async() public async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_WindowsOnly_Async()
{ {
await Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(PixelFormat.Format24bppRgb, await Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(PixelFormat.Format24bppRgb,
PixelFormat.Format32bppRgb, TestContext.CancellationToken); PixelFormat.Format32bppRgb);
} }
[TestMethod] [TestMethod]
[Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)] [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
public async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_Async() public async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_Async()
{ {
await Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(SKColorType.Rgb565, SKColorType.Bgra8888, TestContext.CancellationToken); await Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(SKColorType.Rgb565, SKColorType.Bgra8888);
} }
private static async Task Video_ToMP4_Args_Pipe_DifferentPixelFormats_Internal_Async(dynamic pixelFormatFrame1, dynamic pixelFormatFrame2, 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}"); using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
@ -262,7 +251,6 @@ public class VideoTest
.FromPipeInput(videoFramesSource) .FromPipeInput(videoFramesSource)
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.WithVideoCodec(VideoCodec.LibX264)) .WithVideoCodec(VideoCodec.LibX264))
.CancellableThrough(cancellationToken)
.ProcessAsynchronously()); .ProcessAsynchronously());
} }
@ -277,7 +265,6 @@ public class VideoTest
.FromPipeInput(new StreamPipeSource(input)) .FromPipeInput(new StreamPipeSource(input))
.OutputToFile(output, false, opt => opt .OutputToFile(output, false, opt => opt
.WithVideoCodec(VideoCodec.LibX264)) .WithVideoCodec(VideoCodec.LibX264))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -293,7 +280,6 @@ public class VideoTest
await FFMpegArguments await FFMpegArguments
.FromFileInput(TestResources.Mp4Video) .FromFileInput(TestResources.Mp4Video)
.OutputToPipe(pipeSource, opt => opt.ForceFormat("mp4")) .OutputToPipe(pipeSource, opt => opt.ForceFormat("mp4"))
.CancellableThrough(TestContext.CancellationToken)
.ProcessAsynchronously(); .ProcessAsynchronously();
}); });
} }
@ -309,7 +295,6 @@ public class VideoTest
.ForceFormat("webm")) .ForceFormat("webm"))
.OutputToPipe(new StreamPipeSink(output), opt => opt .OutputToPipe(new StreamPipeSink(output), opt => opt
.ForceFormat("mpegts")) .ForceFormat("mpegts"))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
output.Position = 0; output.Position = 0;
@ -328,7 +313,6 @@ public class VideoTest
.FromFileInput(TestResources.Mp4Video) .FromFileInput(TestResources.Mp4Video)
.OutputToPipe(new StreamPipeSink(ms), opt => opt .OutputToPipe(new StreamPipeSink(ms), opt => opt
.ForceFormat("mkv")) .ForceFormat("mkv"))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
}); });
} }
@ -344,7 +328,6 @@ public class VideoTest
.OutputToPipe(pipeSource, opt => opt .OutputToPipe(pipeSource, opt => opt
.WithVideoCodec(VideoCodec.LibX264) .WithVideoCodec(VideoCodec.LibX264)
.ForceFormat("matroska")) .ForceFormat("matroska"))
.CancellableThrough(TestContext.CancellationToken)
.ProcessAsynchronously(); .ProcessAsynchronously();
} }
@ -355,13 +338,11 @@ public class VideoTest
FFMpegArguments FFMpegArguments
.FromFileInput(TestResources.Mp4Video) .FromFileInput(TestResources.Mp4Video)
.OutputToFile("temporary.mp4") .OutputToFile("temporary.mp4")
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
await FFMpegArguments await FFMpegArguments
.FromFileInput(TestResources.Mp4Video) .FromFileInput(TestResources.Mp4Video)
.OutputToFile("temporary.mp4") .OutputToFile("temporary.mp4")
.CancellableThrough(TestContext.CancellationToken)
.ProcessAsynchronously(); .ProcessAsynchronously();
File.Delete("temporary.mp4"); File.Delete("temporary.mp4");
@ -377,7 +358,6 @@ public class VideoTest
.OutputToPipe(new StreamPipeSink(output), opt => opt .OutputToPipe(new StreamPipeSink(output), opt => opt
.WithVideoCodec(VideoCodec.LibVpx) .WithVideoCodec(VideoCodec.LibVpx)
.ForceFormat("matroska")) .ForceFormat("matroska"))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
@ -396,7 +376,6 @@ public class VideoTest
var success = FFMpegArguments var success = FFMpegArguments
.FromFileInput(TestResources.Mp4Video) .FromFileInput(TestResources.Mp4Video)
.OutputToFile(outputFile, false) .OutputToFile(outputFile, false)
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -413,7 +392,6 @@ public class VideoTest
.CopyChannel() .CopyChannel()
.WithBitStreamFilter(Channel.Video, Filter.H264_Mp4ToAnnexB) .WithBitStreamFilter(Channel.Video, Filter.H264_Mp4ToAnnexB)
.ForceFormat(VideoType.MpegTs)) .ForceFormat(VideoType.MpegTs))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -425,7 +403,7 @@ public class VideoTest
[DataRow(PixelFormat.Format32bppArgb)] [DataRow(PixelFormat.Format32bppArgb)]
public async Task Video_ToTS_Args_Pipe_WindowsOnly(PixelFormat pixelFormat) public async Task Video_ToTS_Args_Pipe_WindowsOnly(PixelFormat pixelFormat)
{ {
await Video_ToTS_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken); await Video_ToTS_Args_Pipe_Internal(pixelFormat);
} }
[TestMethod] [TestMethod]
@ -434,10 +412,10 @@ public class VideoTest
[DataRow(SKColorType.Bgra8888)] [DataRow(SKColorType.Bgra8888)]
public async Task Video_ToTS_Args_Pipe(SKColorType pixelFormat) public async Task Video_ToTS_Args_Pipe(SKColorType pixelFormat)
{ {
await Video_ToTS_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken); await Video_ToTS_Args_Pipe_Internal(pixelFormat);
} }
private static async Task Video_ToTS_Args_Pipe_Internal(dynamic pixelFormat, CancellationToken cancellationToken) private static async Task Video_ToTS_Args_Pipe_Internal(dynamic pixelFormat)
{ {
using var output = new TemporaryFile($"out{VideoType.Ts.Extension}"); using var output = new TemporaryFile($"out{VideoType.Ts.Extension}");
var input = new RawVideoPipeSource(BitmapSource.CreateBitmaps(128, pixelFormat, 256, 256)); var input = new RawVideoPipeSource(BitmapSource.CreateBitmaps(128, pixelFormat, 256, 256));
@ -446,7 +424,6 @@ public class VideoTest
.FromPipeInput(input) .FromPipeInput(input)
.OutputToFile(output, false, opt => opt .OutputToFile(output, false, opt => opt
.ForceFormat(VideoType.Ts)) .ForceFormat(VideoType.Ts))
.CancellableThrough(cancellationToken)
.ProcessAsynchronously(); .ProcessAsynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
@ -464,7 +441,6 @@ public class VideoTest
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.Resize(200, 200) .Resize(200, 200)
.WithVideoCodec(VideoCodec.LibTheora)) .WithVideoCodec(VideoCodec.LibTheora))
.CancellableThrough(TestContext.CancellationToken)
.ProcessAsynchronously(); .ProcessAsynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -485,7 +461,6 @@ public class VideoTest
.WithVideoFilters(filterOptions => filterOptions .WithVideoFilters(filterOptions => filterOptions
.Scale(VideoSize.Ed)) .Scale(VideoSize.Ed))
.WithVideoCodec(VideoCodec.LibTheora)) .WithVideoCodec(VideoCodec.LibTheora))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
var analysis = FFProbe.Analyse(outputFile); var analysis = FFProbe.Analyse(outputFile);
@ -503,7 +478,6 @@ public class VideoTest
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.UsingMultithreading(true) .UsingMultithreading(true)
.WithVideoCodec(VideoCodec.LibX264)) .WithVideoCodec(VideoCodec.LibX264))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -516,7 +490,7 @@ public class VideoTest
// [DataRow(PixelFormat.Format48bppRgb)] // [DataRow(PixelFormat.Format48bppRgb)]
public void Video_ToMP4_Resize_Args_Pipe(PixelFormat pixelFormat) public void Video_ToMP4_Resize_Args_Pipe(PixelFormat pixelFormat)
{ {
Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken); Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat);
} }
[TestMethod] [TestMethod]
@ -525,10 +499,10 @@ public class VideoTest
[DataRow(SKColorType.Bgra8888)] [DataRow(SKColorType.Bgra8888)]
public void Video_ToMP4_Resize_Args_Pipe(SKColorType pixelFormat) public void Video_ToMP4_Resize_Args_Pipe(SKColorType pixelFormat)
{ {
Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat, TestContext.CancellationToken); Video_ToMP4_Resize_Args_Pipe_Internal(pixelFormat);
} }
private static void Video_ToMP4_Resize_Args_Pipe_Internal(dynamic pixelFormat, CancellationToken cancellationToken) private static void Video_ToMP4_Resize_Args_Pipe_Internal(dynamic pixelFormat)
{ {
using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}"); using var outputFile = new TemporaryFile($"out{VideoType.Mp4.Extension}");
var videoFramesSource = new RawVideoPipeSource(BitmapSource.CreateBitmaps(128, pixelFormat, 256, 256)); var videoFramesSource = new RawVideoPipeSource(BitmapSource.CreateBitmaps(128, pixelFormat, 256, 256));
@ -537,7 +511,6 @@ public class VideoTest
.FromPipeInput(videoFramesSource) .FromPipeInput(videoFramesSource)
.OutputToFile(outputFile, false, opt => opt .OutputToFile(outputFile, false, opt => opt
.WithVideoCodec(VideoCodec.LibX264)) .WithVideoCodec(VideoCodec.LibX264))
.CancellableThrough(cancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
} }
@ -766,7 +739,7 @@ public class VideoTest
Assert.IsTrue(success); Assert.IsTrue(success);
var result = FFProbe.Analyse(outputFile); var result = FFProbe.Analyse(outputFile);
Assert.AreEqual(3, result.Duration.Seconds); Assert.AreEqual(1, result.Duration.Seconds);
Assert.AreEqual(imageAnalysis.PrimaryVideoStream!.Width, result.PrimaryVideoStream!.Width); Assert.AreEqual(imageAnalysis.PrimaryVideoStream!.Width, result.PrimaryVideoStream!.Width);
Assert.AreEqual(imageAnalysis.PrimaryVideoStream!.Height, result.PrimaryVideoStream.Height); Assert.AreEqual(imageAnalysis.PrimaryVideoStream!.Height, result.PrimaryVideoStream.Height);
} }
@ -791,7 +764,6 @@ public class VideoTest
FFMpegArguments FFMpegArguments
.FromFileInput(TestResources.Mp4Video) .FromFileInput(TestResources.Mp4Video)
.OutputToFile(outputFile, false, opt => opt.WithDuration(TimeSpan.FromSeconds(video.Duration.TotalSeconds - 2))) .OutputToFile(outputFile, false, opt => opt.WithDuration(TimeSpan.FromSeconds(video.Duration.TotalSeconds - 2)))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(File.Exists(outputFile)); Assert.IsTrue(File.Exists(outputFile));
@ -813,13 +785,13 @@ public class VideoTest
var timeDone = TimeSpan.Zero; var timeDone = TimeSpan.Zero;
var analysis = FFProbe.Analyse(TestResources.Mp4Video); var analysis = FFProbe.Analyse(TestResources.Mp4Video);
var events = new List<double>();
void OnPercentageProgess(double percentage) void OnPercentageProgess(double percentage)
{ {
events.Add(percentage); if (percentage < 100)
{
percentageDone = percentage; percentageDone = percentage;
} }
}
void OnTimeProgess(TimeSpan time) void OnTimeProgess(TimeSpan time)
{ {
@ -835,16 +807,12 @@ public class VideoTest
.WithDuration(analysis.Duration)) .WithDuration(analysis.Duration))
.NotifyOnProgress(OnPercentageProgess, analysis.Duration) .NotifyOnProgress(OnPercentageProgess, analysis.Duration)
.NotifyOnProgress(OnTimeProgess) .NotifyOnProgress(OnTimeProgess)
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(success); Assert.IsTrue(success);
Assert.IsTrue(File.Exists(outputFile)); Assert.IsTrue(File.Exists(outputFile));
Assert.AreNotEqual(0.0, percentageDone); Assert.AreNotEqual(0.0, percentageDone);
Assert.IsGreaterThan(1, events.Count); Assert.AreNotEqual(100.0, percentageDone);
CollectionAssert.AllItemsAreUnique(events);
Assert.AreNotEqual(100.0, events.First());
Assert.AreEqual(100.0, events.Last(), 0.001);
Assert.AreNotEqual(TimeSpan.Zero, timeDone); Assert.AreNotEqual(TimeSpan.Zero, timeDone);
Assert.AreNotEqual(analysis.Duration, timeDone); Assert.AreNotEqual(analysis.Duration, timeDone);
} }
@ -864,7 +832,6 @@ public class VideoTest
.WithDuration(TimeSpan.FromSeconds(2))) .WithDuration(TimeSpan.FromSeconds(2)))
.NotifyOnError(_ => dataReceived = true) .NotifyOnError(_ => dataReceived = true)
.Configure(opt => opt.Encoding = Encoding.UTF8) .Configure(opt => opt.Encoding = Encoding.UTF8)
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
Assert.IsTrue(dataReceived); Assert.IsTrue(dataReceived);
@ -877,17 +844,17 @@ public class VideoTest
[Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)] [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
public void Video_TranscodeInMemory_WindowsOnly() public void Video_TranscodeInMemory_WindowsOnly()
{ {
Video_TranscodeInMemory_Internal(PixelFormat.Format24bppRgb, TestContext.CancellationToken); Video_TranscodeInMemory_Internal(PixelFormat.Format24bppRgb);
} }
[TestMethod] [TestMethod]
[Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)] [Timeout(BaseTimeoutMilliseconds, CooperativeCancellation = true)]
public void Video_TranscodeInMemory() public void Video_TranscodeInMemory()
{ {
Video_TranscodeInMemory_Internal(SKColorType.Rgb565, TestContext.CancellationToken); Video_TranscodeInMemory_Internal(SKColorType.Rgb565);
} }
private static void Video_TranscodeInMemory_Internal(dynamic pixelFormat, CancellationToken cancellationToken) private static void Video_TranscodeInMemory_Internal(dynamic pixelFormat)
{ {
using var resStream = new MemoryStream(); using var resStream = new MemoryStream();
var reader = new StreamPipeSink(resStream); var reader = new StreamPipeSink(resStream);
@ -898,7 +865,6 @@ public class VideoTest
.OutputToPipe(reader, opt => opt .OutputToPipe(reader, opt => opt
.WithVideoCodec("vp9") .WithVideoCodec("vp9")
.ForceFormat("webm")) .ForceFormat("webm"))
.CancellableThrough(cancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
resStream.Position = 0; resStream.Position = 0;
@ -918,7 +884,6 @@ public class VideoTest
.OutputToPipe(new StreamPipeSink(memoryStream), opt => opt .OutputToPipe(new StreamPipeSink(memoryStream), opt => opt
.WithVideoCodec("vp9") .WithVideoCodec("vp9")
.ForceFormat("webm")) .ForceFormat("webm"))
.CancellableThrough(TestContext.CancellationToken)
.ProcessSynchronously(); .ProcessSynchronously();
memoryStream.Position = 0; memoryStream.Position = 0;
@ -942,8 +907,6 @@ public class VideoTest
.WithVideoCodec(VideoCodec.LibX264) .WithVideoCodec(VideoCodec.LibX264)
.WithSpeedPreset(Speed.VeryFast)) .WithSpeedPreset(Speed.VeryFast))
.CancellableThrough(out var cancel) .CancellableThrough(out var cancel)
.CancellableThrough(TestContext.CancellationToken)
.CancellableThrough(TestContext.CancellationToken)
.ProcessAsynchronously(false); .ProcessAsynchronously(false);
await Task.Delay(300, TestContext.CancellationToken); await Task.Delay(300, TestContext.CancellationToken);
@ -967,13 +930,11 @@ public class VideoTest
.WithAudioCodec(AudioCodec.Aac) .WithAudioCodec(AudioCodec.Aac)
.WithVideoCodec(VideoCodec.LibX264) .WithVideoCodec(VideoCodec.LibX264)
.WithSpeedPreset(Speed.VeryFast)) .WithSpeedPreset(Speed.VeryFast))
.CancellableThrough(out var cancel) .CancellableThrough(out var cancel);
.CancellableThrough(TestContext.CancellationToken);
Task.Delay(300, TestContext.CancellationToken).ContinueWith(_ => cancel(), TestContext.CancellationToken); Task.Delay(300, TestContext.CancellationToken).ContinueWith(_ => cancel(), TestContext.CancellationToken);
var result = task.CancellableThrough(TestContext.CancellationToken) var result = task.ProcessSynchronously(false);
.ProcessSynchronously(false);
Assert.IsFalse(result); Assert.IsFalse(result);
} }
@ -993,7 +954,6 @@ public class VideoTest
.WithVideoCodec(VideoCodec.LibX264) .WithVideoCodec(VideoCodec.LibX264)
.WithSpeedPreset(Speed.VeryFast)) .WithSpeedPreset(Speed.VeryFast))
.CancellableThrough(out var cancel, 10000) .CancellableThrough(out var cancel, 10000)
.CancellableThrough(TestContext.CancellationToken)
.ProcessAsynchronously(false); .ProcessAsynchronously(false);
await Task.Delay(300, TestContext.CancellationToken); await Task.Delay(300, TestContext.CancellationToken);
@ -1027,7 +987,6 @@ public class VideoTest
.WithVideoCodec(VideoCodec.LibX264) .WithVideoCodec(VideoCodec.LibX264)
.WithSpeedPreset(Speed.VeryFast)) .WithSpeedPreset(Speed.VeryFast))
.CancellableThrough(cts.Token) .CancellableThrough(cts.Token)
.CancellableThrough(TestContext.CancellationToken)
.ProcessAsynchronously(false); .ProcessAsynchronously(false);
cts.CancelAfter(300); cts.CancelAfter(300);
@ -1054,7 +1013,6 @@ public class VideoTest
.WithVideoCodec(VideoCodec.LibX264) .WithVideoCodec(VideoCodec.LibX264)
.WithSpeedPreset(Speed.VeryFast)) .WithSpeedPreset(Speed.VeryFast))
.CancellableThrough(cts.Token) .CancellableThrough(cts.Token)
.CancellableThrough(TestContext.CancellationToken)
.ProcessAsynchronously(); .ProcessAsynchronously();
cts.CancelAfter(300); cts.CancelAfter(300);
@ -1082,8 +1040,7 @@ public class VideoTest
cts.CancelAfter(300); cts.CancelAfter(300);
Assert.ThrowsExactly<OperationCanceledException>(() => task.CancellableThrough(TestContext.CancellationToken) Assert.ThrowsExactly<OperationCanceledException>(() => task.ProcessSynchronously());
.ProcessSynchronously());
} }
[TestMethod] [TestMethod]
@ -1105,8 +1062,7 @@ public class VideoTest
.WithSpeedPreset(Speed.VeryFast)) .WithSpeedPreset(Speed.VeryFast))
.CancellableThrough(cts.Token); .CancellableThrough(cts.Token);
Assert.ThrowsExactly<OperationCanceledException>(() => task.CancellableThrough(TestContext.CancellationToken) Assert.ThrowsExactly<OperationCanceledException>(() => task.ProcessSynchronously());
.ProcessSynchronously());
} }
[TestMethod] [TestMethod]

5
FFMpegCore/FFMpeg/Arguments/GifPaletteArgument.cs
View file

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

3
FFMpegCore/FFMpeg/FFMpeg.cs
View file

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

2
FFMpegCore/FFMpeg/FFMpegArgumentOptions.cs
View file

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

27
FFMpegCore/FFMpeg/FFMpegArgumentProcessor.cs
View file

@ -10,6 +10,7 @@ namespace FFMpegCore;
public class FFMpegArgumentProcessor public class FFMpegArgumentProcessor
{ {
private static readonly Regex ProgressRegex = new(@"time=(\d\d:\d\d:\d\d.\d\d?)", RegexOptions.Compiled); private static readonly Regex ProgressRegex = new(@"time=(\d\d:\d\d:\d\d.\d\d?)", RegexOptions.Compiled);
private readonly CancellationTokenSource _cancellationTokenSource = new();
private readonly List<Action<FFOptions>> _configurations; private readonly List<Action<FFOptions>> _configurations;
private readonly FFMpegArguments _ffMpegArguments; private readonly FFMpegArguments _ffMpegArguments;
private CancellationTokenRegistration? _cancellationTokenRegistration; private CancellationTokenRegistration? _cancellationTokenRegistration;
@ -31,6 +32,12 @@ public class FFMpegArgumentProcessor
private event EventHandler<int> CancelEvent = null!; private event EventHandler<int> CancelEvent = null!;
~FFMpegArgumentProcessor()
{
_cancellationTokenSource.Dispose();
_cancellationTokenRegistration?.Dispose();
}
/// <summary> /// <summary>
/// Register action that will be invoked during the ffmpeg processing, when a progress time is output and parsed and progress percentage is /// Register action that will be invoked during the ffmpeg processing, when a progress time is output and parsed and progress percentage is
/// calculated. /// calculated.
@ -85,7 +92,6 @@ public class FFMpegArgumentProcessor
public FFMpegArgumentProcessor CancellableThrough(CancellationToken token, int timeout = 0) public FFMpegArgumentProcessor CancellableThrough(CancellationToken token, int timeout = 0)
{ {
_cancellationTokenRegistration?.Dispose();
_cancellationTokenRegistration = token.Register(() => Cancel(timeout)); _cancellationTokenRegistration = token.Register(() => Cancel(timeout));
return this; return this;
} }
@ -111,12 +117,11 @@ public class FFMpegArgumentProcessor
{ {
var options = GetConfiguredOptions(ffMpegOptions); var options = GetConfiguredOptions(ffMpegOptions);
var processArguments = PrepareProcessArguments(options); var processArguments = PrepareProcessArguments(options);
using var cancellationTokenSource = new CancellationTokenSource();
IProcessResult? processResult = null; IProcessResult? processResult = null;
try try
{ {
processResult = Process(processArguments, cancellationTokenSource).ConfigureAwait(false).GetAwaiter().GetResult(); processResult = Process(processArguments).ConfigureAwait(false).GetAwaiter().GetResult();
} }
catch (OperationCanceledException) catch (OperationCanceledException)
{ {
@ -133,12 +138,11 @@ public class FFMpegArgumentProcessor
{ {
var options = GetConfiguredOptions(ffMpegOptions); var options = GetConfiguredOptions(ffMpegOptions);
var processArguments = PrepareProcessArguments(options); var processArguments = PrepareProcessArguments(options);
using var cancellationTokenSource = new CancellationTokenSource();
IProcessResult? processResult = null; IProcessResult? processResult = null;
try try
{ {
processResult = await Process(processArguments, cancellationTokenSource).ConfigureAwait(false); processResult = await Process(processArguments).ConfigureAwait(false);
} }
catch (OperationCanceledException) catch (OperationCanceledException)
{ {
@ -151,12 +155,11 @@ public class FFMpegArgumentProcessor
return HandleCompletion(throwOnError, processResult?.ExitCode ?? -1, processResult?.ErrorData ?? Array.Empty<string>()); return HandleCompletion(throwOnError, processResult?.ExitCode ?? -1, processResult?.ErrorData ?? Array.Empty<string>());
} }
private async Task<IProcessResult> Process(ProcessArguments processArguments, CancellationTokenSource cancellationTokenSource) private async Task<IProcessResult> Process(ProcessArguments processArguments)
{ {
IProcessResult processResult = null!; IProcessResult processResult = null!;
if (_cancelled) if (_cancelled)
{ {
_cancellationTokenRegistration?.Dispose();
throw new OperationCanceledException("cancelled before starting processing"); throw new OperationCanceledException("cancelled before starting processing");
} }
@ -168,9 +171,9 @@ public class FFMpegArgumentProcessor
{ {
instance.SendInput("q"); instance.SendInput("q");
if (!cancellationTokenSource.Token.WaitHandle.WaitOne(timeout, true)) if (!_cancellationTokenSource.Token.WaitHandle.WaitOne(timeout, true))
{ {
cancellationTokenSource.Cancel(); _cancellationTokenSource.Cancel();
instance.Kill(); instance.Kill();
} }
} }
@ -182,13 +185,12 @@ public class FFMpegArgumentProcessor
await Task.WhenAll(instance.WaitForExitAsync().ContinueWith(t => await Task.WhenAll(instance.WaitForExitAsync().ContinueWith(t =>
{ {
processResult = t.Result; processResult = t.Result;
cancellationTokenSource.Cancel(); _cancellationTokenSource.Cancel();
_ffMpegArguments.Post(); _ffMpegArguments.Post();
}), _ffMpegArguments.During(cancellationTokenSource.Token)).ConfigureAwait(false); }), _ffMpegArguments.During(_cancellationTokenSource.Token)).ConfigureAwait(false);
if (_cancelled) if (_cancelled)
{ {
_cancellationTokenRegistration?.Dispose();
throw new OperationCanceledException("ffmpeg processing was cancelled"); throw new OperationCanceledException("ffmpeg processing was cancelled");
} }
@ -197,7 +199,6 @@ public class FFMpegArgumentProcessor
finally finally
{ {
CancelEvent -= OnCancelEvent; CancelEvent -= OnCancelEvent;
_cancellationTokenRegistration?.Dispose();
} }
} }

2
FFMpegCore/FFMpeg/SnapshotArgumentBuilder.cs
View file

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