jellyfin/MediaBrowser.Model/Dlna/StreamBuilder.cs

778 lines
29 KiB
C#
Raw Normal View History

2014-04-02 21:55:19 +00:00
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Extensions;
2014-04-30 15:07:02 +00:00
using MediaBrowser.Model.MediaInfo;
using MediaBrowser.Model.Session;
2014-04-02 21:55:19 +00:00
using System;
using System.Collections.Generic;
2014-04-01 22:23:07 +00:00
namespace MediaBrowser.Model.Dlna
{
public class StreamBuilder
{
private readonly string[] _serverTextSubtitleOutputs = { "srt", "vtt", "ttml" };
2014-04-01 22:23:07 +00:00
public StreamInfo BuildAudioItem(AudioOptions options)
{
ValidateAudioInput(options);
2014-04-03 22:50:04 +00:00
2014-05-08 20:09:53 +00:00
List<MediaSourceInfo> mediaSources = options.MediaSources;
2014-04-01 22:23:07 +00:00
// If the client wants a specific media soure, filter now
if (!string.IsNullOrEmpty(options.MediaSourceId))
{
// Avoid implicitly captured closure
2014-05-08 20:09:53 +00:00
string mediaSourceId = options.MediaSourceId;
2014-04-01 22:23:07 +00:00
2014-05-08 21:23:24 +00:00
mediaSources = new List<MediaSourceInfo>();
foreach (MediaSourceInfo i in mediaSources)
{
if (StringHelper.EqualsIgnoreCase(i.Id, mediaSourceId))
2014-05-08 21:23:24 +00:00
mediaSources.Add(i);
}
2014-04-01 22:23:07 +00:00
}
2014-05-08 21:23:24 +00:00
List<StreamInfo> streams = new List<StreamInfo>();
foreach (MediaSourceInfo i in mediaSources)
streams.Add(BuildAudioItem(i, options));
2014-04-01 22:23:07 +00:00
2014-05-08 20:09:53 +00:00
foreach (StreamInfo stream in streams)
2014-04-01 22:23:07 +00:00
{
stream.DeviceId = options.DeviceId;
stream.DeviceProfileId = options.Profile.Id;
}
return GetOptimalStream(streams);
}
public StreamInfo BuildVideoItem(VideoOptions options)
{
ValidateInput(options);
2014-05-08 20:09:53 +00:00
List<MediaSourceInfo> mediaSources = options.MediaSources;
2014-04-01 22:23:07 +00:00
// If the client wants a specific media source, filter now
2014-04-01 22:23:07 +00:00
if (!string.IsNullOrEmpty(options.MediaSourceId))
{
2014-06-20 04:50:30 +00:00
var newMediaSources = new List<MediaSourceInfo>();
2014-05-08 21:23:24 +00:00
foreach (MediaSourceInfo i in mediaSources)
{
if (StringHelper.EqualsIgnoreCase(i.Id, options.MediaSourceId))
2014-06-20 04:50:30 +00:00
newMediaSources.Add(i);
2014-05-08 21:23:24 +00:00
}
2014-06-20 04:50:30 +00:00
mediaSources = newMediaSources;
2014-04-01 22:23:07 +00:00
}
2014-05-08 21:23:24 +00:00
List<StreamInfo> streams = new List<StreamInfo>();
foreach (MediaSourceInfo i in mediaSources)
streams.Add(BuildVideoItem(i, options));
2014-04-01 22:23:07 +00:00
2014-05-08 20:09:53 +00:00
foreach (StreamInfo stream in streams)
2014-04-01 22:23:07 +00:00
{
stream.DeviceId = options.DeviceId;
stream.DeviceProfileId = options.Profile.Id;
}
return GetOptimalStream(streams);
}
private StreamInfo GetOptimalStream(List<StreamInfo> streams)
{
// Grab the first one that can be direct streamed
// If that doesn't produce anything, just take the first
2014-05-08 21:23:24 +00:00
foreach (StreamInfo i in streams)
{
if (i.IsDirectStream)
{
return i;
}
}
foreach (StreamInfo stream in streams)
{
return stream;
}
return null;
2014-04-01 22:23:07 +00:00
}
2014-04-06 17:53:23 +00:00
private StreamInfo BuildAudioItem(MediaSourceInfo item, AudioOptions options)
2014-04-01 22:23:07 +00:00
{
2014-05-08 20:09:53 +00:00
StreamInfo playlistItem = new StreamInfo
2014-04-01 22:23:07 +00:00
{
2014-04-06 17:53:23 +00:00
ItemId = options.ItemId,
2014-04-01 22:23:07 +00:00
MediaType = DlnaProfileType.Audio,
2014-04-18 17:16:25 +00:00
MediaSource = item,
2014-04-18 05:03:01 +00:00
RunTimeTicks = item.RunTimeTicks
2014-04-01 22:23:07 +00:00
};
2014-07-27 22:01:29 +00:00
int? maxBitrateSetting = options.GetMaxBitrate();
2014-05-09 23:08:08 +00:00
MediaStream audioStream = item.DefaultAudioStream;
2014-04-01 22:23:07 +00:00
2014-04-06 17:53:23 +00:00
// Honor the max bitrate setting
if (IsAudioEligibleForDirectPlay(item, maxBitrateSetting))
2014-04-01 22:23:07 +00:00
{
2014-05-09 19:43:06 +00:00
DirectPlayProfile directPlay = null;
foreach (DirectPlayProfile i in options.Profile.DirectPlayProfiles)
{
if (i.Type == playlistItem.MediaType && IsAudioDirectPlaySupported(i, item, audioStream))
{
directPlay = i;
break;
}
}
2014-04-01 22:23:07 +00:00
2014-04-06 17:53:23 +00:00
if (directPlay != null)
2014-04-01 22:23:07 +00:00
{
2014-05-08 20:09:53 +00:00
string audioCodec = audioStream == null ? null : audioStream.Codec;
2014-04-06 17:53:23 +00:00
// Make sure audio codec profiles are satisfied
2014-04-24 05:08:10 +00:00
if (!string.IsNullOrEmpty(audioCodec))
2014-04-06 17:53:23 +00:00
{
2014-05-08 20:09:53 +00:00
ConditionProcessor conditionProcessor = new ConditionProcessor();
2014-04-01 22:23:07 +00:00
2014-05-09 19:43:06 +00:00
List<ProfileCondition> conditions = new List<ProfileCondition>();
foreach (CodecProfile i in options.Profile.CodecProfiles)
{
if (i.Type == CodecType.Audio && i.ContainsCodec(audioCodec))
2014-07-01 04:06:28 +00:00
{
foreach (var c in i.Conditions)
{
conditions.Add(c);
}
}
2014-05-09 19:43:06 +00:00
}
2014-04-24 05:08:10 +00:00
2014-05-08 20:09:53 +00:00
int? audioChannels = audioStream.Channels;
int? audioBitrate = audioStream.BitRate;
2014-04-24 05:08:10 +00:00
2014-05-09 19:43:06 +00:00
bool all = true;
foreach (ProfileCondition c in conditions)
{
if (!conditionProcessor.IsAudioConditionSatisfied(c, audioChannels, audioBitrate))
{
all = false;
break;
}
}
if (all)
2014-04-24 05:08:10 +00:00
{
playlistItem.PlayMethod = PlayMethod.DirectStream;
2014-04-24 05:08:10 +00:00
playlistItem.Container = item.Container;
return playlistItem;
}
2014-04-06 17:53:23 +00:00
}
2014-04-01 22:23:07 +00:00
}
}
2014-05-09 19:43:06 +00:00
TranscodingProfile transcodingProfile = null;
foreach (TranscodingProfile i in options.Profile.TranscodingProfiles)
{
2014-07-17 03:17:14 +00:00
if (i.Type == playlistItem.MediaType && i.Context == options.Context)
2014-05-09 19:43:06 +00:00
{
transcodingProfile = i;
break;
}
}
2014-04-01 22:23:07 +00:00
if (transcodingProfile != null)
{
playlistItem.PlayMethod = PlayMethod.Transcode;
2014-04-18 05:03:01 +00:00
playlistItem.TranscodeSeekInfo = transcodingProfile.TranscodeSeekInfo;
2014-04-18 17:16:25 +00:00
playlistItem.EstimateContentLength = transcodingProfile.EstimateContentLength;
2014-04-01 22:23:07 +00:00
playlistItem.Container = transcodingProfile.Container;
playlistItem.AudioCodec = transcodingProfile.AudioCodec;
playlistItem.Protocol = transcodingProfile.Protocol;
2014-04-01 22:23:07 +00:00
2014-05-09 23:08:08 +00:00
List<CodecProfile> audioCodecProfiles = new List<CodecProfile>();
foreach (CodecProfile i in options.Profile.CodecProfiles)
{
if (i.Type == CodecType.Audio && i.ContainsCodec(transcodingProfile.AudioCodec))
{
audioCodecProfiles.Add(i);
}
if (audioCodecProfiles.Count >= 1) break;
}
List<ProfileCondition> audioTranscodingConditions = new List<ProfileCondition>();
foreach (CodecProfile i in audioCodecProfiles)
2014-07-01 04:06:28 +00:00
{
foreach (var c in i.Conditions)
{
audioTranscodingConditions.Add(c);
}
}
2014-04-01 22:23:07 +00:00
ApplyTranscodingConditions(playlistItem, audioTranscodingConditions);
2014-04-06 17:53:23 +00:00
// Honor requested max channels
if (options.MaxAudioChannels.HasValue)
{
2014-05-08 20:09:53 +00:00
int currentValue = playlistItem.MaxAudioChannels ?? options.MaxAudioChannels.Value;
2014-04-06 17:53:23 +00:00
playlistItem.MaxAudioChannels = Math.Min(options.MaxAudioChannels.Value, currentValue);
}
if (!playlistItem.AudioBitrate.HasValue)
2014-04-06 17:53:23 +00:00
{
playlistItem.AudioBitrate = 128000;
2014-04-06 17:53:23 +00:00
}
2014-04-01 22:23:07 +00:00
}
return playlistItem;
}
private StreamInfo BuildVideoItem(MediaSourceInfo item, VideoOptions options)
{
2014-05-08 20:09:53 +00:00
StreamInfo playlistItem = new StreamInfo
2014-04-01 22:23:07 +00:00
{
ItemId = options.ItemId,
MediaType = DlnaProfileType.Video,
2014-04-18 17:16:25 +00:00
MediaSource = item,
2014-04-18 05:03:01 +00:00
RunTimeTicks = item.RunTimeTicks
2014-04-01 22:23:07 +00:00
};
int? audioStreamIndex = options.AudioStreamIndex ?? item.DefaultAudioStreamIndex;
playlistItem.SubtitleStreamIndex = options.SubtitleStreamIndex ?? item.DefaultSubtitleStreamIndex;
MediaStream audioStream = audioStreamIndex.HasValue ? item.GetMediaStream(MediaStreamType.Audio, audioStreamIndex.Value) : null;
MediaStream subtitleStream = playlistItem.SubtitleStreamIndex.HasValue ? item.GetMediaStream(MediaStreamType.Subtitle, playlistItem.SubtitleStreamIndex.Value) : null;
2014-05-09 23:08:08 +00:00
MediaStream videoStream = item.VideoStream;
2014-04-01 22:23:07 +00:00
2014-07-27 22:01:29 +00:00
int? maxBitrateSetting = options.GetMaxBitrate();
if (IsEligibleForDirectPlay(item, maxBitrateSetting, subtitleStream, options))
2014-04-01 22:23:07 +00:00
{
// See if it can be direct played
2014-05-08 20:09:53 +00:00
DirectPlayProfile directPlay = GetVideoDirectPlayProfile(options.Profile, item, videoStream, audioStream);
2014-04-01 22:23:07 +00:00
if (directPlay != null)
{
playlistItem.PlayMethod = PlayMethod.DirectStream;
2014-04-24 05:08:10 +00:00
playlistItem.Container = item.Container;
2014-04-01 22:23:07 +00:00
if (subtitleStream != null)
{
playlistItem.SubtitleDeliveryMethod = GetSubtitleDeliveryMethod(subtitleStream, options);
}
2014-04-24 05:08:10 +00:00
return playlistItem;
2014-04-01 22:23:07 +00:00
}
}
// Can't direct play, find the transcoding profile
2014-05-08 21:23:24 +00:00
TranscodingProfile transcodingProfile = null;
foreach (TranscodingProfile i in options.Profile.TranscodingProfiles)
{
2014-07-17 03:17:14 +00:00
if (i.Type == playlistItem.MediaType && i.Context == options.Context)
2014-05-08 21:23:24 +00:00
{
transcodingProfile = i;
break;
}
}
2014-04-01 22:23:07 +00:00
if (transcodingProfile != null)
{
if (subtitleStream != null)
{
playlistItem.SubtitleDeliveryMethod = GetSubtitleDeliveryMethod(subtitleStream, options);
}
playlistItem.PlayMethod = PlayMethod.Transcode;
2014-04-01 22:23:07 +00:00
playlistItem.Container = transcodingProfile.Container;
2014-04-18 17:16:25 +00:00
playlistItem.EstimateContentLength = transcodingProfile.EstimateContentLength;
2014-04-18 05:03:01 +00:00
playlistItem.TranscodeSeekInfo = transcodingProfile.TranscodeSeekInfo;
2014-05-08 21:23:24 +00:00
playlistItem.AudioCodec = transcodingProfile.AudioCodec.Split(',')[0];
2014-04-01 22:23:07 +00:00
playlistItem.VideoCodec = transcodingProfile.VideoCodec;
playlistItem.Protocol = transcodingProfile.Protocol;
playlistItem.AudioStreamIndex = audioStreamIndex;
2014-04-01 22:23:07 +00:00
2014-05-09 23:08:08 +00:00
List<ProfileCondition> videoTranscodingConditions = new List<ProfileCondition>();
foreach (CodecProfile i in options.Profile.CodecProfiles)
{
if (i.Type == CodecType.Video && i.ContainsCodec(transcodingProfile.VideoCodec))
{
2014-07-01 04:06:28 +00:00
foreach (var c in i.Conditions)
{
videoTranscodingConditions.Add(c);
}
2014-05-09 23:08:08 +00:00
break;
}
}
2014-04-01 22:23:07 +00:00
ApplyTranscodingConditions(playlistItem, videoTranscodingConditions);
2014-05-09 23:08:08 +00:00
List<ProfileCondition> audioTranscodingConditions = new List<ProfileCondition>();
foreach (CodecProfile i in options.Profile.CodecProfiles)
{
if (i.Type == CodecType.VideoAudio && i.ContainsCodec(transcodingProfile.AudioCodec))
{
2014-07-01 04:06:28 +00:00
foreach (var c in i.Conditions)
{
audioTranscodingConditions.Add(c);
}
2014-05-09 23:08:08 +00:00
break;
}
}
2014-04-01 22:23:07 +00:00
ApplyTranscodingConditions(playlistItem, audioTranscodingConditions);
2014-04-06 17:53:23 +00:00
// Honor requested max channels
if (options.MaxAudioChannels.HasValue)
{
2014-05-08 20:09:53 +00:00
int currentValue = playlistItem.MaxAudioChannels ?? options.MaxAudioChannels.Value;
2014-04-06 17:53:23 +00:00
playlistItem.MaxAudioChannels = Math.Min(options.MaxAudioChannels.Value, currentValue);
}
if (!playlistItem.AudioBitrate.HasValue)
2014-04-06 17:53:23 +00:00
{
playlistItem.AudioBitrate = GetAudioBitrate(playlistItem.TargetAudioChannels, playlistItem.TargetAudioCodec);
2014-04-06 17:53:23 +00:00
}
// Honor max rate
if (maxBitrateSetting.HasValue)
2014-04-06 17:53:23 +00:00
{
2014-05-08 20:09:53 +00:00
int videoBitrate = maxBitrateSetting.Value;
2014-04-06 17:53:23 +00:00
if (playlistItem.AudioBitrate.HasValue)
{
videoBitrate -= playlistItem.AudioBitrate.Value;
}
2014-05-08 20:09:53 +00:00
int currentValue = playlistItem.VideoBitrate ?? videoBitrate;
2014-04-06 17:53:23 +00:00
playlistItem.VideoBitrate = Math.Min(videoBitrate, currentValue);
}
}
2014-06-23 16:05:19 +00:00
return playlistItem;
}
private int GetAudioBitrate(int? channels, string codec)
{
if (channels.HasValue)
{
if (channels.Value >= 5)
2014-06-23 16:05:19 +00:00
{
return 320000;
2014-06-23 16:05:19 +00:00
}
2014-04-01 22:23:07 +00:00
}
return 128000;
2014-04-01 22:23:07 +00:00
}
2014-04-24 05:08:10 +00:00
private DirectPlayProfile GetVideoDirectPlayProfile(DeviceProfile profile,
MediaSourceInfo mediaSource,
MediaStream videoStream,
MediaStream audioStream)
{
// See if it can be direct played
2014-05-08 21:23:24 +00:00
DirectPlayProfile directPlay = null;
foreach (DirectPlayProfile i in profile.DirectPlayProfiles)
{
if (i.Type == DlnaProfileType.Video && IsVideoDirectPlaySupported(i, mediaSource, videoStream, audioStream))
{
directPlay = i;
break;
}
}
2014-04-24 05:08:10 +00:00
if (directPlay == null)
{
return null;
}
2014-05-08 20:09:53 +00:00
string container = mediaSource.Container;
2014-04-24 05:08:10 +00:00
2014-05-09 19:43:06 +00:00
List<ProfileCondition> conditions = new List<ProfileCondition>();
foreach (ContainerProfile i in profile.ContainerProfiles)
{
if (i.Type == DlnaProfileType.Video &&
2014-06-05 02:32:40 +00:00
ListHelper.ContainsIgnoreCase(i.GetContainers(), container))
2014-05-09 19:43:06 +00:00
{
2014-07-01 04:06:28 +00:00
foreach (var c in i.Conditions)
{
conditions.Add(c);
}
2014-05-09 19:43:06 +00:00
}
}
2014-04-24 05:08:10 +00:00
2014-05-08 20:09:53 +00:00
ConditionProcessor conditionProcessor = new ConditionProcessor();
2014-04-24 05:08:10 +00:00
2014-05-08 20:09:53 +00:00
int? width = videoStream == null ? null : videoStream.Width;
int? height = videoStream == null ? null : videoStream.Height;
int? bitDepth = videoStream == null ? null : videoStream.BitDepth;
int? videoBitrate = videoStream == null ? null : videoStream.BitRate;
double? videoLevel = videoStream == null ? null : videoStream.Level;
string videoProfile = videoStream == null ? null : videoStream.Profile;
float? videoFramerate = videoStream == null ? null : videoStream.AverageFrameRate ?? videoStream.AverageFrameRate;
2014-06-22 16:25:47 +00:00
bool? isAnamorphic = videoStream == null ? null : videoStream.IsAnamorphic;
2014-04-24 05:08:10 +00:00
2014-05-08 20:09:53 +00:00
int? audioBitrate = audioStream == null ? null : audioStream.BitRate;
int? audioChannels = audioStream == null ? null : audioStream.Channels;
string audioProfile = audioStream == null ? null : audioStream.Profile;
2014-04-24 05:08:10 +00:00
2014-05-08 20:09:53 +00:00
TransportStreamTimestamp? timestamp = videoStream == null ? TransportStreamTimestamp.None : mediaSource.Timestamp;
int? packetLength = videoStream == null ? null : videoStream.PacketLength;
2014-04-24 05:08:10 +00:00
// Check container conditions
2014-05-09 19:43:06 +00:00
foreach (ProfileCondition i in conditions)
2014-04-24 05:08:10 +00:00
{
2014-06-22 16:25:47 +00:00
if (!conditionProcessor.IsVideoConditionSatisfied(i, audioBitrate, audioChannels, width, height, bitDepth, videoBitrate, videoProfile, videoLevel, videoFramerate, packetLength, timestamp, isAnamorphic))
2014-05-09 19:43:06 +00:00
{
return null;
}
2014-04-24 05:08:10 +00:00
}
2014-05-08 20:09:53 +00:00
string videoCodec = videoStream == null ? null : videoStream.Codec;
2014-04-24 05:08:10 +00:00
if (string.IsNullOrEmpty(videoCodec))
{
return null;
}
2014-05-09 19:43:06 +00:00
conditions = new List<ProfileCondition>();
foreach (CodecProfile i in profile.CodecProfiles)
{
if (i.Type == CodecType.Video && i.ContainsCodec(videoCodec))
2014-07-01 04:06:28 +00:00
{
foreach (var c in i.Conditions)
{
conditions.Add(c);
}
}
2014-05-09 19:43:06 +00:00
}
2014-04-24 05:08:10 +00:00
2014-05-09 19:43:06 +00:00
foreach (ProfileCondition i in conditions)
2014-04-24 05:08:10 +00:00
{
2014-06-22 16:25:47 +00:00
if (!conditionProcessor.IsVideoConditionSatisfied(i, audioBitrate, audioChannels, width, height, bitDepth, videoBitrate, videoProfile, videoLevel, videoFramerate, packetLength, timestamp, isAnamorphic))
2014-05-09 19:43:06 +00:00
{
return null;
}
2014-04-24 05:08:10 +00:00
}
if (audioStream != null)
{
2014-05-08 20:09:53 +00:00
string audioCodec = audioStream.Codec;
2014-04-24 05:08:10 +00:00
if (string.IsNullOrEmpty(audioCodec))
{
return null;
}
2014-05-09 19:43:06 +00:00
conditions = new List<ProfileCondition>();
foreach (CodecProfile i in profile.CodecProfiles)
{
if (i.Type == CodecType.VideoAudio && i.ContainsCodec(audioCodec))
2014-07-01 04:06:28 +00:00
{
foreach (var c in i.Conditions)
{
conditions.Add(c);
}
}
2014-05-09 19:43:06 +00:00
}
2014-04-24 05:08:10 +00:00
2014-05-09 19:43:06 +00:00
foreach (ProfileCondition i in conditions)
2014-04-24 05:08:10 +00:00
{
2014-05-09 19:43:06 +00:00
if (!conditionProcessor.IsVideoAudioConditionSatisfied(i, audioChannels, audioBitrate, audioProfile))
{
return null;
}
2014-04-24 05:08:10 +00:00
}
}
return directPlay;
}
private bool IsEligibleForDirectPlay(MediaSourceInfo item,
int? maxBitrate,
MediaStream subtitleStream,
VideoOptions options)
2014-04-01 22:23:07 +00:00
{
if (subtitleStream != null)
2014-04-01 22:23:07 +00:00
{
if (!subtitleStream.IsTextSubtitleStream)
{
return false;
}
SubtitleDeliveryMethod subtitleMethod = GetSubtitleDeliveryMethod(subtitleStream, options);
if (subtitleMethod != SubtitleDeliveryMethod.External && subtitleMethod != SubtitleDeliveryMethod.Embed)
{
return false;
}
2014-04-01 22:23:07 +00:00
}
return IsAudioEligibleForDirectPlay(item, maxBitrate);
2014-04-06 17:53:23 +00:00
}
private SubtitleDeliveryMethod GetSubtitleDeliveryMethod(MediaStream subtitleStream,
VideoOptions options)
{
if (subtitleStream.IsTextSubtitleStream)
{
// See if the device can retrieve the subtitles externally
bool supportsSubsExternally = options.Context == EncodingContext.Streaming &&
ContainsSubtitleFormat(options.Profile.ExternalSubtitleProfiles, _serverTextSubtitleOutputs);
if (supportsSubsExternally)
{
return SubtitleDeliveryMethod.External;
}
// See if the device can retrieve the subtitles externally
bool supportsEmbedded = ContainsSubtitleFormat(options.Profile.SoftSubtitleProfiles, _serverTextSubtitleOutputs);
if (supportsEmbedded)
{
return SubtitleDeliveryMethod.Embed;
}
}
return SubtitleDeliveryMethod.Encode;
}
private string NormalizeSubtitleFormat(string codec)
{
if (StringHelper.EqualsIgnoreCase(codec, "subrip"))
{
return SubtitleFormat.SRT;
}
return codec;
}
private bool ContainsSubtitleFormat(SubtitleProfile[] profiles, string[] formats)
{
foreach (SubtitleProfile profile in profiles)
{
if (ListHelper.ContainsIgnoreCase(formats, profile.Format))
{
return true;
}
}
return false;
}
private bool IsAudioEligibleForDirectPlay(MediaSourceInfo item, int? maxBitrate)
2014-04-06 17:53:23 +00:00
{
// Honor the max bitrate setting
return !maxBitrate.HasValue || (item.Bitrate.HasValue && item.Bitrate.Value <= maxBitrate.Value);
2014-04-01 22:23:07 +00:00
}
private void ValidateInput(VideoOptions options)
{
ValidateAudioInput(options);
if (options.AudioStreamIndex.HasValue && string.IsNullOrEmpty(options.MediaSourceId))
{
throw new ArgumentException("MediaSourceId is required when a specific audio stream is requested");
}
if (options.SubtitleStreamIndex.HasValue && string.IsNullOrEmpty(options.MediaSourceId))
{
throw new ArgumentException("MediaSourceId is required when a specific subtitle stream is requested");
}
}
private void ValidateAudioInput(AudioOptions options)
{
if (string.IsNullOrEmpty(options.ItemId))
{
throw new ArgumentException("ItemId is required");
}
if (string.IsNullOrEmpty(options.DeviceId))
{
throw new ArgumentException("DeviceId is required");
}
if (options.Profile == null)
{
throw new ArgumentException("Profile is required");
}
if (options.MediaSources == null)
{
throw new ArgumentException("MediaSources is required");
}
}
private void ApplyTranscodingConditions(StreamInfo item, IEnumerable<ProfileCondition> conditions)
{
2014-05-09 19:43:06 +00:00
foreach (ProfileCondition condition in conditions)
2014-04-01 22:23:07 +00:00
{
2014-05-08 20:09:53 +00:00
string value = condition.Value;
2014-04-01 22:23:07 +00:00
2014-05-09 19:43:06 +00:00
if (string.IsNullOrEmpty(value))
{
continue;
}
2014-04-01 22:23:07 +00:00
switch (condition.Property)
{
case ProfileConditionValue.AudioBitrate:
{
int num;
if (IntHelper.TryParseCultureInvariant(value, out num))
2014-04-01 22:23:07 +00:00
{
item.AudioBitrate = num;
}
break;
}
case ProfileConditionValue.AudioChannels:
{
int num;
if (IntHelper.TryParseCultureInvariant(value, out num))
2014-04-01 22:23:07 +00:00
{
item.MaxAudioChannels = num;
}
break;
}
case ProfileConditionValue.AudioProfile:
2014-06-22 16:25:47 +00:00
case ProfileConditionValue.IsAnamorphic:
2014-04-01 22:23:07 +00:00
case ProfileConditionValue.Has64BitOffsets:
2014-04-24 05:08:10 +00:00
case ProfileConditionValue.PacketLength:
case ProfileConditionValue.VideoTimestamp:
2014-04-01 22:23:07 +00:00
case ProfileConditionValue.VideoBitDepth:
{
// Not supported yet
break;
}
2014-04-24 05:08:10 +00:00
case ProfileConditionValue.VideoProfile:
{
item.VideoProfile = value;
break;
}
2014-04-01 22:23:07 +00:00
case ProfileConditionValue.Height:
{
int num;
if (IntHelper.TryParseCultureInvariant(value, out num))
2014-04-01 22:23:07 +00:00
{
item.MaxHeight = num;
}
break;
}
case ProfileConditionValue.VideoBitrate:
{
int num;
if (IntHelper.TryParseCultureInvariant(value, out num))
2014-04-01 22:23:07 +00:00
{
item.VideoBitrate = num;
}
break;
}
case ProfileConditionValue.VideoFramerate:
{
2014-06-23 16:05:19 +00:00
float num;
if (FloatHelper.TryParseCultureInvariant(value, out num))
2014-04-01 22:23:07 +00:00
{
item.MaxFramerate = num;
}
break;
}
case ProfileConditionValue.VideoLevel:
{
int num;
if (IntHelper.TryParseCultureInvariant(value, out num))
2014-04-01 22:23:07 +00:00
{
item.VideoLevel = num;
}
break;
}
case ProfileConditionValue.Width:
{
int num;
if (IntHelper.TryParseCultureInvariant(value, out num))
2014-04-01 22:23:07 +00:00
{
item.MaxWidth = num;
}
break;
}
default:
throw new ArgumentException("Unrecognized ProfileConditionValue");
}
}
}
2014-04-06 17:53:23 +00:00
private bool IsAudioDirectPlaySupported(DirectPlayProfile profile, MediaSourceInfo item, MediaStream audioStream)
2014-04-01 22:23:07 +00:00
{
if (profile.Container.Length > 0)
{
// Check container type
2014-05-08 20:09:53 +00:00
string mediaContainer = item.Container ?? string.Empty;
2014-05-09 19:43:06 +00:00
bool any = false;
foreach (string i in profile.GetContainers())
{
if (StringHelper.EqualsIgnoreCase(i, mediaContainer))
2014-05-09 19:43:06 +00:00
{
any = true;
break;
}
}
if (!any)
2014-04-01 22:23:07 +00:00
{
return false;
}
}
return true;
}
2014-04-06 17:53:23 +00:00
private bool IsVideoDirectPlaySupported(DirectPlayProfile profile, MediaSourceInfo item, MediaStream videoStream, MediaStream audioStream)
2014-04-01 22:23:07 +00:00
{
// Only plain video files can be direct played
if (item.VideoType != VideoType.VideoFile)
{
return false;
}
if (profile.Container.Length > 0)
{
// Check container type
2014-05-08 20:09:53 +00:00
string mediaContainer = item.Container ?? string.Empty;
2014-05-09 19:43:06 +00:00
bool any = false;
foreach (string i in profile.GetContainers())
{
if (StringHelper.EqualsIgnoreCase(i, mediaContainer))
2014-05-09 19:43:06 +00:00
{
any = true;
break;
}
}
if (!any)
2014-04-01 22:23:07 +00:00
{
return false;
}
}
// Check video codec
2014-05-08 20:09:53 +00:00
List<string> videoCodecs = profile.GetVideoCodecs();
2014-04-01 22:23:07 +00:00
if (videoCodecs.Count > 0)
{
2014-05-08 20:09:53 +00:00
string videoCodec = videoStream == null ? null : videoStream.Codec;
2014-06-05 02:32:40 +00:00
if (string.IsNullOrEmpty(videoCodec) || !ListHelper.ContainsIgnoreCase(videoCodecs, videoCodec))
2014-04-01 22:23:07 +00:00
{
return false;
}
}
2014-05-08 20:09:53 +00:00
List<string> audioCodecs = profile.GetAudioCodecs();
2014-04-01 22:23:07 +00:00
if (audioCodecs.Count > 0)
{
// Check audio codecs
2014-05-08 20:09:53 +00:00
string audioCodec = audioStream == null ? null : audioStream.Codec;
2014-06-05 02:32:40 +00:00
if (string.IsNullOrEmpty(audioCodec) || !ListHelper.ContainsIgnoreCase(audioCodecs, audioCodec))
2014-04-01 22:23:07 +00:00
{
return false;
}
}
return true;
}
}
}