/// <summary>
/// Updates the local state corresponding to the current video player, given in parameter <paramref name="slimDxPlayer"/>.
/// This method will check if the given player is suspended (i.e. it is paused). It will also update the thread state so that the system
/// won't shut down while playing a video.
/// </summary>
/// <param name="slimDxPlayer">Player to check.</param>
private void UpdateVideoPlayerState(ISlimDXVideoPlayer slimDxPlayer)
{
IMediaPlaybackControl player = slimDxPlayer as IMediaPlaybackControl;
_videoPlayerSuspended = player == null || player.IsPaused;
PlayerSuspendLevel = slimDxPlayer == null ? SuspendLevel.None : SuspendLevel.DisplayRequired;
}
private void SynchronizeToVideoPlayerFramerate(ISlimDXVideoPlayer videoPlayer)
{
lock (_screenManager.SyncObj)
{
if (videoPlayer == _synchronizedVideoPlayer)
{
return;
}
ISlimDXVideoPlayer oldPlayer = _synchronizedVideoPlayer;
_synchronizedVideoPlayer = null;
if (oldPlayer != null)
{
oldPlayer.SetRenderDelegate(null);
}
if (videoPlayer != null)
{
if (videoPlayer.SetRenderDelegate(VideoPlayerRender))
{
_synchronizedVideoPlayer = videoPlayer;
ServiceRegistration.Get <ILogger>().Info("SkinEngine MainForm: Synchronized render framerate to video player '{0}'", videoPlayer);
}
else
{
ServiceRegistration.Get <ILogger>().Info(
"SkinEngine MainForm: Video player '{0}' doesn't provide render thread synchronization, using default framerate", videoPlayer);
}
}
}
}
public override void DeepCopy(Utilities.DeepCopy.IDeepCopyable source, Utilities.DeepCopy.ICopyManager copyManager)
{
base.DeepCopy(source, copyManager);
BackgroundVideoBrush b = (BackgroundVideoBrush)source;
VideoPlayer = b.VideoPlayer;
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerStarted:
case PlayerManagerMessaging.MessageType.PlayerStopped:
case PlayerManagerMessaging.MessageType.PlayerEnded:
case PlayerManagerMessaging.MessageType.PlayerSlotsChanged:
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
ISlimDXVideoPlayer player = playerManager[PlayerManagerConsts.PRIMARY_SLOT] as ISlimDXVideoPlayer;
UpdateVideoPlayerState(player);
SynchronizeToVideoPlayerFramerate(player);
break;
}
case PlayerManagerMessaging.MessageType.PlaybackStateChanged:
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
ISlimDXVideoPlayer player = playerManager[PlayerManagerConsts.PRIMARY_SLOT] as ISlimDXVideoPlayer;
UpdateVideoPlayerState(player);
break;
}
}
}
}
protected virtual bool GetPlayer(out ISlimDXVideoPlayer player)
{
player = null;
IPlayerContextManager playerContextManager = ServiceRegistration.Get <IPlayerContextManager>(false);
if (playerContextManager == null)
{
return(false);
}
player = playerContextManager[Stream] as ISlimDXVideoPlayer;
return(player != null);
}
public static void ReallocGUIResources(IPlayerSlotController psc)
{
ISlimDXVideoPlayer sdvp = psc.CurrentPlayer as ISlimDXVideoPlayer;
if (sdvp == null)
{
return;
}
try
{
sdvp.ReallocGUIResources();
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("Problem reallocating GUI resources in player '{0}'", e, sdvp);
}
}
private static string GetPlayerInfos()
{
string playerInfos = string.Empty;
IPlayerManager pm = ServiceRegistration.Get <IPlayerManager>();
int index = 0;
pm.ForEach(psc =>
{
ISlimDXVideoPlayer player = psc.CurrentPlayer as ISlimDXVideoPlayer;
if (player == null || player.Surface == null)
{
return;
}
SurfaceDescription desc = player.Surface.Description;
playerInfos += String.Format("{0}Player {1}: Resolution {2}x{3}", string.IsNullOrEmpty(playerInfos) ? "" : "\r\n", index++, desc.Width, desc.Height);
});
return(playerInfos);
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>(false);
if (playerManager == null)
{
return(false);
}
ISlimDXVideoPlayer player = playerManager[Stream] as ISlimDXVideoPlayer;
if (player == null)
{
return(false);
}
if (!RefreshEffectParameters(player))
{
return(false);
}
lock (player.SurfaceLock)
{
Surface playerSurface = player.Surface;
if (playerSurface == null)
{
return(false);
}
DeviceEx device = SkinContext.Device;
SurfaceDescription desc = playerSurface.Description;
SurfaceDescription?textureDesc = _texture == null ? new SurfaceDescription?() : _texture.GetLevelDescription(0);
if (!textureDesc.HasValue || textureDesc.Value.Width != desc.Width || textureDesc.Value.Height != desc.Height)
{
TryDispose(ref _texture);
_texture = new Texture(device, desc.Width, desc.Height, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
}
using (Surface target = _texture.GetSurfaceLevel(0))
device.StretchRectangle(playerSurface, target, TextureFilter.None);
}
return(_imageContext.StartRender(renderContext, _scaledVideoSize, _texture, _videoTextureClip, BorderColor.ToArgb(), _lastFrameData));
}
protected override bool GetPlayer(out ISlimDXVideoPlayer player)
{
player = VideoPlayer;
return(player != null);
}
private void SynchronizeToVideoPlayerFramerate(ISlimDXVideoPlayer videoPlayer)
{
lock (_screenManager.SyncObj)
{
if (videoPlayer == _synchronizedVideoPlayer)
return;
ISlimDXVideoPlayer oldPlayer = _synchronizedVideoPlayer;
_synchronizedVideoPlayer = null;
if (oldPlayer != null)
oldPlayer.SetRenderDelegate(null);
if (videoPlayer != null)
if (videoPlayer.SetRenderDelegate(VideoPlayerRender))
{
_synchronizedVideoPlayer = videoPlayer;
ServiceRegistration.Get<ILogger>().Info("SkinEngine MainForm: Synchronized render framerate to video player '{0}'", videoPlayer);
}
else
ServiceRegistration.Get<ILogger>().Info(
"SkinEngine MainForm: Video player '{0}' doesn't provide render thread synchronization, using default framerate", videoPlayer);
}
}
/// <summary>
/// Updates the local state corresponding to the current video player, given in parameter <paramref name="slimDxPlayer"/>.
/// This method will check if the given player is suspended (i.e. it is paused). It will also update the thread state so that the system
/// won't shut down while playing a video.
/// </summary>
/// <param name="slimDxPlayer">Player to check.</param>
private void UpdateVideoPlayerState(ISlimDXVideoPlayer slimDxPlayer)
{
IMediaPlaybackControl player = slimDxPlayer as IMediaPlaybackControl;
_videoPlayerSuspended = player == null || player.IsPaused;
PlayerSuspendLevel = slimDxPlayer == null ? SuspendLevel.None : SuspendLevel.DisplayRequired;
}
protected override bool GetPlayer(out ISlimDXVideoPlayer player)
{
player = VideoPlayer;
return player != null;
}
public override void DeepCopy(Utilities.DeepCopy.IDeepCopyable source, Utilities.DeepCopy.ICopyManager copyManager)
{
base.DeepCopy(source, copyManager);
BackgroundVideoBrush b = (BackgroundVideoBrush) source;
VideoPlayer = b.VideoPlayer;
}
protected virtual bool GetPlayer(out ISlimDXVideoPlayer player)
{
player = null;
IPlayerContextManager playerContextManager = ServiceRegistration.Get<IPlayerContextManager>(false);
if (playerContextManager == null)
return false;
player = playerContextManager[Stream] as ISlimDXVideoPlayer;
return player != null;
}
protected bool RefreshEffectParameters(IVideoPlayer player)
{
ISlimDXVideoPlayer sdvPlayer = player as ISlimDXVideoPlayer;
if (sdvPlayer == null)
{
return(false);
}
SizeF aspectRatio = sdvPlayer.VideoAspectRatio;
Size playerSize = sdvPlayer.VideoSize;
Rectangle cropVideoRect = sdvPlayer.CropVideoRect;
IGeometry geometry = ChooseVideoGeometry(player);
string effectName = player.EffectOverride;
int deviceWidth = GraphicsDevice.Width; // To avoid threading issues if the device size changes
int deviceHeight = GraphicsDevice.Height;
RectangleF vertsBounds = _vertsBounds;
// Do we need a refresh?
if (!_refresh &&
_lastVideoSize == playerSize &&
_lastAspectRatio == aspectRatio &&
_lastCropVideoRect == cropVideoRect &&
_lastGeometry == geometry &&
_lastEffect == effectName &&
_lastDeviceWidth == deviceWidth &&
_lastDeviceHeight == deviceHeight &&
_lastVertsBounds == vertsBounds)
{
return(true);
}
SizeF targetSize = vertsBounds.Size;
lock (sdvPlayer.SurfaceLock)
{
Surface surface = sdvPlayer.Surface;
if (surface == null)
{
_refresh = true;
return(false);
}
SurfaceDescription desc = surface.Description;
_videoTextureClip = new Rectangle(cropVideoRect.X / desc.Width, cropVideoRect.Y / desc.Height,
cropVideoRect.Width / desc.Width, cropVideoRect.Height / desc.Height);
}
_scaledVideoSize = cropVideoRect.Size;
// Correct aspect ratio for anamorphic video
if (!aspectRatio.IsEmpty && geometry.RequiresCorrectAspectRatio)
{
float pixelRatio = aspectRatio.Width / aspectRatio.Height;
_scaledVideoSize.Width = _scaledVideoSize.Height * pixelRatio;
}
// Adjust target size to match final Skin scaling
targetSize = ImageContext.AdjustForSkinAR(targetSize);
// Adjust video size to fit desired geometry
_scaledVideoSize = geometry.Transform(_scaledVideoSize, targetSize);
// Cache inverse RelativeTransform
Transform relativeTransform = RelativeTransform;
_inverseRelativeTransformCache = (relativeTransform == null) ? Matrix.Identity : Matrix.Invert(relativeTransform.GetTransform());
// Prepare our ImageContext
_imageContext.FrameSize = targetSize;
_imageContext.ShaderBase = EFFECT_BASE_VIDEO;
_imageContext.ShaderTransform = geometry.Shader;
_imageContext.ShaderEffect = player.EffectOverride;
// Store state
_lastFrameData = new Vector4(playerSize.Width, playerSize.Height, 0.0f, 0.0f);
_lastVideoSize = playerSize;
_lastAspectRatio = aspectRatio;
_lastGeometry = geometry;
_lastCropVideoRect = cropVideoRect;
_lastEffect = effectName;
_lastDeviceWidth = deviceWidth;
_lastDeviceHeight = deviceHeight;
_refresh = false;
return(true);
}
