add methods to media source manager

MediaBrowser.Server.Implementations/Library/MediaSourceManager.cs

@@ -1,19 +1,38 @@
-using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Channels;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.MediaEncoding;
 using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MediaBrowser.Server.Implementations.Library
 {
     public class MediaSourceManager : IMediaSourceManager
     {
         private readonly IItemRepository _itemRepo;
+        private readonly IUserManager _userManager;
+        private readonly ILibraryManager _libraryManager;
+        private readonly IChannelManager _channelManager;
 
-        public MediaSourceManager(IItemRepository itemRepo)
+        private IMediaSourceProvider[] _providers;
+
+        public MediaSourceManager(IItemRepository itemRepo, IUserManager userManager, ILibraryManager libraryManager, IChannelManager channelManager)
         {
             _itemRepo = itemRepo;
+            _userManager = userManager;
+            _libraryManager = libraryManager;
+            _channelManager = channelManager;
+        }
+
+        public void AddParts(IEnumerable<IMediaSourceProvider> providers)
+        {
+            _providers = providers.ToArray();
         }
 
         public IEnumerable<MediaStream> GetMediaStreams(MediaStreamQuery query)
@@ -102,5 +121,132 @@ namespace MediaBrowser.Server.Implementations.Library
 
             return list;
         }
+
+        public async Task<IEnumerable<MediaSourceInfo>> GetPlayackMediaSources(string id, string userId, CancellationToken cancellationToken)
+        {
+            var item = _libraryManager.GetItemById(id);
+            IEnumerable<MediaSourceInfo> mediaSources;
+
+            var channelItem = item as IChannelMediaItem;
+
+            if (channelItem != null)
+            {
+                mediaSources = await _channelManager.GetChannelItemMediaSources(id, true, cancellationToken)
+                        .ConfigureAwait(false);
+            }
+            else
+            {
+                var hasMediaSources = (IHasMediaSources)item;
+
+                if (string.IsNullOrWhiteSpace(userId))
+                {
+                    mediaSources = hasMediaSources.GetMediaSources(true);
+                }
+                else
+                {
+                    var user = _userManager.GetUserById(userId);
+                    mediaSources = GetStaticMediaSources(hasMediaSources, true, user);
+                }
+            }
+
+            return mediaSources;
+        }
+
+        public Task<IEnumerable<MediaSourceInfo>> GetPlayackMediaSources(string id, CancellationToken cancellationToken)
+        {
+            return GetPlayackMediaSources(id, null, cancellationToken);
+        }
+
+        public IEnumerable<MediaSourceInfo> GetStaticMediaSources(IHasMediaSources item, bool enablePathSubstitution)
+        {
+            if (item == null)
+            {
+                throw new ArgumentNullException("item");
+            }
+
+            if (!(item is Video))
+            {
+                return item.GetMediaSources(enablePathSubstitution);
+            }
+
+            return item.GetMediaSources(enablePathSubstitution);
+        }
+
+        public IEnumerable<MediaSourceInfo> GetStaticMediaSources(IHasMediaSources item, bool enablePathSubstitution, User user)
+        {
+            if (item == null)
+            {
+                throw new ArgumentNullException("item");
+            }
+
+            if (!(item is Video))
+            {
+                return item.GetMediaSources(enablePathSubstitution);
+            }
+
+            if (user == null)
+            {
+                throw new ArgumentNullException("user");
+            }
+
+            var sources = item.GetMediaSources(enablePathSubstitution).ToList();
+
+            foreach (var source in sources)
+            {
+                SetUserProperties(source, user);
+            }
+
+            return sources;
+        }
+
+        private void SetUserProperties(MediaSourceInfo source, User user)
+        {
+            var preferredAudio = string.IsNullOrEmpty(user.Configuration.AudioLanguagePreference)
+            ? new string[] { }
+            : new[] { user.Configuration.AudioLanguagePreference };
+
+            var preferredSubs = string.IsNullOrEmpty(user.Configuration.SubtitleLanguagePreference)
+                ? new List<string> { }
+                : new List<string> { user.Configuration.SubtitleLanguagePreference };
+
+            source.DefaultAudioStreamIndex = MediaStreamSelector.GetDefaultAudioStreamIndex(source.MediaStreams, preferredAudio, user.Configuration.PlayDefaultAudioTrack);
+
+            var defaultAudioIndex = source.DefaultAudioStreamIndex;
+            var audioLangage = defaultAudioIndex == null
+                ? null
+                : source.MediaStreams.Where(i => i.Type == MediaStreamType.Audio && i.Index == defaultAudioIndex).Select(i => i.Language).FirstOrDefault();
+
+            source.DefaultSubtitleStreamIndex = MediaStreamSelector.GetDefaultSubtitleStreamIndex(source.MediaStreams,
+                preferredSubs,
+                user.Configuration.SubtitleMode,
+                audioLangage);
+        }
+
+        private IEnumerable<MediaSourceInfo> SortMediaSources(IEnumerable<MediaSourceInfo> sources)
+        {
+            return sources.OrderBy(i =>
+            {
+                if (i.VideoType.HasValue && i.VideoType.Value == VideoType.VideoFile)
+                {
+                    return 0;
+                }
+
+                return 1;
+
+            }).ThenBy(i => i.Video3DFormat.HasValue ? 1 : 0)
+            .ThenByDescending(i =>
+            {
+                var stream = i.VideoStream;
+
+                return stream == null || stream.Width == null ? 0 : stream.Width.Value;
+            })
+            .ToList();
+        }
+
+
+        public MediaSourceInfo GetStaticMediaSource(IHasMediaSources item, string mediaSourceId, bool enablePathSubstitution)
+        {
+            return GetStaticMediaSources(item, enablePathSubstitution).FirstOrDefault(i => string.Equals(i.Id, mediaSourceId, StringComparison.OrdinalIgnoreCase));
+        }
     }
 }