801ac7d470bc19559f82b010e6f41beb0d996084
[mesa.git] / 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 #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
31 struct drisw_display
32 {
33 __GLXDRIdisplay base;
34 };
35
36 struct drisw_context
37 {
38 struct glx_context base;
39 __DRIcontext *driContext;
40
41 };
42
43 struct 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
58 struct 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
70 static Bool
71 XCreateDrawable(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
115 static void
116 XDestroyDrawable(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
129 static void
130 swrastGetDrawableInfo(__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 */
163 static inline int
164 bytes_per_line(unsigned pitch_bits, unsigned mul)
165 {
166 unsigned mask = mul - 1;
167
168 return ((pitch_bits + mask) & ~mask) / 8;
169 }
170
171 static void
172 swrastPutImage(__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
207 static void
208 swrastGetImage(__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
231 static const __DRIswrastLoaderExtension swrastLoaderExtension = {
232 {__DRI_SWRAST_LOADER, __DRI_SWRAST_LOADER_VERSION},
233 swrastGetDrawableInfo,
234 swrastPutImage,
235 swrastGetImage
236 };
237
238 static const __DRIextension *loader_extensions[] = {
239 &systemTimeExtension.base,
240 &swrastLoaderExtension.base,
241 NULL
242 };
243
244 /**
245 * GLXDRI functions
246 */
247
248 static void
249 drisw_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
267 static int
268 drisw_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
290 static void
291 drisw_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
299 static void
300 drisw_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 drisw_drawable *pdraw = (struct drisw_drawable *) base;
308 struct drisw_screen *psc;
309
310 __glXInitialize(dpy);
311
312 if (pdraw != NULL) {
313 psc = (struct drisw_screen *) base->psc;
314
315 if (!psc->texBuffer)
316 return;
317
318 if (psc->texBuffer->base.version >= 2 &&
319 psc->texBuffer->setTexBuffer2 != NULL) {
320 (*psc->texBuffer->setTexBuffer2) (pcp->driContext,
321 pdraw->base.textureTarget,
322 pdraw->base.textureFormat,
323 pdraw->driDrawable);
324 }
325 else {
326 (*psc->texBuffer->setTexBuffer) (pcp->driContext,
327 pdraw->base.textureTarget,
328 pdraw->driDrawable);
329 }
330 }
331 }
332
333 static void
334 drisw_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer)
335 {
336 #if __DRI_TEX_BUFFER_VERSION >= 3
337 struct glx_context *gc = __glXGetCurrentContext();
338 struct dri2_context *pcp = (struct dri2_context *) gc;
339 __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
340 struct glx_display *dpyPriv = __glXInitialize(dpy);
341 struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
342 struct dri2_screen *psc;
343
344 if (pdraw != NULL) {
345 psc = (struct dri2_screen *) base->psc;
346
347 if (!psc->texBuffer)
348 return;
349
350 if (psc->texBuffer->base.version >= 3 &&
351 psc->texBuffer->releaseTexBuffer != NULL) {
352 (*psc->texBuffer->releaseTexBuffer) (pcp->driContext,
353 pdraw->base.textureTarget,
354 pdraw->driDrawable);
355 }
356 }
357 #endif
358 }
359
360 static const struct glx_context_vtable drisw_context_vtable = {
361 drisw_destroy_context,
362 drisw_bind_context,
363 drisw_unbind_context,
364 NULL,
365 NULL,
366 DRI_glXUseXFont,
367 drisw_bind_tex_image,
368 drisw_release_tex_image,
369 NULL, /* get_proc_address */
370 };
371
372 static struct glx_context *
373 drisw_create_context(struct glx_screen *base,
374 struct glx_config *config_base,
375 struct glx_context *shareList, int renderType)
376 {
377 struct drisw_context *pcp, *pcp_shared;
378 __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
379 struct drisw_screen *psc = (struct drisw_screen *) base;
380 __DRIcontext *shared = NULL;
381
382 if (!psc->base.driScreen)
383 return NULL;
384
385 if (shareList) {
386 /* If the shareList context is not a DRISW context, we cannot possibly
387 * create a DRISW context that shares it.
388 */
389 if (shareList->vtable->destroy != drisw_destroy_context) {
390 return NULL;
391 }
392
393 pcp_shared = (struct drisw_context *) shareList;
394 shared = pcp_shared->driContext;
395 }
396
397 pcp = Xmalloc(sizeof *pcp);
398 if (pcp == NULL)
399 return NULL;
400
401 memset(pcp, 0, sizeof *pcp);
402 if (!glx_context_init(&pcp->base, &psc->base, &config->base)) {
403 Xfree(pcp);
404 return NULL;
405 }
406
407 pcp->driContext =
408 (*psc->core->createNewContext) (psc->driScreen,
409 config->driConfig, shared, pcp);
410 if (pcp->driContext == NULL) {
411 Xfree(pcp);
412 return NULL;
413 }
414
415 pcp->base.vtable = &drisw_context_vtable;
416
417 return &pcp->base;
418 }
419
420 static void
421 driswDestroyDrawable(__GLXDRIdrawable * pdraw)
422 {
423 struct drisw_drawable *pdp = (struct drisw_drawable *) pdraw;
424 struct drisw_screen *psc = (struct drisw_screen *) pdp->base.psc;
425
426 (*psc->core->destroyDrawable) (pdp->driDrawable);
427
428 XDestroyDrawable(pdp, pdraw->psc->dpy, pdraw->drawable);
429 Xfree(pdp);
430 }
431
432 static __GLXDRIdrawable *
433 driswCreateDrawable(struct glx_screen *base, XID xDrawable,
434 GLXDrawable drawable, struct glx_config *modes)
435 {
436 struct drisw_drawable *pdp;
437 __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes;
438 struct drisw_screen *psc = (struct drisw_screen *) base;
439
440 const __DRIswrastExtension *swrast = psc->swrast;
441
442 pdp = Xmalloc(sizeof(*pdp));
443 if (!pdp)
444 return NULL;
445
446 memset(pdp, 0, sizeof *pdp);
447 pdp->base.xDrawable = xDrawable;
448 pdp->base.drawable = drawable;
449 pdp->base.psc = &psc->base;
450
451 XCreateDrawable(pdp, psc->base.dpy, xDrawable, modes->visualID);
452
453 /* Create a new drawable */
454 pdp->driDrawable =
455 (*swrast->createNewDrawable) (psc->driScreen, config->driConfig, pdp);
456
457 if (!pdp->driDrawable) {
458 XDestroyDrawable(pdp, psc->base.dpy, xDrawable);
459 Xfree(pdp);
460 return NULL;
461 }
462
463 pdp->base.destroyDrawable = driswDestroyDrawable;
464
465 return &pdp->base;
466 }
467
468 static int64_t
469 driswSwapBuffers(__GLXDRIdrawable * pdraw,
470 int64_t target_msc, int64_t divisor, int64_t remainder)
471 {
472 struct drisw_drawable *pdp = (struct drisw_drawable *) pdraw;
473 struct drisw_screen *psc = (struct drisw_screen *) pdp->base.psc;
474
475 (void) target_msc;
476 (void) divisor;
477 (void) remainder;
478
479 (*psc->core->swapBuffers) (pdp->driDrawable);
480
481 return 0;
482 }
483
484 static void
485 driswDestroyScreen(struct glx_screen *base)
486 {
487 struct drisw_screen *psc = (struct drisw_screen *) base;
488
489 /* Free the direct rendering per screen data */
490 (*psc->core->destroyScreen) (psc->driScreen);
491 driDestroyConfigs(psc->driver_configs);
492 psc->driScreen = NULL;
493 if (psc->driver)
494 dlclose(psc->driver);
495 }
496
497 static void *
498 driOpenSwrast(void)
499 {
500 void *driver = NULL;
501
502 if (driver == NULL)
503 driver = driOpenDriver("swrast");
504
505 return driver;
506 }
507
508 static const struct glx_screen_vtable drisw_screen_vtable = {
509 drisw_create_context
510 };
511
512 static void
513 driswBindExtensions(struct drisw_screen *psc, const __DRIextension **extensions)
514 {
515 int i;
516
517 __glXEnableDirectExtension(&psc->base, "GLX_SGI_make_current_read");
518
519 /* FIXME: Figure out what other extensions can be ported here from dri2. */
520 for (i = 0; extensions[i]; i++) {
521 if ((strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0)) {
522 psc->texBuffer = (__DRItexBufferExtension *) extensions[i];
523 __glXEnableDirectExtension(&psc->base, "GLX_EXT_texture_from_pixmap");
524 }
525 }
526 }
527
528 static struct glx_screen *
529 driswCreateScreen(int screen, struct glx_display *priv)
530 {
531 __GLXDRIscreen *psp;
532 const __DRIconfig **driver_configs;
533 const __DRIextension **extensions;
534 struct drisw_screen *psc;
535 struct glx_config *configs = NULL, *visuals = NULL;
536 int i;
537
538 psc = Xcalloc(1, sizeof *psc);
539 if (psc == NULL)
540 return NULL;
541
542 memset(psc, 0, sizeof *psc);
543 if (!glx_screen_init(&psc->base, screen, priv)) {
544 Xfree(psc);
545 return NULL;
546 }
547
548 psc->driver = driOpenSwrast();
549 if (psc->driver == NULL)
550 goto handle_error;
551
552 extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
553 if (extensions == NULL) {
554 ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
555 goto handle_error;
556 }
557
558 for (i = 0; extensions[i]; i++) {
559 if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
560 psc->core = (__DRIcoreExtension *) extensions[i];
561 if (strcmp(extensions[i]->name, __DRI_SWRAST) == 0)
562 psc->swrast = (__DRIswrastExtension *) extensions[i];
563 }
564
565 if (psc->core == NULL || psc->swrast == NULL) {
566 ErrorMessageF("core dri extension not found\n");
567 goto handle_error;
568 }
569
570 psc->driScreen =
571 psc->swrast->createNewScreen(screen, loader_extensions,
572 &driver_configs, psc);
573 if (psc->driScreen == NULL) {
574 ErrorMessageF("failed to create dri screen\n");
575 goto handle_error;
576 }
577
578 extensions = psc->core->getExtensions(psc->driScreen);
579 driswBindExtensions(psc, extensions);
580
581 configs = driConvertConfigs(psc->core, psc->base.configs, driver_configs);
582 visuals = driConvertConfigs(psc->core, psc->base.visuals, driver_configs);
583
584 if (!configs || !visuals)
585 goto handle_error;
586
587 glx_config_destroy_list(psc->base.configs);
588 psc->base.configs = configs;
589 glx_config_destroy_list(psc->base.visuals);
590 psc->base.visuals = visuals;
591
592 psc->driver_configs = driver_configs;
593
594 psc->base.vtable = &drisw_screen_vtable;
595 psp = &psc->vtable;
596 psc->base.driScreen = psp;
597 psp->destroyScreen = driswDestroyScreen;
598 psp->createDrawable = driswCreateDrawable;
599 psp->swapBuffers = driswSwapBuffers;
600
601 return &psc->base;
602
603 handle_error:
604 if (configs)
605 glx_config_destroy_list(configs);
606 if (visuals)
607 glx_config_destroy_list(visuals);
608 if (psc->driScreen)
609 psc->core->destroyScreen(psc->driScreen);
610 psc->driScreen = NULL;
611
612 if (psc->driver)
613 dlclose(psc->driver);
614 glx_screen_cleanup(&psc->base);
615 Xfree(psc);
616
617 ErrorMessageF("reverting to indirect rendering\n");
618
619 return NULL;
620 }
621
622 /* Called from __glXFreeDisplayPrivate.
623 */
624 static void
625 driswDestroyDisplay(__GLXDRIdisplay * dpy)
626 {
627 Xfree(dpy);
628 }
629
630 /*
631 * Allocate, initialize and return a __DRIdisplayPrivate object.
632 * This is called from __glXInitialize() when we are given a new
633 * display pointer.
634 */
635 _X_HIDDEN __GLXDRIdisplay *
636 driswCreateDisplay(Display * dpy)
637 {
638 struct drisw_display *pdpyp;
639
640 pdpyp = Xmalloc(sizeof *pdpyp);
641 if (pdpyp == NULL)
642 return NULL;
643
644 pdpyp->base.destroyDisplay = driswDestroyDisplay;
645 pdpyp->base.createScreen = driswCreateScreen;
646
647 return &pdpyp->base;
648 }
649
650 #endif /* GLX_DIRECT_RENDERING */