From be9ed29f63da3834e7d32e00909e5c5c3c6c8362 Mon Sep 17 00:00:00 2001
From: Joe Rogers <1337joe@gmail.com>
Date: Sun, 3 Oct 2021 21:28:21 +0200
Subject: [PATCH 1/5] Split EmbeddedImage extracting to new provider
---
.../MediaInfo/EmbeddedImageProvider.cs | 123 ++++++++++++++++++
.../MediaInfo/VideoImageProvider.cs | 40 ++----
2 files changed, 134 insertions(+), 29 deletions(-)
create mode 100644 MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
diff --git a/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
new file mode 100644
index 0000000000..64a47611d8
--- /dev/null
+++ b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
@@ -0,0 +1,123 @@
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging;
+
+namespace MediaBrowser.Providers.MediaInfo
+{
+ ///
+ /// Uses ffmpeg to extract embedded images.
+ ///
+ public class EmbeddedImageProvider : IDynamicImageProvider, IHasOrder
+ {
+ private readonly IMediaEncoder _mediaEncoder;
+ private readonly ILogger _logger;
+
+ public EmbeddedImageProvider(IMediaEncoder mediaEncoder, ILogger logger)
+ {
+ _mediaEncoder = mediaEncoder;
+ _logger = logger;
+ }
+
+ ///
+ public string Name => "Embedded Image Extractor";
+
+ ///
+ // Default to after internet image providers but before Screen Grabber
+ public int Order => 99;
+
+ ///
+ public IEnumerable GetSupportedImages(BaseItem item)
+ {
+ return new[] { ImageType.Primary };
+ }
+
+ ///
+ public Task GetImage(BaseItem item, ImageType type, CancellationToken cancellationToken)
+ {
+ var video = (Video)item;
+
+ // No support for these
+ if (video.IsPlaceHolder || video.VideoType == VideoType.Dvd)
+ {
+ return Task.FromResult(new DynamicImageResponse { HasImage = false });
+ }
+
+ // Can't extract if we didn't find any video streams in the file
+ if (!video.DefaultVideoStreamIndex.HasValue)
+ {
+ _logger.LogInformation("Skipping image extraction due to missing DefaultVideoStreamIndex for {Path}.", video.Path ?? string.Empty);
+ return Task.FromResult(new DynamicImageResponse { HasImage = false });
+ }
+
+ return GetEmbeddedImage(video, cancellationToken);
+ }
+
+ private async Task GetEmbeddedImage(Video item, CancellationToken cancellationToken)
+ {
+ MediaSourceInfo mediaSource = new MediaSourceInfo
+ {
+ VideoType = item.VideoType,
+ IsoType = item.IsoType,
+ Protocol = item.PathProtocol ?? MediaProtocol.File,
+ };
+
+ var imageStreams =
+ item.GetMediaStreams()
+ .Where(i => i.Type == MediaStreamType.EmbeddedImage)
+ .ToList();
+
+ string extractedImagePath;
+
+ if (imageStreams.Count == 0)
+ {
+ // Can't extract if we don't have any EmbeddedImage streams
+ return new DynamicImageResponse { HasImage = false };
+ }
+ else
+ {
+ var imageStream = imageStreams.Find(i => (i.Comment ?? string.Empty).Contains("front", StringComparison.OrdinalIgnoreCase))
+ ?? imageStreams.Find(i => (i.Comment ?? string.Empty).Contains("cover", StringComparison.OrdinalIgnoreCase))
+ ?? imageStreams[0];
+
+ extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, imageStream, imageStream.Index, cancellationToken).ConfigureAwait(false);
+ }
+
+ return new DynamicImageResponse
+ {
+ Format = ImageFormat.Jpg,
+ HasImage = true,
+ Path = extractedImagePath,
+ Protocol = MediaProtocol.File
+ };
+ }
+
+ ///
+ public bool Supports(BaseItem item)
+ {
+ if (item.IsShortcut)
+ {
+ return false;
+ }
+
+ if (!item.IsFileProtocol)
+ {
+ return false;
+ }
+
+ return item is Video video && !video.IsPlaceHolder && video.IsCompleteMedia;
+ }
+ }
+}
diff --git a/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs b/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
index 8b96205c23..8f20099505 100644
--- a/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
@@ -17,6 +17,9 @@ using Microsoft.Extensions.Logging;
namespace MediaBrowser.Providers.MediaInfo
{
+ ///
+ /// Uses ffmpeg to create still images from the main video.
+ ///
public class VideoImageProvider : IDynamicImageProvider, IHasOrder
{
private readonly IMediaEncoder _mediaEncoder;
@@ -71,36 +74,15 @@ namespace MediaBrowser.Providers.MediaInfo
Protocol = item.PathProtocol ?? MediaProtocol.File,
};
- var mediaStreams =
- item.GetMediaStreams();
+ // If we know the duration, grab it from 10% into the video. Otherwise just 10 seconds in.
+ // Always use 10 seconds for dvd because our duration could be out of whack
+ var imageOffset = item.VideoType != VideoType.Dvd && item.RunTimeTicks.HasValue &&
+ item.RunTimeTicks.Value > 0
+ ? TimeSpan.FromTicks(item.RunTimeTicks.Value / 10)
+ : TimeSpan.FromSeconds(10);
- var imageStreams =
- mediaStreams
- .Where(i => i.Type == MediaStreamType.EmbeddedImage)
- .ToList();
-
- string extractedImagePath;
-
- if (imageStreams.Count == 0)
- {
- // If we know the duration, grab it from 10% into the video. Otherwise just 10 seconds in.
- // Always use 10 seconds for dvd because our duration could be out of whack
- var imageOffset = item.VideoType != VideoType.Dvd && item.RunTimeTicks.HasValue &&
- item.RunTimeTicks.Value > 0
- ? TimeSpan.FromTicks(item.RunTimeTicks.Value / 10)
- : TimeSpan.FromSeconds(10);
-
- var videoStream = mediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Video);
- extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, videoStream, item.Video3DFormat, imageOffset, cancellationToken).ConfigureAwait(false);
- }
- else
- {
- var imageStream = imageStreams.Find(i => (i.Comment ?? string.Empty).Contains("front", StringComparison.OrdinalIgnoreCase))
- ?? imageStreams.Find(i => (i.Comment ?? string.Empty).Contains("cover", StringComparison.OrdinalIgnoreCase))
- ?? imageStreams[0];
-
- extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, imageStream, imageStream.Index, cancellationToken).ConfigureAwait(false);
- }
+ var videoStream = item.GetMediaStreams().FirstOrDefault(i => i.Type == MediaStreamType.Video);
+ string extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, videoStream, item.Video3DFormat, imageOffset, cancellationToken).ConfigureAwait(false);
return new DynamicImageResponse
{
From 6ce8cce12c8d24cc0a49aac7a0d371e5ebf1b3a3 Mon Sep 17 00:00:00 2001
From: Joe Rogers <1337joe@gmail.com>
Date: Wed, 6 Oct 2021 01:13:08 +0200
Subject: [PATCH 2/5] Add handling for embedded background and logo
---
.../Probing/ProbeResultNormalizer.cs | 15 ++-
.../MediaInfo/EmbeddedImageProvider.cs | 91 ++++++++++++++++---
2 files changed, 90 insertions(+), 16 deletions(-)
diff --git a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
index fee3bf12ea..5f65394959 100644
--- a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
+++ b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
@@ -735,14 +735,15 @@ namespace MediaBrowser.MediaEncoding.Probing
else if (string.Equals(stream.Codec, "mjpeg", StringComparison.OrdinalIgnoreCase))
{
// How to differentiate between video and embedded image?
- // The only difference I've seen thus far is presence of codec tag, also embedded images have high (unusual) framerates
- if (!string.IsNullOrWhiteSpace(stream.CodecTag))
+ // check disposition, alternately: presence of codec tag, also embedded images have high (unusual) framerates
+ if ((streamInfo.Disposition != null && streamInfo.Disposition.GetValueOrDefault("attached_pic") == 1) ||
+ string.IsNullOrWhiteSpace(stream.CodecTag))
{
- stream.Type = MediaStreamType.Video;
+ stream.Type = MediaStreamType.EmbeddedImage;
}
else
{
- stream.Type = MediaStreamType.EmbeddedImage;
+ stream.Type = MediaStreamType.Video;
}
}
else
@@ -811,6 +812,12 @@ namespace MediaBrowser.MediaEncoding.Probing
{
stream.ColorPrimaries = streamInfo.ColorPrimaries;
}
+
+ // workaround for mkv attached_pics losing filename due to being classified as video based on codec
+ if (stream.Type == MediaStreamType.EmbeddedImage && streamInfo.Tags != null && string.IsNullOrEmpty(stream.Comment))
+ {
+ stream.Comment = GetDictionaryValue(streamInfo.Tags, "filename");
+ }
}
else
{
diff --git a/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
index 64a47611d8..11fdfcdf95 100644
--- a/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
@@ -3,10 +3,12 @@
using System;
using System.Collections.Generic;
+using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.MediaEncoding;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Drawing;
@@ -22,6 +24,27 @@ namespace MediaBrowser.Providers.MediaInfo
///
public class EmbeddedImageProvider : IDynamicImageProvider, IHasOrder
{
+ private static readonly string[] _primaryImageFileNames =
+ {
+ "poster",
+ "folder",
+ "cover",
+ "default"
+ };
+
+ private static readonly string[] _backdropImageFileNames =
+ {
+ "backdrop",
+ "fanart",
+ "background",
+ "art"
+ };
+
+ private static readonly string[] _logoImageFileNames =
+ {
+ "logo",
+ };
+
private readonly IMediaEncoder _mediaEncoder;
private readonly ILogger _logger;
@@ -41,7 +64,25 @@ namespace MediaBrowser.Providers.MediaInfo
///
public IEnumerable GetSupportedImages(BaseItem item)
{
- return new[] { ImageType.Primary };
+ if (item is Video)
+ {
+ if (item is Episode)
+ {
+ return new List
+ {
+ ImageType.Primary,
+ };
+ }
+
+ return new List
+ {
+ ImageType.Primary,
+ ImageType.Backdrop,
+ ImageType.Logo,
+ };
+ }
+
+ return ImmutableList.Empty;
}
///
@@ -62,10 +103,10 @@ namespace MediaBrowser.Providers.MediaInfo
return Task.FromResult(new DynamicImageResponse { HasImage = false });
}
- return GetEmbeddedImage(video, cancellationToken);
+ return GetEmbeddedImage(video, type, cancellationToken);
}
- private async Task GetEmbeddedImage(Video item, CancellationToken cancellationToken)
+ private async Task GetEmbeddedImage(Video item, ImageType type, CancellationToken cancellationToken)
{
MediaSourceInfo mediaSource = new MediaSourceInfo
{
@@ -74,27 +115,53 @@ namespace MediaBrowser.Providers.MediaInfo
Protocol = item.PathProtocol ?? MediaProtocol.File,
};
+ string[] imageFileNames;
+ switch (type)
+ {
+ case ImageType.Backdrop:
+ imageFileNames = _backdropImageFileNames;
+ break;
+ case ImageType.Logo:
+ imageFileNames = _logoImageFileNames;
+ break;
+ case ImageType.Primary:
+ default:
+ imageFileNames = _primaryImageFileNames;
+ break;
+ }
+
var imageStreams =
item.GetMediaStreams()
.Where(i => i.Type == MediaStreamType.EmbeddedImage)
.ToList();
- string extractedImagePath;
-
- if (imageStreams.Count == 0)
+ if (!imageStreams.Any())
{
// Can't extract if we don't have any EmbeddedImage streams
return new DynamicImageResponse { HasImage = false };
}
- else
- {
- var imageStream = imageStreams.Find(i => (i.Comment ?? string.Empty).Contains("front", StringComparison.OrdinalIgnoreCase))
- ?? imageStreams.Find(i => (i.Comment ?? string.Empty).Contains("cover", StringComparison.OrdinalIgnoreCase))
- ?? imageStreams[0];
- extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, imageStream, imageStream.Index, cancellationToken).ConfigureAwait(false);
+ // Extract first stream containing an element of imageFileNames
+ var imageStream = imageStreams
+ .Where(stream => !string.IsNullOrEmpty(stream.Comment))
+ .First(stream => imageFileNames.Any(name => stream.Comment.Contains(name, StringComparison.OrdinalIgnoreCase)));
+
+ // Primary type only: default to first image if none found by label
+ if (imageStream == null)
+ {
+ if (type == ImageType.Primary)
+ {
+ imageStream = imageStreams[0];
+ }
+ else
+ {
+ // No streams matched, abort
+ return new DynamicImageResponse { HasImage = false };
+ }
}
+ string extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, imageStream, imageStream.Index, cancellationToken).ConfigureAwait(false);
+
return new DynamicImageResponse
{
Format = ImageFormat.Jpg,
From 8d70cc2dde81aad0f484a2f0d0c5b90e6e1b97cd Mon Sep 17 00:00:00 2001
From: Joe Rogers <1337joe@gmail.com>
Date: Thu, 7 Oct 2021 22:37:59 +0200
Subject: [PATCH 3/5] Add support for non-jpg image extractions
---
.../MediaEncoding/IMediaEncoder.cs | 3 +-
.../Encoder/MediaEncoder.cs | 21 +++----
.../Probing/ProbeResultNormalizer.cs | 18 ++----
.../MediaInfo/EmbeddedImageProvider.cs | 60 +++++++++++++------
4 files changed, 62 insertions(+), 40 deletions(-)
diff --git a/MediaBrowser.Controller/MediaEncoding/IMediaEncoder.cs b/MediaBrowser.Controller/MediaEncoding/IMediaEncoder.cs
index c5522bc3cf..638588560d 100644
--- a/MediaBrowser.Controller/MediaEncoding/IMediaEncoder.cs
+++ b/MediaBrowser.Controller/MediaEncoding/IMediaEncoder.cs
@@ -95,9 +95,10 @@ namespace MediaBrowser.Controller.MediaEncoding
/// Media source information.
/// Media stream information.
/// Index of the stream to extract from.
+ /// The extension of the file to write.
/// CancellationToken to use for operation.
/// Location of video image.
- Task ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStream imageStream, int? imageStreamIndex, CancellationToken cancellationToken);
+ Task ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStream imageStream, int? imageStreamIndex, string outputExtension, CancellationToken cancellationToken);
///
/// Extracts the video images on interval.
diff --git a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
index 06fe95ce82..30bc7125d7 100644
--- a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
+++ b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
@@ -468,17 +468,17 @@ namespace MediaBrowser.MediaEncoding.Encoder
Protocol = MediaProtocol.File
};
- return ExtractImage(path, null, null, imageStreamIndex, mediaSource, true, null, null, cancellationToken);
+ return ExtractImage(path, null, null, imageStreamIndex, mediaSource, true, null, null, "jpg", cancellationToken);
}
public Task ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStream videoStream, Video3DFormat? threedFormat, TimeSpan? offset, CancellationToken cancellationToken)
{
- return ExtractImage(inputFile, container, videoStream, null, mediaSource, false, threedFormat, offset, cancellationToken);
+ return ExtractImage(inputFile, container, videoStream, null, mediaSource, false, threedFormat, offset, "jpg", cancellationToken);
}
- public Task ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStream imageStream, int? imageStreamIndex, CancellationToken cancellationToken)
+ public Task ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStream imageStream, int? imageStreamIndex, string outputExtension, CancellationToken cancellationToken)
{
- return ExtractImage(inputFile, container, imageStream, imageStreamIndex, mediaSource, false, null, null, cancellationToken);
+ return ExtractImage(inputFile, container, imageStream, imageStreamIndex, mediaSource, false, null, null, outputExtension, cancellationToken);
}
private async Task ExtractImage(
@@ -490,6 +490,7 @@ namespace MediaBrowser.MediaEncoding.Encoder
bool isAudio,
Video3DFormat? threedFormat,
TimeSpan? offset,
+ string outputExtension,
CancellationToken cancellationToken)
{
var inputArgument = GetInputArgument(inputFile, mediaSource);
@@ -499,7 +500,7 @@ namespace MediaBrowser.MediaEncoding.Encoder
// The failure of HDR extraction usually occurs when using custom ffmpeg that does not contain the zscale filter.
try
{
- return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFormat, offset, true, true, cancellationToken).ConfigureAwait(false);
+ return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFormat, offset, true, true, outputExtension, cancellationToken).ConfigureAwait(false);
}
catch (ArgumentException)
{
@@ -512,7 +513,7 @@ namespace MediaBrowser.MediaEncoding.Encoder
try
{
- return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFormat, offset, false, true, cancellationToken).ConfigureAwait(false);
+ return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFormat, offset, false, true, outputExtension, cancellationToken).ConfigureAwait(false);
}
catch (ArgumentException)
{
@@ -525,7 +526,7 @@ namespace MediaBrowser.MediaEncoding.Encoder
try
{
- return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFormat, offset, true, false, cancellationToken).ConfigureAwait(false);
+ return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFormat, offset, true, false, outputExtension, cancellationToken).ConfigureAwait(false);
}
catch (ArgumentException)
{
@@ -537,17 +538,17 @@ namespace MediaBrowser.MediaEncoding.Encoder
}
}
- return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFormat, offset, false, false, cancellationToken).ConfigureAwait(false);
+ return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFormat, offset, false, false, outputExtension, cancellationToken).ConfigureAwait(false);
}
- private async Task ExtractImageInternal(string inputPath, string container, MediaStream videoStream, int? imageStreamIndex, Video3DFormat? threedFormat, TimeSpan? offset, bool useIFrame, bool allowTonemap, CancellationToken cancellationToken)
+ private async Task ExtractImageInternal(string inputPath, string container, MediaStream videoStream, int? imageStreamIndex, Video3DFormat? threedFormat, TimeSpan? offset, bool useIFrame, bool allowTonemap, string outputExtension, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(inputPath))
{
throw new ArgumentNullException(nameof(inputPath));
}
- var tempExtractPath = Path.Combine(_configurationManager.ApplicationPaths.TempDirectory, Guid.NewGuid() + ".jpg");
+ var tempExtractPath = Path.Combine(_configurationManager.ApplicationPaths.TempDirectory, Guid.NewGuid() + "." + outputExtension);
Directory.CreateDirectory(Path.GetDirectoryName(tempExtractPath));
// apply some filters to thumbnail extracted below (below) crop any black lines that we made and get the correct ar.
diff --git a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
index 5f65394959..775689095f 100644
--- a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
+++ b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
@@ -582,7 +582,8 @@ namespace MediaBrowser.MediaEncoding.Probing
/// MediaAttachments.
private MediaAttachment GetMediaAttachment(MediaStreamInfo streamInfo)
{
- if (!string.Equals(streamInfo.CodecType, "attachment", StringComparison.OrdinalIgnoreCase))
+ if (!string.Equals(streamInfo.CodecType, "attachment", StringComparison.OrdinalIgnoreCase) &&
+ !(streamInfo.Disposition != null && streamInfo.Disposition.GetValueOrDefault("attached_pic") == 1))
{
return null;
}
@@ -735,15 +736,14 @@ namespace MediaBrowser.MediaEncoding.Probing
else if (string.Equals(stream.Codec, "mjpeg", StringComparison.OrdinalIgnoreCase))
{
// How to differentiate between video and embedded image?
- // check disposition, alternately: presence of codec tag, also embedded images have high (unusual) framerates
- if ((streamInfo.Disposition != null && streamInfo.Disposition.GetValueOrDefault("attached_pic") == 1) ||
- string.IsNullOrWhiteSpace(stream.CodecTag))
+ // The only difference I've seen thus far is presence of codec tag, also embedded images have high (unusual) framerates
+ if (!string.IsNullOrWhiteSpace(stream.CodecTag))
{
- stream.Type = MediaStreamType.EmbeddedImage;
+ stream.Type = MediaStreamType.Video;
}
else
{
- stream.Type = MediaStreamType.Video;
+ stream.Type = MediaStreamType.EmbeddedImage;
}
}
else
@@ -812,12 +812,6 @@ namespace MediaBrowser.MediaEncoding.Probing
{
stream.ColorPrimaries = streamInfo.ColorPrimaries;
}
-
- // workaround for mkv attached_pics losing filename due to being classified as video based on codec
- if (stream.Type == MediaStreamType.EmbeddedImage && streamInfo.Tags != null && string.IsNullOrEmpty(stream.Comment))
- {
- stream.Comment = GetDictionaryValue(streamInfo.Tags, "filename");
- }
}
else
{
diff --git a/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
index 11fdfcdf95..ad95cdb06f 100644
--- a/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
@@ -4,6 +4,7 @@
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
+using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
@@ -15,6 +16,7 @@ using MediaBrowser.Model.Drawing;
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.MediaInfo;
+using MediaBrowser.Model.Net;
using Microsoft.Extensions.Logging;
namespace MediaBrowser.Providers.MediaInfo
@@ -115,25 +117,49 @@ namespace MediaBrowser.Providers.MediaInfo
Protocol = item.PathProtocol ?? MediaProtocol.File,
};
- string[] imageFileNames;
- switch (type)
+ string[] imageFileNames = type switch
{
- case ImageType.Backdrop:
- imageFileNames = _backdropImageFileNames;
- break;
- case ImageType.Logo:
- imageFileNames = _logoImageFileNames;
- break;
- case ImageType.Primary:
- default:
- imageFileNames = _primaryImageFileNames;
- break;
+ ImageType.Primary => _primaryImageFileNames,
+ ImageType.Backdrop => _backdropImageFileNames,
+ ImageType.Logo => _logoImageFileNames,
+ _ => _primaryImageFileNames
+ };
+
+ // Try attachments first
+ var attachmentSources = item.GetMediaSources(false).SelectMany(source => source.MediaAttachments).ToList();
+ var attachmentStream = attachmentSources
+ .Where(stream => !string.IsNullOrEmpty(stream.FileName))
+ .First(stream => imageFileNames.Any(name => stream.FileName.Contains(name, StringComparison.OrdinalIgnoreCase)));
+
+ if (attachmentStream != null)
+ {
+ var extension = (string.IsNullOrEmpty(attachmentStream.MimeType) ?
+ Path.GetExtension(attachmentStream.FileName) :
+ MimeTypes.ToExtension(attachmentStream.MimeType)) ?? "jpg";
+
+ string extractedAttachmentPath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, null, attachmentStream.Index, extension, cancellationToken).ConfigureAwait(false);
+
+ ImageFormat format = extension switch
+ {
+ "bmp" => ImageFormat.Bmp,
+ "gif" => ImageFormat.Gif,
+ "jpg" => ImageFormat.Jpg,
+ "png" => ImageFormat.Png,
+ "webp" => ImageFormat.Webp,
+ _ => ImageFormat.Jpg
+ };
+
+ return new DynamicImageResponse
+ {
+ Format = format,
+ HasImage = true,
+ Path = extractedAttachmentPath,
+ Protocol = MediaProtocol.File
+ };
}
- var imageStreams =
- item.GetMediaStreams()
- .Where(i => i.Type == MediaStreamType.EmbeddedImage)
- .ToList();
+ // Fall back to EmbeddedImage streams
+ var imageStreams = item.GetMediaStreams().FindAll(i => i.Type == MediaStreamType.EmbeddedImage);
if (!imageStreams.Any())
{
@@ -160,7 +186,7 @@ namespace MediaBrowser.Providers.MediaInfo
}
}
- string extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, imageStream, imageStream.Index, cancellationToken).ConfigureAwait(false);
+ string extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, imageStream, imageStream.Index, "jpg", cancellationToken).ConfigureAwait(false);
return new DynamicImageResponse
{
From e3eee10d05e9ecc7e3fac1f8fdad92329d38a4db Mon Sep 17 00:00:00 2001
From: Joe Rogers <1337joe@gmail.com>
Date: Mon, 11 Oct 2021 12:34:18 +0200
Subject: [PATCH 4/5] Add image provider tests and clean up
---
.../MediaEncoding/IMediaEncoder.cs | 2 +-
.../Encoder/MediaEncoder.cs | 6 +-
.../MediaInfo/EmbeddedImageProvider.cs | 41 ++--
.../MediaInfo/VideoImageProvider.cs | 9 +-
.../MediaInfo/EmbeddedImageProviderTests.cs | 211 ++++++++++++++++++
.../MediaInfo/VideoImageProviderTests.cs | 168 ++++++++++++++
6 files changed, 408 insertions(+), 29 deletions(-)
create mode 100644 tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
create mode 100644 tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
diff --git a/MediaBrowser.Controller/MediaEncoding/IMediaEncoder.cs b/MediaBrowser.Controller/MediaEncoding/IMediaEncoder.cs
index 638588560d..e6511ca8d7 100644
--- a/MediaBrowser.Controller/MediaEncoding/IMediaEncoder.cs
+++ b/MediaBrowser.Controller/MediaEncoding/IMediaEncoder.cs
@@ -95,7 +95,7 @@ namespace MediaBrowser.Controller.MediaEncoding
/// Media source information.
/// Media stream information.
/// Index of the stream to extract from.
- /// The extension of the file to write.
+ /// The extension of the file to write, including the '.'.
/// CancellationToken to use for operation.
/// Location of video image.
Task ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStream imageStream, int? imageStreamIndex, string outputExtension, CancellationToken cancellationToken);
diff --git a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
index 30bc7125d7..dac2c6a26a 100644
--- a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
+++ b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
@@ -468,12 +468,12 @@ namespace MediaBrowser.MediaEncoding.Encoder
Protocol = MediaProtocol.File
};
- return ExtractImage(path, null, null, imageStreamIndex, mediaSource, true, null, null, "jpg", cancellationToken);
+ return ExtractImage(path, null, null, imageStreamIndex, mediaSource, true, null, null, ".jpg", cancellationToken);
}
public Task ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStream videoStream, Video3DFormat? threedFormat, TimeSpan? offset, CancellationToken cancellationToken)
{
- return ExtractImage(inputFile, container, videoStream, null, mediaSource, false, threedFormat, offset, "jpg", cancellationToken);
+ return ExtractImage(inputFile, container, videoStream, null, mediaSource, false, threedFormat, offset, ".jpg", cancellationToken);
}
public Task ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStream imageStream, int? imageStreamIndex, string outputExtension, CancellationToken cancellationToken)
@@ -548,7 +548,7 @@ namespace MediaBrowser.MediaEncoding.Encoder
throw new ArgumentNullException(nameof(inputPath));
}
- var tempExtractPath = Path.Combine(_configurationManager.ApplicationPaths.TempDirectory, Guid.NewGuid() + "." + outputExtension);
+ var tempExtractPath = Path.Combine(_configurationManager.ApplicationPaths.TempDirectory, Guid.NewGuid() + outputExtension);
Directory.CreateDirectory(Path.GetDirectoryName(tempExtractPath));
// apply some filters to thumbnail extracted below (below) crop any black lines that we made and get the correct ar.
diff --git a/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
index ad95cdb06f..df87f2d49c 100644
--- a/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
@@ -1,9 +1,7 @@
-#nullable enable
#pragma warning disable CS1591
using System;
using System.Collections.Generic;
-using System.Collections.Immutable;
using System.IO;
using System.Linq;
using System.Threading;
@@ -17,7 +15,6 @@ using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.MediaInfo;
using MediaBrowser.Model.Net;
-using Microsoft.Extensions.Logging;
namespace MediaBrowser.Providers.MediaInfo
{
@@ -48,12 +45,10 @@ namespace MediaBrowser.Providers.MediaInfo
};
private readonly IMediaEncoder _mediaEncoder;
- private readonly ILogger _logger;
- public EmbeddedImageProvider(IMediaEncoder mediaEncoder, ILogger logger)
+ public EmbeddedImageProvider(IMediaEncoder mediaEncoder)
{
_mediaEncoder = mediaEncoder;
- _logger = logger;
}
///
@@ -84,7 +79,7 @@ namespace MediaBrowser.Providers.MediaInfo
};
}
- return ImmutableList.Empty;
+ return new List();
}
///
@@ -98,13 +93,6 @@ namespace MediaBrowser.Providers.MediaInfo
return Task.FromResult(new DynamicImageResponse { HasImage = false });
}
- // Can't extract if we didn't find any video streams in the file
- if (!video.DefaultVideoStreamIndex.HasValue)
- {
- _logger.LogInformation("Skipping image extraction due to missing DefaultVideoStreamIndex for {Path}.", video.Path ?? string.Empty);
- return Task.FromResult(new DynamicImageResponse { HasImage = false });
- }
-
return GetEmbeddedImage(video, type, cancellationToken);
}
@@ -128,24 +116,29 @@ namespace MediaBrowser.Providers.MediaInfo
// Try attachments first
var attachmentSources = item.GetMediaSources(false).SelectMany(source => source.MediaAttachments).ToList();
var attachmentStream = attachmentSources
- .Where(stream => !string.IsNullOrEmpty(stream.FileName))
- .First(stream => imageFileNames.Any(name => stream.FileName.Contains(name, StringComparison.OrdinalIgnoreCase)));
+ .Where(attachment => !string.IsNullOrEmpty(attachment.FileName))
+ .FirstOrDefault(attachment => imageFileNames.Any(name => attachment.FileName.Contains(name, StringComparison.OrdinalIgnoreCase)));
if (attachmentStream != null)
{
- var extension = (string.IsNullOrEmpty(attachmentStream.MimeType) ?
+ var extension = string.IsNullOrEmpty(attachmentStream.MimeType) ?
Path.GetExtension(attachmentStream.FileName) :
- MimeTypes.ToExtension(attachmentStream.MimeType)) ?? "jpg";
+ MimeTypes.ToExtension(attachmentStream.MimeType);
+
+ if (string.IsNullOrEmpty(extension))
+ {
+ extension = ".jpg";
+ }
string extractedAttachmentPath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, null, attachmentStream.Index, extension, cancellationToken).ConfigureAwait(false);
ImageFormat format = extension switch
{
- "bmp" => ImageFormat.Bmp,
- "gif" => ImageFormat.Gif,
- "jpg" => ImageFormat.Jpg,
- "png" => ImageFormat.Png,
- "webp" => ImageFormat.Webp,
+ ".bmp" => ImageFormat.Bmp,
+ ".gif" => ImageFormat.Gif,
+ ".jpg" => ImageFormat.Jpg,
+ ".png" => ImageFormat.Png,
+ ".webp" => ImageFormat.Webp,
_ => ImageFormat.Jpg
};
@@ -170,7 +163,7 @@ namespace MediaBrowser.Providers.MediaInfo
// Extract first stream containing an element of imageFileNames
var imageStream = imageStreams
.Where(stream => !string.IsNullOrEmpty(stream.Comment))
- .First(stream => imageFileNames.Any(name => stream.Comment.Contains(name, StringComparison.OrdinalIgnoreCase)));
+ .FirstOrDefault(stream => imageFileNames.Any(name => stream.Comment.Contains(name, StringComparison.OrdinalIgnoreCase)));
// Primary type only: default to first image if none found by label
if (imageStream == null)
diff --git a/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs b/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
index 8f20099505..60739f1564 100644
--- a/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
@@ -81,7 +81,14 @@ namespace MediaBrowser.Providers.MediaInfo
? TimeSpan.FromTicks(item.RunTimeTicks.Value / 10)
: TimeSpan.FromSeconds(10);
- var videoStream = item.GetMediaStreams().FirstOrDefault(i => i.Type == MediaStreamType.Video);
+ var videoStream = item.GetDefaultVideoStream() ?? item.GetMediaStreams().FirstOrDefault(i => i.Type == MediaStreamType.Video);
+
+ if (videoStream == null)
+ {
+ _logger.LogInformation("Skipping image extraction: no video stream found for {Path}.", item.Path ?? string.Empty);
+ return new DynamicImageResponse { HasImage = false };
+ }
+
string extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, videoStream, item.Video3DFormat, imageOffset, cancellationToken).ConfigureAwait(false);
return new DynamicImageResponse
diff --git a/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs b/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
new file mode 100644
index 0000000000..fcea1532af
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
@@ -0,0 +1,211 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Providers.MediaInfo;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Providers.Tests.MediaInfo
+{
+ public class EmbeddedImageProviderTests
+ {
+ public static TheoryData GetSupportedImages_Empty_TestData =>
+ new ()
+ {
+ new AudioBook(),
+ new BoxSet(),
+ new Series(),
+ new Season(),
+ };
+
+ public static TheoryData> GetSupportedImages_Populated_TestData =>
+ new TheoryData>
+ {
+ { new Episode(), new List { ImageType.Primary } },
+ { new Movie(), new List { ImageType.Logo, ImageType.Backdrop, ImageType.Primary } },
+ };
+
+ private EmbeddedImageProvider GetEmbeddedImageProvider(IMediaEncoder? mediaEncoder)
+ {
+ return new EmbeddedImageProvider(mediaEncoder);
+ }
+
+ [Theory]
+ [MemberData(nameof(GetSupportedImages_Empty_TestData))]
+ public void GetSupportedImages_Empty(BaseItem item)
+ {
+ var embeddedImageProvider = GetEmbeddedImageProvider(null);
+ Assert.False(embeddedImageProvider.GetSupportedImages(item).Any());
+ }
+
+ [Theory]
+ [MemberData(nameof(GetSupportedImages_Populated_TestData))]
+ public void GetSupportedImages_Populated(BaseItem item, IEnumerable expected)
+ {
+ var embeddedImageProvider = GetEmbeddedImageProvider(null);
+ var actual = embeddedImageProvider.GetSupportedImages(item);
+ Assert.Equal(expected.OrderBy(i => i.ToString()), actual.OrderBy(i => i.ToString()));
+ }
+
+ [Fact]
+ public async void GetImage_Empty_NoStreams()
+ {
+ var embeddedImageProvider = GetEmbeddedImageProvider(null);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetMediaSources(It.IsAny()))
+ .Returns(new List());
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List());
+
+ var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.False(actual.HasImage);
+ }
+
+ [Fact]
+ public async void GetImage_Empty_NoLabeledAttachments()
+ {
+ var embeddedImageProvider = GetEmbeddedImageProvider(null);
+
+ var input = new Mock();
+ // add an attachment without a filename - has a list to look through but finds nothing
+ input.Setup(movie => movie.GetMediaSources(It.IsAny()))
+ .Returns(new List { new () { MediaAttachments = new List { new () } } });
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List());
+
+ var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.False(actual.HasImage);
+ }
+
+ [Fact]
+ public async void GetImage_Empty_NoEmbeddedLabeledBackdrop()
+ {
+ var embeddedImageProvider = GetEmbeddedImageProvider(null);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetMediaSources(It.IsAny()))
+ .Returns(new List());
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List { new () { Type = MediaStreamType.EmbeddedImage } });
+
+ var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Backdrop, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.False(actual.HasImage);
+ }
+
+ [Fact]
+ public async void GetImage_Attached()
+ {
+ // first tests file extension detection, second uses mimetype, third defaults to jpg
+ MediaAttachment sampleAttachment1 = new () { FileName = "clearlogo.png", Index = 1 };
+ MediaAttachment sampleAttachment2 = new () { FileName = "backdrop", MimeType = "image/bmp", Index = 2 };
+ MediaAttachment sampleAttachment3 = new () { FileName = "poster", Index = 3 };
+ string targetPath1 = "path1.png";
+ string targetPath2 = "path2.bmp";
+ string targetPath3 = "path2.jpg";
+
+ var mediaEncoder = new Mock(MockBehavior.Strict);
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), 1, ".png", CancellationToken.None))
+ .Returns(Task.FromResult(targetPath1));
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), 2, ".bmp", CancellationToken.None))
+ .Returns(Task.FromResult(targetPath2));
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), 3, ".jpg", CancellationToken.None))
+ .Returns(Task.FromResult(targetPath3));
+ var embeddedImageProvider = GetEmbeddedImageProvider(mediaEncoder.Object);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetMediaSources(It.IsAny()))
+ .Returns(new List { new () { MediaAttachments = new List { sampleAttachment1, sampleAttachment2, sampleAttachment3 } } });
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List());
+
+ var actualLogo = await embeddedImageProvider.GetImage(input.Object, ImageType.Logo, CancellationToken.None);
+ Assert.NotNull(actualLogo);
+ Assert.True(actualLogo.HasImage);
+ Assert.Equal(targetPath1, actualLogo.Path);
+ Assert.Equal(ImageFormat.Png, actualLogo.Format);
+
+ var actualBackdrop = await embeddedImageProvider.GetImage(input.Object, ImageType.Backdrop, CancellationToken.None);
+ Assert.NotNull(actualBackdrop);
+ Assert.True(actualBackdrop.HasImage);
+ Assert.Equal(targetPath2, actualBackdrop.Path);
+ Assert.Equal(ImageFormat.Bmp, actualBackdrop.Format);
+
+ var actualPrimary = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actualPrimary);
+ Assert.True(actualPrimary.HasImage);
+ Assert.Equal(targetPath3, actualPrimary.Path);
+ Assert.Equal(ImageFormat.Jpg, actualPrimary.Format);
+ }
+
+ [Fact]
+ public async void GetImage_EmbeddedDefault()
+ {
+ MediaStream sampleStream = new () { Type = MediaStreamType.EmbeddedImage, Index = 1 };
+ string targetPath = "path";
+
+ var mediaEncoder = new Mock(MockBehavior.Strict);
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), sampleStream, 1, "jpg", CancellationToken.None))
+ .Returns(Task.FromResult(targetPath));
+ var embeddedImageProvider = GetEmbeddedImageProvider(mediaEncoder.Object);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetMediaSources(It.IsAny()))
+ .Returns(new List());
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List() { sampleStream });
+
+ var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.True(actual.HasImage);
+ Assert.Equal(targetPath, actual.Path);
+ Assert.Equal(ImageFormat.Jpg, actual.Format);
+ }
+
+ [Fact]
+ public async void GetImage_EmbeddedSelection()
+ {
+ // primary is second stream to ensure it's not defaulting, backdrop is first
+ MediaStream sampleStream1 = new () { Type = MediaStreamType.EmbeddedImage, Index = 1, Comment = "backdrop" };
+ MediaStream sampleStream2 = new () { Type = MediaStreamType.EmbeddedImage, Index = 2, Comment = "cover" };
+ string targetPath1 = "path1.jpg";
+ string targetPath2 = "path2.jpg";
+
+ var mediaEncoder = new Mock(MockBehavior.Strict);
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), sampleStream1, 1, "jpg", CancellationToken.None))
+ .Returns(Task.FromResult(targetPath1));
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), sampleStream2, 2, "jpg", CancellationToken.None))
+ .Returns(Task.FromResult(targetPath2));
+ var embeddedImageProvider = GetEmbeddedImageProvider(mediaEncoder.Object);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetMediaSources(It.IsAny()))
+ .Returns(new List());
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List { sampleStream1, sampleStream2 });
+
+ var actualPrimary = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actualPrimary);
+ Assert.True(actualPrimary.HasImage);
+ Assert.Equal(targetPath2, actualPrimary.Path);
+ Assert.Equal(ImageFormat.Jpg, actualPrimary.Format);
+
+ var actualBackdrop = await embeddedImageProvider.GetImage(input.Object, ImageType.Backdrop, CancellationToken.None);
+ Assert.NotNull(actualBackdrop);
+ Assert.True(actualBackdrop.HasImage);
+ Assert.Equal(targetPath1, actualBackdrop.Path);
+ Assert.Equal(ImageFormat.Jpg, actualBackdrop.Format);
+ }
+ }
+}
diff --git a/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs b/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
new file mode 100644
index 0000000000..9a5cd79bbf
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
@@ -0,0 +1,168 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Providers.MediaInfo;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Providers.Tests.MediaInfo
+{
+ public class VideoImageProviderTests
+ {
+ private VideoImageProvider GetVideoImageProvider(IMediaEncoder? mediaEncoder)
+ {
+ // strict to ensure this isn't accidentally used where a prepared mock is intended
+ mediaEncoder ??= new Mock(MockBehavior.Strict).Object;
+ return new VideoImageProvider(mediaEncoder, new NullLogger());
+ }
+
+ [Fact]
+ public async void GetImage_Empty_IsPlaceholder()
+ {
+ var videoImageProvider = GetVideoImageProvider(null);
+
+ var input = new Mock();
+ input.Object.IsPlaceHolder = true;
+
+ var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.False(actual.HasImage);
+ }
+
+ [Fact]
+ public async void GetImage_Empty_NoDefaultVideoStream()
+ {
+ var videoImageProvider = GetVideoImageProvider(null);
+
+ var input = new Mock();
+
+ var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.False(actual.HasImage);
+ }
+
+ [Fact]
+ public async void GetImage_Empty_DefaultSet_NoVideoStream()
+ {
+ var videoImageProvider = GetVideoImageProvider(null);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List());
+ // set a default index but don't put anything there (invalid input, but provider shouldn't break)
+ input.Object.DefaultVideoStreamIndex = 1;
+
+ var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.False(actual.HasImage);
+ }
+
+ [Fact]
+ public async void GetImage_Extract_DefaultStream()
+ {
+ MediaStream firstStream = new () { Type = MediaStreamType.Video, Index = 0 };
+ MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 1 };
+ string targetPath = "path.jpg";
+
+ var mediaEncoder = new Mock(MockBehavior.Strict);
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), firstStream, It.IsAny(), It.IsAny(), CancellationToken.None))
+ .Returns(Task.FromResult("wrong stream called!"));
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), targetStream, It.IsAny(), It.IsAny(), CancellationToken.None))
+ .Returns(Task.FromResult(targetPath));
+ var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetDefaultVideoStream())
+ .Returns(targetStream);
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List() { firstStream, targetStream });
+ input.Object.DefaultVideoStreamIndex = 1;
+
+ var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.True(actual.HasImage);
+ Assert.Equal(targetPath, actual.Path);
+ Assert.Equal(ImageFormat.Jpg, actual.Format);
+ }
+
+ [Fact]
+ public async void GetImage_Extract_FallbackToFirstVideoStream()
+ {
+ MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
+ string targetPath = "path.jpg";
+
+ var mediaEncoder = new Mock(MockBehavior.Strict);
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), targetStream, It.IsAny(), It.IsAny(), CancellationToken.None))
+ .Returns(Task.FromResult(targetPath));
+ var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List() { targetStream });
+ // default must be set, ensure a stream is still found if not pointed at a video
+ input.Object.DefaultVideoStreamIndex = 5;
+
+ var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.True(actual.HasImage);
+ Assert.Equal(targetPath, actual.Path);
+ Assert.Equal(ImageFormat.Jpg, actual.Format);
+ }
+
+ [Fact]
+ public async void GetImage_Time_Default()
+ {
+ MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
+
+ TimeSpan? actualTimeSpan = null;
+ var mediaEncoder = new Mock(MockBehavior.Strict);
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), CancellationToken.None))
+ .Callback((_, _, _, _, _, timeSpan, _) => actualTimeSpan = timeSpan)
+ .Returns(Task.FromResult("path"));
+ var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List() { targetStream });
+ // default must be set
+ input.Object.DefaultVideoStreamIndex = 0;
+
+ // not testing return, just verifying what gets requested for time span
+ await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+
+ Assert.Equal(TimeSpan.FromSeconds(10), actualTimeSpan);
+ }
+
+ [Fact]
+ public async void GetImage_Time_Calculated()
+ {
+ MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
+
+ TimeSpan? actualTimeSpan = null;
+ var mediaEncoder = new Mock(MockBehavior.Strict);
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), CancellationToken.None))
+ .Callback((_, _, _, _, _, timeSpan, _) => actualTimeSpan = timeSpan)
+ .Returns(Task.FromResult("path"));
+ var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
+
+ var input = new Mock();
+ input.Setup(movie => movie.GetMediaStreams())
+ .Returns(new List() { targetStream });
+ // default must be set
+ input.Object.DefaultVideoStreamIndex = 0;
+ input.Object.RunTimeTicks = 5000;
+
+ // not testing return, just verifying what gets requested for time span
+ await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+
+ Assert.Equal(TimeSpan.FromTicks(500), actualTimeSpan);
+ }
+ }
+}
From 31baea072a1ed25346437150f27a93916cb4cca0 Mon Sep 17 00:00:00 2001
From: Joe Rogers <1337joe@gmail.com>
Date: Mon, 11 Oct 2021 21:25:12 +0200
Subject: [PATCH 5/5] Address review comments
Clean up style
Fix references in class summaries
Combine Where+FirstOrDefault queries
Break up large method, long lines
Add validation on file extension
Apply test naming conventions
Extract mock of Movie class, comment on why not mocking interface
Co-authored-by: Cody Robibero
Co-authored-by: Claus Vium
---
.../Encoder/MediaEncoder.cs | 9 +
.../Probing/ProbeResultNormalizer.cs | 4 +-
.../MediaInfo/EmbeddedImageProvider.cs | 95 ++++++-----
.../MediaInfo/VideoImageProvider.cs | 10 +-
.../MediaInfo/EmbeddedImageProviderTests.cs | 155 +++++++++---------
.../MediaInfo/VideoImageProviderTests.cs | 108 ++++++------
6 files changed, 208 insertions(+), 173 deletions(-)
diff --git a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
index dac2c6a26a..102b4f943e 100644
--- a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
+++ b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
@@ -548,6 +548,15 @@ namespace MediaBrowser.MediaEncoding.Encoder
throw new ArgumentNullException(nameof(inputPath));
}
+ if (string.IsNullOrEmpty(outputExtension))
+ {
+ outputExtension = ".jpg";
+ }
+ else if (outputExtension[0] != '.')
+ {
+ outputExtension = "." + outputExtension;
+ }
+
var tempExtractPath = Path.Combine(_configurationManager.ApplicationPaths.TempDirectory, Guid.NewGuid() + outputExtension);
Directory.CreateDirectory(Path.GetDirectoryName(tempExtractPath));
diff --git a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
index 775689095f..9279cb220a 100644
--- a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
+++ b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
@@ -582,8 +582,8 @@ namespace MediaBrowser.MediaEncoding.Probing
/// MediaAttachments.
private MediaAttachment GetMediaAttachment(MediaStreamInfo streamInfo)
{
- if (!string.Equals(streamInfo.CodecType, "attachment", StringComparison.OrdinalIgnoreCase) &&
- !(streamInfo.Disposition != null && streamInfo.Disposition.GetValueOrDefault("attached_pic") == 1))
+ if (!string.Equals(streamInfo.CodecType, "attachment", StringComparison.OrdinalIgnoreCase)
+ && streamInfo.Disposition?.GetValueOrDefault("attached_pic") != 1)
{
return null;
}
diff --git a/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
index df87f2d49c..1d9d1e02a5 100644
--- a/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/EmbeddedImageProvider.cs
@@ -1,5 +1,3 @@
-#pragma warning disable CS1591
-
using System;
using System.Collections.Generic;
using System.IO;
@@ -19,7 +17,7 @@ using MediaBrowser.Model.Net;
namespace MediaBrowser.Providers.MediaInfo
{
///
- /// Uses ffmpeg to extract embedded images.
+ /// Uses to extract embedded images.
///
public class EmbeddedImageProvider : IDynamicImageProvider, IHasOrder
{
@@ -46,6 +44,10 @@ namespace MediaBrowser.Providers.MediaInfo
private readonly IMediaEncoder _mediaEncoder;
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The media encoder for extracting attached/embedded images.
public EmbeddedImageProvider(IMediaEncoder mediaEncoder)
{
_mediaEncoder = mediaEncoder;
@@ -65,13 +67,13 @@ namespace MediaBrowser.Providers.MediaInfo
{
if (item is Episode)
{
- return new List
+ return new[]
{
ImageType.Primary,
};
}
- return new List
+ return new[]
{
ImageType.Primary,
ImageType.Backdrop,
@@ -79,7 +81,7 @@ namespace MediaBrowser.Providers.MediaInfo
};
}
- return new List();
+ return Array.Empty();
}
///
@@ -114,47 +116,20 @@ namespace MediaBrowser.Providers.MediaInfo
};
// Try attachments first
- var attachmentSources = item.GetMediaSources(false).SelectMany(source => source.MediaAttachments).ToList();
- var attachmentStream = attachmentSources
- .Where(attachment => !string.IsNullOrEmpty(attachment.FileName))
- .FirstOrDefault(attachment => imageFileNames.Any(name => attachment.FileName.Contains(name, StringComparison.OrdinalIgnoreCase)));
+ var attachmentStream = item.GetMediaSources(false)
+ .SelectMany(source => source.MediaAttachments)
+ .FirstOrDefault(attachment => !string.IsNullOrEmpty(attachment.FileName)
+ && imageFileNames.Any(name => attachment.FileName.Contains(name, StringComparison.OrdinalIgnoreCase)));
if (attachmentStream != null)
{
- var extension = string.IsNullOrEmpty(attachmentStream.MimeType) ?
- Path.GetExtension(attachmentStream.FileName) :
- MimeTypes.ToExtension(attachmentStream.MimeType);
-
- if (string.IsNullOrEmpty(extension))
- {
- extension = ".jpg";
- }
-
- string extractedAttachmentPath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, null, attachmentStream.Index, extension, cancellationToken).ConfigureAwait(false);
-
- ImageFormat format = extension switch
- {
- ".bmp" => ImageFormat.Bmp,
- ".gif" => ImageFormat.Gif,
- ".jpg" => ImageFormat.Jpg,
- ".png" => ImageFormat.Png,
- ".webp" => ImageFormat.Webp,
- _ => ImageFormat.Jpg
- };
-
- return new DynamicImageResponse
- {
- Format = format,
- HasImage = true,
- Path = extractedAttachmentPath,
- Protocol = MediaProtocol.File
- };
+ return await ExtractAttachment(item, cancellationToken, attachmentStream, mediaSource);
}
// Fall back to EmbeddedImage streams
var imageStreams = item.GetMediaStreams().FindAll(i => i.Type == MediaStreamType.EmbeddedImage);
- if (!imageStreams.Any())
+ if (imageStreams.Count == 0)
{
// Can't extract if we don't have any EmbeddedImage streams
return new DynamicImageResponse { HasImage = false };
@@ -162,8 +137,8 @@ namespace MediaBrowser.Providers.MediaInfo
// Extract first stream containing an element of imageFileNames
var imageStream = imageStreams
- .Where(stream => !string.IsNullOrEmpty(stream.Comment))
- .FirstOrDefault(stream => imageFileNames.Any(name => stream.Comment.Contains(name, StringComparison.OrdinalIgnoreCase)));
+ .FirstOrDefault(stream => !string.IsNullOrEmpty(stream.Comment)
+ && imageFileNames.Any(name => stream.Comment.Contains(name, StringComparison.OrdinalIgnoreCase)));
// Primary type only: default to first image if none found by label
if (imageStream == null)
@@ -179,7 +154,9 @@ namespace MediaBrowser.Providers.MediaInfo
}
}
- string extractedImagePath = await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, imageStream, imageStream.Index, "jpg", cancellationToken).ConfigureAwait(false);
+ string extractedImagePath =
+ await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, imageStream, imageStream.Index, ".jpg", cancellationToken)
+ .ConfigureAwait(false);
return new DynamicImageResponse
{
@@ -190,6 +167,40 @@ namespace MediaBrowser.Providers.MediaInfo
};
}
+ private async Task ExtractAttachment(Video item, CancellationToken cancellationToken, MediaAttachment attachmentStream, MediaSourceInfo mediaSource)
+ {
+ var extension = string.IsNullOrEmpty(attachmentStream.MimeType)
+ ? Path.GetExtension(attachmentStream.FileName)
+ : MimeTypes.ToExtension(attachmentStream.MimeType);
+
+ if (string.IsNullOrEmpty(extension))
+ {
+ extension = ".jpg";
+ }
+
+ string extractedAttachmentPath =
+ await _mediaEncoder.ExtractVideoImage(item.Path, item.Container, mediaSource, null, attachmentStream.Index, extension, cancellationToken)
+ .ConfigureAwait(false);
+
+ ImageFormat format = extension switch
+ {
+ ".bmp" => ImageFormat.Bmp,
+ ".gif" => ImageFormat.Gif,
+ ".jpg" => ImageFormat.Jpg,
+ ".png" => ImageFormat.Png,
+ ".webp" => ImageFormat.Webp,
+ _ => ImageFormat.Jpg
+ };
+
+ return new DynamicImageResponse
+ {
+ Format = format,
+ HasImage = true,
+ Path = extractedAttachmentPath,
+ Protocol = MediaProtocol.File
+ };
+ }
+
///
public bool Supports(BaseItem item)
{
diff --git a/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs b/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
index 60739f1564..d226182c09 100644
--- a/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
@@ -1,6 +1,3 @@
-#nullable enable
-#pragma warning disable CS1591
-
using System;
using System.Collections.Generic;
using System.Linq;
@@ -18,13 +15,18 @@ using Microsoft.Extensions.Logging;
namespace MediaBrowser.Providers.MediaInfo
{
///
- /// Uses ffmpeg to create still images from the main video.
+ /// Uses to create still images from the main video.
///
public class VideoImageProvider : IDynamicImageProvider, IHasOrder
{
private readonly IMediaEncoder _mediaEncoder;
private readonly ILogger _logger;
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The media encoder for capturing images.
+ /// The logger.
public VideoImageProvider(IMediaEncoder mediaEncoder, ILogger logger)
{
_mediaEncoder = mediaEncoder;
diff --git a/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs b/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
index fcea1532af..b194e38855 100644
--- a/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
+++ b/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
@@ -17,38 +17,37 @@ namespace Jellyfin.Providers.Tests.MediaInfo
{
public class EmbeddedImageProviderTests
{
- public static TheoryData GetSupportedImages_Empty_TestData =>
- new ()
+ private static TheoryData GetSupportedImages_UnsupportedBaseItems_ReturnsEmpty_TestData()
+ {
+ return new ()
{
new AudioBook(),
new BoxSet(),
new Series(),
new Season(),
};
-
- public static TheoryData> GetSupportedImages_Populated_TestData =>
- new TheoryData>
- {
- { new Episode(), new List { ImageType.Primary } },
- { new Movie(), new List { ImageType.Logo, ImageType.Backdrop, ImageType.Primary } },
- };
-
- private EmbeddedImageProvider GetEmbeddedImageProvider(IMediaEncoder? mediaEncoder)
- {
- return new EmbeddedImageProvider(mediaEncoder);
}
[Theory]
- [MemberData(nameof(GetSupportedImages_Empty_TestData))]
- public void GetSupportedImages_Empty(BaseItem item)
+ [MemberData(nameof(GetSupportedImages_UnsupportedBaseItems_ReturnsEmpty_TestData))]
+ public void GetSupportedImages_UnsupportedBaseItems_ReturnsEmpty(BaseItem item)
{
var embeddedImageProvider = GetEmbeddedImageProvider(null);
- Assert.False(embeddedImageProvider.GetSupportedImages(item).Any());
+ Assert.Empty(embeddedImageProvider.GetSupportedImages(item));
+ }
+
+ private static TheoryData> GetSupportedImages_SupportedBaseItems_ReturnsPopulated_TestData()
+ {
+ return new TheoryData>
+ {
+ { new Episode(), new List { ImageType.Primary } },
+ { new Movie(), new List { ImageType.Logo, ImageType.Backdrop, ImageType.Primary } },
+ };
}
[Theory]
- [MemberData(nameof(GetSupportedImages_Populated_TestData))]
- public void GetSupportedImages_Populated(BaseItem item, IEnumerable expected)
+ [MemberData(nameof(GetSupportedImages_SupportedBaseItems_ReturnsPopulated_TestData))]
+ public void GetSupportedImages_SupportedBaseItems_ReturnsPopulated(BaseItem item, IEnumerable expected)
{
var embeddedImageProvider = GetEmbeddedImageProvider(null);
var actual = embeddedImageProvider.GetSupportedImages(item);
@@ -56,56 +55,34 @@ namespace Jellyfin.Providers.Tests.MediaInfo
}
[Fact]
- public async void GetImage_Empty_NoStreams()
+ public async void GetImage_InputWithNoStreams_ReturnsNoImage()
{
var embeddedImageProvider = GetEmbeddedImageProvider(null);
- var input = new Mock();
- input.Setup(movie => movie.GetMediaSources(It.IsAny()))
- .Returns(new List());
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List());
+ var input = GetMovie(new List(), new List());
- var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actual = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actual);
Assert.False(actual.HasImage);
}
[Fact]
- public async void GetImage_Empty_NoLabeledAttachments()
+ public async void GetImage_InputWithUnlabeledAttachments_ReturnsNoImage()
{
var embeddedImageProvider = GetEmbeddedImageProvider(null);
- var input = new Mock();
// add an attachment without a filename - has a list to look through but finds nothing
- input.Setup(movie => movie.GetMediaSources(It.IsAny()))
- .Returns(new List { new () { MediaAttachments = new List { new () } } });
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List());
+ var input = GetMovie(
+ new List { new () },
+ new List());
- var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actual = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actual);
Assert.False(actual.HasImage);
}
[Fact]
- public async void GetImage_Empty_NoEmbeddedLabeledBackdrop()
- {
- var embeddedImageProvider = GetEmbeddedImageProvider(null);
-
- var input = new Mock();
- input.Setup(movie => movie.GetMediaSources(It.IsAny()))
- .Returns(new List());
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List { new () { Type = MediaStreamType.EmbeddedImage } });
-
- var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Backdrop, CancellationToken.None);
- Assert.NotNull(actual);
- Assert.False(actual.HasImage);
- }
-
- [Fact]
- public async void GetImage_Attached()
+ public async void GetImage_InputWithLabeledAttachments_ReturnsCorrectSelection()
{
// first tests file extension detection, second uses mimetype, third defaults to jpg
MediaAttachment sampleAttachment1 = new () { FileName = "clearlogo.png", Index = 1 };
@@ -124,25 +101,23 @@ namespace Jellyfin.Providers.Tests.MediaInfo
.Returns(Task.FromResult(targetPath3));
var embeddedImageProvider = GetEmbeddedImageProvider(mediaEncoder.Object);
- var input = new Mock();
- input.Setup(movie => movie.GetMediaSources(It.IsAny()))
- .Returns(new List { new () { MediaAttachments = new List { sampleAttachment1, sampleAttachment2, sampleAttachment3 } } });
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List());
+ var input = GetMovie(
+ new List { sampleAttachment1, sampleAttachment2, sampleAttachment3 },
+ new List());
- var actualLogo = await embeddedImageProvider.GetImage(input.Object, ImageType.Logo, CancellationToken.None);
+ var actualLogo = await embeddedImageProvider.GetImage(input, ImageType.Logo, CancellationToken.None);
Assert.NotNull(actualLogo);
Assert.True(actualLogo.HasImage);
Assert.Equal(targetPath1, actualLogo.Path);
Assert.Equal(ImageFormat.Png, actualLogo.Format);
- var actualBackdrop = await embeddedImageProvider.GetImage(input.Object, ImageType.Backdrop, CancellationToken.None);
+ var actualBackdrop = await embeddedImageProvider.GetImage(input, ImageType.Backdrop, CancellationToken.None);
Assert.NotNull(actualBackdrop);
Assert.True(actualBackdrop.HasImage);
Assert.Equal(targetPath2, actualBackdrop.Path);
Assert.Equal(ImageFormat.Bmp, actualBackdrop.Format);
- var actualPrimary = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actualPrimary = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actualPrimary);
Assert.True(actualPrimary.HasImage);
Assert.Equal(targetPath3, actualPrimary.Path);
@@ -150,23 +125,35 @@ namespace Jellyfin.Providers.Tests.MediaInfo
}
[Fact]
- public async void GetImage_EmbeddedDefault()
+ public async void GetImage_InputWithUnlabeledEmbeddedImages_BackdropReturnsNoImage()
+ {
+ var embeddedImageProvider = GetEmbeddedImageProvider(null);
+
+ var input = GetMovie(
+ new List(),
+ new List { new () { Type = MediaStreamType.EmbeddedImage } });
+
+ var actual = await embeddedImageProvider.GetImage(input, ImageType.Backdrop, CancellationToken.None);
+ Assert.NotNull(actual);
+ Assert.False(actual.HasImage);
+ }
+
+ [Fact]
+ public async void GetImage_InputWithUnlabeledEmbeddedImages_PrimaryReturnsImage()
{
MediaStream sampleStream = new () { Type = MediaStreamType.EmbeddedImage, Index = 1 };
string targetPath = "path";
var mediaEncoder = new Mock(MockBehavior.Strict);
- mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), sampleStream, 1, "jpg", CancellationToken.None))
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), sampleStream, 1, ".jpg", CancellationToken.None))
.Returns(Task.FromResult(targetPath));
var embeddedImageProvider = GetEmbeddedImageProvider(mediaEncoder.Object);
- var input = new Mock();
- input.Setup(movie => movie.GetMediaSources(It.IsAny()))
- .Returns(new List());
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List() { sampleStream });
+ var input = GetMovie(
+ new List(),
+ new List { sampleStream });
- var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actual = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actual);
Assert.True(actual.HasImage);
Assert.Equal(targetPath, actual.Path);
@@ -174,7 +161,7 @@ namespace Jellyfin.Providers.Tests.MediaInfo
}
[Fact]
- public async void GetImage_EmbeddedSelection()
+ public async void GetImage_InputWithLabeledEmbeddedImages_ReturnsCorrectSelection()
{
// primary is second stream to ensure it's not defaulting, backdrop is first
MediaStream sampleStream1 = new () { Type = MediaStreamType.EmbeddedImage, Index = 1, Comment = "backdrop" };
@@ -183,29 +170,47 @@ namespace Jellyfin.Providers.Tests.MediaInfo
string targetPath2 = "path2.jpg";
var mediaEncoder = new Mock(MockBehavior.Strict);
- mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), sampleStream1, 1, "jpg", CancellationToken.None))
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), sampleStream1, 1, ".jpg", CancellationToken.None))
.Returns(Task.FromResult(targetPath1));
- mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), sampleStream2, 2, "jpg", CancellationToken.None))
+ mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), sampleStream2, 2, ".jpg", CancellationToken.None))
.Returns(Task.FromResult(targetPath2));
var embeddedImageProvider = GetEmbeddedImageProvider(mediaEncoder.Object);
- var input = new Mock();
- input.Setup(movie => movie.GetMediaSources(It.IsAny()))
- .Returns(new List());
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List { sampleStream1, sampleStream2 });
+ var input = GetMovie(
+ new List(),
+ new List { sampleStream1, sampleStream2 });
- var actualPrimary = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actualPrimary = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actualPrimary);
Assert.True(actualPrimary.HasImage);
Assert.Equal(targetPath2, actualPrimary.Path);
Assert.Equal(ImageFormat.Jpg, actualPrimary.Format);
- var actualBackdrop = await embeddedImageProvider.GetImage(input.Object, ImageType.Backdrop, CancellationToken.None);
+ var actualBackdrop = await embeddedImageProvider.GetImage(input, ImageType.Backdrop, CancellationToken.None);
Assert.NotNull(actualBackdrop);
Assert.True(actualBackdrop.HasImage);
Assert.Equal(targetPath1, actualBackdrop.Path);
Assert.Equal(ImageFormat.Jpg, actualBackdrop.Format);
}
+
+ private static EmbeddedImageProvider GetEmbeddedImageProvider(IMediaEncoder? mediaEncoder)
+ {
+ return new EmbeddedImageProvider(mediaEncoder);
+ }
+
+ private static Movie GetMovie(List mediaAttachments, List mediaStreams)
+ {
+ // Mocking IMediaSourceManager GetMediaAttachments and GetMediaStreams instead of mocking Movie works, but
+ // has concurrency problems between this and VideoImageProviderTests due to BaseItem.MediaSourceManager
+ // being static
+ var movie = new Mock();
+
+ movie.Setup(item => item.GetMediaSources(It.IsAny()))
+ .Returns(new List { new () { MediaAttachments = mediaAttachments } } );
+ movie.Setup(item => item.GetMediaStreams())
+ .Returns(mediaStreams);
+
+ return movie.Object;
+ }
}
}
diff --git a/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs b/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
index 9a5cd79bbf..0f51a2b8f8 100644
--- a/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
+++ b/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
@@ -16,56 +16,51 @@ namespace Jellyfin.Providers.Tests.MediaInfo
{
public class VideoImageProviderTests
{
- private VideoImageProvider GetVideoImageProvider(IMediaEncoder? mediaEncoder)
- {
- // strict to ensure this isn't accidentally used where a prepared mock is intended
- mediaEncoder ??= new Mock(MockBehavior.Strict).Object;
- return new VideoImageProvider(mediaEncoder, new NullLogger());
- }
-
[Fact]
- public async void GetImage_Empty_IsPlaceholder()
+ public async void GetImage_InputIsPlaceholder_ReturnsNoImage()
{
var videoImageProvider = GetVideoImageProvider(null);
- var input = new Mock();
- input.Object.IsPlaceHolder = true;
+ var input = new Movie
+ {
+ IsPlaceHolder = true
+ };
- var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actual);
Assert.False(actual.HasImage);
}
[Fact]
- public async void GetImage_Empty_NoDefaultVideoStream()
+ public async void GetImage_NoDefaultVideoStream_ReturnsNoImage()
{
var videoImageProvider = GetVideoImageProvider(null);
- var input = new Mock();
+ var input = new Movie
+ {
+ DefaultVideoStreamIndex = null
+ };
- var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actual);
Assert.False(actual.HasImage);
}
[Fact]
- public async void GetImage_Empty_DefaultSet_NoVideoStream()
+ public async void GetImage_DefaultSetButNoVideoStream_ReturnsNoImage()
{
var videoImageProvider = GetVideoImageProvider(null);
- var input = new Mock();
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List());
// set a default index but don't put anything there (invalid input, but provider shouldn't break)
- input.Object.DefaultVideoStreamIndex = 1;
+ var input = GetMovie(0, null, new List());
- var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actual);
Assert.False(actual.HasImage);
}
[Fact]
- public async void GetImage_Extract_DefaultStream()
+ public async void GetImage_DefaultSetMultipleVideoStreams_ReturnsDefaultStreamImage()
{
MediaStream firstStream = new () { Type = MediaStreamType.Video, Index = 0 };
MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 1 };
@@ -78,14 +73,9 @@ namespace Jellyfin.Providers.Tests.MediaInfo
.Returns(Task.FromResult(targetPath));
var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
- var input = new Mock();
- input.Setup(movie => movie.GetDefaultVideoStream())
- .Returns(targetStream);
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List() { firstStream, targetStream });
- input.Object.DefaultVideoStreamIndex = 1;
+ var input = GetMovie(1, targetStream, new List { firstStream, targetStream } );
- var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actual);
Assert.True(actual.HasImage);
Assert.Equal(targetPath, actual.Path);
@@ -93,7 +83,7 @@ namespace Jellyfin.Providers.Tests.MediaInfo
}
[Fact]
- public async void GetImage_Extract_FallbackToFirstVideoStream()
+ public async void GetImage_InvalidDefaultSingleVideoStream_ReturnsFirstVideoStreamImage()
{
MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
string targetPath = "path.jpg";
@@ -103,13 +93,10 @@ namespace Jellyfin.Providers.Tests.MediaInfo
.Returns(Task.FromResult(targetPath));
var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
- var input = new Mock();
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List() { targetStream });
- // default must be set, ensure a stream is still found if not pointed at a video
- input.Object.DefaultVideoStreamIndex = 5;
+ // provide query results for default (empty) and all streams (populated)
+ var input = GetMovie(5, null, new List { targetStream });
- var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.NotNull(actual);
Assert.True(actual.HasImage);
Assert.Equal(targetPath, actual.Path);
@@ -117,10 +104,12 @@ namespace Jellyfin.Providers.Tests.MediaInfo
}
[Fact]
- public async void GetImage_Time_Default()
+ public async void GetImage_NoTimeSpanSet_CallsEncoderWithDefaultTime()
{
MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
+ // use a callback to catch the actual value
+ // provides more information on failure than verifying a specific input was called on the mock
TimeSpan? actualTimeSpan = null;
var mediaEncoder = new Mock(MockBehavior.Strict);
mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), CancellationToken.None))
@@ -128,20 +117,16 @@ namespace Jellyfin.Providers.Tests.MediaInfo
.Returns(Task.FromResult("path"));
var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
- var input = new Mock();
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List() { targetStream });
- // default must be set
- input.Object.DefaultVideoStreamIndex = 0;
+ var input = GetMovie(0, targetStream, new List { targetStream });
// not testing return, just verifying what gets requested for time span
- await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.Equal(TimeSpan.FromSeconds(10), actualTimeSpan);
}
[Fact]
- public async void GetImage_Time_Calculated()
+ public async void GetImage_TimeSpanSet_CallsEncoderWithCalculatedTime()
{
MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
@@ -152,17 +137,40 @@ namespace Jellyfin.Providers.Tests.MediaInfo
.Returns(Task.FromResult("path"));
var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
- var input = new Mock();
- input.Setup(movie => movie.GetMediaStreams())
- .Returns(new List() { targetStream });
- // default must be set
- input.Object.DefaultVideoStreamIndex = 0;
- input.Object.RunTimeTicks = 5000;
+ var input = GetMovie(0, targetStream, new List { targetStream });
+ input.RunTimeTicks = 5000;
// not testing return, just verifying what gets requested for time span
- await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+ await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
Assert.Equal(TimeSpan.FromTicks(500), actualTimeSpan);
}
+
+ private static VideoImageProvider GetVideoImageProvider(IMediaEncoder? mediaEncoder)
+ {
+ // strict to ensure this isn't accidentally used where a prepared mock is intended
+ mediaEncoder ??= new Mock(MockBehavior.Strict).Object;
+ return new VideoImageProvider(mediaEncoder, new NullLogger());
+ }
+
+ private static Movie GetMovie(int defaultVideoStreamIndex, MediaStream? defaultStream, List mediaStreams)
+ {
+ // Mocking IMediaSourceManager GetMediaStreams instead of mocking Movie works, but has concurrency problems
+ // between this and EmbeddedImageProviderTests due to BaseItem.MediaSourceManager being static
+ var movie = new Mock
+ {
+ Object =
+ {
+ DefaultVideoStreamIndex = defaultVideoStreamIndex
+ }
+ };
+
+ movie.Setup(item => item.GetDefaultVideoStream())
+ .Returns(defaultStream!);
+ movie.Setup(item => item.GetMediaStreams())
+ .Returns(mediaStreams);
+
+ return movie.Object;
+ }
}
}