VideoPlayer: create a state for gui/video render

xbmc/ApplicationPlayer.cpp

@@ -23,8 +23,10 @@
 #include "cores/IPlayer.h"
 #include "cores/playercorefactory/PlayerCoreFactory.h"
 #include "guilib/GUIWindowManager.h"
+#include "cores/DataCacheCore.h"
 #include "Application.h"
 #include "PlayListPlayer.h"
+#include "ServiceBroker.h"
 #include "settings/MediaSettings.h"
 
 CApplicationPlayer::CApplicationPlayer()
@@ -125,18 +127,18 @@ PlayBackRet CApplicationPlayer::OpenFile(const CFileItem& item, const CPlayerOpt
   return iResult;
 }
 
-bool CApplicationPlayer::HasPlayer() const 
-{ 
+bool CApplicationPlayer::HasPlayer() const
+{
   std::shared_ptr<IPlayer> player = GetInternal();
-  return player != NULL; 
+  return player != NULL;
 }
 
 int CApplicationPlayer::GetChapter()
 {
   std::shared_ptr<IPlayer> player = GetInternal();
   if (player)
     return player->GetChapter();
-  else 
+  else
     return -1;
 }
 
@@ -145,7 +147,7 @@ int CApplicationPlayer::GetChapterCount()
   std::shared_ptr<IPlayer> player = GetInternal();
   if (player)
     return player->GetChapterCount();
-  else 
+  else
     return 0;
 }
 
@@ -810,7 +812,7 @@ bool CApplicationPlayer::IsRenderingGuiLayer()
 {
   std::shared_ptr<IPlayer> player = GetInternal();
   if (player)
-    return player->IsRenderingGuiLayer();
+    return CServiceBroker::GetDataCacheCore().GetGuiRender();
   else
     return false;
 }
@@ -819,7 +821,7 @@ bool CApplicationPlayer::IsRenderingVideoLayer()
 {
   std::shared_ptr<IPlayer> player = GetInternal();
   if (player)
-    return player->IsRenderingVideoLayer();
+    return CServiceBroker::GetDataCacheCore().GetVideoRender();
   else
     return false;
 }

xbmc/cores/DataCacheCore.cpp

@@ -246,3 +246,33 @@ bool CDataCacheCore::IsPlayerStateChanged()
 
   return ret;
 }
+
+void CDataCacheCore::SetGuiRender(bool gui)
+{
+  CSingleLock lock(m_stateSection);
+
+  m_stateInfo.m_renderGuiLayer = gui;
+  m_playerStateChanged = true;
+}
+
+bool CDataCacheCore::CDataCacheCore::GetGuiRender()
+{
+  CSingleLock lock(m_stateSection);
+
+  return m_stateInfo.m_renderGuiLayer;
+}
+
+void CDataCacheCore::SetVideoRender(bool video)
+{
+  CSingleLock lock(m_stateSection);
+
+  m_stateInfo.m_renderVideoLayer = video;
+  m_playerStateChanged = true;
+}
+
+bool CDataCacheCore::CDataCacheCore::GetVideoRender()
+{
+  CSingleLock lock(m_stateSection);
+
+  return m_stateInfo.m_renderVideoLayer;
+}

xbmc/cores/DataCacheCore.h

@@ -67,6 +67,9 @@ class CDataCacheCore
   void SetStateSeeking(bool active);
   bool IsSeeking();
   bool IsPlayerStateChanged();
+  void SetGuiRender(bool gui);
+  bool GetGuiRender();
+  void SetVideoRender(bool video);
 
 protected:
   std::atomic_bool m_hasAVInfoChanges;
@@ -104,5 +107,7 @@ class CDataCacheCore
   struct SStateInfo
   {
     bool m_stateSeeking;
+    bool m_renderGuiLayer;
+    bool m_renderVideoLayer;
   } m_stateInfo;
 };

xbmc/cores/IPlayer.h

@@ -358,23 +358,13 @@ class IPlayer
    \brief hook into render loop of render thread
    */
   virtual void FrameMove() {};
-
   virtual void Render(bool clear, uint32_t alpha = 255, bool gui = true) {};
-
   virtual void FlushRenderer() {};
-
   virtual void SetRenderViewMode(int mode) {};
-
   virtual float GetRenderAspectRatio() { return 1.0; };
-
   virtual void TriggerUpdateResolution() {};
-
   virtual bool IsRenderingVideo() { return false; };
 
-  virtual bool IsRenderingGuiLayer() { return false; };
-
-  virtual bool IsRenderingVideoLayer() { return false; };
-
   virtual bool Supports(EINTERLACEMETHOD method) { return false; };
   virtual EINTERLACEMETHOD GetDeinterlacingMethodDefault() { return EINTERLACEMETHOD::VS_INTERLACEMETHOD_NONE; }
   virtual bool Supports(ESCALINGMETHOD method) { return false; };

