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