src/glx/g_glxglvnddispatchfuncs.c

   1 /*
   2  * THIS FILE IS AUTOMATICALLY GENERATED BY gen_scrn_dispatch.pl
   3  * DO NOT EDIT!!
   4  */
   5 #include <stdlib.h>
   6
   7 #include "glxglvnd.h"
   8 #include "glxglvnddispatchfuncs.h"
   9 #include "g_glxglvnddispatchindices.h"
  10
  11 const int DI_FUNCTION_COUNT = DI_LAST_INDEX;
  12 /* Allocate an extra 'dummy' to ease lookup. See FindGLXFunction() */
  13 int __glXDispatchTableIndices[DI_LAST_INDEX + 1];
  14 const __GLXapiExports *__glXGLVNDAPIExports;
  15
  16 const char * const __glXDispatchTableStrings[DI_LAST_INDEX] = {
  17 #define __ATTRIB(field) \
  18     [DI_##field] = "glX"#field
  19
  20     __ATTRIB(BindSwapBarrierSGIX),
  21     __ATTRIB(BindTexImageEXT),
  22     // glXChooseFBConfig implemented by libglvnd
  23     __ATTRIB(ChooseFBConfigSGIX),
  24     // glXChooseVisual implemented by libglvnd
  25     // glXCopyContext implemented by libglvnd
  26     __ATTRIB(CopySubBufferMESA),
  27     // glXCreateContext implemented by libglvnd
  28     __ATTRIB(CreateContextAttribsARB),
  29     __ATTRIB(CreateContextWithConfigSGIX),
  30     __ATTRIB(CreateGLXPbufferSGIX),
  31     // glXCreateGLXPixmap implemented by libglvnd
  32     __ATTRIB(CreateGLXPixmapMESA),
  33     __ATTRIB(CreateGLXPixmapWithConfigSGIX),
  34     // glXCreateNewContext implemented by libglvnd
  35     // glXCreatePbuffer implemented by libglvnd
  36     // glXCreatePixmap implemented by libglvnd
  37     // glXCreateWindow implemented by libglvnd
  38     // glXDestroyContext implemented by libglvnd
  39     __ATTRIB(DestroyGLXPbufferSGIX),
  40     // glXDestroyGLXPixmap implemented by libglvnd
  41     // glXDestroyPbuffer implemented by libglvnd
  42     // glXDestroyPixmap implemented by libglvnd
  43     // glXDestroyWindow implemented by libglvnd
  44     // glXFreeContextEXT implemented by libglvnd
  45     // glXGetClientString implemented by libglvnd
  46     // glXGetConfig implemented by libglvnd
  47     __ATTRIB(GetContextIDEXT),
  48     // glXGetCurrentContext implemented by libglvnd
  49     // glXGetCurrentDisplay implemented by libglvnd
  50     __ATTRIB(GetCurrentDisplayEXT),
  51     // glXGetCurrentDrawable implemented by libglvnd
  52     // glXGetCurrentReadDrawable implemented by libglvnd
  53     // glXGetFBConfigAttrib implemented by libglvnd
  54     __ATTRIB(GetFBConfigAttribSGIX),
  55     __ATTRIB(GetFBConfigFromVisualSGIX),
  56     // glXGetFBConfigs implemented by libglvnd
  57     __ATTRIB(GetMscRateOML),
  58     // glXGetProcAddress implemented by libglvnd
  59     // glXGetProcAddressARB implemented by libglvnd
  60     __ATTRIB(GetScreenDriver),
  61     // glXGetSelectedEvent implemented by libglvnd
  62     __ATTRIB(GetSelectedEventSGIX),
  63     __ATTRIB(GetSwapIntervalMESA),
  64     __ATTRIB(GetSyncValuesOML),
  65     __ATTRIB(GetVideoSyncSGI),
  66     // glXGetVisualFromFBConfig implemented by libglvnd
  67     __ATTRIB(GetVisualFromFBConfigSGIX),
  68     // glXImportContextEXT implemented by libglvnd
  69     // glXIsDirect implemented by libglvnd
  70     __ATTRIB(JoinSwapGroupSGIX),
  71     // glXMakeContextCurrent implemented by libglvnd
  72     // glXMakeCurrent implemented by libglvnd
  73     // glXQueryContext implemented by libglvnd
  74     __ATTRIB(QueryContextInfoEXT),
  75     __ATTRIB(QueryCurrentRendererIntegerMESA),
  76     __ATTRIB(QueryCurrentRendererStringMESA),
  77     // glXQueryDrawable implemented by libglvnd
  78     // glXQueryExtension implemented by libglvnd
  79     // glXQueryExtensionsString implemented by libglvnd
  80     __ATTRIB(QueryGLXPbufferSGIX),
  81     __ATTRIB(QueryMaxSwapBarriersSGIX),
  82     __ATTRIB(QueryRendererIntegerMESA),
  83     __ATTRIB(QueryRendererStringMESA),
  84     // glXQueryServerString implemented by libglvnd
  85     // glXQueryVersion implemented by libglvnd
  86     __ATTRIB(ReleaseBuffersMESA),
  87     __ATTRIB(ReleaseTexImageEXT),
  88     // glXSelectEvent implemented by libglvnd
  89     __ATTRIB(SelectEventSGIX),
  90     // glXSwapBuffers implemented by libglvnd
  91     __ATTRIB(SwapBuffersMscOML),
  92     __ATTRIB(SwapIntervalMESA),
  93     __ATTRIB(SwapIntervalSGI),
  94     // glXUseXFont implemented by libglvnd
  95     __ATTRIB(WaitForMscOML),
  96     __ATTRIB(WaitForSbcOML),
  97     // glXWaitGL implemented by libglvnd
  98     __ATTRIB(WaitVideoSyncSGI),
  99     // glXWaitX implemented by libglvnd
 100
 101 #undef __ATTRIB
 102 };
 103
 104 #define __FETCH_FUNCTION_PTR(func_name) \
 105     p##func_name = (void *) \
 106         __VND->fetchDispatchEntry(dd, __glXDispatchTableIndices[DI_##func_name])
 107
 108
 109 static void dispatch_BindTexImageEXT(Display *dpy, GLXDrawable drawable,
 110                                      int buffer, const int *attrib_list)
 111 {
 112     PFNGLXBINDTEXIMAGEEXTPROC pBindTexImageEXT;
 113     __GLXvendorInfo *dd;
 114
 115     dd = GetDispatchFromDrawable(dpy, drawable);
 116     if (dd == NULL)
 117         return;
 118
 119     __FETCH_FUNCTION_PTR(BindTexImageEXT);
 120     if (pBindTexImageEXT == NULL)
 121         return;
 122
 123     (*pBindTexImageEXT)(dpy, drawable, buffer, attrib_list);
 124 }
 125
 126
 127
 128 static GLXFBConfigSGIX *dispatch_ChooseFBConfigSGIX(Display *dpy, int screen,
 129                                                     const int *attrib_list,
 130                                                     int *nelements)
 131 {
 132     PFNGLXCHOOSEFBCONFIGSGIXPROC pChooseFBConfigSGIX;
 133     __GLXvendorInfo *dd;
 134     GLXFBConfigSGIX *ret;
 135
 136     dd = __VND->getDynDispatch(dpy, screen);
 137     if (dd == NULL)
 138         return NULL;
 139
 140     __FETCH_FUNCTION_PTR(ChooseFBConfigSGIX);
 141     if (pChooseFBConfigSGIX == NULL)
 142         return NULL;
 143
 144     ret = (*pChooseFBConfigSGIX)(dpy, screen, attrib_list, nelements);
 145     if (AddFBConfigsMapping(dpy, ret, nelements, dd)) {
 146         free(ret);
 147         return NULL;
 148     }
 149
 150     return ret;
 151 }
 152
 153
 154
 155 static GLXContext dispatch_CreateContextAttribsARB(Display *dpy,
 156                                                    GLXFBConfig config,
 157                                                    GLXContext share_list,
 158                                                    Bool direct,
 159                                                    const int *attrib_list)
 160 {
 161     PFNGLXCREATECONTEXTATTRIBSARBPROC pCreateContextAttribsARB;
 162     __GLXvendorInfo *dd;
 163     GLXContext ret;
 164
 165     dd = GetDispatchFromFBConfig(dpy, config);
 166     if (dd == NULL)
 167         return None;
 168
 169     __FETCH_FUNCTION_PTR(CreateContextAttribsARB);
 170     if (pCreateContextAttribsARB == NULL)
 171         return None;
 172
 173     ret = (*pCreateContextAttribsARB)(dpy, config, share_list, direct, attrib_list);
 174     if (AddContextMapping(dpy, ret, dd)) {
 175         /* XXX: Call glXDestroyContext which lives in libglvnd. If we're not
 176          * allowed to call it from here, should we extend __glXDispatchTableIndices ?
 177          */
 178         return None;
 179     }
 180
 181     return ret;
 182 }
 183
 184
 185
 186 static GLXContext dispatch_CreateContextWithConfigSGIX(Display *dpy,
 187                                                        GLXFBConfigSGIX config,
 188                                                        int render_type,
 189                                                        GLXContext share_list,
 190                                                        Bool direct)
 191 {
 192     PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC pCreateContextWithConfigSGIX;
 193     __GLXvendorInfo *dd;
 194     GLXContext ret;
 195
 196     dd = GetDispatchFromFBConfig(dpy, config);
 197     if (dd == NULL)
 198         return None;
 199
 200     __FETCH_FUNCTION_PTR(CreateContextWithConfigSGIX);
 201     if (pCreateContextWithConfigSGIX == NULL)
 202         return None;
 203
 204     ret = (*pCreateContextWithConfigSGIX)(dpy, config, render_type, share_list, direct);
 205     if (AddContextMapping(dpy, ret, dd)) {
 206         /* XXX: Call glXDestroyContext which lives in libglvnd. If we're not
 207          * allowed to call it from here, should we extend __glXDispatchTableIndices ?
 208          */
 209         return None;
 210     }
 211
 212     return ret;
 213 }
 214
 215
 216
 217 static GLXPbuffer dispatch_CreateGLXPbufferSGIX(Display *dpy,
 218                                                 GLXFBConfig config,
 219                                                 unsigned int width,
 220                                                 unsigned int height,
 221                                                 const int *attrib_list)
 222 {
 223     PFNGLXCREATEGLXPBUFFERSGIXPROC pCreateGLXPbufferSGIX;
 224     __GLXvendorInfo *dd;
 225     GLXPbuffer ret;
 226
 227     dd = GetDispatchFromFBConfig(dpy, config);
 228     if (dd == NULL)
 229         return None;
 230
 231     __FETCH_FUNCTION_PTR(CreateGLXPbufferSGIX);
 232     if (pCreateGLXPbufferSGIX == NULL)
 233         return None;
 234
 235     ret = (*pCreateGLXPbufferSGIX)(dpy, config, width, height, attrib_list);
 236     if (AddDrawableMapping(dpy, ret, dd)) {
 237         PFNGLXDESTROYGLXPBUFFERSGIXPROC pDestroyGLXPbufferSGIX;
 238
 239         __FETCH_FUNCTION_PTR(DestroyGLXPbufferSGIX);
 240         if (pDestroyGLXPbufferSGIX)
 241             (*pDestroyGLXPbufferSGIX)(dpy, ret);
 242
 243         return None;
 244     }
 245
 246     return ret;
 247 }
 248
 249
 250
 251 static GLXPixmap dispatch_CreateGLXPixmapWithConfigSGIX(Display *dpy,
 252                                                         GLXFBConfigSGIX config,
 253                                                         Pixmap pixmap)
 254 {
 255     PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC pCreateGLXPixmapWithConfigSGIX;
 256     __GLXvendorInfo *dd;
 257     GLXPixmap ret;
 258
 259     dd = GetDispatchFromFBConfig(dpy, config);
 260     if (dd == NULL)
 261         return None;
 262
 263     __FETCH_FUNCTION_PTR(CreateGLXPixmapWithConfigSGIX);
 264     if (pCreateGLXPixmapWithConfigSGIX == NULL)
 265         return None;
 266
 267     ret = (*pCreateGLXPixmapWithConfigSGIX)(dpy, config, pixmap);
 268     if (AddDrawableMapping(dpy, ret, dd)) {
 269         /* XXX: Call glXDestroyGLXPixmap which lives in libglvnd. If we're not
 270          * allowed to call it from here, should we extend __glXDispatchTableIndices ?
 271          */
 272         return None;
 273     }
 274
 275     return ret;
 276 }
 277
 278
 279
 280 static void dispatch_DestroyGLXPbufferSGIX(Display *dpy, GLXPbuffer pbuf)
 281 {
 282     PFNGLXDESTROYGLXPBUFFERSGIXPROC pDestroyGLXPbufferSGIX;
 283     __GLXvendorInfo *dd;
 284
 285     dd = GetDispatchFromDrawable(dpy, pbuf);
 286     if (dd == NULL)
 287         return;
 288
 289     __FETCH_FUNCTION_PTR(DestroyGLXPbufferSGIX);
 290     if (pDestroyGLXPbufferSGIX == NULL)
 291         return;
 292
 293     (*pDestroyGLXPbufferSGIX)(dpy, pbuf);
 294 }
 295
 296
 297
 298 static GLXContextID dispatch_GetContextIDEXT(const GLXContext ctx)
 299 {
 300     PFNGLXGETCONTEXTIDEXTPROC pGetContextIDEXT;
 301     __GLXvendorInfo *dd;
 302
 303     dd = GetDispatchFromContext(ctx);
 304     if (dd == NULL)
 305         return None;
 306
 307     __FETCH_FUNCTION_PTR(GetContextIDEXT);
 308     if (pGetContextIDEXT == NULL)
 309         return None;
 310
 311     return (*pGetContextIDEXT)(ctx);
 312 }
 313
 314
 315
 316 static Display *dispatch_GetCurrentDisplayEXT(void)
 317 {
 318     PFNGLXGETCURRENTDISPLAYEXTPROC pGetCurrentDisplayEXT;
 319     __GLXvendorInfo *dd;
 320
 321     if (!__VND->getCurrentContext())
 322         return NULL;
 323
 324     dd = __VND->getCurrentDynDispatch();
 325     if (dd == NULL)
 326         return NULL;
 327
 328     __FETCH_FUNCTION_PTR(GetCurrentDisplayEXT);
 329     if (pGetCurrentDisplayEXT == NULL)
 330         return NULL;
 331
 332     return (*pGetCurrentDisplayEXT)();
 333 }
 334
 335
 336
 337 static int dispatch_GetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config,
 338                                           int attribute, int *value_return)
 339 {
 340     PFNGLXGETFBCONFIGATTRIBSGIXPROC pGetFBConfigAttribSGIX;
 341     __GLXvendorInfo *dd;
 342
 343     dd = GetDispatchFromFBConfig(dpy, config);
 344     if (dd == NULL)
 345         return GLX_NO_EXTENSION;
 346
 347     __FETCH_FUNCTION_PTR(GetFBConfigAttribSGIX);
 348     if (pGetFBConfigAttribSGIX == NULL)
 349         return GLX_NO_EXTENSION;
 350
 351     return (*pGetFBConfigAttribSGIX)(dpy, config, attribute, value_return);
 352 }
 353
 354
 355
 356 static GLXFBConfigSGIX dispatch_GetFBConfigFromVisualSGIX(Display *dpy,
 357                                                           XVisualInfo *vis)
 358 {
 359     PFNGLXGETFBCONFIGFROMVISUALSGIXPROC pGetFBConfigFromVisualSGIX;
 360     __GLXvendorInfo *dd;
 361     GLXFBConfigSGIX ret = NULL;
 362
 363     dd = GetDispatchFromVisual(dpy, vis);
 364     if (dd == NULL)
 365         return NULL;
 366
 367     __FETCH_FUNCTION_PTR(GetFBConfigFromVisualSGIX);
 368     if (pGetFBConfigFromVisualSGIX == NULL)
 369         return NULL;
 370
 371     ret = (*pGetFBConfigFromVisualSGIX)(dpy, vis);
 372     if (AddFBConfigMapping(dpy, ret, dd))
 373         /* XXX: dealloc ret ? */
 374         return NULL;
 375
 376     return ret;
 377 }
 378
 379
 380
 381 static void dispatch_GetSelectedEventSGIX(Display *dpy, GLXDrawable drawable,
 382                                           unsigned long *mask)
 383 {
 384     PFNGLXGETSELECTEDEVENTSGIXPROC pGetSelectedEventSGIX;
 385     __GLXvendorInfo *dd;
 386
 387     dd = GetDispatchFromDrawable(dpy, drawable);
 388     if (dd == NULL)
 389         return;
 390
 391     __FETCH_FUNCTION_PTR(GetSelectedEventSGIX);
 392     if (pGetSelectedEventSGIX == NULL)
 393         return;
 394
 395     (*pGetSelectedEventSGIX)(dpy, drawable, mask);
 396 }
 397
 398
 399
 400 static int dispatch_GetVideoSyncSGI(unsigned int *count)
 401 {
 402     PFNGLXGETVIDEOSYNCSGIPROC pGetVideoSyncSGI;
 403     __GLXvendorInfo *dd;
 404
 405     if (!__VND->getCurrentContext())
 406         return GLX_BAD_CONTEXT;
 407
 408     dd = __VND->getCurrentDynDispatch();
 409     if (dd == NULL)
 410         return GLX_NO_EXTENSION;
 411
 412     __FETCH_FUNCTION_PTR(GetVideoSyncSGI);
 413     if (pGetVideoSyncSGI == NULL)
 414         return GLX_NO_EXTENSION;
 415
 416     return (*pGetVideoSyncSGI)(count);
 417 }
 418
 419
 420
 421 static XVisualInfo *dispatch_GetVisualFromFBConfigSGIX(Display *dpy,
 422                                                        GLXFBConfigSGIX config)
 423 {
 424     PFNGLXGETVISUALFROMFBCONFIGSGIXPROC pGetVisualFromFBConfigSGIX;
 425     __GLXvendorInfo *dd;
 426
 427     dd = GetDispatchFromFBConfig(dpy, config);
 428     if (dd == NULL)
 429         return NULL;
 430
 431     __FETCH_FUNCTION_PTR(GetVisualFromFBConfigSGIX);
 432     if (pGetVisualFromFBConfigSGIX == NULL)
 433         return NULL;
 434
 435     return (*pGetVisualFromFBConfigSGIX)(dpy, config);
 436 }
 437
 438
 439
 440 static int dispatch_QueryContextInfoEXT(Display *dpy, GLXContext ctx,
 441                                         int attribute, int *value)
 442 {
 443     PFNGLXQUERYCONTEXTINFOEXTPROC pQueryContextInfoEXT;
 444     __GLXvendorInfo *dd;
 445
 446     dd = GetDispatchFromContext(ctx);
 447     if (dd == NULL)
 448         return GLX_NO_EXTENSION;
 449
 450     __FETCH_FUNCTION_PTR(QueryContextInfoEXT);
 451     if (pQueryContextInfoEXT == NULL)
 452         return GLX_NO_EXTENSION;
 453
 454     return (*pQueryContextInfoEXT)(dpy, ctx, attribute, value);
 455 }
 456
 457
 458
 459 static void dispatch_QueryGLXPbufferSGIX(Display *dpy, GLXPbuffer pbuf,
 460                                          int attribute, unsigned int *value)
 461 {
 462     PFNGLXQUERYGLXPBUFFERSGIXPROC pQueryGLXPbufferSGIX;
 463     __GLXvendorInfo *dd;
 464
 465     dd = GetDispatchFromDrawable(dpy, pbuf);
 466     if (dd == NULL)
 467         return;
 468
 469     __FETCH_FUNCTION_PTR(QueryGLXPbufferSGIX);
 470     if (pQueryGLXPbufferSGIX == NULL)
 471         return;
 472
 473     (*pQueryGLXPbufferSGIX)(dpy, pbuf, attribute, value);
 474 }
 475
 476
 477
 478 static void dispatch_ReleaseTexImageEXT(Display *dpy, GLXDrawable drawable,
 479                                         int buffer)
 480 {
 481     PFNGLXRELEASETEXIMAGEEXTPROC pReleaseTexImageEXT;
 482     __GLXvendorInfo *dd;
 483
 484     dd = GetDispatchFromDrawable(dpy, drawable);
 485     if (dd == NULL)
 486         return;
 487
 488     __FETCH_FUNCTION_PTR(ReleaseTexImageEXT);
 489     if (pReleaseTexImageEXT == NULL)
 490         return;
 491
 492     (*pReleaseTexImageEXT)(dpy, drawable, buffer);
 493 }
 494
 495
 496
 497 static void dispatch_SelectEventSGIX(Display *dpy, GLXDrawable drawable,
 498                                      unsigned long mask)
 499 {
 500     PFNGLXSELECTEVENTSGIXPROC pSelectEventSGIX;
 501     __GLXvendorInfo *dd;
 502
 503     dd = GetDispatchFromDrawable(dpy, drawable);
 504     if (dd == NULL)
 505         return;
 506
 507     __FETCH_FUNCTION_PTR(SelectEventSGIX);
 508     if (pSelectEventSGIX == NULL)
 509         return;
 510
 511     (*pSelectEventSGIX)(dpy, drawable, mask);
 512 }
 513
 514
 515
 516 static int dispatch_SwapIntervalSGI(int interval)
 517 {
 518     PFNGLXSWAPINTERVALSGIPROC pSwapIntervalSGI;
 519     __GLXvendorInfo *dd;
 520
 521     if (!__VND->getCurrentContext())
 522         return GLX_BAD_CONTEXT;
 523
 524     dd = __VND->getCurrentDynDispatch();
 525     if (dd == NULL)
 526         return GLX_NO_EXTENSION;
 527
 528     __FETCH_FUNCTION_PTR(SwapIntervalSGI);
 529     if (pSwapIntervalSGI == NULL)
 530         return GLX_NO_EXTENSION;
 531
 532     return (*pSwapIntervalSGI)(interval);
 533 }
 534
 535
 536
 537 static int dispatch_WaitVideoSyncSGI(int divisor, int remainder,
 538                                      unsigned int *count)
 539 {
 540     PFNGLXWAITVIDEOSYNCSGIPROC pWaitVideoSyncSGI;
 541     __GLXvendorInfo *dd;
 542
 543     if (!__VND->getCurrentContext())
 544         return GLX_BAD_CONTEXT;
 545
 546     dd = __VND->getCurrentDynDispatch();
 547     if (dd == NULL)
 548         return GLX_NO_EXTENSION;
 549
 550     __FETCH_FUNCTION_PTR(WaitVideoSyncSGI);
 551     if (pWaitVideoSyncSGI == NULL)
 552         return GLX_NO_EXTENSION;
 553
 554     return (*pWaitVideoSyncSGI)(divisor, remainder, count);
 555 }
 556
 557
 558
 559 static void dispatch_BindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable,
 560                                             int barrier)
 561 {
 562     PFNGLXBINDSWAPBARRIERSGIXPROC pBindSwapBarrierSGIX;
 563     __GLXvendorInfo *dd;
 564
 565     dd = GetDispatchFromDrawable(dpy, drawable);
 566     if (dd == NULL)
 567         return;
 568
 569     __FETCH_FUNCTION_PTR(BindSwapBarrierSGIX);
 570     if (pBindSwapBarrierSGIX == NULL)
 571         return;
 572
 573     (*pBindSwapBarrierSGIX)(dpy, drawable, barrier);
 574 }
 575
 576
 577
 578 static void dispatch_CopySubBufferMESA(Display *dpy, GLXDrawable drawable,
 579                                           int x, int y, int width, int height)
 580 {
 581     PFNGLXCOPYSUBBUFFERMESAPROC pCopySubBufferMESA;
 582     __GLXvendorInfo *dd;
 583
 584     dd = GetDispatchFromDrawable(dpy, drawable);
 585     if (dd == NULL)
 586         return;
 587
 588     __FETCH_FUNCTION_PTR(CopySubBufferMESA);
 589     if (pCopySubBufferMESA == NULL)
 590         return;
 591
 592     (*pCopySubBufferMESA)(dpy, drawable, x, y, width, height);
 593 }
 594
 595
 596
 597 static GLXPixmap dispatch_CreateGLXPixmapMESA(Display *dpy,
 598                                                  XVisualInfo *visinfo,
 599                                                  Pixmap pixmap, Colormap cmap)
 600 {
 601     PFNGLXCREATEGLXPIXMAPMESAPROC pCreateGLXPixmapMESA;
 602     __GLXvendorInfo *dd;
 603     GLXPixmap ret;
 604
 605     dd = GetDispatchFromVisual(dpy, visinfo);
 606     if (dd == NULL)
 607         return None;
 608
 609     __FETCH_FUNCTION_PTR(CreateGLXPixmapMESA);
 610     if (pCreateGLXPixmapMESA == NULL)
 611         return None;
 612
 613     ret = (*pCreateGLXPixmapMESA)(dpy, visinfo, pixmap, cmap);
 614     if (AddDrawableMapping(dpy, ret, dd)) {
 615         /* XXX: Call glXDestroyGLXPixmap which lives in libglvnd. If we're not
 616          * allowed to call it from here, should we extend __glXDispatchTableIndices ?
 617          */
 618         return None;
 619     }
 620
 621     return ret;
 622 }
 623
 624
 625
 626 static GLboolean dispatch_GetMscRateOML(Display *dpy, GLXDrawable drawable,
 627                                            int32_t *numerator, int32_t *denominator)
 628 {
 629     PFNGLXGETMSCRATEOMLPROC pGetMscRateOML;
 630     __GLXvendorInfo *dd;
 631
 632     dd = GetDispatchFromDrawable(dpy, drawable);
 633     if (dd == NULL)
 634         return GL_FALSE;
 635
 636     __FETCH_FUNCTION_PTR(GetMscRateOML);
 637     if (pGetMscRateOML == NULL)
 638         return GL_FALSE;
 639
 640     return (*pGetMscRateOML)(dpy, drawable, numerator, denominator);
 641 }
 642
 643
 644
 645 static const char *dispatch_GetScreenDriver(Display *dpy, int scrNum)
 646 {
 647     typedef const char *(*fn_glXGetScreenDriver_ptr)(Display *dpy, int scrNum);
 648     fn_glXGetScreenDriver_ptr pGetScreenDriver;
 649     __GLXvendorInfo *dd;
 650
 651     dd = __VND->getDynDispatch(dpy, scrNum);
 652     if (dd == NULL)
 653         return NULL;
 654
 655     __FETCH_FUNCTION_PTR(GetScreenDriver);
 656     if (pGetScreenDriver == NULL)
 657         return NULL;
 658
 659     return (*pGetScreenDriver)(dpy, scrNum);
 660 }
 661
 662
 663
 664 static int dispatch_GetSwapIntervalMESA(void)
 665 {
 666     PFNGLXGETSWAPINTERVALMESAPROC pGetSwapIntervalMESA;
 667     __GLXvendorInfo *dd;
 668
 669     if (!__VND->getCurrentContext())
 670         return GLX_BAD_CONTEXT;
 671
 672     dd = __VND->getCurrentDynDispatch();
 673     if (dd == NULL)
 674         return 0;
 675
 676     __FETCH_FUNCTION_PTR(GetSwapIntervalMESA);
 677     if (pGetSwapIntervalMESA == NULL)
 678         return 0;
 679
 680     return (*pGetSwapIntervalMESA)();
 681 }
 682
 683
 684
 685 static Bool dispatch_GetSyncValuesOML(Display *dpy, GLXDrawable drawable,
 686                                          int64_t *ust, int64_t *msc, int64_t *sbc)
 687 {
 688     PFNGLXGETSYNCVALUESOMLPROC pGetSyncValuesOML;
 689     __GLXvendorInfo *dd;
 690
 691     dd = GetDispatchFromDrawable(dpy, drawable);
 692     if (dd == NULL)
 693         return False;
 694
 695     __FETCH_FUNCTION_PTR(GetSyncValuesOML);
 696     if (pGetSyncValuesOML == NULL)
 697         return False;
 698
 699     return (*pGetSyncValuesOML)(dpy, drawable, ust, msc, sbc);
 700 }
 701
 702
 703
 704 static void dispatch_JoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable,
 705                                           GLXDrawable member)
 706 {
 707     PFNGLXJOINSWAPGROUPSGIXPROC pJoinSwapGroupSGIX;
 708     __GLXvendorInfo *dd;
 709
 710     dd = GetDispatchFromDrawable(dpy, drawable);
 711     if (dd == NULL)
 712         return;
 713
 714     __FETCH_FUNCTION_PTR(JoinSwapGroupSGIX);
 715     if (pJoinSwapGroupSGIX == NULL)
 716         return;
 717
 718     (*pJoinSwapGroupSGIX)(dpy, drawable, member);
 719 }
 720
 721
 722
 723 static Bool dispatch_QueryCurrentRendererIntegerMESA(int attribute,
 724                                                         unsigned int *value)
 725 {
 726     PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC pQueryCurrentRendererIntegerMESA;
 727     __GLXvendorInfo *dd;
 728
 729     if (!__VND->getCurrentContext())
 730         return False;
 731
 732     dd = __VND->getCurrentDynDispatch();
 733     if (dd == NULL)
 734         return False;
 735
 736     __FETCH_FUNCTION_PTR(QueryCurrentRendererIntegerMESA);
 737     if (pQueryCurrentRendererIntegerMESA == NULL)
 738         return False;
 739
 740     return (*pQueryCurrentRendererIntegerMESA)(attribute, value);
 741 }
 742
 743
 744
 745 static const char *dispatch_QueryCurrentRendererStringMESA(int attribute)
 746 {
 747     PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC pQueryCurrentRendererStringMESA;
 748     __GLXvendorInfo *dd;
 749
 750     if (!__VND->getCurrentContext())
 751         return NULL;
 752
 753     dd = __VND->getCurrentDynDispatch();
 754     if (dd == NULL)
 755         return NULL;
 756
 757     __FETCH_FUNCTION_PTR(QueryCurrentRendererStringMESA);
 758     if (pQueryCurrentRendererStringMESA == NULL)
 759         return NULL;
 760
 761     return (*pQueryCurrentRendererStringMESA)(attribute);
 762 }
 763
 764
 765
 766 static Bool dispatch_QueryMaxSwapBarriersSGIX(Display *dpy, int screen,
 767                                                  int *max)
 768 {
 769     PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC pQueryMaxSwapBarriersSGIX;
 770     __GLXvendorInfo *dd;
 771
 772     dd = __VND->getDynDispatch(dpy, screen);
 773     if (dd == NULL)
 774         return False;
 775
 776     __FETCH_FUNCTION_PTR(QueryMaxSwapBarriersSGIX);
 777     if (pQueryMaxSwapBarriersSGIX == NULL)
 778         return False;
 779
 780     return (*pQueryMaxSwapBarriersSGIX)(dpy, screen, max);
 781 }
 782
 783
 784
 785 static Bool dispatch_QueryRendererIntegerMESA(Display *dpy, int screen,
 786                                                  int renderer, int attribute,
 787                                                  unsigned int *value)
 788 {
 789     PFNGLXQUERYRENDERERINTEGERMESAPROC pQueryRendererIntegerMESA;
 790     __GLXvendorInfo *dd;
 791
 792     dd = __VND->getDynDispatch(dpy, screen);
 793     if (dd == NULL)
 794         return False;
 795
 796     __FETCH_FUNCTION_PTR(QueryRendererIntegerMESA);
 797     if (pQueryRendererIntegerMESA == NULL)
 798         return False;
 799
 800     return (*pQueryRendererIntegerMESA)(dpy, screen, renderer, attribute, value);
 801 }
 802
 803
 804
 805 static const char *dispatch_QueryRendererStringMESA(Display *dpy, int screen,
 806                                                        int renderer, int attribute)
 807 {
 808     PFNGLXQUERYRENDERERSTRINGMESAPROC pQueryRendererStringMESA;
 809     __GLXvendorInfo *dd = NULL;
 810
 811     dd = __VND->getDynDispatch(dpy, screen);
 812     if (dd == NULL)
 813         return NULL;
 814
 815     __FETCH_FUNCTION_PTR(QueryRendererStringMESA);
 816     if (pQueryRendererStringMESA == NULL)
 817         return NULL;
 818
 819     return (*pQueryRendererStringMESA)(dpy, screen, renderer, attribute);
 820 }
 821
 822
 823
 824 static Bool dispatch_ReleaseBuffersMESA(Display *dpy, GLXDrawable d)
 825 {
 826     PFNGLXRELEASEBUFFERSMESAPROC pReleaseBuffersMESA;
 827     __GLXvendorInfo *dd;
 828
 829     dd = GetDispatchFromDrawable(dpy, d);
 830     if (dd == NULL)
 831         return False;
 832
 833     __FETCH_FUNCTION_PTR(ReleaseBuffersMESA);
 834     if (pReleaseBuffersMESA == NULL)
 835         return False;
 836
 837     return (*pReleaseBuffersMESA)(dpy, d);
 838 }
 839
 840
 841
 842 static int64_t dispatch_SwapBuffersMscOML(Display *dpy, GLXDrawable drawable,
 843                                              int64_t target_msc, int64_t divisor,
 844                                              int64_t remainder)
 845 {
 846     PFNGLXSWAPBUFFERSMSCOMLPROC pSwapBuffersMscOML;
 847     __GLXvendorInfo *dd;
 848
 849     dd = GetDispatchFromDrawable(dpy, drawable);
 850     if (dd == NULL)
 851         return 0;
 852
 853     __FETCH_FUNCTION_PTR(SwapBuffersMscOML);
 854     if (pSwapBuffersMscOML == NULL)
 855         return 0;
 856
 857     return (*pSwapBuffersMscOML)(dpy, drawable, target_msc, divisor, remainder);
 858 }
 859
 860
 861
 862 static int dispatch_SwapIntervalMESA(unsigned int interval)
 863 {
 864     PFNGLXSWAPINTERVALMESAPROC pSwapIntervalMESA;
 865     __GLXvendorInfo *dd;
 866
 867     if (!__VND->getCurrentContext())
 868         return GLX_BAD_CONTEXT;
 869
 870     dd = __VND->getCurrentDynDispatch();
 871     if (dd == NULL)
 872         return 0;
 873
 874     __FETCH_FUNCTION_PTR(SwapIntervalMESA);
 875     if (pSwapIntervalMESA == NULL)
 876         return 0;
 877
 878     return (*pSwapIntervalMESA)(interval);
 879 }
 880
 881
 882
 883 static Bool dispatch_WaitForMscOML(Display *dpy, GLXDrawable drawable,
 884                                       int64_t target_msc, int64_t divisor,
 885                                       int64_t remainder, int64_t *ust,
 886                                       int64_t *msc, int64_t *sbc)
 887 {
 888     PFNGLXWAITFORMSCOMLPROC pWaitForMscOML;
 889     __GLXvendorInfo *dd;
 890
 891     dd = GetDispatchFromDrawable(dpy, drawable);
 892     if (dd == NULL)
 893         return False;
 894
 895     __FETCH_FUNCTION_PTR(WaitForMscOML);
 896     if (pWaitForMscOML == NULL)
 897         return False;
 898
 899     return (*pWaitForMscOML)(dpy, drawable, target_msc, divisor, remainder, ust, msc, sbc);
 900 }
 901
 902
 903
 904 static Bool dispatch_WaitForSbcOML(Display *dpy, GLXDrawable drawable,
 905                                       int64_t target_sbc, int64_t *ust,
 906                                       int64_t *msc, int64_t *sbc)
 907 {
 908     PFNGLXWAITFORSBCOMLPROC pWaitForSbcOML;
 909     __GLXvendorInfo *dd;
 910
 911     dd = GetDispatchFromDrawable(dpy, drawable);
 912     if (dd == NULL)
 913         return False;
 914
 915     __FETCH_FUNCTION_PTR(WaitForSbcOML);
 916     if (pWaitForSbcOML == NULL)
 917         return False;
 918
 919     return (*pWaitForSbcOML)(dpy, drawable, target_sbc, ust, msc, sbc);
 920 }
 921
 922 #undef __FETCH_FUNCTION_PTR
 923
 924
 925 /* Allocate an extra 'dummy' to ease lookup. See FindGLXFunction() */
 926 const void * const __glXDispatchFunctions[DI_LAST_INDEX + 1] = {
 927 #define __ATTRIB(field) \
 928     [DI_##field] = (void *)dispatch_##field
 929
 930     __ATTRIB(BindSwapBarrierSGIX),
 931     __ATTRIB(BindTexImageEXT),
 932     __ATTRIB(ChooseFBConfigSGIX),
 933     __ATTRIB(CopySubBufferMESA),
 934     __ATTRIB(CreateContextAttribsARB),
 935     __ATTRIB(CreateContextWithConfigSGIX),
 936     __ATTRIB(CreateGLXPbufferSGIX),
 937     __ATTRIB(CreateGLXPixmapMESA),
 938     __ATTRIB(CreateGLXPixmapWithConfigSGIX),
 939     __ATTRIB(DestroyGLXPbufferSGIX),
 940     __ATTRIB(GetContextIDEXT),
 941     __ATTRIB(GetCurrentDisplayEXT),
 942     __ATTRIB(GetFBConfigAttribSGIX),
 943     __ATTRIB(GetFBConfigFromVisualSGIX),
 944     __ATTRIB(GetMscRateOML),
 945     __ATTRIB(GetScreenDriver),
 946     __ATTRIB(GetSelectedEventSGIX),
 947     __ATTRIB(GetSwapIntervalMESA),
 948     __ATTRIB(GetSyncValuesOML),
 949     __ATTRIB(GetVideoSyncSGI),
 950     __ATTRIB(GetVisualFromFBConfigSGIX),
 951     __ATTRIB(JoinSwapGroupSGIX),
 952     __ATTRIB(QueryContextInfoEXT),
 953     __ATTRIB(QueryCurrentRendererIntegerMESA),
 954     __ATTRIB(QueryCurrentRendererStringMESA),
 955     __ATTRIB(QueryGLXPbufferSGIX),
 956     __ATTRIB(QueryMaxSwapBarriersSGIX),
 957     __ATTRIB(QueryRendererIntegerMESA),
 958     __ATTRIB(QueryRendererStringMESA),
 959     __ATTRIB(ReleaseBuffersMESA),
 960     __ATTRIB(ReleaseTexImageEXT),
 961     __ATTRIB(SelectEventSGIX),
 962     __ATTRIB(SwapBuffersMscOML),
 963     __ATTRIB(SwapIntervalMESA),
 964     __ATTRIB(SwapIntervalSGI),
 965     __ATTRIB(WaitForMscOML),
 966     __ATTRIB(WaitForSbcOML),
 967     __ATTRIB(WaitVideoSyncSGI),
 968
 969     [DI_LAST_INDEX] = NULL,
 970 #undef __ATTRIB
 971 };