src/glx/x11/dri_common.c

   1 /* -*- mode: c; tab-width: 3; indent-tabs-mode: nil; c-basic-offset: 3; coding: utf-8-unix -*- */
   2 /*
   3  * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
   4  * Copyright © 2008 Red Hat, Inc.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Soft-
   8  * ware"), to deal in the Software without restriction, including without
   9  * limitation the rights to use, copy, modify, merge, publish, distribute,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, provided that the above copyright
  12  * notice(s) and this permission notice appear in all copies of the Soft-
  13  * ware and that both the above copyright notice(s) and this permission
  14  * notice appear in supporting documentation.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
  18  * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
  19  * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
  20  * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
  21  * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  22  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  23  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
  24  * MANCE OF THIS SOFTWARE.
  25  *
  26  * Except as contained in this notice, the name of a copyright holder shall
  27  * not be used in advertising or otherwise to promote the sale, use or
  28  * other dealings in this Software without prior written authorization of
  29  * the copyright holder.
  30  *
  31  * Authors:
  32  *   Kevin E. Martin <kevin@precisioninsight.com>
  33  *   Brian Paul <brian@precisioninsight.com>
  34  *   Kristian Høgsberg (krh@redhat.com)
  35  */
  36
  37 #ifdef GLX_DIRECT_RENDERING
  38
  39 #include <unistd.h>
  40 #include <dlfcn.h>
  41 #include <stdarg.h>
  42 #include "glxclient.h"
  43 #include "glcontextmodes.h"
  44 #include "dri_common.h"
  45
  46 #ifndef RTLD_NOW
  47 #define RTLD_NOW 0
  48 #endif
  49 #ifndef RTLD_GLOBAL
  50 #define RTLD_GLOBAL 0
  51 #endif
  52
  53 _X_HIDDEN void InfoMessageF(const char *f, ...)
  54 {
  55     va_list args;
  56     const char *env;
  57
  58     if ((env = getenv("LIBGL_DEBUG")) && strstr(env, "verbose")) {
  59         fprintf(stderr, "libGL: ");
  60         va_start(args, f);
  61         vfprintf(stderr, f, args);
  62         va_end(args);
  63     }
  64 }
  65
  66 /**
  67  * Print error to stderr, unless LIBGL_DEBUG=="quiet".
  68  */
  69 _X_HIDDEN void ErrorMessageF(const char *f, ...)
  70 {
  71     va_list args;
  72     const char *env;
  73
  74     if ((env = getenv("LIBGL_DEBUG")) && !strstr(env, "quiet")) {
  75         fprintf(stderr, "libGL error: ");
  76         va_start(args, f);
  77         vfprintf(stderr, f, args);
  78         va_end(args);
  79     }
  80 }
  81
  82 #ifndef DEFAULT_DRIVER_DIR
  83 /* this is normally defined in Mesa/configs/default with DRI_DRIVER_SEARCH_PATH */
  84 #define DEFAULT_DRIVER_DIR "/usr/local/lib/dri"
  85 #endif
  86
  87 /**
  88  * Try to \c dlopen the named driver.
  89  *
  90  * This function adds the "_dri.so" suffix to the driver name and searches the
  91  * directories specified by the \c LIBGL_DRIVERS_PATH environment variable in
  92  * order to find the driver.
  93  *
  94  * \param driverName - a name like "tdfx", "i810", "mga", etc.
  95  *
  96  * \returns
  97  * A handle from \c dlopen, or \c NULL if driver file not found.
  98  */
  99 _X_HIDDEN void *driOpenDriver(const char *driverName)
 100 {
 101    void *glhandle, *handle;
 102    const char *libPaths, *p, *next;
 103    char realDriverName[200];
 104    int len;
 105
 106    /* Attempt to make sure libGL symbols will be visible to the driver */
 107    glhandle = dlopen("libGL.so.1", RTLD_NOW | RTLD_GLOBAL);
 108
 109    libPaths = NULL;
 110    if (geteuid() == getuid()) {
 111       /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
 112       libPaths = getenv("LIBGL_DRIVERS_PATH");
 113       if (!libPaths)
 114          libPaths = getenv("LIBGL_DRIVERS_DIR"); /* deprecated */
 115    }
 116    if (libPaths == NULL)
 117        libPaths = DEFAULT_DRIVER_DIR;
 118
 119    handle = NULL;
 120    for (p = libPaths; *p; p = next) {
 121        next = strchr(p, ':');
 122        if (next == NULL) {
 123            len = strlen(p);
 124            next = p + len;
 125        } else {
 126            len = next - p;
 127            next++;
 128        }
 129
 130 #ifdef GLX_USE_TLS
 131       snprintf(realDriverName, sizeof realDriverName,
 132                "%.*s/tls/%s_dri.so", len, p, driverName);
 133       InfoMessageF("OpenDriver: trying %s\n", realDriverName);
 134       handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
 135 #endif
 136
 137       if ( handle == NULL ) {
 138          snprintf(realDriverName, sizeof realDriverName,
 139                   "%.*s/%s_dri.so", len, p, driverName);
 140          InfoMessageF("OpenDriver: trying %s\n", realDriverName);
 141          handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
 142       }
 143
 144       if ( handle != NULL )
 145           break;
 146       else
 147          ErrorMessageF("dlopen %s failed (%s)\n", realDriverName, dlerror());
 148    }
 149
 150    if (!handle)
 151       ErrorMessageF("unable to load driver: %s_dri.so\n", driverName);
 152
 153    if (glhandle)
 154       dlclose(glhandle);
 155
 156    return handle;
 157 }
 158
 159 _X_HIDDEN const __DRIsystemTimeExtension systemTimeExtension = {
 160     { __DRI_SYSTEM_TIME, __DRI_SYSTEM_TIME_VERSION },
 161     __glXGetUST,
 162     __driGetMscRateOML
 163 };
 164
 165 #define __ATTRIB(attrib, field) \
 166     { attrib, offsetof(__GLcontextModes, field) }
 167
 168 static const struct { unsigned int attrib, offset; } attribMap[] = {
 169     __ATTRIB(__DRI_ATTRIB_BUFFER_SIZE,                  rgbBits),
 170     __ATTRIB(__DRI_ATTRIB_LEVEL,                        level),
 171     __ATTRIB(__DRI_ATTRIB_RED_SIZE,                     redBits),
 172     __ATTRIB(__DRI_ATTRIB_GREEN_SIZE,                   greenBits),
 173     __ATTRIB(__DRI_ATTRIB_BLUE_SIZE,                    blueBits),
 174     __ATTRIB(__DRI_ATTRIB_ALPHA_SIZE,                   alphaBits),
 175     __ATTRIB(__DRI_ATTRIB_DEPTH_SIZE,                   depthBits),
 176     __ATTRIB(__DRI_ATTRIB_STENCIL_SIZE,                 stencilBits),
 177     __ATTRIB(__DRI_ATTRIB_ACCUM_RED_SIZE,               accumRedBits),
 178     __ATTRIB(__DRI_ATTRIB_ACCUM_GREEN_SIZE,             accumGreenBits),
 179     __ATTRIB(__DRI_ATTRIB_ACCUM_BLUE_SIZE,              accumBlueBits),
 180     __ATTRIB(__DRI_ATTRIB_ACCUM_ALPHA_SIZE,             accumAlphaBits),
 181     __ATTRIB(__DRI_ATTRIB_SAMPLE_BUFFERS,               sampleBuffers),
 182     __ATTRIB(__DRI_ATTRIB_SAMPLES,                      samples),
 183     __ATTRIB(__DRI_ATTRIB_DOUBLE_BUFFER,                doubleBufferMode),
 184     __ATTRIB(__DRI_ATTRIB_STEREO,                       stereoMode),
 185     __ATTRIB(__DRI_ATTRIB_AUX_BUFFERS,                  numAuxBuffers),
 186 #if 0
 187     __ATTRIB(__DRI_ATTRIB_TRANSPARENT_TYPE,             transparentPixel),
 188     __ATTRIB(__DRI_ATTRIB_TRANSPARENT_INDEX_VALUE,      transparentIndex),
 189     __ATTRIB(__DRI_ATTRIB_TRANSPARENT_RED_VALUE,        transparentRed),
 190     __ATTRIB(__DRI_ATTRIB_TRANSPARENT_GREEN_VALUE,      transparentGreen),
 191     __ATTRIB(__DRI_ATTRIB_TRANSPARENT_BLUE_VALUE,       transparentBlue),
 192     __ATTRIB(__DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE,      transparentAlpha),
 193     __ATTRIB(__DRI_ATTRIB_RED_MASK,                     redMask),
 194     __ATTRIB(__DRI_ATTRIB_GREEN_MASK,                   greenMask),
 195     __ATTRIB(__DRI_ATTRIB_BLUE_MASK,                    blueMask),
 196     __ATTRIB(__DRI_ATTRIB_ALPHA_MASK,                   alphaMask),
 197 #endif
 198     __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_WIDTH,            maxPbufferWidth),
 199     __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_HEIGHT,           maxPbufferHeight),
 200     __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_PIXELS,           maxPbufferPixels),
 201     __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH,        optimalPbufferWidth),
 202     __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT,       optimalPbufferHeight),
 203 #if 0
 204     __ATTRIB(__DRI_ATTRIB_SWAP_METHOD,                  swapMethod),
 205 #endif
 206     __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGB,          bindToTextureRgb),
 207     __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGBA,         bindToTextureRgba),
 208     __ATTRIB(__DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE,       bindToMipmapTexture),
 209     __ATTRIB(__DRI_ATTRIB_YINVERTED,                    yInverted),
 210 };
 211
 212 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 213
 214 static int
 215 scalarEqual(__GLcontextModes *mode, unsigned int attrib, unsigned int value)
 216 {
 217     unsigned int glxValue;
 218     int i;
 219
 220     for (i = 0; i < ARRAY_SIZE(attribMap); i++)
 221         if (attribMap[i].attrib == attrib) {
 222             glxValue = *(unsigned int *) ((char *) mode + attribMap[i].offset);
 223             return glxValue == GLX_DONT_CARE || glxValue == value;
 224         }
 225
 226     return GL_TRUE; /* Is a non-existing attribute equal to value? */
 227 }
 228
 229 static int
 230 driConfigEqual(const __DRIcoreExtension *core,
 231                __GLcontextModes *modes, const __DRIconfig *driConfig)
 232 {
 233     unsigned int attrib, value, glxValue;
 234     int i;
 235
 236     i = 0;
 237     while (core->indexConfigAttrib(driConfig, i++, &attrib, &value)) {
 238         switch (attrib) {
 239         case __DRI_ATTRIB_RENDER_TYPE:
 240             glxValue = 0;
 241             if (value & __DRI_ATTRIB_RGBA_BIT) {
 242                 glxValue |= GLX_RGBA_BIT;
 243             } else if (value & __DRI_ATTRIB_COLOR_INDEX_BIT) {
 244                 glxValue |= GLX_COLOR_INDEX_BIT;
 245             }
 246             if (glxValue != modes->renderType)
 247                 return GL_FALSE;
 248             break;
 249
 250         case __DRI_ATTRIB_CONFIG_CAVEAT:
 251             if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
 252                 glxValue = GLX_NON_CONFORMANT_CONFIG;
 253             else if (value & __DRI_ATTRIB_SLOW_BIT)
 254                 glxValue = GLX_SLOW_CONFIG;
 255             else
 256                 glxValue = GLX_NONE;
 257             if (glxValue != modes->visualRating)
 258                 return GL_FALSE;
 259             break;
 260
 261         case __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS:
 262             glxValue = 0;
 263             if (value & __DRI_ATTRIB_TEXTURE_1D_BIT)
 264                 glxValue |= GLX_TEXTURE_1D_BIT_EXT;
 265             if (value & __DRI_ATTRIB_TEXTURE_2D_BIT)
 266                 glxValue |= GLX_TEXTURE_2D_BIT_EXT;
 267             if (value & __DRI_ATTRIB_TEXTURE_RECTANGLE_BIT)
 268                 glxValue |= GLX_TEXTURE_RECTANGLE_BIT_EXT;
 269             if (modes->bindToTextureTargets != GLX_DONT_CARE &&
 270                 glxValue != modes->bindToTextureTargets)
 271                 return GL_FALSE;
 272             break;
 273
 274         default:
 275             if (!scalarEqual(modes, attrib, value))
 276                 return GL_FALSE;
 277         }
 278     }
 279
 280     return GL_TRUE;
 281 }
 282
 283 static __GLcontextModes *
 284 createDriMode(const __DRIcoreExtension *core,
 285               __GLcontextModes *modes, const __DRIconfig **driConfigs)
 286 {
 287     __GLXDRIconfigPrivate *config;
 288     int i;
 289
 290     for (i = 0; driConfigs[i]; i++) {
 291         if (driConfigEqual(core, modes, driConfigs[i]))
 292             break;
 293     }
 294
 295     if (driConfigs[i] == NULL)
 296         return NULL;
 297
 298     config = Xmalloc(sizeof *config);
 299     if (config == NULL)
 300         return NULL;
 301
 302     config->modes = *modes;
 303     config->driConfig = driConfigs[i];
 304
 305     return &config->modes;
 306 }
 307
 308 _X_HIDDEN __GLcontextModes *
 309 driConvertConfigs(const __DRIcoreExtension *core,
 310                   __GLcontextModes *modes, const __DRIconfig **configs)
 311 {
 312     __GLcontextModes head, *tail, *m;
 313
 314     tail = &head;
 315     head.next = NULL;
 316     for (m = modes; m; m = m->next) {
 317         tail->next = createDriMode(core, m, configs);
 318         if (tail->next == NULL) {
 319             /* no matching dri config for m */
 320             continue;
 321         }
 322
 323
 324         tail = tail->next;
 325     }
 326
 327     _gl_context_modes_destroy(modes);
 328
 329     return head.next;
 330 }
 331
 332 _X_HIDDEN void
 333 driBindExtensions(__GLXscreenConfigs *psc, int dri2)
 334 {
 335     const __DRIextension **extensions;
 336     int i;
 337
 338     extensions = psc->core->getExtensions(psc->__driScreen);
 339
 340     for (i = 0; extensions[i]; i++) {
 341 #ifdef __DRI_COPY_SUB_BUFFER
 342         if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0) {
 343             psc->copySubBuffer = (__DRIcopySubBufferExtension *) extensions[i];
 344             __glXEnableDirectExtension(psc, "GLX_MESA_copy_sub_buffer_bit");
 345         }
 346 #endif
 347
 348 #ifdef __DRI_SWAP_CONTROL
 349         if (strcmp(extensions[i]->name, __DRI_SWAP_CONTROL) == 0) {
 350             psc->swapControl = (__DRIswapControlExtension *) extensions[i];
 351             __glXEnableDirectExtension(psc, "GLX_SGI_swap_control");
 352             __glXEnableDirectExtension(psc, "GLX_MESA_swap_control");
 353         }
 354 #endif
 355
 356 #ifdef __DRI_ALLOCATE
 357         if (strcmp(extensions[i]->name, __DRI_ALLOCATE) == 0) {
 358             psc->allocate = (__DRIallocateExtension *) extensions[i];
 359             __glXEnableDirectExtension(psc, "GLX_MESA_allocate_memory");
 360         }
 361 #endif
 362
 363 #ifdef __DRI_FRAME_TRACKING
 364         if (strcmp(extensions[i]->name, __DRI_FRAME_TRACKING) == 0) {
 365             psc->frameTracking = (__DRIframeTrackingExtension *) extensions[i];
 366             __glXEnableDirectExtension(psc, "GLX_MESA_swap_frame_usage");
 367         }
 368 #endif
 369
 370 #ifdef __DRI_MEDIA_STREAM_COUNTER
 371         if (strcmp(extensions[i]->name, __DRI_MEDIA_STREAM_COUNTER) == 0) {
 372             psc->msc = (__DRImediaStreamCounterExtension *) extensions[i];
 373             __glXEnableDirectExtension(psc, "GLX_SGI_video_sync");
 374         }
 375 #endif
 376
 377 #ifdef __DRI_SWAP_BUFFER_COUNTER
 378         /* No driver supports this at this time and the extension is
 379          * not defined in dri_interface.h.  Will enable
 380          * GLX_OML_sync_control if implemented. */
 381 #endif
 382
 383 #ifdef __DRI_READ_DRAWABLE
 384         if (strcmp(extensions[i]->name, __DRI_READ_DRAWABLE) == 0) {
 385             __glXEnableDirectExtension(psc, "GLX_SGI_make_current_read");
 386         }
 387 #endif
 388
 389 #ifdef __DRI_TEX_BUFFER
 390         if ((strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0) && dri2) {
 391             psc->texBuffer = (__DRItexBufferExtension *) extensions[i];
 392             __glXEnableDirectExtension(psc, "GLX_EXT_texture_from_pixmap");
 393         }
 394 #endif
 395
 396         /* Ignore unknown extensions */
 397     }
 398 }
 399
 400 #endif /* GLX_DIRECT_RENDERING */