FFMpegCore/FFMpegCore.Test/FFProbeTests.cs

191 lines
8.3 KiB
C#
Raw Normal View History

2021-03-05 18:06:40 +01:00
using System;
2021-11-08 15:28:16 +01:00
using System.Collections.Generic;
2021-03-05 18:06:40 +01:00
using System.IO;
2021-10-21 20:36:54 +02:00
using System.Linq;
2020-05-08 11:07:51 +02:00
using System.Threading.Tasks;
using FFMpegCore.Test.Resources;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace FFMpegCore.Test
{
[TestClass]
public class FFProbeTests
{
[TestMethod]
public void Probe_TooLongOutput()
{
2020-12-07 00:47:47 +01:00
Assert.ThrowsException<System.Text.Json.JsonException>(() => FFProbe.Analyse(TestResources.Mp4Video, 5));
}
[TestMethod]
public async Task Audio_FromStream_Duration()
{
2020-12-07 21:00:43 +01:00
var fileAnalysis = await FFProbe.AnalyseAsync(TestResources.WebmVideo);
await using var inputStream = File.OpenRead(TestResources.WebmVideo);
2020-12-07 00:47:47 +01:00
var streamAnalysis = await FFProbe.AnalyseAsync(inputStream);
Assert.IsTrue(fileAnalysis.Duration == streamAnalysis.Duration);
}
2021-10-21 20:36:54 +02:00
[TestMethod]
public void FrameAnalysis_Sync()
{
var frameAnalysis = FFProbe.GetFrames(TestResources.WebmVideo);
Assert.AreEqual(90, frameAnalysis.Frames.Count);
Assert.IsTrue(frameAnalysis.Frames.All(f => f.PixelFormat == "yuv420p"));
Assert.IsTrue(frameAnalysis.Frames.All(f => f.Height == 360));
Assert.IsTrue(frameAnalysis.Frames.All(f => f.Width == 640));
Assert.IsTrue(frameAnalysis.Frames.All(f => f.MediaType == "video"));
}
[TestMethod]
public async Task FrameAnalysis_Async()
{
var frameAnalysis = await FFProbe.GetFramesAsync(TestResources.WebmVideo);
Assert.AreEqual(90, frameAnalysis.Frames.Count);
Assert.IsTrue(frameAnalysis.Frames.All(f => f.PixelFormat == "yuv420p"));
Assert.IsTrue(frameAnalysis.Frames.All(f => f.Height == 360));
Assert.IsTrue(frameAnalysis.Frames.All(f => f.Width == 640));
Assert.IsTrue(frameAnalysis.Frames.All(f => f.MediaType == "video"));
}
2021-11-08 15:28:16 +01:00
[TestMethod]
public async Task PacketAnalysis_Async()
{
var packetAnalysis = await FFProbe.GetPacketsAsync(TestResources.WebmVideo);
var packets = packetAnalysis.Packets;
Assert.AreEqual(96, packets.Count);
Assert.IsTrue(packets.All(f => f.CodecType == "video"));
Assert.AreEqual("K_", packets[0].Flags);
Assert.AreEqual(1362, packets.Last().Size);
}
[TestMethod]
public void PacketAnalysis_Sync()
{
var packets = FFProbe.GetPackets(TestResources.WebmVideo).Packets;
Assert.AreEqual(96, packets.Count);
Assert.IsTrue(packets.All(f => f.CodecType == "video"));
Assert.AreEqual("K_", packets[0].Flags);
Assert.AreEqual(1362, packets.Last().Size);
}
[TestMethod]
public void PacketAnalysisAudioVideo_Sync()
{
var packets = FFProbe.GetPackets(TestResources.Mp4Video).Packets;
Assert.AreEqual(216, packets.Count);
var actual = packets.Select(f => f.CodecType).Distinct().ToList();
var expected = new List<string> {"audio", "video"};
CollectionAssert.AreEquivalent(expected, actual);
Assert.IsTrue(packets.Where(t=>t.CodecType == "audio").All(f => f.Flags == "K_"));
Assert.AreEqual(75, packets.Count(t => t.CodecType == "video"));
Assert.AreEqual(141, packets.Count(t => t.CodecType == "audio"));
}
2021-03-15 23:43:22 +01:00
[DataTestMethod]
[DataRow("0:00:03.008000", 0, 0, 0, 3, 8)]
[DataRow("05:12:59.177", 0, 5, 12, 59, 177)]
2021-03-15 23:50:11 +01:00
[DataRow("149:07:50.911750", 6, 5, 7, 50, 911)]
2021-03-15 23:43:22 +01:00
[DataRow("00:00:00.83", 0, 0, 0, 0, 830)]
public void MediaAnalysis_ParseDuration(string duration, int expectedDays, int expectedHours, int expectedMinutes, int expectedSeconds, int expectedMilliseconds)
{
2021-03-15 23:43:22 +01:00
var ffprobeStream = new FFProbeStream { Duration = duration };
2021-03-15 23:43:22 +01:00
var parsedDuration = MediaAnalysisUtils.ParseDuration(ffprobeStream);
2021-03-15 23:50:11 +01:00
Assert.AreEqual(expectedDays, parsedDuration.Days);
Assert.AreEqual(expectedHours, parsedDuration.Hours);
Assert.AreEqual(expectedMinutes, parsedDuration.Minutes);
Assert.AreEqual(expectedSeconds, parsedDuration.Seconds);
Assert.AreEqual(expectedMilliseconds, parsedDuration.Milliseconds);
}
2021-03-05 18:06:40 +01:00
[TestMethod]
public async Task Uri_Duration()
{
var fileAnalysis = await FFProbe.AnalyseAsync(new Uri("https://github.com/rosenbjerg/FFMpegCore/raw/master/FFMpegCore.Test/Resources/input_3sec.webm"));
Assert.IsNotNull(fileAnalysis);
}
[TestMethod]
public void Probe_Success()
{
2020-12-07 00:47:47 +01:00
var info = FFProbe.Analyse(TestResources.Mp4Video);
2020-10-25 17:11:52 +01:00
Assert.AreEqual(3, info.Duration.Seconds);
2020-05-09 17:53:03 +02:00
2021-03-05 18:06:40 +01:00
Assert.AreEqual("5.1", info.PrimaryAudioStream!.ChannelLayout);
2020-05-09 17:53:03 +02:00
Assert.AreEqual(6, info.PrimaryAudioStream.Channels);
Assert.AreEqual("AAC (Advanced Audio Coding)", info.PrimaryAudioStream.CodecLongName);
Assert.AreEqual("aac", info.PrimaryAudioStream.CodecName);
Assert.AreEqual("LC", info.PrimaryAudioStream.Profile);
2020-10-25 17:11:52 +01:00
Assert.AreEqual(377351, info.PrimaryAudioStream.BitRate);
2020-05-09 17:53:03 +02:00
Assert.AreEqual(48000, info.PrimaryAudioStream.SampleRateHz);
Assert.AreEqual("mp4a", info.PrimaryAudioStream.CodecTagString);
Assert.AreEqual("0x6134706d", info.PrimaryAudioStream.CodecTag);
2020-05-09 17:53:03 +02:00
2021-03-05 18:06:40 +01:00
Assert.AreEqual(1471810, info.PrimaryVideoStream!.BitRate);
2020-05-09 17:53:03 +02:00
Assert.AreEqual(16, info.PrimaryVideoStream.DisplayAspectRatio.Width);
Assert.AreEqual(9, info.PrimaryVideoStream.DisplayAspectRatio.Height);
Assert.AreEqual("yuv420p", info.PrimaryVideoStream.PixelFormat);
Assert.AreEqual(1280, info.PrimaryVideoStream.Width);
Assert.AreEqual(720, info.PrimaryVideoStream.Height);
Assert.AreEqual(25, info.PrimaryVideoStream.AvgFrameRate);
Assert.AreEqual(25, info.PrimaryVideoStream.FrameRate);
Assert.AreEqual("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10", info.PrimaryVideoStream.CodecLongName);
Assert.AreEqual("h264", info.PrimaryVideoStream.CodecName);
Assert.AreEqual(8, info.PrimaryVideoStream.BitsPerRawSample);
Assert.AreEqual("Main", info.PrimaryVideoStream.Profile);
Assert.AreEqual("avc1", info.PrimaryVideoStream.CodecTagString);
Assert.AreEqual("0x31637661", info.PrimaryVideoStream.CodecTag);
2020-05-09 17:53:03 +02:00
}
2020-10-25 17:42:50 +01:00
[TestMethod, Timeout(10000)]
2020-05-09 17:53:03 +02:00
public async Task Probe_Async_Success()
{
2020-12-07 00:47:47 +01:00
var info = await FFProbe.AnalyseAsync(TestResources.Mp4Video);
2020-10-25 17:11:52 +01:00
Assert.AreEqual(3, info.Duration.Seconds);
}
2020-05-10 12:07:28 +02:00
[TestMethod, Timeout(10000)]
2020-04-28 14:21:48 +02:00
public void Probe_Success_FromStream()
{
2020-12-07 00:47:47 +01:00
using var stream = File.OpenRead(TestResources.WebmVideo);
2020-05-08 11:07:51 +02:00
var info = FFProbe.Analyse(stream);
2020-10-25 17:11:52 +01:00
Assert.AreEqual(3, info.Duration.Seconds);
2020-04-28 14:21:48 +02:00
}
2020-10-25 17:42:50 +01:00
[TestMethod, Timeout(10000)]
2020-05-08 11:07:51 +02:00
public async Task Probe_Success_FromStream_Async()
2020-04-28 14:21:48 +02:00
{
2020-12-07 00:47:47 +01:00
await using var stream = File.OpenRead(TestResources.WebmVideo);
2020-05-08 11:07:51 +02:00
var info = await FFProbe.AnalyseAsync(stream);
2020-10-25 17:11:52 +01:00
Assert.AreEqual(3, info.Duration.Seconds);
2020-04-28 14:21:48 +02:00
}
2021-07-31 22:46:21 +02:00
[TestMethod, Timeout(10000)]
public async Task Probe_Success_Subtitle_Async()
{
var info = await FFProbe.AnalyseAsync(TestResources.SrtSubtitle);
Assert.IsNotNull(info.PrimarySubtitleStream);
Assert.AreEqual(1, info.SubtitleStreams.Count);
Assert.AreEqual(0, info.AudioStreams.Count);
Assert.AreEqual(0, info.VideoStreams.Count);
}
[TestMethod, Timeout(10000)]
public async Task Probe_Success_Disposition_Async()
{
var info = await FFProbe.AnalyseAsync(TestResources.Mp4Video);
Assert.IsNotNull(info.PrimaryAudioStream);
Assert.IsNotNull(info.PrimaryAudioStream.Disposition);
Assert.AreEqual(true, info.PrimaryAudioStream.Disposition["default"]);
Assert.AreEqual(false, info.PrimaryAudioStream.Disposition["forced"]);
}
}
}