Merge branch 'dev' of https://github.com/hatharry/Emby.git

34 files changed, 3541 insertions, 932 deletions

diff --git a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/DirectRecorder.cs b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/DirectRecorder.cs
index b21aa904b..0f8c15e71 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/DirectRecorder.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/DirectRecorder.cs
@@ -47,25 +47,60 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
                     _logger.Info("Copying recording stream to file {0}", targetFile);
 
-                    if (mediaSource.RunTimeTicks.HasValue)
-                    {
-                        // The media source already has a fixed duration
-                        // But add another stop 1 minute later just in case the recording gets stuck for any reason
-                        var durationToken = new CancellationTokenSource(duration.Add(TimeSpan.FromMinutes(1)));
-                        cancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, durationToken.Token).Token;
-                    }
-                    else
-                    {
-                        // The media source if infinite so we need to handle stopping ourselves
-                        var durationToken = new CancellationTokenSource(duration);
-                        cancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, durationToken.Token).Token;
-                    }
-
-                    await response.Content.CopyToAsync(output, StreamDefaults.DefaultCopyToBufferSize, cancellationToken).ConfigureAwait(false);
+                    // The media source if infinite so we need to handle stopping ourselves
+                    var durationToken = new CancellationTokenSource(duration);
+                    cancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, durationToken.Token).Token;
+
+                    await CopyUntilCancelled(response.Content, output, cancellationToken).ConfigureAwait(false);
                 }
             }
 
             _logger.Info("Recording completed to file {0}", targetFile);
         }
+
+        private const int BufferSize = 81920;
+        public static Task CopyUntilCancelled(Stream source, Stream target, CancellationToken cancellationToken)
+        {
+            return CopyUntilCancelled(source, target, null, cancellationToken);
+        }
+        public static async Task CopyUntilCancelled(Stream source, Stream target, Action onStarted, CancellationToken cancellationToken)
+        {
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                var bytesRead = await CopyToAsyncInternal(source, target, BufferSize, onStarted, cancellationToken).ConfigureAwait(false);
+
+                onStarted = null;
+
+                //var position = fs.Position;
+                //_logger.Debug("Streamed {0} bytes to position {1} from file {2}", bytesRead, position, path);
+
+                if (bytesRead == 0)
+                {
+                    await Task.Delay(100).ConfigureAwait(false);
+                }
+            }
+        }
+
+        private static async Task<int> CopyToAsyncInternal(Stream source, Stream destination, Int32 bufferSize, Action onStarted, CancellationToken cancellationToken)
+        {
+            byte[] buffer = new byte[bufferSize];
+            int bytesRead;
+            int totalBytesRead = 0;
+
+            while ((bytesRead = await source.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false)) != 0)
+            {
+                await destination.WriteAsync(buffer, 0, bytesRead, cancellationToken).ConfigureAwait(false);
+
+                totalBytesRead += bytesRead;
+
+                if (onStarted != null)
+                {
+                    onStarted();
+                }
+                onStarted = null;
+            }
+
+            return totalBytesRead;
+        }
     }
 }
diff --git a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/EmbyTV.cs b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/EmbyTV.cs
index 6acb0783e..9781775d5 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/EmbyTV.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/EmbyTV.cs
@@ -22,20 +22,24 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Xml;
 using CommonIO;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.TV;
-using MediaBrowser.Controller.Power;
 using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.FileOrganization;
 using Microsoft.Win32;
 
 namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 {
-    public class EmbyTV : ILiveTvService, ISupportsNewTimerIds, IHasRegistrationInfo, IDisposable
+    public class EmbyTV : ILiveTvService, ISupportsDirectStreamProvider, ISupportsNewTimerIds, IDisposable
     {
-        private readonly IApplicationHost _appHpst;
+        private readonly IServerApplicationHost _appHost;
         private readonly ILogger _logger;
         private readonly IHttpClient _httpClient;
         private readonly IServerConfigurationManager _config;
@@ -46,7 +50,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
         private readonly LiveTvManager _liveTvManager;
         private readonly IFileSystem _fileSystem;
-        private readonly ISecurityManager _security;
 
         private readonly ILibraryMonitor _libraryMonitor;
         private readonly ILibraryManager _libraryManager;
@@ -62,16 +65,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
         private readonly ConcurrentDictionary<string, ActiveRecordingInfo> _activeRecordings =
             new ConcurrentDictionary<string, ActiveRecordingInfo>(StringComparer.OrdinalIgnoreCase);
 
-        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, IPowerManagement powerManagement)
+        public EmbyTV(IServerApplicationHost appHost, ILogger logger, IJsonSerializer jsonSerializer, IHttpClient httpClient, IServerConfigurationManager config, ILiveTvManager liveTvManager, IFileSystem fileSystem, ILibraryManager libraryManager, ILibraryMonitor libraryMonitor, IProviderManager providerManager, IFileOrganizationService organizationService, IMediaEncoder mediaEncoder)
         {
             Current = this;
 
-            _appHpst = appHost;
+            _appHost = appHost;
             _logger = logger;
             _httpClient = httpClient;
             _config = config;
             _fileSystem = fileSystem;
-            _security = security;
             _libraryManager = libraryManager;
             _libraryMonitor = libraryMonitor;
             _providerManager = providerManager;
@@ -81,7 +83,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             _jsonSerializer = jsonSerializer;
 
             _seriesTimerProvider = new SeriesTimerManager(fileSystem, jsonSerializer, _logger, Path.Combine(DataPath, "seriestimers"));
-            _timerProvider = new TimerManager(fileSystem, jsonSerializer, _logger, Path.Combine(DataPath, "timers"), powerManagement, _logger);
+            _timerProvider = new TimerManager(fileSystem, jsonSerializer, _logger, Path.Combine(DataPath, "timers"), _logger);
             _timerProvider.TimerFired += _timerProvider_TimerFired;
 
             _config.NamedConfigurationUpdated += _config_NamedConfigurationUpdated;
@@ -142,9 +144,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                     continue;
                 }
 
+                var mediaPathInfos = pathsToCreate.Select(i => new MediaPathInfo { Path = i }).ToArray();
+
+                var libraryOptions = new LibraryOptions
+                {
+                    PathInfos = mediaPathInfos
+                };
                 try
                 {
-                    _libraryManager.AddVirtualFolder(recordingFolder.Name, recordingFolder.CollectionType, pathsToCreate.ToArray(), new LibraryOptions(), true);
+                    _libraryManager.AddVirtualFolder(recordingFolder.Name, recordingFolder.CollectionType, libraryOptions, true);
                 }
                 catch (Exception ex)
                 {
@@ -286,7 +294,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
             status.Tuners = list;
             status.Status = LiveTvServiceStatus.Ok;
-            status.Version = _appHpst.ApplicationVersion.ToString();
+            status.Version = _appHost.ApplicationVersion.ToString();
             status.IsVisible = false;
             return status;
         }
@@ -323,27 +331,25 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             {
                 if (DateTime.UtcNow > timer.EndDate && !_activeRecordings.ContainsKey(timer.Id))
                 {
-                    _timerProvider.Delete(timer);
+                    OnTimerOutOfDate(timer);
                 }
             }
         }
 
-        private List<ChannelInfo> _channelCache = null;
-        private async Task<IEnumerable<ChannelInfo>> GetChannelsAsync(bool enableCache, CancellationToken cancellationToken)
+        private void OnTimerOutOfDate(TimerInfo timer)
         {
-            if (enableCache && _channelCache != null)
-            {
-
-                return _channelCache.ToList();
-            }
+            _timerProvider.Delete(timer);
+        }
 
+        private async Task<IEnumerable<ChannelInfo>> GetChannelsAsync(bool enableCache, CancellationToken cancellationToken)
+        {
             var list = new List<ChannelInfo>();
 
             foreach (var hostInstance in _liveTvManager.TunerHosts)
             {
                 try
                 {
-                    var channels = await hostInstance.GetChannels(cancellationToken).ConfigureAwait(false);
+                    var channels = await hostInstance.GetChannels(enableCache, cancellationToken).ConfigureAwait(false);
 
                     list.AddRange(channels);
                 }
@@ -376,7 +382,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 }
             }
 
-            _channelCache = list.ToList();
             return list;
         }
 
@@ -388,7 +393,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             {
                 try
                 {
-                    var channels = await hostInstance.GetChannels(cancellationToken).ConfigureAwait(false);
+                    var channels = await hostInstance.GetChannels(false, cancellationToken).ConfigureAwait(false);
 
                     list.AddRange(channels);
                 }
@@ -417,7 +422,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
             foreach (var timer in timers)
             {
-                CancelTimerInternal(timer.Id);
+                CancelTimerInternal(timer.Id, true);
             }
 
             var remove = _seriesTimerProvider.GetAll().FirstOrDefault(r => string.Equals(r.Id, timerId, StringComparison.OrdinalIgnoreCase));
@@ -428,12 +433,20 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             return Task.FromResult(true);
         }
 
-        private void CancelTimerInternal(string timerId)
+        private void CancelTimerInternal(string timerId, bool isSeriesCancelled)
         {
-            var remove = _timerProvider.GetAll().FirstOrDefault(r => string.Equals(r.Id, timerId, StringComparison.OrdinalIgnoreCase));
-            if (remove != null)
+            var timer = _timerProvider.GetTimer(timerId);
+            if (timer != null)
             {
-                _timerProvider.Delete(remove);
+                if (string.IsNullOrWhiteSpace(timer.SeriesTimerId) || isSeriesCancelled)
+                {
+                    _timerProvider.Delete(timer);
+                }
+                else
+                {
+                    timer.Status = RecordingStatus.Cancelled;
+                    _timerProvider.AddOrUpdate(timer, false);
+                }
             }
             ActiveRecordingInfo activeRecordingInfo;
 
@@ -445,7 +458,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
         public Task CancelTimerAsync(string timerId, CancellationToken cancellationToken)
         {
-            CancelTimerInternal(timerId);
+            CancelTimerInternal(timerId, false);
             return Task.FromResult(true);
         }
 
@@ -454,21 +467,57 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             return Task.FromResult(true);
         }
 
-        public Task CreateTimerAsync(TimerInfo info, CancellationToken cancellationToken)
+        public Task CreateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
         {
-            return CreateTimer(info, cancellationToken);
+            throw new NotImplementedException();
         }
 
-        public Task CreateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
+        public Task CreateTimerAsync(TimerInfo info, CancellationToken cancellationToken)
         {
-            return CreateSeriesTimer(info, cancellationToken);
+            throw new NotImplementedException();
         }
 
-        public Task<string> CreateTimer(TimerInfo info, CancellationToken cancellationToken)
+        public Task<string> CreateTimer(TimerInfo timer, CancellationToken cancellationToken)
         {
-            info.Id = Guid.NewGuid().ToString("N");
-            _timerProvider.Add(info);
-            return Task.FromResult(info.Id);
+            var existingTimer = _timerProvider.GetAll()
+                .FirstOrDefault(i => string.Equals(timer.ProgramId, i.ProgramId, StringComparison.OrdinalIgnoreCase));
+
+            if (existingTimer != null)
+            {
+                if (existingTimer.Status == RecordingStatus.Cancelled ||
+                    existingTimer.Status == RecordingStatus.Completed)
+                {
+                    existingTimer.Status = RecordingStatus.New;
+                    _timerProvider.Update(existingTimer);
+                    return Task.FromResult(existingTimer.Id);
+                }
+                else
+                {
+                    throw new ArgumentException("A scheduled recording already exists for this program.");
+                }
+            }
+
+            timer.Id = Guid.NewGuid().ToString("N");
+
+            ProgramInfo programInfo = null;
+
+            if (!string.IsNullOrWhiteSpace(timer.ProgramId))
+            {
+                programInfo = GetProgramInfoFromCache(timer.ChannelId, timer.ProgramId);
+            }
+            if (programInfo == null)
+            {
+                _logger.Info("Unable to find program with Id {0}. Will search using start date", timer.ProgramId);
+                programInfo = GetProgramInfoFromCache(timer.ChannelId, timer.StartDate);
+            }
+
+            if (programInfo != null)
+            {
+                RecordingHelper.CopyProgramInfoToTimerInfo(programInfo, timer);
+            }
+
+            _timerProvider.Add(timer);
+            return Task.FromResult(timer.Id);
         }
 
         public async Task<string> CreateSeriesTimer(SeriesTimerInfo info, CancellationToken cancellationToken)
@@ -522,6 +571,9 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 instance.RecordAnyChannel = info.RecordAnyChannel;
                 instance.RecordAnyTime = info.RecordAnyTime;
                 instance.RecordNewOnly = info.RecordNewOnly;
+                instance.SkipEpisodesInLibrary = info.SkipEpisodesInLibrary;
+                instance.KeepUpTo = info.KeepUpTo;
+                instance.KeepUntil = info.KeepUntil;
                 instance.StartDate = info.StartDate;
 
                 _seriesTimerProvider.Update(instance);
@@ -542,12 +594,55 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             }
         }
 
-        public Task UpdateTimerAsync(TimerInfo info, CancellationToken cancellationToken)
+        public Task UpdateTimerAsync(TimerInfo updatedTimer, CancellationToken cancellationToken)
         {
-            _timerProvider.Update(info);
+            var existingTimer = _timerProvider.GetTimer(updatedTimer.Id);
+
+            if (existingTimer == null)
+            {
+                throw new ResourceNotFoundException();
+            }
+
+            // Only update if not currently active
+            ActiveRecordingInfo activeRecordingInfo;
+            if (!_activeRecordings.TryGetValue(updatedTimer.Id, out activeRecordingInfo))
+            {
+                existingTimer.PrePaddingSeconds = updatedTimer.PrePaddingSeconds;
+                existingTimer.PostPaddingSeconds = updatedTimer.PostPaddingSeconds;
+                existingTimer.IsPostPaddingRequired = updatedTimer.IsPostPaddingRequired;
+                existingTimer.IsPrePaddingRequired = updatedTimer.IsPrePaddingRequired;
+            }
+
             return Task.FromResult(true);
         }
 
+        private void UpdateExistingTimerWithNewMetadata(TimerInfo existingTimer, TimerInfo updatedTimer)
+        {
+            // Update the program info but retain the status
+            existingTimer.ChannelId = updatedTimer.ChannelId;
+            existingTimer.CommunityRating = updatedTimer.CommunityRating;
+            existingTimer.EndDate = updatedTimer.EndDate;
+            existingTimer.EpisodeNumber = updatedTimer.EpisodeNumber;
+            existingTimer.EpisodeTitle = updatedTimer.EpisodeTitle;
+            existingTimer.Genres = updatedTimer.Genres;
+            existingTimer.HomePageUrl = updatedTimer.HomePageUrl;
+            existingTimer.IsKids = updatedTimer.IsKids;
+            existingTimer.IsNews = updatedTimer.IsNews;
+            existingTimer.IsMovie = updatedTimer.IsMovie;
+            existingTimer.IsProgramSeries = updatedTimer.IsProgramSeries;
+            existingTimer.IsRepeat = updatedTimer.IsRepeat;
+            existingTimer.IsSports = updatedTimer.IsSports;
+            existingTimer.Name = updatedTimer.Name;
+            existingTimer.OfficialRating = updatedTimer.OfficialRating;
+            existingTimer.OriginalAirDate = updatedTimer.OriginalAirDate;
+            existingTimer.Overview = updatedTimer.Overview;
+            existingTimer.ProductionYear = updatedTimer.ProductionYear;
+            existingTimer.ProgramId = updatedTimer.ProgramId;
+            existingTimer.SeasonNumber = updatedTimer.SeasonNumber;
+            existingTimer.ShortOverview = updatedTimer.ShortOverview;
+            existingTimer.StartDate = updatedTimer.StartDate;
+        }
+
         public Task<ImageStream> GetChannelImageAsync(string channelId, CancellationToken cancellationToken)
         {
             throw new NotImplementedException();
@@ -565,12 +660,76 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
         public async Task<IEnumerable<RecordingInfo>> GetRecordingsAsync(CancellationToken cancellationToken)
         {
-            return new List<RecordingInfo>();
+            return _activeRecordings.Values.ToList().Select(GetRecordingInfo).ToList();
+        }
+
+        public string GetActiveRecordingPath(string id)
+        {
+            ActiveRecordingInfo info;
+
+            if (_activeRecordings.TryGetValue(id, out info))
+            {
+                return info.Path;
+            }
+            return null;
+        }
+
+        private RecordingInfo GetRecordingInfo(ActiveRecordingInfo info)
+        {
+            var timer = info.Timer;
+            var program = info.Program;
+
+            var result = new RecordingInfo
+            {
+                ChannelId = timer.ChannelId,
+                CommunityRating = timer.CommunityRating,
+                DateLastUpdated = DateTime.UtcNow,
+                EndDate = timer.EndDate,
+                EpisodeTitle = timer.EpisodeTitle,
+                Genres = timer.Genres,
+                Id = "recording" + timer.Id,
+                IsKids = timer.IsKids,
+                IsMovie = timer.IsMovie,
+                IsNews = timer.IsNews,
+                IsRepeat = timer.IsRepeat,
+                IsSeries = timer.IsProgramSeries,
+                IsSports = timer.IsSports,
+                Name = timer.Name,
+                OfficialRating = timer.OfficialRating,
+                OriginalAirDate = timer.OriginalAirDate,
+                Overview = timer.Overview,
+                ProgramId = timer.ProgramId,
+                SeriesTimerId = timer.SeriesTimerId,
+                StartDate = timer.StartDate,
+                Status = RecordingStatus.InProgress,
+                TimerId = timer.Id
+            };
+
+            if (program != null)
+            {
+                result.Audio = program.Audio;
+                result.ImagePath = program.ImagePath;
+                result.ImageUrl = program.ImageUrl;
+                result.IsHD = program.IsHD;
+                result.IsLive = program.IsLive;
+                result.IsPremiere = program.IsPremiere;
+                result.ShowId = program.ShowId;
+            }
+
+            return result;
         }
 
         public Task<IEnumerable<TimerInfo>> GetTimersAsync(CancellationToken cancellationToken)
         {
-            return Task.FromResult((IEnumerable<TimerInfo>)_timerProvider.GetAll());
+            var excludeStatues = new List<RecordingStatus>
+            {
+                RecordingStatus.Completed
+            };
+
+            var timers = _timerProvider.GetAll()
+                .Where(i => !excludeStatues.Contains(i.Status));
+
+            return Task.FromResult(timers);
         }
 
         public Task<SeriesTimerInfo> GetNewTimerDefaultsAsync(CancellationToken cancellationToken, ProgramInfo program = null)
@@ -583,7 +742,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 PrePaddingSeconds = Math.Max(config.PrePaddingSeconds, 0),
                 RecordAnyChannel = true,
                 RecordAnyTime = true,
-                RecordNewOnly = false,
+                RecordNewOnly = true,
 
                 Days = new List<DayOfWeek>
                 {
@@ -603,6 +762,9 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 defaults.ProgramId = program.Id;
             }
 
+            defaults.SkipEpisodesInLibrary = true;
+            defaults.KeepUntil = KeepUntil.UntilDeleted;
+
             return Task.FromResult(defaults);
         }
 
@@ -719,46 +881,108 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             throw new NotImplementedException();
         }
 
+        private readonly SemaphoreSlim _liveStreamsSemaphore = new SemaphoreSlim(1, 1);
+        private readonly List<LiveStream> _liveStreams = new List<LiveStream>();
+
         public async Task<MediaSourceInfo> GetChannelStream(string channelId, string streamId, CancellationToken cancellationToken)
         {
-            _logger.Info("Streaming Channel " + channelId);
+            var result = await GetChannelStreamWithDirectStreamProvider(channelId, streamId, cancellationToken).ConfigureAwait(false);
 
-            foreach (var hostInstance in _liveTvManager.TunerHosts)
-            {
-                try
-                {
-                    var result = await hostInstance.GetChannelStream(channelId, streamId, cancellationToken).ConfigureAwait(false);
+            return result.Item1;
+        }
 
-                    result.Item2.Release();
+        public async Task<Tuple<MediaSourceInfo, IDirectStreamProvider>> GetChannelStreamWithDirectStreamProvider(string channelId, string streamId, CancellationToken cancellationToken)
+        {
+            var result = await GetChannelStreamInternal(channelId, streamId, cancellationToken).ConfigureAwait(false);
 
-                    return result.Item1;
-                }
-                catch (Exception e)
-                {
-                    _logger.ErrorException("Error getting channel stream", e);
-                }
+            return new Tuple<MediaSourceInfo, IDirectStreamProvider>(result.Item2, result.Item1 as IDirectStreamProvider);
+        }
+
+        private MediaSourceInfo CloneMediaSource(MediaSourceInfo mediaSource, bool enableStreamSharing)
+        {
+            var json = _jsonSerializer.SerializeToString(mediaSource);
+            mediaSource = _jsonSerializer.DeserializeFromString<MediaSourceInfo>(json);
+
+            mediaSource.Id = Guid.NewGuid().ToString("N") + "_" + mediaSource.Id;
+
+            //if (mediaSource.DateLiveStreamOpened.HasValue && enableStreamSharing)
+            //{
+            //    var ticks = (DateTime.UtcNow - mediaSource.DateLiveStreamOpened.Value).Ticks - TimeSpan.FromSeconds(10).Ticks;
+            //    ticks = Math.Max(0, ticks);
+            //    mediaSource.Path += "?t=" + ticks.ToString(CultureInfo.InvariantCulture) + "&s=" + mediaSource.DateLiveStreamOpened.Value.Ticks.ToString(CultureInfo.InvariantCulture);
+            //}
+
+            return mediaSource;
+        }
+
+        public async Task<LiveStream> GetLiveStream(string uniqueId)
+        {
+            await _liveStreamsSemaphore.WaitAsync().ConfigureAwait(false);
+
+            try
+            {
+                return _liveStreams
+                    .FirstOrDefault(i => string.Equals(i.UniqueId, uniqueId, StringComparison.OrdinalIgnoreCase));
+            }
+            finally
+            {
+                _liveStreamsSemaphore.Release();
             }
 
-            throw new ApplicationException("Tuner not found.");
         }
 
-        private async Task<Tuple<MediaSourceInfo, ITunerHost, SemaphoreSlim>> GetChannelStreamInternal(string channelId, string streamId, CancellationToken cancellationToken)
+        private async Task<Tuple<LiveStream, MediaSourceInfo, ITunerHost>> GetChannelStreamInternal(string channelId, string streamId, CancellationToken cancellationToken)
         {
             _logger.Info("Streaming Channel " + channelId);
 
-            foreach (var hostInstance in _liveTvManager.TunerHosts)
+            await _liveStreamsSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+            var result = _liveStreams.FirstOrDefault(i => string.Equals(i.OriginalStreamId, streamId, StringComparison.OrdinalIgnoreCase));
+
+            if (result != null && result.EnableStreamSharing)
             {
-                try
-                {
-                    var result = await hostInstance.GetChannelStream(channelId, streamId, cancellationToken).ConfigureAwait(false);
+                var openedMediaSource = CloneMediaSource(result.OpenedMediaSource, result.EnableStreamSharing);
+                result.SharedStreamIds.Add(openedMediaSource.Id);
+                _liveStreamsSemaphore.Release();
 
-                    return new Tuple<MediaSourceInfo, ITunerHost, SemaphoreSlim>(result.Item1, hostInstance, result.Item2);
-                }
-                catch (Exception e)
+                _logger.Info("Live stream {0} consumer count is now {1}", streamId, result.ConsumerCount);
+
+                return new Tuple<LiveStream, MediaSourceInfo, ITunerHost>(result, openedMediaSource, result.TunerHost);
+            }
+
+            try
+            {
+                foreach (var hostInstance in _liveTvManager.TunerHosts)
                 {
-                    _logger.ErrorException("Error getting channel stream", e);
+                    try
+                    {
+                        result = await hostInstance.GetChannelStream(channelId, streamId, cancellationToken).ConfigureAwait(false);
+
+                        var openedMediaSource = CloneMediaSource(result.OpenedMediaSource, result.EnableStreamSharing);
+
+                        result.SharedStreamIds.Add(openedMediaSource.Id);
+                        _liveStreams.Add(result);
+
+                        result.TunerHost = hostInstance;
+                        result.OriginalStreamId = streamId;
+
+                        _logger.Info("Returning mediasource streamId {0}, mediaSource.Id {1}, mediaSource.LiveStreamId {2}",
+                            streamId, openedMediaSource.Id, openedMediaSource.LiveStreamId);
+
+                        return new Tuple<LiveStream, MediaSourceInfo, ITunerHost>(result, openedMediaSource, hostInstance);
+                    }
+                    catch (FileNotFoundException)
+                    {
+                    }
+                    catch (OperationCanceledException)
+                    {
+                    }
                 }
             }
+            finally
+            {
+                _liveStreamsSemaphore.Release();
+            }
 
             throw new ApplicationException("Tuner not found.");
         }
@@ -787,12 +1011,75 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
         public Task<List<MediaSourceInfo>> GetRecordingStreamMediaSources(string recordingId, CancellationToken cancellationToken)
         {
-            throw new NotImplementedException();
+            ActiveRecordingInfo info;
+
+            recordingId = recordingId.Replace("recording", string.Empty);
+
+            if (_activeRecordings.TryGetValue(recordingId, out info))
+            {
+                return Task.FromResult(new List<MediaSourceInfo>
+                {
+                    new MediaSourceInfo
+                    {
+                        Path = _appHost.GetLocalApiUrl("localhost") + "/LiveTv/LiveRecordings/" + recordingId + "/stream",
+                        Id = recordingId,
+                        SupportsDirectPlay = false,
+                        SupportsDirectStream = true,
+                        SupportsTranscoding = true,
+                        IsInfiniteStream = true,
+                        RequiresOpening = false,
+                        RequiresClosing = false,
+                        Protocol = Model.MediaInfo.MediaProtocol.Http,
+                        BufferMs = 0
+                    }
+                });
+            }
+
+            throw new FileNotFoundException();
         }
 
-        public Task CloseLiveStream(string id, CancellationToken cancellationToken)
+        public async Task CloseLiveStream(string id, CancellationToken cancellationToken)
         {
-            return Task.FromResult(0);
+            // Ignore the consumer id
+            //id = id.Substring(id.IndexOf('_') + 1);
+
+            await _liveStreamsSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+            try
+            {
+                var stream = _liveStreams.FirstOrDefault(i => i.SharedStreamIds.Contains(id));
+                if (stream != null)
+                {
+                    stream.SharedStreamIds.Remove(id);
+
+                    _logger.Info("Live stream {0} consumer count is now {1}", id, stream.ConsumerCount);
+
+                    if (stream.ConsumerCount <= 0)
+                    {
+                        _liveStreams.Remove(stream);
+
+                        _logger.Info("Closing live stream {0}", id);
+
+                        await stream.Close().ConfigureAwait(false);
+                        _logger.Info("Live stream {0} closed successfully", id);
+                    }
+                }
+                else
+                {
+                    _logger.Warn("Live stream not found: {0}, unable to close", id);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error closing live stream", ex);
+            }
+            finally
+            {
+                _liveStreamsSemaphore.Release();
+            }
         }
 
         public Task RecordLiveStream(string id, CancellationToken cancellationToken)
@@ -817,14 +1104,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
                 if (recordingEndDate <= DateTime.UtcNow)
                 {
-                    _logger.Warn("Recording timer fired for timer {0}, Id: {1}, but the program has already ended.", timer.Name, timer.Id);
+                    _logger.Warn("Recording timer fired for updatedTimer {0}, Id: {1}, but the program has already ended.", timer.Name, timer.Id);
+                    OnTimerOutOfDate(timer);
                     return;
                 }
 
                 var activeRecordingInfo = new ActiveRecordingInfo
                 {
                     CancellationTokenSource = new CancellationTokenSource(),
-                    TimerId = timer.Id
+                    Timer = timer
                 };
 
                 if (_activeRecordings.TryAdd(timer.Id, activeRecordingInfo))
@@ -846,14 +1134,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             }
         }
 
