public IList <FanArtImage> GetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom)
{
string baseFolder = GetBaseFolder(mediaType, name);
// No known series
if (baseFolder == null || !Directory.Exists(baseFolder))
{
return(null);
}
string pattern = GetPattern(mediaType, fanArtType);
if (string.IsNullOrEmpty(pattern))
{
return(null);
}
DirectoryInfo directoryInfo = new DirectoryInfo(baseFolder);
try
{
List <string> files = directoryInfo.GetFiles(pattern).Select(file => file.FullName).ToList();
List <FanArtImage> fanArtImages = files.Select(f => FanArtImage.FromFile(f, maxWidth, maxHeight)).Where(fanArtImage => fanArtImage != null).ToList();
if (fanArtImages.Count == 0)
{
return(null);
}
return(singleRandom ? GetSingleRandom(fanArtImages) : fanArtImages);
}
catch (DirectoryNotFoundException)
{
return(null);
}
}
/// <summary>
/// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
/// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
/// </summary>
/// <param name="mediaType">Requested FanArtMediaType</param>
/// <param name="fanArtType">Requested FanArtType</param>
/// <param name="name">Requested name of Series, Actor, Artist...</param>
/// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
/// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
/// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
/// <param name="result">Result if return code is <c>true</c>.</param>
/// <returns><c>true</c> if at least one match was found.</returns>
public bool TryGetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
{
result = null;
if (mediaType != FanArtConstants.FanArtMediaType.ChannelTv && mediaType != FanArtConstants.FanArtMediaType.ChannelRadio)
{
return(false);
}
try
{
string designsFolder = FileUtils.BuildAssemblyRelativePath("Designs");
ChannelType logoChannelType = mediaType == FanArtConstants.FanArtMediaType.ChannelTv ? ChannelType.Tv : ChannelType.Radio;
ThemeHandler themeHandler = new ThemeHandler();
Theme theme = themeHandler.Load(Path.Combine(designsFolder, _settings.LogoTheme));
string logoFolder = Path.Combine(_dataFolder, string.Format("{0}-{1}-{2}", logoChannelType, theme.DesignName, theme.ThemeName));
string logoFileName = Path.Combine(logoFolder, FileUtils.GetSafeFilename(string.Format("{0}.png", name)));
if (!Directory.Exists(logoFolder))
{
Directory.CreateDirectory(logoFolder);
}
if (File.Exists(logoFileName))
{
result = new List <IResourceLocator> {
new ResourceLocator(ResourcePath.BuildBaseProviderPath(LocalFsResourceProviderBase.LOCAL_FS_RESOURCE_PROVIDER_ID, logoFileName))
};
return(true);
}
LogoProcessor processor = new LogoProcessor {
DesignsFolder = designsFolder
};
// From repository
using (var repo = new LogoRepository {
RepositoryUrl = _settings.RepositoryUrl
})
{
var stream = repo.Download(name, logoChannelType, _country.TwoLetterISORegionName);
if (stream == null)
{
return(false);
}
using (stream)
if (processor.CreateLogo(theme, stream, logoFileName))
{
result = new List <IResourceLocator> {
new ResourceLocator(ResourcePath.BuildBaseProviderPath(LocalFsResourceProviderBase.LOCAL_FS_RESOURCE_PROVIDER_ID, logoFileName))
};
return(true);
}
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("SlimTv Logos: Error processing logo image.", ex);
}
return(false);
}
/// <summary>
/// Resizes an image to given size. The resized image will be saved to the given stream. Images that
/// are smaller than the requested target size will not be scaled up, but returned in original size.
/// </summary>
/// <param name="originalStream">Image to resize</param>
/// <param name="maxWidth">Maximum image width</param>
/// <param name="maxHeight">Maximum image height</param>
/// <param name="mediaType">MediaType</param>
/// <param name="fanArtType">FanArtType</param>
/// <param name="fanArtName">Fanart name</param>
/// <param name="originalFile">Original Filename</param>
/// <returns></returns>
protected static Stream ResizeImage(Stream originalStream, int maxWidth, int maxHeight, FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string fanArtName, string originalFile)
{
if (maxWidth == 0 || maxHeight == 0)
{
return(originalStream);
}
try
{
if (!Directory.Exists(CACHE_PATH))
{
Directory.CreateDirectory(CACHE_PATH);
}
string thumbFileName = Path.Combine(CACHE_PATH, string.Format("{0}_{1}_{2}x{3}_{4}", fanArtType, fanArtName, maxWidth, maxHeight, Path.GetFileName(originalFile)));
if (File.Exists(thumbFileName))
{
using (originalStream)
return(new FileStream(thumbFileName, FileMode.Open, FileAccess.Read));
}
Image fullsizeImage = Image.FromStream(originalStream);
if (fullsizeImage.Width <= maxWidth)
{
maxWidth = fullsizeImage.Width;
}
int newHeight = fullsizeImage.Height * maxWidth / fullsizeImage.Width;
if (newHeight > maxHeight)
{
// Resize with height instead
maxWidth = fullsizeImage.Width * maxHeight / fullsizeImage.Height;
newHeight = maxHeight;
}
MemoryStream resizedStream = new MemoryStream();
using (fullsizeImage)
using (Image newImage = ImageUtilities.ResizeImage(fullsizeImage, maxWidth, newHeight))
{
ImageUtilities.SaveJpeg(thumbFileName, newImage, 95);
ImageUtilities.SaveJpeg(resizedStream, newImage, 95);
}
resizedStream.Position = 0;
return(resizedStream);
}
catch (Exception)
{
return(originalStream);
}
}
public IList <FanArtImage> GetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom)
{
InitProviders();
foreach (IFanArtProvider fanArtProvider in _providerList)
{
IList <IResourceLocator> fanArtImages;
if (fanArtProvider.TryGetFanArt(mediaType, fanArtType, name, maxWidth, maxHeight, singleRandom, out fanArtImages))
{
IList <IResourceLocator> result = singleRandom ? GetSingleRandom(fanArtImages) : fanArtImages;
return(result.Select(f => FanArtImage.FromResource(f, maxWidth, maxHeight, mediaType, fanArtType, name)).Where(fanArtImage => fanArtImage != null).ToList());
}
}
foreach (IBinaryFanArtProvider binaryProvider in _providerList.OfType <IBinaryFanArtProvider>())
{
if (binaryProvider != null)
{
IList <FanArtImage> binaryImages;
if (binaryProvider.TryGetFanArt(mediaType, fanArtType, name, maxWidth, maxHeight, singleRandom, out binaryImages))
{
return(singleRandom ? GetSingleRandom(binaryImages) : binaryImages);
}
}
}
return(null);
}
/// <summary>
/// Loads an image from filesystem an returns a new <see cref="FanArtImage"/>.
/// </summary>
/// <param name="resourceLocator">Resource to load</param>
/// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
/// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
/// <param name="mediaType">MediaType</param>
/// <param name="fanArtType">FanArtType</param>
/// <param name="fanArtName">Fanart name</param>
/// <returns>FanArtImage or <c>null</c>.</returns>
public static FanArtImage FromResource(IResourceLocator resourceLocator, int maxWidth, int maxHeight, FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string fanArtName)
{
try
{
using (var ra = resourceLocator.CreateAccessor())
{
ILocalFsResourceAccessor fsra = ra as ILocalFsResourceAccessor;
if (fsra != null)
{
fsra.PrepareStreamAccess();
using (var fileStream = fsra.OpenRead())
// Calling EnsureLocalFileSystemAccess not necessary; only string operation
return(FromStream(fileStream, maxWidth, maxHeight, mediaType, fanArtType, fanArtName, fsra.LocalFileSystemPath));
}
}
}
catch
{
}
return(null);
}
public static FanArtImage FromStream(Stream stream, int maxWidth, int maxHeight, FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string fanArtName, string fileName = null)
{
using (Stream resized = ResizeImage(stream, maxWidth, maxHeight, mediaType, fanArtType, fanArtName, fileName))
return(new FanArtImage(fileName, ReadAll(resized)));
}
/// <summary>
/// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
/// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
/// </summary>
/// <param name="mediaType">Requested FanArtMediaType</param>
/// <param name="fanArtType">Requested FanArtType</param>
/// <param name="name">Requested name of Series, Actor, Artist...</param>
/// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
/// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
/// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
/// <param name="result">Result if return code is <c>true</c>.</param>
/// <returns><c>true</c> if at least one match was found.</returns>
public bool TryGetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
{
result = null;
Guid mediaItemId;
// Don't try to load "fanart" for images
if (!Guid.TryParse(name, out mediaItemId) || mediaType == FanArtConstants.FanArtMediaType.Image)
{
return(false);
}
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false);
if (mediaLibrary == null)
{
return(false);
}
IFilter filter = new MediaItemIdFilter(mediaItemId);
IList <MediaItem> items = mediaLibrary.Search(new MediaItemQuery(_necessarryMIAs, filter), false);
if (items == null || items.Count == 0)
{
return(false);
}
MediaItem mediaItem = items.First();
string fileSystemPath = null;
List <string> localPatterns = new List <string>();
List <IResourceLocator> files = new List <IResourceLocator>();
// File based access
try
{
var resourceLocator = mediaItem.GetResourceLocator();
using (var accessor = resourceLocator.CreateAccessor())
{
ILocalFsResourceAccessor fsra = accessor as ILocalFsResourceAccessor;
if (fsra != null)
{
fileSystemPath = fsra.LocalFileSystemPath;
var path = Path.GetDirectoryName(fileSystemPath);
var file = Path.GetFileNameWithoutExtension(fileSystemPath);
if (fanArtType == FanArtConstants.FanArtType.Poster || fanArtType == FanArtConstants.FanArtType.Thumbnail)
{
localPatterns.Add(Path.ChangeExtension(fileSystemPath, ".jpg"));
localPatterns.Add(Path.Combine(path, file + "-poster.jpg"));
localPatterns.Add(Path.Combine(path, "folder.jpg"));
}
if (fanArtType == FanArtConstants.FanArtType.FanArt)
{
localPatterns.Add(Path.Combine(path, "backdrop.jpg"));
localPatterns.Add(Path.Combine(path, file + "-fanart*.jpg"));
localPatterns.Add(Path.Combine(path, "ExtraFanArt\\*.jpg"));
}
// Copy all patterns for .jpg -> .png + .tbn
localPatterns.AddRange(new List <string>(localPatterns).Select(p => p.Replace(".jpg", ".png")));
localPatterns.AddRange(new List <string>(localPatterns).Select(p => p.Replace(".jpg", ".tbn")));
foreach (var pattern in localPatterns)
{
try
{
var pathPart = Path.GetDirectoryName(pattern);
var filePart = Path.GetFileName(pattern);
DirectoryInfo directoryInfo = new DirectoryInfo(pathPart);
if (directoryInfo.Exists)
{
files.AddRange(directoryInfo.GetFiles(filePart)
.Select(f => f.FullName)
.Select(fileName => new ResourceLocator(resourceLocator.NativeSystemId, ResourcePath.BuildBaseProviderPath(resourceLocator.NativeResourcePath.LastPathSegment.ProviderId, fileName))));
}
}
catch
{
}
}
}
}
}
catch (Exception ex)
{
#if DEBUG
ServiceRegistration.Get <ILogger>().Warn("Error while search fanart of type '{0}' for path '{1}'", ex, fanArtType, fileSystemPath);
#endif
}
result = files;
return(files.Count > 0);
}
public bool TryGetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
{
result = null;
return(false);
}
/// <summary>
/// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
/// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
/// </summary>
/// <param name="mediaType">Requested FanArtMediaType</param>
/// <param name="fanArtType">Requested FanArtType</param>
/// <param name="name">Requested name of Series, Actor, Artist...</param>
/// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
/// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
/// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
/// <param name="result">Result if return code is <c>true</c>.</param>
/// <returns><c>true</c> if at least one match was found.</returns>
public bool TryGetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
{
result = null;
if (string.IsNullOrWhiteSpace(name))
{
return(false);
}
int tvDbId;
int seasonNum = 0;
if (mediaType == FanArtConstants.FanArtMediaType.SeriesSeason)
{
int index = name.LastIndexOf(" S");
if (!int.TryParse(name.Substring(index + 2), out seasonNum))
{
return(false);
}
name = name.Substring(0, index);
}
string baseFolder = GetBaseFolder(mediaType, name, out tvDbId);
// No known series
if (baseFolder == null || !Directory.Exists(baseFolder))
{
return(false);
}
string[] patterns = GetPatterns(mediaType, fanArtType, name, tvDbId, seasonNum);
if (patterns == null)
{
return(false);
}
List <IResourceLocator> files = new List <IResourceLocator>();
try
{
DirectoryInfo directoryInfo = new DirectoryInfo(baseFolder);
if (directoryInfo.Exists)
{
// Try each name pattern first.
foreach (string pattern in patterns)
{
files.AddRange(directoryInfo.GetFiles(pattern)
.Select(f => f.FullName)
.Select(fileName => new ResourceLocator(ResourcePath.BuildBaseProviderPath(LocalFsResourceProviderBase.LOCAL_FS_RESOURCE_PROVIDER_ID, fileName)))
);
result = files;
if (result.Count > 0)
{
return(true);
}
}
// If we tried to load season banners and did not find any, fallback to series banners
if (mediaType == FanArtConstants.FanArtMediaType.SeriesSeason)
{
return(TryGetFanArt(FanArtConstants.FanArtMediaType.Series, fanArtType, name, maxWidth, maxHeight, singleRandom, out result));
}
return(false);
}
}
catch (Exception) { }
return(false);
}
protected bool GetPattern(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, Guid mediaItemId, string name, out string[] patterns)
{
patterns = null;
string basePath = null;
if (mediaItemId != Guid.Empty)
{
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false);
if (mediaLibrary == null)
{
return(false);
}
IFilter filter = new MediaItemIdFilter(mediaItemId);
IList <MediaItem> items = mediaLibrary.Search(new MediaItemQuery(NECESSARY_MIAS, filter), false);
if (items == null || items.Count == 0)
{
return(false);
}
MediaItem mediaItem = items.First();
int movieDbId;
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, MovieAspect.ATTR_TMDB_ID, out movieDbId))
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Undefined:
case FanArtConstants.FanArtMediaType.Movie:
basePath = Path.Combine(MovieTheMovieDbMatcher.CACHE_PATH, movieDbId.ToString());
break;
}
}
}
else
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Undefined:
case FanArtConstants.FanArtMediaType.Movie:
int movieDbId;
basePath = !MovieTheMovieDbMatcher.Instance.TryGetMovieDbId(name, out movieDbId) ? null : Path.Combine(MovieTheMovieDbMatcher.CACHE_PATH, movieDbId.ToString());
break;
case FanArtConstants.FanArtMediaType.MovieCollection:
int collectionId;
basePath = !MovieTheMovieDbMatcher.Instance.TryGetCollectionId(name, out collectionId) ? null : Path.Combine(MovieTheMovieDbMatcher.CACHE_PATH, "COLL_" + collectionId);
break;
}
}
if (string.IsNullOrWhiteSpace(basePath))
{
return(false);
}
switch (fanArtType)
{
case FanArtConstants.FanArtType.Thumbnail:
case FanArtConstants.FanArtType.Poster:
patterns = new[] { Path.Combine(basePath, "Posters\\*.jpg") };
return(true);
case FanArtConstants.FanArtType.FanArt:
patterns = new[] { Path.Combine(basePath, "Backdrops\\*.jpg") };
return(true);
}
return(false);
}
public bool TryGetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <FanArtImage> result)
{
result = null;
Guid mediaItemId;
if (!Guid.TryParse(name, out mediaItemId))
{
return(false);
}
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false);
if (mediaLibrary == null)
{
return(false);
}
IFilter filter = new MediaItemIdFilter(mediaItemId);
IList <MediaItem> items = mediaLibrary.Search(new MediaItemQuery(NECESSARY_MIAS, filter), false);
if (items == null || items.Count == 0)
{
return(false);
}
MediaItem mediaItem = items.First();
string fileSystemPath = string.Empty;
IList <string> patterns = new List <string>();
switch (fanArtType)
{
case FanArtConstants.FanArtType.Banner:
patterns.Add("banner.");
break;
case FanArtConstants.FanArtType.ClearArt:
patterns.Add("clearart.");
break;
case FanArtConstants.FanArtType.Poster:
case FanArtConstants.FanArtType.Thumbnail:
patterns.Add("cover.");
patterns.Add("poster.");
patterns.Add("folder.");
break;
case FanArtConstants.FanArtType.FanArt:
patterns.Add("backdrop.");
patterns.Add("fanart.");
break;
default:
return(false);
}
// File based access
try
{
var resourceLocator = mediaItem.GetResourceLocator();
using (var accessor = resourceLocator.CreateAccessor())
{
ILocalFsResourceAccessor fsra = accessor as ILocalFsResourceAccessor;
if (fsra != null)
{
var ext = Path.GetExtension(fsra.LocalFileSystemPath);
if (!SUPPORTED_EXTENSIONS.Contains(ext))
{
return(false);
}
MatroskaInfoReader mkvReader = new MatroskaInfoReader(fsra);
byte[] binaryData = null;
if (patterns.Any(pattern => mkvReader.GetAttachmentByName(pattern, out binaryData)))
{
result = new List <FanArtImage> {
new FanArtImage(name, binaryData)
};
return(true);
}
}
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Warn("MkvAttachmentsProvider: Exception while reading mkv attachment of type '{0}' from '{1}'", ex, fanArtType, fileSystemPath);
}
return(false);
}
