jellyfin/MediaBrowser.Server.Implementations/Photos/BaseDynamicImageProvider.cs

257 lines
9.1 KiB
C#
Raw Normal View History

using MediaBrowser.Common.Configuration;
using MediaBrowser.Common.Extensions;
2014-10-29 22:01:02 +00:00
using MediaBrowser.Common.IO;
2015-04-08 14:38:02 +00:00
using MediaBrowser.Controller.Drawing;
2014-10-29 22:01:02 +00:00
using MediaBrowser.Controller.Entities;
2015-03-14 17:02:51 +00:00
using MediaBrowser.Controller.Library;
2015-04-02 17:44:44 +00:00
using MediaBrowser.Controller.Playlists;
2014-10-29 22:01:02 +00:00
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Entities;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Server.Implementations.Photos
{
2015-03-14 17:02:51 +00:00
public abstract class BaseDynamicImageProvider<T> : IHasChangeMonitor, IForcedProvider, ICustomMetadataProvider<T>, IHasOrder
2015-03-13 19:16:34 +00:00
where T : IHasMetadata
2014-10-29 22:01:02 +00:00
{
protected IFileSystem FileSystem { get; private set; }
protected IProviderManager ProviderManager { get; private set; }
protected IApplicationPaths ApplicationPaths { get; private set; }
2015-04-08 14:38:02 +00:00
protected IImageProcessor ImageProcessor { get; set; }
2014-10-29 22:01:02 +00:00
2015-04-08 14:38:02 +00:00
protected BaseDynamicImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor)
2014-10-29 22:01:02 +00:00
{
ApplicationPaths = applicationPaths;
2014-10-29 22:01:02 +00:00
ProviderManager = providerManager;
FileSystem = fileSystem;
2015-04-08 14:38:02 +00:00
ImageProcessor = imageProcessor;
2014-10-29 22:01:02 +00:00
}
2015-03-13 19:37:19 +00:00
public virtual bool Supports(IHasImages item)
2014-10-29 22:01:02 +00:00
{
2015-03-14 17:02:51 +00:00
return true;
2014-10-29 22:01:02 +00:00
}
2015-03-14 04:50:23 +00:00
public virtual IEnumerable<ImageType> GetSupportedImages(IHasImages item)
2014-10-29 22:01:02 +00:00
{
2015-03-13 19:37:19 +00:00
return new List<ImageType>
{
ImageType.Primary,
ImageType.Thumb
};
2014-10-29 22:01:02 +00:00
}
2015-03-14 17:02:51 +00:00
public async Task<ItemUpdateType> FetchAsync(T item, MetadataRefreshOptions options, CancellationToken cancellationToken)
{
if (!Supports(item))
{
return ItemUpdateType.None;
}
var primaryResult = await FetchAsync(item, ImageType.Primary, options, cancellationToken).ConfigureAwait(false);
var thumbResult = await FetchAsync(item, ImageType.Thumb, options, cancellationToken).ConfigureAwait(false);
return primaryResult | thumbResult;
}
protected async Task<ItemUpdateType> FetchAsync(IHasImages item, ImageType imageType, MetadataRefreshOptions options, CancellationToken cancellationToken)
{
var items = await GetItemsWithImages(item).ConfigureAwait(false);
2015-03-16 01:48:25 +00:00
var cacheKey = GetConfigurationCacheKey(items, item.Name);
2015-03-14 17:02:51 +00:00
if (!HasChanged(item, imageType, cacheKey))
{
return ItemUpdateType.None;
}
return await FetchToFileInternal(item, items, imageType, cacheKey, cancellationToken).ConfigureAwait(false);
}
protected async Task<ItemUpdateType> FetchToFileInternal(IHasImages item,
List<BaseItem> itemsWithImages,
ImageType imageType,
string cacheKey,
CancellationToken cancellationToken)
{
2015-04-08 15:45:30 +00:00
var outputPath = Path.Combine(ApplicationPaths.TempDirectory, Guid.NewGuid() + ".png");
Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
var imageCreated = CreateImage(item, itemsWithImages, outputPath, imageType, 0);
2015-03-14 17:02:51 +00:00
2015-04-08 15:45:30 +00:00
if (!imageCreated)
2015-03-14 17:02:51 +00:00
{
return ItemUpdateType.None;
}
2015-04-08 15:45:30 +00:00
await ProviderManager.SaveImage(item, outputPath, "image/png", imageType, null, cacheKey, cancellationToken).ConfigureAwait(false);
2015-03-14 17:02:51 +00:00
return ItemUpdateType.ImageUpdate;
}
2015-03-13 19:37:19 +00:00
protected abstract Task<List<BaseItem>> GetItemsWithImages(IHasImages item);
2015-04-16 14:59:39 +00:00
private const string Version = "31";
2015-03-16 01:48:25 +00:00
protected string GetConfigurationCacheKey(List<BaseItem> items, string itemName)
2015-03-13 19:37:19 +00:00
{
2015-03-24 02:26:19 +00:00
var parts = Version + "_" + (itemName ?? string.Empty) + "_" +
string.Join(",", items.Select(i => i.Id.ToString("N")).ToArray());
return parts.GetMD5().ToString("N");
2014-10-29 22:01:02 +00:00
}
2015-04-16 14:59:39 +00:00
protected void CreateThumbCollage(IHasImages primaryItem, List<BaseItem> items, string outputPath, bool drawText)
2014-10-29 22:01:02 +00:00
{
2015-04-16 14:59:39 +00:00
CreateCollage(primaryItem, items, outputPath, 960, 540, drawText, primaryItem.Name);
2014-10-29 22:01:02 +00:00
}
2015-04-08 15:45:30 +00:00
protected virtual IEnumerable<string> GetStripCollageImagePaths(IHasImages primaryItem, IEnumerable<BaseItem> items)
2014-10-29 22:01:02 +00:00
{
2015-04-02 16:58:52 +00:00
return items
2015-03-03 07:03:17 +00:00
.Select(i => i.GetImagePath(ImageType.Primary) ?? i.GetImagePath(ImageType.Thumb))
2015-04-02 16:58:52 +00:00
.Where(i => !string.IsNullOrWhiteSpace(i));
}
2015-04-08 15:45:30 +00:00
protected void CreatePosterCollage(IHasImages primaryItem, List<BaseItem> items, string outputPath)
2015-04-02 17:44:44 +00:00
{
2015-04-08 15:45:30 +00:00
CreateCollage(primaryItem, items, outputPath, 600, 900, true, primaryItem.Name);
2015-04-08 14:38:02 +00:00
}
2015-04-16 14:59:39 +00:00
protected void CreateSquareCollage(IHasImages primaryItem, List<BaseItem> items, string outputPath, bool drawText)
2015-04-08 14:38:02 +00:00
{
2015-04-16 14:59:39 +00:00
CreateCollage(primaryItem, items, outputPath, 800, 800, drawText, primaryItem.Name);
2015-04-08 14:38:02 +00:00
}
2015-04-02 17:44:44 +00:00
2015-04-08 15:45:30 +00:00
protected void CreateThumbCollage(IHasImages primaryItem, List<BaseItem> items, string outputPath, int width, int height, bool drawText, string text)
2015-04-08 14:38:02 +00:00
{
2015-04-08 15:45:30 +00:00
CreateCollage(primaryItem, items, outputPath, width, height, drawText, text);
2015-04-02 17:44:44 +00:00
}
2015-04-08 15:45:30 +00:00
private void CreateCollage(IHasImages primaryItem, List<BaseItem> items, string outputPath, int width, int height, bool drawText, string text)
2015-04-02 16:58:52 +00:00
{
2015-04-08 14:38:02 +00:00
Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
var options = new ImageCollageOptions
{
Height = height,
Width = width,
OutputPath = outputPath,
Text = drawText ? text : null,
InputPaths = GetStripCollageImagePaths(primaryItem, items).ToArray()
};
ImageProcessor.CreateImageCollage(options);
2014-10-29 22:01:02 +00:00
}
public string Name
{
get { return "Dynamic Image Provider"; }
}
2015-04-08 15:45:30 +00:00
protected virtual bool CreateImage(IHasImages item,
2014-10-29 22:01:02 +00:00
List<BaseItem> itemsWithImages,
2015-04-08 15:45:30 +00:00
string outputPath,
2015-03-13 19:37:19 +00:00
ImageType imageType,
2014-10-29 22:01:02 +00:00
int imageIndex)
{
if (itemsWithImages.Count == 0)
{
2015-04-08 15:45:30 +00:00
return false;
2014-10-29 22:01:02 +00:00
}
2015-04-16 14:59:39 +00:00
var drawText = !(item is UserView);
2015-04-02 17:44:44 +00:00
if (imageType == ImageType.Thumb)
{
2015-04-16 14:59:39 +00:00
CreateThumbCollage(item, itemsWithImages, outputPath, drawText);
2015-04-08 15:45:30 +00:00
return true;
2015-04-02 17:44:44 +00:00
}
if (imageType == ImageType.Primary)
{
2015-04-16 14:59:39 +00:00
if (item is UserView)
{
CreateSquareCollage(item, itemsWithImages, outputPath, drawText);
}
else if (item is PhotoAlbum || item is Playlist)
2015-04-08 15:45:30 +00:00
{
2015-04-16 14:59:39 +00:00
CreateSquareCollage(item, itemsWithImages, outputPath, drawText);
2015-04-08 15:45:30 +00:00
}
else
{
CreatePosterCollage(item, itemsWithImages, outputPath);
}
return true;
2015-04-02 17:44:44 +00:00
}
throw new ArgumentException("Unexpected image type");
2014-10-29 22:01:02 +00:00
}
public bool HasChanged(IHasMetadata item, IDirectoryService directoryService, DateTime date)
{
if (!Supports(item))
{
return false;
}
var items = GetItemsWithImages(item).Result;
2015-03-16 01:48:25 +00:00
var cacheKey = GetConfigurationCacheKey(items, item.Name);
2014-10-29 22:01:02 +00:00
return HasChanged(item, ImageType.Primary, cacheKey) || HasChanged(item, ImageType.Thumb, cacheKey);
}
protected bool HasChanged(IHasImages item, ImageType type, string cacheKey)
{
var image = item.GetImageInfo(type, 0);
if (image != null)
{
if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
{
return false;
}
var currentPathCacheKey = (Path.GetFileNameWithoutExtension(image.Path) ?? string.Empty).Split('_').LastOrDefault();
if (string.Equals(cacheKey, currentPathCacheKey, StringComparison.OrdinalIgnoreCase))
{
return false;
}
}
return true;
}
protected List<BaseItem> GetFinalItems(List<BaseItem> items)
2015-03-13 19:52:49 +00:00
{
// Rotate the images no more than once per week
return GetFinalItems(items, 4);
}
2015-03-14 17:02:51 +00:00
protected virtual List<BaseItem> GetFinalItems(List<BaseItem> items, int limit)
2014-10-29 22:01:02 +00:00
{
2015-03-26 23:10:34 +00:00
// Rotate the images once every x days
var random = DateTime.Now.DayOfYear % 4;
2014-10-29 22:01:02 +00:00
return items
2015-03-24 02:26:19 +00:00
.OrderBy(i => (random + "" + items.IndexOf(i)).GetMD5())
2015-03-13 19:52:49 +00:00
.Take(limit)
2014-10-29 22:01:02 +00:00
.OrderBy(i => i.Name)
.ToList();
}
2015-03-13 19:37:19 +00:00
public int Order
{
get
{
// Run before the default image provider which will download placeholders
return 0;
}
}
2014-10-29 22:01:02 +00:00
}
}