-        private string GetRecordingPath(TimerInfo timer, ProgramInfo info)
+        private string GetRecordingPath(TimerInfo timer, out string seriesPath)
         {
             var recordPath = RecordingPath;
             var config = GetConfiguration();
+            seriesPath = null;
 
-            if (info.IsMovie)
+            if (timer.IsProgramSeries)
             {
-                var customRecordingPath = config.MovieRecordingPath;
+                var customRecordingPath = config.SeriesRecordingPath;
                 var allowSubfolder = true;
                 if (!string.IsNullOrWhiteSpace(customRecordingPath))
                 {
@@ -863,19 +1152,25 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
                 if (allowSubfolder && config.EnableRecordingSubfolders)
                 {
-                    recordPath = Path.Combine(recordPath, "Movies");
+                    recordPath = Path.Combine(recordPath, "Series");
                 }
 
-                var folderName = _fileSystem.GetValidFilename(info.Name).Trim();
-                if (info.ProductionYear.HasValue)
+                var folderName = _fileSystem.GetValidFilename(timer.Name).Trim();
+
+                // Can't use the year here in the folder name because it is the year of the episode, not the series.
+                recordPath = Path.Combine(recordPath, folderName);
+
+                seriesPath = recordPath;
+
+                if (timer.SeasonNumber.HasValue)
                 {
-                    folderName += " (" + info.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
+                    folderName = string.Format("Season {0}", timer.SeasonNumber.Value.ToString(CultureInfo.InvariantCulture));
+                    recordPath = Path.Combine(recordPath, folderName);
                 }
-                recordPath = Path.Combine(recordPath, folderName);
             }
-            else if (info.IsSeries)
+            else if (timer.IsMovie)
             {
-                var customRecordingPath = config.SeriesRecordingPath;
+                var customRecordingPath = config.MovieRecordingPath;
                 var allowSubfolder = true;
                 if (!string.IsNullOrWhiteSpace(customRecordingPath))
                 {
@@ -885,52 +1180,37 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
                 if (allowSubfolder && config.EnableRecordingSubfolders)
                 {
-                    recordPath = Path.Combine(recordPath, "Series");
-                }
-
-                var folderName = _fileSystem.GetValidFilename(info.Name).Trim();
-                var folderNameWithYear = folderName;
-                if (info.ProductionYear.HasValue)
-                {
-                    folderNameWithYear += " (" + info.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
-                }
-
-                if (Directory.Exists(Path.Combine(recordPath, folderName)))
-                {
-                    recordPath = Path.Combine(recordPath, folderName);
-                }
-                else
-                {
-                    recordPath = Path.Combine(recordPath, folderNameWithYear);
+                    recordPath = Path.Combine(recordPath, "Movies");
                 }
 
-                if (info.SeasonNumber.HasValue)
+                var folderName = _fileSystem.GetValidFilename(timer.Name).Trim();
+                if (timer.ProductionYear.HasValue)
                 {
-                    folderName = string.Format("Season {0}", info.SeasonNumber.Value.ToString(CultureInfo.InvariantCulture));
-                    recordPath = Path.Combine(recordPath, folderName);
+                    folderName += " (" + timer.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
                 }
+                recordPath = Path.Combine(recordPath, folderName);
             }
-            else if (info.IsKids)
+            else if (timer.IsKids)
             {
                 if (config.EnableRecordingSubfolders)
                 {
                     recordPath = Path.Combine(recordPath, "Kids");
                 }
 
-                var folderName = _fileSystem.GetValidFilename(info.Name).Trim();
-                if (info.ProductionYear.HasValue)
+                var folderName = _fileSystem.GetValidFilename(timer.Name).Trim();
+                if (timer.ProductionYear.HasValue)
                 {
-                    folderName += " (" + info.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
+                    folderName += " (" + timer.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
                 }
                 recordPath = Path.Combine(recordPath, folderName);
             }
-            else if (info.IsSports)
+            else if (timer.IsSports)
             {
                 if (config.EnableRecordingSubfolders)
                 {
                     recordPath = Path.Combine(recordPath, "Sports");
                 }
-                recordPath = Path.Combine(recordPath, _fileSystem.GetValidFilename(info.Name).Trim());
+                recordPath = Path.Combine(recordPath, _fileSystem.GetValidFilename(timer.Name).Trim());
             }
             else
             {
@@ -938,54 +1218,55 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 {
                     recordPath = Path.Combine(recordPath, "Other");
                 }
-                recordPath = Path.Combine(recordPath, _fileSystem.GetValidFilename(info.Name).Trim());
+                recordPath = Path.Combine(recordPath, _fileSystem.GetValidFilename(timer.Name).Trim());
             }
 
-            var recordingFileName = _fileSystem.GetValidFilename(RecordingHelper.GetRecordingName(timer, info)).Trim() + ".ts";
+            var recordingFileName = _fileSystem.GetValidFilename(RecordingHelper.GetRecordingName(timer)).Trim() + ".ts";
 
             return Path.Combine(recordPath, recordingFileName);
         }
 
-        private async Task RecordStream(TimerInfo timer, DateTime recordingEndDate, ActiveRecordingInfo activeRecordingInfo, CancellationToken cancellationToken)
+        private async Task RecordStream(TimerInfo timer, DateTime recordingEndDate,
+            ActiveRecordingInfo activeRecordingInfo, CancellationToken cancellationToken)
         {
             if (timer == null)
             {
                 throw new ArgumentNullException("timer");
             }
 
-            ProgramInfo info = null;
+            ProgramInfo programInfo = null;
 
-            if (string.IsNullOrWhiteSpace(timer.ProgramId))
-            {
-                _logger.Info("Timer {0} has null programId", timer.Id);
-            }
-            else
+            if (!string.IsNullOrWhiteSpace(timer.ProgramId))
             {
-                info = GetProgramInfoFromCache(timer.ChannelId, timer.ProgramId);
+                programInfo = GetProgramInfoFromCache(timer.ChannelId, timer.ProgramId);
             }
-
-            if (info == null)
+            if (programInfo == null)
             {
                 _logger.Info("Unable to find program with Id {0}. Will search using start date", timer.ProgramId);
-                info = GetProgramInfoFromCache(timer.ChannelId, timer.StartDate);
+                programInfo = GetProgramInfoFromCache(timer.ChannelId, timer.StartDate);
             }
 
-            if (info == null)
+            if (programInfo != null)
             {
-                throw new InvalidOperationException(string.Format("Program with Id {0} not found", timer.ProgramId));
+                RecordingHelper.CopyProgramInfoToTimerInfo(programInfo, timer);
+                activeRecordingInfo.Program = programInfo;
             }
 
-            var recordPath = GetRecordingPath(timer, info);
+            string seriesPath = null;
+            var recordPath = GetRecordingPath(timer, out seriesPath);
             var recordingStatus = RecordingStatus.New;
-            var isResourceOpen = false;
-            SemaphoreSlim semaphore = null;
+
+            string liveStreamId = null;
 
             try
             {
-                var result = await GetChannelStreamInternal(timer.ChannelId, null, CancellationToken.None).ConfigureAwait(false);
-                isResourceOpen = true;
-                semaphore = result.Item3;
-                var mediaStreamInfo = result.Item1;
+                var allMediaSources = await GetChannelStreamMediaSources(timer.ChannelId, CancellationToken.None).ConfigureAwait(false);
+
+                var liveStreamInfo = await GetChannelStreamInternal(timer.ChannelId, allMediaSources[0].Id, CancellationToken.None)
+                            .ConfigureAwait(false);
+
+                var mediaStreamInfo = liveStreamInfo.Item2;
+                liveStreamId = mediaStreamInfo.Id;
 
                 // HDHR doesn't seem to release the tuner right away after first probing with ffmpeg
                 //await Task.Delay(3000, cancellationToken).ConfigureAwait(false);
@@ -995,13 +1276,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 recordPath = recorder.GetOutputPath(mediaStreamInfo, recordPath);
                 recordPath = EnsureFileUnique(recordPath, timer.Id);
 
+                _libraryManager.RegisterIgnoredPath(recordPath);
                 _libraryMonitor.ReportFileSystemChangeBeginning(recordPath);
                 _fileSystem.CreateDirectory(Path.GetDirectoryName(recordPath));
                 activeRecordingInfo.Path = recordPath;
 
                 var duration = recordingEndDate - DateTime.UtcNow;
 
-                _logger.Info("Beginning recording. Will record for {0} minutes.", duration.TotalMinutes.ToString(CultureInfo.InvariantCulture));
+                _logger.Info("Beginning recording. Will record for {0} minutes.",
+                    duration.TotalMinutes.ToString(CultureInfo.InvariantCulture));
 
                 _logger.Info("Writing file to path: " + recordPath);
                 _logger.Info("Opening recording stream from tuner provider");
@@ -1011,20 +1294,12 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                     timer.Status = RecordingStatus.InProgress;
                     _timerProvider.AddOrUpdate(timer, false);
 
-                    result.Item3.Release();
-                    isResourceOpen = false;
+                    SaveNfo(timer, recordPath, seriesPath);
+                    EnforceKeepUpTo(timer);
                 };
 
-                var pathWithDuration = result.Item2.ApplyDuration(mediaStreamInfo.Path, duration);
-
-                // If it supports supplying duration via url
-                if (!string.Equals(pathWithDuration, mediaStreamInfo.Path, StringComparison.OrdinalIgnoreCase))
-                {
-                    mediaStreamInfo.Path = pathWithDuration;
-                    mediaStreamInfo.RunTimeTicks = duration.Ticks;
-                }
-
-                await recorder.Record(mediaStreamInfo, recordPath, duration, onStarted, cancellationToken).ConfigureAwait(false);
+                await recorder.Record(mediaStreamInfo, recordPath, duration, onStarted, cancellationToken)
+                        .ConfigureAwait(false);
 
                 recordingStatus = RecordingStatus.Completed;
                 _logger.Info("Recording completed: {0}", recordPath);
@@ -1039,27 +1314,26 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 _logger.ErrorException("Error recording to {0}", ex, recordPath);
                 recordingStatus = RecordingStatus.Error;
             }
-            finally
+
+            if (!string.IsNullOrWhiteSpace(liveStreamId))
             {
-                if (isResourceOpen && semaphore != null)
+                try
                 {
-                    semaphore.Release();
+                    await CloseLiveStream(liveStreamId, CancellationToken.None).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error closing live stream", ex);
                 }
-
-                _libraryMonitor.ReportFileSystemChangeComplete(recordPath, true);
-
-                ActiveRecordingInfo removed;
-                _activeRecordings.TryRemove(timer.Id, out removed);
             }
 
-            if (recordingStatus == RecordingStatus.Completed)
-            {
-                timer.Status = RecordingStatus.Completed;
-                _timerProvider.Delete(timer);
+            _libraryManager.UnRegisterIgnoredPath(recordPath);
+            _libraryMonitor.ReportFileSystemChangeComplete(recordPath, true);
 
-                OnSuccessfulRecording(info.IsSeries, recordPath);
-            }
-            else if (DateTime.UtcNow < timer.EndDate)
+            ActiveRecordingInfo removed;
+            _activeRecordings.TryRemove(timer.Id, out removed);
+
+            if (recordingStatus != RecordingStatus.Completed && DateTime.UtcNow < timer.EndDate)
             {
                 const int retryIntervalSeconds = 60;
                 _logger.Info("Retrying recording in {0} seconds.", retryIntervalSeconds);
@@ -1068,12 +1342,115 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 timer.StartDate = DateTime.UtcNow.AddSeconds(retryIntervalSeconds);
                 _timerProvider.AddOrUpdate(timer);
             }
+            else if (File.Exists(recordPath))
+            {
+                timer.RecordingPath = recordPath;
+                timer.Status = RecordingStatus.Completed;
+                _timerProvider.AddOrUpdate(timer, false);
+                OnSuccessfulRecording(timer, recordPath);
+            }
             else
             {
                 _timerProvider.Delete(timer);
             }
         }
 
+        private async void EnforceKeepUpTo(TimerInfo timer)
+        {
+            if (string.IsNullOrWhiteSpace(timer.SeriesTimerId))
+            {
+                return;
+            }
+
+            var seriesTimerId = timer.SeriesTimerId;
+            var seriesTimer = _seriesTimerProvider.GetAll().FirstOrDefault(i => string.Equals(i.Id, seriesTimerId, StringComparison.OrdinalIgnoreCase));
+
+            if (seriesTimer == null || seriesTimer.KeepUpTo <= 1)
+            {
+                return;
+            }
+
+            if (_disposed)
+            {
+                return;
+            }
+
+            await _recordingDeleteSemaphore.WaitAsync().ConfigureAwait(false);
+
+            try
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                var timersToDelete = _timerProvider.GetAll()
+                    .Where(i => i.Status == RecordingStatus.Completed && !string.IsNullOrWhiteSpace(i.RecordingPath))
+                    .Where(i => string.Equals(i.SeriesTimerId, seriesTimerId, StringComparison.OrdinalIgnoreCase))
+                    .OrderByDescending(i => i.EndDate)
+                    .Where(i => File.Exists(i.RecordingPath))
+                    .Skip(seriesTimer.KeepUpTo - 1)
+                    .ToList();
+
+                await DeleteLibraryItemsForTimers(timersToDelete).ConfigureAwait(false);
+            }
+            finally
+            {
+                _recordingDeleteSemaphore.Release();
+            }
+        }
+
+        private readonly SemaphoreSlim _recordingDeleteSemaphore = new SemaphoreSlim(1, 1);
+        private async Task DeleteLibraryItemsForTimers(List<TimerInfo> timers)
+        {
+            foreach (var timer in timers)
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                try
+                {
+                    await DeleteLibraryItemForTimer(timer).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error deleting recording", ex);
+                }
+            }
+        }
+
+        private async Task DeleteLibraryItemForTimer(TimerInfo timer)
+        {
+            var libraryItem = _libraryManager.FindByPath(timer.RecordingPath, false);
+
+            if (libraryItem != null)
+            {
+                await _libraryManager.DeleteItem(libraryItem, new DeleteOptions
+                {
+                    DeleteFileLocation = true
+                });
+            }
+            else
+            {
+                try
+                {
+                    File.Delete(timer.RecordingPath);
+                }
+                catch (DirectoryNotFoundException)
+                {
+
+                }
+                catch (FileNotFoundException)
+                {
+
+                }
+            }
+
+            _timerProvider.Delete(timer);
+        }
+
         private string EnsureFileUnique(string path, string timerId)
         {
             var originalPath = path;
@@ -1099,7 +1476,10 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 return true;
             }
 
-            var hasRecordingAtPath = _activeRecordings.Values.ToList().Any(i => string.Equals(i.Path, path, StringComparison.OrdinalIgnoreCase) && !string.Equals(i.TimerId, timerId, StringComparison.OrdinalIgnoreCase));
+            var hasRecordingAtPath = _activeRecordings
+                .Values
+                .ToList()
+                .Any(i => string.Equals(i.Path, path, StringComparison.OrdinalIgnoreCase) && !string.Equals(i.Timer.Id, timerId, StringComparison.OrdinalIgnoreCase));
 
             if (hasRecordingAtPath)
             {
@@ -1114,7 +1494,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
             if (config.EnableRecordingEncoding)
             {
-                var regInfo = await _security.GetRegistrationStatus("embytvrecordingconversion").ConfigureAwait(false);
+                var regInfo = await _liveTvManager.GetRegistrationInfo("embytvrecordingconversion").ConfigureAwait(false);
 
                 if (regInfo.IsValid)
                 {
@@ -1125,30 +1505,180 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             return new DirectRecorder(_logger, _httpClient, _fileSystem);
         }
 
-        private async void OnSuccessfulRecording(bool isSeries, string path)
+        private async void OnSuccessfulRecording(TimerInfo timer, string path)
         {
-            if (GetConfiguration().EnableAutoOrganize)
+            if (timer.IsProgramSeries && GetConfiguration().EnableAutoOrganize)
             {
-                if (isSeries)
+                try
                 {
-                    try
+                    // this is to account for the library monitor holding a lock for additional time after the change is complete.
+                    // ideally this shouldn't be hard-coded
+                    await Task.Delay(30000).ConfigureAwait(false);
+
+                    var organize = new EpisodeFileOrganizer(_organizationService, _config, _fileSystem, _logger, _libraryManager, _libraryMonitor, _providerManager);
+
+                    var result = await organize.OrganizeEpisodeFile(path, _config.GetAutoOrganizeOptions(), false, CancellationToken.None).ConfigureAwait(false);
+
+                    if (result.Status == FileSortingStatus.Success)
+                    {
+                        return;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error processing new recording", ex);
+                }
+            }
+        }
+
+        private void SaveNfo(TimerInfo timer, string recordingPath, string seriesPath)
+        {
+            try
+            {
+                if (timer.IsProgramSeries)
+                {
+                    SaveSeriesNfo(timer, recordingPath, seriesPath);
+                }
+                else if (!timer.IsMovie || timer.IsSports || timer.IsNews)
+                {
+                    SaveVideoNfo(timer, recordingPath);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error saving nfo", ex);
+            }
+        }
+
+        private void SaveSeriesNfo(TimerInfo timer, string recordingPath, string seriesPath)
+        {
+            var nfoPath = Path.Combine(seriesPath, "tvshow.nfo");
+
+            if (File.Exists(nfoPath))
+            {
+                return;
+            }
+
+            using (var stream = _fileSystem.GetFileStream(nfoPath, FileMode.Create, FileAccess.Write, FileShare.Read))
+            {
+                var settings = new XmlWriterSettings
+                {
+                    Indent = true,
+                    Encoding = Encoding.UTF8,
+                    CloseOutput = false
+                };
+
+                using (XmlWriter writer = XmlWriter.Create(stream, settings))
+                {
+                    writer.WriteStartDocument(true);
+                    writer.WriteStartElement("tvshow");
+
+                    if (!string.IsNullOrWhiteSpace(timer.Name))
                     {
-                        // this is to account for the library monitor holding a lock for additional time after the change is complete.
-                        // ideally this shouldn't be hard-coded
-                        await Task.Delay(30000).ConfigureAwait(false);
+                        writer.WriteElementString("title", timer.Name);
+                    }
 
-                        var organize = new EpisodeFileOrganizer(_organizationService, _config, _fileSystem, _logger, _libraryManager, _libraryMonitor, _providerManager);
+                    writer.WriteEndElement();
+                    writer.WriteEndDocument();
+                }
+            }
+        }
 
-                        var result = await organize.OrganizeEpisodeFile(path, _config.GetAutoOrganizeOptions(), false, CancellationToken.None).ConfigureAwait(false);
+        public const string DateAddedFormat = "yyyy-MM-dd HH:mm:ss";
+        private void SaveVideoNfo(TimerInfo timer, string recordingPath)
+        {
+            var nfoPath = Path.ChangeExtension(recordingPath, ".nfo");
+
+            if (File.Exists(nfoPath))
+            {
+                return;
+            }
+
+            using (var stream = _fileSystem.GetFileStream(nfoPath, FileMode.Create, FileAccess.Write, FileShare.Read))
+            {
+                var settings = new XmlWriterSettings
+                {
+                    Indent = true,
+                    Encoding = Encoding.UTF8,
+                    CloseOutput = false
+                };
+
+                using (XmlWriter writer = XmlWriter.Create(stream, settings))
+                {
+                    writer.WriteStartDocument(true);
+                    writer.WriteStartElement("movie");
+
+                    if (!string.IsNullOrWhiteSpace(timer.Name))
+                    {
+                        writer.WriteElementString("title", timer.Name);
                     }
-                    catch (Exception ex)
+
+                    writer.WriteElementString("dateadded", DateTime.UtcNow.ToLocalTime().ToString(DateAddedFormat));
+
+                    if (timer.ProductionYear.HasValue)
                     {
-                        _logger.ErrorException("Error processing new recording", ex);
+                        writer.WriteElementString("year", timer.ProductionYear.Value.ToString(CultureInfo.InvariantCulture));
                     }
+                    if (!string.IsNullOrEmpty(timer.OfficialRating))
+                    {
+                        writer.WriteElementString("mpaa", timer.OfficialRating);
+                    }
+
+                    var overview = (timer.Overview ?? string.Empty)
+                        .StripHtml()
+                        .Replace("&quot;", "'");
+
+                    writer.WriteElementString("plot", overview);
+                    writer.WriteElementString("lockdata", true.ToString().ToLower());
+
+                    if (timer.CommunityRating.HasValue)
+                    {
+                        writer.WriteElementString("rating", timer.CommunityRating.Value.ToString(CultureInfo.InvariantCulture));
+                    }
+
+                    if (timer.IsSports)
+                    {
+                        AddGenre(timer.Genres, "Sports");
+                    }
+                    if (timer.IsKids)
+                    {
+                        AddGenre(timer.Genres, "Kids");
+                        AddGenre(timer.Genres, "Children");
+                    }
+                    if (timer.IsNews)
+                    {
+                        AddGenre(timer.Genres, "News");
+                    }
+
+                    foreach (var genre in timer.Genres)
+                    {
+                        writer.WriteElementString("genre", genre);
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(timer.ShortOverview))
+                    {
+                        writer.WriteElementString("outline", timer.ShortOverview);
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(timer.HomePageUrl))
+                    {
+                        writer.WriteElementString("website", timer.HomePageUrl);
+                    }
+
+                    writer.WriteEndElement();
+                    writer.WriteEndDocument();
                 }
             }
         }
 
+        private void AddGenre(List<string> genres, string genre)
+        {
+            if (!genres.Contains(genre, StringComparer.OrdinalIgnoreCase))
+            {
+                genres.Add(genre);
+            }
+        }
+
         private ProgramInfo GetProgramInfoFromCache(string channelId, string programId)
         {
             var epgData = GetEpgDataForChannel(channelId);
@@ -1168,41 +1698,101 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             return _config.GetConfiguration<LiveTvOptions>("livetv");
         }
 
+        private bool ShouldCancelTimerForSeriesTimer(SeriesTimerInfo seriesTimer, TimerInfo timer)
+        {
+            if (!seriesTimer.RecordAnyTime)
+            {
+                if (Math.Abs(seriesTimer.StartDate.TimeOfDay.Ticks - timer.StartDate.TimeOfDay.Ticks) >= TimeSpan.FromMinutes(5).Ticks)
+                {
+                    return true;
+                }
+
+                if (!seriesTimer.Days.Contains(timer.StartDate.ToLocalTime().DayOfWeek))
+                {
+                    return true;
+                }
+            }
+
+            if (seriesTimer.RecordNewOnly && timer.IsRepeat)
+            {
+                return true;
+            }
+
+            if (!seriesTimer.RecordAnyChannel && !string.Equals(timer.ChannelId, seriesTimer.ChannelId, StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+
+            return seriesTimer.SkipEpisodesInLibrary && IsProgramAlreadyInLibrary(timer);
+        }
+
         private async Task UpdateTimersForSeriesTimer(List<ProgramInfo> epgData, SeriesTimerInfo seriesTimer, bool deleteInvalidTimers)
         {
-            var newTimers = GetTimersForSeries(seriesTimer, epgData, true).ToList();
+            var allTimers = GetTimersForSeries(seriesTimer, epgData)
+                .ToList();
 
-            var registration = await GetRegistrationInfo("seriesrecordings").ConfigureAwait(false);
+            var registration = await _liveTvManager.GetRegistrationInfo("seriesrecordings").ConfigureAwait(false);
 
             if (registration.IsValid)
             {
-                foreach (var timer in newTimers)
+                foreach (var timer in allTimers)
                 {
-                    _timerProvider.AddOrUpdate(timer);
+                    var existingTimer = _timerProvider.GetTimer(timer.Id);
+
+                    if (existingTimer == null)
+                    {
+                        if (ShouldCancelTimerForSeriesTimer(seriesTimer, timer))
+                        {
+                            timer.Status = RecordingStatus.Cancelled;
+                        }
+                        _timerProvider.Add(timer);
+                    }
+                    else
+                    {
+                        // Only update if not currently active
+                        ActiveRecordingInfo activeRecordingInfo;
+                        if (!_activeRecordings.TryGetValue(timer.Id, out activeRecordingInfo))
+                        {
+                            UpdateExistingTimerWithNewMetadata(existingTimer, timer);
+
+                            if (ShouldCancelTimerForSeriesTimer(seriesTimer, timer))
+                            {
+                                existingTimer.Status = RecordingStatus.Cancelled;
+                            }
+
+                            existingTimer.SeriesTimerId = seriesTimer.Id;
+                            _timerProvider.Update(existingTimer);
+                        }
+                    }
                 }
             }
 
             if (deleteInvalidTimers)
             {
-                var allTimers = GetTimersForSeries(seriesTimer, epgData, false)
+                var allTimerIds = allTimers
                     .Select(i => i.Id)
                     .ToList();
 
+                var deleteStatuses = new List<RecordingStatus>
+                {
+                    RecordingStatus.New
+                };
+
                 var deletes = _timerProvider.GetAll()
                     .Where(i => string.Equals(i.SeriesTimerId, seriesTimer.Id, StringComparison.OrdinalIgnoreCase))
-                    .Where(i => !allTimers.Contains(i.Id, StringComparer.OrdinalIgnoreCase) && i.StartDate > DateTime.UtcNow)
+                    .Where(i => !allTimerIds.Contains(i.Id, StringComparer.OrdinalIgnoreCase) && i.StartDate > DateTime.UtcNow)
+                    .Where(i => deleteStatuses.Contains(i.Status))
                     .ToList();
 
                 foreach (var timer in deletes)
                 {
-                    await CancelTimerAsync(timer.Id, CancellationToken.None).ConfigureAwait(false);
+                    CancelTimerInternal(timer.Id, false);
                 }
             }
         }
 
         private IEnumerable<TimerInfo> GetTimersForSeries(SeriesTimerInfo seriesTimer,
-            IEnumerable<ProgramInfo> allPrograms,
-            bool filterByCurrentRecordings)
+            IEnumerable<ProgramInfo> allPrograms)
         {
             if (seriesTimer == null)
             {
@@ -1214,19 +1804,14 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             }
 
             // Exclude programs that have already ended
-            allPrograms = allPrograms.Where(i => i.EndDate > DateTime.UtcNow && i.StartDate > DateTime.UtcNow);
+            allPrograms = allPrograms.Where(i => i.EndDate > DateTime.UtcNow);
 
             allPrograms = GetProgramsForSeries(seriesTimer, allPrograms);
 
-            if (filterByCurrentRecordings)
-            {
-                allPrograms = allPrograms.Where(i => !IsProgramAlreadyInLibrary(i));
-            }
-
             return allPrograms.Select(i => RecordingHelper.CreateTimer(i, seriesTimer));
         }
 
-        private bool IsProgramAlreadyInLibrary(ProgramInfo program)
+        private bool IsProgramAlreadyInLibrary(TimerInfo program)
         {
             if ((program.EpisodeNumber.HasValue && program.SeasonNumber.HasValue) || !string.IsNullOrWhiteSpace(program.EpisodeTitle))
             {
@@ -1281,23 +1866,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
         private IEnumerable<ProgramInfo> GetProgramsForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> allPrograms)
         {
-            if (!seriesTimer.RecordAnyTime)
-            {
-                allPrograms = allPrograms.Where(epg => Math.Abs(seriesTimer.StartDate.TimeOfDay.Ticks - epg.StartDate.TimeOfDay.Ticks) < TimeSpan.FromMinutes(5).Ticks);
-
-                allPrograms = allPrograms.Where(i => seriesTimer.Days.Contains(i.StartDate.ToLocalTime().DayOfWeek));
-            }
-
-            if (seriesTimer.RecordNewOnly)
-            {
-                allPrograms = allPrograms.Where(epg => !epg.IsRepeat);
-            }
-
-            if (!seriesTimer.RecordAnyChannel)
-            {
-                allPrograms = allPrograms.Where(epg => string.Equals(epg.ChannelId, seriesTimer.ChannelId, StringComparison.OrdinalIgnoreCase));
-            }
-
             if (string.IsNullOrWhiteSpace(seriesTimer.SeriesId))
             {
                 _logger.Error("seriesTimer.SeriesId is null. Cannot find programs for series");
@@ -1341,28 +1909,16 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             return channelIds.SelectMany(GetEpgDataForChannel).ToList();
         }
 
+        private bool _disposed;
         public void Dispose()
         {
+            _disposed = true;
             foreach (var pair in _activeRecordings.ToList())
             {
                 pair.Value.CancellationTokenSource.Cancel();
             }
         }
 
-        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
-            });
-        }
-
         public List<VirtualFolderInfo> GetRecordingFolders()
         {
             var list = new List<VirtualFolderInfo>();
@@ -1407,7 +1963,8 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
         class ActiveRecordingInfo
         {
             public string Path { get; set; }
-            public string TimerId { get; set; }
+            public TimerInfo Timer { get; set; }
+            public ProgramInfo Program { get; set; }
             public CancellationTokenSource CancellationTokenSource { get; set; }
         }
     }
diff --git a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/EncodedRecorder.cs b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/EncodedRecorder.cs
index fc3a507d1..3e9d186e3 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/EncodedRecorder.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/EncodedRecorder.cs
@@ -46,82 +46,32 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             _httpClient = httpClient;
         }
 
-        public string GetOutputPath(MediaSourceInfo mediaSource, string targetFile)
-        {
-            return Path.ChangeExtension(targetFile, ".mp4");
-        }
-
-        public async Task Record(MediaSourceInfo mediaSource, string targetFile, TimeSpan duration, Action onStarted, CancellationToken cancellationToken)
+        private string OutputFormat
         {
-            var tempfile = Path.Combine(_appPaths.TranscodingTempPath, Guid.NewGuid().ToString("N") + ".ts");
-
-            try
-            {
-                await RecordInternal(mediaSource, tempfile, targetFile, duration, onStarted, cancellationToken)
-                        .ConfigureAwait(false);
-            }
-            finally
+            get
             {
-                try
-                {
-                    File.Delete(tempfile);
-                }
-                catch (Exception ex)
+                var format = _liveTvOptions.RecordingEncodingFormat;
+
+                if (string.Equals(format, "mkv", StringComparison.OrdinalIgnoreCase))
                 {
-                    _logger.ErrorException("Error deleting recording temp file", ex);
+                    return "mkv";
                 }
+
+                return "mp4";
             }
         }
 
-        public async Task RecordInternal(MediaSourceInfo mediaSource, string tempFile, string targetFile, TimeSpan duration, Action onStarted, CancellationToken cancellationToken)
+        public string GetOutputPath(MediaSourceInfo mediaSource, string targetFile)
         {
-            var httpRequestOptions = new HttpRequestOptions()
-            {
-                Url = mediaSource.Path
-            };
-
-            httpRequestOptions.BufferContent = false;
-
-            using (var response = await _httpClient.SendAsync(httpRequestOptions, "GET").ConfigureAwait(false))
-            {
-                _logger.Info("Opened recording stream from tuner provider");
-
-                Directory.CreateDirectory(Path.GetDirectoryName(tempFile));
-
-                using (var output = _fileSystem.GetFileStream(tempFile, FileMode.Create, FileAccess.Write, FileShare.Read))
-                {
-                    //onStarted();
-
-                    _logger.Info("Copying recording stream to file {0}", tempFile);
-
-                    var bufferMs = 5000;
-
-                    if (mediaSource.RunTimeTicks.HasValue)
-                    {
-                        // The media source already has a fixed duration
-                        // But add another stop 1 minute later just in case the recording gets stuck for any reason
-                        var durationToken = new CancellationTokenSource(duration.Add(TimeSpan.FromMinutes(1)));
-                        cancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, durationToken.Token).Token;
-                    }
-                    else
-                    {
-                        // The media source if infinite so we need to handle stopping ourselves
-                        var durationToken = new CancellationTokenSource(duration.Add(TimeSpan.FromMilliseconds(bufferMs)));
-                        cancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, durationToken.Token).Token;
-                    }
-
-                    var tempFileTask = response.Content.CopyToAsync(output, StreamDefaults.DefaultCopyToBufferSize, cancellationToken);
-
-                    // Give the temp file a little time to build up
-                    await Task.Delay(bufferMs, cancellationToken).ConfigureAwait(false);
-
-                    var recordTask = Task.Run(() => RecordFromFile(mediaSource, tempFile, targetFile, duration, onStarted, cancellationToken), cancellationToken);
+            return Path.ChangeExtension(targetFile, "." + OutputFormat);
+        }
 
-                    await tempFileTask.ConfigureAwait(false);
+        public async Task Record(MediaSourceInfo mediaSource, string targetFile, TimeSpan duration, Action onStarted, CancellationToken cancellationToken)
+        {
+            var durationToken = new CancellationTokenSource(duration);
+            cancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, durationToken.Token).Token;
 
-                    await recordTask.ConfigureAwait(false);
-                }
-            }
+            await RecordFromFile(mediaSource, mediaSource.Path, targetFile, duration, onStarted, cancellationToken).ConfigureAwait(false);
 
             _logger.Info("Recording completed to file {0}", targetFile);
         }
