< Summary - Jellyfin

Information
Class: Jellyfin.Api.Controllers.ImageController
Assembly: Jellyfin.Api
File(s): /srv/git/jellyfin/Jellyfin.Api/Controllers/ImageController.cs
Line coverage
9%
Covered lines: 9
Uncovered lines: 88
Coverable lines: 97
Total lines: 2150
Line coverage: 9.2%
Branch coverage
20%
Covered branches: 8
Total branches: 40
Branch coverage: 20%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%210%
GetFromBase64Stream(...)100%210%
DeleteCustomSplashscreen()0%2040%
GetImageInfo(...)0%4260%
GetOutputFormats(...)0%620%
GetClientSupportedFormats()0%210140%
SupportsFormat(...)0%4260%
TryGetImageExtensionFromContentType(...)100%88100%

File(s)

/srv/git/jellyfin/Jellyfin.Api/Controllers/ImageController.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Collections.Immutable;
 4using System.ComponentModel.DataAnnotations;
 5using System.Diagnostics.CodeAnalysis;
 6using System.Globalization;
 7using System.IO;
 8using System.Linq;
 9using System.Net.Mime;
 10using System.Security.Cryptography;
 11using System.Threading;
 12using System.Threading.Tasks;
 13using Jellyfin.Api.Attributes;
 14using Jellyfin.Api.Extensions;
 15using Jellyfin.Api.Helpers;
 16using Jellyfin.Extensions;
 17using MediaBrowser.Common.Api;
 18using MediaBrowser.Common.Configuration;
 19using MediaBrowser.Controller.Configuration;
 20using MediaBrowser.Controller.Drawing;
 21using MediaBrowser.Controller.Entities;
 22using MediaBrowser.Controller.Library;
 23using MediaBrowser.Controller.Providers;
 24using MediaBrowser.Model.Branding;
 25using MediaBrowser.Model.Drawing;
 26using MediaBrowser.Model.Dto;
 27using MediaBrowser.Model.Entities;
 28using MediaBrowser.Model.IO;
 29using MediaBrowser.Model.Net;
 30using Microsoft.AspNetCore.Authorization;
 31using Microsoft.AspNetCore.Http;
 32using Microsoft.AspNetCore.Mvc;
 33using Microsoft.Extensions.Logging;
 34using Microsoft.Net.Http.Headers;
 35
 36namespace Jellyfin.Api.Controllers;
 37
 38/// <summary>
 39/// Image controller.
 40/// </summary>
 41[Route("")]
 42public class ImageController : BaseJellyfinApiController
 43{
 44    private readonly IUserManager _userManager;
 45    private readonly ILibraryManager _libraryManager;
 46    private readonly IProviderManager _providerManager;
 47    private readonly IImageProcessor _imageProcessor;
 48    private readonly IFileSystem _fileSystem;
 49    private readonly ILogger<ImageController> _logger;
 50    private readonly IServerConfigurationManager _serverConfigurationManager;
 51    private readonly IApplicationPaths _appPaths;
 52
 53    /// <summary>
 54    /// Initializes a new instance of the <see cref="ImageController"/> class.
 55    /// </summary>
 56    /// <param name="userManager">Instance of the <see cref="IUserManager"/> interface.</param>
 57    /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
 58    /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
 59    /// <param name="imageProcessor">Instance of the <see cref="IImageProcessor"/> interface.</param>
 60    /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
 61    /// <param name="logger">Instance of the <see cref="ILogger{ImageController}"/> interface.</param>
 62    /// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</p
 63    /// <param name="appPaths">Instance of the <see cref="IApplicationPaths"/> interface.</param>
 064    public ImageController(
 065        IUserManager userManager,
 066        ILibraryManager libraryManager,
 067        IProviderManager providerManager,
 068        IImageProcessor imageProcessor,
 069        IFileSystem fileSystem,
 070        ILogger<ImageController> logger,
 071        IServerConfigurationManager serverConfigurationManager,
 072        IApplicationPaths appPaths)
 73    {
 074        _userManager = userManager;
 075        _libraryManager = libraryManager;
 076        _providerManager = providerManager;
 077        _imageProcessor = imageProcessor;
 078        _fileSystem = fileSystem;
 079        _logger = logger;
 080        _serverConfigurationManager = serverConfigurationManager;
 081        _appPaths = appPaths;
 082    }
 83
 84    private static CryptoStream GetFromBase64Stream(Stream inputStream)
 085        => new CryptoStream(inputStream, new FromBase64Transform(), CryptoStreamMode.Read);
 86
 87    /// <summary>
 88    /// Sets the user image.
 89    /// </summary>
 90    /// <param name="userId">User Id.</param>
 91    /// <response code="204">Image updated.</response>
 92    /// <response code="403">User does not have permission to delete the image.</response>
 93    /// <response code="404">Item not found.</response>
 94    /// <returns>A <see cref="NoContentResult"/>.</returns>
 95    [HttpPost("UserImage")]
 96    [Authorize]
 97    [AcceptsImageFile]
 98    [ProducesResponseType(StatusCodes.Status204NoContent)]
 99    [ProducesResponseType(StatusCodes.Status400BadRequest)]
 100    [ProducesResponseType(StatusCodes.Status403Forbidden)]
 101    [ProducesResponseType(StatusCodes.Status404NotFound)]
 102    public async Task<ActionResult> PostUserImage(
 103        [FromQuery] Guid? userId)
 104    {
 105        var requestUserId = RequestHelpers.GetUserId(User, userId);
 106        var user = _userManager.GetUserById(requestUserId);
 107        if (user is null)
 108        {
 109            return NotFound();
 110        }
 111
 112        if (!RequestHelpers.AssertCanUpdateUser(HttpContext.User, user, true))
 113        {
 114            return StatusCode(StatusCodes.Status403Forbidden, "User is not allowed to update the image.");
 115        }
 116
 117        if (!TryGetImageExtensionFromContentType(Request.ContentType, out string? extension))
 118        {
 119            return BadRequest("Incorrect ContentType.");
 120        }
 121
 122        var stream = GetFromBase64Stream(Request.Body);
 123        await using (stream.ConfigureAwait(false))
 124        {
 125            // Handle image/png; charset=utf-8
 126            var mimeType = Request.ContentType?.Split(';').FirstOrDefault();
 127            var userDataPath = Path.Combine(_serverConfigurationManager.ApplicationPaths.UserConfigurationDirectoryPath,
 128            if (user.ProfileImage is not null)
 129            {
 130                await _userManager.ClearProfileImageAsync(user).ConfigureAwait(false);
 131            }
 132
 133            user.ProfileImage = new Database.Implementations.Entities.ImageInfo(Path.Combine(userDataPath, "profile" + e
 134
 135            await _providerManager
 136                .SaveImage(stream, mimeType, user.ProfileImage.Path)
 137                .ConfigureAwait(false);
 138            await _userManager.UpdateUserAsync(user).ConfigureAwait(false);
 139
 140            return NoContent();
 141        }
 142    }
 143
 144    /// <summary>
 145    /// Sets the user image.
 146    /// </summary>
 147    /// <param name="userId">User Id.</param>
 148    /// <param name="imageType">(Unused) Image type.</param>
 149    /// <response code="204">Image updated.</response>
 150    /// <response code="403">User does not have permission to delete the image.</response>
 151    /// <returns>A <see cref="NoContentResult"/>.</returns>
 152    [HttpPost("Users/{userId}/Images/{imageType}")]
 153    [Authorize]
 154    [Obsolete("Kept for backwards compatibility")]
 155    [ApiExplorerSettings(IgnoreApi = true)]
 156    [AcceptsImageFile]
 157    [ProducesResponseType(StatusCodes.Status204NoContent)]
 158    [ProducesResponseType(StatusCodes.Status400BadRequest)]
 159    [ProducesResponseType(StatusCodes.Status403Forbidden)]
 160    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "imageType", Justification = 
 161    public Task<ActionResult> PostUserImageLegacy(
 162        [FromRoute, Required] Guid userId,
 163        [FromRoute, Required] ImageType imageType)
 164        => PostUserImage(userId);
 165
 166    /// <summary>
 167    /// Sets the user image.
 168    /// </summary>
 169    /// <param name="userId">User Id.</param>
 170    /// <param name="imageType">(Unused) Image type.</param>
 171    /// <param name="index">(Unused) Image index.</param>
 172    /// <response code="204">Image updated.</response>
 173    /// <response code="403">User does not have permission to delete the image.</response>
 174    /// <returns>A <see cref="NoContentResult"/>.</returns>
 175    [HttpPost("Users/{userId}/Images/{imageType}/{index}")]
 176    [Authorize]
 177    [Obsolete("Kept for backwards compatibility")]
 178    [ApiExplorerSettings(IgnoreApi = true)]
 179    [AcceptsImageFile]
 180    [ProducesResponseType(StatusCodes.Status204NoContent)]
 181    [ProducesResponseType(StatusCodes.Status400BadRequest)]
 182    [ProducesResponseType(StatusCodes.Status403Forbidden)]
 183    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "imageType", Justification = 
 184    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "index", Justification = "Imp
 185    public Task<ActionResult> PostUserImageByIndexLegacy(
 186        [FromRoute, Required] Guid userId,
 187        [FromRoute, Required] ImageType imageType,
 188        [FromRoute] int index)
 189        => PostUserImage(userId);
 190
 191    /// <summary>
 192    /// Delete the user's image.
 193    /// </summary>
 194    /// <param name="userId">User Id.</param>
 195    /// <response code="204">Image deleted.</response>
 196    /// <response code="403">User does not have permission to delete the image.</response>
 197    /// <returns>A <see cref="NoContentResult"/>.</returns>
 198    [HttpDelete("UserImage")]
 199    [Authorize]
 200    [ProducesResponseType(StatusCodes.Status204NoContent)]
 201    [ProducesResponseType(StatusCodes.Status403Forbidden)]
 202    public async Task<ActionResult> DeleteUserImage(
 203        [FromQuery] Guid? userId)
 204    {
 205        var requestUserId = RequestHelpers.GetUserId(User, userId);
 206        var user = _userManager.GetUserById(requestUserId);
 207        if (user is null)
 208        {
 209            return NotFound();
 210        }
 211
 212        if (!RequestHelpers.AssertCanUpdateUser(HttpContext.User, user, true))
 213        {
 214            return StatusCode(StatusCodes.Status403Forbidden, "User is not allowed to delete the image.");
 215        }
 216
 217        if (user.ProfileImage is null)
 218        {
 219            return NoContent();
 220        }
 221
 222        try
 223        {
 224            System.IO.File.Delete(user.ProfileImage.Path);
 225        }
 226        catch (IOException e)
 227        {
 228            _logger.LogError(e, "Error deleting user profile image:");
 229        }
 230
 231        await _userManager.ClearProfileImageAsync(user).ConfigureAwait(false);
 232        return NoContent();
 233    }
 234
 235    /// <summary>
 236    /// Delete the user's image.
 237    /// </summary>
 238    /// <param name="userId">User Id.</param>
 239    /// <param name="imageType">(Unused) Image type.</param>
 240    /// <param name="index">(Unused) Image index.</param>
 241    /// <response code="204">Image deleted.</response>
 242    /// <response code="403">User does not have permission to delete the image.</response>
 243    /// <returns>A <see cref="NoContentResult"/>.</returns>
 244    [HttpDelete("Users/{userId}/Images/{imageType}")]
 245    [Authorize]
 246    [Obsolete("Kept for backwards compatibility")]
 247    [ApiExplorerSettings(IgnoreApi = true)]
 248    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "imageType", Justification = 
 249    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "index", Justification = "Imp
 250    [ProducesResponseType(StatusCodes.Status204NoContent)]
 251    [ProducesResponseType(StatusCodes.Status403Forbidden)]
 252    public Task<ActionResult> DeleteUserImageLegacy(
 253        [FromRoute, Required] Guid userId,
 254        [FromRoute, Required] ImageType imageType,
 255        [FromQuery] int? index = null)
 256        => DeleteUserImage(userId);
 257
 258    /// <summary>
 259    /// Delete the user's image.
 260    /// </summary>
 261    /// <param name="userId">User Id.</param>
 262    /// <param name="imageType">(Unused) Image type.</param>
 263    /// <param name="index">(Unused) Image index.</param>
 264    /// <response code="204">Image deleted.</response>
 265    /// <response code="403">User does not have permission to delete the image.</response>
 266    /// <returns>A <see cref="NoContentResult"/>.</returns>
 267    [HttpDelete("Users/{userId}/Images/{imageType}/{index}")]
 268    [Authorize]
 269    [Obsolete("Kept for backwards compatibility")]
 270    [ApiExplorerSettings(IgnoreApi = true)]
 271    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "imageType", Justification = 
 272    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "index", Justification = "Imp
 273    [ProducesResponseType(StatusCodes.Status204NoContent)]
 274    [ProducesResponseType(StatusCodes.Status403Forbidden)]
 275    public Task<ActionResult> DeleteUserImageByIndexLegacy(
 276        [FromRoute, Required] Guid userId,
 277        [FromRoute, Required] ImageType imageType,
 278        [FromRoute] int index)
 279        => DeleteUserImage(userId);
 280
 281    /// <summary>
 282    /// Delete an item's image.
 283    /// </summary>
 284    /// <param name="itemId">Item id.</param>
 285    /// <param name="imageType">Image type.</param>
 286    /// <param name="imageIndex">The image index.</param>
 287    /// <response code="204">Image deleted.</response>
 288    /// <response code="404">Item not found.</response>
 289    /// <returns>A <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if item not found.</retur
 290    [HttpDelete("Items/{itemId}/Images/{imageType}")]
 291    [Authorize(Policy = Policies.RequiresElevation)]
 292    [ProducesResponseType(StatusCodes.Status204NoContent)]
 293    [ProducesResponseType(StatusCodes.Status404NotFound)]
 294    public async Task<ActionResult> DeleteItemImage(
 295        [FromRoute, Required] Guid itemId,
 296        [FromRoute, Required] ImageType imageType,
 297        [FromQuery] int? imageIndex)
 298    {
 299        var item = _libraryManager.GetItemById<BaseItem>(itemId, User.GetUserId());
 300        if (item is null)
 301        {
 302            return NotFound();
 303        }
 304
 305        await item.DeleteImageAsync(imageType, imageIndex ?? 0).ConfigureAwait(false);
 306        return NoContent();
 307    }
 308
 309    /// <summary>
 310    /// Delete an item's image.
 311    /// </summary>
 312    /// <param name="itemId">Item id.</param>
 313    /// <param name="imageType">Image type.</param>
 314    /// <param name="imageIndex">The image index.</param>
 315    /// <response code="204">Image deleted.</response>
 316    /// <response code="404">Item not found.</response>
 317    /// <returns>A <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if item not found.</retur
 318    [HttpDelete("Items/{itemId}/Images/{imageType}/{imageIndex}")]
 319    [Authorize(Policy = Policies.RequiresElevation)]
 320    [ProducesResponseType(StatusCodes.Status204NoContent)]
 321    [ProducesResponseType(StatusCodes.Status404NotFound)]
 322    public async Task<ActionResult> DeleteItemImageByIndex(
 323        [FromRoute, Required] Guid itemId,
 324        [FromRoute, Required] ImageType imageType,
 325        [FromRoute] int imageIndex)
 326    {
 327        var item = _libraryManager.GetItemById<BaseItem>(itemId, User.GetUserId());
 328        if (item is null)
 329        {
 330            return NotFound();
 331        }
 332
 333        await item.DeleteImageAsync(imageType, imageIndex).ConfigureAwait(false);
 334        return NoContent();
 335    }
 336
 337    /// <summary>
 338    /// Set item image.
 339    /// </summary>
 340    /// <param name="itemId">Item id.</param>
 341    /// <param name="imageType">Image type.</param>
 342    /// <response code="204">Image saved.</response>
 343    /// <response code="404">Item not found.</response>
 344    /// <returns>A <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if item not found.</retur
 345    [HttpPost("Items/{itemId}/Images/{imageType}")]
 346    [Authorize(Policy = Policies.RequiresElevation)]
 347    [AcceptsImageFile]
 348    [ProducesResponseType(StatusCodes.Status204NoContent)]
 349    [ProducesResponseType(StatusCodes.Status400BadRequest)]
 350    [ProducesResponseType(StatusCodes.Status404NotFound)]
 351    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "index", Justification = "Imp
 352    public async Task<ActionResult> SetItemImage(
 353        [FromRoute, Required] Guid itemId,
 354        [FromRoute, Required] ImageType imageType)
 355    {
 356        var item = _libraryManager.GetItemById<BaseItem>(itemId, User.GetUserId());
 357        if (item is null)
 358        {
 359            return NotFound();
 360        }
 361
 362        if (!TryGetImageExtensionFromContentType(Request.ContentType, out _))
 363        {
 364            return BadRequest("Incorrect ContentType.");
 365        }
 366
 367        var stream = GetFromBase64Stream(Request.Body);
 368        await using (stream.ConfigureAwait(false))
 369        {
 370            // Handle image/png; charset=utf-8
 371            var mimeType = Request.ContentType?.Split(';').FirstOrDefault();
 372            await _providerManager.SaveImage(item, stream, mimeType, imageType, null, CancellationToken.None).ConfigureA
 373            await item.UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false)
 374
 375            return NoContent();
 376        }
 377    }
 378
 379    /// <summary>
 380    /// Set item image.
 381    /// </summary>
 382    /// <param name="itemId">Item id.</param>
 383    /// <param name="imageType">Image type.</param>
 384    /// <param name="imageIndex">(Unused) Image index.</param>
 385    /// <response code="204">Image saved.</response>
 386    /// <response code="404">Item not found.</response>
 387    /// <returns>A <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if item not found.</retur
 388    [HttpPost("Items/{itemId}/Images/{imageType}/{imageIndex}")]
 389    [Authorize(Policy = Policies.RequiresElevation)]
 390    [AcceptsImageFile]
 391    [ProducesResponseType(StatusCodes.Status204NoContent)]
 392    [ProducesResponseType(StatusCodes.Status400BadRequest)]
 393    [ProducesResponseType(StatusCodes.Status404NotFound)]
 394    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "index", Justification = "Imp
 395    public async Task<ActionResult> SetItemImageByIndex(
 396        [FromRoute, Required] Guid itemId,
 397        [FromRoute, Required] ImageType imageType,
 398        [FromRoute] int imageIndex)
 399    {
 400        var item = _libraryManager.GetItemById<BaseItem>(itemId, User.GetUserId());
 401        if (item is null)
 402        {
 403            return NotFound();
 404        }
 405
 406        if (!TryGetImageExtensionFromContentType(Request.ContentType, out _))
 407        {
 408            return BadRequest("Incorrect ContentType.");
 409        }
 410
 411        var stream = GetFromBase64Stream(Request.Body);
 412        await using (stream.ConfigureAwait(false))
 413        {
 414            // Handle image/png; charset=utf-8
 415            var mimeType = Request.ContentType?.Split(';').FirstOrDefault();
 416            await _providerManager.SaveImage(item, stream, mimeType, imageType, null, CancellationToken.None).ConfigureA
 417            await item.UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false)
 418
 419            return NoContent();
 420        }
 421    }
 422
 423    /// <summary>
 424    /// Updates the index for an item image.
 425    /// </summary>
 426    /// <param name="itemId">Item id.</param>
 427    /// <param name="imageType">Image type.</param>
 428    /// <param name="imageIndex">Old image index.</param>
 429    /// <param name="newIndex">New image index.</param>
 430    /// <response code="204">Image index updated.</response>
 431    /// <response code="404">Item not found.</response>
 432    /// <returns>A <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if item not found.</retur
 433    [HttpPost("Items/{itemId}/Images/{imageType}/{imageIndex}/Index")]
 434    [Authorize(Policy = Policies.RequiresElevation)]
 435    [ProducesResponseType(StatusCodes.Status204NoContent)]
 436    [ProducesResponseType(StatusCodes.Status404NotFound)]
 437    public async Task<ActionResult> UpdateItemImageIndex(
 438        [FromRoute, Required] Guid itemId,
 439        [FromRoute, Required] ImageType imageType,
 440        [FromRoute, Required] int imageIndex,
 441        [FromQuery, Required] int newIndex)
 442    {
 443        var item = _libraryManager.GetItemById<BaseItem>(itemId, User.GetUserId());
 444        if (item is null)
 445        {
 446            return NotFound();
 447        }
 448
 449        await item.SwapImagesAsync(imageType, imageIndex, newIndex).ConfigureAwait(false);
 450        return NoContent();
 451    }
 452
 453    /// <summary>
 454    /// Get item image infos.
 455    /// </summary>
 456    /// <param name="itemId">Item id.</param>
 457    /// <response code="200">Item images returned.</response>
 458    /// <response code="404">Item not found.</response>
 459    /// <returns>The list of image infos on success, or <see cref="NotFoundResult"/> if item not found.</returns>
 460    [HttpGet("Items/{itemId}/Images")]
 461    [Authorize]
 462    [ProducesResponseType(StatusCodes.Status200OK)]
 463    [ProducesResponseType(StatusCodes.Status404NotFound)]
 464    public async Task<ActionResult<IEnumerable<ImageInfo>>> GetItemImageInfos([FromRoute, Required] Guid itemId)
 465    {
 466        var item = _libraryManager.GetItemById<BaseItem>(itemId, User.GetUserId());
 467        if (item is null)
 468        {
 469            return NotFound();
 470        }
 471
 472        var list = new List<ImageInfo>();
 473        var itemImages = item.ImageInfos;
 474
 475        if (itemImages.Length == 0)
 476        {
 477            // short-circuit
 478            return list;
 479        }
 480
 481        await _libraryManager.UpdateImagesAsync(item).ConfigureAwait(false); // this makes sure dimensions and hashes ar
 482
 483        foreach (var image in itemImages)
 484        {
 485            if (!item.AllowsMultipleImages(image.Type))
 486            {
 487                var info = GetImageInfo(item, image, null);
 488
 489                if (info is not null)
 490                {
 491                    list.Add(info);
 492                }
 493            }
 494        }
 495
 496        foreach (var imageType in itemImages.Select(i => i.Type).Distinct().Where(item.AllowsMultipleImages))
 497        {
 498            var index = 0;
 499
 500            // Prevent implicitly captured closure
 501            var currentImageType = imageType;
 502
 503            foreach (var image in itemImages.Where(i => i.Type == currentImageType))
 504            {
 505                var info = GetImageInfo(item, image, index);
 506
 507                if (info is not null)
 508                {
 509                    list.Add(info);
 510                }
 511
 512                index++;
 513            }
 514        }
 515
 516        return list;
 517    }
 518
 519    /// <summary>
 520    /// Gets the item's image.
 521    /// </summary>
 522    /// <param name="itemId">Item id.</param>
 523    /// <param name="imageType">Image type.</param>
 524    /// <param name="maxWidth">The maximum image width to return.</param>
 525    /// <param name="maxHeight">The maximum image height to return.</param>
 526    /// <param name="width">The fixed image width to return.</param>
 527    /// <param name="height">The fixed image height to return.</param>
 528    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 529    /// <param name="fillWidth">Width of box to fill.</param>
 530    /// <param name="fillHeight">Height of box to fill.</param>
 531    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 532    /// <param name="format">Optional. The <see cref="ImageFormat"/> of the returned image.</param>
 533    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 534    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 535    /// <param name="blur">Optional. Blur image.</param>
 536    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 537    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 538    /// <param name="imageIndex">Image index.</param>
 539    /// <response code="200">Image stream returned.</response>
 540    /// <response code="404">Item not found.</response>
 541    /// <returns>
 542    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 543    /// or a <see cref="NotFoundResult"/> if item not found.
 544    /// </returns>
 545    [HttpGet("Items/{itemId}/Images/{imageType}")]
 546    [HttpHead("Items/{itemId}/Images/{imageType}", Name = "HeadItemImage")]
 547    [ProducesResponseType(StatusCodes.Status200OK)]
 548    [ProducesResponseType(StatusCodes.Status404NotFound)]
 549    [ProducesImageFile]
 550    public async Task<ActionResult> GetItemImage(
 551        [FromRoute, Required] Guid itemId,
 552        [FromRoute, Required] ImageType imageType,
 553        [FromQuery] int? maxWidth,
 554        [FromQuery] int? maxHeight,
 555        [FromQuery] int? width,
 556        [FromQuery] int? height,
 557        [FromQuery] int? quality,
 558        [FromQuery] int? fillWidth,
 559        [FromQuery] int? fillHeight,
 560        [FromQuery] string? tag,
 561        [FromQuery] ImageFormat? format,
 562        [FromQuery] double? percentPlayed,
 563        [FromQuery] int? unplayedCount,
 564        [FromQuery] int? blur,
 565        [FromQuery] string? backgroundColor,
 566        [FromQuery] string? foregroundLayer,
 567        [FromQuery] int? imageIndex)
 568    {
 569        var item = _libraryManager.GetItemById<BaseItem>(itemId, User.GetUserId());
 570        if (item is null)
 571        {
 572            return NotFound();
 573        }
 574
 575        return await GetImageInternal(
 576                itemId,
 577                imageType,
 578                imageIndex,
 579                tag,
 580                format,
 581                maxWidth,
 582                maxHeight,
 583                percentPlayed,
 584                unplayedCount,
 585                width,
 586                height,
 587                quality,
 588                fillWidth,
 589                fillHeight,
 590                blur,
 591                backgroundColor,
 592                foregroundLayer,
 593                item)
 594            .ConfigureAwait(false);
 595    }
 596
 597    /// <summary>
 598    /// Gets the item's image.
 599    /// </summary>
 600    /// <param name="itemId">Item id.</param>
 601    /// <param name="imageType">Image type.</param>
 602    /// <param name="imageIndex">Image index.</param>
 603    /// <param name="maxWidth">The maximum image width to return.</param>
 604    /// <param name="maxHeight">The maximum image height to return.</param>
 605    /// <param name="width">The fixed image width to return.</param>
 606    /// <param name="height">The fixed image height to return.</param>
 607    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 608    /// <param name="fillWidth">Width of box to fill.</param>
 609    /// <param name="fillHeight">Height of box to fill.</param>
 610    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 611    /// <param name="format">Optional. The <see cref="ImageFormat"/> of the returned image.</param>
 612    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 613    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 614    /// <param name="blur">Optional. Blur image.</param>
 615    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 616    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 617    /// <response code="200">Image stream returned.</response>
 618    /// <response code="404">Item not found.</response>
 619    /// <returns>
 620    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 621    /// or a <see cref="NotFoundResult"/> if item not found.
 622    /// </returns>
 623    [HttpGet("Items/{itemId}/Images/{imageType}/{imageIndex}")]
 624    [HttpHead("Items/{itemId}/Images/{imageType}/{imageIndex}", Name = "HeadItemImageByIndex")]
 625    [ProducesResponseType(StatusCodes.Status200OK)]
 626    [ProducesResponseType(StatusCodes.Status404NotFound)]
 627    [ProducesImageFile]
 628    public async Task<ActionResult> GetItemImageByIndex(
 629        [FromRoute, Required] Guid itemId,
 630        [FromRoute, Required] ImageType imageType,
 631        [FromRoute] int imageIndex,
 632        [FromQuery] int? maxWidth,
 633        [FromQuery] int? maxHeight,
 634        [FromQuery] int? width,
 635        [FromQuery] int? height,
 636        [FromQuery] int? quality,
 637        [FromQuery] int? fillWidth,
 638        [FromQuery] int? fillHeight,
 639        [FromQuery] string? tag,
 640        [FromQuery] ImageFormat? format,
 641        [FromQuery] double? percentPlayed,
 642        [FromQuery] int? unplayedCount,
 643        [FromQuery] int? blur,
 644        [FromQuery] string? backgroundColor,
 645        [FromQuery] string? foregroundLayer)
 646    {
 647        var item = _libraryManager.GetItemById<BaseItem>(itemId, User.GetUserId());
 648        if (item is null)
 649        {
 650            return NotFound();
 651        }
 652
 653        return await GetImageInternal(
 654                itemId,
 655                imageType,
 656                imageIndex,
 657                tag,
 658                format,
 659                maxWidth,
 660                maxHeight,
 661                percentPlayed,
 662                unplayedCount,
 663                width,
 664                height,
 665                quality,
 666                fillWidth,
 667                fillHeight,
 668                blur,
 669                backgroundColor,
 670                foregroundLayer,
 671                item)
 672            .ConfigureAwait(false);
 673    }
 674
 675    /// <summary>
 676    /// Gets the item's image.
 677    /// </summary>
 678    /// <param name="itemId">Item id.</param>
 679    /// <param name="imageType">Image type.</param>
 680    /// <param name="maxWidth">The maximum image width to return.</param>
 681    /// <param name="maxHeight">The maximum image height to return.</param>
 682    /// <param name="width">The fixed image width to return.</param>
 683    /// <param name="height">The fixed image height to return.</param>
 684    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 685    /// <param name="fillWidth">Width of box to fill.</param>
 686    /// <param name="fillHeight">Height of box to fill.</param>
 687    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 688    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 689    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 690    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 691    /// <param name="blur">Optional. Blur image.</param>
 692    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 693    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 694    /// <param name="imageIndex">Image index.</param>
 695    /// <response code="200">Image stream returned.</response>
 696    /// <response code="404">Item not found.</response>
 697    /// <returns>
 698    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 699    /// or a <see cref="NotFoundResult"/> if item not found.
 700    /// </returns>
 701    [HttpGet("Items/{itemId}/Images/{imageType}/{imageIndex}/{tag}/{format}/{maxWidth}/{maxHeight}/{percentPlayed}/{unpl
 702    [HttpHead("Items/{itemId}/Images/{imageType}/{imageIndex}/{tag}/{format}/{maxWidth}/{maxHeight}/{percentPlayed}/{unp
 703    [ProducesResponseType(StatusCodes.Status200OK)]
 704    [ProducesResponseType(StatusCodes.Status404NotFound)]
 705    [ProducesImageFile]
 706    public async Task<ActionResult> GetItemImage2(
 707        [FromRoute, Required] Guid itemId,
 708        [FromRoute, Required] ImageType imageType,
 709        [FromRoute, Required] int maxWidth,
 710        [FromRoute, Required] int maxHeight,
 711        [FromQuery] int? width,
 712        [FromQuery] int? height,
 713        [FromQuery] int? quality,
 714        [FromQuery] int? fillWidth,
 715        [FromQuery] int? fillHeight,
 716        [FromRoute, Required] string tag,
 717        [FromRoute, Required] ImageFormat format,
 718        [FromRoute, Required] double percentPlayed,
 719        [FromRoute, Required] int unplayedCount,
 720        [FromQuery] int? blur,
 721        [FromQuery] string? backgroundColor,
 722        [FromQuery] string? foregroundLayer,
 723        [FromRoute, Required] int imageIndex)
 724    {
 725        var item = _libraryManager.GetItemById<BaseItem>(itemId, User.GetUserId());
 726        if (item is null)
 727        {
 728            return NotFound();
 729        }
 730
 731        return await GetImageInternal(
 732                itemId,
 733                imageType,
 734                imageIndex,
 735                tag,
 736                format,
 737                maxWidth,
 738                maxHeight,
 739                percentPlayed,
 740                unplayedCount,
 741                width,
 742                height,
 743                quality,
 744                fillWidth,
 745                fillHeight,
 746                blur,
 747                backgroundColor,
 748                foregroundLayer,
 749                item)
 750            .ConfigureAwait(false);
 751    }
 752
 753    /// <summary>
 754    /// Get artist image by name.
 755    /// </summary>
 756    /// <param name="name">Artist name.</param>
 757    /// <param name="imageType">Image type.</param>
 758    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 759    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 760    /// <param name="maxWidth">The maximum image width to return.</param>
 761    /// <param name="maxHeight">The maximum image height to return.</param>
 762    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 763    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 764    /// <param name="width">The fixed image width to return.</param>
 765    /// <param name="height">The fixed image height to return.</param>
 766    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 767    /// <param name="fillWidth">Width of box to fill.</param>
 768    /// <param name="fillHeight">Height of box to fill.</param>
 769    /// <param name="blur">Optional. Blur image.</param>
 770    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 771    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 772    /// <param name="imageIndex">Image index.</param>
 773    /// <response code="200">Image stream returned.</response>
 774    /// <response code="404">Item not found.</response>
 775    /// <returns>
 776    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 777    /// or a <see cref="NotFoundResult"/> if item not found.
 778    /// </returns>
 779    [HttpGet("Artists/{name}/Images/{imageType}/{imageIndex}")]
 780    [HttpHead("Artists/{name}/Images/{imageType}/{imageIndex}", Name = "HeadArtistImage")]
 781    [ProducesResponseType(StatusCodes.Status200OK)]
 782    [ProducesResponseType(StatusCodes.Status404NotFound)]
 783    [ProducesImageFile]
 784    public async Task<ActionResult> GetArtistImage(
 785        [FromRoute, Required] string name,
 786        [FromRoute, Required] ImageType imageType,
 787        [FromQuery] string? tag,
 788        [FromQuery] ImageFormat? format,
 789        [FromQuery] int? maxWidth,
 790        [FromQuery] int? maxHeight,
 791        [FromQuery] double? percentPlayed,
 792        [FromQuery] int? unplayedCount,
 793        [FromQuery] int? width,
 794        [FromQuery] int? height,
 795        [FromQuery] int? quality,
 796        [FromQuery] int? fillWidth,
 797        [FromQuery] int? fillHeight,
 798        [FromQuery] int? blur,
 799        [FromQuery] string? backgroundColor,
 800        [FromQuery] string? foregroundLayer,
 801        [FromRoute, Required] int imageIndex)
 802    {
 803        var item = _libraryManager.GetArtist(name);
 804        if (item is null)
 805        {
 806            return NotFound();
 807        }
 808
 809        return await GetImageInternal(
 810                item.Id,
 811                imageType,
 812                imageIndex,
 813                tag,
 814                format,
 815                maxWidth,
 816                maxHeight,
 817                percentPlayed,
 818                unplayedCount,
 819                width,
 820                height,
 821                quality,
 822                fillWidth,
 823                fillHeight,
 824                blur,
 825                backgroundColor,
 826                foregroundLayer,
 827                item)
 828            .ConfigureAwait(false);
 829    }
 830
 831    /// <summary>
 832    /// Get genre image by name.
 833    /// </summary>
 834    /// <param name="name">Genre name.</param>
 835    /// <param name="imageType">Image type.</param>
 836    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 837    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 838    /// <param name="maxWidth">The maximum image width to return.</param>
 839    /// <param name="maxHeight">The maximum image height to return.</param>
 840    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 841    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 842    /// <param name="width">The fixed image width to return.</param>
 843    /// <param name="height">The fixed image height to return.</param>
 844    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 845    /// <param name="fillWidth">Width of box to fill.</param>
 846    /// <param name="fillHeight">Height of box to fill.</param>
 847    /// <param name="blur">Optional. Blur image.</param>
 848    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 849    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 850    /// <param name="imageIndex">Image index.</param>
 851    /// <response code="200">Image stream returned.</response>
 852    /// <response code="404">Item not found.</response>
 853    /// <returns>
 854    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 855    /// or a <see cref="NotFoundResult"/> if item not found.
 856    /// </returns>
 857    [HttpGet("Genres/{name}/Images/{imageType}")]
 858    [HttpHead("Genres/{name}/Images/{imageType}", Name = "HeadGenreImage")]
 859    [ProducesResponseType(StatusCodes.Status200OK)]
 860    [ProducesResponseType(StatusCodes.Status404NotFound)]
 861    [ProducesImageFile]
 862    public async Task<ActionResult> GetGenreImage(
 863        [FromRoute, Required] string name,
 864        [FromRoute, Required] ImageType imageType,
 865        [FromQuery] string? tag,
 866        [FromQuery] ImageFormat? format,
 867        [FromQuery] int? maxWidth,
 868        [FromQuery] int? maxHeight,
 869        [FromQuery] double? percentPlayed,
 870        [FromQuery] int? unplayedCount,
 871        [FromQuery] int? width,
 872        [FromQuery] int? height,
 873        [FromQuery] int? quality,
 874        [FromQuery] int? fillWidth,
 875        [FromQuery] int? fillHeight,
 876        [FromQuery] int? blur,
 877        [FromQuery] string? backgroundColor,
 878        [FromQuery] string? foregroundLayer,
 879        [FromQuery] int? imageIndex)
 880    {
 881        var item = _libraryManager.GetGenre(name);
 882        if (item is null)
 883        {
 884            return NotFound();
 885        }
 886
 887        return await GetImageInternal(
 888                item.Id,
 889                imageType,
 890                imageIndex,
 891                tag,
 892                format,
 893                maxWidth,
 894                maxHeight,
 895                percentPlayed,
 896                unplayedCount,
 897                width,
 898                height,
 899                quality,
 900                fillWidth,
 901                fillHeight,
 902                blur,
 903                backgroundColor,
 904                foregroundLayer,
 905                item)
 906            .ConfigureAwait(false);
 907    }
 908
 909    /// <summary>
 910    /// Get genre image by name.
 911    /// </summary>
 912    /// <param name="name">Genre name.</param>
 913    /// <param name="imageType">Image type.</param>
 914    /// <param name="imageIndex">Image index.</param>
 915    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 916    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 917    /// <param name="maxWidth">The maximum image width to return.</param>
 918    /// <param name="maxHeight">The maximum image height to return.</param>
 919    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 920    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 921    /// <param name="width">The fixed image width to return.</param>
 922    /// <param name="height">The fixed image height to return.</param>
 923    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 924    /// <param name="fillWidth">Width of box to fill.</param>
 925    /// <param name="fillHeight">Height of box to fill.</param>
 926    /// <param name="blur">Optional. Blur image.</param>
 927    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 928    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 929    /// <response code="200">Image stream returned.</response>
 930    /// <response code="404">Item not found.</response>
 931    /// <returns>
 932    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 933    /// or a <see cref="NotFoundResult"/> if item not found.
 934    /// </returns>
 935    [HttpGet("Genres/{name}/Images/{imageType}/{imageIndex}")]
 936    [HttpHead("Genres/{name}/Images/{imageType}/{imageIndex}", Name = "HeadGenreImageByIndex")]
 937    [ProducesResponseType(StatusCodes.Status200OK)]
 938    [ProducesResponseType(StatusCodes.Status404NotFound)]
 939    [ProducesImageFile]
 940    public async Task<ActionResult> GetGenreImageByIndex(
 941        [FromRoute, Required] string name,
 942        [FromRoute, Required] ImageType imageType,
 943        [FromRoute, Required] int imageIndex,
 944        [FromQuery] string? tag,
 945        [FromQuery] ImageFormat? format,
 946        [FromQuery] int? maxWidth,
 947        [FromQuery] int? maxHeight,
 948        [FromQuery] double? percentPlayed,
 949        [FromQuery] int? unplayedCount,
 950        [FromQuery] int? width,
 951        [FromQuery] int? height,
 952        [FromQuery] int? quality,
 953        [FromQuery] int? fillWidth,
 954        [FromQuery] int? fillHeight,
 955        [FromQuery] int? blur,
 956        [FromQuery] string? backgroundColor,
 957        [FromQuery] string? foregroundLayer)
 958    {
 959        var item = _libraryManager.GetGenre(name);
 960        if (item is null)
 961        {
 962            return NotFound();
 963        }
 964
 965        return await GetImageInternal(
 966                item.Id,
 967                imageType,
 968                imageIndex,
 969                tag,
 970                format,
 971                maxWidth,
 972                maxHeight,
 973                percentPlayed,
 974                unplayedCount,
 975                width,
 976                height,
 977                quality,
 978                fillWidth,
 979                fillHeight,
 980                blur,
 981                backgroundColor,
 982                foregroundLayer,
 983                item)
 984            .ConfigureAwait(false);
 985    }
 986
 987    /// <summary>
 988    /// Get music genre image by name.
 989    /// </summary>
 990    /// <param name="name">Music genre name.</param>
 991    /// <param name="imageType">Image type.</param>
 992    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 993    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 994    /// <param name="maxWidth">The maximum image width to return.</param>
 995    /// <param name="maxHeight">The maximum image height to return.</param>
 996    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 997    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 998    /// <param name="width">The fixed image width to return.</param>
 999    /// <param name="height">The fixed image height to return.</param>
 1000    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 1001    /// <param name="fillWidth">Width of box to fill.</param>
 1002    /// <param name="fillHeight">Height of box to fill.</param>
 1003    /// <param name="blur">Optional. Blur image.</param>
 1004    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 1005    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 1006    /// <param name="imageIndex">Image index.</param>
 1007    /// <response code="200">Image stream returned.</response>
 1008    /// <response code="404">Item not found.</response>
 1009    /// <returns>
 1010    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 1011    /// or a <see cref="NotFoundResult"/> if item not found.
 1012    /// </returns>
 1013    [HttpGet("MusicGenres/{name}/Images/{imageType}")]
 1014    [HttpHead("MusicGenres/{name}/Images/{imageType}", Name = "HeadMusicGenreImage")]
 1015    [ProducesResponseType(StatusCodes.Status200OK)]
 1016    [ProducesResponseType(StatusCodes.Status404NotFound)]
 1017    [ProducesImageFile]
 1018    public async Task<ActionResult> GetMusicGenreImage(
 1019        [FromRoute, Required] string name,
 1020        [FromRoute, Required] ImageType imageType,
 1021        [FromQuery] string? tag,
 1022        [FromQuery] ImageFormat? format,
 1023        [FromQuery] int? maxWidth,
 1024        [FromQuery] int? maxHeight,
 1025        [FromQuery] double? percentPlayed,
 1026        [FromQuery] int? unplayedCount,
 1027        [FromQuery] int? width,
 1028        [FromQuery] int? height,
 1029        [FromQuery] int? quality,
 1030        [FromQuery] int? fillWidth,
 1031        [FromQuery] int? fillHeight,
 1032        [FromQuery] int? blur,
 1033        [FromQuery] string? backgroundColor,
 1034        [FromQuery] string? foregroundLayer,
 1035        [FromQuery] int? imageIndex)
 1036    {
 1037        var item = _libraryManager.GetMusicGenre(name);
 1038        if (item is null)
 1039        {
 1040            return NotFound();
 1041        }
 1042
 1043        return await GetImageInternal(
 1044                item.Id,
 1045                imageType,
 1046                imageIndex,
 1047                tag,
 1048                format,
 1049                maxWidth,
 1050                maxHeight,
 1051                percentPlayed,
 1052                unplayedCount,
 1053                width,
 1054                height,
 1055                quality,
 1056                fillWidth,
 1057                fillHeight,
 1058                blur,
 1059                backgroundColor,
 1060                foregroundLayer,
 1061                item)
 1062            .ConfigureAwait(false);
 1063    }
 1064
 1065    /// <summary>
 1066    /// Get music genre image by name.
 1067    /// </summary>
 1068    /// <param name="name">Music genre name.</param>
 1069    /// <param name="imageType">Image type.</param>
 1070    /// <param name="imageIndex">Image index.</param>
 1071    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 1072    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 1073    /// <param name="maxWidth">The maximum image width to return.</param>
 1074    /// <param name="maxHeight">The maximum image height to return.</param>
 1075    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 1076    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 1077    /// <param name="width">The fixed image width to return.</param>
 1078    /// <param name="height">The fixed image height to return.</param>
 1079    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 1080    /// <param name="fillWidth">Width of box to fill.</param>
 1081    /// <param name="fillHeight">Height of box to fill.</param>
 1082    /// <param name="blur">Optional. Blur image.</param>
 1083    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 1084    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 1085    /// <response code="200">Image stream returned.</response>
 1086    /// <response code="404">Item not found.</response>
 1087    /// <returns>
 1088    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 1089    /// or a <see cref="NotFoundResult"/> if item not found.
 1090    /// </returns>
 1091    [HttpGet("MusicGenres/{name}/Images/{imageType}/{imageIndex}")]
 1092    [HttpHead("MusicGenres/{name}/Images/{imageType}/{imageIndex}", Name = "HeadMusicGenreImageByIndex")]
 1093    [ProducesResponseType(StatusCodes.Status200OK)]
 1094    [ProducesResponseType(StatusCodes.Status404NotFound)]
 1095    [ProducesImageFile]
 1096    public async Task<ActionResult> GetMusicGenreImageByIndex(
 1097        [FromRoute, Required] string name,
 1098        [FromRoute, Required] ImageType imageType,
 1099        [FromRoute, Required] int imageIndex,
 1100        [FromQuery] string? tag,
 1101        [FromQuery] ImageFormat? format,
 1102        [FromQuery] int? maxWidth,
 1103        [FromQuery] int? maxHeight,
 1104        [FromQuery] double? percentPlayed,
 1105        [FromQuery] int? unplayedCount,
 1106        [FromQuery] int? width,
 1107        [FromQuery] int? height,
 1108        [FromQuery] int? quality,
 1109        [FromQuery] int? fillWidth,
 1110        [FromQuery] int? fillHeight,
 1111        [FromQuery] int? blur,
 1112        [FromQuery] string? backgroundColor,
 1113        [FromQuery] string? foregroundLayer)
 1114    {
 1115        var item = _libraryManager.GetMusicGenre(name);
 1116        if (item is null)
 1117        {
 1118            return NotFound();
 1119        }
 1120
 1121        return await GetImageInternal(
 1122                item.Id,
 1123                imageType,
 1124                imageIndex,
 1125                tag,
 1126                format,
 1127                maxWidth,
 1128                maxHeight,
 1129                percentPlayed,
 1130                unplayedCount,
 1131                width,
 1132                height,
 1133                quality,
 1134                fillWidth,
 1135                fillHeight,
 1136                blur,
 1137                backgroundColor,
 1138                foregroundLayer,
 1139                item)
 1140            .ConfigureAwait(false);
 1141    }
 1142
 1143    /// <summary>
 1144    /// Get person image by name.
 1145    /// </summary>
 1146    /// <param name="name">Person name.</param>
 1147    /// <param name="imageType">Image type.</param>
 1148    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 1149    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 1150    /// <param name="maxWidth">The maximum image width to return.</param>
 1151    /// <param name="maxHeight">The maximum image height to return.</param>
 1152    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 1153    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 1154    /// <param name="width">The fixed image width to return.</param>
 1155    /// <param name="height">The fixed image height to return.</param>
 1156    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 1157    /// <param name="fillWidth">Width of box to fill.</param>
 1158    /// <param name="fillHeight">Height of box to fill.</param>
 1159    /// <param name="blur">Optional. Blur image.</param>
 1160    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 1161    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 1162    /// <param name="imageIndex">Image index.</param>
 1163    /// <response code="200">Image stream returned.</response>
 1164    /// <response code="404">Item not found.</response>
 1165    /// <returns>
 1166    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 1167    /// or a <see cref="NotFoundResult"/> if item not found.
 1168    /// </returns>
 1169    [HttpGet("Persons/{name}/Images/{imageType}")]
 1170    [HttpHead("Persons/{name}/Images/{imageType}", Name = "HeadPersonImage")]
 1171    [ProducesResponseType(StatusCodes.Status200OK)]
 1172    [ProducesResponseType(StatusCodes.Status404NotFound)]
 1173    [ProducesImageFile]
 1174    public async Task<ActionResult> GetPersonImage(
 1175        [FromRoute, Required] string name,
 1176        [FromRoute, Required] ImageType imageType,
 1177        [FromQuery] string? tag,
 1178        [FromQuery] ImageFormat? format,
 1179        [FromQuery] int? maxWidth,
 1180        [FromQuery] int? maxHeight,
 1181        [FromQuery] double? percentPlayed,
 1182        [FromQuery] int? unplayedCount,
 1183        [FromQuery] int? width,
 1184        [FromQuery] int? height,
 1185        [FromQuery] int? quality,
 1186        [FromQuery] int? fillWidth,
 1187        [FromQuery] int? fillHeight,
 1188        [FromQuery] int? blur,
 1189        [FromQuery] string? backgroundColor,
 1190        [FromQuery] string? foregroundLayer,
 1191        [FromQuery] int? imageIndex)
 1192    {
 1193        var item = _libraryManager.GetPerson(name);
 1194        if (item is null)
 1195        {
 1196            return NotFound();
 1197        }
 1198
 1199        return await GetImageInternal(
 1200                item.Id,
 1201                imageType,
 1202                imageIndex,
 1203                tag,
 1204                format,
 1205                maxWidth,
 1206                maxHeight,
 1207                percentPlayed,
 1208                unplayedCount,
 1209                width,
 1210                height,
 1211                quality,
 1212                fillWidth,
 1213                fillHeight,
 1214                blur,
 1215                backgroundColor,
 1216                foregroundLayer,
 1217                item)
 1218            .ConfigureAwait(false);
 1219    }
 1220
 1221    /// <summary>
 1222    /// Get person image by name.
 1223    /// </summary>
 1224    /// <param name="name">Person name.</param>
 1225    /// <param name="imageType">Image type.</param>
 1226    /// <param name="imageIndex">Image index.</param>
 1227    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 1228    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 1229    /// <param name="maxWidth">The maximum image width to return.</param>
 1230    /// <param name="maxHeight">The maximum image height to return.</param>
 1231    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 1232    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 1233    /// <param name="width">The fixed image width to return.</param>
 1234    /// <param name="height">The fixed image height to return.</param>
 1235    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 1236    /// <param name="fillWidth">Width of box to fill.</param>
 1237    /// <param name="fillHeight">Height of box to fill.</param>
 1238    /// <param name="blur">Optional. Blur image.</param>
 1239    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 1240    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 1241    /// <response code="200">Image stream returned.</response>
 1242    /// <response code="404">Item not found.</response>
 1243    /// <returns>
 1244    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 1245    /// or a <see cref="NotFoundResult"/> if item not found.
 1246    /// </returns>
 1247    [HttpGet("Persons/{name}/Images/{imageType}/{imageIndex}")]
 1248    [HttpHead("Persons/{name}/Images/{imageType}/{imageIndex}", Name = "HeadPersonImageByIndex")]
 1249    [ProducesResponseType(StatusCodes.Status200OK)]
 1250    [ProducesResponseType(StatusCodes.Status404NotFound)]
 1251    [ProducesImageFile]
 1252    public async Task<ActionResult> GetPersonImageByIndex(
 1253        [FromRoute, Required] string name,
 1254        [FromRoute, Required] ImageType imageType,
 1255        [FromRoute, Required] int imageIndex,
 1256        [FromQuery] string? tag,
 1257        [FromQuery] ImageFormat? format,
 1258        [FromQuery] int? maxWidth,
 1259        [FromQuery] int? maxHeight,
 1260        [FromQuery] double? percentPlayed,
 1261        [FromQuery] int? unplayedCount,
 1262        [FromQuery] int? width,
 1263        [FromQuery] int? height,
 1264        [FromQuery] int? quality,
 1265        [FromQuery] int? fillWidth,
 1266        [FromQuery] int? fillHeight,
 1267        [FromQuery] int? blur,
 1268        [FromQuery] string? backgroundColor,
 1269        [FromQuery] string? foregroundLayer)
 1270    {
 1271        var item = _libraryManager.GetPerson(name);
 1272        if (item is null)
 1273        {
 1274            return NotFound();
 1275        }
 1276
 1277        return await GetImageInternal(
 1278                item.Id,
 1279                imageType,
 1280                imageIndex,
 1281                tag,
 1282                format,
 1283                maxWidth,
 1284                maxHeight,
 1285                percentPlayed,
 1286                unplayedCount,
 1287                width,
 1288                height,
 1289                quality,
 1290                fillWidth,
 1291                fillHeight,
 1292                blur,
 1293                backgroundColor,
 1294                foregroundLayer,
 1295                item)
 1296            .ConfigureAwait(false);
 1297    }
 1298
 1299    /// <summary>
 1300    /// Get studio image by name.
 1301    /// </summary>
 1302    /// <param name="name">Studio name.</param>
 1303    /// <param name="imageType">Image type.</param>
 1304    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 1305    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 1306    /// <param name="maxWidth">The maximum image width to return.</param>
 1307    /// <param name="maxHeight">The maximum image height to return.</param>
 1308    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 1309    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 1310    /// <param name="width">The fixed image width to return.</param>
 1311    /// <param name="height">The fixed image height to return.</param>
 1312    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 1313    /// <param name="fillWidth">Width of box to fill.</param>
 1314    /// <param name="fillHeight">Height of box to fill.</param>
 1315    /// <param name="blur">Optional. Blur image.</param>
 1316    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 1317    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 1318    /// <param name="imageIndex">Image index.</param>
 1319    /// <response code="200">Image stream returned.</response>
 1320    /// <response code="404">Item not found.</response>
 1321    /// <returns>
 1322    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 1323    /// or a <see cref="NotFoundResult"/> if item not found.
 1324    /// </returns>
 1325    [HttpGet("Studios/{name}/Images/{imageType}")]
 1326    [HttpHead("Studios/{name}/Images/{imageType}", Name = "HeadStudioImage")]
 1327    [ProducesResponseType(StatusCodes.Status200OK)]
 1328    [ProducesResponseType(StatusCodes.Status404NotFound)]
 1329    [ProducesImageFile]
 1330    public async Task<ActionResult> GetStudioImage(
 1331        [FromRoute, Required] string name,
 1332        [FromRoute, Required] ImageType imageType,
 1333        [FromQuery] string? tag,
 1334        [FromQuery] ImageFormat? format,
 1335        [FromQuery] int? maxWidth,
 1336        [FromQuery] int? maxHeight,
 1337        [FromQuery] double? percentPlayed,
 1338        [FromQuery] int? unplayedCount,
 1339        [FromQuery] int? width,
 1340        [FromQuery] int? height,
 1341        [FromQuery] int? quality,
 1342        [FromQuery] int? fillWidth,
 1343        [FromQuery] int? fillHeight,
 1344        [FromQuery] int? blur,
 1345        [FromQuery] string? backgroundColor,
 1346        [FromQuery] string? foregroundLayer,
 1347        [FromQuery] int? imageIndex)
 1348    {
 1349        var item = _libraryManager.GetStudio(name);
 1350        if (item is null)
 1351        {
 1352            return NotFound();
 1353        }
 1354
 1355        return await GetImageInternal(
 1356                item.Id,
 1357                imageType,
 1358                imageIndex,
 1359                tag,
 1360                format,
 1361                maxWidth,
 1362                maxHeight,
 1363                percentPlayed,
 1364                unplayedCount,
 1365                width,
 1366                height,
 1367                quality,
 1368                fillWidth,
 1369                fillHeight,
 1370                blur,
 1371                backgroundColor,
 1372                foregroundLayer,
 1373                item)
 1374            .ConfigureAwait(false);
 1375    }
 1376
 1377    /// <summary>
 1378    /// Get studio image by name.
 1379    /// </summary>
 1380    /// <param name="name">Studio name.</param>
 1381    /// <param name="imageType">Image type.</param>
 1382    /// <param name="imageIndex">Image index.</param>
 1383    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 1384    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 1385    /// <param name="maxWidth">The maximum image width to return.</param>
 1386    /// <param name="maxHeight">The maximum image height to return.</param>
 1387    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 1388    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 1389    /// <param name="width">The fixed image width to return.</param>
 1390    /// <param name="height">The fixed image height to return.</param>
 1391    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 1392    /// <param name="fillWidth">Width of box to fill.</param>
 1393    /// <param name="fillHeight">Height of box to fill.</param>
 1394    /// <param name="blur">Optional. Blur image.</param>
 1395    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 1396    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 1397    /// <response code="200">Image stream returned.</response>
 1398    /// <response code="404">Item not found.</response>
 1399    /// <returns>
 1400    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 1401    /// or a <see cref="NotFoundResult"/> if item not found.
 1402    /// </returns>
 1403    [HttpGet("Studios/{name}/Images/{imageType}/{imageIndex}")]
 1404    [HttpHead("Studios/{name}/Images/{imageType}/{imageIndex}", Name = "HeadStudioImageByIndex")]
 1405    [ProducesResponseType(StatusCodes.Status200OK)]
 1406    [ProducesResponseType(StatusCodes.Status404NotFound)]
 1407    [ProducesImageFile]
 1408    public async Task<ActionResult> GetStudioImageByIndex(
 1409        [FromRoute, Required] string name,
 1410        [FromRoute, Required] ImageType imageType,
 1411        [FromRoute, Required] int imageIndex,
 1412        [FromQuery] string? tag,
 1413        [FromQuery] ImageFormat? format,
 1414        [FromQuery] int? maxWidth,
 1415        [FromQuery] int? maxHeight,
 1416        [FromQuery] double? percentPlayed,
 1417        [FromQuery] int? unplayedCount,
 1418        [FromQuery] int? width,
 1419        [FromQuery] int? height,
 1420        [FromQuery] int? quality,
 1421        [FromQuery] int? fillWidth,
 1422        [FromQuery] int? fillHeight,
 1423        [FromQuery] int? blur,
 1424        [FromQuery] string? backgroundColor,
 1425        [FromQuery] string? foregroundLayer)
 1426    {
 1427        var item = _libraryManager.GetStudio(name);
 1428        if (item is null)
 1429        {
 1430            return NotFound();
 1431        }
 1432
 1433        return await GetImageInternal(
 1434                item.Id,
 1435                imageType,
 1436                imageIndex,
 1437                tag,
 1438                format,
 1439                maxWidth,
 1440                maxHeight,
 1441                percentPlayed,
 1442                unplayedCount,
 1443                width,
 1444                height,
 1445                quality,
 1446                fillWidth,
 1447                fillHeight,
 1448                blur,
 1449                backgroundColor,
 1450                foregroundLayer,
 1451                item)
 1452            .ConfigureAwait(false);
 1453    }
 1454
 1455    /// <summary>
 1456    /// Get user profile image.
 1457    /// </summary>
 1458    /// <param name="userId">User id.</param>
 1459    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 1460    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 1461    /// <param name="maxWidth">The maximum image width to return.</param>
 1462    /// <param name="maxHeight">The maximum image height to return.</param>
 1463    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 1464    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 1465    /// <param name="width">The fixed image width to return.</param>
 1466    /// <param name="height">The fixed image height to return.</param>
 1467    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 1468    /// <param name="fillWidth">Width of box to fill.</param>
 1469    /// <param name="fillHeight">Height of box to fill.</param>
 1470    /// <param name="blur">Optional. Blur image.</param>
 1471    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 1472    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 1473    /// <param name="imageIndex">Image index.</param>
 1474    /// <response code="200">Image stream returned.</response>
 1475    /// <response code="400">User id not provided.</response>
 1476    /// <response code="404">Item not found.</response>
 1477    /// <returns>
 1478    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 1479    /// or a <see cref="NotFoundResult"/> if item not found.
 1480    /// </returns>
 1481    [HttpGet("UserImage")]
 1482    [HttpHead("UserImage", Name = "HeadUserImage")]
 1483    [ProducesResponseType(StatusCodes.Status200OK)]
 1484    [ProducesResponseType(StatusCodes.Status400BadRequest)]
 1485    [ProducesResponseType(StatusCodes.Status404NotFound)]
 1486    [ProducesImageFile]
 1487    public async Task<ActionResult> GetUserImage(
 1488        [FromQuery] Guid? userId,
 1489        [FromQuery] string? tag,
 1490        [FromQuery] ImageFormat? format,
 1491        [FromQuery] int? maxWidth,
 1492        [FromQuery] int? maxHeight,
 1493        [FromQuery] double? percentPlayed,
 1494        [FromQuery] int? unplayedCount,
 1495        [FromQuery] int? width,
 1496        [FromQuery] int? height,
 1497        [FromQuery] int? quality,
 1498        [FromQuery] int? fillWidth,
 1499        [FromQuery] int? fillHeight,
 1500        [FromQuery] int? blur,
 1501        [FromQuery] string? backgroundColor,
 1502        [FromQuery] string? foregroundLayer,
 1503        [FromQuery] int? imageIndex)
 1504    {
 1505        var requestUserId = userId ?? User.GetUserId();
 1506        if (requestUserId.IsEmpty())
 1507        {
 1508            return BadRequest("UserId is required if unauthenticated");
 1509        }
 1510
 1511        var user = _userManager.GetUserById(requestUserId);
 1512        if (user?.ProfileImage is null)
 1513        {
 1514            return NotFound();
 1515        }
 1516
 1517        var info = new ItemImageInfo
 1518        {
 1519            Path = user.ProfileImage.Path,
 1520            Type = ImageType.Profile,
 1521            DateModified = user.ProfileImage.LastModified
 1522        };
 1523
 1524        if (width.HasValue)
 1525        {
 1526            info.Width = width.Value;
 1527        }
 1528
 1529        if (height.HasValue)
 1530        {
 1531            info.Height = height.Value;
 1532        }
 1533
 1534        return await GetImageInternal(
 1535                user.Id,
 1536                ImageType.Profile,
 1537                imageIndex,
 1538                tag,
 1539                format,
 1540                maxWidth,
 1541                maxHeight,
 1542                percentPlayed,
 1543                unplayedCount,
 1544                width,
 1545                height,
 1546                quality,
 1547                fillWidth,
 1548                fillHeight,
 1549                blur,
 1550                backgroundColor,
 1551                foregroundLayer,
 1552                null,
 1553                info)
 1554            .ConfigureAwait(false);
 1555    }
 1556
 1557    /// <summary>
 1558    /// Get user profile image.
 1559    /// </summary>
 1560    /// <param name="userId">User id.</param>
 1561    /// <param name="imageType">Image type.</param>
 1562    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 1563    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 1564    /// <param name="maxWidth">The maximum image width to return.</param>
 1565    /// <param name="maxHeight">The maximum image height to return.</param>
 1566    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 1567    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 1568    /// <param name="width">The fixed image width to return.</param>
 1569    /// <param name="height">The fixed image height to return.</param>
 1570    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 1571    /// <param name="fillWidth">Width of box to fill.</param>
 1572    /// <param name="fillHeight">Height of box to fill.</param>
 1573    /// <param name="blur">Optional. Blur image.</param>
 1574    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 1575    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 1576    /// <param name="imageIndex">Image index.</param>
 1577    /// <response code="200">Image stream returned.</response>
 1578    /// <response code="404">Item not found.</response>
 1579    /// <returns>
 1580    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 1581    /// or a <see cref="NotFoundResult"/> if item not found.
 1582    /// </returns>
 1583    [HttpGet("Users/{userId}/Images/{imageType}")]
 1584    [HttpHead("Users/{userId}/Images/{imageType}", Name = "HeadUserImageLegacy")]
 1585    [Obsolete("Kept for backwards compatibility")]
 1586    [ApiExplorerSettings(IgnoreApi = true)]
 1587    [ProducesResponseType(StatusCodes.Status200OK)]
 1588    [ProducesResponseType(StatusCodes.Status404NotFound)]
 1589    [ProducesImageFile]
 1590    public Task<ActionResult> GetUserImageLegacy(
 1591        [FromRoute, Required] Guid userId,
 1592        [FromRoute, Required] ImageType imageType,
 1593        [FromQuery] string? tag,
 1594        [FromQuery] ImageFormat? format,
 1595        [FromQuery] int? maxWidth,
 1596        [FromQuery] int? maxHeight,
 1597        [FromQuery] double? percentPlayed,
 1598        [FromQuery] int? unplayedCount,
 1599        [FromQuery] int? width,
 1600        [FromQuery] int? height,
 1601        [FromQuery] int? quality,
 1602        [FromQuery] int? fillWidth,
 1603        [FromQuery] int? fillHeight,
 1604        [FromQuery] int? blur,
 1605        [FromQuery] string? backgroundColor,
 1606        [FromQuery] string? foregroundLayer,
 1607        [FromQuery] int? imageIndex)
 1608        => GetUserImage(
 1609            userId,
 1610            tag,
 1611            format,
 1612            maxWidth,
 1613            maxHeight,
 1614            percentPlayed,
 1615            unplayedCount,
 1616            width,
 1617            height,
 1618            quality,
 1619            fillWidth,
 1620            fillHeight,
 1621            blur,
 1622            backgroundColor,
 1623            foregroundLayer,
 1624            imageIndex);
 1625
 1626    /// <summary>
 1627    /// Get user profile image.
 1628    /// </summary>
 1629    /// <param name="userId">User id.</param>
 1630    /// <param name="imageType">Image type.</param>
 1631    /// <param name="imageIndex">Image index.</param>
 1632    /// <param name="tag">Optional. Supply the cache tag from the item object to receive strong caching headers.</param>
 1633    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 1634    /// <param name="maxWidth">The maximum image width to return.</param>
 1635    /// <param name="maxHeight">The maximum image height to return.</param>
 1636    /// <param name="percentPlayed">Optional. Percent to render for the percent played overlay.</param>
 1637    /// <param name="unplayedCount">Optional. Unplayed count overlay to render.</param>
 1638    /// <param name="width">The fixed image width to return.</param>
 1639    /// <param name="height">The fixed image height to return.</param>
 1640    /// <param name="quality">Optional. Quality setting, from 0-100. Defaults to 90 and should suffice in most cases.</p
 1641    /// <param name="fillWidth">Width of box to fill.</param>
 1642    /// <param name="fillHeight">Height of box to fill.</param>
 1643    /// <param name="blur">Optional. Blur image.</param>
 1644    /// <param name="backgroundColor">Optional. Apply a background color for transparent images.</param>
 1645    /// <param name="foregroundLayer">Optional. Apply a foreground layer on top of the image.</param>
 1646    /// <response code="200">Image stream returned.</response>
 1647    /// <response code="404">Item not found.</response>
 1648    /// <returns>
 1649    /// A <see cref="FileStreamResult"/> containing the file stream on success,
 1650    /// or a <see cref="NotFoundResult"/> if item not found.
 1651    /// </returns>
 1652    [HttpGet("Users/{userId}/Images/{imageType}/{imageIndex}")]
 1653    [HttpHead("Users/{userId}/Images/{imageType}/{imageIndex}", Name = "HeadUserImageByIndexLegacy")]
 1654    [Obsolete("Kept for backwards compatibility")]
 1655    [ApiExplorerSettings(IgnoreApi = true)]
 1656    [ProducesResponseType(StatusCodes.Status200OK)]
 1657    [ProducesResponseType(StatusCodes.Status404NotFound)]
 1658    [ProducesImageFile]
 1659    public Task<ActionResult> GetUserImageByIndexLegacy(
 1660        [FromRoute, Required] Guid userId,
 1661        [FromRoute, Required] ImageType imageType,
 1662        [FromRoute, Required] int imageIndex,
 1663        [FromQuery] string? tag,
 1664        [FromQuery] ImageFormat? format,
 1665        [FromQuery] int? maxWidth,
 1666        [FromQuery] int? maxHeight,
 1667        [FromQuery] double? percentPlayed,
 1668        [FromQuery] int? unplayedCount,
 1669        [FromQuery] int? width,
 1670        [FromQuery] int? height,
 1671        [FromQuery] int? quality,
 1672        [FromQuery] int? fillWidth,
 1673        [FromQuery] int? fillHeight,
 1674        [FromQuery] int? blur,
 1675        [FromQuery] string? backgroundColor,
 1676        [FromQuery] string? foregroundLayer)
 1677        => GetUserImage(
 1678            userId,
 1679            tag,
 1680            format,
 1681            maxWidth,
 1682            maxHeight,
 1683            percentPlayed,
 1684            unplayedCount,
 1685            width,
 1686            height,
 1687            quality,
 1688            fillWidth,
 1689            fillHeight,
 1690            blur,
 1691            backgroundColor,
 1692            foregroundLayer,
 1693            imageIndex);
 1694
 1695    /// <summary>
 1696    /// Generates or gets the splashscreen.
 1697    /// </summary>
 1698    /// <param name="tag">Supply the cache tag from the item object to receive strong caching headers.</param>
 1699    /// <param name="format">Determines the output format of the image - original,gif,jpg,png.</param>
 1700    /// <param name="maxWidth">The maximum image width to return.</param>
 1701    /// <param name="maxHeight">The maximum image height to return.</param>
 1702    /// <param name="width">The fixed image width to return.</param>
 1703    /// <param name="height">The fixed image height to return.</param>
 1704    /// <param name="fillWidth">Width of box to fill.</param>
 1705    /// <param name="fillHeight">Height of box to fill.</param>
 1706    /// <param name="blur">Blur image.</param>
 1707    /// <param name="backgroundColor">Apply a background color for transparent images.</param>
 1708    /// <param name="foregroundLayer">Apply a foreground layer on top of the image.</param>
 1709    /// <param name="quality">Quality setting, from 0-100.</param>
 1710    /// <response code="200">Splashscreen returned successfully.</response>
 1711    /// <returns>The splashscreen.</returns>
 1712    [HttpGet("Branding/Splashscreen")]
 1713    [ProducesResponseType(StatusCodes.Status200OK)]
 1714    [ProducesImageFile]
 1715    public async Task<ActionResult> GetSplashscreen(
 1716        [FromQuery] string? tag,
 1717        [FromQuery] ImageFormat? format,
 1718        [FromQuery] int? maxWidth,
 1719        [FromQuery] int? maxHeight,
 1720        [FromQuery] int? width,
 1721        [FromQuery] int? height,
 1722        [FromQuery] int? fillWidth,
 1723        [FromQuery] int? fillHeight,
 1724        [FromQuery] int? blur,
 1725        [FromQuery] string? backgroundColor,
 1726        [FromQuery] string? foregroundLayer,
 1727        [FromQuery, Range(0, 100)] int quality = 90)
 1728    {
 1729        var brandingOptions = _serverConfigurationManager.GetConfiguration<BrandingOptions>("branding");
 1730        var isAdmin = User.IsInRole(Constants.UserRoles.Administrator);
 1731        if (!brandingOptions.SplashscreenEnabled && !isAdmin)
 1732        {
 1733            return NotFound();
 1734        }
 1735
 1736        string splashscreenPath;
 1737
 1738        if (!string.IsNullOrWhiteSpace(brandingOptions.SplashscreenLocation)
 1739            && System.IO.File.Exists(brandingOptions.SplashscreenLocation))
 1740        {
 1741            splashscreenPath = brandingOptions.SplashscreenLocation;
 1742        }
 1743        else
 1744        {
 1745            splashscreenPath = Path.Combine(_appPaths.DataPath, "splashscreen.png");
 1746            if (!System.IO.File.Exists(splashscreenPath))
 1747            {
 1748                return NotFound();
 1749            }
 1750        }
 1751
 1752        var outputFormats = GetOutputFormats(format);
 1753
 1754        TimeSpan? cacheDuration = null;
 1755        if (!string.IsNullOrEmpty(tag))
 1756        {
 1757            cacheDuration = TimeSpan.FromDays(365);
 1758        }
 1759
 1760        var options = new ImageProcessingOptions
 1761        {
 1762            Image = new ItemImageInfo
 1763            {
 1764                Path = splashscreenPath
 1765            },
 1766            Height = height,
 1767            MaxHeight = maxHeight,
 1768            MaxWidth = maxWidth,
 1769            FillHeight = fillHeight,
 1770            FillWidth = fillWidth,
 1771            Quality = quality,
 1772            Width = width,
 1773            Blur = blur,
 1774            BackgroundColor = backgroundColor,
 1775            ForegroundLayer = foregroundLayer,
 1776            SupportedOutputFormats = outputFormats
 1777        };
 1778
 1779        return await GetImageResult(
 1780                options,
 1781                cacheDuration,
 1782                ImmutableDictionary<string, string>.Empty)
 1783            .ConfigureAwait(false);
 1784    }
 1785
 1786    /// <summary>
 1787    /// Uploads a custom splashscreen.
 1788    /// The body is expected to the image contents base64 encoded.
 1789    /// </summary>
 1790    /// <returns>A <see cref="NoContentResult"/> indicating success.</returns>
 1791    /// <response code="204">Successfully uploaded new splashscreen.</response>
 1792    /// <response code="400">Error reading MimeType from uploaded image.</response>
 1793    /// <response code="403">User does not have permission to upload splashscreen..</response>
 1794    /// <exception cref="ArgumentException">Error reading the image format.</exception>
 1795    [HttpPost("Branding/Splashscreen")]
 1796    [Authorize(Policy = Policies.RequiresElevation)]
 1797    [ProducesResponseType(StatusCodes.Status204NoContent)]
 1798    [ProducesResponseType(StatusCodes.Status400BadRequest)]
 1799    [ProducesResponseType(StatusCodes.Status403Forbidden)]
 1800    [AcceptsImageFile]
 1801    public async Task<ActionResult> UploadCustomSplashscreen()
 1802    {
 1803        if (!TryGetImageExtensionFromContentType(Request.ContentType, out var extension))
 1804        {
 1805            return BadRequest("Incorrect ContentType.");
 1806        }
 1807
 1808        var stream = GetFromBase64Stream(Request.Body);
 1809        await using (stream.ConfigureAwait(false))
 1810        {
 1811            var filePath = Path.Combine(_appPaths.DataPath, "splashscreen-upload" + extension);
 1812            var brandingOptions = _serverConfigurationManager.GetConfiguration<BrandingOptions>("branding");
 1813            brandingOptions.SplashscreenLocation = filePath;
 1814            _serverConfigurationManager.SaveConfiguration("branding", brandingOptions);
 1815
 1816            var fs = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.None, IODefaults.FileStreamBu
 1817            await using (fs.ConfigureAwait(false))
 1818            {
 1819                await stream.CopyToAsync(fs, CancellationToken.None).ConfigureAwait(false);
 1820            }
 1821
 1822            return NoContent();
 1823        }
 1824    }
 1825
 1826    /// <summary>
 1827    /// Delete a custom splashscreen.
 1828    /// </summary>
 1829    /// <returns>A <see cref="NoContentResult"/> indicating success.</returns>
 1830    /// <response code="204">Successfully deleted the custom splashscreen.</response>
 1831    /// <response code="403">User does not have permission to delete splashscreen..</response>
 1832    [HttpDelete("Branding/Splashscreen")]
 1833    [Authorize(Policy = Policies.RequiresElevation)]
 1834    [ProducesResponseType(StatusCodes.Status204NoContent)]
 1835    public ActionResult DeleteCustomSplashscreen()
 1836    {
 01837        var brandingOptions = _serverConfigurationManager.GetConfiguration<BrandingOptions>("branding");
 01838        if (!string.IsNullOrEmpty(brandingOptions.SplashscreenLocation)
 01839            && System.IO.File.Exists(brandingOptions.SplashscreenLocation))
 1840        {
 01841            System.IO.File.Delete(brandingOptions.SplashscreenLocation);
 01842            brandingOptions.SplashscreenLocation = null;
 01843            _serverConfigurationManager.SaveConfiguration("branding", brandingOptions);
 1844        }
 1845
 01846        return NoContent();
 1847    }
 1848
 1849    private ImageInfo? GetImageInfo(BaseItem item, ItemImageInfo info, int? imageIndex)
 1850    {
 01851        int? width = null;
 01852        int? height = null;
 01853        string? blurhash = null;
 01854        long length = 0;
 1855
 1856        try
 1857        {
 01858            if (info.IsLocalFile)
 1859            {
 01860                var fileInfo = _fileSystem.GetFileInfo(info.Path);
 01861                length = fileInfo.Length;
 1862
 01863                blurhash = info.BlurHash;
 01864                width = info.Width;
 01865                height = info.Height;
 1866
 01867                if (width <= 0 || height <= 0)
 1868                {
 01869                    width = null;
 01870                    height = null;
 1871                }
 1872            }
 01873        }
 01874        catch (Exception ex)
 1875        {
 01876            _logger.LogError(ex, "Error getting image information for {Item}", item.Name);
 01877        }
 1878
 1879        try
 1880        {
 01881            return new ImageInfo
 01882            {
 01883                Path = info.Path,
 01884                ImageIndex = imageIndex,
 01885                ImageType = info.Type,
 01886                ImageTag = _imageProcessor.GetImageCacheTag(item, info),
 01887                Size = length,
 01888                BlurHash = blurhash,
 01889                Width = width,
 01890                Height = height
 01891            };
 1892        }
 01893        catch (Exception ex)
 1894        {
 01895            _logger.LogError(ex, "Error getting image information for {Path}", info.Path);
 01896            return null;
 1897        }
 01898    }
 1899
 1900    private async Task<ActionResult> GetImageInternal(
 1901        Guid itemId,
 1902        ImageType imageType,
 1903        int? imageIndex,
 1904        string? tag,
 1905        ImageFormat? format,
 1906        int? maxWidth,
 1907        int? maxHeight,
 1908        double? percentPlayed,
 1909        int? unplayedCount,
 1910        int? width,
 1911        int? height,
 1912        int? quality,
 1913        int? fillWidth,
 1914        int? fillHeight,
 1915        int? blur,
 1916        string? backgroundColor,
 1917        string? foregroundLayer,
 1918        BaseItem? item,
 1919        ItemImageInfo? imageInfo = null)
 1920    {
 1921        if (percentPlayed.HasValue)
 1922        {
 1923            if (percentPlayed.Value <= 0)
 1924            {
 1925                percentPlayed = null;
 1926            }
 1927            else if (percentPlayed.Value >= 100)
 1928            {
 1929                percentPlayed = null;
 1930            }
 1931        }
 1932
 1933        if (percentPlayed.HasValue)
 1934        {
 1935            unplayedCount = null;
 1936        }
 1937
 1938        if (unplayedCount.HasValue
 1939            && unplayedCount.Value <= 0)
 1940        {
 1941            unplayedCount = null;
 1942        }
 1943
 1944        if (imageInfo is null)
 1945        {
 1946            imageInfo = item?.GetImageInfo(imageType, imageIndex ?? 0);
 1947            if (imageInfo is null)
 1948            {
 1949                return NotFound(string.Format(NumberFormatInfo.InvariantInfo, "{0} does not have an image of type {1}", 
 1950            }
 1951        }
 1952
 1953        var outputFormats = GetOutputFormats(format);
 1954
 1955        TimeSpan? cacheDuration = null;
 1956
 1957        if (!string.IsNullOrEmpty(tag))
 1958        {
 1959            cacheDuration = TimeSpan.FromDays(365);
 1960        }
 1961
 1962        var responseHeaders = new Dictionary<string, string>
 1963        {
 1964            { "transferMode.dlna.org", "Interactive" },
 1965            { "realTimeInfo.dlna.org", "DLNA.ORG_TLAG=*" }
 1966        };
 1967
 1968        if (!imageInfo.IsLocalFile && item is not null)
 1969        {
 1970            imageInfo = await _libraryManager.ConvertImageToLocal(item, imageInfo, imageIndex ?? 0).ConfigureAwait(false
 1971        }
 1972
 1973        var options = new ImageProcessingOptions
 1974        {
 1975            Height = height,
 1976            ImageIndex = imageIndex ?? 0,
 1977            Image = imageInfo,
 1978            Item = item,
 1979            ItemId = itemId,
 1980            MaxHeight = maxHeight,
 1981            MaxWidth = maxWidth,
 1982            FillHeight = fillHeight,
 1983            FillWidth = fillWidth,
 1984            Quality = quality ?? 100,
 1985            Width = width,
 1986            PercentPlayed = percentPlayed ?? 0,
 1987            UnplayedCount = unplayedCount,
 1988            Blur = blur,
 1989            BackgroundColor = backgroundColor,
 1990            ForegroundLayer = foregroundLayer,
 1991            SupportedOutputFormats = outputFormats
 1992        };
 1993
 1994        return await GetImageResult(
 1995            options,
 1996            cacheDuration,
 1997            responseHeaders).ConfigureAwait(false);
 1998    }
 1999
 2000    private ImageFormat[] GetOutputFormats(ImageFormat? format)
 2001    {
 02002        if (format.HasValue)
 2003        {
 02004            return [format.Value];
 2005        }
 2006
 02007        return GetClientSupportedFormats();
 2008    }
 2009
 2010    private ImageFormat[] GetClientSupportedFormats()
 2011    {
 02012        var supportedFormats = Request.Headers.GetCommaSeparatedValues(HeaderNames.Accept);
 02013        for (var i = 0; i < supportedFormats.Length; i++)
 2014        {
 2015            // Remove charsets etc. (anything after semi-colon)
 02016            var type = supportedFormats[i];
 02017            int index = type.IndexOf(';', StringComparison.Ordinal);
 02018            if (index != -1)
 2019            {
 02020                supportedFormats[i] = type.Substring(0, index);
 2021            }
 2022        }
 2023
 02024        var acceptParam = Request.Query[HeaderNames.Accept];
 2025
 02026        var supportsWebP = SupportsFormat(supportedFormats, acceptParam, ImageFormat.Webp, false);
 2027
 02028        if (!supportsWebP)
 2029        {
 02030            var userAgent = Request.Headers[HeaderNames.UserAgent].ToString();
 02031            if (userAgent.Contains("crosswalk", StringComparison.OrdinalIgnoreCase)
 02032                && userAgent.Contains("android", StringComparison.OrdinalIgnoreCase))
 2033            {
 02034                supportsWebP = true;
 2035            }
 2036        }
 2037
 02038        var formats = new List<ImageFormat>(4);
 2039
 02040        if (supportsWebP)
 2041        {
 02042            formats.Add(ImageFormat.Webp);
 2043        }
 2044
 02045        formats.Add(ImageFormat.Jpg);
 02046        formats.Add(ImageFormat.Png);
 2047
 02048        if (SupportsFormat(supportedFormats, acceptParam, ImageFormat.Gif, true))
 2049        {
 02050            formats.Add(ImageFormat.Gif);
 2051        }
 2052
 02053        return formats.ToArray();
 2054    }
 2055
 2056    private bool SupportsFormat(IReadOnlyCollection<string> requestAcceptTypes, string? acceptParam, ImageFormat format,
 2057    {
 02058        if (requestAcceptTypes.Contains(format.GetMimeType()))
 2059        {
 02060            return true;
 2061        }
 2062
 02063        if (acceptAll && requestAcceptTypes.Contains("*/*"))
 2064        {
 02065            return true;
 2066        }
 2067
 2068        // Review if this should be jpeg, jpg or both for ImageFormat.Jpg
 02069        var normalized = format.ToString().ToLowerInvariant();
 02070        return string.Equals(acceptParam, normalized, StringComparison.OrdinalIgnoreCase);
 2071    }
 2072
 2073    private async Task<ActionResult> GetImageResult(
 2074        ImageProcessingOptions imageProcessingOptions,
 2075        TimeSpan? cacheDuration,
 2076        IDictionary<string, string> headers)
 2077    {
 2078        var (imagePath, imageContentType, dateImageModified) = await _imageProcessor.ProcessImage(imageProcessingOptions
 2079
 2080        var disableCaching = Request.Headers[HeaderNames.CacheControl].Contains("no-cache");
 2081        var parsingSuccessful = DateTime.TryParse(Request.Headers[HeaderNames.IfModifiedSince], out var ifModifiedSinceH
 2082
 2083        // if the parsing of the IfModifiedSince header was not successful, disable caching
 2084        if (!parsingSuccessful)
 2085        {
 2086            // disableCaching = true;
 2087        }
 2088
 2089        foreach (var (key, value) in headers)
 2090        {
 2091            Response.Headers.Append(key, value);
 2092        }
 2093
 2094        Response.ContentType = imageContentType ?? MediaTypeNames.Text.Plain;
 2095        Response.Headers.Append(HeaderNames.Age, Convert.ToInt64((DateTime.UtcNow - dateImageModified).TotalSeconds).ToS
 2096        Response.Headers.Append(HeaderNames.Vary, HeaderNames.Accept);
 2097
 2098        Response.Headers.ContentDisposition = "attachment";
 2099
 2100        if (disableCaching)
 2101        {
 2102            Response.Headers.Append(HeaderNames.CacheControl, "no-cache, no-store, must-revalidate");
 2103            Response.Headers.Append(HeaderNames.Pragma, "no-cache, no-store, must-revalidate");
 2104        }
 2105        else
 2106        {
 2107            if (cacheDuration.HasValue)
 2108            {
 2109                Response.Headers.Append(HeaderNames.CacheControl, "public, max-age=" + cacheDuration.Value.TotalSeconds)
 2110            }
 2111            else
 2112            {
 2113                Response.Headers.Append(HeaderNames.CacheControl, "public");
 2114            }
 2115
 2116            Response.Headers.Append(HeaderNames.LastModified, dateImageModified.ToUniversalTime().ToString("ddd, dd MMM 
 2117
 2118            // if the image was not modified since "ifModifiedSinceHeader"-header, return a HTTP status code 304 not mod
 2119            if (!(dateImageModified > ifModifiedSinceHeader) && cacheDuration.HasValue)
 2120            {
 2121                if (ifModifiedSinceHeader.Add(cacheDuration.Value) < DateTime.UtcNow)
 2122                {
 2123                    Response.StatusCode = StatusCodes.Status304NotModified;
 2124                    return new ContentResult();
 2125                }
 2126            }
 2127        }
 2128
 2129        return PhysicalFile(imagePath, imageContentType ?? MediaTypeNames.Text.Plain);
 2130    }
 2131
 2132    internal static bool TryGetImageExtensionFromContentType(string? contentType, [NotNullWhen(true)] out string? extens
 2133    {
 142134        extension = null;
 142135        if (string.IsNullOrEmpty(contentType))
 2136        {
 22137            return false;
 2138        }
 2139
 122140        if (MediaTypeHeaderValue.TryParse(contentType, out var parsedValue)
 122141            && parsedValue.MediaType.HasValue
 122142            && MimeTypes.IsImage(parsedValue.MediaType.Value))
 2143        {
 112144            extension = MimeTypes.ToExtension(parsedValue.MediaType.Value);
 112145            return extension is not null;
 2146        }
 2147
 12148        return false;
 2149    }
 2150}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:21 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Controller.Library.IUserManager,MediaBrowser.Controller.Library.ILibraryManager,MediaBrowser.Controller.Providers.IProviderManager,MediaBrowser.Controller.Drawing.IImageProcessor,MediaBrowser.Model.IO.IFileSystem,Microsoft.Extensions.Logging.ILogger`1<Jellyfin.Api.Controllers.ImageController>,MediaBrowser.Controller.Configuration.IServerConfigurationManager,MediaBrowser.Common.Configuration.IApplicationPaths)
GetFromBase64Stream(System.IO.Stream)
DeleteCustomSplashscreen()
GetImageInfo(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.ItemImageInfo,System.Nullable`1<System.Int32>)
GetOutputFormats(System.Nullable`1<MediaBrowser.Model.Drawing.ImageFormat>)
GetClientSupportedFormats()
SupportsFormat(System.Collections.Generic.IReadOnlyCollection`1<System.String>,System.String,MediaBrowser.Model.Drawing.ImageFormat,System.Boolean)
TryGetImageExtensionFromContentType(System.String,System.String&)