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