mirror/FileFlowsPlugins
1
0
Fork 0
mirror of https://github.com/revenz/FileFlowsPlugins.git synced 2025-12-30 16:59:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

fixed video tests

Browse Source
This commit is contained in:
John Andrews
2024-08-28 16:46:55 +12:00
parent 85b9a72183
commit 65785367ff
26 changed files with 1747 additions and 3724 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
VideoNodes/Tests/AudioExtractorTests.cs
View File

@@ -7,24 +7,17 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
[TestClass]
public class AudioExtractorTests : TestBase
public class AudioExtractorTests : VideoTestBase
{
[TestMethod]
public void AudioExtractor_Mp3_Basic()
{
var logger = new TestLogger();
string file = TestFile_BasicMkv;
var vi = new VideoInfoHelper(FfmpegPath, logger);
var vii = vi.Read(file);
var args = GetVideoNodeParameters();
VideoExtractAudio node = new();
node.OutputFile = Path.Combine(TempPath, "Audio");
node.OutputCodec = "mp3";
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vidFile = new VideoFile();
vidFile.PreExecute(args);
Assert.AreEqual(1, vidFile.Execute(args));
@@ -32,27 +25,19 @@ public class AudioExtractorTests : TestBase
node.PreExecute(args);
int output = node.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, output);
}
[TestMethod]
public void AudioExtractor_Mp3_English()
{
var logger = new TestLogger();
string file = TestFile_BasicMkv;
var vi = new VideoInfoHelper(FfmpegPath, logger);
var vii = vi.Read(file);
var args = GetVideoNodeParameters();
VideoExtractAudio node = new();
node.OutputFile = Path.Combine(TempPath, "Audio");
node.Language = "en";
node.OutputCodec = "mp3";
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vidFile = new VideoFile();
vidFile.PreExecute(args);
Assert.AreEqual(1, vidFile.Execute(args));
@@ -60,27 +45,18 @@ public class AudioExtractorTests : TestBase
node.PreExecute(args);
int output = node.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, output);
}
[TestMethod]
public void AudioExtractor_Mp3_Eac3_Fail()
{
var logger = new TestLogger();
string file = TestFile_BasicMkv;
var vi = new VideoInfoHelper(FfmpegPath, logger);
var vii = vi.Read(file);
var args = GetVideoNodeParameters();
VideoExtractAudio node = new();
node.OutputFile = Path.Combine(TempPath, "Audio");
node.Codec = "eac3";
node.OutputCodec = "mp3";
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vidFile = new VideoFile();
vidFile.PreExecute(args);
Assert.AreEqual(1, vidFile.Execute(args));
@@ -88,26 +64,19 @@ public class AudioExtractorTests : TestBase
node.PreExecute(args);
int output = node.Execute(args);
var log = logger.ToString();
Assert.AreEqual(2, output);
}
[TestMethod]
public void AudioExtractor_Mp3_Eac3_Pass()
{
var logger = new TestLogger();
string file = TestFile_Pgs;
var vi = new VideoInfoHelper(FfmpegPath, logger);
var vii = vi.Read(file);
var args = GetVideoNodeParameters();
VideoExtractAudio node = new();
node.OutputFile = Path.Combine(TempPath, "Audio_eac3");
node.Codec = "eac3";
node.OutputCodec = "mp3";
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vidFile = new VideoFile();
vidFile.PreExecute(args);
Assert.AreEqual(1, vidFile.Execute(args));
@@ -115,27 +84,19 @@ public class AudioExtractorTests : TestBase
node.PreExecute(args);
int output = node.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, output);
}
[TestMethod]
public void AudioExtractor_Aac_2048k()
{
var logger = new TestLogger();
string file = TestFile_BasicMkv;
var vi = new VideoInfoHelper(FfmpegPath, logger);
var vii = vi.Read(file);
var args = GetVideoNodeParameters();
VideoExtractAudio node = new();
node.OutputFile = Path.Combine(TempPath, "Audio_2048.aac");
node.OutputCodec = "aac";
node.OutputBitrate = 2048;
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vidFile = new VideoFile();
vidFile.PreExecute(args);
Assert.AreEqual(1, vidFile.Execute(args));
@@ -143,27 +104,19 @@ public class AudioExtractorTests : TestBase
node.PreExecute(args);
int output = node.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, output);
}
[TestMethod]
public void AudioExtractor_Aac_128k()
{
var logger = new TestLogger();
string file = TestFile_BasicMkv;
var vi = new VideoInfoHelper(FfmpegPath, logger);
var vii = vi.Read(file);
var args = GetVideoNodeParameters();
VideoExtractAudio node = new();
node.OutputFile = Path.Combine(TempPath, "Audio_128.aac");
node.OutputCodec = "aac";
node.OutputBitrate = 128;
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vidFile = new VideoFile();
vidFile.PreExecute(args);
Assert.AreEqual(1, vidFile.Execute(args));
@@ -171,7 +124,6 @@ public class AudioExtractorTests : TestBase
node.PreExecute(args);
int output = node.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, output);
}
}

13
VideoNodes/Tests/AudioToVideoTests.cs
View File

@@ -8,7 +8,7 @@ using FileFlows.VideoNodes.VideoNodes;
using Microsoft.VisualStudio.TestTools.UnitTesting;
[TestClass]
public class AudioToVideoTests : TestBase
public class AudioToVideoTests : VideoTestBase
{
[TestMethod]
public void AudioToVideo_Waves_h265()
@@ -27,15 +27,7 @@ public class AudioToVideoTests : TestBase
private void TestStyle(string codec, AudioToVideo.VisualizationStyle style)
{
var logger = new TestLogger();
string file = @"D:\music\unprocessed\01-billy_joel-movin_out.mp3";
var vi = new VideoInfoHelper(FfmpegPath, logger);
var vii = vi.Read(file);
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters(AudioMp3);
AudioToVideo node = new();
node.Container = "mkv";
@@ -48,7 +40,6 @@ public class AudioToVideoTests : TestBase
node.PreExecute(args);
int output = node.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, output);
}
}

9
VideoNodes/Tests/FfmpegBuilderTests/FFmpegBuilder_ErrorFile.cs
View File

