/
SDL_egl.c
476 lines (398 loc) · 14.2 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
* Simple DirectMedia Layer
* Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#if SDL_VIDEO_OPENGL_EGL
#include "SDL_sysvideo.h"
26
27
28
#include "SDL_egl_c.h"
#include "SDL_loadso.h"
#include "SDL_hints.h"
29
30
#if SDL_VIDEO_DRIVER_RPI
31
/* Raspbian places the OpenGL ES/EGL binaries in a non standard path */
32
33
34
35
#define DEFAULT_EGL "/opt/vc/lib/libEGL.so"
#define DEFAULT_OGL_ES2 "/opt/vc/lib/libGLESv2.so"
#define DEFAULT_OGL_ES_PVR "/opt/vc/lib/libGLES_CM.so"
#define DEFAULT_OGL_ES "/opt/vc/lib/libGLESv1_CM.so"
36
37
38
39
40
41
42
43
#elif SDL_VIDEO_DRIVER_ANDROID
/* Android */
#define DEFAULT_EGL "libEGL.so"
#define DEFAULT_OGL_ES2 "libGLESv2.so"
#define DEFAULT_OGL_ES_PVR "libGLES_CM.so"
#define DEFAULT_OGL_ES "libGLESv1_CM.so"
44
45
46
47
48
49
50
#elif SDL_VIDEO_DRIVER_WINDOWS
/* EGL AND OpenGL ES support via ANGLE */
#define DEFAULT_EGL "libEGL.dll"
#define DEFAULT_OGL_ES2 "libGLESv2.dll"
#define DEFAULT_OGL_ES_PVR "libGLES_CM.dll"
#define DEFAULT_OGL_ES "libGLESv1_CM.dll"
51
#else
52
/* Desktop Linux */
53
54
55
56
57
#define DEFAULT_EGL "libEGL.so.1"
#define DEFAULT_OGL_ES2 "libGLESv2.so.2"
#define DEFAULT_OGL_ES_PVR "libGLES_CM.so.1"
#define DEFAULT_OGL_ES "libGLESv1_CM.so.1"
#endif /* SDL_VIDEO_DRIVER_RPI */
58
59
#define LOAD_FUNC(NAME) \
60
*((void**)&_this->egl_data->NAME) = SDL_LoadFunction(_this->egl_data->dll_handle, #NAME); \
61
62
63
64
65
66
67
68
69
70
71
72
73
74
if (!_this->egl_data->NAME) \
{ \
return SDL_SetError("Could not retrieve EGL function " #NAME); \
}
/* EGL implementation of SDL OpenGL ES support */
void *
SDL_EGL_GetProcAddress(_THIS, const char *proc)
{
static char procname[1024];
void *retval;
/* eglGetProcAddress is busted on Android http://code.google.com/p/android/issues/detail?id=7681 */
75
#if !defined(SDL_VIDEO_DRIVER_ANDROID)
76
77
78
79
80
81
82
83
if (_this->egl_data->eglGetProcAddress) {
retval = _this->egl_data->eglGetProcAddress(proc);
if (retval) {
return retval;
}
}
#endif
84
85
retval = SDL_LoadFunction(_this->egl_data->egl_dll_handle, proc);
if (!retval && SDL_strlen(proc) <= 1022) {
86
procname[0] = '_';
87
88
SDL_strlcpy(procname + 1, proc, 1022);
retval = SDL_LoadFunction(_this->egl_data->egl_dll_handle, procname);
89
90
91
92
93
94
95
}
return retval;
}
void
SDL_EGL_UnloadLibrary(_THIS)
{
96
97
98
99
100
101
if (_this->egl_data) {
if (_this->egl_data->egl_display) {
_this->egl_data->eglTerminate(_this->egl_data->egl_display);
_this->egl_data->egl_display = NULL;
}
102
103
104
if (_this->egl_data->dll_handle) {
SDL_UnloadObject(_this->egl_data->dll_handle);
_this->egl_data->dll_handle = NULL;
105
106
}
if (_this->egl_data->egl_dll_handle) {
107
SDL_UnloadObject(_this->egl_data->egl_dll_handle);
108
109
_this->egl_data->egl_dll_handle = NULL;
}
110
111
112
113
114
115
116
SDL_free(_this->egl_data);
_this->egl_data = NULL;
}
}
int
117
SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_display)
118
{
119
120
121
122
123
124
void *dll_handle = NULL, *egl_dll_handle = NULL; /* The naming is counter intuitive, but hey, I just work here -- Gabriel */
char *path = NULL;
#if SDL_VIDEO_DRIVER_WINDOWS
const char *d3dcompiler;
#endif
125
126
127
if (_this->egl_data) {
return SDL_SetError("OpenGL ES context already created");
}
128
129
130
131
132
133
_this->egl_data = (struct SDL_EGL_VideoData *) SDL_calloc(1, sizeof(SDL_EGL_VideoData));
if (!_this->egl_data) {
return SDL_OutOfMemory();
}
134
135
136
137
138
139
140
141
142
#if SDL_VIDEO_DRIVER_WINDOWS
d3dcompiler = SDL_GetHint(SDL_HINT_VIDEO_WIN_D3DCOMPILER);
if (!d3dcompiler) {
/* By default we load the Vista+ compatible compiler */
d3dcompiler = "d3dcompiler_46.dll";
}
if (SDL_strcasecmp(d3dcompiler, "none") != 0) {
SDL_LoadObject(d3dcompiler);
}
143
144
#endif
145
/* A funny thing, loading EGL.so first does not work on the Raspberry, so we load libGL* first */
146
147
148
149
150
151
path = SDL_getenv("SDL_VIDEO_GL_DRIVER");
if (path != NULL) {
egl_dll_handle = SDL_LoadObject(path);
}
if (egl_dll_handle == NULL) {
152
153
if (_this->gl_config.major_version > 1) {
path = DEFAULT_OGL_ES2;
154
155
156
egl_dll_handle = SDL_LoadObject(path);
}
else {
157
path = DEFAULT_OGL_ES;
158
egl_dll_handle = SDL_LoadObject(path);
159
160
if (egl_dll_handle == NULL) {
path = DEFAULT_OGL_ES_PVR;
161
egl_dll_handle = SDL_LoadObject(path);
162
163
164
}
}
}
165
_this->egl_data->egl_dll_handle = egl_dll_handle;
166
167
if (egl_dll_handle == NULL) {
168
return SDL_SetError("Could not initialize OpenGL ES library");
169
}
170
171
/* Loading libGL* in the previous step took care of loading libEGL.so, but we future proof by double checking */
172
173
174
if (egl_path != NULL) {
dll_handle = SDL_LoadObject(egl_path);
}
175
/* Catch the case where the application isn't linked with EGL */
176
177
178
179
180
if ((SDL_LoadFunction(dll_handle, "eglChooseConfig") == NULL) && (egl_path == NULL)) {
if (dll_handle != NULL) {
SDL_UnloadObject(dll_handle);
}
path = SDL_getenv("SDL_VIDEO_EGL_DRIVER");
181
182
183
if (path == NULL) {
path = DEFAULT_EGL;
}
184
185
186
187
dll_handle = SDL_LoadObject(path);
if (dll_handle == NULL) {
return SDL_SetError("Could not load EGL library");
}
188
}
189
190
_this->egl_data->dll_handle = dll_handle;
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
/* Load new function pointers */
LOAD_FUNC(eglGetDisplay);
LOAD_FUNC(eglInitialize);
LOAD_FUNC(eglTerminate);
LOAD_FUNC(eglGetProcAddress);
LOAD_FUNC(eglChooseConfig);
LOAD_FUNC(eglGetConfigAttrib);
LOAD_FUNC(eglCreateContext);
LOAD_FUNC(eglDestroyContext);
LOAD_FUNC(eglCreateWindowSurface);
LOAD_FUNC(eglDestroySurface);
LOAD_FUNC(eglMakeCurrent);
LOAD_FUNC(eglSwapBuffers);
LOAD_FUNC(eglSwapInterval);
LOAD_FUNC(eglWaitNative);
LOAD_FUNC(eglWaitGL);
_this->egl_data->egl_display = _this->egl_data->eglGetDisplay(native_display);
if (!_this->egl_data->egl_display) {
return SDL_SetError("Could not get EGL display");
}
if (_this->egl_data->eglInitialize(_this->egl_data->egl_display, NULL, NULL) != EGL_TRUE) {
return SDL_SetError("Could not initialize EGL");
}
218
_this->egl_data->dll_handle = dll_handle;
219
_this->egl_data->egl_dll_handle = egl_dll_handle;
220
221
222
_this->gl_config.driver_loaded = 1;
if (path) {
223
SDL_strlcpy(_this->gl_config.driver_path, path, sizeof(_this->gl_config.driver_path) - 1);
224
} else {
225
*_this->gl_config.driver_path = '\0';
226
227
228
}
/* We need to select a config here to satisfy some video backends such as X11 */
229
return SDL_EGL_ChooseConfig(_this);
230
231
232
233
234
235
236
}
int
SDL_EGL_ChooseConfig(_THIS)
{
/* 64 seems nice. */
EGLint attribs[64];
237
EGLint found_configs = 0, value;
238
239
/* 128 seems even nicer here */
EGLConfig configs[128];
240
int i, j, best_bitdiff = -1, bitdiff;
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
if (!_this->egl_data) {
/* The EGL library wasn't loaded, SDL_GetError() should have info */
return -1;
}
/* Get a valid EGL configuration */
i = 0;
attribs[i++] = EGL_RED_SIZE;
attribs[i++] = _this->gl_config.red_size;
attribs[i++] = EGL_GREEN_SIZE;
attribs[i++] = _this->gl_config.green_size;
attribs[i++] = EGL_BLUE_SIZE;
attribs[i++] = _this->gl_config.blue_size;
if (_this->gl_config.alpha_size) {
attribs[i++] = EGL_ALPHA_SIZE;
attribs[i++] = _this->gl_config.alpha_size;
}
if (_this->gl_config.buffer_size) {
attribs[i++] = EGL_BUFFER_SIZE;
attribs[i++] = _this->gl_config.buffer_size;
}
attribs[i++] = EGL_DEPTH_SIZE;
attribs[i++] = _this->gl_config.depth_size;
if (_this->gl_config.stencil_size) {
attribs[i++] = EGL_STENCIL_SIZE;
attribs[i++] = _this->gl_config.stencil_size;
}
if (_this->gl_config.multisamplebuffers) {
attribs[i++] = EGL_SAMPLE_BUFFERS;
attribs[i++] = _this->gl_config.multisamplebuffers;
}
if (_this->gl_config.multisamplesamples) {
attribs[i++] = EGL_SAMPLES;
attribs[i++] = _this->gl_config.multisamplesamples;
}
attribs[i++] = EGL_RENDERABLE_TYPE;
if (_this->gl_config.major_version == 2) {
attribs[i++] = EGL_OPENGL_ES2_BIT;
} else {
attribs[i++] = EGL_OPENGL_ES_BIT;
}
attribs[i++] = EGL_NONE;
if (_this->egl_data->eglChooseConfig(_this->egl_data->egl_display,
attribs,
295
configs, SDL_arraysize(configs),
296
297
298
299
300
&found_configs) == EGL_FALSE ||
found_configs == 0) {
return SDL_SetError("Couldn't find matching EGL config");
}
301
302
/* eglChooseConfig returns a number of configurations that match or exceed the requested attribs. */
/* From those, we select the one that matches our requirements more closely via a makeshift algorithm */
303
304
305
for ( i=0; i<found_configs; i++ ) {
bitdiff = 0;
306
for (j = 0; j < SDL_arraysize(attribs) - 1; j += 2) {
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
if (attribs[j] == EGL_NONE) {
break;
}
if ( attribs[j+1] != EGL_DONT_CARE && (
attribs[j] == EGL_RED_SIZE ||
attribs[j] == EGL_GREEN_SIZE ||
attribs[j] == EGL_BLUE_SIZE ||
attribs[j] == EGL_ALPHA_SIZE ||
attribs[j] == EGL_DEPTH_SIZE ||
attribs[j] == EGL_STENCIL_SIZE)) {
_this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], attribs[j], &value);
bitdiff += value - attribs[j + 1]; /* value is always >= attrib */
}
}
if (bitdiff < best_bitdiff || best_bitdiff == -1) {
_this->egl_data->egl_config = configs[i];
best_bitdiff = bitdiff;
}
if (bitdiff == 0) break; /* we found an exact match! */
}
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
return 0;
}
SDL_GLContext
SDL_EGL_CreateContext(_THIS, EGLSurface egl_surface)
{
EGLint context_attrib_list[] = {
EGL_CONTEXT_CLIENT_VERSION,
1,
EGL_NONE
};
EGLContext egl_context;
if (!_this->egl_data) {
/* The EGL library wasn't loaded, SDL_GetError() should have info */
return NULL;
}
if (_this->gl_config.major_version) {
context_attrib_list[1] = _this->gl_config.major_version;
}
egl_context =
_this->egl_data->eglCreateContext(_this->egl_data->egl_display,
_this->egl_data->egl_config,
EGL_NO_CONTEXT, context_attrib_list);
if (egl_context == EGL_NO_CONTEXT) {
SDL_SetError("Could not create EGL context");
return NULL;
}
_this->egl_data->egl_swapinterval = 0;
if (SDL_EGL_MakeCurrent(_this, egl_surface, egl_context) < 0) {
SDL_EGL_DeleteContext(_this, egl_context);
SDL_SetError("Could not make EGL context current");
return NULL;
}
return (SDL_GLContext) egl_context;
}
int
SDL_EGL_MakeCurrent(_THIS, EGLSurface egl_surface, SDL_GLContext context)
{
379
380
EGLContext egl_context = (EGLContext) context;
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
if (!_this->egl_data) {
return SDL_SetError("OpenGL not initialized");
}
/* The android emulator crashes badly if you try to eglMakeCurrent
* with a valid context and invalid surface, so we have to check for both here.
*/
if (!egl_context || !egl_surface) {
_this->egl_data->eglMakeCurrent(_this->egl_data->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
else {
if (!_this->egl_data->eglMakeCurrent(_this->egl_data->egl_display,
egl_surface, egl_surface, egl_context)) {
return SDL_SetError("Unable to make EGL context current");
}
}
return 0;
}
int
SDL_EGL_SetSwapInterval(_THIS, int interval)
{
404
405
EGLBoolean status;
406
407
if (!_this->egl_data) {
return SDL_SetError("EGL not initialized");
408
409
410
411
412
413
414
415
416
417
418
419
420
421
}
status = _this->egl_data->eglSwapInterval(_this->egl_data->egl_display, interval);
if (status == EGL_TRUE) {
_this->egl_data->egl_swapinterval = interval;
return 0;
}
return SDL_SetError("Unable to set the EGL swap interval");
}
int
SDL_EGL_GetSwapInterval(_THIS)
{
422
423
if (!_this->egl_data) {
return SDL_SetError("EGL not initialized");
424
425
426
427
428
429
430
431
432
433
434
435
436
437
}
return _this->egl_data->egl_swapinterval;
}
void
SDL_EGL_SwapBuffers(_THIS, EGLSurface egl_surface)
{
_this->egl_data->eglSwapBuffers(_this->egl_data->egl_display, egl_surface);
}
void
SDL_EGL_DeleteContext(_THIS, SDL_GLContext context)
{
438
439
EGLContext egl_context = (EGLContext) context;
440
441
442
443
444
/* Clean up GLES and EGL */
if (!_this->egl_data) {
return;
}
445
if (egl_context != NULL && egl_context != EGL_NO_CONTEXT) {
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
SDL_EGL_MakeCurrent(_this, NULL, NULL);
_this->egl_data->eglDestroyContext(_this->egl_data->egl_display, egl_context);
}
}
EGLSurface *
SDL_EGL_CreateSurface(_THIS, NativeWindowType nw)
{
return _this->egl_data->eglCreateWindowSurface(
_this->egl_data->egl_display,
_this->egl_data->egl_config,
nw, NULL);
}
void
SDL_EGL_DestroySurface(_THIS, EGLSurface egl_surface)
{
if (!_this->egl_data) {
return;
}
if (egl_surface != EGL_NO_SURFACE) {
_this->egl_data->eglDestroySurface(_this->egl_data->egl_display, egl_surface);
}
}
#endif /* SDL_VIDEO_OPENGL_EGL */
/* vi: set ts=4 sw=4 expandtab: */
476