src/glx/drisw_glx.c

   1 /*
   2  * Copyright 2008 George Sapountzis
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #ifdef GLX_DIRECT_RENDERING
  25
  26 #include <X11/Xlib.h>
  27 #include "glxclient.h"
  28 #include <dlfcn.h>
  29 #include "dri_common.h"
  30
  31 typedef struct __GLXDRIdisplayPrivateRec __GLXDRIdisplayPrivate;
  32 typedef struct __GLXDRIcontextPrivateRec __GLXDRIcontextPrivate;
  33 typedef struct __GLXDRIdrawablePrivateRec __GLXDRIdrawablePrivate;
  34
  35 struct __GLXDRIdisplayPrivateRec
  36 {
  37    __GLXDRIdisplay base;
  38 };
  39
  40 struct __GLXDRIcontextPrivateRec
  41 {
  42    __GLXDRIcontext base;
  43    __DRIcontext *driContext;
  44    __GLXscreenConfigs *psc;
  45 };
  46
  47 struct __GLXDRIdrawablePrivateRec
  48 {
  49    __GLXDRIdrawable base;
  50
  51    GC gc;
  52    GC swapgc;
  53
  54    XVisualInfo *visinfo;
  55    XImage *ximage;
  56    int bpp;
  57 };
  58
  59 /**
  60  * swrast loader functions
  61  */
  62
  63 static Bool
  64 XCreateDrawable(__GLXDRIdrawablePrivate * pdp,
  65                 Display * dpy, XID drawable, int visualid)
  66 {
  67    XGCValues gcvalues;
  68    long visMask;
  69    XVisualInfo visTemp;
  70    int num_visuals;
  71
  72    /* create GC's */
  73    pdp->gc = XCreateGC(dpy, drawable, 0, NULL);
  74    pdp->swapgc = XCreateGC(dpy, drawable, 0, NULL);
  75
  76    gcvalues.function = GXcopy;
  77    gcvalues.graphics_exposures = False;
  78    XChangeGC(dpy, pdp->gc, GCFunction, &gcvalues);
  79    XChangeGC(dpy, pdp->swapgc, GCFunction, &gcvalues);
  80    XChangeGC(dpy, pdp->swapgc, GCGraphicsExposures, &gcvalues);
  81
  82    /* create XImage  */
  83    visTemp.screen = DefaultScreen(dpy);
  84    visTemp.visualid = visualid;
  85    visMask = (VisualScreenMask | VisualIDMask);
  86    pdp->visinfo = XGetVisualInfo(dpy, visMask, &visTemp, &num_visuals);
  87
  88    pdp->ximage = XCreateImage(dpy, pdp->visinfo->visual, pdp->visinfo->depth, ZPixmap, 0,       /* format, offset */
  89                               NULL,     /* data */
  90                               0, 0,     /* size */
  91                               32,       /* bitmap_pad */
  92                               0);       /* bytes_per_line */
  93
  94    /* get the true number of bits per pixel */
  95    pdp->bpp = pdp->ximage->bits_per_pixel;
  96
  97    return True;
  98 }
  99
 100 static void
 101 XDestroyDrawable(__GLXDRIdrawablePrivate * pdp, Display * dpy, XID drawable)
 102 {
 103    XDestroyImage(pdp->ximage);
 104    XFree(pdp->visinfo);
 105
 106    XFreeGC(dpy, pdp->gc);
 107    XFreeGC(dpy, pdp->swapgc);
 108 }
 109
 110 static void
 111 swrastGetDrawableInfo(__DRIdrawable * draw,
 112                       int *x, int *y, int *w, int *h, void *loaderPrivate)
 113 {
 114    __GLXDRIdrawablePrivate *pdp = loaderPrivate;
 115    __GLXDRIdrawable *pdraw = &(pdp->base);
 116    Display *dpy = pdraw->psc->dpy;
 117    Drawable drawable;
 118
 119    Window root;
 120    Status stat;
 121    unsigned int bw, depth;
 122
 123    drawable = pdraw->xDrawable;
 124
 125    stat = XGetGeometry(dpy, drawable, &root,
 126                        x, y, (unsigned int *) w, (unsigned int *) h,
 127                        &bw, &depth);
 128 }
 129
 130 static inline int
 131 bytes_per_line(int w, int bpp, unsigned mul)
 132 {
 133    unsigned mask = mul - 1;
 134
 135    return ((w * bpp + mask) & ~mask) / 8;
 136 }
 137
 138 static void
 139 swrastPutImage(__DRIdrawable * draw, int op,
 140                int x, int y, int w, int h, char *data, void *loaderPrivate)
 141 {
 142    __GLXDRIdrawablePrivate *pdp = loaderPrivate;
 143    __GLXDRIdrawable *pdraw = &(pdp->base);
 144    Display *dpy = pdraw->psc->dpy;
 145    Drawable drawable;
 146    XImage *ximage;
 147    GC gc;
 148
 149    switch (op) {
 150    case __DRI_SWRAST_IMAGE_OP_DRAW:
 151       gc = pdp->gc;
 152       break;
 153    case __DRI_SWRAST_IMAGE_OP_SWAP:
 154       gc = pdp->swapgc;
 155       break;
 156    default:
 157       return;
 158    }
 159
 160    drawable = pdraw->xDrawable;
 161
 162    ximage = pdp->ximage;
 163    ximage->data = data;
 164    ximage->width = w;
 165    ximage->height = h;
 166    ximage->bytes_per_line = bytes_per_line(w, pdp->bpp, 32);
 167
 168    XPutImage(dpy, drawable, gc, ximage, 0, 0, x, y, w, h);
 169
 170    ximage->data = NULL;
 171 }
 172
 173 static void
 174 swrastGetImage(__DRIdrawable * draw,
 175                int x, int y, int w, int h, char *data, void *loaderPrivate)
 176 {
 177    __GLXDRIdrawablePrivate *pdp = loaderPrivate;
 178    __GLXDRIdrawable *pdraw = &(pdp->base);
 179    Display *dpy = pdraw->psc->dpy;
 180    Drawable drawable;
 181    XImage *ximage;
 182
 183    drawable = pdraw->xDrawable;
 184
 185    ximage = pdp->ximage;
 186    ximage->data = data;
 187    ximage->width = w;
 188    ximage->height = h;
 189    ximage->bytes_per_line = bytes_per_line(w, pdp->bpp, 32);
 190
 191    XGetSubImage(dpy, drawable, x, y, w, h, ~0L, ZPixmap, ximage, 0, 0);
 192
 193    ximage->data = NULL;
 194 }
 195
 196 static const __DRIswrastLoaderExtension swrastLoaderExtension = {
 197    {__DRI_SWRAST_LOADER, __DRI_SWRAST_LOADER_VERSION},
 198    swrastGetDrawableInfo,
 199    swrastPutImage,
 200    swrastGetImage
 201 };
 202
 203 static const __DRIextension *loader_extensions[] = {
 204    &systemTimeExtension.base,
 205    &swrastLoaderExtension.base,
 206    NULL
 207 };
 208
 209 /**
 210  * GLXDRI functions
 211  */
 212
 213 static void
 214 driDestroyContext(__GLXDRIcontext * context,
 215                   __GLXscreenConfigs * psc, Display * dpy)
 216 {
 217    __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
 218    const __DRIcoreExtension *core = pcp->psc->core;
 219
 220    (*core->destroyContext) (pcp->driContext);
 221
 222    Xfree(pcp);
 223 }
 224
 225 static Bool
 226 driBindContext(__GLXDRIcontext * context,
 227                __GLXDRIdrawable * draw, __GLXDRIdrawable * read)
 228 {
 229    __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
 230    const __DRIcoreExtension *core = pcp->psc->core;
 231
 232    return (*core->bindContext) (pcp->driContext,
 233                                 draw->driDrawable, read->driDrawable);
 234 }
 235
 236 static void
 237 driUnbindContext(__GLXDRIcontext * context)
 238 {
 239    __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
 240    const __DRIcoreExtension *core = pcp->psc->core;
 241
 242    (*core->unbindContext) (pcp->driContext);
 243 }
 244
 245 static __GLXDRIcontext *
 246 driCreateContext(__GLXscreenConfigs * psc,
 247                  const __GLcontextModes * mode,
 248                  GLXContext gc, GLXContext shareList, int renderType)
 249 {
 250    __GLXDRIcontextPrivate *pcp, *pcp_shared;
 251    __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) mode;
 252    const __DRIcoreExtension *core;
 253    __DRIcontext *shared = NULL;
 254
 255    if (!psc || !psc->driScreen)
 256       return NULL;
 257
 258    core = psc->core;
 259
 260    if (shareList) {
 261       pcp_shared = (__GLXDRIcontextPrivate *) shareList->driContext;
 262       shared = pcp_shared->driContext;
 263    }
 264
 265    pcp = Xmalloc(sizeof *pcp);
 266    if (pcp == NULL)
 267       return NULL;
 268
 269    pcp->psc = psc;
 270    pcp->driContext =
 271       (*core->createNewContext) (psc->__driScreen,
 272                                  config->driConfig, shared, pcp);
 273    if (pcp->driContext == NULL) {
 274       Xfree(pcp);
 275       return NULL;
 276    }
 277
 278    pcp->base.destroyContext = driDestroyContext;
 279    pcp->base.bindContext = driBindContext;
 280    pcp->base.unbindContext = driUnbindContext;
 281
 282    return &pcp->base;
 283 }
 284
 285 static void
 286 driDestroyDrawable(__GLXDRIdrawable * pdraw)
 287 {
 288    __GLXDRIdrawablePrivate *pdp = (__GLXDRIdrawablePrivate *) pdraw;
 289    const __DRIcoreExtension *core = pdraw->psc->core;
 290
 291    (*core->destroyDrawable) (pdraw->driDrawable);
 292
 293    XDestroyDrawable(pdp, pdraw->psc->dpy, pdraw->drawable);
 294    Xfree(pdp);
 295 }
 296
 297 static __GLXDRIdrawable *
 298 driCreateDrawable(__GLXscreenConfigs * psc,
 299                   XID xDrawable,
 300                   GLXDrawable drawable, const __GLcontextModes * modes)
 301 {
 302    __GLXDRIdrawable *pdraw;
 303    __GLXDRIdrawablePrivate *pdp;
 304    __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes;
 305    const __DRIswrastExtension *swrast = psc->swrast;
 306
 307    /* Old dri can't handle GLX 1.3+ drawable constructors. */
 308    if (xDrawable != drawable)
 309       return NULL;
 310
 311    pdp = Xmalloc(sizeof(*pdp));
 312    if (!pdp)
 313       return NULL;
 314
 315    pdraw = &(pdp->base);
 316    pdraw->xDrawable = xDrawable;
 317    pdraw->drawable = drawable;
 318    pdraw->psc = psc;
 319
 320    XCreateDrawable(pdp, psc->dpy, xDrawable, modes->visualID);
 321
 322    /* Create a new drawable */
 323    pdraw->driDrawable =
 324       (*swrast->createNewDrawable) (psc->__driScreen, config->driConfig, pdp);
 325
 326    if (!pdraw->driDrawable) {
 327       XDestroyDrawable(pdp, psc->dpy, xDrawable);
 328       Xfree(pdp);
 329       return NULL;
 330    }
 331
 332    pdraw->destroyDrawable = driDestroyDrawable;
 333
 334    return pdraw;
 335 }
 336
 337 static int64_t
 338 driSwapBuffers(__GLXDRIdrawable * pdraw,
 339                int64_t target_msc, int64_t divisor, int64_t remainder)
 340 {
 341    (void) target_msc;
 342    (void) divisor;
 343    (void) remainder;
 344
 345    (*pdraw->psc->core->swapBuffers) (pdraw->driDrawable);
 346
 347    return 0;
 348 }
 349
 350 static void
 351 driDestroyScreen(__GLXscreenConfigs * psc)
 352 {
 353    /* Free the direct rendering per screen data */
 354    (*psc->core->destroyScreen) (psc->__driScreen);
 355    psc->__driScreen = NULL;
 356    if (psc->driver)
 357       dlclose(psc->driver);
 358 }
 359
 360 static __GLXDRIscreen *
 361 driCreateScreen(__GLXscreenConfigs * psc, int screen,
 362                 __GLXdisplayPrivate * priv)
 363 {
 364    __GLXDRIscreen *psp;
 365    const __DRIconfig **driver_configs;
 366    const __DRIextension **extensions;
 367    const char *driverName = "swrast";
 368    int i;
 369
 370    psp = Xcalloc(1, sizeof *psp);
 371    if (psp == NULL)
 372       return NULL;
 373
 374    psc->driver = driOpenDriver(driverName);
 375    if (psc->driver == NULL)
 376       goto handle_error;
 377
 378    extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
 379    if (extensions == NULL) {
 380       ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
 381       goto handle_error;
 382    }
 383
 384    for (i = 0; extensions[i]; i++) {
 385       if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
 386          psc->core = (__DRIcoreExtension *) extensions[i];
 387       if (strcmp(extensions[i]->name, __DRI_SWRAST) == 0)
 388          psc->swrast = (__DRIswrastExtension *) extensions[i];
 389    }
 390
 391    if (psc->core == NULL || psc->swrast == NULL) {
 392       ErrorMessageF("core dri extension not found\n");
 393       goto handle_error;
 394    }
 395
 396    psc->__driScreen =
 397       psc->swrast->createNewScreen(screen,
 398                                    loader_extensions, &driver_configs, psc);
 399    if (psc->__driScreen == NULL) {
 400       ErrorMessageF("failed to create dri screen\n");
 401       goto handle_error;
 402    }
 403
 404    driBindExtensions(psc);
 405    driBindCommonExtensions(psc);
 406
 407    psc->configs = driConvertConfigs(psc->core, psc->configs, driver_configs);
 408    psc->visuals = driConvertConfigs(psc->core, psc->visuals, driver_configs);
 409
 410    psc->driver_configs = driver_configs;
 411
 412    psp->destroyScreen = driDestroyScreen;
 413    psp->createContext = driCreateContext;
 414    psp->createDrawable = driCreateDrawable;
 415    psp->swapBuffers = driSwapBuffers;
 416    psp->waitX = NULL;
 417    psp->waitGL = NULL;
 418
 419    return psp;
 420
 421  handle_error:
 422    Xfree(psp);
 423
 424    if (psc->driver)
 425       dlclose(psc->driver);
 426
 427    ErrorMessageF("reverting to indirect rendering\n");
 428
 429    return NULL;
 430 }
 431
 432 /* Called from __glXFreeDisplayPrivate.
 433  */
 434 static void
 435 driDestroyDisplay(__GLXDRIdisplay * dpy)
 436 {
 437    Xfree(dpy);
 438 }
 439
 440 /*
 441  * Allocate, initialize and return a __DRIdisplayPrivate object.
 442  * This is called from __glXInitialize() when we are given a new
 443  * display pointer.
 444  */
 445 _X_HIDDEN __GLXDRIdisplay *
 446 driswCreateDisplay(Display * dpy)
 447 {
 448    __GLXDRIdisplayPrivate *pdpyp;
 449
 450    pdpyp = Xmalloc(sizeof *pdpyp);
 451    if (pdpyp == NULL)
 452       return NULL;
 453
 454    pdpyp->base.destroyDisplay = driDestroyDisplay;
 455    pdpyp->base.createScreen = driCreateScreen;
 456
 457    return &pdpyp->base;
 458 }
 459
 460 #endif /* GLX_DIRECT_RENDERING */