public void SetMediaItem(LibRetroMediaItem mediaItem)
{
if (_retro != null)
{
return;
}
_state = PlayerState.Active;
IResourceLocator locator = mediaItem.GetResourceLocator();
string gamePath;
if (!string.IsNullOrEmpty(mediaItem.ExtractedPath))
{
gamePath = mediaItem.ExtractedPath;
}
else if (locator.TryCreateLocalFsAccessor(out _accessor))
{
gamePath = _accessor.LocalFileSystemPath;
}
else
{
return;
}
string saveName = DosPathHelper.GetFileNameWithoutExtension(locator.NativeResourcePath.FileName);
ServiceRegistration.Get <ILogger>().Debug("LibRetroPlayer: Creating LibRetroFrontend: Core Path '{0}', Game Path '{1}', Save Name '{2}'", mediaItem.LibRetroPath, gamePath, saveName);
_corePath = mediaItem.LibRetroPath;
_isCoreLoaded = ServiceRegistration.Get <ILibRetroCoreInstanceManager>().TrySetCoreLoading(_corePath);
if (!_isCoreLoaded)
{
ShowLoadErrorDialog();
return;
}
_retro = new LibRetroFrontend(mediaItem.LibRetroPath, gamePath, saveName);
_isLibretroInit = _retro.Init();
//if (_isLibretroInit)
//{
// TimingInfo timingInfo = _retro.GetTimingInfo();
// if (timingInfo != null)
// MediaItemAspect.SetAttribute(mediaItem.Aspects, VideoAspect.ATTR_FPS, (int)timingInfo.FPS);
//}
}
protected void CreateListItems(IEnumerable <string> archiveFiles, string archivePath)
{
_items.Clear();
if (archiveFiles != null)
{
List <string> sortedFiles = new List <string>(archiveFiles);
sortedFiles.Sort();
string prefix = DosPathHelper.GetFileNameWithoutExtension(archivePath);
foreach (string file in sortedFiles)
{
string name = GetDisplayName(file, prefix);
ListItem item = new ListItem(Consts.KEY_NAME, name);
item.AdditionalProperties[KEY_ARCHIVE_FILE] = file;
_items.Add(item);
}
}
_items.FireChange();
}
protected void SetDefaultEmulatorSettings()
{
EmulatorConfiguration defaultConfiguration;
if (!DefaultConfigurations.TryMatch(PathBrowser.ChoosenResourcePathDisplayName, out defaultConfiguration))
{
Name = DosPathHelper.GetFileNameWithoutExtension(PathBrowser.ChoosenResourcePathDisplayName);
return;
}
Name = defaultConfiguration.Name;
Arguments = defaultConfiguration.Arguments;
WorkingDirectory = defaultConfiguration.WorkingDirectory;
UseQuotes = defaultConfiguration.UseQuotes;
ExitsOnEscapeKey = defaultConfiguration.ExitsOnEscapeKey;
FileExtensions = new HashSet <string>(defaultConfiguration.FileExtensions);
SelectedGameCategories = new List <string>(defaultConfiguration.Platforms);
UpdateIsGameCategoriesSelected();
}
static async Task <bool> ExtractGameData(ILocalFsResourceAccessor lfsra, IDictionary <Guid, IList <MediaItemAspect> > extractedAspectData, bool forceQuickMode)
{
var categories = ServiceRegistration.Get <IMediaCategoryHelper>().GetMediaCategories(lfsra.CanonicalLocalResourcePath);
string platform = categories.FirstOrDefault(s => _platformCategories.ContainsKey(s));
if (string.IsNullOrEmpty(platform))
{
Logger.Warn("GamesMetadataExtractor: Unable to import {0}, no platform categories have been selected", lfsra.LocalFileSystemPath);
return(false);
}
var configurations = ServiceRegistration.Get <ISettingsManager>().Load <CommonSettings>().ConfiguredEmulators;
if (!HasGameExtension(lfsra.CanonicalLocalResourcePath.BasePathSegment.Path, platform, configurations))
{
return(false);
}
Logger.Debug("GamesMetadataExtractor: Importing game: '{0}', '{1}'", lfsra.LocalFileSystemPath, platform);
string name = DosPathHelper.GetFileNameWithoutExtension(lfsra.CanonicalLocalResourcePath.BasePathSegment.Path);
GameInfo gameInfo = new GameInfo()
{
GameName = name,
Platform = platform
};
GameMatcher matcher = GameMatcher.Instance;
if (!forceQuickMode && !await matcher.FindAndUpdateGameAsync(gameInfo).ConfigureAwait(false))
{
Logger.Debug("GamesMetadataExtractor: No match found for game: '{0}', '{1}'", lfsra.LocalFileSystemPath, platform);
gameInfo.GameName = name;
}
gameInfo.SetMetadata(extractedAspectData, lfsra);
return(true);
}
public bool TryExtractMetadata(IResourceAccessor mediaItemAccessor, IDictionary <Guid, MediaItemAspect> extractedAspectData, bool forceQuickMode)
{
try
{
VideoResult result = null;
IFileSystemResourceAccessor fsra = mediaItemAccessor as IFileSystemResourceAccessor;
if (fsra != null && fsra.IsDirectory && fsra.ResourceExists("VIDEO_TS"))
{
IFileSystemResourceAccessor fsraVideoTs = fsra.GetResource("VIDEO_TS");
if (fsraVideoTs != null && fsraVideoTs.ResourceExists("VIDEO_TS.IFO"))
{
// Video DVD
using (MediaInfoWrapper videoTsInfo = ReadMediaInfo(fsraVideoTs.GetResource("VIDEO_TS.IFO")))
{
if (!videoTsInfo.IsValid || videoTsInfo.GetVideoCount() == 0)
{
return(false); // Invalid video_ts.ifo file
}
result = VideoResult.CreateDVDInfo(fsra.ResourceName, videoTsInfo);
}
// Iterate over all video files; MediaInfo finds different audio/video metadata for each .ifo file
ICollection <IFileSystemResourceAccessor> files = fsraVideoTs.GetFiles();
if (files != null)
{
foreach (IFileSystemResourceAccessor file in files)
{
string lowerPath = (file.ResourcePathName ?? string.Empty).ToLowerInvariant();
if (!lowerPath.EndsWith(".ifo") || lowerPath.EndsWith("video_ts.ifo"))
{
continue;
}
using (MediaInfoWrapper mediaInfo = ReadMediaInfo(file))
{
// Before we start evaluating the file, check if it is a video at all
if (mediaInfo.IsValid && mediaInfo.GetVideoCount() == 0)
{
continue;
}
result.AddMediaInfo(mediaInfo);
}
}
}
}
}
else if (mediaItemAccessor.IsFile)
{
string filePath = mediaItemAccessor.ResourcePathName;
if (!HasVideoExtension(filePath))
{
return(false);
}
using (MediaInfoWrapper fileInfo = ReadMediaInfo(mediaItemAccessor))
{
// Before we start evaluating the file, check if it is a video at all
if (!fileInfo.IsValid || (fileInfo.GetVideoCount() == 0 && !IsWorkaroundRequired(filePath)))
{
return(false);
}
string mediaTitle = DosPathHelper.GetFileNameWithoutExtension(mediaItemAccessor.ResourceName);
result = VideoResult.CreateFileInfo(mediaTitle, fileInfo);
}
using (Stream stream = mediaItemAccessor.OpenRead())
result.MimeType = MimeTypeDetector.GetMimeType(stream);
}
if (result != null)
{
result.UpdateMetadata(extractedAspectData);
ILocalFsResourceAccessor disposeLfsra = null;
try
{
ILocalFsResourceAccessor lfsra = mediaItemAccessor as ILocalFsResourceAccessor;
if (lfsra == null && !forceQuickMode)
{ // In case forceQuickMode, we only want local browsing
IResourceAccessor ra = mediaItemAccessor.Clone();
try
{
lfsra = StreamedResourceToLocalFsAccessBridge.GetLocalFsResourceAccessor(ra);
disposeLfsra = lfsra; // Remember to dispose the extra resource accessor instance
}
catch (Exception)
{
ra.Dispose();
}
}
if (lfsra != null)
{
string localFsPath = lfsra.LocalFileSystemPath;
ExtractMatroskaTags(localFsPath, extractedAspectData, forceQuickMode);
ExtractThumbnailData(localFsPath, extractedAspectData, forceQuickMode);
}
}
finally
{
if (disposeLfsra != null)
{
disposeLfsra.Dispose();
}
}
return(true);
}
}
catch (Exception e)
{
// Only log at the info level here - And simply return false. This lets the caller know that we
// couldn't perform our task here.
ServiceRegistration.Get <ILogger>().Info("VideoMetadataExtractor: Exception reading resource '{0}' (Text: '{1}')", mediaItemAccessor.CanonicalLocalResourcePath, e.Message);
}
return(false);
}
public async Task <bool> TryExtractMetadataAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > extractedAspectData, bool forceQuickMode)
{
string fileName = mediaItemAccessor.ResourceName;
if (!HasImageExtension(fileName))
{
return(false);
}
if (DosPathHelper.GetFileNameWithoutExtension(fileName).ToLowerInvariant() == "folder")
{
return(false); //Ignore folder images
}
bool refresh = false;
if (extractedAspectData.ContainsKey(ImageAspect.ASPECT_ID))
{
refresh = true;
}
try
{
IFileSystemResourceAccessor fsra = mediaItemAccessor as IFileSystemResourceAccessor;
if (!refresh)
{
MultipleMediaItemAspect providerResourceAspect = MediaItemAspect.CreateAspect(extractedAspectData, ProviderResourceAspect.Metadata);
providerResourceAspect.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_INDEX, 0);
providerResourceAspect.SetAttribute(ProviderResourceAspect.ATTR_TYPE, ProviderResourceAspect.TYPE_PRIMARY);
if (!(mediaItemAccessor is IFileSystemResourceAccessor))
{
return(false);
}
providerResourceAspect.SetAttribute(ProviderResourceAspect.ATTR_SIZE, fsra.Size);
if (!forceQuickMode)
{
// Open a stream for media item to detect mimeType.
using (Stream mediaStream = fsra.OpenRead())
{
string mimeType = MimeTypeDetector.GetMimeType(mediaStream) ?? DEFAULT_MIMETYPE;
providerResourceAspect.SetAttribute(ProviderResourceAspect.ATTR_MIME_TYPE, mimeType);
}
}
else
{
string mimeType = MimeTypeDetector.GetMimeTypeFromExtension(fileName) ?? DEFAULT_MIMETYPE;
providerResourceAspect.SetAttribute(ProviderResourceAspect.ATTR_MIME_TYPE, mimeType);
}
}
MediaItemAspect mediaAspect = MediaItemAspect.GetOrCreateAspect(extractedAspectData, MediaAspect.Metadata);
mediaAspect.SetAttribute(MediaAspect.ATTR_ISVIRTUAL, false);
MediaItemAspect imageAspect = MediaItemAspect.GetOrCreateAspect(extractedAspectData, ImageAspect.Metadata);
if (!refresh)
{
mediaAspect.SetAttribute(MediaAspect.ATTR_TITLE, ProviderPathHelper.GetFileNameWithoutExtension(fileName));
if (!forceQuickMode)
{
// Extract EXIF information from media item.
using (ExifMetaInfo.ExifMetaInfo exif = new ExifMetaInfo.ExifMetaInfo(fsra))
{
mediaAspect.SetAttribute(MediaAspect.ATTR_RECORDINGTIME, exif.OriginalDate != DateTime.MinValue ? exif.OriginalDate : fsra.LastChanged);
mediaAspect.SetAttribute(MediaAspect.ATTR_COMMENT, StringUtils.TrimToNull(exif.ImageDescription));
if (exif.PixXDim.HasValue)
{
imageAspect.SetAttribute(ImageAspect.ATTR_WIDTH, (int)exif.PixXDim);
}
if (exif.PixYDim.HasValue)
{
imageAspect.SetAttribute(ImageAspect.ATTR_HEIGHT, (int)exif.PixYDim);
}
imageAspect.SetAttribute(ImageAspect.ATTR_MAKE, StringUtils.TrimToNull(exif.EquipMake));
imageAspect.SetAttribute(ImageAspect.ATTR_MODEL, StringUtils.TrimToNull(exif.EquipModel));
if (exif.ExposureBias.HasValue)
{
imageAspect.SetAttribute(ImageAspect.ATTR_EXPOSURE_BIAS, ((double)exif.ExposureBias).ToString());
}
imageAspect.SetAttribute(ImageAspect.ATTR_EXPOSURE_TIME, exif.ExposureTime);
imageAspect.SetAttribute(ImageAspect.ATTR_FLASH_MODE, StringUtils.TrimToNull(exif.FlashMode));
if (exif.FNumber.HasValue)
{
imageAspect.SetAttribute(ImageAspect.ATTR_FNUMBER, string.Format("F {0}", (double)exif.FNumber));
}
imageAspect.SetAttribute(ImageAspect.ATTR_ISO_SPEED, StringUtils.TrimToNull(exif.ISOSpeed));
imageAspect.SetAttribute(ImageAspect.ATTR_ORIENTATION, (Int32)(exif.OrientationType ?? 0));
imageAspect.SetAttribute(ImageAspect.ATTR_METERING_MODE, exif.MeteringMode.ToString());
if (exif.Latitude.HasValue && exif.Longitude.HasValue)
{
imageAspect.SetAttribute(ImageAspect.ATTR_LATITUDE, exif.Latitude);
imageAspect.SetAttribute(ImageAspect.ATTR_LONGITUDE, exif.Longitude);
}
}
}
else
{
mediaAspect.SetAttribute(MediaAspect.ATTR_RECORDINGTIME, fsra.LastChanged);
imageAspect.SetAttribute(ImageAspect.ATTR_ORIENTATION, 0);
}
byte[] thumbData;
// We only want to create missing thumbnails here, so check for existing ones first
if (MediaItemAspect.TryGetAttribute(extractedAspectData, ThumbnailLargeAspect.ATTR_THUMBNAIL, out thumbData) && thumbData != null)
{
return(true);
}
using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor))
using (rah.LocalFsResourceAccessor.EnsureLocalFileSystemAccess())
{
string localFsResourcePath = rah.LocalFsResourceAccessor.LocalFileSystemPath;
if (localFsResourcePath != null)
{
// Thumbnail extraction
IThumbnailGenerator generator = ServiceRegistration.Get <IThumbnailGenerator>();
ImageType imageType;
if (generator.GetThumbnail(localFsResourcePath, forceQuickMode, out thumbData, out imageType))
{
MediaItemAspect.SetAttribute(extractedAspectData, ThumbnailLargeAspect.ATTR_THUMBNAIL, thumbData);
}
}
}
return(true);
}
else
{
bool updated = false;
double?latitude = imageAspect.GetAttributeValue <double?>(ImageAspect.ATTR_LATITUDE);
double?longitude = imageAspect.GetAttributeValue <double?>(ImageAspect.ATTR_LONGITUDE);
if (!forceQuickMode && IncludeGeoLocationDetails && latitude.HasValue && longitude.HasValue &&
string.IsNullOrEmpty(imageAspect.GetAttributeValue <string>(ImageAspect.ATTR_COUNTRY)))
{
var geoCoordinate = new GeoCoordinate(latitude.Value, longitude.Value);
var lookupResult = await GeoLocationService.Instance.TryLookupAsync(geoCoordinate).ConfigureAwait(false);
if (lookupResult.Success)
{
CivicAddress locationInfo = lookupResult.Result;
imageAspect.SetAttribute(ImageAspect.ATTR_CITY, locationInfo.City);
imageAspect.SetAttribute(ImageAspect.ATTR_STATE, locationInfo.StateProvince);
imageAspect.SetAttribute(ImageAspect.ATTR_COUNTRY, locationInfo.CountryRegion);
updated = true;
}
}
byte[] thumbData;
// We only want to create missing thumbnails here, so check for existing ones first
if (MediaItemAspect.TryGetAttribute(extractedAspectData, ThumbnailLargeAspect.ATTR_THUMBNAIL, out thumbData) && thumbData != null)
{
return(updated);
}
using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor))
using (rah.LocalFsResourceAccessor.EnsureLocalFileSystemAccess())
{
string localFsResourcePath = rah.LocalFsResourceAccessor.LocalFileSystemPath;
if (localFsResourcePath != null)
{
// In quick mode only allow thumbs taken from cache.
bool cachedOnly = forceQuickMode;
// Thumbnail extraction
IThumbnailGenerator generator = ServiceRegistration.Get <IThumbnailGenerator>();
ImageType imageType;
if (generator.GetThumbnail(localFsResourcePath, cachedOnly, out thumbData, out imageType))
{
MediaItemAspect.SetAttribute(extractedAspectData, ThumbnailLargeAspect.ATTR_THUMBNAIL, thumbData);
updated = true;
}
}
}
return(updated);
}
}
catch (Exception e)
{
// Only log at the info level here - And simply return false. This makes the importer know that we
// couldn't perform our task here.
ServiceRegistration.Get <ILogger>().Info("ImageMetadataExtractor: Exception reading resource '{0}' (Text: '{1}')", mediaItemAccessor.CanonicalLocalResourcePath, e.Message);
}
return(false);
}
public bool TryExtractMetadata(IResourceAccessor mediaItemAccessor, IDictionary <Guid, MediaItemAspect> extractedAspectData, bool forceQuickMode)
{
try
{
VideoResult result = null;
IFileSystemResourceAccessor fsra = mediaItemAccessor as IFileSystemResourceAccessor;
if (fsra == null)
{
return(false);
}
if (!fsra.IsFile && fsra.ResourceExists("VIDEO_TS"))
{
IFileSystemResourceAccessor fsraVideoTs = fsra.GetResource("VIDEO_TS");
if (fsraVideoTs != null && fsraVideoTs.ResourceExists("VIDEO_TS.IFO"))
{
// Video DVD
using (MediaInfoWrapper videoTsInfo = ReadMediaInfo(fsraVideoTs.GetResource("VIDEO_TS.IFO")))
{
if (!videoTsInfo.IsValid || videoTsInfo.GetVideoCount() == 0)
{
return(false); // Invalid video_ts.ifo file
}
result = VideoResult.CreateDVDInfo(fsra.ResourceName, videoTsInfo);
}
// Iterate over all video files; MediaInfo finds different audio/video metadata for each .ifo file
ICollection <IFileSystemResourceAccessor> files = fsraVideoTs.GetFiles();
if (files != null)
{
foreach (IFileSystemResourceAccessor file in files)
{
string lowerPath = (file.ResourcePathName ?? string.Empty).ToLowerInvariant();
if (!lowerPath.EndsWith(".ifo") || lowerPath.EndsWith("video_ts.ifo"))
{
continue;
}
using (MediaInfoWrapper mediaInfo = ReadMediaInfo(file))
{
// Before we start evaluating the file, check if it is a video at all
if (mediaInfo.IsValid && mediaInfo.GetVideoCount() == 0)
{
continue;
}
result.AddMediaInfo(mediaInfo);
}
}
}
}
}
else if (fsra.IsFile)
{
string filePath = fsra.ResourcePathName;
if (!HasVideoExtension(filePath))
{
return(false);
}
using (MediaInfoWrapper fileInfo = ReadMediaInfo(fsra))
{
// Before we start evaluating the file, check if it is a video at all
if (!fileInfo.IsValid || (fileInfo.GetVideoCount() == 0 && !IsWorkaroundRequired(filePath)))
{
return(false);
}
string mediaTitle = DosPathHelper.GetFileNameWithoutExtension(fsra.ResourceName);
result = VideoResult.CreateFileInfo(mediaTitle, fileInfo);
}
using (Stream stream = fsra.OpenRead())
result.MimeType = MimeTypeDetector.GetMimeType(stream, DEFAULT_MIMETYPE);
}
if (result != null)
{
result.UpdateMetadata(extractedAspectData);
using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor))
{
ILocalFsResourceAccessor lfsra = rah.LocalFsResourceAccessor;
if (lfsra != null)
{
MediaItemAspect.SetAttribute(extractedAspectData, MediaAspect.ATTR_SIZE, lfsra.Size);
MediaItemAspect.SetAttribute(extractedAspectData, MediaAspect.ATTR_RECORDINGTIME, lfsra.LastChanged);
ExtractMatroskaTags(lfsra, extractedAspectData, forceQuickMode);
ExtractMp4Tags(lfsra, extractedAspectData, forceQuickMode);
ExtractThumbnailData(lfsra, extractedAspectData, forceQuickMode);
}
return(true);
}
}
}
catch (Exception e)
{
// Only log at the info level here - And simply return false. This lets the caller know that we
// couldn't perform our task here.
ServiceRegistration.Get <ILogger>().Info("VideoMetadataExtractor: Exception reading resource '{0}' (Text: '{1}')", mediaItemAccessor.CanonicalLocalResourcePath, e.Message);
}
return(false);
}
protected string CreateArguments(EmulatorConfiguration emulatorConfiguration, string gamePath)
{
if (emulatorConfiguration.IsNative)
{
return(emulatorConfiguration.Arguments);
}
string format = emulatorConfiguration.UseQuotes ? "\"{0}\"" : "{0}";
string arguments = emulatorConfiguration.Arguments ?? "";
arguments = arguments.Replace(EmulatorConfiguration.WILDCARD_GAME_DIRECTORY, string.Format(format, DosPathHelper.GetDirectory(gamePath)));
if (!arguments.Contains(EmulatorConfiguration.WILDCARD_GAME_PATH) && !arguments.Contains(EmulatorConfiguration.WILDCARD_GAME_PATH_NO_EXT))
{
return(string.Format("{0} {1}", arguments.TrimEnd(), string.Format(format, gamePath)));
}
return(arguments.Replace(EmulatorConfiguration.WILDCARD_GAME_PATH, string.Format(format, gamePath))
.Replace(EmulatorConfiguration.WILDCARD_GAME_PATH_NO_EXT, string.Format(format, DosPathHelper.GetFileNameWithoutExtension(gamePath))));
}