xorg-server-1.4/GL/glx/glxglcore.c

   1 /**************************************************************************
   2
   3 Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
   4 All Rights Reserved.
   5
   6 Permission is hereby granted, free of charge, to any person obtaining a
   7 copy of this software and associated documentation files (the
   8 "Software"), to deal in the Software without restriction, including
   9 without limitation the rights to use, copy, modify, merge, publish,
  10 distribute, sub license, and/or sell copies of the Software, and to
  11 permit persons to whom the Software is furnished to do so, subject to
  12 the following conditions:
  13
  14 The above copyright notice and this permission notice (including the
  15 next paragraph) shall be included in all copies or substantial portions
  16 of the Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  22 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26 **************************************************************************/
  27
  28 /*
  29  * Authors:
  30  *   Kevin E. Martin <kevin@precisioninsight.com>
  31  *   Brian E. Paul <brian@precisioninsight.com>
  32  *
  33  */
  34
  35 #ifdef HAVE_DIX_CONFIG_H
  36 #include <dix-config.h>
  37 #endif
  38
  39 #include <string.h>
  40
  41 #include <GL/xmesa.h>
  42 #include <GL/internal/glcore.h>
  43 #include <glxserver.h>
  44 #include <glxscreens.h>
  45 #include <glxdrawable.h>
  46 #include <glxcontext.h>
  47 #include <glxutil.h>
  48
  49 #include "glcontextmodes.h"
  50 #include "os.h"
  51
  52 typedef struct __GLXMESAscreen   __GLXMESAscreen;
  53 typedef struct __GLXMESAcontext  __GLXMESAcontext;
  54 typedef struct __GLXMESAdrawable __GLXMESAdrawable;
  55
  56 struct __GLXMESAscreen {
  57     __GLXscreen   base;
  58     int           index;
  59     int           num_vis;
  60     XMesaVisual  *xm_vis;
  61 };
  62
  63 struct __GLXMESAcontext {
  64     __GLXcontext base;
  65     XMesaContext xmesa;
  66 };
  67
  68 struct __GLXMESAdrawable {
  69     __GLXdrawable base;
  70     XMesaBuffer   xm_buf;
  71 };
  72
  73 static XMesaVisual find_mesa_visual(__GLXscreen *screen, VisualID vid);
  74
  75
  76 static void
  77 __glXMesaDrawableDestroy(__GLXdrawable *base)
  78 {
  79     __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base;
  80
  81     if (glxPriv->xm_buf != NULL)
  82       XMesaDestroyBuffer(glxPriv->xm_buf);
  83     xfree(glxPriv);
  84 }
  85
  86 static GLboolean
  87 __glXMesaDrawableResize(__GLXdrawable *base)
  88 {
  89     __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base;
  90
  91     XMesaResizeBuffers(glxPriv->xm_buf);
  92
  93     return GL_TRUE;
  94 }
  95
  96 static GLboolean
  97 __glXMesaDrawableSwapBuffers(__GLXdrawable *base)
  98 {
  99     __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base;
 100
 101     /* This is terrifying: XMesaSwapBuffers() ends up calling CopyArea
 102      * to do the buffer swap, but this assumes that the server holds
 103      * the lock and has its context visible.  If another screen uses a
 104      * DRI driver, that will have installed the DRI enter/leave server
 105      * functions, which lifts the lock during GLX dispatch.  This is
 106      * why we need to re-take the lock and swap in the server context
 107      * before calling XMesaSwapBuffers() here.  /me shakes head. */
 108
 109     __glXenterServer(GL_FALSE);
 110
 111     XMesaSwapBuffers(glxPriv->xm_buf);
 112
 113     __glXleaveServer(GL_FALSE);
 114
 115     return GL_TRUE;
 116 }
 117
 118
 119 static __GLXdrawable *
 120 __glXMesaScreenCreateDrawable(__GLXscreen *screen,
 121                               DrawablePtr pDraw,
 122                               XID drawId,
 123                               __GLcontextModes *modes)
 124 {
 125     __GLXMESAdrawable *glxPriv;
 126     XMesaVisual xm_vis;
 127
 128     glxPriv = xalloc(sizeof *glxPriv);
 129     if (glxPriv == NULL)
 130         return NULL;
 131
 132     memset(glxPriv, 0, sizeof *glxPriv);
 133
 134     if (!__glXDrawableInit(&glxPriv->base, screen, pDraw, drawId, modes)) {
 135         xfree(glxPriv);
 136         return NULL;
 137     }
 138
 139     glxPriv->base.destroy     = __glXMesaDrawableDestroy;
 140     glxPriv->base.resize      = __glXMesaDrawableResize;
 141     glxPriv->base.swapBuffers = __glXMesaDrawableSwapBuffers;
 142
 143     xm_vis = find_mesa_visual(screen, modes->visualID);
 144     if (xm_vis == NULL) {
 145         ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
 146                modes->visualID);
 147         xfree(glxPriv);
 148         return NULL;
 149     }
 150
 151     if (glxPriv->base.type == DRAWABLE_WINDOW) {
 152         glxPriv->xm_buf = XMesaCreateWindowBuffer(xm_vis, (WindowPtr)pDraw);
 153     } else {
 154         glxPriv->xm_buf = XMesaCreatePixmapBuffer(xm_vis, (PixmapPtr)pDraw, 0);
 155     }
 156
 157     return &glxPriv->base;
 158 }
 159
 160 static void
 161 __glXMesaContextDestroy(__GLXcontext *baseContext)
 162 {
 163     __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext;
 164
 165     XMesaDestroyContext(context->xmesa);
 166     __glXContextDestroy(&context->base);
 167     xfree(context);
 168 }
 169
 170 static int
 171 __glXMesaContextMakeCurrent(__GLXcontext *baseContext)
 172
 173 {
 174     __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext;
 175     __GLXMESAdrawable *drawPriv = (__GLXMESAdrawable *) context->base.drawPriv;
 176     __GLXMESAdrawable *readPriv = (__GLXMESAdrawable *) context->base.readPriv;
 177
 178     return XMesaMakeCurrent2(context->xmesa,
 179                              drawPriv->xm_buf,
 180                              readPriv->xm_buf);
 181 }
 182
 183 static int
 184 __glXMesaContextLoseCurrent(__GLXcontext *baseContext)
 185 {
 186     __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext;
 187
 188     return XMesaLoseCurrent(context->xmesa);
 189 }
 190
 191 static int
 192 __glXMesaContextCopy(__GLXcontext *baseDst,
 193                      __GLXcontext *baseSrc,
 194                      unsigned long mask)
 195 {
 196     __GLXMESAcontext *dst = (__GLXMESAcontext *) baseDst;
 197     __GLXMESAcontext *src = (__GLXMESAcontext *) baseSrc;
 198
 199     return XMesaCopyContext(src->xmesa, dst->xmesa, mask);
 200 }
 201
 202 static int
 203 __glXMesaContextForceCurrent(__GLXcontext *baseContext)
 204 {
 205     __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext;
 206
 207     /* GlxSetRenderTables() call for XGL moved in XMesaForceCurrent() */
 208
 209     return XMesaForceCurrent(context->xmesa);
 210 }
 211
 212 static __GLXcontext *
 213 __glXMesaScreenCreateContext(__GLXscreen *screen,
 214                              __GLcontextModes *modes,
 215                              __GLXcontext *baseShareContext)
 216 {
 217     __GLXMESAcontext *context;
 218     __GLXMESAcontext *shareContext = (__GLXMESAcontext *) baseShareContext;
 219     XMesaVisual xm_vis;
 220     XMesaContext xm_share;
 221
 222     context = xalloc (sizeof (__GLXMESAcontext));
 223     if (context == NULL)
 224         return NULL;
 225
 226     memset(context, 0, sizeof *context);
 227
 228     context->base.pGlxScreen = screen;
 229     context->base.modes      = modes;
 230
 231     context->base.destroy        = __glXMesaContextDestroy;
 232     context->base.makeCurrent    = __glXMesaContextMakeCurrent;
 233     context->base.loseCurrent    = __glXMesaContextLoseCurrent;
 234     context->base.copy           = __glXMesaContextCopy;
 235     context->base.forceCurrent   = __glXMesaContextForceCurrent;
 236
 237     xm_vis = find_mesa_visual(screen, modes->visualID);
 238     if (!xm_vis) {
 239         ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
 240                modes->visualID);
 241         xfree(context);
 242         return NULL;
 243     }
 244
 245     xm_share = shareContext ? shareContext->xmesa : NULL;
 246     context->xmesa = XMesaCreateContext(xm_vis, xm_share);
 247     if (!context->xmesa) {
 248         xfree(context);
 249         return NULL;
 250     }
 251
 252     return &context->base;
 253 }
 254
 255 static void
 256 __glXMesaScreenDestroy(__GLXscreen *screen)
 257 {
 258     __GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen;
 259     int i;
 260
 261     if (mesaScreen->xm_vis) {
 262         for (i = 0; i < mesaScreen->num_vis; i++) {
 263             if (mesaScreen->xm_vis[i])
 264                 XMesaDestroyVisual(mesaScreen->xm_vis[i]);
 265         }
 266
 267         xfree(mesaScreen->xm_vis);
 268     }
 269
 270     __glXScreenDestroy(screen);
 271
 272     xfree(screen);
 273 }
 274
 275 static XMesaVisual
 276 find_mesa_visual(__GLXscreen *screen, VisualID vid)
 277 {
 278     __GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen;
 279     const __GLcontextModes *modes;
 280     unsigned i = 0;
 281
 282     for ( modes = screen->modes ; modes != NULL ; modes = modes->next ) {
 283         if ( modes->visualID == vid ) {
 284             break;
 285         }
 286
 287         i++;
 288     }
 289
 290     return (modes != NULL) ? mesaScreen->xm_vis[i] : NULL;
 291 }
 292
 293 static void init_screen_visuals(__GLXMESAscreen *screen)
 294 {
 295     ScreenPtr pScreen = screen->base.pScreen;
 296     __GLcontextModes *modes;
 297     XMesaVisual *pXMesaVisual;
 298     int *used;
 299     int num_vis, j, size;
 300
 301     /* Alloc space for the list of XMesa visuals */
 302     size = screen->base.numVisuals * sizeof(XMesaVisual);
 303     pXMesaVisual = (XMesaVisual *) xalloc(size);
 304     memset(pXMesaVisual, 0, size);
 305
 306     /* FIXME: Change 'used' to be a array of bits (rather than of ints),
 307      * FIXME: create a stack array of 8 or 16 bytes.  If 'numVisuals' is less
 308      * FIXME: than 64 or 128 the stack array can be used instead of calling
 309      * FIXME: __glXMalloc / __glXFree.  If nothing else, convert 'used' to
 310      * FIXME: array of bytes instead of ints!
 311      */
 312     used = (int *) xalloc(pScreen->numVisuals * sizeof(int));
 313     memset(used, 0, pScreen->numVisuals * sizeof(int));
 314
 315     num_vis = 0;
 316     for ( modes = screen->base.modes; modes != NULL; modes = modes->next ) {
 317         const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
 318         const int nplanes = (modes->rgbBits - modes->alphaBits);
 319         const VisualPtr pVis = pScreen->visuals;
 320
 321         for (j = 0; j < pScreen->numVisuals; j++) {
 322             if (pVis[j].class     == vis_class &&
 323                 pVis[j].nplanes   == nplanes &&
 324                 pVis[j].redMask   == modes->redMask &&
 325                 pVis[j].greenMask == modes->greenMask &&
 326                 pVis[j].blueMask  == modes->blueMask &&
 327                 !used[j]) {
 328
 329                 /* Create the XMesa visual */
 330                 assert(num_vis < screen->base.numVisuals);
 331                 pXMesaVisual[num_vis] =
 332                     XMesaCreateVisual(pScreen,
 333                                       &pVis[j],
 334                                       modes->rgbMode,
 335                                       (modes->alphaBits > 0),
 336                                       modes->doubleBufferMode,
 337                                       modes->stereoMode,
 338                                       GL_TRUE, /* ximage_flag */
 339                                       modes->depthBits,
 340                                       modes->stencilBits,
 341                                       modes->accumRedBits,
 342                                       modes->accumGreenBits,
 343                                       modes->accumBlueBits,
 344                                       modes->accumAlphaBits,
 345                                       modes->samples,
 346                                       modes->level,
 347                                       modes->visualRating);
 348                 /* Set the VisualID */
 349                 modes->visualID = pVis[j].vid;
 350
 351                 /* Mark this visual used */
 352                 used[j] = 1;
 353                 break;
 354             }
 355         }
 356
 357         if ( j == pScreen->numVisuals ) {
 358             ErrorF("No matching visual for __GLcontextMode with "
 359                    "visual class = %d (%d), nplanes = %u\n",
 360                    vis_class,
 361                    modes->visualType,
 362                    (modes->rgbBits - modes->alphaBits) );
 363         }
 364         else if ( modes->visualID == -1 ) {
 365             FatalError( "Matching visual found, but visualID still -1!\n" );
 366         }
 367
 368         num_vis++;
 369     }
 370
 371     xfree(used);
 372
 373     screen->num_vis = num_vis;
 374     screen->xm_vis = pXMesaVisual;
 375
 376     assert(screen->num_vis <= screen->base.numVisuals);
 377 }
 378
 379 static __GLXscreen *
 380 __glXMesaScreenProbe(ScreenPtr pScreen)
 381 {
 382     __GLXMESAscreen *screen;
 383
 384     screen = xalloc(sizeof *screen);
 385     if (screen == NULL)
 386         return NULL;
 387
 388     __glXScreenInit(&screen->base, pScreen);
 389
 390     screen->base.destroy        = __glXMesaScreenDestroy;
 391     screen->base.createContext  = __glXMesaScreenCreateContext;
 392     screen->base.createDrawable = __glXMesaScreenCreateDrawable;
 393     screen->base.pScreen       = pScreen;
 394
 395     /*
 396      * Find the GLX visuals that are supported by this screen and create
 397      * XMesa's visuals.
 398      */
 399     init_screen_visuals(screen);
 400
 401     return &screen->base;
 402 }
 403
 404 __GLXprovider __glXMesaProvider = {
 405     __glXMesaScreenProbe,
 406     "MESA",
 407     NULL
 408 };
 409
 410 __GLXprovider *
 411 GlxGetMesaProvider (void)
 412 {
 413     return &__glXMesaProvider;
 414 }