1 //
2 // Copyright 2016 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 // FunctionsEGL.cpp: Implements the FunctionsEGL class.
8
9 #include "libANGLE/renderer/gl/egl/FunctionsEGL.h"
10
11 #include <algorithm>
12
13 #include "common/platform.h"
14 #include "common/string_utils.h"
15 #include "libANGLE/renderer/driver_utils.h"
16 #include "libANGLE/renderer/gl/FunctionsGL.h"
17 #include "libANGLE/renderer/gl/egl/functionsegl_typedefs.h"
18
19 namespace
20 {
21
22 template <typename T>
SetPtr(T * dst,void * src)23 bool SetPtr(T *dst, void *src)
24 {
25 if (src)
26 {
27 *dst = reinterpret_cast<T>(src);
28 return true;
29 }
30 return false;
31 }
32 } // namespace
33
34 namespace rx
35 {
36
37 struct FunctionsEGL::EGLDispatchTable
38 {
EGLDispatchTablerx::FunctionsEGL::EGLDispatchTable39 EGLDispatchTable()
40 : bindAPIPtr(nullptr),
41 chooseConfigPtr(nullptr),
42 createContextPtr(nullptr),
43 createPbufferSurfacePtr(nullptr),
44 createWindowSurfacePtr(nullptr),
45 destroyContextPtr(nullptr),
46 destroySurfacePtr(nullptr),
47 getConfigAttribPtr(nullptr),
48 getConfigsPtr(nullptr),
49 getCurrentSurfacePtr(nullptr),
50 getDisplayPtr(nullptr),
51 getErrorPtr(nullptr),
52 initializePtr(nullptr),
53 makeCurrentPtr(nullptr),
54 queryStringPtr(nullptr),
55 querySurfacePtr(nullptr),
56 swapBuffersPtr(nullptr),
57 terminatePtr(nullptr),
58
59 bindTexImagePtr(nullptr),
60 releaseTexImagePtr(nullptr),
61 surfaceAttribPtr(nullptr),
62 swapIntervalPtr(nullptr),
63
64 getCurrentContextPtr(nullptr),
65
66 createImageKHRPtr(nullptr),
67 destroyImageKHRPtr(nullptr),
68
69 createSyncKHRPtr(nullptr),
70 destroySyncKHRPtr(nullptr),
71 clientWaitSyncKHRPtr(nullptr),
72 getSyncAttribKHRPtr(nullptr),
73
74 waitSyncKHRPtr(nullptr),
75
76 swapBuffersWithDamageKHRPtr(nullptr),
77
78 presentationTimeANDROIDPtr(nullptr),
79
80 setBlobCacheFuncsANDROIDPtr(nullptr),
81
82 getCompositorTimingSupportedANDROIDPtr(nullptr),
83 getCompositorTimingANDROIDPtr(nullptr),
84 getNextFrameIdANDROIDPtr(nullptr),
85 getFrameTimestampSupportedANDROIDPtr(nullptr),
86 getFrameTimestampsANDROIDPtr(nullptr),
87
88 dupNativeFenceFDANDROIDPtr(nullptr)
89 {}
90
91 // 1.0
92 PFNEGLBINDAPIPROC bindAPIPtr;
93 PFNEGLCHOOSECONFIGPROC chooseConfigPtr;
94 PFNEGLCREATECONTEXTPROC createContextPtr;
95 PFNEGLCREATEPBUFFERSURFACEPROC createPbufferSurfacePtr;
96 PFNEGLCREATEWINDOWSURFACEPROC createWindowSurfacePtr;
97 PFNEGLDESTROYCONTEXTPROC destroyContextPtr;
98 PFNEGLDESTROYSURFACEPROC destroySurfacePtr;
99 PFNEGLGETCONFIGATTRIBPROC getConfigAttribPtr;
100 PFNEGLGETCONFIGSPROC getConfigsPtr;
101 PFNEGLGETCURRENTSURFACEPROC getCurrentSurfacePtr;
102 PFNEGLGETDISPLAYPROC getDisplayPtr;
103 PFNEGLGETERRORPROC getErrorPtr;
104 PFNEGLINITIALIZEPROC initializePtr;
105 PFNEGLMAKECURRENTPROC makeCurrentPtr;
106 PFNEGLQUERYSTRINGPROC queryStringPtr;
107 PFNEGLQUERYSURFACEPROC querySurfacePtr;
108 PFNEGLSWAPBUFFERSPROC swapBuffersPtr;
109 PFNEGLTERMINATEPROC terminatePtr;
110
111 // 1.1
112 PFNEGLBINDTEXIMAGEPROC bindTexImagePtr;
113 PFNEGLRELEASETEXIMAGEPROC releaseTexImagePtr;
114 PFNEGLSURFACEATTRIBPROC surfaceAttribPtr;
115 PFNEGLSWAPINTERVALPROC swapIntervalPtr;
116
117 // 1.4
118 PFNEGLGETCURRENTCONTEXTPROC getCurrentContextPtr;
119
120 // EGL_KHR_image
121 PFNEGLCREATEIMAGEKHRPROC createImageKHRPtr;
122 PFNEGLDESTROYIMAGEKHRPROC destroyImageKHRPtr;
123
124 // EGL_KHR_fence_sync
125 PFNEGLCREATESYNCKHRPROC createSyncKHRPtr;
126 PFNEGLDESTROYSYNCKHRPROC destroySyncKHRPtr;
127 PFNEGLCLIENTWAITSYNCKHRPROC clientWaitSyncKHRPtr;
128 PFNEGLGETSYNCATTRIBKHRPROC getSyncAttribKHRPtr;
129
130 // EGL_KHR_wait_sync
131 PFNEGLWAITSYNCKHRPROC waitSyncKHRPtr;
132
133 // EGL_KHR_swap_buffers_with_damage
134 PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC swapBuffersWithDamageKHRPtr;
135
136 // EGL_ANDROID_presentation_time
137 PFNEGLPRESENTATIONTIMEANDROIDPROC presentationTimeANDROIDPtr;
138
139 // EGL_ANDROID_blob_cache
140 PFNEGLSETBLOBCACHEFUNCSANDROIDPROC setBlobCacheFuncsANDROIDPtr;
141
142 // EGL_ANDROID_get_frame_timestamps
143 PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC getCompositorTimingSupportedANDROIDPtr;
144 PFNEGLGETCOMPOSITORTIMINGANDROIDPROC getCompositorTimingANDROIDPtr;
145 PFNEGLGETNEXTFRAMEIDANDROIDPROC getNextFrameIdANDROIDPtr;
146 PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC getFrameTimestampSupportedANDROIDPtr;
147 PFNEGLGETFRAMETIMESTAMPSANDROIDPROC getFrameTimestampsANDROIDPtr;
148
149 // EGL_ANDROID_native_fence_sync
150 PFNEGLDUPNATIVEFENCEFDANDROIDPROC dupNativeFenceFDANDROIDPtr;
151 };
152
FunctionsEGL()153 FunctionsEGL::FunctionsEGL()
154 : majorVersion(0), minorVersion(0), mFnPtrs(new EGLDispatchTable()), mEGLDisplay(EGL_NO_DISPLAY)
155 {}
156
~FunctionsEGL()157 FunctionsEGL::~FunctionsEGL()
158 {
159 SafeDelete(mFnPtrs);
160 }
161
initialize(EGLNativeDisplayType nativeDisplay)162 egl::Error FunctionsEGL::initialize(EGLNativeDisplayType nativeDisplay)
163 {
164 #define ANGLE_GET_PROC_OR_ERROR(MEMBER, NAME) \
165 do \
166 { \
167 if (!SetPtr(MEMBER, getProcAddress(#NAME))) \
168 { \
169 return egl::EglNotInitialized() << "Could not load EGL entry point " #NAME; \
170 } \
171 } while (0)
172
173 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->bindAPIPtr, eglBindAPI);
174 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->chooseConfigPtr, eglChooseConfig);
175 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->createContextPtr, eglCreateContext);
176 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->createPbufferSurfacePtr, eglCreatePbufferSurface);
177 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->createWindowSurfacePtr, eglCreateWindowSurface);
178 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->destroyContextPtr, eglDestroyContext);
179 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->destroySurfacePtr, eglDestroySurface);
180 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getConfigAttribPtr, eglGetConfigAttrib);
181 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getConfigsPtr, eglGetConfigs);
182 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getCurrentSurfacePtr, eglGetCurrentSurface);
183 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getDisplayPtr, eglGetDisplay);
184 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getErrorPtr, eglGetError);
185 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->initializePtr, eglInitialize);
186 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->makeCurrentPtr, eglMakeCurrent);
187 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->queryStringPtr, eglQueryString);
188 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->querySurfacePtr, eglQuerySurface);
189 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->swapBuffersPtr, eglSwapBuffers);
190 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->terminatePtr, eglTerminate);
191
192 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->bindTexImagePtr, eglBindTexImage);
193 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->releaseTexImagePtr, eglReleaseTexImage);
194 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->surfaceAttribPtr, eglSurfaceAttrib);
195 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->swapIntervalPtr, eglSwapInterval);
196
197 mEGLDisplay = mFnPtrs->getDisplayPtr(nativeDisplay);
198 if (mEGLDisplay != EGL_NO_DISPLAY)
199 {
200 if (mFnPtrs->initializePtr(mEGLDisplay, &majorVersion, &minorVersion) != EGL_TRUE)
201 {
202 return egl::Error(mFnPtrs->getErrorPtr(), "Failed to initialize system egl");
203 }
204 }
205 else
206 {
207 // If no display was available, try to fallback to the first available
208 // native device object's display.
209 mEGLDisplay = getNativeDisplay(&majorVersion, &minorVersion);
210 if (mEGLDisplay == EGL_NO_DISPLAY)
211 {
212 return egl::EglNotInitialized() << "Failed to get system egl display";
213 }
214 }
215 if (majorVersion < 1 || (majorVersion == 1 && minorVersion < 4))
216 {
217 return egl::EglNotInitialized() << "Unsupported EGL version (require at least 1.4).";
218 }
219 if (mFnPtrs->bindAPIPtr(EGL_OPENGL_ES_API) != EGL_TRUE)
220 {
221 return egl::Error(mFnPtrs->getErrorPtr(), "Failed to bind API in system egl");
222 }
223
224 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getCurrentContextPtr, eglGetCurrentContext);
225
226 const char *extensions = queryString(EGL_EXTENSIONS);
227 if (!extensions)
228 {
229 return egl::Error(mFnPtrs->getErrorPtr(), "Failed to query extensions in system egl");
230 }
231 angle::SplitStringAlongWhitespace(extensions, &mExtensions);
232
233 if (hasExtension("EGL_KHR_image_base"))
234 {
235 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->createImageKHRPtr, eglCreateImageKHR);
236 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->destroyImageKHRPtr, eglDestroyImageKHR);
237 }
238 if (hasExtension("EGL_KHR_fence_sync"))
239 {
240 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->createSyncKHRPtr, eglCreateSyncKHR);
241 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->destroySyncKHRPtr, eglDestroySyncKHR);
242 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->clientWaitSyncKHRPtr, eglClientWaitSyncKHR);
243 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getSyncAttribKHRPtr, eglGetSyncAttribKHR);
244 }
245 if (hasExtension("EGL_KHR_wait_sync"))
246 {
247 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->waitSyncKHRPtr, eglWaitSyncKHR);
248 }
249
250 if (hasExtension("EGL_KHR_swap_buffers_with_damage"))
251 {
252 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->swapBuffersWithDamageKHRPtr, eglSwapBuffersWithDamageKHR);
253 }
254
255 if (hasExtension("EGL_ANDROID_presentation_time"))
256 {
257 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->presentationTimeANDROIDPtr, eglPresentationTimeANDROID);
258 }
259
260 if (hasExtension("EGL_ANDROID_blob_cache"))
261 {
262 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->setBlobCacheFuncsANDROIDPtr, eglSetBlobCacheFuncsANDROID);
263 }
264
265 if (hasExtension("EGL_ANDROID_get_frame_timestamps"))
266 {
267 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getCompositorTimingSupportedANDROIDPtr,
268 eglGetCompositorTimingSupportedANDROID);
269 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getCompositorTimingANDROIDPtr,
270 eglGetCompositorTimingANDROID);
271 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getNextFrameIdANDROIDPtr, eglGetNextFrameIdANDROID);
272 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getFrameTimestampSupportedANDROIDPtr,
273 eglGetFrameTimestampSupportedANDROID);
274 ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getFrameTimestampsANDROIDPtr,
275 eglGetFrameTimestampsANDROID);
276 }
277
278 // The native fence sync extension is a bit complicated. It's reported as present for ChromeOS,
279 // but Android currently doesn't report this extension even when it's present, and older devices
280 // may export a useless wrapper function. See crbug.com/775707 for details. In short, if the
281 // symbol is present and we're on Android N or newer, assume that it's usable even if the
282 // extension wasn't reported.
283 if (hasExtension("EGL_ANDROID_native_fence_sync") || GetAndroidSDKVersion() >= 24)
284 {
285 // Don't error trying to load this entry point.
286 if (SetPtr(&mFnPtrs->dupNativeFenceFDANDROIDPtr,
287 getProcAddress("eglDupNativeFenceFDANDROID")) &&
288 !hasExtension("EGL_ANDROID_native_fence_sync"))
289 {
290 mExtensions.push_back("EGL_ANDROID_native_fence_sync");
291 }
292 }
293
294 #undef ANGLE_GET_PROC_OR_ERROR
295
296 return egl::NoError();
297 }
298
terminate()299 egl::Error FunctionsEGL::terminate()
300 {
301 if (mFnPtrs->terminatePtr == nullptr || mFnPtrs->terminatePtr(mEGLDisplay) == EGL_TRUE)
302 {
303 mEGLDisplay = nullptr;
304 return egl::NoError();
305 }
306 return egl::Error(mFnPtrs->getErrorPtr());
307 }
308
getNativeDisplay(int * major,int * minor)309 EGLDisplay FunctionsEGL::getNativeDisplay(int *major, int *minor)
310 {
311 // We haven't queried extensions yet since some platforms require a display
312 // to do so. We'll query them now since we need some for this fallback, and
313 // then re-query them again later once we have the display.
314 const char *extensions = queryString(EGL_EXTENSIONS);
315 if (!extensions)
316 {
317 return EGL_NO_DISPLAY;
318 }
319 angle::SplitStringAlongWhitespace(extensions, &mExtensions);
320
321 // This fallback mechanism makes use of:
322 // - EGL_EXT_device_enumeration or EGL_EXT_device_base for eglQueryDevicesEXT
323 // - EGL_EXT_platform_base for eglGetPlatformDisplayEXT
324 // - EGL_EXT_platform_device for EGL_PLATFORM_DEVICE_EXT
325 PFNEGLQUERYDEVICESEXTPROC queryDevices;
326 PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplay;
327 bool hasQueryDevicesEXT =
328 hasExtension("EGL_EXT_device_enumeration") || hasExtension("EGL_EXT_device_base");
329 bool hasPlatformBaseEXT = hasExtension("EGL_EXT_platform_base");
330 bool hasPlatformDeviceEXT = hasExtension("EGL_EXT_platform_device");
331 if (!hasQueryDevicesEXT || !hasPlatformBaseEXT || !hasPlatformDeviceEXT)
332 {
333 return EGL_NO_DISPLAY;
334 }
335 if (!SetPtr(&queryDevices, getProcAddress("eglQueryDevicesEXT")) ||
336 !SetPtr(&getPlatformDisplay, getProcAddress("eglGetPlatformDisplayEXT")))
337 {
338 return EGL_NO_DISPLAY;
339 }
340
341 // Get a list of native device objects.
342 const EGLint kMaxDevices = 32;
343 EGLDeviceEXT eglDevices[kMaxDevices];
344 EGLint numDevices = 0;
345 if (!queryDevices(kMaxDevices, eglDevices, &numDevices))
346 {
347 return EGL_NO_DISPLAY;
348 }
349
350 // Look for the first native device that gives us a valid display.
351 for (EGLint i = 0; i < numDevices; i++)
352 {
353 EGLDisplay display = getPlatformDisplay(EGL_PLATFORM_DEVICE_EXT, eglDevices[i], nullptr);
354 if (mFnPtrs->getErrorPtr() != EGL_SUCCESS)
355 {
356 continue;
357 }
358 if (mFnPtrs->initializePtr(display, major, minor) == EGL_TRUE)
359 {
360 return display;
361 }
362 }
363
364 return EGL_NO_DISPLAY;
365 }
366
367 class FunctionsGLEGL : public FunctionsGL
368 {
369 public:
FunctionsGLEGL(const FunctionsEGL & egl)370 FunctionsGLEGL(const FunctionsEGL &egl) : mEGL(egl) {}
371
~FunctionsGLEGL()372 ~FunctionsGLEGL() override {}
373
374 private:
loadProcAddress(const std::string & function) const375 void *loadProcAddress(const std::string &function) const override
376 {
377 return mEGL.getProcAddress(function.c_str());
378 }
379
380 const FunctionsEGL &mEGL;
381 };
382
makeFunctionsGL(void) const383 FunctionsGL *FunctionsEGL::makeFunctionsGL(void) const
384 {
385 return new FunctionsGLEGL(*this);
386 }
387
hasExtension(const char * extension) const388 bool FunctionsEGL::hasExtension(const char *extension) const
389 {
390 return std::find(mExtensions.begin(), mExtensions.end(), extension) != mExtensions.end();
391 }
392
getDisplay() const393 EGLDisplay FunctionsEGL::getDisplay() const
394 {
395 return mEGLDisplay;
396 }
397
getError() const398 EGLint FunctionsEGL::getError() const
399 {
400 return mFnPtrs->getErrorPtr();
401 }
402
chooseConfig(EGLint const * attribList,EGLConfig * configs,EGLint configSize,EGLint * numConfig) const403 EGLBoolean FunctionsEGL::chooseConfig(EGLint const *attribList,
404 EGLConfig *configs,
405 EGLint configSize,
406 EGLint *numConfig) const
407 {
408 return mFnPtrs->chooseConfigPtr(mEGLDisplay, attribList, configs, configSize, numConfig);
409 }
410
getConfigs(EGLConfig * configs,EGLint config_size,EGLint * num_config) const411 EGLBoolean FunctionsEGL::getConfigs(EGLConfig *configs,
412 EGLint config_size,
413 EGLint *num_config) const
414 {
415 return mFnPtrs->getConfigsPtr(mEGLDisplay, configs, config_size, num_config);
416 }
417
getConfigAttrib(EGLConfig config,EGLint attribute,EGLint * value) const418 EGLBoolean FunctionsEGL::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value) const
419 {
420 return mFnPtrs->getConfigAttribPtr(mEGLDisplay, config, attribute, value);
421 }
422
getCurrentSurface(EGLint readdraw) const423 EGLSurface FunctionsEGL::getCurrentSurface(EGLint readdraw) const
424 {
425 return mFnPtrs->getCurrentSurfacePtr(readdraw);
426 }
427
createContext(EGLConfig config,EGLContext share_context,EGLint const * attrib_list) const428 EGLContext FunctionsEGL::createContext(EGLConfig config,
429 EGLContext share_context,
430 EGLint const *attrib_list) const
431 {
432 return mFnPtrs->createContextPtr(mEGLDisplay, config, share_context, attrib_list);
433 }
434
createPbufferSurface(EGLConfig config,const EGLint * attrib_list) const435 EGLSurface FunctionsEGL::createPbufferSurface(EGLConfig config, const EGLint *attrib_list) const
436 {
437 return mFnPtrs->createPbufferSurfacePtr(mEGLDisplay, config, attrib_list);
438 }
439
createWindowSurface(EGLConfig config,EGLNativeWindowType win,const EGLint * attrib_list) const440 EGLSurface FunctionsEGL::createWindowSurface(EGLConfig config,
441 EGLNativeWindowType win,
442 const EGLint *attrib_list) const
443 {
444 return mFnPtrs->createWindowSurfacePtr(mEGLDisplay, config, win, attrib_list);
445 }
446
destroyContext(EGLContext context) const447 EGLBoolean FunctionsEGL::destroyContext(EGLContext context) const
448 {
449 return mFnPtrs->destroyContextPtr(mEGLDisplay, context);
450 }
451
destroySurface(EGLSurface surface) const452 EGLBoolean FunctionsEGL::destroySurface(EGLSurface surface) const
453 {
454 return mFnPtrs->destroySurfacePtr(mEGLDisplay, surface);
455 }
456
makeCurrent(EGLSurface surface,EGLContext context) const457 EGLBoolean FunctionsEGL::makeCurrent(EGLSurface surface, EGLContext context) const
458 {
459 return mFnPtrs->makeCurrentPtr(mEGLDisplay, surface, surface, context);
460 }
461
queryString(EGLint name) const462 char const *FunctionsEGL::queryString(EGLint name) const
463 {
464 return mFnPtrs->queryStringPtr(mEGLDisplay, name);
465 }
466
querySurface(EGLSurface surface,EGLint attribute,EGLint * value) const467 EGLBoolean FunctionsEGL::querySurface(EGLSurface surface, EGLint attribute, EGLint *value) const
468 {
469 return mFnPtrs->querySurfacePtr(mEGLDisplay, surface, attribute, value);
470 }
471
swapBuffers(EGLSurface surface) const472 EGLBoolean FunctionsEGL::swapBuffers(EGLSurface surface) const
473 {
474 return mFnPtrs->swapBuffersPtr(mEGLDisplay, surface);
475 }
476
bindTexImage(EGLSurface surface,EGLint buffer) const477 EGLBoolean FunctionsEGL::bindTexImage(EGLSurface surface, EGLint buffer) const
478 {
479 return mFnPtrs->bindTexImagePtr(mEGLDisplay, surface, buffer);
480 }
481
releaseTexImage(EGLSurface surface,EGLint buffer) const482 EGLBoolean FunctionsEGL::releaseTexImage(EGLSurface surface, EGLint buffer) const
483 {
484 return mFnPtrs->releaseTexImagePtr(mEGLDisplay, surface, buffer);
485 }
486
surfaceAttrib(EGLSurface surface,EGLint attribute,EGLint value) const487 EGLBoolean FunctionsEGL::surfaceAttrib(EGLSurface surface, EGLint attribute, EGLint value) const
488 {
489 return mFnPtrs->surfaceAttribPtr(mEGLDisplay, surface, attribute, value);
490 }
491
swapInterval(EGLint interval) const492 EGLBoolean FunctionsEGL::swapInterval(EGLint interval) const
493 {
494 return mFnPtrs->swapIntervalPtr(mEGLDisplay, interval);
495 }
496
getCurrentContext() const497 EGLContext FunctionsEGL::getCurrentContext() const
498 {
499 return mFnPtrs->getCurrentContextPtr();
500 }
501
createImageKHR(EGLContext context,EGLenum target,EGLClientBuffer buffer,const EGLint * attrib_list) const502 EGLImageKHR FunctionsEGL::createImageKHR(EGLContext context,
503 EGLenum target,
504 EGLClientBuffer buffer,
505 const EGLint *attrib_list) const
506 {
507 return mFnPtrs->createImageKHRPtr(mEGLDisplay, context, target, buffer, attrib_list);
508 }
509
destroyImageKHR(EGLImageKHR image) const510 EGLBoolean FunctionsEGL::destroyImageKHR(EGLImageKHR image) const
511 {
512 return mFnPtrs->destroyImageKHRPtr(mEGLDisplay, image);
513 }
514
createSyncKHR(EGLenum type,const EGLint * attrib_list) const515 EGLSyncKHR FunctionsEGL::createSyncKHR(EGLenum type, const EGLint *attrib_list) const
516 {
517 return mFnPtrs->createSyncKHRPtr(mEGLDisplay, type, attrib_list);
518 }
519
destroySyncKHR(EGLSyncKHR sync) const520 EGLBoolean FunctionsEGL::destroySyncKHR(EGLSyncKHR sync) const
521 {
522 return mFnPtrs->destroySyncKHRPtr(mEGLDisplay, sync);
523 }
524
clientWaitSyncKHR(EGLSyncKHR sync,EGLint flags,EGLTimeKHR timeout) const525 EGLint FunctionsEGL::clientWaitSyncKHR(EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) const
526 {
527 return mFnPtrs->clientWaitSyncKHRPtr(mEGLDisplay, sync, flags, timeout);
528 }
529
getSyncAttribKHR(EGLSyncKHR sync,EGLint attribute,EGLint * value) const530 EGLBoolean FunctionsEGL::getSyncAttribKHR(EGLSyncKHR sync, EGLint attribute, EGLint *value) const
531 {
532 return mFnPtrs->getSyncAttribKHRPtr(mEGLDisplay, sync, attribute, value);
533 }
534
waitSyncKHR(EGLSyncKHR sync,EGLint flags) const535 EGLint FunctionsEGL::waitSyncKHR(EGLSyncKHR sync, EGLint flags) const
536 {
537 return mFnPtrs->waitSyncKHRPtr(mEGLDisplay, sync, flags);
538 }
539
swapBuffersWithDamageKHR(EGLSurface surface,const EGLint * rects,EGLint n_rects) const540 EGLBoolean FunctionsEGL::swapBuffersWithDamageKHR(EGLSurface surface,
541 const EGLint *rects,
542 EGLint n_rects) const
543 {
544 return mFnPtrs->swapBuffersWithDamageKHRPtr(mEGLDisplay, surface, rects, n_rects);
545 }
546
presentationTimeANDROID(EGLSurface surface,EGLnsecsANDROID time) const547 EGLBoolean FunctionsEGL::presentationTimeANDROID(EGLSurface surface, EGLnsecsANDROID time) const
548 {
549 return mFnPtrs->presentationTimeANDROIDPtr(mEGLDisplay, surface, time);
550 }
551
setBlobCacheFuncsANDROID(EGLSetBlobFuncANDROID set,EGLGetBlobFuncANDROID get) const552 void FunctionsEGL::setBlobCacheFuncsANDROID(EGLSetBlobFuncANDROID set,
553 EGLGetBlobFuncANDROID get) const
554 {
555 return mFnPtrs->setBlobCacheFuncsANDROIDPtr(mEGLDisplay, set, get);
556 }
557
getCompositorTimingSupportedANDROID(EGLSurface surface,EGLint name) const558 EGLBoolean FunctionsEGL::getCompositorTimingSupportedANDROID(EGLSurface surface, EGLint name) const
559 {
560 return mFnPtrs->getCompositorTimingSupportedANDROIDPtr(mEGLDisplay, surface, name);
561 }
562
getCompositorTimingANDROID(EGLSurface surface,EGLint numTimestamps,const EGLint * names,EGLnsecsANDROID * values) const563 EGLBoolean FunctionsEGL::getCompositorTimingANDROID(EGLSurface surface,
564 EGLint numTimestamps,
565 const EGLint *names,
566 EGLnsecsANDROID *values) const
567 {
568 return mFnPtrs->getCompositorTimingANDROIDPtr(mEGLDisplay, surface, numTimestamps, names,
569 values);
570 }
571
getNextFrameIdANDROID(EGLSurface surface,EGLuint64KHR * frameId) const572 EGLBoolean FunctionsEGL::getNextFrameIdANDROID(EGLSurface surface, EGLuint64KHR *frameId) const
573 {
574 return mFnPtrs->getNextFrameIdANDROIDPtr(mEGLDisplay, surface, frameId);
575 }
576
getFrameTimestampSupportedANDROID(EGLSurface surface,EGLint timestamp) const577 EGLBoolean FunctionsEGL::getFrameTimestampSupportedANDROID(EGLSurface surface,
578 EGLint timestamp) const
579 {
580 return mFnPtrs->getFrameTimestampSupportedANDROIDPtr(mEGLDisplay, surface, timestamp);
581 }
582
getFrameTimestampsANDROID(EGLSurface surface,EGLuint64KHR frameId,EGLint numTimestamps,const EGLint * timestamps,EGLnsecsANDROID * values) const583 EGLBoolean FunctionsEGL::getFrameTimestampsANDROID(EGLSurface surface,
584 EGLuint64KHR frameId,
585 EGLint numTimestamps,
586 const EGLint *timestamps,
587 EGLnsecsANDROID *values) const
588 {
589 return mFnPtrs->getFrameTimestampsANDROIDPtr(mEGLDisplay, surface, frameId, numTimestamps,
590 timestamps, values);
591 }
592
dupNativeFenceFDANDROID(EGLSync sync) const593 EGLint FunctionsEGL::dupNativeFenceFDANDROID(EGLSync sync) const
594 {
595 return mFnPtrs->dupNativeFenceFDANDROIDPtr(mEGLDisplay, sync);
596 }
597
598 } // namespace rx
599