jellyfin/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs

424 lines
15 KiB
C#
Raw Normal View History

2015-07-20 18:32:55 +00:00
using MediaBrowser.Common.Configuration;
using MediaBrowser.Common.Net;
using MediaBrowser.Controller.LiveTv;
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.LiveTv;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.MediaInfo;
using MediaBrowser.Model.Serialization;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
2015-10-14 02:41:46 +00:00
using MediaBrowser.Controller.MediaEncoding;
2015-10-30 16:40:12 +00:00
using MediaBrowser.Model.Configuration;
2015-10-14 02:41:46 +00:00
using MediaBrowser.Model.Dlna;
2015-07-20 18:32:55 +00:00
2015-07-23 16:32:34 +00:00
namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
2015-07-20 18:32:55 +00:00
{
2015-08-19 17:58:41 +00:00
public class HdHomerunHost : BaseTunerHost, ITunerHost
2015-07-20 18:32:55 +00:00
{
private readonly IHttpClient _httpClient;
2015-10-30 16:40:12 +00:00
public HdHomerunHost(IConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder, IHttpClient httpClient)
: base(config, logger, jsonSerializer, mediaEncoder)
2015-07-20 18:32:55 +00:00
{
_httpClient = httpClient;
}
public string Name
{
get { return "HD Homerun"; }
}
2015-08-19 17:58:41 +00:00
public override string Type
2015-07-23 16:32:34 +00:00
{
get { return DeviceType; }
}
public static string DeviceType
2015-07-20 18:32:55 +00:00
{
get { return "hdhomerun"; }
}
2015-08-16 18:37:53 +00:00
private const string ChannelIdPrefix = "hdhr_";
2015-08-19 17:58:41 +00:00
protected override async Task<IEnumerable<ChannelInfo>> GetChannelsInternal(TunerHostInfo info, CancellationToken cancellationToken)
2015-07-20 18:32:55 +00:00
{
var options = new HttpRequestOptions
{
2015-07-23 23:40:54 +00:00
Url = string.Format("{0}/lineup.json", GetApiUrl(info, false)),
2015-07-20 18:32:55 +00:00
CancellationToken = cancellationToken
};
using (var stream = await _httpClient.Get(options))
{
2015-09-23 01:22:52 +00:00
var root = JsonSerializer.DeserializeFromStream<List<Channels>>(stream);
2015-07-20 18:32:55 +00:00
if (root != null)
{
2015-07-25 18:11:46 +00:00
var result = root.Select(i => new ChannelInfo
2015-07-20 18:32:55 +00:00
{
Name = i.GuideName,
Number = i.GuideNumber.ToString(CultureInfo.InvariantCulture),
2015-08-16 18:37:53 +00:00
Id = ChannelIdPrefix + i.GuideNumber.ToString(CultureInfo.InvariantCulture),
2015-07-20 18:32:55 +00:00
IsFavorite = i.Favorite
});
2015-07-25 18:11:46 +00:00
if (info.ImportFavoritesOnly)
{
result = result.Where(i => (i.IsFavorite ?? true)).ToList();
}
return result;
2015-07-20 18:32:55 +00:00
}
return new List<ChannelInfo>();
}
}
2015-07-24 02:48:10 +00:00
private async Task<string> GetModelInfo(TunerHostInfo info, CancellationToken cancellationToken)
2015-07-20 18:32:55 +00:00
{
2015-07-21 04:22:46 +00:00
string model = null;
using (var stream = await _httpClient.Get(new HttpRequestOptions()
{
2015-07-23 23:40:54 +00:00
Url = string.Format("{0}/", GetApiUrl(info, false)),
2015-07-24 02:48:10 +00:00
CancellationToken = cancellationToken,
CacheLength = TimeSpan.FromDays(1),
2015-10-01 16:28:24 +00:00
CacheMode = CacheMode.Unconditional,
TimeoutMs = Convert.ToInt32(TimeSpan.FromSeconds(5).TotalMilliseconds)
2015-07-21 04:22:46 +00:00
}))
{
using (var sr = new StreamReader(stream, System.Text.Encoding.UTF8))
{
while (!sr.EndOfStream)
{
string line = StripXML(sr.ReadLine());
if (line.StartsWith("Model:")) { model = line.Replace("Model: ", ""); }
//if (line.StartsWith("Device ID:")) { deviceID = line.Replace("Device ID: ", ""); }
//if (line.StartsWith("Firmware:")) { firmware = line.Replace("Firmware: ", ""); }
}
}
}
2015-10-01 16:28:24 +00:00
return model;
2015-07-24 02:48:10 +00:00
}
public async Task<List<LiveTvTunerInfo>> GetTunerInfos(TunerHostInfo info, CancellationToken cancellationToken)
{
2015-08-25 03:13:04 +00:00
var model = await GetModelInfo(info, cancellationToken).ConfigureAwait(false);
2015-07-24 02:48:10 +00:00
2015-07-21 04:22:46 +00:00
using (var stream = await _httpClient.Get(new HttpRequestOptions()
2015-07-20 18:32:55 +00:00
{
2015-07-23 23:40:54 +00:00
Url = string.Format("{0}/tuners.html", GetApiUrl(info, false)),
2015-10-01 16:28:24 +00:00
CancellationToken = cancellationToken,
TimeoutMs = Convert.ToInt32(TimeSpan.FromSeconds(5).TotalMilliseconds)
2015-07-21 04:22:46 +00:00
}))
2015-07-20 18:32:55 +00:00
{
var tuners = new List<LiveTvTunerInfo>();
using (var sr = new StreamReader(stream, System.Text.Encoding.UTF8))
{
while (!sr.EndOfStream)
{
string line = StripXML(sr.ReadLine());
if (line.Contains("Channel"))
{
LiveTvTunerStatus status;
var index = line.IndexOf("Channel", StringComparison.OrdinalIgnoreCase);
var name = line.Substring(0, index - 1);
var currentChannel = line.Substring(index + 7);
if (currentChannel != "none") { status = LiveTvTunerStatus.LiveTv; } else { status = LiveTvTunerStatus.Available; }
2015-08-19 23:57:27 +00:00
tuners.Add(new LiveTvTunerInfo
2015-07-20 18:32:55 +00:00
{
Name = name,
2015-07-21 04:22:46 +00:00
SourceType = string.IsNullOrWhiteSpace(model) ? Name : model,
2015-07-20 18:32:55 +00:00
ProgramName = currentChannel,
Status = status
});
}
}
}
return tuners;
}
}
2015-08-19 16:43:23 +00:00
public async Task<List<LiveTvTunerInfo>> GetTunerInfos(CancellationToken cancellationToken)
{
var list = new List<LiveTvTunerInfo>();
foreach (var host in GetConfiguration().TunerHosts
.Where(i => i.IsEnabled && string.Equals(i.Type, Type, StringComparison.OrdinalIgnoreCase)))
{
try
{
list.AddRange(await GetTunerInfos(host, cancellationToken).ConfigureAwait(false));
}
catch (Exception ex)
{
2015-08-19 17:58:41 +00:00
Logger.ErrorException("Error getting tuner info", ex);
2015-08-19 16:43:23 +00:00
}
}
return list;
}
2015-07-23 23:40:54 +00:00
private string GetApiUrl(TunerHostInfo info, bool isPlayback)
2015-07-20 18:32:55 +00:00
{
var url = info.Url;
2015-08-24 02:08:20 +00:00
if (string.IsNullOrWhiteSpace(url))
{
throw new ArgumentException("Invalid tuner info");
}
2015-07-20 18:32:55 +00:00
if (!url.StartsWith("http", StringComparison.OrdinalIgnoreCase))
{
url = "http://" + url;
}
2015-07-23 23:40:54 +00:00
var uri = new Uri(url);
if (isPlayback)
{
var builder = new UriBuilder(uri);
builder.Port = 5004;
uri = builder.Uri;
}
return uri.AbsoluteUri.TrimEnd('/');
2015-07-20 18:32:55 +00:00
}
private static string StripXML(string source)
{
char[] buffer = new char[source.Length];
int bufferIndex = 0;
bool inside = false;
for (int i = 0; i < source.Length; i++)
{
char let = source[i];
if (let == '<')
{
inside = true;
continue;
}
if (let == '>')
{
inside = false;
continue;
}
if (!inside)
{
buffer[bufferIndex] = let;
bufferIndex++;
}
}
return new string(buffer, 0, bufferIndex);
}
private class Channels
{
public string GuideNumber { get; set; }
public string GuideName { get; set; }
public string URL { get; set; }
public bool Favorite { get; set; }
public bool DRM { get; set; }
}
2015-07-23 23:40:54 +00:00
private MediaSourceInfo GetMediaSource(TunerHostInfo info, string channelId, string profile)
2015-07-20 18:32:55 +00:00
{
2015-07-24 02:48:10 +00:00
int? width = null;
int? height = null;
bool isInterlaced = true;
2015-11-27 04:34:11 +00:00
var videoCodec = !string.IsNullOrWhiteSpace(GetEncodingOptions().HardwareAccelerationType) ? null : "mpeg2video";
2015-10-30 16:40:12 +00:00
2015-07-24 02:48:10 +00:00
int? videoBitrate = null;
if (string.Equals(profile, "mobile", StringComparison.OrdinalIgnoreCase))
{
width = 1280;
height = 720;
isInterlaced = false;
videoCodec = "h264";
videoBitrate = 2000000;
}
else if (string.Equals(profile, "heavy", StringComparison.OrdinalIgnoreCase))
{
width = 1920;
height = 1080;
isInterlaced = false;
videoCodec = "h264";
2015-12-29 16:12:33 +00:00
videoBitrate = 15000000;
2015-07-24 02:48:10 +00:00
}
else if (string.Equals(profile, "internet720", StringComparison.OrdinalIgnoreCase))
{
width = 1280;
height = 720;
isInterlaced = false;
videoCodec = "h264";
2015-12-29 16:12:33 +00:00
videoBitrate = 8000000;
2015-07-24 02:48:10 +00:00
}
else if (string.Equals(profile, "internet540", StringComparison.OrdinalIgnoreCase))
{
width = 1280;
height = 720;
isInterlaced = false;
videoCodec = "h264";
videoBitrate = 2500000;
}
else if (string.Equals(profile, "internet480", StringComparison.OrdinalIgnoreCase))
{
width = 848;
height = 480;
isInterlaced = false;
videoCodec = "h264";
videoBitrate = 2000000;
}
else if (string.Equals(profile, "internet360", StringComparison.OrdinalIgnoreCase))
{
width = 640;
height = 360;
isInterlaced = false;
videoCodec = "h264";
videoBitrate = 1500000;
}
else if (string.Equals(profile, "internet240", StringComparison.OrdinalIgnoreCase))
{
width = 432;
height = 240;
isInterlaced = false;
videoCodec = "h264";
videoBitrate = 1000000;
}
var url = GetApiUrl(info, true) + "/auto/v" + channelId;
2015-07-24 21:44:25 +00:00
if (!string.IsNullOrWhiteSpace(profile) && !string.Equals(profile, "native", StringComparison.OrdinalIgnoreCase))
2015-07-24 02:48:10 +00:00
{
url += "?transcode=" + profile;
}
2015-07-23 23:40:54 +00:00
var mediaSource = new MediaSourceInfo
2015-07-20 18:32:55 +00:00
{
2015-07-24 02:48:10 +00:00
Path = url,
2015-07-23 23:40:54 +00:00
Protocol = MediaProtocol.Http,
MediaStreams = new List<MediaStream>
2015-07-20 18:32:55 +00:00
{
new MediaStream
{
Type = MediaStreamType.Video,
// Set the index to -1 because we don't know the exact index of the video stream within the container
Index = -1,
2015-07-24 02:48:10 +00:00
IsInterlaced = isInterlaced,
Codec = videoCodec,
Width = width,
Height = height,
BitRate = videoBitrate
2015-07-20 18:32:55 +00:00
},
new MediaStream
{
Type = MediaStreamType.Audio,
// Set the index to -1 because we don't know the exact index of the audio stream within the container
2015-07-24 02:48:10 +00:00
Index = -1,
Codec = "ac3",
2015-12-29 16:12:33 +00:00
BitRate = 192000
2015-07-20 18:32:55 +00:00
}
2015-07-23 23:40:54 +00:00
},
2015-10-30 16:40:12 +00:00
RequiresOpening = false,
RequiresClosing = false,
2015-12-29 16:12:33 +00:00
BufferMs = 0,
2015-07-25 18:42:39 +00:00
Container = "ts",
2015-09-10 03:22:52 +00:00
Id = profile,
SupportsDirectPlay = true,
2015-09-10 18:28:22 +00:00
SupportsDirectStream = true,
2015-09-10 03:22:52 +00:00
SupportsTranscoding = true
2015-07-23 23:40:54 +00:00
};
2015-07-20 18:32:55 +00:00
2015-07-23 23:40:54 +00:00
return mediaSource;
2015-07-20 18:32:55 +00:00
}
2015-07-23 13:23:22 +00:00
2015-10-30 16:40:12 +00:00
protected EncodingOptions GetEncodingOptions()
{
return Config.GetConfiguration<EncodingOptions>("encoding");
}
2015-08-19 19:25:18 +00:00
protected override async Task<List<MediaSourceInfo>> GetChannelStreamMediaSources(TunerHostInfo info, string channelId, CancellationToken cancellationToken)
2015-07-23 23:40:54 +00:00
{
var list = new List<MediaSourceInfo>();
2015-08-16 18:37:53 +00:00
if (!channelId.StartsWith(ChannelIdPrefix, StringComparison.OrdinalIgnoreCase))
{
return list;
}
2015-08-16 20:26:49 +00:00
channelId = channelId.Substring(ChannelIdPrefix.Length);
2015-08-16 18:37:53 +00:00
2015-07-24 21:44:25 +00:00
list.Add(GetMediaSource(info, channelId, "native"));
2015-07-23 23:40:54 +00:00
2015-07-24 02:48:10 +00:00
try
{
string model = await GetModelInfo(info, cancellationToken).ConfigureAwait(false);
model = model ?? string.Empty;
if (model.IndexOf("hdtc", StringComparison.OrdinalIgnoreCase) != -1)
{
2015-07-24 15:20:11 +00:00
list.Insert(0, GetMediaSource(info, channelId, "heavy"));
2015-07-24 02:48:10 +00:00
list.Add(GetMediaSource(info, channelId, "internet480"));
list.Add(GetMediaSource(info, channelId, "internet360"));
list.Add(GetMediaSource(info, channelId, "internet240"));
list.Add(GetMediaSource(info, channelId, "mobile"));
}
}
catch (Exception ex)
{
2015-08-16 18:37:53 +00:00
2015-07-24 02:48:10 +00:00
}
return list;
2015-07-23 23:40:54 +00:00
}
2015-08-19 19:25:18 +00:00
protected override bool IsValidChannelId(string channelId)
{
2015-10-05 03:24:24 +00:00
if (string.IsNullOrWhiteSpace(channelId))
{
throw new ArgumentNullException("channelId");
}
2015-08-19 19:25:18 +00:00
return channelId.StartsWith(ChannelIdPrefix, StringComparison.OrdinalIgnoreCase);
}
protected override async Task<MediaSourceInfo> GetChannelStream(TunerHostInfo info, string channelId, string streamId, CancellationToken cancellationToken)
2015-07-23 23:40:54 +00:00
{
2015-09-23 01:22:52 +00:00
Logger.Info("GetChannelStream: channel id: {0}. stream id: {1}", channelId, streamId ?? string.Empty);
2015-09-01 19:18:25 +00:00
2015-08-16 18:37:53 +00:00
if (!channelId.StartsWith(ChannelIdPrefix, StringComparison.OrdinalIgnoreCase))
{
2015-10-14 02:41:46 +00:00
throw new ArgumentException("Channel not found");
2015-08-16 18:37:53 +00:00
}
2015-08-16 20:26:49 +00:00
channelId = channelId.Substring(ChannelIdPrefix.Length);
2015-08-16 18:37:53 +00:00
2015-07-24 21:44:25 +00:00
return GetMediaSource(info, channelId, streamId);
2015-07-23 23:40:54 +00:00
}
2015-07-23 13:23:22 +00:00
public async Task Validate(TunerHostInfo info)
{
2015-08-24 02:08:20 +00:00
if (info.IsEnabled)
{
await GetChannels(info, false, CancellationToken.None).ConfigureAwait(false);
}
2015-07-23 13:23:22 +00:00
}
2015-10-30 16:40:12 +00:00
protected override async Task<bool> IsAvailableInternal(TunerHostInfo tuner, string channelId, CancellationToken cancellationToken)
{
var info = await GetTunerInfos(tuner, cancellationToken).ConfigureAwait(false);
return info.Any(i => i.Status == LiveTvTunerStatus.Available);
}
2015-07-20 18:32:55 +00:00
}
}