@@ -167,7 +117,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             var commandLineLogMessageBytes = Encoding.UTF8.GetBytes(_json.SerializeToString(mediaSource) + Environment.NewLine + Environment.NewLine + commandLineLogMessage + Environment.NewLine + Environment.NewLine);
             _logFileStream.Write(commandLineLogMessageBytes, 0, commandLineLogMessageBytes.Length);
 
-            process.Exited += (sender, args) => OnFfMpegProcessExited(process);
+            process.Exited += (sender, args) => OnFfMpegProcessExited(process, inputFile);
 
             process.Start();
 
@@ -181,6 +131,8 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             // Important - don't await the log task or we won't be able to kill ffmpeg when the user stops playback
             StartStreamingLog(process.StandardError.BaseStream, _logFileStream);
 
+            _logger.Info("ffmpeg recording process started for {0}", _targetPath);
+
             return _taskCompletionSource.Task;
         }
 
@@ -201,29 +153,41 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             }
 
             var durationParam = " -t " + _mediaEncoder.GetTimeParameter(duration.Ticks);
-            var commandLineArgs = "-fflags +genpts -async 1 -vsync -1 -re -i \"{0}\"{4} -sn {2} -map_metadata -1 -threads 0 {3} -y \"{1}\"";
+            var inputModifiers = "-fflags +genpts -async 1 -vsync -1";
+            var commandLineArgs = "-i \"{0}\"{4} -sn {2} -map_metadata -1 -threads 0 {3} -y \"{1}\"";
+
+            long startTimeTicks = 0;
+            //if (mediaSource.DateLiveStreamOpened.HasValue)
+            //{
+            //    var elapsed = DateTime.UtcNow - mediaSource.DateLiveStreamOpened.Value;
+            //    elapsed -= TimeSpan.FromSeconds(10);
+            //    if (elapsed.TotalSeconds >= 0)
+            //    {
+            //        startTimeTicks = elapsed.Ticks + startTimeTicks;
+            //    }
+            //}
 
             if (mediaSource.ReadAtNativeFramerate)
             {
-                commandLineArgs = "-re " + commandLineArgs;
+                inputModifiers += " -re";
+            }
+
+            if (startTimeTicks > 0)
+            {
+                inputModifiers = "-ss " + _mediaEncoder.GetTimeParameter(startTimeTicks) + " " + inputModifiers;
             }
 
             commandLineArgs = string.Format(commandLineArgs, inputTempFile, targetFile, videoArgs, GetAudioArgs(mediaSource), durationParam);
 
-            return commandLineArgs;
+            return inputModifiers + " " + commandLineArgs;
         }
 
         private string GetAudioArgs(MediaSourceInfo mediaSource)
         {
-            // do not copy aac because many players have difficulty with aac_latm
-            var copyAudio = new[] { "mp3" };
             var mediaStreams = mediaSource.MediaStreams ?? new List<MediaStream>();
             var inputAudioCodec = mediaStreams.Where(i => i.Type == MediaStreamType.Audio).Select(i => i.Codec).FirstOrDefault() ?? string.Empty;
 
-            if (copyAudio.Contains(inputAudioCodec, StringComparer.OrdinalIgnoreCase))
-            {
-                return "-codec:a:0 copy";
-            }
+            // do not copy aac because many players have difficulty with aac_latm
             if (_liveTvOptions.EnableOriginalAudioWithEncodedRecordings && !string.Equals(inputAudioCodec, "aac", StringComparison.OrdinalIgnoreCase))
             {
                 return "-codec:a:0 copy";
@@ -281,8 +245,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
         /// <summary>
         /// Processes the exited.
         /// </summary>
-        /// <param name="process">The process.</param>
-        private void OnFfMpegProcessExited(Process process)
+        private void OnFfMpegProcessExited(Process process, string inputFile)
         {
             _hasExited = true;
 
diff --git a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/RecordingHelper.cs b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/RecordingHelper.cs
index 37e10d925..f7b4b3fde 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/RecordingHelper.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/RecordingHelper.cs
@@ -2,6 +2,7 @@
 using MediaBrowser.Controller.LiveTv;
 using System;
 using System.Globalization;
+using MediaBrowser.Model.LiveTv;
 
 namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 {
@@ -12,37 +13,55 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             return timer.StartDate.AddSeconds(-timer.PrePaddingSeconds);
         }
 
-        public static TimerInfo CreateTimer(ProgramInfo parent, SeriesTimerInfo series)
+        public static TimerInfo CreateTimer(ProgramInfo parent, SeriesTimerInfo seriesTimer)
         {
             var timer = new TimerInfo();
 
             timer.ChannelId = parent.ChannelId;
-            timer.Id = (series.Id + parent.Id).GetMD5().ToString("N");
+            timer.Id = (seriesTimer.Id + parent.Id).GetMD5().ToString("N");
             timer.StartDate = parent.StartDate;
             timer.EndDate = parent.EndDate;
             timer.ProgramId = parent.Id;
-            timer.PrePaddingSeconds = series.PrePaddingSeconds;
-            timer.PostPaddingSeconds = series.PostPaddingSeconds;
-            timer.IsPostPaddingRequired = series.IsPostPaddingRequired;
-            timer.IsPrePaddingRequired = series.IsPrePaddingRequired;
-            timer.Priority = series.Priority;
+            timer.PrePaddingSeconds = seriesTimer.PrePaddingSeconds;
+            timer.PostPaddingSeconds = seriesTimer.PostPaddingSeconds;
+            timer.IsPostPaddingRequired = seriesTimer.IsPostPaddingRequired;
+            timer.IsPrePaddingRequired = seriesTimer.IsPrePaddingRequired;
+            timer.KeepUntil = seriesTimer.KeepUntil;
+            timer.Priority = seriesTimer.Priority;
             timer.Name = parent.Name;
             timer.Overview = parent.Overview;
-            timer.SeriesTimerId = series.Id;
+            timer.SeriesTimerId = seriesTimer.Id;
+
+            CopyProgramInfoToTimerInfo(parent, timer);
 
             return timer;
         }
 
-        public static string GetRecordingName(TimerInfo timer, ProgramInfo info)
+        public static void CopyProgramInfoToTimerInfo(ProgramInfo programInfo, TimerInfo timerInfo)
         {
-            if (info == null)
-            {
-                return timer.ProgramId;
-            }
+            timerInfo.SeasonNumber = programInfo.SeasonNumber;
+            timerInfo.EpisodeNumber = programInfo.EpisodeNumber;
+            timerInfo.IsMovie = programInfo.IsMovie;
+            timerInfo.IsKids = programInfo.IsKids;
+            timerInfo.IsNews = programInfo.IsNews;
+            timerInfo.IsSports = programInfo.IsSports;
+            timerInfo.ProductionYear = programInfo.ProductionYear;
+            timerInfo.EpisodeTitle = programInfo.EpisodeTitle;
+            timerInfo.OriginalAirDate = programInfo.OriginalAirDate;
+            timerInfo.IsProgramSeries = programInfo.IsSeries;
+
+            timerInfo.HomePageUrl = programInfo.HomePageUrl;
+            timerInfo.CommunityRating = programInfo.CommunityRating;
+            timerInfo.ShortOverview = programInfo.ShortOverview;
+            timerInfo.OfficialRating = programInfo.OfficialRating;
+            timerInfo.IsRepeat = programInfo.IsRepeat;
+        }
 
+        public static string GetRecordingName(TimerInfo info)
+        {
             var name = info.Name;
 
-            if (info.IsSeries)
+            if (info.IsProgramSeries)
             {
                 var addHyphen = true;
 
@@ -55,6 +74,10 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 {
                     name += " " + info.OriginalAirDate.Value.ToString("yyyy-MM-dd");
                 }
+                else
+                {
+                    name += " " + DateTime.Now.ToString("yyyy-MM-dd");
+                }
 
                 if (!string.IsNullOrWhiteSpace(info.EpisodeTitle))
                 {
diff --git a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/TimerManager.cs b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/TimerManager.cs
index 423358906..bddce0420 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/TimerManager.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/EmbyTV/TimerManager.cs
@@ -9,7 +9,6 @@ using System.Globalization;
 using System.Linq;
 using System.Threading;
 using CommonIO;
-using MediaBrowser.Controller.Power;
 using MediaBrowser.Model.LiveTv;
 
 namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
@@ -17,15 +16,13 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
     public class TimerManager : ItemDataProvider<TimerInfo>
     {
         private readonly ConcurrentDictionary<string, Timer> _timers = new ConcurrentDictionary<string, Timer>(StringComparer.OrdinalIgnoreCase);
-        private readonly IPowerManagement _powerManagement;
         private readonly ILogger _logger;
 
         public event EventHandler<GenericEventArgs<TimerInfo>> TimerFired;
 
-        public TimerManager(IFileSystem fileSystem, IJsonSerializer jsonSerializer, ILogger logger, string dataPath, IPowerManagement powerManagement, ILogger logger1)
+        public TimerManager(IFileSystem fileSystem, IJsonSerializer jsonSerializer, ILogger logger, string dataPath, ILogger logger1)
             : base(fileSystem, jsonSerializer, logger, dataPath, (r1, r2) => string.Equals(r1.Id, r2.Id, StringComparison.OrdinalIgnoreCase))
         {
-            _powerManagement = powerManagement;
             _logger = logger1;
         }
 
@@ -35,7 +32,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
 
             foreach (var item in GetAll().ToList())
             {
-                AddTimer(item);
+                AddOrUpdateSystemTimer(item);
             }
         }
 
@@ -58,18 +55,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
         public override void Update(TimerInfo item)
         {
             base.Update(item);
-
-            Timer timer;
-            if (_timers.TryGetValue(item.Id, out timer))
-            {
-                var timespan = RecordingHelper.GetStartTime(item) - DateTime.UtcNow;
-                timer.Change(timespan, TimeSpan.Zero);
-                ScheduleWake(item);
-            }
-            else
-            {
-                AddTimer(item);
-            }
+            AddOrUpdateSystemTimer(item);
         }
 
         public void AddOrUpdate(TimerInfo item, bool resetTimer)
@@ -100,13 +86,25 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
             }
 
             base.Add(item);
-            AddTimer(item);
-            ScheduleWake(item);
+            AddOrUpdateSystemTimer(item);
+        }
+
+        private bool ShouldStartTimer(TimerInfo item)
+        {
+            if (item.Status == RecordingStatus.Completed ||
+                item.Status == RecordingStatus.Cancelled)
+            {
+                return false;
+            }
+
+            return true;
         }
 
-        private void AddTimer(TimerInfo item)
+        private void AddOrUpdateSystemTimer(TimerInfo item)
         {
-            if (item.Status == RecordingStatus.Completed)
+            StopTimer(item);
+
+            if (!ShouldStartTimer(item))
             {
                 return;
             }
@@ -120,33 +118,12 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 return;
             }
 
-            var timerLength = startDate - now;
-            StartTimer(item, timerLength);
+            var dueTime = startDate - now;
+            StartTimer(item, dueTime);
         }
 
-        private void ScheduleWake(TimerInfo info)
+        private void StartTimer(TimerInfo item, TimeSpan dueTime)
         {
-            var startDate = RecordingHelper.GetStartTime(info).AddMinutes(-5);
-
-            try
-            {
-                _powerManagement.ScheduleWake(startDate);
-                _logger.Info("Scheduled system wake timer at {0} (UTC)", startDate);
-            }
-            catch (NotImplementedException)
-            {
-
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error scheduling wake timer", ex);
-            }
-        }
-
-        public void StartTimer(TimerInfo item, TimeSpan dueTime)
-        {
-            StopTimer(item);
-
             var timer = new Timer(TimerCallback, item.Id, dueTime, TimeSpan.Zero);
 
             if (_timers.TryAdd(item.Id, timer))
@@ -179,5 +156,10 @@ namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
                 EventHelper.FireEventIfNotNull(TimerFired, this, new GenericEventArgs<TimerInfo> { Argument = timer }, Logger);
             }
         }
+
+        public TimerInfo GetTimer(string id)
+        {
+            return GetAll().FirstOrDefault(r => string.Equals(r.Id, id, StringComparison.OrdinalIgnoreCase));
+        }
     }
 }
diff --git a/MediaBrowser.Server.Implementations/LiveTv/Listings/SchedulesDirect.cs b/MediaBrowser.Server.Implementations/LiveTv/Listings/SchedulesDirect.cs
index e37109c14..7574eb485 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/Listings/SchedulesDirect.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/Listings/SchedulesDirect.cs
@@ -166,7 +166,17 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                             var imageIndex = images.FindIndex(i => i.programID == schedule.programID.Substring(0, 10));
                             if (imageIndex > -1)
                             {
-                                programDict[schedule.programID].images = GetProgramLogo(ApiUrl, images[imageIndex]);
+                                var programEntry = programDict[schedule.programID];
+
+                                var data = images[imageIndex].data ?? new List<ScheduleDirect.ImageData>();
+                                data = data.OrderByDescending(GetSizeOrder).ToList();
+
+                                programEntry.primaryImage = GetProgramImage(ApiUrl, data, "Logo", true, 600);
+                                //programEntry.thumbImage = GetProgramImage(ApiUrl, data, "Iconic", false);
+                                //programEntry.bannerImage = GetProgramImage(ApiUrl, data, "Banner", false) ??
+                                //    GetProgramImage(ApiUrl, data, "Banner-L1", false) ??
+                                //    GetProgramImage(ApiUrl, data, "Banner-LO", false) ??
+                                //    GetProgramImage(ApiUrl, data, "Banner-LOT", false);
                             }
                         }
 
@@ -179,6 +189,20 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
             return programsInfo;
         }
 
+        private int GetSizeOrder(ScheduleDirect.ImageData image)
+        {
+            if (!string.IsNullOrWhiteSpace(image.height))
+            {
+                int value;
+                if (int.TryParse(image.height, out value))
+                {
+                    return value;
+                }
+            }
+
+            return 0;
+        }
+
         private readonly object _channelCacheLock = new object();
         private ScheduleDirect.Station GetStation(string listingsId, string channelNumber, string channelName)
         {
@@ -194,14 +218,22 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                         return station;
                     }
 
-                    if (string.IsNullOrWhiteSpace(channelName))
+                    if (!string.IsNullOrWhiteSpace(channelName))
                     {
-                        return null;
-                    }
+                        channelName = NormalizeName(channelName);
 
-                    channelName = NormalizeName(channelName);
+                        var result = channelPair.Values.FirstOrDefault(i => string.Equals(NormalizeName(i.callsign ?? string.Empty), channelName, StringComparison.OrdinalIgnoreCase));
+
+                        if (result != null)
+                        {
+                            return result;
+                        }
+                    }
 
-                    return channelPair.Values.FirstOrDefault(i => string.Equals(NormalizeName(i.callsign ?? string.Empty), channelName, StringComparison.OrdinalIgnoreCase));
+                    if (!string.IsNullOrWhiteSpace(channelNumber))
+                    {
+                        return channelPair.Values.FirstOrDefault(i => string.Equals(NormalizeName(i.stationID ?? string.Empty), channelNumber, StringComparison.OrdinalIgnoreCase));
+                    }
                 }
 
                 return null;
@@ -307,9 +339,19 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                     channelNumber = channelNumber.TrimStart('0');
 
                     _logger.Debug("Found channel: " + channelNumber + " in Schedules Direct");
-                    var schChannel = root.stations.FirstOrDefault(item => item.stationID == map.stationID);
 
-                    AddToChannelPairCache(listingsId, channelNumber, schChannel);
+                    var schChannel = (root.stations ?? new List<ScheduleDirect.Station>()).FirstOrDefault(item => string.Equals(item.stationID, map.stationID, StringComparison.OrdinalIgnoreCase));
+                    if (schChannel != null)
+                    {
+                        AddToChannelPairCache(listingsId, channelNumber, schChannel);
+                    }
+                    else
+                    {
+                        AddToChannelPairCache(listingsId, channelNumber, new ScheduleDirect.Station
+                        {
+                            stationID = map.stationID
+                        });
+                    }
                 }
                 _logger.Info("Added " + GetChannelPairCacheCount(listingsId) + " channels to the dictionary");
 
@@ -324,8 +366,11 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                             channel.ImageUrl = station.logo.URL;
                             channel.HasImage = true;
                         }
-                        string channelName = station.name;
-                        channel.Name = channelName;
+
+                        if (!string.IsNullOrWhiteSpace(station.name))
+                        {
+                            channel.Name = station.name;
+                        }
                     }
                     else
                     {
@@ -348,7 +393,11 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
 
             if (programInfo.audioProperties != null)
             {
-                if (programInfo.audioProperties.Exists(item => string.Equals(item, "dd 5.1", StringComparison.OrdinalIgnoreCase)))
+                if (programInfo.audioProperties.Exists(item => string.Equals(item, "atmos", StringComparison.OrdinalIgnoreCase)))
+                {
+                    audioType = ProgramAudio.Atmos;
+                }
+                else if (programInfo.audioProperties.Exists(item => string.Equals(item, "dd 5.1", StringComparison.OrdinalIgnoreCase)))
                 {
                     audioType = ProgramAudio.DolbyDigital;
                 }
@@ -372,13 +421,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                 episodeTitle = details.episodeTitle150;
             }
 
-            string imageUrl = null;
-
-            if (details.hasImageArtwork)
-            {
-                imageUrl = details.images;
-            }
-
             var showType = details.showType ?? string.Empty;
 
             var info = new ProgramInfo
@@ -394,7 +436,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                 Audio = audioType,
                 IsRepeat = repeat,
                 IsSeries = showType.IndexOf("series", StringComparison.OrdinalIgnoreCase) != -1,
-                ImageUrl = imageUrl,
+                ImageUrl = details.primaryImage,
                 IsKids = string.Equals(details.audience, "children", StringComparison.OrdinalIgnoreCase),
                 IsSports = showType.IndexOf("sports", StringComparison.OrdinalIgnoreCase) != -1,
                 IsMovie = showType.IndexOf("movie", StringComparison.OrdinalIgnoreCase) != -1 || showType.IndexOf("film", StringComparison.OrdinalIgnoreCase) != -1,
@@ -405,6 +447,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
             if (programInfo.videoProperties != null)
             {
                 info.IsHD = programInfo.videoProperties.Contains("hdtv", StringComparer.OrdinalIgnoreCase);
+                info.Is3D = programInfo.videoProperties.Contains("3d", StringComparer.OrdinalIgnoreCase);
             }
 
             if (details.contentRating != null && details.contentRating.Count > 0)
@@ -442,7 +485,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                 }
             }
 
-            if (!string.IsNullOrWhiteSpace(details.originalAirDate))
+            if (!string.IsNullOrWhiteSpace(details.originalAirDate) && (!info.IsSeries || info.IsRepeat))
             {
                 info.OriginalAirDate = DateTime.Parse(details.originalAirDate);
             }
@@ -472,36 +515,69 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
             return date;
         }
 
-        private string GetProgramLogo(string apiUrl, ScheduleDirect.ShowImages images)
+        private string GetProgramImage(string apiUrl, List<ScheduleDirect.ImageData> images, string category, bool returnDefaultImage, int desiredWidth)
         {
             string url = null;
-            if (images.data != null)
+
+            var matches = images
+                .Where(i => string.Equals(i.category, category, StringComparison.OrdinalIgnoreCase))
+                .ToList();
+
+            if (matches.Count == 0)
             {
-                var smallImages = images.data.Where(i => i.size == "Sm").ToList();
-                if (smallImages.Any())
-                {
-                    images.data = smallImages;
-                }
-                var logoIndex = images.data.FindIndex(i => i.category == "Logo");
-                if (logoIndex == -1)
+                if (!returnDefaultImage)
                 {
-                    logoIndex = 0;
+                    return null;
                 }
-                var uri = images.data[logoIndex].uri;
+                matches = images;
+            }
 
-                if (!string.IsNullOrWhiteSpace(uri))
+            var match = matches.FirstOrDefault(i =>
+            {
+                if (!string.IsNullOrWhiteSpace(i.width))
                 {
-                    if (uri.IndexOf("http", StringComparison.OrdinalIgnoreCase) != -1)
+                    int value;
+                    if (int.TryParse(i.width, out value))
                     {
-                        url = uri;
-                    }
-                    else
-                    {
-                        url = apiUrl + "/image/" + uri;
+                        return value <= desiredWidth;
                     }
                 }
-                //_logger.Debug("URL for image is : " + url);
+
+                return false;
+            });
+
+            if (match == null)
+            {
+                // Get the second lowest quality image, when possible
+                if (matches.Count > 1)
+                {
+                    match = matches[matches.Count - 2];
+                }
+                else
+                {
+                    match = matches.FirstOrDefault();
+                }
             }
+
+            if (match == null)
+            {
+                return null;
+            }
+
+            var uri = match.uri;
+
+            if (!string.IsNullOrWhiteSpace(uri))
+            {
+                if (uri.IndexOf("http", StringComparison.OrdinalIgnoreCase) != -1)
+                {
+                    url = uri;
+                }
+                else
+                {
+                    url = apiUrl + "/image/" + uri;
+                }
+            }
+            //_logger.Debug("URL for image is : " + url);
             return url;
         }
 
