ImageProcessor.cs 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887
  1. using MediaBrowser.Common.Extensions;
  2. using MediaBrowser.Controller;
  3. using MediaBrowser.Controller.Drawing;
  4. using MediaBrowser.Controller.Entities;
  5. using MediaBrowser.Controller.Providers;
  6. using MediaBrowser.Model.Drawing;
  7. using MediaBrowser.Model.Entities;
  8. using MediaBrowser.Model.Logging;
  9. using MediaBrowser.Model.Serialization;
  10. using System;
  11. using System.Collections.Concurrent;
  12. using System.Collections.Generic;
  13. using System.Globalization;
  14. using System.IO;
  15. using System.Linq;
  16. using System.Threading;
  17. using System.Threading.Tasks;
  18. using MediaBrowser.Model.IO;
  19. using Emby.Drawing.Common;
  20. using MediaBrowser.Controller.IO;
  21. using MediaBrowser.Controller.Library;
  22. using MediaBrowser.Model.Net;
  23. using MediaBrowser.Model.Threading;
  24. using TagLib;
  25. namespace Emby.Drawing
  26. {
  27. /// <summary>
  28. /// Class ImageProcessor
  29. /// </summary>
  30. public class ImageProcessor : IImageProcessor, IDisposable
  31. {
  32. /// <summary>
  33. /// The us culture
  34. /// </summary>
  35. protected readonly CultureInfo UsCulture = new CultureInfo("en-US");
  36. /// <summary>
  37. /// The _cached imaged sizes
  38. /// </summary>
  39. private readonly ConcurrentDictionary<Guid, ImageSize> _cachedImagedSizes;
  40. /// <summary>
  41. /// Gets the list of currently registered image processors
  42. /// Image processors are specialized metadata providers that run after the normal ones
  43. /// </summary>
  44. /// <value>The image enhancers.</value>
  45. public IEnumerable<IImageEnhancer> ImageEnhancers { get; private set; }
  46. /// <summary>
  47. /// The _logger
  48. /// </summary>
  49. private readonly ILogger _logger;
  50. private readonly IFileSystem _fileSystem;
  51. private readonly IJsonSerializer _jsonSerializer;
  52. private readonly IServerApplicationPaths _appPaths;
  53. private IImageEncoder _imageEncoder;
  54. private readonly Func<ILibraryManager> _libraryManager;
  55. public ImageProcessor(ILogger logger,
  56. IServerApplicationPaths appPaths,
  57. IFileSystem fileSystem,
  58. IJsonSerializer jsonSerializer,
  59. IImageEncoder imageEncoder,
  60. Func<ILibraryManager> libraryManager, ITimerFactory timerFactory)
  61. {
  62. _logger = logger;
  63. _fileSystem = fileSystem;
  64. _jsonSerializer = jsonSerializer;
  65. _imageEncoder = imageEncoder;
  66. _libraryManager = libraryManager;
  67. _appPaths = appPaths;
  68. ImageEnhancers = new List<IImageEnhancer>();
  69. _saveImageSizeTimer = timerFactory.Create(SaveImageSizeCallback, null, Timeout.Infinite, Timeout.Infinite);
  70. ImageHelper.ImageProcessor = this;
  71. Dictionary<Guid, ImageSize> sizeDictionary;
  72. try
  73. {
  74. sizeDictionary = jsonSerializer.DeserializeFromFile<Dictionary<Guid, ImageSize>>(ImageSizeFile) ??
  75. new Dictionary<Guid, ImageSize>();
  76. }
  77. catch (FileNotFoundException)
  78. {
  79. // No biggie
  80. sizeDictionary = new Dictionary<Guid, ImageSize>();
  81. }
  82. catch (IOException)
  83. {
  84. // No biggie
  85. sizeDictionary = new Dictionary<Guid, ImageSize>();
  86. }
  87. catch (Exception ex)
  88. {
  89. logger.ErrorException("Error parsing image size cache file", ex);
  90. sizeDictionary = new Dictionary<Guid, ImageSize>();
  91. }
  92. _cachedImagedSizes = new ConcurrentDictionary<Guid, ImageSize>(sizeDictionary);
  93. }
  94. public IImageEncoder ImageEncoder
  95. {
  96. get { return _imageEncoder; }
  97. set
  98. {
  99. if (value == null)
  100. {
  101. throw new ArgumentNullException("value");
  102. }
  103. _imageEncoder = value;
  104. }
  105. }
  106. public string[] SupportedInputFormats
  107. {
  108. get
  109. {
  110. return _imageEncoder.SupportedInputFormats;
  111. }
  112. }
  113. public bool SupportsImageCollageCreation
  114. {
  115. get
  116. {
  117. return _imageEncoder.SupportsImageCollageCreation;
  118. }
  119. }
  120. private string ResizedImageCachePath
  121. {
  122. get
  123. {
  124. return Path.Combine(_appPaths.ImageCachePath, "resized-images");
  125. }
  126. }
  127. private string EnhancedImageCachePath
  128. {
  129. get
  130. {
  131. return Path.Combine(_appPaths.ImageCachePath, "enhanced-images");
  132. }
  133. }
  134. public void AddParts(IEnumerable<IImageEnhancer> enhancers)
  135. {
  136. ImageEnhancers = enhancers.ToArray();
  137. }
  138. public async Task ProcessImage(ImageProcessingOptions options, Stream toStream)
  139. {
  140. var file = await ProcessImage(options).ConfigureAwait(false);
  141. using (var fileStream = _fileSystem.GetFileStream(file.Item1, FileOpenMode.Open, FileAccessMode.Read, FileShareMode.Read, true))
  142. {
  143. await fileStream.CopyToAsync(toStream).ConfigureAwait(false);
  144. }
  145. }
  146. public ImageFormat[] GetSupportedImageOutputFormats()
  147. {
  148. return _imageEncoder.SupportedOutputFormats;
  149. }
  150. public async Task<Tuple<string, string, DateTime>> ProcessImage(ImageProcessingOptions options)
  151. {
  152. if (options == null)
  153. {
  154. throw new ArgumentNullException("options");
  155. }
  156. var originalImage = options.Image;
  157. IHasImages item = options.Item;
  158. if (!originalImage.IsLocalFile)
  159. {
  160. if (item == null)
  161. {
  162. item = _libraryManager().GetItemById(options.ItemId);
  163. }
  164. originalImage = await _libraryManager().ConvertImageToLocal(item, originalImage, options.ImageIndex).ConfigureAwait(false);
  165. }
  166. var originalImagePath = originalImage.Path;
  167. var dateModified = originalImage.DateModified;
  168. if (!_imageEncoder.SupportsImageEncoding)
  169. {
  170. return new Tuple<string, string, DateTime>(originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
  171. }
  172. if (options.Enhancers.Count > 0)
  173. {
  174. if (item == null)
  175. {
  176. item = _libraryManager().GetItemById(options.ItemId);
  177. }
  178. var tuple = await GetEnhancedImage(new ItemImageInfo
  179. {
  180. DateModified = dateModified,
  181. Type = originalImage.Type,
  182. Path = originalImagePath
  183. }, item, options.ImageIndex, options.Enhancers).ConfigureAwait(false);
  184. originalImagePath = tuple.Item1;
  185. dateModified = tuple.Item2;
  186. }
  187. var photo = item as Photo;
  188. var autoOrient = false;
  189. ImageOrientation? orientation = null;
  190. if (photo != null && photo.Orientation.HasValue && photo.Orientation.Value != ImageOrientation.TopLeft)
  191. {
  192. autoOrient = true;
  193. orientation = photo.Orientation;
  194. }
  195. if (options.HasDefaultOptions(originalImagePath) && !autoOrient)
  196. {
  197. // Just spit out the original file if all the options are default
  198. return new Tuple<string, string, DateTime>(originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
  199. }
  200. ImageSize? originalImageSize = GetSavedImageSize(originalImagePath, dateModified);
  201. if (originalImageSize.HasValue && options.HasDefaultOptions(originalImagePath, originalImageSize.Value) && !autoOrient)
  202. {
  203. // Just spit out the original file if all the options are default
  204. _logger.Info("Returning original image {0}", originalImagePath);
  205. return new Tuple<string, string, DateTime>(originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
  206. }
  207. var newSize = ImageHelper.GetNewImageSize(options, originalImageSize);
  208. var quality = options.Quality;
  209. var outputFormat = GetOutputFormat(options.SupportedOutputFormats[0]);
  210. var cacheFilePath = GetCacheFilePath(originalImagePath, newSize, quality, dateModified, outputFormat, options.AddPlayedIndicator, options.PercentPlayed, options.UnplayedCount, options.Blur, options.BackgroundColor, options.ForegroundLayer);
  211. try
  212. {
  213. CheckDisposed();
  214. if (!_fileSystem.FileExists(cacheFilePath))
  215. {
  216. var tmpPath = Path.ChangeExtension(Path.Combine(_appPaths.TempDirectory, Guid.NewGuid().ToString("N")), Path.GetExtension(cacheFilePath));
  217. _fileSystem.CreateDirectory(_fileSystem.GetDirectoryName(tmpPath));
  218. if (item == null && string.Equals(options.ItemType, typeof(Photo).Name, StringComparison.OrdinalIgnoreCase))
  219. {
  220. item = _libraryManager().GetItemById(options.ItemId);
  221. }
  222. var resultPath = _imageEncoder.EncodeImage(originalImagePath, dateModified, tmpPath, autoOrient, orientation, quality, options, outputFormat);
  223. if (string.Equals(resultPath, originalImagePath, StringComparison.OrdinalIgnoreCase))
  224. {
  225. return new Tuple<string, string, DateTime>(originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
  226. }
  227. _fileSystem.CreateDirectory(_fileSystem.GetDirectoryName(cacheFilePath));
  228. CopyFile(tmpPath, cacheFilePath);
  229. return new Tuple<string, string, DateTime>(tmpPath, GetMimeType(outputFormat, cacheFilePath), _fileSystem.GetLastWriteTimeUtc(tmpPath));
  230. }
  231. return new Tuple<string, string, DateTime>(cacheFilePath, GetMimeType(outputFormat, cacheFilePath), _fileSystem.GetLastWriteTimeUtc(cacheFilePath));
  232. }
  233. catch (Exception ex)
  234. {
  235. // If it fails for whatever reason, return the original image
  236. _logger.ErrorException("Error encoding image", ex);
  237. // Just spit out the original file if all the options are default
  238. return new Tuple<string, string, DateTime>(originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
  239. }
  240. }
  241. private void CopyFile(string src, string destination)
  242. {
  243. try
  244. {
  245. _fileSystem.CopyFile(src, destination, true);
  246. }
  247. catch
  248. {
  249. }
  250. }
  251. //private static int[][] OPERATIONS = new int[][] {
  252. // TopLeft
  253. //new int[] { 0, NONE},
  254. // TopRight
  255. //new int[] { 0, HORIZONTAL},
  256. //new int[] {180, NONE},
  257. // LeftTop
  258. //new int[] { 0, VERTICAL},
  259. //new int[] { 90, HORIZONTAL},
  260. // RightTop
  261. //new int[] { 90, NONE},
  262. //new int[] {-90, HORIZONTAL},
  263. //new int[] {-90, NONE},
  264. //};
  265. private string GetMimeType(ImageFormat format, string path)
  266. {
  267. if (format == ImageFormat.Bmp)
  268. {
  269. return MimeTypes.GetMimeType("i.bmp");
  270. }
  271. if (format == ImageFormat.Gif)
  272. {
  273. return MimeTypes.GetMimeType("i.gif");
  274. }
  275. if (format == ImageFormat.Jpg)
  276. {
  277. return MimeTypes.GetMimeType("i.jpg");
  278. }
  279. if (format == ImageFormat.Png)
  280. {
  281. return MimeTypes.GetMimeType("i.png");
  282. }
  283. if (format == ImageFormat.Webp)
  284. {
  285. return MimeTypes.GetMimeType("i.webp");
  286. }
  287. return MimeTypes.GetMimeType(path);
  288. }
  289. private ImageFormat GetOutputFormat(ImageFormat requestedFormat)
  290. {
  291. if (requestedFormat == ImageFormat.Webp && !_imageEncoder.SupportedOutputFormats.Contains(ImageFormat.Webp))
  292. {
  293. return ImageFormat.Png;
  294. }
  295. return requestedFormat;
  296. }
  297. private Tuple<string, DateTime> GetResult(string path)
  298. {
  299. return new Tuple<string, DateTime>(path, _fileSystem.GetLastWriteTimeUtc(path));
  300. }
  301. /// <summary>
  302. /// Increment this when there's a change requiring caches to be invalidated
  303. /// </summary>
  304. private const string Version = "3";
  305. /// <summary>
  306. /// Gets the cache file path based on a set of parameters
  307. /// </summary>
  308. private string GetCacheFilePath(string originalPath, ImageSize outputSize, int quality, DateTime dateModified, ImageFormat format, bool addPlayedIndicator, double percentPlayed, int? unwatchedCount, int? blur, string backgroundColor, string foregroundLayer)
  309. {
  310. var filename = originalPath;
  311. filename += "width=" + outputSize.Width;
  312. filename += "height=" + outputSize.Height;
  313. filename += "quality=" + quality;
  314. filename += "datemodified=" + dateModified.Ticks;
  315. filename += "f=" + format;
  316. if (addPlayedIndicator)
  317. {
  318. filename += "pl=true";
  319. }
  320. if (percentPlayed > 0)
  321. {
  322. filename += "p=" + percentPlayed;
  323. }
  324. if (unwatchedCount.HasValue)
  325. {
  326. filename += "p=" + unwatchedCount.Value;
  327. }
  328. if (blur.HasValue)
  329. {
  330. filename += "blur=" + blur.Value;
  331. }
  332. if (!string.IsNullOrEmpty(backgroundColor))
  333. {
  334. filename += "b=" + backgroundColor;
  335. }
  336. if (!string.IsNullOrEmpty(foregroundLayer))
  337. {
  338. filename += "fl=" + foregroundLayer;
  339. }
  340. filename += "v=" + Version;
  341. return GetCachePath(ResizedImageCachePath, filename, "." + format.ToString().ToLower());
  342. }
  343. public ImageSize GetImageSize(ItemImageInfo info)
  344. {
  345. return GetImageSize(info.Path, info.DateModified, false);
  346. }
  347. public ImageSize GetImageSize(string path)
  348. {
  349. return GetImageSize(path, _fileSystem.GetLastWriteTimeUtc(path), false);
  350. }
  351. /// <summary>
  352. /// Gets the size of the image.
  353. /// </summary>
  354. /// <param name="path">The path.</param>
  355. /// <param name="imageDateModified">The image date modified.</param>
  356. /// <param name="allowSlowMethod">if set to <c>true</c> [allow slow method].</param>
  357. /// <returns>ImageSize.</returns>
  358. /// <exception cref="System.ArgumentNullException">path</exception>
  359. private ImageSize GetImageSize(string path, DateTime imageDateModified, bool allowSlowMethod)
  360. {
  361. if (string.IsNullOrEmpty(path))
  362. {
  363. throw new ArgumentNullException("path");
  364. }
  365. ImageSize size;
  366. var cacheHash = GetImageSizeKey(path, imageDateModified);
  367. if (!_cachedImagedSizes.TryGetValue(cacheHash, out size))
  368. {
  369. size = GetImageSizeInternal(path, allowSlowMethod);
  370. SaveImageSize(size, cacheHash, false);
  371. }
  372. return size;
  373. }
  374. public void SaveImageSize(string path, DateTime imageDateModified, ImageSize size)
  375. {
  376. var cacheHash = GetImageSizeKey(path, imageDateModified);
  377. SaveImageSize(size, cacheHash, true);
  378. }
  379. private void SaveImageSize(ImageSize size, Guid cacheHash, bool checkExists)
  380. {
  381. if (size.Width <= 0 || size.Height <= 0)
  382. {
  383. return;
  384. }
  385. if (checkExists && _cachedImagedSizes.ContainsKey(cacheHash))
  386. {
  387. return;
  388. }
  389. if (checkExists)
  390. {
  391. if (_cachedImagedSizes.TryAdd(cacheHash, size))
  392. {
  393. StartSaveImageSizeTimer();
  394. }
  395. }
  396. else
  397. {
  398. StartSaveImageSizeTimer();
  399. _cachedImagedSizes.AddOrUpdate(cacheHash, size, (keyName, oldValue) => size);
  400. }
  401. }
  402. private Guid GetImageSizeKey(string path, DateTime imageDateModified)
  403. {
  404. var name = path + "datemodified=" + imageDateModified.Ticks;
  405. return name.GetMD5();
  406. }
  407. public ImageSize? GetSavedImageSize(string path, DateTime imageDateModified)
  408. {
  409. ImageSize size;
  410. var cacheHash = GetImageSizeKey(path, imageDateModified);
  411. if (_cachedImagedSizes.TryGetValue(cacheHash, out size))
  412. {
  413. return size;
  414. }
  415. return null;
  416. }
  417. /// <summary>
  418. /// Gets the image size internal.
  419. /// </summary>
  420. /// <param name="path">The path.</param>
  421. /// <param name="allowSlowMethod">if set to <c>true</c> [allow slow method].</param>
  422. /// <returns>ImageSize.</returns>
  423. private ImageSize GetImageSizeInternal(string path, bool allowSlowMethod)
  424. {
  425. //try
  426. //{
  427. // using (var fileStream = _fileSystem.OpenRead(path))
  428. // {
  429. // using (var file = TagLib.File.Create(new StreamFileAbstraction(Path.GetFileName(path), fileStream, null)))
  430. // {
  431. // var image = file as TagLib.Image.File;
  432. // if (image != null)
  433. // {
  434. // var properties = image.Properties;
  435. // return new ImageSize
  436. // {
  437. // Height = properties.PhotoHeight,
  438. // Width = properties.PhotoWidth
  439. // };
  440. // }
  441. // }
  442. // }
  443. //}
  444. //catch
  445. //{
  446. //}
  447. try
  448. {
  449. return ImageHeader.GetDimensions(path, _logger, _fileSystem);
  450. }
  451. catch
  452. {
  453. if (allowSlowMethod)
  454. {
  455. return _imageEncoder.GetImageSize(path);
  456. }
  457. throw;
  458. }
  459. }
  460. private readonly ITimer _saveImageSizeTimer;
  461. private const int SaveImageSizeTimeout = 5000;
  462. private readonly object _saveImageSizeLock = new object();
  463. private void StartSaveImageSizeTimer()
  464. {
  465. _saveImageSizeTimer.Change(SaveImageSizeTimeout, Timeout.Infinite);
  466. }
  467. private void SaveImageSizeCallback(object state)
  468. {
  469. lock (_saveImageSizeLock)
  470. {
  471. try
  472. {
  473. var path = ImageSizeFile;
  474. _fileSystem.CreateDirectory(_fileSystem.GetDirectoryName(path));
  475. _jsonSerializer.SerializeToFile(_cachedImagedSizes, path);
  476. }
  477. catch (Exception ex)
  478. {
  479. _logger.ErrorException("Error saving image size file", ex);
  480. }
  481. }
  482. }
  483. private string ImageSizeFile
  484. {
  485. get
  486. {
  487. return Path.Combine(_appPaths.DataPath, "imagesizes.json");
  488. }
  489. }
  490. /// <summary>
  491. /// Gets the image cache tag.
  492. /// </summary>
  493. /// <param name="item">The item.</param>
  494. /// <param name="image">The image.</param>
  495. /// <returns>Guid.</returns>
  496. /// <exception cref="System.ArgumentNullException">item</exception>
  497. public string GetImageCacheTag(IHasImages item, ItemImageInfo image)
  498. {
  499. if (item == null)
  500. {
  501. throw new ArgumentNullException("item");
  502. }
  503. if (image == null)
  504. {
  505. throw new ArgumentNullException("image");
  506. }
  507. var supportedEnhancers = GetSupportedEnhancers(item, image.Type);
  508. return GetImageCacheTag(item, image, supportedEnhancers.ToList());
  509. }
  510. /// <summary>
  511. /// Gets the image cache tag.
  512. /// </summary>
  513. /// <param name="item">The item.</param>
  514. /// <param name="image">The image.</param>
  515. /// <param name="imageEnhancers">The image enhancers.</param>
  516. /// <returns>Guid.</returns>
  517. /// <exception cref="System.ArgumentNullException">item</exception>
  518. public string GetImageCacheTag(IHasImages item, ItemImageInfo image, List<IImageEnhancer> imageEnhancers)
  519. {
  520. if (item == null)
  521. {
  522. throw new ArgumentNullException("item");
  523. }
  524. if (imageEnhancers == null)
  525. {
  526. throw new ArgumentNullException("imageEnhancers");
  527. }
  528. if (image == null)
  529. {
  530. throw new ArgumentNullException("image");
  531. }
  532. var originalImagePath = image.Path;
  533. var dateModified = image.DateModified;
  534. var imageType = image.Type;
  535. // Optimization
  536. if (imageEnhancers.Count == 0)
  537. {
  538. return (originalImagePath + dateModified.Ticks).GetMD5().ToString("N");
  539. }
  540. // Cache name is created with supported enhancers combined with the last config change so we pick up new config changes
  541. var cacheKeys = imageEnhancers.Select(i => i.GetConfigurationCacheKey(item, imageType)).ToList();
  542. cacheKeys.Add(originalImagePath + dateModified.Ticks);
  543. return string.Join("|", cacheKeys.ToArray()).GetMD5().ToString("N");
  544. }
  545. /// <summary>
  546. /// Gets the enhanced image.
  547. /// </summary>
  548. /// <param name="item">The item.</param>
  549. /// <param name="imageType">Type of the image.</param>
  550. /// <param name="imageIndex">Index of the image.</param>
  551. /// <returns>Task{System.String}.</returns>
  552. public async Task<string> GetEnhancedImage(IHasImages item, ImageType imageType, int imageIndex)
  553. {
  554. var enhancers = GetSupportedEnhancers(item, imageType).ToList();
  555. var imageInfo = item.GetImageInfo(imageType, imageIndex);
  556. var result = await GetEnhancedImage(imageInfo, item, imageIndex, enhancers);
  557. return result.Item1;
  558. }
  559. private async Task<Tuple<string, DateTime>> GetEnhancedImage(ItemImageInfo image,
  560. IHasImages item,
  561. int imageIndex,
  562. List<IImageEnhancer> enhancers)
  563. {
  564. var originalImagePath = image.Path;
  565. var dateModified = image.DateModified;
  566. var imageType = image.Type;
  567. try
  568. {
  569. var cacheGuid = GetImageCacheTag(item, image, enhancers);
  570. // Enhance if we have enhancers
  571. var ehnancedImagePath = await GetEnhancedImageInternal(originalImagePath, item, imageType, imageIndex, enhancers, cacheGuid).ConfigureAwait(false);
  572. // If the path changed update dateModified
  573. if (!string.Equals(ehnancedImagePath, originalImagePath, StringComparison.OrdinalIgnoreCase))
  574. {
  575. return GetResult(ehnancedImagePath);
  576. }
  577. }
  578. catch (Exception ex)
  579. {
  580. _logger.Error("Error enhancing image", ex);
  581. }
  582. return new Tuple<string, DateTime>(originalImagePath, dateModified);
  583. }
  584. /// <summary>
  585. /// Gets the enhanced image internal.
  586. /// </summary>
  587. /// <param name="originalImagePath">The original image path.</param>
  588. /// <param name="item">The item.</param>
  589. /// <param name="imageType">Type of the image.</param>
  590. /// <param name="imageIndex">Index of the image.</param>
  591. /// <param name="supportedEnhancers">The supported enhancers.</param>
  592. /// <param name="cacheGuid">The cache unique identifier.</param>
  593. /// <returns>Task&lt;System.String&gt;.</returns>
  594. /// <exception cref="ArgumentNullException">
  595. /// originalImagePath
  596. /// or
  597. /// item
  598. /// </exception>
  599. private async Task<string> GetEnhancedImageInternal(string originalImagePath,
  600. IHasImages item,
  601. ImageType imageType,
  602. int imageIndex,
  603. IEnumerable<IImageEnhancer> supportedEnhancers,
  604. string cacheGuid)
  605. {
  606. if (string.IsNullOrEmpty(originalImagePath))
  607. {
  608. throw new ArgumentNullException("originalImagePath");
  609. }
  610. if (item == null)
  611. {
  612. throw new ArgumentNullException("item");
  613. }
  614. // All enhanced images are saved as png to allow transparency
  615. var enhancedImagePath = GetCachePath(EnhancedImageCachePath, cacheGuid + ".png");
  616. // Check again in case of contention
  617. if (_fileSystem.FileExists(enhancedImagePath))
  618. {
  619. return enhancedImagePath;
  620. }
  621. _fileSystem.CreateDirectory(_fileSystem.GetDirectoryName(enhancedImagePath));
  622. var tmpPath = Path.Combine(_appPaths.TempDirectory, Path.ChangeExtension(Guid.NewGuid().ToString(), Path.GetExtension(enhancedImagePath)));
  623. _fileSystem.CreateDirectory(_fileSystem.GetDirectoryName(tmpPath));
  624. await ExecuteImageEnhancers(supportedEnhancers, originalImagePath, tmpPath, item, imageType, imageIndex).ConfigureAwait(false);
  625. try
  626. {
  627. _fileSystem.CopyFile(tmpPath, enhancedImagePath, true);
  628. }
  629. catch
  630. {
  631. }
  632. return tmpPath;
  633. }
  634. /// <summary>
  635. /// Executes the image enhancers.
  636. /// </summary>
  637. /// <param name="imageEnhancers">The image enhancers.</param>
  638. /// <param name="inputPath">The input path.</param>
  639. /// <param name="outputPath">The output path.</param>
  640. /// <param name="item">The item.</param>
  641. /// <param name="imageType">Type of the image.</param>
  642. /// <param name="imageIndex">Index of the image.</param>
  643. /// <returns>Task{EnhancedImage}.</returns>
  644. private async Task ExecuteImageEnhancers(IEnumerable<IImageEnhancer> imageEnhancers, string inputPath, string outputPath, IHasImages item, ImageType imageType, int imageIndex)
  645. {
  646. // Run the enhancers sequentially in order of priority
  647. foreach (var enhancer in imageEnhancers)
  648. {
  649. await enhancer.EnhanceImageAsync(item, inputPath, outputPath, imageType, imageIndex).ConfigureAwait(false);
  650. // Feed the output into the next enhancer as input
  651. inputPath = outputPath;
  652. }
  653. }
  654. /// <summary>
  655. /// Gets the cache path.
  656. /// </summary>
  657. /// <param name="path">The path.</param>
  658. /// <param name="uniqueName">Name of the unique.</param>
  659. /// <param name="fileExtension">The file extension.</param>
  660. /// <returns>System.String.</returns>
  661. /// <exception cref="System.ArgumentNullException">
  662. /// path
  663. /// or
  664. /// uniqueName
  665. /// or
  666. /// fileExtension
  667. /// </exception>
  668. public string GetCachePath(string path, string uniqueName, string fileExtension)
  669. {
  670. if (string.IsNullOrEmpty(path))
  671. {
  672. throw new ArgumentNullException("path");
  673. }
  674. if (string.IsNullOrEmpty(uniqueName))
  675. {
  676. throw new ArgumentNullException("uniqueName");
  677. }
  678. if (string.IsNullOrEmpty(fileExtension))
  679. {
  680. throw new ArgumentNullException("fileExtension");
  681. }
  682. var filename = uniqueName.GetMD5() + fileExtension;
  683. return GetCachePath(path, filename);
  684. }
  685. /// <summary>
  686. /// Gets the cache path.
  687. /// </summary>
  688. /// <param name="path">The path.</param>
  689. /// <param name="filename">The filename.</param>
  690. /// <returns>System.String.</returns>
  691. /// <exception cref="System.ArgumentNullException">
  692. /// path
  693. /// or
  694. /// filename
  695. /// </exception>
  696. public string GetCachePath(string path, string filename)
  697. {
  698. if (string.IsNullOrEmpty(path))
  699. {
  700. throw new ArgumentNullException("path");
  701. }
  702. if (string.IsNullOrEmpty(filename))
  703. {
  704. throw new ArgumentNullException("filename");
  705. }
  706. var prefix = filename.Substring(0, 1);
  707. path = Path.Combine(path, prefix);
  708. return Path.Combine(path, filename);
  709. }
  710. public void CreateImageCollage(ImageCollageOptions options)
  711. {
  712. _logger.Info("Creating image collage and saving to {0}", options.OutputPath);
  713. _imageEncoder.CreateImageCollage(options);
  714. _logger.Info("Completed creation of image collage and saved to {0}", options.OutputPath);
  715. }
  716. public IEnumerable<IImageEnhancer> GetSupportedEnhancers(IHasImages item, ImageType imageType)
  717. {
  718. return ImageEnhancers.Where(i =>
  719. {
  720. try
  721. {
  722. return i.Supports(item, imageType);
  723. }
  724. catch (Exception ex)
  725. {
  726. _logger.ErrorException("Error in image enhancer: {0}", ex, i.GetType().Name);
  727. return false;
  728. }
  729. });
  730. }
  731. private bool _disposed;
  732. public void Dispose()
  733. {
  734. _disposed = true;
  735. _imageEncoder.Dispose();
  736. _saveImageSizeTimer.Dispose();
  737. }
  738. private void CheckDisposed()
  739. {
  740. if (_disposed)
  741. {
  742. throw new ObjectDisposedException(GetType().Name);
  743. }
  744. }
  745. }
  746. }