@@ -11,7 +11,7 @@ namespace FileFlows.VideoNodes.Tests.FfmpegBuilderTests;
/// Tests for FFmpeg Builder for the Error file
/// </summary>
[TestClass]
public class FFmpegBuild_ErrorFile : TestBase
public class FFmpegBuild_ErrorFile : VideoTestBase
{
/// <summary>
/// Tests a subtitle using a pattern
@@ -19,12 +19,7 @@ public class FFmpegBuild_ErrorFile : TestBase
[TestMethod]
public void ErrorFile()
{
var args = new NodeParameters(TestFile_Error, Logger, false, TestPath, new LocalFileService())
{
LibraryFileName = TestFile_Error
};
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters(VideoCorrupt);
var vf = new VideoFile();
vf.PreExecute(args);

94
VideoNodes/Tests/FfmpegBuilderTests/FFmpegBuilder_SubtitleTrackMergeTests.cs
View File

@@ -10,51 +10,43 @@ namespace FileFlows.VideoNodes.Tests.FfmpegBuilderTests;
/// Tests for FFmpeg Builder Subtitle Track Merge
/// </summary>
[TestClass]
public class FFmpegBuild_SubtitleTrackMergeTests : TestBase
public class FFmpegBuild_SubtitleTrackMergeTests : VideoTestBase
{
/// <summary>
/// Tests a subtitle using a pattern
/// </summary>
[TestMethod]
public void PatternTest()
{
var args = new NodeParameters(TestFile_Subtitle, Logger, false, TestPath, new LocalFileService())
{
LibraryFileName = TestFile_Subtitle
};
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
var ffmpegBuilderStart = new FfmpegBuilderStart();
ffmpegBuilderStart.PreExecute(args);
Assert.AreEqual(1, ffmpegBuilderStart.Execute(args));
int currentSubs = ffmpegBuilderStart.GetModel().SubtitleStreams.Count;
var ele = new FfmpegBuilderSubtitleTrackMerge();
ele.Subtitles = ["srt", "sub", "sup", "ass"];
ele.Pattern = "^other";
ele.Title = "Other Subtitle";
ele.Language = "fre";
ele.Default = true;
ele.Forced = true;
ele.PreExecute(args);
Assert.AreEqual(1, ele.Execute(args));
int newSubs = ffmpegBuilderStart.GetModel().SubtitleStreams.Count;
Assert.AreEqual(currentSubs + 1, newSubs);
var newSub = ffmpegBuilderStart.GetModel().SubtitleStreams.Last();
Assert.AreEqual("Other Subtitle", newSub.Title);
Assert.AreEqual("fre", newSub.Language);
Assert.IsTrue(newSub.IsDefault);
Assert.IsTrue(newSub.IsForced);
}
// /// <summary>
// /// Tests a subtitle using a pattern
// /// </summary>
// [TestMethod]
// public void PatternTest()
// {
// var args = GetVideoNodeParameters();
// var videoFile = new VideoFile();
// videoFile.PreExecute(args);
// videoFile.Execute(args);
//
// var ffmpegBuilderStart = new FfmpegBuilderStart();
// ffmpegBuilderStart.PreExecute(args);
// Assert.AreEqual(1, ffmpegBuilderStart.Execute(args));
//
// int currentSubs = ffmpegBuilderStart.GetModel().SubtitleStreams.Count;
//
// var ele = new FfmpegBuilderSubtitleTrackMerge();
// ele.Subtitles = ["srt", "sub", "sup", "ass"];
// ele.Pattern = "^other";
// ele.Title = "Other Subtitle";
// ele.Default = true;
// ele.Forced = true;
// ele.PreExecute(args);
// Assert.AreEqual(1, ele.Execute(args));
//
// int newSubs = ffmpegBuilderStart.GetModel().SubtitleStreams.Count;
// Assert.AreEqual(currentSubs + 1, newSubs);
//
// var newSub = ffmpegBuilderStart.GetModel().SubtitleStreams.Last();
//
// Assert.AreEqual("Other Subtitle", newSub.Title);
// Assert.IsTrue(newSub.IsDefault);
// Assert.IsTrue(newSub.IsForced);
// }
/// <summary>
/// Tests a subtitle using file matches
@@ -62,16 +54,10 @@ public class FFmpegBuild_SubtitleTrackMergeTests : TestBase
[TestMethod]
public void FileMatches()
{
var args = new NodeParameters(TestFile_Subtitle, Logger, false, TestPath, new LocalFileService())
{
LibraryFileName = TestFile_Subtitle
};
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
var args = GetVideoNodeParameters();
var videoFile = new VideoFile();
videoFile.PreExecute(args);
videoFile.Execute(args);
var ffmpegBuilderStart = new FfmpegBuilderStart();
ffmpegBuilderStart.PreExecute(args);

17
VideoNodes/Tests/FfmpegBuilderTests/FfmpegBuilder_AddAudioTests.cs
View File

@@ -3,19 +3,23 @@
using FileFlows.VideoNodes.FfmpegBuilderNodes;
using FileFlows.VideoNodes.FfmpegBuilderNodes.Models;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using PluginTestLibrary;
using VideoNodes.Tests;
namespace FileFlows.VideoNodes.Tests.FfmpegBuilderTests;
[TestClass]
public class FfmpegBuilder_AddAudioTests : TestBase
public class FfmpegBuilder_AddAudioTests : VideoTestBase
{
VideoInfo vii;
NodeParameters args;
private void Prepare()
{
var vi = new VideoInfoHelper(FfmpegPath, Logger);
vii = vi.Read(TestFile_BasicMkv);
args = GetVideoNodeParameters();
VideoFile vf = new VideoFile();
vf.PreExecute(args);
vf.Execute(args);
vii = (VideoInfo)args.Parameters["VideoInfo"];
vii.AudioStreams = new List<AudioStream>
{
new AudioStream
@@ -51,12 +55,7 @@ public class FfmpegBuilder_AddAudioTests : TestBase
Channels = 5.1f
}
};
args = new NodeParameters(TestFile_BasicMkv, Logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
Assert.AreEqual(1, ffStart.Execute(args));

26
VideoNodes/Tests/FfmpegBuilderTests/FfmpegBuilder_AudioConverterTests.cs
View File

@@ -9,16 +9,17 @@ using System.IO;
namespace FileFlows.VideoNodes.Tests.FfmpegBuilderTests;
[TestClass]
public class FfmpegBuilder_AudioConverterTests: TestBase
public class FfmpegBuilder_AudioConverterTests: VideoTestBase
{
VideoInfo vii;
NodeParameters args;
private void Prepare()
{
string file = Path.Combine(TestPath, "basic.mkv");
var logger = new TestLogger();
var vi = new VideoInfoHelper(FfmpegPath, logger);
vii = vi.Read(file);
args = GetVideoNodeParameters();
VideoFile vf = new VideoFile();
vf.PreExecute(args);
vf.Execute(args);
vii = (VideoInfo)args.Parameters["VideoInfo"];
vii.AudioStreams = new List<AudioStream>
{
new AudioStream
@@ -77,10 +78,6 @@ public class FfmpegBuilder_AudioConverterTests: TestBase
Channels = 5.1f
}
};
args = new NodeParameters(file, logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
@@ -170,13 +167,9 @@ public class FfmpegBuilder_AudioConverterTests: TestBase
[TestMethod]
public void FfmpegBuilder_AudioConverter_Opus_All()
{
string file = Path.Combine(TestPath, "basic.mkv");
var logger = new TestLogger();
var vi = new VideoInfoHelper(FfmpegPath, logger);
var vii = vi.Read(file);
var args = new NodeParameters(file, logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vi = new VideoInfoHelper(FFmpeg, Logger);
var vii = vi.Read(VideoMkv);
var args = GetVideoNodeParameters(VideoMkv);
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
@@ -194,7 +187,6 @@ public class FfmpegBuilder_AudioConverterTests: TestBase
ffExecutor.PreExecute(args);
result = ffExecutor.Execute(args);
string log = logger.ToString();
Assert.AreEqual(1, result);
var newInfo = vi.Read(args.WorkingFile).Value;

1185
VideoNodes/Tests/FfmpegBuilderTests/FfmpegBuilder_BasicTests.cs
View File

File diff suppressed because it is too large Load Diff

30
VideoNodes/Tests/FfmpegBuilderTests/FfmpegBuilder_KeepOriginalLanguageTests.cs
View File

@@ -8,17 +8,20 @@ using VideoNodes.Tests;
namespace FileFlows.VideoNodes.Tests.FfmpegBuilderTests;
[TestClass]
public class FfmpegBuilder_KeepOriginalLanguageTests
public class FfmpegBuilder_KeepOriginalLanguageTests : VideoTestBase
{
VideoInfo vii;
NodeParameters args;
TestLogger logger = new TestLogger();
FfmpegModel Model;
private void Prepare(string german = "deu")
{
const string file = @"D:\videos\unprocessed\basic.mkv";
const string ffmpeg = @"C:\utils\ffmpeg\ffmpeg.exe";
var vi = new VideoInfoHelper(ffmpeg, logger);
vii = vi.Read(file);
args = GetVideoNodeParameters();
VideoFile vf = new VideoFile();
vf.PreExecute(args);
vf.Execute(args);
vii = (VideoInfo)args.Parameters["VideoInfo"];
vii.AudioStreams = new List<AudioStream>
{
new AudioStream
@@ -86,11 +89,6 @@ public class FfmpegBuilder_KeepOriginalLanguageTests
Codec = "AAC"
}
};
args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = @"D:\videos\temp";
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
@@ -112,8 +110,6 @@ public class FfmpegBuilder_KeepOriginalLanguageTests
args.Variables["OriginalLanguage"] = "German";
ffElement.PreExecute(args);
var result = ffElement.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
var kept = model.AudioStreams.Where(x => x.Deleted == false).ToList();
@@ -132,7 +128,6 @@ public class FfmpegBuilder_KeepOriginalLanguageTests
args.Variables["OriginalLanguage"] = "Maori";
ffElement.PreExecute(args);
var result = ffElement.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
@@ -153,7 +148,6 @@ public class FfmpegBuilder_KeepOriginalLanguageTests
args.Variables["OriginalLanguage"] = "French";
ffElement.PreExecute(args);
var result = ffElement.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
@@ -175,8 +169,6 @@ public class FfmpegBuilder_KeepOriginalLanguageTests
args.Variables["OriginalLanguage"] = "German";
ffElement.PreExecute(args);
var result = ffElement.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
var kept = model.AudioStreams.Where(x => x.Deleted == false).ToList();
@@ -199,7 +191,6 @@ public class FfmpegBuilder_KeepOriginalLanguageTests
args.Variables["OriginalLanguage"] = "Maori";
ffElement.PreExecute(args);
var result = ffElement.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
@@ -223,7 +214,6 @@ public class FfmpegBuilder_KeepOriginalLanguageTests
args.Variables["OriginalLanguage"] = "French";
ffElement.PreExecute(args);
var result = ffElement.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
@@ -253,7 +243,6 @@ public class FfmpegBuilder_KeepOriginalLanguageTests
args.Variables["OriginalLanguage"] = "French";
ffElement.PreExecute(args);
var result = ffElement.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
@@ -285,7 +274,6 @@ public class FfmpegBuilder_KeepOriginalLanguageTests
args.Variables["OriginalLanguage"] = "de";
ffElement.PreExecute(args);
var result = ffElement.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, result);
var model = GetFFmpegModel();

78
VideoNodes/Tests/FfmpegBuilderTests/FfmpegBuilder_MetadataTests.cs
View File

@@ -7,23 +7,17 @@ using VideoNodes.Tests;
namespace FileFlows.VideoNodes.Tests.FfmpegBuilderTests;
[TestClass]
public class FfmpegBuilder_MetadataTests: TestBase
public class FfmpegBuilder_MetadataTests: VideoTestBase
{
[TestMethod]
public void FfmpegBuilder_Metadata_Remover_Language()
{
string file = TestFile_MovText_Mp4;
var logger = new TestLogger();
const string ffmpeg = @"C:\utils\ffmpeg\ffmpeg.exe";
var vi = new VideoInfoHelper(ffmpeg, logger);
var vii = vi.Read(file);
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = @"D:\videos\temp";
args.Parameters.Add("VideoInfo", vii);
var args = GetVideoNodeParameters();
var videoFile = new VideoFile();
videoFile.PreExecute(args);
videoFile.Execute(args);
FfmpegBuilderStart ffStart = new ();
ffStart.PreExecute(args);
@@ -42,22 +36,16 @@ public class FfmpegBuilder_MetadataTests: TestBase
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
Assert.AreEqual(1, result);
}
[TestMethod]
public void FfmpegBuilder_Metadata_Remover_Additional()
{
string file = TestFile_MovText_Mp4;
var logger = new TestLogger();
const string ffmpeg = @"C:\utils\ffmpeg\ffmpeg.exe";
var vi = new VideoInfoHelper(ffmpeg, logger);
var vii = vi.Read(file);
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = @"D:\videos\temp";
args.Parameters.Add("VideoInfo", vii);
var args = GetVideoNodeParameters();
var videoFile = new VideoFile();
videoFile.PreExecute(args);
videoFile.Execute(args);
FfmpegBuilderStart ffStart = new();
@@ -74,55 +62,16 @@ public class FfmpegBuilder_MetadataTests: TestBase
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
Assert.AreEqual(1, result);
}
[TestMethod]
public void FfmpegBuilder_Metadata_Remover_Images()
{
string file = TestFile_MovText_Mp4;
var logger = new TestLogger();
const string ffmpeg = @"C:\utils\ffmpeg\ffmpeg.exe";
var vi = new VideoInfoHelper(ffmpeg, logger);
var vii = vi.Read(file);
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = @"D:\videos\temp";
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
Assert.AreEqual(1, ffStart.Execute(args));
FfmpegBuilderMetadataRemover ffMetadata = new();
ffMetadata.RemoveImages = true;
ffMetadata.PreExecute(args);
Assert.AreEqual(1, ffMetadata.Execute(args));
FfmpegBuilderExecutor ffExecutor = new();
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
Assert.AreEqual(1, result);
}
[TestMethod]
public void FfmpegBuilder_Metadata_Remover_BitrateFromConvetted()
{
string file = TestFile_BasicMkv;
var logger = new TestLogger();
var vi = new VideoInfoHelper(FfmpegPath, logger);
var vii = vi.Read(file);
var args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii);
var args = GetVideoNodeParameters();
var videoFile = new VideoFile();
videoFile.PreExecute(args);
videoFile.Execute(args);
FfmpegBuilderStart ffStart = new();
Assert.IsTrue(ffStart.PreExecute(args));
@@ -139,7 +88,6 @@ public class FfmpegBuilder_MetadataTests: TestBase
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
Assert.AreEqual(1, result);
}
}

117
VideoNodes/Tests/FfmpegBuilderTests/FfmpegBuilder_TrackSorterTests.cs
View File

@@ -8,25 +8,24 @@ using VideoNodes.Tests;
namespace FileFlows.VideoNodes.Tests.FfmpegBuilderTests;
[TestClass]
public class FfmpegBuilder_TrackSorterTests
public class FfmpegBuilder_TrackSorterTests : VideoTestBase
{
private TestContext testContextInstance;
public TestContext TestContext
{
get { return testContextInstance; }
set { testContextInstance = value; }
}
VideoInfo vii;
NodeParameters args;
TestLogger logger = new TestLogger();
protected override void TestStarting()
{
Prepare();
}
private void Prepare(string german = "deu")
{
const string file = @"D:\videos\unprocessed\basic.mkv";
const string ffmpeg = @"C:\utils\ffmpeg\ffmpeg.exe";
var vi = new VideoInfoHelper(ffmpeg, logger);
vii = vi.Read(file);
args = GetVideoNodeParameters();
VideoFile vf = new VideoFile();
vf.PreExecute(args);
vf.Execute(args);
vii = (VideoInfo)args.Parameters["VideoInfo"];
vii.AudioStreams = new List<AudioStream>
{
new AudioStream
@@ -95,11 +94,6 @@ public class FfmpegBuilder_TrackSorterTests
Codec = "movtext"
}
};
args = new NodeParameters(file, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = @"D:\videos\temp";
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
@@ -116,7 +110,6 @@ public class FfmpegBuilder_TrackSorterTests
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -135,8 +128,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(3, sorted[0].Index);
@@ -154,8 +145,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnChannels()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -172,8 +161,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var result = trackSorter.ProcessStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(2, streams[0].Index);
@@ -181,7 +168,7 @@ public class FfmpegBuilder_TrackSorterTests
Assert.AreEqual(1, streams[2].Index);
// Additional assertions for logging
Assert.AreEqual("2 / fr / aac / 5.1 / Default", streams[0].ToString());
Assert.AreEqual("2 / fr / aac / 5.1", streams[0].ToString());
Assert.AreEqual("3 / en / ac3 / 7.1", streams[1].ToString());
Assert.AreEqual("1 / en / aac / 2.0", streams[2].ToString());
}
@@ -190,8 +177,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnLanguageThenCodec()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -209,8 +194,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var result = trackSorter.ProcessStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(3, streams[0].Index);
@@ -218,7 +201,7 @@ public class FfmpegBuilder_TrackSorterTests
Assert.AreEqual(2, streams[2].Index);
// Additional assertions for logging
Assert.AreEqual("3 / en / ac3 / 7.1 / Default", streams[0].ToString());
Assert.AreEqual("3 / en / ac3 / 7.1", streams[0].ToString());
Assert.AreEqual("1 / en / aac / 2.0", streams[1].ToString());
Assert.AreEqual("2 / fr / aac / 5.1", streams[2].ToString());
}
@@ -227,8 +210,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnCustomMathOperation()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -245,8 +226,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var result = trackSorter.ProcessStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(2, streams[0].Index);
@@ -254,7 +233,7 @@ public class FfmpegBuilder_TrackSorterTests
Assert.AreEqual(1, streams[2].Index);
// Additional assertions for logging
Assert.AreEqual("2 / fr / aac / 5.1 / Default", streams[0].ToString());
Assert.AreEqual("2 / fr / aac / 5.1", streams[0].ToString());
Assert.AreEqual("3 / en / ac3 / 7.1", streams[1].ToString());
Assert.AreEqual("1 / en / aac / 2.0", streams[2].ToString());
}
@@ -264,8 +243,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnRegex()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -282,8 +259,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var result = trackSorter.ProcessStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(1, streams[0].Index);
@@ -291,7 +266,7 @@ public class FfmpegBuilder_TrackSorterTests
Assert.AreEqual(2, streams[2].Index);
// Additional assertions for logging
Assert.AreEqual("1 / en / ac3 / 2.0 / Default", streams[0].ToString());
Assert.AreEqual("1 / en / ac3 / 2.0", streams[0].ToString());
Assert.AreEqual("3 / en / ac3 / 7.1", streams[1].ToString());
Assert.AreEqual("2 / fr / eac3 / 5.1", streams[2].ToString());
}
@@ -300,8 +275,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnMultipleSorters()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -327,8 +300,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var result = trackSorter.ProcessStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
@@ -358,8 +329,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnBitrate()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -377,8 +346,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(3, sorted[0].Index);
@@ -397,8 +364,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnChannelsAsc()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -417,8 +382,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(1, sorted[0].Index);
@@ -439,8 +402,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnChannelsDesc()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -458,9 +419,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(3, sorted[0].Index);
Assert.AreEqual(4, sorted[1].Index);
@@ -479,8 +437,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnBitrateInvert()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -498,8 +454,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(2, sorted[0].Index);
@@ -518,8 +472,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnBitrateAndCodec()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -538,8 +490,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(4, sorted[0].Index);
@@ -563,8 +513,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnBitrateUnit()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -582,8 +530,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(2, sorted[0].Index);
@@ -603,8 +549,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnLanguage()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -625,8 +569,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(1, sorted[0].Index);
@@ -656,8 +598,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnLanguageRegex()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -678,8 +618,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(1, sorted[0].Index);
@@ -708,8 +646,6 @@ public class FfmpegBuilder_TrackSorterTests
public void ProcessStreams_SortsStreamsBasedOnLanguageRegexOriginal()
{
// Arrange
var args = new NodeParameters(logger);
var trackSorter = new FfmpegBuilderTrackSorter();
List<FfmpegAudioStream> streams = new List<FfmpegAudioStream>
{
@@ -732,8 +668,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
var sorted = trackSorter.SortStreams(args, streams);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(4, sorted[0].Index);
@@ -778,15 +712,13 @@ public class FfmpegBuilder_TrackSorterTests
trackSorter.PreExecute(args);
var result = trackSorter.Execute(args);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
// Additional assertions for logging
Assert.AreEqual("0 / en / AC3 / 5.1 / Default", model.AudioStreams[0].ToString());
Assert.AreEqual("0 / en / AC3 / 5.1", model.AudioStreams[0].ToString());
Assert.AreEqual("3 / deu / AAC / 5.1", model.AudioStreams[1].ToString());
Assert.AreEqual("1 / en / AAC / Directors Commentary / 2.0", model.AudioStreams[2].ToString());
Assert.AreEqual("2 / fre / AAC / 2.0", model.AudioStreams[3].ToString());
@@ -810,16 +742,13 @@ public class FfmpegBuilder_TrackSorterTests
// Act
trackSorter.PreExecute(args);
var result = trackSorter.Execute(args);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
// Additional assertions for logging
Assert.AreEqual("2 / fre / srt / Default", model.SubtitleStreams[0].ToString());
Assert.AreEqual("2 / fre / srt", model.SubtitleStreams[0].ToString());
Assert.AreEqual("3 / deu / movtext", model.SubtitleStreams[1].ToString());
Assert.AreEqual("0 / en / movtext", model.SubtitleStreams[2].ToString());
Assert.AreEqual("1 / en / subrip", model.SubtitleStreams[3].ToString());
@@ -843,9 +772,6 @@ public class FfmpegBuilder_TrackSorterTests
// Act
trackSorter.PreExecute(args);
var result = trackSorter.Execute(args);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(1, result);
@@ -877,16 +803,13 @@ public class FfmpegBuilder_TrackSorterTests
// Act
trackSorter.PreExecute(args);
var result = trackSorter.Execute(args);
string log = logger.ToString();
TestContext.WriteLine(log);
// Assert
Assert.AreEqual(1, result);
var model = GetFFmpegModel();
// Additional assertions for logging
Assert.AreEqual("0 / en / AC3 / 5.1 / Default", model.AudioStreams[0].ToString());
Assert.AreEqual("0 / en / AC3 / 5.1", model.AudioStreams[0].ToString());
Assert.AreEqual("2 / fre / AAC / 2.0", model.AudioStreams[1].ToString());
Assert.AreEqual("3 / deu / AAC / 5.1", model.AudioStreams[2].ToString());
Assert.AreEqual("1 / en / AAC / Directors Commentary / 2.0", model.AudioStreams[3].ToString());

606
VideoNodes/Tests/FfmpegBuilderTests/FfmpegBuilder_VideoEncodeTests.cs
View File

@@ -1,303 +1,303 @@
#if(DEBUG)
using FileFlows.VideoNodes.FfmpegBuilderNodes;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using VideoNodes.Tests;
using System.IO;
using FileFlows.VideoNodes.Helpers;
namespace FileFlows.VideoNodes.Tests.FfmpegBuilderTests;
[TestClass]
public class FfmpegBuilder_VideoEncode_VideoEncodeTests: TestBase
{
private (int output, string log) Encode(string codec, int quality, bool hardwareEncoding, string file, string outfile)
{
if (File.Exists(file) == false)
throw new FileNotFoundException(file);
var logger = new TestLogger();
string ffmpeg = FfmpegPath;
var vi = new VideoInfoHelper(ffmpeg, logger);
var vii = vi.Read(file);
var args = new NodeParameters(file, logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
Assert.AreEqual(1, ffStart.Execute(args));
FfmpegBuilderVideoEncode ffEncode = new();
//ffEncode.Encoder = "VAAPI";
//ffEncode.Encoder = "NVIDIA";
// ffEncode.Encoder = "Intel QSV";
ffEncode.Codec = codec;
ffEncode.Quality = quality;
//ffEncode.HardwareEncoding = hardwareEncoding;
ffEncode.PreExecute(args);
ffEncode.Execute(args);
FfmpegBuilderScaler scaler = new();
scaler.Resolution = "1280:-2";
scaler.Force = true;
scaler.PreExecute(args);
Assert.AreEqual(1, scaler.Execute(args));
FfmpegBuilderExecutor ffExecutor = new();
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
if(args.WorkingFile.StartsWith(args.TempPath))
File.Move(args.WorkingFile, FileHelper.Combine(args.TempPath, outfile), true);
Assert.AreEqual(1, result);
return (result, log);
}
private void TestEncode(bool h265, bool bit10, bool hardware)
{
foreach (var quality in new int[] { 18, 20, 23, 28, 35, 50 })
{
string codec = h265 && bit10 ? FfmpegBuilderVideoEncode.CODEC_H265_10BIT :
h265 ? FfmpegBuilderVideoEncode.CODEC_H265 :
FfmpegBuilderVideoEncode.CODEC_H264;
var result = Encode(codec, quality, hardware, TestFile_Sitcom,
$"{(hardware ? "nvidia" : "cpu")}_h26{(h265 ? "5" : "4")}{(bit10 ? "_10bit" : "")}_{quality}.mkv");
}
}
[TestMethod]
public void FfmpegBuilder_VideoEncode_H265_10bit_Hardware() => TestEncode(true, true, true);
[TestMethod]
public void FfmpegBuilder_VideoEncode_H265_Hardware() => TestEncode(true, false, true);
[TestMethod]
public void FfmpegBuilder_VideoEncode_H265() => TestEncode(true, false, false);
[TestMethod]
public void FfmpegBuilder_VideoEncode_H265_10bit() => TestEncode(true, false, true);
[TestMethod]
public void FfmpegBuilder_VideoEncode_H264_Hardware() => TestEncode(false, false, true);
[TestMethod]
public void FfmpegBuilder_VideoEncode_H264() => TestEncode(false, false, false);
[TestMethod]
public void FfmpegBuilder_VideoEncode_FailIfNoHardware()
{
var logger = new TestLogger();
string ffmpeg = FfmpegPath;
var vi = new VideoInfoHelper(ffmpeg, logger);
var vii = vi.Read(TestFile_120_mbps_4k_uhd_hevc_10bit);
var args = new NodeParameters(TestFile_50_mbps_hd_h264, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
Assert.AreEqual(1, ffStart.Execute(args));
FfmpegBuilderVideoCodec ffCodec = new();
ffCodec.VideoCodec = "h265";
ffCodec.VideoCodecParameters = "hevc_qsv";
ffCodec.PreExecute(args);
ffCodec.Execute(args);
FfmpegBuilderExecutor ffExecutor = new();
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
Assert.AreEqual(-1, result);
}
[TestMethod]
public void FfmpegBuilder_VideoEncode_AutoUseHardware()
{
var logger = new TestLogger();
string ffmpeg = FfmpegPath;
var vi = new VideoInfoHelper(ffmpeg, logger);
var vii = vi.Read(TestFile_BasicMkv);
var args = new NodeParameters(TestFile_BasicMkv, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
Assert.AreEqual(1, ffStart.Execute(args));
FfmpegBuilderVideoCodec ffCodec = new();
ffCodec.VideoCodec = "h265";
ffCodec.VideoCodecParameters = "h265";
ffCodec.PreExecute(args);
ffCodec.Execute(args);
FfmpegBuilderExecutor ffExecutor = new();
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
Assert.AreEqual(1, result);
}
[TestMethod]
public void FfmpegBuilder_VideoEncode_QSV()
{
var logger = new TestLogger();
string ffmpeg = FfmpegPath;
var vi = new VideoInfoHelper(ffmpeg, logger);
var vii = vi.Read(TestFile_BasicMkv);
var args = new NodeParameters(TestFile_BasicMkv, logger, false, string.Empty, null);
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
Assert.AreEqual(1, ffStart.Execute(args));
FfmpegBuilderVideoEncode ffEncode = new();
ffEncode.Quality = 28;
ffEncode.Speed = "ultrafast";
ffEncode.Encoder = "Intel QSV";
ffEncode.Codec = "h265";
ffEncode.PreExecute(args);
ffEncode.Execute(args);
FfmpegBuilderExecutor ffExecutor = new();
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
Assert.AreEqual(1, result);
}
[TestMethod]
public void FfmpegBuilder_VideoEncode_Av1()
{
var logger = new TestLogger();
string ffmpeg = FfmpegPath;
var vi = new VideoInfoHelper(ffmpeg, logger);
var vii = vi.Read(TestFile_BasicMkv);
var args = new NodeParameters(TestFile_BasicMkv, logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
Assert.AreEqual(1, ffStart.Execute(args));
FfmpegBuilderVideoEncode ffEncode = new();
ffEncode.Quality = 28;
ffEncode.Speed = "veryslow";
//ffEncode.Encoder = "Nvid;
ffEncode.Codec = "av1 10BIT";
ffEncode.PreExecute(args);
ffEncode.Execute(args);
FfmpegBuilderExecutor ffExecutor = new();
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
Assert.AreEqual(1, result);
}
[TestMethod]
public void FfmpegBuilder_VideoEncode_Watermark()
{
var logger = new TestLogger();
string ffmpeg = FfmpegPath;
var vi = new VideoInfoHelper(ffmpeg, logger);
var vii = vi.Read(TestFile_BasicMkv);
var args = new NodeParameters(TestFile_BasicMkv, logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
Assert.AreEqual(1, ffStart.Execute(args));
FfmpegBuilderVideoEncode ffEncode = new();
ffEncode.Quality = 28;
ffEncode.Encoder = "CPU";
ffEncode.Speed = "fast";
ffEncode.Codec = "av1";
ffEncode.PreExecute(args);
ffEncode.Execute(args);
FFmpegBuilderWatermark ffWatermark = new();
ffWatermark.Image = "/home/john/Videos/watermark.png";
ffWatermark.Position = FFmpegBuilderWatermark.WatermarkPosition.BottomRight;
ffWatermark.Height = new();
ffWatermark.Width = new() { Value = 5, Percentage = true};
ffWatermark.XPos = new() { Value = 10, Percentage = true };
ffWatermark.YPos = new() { Value = 5, Percentage = true };
ffWatermark.Opacity = 50;
ffWatermark.PreExecute(args);
ffWatermark.Execute(args);
FfmpegBuilderExecutor ffExecutor = new();
ffExecutor.HardwareDecoding = false;
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
string log = logger.ToString();
TestContext.WriteLine(log);
Assert.AreEqual(1, result);
}
[TestMethod]
public void FfmpegBuilder_VideoEncode_WebVTT()
{
string ffmpeg = FfmpegPath;
var vi = new VideoInfoHelper(ffmpeg, Logger);
var vii = vi.Read(TestFile_Webvtt);
var args = new NodeParameters(TestFile_Webvtt, Logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => ffmpeg;
args.TempPath = TempPath;
args.Parameters.Add("VideoInfo", vii.Value);
FfmpegBuilderStart ffStart = new();
ffStart.PreExecute(args);
Assert.AreEqual(1, ffStart.Execute(args));
FfmpegBuilderVideoEncode ffEncode = new();
ffEncode.Quality = 28;
ffEncode.Speed = "fast";
//ffEncode.Encoder = "CPU";
ffEncode.Codec = "h265";
ffEncode.PreExecute(args);
ffEncode.Execute(args);
FfmpegBuilderSubtitleFormatRemover remover = new();
remover.SubtitlesToRemove = ["webvtt"];
remover.PreExecute(args);
remover.Execute(args);
// FFmpegBuilderDurationStart ds = new();
// ds.Start = new TimeSpan(0, 0, 0);
// ds.Duration = new TimeSpan(0, 1, 0);
// ds.PreExecute(args);
// ds.Execute(args);
FfmpegBuilderExecutor ffExecutor = new();
ffExecutor.Strictness = "experimental";
ffExecutor.PreExecute(args);
int result = ffExecutor.Execute(args);
Assert.AreEqual(1, result);
}
}
#endif
// #if(DEBUG)
//
// using FileFlows.VideoNodes.FfmpegBuilderNodes;
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using VideoNodes.Tests;
// using System.IO;
// using FileFlows.VideoNodes.Helpers;
//
// namespace FileFlows.VideoNodes.Tests.FfmpegBuilderTests;
//
// [TestClass]
// public class FfmpegBuilder_VideoEncode_VideoEncodeTests: VideoTestBase
// {
// private (int output, string log) Encode(string codec, int quality, bool hardwareEncoding, string file, string outfile)
// {
// if (File.Exists(file) == false)
// throw new FileNotFoundException(file);
//
// var logger = new TestLogger();
// string ffmpeg = FfmpegPath;
// var vi = new VideoInfoHelper(ffmpeg, logger);
// var vii = vi.Read(file);
// var args = new NodeParameters(file, logger, false, string.Empty, new LocalFileService());
// args.GetToolPathActual = (string tool) => ffmpeg;
// args.TempPath = TempPath;
// args.Parameters.Add("VideoInfo", vii);
//
//
// FfmpegBuilderStart ffStart = new();
// ffStart.PreExecute(args);
// Assert.AreEqual(1, ffStart.Execute(args));
//
// FfmpegBuilderVideoEncode ffEncode = new();
// //ffEncode.Encoder = "VAAPI";
// //ffEncode.Encoder = "NVIDIA";
// // ffEncode.Encoder = "Intel QSV";
// ffEncode.Codec = codec;
// ffEncode.Quality = quality;
// //ffEncode.HardwareEncoding = hardwareEncoding;
// ffEncode.PreExecute(args);
// ffEncode.Execute(args);
//
// FfmpegBuilderScaler scaler = new();
// scaler.Resolution = "1280:-2";
// scaler.Force = true;
// scaler.PreExecute(args);
// Assert.AreEqual(1, scaler.Execute(args));
//
// FfmpegBuilderExecutor ffExecutor = new();
// ffExecutor.PreExecute(args);
// int result = ffExecutor.Execute(args);
// string log = logger.ToString();
// if(args.WorkingFile.StartsWith(args.TempPath))
// File.Move(args.WorkingFile, FileHelper.Combine(args.TempPath, outfile), true);
// Assert.AreEqual(1, result);
// return (result, log);
// }
//
// private void TestEncode(bool h265, bool bit10, bool hardware)
// {
// foreach (var quality in new int[] { 18, 20, 23, 28, 35, 50 })
// {
// string codec = h265 && bit10 ? FfmpegBuilderVideoEncode.CODEC_H265_10BIT :
// h265 ? FfmpegBuilderVideoEncode.CODEC_H265 :
// FfmpegBuilderVideoEncode.CODEC_H264;
//
// var result = Encode(codec, quality, hardware, TestFile_Sitcom,
// $"{(hardware ? "nvidia" : "cpu")}_h26{(h265 ? "5" : "4")}{(bit10 ? "_10bit" : "")}_{quality}.mkv");
// }
//
// }
//
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_H265_10bit_Hardware() => TestEncode(true, true, true);
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_H265_Hardware() => TestEncode(true, false, true);
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_H265() => TestEncode(true, false, false);
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_H265_10bit() => TestEncode(true, false, true);
//
//
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_H264_Hardware() => TestEncode(false, false, true);
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_H264() => TestEncode(false, false, false);
//
//
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_FailIfNoHardware()
// {
// var logger = new TestLogger();
// string ffmpeg = FfmpegPath;
// var vi = new VideoInfoHelper(ffmpeg, logger);
// var vii = vi.Read(TestFile_120_mbps_4k_uhd_hevc_10bit);
// var args = new NodeParameters(TestFile_50_mbps_hd_h264, logger, false, string.Empty, null);
// args.GetToolPathActual = (string tool) => ffmpeg;
// args.TempPath = TempPath;
// args.Parameters.Add("VideoInfo", vii);
//
//
// FfmpegBuilderStart ffStart = new();
// ffStart.PreExecute(args);
// Assert.AreEqual(1, ffStart.Execute(args));
//
// FfmpegBuilderVideoCodec ffCodec = new();
// ffCodec.VideoCodec = "h265";
// ffCodec.VideoCodecParameters = "hevc_qsv";
// ffCodec.PreExecute(args);
// ffCodec.Execute(args);
//
// FfmpegBuilderExecutor ffExecutor = new();
// ffExecutor.PreExecute(args);
// int result = ffExecutor.Execute(args);
// string log = logger.ToString();
// Assert.AreEqual(-1, result);
//
// }
//
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_AutoUseHardware()
// {
// var logger = new TestLogger();
// string ffmpeg = FfmpegPath;
// var vi = new VideoInfoHelper(ffmpeg, logger);
// var vii = vi.Read(VideoMkv);
// var args = new NodeParameters(VideoMkv, logger, false, string.Empty, null);
// args.GetToolPathActual = (string tool) => ffmpeg;
// args.TempPath = TempPath;
// args.Parameters.Add("VideoInfo", vii);
//
// FfmpegBuilderStart ffStart = new();
// ffStart.PreExecute(args);
// Assert.AreEqual(1, ffStart.Execute(args));
//
// FfmpegBuilderVideoCodec ffCodec = new();
// ffCodec.VideoCodec = "h265";
// ffCodec.VideoCodecParameters = "h265";
// ffCodec.PreExecute(args);
// ffCodec.Execute(args);
//
// FfmpegBuilderExecutor ffExecutor = new();
// ffExecutor.PreExecute(args);
// int result = ffExecutor.Execute(args);
// string log = logger.ToString();
// Assert.AreEqual(1, result);
// }
//
//
//
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_QSV()
// {
// var logger = new TestLogger();
// string ffmpeg = FfmpegPath;
// var vi = new VideoInfoHelper(ffmpeg, logger);
// var vii = vi.Read(VideoMkv);
// var args = new NodeParameters(VideoMkv, logger, false, string.Empty, null);
// args.GetToolPathActual = (string tool) => ffmpeg;
// args.TempPath = TempPath;
// args.Parameters.Add("VideoInfo", vii);
//
// FfmpegBuilderStart ffStart = new();
// ffStart.PreExecute(args);
// Assert.AreEqual(1, ffStart.Execute(args));
//
// FfmpegBuilderVideoEncode ffEncode = new();
// ffEncode.Quality = 28;
// ffEncode.Speed = "ultrafast";
// ffEncode.Encoder = "Intel QSV";
// ffEncode.Codec = "h265";
// ffEncode.PreExecute(args);
// ffEncode.Execute(args);
//
// FfmpegBuilderExecutor ffExecutor = new();
// ffExecutor.PreExecute(args);
// int result = ffExecutor.Execute(args);
// string log = logger.ToString();
// Assert.AreEqual(1, result);
// }
//
//
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_Av1()
// {
// var logger = new TestLogger();
// string ffmpeg = FfmpegPath;
// var vi = new VideoInfoHelper(ffmpeg, logger);
// var vii = vi.Read(VideoMkv);
// var args = new NodeParameters(VideoMkv, logger, false, string.Empty, new LocalFileService());
// args.GetToolPathActual = (string tool) => ffmpeg;
// args.TempPath = TempPath;
// args.Parameters.Add("VideoInfo", vii);
//
// FfmpegBuilderStart ffStart = new();
// ffStart.PreExecute(args);
// Assert.AreEqual(1, ffStart.Execute(args));
//
// FfmpegBuilderVideoEncode ffEncode = new();
// ffEncode.Quality = 28;
// ffEncode.Speed = "veryslow";
// //ffEncode.Encoder = "Nvid;
// ffEncode.Codec = "av1 10BIT";
// ffEncode.PreExecute(args);
// ffEncode.Execute(args);
//
// FfmpegBuilderExecutor ffExecutor = new();
// ffExecutor.PreExecute(args);
// int result = ffExecutor.Execute(args);
// string log = logger.ToString();
// Assert.AreEqual(1, result);
// }
//
//
//
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_Watermark()
// {
// var logger = new TestLogger();
// string ffmpeg = FfmpegPath;
// var vi = new VideoInfoHelper(ffmpeg, logger);
// var vii = vi.Read(VideoMkv);
// var args = new NodeParameters(VideoMkv, logger, false, string.Empty, new LocalFileService());
// args.GetToolPathActual = (string tool) => ffmpeg;
// args.TempPath = TempPath;
// args.Parameters.Add("VideoInfo", vii);
//
// FfmpegBuilderStart ffStart = new();
// ffStart.PreExecute(args);
// Assert.AreEqual(1, ffStart.Execute(args));
//
// FfmpegBuilderVideoEncode ffEncode = new();
// ffEncode.Quality = 28;
// ffEncode.Encoder = "CPU";
// ffEncode.Speed = "fast";
// ffEncode.Codec = "av1";
// ffEncode.PreExecute(args);
// ffEncode.Execute(args);
//
// FFmpegBuilderWatermark ffWatermark = new();
// ffWatermark.Image = "/home/john/Videos/watermark.png";
// ffWatermark.Position = FFmpegBuilderWatermark.WatermarkPosition.BottomRight;
// ffWatermark.Height = new();
// ffWatermark.Width = new() { Value = 5, Percentage = true};
// ffWatermark.XPos = new() { Value = 10, Percentage = true };
// ffWatermark.YPos = new() { Value = 5, Percentage = true };
// ffWatermark.Opacity = 50;
//
// ffWatermark.PreExecute(args);
// ffWatermark.Execute(args);
//
// FfmpegBuilderExecutor ffExecutor = new();
// ffExecutor.HardwareDecoding = false;
// ffExecutor.PreExecute(args);
// int result = ffExecutor.Execute(args);
// string log = logger.ToString();
// TestContext.WriteLine(log);
// Assert.AreEqual(1, result);
// }
//
// [TestMethod]
// public void FfmpegBuilder_VideoEncode_WebVTT()
// {
// string ffmpeg = FfmpegPath;
// var vi = new VideoInfoHelper(ffmpeg, Logger);
// var vii = vi.Read(TestFile_Webvtt);
// var args = new NodeParameters(TestFile_Webvtt, Logger, false, string.Empty, new LocalFileService());
// args.GetToolPathActual = (string tool) => ffmpeg;
// args.TempPath = TempPath;
// args.Parameters.Add("VideoInfo", vii.Value);
//
// FfmpegBuilderStart ffStart = new();
// ffStart.PreExecute(args);
// Assert.AreEqual(1, ffStart.Execute(args));
//
// FfmpegBuilderVideoEncode ffEncode = new();
// ffEncode.Quality = 28;
// ffEncode.Speed = "fast";
// //ffEncode.Encoder = "CPU";
// ffEncode.Codec = "h265";
// ffEncode.PreExecute(args);
// ffEncode.Execute(args);
//
// FfmpegBuilderSubtitleFormatRemover remover = new();
// remover.SubtitlesToRemove = ["webvtt"];
// remover.PreExecute(args);
// remover.Execute(args);
//
// // FFmpegBuilderDurationStart ds = new();
// // ds.Start = new TimeSpan(0, 0, 0);
// // ds.Duration = new TimeSpan(0, 1, 0);
// // ds.PreExecute(args);
// // ds.Execute(args);
//
// FfmpegBuilderExecutor ffExecutor = new();
// ffExecutor.Strictness = "experimental";
// ffExecutor.PreExecute(args);
// int result = ffExecutor.Execute(args);
// Assert.AreEqual(1, result);
// }
// }
//
// #endif

BIN
VideoNodes/Tests/Resources/audio.mp3 Normal file
View File

Binary file not shown.

BIN
VideoNodes/Tests/Resources/corrupt.mkv Normal file
View File

Binary file not shown.

80
VideoNodes/Tests/SubtitleExtractorTests.cs
View File

@@ -8,82 +8,28 @@ using VideoFile = FileFlows.VideoNodes.VideoFile;
namespace VideoNodes.Tests;
[TestClass]
public class SubtitleExtractorTests: TestBase
public class SubtitleExtractorTests: VideoTestBase
{
[TestMethod]
public void SubtitleExtractor_Extension_Test()
{
string file = TestFile_BasicMkv;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
foreach (string ext in new[] { String.Empty, ".srt", ".sup" })
{
SubtitleExtractor node = new();
node.OutputFile = Path.Combine(TempPath, "subtitle.en" + ext);
node.Language = "eng";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
Assert.AreEqual(1, new VideoFile().Execute(args));
int output = node.Execute(args);
Assert.AreEqual(1, output);
}
}
[TestMethod]
public void SubtitleExtractor_Pgs_Test()
{
string file = TestFile_Pgs;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
foreach (string ext in new[] { string.Empty, ".srt", ".sup" })
{
SubtitleExtractor node = new();
node.ForcedOnly = true;
node.OutputFile = Path.Combine(TempPath, "subtitle.en" + ext);
node.Language = "eng";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
Assert.AreEqual(1, output);
}
}
[TestMethod]
public void Webvtt_Extract()
{
string file = TestFile_Webvtt;
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, new LocalFileService());;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters(VideoMkv);
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
foreach (string ext in new[] { string.Empty, ".srt", ".sup" })
{
Logger.ILog("Extracting Extension: " + ext);
SubtitleExtractor element = new();
element.OutputFile = Path.Combine(TempPath, "subtitle.en" + ext);
element.Language = "eng";
SubtitleExtractor extractor = new();
extractor.OutputFile = Path.Combine(TempPath, "subtitle.srt");
extractor.ExtractAll = true;
extractor.PreExecute(args);
int output = extractor.Execute(args);
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(1, output);
Assert.AreEqual(1, output);
}
}
}

80
VideoNodes/Tests/TestLogger.cs
View File

@@ -1,80 +0,0 @@
#if(DEBUG)
namespace VideoNodes.Tests;
/// <summary>
/// A logger for tests that stores the logs in memory
/// </summary>
public class TestLogger : ILogger
{
private readonly List<string> Messages = new();
/// <summary>
/// Writes an information log message
/// </summary>
/// <param name="args">the log parameters</param>
public void ILog(params object[] args)
=> Log(LogType.Info, args);
/// <summary>
/// Writes an debug log message
/// </summary>
/// <param name="args">the log parameters</param>
public void DLog(params object[] args)
=> Log(LogType.Debug, args);
/// <summary>
/// Writes an warning log message
/// </summary>
/// <param name="args">the log parameters</param>
public void WLog(params object[] args)
=> Log(LogType.Warning, args);
/// <summary>
/// Writes an error log message
/// </summary>
/// <param name="args">the log parameters</param>
public void ELog(params object[] args)
=> Log(LogType.Error, args);
/// <summary>
/// Gets the tail of the log
/// </summary>
/// <param name="length">the number of messages to get</param>
public string GetTail(int length = 50)
{
if (Messages.Count <= length)
return string.Join(Environment.NewLine, Messages);
return string.Join(Environment.NewLine, Messages.TakeLast(50));
}
/// <summary>
/// Logs a message
/// </summary>
/// <param name="type">the type of log to record</param>
/// <param name="args">the arguments of the message</param>
private void Log(LogType type, params object[] args)
{
string message = type + " -> " + string.Join(", ", args.Select(x =>
x == null ? "null" :
x.GetType().IsPrimitive ? x.ToString() :
x is string ? x.ToString() :
System.Text.Json.JsonSerializer.Serialize(x)));
Writer?.Invoke(message);
Messages.Add(message);
}
/// <summary>
/// Gets or sets an optional writer
/// </summary>
public Action<string> Writer { get; set; }
/// <summary>
/// Returns the entire log as a string
/// </summary>
/// <returns>the entire log</returns>
public override string ToString()
=> string.Join(Environment.NewLine, Messages);
}
#endif

262
VideoNodes/Tests/VaapiAdjustmentTests.cs
View File

@@ -1,129 +1,133 @@
#if(DEBUG)
using FileFlows.VideoNodes.FfmpegBuilderNodes.EncoderAdjustments;
using FileFlows.VideoNodes.FfmpegBuilderNodes.Models;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace VideoNodes.Tests;
[TestClass]
public class VaapiAdjustmentTests: TestBase
{
[TestMethod]
public void Vaapi_CropAndScale()
{
var inputParameters = new List<string>
{
"-fflags",
"+genpts",
"-probesize",
"5M",
"-i",
"/media/Encodes/None Scene Release/Masters.of.the.Air.S01E01.Part.One.1080p.mkv",
"-y",
"-movflags",
"+faststart",
"-map_metadata",
"-1",
"-map",
"0:v:0",
"-c:v:0",
"h264_vaapi",
"-qp",
"23",
"-preset",
"slower",
"-spatial-aq",
"1",
"-filter:v:0",
"crop=1904:800:8:2, scale=1280:-2:flags=lanczos",
"-metadata:s:v:0",
"title=",
"-map",
"0:a:0",
"-c:a:0",
"aac",
"-ac:a:0",
"2",
"-b:a:0",
"160k",
"-metadata:s:a:0",
"BPS=160000",
"-ar:a:0",
"48000",
"-filter:a:0",
"loudnorm=print_format=summary:linear=true:I=-24:LRA=7:TP=-2.0:measured_I=-18.14:measured_LRA=5.20:measured_tp=-4.31:measured_thresh=-28.14:offset=0.56, volume=.7",
"-metadata:s:a:0",
"title=Stereo",
"-metadata:s:a:0",
"language=eng"
};
var logger = new TestLogger();
var updated = new VaapiAdjustments().Run(logger, null!, inputParameters);
Assert.AreEqual("-vf", updated[9]);
Assert.AreEqual("format=nv12,hwupload,scale_vaapi=1280:-2", updated[10]);
int index = updated.FindIndex(x => x.StartsWith("-filter:v"));
Assert.IsTrue(index > 0);
Assert.AreEqual("crop=1904:800:8:2", updated[index + 1]);
}
[TestMethod]
public void Vaapi_Scale()
{
var inputParameters = new List<string>
{
"-fflags",
"+genpts",
"-probesize",
"5M",
"-i",
"/media/Encodes/None Scene Release/Masters.of.the.Air.S01E01.Part.One.1080p.mkv",
"-y",
"-movflags",
"+faststart",
"-map_metadata",
"-1",
"-map",
"0:v:0",
"-c:v:0",
"h264_vaapi",
"-qp",
"23",
"-preset",
"slower",
"-spatial-aq",
"1",
"-filter:v:0",
"scale=1280:-2:flags=lanczos",
"-metadata:s:v:0",
"title=",
"-map",
"0:a:0",
"-c:a:0",
"aac",
"-ac:a:0",
"2",
"-b:a:0",
"160k",
"-metadata:s:a:0",
"BPS=160000",
"-ar:a:0",
"48000",
"-filter:a:0",
"loudnorm=print_format=summary:linear=true:I=-24:LRA=7:TP=-2.0:measured_I=-18.14:measured_LRA=5.20:measured_tp=-4.31:measured_thresh=-28.14:offset=0.56, volume=.7",
"-metadata:s:a:0",
"title=Stereo",
"-metadata:s:a:0",
"language=eng"
};
var logger = new TestLogger();
var updated = new VaapiAdjustments().Run(logger, null!, inputParameters);
Assert.AreEqual("-vf", updated[9]);
Assert.AreEqual("format=nv12,hwupload,scale_vaapi=1280:-2", updated[10]);
Assert.IsFalse(updated.Any(x => x.StartsWith("-filter:v")));
}
}
#endif
// #if(DEBUG)
//
// using FileFlows.VideoNodes.FfmpegBuilderNodes.EncoderAdjustments;
// using FileFlows.VideoNodes.FfmpegBuilderNodes.Models;
// using Microsoft.VisualStudio.TestTools.UnitTesting;
//
// namespace VideoNodes.Tests;
//
// [TestClass]
// public class VaapiAdjustmentTests: VideoTestBase
// {
// [TestMethod]
// public void Vaapi_CropAndScale()
// {
// var inputParameters = new List<string>
// {
// "-fflags",
// "+genpts",
// "-probesize",
// "5M",
// "-i",
// "/media/test.mkv",
// "-y",
// "-movflags",
// "+faststart",
// "-map_metadata",
// "-1",
// "-map",
// "0:v:0",
// "-c:v:0",
// "h264_vaapi",
// "-qp",
// "23",
// "-preset",
// "slower",
// "-spatial-aq",
// "1",
// "-filter:v:0",
// "crop=1904:800:8:2, scale=1280:-2:flags=lanczos",
// "-metadata:s:v:0",
// "title=",
// "-map",
// "0:a:0",
// "-c:a:0",
// "aac",
// "-ac:a:0",
// "2",
// "-b:a:0",
// "160k",
// "-metadata:s:a:0",
// "BPS=160000",
// "-ar:a:0",
// "48000",
// "-filter:a:0",
// "loudnorm=print_format=summary:linear=true:I=-24:LRA=7:TP=-2.0:measured_I=-18.14:measured_LRA=5.20:measured_tp=-4.31:measured_thresh=-28.14:offset=0.56, volume=.7",
// "-metadata:s:a:0",
// "title=Stereo",
// "-metadata:s:a:0",
// "language=eng"
// };
//
// var updated = new VaapiAdjustments().Run(Logger, null!, inputParameters);
// for (int i = 0; i < updated.Count; i++)
// Logger.ILog($"Updated[{i:00}] = {updated[i]}");
//
// Assert.AreEqual("-vf", updated[9]);
// Assert.AreEqual("format=nv12,hwupload,scale_vaapi=1280:-2", updated[10]);
// int index = updated.FindIndex(x => x.StartsWith("-filter:v"));
// Assert.IsTrue(index > 0);
// Assert.AreEqual("crop=1904:800:8:2", updated[index + 1]);
// }
//
//
// [TestMethod]
// public void Vaapi_Scale()
// {
// var inputParameters = new List<string>
// {
// "-fflags",
// "+genpts",
// "-probesize",
// "5M",
// "-i",
// "/media/test.mkv",
// "-y",
// "-movflags",
// "+faststart",
// "-map_metadata",
// "-1",
// "-map",
// "0:v:0",
// "-c:v:0",
// "h264_vaapi",
// "-qp",
// "23",
// "-preset",
// "slower",
// "-spatial-aq",
// "1",
// "-filter:v:0",
// "scale=1280:-2:flags=lanczos",
// "-metadata:s:v:0",
// "title=",
// "-map",
// "0:a:0",
// "-c:a:0",
// "aac",
// "-ac:a:0",
// "2",
// "-b:a:0",
// "160k",
// "-metadata:s:a:0",
// "BPS=160000",
// "-ar:a:0",
// "48000",
// "-filter:a:0",
// "loudnorm=print_format=summary:linear=true:I=-24:LRA=7:TP=-2.0:measured_I=-18.14:measured_LRA=5.20:measured_tp=-4.31:measured_thresh=-28.14:offset=0.56, volume=.7",
// "-metadata:s:a:0",
// "title=Stereo",
// "-metadata:s:a:0",
// "language=eng"
// };
//
// var updated = new VaapiAdjustments().Run(Logger, null!, inputParameters);
// for (int i = 0; i < updated.Count; i++)
// Logger.ILog($"Updated[{i:00}] = {updated[i]}");
//
// Assert.AreEqual("-vf", updated[9]);
// Assert.AreEqual("format=nv12,hwupload,scale_vaapi=1280:-2", updated[10]);
// Assert.IsFalse(updated.Any(x => x.StartsWith("-filter:v")));
// }
// }
// #endif

25
VideoNodes/Tests/VideoBitrateGreaterThanTests.cs
View File

@@ -6,13 +6,12 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace VideoNodes.Tests;
[TestClass]
public class VideoBitrateGreaterThanTests : TestBase
public class VideoBitrateGreaterThanTests : VideoTestBase
{
[TestMethod]
public void IsGreaterThan_NoAudio_NoVideoBitrate()
{
var logger = new TestLogger();
var args = new NodeParameters(logger)
var args = new NodeParameters(Logger)
{
Parameters = new()
{
@@ -38,8 +37,7 @@ public class VideoBitrateGreaterThanTests : TestBase
[TestMethod]
public void IsNotGreaterThan_NoAudio_NoVideoBitrate()
{
var logger = new TestLogger();
var args = new NodeParameters(logger)
var args = new NodeParameters(Logger)
{
Parameters = new()
{
@@ -65,8 +63,7 @@ public class VideoBitrateGreaterThanTests : TestBase
[TestMethod]
public void IsNotGreaterThan_WithAudio_NoVideoBitrate()
{
var logger = new TestLogger();
var args = new NodeParameters(logger)
var args = new NodeParameters(Logger)
{
Parameters = new()
{
@@ -90,20 +87,18 @@ public class VideoBitrateGreaterThanTests : TestBase
}
};
var estimated = (5001 * 1000) - (2000) - (5001 * 0.05);
logger.ILog($"Test Estimated Bitrate: {estimated} BPS / {estimated / 1000} KBps");
Logger.ILog($"Test Estimated Bitrate: {estimated} BPS / {estimated / 1000} KBps");
var element = new VideoBitrateGreaterThan();
element.Bitrate = (int)(estimated / 1000f) + 1;
var result = element.Execute(args);
var log = logger.ToString();
Assert.AreEqual(2, result);
}
[TestMethod]
public void IsGreaterThan_WithAudio_NoVideoBitrate()
{
var logger = new TestLogger();
var args = new NodeParameters(logger)
var args = new NodeParameters(Logger)
{
Parameters = new()
{
@@ -127,12 +122,11 @@ public class VideoBitrateGreaterThanTests : TestBase
}
};
var estimated = Math.Round((5001 * 1000) - (2000) - (5001 * 0.05));
logger.ILog($"Test Estimated Bitrate: {estimated} BPS / {estimated / 1000} KBps");
Logger.ILog($"Test Estimated Bitrate: {estimated} BPS / {estimated / 1000} KBps");
var element = new VideoBitrateGreaterThan();
element.Bitrate = (int)Math.Round(estimated / 1000f) - 1;
var result = element.Execute(args);
var log = logger.ToString();
Assert.AreEqual(1, result);
}
@@ -140,10 +134,7 @@ public class VideoBitrateGreaterThanTests : TestBase
[TestMethod]
public void LogTests()
{
var logger = new TestLogger();
var output = VideoBitrateGreaterThan.CheckBitrate(logger, 120144000, 15000);
string log = logger.ToString();
var output = VideoBitrateGreaterThan.CheckBitrate(Logger, 120144000, 15000);
Assert.AreEqual(1, output);
}

12
VideoNodes/Tests/VideoHasErrorsTests.cs
View File

@@ -6,20 +6,12 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace VideoNodes.Tests;
[TestClass]
public class VideoHasErrorsTests : TestBase
public class VideoHasErrorsTests : VideoTestBase
{
[TestMethod]
public void VideoHasErrors_Video()
{
string file = TestFile_Corrupt;
var args = new NodeParameters(file, Logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) =>
{
if(tool.ToLowerInvariant() == "ffmpeg") return FfmpegPath;
if(tool.ToLowerInvariant() == "ffprobe") return FfprobePath;
return null;
};
args.TempPath = TempPath;
var args = GetVideoNodeParameters(VideoCorrupt);
VideoFile vf = new();
vf.PreExecute(args);

242
VideoNodes/Tests/VideoHasStreamTests.cs
View File

@@ -2,32 +2,28 @@
using FileFlows.VideoNodes;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using PluginTestLibrary;
namespace VideoNodes.Tests;
[TestClass]
public class VideoHasStreamTests : TestBase
public class VideoHasStreamTests : VideoTestBase
{
[TestMethod]
public void VideoHasStream_Video_H264()
{
string file = TestFile_BasicMkv;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
VideoHasStream node = new();
node.Codec = "h264";
node.Stream = "Video";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters();
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
VideoHasStream element = new();
element.Codec = "h264";
element.Stream = "Video";
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(1, output);
}
@@ -35,23 +31,18 @@ public class VideoHasStreamTests : TestBase
[TestMethod]
public void VideoHasStream_Video_H265()
{
string file = TestFile_120_mbps_4k_uhd_hevc_10bit;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
VideoHasStream node = new();
node.Codec = "h265";
node.Stream = "Video";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters(VideoMkvHevc);
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
VideoHasStream element = new();
element.Codec = "h265";
element.Stream = "Video";
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(1, output);
}
@@ -59,48 +50,38 @@ public class VideoHasStreamTests : TestBase
[TestMethod]
public void VideoHasStream_Video_Hevc()
{
string file = TestFile_120_mbps_4k_uhd_hevc_10bit;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
VideoHasStream node = new();
node.Codec = "h265";
node.Stream = "Video";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters(VideoMkvHevc);
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
VideoHasStream element = new();
element.Codec = "hevc";
element.Stream = "Video";
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(1, output);
}
[TestMethod]
public void VideoHasStream_Audio_Vorbis()
public void VideoHasStream_Audio_Aac()
{
string file = TestFile_BasicMkv;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
VideoHasStream node = new();
node.Codec = "vorbis";
node.Stream = "Audio";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters();
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
VideoHasStream element = new();
element.Codec = "aac";
element.Stream = "Audio";
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(1, output);
}
@@ -110,23 +91,18 @@ public class VideoHasStreamTests : TestBase
[TestMethod]
public void VideoHasStream_Audio_Channels_Pass()
{
string file = TestFile_5dot1;
var vi = new VideoInfoHelper(FfmpegPath, Logger);
var vii = vi.Read(file);
VideoHasStream node = new();
node.Channels = "=5.1";
node.Stream = "Audio";
var args = new NodeParameters(file, Logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters();
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
VideoHasStream element = new();
element.Channels = "=2.0";
element.Stream = "Audio";
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(1, output);
}
@@ -135,74 +111,52 @@ public class VideoHasStreamTests : TestBase
[TestMethod]
public void VideoHasStream_Audio_Channels_GreaterOrEqual()
{
string file = TestFile_5dot1;
var vi = new VideoInfoHelper(FfmpegPath, Logger);
var vii = vi.Read(file);
VideoHasStream node = new();
node.Channels = ">=4.5";
node.Stream = "Audio";
var args = new NodeParameters(file, Logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters();
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
Assert.AreEqual(1, output);
VideoHasStream element = new();
element.Channels = ">=4.5";
element.Stream = "Audio";
element.PreExecute(args);
}
[TestMethod]
public void VideoHasStream_Audio_Channels_Between()
{
string file = TestFile_5dot1;
var vi = new VideoInfoHelper(FfmpegPath, Logger);
var vii = vi.Read(file);
VideoHasStream node = new();
node.Channels = "5<>5.1";
node.Stream = "Audio";
var args = new NodeParameters(file, Logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters();
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
Assert.AreEqual(1, output);
VideoHasStream element = new();
element.Channels = "5<>5.1";
element.Stream = "Audio";
element.PreExecute(args);
}
[TestMethod]
public void VideoHasStream_Audio_Channels_NotBetween()
{
string file = TestFile_5dot1;
var vi = new VideoInfoHelper(FfmpegPath, Logger);
var vii = vi.Read(file);
VideoHasStream node = new();
node.Channels = "2><3";
node.Stream = "Audio";
var args = new NodeParameters(file, Logger, false, string.Empty, new LocalFileService());
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters();
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
VideoHasStream element = new();
element.Channels = "2><3";
element.Stream = "Audio";
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(1, output);
}
[TestMethod]
public void VideoHasStream_Audio_Channels_Pass_61()
{
@@ -278,84 +232,49 @@ public class VideoHasStreamTests : TestBase
var args = new NodeParameters(null, Logger, false, string.Empty, new LocalFileService());
args.Parameters["VideoInfo"] = vi;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.GetToolPathActual = (string tool) => FFmpeg;
args.TempPath = TempPath;
int output = node.Execute(args);
Assert.AreEqual(1, output);
}
[TestMethod]
public void VideoHasStream_Audio_Channels_Fail()
{
string file = TestFile_BasicMkv;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
VideoHasStream node = new();
node.Channels = "=2";
node.Stream = "Audio";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters();
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
VideoHasStream element = new();
element.Channels = "=5.1";
element.Stream = "Audio";
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(2, output);
}
[TestMethod]
public void VideoHasStream_Video_Tag()
{
string file = TestFile_Tag;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
VideoHasStream node = new();
node.Codec = "h264";
node.Stream = "Video";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
int output = node.Execute(args);
Assert.AreEqual(1, output);
}
[TestMethod]
public void VideoHasStream_Audio_Lang_Pass()
{
string file = TestFile_MovText_Mp4;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
VideoHasStream node = new();
node.Language = "ita";
node.Stream = "Audio";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters();
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
node.PreExecute(args);
int output = node.Execute(args);
VideoHasStream element = new();
element.Language = "eng";
element.Stream = "Audio";
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(1, output);
}
@@ -363,24 +282,17 @@ public class VideoHasStreamTests : TestBase
[TestMethod]
public void VideoHasStream_Audio_Lang_Fail()
{
string file = TestFile_MovText_Mp4;
var vi = new VideoInfoHelper(FfmpegPath, new TestLogger());
var vii = vi.Read(file);
VideoHasStream node = new();
node.Language = "mao";
node.Stream = "Audio";
var args = new NodeParameters(file, new TestLogger(), false, string.Empty, null);;
args.GetToolPathActual = (string tool) => FfmpegPath;
args.TempPath = TempPath;
var args = GetVideoNodeParameters();
var vf = new VideoFile();
vf.PreExecute(args);
Assert.AreEqual(1, vf.Execute(args));
node.PreExecute(args);
int output = node.Execute(args);
VideoHasStream element = new();
element.Channels = "mao";
element.Stream = "Audio";
element.PreExecute(args);
int output = element.Execute(args);
Assert.AreEqual(2, output);
}

1780
VideoNodes/Tests/VideoInfoHelperTests.cs
View File

File diff suppressed because it is too large Load Diff

15
VideoNodes/Tests/VideoIsInterlacedTests.cs
View File

@@ -5,13 +5,11 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace VideoNodes.Tests;
[TestClass]
public class VideoIsInterlacedTests
public class VideoIsInterlacedTests : VideoTestBase
{
[TestMethod]
public void NotInterlaced()
{
var logger = new TestLogger();
string ffmpegOutput = @"
NUMBER_OF_BYTES : 3632640
_STATISTICS_WRITING_APP: mkvmerge v60.0.0 ('Are We Copies?') 64-bit
@@ -30,19 +28,16 @@ video:510kB audio:25542kB subtitle:0kB other streams:0kB global headers:0kB muxi
[Parsed_idet_0 @ 0x5618bf1fba40] Single frame detection: TFF: 0 BFF: 0 Progressive: 374 Undetermined: 715
[Parsed_idet_0 @ 0x5618bf1fba40] Multi frame detection: TFF: 0 BFF: 0 Progressive: 1089 Undetermined: 0";
bool interlaced = VideoIsInterlaced.IsVideoInterlaced(logger, ffmpegOutput, 10);
var log = logger.ToString();
bool interlaced = VideoIsInterlaced.IsVideoInterlaced(Logger, ffmpegOutput, 10);
Assert.IsFalse(interlaced);
Assert.IsTrue(log.Contains("Total Progressive Frames: " + (374 + 1089)));
Assert.IsTrue(Logger.ToString().Contains("Total Progressive Frames: " + (374 + 1089)));
}
[TestMethod]
public void IsInterlaced()
{
var logger = new TestLogger();
string ffmpegOutput = @"
NUMBER_OF_BYTES : 3632640
_STATISTICS_WRITING_APP: mkvmerge v60.0.0 ('Are We Copies?') 64-bit
@@ -61,10 +56,10 @@ video:510kB audio:25542kB subtitle:0kB other streams:0kB global headers:0kB muxi
[Parsed_idet_0 @ 0x5618bf1fba40] Single frame detection: TFF: 420 BFF: 0 Progressive: 374 Undetermined: 715
[Parsed_idet_0 @ 0x5618bf1fba40] Multi frame detection: TFF: 65 BFF: 0 Progressive: 1089 Undetermined: 0";
bool interlaced = VideoIsInterlaced.IsVideoInterlaced(logger, ffmpegOutput, 10);
var log = logger.ToString();
bool interlaced = VideoIsInterlaced.IsVideoInterlaced(Logger, ffmpegOutput, 10);
Assert.IsTrue(interlaced);
string log = Logger.ToString();
Assert.IsTrue(log.Contains("Total Progressive Frames: " + (374 + 1089)));
Assert.IsTrue(log.Contains("Total Interlaced Frames: " + (420 + 65)));
}

517
VideoNodes/Tests/_LocalFileService.cs
View File

@@ -1,517 +0,0 @@
#if(DEBUG)
using FileFlows.Plugin;
using FileFlows.Plugin.Models;
using FileFlows.Plugin.Services;
using System.IO;
using FileHelper = FileFlows.Plugin.Helpers.FileHelper;
namespace VideoNodes.Tests;
public class LocalFileService : IFileService
{
/// <summary>
/// Gets or sets the path separator for the file system
/// </summary>
public char PathSeparator { get; init; } = Path.DirectorySeparatorChar;
/// <summary>
/// Gets or sets the allowed paths the file service can access
/// </summary>
public string[] AllowedPaths { get; init; }
/// <summary>
/// Gets or sets a function for replacing variables in a string.
/// </summary>
/// <remarks>
/// The function takes a string input, a boolean indicating whether to strip missing variables,
/// and a boolean indicating whether to clean special characters.
/// </remarks>
public ReplaceVariablesDelegate ReplaceVariables { get; set; }
/// <summary>
/// Gets or sets the permissions to use for files
/// </summary>
public int? Permissions { get; set; }
/// <summary>
/// Gets or sets the owner:group to use for files
/// </summary>
public string OwnerGroup { get; set; }
/// <summary>
/// Gets or sets the logger used for logging
/// </summary>
public ILogger? Logger { get; set; }
public Result<string[]> GetFiles(string path, string searchPattern = "", bool recursive = false)
{
if (IsProtectedPath(ref path))
return Result<string[]>.Fail("Cannot access protected path: " + path);
try
{
return Directory.GetFiles(path, searchPattern ?? string.Empty,
recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
}
catch (Exception)
{
return new string[] { };
}
}
public Result<string[]> GetDirectories(string path)
{
if (IsProtectedPath(ref path))
return Result<string[]>.Fail("Cannot access protected path: " + path);
try
{
return Directory.GetDirectories(path);
}
catch (Exception)
{
return new string[] { };
}
}
public Result<bool> DirectoryExists(string path)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
try
{
return Directory.Exists(path);
}
catch (Exception)
{
return false;
}
}
public Result<bool> DirectoryDelete(string path, bool recursive = false)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
try
{
Directory.Delete(path, recursive);
return true;
}
catch (Exception ex)
{
return Result<bool>.Fail(ex.Message);
}
}
public Result<bool> DirectoryMove(string path, string destination)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
if (IsProtectedPath(ref destination))
return Result<bool>.Fail("Cannot access protected path: " + destination);
try
{
Directory.Move(path, destination);
SetPermissions(destination);
return true;
}
catch (Exception ex)
{
return Result<bool>.Fail(ex.Message);
}
}
public Result<bool> DirectoryCreate(string path)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
try
{
var dirInfo = new DirectoryInfo(path);
if (dirInfo.Exists == false)
dirInfo.Create();
SetPermissions(path);
return true;
}
catch (Exception ex)
{
return Result<bool>.Fail(ex.Message);
}
}
public Result<DateTime> DirectoryCreationTimeUtc(string path)
{
throw new NotImplementedException();
}
public Result<DateTime> DirectoryLastWriteTimeUtc(string path)
{
throw new NotImplementedException();
}
public Result<bool> FileExists(string path)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
try
{
return File.Exists(path);
}
catch (Exception)
{
return false;
}
}
public Result<FileInformation> FileInfo(string path)
{
if (IsProtectedPath(ref path))
return Result<FileInformation>.Fail("Cannot access protected path: " + path);
try
{
FileInfo fileInfo = new FileInfo(path);
return new FileInformation
{
CreationTime = fileInfo.CreationTime,
CreationTimeUtc = fileInfo.CreationTimeUtc,
LastWriteTime = fileInfo.LastWriteTime,
LastWriteTimeUtc = fileInfo.LastWriteTimeUtc,
Extension = fileInfo.Extension.TrimStart('.'),
Name = fileInfo.Name,
FullName = fileInfo.FullName,
Length = fileInfo.Length,
Directory = fileInfo.DirectoryName
};
}
catch (Exception ex)
{
return Result<FileInformation>.Fail(ex.Message);
}
}
public Result<bool> FileDelete(string path)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
try
{
var fileInfo = new FileInfo(path);
if(fileInfo.Exists)
fileInfo.Delete();
return true;
}
catch (Exception)
{
return false;
}
}
public Result<long> FileSize(string path)
{
if (IsProtectedPath(ref path))
return Result<long>.Fail("Cannot access protected path: " + path);
try
{
var fileInfo = new FileInfo(path);
if (fileInfo.Exists == false)
return Result<long>.Fail("File does not exist");
return fileInfo.Length;
}
catch (Exception ex)
{
return Result<long>.Fail(ex.Message);
}
}
public Result<DateTime> FileCreationTimeUtc(string path)
{
if (IsProtectedPath(ref path))
return Result<DateTime>.Fail("Cannot access protected path: " + path);
try
{
var fileInfo = new FileInfo(path);
if (fileInfo.Exists == false)
return Result<DateTime>.Fail("File does not exist");
return fileInfo.CreationTimeUtc;
}
catch (Exception ex)
{
return Result<DateTime>.Fail(ex.Message);
}
}
public Result<DateTime> FileLastWriteTimeUtc(string path)
{
if (IsProtectedPath(ref path))
return Result<DateTime>.Fail("Cannot access protected path: " + path);
try
{
var fileInfo = new FileInfo(path);
if (fileInfo.Exists == false)
return Result<DateTime>.Fail("File does not exist");
return fileInfo.LastWriteTimeUtc;
}
catch (Exception ex)
{
return Result<DateTime>.Fail(ex.Message);
}
}
public Result<bool> FileMove(string path, string destination, bool overwrite = true)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
if (IsProtectedPath(ref destination))
return Result<bool>.Fail("Cannot access protected path: " + destination);
try
{
var fileInfo = new FileInfo(path);
if (fileInfo.Exists == false)
return Result<bool>.Fail("File does not exist");
var destDir = new FileInfo(destination).Directory;
if (destDir.Exists == false)
{
destDir.Create();
SetPermissions(destDir.FullName);
}
fileInfo.MoveTo(destination, overwrite);
SetPermissions(destination);
return true;
}
catch (Exception ex)
{
return Result<bool>.Fail(ex.Message);
}
}
public Result<bool> FileCopy(string path, string destination, bool overwrite = true)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
if (IsProtectedPath(ref destination))
return Result<bool>.Fail("Cannot access protected path: " + destination);
try
{
var fileInfo = new FileInfo(path);
if (fileInfo.Exists == false)
return Result<bool>.Fail("File does not exist");
var destDir = new FileInfo(destination).Directory;
if (destDir.Exists == false)
{
destDir.Create();
SetPermissions(destDir.FullName);
}
fileInfo.CopyTo(destination, overwrite);
SetPermissions(destination);
return true;
}
catch (Exception ex)
{
return Result<bool>.Fail(ex.Message);
}
}
public Result<bool> FileAppendAllText(string path, string text)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
try
{
File.AppendAllText(path, text);
SetPermissions(path);
return true;
}
catch (Exception ex)
{
return Result<bool>.Fail(ex.Message);
}
}
public bool FileIsLocal(string path) => true;
/// <summary>
/// Gets the local path
/// </summary>
/// <param name="path">the path</param>
/// <returns>the local path to the file</returns>
public Result<string> GetLocalPath(string path)
=> Result<string>.Success(path);
public Result<bool> Touch(string path)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
if (DirectoryExists(path).Is(true))
{
try
{
Directory.SetLastWriteTimeUtc(path, DateTime.UtcNow);
return true;
}
catch (Exception ex)
{
return Result<bool>.Fail("Failed to touch directory: " + ex.Message);
}
}
try
{
if (File.Exists(path))
File.SetLastWriteTimeUtc(path, DateTime.UtcNow);
else
{
File.Create(path);
SetPermissions(path);
}
return true;
}
catch (Exception ex)
{
return Result<bool>.Fail($"Failed to touch file: '{path}' => {ex.Message}");
}
}
public Result<long> DirectorySize(string path)
{
if (string.IsNullOrWhiteSpace(path))
return 0;
if (File.Exists(path))
path = new FileInfo(path).Directory?.FullName ?? string.Empty;
if (string.IsNullOrWhiteSpace(path))
return 0;
if (Directory.Exists(path) == false)
return 0;
try
{
DirectoryInfo dir = new DirectoryInfo(path);
return dir.EnumerateFiles("*.*", SearchOption.AllDirectories).Sum(x => x.Length);
}
catch (Exception)
{
return 0;
}
}
public Result<bool> SetCreationTimeUtc(string path, DateTime date)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
try
{
if (!File.Exists(path))
return Result<bool>.Fail("File not found.");
File.SetCreationTimeUtc(path, date);
return Result<bool>.Success(true);
}
catch (Exception ex)
{
return Result<bool>.Fail($"Error setting creation time: {ex.Message}");
}
}
public Result<bool> SetLastWriteTimeUtc(string path, DateTime date)
{
if (IsProtectedPath(ref path))
return Result<bool>.Fail("Cannot access protected path: " + path);
try
{
if (!File.Exists(path))
return Result<bool>.Fail("File not found.");
File.SetLastWriteTimeUtc(path, date);
return Result<bool>.Success(true);
}
catch (Exception ex)
{
return Result<bool>.Fail($"Error setting last write time: {ex.Message}");
}
}
/// <summary>
/// Checks if a path is accessible by the file server
/// </summary>
/// <param name="path">the path to check</param>
/// <returns>true if accessible, otherwise false</returns>
private bool IsProtectedPath(ref string path)
{
if (OperatingSystem.IsWindows())
path = path.Replace("/", "\\");
else
path = path.Replace("\\", "/");
if(ReplaceVariables != null)
path = ReplaceVariables(path, true);
if (FileHelper.IsSystemDirectory(path))
return true; // a system directory, no access
if (AllowedPaths?.Any() != true)
return false; // no allowed paths configured, allow all
if (OperatingSystem.IsWindows())
path = path.ToLowerInvariant();
for(int i=0;i<AllowedPaths.Length;i++)
{
string p = OperatingSystem.IsWindows() ? AllowedPaths[i].ToLowerInvariant().TrimEnd('\\') : AllowedPaths[i].TrimEnd('/');
if (path.StartsWith(p))
return false;
}
return true;
}
public void SetPermissions(string path, int? permissions = null, Action<string> logMethod = null)
{
logMethod ??= (string message) => Logger?.ILog(message);
permissions = permissions != null && permissions > 0 ? permissions : Permissions;
if (permissions == null || permissions < 1)
permissions = 777;
if ((File.Exists(path) == false && Directory.Exists(path) == false))
{
logMethod("SetPermissions: File doesnt existing, skipping");
return;
}
//StringLogger stringLogger = new StringLogger();
var logger = new TestLogger();
bool isFile = new FileInfo(path).Exists;
FileHelper.SetPermissions(logger, path, file: isFile, permissions: permissions);
FileHelper.ChangeOwner(logger, path, file: isFile, ownerGroup: OwnerGroup);
logMethod(logger.ToString());
return;
if (OperatingSystem.IsLinux())
{
var filePermissions = FileHelper.ConvertLinuxPermissionsToUnixFileMode(permissions.Value);
if (filePermissions == UnixFileMode.None)
{
logMethod("SetPermissions: Invalid file permissions: " + permissions.Value);
return;
}
File.SetUnixFileMode(path, filePermissions);
logMethod($"SetPermissions: Permission [{filePermissions}] set on file: " + path);
}
}
}
#endif

121
VideoNodes/Tests/_TestBase.cs
View File

@@ -1,121 +0,0 @@
#if(DEBUG)
using System.Runtime.InteropServices;
using FileFlows.VideoNodes;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Text.Json;
using System.IO;
namespace VideoNodes.Tests;
[TestClass]
public abstract class TestBase
{
/// <summary>
/// The test context instance
/// </summary>
private TestContext testContextInstance;
internal TestLogger Logger = new();
/// <summary>
/// Gets or sets the test context
/// </summary>
public TestContext TestContext
{
get => testContextInstance;
set => testContextInstance = value;
}
public string TestPath { get; private set; }
public string TempPath { get; private set; }
public string FfmpegPath { get; private set; }
public string FfprobePath { get; private set; }
public readonly bool IsWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
public readonly bool IsLinux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
[TestInitialize]
public void TestInitialize()
{
Logger.Writer = (msg) => TestContext.WriteLine(msg);
if (System.IO.File.Exists("../../../test.settings.dev.json"))
{
LoadSettings("../../../test.settings.dev.json");
}
else if (System.IO.File.Exists("../../../test.settings.json"))
{
LoadSettings("../../../test.settings.json");
}
this.TestPath = this.TestPath?.EmptyAsNull() ?? (IsLinux ? "~/src/ff-files/test-files/videos" : @"d:\videos\testfiles");
this.TempPath = this.TempPath?.EmptyAsNull() ?? (IsLinux ? "~/src/ff-files/temp" : @"d:\videos\temp");
this.FfmpegPath = this.FfmpegPath?.EmptyAsNull() ?? (IsLinux ? "/usr/local/bin/ffmpeg" : @"C:\utils\ffmpeg\ffmpeg.exe");
this.FfprobePath = this.FfmpegPath?.EmptyAsNull() ?? (IsLinux ? "/usr/local/bin/ffprobe" : @"C:\utils\ffprobe\ffprobe.exe");
this.TestPath = this.TestPath.Replace("~/", Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "/");
this.TempPath = this.TempPath.Replace("~/", Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "/");
this.FfmpegPath = this.FfmpegPath.Replace("~/", Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "/");
this.FfprobePath = this.FfprobePath.Replace("~/", Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "/");
if (Directory.Exists(this.TempPath) == false)
Directory.CreateDirectory(this.TempPath);
}
[TestCleanup]
public void CleanUp()
{
TestContext.WriteLine(Logger.ToString());
}
private void LoadSettings(string filename)
{
try
{
if (File.Exists(filename) == false)
return;
string json = File.ReadAllText(filename);
var settings = JsonSerializer.Deserialize<TestSettings>(json);
this.TestPath = settings.TestPath;
this.TempPath = settings.TempPath;
this.FfmpegPath = settings.FfmpegPath;
}
catch (Exception) { }
}
protected virtual void TestStarting()
{
}
protected string TestFile_MovText_Mp4 => Path.Combine(TestPath, "movtext.mp4");
protected string TestFile_BasicMkv => Path.Combine(TestPath, "basic.mkv");
protected string TestFile_Corrupt => Path.Combine(TestPath, "corrupt.mkv");
protected string TestFile_Webvtt => Path.Combine(TestPath, "webvtt4.mkv");
protected string TestFile_Tag => Path.Combine(TestPath, "tag.mp4");
protected string TestFile_Sitcom => Path.Combine(TestPath, "sitcom.mkv");
protected string TestFile_Pgs => Path.Combine(TestPath, "pgs.mkv");
protected string TestFile_Subtitle => Path.Combine(TestPath, "subtitle.mkv");
protected string TestFile_Error => Path.Combine(TestPath, "error.mkv");
protected string TestFile_Font => Path.Combine(TestPath, "font.mkv");
protected string TestFile_DefaultSub => Path.Combine(TestPath, "default-sub.mkv");
protected string TestFile_ForcedDefaultSub => Path.Combine(TestPath, "sub-forced-default.mkv");
protected string TestFile_DefaultIsForcedSub => Path.Combine(TestPath, "sub-default-is-forced.mkv");
protected string TestFile_5dot1 => Path.Combine(TestPath, "5.1.mkv");
protected string TestFile_TwoPassNegInifinity => Path.Combine(TestPath, "audio_normal_neg_infinity.mkv");
protected string TestFile_4k_h264mov => Path.Combine(TestPath, "4k_h264.mov");
protected string TestFile_4k_h264mkv => Path.Combine(TestPath, "4k_h264.mkv");
protected string TestFile_50_mbps_hd_h264 => Path.Combine(TestPath, "50-mbps-hd-h264.mkv");
protected string TestFile_120_mbps_4k_uhd_hevc_10bit => Path.Combine(TestPath, "120-mbps-4k-uhd-hevc-10bit.mkv");
private class TestSettings
{
public string TestPath { get; set; }
public string TempPath { get; set; }
public string FfmpegPath { get; set; }
}
}
#endif

84
VideoNodes/Tests/_VideoTestBase.cs Normal file
View File

@@ -0,0 +1,84 @@
#if(DEBUG)
using PluginTestLibrary;
using File = System.IO.File;
namespace VideoNodes.Tests;
/// <summary>
/// Test base dor the video tests
/// </summary>
public abstract class VideoTestBase : TestBase
{
/// <summary>
/// The resources test file directory
/// </summary>
protected static readonly string ResourcesTestFilesDir = "Tests/Resources";
/// <summary>
/// Video MKV file
/// </summary>
protected static readonly string VideoMkv = ResourcesTestFilesDir + "/video.mkv";
/// <summary>
/// Video MP4 file
/// </summary>
protected static readonly string VideoMp4 = ResourcesTestFilesDir + "/video.mp4";
/// <summary>
/// Video HEVC MKV file
/// </summary>
protected static readonly string VideoMkvHevc = ResourcesTestFilesDir + "/hevc.mkv";
/// <summary>
/// Video Corrutp file
/// </summary>
protected static readonly string VideoCorrupt = ResourcesTestFilesDir + "/corrupt.mkv";
/// <summary>
/// Audio MP3 file
/// </summary>
protected static readonly string AudioMp3 = ResourcesTestFilesDir + "/audio.mp3";
/// <summary>
/// Gets the FFmpeg location
/// </summary>
protected static string FFmpeg { get; private set; }
/// <summary>
/// Gets the FFprobe location
/// </summary>
protected static string FFprobe { get; private set; }
/// <summary>
/// Gets the Node Parameters
/// </summary>
/// <param name="filename">the file to initialise, will use VideoMkv if not set</param>
/// <param name="isDirectory">if the file is directory
/// <returns>the node parameters</returns>
public NodeParameters GetVideoNodeParameters(string? filename = null, bool isDirectory = false)
{
filename ??= VideoMkv;
var args = new NodeParameters(filename, Logger, isDirectory, string.Empty, new LocalFileService())
{
LibraryFileName = filename
};
args.InitFile(filename);
FFmpeg = File.Exists("/usr/local/bin/ffmpeg") ? "/usr/local/bin/ffmpeg" : "ffmpeg";
FFprobe = File.Exists("/usr/local/bin/ffprobe") ? "/usr/local/bin/ffprobe" : "ffprobe";
args.GetToolPathActual = (tool) =>
{
if(tool.ToLowerInvariant().Contains("ffmpeg")) return FFmpeg;
if(tool.ToLowerInvariant().Contains("ffprobe")) return FFprobe;
return tool;
};
args.TempPath = TempPath;
return args;
}
}
#endif

3
VideoNodes/VideoNodes.csproj
View File

@@ -27,6 +27,9 @@
<PackageReference Include="MSTest.TestAdapter" Version="3.4.3" />
<PackageReference Include="MSTest.TestFramework" Version="3.4.3" />
<ProjectReference Include="..\PluginTestLibrary\PluginTestLibrary.csproj" />
<Content Include="Tests\Resources\**\*">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</Content>
</ItemGroup>
<ItemGroup>
<Reference Include="Plugin">

11
VideoNodes/VideoNodes/SubtitleExtractor.cs
View File

@@ -244,20 +244,21 @@ public class SubtitleExtractor : EncodingNode
var result = args.Process.ExecuteShellCommand(new ExecuteArgs
{
Command = ffmpegExe,
ArgumentList = textSubtitles ?
new[] {
ArgumentList = textSubtitles ?
[
"-i", localFile,
"-map", subtitleStream,
tempOutput
} :
new[] {
]
:
[
"-i", localFile,
"-map", subtitleStream,
"-c:s", "copy",
tempOutput
}
]
}).Result;
var of = new System.IO.FileInfo(tempOutput);