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