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 */ 17 #include "qemu/osdep.h" 18 19 #include "qemu/drm.h" 20 #include "qemu/error-report.h" 21 #include "ui/console.h" 22 #include "ui/egl-helpers.h" 23 #include "sysemu/sysemu.h" 24 #include "qapi/error.h" 25 #include "trace.h" 26 27 EGLDisplay *qemu_egl_display; 28 EGLConfig qemu_egl_config; 29 DisplayGLMode qemu_egl_mode; 30 bool qemu_egl_angle_d3d; 31 32 /* ------------------------------------------------------------------ */ 33 34 const char *qemu_egl_get_error_string(void) 35 { 36 EGLint error = eglGetError(); 37 38 switch (error) { 39 case EGL_SUCCESS: 40 return "EGL_SUCCESS"; 41 case EGL_NOT_INITIALIZED: 42 return "EGL_NOT_INITIALIZED"; 43 case EGL_BAD_ACCESS: 44 return "EGL_BAD_ACCESS"; 45 case EGL_BAD_ALLOC: 46 return "EGL_BAD_ALLOC"; 47 case EGL_BAD_ATTRIBUTE: 48 return "EGL_BAD_ATTRIBUTE"; 49 case EGL_BAD_CONTEXT: 50 return "EGL_BAD_CONTEXT"; 51 case EGL_BAD_CONFIG: 52 return "EGL_BAD_CONFIG"; 53 case EGL_BAD_CURRENT_SURFACE: 54 return "EGL_BAD_CURRENT_SURFACE"; 55 case EGL_BAD_DISPLAY: 56 return "EGL_BAD_DISPLAY"; 57 case EGL_BAD_SURFACE: 58 return "EGL_BAD_SURFACE"; 59 case EGL_BAD_MATCH: 60 return "EGL_BAD_MATCH"; 61 case EGL_BAD_PARAMETER: 62 return "EGL_BAD_PARAMETER"; 63 case EGL_BAD_NATIVE_PIXMAP: 64 return "EGL_BAD_NATIVE_PIXMAP"; 65 case EGL_BAD_NATIVE_WINDOW: 66 return "EGL_BAD_NATIVE_WINDOW"; 67 case EGL_CONTEXT_LOST: 68 return "EGL_CONTEXT_LOST"; 69 default: 70 return "Unknown EGL error"; 71 } 72 } 73 74 static void egl_fb_delete_texture(egl_fb *fb) 75 { 76 if (!fb->delete_texture) { 77 return; 78 } 79 80 glDeleteTextures(1, &fb->texture); 81 fb->delete_texture = false; 82 } 83 84 void egl_fb_destroy(egl_fb *fb) 85 { 86 if (!fb->framebuffer) { 87 return; 88 } 89 90 egl_fb_delete_texture(fb); 91 glDeleteFramebuffers(1, &fb->framebuffer); 92 93 fb->width = 0; 94 fb->height = 0; 95 fb->texture = 0; 96 fb->framebuffer = 0; 97 } 98 99 void egl_fb_setup_default(egl_fb *fb, int width, int height) 100 { 101 fb->width = width; 102 fb->height = height; 103 fb->framebuffer = 0; /* default framebuffer */ 104 } 105 106 void egl_fb_setup_for_tex(egl_fb *fb, int width, int height, 107 GLuint texture, bool delete) 108 { 109 egl_fb_delete_texture(fb); 110 111 fb->width = width; 112 fb->height = height; 113 fb->texture = texture; 114 fb->delete_texture = delete; 115 if (!fb->framebuffer) { 116 glGenFramebuffers(1, &fb->framebuffer); 117 } 118 119 glBindFramebuffer(GL_FRAMEBUFFER_EXT, fb->framebuffer); 120 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, 121 GL_TEXTURE_2D, fb->texture, 0); 122 } 123 124 void egl_fb_setup_new_tex(egl_fb *fb, int width, int height) 125 { 126 GLuint texture; 127 128 glGenTextures(1, &texture); 129 glBindTexture(GL_TEXTURE_2D, texture); 130 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 131 0, GL_BGRA, GL_UNSIGNED_BYTE, 0); 132 133 egl_fb_setup_for_tex(fb, width, height, texture, true); 134 } 135 136 void egl_fb_blit(egl_fb *dst, egl_fb *src, bool flip) 137 { 138 GLuint x1 = 0; 139 GLuint y1 = 0; 140 GLuint x2, y2; 141 GLuint w = src->width; 142 GLuint h = src->height; 143 144 glBindFramebuffer(GL_READ_FRAMEBUFFER, src->framebuffer); 145 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dst->framebuffer); 146 glViewport(0, 0, dst->width, dst->height); 147 148 if (src->dmabuf) { 149 x1 = qemu_dmabuf_get_x(src->dmabuf); 150 y1 = qemu_dmabuf_get_y(src->dmabuf); 151 w = qemu_dmabuf_get_width(src->dmabuf); 152 h = qemu_dmabuf_get_height(src->dmabuf); 153 } 154 155 w = (x1 + w) > src->width ? src->width - x1 : w; 156 h = (y1 + h) > src->height ? src->height - y1 : h; 157 158 y2 = flip ? y1 : h + y1; 159 y1 = flip ? h + y1 : y1; 160 x2 = x1 + w; 161 162 glBlitFramebuffer(x1, y1, x2, y2, 163 0, 0, dst->width, dst->height, 164 GL_COLOR_BUFFER_BIT, GL_LINEAR); 165 } 166 167 void egl_fb_read(DisplaySurface *dst, egl_fb *src) 168 { 169 glBindFramebuffer(GL_READ_FRAMEBUFFER, src->framebuffer); 170 glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); 171 glReadPixels(0, 0, surface_width(dst), surface_height(dst), 172 GL_BGRA, GL_UNSIGNED_BYTE, surface_data(dst)); 173 } 174 175 void egl_fb_read_rect(DisplaySurface *dst, egl_fb *src, int x, int y, int w, int h) 176 { 177 assert(surface_width(dst) == src->width); 178 assert(surface_height(dst) == src->height); 179 assert(surface_format(dst) == PIXMAN_x8r8g8b8); 180 181 glBindFramebuffer(GL_READ_FRAMEBUFFER, src->framebuffer); 182 glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); 183 glPixelStorei(GL_PACK_ROW_LENGTH, surface_stride(dst) / 4); 184 glReadPixels(x, y, w, h, 185 GL_BGRA, GL_UNSIGNED_BYTE, surface_data(dst) + x * 4); 186 glPixelStorei(GL_PACK_ROW_LENGTH, 0); 187 } 188 189 void egl_texture_blit(QemuGLShader *gls, egl_fb *dst, egl_fb *src, bool flip) 190 { 191 glBindFramebuffer(GL_FRAMEBUFFER_EXT, dst->framebuffer); 192 glViewport(0, 0, dst->width, dst->height); 193 glEnable(GL_TEXTURE_2D); 194 glBindTexture(GL_TEXTURE_2D, src->texture); 195 qemu_gl_run_texture_blit(gls, flip); 196 } 197 198 void egl_texture_blend(QemuGLShader *gls, egl_fb *dst, egl_fb *src, bool flip, 199 int x, int y, double scale_x, double scale_y) 200 { 201 glBindFramebuffer(GL_FRAMEBUFFER_EXT, dst->framebuffer); 202 int w = scale_x * src->width; 203 int h = scale_y * src->height; 204 if (flip) { 205 glViewport(x, y, w, h); 206 } else { 207 glViewport(x, dst->height - h - y, w, h); 208 } 209 glEnable(GL_TEXTURE_2D); 210 glBindTexture(GL_TEXTURE_2D, src->texture); 211 glEnable(GL_BLEND); 212 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 213 qemu_gl_run_texture_blit(gls, flip); 214 glDisable(GL_BLEND); 215 } 216 217 /* ---------------------------------------------------------------------- */ 218 219 EGLContext qemu_egl_rn_ctx; 220 221 #ifdef CONFIG_GBM 222 223 int qemu_egl_rn_fd; 224 struct gbm_device *qemu_egl_rn_gbm_dev; 225 226 int egl_rendernode_init(const char *rendernode, DisplayGLMode mode) 227 { 228 qemu_egl_rn_fd = -1; 229 int rc; 230 231 qemu_egl_rn_fd = qemu_drm_rendernode_open(rendernode); 232 if (qemu_egl_rn_fd == -1) { 233 error_report("egl: no drm render node available"); 234 goto err; 235 } 236 237 qemu_egl_rn_gbm_dev = gbm_create_device(qemu_egl_rn_fd); 238 if (!qemu_egl_rn_gbm_dev) { 239 error_report("egl: gbm_create_device failed"); 240 goto err; 241 } 242 243 rc = qemu_egl_init_dpy_mesa((EGLNativeDisplayType)qemu_egl_rn_gbm_dev, 244 mode); 245 if (rc != 0) { 246 /* qemu_egl_init_dpy_mesa reports error */ 247 goto err; 248 } 249 250 if (!epoxy_has_egl_extension(qemu_egl_display, 251 "EGL_KHR_surfaceless_context")) { 252 error_report("egl: EGL_KHR_surfaceless_context not supported"); 253 goto err; 254 } 255 if (!epoxy_has_egl_extension(qemu_egl_display, 256 "EGL_MESA_image_dma_buf_export")) { 257 error_report("egl: EGL_MESA_image_dma_buf_export not supported"); 258 goto err; 259 } 260 261 qemu_egl_rn_ctx = qemu_egl_init_ctx(); 262 if (!qemu_egl_rn_ctx) { 263 error_report("egl: egl_init_ctx failed"); 264 goto err; 265 } 266 267 return 0; 268 269 err: 270 if (qemu_egl_rn_gbm_dev) { 271 gbm_device_destroy(qemu_egl_rn_gbm_dev); 272 } 273 if (qemu_egl_rn_fd != -1) { 274 close(qemu_egl_rn_fd); 275 } 276 277 return -1; 278 } 279 280 int egl_get_fd_for_texture(uint32_t tex_id, EGLint *stride, EGLint *fourcc, 281 EGLuint64KHR *modifier) 282 { 283 EGLImageKHR image; 284 EGLint num_planes, fd; 285 286 image = eglCreateImageKHR(qemu_egl_display, eglGetCurrentContext(), 287 EGL_GL_TEXTURE_2D_KHR, 288 (EGLClientBuffer)(unsigned long)tex_id, 289 NULL); 290 if (!image) { 291 return -1; 292 } 293 294 eglExportDMABUFImageQueryMESA(qemu_egl_display, image, fourcc, 295 &num_planes, modifier); 296 if (num_planes != 1) { 297 eglDestroyImageKHR(qemu_egl_display, image); 298 return -1; 299 } 300 eglExportDMABUFImageMESA(qemu_egl_display, image, &fd, stride, NULL); 301 eglDestroyImageKHR(qemu_egl_display, image); 302 303 return fd; 304 } 305 306 void egl_dmabuf_import_texture(QemuDmaBuf *dmabuf) 307 { 308 EGLImageKHR image = EGL_NO_IMAGE_KHR; 309 EGLint attrs[64]; 310 int i = 0; 311 uint64_t modifier; 312 uint32_t texture = qemu_dmabuf_get_texture(dmabuf); 313 314 if (texture != 0) { 315 return; 316 } 317 318 attrs[i++] = EGL_WIDTH; 319 attrs[i++] = qemu_dmabuf_get_backing_width(dmabuf); 320 attrs[i++] = EGL_HEIGHT; 321 attrs[i++] = qemu_dmabuf_get_backing_height(dmabuf); 322 attrs[i++] = EGL_LINUX_DRM_FOURCC_EXT; 323 attrs[i++] = qemu_dmabuf_get_fourcc(dmabuf); 324 325 attrs[i++] = EGL_DMA_BUF_PLANE0_FD_EXT; 326 attrs[i++] = qemu_dmabuf_get_fd(dmabuf); 327 attrs[i++] = EGL_DMA_BUF_PLANE0_PITCH_EXT; 328 attrs[i++] = qemu_dmabuf_get_stride(dmabuf); 329 attrs[i++] = EGL_DMA_BUF_PLANE0_OFFSET_EXT; 330 attrs[i++] = 0; 331 #ifdef EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT 332 modifier = qemu_dmabuf_get_modifier(dmabuf); 333 if (modifier) { 334 attrs[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT; 335 attrs[i++] = (modifier >> 0) & 0xffffffff; 336 attrs[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT; 337 attrs[i++] = (modifier >> 32) & 0xffffffff; 338 } 339 #endif 340 attrs[i++] = EGL_NONE; 341 342 image = eglCreateImageKHR(qemu_egl_display, 343 EGL_NO_CONTEXT, 344 EGL_LINUX_DMA_BUF_EXT, 345 NULL, attrs); 346 if (image == EGL_NO_IMAGE_KHR) { 347 error_report("eglCreateImageKHR failed"); 348 return; 349 } 350 351 glGenTextures(1, &texture); 352 qemu_dmabuf_set_texture(dmabuf, texture); 353 glBindTexture(GL_TEXTURE_2D, texture); 354 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 355 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 356 357 glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image); 358 eglDestroyImageKHR(qemu_egl_display, image); 359 } 360 361 void egl_dmabuf_release_texture(QemuDmaBuf *dmabuf) 362 { 363 uint32_t texture; 364 365 texture = qemu_dmabuf_get_texture(dmabuf); 366 if (texture == 0) { 367 return; 368 } 369 370 glDeleteTextures(1, &texture); 371 qemu_dmabuf_set_texture(dmabuf, 0); 372 } 373 374 void egl_dmabuf_create_sync(QemuDmaBuf *dmabuf) 375 { 376 EGLSyncKHR sync; 377 378 if (epoxy_has_egl_extension(qemu_egl_display, 379 "EGL_KHR_fence_sync") && 380 epoxy_has_egl_extension(qemu_egl_display, 381 "EGL_ANDROID_native_fence_sync")) { 382 sync = eglCreateSyncKHR(qemu_egl_display, 383 EGL_SYNC_NATIVE_FENCE_ANDROID, NULL); 384 if (sync != EGL_NO_SYNC_KHR) { 385 qemu_dmabuf_set_sync(dmabuf, sync); 386 } 387 } 388 } 389 390 void egl_dmabuf_create_fence(QemuDmaBuf *dmabuf) 391 { 392 void *sync = qemu_dmabuf_get_sync(dmabuf); 393 int fence_fd; 394 395 if (sync) { 396 fence_fd = eglDupNativeFenceFDANDROID(qemu_egl_display, 397 sync); 398 qemu_dmabuf_set_fence_fd(dmabuf, fence_fd); 399 eglDestroySyncKHR(qemu_egl_display, sync); 400 qemu_dmabuf_set_sync(dmabuf, NULL); 401 } 402 } 403 404 #endif /* CONFIG_GBM */ 405 406 /* ---------------------------------------------------------------------- */ 407 408 EGLSurface qemu_egl_init_surface_x11(EGLContext ectx, EGLNativeWindowType win) 409 { 410 EGLSurface esurface; 411 EGLBoolean b; 412 413 esurface = eglCreateWindowSurface(qemu_egl_display, 414 qemu_egl_config, 415 win, NULL); 416 if (esurface == EGL_NO_SURFACE) { 417 error_report("egl: eglCreateWindowSurface failed"); 418 return NULL; 419 } 420 421 b = eglMakeCurrent(qemu_egl_display, esurface, esurface, ectx); 422 if (b == EGL_FALSE) { 423 error_report("egl: eglMakeCurrent failed"); 424 return NULL; 425 } 426 427 return esurface; 428 } 429 430 /* ---------------------------------------------------------------------- */ 431 432 #if defined(CONFIG_X11) || defined(CONFIG_GBM) || defined(WIN32) 433 434 /* 435 * Taken from glamor_egl.h from the Xorg xserver, which is MIT licensed 436 * 437 * Create an EGLDisplay from a native display type. This is a little quirky 438 * for a few reasons. 439 * 440 * 1: GetPlatformDisplayEXT and GetPlatformDisplay are the API you want to 441 * use, but have different function signatures in the third argument; this 442 * happens not to matter for us, at the moment, but it means epoxy won't alias 443 * them together. 444 * 445 * 2: epoxy 1.3 and earlier don't understand EGL client extensions, which 446 * means you can't call "eglGetPlatformDisplayEXT" directly, as the resolver 447 * will crash. 448 * 449 * 3: You can't tell whether you have EGL 1.5 at this point, because 450 * eglQueryString(EGL_VERSION) is a property of the display, which we don't 451 * have yet. So you have to query for extensions no matter what. Fortunately 452 * epoxy_has_egl_extension _does_ let you query for client extensions, so 453 * we don't have to write our own extension string parsing. 454 * 455 * 4. There is no EGL_KHR_platform_base to complement the EXT one, thus one 456 * needs to know EGL 1.5 is supported in order to use the eglGetPlatformDisplay 457 * function pointer. 458 * We can workaround this (circular dependency) by probing for the EGL 1.5 459 * platform extensions (EGL_KHR_platform_gbm and friends) yet it doesn't seem 460 * like mesa will be able to advertise these (even though it can do EGL 1.5). 461 */ 462 static EGLDisplay qemu_egl_get_display(EGLNativeDisplayType native, 463 EGLenum platform) 464 { 465 EGLDisplay dpy = EGL_NO_DISPLAY; 466 467 /* In practise any EGL 1.5 implementation would support the EXT extension */ 468 if (epoxy_has_egl_extension(NULL, "EGL_EXT_platform_base")) { 469 if (platform != 0) { 470 dpy = eglGetPlatformDisplayEXT(platform, native, NULL); 471 } 472 } 473 474 if (dpy == EGL_NO_DISPLAY) { 475 /* fallback */ 476 dpy = eglGetDisplay(native); 477 } 478 return dpy; 479 } 480 481 static int qemu_egl_init_dpy(EGLNativeDisplayType dpy, 482 EGLenum platform, 483 DisplayGLMode mode) 484 { 485 static const EGLint conf_att_core[] = { 486 EGL_SURFACE_TYPE, EGL_WINDOW_BIT, 487 EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT, 488 EGL_RED_SIZE, 5, 489 EGL_GREEN_SIZE, 5, 490 EGL_BLUE_SIZE, 5, 491 EGL_ALPHA_SIZE, 0, 492 EGL_NONE, 493 }; 494 static const EGLint conf_att_gles[] = { 495 EGL_SURFACE_TYPE, EGL_WINDOW_BIT, 496 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, 497 EGL_RED_SIZE, 5, 498 EGL_GREEN_SIZE, 5, 499 EGL_BLUE_SIZE, 5, 500 EGL_ALPHA_SIZE, 0, 501 EGL_NONE, 502 }; 503 EGLint major, minor; 504 EGLBoolean b; 505 EGLint n; 506 bool gles = (mode == DISPLAYGL_MODE_ES); 507 508 qemu_egl_display = qemu_egl_get_display(dpy, platform); 509 if (qemu_egl_display == EGL_NO_DISPLAY) { 510 error_report("egl: eglGetDisplay failed: %s", qemu_egl_get_error_string()); 511 return -1; 512 } 513 514 b = eglInitialize(qemu_egl_display, &major, &minor); 515 if (b == EGL_FALSE) { 516 error_report("egl: eglInitialize failed: %s", qemu_egl_get_error_string()); 517 return -1; 518 } 519 520 b = eglBindAPI(gles ? EGL_OPENGL_ES_API : EGL_OPENGL_API); 521 if (b == EGL_FALSE) { 522 error_report("egl: eglBindAPI failed (%s mode): %s", 523 gles ? "gles" : "core", qemu_egl_get_error_string()); 524 return -1; 525 } 526 527 b = eglChooseConfig(qemu_egl_display, 528 gles ? conf_att_gles : conf_att_core, 529 &qemu_egl_config, 1, &n); 530 if (b == EGL_FALSE || n != 1) { 531 error_report("egl: eglChooseConfig failed (%s mode): %s", 532 gles ? "gles" : "core", qemu_egl_get_error_string()); 533 return -1; 534 } 535 536 qemu_egl_mode = gles ? DISPLAYGL_MODE_ES : DISPLAYGL_MODE_CORE; 537 return 0; 538 } 539 540 #endif 541 542 #if defined(CONFIG_X11) || defined(CONFIG_GBM) 543 int qemu_egl_init_dpy_x11(EGLNativeDisplayType dpy, DisplayGLMode mode) 544 { 545 #ifdef EGL_KHR_platform_x11 546 return qemu_egl_init_dpy(dpy, EGL_PLATFORM_X11_KHR, mode); 547 #else 548 return qemu_egl_init_dpy(dpy, 0, mode); 549 #endif 550 } 551 552 int qemu_egl_init_dpy_mesa(EGLNativeDisplayType dpy, DisplayGLMode mode) 553 { 554 #ifdef EGL_MESA_platform_gbm 555 return qemu_egl_init_dpy(dpy, EGL_PLATFORM_GBM_MESA, mode); 556 #else 557 return qemu_egl_init_dpy(dpy, 0, mode); 558 #endif 559 } 560 #endif 561 562 563 #ifdef WIN32 564 int qemu_egl_init_dpy_win32(EGLNativeDisplayType dpy, DisplayGLMode mode) 565 { 566 /* prefer GL ES, as that's what ANGLE supports */ 567 if (mode == DISPLAYGL_MODE_ON) { 568 mode = DISPLAYGL_MODE_ES; 569 } 570 571 if (qemu_egl_init_dpy(dpy, 0, mode) < 0) { 572 return -1; 573 } 574 575 #ifdef EGL_D3D11_DEVICE_ANGLE 576 if (epoxy_has_egl_extension(qemu_egl_display, "EGL_EXT_device_query")) { 577 EGLDeviceEXT device; 578 void *d3d11_device; 579 580 if (!eglQueryDisplayAttribEXT(qemu_egl_display, 581 EGL_DEVICE_EXT, 582 (EGLAttrib *)&device)) { 583 return 0; 584 } 585 586 if (!eglQueryDeviceAttribEXT(device, 587 EGL_D3D11_DEVICE_ANGLE, 588 (EGLAttrib *)&d3d11_device)) { 589 return 0; 590 } 591 592 trace_egl_init_d3d11_device(device); 593 qemu_egl_angle_d3d = device != NULL; 594 } 595 #endif 596 597 return 0; 598 } 599 #endif 600 601 bool qemu_egl_has_dmabuf(void) 602 { 603 if (qemu_egl_display == EGL_NO_DISPLAY) { 604 return false; 605 } 606 607 return epoxy_has_egl_extension(qemu_egl_display, 608 "EGL_EXT_image_dma_buf_import"); 609 } 610 611 EGLContext qemu_egl_init_ctx(void) 612 { 613 static const EGLint ctx_att_core[] = { 614 EGL_CONTEXT_OPENGL_PROFILE_MASK, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, 615 EGL_NONE 616 }; 617 static const EGLint ctx_att_gles[] = { 618 EGL_CONTEXT_CLIENT_VERSION, 2, 619 EGL_NONE 620 }; 621 bool gles = (qemu_egl_mode == DISPLAYGL_MODE_ES); 622 EGLContext ectx; 623 EGLBoolean b; 624 625 ectx = eglCreateContext(qemu_egl_display, qemu_egl_config, EGL_NO_CONTEXT, 626 gles ? ctx_att_gles : ctx_att_core); 627 if (ectx == EGL_NO_CONTEXT) { 628 error_report("egl: eglCreateContext failed"); 629 return NULL; 630 } 631 632 b = eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, ectx); 633 if (b == EGL_FALSE) { 634 error_report("egl: eglMakeCurrent failed"); 635 return NULL; 636 } 637 638 return ectx; 639 } 640 641 bool egl_init(const char *rendernode, DisplayGLMode mode, Error **errp) 642 { 643 ERRP_GUARD(); 644 645 if (mode == DISPLAYGL_MODE_OFF) { 646 error_setg(errp, "egl: turning off GL doesn't make sense"); 647 return false; 648 } 649 650 #ifdef WIN32 651 if (qemu_egl_init_dpy_win32(EGL_DEFAULT_DISPLAY, mode) < 0) { 652 error_setg(errp, "egl: init failed"); 653 return false; 654 } 655 qemu_egl_rn_ctx = qemu_egl_init_ctx(); 656 if (!qemu_egl_rn_ctx) { 657 error_setg(errp, "egl: egl_init_ctx failed"); 658 return false; 659 } 660 #elif defined(CONFIG_GBM) 661 if (egl_rendernode_init(rendernode, mode) < 0) { 662 error_setg(errp, "egl: render node init failed"); 663 return false; 664 } 665 #endif 666 667 if (!qemu_egl_rn_ctx) { 668 error_setg(errp, "egl: not available on this platform"); 669 return false; 670 } 671 672 display_opengl = 1; 673 return true; 674 } 675