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