move drawing code

7 files changed, 1314 insertions, 1 deletions

diff --git a/Emby.Drawing/Emby.Drawing.csproj b/Emby.Drawing/Emby.Drawing.csproj
index 4b72fef15f..7e833eeeb5 100644
--- a/Emby.Drawing/Emby.Drawing.csproj
+++ b/Emby.Drawing/Emby.Drawing.csproj
@@ -11,6 +11,8 @@
     <AssemblyName>Emby.Drawing</AssemblyName>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
+    <RestorePackages>true</RestorePackages>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -30,6 +32,9 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="ImageMagickSharp">
+      <HintPath>..\packages\ImageMagickSharp.1.0.0.13\lib\net45\ImageMagickSharp.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Drawing" />
@@ -43,11 +48,21 @@
     <Compile Include="..\SharedVersion.cs">
       <Link>Properties\SharedVersion.cs</Link>
     </Compile>
+    <Compile Include="ImageHeader.cs" />
+    <Compile Include="ImageProcessor.cs" />
+    <Compile Include="PercentPlayedDrawer.cs" />
+    <Compile Include="PlayedIndicatorDrawer.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UnplayedCountIndicator.cs" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="GDI\" />
-    <Folder Include="ImageMagick\" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="ImageMagick\fonts\MontserratLight.otf" />
+    <EmbeddedResource Include="ImageMagick\fonts\robotoregular.ttf" />
+    <EmbeddedResource Include="ImageMagick\fonts\webdings.ttf" />
+    <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Emby.Drawing/ImageHeader.cs b/Emby.Drawing/ImageHeader.cs
new file mode 100644
index 0000000000..7117482c8a
--- /dev/null
+++ b/Emby.Drawing/ImageHeader.cs
@@ -0,0 +1,223 @@
+using MediaBrowser.Common.IO;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace MediaBrowser.Server.Implementations.Drawing
+{
+    /// <summary>
+    /// Taken from http://stackoverflow.com/questions/111345/getting-image-dimensions-without-reading-the-entire-file/111349
+    /// http://www.codeproject.com/Articles/35978/Reading-Image-Headers-to-Get-Width-and-Height
+    /// Minor improvements including supporting unsigned 16-bit integers when decoding Jfif and added logic
+    /// to load the image using new Bitmap if reading the headers fails
+    /// </summary>
+    public static class ImageHeader
+    {
+        /// <summary>
+        /// The error message
+        /// </summary>
+        const string ErrorMessage = "Could not recognize image format.";
+
+        /// <summary>
+        /// The image format decoders
+        /// </summary>
+        private static readonly KeyValuePair<byte[], Func<BinaryReader, ImageSize>>[] ImageFormatDecoders = new Dictionary<byte[], Func<BinaryReader, ImageSize>>
+        { 
+            { new byte[] { 0x42, 0x4D }, DecodeBitmap }, 
+            { new byte[] { 0x47, 0x49, 0x46, 0x38, 0x37, 0x61 }, DecodeGif }, 
+            { new byte[] { 0x47, 0x49, 0x46, 0x38, 0x39, 0x61 }, DecodeGif }, 
+            { new byte[] { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A }, DecodePng },
+            { new byte[] { 0xff, 0xd8 }, DecodeJfif }
+
+        }.ToArray();
+
+        private static readonly int MaxMagicBytesLength = ImageFormatDecoders.Select(i => i.Key.Length).OrderByDescending(i => i).First();
+
+        /// <summary>
+        /// Gets the dimensions of an image.
+        /// </summary>
+        /// <param name="path">The path of the image to get the dimensions of.</param>
+        /// <param name="logger">The logger.</param>
+        /// <param name="fileSystem">The file system.</param>
+        /// <returns>The dimensions of the specified image.</returns>
+        /// <exception cref="ArgumentException">The image was of an unrecognised format.</exception>
+        public static ImageSize GetDimensions(string path, ILogger logger, IFileSystem fileSystem)
+        {
+            using (var fs = File.OpenRead(path))
+            {
+                using (var binaryReader = new BinaryReader(fs))
+                {
+                    return GetDimensions(binaryReader);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the dimensions of an image.
+        /// </summary>
+        /// <param name="binaryReader">The binary reader.</param>
+        /// <returns>Size.</returns>
+        /// <exception cref="System.ArgumentException">binaryReader</exception>
+        /// <exception cref="ArgumentException">The image was of an unrecognized format.</exception>
+        private static ImageSize GetDimensions(BinaryReader binaryReader)
+        {
+            var magicBytes = new byte[MaxMagicBytesLength];
+
+            for (var i = 0; i < MaxMagicBytesLength; i += 1)
+            {
+                magicBytes[i] = binaryReader.ReadByte();
+
+                foreach (var kvPair in ImageFormatDecoders)
+                {
+                    if (StartsWith(magicBytes, kvPair.Key))
+                    {
+                        return kvPair.Value(binaryReader);
+                    }
+                }
+            }
+
+            throw new ArgumentException(ErrorMessage, "binaryReader");
+        }
+
+        /// <summary>
+        /// Startses the with.
+        /// </summary>
+        /// <param name="thisBytes">The this bytes.</param>
+        /// <param name="thatBytes">The that bytes.</param>
+        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
+        private static bool StartsWith(byte[] thisBytes, byte[] thatBytes)
+        {
+            for (int i = 0; i < thatBytes.Length; i += 1)
+            {
+                if (thisBytes[i] != thatBytes[i])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Reads the little endian int16.
+        /// </summary>
+        /// <param name="binaryReader">The binary reader.</param>
+        /// <returns>System.Int16.</returns>
+        private static short ReadLittleEndianInt16(BinaryReader binaryReader)
+        {
+            var bytes = new byte[sizeof(short)];
+
+            for (int i = 0; i < sizeof(short); i += 1)
+            {
+                bytes[sizeof(short) - 1 - i] = binaryReader.ReadByte();
+            }
+            return BitConverter.ToInt16(bytes, 0);
+        }
+
+        /// <summary>
+        /// Reads the little endian int32.
+        /// </summary>
+        /// <param name="binaryReader">The binary reader.</param>
+        /// <returns>System.Int32.</returns>
+        private static int ReadLittleEndianInt32(BinaryReader binaryReader)
+        {
+            var bytes = new byte[sizeof(int)];
+            for (int i = 0; i < sizeof(int); i += 1)
+            {
+                bytes[sizeof(int) - 1 - i] = binaryReader.ReadByte();
+            }
+            return BitConverter.ToInt32(bytes, 0);
+        }
+
+        /// <summary>
+        /// Decodes the bitmap.
+        /// </summary>
+        /// <param name="binaryReader">The binary reader.</param>
+        /// <returns>Size.</returns>
+        private static ImageSize DecodeBitmap(BinaryReader binaryReader)
+        {
+            binaryReader.ReadBytes(16);
+            int width = binaryReader.ReadInt32();
+            int height = binaryReader.ReadInt32();
+            return new ImageSize
+            {
+                Width = width,
+                Height = height
+            };
+        }
+
+        /// <summary>
+        /// Decodes the GIF.
+        /// </summary>
+        /// <param name="binaryReader">The binary reader.</param>
+        /// <returns>Size.</returns>
+        private static ImageSize DecodeGif(BinaryReader binaryReader)
+        {
+            int width = binaryReader.ReadInt16();
+            int height = binaryReader.ReadInt16();
+            return new ImageSize
+            {
+                Width = width,
+                Height = height
+            };
+        }
+
+        /// <summary>
+        /// Decodes the PNG.
+        /// </summary>
+        /// <param name="binaryReader">The binary reader.</param>
+        /// <returns>Size.</returns>
+        private static ImageSize DecodePng(BinaryReader binaryReader)
+        {
+            binaryReader.ReadBytes(8);
+            int width = ReadLittleEndianInt32(binaryReader);
+            int height = ReadLittleEndianInt32(binaryReader);
+            return new ImageSize
+            {
+                Width = width,
+                Height = height
+            };
+        }
+
+        /// <summary>
+        /// Decodes the jfif.
+        /// </summary>
+        /// <param name="binaryReader">The binary reader.</param>
+        /// <returns>Size.</returns>
+        /// <exception cref="System.ArgumentException"></exception>
+        private static ImageSize DecodeJfif(BinaryReader binaryReader)
+        {
+            while (binaryReader.ReadByte() == 0xff)
+            {
+                byte marker = binaryReader.ReadByte();
+                short chunkLength = ReadLittleEndianInt16(binaryReader);
+                if (marker == 0xc0)
+                {
+                    binaryReader.ReadByte();
+                    int height = ReadLittleEndianInt16(binaryReader);
+                    int width = ReadLittleEndianInt16(binaryReader);
+                    return new ImageSize
+                    {
+                        Width = width,
+                        Height = height
+                    };
+                }
+
+                if (chunkLength < 0)
+                {
+                    var uchunkLength = (ushort)chunkLength;
+                    binaryReader.ReadBytes(uchunkLength - 2);
+                }
+                else
+                {
+                    binaryReader.ReadBytes(chunkLength - 2);
+                }
+            }
+
+            throw new ArgumentException(ErrorMessage);
+        }
+    }
+}
diff --git a/Emby.Drawing/ImageProcessor.cs b/Emby.Drawing/ImageProcessor.cs
new file mode 100644
index 0000000000..d78d5e8ea1
--- /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);
+            }
+        }
+    }
+}
diff --git a/Emby.Drawing/PercentPlayedDrawer.cs b/Emby.Drawing/PercentPlayedDrawer.cs
new file mode 100644
index 0000000000..20c2ab93be
--- /dev/null
+++ b/Emby.Drawing/PercentPlayedDrawer.cs
@@ -0,0 +1,40 @@
+using ImageMagickSharp;
+using System;
+
+namespace MediaBrowser.Server.Implementations.Drawing
+{
+    public class PercentPlayedDrawer
+    {
+        private const int IndicatorHeight = 8;
+
+        public void Process(MagickWand wand, double percent)
+        {
+            var currentImage = wand.CurrentImage;
+            var height = currentImage.Height;
+
+            using (var draw = new DrawingWand())
+            {
+                using (PixelWand pixel = new PixelWand())
+                {
+                    var endX = currentImage.Width - 1;
+                    var endY = height - 1;
+
+                    pixel.Color = "black";
+                    pixel.Opacity = 0.4;
+                    draw.FillColor = pixel;
+                    draw.DrawRectangle(0, endY - IndicatorHeight, endX, endY);
+
+                    double foregroundWidth = endX;
+                    foregroundWidth *= percent;
+                    foregroundWidth /= 100;
+
+                    pixel.Color = "#52B54B";
+                    pixel.Opacity = 0;
+                    draw.FillColor = pixel;
+                    draw.DrawRectangle(0, endY - IndicatorHeight, Convert.ToInt32(Math.Round(foregroundWidth)), endY);
+                    wand.CurrentImage.DrawImage(draw);
+                }
+            }
+        }
+    }
+}
diff --git a/Emby.Drawing/PlayedIndicatorDrawer.cs b/Emby.Drawing/PlayedIndicatorDrawer.cs
new file mode 100644
index 0000000000..359065cc2e
--- /dev/null
+++ b/Emby.Drawing/PlayedIndicatorDrawer.cs
@@ -0,0 +1,86 @@
+using ImageMagickSharp;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Model.Drawing;
+using System;
+using System.IO;
+
+namespace MediaBrowser.Server.Implementations.Drawing
+{
+    public class PlayedIndicatorDrawer
+    {
+        private const int FontSize = 52;
+        private const int OffsetFromTopRightCorner = 38;
+
+        private readonly IApplicationPaths _appPaths;
+
+        public PlayedIndicatorDrawer(IApplicationPaths appPaths)
+        {
+            _appPaths = appPaths;
+        }
+
+        public void DrawPlayedIndicator(MagickWand wand, ImageSize imageSize)
+        {
+            var x = imageSize.Width - OffsetFromTopRightCorner;
+
+            using (var draw = new DrawingWand())
+            {
+                using (PixelWand pixel = new PixelWand())
+                {
+                    pixel.Color = "#52B54B";
+                    pixel.Opacity = 0.2;
+                    draw.FillColor = pixel;
+                    draw.DrawCircle(x, OffsetFromTopRightCorner, x - 20, OffsetFromTopRightCorner - 20);
+
+                    pixel.Opacity = 0;
+                    pixel.Color = "white";
+                    draw.FillColor = pixel;
+                    draw.Font = ExtractFont("webdings.ttf", _appPaths);
+                    draw.FontSize = FontSize;
+                    draw.FontStyle = FontStyleType.NormalStyle;
+                    draw.TextAlignment = TextAlignType.CenterAlign;
+                    draw.FontWeight = FontWeightType.RegularStyle;
+                    draw.TextAntialias = true;
+                    draw.DrawAnnotation(x + 4, OffsetFromTopRightCorner + 14, "a");
+
+                    draw.FillColor = pixel;
+                    wand.CurrentImage.DrawImage(draw);
+                }
+            }
+        }
+
+        internal static string ExtractFont(string name, IApplicationPaths paths)
+        {
+            var filePath = Path.Combine(paths.ProgramDataPath, "fonts", name);
+
+            if (File.Exists(filePath))
+            {
+                return filePath;
+            }
+
+            var namespacePath = typeof(PlayedIndicatorDrawer).Namespace + ".fonts." + name;
+            var tempPath = Path.Combine(paths.TempDirectory, Guid.NewGuid().ToString("N") + ".ttf");
+            Directory.CreateDirectory(Path.GetDirectoryName(tempPath));
+
+            using (var stream = typeof(PlayedIndicatorDrawer).Assembly.GetManifestResourceStream(namespacePath))
+            {
+                using (var fileStream = new FileStream(tempPath, FileMode.Create, FileAccess.Write, FileShare.Read))
+                {
+                    stream.CopyTo(fileStream);
+                }
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(filePath));
+
+            try
+            {
+                File.Copy(tempPath, filePath, false);
+            }
+            catch (IOException)
+            {
+                
+            }
+
+            return tempPath;
+        }
+    }
+}
diff --git a/Emby.Drawing/UnplayedCountIndicator.cs b/Emby.Drawing/UnplayedCountIndicator.cs
new file mode 100644
index 0000000000..71cced0416
--- /dev/null
+++ b/Emby.Drawing/UnplayedCountIndicator.cs
@@ -0,0 +1,70 @@
+using ImageMagickSharp;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Model.Drawing;
+using System.Globalization;
+
+namespace MediaBrowser.Server.Implementations.Drawing
+{
+    public class UnplayedCountIndicator
+    {
+        private const int OffsetFromTopRightCorner = 38;
+
+        private readonly IApplicationPaths _appPaths;
+
+        public UnplayedCountIndicator(IApplicationPaths appPaths)
+        {
+            _appPaths = appPaths;
+        }
+
+        public void DrawUnplayedCountIndicator(MagickWand wand, ImageSize imageSize, int count)
+        {
+            var x = imageSize.Width - OffsetFromTopRightCorner;
+            var text = count.ToString(CultureInfo.InvariantCulture);
+
+            using (var draw = new DrawingWand())
+            {
+                using (PixelWand pixel = new PixelWand())
+                {
+                    pixel.Color = "#52B54B";
+                    pixel.Opacity = 0.2;
+                    draw.FillColor = pixel;
+                    draw.DrawCircle(x, OffsetFromTopRightCorner, x - 20, OffsetFromTopRightCorner - 20);
+
+                    pixel.Opacity = 0;
+                    pixel.Color = "white";
+                    draw.FillColor = pixel;
+                    draw.Font = PlayedIndicatorDrawer.ExtractFont("robotoregular.ttf", _appPaths);
+                    draw.FontStyle = FontStyleType.NormalStyle;
+                    draw.TextAlignment = TextAlignType.CenterAlign;
+                    draw.FontWeight = FontWeightType.RegularStyle;
+                    draw.TextAntialias = true;
+
+                    var fontSize = 30;
+                    var y = OffsetFromTopRightCorner + 11;
+
+                    if (text.Length == 1)
+                    {
+                        x += 1;
+                    }
+                    else if (text.Length == 2)
+                    {
+                        x += 1;
+                    }
+                    else if (text.Length >= 3)
+                    {
+                        //x += 1;
+                        y -= 2;
+                        fontSize = 24;
+                    }
+
+                    draw.FontSize = fontSize;
+                    draw.DrawAnnotation(x, y, text);
+
+                    draw.FillColor = pixel;
+                    wand.CurrentImage.DrawImage(draw);
+                }
+
+            }
+        }
+    }
+}
diff --git a/Emby.Drawing/packages.config b/Emby.Drawing/packages.config
new file mode 100644
index 0000000000..f1efe6e1c8
--- /dev/null
+++ b/Emby.Drawing/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="ImageMagickSharp" version="1.0.0.13" targetFramework="net45" />
+</packages>
\ No newline at end of file