]>
Commit | Line | Data |
---|---|---|
6250dff3 FZ |
1 | /* |
2 | * Copyright (C) 2015-2016 Gerd Hoffmann <kraxel@redhat.com> | |
3 | * | |
4 | * This library is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU Lesser General Public | |
6 | * License as published by the Free Software Foundation; either | |
7 | * version 2.1 of the License, or (at your option) any later version. | |
8 | * | |
9 | * This library is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
12 | * Lesser General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU Lesser General Public | |
15 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. | |
16 | */ | |
e16f4c87 | 17 | #include "qemu/osdep.h" |
b1d38037 | 18 | #include "qemu/drm.h" |
38a55bdd | 19 | #include "qemu/error-report.h" |
86c0522c | 20 | #include "ui/console.h" |
7ced9e9f GH |
21 | #include "ui/egl-helpers.h" |
22 | ||
23 | EGLDisplay *qemu_egl_display; | |
24 | EGLConfig qemu_egl_config; | |
54d208ff | 25 | DisplayGLMode qemu_egl_mode; |
7ced9e9f | 26 | |
6fafc260 GH |
27 | /* ------------------------------------------------------------------ */ |
28 | ||
74083f9c GH |
29 | static void egl_fb_delete_texture(egl_fb *fb) |
30 | { | |
31 | if (!fb->delete_texture) { | |
32 | return; | |
33 | } | |
34 | ||
35 | glDeleteTextures(1, &fb->texture); | |
36 | fb->delete_texture = false; | |
37 | } | |
38 | ||
6fafc260 GH |
39 | void egl_fb_destroy(egl_fb *fb) |
40 | { | |
41 | if (!fb->framebuffer) { | |
42 | return; | |
43 | } | |
44 | ||
74083f9c | 45 | egl_fb_delete_texture(fb); |
6fafc260 GH |
46 | glDeleteFramebuffers(1, &fb->framebuffer); |
47 | ||
48 | fb->width = 0; | |
49 | fb->height = 0; | |
50 | fb->texture = 0; | |
51 | fb->framebuffer = 0; | |
52 | } | |
53 | ||
54 | void egl_fb_setup_default(egl_fb *fb, int width, int height) | |
55 | { | |
56 | fb->width = width; | |
57 | fb->height = height; | |
58 | fb->framebuffer = 0; /* default framebuffer */ | |
59 | } | |
60 | ||
74083f9c GH |
61 | void egl_fb_setup_for_tex(egl_fb *fb, int width, int height, |
62 | GLuint texture, bool delete) | |
6fafc260 | 63 | { |
74083f9c GH |
64 | egl_fb_delete_texture(fb); |
65 | ||
6fafc260 GH |
66 | fb->width = width; |
67 | fb->height = height; | |
68 | fb->texture = texture; | |
74083f9c | 69 | fb->delete_texture = delete; |
6fafc260 GH |
70 | if (!fb->framebuffer) { |
71 | glGenFramebuffers(1, &fb->framebuffer); | |
72 | } | |
73 | ||
74 | glBindFramebuffer(GL_FRAMEBUFFER_EXT, fb->framebuffer); | |
75 | glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, | |
76 | GL_TEXTURE_2D, fb->texture, 0); | |
77 | } | |
78 | ||
74083f9c | 79 | void egl_fb_setup_new_tex(egl_fb *fb, int width, int height) |
6fafc260 GH |
80 | { |
81 | GLuint texture; | |
82 | ||
83 | glGenTextures(1, &texture); | |
84 | glBindTexture(GL_TEXTURE_2D, texture); | |
41126214 | 85 | glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, |
6fafc260 GH |
86 | 0, GL_BGRA, GL_UNSIGNED_BYTE, 0); |
87 | ||
74083f9c | 88 | egl_fb_setup_for_tex(fb, width, height, texture, true); |
6fafc260 GH |
89 | } |
90 | ||
91 | void egl_fb_blit(egl_fb *dst, egl_fb *src, bool flip) | |
92 | { | |
1350ff15 DK |
93 | GLuint x1 = 0; |
94 | GLuint y1 = 0; | |
95 | GLuint x2, y2; | |
96 | GLuint w = src->width; | |
97 | GLuint h = src->height; | |
6fafc260 GH |
98 | |
99 | glBindFramebuffer(GL_READ_FRAMEBUFFER, src->framebuffer); | |
100 | glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dst->framebuffer); | |
101 | glViewport(0, 0, dst->width, dst->height); | |
1350ff15 DK |
102 | |
103 | if (src->dmabuf) { | |
104 | x1 = src->dmabuf->x; | |
105 | y1 = src->dmabuf->y; | |
106 | w = src->dmabuf->scanout_width; | |
107 | h = src->dmabuf->scanout_height; | |
108 | } | |
109 | ||
110 | w = (x1 + w) > src->width ? src->width - x1 : w; | |
111 | h = (y1 + h) > src->height ? src->height - y1 : h; | |
112 | ||
113 | y2 = flip ? y1 : h + y1; | |
114 | y1 = flip ? h + y1 : y1; | |
115 | x2 = x1 + w; | |
116 | ||
117 | glBlitFramebuffer(x1, y1, x2, y2, | |
6fafc260 GH |
118 | 0, 0, dst->width, dst->height, |
119 | GL_COLOR_BUFFER_BIT, GL_LINEAR); | |
120 | } | |
121 | ||
d2329237 | 122 | void egl_fb_read(DisplaySurface *dst, egl_fb *src) |
6fafc260 GH |
123 | { |
124 | glBindFramebuffer(GL_READ_FRAMEBUFFER, src->framebuffer); | |
125 | glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); | |
d2329237 GH |
126 | glReadPixels(0, 0, surface_width(dst), surface_height(dst), |
127 | GL_BGRA, GL_UNSIGNED_BYTE, surface_data(dst)); | |
6fafc260 GH |
128 | } |
129 | ||
0eb50c27 GH |
130 | void egl_texture_blit(QemuGLShader *gls, egl_fb *dst, egl_fb *src, bool flip) |
131 | { | |
132 | glBindFramebuffer(GL_FRAMEBUFFER_EXT, dst->framebuffer); | |
133 | glViewport(0, 0, dst->width, dst->height); | |
134 | glEnable(GL_TEXTURE_2D); | |
135 | glBindTexture(GL_TEXTURE_2D, src->texture); | |
136 | qemu_gl_run_texture_blit(gls, flip); | |
137 | } | |
138 | ||
139 | void egl_texture_blend(QemuGLShader *gls, egl_fb *dst, egl_fb *src, bool flip, | |
051a0cde | 140 | int x, int y, double scale_x, double scale_y) |
0eb50c27 GH |
141 | { |
142 | glBindFramebuffer(GL_FRAMEBUFFER_EXT, dst->framebuffer); | |
051a0cde CZ |
143 | int w = scale_x * src->width; |
144 | int h = scale_y * src->height; | |
0eb50c27 | 145 | if (flip) { |
051a0cde | 146 | glViewport(x, y, w, h); |
0eb50c27 | 147 | } else { |
051a0cde | 148 | glViewport(x, dst->height - h - y, w, h); |
0eb50c27 GH |
149 | } |
150 | glEnable(GL_TEXTURE_2D); | |
151 | glBindTexture(GL_TEXTURE_2D, src->texture); | |
152 | glEnable(GL_BLEND); | |
153 | glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); | |
154 | qemu_gl_run_texture_blit(gls, flip); | |
155 | glDisable(GL_BLEND); | |
156 | } | |
157 | ||
7ced9e9f GH |
158 | /* ---------------------------------------------------------------------- */ |
159 | ||
bc6a3565 | 160 | #ifdef CONFIG_GBM |
1e316598 GH |
161 | |
162 | int qemu_egl_rn_fd; | |
163 | struct gbm_device *qemu_egl_rn_gbm_dev; | |
164 | EGLContext qemu_egl_rn_ctx; | |
165 | ||
54d208ff | 166 | int egl_rendernode_init(const char *rendernode, DisplayGLMode mode) |
1e316598 GH |
167 | { |
168 | qemu_egl_rn_fd = -1; | |
151c8e60 | 169 | int rc; |
1e316598 | 170 | |
b1d38037 | 171 | qemu_egl_rn_fd = qemu_drm_rendernode_open(rendernode); |
1e316598 | 172 | if (qemu_egl_rn_fd == -1) { |
38a55bdd | 173 | error_report("egl: no drm render node available"); |
1e316598 GH |
174 | goto err; |
175 | } | |
176 | ||
177 | qemu_egl_rn_gbm_dev = gbm_create_device(qemu_egl_rn_fd); | |
178 | if (!qemu_egl_rn_gbm_dev) { | |
38a55bdd | 179 | error_report("egl: gbm_create_device failed"); |
1e316598 GH |
180 | goto err; |
181 | } | |
182 | ||
54d208ff GH |
183 | rc = qemu_egl_init_dpy_mesa((EGLNativeDisplayType)qemu_egl_rn_gbm_dev, |
184 | mode); | |
151c8e60 GH |
185 | if (rc != 0) { |
186 | /* qemu_egl_init_dpy_mesa reports error */ | |
187 | goto err; | |
188 | } | |
1e316598 GH |
189 | |
190 | if (!epoxy_has_egl_extension(qemu_egl_display, | |
191 | "EGL_KHR_surfaceless_context")) { | |
38a55bdd | 192 | error_report("egl: EGL_KHR_surfaceless_context not supported"); |
1e316598 GH |
193 | goto err; |
194 | } | |
195 | if (!epoxy_has_egl_extension(qemu_egl_display, | |
196 | "EGL_MESA_image_dma_buf_export")) { | |
38a55bdd | 197 | error_report("egl: EGL_MESA_image_dma_buf_export not supported"); |
1e316598 GH |
198 | goto err; |
199 | } | |
200 | ||
201 | qemu_egl_rn_ctx = qemu_egl_init_ctx(); | |
202 | if (!qemu_egl_rn_ctx) { | |
38a55bdd | 203 | error_report("egl: egl_init_ctx failed"); |
1e316598 GH |
204 | goto err; |
205 | } | |
206 | ||
207 | return 0; | |
208 | ||
209 | err: | |
210 | if (qemu_egl_rn_gbm_dev) { | |
211 | gbm_device_destroy(qemu_egl_rn_gbm_dev); | |
212 | } | |
213 | if (qemu_egl_rn_fd != -1) { | |
214 | close(qemu_egl_rn_fd); | |
215 | } | |
216 | ||
217 | return -1; | |
218 | } | |
219 | ||
5fc1fb62 GH |
220 | int egl_get_fd_for_texture(uint32_t tex_id, EGLint *stride, EGLint *fourcc, |
221 | EGLuint64KHR *modifier) | |
1e316598 GH |
222 | { |
223 | EGLImageKHR image; | |
224 | EGLint num_planes, fd; | |
225 | ||
226 | image = eglCreateImageKHR(qemu_egl_display, eglGetCurrentContext(), | |
227 | EGL_GL_TEXTURE_2D_KHR, | |
228 | (EGLClientBuffer)(unsigned long)tex_id, | |
229 | NULL); | |
230 | if (!image) { | |
231 | return -1; | |
232 | } | |
233 | ||
234 | eglExportDMABUFImageQueryMESA(qemu_egl_display, image, fourcc, | |
5fc1fb62 | 235 | &num_planes, modifier); |
1e316598 GH |
236 | if (num_planes != 1) { |
237 | eglDestroyImageKHR(qemu_egl_display, image); | |
238 | return -1; | |
239 | } | |
240 | eglExportDMABUFImageMESA(qemu_egl_display, image, &fd, stride, NULL); | |
241 | eglDestroyImageKHR(qemu_egl_display, image); | |
242 | ||
243 | return fd; | |
244 | } | |
245 | ||
86c0522c GH |
246 | void egl_dmabuf_import_texture(QemuDmaBuf *dmabuf) |
247 | { | |
248 | EGLImageKHR image = EGL_NO_IMAGE_KHR; | |
15ee0d9b GH |
249 | EGLint attrs[64]; |
250 | int i = 0; | |
86c0522c GH |
251 | |
252 | if (dmabuf->texture != 0) { | |
253 | return; | |
254 | } | |
255 | ||
15ee0d9b GH |
256 | attrs[i++] = EGL_WIDTH; |
257 | attrs[i++] = dmabuf->width; | |
258 | attrs[i++] = EGL_HEIGHT; | |
259 | attrs[i++] = dmabuf->height; | |
260 | attrs[i++] = EGL_LINUX_DRM_FOURCC_EXT; | |
261 | attrs[i++] = dmabuf->fourcc; | |
262 | ||
263 | attrs[i++] = EGL_DMA_BUF_PLANE0_FD_EXT; | |
264 | attrs[i++] = dmabuf->fd; | |
265 | attrs[i++] = EGL_DMA_BUF_PLANE0_PITCH_EXT; | |
266 | attrs[i++] = dmabuf->stride; | |
267 | attrs[i++] = EGL_DMA_BUF_PLANE0_OFFSET_EXT; | |
268 | attrs[i++] = 0; | |
269 | #ifdef EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT | |
270 | if (dmabuf->modifier) { | |
271 | attrs[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT; | |
272 | attrs[i++] = (dmabuf->modifier >> 0) & 0xffffffff; | |
273 | attrs[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT; | |
274 | attrs[i++] = (dmabuf->modifier >> 32) & 0xffffffff; | |
275 | } | |
276 | #endif | |
277 | attrs[i++] = EGL_NONE; | |
278 | ||
86c0522c GH |
279 | image = eglCreateImageKHR(qemu_egl_display, |
280 | EGL_NO_CONTEXT, | |
281 | EGL_LINUX_DMA_BUF_EXT, | |
282 | NULL, attrs); | |
283 | if (image == EGL_NO_IMAGE_KHR) { | |
284 | error_report("eglCreateImageKHR failed"); | |
285 | return; | |
286 | } | |
287 | ||
288 | glGenTextures(1, &dmabuf->texture); | |
289 | glBindTexture(GL_TEXTURE_2D, dmabuf->texture); | |
290 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); | |
291 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); | |
292 | ||
293 | glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image); | |
294 | eglDestroyImageKHR(qemu_egl_display, image); | |
295 | } | |
296 | ||
297 | void egl_dmabuf_release_texture(QemuDmaBuf *dmabuf) | |
298 | { | |
299 | if (dmabuf->texture == 0) { | |
300 | return; | |
301 | } | |
302 | ||
303 | glDeleteTextures(1, &dmabuf->texture); | |
304 | dmabuf->texture = 0; | |
305 | } | |
306 | ||
121abaf3 VK |
307 | void egl_dmabuf_create_sync(QemuDmaBuf *dmabuf) |
308 | { | |
309 | EGLSyncKHR sync; | |
310 | ||
311 | if (epoxy_has_egl_extension(qemu_egl_display, | |
312 | "EGL_KHR_fence_sync") && | |
313 | epoxy_has_egl_extension(qemu_egl_display, | |
314 | "EGL_ANDROID_native_fence_sync")) { | |
315 | sync = eglCreateSyncKHR(qemu_egl_display, | |
316 | EGL_SYNC_NATIVE_FENCE_ANDROID, NULL); | |
317 | if (sync != EGL_NO_SYNC_KHR) { | |
318 | dmabuf->sync = sync; | |
319 | } | |
320 | } | |
321 | } | |
322 | ||
323 | void egl_dmabuf_create_fence(QemuDmaBuf *dmabuf) | |
324 | { | |
325 | if (dmabuf->sync) { | |
326 | dmabuf->fence_fd = eglDupNativeFenceFDANDROID(qemu_egl_display, | |
327 | dmabuf->sync); | |
328 | eglDestroySyncKHR(qemu_egl_display, dmabuf->sync); | |
329 | dmabuf->sync = NULL; | |
330 | } | |
331 | } | |
332 | ||
bc6a3565 | 333 | #endif /* CONFIG_GBM */ |
1e316598 GH |
334 | |
335 | /* ---------------------------------------------------------------------- */ | |
336 | ||
fbd57c75 | 337 | EGLSurface qemu_egl_init_surface_x11(EGLContext ectx, EGLNativeWindowType win) |
7ced9e9f GH |
338 | { |
339 | EGLSurface esurface; | |
340 | EGLBoolean b; | |
341 | ||
7ced9e9f GH |
342 | esurface = eglCreateWindowSurface(qemu_egl_display, |
343 | qemu_egl_config, | |
fbd57c75 | 344 | win, NULL); |
7ced9e9f | 345 | if (esurface == EGL_NO_SURFACE) { |
38a55bdd | 346 | error_report("egl: eglCreateWindowSurface failed"); |
7ced9e9f GH |
347 | return NULL; |
348 | } | |
349 | ||
350 | b = eglMakeCurrent(qemu_egl_display, esurface, esurface, ectx); | |
351 | if (b == EGL_FALSE) { | |
38a55bdd | 352 | error_report("egl: eglMakeCurrent failed"); |
7ced9e9f GH |
353 | return NULL; |
354 | } | |
355 | ||
356 | return esurface; | |
357 | } | |
358 | ||
359 | /* ---------------------------------------------------------------------- */ | |
360 | ||
bc6a3565 AO |
361 | #if defined(CONFIG_X11) || defined(CONFIG_GBM) |
362 | ||
8bce03e3 GH |
363 | /* |
364 | * Taken from glamor_egl.h from the Xorg xserver, which is MIT licensed | |
365 | * | |
366 | * Create an EGLDisplay from a native display type. This is a little quirky | |
367 | * for a few reasons. | |
368 | * | |
369 | * 1: GetPlatformDisplayEXT and GetPlatformDisplay are the API you want to | |
370 | * use, but have different function signatures in the third argument; this | |
371 | * happens not to matter for us, at the moment, but it means epoxy won't alias | |
372 | * them together. | |
373 | * | |
374 | * 2: epoxy 1.3 and earlier don't understand EGL client extensions, which | |
375 | * means you can't call "eglGetPlatformDisplayEXT" directly, as the resolver | |
376 | * will crash. | |
377 | * | |
378 | * 3: You can't tell whether you have EGL 1.5 at this point, because | |
379 | * eglQueryString(EGL_VERSION) is a property of the display, which we don't | |
380 | * have yet. So you have to query for extensions no matter what. Fortunately | |
381 | * epoxy_has_egl_extension _does_ let you query for client extensions, so | |
382 | * we don't have to write our own extension string parsing. | |
383 | * | |
384 | * 4. There is no EGL_KHR_platform_base to complement the EXT one, thus one | |
385 | * needs to know EGL 1.5 is supported in order to use the eglGetPlatformDisplay | |
386 | * function pointer. | |
387 | * We can workaround this (circular dependency) by probing for the EGL 1.5 | |
388 | * platform extensions (EGL_KHR_platform_gbm and friends) yet it doesn't seem | |
389 | * like mesa will be able to advertise these (even though it can do EGL 1.5). | |
390 | */ | |
e1913dbb GH |
391 | static EGLDisplay qemu_egl_get_display(EGLNativeDisplayType native, |
392 | EGLenum platform) | |
8bce03e3 GH |
393 | { |
394 | EGLDisplay dpy = EGL_NO_DISPLAY; | |
395 | ||
8bce03e3 GH |
396 | /* In practise any EGL 1.5 implementation would support the EXT extension */ |
397 | if (epoxy_has_egl_extension(NULL, "EGL_EXT_platform_base")) { | |
398 | PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplayEXT = | |
399 | (void *) eglGetProcAddress("eglGetPlatformDisplayEXT"); | |
e1913dbb GH |
400 | if (getPlatformDisplayEXT && platform != 0) { |
401 | dpy = getPlatformDisplayEXT(platform, native, NULL); | |
8bce03e3 GH |
402 | } |
403 | } | |
8bce03e3 GH |
404 | |
405 | if (dpy == EGL_NO_DISPLAY) { | |
406 | /* fallback */ | |
407 | dpy = eglGetDisplay(native); | |
408 | } | |
409 | return dpy; | |
410 | } | |
411 | ||
e1913dbb | 412 | static int qemu_egl_init_dpy(EGLNativeDisplayType dpy, |
54d208ff GH |
413 | EGLenum platform, |
414 | DisplayGLMode mode) | |
7ced9e9f | 415 | { |
54d208ff | 416 | static const EGLint conf_att_core[] = { |
7ced9e9f GH |
417 | EGL_SURFACE_TYPE, EGL_WINDOW_BIT, |
418 | EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT, | |
419 | EGL_RED_SIZE, 5, | |
420 | EGL_GREEN_SIZE, 5, | |
421 | EGL_BLUE_SIZE, 5, | |
422 | EGL_ALPHA_SIZE, 0, | |
423 | EGL_NONE, | |
424 | }; | |
54d208ff GH |
425 | static const EGLint conf_att_gles[] = { |
426 | EGL_SURFACE_TYPE, EGL_WINDOW_BIT, | |
427 | EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, | |
428 | EGL_RED_SIZE, 5, | |
429 | EGL_GREEN_SIZE, 5, | |
430 | EGL_BLUE_SIZE, 5, | |
431 | EGL_ALPHA_SIZE, 0, | |
432 | EGL_NONE, | |
433 | }; | |
7ced9e9f GH |
434 | EGLint major, minor; |
435 | EGLBoolean b; | |
436 | EGLint n; | |
54d208ff | 437 | bool gles = (mode == DISPLAYGL_MODE_ES); |
7ced9e9f | 438 | |
e1913dbb | 439 | qemu_egl_display = qemu_egl_get_display(dpy, platform); |
7ced9e9f | 440 | if (qemu_egl_display == EGL_NO_DISPLAY) { |
38a55bdd | 441 | error_report("egl: eglGetDisplay failed"); |
7ced9e9f GH |
442 | return -1; |
443 | } | |
444 | ||
7ced9e9f GH |
445 | b = eglInitialize(qemu_egl_display, &major, &minor); |
446 | if (b == EGL_FALSE) { | |
38a55bdd | 447 | error_report("egl: eglInitialize failed"); |
7ced9e9f GH |
448 | return -1; |
449 | } | |
450 | ||
54d208ff | 451 | b = eglBindAPI(gles ? EGL_OPENGL_ES_API : EGL_OPENGL_API); |
7ced9e9f | 452 | if (b == EGL_FALSE) { |
54d208ff GH |
453 | error_report("egl: eglBindAPI failed (%s mode)", |
454 | gles ? "gles" : "core"); | |
7ced9e9f GH |
455 | return -1; |
456 | } | |
457 | ||
54d208ff GH |
458 | b = eglChooseConfig(qemu_egl_display, |
459 | gles ? conf_att_gles : conf_att_core, | |
7ced9e9f GH |
460 | &qemu_egl_config, 1, &n); |
461 | if (b == EGL_FALSE || n != 1) { | |
54d208ff GH |
462 | error_report("egl: eglChooseConfig failed (%s mode)", |
463 | gles ? "gles" : "core"); | |
7ced9e9f GH |
464 | return -1; |
465 | } | |
54d208ff GH |
466 | |
467 | qemu_egl_mode = gles ? DISPLAYGL_MODE_ES : DISPLAYGL_MODE_CORE; | |
7ced9e9f GH |
468 | return 0; |
469 | } | |
470 | ||
54d208ff | 471 | int qemu_egl_init_dpy_x11(EGLNativeDisplayType dpy, DisplayGLMode mode) |
e1913dbb GH |
472 | { |
473 | #ifdef EGL_KHR_platform_x11 | |
54d208ff | 474 | return qemu_egl_init_dpy(dpy, EGL_PLATFORM_X11_KHR, mode); |
e1913dbb | 475 | #else |
54d208ff | 476 | return qemu_egl_init_dpy(dpy, 0, mode); |
e1913dbb GH |
477 | #endif |
478 | } | |
479 | ||
54d208ff | 480 | int qemu_egl_init_dpy_mesa(EGLNativeDisplayType dpy, DisplayGLMode mode) |
e1913dbb GH |
481 | { |
482 | #ifdef EGL_MESA_platform_gbm | |
54d208ff | 483 | return qemu_egl_init_dpy(dpy, EGL_PLATFORM_GBM_MESA, mode); |
e1913dbb | 484 | #else |
54d208ff | 485 | return qemu_egl_init_dpy(dpy, 0, mode); |
e1913dbb GH |
486 | #endif |
487 | } | |
488 | ||
bc6a3565 AO |
489 | #endif |
490 | ||
0df5c72b MAL |
491 | bool qemu_egl_has_dmabuf(void) |
492 | { | |
493 | if (qemu_egl_display == EGL_NO_DISPLAY) { | |
494 | return false; | |
495 | } | |
496 | ||
497 | return epoxy_has_egl_extension(qemu_egl_display, | |
498 | "EGL_EXT_image_dma_buf_import"); | |
499 | } | |
500 | ||
7ced9e9f GH |
501 | EGLContext qemu_egl_init_ctx(void) |
502 | { | |
54d208ff | 503 | static const EGLint ctx_att_core[] = { |
bc8c946f | 504 | EGL_CONTEXT_OPENGL_PROFILE_MASK, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, |
7ced9e9f GH |
505 | EGL_NONE |
506 | }; | |
54d208ff GH |
507 | static const EGLint ctx_att_gles[] = { |
508 | EGL_CONTEXT_CLIENT_VERSION, 2, | |
509 | EGL_NONE | |
510 | }; | |
511 | bool gles = (qemu_egl_mode == DISPLAYGL_MODE_ES); | |
7ced9e9f GH |
512 | EGLContext ectx; |
513 | EGLBoolean b; | |
514 | ||
7ced9e9f | 515 | ectx = eglCreateContext(qemu_egl_display, qemu_egl_config, EGL_NO_CONTEXT, |
54d208ff | 516 | gles ? ctx_att_gles : ctx_att_core); |
7ced9e9f | 517 | if (ectx == EGL_NO_CONTEXT) { |
38a55bdd | 518 | error_report("egl: eglCreateContext failed"); |
7ced9e9f GH |
519 | return NULL; |
520 | } | |
521 | ||
522 | b = eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, ectx); | |
523 | if (b == EGL_FALSE) { | |
38a55bdd | 524 | error_report("egl: eglMakeCurrent failed"); |
7ced9e9f GH |
525 | return NULL; |
526 | } | |
527 | ||
528 | return ectx; | |
529 | } |