Lines Matching refs:disp
121 #define RETURN_EGL_ERROR(disp, err, ret) \
123 if (disp) \
124 _eglUnlockDisplay(disp); \
131 #define RETURN_EGL_SUCCESS(disp, ret) \
132 RETURN_EGL_ERROR(disp, EGL_SUCCESS, ret)
135 #define RETURN_EGL_EVAL(disp, ret) \
136 RETURN_EGL_ERROR(disp, (ret) ? EGL_SUCCESS : 0, ret)
143 #define _EGL_CHECK_DISPLAY(disp, ret) \
145 if (!_eglCheckDisplay(disp, __func__)) \
146 RETURN_EGL_ERROR(disp, 0, ret); \
149 #define _EGL_CHECK_OBJECT(disp, type, obj, ret) \
151 if (!_eglCheck ## type(disp, obj, __func__)) \
152 RETURN_EGL_ERROR(disp, 0, ret); \
155 #define _EGL_CHECK_SURFACE(disp, surf, ret) \
156 _EGL_CHECK_OBJECT(disp, Surface, surf, ret)
158 #define _EGL_CHECK_CONTEXT(disp, context, ret) \
159 _EGL_CHECK_OBJECT(disp, Context, context, ret)
161 #define _EGL_CHECK_CONFIG(disp, conf, ret) \
162 _EGL_CHECK_OBJECT(disp, Config, conf, ret)
164 #define _EGL_CHECK_SYNC(disp, s, ret) \
165 _EGL_CHECK_OBJECT(disp, Sync, s, ret)
178 _eglCheckDisplay(_EGLDisplay *disp, const char *msg)
180 if (!disp) {
184 if (!disp->Initialized) {
193 _eglCheckSurface(_EGLDisplay *disp, _EGLSurface *surf, const char *msg)
195 if (!_eglCheckDisplay(disp, msg))
206 _eglCheckContext(_EGLDisplay *disp, _EGLContext *context, const char *msg)
208 if (!_eglCheckDisplay(disp, msg))
219 _eglCheckConfig(_EGLDisplay *disp, _EGLConfig *conf, const char *msg)
221 if (!_eglCheckDisplay(disp, msg))
232 _eglCheckSync(_EGLDisplay *disp, _EGLSync *s, const char *msg)
234 if (!_eglCheckDisplay(disp, msg))
250 _EGLDisplay *disp = _eglLookupDisplay(dpy);
251 if (disp)
252 mtx_lock(&disp->Mutex);
253 return disp;
261 _eglUnlockDisplay(_EGLDisplay *disp)
263 mtx_unlock(&disp->Mutex);
267 _eglSetFuncName(const char *funcName, _EGLDisplay *disp, EGLenum objectType, _EGLResource *object)
275 else if (objectType == EGL_OBJECT_DISPLAY_KHR && disp)
276 thr->CurrentObjectLabel = disp->Label;
283 #define _EGL_FUNC_START(disp, objectType, object, ret) \
285 if (!_eglSetFuncName(__func__, disp, objectType, (_EGLResource *) object)) { \
286 if (disp) \
287 _eglUnlockDisplay(disp); \
360 _EGLDisplay *disp;
369 disp = _eglFindDisplay(plat, native_display_ptr, NULL);
370 return _eglGetDisplayHandle(disp);
377 _EGLDisplay *disp;
382 disp = _eglGetX11Display((Display*) native_display, attrib_list);
387 disp = _eglGetXcbDisplay((xcb_connection_t*) native_display, attrib_list);
392 disp = _eglGetGbmDisplay((struct gbm_device*) native_display,
398 disp = _eglGetWaylandDisplay((struct wl_display*) native_display,
403 disp = _eglGetSurfacelessDisplay(native_display, attrib_list);
407 disp = _eglGetAndroidDisplay(native_display, attrib_list);
412 disp = _eglGetOHOSDisplay(native_display, attrib_list);
416 disp = _eglGetDeviceDisplay(native_display, attrib_list);
422 return _eglGetDisplayHandle(disp);
430 EGLDisplay disp;
437 disp = _eglGetPlatformDisplayCommon(platform, native_display, attrib_list);
439 return disp;
478 _eglCreateExtensionsString(_EGLDisplay *disp)
482 if (disp->Extensions.ext) { \
484 assert(exts <= disp->ExtensionsString + _EGL_MAX_EXTENSIONS_LEN); \
488 char *exts = disp->ExtensionsString;
523 if (disp->Extensions.KHR_image_base && disp->Extensions.KHR_image_pixmap)
524 disp->Extensions.KHR_image = EGL_TRUE;
533 if (disp->Extensions.EXT_swap_buffers_with_damage)
538 if (disp->Extensions.KHR_no_config_context)
556 _eglCreateAPIsString(_EGLDisplay *disp)
560 const size_t old_len = strlen(disp->ClientAPIsString); \
562 const size_t max_len = sizeof(disp->ClientAPIsString) - 1; \
564 strcat(disp->ClientAPIsString, str " "); \
566 assert(!"disp->ClientAPIsString is not large enough"); \
569 if (disp->ClientAPIs & EGL_OPENGL_BIT)
572 if (disp->ClientAPIs & EGL_OPENGL_ES_BIT ||
573 disp->ClientAPIs & EGL_OPENGL_ES2_BIT ||
574 disp->ClientAPIs & EGL_OPENGL_ES3_BIT_KHR) {
578 if (disp->ClientAPIs & EGL_OPENVG_BIT)
585 _eglComputeVersion(_EGLDisplay *disp)
587 disp->Version = 14;
589 if (disp->Extensions.KHR_fence_sync &&
590 disp->Extensions.KHR_cl_event2 &&
591 disp->Extensions.KHR_wait_sync &&
592 disp->Extensions.KHR_image_base &&
593 disp->Extensions.KHR_gl_texture_2D_image &&
594 disp->Extensions.KHR_gl_texture_3D_image &&
595 disp->Extensions.KHR_gl_texture_cubemap_image &&
596 disp->Extensions.KHR_gl_renderbuffer_image &&
597 disp->Extensions.KHR_create_context &&
598 disp->Extensions.EXT_create_context_robustness &&
599 disp->Extensions.KHR_get_all_proc_addresses &&
600 disp->Extensions.KHR_gl_colorspace &&
601 disp->Extensions.KHR_surfaceless_context)
602 disp->Version = 15;
606 disp->Version = 14;
617 _EGLDisplay *disp = _eglLockDisplay(dpy);
619 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
621 if (!disp)
624 if (!disp->Initialized) {
626 disp->Options.ForceSoftware =
628 if (disp->Options.ForceSoftware)
632 disp->Options.Zink = env && !strcmp(env, "zink");
633 disp->Options.ForceSoftware |= disp->Options.Zink;
639 if (!_eglDriver.Initialize(disp)) {
640 if (disp->Options.ForceSoftware)
641 RETURN_EGL_ERROR(disp, EGL_NOT_INITIALIZED, EGL_FALSE);
643 disp->Options.ForceSoftware = EGL_TRUE;
644 if (!_eglDriver.Initialize(disp))
645 RETURN_EGL_ERROR(disp, EGL_NOT_INITIALIZED, EGL_FALSE);
649 disp->Initialized = EGL_TRUE;
650 disp->Driver = &_eglDriver;
653 disp->ClientAPIs &= _EGL_API_ALL_BITS;
670 disp->Extensions.KHR_get_all_proc_addresses = EGL_TRUE;
675 disp->Extensions.KHR_config_attribs = EGL_TRUE;
677 _eglComputeVersion(disp);
678 _eglCreateExtensionsString(disp);
679 _eglCreateAPIsString(disp);
680 snprintf(disp->VersionString, sizeof(disp->VersionString),
681 "%d.%d", disp->Version / 10, disp->Version % 10);
686 *major = disp->Version / 10;
687 *minor = disp->Version % 10;
690 RETURN_EGL_SUCCESS(disp, EGL_TRUE);
697 _EGLDisplay *disp = _eglLockDisplay(dpy);
699 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
701 if (!disp)
704 if (disp->Initialized) {
705 disp->Driver->Terminate(disp);
706 /* do not reset disp->Driver */
707 disp->ClientAPIsString[0] = 0;
708 disp->Initialized = EGL_FALSE;
711 disp->BlobCacheSet = NULL;
712 disp->BlobCacheGet = NULL;
715 RETURN_EGL_SUCCESS(disp, EGL_TRUE);
722 _EGLDisplay *disp;
730 disp = _eglLockDisplay(dpy);
731 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, NULL);
732 _EGL_CHECK_DISPLAY(disp, NULL);
736 RETURN_EGL_SUCCESS(disp, _EGL_VENDOR_STRING);
738 RETURN_EGL_SUCCESS(disp, disp->VersionString);
740 RETURN_EGL_SUCCESS(disp, disp->ExtensionsString);
742 RETURN_EGL_SUCCESS(disp, disp->ClientAPIsString);
744 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, NULL);
753 _EGLDisplay *disp = _eglLockDisplay(dpy);
756 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
758 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
761 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
763 ret = _eglGetConfigs(disp, configs, config_size, num_config);
765 RETURN_EGL_EVAL(disp, ret);
773 _EGLDisplay *disp = _eglLockDisplay(dpy);
776 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
778 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
781 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
783 ret = _eglChooseConfig(disp, attrib_list, configs,
786 RETURN_EGL_EVAL(disp, ret);
794 _EGLDisplay *disp = _eglLockDisplay(dpy);
795 _EGLConfig *conf = _eglLookupConfig(config, disp);
798 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
800 _EGL_CHECK_CONFIG(disp, conf, EGL_FALSE);
802 ret = _eglGetConfigAttrib(disp, conf, attribute, value);
804 RETURN_EGL_EVAL(disp, ret);
812 _EGLDisplay *disp = _eglLockDisplay(dpy);
813 _EGLConfig *conf = _eglLookupConfig(config, disp);
814 _EGLContext *share = _eglLookupContext(share_list, disp);
818 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_CONTEXT);
820 _EGL_CHECK_DISPLAY(disp, EGL_NO_CONTEXT);
823 _EGL_CHECK_CONFIG(disp, conf, EGL_NO_CONTEXT);
824 else if (!disp->Extensions.KHR_no_config_context)
825 RETURN_EGL_ERROR(disp, EGL_BAD_CONFIG, EGL_NO_CONTEXT);
828 RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
830 context = disp->Driver->CreateContext(disp, conf, share, attrib_list);
833 RETURN_EGL_EVAL(disp, ret);
840 _EGLDisplay *disp = _eglLockDisplay(dpy);
841 _EGLContext *context = _eglLookupContext(ctx, disp);
844 _EGL_FUNC_START(disp, EGL_OBJECT_CONTEXT_KHR, context, EGL_FALSE);
846 _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE);
848 ret = disp->Driver->DestroyContext(disp, context);
850 RETURN_EGL_EVAL(disp, ret);
858 _EGLDisplay *disp = _eglLockDisplay(dpy);
859 _EGLContext *context = _eglLookupContext(ctx, disp);
860 _EGLSurface *draw_surf = _eglLookupSurface(draw, disp);
861 _EGLSurface *read_surf = _eglLookupSurface(read, disp);
864 _EGL_FUNC_START(disp, EGL_OBJECT_CONTEXT_KHR, context, EGL_FALSE);
866 if (!disp)
867 RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
870 if (!disp->Initialized) {
873 RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
875 if (!disp->Driver)
876 RETURN_EGL_SUCCESS(disp, EGL_TRUE);
879 RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
886 if (!disp->Extensions.KHR_surfaceless_context && ctx != EGL_NO_CONTEXT)
887 RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
891 RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
893 RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_FALSE);
900 RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_FALSE);
902 RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_FALSE);
910 RETURN_EGL_ERROR(disp, EGL_BAD_ACCESS, EGL_FALSE);
912 ret = disp->Driver->MakeCurrent(disp, draw_surf, read_surf, context);
914 RETURN_EGL_EVAL(disp, ret);
922 _EGLDisplay *disp = _eglLockDisplay(dpy);
923 _EGLContext *context = _eglLookupContext(ctx, disp);
926 _EGL_FUNC_START(disp, EGL_OBJECT_CONTEXT_KHR, context, EGL_FALSE);
928 _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE);
932 RETURN_EGL_EVAL(disp, ret);
941 _eglNativeSurfaceAlreadyUsed(_EGLDisplay *disp, void *native_surface)
945 list = disp->ResourceLists[_EGL_RESOURCE_SURFACE];
963 _eglCreateWindowSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
966 _EGLConfig *conf = _eglLookupConfig(config, disp);
972 RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
974 if (disp && (disp->Platform == _EGL_PLATFORM_SURFACELESS ||
975 disp->Platform == _EGL_PLATFORM_DEVICE)) {
988 RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
991 _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
994 RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_NO_SURFACE);
996 if (_eglNativeSurfaceAlreadyUsed(disp, native_window))
997 RETURN_EGL_ERROR(disp, EGL_BAD_ALLOC, EGL_NO_SURFACE);
999 surf = disp->Driver->CreateWindowSurface(disp, conf, native_window, attrib_list);
1002 RETURN_EGL_EVAL(disp, ret);
1010 _EGLDisplay *disp = _eglLockDisplay(dpy);
1012 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
1014 return _eglCreateWindowSurfaceCommon(disp, config, (void*) window,
1019 _fixupNativeWindow(_EGLDisplay *disp, void *native_window)
1022 if (disp && disp->Platform == _EGL_PLATFORM_X11 && native_window != NULL) {
1034 if (disp && disp->Platform == _EGL_PLATFORM_XCB && native_window != NULL) {
1050 _EGLDisplay *disp = _eglLockDisplay(dpy);
1052 native_window = _fixupNativeWindow(disp, native_window);
1054 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
1055 return _eglCreateWindowSurfaceCommon(disp, config, native_window,
1065 _EGLDisplay *disp = _eglLockDisplay(dpy);
1069 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
1073 RETURN_EGL_ERROR(disp, EGL_BAD_ALLOC, EGL_NO_SURFACE);
1075 native_window = _fixupNativeWindow(disp, native_window);
1076 surface = _eglCreateWindowSurfaceCommon(disp, config, native_window,
1083 _fixupNativePixmap(_EGLDisplay *disp, void *native_pixmap)
1093 if (disp && disp->Platform == _EGL_PLATFORM_X11 && native_pixmap != NULL)
1097 if (disp && disp->Platform == _EGL_PLATFORM_XCB && native_pixmap != NULL) {
1109 _eglCreatePixmapSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
1112 _EGLConfig *conf = _eglLookupConfig(config, disp);
1116 if (disp && (disp->Platform == _EGL_PLATFORM_SURFACELESS ||
1117 disp->Platform == _EGL_PLATFORM_DEVICE)) {
1128 RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_PIXMAP, EGL_NO_SURFACE);
1131 _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
1134 RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_NO_SURFACE);
1137 RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_PIXMAP, EGL_NO_SURFACE);
1139 if (_eglNativeSurfaceAlreadyUsed(disp, native_pixmap))
1140 RETURN_EGL_ERROR(disp, EGL_BAD_ALLOC, EGL_NO_SURFACE);
1142 surf = disp->Driver->CreatePixmapSurface(disp, conf, native_pixmap, attrib_list);
1145 RETURN_EGL_EVAL(disp, ret);
1153 _EGLDisplay *disp = _eglLockDisplay(dpy);
1155 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
1157 return _eglCreatePixmapSurfaceCommon(disp, config, (void*) pixmap,
1166 _EGLDisplay *disp = _eglLockDisplay(dpy);
1168 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
1169 native_pixmap = _fixupNativePixmap(disp, native_pixmap);
1170 return _eglCreatePixmapSurfaceCommon(disp, config, native_pixmap,
1180 _EGLDisplay *disp = _eglLockDisplay(dpy);
1184 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
1188 RETURN_EGL_ERROR(disp, EGL_BAD_ALLOC, EGL_NO_SURFACE);
1190 native_pixmap = _fixupNativePixmap(disp, native_pixmap);
1191 surface = _eglCreatePixmapSurfaceCommon(disp, config, native_pixmap,
1202 _EGLDisplay *disp = _eglLockDisplay(dpy);
1203 _EGLConfig *conf = _eglLookupConfig(config, disp);
1207 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
1208 _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
1211 RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_NO_SURFACE);
1213 surf = disp->Driver->CreatePbufferSurface(disp, conf, attrib_list);
1216 RETURN_EGL_EVAL(disp, ret);
1223 _EGLDisplay *disp = _eglLockDisplay(dpy);
1224 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1227 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1228 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
1230 ret = disp->Driver->DestroySurface(disp, surf);
1232 RETURN_EGL_EVAL(disp, ret);
1239 _EGLDisplay *disp = _eglLockDisplay(dpy);
1240 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1243 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1244 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
1246 if (disp->Driver->QuerySurface)
1247 ret = disp->Driver->QuerySurface(disp, surf, attribute, value);
1249 ret = _eglQuerySurface(disp, surf, attribute, value);
1251 RETURN_EGL_EVAL(disp, ret);
1258 _EGLDisplay *disp = _eglLockDisplay(dpy);
1259 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1262 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1263 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
1265 ret = _eglSurfaceAttrib(disp, surf, attribute, value);
1267 RETURN_EGL_EVAL(disp, ret);
1274 _EGLDisplay *disp = _eglLockDisplay(dpy);
1275 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1278 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1279 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
1280 ret = disp->Driver->BindTexImage(disp, surf, buffer);
1282 RETURN_EGL_EVAL(disp, ret);
1289 _EGLDisplay *disp = _eglLockDisplay(dpy);
1290 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1293 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1294 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
1295 ret = disp->Driver->ReleaseTexImage(disp, surf, buffer);
1297 RETURN_EGL_EVAL(disp, ret);
1304 _EGLDisplay *disp = _eglLockDisplay(dpy);
1309 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1310 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
1313 ctx->Resource.Display != disp)
1314 RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
1317 RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
1320 RETURN_EGL_EVAL(disp, EGL_TRUE);
1326 if (surf->SwapInterval != interval && disp->Driver->SwapInterval)
1327 ret = disp->Driver->SwapInterval(disp, surf, interval);
1334 RETURN_EGL_EVAL(disp, ret);
1342 _EGLDisplay *disp = _eglLockDisplay(dpy);
1343 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1346 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1347 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
1353 RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
1357 RETURN_EGL_EVAL(disp, EGL_TRUE);
1366 RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_FALSE);
1368 ret = disp->Driver->SwapBuffers(disp, surf);
1379 RETURN_EGL_EVAL(disp, ret);
1384 _eglSwapBuffersWithDamageCommon(_EGLDisplay *disp, _EGLSurface *surf,
1390 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
1395 RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
1398 RETURN_EGL_EVAL(disp, EGL_TRUE);
1401 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
1403 ret = disp->Driver->SwapBuffersWithDamageEXT(disp, surf, rects, n_rects);
1414 RETURN_EGL_EVAL(disp, ret);
1421 _EGLDisplay *disp = _eglLockDisplay(dpy);
1422 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1423 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1424 return _eglSwapBuffersWithDamageCommon(disp, surf, rects, n_rects);
1431 _EGLDisplay *disp = _eglLockDisplay(dpy);
1432 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1433 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1434 return _eglSwapBuffersWithDamageCommon(disp, surf, rects, n_rects);
1467 _EGLDisplay *disp = _eglLockDisplay(dpy);
1468 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1469 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1472 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
1478 RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_FALSE);
1486 RETURN_EGL_ERROR(disp, EGL_BAD_ACCESS, EGL_FALSE);
1489 ret = disp->Driver->SetDamageRegion(disp, surf, rects, n_rects);
1494 RETURN_EGL_EVAL(disp, ret);
1500 _EGLDisplay *disp = _eglLockDisplay(dpy);
1501 _EGLSurface *surf = _eglLookupSurface(surface, disp);
1505 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
1509 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
1511 RETURN_EGL_ERROR(disp, EGL_BAD_ACCESS, EGL_FALSE);
1512 ret = disp->Driver->CopyBuffers(disp, surf, native_pixmap_ptr);
1514 RETURN_EGL_EVAL(disp, ret);
1522 _EGLDisplay *disp;
1528 disp = ctx->Resource.Display;
1529 mtx_lock(&disp->Mutex);
1534 RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
1537 assert(disp->Initialized);
1538 ret = disp->Driver->WaitClient(disp, ctx);
1540 RETURN_EGL_EVAL(disp, ret);
1563 _EGLDisplay *disp;
1571 disp = ctx->Resource.Display;
1572 mtx_lock(&disp->Mutex);
1577 RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
1580 assert(disp->Initialized);
1581 ret = disp->Driver->WaitNative(engine);
1583 RETURN_EGL_EVAL(disp, ret);
1707 _EGLDisplay *disp = _eglLockDisplay(dpy);
1708 _EGLConfig *conf = _eglLookupConfig(config, disp);
1710 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
1712 _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
1715 RETURN_EGL_ERROR(disp, EGL_BAD_ALLOC, EGL_NO_SURFACE);
1729 _EGLDisplay *disp = ctx->Resource.Display;
1731 mtx_lock(&disp->Mutex);
1732 (void) disp->Driver->MakeCurrent(disp, NULL, NULL, NULL);
1733 mtx_unlock(&disp->Mutex);
1743 _eglCreateImageCommon(_EGLDisplay *disp, EGLContext ctx, EGLenum target,
1746 _EGLContext *context = _eglLookupContext(ctx, disp);
1750 _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR);
1751 if (!disp->Extensions.KHR_image_base)
1752 RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
1754 RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
1759 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
1761 img = disp->Driver->CreateImageKHR(disp, context, target, buffer, attr_list);
1764 RETURN_EGL_EVAL(disp, ret);
1771 _EGLDisplay *disp = _eglLockDisplay(dpy);
1772 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_IMAGE_KHR);
1773 return _eglCreateImageCommon(disp, ctx, target, buffer, attr_list);
1781 _EGLDisplay *disp = _eglLockDisplay(dpy);
1785 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_IMAGE_KHR);
1789 RETURN_EGL_ERROR(disp, EGL_BAD_ALLOC, EGL_NO_IMAGE);
1791 image = _eglCreateImageCommon(disp, ctx, target, buffer, int_attribs);
1798 _eglDestroyImageCommon(_EGLDisplay *disp, _EGLImage *img)
1802 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
1803 if (!disp->Extensions.KHR_image_base)
1804 RETURN_EGL_EVAL(disp, EGL_FALSE);
1806 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
1809 ret = disp->Driver->DestroyImageKHR(disp, img);
1811 RETURN_EGL_EVAL(disp, ret);
1817 _EGLDisplay *disp = _eglLockDisplay(dpy);
1818 _EGLImage *img = _eglLookupImage(image, disp);
1819 _EGL_FUNC_START(disp, EGL_OBJECT_IMAGE_KHR, img, EGL_FALSE);
1820 return _eglDestroyImageCommon(disp, img);
1826 _EGLDisplay *disp = _eglLockDisplay(dpy);
1827 _EGLImage *img = _eglLookupImage(image, disp);
1828 _EGL_FUNC_START(disp, EGL_OBJECT_IMAGE_KHR, img, EGL_FALSE);
1829 return _eglDestroyImageCommon(disp, img);
1834 _eglCreateSync(_EGLDisplay *disp, EGLenum type, const EGLAttrib *attrib_list,
1842 _EGL_CHECK_DISPLAY(disp, EGL_NO_SYNC_KHR);
1844 if (!disp->Extensions.KHR_cl_event2 && orig_is_EGLAttrib) {
1854 RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_NO_SYNC_KHR);
1863 RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_NO_SYNC_KHR);
1866 if (ctx && (ctx->Resource.Display != disp ||
1869 RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_NO_SYNC_KHR);
1873 if (!disp->Extensions.KHR_fence_sync)
1874 RETURN_EGL_ERROR(disp, invalid_type_error, EGL_NO_SYNC_KHR);
1877 if (!disp->Extensions.KHR_reusable_sync)
1878 RETURN_EGL_ERROR(disp, invalid_type_error, EGL_NO_SYNC_KHR);
1881 if (!disp->Extensions.KHR_cl_event2)
1882 RETURN_EGL_ERROR(disp, invalid_type_error, EGL_NO_SYNC_KHR);
1885 if (!disp->Extensions.ANDROID_native_fence_sync)
1886 RETURN_EGL_ERROR(disp, invalid_type_error, EGL_NO_SYNC_KHR);
1889 RETURN_EGL_ERROR(disp, invalid_type_error, EGL_NO_SYNC_KHR);
1892 sync = disp->Driver->CreateSyncKHR(disp, type, attrib_list);
1895 RETURN_EGL_EVAL(disp, ret);
1902 _EGLDisplay *disp = _eglLockDisplay(dpy);
1903 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, NULL);
1914 RETURN_EGL_ERROR(disp, err, EGL_NO_SYNC);
1917 sync = _eglCreateSync(disp, type, attrib_list, EGL_FALSE,
1931 _EGLDisplay *disp = _eglLockDisplay(dpy);
1932 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, NULL);
1933 return _eglCreateSync(disp, type, attrib_list, EGL_TRUE,
1941 _EGLDisplay *disp = _eglLockDisplay(dpy);
1942 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, NULL);
1943 return _eglCreateSync(disp, type, attrib_list, EGL_TRUE,
1949 _eglDestroySync(_EGLDisplay *disp, _EGLSync *s)
1953 _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
1954 assert(disp->Extensions.KHR_reusable_sync ||
1955 disp->Extensions.KHR_fence_sync ||
1956 disp->Extensions.ANDROID_native_fence_sync);
1959 ret = disp->Driver->DestroySyncKHR(disp, s);
1961 RETURN_EGL_EVAL(disp, ret);
1967 _EGLDisplay *disp = _eglLockDisplay(dpy);
1968 _EGLSync *s = _eglLookupSync(sync, disp);
1969 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
1970 return _eglDestroySync(disp, s);
1976 _EGLDisplay *disp = _eglLockDisplay(dpy);
1977 _EGLSync *s = _eglLookupSync(sync, disp);
1978 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
1979 return _eglDestroySync(disp, s);
1984 _eglClientWaitSyncCommon(_EGLDisplay *disp, EGLDisplay dpy,
1989 _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
1990 assert(disp->Extensions.KHR_reusable_sync ||
1991 disp->Extensions.KHR_fence_sync ||
1992 disp->Extensions.ANDROID_native_fence_sync);
1995 RETURN_EGL_EVAL(disp, EGL_CONDITION_SATISFIED_KHR);
2005 ret = disp->Driver->ClientWaitSyncKHR(disp, s, flags, timeout);
2008 * 'disp' is already unlocked for reusable sync type,
2014 RETURN_EGL_EVAL(disp, ret);
2021 _EGLDisplay *disp = _eglLockDisplay(dpy);
2022 _EGLSync *s = _eglLookupSync(sync, disp);
2023 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
2024 return _eglClientWaitSyncCommon(disp, dpy, s, flags, timeout);
2031 _EGLDisplay *disp = _eglLockDisplay(dpy);
2032 _EGLSync *s = _eglLookupSync(sync, disp);
2033 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
2034 return _eglClientWaitSyncCommon(disp, dpy, s, flags, timeout);
2039 _eglWaitSyncCommon(_EGLDisplay *disp, _EGLSync *s, EGLint flags)
2044 _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
2045 assert(disp->Extensions.KHR_wait_sync);
2051 RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_FALSE);
2055 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2057 ret = disp->Driver->WaitSyncKHR(disp, s);
2059 RETURN_EGL_EVAL(disp, ret);
2065 _EGLDisplay *disp = _eglLockDisplay(dpy);
2066 _EGLSync *s = _eglLookupSync(sync, disp);
2067 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
2068 return _eglWaitSyncCommon(disp, s, flags);
2079 _EGLDisplay *disp = _eglLockDisplay(dpy);
2080 _EGLSync *s = _eglLookupSync(sync, disp);
2081 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
2082 return _eglWaitSyncCommon(disp, s, flags);
2089 _EGLDisplay *disp = _eglLockDisplay(dpy);
2090 _EGLSync *s = _eglLookupSync(sync, disp);
2093 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
2095 _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
2096 assert(disp->Extensions.KHR_reusable_sync);
2097 ret = disp->Driver->SignalSyncKHR(disp, s, mode);
2099 RETURN_EGL_EVAL(disp, ret);
2104 _eglGetSyncAttribCommon(_EGLDisplay *disp, _EGLSync *s, EGLint attribute, EGLAttrib *value)
2108 _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
2109 assert(disp->Extensions.KHR_reusable_sync ||
2110 disp->Extensions.KHR_fence_sync ||
2111 disp->Extensions.ANDROID_native_fence_sync);
2113 ret = _eglGetSyncAttrib(disp, s, attribute, value);
2115 RETURN_EGL_EVAL(disp, ret);
2121 _EGLDisplay *disp = _eglLockDisplay(dpy);
2122 _EGLSync *s = _eglLookupSync(sync, disp);
2123 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
2126 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2128 return _eglGetSyncAttribCommon(disp, s, attribute, value);
2135 _EGLDisplay *disp = _eglLockDisplay(dpy);
2136 _EGLSync *s = _eglLookupSync(sync, disp);
2140 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
2143 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2146 result = _eglGetSyncAttribCommon(disp, s, attribute, &attrib);
2162 _EGLDisplay *disp = _eglLockDisplay(dpy);
2163 _EGLSync *s = _eglLookupSync(sync, disp);
2166 _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
2173 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_NO_NATIVE_FENCE_FD_ANDROID);
2175 _EGL_CHECK_SYNC(disp, s, EGL_NO_NATIVE_FENCE_FD_ANDROID);
2176 assert(disp->Extensions.ANDROID_native_fence_sync);
2177 ret = disp->Driver->DupNativeFenceFDANDROID(disp, s);
2179 RETURN_EGL_SUCCESS(disp, ret);
2187 _EGLDisplay *disp = _eglLockDisplay(dpy);
2188 _EGLSurface *surf = _eglLookupSurface(surface, disp);
2191 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
2193 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
2195 if (!disp->Extensions.NOK_swap_region)
2196 RETURN_EGL_EVAL(disp, EGL_FALSE);
2201 RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
2203 ret = disp->Driver->SwapBuffersRegionNOK(disp, surf, numRects, rects);
2205 RETURN_EGL_EVAL(disp, ret);
2212 _EGLDisplay *disp = _eglLockDisplay(dpy);
2216 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, NULL);
2218 _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR);
2219 if (!disp->Extensions.MESA_drm_image)
2220 RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
2222 img = disp->Driver->CreateDRMImageMESA(disp, attr_list);
2225 RETURN_EGL_EVAL(disp, ret);
2232 _EGLDisplay *disp = _eglLockDisplay(dpy);
2233 _EGLImage *img = _eglLookupImage(image, disp);
2236 _EGL_FUNC_START(disp, EGL_OBJECT_IMAGE_KHR, img, EGL_FALSE);
2238 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
2239 assert(disp->Extensions.MESA_drm_image);
2242 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2244 ret = disp->Driver->ExportDRMImageMESA(disp, img, name, handle, stride);
2246 RETURN_EGL_EVAL(disp, ret);
2255 _EGLDisplay *disp = _eglLockDisplay(dpy);
2258 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
2260 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
2261 assert(disp->Extensions.WL_bind_wayland_display);
2264 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2266 ret = disp->Driver->BindWaylandDisplayWL(disp, display);
2268 RETURN_EGL_EVAL(disp, ret);
2274 _EGLDisplay *disp = _eglLockDisplay(dpy);
2277 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
2279 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
2280 assert(disp->Extensions.WL_bind_wayland_display);
2283 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2285 ret = disp->Driver->UnbindWaylandDisplayWL(disp, display);
2287 RETURN_EGL_EVAL(disp, ret);
2294 _EGLDisplay *disp = _eglLockDisplay(dpy);
2297 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
2299 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
2300 assert(disp->Extensions.WL_bind_wayland_display);
2303 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2305 ret = disp->Driver->QueryWaylandBufferWL(disp, buffer, attribute, value);
2307 RETURN_EGL_EVAL(disp, ret);
2314 _EGLDisplay *disp = _eglLockDisplay(dpy);
2318 _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, NULL);
2320 _EGL_CHECK_DISPLAY(disp, NULL);
2321 if (!disp->Extensions.WL_create_wayland_buffer_from_image)
2322 RETURN_EGL_EVAL(disp, NULL);
2324 img = _eglLookupImage(image, disp);
2327 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, NULL);
2329 ret = disp->Driver->CreateWaylandBufferFromImageWL(disp, img);
2331 RETURN_EGL_EVAL(disp, ret);
2338 _EGLDisplay *disp = _eglLockDisplay(dpy);
2339 _EGLSurface *surf = _eglLookupSurface(surface, disp);
2342 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
2344 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
2346 if (!disp->Extensions.NV_post_sub_buffer)
2347 RETURN_EGL_EVAL(disp, EGL_FALSE);
2349 ret = disp->Driver->PostSubBufferNV(disp, surf, x, y, width, height);
2351 RETURN_EGL_EVAL(disp, ret);
2359 _EGLDisplay *disp = _eglLockDisplay(dpy);
2360 _EGLSurface *surf = _eglLookupSurface(surface, disp);
2363 _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
2365 _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
2366 if (!disp->Extensions.CHROMIUM_sync_control)
2367 RETURN_EGL_EVAL(disp, EGL_FALSE);
2370 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2372 ret = disp->Driver->GetSyncValuesCHROMIUM(disp, surf, ust, msc, sbc);
2374 RETURN_EGL_EVAL(disp, ret);
2382 _EGLDisplay *disp = _eglLockDisplay(dpy);
2383 _EGLImage *img = _eglLookupImage(image, disp);
2386 _EGL_FUNC_START(disp, EGL_OBJECT_IMAGE_KHR, img, EGL_FALSE);
2388 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
2389 assert(disp->Extensions.MESA_image_dma_buf_export);
2392 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2394 ret = disp->Driver->ExportDMABUFImageQueryMESA(disp, img, fourcc, nplanes, modifiers);
2396 RETURN_EGL_EVAL(disp, ret);
2403 _EGLDisplay *disp = _eglLockDisplay(dpy);
2404 _EGLImage *img = _eglLookupImage(image, disp);
2407 _EGL_FUNC_START(disp, EGL_OBJECT_IMAGE_KHR, img, EGL_FALSE);
2409 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
2410 assert(disp->Extensions.MESA_image_dma_buf_export);
2413 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
2415 ret = disp->Driver->ExportDMABUFImageMESA(disp, img, fds, strides, offsets);
2417 RETURN_EGL_EVAL(disp, ret);
2424 _EGLDisplay *disp = NULL;
2436 disp = _eglLockDisplay(dpy);
2437 if (disp == NULL)
2438 RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_BAD_DISPLAY);
2442 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_BAD_PARAMETER);
2444 disp->Label = label;
2445 RETURN_EGL_EVAL(disp, EGL_SUCCESS);
2463 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_BAD_PARAMETER);
2466 if (_eglCheckResource(object, type, disp)) {
2470 RETURN_EGL_EVAL(disp, EGL_SUCCESS);
2473 RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_BAD_PARAMETER);
2567 _EGLDisplay *disp = _eglLockDisplay(dpy);
2572 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
2574 ret = disp->Driver->QueryDmaBufFormatsEXT(disp, max_formats, formats, num_formats);
2576 RETURN_EGL_EVAL(disp, ret);
2584 _EGLDisplay *disp = _eglLockDisplay(dpy);
2589 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
2591 ret = disp->Driver->QueryDmaBufModifiersEXT(disp, format, max_modifiers, modifiers,
2594 RETURN_EGL_EVAL(disp, ret);
2604 _EGLDisplay *disp = _eglLockDisplay(dpy);
2605 if (!_eglSetFuncName(__func__, disp, EGL_OBJECT_DISPLAY_KHR, NULL)) {
2606 if (disp)
2607 _eglUnlockDisplay(disp);
2611 if (!_eglCheckDisplay(disp, __func__)) {
2612 if (disp)
2613 _eglUnlockDisplay(disp);
2620 _eglUnlockDisplay(disp);
2624 if (disp->BlobCacheSet) {
2627 _eglUnlockDisplay(disp);
2631 disp->BlobCacheSet = set;
2632 disp->BlobCacheGet = get;
2634 disp->Driver->SetBlobCacheFuncsANDROID(disp, set, get);
2636 _eglUnlockDisplay(disp);
2686 _EGLDisplay *disp = _eglLockDisplay(dpy);
2689 _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
2693 *value = (EGLAttrib) disp->Device;
2696 RETURN_EGL_ERROR(disp, EGL_BAD_ATTRIBUTE, EGL_FALSE);
2698 RETURN_EGL_SUCCESS(disp, EGL_TRUE);
2704 _EGLDisplay *disp = _eglLockDisplay(dpy);
2707 _EGL_FUNC_START(disp, EGL_NONE, NULL, NULL);
2708 _EGL_CHECK_DISPLAY(disp, NULL);
2710 assert(disp->Extensions.MESA_query_driver);
2712 ret = disp->Driver->QueryDriverConfig(disp);
2713 RETURN_EGL_EVAL(disp, ret);
2719 _EGLDisplay *disp = _eglLockDisplay(dpy);
2722 _EGL_FUNC_START(disp, EGL_NONE, NULL, NULL);
2723 _EGL_CHECK_DISPLAY(disp, NULL);
2725 assert(disp->Extensions.MESA_query_driver);
2727 ret = disp->Driver->QueryDriverName(disp);
2728 RETURN_EGL_EVAL(disp, ret);
2764 _EGLDisplay **disp, _EGLContext **ctx)
2767 *disp = _eglLockDisplay(dpy);
2768 if (!*disp || !(*disp)->Initialized || !(*disp)->Driver) {
2769 if (*disp)
2770 _eglUnlockDisplay(*disp);
2774 *ctx = _eglLookupContext(context, *disp);
2778 _eglUnlockDisplay(*disp);
2789 _EGLDisplay *disp;
2793 ret = _eglLockDisplayInterop(dpy, context, &disp, &ctx);
2797 if (disp->Driver->GLInteropQueryDeviceInfo)
2798 ret = disp->Driver->GLInteropQueryDeviceInfo(disp, ctx, out);
2802 _eglUnlockDisplay(disp);
2811 _EGLDisplay *disp;
2815 ret = _eglLockDisplayInterop(dpy, context, &disp, &ctx);
2819 if (disp->Driver->GLInteropExportObject)
2820 ret = disp->Driver->GLInteropExportObject(disp, ctx, in, out);
2824 _eglUnlockDisplay(disp);