native_ximage.c revision f22665df95406567193dee0089f4830664ff4101 
1/*
2 * Mesa 3-D graphics library
3 * Version:  7.8
4 *
5 * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org>
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
24 */
25
26#include <X11/Xlib.h>
27#include <X11/Xutil.h>
28#include "util/u_memory.h"
29#include "util/u_math.h"
30#include "util/u_format.h"
31#include "pipe/p_compiler.h"
32#include "util/u_inlines.h"
33#include "state_tracker/xlib_sw_winsys.h"
34#include "util/u_debug.h"
35#include "egllog.h"
36
37#include "common/native_helper.h"
38#include "native_x11.h"
39#include "x11_screen.h"
40
41enum ximage_surface_type {
42   XIMAGE_SURFACE_TYPE_WINDOW,
43   XIMAGE_SURFACE_TYPE_PIXMAP,
44};
45
46struct ximage_display {
47   struct native_display base;
48   Display *dpy;
49   boolean own_dpy;
50
51   struct native_event_handler *event_handler;
52
53   struct x11_screen *xscr;
54   int xscr_number;
55
56   struct ximage_config *configs;
57   int num_configs;
58};
59
60struct ximage_surface {
61   struct native_surface base;
62   Drawable drawable;
63   enum ximage_surface_type type;
64   enum pipe_format color_format;
65   XVisualInfo visual;
66   struct ximage_display *xdpy;
67
68   unsigned int server_stamp;
69   unsigned int client_stamp;
70
71   struct resource_surface *rsurf;
72   struct xlib_drawable xdraw;
73};
74
75struct ximage_config {
76   struct native_config base;
77   const XVisualInfo *visual;
78};
79
80static INLINE struct ximage_display *
81ximage_display(const struct native_display *ndpy)
82{
83   return (struct ximage_display *) ndpy;
84}
85
86static INLINE struct ximage_surface *
87ximage_surface(const struct native_surface *nsurf)
88{
89   return (struct ximage_surface *) nsurf;
90}
91
92static INLINE struct ximage_config *
93ximage_config(const struct native_config *nconf)
94{
95   return (struct ximage_config *) nconf;
96}
97
98/**
99 * Update the geometry of the surface.  This is a slow functions.
100 */
101static void
102ximage_surface_update_geometry(struct native_surface *nsurf)
103{
104   struct ximage_surface *xsurf = ximage_surface(nsurf);
105   Status ok;
106   Window root;
107   int x, y;
108   unsigned int w, h, border, depth;
109
110   ok = XGetGeometry(xsurf->xdpy->dpy, xsurf->drawable,
111         &root, &x, &y, &w, &h, &border, &depth);
112   if (ok && resource_surface_set_size(xsurf->rsurf, w, h))
113      xsurf->server_stamp++;
114}
115
116/**
117 * Update the buffers of the surface.
118 */
119static boolean
120ximage_surface_update_buffers(struct native_surface *nsurf, uint buffer_mask)
121{
122   struct ximage_surface *xsurf = ximage_surface(nsurf);
123
124   if (xsurf->client_stamp != xsurf->server_stamp) {
125      ximage_surface_update_geometry(&xsurf->base);
126      xsurf->client_stamp = xsurf->server_stamp;
127   }
128
129   return resource_surface_add_resources(xsurf->rsurf, buffer_mask);
130}
131
132/**
133 * Emulate an invalidate event.
134 */
135static void
136ximage_surface_invalidate(struct native_surface *nsurf)
137{
138   struct ximage_surface *xsurf = ximage_surface(nsurf);
139   struct ximage_display *xdpy = xsurf->xdpy;
140
141   xsurf->server_stamp++;
142   xdpy->event_handler->invalid_surface(&xdpy->base,
143         &xsurf->base, xsurf->server_stamp);
144}
145
146static boolean
147ximage_surface_flush_frontbuffer(struct native_surface *nsurf)
148{
149   struct ximage_surface *xsurf = ximage_surface(nsurf);
150   boolean ret;
151
152   ret = resource_surface_present(xsurf->rsurf,
153         NATIVE_ATTACHMENT_FRONT_LEFT, (void *) &xsurf->xdraw);
154   /* force buffers to be updated in next validation call */
155   ximage_surface_invalidate(&xsurf->base);
156
157   return ret;
158}
159
160static boolean
161ximage_surface_swap_buffers(struct native_surface *nsurf)
162{
163   struct ximage_surface *xsurf = ximage_surface(nsurf);
164   boolean ret;
165
166   ret = resource_surface_present(xsurf->rsurf,
167         NATIVE_ATTACHMENT_BACK_LEFT, (void *) &xsurf->xdraw);
168
169   resource_surface_swap_buffers(xsurf->rsurf,
170         NATIVE_ATTACHMENT_FRONT_LEFT, NATIVE_ATTACHMENT_BACK_LEFT, TRUE);
171   /* the front/back buffers have been swapped */
172   ximage_surface_invalidate(&xsurf->base);
173
174   return ret;
175}
176
177static boolean
178ximage_surface_validate(struct native_surface *nsurf, uint attachment_mask,
179                        unsigned int *seq_num, struct pipe_resource **textures,
180                        int *width, int *height)
181{
182   struct ximage_surface *xsurf = ximage_surface(nsurf);
183   uint w, h;
184
185   if (!ximage_surface_update_buffers(&xsurf->base, attachment_mask))
186      return FALSE;
187
188   if (seq_num)
189      *seq_num = xsurf->client_stamp;
190
191   if (textures)
192      resource_surface_get_resources(xsurf->rsurf, textures, attachment_mask);
193
194   resource_surface_get_size(xsurf->rsurf, &w, &h);
195   if (width)
196      *width = w;
197   if (height)
198      *height = h;
199
200   return TRUE;
201}
202
203static void
204ximage_surface_wait(struct native_surface *nsurf)
205{
206   struct ximage_surface *xsurf = ximage_surface(nsurf);
207   XSync(xsurf->xdpy->dpy, FALSE);
208   /* TODO XGetImage and update the front texture */
209}
210
211static void
212ximage_surface_destroy(struct native_surface *nsurf)
213{
214   struct ximage_surface *xsurf = ximage_surface(nsurf);
215
216   resource_surface_destroy(xsurf->rsurf);
217   FREE(xsurf);
218}
219
220static struct ximage_surface *
221ximage_display_create_surface(struct native_display *ndpy,
222                              enum ximage_surface_type type,
223                              Drawable drawable,
224                              const struct native_config *nconf)
225{
226   struct ximage_display *xdpy = ximage_display(ndpy);
227   struct ximage_config *xconf = ximage_config(nconf);
228   struct ximage_surface *xsurf;
229
230   xsurf = CALLOC_STRUCT(ximage_surface);
231   if (!xsurf)
232      return NULL;
233
234   xsurf->xdpy = xdpy;
235   xsurf->type = type;
236   xsurf->color_format = xconf->base.color_format;
237   xsurf->drawable = drawable;
238
239   xsurf->rsurf = resource_surface_create(xdpy->base.screen,
240         xsurf->color_format,
241         PIPE_BIND_RENDER_TARGET |
242         PIPE_BIND_SAMPLER_VIEW |
243         PIPE_BIND_DISPLAY_TARGET |
244         PIPE_BIND_SCANOUT);
245   if (!xsurf->rsurf) {
246      FREE(xsurf);
247      return NULL;
248   }
249
250   xsurf->drawable = drawable;
251   xsurf->visual = *xconf->visual;
252   /* initialize the geometry */
253   ximage_surface_update_geometry(&xsurf->base);
254
255   xsurf->xdraw.visual = xsurf->visual.visual;
256   xsurf->xdraw.depth = xsurf->visual.depth;
257   xsurf->xdraw.drawable = xsurf->drawable;
258
259   xsurf->base.destroy = ximage_surface_destroy;
260   xsurf->base.swap_buffers = ximage_surface_swap_buffers;
261   xsurf->base.flush_frontbuffer = ximage_surface_flush_frontbuffer;
262   xsurf->base.validate = ximage_surface_validate;
263   xsurf->base.wait = ximage_surface_wait;
264
265   return xsurf;
266}
267
268static struct native_surface *
269ximage_display_create_window_surface(struct native_display *ndpy,
270                                     EGLNativeWindowType win,
271                                     const struct native_config *nconf)
272{
273   struct ximage_surface *xsurf;
274
275   xsurf = ximage_display_create_surface(ndpy, XIMAGE_SURFACE_TYPE_WINDOW,
276         (Drawable) win, nconf);
277   return (xsurf) ? &xsurf->base : NULL;
278}
279
280static struct native_surface *
281ximage_display_create_pixmap_surface(struct native_display *ndpy,
282                                     EGLNativePixmapType pix,
283                                     const struct native_config *nconf)
284{
285   struct ximage_surface *xsurf;
286
287   xsurf = ximage_display_create_surface(ndpy, XIMAGE_SURFACE_TYPE_PIXMAP,
288         (Drawable) pix, nconf);
289   return (xsurf) ? &xsurf->base : NULL;
290}
291
292static enum pipe_format
293choose_format(const XVisualInfo *vinfo)
294{
295   enum pipe_format fmt;
296   /* TODO elaborate the formats */
297   switch (vinfo->depth) {
298   case 32:
299      fmt = PIPE_FORMAT_B8G8R8A8_UNORM;
300      break;
301   case 24:
302      fmt = PIPE_FORMAT_B8G8R8X8_UNORM;
303      break;
304   case 16:
305      fmt = PIPE_FORMAT_B5G6R5_UNORM;
306      break;
307   default:
308      fmt = PIPE_FORMAT_NONE;
309      break;
310   }
311
312   return fmt;
313}
314
315static const struct native_config **
316ximage_display_get_configs(struct native_display *ndpy, int *num_configs)
317{
318   struct ximage_display *xdpy = ximage_display(ndpy);
319   const struct native_config **configs;
320   int i;
321
322   /* first time */
323   if (!xdpy->configs) {
324      const XVisualInfo *visuals;
325      int num_visuals, count;
326
327      visuals = x11_screen_get_visuals(xdpy->xscr, &num_visuals);
328      if (!visuals)
329         return NULL;
330
331      /*
332       * Create two configs for each visual.
333       * One with depth/stencil buffer; one without
334       */
335      xdpy->configs = CALLOC(num_visuals * 2, sizeof(*xdpy->configs));
336      if (!xdpy->configs)
337         return NULL;
338
339      count = 0;
340      for (i = 0; i < num_visuals; i++) {
341         struct ximage_config *xconf = &xdpy->configs[count];
342
343         xconf->visual = &visuals[i];
344         xconf->base.color_format = choose_format(xconf->visual);
345         if (xconf->base.color_format == PIPE_FORMAT_NONE)
346            continue;
347
348         xconf->base.buffer_mask =
349            (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
350            (1 << NATIVE_ATTACHMENT_BACK_LEFT);
351
352         xconf->base.window_bit = TRUE;
353         xconf->base.pixmap_bit = TRUE;
354
355         xconf->base.native_visual_id = xconf->visual->visualid;
356#if defined(__cplusplus) || defined(c_plusplus)
357         xconf->base.native_visual_type = xconf->visual->c_class;
358#else
359         xconf->base.native_visual_type = xconf->visual->class;
360#endif
361
362         xconf->base.slow_config = TRUE;
363
364         count++;
365      }
366
367      xdpy->num_configs = count;
368   }
369
370   configs = MALLOC(xdpy->num_configs * sizeof(*configs));
371   if (configs) {
372      for (i = 0; i < xdpy->num_configs; i++)
373         configs[i] = (const struct native_config *) &xdpy->configs[i];
374      if (num_configs)
375         *num_configs = xdpy->num_configs;
376   }
377   return configs;
378}
379
380static boolean
381ximage_display_is_pixmap_supported(struct native_display *ndpy,
382                                   EGLNativePixmapType pix,
383                                   const struct native_config *nconf)
384{
385   struct ximage_display *xdpy = ximage_display(ndpy);
386   enum pipe_format fmt;
387   uint depth;
388
389   depth = x11_drawable_get_depth(xdpy->xscr, (Drawable) pix);
390   switch (depth) {
391   case 32:
392      fmt = PIPE_FORMAT_B8G8R8A8_UNORM;
393      break;
394   case 24:
395      fmt = PIPE_FORMAT_B8G8R8X8_UNORM;
396      break;
397   case 16:
398      fmt = PIPE_FORMAT_B5G6R5_UNORM;
399      break;
400   default:
401      fmt = PIPE_FORMAT_NONE;
402      break;
403   }
404
405   return (fmt == nconf->color_format);
406}
407
408static int
409ximage_display_get_param(struct native_display *ndpy,
410                         enum native_param_type param)
411{
412   int val;
413
414   switch (param) {
415   case NATIVE_PARAM_USE_NATIVE_BUFFER:
416      /* private buffers are allocated */
417      val = FALSE;
418      break;
419   default:
420      val = 0;
421      break;
422   }
423
424   return val;
425}
426
427static void
428ximage_display_destroy(struct native_display *ndpy)
429{
430   struct ximage_display *xdpy = ximage_display(ndpy);
431
432   if (xdpy->configs)
433      FREE(xdpy->configs);
434
435   xdpy->base.screen->destroy(xdpy->base.screen);
436
437   x11_screen_destroy(xdpy->xscr);
438   if (xdpy->own_dpy)
439      XCloseDisplay(xdpy->dpy);
440   FREE(xdpy);
441}
442
443struct native_display *
444x11_create_ximage_display(Display *dpy,
445                          struct native_event_handler *event_handler)
446{
447   struct ximage_display *xdpy;
448   struct sw_winsys *winsys = NULL;
449
450   xdpy = CALLOC_STRUCT(ximage_display);
451   if (!xdpy)
452      return NULL;
453
454   xdpy->dpy = dpy;
455   if (!xdpy->dpy) {
456      xdpy->dpy = XOpenDisplay(NULL);
457      if (!xdpy->dpy) {
458         FREE(xdpy);
459         return NULL;
460      }
461      xdpy->own_dpy = TRUE;
462   }
463
464   xdpy->event_handler = event_handler;
465
466   xdpy->xscr_number = DefaultScreen(xdpy->dpy);
467   xdpy->xscr = x11_screen_create(xdpy->dpy, xdpy->xscr_number);
468   if (!xdpy->xscr)
469      goto fail;
470
471   winsys = xlib_create_sw_winsys(xdpy->dpy);
472   if (!winsys)
473      goto fail;
474
475   xdpy->base.screen = native_create_sw_screen(winsys);
476   if (!xdpy->base.screen)
477      goto fail;
478
479   xdpy->base.destroy = ximage_display_destroy;
480   xdpy->base.get_param = ximage_display_get_param;
481
482   xdpy->base.get_configs = ximage_display_get_configs;
483   xdpy->base.is_pixmap_supported = ximage_display_is_pixmap_supported;
484   xdpy->base.create_window_surface = ximage_display_create_window_surface;
485   xdpy->base.create_pixmap_surface = ximage_display_create_pixmap_surface;
486
487   return &xdpy->base;
488
489fail:
490   if (winsys && winsys->destroy)
491      winsys->destroy(winsys);
492   if (xdpy->xscr)
493      x11_screen_destroy(xdpy->xscr);
494   if (xdpy->dpy && xdpy->own_dpy)
495      XCloseDisplay(xdpy->dpy);
496   FREE(xdpy);
497   return NULL;
498}
499