egl_dri2.h revision 01e04c3f 
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 <stdbool.h>
32#include <stdint.h>
33
34#ifdef HAVE_X11_PLATFORM
35#include <xcb/xcb.h>
36#include <xcb/dri2.h>
37#include <xcb/xfixes.h>
38#include <X11/Xlib-xcb.h>
39
40#ifdef HAVE_DRI3
41#include "loader_dri3_helper.h"
42#endif
43#endif
44
45#ifdef HAVE_WAYLAND_PLATFORM
46/* forward declarations to avoid pulling wayland headers everywhere */
47struct wl_egl_window;
48struct wl_event_queue;
49struct wl_callback;
50struct wl_display;
51struct wl_drm;
52struct wl_registry;
53struct wl_shm;
54struct wl_surface;
55struct zwp_linux_dmabuf_v1;
56#endif
57
58#include <GL/gl.h>
59#include <GL/internal/dri_interface.h>
60
61#ifdef HAVE_DRM_PLATFORM
62#include <gbm_driint.h>
63#endif
64
65#ifdef HAVE_ANDROID_PLATFORM
66#define LOG_TAG "EGL-DRI2"
67
68#include <system/window.h>
69#include <hardware/gralloc.h>
70#endif /* HAVE_ANDROID_PLATFORM */
71
72#include "eglconfig.h"
73#include "eglcontext.h"
74#include "egldevice.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#include "util/u_vector.h"
84
85struct wl_buffer;
86
87struct dri2_egl_display_vtbl {
88   int (*authenticate)(_EGLDisplay *disp, uint32_t id);
89
90   _EGLSurface* (*create_window_surface)(_EGLDriver *drv, _EGLDisplay *dpy,
91                                         _EGLConfig *config,
92                                         void *native_window,
93                                         const EGLint *attrib_list);
94
95   _EGLSurface* (*create_pixmap_surface)(_EGLDriver *drv, _EGLDisplay *dpy,
96                                         _EGLConfig *config,
97                                         void *native_pixmap,
98                                         const EGLint *attrib_list);
99
100   _EGLSurface* (*create_pbuffer_surface)(_EGLDriver *drv, _EGLDisplay *dpy,
101                                          _EGLConfig *config,
102                                          const EGLint *attrib_list);
103
104   EGLBoolean (*destroy_surface)(_EGLDriver *drv, _EGLDisplay *dpy,
105                                 _EGLSurface *surface);
106
107   EGLBoolean (*swap_interval)(_EGLDriver *drv, _EGLDisplay *dpy,
108                               _EGLSurface *surf, EGLint interval);
109
110   _EGLImage* (*create_image)(_EGLDriver *drv, _EGLDisplay *dpy,
111                              _EGLContext *ctx, EGLenum target,
112                              EGLClientBuffer buffer,
113                              const EGLint *attr_list);
114
115   EGLBoolean (*swap_buffers)(_EGLDriver *drv, _EGLDisplay *dpy,
116                              _EGLSurface *surf);
117
118   EGLBoolean (*swap_buffers_with_damage)(_EGLDriver *drv, _EGLDisplay *dpy,
119                                          _EGLSurface *surface,
120                                          const EGLint *rects, EGLint n_rects);
121
122   EGLBoolean (*set_damage_region)(_EGLDriver *drv, _EGLDisplay *dpy,
123                                   _EGLSurface *surface,
124                                   const EGLint *rects, EGLint n_rects);
125
126   EGLBoolean (*swap_buffers_region)(_EGLDriver *drv, _EGLDisplay *dpy,
127                                     _EGLSurface *surf, EGLint numRects,
128                                     const EGLint *rects);
129
130   EGLBoolean (*post_sub_buffer)(_EGLDriver *drv, _EGLDisplay *dpy,
131                                 _EGLSurface *surf,
132                                 EGLint x, EGLint y,
133                                 EGLint width, EGLint height);
134
135   EGLBoolean (*copy_buffers)(_EGLDriver *drv, _EGLDisplay *dpy,
136                              _EGLSurface *surf, void *native_pixmap_target);
137
138   EGLint (*query_buffer_age)(_EGLDriver *drv, _EGLDisplay *dpy,
139                              _EGLSurface *surf);
140
141   EGLBoolean (*query_surface)(_EGLDriver *drv, _EGLDisplay *dpy,
142                               _EGLSurface *surf, EGLint attribute,
143                               EGLint *value);
144
145   struct wl_buffer* (*create_wayland_buffer_from_image)(
146                        _EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img);
147
148   EGLBoolean (*get_sync_values)(_EGLDisplay *display, _EGLSurface *surface,
149                                 EGLuint64KHR *ust, EGLuint64KHR *msc,
150                                 EGLuint64KHR *sbc);
151
152   __DRIdrawable *(*get_dri_drawable)(_EGLSurface *surf);
153
154   void (*close_screen_notify)(_EGLDisplay *dpy);
155
156   /* Used in EGL_KHR_mutable_render_buffer to update the native window's
157    * shared buffer mode.
158    */
159   bool (*set_shared_buffer_mode)(_EGLDisplay *dpy, _EGLSurface *surf,
160                                  bool mode);
161};
162
163struct dri2_egl_display
164{
165   const struct dri2_egl_display_vtbl *vtbl;
166
167   int                       dri2_major;
168   int                       dri2_minor;
169   __DRIscreen              *dri_screen;
170   bool                      own_dri_screen;
171   const __DRIconfig       **driver_configs;
172   void                     *driver;
173   const __DRIcoreExtension       *core;
174   const __DRIimageDriverExtension *image_driver;
175   const __DRIdri2Extension       *dri2;
176   const __DRIswrastExtension     *swrast;
177   const __DRI2flushExtension     *flush;
178   const __DRI2flushControlExtension *flush_control;
179   const __DRItexBufferExtension  *tex_buffer;
180   const __DRIimageExtension      *image;
181   const __DRIrobustnessExtension *robustness;
182   const __DRInoErrorExtension    *no_error;
183   const __DRI2configQueryExtension *config;
184   const __DRI2fenceExtension *fence;
185   const __DRI2blobExtension *blob;
186   const __DRI2rendererQueryExtension *rendererQuery;
187   const __DRI2interopExtension *interop;
188   const __DRImutableRenderBufferDriverExtension *mutable_render_buffer;
189   int                       fd;
190
191   /* dri2_initialize/dri2_terminate increment/decrement this count, so does
192    * dri2_make_current (tracks if there are active contexts/surfaces). */
193   int                       ref_count;
194
195   bool                      own_device;
196   bool                      invalidate_available;
197   int                       min_swap_interval;
198   int                       max_swap_interval;
199   int                       default_swap_interval;
200#ifdef HAVE_DRM_PLATFORM
201   struct gbm_dri_device    *gbm_dri;
202#endif
203
204   char                     *driver_name;
205
206   const __DRIextension    **loader_extensions;
207   const __DRIextension    **driver_extensions;
208
209#ifdef HAVE_X11_PLATFORM
210   xcb_connection_t         *conn;
211   xcb_screen_t             *screen;
212   bool                     swap_available;
213#ifdef HAVE_DRI3
214   bool                     multibuffers_available;
215   int                      dri3_major_version;
216   int                      dri3_minor_version;
217   int                      present_major_version;
218   int                      present_minor_version;
219   struct loader_dri3_extensions loader_dri3_ext;
220#endif
221#endif
222
223#ifdef HAVE_WAYLAND_PLATFORM
224   struct wl_display        *wl_dpy;
225   struct wl_display        *wl_dpy_wrapper;
226   struct wl_registry       *wl_registry;
227   struct wl_drm            *wl_server_drm;
228   struct wl_drm            *wl_drm;
229   struct wl_shm            *wl_shm;
230   struct wl_event_queue    *wl_queue;
231   struct zwp_linux_dmabuf_v1 *wl_dmabuf;
232   struct u_vector          *wl_modifiers;
233   bool                      authenticated;
234   unsigned                  formats;
235   uint32_t                  capabilities;
236   char                     *device_name;
237#endif
238
239#ifdef HAVE_ANDROID_PLATFORM
240   const gralloc_module_t *gralloc;
241#endif
242
243   bool                      is_render_node;
244   bool                      is_different_gpu;
245};
246
247struct dri2_egl_context
248{
249   _EGLContext   base;
250   __DRIcontext *dri_context;
251};
252
253#ifdef HAVE_WAYLAND_PLATFORM
254enum wayland_buffer_type {
255   WL_BUFFER_FRONT,
256   WL_BUFFER_BACK,
257   WL_BUFFER_THIRD,
258   WL_BUFFER_COUNT
259};
260#endif
261
262struct dri2_egl_surface
263{
264   _EGLSurface          base;
265   __DRIdrawable       *dri_drawable;
266   __DRIbuffer          buffers[5];
267   bool                 have_fake_front;
268
269#ifdef HAVE_X11_PLATFORM
270   xcb_drawable_t       drawable;
271   xcb_xfixes_region_t  region;
272   int                  depth;
273   int                  bytes_per_pixel;
274   xcb_gcontext_t       gc;
275   xcb_gcontext_t       swapgc;
276#endif
277
278#ifdef HAVE_WAYLAND_PLATFORM
279   struct wl_egl_window  *wl_win;
280   int                    dx;
281   int                    dy;
282   struct wl_event_queue *wl_queue;
283   struct wl_surface     *wl_surface_wrapper;
284   struct wl_display     *wl_dpy_wrapper;
285   struct wl_drm         *wl_drm_wrapper;
286   struct wl_callback    *throttle_callback;
287   int                    format;
288#endif
289
290#ifdef HAVE_DRM_PLATFORM
291   struct gbm_dri_surface *gbm_surf;
292#endif
293
294   /* EGL-owned buffers */
295   __DRIbuffer           *local_buffers[__DRI_BUFFER_COUNT];
296
297#if defined(HAVE_WAYLAND_PLATFORM) || defined(HAVE_DRM_PLATFORM)
298   struct {
299#ifdef HAVE_WAYLAND_PLATFORM
300      struct wl_buffer   *wl_buffer;
301      bool                wl_release;
302      __DRIimage         *dri_image;
303      /* for is_different_gpu case. NULL else */
304      __DRIimage         *linear_copy;
305      /* for swrast */
306      void *data;
307      int data_size;
308#endif
309#ifdef HAVE_DRM_PLATFORM
310      struct gbm_bo       *bo;
311#endif
312      bool                locked;
313      int                 age;
314   } color_buffers[4], *back, *current;
315#endif
316
317#ifdef HAVE_ANDROID_PLATFORM
318   struct ANativeWindow *window;
319   struct ANativeWindowBuffer *buffer;
320   __DRIimage *dri_image_back;
321   __DRIimage *dri_image_front;
322
323   /* Used to record all the buffers created by ANativeWindow and their ages.
324    * Usually Android uses at most triple buffers in ANativeWindow
325    * so hardcode the number of color_buffers to 3.
326    */
327   struct {
328      struct ANativeWindowBuffer *buffer;
329      int age;
330   } color_buffers[3], *back;
331#endif
332
333#if defined(HAVE_SURFACELESS_PLATFORM)
334      __DRIimage           *front;
335      unsigned int         visual;
336#endif
337   int out_fence_fd;
338   EGLBoolean enable_out_fence;
339};
340
341struct dri2_egl_config
342{
343   _EGLConfig         base;
344   const __DRIconfig *dri_config[2][2];
345};
346
347struct dri2_egl_image
348{
349   _EGLImage   base;
350   __DRIimage *dri_image;
351};
352
353struct dri2_egl_sync {
354   _EGLSync base;
355   mtx_t mutex;
356   cnd_t cond;
357   int refcount;
358   void *fence;
359};
360
361/* From xmlpool/options.h, user exposed so should be stable */
362#define DRI_CONF_VBLANK_NEVER 0
363#define DRI_CONF_VBLANK_DEF_INTERVAL_0 1
364#define DRI_CONF_VBLANK_DEF_INTERVAL_1 2
365#define DRI_CONF_VBLANK_ALWAYS_SYNC 3
366
367/* standard typecasts */
368_EGL_DRIVER_STANDARD_TYPECASTS(dri2_egl)
369_EGL_DRIVER_TYPECAST(dri2_egl_image, _EGLImage, obj)
370_EGL_DRIVER_TYPECAST(dri2_egl_sync, _EGLSync, obj)
371
372extern const __DRIimageLookupExtension image_lookup_extension;
373extern const __DRIuseInvalidateExtension use_invalidate;
374extern const __DRIbackgroundCallableExtension background_callable_extension;
375
376EGLBoolean
377dri2_load_driver(_EGLDisplay *disp);
378
379/* Helper for platforms not using dri2_create_screen */
380void
381dri2_setup_screen(_EGLDisplay *disp);
382
383void
384dri2_setup_swap_interval(_EGLDisplay *disp, int max_swap_interval);
385
386EGLBoolean
387dri2_load_driver_swrast(_EGLDisplay *disp);
388
389EGLBoolean
390dri2_load_driver_dri3(_EGLDisplay *disp);
391
392EGLBoolean
393dri2_create_screen(_EGLDisplay *disp);
394
395EGLBoolean
396dri2_setup_extensions(_EGLDisplay *disp);
397
398__DRIdrawable *
399dri2_surface_get_dri_drawable(_EGLSurface *surf);
400
401__DRIimage *
402dri2_lookup_egl_image(__DRIscreen *screen, void *image, void *data);
403
404struct dri2_egl_config *
405dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
406                EGLint surface_type, const EGLint *attr_list,
407                const unsigned int *rgba_masks);
408
409_EGLImage *
410dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
411                      _EGLContext *ctx, EGLenum target,
412                      EGLClientBuffer buffer, const EGLint *attr_list);
413
414_EGLImage *
415dri2_create_image_dma_buf(_EGLDisplay *disp, _EGLContext *ctx,
416                          EGLClientBuffer buffer, const EGLint *attr_list);
417
418#ifdef HAVE_X11_PLATFORM
419EGLBoolean
420dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp);
421void
422dri2_teardown_x11(struct dri2_egl_display *dri2_dpy);
423unsigned int
424dri2_x11_get_red_mask_for_depth(struct dri2_egl_display *dri2_dpy, int depth);
425#else
426static inline EGLBoolean
427dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp)
428{
429   return _eglError(EGL_NOT_INITIALIZED, "X11 platform not built");
430}
431static inline void
432dri2_teardown_x11(struct dri2_egl_display *dri2_dpy) {}
433static inline unsigned int
434dri2_x11_get_red_mask_for_depth(struct dri2_egl_display *dri2_dpy, int depth)
435{
436   return 0;
437}
438#endif
439
440#ifdef HAVE_DRM_PLATFORM
441EGLBoolean
442dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp);
443void
444dri2_teardown_drm(struct dri2_egl_display *dri2_dpy);
445#else
446static inline EGLBoolean
447dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp)
448{
449   return _eglError(EGL_NOT_INITIALIZED, "GBM/DRM platform not built");
450}
451static inline void
452dri2_teardown_drm(struct dri2_egl_display *dri2_dpy) {}
453#endif
454
455#ifdef HAVE_WAYLAND_PLATFORM
456EGLBoolean
457dri2_initialize_wayland(_EGLDriver *drv, _EGLDisplay *disp);
458void
459dri2_teardown_wayland(struct dri2_egl_display *dri2_dpy);
460bool
461dri2_wl_is_format_supported(void* user_data, uint32_t format);
462#else
463static inline EGLBoolean
464dri2_initialize_wayland(_EGLDriver *drv, _EGLDisplay *disp)
465{
466   return _eglError(EGL_NOT_INITIALIZED, "Wayland platform not built");
467}
468static inline void
469dri2_teardown_wayland(struct dri2_egl_display *dri2_dpy) {}
470#endif
471
472#ifdef HAVE_ANDROID_PLATFORM
473EGLBoolean
474dri2_initialize_android(_EGLDriver *drv, _EGLDisplay *disp);
475#else
476static inline EGLBoolean
477dri2_initialize_android(_EGLDriver *drv, _EGLDisplay *disp)
478{
479   return _eglError(EGL_NOT_INITIALIZED, "Android platform not built");
480}
481#endif
482
483#ifdef HAVE_SURFACELESS_PLATFORM
484EGLBoolean
485dri2_initialize_surfaceless(_EGLDriver *drv, _EGLDisplay *disp);
486#else
487static inline EGLBoolean
488dri2_initialize_surfaceless(_EGLDriver *drv, _EGLDisplay *disp)
489{
490   return _eglError(EGL_NOT_INITIALIZED, "Surfaceless platform not built");
491}
492#endif
493
494void
495dri2_flush_drawable_for_swapbuffers(_EGLDisplay *disp, _EGLSurface *draw);
496
497const __DRIconfig *
498dri2_get_dri_config(struct dri2_egl_config *conf, EGLint surface_type,
499                    EGLenum colorspace);
500
501static inline void
502dri2_set_WL_bind_wayland_display(_EGLDriver *drv, _EGLDisplay *disp)
503{
504#ifdef HAVE_WAYLAND_PLATFORM
505   struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
506
507   (void) drv;
508
509   if (dri2_dpy->device_name && dri2_dpy->image) {
510       if (dri2_dpy->image->base.version >= 10 &&
511           dri2_dpy->image->getCapabilities != NULL) {
512           int capabilities;
513
514           capabilities =
515               dri2_dpy->image->getCapabilities(dri2_dpy->dri_screen);
516           disp->Extensions.WL_bind_wayland_display =
517               (capabilities & __DRI_IMAGE_CAP_GLOBAL_NAMES) != 0;
518       } else {
519           disp->Extensions.WL_bind_wayland_display = EGL_TRUE;
520       }
521   }
522#endif
523}
524
525void
526dri2_display_destroy(_EGLDisplay *disp);
527
528__DRIbuffer *
529dri2_egl_surface_alloc_local_buffer(struct dri2_egl_surface *dri2_surf,
530                                    unsigned int att, unsigned int format);
531
532void
533dri2_egl_surface_free_local_buffers(struct dri2_egl_surface *dri2_surf);
534
535EGLBoolean
536dri2_init_surface(_EGLSurface *surf, _EGLDisplay *dpy, EGLint type,
537        _EGLConfig *conf, const EGLint *attrib_list, EGLBoolean enable_out_fence);
538
539void
540dri2_fini_surface(_EGLSurface *surf);
541
542static inline uint64_t
543combine_u32_into_u64(uint32_t hi, uint32_t lo)
544{
545   return (((uint64_t) hi) << 32) | (((uint64_t) lo) & 0xffffffff);
546}
547
548#endif /* EGL_DRI2_INCLUDED */
549