blob: 3a7979c7711f356fcca6d57a3e96f3fed70f3544 [file] [log] [blame]
Cody Northrop68d10352018-10-15 07:22:09 -06001/*
2 ** Copyright 2018, The Android Open Source Project
3 **
4 ** Licensed under the Apache License, Version 2.0 (the "License");
5 ** you may not use this file except in compliance with the License.
6 ** You may obtain a copy of the License at
7 **
8 ** http://www.apache.org/licenses/LICENSE-2.0
9 **
10 ** Unless required by applicable law or agreed to in writing, software
11 ** distributed under the License is distributed on an "AS IS" BASIS,
12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 ** See the License for the specific language governing permissions and
14 ** limitations under the License.
15 */
16
17#define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
19#include <EGL/egl.h>
20#include <EGL/eglext.h>
21
22#include "../egl_impl.h"
23
24#include "egl_layers.h"
25#include "egl_platform_entries.h"
26#include "egl_tls.h"
27#include "egl_trace.h"
28
29using namespace android;
30
31namespace android {
32
33extern EGLBoolean egl_init_drivers();
34
35} // namespace android
36
37static inline void clearError() {
38 egl_tls_t::clearError();
39}
40
41EGLDisplay eglGetDisplay(EGLNativeDisplayType display) {
42 ATRACE_CALL();
43 clearError();
44
45 if (egl_init_drivers() == EGL_FALSE) {
46 return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
47 }
48
49 // Call down the chain, which usually points directly to the impl
50 // but may also be routed through layers
51 egl_connection_t* const cnx = &gEGLImpl;
52 return cnx->platform.eglGetDisplay(display);
53}
54
55EGLBoolean eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
56 clearError();
57
58 egl_connection_t* const cnx = &gEGLImpl;
59 return cnx->platform.eglInitialize(dpy, major, minor);
60}
61
62EGLBoolean eglTerminate(EGLDisplay dpy) {
63 clearError();
64
65 egl_connection_t* const cnx = &gEGLImpl;
66 return cnx->platform.eglTerminate(dpy);
67}
68
69EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size,
70 EGLint* num_config) {
71 clearError();
72
73 egl_connection_t* const cnx = &gEGLImpl;
74 return cnx->platform.eglGetConfigs(dpy, configs, config_size, num_config);
75}
76
77EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs,
78 EGLint config_size, EGLint* num_config) {
79 clearError();
80
81 egl_connection_t* const cnx = &gEGLImpl;
82 return cnx->platform.eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
83}
84
85EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value) {
86 clearError();
87
88 egl_connection_t* const cnx = &gEGLImpl;
89 return cnx->platform.eglGetConfigAttrib(dpy, config, attribute, value);
90}
91
92EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
93 const EGLint* attrib_list) {
94 clearError();
95
96 egl_connection_t* const cnx = &gEGLImpl;
97 return cnx->platform.eglCreateWindowSurface(dpy, config, window, attrib_list);
98}
99
100EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, NativePixmapType pixmap,
101 const EGLint* attrib_list) {
102 clearError();
103
104 egl_connection_t* const cnx = &gEGLImpl;
105 return cnx->platform.eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
106}
107
108EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) {
109 clearError();
110
111 egl_connection_t* const cnx = &gEGLImpl;
112 return cnx->platform.eglCreatePbufferSurface(dpy, config, attrib_list);
113}
114
115EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) {
116 clearError();
117
118 egl_connection_t* const cnx = &gEGLImpl;
119 return cnx->platform.eglDestroySurface(dpy, surface);
120}
121
122EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint* value) {
123 clearError();
124
125 egl_connection_t* const cnx = &gEGLImpl;
126 return cnx->platform.eglQuerySurface(dpy, surface, attribute, value);
127}
128
129void EGLAPI eglBeginFrame(EGLDisplay dpy, EGLSurface surface) {
130 ATRACE_CALL();
131 clearError();
132
133 egl_connection_t* const cnx = &gEGLImpl;
134 cnx->platform.eglBeginFrame(dpy, surface);
135}
136
137EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
138 const EGLint* attrib_list) {
139 clearError();
140
141 egl_connection_t* const cnx = &gEGLImpl;
142 return cnx->platform.eglCreateContext(dpy, config, share_list, attrib_list);
143}
144
145EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
146 clearError();
147
148 egl_connection_t* const cnx = &gEGLImpl;
149 return cnx->platform.eglDestroyContext(dpy, ctx);
150}
151
152EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
153 clearError();
154
155 egl_connection_t* const cnx = &gEGLImpl;
156 return cnx->platform.eglMakeCurrent(dpy, draw, read, ctx);
157}
158
159EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value) {
160 clearError();
161
162 egl_connection_t* const cnx = &gEGLImpl;
163 return cnx->platform.eglQueryContext(dpy, ctx, attribute, value);
164}
165
166EGLContext eglGetCurrentContext(void) {
167 clearError();
168
169 egl_connection_t* const cnx = &gEGLImpl;
170 return cnx->platform.eglGetCurrentContext();
171}
172
173EGLSurface eglGetCurrentSurface(EGLint readdraw) {
174 clearError();
175
176 egl_connection_t* const cnx = &gEGLImpl;
177 return cnx->platform.eglGetCurrentSurface(readdraw);
178}
179
180EGLDisplay eglGetCurrentDisplay(void) {
181 clearError();
182
183 egl_connection_t* const cnx = &gEGLImpl;
184 return cnx->platform.eglGetCurrentDisplay();
185}
186
187EGLBoolean eglWaitGL(void) {
188 clearError();
189
190 egl_connection_t* const cnx = &gEGLImpl;
191 return cnx->platform.eglWaitGL();
192}
193
194EGLBoolean eglWaitNative(EGLint engine) {
195 clearError();
196
197 egl_connection_t* const cnx = &gEGLImpl;
198 return cnx->platform.eglWaitNative(engine);
199}
200
201EGLint eglGetError(void) {
202 egl_connection_t* const cnx = &gEGLImpl;
Cody Northrop9a9a1f42018-10-15 18:32:41 -0600203 return cnx->platform.eglGetError();
Cody Northrop68d10352018-10-15 07:22:09 -0600204}
205
206__eglMustCastToProperFunctionPointerType eglGetProcAddress(const char* procname) {
207 // eglGetProcAddress() could be the very first function called
208 // in which case we must make sure we've initialized ourselves, this
209 // happens the first time egl_get_display() is called.
210
211 clearError();
212
213 if (egl_init_drivers() == EGL_FALSE) {
214 setError(EGL_BAD_PARAMETER, NULL);
215 return nullptr;
216 }
217
218 egl_connection_t* const cnx = &gEGLImpl;
219 return cnx->platform.eglGetProcAddress(procname);
220}
221
222EGLBoolean eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface draw, EGLint* rects,
223 EGLint n_rects) {
224 ATRACE_CALL();
225 clearError();
226
227 egl_connection_t* const cnx = &gEGLImpl;
228 return cnx->platform.eglSwapBuffersWithDamageKHR(dpy, draw, rects, n_rects);
229}
230
231EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
232 ATRACE_CALL();
233 clearError();
234
235 egl_connection_t* const cnx = &gEGLImpl;
236 return cnx->platform.eglSwapBuffers(dpy, surface);
237}
238
239EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, NativePixmapType target) {
240 clearError();
241
242 egl_connection_t* const cnx = &gEGLImpl;
243 return cnx->platform.eglCopyBuffers(dpy, surface, target);
244}
245
246const char* eglQueryString(EGLDisplay dpy, EGLint name) {
247 clearError();
248
249 egl_connection_t* const cnx = &gEGLImpl;
250 return cnx->platform.eglQueryString(dpy, name);
251}
252
253extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name) {
254 clearError();
255
256 egl_connection_t* const cnx = &gEGLImpl;
257 return cnx->platform.eglQueryStringImplementationANDROID(dpy, name);
258}
259
260EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
261 clearError();
262
263 egl_connection_t* const cnx = &gEGLImpl;
264 return cnx->platform.eglSurfaceAttrib(dpy, surface, attribute, value);
265}
266
267EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
268 clearError();
269
270 egl_connection_t* const cnx = &gEGLImpl;
271 return cnx->platform.eglBindTexImage(dpy, surface, buffer);
272}
273
274EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
275 clearError();
276
277 egl_connection_t* const cnx = &gEGLImpl;
278 return cnx->platform.eglReleaseTexImage(dpy, surface, buffer);
279}
280
281EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) {
282 clearError();
283
284 egl_connection_t* const cnx = &gEGLImpl;
285 return cnx->platform.eglSwapInterval(dpy, interval);
286}
287
288EGLBoolean eglWaitClient(void) {
289 clearError();
290
291 egl_connection_t* const cnx = &gEGLImpl;
292 return cnx->platform.eglWaitClient();
293}
294
295EGLBoolean eglBindAPI(EGLenum api) {
296 clearError();
297
298 if (egl_init_drivers() == EGL_FALSE) {
299 return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE);
300 }
301
302 egl_connection_t* const cnx = &gEGLImpl;
303 return cnx->platform.eglBindAPI(api);
304}
305
306EGLenum eglQueryAPI(void) {
307 clearError();
308
309 if (egl_init_drivers() == EGL_FALSE) {
310 return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE);
311 }
312
313 egl_connection_t* const cnx = &gEGLImpl;
314 return cnx->platform.eglQueryAPI();
315}
316
317EGLBoolean eglReleaseThread(void) {
318 clearError();
319
320 egl_connection_t* const cnx = &gEGLImpl;
321 return cnx->platform.eglReleaseThread();
322}
323
324EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
325 EGLConfig config, const EGLint* attrib_list) {
326 clearError();
327
328 egl_connection_t* const cnx = &gEGLImpl;
329 return cnx->platform.eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config,
330 attrib_list);
331}
332
333EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface, const EGLint* attrib_list) {
334 clearError();
335
336 egl_connection_t* const cnx = &gEGLImpl;
337 return cnx->platform.eglLockSurfaceKHR(dpy, surface, attrib_list);
338}
339
340EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface) {
341 clearError();
342
343 egl_connection_t* const cnx = &gEGLImpl;
344 return cnx->platform.eglUnlockSurfaceKHR(dpy, surface);
345}
346
347EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
348 EGLClientBuffer buffer, const EGLint* attrib_list) {
349 clearError();
350
351 egl_connection_t* const cnx = &gEGLImpl;
352 return cnx->platform.eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
353}
354
Courtney Goeltzenleuchtere498a2d2018-07-19 17:11:04 -0600355EGLImage eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
356 const EGLAttrib* attrib_list) {
357 clearError();
358
359 egl_connection_t* const cnx = &gEGLImpl;
360 return cnx->platform.eglCreateImage(dpy, ctx, target, buffer, attrib_list);
361}
362
Cody Northrop68d10352018-10-15 07:22:09 -0600363EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img) {
364 clearError();
365
366 egl_connection_t* const cnx = &gEGLImpl;
367 return cnx->platform.eglDestroyImageKHR(dpy, img);
368}
369
Courtney Goeltzenleuchtere498a2d2018-07-19 17:11:04 -0600370EGLBoolean eglDestroyImage(EGLDisplay dpy, EGLImageKHR img) {
371 clearError();
372
373 egl_connection_t* const cnx = &gEGLImpl;
374 return cnx->platform.eglDestroyImage(dpy, img);
375}
376
377// ----------------------------------------------------------------------------
378// EGL_EGLEXT_VERSION 5
379// ----------------------------------------------------------------------------
380
Cody Northrop68d10352018-10-15 07:22:09 -0600381EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list) {
382 clearError();
383
384 egl_connection_t* const cnx = &gEGLImpl;
385 return cnx->platform.eglCreateSyncKHR(dpy, type, attrib_list);
386}
387
388EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) {
389 clearError();
390
391 egl_connection_t* const cnx = &gEGLImpl;
392 return cnx->platform.eglDestroySyncKHR(dpy, sync);
393}
394
395EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {
396 clearError();
397
398 egl_connection_t* const cnx = &gEGLImpl;
399 return cnx->platform.eglSignalSyncKHR(dpy, sync, mode);
400}
401
402EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) {
403 clearError();
404
405 egl_connection_t* const cnx = &gEGLImpl;
406 return cnx->platform.eglClientWaitSyncKHR(dpy, sync, flags, timeout);
407}
408
409EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint* value) {
410 clearError();
411
412 egl_connection_t* const cnx = &gEGLImpl;
413 return cnx->platform.eglGetSyncAttribKHR(dpy, sync, attribute, value);
414}
415
416EGLStreamKHR eglCreateStreamKHR(EGLDisplay dpy, const EGLint* attrib_list) {
417 clearError();
418
419 egl_connection_t* const cnx = &gEGLImpl;
420 return cnx->platform.eglCreateStreamKHR(dpy, attrib_list);
421}
422
423EGLBoolean eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) {
424 clearError();
425
426 egl_connection_t* const cnx = &gEGLImpl;
427 return cnx->platform.eglDestroyStreamKHR(dpy, stream);
428}
429
430EGLBoolean eglStreamAttribKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
431 EGLint value) {
432 clearError();
433
434 egl_connection_t* const cnx = &gEGLImpl;
435 return cnx->platform.eglStreamAttribKHR(dpy, stream, attribute, value);
436}
437
438EGLBoolean eglQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
439 EGLint* value) {
440 clearError();
441
442 egl_connection_t* const cnx = &gEGLImpl;
443 return cnx->platform.eglQueryStreamKHR(dpy, stream, attribute, value);
444}
445
446EGLBoolean eglQueryStreamu64KHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
447 EGLuint64KHR* value) {
448 clearError();
449
450 egl_connection_t* const cnx = &gEGLImpl;
451 return cnx->platform.eglQueryStreamu64KHR(dpy, stream, attribute, value);
452}
453
454EGLBoolean eglQueryStreamTimeKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
455 EGLTimeKHR* value) {
456 clearError();
457
458 egl_connection_t* const cnx = &gEGLImpl;
459 return cnx->platform.eglQueryStreamTimeKHR(dpy, stream, attribute, value);
460}
461
462EGLSurface eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream,
463 const EGLint* attrib_list) {
464 clearError();
465
466 egl_connection_t* const cnx = &gEGLImpl;
467 return cnx->platform.eglCreateStreamProducerSurfaceKHR(dpy, config, stream, attrib_list);
468}
469
470EGLBoolean eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream) {
471 clearError();
472
473 egl_connection_t* const cnx = &gEGLImpl;
474 return cnx->platform.eglStreamConsumerGLTextureExternalKHR(dpy, stream);
475}
476
477EGLBoolean eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream) {
478 clearError();
479
480 egl_connection_t* const cnx = &gEGLImpl;
481 return cnx->platform.eglStreamConsumerAcquireKHR(dpy, stream);
482}
483
484EGLBoolean eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream) {
485 clearError();
486
487 egl_connection_t* const cnx = &gEGLImpl;
488 return cnx->platform.eglStreamConsumerReleaseKHR(dpy, stream);
489}
490
491EGLNativeFileDescriptorKHR eglGetStreamFileDescriptorKHR(EGLDisplay dpy, EGLStreamKHR stream) {
492 clearError();
493
494 egl_connection_t* const cnx = &gEGLImpl;
495 return cnx->platform.eglGetStreamFileDescriptorKHR(dpy, stream);
496}
497
498EGLStreamKHR eglCreateStreamFromFileDescriptorKHR(EGLDisplay dpy,
499 EGLNativeFileDescriptorKHR file_descriptor) {
500 clearError();
501
502 egl_connection_t* const cnx = &gEGLImpl;
503 return cnx->platform.eglCreateStreamFromFileDescriptorKHR(dpy, file_descriptor);
504}
505
506EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
507 clearError();
508 egl_connection_t* const cnx = &gEGLImpl;
509 return cnx->platform.eglWaitSyncKHR(dpy, sync, flags);
510}
511
512EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync) {
513 clearError();
514
515 egl_connection_t* const cnx = &gEGLImpl;
516 return cnx->platform.eglDupNativeFenceFDANDROID(dpy, sync);
517}
518
519EGLBoolean eglPresentationTimeANDROID(EGLDisplay dpy, EGLSurface surface, EGLnsecsANDROID time) {
520 clearError();
521
522 egl_connection_t* const cnx = &gEGLImpl;
523 return cnx->platform.eglPresentationTimeANDROID(dpy, surface, time);
524}
525
526EGLClientBuffer eglGetNativeClientBufferANDROID(const AHardwareBuffer* buffer) {
527 clearError();
528 egl_connection_t* const cnx = &gEGLImpl;
529 return cnx->platform.eglGetNativeClientBufferANDROID(buffer);
530}
531
532EGLuint64NV eglGetSystemTimeFrequencyNV() {
533 clearError();
534
535 if (egl_init_drivers() == EGL_FALSE) {
536 return setError(EGL_BAD_PARAMETER, (EGLuint64NV)EGL_FALSE);
537 }
538
539 egl_connection_t* const cnx = &gEGLImpl;
540 return cnx->platform.eglGetSystemTimeFrequencyNV();
541}
542
543EGLuint64NV eglGetSystemTimeNV() {
544 clearError();
545
546 if (egl_init_drivers() == EGL_FALSE) {
547 return setError(EGL_BAD_PARAMETER, (EGLuint64NV)EGL_FALSE);
548 }
549
550 egl_connection_t* const cnx = &gEGLImpl;
551 return cnx->platform.eglGetSystemTimeNV();
552}
553
554EGLBoolean eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface, EGLint* rects,
555 EGLint n_rects) {
556 clearError();
557
558 egl_connection_t* const cnx = &gEGLImpl;
559 return cnx->platform.eglSetDamageRegionKHR(dpy, surface, rects, n_rects);
560}
561
562EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR* frameId) {
563 clearError();
564
565 egl_connection_t* const cnx = &gEGLImpl;
566 return cnx->platform.eglGetNextFrameIdANDROID(dpy, surface, frameId);
567}
568
569EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps,
570 const EGLint* names, EGLnsecsANDROID* values) {
571 clearError();
572
573 egl_connection_t* const cnx = &gEGLImpl;
574 return cnx->platform.eglGetCompositorTimingANDROID(dpy, surface, numTimestamps, names, values);
575}
576
577EGLBoolean eglGetCompositorTimingSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint name) {
578 clearError();
579
580 egl_connection_t* const cnx = &gEGLImpl;
581 return cnx->platform.eglGetCompositorTimingSupportedANDROID(dpy, surface, name);
582}
583
584EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId,
585 EGLint numTimestamps, const EGLint* timestamps,
586 EGLnsecsANDROID* values) {
587 clearError();
588
589 egl_connection_t* const cnx = &gEGLImpl;
590 return cnx->platform.eglGetFrameTimestampsANDROID(dpy, surface, frameId, numTimestamps,
591 timestamps, values);
592}
593
594EGLBoolean eglGetFrameTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface,
595 EGLint timestamp) {
596 clearError();
597
598 egl_connection_t* const cnx = &gEGLImpl;
599 return cnx->platform.eglGetFrameTimestampSupportedANDROID(dpy, surface, timestamp);
600}