@@ -770,7 +846,8 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                 Url = ApiUrl + "/lineups/" + info.ListingsId,
                 UserAgent = UserAgent,
                 CancellationToken = cancellationToken,
-                LogErrorResponseBody = true
+                LogErrorResponseBody = true,
+                BufferContent = false
             };
 
             httpOptions.RequestHeaders["token"] = token;
@@ -785,9 +862,10 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
             get { return "Schedules Direct"; }
         }
 
+        public static string TypeName = "SchedulesDirect";
         public string Type
         {
-            get { return "SchedulesDirect"; }
+            get { return TypeName; }
         }
 
         private async Task<bool> HasLineup(ListingsProviderInfo info, CancellationToken cancellationToken)
@@ -924,7 +1002,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                     var name = channelNumber;
                     var station = GetStation(listingsId, channelNumber, null);
 
-                    if (station != null)
+                    if (station != null && !string.IsNullOrWhiteSpace(station.name))
                     {
                         name = station.name;
                     }
@@ -1190,7 +1268,9 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                 public List<Crew> crew { get; set; }
                 public string showType { get; set; }
                 public bool hasImageArtwork { get; set; }
-                public string images { get; set; }
+                public string primaryImage { get; set; }
+                public string thumbImage { get; set; }
+                public string bannerImage { get; set; }
                 public string imageID { get; set; }
                 public string md5 { get; set; }
                 public List<string> contentAdvisory { get; set; }
diff --git a/MediaBrowser.Server.Implementations/LiveTv/Listings/XmlTvListingsProvider.cs b/MediaBrowser.Server.Implementations/LiveTv/Listings/XmlTvListingsProvider.cs
index d1d8df2e8..d3549aef5 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/Listings/XmlTvListingsProvider.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/Listings/XmlTvListingsProvider.cs
@@ -11,6 +11,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Emby.XmlTv.Classes;
+using Emby.XmlTv.Entities;
 using MediaBrowser.Common.Extensions;
 using MediaBrowser.Common.Net;
 using MediaBrowser.Controller.Configuration;
@@ -115,7 +116,12 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
             var reader = new XmlTvReader(path, GetLanguage(), null);
 
             var results = reader.GetProgrammes(channelNumber, startDateUtc, endDateUtc, cancellationToken);
-            return results.Select(p => new ProgramInfo()
+            return results.Select(p => GetProgramInfo(p, info));
+        }
+
+        private ProgramInfo GetProgramInfo(XmlTvProgram p, ListingsProviderInfo info)
+        {
+            var programInfo = new ProgramInfo
             {
                 ChannelId = p.ChannelId,
                 EndDate = GetDate(p.EndDate),
@@ -141,7 +147,16 @@ namespace MediaBrowser.Server.Implementations.LiveTv.Listings
                 OfficialRating = p.Rating != null && !String.IsNullOrEmpty(p.Rating.Value) ? p.Rating.Value : null,
                 CommunityRating = p.StarRating.HasValue ? p.StarRating.Value : (float?)null,
                 SeriesId = p.Episode != null ? p.Title.GetMD5().ToString("N") : null
-            });
+            };
+
+            if (programInfo.IsMovie)
+            {
+                programInfo.IsSeries = false;
+                programInfo.EpisodeNumber = null;
+                programInfo.EpisodeTitle = null;
+            }
+
+            return programInfo;
         }
 
         private DateTime GetDate(DateTime date)
diff --git a/MediaBrowser.Server.Implementations/LiveTv/LiveTvDtoService.cs b/MediaBrowser.Server.Implementations/LiveTv/LiveTvDtoService.cs
index 683377c61..8c46b4597 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/LiveTvDtoService.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/LiveTvDtoService.cs
@@ -10,6 +10,7 @@ using MediaBrowser.Model.LiveTv;
 using MediaBrowser.Model.Logging;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -52,6 +53,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 PostPaddingSeconds = info.PostPaddingSeconds,
                 IsPostPaddingRequired = info.IsPostPaddingRequired,
                 IsPrePaddingRequired = info.IsPrePaddingRequired,
+                KeepUntil = info.KeepUntil,
                 ExternalChannelId = info.ChannelId,
                 ExternalSeriesTimerId = info.SeriesTimerId,
                 ServiceName = service.Name,
@@ -71,6 +73,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 dto.ProgramInfo = _dtoService.GetBaseItemDto(program, new DtoOptions());
 
                 dto.ProgramInfo.TimerId = dto.Id;
+
                 dto.ProgramInfo.SeriesTimerId = dto.SeriesTimerId;
             }
 
@@ -100,6 +103,9 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 Priority = info.Priority,
                 RecordAnyChannel = info.RecordAnyChannel,
                 RecordAnyTime = info.RecordAnyTime,
+                SkipEpisodesInLibrary = info.SkipEpisodesInLibrary,
+                KeepUpTo = info.KeepUpTo,
+                KeepUntil = info.KeepUntil,
                 RecordNewOnly = info.RecordNewOnly,
                 ExternalChannelId = info.ChannelId,
                 ExternalProgramId = info.ProgramId,
@@ -120,6 +126,34 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
             dto.DayPattern = info.Days == null ? null : GetDayPattern(info.Days);
 
+            if (!string.IsNullOrWhiteSpace(info.SeriesId))
+            {
+                var program = _libraryManager.GetItemList(new InternalItemsQuery
+                {
+                    IncludeItemTypes = new string[] { typeof(LiveTvProgram).Name },
+                    ExternalSeriesId = info.SeriesId,
+                    Limit = 1,
+                    ImageTypes = new ImageType[] { ImageType.Primary }
+
+                }).FirstOrDefault();
+
+                if (program != null)
+                {
+                    var image = program.GetImageInfo(ImageType.Primary, 0);
+                    if (image != null)
+                    {
+                        try
+                        {
+                            dto.ParentPrimaryImageTag = _imageProcessor.GetImageCacheTag(program, image);
+                            dto.ParentPrimaryImageItemId = program.Id.ToString("N");
+                        }
+                        catch (Exception ex)
+                        {
+                        }
+                    }
+                }
+            }
+
             return dto;
         }
 
@@ -244,6 +278,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 PostPaddingSeconds = dto.PostPaddingSeconds,
                 IsPostPaddingRequired = dto.IsPostPaddingRequired,
                 IsPrePaddingRequired = dto.IsPrePaddingRequired,
+                KeepUntil = dto.KeepUntil,
                 Priority = dto.Priority,
                 SeriesTimerId = dto.ExternalSeriesTimerId,
                 ProgramId = dto.ExternalProgramId,
@@ -308,6 +343,9 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 Priority = dto.Priority,
                 RecordAnyChannel = dto.RecordAnyChannel,
                 RecordAnyTime = dto.RecordAnyTime,
+                SkipEpisodesInLibrary = dto.SkipEpisodesInLibrary,
+                KeepUpTo = dto.KeepUpTo,
+                KeepUntil = dto.KeepUntil,
                 RecordNewOnly = dto.RecordNewOnly,
                 ProgramId = dto.ExternalProgramId,
                 ChannelId = dto.ExternalChannelId,
diff --git a/MediaBrowser.Server.Implementations/LiveTv/LiveTvManager.cs b/MediaBrowser.Server.Implementations/LiveTv/LiveTvManager.cs
index 88017aa59..a295320ec 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/LiveTvManager.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/LiveTvManager.cs
@@ -31,7 +31,11 @@ using CommonIO;
 using IniParser;
 using IniParser.Model;
 using MediaBrowser.Common.Events;
+using MediaBrowser.Common.Security;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Model.Events;
+using MediaBrowser.Server.Implementations.LiveTv.Listings;
 
 namespace MediaBrowser.Server.Implementations.LiveTv
 {
@@ -49,6 +53,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
         private readonly ITaskManager _taskManager;
         private readonly IJsonSerializer _jsonSerializer;
         private readonly IProviderManager _providerManager;
+        private readonly ISecurityManager _security;
 
         private readonly IDtoService _dtoService;
         private readonly ILocalizationManager _localization;
@@ -57,9 +62,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
         private readonly List<ILiveTvService> _services = new List<ILiveTvService>();
 
-        private readonly ConcurrentDictionary<string, LiveStreamData> _openStreams =
-            new ConcurrentDictionary<string, LiveStreamData>();
-
         private readonly SemaphoreSlim _refreshRecordingsLock = new SemaphoreSlim(1, 1);
 
         private readonly List<ITunerHost> _tunerHosts = new List<ITunerHost>();
@@ -71,7 +73,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
         public event EventHandler<GenericEventArgs<TimerEventInfo>> TimerCreated;
         public event EventHandler<GenericEventArgs<TimerEventInfo>> SeriesTimerCreated;
 
-        public LiveTvManager(IApplicationHost appHost, IServerConfigurationManager config, ILogger logger, IItemRepository itemRepo, IImageProcessor imageProcessor, IUserDataManager userDataManager, IDtoService dtoService, IUserManager userManager, ILibraryManager libraryManager, ITaskManager taskManager, ILocalizationManager localization, IJsonSerializer jsonSerializer, IProviderManager providerManager, IFileSystem fileSystem)
+        public LiveTvManager(IApplicationHost appHost, IServerConfigurationManager config, ILogger logger, IItemRepository itemRepo, IImageProcessor imageProcessor, IUserDataManager userDataManager, IDtoService dtoService, IUserManager userManager, ILibraryManager libraryManager, ITaskManager taskManager, ILocalizationManager localization, IJsonSerializer jsonSerializer, IProviderManager providerManager, IFileSystem fileSystem, ISecurityManager security)
         {
             _config = config;
             _logger = logger;
@@ -83,6 +85,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             _jsonSerializer = jsonSerializer;
             _providerManager = providerManager;
             _fileSystem = fileSystem;
+            _security = security;
             _dtoService = dtoService;
             _userDataManager = userDataManager;
 
@@ -145,112 +148,40 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
             var topFolder = await GetInternalLiveTvFolder(cancellationToken).ConfigureAwait(false);
 
-            var channels = _libraryManager.GetItemList(new InternalItemsQuery
+            var internalQuery = new InternalItemsQuery(user)
             {
+                IsMovie = query.IsMovie,
+                IsNews = query.IsNews,
+                IsKids = query.IsKids,
+                IsSports = query.IsSports,
+                IsSeries = query.IsSeries,
                 IncludeItemTypes = new[] { typeof(LiveTvChannel).Name },
-                SortBy = new[] { ItemSortBy.SortName },
-                TopParentIds = new[] { topFolder.Id.ToString("N") }
+                SortOrder = query.SortOrder ?? SortOrder.Ascending,
+                TopParentIds = new[] { topFolder.Id.ToString("N") },
+                IsFavorite = query.IsFavorite,
+                IsLiked = query.IsLiked,
+                StartIndex = query.StartIndex,
+                Limit = query.Limit
+            };
 
-            }).Cast<LiveTvChannel>();
+            internalQuery.OrderBy.AddRange(query.SortBy.Select(i => new Tuple<string, SortOrder>(i, query.SortOrder ?? SortOrder.Ascending)));
 
-            if (user != null)
+            if (query.EnableFavoriteSorting)
             {
-                // Avoid implicitly captured closure
-                var currentUser = user;
-
-                channels = channels
-                    .Where(i => i.IsVisible(currentUser))
-                    .OrderBy(i =>
-                    {
-                        double number = 0;
-
-                        if (!string.IsNullOrEmpty(i.Number))
-                        {
-                            double.TryParse(i.Number, out number);
-                        }
-
-                        return number;
-
-                    });
-
-                if (query.IsFavorite.HasValue)
-                {
-                    var val = query.IsFavorite.Value;
-
-                    channels = channels
-                        .Where(i => _userDataManager.GetUserData(user, i).IsFavorite == val);
-                }
-
-                if (query.IsLiked.HasValue)
-                {
-                    var val = query.IsLiked.Value;
-
-                    channels = channels
-                        .Where(i =>
-                        {
-                            var likes = _userDataManager.GetUserData(user, i).Likes;
-
-                            return likes.HasValue && likes.Value == val;
-                        });
-                }
-
-                if (query.IsDisliked.HasValue)
-                {
-                    var val = query.IsDisliked.Value;
-
-                    channels = channels
-                        .Where(i =>
-                        {
-                            var likes = _userDataManager.GetUserData(user, i).Likes;
-
-                            return likes.HasValue && likes.Value != val;
-                        });
-                }
+                internalQuery.OrderBy.Insert(0, new Tuple<string, SortOrder>(ItemSortBy.IsFavoriteOrLiked, SortOrder.Descending));
             }
 
-            var enableFavoriteSorting = query.EnableFavoriteSorting;
-
-            channels = channels.OrderBy(i =>
-            {
-                if (enableFavoriteSorting)
-                {
-                    var userData = _userDataManager.GetUserData(user, i);
-
-                    if (userData.IsFavorite)
-                    {
-                        return 0;
-                    }
-                    if (userData.Likes.HasValue)
-                    {
-                        if (!userData.Likes.Value)
-                        {
-                            return 3;
-                        }
-
-                        return 1;
-                    }
-                }
-
-                return 2;
-            });
-
-            var allChannels = channels.ToList();
-            IEnumerable<LiveTvChannel> allEnumerable = allChannels;
-
-            if (query.StartIndex.HasValue)
+            if (!internalQuery.OrderBy.Any(i => string.Equals(i.Item1, ItemSortBy.SortName, StringComparison.OrdinalIgnoreCase)))
             {
-                allEnumerable = allEnumerable.Skip(query.StartIndex.Value);
+                internalQuery.OrderBy.Add(new Tuple<string, SortOrder>(ItemSortBy.SortName, SortOrder.Ascending));
             }
 
-            if (query.Limit.HasValue)
-            {
-                allEnumerable = allEnumerable.Take(query.Limit.Value);
-            }
+            var channelResult = _libraryManager.GetItemsResult(internalQuery);
 
             var result = new QueryResult<LiveTvChannel>
             {
-                Items = allEnumerable.ToArray(),
-                TotalRecordCount = allChannels.Count
+                Items = channelResult.Items.Cast<LiveTvChannel>().ToArray(),
+                TotalRecordCount = channelResult.TotalRecordCount
             };
 
             return result;
@@ -292,32 +223,32 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             return result.Items.FirstOrDefault();
         }
 
-        private readonly SemaphoreSlim _liveStreamSemaphore = new SemaphoreSlim(1, 1);
-
         public async Task<MediaSourceInfo> GetRecordingStream(string id, CancellationToken cancellationToken)
         {
-            return await GetLiveStream(id, null, false, cancellationToken).ConfigureAwait(false);
+            var info = await GetLiveStream(id, null, false, cancellationToken).ConfigureAwait(false);
+
+            return info.Item1;
         }
 
-        public async Task<MediaSourceInfo> GetChannelStream(string id, string mediaSourceId, CancellationToken cancellationToken)
+        public async Task<Tuple<MediaSourceInfo, IDirectStreamProvider>> GetChannelStream(string id, string mediaSourceId, CancellationToken cancellationToken)
         {
             return await GetLiveStream(id, mediaSourceId, true, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<IEnumerable<MediaSourceInfo>> GetRecordingMediaSources(string id, CancellationToken cancellationToken)
+        public async Task<IEnumerable<MediaSourceInfo>> GetRecordingMediaSources(IHasMediaSources item, CancellationToken cancellationToken)
         {
-            var item = await GetInternalRecording(id, cancellationToken).ConfigureAwait(false);
-            var service = GetService(item);
+            var baseItem = (BaseItem)item;
+            var service = GetService(baseItem);
 
-            return await service.GetRecordingStreamMediaSources(id, cancellationToken).ConfigureAwait(false);
+            return await service.GetRecordingStreamMediaSources(baseItem.ExternalId, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<IEnumerable<MediaSourceInfo>> GetChannelMediaSources(string id, CancellationToken cancellationToken)
+        public async Task<IEnumerable<MediaSourceInfo>> GetChannelMediaSources(IHasMediaSources item, CancellationToken cancellationToken)
         {
-            var item = GetInternalChannel(id);
-            var service = GetService(item);
+            var baseItem = (LiveTvChannel)item;
+            var service = GetService(baseItem);
 
-            var sources = await service.GetChannelStreamMediaSources(item.ExternalId, cancellationToken).ConfigureAwait(false);
+            var sources = await service.GetChannelStreamMediaSources(baseItem.ExternalId, cancellationToken).ConfigureAwait(false);
 
             if (sources.Count == 0)
             {
@@ -328,7 +259,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
             foreach (var source in list)
             {
-                Normalize(source, service, item.ChannelType == ChannelType.TV);
+                Normalize(source, service, baseItem.ChannelType == ChannelType.TV);
             }
 
             return list;
@@ -349,79 +280,67 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             return _services.FirstOrDefault(i => string.Equals(i.Name, name, StringComparison.OrdinalIgnoreCase));
         }
 
-        private async Task<MediaSourceInfo> GetLiveStream(string id, string mediaSourceId, bool isChannel, CancellationToken cancellationToken)
+        private async Task<Tuple<MediaSourceInfo, IDirectStreamProvider>> GetLiveStream(string id, string mediaSourceId, bool isChannel, CancellationToken cancellationToken)
         {
-            await _liveStreamSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
-
             if (string.Equals(id, mediaSourceId, StringComparison.OrdinalIgnoreCase))
             {
                 mediaSourceId = null;
             }
 
-            try
+            MediaSourceInfo info;
+            bool isVideo;
+            ILiveTvService service;
+            IDirectStreamProvider directStreamProvider = null;
+
+            if (isChannel)
             {
-                MediaSourceInfo info;
-                bool isVideo;
-                ILiveTvService service;
+                var channel = GetInternalChannel(id);
+                isVideo = channel.ChannelType == ChannelType.TV;
+                service = GetService(channel);
+                _logger.Info("Opening channel stream from {0}, external channel Id: {1}", service.Name, channel.ExternalId);
 
-                if (isChannel)
+                var supportsManagedStream = service as ISupportsDirectStreamProvider;
+                if (supportsManagedStream != null)
                 {
-                    var channel = GetInternalChannel(id);
-                    isVideo = channel.ChannelType == ChannelType.TV;
-                    service = GetService(channel);
-                    _logger.Info("Opening channel stream from {0}, external channel Id: {1}", service.Name, channel.ExternalId);
-                    info = await service.GetChannelStream(channel.ExternalId, mediaSourceId, cancellationToken).ConfigureAwait(false);
-                    info.RequiresClosing = true;
-
-                    if (info.RequiresClosing)
-                    {
-                        var idPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
-
-                        info.LiveStreamId = idPrefix + info.Id;
-                    }
+                    var streamInfo = await supportsManagedStream.GetChannelStreamWithDirectStreamProvider(channel.ExternalId, mediaSourceId, cancellationToken).ConfigureAwait(false);
+                    info = streamInfo.Item1;
+                    directStreamProvider = streamInfo.Item2;
                 }
                 else
                 {
-                    var recording = await GetInternalRecording(id, cancellationToken).ConfigureAwait(false);
-                    isVideo = !string.Equals(recording.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase);
-                    service = GetService(recording);
-
-                    _logger.Info("Opening recording stream from {0}, external recording Id: {1}", service.Name, recording.ExternalId);
-                    info = await service.GetRecordingStream(recording.ExternalId, null, cancellationToken).ConfigureAwait(false);
-                    info.RequiresClosing = true;
+                    info = await service.GetChannelStream(channel.ExternalId, mediaSourceId, cancellationToken).ConfigureAwait(false);
+                }
+                info.RequiresClosing = true;
 
-                    if (info.RequiresClosing)
-                    {
-                        var idPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
+                if (info.RequiresClosing)
+                {
+                    var idPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
 
-                        info.LiveStreamId = idPrefix + info.Id;
-                    }
+                    info.LiveStreamId = idPrefix + info.Id;
                 }
+            }
+            else
+            {
+                var recording = await GetInternalRecording(id, cancellationToken).ConfigureAwait(false);
+                isVideo = !string.Equals(recording.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase);
+                service = GetService(recording);
 
-                _logger.Info("Live stream info: {0}", _jsonSerializer.SerializeToString(info));
-                Normalize(info, service, isVideo);
+                _logger.Info("Opening recording stream from {0}, external recording Id: {1}", service.Name, recording.ExternalId);
+                info = await service.GetRecordingStream(recording.ExternalId, null, cancellationToken).ConfigureAwait(false);
+                info.RequiresClosing = true;
 
-                var data = new LiveStreamData
+                if (info.RequiresClosing)
                 {
-                    Info = info,
-                    IsChannel = isChannel,
-                    ItemId = id
-                };
+                    var idPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
 
-                _openStreams.AddOrUpdate(info.Id, data, (key, i) => data);
-
-                return info;
+                    info.LiveStreamId = idPrefix + info.Id;
+                }
             }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error getting channel stream", ex);
 
-                throw;
-            }
-            finally
-            {
-                _liveStreamSemaphore.Release();
-            }
+            _logger.Info("Live stream info: {0}", _jsonSerializer.SerializeToString(info));
+            Normalize(info, service, isVideo);
+
+            return new Tuple<MediaSourceInfo, IDirectStreamProvider>(info, directStreamProvider);
         }
 
         private void Normalize(MediaSourceInfo mediaSource, ILiveTvService service, bool isVideo)
@@ -622,11 +541,13 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             return item;
         }
 
-        private async Task<LiveTvProgram> GetProgram(ProgramInfo info, LiveTvChannel channel, ChannelType channelType, string serviceName, CancellationToken cancellationToken)
+        private Tuple<LiveTvProgram, bool, bool> GetProgram(ProgramInfo info, Dictionary<Guid, LiveTvProgram> allExistingPrograms, LiveTvChannel channel, ChannelType channelType, string serviceName, CancellationToken cancellationToken)
         {
             var id = _tvDtoService.GetInternalProgramId(serviceName, info.Id);
 
-            var item = _libraryManager.GetItemById(id) as LiveTvProgram;
+            LiveTvProgram item = null;
+            allExistingPrograms.TryGetValue(id, out item);
+
             var isNew = false;
             var forceUpdate = false;
 
@@ -643,6 +564,8 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 };
             }
 
+            var seriesId = info.SeriesId;
+
             if (!item.ParentId.Equals(channel.Id))
             {
                 forceUpdate = true;
@@ -662,6 +585,14 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
             item.EpisodeTitle = info.EpisodeTitle;
             item.ExternalId = info.Id;
+            item.ExternalSeriesIdLegacy = seriesId;
+
+            if (!string.IsNullOrWhiteSpace(seriesId) && !string.Equals(item.ExternalSeriesId, seriesId, StringComparison.Ordinal))
+            {
+                forceUpdate = true;
+            }
+            item.ExternalSeriesId = seriesId;
+
             item.Genres = info.Genres;
             item.IsHD = info.IsHD;
             item.IsKids = info.IsKids;
@@ -692,7 +623,11 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             item.HomePageUrl = info.HomePageUrl;
 
             item.ProductionYear = info.ProductionYear;
-            item.PremiereDate = info.OriginalAirDate;
+
+            if (!info.IsSeries || info.IsRepeat)
+            {
+                item.PremiereDate = info.OriginalAirDate;
+            }
 
             item.IndexNumber = info.EpisodeNumber;
             item.ParentIndexNumber = info.SeasonNumber;
@@ -719,13 +654,13 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 }
             }
 
+            var isUpdated = false;
             if (isNew)
             {
-                await _libraryManager.CreateItem(item, cancellationToken).ConfigureAwait(false);
             }
             else if (forceUpdate || string.IsNullOrWhiteSpace(info.Etag))
             {
-                await _libraryManager.UpdateItem(item, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
+                isUpdated = true;
             }
             else
             {
@@ -735,13 +670,11 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 if (!string.Equals(etag, item.ExternalEtag, StringComparison.OrdinalIgnoreCase))
                 {
                     item.ExternalEtag = etag;
-                    await _libraryManager.UpdateItem(item, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
+                    isUpdated = true;
                 }
             }
 
-            _providerManager.QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem));
-
-            return item;
+            return new Tuple<LiveTvProgram, bool, bool>(item, isNew, isUpdated);
         }
 
         private async Task<Guid> CreateRecordingRecord(RecordingInfo info, string serviceName, Guid parentFolderId, CancellationToken cancellationToken)
@@ -805,6 +738,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             recording.IsRepeat = info.IsRepeat;
             recording.IsSports = info.IsSports;
             recording.SeriesTimerId = info.SeriesTimerId;
+            recording.TimerId = info.TimerId;
             recording.StartDate = info.StartDate;
 
             if (!dataChanged)
@@ -897,8 +831,8 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
             var dto = _dtoService.GetBaseItemDto(program, new DtoOptions(), user);
 
-            var list = new List<Tuple<BaseItemDto, string, string>>();
-            list.Add(new Tuple<BaseItemDto, string, string>(dto, program.ServiceName, program.ExternalId));
+            var list = new List<Tuple<BaseItemDto, string, string, string>>();
+            list.Add(new Tuple<BaseItemDto, string, string, string>(dto, program.ServiceName, program.ExternalId, program.ExternalSeriesIdLegacy));
 
             await AddRecordingInfo(list, cancellationToken).ConfigureAwait(false);
 
@@ -926,17 +860,41 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 MaxStartDate = query.MaxStartDate,
                 ChannelIds = query.ChannelIds,
                 IsMovie = query.IsMovie,
+                IsSeries = query.IsSeries,
                 IsSports = query.IsSports,
                 IsKids = query.IsKids,
+                IsNews = query.IsNews,
                 Genres = query.Genres,
                 StartIndex = query.StartIndex,
                 Limit = query.Limit,
                 SortBy = query.SortBy,
                 SortOrder = query.SortOrder ?? SortOrder.Ascending,
                 EnableTotalRecordCount = query.EnableTotalRecordCount,
-                TopParentIds = new[] { topFolder.Id.ToString("N") }
+                TopParentIds = new[] { topFolder.Id.ToString("N") },
+                DtoOptions = options
             };
 
