2019-01-13 14:54:44 -05:00
|
|
|
using System;
|
2013-09-19 11:12:28 -04:00
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.Globalization;
|
2013-09-18 14:49:06 -04:00
|
|
|
using System.IO;
|
2013-09-19 11:12:28 -04:00
|
|
|
using System.Linq;
|
2022-01-03 14:23:55 -05:00
|
|
|
using System.Net.Mime;
|
2021-03-28 18:48:59 -04:00
|
|
|
using System.Text;
|
2013-09-19 11:12:28 -04:00
|
|
|
using System.Threading.Tasks;
|
2020-05-12 22:10:35 -04:00
|
|
|
using Jellyfin.Data.Entities;
|
2019-01-13 14:17:02 -05:00
|
|
|
using MediaBrowser.Common.Extensions;
|
|
|
|
using MediaBrowser.Controller;
|
|
|
|
using MediaBrowser.Controller.Drawing;
|
|
|
|
using MediaBrowser.Controller.Entities;
|
2017-08-26 02:18:52 -04:00
|
|
|
using MediaBrowser.Controller.MediaEncoding;
|
2019-01-13 14:17:02 -05:00
|
|
|
using MediaBrowser.Model.Drawing;
|
|
|
|
using MediaBrowser.Model.Entities;
|
|
|
|
using MediaBrowser.Model.IO;
|
2015-11-09 13:18:37 -05:00
|
|
|
using MediaBrowser.Model.Net;
|
2019-01-13 14:17:02 -05:00
|
|
|
using Microsoft.Extensions.Logging;
|
2020-05-12 22:10:35 -04:00
|
|
|
using Photo = MediaBrowser.Controller.Entities.Photo;
|
2013-02-20 20:33:05 -05:00
|
|
|
|
2015-04-08 10:38:02 -04:00
|
|
|
namespace Emby.Drawing
|
2013-02-20 20:33:05 -05:00
|
|
|
{
|
|
|
|
/// <summary>
|
2019-08-11 10:52:37 -04:00
|
|
|
/// Class ImageProcessor.
|
2013-02-20 20:33:05 -05:00
|
|
|
/// </summary>
|
2020-01-21 14:26:30 -05:00
|
|
|
public sealed class ImageProcessor : IImageProcessor, IDisposable
|
2013-02-20 20:33:05 -05:00
|
|
|
{
|
2019-08-11 10:52:37 -04:00
|
|
|
// Increment this when there's a change requiring caches to be invalidated
|
2021-11-08 14:39:02 -05:00
|
|
|
private const char Version = '3';
|
2013-02-20 20:33:05 -05:00
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
private static readonly HashSet<string> _transparentImageTypes
|
|
|
|
= new HashSet<string>(StringComparer.OrdinalIgnoreCase) { ".png", ".webp", ".gif" };
|
2013-02-20 20:33:05 -05:00
|
|
|
|
2020-06-05 20:15:56 -04:00
|
|
|
private readonly ILogger<ImageProcessor> _logger;
|
2013-10-31 10:03:23 -04:00
|
|
|
private readonly IFileSystem _fileSystem;
|
2013-11-07 10:57:12 -05:00
|
|
|
private readonly IServerApplicationPaths _appPaths;
|
2020-01-21 14:26:30 -05:00
|
|
|
private readonly IImageEncoder _imageEncoder;
|
2020-04-04 17:12:24 -04:00
|
|
|
private readonly IMediaEncoder _mediaEncoder;
|
2013-09-18 14:49:06 -04:00
|
|
|
|
2020-08-21 13:53:55 -04:00
|
|
|
private bool _disposed;
|
2019-08-11 10:52:37 -04:00
|
|
|
|
|
|
|
/// <summary>
|
2020-01-21 14:26:30 -05:00
|
|
|
/// Initializes a new instance of the <see cref="ImageProcessor"/> class.
|
2019-08-11 10:52:37 -04:00
|
|
|
/// </summary>
|
2020-01-21 14:26:30 -05:00
|
|
|
/// <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 08:46:17 -05:00
|
|
|
public ImageProcessor(
|
2019-08-11 10:52:37 -04:00
|
|
|
ILogger<ImageProcessor> logger,
|
2015-04-29 13:39:23 -04:00
|
|
|
IServerApplicationPaths appPaths,
|
|
|
|
IFileSystem fileSystem,
|
|
|
|
IImageEncoder imageEncoder,
|
2020-04-04 17:12:24 -04:00
|
|
|
IMediaEncoder mediaEncoder)
|
2013-02-20 20:33:05 -05:00
|
|
|
{
|
2019-08-11 10:52:37 -04:00
|
|
|
_logger = logger;
|
2013-10-31 10:03:23 -04:00
|
|
|
_fileSystem = fileSystem;
|
2015-04-08 10:38:02 -04:00
|
|
|
_imageEncoder = imageEncoder;
|
2017-08-26 02:18:52 -04:00
|
|
|
_mediaEncoder = mediaEncoder;
|
2019-01-20 20:46:40 -05:00
|
|
|
_appPaths = appPaths;
|
2015-04-08 10:38:02 -04:00
|
|
|
}
|
2014-10-26 23:06:01 -04:00
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
private string ResizedImageCachePath => Path.Combine(_appPaths.ImageCachePath, "resized-images");
|
2017-05-12 14:09:42 -04:00
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2019-02-06 15:31:41 -05:00
|
|
|
public IReadOnlyCollection<string> SupportedInputFormats =>
|
|
|
|
new HashSet<string>(StringComparer.OrdinalIgnoreCase)
|
2013-12-14 20:17:57 -05:00
|
|
|
{
|
2019-01-13 15:31:14 -05:00
|
|
|
"tiff",
|
|
|
|
"tif",
|
|
|
|
"jpeg",
|
|
|
|
"jpg",
|
|
|
|
"png",
|
|
|
|
"aiff",
|
|
|
|
"cr2",
|
|
|
|
"crw",
|
2020-01-21 14:26:30 -05:00
|
|
|
"nef",
|
2019-01-13 15:31:14 -05:00
|
|
|
"orf",
|
|
|
|
"pef",
|
|
|
|
"arw",
|
|
|
|
"webp",
|
|
|
|
"gif",
|
|
|
|
"bmp",
|
|
|
|
"erf",
|
|
|
|
"raf",
|
|
|
|
"rw2",
|
|
|
|
"nrw",
|
|
|
|
"dng",
|
|
|
|
"ico",
|
|
|
|
"astc",
|
|
|
|
"ktx",
|
|
|
|
"pkm",
|
|
|
|
"wbmp"
|
|
|
|
};
|
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2019-01-13 15:31:14 -05:00
|
|
|
public bool SupportsImageCollageCreation => _imageEncoder.SupportsImageCollageCreation;
|
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2013-09-19 11:12:28 -04:00
|
|
|
public async Task ProcessImage(ImageProcessingOptions options, Stream toStream)
|
2013-02-20 20:33:05 -05:00
|
|
|
{
|
2014-07-17 18:21:35 -04:00
|
|
|
var file = await ProcessImage(options).ConfigureAwait(false);
|
2021-12-24 16:18:24 -05:00
|
|
|
using (var fileStream = AsyncFile.OpenRead(file.Path))
|
2013-02-20 20:33:05 -05:00
|
|
|
{
|
2014-07-17 18:21:35 -04:00
|
|
|
await fileStream.CopyToAsync(toStream).ConfigureAwait(false);
|
2013-02-20 20:33:05 -05:00
|
|
|
}
|
2014-07-17 18:21:35 -04:00
|
|
|
}
|
2013-02-20 20:33:05 -05:00
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2019-02-06 15:31:41 -05:00
|
|
|
public IReadOnlyCollection<ImageFormat> GetSupportedImageOutputFormats()
|
|
|
|
=> _imageEncoder.SupportedOutputFormats;
|
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2017-09-07 14:17:18 -04:00
|
|
|
public bool SupportsTransparency(string path)
|
2019-08-11 10:52:37 -04:00
|
|
|
=> _transparentImageTypes.Contains(Path.GetExtension(path));
|
2017-07-25 14:32:03 -04:00
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2021-12-24 16:18:24 -05:00
|
|
|
public async Task<(string Path, string? MimeType, DateTime DateModified)> ProcessImage(ImageProcessingOptions options)
|
2014-07-17 18:21:35 -04:00
|
|
|
{
|
2019-01-12 08:46:17 -05:00
|
|
|
ItemImageInfo originalImage = options.Image;
|
|
|
|
BaseItem item = options.Item;
|
2015-10-16 13:06:31 -04:00
|
|
|
|
2019-01-12 08:46:17 -05:00
|
|
|
string originalImagePath = originalImage.Path;
|
|
|
|
DateTime dateModified = originalImage.DateModified;
|
2019-01-26 07:16:47 -05:00
|
|
|
ImageDimensions? originalImageSize = null;
|
2019-01-12 08:46:17 -05:00
|
|
|
if (originalImage.Width > 0 && originalImage.Height > 0)
|
|
|
|
{
|
2019-01-26 07:16:47 -05:00
|
|
|
originalImageSize = new ImageDimensions(originalImage.Width, originalImage.Height);
|
2019-01-12 08:46:17 -05:00
|
|
|
}
|
2013-11-07 10:57:12 -05:00
|
|
|
|
2022-01-03 14:23:55 -05:00
|
|
|
var mimeType = MimeTypes.GetMimeType(originalImagePath);
|
2015-10-26 01:29:32 -04:00
|
|
|
if (!_imageEncoder.SupportsImageEncoding)
|
|
|
|
{
|
2022-01-03 14:23:55 -05:00
|
|
|
return (originalImagePath, mimeType, dateModified);
|
2013-11-06 16:32:26 -05:00
|
|
|
}
|
|
|
|
|
2017-08-26 02:18:52 -04:00
|
|
|
var supportedImageInfo = await GetSupportedImage(originalImagePath, dateModified).ConfigureAwait(false);
|
2021-12-24 16:18:24 -05:00
|
|
|
originalImagePath = supportedImageInfo.Path;
|
2019-03-11 15:44:12 -04:00
|
|
|
|
2022-01-03 14:23:55 -05:00
|
|
|
// Original file doesn't exist, or original file is gif.
|
|
|
|
if (!File.Exists(originalImagePath) || string.Equals(mimeType, MediaTypeNames.Image.Gif, StringComparison.OrdinalIgnoreCase))
|
2019-03-11 15:44:12 -04:00
|
|
|
{
|
2022-01-03 14:23:55 -05:00
|
|
|
return (originalImagePath, mimeType, dateModified);
|
2019-03-11 15:44:12 -04:00
|
|
|
}
|
|
|
|
|
2021-12-24 16:18:24 -05:00
|
|
|
dateModified = supportedImageInfo.DateModified;
|
2019-08-11 10:52:37 -04:00
|
|
|
bool requiresTransparency = _transparentImageTypes.Contains(Path.GetExtension(originalImagePath));
|
2017-08-26 02:18:52 -04:00
|
|
|
|
2019-01-12 08:46:17 -05:00
|
|
|
bool autoOrient = false;
|
2017-06-09 15:24:31 -04:00
|
|
|
ImageOrientation? orientation = null;
|
2019-01-12 08:46:17 -05:00
|
|
|
if (item is Photo photo)
|
2017-06-09 15:24:31 -04:00
|
|
|
{
|
2018-09-12 13:26:21 -04: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 15:24:31 -04:00
|
|
|
}
|
|
|
|
|
2018-09-12 13:26:21 -04:00
|
|
|
if (options.HasDefaultOptions(originalImagePath, originalImageSize) && (!autoOrient || !options.RequiresAutoOrientation))
|
2015-11-09 13:18:37 -05:00
|
|
|
{
|
|
|
|
// Just spit out the original file if all the options are default
|
2019-01-12 08:46:17 -05:00
|
|
|
return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
|
2015-11-09 13:18:37 -05:00
|
|
|
}
|
2013-02-20 20:33:05 -05:00
|
|
|
|
2019-01-12 08:46:17 -05:00
|
|
|
int quality = options.Quality;
|
2013-02-20 20:33:05 -05:00
|
|
|
|
2019-01-12 08:46:17 -05:00
|
|
|
ImageFormat outputFormat = GetOutputFormat(options.SupportedOutputFormats, requiresTransparency);
|
2021-03-17 15:46:45 -04:00
|
|
|
string cacheFilePath = GetCacheFilePath(
|
|
|
|
originalImagePath,
|
|
|
|
options.Width,
|
|
|
|
options.Height,
|
|
|
|
options.MaxWidth,
|
|
|
|
options.MaxHeight,
|
|
|
|
options.FillWidth,
|
|
|
|
options.FillHeight,
|
|
|
|
quality,
|
|
|
|
dateModified,
|
|
|
|
outputFormat,
|
|
|
|
options.AddPlayedIndicator,
|
|
|
|
options.PercentPlayed,
|
|
|
|
options.UnplayedCount,
|
|
|
|
options.Blur,
|
|
|
|
options.BackgroundColor,
|
|
|
|
options.ForegroundLayer);
|
2013-02-20 20:33:05 -05:00
|
|
|
|
2013-04-02 22:59:27 -04:00
|
|
|
try
|
2013-02-20 20:33:05 -05:00
|
|
|
{
|
2019-01-26 16:59:53 -05:00
|
|
|
if (!File.Exists(cacheFilePath))
|
2015-03-27 00:17:04 -04:00
|
|
|
{
|
2019-01-12 08:46:17 -05:00
|
|
|
string resultPath = _imageEncoder.EncodeImage(originalImagePath, dateModified, cacheFilePath, autoOrient, orientation, quality, options, outputFormat);
|
2017-05-17 14:18:18 -04:00
|
|
|
|
|
|
|
if (string.Equals(resultPath, originalImagePath, StringComparison.OrdinalIgnoreCase))
|
|
|
|
{
|
2019-01-12 08:46:17 -05:00
|
|
|
return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
|
2017-05-17 14:18:18 -04:00
|
|
|
}
|
2013-02-20 20:33:05 -05:00
|
|
|
}
|
2015-11-11 09:56:31 -05:00
|
|
|
|
2019-01-12 08:46:17 -05:00
|
|
|
return (cacheFilePath, GetMimeType(outputFormat, cacheFilePath), _fileSystem.GetLastWriteTimeUtc(cacheFilePath));
|
2015-11-11 09:56:31 -05:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
// If it fails for whatever reason, return the original image
|
2018-12-20 07:11:26 -05:00
|
|
|
_logger.LogError(ex, "Error encoding image");
|
2019-01-12 08:46:17 -05:00
|
|
|
return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
|
2013-02-20 20:33:05 -05:00
|
|
|
}
|
2016-07-17 12:59:40 -04:00
|
|
|
}
|
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
private ImageFormat GetOutputFormat(IReadOnlyCollection<ImageFormat> clientSupportedFormats, bool requiresTransparency)
|
2017-09-07 14:17:18 -04: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 13:26:21 -04:00
|
|
|
if (requiresTransparency && clientSupportedFormats.Contains(ImageFormat.Png))
|
2017-09-07 14:17:18 -04:00
|
|
|
{
|
|
|
|
return ImageFormat.Png;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (var format in clientSupportedFormats)
|
|
|
|
{
|
|
|
|
if (serverFormats.Contains(format))
|
|
|
|
{
|
|
|
|
return format;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// We should never actually get here
|
|
|
|
return ImageFormat.Jpg;
|
|
|
|
}
|
|
|
|
|
2021-12-15 12:25:36 -05:00
|
|
|
private string GetMimeType(ImageFormat format, string path)
|
2020-01-21 14:26:30 -05:00
|
|
|
=> 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-27 22:30:19 -04:00
|
|
|
|
2013-02-20 20:33:05 -05:00
|
|
|
/// <summary>
|
2020-01-21 14:26:30 -05:00
|
|
|
/// Gets the cache file path based on a set of parameters.
|
2013-02-20 20:33:05 -05:00
|
|
|
/// </summary>
|
2021-03-17 15:46:45 -04:00
|
|
|
private string GetCacheFilePath(
|
|
|
|
string originalPath,
|
|
|
|
int? width,
|
|
|
|
int? height,
|
|
|
|
int? maxWidth,
|
|
|
|
int? maxHeight,
|
|
|
|
int? fillWidth,
|
|
|
|
int? fillHeight,
|
|
|
|
int quality,
|
|
|
|
DateTime dateModified,
|
|
|
|
ImageFormat format,
|
|
|
|
bool addPlayedIndicator,
|
|
|
|
double percentPlayed,
|
|
|
|
int? unwatchedCount,
|
|
|
|
int? blur,
|
|
|
|
string backgroundColor,
|
|
|
|
string foregroundLayer)
|
2013-02-20 20:33:05 -05:00
|
|
|
{
|
2021-03-28 18:48:59 -04:00
|
|
|
var filename = new StringBuilder(256);
|
2021-03-17 15:46:45 -04:00
|
|
|
filename.Append(originalPath);
|
|
|
|
|
|
|
|
filename.Append(",quality=");
|
|
|
|
filename.Append(quality);
|
|
|
|
|
|
|
|
filename.Append(",datemodified=");
|
|
|
|
filename.Append(dateModified.Ticks);
|
|
|
|
|
|
|
|
filename.Append(",f=");
|
|
|
|
filename.Append(format);
|
|
|
|
|
|
|
|
if (width.HasValue)
|
|
|
|
{
|
|
|
|
filename.Append(",width=");
|
|
|
|
filename.Append(width.Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (height.HasValue)
|
|
|
|
{
|
|
|
|
filename.Append(",height=");
|
|
|
|
filename.Append(height.Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (maxWidth.HasValue)
|
|
|
|
{
|
|
|
|
filename.Append(",maxwidth=");
|
|
|
|
filename.Append(maxWidth.Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (maxHeight.HasValue)
|
|
|
|
{
|
|
|
|
filename.Append(",maxheight=");
|
|
|
|
filename.Append(maxHeight.Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fillWidth.HasValue)
|
|
|
|
{
|
|
|
|
filename.Append(",fillwidth=");
|
|
|
|
filename.Append(fillWidth.Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fillHeight.HasValue)
|
|
|
|
{
|
|
|
|
filename.Append(",fillheight=");
|
|
|
|
filename.Append(fillHeight.Value);
|
|
|
|
}
|
2013-09-19 11:12:28 -04:00
|
|
|
|
2013-10-02 11:32:11 -04:00
|
|
|
if (addPlayedIndicator)
|
|
|
|
{
|
2021-03-17 15:46:45 -04:00
|
|
|
filename.Append(",pl=true");
|
2013-10-02 11:32:11 -04:00
|
|
|
}
|
|
|
|
|
2014-09-01 16:10:54 -04:00
|
|
|
if (percentPlayed > 0)
|
2013-09-19 13:45:48 -04:00
|
|
|
{
|
2021-03-17 15:46:45 -04:00
|
|
|
filename.Append(",p=");
|
|
|
|
filename.Append(percentPlayed);
|
2013-09-21 11:06:00 -04:00
|
|
|
}
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
if (unwatchedCount.HasValue)
|
|
|
|
{
|
2021-03-17 15:46:45 -04:00
|
|
|
filename.Append(",p=");
|
|
|
|
filename.Append(unwatchedCount.Value);
|
2014-01-01 13:26:31 -05:00
|
|
|
}
|
2014-03-27 23:32:43 -04:00
|
|
|
|
2016-12-03 02:58:48 -05:00
|
|
|
if (blur.HasValue)
|
|
|
|
{
|
2021-03-17 15:46:45 -04:00
|
|
|
filename.Append(",blur=");
|
|
|
|
filename.Append(blur.Value);
|
2016-12-03 02:58:48 -05:00
|
|
|
}
|
|
|
|
|
2013-09-21 11:06:00 -04:00
|
|
|
if (!string.IsNullOrEmpty(backgroundColor))
|
|
|
|
{
|
2021-03-17 15:46:45 -04:00
|
|
|
filename.Append(",b=");
|
|
|
|
filename.Append(backgroundColor);
|
2013-09-19 13:45:48 -04:00
|
|
|
}
|
|
|
|
|
2016-02-23 14:48:58 -05:00
|
|
|
if (!string.IsNullOrEmpty(foregroundLayer))
|
|
|
|
{
|
2021-03-17 15:46:45 -04:00
|
|
|
filename.Append(",fl=");
|
|
|
|
filename.Append(foregroundLayer);
|
2016-02-23 14:48:58 -05:00
|
|
|
}
|
|
|
|
|
2021-03-17 15:46:45 -04:00
|
|
|
filename.Append(",v=");
|
|
|
|
filename.Append(Version);
|
2015-03-02 00:16:29 -05:00
|
|
|
|
2021-03-17 15:46:45 -04:00
|
|
|
return GetCachePath(ResizedImageCachePath, filename.ToString(), "." + format.ToString().ToLowerInvariant());
|
2013-02-20 20:33:05 -05:00
|
|
|
}
|
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2019-02-05 13:53:50 -05:00
|
|
|
public ImageDimensions GetImageDimensions(BaseItem item, ItemImageInfo info)
|
2015-02-28 08:42:47 -05:00
|
|
|
{
|
2019-01-12 08:46:17 -05:00
|
|
|
int width = info.Width;
|
|
|
|
int height = info.Height;
|
2015-02-28 08:42:47 -05:00
|
|
|
|
2017-10-22 02:22:43 -04:00
|
|
|
if (height > 0 && width > 0)
|
|
|
|
{
|
2019-01-26 07:16:47 -05:00
|
|
|
return new ImageDimensions(width, height);
|
2017-10-22 02:22:43 -04:00
|
|
|
}
|
|
|
|
|
2019-01-12 08:46:17 -05:00
|
|
|
string path = info.Path;
|
2020-06-08 03:27:03 -04:00
|
|
|
_logger.LogDebug("Getting image size for item {ItemType} {Path}", item.GetType().Name, path);
|
2017-10-22 02:22:43 -04:00
|
|
|
|
2019-02-05 13:53:50 -05:00
|
|
|
ImageDimensions size = GetImageDimensions(path);
|
2019-01-26 07:16:47 -05:00
|
|
|
info.Width = size.Width;
|
|
|
|
info.Height = size.Height;
|
2017-10-22 02:22:43 -04:00
|
|
|
|
|
|
|
return size;
|
2015-10-16 15:25:19 -04:00
|
|
|
}
|
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2019-02-05 13:53:50 -05:00
|
|
|
public ImageDimensions GetImageDimensions(string path)
|
2019-01-26 07:16:47 -05:00
|
|
|
=> _imageEncoder.GetImageSize(path);
|
2013-06-03 22:02:49 -04:00
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2020-05-20 18:43:19 -04:00
|
|
|
public string GetImageBlurHash(string path)
|
2020-06-01 11:12:49 -04:00
|
|
|
{
|
|
|
|
var size = GetImageDimensions(path);
|
2022-06-16 09:14:56 -04:00
|
|
|
return GetImageBlurHash(path, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <inheritdoc />
|
|
|
|
public string GetImageBlurHash(string path, ImageDimensions imageDimensions)
|
|
|
|
{
|
|
|
|
if (imageDimensions.Width <= 0 || imageDimensions.Height <= 0)
|
2020-06-01 11:12:49 -04:00
|
|
|
{
|
|
|
|
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
|
2022-06-16 09:14:56 -04:00
|
|
|
float xCompF = MathF.Sqrt(16.0f * imageDimensions.Width / imageDimensions.Height);
|
|
|
|
float yCompF = xCompF * imageDimensions.Height / imageDimensions.Width;
|
2020-06-01 11:12:49 -04:00
|
|
|
|
|
|
|
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 15:05:49 -04:00
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2018-09-12 13:26:21 -04:00
|
|
|
public string GetImageCacheTag(BaseItem item, ItemImageInfo image)
|
2020-01-21 14:26:30 -05:00
|
|
|
=> (item.Path + image.DateModified.Ticks).GetMD5().ToString("N", CultureInfo.InvariantCulture);
|
2018-09-12 13:26:21 -04:00
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2018-09-12 13:26:21 -04:00
|
|
|
public string GetImageCacheTag(BaseItem item, ChapterInfo chapter)
|
|
|
|
{
|
2020-04-05 15:19:04 -04:00
|
|
|
return GetImageCacheTag(item, new ItemImageInfo
|
2013-02-20 20:33:05 -05:00
|
|
|
{
|
2020-04-05 15:19:04 -04:00
|
|
|
Path = chapter.ImagePath,
|
|
|
|
Type = ImageType.Chapter,
|
|
|
|
DateModified = chapter.ImageDateModified
|
|
|
|
});
|
2013-02-20 20:33:05 -05:00
|
|
|
}
|
|
|
|
|
2020-05-12 22:10:35 -04:00
|
|
|
/// <inheritdoc />
|
2021-03-06 17:43:01 -05:00
|
|
|
public string? GetImageCacheTag(User user)
|
2020-05-12 22:10:35 -04:00
|
|
|
{
|
2022-12-05 09:00:20 -05:00
|
|
|
if (user.ProfileImage is null)
|
2021-03-06 17:43:01 -05:00
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2020-05-12 22:10:35 -04:00
|
|
|
return (user.ProfileImage.Path + user.ProfileImage.LastModified.Ticks).GetMD5()
|
|
|
|
.ToString("N", CultureInfo.InvariantCulture);
|
|
|
|
}
|
|
|
|
|
2022-06-16 09:14:56 -04:00
|
|
|
private Task<(string Path, DateTime DateModified)> GetSupportedImage(string originalImagePath, DateTime dateModified)
|
2017-08-26 02:18:52 -04:00
|
|
|
{
|
2022-06-16 09:14:56 -04:00
|
|
|
var inputFormat = Path.GetExtension(originalImagePath.AsSpan()).TrimStart('.').ToString();
|
2017-08-26 02:18:52 -04:00
|
|
|
|
2017-09-10 16:40:31 -04:00
|
|
|
// These are just jpg files renamed as tbn
|
|
|
|
if (string.Equals(inputFormat, "tbn", StringComparison.OrdinalIgnoreCase))
|
|
|
|
{
|
2022-06-16 09:14:56 -04:00
|
|
|
return Task.FromResult((originalImagePath, dateModified));
|
2017-08-26 02:18:52 -04:00
|
|
|
}
|
|
|
|
|
2022-06-16 09:14:56 -04:00
|
|
|
// TODO _mediaEncoder.ConvertImage is not implemented
|
|
|
|
// 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";
|
|
|
|
// 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)
|
|
|
|
// {
|
|
|
|
// _logger.LogError(ex, "Image conversion failed for {Path}", originalImagePath);
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
|
|
|
|
return Task.FromResult((originalImagePath, dateModified));
|
2017-08-26 02:18:52 -04:00
|
|
|
}
|
|
|
|
|
2013-09-18 14:49:06 -04: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 15:37:13 -05:00
|
|
|
/// <exception cref="ArgumentNullException">
|
2013-09-18 14:49:06 -04:00
|
|
|
/// path
|
|
|
|
/// or
|
|
|
|
/// uniqueName
|
|
|
|
/// or
|
2020-01-21 14:26:30 -05:00
|
|
|
/// fileExtension.
|
2013-09-18 14:49:06 -04:00
|
|
|
/// </exception>
|
|
|
|
public string GetCachePath(string path, string uniqueName, string fileExtension)
|
|
|
|
{
|
2022-10-13 13:08:00 -04:00
|
|
|
ArgumentException.ThrowIfNullOrEmpty(path);
|
|
|
|
ArgumentException.ThrowIfNullOrEmpty(uniqueName);
|
|
|
|
ArgumentException.ThrowIfNullOrEmpty(fileExtension);
|
2013-09-18 14:49:06 -04: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 15:37:13 -05:00
|
|
|
/// <exception cref="ArgumentNullException">
|
2013-09-18 14:49:06 -04:00
|
|
|
/// path
|
|
|
|
/// or
|
2020-01-21 14:26:30 -05:00
|
|
|
/// filename.
|
2013-09-18 14:49:06 -04:00
|
|
|
/// </exception>
|
2020-07-22 07:34:51 -04:00
|
|
|
public string GetCachePath(ReadOnlySpan<char> path, ReadOnlySpan<char> filename)
|
2013-09-18 14:49:06 -04:00
|
|
|
{
|
2020-07-22 07:34:51 -04:00
|
|
|
if (path.IsEmpty)
|
2013-09-18 14:49:06 -04:00
|
|
|
{
|
2020-07-22 07:34:51 -04:00
|
|
|
throw new ArgumentException("Path can't be empty.", nameof(path));
|
2013-09-18 14:49:06 -04:00
|
|
|
}
|
2020-01-21 14:26:30 -05:00
|
|
|
|
2020-09-13 15:38:31 -04:00
|
|
|
if (filename.IsEmpty)
|
2013-09-18 14:49:06 -04:00
|
|
|
{
|
2020-07-22 07:34:51 -04:00
|
|
|
throw new ArgumentException("Filename can't be empty.", nameof(filename));
|
2013-09-18 14:49:06 -04:00
|
|
|
}
|
|
|
|
|
2020-07-22 07:34:51 -04:00
|
|
|
var prefix = filename.Slice(0, 1);
|
2013-09-18 14:49:06 -04:00
|
|
|
|
2020-07-22 07:34:51 -04:00
|
|
|
return Path.Join(path, prefix, filename);
|
2013-09-18 14:49:06 -04:00
|
|
|
}
|
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2020-08-21 13:53:55 -04:00
|
|
|
public void CreateImageCollage(ImageCollageOptions options, string? libraryName)
|
2015-04-08 10:38:02 -04:00
|
|
|
{
|
2019-01-12 08:46:17 -05:00
|
|
|
_logger.LogInformation("Creating image collage and saving to {Path}", options.OutputPath);
|
2015-04-23 12:50:54 -04:00
|
|
|
|
2020-08-21 13:53:55 -04:00
|
|
|
_imageEncoder.CreateImageCollage(options, libraryName);
|
2015-05-11 12:32:15 -04:00
|
|
|
|
2019-01-12 08:46:17 -05:00
|
|
|
_logger.LogInformation("Completed creation of image collage and saved to {Path}", options.OutputPath);
|
2015-04-08 10:38:02 -04:00
|
|
|
}
|
|
|
|
|
2019-08-11 10:52:37 -04:00
|
|
|
/// <inheritdoc />
|
2020-01-21 14:26:30 -05:00
|
|
|
public void Dispose()
|
2017-12-01 12:04:32 -05:00
|
|
|
{
|
2020-01-21 14:26:30 -05:00
|
|
|
if (_disposed)
|
2017-12-01 12:04:32 -05:00
|
|
|
{
|
2020-01-21 14:26:30 -05:00
|
|
|
return;
|
2017-12-01 12:04:32 -05:00
|
|
|
}
|
2017-09-05 15:49:02 -04:00
|
|
|
|
2020-01-21 14:26:30 -05:00
|
|
|
if (_imageEncoder is IDisposable disposable)
|
2017-09-05 15:49:02 -04:00
|
|
|
{
|
|
|
|
disposable.Dispose();
|
|
|
|
}
|
2015-03-06 01:42:59 -05:00
|
|
|
|
2020-01-21 14:26:30 -05:00
|
|
|
_disposed = true;
|
2015-03-06 01:42:59 -05:00
|
|
|
}
|
2013-02-20 20:33:05 -05:00
|
|
|
}
|
2018-12-28 10:48:26 -05:00
|
|
|
}
|