< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.Dto.DtoService
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/Dto/DtoService.cs
Line coverage
42%
Covered lines: 281
Uncovered lines: 376
Coverable lines: 657
Total lines: 1442
Line coverage: 42.7%
Branch coverage
36%
Covered branches: 166
Total branches: 458
Branch coverage: 36.2%
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%11100%
get_LivetvManager()100%210%
GetBaseItemDtos(...)45%702050%
GetBaseItemDto(...)50%27833.33%
GetTaggedItems(...)100%210%
GetBaseItemDtoInternal(...)71.87%593270.21%
NormalizeMediaSourceContainers(...)0%342180%
GetItemByNameDto(...)0%2040%
SetItemByNameInfo(...)0%2040%
AttachUserSpecificInfo(...)76.66%513071.42%
GetChildCount(...)50%5466.66%
SetBookProperties(...)100%210%
SetPhotoProperties(...)0%620%
SetMusicVideoProperties(...)0%2040%
GetImageTags(...)100%11100%
GetImageCacheTag(...)100%210%
AttachPeople(...)7.14%171474.66%
AttachStudios(...)100%11100%
AttachGenreItems(...)100%11100%
GetGenreId(...)0%620%
GetTagAndFillBlurhash(...)0%620%
GetTagAndFillBlurhash(...)0%7280%
GetTagsAndFillBlurhashes(...)100%11100%
GetTagsAndFillBlurhashes(...)25%18845.45%
AttachBasicFields(...)53.93%627417842.27%
GetImageDisplayParent(...)0%420200%
AddInheritedImages(...)1.13%6801884.65%
GetMappedPath(...)100%44100%
AttachPrimaryImageAspectRatio(...)100%11100%
GetPrimaryImageAspectRatio(...)12.5%42818.75%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Dto/DtoService.cs