+            if (!string.IsNullOrWhiteSpace(query.SeriesTimerId))
+            {
+                var seriesTimers = await GetSeriesTimersInternal(new SeriesTimerQuery { }, cancellationToken).ConfigureAwait(false);
+                var seriesTimer = seriesTimers.Items.FirstOrDefault(i => string.Equals(_tvDtoService.GetInternalSeriesTimerId(i.ServiceName, i.Id).ToString("N"), query.SeriesTimerId, StringComparison.OrdinalIgnoreCase));
+                if (seriesTimer != null)
+                {
+                    internalQuery.ExternalSeriesId = seriesTimer.SeriesId;
+
+                    if (string.IsNullOrWhiteSpace(seriesTimer.SeriesId))
+                    {
+                        // Better to return nothing than every program in the database
+                        return new QueryResult<BaseItemDto>();
+                    }
+                }
+                else
+                {
+                    // Better to return nothing than every program in the database
+                    return new QueryResult<BaseItemDto>();
+                }
+            }
+
             if (query.HasAired.HasValue)
             {
                 if (query.HasAired.Value)
@@ -964,7 +922,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             return result;
         }
 
-        public async Task<QueryResult<LiveTvProgram>> GetRecommendedProgramsInternal(RecommendedProgramQuery query, CancellationToken cancellationToken)
+        public async Task<QueryResult<LiveTvProgram>> GetRecommendedProgramsInternal(RecommendedProgramQuery query, DtoOptions options, CancellationToken cancellationToken)
         {
             var user = _userManager.GetUserById(query.UserId);
 
@@ -974,12 +932,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             {
                 IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
                 IsAiring = query.IsAiring,
+                IsNews = query.IsNews,
                 IsMovie = query.IsMovie,
+                IsSeries = query.IsSeries,
                 IsSports = query.IsSports,
                 IsKids = query.IsKids,
                 EnableTotalRecordCount = query.EnableTotalRecordCount,
                 SortBy = new[] { ItemSortBy.StartDate },
-                TopParentIds = new[] { topFolder.Id.ToString("N") }
+                TopParentIds = new[] { topFolder.Id.ToString("N") },
+                DtoOptions = options
             };
 
             if (query.Limit.HasValue)
@@ -1003,9 +964,9 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
             var programList = programs.ToList();
 
-            var factorChannelWatchCount = (query.IsAiring ?? false) || (query.IsKids ?? false) || (query.IsSports ?? false) || (query.IsMovie ?? false);
+            var factorChannelWatchCount = (query.IsAiring ?? false) || (query.IsKids ?? false) || (query.IsSports ?? false) || (query.IsMovie ?? false) || (query.IsNews ?? false) || (query.IsSeries ?? false);
 
-            programs = programList.OrderBy(i => i.HasImage(ImageType.Primary) ? 0 : 1)
+            programs = programList.OrderBy(i => i.StartDate.Date)
                 .ThenByDescending(i => GetRecommendationScore(i, user.Id, factorChannelWatchCount))
                 .ThenBy(i => i.StartDate);
 
@@ -1029,7 +990,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
         public async Task<QueryResult<BaseItemDto>> GetRecommendedPrograms(RecommendedProgramQuery query, DtoOptions options, CancellationToken cancellationToken)
         {
-            var internalResult = await GetRecommendedProgramsInternal(query, cancellationToken).ConfigureAwait(false);
+            var internalResult = await GetRecommendedProgramsInternal(query, options, cancellationToken).ConfigureAwait(false);
 
             var user = _userManager.GetUserById(query.UserId);
 
@@ -1086,15 +1047,17 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             return score;
         }
 
-        private async Task AddRecordingInfo(IEnumerable<Tuple<BaseItemDto, string, string>> programs, CancellationToken cancellationToken)
+        private async Task AddRecordingInfo(IEnumerable<Tuple<BaseItemDto, string, string, string>> programs, CancellationToken cancellationToken)
         {
             var timers = new Dictionary<string, List<TimerInfo>>();
+            var seriesTimers = new Dictionary<string, List<SeriesTimerInfo>>();
 
             foreach (var programTuple in programs)
             {
                 var program = programTuple.Item1;
                 var serviceName = programTuple.Item2;
                 var externalProgramId = programTuple.Item3;
+                string externalSeriesId = programTuple.Item4;
 
                 if (string.IsNullOrWhiteSpace(serviceName))
                 {
@@ -1117,18 +1080,54 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 }
 
                 var timer = timerList.FirstOrDefault(i => string.Equals(i.ProgramId, externalProgramId, StringComparison.OrdinalIgnoreCase));
+                var foundSeriesTimer = false;
 
                 if (timer != null)
                 {
-                    program.TimerId = _tvDtoService.GetInternalTimerId(serviceName, timer.Id)
-                        .ToString("N");
+                    if (timer.Status != RecordingStatus.Cancelled && timer.Status != RecordingStatus.Error)
+                    {
+                        program.TimerId = _tvDtoService.GetInternalTimerId(serviceName, timer.Id)
+                            .ToString("N");
+
+                        program.Status = timer.Status.ToString();
+                    }
 
                     if (!string.IsNullOrEmpty(timer.SeriesTimerId))
                     {
                         program.SeriesTimerId = _tvDtoService.GetInternalSeriesTimerId(serviceName, timer.SeriesTimerId)
                             .ToString("N");
+
+                        foundSeriesTimer = true;
                     }
                 }
+
+                if (foundSeriesTimer || string.IsNullOrWhiteSpace(externalSeriesId))
+                {
+                    continue;
+                }
+
+                List<SeriesTimerInfo> seriesTimerList;
+                if (!seriesTimers.TryGetValue(serviceName, out seriesTimerList))
+                {
+                    try
+                    {
+                        var tempTimers = await GetService(serviceName).GetSeriesTimersAsync(cancellationToken).ConfigureAwait(false);
+                        seriesTimers[serviceName] = seriesTimerList = tempTimers.ToList();
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.ErrorException("Error getting series timer infos", ex);
+                        seriesTimers[serviceName] = seriesTimerList = new List<SeriesTimerInfo>();
+                    }
+                }
+
+                var seriesTimer = seriesTimerList.FirstOrDefault(i => string.Equals(i.SeriesId, externalSeriesId, StringComparison.OrdinalIgnoreCase));
+
+                if (seriesTimer != null)
+                {
+                    program.SeriesTimerId = _tvDtoService.GetInternalSeriesTimerId(serviceName, seriesTimer.Id)
+                        .ToString("N");
+                }
             }
         }
 
@@ -1261,14 +1260,96 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                     var start = DateTime.UtcNow.AddHours(-1);
                     var end = start.AddDays(guideDays);
 
+                    var isMovie = false;
+                    var isSports = false;
+                    var isNews = false;
+                    var isKids = false;
+                    var iSSeries = false;
+
                     var channelPrograms = await service.GetProgramsAsync(currentChannel.ExternalId, start, end, cancellationToken).ConfigureAwait(false);
 
+                    var existingPrograms = _libraryManager.GetItemList(new InternalItemsQuery
+                    {
+
+                        IncludeItemTypes = new string[] { typeof(LiveTvProgram).Name },
+                        ChannelIds = new string[] { currentChannel.Id.ToString("N") }
+
+                    }).Cast<LiveTvProgram>().ToDictionary(i => i.Id);
+
+                    var newPrograms = new List<LiveTvProgram>();
+                    var updatedPrograms = new List<LiveTvProgram>();
+
                     foreach (var program in channelPrograms)
                     {
-                        var programItem = await GetProgram(program, currentChannel, currentChannel.ChannelType, service.Name, cancellationToken).ConfigureAwait(false);
+                        var programTuple = GetProgram(program, existingPrograms, currentChannel, currentChannel.ChannelType, service.Name, cancellationToken);
+                        var programItem = programTuple.Item1;
+
+                        if (programTuple.Item2)
+                        {
+                            newPrograms.Add(programItem);
+                        }
+                        else if (programTuple.Item3)
+                        {
+                            updatedPrograms.Add(programItem);
+                        }
 
                         programs.Add(programItem.Id);
+
+                        if (program.IsMovie)
+                        {
+                            isMovie = true;
+                        }
+
+                        if (program.IsSeries)
+                        {
+                            iSSeries = true;
+                        }
+
+                        if (program.IsSports)
+                        {
+                            isSports = true;
+                        }
+
+                        if (program.IsNews)
+                        {
+                            isNews = true;
+                        }
+
+                        if (program.IsKids)
+                        {
+                            isKids = true;
+                        }
+                    }
+
+                    _logger.Debug("Channel {0} has {1} new programs and {2} updated programs", currentChannel.Name, newPrograms.Count, updatedPrograms.Count);
+
+                    if (newPrograms.Count > 0)
+                    {
+                        await _libraryManager.CreateItems(newPrograms, cancellationToken).ConfigureAwait(false);
+                    }
+
+                    // TODO: Do this in bulk
+                    foreach (var program in updatedPrograms)
+                    {
+                        await _libraryManager.UpdateItem(program, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
                     }
+
+                    foreach (var program in newPrograms)
+                    {
+                        _providerManager.QueueRefresh(program.Id, new MetadataRefreshOptions(_fileSystem));
+                    }
+                    foreach (var program in updatedPrograms)
+                    {
+                        _providerManager.QueueRefresh(program.Id, new MetadataRefreshOptions(_fileSystem));
+                    }
+
+                    currentChannel.IsMovie = isMovie;
+                    currentChannel.IsNews = isNews;
+                    currentChannel.IsSports = isSports;
+                    currentChannel.IsKids = isKids;
+                    currentChannel.IsSeries = iSSeries;
+
+                    await currentChannel.UpdateToRepository(ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
                 }
                 catch (OperationCanceledException)
                 {
@@ -1355,7 +1436,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
         private DateTime _lastRecordingRefreshTime;
         private async Task RefreshRecordings(CancellationToken cancellationToken)
         {
-            const int cacheMinutes = 5;
+            const int cacheMinutes = 3;
 
             if ((DateTime.UtcNow - _lastRecordingRefreshTime).TotalMinutes < cacheMinutes)
             {
@@ -1403,9 +1484,14 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             }
         }
 
-        private QueryResult<BaseItem> GetEmbyRecordings(RecordingQuery query, User user)
+        private QueryResult<BaseItem> GetEmbyRecordings(RecordingQuery query, DtoOptions dtoOptions, User user)
         {
-            if (user == null || (query.IsInProgress ?? false))
+            if (user == null)
+            {
+                return new QueryResult<BaseItem>();
+            }
+
+            if ((query.IsInProgress ?? false))
             {
                 return new QueryResult<BaseItem>();
             }
@@ -1423,6 +1509,49 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 return new QueryResult<BaseItem>();
             }
 
+            var includeItemTypes = new List<string>();
+            var excludeItemTypes = new List<string>();
+            var genres = new List<string>();
+
+            if (query.IsMovie.HasValue)
+            {
+                if (query.IsMovie.Value)
+                {
+                    includeItemTypes.Add(typeof(Movie).Name);
+                }
+                else
+                {
+                    excludeItemTypes.Add(typeof(Movie).Name);
+                }
+            }
+            if (query.IsSeries.HasValue)
+            {
+                if (query.IsSeries.Value)
+                {
+                    includeItemTypes.Add(typeof(Episode).Name);
+                }
+                else
+                {
+                    excludeItemTypes.Add(typeof(Episode).Name);
+                }
+            }
+            if (query.IsSports.HasValue)
+            {
+                if (query.IsSports.Value)
+                {
+                    genres.Add("Sports");
+                }
+            }
+            if (query.IsKids.HasValue)
+            {
+                if (query.IsKids.Value)
+                {
+                    genres.Add("Kids");
+                    genres.Add("Children");
+                    genres.Add("Family");
+                }
+            }
+
             return _libraryManager.GetItemsResult(new InternalItemsQuery(user)
             {
                 MediaTypes = new[] { MediaType.Video },
@@ -1430,11 +1559,74 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 AncestorIds = folders.Select(i => i.Id.ToString("N")).ToArray(),
                 IsFolder = false,
                 ExcludeLocationTypes = new[] { LocationType.Virtual },
-                Limit = Math.Min(200, query.Limit ?? int.MaxValue),
+                Limit = query.Limit,
+                SortBy = new[] { ItemSortBy.DateCreated },
+                SortOrder = SortOrder.Descending,
+                EnableTotalRecordCount = query.EnableTotalRecordCount,
+                IncludeItemTypes = includeItemTypes.ToArray(),
+                ExcludeItemTypes = excludeItemTypes.ToArray(),
+                Genres = genres.ToArray(),
+                DtoOptions = dtoOptions
+            });
+        }
+
+        public async Task<QueryResult<BaseItemDto>> GetRecordingSeries(RecordingQuery query, DtoOptions options, CancellationToken cancellationToken)
+        {
+            var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
+            if (user != null && !IsLiveTvEnabled(user))
+            {
+                return new QueryResult<BaseItemDto>();
+            }
+
+            if (_services.Count > 1)
+            {
+                return new QueryResult<BaseItemDto>();
+            }
+
+            if (user == null || (query.IsInProgress ?? false))
+            {
+                return new QueryResult<BaseItemDto>();
+            }
+
+            var folders = EmbyTV.EmbyTV.Current.GetRecordingFolders()
+                .SelectMany(i => i.Locations)
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .Select(i => _libraryManager.FindByPath(i, true))
+                .Where(i => i != null)
+                .Where(i => i.IsVisibleStandalone(user))
+                .ToList();
+
+            if (folders.Count == 0)
+            {
+                return new QueryResult<BaseItemDto>();
+            }
+
+            var includeItemTypes = new List<string>();
+            var excludeItemTypes = new List<string>();
+
+            includeItemTypes.Add(typeof(Series).Name);
+
+            var internalResult = _libraryManager.GetItemsResult(new InternalItemsQuery(user)
+            {
+                Recursive = true,
+                AncestorIds = folders.Select(i => i.Id.ToString("N")).ToArray(),
+                Limit = query.Limit,
                 SortBy = new[] { ItemSortBy.DateCreated },
                 SortOrder = SortOrder.Descending,
-                EnableTotalRecordCount = query.EnableTotalRecordCount
+                EnableTotalRecordCount = query.EnableTotalRecordCount,
+                IncludeItemTypes = includeItemTypes.ToArray(),
+                ExcludeItemTypes = excludeItemTypes.ToArray()
             });
+
+            RemoveFields(options);
+
+            var returnArray = (await _dtoService.GetBaseItemDtos(internalResult.Items, options, user).ConfigureAwait(false)).ToArray();
+
+            return new QueryResult<BaseItemDto>
+            {
+                Items = returnArray,
+                TotalRecordCount = internalResult.TotalRecordCount
+            };
         }
 
         public async Task<QueryResult<BaseItem>> GetInternalRecordings(RecordingQuery query, CancellationToken cancellationToken)
@@ -1445,9 +1637,9 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 return new QueryResult<BaseItem>();
             }
 
-            if (_services.Count == 1)
+            if (_services.Count == 1 && !(query.IsInProgress ?? false))
             {
-                return GetEmbyRecordings(query, user);
+                return GetEmbyRecordings(query, new DtoOptions(), user);
             }
 
             await RefreshRecordings(cancellationToken).ConfigureAwait(false);
@@ -1492,6 +1684,36 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 recordings = recordings.Where(i => i.Status == val);
             }
 
+            if (query.IsMovie.HasValue)
+            {
+                var val = query.IsMovie.Value;
+                recordings = recordings.Where(i => i.IsMovie == val);
+            }
+
+            if (query.IsNews.HasValue)
+            {
+                var val = query.IsNews.Value;
+                recordings = recordings.Where(i => i.IsNews == val);
+            }
+
+            if (query.IsSeries.HasValue)
+            {
+                var val = query.IsSeries.Value;
+                recordings = recordings.Where(i => i.IsSeries == val);
+            }
+
+            if (query.IsKids.HasValue)
+            {
+                var val = query.IsKids.Value;
+                recordings = recordings.Where(i => i.IsKids == val);
+            }
+
+            if (query.IsSports.HasValue)
+            {
+                var val = query.IsSports.Value;
+                recordings = recordings.Where(i => i.IsSports == val);
+            }
+
             if (!string.IsNullOrEmpty(query.SeriesTimerId))
             {
                 var guid = new Guid(query.SeriesTimerId);
@@ -1524,7 +1746,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
         public async Task AddInfoToProgramDto(List<Tuple<BaseItem, BaseItemDto>> tuples, List<ItemFields> fields, User user = null)
         {
-            var recordingTuples = new List<Tuple<BaseItemDto, string, string>>();
+            var recordingTuples = new List<Tuple<BaseItemDto, string, string, string>>();
 
             foreach (var tuple in tuples)
             {
@@ -1592,7 +1814,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                     dto.ServiceName = serviceName;
                 }
 
-                recordingTuples.Add(new Tuple<BaseItemDto, string, string>(dto, serviceName, program.ExternalId));
+                recordingTuples.Add(new Tuple<BaseItemDto, string, string, string>(dto, serviceName, program.ExternalId, program.ExternalSeriesIdLegacy));
             }
 
             await AddRecordingInfo(recordingTuples, CancellationToken.None).ConfigureAwait(false);
@@ -1611,6 +1833,10 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 ? null
                 : _tvDtoService.GetInternalSeriesTimerId(service.Name, info.SeriesTimerId).ToString("N");
 
+            dto.TimerId = string.IsNullOrEmpty(info.TimerId)
+                ? null
+                : _tvDtoService.GetInternalTimerId(service.Name, info.TimerId).ToString("N");
+
             dto.StartDate = info.StartDate;
             dto.RecordingStatus = info.Status;
             dto.IsRepeat = info.IsRepeat;
@@ -1707,6 +1933,18 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 }
             }
 
+            if (query.IsScheduled.HasValue)
+            {
+                if (query.IsScheduled.Value)
+                {
+                    timers = timers.Where(i => i.Item1.Status == RecordingStatus.New);
+                }
+                else
+                {
+                    timers = timers.Where(i => !(i.Item1.Status == RecordingStatus.New));
+                }
+            }
+
             if (!string.IsNullOrEmpty(query.ChannelId))
             {
                 var guid = new Guid(query.ChannelId);
@@ -1867,6 +2105,56 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             return results.Items.FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase));
         }
 
+        private async Task<QueryResult<SeriesTimerInfo>> GetSeriesTimersInternal(SeriesTimerQuery query, CancellationToken cancellationToken)
+        {
+            var tasks = _services.Select(async i =>
+            {
+                try
+                {
+                    var recs = await i.GetSeriesTimersAsync(cancellationToken).ConfigureAwait(false);
+                    return recs.Select(r =>
+                    {
+                        r.ServiceName = i.Name;
+                        return new Tuple<SeriesTimerInfo, ILiveTvService>(r, i);
+                    });
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error getting recordings", ex);
+                    return new List<Tuple<SeriesTimerInfo, ILiveTvService>>();
+                }
+            });
+            var results = await Task.WhenAll(tasks).ConfigureAwait(false);
+            var timers = results.SelectMany(i => i.ToList());
+
+            if (string.Equals(query.SortBy, "Priority", StringComparison.OrdinalIgnoreCase))
+            {
+                timers = query.SortOrder == SortOrder.Descending ?
+                    timers.OrderBy(i => i.Item1.Priority).ThenByStringDescending(i => i.Item1.Name) :
+                    timers.OrderByDescending(i => i.Item1.Priority).ThenByString(i => i.Item1.Name);
+            }
+            else
+            {
+                timers = query.SortOrder == SortOrder.Descending ?
+                    timers.OrderByStringDescending(i => i.Item1.Name) :
+                    timers.OrderByString(i => i.Item1.Name);
+            }
+
+            var returnArray = timers
+                .Select(i =>
+                {
+                    return i.Item1;
+
+                })
+                .ToArray();
+
+            return new QueryResult<SeriesTimerInfo>
+            {
+                Items = returnArray,
+                TotalRecordCount = returnArray.Length
+            };
+        }
+
         public async Task<QueryResult<SeriesTimerInfoDto>> GetSeriesTimers(SeriesTimerQuery query, CancellationToken cancellationToken)
         {
             var tasks = _services.Select(async i =>
@@ -1950,16 +2238,16 @@ namespace MediaBrowser.Server.Implementations.LiveTv
                 dto.Number = channel.Number;
                 dto.ChannelNumber = channel.Number;
                 dto.ChannelType = channel.ChannelType;
-                dto.ServiceName = GetService(channel).Name;
+                dto.ServiceName = channel.ServiceName;
 
                 if (options.Fields.Contains(ItemFields.MediaSources))
                 {
                     dto.MediaSources = channel.GetMediaSources(true).ToList();
                 }
 
-                var channelIdString = channel.Id.ToString("N");
                 if (options.AddCurrentProgram)
                 {
+                    var channelIdString = channel.Id.ToString("N");
                     var currentProgram = programs.FirstOrDefault(i => string.Equals(i.ChannelId, channelIdString));
 
                     if (currentProgram != null)
@@ -2091,6 +2379,14 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
         public async Task CreateSeriesTimer(SeriesTimerInfoDto timer, CancellationToken cancellationToken)
         {
+            var registration = await GetRegistrationInfo("seriesrecordings").ConfigureAwait(false);
+
+            if (!registration.IsValid)
+            {
+                _logger.Info("Creating series recordings requires an active Emby Premiere subscription.");
+                return;
+            }
+
             var service = GetService(timer.ServiceName);
 
             var info = await _tvDtoService.GetSeriesTimerInfo(timer, true, this, cancellationToken).ConfigureAwait(false);
@@ -2256,47 +2552,22 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             };
         }
 
-        class LiveStreamData
+        public async Task CloseLiveStream(string id)
         {
-            internal MediaSourceInfo Info;
-            internal string ItemId;
-            internal bool IsChannel;
-        }
+            var parts = id.Split(new[] { '_' }, 2);
 
-        public async Task CloseLiveStream(string id, CancellationToken cancellationToken)
-        {
-            await _liveStreamSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
+            var service = _services.FirstOrDefault(i => string.Equals(i.GetType().FullName.GetMD5().ToString("N"), parts[0], StringComparison.OrdinalIgnoreCase));
 
-            try
+            if (service == null)
             {
-                var parts = id.Split(new[] { '_' }, 2);
-
-                var service = _services.FirstOrDefault(i => string.Equals(i.GetType().FullName.GetMD5().ToString("N"), parts[0], StringComparison.OrdinalIgnoreCase));
-
-                if (service == null)
-                {
-                    throw new ArgumentException("Service not found.");
-                }
-
-                id = parts[1];
+                throw new ArgumentException("Service not found.");
+            }
 
-                LiveStreamData data;
-                _openStreams.TryRemove(id, out data);
+            id = parts[1];
 
-                _logger.Info("Closing live stream from {0}, stream Id: {1}", service.Name, id);
+            _logger.Info("Closing live stream from {0}, stream Id: {1}", service.Name, id);
 
-                await service.CloseLiveStream(id, cancellationToken).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error closing live stream", ex);
-
-                throw;
-            }
-            finally
-            {
-                _liveStreamSemaphore.Release();
-            }
+            await service.CloseLiveStream(id, CancellationToken.None).ConfigureAwait(false);
         }
 
         public GuideInfo GetGuideInfo()
@@ -2319,7 +2590,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             Dispose(true);
         }
 
-        private readonly object _disposeLock = new object();
         private bool _isDisposed = false;
         /// <summary>
         /// Releases unmanaged and - optionally - managed resources.
@@ -2330,18 +2600,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             if (dispose)
             {
                 _isDisposed = true;
-
-                lock (_disposeLock)
-                {
-                    foreach (var stream in _openStreams.Values.ToList())
-                    {
-                        var task = CloseLiveStream(stream.Info.Id, CancellationToken.None);
-
-                        Task.WaitAll(task);
-                    }
-
-                    _openStreams.Clear();
-                }
             }
         }
 
@@ -2477,7 +2735,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
         public async Task<TunerHostInfo> SaveTunerHost(TunerHostInfo info, bool dataSourceChanged = true)
         {
-            info = (TunerHostInfo)_jsonSerializer.DeserializeFromString(_jsonSerializer.SerializeToString(info), typeof(TunerHostInfo));
+            info = _jsonSerializer.DeserializeFromString<TunerHostInfo>(_jsonSerializer.SerializeToString(info));
 
             var provider = _tunerHosts.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
 
@@ -2518,7 +2776,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
         public async Task<ListingsProviderInfo> SaveListingProvider(ListingsProviderInfo info, bool validateLogin, bool validateListings)
         {
-            info = (ListingsProviderInfo)_jsonSerializer.DeserializeFromString(_jsonSerializer.SerializeToString(info), typeof(ListingsProviderInfo));
+            info = _jsonSerializer.DeserializeFromString< ListingsProviderInfo>(_jsonSerializer.SerializeToString(info));
 
             var provider = _listingProviders.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
 
@@ -2653,33 +2911,28 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             }
         }
 
-        public Task<MBRegistrationRecord> GetRegistrationInfo(string channelId, string programId, string feature)
+        public Task<MBRegistrationRecord> GetRegistrationInfo(string feature)
         {
-            ILiveTvService service;
-
-            if (string.IsNullOrWhiteSpace(programId))
+            if (string.Equals(feature, "seriesrecordings", StringComparison.OrdinalIgnoreCase))
             {
-                var channel = GetInternalChannel(channelId);
-                service = GetService(channel);
-            }
-            else
-            {
-                var program = GetInternalProgram(programId);
-                service = GetService(program);
+                feature = "embytvseriesrecordings";
             }
 
-            var hasRegistration = service as IHasRegistrationInfo;
-
-            if (hasRegistration != null)
+            if (string.Equals(feature, "dvr-l", StringComparison.OrdinalIgnoreCase))
             {
-                return hasRegistration.GetRegistrationInfo(feature);
+                var config = GetConfiguration();
+                if (config.TunerHosts.Count(i => i.IsEnabled) > 0 &&
+                    config.ListingProviders.Count(i => (i.EnableAllTuners || i.EnabledTuners.Length > 0) && string.Equals(i.Type, SchedulesDirect.TypeName, StringComparison.OrdinalIgnoreCase)) > 0)
+                {
+                    return Task.FromResult(new MBRegistrationRecord
+                    {
+                        IsRegistered = true,
+                        IsValid = true
+                    });
+                }
             }
 
-            return Task.FromResult(new MBRegistrationRecord
-            {
-                IsValid = true,
-                IsRegistered = true
-            });
+            return _security.GetRegistrationStatus(feature);
         }
 
         public List<NameValuePair> GetSatIniMappings()
