vcl/opengl/x11/gdiimpl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <memory>
  11 #include <vcl/lazydelete.hxx>
  12
  13 #include <svdata.hxx>
  14
  15 #include <unx/saldisp.hxx>
  16 #include <unx/salframe.h>
  17 #include <unx/salgdi.h>
  18 #include <unx/salinst.h>
  19 #include <unx/salvd.h>
  20 #include <unx/x11/xlimits.hxx>
  21
  22 #include <opengl/texture.hxx>
  23 #include <opengl/zone.hxx>
  24 #include <opengl/RenderState.hxx>
  25 #include <opengl/x11/gdiimpl.hxx>
  26 #include <opengl/x11/salvd.hxx>
  27
  28 #include <vcl/opengl/OpenGLContext.hxx>
  29 #include <vcl/opengl/OpenGLHelper.hxx>
  30 #include <sal/log.hxx>
  31
  32 #include <o3tl/lru_map.hxx>
  33 #include <ControlCacheKey.hxx>
  34
  35 static std::vector<GLXContext> g_vShareList;
  36 static bool g_bAnyCurrent;
  37
  38 class X11OpenGLContext : public OpenGLContext
  39 {
  40 public:
  41     void init(Display* dpy, Window win, int screen);
  42     virtual void initWindow() override;
  43 private:
  44     GLX11Window m_aGLWin;
  45     virtual const GLWindow& getOpenGLWindow() const override { return m_aGLWin; }
  46     virtual GLWindow& getModifiableOpenGLWindow() override { return m_aGLWin; }
  47     virtual bool ImplInit() override;
  48     void initGLWindow(Visual* pVisual);
  49     virtual SystemWindowData generateWinData(vcl::Window* pParent, bool bRequestLegacyContext) override;
  50     virtual void makeCurrent() override;
  51     virtual void destroyCurrentContext() override;
  52     virtual bool isCurrent() override;
  53     virtual bool isAnyCurrent() override;
  54     virtual void sync() override;
  55     virtual void resetCurrent() override;
  56     virtual void swapBuffers() override;
  57 };
  58
  59 namespace
  60 {
  61
  62 #ifdef DBG_UTIL
  63     int unxErrorHandler(Display* dpy, XErrorEvent* event)
  64     {
  65         char err[256];
  66         char req[256];
  67         char minor[256];
  68         XGetErrorText(dpy, event->error_code, err, 256);
  69         XGetErrorText(dpy, event->request_code, req, 256);
  70         XGetErrorText(dpy, event->minor_code, minor, 256);
  71         SAL_WARN("vcl.opengl", "Error: " << err << ", Req: " << req << ", Minor: " << minor);
  72         return 0;
  73     }
  74 #endif
  75
  76     typedef int (*errorHandler)(Display* /*dpy*/, XErrorEvent* /*evnt*/);
  77
  78     class TempErrorHandler
  79     {
  80     private:
  81         errorHandler oldErrorHandler;
  82         Display* const mdpy;
  83
  84     public:
  85         TempErrorHandler(Display* dpy, errorHandler newErrorHandler)
  86             : oldErrorHandler(nullptr)
  87             , mdpy(dpy)
  88         {
  89             if (mdpy)
  90             {
  91                 XLockDisplay(dpy);
  92                 XSync(dpy, false);
  93                 oldErrorHandler = XSetErrorHandler(newErrorHandler);
  94             }
  95         }
  96
  97         ~TempErrorHandler()
  98         {
  99             if (mdpy)
 100             {
 101                 // sync so that we possibly get an XError
 102                 glXWaitGL();
 103                 XSync(mdpy, false);
 104                 XSetErrorHandler(oldErrorHandler);
 105                 XUnlockDisplay(mdpy);
 106             }
 107         }
 108     };
 109
 110     static bool errorTriggered;
 111     int oglErrorHandler( Display* /*dpy*/, XErrorEvent* /*evnt*/ )
 112     {
 113         errorTriggered = true;
 114
 115         return 0;
 116     }
 117
 118     GLXFBConfig* getFBConfig(Display* dpy, Window win, int& nBestFBC)
 119     {
 120         OpenGLZone aZone;
 121
 122         if( dpy == nullptr || !glXQueryExtension( dpy, nullptr, nullptr ) )
 123             return nullptr;
 124
 125         VCL_GL_INFO("window: " << win);
 126
 127         XWindowAttributes xattr;
 128         if( !XGetWindowAttributes( dpy, win, &xattr ) )
 129         {
 130             SAL_WARN("vcl.opengl", "Failed to get window attributes for fbconfig " << win);
 131             xattr.screen = nullptr;
 132             xattr.visual = nullptr;
 133         }
 134
 135         int screen = XScreenNumberOfScreen( xattr.screen );
 136
 137         // TODO: moggi: Select colour channel depth based on visual attributes, not hardcoded */
 138         static int visual_attribs[] =
 139         {
 140             GLX_DOUBLEBUFFER,       True,
 141             GLX_X_RENDERABLE,       True,
 142             GLX_RED_SIZE,           8,
 143             GLX_GREEN_SIZE,         8,
 144             GLX_BLUE_SIZE,          8,
 145             GLX_ALPHA_SIZE,         8,
 146             GLX_DEPTH_SIZE,         24,
 147             GLX_X_VISUAL_TYPE,      GLX_TRUE_COLOR,
 148             None
 149         };
 150
 151         int fbCount = 0;
 152         GLXFBConfig* pFBC = glXChooseFBConfig( dpy,
 153                 screen,
 154                 visual_attribs, &fbCount );
 155
 156         if(!pFBC)
 157         {
 158             SAL_WARN("vcl.opengl", "no suitable fb format found");
 159             return nullptr;
 160         }
 161
 162         int best_num_samp = -1;
 163         for(int i = 0; i < fbCount; ++i)
 164         {
 165             XVisualInfo* pVi = glXGetVisualFromFBConfig( dpy, pFBC[i] );
 166             if(pVi && (xattr.visual && pVi->visualid == xattr.visual->visualid) )
 167             {
 168                 // pick the one with the most samples per pixel
 169                 int nSampleBuf = 0;
 170                 int nSamples = 0;
 171                 glXGetFBConfigAttrib( dpy, pFBC[i], GLX_SAMPLE_BUFFERS, &nSampleBuf );
 172                 glXGetFBConfigAttrib( dpy, pFBC[i], GLX_SAMPLES       , &nSamples  );
 173
 174                 if ( nBestFBC < 0 || (nSampleBuf && ( nSamples > best_num_samp )) )
 175                 {
 176                     nBestFBC = i;
 177                     best_num_samp = nSamples;
 178                 }
 179             }
 180             XFree( pVi );
 181         }
 182
 183         return pFBC;
 184     }
 185
 186     Visual* getVisual(Display* dpy, Window win)
 187     {
 188         OpenGLZone aZone;
 189
 190         XWindowAttributes xattr;
 191         if( !XGetWindowAttributes( dpy, win, &xattr ) )
 192         {
 193             SAL_WARN("vcl.opengl", "Failed to get window attributes for getVisual " << win);
 194             xattr.visual = nullptr;
 195         }
 196         VCL_GL_INFO("using VisualID " << xattr.visual);
 197         return xattr.visual;
 198     }
 199 }
 200
 201 void X11OpenGLContext::sync()
 202 {
 203     OpenGLZone aZone;
 204     glXWaitGL();
 205     XSync(m_aGLWin.dpy, false);
 206 }
 207
 208 void X11OpenGLContext::swapBuffers()
 209 {
 210     OpenGLZone aZone;
 211
 212     glXSwapBuffers(m_aGLWin.dpy, m_aGLWin.win);
 213
 214     BuffersSwapped();
 215 }
 216
 217 void X11OpenGLContext::resetCurrent()
 218 {
 219     clearCurrent();
 220
 221     OpenGLZone aZone;
 222
 223     if (m_aGLWin.dpy)
 224     {
 225         glXMakeCurrent(m_aGLWin.dpy, None, nullptr);
 226         g_bAnyCurrent = false;
 227     }
 228 }
 229
 230 bool X11OpenGLContext::isCurrent()
 231 {
 232     OpenGLZone aZone;
 233     return g_bAnyCurrent && m_aGLWin.ctx && glXGetCurrentContext() == m_aGLWin.ctx &&
 234            glXGetCurrentDrawable() == m_aGLWin.win;
 235 }
 236
 237 bool X11OpenGLContext::isAnyCurrent()
 238 {
 239     return g_bAnyCurrent && glXGetCurrentContext() != None;
 240 }
 241
 242 SystemWindowData X11OpenGLContext::generateWinData(vcl::Window* pParent, bool /*bRequestLegacyContext*/)
 243 {
 244     OpenGLZone aZone;
 245
 246     SystemWindowData aWinData;
 247     aWinData.pVisual = nullptr;
 248
 249     const SystemEnvData* sysData(pParent->GetSystemData());
 250
 251     Display *dpy = static_cast<Display*>(sysData->pDisplay);
 252     Window win = sysData->aWindow;
 253
 254     if( dpy == nullptr || !glXQueryExtension( dpy, nullptr, nullptr ) )
 255         return aWinData;
 256
 257     int best_fbc = -1;
 258     GLXFBConfig* pFBC = getFBConfig(dpy, win, best_fbc);
 259
 260     if (!pFBC)
 261         return aWinData;
 262
 263     XVisualInfo* vi = nullptr;
 264     if( best_fbc != -1 )
 265         vi = glXGetVisualFromFBConfig( dpy, pFBC[best_fbc] );
 266
 267     XFree(pFBC);
 268
 269     if( vi )
 270     {
 271         VCL_GL_INFO("using VisualID " << vi->visualid);
 272         aWinData.pVisual = static_cast<void*>(vi->visual);
 273     }
 274
 275     return aWinData;
 276 }
 277
 278 bool X11OpenGLContext::ImplInit()
 279 {
 280     if (!m_aGLWin.dpy)
 281         return false;
 282
 283     OpenGLZone aZone;
 284
 285     GLXContext pSharedCtx( nullptr );
 286 #ifdef DBG_UTIL
 287     TempErrorHandler aErrorHandler(m_aGLWin.dpy, unxErrorHandler);
 288 #endif
 289
 290     VCL_GL_INFO("OpenGLContext::ImplInit----start");
 291
 292     if (!g_vShareList.empty())
 293         pSharedCtx = g_vShareList.front();
 294
 295     //tdf#112166 for, e.g. VirtualBox GL, claiming OpenGL 2.1
 296     static bool hasCreateContextAttribsARB = glXGetProcAddress(reinterpret_cast<const GLubyte*>("glXCreateContextAttribsARB")) != nullptr;
 297     if (hasCreateContextAttribsARB && !mbRequestLegacyContext)
 298     {
 299         int best_fbc = -1;
 300         GLXFBConfig* pFBC = getFBConfig(m_aGLWin.dpy, m_aGLWin.win, best_fbc);
 301
 302         if (pFBC && best_fbc != -1)
 303         {
 304             int const pContextAttribs[] =
 305             {
 306 #if 0 // defined(DBG_UTIL)
 307                 GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
 308                 GLX_CONTEXT_MINOR_VERSION_ARB, 2,
 309 #endif
 310                 None
 311
 312             };
 313             m_aGLWin.ctx = glXCreateContextAttribsARB(m_aGLWin.dpy, pFBC[best_fbc], pSharedCtx, /* direct, not via X */ GL_TRUE, pContextAttribs);
 314             SAL_INFO_IF(m_aGLWin.ctx, "vcl.opengl", "created a 3.2 core context");
 315         }
 316         else
 317             SAL_WARN("vcl.opengl", "unable to find correct FBC");
 318     }
 319
 320     if (!m_aGLWin.ctx)
 321     {
 322         if (!m_aGLWin.vi)
 323            return false;
 324
 325         SAL_WARN("vcl.opengl", "attempting to create a non-double-buffered "
 326                                "visual matching the context");
 327
 328         m_aGLWin.ctx = glXCreateContext(m_aGLWin.dpy,
 329                 m_aGLWin.vi,
 330                 pSharedCtx,
 331                 GL_TRUE /* direct, not via X server */);
 332     }
 333
 334     if( m_aGLWin.ctx )
 335     {
 336         g_vShareList.push_back( m_aGLWin.ctx );
 337     }
 338     else
 339     {
 340         SAL_WARN("vcl.opengl", "unable to create GLX context");
 341         return false;
 342     }
 343
 344     if( !glXMakeCurrent( m_aGLWin.dpy, m_aGLWin.win, m_aGLWin.ctx ) )
 345     {
 346         g_bAnyCurrent = false;
 347         SAL_WARN("vcl.opengl", "unable to select current GLX context");
 348         return false;
 349     }
 350
 351     g_bAnyCurrent = true;
 352
 353     int glxMinor, glxMajor;
 354     double nGLXVersion = 0;
 355     if( glXQueryVersion( m_aGLWin.dpy, &glxMajor, &glxMinor ) )
 356       nGLXVersion = glxMajor + 0.1*glxMinor;
 357     SAL_INFO("vcl.opengl", "available GLX version: " << nGLXVersion);
 358
 359     SAL_INFO("vcl.opengl", "available GL  extensions: " << glGetString(GL_EXTENSIONS));
 360
 361     XWindowAttributes aWinAttr;
 362     if( !XGetWindowAttributes( m_aGLWin.dpy, m_aGLWin.win, &aWinAttr ) )
 363     {
 364         SAL_WARN("vcl.opengl", "Failed to get window attributes on " << m_aGLWin.win);
 365         m_aGLWin.Width = 0;
 366         m_aGLWin.Height = 0;
 367     }
 368     else
 369     {
 370         m_aGLWin.Width = aWinAttr.width;
 371         m_aGLWin.Height = aWinAttr.height;
 372     }
 373
 374     if( m_aGLWin.HasGLXExtension("GLX_SGI_swap_control" ) )
 375     {
 376         // enable vsync
 377         typedef GLint (*glXSwapIntervalProc)(GLint);
 378         glXSwapIntervalProc glXSwapInterval = reinterpret_cast<glXSwapIntervalProc>(glXGetProcAddress( reinterpret_cast<const GLubyte*>("glXSwapIntervalSGI") ));
 379         if( glXSwapInterval )
 380         {
 381             TempErrorHandler aLocalErrorHandler(m_aGLWin.dpy, oglErrorHandler);
 382
 383             errorTriggered = false;
 384
 385             glXSwapInterval( 1 );
 386
 387             if( errorTriggered )
 388                 SAL_WARN("vcl.opengl", "error when trying to set swap interval, NVIDIA or Mesa bug?");
 389             else
 390                 VCL_GL_INFO("set swap interval to 1 (enable vsync)");
 391         }
 392     }
 393
 394     bool bRet = InitGL();
 395     InitGLDebugging();
 396
 397     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 398
 399     registerAsCurrent();
 400
 401     return bRet;
 402 }
 403
 404 void X11OpenGLContext::makeCurrent()
 405 {
 406     if (isCurrent())
 407         return;
 408
 409     OpenGLZone aZone;
 410
 411     clearCurrent();
 412
 413 #ifdef DBG_UTIL
 414     TempErrorHandler aErrorHandler(m_aGLWin.dpy, unxErrorHandler);
 415 #endif
 416
 417     if (m_aGLWin.dpy)
 418     {
 419         if (!glXMakeCurrent( m_aGLWin.dpy, m_aGLWin.win, m_aGLWin.ctx ))
 420         {
 421             g_bAnyCurrent = false;
 422             SAL_WARN("vcl.opengl", "OpenGLContext::makeCurrent failed "
 423                      "on drawable " << m_aGLWin.win);
 424             return;
 425         }
 426         g_bAnyCurrent = true;
 427     }
 428
 429     registerAsCurrent();
 430 }
 431
 432 void X11OpenGLContext::destroyCurrentContext()
 433 {
 434     if(m_aGLWin.ctx)
 435     {
 436         std::vector<GLXContext>::iterator itr = std::remove( g_vShareList.begin(), g_vShareList.end(), m_aGLWin.ctx );
 437         if (itr != g_vShareList.end())
 438             g_vShareList.erase(itr);
 439
 440         glXMakeCurrent(m_aGLWin.dpy, None, nullptr);
 441         g_bAnyCurrent = false;
 442         if( glGetError() != GL_NO_ERROR )
 443         {
 444             SAL_WARN("vcl.opengl", "glError: " << glGetError());
 445         }
 446         glXDestroyContext(m_aGLWin.dpy, m_aGLWin.ctx);
 447         m_aGLWin.ctx = nullptr;
 448     }
 449 }
 450
 451 void X11OpenGLContext::init(Display* dpy, Window win, int screen)
 452 {
 453     if (isInitialized())
 454         return;
 455
 456     if (!dpy)
 457         return;
 458
 459     OpenGLZone aZone;
 460
 461     m_aGLWin.dpy = dpy;
 462     m_aGLWin.win = win;
 463     m_aGLWin.screen = screen;
 464
 465     Visual* pVisual = getVisual(dpy, win);
 466
 467     initGLWindow(pVisual);
 468
 469     ImplInit();
 470 }
 471
 472 void X11OpenGLContext::initGLWindow(Visual* pVisual)
 473 {
 474     OpenGLZone aZone;
 475
 476     // Get visual info
 477     {
 478         XVisualInfo aTemplate;
 479         aTemplate.visualid = XVisualIDFromVisual( pVisual );
 480         int nVisuals = 0;
 481         XVisualInfo* pInfo = XGetVisualInfo( m_aGLWin.dpy, VisualIDMask, &aTemplate, &nVisuals );
 482         if( nVisuals != 1 )
 483             SAL_WARN( "vcl.opengl", "match count for visual id is not 1" );
 484         m_aGLWin.vi = pInfo;
 485     }
 486
 487     // Check multisample support
 488     /* TODO: moggi: This is not necessarily correct in the DBG_UTIL path, as it picks
 489      *      an FBConfig instead ... */
 490     int nSamples = 0;
 491     glXGetConfig(m_aGLWin.dpy, m_aGLWin.vi, GLX_SAMPLES, &nSamples);
 492     if( nSamples > 0 )
 493         m_aGLWin.bMultiSampleSupported = true;
 494
 495     m_aGLWin.GLXExtensions = glXQueryExtensionsString( m_aGLWin.dpy, m_aGLWin.screen );
 496     SAL_INFO("vcl.opengl", "available GLX extensions: " << m_aGLWin.GLXExtensions);
 497 }
 498
 499 void X11OpenGLContext::initWindow()
 500 {
 501     const SystemEnvData* pChildSysData = nullptr;
 502     SystemWindowData winData = generateWinData(mpWindow, false);
 503     if( winData.pVisual )
 504     {
 505         if( !m_pChildWindow )
 506         {
 507             m_pChildWindow = VclPtr<SystemChildWindow>::Create(mpWindow, 0, &winData, false);
 508         }
 509         pChildSysData = m_pChildWindow->GetSystemData();
 510     }
 511
 512     if (!m_pChildWindow || !pChildSysData)
 513         return;
 514
 515     InitChildWindow(m_pChildWindow.get());
 516
 517     m_aGLWin.dpy = static_cast<Display*>(pChildSysData->pDisplay);
 518     m_aGLWin.win = pChildSysData->aWindow;
 519     m_aGLWin.screen = pChildSysData->nScreen;
 520
 521     Visual* pVisual = static_cast<Visual*>(pChildSysData->pVisual);
 522     initGLWindow(pVisual);
 523 }
 524
 525 GLX11Window::GLX11Window()
 526     : dpy(nullptr)
 527     , screen(0)
 528     , win(0)
 529     , vi(nullptr)
 530     , ctx(nullptr)
 531 {
 532 }
 533
 534 bool GLX11Window::HasGLXExtension( const char* name ) const
 535 {
 536     for (sal_Int32 i = 0; i != -1;) {
 537         if (GLXExtensions.getToken(0, ' ', i) == name) {
 538             return true;
 539         }
 540     }
 541     return false;
 542 }
 543
 544 GLX11Window::~GLX11Window()
 545 {
 546     XFree(vi);
 547 }
 548
 549 bool GLX11Window::Synchronize(bool bOnoff) const
 550 {
 551     XSynchronize(dpy, bOnoff);
 552     return true;
 553 }
 554
 555 OpenGLContext* X11SalInstance::CreateOpenGLContext()
 556 {
 557     return new X11OpenGLContext;
 558 }
 559
 560 X11OpenGLSalGraphicsImpl::X11OpenGLSalGraphicsImpl( X11SalGraphics& rParent ):
 561     OpenGLSalGraphicsImpl(rParent,rParent.GetGeometryProvider()),
 562     mrX11Parent(rParent)
 563 {
 564 }
 565
 566 X11OpenGLSalGraphicsImpl::~X11OpenGLSalGraphicsImpl()
 567 {
 568 }
 569
 570 void X11OpenGLSalGraphicsImpl::Init()
 571 {
 572     // The m_pFrame and m_pVDev pointers are updated late in X11
 573     mpProvider = mrX11Parent.GetGeometryProvider();
 574     OpenGLSalGraphicsImpl::Init();
 575 }
 576
 577 rtl::Reference<OpenGLContext> X11OpenGLSalGraphicsImpl::CreateWinContext()
 578 {
 579     NativeWindowHandleProvider *pProvider = dynamic_cast<NativeWindowHandleProvider*>(mrX11Parent.m_pFrame);
 580
 581     if( !pProvider )
 582         return nullptr;
 583
 584     sal_uIntPtr aWin = pProvider->GetNativeWindowHandle();
 585     rtl::Reference<X11OpenGLContext> xContext = new X11OpenGLContext;
 586     xContext->setVCLOnly();
 587     xContext->init( mrX11Parent.GetXDisplay(), aWin,
 588                     mrX11Parent.m_nXScreen.getXScreen() );
 589     return rtl::Reference<OpenGLContext>(xContext.get());
 590 }
 591
 592 void X11OpenGLSalGraphicsImpl::copyBits( const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics )
 593 {
 594     OpenGLSalGraphicsImpl *pImpl = pSrcGraphics ? static_cast< OpenGLSalGraphicsImpl* >(pSrcGraphics->GetImpl()) : static_cast< OpenGLSalGraphicsImpl *>(mrX11Parent.GetImpl());
 595     OpenGLSalGraphicsImpl::DoCopyBits( rPosAry, *pImpl );
 596 }
 597
 598 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */