< Summary - Jellyfin

Information
Class: Jellyfin.Drawing.ImageProcessor
Assembly: Jellyfin.Drawing
File(s): /srv/git/jellyfin/src/Jellyfin.Drawing/ImageProcessor.cs
Line coverage
8%
Covered lines: 14
Uncovered lines: 145
Coverable lines: 159
Total lines: 551
Line coverage: 8.8%
Branch coverage
8%
Covered branches: 5
Total branches: 60
Branch coverage: 8.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 7/22/2025 - 12:11:20 AM Line coverage: 8.8% (14/159) Branch coverage: 8.3% (5/60) Total lines: 551 7/22/2025 - 12:11:20 AM Line coverage: 8.8% (14/159) Branch coverage: 8.3% (5/60) Total lines: 551

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%210%
.ctor(...)100%22100%
get_ResizedImageCachePath()100%210%
get_SupportedInputFormats()100%210%
get_SupportsImageCollageCreation()100%210%
GetSupportedImageOutputFormats()100%210%
GetOutputFormat(...)0%156120%
GetCacheFilePath(...)0%506220%
GetImageDimensions(...)0%2040%
GetImageDimensions(...)100%210%
GetImageBlurHash(...)100%210%
GetImageBlurHash(...)0%2040%
GetImageCacheTag(...)100%210%
GetImageCacheTag(...)100%210%
GetImageCacheTag(...)100%210%
GetImageCacheTag(...)0%620%
GetImageCacheTag(...)0%620%
GetImageCacheTag(...)0%620%
GetSupportedImage(...)100%210%
GetCachePath(...)100%210%
GetCachePath(...)0%2040%
CreateImageCollage(...)100%210%
Dispose()50%7671.42%

File(s)