diff --git a/MediaBrowser.Server.Implementations/LiveTv/LiveTvMediaSourceProvider.cs b/MediaBrowser.Server.Implementations/LiveTv/LiveTvMediaSourceProvider.cs
index cdba1873e..521f33e1c 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/LiveTvMediaSourceProvider.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/LiveTvMediaSourceProvider.cs
@@ -9,9 +9,11 @@ using MediaBrowser.Model.MediaInfo;
 using MediaBrowser.Model.Serialization;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using MediaBrowser.Model.Dlna;
 
 namespace MediaBrowser.Server.Implementations.LiveTv
 {
@@ -63,12 +65,12 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             {
                 if (item is ILiveTvRecording)
                 {
-                    sources = await _liveTvManager.GetRecordingMediaSources(item.Id.ToString("N"), cancellationToken)
+                    sources = await _liveTvManager.GetRecordingMediaSources(item, cancellationToken)
                                 .ConfigureAwait(false);
                 }
                 else
                 {
-                    sources = await _liveTvManager.GetChannelMediaSources(item.Id.ToString("N"), cancellationToken)
+                    sources = await _liveTvManager.GetChannelMediaSources(item, cancellationToken)
                                 .ConfigureAwait(false);
                 }
             }
@@ -116,17 +118,20 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             return list;
         }
 
-        public async Task<MediaSourceInfo> OpenMediaSource(string openToken, CancellationToken cancellationToken)
+        public async Task<Tuple<MediaSourceInfo, IDirectStreamProvider>> OpenMediaSource(string openToken, CancellationToken cancellationToken)
         {
-            MediaSourceInfo stream;
+            MediaSourceInfo stream = null;
             const bool isAudio = false;
 
             var keys = openToken.Split(new[] { StreamIdDelimeter }, 3);
             var mediaSourceId = keys.Length >= 3 ? keys[2] : null;
+            IDirectStreamProvider directStreamProvider = null;
 
             if (string.Equals(keys[0], typeof(LiveTvChannel).Name, StringComparison.OrdinalIgnoreCase))
             {
-                stream = await _liveTvManager.GetChannelStream(keys[1], mediaSourceId, cancellationToken).ConfigureAwait(false);
+                var info = await _liveTvManager.GetChannelStream(keys[1], mediaSourceId, cancellationToken).ConfigureAwait(false);
+                stream = info.Item1;
+                directStreamProvider = info.Item2;
             }
             else
             {
@@ -135,14 +140,21 @@ namespace MediaBrowser.Server.Implementations.LiveTv
 
             try
             {
-                await AddMediaInfo(stream, isAudio, cancellationToken).ConfigureAwait(false);
+                if (stream.MediaStreams.Any(i => i.Index != -1))
+                {
+                    await AddMediaInfo(stream, isAudio, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    await AddMediaInfoWithProbe(stream, isAudio, cancellationToken).ConfigureAwait(false);
+                }
             }
             catch (Exception ex)
             {
                 _logger.ErrorException("Error probing live tv stream", ex);
             }
 
-            return stream;
+            return new Tuple<MediaSourceInfo, IDirectStreamProvider>(stream, directStreamProvider);
         }
 
         private async Task AddMediaInfo(MediaSourceInfo mediaSource, bool isAudio, CancellationToken cancellationToken)
@@ -204,9 +216,95 @@ namespace MediaBrowser.Server.Implementations.LiveTv
             }
         }
 
-        public Task CloseMediaSource(string liveStreamId, CancellationToken cancellationToken)
+        private async Task AddMediaInfoWithProbe(MediaSourceInfo mediaSource, bool isAudio, CancellationToken cancellationToken)
+        {
+            var originalRuntime = mediaSource.RunTimeTicks;
+
+            var now = DateTime.UtcNow;
+
+            var info = await _mediaEncoder.GetMediaInfo(new MediaInfoRequest
+            {
+                InputPath = mediaSource.Path,
+                Protocol = mediaSource.Protocol,
+                MediaType = isAudio ? DlnaProfileType.Audio : DlnaProfileType.Video,
+                ExtractChapters = false
+
+            }, cancellationToken).ConfigureAwait(false);
+
+            _logger.Info("Live tv media info probe took {0} seconds", (DateTime.UtcNow - now).TotalSeconds.ToString(CultureInfo.InvariantCulture));
+
+            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;
+                    }
+                }
+
+                // This is coming up false and preventing stream copy
+                videoStream.IsAVC = null;
+            }
+
+            // Try to estimate this
+            if (!mediaSource.Bitrate.HasValue)
+            {
+                var total = mediaSource.MediaStreams.Select(i => i.BitRate ?? 0).Sum();
+
+                if (total > 0)
+                {
+                    mediaSource.Bitrate = total;
+                }
+            }
+        }
+
+
+        public Task CloseMediaSource(string liveStreamId)
         {
-            return _liveTvManager.CloseLiveStream(liveStreamId, cancellationToken);
+            return _liveTvManager.CloseLiveStream(liveStreamId);
         }
     }
 }
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/BaseTunerHost.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/BaseTunerHost.cs
index 9bb5b4fd7..0fe74798f 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/BaseTunerHost.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/BaseTunerHost.cs
@@ -6,9 +6,11 @@ using MediaBrowser.Model.Logging;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.MediaEncoding;
 using MediaBrowser.Model.Dlna;
 using MediaBrowser.Model.Serialization;
@@ -17,7 +19,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
 {
     public abstract class BaseTunerHost
     {
-        protected readonly IConfigurationManager Config;
+        protected readonly IServerConfigurationManager Config;
         protected readonly ILogger Logger;
         protected IJsonSerializer JsonSerializer;
         protected readonly IMediaEncoder MediaEncoder;
@@ -25,7 +27,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
         private readonly ConcurrentDictionary<string, ChannelCache> _channelCache =
             new ConcurrentDictionary<string, ChannelCache>(StringComparer.OrdinalIgnoreCase);
 
-        protected BaseTunerHost(IConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder)
+        protected BaseTunerHost(IServerConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder)
         {
             Config = config;
             Logger = logger;
@@ -71,7 +73,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
                 .ToList();
         }
 
-        public async Task<IEnumerable<ChannelInfo>> GetChannels(CancellationToken cancellationToken)
+        public async Task<IEnumerable<ChannelInfo>> GetChannels(bool enableCache, CancellationToken cancellationToken)
         {
             var list = new List<ChannelInfo>();
 
@@ -81,7 +83,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
             {
                 try
                 {
-                    var channels = await GetChannels(host, true, cancellationToken).ConfigureAwait(false);
+                    var channels = await GetChannels(host, enableCache, cancellationToken).ConfigureAwait(false);
                     var newChannels = channels.Where(i => !list.Any(l => string.Equals(i.Id, l.Id, StringComparison.OrdinalIgnoreCase))).ToList();
 
                     list.AddRange(newChannels);
@@ -124,12 +126,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
 
                 foreach (var host in hostsWithChannel)
                 {
-                    var resourcePool = GetLock(host.Url);
-                    Logger.Debug("GetChannelStreamMediaSources - Waiting on tuner resource pool");
-
-                    await resourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
-                    Logger.Debug("GetChannelStreamMediaSources - Unlocked resource pool");
-
                     try
                     {
                         // Check to make sure the tuner is available
@@ -155,89 +151,63 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
                     {
                         Logger.Error("Error opening tuner", ex);
                     }
-                    finally
-                    {
-                        resourcePool.Release();
-                    }
                 }
             }
 
             return new List<MediaSourceInfo>();
         }
 
-        protected abstract Task<MediaSourceInfo> GetChannelStream(TunerHostInfo tuner, string channelId, string streamId, CancellationToken cancellationToken);
+        protected abstract Task<LiveStream> GetChannelStream(TunerHostInfo tuner, string channelId, string streamId, CancellationToken cancellationToken);
 
-        public async Task<Tuple<MediaSourceInfo, SemaphoreSlim>> GetChannelStream(string channelId, string streamId, CancellationToken cancellationToken)
+        public async Task<LiveStream> GetChannelStream(string channelId, string streamId, CancellationToken cancellationToken)
         {
-            if (IsValidChannelId(channelId))
+            if (!IsValidChannelId(channelId))
             {
-                var hosts = GetTunerHosts();
-
-                var hostsWithChannel = new List<TunerHostInfo>();
+                throw new FileNotFoundException();
+            }
 
-                foreach (var host in hosts)
-                {
-                    if (string.IsNullOrWhiteSpace(streamId))
-                    {
-                        try
-                        {
-                            var channels = await GetChannels(host, true, cancellationToken).ConfigureAwait(false);
+            var hosts = GetTunerHosts();
 
-                            if (channels.Any(i => string.Equals(i.Id, channelId, StringComparison.OrdinalIgnoreCase)))
-                            {
-                                hostsWithChannel.Add(host);
-                            }
-                        }
-                        catch (Exception ex)
-                        {
-                            Logger.Error("Error getting channels", ex);
-                        }
-                    }
-                    else if (streamId.StartsWith(host.Id, StringComparison.OrdinalIgnoreCase))
-                    {
-                        hostsWithChannel = new List<TunerHostInfo> { host };
-                        streamId = streamId.Substring(host.Id.Length);
-                        break;
-                    }
-                }
+            var hostsWithChannel = new List<TunerHostInfo>();
 
-                foreach (var host in hostsWithChannel)
+            foreach (var host in hosts)
+            {
+                if (string.IsNullOrWhiteSpace(streamId))
                 {
-                    var resourcePool = GetLock(host.Url);
-                    Logger.Debug("GetChannelStream - Waiting on tuner resource pool");
-                    await resourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
-                    Logger.Debug("GetChannelStream - Unlocked resource pool");
                     try
                     {
-                        // Check to make sure the tuner is available
-                        // If there's only one tuner, don't bother with the check and just let the tuner be the one to throw an error
-                        // If a streamId is specified then availibility has already been checked in GetChannelStreamMediaSources
-                        if (string.IsNullOrWhiteSpace(streamId) && hostsWithChannel.Count > 1)
-                        {
-                            if (!await IsAvailable(host, channelId, cancellationToken).ConfigureAwait(false))
-                            {
-                                Logger.Error("Tuner is not currently available");
-                                resourcePool.Release();
-                                continue;
-                            }
-                        }
-
-                        var stream = await GetChannelStream(host, channelId, streamId, cancellationToken).ConfigureAwait(false);
+                        var channels = await GetChannels(host, true, cancellationToken).ConfigureAwait(false);
 
-                        if (EnableMediaProbing)
+                        if (channels.Any(i => string.Equals(i.Id, channelId, StringComparison.OrdinalIgnoreCase)))
                         {
-                            await AddMediaInfo(stream, false, resourcePool, cancellationToken).ConfigureAwait(false);
+                            hostsWithChannel.Add(host);
                         }
-
-                        return new Tuple<MediaSourceInfo, SemaphoreSlim>(stream, resourcePool);
                     }
                     catch (Exception ex)
                     {
-                        Logger.Error("Error opening tuner", ex);
-
-                        resourcePool.Release();
+                        Logger.Error("Error getting channels", ex);
                     }
                 }
+                else if (streamId.StartsWith(host.Id, StringComparison.OrdinalIgnoreCase))
+                {
+                    hostsWithChannel = new List<TunerHostInfo> { host };
+                    streamId = streamId.Substring(host.Id.Length);
+                    break;
+                }
+            }
+
+            foreach (var host in hostsWithChannel)
+            {
+                try
+                {
+                    var liveStream = await GetChannelStream(host, channelId, streamId, cancellationToken).ConfigureAwait(false);
+                    await liveStream.Open(cancellationToken).ConfigureAwait(false);
+                    return liveStream;
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error("Error opening tuner", ex);
+                }
             }
 
             throw new LiveTvConflictException();
@@ -263,117 +233,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
 
         protected abstract Task<bool> IsAvailableInternal(TunerHostInfo tuner, string channelId, CancellationToken cancellationToken);
 
-        /// <summary>
-        /// The _semaphoreLocks
-        /// </summary>
-        private readonly ConcurrentDictionary<string, SemaphoreSlim> _semaphoreLocks = new ConcurrentDictionary<string, SemaphoreSlim>(StringComparer.OrdinalIgnoreCase);
-        /// <summary>
-        /// Gets the lock.
-        /// </summary>
-        /// <param name="url">The filename.</param>
-        /// <returns>System.Object.</returns>
-        private SemaphoreSlim GetLock(string url)
-        {
-            return _semaphoreLocks.GetOrAdd(url, key => new SemaphoreSlim(1, 1));
-        }
-
-        private async Task AddMediaInfo(MediaSourceInfo mediaSource, bool isAudio, SemaphoreSlim resourcePool, CancellationToken cancellationToken)
-        {
-            await resourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
-
-            try
-            {
-                await AddMediaInfoInternal(mediaSource, isAudio, cancellationToken).ConfigureAwait(false);
-
-                // Leave the resource locked. it will be released upstream
-            }
-            catch (Exception)
-            {
-                // Release the resource if there's some kind of failure.
-                resourcePool.Release();
-
-                throw;
-            }
-        }
-
-        private async Task AddMediaInfoInternal(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;
-                }
-            }
-        }
-
         protected abstract bool IsValidChannelId(string channelId);
 
         protected LiveTvOptions GetConfiguration()
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunDiscovery.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunDiscovery.cs
index 9ba1c60cc..cd168ba58 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunDiscovery.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunDiscovery.cs
@@ -10,6 +10,7 @@ using System;
 using System.Linq;
 using System.Threading;
 using MediaBrowser.Common.Net;
+using MediaBrowser.Model.Events;
 using MediaBrowser.Model.Serialization;
 
 namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
@@ -39,13 +40,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             _deviceDiscovery.DeviceDiscovered += _deviceDiscovery_DeviceDiscovered;
         }
 
-        void _deviceDiscovery_DeviceDiscovered(object sender, SsdpMessageEventArgs e)
+        void _deviceDiscovery_DeviceDiscovered(object sender, GenericEventArgs<UpnpDeviceInfo> e)
         {
             string server = null;
-            if (e.Headers.TryGetValue("SERVER", out server) && server.IndexOf("HDHomeRun", StringComparison.OrdinalIgnoreCase) != -1)
+            var info = e.Argument;
+
+            if (info.Headers.TryGetValue("SERVER", out server) && server.IndexOf("HDHomeRun", StringComparison.OrdinalIgnoreCase) != -1)
             {
                 string location;
-                if (e.Headers.TryGetValue("Location", out location))
+                if (info.Headers.TryGetValue("Location", out location))
                 {
                     //_logger.Debug("HdHomerun found at {0}", location);
 
@@ -85,7 +88,8 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                 using (var stream = await _httpClient.Get(new HttpRequestOptions
                 {
                     Url = string.Format("{0}/discover.json", url),
-                    CancellationToken = CancellationToken.None
+                    CancellationToken = CancellationToken.None,
+                    BufferContent = false
                 }))
                 {
                     var response = _json.DeserializeFromStream<HdHomerunHost.DiscoverResponse>(stream);
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs
index fd4775938..365f784a7 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs
@@ -14,7 +14,10 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using CommonIO;
 using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.MediaEncoding;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Net;
@@ -24,11 +27,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
     public class HdHomerunHost : BaseTunerHost, ITunerHost, IConfigurableTunerHost
     {
         private readonly IHttpClient _httpClient;
+        private readonly IFileSystem _fileSystem;
+        private readonly IServerApplicationHost _appHost;
 
-        public HdHomerunHost(IConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder, IHttpClient httpClient)
+        public HdHomerunHost(IServerConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder, IHttpClient httpClient, IFileSystem fileSystem, IServerApplicationHost appHost)
             : base(config, logger, jsonSerializer, mediaEncoder)
         {
             _httpClient = httpClient;
+            _fileSystem = fileSystem;
+            _appHost = appHost;
         }
 
         public string Name
@@ -60,20 +67,13 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             return id;
         }
 
-        public string ApplyDuration(string streamPath, TimeSpan duration)
-        {
-            streamPath += streamPath.IndexOf('?') == -1 ? "?" : "&";
-            streamPath += "duration=" + Convert.ToInt32(duration.TotalSeconds).ToString(CultureInfo.InvariantCulture);
-
-            return streamPath;
-        }
-
         private async Task<IEnumerable<Channels>> GetLineup(TunerHostInfo info, CancellationToken cancellationToken)
         {
             var options = new HttpRequestOptions
             {
                 Url = string.Format("{0}/lineup.json", GetApiUrl(info, false)),
-                CancellationToken = cancellationToken
+                CancellationToken = cancellationToken,
+                BufferContent = false
             };
             using (var stream = await _httpClient.Get(options))
             {
@@ -105,8 +105,18 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             });
         }
 
+        private readonly Dictionary<string, DiscoverResponse> _modelCache = new Dictionary<string, DiscoverResponse>();
         private async Task<string> GetModelInfo(TunerHostInfo info, CancellationToken cancellationToken)
         {
+            lock (_modelCache)
+            {
+                DiscoverResponse response;
+                if (_modelCache.TryGetValue(info.Url, out response))
+                {
+                    return response.ModelNumber;
+                }
+            }
+
             try
             {
                 using (var stream = await _httpClient.Get(new HttpRequestOptions()
@@ -115,11 +125,17 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                     CancellationToken = cancellationToken,
                     CacheLength = TimeSpan.FromDays(1),
                     CacheMode = CacheMode.Unconditional,
-                    TimeoutMs = Convert.ToInt32(TimeSpan.FromSeconds(5).TotalMilliseconds)
+                    TimeoutMs = Convert.ToInt32(TimeSpan.FromSeconds(5).TotalMilliseconds),
+                    BufferContent = false
                 }))
                 {
                     var response = JsonSerializer.DeserializeFromStream<DiscoverResponse>(stream);
 
+                    lock (_modelCache)
+                    {
+                        _modelCache[info.Id] = response;
+                    }
+
                     return response.ModelNumber;
                 }
             }
@@ -127,8 +143,16 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             {
                 if (ex.StatusCode.HasValue && ex.StatusCode.Value == System.Net.HttpStatusCode.NotFound)
                 {
+                    var defaultValue = "HDHR";
                     // HDHR4 doesn't have this api
-                    return "HDHR";
+                    lock (_modelCache)
+                    {
+                        _modelCache[info.Id] = new DiscoverResponse
+                        {
+                            ModelNumber = defaultValue
+                        };
+                    }
+                    return defaultValue;
                 }
 
                 throw;
@@ -143,7 +167,8 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             {
                 Url = string.Format("{0}/tuners.html", GetApiUrl(info, false)),
                 CancellationToken = cancellationToken,
-                TimeoutMs = Convert.ToInt32(TimeSpan.FromSeconds(5).TotalMilliseconds)
+                TimeoutMs = Convert.ToInt32(TimeSpan.FromSeconds(5).TotalMilliseconds),
+                BufferContent = false
             }))
             {
                 var tuners = new List<LiveTvTunerInfo>();
@@ -319,18 +344,21 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                 videoBitrate = 1000000;
             }
 
-            if (string.IsNullOrWhiteSpace(videoCodec))
+            var channels = await GetChannels(info, true, CancellationToken.None).ConfigureAwait(false);
+            var channel = channels.FirstOrDefault(i => string.Equals(i.Number, channelId, StringComparison.OrdinalIgnoreCase));
+            if (channel != null)
             {
-                var channels = await GetChannels(info, true, CancellationToken.None).ConfigureAwait(false);
-                var channel = channels.FirstOrDefault(i => string.Equals(i.Number, channelId, StringComparison.OrdinalIgnoreCase));
-                if (channel != null)
+                if (string.IsNullOrWhiteSpace(videoCodec))
                 {
                     videoCodec = channel.VideoCodec;
-                    audioCodec = channel.AudioCodec;
+                }
+                audioCodec = channel.AudioCodec;
 
+                if (!videoBitrate.HasValue)
+                {
                     videoBitrate = (channel.IsHD ?? true) ? 15000000 : 2000000;
-                    audioBitrate = (channel.IsHD ?? true) ? 448000 : 192000;
                 }
+                audioBitrate = (channel.IsHD ?? true) ? 448000 : 192000;
             }
 
             // normalize
@@ -352,6 +380,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                 url += "?transcode=" + profile;
             }
 
+            var id = profile;
+            if (string.IsNullOrWhiteSpace(id))
+            {
+                id = "native";
+            }
+            id += "_" + url.GetMD5().ToString("N");
+
+            var enableLocalBuffer = EnableLocalBuffer();
+
             var mediaSource = new MediaSourceInfo
             {
                 Path = url,
@@ -380,14 +417,15 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                                 BitRate = audioBitrate
                             }
                         },
-                RequiresOpening = false,
+                RequiresOpening = true,
                 RequiresClosing = false,
                 BufferMs = 0,
                 Container = "ts",
-                Id = profile,
-                SupportsDirectPlay = true,
-                SupportsDirectStream = false,
-                SupportsTranscoding = true
+                Id = id,
+                SupportsDirectPlay = !enableLocalBuffer,
+                SupportsDirectStream = enableLocalBuffer,
+                SupportsTranscoding = true,
+                IsInfiniteStream = true
             };
 
             return mediaSource;
@@ -417,18 +455,21 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
 
             try
             {
-                string model = await GetModelInfo(info, cancellationToken).ConfigureAwait(false);
-                model = model ?? string.Empty;
-
-                if (info.AllowHWTranscoding && (model.IndexOf("hdtc", StringComparison.OrdinalIgnoreCase) != -1))
+                if (info.AllowHWTranscoding)
                 {
-                    list.Add(await GetMediaSource(info, hdhrId, "heavy").ConfigureAwait(false));
+                    string model = await GetModelInfo(info, cancellationToken).ConfigureAwait(false);
+                    model = model ?? string.Empty;
 
-                    list.Add(await GetMediaSource(info, hdhrId, "internet540").ConfigureAwait(false));
-                    list.Add(await GetMediaSource(info, hdhrId, "internet480").ConfigureAwait(false));
-                    list.Add(await GetMediaSource(info, hdhrId, "internet360").ConfigureAwait(false));
-                    list.Add(await GetMediaSource(info, hdhrId, "internet240").ConfigureAwait(false));
-                    list.Add(await GetMediaSource(info, hdhrId, "mobile").ConfigureAwait(false));
+                    if ((model.IndexOf("hdtc", StringComparison.OrdinalIgnoreCase) != -1))
+                    {
+                        list.Add(await GetMediaSource(info, hdhrId, "heavy").ConfigureAwait(false));
+
+                        list.Add(await GetMediaSource(info, hdhrId, "internet540").ConfigureAwait(false));
+                        list.Add(await GetMediaSource(info, hdhrId, "internet480").ConfigureAwait(false));
+                        list.Add(await GetMediaSource(info, hdhrId, "internet360").ConfigureAwait(false));
+                        list.Add(await GetMediaSource(info, hdhrId, "internet240").ConfigureAwait(false));
+                        list.Add(await GetMediaSource(info, hdhrId, "mobile").ConfigureAwait(false));
+                    }
                 }
             }
             catch
@@ -449,9 +490,16 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             return channelId.StartsWith(ChannelIdPrefix, StringComparison.OrdinalIgnoreCase);
         }
 
-        protected override async Task<MediaSourceInfo> GetChannelStream(TunerHostInfo info, string channelId, string streamId, CancellationToken cancellationToken)
+        private bool EnableLocalBuffer()
+        {
+            return true;
+        }
+
+        protected override async Task<LiveStream> GetChannelStream(TunerHostInfo info, string channelId, string streamId, CancellationToken cancellationToken)
         {
-            Logger.Info("GetChannelStream: channel id: {0}. stream id: {1}", channelId, streamId ?? string.Empty);
+            var profile = streamId.Split('_')[0];
+
+            Logger.Info("GetChannelStream: channel id: {0}. stream id: {1} profile: {2}", channelId, streamId, profile);
 
             if (!channelId.StartsWith(ChannelIdPrefix, StringComparison.OrdinalIgnoreCase))
             {
@@ -459,7 +507,36 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             }
             var hdhrId = GetHdHrIdFromChannelId(channelId);
 
-            return await GetMediaSource(info, hdhrId, streamId).ConfigureAwait(false);
+            var mediaSource = await GetMediaSource(info, hdhrId, profile).ConfigureAwait(false);
+
+            if (EnableLocalBuffer())
+            {
+                var liveStream = new HdHomerunLiveStream(mediaSource, streamId, _fileSystem, _httpClient, Logger, Config.ApplicationPaths, _appHost);
+                if (info.AllowHWTranscoding)
+                {
+                    var model = await GetModelInfo(info, cancellationToken).ConfigureAwait(false);
+
+                    if ((model ?? string.Empty).IndexOf("hdtc", StringComparison.OrdinalIgnoreCase) != -1)
+                    {
+                        liveStream.EnableStreamSharing = !info.AllowHWTranscoding;
+                    }
+                    else
+                    {
+                        liveStream.EnableStreamSharing = true;
+                    }
+                }
+                else
+                {
+                    liveStream.EnableStreamSharing = true;
+                }
+                return liveStream;
+            }
+            else
+            {
+                var liveStream = new LiveStream(mediaSource);
+                liveStream.EnableStreamSharing = false;
+                return liveStream;
+            }
         }
 
         public async Task Validate(TunerHostInfo info)
@@ -469,13 +546,19 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                 return;
             }
 
