/// <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<string> result)
{
result = null;
string baseFolder = GetBaseFolder(mediaType, name);
if (baseFolder == null || !Directory.Exists(baseFolder))
{
if (baseFolder != null)
ServiceRegistration.Get<ILogger>().Error("SlimTvFanartProvider: Directory '{0}' not found", baseFolder);
return false;
}
string pattern = GetPattern(mediaType, fanArtType, name);
if (string.IsNullOrEmpty(pattern))
return false;
try
{
DirectoryInfo directoryInfo = new DirectoryInfo(baseFolder);
if (directoryInfo.Exists)
{
result = directoryInfo.GetFiles(pattern).Select(file => file.FullName).ToList();
int count = result.Count;
if (count == 0)
ServiceRegistration.Get<ILogger>().Info("SlimTvFanartProvider: No result for '{0}'", pattern);
return count > 0;
}
}
catch (Exception) { }
return false;
}
protected string GetPattern(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name)
{
if (mediaType != FanArtConstants.FanArtMediaType.Channel)
return null;
return FileUtils.GetSafeFilename(string.Format("{0}.png", name));
}
protected string GetPattern(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType)
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Movie:
switch (fanArtType)
{
case FanArtConstants.FanArtType.Poster:
return "Posters\\*.jpg";
case FanArtConstants.FanArtType.FanArt:
return "Backdrops\\*.jpg";
default:
return null;
}
case FanArtConstants.FanArtMediaType.Series:
switch (fanArtType)
{
case FanArtConstants.FanArtType.Banner:
return "img_graphical_*.jpg";
case FanArtConstants.FanArtType.Poster:
return "img_posters_*.jpg";
case FanArtConstants.FanArtType.FanArt:
return "img_fan-*.jpg";
default:
return null;
}
}
return null;
}
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;
}
}
public bool TryGetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList<FanArtImage> result)
{
result = null;
if (mediaType != FanArtConstants.FanArtMediaType.Album || fanArtType != FanArtConstants.FanArtType.Poster || string.IsNullOrEmpty(name))
return false;
IMediaLibrary mediaLibrary = ServiceRegistration.Get<IMediaLibrary>(false);
if (mediaLibrary == null)
return false;
IFilter filter = new RelationalFilter(AudioAspect.ATTR_ALBUM, RelationalOperator.EQ, name);
MediaItemQuery query = new MediaItemQuery(NECESSARY_MIAS, filter)
{
Limit = 1, // Only one needed
SortInformation = new List<SortInformation> { new SortInformation(AudioAspect.ATTR_ALBUM, SortDirection.Ascending) }
};
var items = mediaLibrary.Search(query, false);
result = new List<FanArtImage>();
foreach (var mediaItem in items)
{
byte[] textureData;
if (!MediaItemAspect.TryGetAttribute(mediaItem.Aspects, ThumbnailLargeAspect.ATTR_THUMBNAIL, out textureData))
continue;
// Only one record required
result.Add(new FanArtImage(name, textureData));
return true;
}
return true;
}
protected string GetBaseFolder(FanArtConstants.FanArtMediaType mediaType, string name)
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Channel:
return @"Plugins\SlimTv.Resources\Resources\ChannelLogos";
default:
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 (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;
}
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<string> fanArtImages;
if (fanArtProvider.TryGetFanArt(mediaType, fanArtType, name, maxWidth, maxHeight, singleRandom, out fanArtImages))
{
IList<string> result = singleRandom ? GetSingleRandom(fanArtImages) : fanArtImages;
return result.Select(f => FanArtImage.FromFile(f, maxWidth, maxHeight)).Where(fanArtImage => fanArtImage != null).ToList();
}
}
return null;
}
protected string GetPattern(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name)
{
if (mediaType != FanArtConstants.FanArtMediaType.Movie && mediaType != FanArtConstants.FanArtMediaType.MovieCollection)
return null;
switch (fanArtType)
{
case FanArtConstants.FanArtType.Poster:
return "Posters\\*.jpg";
case FanArtConstants.FanArtType.FanArt:
return "Backdrops\\*.jpg";
default:
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;
}
protected string GetPattern(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name)
{
if (mediaType != FanArtConstants.FanArtMediaType.Series)
return null;
switch (fanArtType)
{
case FanArtConstants.FanArtType.Banner:
return "img_graphical_*.jpg";
case FanArtConstants.FanArtType.Poster:
return "img_posters_*.jpg";
case FanArtConstants.FanArtType.FanArt:
return "img_fan-*.jpg";
default:
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<string> 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 pattern = GetPattern(mediaType, fanArtType, name, tvDbId, seasonNum);
if (string.IsNullOrEmpty(pattern))
return false;
try
{
DirectoryInfo directoryInfo = new DirectoryInfo(baseFolder);
if (directoryInfo.Exists)
{
result = directoryInfo.GetFiles(pattern).Select(file => file.FullName).ToList();
// If we tried to load season banners and did not find any, fallback to series banners
if (mediaType == FanArtConstants.FanArtMediaType.SeriesSeason && result.Count == 0)
return TryGetFanArt(FanArtConstants.FanArtMediaType.Series, fanArtType, name, maxWidth, maxHeight, singleRandom, out result);
return result.Count > 0;
}
}
catch (Exception) { }
return false;
}
public IList<FanArtImage> GetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom)
{
try
{
CpAction action = GetAction("GetFanArt");
IList<object> inParameters = new List<object>
{
mediaType.ToString(),
fanArtType.ToString(),
name,
maxWidth,
maxHeight,
singleRandom
};
IList<object> outParameters = action.InvokeAction(inParameters);
return (IList<FanArtImage>)outParameters[0];
}
catch (Exception)
{
return EMPTY_LIST;
}
}
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;
var isImage = mediaType == FanArtConstants.FanArtMediaType.Image;
if (!Guid.TryParse(name, out mediaItemId) ||
mediaType != FanArtConstants.FanArtMediaType.Undefined && !isImage ||
fanArtType != FanArtConstants.FanArtType.Thumbnail)
return false;
IMediaLibrary mediaLibrary = ServiceRegistration.Get<IMediaLibrary>(false);
if (mediaLibrary == null)
return false;
// Try to load thumbnail from ML
List<Guid> thumbGuids = new List<Guid> { ThumbnailLargeAspect.ASPECT_ID };
// Check for Image's rotation info
if (isImage)
thumbGuids.Add(ImageAspect.ASPECT_ID);
IFilter filter = new MediaItemIdFilter(mediaItemId);
IList<MediaItem> items = mediaLibrary.Search(new MediaItemQuery(thumbGuids, filter), false);
if (items == null || items.Count == 0)
return false;
MediaItem mediaItem = items.First();
byte[] textureData;
if (!MediaItemAspect.TryGetAttribute(mediaItem.Aspects, ThumbnailLargeAspect.ATTR_THUMBNAIL, out textureData))
return false;
if (isImage)
textureData = AutoRotateThumb(mediaItem, textureData);
// Only one record required
result = new List<FanArtImage> { new FanArtImage(name, textureData) };
return true;
}
/// <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.Movie && mediaType != FanArtConstants.FanArtMediaType.MovieCollection &&
mediaType != FanArtConstants.FanArtMediaType.Undefined && fanArtType == FanArtConstants.FanArtType.Thumbnail)
return false;
Guid mediaItemId;
string[] patterns;
Guid.TryParse(name, out mediaItemId);
if (!GetPattern(mediaType, fanArtType, mediaItemId, name, out patterns))
return false;
List<IResourceLocator> files = new List<IResourceLocator>();
foreach (var pattern in patterns)
{
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(ResourcePath.BuildBaseProviderPath(LocalFsResourceProviderBase.LOCAL_FS_RESOURCE_PROVIDER_ID, fileName)))
);
}
}
catch
{
}
}
result = files;
return files.Count > 0;
}
/// <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<string> result)
{
result = null;
string baseFolder = GetBaseFolder(mediaType, name);
if (baseFolder == null || !Directory.Exists(baseFolder))
return false;
string pattern = GetPattern(mediaType, fanArtType, name);
if (string.IsNullOrEmpty(pattern))
return false;
try
{
DirectoryInfo directoryInfo = new DirectoryInfo(baseFolder);
if (directoryInfo.Exists)
{
result = directoryInfo.GetFiles(pattern).Select(file => file.FullName).ToList();
return result.Count > 0;
}
}
catch
{ }
return false;
}
protected string GetBaseFolder(FanArtConstants.FanArtMediaType mediaType, string name)
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Channel:
return FileUtils.BuildAssemblyRelativePath(@"Resources\ChannelLogos");
default:
return null;
}
}
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;
}
/// <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 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>
/// 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;
}
protected string GetBaseFolder(FanArtConstants.FanArtMediaType mediaType, string name)
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Series:
int tvDbId;
return !SeriesTvDbMatcher.Instance.TryGetTvDbId(name, out tvDbId) ? null : Path.Combine(SeriesTvDbMatcher.CACHE_PATH, tvDbId.ToString());
case FanArtConstants.FanArtMediaType.Movie:
int movieDbId;
return !MovieTheMovieDbMatcher.Instance.TryGetMovieDbId(name, out movieDbId) ? null : Path.Combine(MovieTheMovieDbMatcher.CACHE_PATH, movieDbId.ToString());
default:
return null;
}
}
protected string GetBaseFolder(FanArtConstants.FanArtMediaType mediaType, string name)
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Movie:
int movieDbId;
return !MovieTheMovieDbMatcher.Instance.TryGetMovieDbId(name, out movieDbId) ? null : Path.Combine(MovieTheMovieDbMatcher.CACHE_PATH, movieDbId.ToString());
case FanArtConstants.FanArtMediaType.MovieCollection:
int collectionId;
return !MovieTheMovieDbMatcher.Instance.TryGetCollectionId(name, out collectionId) ? null : Path.Combine(MovieTheMovieDbMatcher.CACHE_PATH, "COLL_" + collectionId);
default:
return null;
}
}
public bool TryGetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList<string> result)
{
throw new NotImplementedException("Use IBinaryFanArtProvider's method.");
}
/// <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;
}
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;
}
protected string GetBaseFolder(FanArtConstants.FanArtMediaType mediaType, string name, out int tvDbId)
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.SeriesSeason:
case FanArtConstants.FanArtMediaType.Series:
return !SeriesTvDbMatcher.Instance.TryGetTvDbId(name, out tvDbId) ? null : Path.Combine(SeriesTvDbMatcher.CACHE_PATH, tvDbId.ToString());
default:
tvDbId = 0;
return null;
}
}
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;
}
protected string GetPattern(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int tvdbId, int seasonNum)
{
if (mediaType == FanArtConstants.FanArtMediaType.Series)
{
switch (fanArtType)
{
case FanArtConstants.FanArtType.Banner:
return "img_graphical_*.jpg";
case FanArtConstants.FanArtType.Poster:
return "img_posters_*.jpg";
case FanArtConstants.FanArtType.FanArt:
return "img_fan-*.jpg";
default:
return null;
}
}
if (mediaType == FanArtConstants.FanArtMediaType.SeriesSeason)
{
switch (fanArtType)
{
case FanArtConstants.FanArtType.Banner:
return string.Format("img_seasonswide_{0}-{1}*.jpg", tvdbId, seasonNum);
case FanArtConstants.FanArtType.Poster:
return string.Format("img_posters_{0}-{1}*.jpg", tvdbId, seasonNum);
default:
return null;
}
}
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;
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(NECESSARY_MIAS, filter), false);
if (items == null || items.Count == 0)
return false;
MediaItem mediaItem = items.First();
var mediaIteamLocator = mediaItem.GetResourceLocator();
var fanArtPaths = new List<ResourcePath>();
var files = new List<IResourceLocator>();
// File based access
try
{
var mediaItemPath = mediaIteamLocator.NativeResourcePath;
var mediaItemDirectoryPath = ResourcePathHelper.Combine(mediaItemPath, "../");
var mediaItemFileNameWithoutExtension = ResourcePathHelper.GetFileNameWithoutExtension(mediaItemPath.ToString());
using (var directoryRa = new ResourceLocator(mediaIteamLocator.NativeSystemId, mediaItemDirectoryPath).CreateAccessor())
{
var directoryFsra = directoryRa as IFileSystemResourceAccessor;
if (directoryFsra != null)
{
var potentialFanArtFiles = GetPotentialFanArtFiles(directoryFsra);
if (fanArtType == FanArtConstants.FanArtType.Poster || fanArtType == FanArtConstants.FanArtType.Thumbnail)
fanArtPaths.AddRange(
from potentialFanArtFile in potentialFanArtFiles
let potentialFanArtFileNameWithoutExtension = ResourcePathHelper.GetFileNameWithoutExtension(potentialFanArtFile.ToString())
where potentialFanArtFileNameWithoutExtension == mediaItemFileNameWithoutExtension ||
potentialFanArtFileNameWithoutExtension == mediaItemFileNameWithoutExtension + "-poster" ||
potentialFanArtFileNameWithoutExtension == "folder"
select potentialFanArtFile);
if (fanArtType == FanArtConstants.FanArtType.FanArt)
{
fanArtPaths.AddRange(
from potentialFanArtFile in potentialFanArtFiles
let potentialFanArtFileNameWithoutExtension = ResourcePathHelper.GetFileNameWithoutExtension(potentialFanArtFile.ToString())
where potentialFanArtFileNameWithoutExtension == "backdrop" ||
potentialFanArtFileNameWithoutExtension.StartsWith(mediaItemFileNameWithoutExtension + "-fanart")
select potentialFanArtFile);
if (directoryFsra.ResourceExists("ExtraFanArt/"))
using (var extraFanArtDirectoryFsra = directoryFsra.GetResource("ExtraFanArt/"))
fanArtPaths.AddRange(GetPotentialFanArtFiles(extraFanArtDirectoryFsra));
}
files.AddRange(fanArtPaths.Select(path => new ResourceLocator(mediaIteamLocator.NativeSystemId, path)));
}
}
}
catch (Exception ex)
{
#if DEBUG
ServiceRegistration.Get<ILogger>().Warn("LocalFanArtProvider: Error while searching fanart of type '{0}' for '{1}'", ex, fanArtType, mediaIteamLocator);
#endif
}
result = files;
return files.Count > 0;
}
