projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge ../mesa into vulkan
[mesa.git] / src / egl / drivers / dri2 / egl_dri2.c
1 /*
2 * Copyright © 2010 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 #define WL_HIDE_DEPRECATED
29
30 #include <stdbool.h>
31 #include <stdint.h>
32 #include <stdbool.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdio.h>
36 #include <limits.h>
37 #include <dlfcn.h>
38 #include <fcntl.h>
39 #include <errno.h>
40 #include <unistd.h>
41 #ifdef HAVE_LIBDRM
42 #include <xf86drm.h>
43 #include <drm_fourcc.h>
44 #endif
45 #include <GL/gl.h>
46 #include <GL/internal/dri_interface.h>
47 #include <sys/types.h>
48 #include <sys/stat.h>
49
50 #ifdef HAVE_WAYLAND_PLATFORM
51 #include "wayland-drm.h"
52 #include "wayland-drm-client-protocol.h"
53 #endif
54
55 #include "egl_dri2.h"
56 #include "util/u_atomic.h"
57
58 /* The kernel header drm_fourcc.h defines the DRM formats below. We duplicate
59 * some of the definitions here so that building Mesa won't bleeding-edge
60 * kernel headers.
61 */
62 #ifndef DRM_FORMAT_R8
63 #define DRM_FORMAT_R8 fourcc_code('R', '8', ' ', ' ') /* [7:0] R */
64 #endif
65
66 #ifndef DRM_FORMAT_RG88
67 #define DRM_FORMAT_RG88 fourcc_code('R', 'G', '8', '8') /* [15:0] R:G 8:8 little endian */
68 #endif
69
70 #ifndef DRM_FORMAT_GR88
71 #define DRM_FORMAT_GR88 fourcc_code('G', 'R', '8', '8') /* [15:0] G:R 8:8 little endian */
72 #endif
73
74 const __DRIuseInvalidateExtension use_invalidate = {
75 .base = { __DRI_USE_INVALIDATE, 1 }
76 };
77
78 EGLint dri2_to_egl_attribute_map[] = {
79 0,
80 EGL_BUFFER_SIZE, /* __DRI_ATTRIB_BUFFER_SIZE */
81 EGL_LEVEL, /* __DRI_ATTRIB_LEVEL */
82 EGL_RED_SIZE, /* __DRI_ATTRIB_RED_SIZE */
83 EGL_GREEN_SIZE, /* __DRI_ATTRIB_GREEN_SIZE */
84 EGL_BLUE_SIZE, /* __DRI_ATTRIB_BLUE_SIZE */
85 EGL_LUMINANCE_SIZE, /* __DRI_ATTRIB_LUMINANCE_SIZE */
86 EGL_ALPHA_SIZE, /* __DRI_ATTRIB_ALPHA_SIZE */
87 0, /* __DRI_ATTRIB_ALPHA_MASK_SIZE */
88 EGL_DEPTH_SIZE, /* __DRI_ATTRIB_DEPTH_SIZE */
89 EGL_STENCIL_SIZE, /* __DRI_ATTRIB_STENCIL_SIZE */
90 0, /* __DRI_ATTRIB_ACCUM_RED_SIZE */
91 0, /* __DRI_ATTRIB_ACCUM_GREEN_SIZE */
92 0, /* __DRI_ATTRIB_ACCUM_BLUE_SIZE */
93 0, /* __DRI_ATTRIB_ACCUM_ALPHA_SIZE */
94 EGL_SAMPLE_BUFFERS, /* __DRI_ATTRIB_SAMPLE_BUFFERS */
95 EGL_SAMPLES, /* __DRI_ATTRIB_SAMPLES */
96 0, /* __DRI_ATTRIB_RENDER_TYPE, */
97 0, /* __DRI_ATTRIB_CONFIG_CAVEAT */
98 0, /* __DRI_ATTRIB_CONFORMANT */
99 0, /* __DRI_ATTRIB_DOUBLE_BUFFER */
100 0, /* __DRI_ATTRIB_STEREO */
101 0, /* __DRI_ATTRIB_AUX_BUFFERS */
102 0, /* __DRI_ATTRIB_TRANSPARENT_TYPE */
103 0, /* __DRI_ATTRIB_TRANSPARENT_INDEX_VALUE */
104 0, /* __DRI_ATTRIB_TRANSPARENT_RED_VALUE */
105 0, /* __DRI_ATTRIB_TRANSPARENT_GREEN_VALUE */
106 0, /* __DRI_ATTRIB_TRANSPARENT_BLUE_VALUE */
107 0, /* __DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE */
108 0, /* __DRI_ATTRIB_FLOAT_MODE (deprecated) */
109 0, /* __DRI_ATTRIB_RED_MASK */
110 0, /* __DRI_ATTRIB_GREEN_MASK */
111 0, /* __DRI_ATTRIB_BLUE_MASK */
112 0, /* __DRI_ATTRIB_ALPHA_MASK */
113 EGL_MAX_PBUFFER_WIDTH, /* __DRI_ATTRIB_MAX_PBUFFER_WIDTH */
114 EGL_MAX_PBUFFER_HEIGHT, /* __DRI_ATTRIB_MAX_PBUFFER_HEIGHT */
115 EGL_MAX_PBUFFER_PIXELS, /* __DRI_ATTRIB_MAX_PBUFFER_PIXELS */
116 0, /* __DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH */
117 0, /* __DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT */
118 0, /* __DRI_ATTRIB_VISUAL_SELECT_GROUP */
119 0, /* __DRI_ATTRIB_SWAP_METHOD */
120 EGL_MAX_SWAP_INTERVAL, /* __DRI_ATTRIB_MAX_SWAP_INTERVAL */
121 EGL_MIN_SWAP_INTERVAL, /* __DRI_ATTRIB_MIN_SWAP_INTERVAL */
122 0, /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGB */
123 0, /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA */
124 0, /* __DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE */
125 0, /* __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS */
126 EGL_Y_INVERTED_NOK, /* __DRI_ATTRIB_YINVERTED */
127 0, /* __DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE */
128 };
129
130 const __DRIconfig *
131 dri2_get_dri_config(struct dri2_egl_config *conf, EGLint surface_type,
132 EGLenum colorspace)
133 {
134 const bool srgb = colorspace == EGL_GL_COLORSPACE_SRGB_KHR;
135
136 return surface_type == EGL_WINDOW_BIT ? conf->dri_double_config[srgb] :
137 conf->dri_single_config[srgb];
138 }
139
140 static EGLBoolean
141 dri2_match_config(const _EGLConfig *conf, const _EGLConfig *criteria)
142 {
143 if (_eglCompareConfigs(conf, criteria, NULL, EGL_FALSE) != 0)
144 return EGL_FALSE;
145
146 if (!_eglMatchConfig(conf, criteria))
147 return EGL_FALSE;
148
149 return EGL_TRUE;
150 }
151
152 struct dri2_egl_config *
153 dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
154 EGLint surface_type, const EGLint *attr_list,
155 const unsigned int *rgba_masks)
156 {
157 struct dri2_egl_config *conf;
158 struct dri2_egl_display *dri2_dpy;
159 _EGLConfig base;
160 unsigned int attrib, value, double_buffer;
161 bool srgb = false;
162 EGLint key, bind_to_texture_rgb, bind_to_texture_rgba;
163 unsigned int dri_masks[4] = { 0, 0, 0, 0 };
164 _EGLConfig *matching_config;
165 EGLint num_configs = 0;
166 EGLint config_id;
167 int i;
168
169 dri2_dpy = disp->DriverData;
170 _eglInitConfig(&base, disp, id);
171
172 i = 0;
173 double_buffer = 0;
174 bind_to_texture_rgb = 0;
175 bind_to_texture_rgba = 0;
176
177 while (dri2_dpy->core->indexConfigAttrib(dri_config, i++, &attrib, &value)) {
178 switch (attrib) {
179 case __DRI_ATTRIB_RENDER_TYPE:
180 if (value & __DRI_ATTRIB_RGBA_BIT)
181 value = EGL_RGB_BUFFER;
182 else if (value & __DRI_ATTRIB_LUMINANCE_BIT)
183 value = EGL_LUMINANCE_BUFFER;
184 else
185 return NULL;
186 _eglSetConfigKey(&base, EGL_COLOR_BUFFER_TYPE, value);
187 break;
188
189 case __DRI_ATTRIB_CONFIG_CAVEAT:
190 if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
191 value = EGL_NON_CONFORMANT_CONFIG;
192 else if (value & __DRI_ATTRIB_SLOW_BIT)
193 value = EGL_SLOW_CONFIG;
194 else
195 value = EGL_NONE;
196 _eglSetConfigKey(&base, EGL_CONFIG_CAVEAT, value);
197 break;
198
199 case __DRI_ATTRIB_BIND_TO_TEXTURE_RGB:
200 bind_to_texture_rgb = value;
201 break;
202
203 case __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA:
204 bind_to_texture_rgba = value;
205 break;
206
207 case __DRI_ATTRIB_DOUBLE_BUFFER:
208 double_buffer = value;
209 break;
210
211 case __DRI_ATTRIB_RED_MASK:
212 dri_masks[0] = value;
213 break;
214
215 case __DRI_ATTRIB_GREEN_MASK:
216 dri_masks[1] = value;
217 break;
218
219 case __DRI_ATTRIB_BLUE_MASK:
220 dri_masks[2] = value;
221 break;
222
223 case __DRI_ATTRIB_ALPHA_MASK:
224 dri_masks[3] = value;
225 break;
226
227 case __DRI_ATTRIB_ACCUM_RED_SIZE:
228 case __DRI_ATTRIB_ACCUM_GREEN_SIZE:
229 case __DRI_ATTRIB_ACCUM_BLUE_SIZE:
230 case __DRI_ATTRIB_ACCUM_ALPHA_SIZE:
231 /* Don't expose visuals with the accumulation buffer. */
232 if (value > 0)
233 return NULL;
234 break;
235
236 case __DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE:
237 srgb = value != 0;
238 break;
239
240 default:
241 key = dri2_to_egl_attribute_map[attrib];
242 if (key != 0)
243 _eglSetConfigKey(&base, key, value);
244 break;
245 }
246 }
247
248 if (attr_list)
249 for (i = 0; attr_list[i] != EGL_NONE; i += 2)
250 _eglSetConfigKey(&base, attr_list[i], attr_list[i+1]);
251
252 if (rgba_masks && memcmp(rgba_masks, dri_masks, sizeof(dri_masks)))
253 return NULL;
254
255 base.NativeRenderable = EGL_TRUE;
256
257 base.SurfaceType = surface_type;
258 if (surface_type & (EGL_PBUFFER_BIT |
259 (disp->Extensions.NOK_texture_from_pixmap ? EGL_PIXMAP_BIT : 0))) {
260 base.BindToTextureRGB = bind_to_texture_rgb;
261 if (base.AlphaSize > 0)
262 base.BindToTextureRGBA = bind_to_texture_rgba;
263 }
264
265 base.RenderableType = disp->ClientAPIs;
266 base.Conformant = disp->ClientAPIs;
267
268 base.MinSwapInterval = dri2_dpy->min_swap_interval;
269 base.MaxSwapInterval = dri2_dpy->max_swap_interval;
270
271 if (!_eglValidateConfig(&base, EGL_FALSE)) {
272 _eglLog(_EGL_DEBUG, "DRI2: failed to validate config %d", id);
273 return NULL;
274 }
275
276 config_id = base.ConfigID;
277 base.ConfigID = EGL_DONT_CARE;
278 base.SurfaceType = EGL_DONT_CARE;
279 num_configs = _eglFilterArray(disp->Configs, (void **) &matching_config, 1,
280 (_EGLArrayForEach) dri2_match_config, &base);
281
282 if (num_configs == 1) {
283 conf = (struct dri2_egl_config *) matching_config;
284
285 if (double_buffer && !conf->dri_double_config[srgb])
286 conf->dri_double_config[srgb] = dri_config;
287 else if (!double_buffer && !conf->dri_single_config[srgb])
288 conf->dri_single_config[srgb] = dri_config;
289 else
290 /* a similar config type is already added (unlikely) => discard */
291 return NULL;
292 }
293 else if (num_configs == 0) {
294 conf = calloc(1, sizeof *conf);
295 if (conf == NULL)
296 return NULL;
297
298 if (double_buffer)
299 conf->dri_double_config[srgb] = dri_config;
300 else
301 conf->dri_single_config[srgb] = dri_config;
302
303 memcpy(&conf->base, &base, sizeof base);
304 conf->base.SurfaceType = 0;
305 conf->base.ConfigID = config_id;
306
307 _eglLinkConfig(&conf->base);
308 }
309 else {
310 assert(0);
311 return NULL;
312 }
313
314 if (double_buffer) {
315 surface_type &= ~EGL_PIXMAP_BIT;
316 }
317
318 conf->base.SurfaceType |= surface_type;
319
320 return conf;
321 }
322
323 __DRIimage *
324 dri2_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
325 {
326 _EGLDisplay *disp = data;
327 struct dri2_egl_image *dri2_img;
328 _EGLImage *img;
329
330 (void) screen;
331
332 img = _eglLookupImage(image, disp);
333 if (img == NULL) {
334 _eglError(EGL_BAD_PARAMETER, "dri2_lookup_egl_image");
335 return NULL;
336 }
337
338 dri2_img = dri2_egl_image(image);
339
340 return dri2_img->dri_image;
341 }
342
343 const __DRIimageLookupExtension image_lookup_extension = {
344 .base = { __DRI_IMAGE_LOOKUP, 1 },
345
346 .lookupEGLImage = dri2_lookup_egl_image
347 };
348
349 struct dri2_extension_match {
350 const char *name;
351 int version;
352 int offset;
353 };
354
355 static struct dri2_extension_match dri2_driver_extensions[] = {
356 { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
357 { __DRI_DRI2, 2, offsetof(struct dri2_egl_display, dri2) },
358 { NULL, 0, 0 }
359 };
360
361 static struct dri2_extension_match dri2_core_extensions[] = {
362 { __DRI2_FLUSH, 1, offsetof(struct dri2_egl_display, flush) },
363 { __DRI_TEX_BUFFER, 2, offsetof(struct dri2_egl_display, tex_buffer) },
364 { __DRI_IMAGE, 1, offsetof(struct dri2_egl_display, image) },
365 { NULL, 0, 0 }
366 };
367
368 static struct dri2_extension_match swrast_driver_extensions[] = {
369 { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
370 { __DRI_SWRAST, 2, offsetof(struct dri2_egl_display, swrast) },
371 { NULL, 0, 0 }
372 };
373
374 static struct dri2_extension_match swrast_core_extensions[] = {
375 { __DRI_TEX_BUFFER, 2, offsetof(struct dri2_egl_display, tex_buffer) },
376 { NULL, 0, 0 }
377 };
378
379 static EGLBoolean
380 dri2_bind_extensions(struct dri2_egl_display *dri2_dpy,
381 struct dri2_extension_match *matches,
382 const __DRIextension **extensions)
383 {
384 int i, j, ret = EGL_TRUE;
385 void *field;
386
387 for (i = 0; extensions[i]; i++) {
388 _eglLog(_EGL_DEBUG, "DRI2: found extension `%s'", extensions[i]->name);
389 for (j = 0; matches[j].name; j++) {
390 if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
391 extensions[i]->version >= matches[j].version) {
392 field = ((char *) dri2_dpy + matches[j].offset);
393 *(const __DRIextension **) field = extensions[i];
394 _eglLog(_EGL_INFO, "DRI2: found extension %s version %d",
395 extensions[i]->name, extensions[i]->version);
396 }
397 }
398 }
399
400 for (j = 0; matches[j].name; j++) {
401 field = ((char *) dri2_dpy + matches[j].offset);
402 if (*(const __DRIextension **) field == NULL) {
403 _eglLog(_EGL_WARNING, "DRI2: did not find extension %s version %d",
404 matches[j].name, matches[j].version);
405 ret = EGL_FALSE;
406 }
407 }
408
409 return ret;
410 }
411
412 static const __DRIextension **
413 dri2_open_driver(_EGLDisplay *disp)
414 {
415 struct dri2_egl_display *dri2_dpy = disp->DriverData;
416 const __DRIextension **extensions = NULL;
417 char path[PATH_MAX], *search_paths, *p, *next, *end;
418 char *get_extensions_name;
419 const __DRIextension **(*get_extensions)(void);
420
421 search_paths = NULL;
422 if (geteuid() == getuid()) {
423 /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
424 search_paths = getenv("LIBGL_DRIVERS_PATH");
425 }
426 if (search_paths == NULL)
427 search_paths = DEFAULT_DRIVER_DIR;
428
429 dri2_dpy->driver = NULL;
430 end = search_paths + strlen(search_paths);
431 for (p = search_paths; p < end; p = next + 1) {
432 int len;
433 next = strchr(p, ':');
434 if (next == NULL)
435 next = end;
436
437 len = next - p;
438 #if GLX_USE_TLS
439 snprintf(path, sizeof path,
440 "%.*s/tls/%s_dri.so", len, p, dri2_dpy->driver_name);
441 dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
442 #endif
443 if (dri2_dpy->driver == NULL) {
444 snprintf(path, sizeof path,
445 "%.*s/%s_dri.so", len, p, dri2_dpy->driver_name);
446 dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
447 if (dri2_dpy->driver == NULL)
448 _eglLog(_EGL_DEBUG, "failed to open %s: %s\n", path, dlerror());
449 }
450 /* not need continue to loop all paths once the driver is found */
451 if (dri2_dpy->driver != NULL)
452 break;
453
454 #ifdef ANDROID
455 snprintf(path, sizeof path, "%.*s/gallium_dri.so", len, p);
456 dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
457 if (dri2_dpy->driver == NULL)
458 _eglLog(_EGL_DEBUG, "failed to open %s: %s\n", path, dlerror());
459 else
460 break;
461 #endif
462 }
463
464 if (dri2_dpy->driver == NULL) {
465 _eglLog(_EGL_WARNING,
466 "DRI2: failed to open %s (search paths %s)",
467 dri2_dpy->driver_name, search_paths);
468 return NULL;
469 }
470
471 _eglLog(_EGL_DEBUG, "DRI2: dlopen(%s)", path);
472
473 if (asprintf(&get_extensions_name, "%s_%s",
474 __DRI_DRIVER_GET_EXTENSIONS, dri2_dpy->driver_name) != -1) {
475 get_extensions = dlsym(dri2_dpy->driver, get_extensions_name);
476 if (get_extensions) {
477 extensions = get_extensions();
478 } else {
479 _eglLog(_EGL_DEBUG, "driver does not expose %s(): %s\n",
480 get_extensions_name, dlerror());
481 }
482 free(get_extensions_name);
483 }
484
485 if (!extensions)
486 extensions = dlsym(dri2_dpy->driver, __DRI_DRIVER_EXTENSIONS);
487 if (extensions == NULL) {
488 _eglLog(_EGL_WARNING,
489 "DRI2: driver exports no extensions (%s)", dlerror());
490 dlclose(dri2_dpy->driver);
491 }
492
493 return extensions;
494 }
495
496 EGLBoolean
497 dri2_load_driver(_EGLDisplay *disp)
498 {
499 struct dri2_egl_display *dri2_dpy = disp->DriverData;
500 const __DRIextension **extensions;
501
502 extensions = dri2_open_driver(disp);
503 if (!extensions)
504 return EGL_FALSE;
505
506 if (!dri2_bind_extensions(dri2_dpy, dri2_driver_extensions, extensions)) {
507 dlclose(dri2_dpy->driver);
508 return EGL_FALSE;
509 }
510 dri2_dpy->driver_extensions = extensions;
511
512 return EGL_TRUE;
513 }
514
515 EGLBoolean
516 dri2_load_driver_swrast(_EGLDisplay *disp)
517 {
518 struct dri2_egl_display *dri2_dpy = disp->DriverData;
519 const __DRIextension **extensions;
520
521 extensions = dri2_open_driver(disp);
522 if (!extensions)
523 return EGL_FALSE;
524
525 if (!dri2_bind_extensions(dri2_dpy, swrast_driver_extensions, extensions)) {
526 dlclose(dri2_dpy->driver);
527 return EGL_FALSE;
528 }
529 dri2_dpy->driver_extensions = extensions;
530
531 return EGL_TRUE;
532 }
533
534 static unsigned
535 dri2_renderer_query_integer(struct dri2_egl_display *dri2_dpy, int param)
536 {
537 const __DRI2rendererQueryExtension *rendererQuery = dri2_dpy->rendererQuery;
538 unsigned int value = 0;
539
540 if (!rendererQuery ||
541 rendererQuery->queryInteger(dri2_dpy->dri_screen, param, &value) == -1)
542 return 0;
543
544 return value;
545 }
546
547 void
548 dri2_setup_screen(_EGLDisplay *disp)
549 {
550 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
551 unsigned int api_mask;
552
553 if (dri2_dpy->dri2) {
554 api_mask = dri2_dpy->dri2->getAPIMask(dri2_dpy->dri_screen);
555 } else {
556 assert(dri2_dpy->swrast);
557 api_mask = 1 << __DRI_API_OPENGL |
558 1 << __DRI_API_GLES |
559 1 << __DRI_API_GLES2 |
560 1 << __DRI_API_GLES3;
561 }
562
563 disp->ClientAPIs = 0;
564 if (api_mask & (1 <<__DRI_API_OPENGL))
565 disp->ClientAPIs |= EGL_OPENGL_BIT;
566 if (api_mask & (1 <<__DRI_API_GLES))
567 disp->ClientAPIs |= EGL_OPENGL_ES_BIT;
568 if (api_mask & (1 << __DRI_API_GLES2))
569 disp->ClientAPIs |= EGL_OPENGL_ES2_BIT;
570 if (api_mask & (1 << __DRI_API_GLES3))
571 disp->ClientAPIs |= EGL_OPENGL_ES3_BIT_KHR;
572
573 assert(dri2_dpy->dri2 || dri2_dpy->swrast);
574 disp->Extensions.KHR_surfaceless_context = EGL_TRUE;
575 disp->Extensions.MESA_configless_context = EGL_TRUE;
576
577 if (dri2_renderer_query_integer(dri2_dpy,
578 __DRI2_RENDERER_HAS_FRAMEBUFFER_SRGB))
579 disp->Extensions.KHR_gl_colorspace = EGL_TRUE;
580
581 if ((dri2_dpy->dri2 && dri2_dpy->dri2->base.version >= 3) ||
582 (dri2_dpy->swrast && dri2_dpy->swrast->base.version >= 3)) {
583 disp->Extensions.KHR_create_context = EGL_TRUE;
584
585 if (dri2_dpy->robustness)
586 disp->Extensions.EXT_create_context_robustness = EGL_TRUE;
587 }
588
589 if (dri2_dpy->fence) {
590 disp->Extensions.KHR_fence_sync = EGL_TRUE;
591 disp->Extensions.KHR_wait_sync = EGL_TRUE;
592 if (dri2_dpy->fence->get_fence_from_cl_event)
593 disp->Extensions.KHR_cl_event2 = EGL_TRUE;
594 }
595
596 if (dri2_dpy->image) {
597 if (dri2_dpy->image->base.version >= 10 &&
598 dri2_dpy->image->getCapabilities != NULL) {
599 int capabilities;
600
601 capabilities = dri2_dpy->image->getCapabilities(dri2_dpy->dri_screen);
602 disp->Extensions.MESA_drm_image = (capabilities & __DRI_IMAGE_CAP_GLOBAL_NAMES) != 0;
603
604 if (dri2_dpy->image->base.version >= 11)
605 disp->Extensions.MESA_image_dma_buf_export = EGL_TRUE;
606 } else {
607 disp->Extensions.MESA_drm_image = EGL_TRUE;
608 if (dri2_dpy->image->base.version >= 11)
609 disp->Extensions.MESA_image_dma_buf_export = EGL_TRUE;
610 }
611
612 disp->Extensions.KHR_image_base = EGL_TRUE;
613 disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
614 if (dri2_dpy->image->base.version >= 5 &&
615 dri2_dpy->image->createImageFromTexture) {
616 disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
617 disp->Extensions.KHR_gl_texture_cubemap_image = EGL_TRUE;
618 }
619 if (dri2_renderer_query_integer(dri2_dpy,
620 __DRI2_RENDERER_HAS_TEXTURE_3D))
621 disp->Extensions.KHR_gl_texture_3D_image = EGL_TRUE;
622 #ifdef HAVE_LIBDRM
623 if (dri2_dpy->image->base.version >= 8 &&
624 dri2_dpy->image->createImageFromDmaBufs) {
625 disp->Extensions.EXT_image_dma_buf_import = EGL_TRUE;
626 }
627 #endif
628 }
629 }
630
631 /* All platforms but DRM call this function to create the screen, query the
632 * dri extensions, setup the vtables and populate the driver_configs.
633 * DRM inherits all that information from its display - GBM.
634 */
635 EGLBoolean
636 dri2_create_screen(_EGLDisplay *disp)
637 {
638 const __DRIextension **extensions;
639 struct dri2_egl_display *dri2_dpy;
640 unsigned i;
641
642 dri2_dpy = disp->DriverData;
643
644 if (dri2_dpy->dri2) {
645 if (dri2_dpy->dri2->base.version >= 4) {
646 dri2_dpy->dri_screen =
647 dri2_dpy->dri2->createNewScreen2(0, dri2_dpy->fd,
648 dri2_dpy->extensions,
649 dri2_dpy->driver_extensions,
650 &dri2_dpy->driver_configs, disp);
651 } else {
652 dri2_dpy->dri_screen =
653 dri2_dpy->dri2->createNewScreen(0, dri2_dpy->fd,
654 dri2_dpy->extensions,
655 &dri2_dpy->driver_configs, disp);
656 }
657 } else {
658 assert(dri2_dpy->swrast);
659 if (dri2_dpy->swrast->base.version >= 4) {
660 dri2_dpy->dri_screen =
661 dri2_dpy->swrast->createNewScreen2(0, dri2_dpy->extensions,
662 dri2_dpy->driver_extensions,
663 &dri2_dpy->driver_configs, disp);
664 } else {
665 dri2_dpy->dri_screen =
666 dri2_dpy->swrast->createNewScreen(0, dri2_dpy->extensions,
667 &dri2_dpy->driver_configs, disp);
668 }
669 }
670
671 if (dri2_dpy->dri_screen == NULL) {
672 _eglLog(_EGL_WARNING, "DRI2: failed to create dri screen");
673 return EGL_FALSE;
674 }
675
676 dri2_dpy->own_dri_screen = 1;
677
678 extensions = dri2_dpy->core->getExtensions(dri2_dpy->dri_screen);
679
680 if (dri2_dpy->dri2) {
681 if (!dri2_bind_extensions(dri2_dpy, dri2_core_extensions, extensions))
682 goto cleanup_dri_screen;
683 } else {
684 assert(dri2_dpy->swrast);
685 if (!dri2_bind_extensions(dri2_dpy, swrast_core_extensions, extensions))
686 goto cleanup_dri_screen;
687 }
688
689 for (i = 0; extensions[i]; i++) {
690 if (strcmp(extensions[i]->name, __DRI2_ROBUSTNESS) == 0) {
691 dri2_dpy->robustness = (__DRIrobustnessExtension *) extensions[i];
692 }
693 if (strcmp(extensions[i]->name, __DRI2_CONFIG_QUERY) == 0) {
694 dri2_dpy->config = (__DRI2configQueryExtension *) extensions[i];
695 }
696 if (strcmp(extensions[i]->name, __DRI2_FENCE) == 0) {
697 dri2_dpy->fence = (__DRI2fenceExtension *) extensions[i];
698 }
699 if (strcmp(extensions[i]->name, __DRI2_RENDERER_QUERY) == 0) {
700 dri2_dpy->rendererQuery = (__DRI2rendererQueryExtension *) extensions[i];
701 }
702 }
703
704 dri2_setup_screen(disp);
705
706 return EGL_TRUE;
707
708 cleanup_dri_screen:
709 dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
710
711 return EGL_FALSE;
712 }
713
714 /**
715 * Called via eglInitialize(), GLX_drv->API.Initialize().
716 */
717 static EGLBoolean
718 dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp)
719 {
720 /* not until swrast_dri is supported */
721 if (disp->Options.UseFallback)
722 return EGL_FALSE;
723
724 switch (disp->Platform) {
725 #ifdef HAVE_SURFACELESS_PLATFORM
726 case _EGL_PLATFORM_SURFACELESS:
727 if (disp->Options.TestOnly)
728 return EGL_TRUE;
729 return dri2_initialize_surfaceless(drv, disp);
730 #endif
731
732 #ifdef HAVE_X11_PLATFORM
733 case _EGL_PLATFORM_X11:
734 if (disp->Options.TestOnly)
735 return EGL_TRUE;
736 return dri2_initialize_x11(drv, disp);
737 #endif
738
739 #ifdef HAVE_DRM_PLATFORM
740 case _EGL_PLATFORM_DRM:
741 if (disp->Options.TestOnly)
742 return EGL_TRUE;
743 return dri2_initialize_drm(drv, disp);
744 #endif
745 #ifdef HAVE_WAYLAND_PLATFORM
746 case _EGL_PLATFORM_WAYLAND:
747 if (disp->Options.TestOnly)
748 return EGL_TRUE;
749 return dri2_initialize_wayland(drv, disp);
750 #endif
751 #ifdef HAVE_ANDROID_PLATFORM
752 case _EGL_PLATFORM_ANDROID:
753 if (disp->Options.TestOnly)
754 return EGL_TRUE;
755 return dri2_initialize_android(drv, disp);
756 #endif
757
758 default:
759 _eglLog(_EGL_WARNING, "No EGL platform enabled.");
760 return EGL_FALSE;
761 }
762 }
763
764 /**
765 * Called via eglTerminate(), drv->API.Terminate().
766 */
767 static EGLBoolean
768 dri2_terminate(_EGLDriver *drv, _EGLDisplay *disp)
769 {
770 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
771 unsigned i;
772
773 _eglReleaseDisplayResources(drv, disp);
774 _eglCleanupDisplay(disp);
775
776 if (dri2_dpy->own_dri_screen)
777 dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
778 if (dri2_dpy->fd >= 0)
779 close(dri2_dpy->fd);
780 if (dri2_dpy->driver)
781 dlclose(dri2_dpy->driver);
782 free(dri2_dpy->device_name);
783 free(dri2_dpy->driver_name);
784
785 switch (disp->Platform) {
786 #ifdef HAVE_X11_PLATFORM
787 case _EGL_PLATFORM_X11:
788 if (dri2_dpy->own_device) {
789 xcb_disconnect(dri2_dpy->conn);
790 }
791 break;
792 #endif
793 #ifdef HAVE_DRM_PLATFORM
794 case _EGL_PLATFORM_DRM:
795 if (dri2_dpy->own_device) {
796 gbm_device_destroy(&dri2_dpy->gbm_dri->base.base);
797 }
798 break;
799 #endif
800 #ifdef HAVE_WAYLAND_PLATFORM
801 case _EGL_PLATFORM_WAYLAND:
802 if (dri2_dpy->wl_drm)
803 wl_drm_destroy(dri2_dpy->wl_drm);
804 if (dri2_dpy->wl_shm)
805 wl_shm_destroy(dri2_dpy->wl_shm);
806 wl_registry_destroy(dri2_dpy->wl_registry);
807 wl_event_queue_destroy(dri2_dpy->wl_queue);
808 if (dri2_dpy->own_device) {
809 wl_display_disconnect(dri2_dpy->wl_dpy);
810 }
811 break;
812 #endif
813 default:
814 break;
815 }
816
817 /* The drm platform does not create the screen/driver_configs but reuses
818 * the ones from the gbm device. As such the gbm itself is responsible
819 * for the cleanup.
820 */
821 if (disp->Platform != _EGL_PLATFORM_DRM) {
822 for (i = 0; dri2_dpy->driver_configs[i]; i++)
823 free((__DRIconfig *) dri2_dpy->driver_configs[i]);
824 free(dri2_dpy->driver_configs);
825 }
826 free(dri2_dpy);
827 disp->DriverData = NULL;
828
829 return EGL_TRUE;
830 }
831
832 /**
833 * Set the error code after a call to
834 * dri2_egl_display::dri2::createContextAttribs.
835 */
836 static void
837 dri2_create_context_attribs_error(int dri_error)
838 {
839 EGLint egl_error;
840
841 switch (dri_error) {
842 case __DRI_CTX_ERROR_SUCCESS:
843 return;
844
845 case __DRI_CTX_ERROR_NO_MEMORY:
846 egl_error = EGL_BAD_ALLOC;
847 break;
848
849 /* From the EGL_KHR_create_context spec, section "Errors":
850 *
851 * * If <config> does not support a client API context compatible
852 * with the requested API major and minor version, [...] context flags,
853 * and context reset notification behavior (for client API types where
854 * these attributes are supported), then an EGL_BAD_MATCH error is
855 * generated.
856 *
857 * * If an OpenGL ES context is requested and the values for
858 * attributes EGL_CONTEXT_MAJOR_VERSION_KHR and
859 * EGL_CONTEXT_MINOR_VERSION_KHR specify an OpenGL ES version that
860 * is not defined, than an EGL_BAD_MATCH error is generated.
861 *
862 * * If an OpenGL context is requested, the requested version is
863 * greater than 3.2, and the value for attribute
864 * EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR has no bits set; has any
865 * bits set other than EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR and
866 * EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR; has more than
867 * one of these bits set; or if the implementation does not support
868 * the requested profile, then an EGL_BAD_MATCH error is generated.
869 */
870 case __DRI_CTX_ERROR_BAD_API:
871 case __DRI_CTX_ERROR_BAD_VERSION:
872 case __DRI_CTX_ERROR_BAD_FLAG:
873 egl_error = EGL_BAD_MATCH;
874 break;
875
876 /* From the EGL_KHR_create_context spec, section "Errors":
877 *
878 * * If an attribute name or attribute value in <attrib_list> is not
879 * recognized (including unrecognized bits in bitmask attributes),
880 * then an EGL_BAD_ATTRIBUTE error is generated."
881 */
882 case __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE:
883 case __DRI_CTX_ERROR_UNKNOWN_FLAG:
884 egl_error = EGL_BAD_ATTRIBUTE;
885 break;
886
887 default:
888 assert(0);
889 egl_error = EGL_BAD_MATCH;
890 break;
891 }
892
893 _eglError(egl_error, "dri2_create_context");
894 }
895
896 static bool
897 dri2_fill_context_attribs(struct dri2_egl_context *dri2_ctx,
898 struct dri2_egl_display *dri2_dpy,
899 uint32_t *ctx_attribs,
900 unsigned *num_attribs)
901 {
902 int pos = 0;
903
904 assert(*num_attribs >= 8);
905
906 ctx_attribs[pos++] = __DRI_CTX_ATTRIB_MAJOR_VERSION;
907 ctx_attribs[pos++] = dri2_ctx->base.ClientMajorVersion;
908 ctx_attribs[pos++] = __DRI_CTX_ATTRIB_MINOR_VERSION;
909 ctx_attribs[pos++] = dri2_ctx->base.ClientMinorVersion;
910
911 if (dri2_ctx->base.Flags != 0) {
912 /* If the implementation doesn't support the __DRI2_ROBUSTNESS
913 * extension, don't even try to send it the robust-access flag.
914 * It may explode. Instead, generate the required EGL error here.
915 */
916 if ((dri2_ctx->base.Flags & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR) != 0
917 && !dri2_dpy->robustness) {
918 _eglError(EGL_BAD_MATCH, "eglCreateContext");
919 return false;
920 }
921
922 ctx_attribs[pos++] = __DRI_CTX_ATTRIB_FLAGS;
923 ctx_attribs[pos++] = dri2_ctx->base.Flags;
924 }
925
926 if (dri2_ctx->base.ResetNotificationStrategy != EGL_NO_RESET_NOTIFICATION_KHR) {
927 /* If the implementation doesn't support the __DRI2_ROBUSTNESS
928 * extension, don't even try to send it a reset strategy. It may
929 * explode. Instead, generate the required EGL error here.
930 */
931 if (!dri2_dpy->robustness) {
932 _eglError(EGL_BAD_CONFIG, "eglCreateContext");
933 return false;
934 }
935
936 ctx_attribs[pos++] = __DRI_CTX_ATTRIB_RESET_STRATEGY;
937 ctx_attribs[pos++] = __DRI_CTX_RESET_LOSE_CONTEXT;
938 }
939
940 *num_attribs = pos;
941
942 return true;
943 }
944
945 /**
946 * Called via eglCreateContext(), drv->API.CreateContext().
947 */
948 static _EGLContext *
949 dri2_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
950 _EGLContext *share_list, const EGLint *attrib_list)
951 {
952 struct dri2_egl_context *dri2_ctx;
953 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
954 struct dri2_egl_context *dri2_ctx_shared = dri2_egl_context(share_list);
955 __DRIcontext *shared =
956 dri2_ctx_shared ? dri2_ctx_shared->dri_context : NULL;
957 struct dri2_egl_config *dri2_config = dri2_egl_config(conf);
958 const __DRIconfig *dri_config;
959 int api;
960
961 (void) drv;
962
963 dri2_ctx = malloc(sizeof *dri2_ctx);
964 if (!dri2_ctx) {
965 _eglError(EGL_BAD_ALLOC, "eglCreateContext");
966 return NULL;
967 }
968
969 if (!_eglInitContext(&dri2_ctx->base, disp, conf, attrib_list))
970 goto cleanup;
971
972 switch (dri2_ctx->base.ClientAPI) {
973 case EGL_OPENGL_ES_API:
974 switch (dri2_ctx->base.ClientMajorVersion) {
975 case 1:
976 api = __DRI_API_GLES;
977 break;
978 case 2:
979 api = __DRI_API_GLES2;
980 break;
981 case 3:
982 api = __DRI_API_GLES3;
983 break;
984 default:
985 _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
986 free(dri2_ctx);
987 return NULL;
988 }
989 break;
990 case EGL_OPENGL_API:
991 if ((dri2_ctx->base.ClientMajorVersion >= 4
992 || (dri2_ctx->base.ClientMajorVersion == 3
993 && dri2_ctx->base.ClientMinorVersion >= 2))
994 && dri2_ctx->base.Profile == EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR)
995 api = __DRI_API_OPENGL_CORE;
996 else
997 api = __DRI_API_OPENGL;
998 break;
999 default:
1000 _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
1001 free(dri2_ctx);
1002 return NULL;
1003 }
1004
1005 if (conf != NULL) {
1006 /* The config chosen here isn't necessarily
1007 * used for surfaces later.
1008 * A pixmap surface will use the single config.
1009 * This opportunity depends on disabling the
1010 * doubleBufferMode check in
1011 * src/mesa/main/context.c:check_compatible()
1012 */
1013 if (dri2_config->dri_double_config[0])
1014 dri_config = dri2_config->dri_double_config[0];
1015 else
1016 dri_config = dri2_config->dri_single_config[0];
1017
1018 /* EGL_WINDOW_BIT is set only when there is a dri_double_config. This
1019 * makes sure the back buffer will always be used.
1020 */
1021 if (conf->SurfaceType & EGL_WINDOW_BIT)
1022 dri2_ctx->base.WindowRenderBuffer = EGL_BACK_BUFFER;
1023 }
1024 else
1025 dri_config = NULL;
1026
1027 if (dri2_dpy->dri2) {
1028 if (dri2_dpy->dri2->base.version >= 3) {
1029 unsigned error;
1030 unsigned num_attribs = 8;
1031 uint32_t ctx_attribs[8];
1032
1033 if (!dri2_fill_context_attribs(dri2_ctx, dri2_dpy, ctx_attribs,
1034 &num_attribs))
1035 goto cleanup;
1036
1037 dri2_ctx->dri_context =
1038 dri2_dpy->dri2->createContextAttribs(dri2_dpy->dri_screen,
1039 api,
1040 dri_config,
1041 shared,
1042 num_attribs / 2,
1043 ctx_attribs,
1044 & error,
1045 dri2_ctx);
1046 dri2_create_context_attribs_error(error);
1047 } else {
1048 dri2_ctx->dri_context =
1049 dri2_dpy->dri2->createNewContextForAPI(dri2_dpy->dri_screen,
1050 api,
1051 dri_config,
1052 shared,
1053 dri2_ctx);
1054 }
1055 } else {
1056 assert(dri2_dpy->swrast);
1057 if (dri2_dpy->swrast->base.version >= 3) {
1058 unsigned error;
1059 unsigned num_attribs = 8;
1060 uint32_t ctx_attribs[8];
1061
1062 if (!dri2_fill_context_attribs(dri2_ctx, dri2_dpy, ctx_attribs,
1063 &num_attribs))
1064 goto cleanup;
1065
1066 dri2_ctx->dri_context =
1067 dri2_dpy->swrast->createContextAttribs(dri2_dpy->dri_screen,
1068 api,
1069 dri_config,
1070 shared,
1071 num_attribs / 2,
1072 ctx_attribs,
1073 & error,
1074 dri2_ctx);
1075 dri2_create_context_attribs_error(error);
1076 } else {
1077 dri2_ctx->dri_context =
1078 dri2_dpy->swrast->createNewContextForAPI(dri2_dpy->dri_screen,
1079 api,
1080 dri_config,
1081 shared,
1082 dri2_ctx);
1083 }
1084 }
1085
1086 if (!dri2_ctx->dri_context)
1087 goto cleanup;
1088
1089 return &dri2_ctx->base;
1090
1091 cleanup:
1092 free(dri2_ctx);
1093 return NULL;
1094 }
1095
1096 /**
1097 * Called via eglDestroyContext(), drv->API.DestroyContext().
1098 */
1099 static EGLBoolean
1100 dri2_destroy_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
1101 {
1102 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1103 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1104
1105 if (_eglPutContext(ctx)) {
1106 dri2_dpy->core->destroyContext(dri2_ctx->dri_context);
1107 free(dri2_ctx);
1108 }
1109
1110 return EGL_TRUE;
1111 }
1112
1113 /**
1114 * Called via eglMakeCurrent(), drv->API.MakeCurrent().
1115 */
1116 static EGLBoolean
1117 dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
1118 _EGLSurface *rsurf, _EGLContext *ctx)
1119 {
1120 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1121 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1122 struct dri2_egl_surface *dri2_dsurf = dri2_egl_surface(dsurf);
1123 struct dri2_egl_surface *dri2_rsurf = dri2_egl_surface(rsurf);
1124 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1125 _EGLContext *old_ctx;
1126 _EGLSurface *old_dsurf, *old_rsurf;
1127 __DRIdrawable *ddraw, *rdraw;
1128 __DRIcontext *cctx;
1129
1130 /* make new bindings */
1131 if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
1132 return EGL_FALSE;
1133
1134 /* flush before context switch */
1135 if (old_ctx && dri2_drv->glFlush)
1136 dri2_drv->glFlush();
1137
1138 ddraw = (dri2_dsurf) ? dri2_dsurf->dri_drawable : NULL;
1139 rdraw = (dri2_rsurf) ? dri2_rsurf->dri_drawable : NULL;
1140 cctx = (dri2_ctx) ? dri2_ctx->dri_context : NULL;
1141
1142 if (old_ctx) {
1143 __DRIcontext *old_cctx = dri2_egl_context(old_ctx)->dri_context;
1144 dri2_dpy->core->unbindContext(old_cctx);
1145 }
1146
1147 if ((cctx == NULL && ddraw == NULL && rdraw == NULL) ||
1148 dri2_dpy->core->bindContext(cctx, ddraw, rdraw)) {
1149 if (old_dsurf)
1150 drv->API.DestroySurface(drv, disp, old_dsurf);
1151 if (old_rsurf)
1152 drv->API.DestroySurface(drv, disp, old_rsurf);
1153 if (old_ctx)
1154 drv->API.DestroyContext(drv, disp, old_ctx);
1155
1156 return EGL_TRUE;
1157 } else {
1158 /* undo the previous _eglBindContext */
1159 _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &dsurf, &rsurf);
1160 assert(&dri2_ctx->base == ctx &&
1161 &dri2_dsurf->base == dsurf &&
1162 &dri2_rsurf->base == rsurf);
1163
1164 _eglPutSurface(dsurf);
1165 _eglPutSurface(rsurf);
1166 _eglPutContext(ctx);
1167
1168 _eglPutSurface(old_dsurf);
1169 _eglPutSurface(old_rsurf);
1170 _eglPutContext(old_ctx);
1171
1172 return EGL_FALSE;
1173 }
1174 }
1175
1176 /*
1177 * Called from eglGetProcAddress() via drv->API.GetProcAddress().
1178 */
1179 static _EGLProc
1180 dri2_get_proc_address(_EGLDriver *drv, const char *procname)
1181 {
1182 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1183
1184 return dri2_drv->get_proc_address(procname);
1185 }
1186
1187 static _EGLSurface*
1188 dri2_create_window_surface(_EGLDriver *drv, _EGLDisplay *dpy,
1189 _EGLConfig *conf, void *native_window,
1190 const EGLint *attrib_list)
1191 {
1192 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1193 return dri2_dpy->vtbl->create_window_surface(drv, dpy, conf, native_window,
1194 attrib_list);
1195 }
1196
1197 static _EGLSurface*
1198 dri2_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *dpy,
1199 _EGLConfig *conf, void *native_pixmap,
1200 const EGLint *attrib_list)
1201 {
1202 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1203 return dri2_dpy->vtbl->create_pixmap_surface(drv, dpy, conf, native_pixmap,
1204 attrib_list);
1205 }
1206
1207 static _EGLSurface*
1208 dri2_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy,
1209 _EGLConfig *conf, const EGLint *attrib_list)
1210 {
1211 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1212 return dri2_dpy->vtbl->create_pbuffer_surface(drv, dpy, conf, attrib_list);
1213 }
1214
1215 static EGLBoolean
1216 dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
1217 {
1218 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1219 return dri2_dpy->vtbl->destroy_surface(drv, dpy, surf);
1220 }
1221
1222 static EGLBoolean
1223 dri2_swap_interval(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
1224 EGLint interval)
1225 {
1226 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1227 return dri2_dpy->vtbl->swap_interval(drv, dpy, surf, interval);
1228 }
1229
1230 /**
1231 * Asks the client API to flush any rendering to the drawable so that we can
1232 * do our swapbuffers.
1233 */
1234 void
1235 dri2_flush_drawable_for_swapbuffers(_EGLDisplay *disp, _EGLSurface *draw)
1236 {
1237 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1238 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1239
1240 if (dri2_dpy->flush) {
1241 if (dri2_dpy->flush->base.version >= 4) {
1242 /* We know there's a current context because:
1243 *
1244 * "If surface is not bound to the calling thread’s current
1245 * context, an EGL_BAD_SURFACE error is generated."
1246 */
1247 _EGLContext *ctx = _eglGetCurrentContext();
1248 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1249
1250 /* From the EGL 1.4 spec (page 52):
1251 *
1252 * "The contents of ancillary buffers are always undefined
1253 * after calling eglSwapBuffers."
1254 */
1255 dri2_dpy->flush->flush_with_flags(dri2_ctx->dri_context,
1256 dri2_surf->dri_drawable,
1257 __DRI2_FLUSH_DRAWABLE |
1258 __DRI2_FLUSH_INVALIDATE_ANCILLARY,
1259 __DRI2_THROTTLE_SWAPBUFFER);
1260 } else {
1261 dri2_dpy->flush->flush(dri2_surf->dri_drawable);
1262 }
1263 }
1264 }
1265
1266 static EGLBoolean
1267 dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
1268 {
1269 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1270 return dri2_dpy->vtbl->swap_buffers(drv, dpy, surf);
1271 }
1272
1273 static EGLBoolean
1274 dri2_swap_buffers_with_damage(_EGLDriver *drv, _EGLDisplay *dpy,
1275 _EGLSurface *surf,
1276 const EGLint *rects, EGLint n_rects)
1277 {
1278 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1279 return dri2_dpy->vtbl->swap_buffers_with_damage(drv, dpy, surf,
1280 rects, n_rects);
1281 }
1282
1283 static EGLBoolean
1284 dri2_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
1285 EGLint numRects, const EGLint *rects)
1286 {
1287 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1288 return dri2_dpy->vtbl->swap_buffers_region(drv, dpy, surf, numRects, rects);
1289 }
1290
1291 static EGLBoolean
1292 dri2_post_sub_buffer(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
1293 EGLint x, EGLint y, EGLint width, EGLint height)
1294 {
1295 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1296 return dri2_dpy->vtbl->post_sub_buffer(drv, dpy, surf, x, y, width, height);
1297 }
1298
1299 static EGLBoolean
1300 dri2_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
1301 void *native_pixmap_target)
1302 {
1303 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1304 return dri2_dpy->vtbl->copy_buffers(drv, dpy, surf, native_pixmap_target);
1305 }
1306
1307 static EGLint
1308 dri2_query_buffer_age(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
1309 {
1310 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1311 return dri2_dpy->vtbl->query_buffer_age(drv, dpy, surf);
1312 }
1313
1314 static EGLBoolean
1315 dri2_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
1316 {
1317 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1318 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(ctx->DrawSurface);
1319
1320 (void) drv;
1321
1322 /* FIXME: If EGL allows frontbuffer rendering for window surfaces,
1323 * we need to copy fake to real here.*/
1324
1325 if (dri2_dpy->flush != NULL)
1326 dri2_dpy->flush->flush(dri2_surf->dri_drawable);
1327
1328 return EGL_TRUE;
1329 }
1330
1331 static EGLBoolean
1332 dri2_wait_native(_EGLDriver *drv, _EGLDisplay *disp, EGLint engine)
1333 {
1334 (void) drv;
1335 (void) disp;
1336
1337 if (engine != EGL_CORE_NATIVE_ENGINE)
1338 return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
1339 /* glXWaitX(); */
1340
1341 return EGL_TRUE;
1342 }
1343
1344 static EGLBoolean
1345 dri2_bind_tex_image(_EGLDriver *drv,
1346 _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1347 {
1348 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1349 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1350 struct dri2_egl_context *dri2_ctx;
1351 _EGLContext *ctx;
1352 GLint format, target;
1353
1354 ctx = _eglGetCurrentContext();
1355 dri2_ctx = dri2_egl_context(ctx);
1356
1357 if (!_eglBindTexImage(drv, disp, surf, buffer))
1358 return EGL_FALSE;
1359
1360 switch (dri2_surf->base.TextureFormat) {
1361 case EGL_TEXTURE_RGB:
1362 format = __DRI_TEXTURE_FORMAT_RGB;
1363 break;
1364 case EGL_TEXTURE_RGBA:
1365 format = __DRI_TEXTURE_FORMAT_RGBA;
1366 break;
1367 default:
1368 assert(!"Unexpected texture format in dri2_bind_tex_image()");
1369 format = __DRI_TEXTURE_FORMAT_RGBA;
1370 }
1371
1372 switch (dri2_surf->base.TextureTarget) {
1373 case EGL_TEXTURE_2D:
1374 target = GL_TEXTURE_2D;
1375 break;
1376 default:
1377 target = GL_TEXTURE_2D;
1378 assert(!"Unexpected texture target in dri2_bind_tex_image()");
1379 }
1380
1381 (*dri2_dpy->tex_buffer->setTexBuffer2)(dri2_ctx->dri_context,
1382 target, format,
1383 dri2_surf->dri_drawable);
1384
1385 return EGL_TRUE;
1386 }
1387
1388 static EGLBoolean
1389 dri2_release_tex_image(_EGLDriver *drv,
1390 _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1391 {
1392 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1393 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1394 struct dri2_egl_context *dri2_ctx;
1395 _EGLContext *ctx;
1396 GLint target;
1397
1398 ctx = _eglGetCurrentContext();
1399 dri2_ctx = dri2_egl_context(ctx);
1400
1401 if (!_eglReleaseTexImage(drv, disp, surf, buffer))
1402 return EGL_FALSE;
1403
1404 switch (dri2_surf->base.TextureTarget) {
1405 case EGL_TEXTURE_2D:
1406 target = GL_TEXTURE_2D;
1407 break;
1408 default:
1409 assert(0);
1410 }
1411
1412 if (dri2_dpy->tex_buffer->base.version >= 3 &&
1413 dri2_dpy->tex_buffer->releaseTexBuffer != NULL) {
1414 (*dri2_dpy->tex_buffer->releaseTexBuffer)(dri2_ctx->dri_context,
1415 target,
1416 dri2_surf->dri_drawable);
1417 }
1418
1419 return EGL_TRUE;
1420 }
1421
1422 static _EGLImage*
1423 dri2_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx,
1424 EGLenum target, EGLClientBuffer buffer,
1425 const EGLint *attr_list)
1426 {
1427 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1428 return dri2_dpy->vtbl->create_image(drv, dpy, ctx, target, buffer,
1429 attr_list);
1430 }
1431
1432 static _EGLImage *
1433 dri2_create_image_from_dri(_EGLDisplay *disp, __DRIimage *dri_image)
1434 {
1435 struct dri2_egl_image *dri2_img;
1436
1437 if (dri_image == NULL) {
1438 _eglError(EGL_BAD_ALLOC, "dri2_create_image");
1439 return NULL;
1440 }
1441
1442 dri2_img = malloc(sizeof *dri2_img);
1443 if (!dri2_img) {
1444 _eglError(EGL_BAD_ALLOC, "dri2_create_image");
1445 return NULL;
1446 }
1447
1448 if (!_eglInitImage(&dri2_img->base, disp)) {
1449 free(dri2_img);
1450 return NULL;
1451 }
1452
1453 dri2_img->dri_image = dri_image;
1454
1455 return &dri2_img->base;
1456 }
1457
1458 static _EGLImage *
1459 dri2_create_image_khr_renderbuffer(_EGLDisplay *disp, _EGLContext *ctx,
1460 EGLClientBuffer buffer,
1461 const EGLint *attr_list)
1462 {
1463 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1464 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1465 GLuint renderbuffer = (GLuint) (uintptr_t) buffer;
1466 __DRIimage *dri_image;
1467
1468 if (renderbuffer == 0) {
1469 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
1470 return EGL_NO_IMAGE_KHR;
1471 }
1472
1473 dri_image =
1474 dri2_dpy->image->createImageFromRenderbuffer(dri2_ctx->dri_context,
1475 renderbuffer, NULL);
1476
1477 return dri2_create_image_from_dri(disp, dri_image);
1478 }
1479
1480 #ifdef HAVE_WAYLAND_PLATFORM
1481
1482 /* This structure describes how a wl_buffer maps to one or more
1483 * __DRIimages. A wl_drm_buffer stores the wl_drm format code and the
1484 * offsets and strides of the planes in the buffer. This table maps a
1485 * wl_drm format code to a description of the planes in the buffer
1486 * that lets us create a __DRIimage for each of the planes. */
1487
1488 static const struct wl_drm_components_descriptor {
1489 uint32_t dri_components;
1490 EGLint components;
1491 int nplanes;
1492 } wl_drm_components[] = {
1493 { __DRI_IMAGE_COMPONENTS_RGB, EGL_TEXTURE_RGB, 1 },
1494 { __DRI_IMAGE_COMPONENTS_RGBA, EGL_TEXTURE_RGBA, 1 },
1495 { __DRI_IMAGE_COMPONENTS_Y_U_V, EGL_TEXTURE_Y_U_V_WL, 3 },
1496 { __DRI_IMAGE_COMPONENTS_Y_UV, EGL_TEXTURE_Y_UV_WL, 2 },
1497 { __DRI_IMAGE_COMPONENTS_Y_XUXV, EGL_TEXTURE_Y_XUXV_WL, 2 },
1498 };
1499
1500 static _EGLImage *
1501 dri2_create_image_wayland_wl_buffer(_EGLDisplay *disp, _EGLContext *ctx,
1502 EGLClientBuffer _buffer,
1503 const EGLint *attr_list)
1504 {
1505 struct wl_drm_buffer *buffer;
1506 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1507 const struct wl_drm_components_descriptor *f;
1508 __DRIimage *dri_image;
1509 _EGLImageAttribs attrs;
1510 EGLint err;
1511 int32_t plane;
1512
1513 buffer = wayland_drm_buffer_get(dri2_dpy->wl_server_drm,
1514 (struct wl_resource *) _buffer);
1515 if (!buffer)
1516 return NULL;
1517
1518 err = _eglParseImageAttribList(&attrs, disp, attr_list);
1519 plane = attrs.PlaneWL;
1520 if (err != EGL_SUCCESS) {
1521 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_wayland_wl_buffer");
1522 return NULL;
1523 }
1524
1525 f = buffer->driver_format;
1526 if (plane < 0 || plane >= f->nplanes) {
1527 _eglError(EGL_BAD_PARAMETER,
1528 "dri2_create_image_wayland_wl_buffer (plane out of bounds)");
1529 return NULL;
1530 }
1531
1532 dri_image = dri2_dpy->image->fromPlanar(buffer->driver_buffer, plane, NULL);
1533
1534 if (dri_image == NULL) {
1535 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_wayland_wl_buffer");
1536 return NULL;
1537 }
1538
1539 return dri2_create_image_from_dri(disp, dri_image);
1540 }
1541 #endif
1542
1543 static EGLBoolean
1544 dri2_get_sync_values_chromium(_EGLDisplay *dpy, _EGLSurface *surf,
1545 EGLuint64KHR *ust, EGLuint64KHR *msc,
1546 EGLuint64KHR *sbc)
1547 {
1548 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1549 return dri2_dpy->vtbl->get_sync_values(dpy, surf, ust, msc, sbc);
1550 }
1551
1552 /**
1553 * Set the error code after a call to
1554 * dri2_egl_image::dri_image::createImageFromTexture.
1555 */
1556 static void
1557 dri2_create_image_khr_texture_error(int dri_error)
1558 {
1559 EGLint egl_error;
1560
1561 switch (dri_error) {
1562 case __DRI_IMAGE_ERROR_SUCCESS:
1563 return;
1564
1565 case __DRI_IMAGE_ERROR_BAD_ALLOC:
1566 egl_error = EGL_BAD_ALLOC;
1567 break;
1568
1569 case __DRI_IMAGE_ERROR_BAD_MATCH:
1570 egl_error = EGL_BAD_MATCH;
1571 break;
1572
1573 case __DRI_IMAGE_ERROR_BAD_PARAMETER:
1574 egl_error = EGL_BAD_PARAMETER;
1575 break;
1576
1577 case __DRI_IMAGE_ERROR_BAD_ACCESS:
1578 egl_error = EGL_BAD_ACCESS;
1579 break;
1580
1581 default:
1582 assert(0);
1583 egl_error = EGL_BAD_MATCH;
1584 break;
1585 }
1586
1587 _eglError(egl_error, "dri2_create_image_khr_texture");
1588 }
1589
1590 static _EGLImage *
1591 dri2_create_image_khr_texture(_EGLDisplay *disp, _EGLContext *ctx,
1592 EGLenum target,
1593 EGLClientBuffer buffer,
1594 const EGLint *attr_list)
1595 {
1596 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1597 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1598 struct dri2_egl_image *dri2_img;
1599 GLuint texture = (GLuint) (uintptr_t) buffer;
1600 _EGLImageAttribs attrs;
1601 GLuint depth;
1602 GLenum gl_target;
1603 unsigned error;
1604
1605 if (texture == 0) {
1606 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
1607 return EGL_NO_IMAGE_KHR;
1608 }
1609
1610 if (_eglParseImageAttribList(&attrs, disp, attr_list) != EGL_SUCCESS)
1611 return EGL_NO_IMAGE_KHR;
1612
1613 switch (target) {
1614 case EGL_GL_TEXTURE_2D_KHR:
1615 depth = 0;
1616 gl_target = GL_TEXTURE_2D;
1617 break;
1618 case EGL_GL_TEXTURE_3D_KHR:
1619 if (disp->Extensions.KHR_gl_texture_3D_image) {
1620 depth = attrs.GLTextureZOffset;
1621 gl_target = GL_TEXTURE_3D;
1622 break;
1623 }
1624 else {
1625 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
1626 return EGL_NO_IMAGE_KHR;
1627 }
1628 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
1629 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
1630 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
1631 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
1632 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
1633 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
1634 depth = target - EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR;
1635 gl_target = GL_TEXTURE_CUBE_MAP;
1636 break;
1637 default:
1638 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
1639 return EGL_NO_IMAGE_KHR;
1640 }
1641
1642 dri2_img = malloc(sizeof *dri2_img);
1643 if (!dri2_img) {
1644 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1645 return EGL_NO_IMAGE_KHR;
1646 }
1647
1648 if (!_eglInitImage(&dri2_img->base, disp)) {
1649 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1650 free(dri2_img);
1651 return EGL_NO_IMAGE_KHR;
1652 }
1653
1654 dri2_img->dri_image =
1655 dri2_dpy->image->createImageFromTexture(dri2_ctx->dri_context,
1656 gl_target,
1657 texture,
1658 depth,
1659 attrs.GLTextureLevel,
1660 &error,
1661 dri2_img);
1662 dri2_create_image_khr_texture_error(error);
1663
1664 if (!dri2_img->dri_image) {
1665 free(dri2_img);
1666 return EGL_NO_IMAGE_KHR;
1667 }
1668 return &dri2_img->base;
1669 }
1670
1671 static struct wl_buffer*
1672 dri2_create_wayland_buffer_from_image(_EGLDriver *drv, _EGLDisplay *dpy,
1673 _EGLImage *img)
1674 {
1675 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1676 return dri2_dpy->vtbl->create_wayland_buffer_from_image(drv, dpy, img);
1677 }
1678
1679 #ifdef HAVE_LIBDRM
1680 static _EGLImage *
1681 dri2_create_image_mesa_drm_buffer(_EGLDisplay *disp, _EGLContext *ctx,
1682 EGLClientBuffer buffer, const EGLint *attr_list)
1683 {
1684 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1685 EGLint format, name, pitch, err;
1686 _EGLImageAttribs attrs;
1687 __DRIimage *dri_image;
1688
1689 name = (EGLint) (uintptr_t) buffer;
1690
1691 err = _eglParseImageAttribList(&attrs, disp, attr_list);
1692 if (err != EGL_SUCCESS)
1693 return NULL;
1694
1695 if (attrs.Width <= 0 || attrs.Height <= 0 ||
1696 attrs.DRMBufferStrideMESA <= 0) {
1697 _eglError(EGL_BAD_PARAMETER,
1698 "bad width, height or stride");
1699 return NULL;
1700 }
1701
1702 switch (attrs.DRMBufferFormatMESA) {
1703 case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
1704 format = __DRI_IMAGE_FORMAT_ARGB8888;
1705 pitch = attrs.DRMBufferStrideMESA;
1706 break;
1707 default:
1708 _eglError(EGL_BAD_PARAMETER,
1709 "dri2_create_image_khr: unsupported pixmap depth");
1710 return NULL;
1711 }
1712
1713 dri_image =
1714 dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
1715 attrs.Width,
1716 attrs.Height,
1717 format,
1718 name,
1719 pitch,
1720 NULL);
1721
1722 return dri2_create_image_from_dri(disp, dri_image);
1723 }
1724
1725 static EGLBoolean
1726 dri2_check_dma_buf_attribs(const _EGLImageAttribs *attrs)
1727 {
1728 unsigned i;
1729
1730 /**
1731 * The spec says:
1732 *
1733 * "Required attributes and their values are as follows:
1734 *
1735 * * EGL_WIDTH & EGL_HEIGHT: The logical dimensions of the buffer in pixels
1736 *
1737 * * EGL_LINUX_DRM_FOURCC_EXT: The pixel format of the buffer, as specified
1738 * by drm_fourcc.h and used as the pixel_format parameter of the
1739 * drm_mode_fb_cmd2 ioctl."
1740 *
1741 * and
1742 *
1743 * "* If <target> is EGL_LINUX_DMA_BUF_EXT, and the list of attributes is
1744 * incomplete, EGL_BAD_PARAMETER is generated."
1745 */
1746 if (attrs->Width <= 0 || attrs->Height <= 0 ||
1747 !attrs->DMABufFourCC.IsPresent) {
1748 _eglError(EGL_BAD_PARAMETER, "attribute(s) missing");
1749 return EGL_FALSE;
1750 }
1751
1752 /**
1753 * Also:
1754 *
1755 * "If <target> is EGL_LINUX_DMA_BUF_EXT and one or more of the values
1756 * specified for a plane's pitch or offset isn't supported by EGL,
1757 * EGL_BAD_ACCESS is generated."
1758 */
1759 for (i = 0; i < ARRAY_SIZE(attrs->DMABufPlanePitches); ++i) {
1760 if (attrs->DMABufPlanePitches[i].IsPresent &&
1761 attrs->DMABufPlanePitches[i].Value <= 0) {
1762 _eglError(EGL_BAD_ACCESS, "invalid pitch");
1763 return EGL_FALSE;
1764 }
1765 }
1766
1767 return EGL_TRUE;
1768 }
1769
1770 /* Returns the total number of file descriptors. Zero indicates an error. */
1771 static unsigned
1772 dri2_check_dma_buf_format(const _EGLImageAttribs *attrs)
1773 {
1774 unsigned i, plane_n;
1775
1776 switch (attrs->DMABufFourCC.Value) {
1777 case DRM_FORMAT_R8:
1778 case DRM_FORMAT_RG88:
1779 case DRM_FORMAT_GR88:
1780 case DRM_FORMAT_RGB332:
1781 case DRM_FORMAT_BGR233:
1782 case DRM_FORMAT_XRGB4444:
1783 case DRM_FORMAT_XBGR4444:
1784 case DRM_FORMAT_RGBX4444:
1785 case DRM_FORMAT_BGRX4444:
1786 case DRM_FORMAT_ARGB4444:
1787 case DRM_FORMAT_ABGR4444:
1788 case DRM_FORMAT_RGBA4444:
1789 case DRM_FORMAT_BGRA4444:
1790 case DRM_FORMAT_XRGB1555:
1791 case DRM_FORMAT_XBGR1555:
1792 case DRM_FORMAT_RGBX5551:
1793 case DRM_FORMAT_BGRX5551:
1794 case DRM_FORMAT_ARGB1555:
1795 case DRM_FORMAT_ABGR1555:
1796 case DRM_FORMAT_RGBA5551:
1797 case DRM_FORMAT_BGRA5551:
1798 case DRM_FORMAT_RGB565:
1799 case DRM_FORMAT_BGR565:
1800 case DRM_FORMAT_RGB888:
1801 case DRM_FORMAT_BGR888:
1802 case DRM_FORMAT_XRGB8888:
1803 case DRM_FORMAT_XBGR8888:
1804 case DRM_FORMAT_RGBX8888:
1805 case DRM_FORMAT_BGRX8888:
1806 case DRM_FORMAT_ARGB8888:
1807 case DRM_FORMAT_ABGR8888:
1808 case DRM_FORMAT_RGBA8888:
1809 case DRM_FORMAT_BGRA8888:
1810 case DRM_FORMAT_XRGB2101010:
1811 case DRM_FORMAT_XBGR2101010:
1812 case DRM_FORMAT_RGBX1010102:
1813 case DRM_FORMAT_BGRX1010102:
1814 case DRM_FORMAT_ARGB2101010:
1815 case DRM_FORMAT_ABGR2101010:
1816 case DRM_FORMAT_RGBA1010102:
1817 case DRM_FORMAT_BGRA1010102:
1818 case DRM_FORMAT_YUYV:
1819 case DRM_FORMAT_YVYU:
1820 case DRM_FORMAT_UYVY:
1821 case DRM_FORMAT_VYUY:
1822 plane_n = 1;
1823 break;
1824 case DRM_FORMAT_NV12:
1825 case DRM_FORMAT_NV21:
1826 case DRM_FORMAT_NV16:
1827 case DRM_FORMAT_NV61:
1828 plane_n = 2;
1829 break;
1830 case DRM_FORMAT_YUV410:
1831 case DRM_FORMAT_YVU410:
1832 case DRM_FORMAT_YUV411:
1833 case DRM_FORMAT_YVU411:
1834 case DRM_FORMAT_YUV420:
1835 case DRM_FORMAT_YVU420:
1836 case DRM_FORMAT_YUV422:
1837 case DRM_FORMAT_YVU422:
1838 case DRM_FORMAT_YUV444:
1839 case DRM_FORMAT_YVU444:
1840 plane_n = 3;
1841 break;
1842 default:
1843 _eglError(EGL_BAD_ATTRIBUTE, "invalid format");
1844 return 0;
1845 }
1846
1847 /**
1848 * The spec says:
1849 *
1850 * "* If <target> is EGL_LINUX_DMA_BUF_EXT, and the list of attributes is
1851 * incomplete, EGL_BAD_PARAMETER is generated."
1852 */
1853 for (i = 0; i < plane_n; ++i) {
1854 if (!attrs->DMABufPlaneFds[i].IsPresent ||
1855 !attrs->DMABufPlaneOffsets[i].IsPresent ||
1856 !attrs->DMABufPlanePitches[i].IsPresent) {
1857 _eglError(EGL_BAD_PARAMETER, "plane attribute(s) missing");
1858 return 0;
1859 }
1860 }
1861
1862 /**
1863 * The spec also says:
1864 *
1865 * "If <target> is EGL_LINUX_DMA_BUF_EXT, and the EGL_LINUX_DRM_FOURCC_EXT
1866 * attribute indicates a single-plane format, EGL_BAD_ATTRIBUTE is
1867 * generated if any of the EGL_DMA_BUF_PLANE1_* or EGL_DMA_BUF_PLANE2_*
1868 * attributes are specified."
1869 */
1870 for (i = plane_n; i < 3; ++i) {
1871 if (attrs->DMABufPlaneFds[i].IsPresent ||
1872 attrs->DMABufPlaneOffsets[i].IsPresent ||
1873 attrs->DMABufPlanePitches[i].IsPresent) {
1874 _eglError(EGL_BAD_ATTRIBUTE, "too many plane attributes");
1875 return 0;
1876 }
1877 }
1878
1879 return plane_n;
1880 }
1881
1882 /**
1883 * The spec says:
1884 *
1885 * "If eglCreateImageKHR is successful for a EGL_LINUX_DMA_BUF_EXT target, the
1886 * EGL will take a reference to the dma_buf(s) which it will release at any
1887 * time while the EGLDisplay is initialized. It is the responsibility of the
1888 * application to close the dma_buf file descriptors."
1889 *
1890 * Therefore we must never close or otherwise modify the file descriptors.
1891 */
1892 static _EGLImage *
1893 dri2_create_image_dma_buf(_EGLDisplay *disp, _EGLContext *ctx,
1894 EGLClientBuffer buffer, const EGLint *attr_list)
1895 {
1896 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1897 _EGLImage *res;
1898 EGLint err;
1899 _EGLImageAttribs attrs;
1900 __DRIimage *dri_image;
1901 unsigned num_fds;
1902 unsigned i;
1903 int fds[3];
1904 int pitches[3];
1905 int offsets[3];
1906 unsigned error;
1907
1908 /**
1909 * The spec says:
1910 *
1911 * ""* If <target> is EGL_LINUX_DMA_BUF_EXT and <buffer> is not NULL, the
1912 * error EGL_BAD_PARAMETER is generated."
1913 */
1914 if (buffer != NULL) {
1915 _eglError(EGL_BAD_PARAMETER, "buffer not NULL");
1916 return NULL;
1917 }
1918
1919 err = _eglParseImageAttribList(&attrs, disp, attr_list);
1920 if (err != EGL_SUCCESS) {
1921 _eglError(err, "bad attribute");
1922 return NULL;
1923 }
1924
1925 if (!dri2_check_dma_buf_attribs(&attrs))
1926 return NULL;
1927
1928 num_fds = dri2_check_dma_buf_format(&attrs);
1929 if (!num_fds)
1930 return NULL;
1931
1932 for (i = 0; i < num_fds; ++i) {
1933 fds[i] = attrs.DMABufPlaneFds[i].Value;
1934 pitches[i] = attrs.DMABufPlanePitches[i].Value;
1935 offsets[i] = attrs.DMABufPlaneOffsets[i].Value;
1936 }
1937
1938 dri_image =
1939 dri2_dpy->image->createImageFromDmaBufs(dri2_dpy->dri_screen,
1940 attrs.Width, attrs.Height, attrs.DMABufFourCC.Value,
1941 fds, num_fds, pitches, offsets,
1942 attrs.DMABufYuvColorSpaceHint.Value,
1943 attrs.DMABufSampleRangeHint.Value,
1944 attrs.DMABufChromaHorizontalSiting.Value,
1945 attrs.DMABufChromaVerticalSiting.Value,
1946 &error,
1947 NULL);
1948 dri2_create_image_khr_texture_error(error);
1949
1950 if (!dri_image)
1951 return EGL_NO_IMAGE_KHR;
1952
1953 res = dri2_create_image_from_dri(disp, dri_image);
1954
1955 return res;
1956 }
1957 static _EGLImage *
1958 dri2_create_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp,
1959 const EGLint *attr_list)
1960 {
1961 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1962 struct dri2_egl_image *dri2_img;
1963 _EGLImageAttribs attrs;
1964 unsigned int dri_use, valid_mask;
1965 int format;
1966 EGLint err = EGL_SUCCESS;
1967
1968 (void) drv;
1969
1970 dri2_img = malloc(sizeof *dri2_img);
1971 if (!dri2_img) {
1972 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1973 return EGL_NO_IMAGE_KHR;
1974 }
1975
1976 if (!attr_list) {
1977 err = EGL_BAD_PARAMETER;
1978 goto cleanup_img;
1979 }
1980
1981 if (!_eglInitImage(&dri2_img->base, disp)) {
1982 err = EGL_BAD_PARAMETER;
1983 goto cleanup_img;
1984 }
1985
1986 err = _eglParseImageAttribList(&attrs, disp, attr_list);
1987 if (err != EGL_SUCCESS)
1988 goto cleanup_img;
1989
1990 if (attrs.Width <= 0 || attrs.Height <= 0) {
1991 _eglLog(_EGL_WARNING, "bad width or height (%dx%d)",
1992 attrs.Width, attrs.Height);
1993 goto cleanup_img;
1994 }
1995
1996 switch (attrs.DRMBufferFormatMESA) {
1997 case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
1998 format = __DRI_IMAGE_FORMAT_ARGB8888;
1999 break;
2000 default:
2001 _eglLog(_EGL_WARNING, "bad image format value 0x%04x",
2002 attrs.DRMBufferFormatMESA);
2003 goto cleanup_img;
2004 }
2005
2006 valid_mask =
2007 EGL_DRM_BUFFER_USE_SCANOUT_MESA |
2008 EGL_DRM_BUFFER_USE_SHARE_MESA |
2009 EGL_DRM_BUFFER_USE_CURSOR_MESA;
2010 if (attrs.DRMBufferUseMESA & ~valid_mask) {
2011 _eglLog(_EGL_WARNING, "bad image use bit 0x%04x",
2012 attrs.DRMBufferUseMESA & ~valid_mask);
2013 goto cleanup_img;
2014 }
2015
2016 dri_use = 0;
2017 if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SHARE_MESA)
2018 dri_use |= __DRI_IMAGE_USE_SHARE;
2019 if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SCANOUT_MESA)
2020 dri_use |= __DRI_IMAGE_USE_SCANOUT;
2021 if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_CURSOR_MESA)
2022 dri_use |= __DRI_IMAGE_USE_CURSOR;
2023
2024 dri2_img->dri_image =
2025 dri2_dpy->image->createImage(dri2_dpy->dri_screen,
2026 attrs.Width, attrs.Height,
2027 format, dri_use, dri2_img);
2028 if (dri2_img->dri_image == NULL) {
2029 err = EGL_BAD_ALLOC;
2030 goto cleanup_img;
2031 }
2032
2033 return &dri2_img->base;
2034
2035 cleanup_img:
2036 free(dri2_img);
2037 _eglError(err, "dri2_create_drm_image_mesa");
2038
2039 return EGL_NO_IMAGE_KHR;
2040 }
2041
2042 static EGLBoolean
2043 dri2_export_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
2044 EGLint *name, EGLint *handle, EGLint *stride)
2045 {
2046 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2047 struct dri2_egl_image *dri2_img = dri2_egl_image(img);
2048
2049 (void) drv;
2050
2051 if (name && !dri2_dpy->image->queryImage(dri2_img->dri_image,
2052 __DRI_IMAGE_ATTRIB_NAME, name)) {
2053 _eglError(EGL_BAD_ALLOC, "dri2_export_drm_image_mesa");
2054 return EGL_FALSE;
2055 }
2056
2057 if (handle)
2058 dri2_dpy->image->queryImage(dri2_img->dri_image,
2059 __DRI_IMAGE_ATTRIB_HANDLE, handle);
2060
2061 if (stride)
2062 dri2_dpy->image->queryImage(dri2_img->dri_image,
2063 __DRI_IMAGE_ATTRIB_STRIDE, stride);
2064
2065 return EGL_TRUE;
2066 }
2067
2068 static EGLBoolean
2069 dri2_export_dma_buf_image_query_mesa(_EGLDriver *drv, _EGLDisplay *disp,
2070 _EGLImage *img,
2071 EGLint *fourcc, EGLint *nplanes,
2072 EGLuint64KHR *modifiers)
2073 {
2074 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2075 struct dri2_egl_image *dri2_img = dri2_egl_image(img);
2076
2077 (void) drv;
2078
2079
2080 if (nplanes)
2081 dri2_dpy->image->queryImage(dri2_img->dri_image,
2082 __DRI_IMAGE_ATTRIB_NUM_PLANES, nplanes);
2083 if (fourcc)
2084 dri2_dpy->image->queryImage(dri2_img->dri_image,
2085 __DRI_IMAGE_ATTRIB_FOURCC, fourcc);
2086
2087 if (modifiers)
2088 *modifiers = 0;
2089
2090 return EGL_TRUE;
2091 }
2092
2093 static EGLBoolean
2094 dri2_export_dma_buf_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
2095 int *fds, EGLint *strides, EGLint *offsets)
2096 {
2097 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2098 struct dri2_egl_image *dri2_img = dri2_egl_image(img);
2099
2100 (void) drv;
2101
2102 /* rework later to provide multiple fds/strides/offsets */
2103 if (fds)
2104 dri2_dpy->image->queryImage(dri2_img->dri_image,
2105 __DRI_IMAGE_ATTRIB_FD, fds);
2106
2107 if (strides)
2108 dri2_dpy->image->queryImage(dri2_img->dri_image,
2109 __DRI_IMAGE_ATTRIB_STRIDE, strides);
2110
2111 if (offsets)
2112 offsets[0] = 0;
2113
2114 return EGL_TRUE;
2115 }
2116
2117 #endif
2118
2119 _EGLImage *
2120 dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
2121 _EGLContext *ctx, EGLenum target,
2122 EGLClientBuffer buffer, const EGLint *attr_list)
2123 {
2124 (void) drv;
2125
2126 switch (target) {
2127 case EGL_GL_TEXTURE_2D_KHR:
2128 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
2129 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
2130 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
2131 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
2132 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
2133 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
2134 return dri2_create_image_khr_texture(disp, ctx, target, buffer, attr_list);
2135 case EGL_GL_TEXTURE_3D_KHR:
2136 if (disp->Extensions.KHR_gl_texture_3D_image) {
2137 return dri2_create_image_khr_texture(disp, ctx, target, buffer, attr_list);
2138 }
2139 else {
2140 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2141 return EGL_NO_IMAGE_KHR;
2142 }
2143 case EGL_GL_RENDERBUFFER_KHR:
2144 return dri2_create_image_khr_renderbuffer(disp, ctx, buffer, attr_list);
2145 #ifdef HAVE_LIBDRM
2146 case EGL_DRM_BUFFER_MESA:
2147 return dri2_create_image_mesa_drm_buffer(disp, ctx, buffer, attr_list);
2148 case EGL_LINUX_DMA_BUF_EXT:
2149 return dri2_create_image_dma_buf(disp, ctx, buffer, attr_list);
2150 #endif
2151 #ifdef HAVE_WAYLAND_PLATFORM
2152 case EGL_WAYLAND_BUFFER_WL:
2153 return dri2_create_image_wayland_wl_buffer(disp, ctx, buffer, attr_list);
2154 #endif
2155 default:
2156 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2157 return EGL_NO_IMAGE_KHR;
2158 }
2159 }
2160
2161 static EGLBoolean
2162 dri2_destroy_image_khr(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image)
2163 {
2164 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2165 struct dri2_egl_image *dri2_img = dri2_egl_image(image);
2166
2167 (void) drv;
2168
2169 dri2_dpy->image->destroyImage(dri2_img->dri_image);
2170 free(dri2_img);
2171
2172 return EGL_TRUE;
2173 }
2174
2175 #ifdef HAVE_WAYLAND_PLATFORM
2176
2177 static void
2178 dri2_wl_reference_buffer(void *user_data, uint32_t name, int fd,
2179 struct wl_drm_buffer *buffer)
2180 {
2181 _EGLDisplay *disp = user_data;
2182 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2183 __DRIimage *img;
2184 int i, dri_components = 0;
2185
2186 if (fd == -1)
2187 img = dri2_dpy->image->createImageFromNames(dri2_dpy->dri_screen,
2188 buffer->width,
2189 buffer->height,
2190 buffer->format,
2191 (int*)&name, 1,
2192 buffer->stride,
2193 buffer->offset,
2194 NULL);
2195 else
2196 img = dri2_dpy->image->createImageFromFds(dri2_dpy->dri_screen,
2197 buffer->width,
2198 buffer->height,
2199 buffer->format,
2200 &fd, 1,
2201 buffer->stride,
2202 buffer->offset,
2203 NULL);
2204
2205 if (img == NULL)
2206 return;
2207
2208 dri2_dpy->image->queryImage(img, __DRI_IMAGE_ATTRIB_COMPONENTS, &dri_components);
2209
2210 buffer->driver_format = NULL;
2211 for (i = 0; i < ARRAY_SIZE(wl_drm_components); i++)
2212 if (wl_drm_components[i].dri_components == dri_components)
2213 buffer->driver_format = &wl_drm_components[i];
2214
2215 if (buffer->driver_format == NULL)
2216 dri2_dpy->image->destroyImage(img);
2217 else
2218 buffer->driver_buffer = img;
2219 }
2220
2221 static void
2222 dri2_wl_release_buffer(void *user_data, struct wl_drm_buffer *buffer)
2223 {
2224 _EGLDisplay *disp = user_data;
2225 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2226
2227 dri2_dpy->image->destroyImage(buffer->driver_buffer);
2228 }
2229
2230 static struct wayland_drm_callbacks wl_drm_callbacks = {
2231 .authenticate = NULL,
2232 .reference_buffer = dri2_wl_reference_buffer,
2233 .release_buffer = dri2_wl_release_buffer
2234 };
2235
2236 static EGLBoolean
2237 dri2_bind_wayland_display_wl(_EGLDriver *drv, _EGLDisplay *disp,
2238 struct wl_display *wl_dpy)
2239 {
2240 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2241 int flags = 0;
2242 uint64_t cap;
2243
2244 (void) drv;
2245
2246 if (dri2_dpy->wl_server_drm)
2247 return EGL_FALSE;
2248
2249 wl_drm_callbacks.authenticate =
2250 (int(*)(void *, uint32_t)) dri2_dpy->vtbl->authenticate;
2251
2252 if (drmGetCap(dri2_dpy->fd, DRM_CAP_PRIME, &cap) == 0 &&
2253 cap == (DRM_PRIME_CAP_IMPORT | DRM_PRIME_CAP_EXPORT) &&
2254 dri2_dpy->image->base.version >= 7 &&
2255 dri2_dpy->image->createImageFromFds != NULL)
2256 flags |= WAYLAND_DRM_PRIME;
2257
2258 dri2_dpy->wl_server_drm =
2259 wayland_drm_init(wl_dpy, dri2_dpy->device_name,
2260 &wl_drm_callbacks, disp, flags);
2261
2262 if (!dri2_dpy->wl_server_drm)
2263 return EGL_FALSE;
2264
2265 #ifdef HAVE_DRM_PLATFORM
2266 /* We have to share the wl_drm instance with gbm, so gbm can convert
2267 * wl_buffers to gbm bos. */
2268 if (dri2_dpy->gbm_dri)
2269 dri2_dpy->gbm_dri->wl_drm = dri2_dpy->wl_server_drm;
2270 #endif
2271
2272 return EGL_TRUE;
2273 }
2274
2275 static EGLBoolean
2276 dri2_unbind_wayland_display_wl(_EGLDriver *drv, _EGLDisplay *disp,
2277 struct wl_display *wl_dpy)
2278 {
2279 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2280
2281 (void) drv;
2282
2283 if (!dri2_dpy->wl_server_drm)
2284 return EGL_FALSE;
2285
2286 wayland_drm_uninit(dri2_dpy->wl_server_drm);
2287 dri2_dpy->wl_server_drm = NULL;
2288
2289 return EGL_TRUE;
2290 }
2291
2292 static EGLBoolean
2293 dri2_query_wayland_buffer_wl(_EGLDriver *drv, _EGLDisplay *disp,
2294 struct wl_resource *buffer_resource,
2295 EGLint attribute, EGLint *value)
2296 {
2297 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2298 struct wl_drm_buffer *buffer;
2299 const struct wl_drm_components_descriptor *format;
2300
2301 buffer = wayland_drm_buffer_get(dri2_dpy->wl_server_drm, buffer_resource);
2302 if (!buffer)
2303 return EGL_FALSE;
2304
2305 format = buffer->driver_format;
2306 switch (attribute) {
2307 case EGL_TEXTURE_FORMAT:
2308 *value = format->components;
2309 return EGL_TRUE;
2310 case EGL_WIDTH:
2311 *value = buffer->width;
2312 return EGL_TRUE;
2313 case EGL_HEIGHT:
2314 *value = buffer->height;
2315 return EGL_TRUE;
2316 }
2317
2318 return EGL_FALSE;
2319 }
2320 #endif
2321
2322 static void
2323 dri2_egl_ref_sync(struct dri2_egl_sync *sync)
2324 {
2325 p_atomic_inc(&sync->refcount);
2326 }
2327
2328 static void
2329 dri2_egl_unref_sync(struct dri2_egl_display *dri2_dpy,
2330 struct dri2_egl_sync *dri2_sync)
2331 {
2332 if (p_atomic_dec_zero(&dri2_sync->refcount)) {
2333 dri2_dpy->fence->destroy_fence(dri2_dpy->dri_screen, dri2_sync->fence);
2334 free(dri2_sync);
2335 }
2336 }
2337
2338 static _EGLSync *
2339 dri2_create_sync(_EGLDriver *drv, _EGLDisplay *dpy,
2340 EGLenum type, const EGLint *attrib_list,
2341 const EGLAttrib *attrib_list64)
2342 {
2343 _EGLContext *ctx = _eglGetCurrentContext();
2344 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
2345 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
2346 struct dri2_egl_sync *dri2_sync;
2347
2348 dri2_sync = calloc(1, sizeof(struct dri2_egl_sync));
2349 if (!dri2_sync) {
2350 _eglError(EGL_BAD_ALLOC, "eglCreateSyncKHR");
2351 return NULL;
2352 }
2353
2354 if (!_eglInitSync(&dri2_sync->base, dpy, type, attrib_list,
2355 attrib_list64)) {
2356 free(dri2_sync);
2357 return NULL;
2358 }
2359
2360 switch (type) {
2361 case EGL_SYNC_FENCE_KHR:
2362 dri2_sync->fence = dri2_dpy->fence->create_fence(dri2_ctx->dri_context);
2363 if (!dri2_sync->fence) {
2364 /* Why did it fail? DRI doesn't return an error code, so we emit
2365 * a generic EGL error that doesn't communicate user error.
2366 */
2367 _eglError(EGL_BAD_ALLOC, "eglCreateSyncKHR");
2368 free(dri2_sync);
2369 return NULL;
2370 }
2371 break;
2372
2373 case EGL_SYNC_CL_EVENT_KHR:
2374 dri2_sync->fence = dri2_dpy->fence->get_fence_from_cl_event(
2375 dri2_dpy->dri_screen,
2376 dri2_sync->base.CLEvent);
2377 /* this can only happen if the cl_event passed in is invalid. */
2378 if (!dri2_sync->fence) {
2379 _eglError(EGL_BAD_ATTRIBUTE, "eglCreateSyncKHR");
2380 free(dri2_sync);
2381 return NULL;
2382 }
2383
2384 /* the initial status must be "signaled" if the cl_event is signaled */
2385 if (dri2_dpy->fence->client_wait_sync(dri2_ctx->dri_context,
2386 dri2_sync->fence, 0, 0))
2387 dri2_sync->base.SyncStatus = EGL_SIGNALED_KHR;
2388 break;
2389 }
2390
2391 p_atomic_set(&dri2_sync->refcount, 1);
2392 return &dri2_sync->base;
2393 }
2394
2395 static EGLBoolean
2396 dri2_destroy_sync(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSync *sync)
2397 {
2398 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
2399 struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
2400
2401 dri2_egl_unref_sync(dri2_dpy, dri2_sync);
2402 return EGL_TRUE;
2403 }
2404
2405 static EGLint
2406 dri2_client_wait_sync(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSync *sync,
2407 EGLint flags, EGLTime timeout)
2408 {
2409 _EGLContext *ctx = _eglGetCurrentContext();
2410 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
2411 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
2412 struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
2413 unsigned wait_flags = 0;
2414 EGLint ret = EGL_CONDITION_SATISFIED_KHR;
2415
2416 /* The EGL_KHR_fence_sync spec states:
2417 *
2418 * "If no context is current for the bound API,
2419 * the EGL_SYNC_FLUSH_COMMANDS_BIT_KHR bit is ignored.
2420 */
2421 if (dri2_ctx && flags & EGL_SYNC_FLUSH_COMMANDS_BIT_KHR)
2422 wait_flags |= __DRI2_FENCE_FLAG_FLUSH_COMMANDS;
2423
2424 /* the sync object should take a reference while waiting */
2425 dri2_egl_ref_sync(dri2_sync);
2426
2427 if (dri2_dpy->fence->client_wait_sync(dri2_ctx ? dri2_ctx->dri_context : NULL,
2428 dri2_sync->fence, wait_flags,
2429 timeout))
2430 dri2_sync->base.SyncStatus = EGL_SIGNALED_KHR;
2431 else
2432 ret = EGL_TIMEOUT_EXPIRED_KHR;
2433
2434 dri2_egl_unref_sync(dri2_dpy, dri2_sync);
2435 return ret;
2436 }
2437
2438 static EGLint
2439 dri2_server_wait_sync(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSync *sync)
2440 {
2441 _EGLContext *ctx = _eglGetCurrentContext();
2442 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
2443 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
2444 struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
2445
2446 dri2_dpy->fence->server_wait_sync(dri2_ctx->dri_context,
2447 dri2_sync->fence, 0);
2448 return EGL_TRUE;
2449 }
2450
2451 static void
2452 dri2_unload(_EGLDriver *drv)
2453 {
2454 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
2455
2456 if (dri2_drv->handle)
2457 dlclose(dri2_drv->handle);
2458 free(dri2_drv);
2459 }
2460
2461 static EGLBoolean
2462 dri2_load(_EGLDriver *drv)
2463 {
2464 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
2465 #ifdef HAVE_ANDROID_PLATFORM
2466 const char *libname = "libglapi.so";
2467 #elif defined(__APPLE__)
2468 const char *libname = "libglapi.0.dylib";
2469 #else
2470 const char *libname = "libglapi.so.0";
2471 #endif
2472 void *handle;
2473
2474 /* RTLD_GLOBAL to make sure glapi symbols are visible to DRI drivers */
2475 handle = dlopen(libname, RTLD_LAZY | RTLD_GLOBAL);
2476 if (handle) {
2477 dri2_drv->get_proc_address = (_EGLProc (*)(const char *))
2478 dlsym(handle, "_glapi_get_proc_address");
2479 if (!dri2_drv->get_proc_address || !libname) {
2480 /* no need to keep a reference */
2481 dlclose(handle);
2482 handle = NULL;
2483 }
2484 }
2485
2486 /* if glapi is not available, loading DRI drivers will fail */
2487 if (!dri2_drv->get_proc_address) {
2488 _eglLog(_EGL_WARNING, "DRI2: failed to find _glapi_get_proc_address");
2489 return EGL_FALSE;
2490 }
2491
2492 dri2_drv->glFlush = (void (*)(void))
2493 dri2_drv->get_proc_address("glFlush");
2494
2495 dri2_drv->handle = handle;
2496
2497 return EGL_TRUE;
2498 }
2499
2500 /**
2501 * This is the main entrypoint into the driver, called by libEGL.
2502 * Create a new _EGLDriver object and init its dispatch table.
2503 */
2504 _EGLDriver *
2505 _eglBuiltInDriverDRI2(const char *args)
2506 {
2507 struct dri2_egl_driver *dri2_drv;
2508
2509 (void) args;
2510
2511 dri2_drv = calloc(1, sizeof *dri2_drv);
2512 if (!dri2_drv)
2513 return NULL;
2514
2515 if (!dri2_load(&dri2_drv->base)) {
2516 free(dri2_drv);
2517 return NULL;
2518 }
2519
2520 _eglInitDriverFallbacks(&dri2_drv->base);
2521 dri2_drv->base.API.Initialize = dri2_initialize;
2522 dri2_drv->base.API.Terminate = dri2_terminate;
2523 dri2_drv->base.API.CreateContext = dri2_create_context;
2524 dri2_drv->base.API.DestroyContext = dri2_destroy_context;
2525 dri2_drv->base.API.MakeCurrent = dri2_make_current;
2526 dri2_drv->base.API.CreateWindowSurface = dri2_create_window_surface;
2527 dri2_drv->base.API.CreatePixmapSurface = dri2_create_pixmap_surface;
2528 dri2_drv->base.API.CreatePbufferSurface = dri2_create_pbuffer_surface;
2529 dri2_drv->base.API.DestroySurface = dri2_destroy_surface;
2530 dri2_drv->base.API.GetProcAddress = dri2_get_proc_address;
2531 dri2_drv->base.API.WaitClient = dri2_wait_client;
2532 dri2_drv->base.API.WaitNative = dri2_wait_native;
2533 dri2_drv->base.API.BindTexImage = dri2_bind_tex_image;
2534 dri2_drv->base.API.ReleaseTexImage = dri2_release_tex_image;
2535 dri2_drv->base.API.SwapInterval = dri2_swap_interval;
2536 dri2_drv->base.API.SwapBuffers = dri2_swap_buffers;
2537 dri2_drv->base.API.SwapBuffersWithDamageEXT = dri2_swap_buffers_with_damage;
2538 dri2_drv->base.API.SwapBuffersRegionNOK = dri2_swap_buffers_region;
2539 dri2_drv->base.API.PostSubBufferNV = dri2_post_sub_buffer;
2540 dri2_drv->base.API.CopyBuffers = dri2_copy_buffers,
2541 dri2_drv->base.API.QueryBufferAge = dri2_query_buffer_age;
2542 dri2_drv->base.API.CreateImageKHR = dri2_create_image;
2543 dri2_drv->base.API.DestroyImageKHR = dri2_destroy_image_khr;
2544 dri2_drv->base.API.CreateWaylandBufferFromImageWL = dri2_create_wayland_buffer_from_image;
2545 #ifdef HAVE_LIBDRM
2546 dri2_drv->base.API.CreateDRMImageMESA = dri2_create_drm_image_mesa;
2547 dri2_drv->base.API.ExportDRMImageMESA = dri2_export_drm_image_mesa;
2548 dri2_drv->base.API.ExportDMABUFImageQueryMESA = dri2_export_dma_buf_image_query_mesa;
2549 dri2_drv->base.API.ExportDMABUFImageMESA = dri2_export_dma_buf_image_mesa;
2550 #endif
2551 #ifdef HAVE_WAYLAND_PLATFORM
2552 dri2_drv->base.API.BindWaylandDisplayWL = dri2_bind_wayland_display_wl;
2553 dri2_drv->base.API.UnbindWaylandDisplayWL = dri2_unbind_wayland_display_wl;
2554 dri2_drv->base.API.QueryWaylandBufferWL = dri2_query_wayland_buffer_wl;
2555 #endif
2556 dri2_drv->base.API.GetSyncValuesCHROMIUM = dri2_get_sync_values_chromium;
2557 dri2_drv->base.API.CreateSyncKHR = dri2_create_sync;
2558 dri2_drv->base.API.ClientWaitSyncKHR = dri2_client_wait_sync;
2559 dri2_drv->base.API.WaitSyncKHR = dri2_server_wait_sync;
2560 dri2_drv->base.API.DestroySyncKHR = dri2_destroy_sync;
2561
2562 dri2_drv->base.Name = "DRI2";
2563 dri2_drv->base.Unload = dri2_unload;
2564
2565 return &dri2_drv->base;
2566 }