hw/xquartz/GL/indirect.c

   1 /*
   2  * GLX implementation that uses Apple's OpenGL.framework
   3  * (Indirect rendering path -- it's also used for some direct mode code too)
   4  *
   5  * Copyright (c) 2007-2012 Apple Inc.
   6  * Copyright (c) 2004 Torrey T. Lyons. All Rights Reserved.
   7  * Copyright (c) 2002 Greg Parker. All Rights Reserved.
   8  *
   9  * Portions of this file are copied from Mesa's xf86glx.c,
  10  * which contains the following copyright:
  11  *
  12  * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
  13  * All Rights Reserved.
  14  *
  15  * Permission is hereby granted, free of charge, to any person obtaining a
  16  * copy of this software and associated documentation files (the "Software"),
  17  * to deal in the Software without restriction, including without limitation
  18  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  19  * and/or sell copies of the Software, and to permit persons to whom the
  20  * Software is furnished to do so, subject to the following conditions:
  21  *
  22  * The above copyright notice and this permission notice shall be included in
  23  * all copies or substantial portions of the Software.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  26  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  27  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  28  * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  29  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  30  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  31  * DEALINGS IN THE SOFTWARE.
  32  */
  33
  34 #ifdef HAVE_DIX_CONFIG_H
  35 #include <dix-config.h>
  36 #endif
  37
  38 #include <AvailabilityMacros.h>
  39
  40 #include <dlfcn.h>
  41
  42 #include <OpenGL/OpenGL.h>
  43 #include <OpenGL/gl.h>     /* Just to prevent glxserver.h from loading mesa's and colliding with OpenGL.h */
  44
  45 #include <X11/Xproto.h>
  46 #include <GL/glxproto.h>
  47
  48 #include <glxserver.h>
  49 #include <glxutil.h>
  50
  51 #include "x-hash.h"
  52
  53 #include "visualConfigs.h"
  54 #include "dri.h"
  55
  56 #include "darwin.h"
  57 #define GLAQUA_DEBUG_MSG(msg, args ...) ASL_LOG(ASL_LEVEL_DEBUG, "GLXAqua", \
  58                                                 msg, \
  59                                                 ## args)
  60
  61 __GLXprovider *
  62 GlxGetDRISWrastProvider(void);
  63
  64 static void
  65 setup_dispatch_table(void);
  66 GLuint
  67 __glFloorLog2(GLuint val);
  68 void
  69 warn_func(void * p1, char *format, ...);
  70
  71 // some prototypes
  72 static __GLXscreen *
  73 __glXAquaScreenProbe(ScreenPtr pScreen);
  74 static __GLXdrawable *
  75 __glXAquaScreenCreateDrawable(ClientPtr client, __GLXscreen *screen,
  76                               DrawablePtr pDraw, XID drawId, int type,
  77                               XID glxDrawId,
  78                               __GLXconfig *conf);
  79
  80 static void
  81 __glXAquaContextDestroy(__GLXcontext *baseContext);
  82 static int
  83 __glXAquaContextMakeCurrent(__GLXcontext *baseContext);
  84 static int
  85 __glXAquaContextLoseCurrent(__GLXcontext *baseContext);
  86 static int
  87 __glXAquaContextCopy(__GLXcontext *baseDst, __GLXcontext *baseSrc,
  88                      unsigned long mask);
  89
  90 static CGLPixelFormatObj
  91 makeFormat(__GLXconfig *conf);
  92
  93 __GLXprovider __glXDRISWRastProvider = {
  94     __glXAquaScreenProbe,
  95     "Core OpenGL",
  96     NULL
  97 };
  98
  99 typedef struct __GLXAquaScreen __GLXAquaScreen;
 100 typedef struct __GLXAquaContext __GLXAquaContext;
 101 typedef struct __GLXAquaDrawable __GLXAquaDrawable;
 102
 103 /*
 104  * The following structs must keep the base as the first member.
 105  * It's used to treat the start of the struct as a different struct
 106  * in GLX.
 107  *
 108  * Note: these structs should be initialized with xcalloc or memset
 109  * prior to usage, and some of them require initializing
 110  * the base with function pointers.
 111  */
 112 struct __GLXAquaScreen {
 113     __GLXscreen base;
 114     int index;
 115     int num_vis;
 116 };
 117
 118 struct __GLXAquaContext {
 119     __GLXcontext base;
 120     CGLContextObj ctx;
 121     CGLPixelFormatObj pixelFormat;
 122     xp_surface_id sid;
 123     unsigned isAttached : 1;
 124 };
 125
 126 struct __GLXAquaDrawable {
 127     __GLXdrawable base;
 128     DrawablePtr pDraw;
 129     xp_surface_id sid;
 130     __GLXAquaContext *context;
 131 };
 132
 133 static __GLXcontext *
 134 __glXAquaScreenCreateContext(__GLXscreen *screen,
 135                              __GLXconfig *conf,
 136                              __GLXcontext *baseShareContext,
 137                              unsigned num_attribs,
 138                              const uint32_t *attribs,
 139                              int *error)
 140 {
 141     __GLXAquaContext *context;
 142     __GLXAquaContext *shareContext = (__GLXAquaContext *)baseShareContext;
 143     CGLError gl_err;
 144
 145     /* Unused (for now?) */
 146     (void)num_attribs;
 147     (void)attribs;
 148     (void)error;
 149
 150     GLAQUA_DEBUG_MSG("glXAquaScreenCreateContext\n");
 151
 152     context = calloc(1, sizeof(__GLXAquaContext));
 153
 154     if (context == NULL)
 155         return NULL;
 156
 157     memset(context, 0, sizeof *context);
 158
 159     context->base.pGlxScreen = screen;
 160
 161     context->base.destroy = __glXAquaContextDestroy;
 162     context->base.makeCurrent = __glXAquaContextMakeCurrent;
 163     context->base.loseCurrent = __glXAquaContextLoseCurrent;
 164     context->base.copy = __glXAquaContextCopy;
 165     /*FIXME verify that the context->base is fully initialized. */
 166
 167     context->pixelFormat = makeFormat(conf);
 168
 169     if (!context->pixelFormat) {
 170         free(context);
 171         return NULL;
 172     }
 173
 174     context->ctx = NULL;
 175     gl_err = CGLCreateContext(context->pixelFormat,
 176                               shareContext ? shareContext->ctx : NULL,
 177                               &context->ctx);
 178
 179     if (gl_err != 0) {
 180         ErrorF("CGLCreateContext error: %s\n", CGLErrorString(gl_err));
 181         CGLDestroyPixelFormat(context->pixelFormat);
 182         free(context);
 183         return NULL;
 184     }
 185
 186     setup_dispatch_table();
 187     GLAQUA_DEBUG_MSG("glAquaCreateContext done\n");
 188
 189     return &context->base;
 190 }
 191
 192 /* maps from surface id -> list of __GLcontext */
 193 static x_hash_table *surface_hash;
 194
 195 static void
 196 __glXAquaContextDestroy(__GLXcontext *baseContext)
 197 {
 198     x_list *lst;
 199
 200     __GLXAquaContext *context = (__GLXAquaContext *)baseContext;
 201
 202     GLAQUA_DEBUG_MSG("glAquaContextDestroy (ctx %p)\n", baseContext);
 203     if (context != NULL) {
 204         if (context->sid != 0 && surface_hash != NULL) {
 205             lst =
 206                 x_hash_table_lookup(surface_hash, x_cvt_uint_to_vptr(
 207                                         context->sid), NULL);
 208             lst = x_list_remove(lst, context);
 209             x_hash_table_insert(surface_hash, x_cvt_uint_to_vptr(
 210                                     context->sid), lst);
 211         }
 212
 213         if (context->ctx != NULL)
 214             CGLDestroyContext(context->ctx);
 215
 216         if (context->pixelFormat != NULL)
 217             CGLDestroyPixelFormat(context->pixelFormat);
 218
 219         free(context);
 220     }
 221 }
 222
 223 static int
 224 __glXAquaContextLoseCurrent(__GLXcontext *baseContext)
 225 {
 226     CGLError gl_err;
 227
 228     GLAQUA_DEBUG_MSG("glAquaLoseCurrent (ctx 0x%p)\n", baseContext);
 229
 230     gl_err = CGLSetCurrentContext(NULL);
 231     if (gl_err != 0)
 232         ErrorF("CGLSetCurrentContext error: %s\n", CGLErrorString(gl_err));
 233
 234     /*
 235      * There should be no need to set __glXLastContext to NULL here, because
 236      * glxcmds.c does it as part of the context cache flush after calling
 237      * this.
 238      */
 239
 240     return GL_TRUE;
 241 }
 242
 243 /* Called when a surface is destroyed as a side effect of destroying
 244    the window it's attached to. */
 245 static void
 246 surface_notify(void *_arg, void *data)
 247 {
 248     DRISurfaceNotifyArg *arg = (DRISurfaceNotifyArg *)_arg;
 249     __GLXAquaDrawable *draw = (__GLXAquaDrawable *)data;
 250     __GLXAquaContext *context;
 251     x_list *lst;
 252     if (_arg == NULL || data == NULL) {
 253         ErrorF("surface_notify called with bad params");
 254         return;
 255     }
 256
 257     GLAQUA_DEBUG_MSG("surface_notify(%p, %p)\n", _arg, data);
 258     switch (arg->kind) {
 259     case AppleDRISurfaceNotifyDestroyed:
 260         if (surface_hash != NULL)
 261             x_hash_table_remove(surface_hash, x_cvt_uint_to_vptr(arg->id));
 262         draw->pDraw = NULL;
 263         draw->sid = 0;
 264         break;
 265
 266     case AppleDRISurfaceNotifyChanged:
 267         if (surface_hash != NULL) {
 268             lst =
 269                 x_hash_table_lookup(surface_hash, x_cvt_uint_to_vptr(
 270                                         arg->id), NULL);
 271             for (; lst != NULL; lst = lst->next) {
 272                 context = lst->data;
 273                 xp_update_gl_context(context->ctx);
 274             }
 275         }
 276         break;
 277
 278     default:
 279         ErrorF("surface_notify: unknown kind %d\n", arg->kind);
 280         break;
 281     }
 282 }
 283
 284 static BOOL
 285 attach(__GLXAquaContext *context, __GLXAquaDrawable *draw)
 286 {
 287     DrawablePtr pDraw;
 288
 289     GLAQUA_DEBUG_MSG("attach(%p, %p)\n", context, draw);
 290
 291     if (NULL == context || NULL == draw)
 292         return TRUE;
 293
 294     pDraw = draw->base.pDraw;
 295
 296     if (NULL == pDraw) {
 297         ErrorF("%s:%s() pDraw is NULL!\n", __FILE__, __func__);
 298         return TRUE;
 299     }
 300
 301     if (draw->sid == 0) {
 302         //if (!quartzProcs->CreateSurface(pDraw->pScreen, pDraw->id, pDraw,
 303         if (!DRICreateSurface(pDraw->pScreen, pDraw->id, pDraw,
 304                               0, &draw->sid, NULL,
 305                               surface_notify, draw))
 306             return TRUE;
 307         draw->pDraw = pDraw;
 308     }
 309
 310     if (!context->isAttached || context->sid != draw->sid) {
 311         x_list *lst;
 312
 313         if (xp_attach_gl_context(context->ctx, draw->sid) != Success) {
 314             //quartzProcs->DestroySurface(pDraw->pScreen, pDraw->id, pDraw,
 315             DRIDestroySurface(pDraw->pScreen, pDraw->id, pDraw,
 316                               surface_notify, draw);
 317             if (surface_hash != NULL)
 318                 x_hash_table_remove(surface_hash,
 319                                     x_cvt_uint_to_vptr(draw->sid));
 320
 321             draw->sid = 0;
 322             return TRUE;
 323         }
 324
 325         context->isAttached = TRUE;
 326         context->sid = draw->sid;
 327
 328         if (surface_hash == NULL)
 329             surface_hash = x_hash_table_new(NULL, NULL, NULL, NULL);
 330
 331         lst =
 332             x_hash_table_lookup(surface_hash, x_cvt_uint_to_vptr(
 333                                     context->sid), NULL);
 334         if (x_list_find(lst, context) == NULL) {
 335             lst = x_list_prepend(lst, context);
 336             x_hash_table_insert(surface_hash, x_cvt_uint_to_vptr(
 337                                     context->sid), lst);
 338         }
 339
 340         GLAQUA_DEBUG_MSG("attached 0x%x to 0x%x\n", (unsigned int)pDraw->id,
 341                          (unsigned int)draw->sid);
 342     }
 343
 344     draw->context = context;
 345
 346     return FALSE;
 347 }
 348
 349 #if 0     // unused
 350 static void
 351 unattach(__GLXAquaContext *context)
 352 {
 353     x_list *lst;
 354     GLAQUA_DEBUG_MSG("unattach\n");
 355     if (context == NULL) {
 356         ErrorF("Tried to unattach a null context\n");
 357         return;
 358     }
 359     if (context->isAttached) {
 360         GLAQUA_DEBUG_MSG("unattaching\n");
 361
 362         if (surface_hash != NULL) {
 363             lst = x_hash_table_lookup(surface_hash, (void *)context->sid,
 364                                       NULL);
 365             lst = x_list_remove(lst, context);
 366             x_hash_table_insert(surface_hash, (void *)context->sid, lst);
 367         }
 368
 369         CGLClearDrawable(context->ctx);
 370         context->isAttached = FALSE;
 371         context->sid = 0;
 372     }
 373 }
 374 #endif
 375
 376 static int
 377 __glXAquaContextMakeCurrent(__GLXcontext *baseContext)
 378 {
 379     CGLError gl_err;
 380     __GLXAquaContext *context = (__GLXAquaContext *)baseContext;
 381     __GLXAquaDrawable *drawPriv = (__GLXAquaDrawable *)context->base.drawPriv;
 382
 383     GLAQUA_DEBUG_MSG("glAquaMakeCurrent (ctx 0x%p)\n", baseContext);
 384
 385     if (attach(context, drawPriv))
 386         return /*error*/ 0;
 387
 388     gl_err = CGLSetCurrentContext(context->ctx);
 389     if (gl_err != 0)
 390         ErrorF("CGLSetCurrentContext error: %s\n", CGLErrorString(gl_err));
 391
 392     return gl_err == 0;
 393 }
 394
 395 static int
 396 __glXAquaContextCopy(__GLXcontext *baseDst, __GLXcontext *baseSrc,
 397                      unsigned long mask)
 398 {
 399     CGLError gl_err;
 400
 401     __GLXAquaContext *dst = (__GLXAquaContext *)baseDst;
 402     __GLXAquaContext *src = (__GLXAquaContext *)baseSrc;
 403
 404     GLAQUA_DEBUG_MSG("GLXAquaContextCopy\n");
 405
 406     gl_err = CGLCopyContext(src->ctx, dst->ctx, mask);
 407     if (gl_err != 0)
 408         ErrorF("CGLCopyContext error: %s\n", CGLErrorString(gl_err));
 409
 410     return gl_err == 0;
 411 }
 412
 413 /* Drawing surface notification callbacks */
 414 static GLboolean
 415 __glXAquaDrawableSwapBuffers(ClientPtr client, __GLXdrawable *base)
 416 {
 417     CGLError err;
 418     __GLXAquaDrawable *drawable;
 419
 420     //    GLAQUA_DEBUG_MSG("glAquaDrawableSwapBuffers(%p)\n",base);
 421
 422     if (!base) {
 423         ErrorF("%s passed NULL\n", __func__);
 424         return GL_FALSE;
 425     }
 426
 427     drawable = (__GLXAquaDrawable *)base;
 428
 429     if (NULL == drawable->context) {
 430         ErrorF("%s called with a NULL->context for drawable %p!\n",
 431                __func__, (void *)drawable);
 432         return GL_FALSE;
 433     }
 434
 435     err = CGLFlushDrawable(drawable->context->ctx);
 436
 437     if (kCGLNoError != err) {
 438         ErrorF("CGLFlushDrawable error: %s in %s\n", CGLErrorString(err),
 439                __func__);
 440         return GL_FALSE;
 441     }
 442
 443     return GL_TRUE;
 444 }
 445
 446 static CGLPixelFormatObj
 447 makeFormat(__GLXconfig *conf)
 448 {
 449     CGLPixelFormatAttribute attr[64];
 450     CGLPixelFormatObj fobj;
 451     GLint formats;
 452     CGLError error;
 453     int i = 0;
 454
 455     if (conf->doubleBufferMode)
 456         attr[i++] = kCGLPFADoubleBuffer;
 457
 458     if (conf->stereoMode)
 459         attr[i++] = kCGLPFAStereo;
 460
 461     attr[i++] = kCGLPFAColorSize;
 462     attr[i++] = conf->redBits + conf->greenBits + conf->blueBits;
 463     attr[i++] = kCGLPFAAlphaSize;
 464     attr[i++] = conf->alphaBits;
 465
 466     if ((conf->accumRedBits + conf->accumGreenBits + conf->accumBlueBits +
 467          conf->accumAlphaBits) > 0) {
 468
 469         attr[i++] = kCGLPFAAccumSize;
 470         attr[i++] = conf->accumRedBits + conf->accumGreenBits
 471                     + conf->accumBlueBits + conf->accumAlphaBits;
 472     }
 473
 474     attr[i++] = kCGLPFADepthSize;
 475     attr[i++] = conf->depthBits;
 476
 477     if (conf->stencilBits) {
 478         attr[i++] = kCGLPFAStencilSize;
 479         attr[i++] = conf->stencilBits;
 480     }
 481
 482     if (conf->numAuxBuffers > 0) {
 483         attr[i++] = kCGLPFAAuxBuffers;
 484         attr[i++] = conf->numAuxBuffers;
 485     }
 486
 487     if (conf->sampleBuffers > 0) {
 488         attr[i++] = kCGLPFASampleBuffers;
 489         attr[i++] = conf->sampleBuffers;
 490         attr[i++] = kCGLPFASamples;
 491         attr[i++] = conf->samples;
 492     }
 493
 494     attr[i] = 0;
 495
 496     error = CGLChoosePixelFormat(attr, &fobj, &formats);
 497     if (error) {
 498         ErrorF("error: creating pixel format %s\n", CGLErrorString(error));
 499         return NULL;
 500     }
 501
 502     return fobj;
 503 }
 504
 505 static void
 506 __glXAquaScreenDestroy(__GLXscreen *screen)
 507 {
 508
 509     GLAQUA_DEBUG_MSG("glXAquaScreenDestroy(%p)\n", screen);
 510     __glXScreenDestroy(screen);
 511
 512     free(screen);
 513 }
 514
 515 /* This is called by __glXInitScreens(). */
 516 static __GLXscreen *
 517 __glXAquaScreenProbe(ScreenPtr pScreen)
 518 {
 519     __GLXAquaScreen *screen;
 520
 521     GLAQUA_DEBUG_MSG("glXAquaScreenProbe\n");
 522
 523     if (pScreen == NULL)
 524         return NULL;
 525
 526     screen = calloc(1, sizeof *screen);
 527
 528     if (NULL == screen)
 529         return NULL;
 530
 531     screen->base.destroy = __glXAquaScreenDestroy;
 532     screen->base.createContext = __glXAquaScreenCreateContext;
 533     screen->base.createDrawable = __glXAquaScreenCreateDrawable;
 534     screen->base.swapInterval = /*FIXME*/ NULL;
 535     screen->base.pScreen = pScreen;
 536
 537     screen->base.fbconfigs = __glXAquaCreateVisualConfigs(
 538         &screen->base.numFBConfigs, pScreen->myNum);
 539
 540     __glXScreenInit(&screen->base, pScreen);
 541
 542     screen->base.GLXmajor = 1;
 543     screen->base.GLXminor = 4;
 544     screen->base.GLXextensions = strdup("GLX_SGIX_fbconfig "
 545                                         "GLX_SGIS_multisample "
 546                                         "GLX_ARB_multisample "
 547                                         "GLX_EXT_visual_info "
 548                                         "GLX_EXT_import_context ");
 549
 550     /*We may be able to add more GLXextensions at a later time. */
 551
 552     return &screen->base;
 553 }
 554
 555 #if 0 // unused
 556 static void
 557 __glXAquaDrawableCopySubBuffer(__GLXdrawable *drawable,
 558                                int x, int y, int w, int h)
 559 {
 560     /*TODO finish me*/
 561 }
 562 #endif
 563
 564 static void
 565 __glXAquaDrawableDestroy(__GLXdrawable *base)
 566 {
 567     /* gstaplin: base is the head of the structure, so it's at the same
 568      * offset in memory.
 569      * Is this safe with strict aliasing?   I noticed that the other dri code
 570      * does this too...
 571      */
 572     __GLXAquaDrawable *glxPriv = (__GLXAquaDrawable *)base;
 573
 574     GLAQUA_DEBUG_MSG("TRACE");
 575
 576     /* It doesn't work to call DRIDestroySurface here, the drawable's
 577        already gone.. But dri.c notices the window destruction and
 578        frees the surface itself. */
 579
 580     /*gstaplin: verify the statement above.  The surface destroy
 581        *messages weren't making it through, and may still not be.
 582        *We need a good test case for surface creation and destruction.
 583        *We also need a good way to enable introspection on the server
 584        *to validate the test, beyond using gdb with print.
 585      */
 586
 587     free(glxPriv);
 588 }
 589
 590 static __GLXdrawable *
 591 __glXAquaScreenCreateDrawable(ClientPtr client,
 592                               __GLXscreen *screen,
 593                               DrawablePtr pDraw,
 594                               XID drawId,
 595                               int type,
 596                               XID glxDrawId,
 597                               __GLXconfig *conf)
 598 {
 599     __GLXAquaDrawable *glxPriv;
 600
 601     glxPriv = malloc(sizeof *glxPriv);
 602
 603     if (glxPriv == NULL)
 604         return NULL;
 605
 606     memset(glxPriv, 0, sizeof *glxPriv);
 607
 608     if (!__glXDrawableInit(&glxPriv->base, screen, pDraw, type, glxDrawId,
 609                            conf)) {
 610         free(glxPriv);
 611         return NULL;
 612     }
 613
 614     glxPriv->base.destroy = __glXAquaDrawableDestroy;
 615     glxPriv->base.swapBuffers = __glXAquaDrawableSwapBuffers;
 616     glxPriv->base.copySubBuffer = NULL; /* __glXAquaDrawableCopySubBuffer; */
 617
 618     glxPriv->pDraw = pDraw;
 619     glxPriv->sid = 0;
 620     glxPriv->context = NULL;
 621
 622     return &glxPriv->base;
 623 }
 624
 625 // Extra goodies for glx
 626
 627 GLuint
 628 __glFloorLog2(GLuint val)
 629 {
 630     int c = 0;
 631
 632     while (val > 1) {
 633         c++;
 634         val >>= 1;
 635     }
 636     return c;
 637 }
 638
 639 #ifndef OPENGL_FRAMEWORK_PATH
 640 #define OPENGL_FRAMEWORK_PATH \
 641     "/System/Library/Frameworks/OpenGL.framework/OpenGL"
 642 #endif
 643
 644 static void *opengl_framework_handle;
 645
 646 static glx_func_ptr
 647 get_proc_address(const char *sym)
 648 {
 649     return (glx_func_ptr) dlsym(opengl_framework_handle, sym);
 650 }
 651
 652 static void
 653 setup_dispatch_table(void)
 654 {
 655     const char *opengl_framework_path;
 656
 657     if (opengl_framework_handle) {
 658         return;
 659     }
 660
 661     opengl_framework_path = getenv("OPENGL_FRAMEWORK_PATH");
 662     if (!opengl_framework_path) {
 663         opengl_framework_path = OPENGL_FRAMEWORK_PATH;
 664     }
 665
 666     (void)dlerror();             /*drain dlerror */
 667     opengl_framework_handle = dlopen(opengl_framework_path, RTLD_LOCAL);
 668
 669     if (!opengl_framework_handle) {
 670         ErrorF("unable to dlopen %s : %s, using RTLD_DEFAULT\n",
 671                opengl_framework_path, dlerror());
 672         opengl_framework_handle = RTLD_DEFAULT;
 673     }
 674
 675     __glXsetGetProcAddress(get_proc_address);
 676 }