| | | 1 | | #nullable disable |
| | | 2 | | |
| | | 3 | | #pragma warning disable CS1591 |
| | | 4 | | |
| | | 5 | | using System; |
| | | 6 | | using System.Collections.Generic; |
| | | 7 | | using System.Globalization; |
| | | 8 | | using System.IO; |
| | | 9 | | using System.Linq; |
| | | 10 | | using System.Net; |
| | | 11 | | using System.Net.Http; |
| | | 12 | | using System.Threading; |
| | | 13 | | using System.Threading.Tasks; |
| | | 14 | | using Jellyfin.Extensions; |
| | | 15 | | using MediaBrowser.Common.Extensions; |
| | | 16 | | using MediaBrowser.Common.Net; |
| | | 17 | | using MediaBrowser.Controller; |
| | | 18 | | using MediaBrowser.Controller.Configuration; |
| | | 19 | | using MediaBrowser.Controller.Library; |
| | | 20 | | using MediaBrowser.Controller.LiveTv; |
| | | 21 | | using MediaBrowser.Model.Dto; |
| | | 22 | | using MediaBrowser.Model.Entities; |
| | | 23 | | using MediaBrowser.Model.IO; |
| | | 24 | | using MediaBrowser.Model.LiveTv; |
| | | 25 | | using MediaBrowser.Model.MediaInfo; |
| | | 26 | | using Microsoft.Extensions.Logging; |
| | | 27 | | using Microsoft.Net.Http.Headers; |
| | | 28 | | |
| | | 29 | | namespace Jellyfin.LiveTv.TunerHosts |
| | | 30 | | { |
| | | 31 | | public class M3UTunerHost : BaseTunerHost, ITunerHost, IConfigurableTunerHost |
| | | 32 | | { |
| | 1 | 33 | | private static readonly string[] _mimeTypesCanShareHttpStream = ["video/MP2T"]; |
| | 1 | 34 | | private static readonly string[] _extensionsCanShareHttpStream = [".ts", ".tsv", ".m2t"]; |
| | 1 | 35 | | private static readonly string[] _manifestExtensions = [".m3u8", ".m3u", ".mpd"]; |
| | | 36 | | |
| | | 37 | | private readonly IHttpClientFactory _httpClientFactory; |
| | | 38 | | private readonly IServerApplicationHost _appHost; |
| | | 39 | | private readonly INetworkManager _networkManager; |
| | | 40 | | private readonly IMediaSourceManager _mediaSourceManager; |
| | | 41 | | private readonly IStreamHelper _streamHelper; |
| | | 42 | | |
| | | 43 | | public M3UTunerHost( |
| | | 44 | | IServerConfigurationManager config, |
| | | 45 | | IMediaSourceManager mediaSourceManager, |
| | | 46 | | ILogger<M3UTunerHost> logger, |
| | | 47 | | IFileSystem fileSystem, |
| | | 48 | | IHttpClientFactory httpClientFactory, |
| | | 49 | | IServerApplicationHost appHost, |
| | | 50 | | INetworkManager networkManager, |
| | | 51 | | IStreamHelper streamHelper) |
| | 32 | 52 | | : base(config, logger, fileSystem) |
| | | 53 | | { |
| | 32 | 54 | | _httpClientFactory = httpClientFactory; |
| | 32 | 55 | | _appHost = appHost; |
| | 32 | 56 | | _networkManager = networkManager; |
| | 32 | 57 | | _mediaSourceManager = mediaSourceManager; |
| | 32 | 58 | | _streamHelper = streamHelper; |
| | 32 | 59 | | } |
| | | 60 | | |
| | 4 | 61 | | public override string Type => "m3u"; |
| | | 62 | | |
| | 0 | 63 | | public virtual string Name => "M3U Tuner"; |
| | | 64 | | |
| | | 65 | | private string GetFullChannelIdPrefix(TunerHostInfo info) |
| | | 66 | | { |
| | 0 | 67 | | return ChannelIdPrefix + info.Url.GetMD5().ToString("N", CultureInfo.InvariantCulture); |
| | | 68 | | } |
| | | 69 | | |
| | | 70 | | protected override async Task<List<ChannelInfo>> GetChannelsInternal(TunerHostInfo tuner, CancellationToken canc |
| | | 71 | | { |
| | 0 | 72 | | var channelIdPrefix = GetFullChannelIdPrefix(tuner); |
| | | 73 | | |
| | 0 | 74 | | return await new M3uParser(Logger, _httpClientFactory) |
| | 0 | 75 | | .Parse(tuner, channelIdPrefix, cancellationToken) |
| | 0 | 76 | | .ConfigureAwait(false); |
| | 0 | 77 | | } |
| | | 78 | | |
| | | 79 | | protected override async Task<ILiveStream> GetChannelStream(TunerHostInfo tunerHost, ChannelInfo channel, string |
| | | 80 | | { |
| | 0 | 81 | | var tunerCount = tunerHost.TunerCount; |
| | | 82 | | |
| | 0 | 83 | | if (tunerCount > 0) |
| | | 84 | | { |
| | 0 | 85 | | var tunerHostId = tunerHost.Id; |
| | 0 | 86 | | var liveStreams = currentLiveStreams.Where(i => string.Equals(i.TunerHostId, tunerHostId, StringComparis |
| | | 87 | | |
| | 0 | 88 | | if (liveStreams.Count() >= tunerCount) |
| | | 89 | | { |
| | 0 | 90 | | throw new LiveTvConflictException("M3U simultaneous stream limit has been reached."); |
| | | 91 | | } |
| | | 92 | | } |
| | | 93 | | |
| | 0 | 94 | | var sources = await GetChannelStreamMediaSources(tunerHost, channel, cancellationToken).ConfigureAwait(false |
| | | 95 | | |
| | 0 | 96 | | var mediaSource = sources[0]; |
| | | 97 | | |
| | 0 | 98 | | if (tunerHost.AllowStreamSharing && mediaSource.Protocol == MediaProtocol.Http && !mediaSource.RequiresLoopi |
| | | 99 | | { |
| | 0 | 100 | | var extension = Path.GetExtension(new UriBuilder(mediaSource.Path).Path); |
| | | 101 | | |
| | 0 | 102 | | if (string.IsNullOrEmpty(extension)) |
| | | 103 | | { |
| | | 104 | | try |
| | | 105 | | { |
| | 0 | 106 | | using var message = new HttpRequestMessage(HttpMethod.Head, mediaSource.Path); |
| | 0 | 107 | | using var response = await _httpClientFactory.CreateClient(NamedClient.Default) |
| | 0 | 108 | | .SendAsync(message, cancellationToken) |
| | 0 | 109 | | .ConfigureAwait(false); |
| | | 110 | | |
| | 0 | 111 | | if (response.IsSuccessStatusCode) |
| | | 112 | | { |
| | 0 | 113 | | if (_mimeTypesCanShareHttpStream.Contains(response.Content.Headers.ContentType?.MediaType, S |
| | | 114 | | { |
| | 0 | 115 | | return new SharedHttpStream(mediaSource, tunerHost, streamId, FileSystem, _httpClientFac |
| | | 116 | | } |
| | | 117 | | } |
| | 0 | 118 | | } |
| | 0 | 119 | | catch (Exception) |
| | | 120 | | { |
| | 0 | 121 | | Logger.LogWarning("HEAD request to check MIME type failed, shared stream disabled"); |
| | 0 | 122 | | } |
| | | 123 | | } |
| | 0 | 124 | | else if (_extensionsCanShareHttpStream.Contains(extension, StringComparison.OrdinalIgnoreCase)) |
| | | 125 | | { |
| | 0 | 126 | | return new SharedHttpStream(mediaSource, tunerHost, streamId, FileSystem, _httpClientFactory, Logger |
| | | 127 | | } |
| | | 128 | | } |
| | | 129 | | |
| | 0 | 130 | | return new LiveStream(mediaSource, tunerHost, FileSystem, Logger, Config, _streamHelper); |
| | 0 | 131 | | } |
| | | 132 | | |
| | | 133 | | public async Task Validate(TunerHostInfo info) |
| | | 134 | | { |
| | 2 | 135 | | using (await new M3uParser(Logger, _httpClientFactory).GetListingsStream(info, CancellationToken.None).Confi |
| | | 136 | | { |
| | 1 | 137 | | } |
| | 1 | 138 | | } |
| | | 139 | | |
| | | 140 | | protected override Task<List<MediaSourceInfo>> GetChannelStreamMediaSources(TunerHostInfo tuner, ChannelInfo cha |
| | | 141 | | { |
| | 5 | 142 | | return Task.FromResult(new List<MediaSourceInfo> { CreateMediaSourceInfo(tuner, channel) }); |
| | | 143 | | } |
| | | 144 | | |
| | | 145 | | protected virtual MediaSourceInfo CreateMediaSourceInfo(TunerHostInfo info, ChannelInfo channel) |
| | | 146 | | { |
| | 5 | 147 | | var path = channel.Path; |
| | | 148 | | |
| | 5 | 149 | | var supportsDirectPlay = !info.EnableStreamLooping && info.TunerCount == 0; |
| | 5 | 150 | | var supportsDirectStream = !info.EnableStreamLooping; |
| | | 151 | | |
| | 5 | 152 | | var protocol = _mediaSourceManager.GetPathProtocol(path); |
| | | 153 | | |
| | 5 | 154 | | var isRemote = true; |
| | 5 | 155 | | Uri.TryCreate(path, UriKind.Absolute, out var uri); |
| | 5 | 156 | | if (uri is not null) |
| | | 157 | | { |
| | 5 | 158 | | isRemote = !_networkManager.IsInLocalNetwork(uri.Host); |
| | | 159 | | } |
| | | 160 | | |
| | | 161 | | // A manifest is not a byte stream. Serving one directly hands the client a playlist whose |
| | | 162 | | // variant and segment URIs are relative to the origin, and those do not resolve against the |
| | | 163 | | // Jellyfin url the client fetched it from. Remux or transcode these instead. |
| | 5 | 164 | | if (IsManifest(path, uri)) |
| | | 165 | | { |
| | 3 | 166 | | supportsDirectPlay = false; |
| | | 167 | | } |
| | | 168 | | |
| | 5 | 169 | | var httpHeaders = new Dictionary<string, string>(); |
| | | 170 | | |
| | 5 | 171 | | if (protocol == MediaProtocol.Http) |
| | | 172 | | { |
| | | 173 | | // Use user-defined user-agent. If there isn't one, make it look like a browser. |
| | 5 | 174 | | httpHeaders[HeaderNames.UserAgent] = string.IsNullOrWhiteSpace(info.UserAgent) ? |
| | 5 | 175 | | "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 S |
| | 5 | 176 | | info.UserAgent; |
| | | 177 | | } |
| | | 178 | | |
| | 5 | 179 | | var mediaSource = new MediaSourceInfo |
| | 5 | 180 | | { |
| | 5 | 181 | | Path = path, |
| | 5 | 182 | | Protocol = protocol, |
| | 5 | 183 | | MediaStreams = new MediaStream[] |
| | 5 | 184 | | { |
| | 5 | 185 | | new MediaStream |
| | 5 | 186 | | { |
| | 5 | 187 | | Type = MediaStreamType.Video, |
| | 5 | 188 | | // Set the index to -1 because we don't know the exact index of the video stream within the cont |
| | 5 | 189 | | Index = -1, |
| | 5 | 190 | | IsInterlaced = true |
| | 5 | 191 | | }, |
| | 5 | 192 | | new MediaStream |
| | 5 | 193 | | { |
| | 5 | 194 | | Type = MediaStreamType.Audio, |
| | 5 | 195 | | // Set the index to -1 because we don't know the exact index of the audio stream within the cont |
| | 5 | 196 | | Index = -1 |
| | 5 | 197 | | } |
| | 5 | 198 | | }, |
| | 5 | 199 | | RequiresOpening = true, |
| | 5 | 200 | | RequiresClosing = true, |
| | 5 | 201 | | RequiresLooping = info.EnableStreamLooping, |
| | 5 | 202 | | |
| | 5 | 203 | | ReadAtNativeFramerate = info.ReadAtNativeFramerate, |
| | 5 | 204 | | |
| | 5 | 205 | | Id = channel.Path.GetMD5().ToString("N", CultureInfo.InvariantCulture), |
| | 5 | 206 | | IsInfiniteStream = true, |
| | 5 | 207 | | IsRemote = isRemote, |
| | 5 | 208 | | |
| | 5 | 209 | | IgnoreDts = info.IgnoreDts, |
| | 5 | 210 | | SupportsDirectPlay = supportsDirectPlay, |
| | 5 | 211 | | SupportsDirectStream = supportsDirectStream, |
| | 5 | 212 | | |
| | 5 | 213 | | RequiredHttpHeaders = httpHeaders, |
| | 5 | 214 | | UseMostCompatibleTranscodingProfile = !info.AllowFmp4TranscodingContainer, |
| | 5 | 215 | | FallbackMaxStreamingBitrate = info.FallbackMaxStreamingBitrate |
| | 5 | 216 | | }; |
| | | 217 | | |
| | 5 | 218 | | mediaSource.InferTotalBitrate(); |
| | | 219 | | |
| | 5 | 220 | | return mediaSource; |
| | | 221 | | } |
| | | 222 | | |
| | | 223 | | /// <summary> |
| | | 224 | | /// Determines whether a channel path points at an HLS or DASH manifest rather than at a byte stream. |
| | | 225 | | /// </summary> |
| | | 226 | | /// <param name="path">The channel path.</param> |
| | | 227 | | /// <param name="uri">The channel path parsed as an absolute uri, or <c>null</c> if it is not one.</param> |
| | | 228 | | /// <returns><c>true</c> if the path names a streaming manifest.</returns> |
| | | 229 | | private static bool IsManifest(string path, Uri uri) |
| | | 230 | | { |
| | | 231 | | // Use the uri path when there is one so that a query string does not hide the extension. |
| | 5 | 232 | | var extension = Path.GetExtension(uri is null ? path : uri.AbsolutePath); |
| | | 233 | | |
| | 5 | 234 | | return _manifestExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase); |
| | | 235 | | } |
| | | 236 | | |
| | | 237 | | public Task<List<TunerHostInfo>> DiscoverDevices(int discoveryDurationMs, CancellationToken cancellationToken) |
| | | 238 | | { |
| | 1 | 239 | | return Task.FromResult(new List<TunerHostInfo>()); |
| | | 240 | | } |
| | | 241 | | } |
| | | 242 | | } |