tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

GLXLibrary.h (10141B)

      1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
      2 * This Source Code Form is subject to the terms of the Mozilla Public
      3 * License, v. 2.0. If a copy of the MPL was not distributed with this
      4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      5 
      6 #ifndef GFX_GLXLIBRARY_H
      7 #define GFX_GLXLIBRARY_H
      8 
      9 #include "GLContext.h"
     10 #include "mozilla/Assertions.h"
     11 #include "mozilla/DataMutex.h"
     12 #include "mozilla/gfx/XlibDisplay.h"
     13 #include "prlink.h"
     14 typedef realGLboolean GLboolean;
     15 
     16 // stuff from glx.h
     17 #include "X11/Xlib.h"
     18 #include "X11/Xutil.h"  // for XVisualInfo
     19 #include "X11UndefineNone.h"
     20 typedef struct __GLXcontextRec* GLXContext;
     21 typedef XID GLXPixmap;
     22 typedef XID GLXDrawable;
     23 /* GLX 1.3 and later */
     24 typedef struct __GLXFBConfigRec* GLXFBConfig;
     25 // end of stuff from glx.h
     26 #include "prenv.h"
     27 
     28 struct PRLibrary;
     29 class gfxASurface;
     30 
     31 namespace mozilla {
     32 namespace gl {
     33 
     34 class GLContextGLX;
     35 
     36 class GLXLibrary final {
     37 public:
     38  bool EnsureInitialized(Display* aDisplay);
     39 
     40 private:
     41  class WrapperScope final {
     42    const GLXLibrary& mGlx;
     43    const char* const mFuncName;
     44    Display* const mDisplay;
     45 
     46   public:
     47    WrapperScope(const GLXLibrary& glx, const char* const funcName,
     48                 Display* aDisplay);
     49    ~WrapperScope();
     50  };
     51 
     52 public:
     53 #ifdef DEBUG
     54 #  define DECL_WRAPPER_SCOPE(display) \
     55    const WrapperScope wrapperScope(*this, __func__, display);
     56 #else
     57 #  define DECL_WRAPPER_SCOPE(display)
     58 #endif
     59 
     60  void fDestroyContext(Display* display, GLXContext context) const {
     61    DECL_WRAPPER_SCOPE(display)
     62    return mSymbols.fDestroyContext(display, context);
     63  }
     64 
     65  Bool fMakeCurrent(Display* display, GLXDrawable drawable,
     66                    GLXContext context) const {
     67    DECL_WRAPPER_SCOPE(display)
     68    GLContext::ResetTLSCurrentContext();
     69    return mSymbols.fMakeCurrent(display, drawable, context);
     70  }
     71 
     72  XVisualInfo* fGetConfig(Display* display, XVisualInfo* info, int attrib,
     73                          int* value) const {
     74    DECL_WRAPPER_SCOPE(display)
     75    return mSymbols.fGetConfig(display, info, attrib, value);
     76  }
     77 
     78  GLXContext fGetCurrentContext() const {
     79    DECL_WRAPPER_SCOPE(nullptr)
     80    return mSymbols.fGetCurrentContext();
     81  }
     82 
     83  GLXFBConfig* fChooseFBConfig(Display* display, int screen,
     84                               const int* attrib_list, int* nelements) const {
     85    DECL_WRAPPER_SCOPE(display)
     86    return mSymbols.fChooseFBConfig(display, screen, attrib_list, nelements);
     87  }
     88 
     89  XVisualInfo* fChooseVisual(Display* display, int screen,
     90                             int* attrib_list) const {
     91    DECL_WRAPPER_SCOPE(display)
     92    return mSymbols.fChooseVisual(display, screen, attrib_list);
     93  }
     94 
     95  GLXFBConfig* fGetFBConfigs(Display* display, int screen,
     96                             int* nelements) const {
     97    DECL_WRAPPER_SCOPE(display)
     98    return mSymbols.fGetFBConfigs(display, screen, nelements);
     99  }
    100 
    101  GLXContext fCreateNewContext(Display* display, GLXFBConfig config,
    102                               int render_type, GLXContext share_list,
    103                               Bool direct) const {
    104    DECL_WRAPPER_SCOPE(display)
    105    return mSymbols.fCreateNewContext(display, config, render_type, share_list,
    106                                      direct);
    107  }
    108 
    109  int fGetFBConfigAttrib(Display* display, GLXFBConfig config, int attribute,
    110                         int* value) const {
    111    DECL_WRAPPER_SCOPE(display)
    112    return mSymbols.fGetFBConfigAttrib(display, config, attribute, value);
    113  }
    114 
    115  void fSwapBuffers(Display* display, GLXDrawable drawable) const {
    116    DECL_WRAPPER_SCOPE(display)
    117    return mSymbols.fSwapBuffers(display, drawable);
    118  }
    119 
    120  const char* fQueryExtensionsString(Display* display, int screen) const {
    121    DECL_WRAPPER_SCOPE(display)
    122    return mSymbols.fQueryExtensionsString(display, screen);
    123  }
    124 
    125  const char* fGetClientString(Display* display, int screen) const {
    126    DECL_WRAPPER_SCOPE(display)
    127    return mSymbols.fGetClientString(display, screen);
    128  }
    129 
    130  const char* fQueryServerString(Display* display, int screen, int name) const {
    131    DECL_WRAPPER_SCOPE(display)
    132    return mSymbols.fQueryServerString(display, screen, name);
    133  }
    134 
    135  GLXPixmap fCreatePixmap(Display* display, GLXFBConfig config, Pixmap pixmap,
    136                          const int* attrib_list) const {
    137    DECL_WRAPPER_SCOPE(display)
    138    return mSymbols.fCreatePixmap(display, config, pixmap, attrib_list);
    139  }
    140 
    141  GLXPixmap fCreateGLXPixmapWithConfig(Display* display, GLXFBConfig config,
    142                                       Pixmap pixmap) const {
    143    DECL_WRAPPER_SCOPE(display)
    144    return mSymbols.fCreateGLXPixmapWithConfig(display, config, pixmap);
    145  }
    146 
    147  void fDestroyPixmap(Display* display, GLXPixmap pixmap) const {
    148    DECL_WRAPPER_SCOPE(display)
    149    return mSymbols.fDestroyPixmap(display, pixmap);
    150  }
    151 
    152  Bool fQueryVersion(Display* display, int* major, int* minor) const {
    153    DECL_WRAPPER_SCOPE(display)
    154    return mSymbols.fQueryVersion(display, major, minor);
    155  }
    156 
    157  void fBindTexImage(Display* display, GLXDrawable drawable, int buffer,
    158                     const int* attrib_list) const {
    159    DECL_WRAPPER_SCOPE(display)
    160    return mSymbols.fBindTexImageEXT(display, drawable, buffer, attrib_list);
    161  }
    162 
    163  void fReleaseTexImage(Display* display, GLXDrawable drawable,
    164                        int buffer) const {
    165    DECL_WRAPPER_SCOPE(display)
    166    return mSymbols.fReleaseTexImageEXT(display, drawable, buffer);
    167  }
    168 
    169  void fWaitGL() const {
    170    DECL_WRAPPER_SCOPE(nullptr)
    171    return mSymbols.fWaitGL();
    172  }
    173 
    174  void fWaitX() const {
    175    DECL_WRAPPER_SCOPE(nullptr)
    176    return mSymbols.fWaitX();
    177  }
    178 
    179  GLXContext fCreateContextAttribs(Display* display, GLXFBConfig config,
    180                                   GLXContext share_list, Bool direct,
    181                                   const int* attrib_list) const {
    182    DECL_WRAPPER_SCOPE(display)
    183    return mSymbols.fCreateContextAttribsARB(display, config, share_list,
    184                                             direct, attrib_list);
    185  }
    186 
    187  int fGetVideoSync(unsigned int* count) const {
    188    DECL_WRAPPER_SCOPE(nullptr)
    189    return mSymbols.fGetVideoSyncSGI(count);
    190  }
    191 
    192  int fWaitVideoSync(int divisor, int remainder, unsigned int* count) const {
    193    DECL_WRAPPER_SCOPE(nullptr)
    194    return mSymbols.fWaitVideoSyncSGI(divisor, remainder, count);
    195  }
    196 
    197  void fSwapInterval(Display* dpy, GLXDrawable drawable, int interval) const {
    198    DECL_WRAPPER_SCOPE(dpy)
    199    return mSymbols.fSwapIntervalEXT(dpy, drawable, interval);
    200  }
    201 
    202  int fQueryDrawable(Display* dpy, GLXDrawable drawable, int attribute,
    203                     unsigned int* value) const {
    204    DECL_WRAPPER_SCOPE(dpy)
    205    return mSymbols.fQueryDrawable(dpy, drawable, attribute, value);
    206  }
    207 #undef DECL_WRAPPER_SCOPE
    208 
    209  ////
    210 
    211  bool HasRobustness() { return mHasRobustness; }
    212  bool HasVideoMemoryPurge() { return mHasVideoMemoryPurge; }
    213  bool HasCreateContextAttribs() { return mHasCreateContextAttribs; }
    214  bool SupportsTextureFromPixmap(gfxASurface* aSurface);
    215  bool SupportsVideoSync(Display* aDisplay);
    216  bool SupportsSwapControl() const { return bool(mSymbols.fSwapIntervalEXT); }
    217  bool SupportsBufferAge() const {
    218    MOZ_ASSERT(mInitialized);
    219    return mHasBufferAge;
    220  }
    221  bool IsATI() { return mIsATI; }
    222  bool IsMesa() { return mClientIsMesa; }
    223 
    224  auto GetGetProcAddress() const { return mSymbols.fGetProcAddress; }
    225 
    226  std::shared_ptr<gfx::XlibDisplay> GetDisplay();
    227 
    228 private:
    229  struct {
    230    void(GLAPIENTRY* fDestroyContext)(Display*, GLXContext);
    231    Bool(GLAPIENTRY* fMakeCurrent)(Display*, GLXDrawable, GLXContext);
    232    XVisualInfo*(GLAPIENTRY* fGetConfig)(Display*, XVisualInfo*, int, int*);
    233    GLXContext(GLAPIENTRY* fGetCurrentContext)();
    234    void*(GLAPIENTRY* fGetProcAddress)(const char*);
    235    GLXFBConfig*(GLAPIENTRY* fChooseFBConfig)(Display*, int, const int*, int*);
    236    XVisualInfo*(GLAPIENTRY* fChooseVisual)(Display*, int, const int*);
    237    GLXFBConfig*(GLAPIENTRY* fGetFBConfigs)(Display*, int, int*);
    238    GLXContext(GLAPIENTRY* fCreateNewContext)(Display*, GLXFBConfig, int,
    239                                              GLXContext, Bool);
    240    int(GLAPIENTRY* fGetFBConfigAttrib)(Display*, GLXFBConfig, int, int*);
    241    void(GLAPIENTRY* fSwapBuffers)(Display*, GLXDrawable);
    242    const char*(GLAPIENTRY* fQueryExtensionsString)(Display*, int);
    243    const char*(GLAPIENTRY* fGetClientString)(Display*, int);
    244    const char*(GLAPIENTRY* fQueryServerString)(Display*, int, int);
    245    GLXPixmap(GLAPIENTRY* fCreatePixmap)(Display*, GLXFBConfig, Pixmap,
    246                                         const int*);
    247    GLXPixmap(GLAPIENTRY* fCreateGLXPixmapWithConfig)(Display*, GLXFBConfig,
    248                                                      Pixmap);
    249    void(GLAPIENTRY* fDestroyPixmap)(Display*, GLXPixmap);
    250    Bool(GLAPIENTRY* fQueryVersion)(Display*, int*, int*);
    251    void(GLAPIENTRY* fWaitGL)();
    252    void(GLAPIENTRY* fWaitX)();
    253    void(GLAPIENTRY* fBindTexImageEXT)(Display*, GLXDrawable, int, const int*);
    254    void(GLAPIENTRY* fReleaseTexImageEXT)(Display*, GLXDrawable, int);
    255    GLXContext(GLAPIENTRY* fCreateContextAttribsARB)(Display*, GLXFBConfig,
    256                                                     GLXContext, Bool,
    257                                                     const int*);
    258    int(GLAPIENTRY* fGetVideoSyncSGI)(unsigned int*);
    259    int(GLAPIENTRY* fWaitVideoSyncSGI)(int, int, unsigned int*);
    260    void(GLAPIENTRY* fSwapIntervalEXT)(Display*, GLXDrawable, int);
    261    int(GLAPIENTRY* fQueryDrawable)(Display*, GLXDrawable, int, unsigned int*);
    262  } mSymbols = {};
    263 
    264  bool mInitialized = false;
    265  bool mTriedInitializing = false;
    266  bool mDebug = false;
    267  bool mHasRobustness = false;
    268  bool mHasVideoMemoryPurge = false;
    269  bool mHasCreateContextAttribs = false;
    270  bool mHasVideoSync = false;
    271  bool mHasBufferAge = false;
    272  bool mIsATI = false;
    273  bool mIsNVIDIA = false;
    274  bool mClientIsMesa = false;
    275  PRLibrary* mOGLLibrary = nullptr;
    276  StaticDataMutex<std::weak_ptr<gfx::XlibDisplay>> mOwnDisplay{
    277      "GLXLibrary::mOwnDisplay"};
    278 };
    279 
    280 // a global GLXLibrary instance
    281 extern GLXLibrary sGLXLibrary;
    282 
    283 } /* namespace gl */
    284 } /* namespace mozilla */
    285 #endif /* GFX_GLXLIBRARY_H */