public IPlayer GetPlayer(MediaItem mediaItem) { string mimeType; string title; if (!mediaItem.GetPlayData(out mimeType, out title)) { return(null); } if (mimeType != "video/livetv") { return(null); } IResourceLocator locator = mediaItem.GetResourceLocator(); LiveTvPlayer player = new LiveTvPlayer(); try { player.SetMediaItem(locator, title); } catch (Exception e) { ServiceRegistration.Get <ILogger>().Warn("LiveTvPlayer: Error playing media item '{0}'", e, locator); player.Dispose(); return(null); } return(player); }
/// <summary> /// Sets the data of the new image to be played. /// </summary> /// <param name="locator">Resource locator of the image item.</param> /// <param name="mediaItemTitle">Title of the image item.</param> /// <param name="rotation">Rotation of the image.</param> /// <param name="flipX">Flipping in horizontal direction.</param> /// <param name="flipY">Flipping in vertical direction.</param> public void SetMediaItemData(IResourceLocator locator, string mediaItemTitle, RightAngledRotation rotation, bool flipX, bool flipY) { if (locator == null) { lock (_syncObj) { DisposeTexture(); _currentLocator = null; return; } } Texture texture; ImageInformation imageInformation; using (IResourceAccessor ra = locator.CreateAccessor()) { IFileSystemResourceAccessor fsra = ra as IFileSystemResourceAccessor; if (fsra == null) { return; } using (Stream stream = fsra.OpenRead()) using (Stream tmpImageStream = ImageUtilities.ResizeImage(stream, ImageFormat.MemoryBmp, MAX_TEXTURE_DIMENSION, MAX_TEXTURE_DIMENSION)) texture = Texture.FromStream(SkinContext.Device, tmpImageStream, (int)tmpImageStream.Length, 0, 0, 1, Usage.None, Format.A8R8G8B8, Pool.Default, Filter.None, Filter.None, 0, out imageInformation); } lock (_syncObj) { ReloadSettings(); _state = PlayerState.Active; DisposeTexture(); _currentLocator = locator; _mediaItemTitle = mediaItemTitle; _texture = texture; _rotation = rotation; _flipX = flipX; _flipY = flipY; SurfaceDescription desc = _texture.GetLevelDescription(0); _textureMaxUV = new SizeF(imageInformation.Width / (float)desc.Width, imageInformation.Height / (float)desc.Height); // Reset animation _animator.Initialize(); if (_slideShowTimer != null) { _slideShowTimer.Change(_slideShowImageDuration, TS_INFINITE); } else { CheckTimer(); } _playbackStartTime = DateTime.Now; if (_pauseTime.HasValue) { _pauseTime = _playbackStartTime; } } }
/// <summary> /// Locates the specified asset and opens a stream to read it using the resource locator /// override. If UseDefaultContent is set to true and the resource cannot be found, an /// attempt to locate it from default content will be made. /// </summary> /// <param name="assetName">Asset name</param> /// <param name="locatorOverride">Locator to attempt to locate the asset with</param> /// <returns>Stream</returns> public Stream OpenStream(String assetName, IResourceLocator locatorOverride) { if (String.IsNullOrEmpty(assetName)) { throw new NullReferenceException("Asset name is not valid"); } IResource resource = null; //First try: Try to locate the resource with the override resource = locatorOverride.LocateResource(assetName); //Second try, if resource is not located then try the default content if (resource == null) { if (!_useDefault) { throw new ResourceNotFoundException(String.Format("Resource {0} could not be found", assetName)); } try { return(Engine.RenderSystemProvider.DefaultContent.OpenStream(assetName)); } catch (Exception e) { throw new ResourceNotFoundException(String.Format("Resource {0} could not be found", assetName), e.InnerException); } } return(resource.OpenStream()); }
/// <summary> /// Reads all tag images and caches them in the <see cref="IFanArtCache"/> service. /// </summary> /// <param name="mediaItemLocator"><see cref="IResourceLocator>"/> that points to the file.</param> /// <param name="mediaItemId">Id of the media item.</param> /// <param name="title">Title of the media item.</param> /// <returns><see cref="Task"/> that completes when the images have been cached.</returns> protected async Task ExtractFanArt(IResourceLocator mediaItemLocator, Guid mediaItemId, string title, IDictionary <Guid, IList <MediaItemAspect> > aspects) { try { //File based access using (IResourceAccessor mediaItemAccessor = mediaItemLocator.CreateAccessor()) using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor)) using (rah.LocalFsResourceAccessor.EnsureLocalFileSystemAccess()) { if (MKV_EXTENSIONS.Contains(ResourcePathHelper.GetExtension(mediaItemLocator.NativeResourcePath.FileName))) { await ExtractMkvFanArt(rah.LocalFsResourceAccessor, mediaItemId, title).ConfigureAwait(false); } if (MP4_EXTENSIONS.Contains(ResourcePathHelper.GetExtension(mediaItemLocator.NativeResourcePath.FileName))) { await ExtractTagFanArt(rah.LocalFsResourceAccessor, mediaItemId, title).ConfigureAwait(false); } //Don't create thumbs if they already exist or if it is a movie (they use posters) var thumbs = ServiceRegistration.Get <IFanArtCache>().GetFanArtFiles(mediaItemId, FanArtTypes.Thumbnail); if (!thumbs.Any() && !aspects.ContainsKey(ThumbnailLargeAspect.ASPECT_ID) && !aspects.ContainsKey(MovieAspect.ASPECT_ID)) { await ExtractThumbnailFanArt(rah.LocalFsResourceAccessor, mediaItemId, title, aspects); } } } catch (Exception ex) { Logger.Warn("VideoFanArtHandler: Exception while reading MKV tag images for '{0}'", ex, mediaItemLocator.NativeResourcePath); } }
public IPlayer GetPlayer(MediaItem mediaItem) { string mimeType; string title; if (!mediaItem.GetPlayData(out mimeType, out title)) { return(null); } IResourceLocator locator = mediaItem.GetResourceLocator(); if (InputSourceFactory.CanPlay(locator, mimeType)) { BassPlayer player = new BassPlayer(_pluginDirectory); try { player.SetMediaItemLocator(locator, mimeType, title); } catch (Exception e) { ServiceRegistration.Get <ILogger>().Warn("BassPlayerPlugin: Error playing media item '{0}'", e, locator); player.Dispose(); return(null); } return(player); } return(null); }
public IPlayer GetPlayer(MediaItem mediaItem) { string mimeType; string title; if (!mediaItem.GetPlayData(out mimeType, out title)) { return(null); } if (Enabled && mimeType == "video/bluray") { IResourceLocator locator = mediaItem.GetResourceLocator(); BDPlayer player = new BDPlayer(); try { player.SetMediaItem(locator, title); } catch (Exception) { LogError("Error playing media item '{0}'", locator); player.Dispose(); return(null); } return(player); } return(null); }
public Formatter Parse() { var f = _locatorFactory.CloneForTagLib(_lib); if (_initialLocator == null) { _initialLocator = f.GetNewLocator(); } var formatter = new InternalFormatter(new TagLibParserFactory(new TagLibForParsing(_lib), _expressionLib, f, _tagValidator), _expressionLib, _template, _allowTags, _initialLocator); try { formatter.Parse(); CreateTemplateProcessorFor(_lib).Process(formatter.ParsedTemplate); if (_templateValidator != null) { _templateValidator.Validate(formatter.ParsedTemplate); } CreateTemplateValidatorFor(_lib).Validate(formatter.ParsedTemplate); } finally { _templateParsed = formatter.ParsedTemplate; } return(this); }
/// <summary> /// Gets all season folder images and caches them in the <see cref="IFanArtCache"/> service. /// </summary> /// <param name="mediaItemLocator"><see cref="IResourceLocator>"/> that points to the file.</param> /// <param name="seasonMediaItemId">Id of the season media item.</param> /// <param name="title">Title of the media item.</param> /// <param name="seasonNumber">Season number.</param> /// <param name="actors">Collection of actor ids and names.</param> /// <returns><see cref="Task"/> that completes when the images have been cached.</returns> protected async Task ExtractSeasonFolderFanArt(IResourceLocator mediaItemLocator, Guid seasonMediaItemId, string title, int?seasonNumber, IList <Tuple <Guid, string> > actors) { var seasonDirectory = ResourcePathHelper.Combine(mediaItemLocator.NativeResourcePath, "../"); try { FanArtPathCollection paths = null; IList <ResourcePath> potentialActorImages = null; using (IResourceAccessor accessor = new ResourceLocator(mediaItemLocator.NativeSystemId, seasonDirectory).CreateAccessor()) if (accessor is IFileSystemResourceAccessor fsra) { paths = GetSeasonFolderFanArt(fsra, seasonNumber); //See if there's an actor fanart directory and try and get any actor fanart if (actors != null && actors.Count > 0 && fsra.ResourceExists(".actors")) { using (IFileSystemResourceAccessor actorsDirectory = fsra.GetResource(".actors")) potentialActorImages = LocalFanartHelper.GetPotentialFanArtFiles(actorsDirectory); } } if (paths != null) { await SaveFolderImagesToCache(mediaItemLocator.NativeSystemId, paths, seasonMediaItemId, title).ConfigureAwait(false); } if (potentialActorImages != null) { await SavePersonFolderImages(mediaItemLocator.NativeSystemId, potentialActorImages, actors).ConfigureAwait(false); } } catch (Exception ex) { Logger.Warn("SeriesFanArtHandler: Exception while reading folder images for '{0}'", ex, seasonDirectory); } }
protected override void UnregisterResource(string name) { Guard.ArgumentNotNullOrEmpty(name, "name"); lock (_lock) { // contains checks if (!_resources.ContainsKey(name)) { throw new KeyNotFoundException(string.Format(RESOURCE_NOTFOUND, typeof(T), name)); } // we get the locator and dispose it to release any resources IResourceLocator _locator = _resources[name]; if (_locator != null) { _locator.Dispose(); } // and remove, and change the default resource name _resources.Remove(name); if (string.Equals(_defaultResourceName, name, StringComparison.InvariantCultureIgnoreCase)) { _defaultResourceName = null; } // notify collection changed var _collectionChanged = CollectionChanged; if (_collectionChanged != null) { _collectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, _locator, -1)); } } }
protected override void RegisterResourceLocator(IResourceLocator locator, bool isDefault) { Guard.ArgumentNotNull(locator, "locator"); Guard.ArgumentNotNullOrWhiteSpace(locator.ResourceName, "locator", RESOURCE_NOTNULLOREMPTY); // we get the name var _name = locator.ResourceName; lock (_lock) { // and check if (_resources.ContainsKey(_name)) { throw new InvalidOperationException(string.Format(RESOURCE_ALREADYEXISTS, typeof(T).FullName, _name)); } // add the resource _resources.Add(_name, locator); if (isDefault) { _defaultResourceName = _name; } // notify collection changed var _collectionChanged = CollectionChanged; if (_collectionChanged != null) { _collectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, locator, -1)); } } }
/// <summary> /// Creates an <see cref="IInputSource"/> object for a given mediaitem. /// </summary> /// <param name="resourceLocator">Locator instance to the media item to create the input source for.</param> /// <param name="mimeType">Mime type of the media item, if present. May be <c>null</c>.</param> /// <returns>Input source object for the given <paramref name="resourceLocator"/> or <c>null</c>, if no input source /// could be created.</returns> public IInputSource CreateInputSource(IResourceLocator resourceLocator, string mimeType) { if (!CanPlay(resourceLocator, mimeType)) return null; IResourceAccessor accessor = resourceLocator.CreateAccessor(); IInputSource result; AudioCDResourceAccessor acdra = accessor as AudioCDResourceAccessor; if (acdra != null) result = BassCDTrackInputSource.Create(acdra.Drive, acdra.TrackNo); else { string filePath = accessor.ResourcePathName; if (URLUtils.IsCDDA(filePath)) { ILocalFsResourceAccessor lfra = accessor as ILocalFsResourceAccessor; if (lfra == null) return null; result = BassFsCDTrackInputSource.Create(lfra.LocalFileSystemPath); } else if (URLUtils.IsMODFile(filePath)) result = BassMODFileInputSource.Create(accessor); else result = BassAudioFileInputSource.Create(accessor); // TODO: Handle web streams when we have resource accessors for web URLs: BassWebStreamInputSource.Create(...); } accessor.PrepareStreamAccess(); Log.Debug("InputSourceFactory: Creating input source for media resource '{0}' of type '{1}'", accessor, result.GetType()); return result; }
/// <summary> /// Enqueues a play workitem for the given mediaitem. /// </summary> /// <param name="mediaItem">MediaItem to-be-played item.</param> /// <remarks> /// The workitem will actually be executed on the controller's mainthread. /// </remarks> public bool SetMediaItem(MediaItem mediaItem) { string mimeType; string title; if (!GetMediaItemPlayData(mediaItem, out mimeType, out title)) { return(false); } IResourceLocator locator = mediaItem.GetResourceLocator(); if (!InputSourceFactory.CanPlay(locator, mimeType)) { return(false); } if (_externalState != PlayerState.Stopped) { Stop(); } IInputSource inputSource = _inputSourceFactory.CreateInputSource(locator, mimeType); if (inputSource == null) { ServiceRegistration.Get <ILogger>().Warn("Unable to play '{0}'", locator); return(false); } _mediaItemTitle = title; _mediaItemId = mediaItem.MediaItemId; _externalState = PlayerState.Active; _controller.MoveToNextItem_Async(inputSource, StartTime.AtOnce); return(true); }
/// <summary> /// Sets the media item for the new image to be played. /// </summary> /// <param name="mediaItem">MediaItem to-be-played item.</param> public bool SetMediaItem(MediaItem mediaItem) { string mimeType; string title; if (!mediaItem.GetPlayData(out mimeType, out title)) { return(false); } IResourceLocator locator = mediaItem.GetResourceLocator(); if (locator == null) { return(false); } if (!CanPlay(locator, mimeType)) { return(false); } RightAngledRotation rotation = RightAngledRotation.Zero; bool flipX = false; bool flipY = false; SetMediaItemData(locator, title, rotation, flipX, flipY); return(true); }
/// <summary> /// Initializes a new <see cref="ContentTypeHelper"/> instance /// </summary> /// <param name="variationHelper">Variations helper</param> /// <param name="fieldHelper">Field helper</param> /// <param name="resourceLocator">The resource locator</param> /// <param name="log">Logging utility</param> public ContentTypeHelper(IVariationHelper variationHelper, IFieldHelper fieldHelper, IResourceLocator resourceLocator, ILogger log) { this.variationHelper = variationHelper; this.fieldHelper = fieldHelper; this.resourceLocator = resourceLocator; this.log = log; }
public bool NextItem(MediaItem mediaItem, StartTime startTime) { string mimeType; string title; if (!mediaItem.GetPlayData(out mimeType, out title)) { return(false); } IResourceLocator locator = mediaItem.GetResourceLocator(); if (locator == null) { return(false); } IInputSource inputSource = _inputSourceFactory.CreateInputSource(locator, mimeType); if (inputSource == null) { return(false); } lock (_syncObj) _externalState = PlayerState.Active; _controller.MoveToNextItem_Async(inputSource, startTime); _mediaItemTitle = title; // This is a bit too early because we're not switching to the next item at once, but doesn't matter return(true); }
public RefreshableResourceTemplate(IResourceLocator locator, IResourceLocatorFactory factory, string name) { _name = name; _locator = locator; _factory = factory; LoadResource(); }
public virtual bool NextItem(MediaItem mediaItem, StartTime startTime) { string mimeType; string title; // Only re-use player for multi-part files if (!mediaItem.GetPlayData(out mimeType, out title) || mediaItem.MaximumResourceLocatorIndex == 0 && mediaItem.MaximumEditionIndex == 0) { ServiceRegistration.Get <ILogger>().Debug("VideoPlayer: Can reuse current player only for multi-resource items"); return(false); } Stop(); if (mediaItem.ActiveResourceLocatorIndex > mediaItem.MaximumResourceLocatorIndex) { return(false); } // Set new resource locator for existing player, this avoids interim close of player slot IResourceLocator resourceLocator = mediaItem.GetResourceLocator(); ServiceRegistration.Get <ILogger>().Debug("VideoPlayer: Changed resource to index {0}", mediaItem.ActiveResourceLocatorIndex); SetMediaItem(resourceLocator, title, mediaItem); _isPaused = false; return(true); }
public RefreshableResourceTemplate(IResourceLocator locator, IResourceLocatorFactory factory, string name) { _name = name; _locator = locator; _factory = factory; LoadResource(); }
/// <summary> /// Gets all collection folder images and caches them in the <see cref="IFanArtCache"/> service. /// </summary> /// <param name="mediaItemLocator"><see cref="IResourceLocator>"/> that points to the file.</param> /// <param name="collectionMediaItemId">Id of the series media item.</param> /// <param name="title">Title of the media item.</param> /// <returns><see cref="Task"/> that completes when the images have been cached.</returns> protected async Task ExtractCollectionFolderFanArt(IResourceLocator mediaItemLocator, Guid collectionMediaItemId, string title) { var collectionDirectory = ResourcePathHelper.Combine(mediaItemLocator.NativeResourcePath, "../../"); var centralCollectionDirectory = ResourcePathHelper.Combine(mediaItemLocator.NativeResourcePath, "../../../" + MOVIESET_FANART_FOLDER); var centralCollectionDirectory2 = ResourcePathHelper.Combine(mediaItemLocator.NativeResourcePath, "../../" + MOVIESET_FANART_FOLDER); var movieDirectory = ResourcePathHelper.Combine(mediaItemLocator.NativeResourcePath, "../"); try { FanArtPathCollection paths = new FanArtPathCollection(); using (IResourceAccessor accessor = new ResourceLocator(mediaItemLocator.NativeSystemId, centralCollectionDirectory).CreateAccessor()) paths.AddRange(GetCollectionFolderFanArt(accessor as IFileSystemResourceAccessor)); using (IResourceAccessor accessor = new ResourceLocator(mediaItemLocator.NativeSystemId, centralCollectionDirectory2).CreateAccessor()) paths.AddRange(GetCollectionFolderFanArt(accessor as IFileSystemResourceAccessor)); using (IResourceAccessor accessor = new ResourceLocator(mediaItemLocator.NativeSystemId, collectionDirectory).CreateAccessor()) paths.AddRange(GetCollectionFolderFanArt(accessor as IFileSystemResourceAccessor)); using (IResourceAccessor accessor = new ResourceLocator(mediaItemLocator.NativeSystemId, movieDirectory).CreateAccessor()) paths.AddRange(GetMovieFolderCollectionFanArt(accessor as IFileSystemResourceAccessor)); await SaveFolderImagesToCache(mediaItemLocator.NativeSystemId, paths, collectionMediaItemId, title).ConfigureAwait(false); } catch (Exception ex) { Logger.Warn("MovieFanArtHandler: Exception while reading folder images for '{0}'", ex, collectionDirectory); } }
public IPlayer GetPlayer(MediaItem mediaItem) { string mimeType; string title; if (!mediaItem.GetPlayData(out mimeType, out title)) { return(null); } if (mimeType != LiveTvMediaItem.MIME_TYPE_TV && mimeType != LiveTvMediaItem.MIME_TYPE_RADIO) { return(null); } IResourceLocator locator = mediaItem.GetResourceLocator(); BaseDXPlayer player = mimeType == LiveTvMediaItem.MIME_TYPE_TV ? (BaseDXPlayer) new LiveTvPlayer() : new LiveRadioPlayer(true); try { player.SetMediaItem(locator, title); } catch (Exception e) { ServiceRegistration.Get <ILogger>().Warn("SlimTvPlayerBuilder: Error playing media item '{0}'", e, locator); player.Dispose(); return(null); } return(player); }
/// <summary> /// Initializes a new <see cref="ContentTypeHelper"/> instance /// </summary> /// <param name="variationHelper">Variations helper</param> /// <param name="fieldHelper">Field helper</param> /// <param name="resourceLocator">The resource locator</param> /// <param name="log">Logging utility</param> public ContentTypeHelper(IVariationHelper variationHelper, IFieldHelper fieldHelper, IResourceLocator resourceLocator, ILogger log) { this.variationHelper = variationHelper; this.fieldHelper = fieldHelper; this.resourceLocator = resourceLocator; this.log = log; }
public bool NextItem(MediaItem mediaItem, StartTime startTime) { string mimeType; string title; if (!mediaItem.GetPlayData(out mimeType, out title)) { return(false); } IResourceLocator locator = mediaItem.GetResourceLocator(); if (locator == null) { return(false); } if (!CanPlay(locator, mimeType)) { return(false); } RightAngledRotation rotation = RightAngledRotation.Zero; bool flipX = false; bool flipY = false; MediaItemAspect imageAspect = mediaItem[ImageAspect.ASPECT_ID]; if (imageAspect != null) { int orientationInfo = (int)imageAspect[ImageAspect.ATTR_ORIENTATION]; ImageRotation imageRotation; ImageAspect.OrientationToRotation(orientationInfo, out imageRotation); rotation = PlayerRotationTranslator.TranslateToRightAngledRotation(imageRotation); ImageAspect.OrientationToFlip(orientationInfo, out flipX, out flipY); } SetMediaItemData(locator, title, rotation, flipX, flipY); return(true); }
private void ExtractLocalImages(IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?episodeMediaItemId, Guid?seriesMediaItemId, Guid?seasonMediaItemId, EpisodeInfo episode, SeriesInfo series, SeasonInfo season, IDictionary <Guid, string> actorMediaItems) { if (BaseInfo.IsVirtualResource(aspects)) { return; } IResourceLocator mediaItemLocater = GetResourceLocator(aspects); if (mediaItemLocater == null) { return; } ExtractFolderImages(mediaItemLocater, episodeMediaItemId, seriesMediaItemId, seasonMediaItemId, episode, series, season, actorMediaItems); using (IResourceAccessor mediaItemAccessor = mediaItemLocater.CreateAccessor()) { using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor)) { using (rah.LocalFsResourceAccessor.EnsureLocalFileSystemAccess()) { ExtractMkvImages(rah.LocalFsResourceAccessor, seriesMediaItemId, series); } } } }
public IPlayer GetPlayer(MediaItem mediaItem) { string mimeType; string title; if (!mediaItem.GetPlayData(out mimeType, out title)) { return(null); } IResourceLocator locator = mediaItem.GetResourceLocator(); if (!ImagePlayer.CanPlay(locator, mimeType)) { return(null); } ImagePlayer player = new ImagePlayer(); try { if (!player.NextItem(mediaItem, StartTime.AtOnce)) { player.Dispose(); return(null); } } catch (Exception e) { ServiceRegistration.Get <ILogger>().Warn("ImagePlayerBuilder: Error playing media item '{0}'", e, locator); player.Dispose(); return(null); } return(player); }
private void ExtractLocalImages(IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?movieMediaItemId, Guid?collectionMediaItemId, string movieName, string collectionName, IDictionary <Guid, string> actorMediaItems) { if (BaseInfo.IsVirtualResource(aspects)) { return; } IResourceLocator mediaItemLocater = GetResourceLocator(aspects); if (mediaItemLocater == null) { return; } ExtractFolderImages(mediaItemLocater, movieMediaItemId, collectionMediaItemId, movieName, collectionName, actorMediaItems); using (IResourceAccessor mediaItemAccessor = mediaItemLocater.CreateAccessor()) { using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor)) { using (rah.LocalFsResourceAccessor.EnsureLocalFileSystemAccess()) { ExtractMkvImages(rah.LocalFsResourceAccessor, movieMediaItemId, movieName); } } } }
public void SetMediaItem(IResourceLocator locator, string mediaItemTitle) { // free previous opened resource FilterGraphTools.TryDispose(ref _resourceAccessor); FilterGraphTools.TryDispose(ref _rot); _state = PlayerState.Active; _isPaused = true; try { _resourceLocator = locator; _mediaItemTitle = mediaItemTitle; _resourceAccessor = _resourceLocator.CreateAccessor(); // Create a DirectShow FilterGraph CreateGraphBuilder(); // Add it in ROT (Running Object Table) for debug purpose, it allows to view the Graph from outside (i.e. graphedit) _rot = new DsROTEntry(_graphBuilder); // Add a notification handler (see WndProc) _instancePtr = Marshal.AllocCoTaskMem(4); IMediaEventEx mee = _graphBuilder as IMediaEventEx; if (mee != null) { mee.SetNotifyWindow(SkinContext.Form.Handle, WM_GRAPHNOTIFY, _instancePtr); } // Create the Allocator / Presenter object AddPresenter(); ServiceRegistration.Get <ILogger>().Debug("{0}: Adding audio renderer", PlayerTitle); AddAudioRenderer(); ServiceRegistration.Get <ILogger>().Debug("{0}: Adding preferred codecs", PlayerTitle); AddPreferredCodecs(); ServiceRegistration.Get <ILogger>().Debug("{0}: Adding source filter", PlayerTitle); AddSourceFilter(); ServiceRegistration.Get <ILogger>().Debug("{0}: Run graph", PlayerTitle); //This needs to be done here before we check if the evr pins are connected //since this method gives players the chance to render the last bits of the graph OnBeforeGraphRunning(); // Now run the graph, i.e. the DVD player needs a running graph before getting informations from dvd filter. IMediaControl mc = (IMediaControl)_graphBuilder; int hr = mc.Run(); new HRESULT(hr).Throw(); _initialized = true; OnGraphRunning(); } catch (Exception) { Shutdown(); throw; } }
public IPlayer GetPlayer(MediaItem mediaItem) { string mimeType; string title; if (!mediaItem.GetPlayData(out mimeType, out title)) { return(null); } IResourceLocator locator = mediaItem.GetResourceLocator(); Type playerType = PlayerRegistration.GetPlayerTypeForMediaItem(locator, mimeType); if (playerType == null) { return(null); } IInitializablePlayer player = (IInitializablePlayer)Activator.CreateInstance(playerType); try { player.SetMediaItem(locator, title, mediaItem); } catch (Exception e) { // The file might be broken, so the player wasn't able to play it ServiceRegistration.Get <ILogger>().Warn("{0}: Unable to play '{1}'", e, playerType, locator); IDisposable disposablePlayer = player as IDisposable; if (disposablePlayer != null) { disposablePlayer.Dispose(); } throw; } return((IPlayer)player); }
private void ExtractLocalImages(IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?albumMediaItemId, IDictionary <Guid, string> artistMediaItems, string albumTitle) { if (BaseInfo.IsVirtualResource(aspects)) { return; } IResourceLocator mediaItemLocater = GetResourceLocator(aspects); if (mediaItemLocater == null) { return; } ExtractFolderImages(mediaItemLocater, albumMediaItemId, artistMediaItems, albumTitle); using (IResourceAccessor mediaItemAccessor = mediaItemLocater.CreateAccessor()) { using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor)) { using (rah.LocalFsResourceAccessor.EnsureLocalFileSystemAccess()) { ExtractFileImages(rah.LocalFsResourceAccessor, albumMediaItemId, albumTitle); } } } }
private static ResourceManager LoadResourceFileWithCache(string filePath, IResourceLocator locator) { if (!CACHE.ContainsKey(filePath)) { CACHE.Add(filePath, locator.LoadBundle(filePath)); } return(CACHE[filePath]); }
public ObjectPathItemLoader(IResourceLocator <DAL.Model, Model> modelLocator, IResourceLocator <Texture, byte[]> textureLocator, IResourceLocator <DAL.Animation, Animation> animationLocator) { _textureLocator = textureLocator; _modelLocator = modelLocator; _animationLocator = animationLocator; }
/// <summary> /// Constructor to inject the view model dependencies /// </summary> /// <param name="wallPostRepository">Wall post data access</param> /// <param name="wallReplyRepository">Wall reply data access</param> /// <param name="taxonomyService">Taxonomy service</param> /// <param name="resourceLocator">Resource utility</param> /// <param name="log">Logging utility</param> public WallViewModel(IWallPostRepository wallPostRepository, IWallReplyRepository wallReplyRepository, ITaxonomyService taxonomyService, IResourceLocator resourceLocator, ILogger log) { this._wallPostRepository = wallPostRepository; this._wallReplyRepository = wallReplyRepository; this._taxonomyService = taxonomyService; this._resourceLocator = resourceLocator; this._log = log; }
public ParsedTemplate(IResourceLocator locator, IList <ITemplatePart> templateParsed) { _locator = locator; _templateParsed = templateParsed; _context = templateParsed != null && templateParsed.Count > 0 && templateParsed[0] != null ? templateParsed[0].Context : null; }
public ObjectPathItemLoader(IResourceLocator<DAL.Model, Model> modelLocator, IResourceLocator<Texture, byte[]> textureLocator, IResourceLocator<DAL.Animation, Animation> animationLocator) { _textureLocator = textureLocator; _modelLocator = modelLocator; _animationLocator = animationLocator; }
public ITemplate Handle(string entry, IResourceLocator locator, bool throwException) { if (throwException || locator.Exists(entry)) { return new RefreshableResourceTemplate(locator, this, entry); } return null; }
public ResourceTemplate(ITagLib lib, IResourceLocator resource, IResourceLocatorFactory factory, string path) { _lib = lib; _path = path; _resource = resource; _factory = factory; Load(); }
public ITemplate Handle(String entry, IResourceLocator locator, bool throwException) { if (throwException || locator.Exists(entry)) { return(new FileTemplate(locator, this, locator.PreFixed(entry))); } return(null); }
public DashboardContentProvider( IResourceLocator resourceLocator, IQueryExecutor queryExecutor ) { _resourceLocator = resourceLocator; _queryExecutor = queryExecutor; }
public ITagLibParser Construct(ParseHelper helper, IResourceLocator locator) { var mode = _lib.Mode; if(mode==TagLibMode.Strict) return new StrictTagLibParser(_lib, _expressionLib,helper, locator, _factory, _tagValidator); if (mode == TagLibMode.StrictResolve) return new StrictResolveTagLibParser(_lib, _expressionLib, helper, locator, _factory, _tagValidator); if (mode == TagLibMode.RelaxedResolve) return new RelaxedResolveTagLibParser(_lib, _expressionLib, helper, locator, _factory, _tagValidator); if (mode == TagLibMode.IgnoreResolve) return new IgnoreResolveTagLibParser(_lib, _expressionLib, helper, locator, _factory, _tagValidator); return null; }
public AbstractTagLibParser(TagLibForParsing lib, ExpressionLib expressionLib, ParseHelper helper, IResourceLocator locator, IResourceLocatorFactory factory, ITagValidator tagValidator) { _lib = lib; _expressionLib = expressionLib; _helper = helper; _locator = locator; _factory = factory; _tagValidator = tagValidator; }
/// <summary> /// Creates an empty registry. /// </summary> public Registry() { plugins = new Plugins(this); components = new Components(this); services = new Services(this); serviceLocator = new RegistryServiceLocator(this); resourceLocator = new RegistryResourceLocator(this); dataBox = new LockBox<RegistryData>(new RegistryData()); }
/// <summary>Creates a list helper</summary> /// <param name="contentTypeBuilder">The content Type Builder.</param> /// <param name="fieldHelper">Field creator utility</param> /// <param name="resourceLocator">The resource locator</param> /// <param name="logger">The logger</param> /// <param name="listLocator">List locator</param> public ListHelper( IContentTypeHelper contentTypeBuilder, IFieldHelper fieldHelper, IResourceLocator resourceLocator, ILogger logger, IListLocator listLocator) { this.contentTypeBuilder = contentTypeBuilder; this.fieldHelper = fieldHelper; this.resourceLocator = resourceLocator; this.logger = logger; this.listLocator = listLocator; }
public ITag Parse(ParseHelper helper, IResourceLocator locator) { helper.PushNewTokenConfiguration(true, true, null, TagLibConstants.SEPERATORS, null, TagLibConstants.LITERALS, ResetIndex.CurrentAndLookAhead); try { return Construct(helper, locator).Parse(); } finally { helper.PopTokenConfiguration(ResetIndex.LookAhead); } }
public static Type GetPlayerTypeForMediaItem(IResourceLocator locator, string mimeType) { Type playerType; // When a mimetype is set, try to get the player type for it if (mimeType != null && MIMETYPES2PLAYER.TryGetValue(mimeType.ToLowerInvariant(), out playerType)) return playerType; // 2nd chance: If no mimetype matches, try extension string path = locator.NativeResourcePath.LastPathSegment.Path; string extension = StringUtils.TrimToEmpty(ProviderPathHelper.GetExtension(path)).ToLowerInvariant(); if (EXTENSIONS2PLAYER.TryGetValue(extension, out playerType)) return playerType; return null; }
/// <summary> /// Creates an <see cref="IInputSource"/> object for a given mediaitem. /// </summary> /// <param name="resourceLocator">Locator instance to the media item to create the input source for.</param> /// <param name="mimeType">Mime type of the media item, if present. May be <c>null</c>.</param> /// <returns>Input source object for the given <paramref name="resourceLocator"/> or <c>null</c>, if no input source /// could be created.</returns> public IInputSource CreateInputSource(IResourceLocator resourceLocator, string mimeType) { if (!CanPlay(resourceLocator, mimeType)) return null; IInputSource result; _accessor = resourceLocator.CreateAccessor(); AudioCDResourceAccessor acdra = _accessor as AudioCDResourceAccessor; if (acdra != null) result = BassCDTrackInputSource.Create(acdra.Drive, acdra.TrackNo); else { string filePath = _accessor.ResourcePathName; // Network streams INetworkResourceAccessor netra = _accessor as INetworkResourceAccessor; if (netra != null) { result = BassWebStreamInputSource.Create(netra.URL); } // CDDA else if (URLUtils.IsCDDA(filePath)) { ILocalFsResourceAccessor lfra = _accessor as ILocalFsResourceAccessor; if (lfra == null) return null; using (lfra.EnsureLocalFileSystemAccess()) result = BassFsCDTrackInputSource.Create(lfra.LocalFileSystemPath); } else { // Filesystem resources IFileSystemResourceAccessor fsra = _accessor as IFileSystemResourceAccessor; if (fsra == null) return null; if (URLUtils.IsMODFile(filePath)) result = BassMODFileInputSource.Create(fsra); else result = BassAudioFileInputSource.Create(fsra); } } Log.Debug("InputSourceFactory: Creating input source for media resource '{0}' of type '{1}'", _accessor, result.GetType()); return result; }
/// <summary> /// Creates a list finder /// </summary> /// <param name="resources">The resource locator</param> /// <param name="logger">The Logger</param> public ListLocator(IResourceLocator resources, ILogger logger) { this.resources = resources; this.logger = logger; }
/// <summary> /// Sets the data of the new image to be played. /// </summary> /// <param name="locator">Resource locator of the image item.</param> /// <param name="mediaItemTitle">Title of the image item.</param> /// <param name="rotation">Rotation of the image.</param> /// <param name="flipX">Flipping in horizontal direction.</param> /// <param name="flipY">Flipping in vertical direction.</param> public void SetMediaItemData(IResourceLocator locator, string mediaItemTitle, RightAngledRotation rotation, bool flipX, bool flipY) { if (locator == null) lock (_syncObj) { _currentLocator = null; return; } using (IResourceAccessor ra = locator.CreateAccessor()) { IFileSystemResourceAccessor fsra = ra as IFileSystemResourceAccessor; if (fsra == null) return; using (Stream stream = fsra.OpenRead()) { string key = fsra.CanonicalLocalResourcePath.Serialize(); _texture = ContentManager.Instance.GetTexture(stream, key, true); if (_texture == null) return; if (!_texture.IsAllocated) _texture.Allocate(); if (!_texture.IsAllocated) return; } } lock (_syncObj) { ReloadSettings(); _state = PlayerState.Active; _currentLocator = locator; _mediaItemTitle = mediaItemTitle; _rotation = rotation; _flipX = flipX; _flipY = flipY; SurfaceDescription desc = _texture.Texture.GetLevelDescription(0); _textureMaxUV = new SizeF(_texture.Width / (float) desc.Width, _texture.Height / (float) desc.Height); // Reset animation _animator.Initialize(); if (_slideShowTimer != null) _slideShowTimer.Change(_slideShowImageDuration, TS_INFINITE); else CheckTimer(); _playbackStartTime = DateTime.Now; if (_pauseTime.HasValue) _pauseTime = _playbackStartTime; } }
public static bool CanPlay(IResourceLocator locator, string mimeType) { // First check the mime type if (!string.IsNullOrEmpty(mimeType) && !mimeType.StartsWith("image")) return false; using (IResourceAccessor accessor = locator.CreateAccessor()) { if (!(accessor is IFileSystemResourceAccessor)) return false; string ext = StringUtils.TrimToEmpty(DosPathHelper.GetExtension(accessor.ResourcePathName)).ToLowerInvariant(); ImagePlayerSettings settings = ServiceRegistration.Get<ISettingsManager>().Load<ImagePlayerSettings>(); return settings.SupportedExtensions.IndexOf(ext) > -1; } }
public Formatter SetInitialLocator(IResourceLocator locator) { _initialLocator = locator; return this; }
public Formatter Parse() { var f = _locatorFactory.CloneForTagLib(_lib); if (_initialLocator == null) { _initialLocator = f.GetNewLocator(); } var formatter = new InternalFormatter(new TagLibParserFactory(new TagLibForParsing(_lib), _expressionLib, f, _tagValidator), _expressionLib, _template, _allowTags, _initialLocator); try { formatter.Parse(); var templateValidator = _templateValidator ?? CreateTemplateValidatorFor(_lib); templateValidator.Validate(formatter.ParsedTemplate); } finally { _templateParsed = formatter.ParsedTemplate; } return this; }
public void SetMediaItem(IResourceLocator locator, string mediaItemTitle) { // free previous opened resource FilterGraphTools.TryDispose(ref _resourceAccessor); FilterGraphTools.TryDispose(ref _rot); _state = PlayerState.Active; _isPaused = true; try { _resourceLocator = locator; _mediaItemTitle = mediaItemTitle; if (_resourceLocator.NativeResourcePath.IsNetworkResource) { _resourceAccessor = _resourceLocator.CreateAccessor() as INetworkResourceAccessor; if (_resourceAccessor == null) throw new IllegalCallException("The VideoPlayer can only play network resources of type INetworkResourceAccessor"); ServiceRegistration.Get<ILogger>().Debug("{0}: Initializing for network media item '{1}'", PlayerTitle, SourcePathOrUrl); } else { ILocalFsResourceAccessor lfsr; if (!_resourceLocator.TryCreateLocalFsAccessor(out lfsr)) throw new IllegalCallException("The VideoPlayer can only play local file system resources"); _resourceAccessor = lfsr; ServiceRegistration.Get<ILogger>().Debug("{0}: Initializing for media item '{1}'", PlayerTitle, SourcePathOrUrl); } // Create a DirectShow FilterGraph CreateGraphBuilder(); // Add it in ROT (Running Object Table) for debug purpose, it allows to view the Graph from outside (i.e. graphedit) _rot = new DsROTEntry(_graphBuilder); // Add a notification handler (see WndProc) _instancePtr = Marshal.AllocCoTaskMem(4); IMediaEventEx mee = _graphBuilder as IMediaEventEx; if (mee != null) mee.SetNotifyWindow(SkinContext.Form.Handle, WM_GRAPHNOTIFY, _instancePtr); // Create the Allocator / Presenter object AddPresenter(); ServiceRegistration.Get<ILogger>().Debug("{0}: Adding audio renderer", PlayerTitle); AddAudioRenderer(); ServiceRegistration.Get<ILogger>().Debug("{0}: Adding preferred codecs", PlayerTitle); AddPreferredCodecs(); ServiceRegistration.Get<ILogger>().Debug("{0}: Adding file source", PlayerTitle); AddFileSource(); ServiceRegistration.Get<ILogger>().Debug("{0}: Run graph", PlayerTitle); //This needs to be done here before we check if the evr pins are connected //since this method gives players the chance to render the last bits of the graph OnBeforeGraphRunning(); // Now run the graph, i.e. the DVD player needs a running graph before getting informations from dvd filter. IMediaControl mc = (IMediaControl) _graphBuilder; int hr = mc.Run(); DsError.ThrowExceptionForHR(hr); _initialized = true; OnGraphRunning(); } catch (Exception) { Shutdown(); throw; } }
public ParsedTemplate ParseNested(ParseHelper helper, IResourceLocator locator) { try { helper.PushNewTokenConfiguration( true, false, InternalFormatter.COMMENT, InternalFormatter.SEPERATORS, null, null, //InternalFormatter.LITERALS, ResetIndex.LookAhead); return new InternalFormatter(new TagLibParserFactoryAdapter(this), _expressionLib, helper, true, true, locator).ParseNested(); } finally { helper.PopTokenConfiguration(ResetIndex.CurrentAndLookAhead); } }
/// <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 IPlayer GetPlayer(IResourceLocator locator, string mimeType) { if (Enabled && mimeType == "video/bluray") { BDPlayer player = new BDPlayer(); try { player.SetMediaItemLocator(locator); } catch (Exception) { LogError("Error playing media item '{0}'", locator); player.Dispose(); return null; } return player; } return null; }
public void Stop() { lock (_syncObj) { if (_state != PlayerState.Active) return; _state = PlayerState.Stopped; _currentLocator = null; } FireStopped(); }
/// <summary> /// Sets the data of the new image to be played. /// </summary> /// <param name="locator">Resource locator of the image item.</param> /// <param name="mediaItemTitle">Title of the image item.</param> /// <param name="rotation">Rotation of the image.</param> /// <param name="flipX">Flipping in horizontal direction.</param> /// <param name="flipY">Flipping in vertical direction.</param> public void SetMediaItemData(IResourceLocator locator, string mediaItemTitle, RightAngledRotation rotation, bool flipX, bool flipY) { if (locator == null) lock (_syncObj) { DisposeTexture(); _currentLocator = null; return; } Texture texture; ImageInformation imageInformation; using (IResourceAccessor ra = locator.CreateAccessor()) using (Stream stream = ra.OpenRead()) texture = Texture.FromStream(SkinContext.Device, stream, (int) stream.Length, 0, 0, 1, Usage.None, Format.A8R8G8B8, Pool.Default, Filter.None, Filter.None, 0, out imageInformation); lock (_syncObj) { ReloadSettings(); _state = PlayerState.Active; DisposeTexture(); _currentLocator = locator; _mediaItemTitle = mediaItemTitle; _texture = texture; _rotation = rotation; _flipX = flipX; _flipY = flipY; SurfaceDescription desc = _texture.GetLevelDescription(0); _textureMaxUV = new SizeF(imageInformation.Width / (float) desc.Width, imageInformation.Height / (float) desc.Height); // Reset animation _animator.Initialize(); if (_slideShowTimer != null) _slideShowTimer.Change(_slideShowImageDuration, TS_INFINITE); else CheckTimer(); _playbackStartTime = DateTime.Now; if (_pauseTime.HasValue) _pauseTime = _playbackStartTime; } }
public void SetMediaItem(IResourceLocator locator, string mediaItemTitle) { // free previous opened resource FilterGraphTools.TryDispose(ref _resourceAccessor); FilterGraphTools.TryDispose(ref _rot); _state = PlayerState.Active; _isPaused = true; try { _resourceLocator = locator; _mediaItemTitle = mediaItemTitle; CreateResourceAccessor(); // Create a DirectShow FilterGraph CreateGraphBuilder(); // Add it in ROT (Running Object Table) for debug purpose, it allows to view the Graph from outside (i.e. graphedit) _rot = new DsROTEntry(_graphBuilder); // Add a notification handler (see WndProc) _instancePtr = Marshal.AllocCoTaskMem(4); IMediaEventEx mee = _graphBuilder as IMediaEventEx; if (mee != null) mee.SetNotifyWindow(SkinContext.Form.Handle, WM_GRAPHNOTIFY, _instancePtr); // Create the Allocator / Presenter object AddPresenter(); ServiceRegistration.Get<ILogger>().Debug("{0}: Adding audio renderer", PlayerTitle); AddAudioRenderer(); ServiceRegistration.Get<ILogger>().Debug("{0}: Adding preferred codecs", PlayerTitle); AddPreferredCodecs(); ServiceRegistration.Get<ILogger>().Debug("{0}: Adding source filter", PlayerTitle); AddSourceFilter(); ServiceRegistration.Get<ILogger>().Debug("{0}: Run graph", PlayerTitle); //This needs to be done here before we check if the evr pins are connected //since this method gives players the chance to render the last bits of the graph OnBeforeGraphRunning(); // Now run the graph, i.e. the DVD player needs a running graph before getting informations from dvd filter. IMediaControl mc = (IMediaControl) _graphBuilder; int hr = mc.Run(); new HRESULT(hr).Throw(); _initialized = true; OnGraphRunning(); } catch (Exception) { Shutdown(); throw; } }
/// <summary> /// Creates a list helper /// </summary> /// <param name="contentTypeBuilder">A content type helper</param> public ListHelper(ContentTypeBuilder contentTypeBuilder, IResourceLocator resourceLocator) { this.contentTypeBuilder = contentTypeBuilder; this.resourceLocator = resourceLocator; }
public static Formatter LocatorBasedFormatter(ITagLib lib, string path, IResourceLocator locator, IResourceLocatorFactory factory) { var template = locator.GetDataAsString(path); return new Formatter(template). OverrideLib(lib). OverrideExpressionLib(factory.ExpressionLib). AllowTags(true). SetLocatorFactory(factory). SetInitialLocator(locator.Update(path)). SetTagValidator(CreateTagValidatorFor(lib)). Parse(); }
public static bool CanPlay(IResourceLocator locator, string mimeType) { // First check the Mime Type if (!string.IsNullOrEmpty(mimeType) && !mimeType.StartsWith("audio")) return false; using (IResourceAccessor accessor = locator.CreateAccessor()) { if (accessor is AudioCDResourceAccessor || accessor is INetworkResourceAccessor) return true; string ext = DosPathHelper.GetExtension(accessor.ResourcePathName).ToLowerInvariant(); BassPlayerSettings settings = ServiceRegistration.Get<ISettingsManager>().Load<BassPlayerSettings>(); return settings.SupportedExtensions.IndexOf(ext) > -1; } }
/// <summary> /// Initializes a new <see cref="FieldChemaHelper"/> instance /// </summary> /// <param name="resourceLocator">The resource locator</param> /// <param name="logger">The logging utility</param> /// <param name="fieldLocator">Field finder</param> public FieldSchemaHelper(IResourceLocator resourceLocator, ILogger logger, IFieldLocator fieldLocator) { this.resourceLocator = resourceLocator; this.logger = logger; this.fieldLocator = fieldLocator; }