xbmc/cores/RetroPlayer/RetroPlayer.h

@@ -127,8 +127,6 @@ namespace RETRO
     virtual float GetRenderAspectRatio() override { return m_renderManager.GetAspectRatio(); }
     virtual void TriggerUpdateResolution() override { m_renderManager.TriggerUpdateResolution(0.0f, 0, 0); }
     virtual bool IsRenderingVideo() override { return m_renderManager.IsConfigured(); }
-    virtual bool IsRenderingGuiLayer() override { return m_renderManager.IsGuiLayer(); }
-    virtual bool IsRenderingVideoLayer() override { return m_renderManager.IsVideoLayer(); }
     virtual bool Supports(EINTERLACEMETHOD method) override;
     virtual EINTERLACEMETHOD GetDeinterlacingMethodDefault() override;
     virtual bool Supports(ESCALINGMETHOD method) override { return m_renderManager.Supports(method); }

xbmc/cores/VideoPlayer/Process/ProcessInfo.cpp

@@ -38,11 +38,16 @@ CProcessInfo* CProcessInfo::CreateInstance()
 CProcessInfo::CProcessInfo()
 {
   ResetVideoCodecInfo();
+  m_renderGuiLayer = true;
+  m_renderVideoLayer = false;
+  CServiceBroker::GetDataCacheCore().SetGuiRender(m_renderGuiLayer);
+  CServiceBroker::GetDataCacheCore().SetVideoRender(m_renderVideoLayer);
 }
 
 CProcessInfo::~CProcessInfo()
 {
-
+  CServiceBroker::GetDataCacheCore().SetGuiRender(false);
+  CServiceBroker::GetDataCacheCore().SetVideoRender(false);
 }
 
 void CProcessInfo::ResetVideoCodecInfo()
@@ -391,3 +396,37 @@ int CProcessInfo::GetLevelVQ()
 {
   return m_levelVQ;
 }
+
+void CProcessInfo::SetGuiRender(bool gui)
+{
+  CSingleLock lock(m_stateSection);
+
+  bool change = (m_renderGuiLayer != gui);
+  m_renderGuiLayer = gui;
+  if (change)
+    CServiceBroker::GetDataCacheCore().SetGuiRender(gui);
+}
+
+bool CProcessInfo::GetGuiRender()
+{
+  CSingleLock lock(m_stateSection);
+
+  return m_renderGuiLayer;
+}
+
+void CProcessInfo::SetVideoRender(bool video)
+{
+  CSingleLock lock(m_stateSection);
+
+  bool change = (m_renderVideoLayer != video);
+  m_renderVideoLayer = video;
+  if (change)
+    CServiceBroker::GetDataCacheCore().SetVideoRender(video);
+}
+
+bool CProcessInfo::GetVideoRender()
+{
+  CSingleLock lock(m_stateSection);
+
+  return m_renderVideoLayer;
+}

xbmc/cores/VideoPlayer/Process/ProcessInfo.h

@@ -79,6 +79,10 @@ class CProcessInfo
 
   void SetLevelVQ(int level);
   int GetLevelVQ();
+  void SetGuiRender(bool gui);
+  bool GetGuiRender();
+  void SetVideoRender(bool video);
+  bool GetVideoRender();
 
 protected:
   CProcessInfo();
@@ -115,4 +119,6 @@ class CProcessInfo
   CCriticalSection m_stateSection;
   bool m_stateSeeking;
   std::atomic_int m_levelVQ;
+  std::atomic_bool m_renderGuiLayer;
+  std::atomic_bool m_renderVideoLayer;
 };

xbmc/cores/VideoPlayer/VideoPlayer.cpp

@@ -5215,16 +5215,6 @@ bool CVideoPlayer::IsRenderingVideo()
   return m_renderManager.IsConfigured();
 }
 
-bool CVideoPlayer::IsRenderingGuiLayer()
-{
-  return m_renderManager.IsGuiLayer();
-}
-
-bool CVideoPlayer::IsRenderingVideoLayer()
-{
-  return m_renderManager.IsVideoLayer();
-}
-
 bool CVideoPlayer::Supports(EINTERLACEMETHOD method)
 {
   if (!m_processInfo)
@@ -5296,6 +5286,16 @@ void CVideoPlayer::UpdateRenderBuffers(int queued, int discard, int free)
   m_processInfo->UpdateRenderBuffers(queued, discard, free);
 }
 
