| | | 1 | | using System; |
| | | 2 | | using System.Collections.Generic; |
| | | 3 | | using System.Globalization; |
| | | 4 | | using System.Linq; |
| | | 5 | | using Jellyfin.Data.Enums; |
| | | 6 | | using Jellyfin.Extensions; |
| | | 7 | | using MediaBrowser.Model.Dto; |
| | | 8 | | using MediaBrowser.Model.Entities; |
| | | 9 | | using MediaBrowser.Model.Extensions; |
| | | 10 | | using MediaBrowser.Model.MediaInfo; |
| | | 11 | | using MediaBrowser.Model.Session; |
| | | 12 | | using Microsoft.Extensions.Logging; |
| | | 13 | | |
| | | 14 | | namespace MediaBrowser.Model.Dlna |
| | | 15 | | { |
| | | 16 | | /// <summary> |
| | | 17 | | /// Class StreamBuilder. |
| | | 18 | | /// </summary> |
| | | 19 | | public class StreamBuilder |
| | | 20 | | { |
| | | 21 | | // Aliases |
| | | 22 | | internal const TranscodeReason ContainerReasons = TranscodeReason.ContainerNotSupported | TranscodeReason.Contai |
| | | 23 | | internal const TranscodeReason AudioCodecReasons = TranscodeReason.AudioBitrateNotSupported | TranscodeReason.Au |
| | | 24 | | internal const TranscodeReason AudioReasons = TranscodeReason.AudioCodecNotSupported | AudioCodecReasons; |
| | | 25 | | internal const TranscodeReason VideoCodecReasons = TranscodeReason.VideoResolutionNotSupported | TranscodeReason |
| | | 26 | | internal const TranscodeReason VideoReasons = TranscodeReason.VideoCodecNotSupported | VideoCodecReasons; |
| | | 27 | | internal const TranscodeReason DirectStreamReasons = AudioReasons | TranscodeReason.ContainerNotSupported | Tran |
| | | 28 | | |
| | | 29 | | private readonly ILogger _logger; |
| | | 30 | | private readonly ITranscoderSupport _transcoderSupport; |
| | 1 | 31 | | private static readonly string[] _supportedHlsVideoCodecs = ["h264", "hevc", "vp9", "av1"]; |
| | 1 | 32 | | private static readonly string[] _supportedHlsAudioCodecsTs = ["aac", "ac3", "eac3", "mp3"]; |
| | 1 | 33 | | private static readonly string[] _supportedHlsAudioCodecsMp4 = ["aac", "ac3", "eac3", "mp3", "alac", "flac", "op |
| | | 34 | | |
| | | 35 | | /// <summary> |
| | | 36 | | /// Initializes a new instance of the <see cref="StreamBuilder"/> class. |
| | | 37 | | /// </summary> |
| | | 38 | | /// <param name="transcoderSupport">The <see cref="ITranscoderSupport"/> object.</param> |
| | | 39 | | /// <param name="logger">The <see cref="ILogger"/> object.</param> |
| | | 40 | | public StreamBuilder(ITranscoderSupport transcoderSupport, ILogger logger) |
| | | 41 | | { |
| | 280 | 42 | | _transcoderSupport = transcoderSupport; |
| | 280 | 43 | | _logger = logger; |
| | 280 | 44 | | } |
| | | 45 | | |
| | | 46 | | /// <summary> |
| | | 47 | | /// Gets the optimal audio stream. |
| | | 48 | | /// </summary> |
| | | 49 | | /// <param name="options">The <see cref="MediaOptions"/> object to get the audio stream from.</param> |
| | | 50 | | /// <returns>The <see cref="StreamInfo"/> of the optimal audio stream.</returns> |
| | | 51 | | public StreamInfo? GetOptimalAudioStream(MediaOptions options) |
| | | 52 | | { |
| | 0 | 53 | | ValidateMediaOptions(options, false); |
| | | 54 | | |
| | 0 | 55 | | List<StreamInfo> streams = []; |
| | 0 | 56 | | foreach (var mediaSource in options.MediaSources) |
| | | 57 | | { |
| | 0 | 58 | | if (!(string.IsNullOrEmpty(options.MediaSourceId) |
| | 0 | 59 | | || string.Equals(mediaSource.Id, options.MediaSourceId, StringComparison.OrdinalIgnoreCase))) |
| | | 60 | | { |
| | | 61 | | continue; |
| | | 62 | | } |
| | | 63 | | |
| | 0 | 64 | | StreamInfo? streamInfo = GetOptimalAudioStream(mediaSource, options); |
| | 0 | 65 | | if (streamInfo is not null) |
| | | 66 | | { |
| | 0 | 67 | | streamInfo.DeviceId = options.DeviceId; |
| | 0 | 68 | | streamInfo.DeviceProfileId = options.Profile.Id?.ToString("N", CultureInfo.InvariantCulture); |
| | 0 | 69 | | streams.Add(streamInfo); |
| | | 70 | | } |
| | | 71 | | } |
| | | 72 | | |
| | 0 | 73 | | return GetOptimalStream(streams, options.GetMaxBitrate(true) ?? 0); |
| | | 74 | | } |
| | | 75 | | |
| | | 76 | | private StreamInfo? GetOptimalAudioStream(MediaSourceInfo item, MediaOptions options) |
| | | 77 | | { |
| | 0 | 78 | | var playlistItem = new StreamInfo |
| | 0 | 79 | | { |
| | 0 | 80 | | ItemId = options.ItemId, |
| | 0 | 81 | | MediaType = DlnaProfileType.Audio, |
| | 0 | 82 | | MediaSource = item, |
| | 0 | 83 | | RunTimeTicks = item.RunTimeTicks, |
| | 0 | 84 | | Context = options.Context, |
| | 0 | 85 | | DeviceProfile = options.Profile |
| | 0 | 86 | | }; |
| | | 87 | | |
| | 0 | 88 | | if (options.ForceDirectPlay) |
| | | 89 | | { |
| | 0 | 90 | | playlistItem.PlayMethod = PlayMethod.DirectPlay; |
| | 0 | 91 | | playlistItem.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, |
| | 0 | 92 | | return playlistItem; |
| | | 93 | | } |
| | | 94 | | |
| | 0 | 95 | | if (options.ForceDirectStream) |
| | | 96 | | { |
| | 0 | 97 | | playlistItem.PlayMethod = PlayMethod.DirectStream; |
| | 0 | 98 | | playlistItem.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, |
| | 0 | 99 | | return playlistItem; |
| | | 100 | | } |
| | | 101 | | |
| | 0 | 102 | | MediaStream audioStream = item.GetDefaultAudioStream(null); |
| | | 103 | | |
| | 0 | 104 | | ArgumentNullException.ThrowIfNull(audioStream); |
| | | 105 | | |
| | 0 | 106 | | var directPlayInfo = GetAudioDirectPlayProfile(item, audioStream, options); |
| | | 107 | | |
| | 0 | 108 | | var directPlayMethod = directPlayInfo.PlayMethod; |
| | 0 | 109 | | var transcodeReasons = directPlayInfo.TranscodeReasons; |
| | | 110 | | |
| | 0 | 111 | | if (directPlayMethod is PlayMethod.DirectPlay) |
| | | 112 | | { |
| | 0 | 113 | | var audioFailureReasons = GetCompatibilityAudioCodec(options, item, item.Container, audioStream, null, f |
| | 0 | 114 | | transcodeReasons |= audioFailureReasons; |
| | | 115 | | |
| | 0 | 116 | | if (audioFailureReasons == 0) |
| | | 117 | | { |
| | 0 | 118 | | playlistItem.PlayMethod = directPlayMethod.Value; |
| | 0 | 119 | | playlistItem.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profi |
| | | 120 | | |
| | 0 | 121 | | return playlistItem; |
| | | 122 | | } |
| | | 123 | | } |
| | | 124 | | |
| | 0 | 125 | | if (directPlayMethod is PlayMethod.DirectStream) |
| | | 126 | | { |
| | 0 | 127 | | var remuxContainer = item.TranscodingContainer ?? "ts"; |
| | 0 | 128 | | string[] supportedHlsContainers = ["ts", "mp4"]; |
| | | 129 | | // If the container specified for the profile is an HLS supported container, use that container instead, |
| | | 130 | | // The client should be responsible to ensure this container is compatible |
| | 0 | 131 | | remuxContainer = Array.Exists(supportedHlsContainers, element => string.Equals(element, directPlayInfo.P |
| | | 132 | | bool codeIsSupported; |
| | 0 | 133 | | if (item.TranscodingSubProtocol == MediaStreamProtocol.hls) |
| | | 134 | | { |
| | | 135 | | // Enforce HLS audio codec restrictions |
| | 0 | 136 | | if (string.Equals(remuxContainer, "mp4", StringComparison.OrdinalIgnoreCase)) |
| | | 137 | | { |
| | 0 | 138 | | codeIsSupported = _supportedHlsAudioCodecsMp4.Contains(directPlayInfo.Profile?.AudioCodec ?? dir |
| | | 139 | | } |
| | | 140 | | else |
| | | 141 | | { |
| | 0 | 142 | | codeIsSupported = _supportedHlsAudioCodecsTs.Contains(directPlayInfo.Profile?.AudioCodec ?? dire |
| | | 143 | | } |
| | | 144 | | } |
| | | 145 | | else |
| | | 146 | | { |
| | | 147 | | // Let's assume the client has given a correct container for http |
| | 0 | 148 | | codeIsSupported = true; |
| | | 149 | | } |
| | | 150 | | |
| | 0 | 151 | | if (codeIsSupported) |
| | | 152 | | { |
| | 0 | 153 | | playlistItem.PlayMethod = directPlayMethod.Value; |
| | 0 | 154 | | playlistItem.Container = remuxContainer; |
| | 0 | 155 | | playlistItem.TranscodeReasons = transcodeReasons; |
| | 0 | 156 | | playlistItem.SubProtocol = item.TranscodingSubProtocol; |
| | 0 | 157 | | item.TranscodingContainer = remuxContainer; |
| | 0 | 158 | | return playlistItem; |
| | | 159 | | } |
| | | 160 | | |
| | 0 | 161 | | transcodeReasons |= TranscodeReason.AudioCodecNotSupported; |
| | 0 | 162 | | playlistItem.TranscodeReasons = transcodeReasons; |
| | | 163 | | } |
| | | 164 | | |
| | 0 | 165 | | TranscodingProfile? transcodingProfile = null; |
| | 0 | 166 | | foreach (var tcProfile in options.Profile.TranscodingProfiles) |
| | | 167 | | { |
| | 0 | 168 | | if (tcProfile.Type == playlistItem.MediaType |
| | 0 | 169 | | && tcProfile.Context == options.Context |
| | 0 | 170 | | && _transcoderSupport.CanEncodeToAudioCodec(tcProfile.AudioCodec ?? tcProfile.Container)) |
| | | 171 | | { |
| | 0 | 172 | | transcodingProfile = tcProfile; |
| | 0 | 173 | | break; |
| | | 174 | | } |
| | | 175 | | } |
| | | 176 | | |
| | 0 | 177 | | if (transcodingProfile is not null) |
| | | 178 | | { |
| | 0 | 179 | | if (!item.SupportsTranscoding) |
| | | 180 | | { |
| | 0 | 181 | | return null; |
| | | 182 | | } |
| | | 183 | | |
| | 0 | 184 | | SetStreamInfoOptionsFromTranscodingProfile(item, playlistItem, transcodingProfile); |
| | | 185 | | |
| | 0 | 186 | | var inputAudioChannels = audioStream.Channels; |
| | 0 | 187 | | var inputAudioBitrate = audioStream.BitRate; |
| | 0 | 188 | | var inputAudioSampleRate = audioStream.SampleRate; |
| | 0 | 189 | | var inputAudioBitDepth = audioStream.BitDepth; |
| | | 190 | | |
| | 0 | 191 | | var audioTranscodingConditions = GetProfileConditionsForAudio(options.Profile.CodecProfiles, transcoding |
| | 0 | 192 | | ApplyTranscodingConditions(playlistItem, audioTranscodingConditions, null, true, true); |
| | | 193 | | |
| | | 194 | | // Honor requested max channels |
| | 0 | 195 | | playlistItem.GlobalMaxAudioChannels = options.MaxAudioChannels; |
| | | 196 | | |
| | 0 | 197 | | var configuredBitrate = options.GetMaxBitrate(true); |
| | | 198 | | |
| | 0 | 199 | | long transcodingBitrate = options.AudioTranscodingBitrate |
| | 0 | 200 | | ?? (options.Context == EncodingContext.Streaming ? options.Profile.MusicStreamingTranscodingBitrate |
| | 0 | 201 | | ?? configuredBitrate |
| | 0 | 202 | | ?? 128000; |
| | | 203 | | |
| | 0 | 204 | | if (configuredBitrate.HasValue) |
| | | 205 | | { |
| | 0 | 206 | | transcodingBitrate = Math.Min(configuredBitrate.Value, transcodingBitrate); |
| | | 207 | | } |
| | | 208 | | |
| | 0 | 209 | | var longBitrate = Math.Min(transcodingBitrate, playlistItem.AudioBitrate ?? transcodingBitrate); |
| | 0 | 210 | | playlistItem.AudioBitrate = longBitrate > int.MaxValue ? int.MaxValue : Convert.ToInt32(longBitrate); |
| | | 211 | | |
| | | 212 | | // Pure audio transcoding does not support comma separated list of transcoding codec at the moment. |
| | | 213 | | // So just use the AudioCodec as is would be safe enough as the _transcoderSupport.CanEncodeToAudioCodec |
| | | 214 | | // would fail so this profile will not even be picked up. |
| | 0 | 215 | | if (playlistItem.AudioCodecs.Count == 0 && !string.IsNullOrWhiteSpace(transcodingProfile.AudioCodec)) |
| | | 216 | | { |
| | 0 | 217 | | playlistItem.AudioCodecs = [transcodingProfile.AudioCodec]; |
| | | 218 | | } |
| | | 219 | | } |
| | | 220 | | |
| | 0 | 221 | | playlistItem.TranscodeReasons = transcodeReasons; |
| | 0 | 222 | | return playlistItem; |
| | | 223 | | } |
| | | 224 | | |
| | | 225 | | /// <summary> |
| | | 226 | | /// Gets the optimal video stream. |
| | | 227 | | /// </summary> |
| | | 228 | | /// <param name="options">The <see cref="MediaOptions"/> object to get the video stream from.</param> |
| | | 229 | | /// <returns>The <see cref="StreamInfo"/> of the optimal video stream.</returns> |
| | | 230 | | public StreamInfo? GetOptimalVideoStream(MediaOptions options) |
| | | 231 | | { |
| | 280 | 232 | | ValidateMediaOptions(options, true); |
| | | 233 | | |
| | 280 | 234 | | var mediaSources = string.IsNullOrEmpty(options.MediaSourceId) |
| | 280 | 235 | | ? options.MediaSources |
| | 280 | 236 | | : options.MediaSources.Where(x => string.Equals(x.Id, options.MediaSourceId, StringComparison.OrdinalIgn |
| | | 237 | | |
| | 280 | 238 | | List<StreamInfo> streams = []; |
| | 1120 | 239 | | foreach (var mediaSourceInfo in mediaSources) |
| | | 240 | | { |
| | 280 | 241 | | var streamInfo = BuildVideoItem(mediaSourceInfo, options); |
| | 280 | 242 | | if (streamInfo is not null) |
| | | 243 | | { |
| | 280 | 244 | | streams.Add(streamInfo); |
| | | 245 | | } |
| | | 246 | | } |
| | | 247 | | |
| | 1120 | 248 | | foreach (var stream in streams) |
| | | 249 | | { |
| | 280 | 250 | | stream.DeviceId = options.DeviceId; |
| | 280 | 251 | | stream.DeviceProfileId = options.Profile.Id?.ToString("N", CultureInfo.InvariantCulture); |
| | | 252 | | } |
| | | 253 | | |
| | 280 | 254 | | return GetOptimalStream(streams, options.GetMaxBitrate(false) ?? 0); |
| | | 255 | | } |
| | | 256 | | |
| | | 257 | | private static StreamInfo? GetOptimalStream(List<StreamInfo> streams, long maxBitrate) |
| | 280 | 258 | | => SortMediaSources(streams, maxBitrate).FirstOrDefault(); |
| | | 259 | | |
| | | 260 | | private static IOrderedEnumerable<StreamInfo> SortMediaSources(List<StreamInfo> streams, long maxBitrate) |
| | | 261 | | { |
| | 280 | 262 | | return streams.OrderBy(i => |
| | 280 | 263 | | { |
| | 280 | 264 | | // Nothing beats direct playing a file |
| | 280 | 265 | | if (i.PlayMethod == PlayMethod.DirectPlay && i.MediaSource?.Protocol == MediaProtocol.File) |
| | 280 | 266 | | { |
| | 280 | 267 | | return 0; |
| | 280 | 268 | | } |
| | 280 | 269 | | |
| | 280 | 270 | | return 1; |
| | 280 | 271 | | }).ThenBy(i => |
| | 280 | 272 | | { |
| | 280 | 273 | | switch (i.PlayMethod) |
| | 280 | 274 | | { |
| | 280 | 275 | | // Let's assume direct streaming a file is just as desirable as direct playing a remote url |
| | 280 | 276 | | case PlayMethod.DirectStream: |
| | 280 | 277 | | case PlayMethod.DirectPlay: |
| | 280 | 278 | | return 0; |
| | 280 | 279 | | default: |
| | 280 | 280 | | return 1; |
| | 280 | 281 | | } |
| | 280 | 282 | | }).ThenBy(i => |
| | 280 | 283 | | { |
| | 280 | 284 | | switch (i.MediaSource?.Protocol) |
| | 280 | 285 | | { |
| | 280 | 286 | | case MediaProtocol.File: |
| | 280 | 287 | | return 0; |
| | 280 | 288 | | default: |
| | 280 | 289 | | return 1; |
| | 280 | 290 | | } |
| | 280 | 291 | | }).ThenBy(i => |
| | 280 | 292 | | { |
| | 280 | 293 | | if (maxBitrate > 0) |
| | 280 | 294 | | { |
| | 280 | 295 | | if (i.MediaSource?.Bitrate is not null) |
| | 280 | 296 | | { |
| | 280 | 297 | | return Math.Abs(i.MediaSource.Bitrate.Value - maxBitrate); |
| | 280 | 298 | | } |
| | 280 | 299 | | } |
| | 280 | 300 | | |
| | 280 | 301 | | return 0; |
| | 280 | 302 | | }).ThenBy(streams.IndexOf); |
| | | 303 | | } |
| | | 304 | | |
| | | 305 | | private static TranscodeReason GetTranscodeReasonForFailedCondition(ProfileCondition condition) |
| | | 306 | | { |
| | 248 | 307 | | switch (condition.Property) |
| | | 308 | | { |
| | | 309 | | case ProfileConditionValue.AudioBitrate: |
| | 0 | 310 | | return TranscodeReason.AudioBitrateNotSupported; |
| | | 311 | | |
| | | 312 | | case ProfileConditionValue.AudioChannels: |
| | 122 | 313 | | return TranscodeReason.AudioChannelsNotSupported; |
| | | 314 | | |
| | | 315 | | case ProfileConditionValue.AudioProfile: |
| | 0 | 316 | | return TranscodeReason.AudioProfileNotSupported; |
| | | 317 | | |
| | | 318 | | case ProfileConditionValue.AudioSampleRate: |
| | 0 | 319 | | return TranscodeReason.AudioSampleRateNotSupported; |
| | | 320 | | |
| | | 321 | | case ProfileConditionValue.Has64BitOffsets: |
| | | 322 | | // TODO |
| | 0 | 323 | | return 0; |
| | | 324 | | |
| | | 325 | | case ProfileConditionValue.Height: |
| | 0 | 326 | | return TranscodeReason.VideoResolutionNotSupported; |
| | | 327 | | |
| | | 328 | | case ProfileConditionValue.IsAnamorphic: |
| | 0 | 329 | | return TranscodeReason.AnamorphicVideoNotSupported; |
| | | 330 | | |
| | | 331 | | case ProfileConditionValue.IsAvc: |
| | | 332 | | // TODO |
| | 0 | 333 | | return 0; |
| | | 334 | | |
| | | 335 | | case ProfileConditionValue.IsInterlaced: |
| | 0 | 336 | | return TranscodeReason.InterlacedVideoNotSupported; |
| | | 337 | | |
| | | 338 | | case ProfileConditionValue.IsSecondaryAudio: |
| | 35 | 339 | | return TranscodeReason.SecondaryAudioNotSupported; |
| | | 340 | | |
| | | 341 | | case ProfileConditionValue.NumStreams: |
| | 2 | 342 | | return TranscodeReason.StreamCountExceedsLimit; |
| | | 343 | | |
| | | 344 | | case ProfileConditionValue.NumAudioStreams: |
| | | 345 | | // TODO |
| | 0 | 346 | | return 0; |
| | | 347 | | |
| | | 348 | | case ProfileConditionValue.NumVideoStreams: |
| | | 349 | | // TODO |
| | 0 | 350 | | return 0; |
| | | 351 | | |
| | | 352 | | case ProfileConditionValue.PacketLength: |
| | | 353 | | // TODO |
| | 0 | 354 | | return 0; |
| | | 355 | | |
| | | 356 | | case ProfileConditionValue.RefFrames: |
| | 0 | 357 | | return TranscodeReason.RefFramesNotSupported; |
| | | 358 | | |
| | | 359 | | case ProfileConditionValue.VideoBitDepth: |
| | 0 | 360 | | return TranscodeReason.VideoBitDepthNotSupported; |
| | | 361 | | |
| | | 362 | | case ProfileConditionValue.AudioBitDepth: |
| | 0 | 363 | | return TranscodeReason.AudioBitDepthNotSupported; |
| | | 364 | | |
| | | 365 | | case ProfileConditionValue.VideoBitrate: |
| | 4 | 366 | | return TranscodeReason.VideoBitrateNotSupported; |
| | | 367 | | |
| | | 368 | | case ProfileConditionValue.VideoCodecTag: |
| | 18 | 369 | | return TranscodeReason.VideoCodecTagNotSupported; |
| | | 370 | | |
| | | 371 | | case ProfileConditionValue.VideoFramerate: |
| | 0 | 372 | | return TranscodeReason.VideoFramerateNotSupported; |
| | | 373 | | |
| | | 374 | | case ProfileConditionValue.VideoLevel: |
| | 13 | 375 | | return TranscodeReason.VideoLevelNotSupported; |
| | | 376 | | |
| | | 377 | | case ProfileConditionValue.VideoProfile: |
| | 25 | 378 | | return TranscodeReason.VideoProfileNotSupported; |
| | | 379 | | |
| | | 380 | | case ProfileConditionValue.VideoRangeType: |
| | 28 | 381 | | return TranscodeReason.VideoRangeTypeNotSupported; |
| | | 382 | | |
| | | 383 | | case ProfileConditionValue.VideoRotation: |
| | 1 | 384 | | return TranscodeReason.VideoRotationNotSupported; |
| | | 385 | | |
| | | 386 | | case ProfileConditionValue.VideoTimestamp: |
| | | 387 | | // TODO |
| | 0 | 388 | | return 0; |
| | | 389 | | |
| | | 390 | | case ProfileConditionValue.Width: |
| | 0 | 391 | | return TranscodeReason.VideoResolutionNotSupported; |
| | | 392 | | |
| | | 393 | | default: |
| | 0 | 394 | | return 0; |
| | | 395 | | } |
| | | 396 | | } |
| | | 397 | | |
| | | 398 | | /// <summary> |
| | | 399 | | /// Normalizes input container. |
| | | 400 | | /// </summary> |
| | | 401 | | /// <param name="inputContainer">The input container.</param> |
| | | 402 | | /// <param name="profile">The <see cref="DeviceProfile"/>.</param> |
| | | 403 | | /// <param name="type">The <see cref="DlnaProfileType"/>.</param> |
| | | 404 | | /// <param name="playProfile">The <see cref="DirectPlayProfile"/> object to get the video stream from.</param> |
| | | 405 | | /// <returns>The normalized input container.</returns> |
| | | 406 | | public static string? NormalizeMediaSourceFormatIntoSingleContainer(string inputContainer, DeviceProfile? profil |
| | | 407 | | { |
| | | 408 | | // If the source is Live TV the inputContainer will be null until the mediasource is probed on first access |
| | 405 | 409 | | if (profile is null || string.IsNullOrEmpty(inputContainer) || !inputContainer.Contains(',', StringCompariso |
| | | 410 | | { |
| | 94 | 411 | | return inputContainer; |
| | | 412 | | } |
| | | 413 | | |
| | 311 | 414 | | var formats = ContainerHelper.Split(inputContainer); |
| | 311 | 415 | | var playProfiles = playProfile is null ? profile.DirectPlayProfiles : [playProfile]; |
| | 1370 | 416 | | foreach (var format in formats) |
| | | 417 | | { |
| | 2602 | 418 | | foreach (var directPlayProfile in playProfiles) |
| | | 419 | | { |
| | 927 | 420 | | if (directPlayProfile.Type != type) |
| | | 421 | | { |
| | | 422 | | continue; |
| | | 423 | | } |
| | | 424 | | |
| | 699 | 425 | | if (directPlayProfile.SupportsContainer(format)) |
| | | 426 | | { |
| | 294 | 427 | | return format; |
| | | 428 | | } |
| | | 429 | | } |
| | | 430 | | } |
| | | 431 | | |
| | 17 | 432 | | return inputContainer; |
| | | 433 | | } |
| | | 434 | | |
| | | 435 | | private (DirectPlayProfile? Profile, PlayMethod? PlayMethod, TranscodeReason TranscodeReasons) GetAudioDirectPla |
| | | 436 | | { |
| | 0 | 437 | | var directPlayProfile = options.Profile.DirectPlayProfiles |
| | 0 | 438 | | .FirstOrDefault(x => x.Type == DlnaProfileType.Audio && IsAudioDirectPlaySupported(x, item, audioStream) |
| | | 439 | | |
| | 0 | 440 | | TranscodeReason transcodeReasons = 0; |
| | 0 | 441 | | if (directPlayProfile is null) |
| | | 442 | | { |
| | 0 | 443 | | _logger.LogDebug( |
| | 0 | 444 | | "Profile: {0}, No audio direct play profiles found for {1} with codec {2}", |
| | 0 | 445 | | options.Profile.Name ?? "Unknown Profile", |
| | 0 | 446 | | item.Path ?? "Unknown path", |
| | 0 | 447 | | audioStream.Codec ?? "Unknown codec"); |
| | | 448 | | |
| | 0 | 449 | | var directStreamProfile = options.Profile.DirectPlayProfiles |
| | 0 | 450 | | .FirstOrDefault(x => x.Type == DlnaProfileType.Audio && IsAudioDirectStreamSupported(x, item, audioS |
| | | 451 | | |
| | 0 | 452 | | if (directStreamProfile is not null) |
| | | 453 | | { |
| | 0 | 454 | | directPlayProfile = directStreamProfile; |
| | 0 | 455 | | transcodeReasons |= TranscodeReason.ContainerNotSupported; |
| | | 456 | | } |
| | | 457 | | else |
| | | 458 | | { |
| | 0 | 459 | | return (null, null, GetTranscodeReasonsFromDirectPlayProfile(item, null, audioStream, options.Profil |
| | | 460 | | } |
| | | 461 | | } |
| | | 462 | | |
| | | 463 | | // The profile describes what the device supports |
| | | 464 | | // If device requirements are satisfied then allow both direct stream and direct play |
| | | 465 | | // Note: As of 10.10 codebase, SupportsDirectPlay is always true because the MediaSourceInfo initializes thi |
| | | 466 | | // Need to check additionally for current transcode reasons |
| | 0 | 467 | | if (item.SupportsDirectPlay && transcodeReasons == 0) |
| | | 468 | | { |
| | 0 | 469 | | if (!IsBitrateLimitExceeded(item, options.GetMaxBitrate(true) ?? 0)) |
| | | 470 | | { |
| | 0 | 471 | | if (options.EnableDirectPlay) |
| | | 472 | | { |
| | 0 | 473 | | return (directPlayProfile, PlayMethod.DirectPlay, 0); |
| | | 474 | | } |
| | | 475 | | } |
| | | 476 | | else |
| | | 477 | | { |
| | 0 | 478 | | transcodeReasons |= TranscodeReason.ContainerBitrateExceedsLimit; |
| | | 479 | | } |
| | | 480 | | } |
| | | 481 | | |
| | | 482 | | // While options takes the network and other factors into account. Only applies to direct stream |
| | 0 | 483 | | if (item.SupportsDirectStream) |
| | | 484 | | { |
| | 0 | 485 | | if (!IsBitrateLimitExceeded(item, options.GetMaxBitrate(true) ?? 0)) |
| | | 486 | | { |
| | | 487 | | // Note: as of 10.10 codebase, the options.EnableDirectStream is always false due to |
| | | 488 | | // "direct-stream http streaming is currently broken" |
| | | 489 | | // Don't check that option for audio as we always assume that is supported |
| | 0 | 490 | | if (transcodeReasons == TranscodeReason.ContainerNotSupported) |
| | | 491 | | { |
| | 0 | 492 | | return (directPlayProfile, PlayMethod.DirectStream, transcodeReasons); |
| | | 493 | | } |
| | | 494 | | } |
| | | 495 | | else |
| | | 496 | | { |
| | 0 | 497 | | transcodeReasons |= TranscodeReason.ContainerBitrateExceedsLimit; |
| | | 498 | | } |
| | | 499 | | } |
| | | 500 | | |
| | 0 | 501 | | return (directPlayProfile, null, transcodeReasons); |
| | | 502 | | } |
| | | 503 | | |
| | | 504 | | private static TranscodeReason GetTranscodeReasonsFromDirectPlayProfile(MediaSourceInfo item, MediaStream? video |
| | | 505 | | { |
| | 0 | 506 | | var mediaType = videoStream is null ? DlnaProfileType.Audio : DlnaProfileType.Video; |
| | | 507 | | |
| | 0 | 508 | | var containerSupported = false; |
| | 0 | 509 | | var audioSupported = false; |
| | 0 | 510 | | var videoSupported = false; |
| | | 511 | | |
| | 0 | 512 | | foreach (var profile in directPlayProfiles) |
| | | 513 | | { |
| | | 514 | | // Check container type |
| | 0 | 515 | | if (profile.Type == mediaType && profile.SupportsContainer(item.Container)) |
| | | 516 | | { |
| | 0 | 517 | | containerSupported = true; |
| | | 518 | | |
| | 0 | 519 | | videoSupported = videoStream is null || profile.SupportsVideoCodec(videoStream.Codec); |
| | | 520 | | |
| | 0 | 521 | | audioSupported = audioStream is null || profile.SupportsAudioCodec(audioStream.Codec); |
| | | 522 | | |
| | 0 | 523 | | if (videoSupported && audioSupported) |
| | | 524 | | { |
| | 0 | 525 | | break; |
| | | 526 | | } |
| | | 527 | | } |
| | | 528 | | } |
| | | 529 | | |
| | 0 | 530 | | TranscodeReason reasons = 0; |
| | 0 | 531 | | if (!containerSupported) |
| | | 532 | | { |
| | 0 | 533 | | reasons |= TranscodeReason.ContainerNotSupported; |
| | | 534 | | } |
| | | 535 | | |
| | 0 | 536 | | if (!videoSupported) |
| | | 537 | | { |
| | 0 | 538 | | reasons |= TranscodeReason.VideoCodecNotSupported; |
| | | 539 | | } |
| | | 540 | | |
| | 0 | 541 | | if (!audioSupported) |
| | | 542 | | { |
| | 0 | 543 | | reasons |= TranscodeReason.AudioCodecNotSupported; |
| | | 544 | | } |
| | | 545 | | |
| | 0 | 546 | | return reasons; |
| | | 547 | | } |
| | | 548 | | |
| | | 549 | | private static int? GetDefaultSubtitleStreamIndex(MediaSourceInfo item, SubtitleProfile[] subtitleProfiles) |
| | | 550 | | { |
| | 177 | 551 | | int highestScore = -1; |
| | 1800 | 552 | | foreach (var stream in item.MediaStreams) |
| | | 553 | | { |
| | 723 | 554 | | if (stream.Type == MediaStreamType.Subtitle |
| | 723 | 555 | | && stream.Score.HasValue |
| | 723 | 556 | | && stream.Score.Value > highestScore) |
| | | 557 | | { |
| | 144 | 558 | | highestScore = stream.Score.Value; |
| | | 559 | | } |
| | | 560 | | } |
| | | 561 | | |
| | 177 | 562 | | List<MediaStream> topStreams = []; |
| | 1800 | 563 | | foreach (var stream in item.MediaStreams) |
| | | 564 | | { |
| | 723 | 565 | | if (stream.Type == MediaStreamType.Subtitle && stream.Score.HasValue && stream.Score.Value == highestSco |
| | | 566 | | { |
| | 321 | 567 | | topStreams.Add(stream); |
| | | 568 | | } |
| | | 569 | | } |
| | | 570 | | |
| | | 571 | | // If multiple streams have an equal score, try to pick the most efficient one |
| | 177 | 572 | | if (topStreams.Count > 1) |
| | | 573 | | { |
| | 378 | 574 | | foreach (var stream in topStreams) |
| | | 575 | | { |
| | 1464 | 576 | | foreach (var profile in subtitleProfiles) |
| | | 577 | | { |
| | 549 | 578 | | if (profile.Method == SubtitleDeliveryMethod.External |
| | 549 | 579 | | && (string.Equals(profile.Format, stream.Codec, StringComparison.OrdinalIgnoreCase) |
| | 549 | 580 | | // FFmpeg cannot mux VobSub back into an .idx/.sub pair, so extracted VobSub streams are |
| | 549 | 581 | | || (string.Equals(profile.Format, "mks", StringComparison.OrdinalIgnoreCase) |
| | 549 | 582 | | && stream.IsVobSubSubtitleStream |
| | 549 | 583 | | && (!stream.IsExternal || stream.Path.EndsWith(".mks", StringComparison.OrdinalIgnor |
| | | 584 | | { |
| | 0 | 585 | | return stream.Index; |
| | | 586 | | } |
| | | 587 | | } |
| | | 588 | | } |
| | | 589 | | } |
| | | 590 | | |
| | | 591 | | // If no optimization panned out, just use the original default |
| | 177 | 592 | | return item.DefaultSubtitleStreamIndex; |
| | 0 | 593 | | } |
| | | 594 | | |
| | | 595 | | private static void SetStreamInfoOptionsFromTranscodingProfile(MediaSourceInfo item, StreamInfo playlistItem, Tr |
| | | 596 | | { |
| | 147 | 597 | | var container = transcodingProfile.Container; |
| | 147 | 598 | | var protocol = transcodingProfile.Protocol; |
| | | 599 | | |
| | 147 | 600 | | item.TranscodingContainer = container; |
| | 147 | 601 | | item.TranscodingSubProtocol = protocol; |
| | | 602 | | |
| | 147 | 603 | | if (playlistItem.PlayMethod == PlayMethod.Transcode) |
| | | 604 | | { |
| | 147 | 605 | | playlistItem.Container = container; |
| | 147 | 606 | | playlistItem.SubProtocol = protocol; |
| | | 607 | | } |
| | | 608 | | |
| | 147 | 609 | | playlistItem.TranscodeSeekInfo = transcodingProfile.TranscodeSeekInfo; |
| | 147 | 610 | | if (int.TryParse(transcodingProfile.MaxAudioChannels, CultureInfo.InvariantCulture, out int transcodingMaxAu |
| | | 611 | | { |
| | 133 | 612 | | playlistItem.TranscodingMaxAudioChannels = transcodingMaxAudioChannels; |
| | | 613 | | } |
| | | 614 | | |
| | 147 | 615 | | playlistItem.EstimateContentLength = transcodingProfile.EstimateContentLength; |
| | | 616 | | |
| | 147 | 617 | | playlistItem.CopyTimestamps = transcodingProfile.CopyTimestamps; |
| | 147 | 618 | | playlistItem.EnableSubtitlesInManifest = transcodingProfile.EnableSubtitlesInManifest; |
| | 147 | 619 | | playlistItem.EnableMpegtsM2TsMode = transcodingProfile.EnableMpegtsM2TsMode; |
| | | 620 | | |
| | 147 | 621 | | playlistItem.EnableAudioVbrEncoding = transcodingProfile.EnableAudioVbrEncoding; |
| | | 622 | | |
| | 147 | 623 | | if (transcodingProfile.MinSegments > 0) |
| | | 624 | | { |
| | 102 | 625 | | playlistItem.MinSegments = transcodingProfile.MinSegments; |
| | | 626 | | } |
| | | 627 | | |
| | 147 | 628 | | if (transcodingProfile.SegmentLength > 0) |
| | | 629 | | { |
| | 0 | 630 | | playlistItem.SegmentLength = transcodingProfile.SegmentLength; |
| | | 631 | | } |
| | 147 | 632 | | } |
| | | 633 | | |
| | | 634 | | private static void SetStreamInfoOptionsFromDirectPlayProfile(MediaOptions options, MediaSourceInfo item, Stream |
| | | 635 | | { |
| | 0 | 636 | | var container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, DlnaProfileTy |
| | 0 | 637 | | var protocol = MediaStreamProtocol.http; |
| | | 638 | | |
| | 0 | 639 | | item.TranscodingContainer = container; |
| | 0 | 640 | | item.TranscodingSubProtocol = protocol; |
| | | 641 | | |
| | 0 | 642 | | playlistItem.Container = container; |
| | 0 | 643 | | playlistItem.SubProtocol = protocol; |
| | | 644 | | |
| | 0 | 645 | | playlistItem.VideoCodecs = [item.VideoStream.Codec]; |
| | 0 | 646 | | playlistItem.AudioCodecs = ContainerHelper.Split(directPlayProfile?.AudioCodec); |
| | 0 | 647 | | } |
| | | 648 | | |
| | | 649 | | private StreamInfo BuildVideoItem(MediaSourceInfo item, MediaOptions options) |
| | | 650 | | { |
| | 280 | 651 | | ArgumentNullException.ThrowIfNull(item); |
| | | 652 | | |
| | 280 | 653 | | StreamInfo playlistItem = new StreamInfo |
| | 280 | 654 | | { |
| | 280 | 655 | | ItemId = options.ItemId, |
| | 280 | 656 | | MediaType = DlnaProfileType.Video, |
| | 280 | 657 | | MediaSource = item, |
| | 280 | 658 | | RunTimeTicks = item.RunTimeTicks, |
| | 280 | 659 | | Context = options.Context, |
| | 280 | 660 | | DeviceProfile = options.Profile, |
| | 280 | 661 | | SubtitleStreamIndex = options.SubtitleStreamIndex ?? GetDefaultSubtitleStreamIndex(item, options.Profile |
| | 280 | 662 | | AlwaysBurnInSubtitleWhenTranscoding = options.AlwaysBurnInSubtitleWhenTranscoding |
| | 280 | 663 | | }; |
| | | 664 | | |
| | 280 | 665 | | var subtitleStream = playlistItem.SubtitleStreamIndex.HasValue ? item.GetMediaStream(MediaStreamType.Subtitl |
| | | 666 | | |
| | 280 | 667 | | var audioStream = item.GetDefaultAudioStream(options.AudioStreamIndex ?? item.DefaultAudioStreamIndex); |
| | 280 | 668 | | if (audioStream is not null) |
| | | 669 | | { |
| | 279 | 670 | | playlistItem.AudioStreamIndex = audioStream.Index; |
| | | 671 | | } |
| | | 672 | | |
| | | 673 | | // Collect candidate audio streams |
| | 280 | 674 | | ICollection<MediaStream> candidateAudioStreams = audioStream is null ? [] : [audioStream]; |
| | | 675 | | // When the index is explicitly required by client or the default is specified by user, don't do any stream |
| | 280 | 676 | | if (!item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.User) && (options.AudioStreamIndex is null or < 0 |
| | | 677 | | { |
| | | 678 | | // When user has no preferences allow stream selection on all streams. |
| | 177 | 679 | | if (item.DefaultAudioIndexSource == AudioIndexSource.None && audioStream is not null) |
| | | 680 | | { |
| | 176 | 681 | | candidateAudioStreams = item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio).ToAr |
| | 176 | 682 | | if (audioStream.IsDefault) |
| | | 683 | | { |
| | | 684 | | // If default is picked, only allow selection within default streams. |
| | 176 | 685 | | candidateAudioStreams = candidateAudioStreams.Where(stream => stream.IsDefault).ToArray(); |
| | | 686 | | } |
| | | 687 | | } |
| | | 688 | | |
| | 177 | 689 | | if (item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.Language)) |
| | | 690 | | { |
| | | 691 | | // If user has language preference, only allow stream selection within the same language. |
| | 0 | 692 | | candidateAudioStreams = item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio && st |
| | 0 | 693 | | if (item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.Default)) |
| | | 694 | | { |
| | 0 | 695 | | var defaultStreamsInPreferredLanguage = candidateAudioStreams.Where(stream => stream.IsDefault). |
| | | 696 | | |
| | | 697 | | // If the user also prefers default streams, try limit selection within default tracks in the sa |
| | | 698 | | // If there is no default stream in the preferred language, allow selection on all default strea |
| | 0 | 699 | | candidateAudioStreams = defaultStreamsInPreferredLanguage.Length > 0 |
| | 0 | 700 | | ? defaultStreamsInPreferredLanguage |
| | 0 | 701 | | : item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio && stream.IsDefault |
| | | 702 | | } |
| | | 703 | | } |
| | 177 | 704 | | else if (item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.Default)) |
| | | 705 | | { |
| | | 706 | | // If user prefers default streams, only allow stream selection on default streams. |
| | 0 | 707 | | candidateAudioStreams = item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio && st |
| | | 708 | | } |
| | | 709 | | } |
| | | 710 | | |
| | 280 | 711 | | var videoStream = item.VideoStream; |
| | | 712 | | |
| | 280 | 713 | | var bitrateLimitExceeded = IsBitrateLimitExceeded(item, options.GetMaxBitrate(false) ?? 0); |
| | 280 | 714 | | var isEligibleForDirectPlay = options.EnableDirectPlay && (options.ForceDirectPlay || !bitrateLimitExceeded) |
| | 280 | 715 | | var isEligibleForDirectStream = options.EnableDirectStream && (options.ForceDirectStream || !bitrateLimitExc |
| | 280 | 716 | | TranscodeReason transcodeReasons = 0; |
| | | 717 | | |
| | | 718 | | // Force transcode or remux for BD/DVD folders |
| | 280 | 719 | | if (item.VideoType == VideoType.Dvd || item.VideoType == VideoType.BluRay) |
| | | 720 | | { |
| | 0 | 721 | | isEligibleForDirectPlay = false; |
| | | 722 | | } |
| | | 723 | | |
| | 280 | 724 | | if (bitrateLimitExceeded) |
| | | 725 | | { |
| | 24 | 726 | | transcodeReasons = TranscodeReason.ContainerBitrateExceedsLimit; |
| | | 727 | | } |
| | | 728 | | |
| | 280 | 729 | | _logger.LogDebug( |
| | 280 | 730 | | "Profile: {0}, Path: {1}, isEligibleForDirectPlay: {2}, isEligibleForDirectStream: {3}", |
| | 280 | 731 | | options.Profile.Name ?? "Unknown Profile", |
| | 280 | 732 | | item.Path ?? "Unknown path", |
| | 280 | 733 | | isEligibleForDirectPlay, |
| | 280 | 734 | | isEligibleForDirectStream); |
| | | 735 | | |
| | 280 | 736 | | DirectPlayProfile? directPlayProfile = null; |
| | 280 | 737 | | if (isEligibleForDirectPlay || isEligibleForDirectStream) |
| | | 738 | | { |
| | | 739 | | // See if it can be direct played |
| | 256 | 740 | | var directPlayInfo = GetVideoDirectPlayProfile(options, item, videoStream, audioStream, candidateAudioSt |
| | 256 | 741 | | var directPlay = directPlayInfo.PlayMethod; |
| | 256 | 742 | | transcodeReasons |= directPlayInfo.TranscodeReasons; |
| | | 743 | | |
| | 256 | 744 | | if (directPlay.HasValue) |
| | | 745 | | { |
| | 125 | 746 | | directPlayProfile = directPlayInfo.Profile; |
| | 125 | 747 | | playlistItem.PlayMethod = directPlay.Value; |
| | 125 | 748 | | playlistItem.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profi |
| | 125 | 749 | | var videoCodec = videoStream?.Codec; |
| | 125 | 750 | | playlistItem.VideoCodecs = videoCodec is null ? [] : [videoCodec]; |
| | | 751 | | |
| | 125 | 752 | | if (directPlay == PlayMethod.DirectPlay) |
| | | 753 | | { |
| | 125 | 754 | | playlistItem.SubProtocol = MediaStreamProtocol.http; |
| | | 755 | | |
| | 125 | 756 | | var audioStreamIndex = directPlayInfo.AudioStreamIndex ?? audioStream?.Index; |
| | 125 | 757 | | if (audioStreamIndex.HasValue) |
| | | 758 | | { |
| | 125 | 759 | | playlistItem.AudioStreamIndex = audioStreamIndex; |
| | 125 | 760 | | var audioCodec = item.GetMediaStream(MediaStreamType.Audio, audioStreamIndex.Value)?.Codec; |
| | 125 | 761 | | playlistItem.AudioCodecs = audioCodec is null ? [] : [audioCodec]; |
| | | 762 | | } |
| | | 763 | | } |
| | 0 | 764 | | else if (directPlay == PlayMethod.DirectStream) |
| | | 765 | | { |
| | 0 | 766 | | playlistItem.AudioStreamIndex = audioStream?.Index; |
| | 0 | 767 | | if (audioStream is not null) |
| | | 768 | | { |
| | 0 | 769 | | playlistItem.AudioCodecs = ContainerHelper.Split(directPlayProfile?.AudioCodec); |
| | | 770 | | } |
| | | 771 | | |
| | 0 | 772 | | SetStreamInfoOptionsFromDirectPlayProfile(options, item, playlistItem, directPlayProfile); |
| | 0 | 773 | | BuildStreamVideoItem(playlistItem, options, item, videoStream, audioStream, candidateAudioStream |
| | | 774 | | } |
| | | 775 | | |
| | 125 | 776 | | if (subtitleStream is not null) |
| | | 777 | | { |
| | 116 | 778 | | var subtitleProfile = GetSubtitleProfile(item, subtitleStream, options.Profile.SubtitleProfiles, |
| | | 779 | | |
| | 116 | 780 | | playlistItem.SubtitleDeliveryMethod = subtitleProfile.Method; |
| | 116 | 781 | | playlistItem.SubtitleFormat = subtitleProfile.Format; |
| | | 782 | | } |
| | | 783 | | } |
| | | 784 | | |
| | 256 | 785 | | _logger.LogDebug( |
| | 256 | 786 | | "DirectPlay Result for Profile: {0}, Path: {1}, PlayMethod: {2}, AudioStreamIndex: {3}, SubtitleStre |
| | 256 | 787 | | options.Profile.Name ?? "Anonymous Profile", |
| | 256 | 788 | | item.Path ?? "Unknown path", |
| | 256 | 789 | | directPlayInfo.PlayMethod, |
| | 256 | 790 | | directPlayInfo.AudioStreamIndex ?? audioStream?.Index, |
| | 256 | 791 | | playlistItem.SubtitleStreamIndex, |
| | 256 | 792 | | directPlayInfo.TranscodeReasons); |
| | | 793 | | } |
| | | 794 | | |
| | 280 | 795 | | playlistItem.TranscodeReasons = transcodeReasons; |
| | | 796 | | |
| | 280 | 797 | | if (playlistItem.PlayMethod != PlayMethod.DirectStream && playlistItem.PlayMethod != PlayMethod.DirectPlay) |
| | | 798 | | { |
| | | 799 | | // Can't direct play, find the transcoding profile |
| | | 800 | | // If we do this for direct-stream we will overwrite the info |
| | 155 | 801 | | var (transcodingProfile, playMethod) = GetVideoTranscodeProfile(item, options, videoStream, audioStream, |
| | | 802 | | |
| | 155 | 803 | | if (transcodingProfile is not null && playMethod.HasValue) |
| | | 804 | | { |
| | 147 | 805 | | SetStreamInfoOptionsFromTranscodingProfile(item, playlistItem, transcodingProfile); |
| | | 806 | | |
| | 147 | 807 | | BuildStreamVideoItem(playlistItem, options, item, videoStream, audioStream, candidateAudioStreams, t |
| | | 808 | | |
| | 147 | 809 | | playlistItem.PlayMethod = PlayMethod.Transcode; |
| | | 810 | | |
| | 147 | 811 | | if (subtitleStream is not null) |
| | | 812 | | { |
| | 123 | 813 | | var subtitleProfile = GetSubtitleProfile(item, subtitleStream, options.Profile.SubtitleProfiles, |
| | 123 | 814 | | playlistItem.SubtitleDeliveryMethod = subtitleProfile.Method; |
| | 123 | 815 | | playlistItem.SubtitleFormat = subtitleProfile.Format; |
| | 123 | 816 | | playlistItem.SubtitleCodecs = [subtitleProfile.Format]; |
| | | 817 | | } |
| | | 818 | | |
| | 147 | 819 | | if ((playlistItem.TranscodeReasons & (VideoReasons | TranscodeReason.ContainerBitrateExceedsLimit)) |
| | | 820 | | { |
| | 55 | 821 | | ApplyTranscodingConditions(playlistItem, transcodingProfile.Conditions, null, true, true); |
| | | 822 | | } |
| | | 823 | | } |
| | | 824 | | } |
| | | 825 | | |
| | 280 | 826 | | _logger.LogDebug( |
| | 280 | 827 | | "StreamBuilder.BuildVideoItem( Profile={0}, Path={1}, AudioStreamIndex={2}, SubtitleStreamIndex={3} ) => |
| | 280 | 828 | | options.Profile.Name ?? "Anonymous Profile", |
| | 280 | 829 | | item.Path ?? "Unknown path", |
| | 280 | 830 | | options.AudioStreamIndex, |
| | 280 | 831 | | options.SubtitleStreamIndex, |
| | 280 | 832 | | playlistItem.PlayMethod, |
| | 280 | 833 | | playlistItem.TranscodeReasons, |
| | 280 | 834 | | playlistItem.ToUrl("media:", "<token>", null)); |
| | | 835 | | |
| | 280 | 836 | | item.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, DlnaProfileT |
| | 280 | 837 | | return playlistItem; |
| | | 838 | | } |
| | | 839 | | |
| | | 840 | | private (TranscodingProfile? Profile, PlayMethod? PlayMethod) GetVideoTranscodeProfile( |
| | | 841 | | MediaSourceInfo item, |
| | | 842 | | MediaOptions options, |
| | | 843 | | MediaStream? videoStream, |
| | | 844 | | MediaStream? audioStream, |
| | | 845 | | StreamInfo playlistItem) |
| | | 846 | | { |
| | 155 | 847 | | var mediaSource = playlistItem.MediaSource; |
| | | 848 | | |
| | 155 | 849 | | ArgumentNullException.ThrowIfNull(mediaSource); |
| | | 850 | | |
| | 155 | 851 | | if (!(item.SupportsTranscoding || item.SupportsDirectStream)) |
| | | 852 | | { |
| | 0 | 853 | | return (null, null); |
| | | 854 | | } |
| | | 855 | | |
| | 155 | 856 | | var transcodingProfiles = options.Profile.TranscodingProfiles |
| | 155 | 857 | | .Where(i => i.Type == playlistItem.MediaType && i.Context == options.Context); |
| | | 858 | | |
| | 155 | 859 | | if (item.UseMostCompatibleTranscodingProfile) |
| | | 860 | | { |
| | 0 | 861 | | transcodingProfiles = transcodingProfiles.Where(i => string.Equals(i.Container, "ts", StringComparison.O |
| | | 862 | | } |
| | | 863 | | |
| | 155 | 864 | | var videoCodec = videoStream?.Codec; |
| | 155 | 865 | | var audioCodec = audioStream?.Codec; |
| | | 866 | | |
| | 155 | 867 | | var analyzedProfiles = transcodingProfiles |
| | 155 | 868 | | .Select(transcodingProfile => |
| | 155 | 869 | | { |
| | 155 | 870 | | var rank = (Video: 3, Audio: 3); |
| | 155 | 871 | | |
| | 155 | 872 | | var container = transcodingProfile.Container; |
| | 155 | 873 | | |
| | 155 | 874 | | if (videoStream is not null |
| | 155 | 875 | | && options.AllowVideoStreamCopy |
| | 155 | 876 | | && ContainerHelper.ContainsContainer(transcodingProfile.VideoCodec, videoCodec)) |
| | 155 | 877 | | { |
| | 155 | 878 | | var failures = GetCompatibilityVideoCodec(options, mediaSource, container, videoStream); |
| | 155 | 879 | | rank.Video = failures == 0 ? 1 : 2; |
| | 155 | 880 | | } |
| | 155 | 881 | | |
| | 155 | 882 | | if (audioStream is not null |
| | 155 | 883 | | && options.AllowAudioStreamCopy) |
| | 155 | 884 | | { |
| | 155 | 885 | | // For Audio stream, we prefer the audio codec that can be directly copied, then the codec that |
| | 155 | 886 | | // the transcoding conditions, then the one does not satisfy the transcoding conditions. |
| | 155 | 887 | | // For example: A client can support both aac and flac, but flac only supports 2 channels while |
| | 155 | 888 | | // When the source audio is 6 channel flac, we should transcode to 6 channel aac, instead of dow |
| | 155 | 889 | | var transcodingAudioCodecs = ContainerHelper.Split(transcodingProfile.AudioCodec); |
| | 155 | 890 | | |
| | 155 | 891 | | foreach (var transcodingAudioCodec in transcodingAudioCodecs) |
| | 155 | 892 | | { |
| | 155 | 893 | | var failures = GetCompatibilityAudioCodec(options, mediaSource, container, audioStream, tran |
| | 155 | 894 | | |
| | 155 | 895 | | var rankAudio = 3; |
| | 155 | 896 | | |
| | 155 | 897 | | if (failures == 0) |
| | 155 | 898 | | { |
| | 155 | 899 | | rankAudio = string.Equals(transcodingAudioCodec, audioCodec, StringComparison.OrdinalIgn |
| | 155 | 900 | | } |
| | 155 | 901 | | |
| | 155 | 902 | | rank.Audio = Math.Min(rank.Audio, rankAudio); |
| | 155 | 903 | | |
| | 155 | 904 | | if (rank.Audio == 1) |
| | 155 | 905 | | { |
| | 155 | 906 | | break; |
| | 155 | 907 | | } |
| | 155 | 908 | | } |
| | 155 | 909 | | } |
| | 155 | 910 | | |
| | 155 | 911 | | PlayMethod playMethod = PlayMethod.Transcode; |
| | 155 | 912 | | |
| | 155 | 913 | | if (rank.Video == 1) |
| | 155 | 914 | | { |
| | 155 | 915 | | playMethod = PlayMethod.DirectStream; |
| | 155 | 916 | | } |
| | 155 | 917 | | |
| | 155 | 918 | | return (Profile: transcodingProfile, PlayMethod: playMethod, Rank: rank); |
| | 155 | 919 | | }) |
| | 155 | 920 | | .OrderBy(analysis => analysis.Rank); |
| | | 921 | | |
| | 155 | 922 | | var profileMatch = analyzedProfiles.FirstOrDefault(); |
| | | 923 | | |
| | 155 | 924 | | return (profileMatch.Profile, profileMatch.PlayMethod); |
| | | 925 | | } |
| | | 926 | | |
| | | 927 | | private void BuildStreamVideoItem( |
| | | 928 | | StreamInfo playlistItem, |
| | | 929 | | MediaOptions options, |
| | | 930 | | MediaSourceInfo item, |
| | | 931 | | MediaStream? videoStream, |
| | | 932 | | MediaStream? audioStream, |
| | | 933 | | IEnumerable<MediaStream> candidateAudioStreams, |
| | | 934 | | string? container, |
| | | 935 | | string? videoCodec, |
| | | 936 | | string? audioCodec) |
| | | 937 | | { |
| | | 938 | | // Prefer matching video codecs |
| | 147 | 939 | | var videoCodecs = ContainerHelper.Split(videoCodec).ToList(); |
| | | 940 | | |
| | 147 | 941 | | if (videoCodecs.Count == 0 && videoStream is not null) |
| | | 942 | | { |
| | | 943 | | // Add the original codec if no codec is specified |
| | 0 | 944 | | videoCodecs.Add(videoStream.Codec); |
| | | 945 | | } |
| | | 946 | | |
| | | 947 | | // Enforce HLS video codec restrictions |
| | 147 | 948 | | if (playlistItem.SubProtocol == MediaStreamProtocol.hls) |
| | | 949 | | { |
| | 133 | 950 | | videoCodecs = videoCodecs.Where(codec => _supportedHlsVideoCodecs.Contains(codec)).ToList(); |
| | | 951 | | } |
| | | 952 | | |
| | 147 | 953 | | playlistItem.VideoCodecs = videoCodecs; |
| | 147 | 954 | | if (videoStream is not null && !ContainerHelper.ContainsContainer(videoCodecs, false, videoStream.Codec)) |
| | | 955 | | { |
| | 31 | 956 | | playlistItem.TranscodeReasons |= TranscodeReason.VideoCodecNotSupported; |
| | | 957 | | } |
| | | 958 | | |
| | | 959 | | // Copy video codec options as a starting point, this applies to transcode and direct-stream |
| | 147 | 960 | | playlistItem.MaxFramerate = videoStream?.ReferenceFrameRate; |
| | 147 | 961 | | var qualifier = videoStream?.Codec; |
| | 147 | 962 | | if (videoStream?.Level is not null) |
| | | 963 | | { |
| | 146 | 964 | | playlistItem.SetOption(qualifier, "level", videoStream.Level.Value.ToString(CultureInfo.InvariantCulture |
| | | 965 | | } |
| | | 966 | | |
| | 147 | 967 | | if (videoStream?.BitDepth is not null) |
| | | 968 | | { |
| | 146 | 969 | | playlistItem.SetOption(qualifier, "videobitdepth", videoStream.BitDepth.Value.ToString(CultureInfo.Invar |
| | | 970 | | } |
| | | 971 | | |
| | 147 | 972 | | if (!string.IsNullOrEmpty(videoStream?.Profile)) |
| | | 973 | | { |
| | 146 | 974 | | playlistItem.SetOption(qualifier, "profile", videoStream.Profile.ToLowerInvariant()); |
| | | 975 | | } |
| | | 976 | | |
| | | 977 | | // Prefer matching audio codecs, could do better here |
| | 147 | 978 | | var audioCodecs = ContainerHelper.Split(audioCodec).ToList(); |
| | | 979 | | |
| | 147 | 980 | | if (audioCodecs.Count == 0 && audioStream is not null) |
| | | 981 | | { |
| | | 982 | | // Add the original codec if no codec is specified |
| | 0 | 983 | | audioCodecs.Add(audioStream.Codec); |
| | | 984 | | } |
| | | 985 | | |
| | | 986 | | // Enforce HLS audio codec restrictions |
| | 147 | 987 | | if (playlistItem.SubProtocol == MediaStreamProtocol.hls) |
| | | 988 | | { |
| | 133 | 989 | | if (string.Equals(playlistItem.Container, "mp4", StringComparison.OrdinalIgnoreCase)) |
| | | 990 | | { |
| | 72 | 991 | | audioCodecs = audioCodecs.Where(codec => _supportedHlsAudioCodecsMp4.Contains(codec)).ToList(); |
| | | 992 | | } |
| | | 993 | | else |
| | | 994 | | { |
| | 61 | 995 | | audioCodecs = audioCodecs.Where(codec => _supportedHlsAudioCodecsTs.Contains(codec)).ToList(); |
| | | 996 | | } |
| | | 997 | | } |
| | | 998 | | |
| | 147 | 999 | | var audioStreamWithSupportedCodec = candidateAudioStreams.Where(stream => ContainerHelper.ContainsContainer( |
| | | 1000 | | |
| | 147 | 1001 | | var channelsExceedsLimit = audioStreamWithSupportedCodec is not null && audioStreamWithSupportedCodec.Channe |
| | | 1002 | | |
| | 147 | 1003 | | var directAudioFailures = audioStreamWithSupportedCodec is null ? default : GetCompatibilityAudioCodec(optio |
| | | 1004 | | |
| | 147 | 1005 | | playlistItem.TranscodeReasons |= directAudioFailures; |
| | 147 | 1006 | | if (audioStream is not null && audioStreamWithSupportedCodec is null) |
| | | 1007 | | { |
| | 65 | 1008 | | playlistItem.TranscodeReasons |= TranscodeReason.AudioCodecNotSupported; |
| | | 1009 | | } |
| | | 1010 | | |
| | 147 | 1011 | | var directAudioStreamSatisfied = audioStreamWithSupportedCodec is not null && !channelsExceedsLimit |
| | 147 | 1012 | | && directAudioFailures == 0; |
| | | 1013 | | |
| | 147 | 1014 | | directAudioStreamSatisfied = directAudioStreamSatisfied && !playlistItem.TranscodeReasons.HasFlag(TranscodeR |
| | | 1015 | | |
| | 147 | 1016 | | var directAudioStream = directAudioStreamSatisfied ? audioStreamWithSupportedCodec : null; |
| | | 1017 | | |
| | 147 | 1018 | | if (channelsExceedsLimit && playlistItem.TargetAudioStream is not null) |
| | | 1019 | | { |
| | 10 | 1020 | | playlistItem.TranscodeReasons |= TranscodeReason.AudioChannelsNotSupported; |
| | 10 | 1021 | | playlistItem.TargetAudioStream.Channels = playlistItem.TranscodingMaxAudioChannels; |
| | | 1022 | | } |
| | | 1023 | | |
| | 147 | 1024 | | playlistItem.AudioCodecs = audioCodecs; |
| | 147 | 1025 | | if (directAudioStream is not null) |
| | | 1026 | | { |
| | 56 | 1027 | | audioStream = directAudioStream; |
| | 56 | 1028 | | playlistItem.AudioStreamIndex = audioStream.Index; |
| | 56 | 1029 | | audioCodecs = [audioStream.Codec]; |
| | 56 | 1030 | | playlistItem.AudioCodecs = audioCodecs; |
| | | 1031 | | |
| | | 1032 | | // Copy matching audio codec options |
| | 56 | 1033 | | playlistItem.AudioSampleRate = audioStream.SampleRate; |
| | 56 | 1034 | | playlistItem.SetOption(qualifier, "audiochannels", audioStream.Channels?.ToString(CultureInfo.InvariantC |
| | | 1035 | | |
| | 56 | 1036 | | if (!string.IsNullOrEmpty(audioStream.Profile)) |
| | | 1037 | | { |
| | 54 | 1038 | | playlistItem.SetOption(audioStream.Codec, "profile", audioStream.Profile.ToLowerInvariant()); |
| | | 1039 | | } |
| | | 1040 | | |
| | 56 | 1041 | | if (audioStream.Level.HasValue && audioStream.Level.Value != 0) |
| | | 1042 | | { |
| | 0 | 1043 | | playlistItem.SetOption(audioStream.Codec, "level", audioStream.Level.Value.ToString(CultureInfo.Inva |
| | | 1044 | | } |
| | | 1045 | | } |
| | | 1046 | | |
| | 147 | 1047 | | int? width = videoStream?.Width; |
| | 147 | 1048 | | int? height = videoStream?.Height; |
| | 147 | 1049 | | int? bitDepth = videoStream?.BitDepth; |
| | 147 | 1050 | | int? videoBitrate = videoStream?.BitRate; |
| | 147 | 1051 | | double? videoLevel = videoStream?.Level; |
| | 147 | 1052 | | string? videoProfile = videoStream?.Profile; |
| | 147 | 1053 | | VideoRangeType? videoRangeType = videoStream?.VideoRangeType; |
| | 147 | 1054 | | float videoFramerate = videoStream is null ? 0 : videoStream.ReferenceFrameRate ?? 0; |
| | 147 | 1055 | | bool? isAnamorphic = videoStream?.IsAnamorphic; |
| | 147 | 1056 | | bool? isInterlaced = videoStream?.IsInterlaced; |
| | 147 | 1057 | | string? videoCodecTag = videoStream?.CodecTag; |
| | 147 | 1058 | | bool? isAvc = videoStream?.IsAVC; |
| | 147 | 1059 | | int? videoRotation = videoStream?.Rotation; |
| | | 1060 | | |
| | 147 | 1061 | | TransportStreamTimestamp? timestamp = videoStream is null ? TransportStreamTimestamp.None : item.Timestamp; |
| | 147 | 1062 | | int? packetLength = videoStream?.PacketLength; |
| | 147 | 1063 | | int? refFrames = videoStream?.RefFrames; |
| | | 1064 | | |
| | 147 | 1065 | | int numStreams = item.MediaStreams.Count; |
| | 147 | 1066 | | int? numAudioStreams = item.GetStreamCount(MediaStreamType.Audio); |
| | 147 | 1067 | | int? numVideoStreams = item.GetStreamCount(MediaStreamType.Video); |
| | | 1068 | | |
| | 147 | 1069 | | var useSubContainer = playlistItem.SubProtocol == MediaStreamProtocol.hls; |
| | | 1070 | | |
| | 147 | 1071 | | var appliedVideoConditions = options.Profile.CodecProfiles |
| | 147 | 1072 | | .Where(i => i.Type == CodecType.Video && |
| | 147 | 1073 | | i.ContainsAnyCodec(playlistItem.VideoCodecs, container, useSubContainer) && |
| | 147 | 1074 | | i.ApplyConditions.All(applyCondition => ConditionProcessor.IsVideoConditionSatisfied(applyCondition, |
| | 147 | 1075 | | // Reverse codec profiles for backward compatibility - first codec profile has higher priority |
| | 147 | 1076 | | .Reverse(); |
| | 890 | 1077 | | foreach (var condition in appliedVideoConditions) |
| | | 1078 | | { |
| | 2416 | 1079 | | foreach (var transcodingVideoCodec in playlistItem.VideoCodecs) |
| | | 1080 | | { |
| | 910 | 1081 | | if (condition.ContainsAnyCodec(transcodingVideoCodec, container, useSubContainer)) |
| | | 1082 | | { |
| | 306 | 1083 | | ApplyTranscodingConditions(playlistItem, condition.Conditions, transcodingVideoCodec, true, true |
| | | 1084 | | continue; |
| | | 1085 | | } |
| | | 1086 | | } |
| | | 1087 | | } |
| | | 1088 | | |
| | | 1089 | | // Honor requested max channels |
| | 147 | 1090 | | playlistItem.GlobalMaxAudioChannels = channelsExceedsLimit ? playlistItem.TranscodingMaxAudioChannels : opti |
| | | 1091 | | |
| | 147 | 1092 | | int audioBitrate = GetAudioBitrate(options.GetMaxBitrate(true) ?? 0, playlistItem.TargetAudioCodec, audioStr |
| | 147 | 1093 | | playlistItem.AudioBitrate = Math.Min(playlistItem.AudioBitrate ?? audioBitrate, audioBitrate); |
| | | 1094 | | |
| | 147 | 1095 | | bool? isSecondaryAudio = audioStream is null ? null : item.IsSecondaryAudio(audioStream); |
| | 147 | 1096 | | int? inputAudioBitrate = audioStream?.BitRate; |
| | 147 | 1097 | | int? audioChannels = audioStream?.Channels; |
| | 147 | 1098 | | string? audioProfile = audioStream?.Profile; |
| | 147 | 1099 | | int? inputAudioSampleRate = audioStream?.SampleRate; |
| | 147 | 1100 | | int? inputAudioBitDepth = audioStream?.BitDepth; |
| | | 1101 | | |
| | 147 | 1102 | | var appliedAudioConditions = options.Profile.CodecProfiles |
| | 147 | 1103 | | .Where(i => i.Type == CodecType.VideoAudio && |
| | 147 | 1104 | | i.ContainsAnyCodec(playlistItem.AudioCodecs, container) && |
| | 147 | 1105 | | i.ApplyConditions.All(applyCondition => ConditionProcessor.IsVideoAudioConditionSatisfied(applyCondi |
| | 147 | 1106 | | // Reverse codec profiles for backward compatibility - first codec profile has higher priority |
| | 147 | 1107 | | .Reverse(); |
| | | 1108 | | |
| | 598 | 1109 | | foreach (var codecProfile in appliedAudioConditions) |
| | | 1110 | | { |
| | 456 | 1111 | | foreach (var transcodingAudioCodec in playlistItem.AudioCodecs) |
| | | 1112 | | { |
| | 152 | 1113 | | if (codecProfile.ContainsAnyCodec(transcodingAudioCodec, container)) |
| | | 1114 | | { |
| | 152 | 1115 | | ApplyTranscodingConditions(playlistItem, codecProfile.Conditions, transcodingAudioCodec, true, t |
| | 152 | 1116 | | break; |
| | | 1117 | | } |
| | | 1118 | | } |
| | | 1119 | | } |
| | | 1120 | | |
| | 147 | 1121 | | var maxBitrateSetting = options.GetMaxBitrate(false); |
| | | 1122 | | // Honor max rate |
| | 147 | 1123 | | if (maxBitrateSetting.HasValue) |
| | | 1124 | | { |
| | 147 | 1125 | | var availableBitrateForVideo = maxBitrateSetting.Value; |
| | | 1126 | | |
| | 147 | 1127 | | if (playlistItem.AudioBitrate.HasValue) |
| | | 1128 | | { |
| | 147 | 1129 | | availableBitrateForVideo -= playlistItem.AudioBitrate.Value; |
| | | 1130 | | } |
| | | 1131 | | |
| | | 1132 | | // Make sure the video bitrate is lower than bitrate settings but at least 64k |
| | | 1133 | | // Don't use Math.Clamp as availableBitrateForVideo can be lower then 64k. |
| | 147 | 1134 | | var currentValue = playlistItem.VideoBitrate ?? availableBitrateForVideo; |
| | 147 | 1135 | | playlistItem.VideoBitrate = Math.Max(Math.Min(availableBitrateForVideo, currentValue), 64_000); |
| | | 1136 | | } |
| | | 1137 | | |
| | 147 | 1138 | | _logger.LogDebug( |
| | 147 | 1139 | | "Transcode Result for Profile: {Profile}, Path: {Path}, PlayMethod: {PlayMethod}, AudioStreamIndex: {Aud |
| | 147 | 1140 | | options.Profile.Name ?? "Anonymous Profile", |
| | 147 | 1141 | | item.Path ?? "Unknown path", |
| | 147 | 1142 | | playlistItem.PlayMethod, |
| | 147 | 1143 | | audioStream?.Index, |
| | 147 | 1144 | | playlistItem.SubtitleStreamIndex, |
| | 147 | 1145 | | playlistItem.TranscodeReasons); |
| | 147 | 1146 | | } |
| | | 1147 | | |
| | | 1148 | | private static int GetDefaultAudioBitrate(string? audioCodec, int? audioChannels) |
| | | 1149 | | { |
| | 60 | 1150 | | if (!string.IsNullOrEmpty(audioCodec)) |
| | | 1151 | | { |
| | | 1152 | | // Default to a higher bitrate for stream copy |
| | 60 | 1153 | | if (string.Equals(audioCodec, "aac", StringComparison.OrdinalIgnoreCase) |
| | 60 | 1154 | | || string.Equals(audioCodec, "mp3", StringComparison.OrdinalIgnoreCase) |
| | 60 | 1155 | | || string.Equals(audioCodec, "ac3", StringComparison.OrdinalIgnoreCase) |
| | 60 | 1156 | | || string.Equals(audioCodec, "eac3", StringComparison.OrdinalIgnoreCase)) |
| | | 1157 | | { |
| | 55 | 1158 | | if ((audioChannels ?? 0) < 2) |
| | | 1159 | | { |
| | 0 | 1160 | | return 128000; |
| | | 1161 | | } |
| | | 1162 | | |
| | 55 | 1163 | | return (audioChannels ?? 0) >= 6 ? 640000 : 384000; |
| | | 1164 | | } |
| | | 1165 | | |
| | 5 | 1166 | | if (string.Equals(audioCodec, "flac", StringComparison.OrdinalIgnoreCase) |
| | 5 | 1167 | | || string.Equals(audioCodec, "alac", StringComparison.OrdinalIgnoreCase)) |
| | | 1168 | | { |
| | 0 | 1169 | | if ((audioChannels ?? 0) < 2) |
| | | 1170 | | { |
| | 0 | 1171 | | return 768000; |
| | | 1172 | | } |
| | | 1173 | | |
| | 0 | 1174 | | return (audioChannels ?? 0) >= 6 ? 3584000 : 1536000; |
| | | 1175 | | } |
| | | 1176 | | } |
| | | 1177 | | |
| | 5 | 1178 | | return 192000; |
| | | 1179 | | } |
| | | 1180 | | |
| | | 1181 | | private static int GetAudioBitrate(long maxTotalBitrate, IReadOnlyList<string> targetAudioCodecs, MediaStream? a |
| | | 1182 | | { |
| | 147 | 1183 | | string? targetAudioCodec = targetAudioCodecs.Count == 0 ? null : targetAudioCodecs[0]; |
| | | 1184 | | |
| | 147 | 1185 | | int? targetAudioChannels = item.GetTargetAudioChannels(targetAudioCodec); |
| | | 1186 | | |
| | | 1187 | | int defaultBitrate; |
| | 147 | 1188 | | int encoderAudioBitrateLimit = int.MaxValue; |
| | | 1189 | | |
| | 147 | 1190 | | if (audioStream is null) |
| | | 1191 | | { |
| | 1 | 1192 | | defaultBitrate = 192000; |
| | | 1193 | | } |
| | | 1194 | | else |
| | | 1195 | | { |
| | 146 | 1196 | | if (targetAudioChannels.HasValue |
| | 146 | 1197 | | && audioStream.Channels.HasValue |
| | 146 | 1198 | | && audioStream.Channels.Value > targetAudioChannels.Value) |
| | | 1199 | | { |
| | | 1200 | | // Reduce the bitrate if we're down mixing. |
| | 46 | 1201 | | defaultBitrate = GetDefaultAudioBitrate(targetAudioCodec, targetAudioChannels); |
| | | 1202 | | } |
| | 100 | 1203 | | else if (targetAudioChannels.HasValue |
| | 100 | 1204 | | && audioStream.Channels.HasValue |
| | 100 | 1205 | | && audioStream.Channels.Value <= targetAudioChannels.Value |
| | 100 | 1206 | | && !string.IsNullOrEmpty(audioStream.Codec) |
| | 100 | 1207 | | && targetAudioCodecs is not null |
| | 100 | 1208 | | && targetAudioCodecs.Count > 0 |
| | 100 | 1209 | | && !targetAudioCodecs.Any(elem => string.Equals(audioStream.Codec, elem, StringComparison.Ordin |
| | | 1210 | | { |
| | | 1211 | | // Shift the bitrate if we're transcoding to a different audio codec. |
| | 14 | 1212 | | defaultBitrate = GetDefaultAudioBitrate(targetAudioCodec, audioStream.Channels.Value); |
| | | 1213 | | } |
| | | 1214 | | else |
| | | 1215 | | { |
| | 86 | 1216 | | defaultBitrate = audioStream.BitRate ?? GetDefaultAudioBitrate(targetAudioCodec, targetAudioChannels |
| | | 1217 | | } |
| | | 1218 | | |
| | | 1219 | | // Seeing webm encoding failures when source has 1 audio channel and 22k bitrate. |
| | | 1220 | | // Any attempts to transcode over 64k will fail |
| | 146 | 1221 | | if (audioStream.Channels == 1 |
| | 146 | 1222 | | && (audioStream.BitRate ?? 0) < 64000) |
| | | 1223 | | { |
| | 0 | 1224 | | encoderAudioBitrateLimit = 64000; |
| | | 1225 | | } |
| | | 1226 | | } |
| | | 1227 | | |
| | 147 | 1228 | | if (maxTotalBitrate > 0) |
| | | 1229 | | { |
| | 147 | 1230 | | defaultBitrate = Math.Min(GetMaxAudioBitrateForTotalBitrate(maxTotalBitrate), defaultBitrate); |
| | | 1231 | | } |
| | | 1232 | | |
| | 147 | 1233 | | return Math.Min(defaultBitrate, encoderAudioBitrateLimit); |
| | | 1234 | | } |
| | | 1235 | | |
| | | 1236 | | private static int GetMaxAudioBitrateForTotalBitrate(long totalBitrate) |
| | | 1237 | | { |
| | 147 | 1238 | | if (totalBitrate <= 640000) |
| | | 1239 | | { |
| | 8 | 1240 | | return 128000; |
| | | 1241 | | } |
| | | 1242 | | |
| | 139 | 1243 | | if (totalBitrate <= 2000000) |
| | | 1244 | | { |
| | 0 | 1245 | | return 384000; |
| | | 1246 | | } |
| | | 1247 | | |
| | 139 | 1248 | | if (totalBitrate <= 3000000) |
| | | 1249 | | { |
| | 0 | 1250 | | return 448000; |
| | | 1251 | | } |
| | | 1252 | | |
| | 139 | 1253 | | if (totalBitrate <= 4000000) |
| | | 1254 | | { |
| | 0 | 1255 | | return 640000; |
| | | 1256 | | } |
| | | 1257 | | |
| | 139 | 1258 | | if (totalBitrate <= 5000000) |
| | | 1259 | | { |
| | 0 | 1260 | | return 768000; |
| | | 1261 | | } |
| | | 1262 | | |
| | 139 | 1263 | | if (totalBitrate <= 10000000) |
| | | 1264 | | { |
| | 8 | 1265 | | return 1536000; |
| | | 1266 | | } |
| | | 1267 | | |
| | 131 | 1268 | | if (totalBitrate <= 15000000) |
| | | 1269 | | { |
| | 0 | 1270 | | return 2304000; |
| | | 1271 | | } |
| | | 1272 | | |
| | 131 | 1273 | | if (totalBitrate <= 20000000) |
| | | 1274 | | { |
| | 14 | 1275 | | return 3584000; |
| | | 1276 | | } |
| | | 1277 | | |
| | 117 | 1278 | | return 7168000; |
| | | 1279 | | } |
| | | 1280 | | |
| | | 1281 | | private (DirectPlayProfile? Profile, PlayMethod? PlayMethod, int? AudioStreamIndex, TranscodeReason TranscodeRea |
| | | 1282 | | MediaOptions options, |
| | | 1283 | | MediaSourceInfo mediaSource, |
| | | 1284 | | MediaStream? videoStream, |
| | | 1285 | | MediaStream? audioStream, |
| | | 1286 | | ICollection<MediaStream> candidateAudioStreams, |
| | | 1287 | | MediaStream? subtitleStream, |
| | | 1288 | | bool isEligibleForDirectPlay, |
| | | 1289 | | bool isEligibleForDirectStream) |
| | | 1290 | | { |
| | 256 | 1291 | | if (options.ForceDirectPlay) |
| | | 1292 | | { |
| | 0 | 1293 | | return (null, PlayMethod.DirectPlay, audioStream?.Index, 0); |
| | | 1294 | | } |
| | | 1295 | | |
| | 256 | 1296 | | if (options.ForceDirectStream) |
| | | 1297 | | { |
| | 0 | 1298 | | return (null, PlayMethod.DirectStream, audioStream?.Index, 0); |
| | | 1299 | | } |
| | | 1300 | | |
| | 256 | 1301 | | DeviceProfile profile = options.Profile; |
| | 256 | 1302 | | string container = mediaSource.Container; |
| | | 1303 | | |
| | | 1304 | | // Check container conditions |
| | 256 | 1305 | | var containerProfileReasons = GetCompatibilityContainer(options, mediaSource, container, videoStream); |
| | | 1306 | | |
| | | 1307 | | // Check video conditions |
| | 256 | 1308 | | var videoCodecProfileReasons = videoStream is null ? default : GetCompatibilityVideoCodec(options, mediaSour |
| | | 1309 | | |
| | | 1310 | | // Check audio candidates profile conditions |
| | 256 | 1311 | | var audioStreamMatches = candidateAudioStreams.ToDictionary(s => s, audioStream => GetCompatibilityAudioCode |
| | | 1312 | | |
| | 256 | 1313 | | TranscodeReason subtitleProfileReasons = 0; |
| | 256 | 1314 | | if (subtitleStream is not null) |
| | | 1315 | | { |
| | 223 | 1316 | | var subtitleProfile = GetSubtitleProfile(mediaSource, subtitleStream, options.Profile.SubtitleProfiles, |
| | | 1317 | | |
| | 223 | 1318 | | if (subtitleProfile.Method != SubtitleDeliveryMethod.Drop |
| | 223 | 1319 | | && subtitleProfile.Method != SubtitleDeliveryMethod.External |
| | 223 | 1320 | | && subtitleProfile.Method != SubtitleDeliveryMethod.Embed) |
| | | 1321 | | { |
| | 0 | 1322 | | _logger.LogDebug("Not eligible for {0} due to unsupported subtitles", PlayMethod.DirectPlay); |
| | 0 | 1323 | | subtitleProfileReasons |= TranscodeReason.SubtitleCodecNotSupported; |
| | | 1324 | | } |
| | | 1325 | | } |
| | | 1326 | | |
| | 256 | 1327 | | var containerSupported = false; |
| | 256 | 1328 | | TranscodeReason[] rankings = [TranscodeReason.VideoCodecNotSupported, VideoCodecReasons, TranscodeReason.Aud |
| | | 1329 | | |
| | | 1330 | | // Check DirectPlay profiles to see if it can be direct played |
| | 256 | 1331 | | var analyzedProfiles = profile.DirectPlayProfiles |
| | 256 | 1332 | | .Where(directPlayProfile => directPlayProfile.Type == DlnaProfileType.Video) |
| | 256 | 1333 | | .Select((directPlayProfile, order) => |
| | 256 | 1334 | | { |
| | 256 | 1335 | | TranscodeReason directPlayProfileReasons = 0; |
| | 256 | 1336 | | TranscodeReason audioCodecProfileReasons = 0; |
| | 256 | 1337 | | |
| | 256 | 1338 | | // Check container type |
| | 256 | 1339 | | if (!directPlayProfile.SupportsContainer(container)) |
| | 256 | 1340 | | { |
| | 256 | 1341 | | directPlayProfileReasons |= TranscodeReason.ContainerNotSupported; |
| | 256 | 1342 | | } |
| | 256 | 1343 | | else |
| | 256 | 1344 | | { |
| | 256 | 1345 | | containerSupported = true; |
| | 256 | 1346 | | } |
| | 256 | 1347 | | |
| | 256 | 1348 | | // Check video codec |
| | 256 | 1349 | | string? videoCodec = videoStream?.Codec; |
| | 256 | 1350 | | if (!directPlayProfile.SupportsVideoCodec(videoCodec)) |
| | 256 | 1351 | | { |
| | 256 | 1352 | | directPlayProfileReasons |= TranscodeReason.VideoCodecNotSupported; |
| | 256 | 1353 | | } |
| | 256 | 1354 | | |
| | 256 | 1355 | | // Check audio codec |
| | 256 | 1356 | | MediaStream? selectedAudioStream = null; |
| | 256 | 1357 | | if (candidateAudioStreams.Count != 0) |
| | 256 | 1358 | | { |
| | 256 | 1359 | | selectedAudioStream = candidateAudioStreams.FirstOrDefault(audioStream => directPlayProfile.Supp |
| | 256 | 1360 | | if (selectedAudioStream is null) |
| | 256 | 1361 | | { |
| | 256 | 1362 | | directPlayProfileReasons |= TranscodeReason.AudioCodecNotSupported; |
| | 256 | 1363 | | } |
| | 256 | 1364 | | else |
| | 256 | 1365 | | { |
| | 256 | 1366 | | audioCodecProfileReasons = audioStreamMatches.GetValueOrDefault(selectedAudioStream); |
| | 256 | 1367 | | } |
| | 256 | 1368 | | } |
| | 256 | 1369 | | |
| | 256 | 1370 | | var failureReasons = directPlayProfileReasons | containerProfileReasons | subtitleProfileReasons; |
| | 256 | 1371 | | |
| | 256 | 1372 | | if ((failureReasons & TranscodeReason.VideoCodecNotSupported) == 0) |
| | 256 | 1373 | | { |
| | 256 | 1374 | | failureReasons |= videoCodecProfileReasons; |
| | 256 | 1375 | | } |
| | 256 | 1376 | | |
| | 256 | 1377 | | if ((failureReasons & TranscodeReason.AudioCodecNotSupported) == 0) |
| | 256 | 1378 | | { |
| | 256 | 1379 | | failureReasons |= audioCodecProfileReasons; |
| | 256 | 1380 | | } |
| | 256 | 1381 | | |
| | 256 | 1382 | | var directStreamFailureReasons = failureReasons & (~DirectStreamReasons); |
| | 256 | 1383 | | |
| | 256 | 1384 | | PlayMethod? playMethod = null; |
| | 256 | 1385 | | if (failureReasons == 0 && isEligibleForDirectPlay && mediaSource.SupportsDirectPlay) |
| | 256 | 1386 | | { |
| | 256 | 1387 | | playMethod = PlayMethod.DirectPlay; |
| | 256 | 1388 | | } |
| | 256 | 1389 | | else if (directStreamFailureReasons == 0 && isEligibleForDirectStream && mediaSource.SupportsDirectS |
| | 256 | 1390 | | { |
| | 256 | 1391 | | playMethod = PlayMethod.DirectStream; |
| | 256 | 1392 | | } |
| | 256 | 1393 | | |
| | 256 | 1394 | | var ranked = GetRank(ref failureReasons, rankings); |
| | 256 | 1395 | | |
| | 256 | 1396 | | return (Result: (Profile: directPlayProfile, PlayMethod: playMethod, AudioStreamIndex: selectedAudio |
| | 256 | 1397 | | }) |
| | 256 | 1398 | | .OrderByDescending(analysis => analysis.Result.PlayMethod) |
| | 256 | 1399 | | .ThenByDescending(analysis => analysis.Rank) |
| | 256 | 1400 | | .ThenBy(analysis => analysis.Order) |
| | 256 | 1401 | | .ToArray() |
| | 256 | 1402 | | .ToLookup(analysis => analysis.Result.PlayMethod is not null); |
| | | 1403 | | |
| | 256 | 1404 | | var profileMatch = analyzedProfiles[true] |
| | 256 | 1405 | | .Select(analysis => analysis.Result) |
| | 256 | 1406 | | .FirstOrDefault(); |
| | 256 | 1407 | | if (profileMatch.Profile is not null) |
| | | 1408 | | { |
| | 125 | 1409 | | return profileMatch; |
| | | 1410 | | } |
| | | 1411 | | |
| | 131 | 1412 | | var failureReasons = analyzedProfiles[false] |
| | 131 | 1413 | | .Select(analysis => analysis.Result) |
| | 131 | 1414 | | .Where(result => !containerSupported || !result.TranscodeReason.HasFlag(TranscodeReason.ContainerNotSupp |
| | 131 | 1415 | | .FirstOrDefault().TranscodeReason; |
| | 131 | 1416 | | if (failureReasons == 0) |
| | | 1417 | | { |
| | 14 | 1418 | | failureReasons = TranscodeReason.DirectPlayError; |
| | | 1419 | | } |
| | | 1420 | | |
| | 131 | 1421 | | return (Profile: null, PlayMethod: null, AudioStreamIndex: null, TranscodeReasons: failureReasons); |
| | | 1422 | | } |
| | | 1423 | | |
| | | 1424 | | private TranscodeReason AggregateFailureConditions(MediaSourceInfo mediaSource, DeviceProfile profile, string ty |
| | | 1425 | | { |
| | 1669 | 1426 | | return conditions.Aggregate<ProfileCondition, TranscodeReason>(0, (reasons, i) => |
| | 1669 | 1427 | | { |
| | 1669 | 1428 | | LogConditionFailure(profile, type, i, mediaSource); |
| | 1669 | 1429 | | var transcodeReasons = GetTranscodeReasonForFailedCondition(i); |
| | 1669 | 1430 | | return reasons | transcodeReasons; |
| | 1669 | 1431 | | }); |
| | | 1432 | | } |
| | | 1433 | | |
| | | 1434 | | private void LogConditionFailure(DeviceProfile profile, string type, ProfileCondition condition, MediaSourceInfo |
| | | 1435 | | { |
| | 248 | 1436 | | _logger.LogDebug( |
| | 248 | 1437 | | "Profile: {0}, DirectPlay=false. Reason={1}.{2} Condition: {3}. ConditionValue: {4}. IsRequired: {5}. Pa |
| | 248 | 1438 | | type, |
| | 248 | 1439 | | profile.Name ?? "Unknown Profile", |
| | 248 | 1440 | | condition.Property, |
| | 248 | 1441 | | condition.Condition, |
| | 248 | 1442 | | condition.Value ?? string.Empty, |
| | 248 | 1443 | | condition.IsRequired, |
| | 248 | 1444 | | mediaSource.Path ?? "Unknown path"); |
| | 248 | 1445 | | } |
| | | 1446 | | |
| | | 1447 | | /// <summary> |
| | | 1448 | | /// Normalizes input container. |
| | | 1449 | | /// </summary> |
| | | 1450 | | /// <param name="mediaSource">The <see cref="MediaSourceInfo"/>.</param> |
| | | 1451 | | /// <param name="subtitleStream">The <see cref="MediaStream"/> of the subtitle stream.</param> |
| | | 1452 | | /// <param name="subtitleProfiles">The list of supported <see cref="SubtitleProfile"/>s.</param> |
| | | 1453 | | /// <param name="playMethod">The <see cref="PlayMethod"/>.</param> |
| | | 1454 | | /// <param name="transcoderSupport">The <see cref="ITranscoderSupport"/>.</param> |
| | | 1455 | | /// <param name="outputContainer">The output container.</param> |
| | | 1456 | | /// <param name="transcodingSubProtocol">The subtitle transcoding protocol.</param> |
| | | 1457 | | /// <returns>The normalized input container.</returns> |
| | | 1458 | | public static SubtitleProfile GetSubtitleProfile( |
| | | 1459 | | MediaSourceInfo mediaSource, |
| | | 1460 | | MediaStream subtitleStream, |
| | | 1461 | | SubtitleProfile[] subtitleProfiles, |
| | | 1462 | | PlayMethod playMethod, |
| | | 1463 | | ITranscoderSupport transcoderSupport, |
| | | 1464 | | string? outputContainer, |
| | | 1465 | | MediaStreamProtocol? transcodingSubProtocol) |
| | | 1466 | | { |
| | 482 | 1467 | | if (CanConsiderEmbedSubtitle(subtitleStream, playMethod, transcodingSubProtocol, outputContainer)) |
| | | 1468 | | { |
| | | 1469 | | // Look for supported embedded subs of the same format |
| | 54 | 1470 | | foreach (var profile in subtitleProfiles) |
| | | 1471 | | { |
| | 15 | 1472 | | if (!profile.SupportsLanguage(subtitleStream.Language)) |
| | | 1473 | | { |
| | | 1474 | | continue; |
| | | 1475 | | } |
| | | 1476 | | |
| | 15 | 1477 | | if (profile.Method != SubtitleDeliveryMethod.Embed) |
| | | 1478 | | { |
| | | 1479 | | continue; |
| | | 1480 | | } |
| | | 1481 | | |
| | 6 | 1482 | | if (!ContainerHelper.ContainsContainer(profile.Container, outputContainer)) |
| | | 1483 | | { |
| | | 1484 | | continue; |
| | | 1485 | | } |
| | | 1486 | | |
| | 6 | 1487 | | if (playMethod == PlayMethod.Transcode && !IsSubtitleEmbedSupported(outputContainer)) |
| | | 1488 | | { |
| | | 1489 | | continue; |
| | | 1490 | | } |
| | | 1491 | | |
| | 6 | 1492 | | if (subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profile.Format) && string.Equals |
| | | 1493 | | { |
| | 6 | 1494 | | return profile; |
| | | 1495 | | } |
| | | 1496 | | } |
| | | 1497 | | |
| | | 1498 | | // Look for supported embedded subs of a convertible format |
| | 36 | 1499 | | foreach (var profile in subtitleProfiles) |
| | | 1500 | | { |
| | 9 | 1501 | | if (!profile.SupportsLanguage(subtitleStream.Language)) |
| | | 1502 | | { |
| | | 1503 | | continue; |
| | | 1504 | | } |
| | | 1505 | | |
| | 9 | 1506 | | if (profile.Method != SubtitleDeliveryMethod.Embed) |
| | | 1507 | | { |
| | | 1508 | | continue; |
| | | 1509 | | } |
| | | 1510 | | |
| | 0 | 1511 | | if (!ContainerHelper.ContainsContainer(profile.Container, outputContainer)) |
| | | 1512 | | { |
| | | 1513 | | continue; |
| | | 1514 | | } |
| | | 1515 | | |
| | 0 | 1516 | | if (playMethod == PlayMethod.Transcode && !IsSubtitleEmbedSupported(outputContainer)) |
| | | 1517 | | { |
| | | 1518 | | continue; |
| | | 1519 | | } |
| | | 1520 | | |
| | 0 | 1521 | | if (subtitleStream.IsTextSubtitleStream && subtitleStream.SupportsSubtitleConversionTo(profile.Forma |
| | | 1522 | | { |
| | 0 | 1523 | | return profile; |
| | | 1524 | | } |
| | | 1525 | | } |
| | | 1526 | | } |
| | | 1527 | | |
| | | 1528 | | // Look for an external or hls profile that matches the stream type (text/graphical) and doesn't require con |
| | 476 | 1529 | | return GetExternalSubtitleProfile(mediaSource, subtitleStream, subtitleProfiles, playMethod, transcoderSuppo |
| | 476 | 1530 | | GetExternalSubtitleProfile(mediaSource, subtitleStream, subtitleProfiles, playMethod, transcoderSupport, |
| | 476 | 1531 | | new SubtitleProfile |
| | 476 | 1532 | | { |
| | 476 | 1533 | | Method = SubtitleDeliveryMethod.Encode, |
| | 476 | 1534 | | Format = subtitleStream.Codec |
| | 476 | 1535 | | }; |
| | | 1536 | | } |
| | | 1537 | | |
| | | 1538 | | private static bool IsSubtitleEmbedSupported(string? transcodingContainer) |
| | | 1539 | | { |
| | 26 | 1540 | | if (!string.IsNullOrEmpty(transcodingContainer)) |
| | | 1541 | | { |
| | 24 | 1542 | | if (ContainerHelper.ContainsContainer(transcodingContainer, "ts,mpegts,mp4")) |
| | | 1543 | | { |
| | 7 | 1544 | | return false; |
| | | 1545 | | } |
| | | 1546 | | |
| | 17 | 1547 | | if (ContainerHelper.ContainsContainer(transcodingContainer, "mkv,matroska")) |
| | | 1548 | | { |
| | 10 | 1549 | | return true; |
| | | 1550 | | } |
| | | 1551 | | } |
| | | 1552 | | |
| | 9 | 1553 | | return false; |
| | | 1554 | | } |
| | | 1555 | | |
| | | 1556 | | private static bool CanConsiderEmbedSubtitle(MediaStream subtitleStream, PlayMethod playMethod, MediaStreamProto |
| | | 1557 | | { |
| | 482 | 1558 | | if (subtitleStream.IsExternal) |
| | | 1559 | | { |
| | 471 | 1560 | | return playMethod == PlayMethod.Transcode |
| | 471 | 1561 | | && transcodingSubProtocol != MediaStreamProtocol.hls |
| | 471 | 1562 | | && IsSubtitleEmbedSupported(outputContainer); |
| | | 1563 | | } |
| | | 1564 | | |
| | 11 | 1565 | | return playMethod != PlayMethod.Transcode |
| | 11 | 1566 | | || transcodingSubProtocol != MediaStreamProtocol.hls; |
| | | 1567 | | } |
| | | 1568 | | |
| | | 1569 | | private static SubtitleProfile? GetExternalSubtitleProfile(MediaSourceInfo mediaSource, MediaStream subtitleStre |
| | | 1570 | | { |
| | 5134 | 1571 | | foreach (var profile in subtitleProfiles) |
| | | 1572 | | { |
| | 2037 | 1573 | | if (profile.Method != SubtitleDeliveryMethod.External && profile.Method != SubtitleDeliveryMethod.Hls) |
| | | 1574 | | { |
| | | 1575 | | continue; |
| | | 1576 | | } |
| | | 1577 | | |
| | 1400 | 1578 | | if (profile.Method == SubtitleDeliveryMethod.Hls && playMethod != PlayMethod.Transcode) |
| | | 1579 | | { |
| | | 1580 | | continue; |
| | | 1581 | | } |
| | | 1582 | | |
| | 1400 | 1583 | | if (!profile.SupportsLanguage(subtitleStream.Language)) |
| | | 1584 | | { |
| | | 1585 | | continue; |
| | | 1586 | | } |
| | | 1587 | | |
| | 1400 | 1588 | | if (!subtitleStream.IsExternal && playMethod == PlayMethod.Transcode && !transcoderSupport.CanExtractSub |
| | | 1589 | | { |
| | | 1590 | | continue; |
| | | 1591 | | } |
| | | 1592 | | |
| | | 1593 | | // FFmpeg cannot mux VobSub back into an .idx/.sub pair, so extracted VobSub streams are matched against |
| | 1394 | 1594 | | bool isVobSubMksProfile = string.Equals(profile.Format, "mks", StringComparison.OrdinalIgnoreCase) |
| | 1394 | 1595 | | && subtitleStream.IsVobSubSubtitleStream |
| | 1394 | 1596 | | && (!subtitleStream.IsExternal || subtitleStream.Path.EndsWith(".mks", StringComparison.OrdinalIgnor |
| | | 1597 | | |
| | 1394 | 1598 | | if ((profile.Method == SubtitleDeliveryMethod.External |
| | 1394 | 1599 | | && (isVobSubMksProfile || subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profil |
| | 1394 | 1600 | | (profile.Method == SubtitleDeliveryMethod.Hls && subtitleStream.IsTextSubtitleStream)) |
| | | 1601 | | { |
| | 1374 | 1602 | | bool requiresConversion = !isVobSubMksProfile |
| | 1374 | 1603 | | && !string.Equals(subtitleStream.Codec, profile.Format, StringComparison.OrdinalIgnoreCase); |
| | | 1604 | | |
| | 1374 | 1605 | | if (!requiresConversion) |
| | | 1606 | | { |
| | 186 | 1607 | | return profile; |
| | | 1608 | | } |
| | | 1609 | | |
| | 1188 | 1610 | | if (!allowConversion) |
| | | 1611 | | { |
| | | 1612 | | continue; |
| | | 1613 | | } |
| | | 1614 | | |
| | | 1615 | | // TODO: Build this into subtitleStream.SupportsExternalStream |
| | 286 | 1616 | | if (mediaSource.IsInfiniteStream) |
| | | 1617 | | { |
| | | 1618 | | continue; |
| | | 1619 | | } |
| | | 1620 | | |
| | 286 | 1621 | | if (subtitleStream.IsTextSubtitleStream && subtitleStream.SupportsExternalStream && subtitleStream.S |
| | | 1622 | | { |
| | 286 | 1623 | | return profile; |
| | | 1624 | | } |
| | | 1625 | | } |
| | | 1626 | | } |
| | | 1627 | | |
| | 294 | 1628 | | return null; |
| | | 1629 | | } |
| | | 1630 | | |
| | | 1631 | | private bool IsBitrateLimitExceeded(MediaSourceInfo item, long maxBitrate) |
| | | 1632 | | { |
| | | 1633 | | // Don't restrict bitrate if item is remote. |
| | 280 | 1634 | | if (item.IsRemote) |
| | | 1635 | | { |
| | 0 | 1636 | | return false; |
| | | 1637 | | } |
| | | 1638 | | |
| | | 1639 | | // If no maximum bitrate is set, default to no maximum bitrate. |
| | 280 | 1640 | | long requestedMaxBitrate = maxBitrate > 0 ? maxBitrate : int.MaxValue; |
| | | 1641 | | |
| | | 1642 | | // If we don't know the item bitrate, then force a transcode if requested max bitrate is under 40 mbps |
| | 280 | 1643 | | int itemBitrate = item.Bitrate ?? 40000000; |
| | | 1644 | | |
| | 280 | 1645 | | if (itemBitrate > requestedMaxBitrate) |
| | | 1646 | | { |
| | 24 | 1647 | | _logger.LogDebug( |
| | 24 | 1648 | | "Bitrate exceeds limit: media bitrate: {MediaBitrate}, max bitrate: {MaxBitrate}", |
| | 24 | 1649 | | itemBitrate, |
| | 24 | 1650 | | requestedMaxBitrate); |
| | 24 | 1651 | | return true; |
| | | 1652 | | } |
| | | 1653 | | |
| | 256 | 1654 | | return false; |
| | | 1655 | | } |
| | | 1656 | | |
| | | 1657 | | private static void ValidateMediaOptions(MediaOptions options, bool isMediaSource) |
| | | 1658 | | { |
| | 280 | 1659 | | if (options.ItemId.IsEmpty()) |
| | | 1660 | | { |
| | 0 | 1661 | | ArgumentException.ThrowIfNullOrEmpty(options.DeviceId); |
| | | 1662 | | } |
| | | 1663 | | |
| | 280 | 1664 | | if (options.Profile is null) |
| | | 1665 | | { |
| | 0 | 1666 | | throw new ArgumentException("Profile is required"); |
| | | 1667 | | } |
| | | 1668 | | |
| | 280 | 1669 | | if (options.MediaSources is null) |
| | | 1670 | | { |
| | 0 | 1671 | | throw new ArgumentException("MediaSources is required"); |
| | | 1672 | | } |
| | | 1673 | | |
| | 280 | 1674 | | if (isMediaSource) |
| | | 1675 | | { |
| | 280 | 1676 | | if (options.AudioStreamIndex.HasValue && string.IsNullOrEmpty(options.MediaSourceId)) |
| | | 1677 | | { |
| | 0 | 1678 | | throw new ArgumentException("MediaSourceId is required when a specific audio stream is requested"); |
| | | 1679 | | } |
| | | 1680 | | |
| | 280 | 1681 | | if (options.SubtitleStreamIndex.HasValue && string.IsNullOrEmpty(options.MediaSourceId)) |
| | | 1682 | | { |
| | 0 | 1683 | | throw new ArgumentException("MediaSourceId is required when a specific subtitle stream is requested" |
| | | 1684 | | } |
| | | 1685 | | } |
| | 280 | 1686 | | } |
| | | 1687 | | |
| | | 1688 | | private static IEnumerable<ProfileCondition> GetProfileConditionsForVideoAudio( |
| | | 1689 | | IEnumerable<CodecProfile> codecProfiles, |
| | | 1690 | | string container, |
| | | 1691 | | string codec, |
| | | 1692 | | int? audioChannels, |
| | | 1693 | | int? audioBitrate, |
| | | 1694 | | int? audioSampleRate, |
| | | 1695 | | int? audioBitDepth, |
| | | 1696 | | string audioProfile, |
| | | 1697 | | bool? isSecondaryAudio) |
| | | 1698 | | { |
| | 1009 | 1699 | | return codecProfiles |
| | 1009 | 1700 | | .Where(profile => profile.Type == CodecType.VideoAudio && |
| | 1009 | 1701 | | profile.ContainsAnyCodec(codec, container) && |
| | 1009 | 1702 | | profile.ApplyConditions.All(applyCondition => ConditionProcessor.IsVideoAudioConditionSatisfied(appl |
| | 1009 | 1703 | | .SelectMany(profile => profile.Conditions) |
| | 1009 | 1704 | | .Where(condition => !ConditionProcessor.IsVideoAudioConditionSatisfied(condition, audioChannels, audioBi |
| | | 1705 | | } |
| | | 1706 | | |
| | | 1707 | | private static IEnumerable<ProfileCondition> GetProfileConditionsForAudio( |
| | | 1708 | | IEnumerable<CodecProfile> codecProfiles, |
| | | 1709 | | string container, |
| | | 1710 | | string? codec, |
| | | 1711 | | int? audioChannels, |
| | | 1712 | | int? audioBitrate, |
| | | 1713 | | int? audioSampleRate, |
| | | 1714 | | int? audioBitDepth, |
| | | 1715 | | bool checkConditions) |
| | | 1716 | | { |
| | 0 | 1717 | | var conditions = codecProfiles |
| | 0 | 1718 | | .Where(profile => profile.Type == CodecType.Audio && |
| | 0 | 1719 | | profile.ContainsAnyCodec(codec, container) && |
| | 0 | 1720 | | profile.ApplyConditions.All(applyCondition => ConditionProcessor.IsAudioConditionSatisfied(applyCond |
| | 0 | 1721 | | .SelectMany(profile => profile.Conditions); |
| | | 1722 | | |
| | 0 | 1723 | | if (!checkConditions) |
| | | 1724 | | { |
| | 0 | 1725 | | return conditions; |
| | | 1726 | | } |
| | | 1727 | | |
| | 0 | 1728 | | return conditions.Where(condition => !ConditionProcessor.IsAudioConditionSatisfied(condition, audioChannels, |
| | | 1729 | | } |
| | | 1730 | | |
| | | 1731 | | private void ApplyTranscodingConditions(StreamInfo item, IEnumerable<ProfileCondition> conditions, string? quali |
| | | 1732 | | { |
| | 3514 | 1733 | | foreach (ProfileCondition condition in conditions) |
| | | 1734 | | { |
| | 1244 | 1735 | | string value = condition.Value; |
| | | 1736 | | |
| | 1244 | 1737 | | if (string.IsNullOrEmpty(value)) |
| | | 1738 | | { |
| | | 1739 | | continue; |
| | | 1740 | | } |
| | | 1741 | | |
| | | 1742 | | // No way to express this |
| | 1244 | 1743 | | if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 1744 | | { |
| | | 1745 | | continue; |
| | | 1746 | | } |
| | | 1747 | | |
| | 1244 | 1748 | | switch (condition.Property) |
| | | 1749 | | { |
| | | 1750 | | case ProfileConditionValue.AudioBitrate: |
| | | 1751 | | { |
| | 0 | 1752 | | if (!enableNonQualifiedConditions) |
| | | 1753 | | { |
| | | 1754 | | continue; |
| | | 1755 | | } |
| | | 1756 | | |
| | 0 | 1757 | | if (int.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 1758 | | { |
| | 0 | 1759 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 1760 | | { |
| | 0 | 1761 | | item.AudioBitrate = num; |
| | | 1762 | | } |
| | 0 | 1763 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 1764 | | { |
| | 0 | 1765 | | item.AudioBitrate = Math.Min(num, item.AudioBitrate ?? num); |
| | | 1766 | | } |
| | 0 | 1767 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 1768 | | { |
| | 0 | 1769 | | item.AudioBitrate = Math.Max(num, item.AudioBitrate ?? num); |
| | | 1770 | | } |
| | | 1771 | | } |
| | | 1772 | | |
| | 0 | 1773 | | break; |
| | | 1774 | | } |
| | | 1775 | | |
| | | 1776 | | case ProfileConditionValue.AudioSampleRate: |
| | | 1777 | | { |
| | 0 | 1778 | | if (!enableNonQualifiedConditions) |
| | | 1779 | | { |
| | | 1780 | | continue; |
| | | 1781 | | } |
| | | 1782 | | |
| | 0 | 1783 | | if (int.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 1784 | | { |
| | 0 | 1785 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 1786 | | { |
| | 0 | 1787 | | item.AudioSampleRate = num; |
| | | 1788 | | } |
| | 0 | 1789 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 1790 | | { |
| | 0 | 1791 | | item.AudioSampleRate = Math.Min(num, item.AudioSampleRate ?? num); |
| | | 1792 | | } |
| | 0 | 1793 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 1794 | | { |
| | 0 | 1795 | | item.AudioSampleRate = Math.Max(num, item.AudioSampleRate ?? num); |
| | | 1796 | | } |
| | | 1797 | | } |
| | | 1798 | | |
| | 0 | 1799 | | break; |
| | | 1800 | | } |
| | | 1801 | | |
| | | 1802 | | case ProfileConditionValue.AudioChannels: |
| | | 1803 | | { |
| | 28 | 1804 | | if (string.IsNullOrEmpty(qualifier)) |
| | | 1805 | | { |
| | 0 | 1806 | | if (!enableNonQualifiedConditions) |
| | | 1807 | | { |
| | 0 | 1808 | | continue; |
| | | 1809 | | } |
| | | 1810 | | } |
| | | 1811 | | else |
| | | 1812 | | { |
| | 28 | 1813 | | if (!enableQualifiedConditions) |
| | | 1814 | | { |
| | | 1815 | | continue; |
| | | 1816 | | } |
| | | 1817 | | } |
| | | 1818 | | |
| | 28 | 1819 | | if (int.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 1820 | | { |
| | 28 | 1821 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 1822 | | { |
| | 0 | 1823 | | item.SetOption(qualifier, "audiochannels", num.ToString(CultureInfo.InvariantCulture |
| | | 1824 | | } |
| | 28 | 1825 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 1826 | | { |
| | 28 | 1827 | | item.SetOption(qualifier, "audiochannels", Math.Min(num, item.GetTargetAudioChannels |
| | | 1828 | | } |
| | 0 | 1829 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 1830 | | { |
| | 0 | 1831 | | item.SetOption(qualifier, "audiochannels", Math.Max(num, item.GetTargetAudioChannels |
| | | 1832 | | } |
| | | 1833 | | } |
| | | 1834 | | |
| | 0 | 1835 | | break; |
| | | 1836 | | } |
| | | 1837 | | |
| | | 1838 | | case ProfileConditionValue.IsAvc: |
| | | 1839 | | { |
| | 0 | 1840 | | if (!enableNonQualifiedConditions) |
| | | 1841 | | { |
| | | 1842 | | continue; |
| | | 1843 | | } |
| | | 1844 | | |
| | 0 | 1845 | | if (bool.TryParse(value, out var isAvc)) |
| | | 1846 | | { |
| | 0 | 1847 | | if (isAvc && condition.Condition == ProfileConditionType.Equals) |
| | | 1848 | | { |
| | 0 | 1849 | | item.RequireAvc = true; |
| | | 1850 | | } |
| | 0 | 1851 | | else if (!isAvc && condition.Condition == ProfileConditionType.NotEquals) |
| | | 1852 | | { |
| | 0 | 1853 | | item.RequireAvc = true; |
| | | 1854 | | } |
| | | 1855 | | } |
| | | 1856 | | |
| | 0 | 1857 | | break; |
| | | 1858 | | } |
| | | 1859 | | |
| | | 1860 | | case ProfileConditionValue.IsAnamorphic: |
| | | 1861 | | { |
| | 201 | 1862 | | if (!enableNonQualifiedConditions) |
| | | 1863 | | { |
| | | 1864 | | continue; |
| | | 1865 | | } |
| | | 1866 | | |
| | 201 | 1867 | | if (bool.TryParse(value, out var isAnamorphic)) |
| | | 1868 | | { |
| | 201 | 1869 | | if (isAnamorphic && condition.Condition == ProfileConditionType.Equals) |
| | | 1870 | | { |
| | 0 | 1871 | | item.RequireNonAnamorphic = true; |
| | | 1872 | | } |
| | 201 | 1873 | | else if (!isAnamorphic && condition.Condition == ProfileConditionType.NotEquals) |
| | | 1874 | | { |
| | 0 | 1875 | | item.RequireNonAnamorphic = true; |
| | | 1876 | | } |
| | | 1877 | | } |
| | | 1878 | | |
| | 0 | 1879 | | break; |
| | | 1880 | | } |
| | | 1881 | | |
| | | 1882 | | case ProfileConditionValue.IsInterlaced: |
| | | 1883 | | { |
| | 109 | 1884 | | if (string.IsNullOrEmpty(qualifier)) |
| | | 1885 | | { |
| | 0 | 1886 | | if (!enableNonQualifiedConditions) |
| | | 1887 | | { |
| | 0 | 1888 | | continue; |
| | | 1889 | | } |
| | | 1890 | | } |
| | | 1891 | | else |
| | | 1892 | | { |
| | 109 | 1893 | | if (!enableQualifiedConditions) |
| | | 1894 | | { |
| | | 1895 | | continue; |
| | | 1896 | | } |
| | | 1897 | | } |
| | | 1898 | | |
| | 109 | 1899 | | if (bool.TryParse(value, out var isInterlaced)) |
| | | 1900 | | { |
| | 109 | 1901 | | if (!isInterlaced && condition.Condition == ProfileConditionType.Equals) |
| | | 1902 | | { |
| | 0 | 1903 | | item.SetOption(qualifier, "deinterlace", "true"); |
| | | 1904 | | } |
| | 109 | 1905 | | else if (isInterlaced && condition.Condition == ProfileConditionType.NotEquals) |
| | | 1906 | | { |
| | 109 | 1907 | | item.SetOption(qualifier, "deinterlace", "true"); |
| | | 1908 | | } |
| | | 1909 | | } |
| | | 1910 | | |
| | 109 | 1911 | | break; |
| | | 1912 | | } |
| | | 1913 | | |
| | | 1914 | | case ProfileConditionValue.AudioProfile: |
| | | 1915 | | case ProfileConditionValue.Has64BitOffsets: |
| | | 1916 | | case ProfileConditionValue.PacketLength: |
| | | 1917 | | case ProfileConditionValue.NumStreams: |
| | | 1918 | | case ProfileConditionValue.NumAudioStreams: |
| | | 1919 | | case ProfileConditionValue.NumVideoStreams: |
| | | 1920 | | case ProfileConditionValue.IsSecondaryAudio: |
| | | 1921 | | case ProfileConditionValue.VideoTimestamp: |
| | | 1922 | | { |
| | | 1923 | | // Not supported yet |
| | | 1924 | | break; |
| | | 1925 | | } |
| | | 1926 | | |
| | | 1927 | | case ProfileConditionValue.RefFrames: |
| | | 1928 | | { |
| | 2 | 1929 | | if (string.IsNullOrEmpty(qualifier)) |
| | | 1930 | | { |
| | 0 | 1931 | | if (!enableNonQualifiedConditions) |
| | | 1932 | | { |
| | 0 | 1933 | | continue; |
| | | 1934 | | } |
| | | 1935 | | } |
| | | 1936 | | else |
| | | 1937 | | { |
| | 2 | 1938 | | if (!enableQualifiedConditions) |
| | | 1939 | | { |
| | | 1940 | | continue; |
| | | 1941 | | } |
| | | 1942 | | } |
| | | 1943 | | |
| | 2 | 1944 | | if (int.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 1945 | | { |
| | 2 | 1946 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 1947 | | { |
| | 0 | 1948 | | item.SetOption(qualifier, "maxrefframes", num.ToString(CultureInfo.InvariantCulture) |
| | | 1949 | | } |
| | 2 | 1950 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 1951 | | { |
| | 2 | 1952 | | item.SetOption(qualifier, "maxrefframes", Math.Min(num, item.GetTargetRefFrames(qual |
| | | 1953 | | } |
| | 0 | 1954 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 1955 | | { |
| | 0 | 1956 | | item.SetOption(qualifier, "maxrefframes", Math.Max(num, item.GetTargetRefFrames(qual |
| | | 1957 | | } |
| | | 1958 | | } |
| | | 1959 | | |
| | 0 | 1960 | | break; |
| | | 1961 | | } |
| | | 1962 | | |
| | | 1963 | | case ProfileConditionValue.VideoBitDepth: |
| | | 1964 | | { |
| | 0 | 1965 | | if (string.IsNullOrEmpty(qualifier)) |
| | | 1966 | | { |
| | 0 | 1967 | | if (!enableNonQualifiedConditions) |
| | | 1968 | | { |
| | 0 | 1969 | | continue; |
| | | 1970 | | } |
| | | 1971 | | } |
| | | 1972 | | else |
| | | 1973 | | { |
| | 0 | 1974 | | if (!enableQualifiedConditions) |
| | | 1975 | | { |
| | | 1976 | | continue; |
| | | 1977 | | } |
| | | 1978 | | } |
| | | 1979 | | |
| | 0 | 1980 | | if (int.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 1981 | | { |
| | 0 | 1982 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 1983 | | { |
| | 0 | 1984 | | item.SetOption(qualifier, "videobitdepth", num.ToString(CultureInfo.InvariantCulture |
| | | 1985 | | } |
| | 0 | 1986 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 1987 | | { |
| | 0 | 1988 | | item.SetOption(qualifier, "videobitdepth", Math.Min(num, item.GetTargetVideoBitDepth |
| | | 1989 | | } |
| | 0 | 1990 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 1991 | | { |
| | 0 | 1992 | | item.SetOption(qualifier, "videobitdepth", Math.Max(num, item.GetTargetVideoBitDepth |
| | | 1993 | | } |
| | | 1994 | | } |
| | | 1995 | | |
| | 0 | 1996 | | break; |
| | | 1997 | | } |
| | | 1998 | | |
| | | 1999 | | case ProfileConditionValue.VideoProfile: |
| | | 2000 | | { |
| | 224 | 2001 | | if (string.IsNullOrEmpty(qualifier)) |
| | | 2002 | | { |
| | | 2003 | | continue; |
| | | 2004 | | } |
| | | 2005 | | |
| | | 2006 | | // Change from split by | to comma |
| | | 2007 | | // Strip spaces to avoid having to encode |
| | 224 | 2008 | | var values = value |
| | 224 | 2009 | | .Split('|', StringSplitOptions.RemoveEmptyEntries); |
| | | 2010 | | |
| | 224 | 2011 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 2012 | | { |
| | 0 | 2013 | | item.SetOption(qualifier, "profile", string.Join(',', values)); |
| | | 2014 | | } |
| | 224 | 2015 | | else if (condition.Condition == ProfileConditionType.EqualsAny) |
| | | 2016 | | { |
| | 224 | 2017 | | var currentValue = item.GetOption(qualifier, "profile"); |
| | 224 | 2018 | | if (!string.IsNullOrEmpty(currentValue) && values.Any(value => value == currentValue)) |
| | | 2019 | | { |
| | 71 | 2020 | | item.SetOption(qualifier, "profile", currentValue); |
| | | 2021 | | } |
| | | 2022 | | else |
| | | 2023 | | { |
| | 153 | 2024 | | item.SetOption(qualifier, "profile", string.Join(',', values)); |
| | | 2025 | | } |
| | | 2026 | | } |
| | | 2027 | | |
| | 153 | 2028 | | break; |
| | | 2029 | | } |
| | | 2030 | | |
| | | 2031 | | case ProfileConditionValue.VideoRangeType: |
| | | 2032 | | { |
| | 258 | 2033 | | if (string.IsNullOrEmpty(qualifier)) |
| | | 2034 | | { |
| | | 2035 | | continue; |
| | | 2036 | | } |
| | | 2037 | | |
| | | 2038 | | // change from split by | to comma |
| | | 2039 | | // strip spaces to avoid having to encode |
| | 258 | 2040 | | var values = value |
| | 258 | 2041 | | .Split('|', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries); |
| | | 2042 | | |
| | 258 | 2043 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 2044 | | { |
| | 0 | 2045 | | item.SetOption(qualifier, "rangetype", string.Join(',', values)); |
| | | 2046 | | } |
| | 258 | 2047 | | else if (condition.Condition == ProfileConditionType.NotEquals) |
| | | 2048 | | { |
| | 0 | 2049 | | item.SetOption(qualifier, "rangetype", string.Join(',', Enum.GetNames<VideoRangeType>(). |
| | | 2050 | | } |
| | 258 | 2051 | | else if (condition.Condition == ProfileConditionType.EqualsAny) |
| | | 2052 | | { |
| | 258 | 2053 | | var currentValue = item.GetOption(qualifier, "rangetype"); |
| | 258 | 2054 | | if (!string.IsNullOrEmpty(currentValue) && values.Any(v => string.Equals(v, currentValue |
| | | 2055 | | { |
| | 0 | 2056 | | item.SetOption(qualifier, "rangetype", currentValue); |
| | | 2057 | | } |
| | | 2058 | | else |
| | | 2059 | | { |
| | 258 | 2060 | | item.SetOption(qualifier, "rangetype", string.Join(',', values)); |
| | | 2061 | | } |
| | | 2062 | | } |
| | | 2063 | | |
| | 258 | 2064 | | break; |
| | | 2065 | | } |
| | | 2066 | | |
| | | 2067 | | case ProfileConditionValue.VideoCodecTag: |
| | | 2068 | | { |
| | 12 | 2069 | | if (string.IsNullOrEmpty(qualifier)) |
| | | 2070 | | { |
| | | 2071 | | continue; |
| | | 2072 | | } |
| | | 2073 | | |
| | | 2074 | | // change from split by | to comma |
| | | 2075 | | // strip spaces to avoid having to encode |
| | 12 | 2076 | | var values = value |
| | 12 | 2077 | | .Split('|', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries); |
| | | 2078 | | |
| | 12 | 2079 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 2080 | | { |
| | 0 | 2081 | | item.SetOption(qualifier, "codectag", string.Join(',', values)); |
| | | 2082 | | } |
| | 12 | 2083 | | else if (condition.Condition == ProfileConditionType.EqualsAny) |
| | | 2084 | | { |
| | 12 | 2085 | | var currentValue = item.GetOption(qualifier, "codectag"); |
| | 12 | 2086 | | if (!string.IsNullOrEmpty(currentValue) && values.Any(v => string.Equals(v, currentValue |
| | | 2087 | | { |
| | 0 | 2088 | | item.SetOption(qualifier, "codectag", currentValue); |
| | | 2089 | | } |
| | | 2090 | | else |
| | | 2091 | | { |
| | 12 | 2092 | | item.SetOption(qualifier, "codectag", string.Join(',', values)); |
| | | 2093 | | } |
| | | 2094 | | } |
| | | 2095 | | |
| | 12 | 2096 | | break; |
| | | 2097 | | } |
| | | 2098 | | |
| | | 2099 | | case ProfileConditionValue.VideoRotation: |
| | | 2100 | | { |
| | 0 | 2101 | | if (string.IsNullOrEmpty(qualifier)) |
| | | 2102 | | { |
| | | 2103 | | continue; |
| | | 2104 | | } |
| | | 2105 | | |
| | | 2106 | | // change from split by | to comma |
| | | 2107 | | // strip spaces to avoid having to encode |
| | 0 | 2108 | | var values = value |
| | 0 | 2109 | | .Split('|', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries); |
| | | 2110 | | |
| | 0 | 2111 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 2112 | | { |
| | 0 | 2113 | | item.SetOption(qualifier, "rotation", string.Join(',', values)); |
| | | 2114 | | } |
| | 0 | 2115 | | else if (condition.Condition == ProfileConditionType.EqualsAny) |
| | | 2116 | | { |
| | 0 | 2117 | | var currentValue = item.GetOption(qualifier, "rotation"); |
| | 0 | 2118 | | if (!string.IsNullOrEmpty(currentValue) && values.Any(v => string.Equals(v, currentValue |
| | | 2119 | | { |
| | 0 | 2120 | | item.SetOption(qualifier, "rotation", currentValue); |
| | | 2121 | | } |
| | | 2122 | | else |
| | | 2123 | | { |
| | 0 | 2124 | | item.SetOption(qualifier, "rotation", string.Join(',', values)); |
| | | 2125 | | } |
| | | 2126 | | } |
| | | 2127 | | |
| | 0 | 2128 | | break; |
| | | 2129 | | } |
| | | 2130 | | |
| | | 2131 | | case ProfileConditionValue.Height: |
| | | 2132 | | { |
| | 0 | 2133 | | if (!enableNonQualifiedConditions) |
| | | 2134 | | { |
| | | 2135 | | continue; |
| | | 2136 | | } |
| | | 2137 | | |
| | 0 | 2138 | | if (int.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 2139 | | { |
| | 0 | 2140 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 2141 | | { |
| | 0 | 2142 | | item.MaxHeight = num; |
| | | 2143 | | } |
| | 0 | 2144 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 2145 | | { |
| | 0 | 2146 | | item.MaxHeight = Math.Min(num, item.MaxHeight ?? num); |
| | | 2147 | | } |
| | 0 | 2148 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 2149 | | { |
| | 0 | 2150 | | item.MaxHeight = Math.Max(num, item.MaxHeight ?? num); |
| | | 2151 | | } |
| | | 2152 | | } |
| | | 2153 | | |
| | 0 | 2154 | | break; |
| | | 2155 | | } |
| | | 2156 | | |
| | | 2157 | | case ProfileConditionValue.VideoBitrate: |
| | | 2158 | | { |
| | 32 | 2159 | | if (!enableNonQualifiedConditions) |
| | | 2160 | | { |
| | | 2161 | | continue; |
| | | 2162 | | } |
| | | 2163 | | |
| | 32 | 2164 | | if (int.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 2165 | | { |
| | 32 | 2166 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 2167 | | { |
| | 0 | 2168 | | item.VideoBitrate = num; |
| | | 2169 | | } |
| | 32 | 2170 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 2171 | | { |
| | 32 | 2172 | | item.VideoBitrate = Math.Min(num, item.VideoBitrate ?? num); |
| | | 2173 | | } |
| | 0 | 2174 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 2175 | | { |
| | 0 | 2176 | | item.VideoBitrate = Math.Max(num, item.VideoBitrate ?? num); |
| | | 2177 | | } |
| | | 2178 | | } |
| | | 2179 | | |
| | 0 | 2180 | | break; |
| | | 2181 | | } |
| | | 2182 | | |
| | | 2183 | | case ProfileConditionValue.VideoFramerate: |
| | | 2184 | | { |
| | 12 | 2185 | | if (!enableNonQualifiedConditions) |
| | | 2186 | | { |
| | | 2187 | | continue; |
| | | 2188 | | } |
| | | 2189 | | |
| | 12 | 2190 | | if (float.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 2191 | | { |
| | 12 | 2192 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 2193 | | { |
| | 0 | 2194 | | item.MaxFramerate = num; |
| | | 2195 | | } |
| | 12 | 2196 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 2197 | | { |
| | 12 | 2198 | | item.MaxFramerate = Math.Min(num, item.MaxFramerate ?? num); |
| | | 2199 | | } |
| | 0 | 2200 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 2201 | | { |
| | 0 | 2202 | | item.MaxFramerate = Math.Max(num, item.MaxFramerate ?? num); |
| | | 2203 | | } |
| | | 2204 | | } |
| | | 2205 | | |
| | 0 | 2206 | | break; |
| | | 2207 | | } |
| | | 2208 | | |
| | | 2209 | | case ProfileConditionValue.VideoLevel: |
| | | 2210 | | { |
| | 212 | 2211 | | if (string.IsNullOrEmpty(qualifier)) |
| | | 2212 | | { |
| | | 2213 | | continue; |
| | | 2214 | | } |
| | | 2215 | | |
| | 212 | 2216 | | if (int.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 2217 | | { |
| | 212 | 2218 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 2219 | | { |
| | 0 | 2220 | | item.SetOption(qualifier, "level", num.ToString(CultureInfo.InvariantCulture)); |
| | | 2221 | | } |
| | 212 | 2222 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 2223 | | { |
| | 212 | 2224 | | item.SetOption(qualifier, "level", Math.Min(num, item.GetTargetVideoLevel(qualifier) |
| | | 2225 | | } |
| | 0 | 2226 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 2227 | | { |
| | 0 | 2228 | | item.SetOption(qualifier, "level", Math.Max(num, item.GetTargetVideoLevel(qualifier) |
| | | 2229 | | } |
| | | 2230 | | } |
| | | 2231 | | |
| | 0 | 2232 | | break; |
| | | 2233 | | } |
| | | 2234 | | |
| | | 2235 | | case ProfileConditionValue.Width: |
| | | 2236 | | { |
| | 4 | 2237 | | if (!enableNonQualifiedConditions) |
| | | 2238 | | { |
| | | 2239 | | continue; |
| | | 2240 | | } |
| | | 2241 | | |
| | 4 | 2242 | | if (int.TryParse(value, CultureInfo.InvariantCulture, out var num)) |
| | | 2243 | | { |
| | 4 | 2244 | | if (condition.Condition == ProfileConditionType.Equals) |
| | | 2245 | | { |
| | 0 | 2246 | | item.MaxWidth = num; |
| | | 2247 | | } |
| | 4 | 2248 | | else if (condition.Condition == ProfileConditionType.LessThanEqual) |
| | | 2249 | | { |
| | 4 | 2250 | | item.MaxWidth = Math.Min(num, item.MaxWidth ?? num); |
| | | 2251 | | } |
| | 0 | 2252 | | else if (condition.Condition == ProfileConditionType.GreaterThanEqual) |
| | | 2253 | | { |
| | 0 | 2254 | | item.MaxWidth = Math.Max(num, item.MaxWidth ?? num); |
| | | 2255 | | } |
| | | 2256 | | } |
| | | 2257 | | |
| | | 2258 | | break; |
| | | 2259 | | } |
| | | 2260 | | |
| | | 2261 | | default: |
| | | 2262 | | break; |
| | | 2263 | | } |
| | | 2264 | | } |
| | 513 | 2265 | | } |
| | | 2266 | | |
| | | 2267 | | private static bool IsAudioContainerSupported(DirectPlayProfile profile, MediaSourceInfo item) |
| | | 2268 | | { |
| | | 2269 | | // Check container type |
| | 0 | 2270 | | if (!profile.SupportsContainer(item.Container)) |
| | | 2271 | | { |
| | 0 | 2272 | | return false; |
| | | 2273 | | } |
| | | 2274 | | |
| | | 2275 | | // Never direct play audio in matroska when the device only declare support for webm. |
| | | 2276 | | // The first check is not enough because mkv is assumed can be webm. |
| | | 2277 | | // See https://github.com/jellyfin/jellyfin/issues/13344 |
| | 0 | 2278 | | return !ContainerHelper.ContainsContainer("mkv", item.Container) |
| | 0 | 2279 | | || profile.SupportsContainer("mkv"); |
| | | 2280 | | } |
| | | 2281 | | |
| | | 2282 | | private static bool IsAudioDirectPlaySupported(DirectPlayProfile profile, MediaSourceInfo item, MediaStream audi |
| | | 2283 | | { |
| | 0 | 2284 | | if (!IsAudioContainerSupported(profile, item)) |
| | | 2285 | | { |
| | 0 | 2286 | | return false; |
| | | 2287 | | } |
| | | 2288 | | |
| | | 2289 | | // Check audio codec |
| | 0 | 2290 | | string? audioCodec = audioStream?.Codec; |
| | 0 | 2291 | | if (!profile.SupportsAudioCodec(audioCodec)) |
| | | 2292 | | { |
| | 0 | 2293 | | return false; |
| | | 2294 | | } |
| | | 2295 | | |
| | 0 | 2296 | | return true; |
| | | 2297 | | } |
| | | 2298 | | |
| | | 2299 | | private static bool IsAudioDirectStreamSupported(DirectPlayProfile profile, MediaSourceInfo item, MediaStream au |
| | | 2300 | | { |
| | | 2301 | | // Check container type, this should NOT be supported |
| | | 2302 | | // If the container is supported, the file should be directly played |
| | 0 | 2303 | | if (IsAudioContainerSupported(profile, item)) |
| | | 2304 | | { |
| | 0 | 2305 | | return false; |
| | | 2306 | | } |
| | | 2307 | | |
| | | 2308 | | // Check audio codec, we cannot use the SupportsAudioCodec here |
| | | 2309 | | // Because that one assumes empty container supports all codec, which is just useless |
| | 0 | 2310 | | string? audioCodec = audioStream?.Codec; |
| | 0 | 2311 | | return string.Equals(profile.AudioCodec, audioCodec, StringComparison.OrdinalIgnoreCase) |
| | 0 | 2312 | | || string.Equals(profile.Container, audioCodec, StringComparison.OrdinalIgnoreCase); |
| | | 2313 | | } |
| | | 2314 | | |
| | | 2315 | | private int GetRank(ref TranscodeReason a, TranscodeReason[] rankings) |
| | | 2316 | | { |
| | 1211 | 2317 | | var index = 1; |
| | 8757 | 2318 | | foreach (var flag in rankings) |
| | | 2319 | | { |
| | 3673 | 2320 | | var reason = a & flag; |
| | 3673 | 2321 | | if (reason != 0) |
| | | 2322 | | { |
| | 1011 | 2323 | | return index; |
| | | 2324 | | } |
| | | 2325 | | |
| | 2662 | 2326 | | index++; |
| | | 2327 | | } |
| | | 2328 | | |
| | 200 | 2329 | | return index; |
| | | 2330 | | } |
| | | 2331 | | |
| | | 2332 | | /// <summary> |
| | | 2333 | | /// Check the profile conditions. |
| | | 2334 | | /// </summary> |
| | | 2335 | | /// <param name="conditions">Profile conditions.</param> |
| | | 2336 | | /// <param name="mediaSource">Media source.</param> |
| | | 2337 | | /// <param name="videoStream">Video stream.</param> |
| | | 2338 | | /// <returns>Failed profile conditions.</returns> |
| | | 2339 | | private IEnumerable<ProfileCondition> CheckVideoConditions(ProfileCondition[] conditions, MediaSourceInfo mediaS |
| | | 2340 | | { |
| | 731 | 2341 | | int? width = videoStream?.Width; |
| | 731 | 2342 | | int? height = videoStream?.Height; |
| | 731 | 2343 | | int? bitDepth = videoStream?.BitDepth; |
| | 731 | 2344 | | int? videoBitrate = videoStream?.BitRate; |
| | 731 | 2345 | | double? videoLevel = videoStream?.Level; |
| | 731 | 2346 | | string? videoProfile = videoStream?.Profile; |
| | 731 | 2347 | | VideoRangeType? videoRangeType = videoStream?.VideoRangeType; |
| | 731 | 2348 | | float videoFramerate = videoStream is null ? 0 : videoStream.ReferenceFrameRate ?? 0; |
| | 731 | 2349 | | bool? isAnamorphic = videoStream?.IsAnamorphic; |
| | 731 | 2350 | | bool? isInterlaced = videoStream?.IsInterlaced; |
| | 731 | 2351 | | string? videoCodecTag = videoStream?.CodecTag; |
| | 731 | 2352 | | bool? isAvc = videoStream?.IsAVC; |
| | 731 | 2353 | | int? videoRotation = videoStream?.Rotation; |
| | | 2354 | | |
| | 731 | 2355 | | TransportStreamTimestamp? timestamp = videoStream is null ? TransportStreamTimestamp.None : mediaSource.Time |
| | 731 | 2356 | | int? packetLength = videoStream?.PacketLength; |
| | 731 | 2357 | | int? refFrames = videoStream?.RefFrames; |
| | | 2358 | | |
| | 731 | 2359 | | int numStreams = mediaSource.MediaStreams.Count; |
| | 731 | 2360 | | int? numAudioStreams = mediaSource.GetStreamCount(MediaStreamType.Audio); |
| | 731 | 2361 | | int? numVideoStreams = mediaSource.GetStreamCount(MediaStreamType.Video); |
| | | 2362 | | |
| | 731 | 2363 | | return conditions.Where(applyCondition => !ConditionProcessor.IsVideoConditionSatisfied(applyCondition, widt |
| | | 2364 | | } |
| | | 2365 | | |
| | | 2366 | | /// <summary> |
| | | 2367 | | /// Check the compatibility of the container. |
| | | 2368 | | /// </summary> |
| | | 2369 | | /// <param name="options">Media options.</param> |
| | | 2370 | | /// <param name="mediaSource">Media source.</param> |
| | | 2371 | | /// <param name="container">Container.</param> |
| | | 2372 | | /// <param name="videoStream">Video stream.</param> |
| | | 2373 | | /// <returns>Transcode reasons if the container is not fully compatible.</returns> |
| | | 2374 | | private TranscodeReason GetCompatibilityContainer(MediaOptions options, MediaSourceInfo mediaSource, string cont |
| | | 2375 | | { |
| | 256 | 2376 | | var profile = options.Profile; |
| | | 2377 | | |
| | 256 | 2378 | | var failures = AggregateFailureConditions( |
| | 256 | 2379 | | mediaSource, |
| | 256 | 2380 | | profile, |
| | 256 | 2381 | | "VideoCodecProfile", |
| | 256 | 2382 | | profile.ContainerProfiles |
| | 256 | 2383 | | .Where(containerProfile => containerProfile.Type == DlnaProfileType.Video && containerProfile.Contai |
| | 256 | 2384 | | .SelectMany(containerProfile => CheckVideoConditions(containerProfile.Conditions, mediaSource, video |
| | | 2385 | | |
| | 256 | 2386 | | return failures; |
| | | 2387 | | } |
| | | 2388 | | |
| | | 2389 | | /// <summary> |
| | | 2390 | | /// Check the compatibility of the video codec. |
| | | 2391 | | /// </summary> |
| | | 2392 | | /// <param name="options">Media options.</param> |
| | | 2393 | | /// <param name="mediaSource">Media source.</param> |
| | | 2394 | | /// <param name="container">Container.</param> |
| | | 2395 | | /// <param name="videoStream">Video stream.</param> |
| | | 2396 | | /// <returns>Transcode reasons if the video stream is not fully compatible.</returns> |
| | | 2397 | | private TranscodeReason GetCompatibilityVideoCodec(MediaOptions options, MediaSourceInfo mediaSource, string con |
| | | 2398 | | { |
| | 404 | 2399 | | var profile = options.Profile; |
| | | 2400 | | |
| | 404 | 2401 | | string videoCodec = videoStream.Codec; |
| | | 2402 | | |
| | 404 | 2403 | | var failures = AggregateFailureConditions( |
| | 404 | 2404 | | mediaSource, |
| | 404 | 2405 | | profile, |
| | 404 | 2406 | | "VideoCodecProfile", |
| | 404 | 2407 | | profile.CodecProfiles |
| | 404 | 2408 | | .Where(codecProfile => codecProfile.Type == CodecType.Video && |
| | 404 | 2409 | | codecProfile.ContainsAnyCodec(videoCodec, container) && |
| | 404 | 2410 | | !CheckVideoConditions(codecProfile.ApplyConditions, mediaSource, videoStream).Any()) |
| | 404 | 2411 | | .SelectMany(codecProfile => CheckVideoConditions(codecProfile.Conditions, mediaSource, videoStream)) |
| | | 2412 | | |
| | 404 | 2413 | | return failures; |
| | | 2414 | | } |
| | | 2415 | | |
| | | 2416 | | /// <summary> |
| | | 2417 | | /// Check the compatibility of the audio codec. |
| | | 2418 | | /// </summary> |
| | | 2419 | | /// <param name="options">Media options.</param> |
| | | 2420 | | /// <param name="mediaSource">Media source.</param> |
| | | 2421 | | /// <param name="container">Container.</param> |
| | | 2422 | | /// <param name="audioStream">Audio stream.</param> |
| | | 2423 | | /// <param name="transcodingAudioCodec">Override audio codec.</param> |
| | | 2424 | | /// <param name="isVideo">The media source is video.</param> |
| | | 2425 | | /// <param name="isSecondaryAudio">The audio stream is secondary.</param> |
| | | 2426 | | /// <returns>Transcode reasons if the audio stream is not fully compatible.</returns> |
| | | 2427 | | private TranscodeReason GetCompatibilityAudioCodec(MediaOptions options, MediaSourceInfo mediaSource, string con |
| | | 2428 | | { |
| | 1009 | 2429 | | var profile = options.Profile; |
| | | 2430 | | |
| | 1009 | 2431 | | var audioCodec = transcodingAudioCodec ?? audioStream.Codec; |
| | 1009 | 2432 | | var audioProfile = audioStream.Profile; |
| | 1009 | 2433 | | var audioChannels = audioStream.Channels; |
| | 1009 | 2434 | | var audioBitrate = audioStream.BitRate; |
| | 1009 | 2435 | | var audioSampleRate = audioStream.SampleRate; |
| | 1009 | 2436 | | var audioBitDepth = audioStream.BitDepth; |
| | | 2437 | | |
| | 1009 | 2438 | | var audioFailureConditions = isVideo |
| | 1009 | 2439 | | ? GetProfileConditionsForVideoAudio(profile.CodecProfiles, container, audioCodec, audioChannels, audioBi |
| | 1009 | 2440 | | : GetProfileConditionsForAudio(profile.CodecProfiles, container, audioCodec, audioChannels, audioBitrate |
| | | 2441 | | |
| | 1009 | 2442 | | var failures = AggregateFailureConditions(mediaSource, profile, "AudioCodecProfile", audioFailureConditions) |
| | | 2443 | | |
| | 1009 | 2444 | | return failures; |
| | | 2445 | | } |
| | | 2446 | | |
| | | 2447 | | /// <summary> |
| | | 2448 | | /// Check the compatibility of the audio codec for direct playback. |
| | | 2449 | | /// </summary> |
| | | 2450 | | /// <param name="options">Media options.</param> |
| | | 2451 | | /// <param name="mediaSource">Media source.</param> |
| | | 2452 | | /// <param name="container">Container.</param> |
| | | 2453 | | /// <param name="audioStream">Audio stream.</param> |
| | | 2454 | | /// <param name="isVideo">The media source is video.</param> |
| | | 2455 | | /// <param name="isSecondaryAudio">The audio stream is secondary.</param> |
| | | 2456 | | /// <returns>Transcode reasons if the audio stream is not fully compatible for direct playback.</returns> |
| | | 2457 | | private TranscodeReason GetCompatibilityAudioCodecDirect(MediaOptions options, MediaSourceInfo mediaSource, stri |
| | | 2458 | | { |
| | 275 | 2459 | | var failures = GetCompatibilityAudioCodec(options, mediaSource, container, audioStream, null, isVideo, isSec |
| | | 2460 | | |
| | 275 | 2461 | | if (audioStream.IsExternal) |
| | | 2462 | | { |
| | 6 | 2463 | | failures |= TranscodeReason.AudioIsExternal; |
| | | 2464 | | } |
| | | 2465 | | |
| | 275 | 2466 | | return failures; |
| | | 2467 | | } |
| | | 2468 | | } |
| | | 2469 | | } |