jellyfin/MediaBrowser.Model/Dlna/StreamInfo.cs

519 lines
16 KiB
C#
Raw Normal View History

2014-04-23 02:47:46 +00:00
using MediaBrowser.Model.Drawing;
using MediaBrowser.Model.Dto;
2014-04-18 17:16:25 +00:00
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Extensions;
2014-05-08 21:23:24 +00:00
using MediaBrowser.Model.MediaInfo;
using MediaBrowser.Model.Session;
2014-04-06 17:53:23 +00:00
using System;
2014-04-01 22:23:07 +00:00
using System.Collections.Generic;
namespace MediaBrowser.Model.Dlna
{
/// <summary>
/// Class StreamInfo.
/// </summary>
public class StreamInfo
{
public string ItemId { get; set; }
public PlayMethod PlayMethod { get; set; }
2014-04-01 22:23:07 +00:00
public DlnaProfileType MediaType { get; set; }
public string Container { get; set; }
public string Protocol { get; set; }
2014-04-01 22:23:07 +00:00
public long StartPositionTicks { get; set; }
public string VideoCodec { get; set; }
2014-04-24 05:08:10 +00:00
public string VideoProfile { get; set; }
2014-04-01 22:23:07 +00:00
public string AudioCodec { get; set; }
public int? AudioStreamIndex { get; set; }
public int? SubtitleStreamIndex { get; set; }
public int? MaxAudioChannels { get; set; }
public int? AudioBitrate { get; set; }
public int? VideoBitrate { get; set; }
public int? VideoLevel { get; set; }
public int? MaxWidth { get; set; }
public int? MaxHeight { get; set; }
2014-06-23 16:05:19 +00:00
public float? MaxFramerate { get; set; }
2014-04-01 22:23:07 +00:00
public string DeviceProfileId { get; set; }
public string DeviceId { get; set; }
2014-04-18 05:03:01 +00:00
public long? RunTimeTicks { get; set; }
public TranscodeSeekInfo TranscodeSeekInfo { get; set; }
2014-04-18 17:16:25 +00:00
public bool EstimateContentLength { get; set; }
public MediaSourceInfo MediaSource { get; set; }
public SubtitleDeliveryMethod SubtitleDeliveryMethod { get; set; }
public string SubtitleFormat { get; set; }
2014-04-18 17:16:25 +00:00
public string MediaSourceId
{
get
{
return MediaSource == null ? null : MediaSource.Id;
}
}
public bool IsDirectStream
{
get { return PlayMethod == PlayMethod.DirectStream; }
}
2014-04-01 22:23:07 +00:00
public string ToUrl(string baseUrl)
{
return ToDlnaUrl(baseUrl);
}
public string ToDlnaUrl(string baseUrl)
{
if (string.IsNullOrEmpty(baseUrl))
{
throw new ArgumentNullException(baseUrl);
}
2014-05-08 20:09:53 +00:00
string dlnaCommand = BuildDlnaParam(this);
2014-04-01 22:23:07 +00:00
2014-05-08 20:09:53 +00:00
string extension = string.IsNullOrEmpty(Container) ? string.Empty : "." + Container;
2014-04-01 22:23:07 +00:00
baseUrl = baseUrl.TrimEnd('/');
if (MediaType == DlnaProfileType.Audio)
{
return string.Format("{0}/audio/{1}/stream{2}?{3}", baseUrl, ItemId, extension, dlnaCommand);
}
if (StringHelper.EqualsIgnoreCase(Protocol, "hls"))
{
return string.Format("{0}/videos/{1}/master.m3u8?{2}", baseUrl, ItemId, dlnaCommand);
}
2014-04-01 22:23:07 +00:00
return string.Format("{0}/videos/{1}/stream{2}?{3}", baseUrl, ItemId, extension, dlnaCommand);
}
private static string BuildDlnaParam(StreamInfo item)
{
2014-05-08 20:09:53 +00:00
List<string> list = new List<string>
2014-04-01 22:23:07 +00:00
{
item.DeviceProfileId ?? string.Empty,
item.DeviceId ?? string.Empty,
item.MediaSourceId ?? string.Empty,
(item.IsDirectStream).ToString().ToLower(),
item.VideoCodec ?? string.Empty,
item.AudioCodec ?? string.Empty,
item.AudioStreamIndex.HasValue ? StringHelper.ToStringCultureInvariant(item.AudioStreamIndex.Value) : string.Empty,
item.SubtitleStreamIndex.HasValue && item.SubtitleDeliveryMethod != SubtitleDeliveryMethod.External ? StringHelper.ToStringCultureInvariant(item.SubtitleStreamIndex.Value) : string.Empty,
item.VideoBitrate.HasValue ? StringHelper.ToStringCultureInvariant(item.VideoBitrate.Value) : string.Empty,
item.AudioBitrate.HasValue ? StringHelper.ToStringCultureInvariant(item.AudioBitrate.Value) : string.Empty,
item.MaxAudioChannels.HasValue ? StringHelper.ToStringCultureInvariant(item.MaxAudioChannels.Value) : string.Empty,
item.MaxFramerate.HasValue ? StringHelper.ToStringCultureInvariant(item.MaxFramerate.Value) : string.Empty,
item.MaxWidth.HasValue ? StringHelper.ToStringCultureInvariant(item.MaxWidth.Value) : string.Empty,
item.MaxHeight.HasValue ? StringHelper.ToStringCultureInvariant(item.MaxHeight.Value) : string.Empty,
StringHelper.ToStringCultureInvariant(item.StartPositionTicks),
item.VideoLevel.HasValue ? StringHelper.ToStringCultureInvariant(item.VideoLevel.Value) : string.Empty
2014-04-01 22:23:07 +00:00
};
return string.Format("Params={0}", string.Join(";", list.ToArray()));
}
2014-08-06 02:26:12 +00:00
public List<SubtitleStreamInfo> GetExternalSubtitles(string baseUrl)
{
2014-08-06 04:18:13 +00:00
if (string.IsNullOrEmpty(baseUrl))
{
throw new ArgumentNullException(baseUrl);
}
List<SubtitleStreamInfo> list = new List<SubtitleStreamInfo>();
if (SubtitleDeliveryMethod != SubtitleDeliveryMethod.External)
{
2014-08-06 04:18:13 +00:00
return list;
}
if (!SubtitleStreamIndex.HasValue)
{
2014-08-06 04:18:13 +00:00
return list;
}
// HLS will preserve timestamps so we can just grab the full subtitle stream
long startPositionTicks = StringHelper.EqualsIgnoreCase(Protocol, "hls")
? 0
: StartPositionTicks;
2014-08-06 02:26:12 +00:00
string url = string.Format("{0}/Videos/{1}/{2}/Subtitles/{3}/{4}/Stream.{5}",
baseUrl,
ItemId,
MediaSourceId,
StringHelper.ToStringCultureInvariant(SubtitleStreamIndex.Value),
StringHelper.ToStringCultureInvariant(startPositionTicks),
SubtitleFormat);
2014-08-06 02:26:12 +00:00
foreach (MediaStream stream in MediaSource.MediaStreams)
{
if (stream.Type == MediaStreamType.Subtitle && stream.Index == SubtitleStreamIndex.Value)
{
list.Add(new SubtitleStreamInfo
{
Url = url,
IsForced = stream.IsForced,
Language = stream.Language,
2014-08-07 02:51:09 +00:00
Name = stream.Language ?? "Unknown",
Format = SubtitleFormat
2014-08-06 02:26:12 +00:00
});
}
}
return list;
}
2014-04-18 17:16:25 +00:00
/// <summary>
/// Returns the audio stream that will be used
/// </summary>
public MediaStream TargetAudioStream
{
get
{
if (MediaSource != null)
{
if (AudioStreamIndex.HasValue)
{
2014-05-08 21:23:24 +00:00
foreach (MediaStream i in MediaSource.MediaStreams)
{
2014-08-06 02:26:12 +00:00
if (i.Index == AudioStreamIndex.Value && i.Type == MediaStreamType.Audio)
2014-05-08 21:23:24 +00:00
return i;
}
return null;
}
2014-05-09 23:08:08 +00:00
return MediaSource.DefaultAudioStream;
2014-04-18 17:16:25 +00:00
}
return null;
}
}
/// <summary>
/// Returns the video stream that will be used
/// </summary>
public MediaStream TargetVideoStream
{
get
{
if (MediaSource != null)
{
2014-05-09 23:08:08 +00:00
return MediaSource.VideoStream;
2014-04-18 17:16:25 +00:00
}
return null;
}
}
/// <summary>
/// Predicts the audio sample rate that will be in the output stream
/// </summary>
public int? TargetAudioSampleRate
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetAudioStream;
2014-04-18 17:16:25 +00:00
return stream == null ? null : stream.SampleRate;
}
}
2014-04-24 05:08:10 +00:00
/// <summary>
/// Predicts the audio sample rate that will be in the output stream
/// </summary>
public int? TargetVideoBitDepth
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetVideoStream;
2014-04-24 05:08:10 +00:00
return stream == null || !IsDirectStream ? null : stream.BitDepth;
}
}
/// <summary>
/// Predicts the audio sample rate that will be in the output stream
/// </summary>
2014-06-23 16:05:19 +00:00
public float? TargetFramerate
2014-04-24 05:08:10 +00:00
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetVideoStream;
2014-04-24 05:08:10 +00:00
return MaxFramerate.HasValue && !IsDirectStream
? MaxFramerate
: stream == null ? null : stream.AverageFrameRate ?? stream.RealFrameRate;
}
}
/// <summary>
/// Predicts the audio sample rate that will be in the output stream
/// </summary>
public double? TargetVideoLevel
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetVideoStream;
2014-04-24 05:08:10 +00:00
return VideoLevel.HasValue && !IsDirectStream
? VideoLevel
: stream == null ? null : stream.Level;
}
}
/// <summary>
/// Predicts the audio sample rate that will be in the output stream
/// </summary>
public int? TargetPacketLength
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetVideoStream;
2014-04-24 05:08:10 +00:00
return !IsDirectStream
? null
: stream == null ? null : stream.PacketLength;
}
}
/// <summary>
/// Predicts the audio sample rate that will be in the output stream
/// </summary>
public string TargetVideoProfile
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetVideoStream;
2014-04-24 05:08:10 +00:00
return !string.IsNullOrEmpty(VideoProfile) && !IsDirectStream
? VideoProfile
: stream == null ? null : stream.Profile;
}
}
2014-04-18 17:16:25 +00:00
/// <summary>
/// Predicts the audio bitrate that will be in the output stream
/// </summary>
public int? TargetAudioBitrate
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetAudioStream;
2014-04-18 17:16:25 +00:00
return AudioBitrate.HasValue && !IsDirectStream
? AudioBitrate
: stream == null ? null : stream.BitRate;
}
}
/// <summary>
/// Predicts the audio channels that will be in the output stream
/// </summary>
public int? TargetAudioChannels
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetAudioStream;
int? streamChannels = stream == null ? null : stream.Channels;
2014-04-18 17:16:25 +00:00
return MaxAudioChannels.HasValue && !IsDirectStream
2014-04-28 15:05:28 +00:00
? (streamChannels.HasValue ? Math.Min(MaxAudioChannels.Value, streamChannels.Value) : MaxAudioChannels.Value)
2014-08-01 12:13:24 +00:00
: streamChannels;
2014-04-18 17:16:25 +00:00
}
}
/// <summary>
/// Predicts the audio codec that will be in the output stream
/// </summary>
public string TargetAudioCodec
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetAudioStream;
2014-04-18 17:16:25 +00:00
return IsDirectStream
? (stream == null ? null : stream.Codec)
: AudioCodec;
}
}
/// <summary>
/// Predicts the audio channels that will be in the output stream
/// </summary>
public long? TargetSize
{
get
{
if (IsDirectStream)
{
2014-04-25 17:30:41 +00:00
return MediaSource.Size;
2014-04-18 17:16:25 +00:00
}
if (RunTimeTicks.HasValue)
{
2014-05-08 20:09:53 +00:00
int? totalBitrate = TargetTotalBitrate;
2014-04-18 17:16:25 +00:00
2014-07-01 04:06:28 +00:00
double totalSeconds = RunTimeTicks.Value;
// Convert to ms
totalSeconds /= 10000;
// Convert to seconds
totalSeconds /= 1000;
2014-04-28 15:05:28 +00:00
return totalBitrate.HasValue ?
2014-07-01 04:06:28 +00:00
Convert.ToInt64(totalBitrate.Value * totalSeconds) :
2014-04-28 15:05:28 +00:00
(long?)null;
2014-04-18 17:16:25 +00:00
}
2014-04-28 15:05:28 +00:00
return null;
2014-04-18 17:16:25 +00:00
}
}
2014-04-23 02:47:46 +00:00
2014-04-24 05:08:10 +00:00
public int? TargetVideoBitrate
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream stream = TargetVideoStream;
2014-04-24 05:08:10 +00:00
return VideoBitrate.HasValue && !IsDirectStream
? VideoBitrate
: stream == null ? null : stream.BitRate;
}
}
public TransportStreamTimestamp TargetTimestamp
{
get
{
TransportStreamTimestamp defaultValue = StringHelper.EqualsIgnoreCase(Container, "m2ts")
2014-04-25 02:45:06 +00:00
? TransportStreamTimestamp.Valid
: TransportStreamTimestamp.None;
2014-04-28 15:05:28 +00:00
return !IsDirectStream
? defaultValue
2014-04-25 02:45:06 +00:00
: MediaSource == null ? defaultValue : MediaSource.Timestamp ?? TransportStreamTimestamp.None;
2014-04-24 05:08:10 +00:00
}
}
public int? TargetTotalBitrate
2014-04-23 02:47:46 +00:00
{
get
{
2014-04-24 05:08:10 +00:00
return (TargetAudioBitrate ?? 0) + (TargetVideoBitrate ?? 0);
2014-04-23 02:47:46 +00:00
}
}
2014-06-22 16:25:47 +00:00
public bool? IsTargetAnamorphic
{
get
{
if (IsDirectStream)
{
return TargetVideoStream == null ? null : TargetVideoStream.IsAnamorphic;
}
return false;
}
}
2014-04-23 02:47:46 +00:00
public int? TargetWidth
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream videoStream = TargetVideoStream;
2014-04-23 02:47:46 +00:00
if (videoStream != null && videoStream.Width.HasValue && videoStream.Height.HasValue)
{
2014-05-08 20:09:53 +00:00
ImageSize size = new ImageSize
2014-04-23 02:47:46 +00:00
{
Width = videoStream.Width.Value,
Height = videoStream.Height.Value
};
2014-07-01 04:06:28 +00:00
double? maxWidth = MaxWidth.HasValue ? (double)MaxWidth.Value : (double?)null;
double? maxHeight = MaxHeight.HasValue ? (double)MaxHeight.Value : (double?)null;
2014-05-08 20:09:53 +00:00
ImageSize newSize = DrawingUtils.Resize(size,
2014-04-23 02:47:46 +00:00
null,
null,
2014-07-01 04:06:28 +00:00
maxWidth,
maxHeight);
2014-04-23 02:47:46 +00:00
return Convert.ToInt32(newSize.Width);
}
return MaxWidth;
}
}
public int? TargetHeight
{
get
{
2014-05-08 20:09:53 +00:00
MediaStream videoStream = TargetVideoStream;
2014-04-23 02:47:46 +00:00
if (videoStream != null && videoStream.Width.HasValue && videoStream.Height.HasValue)
{
2014-05-08 20:09:53 +00:00
ImageSize size = new ImageSize
2014-04-23 02:47:46 +00:00
{
Width = videoStream.Width.Value,
Height = videoStream.Height.Value
};
2014-07-01 04:06:28 +00:00
double? maxWidth = MaxWidth.HasValue ? (double)MaxWidth.Value : (double?)null;
double? maxHeight = MaxHeight.HasValue ? (double)MaxHeight.Value : (double?)null;
2014-05-08 20:09:53 +00:00
ImageSize newSize = DrawingUtils.Resize(size,
2014-04-23 02:47:46 +00:00
null,
null,
2014-07-01 04:06:28 +00:00
maxWidth,
maxHeight);
2014-04-23 02:47:46 +00:00
return Convert.ToInt32(newSize.Height);
}
return MaxHeight;
}
}
2014-04-01 22:23:07 +00:00
}
public enum SubtitleDeliveryMethod
{
/// <summary>
/// The encode
/// </summary>
Encode = 0,
/// <summary>
/// The embed
/// </summary>
Embed = 1,
/// <summary>
/// The external
/// </summary>
External = 2,
/// <summary>
/// The HLS
/// </summary>
Hls = 3
}
2014-08-06 02:26:12 +00:00
public class SubtitleStreamInfo
{
public string Url { get; set; }
public string Language { get; set; }
public string Name { get; set; }
public bool IsForced { get; set; }
2014-08-07 02:51:09 +00:00
public string Format { get; set; }
2014-08-06 02:26:12 +00:00
}
2014-04-01 22:23:07 +00:00
}