jellyfin/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/EmbyTV.cs

935 lines
34 KiB
C#
Raw Normal View History

2015-08-02 23:47:31 +00:00
using MediaBrowser.Common;
2015-07-20 18:32:55 +00:00
using MediaBrowser.Common.Configuration;
2015-08-16 00:41:55 +00:00
using MediaBrowser.Common.IO;
2015-07-20 18:32:55 +00:00
using MediaBrowser.Common.Net;
2015-08-21 19:25:35 +00:00
using MediaBrowser.Common.Security;
2015-08-22 19:46:55 +00:00
using MediaBrowser.Controller.Configuration;
2015-07-20 18:32:55 +00:00
using MediaBrowser.Controller.Drawing;
2015-08-22 19:46:55 +00:00
using MediaBrowser.Controller.FileOrganization;
using MediaBrowser.Controller.Library;
2015-07-20 18:32:55 +00:00
using MediaBrowser.Controller.LiveTv;
2015-09-21 16:26:05 +00:00
using MediaBrowser.Controller.MediaEncoding;
2015-08-22 19:46:55 +00:00
using MediaBrowser.Controller.Providers;
2015-09-21 16:26:05 +00:00
using MediaBrowser.Model.Dlna;
2015-07-20 18:32:55 +00:00
using MediaBrowser.Model.Dto;
2015-08-21 19:25:35 +00:00
using MediaBrowser.Model.Entities;
2015-07-20 18:32:55 +00:00
using MediaBrowser.Model.Events;
2015-08-22 19:46:55 +00:00
using MediaBrowser.Model.FileOrganization;
2015-07-20 18:32:55 +00:00
using MediaBrowser.Model.LiveTv;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Serialization;
2015-08-22 19:46:55 +00:00
using MediaBrowser.Server.Implementations.FileOrganization;
2015-07-20 18:32:55 +00:00
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
{
2015-08-22 19:46:55 +00:00
public class EmbyTV : ILiveTvService, IHasRegistrationInfo, IDisposable
2015-07-20 18:32:55 +00:00
{
2015-07-21 04:22:46 +00:00
private readonly IApplicationHost _appHpst;
2015-07-20 18:32:55 +00:00
private readonly ILogger _logger;
private readonly IHttpClient _httpClient;
2015-08-22 19:46:55 +00:00
private readonly IServerConfigurationManager _config;
2015-07-20 18:32:55 +00:00
private readonly IJsonSerializer _jsonSerializer;
private readonly ItemDataProvider<RecordingInfo> _recordingProvider;
private readonly ItemDataProvider<SeriesTimerInfo> _seriesTimerProvider;
private readonly TimerManager _timerProvider;
2015-07-23 13:23:22 +00:00
private readonly LiveTvManager _liveTvManager;
2015-08-16 18:54:25 +00:00
private readonly IFileSystem _fileSystem;
2015-08-21 19:25:35 +00:00
private readonly ISecurityManager _security;
2015-07-23 05:25:55 +00:00
2015-08-22 19:46:55 +00:00
private readonly ILibraryMonitor _libraryMonitor;
private readonly ILibraryManager _libraryManager;
private readonly IProviderManager _providerManager;
private readonly IFileOrganizationService _organizationService;
2015-09-21 16:26:05 +00:00
private readonly IMediaEncoder _mediaEncoder;
2015-08-22 19:46:55 +00:00
2015-07-29 03:42:03 +00:00
public static EmbyTV Current;
2015-09-21 16:26:05 +00:00
public EmbyTV(IApplicationHost appHost, ILogger logger, IJsonSerializer jsonSerializer, IHttpClient httpClient, IServerConfigurationManager config, ILiveTvManager liveTvManager, IFileSystem fileSystem, ISecurityManager security, ILibraryManager libraryManager, ILibraryMonitor libraryMonitor, IProviderManager providerManager, IFileOrganizationService organizationService, IMediaEncoder mediaEncoder)
2015-07-20 18:32:55 +00:00
{
2015-07-29 03:42:03 +00:00
Current = this;
2015-07-21 04:22:46 +00:00
_appHpst = appHost;
2015-07-20 18:32:55 +00:00
_logger = logger;
_httpClient = httpClient;
_config = config;
2015-08-16 18:54:25 +00:00
_fileSystem = fileSystem;
2015-08-21 19:25:35 +00:00
_security = security;
2015-08-22 19:46:55 +00:00
_libraryManager = libraryManager;
_libraryMonitor = libraryMonitor;
_providerManager = providerManager;
_organizationService = organizationService;
2015-09-21 16:26:05 +00:00
_mediaEncoder = mediaEncoder;
2015-07-23 13:23:22 +00:00
_liveTvManager = (LiveTvManager)liveTvManager;
2015-07-20 18:32:55 +00:00
_jsonSerializer = jsonSerializer;
2015-09-21 16:26:05 +00:00
_recordingProvider = new ItemDataProvider<RecordingInfo>(fileSystem, jsonSerializer, _logger, Path.Combine(DataPath, "recordings"), (r1, r2) => string.Equals(r1.Id, r2.Id, StringComparison.OrdinalIgnoreCase));
_seriesTimerProvider = new SeriesTimerManager(fileSystem, jsonSerializer, _logger, Path.Combine(DataPath, "seriestimers"));
_timerProvider = new TimerManager(fileSystem, jsonSerializer, _logger, Path.Combine(DataPath, "timers"));
2015-07-20 18:32:55 +00:00
_timerProvider.TimerFired += _timerProvider_TimerFired;
}
2015-07-29 03:42:03 +00:00
public void Start()
{
_timerProvider.RestartTimers();
}
2015-07-20 18:32:55 +00:00
public event EventHandler DataSourceChanged;
public event EventHandler<RecordingStatusChangedEventArgs> RecordingStatusChanged;
private readonly ConcurrentDictionary<string, CancellationTokenSource> _activeRecordings =
new ConcurrentDictionary<string, CancellationTokenSource>(StringComparer.OrdinalIgnoreCase);
public string Name
{
get { return "Emby"; }
}
public string DataPath
{
get { return Path.Combine(_config.CommonApplicationPaths.DataPath, "livetv"); }
}
public string HomePageUrl
{
get { return "http://emby.media"; }
}
public async Task<LiveTvServiceStatusInfo> GetStatusInfoAsync(CancellationToken cancellationToken)
{
var status = new LiveTvServiceStatusInfo();
var list = new List<LiveTvTunerInfo>();
2015-08-19 16:43:23 +00:00
foreach (var hostInstance in _liveTvManager.TunerHosts)
2015-07-20 18:32:55 +00:00
{
2015-07-23 23:40:54 +00:00
try
2015-07-20 18:32:55 +00:00
{
2015-08-19 16:43:23 +00:00
var tuners = await hostInstance.GetTunerInfos(cancellationToken).ConfigureAwait(false);
2015-07-20 18:32:55 +00:00
2015-07-23 23:40:54 +00:00
list.AddRange(tuners);
}
catch (Exception ex)
{
_logger.ErrorException("Error getting tuners", ex);
2015-07-20 18:32:55 +00:00
}
}
status.Tuners = list;
status.Status = LiveTvServiceStatus.Ok;
2015-07-21 04:22:46 +00:00
status.Version = _appHpst.ApplicationVersion.ToString();
status.IsVisible = false;
2015-07-20 18:32:55 +00:00
return status;
}
2015-09-21 16:26:05 +00:00
public async Task RefreshSeriesTimers(CancellationToken cancellationToken, IProgress<double> progress)
{
var timers = await GetSeriesTimersAsync(cancellationToken).ConfigureAwait(false);
List<ChannelInfo> channels = null;
foreach (var timer in timers)
{
List<ProgramInfo> epgData;
if (timer.RecordAnyChannel)
{
if (channels == null)
{
channels = (await GetChannelsAsync(true, CancellationToken.None).ConfigureAwait(false)).ToList();
}
var channelIds = channels.Select(i => i.Id).ToList();
epgData = GetEpgDataForChannels(channelIds);
}
else
{
epgData = GetEpgDataForChannel(timer.ChannelId);
}
await UpdateTimersForSeriesTimer(epgData, timer).ConfigureAwait(false);
}
}
2015-08-16 18:54:25 +00:00
private List<ChannelInfo> _channelCache = null;
private async Task<IEnumerable<ChannelInfo>> GetChannelsAsync(bool enableCache, CancellationToken cancellationToken)
2015-07-20 18:32:55 +00:00
{
2015-08-16 18:54:25 +00:00
if (enableCache && _channelCache != null)
{
return _channelCache.ToList();
}
2015-07-20 18:32:55 +00:00
var list = new List<ChannelInfo>();
2015-08-19 16:43:23 +00:00
foreach (var hostInstance in _liveTvManager.TunerHosts)
2015-07-20 18:32:55 +00:00
{
2015-07-23 23:40:54 +00:00
try
2015-07-20 18:32:55 +00:00
{
2015-08-19 16:43:23 +00:00
var channels = await hostInstance.GetChannels(cancellationToken).ConfigureAwait(false);
2015-07-20 18:32:55 +00:00
2015-08-16 18:37:53 +00:00
list.AddRange(channels);
2015-07-23 23:40:54 +00:00
}
catch (Exception ex)
{
_logger.ErrorException("Error getting channels", ex);
2015-07-20 18:32:55 +00:00
}
}
2015-07-23 05:25:55 +00:00
if (list.Count > 0)
{
foreach (var provider in GetListingProviders())
{
2015-08-02 23:47:31 +00:00
try
{
await provider.Item1.AddMetadata(provider.Item2, list, cancellationToken).ConfigureAwait(false);
}
catch (NotSupportedException)
{
}
catch (Exception ex)
{
_logger.ErrorException("Error adding metadata", ex);
}
2015-07-23 05:25:55 +00:00
}
}
2015-08-16 18:54:25 +00:00
_channelCache = list;
2015-07-20 18:32:55 +00:00
return list;
}
2015-08-16 18:54:25 +00:00
public Task<IEnumerable<ChannelInfo>> GetChannelsAsync(CancellationToken cancellationToken)
{
return GetChannelsAsync(false, cancellationToken);
}
2015-07-20 18:32:55 +00:00
public Task CancelSeriesTimerAsync(string timerId, CancellationToken cancellationToken)
{
2015-08-17 16:52:56 +00:00
var timers = _timerProvider.GetAll().Where(i => string.Equals(i.SeriesTimerId, timerId, StringComparison.OrdinalIgnoreCase));
foreach (var timer in timers)
{
CancelTimerInternal(timer.Id);
}
2015-07-29 03:42:03 +00:00
var remove = _seriesTimerProvider.GetAll().FirstOrDefault(r => string.Equals(r.Id, timerId, StringComparison.OrdinalIgnoreCase));
2015-07-20 18:32:55 +00:00
if (remove != null)
{
_seriesTimerProvider.Delete(remove);
}
return Task.FromResult(true);
}
private void CancelTimerInternal(string timerId)
{
2015-07-29 03:42:03 +00:00
var remove = _timerProvider.GetAll().FirstOrDefault(r => string.Equals(r.Id, timerId, StringComparison.OrdinalIgnoreCase));
2015-07-20 18:32:55 +00:00
if (remove != null)
{
_timerProvider.Delete(remove);
}
CancellationTokenSource cancellationTokenSource;
if (_activeRecordings.TryGetValue(timerId, out cancellationTokenSource))
{
cancellationTokenSource.Cancel();
}
}
public Task CancelTimerAsync(string timerId, CancellationToken cancellationToken)
{
CancelTimerInternal(timerId);
return Task.FromResult(true);
}
2015-07-29 03:42:03 +00:00
public async Task DeleteRecordingAsync(string recordingId, CancellationToken cancellationToken)
2015-07-20 18:32:55 +00:00
{
var remove = _recordingProvider.GetAll().FirstOrDefault(i => string.Equals(i.Id, recordingId, StringComparison.OrdinalIgnoreCase));
if (remove != null)
{
2015-07-29 03:42:03 +00:00
if (!string.IsNullOrWhiteSpace(remove.TimerId))
{
var enableDelay = _activeRecordings.ContainsKey(remove.TimerId);
CancelTimerInternal(remove.TimerId);
if (enableDelay)
{
// A hack yes, but need to make sure the file is closed before attempting to delete it
2015-08-16 20:26:49 +00:00
await Task.Delay(3000, cancellationToken).ConfigureAwait(false);
2015-07-29 03:42:03 +00:00
}
}
2015-07-20 18:32:55 +00:00
try
{
2015-09-21 16:26:05 +00:00
_fileSystem.DeleteFile(remove.Path);
2015-07-20 18:32:55 +00:00
}
catch (DirectoryNotFoundException)
{
}
catch (FileNotFoundException)
{
}
_recordingProvider.Delete(remove);
}
}
public Task CreateTimerAsync(TimerInfo info, CancellationToken cancellationToken)
{
info.Id = Guid.NewGuid().ToString("N");
_timerProvider.Add(info);
return Task.FromResult(0);
}
2015-08-15 21:58:52 +00:00
public async Task CreateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
2015-07-20 18:32:55 +00:00
{
2015-07-29 17:16:00 +00:00
info.Id = Guid.NewGuid().ToString("N");
2015-07-20 18:32:55 +00:00
2015-08-16 22:03:22 +00:00
List<ProgramInfo> epgData;
if (info.RecordAnyChannel)
{
var channels = await GetChannelsAsync(true, CancellationToken.None).ConfigureAwait(false);
var channelIds = channels.Select(i => i.Id).ToList();
epgData = GetEpgDataForChannels(channelIds);
}
else
{
epgData = GetEpgDataForChannel(info.ChannelId);
}
// populate info.seriesID
var program = epgData.FirstOrDefault(i => string.Equals(i.Id, info.ProgramId, StringComparison.OrdinalIgnoreCase));
if (program != null)
{
info.SeriesId = program.SeriesId;
}
else
{
throw new InvalidOperationException("SeriesId for program not found");
}
2015-07-20 18:32:55 +00:00
_seriesTimerProvider.Add(info);
2015-08-16 22:03:22 +00:00
await UpdateTimersForSeriesTimer(epgData, info).ConfigureAwait(false);
2015-07-20 18:32:55 +00:00
}
2015-08-15 21:58:52 +00:00
public async Task UpdateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
2015-07-20 18:32:55 +00:00
{
_seriesTimerProvider.Update(info);
2015-08-16 22:03:22 +00:00
List<ProgramInfo> epgData;
if (info.RecordAnyChannel)
{
var channels = await GetChannelsAsync(true, CancellationToken.None).ConfigureAwait(false);
var channelIds = channels.Select(i => i.Id).ToList();
epgData = GetEpgDataForChannels(channelIds);
}
else
{
epgData = GetEpgDataForChannel(info.ChannelId);
}
await UpdateTimersForSeriesTimer(epgData, info).ConfigureAwait(false);
2015-07-20 18:32:55 +00:00
}
public Task UpdateTimerAsync(TimerInfo info, CancellationToken cancellationToken)
{
_timerProvider.Update(info);
return Task.FromResult(true);
}
public Task<ImageStream> GetChannelImageAsync(string channelId, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<ImageStream> GetRecordingImageAsync(string recordingId, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<ImageStream> GetProgramImageAsync(string programId, string channelId, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<IEnumerable<RecordingInfo>> GetRecordingsAsync(CancellationToken cancellationToken)
{
return Task.FromResult((IEnumerable<RecordingInfo>)_recordingProvider.GetAll());
}
public Task<IEnumerable<TimerInfo>> GetTimersAsync(CancellationToken cancellationToken)
{
return Task.FromResult((IEnumerable<TimerInfo>)_timerProvider.GetAll());
}
public Task<SeriesTimerInfo> GetNewTimerDefaultsAsync(CancellationToken cancellationToken, ProgramInfo program = null)
{
2015-08-24 02:08:20 +00:00
var config = GetConfiguration();
2015-07-20 18:32:55 +00:00
var defaults = new SeriesTimerInfo()
{
2015-08-24 02:08:20 +00:00
PostPaddingSeconds = Math.Max(config.PostPaddingSeconds, 0),
PrePaddingSeconds = Math.Max(config.PrePaddingSeconds, 0),
2015-07-20 18:32:55 +00:00
RecordAnyChannel = false,
RecordAnyTime = false,
RecordNewOnly = false
};
2015-08-11 17:47:29 +00:00
if (program != null)
{
defaults.SeriesId = program.SeriesId;
defaults.ProgramId = program.Id;
}
2015-07-20 18:32:55 +00:00
return Task.FromResult(defaults);
}
public Task<IEnumerable<SeriesTimerInfo>> GetSeriesTimersAsync(CancellationToken cancellationToken)
{
return Task.FromResult((IEnumerable<SeriesTimerInfo>)_seriesTimerProvider.GetAll());
}
2015-07-23 05:25:55 +00:00
public async Task<IEnumerable<ProgramInfo>> GetProgramsAsync(string channelId, DateTime startDateUtc, DateTime endDateUtc, CancellationToken cancellationToken)
2015-09-10 18:28:22 +00:00
{
try
{
return await GetProgramsAsyncInternal(channelId, startDateUtc, endDateUtc, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.ErrorException("Error getting programs", ex);
return GetEpgDataForChannel(channelId).Where(i => i.StartDate <= endDateUtc && i.EndDate >= startDateUtc);
}
}
private async Task<IEnumerable<ProgramInfo>> GetProgramsAsyncInternal(string channelId, DateTime startDateUtc, DateTime endDateUtc, CancellationToken cancellationToken)
2015-07-20 18:32:55 +00:00
{
2015-08-16 18:54:25 +00:00
var channels = await GetChannelsAsync(true, cancellationToken).ConfigureAwait(false);
var channel = channels.First(i => string.Equals(i.Id, channelId, StringComparison.OrdinalIgnoreCase));
2015-07-23 05:25:55 +00:00
foreach (var provider in GetListingProviders())
{
2015-08-16 18:54:25 +00:00
var programs = await provider.Item1.GetProgramsAsync(provider.Item2, channel.Number, startDateUtc, endDateUtc, cancellationToken)
2015-07-23 05:25:55 +00:00
.ConfigureAwait(false);
2015-09-10 18:28:22 +00:00
2015-07-23 05:25:55 +00:00
var list = programs.ToList();
2015-07-23 23:40:54 +00:00
// Replace the value that came from the provider with a normalized value
foreach (var program in list)
{
program.ChannelId = channelId;
}
2015-07-23 05:25:55 +00:00
if (list.Count > 0)
{
2015-07-29 03:42:03 +00:00
SaveEpgDataForChannel(channelId, list);
2015-07-23 05:25:55 +00:00
return list;
}
}
return new List<ProgramInfo>();
}
private List<Tuple<IListingsProvider, ListingsProviderInfo>> GetListingProviders()
{
return GetConfiguration().ListingProviders
.Select(i =>
{
2015-07-23 13:23:22 +00:00
var provider = _liveTvManager.ListingProviders.FirstOrDefault(l => string.Equals(l.Type, i.Type, StringComparison.OrdinalIgnoreCase));
2015-07-23 05:25:55 +00:00
return provider == null ? null : new Tuple<IListingsProvider, ListingsProviderInfo>(provider, i);
})
.Where(i => i != null)
.ToList();
2015-07-20 18:32:55 +00:00
}
public Task<MediaSourceInfo> GetRecordingStream(string recordingId, string streamId, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
2015-07-23 23:40:54 +00:00
public async Task<MediaSourceInfo> GetChannelStream(string channelId, string streamId, CancellationToken cancellationToken)
2015-07-20 18:32:55 +00:00
{
2015-07-23 23:40:54 +00:00
_logger.Info("Streaming Channel " + channelId);
2015-08-19 19:25:18 +00:00
foreach (var hostInstance in _liveTvManager.TunerHosts)
2015-07-23 23:40:54 +00:00
{
MediaSourceInfo mediaSourceInfo = null;
try
{
2015-08-19 19:25:18 +00:00
mediaSourceInfo = await hostInstance.GetChannelStream(channelId, streamId, cancellationToken).ConfigureAwait(false);
2015-07-23 23:40:54 +00:00
}
2015-08-16 18:37:53 +00:00
catch (Exception e)
2015-07-23 23:40:54 +00:00
{
2015-08-16 18:37:53 +00:00
_logger.ErrorException("Error getting channel stream", e);
2015-07-23 23:40:54 +00:00
}
2015-08-16 18:37:53 +00:00
if (mediaSourceInfo != null)
{
2015-09-21 16:26:05 +00:00
await AddMediaInfo(mediaSourceInfo, false, cancellationToken).ConfigureAwait(false);
2015-08-16 18:37:53 +00:00
mediaSourceInfo.Id = Guid.NewGuid().ToString("N");
return mediaSourceInfo;
}
2015-07-23 23:40:54 +00:00
}
throw new ApplicationException("Tuner not found.");
2015-07-20 18:32:55 +00:00
}
2015-07-23 23:40:54 +00:00
public async Task<List<MediaSourceInfo>> GetChannelStreamMediaSources(string channelId, CancellationToken cancellationToken)
2015-07-20 18:32:55 +00:00
{
2015-08-19 19:25:18 +00:00
foreach (var hostInstance in _liveTvManager.TunerHosts)
2015-07-23 23:40:54 +00:00
{
2015-08-16 18:37:53 +00:00
try
2015-07-23 23:40:54 +00:00
{
2015-08-19 19:25:18 +00:00
var sources = await hostInstance.GetChannelStreamMediaSources(channelId, cancellationToken).ConfigureAwait(false);
2015-07-23 23:40:54 +00:00
2015-08-16 18:37:53 +00:00
if (sources.Count > 0)
{
return sources;
}
}
catch (NotImplementedException)
{
2015-08-16 18:54:25 +00:00
2015-07-23 23:40:54 +00:00
}
}
2015-08-27 19:59:42 +00:00
throw new NotImplementedException();
2015-07-20 18:32:55 +00:00
}
2015-09-21 16:26:05 +00:00
private async Task AddMediaInfo(MediaSourceInfo mediaSource, bool isAudio, CancellationToken cancellationToken)
{
var originalRuntime = mediaSource.RunTimeTicks;
var info = await _mediaEncoder.GetMediaInfo(new MediaInfoRequest
{
InputPath = mediaSource.Path,
Protocol = mediaSource.Protocol,
MediaType = isAudio ? DlnaProfileType.Audio : DlnaProfileType.Video,
ExtractChapters = false
}, cancellationToken).ConfigureAwait(false);
mediaSource.Bitrate = info.Bitrate;
mediaSource.Container = info.Container;
mediaSource.Formats = info.Formats;
mediaSource.MediaStreams = info.MediaStreams;
mediaSource.RunTimeTicks = info.RunTimeTicks;
mediaSource.Size = info.Size;
mediaSource.Timestamp = info.Timestamp;
mediaSource.Video3DFormat = info.Video3DFormat;
mediaSource.VideoType = info.VideoType;
mediaSource.DefaultSubtitleStreamIndex = null;
// Null this out so that it will be treated like a live stream
if (!originalRuntime.HasValue)
{
mediaSource.RunTimeTicks = null;
}
var audioStream = mediaSource.MediaStreams.FirstOrDefault(i => i.Type == Model.Entities.MediaStreamType.Audio);
if (audioStream == null || audioStream.Index == -1)
{
mediaSource.DefaultAudioStreamIndex = null;
}
else
{
mediaSource.DefaultAudioStreamIndex = audioStream.Index;
}
var videoStream = mediaSource.MediaStreams.FirstOrDefault(i => i.Type == Model.Entities.MediaStreamType.Video);
if (videoStream != null)
{
if (!videoStream.BitRate.HasValue)
{
var width = videoStream.Width ?? 1920;
if (width >= 1900)
{
videoStream.BitRate = 8000000;
}
else if (width >= 1260)
{
videoStream.BitRate = 3000000;
}
else if (width >= 700)
{
videoStream.BitRate = 1000000;
}
}
}
// Try to estimate this
if (!mediaSource.Bitrate.HasValue)
{
var total = mediaSource.MediaStreams.Select(i => i.BitRate ?? 0).Sum();
if (total > 0)
{
mediaSource.Bitrate = total;
}
}
}
2015-07-20 18:32:55 +00:00
public Task<List<MediaSourceInfo>> GetRecordingStreamMediaSources(string recordingId, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task CloseLiveStream(string id, CancellationToken cancellationToken)
{
return Task.FromResult(0);
}
public Task RecordLiveStream(string id, CancellationToken cancellationToken)
{
return Task.FromResult(0);
}
public Task ResetTuner(string id, CancellationToken cancellationToken)
{
return Task.FromResult(0);
}
async void _timerProvider_TimerFired(object sender, GenericEventArgs<TimerInfo> e)
{
2015-08-22 18:29:12 +00:00
var timer = e.Argument;
2015-08-31 23:47:47 +00:00
_logger.Info("Recording timer fired.");
2015-09-21 16:23:20 +00:00
2015-07-20 18:32:55 +00:00
try
{
var cancellationTokenSource = new CancellationTokenSource();
2015-08-22 18:29:12 +00:00
if (_activeRecordings.TryAdd(timer.Id, cancellationTokenSource))
2015-07-20 18:32:55 +00:00
{
2015-08-22 18:29:12 +00:00
await RecordStream(timer, cancellationTokenSource.Token).ConfigureAwait(false);
2015-07-20 18:32:55 +00:00
}
}
catch (OperationCanceledException)
{
}
catch (Exception ex)
{
_logger.ErrorException("Error recording stream", ex);
}
}
private async Task RecordStream(TimerInfo timer, CancellationToken cancellationToken)
{
2015-07-28 03:32:33 +00:00
if (timer == null)
{
throw new ArgumentNullException("timer");
}
2015-07-27 18:18:10 +00:00
var mediaStreamInfo = await GetChannelStream(timer.ChannelId, null, CancellationToken.None);
2015-07-29 20:31:15 +00:00
var duration = (timer.EndDate - DateTime.UtcNow).Add(TimeSpan.FromSeconds(timer.PostPaddingSeconds));
2015-07-20 18:32:55 +00:00
HttpRequestOptions httpRequestOptions = new HttpRequestOptions()
{
2015-08-17 04:08:33 +00:00
Url = mediaStreamInfo.Path
2015-07-20 18:32:55 +00:00
};
var info = GetProgramInfoFromCache(timer.ChannelId, timer.ProgramId);
var recordPath = RecordingPath;
2015-08-20 23:55:23 +00:00
2015-07-20 18:32:55 +00:00
if (info.IsMovie)
{
2015-08-16 00:41:55 +00:00
recordPath = Path.Combine(recordPath, "Movies", _fileSystem.GetValidFilename(info.Name));
2015-07-20 18:32:55 +00:00
}
2015-08-20 23:55:23 +00:00
else if (info.IsSeries)
{
recordPath = Path.Combine(recordPath, "Series", _fileSystem.GetValidFilename(info.Name));
}
else if (info.IsKids)
{
recordPath = Path.Combine(recordPath, "Kids", _fileSystem.GetValidFilename(info.Name));
}
else if (info.IsSports)
{
recordPath = Path.Combine(recordPath, "Sports", _fileSystem.GetValidFilename(info.Name));
}
2015-07-20 18:32:55 +00:00
else
{
2015-08-22 15:54:29 +00:00
recordPath = Path.Combine(recordPath, "Other", _fileSystem.GetValidFilename(info.Name));
2015-07-20 18:32:55 +00:00
}
2015-08-21 02:36:30 +00:00
var recordingFileName = _fileSystem.GetValidFilename(RecordingHelper.GetRecordingName(timer, info)) + ".ts";
recordPath = Path.Combine(recordPath, recordingFileName);
2015-09-21 16:26:05 +00:00
_fileSystem.CreateDirectory(Path.GetDirectoryName(recordPath));
2015-07-20 18:32:55 +00:00
2015-07-29 03:42:03 +00:00
var recording = _recordingProvider.GetAll().FirstOrDefault(x => string.Equals(x.ProgramId, info.Id, StringComparison.OrdinalIgnoreCase));
2015-07-20 18:32:55 +00:00
if (recording == null)
{
2015-08-04 14:26:36 +00:00
recording = new RecordingInfo
2015-07-20 18:32:55 +00:00
{
ChannelId = info.ChannelId,
2015-07-29 03:42:03 +00:00
Id = Guid.NewGuid().ToString("N"),
2015-07-20 18:32:55 +00:00
StartDate = info.StartDate,
EndDate = info.EndDate,
2015-08-04 14:26:36 +00:00
Genres = info.Genres,
2015-07-20 18:32:55 +00:00
IsKids = info.IsKids,
IsLive = info.IsLive,
IsMovie = info.IsMovie,
IsHD = info.IsHD,
IsNews = info.IsNews,
IsPremiere = info.IsPremiere,
IsSeries = info.IsSeries,
IsSports = info.IsSports,
IsRepeat = !info.IsPremiere,
Name = info.Name,
2015-08-04 14:26:36 +00:00
EpisodeTitle = info.EpisodeTitle,
2015-07-20 18:32:55 +00:00
ProgramId = info.Id,
2015-08-04 14:26:36 +00:00
HasImage = info.HasImage,
ImagePath = info.ImagePath,
2015-07-20 18:32:55 +00:00
ImageUrl = info.ImageUrl,
OriginalAirDate = info.OriginalAirDate,
Status = RecordingStatus.Scheduled,
Overview = info.Overview,
2015-08-11 17:47:29 +00:00
SeriesTimerId = timer.SeriesTimerId,
TimerId = timer.Id,
ShowId = info.ShowId
2015-07-20 18:32:55 +00:00
};
_recordingProvider.Add(recording);
}
recording.Path = recordPath;
recording.Status = RecordingStatus.InProgress;
2015-08-18 15:25:57 +00:00
recording.DateLastUpdated = DateTime.UtcNow;
2015-07-20 18:32:55 +00:00
_recordingProvider.Update(recording);
2015-08-31 23:47:47 +00:00
_logger.Info("Beginning recording.");
2015-09-21 16:26:05 +00:00
2015-07-20 18:32:55 +00:00
try
{
httpRequestOptions.BufferContent = false;
2015-07-29 20:31:15 +00:00
var durationToken = new CancellationTokenSource(duration);
var linkedToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, durationToken.Token).Token;
httpRequestOptions.CancellationToken = linkedToken;
2015-07-20 18:32:55 +00:00
_logger.Info("Writing file to path: " + recordPath);
using (var response = await _httpClient.SendAsync(httpRequestOptions, "GET"))
{
2015-09-21 16:26:05 +00:00
using (var output = _fileSystem.GetFileStream(recordPath, FileMode.Create, FileAccess.Write, FileShare.Read))
2015-07-20 18:32:55 +00:00
{
2015-08-17 16:52:56 +00:00
await response.Content.CopyToAsync(output, StreamDefaults.DefaultCopyToBufferSize, linkedToken);
2015-07-20 18:32:55 +00:00
}
}
recording.Status = RecordingStatus.Completed;
2015-08-05 03:43:54 +00:00
_logger.Info("Recording completed");
2015-07-20 18:32:55 +00:00
}
catch (OperationCanceledException)
{
2015-08-18 15:25:57 +00:00
_logger.Info("Recording stopped");
2015-07-29 20:31:15 +00:00
recording.Status = RecordingStatus.Completed;
2015-07-20 18:32:55 +00:00
}
2015-08-05 03:43:54 +00:00
catch (Exception ex)
2015-07-20 18:32:55 +00:00
{
2015-08-05 03:43:54 +00:00
_logger.ErrorException("Error recording", ex);
2015-07-20 18:32:55 +00:00
recording.Status = RecordingStatus.Error;
}
2015-09-04 01:34:57 +00:00
finally
{
CancellationTokenSource removed;
_activeRecordings.TryRemove(timer.Id, out removed);
}
2015-07-20 18:32:55 +00:00
2015-08-18 15:25:57 +00:00
recording.DateLastUpdated = DateTime.UtcNow;
2015-07-20 18:32:55 +00:00
_recordingProvider.Update(recording);
2015-08-22 19:46:55 +00:00
if (recording.Status == RecordingStatus.Completed)
{
OnSuccessfulRecording(recording);
2015-09-03 01:40:47 +00:00
_timerProvider.Delete(timer);
}
2015-09-04 01:34:57 +00:00
else if (DateTime.UtcNow < timer.EndDate)
2015-09-03 01:40:47 +00:00
{
2015-09-04 01:34:57 +00:00
const int retryIntervalSeconds = 60;
_logger.Info("Retrying recording in {0} seconds.", retryIntervalSeconds);
2015-09-03 01:40:47 +00:00
2015-09-04 01:34:57 +00:00
_timerProvider.StartTimer(timer, TimeSpan.FromSeconds(retryIntervalSeconds));
}
else
{
_timerProvider.Delete(timer);
_recordingProvider.Delete(recording);
2015-08-22 19:46:55 +00:00
}
}
private async void OnSuccessfulRecording(RecordingInfo recording)
{
if (GetConfiguration().EnableAutoOrganize)
{
if (recording.IsSeries)
{
try
{
var organize = new EpisodeFileOrganizer(_organizationService, _config, _fileSystem, _logger, _libraryManager, _libraryMonitor, _providerManager);
var result = await organize.OrganizeEpisodeFile(recording.Path, CancellationToken.None).ConfigureAwait(false);
if (result.Status == FileSortingStatus.Success)
{
_recordingProvider.Delete(recording);
}
}
catch (Exception ex)
{
_logger.ErrorException("Error processing new recording", ex);
}
}
}
2015-07-20 18:32:55 +00:00
}
private ProgramInfo GetProgramInfoFromCache(string channelId, string programId)
{
var epgData = GetEpgDataForChannel(channelId);
2015-08-18 04:22:45 +00:00
return epgData.FirstOrDefault(p => string.Equals(p.Id, programId, StringComparison.OrdinalIgnoreCase));
2015-07-20 18:32:55 +00:00
}
private string RecordingPath
{
get
{
var path = GetConfiguration().RecordingPath;
return string.IsNullOrWhiteSpace(path)
? Path.Combine(DataPath, "recordings")
: path;
}
}
private LiveTvOptions GetConfiguration()
{
return _config.GetConfiguration<LiveTvOptions>("livetv");
}
2015-08-16 22:03:22 +00:00
private async Task UpdateTimersForSeriesTimer(List<ProgramInfo> epgData, SeriesTimerInfo seriesTimer)
2015-07-20 18:32:55 +00:00
{
2015-08-21 19:25:35 +00:00
var registration = await GetRegistrationInfo("seriesrecordings").ConfigureAwait(false);
if (registration.IsValid)
2015-07-20 18:32:55 +00:00
{
2015-08-22 02:59:10 +00:00
var newTimers = GetTimersForSeries(seriesTimer, epgData, _recordingProvider.GetAll()).ToList();
2015-08-21 19:25:35 +00:00
foreach (var timer in newTimers)
{
_timerProvider.AddOrUpdate(timer);
}
2015-07-20 18:32:55 +00:00
}
}
2015-07-29 17:16:00 +00:00
private IEnumerable<TimerInfo> GetTimersForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> allPrograms, IReadOnlyList<RecordingInfo> currentRecordings)
{
2015-08-17 16:52:56 +00:00
// Exclude programs that have already ended
allPrograms = allPrograms.Where(i => i.EndDate > DateTime.UtcNow);
2015-07-29 17:16:00 +00:00
allPrograms = GetProgramsForSeries(seriesTimer, allPrograms);
2015-08-18 04:22:45 +00:00
var recordingShowIds = currentRecordings.Select(i => i.ProgramId).Where(i => !string.IsNullOrWhiteSpace(i)).ToList();
2015-08-11 17:47:29 +00:00
2015-08-18 04:22:45 +00:00
allPrograms = allPrograms.Where(i => !recordingShowIds.Contains(i.Id, StringComparer.OrdinalIgnoreCase));
2015-07-29 17:16:00 +00:00
return allPrograms.Select(i => RecordingHelper.CreateTimer(i, seriesTimer));
}
private IEnumerable<ProgramInfo> GetProgramsForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> allPrograms)
{
if (!seriesTimer.RecordAnyTime)
{
allPrograms = allPrograms.Where(epg => (seriesTimer.StartDate.TimeOfDay == epg.StartDate.TimeOfDay));
}
if (seriesTimer.RecordNewOnly)
{
2015-08-16 18:37:53 +00:00
allPrograms = allPrograms.Where(epg => !epg.IsRepeat);
2015-07-29 17:16:00 +00:00
}
if (!seriesTimer.RecordAnyChannel)
{
allPrograms = allPrograms.Where(epg => string.Equals(epg.ChannelId, seriesTimer.ChannelId, StringComparison.OrdinalIgnoreCase));
}
2015-08-18 16:32:18 +00:00
allPrograms = allPrograms.Where(i => seriesTimer.Days.Contains(i.StartDate.ToLocalTime().DayOfWeek));
2015-07-29 17:16:00 +00:00
2015-08-16 18:37:53 +00:00
if (string.IsNullOrWhiteSpace(seriesTimer.SeriesId))
{
_logger.Error("seriesTimer.SeriesId is null. Cannot find programs for series");
return new List<ProgramInfo>();
}
2015-08-15 21:58:52 +00:00
return allPrograms.Where(i => string.Equals(i.SeriesId, seriesTimer.SeriesId, StringComparison.OrdinalIgnoreCase));
2015-07-29 17:16:00 +00:00
}
2015-08-02 23:47:31 +00:00
2015-07-20 18:32:55 +00:00
private string GetChannelEpgCachePath(string channelId)
{
return Path.Combine(DataPath, "epg", channelId + ".json");
}
private readonly object _epgLock = new object();
private void SaveEpgDataForChannel(string channelId, List<ProgramInfo> epgData)
{
var path = GetChannelEpgCachePath(channelId);
2015-09-21 16:26:05 +00:00
_fileSystem.CreateDirectory(Path.GetDirectoryName(path));
2015-07-20 18:32:55 +00:00
lock (_epgLock)
{
_jsonSerializer.SerializeToFile(epgData, path);
}
}
private List<ProgramInfo> GetEpgDataForChannel(string channelId)
{
try
{
lock (_epgLock)
{
return _jsonSerializer.DeserializeFromFile<List<ProgramInfo>>(GetChannelEpgCachePath(channelId));
}
}
catch
{
return new List<ProgramInfo>();
}
}
2015-08-15 21:58:52 +00:00
private List<ProgramInfo> GetEpgDataForChannels(List<string> channelIds)
2015-07-20 18:32:55 +00:00
{
2015-08-15 21:58:52 +00:00
return channelIds.SelectMany(GetEpgDataForChannel).ToList();
2015-07-20 18:32:55 +00:00
}
public void Dispose()
{
foreach (var pair in _activeRecordings.ToList())
{
pair.Value.Cancel();
}
}
2015-08-21 19:25:35 +00:00
public Task<MBRegistrationRecord> GetRegistrationInfo(string feature)
{
if (string.Equals(feature, "seriesrecordings", StringComparison.OrdinalIgnoreCase))
{
return _security.GetRegistrationStatus("embytvseriesrecordings");
}
return Task.FromResult(new MBRegistrationRecord
{
IsValid = true,
IsRegistered = true
});
}
2015-07-20 18:32:55 +00:00
}
2015-09-21 16:26:05 +00:00
}