/srv/git/jellyfin/src/Jellyfin.Drawing/ImageProcessor.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Globalization;
 4using System.IO;
 5using System.Linq;
 6using System.Net.Mime;
 7using System.Reflection.Metadata.Ecma335;
 8using System.Text;
 9using System.Threading;
 10using System.Threading.Tasks;
 11using AsyncKeyedLock;
 12using Jellyfin.Database.Implementations.Entities;
 13using MediaBrowser.Common.Extensions;
 14using MediaBrowser.Controller;
 15using MediaBrowser.Controller.Configuration;
 16using MediaBrowser.Controller.Drawing;
 17using MediaBrowser.Controller.Entities;
 18using MediaBrowser.Model.Drawing;
 19using MediaBrowser.Model.Dto;
 20using MediaBrowser.Model.Entities;
 21using MediaBrowser.Model.IO;
 22using MediaBrowser.Model.Net;
 23using Microsoft.Extensions.Logging;
 24using Photo = MediaBrowser.Controller.Entities.Photo;
 25
 26namespace Jellyfin.Drawing;
 27
 28/// <summary>
 29/// Class ImageProcessor.
 30/// </summary>
 31public sealed class ImageProcessor : IImageProcessor, IDisposable
 32{
 33    // Increment this when there's a change requiring caches to be invalidated
 34    private const char Version = '3';
 35
 036    private static readonly HashSet<string> _transparentImageTypes
 037        = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { ".png", ".webp", ".gif", ".svg" };
 38
 39    private readonly ILogger<ImageProcessor> _logger;
 40    private readonly IFileSystem _fileSystem;
 41    private readonly IServerApplicationPaths _appPaths;
 42    private readonly IImageEncoder _imageEncoder;
 43
 44    private readonly AsyncNonKeyedLocker _parallelEncodingLimit;
 45
 46    private bool _disposed;
 47
 48    /// <summary>
 49    /// Initializes a new instance of the <see cref="ImageProcessor"/> class.
 50    /// </summary>
 51    /// <param name="logger">The logger.</param>
 52    /// <param name="appPaths">The server application paths.</param>
 53    /// <param name="fileSystem">The filesystem.</param>
 54    /// <param name="imageEncoder">The image encoder.</param>
 55    /// <param name="config">The configuration.</param>
 56    public ImageProcessor(
 57        ILogger<ImageProcessor> logger,
 58        IServerApplicationPaths appPaths,
 59        IFileSystem fileSystem,
 60        IImageEncoder imageEncoder,
 61        IServerConfigurationManager config)
 62    {
 2163        _logger = logger;
 2164        _fileSystem = fileSystem;
 2165        _imageEncoder = imageEncoder;
 2166        _appPaths = appPaths;
 67
 2168        var semaphoreCount = config.Configuration.ParallelImageEncodingLimit;
 2169        if (semaphoreCount < 1)
 70        {
 2171            semaphoreCount = Environment.ProcessorCount;
 72        }
 73
 2174        _parallelEncodingLimit = new(semaphoreCount);
 2175    }
 76
 077    private string ResizedImageCachePath => Path.Combine(_appPaths.ImageCachePath, "resized-images");
 78
 79    /// <inheritdoc />
 80    public IReadOnlyCollection<string> SupportedInputFormats =>
 081        new HashSet<string>(StringComparer.OrdinalIgnoreCase)
 082        {
 083            "tiff",
 084            "tif",
 085            "jpeg",
 086            "jpg",
 087            "png",
 088            "aiff",
 089            "cr2",
 090            "crw",
 091            "nef",
 092            "orf",
 093            "pef",
 094            "arw",
 095            "webp",
 096            "gif",
 097            "bmp",
 098            "erf",
 099            "raf",
 0100            "rw2",
 0101            "nrw",
 0102            "dng",
 0103            "ico",
 0104            "astc",
 0105            "ktx",
 0106            "pkm",
 0107            "wbmp",
 0108            "avif"
 0109        };
 110
 111    /// <inheritdoc />
 0112    public bool SupportsImageCollageCreation => _imageEncoder.SupportsImageCollageCreation;
 113
 114    /// <inheritdoc />
 115    public IReadOnlyCollection<ImageFormat> GetSupportedImageOutputFormats()
 0116        => _imageEncoder.SupportedOutputFormats;
 117
 118    /// <inheritdoc />
 119    public async Task<(string Path, string? MimeType, DateTime DateModified)> ProcessImage(ImageProcessingOptions option
 120    {
 121        ItemImageInfo originalImage = options.Image;
 122        BaseItem item = options.Item;
 123
 124        string originalImagePath = originalImage.Path;
 125        DateTime dateModified = originalImage.DateModified;
 126        ImageDimensions? originalImageSize = null;
 127        if (originalImage.Width > 0 && originalImage.Height > 0)
 128        {
 129            originalImageSize = new ImageDimensions(originalImage.Width, originalImage.Height);
 130        }
 131
 132        var mimeType = MimeTypes.GetMimeType(originalImagePath);
 133        if (!_imageEncoder.SupportsImageEncoding)
 134        {
 135            return (originalImagePath, mimeType, dateModified);
 136        }
 137
 138        var supportedImageInfo = await GetSupportedImage(originalImagePath, dateModified).ConfigureAwait(false);
 139        originalImagePath = supportedImageInfo.Path;
 140
 141        // Original file doesn't exist, or original file is gif.
 142        if (!File.Exists(originalImagePath) || string.Equals(mimeType, MediaTypeNames.Image.Gif, StringComparison.Ordina
 143        {
 144            return (originalImagePath, mimeType, dateModified);
 145        }
 146
 147        dateModified = supportedImageInfo.DateModified;
 148        bool requiresTransparency = _transparentImageTypes.Contains(Path.GetExtension(originalImagePath));
 149
 150        bool autoOrient = false;
 151        ImageOrientation? orientation = null;
 152        if (item is Photo photo)
 153        {
 154            if (photo.Orientation.HasValue)
 155            {
 156                if (photo.Orientation.Value != ImageOrientation.TopLeft)
 157                {
 158                    autoOrient = true;
 159                    orientation = photo.Orientation;
 160                }
 161            }
 162            else
 163            {
 164                // Orientation unknown, so do it
 165                autoOrient = true;
 166                orientation = photo.Orientation;
 167            }
 168        }
 169
 170        if (options.HasDefaultOptions(originalImagePath, originalImageSize) && (!autoOrient || !options.RequiresAutoOrie
 171        {
 172            // Just spit out the original file if all the options are default
 173            return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
 174        }
 175
 176        int quality = options.Quality;
 177
 178        ImageFormat outputFormat = GetOutputFormat(options.SupportedOutputFormats, requiresTransparency);
 179        string cacheFilePath = GetCacheFilePath(
 180            originalImagePath,
 181            options.Width,
 182            options.Height,
 183            options.MaxWidth,
 184            options.MaxHeight,
 185            options.FillWidth,
 186            options.FillHeight,
 187            quality,
 188            dateModified,
 189            outputFormat,
 190            options.PercentPlayed,
 191            options.UnplayedCount,
 192            options.Blur,
 193            options.BackgroundColor,
 194            options.ForegroundLayer);
 195
 196        try
 197        {
 198            if (!File.Exists(cacheFilePath))
 199            {
 200                string resultPath;
 201
 202                // Limit number of parallel (more precisely: concurrent) image encodings to prevent a high memory usage
 203                using (await _parallelEncodingLimit.LockAsync().ConfigureAwait(false))
 204                {
 205                    resultPath = _imageEncoder.EncodeImage(originalImagePath, dateModified, cacheFilePath, autoOrient, o
 206                }
 207
 208                if (string.Equals(resultPath, originalImagePath, StringComparison.OrdinalIgnoreCase))
 209                {
 210                    return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
 211                }
 212            }
 213
 214            return (cacheFilePath, outputFormat.GetMimeType(), _fileSystem.GetLastWriteTimeUtc(cacheFilePath));
 215        }
 216        catch (Exception ex)
 217        {
 218            // If it fails for whatever reason, return the original image
 219            _logger.LogError(ex, "Error encoding image");
 220            return (originalImagePath, MimeTypes.GetMimeType(originalImagePath), dateModified);
 221        }
 222    }
 223
 224    private ImageFormat GetOutputFormat(IReadOnlyCollection<ImageFormat> clientSupportedFormats, bool requiresTransparen
 225    {
 0226        var serverFormats = GetSupportedImageOutputFormats();
 227
 228        // Client doesn't care about format, so start with webp if supported
 0229        if (serverFormats.Contains(ImageFormat.Webp) && clientSupportedFormats.Contains(ImageFormat.Webp))
 230        {
 0231            return ImageFormat.Webp;
 232        }
 233
 234        // If transparency is needed and webp isn't supported, than png is the only option
 0235        if (requiresTransparency && clientSupportedFormats.Contains(ImageFormat.Png))
 236        {
 0237            return ImageFormat.Png;
 238        }
 239
 0240        foreach (var format in clientSupportedFormats)
 241        {
 0242            if (serverFormats.Contains(format))
 243            {
 0244                return format;
 245            }
 246        }
 247
 248        // We should never actually get here
 0249        return ImageFormat.Jpg;
 0250    }
 251
 252    /// <summary>
 253    /// Gets the cache file path based on a set of parameters.
 254    /// </summary>
 255    private string GetCacheFilePath(
 256        string originalPath,
 257        int? width,
 258        int? height,
 259        int? maxWidth,
 260        int? maxHeight,
 261        int? fillWidth,
 262        int? fillHeight,
 263        int quality,
 264        DateTime dateModified,
 265        ImageFormat format,
 266        double percentPlayed,
 267        int? unwatchedCount,
 268        int? blur,
 269        string backgroundColor,
 270        string foregroundLayer)
 271    {
 0272        var filename = new StringBuilder(256);
 0273        filename.Append(originalPath);
 274
 0275        filename.Append(",quality=");
 0276        filename.Append(quality);
 277
 0278        filename.Append(",datemodified=");
 0279        filename.Append(dateModified.Ticks);
 280
 0281        filename.Append(",f=");
 0282        filename.Append(format);
 283
 0284        if (width.HasValue)
 285        {
 0286            filename.Append(",width=");
 0287            filename.Append(width.Value);
 288        }
 289
 0290        if (height.HasValue)
 291        {
 0292            filename.Append(",height=");
 0293            filename.Append(height.Value);
 294        }
 295
 0296        if (maxWidth.HasValue)
 297        {
 0298            filename.Append(",maxwidth=");
 0299            filename.Append(maxWidth.Value);
 300        }
 301
 0302        if (maxHeight.HasValue)
 303        {
 0304            filename.Append(",maxheight=");
 0305            filename.Append(maxHeight.Value);
 306        }
 307
 0308        if (fillWidth.HasValue)
 309        {
 0310            filename.Append(",fillwidth=");
 0311            filename.Append(fillWidth.Value);
 312        }
 313
 0314        if (fillHeight.HasValue)
 315        {
 0316            filename.Append(",fillheight=");
 0317            filename.Append(fillHeight.Value);
 318        }
 319
 0320        if (percentPlayed > 0)
 321        {
 0322            filename.Append(",p=");
 0323            filename.Append(percentPlayed);
 324        }
 325
 0326        if (unwatchedCount.HasValue)
 327        {
 0328            filename.Append(",p=");
 0329            filename.Append(unwatchedCount.Value);
 330        }
 331
 0332        if (blur.HasValue)
 333        {
 0334            filename.Append(",blur=");
 0335            filename.Append(blur.Value);
 336        }
 337
 0338        if (!string.IsNullOrEmpty(backgroundColor))
 339        {
 0340            filename.Append(",b=");
 0341            filename.Append(backgroundColor);
 342        }
 343
 0344        if (!string.IsNullOrEmpty(foregroundLayer))
 345        {
 0346            filename.Append(",fl=");
 0347            filename.Append(foregroundLayer);
 348        }
 349
 0350        filename.Append(",v=");
 0351        filename.Append(Version);
 352
 0353        return GetCachePath(ResizedImageCachePath, filename.ToString(), format.GetExtension());
 354    }
 355
 356    /// <inheritdoc />
 357    public ImageDimensions GetImageDimensions(BaseItem item, ItemImageInfo info)
 358    {
 0359        int width = info.Width;
 0360        int height = info.Height;
 361
 0362        if (height > 0 && width > 0)
 363        {
 0364            return new ImageDimensions(width, height);
 365        }
 366
 0367        string path = info.Path;
 0368        _logger.LogDebug("Getting image size for item {ItemType} {Path}", item.GetType().Name, path);
 369
 0370        ImageDimensions size = GetImageDimensions(path);
 0371        info.Width = size.Width;
 0372        info.Height = size.Height;
 373
 0374        return size;
 375    }
 376
 377    /// <inheritdoc />
 378    public ImageDimensions GetImageDimensions(string path)
 0379        => _imageEncoder.GetImageSize(path);
 380
 381    /// <inheritdoc />
 382    public string GetImageBlurHash(string path)
 383    {
 0384        var size = GetImageDimensions(path);
 0385        return GetImageBlurHash(path, size);
 386    }
 387
 388    /// <inheritdoc />
 389    public string GetImageBlurHash(string path, ImageDimensions imageDimensions)
 390    {
 0391        if (imageDimensions.Width <= 0 || imageDimensions.Height <= 0)
 392        {
 0393            return string.Empty;
 394        }
 395
 396        // We want tiles to be as close to square as possible, and to *mostly* keep under 16 tiles for performance.
 397        // One tile is (width / xComp) x (height / yComp) pixels, which means that ideally yComp = xComp * height / widt
 398        // See more at https://github.com/woltapp/blurhash/#how-do-i-pick-the-number-of-x-and-y-components
 0399        float xCompF = MathF.Sqrt(16.0f * imageDimensions.Width / imageDimensions.Height);
 0400        float yCompF = xCompF * imageDimensions.Height / imageDimensions.Width;
 401
 0402        int xComp = Math.Min((int)xCompF + 1, 9);
 0403        int yComp = Math.Min((int)yCompF + 1, 9);
 404
 0405        return _imageEncoder.GetImageBlurHash(xComp, yComp, path);
 406    }
 407
 408    /// <inheritdoc />
 409    public string GetImageCacheTag(string baseItemPath, DateTime imageDateModified)
 0410        => (baseItemPath + imageDateModified.Ticks).GetMD5().ToString("N", CultureInfo.InvariantCulture);
 411
 412    /// <inheritdoc />
 413    public string GetImageCacheTag(BaseItem item, ItemImageInfo image)
 0414        => GetImageCacheTag(item.Path, image.DateModified);
 415
 416    /// <inheritdoc />
 417    public string GetImageCacheTag(BaseItemDto item, ItemImageInfo image)
 0418        => GetImageCacheTag(item.Path, image.DateModified);
 419
 420    /// <inheritdoc />
 421    public string? GetImageCacheTag(BaseItemDto item, ChapterInfo chapter)
 422    {
 0423        if (chapter.ImagePath is null)
 424        {
 0425            return null;
 426        }
 427
 0428        return GetImageCacheTag(item.Path, chapter.ImageDateModified);
 429    }
 430
 431    /// <inheritdoc />
 432    public string? GetImageCacheTag(BaseItem item, ChapterInfo chapter)
 433    {
 0434        if (chapter.ImagePath is null)
 435        {
 0436            return null;
 437        }
 438
 0439        return GetImageCacheTag(item, new ItemImageInfo
 0440        {
 0441            Path = chapter.ImagePath,
 0442            Type = ImageType.Chapter,
 0443            DateModified = chapter.ImageDateModified
 0444        });
 445    }
 446
 447    /// <inheritdoc />
 448    public string? GetImageCacheTag(User user)
 449    {
 0450        if (user.ProfileImage is null)
 451        {
 0452            return null;
 453        }
 454
 0455        return GetImageCacheTag(user.ProfileImage.Path, user.ProfileImage.LastModified);
 456    }
 457
 458    private Task<(string Path, DateTime DateModified)> GetSupportedImage(string originalImagePath, DateTime dateModified
 459    {
 0460        var inputFormat = Path.GetExtension(originalImagePath.AsSpan()).TrimStart('.').ToString();
 461
 462        // These are just jpg files renamed as tbn
 0463        if (string.Equals(inputFormat, "tbn", StringComparison.OrdinalIgnoreCase))
 464        {
 0465            return Task.FromResult((originalImagePath, dateModified));
 466        }
 467
 468        return Task.FromResult((originalImagePath, dateModified));
 469    }
 470
 471    /// <summary>
 472    /// Gets the cache path.
 473    /// </summary>
 474    /// <param name="path">The path.</param>
 475    /// <param name="uniqueName">Name of the unique.</param>
 476    /// <param name="fileExtension">The file extension.</param>
 477    /// <returns>System.String.</returns>
 478    /// <exception cref="ArgumentNullException">
 479    /// path
 480    /// or
 481    /// uniqueName
 482    /// or
 483    /// fileExtension.
 484    /// </exception>
 485    public string GetCachePath(string path, string uniqueName, string fileExtension)
 486    {
 0487        ArgumentException.ThrowIfNullOrEmpty(path);
 0488        ArgumentException.ThrowIfNullOrEmpty(uniqueName);
 0489        ArgumentException.ThrowIfNullOrEmpty(fileExtension);
 490
 0491        var filename = uniqueName.GetMD5() + fileExtension;
 492
 0493        return GetCachePath(path, filename);
 494    }
 495
 496    /// <summary>
 497    /// Gets the cache path.
 498    /// </summary>
 499    /// <param name="path">The path.</param>
 500    /// <param name="filename">The filename.</param>
 501    /// <returns>System.String.</returns>
 502    /// <exception cref="ArgumentNullException">
 503    /// path
 504    /// or
 505    /// filename.
 506    /// </exception>
 507    public string GetCachePath(ReadOnlySpan<char> path, ReadOnlySpan<char> filename)
 508    {
 0509        if (path.IsEmpty)
 510        {
 0511            throw new ArgumentException("Path can't be empty.", nameof(path));
 512        }
 513
 0514        if (filename.IsEmpty)
 515        {
 0516            throw new ArgumentException("Filename can't be empty.", nameof(filename));
 517        }
 518
 0519        var prefix = filename.Slice(0, 1);
 520
 0521        return Path.Join(path, prefix, filename);
 522    }
 523
 524    /// <inheritdoc />
 525    public void CreateImageCollage(ImageCollageOptions options, string? libraryName)
 526    {
 0527        _logger.LogDebug("Creating image collage and saving to {Path}", options.OutputPath);
 528
 0529        _imageEncoder.CreateImageCollage(options, libraryName);
 530
 0531        _logger.LogDebug("Completed creation of image collage and saved to {Path}", options.OutputPath);
 0532    }
 533
 534    /// <inheritdoc />
 535    public void Dispose()
 536    {
 21537        if (_disposed)
 538        {
 0539            return;
 540        }
 541
 21542        if (_imageEncoder is IDisposable disposable)
 543        {
 0544            disposable.Dispose();
 545        }
 546
 21547        _parallelEncodingLimit?.Dispose();
 548
 21549        _disposed = true;
 21550    }
 551}
Generated by: ReportGenerator 5.4.17.0
11/3/2025 - 12:10:25 AM
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(Microsoft.Extensions.Logging.ILogger`1<Jellyfin.Drawing.ImageProcessor>,MediaBrowser.Controller.IServerApplicationPaths,MediaBrowser.Model.IO.IFileSystem,MediaBrowser.Controller.Drawing.IImageEncoder,MediaBrowser.Controller.Configuration.IServerConfigurationManager)
get_ResizedImageCachePath()
get_SupportedInputFormats()
get_SupportsImageCollageCreation()
GetSupportedImageOutputFormats()
GetOutputFormat(System.Collections.Generic.IReadOnlyCollection`1<MediaBrowser.Model.Drawing.ImageFormat>,System.Boolean)
GetCacheFilePath(System.String,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Int32,System.DateTime,MediaBrowser.Model.Drawing.ImageFormat,System.Double,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.String,System.String)
GetImageDimensions(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.ItemImageInfo)
GetImageDimensions(System.String)
GetImageBlurHash(System.String)
GetImageBlurHash(System.String,MediaBrowser.Model.Drawing.ImageDimensions)
GetImageCacheTag(System.String,System.DateTime)
GetImageCacheTag(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.ItemImageInfo)
GetImageCacheTag(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.ItemImageInfo)
GetImageCacheTag(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Model.Entities.ChapterInfo)
GetImageCacheTag(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Entities.ChapterInfo)
GetImageCacheTag(Jellyfin.Database.Implementations.Entities.User)
GetSupportedImage(System.String,System.DateTime)
GetCachePath(System.String,System.String,System.String)
GetCachePath(System.ReadOnlySpan`1<System.Char>,System.ReadOnlySpan`1<System.Char>)
CreateImageCollage(MediaBrowser.Controller.Drawing.ImageCollageOptions,System.String)
Dispose()