entry_points_egl_autogen.cpp (31778B)
1 // GENERATED FILE - DO NOT EDIT. 2 // Generated by generate_entry_points.py using data from egl.xml. 3 // 4 // Copyright 2020 The ANGLE Project Authors. All rights reserved. 5 // Use of this source code is governed by a BSD-style license that can be 6 // found in the LICENSE file. 7 // 8 // entry_points_egl_autogen.cpp: 9 // Defines the EGL entry points. 10 11 #include "libGLESv2/entry_points_egl_autogen.h" 12 13 #include "libANGLE/entry_points_utils.h" 14 #include "libANGLE/validationEGL_autogen.h" 15 #include "libGLESv2/egl_ext_stubs_autogen.h" 16 #include "libGLESv2/egl_stubs_autogen.h" 17 #include "libGLESv2/global_state.h" 18 19 using namespace egl; 20 21 extern "C" { 22 23 // EGL 1.0 24 EGLBoolean EGLAPIENTRY EGL_ChooseConfig(EGLDisplay dpy, 25 const EGLint *attrib_list, 26 EGLConfig *configs, 27 EGLint config_size, 28 EGLint *num_config) 29 { 30 31 ANGLE_SCOPED_GLOBAL_LOCK(); 32 EGL_EVENT(ChooseConfig, 33 "dpy = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR ", configs = 0x%016" PRIxPTR 34 ", config_size = %d, num_config = 0x%016" PRIxPTR "", 35 (uintptr_t)dpy, (uintptr_t)attrib_list, (uintptr_t)configs, config_size, 36 (uintptr_t)num_config); 37 38 Thread *thread = egl::GetCurrentThread(); 39 40 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 41 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 42 43 ANGLE_EGL_VALIDATE(thread, ChooseConfig, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 44 attrib_listPacked, configs, config_size, num_config); 45 46 return ChooseConfig(thread, dpyPacked, attrib_listPacked, configs, config_size, num_config); 47 } 48 49 EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy, 50 EGLSurface surface, 51 EGLNativePixmapType target) 52 { 53 54 ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); 55 ANGLE_SCOPED_GLOBAL_LOCK(); 56 EGL_EVENT(CopyBuffers, 57 "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", target = 0x%016" PRIxPTR "", 58 (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)target); 59 60 Thread *thread = egl::GetCurrentThread(); 61 62 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 63 Surface *surfacePacked = PackParam<Surface *>(surface); 64 65 ANGLE_EGL_VALIDATE(thread, CopyBuffers, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 66 surfacePacked, target); 67 68 return CopyBuffers(thread, dpyPacked, surfacePacked, target); 69 } 70 71 EGLContext EGLAPIENTRY EGL_CreateContext(EGLDisplay dpy, 72 EGLConfig config, 73 EGLContext share_context, 74 const EGLint *attrib_list) 75 { 76 77 ANGLE_SCOPED_GLOBAL_LOCK(); 78 EGL_EVENT(CreateContext, 79 "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", share_context = 0x%016" PRIxPTR 80 ", attrib_list = 0x%016" PRIxPTR "", 81 (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)share_context, (uintptr_t)attrib_list); 82 83 Thread *thread = egl::GetCurrentThread(); 84 85 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 86 Config *configPacked = PackParam<Config *>(config); 87 gl::Context *share_contextPacked = PackParam<gl::Context *>(share_context); 88 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 89 90 ANGLE_EGL_VALIDATE(thread, CreateContext, GetDisplayIfValid(dpyPacked), EGLContext, dpyPacked, 91 configPacked, share_contextPacked, attrib_listPacked); 92 93 return CreateContext(thread, dpyPacked, configPacked, share_contextPacked, attrib_listPacked); 94 } 95 96 EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy, 97 EGLConfig config, 98 const EGLint *attrib_list) 99 { 100 101 ANGLE_SCOPED_GLOBAL_LOCK(); 102 EGL_EVENT(CreatePbufferSurface, 103 "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR 104 "", 105 (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)attrib_list); 106 107 Thread *thread = egl::GetCurrentThread(); 108 109 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 110 Config *configPacked = PackParam<Config *>(config); 111 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 112 113 ANGLE_EGL_VALIDATE(thread, CreatePbufferSurface, GetDisplayIfValid(dpyPacked), EGLSurface, 114 dpyPacked, configPacked, attrib_listPacked); 115 116 return CreatePbufferSurface(thread, dpyPacked, configPacked, attrib_listPacked); 117 } 118 119 EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy, 120 EGLConfig config, 121 EGLNativePixmapType pixmap, 122 const EGLint *attrib_list) 123 { 124 125 ANGLE_SCOPED_GLOBAL_LOCK(); 126 EGL_EVENT(CreatePixmapSurface, 127 "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", pixmap = 0x%016" PRIxPTR 128 ", attrib_list = 0x%016" PRIxPTR "", 129 (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)pixmap, (uintptr_t)attrib_list); 130 131 Thread *thread = egl::GetCurrentThread(); 132 133 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 134 Config *configPacked = PackParam<Config *>(config); 135 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 136 137 ANGLE_EGL_VALIDATE(thread, CreatePixmapSurface, GetDisplayIfValid(dpyPacked), EGLSurface, 138 dpyPacked, configPacked, pixmap, attrib_listPacked); 139 140 return CreatePixmapSurface(thread, dpyPacked, configPacked, pixmap, attrib_listPacked); 141 } 142 143 EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy, 144 EGLConfig config, 145 EGLNativeWindowType win, 146 const EGLint *attrib_list) 147 { 148 149 ANGLE_SCOPED_GLOBAL_LOCK(); 150 EGL_EVENT(CreateWindowSurface, 151 "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", win = 0x%016" PRIxPTR 152 ", attrib_list = 0x%016" PRIxPTR "", 153 (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)win, (uintptr_t)attrib_list); 154 155 Thread *thread = egl::GetCurrentThread(); 156 157 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 158 Config *configPacked = PackParam<Config *>(config); 159 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 160 161 ANGLE_EGL_VALIDATE(thread, CreateWindowSurface, GetDisplayIfValid(dpyPacked), EGLSurface, 162 dpyPacked, configPacked, win, attrib_listPacked); 163 164 return CreateWindowSurface(thread, dpyPacked, configPacked, win, attrib_listPacked); 165 } 166 167 EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx) 168 { 169 170 ANGLE_SCOPED_GLOBAL_LOCK(); 171 EGL_EVENT(DestroyContext, "dpy = 0x%016" PRIxPTR ", ctx = 0x%016" PRIxPTR "", (uintptr_t)dpy, 172 (uintptr_t)ctx); 173 174 Thread *thread = egl::GetCurrentThread(); 175 176 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 177 gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); 178 179 ANGLE_EGL_VALIDATE(thread, DestroyContext, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 180 ctxPacked); 181 182 return DestroyContext(thread, dpyPacked, ctxPacked); 183 } 184 185 EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface) 186 { 187 188 ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); 189 ANGLE_SCOPED_GLOBAL_LOCK(); 190 EGL_EVENT(DestroySurface, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR "", 191 (uintptr_t)dpy, (uintptr_t)surface); 192 193 Thread *thread = egl::GetCurrentThread(); 194 195 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 196 Surface *surfacePacked = PackParam<Surface *>(surface); 197 198 ANGLE_EGL_VALIDATE(thread, DestroySurface, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 199 surfacePacked); 200 201 return DestroySurface(thread, dpyPacked, surfacePacked); 202 } 203 204 EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy, 205 EGLConfig config, 206 EGLint attribute, 207 EGLint *value) 208 { 209 210 ANGLE_SCOPED_GLOBAL_LOCK(); 211 EGL_EVENT(GetConfigAttrib, 212 "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR 213 ", attribute = %d, value = 0x%016" PRIxPTR "", 214 (uintptr_t)dpy, (uintptr_t)config, attribute, (uintptr_t)value); 215 216 Thread *thread = egl::GetCurrentThread(); 217 218 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 219 Config *configPacked = PackParam<Config *>(config); 220 221 ANGLE_EGL_VALIDATE(thread, GetConfigAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 222 configPacked, attribute, value); 223 224 return GetConfigAttrib(thread, dpyPacked, configPacked, attribute, value); 225 } 226 227 EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy, 228 EGLConfig *configs, 229 EGLint config_size, 230 EGLint *num_config) 231 { 232 233 ANGLE_SCOPED_GLOBAL_LOCK(); 234 EGL_EVENT(GetConfigs, 235 "dpy = 0x%016" PRIxPTR ", configs = 0x%016" PRIxPTR 236 ", config_size = %d, num_config = 0x%016" PRIxPTR "", 237 (uintptr_t)dpy, (uintptr_t)configs, config_size, (uintptr_t)num_config); 238 239 Thread *thread = egl::GetCurrentThread(); 240 241 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 242 243 ANGLE_EGL_VALIDATE(thread, GetConfigs, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 244 configs, config_size, num_config); 245 246 return GetConfigs(thread, dpyPacked, configs, config_size, num_config); 247 } 248 249 EGLDisplay EGLAPIENTRY EGL_GetCurrentDisplay() 250 { 251 252 ANGLE_SCOPED_GLOBAL_LOCK(); 253 EGL_EVENT(GetCurrentDisplay, ""); 254 255 Thread *thread = egl::GetCurrentThread(); 256 257 ANGLE_EGL_VALIDATE(thread, GetCurrentDisplay, nullptr, EGLDisplay); 258 259 return GetCurrentDisplay(thread); 260 } 261 262 EGLSurface EGLAPIENTRY EGL_GetCurrentSurface(EGLint readdraw) 263 { 264 265 ANGLE_SCOPED_GLOBAL_LOCK(); 266 EGL_EVENT(GetCurrentSurface, "readdraw = %d", readdraw); 267 268 Thread *thread = egl::GetCurrentThread(); 269 270 ANGLE_EGL_VALIDATE(thread, GetCurrentSurface, nullptr, EGLSurface, readdraw); 271 272 return GetCurrentSurface(thread, readdraw); 273 } 274 275 EGLDisplay EGLAPIENTRY EGL_GetDisplay(EGLNativeDisplayType display_id) 276 { 277 278 ANGLE_SCOPED_GLOBAL_LOCK(); 279 EGL_EVENT(GetDisplay, "display_id = 0x%016" PRIxPTR "", (uintptr_t)display_id); 280 281 Thread *thread = egl::GetCurrentThread(); 282 283 ANGLE_EGL_VALIDATE(thread, GetDisplay, nullptr, EGLDisplay, display_id); 284 285 return GetDisplay(thread, display_id); 286 } 287 288 EGLint EGLAPIENTRY EGL_GetError() 289 { 290 291 ANGLE_SCOPED_GLOBAL_LOCK(); 292 EGL_EVENT(GetError, ""); 293 294 Thread *thread = egl::GetCurrentThread(); 295 296 ANGLE_EGL_VALIDATE(thread, GetError, nullptr, EGLint); 297 298 return GetError(thread); 299 } 300 301 __eglMustCastToProperFunctionPointerType EGLAPIENTRY EGL_GetProcAddress(const char *procname) 302 { 303 304 ANGLE_SCOPED_GLOBAL_LOCK(); 305 EGL_EVENT(GetProcAddress, "procname = 0x%016" PRIxPTR "", (uintptr_t)procname); 306 307 Thread *thread = egl::GetCurrentThread(); 308 309 ANGLE_EGL_VALIDATE(thread, GetProcAddress, nullptr, __eglMustCastToProperFunctionPointerType, 310 procname); 311 312 return GetProcAddress(thread, procname); 313 } 314 315 EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor) 316 { 317 318 ANGLE_SCOPED_GLOBAL_LOCK(); 319 EGL_EVENT(Initialize, 320 "dpy = 0x%016" PRIxPTR ", major = 0x%016" PRIxPTR ", minor = 0x%016" PRIxPTR "", 321 (uintptr_t)dpy, (uintptr_t)major, (uintptr_t)minor); 322 323 Thread *thread = egl::GetCurrentThread(); 324 325 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 326 327 ANGLE_EGL_VALIDATE(thread, Initialize, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 328 major, minor); 329 330 return Initialize(thread, dpyPacked, major, minor); 331 } 332 333 EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy, 334 EGLSurface draw, 335 EGLSurface read, 336 EGLContext ctx) 337 { 338 339 ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); 340 ANGLE_SCOPED_GLOBAL_LOCK(); 341 EGL_EVENT(MakeCurrent, 342 "dpy = 0x%016" PRIxPTR ", draw = 0x%016" PRIxPTR ", read = 0x%016" PRIxPTR 343 ", ctx = 0x%016" PRIxPTR "", 344 (uintptr_t)dpy, (uintptr_t)draw, (uintptr_t)read, (uintptr_t)ctx); 345 346 Thread *thread = egl::GetCurrentThread(); 347 348 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 349 Surface *drawPacked = PackParam<Surface *>(draw); 350 Surface *readPacked = PackParam<Surface *>(read); 351 gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); 352 353 ANGLE_EGL_VALIDATE(thread, MakeCurrent, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 354 drawPacked, readPacked, ctxPacked); 355 356 return MakeCurrent(thread, dpyPacked, drawPacked, readPacked, ctxPacked); 357 } 358 359 EGLBoolean EGLAPIENTRY EGL_QueryContext(EGLDisplay dpy, 360 EGLContext ctx, 361 EGLint attribute, 362 EGLint *value) 363 { 364 365 ANGLE_SCOPED_GLOBAL_LOCK(); 366 EGL_EVENT(QueryContext, 367 "dpy = 0x%016" PRIxPTR ", ctx = 0x%016" PRIxPTR 368 ", attribute = %d, value = 0x%016" PRIxPTR "", 369 (uintptr_t)dpy, (uintptr_t)ctx, attribute, (uintptr_t)value); 370 371 Thread *thread = egl::GetCurrentThread(); 372 373 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 374 gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); 375 376 ANGLE_EGL_VALIDATE(thread, QueryContext, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 377 ctxPacked, attribute, value); 378 379 return QueryContext(thread, dpyPacked, ctxPacked, attribute, value); 380 } 381 382 const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name) 383 { 384 385 ANGLE_SCOPED_GLOBAL_LOCK(); 386 EGL_EVENT(QueryString, "dpy = 0x%016" PRIxPTR ", name = %d", (uintptr_t)dpy, name); 387 388 Thread *thread = egl::GetCurrentThread(); 389 390 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 391 392 ANGLE_EGL_VALIDATE(thread, QueryString, GetDisplayIfValid(dpyPacked), const char *, dpyPacked, 393 name); 394 395 return QueryString(thread, dpyPacked, name); 396 } 397 398 EGLBoolean EGLAPIENTRY EGL_QuerySurface(EGLDisplay dpy, 399 EGLSurface surface, 400 EGLint attribute, 401 EGLint *value) 402 { 403 404 ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); 405 ANGLE_SCOPED_GLOBAL_LOCK(); 406 EGL_EVENT(QuerySurface, 407 "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR 408 ", attribute = %d, value = 0x%016" PRIxPTR "", 409 (uintptr_t)dpy, (uintptr_t)surface, attribute, (uintptr_t)value); 410 411 Thread *thread = egl::GetCurrentThread(); 412 413 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 414 Surface *surfacePacked = PackParam<Surface *>(surface); 415 416 ANGLE_EGL_VALIDATE(thread, QuerySurface, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 417 surfacePacked, attribute, value); 418 419 return QuerySurface(thread, dpyPacked, surfacePacked, attribute, value); 420 } 421 422 EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface) 423 { 424 ANGLE_EGLBOOLEAN_TRY(PrepareSwapBuffersANGLE(dpy, surface)); 425 ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); 426 ANGLE_SCOPED_GLOBAL_LOCK(); 427 EGL_EVENT(SwapBuffers, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR "", (uintptr_t)dpy, 428 (uintptr_t)surface); 429 430 Thread *thread = egl::GetCurrentThread(); 431 432 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 433 Surface *surfacePacked = PackParam<Surface *>(surface); 434 435 ANGLE_EGL_VALIDATE(thread, SwapBuffers, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 436 surfacePacked); 437 438 return SwapBuffers(thread, dpyPacked, surfacePacked); 439 } 440 441 EGLBoolean EGLAPIENTRY EGL_Terminate(EGLDisplay dpy) 442 { 443 444 ANGLE_SCOPED_GLOBAL_LOCK(); 445 EGL_EVENT(Terminate, "dpy = 0x%016" PRIxPTR "", (uintptr_t)dpy); 446 447 Thread *thread = egl::GetCurrentThread(); 448 449 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 450 451 ANGLE_EGL_VALIDATE(thread, Terminate, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked); 452 453 return Terminate(thread, dpyPacked); 454 } 455 456 EGLBoolean EGLAPIENTRY EGL_WaitGL() 457 { 458 459 ANGLE_SCOPED_GLOBAL_LOCK(); 460 EGL_EVENT(WaitGL, ""); 461 462 Thread *thread = egl::GetCurrentThread(); 463 464 ANGLE_EGL_VALIDATE(thread, WaitGL, nullptr, EGLBoolean); 465 466 return WaitGL(thread); 467 } 468 469 EGLBoolean EGLAPIENTRY EGL_WaitNative(EGLint engine) 470 { 471 472 ANGLE_SCOPED_GLOBAL_LOCK(); 473 EGL_EVENT(WaitNative, "engine = %d", engine); 474 475 Thread *thread = egl::GetCurrentThread(); 476 477 ANGLE_EGL_VALIDATE(thread, WaitNative, nullptr, EGLBoolean, engine); 478 479 return WaitNative(thread, engine); 480 } 481 482 // EGL 1.1 483 EGLBoolean EGLAPIENTRY EGL_BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) 484 { 485 486 ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); 487 ANGLE_SCOPED_GLOBAL_LOCK(); 488 EGL_EVENT(BindTexImage, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", buffer = %d", 489 (uintptr_t)dpy, (uintptr_t)surface, buffer); 490 491 Thread *thread = egl::GetCurrentThread(); 492 493 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 494 Surface *surfacePacked = PackParam<Surface *>(surface); 495 496 ANGLE_EGL_VALIDATE(thread, BindTexImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 497 surfacePacked, buffer); 498 499 return BindTexImage(thread, dpyPacked, surfacePacked, buffer); 500 } 501 502 EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) 503 { 504 505 ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); 506 ANGLE_SCOPED_GLOBAL_LOCK(); 507 EGL_EVENT(ReleaseTexImage, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", buffer = %d", 508 (uintptr_t)dpy, (uintptr_t)surface, buffer); 509 510 Thread *thread = egl::GetCurrentThread(); 511 512 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 513 Surface *surfacePacked = PackParam<Surface *>(surface); 514 515 ANGLE_EGL_VALIDATE(thread, ReleaseTexImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 516 surfacePacked, buffer); 517 518 return ReleaseTexImage(thread, dpyPacked, surfacePacked, buffer); 519 } 520 521 EGLBoolean EGLAPIENTRY EGL_SurfaceAttrib(EGLDisplay dpy, 522 EGLSurface surface, 523 EGLint attribute, 524 EGLint value) 525 { 526 527 ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); 528 ANGLE_SCOPED_GLOBAL_LOCK(); 529 EGL_EVENT(SurfaceAttrib, 530 "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", attribute = %d, value = %d", 531 (uintptr_t)dpy, (uintptr_t)surface, attribute, value); 532 533 Thread *thread = egl::GetCurrentThread(); 534 535 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 536 Surface *surfacePacked = PackParam<Surface *>(surface); 537 538 ANGLE_EGL_VALIDATE(thread, SurfaceAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 539 surfacePacked, attribute, value); 540 541 return SurfaceAttrib(thread, dpyPacked, surfacePacked, attribute, value); 542 } 543 544 EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval) 545 { 546 547 ANGLE_SCOPED_GLOBAL_LOCK(); 548 EGL_EVENT(SwapInterval, "dpy = 0x%016" PRIxPTR ", interval = %d", (uintptr_t)dpy, interval); 549 550 Thread *thread = egl::GetCurrentThread(); 551 552 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 553 554 ANGLE_EGL_VALIDATE(thread, SwapInterval, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 555 interval); 556 557 return SwapInterval(thread, dpyPacked, interval); 558 } 559 560 // EGL 1.2 561 EGLBoolean EGLAPIENTRY EGL_BindAPI(EGLenum api) 562 { 563 564 ANGLE_SCOPED_GLOBAL_LOCK(); 565 EGL_EVENT(BindAPI, "api = 0x%X", api); 566 567 Thread *thread = egl::GetCurrentThread(); 568 569 ANGLE_EGL_VALIDATE(thread, BindAPI, nullptr, EGLBoolean, api); 570 571 return BindAPI(thread, api); 572 } 573 574 EGLSurface EGLAPIENTRY EGL_CreatePbufferFromClientBuffer(EGLDisplay dpy, 575 EGLenum buftype, 576 EGLClientBuffer buffer, 577 EGLConfig config, 578 const EGLint *attrib_list) 579 { 580 581 ANGLE_SCOPED_GLOBAL_LOCK(); 582 EGL_EVENT(CreatePbufferFromClientBuffer, 583 "dpy = 0x%016" PRIxPTR ", buftype = 0x%X, buffer = 0x%016" PRIxPTR 584 ", config = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", 585 (uintptr_t)dpy, buftype, (uintptr_t)buffer, (uintptr_t)config, 586 (uintptr_t)attrib_list); 587 588 Thread *thread = egl::GetCurrentThread(); 589 590 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 591 Config *configPacked = PackParam<Config *>(config); 592 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 593 594 ANGLE_EGL_VALIDATE(thread, CreatePbufferFromClientBuffer, GetDisplayIfValid(dpyPacked), 595 EGLSurface, dpyPacked, buftype, buffer, configPacked, attrib_listPacked); 596 597 return CreatePbufferFromClientBuffer(thread, dpyPacked, buftype, buffer, configPacked, 598 attrib_listPacked); 599 } 600 601 EGLenum EGLAPIENTRY EGL_QueryAPI() 602 { 603 604 ANGLE_SCOPED_GLOBAL_LOCK(); 605 EGL_EVENT(QueryAPI, ""); 606 607 Thread *thread = egl::GetCurrentThread(); 608 609 ANGLE_EGL_VALIDATE(thread, QueryAPI, nullptr, EGLenum); 610 611 return QueryAPI(thread); 612 } 613 614 EGLBoolean EGLAPIENTRY EGL_ReleaseThread() 615 { 616 617 ANGLE_SCOPED_GLOBAL_LOCK(); 618 EGL_EVENT(ReleaseThread, ""); 619 620 Thread *thread = egl::GetCurrentThread(); 621 622 ANGLE_EGL_VALIDATE(thread, ReleaseThread, nullptr, EGLBoolean); 623 624 return ReleaseThread(thread); 625 } 626 627 EGLBoolean EGLAPIENTRY EGL_WaitClient() 628 { 629 630 ANGLE_SCOPED_GLOBAL_LOCK(); 631 EGL_EVENT(WaitClient, ""); 632 633 Thread *thread = egl::GetCurrentThread(); 634 635 ANGLE_EGL_VALIDATE(thread, WaitClient, nullptr, EGLBoolean); 636 637 return WaitClient(thread); 638 } 639 640 // EGL 1.4 641 EGLContext EGLAPIENTRY EGL_GetCurrentContext() 642 { 643 644 ANGLE_SCOPED_GLOBAL_LOCK(); 645 EGL_EVENT(GetCurrentContext, ""); 646 647 Thread *thread = egl::GetCurrentThread(); 648 649 ANGLE_EGL_VALIDATE(thread, GetCurrentContext, nullptr, EGLContext); 650 651 return GetCurrentContext(thread); 652 } 653 654 // EGL 1.5 655 EGLint EGLAPIENTRY EGL_ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout) 656 { 657 658 ANGLE_SCOPED_GLOBAL_LOCK(); 659 EGL_EVENT(ClientWaitSync, 660 "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR ", flags = %d, timeout = %llu", 661 (uintptr_t)dpy, (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout)); 662 663 Thread *thread = egl::GetCurrentThread(); 664 665 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 666 Sync *syncPacked = PackParam<Sync *>(sync); 667 668 ANGLE_EGL_VALIDATE(thread, ClientWaitSync, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked, 669 syncPacked, flags, timeout); 670 671 return ClientWaitSync(thread, dpyPacked, syncPacked, flags, timeout); 672 } 673 674 EGLImage EGLAPIENTRY EGL_CreateImage(EGLDisplay dpy, 675 EGLContext ctx, 676 EGLenum target, 677 EGLClientBuffer buffer, 678 const EGLAttrib *attrib_list) 679 { 680 681 ANGLE_SCOPED_GLOBAL_LOCK(); 682 EGL_EVENT(CreateImage, 683 "dpy = 0x%016" PRIxPTR ", ctx = 0x%016" PRIxPTR 684 ", target = 0x%X, buffer = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", 685 (uintptr_t)dpy, (uintptr_t)ctx, target, (uintptr_t)buffer, (uintptr_t)attrib_list); 686 687 Thread *thread = egl::GetCurrentThread(); 688 689 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 690 gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); 691 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 692 693 ANGLE_EGL_VALIDATE(thread, CreateImage, GetDisplayIfValid(dpyPacked), EGLImage, dpyPacked, 694 ctxPacked, target, buffer, attrib_listPacked); 695 696 return CreateImage(thread, dpyPacked, ctxPacked, target, buffer, attrib_listPacked); 697 } 698 699 EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy, 700 EGLConfig config, 701 void *native_pixmap, 702 const EGLAttrib *attrib_list) 703 { 704 705 ANGLE_SCOPED_GLOBAL_LOCK(); 706 EGL_EVENT(CreatePlatformPixmapSurface, 707 "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", native_pixmap = 0x%016" PRIxPTR 708 ", attrib_list = 0x%016" PRIxPTR "", 709 (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_pixmap, (uintptr_t)attrib_list); 710 711 Thread *thread = egl::GetCurrentThread(); 712 713 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 714 Config *configPacked = PackParam<Config *>(config); 715 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 716 717 ANGLE_EGL_VALIDATE(thread, CreatePlatformPixmapSurface, GetDisplayIfValid(dpyPacked), 718 EGLSurface, dpyPacked, configPacked, native_pixmap, attrib_listPacked); 719 720 return CreatePlatformPixmapSurface(thread, dpyPacked, configPacked, native_pixmap, 721 attrib_listPacked); 722 } 723 724 EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy, 725 EGLConfig config, 726 void *native_window, 727 const EGLAttrib *attrib_list) 728 { 729 730 ANGLE_SCOPED_GLOBAL_LOCK(); 731 EGL_EVENT(CreatePlatformWindowSurface, 732 "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", native_window = 0x%016" PRIxPTR 733 ", attrib_list = 0x%016" PRIxPTR "", 734 (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_window, (uintptr_t)attrib_list); 735 736 Thread *thread = egl::GetCurrentThread(); 737 738 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 739 Config *configPacked = PackParam<Config *>(config); 740 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 741 742 ANGLE_EGL_VALIDATE(thread, CreatePlatformWindowSurface, GetDisplayIfValid(dpyPacked), 743 EGLSurface, dpyPacked, configPacked, native_window, attrib_listPacked); 744 745 return CreatePlatformWindowSurface(thread, dpyPacked, configPacked, native_window, 746 attrib_listPacked); 747 } 748 749 EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list) 750 { 751 752 ANGLE_SCOPED_GLOBAL_LOCK(); 753 EGL_EVENT(CreateSync, "dpy = 0x%016" PRIxPTR ", type = 0x%X, attrib_list = 0x%016" PRIxPTR "", 754 (uintptr_t)dpy, type, (uintptr_t)attrib_list); 755 756 Thread *thread = egl::GetCurrentThread(); 757 758 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 759 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 760 761 ANGLE_EGL_VALIDATE(thread, CreateSync, GetDisplayIfValid(dpyPacked), EGLSync, dpyPacked, type, 762 attrib_listPacked); 763 764 return CreateSync(thread, dpyPacked, type, attrib_listPacked); 765 } 766 767 EGLBoolean EGLAPIENTRY EGL_DestroyImage(EGLDisplay dpy, EGLImage image) 768 { 769 770 ANGLE_SCOPED_GLOBAL_LOCK(); 771 EGL_EVENT(DestroyImage, "dpy = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR "", (uintptr_t)dpy, 772 (uintptr_t)image); 773 774 Thread *thread = egl::GetCurrentThread(); 775 776 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 777 Image *imagePacked = PackParam<Image *>(image); 778 779 ANGLE_EGL_VALIDATE(thread, DestroyImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 780 imagePacked); 781 782 return DestroyImage(thread, dpyPacked, imagePacked); 783 } 784 785 EGLBoolean EGLAPIENTRY EGL_DestroySync(EGLDisplay dpy, EGLSync sync) 786 { 787 788 ANGLE_SCOPED_GLOBAL_LOCK(); 789 EGL_EVENT(DestroySync, "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR "", (uintptr_t)dpy, 790 (uintptr_t)sync); 791 792 Thread *thread = egl::GetCurrentThread(); 793 794 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 795 Sync *syncPacked = PackParam<Sync *>(sync); 796 797 ANGLE_EGL_VALIDATE(thread, DestroySync, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 798 syncPacked); 799 800 return DestroySync(thread, dpyPacked, syncPacked); 801 } 802 803 EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplay(EGLenum platform, 804 void *native_display, 805 const EGLAttrib *attrib_list) 806 { 807 808 ANGLE_SCOPED_GLOBAL_LOCK(); 809 EGL_EVENT(GetPlatformDisplay, 810 "platform = 0x%X, native_display = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR 811 "", 812 platform, (uintptr_t)native_display, (uintptr_t)attrib_list); 813 814 Thread *thread = egl::GetCurrentThread(); 815 816 const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); 817 818 ANGLE_EGL_VALIDATE(thread, GetPlatformDisplay, nullptr, EGLDisplay, platform, native_display, 819 attrib_listPacked); 820 821 return GetPlatformDisplay(thread, platform, native_display, attrib_listPacked); 822 } 823 824 EGLBoolean EGLAPIENTRY EGL_GetSyncAttrib(EGLDisplay dpy, 825 EGLSync sync, 826 EGLint attribute, 827 EGLAttrib *value) 828 { 829 830 ANGLE_SCOPED_GLOBAL_LOCK(); 831 EGL_EVENT(GetSyncAttrib, 832 "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR 833 ", attribute = %d, value = 0x%016" PRIxPTR "", 834 (uintptr_t)dpy, (uintptr_t)sync, attribute, (uintptr_t)value); 835 836 Thread *thread = egl::GetCurrentThread(); 837 838 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 839 Sync *syncPacked = PackParam<Sync *>(sync); 840 841 ANGLE_EGL_VALIDATE(thread, GetSyncAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 842 syncPacked, attribute, value); 843 844 return GetSyncAttrib(thread, dpyPacked, syncPacked, attribute, value); 845 } 846 847 EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) 848 { 849 850 ANGLE_SCOPED_GLOBAL_LOCK(); 851 EGL_EVENT(WaitSync, "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR ", flags = %d", 852 (uintptr_t)dpy, (uintptr_t)sync, flags); 853 854 Thread *thread = egl::GetCurrentThread(); 855 856 egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); 857 Sync *syncPacked = PackParam<Sync *>(sync); 858 859 ANGLE_EGL_VALIDATE(thread, WaitSync, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, 860 syncPacked, flags); 861 862 return WaitSync(thread, dpyPacked, syncPacked, flags); 863 } 864 865 } // extern "C"