+            lock (_modelCache)
+            {
+                _modelCache.Clear();
+            }
+
             try
             {
                 // Test it by pulling down the lineup
                 using (var stream = await _httpClient.Get(new HttpRequestOptions
                 {
                     Url = string.Format("{0}/discover.json", GetApiUrl(info, false)),
-                    CancellationToken = CancellationToken.None
+                    CancellationToken = CancellationToken.None,
+                    BufferContent = false
                 }))
                 {
                     var response = JsonSerializer.DeserializeFromStream<DiscoverResponse>(stream);
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunLiveStream.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunLiveStream.cs
new file mode 100644
index 000000000..60222415c
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunLiveStream.cs
@@ -0,0 +1,145 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using CommonIO;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.MediaInfo;
+using MediaBrowser.Server.Implementations.LiveTv.EmbyTV;
+using System.Collections.Generic;
+using System.Linq;
+using MediaBrowser.Common.Extensions;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.HdHomerun
+{
+    public class HdHomerunLiveStream : LiveStream, IDirectStreamProvider
+    {
+        private readonly ILogger _logger;
+        private readonly IHttpClient _httpClient;
+        private readonly IFileSystem _fileSystem;
+        private readonly IServerApplicationPaths _appPaths;
+        private readonly IServerApplicationHost _appHost;
+
+        private readonly CancellationTokenSource _liveStreamCancellationTokenSource = new CancellationTokenSource();
+        private readonly TaskCompletionSource<bool> _liveStreamTaskCompletionSource = new TaskCompletionSource<bool>();
+        private readonly MulticastStream _multicastStream;
+
+
+        public HdHomerunLiveStream(MediaSourceInfo mediaSource, string originalStreamId, IFileSystem fileSystem, IHttpClient httpClient, ILogger logger, IServerApplicationPaths appPaths, IServerApplicationHost appHost)
+            : base(mediaSource)
+        {
+            _fileSystem = fileSystem;
+            _httpClient = httpClient;
+            _logger = logger;
+            _appPaths = appPaths;
+            _appHost = appHost;
+            OriginalStreamId = originalStreamId;
+            _multicastStream = new MulticastStream(_logger);
+        }
+
+        protected override async Task OpenInternal(CancellationToken openCancellationToken)
+        {
+            _liveStreamCancellationTokenSource.Token.ThrowIfCancellationRequested();
+
+            var mediaSource = OriginalMediaSource;
+
+            var url = mediaSource.Path;
+
+            _logger.Info("Opening HDHR Live stream from {0}", url);
+
+            var taskCompletionSource = new TaskCompletionSource<bool>();
+
+            StartStreaming(url, taskCompletionSource, _liveStreamCancellationTokenSource.Token);
+
+            //OpenedMediaSource.Protocol = MediaProtocol.File;
+            //OpenedMediaSource.Path = tempFile;
+            //OpenedMediaSource.ReadAtNativeFramerate = true;
+
+            OpenedMediaSource.Path = _appHost.GetLocalApiUrl("localhost") + "/LiveTv/LiveStreamFiles/" + UniqueId + "/stream.ts";
+            OpenedMediaSource.Protocol = MediaProtocol.Http;
+            OpenedMediaSource.SupportsDirectPlay = false;
+            OpenedMediaSource.SupportsDirectStream = true;
+            OpenedMediaSource.SupportsTranscoding = true;
+
+            await taskCompletionSource.Task.ConfigureAwait(false);
+
+            //await Task.Delay(5000).ConfigureAwait(false);
+        }
+
+        public override Task Close()
+        {
+            _logger.Info("Closing HDHR live stream");
+            _liveStreamCancellationTokenSource.Cancel();
+
+            return _liveStreamTaskCompletionSource.Task;
+        }
+
+        private async Task StartStreaming(string url, TaskCompletionSource<bool> openTaskCompletionSource, CancellationToken cancellationToken)
+        {
+            await Task.Run(async () =>
+            {
+                var isFirstAttempt = true;
+
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    try
+                    {
+                        using (var response = await _httpClient.SendAsync(new HttpRequestOptions
+                        {
+                            Url = url,
+                            CancellationToken = cancellationToken,
+                            BufferContent = false
+
+                        }, "GET").ConfigureAwait(false))
+                        {
+                            _logger.Info("Opened HDHR stream from {0}", url);
+
+                            if (!cancellationToken.IsCancellationRequested)
+                            {
+                                _logger.Info("Beginning multicastStream.CopyUntilCancelled");
+
+                                Action onStarted = null;
+                                if (isFirstAttempt)
+                                {
+                                    onStarted = () => openTaskCompletionSource.TrySetResult(true);
+                                }
+
+                                await _multicastStream.CopyUntilCancelled(response.Content, onStarted, cancellationToken).ConfigureAwait(false);
+                            }
+                        }
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        break;
+                    }
+                    catch (Exception ex)
+                    {
+                        if (isFirstAttempt)
+                        {
+                            _logger.ErrorException("Error opening live stream:", ex);
+                            openTaskCompletionSource.TrySetException(ex);
+                            break;
+                        }
+
+                        _logger.ErrorException("Error copying live stream, will reopen", ex);
+                    }
+
+                    isFirstAttempt = false;
+                }
+
+                _liveStreamTaskCompletionSource.TrySetResult(true);
+
+            }).ConfigureAwait(false);
+        }
+
+        public Task CopyToAsync(Stream stream, CancellationToken cancellationToken)
+        {
+            return _multicastStream.CopyToAsync(stream);
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/M3UTunerHost.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/M3UTunerHost.cs
index 5c508aacd..b03feefe4 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/M3UTunerHost.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/M3UTunerHost.cs
@@ -13,8 +13,10 @@ using System.Threading;
 using System.Threading.Tasks;
 using CommonIO;
 using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.MediaEncoding;
 using MediaBrowser.Model.Serialization;
+using MediaBrowser.Server.Implementations.LiveTv.EmbyTV;
 
 namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
 {
@@ -23,7 +25,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
         private readonly IFileSystem _fileSystem;
         private readonly IHttpClient _httpClient;
 
-        public M3UTunerHost(IConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IHttpClient httpClient)
+        public M3UTunerHost(IServerConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IHttpClient httpClient)
             : base(config, logger, jsonSerializer, mediaEncoder)
         {
             _fileSystem = fileSystem;
@@ -63,11 +65,12 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
             return Task.FromResult(list);
         }
 
-        protected override async Task<MediaSourceInfo> GetChannelStream(TunerHostInfo info, string channelId, string streamId, CancellationToken cancellationToken)
+        protected override async Task<LiveStream> GetChannelStream(TunerHostInfo info, string channelId, string streamId, CancellationToken cancellationToken)
         {
             var sources = await GetChannelStreamMediaSources(info, channelId, cancellationToken).ConfigureAwait(false);
 
-            return sources.First();
+            var liveStream = new LiveStream(sources.First());
+            return liveStream;
         }
 
         public async Task Validate(TunerHostInfo info)
@@ -136,7 +139,10 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
                     RequiresOpening = false,
                     RequiresClosing = false,
 
-                    ReadAtNativeFramerate = false
+                    ReadAtNativeFramerate = false,
+
+                    Id = channel.Path.GetMD5().ToString("N"),
+                    IsInfiniteStream = true
                 };
 
                 return new List<MediaSourceInfo> { mediaSource };
@@ -148,10 +154,5 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
         {
             return Task.FromResult(true);
         }
-
-        public string ApplyDuration(string streamPath, TimeSpan duration)
-        {
-            return streamPath;
-        }
     }
 }
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/M3uParser.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/M3uParser.cs
index ffe95c862..8095a6989 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/M3uParser.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/M3uParser.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -70,7 +71,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
                 }
                 else if (!string.IsNullOrWhiteSpace(extInf) && !line.StartsWith("#", StringComparison.OrdinalIgnoreCase))
                 {
-                    var channel = GetChannelnfo(extInf, tunerHostId);
+                    var channel = GetChannelnfo(extInf, tunerHostId, line);
                     channel.Id = channelIdPrefix + urlHash + line.GetMD5().ToString("N");
                     channel.Path = line;
                     channels.Add(channel);
@@ -79,7 +80,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
             }
             return channels;
         }
-        private M3UChannel GetChannelnfo(string extInf, string tunerHostId)
+        private M3UChannel GetChannelnfo(string extInf, string tunerHostId, string mediaUrl)
         {
             var titleIndex = extInf.LastIndexOf(',');
             var channel = new M3UChannel();
@@ -87,8 +88,6 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
 
             channel.Number = extInf.Trim().Split(' ')[0] ?? "0";
             channel.Name = extInf.Substring(titleIndex + 1);
-            
-            if(channel.Number == "-1") { channel.Number = "0"; }         
 
             //Check for channel number with the format from SatIp            
             int number;                   
@@ -101,6 +100,17 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
                     channel.Name = channel.Name.Substring(numberIndex + 1);
                 }
             }
