From 78e96917e12abb963301957607da4a738f27df58 Mon Sep 17 00:00:00 2001 From: Luke Pulverenti Date: Wed, 8 Apr 2015 08:37:07 -0400 Subject: move drawing code --- Emby.Drawing/ImageProcessor.cs | 875 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 875 insertions(+) create mode 100644 Emby.Drawing/ImageProcessor.cs (limited to 'Emby.Drawing/ImageProcessor.cs') 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 +{ + /// + /// Class ImageProcessor + /// + public class ImageProcessor : IImageProcessor, IDisposable + { + /// + /// The us culture + /// + protected readonly CultureInfo UsCulture = new CultureInfo("en-US"); + + /// + /// The _cached imaged sizes + /// + private readonly ConcurrentDictionary _cachedImagedSizes; + + /// + /// Gets the list of currently registered image processors + /// Image processors are specialized metadata providers that run after the normal ones + /// + /// The image enhancers. + public IEnumerable ImageEnhancers { get; private set; } + + /// + /// The _logger + /// + 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 sizeDictionary; + + try + { + sizeDictionary = jsonSerializer.DeserializeFromFile>(ImageSizeFile) ?? + new Dictionary(); + } + catch (FileNotFoundException) + { + // No biggie + sizeDictionary = new Dictionary(); + } + catch (DirectoryNotFoundException) + { + // No biggie + sizeDictionary = new Dictionary(); + } + catch (Exception ex) + { + logger.ErrorException("Error parsing image size cache file", ex); + + sizeDictionary = new Dictionary(); + } + + _cachedImagedSizes = new ConcurrentDictionary(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 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 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; + } + + /// + /// Draws the indicator. + /// + /// The wand. + /// Width of the image. + /// Height of the image. + /// The options. + 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); + } + } + + /// + /// Crops whitespace from an image, caches the result, and returns the cached path + /// + private async Task> 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(originalImagePath, dateModified, length); + } + finally + { + semaphore.Release(); + } + + return GetResult(croppedImagePath); + } + + private Tuple GetResult(string path) + { + var file = new FileInfo(path); + + return new Tuple(path, _fileSystem.GetLastWriteTimeUtc(file), file.Length); + } + + /// + /// Increment this when there's a change requiring caches to be invalidated + /// + private const string Version = "3"; + + /// + /// Gets the cache file path based on a set of parameters + /// + 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()); + } + + /// + /// Gets the size of the image. + /// + /// The path. + /// ImageSize. + public ImageSize GetImageSize(string path) + { + return GetImageSize(path, File.GetLastWriteTimeUtc(path)); + } + + public ImageSize GetImageSize(ItemImageInfo info) + { + return GetImageSize(info.Path, info.DateModified); + } + + /// + /// Gets the size of the image. + /// + /// The path. + /// The image date modified. + /// ImageSize. + /// path + 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; + } + + /// + /// Gets the image size internal. + /// + /// The path. + /// ImageSize. + 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"); + } + } + + /// + /// Gets the image cache tag. + /// + /// The item. + /// The image. + /// Guid. + /// item + 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()); + } + + /// + /// Gets the image cache tag. + /// + /// The item. + /// The image. + /// The image enhancers. + /// Guid. + /// item + public string GetImageCacheTag(IHasImages item, ItemImageInfo image, List 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"); + } + + /// + /// Gets the enhanced image. + /// + /// The item. + /// Type of the image. + /// Index of the image. + /// Task{System.String}. + public async Task 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> GetEnhancedImage(ItemImageInfo image, + IHasImages item, + int imageIndex, + List 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(originalImagePath, dateModified, length); + } + + /// + /// Gets the enhanced image internal. + /// + /// The original image path. + /// The item. + /// Type of the image. + /// Index of the image. + /// The supported enhancers. + /// The cache unique identifier. + /// Task<System.String>. + /// + /// originalImagePath + /// or + /// item + /// + private async Task GetEnhancedImageInternal(string originalImagePath, + IHasImages item, + ImageType imageType, + int imageIndex, + IEnumerable 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; + } + + /// + /// Executes the image enhancers. + /// + /// The image enhancers. + /// The input path. + /// The output path. + /// The item. + /// Type of the image. + /// Index of the image. + /// Task{EnhancedImage}. + private async Task ExecuteImageEnhancers(IEnumerable 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; + } + } + + /// + /// The _semaphoreLocks + /// + private readonly ConcurrentDictionary _semaphoreLocks = new ConcurrentDictionary(); + + /// + /// Gets the lock. + /// + /// The filename. + /// System.Object. + private SemaphoreSlim GetLock(string filename) + { + return _semaphoreLocks.GetOrAdd(filename, key => new SemaphoreSlim(1, 1)); + } + + /// + /// Gets the cache path. + /// + /// The path. + /// Name of the unique. + /// The file extension. + /// System.String. + /// + /// path + /// or + /// uniqueName + /// or + /// fileExtension + /// + 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); + } + + /// + /// Gets the cache path. + /// + /// The path. + /// The filename. + /// System.String. + /// + /// path + /// or + /// filename + /// + 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 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); + } + } + } +} -- cgit v1.2.3 From 4820fe80971c83cde97a445e45b9e0b1952b0d90 Mon Sep 17 00:00:00 2001 From: Luke Pulverenti Date: Wed, 8 Apr 2015 10:38:02 -0400 Subject: added drawing project --- Emby.Drawing/Common/ImageHeader.cs | 223 +++++++++ Emby.Drawing/Emby.Drawing.csproj | 34 +- Emby.Drawing/GDI/GDIImageEncoder.cs | 233 +++++++++ Emby.Drawing/GDI/ImageExtensions.cs | 217 +++++++++ Emby.Drawing/GDI/PercentPlayedDrawer.cs | 34 ++ Emby.Drawing/GDI/PlayedIndicatorDrawer.cs | 32 ++ Emby.Drawing/GDI/UnplayedCountIndicator.cs | 50 ++ Emby.Drawing/IImageEncoder.cs | 48 ++ Emby.Drawing/ImageHeader.cs | 223 --------- Emby.Drawing/ImageMagick/ImageMagickEncoder.cs | 224 +++++++++ Emby.Drawing/ImageMagick/PercentPlayedDrawer.cs | 40 ++ Emby.Drawing/ImageMagick/PlayedIndicatorDrawer.cs | 86 ++++ Emby.Drawing/ImageMagick/StripCollageBuilder.cs | 518 +++++++++++++++++++++ Emby.Drawing/ImageMagick/UnplayedCountIndicator.cs | 70 +++ Emby.Drawing/ImageProcessor.cs | 153 +----- Emby.Drawing/PercentPlayedDrawer.cs | 40 -- Emby.Drawing/PlayedIndicatorDrawer.cs | 86 ---- Emby.Drawing/UnplayedCountIndicator.cs | 70 --- MediaBrowser.Controller/Drawing/IImageProcessor.cs | 12 + .../Drawing/ImageCollageOptions.cs | 32 ++ .../MediaBrowser.Controller.csproj | 1 + .../Collections/CollectionImageProvider.cs | 3 +- .../Library/Resolvers/PhotoAlbumResolver.cs | 13 +- .../Library/Resolvers/PhotoResolver.cs | 18 +- .../MediaBrowser.Server.Implementations.csproj | 2 - .../Photos/BaseDynamicImageProvider.cs | 63 ++- .../Photos/DynamicImageHelpers.cs | 132 ------ .../Photos/PhotoAlbumImageProvider.cs | 3 +- .../Playlists/PlaylistImageProvider.cs | 3 +- .../UserViews/DynamicImageProvider.cs | 20 +- .../UserViews/StripCollageBuilder.cs | 512 -------------------- .../ApplicationHost.cs | 25 +- MediaBrowser.ServerApplication/MainStartup.cs | 1 - 33 files changed, 1972 insertions(+), 1249 deletions(-) create mode 100644 Emby.Drawing/Common/ImageHeader.cs create mode 100644 Emby.Drawing/GDI/GDIImageEncoder.cs create mode 100644 Emby.Drawing/GDI/ImageExtensions.cs create mode 100644 Emby.Drawing/GDI/PercentPlayedDrawer.cs create mode 100644 Emby.Drawing/GDI/PlayedIndicatorDrawer.cs create mode 100644 Emby.Drawing/GDI/UnplayedCountIndicator.cs create mode 100644 Emby.Drawing/IImageEncoder.cs delete mode 100644 Emby.Drawing/ImageHeader.cs create mode 100644 Emby.Drawing/ImageMagick/ImageMagickEncoder.cs create mode 100644 Emby.Drawing/ImageMagick/PercentPlayedDrawer.cs create mode 100644 Emby.Drawing/ImageMagick/PlayedIndicatorDrawer.cs create mode 100644 Emby.Drawing/ImageMagick/StripCollageBuilder.cs create mode 100644 Emby.Drawing/ImageMagick/UnplayedCountIndicator.cs delete mode 100644 Emby.Drawing/PercentPlayedDrawer.cs delete mode 100644 Emby.Drawing/PlayedIndicatorDrawer.cs delete mode 100644 Emby.Drawing/UnplayedCountIndicator.cs create mode 100644 MediaBrowser.Controller/Drawing/ImageCollageOptions.cs delete mode 100644 MediaBrowser.Server.Implementations/Photos/DynamicImageHelpers.cs delete mode 100644 MediaBrowser.Server.Implementations/UserViews/StripCollageBuilder.cs (limited to 'Emby.Drawing/ImageProcessor.cs') diff --git a/Emby.Drawing/Common/ImageHeader.cs b/Emby.Drawing/Common/ImageHeader.cs new file mode 100644 index 0000000000..b66bd71ea5 --- /dev/null +++ b/Emby.Drawing/Common/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 Emby.Drawing.Common +{ + /// + /// 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 + /// + public static class ImageHeader + { + /// + /// The error message + /// + const string ErrorMessage = "Could not recognize image format."; + + /// + /// The image format decoders + /// + private static readonly KeyValuePair>[] ImageFormatDecoders = new Dictionary> + { + { 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(); + + /// + /// Gets the dimensions of an image. + /// + /// The path of the image to get the dimensions of. + /// The logger. + /// The file system. + /// The dimensions of the specified image. + /// The image was of an unrecognised format. + 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); + } + } + } + + /// + /// Gets the dimensions of an image. + /// + /// The binary reader. + /// Size. + /// binaryReader + /// The image was of an unrecognized format. + 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"); + } + + /// + /// Startses the with. + /// + /// The this bytes. + /// The that bytes. + /// true if XXXX, false otherwise + 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; + } + + /// + /// Reads the little endian int16. + /// + /// The binary reader. + /// System.Int16. + 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); + } + + /// + /// Reads the little endian int32. + /// + /// The binary reader. + /// System.Int32. + 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); + } + + /// + /// Decodes the bitmap. + /// + /// The binary reader. + /// Size. + private static ImageSize DecodeBitmap(BinaryReader binaryReader) + { + binaryReader.ReadBytes(16); + int width = binaryReader.ReadInt32(); + int height = binaryReader.ReadInt32(); + return new ImageSize + { + Width = width, + Height = height + }; + } + + /// + /// Decodes the GIF. + /// + /// The binary reader. + /// Size. + private static ImageSize DecodeGif(BinaryReader binaryReader) + { + int width = binaryReader.ReadInt16(); + int height = binaryReader.ReadInt16(); + return new ImageSize + { + Width = width, + Height = height + }; + } + + /// + /// Decodes the PNG. + /// + /// The binary reader. + /// Size. + private static ImageSize DecodePng(BinaryReader binaryReader) + { + binaryReader.ReadBytes(8); + int width = ReadLittleEndianInt32(binaryReader); + int height = ReadLittleEndianInt32(binaryReader); + return new ImageSize + { + Width = width, + Height = height + }; + } + + /// + /// Decodes the jfif. + /// + /// The binary reader. + /// Size. + /// + 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/Emby.Drawing.csproj b/Emby.Drawing/Emby.Drawing.csproj index 7e833eeeb5..1907381e9c 100644 --- a/Emby.Drawing/Emby.Drawing.csproj +++ b/Emby.Drawing/Emby.Drawing.csproj @@ -48,22 +48,42 @@ Properties\SharedVersion.cs - + + + + + + + + + - - + + - - - - + + + + + {9142eefa-7570-41e1-bfcc-468bb571af2f} + MediaBrowser.Common + + + {17e1f4e6-8abd-4fe5-9ecf-43d4b6087ba2} + MediaBrowser.Controller + + + {7eeeb4bb-f3e8-48fc-b4c5-70f0fff8329b} + MediaBrowser.Model + +