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