+void CVideoPlayer::UpdareGuiRender(bool gui)
+{
+  m_processInfo->SetGuiRender(gui);
+}
+
+void CVideoPlayer::UpdareVideoRender(bool video)
+{
+  m_processInfo->SetVideoRender(video);
+}
+
 // IDispResource interface
 void CVideoPlayer::OnLostDisplay()
 {

xbmc/cores/VideoPlayer/VideoPlayer.h

@@ -371,15 +371,13 @@ class CVideoPlayer : public IPlayer, public CThread, public IVideoPlayer, public
 
   virtual bool SwitchChannel(const PVR::CPVRChannelPtr &channel);
 
-  virtual void FrameMove();
-  virtual void Render(bool clear, uint32_t alpha = 255, bool gui = true);
-  virtual void FlushRenderer();
-  virtual void SetRenderViewMode(int mode);
-  float GetRenderAspectRatio();
-  virtual void TriggerUpdateResolution();
-  virtual bool IsRenderingVideo();
-  virtual bool IsRenderingGuiLayer();
-  virtual bool IsRenderingVideoLayer();
+  virtual void FrameMove() override;
+  virtual void Render(bool clear, uint32_t alpha = 255, bool gui = true) override;
+  virtual void FlushRenderer() override;
+  virtual void SetRenderViewMode(int mode) override;
+  virtual float GetRenderAspectRatio() override;
+  virtual void TriggerUpdateResolution() override;
+  virtual bool IsRenderingVideo() override;
   virtual bool Supports(EINTERLACEMETHOD method) override;
   virtual EINTERLACEMETHOD GetDeinterlacingMethodDefault() override;
   virtual bool Supports(ESCALINGMETHOD method) override;
@@ -403,14 +401,16 @@ class CVideoPlayer : public IPlayer, public CThread, public IVideoPlayer, public
 protected:
   friend class CSelectionStreams;
 
-  virtual void OnStartup();
-  virtual void OnExit();
-  virtual void Process();
+  virtual void OnStartup() override;
+  virtual void OnExit() override;
+  virtual void Process() override;
   virtual void VideoParamsChange() override;
   virtual void GetDebugInfo(std::string &audio, std::string &video, std::string &general) override;
   virtual void UpdateClockSync(bool enabled) override;
   virtual void UpdateRenderInfo(CRenderInfo &info) override;
   virtual void UpdateRenderBuffers(int queued, int discard, int free) override;
+  virtual void UpdareGuiRender(bool gui) override;
+  virtual void UpdareVideoRender(bool video) override;
 
   void CreatePlayers();
   void DestroyPlayers();

xbmc/cores/VideoPlayer/VideoRenderers/RenderManager.cpp

@@ -275,7 +275,7 @@ bool CRenderManager::Configure()
     DeleteRenderer();
   }
 
-  if(!m_pRenderer)
+  if (!m_pRenderer)
   {
     CreateRenderer();
     if (!m_pRenderer)
@@ -303,6 +303,7 @@ bool CRenderManager::Configure()
     m_pRenderer->Update();
 
     m_playerPort->UpdateRenderInfo(info);
+    m_playerPort->UpdareVideoRender(!m_pRenderer->IsGuiLayer());
 
     m_queued.clear();
     m_discard.clear();
@@ -427,6 +428,8 @@ void CRenderManager::FrameMove()
     m_bRenderGUI = true;
   }
 
+  m_playerPort->UpdateGuiRender(IsGuiLayer());
+
   ManageCaptures();
 }
 
@@ -972,6 +975,8 @@ void CRenderManager::Render(bool clear, DWORD flags, DWORD alpha, bool gui)
 
     m_presentevent.notifyAll();
   }
+
+  m_playerPort->UpdareGuiRender(IsGuiLayer());
 }
 
 bool CRenderManager::IsGuiLayer()

xbmc/cores/VideoPlayer/VideoRenderers/RenderManager.h

@@ -56,6 +56,8 @@ class IRenderMsg
   virtual void UpdateClockSync(bool enabled) = 0;
   virtual void UpdateRenderInfo(CRenderInfo &info) = 0;
   virtual void UpdateRenderBuffers(int queued, int discard, int free) = 0;
+  virtual void UpdareGuiRender(bool gui) = 0;
+  virtual void UpdareVideoRender(bool video) = 0;
 };
 
 class CRenderManager
@@ -70,7 +72,6 @@ class CRenderManager
   void FrameMove();
   void FrameWait(int ms);
   void Render(bool clear, DWORD flags = 0, DWORD alpha = 255, bool gui = true);
-  bool IsGuiLayer();
   bool IsVideoLayer();
   RESOLUTION GetResolution();
   void UpdateResolution();
@@ -160,6 +161,7 @@ class CRenderManager
 
   void PrepareNextRender();
   bool IsPresenting();
+  bool IsGuiLayer();
 
   bool Configure();
   void CreateRenderer();