Home | History | Annotate | Download | only in glx 
      1 /*
      2  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
      3  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
      4  *
      5  * Permission is hereby granted, free of charge, to any person obtaining a
      6  * copy of this software and associated documentation files (the "Software"),
      7  * to deal in the Software without restriction, including without limitation
      8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
      9  * and/or sell copies of the Software, and to permit persons to whom the
     10  * Software is furnished to do so, subject to the following conditions:
     11  *
     12  * The above copyright notice including the dates of first publication and
     13  * either this permission notice or a reference to
     14  * http://oss.sgi.com/projects/FreeB/
     15  * shall be included in all copies or substantial portions of the Software.
     16  *
     17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
     18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
     20  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
     21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
     22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     23  * SOFTWARE.
     24  *
     25  * Except as contained in this notice, the name of Silicon Graphics, Inc.
     26  * shall not be used in advertising or otherwise to promote the sale, use or
     27  * other dealings in this Software without prior written authorization from
     28  * Silicon Graphics, Inc.
     29  */
     30 
     31 /**
     32  * \file glxcurrent.c
     33  * Client-side GLX interface for current context management.
     34  */
     35 
     36 #ifdef HAVE_PTHREAD
     37 #include <pthread.h>
     38 #endif
     39 
     40 #include "glxclient.h"
     41 #ifdef GLX_USE_APPLEGL
     42 #include <stdlib.h>
     43 
     44 #include "apple_glx.h"
     45 #include "apple_glx_context.h"
     46 #endif
     47 
     48 #include "glapi.h"
     49 
     50 /*
     51 ** We setup some dummy structures here so that the API can be used
     52 ** even if no context is current.
     53 */
     54 
     55 static GLubyte dummyBuffer[__GLX_BUFFER_LIMIT_SIZE];
     56 static struct glx_context_vtable dummyVtable;
     57 /*
     58 ** Dummy context used by small commands when there is no current context.
     59 ** All the
     60 ** gl and glx entry points are designed to operate as nop's when using
     61 ** the dummy context structure.
     62 */
     63 struct glx_context dummyContext = {
     64    &dummyBuffer[0],
     65    &dummyBuffer[0],
     66    &dummyBuffer[0],
     67    &dummyBuffer[__GLX_BUFFER_LIMIT_SIZE],
     68    sizeof(dummyBuffer),
     69    &dummyVtable
     70 };
     71 
     72 /*
     73  * Current context management and locking
     74  */
     75 
     76 #if defined( HAVE_PTHREAD )
     77 
     78 _X_HIDDEN pthread_mutex_t __glXmutex = PTHREAD_MUTEX_INITIALIZER;
     79 
     80 # if defined( GLX_USE_TLS )
     81 
     82 /**
     83  * Per-thread GLX context pointer.
     84  *
     85  * \c __glXSetCurrentContext is written is such a way that this pointer can
     86  * \b never be \c NULL.  This is important!  Because of this
     87  * \c __glXGetCurrentContext can be implemented as trivial macro.
     88  */
     89 __thread void *__glX_tls_Context __attribute__ ((tls_model("initial-exec")))
     90    = &dummyContext;
     91 
     92 _X_HIDDEN void
     93 __glXSetCurrentContext(struct glx_context * c)
     94 {
     95    __glX_tls_Context = (c != NULL) ? c : &dummyContext;
     96 }
     97 
     98 # else
     99 
    100 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
    101 
    102 /**
    103  * Per-thread data key.
    104  *
    105  * Once \c init_thread_data has been called, the per-thread data key will
    106  * take a value of \c NULL.  As each new thread is created the default
    107  * value, in that thread, will be \c NULL.
    108  */
    109 static pthread_key_t ContextTSD;
    110 
    111 /**
    112  * Initialize the per-thread data key.
    113  *
    114  * This function is called \b exactly once per-process (not per-thread!) to
    115  * initialize the per-thread data key.  This is ideally done using the
    116  * \c pthread_once mechanism.
    117  */
    118 static void
    119 init_thread_data(void)
    120 {
    121    if (pthread_key_create(&ContextTSD, NULL) != 0) {
    122       perror("pthread_key_create");
    123       exit(-1);
    124    }
    125 }
    126 
    127 _X_HIDDEN void
    128 __glXSetCurrentContext(struct glx_context * c)
    129 {
    130    pthread_once(&once_control, init_thread_data);
    131    pthread_setspecific(ContextTSD, c);
    132 }
    133 
    134 _X_HIDDEN struct glx_context *
    135 __glXGetCurrentContext(void)
    136 {
    137    void *v;
    138 
    139    pthread_once(&once_control, init_thread_data);
    140 
    141    v = pthread_getspecific(ContextTSD);
    142    return (v == NULL) ? &dummyContext : (struct glx_context *) v;
    143 }
    144 
    145 # endif /* defined( GLX_USE_TLS ) */
    146 
    147 #elif defined( THREADS )
    148 
    149 #error Unknown threading method specified.
    150 
    151 #else
    152 
    153 /* not thread safe */
    154 _X_HIDDEN struct glx_context *__glXcurrentContext = &dummyContext;
    155 
    156 #endif
    157 
    158 
    159 _X_HIDDEN void
    160 __glXSetCurrentContextNull(void)
    161 {
    162    __glXSetCurrentContext(&dummyContext);
    163 #if defined(GLX_DIRECT_RENDERING)
    164    _glapi_set_dispatch(NULL);   /* no-op functions */
    165    _glapi_set_context(NULL);
    166 #endif
    167 }
    168 
    169 _X_EXPORT GLXContext
    170 glXGetCurrentContext(void)
    171 {
    172    struct glx_context *cx = __glXGetCurrentContext();
    173 
    174    if (cx == &dummyContext) {
    175       return NULL;
    176    }
    177    else {
    178       return (GLXContext) cx;
    179    }
    180 }
    181 
    182 _X_EXPORT GLXDrawable
    183 glXGetCurrentDrawable(void)
    184 {
    185    struct glx_context *gc = __glXGetCurrentContext();
    186    return gc->currentDrawable;
    187 }
    188 
    189 static void
    190 __glXGenerateError(Display * dpy, XID resource,
    191                    BYTE errorCode, CARD16 minorCode)
    192 {
    193    xError error;
    194 
    195    error.errorCode = errorCode;
    196    error.resourceID = resource;
    197    error.sequenceNumber = dpy->request;
    198    error.type = X_Error;
    199    error.majorCode = __glXSetupForCommand(dpy);
    200    error.minorCode = minorCode;
    201    _XError(dpy, &error);
    202 }
    203 
    204 /**
    205  * Make a particular context current.
    206  *
    207  * \note This is in this file so that it can access dummyContext.
    208  */
    209 static Bool
    210 MakeContextCurrent(Display * dpy, GLXDrawable draw,
    211                    GLXDrawable read, GLXContext gc_user)
    212 {
    213    struct glx_context *gc = (struct glx_context *) gc_user;
    214    struct glx_context *oldGC = __glXGetCurrentContext();
    215 
    216    /* XXX: If this is left out, then libGL ends up not having this
    217     * symbol, and drivers using it fail to load.  Compare the
    218     * implementation of this symbol to _glapi_noop_enable_warnings(),
    219     * though, which gets into the library despite no callers, the same
    220     * prototypes, and the same compile flags to the files containing
    221     * them.  Moving the definition to glapi_nop.c gets it into the
    222     * library, though.
    223     */
    224    (void)_glthread_GetID();
    225 
    226    /* Make sure that the new context has a nonzero ID.  In the request,
    227     * a zero context ID is used only to mean that we bind to no current
    228     * context.
    229     */
    230    if ((gc != NULL) && (gc->xid == None)) {
    231       return GL_FALSE;
    232    }
    233 
    234    if (gc == NULL && (draw != None || read != None)) {
    235       __glXGenerateError(dpy, (draw != None) ? draw : read,
    236                          BadMatch, X_GLXMakeContextCurrent);
    237       return False;
    238    }
    239    if (gc != NULL && (draw == None || read == None)) {
    240       __glXGenerateError(dpy, None, BadMatch, X_GLXMakeContextCurrent);
    241       return False;
    242    }
    243 
    244    _glapi_check_multithread();
    245 
    246    __glXLock();
    247    if (oldGC == gc &&
    248        gc->currentDrawable == draw && gc->currentReadable == read) {
    249       __glXUnlock();
    250       return True;
    251    }
    252 
    253    if (oldGC != &dummyContext) {
    254       if (--oldGC->thread_refcount == 0) {
    255 	 oldGC->vtable->unbind(oldGC, gc);
    256 	 oldGC->currentDpy = 0;
    257       }
    258    }
    259 
    260    if (gc) {
    261       /* Attempt to bind the context.  We do this before mucking with
    262        * gc and __glXSetCurrentContext to properly handle our state in
    263        * case of an error.
    264        *
    265        * If an error occurs, set the Null context since we've already
    266        * blown away our old context.  The caller is responsible for
    267        * figuring out how to handle setting a valid context.
    268        */
    269       if (gc->vtable->bind(gc, oldGC, draw, read) != Success) {
    270          __glXSetCurrentContextNull();
    271          __glXUnlock();
    272          __glXGenerateError(dpy, None, GLXBadContext, X_GLXMakeContextCurrent);
    273          return GL_FALSE;
    274       }
    275 
    276       if (gc->thread_refcount == 0) {
    277          gc->currentDpy = dpy;
    278          gc->currentDrawable = draw;
    279          gc->currentReadable = read;
    280       }
    281       gc->thread_refcount++;
    282       __glXSetCurrentContext(gc);
    283    } else {
    284       __glXSetCurrentContextNull();
    285    }
    286 
    287    if (oldGC->thread_refcount == 0 && oldGC != &dummyContext && oldGC->xid == None) {
    288       /* We are switching away from a context that was
    289        * previously destroyed, so we need to free the memory
    290        * for the old handle. */
    291       oldGC->vtable->destroy(oldGC);
    292    }
    293 
    294    __glXUnlock();
    295 
    296    return GL_TRUE;
    297 }
    298 
    299 
    300 _X_EXPORT Bool
    301 glXMakeCurrent(Display * dpy, GLXDrawable draw, GLXContext gc)
    302 {
    303    return MakeContextCurrent(dpy, draw, draw, gc);
    304 }
    305 
    306 _X_EXPORT
    307 GLX_ALIAS(Bool, glXMakeCurrentReadSGI,
    308           (Display * dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
    309           (dpy, d, r, ctx), MakeContextCurrent)
    310 
    311 _X_EXPORT
    312 GLX_ALIAS(Bool, glXMakeContextCurrent,
    313           (Display * dpy, GLXDrawable d, GLXDrawable r,
    314            GLXContext ctx), (dpy, d, r, ctx), MakeContextCurrent)
    315