+
+            if (string.Equals(channel.Number, "-1", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(mediaUrl))
+            {
+                channel.Number = Path.GetFileNameWithoutExtension(mediaUrl.Split('/').Last());
+            }
+
+            if (string.Equals(channel.Number, "-1", StringComparison.OrdinalIgnoreCase))
+            {
+                channel.Number = "0";
+            }
+
             channel.ImageUrl = FindProperty("tvg-logo", extInf, null);
             channel.Number = FindProperty("tvg-id", extInf, channel.Number);
             channel.Number = FindProperty("channel-id", extInf, channel.Number);
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/MulticastStream.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/MulticastStream.cs
new file mode 100644
index 000000000..8ff3fd6c1
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/MulticastStream.cs
@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Model.Logging;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
+{
+    public class MulticastStream
+    {
+        private readonly List<QueueStream> _outputStreams = new List<QueueStream>();
+        private const int BufferSize = 81920;
+        private CancellationToken _cancellationToken;
+        private readonly ILogger _logger;
+
+        public MulticastStream(ILogger logger)
+        {
+            _logger = logger;
+        }
+
+        public async Task CopyUntilCancelled(Stream source, Action onStarted, CancellationToken cancellationToken)
+        {
+            _cancellationToken = cancellationToken;
+
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                byte[] buffer = new byte[BufferSize];
+
+                var bytesRead = await source.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false);
+
+                if (bytesRead > 0)
+                {
+                    byte[] copy = new byte[bytesRead];
+                    Buffer.BlockCopy(buffer, 0, copy, 0, bytesRead);
+                   
+                    List<QueueStream> streams = null;
+
+                    lock (_outputStreams)
+                    {
+                        streams = _outputStreams.ToList();
+                    }
+
+                    foreach (var stream in streams)
+                    {
+                        stream.Queue(copy);
+                    }
+
+                    if (onStarted != null)
+                    {
+                        var onStartedCopy = onStarted;
+                        onStarted = null;
+                        Task.Run(onStartedCopy);
+                    }
+                }
+
+                else
+                {
+                    await Task.Delay(100).ConfigureAwait(false);
+                }
+            }
+        }
+
+        public Task CopyToAsync(Stream stream)
+        {
+            var result = new QueueStream(stream, _logger)
+            {
+                OnFinished = OnFinished
+            };
+
+            lock (_outputStreams)
+            {
+                _outputStreams.Add(result);
+            }
+
+            result.Start(_cancellationToken);
+
+            return result.TaskCompletion.Task;
+        }
+
+        public void RemoveOutputStream(QueueStream stream)
+        {
+            lock (_outputStreams)
+            {
+                _outputStreams.Remove(stream);
+            }
+        }
+
+        private void OnFinished(QueueStream queueStream)
+        {
+            RemoveOutputStream(queueStream);
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/QueueStream.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/QueueStream.cs
new file mode 100644
index 000000000..c1566b900
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/QueueStream.cs
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Model.Logging;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts
+{
+    public class QueueStream
+    {
+        private readonly Stream _outputStream;
+        private readonly ConcurrentQueue<byte[]> _queue = new ConcurrentQueue<byte[]>();
+        private CancellationToken _cancellationToken;
+        public TaskCompletionSource<bool> TaskCompletion { get; private set; }
+
+        public Action<QueueStream> OnFinished { get; set; }
+        private readonly ILogger _logger;
+
+        public QueueStream(Stream outputStream, ILogger logger)
+        {
+            _outputStream = outputStream;
+            _logger = logger;
+            TaskCompletion = new TaskCompletionSource<bool>();
+        }
+
+        public void Queue(byte[] bytes)
+        {
+            _queue.Enqueue(bytes);
+        }
+
+        public void Start(CancellationToken cancellationToken)
+        {
+            _cancellationToken = cancellationToken;
+            Task.Run(() => StartInternal());
+        }
+
+        private byte[] Dequeue()
+        {
+            byte[] bytes;
+            if (_queue.TryDequeue(out bytes))
+            {
+                return bytes;
+            }
+
+            return null;
+        }
+
+        private async Task StartInternal()
+        {
+            var cancellationToken = _cancellationToken;
+
+            try
+            {
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    var bytes = Dequeue();
+                    if (bytes != null)
+                    {
+                        await _outputStream.WriteAsync(bytes, 0, bytes.Length, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        await Task.Delay(50, cancellationToken).ConfigureAwait(false);
+                    }
+                }
+
+                TaskCompletion.TrySetResult(true);
+                _logger.Debug("QueueStream complete");
+            }
+            catch (OperationCanceledException)
+            {
+                _logger.Debug("QueueStream cancelled");
+                TaskCompletion.TrySetCanceled();
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error in QueueStream", ex);
+                TaskCompletion.TrySetException(ex);
+            }
+            finally
+            {
+                if (OnFinished != null)
+                {
+                    OnFinished(this);
+                }
+            }
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/ReportBlock.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/ReportBlock.cs
new file mode 100644
index 000000000..dddd77179
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/ReportBlock.cs
@@ -0,0 +1,79 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    public class ReportBlock
+    {
+        /// <summary>
+        /// Get the length of the block.
+        /// </summary>
+        public int BlockLength { get { return (24); } }
+        /// <summary>
+        /// Get the synchronization source.
+        /// </summary>
+        public string SynchronizationSource { get; private set; }
+        /// <summary>
+        /// Get the fraction lost.
+        /// </summary>
+        public int FractionLost { get; private set; }
+        /// <summary>
+        /// Get the cumulative packets lost.
+        /// </summary>
+        public int CumulativePacketsLost { get; private set; }
+        /// <summary>
+        /// Get the highest number received.
+        /// </summary>
+        public int HighestNumberReceived { get; private set; }
+        /// <summary>
+        /// Get the inter arrival jitter.
+        /// </summary>
+        public int InterArrivalJitter { get; private set; }
+        /// <summary>
+        /// Get the timestamp of the last report.
+        /// </summary>
+        public int LastReportTimeStamp { get; private set; }
+        /// <summary>
+        /// Get the delay since the last report.
+        /// </summary>
+        public int DelaySinceLastReport { get; private set; }
+
+        /// <summary>
+        /// Initialize a new instance of the ReportBlock class.
+        /// </summary>
+        public ReportBlock() { }
+
+        /// <summary>
+        /// Unpack the data in a packet.
+        /// </summary>
+        /// <param name="buffer">The buffer containing the packet.</param>
+        /// <param name="offset">The offset to the first byte of the packet within the buffer.</param>
+        /// <returns>An ErrorSpec instance if an error occurs; null otherwise.</returns>
+        public void Process(byte[] buffer, int offset)
+        {
+            SynchronizationSource = Utils.ConvertBytesToString(buffer, offset, 4);
+            FractionLost = buffer[offset + 4];
+            CumulativePacketsLost = Utils.Convert3BytesToInt(buffer, offset + 5);
+            HighestNumberReceived = Utils.Convert4BytesToInt(buffer, offset + 8);
+            InterArrivalJitter = Utils.Convert4BytesToInt(buffer, offset + 12);
+            LastReportTimeStamp = Utils.Convert4BytesToInt(buffer, offset + 16);
+            DelaySinceLastReport = Utils.Convert4BytesToInt(buffer, offset + 20);
+
+            
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpAppPacket.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpAppPacket.cs
new file mode 100644
index 000000000..990b6dd94
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpAppPacket.cs
@@ -0,0 +1,68 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+using System.Text;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    class RtcpAppPacket : RtcpPacket
+    {
+        /// <summary>
+        /// Get the synchronization source.
+        /// </summary>
+        public int SynchronizationSource { get; private set; }
+        /// <summary>
+        /// Get the name.
+        /// </summary>
+        public string Name { get; private set; }
+        /// <summary>
+        /// Get the identity.
+        /// </summary>
+        public int Identity { get; private set; }
+        /// <summary>
+        /// Get the variable data portion.
+        /// </summary>
+        public string Data { get; private set; }
+
+        public override void Parse(byte[] buffer, int offset)
+        {
+            base.Parse(buffer, offset);
+            SynchronizationSource = Utils.Convert4BytesToInt(buffer, offset + 4);
+            Name = Utils.ConvertBytesToString(buffer, offset + 8, 4);
+            Identity = Utils.Convert2BytesToInt(buffer, offset + 12);
+
+            int dataLength = Utils.Convert2BytesToInt(buffer, offset + 14);
+            if (dataLength != 0)
+                Data = Utils.ConvertBytesToString(buffer, offset + 16, dataLength);
+        }
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendFormat("Application Specific.\n");
+            sb.AppendFormat("Version : {0} .\n", Version);
+            sb.AppendFormat("Padding : {0} .\n", Padding);
+            sb.AppendFormat("Report Count : {0} .\n", ReportCount);
+            sb.AppendFormat("PacketType: {0} .\n", Type);
+            sb.AppendFormat("Length : {0} .\n", Length);
+            sb.AppendFormat("SynchronizationSource : {0} .\n", SynchronizationSource);
+            sb.AppendFormat("Name : {0} .\n", Name);
+            sb.AppendFormat("Identity : {0} .\n", Identity);
+            sb.AppendFormat("Data : {0} .\n", Data);            
+            sb.AppendFormat(".\n");
+            return sb.ToString();
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpByePacket.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpByePacket.cs
new file mode 100644
index 000000000..c79ea31a8
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpByePacket.cs
@@ -0,0 +1,59 @@
+using System.Collections.ObjectModel;
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+using System.Text;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    public class RtcpByePacket :RtcpPacket
+    {
+        public Collection<string> SynchronizationSources { get; private set; }
+        public string ReasonForLeaving { get; private set; }
+        public override void Parse(byte[] buffer, int offset)
+        {
+            base.Parse(buffer, offset);
+            SynchronizationSources = new Collection<string>();
+            int index = 4;
+
+            while (SynchronizationSources.Count < ReportCount)
+            {
+                SynchronizationSources.Add(Utils.ConvertBytesToString(buffer, offset + index, 4));
+                index += 4;
+            }
+
+            if (index < Length)
+            {
+                int reasonLength = buffer[offset + index];
+                ReasonForLeaving = Utils.ConvertBytesToString(buffer, offset + index + 1, reasonLength);
+            }
+        }
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendFormat("ByeBye .\n");
+            sb.AppendFormat("Version : {0} .\n", Version);
+            sb.AppendFormat("Padding : {0} .\n", Padding);
+            sb.AppendFormat("Report Count : {0} .\n", ReportCount);
+            sb.AppendFormat("PacketType: {0} .\n", Type);
+            sb.AppendFormat("Length : {0} .\n", Length);
+            sb.AppendFormat("SynchronizationSources : {0} .\n", SynchronizationSources);
+            sb.AppendFormat("ReasonForLeaving : {0} .\n", ReasonForLeaving);            
+            sb.AppendFormat(".\n");
+            return sb.ToString();
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpListener.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpListener.cs
new file mode 100644
index 000000000..2c54f0665
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpListener.cs
@@ -0,0 +1,203 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using MediaBrowser.Model.Logging;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    public class RtcpListener
+    {
+	private readonly ILogger _logger;
+        private Thread _rtcpListenerThread;
+        private AutoResetEvent _rtcpListenerThreadStopEvent = null;
+        private UdpClient _udpClient;
+        private IPEndPoint _multicastEndPoint;
+        private IPEndPoint _serverEndPoint;
+        private TransmissionMode _transmissionMode;
+
+        public RtcpListener(String address, int port, TransmissionMode mode,ILogger logger)
+        {
+            _logger = logger;
+            _transmissionMode = mode;
+            switch (mode)
+            {
+                case TransmissionMode.Unicast:
+                    _udpClient = new UdpClient(new IPEndPoint(IPAddress.Parse(address), port));
+                    _serverEndPoint = new IPEndPoint(IPAddress.Any, 0);
+                    break;
+                case TransmissionMode.Multicast:
+                    _multicastEndPoint = new IPEndPoint(IPAddress.Parse(address), port);
+                    _serverEndPoint = new IPEndPoint(IPAddress.Any, 0);
+                    _udpClient = new UdpClient();
+                    _udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
+                    _udpClient.ExclusiveAddressUse = false;
+                    _udpClient.Client.Bind(new IPEndPoint(IPAddress.Any, port));
+                    _udpClient.JoinMulticastGroup(_multicastEndPoint.Address);
+                    break;
+            }
+            //StartRtcpListenerThread();
+        }
+
+        public void StartRtcpListenerThread()
+        {
+            // Kill the existing thread if it is in "zombie" state.
+            if (_rtcpListenerThread != null && !_rtcpListenerThread.IsAlive)
+            {
+                StopRtcpListenerThread();
+            }
+
+            if (_rtcpListenerThread == null)
+            {
+                _logger.Info("SAT>IP : starting new RTCP listener thread");
+                _rtcpListenerThreadStopEvent = new AutoResetEvent(false);
+                _rtcpListenerThread = new Thread(new ThreadStart(RtcpListenerThread));
+                _rtcpListenerThread.Name = string.Format("SAT>IP tuner  RTCP listener");
+                _rtcpListenerThread.IsBackground = true;
+                _rtcpListenerThread.Priority = ThreadPriority.Lowest;
+                _rtcpListenerThread.Start();
+            }
+        }
+
+        public void StopRtcpListenerThread()
+        {
+            if (_rtcpListenerThread != null)
+            {
+                if (!_rtcpListenerThread.IsAlive)
+                {
+                    _logger.Info("SAT>IP : aborting old RTCP listener thread");
+                    _rtcpListenerThread.Abort();
+                }
+                else
+                {
+                    _rtcpListenerThreadStopEvent.Set();
+                    if (!_rtcpListenerThread.Join(400 * 2))
+                    {
+                        _logger.Info("SAT>IP : failed to join RTCP listener thread, aborting thread");
+                        _rtcpListenerThread.Abort();
+                    }
+                }
+                _rtcpListenerThread = null;
+                if (_rtcpListenerThreadStopEvent != null)
+                {
+                    _rtcpListenerThreadStopEvent.Close();
+                    _rtcpListenerThreadStopEvent = null;
+                }
+            }
+        }
+
+        private void RtcpListenerThread()
+        {
+            try
+            {               
+                bool receivedGoodBye = false;                
+                try
+                {
+                    _udpClient.Client.ReceiveTimeout = 400;
+                    IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Any, 0);
+                    while (!receivedGoodBye && !_rtcpListenerThreadStopEvent.WaitOne(1))
+                    {
+                        byte[] packets = _udpClient.Receive(ref serverEndPoint);
+                        if (packets == null)
+                        {
+                            continue;
+                        }
+                        
+                        int offset = 0;
+                        while (offset < packets.Length)
+                        {
+                            switch (packets[offset + 1])
+                            {
+                                case 200: //sr
+                                    var sr = new RtcpSenderReportPacket();
+                                    sr.Parse(packets, offset);                                    
+                                    offset += sr.Length;
+                                    break;
+                                case 201: //rr
+                                    var rr = new RtcpReceiverReportPacket();
+                                    rr.Parse(packets, offset);                                    
+                                    offset += rr.Length;
+                                    break;
+                                case 202: //sd
+                                    var sd = new RtcpSourceDescriptionPacket();
+                                    sd.Parse(packets, offset);                                    
+                                    offset += sd.Length;
+                                    break;
+                                case 203: // bye
+                                    var bye = new RtcpByePacket();
+                                    bye.Parse(packets, offset);                                    
+                                    receivedGoodBye = true;
+                                    OnPacketReceived(new RtcpPacketReceivedArgs(bye));
+                                    offset += bye.Length;                                    
+                                    break;
+                                case 204: // app
+                                    var app = new RtcpAppPacket();
+                                    app.Parse(packets, offset);                                    
+                                    OnPacketReceived(new RtcpPacketReceivedArgs(app));
+                                    offset += app.Length;
+                                    break;
+                            }                           
+                        }
+                        
+                    }
+                }
+                finally
+                {
+                    switch (_transmissionMode)
+                    {
+                        case TransmissionMode.Multicast:
+                            _udpClient.DropMulticastGroup(_multicastEndPoint.Address);
+                            _udpClient.Close();
+                            break;
+                        case TransmissionMode.Unicast:
+                            _udpClient.Close();
+                            break;
+                    }   
+                }
+            }
+            catch (ThreadAbortException)
+            {
+            }
+            catch (Exception ex)
+            {
+                _logger.Info(string.Format("SAT>IP : RTCP listener thread exception"), ex);
+                return;
+            }
+            _logger.Info("SAT>IP : RTCP listener thread stopping");
+        }
+        public delegate void PacketReceivedHandler(object sender, RtcpPacketReceivedArgs e);
+        public event PacketReceivedHandler PacketReceived;
+        public class RtcpPacketReceivedArgs : EventArgs
+        {
+            public Object Packet { get; private set; }
+
+            public RtcpPacketReceivedArgs(Object packet)
+            {
+                Packet = packet;
+            }
+        }
+        protected void OnPacketReceived(RtcpPacketReceivedArgs args)
+        {
+            if (PacketReceived != null)
+            {
+                PacketReceived(this, args);
+            }
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpPacket.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpPacket.cs
new file mode 100644
index 000000000..0a949eb7e
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpPacket.cs
@@ -0,0 +1,37 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    public abstract class RtcpPacket
+    {
+        public int Version { get; private set; }
+        public bool Padding { get; private set; }
+        public int ReportCount { get; private set; }
+        public int Type { get; private set; }
+        public int Length { get; private set; }        
+
+        public virtual void Parse(byte[] buffer, int offset)
+        {
+            Version = buffer[offset] >> 6;
+            Padding = (buffer[offset] & 0x20) != 0;
+            ReportCount = buffer[offset] & 0x1f;
+            Type = buffer[offset + 1];
+            Length = (Utils.Convert2BytesToInt(buffer, offset + 2) * 4) + 4;             
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpReceiverReportPacket.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpReceiverReportPacket.cs
new file mode 100644
index 000000000..abb863652
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpReceiverReportPacket.cs
@@ -0,0 +1,68 @@
+using System.Collections.ObjectModel;
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+using System.Text;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    public class RtcpReceiverReportPacket :RtcpPacket
+    {
+        public string SynchronizationSource { get; private set; }
+        public Collection<ReportBlock> ReportBlocks { get; private set; }
+        public byte[] ProfileExtension { get; private set; }
+        public override void Parse(byte[] buffer, int offset)
+        {
+            base.Parse(buffer, offset);
+            SynchronizationSource = Utils.ConvertBytesToString(buffer, offset + 4, 4);
+
+            ReportBlocks = new Collection<ReportBlock>();
+            int index = 8;
+
+            while (ReportBlocks.Count < ReportCount)
+            {
+                ReportBlock reportBlock = new ReportBlock();
+                reportBlock.Process(buffer, offset + index);
+                ReportBlocks.Add(reportBlock);
+                index += reportBlock.BlockLength;
+            }
+
+            if (index < Length)
+            {
+                ProfileExtension = new byte[Length - index];
+
+                for (int extensionIndex = 0; index < Length; index++)
+                {
+                    ProfileExtension[extensionIndex] = buffer[offset + index];
+                    extensionIndex++;
+                }
+            }
+        }
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendFormat("Receiver Report.\n");
+            sb.AppendFormat("Version : {0} .\n", Version);
+            sb.AppendFormat("Padding : {0} .\n", Padding);
+            sb.AppendFormat("Report Count : {0} .\n", ReportCount);
+            sb.AppendFormat("PacketType: {0} .\n", Type);
+            sb.AppendFormat("Length : {0} .\n", Length);
+            sb.AppendFormat("SynchronizationSource : {0} .\n", SynchronizationSource);            
+            sb.AppendFormat(".\n");
+            return sb.ToString();
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpSenderReportPacket.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpSenderReportPacket.cs
new file mode 100644
index 000000000..dda5d6a03
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpSenderReportPacket.cs
@@ -0,0 +1,105 @@
+using System.Collections.ObjectModel;
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+using System.Text;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    public class RtcpSenderReportPacket : RtcpPacket
+    {
+        #region Properties
+        /// <summary>
+        /// Get the synchronization source.
+        /// </summary>
+        public int SynchronizationSource { get; private set; }
+        /// <summary>
+        /// Get the NPT timestamp.
+        /// </summary>
+        public long NPTTimeStamp { get; private set; }
+        /// <summary>
+        /// Get the RTP timestamp.
+        /// </summary>
+        public int RTPTimeStamp { get; private set; }
+        /// <summary>
+        /// Get the packet count.
+        /// </summary>
+        public int SenderPacketCount { get; private set; }
+        /// <summary>
+        /// Get the octet count.
+        /// </summary>
+        public int SenderOctetCount { get; private set; }
+        /// <summary>
+        /// Get the list of report blocks.
+        /// </summary>
+        public Collection<ReportBlock> ReportBlocks { get; private set; }
+        /// <summary>
+        /// Get the profile extension data.
+        /// </summary>
+        public byte[] ProfileExtension { get; private set; } 
+        #endregion
+
+        public override void Parse(byte[] buffer, int offset)
+        {
+            base.Parse(buffer, offset);
+            SynchronizationSource = Utils.Convert4BytesToInt(buffer, offset + 4);
+            NPTTimeStamp = Utils.Convert8BytesToLong(buffer, offset + 8);
+            RTPTimeStamp = Utils.Convert4BytesToInt(buffer, offset + 16);
+            SenderPacketCount = Utils.Convert4BytesToInt(buffer, offset + 20);
+            SenderOctetCount = Utils.Convert4BytesToInt(buffer, offset + 24);
+
+            ReportBlocks = new Collection<ReportBlock>();
+            int index = 28;
+
+            while (ReportBlocks.Count < ReportCount)
+            {
+                ReportBlock reportBlock = new ReportBlock();
+                reportBlock.Process(buffer, offset + index);                
+                ReportBlocks.Add(reportBlock);
+                index += reportBlock.BlockLength;
+            }
+
+            if (index < Length)
+            {
+                ProfileExtension = new byte[Length - index];
+
+                for (int extensionIndex = 0; index < Length; index++)
+                {
+                    ProfileExtension[extensionIndex] = buffer[offset + index];
+                    extensionIndex++;
+                }
+            }
+        }
+
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendFormat("Sender Report.\n");
+            sb.AppendFormat("Version : {0} .\n", Version);
+            sb.AppendFormat("Padding : {0} .\n", Padding);
+            sb.AppendFormat("Report Count : {0} .\n", ReportCount);
+            sb.AppendFormat("PacketType: {0} .\n", Type);
+            sb.AppendFormat("Length : {0} .\n", Length);
+            sb.AppendFormat("SynchronizationSource : {0} .\n", SynchronizationSource);
+            sb.AppendFormat("NTP Timestamp : {0} .\n", Utils.NptTimestampToDateTime(NPTTimeStamp));
+            sb.AppendFormat("RTP Timestamp : {0} .\n", RTPTimeStamp);
+            sb.AppendFormat("Sender PacketCount : {0} .\n", SenderPacketCount);
+            sb.AppendFormat("Sender Octet Count : {0} .\n", SenderOctetCount);            
+            sb.AppendFormat(".\n");
+            return sb.ToString();
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpSourceDescriptionPacket.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpSourceDescriptionPacket.cs
new file mode 100644
index 000000000..0a95a4413
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/RtcpSourceDescriptionPacket.cs
@@ -0,0 +1,57 @@
+using System.Collections.ObjectModel;
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+using System.Text;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    class RtcpSourceDescriptionPacket :RtcpPacket
+    { /// <summary>
+        /// Get the list of source descriptions.
+        /// </summary>
+        public Collection<SourceDescriptionBlock> Descriptions;
+        public override void Parse(byte[] buffer, int offset)
+        {
+            base.Parse(buffer, offset);
+            Descriptions = new Collection<SourceDescriptionBlock>();
+
+            int index = 4;
+
+            while (Descriptions.Count < ReportCount)
+            {
+                SourceDescriptionBlock descriptionBlock = new SourceDescriptionBlock();
+                descriptionBlock.Process(buffer, offset + index);
+                Descriptions.Add(descriptionBlock);
+                index += descriptionBlock.BlockLength;
+            }
+        }
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendFormat("Source Description.\n");
+            sb.AppendFormat("Version : {0} .\n", Version);
+            sb.AppendFormat("Padding : {0} .\n", Padding);
+            sb.AppendFormat("Report Count : {0} .\n", ReportCount);
+            sb.AppendFormat("PacketType: {0} .\n", Type);
+            sb.AppendFormat("Length : {0} .\n", Length);            
+            sb.AppendFormat("Descriptions : {0} .\n", Descriptions);
+            
+            sb.AppendFormat(".\n");
+            return sb.ToString();
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/SourceDescriptionBlock.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/SourceDescriptionBlock.cs
new file mode 100644
index 000000000..bf56087cd
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/SourceDescriptionBlock.cs
@@ -0,0 +1,65 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+using System.Collections.ObjectModel;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    class SourceDescriptionBlock
+    {
+        /// <summary>
+        /// Get the length of the block.
+        /// </summary>
+        public int BlockLength { get { return (blockLength + (blockLength % 4)); } }
+
+        /// <summary>
+        /// Get the synchronization source.
+        /// </summary>
+        public string SynchronizationSource { get; private set; }
+        /// <summary>
+        /// Get the list of source descriptioni items.
+        /// </summary>
+        public Collection<SourceDescriptionItem> Items;
+
+        private int blockLength;
+
+        public void Process(byte[] buffer, int offset)
+        {
+            SynchronizationSource = Utils.ConvertBytesToString(buffer, offset, 4);
+            Items = new Collection<SourceDescriptionItem>();
+            int index = 4;
+            bool done = false;
+            do
+            {
+                SourceDescriptionItem item = new SourceDescriptionItem();
+                item.Process(buffer, offset + index);
+                
+                if (item.Type != 0)
+                {
+                    Items.Add(item);
+                    index += item.ItemLength;                    
+                    blockLength += item.ItemLength;
+                }
+                else
+                {
+                    blockLength++;
+                    done = true;
+                }
+            }
+            while (!done);            
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/SourceDescriptionItem.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/SourceDescriptionItem.cs
new file mode 100644
index 000000000..5dd033642
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtcp/SourceDescriptionItem.cs
@@ -0,0 +1,60 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtcp
+{
+    /// <summary>
+    /// The class that describes a source description item.
+    /// </summary>
+    public class SourceDescriptionItem
+    {
+        /// <summary>
+        /// Get the type.
+        /// </summary>
+        public int Type { get; private set; }
+        /// <summary>
+        /// Get the text.
+        /// </summary>
+        public string Text { get; private set; }
+
+        /// <summary>
+        /// Get the length of the item.
+        /// </summary>
+        public int ItemLength { get { return (Text.Length + 2); } }
+
+        /// <summary>
+        /// Initialize a new instance of the SourceDescriptionItem class.
+        /// </summary>
+        public SourceDescriptionItem() { }
+
+        /// <summary>
+        /// Unpack the data in a packet.
+        /// </summary>
+        /// <param name="buffer">The buffer containing the packet.</param>
+        /// <param name="offset">The offset to the first byte of the packet within the buffer.</param>
+        /// <returns>An ErrorSpec instance if an error occurs; null otherwise.</returns>
+        public void Process(byte[] buffer, int offset)
+        {
+            Type = buffer[offset];
+            if (Type != 0)
+            {
+                int length = buffer[offset + 1];
+                Text = Utils.ConvertBytesToString(buffer, offset + 2, length);
+            }            
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtp/RtpListener.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtp/RtpListener.cs
new file mode 100644
index 000000000..ea6a9ba6a
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtp/RtpListener.cs
@@ -0,0 +1,160 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using MediaBrowser.Model.Logging;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtp
+{
+    public class RtpListener
+    {
+        private readonly ILogger _logger;
+        private AutoResetEvent _rtpListenerThreadStopEvent;
+        private Thread _rtpListenerThread;
+        private UdpClient _udpClient;
+        private IPEndPoint _multicastEndPoint;
+        private IPEndPoint _serverEndPoint;
+        private TransmissionMode _transmissionMode;
+        public RtpListener(String address, int port,TransmissionMode mode,ILogger logger)
+        {
+            _logger = logger;
+            _transmissionMode = mode;
+            switch (mode)
+            {
+                case TransmissionMode.Unicast:
+                    _udpClient = new UdpClient(new IPEndPoint(IPAddress.Parse(address), port));
+                    _serverEndPoint = new IPEndPoint(IPAddress.Any, 0);
+                    break;
+                case TransmissionMode.Multicast:                    
+                    _multicastEndPoint = new IPEndPoint(IPAddress.Parse(address), port);
+                    _serverEndPoint = null;
+                    _udpClient = new UdpClient();
+                    _udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
+                    _udpClient.ExclusiveAddressUse = false;
+                    _udpClient.Client.Bind(new IPEndPoint(IPAddress.Any, _multicastEndPoint.Port));
+                    _udpClient.JoinMulticastGroup(_multicastEndPoint.Address);
+                    break;
+            }            
+            //StartRtpListenerThread();
+        }
+        public void StartRtpListenerThread()
+        {
+            // Kill the existing thread if it is in "zombie" state.
+            if (_rtpListenerThread != null && !_rtpListenerThread.IsAlive)
+            {
+                StopRtpListenerThread();
+            }
+
+            if (_rtpListenerThread == null)
+            {
+                _logger.Info("SAT>IP : starting new RTP listener thread");
+                _rtpListenerThreadStopEvent = new AutoResetEvent(false);
+                _rtpListenerThread = new Thread(new ThreadStart(RtpListenerThread));
+                _rtpListenerThread.Name = string.Format("SAT>IP tuner  RTP listener");
+                _rtpListenerThread.IsBackground = true;
+                _rtpListenerThread.Priority = ThreadPriority.Lowest;
+                _rtpListenerThread.Start();
+            }
+        }
+
+        public void StopRtpListenerThread()
+        {
+            if (_rtpListenerThread != null)
+            {
+                if (!_rtpListenerThread.IsAlive)
+                {
+                    _logger.Info("SAT>IP : aborting old RTP listener thread");
+                    _rtpListenerThread.Abort();
+                }
+                else
+                {
+                    _rtpListenerThreadStopEvent.Set();
+                    if (!_rtpListenerThread.Join(400 * 2))
+                    {
+                        _logger.Info("SAT>IP : failed to join RTP listener thread, aborting thread");
+                        _rtpListenerThread.Abort();
+                    }
+                }
+                _rtpListenerThread = null;
+                if (_rtpListenerThreadStopEvent != null)
+                {
+                    _rtpListenerThreadStopEvent.Close();
+                    _rtpListenerThreadStopEvent = null;
+                }
+            }
+        }
+
+        private void RtpListenerThread()
+        {
+            try
+            { 
+                try
+                {                   
+                    
+                    while (!_rtpListenerThreadStopEvent.WaitOne(1))
+                    {
+                        byte[] receivedbytes = _udpClient.Receive(ref _serverEndPoint);
+                        RtpPacket packet = RtpPacket.Decode(receivedbytes);
+                        OnPacketReceived(new RtpPacketReceivedArgs(packet));
+                    }
+                }
+                finally
+                {
+                    switch (_transmissionMode)
+                    {
+                        case TransmissionMode.Multicast:
+                            _udpClient.DropMulticastGroup(_multicastEndPoint.Address);
+                            _udpClient.Close();
+                            break;
+                        case TransmissionMode.Unicast:
+                            _udpClient.Close();
+                            break;
+                    }                   
+                }
+            }
+            catch (ThreadAbortException)
+            {
+            }
+            catch (Exception ex)
+            {
+                _logger.Info(string.Format("SAT>IP : RTP listener thread exception"), ex);
+                return;
+            }
+            _logger.Info("SAT>IP : RTP listener thread stopping");
+        }
+        public delegate void PacketReceivedHandler(object sender, RtpPacketReceivedArgs e);
+        public event PacketReceivedHandler PacketReceived;
+        public class RtpPacketReceivedArgs : EventArgs
+        {
+            public RtpPacket Packet { get; private set; }
+
+            public RtpPacketReceivedArgs(RtpPacket packet)
+            {
+                Packet = packet;
+            }
+        }
+        protected void OnPacketReceived(RtpPacketReceivedArgs args)
+        {
+            if (PacketReceived != null)
+            {
+                PacketReceived(this, args);
+            }
+        }
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtp/RtpPacket.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtp/RtpPacket.cs
new file mode 100644
index 000000000..489d7f087
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Rtp/RtpPacket.cs
@@ -0,0 +1,116 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+using System;
+using System.Collections.ObjectModel;
+using System.Text;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp.Rtp
+{
+    public class RtpPacket
+    {
+        private static int MinHeaderLength = 12;
+        public int HeaderSize = MinHeaderLength;
+        public int Version { get; set; }
+        public Boolean Padding { get; set; }
+        public Boolean Extension { get; set; }
+        public int ContributingSourceCount { get; set; }
+        public Boolean Marker { get; set; }
+        public int PayloadType { get; set; }
+        public int SequenceNumber { get; set; }
+        public long TimeStamp { get; set; }
+        public long SynchronizationSource { get; set; }
+        public Collection<string> ContributingSources { get; private set; }
+        public int ExtensionHeaderId = 0;
+        public int ExtensionHeaderLength = 0;       
+        public bool HasPayload { get; set; }
+        public byte[] Payload { get; set; }
+        public RtpPacket()
+        {
+            
+        }
+        public static RtpPacket Decode(byte[] buffer)
+        {
+            var packet = new RtpPacket();
+            packet.Version = buffer[0] >> 6;
+            packet.Padding = (buffer[0] & 0x20) != 0;
+            packet.Extension = (buffer[0] & 0x10) != 0;
+            packet.ContributingSourceCount = buffer[0] & 0x0f;
+
+            packet.Marker = (buffer[1] & 0x80) != 0;
+            packet.PayloadType = buffer[1] & 0x7f;
+
+            packet.SequenceNumber = Utils.Convert2BytesToInt(buffer, 2);
+            packet.TimeStamp = Utils.Convert4BytesToLong(buffer, 4);
+            packet.SynchronizationSource = Utils.Convert4BytesToLong(buffer, 8);
+
+            int index = 12;
+
+            if (packet.ContributingSourceCount != 0)
+            {
+                packet.ContributingSources = new Collection<string>();
+
+                while (packet.ContributingSources.Count < packet.ContributingSourceCount)
+                {
+                    packet.ContributingSources.Add(Utils.ConvertBytesToString(buffer, index, 4));
+                    index += 4;
+                }
+            }
+            var dataoffset = 0;
+            if (!packet.Extension)
+                dataoffset = index;
+            else
+            {
+                packet.ExtensionHeaderId = Utils.Convert2BytesToInt(buffer, index);
+                packet.ExtensionHeaderLength = Utils.Convert2BytesToInt(buffer, index + 2);
+                dataoffset = index + packet.ExtensionHeaderLength + 4;
+            }
+
+            var dataLength = buffer.Length - dataoffset;
+            if (dataLength > dataoffset)
+            {
+                packet.HasPayload = true;
+                packet.Payload = new byte[dataLength];
+                Array.Copy(buffer, dataoffset, packet.Payload, 0, dataLength);
+            }
+            else
+            {
+                packet.HasPayload = false;
+            }
+            return packet;
+        }        
+
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendFormat("RTP Packet");
+            sb.AppendFormat("Version: {0} \n", Version);
+            sb.AppendFormat("Padding: {0} \n", Padding);
+            sb.AppendFormat("Extension: {0} \n", Extension);
+            sb.AppendFormat("Contributing Source Identifiers Count: {0} \n", ContributingSourceCount);
+            sb.AppendFormat("Marker: {0} \n", Marker);
+            sb.AppendFormat("Payload Type: {0} \n", PayloadType);
+            sb.AppendFormat("Sequence Number: {0} \n", SequenceNumber);
+            sb.AppendFormat("Timestamp: {0} .\n", TimeStamp);
+            sb.AppendFormat("Synchronization Source Identifier: {0} \n", SynchronizationSource);
+            sb.AppendFormat("\n");
+            return sb.ToString();
+        }
+
+    }
+
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/SatIpDiscovery.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/SatIpDiscovery.cs
index 9d5dba282..a0b8ef5f7 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/SatIpDiscovery.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/SatIpDiscovery.cs
@@ -14,6 +14,7 @@ using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.Serialization;
 using MediaBrowser.Model.Extensions;
 using System.Xml.Linq;
+using MediaBrowser.Model.Events;
 
 namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
 {
@@ -26,7 +27,12 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
         private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
         private readonly IHttpClient _httpClient;
         private readonly IJsonSerializer _json;
-
+        private int _tunerCountDVBS=0;
+        private int _tunerCountDVBC=0;
+        private int _tunerCountDVBT=0;
+        private bool  _supportsDVBS=false;
+        private bool  _supportsDVBC=false;
+        private bool  _supportsDVBT=false;
         public static SatIpDiscovery Current;
 
         public SatIpDiscovery(IDeviceDiscovery deviceDiscovery, IServerConfigurationManager config, ILogger logger, ILiveTvManager liveTvManager, IHttpClient httpClient, IJsonSerializer json)
@@ -45,18 +51,20 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
             _deviceDiscovery.DeviceDiscovered += _deviceDiscovery_DeviceDiscovered;
         }
 
-        void _deviceDiscovery_DeviceDiscovered(object sender, SsdpMessageEventArgs e)
+        void _deviceDiscovery_DeviceDiscovered(object sender, GenericEventArgs<UpnpDeviceInfo> e)
         {
+            var info = e.Argument;
+
             string st = null;
             string nt = null;
-            e.Headers.TryGetValue("ST", out st);
-            e.Headers.TryGetValue("NT", out nt);
+            info.Headers.TryGetValue("ST", out st);
+            info.Headers.TryGetValue("NT", out nt);
 
             if (string.Equals(st, "urn:ses-com:device:SatIPServer:1", StringComparison.OrdinalIgnoreCase) ||
                 string.Equals(nt, "urn:ses-com:device:SatIPServer:1", StringComparison.OrdinalIgnoreCase))
             {
                 string location;
-                if (e.Headers.TryGetValue("Location", out location) && !string.IsNullOrWhiteSpace(location))
+                if (info.Headers.TryGetValue("Location", out location) && !string.IsNullOrWhiteSpace(location))
                 {
                     _logger.Debug("SAT IP found at {0}", location);
 
@@ -167,7 +175,57 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
         public void Dispose()
         {
         }
+ private void ReadCapability(string capability)
+        {
+
+            string[] cap = capability.Split('-');
+            switch (cap[0].ToLower())
+            {
+                case "dvbs":
+                case "dvbs2":
+                    {
+                        // Optional that you know what an device Supports can you add an flag 
+                        _supportsDVBS = true;
 
+                        for (int i = 0; i < int.Parse(cap[1]); i++)
+                        {
+                            //ToDo Create Digital Recorder / Tuner Capture Instance here for each with index FE param in Sat>Ip Spec for direct communication with this instance 
+                        }
+                        _tunerCountDVBS = int.Parse(cap[1]);
+                        break;
+                    }
+                case "dvbc":
+                case "dvbc2":
+                    {
+                        // Optional that you know what an device Supports can you add an flag 
+                        _supportsDVBC = true;
+
+                        for (int i = 0; i < int.Parse(cap[1]); i++)
+                        {
+                            //ToDo Create Digital Recorder / Tuner Capture Instance here for each with index FE param in Sat>Ip Spec for direct communication with this instance
+                            
+                        }
+                        _tunerCountDVBC = int.Parse(cap[1]);
+                        break;
+                    }
+                case "dvbt":
+                case "dvbt2":
+                    {
+                        // Optional that you know what an device Supports can you add an flag 
+                        _supportsDVBT = true;
+
+
+                        for (int i = 0; i < int.Parse(cap[1]); i++)
+                        {
+                            //ToDo Create Digital Recorder / Tuner Capture Instance here for each with index FE param in Sat>Ip Spec for direct communication with this instance  
+
+                        }
+                        _tunerCountDVBT = int.Parse(cap[1]);
+                        break;
+                    }
+            }
+
+        }
         public async Task<SatIpTunerHostInfo> GetInfo(string url, CancellationToken cancellationToken)
         {
             Uri locationUri = new Uri(url);
@@ -182,7 +240,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
             string modelurl = "";
             string serialnumber = "";
             string presentationurl = "";
-            string capabilities = "";
+            //string capabilities = "";
             string m3u = "";
             var document = XDocument.Load(locationUri.AbsoluteUri);
             var xnm = new XmlNamespaceManager(new NameTable());
@@ -227,7 +285,27 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
                     var presentationUrlElement = deviceElement.Element(n0 + "presentationURL");
                     if (presentationUrlElement != null) presentationurl = presentationUrlElement.Value;
                     var capabilitiesElement = deviceElement.Element(n1 + "X_SATIPCAP");
-                    if (capabilitiesElement != null) capabilities = capabilitiesElement.Value;
+                        if (capabilitiesElement != null)
+                        {
+                        //_capabilities = capabilitiesElement.Value;
+                        if (capabilitiesElement.Value.Contains(','))
+                        {
+                            string[] capabilities = capabilitiesElement.Value.Split(',');
+                            foreach (var capability in capabilities)
+                            {
+                                ReadCapability(capability);
+                            }
+                        }
+                        else
+                        {
+                            ReadCapability(capabilitiesElement.Value);
+                        }
+                    }
+                        else
+                        {
+                            _supportsDVBS = true;
+                            _tunerCountDVBS =1;
+                        }
                     var m3uElement = deviceElement.Element(n1 + "X_SATIPM3U");
                     if (m3uElement != null) m3u = m3uElement.Value;
                 }
@@ -239,8 +317,8 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
                 Id = uniquedevicename,
                 IsEnabled = true,
                 Type = SatIpHost.DeviceType,
-                Tuners = 1,
-                TunersAvailable = 1,
+                Tuners = _tunerCountDVBS,
+                TunersAvailable = _tunerCountDVBS,
                 M3UUrl = m3u
             };
 
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/SatIpHost.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/SatIpHost.cs
index b1e349a86..81deb2995 100644
--- a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/SatIpHost.cs
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/SatIpHost.cs
@@ -8,6 +8,7 @@ using CommonIO;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Extensions;
 using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.MediaEncoding;
 using MediaBrowser.Model.Dto;
@@ -16,6 +17,7 @@ using MediaBrowser.Model.LiveTv;
 using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.MediaInfo;
 using MediaBrowser.Model.Serialization;
+using MediaBrowser.Server.Implementations.LiveTv.EmbyTV;
 
 namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
 {
@@ -24,7 +26,7 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
         private readonly IFileSystem _fileSystem;
         private readonly IHttpClient _httpClient;
 
-        public SatIpHost(IConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IHttpClient httpClient)
+        public SatIpHost(IServerConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IHttpClient httpClient)
             : base(config, logger, jsonSerializer, mediaEncoder)
         {
             _fileSystem = fileSystem;
@@ -113,11 +115,13 @@ namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
             return new List<MediaSourceInfo>();
         }
 
-        protected override async Task<MediaSourceInfo> GetChannelStream(TunerHostInfo tuner, string channelId, string streamId, CancellationToken cancellationToken)
+        protected override async Task<LiveStream> GetChannelStream(TunerHostInfo tuner, string channelId, string streamId, CancellationToken cancellationToken)
         {
             var sources = await GetChannelStreamMediaSources(tuner, channelId, cancellationToken).ConfigureAwait(false);
 
-            return sources.First();
+            var liveStream = new LiveStream(sources.First());
+
+            return liveStream;
         }
 
         protected override async Task<bool> IsAvailableInternal(TunerHostInfo tuner, string channelId, CancellationToken cancellationToken)
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/TransmissionMode.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/TransmissionMode.cs
new file mode 100644
index 000000000..71d7656d9
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/TransmissionMode.cs
@@ -0,0 +1,25 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
+{
+    public enum TransmissionMode
+    {
+        Unicast,
+        Multicast
+    }
+}
diff --git a/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Utils.cs b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Utils.cs
new file mode 100644
index 000000000..3595e4b0a
--- /dev/null
+++ b/MediaBrowser.Server.Implementations/LiveTv/TunerHosts/SatIp/Utils.cs
@@ -0,0 +1,90 @@
+/*  
+    Copyright (C) <2007-2016>  <Kay Diefenthal>
+
+    SatIp.RtspSample is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    SatIp.RtspSample is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with SatIp.RtspSample.  If not, see <http://www.gnu.org/licenses/>.
+*/
+using System;
+using System.Text;
+
+namespace MediaBrowser.Server.Implementations.LiveTv.TunerHosts.SatIp
+{
+    public class Utils
+    {
+        public static int Convert2BytesToInt(byte[] buffer, int offset)
+        {
+            int temp = (int)buffer[offset];
+            temp = (temp * 256) + buffer[offset + 1];
+
+            return (temp);
+        }
+        public static int Convert3BytesToInt(byte[] buffer, int offset)
+        {
+            int temp = (int)buffer[offset];
+            temp = (temp * 256) + buffer[offset + 1];
+            temp = (temp * 256) + buffer[offset + 2];
+
+            return (temp);
+        }
+        public static int Convert4BytesToInt(byte[] buffer, int offset)
+        {
+            int temp =(int)buffer[offset]; 
+            temp = (temp * 256) + buffer[offset + 1];
+            temp = (temp * 256) + buffer[offset + 2];
+            temp = (temp * 256) + buffer[offset + 3];
+            
+            return (temp);
+        }
+        public static long Convert4BytesToLong(byte[] buffer, int offset)
+        {
+            long temp = 0;
+
+            for (int index = 0; index < 4; index++)
+                temp = (temp * 256) + buffer[offset + index];
+
+            return (temp);
+        }
+        public static long Convert8BytesToLong(byte[] buffer, int offset)
+        {
+            long temp = 0;
+
+            for (int index = 0; index < 8; index++)
+                temp = (temp * 256) + buffer[offset + index];
+
+            return (temp);
+        }
+        public static string ConvertBytesToString(byte[] buffer, int offset, int length)
+        {
+            StringBuilder reply = new StringBuilder(4);
+            for (int index = 0; index < length; index++)
+                reply.Append((char)buffer[offset + index]);
+            return (reply.ToString());
+        }
+        public static DateTime NptTimestampToDateTime(long nptTimestamp) { return NptTimestampToDateTime((uint)((nptTimestamp >> 32) & 0xFFFFFFFF), (uint)(nptTimestamp & 0xFFFFFFFF),null); }
+
+        public static DateTime NptTimestampToDateTime(uint seconds, uint fractions, DateTime? epoch )
+        {
+            ulong ticks =(ulong)((seconds * TimeSpan.TicksPerSecond) + ((fractions * TimeSpan.TicksPerSecond) / 0x100000000L));
+            if (epoch.HasValue) return epoch.Value + TimeSpan.FromTicks((Int64)ticks);
+            return (seconds & 0x80000000L) == 0 ? UtcEpoch2036 + TimeSpan.FromTicks((Int64)ticks) : UtcEpoch1900 + TimeSpan.FromTicks((Int64)ticks);
+        }
+
+        //When the First Epoch will wrap (The real Y2k)
+        public static DateTime UtcEpoch2036 = new DateTime(2036, 2, 7, 6, 28, 16, DateTimeKind.Utc);
+
+        public static DateTime UtcEpoch1900 = new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+        public static DateTime UtcEpoch1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+    }
+}