move drawing code

1 files changed, 875 insertions, 0 deletions

diff --git a/Emby.Drawing/ImageProcessor.cs b/Emby.Drawing/ImageProcessor.cs
new file mode 100644
index 000000000..d78d5e8ea
--- /dev/null
+++ b/Emby.Drawing/ImageProcessor.cs
@@ -0,0 +1,875 @@
+using ImageMagickSharp;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Serialization;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Server.Implementations.Drawing
+{
+    /// <summary>
+    /// Class ImageProcessor
+    /// </summary>
+    public class ImageProcessor : IImageProcessor, IDisposable
+    {
+        /// <summary>
+        /// The us culture
+        /// </summary>
+        protected readonly CultureInfo UsCulture = new CultureInfo("en-US");
+
+        /// <summary>
+        /// The _cached imaged sizes
+        /// </summary>
+        private readonly ConcurrentDictionary<Guid, ImageSize> _cachedImagedSizes;
+
+        /// <summary>
+        /// Gets the list of currently registered image processors
+        /// Image processors are specialized metadata providers that run after the normal ones
+        /// </summary>
+        /// <value>The image enhancers.</value>
+        public IEnumerable<IImageEnhancer> ImageEnhancers { get; private set; }
+
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+
+        private readonly IFileSystem _fileSystem;
+        private readonly IJsonSerializer _jsonSerializer;
+        private readonly IServerApplicationPaths _appPaths;
+
+        public ImageProcessor(ILogger logger, IServerApplicationPaths appPaths, IFileSystem fileSystem, IJsonSerializer jsonSerializer)
+        {
+            _logger = logger;
+            _fileSystem = fileSystem;
+            _jsonSerializer = jsonSerializer;
+            _appPaths = appPaths;
+
+            _saveImageSizeTimer = new Timer(SaveImageSizeCallback, null, Timeout.Infinite, Timeout.Infinite);
+
+            Dictionary<Guid, ImageSize> sizeDictionary;
+
+            try
+            {
+                sizeDictionary = jsonSerializer.DeserializeFromFile<Dictionary<Guid, ImageSize>>(ImageSizeFile) ??
+                    new Dictionary<Guid, ImageSize>();
+            }
+            catch (FileNotFoundException)
+            {
+                // No biggie
+                sizeDictionary = new Dictionary<Guid, ImageSize>();
+            }
+            catch (DirectoryNotFoundException)
+            {
+                // No biggie
+                sizeDictionary = new Dictionary<Guid, ImageSize>();
+            }
+            catch (Exception ex)
+            {
+                logger.ErrorException("Error parsing image size cache file", ex);
+
+                sizeDictionary = new Dictionary<Guid, ImageSize>();
+            }
+
+            _cachedImagedSizes = new ConcurrentDictionary<Guid, ImageSize>(sizeDictionary);
+
+            LogImageMagickVersionVersion();
+        }
+
+        private string ResizedImageCachePath
+        {
+            get
+            {
+                return Path.Combine(_appPaths.ImageCachePath, "resized-images");
+            }
+        }
+
+        private string EnhancedImageCachePath
+        {
+            get
+            {
+                return Path.Combine(_appPaths.ImageCachePath, "enhanced-images");
+            }
+        }
+
+        private string CroppedWhitespaceImageCachePath
+        {
+            get
+            {
+                return Path.Combine(_appPaths.ImageCachePath, "cropped-images");
+            }
+        }
+
+        public void AddParts(IEnumerable<IImageEnhancer> enhancers)
+        {
+            ImageEnhancers = enhancers.ToArray();
+        }
+
+        public async Task ProcessImage(ImageProcessingOptions options, Stream toStream)
+        {
+            var file = await ProcessImage(options).ConfigureAwait(false);
+
+            using (var fileStream = _fileSystem.GetFileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read, true))
+            {
+                await fileStream.CopyToAsync(toStream).ConfigureAwait(false);
+            }
+        }
+
+        public ImageFormat[] GetSupportedImageOutputFormats()
+        {
+            if (_webpAvailable)
+            {
+                return new[] { ImageFormat.Webp, ImageFormat.Gif, ImageFormat.Jpg, ImageFormat.Png };
+            }
+            return new[] { ImageFormat.Gif, ImageFormat.Jpg, ImageFormat.Png };
+        }
+
+        private bool _webpAvailable = true;
+        private void TestWebp()
+        {
+            try
+            {
+                var tmpPath = Path.Combine(_appPaths.TempDirectory, Guid.NewGuid() + ".webp");
+                Directory.CreateDirectory(Path.GetDirectoryName(tmpPath));
+
+                using (var wand = new MagickWand(1, 1, new PixelWand("none", 1)))
+                {
+                    wand.SaveImage(tmpPath);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error loading webp: ", ex);
+                _webpAvailable = false;
+            }
+        }
+
+        private void LogImageMagickVersionVersion()
+        {
+            try
+            {
+                _logger.Info("ImageMagick version: " + Wand.VersionString);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error loading ImageMagick: ", ex);
+            }
+            TestWebp();
+        }
+
+        public async Task<string> ProcessImage(ImageProcessingOptions options)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException("options");
+            }
+
+            var originalImagePath = options.Image.Path;
+
+            if (options.HasDefaultOptions(originalImagePath) && options.Enhancers.Count == 0 && !options.CropWhiteSpace)
+            {
+                // Just spit out the original file if all the options are default
+                return originalImagePath;
+            }
+
+            var dateModified = options.Image.DateModified;
+            var length = options.Image.Length;
+
+            if (options.CropWhiteSpace)
+            {
+                var tuple = await GetWhitespaceCroppedImage(originalImagePath, dateModified, length).ConfigureAwait(false);
+
+                originalImagePath = tuple.Item1;
+                dateModified = tuple.Item2;
+                length = tuple.Item3;
+            }
+
+            if (options.Enhancers.Count > 0)
+            {
+                var tuple = await GetEnhancedImage(new ItemImageInfo
+                {
+                    Length = length,
+                    DateModified = dateModified,
+                    Type = options.Image.Type,
+                    Path = originalImagePath
+
+                }, options.Item, options.ImageIndex, options.Enhancers).ConfigureAwait(false);
+
+                originalImagePath = tuple.Item1;
+                dateModified = tuple.Item2;
+                length = tuple.Item3;
+            }
+
+            var originalImageSize = GetImageSize(originalImagePath, dateModified);
+
+            // Determine the output size based on incoming parameters
+            var newSize = DrawingUtils.Resize(originalImageSize, options.Width, options.Height, options.MaxWidth, options.MaxHeight);
+
+            if (options.HasDefaultOptionsWithoutSize(originalImagePath) && newSize.Equals(originalImageSize) && options.Enhancers.Count == 0)
+            {
+                // Just spit out the original file if the new size equals the old
+                return originalImagePath;
+            }
+
+            var quality = options.Quality ?? 90;
+
+            var outputFormat = GetOutputFormat(options.OutputFormat);
+            var cacheFilePath = GetCacheFilePath(originalImagePath, newSize, quality, dateModified, length, outputFormat, options.AddPlayedIndicator, options.PercentPlayed, options.UnplayedCount, options.BackgroundColor);
+
+            var semaphore = GetLock(cacheFilePath);
+
+            await semaphore.WaitAsync().ConfigureAwait(false);
+
+            try
+            {
+                CheckDisposed();
+
+                if (!File.Exists(cacheFilePath))
+                {
+                    var newWidth = Convert.ToInt32(newSize.Width);
+                    var newHeight = Convert.ToInt32(newSize.Height);
+
+                    Directory.CreateDirectory(Path.GetDirectoryName(cacheFilePath));
+
+                    if (string.IsNullOrWhiteSpace(options.BackgroundColor))
+                    {
+                        using (var originalImage = new MagickWand(originalImagePath))
+                        {
+                            originalImage.CurrentImage.ResizeImage(newWidth, newHeight);
+
+                            DrawIndicator(originalImage, newWidth, newHeight, options);
+
+                            originalImage.CurrentImage.CompressionQuality = quality;
+
+                            originalImage.SaveImage(cacheFilePath);
+                        }
+                    }
+                    else
+                    {
+                        using (var wand = new MagickWand(newWidth, newHeight, options.BackgroundColor))
+                        {
+                            using (var originalImage = new MagickWand(originalImagePath))
+                            {
+                                originalImage.CurrentImage.ResizeImage(newWidth, newHeight);
+
+                                wand.CurrentImage.CompositeImage(originalImage, CompositeOperator.OverCompositeOp, 0, 0);
+                                DrawIndicator(wand, newWidth, newHeight, options);
+
+                                wand.CurrentImage.CompressionQuality = quality;
+
+                                wand.SaveImage(cacheFilePath);
+                            }
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+
+            return cacheFilePath;
+        }
+
+        private ImageFormat GetOutputFormat(ImageFormat requestedFormat)
+        {
+            if (requestedFormat == ImageFormat.Webp && !_webpAvailable)
+            {
+                return ImageFormat.Png;
+            }
+
+            return requestedFormat;
+        }
+
+        /// <summary>
+        /// Draws the indicator.
+        /// </summary>
+        /// <param name="wand">The wand.</param>
+        /// <param name="imageWidth">Width of the image.</param>
+        /// <param name="imageHeight">Height of the image.</param>
+        /// <param name="options">The options.</param>
+        private void DrawIndicator(MagickWand wand, int imageWidth, int imageHeight, ImageProcessingOptions options)
+        {
+            if (!options.AddPlayedIndicator && !options.UnplayedCount.HasValue && options.PercentPlayed.Equals(0))
+            {
+                return;
+            }
+
+            try
+            {
+                if (options.AddPlayedIndicator)
+                {
+                    var currentImageSize = new ImageSize(imageWidth, imageHeight);
+
+                    new PlayedIndicatorDrawer(_appPaths).DrawPlayedIndicator(wand, currentImageSize);
+                }
+                else if (options.UnplayedCount.HasValue)
+                {
+                    var currentImageSize = new ImageSize(imageWidth, imageHeight);
+
+                    new UnplayedCountIndicator(_appPaths).DrawUnplayedCountIndicator(wand, currentImageSize, options.UnplayedCount.Value);
+                }
+
+                if (options.PercentPlayed > 0)
+                {
+                    new PercentPlayedDrawer().Process(wand, options.PercentPlayed);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error drawing indicator overlay", ex);
+            }
+        }
+
+        /// <summary>
+        /// Crops whitespace from an image, caches the result, and returns the cached path
+        /// </summary>
+        private async Task<Tuple<string, DateTime, long>> GetWhitespaceCroppedImage(string originalImagePath, DateTime dateModified, long length)
+        {
+            var name = originalImagePath;
+            name += "datemodified=" + dateModified.Ticks;
+            name += "length=" + length;
+
+            var croppedImagePath = GetCachePath(CroppedWhitespaceImageCachePath, name, Path.GetExtension(originalImagePath));
+
+            var semaphore = GetLock(croppedImagePath);
+
+            await semaphore.WaitAsync().ConfigureAwait(false);
+
+            // Check again in case of contention
+            if (File.Exists(croppedImagePath))
+            {
+                semaphore.Release();
+                return GetResult(croppedImagePath);
+            }
+
+            try
+            {
+                Directory.CreateDirectory(Path.GetDirectoryName(croppedImagePath));
+
+                using (var wand = new MagickWand(originalImagePath))
+                {
+                    wand.CurrentImage.TrimImage(10);
+                    wand.SaveImage(croppedImagePath);
+                }
+            }
+            catch (Exception ex)
+            {
+                // We have to have a catch-all here because some of the .net image methods throw a plain old Exception
+                _logger.ErrorException("Error cropping image {0}", ex, originalImagePath);
+
+                return new Tuple<string, DateTime, long>(originalImagePath, dateModified, length);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+
+            return GetResult(croppedImagePath);
+        }
+
+        private Tuple<string, DateTime, long> GetResult(string path)
+        {
+            var file = new FileInfo(path);
+
+            return new Tuple<string, DateTime, long>(path, _fileSystem.GetLastWriteTimeUtc(file), file.Length);
+        }
+
+        /// <summary>
+        /// Increment this when there's a change requiring caches to be invalidated
+        /// </summary>
+        private const string Version = "3";
+
+        /// <summary>
+        /// Gets the cache file path based on a set of parameters
+        /// </summary>
+        private string GetCacheFilePath(string originalPath, ImageSize outputSize, int quality, DateTime dateModified, long length, ImageFormat format, bool addPlayedIndicator, double percentPlayed, int? unwatchedCount, string backgroundColor)
+        {
+            var filename = originalPath;
+
+            filename += "width=" + outputSize.Width;
+
+            filename += "height=" + outputSize.Height;
+
+            filename += "quality=" + quality;
+
+            filename += "datemodified=" + dateModified.Ticks;
+            filename += "length=" + length;
+
+            filename += "f=" + format;
+
+            if (addPlayedIndicator)
+            {
+                filename += "pl=true";
+            }
+
+            if (percentPlayed > 0)
+            {
+                filename += "p=" + percentPlayed;
+            }
+
+            if (unwatchedCount.HasValue)
+            {
+                filename += "p=" + unwatchedCount.Value;
+            }
+
+            if (!string.IsNullOrEmpty(backgroundColor))
+            {
+                filename += "b=" + backgroundColor;
+            }
+
+            filename += "v=" + Version;
+
+            return GetCachePath(ResizedImageCachePath, filename, "." + format.ToString().ToLower());
+        }
+
+        /// <summary>
+        /// Gets the size of the image.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns>ImageSize.</returns>
+        public ImageSize GetImageSize(string path)
+        {
+            return GetImageSize(path, File.GetLastWriteTimeUtc(path));
+        }
+
+        public ImageSize GetImageSize(ItemImageInfo info)
+        {
+            return GetImageSize(info.Path, info.DateModified);
+        }
+
+        /// <summary>
+        /// Gets the size of the image.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="imageDateModified">The image date modified.</param>
+        /// <returns>ImageSize.</returns>
+        /// <exception cref="System.ArgumentNullException">path</exception>
+        private ImageSize GetImageSize(string path, DateTime imageDateModified)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            var name = path + "datemodified=" + imageDateModified.Ticks;
+
+            ImageSize size;
+
+            var cacheHash = name.GetMD5();
+
+            if (!_cachedImagedSizes.TryGetValue(cacheHash, out size))
+            {
+                size = GetImageSizeInternal(path);
+
+                _cachedImagedSizes.AddOrUpdate(cacheHash, size, (keyName, oldValue) => size);
+            }
+
+            return size;
+        }
+
+        /// <summary>
+        /// Gets the image size internal.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns>ImageSize.</returns>
+        private ImageSize GetImageSizeInternal(string path)
+        {
+            ImageSize size;
+
+            try
+            {
+                size = ImageHeader.GetDimensions(path, _logger, _fileSystem);
+            }
+            catch
+            {
+                _logger.Info("Failed to read image header for {0}. Doing it the slow way.", path);
+
+                CheckDisposed();
+
+                using (var wand = new MagickWand())
+                {
+                    wand.PingImage(path);
+                    var img = wand.CurrentImage;
+
+                    size = new ImageSize
+                    {
+                        Width = img.Width,
+                        Height = img.Height
+                    };
+                }
+            }
+
+            StartSaveImageSizeTimer();
+
+            return size;
+        }
+
+        private readonly Timer _saveImageSizeTimer;
+        private const int SaveImageSizeTimeout = 5000;
+        private readonly object _saveImageSizeLock = new object();
+        private void StartSaveImageSizeTimer()
+        {
+            _saveImageSizeTimer.Change(SaveImageSizeTimeout, Timeout.Infinite);
+        }
+
+        private void SaveImageSizeCallback(object state)
+        {
+            lock (_saveImageSizeLock)
+            {
+                try
+                {
+                    var path = ImageSizeFile;
+                    Directory.CreateDirectory(Path.GetDirectoryName(path));
+                    _jsonSerializer.SerializeToFile(_cachedImagedSizes, path);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error saving image size file", ex);
+                }
+            }
+        }
+
+        private string ImageSizeFile
+        {
+            get
+            {
+                return Path.Combine(_appPaths.DataPath, "imagesizes.json");
+            }
+        }
+
+        /// <summary>
+        /// Gets the image cache tag.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="image">The image.</param>
+        /// <returns>Guid.</returns>
+        /// <exception cref="System.ArgumentNullException">item</exception>
+        public string GetImageCacheTag(IHasImages item, ItemImageInfo image)
+        {
+            if (item == null)
+            {
+                throw new ArgumentNullException("item");
+            }
+
+            if (image == null)
+            {
+                throw new ArgumentNullException("image");
+            }
+
+            var supportedEnhancers = GetSupportedEnhancers(item, image.Type);
+
+            return GetImageCacheTag(item, image, supportedEnhancers.ToList());
+        }
+
+        /// <summary>
+        /// Gets the image cache tag.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="image">The image.</param>
+        /// <param name="imageEnhancers">The image enhancers.</param>
+        /// <returns>Guid.</returns>
+        /// <exception cref="System.ArgumentNullException">item</exception>
+        public string GetImageCacheTag(IHasImages item, ItemImageInfo image, List<IImageEnhancer> imageEnhancers)
+        {
+            if (item == null)
+            {
+                throw new ArgumentNullException("item");
+            }
+
+            if (imageEnhancers == null)
+            {
+                throw new ArgumentNullException("imageEnhancers");
+            }
+
+            if (image == null)
+            {
+                throw new ArgumentNullException("image");
+            }
+
+            var originalImagePath = image.Path;
+            var dateModified = image.DateModified;
+            var imageType = image.Type;
+            var length = image.Length;
+
+            // Optimization
+            if (imageEnhancers.Count == 0)
+            {
+                return (originalImagePath + dateModified.Ticks + string.Empty + length).GetMD5().ToString("N");
+            }
+
+            // Cache name is created with supported enhancers combined with the last config change so we pick up new config changes
+            var cacheKeys = imageEnhancers.Select(i => i.GetConfigurationCacheKey(item, imageType)).ToList();
+            cacheKeys.Add(originalImagePath + dateModified.Ticks + string.Empty + length);
+
+            return string.Join("|", cacheKeys.ToArray()).GetMD5().ToString("N");
+        }
+
+        /// <summary>
+        /// Gets the enhanced image.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="imageType">Type of the image.</param>
+        /// <param name="imageIndex">Index of the image.</param>
+        /// <returns>Task{System.String}.</returns>
+        public async Task<string> GetEnhancedImage(IHasImages item, ImageType imageType, int imageIndex)
+        {
+            var enhancers = GetSupportedEnhancers(item, imageType).ToList();
+
+            var imageInfo = item.GetImageInfo(imageType, imageIndex);
+
+            var result = await GetEnhancedImage(imageInfo, item, imageIndex, enhancers);
+
+            return result.Item1;
+        }
+
+        private async Task<Tuple<string, DateTime, long>> GetEnhancedImage(ItemImageInfo image,
+            IHasImages item,
+            int imageIndex,
+            List<IImageEnhancer> enhancers)
+        {
+            var originalImagePath = image.Path;
+            var dateModified = image.DateModified;
+            var imageType = image.Type;
+            var length = image.Length;
+
+            try
+            {
+                var cacheGuid = GetImageCacheTag(item, image, enhancers);
+
+                // Enhance if we have enhancers
+                var ehnancedImagePath = await GetEnhancedImageInternal(originalImagePath, item, imageType, imageIndex, enhancers, cacheGuid).ConfigureAwait(false);
+
+                // If the path changed update dateModified
+                if (!ehnancedImagePath.Equals(originalImagePath, StringComparison.OrdinalIgnoreCase))
+                {
+                    return GetResult(ehnancedImagePath);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.Error("Error enhancing image", ex);
+            }
+
+            return new Tuple<string, DateTime, long>(originalImagePath, dateModified, length);
+        }
+
+        /// <summary>
+        /// Gets the enhanced image internal.
+        /// </summary>
+        /// <param name="originalImagePath">The original image path.</param>
+        /// <param name="item">The item.</param>
+        /// <param name="imageType">Type of the image.</param>
+        /// <param name="imageIndex">Index of the image.</param>
+        /// <param name="supportedEnhancers">The supported enhancers.</param>
+        /// <param name="cacheGuid">The cache unique identifier.</param>
+        /// <returns>Task&lt;System.String&gt;.</returns>
+        /// <exception cref="ArgumentNullException">
+        /// originalImagePath
+        /// or
+        /// item
+        /// </exception>
+        private async Task<string> GetEnhancedImageInternal(string originalImagePath,
+            IHasImages item,
+            ImageType imageType,
+            int imageIndex,
+            IEnumerable<IImageEnhancer> supportedEnhancers,
+            string cacheGuid)
+        {
+            if (string.IsNullOrEmpty(originalImagePath))
+            {
+                throw new ArgumentNullException("originalImagePath");
+            }
+
+            if (item == null)
+            {
+                throw new ArgumentNullException("item");
+            }
+
+            // All enhanced images are saved as png to allow transparency
+            var enhancedImagePath = GetCachePath(EnhancedImageCachePath, cacheGuid + ".png");
+
+            var semaphore = GetLock(enhancedImagePath);
+
+            await semaphore.WaitAsync().ConfigureAwait(false);
+
+            // Check again in case of contention
+            if (File.Exists(enhancedImagePath))
+            {
+                semaphore.Release();
+                return enhancedImagePath;
+            }
+
+            try
+            {
+                Directory.CreateDirectory(Path.GetDirectoryName(enhancedImagePath));
+                await ExecuteImageEnhancers(supportedEnhancers, originalImagePath, enhancedImagePath, item, imageType, imageIndex).ConfigureAwait(false);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+
+            return enhancedImagePath;
+        }
+
+        /// <summary>
+        /// Executes the image enhancers.
+        /// </summary>
+        /// <param name="imageEnhancers">The image enhancers.</param>
+        /// <param name="inputPath">The input path.</param>
+        /// <param name="outputPath">The output path.</param>
+        /// <param name="item">The item.</param>
+        /// <param name="imageType">Type of the image.</param>
+        /// <param name="imageIndex">Index of the image.</param>
+        /// <returns>Task{EnhancedImage}.</returns>
+        private async Task ExecuteImageEnhancers(IEnumerable<IImageEnhancer> imageEnhancers, string inputPath, string outputPath, IHasImages item, ImageType imageType, int imageIndex)
+        {
+            // Run the enhancers sequentially in order of priority
+            foreach (var enhancer in imageEnhancers)
+            {
+                var typeName = enhancer.GetType().Name;
+
+                try
+                {
+                    await enhancer.EnhanceImageAsync(item, inputPath, outputPath, imageType, imageIndex).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("{0} failed enhancing {1}", ex, typeName, item.Name);
+
+                    throw;
+                }
+
+                // Feed the output into the next enhancer as input
+                inputPath = outputPath;
+            }
+        }
+
+        /// <summary>
+        /// The _semaphoreLocks
+        /// </summary>
+        private readonly ConcurrentDictionary<string, SemaphoreSlim> _semaphoreLocks = new ConcurrentDictionary<string, SemaphoreSlim>();
+
+        /// <summary>
+        /// Gets the lock.
+        /// </summary>
+        /// <param name="filename">The filename.</param>
+        /// <returns>System.Object.</returns>
+        private SemaphoreSlim GetLock(string filename)
+        {
+            return _semaphoreLocks.GetOrAdd(filename, key => new SemaphoreSlim(1, 1));
+        }
+
+        /// <summary>
+        /// Gets the cache path.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="uniqueName">Name of the unique.</param>
+        /// <param name="fileExtension">The file extension.</param>
+        /// <returns>System.String.</returns>
+        /// <exception cref="System.ArgumentNullException">
+        /// path
+        /// or
+        /// uniqueName
+        /// or
+        /// fileExtension
+        /// </exception>
+        public string GetCachePath(string path, string uniqueName, string fileExtension)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+            if (string.IsNullOrEmpty(uniqueName))
+            {
+                throw new ArgumentNullException("uniqueName");
+            }
+
+            if (string.IsNullOrEmpty(fileExtension))
+            {
+                throw new ArgumentNullException("fileExtension");
+            }
+
+            var filename = uniqueName.GetMD5() + fileExtension;
+
+            return GetCachePath(path, filename);
+        }
+
+        /// <summary>
+        /// Gets the cache path.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="filename">The filename.</param>
+        /// <returns>System.String.</returns>
+        /// <exception cref="System.ArgumentNullException">
+        /// path
+        /// or
+        /// filename
+        /// </exception>
+        public string GetCachePath(string path, string filename)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+            if (string.IsNullOrEmpty(filename))
+            {
+                throw new ArgumentNullException("filename");
+            }
+
+            var prefix = filename.Substring(0, 1);
+
+            path = Path.Combine(path, prefix);
+
+            return Path.Combine(path, filename);
+        }
+
+        public IEnumerable<IImageEnhancer> GetSupportedEnhancers(IHasImages item, ImageType imageType)
+        {
+            return ImageEnhancers.Where(i =>
+            {
+                try
+                {
+                    return i.Supports(item, imageType);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error in image enhancer: {0}", ex, i.GetType().Name);
+
+                    return false;
+                }
+
+            });
+        }
+
+        private bool _disposed;
+        public void Dispose()
+        {
+            _disposed = true;
+            Wand.CloseEnvironment();
+            _saveImageSizeTimer.Dispose();
+        }
+
+        private void CheckDisposed()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(GetType().Name);
+            }
+        }
+    }
+}