#LineLine coverage
 1#pragma warning disable CS1591
 2
 3using System;
 4using System.Collections.Generic;
 5using System.Globalization;
 6using System.IO;
 7using System.Linq;
 8using Jellyfin.Data.Enums;
 9using Jellyfin.Database.Implementations.Entities;
 10using Jellyfin.Extensions;
 11using MediaBrowser.Common;
 12using MediaBrowser.Controller.Channels;
 13using MediaBrowser.Controller.Chapters;
 14using MediaBrowser.Controller.Drawing;
 15using MediaBrowser.Controller.Dto;
 16using MediaBrowser.Controller.Entities;
 17using MediaBrowser.Controller.Entities.Audio;
 18using MediaBrowser.Controller.Library;
 19using MediaBrowser.Controller.LiveTv;
 20using MediaBrowser.Controller.Persistence;
 21using MediaBrowser.Controller.Playlists;
 22using MediaBrowser.Controller.Providers;
 23using MediaBrowser.Controller.Trickplay;
 24using MediaBrowser.Model.Dto;
 25using MediaBrowser.Model.Entities;
 26using MediaBrowser.Model.Querying;
 27using Microsoft.Extensions.Logging;
 28using Book = MediaBrowser.Controller.Entities.Book;
 29using Episode = MediaBrowser.Controller.Entities.TV.Episode;
 30using Movie = MediaBrowser.Controller.Entities.Movies.Movie;
 31using MusicAlbum = MediaBrowser.Controller.Entities.Audio.MusicAlbum;
 32using Person = MediaBrowser.Controller.Entities.Person;
 33using Photo = MediaBrowser.Controller.Entities.Photo;
 34using Season = MediaBrowser.Controller.Entities.TV.Season;
 35using Series = MediaBrowser.Controller.Entities.TV.Series;
 36
 37namespace Emby.Server.Implementations.Dto
 38{
 39    public class DtoService : IDtoService
 40    {
 41        private readonly ILogger<DtoService> _logger;
 42        private readonly ILibraryManager _libraryManager;
 43        private readonly IUserDataManager _userDataRepository;
 44
 45        private readonly IImageProcessor _imageProcessor;
 46        private readonly IProviderManager _providerManager;
 47        private readonly IRecordingsManager _recordingsManager;
 48
 49        private readonly IApplicationHost _appHost;
 50        private readonly IMediaSourceManager _mediaSourceManager;
 51        private readonly Lazy<ILiveTvManager> _livetvManagerFactory;
 52
 53        private readonly ITrickplayManager _trickplayManager;
 54        private readonly IChapterRepository _chapterRepository;
 55
 56        public DtoService(
 57            ILogger<DtoService> logger,
 58            ILibraryManager libraryManager,
 59            IUserDataManager userDataRepository,
 60            IImageProcessor imageProcessor,
 61            IProviderManager providerManager,
 62            IRecordingsManager recordingsManager,
 63            IApplicationHost appHost,
 64            IMediaSourceManager mediaSourceManager,
 65            Lazy<ILiveTvManager> livetvManagerFactory,
 66            ITrickplayManager trickplayManager,
 67            IChapterRepository chapterRepository)
 68        {
 2169            _logger = logger;
 2170            _libraryManager = libraryManager;
 2171            _userDataRepository = userDataRepository;
 2172            _imageProcessor = imageProcessor;
 2173            _providerManager = providerManager;
 2174            _recordingsManager = recordingsManager;
 2175            _appHost = appHost;
 2176            _mediaSourceManager = mediaSourceManager;
 2177            _livetvManagerFactory = livetvManagerFactory;
 2178            _trickplayManager = trickplayManager;
 2179            _chapterRepository = chapterRepository;
 2180        }
 81
 082        private ILiveTvManager LivetvManager => _livetvManagerFactory.Value;
 83
 84        /// <inheritdoc />
 85        public IReadOnlyList<BaseItemDto> GetBaseItemDtos(IReadOnlyList<BaseItem> items, DtoOptions options, User? user 
 86        {
 487            var accessibleItems = user is null ? items : items.Where(x => x.IsVisible(user)).ToList();
 488            var returnItems = new BaseItemDto[accessibleItems.Count];
 489            List<(BaseItem, BaseItemDto)>? programTuples = null;
 490            List<(BaseItemDto, LiveTvChannel)>? channelTuples = null;
 91
 1492            for (int index = 0; index < accessibleItems.Count; index++)
 93            {
 394                var item = accessibleItems[index];
 395                var dto = GetBaseItemDtoInternal(item, options, user, owner);
 96
 397                if (item is LiveTvChannel tvChannel)
 98                {
 099                    (channelTuples ??= []).Add((dto, tvChannel));
 100                }
 3101                else if (item is LiveTvProgram)
 102                {
 0103                    (programTuples ??= []).Add((item, dto));
 104                }
 105
 3106                if (item is IItemByName byName)
 107                {
 0108                    if (options.ContainsField(ItemFields.ItemCounts))
 109                    {
 0110                        var libraryItems = byName.GetTaggedItems(new InternalItemsQuery(user)
 0111                        {
 0112                            Recursive = true,
 0113                            DtoOptions = new DtoOptions(false)
 0114                            {
 0115                                EnableImages = false
 0116                            }
 0117                        });
 118
 0119                        SetItemByNameInfo(item, dto, libraryItems);
 120                    }
 121                }
 122
 3123                returnItems[index] = dto;
 124            }
 125
 4126            if (programTuples is not null)
 127            {
 0128                LivetvManager.AddInfoToProgramDto(programTuples, options.Fields, user).GetAwaiter().GetResult();
 129            }
 130
 4131            if (channelTuples is not null)
 132            {
 0133                LivetvManager.AddChannelInfo(channelTuples, options, user);
 134            }
 135
 4136            return returnItems;
 137        }
 138
 139        public BaseItemDto GetBaseItemDto(BaseItem item, DtoOptions options, User? user = null, BaseItem? owner = null)
 140        {
 6141            var dto = GetBaseItemDtoInternal(item, options, user, owner);
 6142            if (item is LiveTvChannel tvChannel)
 143            {
 0144                LivetvManager.AddChannelInfo(new[] { (dto, tvChannel) }, options, user);
 145            }
 6146            else if (item is LiveTvProgram)
 147            {
 0148                LivetvManager.AddInfoToProgramDto(new[] { (item, dto) }, options.Fields, user).GetAwaiter().GetResult();
 149            }
 150
 6151            if (item is IItemByName itemByName
 6152                && options.ContainsField(ItemFields.ItemCounts))
 153            {
 0154                SetItemByNameInfo(
 0155                    item,
 0156                    dto,
 0157                    GetTaggedItems(
 0158                        itemByName,
 0159                        user,
 0160                        new DtoOptions(false)
 0161                        {
 0162                            EnableImages = false
 0163                        }));
 164            }
 165
 6166            return dto;
 167        }
 168
 169        private static IReadOnlyList<BaseItem> GetTaggedItems(IItemByName byName, User? user, DtoOptions options)
 170        {
 0171            return byName.GetTaggedItems(
 0172                new InternalItemsQuery(user)
 0173                {
 0174                    Recursive = true,
 0175                    DtoOptions = options
 0176                });
 177        }
 178
 179        private BaseItemDto GetBaseItemDtoInternal(BaseItem item, DtoOptions options, User? user = null, BaseItem? owner
 180        {
 9181            var dto = new BaseItemDto
 9182            {
 9183                ServerId = _appHost.SystemId
 9184            };
 185
 9186            if (item.SourceType == SourceType.Channel)
 187            {
 0188                dto.SourceType = item.SourceType.ToString();
 189            }
 190
 9191            if (options.ContainsField(ItemFields.People))
 192            {
 6193                AttachPeople(dto, item, user);
 194            }
 195
 9196            if (options.ContainsField(ItemFields.PrimaryImageAspectRatio))
 197            {
 198                try
 199                {
 6200                    AttachPrimaryImageAspectRatio(dto, item);
 6201                }
 0202                catch (Exception ex)
 203                {
 204                    // Have to use a catch-all unfortunately because some .net image methods throw plain Exceptions
 0205                    _logger.LogError(ex, "Error generating PrimaryImageAspectRatio for {ItemName}", item.Name);
 0206                }
 207            }
 208
 9209            if (options.ContainsField(ItemFields.DisplayPreferencesId))
 210            {
 6211                dto.DisplayPreferencesId = item.DisplayPreferencesId.ToString("N", CultureInfo.InvariantCulture);
 212            }
 213
 9214            if (user is not null)
 215            {
 9216                AttachUserSpecificInfo(dto, item, user, options);
 217            }
 218
 9219            if (item is IHasMediaSources
 9220                && options.ContainsField(ItemFields.MediaSources))
 221            {
 0222                dto.MediaSources = _mediaSourceManager.GetStaticMediaSources(item, true, user).ToArray();
 223
 0224                NormalizeMediaSourceContainers(dto);
 225            }
 226
 9227            if (options.ContainsField(ItemFields.Studios))
 228            {
 6229                AttachStudios(dto, item);
 230            }
 231
 9232            AttachBasicFields(dto, item, owner, options);
 233
 9234            if (options.ContainsField(ItemFields.CanDelete))
 235            {
 6236                dto.CanDelete = user is null
 6237                    ? item.CanDelete()
 6238                    : item.CanDelete(user);
 239            }
 240
 9241            if (options.ContainsField(ItemFields.CanDownload))
 242            {
 6243                dto.CanDownload = user is null
 6244                    ? item.CanDownload()
 6245                    : item.CanDownload(user);
 246            }
 247
 9248            if (options.ContainsField(ItemFields.Etag))
 249            {
 6250                dto.Etag = item.GetEtag(user);
 251            }
 252
 9253            var activeRecording = _recordingsManager.GetActiveRecordingInfo(item.Path);
 9254            if (activeRecording is not null)
 255            {
 0256                dto.Type = BaseItemKind.Recording;
 0257                dto.CanDownload = false;
 0258                dto.RunTimeTicks = null;
 259
 0260                if (!string.IsNullOrEmpty(dto.SeriesName))
 261                {
 0262                    dto.EpisodeTitle = dto.Name;
 0263                    dto.Name = dto.SeriesName;
 264                }
 265
 0266                LivetvManager.AddInfoToRecordingDto(item, dto, activeRecording, user);
 267            }
 268
 9269            if (item is Audio audio)
 270            {
 0271                dto.HasLyrics = audio.GetMediaStreams().Any(s => s.Type == MediaStreamType.Lyric);
 272            }
 273
 9274            return dto;
 275        }
 276
 277        private static void NormalizeMediaSourceContainers(BaseItemDto dto)
 278        {
 0279            foreach (var mediaSource in dto.MediaSources)
 280            {
 0281                var container = mediaSource.Container;
 0282                if (string.IsNullOrEmpty(container))
 283                {
 284                    continue;
 285                }
 286
 0287                var containers = container.Split(',');
 0288                if (containers.Length < 2)
 289                {
 290                    continue;
 291                }
 292
 0293                var path = mediaSource.Path;
 0294                string? fileExtensionContainer = null;
 295
 0296                if (!string.IsNullOrEmpty(path))
 297                {
 0298                    path = Path.GetExtension(path);
 0299                    if (!string.IsNullOrEmpty(path))
 300                    {
 0301                        path = Path.GetExtension(path);
 0302                        if (!string.IsNullOrEmpty(path))
 303                        {
 0304                            path = path.TrimStart('.');
 305                        }
 306
 0307                        if (!string.IsNullOrEmpty(path) && containers.Contains(path, StringComparison.OrdinalIgnoreCase)
 308                        {
 0309                            fileExtensionContainer = path;
 310                        }
 311                    }
 312                }
 313
 0314                mediaSource.Container = fileExtensionContainer ?? containers[0];
 315            }
 0316        }
 317
 318        /// <inheritdoc />
 319        public BaseItemDto GetItemByNameDto(BaseItem item, DtoOptions options, List<BaseItem>? taggedItems, User? user =
 320        {
 0321            var dto = GetBaseItemDtoInternal(item, options, user);
 322
 0323            if (taggedItems is not null && options.ContainsField(ItemFields.ItemCounts))
 324            {
 0325                SetItemByNameInfo(item, dto, taggedItems);
 326            }
 327
 0328            return dto;
 329        }
 330
 331        private static void SetItemByNameInfo(BaseItem item, BaseItemDto dto, IReadOnlyList<BaseItem> taggedItems)
 332        {
 0333            if (item is MusicArtist)
 334            {
 0335                dto.AlbumCount = taggedItems.Count(i => i is MusicAlbum);
 0336                dto.MusicVideoCount = taggedItems.Count(i => i is MusicVideo);
 0337                dto.SongCount = taggedItems.Count(i => i is Audio);
 338            }
 0339            else if (item is MusicGenre)
 340            {
 0341                dto.ArtistCount = taggedItems.Count(i => i is MusicArtist);
 0342                dto.AlbumCount = taggedItems.Count(i => i is MusicAlbum);
 0343                dto.MusicVideoCount = taggedItems.Count(i => i is MusicVideo);
 0344                dto.SongCount = taggedItems.Count(i => i is Audio);
 345            }
 346            else
 347            {
 348                // This populates them all and covers Genre, Person, Studio, Year
 349
 0350                dto.ArtistCount = taggedItems.Count(i => i is MusicArtist);
 0351                dto.AlbumCount = taggedItems.Count(i => i is MusicAlbum);
 0352                dto.EpisodeCount = taggedItems.Count(i => i is Episode);
 0353                dto.MovieCount = taggedItems.Count(i => i is Movie);
 0354                dto.TrailerCount = taggedItems.Count(i => i is Trailer);
 0355                dto.MusicVideoCount = taggedItems.Count(i => i is MusicVideo);
 0356                dto.SeriesCount = taggedItems.Count(i => i is Series);
 0357                dto.ProgramCount = taggedItems.Count(i => i is LiveTvProgram);
 0358                dto.SongCount = taggedItems.Count(i => i is Audio);
 359            }
 360
 0361            dto.ChildCount = taggedItems.Count;
 0362        }
 363
 364        /// <summary>
 365        /// Attaches the user specific info.
 366        /// </summary>
 367        private void AttachUserSpecificInfo(BaseItemDto dto, BaseItem item, User user, DtoOptions options)
 368        {
 9369            if (item.IsFolder)
 370            {
 9371                var folder = (Folder)item;
 372
 9373                if (options.EnableUserData)
 374                {
 9375                    dto.UserData = _userDataRepository.GetUserDataDto(item, dto, user, options);
 376                }
 377
 9378                if (!dto.ChildCount.HasValue && item.SourceType == SourceType.Library)
 379                {
 380                    // For these types we can try to optimize and assume these values will be equal
 9381                    if (item is MusicAlbum || item is Season || item is Playlist)
 382                    {
 0383                        dto.ChildCount = dto.RecursiveItemCount;
 0384                        var folderChildCount = folder.LinkedChildren.Length;
 385                        // The default is an empty array, so we can't reliably use the count when it's empty
 0386                        if (folderChildCount > 0)
 387                        {
 0388                            dto.ChildCount ??= folderChildCount;
 389                        }
 390                    }
 391
 9392                    if (options.ContainsField(ItemFields.ChildCount))
 393                    {
 6394                        dto.ChildCount ??= GetChildCount(folder, user);
 395                    }
 396                }
 397
 9398                if (options.ContainsField(ItemFields.CumulativeRunTimeTicks))
 399                {
 6400                    dto.CumulativeRunTimeTicks = item.RunTimeTicks;
 401                }
 402
 9403                if (options.ContainsField(ItemFields.DateLastMediaAdded))
 404                {
 6405                    dto.DateLastMediaAdded = folder.DateLastMediaAdded;
 406                }
 407            }
 408            else
 409            {
 0410                if (options.EnableUserData)
 411                {
 0412                    dto.UserData = _userDataRepository.GetUserDataDto(item, user);
 413                }
 414            }
 415
 9416            if (options.ContainsField(ItemFields.PlayAccess))
 417            {
 6418                dto.PlayAccess = item.GetPlayAccess(user);
 419            }
 9420        }
 421
 422        private static int GetChildCount(Folder folder, User user)
 423        {
 424            // Right now this is too slow to calculate for top level folders on a per-user basis
 425            // Just return something so that apps that are expecting a value won't think the folders are empty
 6426            if (folder is ICollectionFolder || folder is UserView)
 427            {
 0428                return Random.Shared.Next(1, 10);
 429            }
 430
 6431            return folder.GetChildCount(user);
 432        }
 433
 434        private static void SetBookProperties(BaseItemDto dto, Book item)
 435        {
 0436            dto.SeriesName = item.SeriesName;
 0437        }
 438
 439        private static void SetPhotoProperties(BaseItemDto dto, Photo item)
 440        {
 0441            dto.CameraMake = item.CameraMake;
 0442            dto.CameraModel = item.CameraModel;
 0443            dto.Software = item.Software;
 0444            dto.ExposureTime = item.ExposureTime;
 0445            dto.FocalLength = item.FocalLength;
 0446            dto.ImageOrientation = item.Orientation;
 0447            dto.Aperture = item.Aperture;
 0448            dto.ShutterSpeed = item.ShutterSpeed;
 449
 0450            dto.Latitude = item.Latitude;
 0451            dto.Longitude = item.Longitude;
 0452            dto.Altitude = item.Altitude;
 0453            dto.IsoSpeedRating = item.IsoSpeedRating;
 454
 0455            var album = item.AlbumEntity;
 456
 0457            if (album is not null)
 458            {
 0459                dto.Album = album.Name;
 0460                dto.AlbumId = album.Id;
 461            }
 0462        }
 463
 464        private void SetMusicVideoProperties(BaseItemDto dto, MusicVideo item)
 465        {
 0466            if (!string.IsNullOrEmpty(item.Album))
 467            {
 0468                var parentAlbumIds = _libraryManager.GetItemIds(new InternalItemsQuery
 0469                {
 0470                    IncludeItemTypes = new[] { BaseItemKind.MusicAlbum },
 0471                    Name = item.Album,
 0472                    Limit = 1
 0473                });
 474
 0475                if (parentAlbumIds.Count > 0)
 476                {
 0477                    dto.AlbumId = parentAlbumIds[0];
 478                }
 479            }
 480
 0481            dto.Album = item.Album;
 0482        }
 483
 484        private string[] GetImageTags(BaseItem item, List<ItemImageInfo> images)
 485        {
 9486            return images
 9487                .Select(p => GetImageCacheTag(item, p))
 9488                .Where(i => i is not null)
 9489                .ToArray()!; // null values got filtered out
 490        }
 491
 492        private string? GetImageCacheTag(BaseItem item, ItemImageInfo image)
 493        {
 494            try
 495            {
 0496                return _imageProcessor.GetImageCacheTag(item, image);
 497            }
 0498            catch (Exception ex)
 499            {
 0500                _logger.LogError(ex, "Error getting {ImageType} image info for {Path}", image.Type, image.Path);
 0501                return null;
 502            }
 0503        }
 504
 505        /// <summary>
 506        /// Attaches People DTO's to a DTOBaseItem.
 507        /// </summary>
 508        /// <param name="dto">The dto.</param>
 509        /// <param name="item">The item.</param>
 510        /// <param name="user">The requesting user.</param>
 511        private void AttachPeople(BaseItemDto dto, BaseItem item, User? user = null)
 512        {
 513            // Ordering by person type to ensure actors and artists are at the front.
 514            // This is taking advantage of the fact that they both begin with A
 515            // This should be improved in the future
 6516            var people = _libraryManager.GetPeople(item).OrderBy(i => i.SortOrder ?? int.MaxValue)
 6517                .ThenBy(i =>
 6518                {
 6519                    if (i.IsType(PersonKind.Actor))
 6520                    {
 6521                        return 0;
 6522                    }
 6523
 6524                    if (i.IsType(PersonKind.GuestStar))
 6525                    {
 6526                        return 1;
 6527                    }
 6528
 6529                    if (i.IsType(PersonKind.Director))
 6530                    {
 6531                        return 2;
 6532                    }
 6533
 6534                    if (i.IsType(PersonKind.Writer))
 6535                    {
 6536                        return 3;
 6537                    }
 6538
 6539                    if (i.IsType(PersonKind.Producer))
 6540                    {
 6541                        return 4;
 6542                    }
 6543
 6544                    if (i.IsType(PersonKind.Composer))
 6545                    {
 6546                        return 4;
 6547                    }
 6548
 6549                    return 10;
 6550                })
 6551                .ToList();
 552
 6553            var list = new List<BaseItemPerson>();
 554
 6555            Dictionary<string, Person> dictionary = people.Select(p => p.Name)
 6556                .Distinct(StringComparer.OrdinalIgnoreCase).Select(c =>
 6557                {
 6558                    try
 6559                    {
 6560                        return _libraryManager.GetPerson(c);
 6561                    }
 6562                    catch (Exception ex)
 6563                    {
 6564                        _logger.LogError(ex, "Error getting person {Name}", c);
 6565                        return null;
 6566                    }
 6567                }).Where(i => i is not null)
 6568                .Where(i => user is null || i!.IsVisible(user))
 6569                .DistinctBy(x => x!.Name, StringComparer.OrdinalIgnoreCase)
 6570                .ToDictionary(i => i!.Name, StringComparer.OrdinalIgnoreCase)!; // null values got filtered out
 571
 12572            for (var i = 0; i < people.Count; i++)
 573            {
 0574                var person = people[i];
 575
 0576                var baseItemPerson = new BaseItemPerson
 0577                {
 0578                    Name = person.Name,
 0579                    Role = person.Role,
 0580                    Type = person.Type
 0581                };
 582
 0583                if (dictionary.TryGetValue(person.Name, out Person? entity))
 584                {
 0585                    baseItemPerson.PrimaryImageTag = GetTagAndFillBlurhash(dto, entity, ImageType.Primary);
 0586                    baseItemPerson.Id = entity.Id;
 0587                    if (dto.ImageBlurHashes is not null)
 588                    {
 589                        // Only add BlurHash for the person's image.
 0590                        baseItemPerson.ImageBlurHashes = [];
 0591                        foreach (var (imageType, blurHash) in dto.ImageBlurHashes)
 592                        {
 0593                            if (blurHash is not null)
 594                            {
 0595                                baseItemPerson.ImageBlurHashes[imageType] = [];
 0596                                foreach (var (imageId, blurHashValue) in blurHash)
 597                                {
 0598                                    if (string.Equals(baseItemPerson.PrimaryImageTag, imageId, StringComparison.OrdinalI
 599                                    {
 0600                                        baseItemPerson.ImageBlurHashes[imageType][imageId] = blurHashValue;
 601                                    }
 602                                }
 603                            }
 604                        }
 605                    }
 606
 0607                    list.Add(baseItemPerson);
 608                }
 609            }
 610
 6611            dto.People = list.ToArray();
 6612        }
 613
 614        /// <summary>
 615        /// Attaches the studios.
 616        /// </summary>
 617        /// <param name="dto">The dto.</param>
 618        /// <param name="item">The item.</param>
 619        private void AttachStudios(BaseItemDto dto, BaseItem item)
 620        {
 6621            dto.Studios = item.Studios
 6622                .Where(i => !string.IsNullOrEmpty(i))
 6623                .Select(i => new NameGuidPair
 6624                {
 6625                    Name = i,
 6626                    Id = _libraryManager.GetStudioId(i)
 6627                })
 6628                .ToArray();
 6629        }
 630
 631        private void AttachGenreItems(BaseItemDto dto, BaseItem item)
 632        {
 6633            dto.GenreItems = item.Genres
 6634                .Where(i => !string.IsNullOrEmpty(i))
 6635                .Select(i => new NameGuidPair
 6636                {
 6637                    Name = i,
 6638                    Id = GetGenreId(i, item)
 6639                })
 6640                .ToArray();
 6641        }
 642
 643        private Guid GetGenreId(string name, BaseItem owner)
 644        {
 0645            if (owner is IHasMusicGenres)
 646            {
 0647                return _libraryManager.GetMusicGenreId(name);
 648            }
 649
 0650            return _libraryManager.GetGenreId(name);
 651        }
 652
 653        private string? GetTagAndFillBlurhash(BaseItemDto dto, BaseItem item, ImageType imageType, int imageIndex = 0)
 654        {
 0655            var image = item.GetImageInfo(imageType, imageIndex);
 0656            if (image is not null)
 657            {
 0658                return GetTagAndFillBlurhash(dto, item, image);
 659            }
 660
 0661            return null;
 662        }
 663
 664        private string? GetTagAndFillBlurhash(BaseItemDto dto, BaseItem item, ItemImageInfo image)
 665        {
 0666            var tag = GetImageCacheTag(item, image);
 0667            if (tag is null)
 668            {
 0669                return null;
 670            }
 671
 0672            if (!string.IsNullOrEmpty(image.BlurHash))
 673            {
 0674                dto.ImageBlurHashes ??= [];
 675
 0676                if (!dto.ImageBlurHashes.TryGetValue(image.Type, out var value))
 677                {
 0678                    value = [];
 0679                    dto.ImageBlurHashes[image.Type] = value;
 680                }
 681
 0682                value[tag] = image.BlurHash;
 683            }
 684
 0685            return tag;
 686        }
 687
 688        private string[] GetTagsAndFillBlurhashes(BaseItemDto dto, BaseItem item, ImageType imageType, int limit)
 689        {
 9690            return GetTagsAndFillBlurhashes(dto, item, imageType, item.GetImages(imageType).Take(limit).ToList());
 691        }
 692
 693        private string[] GetTagsAndFillBlurhashes(BaseItemDto dto, BaseItem item, ImageType imageType, List<ItemImageInf
 694        {
 9695            var tags = GetImageTags(item, images);
 9696            var hashes = new Dictionary<string, string>();
 18697            for (int i = 0; i < images.Count; i++)
 698            {
 0699                var img = images[i];
 0700                if (!string.IsNullOrEmpty(img.BlurHash))
 701                {
 0702                    var tag = tags[i];
 0703                    hashes[tag] = img.BlurHash;
 704                }
 705            }
 706
 9707            if (hashes.Count > 0)
 708            {
 0709                dto.ImageBlurHashes ??= [];
 710
 0711                dto.ImageBlurHashes[imageType] = hashes;
 712            }
 713
 9714            return tags;
 715        }
 716
 717        /// <summary>
 718        /// Sets simple property values on a DTOBaseItem.
 719        /// </summary>
 720        /// <param name="dto">The dto.</param>
 721        /// <param name="item">The item.</param>
 722        /// <param name="owner">The owner.</param>
 723        /// <param name="options">The options.</param>
 724        private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem? owner, DtoOptions options)
 725        {
 9726            if (options.ContainsField(ItemFields.DateCreated))
 727            {
 6728                dto.DateCreated = item.DateCreated;
 729            }
 730
 9731            if (options.ContainsField(ItemFields.Settings))
 732            {
 6733                dto.LockedFields = item.LockedFields;
 6734                dto.LockData = item.IsLocked;
 6735                dto.ForcedSortName = item.ForcedSortName;
 736            }
 737
 9738            dto.Container = item.Container;
 9739            dto.EndDate = item.EndDate;
 740
 9741            if (options.ContainsField(ItemFields.ExternalUrls))
 742            {
 6743                dto.ExternalUrls = _providerManager.GetExternalUrls(item).ToArray();
 744            }
 745
 9746            if (options.ContainsField(ItemFields.Tags))
 747            {
 6748                dto.Tags = item.Tags;
 749            }
 750
 9751            if (item is IHasAspectRatio hasAspectRatio)
 752            {
 0753                dto.AspectRatio = hasAspectRatio.AspectRatio;
 754            }
 755
 9756            dto.ImageBlurHashes = [];
 757
 9758            var backdropLimit = options.GetImageLimit(ImageType.Backdrop);
 9759            if (backdropLimit > 0)
 760            {
 9761                dto.BackdropImageTags = GetTagsAndFillBlurhashes(dto, item, ImageType.Backdrop, backdropLimit);
 762            }
 763
 9764            if (options.ContainsField(ItemFields.Genres))
 765            {
 6766                dto.Genres = item.Genres;
 6767                AttachGenreItems(dto, item);
 768            }
 769
 9770            if (options.EnableImages)
 771            {
 9772                dto.ImageTags = [];
 773
 774                // Prevent implicitly captured closure
 9775                var currentItem = item;
 18776                foreach (var image in currentItem.ImageInfos.Where(i => !currentItem.AllowsMultipleImages(i.Type)))
 777                {
 0778                    if (options.GetImageLimit(image.Type) > 0)
 779                    {
 0780                        var tag = GetTagAndFillBlurhash(dto, item, image);
 781
 0782                        if (tag is not null)
 783                        {
 0784                            dto.ImageTags[image.Type] = tag;
 785                        }
 786                    }
 787                }
 788            }
 789
 9790            dto.Id = item.Id;
 9791            dto.IndexNumber = item.IndexNumber;
 9792            dto.ParentIndexNumber = item.ParentIndexNumber;
 793
 9794            if (item.IsFolder)
 795            {
 9796                dto.IsFolder = true;
 797            }
 0798            else if (item is IHasMediaSources)
 799            {
 0800                dto.IsFolder = false;
 801            }
 802
 9803            dto.MediaType = item.MediaType;
 804
 9805            if (item is not LiveTvProgram)
 806            {
 9807                dto.LocationType = item.LocationType;
 808            }
 809
 9810            dto.Audio = item.Audio;
 811
 9812            if (options.ContainsField(ItemFields.Settings))
 813            {
 6814                dto.PreferredMetadataCountryCode = item.PreferredMetadataCountryCode;
 6815                dto.PreferredMetadataLanguage = item.PreferredMetadataLanguage;
 816            }
 817
 9818            dto.CriticRating = item.CriticRating;
 819
 9820            if (item is IHasDisplayOrder hasDisplayOrder)
 821            {
 0822                dto.DisplayOrder = hasDisplayOrder.DisplayOrder;
 823            }
 824
 9825            if (item is IHasCollectionType hasCollectionType)
 826            {
 3827                dto.CollectionType = hasCollectionType.CollectionType;
 828            }
 829
 9830            if (options.ContainsField(ItemFields.RemoteTrailers))
 831            {
 6832                dto.RemoteTrailers = item.RemoteTrailers;
 833            }
 834
 9835            dto.Name = item.Name;
 9836            dto.OfficialRating = item.OfficialRating;
 837
 9838            if (options.ContainsField(ItemFields.Overview))
 839            {
 6840                dto.Overview = item.Overview;
 841            }
 842
 9843            if (options.ContainsField(ItemFields.OriginalTitle))
 844            {
 6845                dto.OriginalTitle = item.OriginalTitle;
 846            }
 847
 9848            if (options.ContainsField(ItemFields.ParentId))
 849            {
 6850                dto.ParentId = item.DisplayParentId;
 851            }
 852
 9853            AddInheritedImages(dto, item, options, owner);
 854
 9855            if (options.ContainsField(ItemFields.Path))
 856            {
 6857                dto.Path = GetMappedPath(item, owner);
 858            }
 859
 9860            if (options.ContainsField(ItemFields.EnableMediaSourceDisplay))
 861            {
 6862                dto.EnableMediaSourceDisplay = item.EnableMediaSourceDisplay;
 863            }
 864
 9865            dto.PremiereDate = item.PremiereDate;
 9866            dto.ProductionYear = item.ProductionYear;
 867
 9868            if (options.ContainsField(ItemFields.ProviderIds))
 869            {
 6870                dto.ProviderIds = item.ProviderIds;
 871            }
 872
 9873            dto.RunTimeTicks = item.RunTimeTicks;
 874
 9875            if (options.ContainsField(ItemFields.SortName))
 876            {
 6877                dto.SortName = item.SortName;
 878            }
 879
 9880            if (options.ContainsField(ItemFields.CustomRating))
 881            {
 6882                dto.CustomRating = item.CustomRating;
 883            }
 884
 9885            if (options.ContainsField(ItemFields.Taglines))
 886            {
 6887                if (!string.IsNullOrEmpty(item.Tagline))
 888                {
 0889                    dto.Taglines = new string[] { item.Tagline };
 890                }
 891
 6892                dto.Taglines ??= Array.Empty<string>();
 893            }
 894
 9895            dto.Type = item.GetBaseItemKind();
 9896            if ((item.CommunityRating ?? 0) > 0)
 897            {
 0898                dto.CommunityRating = item.CommunityRating;
 899            }
 900
 9901            if (item is ISupportsPlaceHolders supportsPlaceHolders && supportsPlaceHolders.IsPlaceHolder)
 902            {
 0903                dto.IsPlaceHolder = supportsPlaceHolders.IsPlaceHolder;
 904            }
 905
 9906            if (item.LUFS.HasValue)
 907            {
 908                // -18 LUFS reference, same as ReplayGain 2.0, compatible with ReplayGain 1.0
 0909                dto.NormalizationGain = -18f - item.LUFS;
 910            }
 9911            else if (item.NormalizationGain.HasValue)
 912            {
 0913                dto.NormalizationGain = item.NormalizationGain;
 914            }
 915
 916            // Add audio info
 9917            if (item is Audio audio)
 918            {
 0919                dto.Album = audio.Album;
 0920                dto.ExtraType = audio.ExtraType;
 921
 0922                var albumParent = audio.AlbumEntity;
 923
 0924                if (albumParent is not null)
 925                {
 0926                    dto.AlbumId = albumParent.Id;
 0927                    dto.AlbumPrimaryImageTag = GetTagAndFillBlurhash(dto, albumParent, ImageType.Primary);
 928                }
 929
 930                // if (options.ContainsField(ItemFields.MediaSourceCount))
 931                // {
 932                // Songs always have one
 933                // }
 934            }
 935
 9936            if (item is IHasArtist hasArtist)
 937            {
 0938                dto.Artists = hasArtist.Artists;
 939
 940                // var artistItems = _libraryManager.GetArtists(new InternalItemsQuery
 941                // {
 942                //    EnableTotalRecordCount = false,
 943                //    ItemIds = new[] { item.Id.ToString("N", CultureInfo.InvariantCulture) }
 944                // });
 945
 946                // dto.ArtistItems = artistItems.Items
 947                //    .Select(i =>
 948                //    {
 949                //        var artist = i.Item1;
 950                //        return new NameIdPair
 951                //        {
 952                //            Name = artist.Name,
 953                //            Id = artist.Id.ToString("N", CultureInfo.InvariantCulture)
 954                //        };
 955                //    })
 956                //    .ToList();
 957
 958                // Include artists that are not in the database yet, e.g., just added via metadata editor
 959                // var foundArtists = artistItems.Items.Select(i => i.Item1.Name).ToList();
 0960                dto.ArtistItems = hasArtist.Artists
 0961                    // .Except(foundArtists, new DistinctNameComparer())
 0962                    .Select(i =>
 0963                    {
 0964                        // This should not be necessary but we're seeing some cases of it
 0965                        if (string.IsNullOrEmpty(i))
 0966                        {
 0967                            return null;
 0968                        }
 0969
 0970                        var artist = _libraryManager.GetArtist(i, new DtoOptions(false)
 0971                        {
 0972                            EnableImages = false
 0973                        });
 0974                        if (artist is not null)
 0975                        {
 0976                            return new NameGuidPair
 0977                            {
 0978                                Name = artist.Name,
 0979                                Id = artist.Id
 0980                            };
 0981                        }
 0982
 0983                        return null;
 0984                    }).Where(i => i is not null).ToArray();
 985            }
 986
 9987            if (item is IHasAlbumArtist hasAlbumArtist)
 988            {
 0989                dto.AlbumArtist = hasAlbumArtist.AlbumArtists.FirstOrDefault();
 990
 991                // var artistItems = _libraryManager.GetAlbumArtists(new InternalItemsQuery
 992                // {
 993                //    EnableTotalRecordCount = false,
 994                //    ItemIds = new[] { item.Id.ToString("N", CultureInfo.InvariantCulture) }
 995                // });
 996
 997                // dto.AlbumArtists = artistItems.Items
 998                //    .Select(i =>
 999                //    {
 1000                //        var artist = i.Item1;
 1001                //        return new NameIdPair
 1002                //        {
 1003                //            Name = artist.Name,
 1004                //            Id = artist.Id.ToString("N", CultureInfo.InvariantCulture)
 1005                //        };
 1006                //    })
 1007                //    .ToList();
 1008
 01009                dto.AlbumArtists = hasAlbumArtist.AlbumArtists
 01010                    // .Except(foundArtists, new DistinctNameComparer())
 01011                    .Select(i =>
 01012                    {
 01013                        // This should not be necessary but we're seeing some cases of it
 01014                        if (string.IsNullOrEmpty(i))
 01015                        {
 01016                            return null;
 01017                        }
 01018
 01019                        var artist = _libraryManager.GetArtist(i, new DtoOptions(false)
 01020                        {
 01021                            EnableImages = false
 01022                        });
 01023                        if (artist is not null)
 01024                        {
 01025                            return new NameGuidPair
 01026                            {
 01027                                Name = artist.Name,
 01028                                Id = artist.Id
 01029                            };
 01030                        }
 01031
 01032                        return null;
 01033                    }).Where(i => i is not null).ToArray();
 1034            }
 1035
 1036            // Add video info
 91037            if (item is Video video)
 1038            {
 01039                dto.VideoType = video.VideoType;
 01040                dto.Video3DFormat = video.Video3DFormat;
 01041                dto.IsoType = video.IsoType;
 1042
 01043                if (video.HasSubtitles)
 1044                {
 01045                    dto.HasSubtitles = video.HasSubtitles;
 1046                }
 1047
 01048                if (video.AdditionalParts.Length != 0)
 1049                {
 01050                    dto.PartCount = video.AdditionalParts.Length + 1;
 1051                }
 1052
 01053                if (options.ContainsField(ItemFields.MediaSourceCount))
 1054                {
 01055                    var mediaSourceCount = video.MediaSourceCount;
 01056                    if (mediaSourceCount != 1)
 1057                    {
 01058                        dto.MediaSourceCount = mediaSourceCount;
 1059                    }
 1060                }
 1061
 01062                if (options.ContainsField(ItemFields.Chapters))
 1063                {
 01064                    dto.Chapters = _chapterRepository.GetChapters(item.Id).ToList();
 1065                }
 1066
 01067                if (options.ContainsField(ItemFields.Trickplay))
 1068                {
 01069                    dto.Trickplay = _trickplayManager.GetTrickplayManifest(item).GetAwaiter().GetResult();
 1070                }
 1071
 01072                dto.ExtraType = video.ExtraType;
 1073            }
 1074
 91075            if (options.ContainsField(ItemFields.MediaStreams))
 1076            {
 1077                // Add VideoInfo
 61078                if (item is IHasMediaSources)
 1079                {
 1080                    MediaStream[] mediaStreams;
 1081
 01082                    if (dto.MediaSources is not null && dto.MediaSources.Length > 0)
 1083                    {
 01084                        if (item.SourceType == SourceType.Channel)
 1085                        {
 01086                            mediaStreams = dto.MediaSources[0].MediaStreams.ToArray();
 1087                        }
 1088                        else
 1089                        {
 01090                            string id = item.Id.ToString("N", CultureInfo.InvariantCulture);
 01091                            mediaStreams = dto.MediaSources.Where(i => string.Equals(i.Id, id, StringComparison.OrdinalI
 01092                                .SelectMany(i => i.MediaStreams)
 01093                                .ToArray();
 1094                        }
 1095                    }
 1096                    else
 1097                    {
 01098                        mediaStreams = _mediaSourceManager.GetStaticMediaSources(item, true)[0].MediaStreams.ToArray();
 1099                    }
 1100
 01101                    dto.MediaStreams = mediaStreams;
 1102                }
 1103            }
 1104
 91105            BaseItem[]? allExtras = null;
 1106
 91107            if (options.ContainsField(ItemFields.SpecialFeatureCount))
 1108            {
 61109                allExtras = item.GetExtras().ToArray();
 61110                dto.SpecialFeatureCount = allExtras.Count(i => i.ExtraType.HasValue && BaseItem.DisplayExtraTypes.Contai
 1111            }
 1112
 91113            if (options.ContainsField(ItemFields.LocalTrailerCount))
 1114            {
 61115                if (item is IHasTrailers hasTrailers)
 1116                {
 01117                    dto.LocalTrailerCount = hasTrailers.LocalTrailers.Count;
 1118                }
 1119                else
 1120                {
 61121                    dto.LocalTrailerCount = (allExtras ?? item.GetExtras()).Count(i => i.ExtraType == ExtraType.Trailer)
 1122                }
 1123            }
 1124
 1125            // Add EpisodeInfo
 91126            if (item is Episode episode)
 1127            {
 01128                dto.IndexNumberEnd = episode.IndexNumberEnd;
 01129                dto.SeriesName = episode.SeriesName;
 1130
 01131                if (options.ContainsField(ItemFields.SpecialEpisodeNumbers))
 1132                {
 01133                    dto.AirsAfterSeasonNumber = episode.AirsAfterSeasonNumber;
 01134                    dto.AirsBeforeEpisodeNumber = episode.AirsBeforeEpisodeNumber;
 01135                    dto.AirsBeforeSeasonNumber = episode.AirsBeforeSeasonNumber;
 1136                }
 1137
 01138                dto.SeasonName = episode.SeasonName;
 01139                dto.SeasonId = episode.SeasonId;
 01140                dto.SeriesId = episode.SeriesId;
 1141
 01142                Series? episodeSeries = null;
 1143
 1144                // this block will add the series poster for episodes without a poster
 1145                // TODO maybe remove the if statement entirely
 1146                // if (options.ContainsField(ItemFields.SeriesPrimaryImage))
 1147                {
 01148                    episodeSeries ??= episode.Series;
 01149                    if (episodeSeries is not null)
 1150                    {
 01151                        dto.SeriesPrimaryImageTag = GetTagAndFillBlurhash(dto, episodeSeries, ImageType.Primary);
 01152                        if (dto.ImageTags is null || !dto.ImageTags.ContainsKey(ImageType.Primary))
 1153                        {
 01154                            AttachPrimaryImageAspectRatio(dto, episodeSeries);
 1155                        }
 1156                    }
 1157                }
 1158
 01159                if (options.ContainsField(ItemFields.SeriesStudio))
 1160                {
 01161                    episodeSeries ??= episode.Series;
 01162                    if (episodeSeries is not null)
 1163                    {
 01164                        dto.SeriesStudio = episodeSeries.Studios.FirstOrDefault();
 1165                    }
 1166                }
 1167            }
 1168
 1169            // Add SeriesInfo
 1170            Series? series;
 91171            if (item is Series tmp)
 1172            {
 01173                series = tmp;
 01174                dto.AirDays = series.AirDays;
 01175                dto.AirTime = series.AirTime;
 01176                dto.Status = series.Status?.ToString();
 1177            }
 1178
 1179            // Add SeasonInfo
 91180            if (item is Season season)
 1181            {
 01182                dto.SeriesName = season.SeriesName;
 01183                dto.SeriesId = season.SeriesId;
 1184
 01185                series = null;
 1186
 01187                if (options.ContainsField(ItemFields.SeriesStudio))
 1188                {
 01189                    series ??= season.Series;
 01190                    if (series is not null)
 1191                    {
 01192                        dto.SeriesStudio = series.Studios.FirstOrDefault();
 1193                    }
 1194                }
 1195
 1196                // this block will add the series poster for seasons without a poster
 1197                // TODO maybe remove the if statement entirely
 1198                // if (options.ContainsField(ItemFields.SeriesPrimaryImage))
 1199                {
 01200                    series ??= season.Series;
 01201                    if (series is not null)
 1202                    {
 01203                        dto.SeriesPrimaryImageTag = GetTagAndFillBlurhash(dto, series, ImageType.Primary);
 01204                        if (dto.ImageTags is null || !dto.ImageTags.ContainsKey(ImageType.Primary))
 1205                        {
 01206                            AttachPrimaryImageAspectRatio(dto, series);
 1207                        }
 1208                    }
 1209                }
 1210            }
 1211
 91212            if (item is MusicVideo musicVideo)
 1213            {
 01214                SetMusicVideoProperties(dto, musicVideo);
 1215            }
 1216
 91217            if (item is Book book)
 1218            {
 01219                SetBookProperties(dto, book);
 1220            }
 1221
 91222            if (options.ContainsField(ItemFields.ProductionLocations))
 1223            {
 61224                if (item.ProductionLocations.Length > 0 || item is Movie)
 1225                {
 01226                    dto.ProductionLocations = item.ProductionLocations;
 1227                }
 1228            }
 1229
 91230            if (options.ContainsField(ItemFields.Width))
 1231            {
 61232                var width = item.Width;
 61233                if (width > 0)
 1234                {
 01235                    dto.Width = width;
 1236                }
 1237            }
 1238
 91239            if (options.ContainsField(ItemFields.Height))
 1240            {
 61241                var height = item.Height;
 61242                if (height > 0)
 1243                {
 01244                    dto.Height = height;
 1245                }
 1246            }
 1247
 91248            if (options.ContainsField(ItemFields.IsHD))
 1249            {
 1250                // Compatibility
 61251                if (item.IsHD)
 1252                {
 01253                    dto.IsHD = true;
 1254                }
 1255            }
 1256
 91257            if (item is Photo photo)
 1258            {
 01259                SetPhotoProperties(dto, photo);
 1260            }
 1261
 91262            dto.ChannelId = item.ChannelId;
 1263
 91264            if (item.SourceType == SourceType.Channel)
 1265            {
 01266                var channel = _libraryManager.GetItemById(item.ChannelId);
 01267                if (channel is not null)
 1268                {
 01269                    dto.ChannelName = channel.Name;
 1270                }
 1271            }
 91272        }
 1273
 1274        private BaseItem? GetImageDisplayParent(BaseItem currentItem, BaseItem originalItem)
 1275        {
 01276            if (currentItem is MusicAlbum musicAlbum)
 1277            {
 01278                var artist = musicAlbum.GetMusicArtist(new DtoOptions(false));
 01279                if (artist is not null)
 1280                {
 01281                    return artist;
 1282                }
 1283            }
 1284
 01285            var parent = currentItem.DisplayParent ?? currentItem.GetOwner() ?? currentItem.GetParent();
 1286
 01287            if (parent is null && originalItem is not UserRootFolder && originalItem is not UserView && originalItem is 
 1288            {
 01289                parent = _libraryManager.GetCollectionFolders(originalItem).FirstOrDefault();
 1290            }
 1291
 01292            return parent;
 1293        }
 1294
 1295        private void AddInheritedImages(BaseItemDto dto, BaseItem item, DtoOptions options, BaseItem? owner)
 1296        {
 91297            if (!item.SupportsInheritedParentImages)
 1298            {
 91299                return;
 1300            }
 1301
 01302            var logoLimit = options.GetImageLimit(ImageType.Logo);
 01303            var artLimit = options.GetImageLimit(ImageType.Art);
 01304            var thumbLimit = options.GetImageLimit(ImageType.Thumb);
 01305            var backdropLimit = options.GetImageLimit(ImageType.Backdrop);
 1306
 1307            // For now. Emby apps are not using this
 01308            artLimit = 0;
 1309
 01310            if (logoLimit == 0 && artLimit == 0 && thumbLimit == 0 && backdropLimit == 0)
 1311            {
 01312                return;
 1313            }
 1314
 01315            BaseItem? parent = null;
 01316            var isFirst = true;
 1317
 01318            var imageTags = dto.ImageTags;
 1319
 01320            while ((!(imageTags is not null && imageTags.ContainsKey(ImageType.Logo)) && logoLimit > 0)
 01321                || (!(imageTags is not null && imageTags.ContainsKey(ImageType.Art)) && artLimit > 0)
 01322                || (!(imageTags is not null && imageTags.ContainsKey(ImageType.Thumb)) && thumbLimit > 0)
 01323                || parent is Series)
 1324            {
 01325                parent ??= isFirst ? GetImageDisplayParent(item, item) ?? owner : parent;
 01326                if (parent is null)
 1327                {
 1328                    break;
 1329                }
 1330
 01331                var allImages = parent.ImageInfos;
 1332
 01333                if (logoLimit > 0 && !(imageTags is not null && imageTags.ContainsKey(ImageType.Logo)) && dto.ParentLogo
 1334                {
 01335                    var image = allImages.FirstOrDefault(i => i.Type == ImageType.Logo);
 1336
 01337                    if (image is not null)
 1338                    {
 01339                        dto.ParentLogoItemId = parent.Id;
 01340                        dto.ParentLogoImageTag = GetTagAndFillBlurhash(dto, parent, image);
 1341                    }
 1342                }
 1343
 01344                if (artLimit > 0 && !(imageTags is not null && imageTags.ContainsKey(ImageType.Art)) && dto.ParentArtIte
 1345                {
 01346                    var image = allImages.FirstOrDefault(i => i.Type == ImageType.Art);
 1347
 01348                    if (image is not null)
 1349                    {
 01350                        dto.ParentArtItemId = parent.Id;
 01351                        dto.ParentArtImageTag = GetTagAndFillBlurhash(dto, parent, image);
 1352                    }
 1353                }
 1354
 01355                if (thumbLimit > 0 && !(imageTags is not null && imageTags.ContainsKey(ImageType.Thumb)) && (dto.ParentT
 1356                {
 01357                    var image = allImages.FirstOrDefault(i => i.Type == ImageType.Thumb);
 1358
 01359                    if (image is not null)
 1360                    {
 01361                        dto.ParentThumbItemId = parent.Id;
 01362                        dto.ParentThumbImageTag = GetTagAndFillBlurhash(dto, parent, image);
 1363                    }
 1364                }
 1365
 01366                if (backdropLimit > 0 && !((dto.BackdropImageTags is not null && dto.BackdropImageTags.Length > 0) || (d
 1367                {
 01368                    var images = allImages.Where(i => i.Type == ImageType.Backdrop).Take(backdropLimit).ToList();
 1369
 01370                    if (images.Count > 0)
 1371                    {
 01372                        dto.ParentBackdropItemId = parent.Id;
 01373                        dto.ParentBackdropImageTags = GetTagsAndFillBlurhashes(dto, parent, ImageType.Backdrop, images);
 1374                    }
 1375                }
 1376
 01377                isFirst = false;
 1378
 01379                if (!parent.SupportsInheritedParentImages)
 1380                {
 1381                    break;
 1382                }
 1383
 01384                parent = GetImageDisplayParent(parent, item);
 1385            }
 01386        }
 1387
 1388        private string GetMappedPath(BaseItem item, BaseItem? ownerItem)
 1389        {
 61390            var path = item.Path;
 1391
 61392            if (item.IsFileProtocol)
 1393            {
 61394                path = _libraryManager.GetPathAfterNetworkSubstitution(path, ownerItem ?? item);
 1395            }
 1396
 61397            return path;
 1398        }
 1399
 1400        /// <summary>
 1401        /// Attaches the primary image aspect ratio.
 1402        /// </summary>
 1403        /// <param name="dto">The dto.</param>
 1404        /// <param name="item">The item.</param>
 1405        public void AttachPrimaryImageAspectRatio(IItemDto dto, BaseItem item)
 1406        {
 61407            dto.PrimaryImageAspectRatio = GetPrimaryImageAspectRatio(item);
 61408        }
 1409
 1410        public double? GetPrimaryImageAspectRatio(BaseItem item)
 1411        {
 61412            var imageInfo = item.GetImageInfo(ImageType.Primary, 0);
 1413
 61414            if (imageInfo is null)
 1415            {
 61416                return null;
 1417            }
 1418
 01419            if (!imageInfo.IsLocalFile)
 1420            {
 01421                return item.GetDefaultPrimaryImageAspectRatio();
 1422            }
 1423
 1424            try
 1425            {
 01426                var size = _imageProcessor.GetImageDimensions(item, imageInfo);
 01427                var width = size.Width;
 01428                var height = size.Height;
 01429                if (width > 0 && height > 0)
 1430                {
 01431                    return (double)width / height;
 1432                }
 01433            }
 01434            catch (Exception ex)
 1435            {
 01436                _logger.LogError(ex, "Failed to determine primary image aspect ratio for {ImagePath}", imageInfo.Path);
 01437            }
 1438
 01439            return item.GetDefaultPrimaryImageAspectRatio();
 01440        }
 1441    }
 1442}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:20 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Microsoft.Extensions.Logging.ILogger`1<Emby.Server.Implementations.Dto.DtoService>,MediaBrowser.Controller.Library.ILibraryManager,MediaBrowser.Controller.Library.IUserDataManager,MediaBrowser.Controller.Drawing.IImageProcessor,MediaBrowser.Controller.Providers.IProviderManager,MediaBrowser.Controller.LiveTv.IRecordingsManager,MediaBrowser.Common.IApplicationHost,MediaBrowser.Controller.Library.IMediaSourceManager,System.Lazy`1<MediaBrowser.Controller.LiveTv.ILiveTvManager>,MediaBrowser.Controller.Trickplay.ITrickplayManager,MediaBrowser.Controller.Chapters.IChapterRepository)
get_LivetvManager()
GetBaseItemDtos(System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.BaseItem>,MediaBrowser.Controller.Dto.DtoOptions,Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Entities.BaseItem)
GetBaseItemDto(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Dto.DtoOptions,Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Entities.BaseItem)
GetTaggedItems(MediaBrowser.Controller.Entities.IItemByName,Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Dto.DtoOptions)
GetBaseItemDtoInternal(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Dto.DtoOptions,Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Entities.BaseItem)
NormalizeMediaSourceContainers(MediaBrowser.Model.Dto.BaseItemDto)
GetItemByNameDto(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Dto.DtoOptions,System.Collections.Generic.List`1<MediaBrowser.Controller.Entities.BaseItem>,Jellyfin.Database.Implementations.Entities.User)
SetItemByNameInfo(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Dto.BaseItemDto,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.BaseItem>)
AttachUserSpecificInfo(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem,Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Dto.DtoOptions)
GetChildCount(MediaBrowser.Controller.Entities.Folder,Jellyfin.Database.Implementations.Entities.User)
SetBookProperties(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.Book)
SetPhotoProperties(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.Photo)
SetMusicVideoProperties(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.MusicVideo)
GetImageTags(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.List`1<MediaBrowser.Controller.Entities.ItemImageInfo>)
GetImageCacheTag(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.ItemImageInfo)
AttachPeople(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem,Jellyfin.Database.Implementations.Entities.User)
AttachStudios(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem)
AttachGenreItems(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem)
GetGenreId(System.String,MediaBrowser.Controller.Entities.BaseItem)
GetTagAndFillBlurhash(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Entities.ImageType,System.Int32)
GetTagAndFillBlurhash(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.ItemImageInfo)
GetTagsAndFillBlurhashes(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Entities.ImageType,System.Int32)
GetTagsAndFillBlurhashes(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Entities.ImageType,System.Collections.Generic.List`1<MediaBrowser.Controller.Entities.ItemImageInfo>)
AttachBasicFields(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Dto.DtoOptions)
GetImageDisplayParent(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.BaseItem)
AddInheritedImages(MediaBrowser.Model.Dto.BaseItemDto,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Dto.DtoOptions,MediaBrowser.Controller.Entities.BaseItem)
GetMappedPath(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.BaseItem)
AttachPrimaryImageAspectRatio(MediaBrowser.Model.Dto.IItemDto,MediaBrowser.Controller.Entities.BaseItem)
GetPrimaryImageAspectRatio(MediaBrowser.Controller.Entities.BaseItem)