jellyfin-server/Emby.Drawing/ImageProcessor.cs

495 lines
18 KiB
C#
Raw Normal View History

using System;
2013-09-19 15:12:28 +00:00
using System.Collections.Generic;
using System.Globalization;
2013-09-18 18:49:06 +00:00
using System.IO;
2013-09-19 15:12:28 +00:00
using System.Linq;
using System.Threading.Tasks;
2020-05-13 02:10:35 +00:00
using Jellyfin.Data.Entities;
2019-01-13 19:17:02 +00:00
using MediaBrowser.Common.Extensions;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Drawing;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.MediaEncoding;
2019-01-13 19:17:02 +00:00
using MediaBrowser.Model.Drawing;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.IO;
2015-11-09 18:18:37 +00:00
using MediaBrowser.Model.Net;
2019-01-13 19:17:02 +00:00
using Microsoft.Extensions.Logging;
2020-05-13 02:10:35 +00:00
using Photo = MediaBrowser.Controller.Entities.Photo;
2013-02-21 01:33:05 +00:00
2015-04-08 14:38:02 +00:00
namespace Emby.Drawing
2013-02-21 01:33:05 +00:00
{
/// <summary>
/// Class ImageProcessor.
2013-02-21 01:33:05 +00:00
/// </summary>
public sealed class ImageProcessor : IImageProcessor, IDisposable
2013-02-21 01:33:05 +00:00
{
// Increment this when there's a change requiring caches to be invalidated
private const string Version = "3";
2013-02-21 01:33:05 +00:00
private static readonly HashSet<string> _transparentImageTypes
= new HashSet<string>(StringComparer.OrdinalIgnoreCase) { ".png", ".webp", ".gif" };
2013-02-21 01:33:05 +00:00
2020-06-06 00:15:56 +00:00
private readonly ILogger<ImageProcessor> _logger;
private readonly IFileSystem _fileSystem;
private readonly IServerApplicationPaths _appPaths;
private readonly IImageEncoder _imageEncoder;
private readonly IMediaEncoder _mediaEncoder;
2013-09-18 18:49:06 +00:00
private bool _disposed = false;
/// <summary>
/// Initializes a new instance of the <see cref="ImageProcessor"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="appPaths">The server application paths.</param>
/// <param name="fileSystem">The filesystem.</param>
/// <param name="imageEncoder">The image encoder.</param>
/// <param name="mediaEncoder">The media encoder.</param>
2019-01-12 13:46:17 +00:00
public ImageProcessor(
ILogger<ImageProcessor> logger,
2015-04-29 17:39:23 +00:00
IServerApplicationPaths appPaths,
IFileSystem fileSystem,
IImageEncoder imageEncoder,
IMediaEncoder mediaEncoder)
2013-02-21 01:33:05 +00:00
{
_logger = logger;
_fileSystem = fileSystem;
2015-04-08 14:38:02 +00:00
_imageEncoder = imageEncoder;
_mediaEncoder = mediaEncoder;
2019-01-21 01:46:40 +00:00
_appPaths = appPaths;
2015-04-08 14:38:02 +00:00
}
2014-10-27 03:06:01 +00:00
private string ResizedImageCachePath => Path.Combine(_appPaths.ImageCachePath, "resized-images");
2017-05-12 18:09:42 +00:00
/// <inheritdoc />
2019-02-06 20:31:41 +00:00
public IReadOnlyCollection<string> SupportedInputFormats =>
new HashSet<string>(StringComparer.OrdinalIgnoreCase)
2013-12-15 01:17:57 +00:00
{
"tiff",
"tif",
"jpeg",
"jpg",
"png",
"aiff",
"cr2",
"crw",
"nef",
"orf",
"pef",
"arw",
"webp",
"gif",
"bmp",
"erf",
"raf",
"rw2",
"nrw",
"dng",
"ico",
"astc",
"ktx",
"pkm",
"wbmp"
};
/// <inheritdoc />
public bool SupportsImageCollageCreation => _imageEncoder.SupportsImageCollageCreation;
/// <inheritdoc />
2013-09-19 15:12:28 +00:00
public async Task ProcessImage(ImageProcessingOptions options, Stream toStream)
2013-02-21 01:33:05 +00:00
{
2014-07-17 22:21:35 +00:00
var file = await ProcessImage(options).ConfigureAwait(false);
2020-01-08 16:52:50 +00:00
using (var fileStream = new FileStream(file.Item1, FileMode.Open, FileAccess.Read, FileShare.Read, IODefaults.FileStreamBufferSize, true))
2013-02-21 01:33:05 +00:00
{
2014-07-17 22:21:35 +00:00
await fileStream.CopyToAsync(toStream).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
}
2014-07-17 22:21:35 +00:00
}
2013-02-21 01:33:05 +00:00
/// <inheritdoc />
2019-02-06 20:31:41 +00:00
public IReadOnlyCollection<ImageFormat> GetSupportedImageOutputFormats()
=> _imageEncoder.SupportedOutputFormats;
/// <inheritdoc />
2017-09-07 18:17:18 +00:00
public bool SupportsTransparency(string path)
=> _transparentImageTypes.Contains(Path.GetExtension(path));
2017-07-25 18:32:03 +00:00
/// <inheritdoc />
2020-05-27 18:49:18 +00:00
public async Task<(string path, string? mimeType, DateTime dateModified)> ProcessImage(ImageProcessingOptions options)
2014-07-17 22:21:35 +00:00
{
2019-01-12 13:46:17 +00:00
ItemImageInfo originalImage = options.Image;
BaseItem item = options.Item;
2015-10-16 17:06:31 +00:00
2019-01-12 13:46:17 +00:00
string originalImagePath = originalImage.Path;
DateTime dateModified = originalImage.DateModified;
ImageDimensions? originalImageSize = null;
2019-01-12 13:46:17 +00:00
if (originalImage.Width > 0 && originalImage.Height > 0)
{
originalImageSize = new ImageDimensions(originalImage.Width, originalImage.Height);
2019-01-12 13:46:17 +00:00
}
2015-10-26 05:29:32 +00:00
if (!_imageEncoder.SupportsImageEncoding)
{
2019-01-12 13:46:17 +00:00
return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
}
var supportedImageInfo = await GetSupportedImage(originalImagePath, dateModified).ConfigureAwait(false);
2019-01-12 13:46:17 +00:00
originalImagePath = supportedImageInfo.path;
if (!File.Exists(originalImagePath))
{
return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
}
2019-01-12 13:46:17 +00:00
dateModified = supportedImageInfo.dateModified;
bool requiresTransparency = _transparentImageTypes.Contains(Path.GetExtension(originalImagePath));
2019-01-12 13:46:17 +00:00
bool autoOrient = false;
2017-06-09 19:24:31 +00:00
ImageOrientation? orientation = null;
2019-01-12 13:46:17 +00:00
if (item is Photo photo)
2017-06-09 19:24:31 +00:00
{
2018-09-12 17:26:21 +00:00
if (photo.Orientation.HasValue)
{
if (photo.Orientation.Value != ImageOrientation.TopLeft)
{
autoOrient = true;
orientation = photo.Orientation;
}
}
else
{
// Orientation unknown, so do it
autoOrient = true;
orientation = photo.Orientation;
}
2017-06-09 19:24:31 +00:00
}
2018-09-12 17:26:21 +00:00
if (options.HasDefaultOptions(originalImagePath, originalImageSize) && (!autoOrient || !options.RequiresAutoOrientation))
2015-11-09 18:18:37 +00:00
{
// Just spit out the original file if all the options are default
2019-01-12 13:46:17 +00:00
return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
2015-11-09 18:18:37 +00:00
}
2013-02-21 01:33:05 +00:00
ImageDimensions newSize = ImageHelper.GetNewImageSize(options, null);
2019-01-12 13:46:17 +00:00
int quality = options.Quality;
2013-02-21 01:33:05 +00:00
2019-01-12 13:46:17 +00:00
ImageFormat outputFormat = GetOutputFormat(options.SupportedOutputFormats, requiresTransparency);
string cacheFilePath = GetCacheFilePath(originalImagePath, newSize, quality, dateModified, outputFormat, options.AddPlayedIndicator, options.PercentPlayed, options.UnplayedCount, options.Blur, options.BackgroundColor, options.ForegroundLayer);
2013-02-21 01:33:05 +00:00
2013-04-03 02:59:27 +00:00
try
2013-02-21 01:33:05 +00:00
{
if (!File.Exists(cacheFilePath))
2015-03-27 04:17:04 +00:00
{
2017-07-25 18:32:03 +00:00
if (options.CropWhiteSpace && !SupportsTransparency(originalImagePath))
{
options.CropWhiteSpace = false;
}
2019-01-12 13:46:17 +00:00
string resultPath = _imageEncoder.EncodeImage(originalImagePath, dateModified, cacheFilePath, autoOrient, orientation, quality, options, outputFormat);
2017-05-17 18:18:18 +00:00
if (string.Equals(resultPath, originalImagePath, StringComparison.OrdinalIgnoreCase))
{
2019-01-12 13:46:17 +00:00
return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
2017-05-17 18:18:18 +00:00
}
2013-02-21 01:33:05 +00:00
}
2015-11-11 14:56:31 +00:00
2019-01-12 13:46:17 +00:00
return (cacheFilePath, GetMimeType(outputFormat, cacheFilePath), _fileSystem.GetLastWriteTimeUtc(cacheFilePath));
2015-11-11 14:56:31 +00:00
}
catch (Exception ex)
{
// If it fails for whatever reason, return the original image
2018-12-20 12:11:26 +00:00
_logger.LogError(ex, "Error encoding image");
2019-01-12 13:46:17 +00:00
return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
2013-02-21 01:33:05 +00:00
}
2016-07-17 16:59:40 +00:00
}
private ImageFormat GetOutputFormat(IReadOnlyCollection<ImageFormat> clientSupportedFormats, bool requiresTransparency)
2017-09-07 18:17:18 +00:00
{
var serverFormats = GetSupportedImageOutputFormats();
// Client doesn't care about format, so start with webp if supported
if (serverFormats.Contains(ImageFormat.Webp) && clientSupportedFormats.Contains(ImageFormat.Webp))
{
return ImageFormat.Webp;
}
// If transparency is needed and webp isn't supported, than png is the only option
2018-09-12 17:26:21 +00:00
if (requiresTransparency && clientSupportedFormats.Contains(ImageFormat.Png))
2017-09-07 18:17:18 +00:00
{
return ImageFormat.Png;
}
foreach (var format in clientSupportedFormats)
{
if (serverFormats.Contains(format))
{
return format;
}
}
// We should never actually get here
return ImageFormat.Jpg;
}
2020-05-27 18:49:18 +00:00
private string? GetMimeType(ImageFormat format, string path)
=> format switch
{
ImageFormat.Bmp => MimeTypes.GetMimeType("i.bmp"),
ImageFormat.Gif => MimeTypes.GetMimeType("i.gif"),
ImageFormat.Jpg => MimeTypes.GetMimeType("i.jpg"),
ImageFormat.Png => MimeTypes.GetMimeType("i.png"),
ImageFormat.Webp => MimeTypes.GetMimeType("i.webp"),
_ => MimeTypes.GetMimeType(path)
};
2015-10-28 02:30:19 +00:00
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the cache file path based on a set of parameters.
2013-02-21 01:33:05 +00:00
/// </summary>
private string GetCacheFilePath(string originalPath, ImageDimensions outputSize, int quality, DateTime dateModified, ImageFormat format, bool addPlayedIndicator, double percentPlayed, int? unwatchedCount, int? blur, string backgroundColor, string foregroundLayer)
2013-02-21 01:33:05 +00:00
{
2019-01-12 13:46:17 +00:00
var filename = originalPath
+ "width=" + outputSize.Width
+ "height=" + outputSize.Height
+ "quality=" + quality
+ "datemodified=" + dateModified.Ticks
+ "f=" + format;
2013-09-19 15:12:28 +00:00
if (addPlayedIndicator)
{
filename += "pl=true";
}
if (percentPlayed > 0)
{
filename += "p=" + percentPlayed;
2013-09-21 15:06:00 +00:00
}
if (unwatchedCount.HasValue)
{
filename += "p=" + unwatchedCount.Value;
}
2014-03-28 03:32:43 +00:00
2016-12-03 07:58:48 +00:00
if (blur.HasValue)
{
filename += "blur=" + blur.Value;
}
2013-09-21 15:06:00 +00:00
if (!string.IsNullOrEmpty(backgroundColor))
{
filename += "b=" + backgroundColor;
}
2016-02-23 19:48:58 +00:00
if (!string.IsNullOrEmpty(foregroundLayer))
{
filename += "fl=" + foregroundLayer;
}
2015-03-02 05:16:29 +00:00
filename += "v=" + Version;
2019-01-27 11:03:43 +00:00
return GetCachePath(ResizedImageCachePath, filename, "." + format.ToString().ToLowerInvariant());
2013-02-21 01:33:05 +00:00
}
/// <inheritdoc />
public ImageDimensions GetImageDimensions(BaseItem item, ItemImageInfo info)
2015-02-28 13:42:47 +00:00
{
2019-01-12 13:46:17 +00:00
int width = info.Width;
int height = info.Height;
2015-02-28 13:42:47 +00:00
2017-10-22 06:22:43 +00:00
if (height > 0 && width > 0)
{
return new ImageDimensions(width, height);
2017-10-22 06:22:43 +00:00
}
2019-01-12 13:46:17 +00:00
string path = info.Path;
_logger.LogDebug("Getting image size for item {ItemType} {Path}", item.GetType().Name, path);
2017-10-22 06:22:43 +00:00
ImageDimensions size = GetImageDimensions(path);
info.Width = size.Width;
info.Height = size.Height;
2017-10-22 06:22:43 +00:00
return size;
2015-10-16 19:25:19 +00:00
}
/// <inheritdoc />
public ImageDimensions GetImageDimensions(string path)
=> _imageEncoder.GetImageSize(path);
2013-06-04 02:02:49 +00:00
/// <inheritdoc />
public string GetImageBlurHash(string path)
{
var size = GetImageDimensions(path);
if (size.Width <= 0 || size.Height <= 0)
{
return string.Empty;
}
// We want tiles to be as close to square as possible, and to *mostly* keep under 16 tiles for performance.
// One tile is (width / xComp) x (height / yComp) pixels, which means that ideally yComp = xComp * height / width.
// See more at https://github.com/woltapp/blurhash/#how-do-i-pick-the-number-of-x-and-y-components
float xCompF = MathF.Sqrt(16.0f * size.Width / size.Height);
float yCompF = xCompF * size.Height / size.Width;
int xComp = Math.Min((int)xCompF + 1, 9);
int yComp = Math.Min((int)yCompF + 1, 9);
return _imageEncoder.GetImageBlurHash(xComp, yComp, path);
}
2020-03-23 19:05:49 +00:00
/// <inheritdoc />
2018-09-12 17:26:21 +00:00
public string GetImageCacheTag(BaseItem item, ItemImageInfo image)
=> (item.Path + image.DateModified.Ticks).GetMD5().ToString("N", CultureInfo.InvariantCulture);
2018-09-12 17:26:21 +00:00
/// <inheritdoc />
2018-09-12 17:26:21 +00:00
public string GetImageCacheTag(BaseItem item, ChapterInfo chapter)
{
return GetImageCacheTag(item, new ItemImageInfo
2013-02-21 01:33:05 +00:00
{
Path = chapter.ImagePath,
Type = ImageType.Chapter,
DateModified = chapter.ImageDateModified
});
2013-02-21 01:33:05 +00:00
}
2020-05-13 02:10:35 +00:00
/// <inheritdoc />
public string GetImageCacheTag(User user)
{
return (user.ProfileImage.Path + user.ProfileImage.LastModified.Ticks).GetMD5()
.ToString("N", CultureInfo.InvariantCulture);
}
2019-01-12 13:46:17 +00:00
private async Task<(string path, DateTime dateModified)> GetSupportedImage(string originalImagePath, DateTime dateModified)
{
2019-01-12 13:46:17 +00:00
var inputFormat = Path.GetExtension(originalImagePath)
.TrimStart('.')
.Replace("jpeg", "jpg", StringComparison.OrdinalIgnoreCase);
// These are just jpg files renamed as tbn
if (string.Equals(inputFormat, "tbn", StringComparison.OrdinalIgnoreCase))
{
2019-01-12 13:46:17 +00:00
return (originalImagePath, dateModified);
}
2019-02-06 20:31:41 +00:00
if (!_imageEncoder.SupportedInputFormats.Contains(inputFormat))
{
try
{
string filename = (originalImagePath + dateModified.Ticks.ToString(CultureInfo.InvariantCulture)).GetMD5().ToString("N", CultureInfo.InvariantCulture);
string cacheExtension = _mediaEncoder.SupportsEncoder("libwebp") ? ".webp" : ".png";
2017-09-18 17:07:50 +00:00
var outputPath = Path.Combine(_appPaths.ImageCachePath, "converted-images", filename + cacheExtension);
var file = _fileSystem.GetFileInfo(outputPath);
if (!file.Exists)
{
await _mediaEncoder.ConvertImage(originalImagePath, outputPath).ConfigureAwait(false);
dateModified = _fileSystem.GetLastWriteTimeUtc(outputPath);
}
else
{
dateModified = file.LastWriteTimeUtc;
}
originalImagePath = outputPath;
}
catch (Exception ex)
{
2019-01-12 13:46:17 +00:00
_logger.LogError(ex, "Image conversion failed for {Path}", originalImagePath);
}
}
2019-01-12 13:46:17 +00:00
return (originalImagePath, dateModified);
}
2013-09-18 18:49:06 +00:00
/// <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>
2019-01-13 20:37:13 +00:00
/// <exception cref="ArgumentNullException">
2013-09-18 18:49:06 +00:00
/// path
/// or
/// uniqueName
/// or
/// fileExtension.
2013-09-18 18:49:06 +00:00
/// </exception>
public string GetCachePath(string path, string uniqueName, string fileExtension)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
2013-09-18 18:49:06 +00:00
}
2013-09-18 18:49:06 +00:00
if (string.IsNullOrEmpty(uniqueName))
{
throw new ArgumentNullException(nameof(uniqueName));
2013-09-18 18:49:06 +00:00
}
if (string.IsNullOrEmpty(fileExtension))
{
throw new ArgumentNullException(nameof(fileExtension));
2013-09-18 18:49:06 +00:00
}
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>
2019-01-13 20:37:13 +00:00
/// <exception cref="ArgumentNullException">
2013-09-18 18:49:06 +00:00
/// path
/// or
/// filename.
2013-09-18 18:49:06 +00:00
/// </exception>
public string GetCachePath(ReadOnlySpan<char> path, ReadOnlySpan<char> filename)
2013-09-18 18:49:06 +00:00
{
if (path.IsEmpty)
2013-09-18 18:49:06 +00:00
{
throw new ArgumentException("Path can't be empty.", nameof(path));
2013-09-18 18:49:06 +00:00
}
if (path.IsEmpty)
2013-09-18 18:49:06 +00:00
{
throw new ArgumentException("Filename can't be empty.", nameof(filename));
2013-09-18 18:49:06 +00:00
}
var prefix = filename.Slice(0, 1);
2013-09-18 18:49:06 +00:00
return Path.Join(path, prefix, filename);
2013-09-18 18:49:06 +00:00
}
/// <inheritdoc />
2017-05-19 17:09:37 +00:00
public void CreateImageCollage(ImageCollageOptions options)
2015-04-08 14:38:02 +00:00
{
2019-01-12 13:46:17 +00:00
_logger.LogInformation("Creating image collage and saving to {Path}", options.OutputPath);
2016-12-02 20:10:35 +00:00
_imageEncoder.CreateImageCollage(options);
2015-05-11 16:32:15 +00:00
2019-01-12 13:46:17 +00:00
_logger.LogInformation("Completed creation of image collage and saved to {Path}", options.OutputPath);
2015-04-08 14:38:02 +00:00
}
/// <inheritdoc />
public void Dispose()
2017-12-01 17:04:32 +00:00
{
if (_disposed)
2017-12-01 17:04:32 +00:00
{
return;
2017-12-01 17:04:32 +00:00
}
2017-09-05 19:49:02 +00:00
if (_imageEncoder is IDisposable disposable)
2017-09-05 19:49:02 +00:00
{
disposable.Dispose();
}
_disposed = true;
}
2013-02-21 01:33:05 +00:00
}
2018-12-28 15:48:26 +00:00
}