blob: e3c708dc478f2eb98677f777dcd5e45ae9d9e655 [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
355EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img) {
356 clearError();
357
358 egl_connection_t* const cnx = &gEGLImpl;
359 return cnx->platform.eglDestroyImageKHR(dpy, img);
360}
361
362EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list) {
363 clearError();
364
365 egl_connection_t* const cnx = &gEGLImpl;
366 return cnx->platform.eglCreateSyncKHR(dpy, type, attrib_list);
367}
368
369EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) {
370 clearError();
371
372 egl_connection_t* const cnx = &gEGLImpl;
373 return cnx->platform.eglDestroySyncKHR(dpy, sync);
374}
375
376EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {
377 clearError();
378
379 egl_connection_t* const cnx = &gEGLImpl;
380 return cnx->platform.eglSignalSyncKHR(dpy, sync, mode);
381}
382
383EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) {
384 clearError();
385
386 egl_connection_t* const cnx = &gEGLImpl;
387 return cnx->platform.eglClientWaitSyncKHR(dpy, sync, flags, timeout);
388}
389
390EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint* value) {
391 clearError();
392
393 egl_connection_t* const cnx = &gEGLImpl;
394 return cnx->platform.eglGetSyncAttribKHR(dpy, sync, attribute, value);
395}
396
397EGLStreamKHR eglCreateStreamKHR(EGLDisplay dpy, const EGLint* attrib_list) {
398 clearError();
399
400 egl_connection_t* const cnx = &gEGLImpl;
401 return cnx->platform.eglCreateStreamKHR(dpy, attrib_list);
402}
403
404EGLBoolean eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) {
405 clearError();
406
407 egl_connection_t* const cnx = &gEGLImpl;
408 return cnx->platform.eglDestroyStreamKHR(dpy, stream);
409}
410
411EGLBoolean eglStreamAttribKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
412 EGLint value) {
413 clearError();
414
415 egl_connection_t* const cnx = &gEGLImpl;
416 return cnx->platform.eglStreamAttribKHR(dpy, stream, attribute, value);
417}
418
419EGLBoolean eglQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
420 EGLint* value) {
421 clearError();
422
423 egl_connection_t* const cnx = &gEGLImpl;
424 return cnx->platform.eglQueryStreamKHR(dpy, stream, attribute, value);
425}
426
427EGLBoolean eglQueryStreamu64KHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
428 EGLuint64KHR* value) {
429 clearError();
430
431 egl_connection_t* const cnx = &gEGLImpl;
432 return cnx->platform.eglQueryStreamu64KHR(dpy, stream, attribute, value);
433}
434
435EGLBoolean eglQueryStreamTimeKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
436 EGLTimeKHR* value) {
437 clearError();
438
439 egl_connection_t* const cnx = &gEGLImpl;
440 return cnx->platform.eglQueryStreamTimeKHR(dpy, stream, attribute, value);
441}
442
443EGLSurface eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream,
444 const EGLint* attrib_list) {
445 clearError();
446
447 egl_connection_t* const cnx = &gEGLImpl;
448 return cnx->platform.eglCreateStreamProducerSurfaceKHR(dpy, config, stream, attrib_list);
449}
450
451EGLBoolean eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream) {
452 clearError();
453
454 egl_connection_t* const cnx = &gEGLImpl;
455 return cnx->platform.eglStreamConsumerGLTextureExternalKHR(dpy, stream);
456}
457
458EGLBoolean eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream) {
459 clearError();
460
461 egl_connection_t* const cnx = &gEGLImpl;
462 return cnx->platform.eglStreamConsumerAcquireKHR(dpy, stream);
463}
464
465EGLBoolean eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream) {
466 clearError();
467
468 egl_connection_t* const cnx = &gEGLImpl;
469 return cnx->platform.eglStreamConsumerReleaseKHR(dpy, stream);
470}
471
472EGLNativeFileDescriptorKHR eglGetStreamFileDescriptorKHR(EGLDisplay dpy, EGLStreamKHR stream) {
473 clearError();
474
475 egl_connection_t* const cnx = &gEGLImpl;
476 return cnx->platform.eglGetStreamFileDescriptorKHR(dpy, stream);
477}
478
479EGLStreamKHR eglCreateStreamFromFileDescriptorKHR(EGLDisplay dpy,
480 EGLNativeFileDescriptorKHR file_descriptor) {
481 clearError();
482
483 egl_connection_t* const cnx = &gEGLImpl;
484 return cnx->platform.eglCreateStreamFromFileDescriptorKHR(dpy, file_descriptor);
485}
486
487EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
488 clearError();
489 egl_connection_t* const cnx = &gEGLImpl;
490 return cnx->platform.eglWaitSyncKHR(dpy, sync, flags);
491}
492
493EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync) {
494 clearError();
495
496 egl_connection_t* const cnx = &gEGLImpl;
497 return cnx->platform.eglDupNativeFenceFDANDROID(dpy, sync);
498}
499
500EGLBoolean eglPresentationTimeANDROID(EGLDisplay dpy, EGLSurface surface, EGLnsecsANDROID time) {
501 clearError();
502
503 egl_connection_t* const cnx = &gEGLImpl;
504 return cnx->platform.eglPresentationTimeANDROID(dpy, surface, time);
505}
506
507EGLClientBuffer eglGetNativeClientBufferANDROID(const AHardwareBuffer* buffer) {
508 clearError();
509 egl_connection_t* const cnx = &gEGLImpl;
510 return cnx->platform.eglGetNativeClientBufferANDROID(buffer);
511}
512
513EGLuint64NV eglGetSystemTimeFrequencyNV() {
514 clearError();
515
516 if (egl_init_drivers() == EGL_FALSE) {
517 return setError(EGL_BAD_PARAMETER, (EGLuint64NV)EGL_FALSE);
518 }
519
520 egl_connection_t* const cnx = &gEGLImpl;
521 return cnx->platform.eglGetSystemTimeFrequencyNV();
522}
523
524EGLuint64NV eglGetSystemTimeNV() {
525 clearError();
526
527 if (egl_init_drivers() == EGL_FALSE) {
528 return setError(EGL_BAD_PARAMETER, (EGLuint64NV)EGL_FALSE);
529 }
530
531 egl_connection_t* const cnx = &gEGLImpl;
532 return cnx->platform.eglGetSystemTimeNV();
533}
534
535EGLBoolean eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface, EGLint* rects,
536 EGLint n_rects) {
537 clearError();
538
539 egl_connection_t* const cnx = &gEGLImpl;
540 return cnx->platform.eglSetDamageRegionKHR(dpy, surface, rects, n_rects);
541}
542
543EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR* frameId) {
544 clearError();
545
546 egl_connection_t* const cnx = &gEGLImpl;
547 return cnx->platform.eglGetNextFrameIdANDROID(dpy, surface, frameId);
548}
549
550EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps,
551 const EGLint* names, EGLnsecsANDROID* values) {
552 clearError();
553
554 egl_connection_t* const cnx = &gEGLImpl;
555 return cnx->platform.eglGetCompositorTimingANDROID(dpy, surface, numTimestamps, names, values);
556}
557
558EGLBoolean eglGetCompositorTimingSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint name) {
559 clearError();
560
561 egl_connection_t* const cnx = &gEGLImpl;
562 return cnx->platform.eglGetCompositorTimingSupportedANDROID(dpy, surface, name);
563}
564
565EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId,
566 EGLint numTimestamps, const EGLint* timestamps,
567 EGLnsecsANDROID* values) {
568 clearError();
569
570 egl_connection_t* const cnx = &gEGLImpl;
571 return cnx->platform.eglGetFrameTimestampsANDROID(dpy, surface, frameId, numTimestamps,
572 timestamps, values);
573}
574
575EGLBoolean eglGetFrameTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface,
576 EGLint timestamp) {
577 clearError();
578
579 egl_connection_t* const cnx = &gEGLImpl;
580 return cnx->platform.eglGetFrameTimestampSupportedANDROID(dpy, surface, timestamp);
581}