xbmc/windowing/X11/WinSystemX11GLContext.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "WinSystemX11GLContext.h"
  10
  11 #include "GLContextEGL.h"
  12 #include "OptionalsReg.h"
  13 #include "ServiceBroker.h"
  14 #include "VideoSyncOML.h"
  15 #include "X11DPMSSupport.h"
  16 #include "application/AppParams.h"
  17 #include "application/ApplicationComponents.h"
  18 #include "application/ApplicationSkinHandling.h"
  19 #include "cores/RetroPlayer/process/X11/RPProcessInfoX11.h"
  20 #include "cores/RetroPlayer/rendering/VideoRenderers/RPRendererOpenGL.h"
  21 #include "cores/VideoPlayer/DVDCodecs/DVDFactoryCodec.h"
  22 #include "cores/VideoPlayer/Process/X11/ProcessInfoX11.h"
  23 #include "cores/VideoPlayer/VideoReferenceClock.h"
  24 #include "cores/VideoPlayer/VideoRenderers/LinuxRendererGL.h"
  25 #include "cores/VideoPlayer/VideoRenderers/RenderFactory.h"
  26 #include "guilib/DispResource.h"
  27 #include "rendering/gl/ScreenshotSurfaceGL.h"
  28 #include "windowing/GraphicContext.h"
  29 #include "windowing/WindowSystemFactory.h"
  30
  31 #include <memory>
  32 #include <mutex>
  33 #include <vector>
  34
  35 #include <X11/Xlib.h>
  36 #include <X11/Xutil.h>
  37
  38 using namespace KODI;
  39 using namespace KODI::WINDOWING::X11;
  40
  41
  42 void CWinSystemX11GLContext::Register()
  43 {
  44   KODI::WINDOWING::CWindowSystemFactory::RegisterWindowSystem(CreateWinSystem, "x11");
  45 }
  46
  47 std::unique_ptr<CWinSystemBase> CWinSystemX11GLContext::CreateWinSystem()
  48 {
  49   return std::make_unique<CWinSystemX11GLContext>();
  50 }
  51
  52 CWinSystemX11GLContext::~CWinSystemX11GLContext()
  53 {
  54   delete m_pGLContext;
  55 }
  56
  57 void CWinSystemX11GLContext::PresentRenderImpl(bool rendered)
  58 {
  59   if (rendered)
  60     m_pGLContext->SwapBuffers();
  61
  62   if (m_delayDispReset && m_dispResetTimer.IsTimePast())
  63   {
  64     m_delayDispReset = false;
  65     std::unique_lock<CCriticalSection> lock(m_resourceSection);
  66     // tell any shared resources
  67     for (std::vector<IDispResource *>::iterator i = m_resources.begin(); i != m_resources.end(); ++i)
  68       (*i)->OnResetDisplay();
  69   }
  70 }
  71
  72 void CWinSystemX11GLContext::SetVSyncImpl(bool enable)
  73 {
  74   m_pGLContext->SetVSync(enable);
  75 }
  76
  77 bool CWinSystemX11GLContext::IsExtSupported(const char* extension) const
  78 {
  79   if(strncmp(extension, m_pGLContext->ExtPrefix().c_str(), 4) != 0)
  80     return CRenderSystemGL::IsExtSupported(extension);
  81
  82   return m_pGLContext->IsExtSupported(extension);
  83 }
  84
  85 XID CWinSystemX11GLContext::GetWindow() const
  86 {
  87   return GLXGetWindow(m_pGLContext);
  88 }
  89
  90 void* CWinSystemX11GLContext::GetGlxContext() const
  91 {
  92   return GLXGetContext(m_pGLContext);
  93 }
  94
  95 EGLDisplay CWinSystemX11GLContext::GetEGLDisplay() const
  96 {
  97   return static_cast<CGLContextEGL*>(m_pGLContext)->m_eglDisplay;
  98 }
  99
 100 EGLSurface CWinSystemX11GLContext::GetEGLSurface() const
 101 {
 102   return static_cast<CGLContextEGL*>(m_pGLContext)->m_eglSurface;
 103 }
 104
 105 EGLContext CWinSystemX11GLContext::GetEGLContext() const
 106 {
 107   return static_cast<CGLContextEGL*>(m_pGLContext)->m_eglContext;
 108 }
 109
 110 EGLConfig CWinSystemX11GLContext::GetEGLConfig() const
 111 {
 112   return static_cast<CGLContextEGL*>(m_pGLContext)->m_eglConfig;
 113 }
 114
 115 bool CWinSystemX11GLContext::BindTextureUploadContext()
 116 {
 117   if (m_pGLContext)
 118     return static_cast<CGLContextEGL*>(m_pGLContext)->BindTextureUploadContext();
 119   else
 120     return false;
 121 }
 122
 123 bool CWinSystemX11GLContext::UnbindTextureUploadContext()
 124 {
 125   if (m_pGLContext)
 126     return static_cast<CGLContextEGL*>(m_pGLContext)->UnbindTextureUploadContext();
 127   else
 128     return false;
 129 }
 130
 131 bool CWinSystemX11GLContext::HasContext()
 132 {
 133   if (m_pGLContext)
 134     return static_cast<CGLContextEGL*>(m_pGLContext)->HasContext();
 135   else
 136     return false;
 137 }
 138
 139 bool CWinSystemX11GLContext::SetWindow(int width, int height, bool fullscreen, const std::string &output, int *winstate)
 140 {
 141   int newwin = 0;
 142
 143   CWinSystemX11::SetWindow(width, height, fullscreen, output, &newwin);
 144   if (newwin)
 145   {
 146     RefreshGLContext(m_currentOutput.compare(output) != 0);
 147     XSync(m_dpy, False);
 148     CServiceBroker::GetWinSystem()->GetGfxContext().Clear(0);
 149     CServiceBroker::GetWinSystem()->GetGfxContext().Flip(true, false);
 150     ResetVSync();
 151
 152     m_windowDirty = false;
 153     m_bIsInternalXrr = false;
 154
 155     if (!m_delayDispReset)
 156     {
 157       std::unique_lock<CCriticalSection> lock(m_resourceSection);
 158       // tell any shared resources
 159       for (std::vector<IDispResource *>::iterator i = m_resources.begin(); i != m_resources.end(); ++i)
 160         (*i)->OnResetDisplay();
 161     }
 162   }
 163   return true;
 164 }
 165
 166 bool CWinSystemX11GLContext::CreateNewWindow(const std::string& name, bool fullScreen, RESOLUTION_INFO& res)
 167 {
 168   if(!CWinSystemX11::CreateNewWindow(name, fullScreen, res))
 169     return false;
 170
 171   m_pGLContext->QueryExtensions();
 172   return true;
 173 }
 174
 175 bool CWinSystemX11GLContext::ResizeWindow(int newWidth, int newHeight, int newLeft, int newTop)
 176 {
 177   m_newGlContext = false;
 178   CWinSystemX11::ResizeWindow(newWidth, newHeight, newLeft, newTop);
 179   CRenderSystemGL::ResetRenderSystem(newWidth, newHeight);
 180
 181   if (m_newGlContext)
 182   {
 183     auto& components = CServiceBroker::GetAppComponents();
 184     const auto appSkin = components.GetComponent<CApplicationSkinHandling>();
 185     appSkin->ReloadSkin();
 186   }
 187
 188   return true;
 189 }
 190
 191 void CWinSystemX11GLContext::FinishWindowResize(int newWidth, int newHeight)
 192 {
 193   m_newGlContext = false;
 194   CWinSystemX11::FinishWindowResize(newWidth, newHeight);
 195   CRenderSystemGL::ResetRenderSystem(newWidth, newHeight);
 196
 197   if (m_newGlContext)
 198   {
 199     auto& components = CServiceBroker::GetAppComponents();
 200     const auto appSkin = components.GetComponent<CApplicationSkinHandling>();
 201     appSkin->ReloadSkin();
 202   }
 203 }
 204
 205 bool CWinSystemX11GLContext::SetFullScreen(bool fullScreen, RESOLUTION_INFO& res, bool blankOtherDisplays)
 206 {
 207   m_newGlContext = false;
 208   CWinSystemX11::SetFullScreen(fullScreen, res, blankOtherDisplays);
 209   CRenderSystemGL::ResetRenderSystem(res.iWidth, res.iHeight);
 210
 211   if (m_newGlContext)
 212   {
 213     auto& components = CServiceBroker::GetAppComponents();
 214     const auto appSkin = components.GetComponent<CApplicationSkinHandling>();
 215     appSkin->ReloadSkin();
 216   }
 217
 218   return true;
 219 }
 220
 221 bool CWinSystemX11GLContext::DestroyWindowSystem()
 222 {
 223   if (m_pGLContext)
 224     m_pGLContext->Destroy();
 225   return CWinSystemX11::DestroyWindowSystem();
 226 }
 227
 228 bool CWinSystemX11GLContext::DestroyWindow()
 229 {
 230   if (m_pGLContext)
 231     m_pGLContext->Detach();
 232   return CWinSystemX11::DestroyWindow();
 233 }
 234
 235 XVisualInfo* CWinSystemX11GLContext::GetVisual()
 236 {
 237   int count = 0;
 238   XVisualInfo vTemplate;
 239   XVisualInfo *visual = nullptr;
 240
 241   int vMask = VisualScreenMask | VisualDepthMask | VisualClassMask;
 242
 243   vTemplate.screen = m_screen;
 244   vTemplate.depth = 24;
 245   vTemplate.c_class = TrueColor;
 246
 247   visual = XGetVisualInfo(m_dpy, vMask, &vTemplate, &count);
 248
 249   if (!visual)
 250   {
 251     vTemplate.depth = 30;
 252     visual = XGetVisualInfo(m_dpy, vMask, &vTemplate, &count);
 253   }
 254
 255   return visual;
 256 }
 257
 258 bool CWinSystemX11GLContext::RefreshGLContext(bool force)
 259 {
 260   bool success = false;
 261   if (m_pGLContext)
 262   {
 263     if (force)
 264     {
 265       auto& components = CServiceBroker::GetAppComponents();
 266       const auto appSkin = components.GetComponent<CApplicationSkinHandling>();
 267       appSkin->UnloadSkin();
 268       CRenderSystemGL::DestroyRenderSystem();
 269     }
 270     success = m_pGLContext->Refresh(force, m_screen, m_glWindow, m_newGlContext);
 271     if (!success)
 272     {
 273       success = m_pGLContext->CreatePB();
 274       m_newGlContext = true;
 275     }
 276     if (force)
 277       CRenderSystemGL::InitRenderSystem();
 278     return success;
 279   }
 280
 281   m_dpms = std::make_shared<CX11DPMSSupport>();
 282   VIDEOPLAYER::CProcessInfoX11::Register();
 283   RETRO::CRPProcessInfoX11::Register();
 284   RETRO::CRPProcessInfoX11::RegisterRendererFactory(new RETRO::CRendererFactoryOpenGL);
 285   CDVDFactoryCodec::ClearHWAccels();
 286   VIDEOPLAYER::CRendererFactory::ClearRenderer();
 287   CLinuxRendererGL::Register();
 288
 289   CScreenshotSurfaceGL::Register();
 290
 291   std::string gpuvendor;
 292   const char* vend = (const char*) glGetString(GL_VENDOR);
 293   if (vend)
 294     gpuvendor = vend;
 295   std::transform(gpuvendor.begin(), gpuvendor.end(), gpuvendor.begin(), ::tolower);
 296   bool isNvidia = (gpuvendor.compare(0, 6, "nvidia") == 0);
 297   bool isIntel = (gpuvendor.compare(0, 5, "intel") == 0);
 298
 299   std::string_view gli = CServiceBroker::GetAppParams()->GetGlInterface();
 300
 301   if (gli != "glx")
 302   {
 303     m_pGLContext = new CGLContextEGL(m_dpy, EGL_OPENGL_API);
 304     success = m_pGLContext->Refresh(force, m_screen, m_glWindow, m_newGlContext);
 305     if (success)
 306     {
 307       if (!isNvidia)
 308       {
 309         m_vaapiProxy.reset(VaapiProxyCreate());
 310         VaapiProxyConfig(m_vaapiProxy.get(), GetDisplay(),
 311                               static_cast<CGLContextEGL*>(m_pGLContext)->m_eglDisplay);
 312         bool general = false;
 313         bool deepColor = false;
 314         VAAPIRegisterRenderGL(m_vaapiProxy.get(), general, deepColor);
 315         if (general)
 316         {
 317           VAAPIRegister(m_vaapiProxy.get(), deepColor);
 318           return true;
 319         }
 320         if (isIntel || gli == "egl")
 321           return true;
 322       }
 323     }
 324     else if (gli == "egl-pb")
 325     {
 326       success = m_pGLContext->CreatePB();
 327       if (success)
 328         return true;
 329     }
 330   }
 331
 332   delete m_pGLContext;
 333
 334   // fallback for vdpau
 335   m_pGLContext = GLXContextCreate(m_dpy);
 336   success = m_pGLContext->Refresh(force, m_screen, m_glWindow, m_newGlContext);
 337   if (success)
 338   {
 339     VDPAURegister();
 340     VDPAURegisterRender();
 341   }
 342   return success;
 343 }
 344
 345 std::unique_ptr<CVideoSync> CWinSystemX11GLContext::GetVideoSync(CVideoReferenceClock* clock)
 346 {
 347   std::unique_ptr<CVideoSync> pVSync;
 348
 349   if (dynamic_cast<CGLContextEGL*>(m_pGLContext))
 350   {
 351     pVSync = std::make_unique<CVideoSyncOML>(clock, *this);
 352   }
 353   else
 354   {
 355     pVSync.reset(GLXVideoSyncCreate(clock, *this));
 356   }
 357
 358   return pVSync;
 359 }
 360
 361 float CWinSystemX11GLContext::GetFrameLatencyAdjustment()
 362 {
 363   if (m_pGLContext)
 364   {
 365     uint64_t msc, interval;
 366     float micros = m_pGLContext->GetVblankTiming(msc, interval);
 367     return micros / 1000;
 368   }
 369   return 0;
 370 }
 371
 372 uint64_t CWinSystemX11GLContext::GetVblankTiming(uint64_t &msc, uint64_t &interval)
 373 {
 374   if (m_pGLContext)
 375   {
 376     float micros = m_pGLContext->GetVblankTiming(msc, interval);
 377     return micros;
 378   }
 379   msc = 0;
 380   interval = 0;
 381   return 0;
 382 }
 383
 384 void CWinSystemX11GLContext::delete_CVaapiProxy::operator()(CVaapiProxy *p) const
 385 {
 386   VaapiProxyDelete(p);
 387 }