egl_dri2.h revision 63c5d5c6c46c8472ee7a8241a0f80f13d79cb8cd 
1/*
2 * Copyright © 2011 Intel Corporation
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,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 *    Kristian Høgsberg <krh@bitplanet.net>
26 */
27
28#ifndef EGL_DRI2_INCLUDED
29#define EGL_DRI2_INCLUDED
30
31#include <stdint.h>
32
33#ifdef HAVE_X11_PLATFORM
34#include <xcb/xcb.h>
35#include <xcb/dri2.h>
36#include <xcb/xfixes.h>
37#include <X11/Xlib-xcb.h>
38
39#ifdef HAVE_DRI3
40#include "loader_dri3_helper.h"
41#endif
42#endif
43
44#ifdef HAVE_WAYLAND_PLATFORM
45#include <wayland-client.h>
46#include "wayland-egl-priv.h"
47#endif
48
49#include <GL/gl.h>
50#include <GL/internal/dri_interface.h>
51
52#ifdef HAVE_DRM_PLATFORM
53#include <gbm_driint.h>
54#endif
55
56#ifdef HAVE_ANDROID_PLATFORM
57#define LOG_TAG "EGL-DRI2"
58
59#if ANDROID_VERSION >= 0x0400
60#  include <system/window.h>
61#else
62#  define android_native_buffer_t ANativeWindowBuffer
63#  include <ui/egl/android_natives.h>
64#  include <ui/android_native_buffer.h>
65#endif
66
67#include <hardware/gralloc.h>
68#include <gralloc_drm_handle.h>
69#include <cutils/log.h>
70
71#endif /* HAVE_ANDROID_PLATFORM */
72
73#include "eglconfig.h"
74#include "eglcontext.h"
75#include "egldisplay.h"
76#include "egldriver.h"
77#include "eglcurrent.h"
78#include "egllog.h"
79#include "eglsurface.h"
80#include "eglimage.h"
81#include "eglsync.h"
82
83#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
84
85struct wl_buffer;
86
87struct dri2_egl_driver
88{
89   _EGLDriver base;
90
91   void *handle;
92   _EGLProc (*get_proc_address)(const char *procname);
93   void (*glFlush)(void);
94};
95
96struct dri2_egl_display_vtbl {
97   int (*authenticate)(_EGLDisplay *disp, uint32_t id);
98
99   _EGLSurface* (*create_window_surface)(_EGLDriver *drv, _EGLDisplay *dpy,
100                                         _EGLConfig *config,
101                                         void *native_window,
102                                         const EGLint *attrib_list);
103
104   _EGLSurface* (*create_pixmap_surface)(_EGLDriver *drv, _EGLDisplay *dpy,
105                                         _EGLConfig *config,
106                                         void *native_pixmap,
107                                         const EGLint *attrib_list);
108
109   _EGLSurface* (*create_pbuffer_surface)(_EGLDriver *drv, _EGLDisplay *dpy,
110                                          _EGLConfig *config,
111                                          const EGLint *attrib_list);
112
113   EGLBoolean (*destroy_surface)(_EGLDriver *drv, _EGLDisplay *dpy,
114                                 _EGLSurface *surface);
115
116   EGLBoolean (*swap_interval)(_EGLDriver *drv, _EGLDisplay *dpy,
117                               _EGLSurface *surf, EGLint interval);
118
119   _EGLImage* (*create_image)(_EGLDriver *drv, _EGLDisplay *dpy,
120                              _EGLContext *ctx, EGLenum target,
121                              EGLClientBuffer buffer,
122                              const EGLint *attr_list);
123
124   EGLBoolean (*swap_buffers)(_EGLDriver *drv, _EGLDisplay *dpy,
125                              _EGLSurface *surf);
126
127   EGLBoolean (*swap_buffers_with_damage)(_EGLDriver *drv, _EGLDisplay *dpy,
128                                          _EGLSurface *surface,
129                                          const EGLint *rects, EGLint n_rects);
130
131   EGLBoolean (*swap_buffers_region)(_EGLDriver *drv, _EGLDisplay *dpy,
132                                     _EGLSurface *surf, EGLint numRects,
133                                     const EGLint *rects);
134
135   EGLBoolean (*post_sub_buffer)(_EGLDriver *drv, _EGLDisplay *dpy,
136                                 _EGLSurface *surf,
137                                 EGLint x, EGLint y,
138                                 EGLint width, EGLint height);
139
140   EGLBoolean (*copy_buffers)(_EGLDriver *drv, _EGLDisplay *dpy,
141                              _EGLSurface *surf, void *native_pixmap_target);
142
143   EGLint (*query_buffer_age)(_EGLDriver *drv, _EGLDisplay *dpy,
144                              _EGLSurface *surf);
145
146   struct wl_buffer* (*create_wayland_buffer_from_image)(
147                        _EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img);
148
149   EGLBoolean (*get_sync_values)(_EGLDisplay *display, _EGLSurface *surface,
150                                 EGLuint64KHR *ust, EGLuint64KHR *msc,
151                                 EGLuint64KHR *sbc);
152
153   __DRIdrawable *(*get_dri_drawable)(_EGLSurface *surf);
154};
155
156struct dri2_egl_display
157{
158   const struct dri2_egl_display_vtbl *vtbl;
159
160   int                       dri2_major;
161   int                       dri2_minor;
162   __DRIscreen              *dri_screen;
163   int                       own_dri_screen;
164   const __DRIconfig       **driver_configs;
165   void                     *driver;
166   const __DRIcoreExtension       *core;
167   const __DRIimageDriverExtension *image_driver;
168   const __DRIdri2Extension       *dri2;
169   const __DRIswrastExtension     *swrast;
170   const __DRI2flushExtension     *flush;
171   const __DRItexBufferExtension  *tex_buffer;
172   const __DRIimageExtension      *image;
173   const __DRIrobustnessExtension *robustness;
174   const __DRI2configQueryExtension *config;
175   const __DRI2fenceExtension *fence;
176   const __DRI2rendererQueryExtension *rendererQuery;
177   const __DRI2interopExtension *interop;
178   int                       fd;
179
180   int                       own_device;
181   int                       swap_available;
182   int                       invalidate_available;
183   int                       min_swap_interval;
184   int                       max_swap_interval;
185   int                       default_swap_interval;
186#ifdef HAVE_DRM_PLATFORM
187   struct gbm_dri_device    *gbm_dri;
188#endif
189
190   char                     *device_name;
191   char                     *driver_name;
192
193   __DRIdri2LoaderExtension    dri2_loader_extension;
194   __DRIswrastLoaderExtension  swrast_loader_extension;
195   const __DRIextension     *extensions[5];
196   const __DRIextension    **driver_extensions;
197
198#ifdef HAVE_X11_PLATFORM
199   xcb_connection_t         *conn;
200   int                      screen;
201#ifdef HAVE_DRI3
202   struct loader_dri3_extensions loader_dri3_ext;
203#endif
204#endif
205
206#ifdef HAVE_WAYLAND_PLATFORM
207   struct wl_display        *wl_dpy;
208   struct wl_registry       *wl_registry;
209   struct wl_drm            *wl_server_drm;
210   struct wl_drm            *wl_drm;
211   struct wl_shm            *wl_shm;
212   struct wl_event_queue    *wl_queue;
213   int			     authenticated;
214   int			     formats;
215   uint32_t                  capabilities;
216#endif
217
218   int              is_render_node;
219   int			     is_different_gpu;
220};
221
222struct dri2_egl_context
223{
224   _EGLContext   base;
225   __DRIcontext *dri_context;
226};
227
228#ifdef HAVE_WAYLAND_PLATFORM
229enum wayland_buffer_type {
230   WL_BUFFER_FRONT,
231   WL_BUFFER_BACK,
232   WL_BUFFER_THIRD,
233   WL_BUFFER_COUNT
234};
235#endif
236
237struct dri2_egl_surface
238{
239   _EGLSurface          base;
240   __DRIdrawable       *dri_drawable;
241   __DRIbuffer          buffers[5];
242   int                  buffer_count;
243   int                  have_fake_front;
244
245#ifdef HAVE_X11_PLATFORM
246   xcb_drawable_t       drawable;
247   xcb_xfixes_region_t  region;
248   int                  depth;
249   int                  bytes_per_pixel;
250   xcb_gcontext_t       gc;
251   xcb_gcontext_t       swapgc;
252#endif
253
254#ifdef HAVE_WAYLAND_PLATFORM
255   struct wl_egl_window  *wl_win;
256   int                    dx;
257   int                    dy;
258   struct wl_callback    *throttle_callback;
259   int			  format;
260#endif
261
262#ifdef HAVE_DRM_PLATFORM
263   struct gbm_dri_surface *gbm_surf;
264#endif
265
266#if defined(HAVE_WAYLAND_PLATFORM) || defined(HAVE_DRM_PLATFORM)
267   __DRIbuffer           *dri_buffers[__DRI_BUFFER_COUNT];
268   struct {
269#ifdef HAVE_WAYLAND_PLATFORM
270      struct wl_buffer   *wl_buffer;
271      __DRIimage         *dri_image;
272      /* for is_different_gpu case. NULL else */
273      __DRIimage         *linear_copy;
274      /* for swrast */
275      void *data;
276      int data_size;
277#endif
278#ifdef HAVE_DRM_PLATFORM
279      struct gbm_bo       *bo;
280#endif
281      int                 locked;
282      int                 age;
283   } color_buffers[4], *back, *current;
284#endif
285
286#ifdef HAVE_ANDROID_PLATFORM
287   struct ANativeWindow *window;
288   struct ANativeWindowBuffer *buffer;
289   __DRIimage *dri_image;
290
291   /* EGL-owned buffers */
292   __DRIbuffer           *local_buffers[__DRI_BUFFER_COUNT];
293#endif
294
295#if defined(HAVE_SURFACELESS_PLATFORM)
296      __DRIimage           *front;
297      unsigned int         visual;
298#endif
299
300};
301
302struct dri2_egl_config
303{
304   _EGLConfig         base;
305   const __DRIconfig *dri_single_config[2];
306   const __DRIconfig *dri_double_config[2];
307};
308
309struct dri2_egl_image
310{
311   _EGLImage   base;
312   __DRIimage *dri_image;
313};
314
315struct dri2_egl_sync {
316   _EGLSync base;
317   mtx_t mutex;
318   cnd_t cond;
319   int refcount;
320   void *fence;
321};
322
323/* From xmlpool/options.h, user exposed so should be stable */
324#define DRI_CONF_VBLANK_NEVER 0
325#define DRI_CONF_VBLANK_DEF_INTERVAL_0 1
326#define DRI_CONF_VBLANK_DEF_INTERVAL_1 2
327#define DRI_CONF_VBLANK_ALWAYS_SYNC 3
328
329/* standard typecasts */
330_EGL_DRIVER_STANDARD_TYPECASTS(dri2_egl)
331_EGL_DRIVER_TYPECAST(dri2_egl_image, _EGLImage, obj)
332_EGL_DRIVER_TYPECAST(dri2_egl_sync, _EGLSync, obj)
333
334extern const __DRIimageLookupExtension image_lookup_extension;
335extern const __DRIuseInvalidateExtension use_invalidate;
336
337EGLBoolean
338dri2_load_driver(_EGLDisplay *disp);
339
340/* Helper for platforms not using dri2_create_screen */
341void
342dri2_setup_screen(_EGLDisplay *disp);
343
344EGLBoolean
345dri2_load_driver_swrast(_EGLDisplay *disp);
346
347EGLBoolean
348dri2_load_driver_dri3(_EGLDisplay *disp);
349
350EGLBoolean
351dri2_create_screen(_EGLDisplay *disp);
352
353__DRIdrawable *
354dri2_surface_get_dri_drawable(_EGLSurface *surf);
355
356__DRIimage *
357dri2_lookup_egl_image(__DRIscreen *screen, void *image, void *data);
358
359struct dri2_egl_config *
360dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
361		EGLint surface_type, const EGLint *attr_list,
362		const unsigned int *rgba_masks);
363
364_EGLImage *
365dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
366		      _EGLContext *ctx, EGLenum target,
367		      EGLClientBuffer buffer, const EGLint *attr_list);
368
369_EGLImage *
370dri2_create_image_dma_buf(_EGLDisplay *disp, _EGLContext *ctx,
371			  EGLClientBuffer buffer, const EGLint *attr_list);
372
373EGLBoolean
374dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp);
375
376EGLBoolean
377dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp);
378
379EGLBoolean
380dri2_initialize_wayland(_EGLDriver *drv, _EGLDisplay *disp);
381
382EGLBoolean
383dri2_initialize_android(_EGLDriver *drv, _EGLDisplay *disp);
384
385EGLBoolean
386dri2_initialize_surfaceless(_EGLDriver *drv, _EGLDisplay *disp);
387
388void
389dri2_flush_drawable_for_swapbuffers(_EGLDisplay *disp, _EGLSurface *draw);
390
391const __DRIconfig *
392dri2_get_dri_config(struct dri2_egl_config *conf, EGLint surface_type,
393                    EGLenum colorspace);
394
395#endif /* EGL_DRI2_INCLUDED */
396