BaseDynamicImageProvider.cs 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316
  1. #pragma warning disable CS1591
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Globalization;
  5. using System.IO;
  6. using System.Linq;
  7. using System.Threading;
  8. using System.Threading.Tasks;
  9. using MediaBrowser.Common.Configuration;
  10. using MediaBrowser.Controller.Drawing;
  11. using MediaBrowser.Controller.Entities;
  12. using MediaBrowser.Controller.Entities.Audio;
  13. using MediaBrowser.Controller.Library;
  14. using MediaBrowser.Controller.Playlists;
  15. using MediaBrowser.Controller.Providers;
  16. using MediaBrowser.Model.Entities;
  17. using MediaBrowser.Model.IO;
  18. using MediaBrowser.Model.Net;
  19. namespace Emby.Server.Implementations.Images
  20. {
  21. public abstract class BaseDynamicImageProvider<T> : IHasItemChangeMonitor, IForcedProvider, ICustomMetadataProvider<T>, IHasOrder
  22. where T : BaseItem
  23. {
  24. protected BaseDynamicImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor)
  25. {
  26. ApplicationPaths = applicationPaths;
  27. ProviderManager = providerManager;
  28. FileSystem = fileSystem;
  29. ImageProcessor = imageProcessor;
  30. }
  31. protected IFileSystem FileSystem { get; }
  32. protected IProviderManager ProviderManager { get; }
  33. protected IApplicationPaths ApplicationPaths { get; }
  34. protected IImageProcessor ImageProcessor { get; set; }
  35. protected virtual IReadOnlyCollection<ImageType> SupportedImages { get; }
  36. = new ImageType[] { ImageType.Primary };
  37. /// <inheritdoc />
  38. public string Name => "Dynamic Image Provider";
  39. protected virtual int MaxImageAgeDays => 7;
  40. public int Order => 0;
  41. protected virtual bool Supports(BaseItem _) => true;
  42. public async Task<ItemUpdateType> FetchAsync(T item, MetadataRefreshOptions options, CancellationToken cancellationToken)
  43. {
  44. if (!Supports(item))
  45. {
  46. return ItemUpdateType.None;
  47. }
  48. var updateType = ItemUpdateType.None;
  49. if (SupportedImages.Contains(ImageType.Primary))
  50. {
  51. var primaryResult = await FetchAsync(item, ImageType.Primary, options, cancellationToken).ConfigureAwait(false);
  52. updateType = updateType | primaryResult;
  53. }
  54. if (SupportedImages.Contains(ImageType.Thumb))
  55. {
  56. var thumbResult = await FetchAsync(item, ImageType.Thumb, options, cancellationToken).ConfigureAwait(false);
  57. updateType = updateType | thumbResult;
  58. }
  59. return updateType;
  60. }
  61. protected Task<ItemUpdateType> FetchAsync(BaseItem item, ImageType imageType, MetadataRefreshOptions options, CancellationToken cancellationToken)
  62. {
  63. var image = item.GetImageInfo(imageType, 0);
  64. if (image != null)
  65. {
  66. if (!image.IsLocalFile)
  67. {
  68. return Task.FromResult(ItemUpdateType.None);
  69. }
  70. if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
  71. {
  72. return Task.FromResult(ItemUpdateType.None);
  73. }
  74. }
  75. var items = GetItemsWithImages(item);
  76. return FetchToFileInternal(item, items, imageType, cancellationToken);
  77. }
  78. protected async Task<ItemUpdateType> FetchToFileInternal(
  79. BaseItem item,
  80. IReadOnlyList<BaseItem> itemsWithImages,
  81. ImageType imageType,
  82. CancellationToken cancellationToken)
  83. {
  84. var outputPathWithoutExtension = Path.Combine(ApplicationPaths.TempDirectory, Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture));
  85. Directory.CreateDirectory(Path.GetDirectoryName(outputPathWithoutExtension));
  86. string outputPath = CreateImage(item, itemsWithImages, outputPathWithoutExtension, imageType, 0);
  87. if (string.IsNullOrEmpty(outputPath))
  88. {
  89. return ItemUpdateType.None;
  90. }
  91. var mimeType = MimeTypes.GetMimeType(outputPath);
  92. if (string.Equals(mimeType, "application/octet-stream", StringComparison.OrdinalIgnoreCase))
  93. {
  94. mimeType = "image/png";
  95. }
  96. await ProviderManager.SaveImage(item, outputPath, mimeType, imageType, null, false, cancellationToken).ConfigureAwait(false);
  97. return ItemUpdateType.ImageUpdate;
  98. }
  99. protected abstract IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item);
  100. protected string CreateThumbCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath)
  101. {
  102. return CreateCollage(primaryItem, items, outputPath, 640, 360);
  103. }
  104. protected virtual IEnumerable<string> GetStripCollageImagePaths(BaseItem primaryItem, IEnumerable<BaseItem> items)
  105. {
  106. var useBackdrop = primaryItem is CollectionFolder;
  107. return items
  108. .Select(i =>
  109. {
  110. // Use Backdrop instead of Primary image for Library images.
  111. if (useBackdrop)
  112. {
  113. var backdrop = i.GetImageInfo(ImageType.Backdrop, 0);
  114. if (backdrop != null && backdrop.IsLocalFile)
  115. {
  116. return backdrop.Path;
  117. }
  118. }
  119. var image = i.GetImageInfo(ImageType.Primary, 0);
  120. if (image != null && image.IsLocalFile)
  121. {
  122. return image.Path;
  123. }
  124. image = i.GetImageInfo(ImageType.Thumb, 0);
  125. if (image != null && image.IsLocalFile)
  126. {
  127. return image.Path;
  128. }
  129. return null;
  130. })
  131. .Where(i => !string.IsNullOrEmpty(i));
  132. }
  133. protected string CreatePosterCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath)
  134. {
  135. return CreateCollage(primaryItem, items, outputPath, 400, 600);
  136. }
  137. protected string CreateSquareCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath)
  138. {
  139. return CreateCollage(primaryItem, items, outputPath, 600, 600);
  140. }
  141. protected string CreateThumbCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath, int width, int height)
  142. {
  143. return CreateCollage(primaryItem, items, outputPath, width, height);
  144. }
  145. private string CreateCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath, int width, int height)
  146. {
  147. Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
  148. var options = new ImageCollageOptions
  149. {
  150. Height = height,
  151. Width = width,
  152. OutputPath = outputPath,
  153. InputPaths = GetStripCollageImagePaths(primaryItem, items).ToArray()
  154. };
  155. if (options.InputPaths.Length == 0)
  156. {
  157. return null;
  158. }
  159. if (!ImageProcessor.SupportsImageCollageCreation)
  160. {
  161. return null;
  162. }
  163. ImageProcessor.CreateImageCollage(options, primaryItem.Name);
  164. return outputPath;
  165. }
  166. protected virtual string CreateImage(
  167. BaseItem item,
  168. IReadOnlyCollection<BaseItem> itemsWithImages,
  169. string outputPathWithoutExtension,
  170. ImageType imageType,
  171. int imageIndex)
  172. {
  173. if (itemsWithImages.Count == 0)
  174. {
  175. return null;
  176. }
  177. string outputPath = Path.ChangeExtension(outputPathWithoutExtension, ".png");
  178. if (imageType == ImageType.Thumb)
  179. {
  180. return CreateThumbCollage(item, itemsWithImages, outputPath);
  181. }
  182. if (imageType == ImageType.Primary)
  183. {
  184. if (item is UserView
  185. || item is Playlist
  186. || item is MusicGenre
  187. || item is Genre
  188. || item is PhotoAlbum
  189. || item is MusicArtist)
  190. {
  191. return CreateSquareCollage(item, itemsWithImages, outputPath);
  192. }
  193. return CreatePosterCollage(item, itemsWithImages, outputPath);
  194. }
  195. throw new ArgumentException("Unexpected image type", nameof(imageType));
  196. }
  197. public bool HasChanged(BaseItem item, IDirectoryService directoryService)
  198. {
  199. if (!Supports(item))
  200. {
  201. return false;
  202. }
  203. if (SupportedImages.Contains(ImageType.Primary) && HasChanged(item, ImageType.Primary))
  204. {
  205. return true;
  206. }
  207. if (SupportedImages.Contains(ImageType.Thumb) && HasChanged(item, ImageType.Thumb))
  208. {
  209. return true;
  210. }
  211. return false;
  212. }
  213. protected bool HasChanged(BaseItem item, ImageType type)
  214. {
  215. var image = item.GetImageInfo(type, 0);
  216. if (image != null)
  217. {
  218. if (!image.IsLocalFile)
  219. {
  220. return false;
  221. }
  222. if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
  223. {
  224. return false;
  225. }
  226. if (!HasChangedByDate(item, image))
  227. {
  228. return false;
  229. }
  230. }
  231. return true;
  232. }
  233. protected virtual bool HasChangedByDate(BaseItem item, ItemImageInfo image)
  234. {
  235. var age = DateTime.UtcNow - image.DateModified;
  236. return age.TotalDays > MaxImageAgeDays;
  237. }
  238. protected string CreateSingleImage(IEnumerable<BaseItem> itemsWithImages, string outputPathWithoutExtension, ImageType imageType)
  239. {
  240. var image = itemsWithImages
  241. .Where(i => i.HasImage(imageType) && i.GetImageInfo(imageType, 0).IsLocalFile && Path.HasExtension(i.GetImagePath(imageType)))
  242. .Select(i => i.GetImagePath(imageType))
  243. .FirstOrDefault();
  244. if (string.IsNullOrEmpty(image))
  245. {
  246. return null;
  247. }
  248. var ext = Path.GetExtension(image);
  249. var outputPath = Path.ChangeExtension(outputPathWithoutExtension, ext);
  250. File.Copy(image, outputPath, true);
  251. return outputPath;
  252. }
  253. }
  254. }