< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.Images.BaseDynamicImageProvider<T>
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/Images/BaseDynamicImageProvider.cs
Line coverage
20%
Covered lines: 22
Uncovered lines: 86
Coverable lines: 108
Total lines: 319
Line coverage: 20.3%
Branch coverage
15%
Covered branches: 8
Total branches: 52
Branch coverage: 15.3%
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_Name()100%210%
get_MaxImageAgeDays()100%210%
get_Order()100%210%
Supports(...)100%210%
FetchAsync(...)33.33%11650%
CreateThumbCollage(...)100%210%
GetStripCollageImagePaths(...)0%2040%
CreatePosterCollage(...)100%210%
CreateSquareCollage(...)100%210%
CreateThumbCollage(...)100%210%
CreateCollage(...)0%2040%
CreateImage(...)0%342180%
HasChanged(...)30%291042.85%
HasChanged(...)25%27833.33%
HasChangedByDate(...)100%210%
CreateSingleImage(...)50%2260%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Images/BaseDynamicImageProvider.cs

#LineLine coverage
 1#nullable disable
 2
 3#pragma warning disable CS1591
 4
 5using System;
 6using System.Collections.Generic;
 7using System.Globalization;
 8using System.IO;
 9using System.Linq;
 10using System.Net.Mime;
 11using System.Threading;
 12using System.Threading.Tasks;
 13using MediaBrowser.Common.Configuration;
 14using MediaBrowser.Controller.Drawing;
 15using MediaBrowser.Controller.Entities;
 16using MediaBrowser.Controller.Entities.Audio;
 17using MediaBrowser.Controller.Library;
 18using MediaBrowser.Controller.Playlists;
 19using MediaBrowser.Controller.Providers;
 20using MediaBrowser.Model.Entities;
 21using MediaBrowser.Model.IO;
 22using MediaBrowser.Model.Net;
 23
 24namespace Emby.Server.Implementations.Images
 25{
 26    public abstract class BaseDynamicImageProvider<T> : IHasItemChangeMonitor, IForcedProvider, ICustomMetadataProvider<
 27        where T : BaseItem
 28    {
 29        protected BaseDynamicImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths a
 30        {
 21031            ApplicationPaths = applicationPaths;
 21032            ProviderManager = providerManager;
 21033            FileSystem = fileSystem;
 21034            ImageProcessor = imageProcessor;
 21035        }
 36
 37        protected IFileSystem FileSystem { get; }
 38
 39        protected IProviderManager ProviderManager { get; }
 40
 41        protected IApplicationPaths ApplicationPaths { get; }
 42
 43        protected IImageProcessor ImageProcessor { get; set; }
 44
 45        protected virtual IReadOnlyCollection<ImageType> SupportedImages { get; }
 21046            = new ImageType[] { ImageType.Primary };
 47
 48        /// <inheritdoc />
 049        public string Name => "Dynamic Image Provider";
 50
 051        protected virtual int MaxImageAgeDays => 7;
 52
 053        public int Order => 0;
 54
 055        protected virtual bool Supports(BaseItem item) => true;
 56
 57        public async Task<ItemUpdateType> FetchAsync(T item, MetadataRefreshOptions options, CancellationToken cancellat
 58        {
 59            if (!Supports(item))
 60            {
 61                return ItemUpdateType.None;
 62            }
 63
 64            var updateType = ItemUpdateType.None;
 65
 66            if (SupportedImages.Contains(ImageType.Primary))
 67            {
 68                var primaryResult = await FetchAsync(item, ImageType.Primary, options, cancellationToken).ConfigureAwait
 69                updateType |= primaryResult;
 70            }
 71
 72            if (SupportedImages.Contains(ImageType.Thumb))
 73            {
 74                var thumbResult = await FetchAsync(item, ImageType.Thumb, options, cancellationToken).ConfigureAwait(fal
 75                updateType |= thumbResult;
 76            }
 77
 78            return updateType;
 79        }
 80
 81        protected Task<ItemUpdateType> FetchAsync(BaseItem item, ImageType imageType, MetadataRefreshOptions options, Ca
 82        {
 5183            var image = item.GetImageInfo(imageType, 0);
 84
 5185            if (image is not null)
 86            {
 087                if (!image.IsLocalFile)
 88                {
 089                    return Task.FromResult(ItemUpdateType.None);
 90                }
 91
 092                if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
 93                {
 094                    return Task.FromResult(ItemUpdateType.None);
 95                }
 96            }
 97
 5198            var items = GetItemsWithImages(item);
 99
 51100            return FetchToFileInternal(item, items, imageType, cancellationToken);
 101        }
 102
 103        protected async Task<ItemUpdateType> FetchToFileInternal(
 104            BaseItem item,
 105            IReadOnlyList<BaseItem> itemsWithImages,
 106            ImageType imageType,
 107            CancellationToken cancellationToken)
 108        {
 109            var outputPathWithoutExtension = Path.Combine(ApplicationPaths.TempDirectory, Guid.NewGuid().ToString("N", C
 110            Directory.CreateDirectory(Path.GetDirectoryName(outputPathWithoutExtension));
 111            string outputPath = CreateImage(item, itemsWithImages, outputPathWithoutExtension, imageType, 0);
 112
 113            if (string.IsNullOrEmpty(outputPath))
 114            {
 115                return ItemUpdateType.None;
 116            }
 117
 118            var mimeType = MimeTypes.GetMimeType(outputPath);
 119
 120            if (string.Equals(mimeType, MediaTypeNames.Application.Octet, StringComparison.OrdinalIgnoreCase))
 121            {
 122                mimeType = MediaTypeNames.Image.Png;
 123            }
 124
 125            await ProviderManager.SaveImage(item, outputPath, mimeType, imageType, null, false, cancellationToken).Confi
 126
 127            return ItemUpdateType.ImageUpdate;
 128        }
 129
 130        protected abstract IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item);
 131
 132        protected string CreateThumbCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath)
 133        {
 0134            return CreateCollage(primaryItem, items, outputPath, 640, 360);
 135        }
 136
 137        protected virtual IEnumerable<string> GetStripCollageImagePaths(BaseItem primaryItem, IEnumerable<BaseItem> item
 138        {
 0139            var useBackdrop = primaryItem is CollectionFolder || primaryItem is UserView;
 0140            return items
 0141                .Select(i =>
 0142                {
 0143                    // Use Backdrop instead of Primary image for Library images.
 0144                    if (useBackdrop)
 0145                    {
 0146                        var backdrop = i.GetImageInfo(ImageType.Backdrop, 0);
 0147                        if (backdrop is not null && backdrop.IsLocalFile)
 0148                        {
 0149                            return backdrop.Path;
 0150                        }
 0151                    }
 0152
 0153                    var image = i.GetImageInfo(ImageType.Primary, 0);
 0154                    if (image is not null && image.IsLocalFile)
 0155                    {
 0156                        return image.Path;
 0157                    }
 0158
 0159                    image = i.GetImageInfo(ImageType.Thumb, 0);
 0160                    if (image is not null && image.IsLocalFile)
 0161                    {
 0162                        return image.Path;
 0163                    }
 0164
 0165                    return null;
 0166                })
 0167                .Where(i => !string.IsNullOrEmpty(i));
 168        }
 169
 170        protected string CreatePosterCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath)
 171        {
 0172            return CreateCollage(primaryItem, items, outputPath, 400, 600);
 173        }
 174
 175        protected string CreateSquareCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath)
 176        {
 0177            return CreateCollage(primaryItem, items, outputPath, 600, 600);
 178        }
 179
 180        protected string CreateThumbCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath, int wi
 181        {
 0182            return CreateCollage(primaryItem, items, outputPath, width, height);
 183        }
 184
 185        private string CreateCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath, int width, in
 186        {
 0187            Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
 188
 0189            var options = new ImageCollageOptions
 0190            {
 0191                Height = height,
 0192                Width = width,
 0193                OutputPath = outputPath,
 0194                InputPaths = GetStripCollageImagePaths(primaryItem, items).ToArray()
 0195            };
 196
 0197            if (options.InputPaths.Count == 0)
 198            {
 0199                return null;
 200            }
 201
 0202            if (!ImageProcessor.SupportsImageCollageCreation)
 203            {
 0204                return null;
 205            }
 206
 0207            ImageProcessor.CreateImageCollage(options, primaryItem.Name);
 0208            return outputPath;
 209        }
 210
 211        protected virtual string CreateImage(
 212            BaseItem item,
 213            IReadOnlyCollection<BaseItem> itemsWithImages,
 214            string outputPathWithoutExtension,
 215            ImageType imageType,
 216            int imageIndex)
 217        {
 0218            if (itemsWithImages.Count == 0)
 219            {
 0220                return null;
 221            }
 222
 0223            string outputPath = Path.ChangeExtension(outputPathWithoutExtension, ".png");
 224
 0225            if (imageType == ImageType.Thumb)
 226            {
 0227                return CreateThumbCollage(item, itemsWithImages, outputPath);
 228            }
 229
 0230            if (imageType == ImageType.Primary)
 231            {
 0232                if (item is UserView
 0233                    || item is Playlist
 0234                    || item is MusicGenre
 0235                    || item is Genre
 0236                    || item is PhotoAlbum
 0237                    || item is MusicArtist)
 238                {
 0239                    return CreateSquareCollage(item, itemsWithImages, outputPath);
 240                }
 241
 0242                return CreatePosterCollage(item, itemsWithImages, outputPath);
 243            }
 244
 0245            throw new ArgumentException("Unexpected image type", nameof(imageType));
 246        }
 247
 248        public bool HasChanged(BaseItem item, IDirectoryService directoryService)
 249        {
 21250            if (!Supports(item))
 251            {
 0252                return false;
 253            }
 254
 21255            if (SupportedImages.Contains(ImageType.Primary) && HasChanged(item, ImageType.Primary))
 256            {
 21257                return true;
 258            }
 259
 0260            if (SupportedImages.Contains(ImageType.Thumb) && HasChanged(item, ImageType.Thumb))
 261            {
 0262                return true;
 263            }
 264
 0265            return false;
 266        }
 267
 268        protected bool HasChanged(BaseItem item, ImageType type)
 269        {
 21270            var image = item.GetImageInfo(type, 0);
 271
 21272            if (image is not null)
 273            {
 0274                if (!image.IsLocalFile)
 275                {
 0276                    return false;
 277                }
 278
 0279                if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
 280                {
 0281                    return false;
 282                }
 283
 0284                if (!HasChangedByDate(item, image))
 285                {
 0286                    return false;
 287                }
 288            }
 289
 21290            return true;
 291        }
 292
 293        protected virtual bool HasChangedByDate(BaseItem item, ItemImageInfo image)
 294        {
 0295            var age = DateTime.UtcNow - image.DateModified;
 0296            return age.TotalDays > MaxImageAgeDays;
 297        }
 298
 299        protected string CreateSingleImage(IEnumerable<BaseItem> itemsWithImages, string outputPathWithoutExtension, Ima
 300        {
 38301            var image = itemsWithImages
 38302                .Where(i => i.HasImage(imageType) && i.GetImageInfo(imageType, 0).IsLocalFile && Path.HasExtension(i.Get
 38303                .Select(i => i.GetImagePath(imageType))
 38304                .FirstOrDefault();
 305
 38306            if (string.IsNullOrEmpty(image))
 307            {
 38308                return null;
 309            }
 310
 0311            var ext = Path.GetExtension(image);
 312
 0313            var outputPath = Path.ChangeExtension(outputPathWithoutExtension, ext);
 0314            File.Copy(image, outputPath, true);
 315
 0316            return outputPath;
 317        }
 318    }
 319}
Generated by: ReportGenerator 5.4.5.0
4/26/2025 - 12:10:58 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Model.IO.IFileSystem,MediaBrowser.Controller.Providers.IProviderManager,MediaBrowser.Common.Configuration.IApplicationPaths,MediaBrowser.Controller.Drawing.IImageProcessor)
get_Name()
get_MaxImageAgeDays()
get_Order()
Supports(MediaBrowser.Controller.Entities.BaseItem)
FetchAsync(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Entities.ImageType,MediaBrowser.Controller.Providers.MetadataRefreshOptions,System.Threading.CancellationToken)
CreateThumbCollage(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>,System.String)
GetStripCollageImagePaths(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>)
CreatePosterCollage(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>,System.String)
CreateSquareCollage(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>,System.String)
CreateThumbCollage(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>,System.String,System.Int32,System.Int32)
CreateCollage(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>,System.String,System.Int32,System.Int32)
CreateImage(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IReadOnlyCollection`1<MediaBrowser.Controller.Entities.BaseItem>,System.String,MediaBrowser.Model.Entities.ImageType,System.Int32)
HasChanged(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Providers.IDirectoryService)
HasChanged(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Entities.ImageType)
HasChangedByDate(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.ItemImageInfo)
CreateSingleImage(System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>,System.String,MediaBrowser.Model.Entities.ImageType)