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);
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);
}
/// <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[] GetPatterns(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int tvdbId, int seasonNum)
{
if (mediaType == FanArtConstants.FanArtMediaType.Series)
{
switch (fanArtType)
{
case FanArtConstants.FanArtType.Banner:
return(new[] { "img_graphical_*.jpg", "img_text_*.jpg" });
case FanArtConstants.FanArtType.Poster:
return(new[] { "img_posters_*.jpg" });
case FanArtConstants.FanArtType.FanArt:
return(new[] { "img_fan-*.jpg" });
default:
return(null);
}
}
if (mediaType == FanArtConstants.FanArtMediaType.SeriesSeason)
{
switch (fanArtType)
{
case FanArtConstants.FanArtType.Banner:
return(new[] { string.Format("img_seasonswide_{0}-{1}*.jpg", tvdbId, seasonNum) });
case FanArtConstants.FanArtType.Poster:
return(new[] { string.Format("img_posters_{0}-{1}*.jpg", tvdbId, seasonNum) });
default:
return(null);
}
}
return(null);
}
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);
}
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 static ImageSource CreateFanArtImageSource(object source, int width, int height)
{
MediaItem mediaItem = source as MediaItem;
if (mediaItem == null)
{
return(null);
}
FanArtConstants.FanArtMediaType mediaType = FanArtConstants.FanArtMediaType.Undefined;
// Special handling for ImageThumbs that might require rotation
if (mediaItem.Aspects.ContainsKey(ImageAspect.ASPECT_ID))
{
mediaType = FanArtConstants.FanArtMediaType.Image;
}
FanArtImageSource fanArtImageSource = new FanArtImageSource
{
FanArtMediaType = mediaType,
FanArtType = FanArtConstants.FanArtType.Thumbnail,
MaxWidth = MAX_SIZE_THUMBS,
MaxHeight = MAX_SIZE_THUMBS,
// Order matters here: if all arguments are complete, download will start. We control the start time by setting FanArtName after all required properties are set
FanArtName = mediaItem.MediaItemId.ToString()
};
return(fanArtImageSource);
}
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);
}
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 GetBaseFolder(FanArtConstants.FanArtMediaType mediaType, string name)
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Channel:
return(@"Plugins\SlimTv.Resources\Resources\ChannelLogos");
default:
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()));
default:
return(null);
}
}
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 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);
}
}
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.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);
}
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);
}
}
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);
}
}
private UPnPError OnGetFanArt(DvAction action, IList <object> inParams, out IList <object> outParams, CallContext context)
{
outParams = new List <object>();
IFanArtService fanArtService = ServiceRegistration.Get <IFanArtService>();
if (fanArtService == null)
{
return(new UPnPError(500, "FanArt service not available"));
}
FanArtConstants.FanArtMediaType fanArtMediaType = (FanArtConstants.FanArtMediaType)Enum.Parse(typeof(FanArtConstants.FanArtMediaType), inParams[0].ToString());
FanArtConstants.FanArtType fanArtType = (FanArtConstants.FanArtType)Enum.Parse(typeof(FanArtConstants.FanArtType), inParams[1].ToString());
string name = inParams[2].ToString();
int maxWidth = (int)inParams[3];
int maxHeight = (int)inParams[4];
bool singleRandom = (bool)inParams[5];
IList <FanArtImage> fanArtImages = fanArtService.GetFanArt(fanArtMediaType, fanArtType, name, maxWidth, maxHeight, singleRandom) ?? new List <FanArtImage>();
outParams = new List <object> {
fanArtImages
};
return(null);
}
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);
}
/// <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())
return(FromStream(fileStream, maxWidth, maxHeight, mediaType, fanArtType, fanArtName, fsra.LocalFileSystemPath));
}
}
}
catch
{
}
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(_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 <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)
{
fileSystemPath = fsra.LocalFileSystemPath;
var ext = Path.GetExtension(fileSystemPath);
if (!SUPPORTED_EXTENSIONS.Contains(ext))
{
return(false);
}
MatroskaInfoReader mkvReader = new MatroskaInfoReader(fileSystemPath);
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>
/// 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);
}
/// <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);
}
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 (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);
}
