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