drisw_glx.c revision 55e763c86da1aa2042d50d190d797574d6fb6fa8
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#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 25 26#include <X11/Xlib.h> 27#include "glxclient.h" 28#include <dlfcn.h> 29#include "dri_common.h" 30 31struct drisw_display 32{ 33 __GLXDRIdisplay base; 34}; 35 36struct drisw_context 37{ 38 struct glx_context base; 39 __DRIcontext *driContext; 40 41}; 42 43struct drisw_screen 44{ 45 struct glx_screen base; 46 47 __DRIscreen *driScreen; 48 __GLXDRIscreen vtable; 49 const __DRIcoreExtension *core; 50 const __DRIswrastExtension *swrast; 51 const __DRItexBufferExtension *texBuffer; 52 53 const __DRIconfig **driver_configs; 54 55 void *driver; 56}; 57 58struct drisw_drawable 59{ 60 __GLXDRIdrawable base; 61 62 GC gc; 63 GC swapgc; 64 65 __DRIdrawable *driDrawable; 66 XVisualInfo *visinfo; 67 XImage *ximage; 68}; 69 70static Bool 71XCreateDrawable(struct drisw_drawable * pdp, 72 Display * dpy, XID drawable, int visualid) 73{ 74 XGCValues gcvalues; 75 long visMask; 76 XVisualInfo visTemp; 77 int num_visuals; 78 79 /* create GC's */ 80 pdp->gc = XCreateGC(dpy, drawable, 0, NULL); 81 pdp->swapgc = XCreateGC(dpy, drawable, 0, NULL); 82 83 gcvalues.function = GXcopy; 84 gcvalues.graphics_exposures = False; 85 XChangeGC(dpy, pdp->gc, GCFunction, &gcvalues); 86 XChangeGC(dpy, pdp->swapgc, GCFunction, &gcvalues); 87 XChangeGC(dpy, pdp->swapgc, GCGraphicsExposures, &gcvalues); 88 89 /* visual */ 90 visTemp.screen = DefaultScreen(dpy); 91 visTemp.visualid = visualid; 92 visMask = (VisualScreenMask | VisualIDMask); 93 pdp->visinfo = XGetVisualInfo(dpy, visMask, &visTemp, &num_visuals); 94 95 /* create XImage */ 96 pdp->ximage = XCreateImage(dpy, 97 pdp->visinfo->visual, 98 pdp->visinfo->depth, 99 ZPixmap, 0, /* format, offset */ 100 NULL, /* data */ 101 0, 0, /* width, height */ 102 32, /* bitmap_pad */ 103 0); /* bytes_per_line */ 104 105 /** 106 * swrast does not handle 24-bit depth with 24 bpp, so let X do the 107 * the conversion for us. 108 */ 109 if (pdp->ximage->bits_per_pixel == 24) 110 pdp->ximage->bits_per_pixel = 32; 111 112 return True; 113} 114 115static void 116XDestroyDrawable(struct drisw_drawable * pdp, Display * dpy, XID drawable) 117{ 118 XDestroyImage(pdp->ximage); 119 XFree(pdp->visinfo); 120 121 XFreeGC(dpy, pdp->gc); 122 XFreeGC(dpy, pdp->swapgc); 123} 124 125/** 126 * swrast loader functions 127 */ 128 129static void 130swrastGetDrawableInfo(__DRIdrawable * draw, 131 int *x, int *y, int *w, int *h, 132 void *loaderPrivate) 133{ 134 struct drisw_drawable *pdp = loaderPrivate; 135 __GLXDRIdrawable *pdraw = &(pdp->base); 136 Display *dpy = pdraw->psc->dpy; 137 Drawable drawable; 138 139 Window root; 140 unsigned uw, uh, bw, depth; 141 142 drawable = pdraw->xDrawable; 143 144 XGetGeometry(dpy, drawable, &root, x, y, &uw, &uh, &bw, &depth); 145 *w = uw; 146 *h = uh; 147} 148 149/** 150 * Align renderbuffer pitch. 151 * 152 * This should be chosen by the driver and the loader (libGL, xserver/glx) 153 * should use the driver provided pitch. 154 * 155 * It seems that the xorg loader (that is the xserver loading swrast_dri for 156 * indirect rendering, not client-side libGL) requires that the pitch is 157 * exactly the image width padded to 32 bits. XXX 158 * 159 * The above restriction can probably be overcome by using ScratchPixmap and 160 * CopyArea in the xserver, similar to ShmPutImage, and setting the width of 161 * the scratch pixmap to 'pitch / cpp'. 162 */ 163static inline int 164bytes_per_line(unsigned pitch_bits, unsigned mul) 165{ 166 unsigned mask = mul - 1; 167 168 return ((pitch_bits + mask) & ~mask) / 8; 169} 170 171static void 172swrastPutImage(__DRIdrawable * draw, int op, 173 int x, int y, int w, int h, 174 char *data, void *loaderPrivate) 175{ 176 struct drisw_drawable *pdp = loaderPrivate; 177 __GLXDRIdrawable *pdraw = &(pdp->base); 178 Display *dpy = pdraw->psc->dpy; 179 Drawable drawable; 180 XImage *ximage; 181 GC gc; 182 183 switch (op) { 184 case __DRI_SWRAST_IMAGE_OP_DRAW: 185 gc = pdp->gc; 186 break; 187 case __DRI_SWRAST_IMAGE_OP_SWAP: 188 gc = pdp->swapgc; 189 break; 190 default: 191 return; 192 } 193 194 drawable = pdraw->xDrawable; 195 196 ximage = pdp->ximage; 197 ximage->data = data; 198 ximage->width = w; 199 ximage->height = h; 200 ximage->bytes_per_line = bytes_per_line(w * ximage->bits_per_pixel, 32); 201 202 XPutImage(dpy, drawable, gc, ximage, 0, 0, x, y, w, h); 203 204 ximage->data = NULL; 205} 206 207static void 208swrastGetImage(__DRIdrawable * read, 209 int x, int y, int w, int h, 210 char *data, void *loaderPrivate) 211{ 212 struct drisw_drawable *prp = loaderPrivate; 213 __GLXDRIdrawable *pread = &(prp->base); 214 Display *dpy = pread->psc->dpy; 215 Drawable readable; 216 XImage *ximage; 217 218 readable = pread->xDrawable; 219 220 ximage = prp->ximage; 221 ximage->data = data; 222 ximage->width = w; 223 ximage->height = h; 224 ximage->bytes_per_line = bytes_per_line(w * ximage->bits_per_pixel, 32); 225 226 XGetSubImage(dpy, readable, x, y, w, h, ~0L, ZPixmap, ximage, 0, 0); 227 228 ximage->data = NULL; 229} 230 231static const __DRIswrastLoaderExtension swrastLoaderExtension = { 232 {__DRI_SWRAST_LOADER, __DRI_SWRAST_LOADER_VERSION}, 233 swrastGetDrawableInfo, 234 swrastPutImage, 235 swrastGetImage 236}; 237 238static const __DRIextension *loader_extensions[] = { 239 &systemTimeExtension.base, 240 &swrastLoaderExtension.base, 241 NULL 242}; 243 244/** 245 * GLXDRI functions 246 */ 247 248static void 249drisw_destroy_context(struct glx_context *context) 250{ 251 struct drisw_context *pcp = (struct drisw_context *) context; 252 struct drisw_screen *psc = (struct drisw_screen *) context->psc; 253 254 driReleaseDrawables(&pcp->base); 255 256 if (context->xid) 257 glx_send_destroy_context(psc->base.dpy, context->xid); 258 259 if (context->extensions) 260 XFree((char *) context->extensions); 261 262 (*psc->core->destroyContext) (pcp->driContext); 263 264 Xfree(pcp); 265} 266 267static int 268drisw_bind_context(struct glx_context *context, struct glx_context *old, 269 GLXDrawable draw, GLXDrawable read) 270{ 271 struct drisw_context *pcp = (struct drisw_context *) context; 272 struct drisw_screen *psc = (struct drisw_screen *) pcp->base.psc; 273 struct drisw_drawable *pdraw, *pread; 274 275 pdraw = (struct drisw_drawable *) driFetchDrawable(context, draw); 276 pread = (struct drisw_drawable *) driFetchDrawable(context, read); 277 278 driReleaseDrawables(&pcp->base); 279 280 if (pdraw == NULL || pread == NULL) 281 return GLXBadDrawable; 282 283 if ((*psc->core->bindContext) (pcp->driContext, 284 pdraw->driDrawable, pread->driDrawable)) 285 return Success; 286 287 return GLXBadContext; 288} 289 290static void 291drisw_unbind_context(struct glx_context *context, struct glx_context *new) 292{ 293 struct drisw_context *pcp = (struct drisw_context *) context; 294 struct drisw_screen *psc = (struct drisw_screen *) pcp->base.psc; 295 296 (*psc->core->unbindContext) (pcp->driContext); 297} 298 299static void 300drisw_bind_tex_image(Display * dpy, 301 GLXDrawable drawable, 302 int buffer, const int *attrib_list) 303{ 304 struct glx_context *gc = __glXGetCurrentContext(); 305 struct drisw_context *pcp = (struct drisw_context *) gc; 306 __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable); 307 struct glx_display *dpyPriv = __glXInitialize(dpy); 308 struct drisw_drawable *pdraw = (struct drisw_drawable *) base; 309 struct drisw_screen *psc; 310 311 if (pdraw != NULL) { 312 psc = (struct drisw_screen *) base->psc; 313 314 if (!psc->texBuffer) 315 return; 316 317 if (psc->texBuffer->base.version >= 2 && 318 psc->texBuffer->setTexBuffer2 != NULL) { 319 (*psc->texBuffer->setTexBuffer2) (pcp->driContext, 320 pdraw->base.textureTarget, 321 pdraw->base.textureFormat, 322 pdraw->driDrawable); 323 } 324 else { 325 (*psc->texBuffer->setTexBuffer) (pcp->driContext, 326 pdraw->base.textureTarget, 327 pdraw->driDrawable); 328 } 329 } 330} 331 332static void 333drisw_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer) 334{ 335#if __DRI_TEX_BUFFER_VERSION >= 3 336 struct glx_context *gc = __glXGetCurrentContext(); 337 struct dri2_context *pcp = (struct dri2_context *) gc; 338 __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable); 339 struct glx_display *dpyPriv = __glXInitialize(dpy); 340 struct dri2_drawable *pdraw = (struct dri2_drawable *) base; 341 struct dri2_screen *psc; 342 343 if (pdraw != NULL) { 344 psc = (struct dri2_screen *) base->psc; 345 346 if (!psc->texBuffer) 347 return; 348 349 if (psc->texBuffer->base.version >= 3 && 350 psc->texBuffer->releaseTexBuffer != NULL) { 351 (*psc->texBuffer->releaseTexBuffer) (pcp->driContext, 352 pdraw->base.textureTarget, 353 pdraw->driDrawable); 354 } 355 } 356#endif 357} 358 359static const struct glx_context_vtable drisw_context_vtable = { 360 drisw_destroy_context, 361 drisw_bind_context, 362 drisw_unbind_context, 363 NULL, 364 NULL, 365 DRI_glXUseXFont, 366 drisw_bind_tex_image, 367 drisw_release_tex_image, 368 NULL, /* get_proc_address */ 369}; 370 371static struct glx_context * 372drisw_create_context(struct glx_screen *base, 373 struct glx_config *config_base, 374 struct glx_context *shareList, int renderType) 375{ 376 struct drisw_context *pcp, *pcp_shared; 377 __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base; 378 struct drisw_screen *psc = (struct drisw_screen *) base; 379 __DRIcontext *shared = NULL; 380 381 if (!psc->base.driScreen) 382 return NULL; 383 384 if (shareList) { 385 pcp_shared = (struct drisw_context *) shareList; 386 shared = pcp_shared->driContext; 387 } 388 389 pcp = Xmalloc(sizeof *pcp); 390 if (pcp == NULL) 391 return NULL; 392 393 memset(pcp, 0, sizeof *pcp); 394 if (!glx_context_init(&pcp->base, &psc->base, &config->base)) { 395 Xfree(pcp); 396 return NULL; 397 } 398 399 pcp->driContext = 400 (*psc->core->createNewContext) (psc->driScreen, 401 config->driConfig, shared, pcp); 402 if (pcp->driContext == NULL) { 403 Xfree(pcp); 404 return NULL; 405 } 406 407 pcp->base.vtable = &drisw_context_vtable; 408 409 return &pcp->base; 410} 411 412static void 413driswDestroyDrawable(__GLXDRIdrawable * pdraw) 414{ 415 struct drisw_drawable *pdp = (struct drisw_drawable *) pdraw; 416 struct drisw_screen *psc = (struct drisw_screen *) pdp->base.psc; 417 418 (*psc->core->destroyDrawable) (pdp->driDrawable); 419 420 XDestroyDrawable(pdp, pdraw->psc->dpy, pdraw->drawable); 421 Xfree(pdp); 422} 423 424static __GLXDRIdrawable * 425driswCreateDrawable(struct glx_screen *base, XID xDrawable, 426 GLXDrawable drawable, struct glx_config *modes) 427{ 428 struct drisw_drawable *pdp; 429 __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes; 430 struct drisw_screen *psc = (struct drisw_screen *) base; 431 432 const __DRIswrastExtension *swrast = psc->swrast; 433 434 pdp = Xmalloc(sizeof(*pdp)); 435 if (!pdp) 436 return NULL; 437 438 memset(pdp, 0, sizeof *pdp); 439 pdp->base.xDrawable = xDrawable; 440 pdp->base.drawable = drawable; 441 pdp->base.psc = &psc->base; 442 443 XCreateDrawable(pdp, psc->base.dpy, xDrawable, modes->visualID); 444 445 /* Create a new drawable */ 446 pdp->driDrawable = 447 (*swrast->createNewDrawable) (psc->driScreen, config->driConfig, pdp); 448 449 if (!pdp->driDrawable) { 450 XDestroyDrawable(pdp, psc->base.dpy, xDrawable); 451 Xfree(pdp); 452 return NULL; 453 } 454 455 pdp->base.destroyDrawable = driswDestroyDrawable; 456 457 return &pdp->base; 458} 459 460static int64_t 461driswSwapBuffers(__GLXDRIdrawable * pdraw, 462 int64_t target_msc, int64_t divisor, int64_t remainder) 463{ 464 struct drisw_drawable *pdp = (struct drisw_drawable *) pdraw; 465 struct drisw_screen *psc = (struct drisw_screen *) pdp->base.psc; 466 467 (void) target_msc; 468 (void) divisor; 469 (void) remainder; 470 471 (*psc->core->swapBuffers) (pdp->driDrawable); 472 473 return 0; 474} 475 476static void 477driswDestroyScreen(struct glx_screen *base) 478{ 479 struct drisw_screen *psc = (struct drisw_screen *) base; 480 481 /* Free the direct rendering per screen data */ 482 (*psc->core->destroyScreen) (psc->driScreen); 483 driDestroyConfigs(psc->driver_configs); 484 psc->driScreen = NULL; 485 if (psc->driver) 486 dlclose(psc->driver); 487} 488 489static void * 490driOpenSwrast(void) 491{ 492 void *driver = NULL; 493 494 if (driver == NULL) 495 driver = driOpenDriver("swrast"); 496 497 return driver; 498} 499 500static const struct glx_screen_vtable drisw_screen_vtable = { 501 drisw_create_context 502}; 503 504static void 505driswBindExtensions(struct drisw_screen *psc, const __DRIextension **extensions) 506{ 507 int i; 508 509 /* FIXME: Figure out what other extensions can be ported here from dri2. */ 510 for (i = 0; extensions[i]; i++) { 511 if ((strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0)) { 512 psc->texBuffer = (__DRItexBufferExtension *) extensions[i]; 513 __glXEnableDirectExtension(&psc->base, "GLX_EXT_texture_from_pixmap"); 514 } 515 } 516} 517 518static struct glx_screen * 519driswCreateScreen(int screen, struct glx_display *priv) 520{ 521 __GLXDRIscreen *psp; 522 const __DRIconfig **driver_configs; 523 const __DRIextension **extensions; 524 struct drisw_screen *psc; 525 int i; 526 527 psc = Xcalloc(1, sizeof *psc); 528 if (psc == NULL) 529 return NULL; 530 531 memset(psc, 0, sizeof *psc); 532 if (!glx_screen_init(&psc->base, screen, priv)) { 533 Xfree(psc); 534 return NULL; 535 } 536 537 psc->driver = driOpenSwrast(); 538 if (psc->driver == NULL) 539 goto handle_error; 540 541 extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS); 542 if (extensions == NULL) { 543 ErrorMessageF("driver exports no extensions (%s)\n", dlerror()); 544 goto handle_error; 545 } 546 547 for (i = 0; extensions[i]; i++) { 548 if (strcmp(extensions[i]->name, __DRI_CORE) == 0) 549 psc->core = (__DRIcoreExtension *) extensions[i]; 550 if (strcmp(extensions[i]->name, __DRI_SWRAST) == 0) 551 psc->swrast = (__DRIswrastExtension *) extensions[i]; 552 } 553 554 if (psc->core == NULL || psc->swrast == NULL) { 555 ErrorMessageF("core dri extension not found\n"); 556 goto handle_error; 557 } 558 559 psc->driScreen = 560 psc->swrast->createNewScreen(screen, loader_extensions, 561 &driver_configs, psc); 562 if (psc->driScreen == NULL) { 563 ErrorMessageF("failed to create dri screen\n"); 564 goto handle_error; 565 } 566 567 extensions = psc->core->getExtensions(psc->driScreen); 568 driswBindExtensions(psc, extensions); 569 570 psc->base.configs = 571 driConvertConfigs(psc->core, psc->base.configs, driver_configs); 572 psc->base.visuals = 573 driConvertConfigs(psc->core, psc->base.visuals, driver_configs); 574 575 psc->driver_configs = driver_configs; 576 577 psc->base.vtable = &drisw_screen_vtable; 578 psp = &psc->vtable; 579 psc->base.driScreen = psp; 580 psp->destroyScreen = driswDestroyScreen; 581 psp->createDrawable = driswCreateDrawable; 582 psp->swapBuffers = driswSwapBuffers; 583 584 return &psc->base; 585 586 handle_error: 587 if (psc->driver) 588 dlclose(psc->driver); 589 glx_screen_cleanup(&psc->base); 590 Xfree(psc); 591 592 ErrorMessageF("reverting to indirect rendering\n"); 593 594 return NULL; 595} 596 597/* Called from __glXFreeDisplayPrivate. 598 */ 599static void 600driswDestroyDisplay(__GLXDRIdisplay * dpy) 601{ 602 Xfree(dpy); 603} 604 605/* 606 * Allocate, initialize and return a __DRIdisplayPrivate object. 607 * This is called from __glXInitialize() when we are given a new 608 * display pointer. 609 */ 610_X_HIDDEN __GLXDRIdisplay * 611driswCreateDisplay(Display * dpy) 612{ 613 struct drisw_display *pdpyp; 614 615 pdpyp = Xmalloc(sizeof *pdpyp); 616 if (pdpyp == NULL) 617 return NULL; 618 619 pdpyp->base.destroyDisplay = driswDestroyDisplay; 620 pdpyp->base.createScreen = driswCreateScreen; 621 622 return &pdpyp->base; 623} 624 625#endif /* GLX_DIRECT_RENDERING */ 626