Never treat a manifest container as an audio codec or a direct play target

3 files changed, 216 insertions, 0 deletions

diff --git a/tests/Jellyfin.Controller.Tests/MediaEncoding/EncodingHelperInferAudioCodecTests.cs b/tests/Jellyfin.Controller.Tests/MediaEncoding/EncodingHelperInferAudioCodecTests.cs
new file mode 100644
index 0000000000..586db2dd50
--- /dev/null
+++ b/tests/Jellyfin.Controller.Tests/MediaEncoding/EncodingHelperInferAudioCodecTests.cs
@@ -0,0 +1,40 @@
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Controller.MediaEncoding;
+using Moq;
+using Xunit;
+using IConfiguration = Microsoft.Extensions.Configuration.IConfiguration;
+
+namespace Jellyfin.Controller.Tests.MediaEncoding;
+
+public class EncodingHelperInferAudioCodecTests
+{
+    [Theory]
+    // Manifests and other containers that carry no inferable audio codec.
+    [InlineData("m3u8", "aac")]
+    [InlineData("mpd", "aac")]
+    [InlineData("wtv", "aac")]
+    [InlineData("", "aac")]
+    // Containers with a well known audio codec.
+    [InlineData("mp4", "aac")]
+    [InlineData("mkv", "aac")]
+    [InlineData("webm", "opus")]
+    [InlineData("ts", "mp3")]
+    // Containers named after the codec they carry.
+    [InlineData("flac", "flac")]
+    [InlineData("opus", "opus")]
+    [InlineData("ac3", "ac3")]
+    public void InferAudioCodec_ReturnsAnAudioCodec(string container, string expected)
+    {
+        Assert.Equal(expected, Create().InferAudioCodec(container));
+    }
+
+    private static EncodingHelper Create()
+        => new(
+            Mock.Of<IApplicationPaths>(),
+            Mock.Of<IMediaEncoder>(),
+            Mock.Of<ISubtitleEncoder>(),
+            Mock.Of<IConfiguration>(),
+            Mock.Of<IConfigurationManager>(),
+            Mock.Of<IPathManager>());
+}
diff --git a/tests/Jellyfin.LiveTv.Tests/M3UTunerHostTests.cs b/tests/Jellyfin.LiveTv.Tests/M3UTunerHostTests.cs
new file mode 100644
index 0000000000..4487a5ff2b
--- /dev/null
+++ b/tests/Jellyfin.LiveTv.Tests/M3UTunerHostTests.cs
@@ -0,0 +1,72 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.LiveTv.TunerHosts;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.LiveTv;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.LiveTv.Tests
+{
+    public class M3UTunerHostTests
+    {
+        [Theory]
+        // A manifest is not a byte stream, so it must never be offered for direct play.
+        [InlineData("http://example.com/live/1234.m3u8", false)]
+        [InlineData("http://example.com/live/1234.m3u8?token=abc", false)]
+        [InlineData("http://example.com/live/1234.mpd", false)]
+        // Byte streams are unaffected.
+        [InlineData("http://example.com/live/1234.ts", true)]
+        [InlineData("http://example.com/live/1234", true)]
+        public async Task GetChannelStreamMediaSources_ManifestPath_DisablesDirectPlay(string path, bool expectDirectPlay)
+        {
+            var mediaSourceManager = new Mock<IMediaSourceManager>();
+            mediaSourceManager.Setup(x => x.GetPathProtocol(It.IsAny<string>())).Returns(MediaProtocol.Http);
+
+            var host = new TestableM3UTunerHost(
+                Mock.Of<IServerConfigurationManager>(),
+                mediaSourceManager.Object,
+                Mock.Of<ILogger<M3UTunerHost>>(),
+                Mock.Of<IFileSystem>(),
+                Mock.Of<IHttpClientFactory>(),
+                Mock.Of<IServerApplicationHost>(),
+                Mock.Of<INetworkManager>(),
+                Mock.Of<IStreamHelper>());
+
+            var sources = await host.GetMediaSources(
+                new TunerHostInfo { TunerCount = 0, EnableStreamLooping = false },
+                new ChannelInfo { Path = path });
+
+            Assert.Equal(expectDirectPlay, sources[0].SupportsDirectPlay);
+        }
+
+        private sealed class TestableM3UTunerHost : M3UTunerHost
+        {
+            public TestableM3UTunerHost(
+                IServerConfigurationManager config,
+                IMediaSourceManager mediaSourceManager,
+                ILogger<M3UTunerHost> logger,
+                IFileSystem fileSystem,
+                IHttpClientFactory httpClientFactory,
+                IServerApplicationHost appHost,
+                INetworkManager networkManager,
+                IStreamHelper streamHelper)
+                : base(config, mediaSourceManager, logger, fileSystem, httpClientFactory, appHost, networkManager, streamHelper)
+            {
+            }
+
+            public Task<List<MediaSourceInfo>> GetMediaSources(TunerHostInfo tuner, ChannelInfo channel)
+                => GetChannelStreamMediaSources(tuner, channel, CancellationToken.None);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Model.Tests/Dlna/StreamBuilderManifestContainerTests.cs b/tests/Jellyfin.Model.Tests/Dlna/StreamBuilderManifestContainerTests.cs
new file mode 100644
index 0000000000..dfd1eb2e85
--- /dev/null
+++ b/tests/Jellyfin.Model.Tests/Dlna/StreamBuilderManifestContainerTests.cs
@@ -0,0 +1,104 @@
+using System;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Model.Dlna;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.MediaInfo;
+using MediaBrowser.Model.Session;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Model.Tests.Dlna;
+
+public class StreamBuilderManifestContainerTests
+{
+    [Theory]
+    // A manifest describes a stream instead of carrying one, so it can never be direct played,
+    // even when the client claims to support the container.
+    [InlineData("hls")]
+    [InlineData("hls,applehttp")]
+    [InlineData("applehttp")]
+    [InlineData("dash")]
+    public void GetOptimalVideoStream_ManifestContainer_DoesNotDirectPlay(string container)
+    {
+        var streamInfo = BuildFor(container);
+
+        Assert.NotNull(streamInfo);
+        Assert.Equal(PlayMethod.Transcode, streamInfo.PlayMethod);
+    }
+
+    [Fact]
+    public void GetOptimalVideoStream_ByteStreamContainer_StillDirectPlays()
+    {
+        var streamInfo = BuildFor("mp4");
+
+        Assert.NotNull(streamInfo);
+        Assert.Equal(PlayMethod.DirectPlay, streamInfo.PlayMethod);
+    }
+
+    private static StreamInfo? BuildFor(string container)
+    {
+        var mediaSource = new MediaSourceInfo
+        {
+            Id = "test-source",
+            Path = "http://example.com/live/channel",
+            Protocol = MediaProtocol.Http,
+            Container = container,
+            SupportsDirectPlay = true,
+            SupportsDirectStream = true,
+            SupportsTranscoding = true,
+            IsInfiniteStream = true,
+            IsRemote = true,
+            MediaStreams =
+            [
+                new MediaStream { Type = MediaStreamType.Video, Index = 0, Codec = "h264" },
+                new MediaStream { Type = MediaStreamType.Audio, Index = 1, Codec = "aac" }
+            ]
+        };
+
+        var profile = new DeviceProfile
+        {
+            Name = "Manifest aware client",
+            DirectPlayProfiles =
+            [
+                new DirectPlayProfile
+                {
+                    Type = DlnaProfileType.Video,
+                    Container = "mp4,hls,applehttp,dash",
+                    VideoCodec = "h264",
+                    AudioCodec = "aac"
+                }
+            ],
+            TranscodingProfiles =
+            [
+                new TranscodingProfile
+                {
+                    Type = DlnaProfileType.Video,
+                    Context = EncodingContext.Streaming,
+                    Protocol = MediaStreamProtocol.hls,
+                    Container = "ts",
+                    VideoCodec = "h264",
+                    AudioCodec = "aac"
+                }
+            ]
+        };
+
+        var options = new MediaOptions
+        {
+            ItemId = new Guid("11D229B7-2D48-4B95-9F9B-49F6AB75E613"),
+            MediaSourceId = mediaSource.Id,
+            MediaSources = [mediaSource],
+            DeviceId = "test-deviceId",
+            Profile = profile,
+            AllowAudioStreamCopy = true,
+            AllowVideoStreamCopy = true,
+            EnableDirectStream = false // This is disabled in server
+        };
+
+        var transcodeSupport = new Mock<ITranscoderSupport>();
+
+        return new StreamBuilder(transcodeSupport.Object, new NullLogger<StreamBuilderManifestContainerTests>())
+            .GetOptimalVideoStream(options);
+    }
+}