| 1 | /** |
| 2 | * |
| 3 | * EGLPORT.C |
| 4 | * Copyright (C) 2011-2013 Scott R. Smith |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 7 | * of this software and associated documentation files (the "Software"), to deal |
| 8 | * in the Software without restriction, including without limitation the rights |
| 9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 10 | * copies of the Software, and to permit persons to whom the Software is |
| 11 | * furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in |
| 14 | * all copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 22 | * THE SOFTWARE. |
| 23 | * |
| 24 | */ |
| 25 | |
| 26 | #include "eglport.h" |
| 27 | |
| 28 | #include <stdio.h> |
| 29 | #include <stdlib.h> |
| 30 | |
| 31 | #define USE_EGL_SDL 1 |
| 32 | #define USE_GLES2 1 |
| 33 | |
| 34 | #if defined(USE_EGL_SDL) |
| 35 | #include "SDL.h" |
| 36 | #include "SDL_syswm.h" |
| 37 | SDL_SysWMinfo sysWmInfo; /** Holds our X Display/Window information */ |
| 38 | #endif /* USE_EGL_SDL */ |
| 39 | |
| 40 | #if defined(PANDORA) /* Pandora VSync Support */ |
| 41 | #include <unistd.h> |
| 42 | #include <fcntl.h> |
| 43 | #include <sys/ioctl.h> |
| 44 | #include <linux/fb.h> |
| 45 | |
| 46 | #ifndef FBIO_WAITFORVSYNC |
| 47 | #define FBIO_WAITFORVSYNC _IOW('F', 0x20, __u32) |
| 48 | #endif |
| 49 | int fbdev = -1; |
| 50 | |
| 51 | #elif defined(RPI) |
| 52 | #include "bcm_host.h" |
| 53 | #endif /* PANDORA */ |
| 54 | |
| 55 | enum EGL_RENDER_T { |
| 56 | RENDER_RAW=0, /** Sets render mode to raw or framebuffer mode. */ |
| 57 | RENDER_SDL, /** Sets render mode to X11/SDL mode. */ |
| 58 | RENDER_TOTAL |
| 59 | }; |
| 60 | |
| 61 | enum EGL_SETTINGS_T { |
| 62 | CFG_MODE=0, /** Render mode for EGL 0=RAW 1=SDL. */ |
| 63 | CFG_VSYNC, /** Controls system vsync if available. */ |
| 64 | CFG_FSAA, /** Number of samples for full screen AA. 0 is off, 2/4 samples. */ |
| 65 | CFG_FPS, /** Calculate and report frame per second. */ |
| 66 | CFG_RED_SIZE, /** Number of bits of Red in the color buffer. */ |
| 67 | CFG_GREEN_SIZE, /** Number of bits of Green in the color buffer. */ |
| 68 | CFG_BLUE_SIZE, /** Number of bits of Blue in the color buffer. */ |
| 69 | CFG_ALPHA_SIZE, /** Number of bits of Alpha in the color buffer. */ |
| 70 | CFG_DEPTH_SIZE, /** Number of bits of Z in the depth buffer. */ |
| 71 | CFG_BUFFER_SIZE, /** The total color component bits in the color buffer. */ |
| 72 | CFG_STENCIL_SIZE, /** Number of bits of Stencil in the stencil buffer. */ |
| 73 | CFG_TOTAL /** Total number of settings. */ |
| 74 | }; |
| 75 | |
| 76 | NativeDisplayType nativeDisplay = 0; /** Reference to the systems native display */ |
| 77 | NativeWindowType nativeWindow = 0; /** Reference to the systems native window */ |
| 78 | EGLint eglSettings[CFG_TOTAL]; /** Stores setting values. */ |
| 79 | EGLDisplay eglDisplay = NULL; /** Reference to the EGL display */ |
| 80 | EGLConfig eglConfig = NULL; /** Reference to the EGL config */ |
| 81 | EGLContext eglContext = NULL; /** Reference to the EGL context */ |
| 82 | EGLSurface eglSurface = NULL; /** Reference to the EGL surface */ |
| 83 | |
| 84 | #define totalConfigsIn 5 /** Total number of configurations to request */ |
| 85 | EGLint totalConfigsFound = 0; /** Total number of configurations matching attributes */ |
| 86 | EGLConfig eglConfigs[totalConfigsIn]; /** Structure containing references to matching configurations */ |
| 87 | |
| 88 | uint32_t fpsCount = 0; /** Total number of frames counted */ |
| 89 | uint32_t fpsTime = 0; /** Start time of frame count measurment */ |
| 90 | |
| 91 | int8_t eglColorbits = 0; |
| 92 | int8_t eglDepthbits = 0; |
| 93 | int8_t eglStencilbits = 0; |
| 94 | |
| 95 | |
| 96 | /** Private API */ |
| 97 | void OpenCfg ( const char* file ); |
| 98 | int8_t ConfigureEGL ( EGLConfig config ); |
| 99 | int8_t FindEGLConfigs ( void ); |
| 100 | int8_t CheckEGLErrors ( const char* file, uint16_t line ); |
| 101 | |
| 102 | int8_t GetNativeDisplay ( void ); |
| 103 | int8_t GetNativeWindow ( uint16_t width, uint16_t height ); |
| 104 | void FreeNativeDisplay ( void ); |
| 105 | void FreeNativeWindow ( void ); |
| 106 | |
| 107 | void Platform_Open ( void ); |
| 108 | void Platform_Close ( void ); |
| 109 | void Platform_VSync ( void ); |
| 110 | uint32_t Platform_GetTicks ( void ); |
| 111 | |
| 112 | static void drm_do_swap(void); |
| 113 | |
| 114 | /** @brief Release all EGL and system resources |
| 115 | */ |
| 116 | void EGL_Close( void ) |
| 117 | { |
| 118 | /* Release EGL resources */ |
| 119 | if (eglDisplay != NULL) |
| 120 | { |
| 121 | peglMakeCurrent( eglDisplay, NULL, NULL, EGL_NO_CONTEXT ); |
| 122 | if (eglContext != NULL) { |
| 123 | peglDestroyContext( eglDisplay, eglContext ); |
| 124 | } |
| 125 | if (eglSurface != NULL) { |
| 126 | peglDestroySurface( eglDisplay, eglSurface ); |
| 127 | } |
| 128 | peglTerminate( eglDisplay ); |
| 129 | } |
| 130 | |
| 131 | eglSurface = NULL; |
| 132 | eglContext = NULL; |
| 133 | eglDisplay = NULL; |
| 134 | |
| 135 | eglColorbits = 0; |
| 136 | eglDepthbits = 0; |
| 137 | eglStencilbits = 0; |
| 138 | |
| 139 | /* Release platform resources */ |
| 140 | FreeNativeWindow(); |
| 141 | FreeNativeDisplay(); |
| 142 | Platform_Close(); |
| 143 | |
| 144 | CheckEGLErrors( __FILE__, __LINE__ ); |
| 145 | |
| 146 | printf( "EGLport: Closed\n" ); |
| 147 | } |
| 148 | |
| 149 | /** @brief Swap the surface buffer onto the display |
| 150 | */ |
| 151 | void EGL_SwapBuffers( void ) |
| 152 | { |
| 153 | if (eglSettings[CFG_VSYNC] != 0) { |
| 154 | Platform_VSync(); |
| 155 | } |
| 156 | |
| 157 | peglSwapBuffers( eglDisplay, eglSurface ); |
| 158 | drm_do_swap(); |
| 159 | |
| 160 | if (eglSettings[CFG_FPS] != 0) { |
| 161 | fpsCount++; |
| 162 | |
| 163 | if (fpsTime - Platform_GetTicks() >= 1000) |
| 164 | { |
| 165 | printf( "EGLport: %d fps\n", fpsCount ); |
| 166 | fpsTime = Platform_GetTicks(); |
| 167 | fpsCount = 0; |
| 168 | } |
| 169 | } |
| 170 | } |
| 171 | |
| 172 | /** @brief Obtain the system display and initialize EGL |
| 173 | * @param width : desired pixel width of the window (not used by all platforms) |
| 174 | * @param height : desired pixel height of the window (not used by all platforms) |
| 175 | * @return : 0 if the function passed, else 1 |
| 176 | */ |
| 177 | int8_t EGL_Open( uint16_t width, uint16_t height ) |
| 178 | { |
| 179 | EGLint eglMajorVer, eglMinorVer; |
| 180 | EGLBoolean result; |
| 181 | uint32_t configIndex = 0; |
| 182 | const char* output; |
| 183 | |
| 184 | static const EGLint contextAttribs[] = |
| 185 | { |
| 186 | #if defined(USE_GLES2) |
| 187 | EGL_CONTEXT_CLIENT_VERSION, 2, |
| 188 | #endif |
| 189 | EGL_NONE |
| 190 | }; |
| 191 | |
| 192 | #if defined(DEBUG) |
| 193 | printf( "EGLport Warning: DEBUG is enabled which may effect performance\n" ); |
| 194 | #endif |
| 195 | |
| 196 | /* Check that system is not open */ |
| 197 | if (eglDisplay != NULL || eglContext != NULL || eglSurface != NULL) |
| 198 | { |
| 199 | printf( "EGLport ERROR: EGL system is already open!\n" ); |
| 200 | return 1; |
| 201 | } |
| 202 | |
| 203 | /* Check for the cfg file to alternative settings */ |
| 204 | OpenCfg( "eglport.cfg" ); |
| 205 | |
| 206 | /* Setup any platform specific bits */ |
| 207 | Platform_Open(); |
| 208 | |
| 209 | printf( "EGLport: Opening EGL display\n" ); |
| 210 | if (GetNativeDisplay() != 0) |
| 211 | { |
| 212 | printf( "EGLport ERROR: Unable to obtain native display!\n" ); |
| 213 | return 1; |
| 214 | } |
| 215 | |
| 216 | eglDisplay = peglGetDisplay( nativeDisplay ); |
| 217 | if (eglDisplay == EGL_NO_DISPLAY) |
| 218 | { |
| 219 | CheckEGLErrors( __FILE__, __LINE__ ); |
| 220 | printf( "EGLport ERROR: Unable to create EGL display.\n" ); |
| 221 | return 1; |
| 222 | } |
| 223 | |
| 224 | printf( "EGLport: Initializing\n" ); |
| 225 | result = peglInitialize( eglDisplay, &eglMajorVer, &eglMinorVer ); |
| 226 | if (result != EGL_TRUE ) |
| 227 | { |
| 228 | CheckEGLErrors( __FILE__, __LINE__ ); |
| 229 | printf( "EGLport ERROR: Unable to initialize EGL display.\n" ); |
| 230 | return 1; |
| 231 | } |
| 232 | |
| 233 | /* Get EGL Library Information */ |
| 234 | printf( "EGL Implementation Version: Major %d Minor %d\n", eglMajorVer, eglMinorVer ); |
| 235 | output = peglQueryString( eglDisplay, EGL_VENDOR ); |
| 236 | printf( "EGL_VENDOR: %s\n", output ); |
| 237 | output = peglQueryString( eglDisplay, EGL_VERSION ); |
| 238 | printf( "EGL_VERSION: %s\n", output ); |
| 239 | output = peglQueryString( eglDisplay, EGL_EXTENSIONS ); |
| 240 | printf( "EGL_EXTENSIONS: %s\n", output ); |
| 241 | |
| 242 | if (FindEGLConfigs() != 0) |
| 243 | { |
| 244 | printf( "EGLport ERROR: Unable to configure EGL. See previous error.\n" ); |
| 245 | return 1; |
| 246 | } |
| 247 | |
| 248 | printf( "EGLport: Using Config %d\n", configIndex ); |
| 249 | #if defined(EGL_VERSION_1_2) |
| 250 | /* Bind GLES and create the context */ |
| 251 | printf( "EGLport: Binding API\n" ); |
| 252 | result = peglBindAPI( EGL_OPENGL_ES_API ); |
| 253 | if ( result == EGL_FALSE ) |
| 254 | { |
| 255 | CheckEGLErrors( __FILE__, __LINE__ ); |
| 256 | printf( "EGLport ERROR: Could not bind EGL API.\n" ); |
| 257 | return 1; |
| 258 | } |
| 259 | #endif /* EGL_VERSION_1_2 */ |
| 260 | |
| 261 | printf( "EGLport: Creating Context\n" ); |
| 262 | eglContext = peglCreateContext( eglDisplay, eglConfigs[configIndex], NULL, contextAttribs ); |
| 263 | if (eglContext == EGL_NO_CONTEXT) |
| 264 | { |
| 265 | CheckEGLErrors( __FILE__, __LINE__ ); |
| 266 | printf( "EGLport ERROR: Unable to create GLES context!\n"); |
| 267 | return 1; |
| 268 | } |
| 269 | |
| 270 | printf( "EGLport: Creating window surface\n" ); |
| 271 | if (GetNativeWindow( width, height ) != 0) |
| 272 | { |
| 273 | printf( "EGLport ERROR: Unable to obtain native window!\n" ); |
| 274 | return 1; |
| 275 | } |
| 276 | |
| 277 | eglSurface = peglCreateWindowSurface( eglDisplay, eglConfigs[configIndex], nativeWindow, 0 ); |
| 278 | if (eglSurface == EGL_NO_SURFACE) |
| 279 | { |
| 280 | CheckEGLErrors( __FILE__, __LINE__ ); |
| 281 | printf( "EGLport ERROR: Unable to create EGL surface!\n" ); |
| 282 | return 1; |
| 283 | } |
| 284 | |
| 285 | printf( "EGLport: Making Current\n" ); |
| 286 | result = peglMakeCurrent( eglDisplay, eglSurface, eglSurface, eglContext ); |
| 287 | if (result != EGL_TRUE) |
| 288 | { |
| 289 | CheckEGLErrors( __FILE__, __LINE__ ); |
| 290 | printf( "EGLport ERROR: Unable to make GLES context current\n" ); |
| 291 | return 1; |
| 292 | } |
| 293 | |
| 294 | { |
| 295 | EGLint color, depth, stencil; |
| 296 | eglGetConfigAttrib(eglDisplay, eglConfigs[configIndex], EGL_BUFFER_SIZE, &color); |
| 297 | eglGetConfigAttrib(eglDisplay, eglConfigs[configIndex], EGL_DEPTH_SIZE, &depth); |
| 298 | eglGetConfigAttrib(eglDisplay, eglConfigs[configIndex], EGL_STENCIL_SIZE, &stencil); |
| 299 | eglColorbits = (color==16)?5:8; //quick hack |
| 300 | eglDepthbits = depth; |
| 301 | eglStencilbits = stencil; |
| 302 | } |
| 303 | |
| 304 | printf( "EGLport: Setting swap interval\n" ); |
| 305 | peglSwapInterval( eglDisplay, (eglSettings[CFG_VSYNC] > 0) ? 1 : 0 ); |
| 306 | |
| 307 | printf( "EGLport: Complete\n" ); |
| 308 | |
| 309 | CheckEGLErrors( __FILE__, __LINE__ ); |
| 310 | |
| 311 | return 0; |
| 312 | } |
| 313 | |
| 314 | /** @brief Read settings that configure how to use EGL |
| 315 | * @param file : name of the config file |
| 316 | */ |
| 317 | void OpenCfg ( const char* file ) |
| 318 | { |
| 319 | #define MAX_STRING 20 |
| 320 | #define MAX_SIZE 100 |
| 321 | uint8_t i; |
| 322 | FILE* fp = NULL; |
| 323 | char* location = NULL; |
| 324 | char eglStrings[CFG_TOTAL][MAX_STRING]; |
| 325 | char buffer[MAX_SIZE]; |
| 326 | |
| 327 | strncpy( eglStrings[CFG_MODE], "egl_mode=", MAX_STRING ); |
| 328 | strncpy( eglStrings[CFG_VSYNC], "use_vsync=", MAX_STRING ); |
| 329 | strncpy( eglStrings[CFG_FSAA], "use_fsaa=", MAX_STRING ); |
| 330 | strncpy( eglStrings[CFG_RED_SIZE], "size_red=", MAX_STRING ); |
| 331 | strncpy( eglStrings[CFG_GREEN_SIZE], "size_green=", MAX_STRING ); |
| 332 | strncpy( eglStrings[CFG_BLUE_SIZE], "size_blue=", MAX_STRING ); |
| 333 | strncpy( eglStrings[CFG_ALPHA_SIZE], "size_alpha=", MAX_STRING ); |
| 334 | strncpy( eglStrings[CFG_DEPTH_SIZE], "size_depth=", MAX_STRING ); |
| 335 | strncpy( eglStrings[CFG_BUFFER_SIZE], "size_buffer=", MAX_STRING ); |
| 336 | strncpy( eglStrings[CFG_STENCIL_SIZE], "size_stencil=", MAX_STRING ); |
| 337 | |
| 338 | /* Set defaults */ |
| 339 | //#if defined(USE_EGL_SDL) |
| 340 | // eglSettings[CFG_MODE] = RENDER_SDL; |
| 341 | //#else |
| 342 | eglSettings[CFG_MODE] = RENDER_RAW; |
| 343 | //#endif |
| 344 | eglSettings[CFG_VSYNC] = 0; |
| 345 | eglSettings[CFG_FSAA] = 0; |
| 346 | eglSettings[CFG_FPS] = 0; |
| 347 | eglSettings[CFG_RED_SIZE] = 5; |
| 348 | eglSettings[CFG_GREEN_SIZE] = 6; |
| 349 | eglSettings[CFG_BLUE_SIZE] = 5; |
| 350 | eglSettings[CFG_ALPHA_SIZE] = 0; |
| 351 | eglSettings[CFG_DEPTH_SIZE] = 16; |
| 352 | eglSettings[CFG_BUFFER_SIZE] = 16; |
| 353 | eglSettings[CFG_STENCIL_SIZE] = 0; |
| 354 | |
| 355 | /* Parse INI file */ |
| 356 | fp = fopen( file, "r"); |
| 357 | if (fp != NULL) |
| 358 | { |
| 359 | while (fgets( buffer, MAX_SIZE, fp ) != NULL) |
| 360 | { |
| 361 | for (i=0; i<CFG_TOTAL; i++) |
| 362 | { |
| 363 | location = strstr( buffer, eglStrings[i] ); |
| 364 | if (location != NULL) |
| 365 | { |
| 366 | eglSettings[i] = atol( location+strlen( eglStrings[i] ) ); |
| 367 | printf( "EGLport: %s set to %d.\n", eglStrings[i], eglSettings[i] ); |
| 368 | break; |
| 369 | } |
| 370 | } |
| 371 | } |
| 372 | |
| 373 | fclose( fp ); |
| 374 | } |
| 375 | else |
| 376 | { |
| 377 | printf( "EGL NOTICE: Unable to read ini settings from file '%s'. Using defaults\n", file ); |
| 378 | } |
| 379 | } |
| 380 | |
| 381 | /** @brief Find a EGL configuration tht matches the defined attributes |
| 382 | * @return : 0 if the function passed, else 1 |
| 383 | */ |
| 384 | int8_t FindEGLConfigs( void ) |
| 385 | { |
| 386 | EGLBoolean result; |
| 387 | int attrib = 0; |
| 388 | EGLint ConfigAttribs[23]; |
| 389 | |
| 390 | ConfigAttribs[attrib++] = EGL_RED_SIZE; /* 1 */ |
| 391 | ConfigAttribs[attrib++] = eglSettings[CFG_RED_SIZE]; /* 2 */ |
| 392 | ConfigAttribs[attrib++] = EGL_GREEN_SIZE; /* 3 */ |
| 393 | ConfigAttribs[attrib++] = eglSettings[CFG_GREEN_SIZE]; /* 4 */ |
| 394 | ConfigAttribs[attrib++] = EGL_BLUE_SIZE; /* 5 */ |
| 395 | ConfigAttribs[attrib++] = eglSettings[CFG_BLUE_SIZE]; /* 6 */ |
| 396 | ConfigAttribs[attrib++] = EGL_ALPHA_SIZE; /* 7 */ |
| 397 | ConfigAttribs[attrib++] = eglSettings[CFG_ALPHA_SIZE]; /* 8 */ |
| 398 | ConfigAttribs[attrib++] = EGL_DEPTH_SIZE; /* 9 */ |
| 399 | ConfigAttribs[attrib++] = eglSettings[CFG_DEPTH_SIZE]; /* 10 */ |
| 400 | ConfigAttribs[attrib++] = EGL_BUFFER_SIZE; /* 11 */ |
| 401 | ConfigAttribs[attrib++] = eglSettings[CFG_BUFFER_SIZE]; /* 12 */ |
| 402 | ConfigAttribs[attrib++] = EGL_STENCIL_SIZE; /* 13 */ |
| 403 | ConfigAttribs[attrib++] = eglSettings[CFG_STENCIL_SIZE]; /* 14 */ |
| 404 | ConfigAttribs[attrib++] = EGL_SURFACE_TYPE; /* 15 */ |
| 405 | ConfigAttribs[attrib++] = EGL_WINDOW_BIT; /* 16 */ |
| 406 | #if defined(EGL_VERSION_1_2) |
| 407 | ConfigAttribs[attrib++] = EGL_RENDERABLE_TYPE; /* 17 */ |
| 408 | #if defined(USE_GLES1) |
| 409 | ConfigAttribs[attrib++] = EGL_OPENGL_ES_BIT; |
| 410 | #elif defined(USE_GLES2) |
| 411 | ConfigAttribs[attrib++] = EGL_OPENGL_ES2_BIT; /* 18 */ |
| 412 | #endif /* USE_GLES1 */ |
| 413 | #endif /* EGL_VERSION_1_2 */ |
| 414 | ConfigAttribs[attrib++] = EGL_SAMPLE_BUFFERS; /* 19 */ |
| 415 | ConfigAttribs[attrib++] = (eglSettings[CFG_FSAA] > 0) ? 1 : 0; /* 20 */ |
| 416 | ConfigAttribs[attrib++] = EGL_SAMPLES; /* 21 */ |
| 417 | ConfigAttribs[attrib++] = eglSettings[CFG_FSAA]; /* 22 */ |
| 418 | ConfigAttribs[attrib++] = EGL_NONE; /* 23 */ |
| 419 | |
| 420 | result = peglChooseConfig( eglDisplay, ConfigAttribs, eglConfigs, totalConfigsIn, &totalConfigsFound ); |
| 421 | if (result != EGL_TRUE || totalConfigsFound == 0) |
| 422 | { |
| 423 | CheckEGLErrors( __FILE__, __LINE__ ); |
| 424 | printf( "EGLport ERROR: Unable to query for available configs, found %d.\n", totalConfigsFound ); |
| 425 | return 1; |
| 426 | } |
| 427 | printf( "EGLport: Found %d available configs\n", totalConfigsFound ); |
| 428 | |
| 429 | return 0; |
| 430 | } |
| 431 | |
| 432 | /** @brief Error checking function |
| 433 | * @param file : string reference that contains the source file that the check is occuring in |
| 434 | * @param line : numeric reference that contains the line number that the check is occuring in |
| 435 | * @return : 0 if the function passed, else 1 |
| 436 | */ |
| 437 | int8_t CheckEGLErrors( const char* file, uint16_t line ) |
| 438 | { |
| 439 | EGLenum error; |
| 440 | const char* errortext; |
| 441 | const char* description; |
| 442 | |
| 443 | error = eglGetError(); |
| 444 | |
| 445 | if (error != EGL_SUCCESS && error != 0) |
| 446 | { |
| 447 | switch (error) |
| 448 | { |
| 449 | case EGL_NOT_INITIALIZED: |
| 450 | errortext = "EGL_NOT_INITIALIZED."; |
| 451 | description = "EGL is not or could not be initialized, for the specified display."; |
| 452 | break; |
| 453 | case EGL_BAD_ACCESS: |
| 454 | errortext = "EGL_BAD_ACCESS EGL"; |
| 455 | description = "cannot access a requested resource (for example, a context is bound in another thread)."; |
| 456 | break; |
| 457 | case EGL_BAD_ALLOC: |
| 458 | errortext = "EGL_BAD_ALLOC EGL"; |
| 459 | description = "failed to allocate resources for the requested operation."; |
| 460 | break; |
| 461 | case EGL_BAD_ATTRIBUTE: |
| 462 | errortext = "EGL_BAD_ATTRIBUTE"; |
| 463 | description = "An unrecognized attribute or attribute value was passed in anattribute list."; |
| 464 | break; |
| 465 | case EGL_BAD_CONFIG: |
| 466 | errortext = "EGL_BAD_CONFIG"; |
| 467 | description = "An EGLConfig argument does not name a valid EGLConfig."; |
| 468 | break; |
| 469 | case EGL_BAD_CONTEXT: |
| 470 | errortext = "EGL_BAD_CONTEXT"; |
| 471 | description = "An EGLContext argument does not name a valid EGLContext."; |
| 472 | break; |
| 473 | case EGL_BAD_CURRENT_SURFACE: |
| 474 | errortext = "EGL_BAD_CURRENT_SURFACE"; |
| 475 | description = "The current surface of the calling thread is a window, pbuffer,or pixmap that is no longer valid."; |
| 476 | break; |
| 477 | case EGL_BAD_DISPLAY: |
| 478 | errortext = "EGL_BAD_DISPLAY"; |
| 479 | description = "An EGLDisplay argument does not name a valid EGLDisplay."; |
| 480 | break; |
| 481 | case EGL_BAD_MATCH: |
| 482 | errortext = "EGL_BAD_MATCH"; |
| 483 | description = "Arguments are inconsistent; for example, an otherwise valid context requires buffers (e.g. depth or stencil) not allocated by an otherwise valid surface."; |
| 484 | break; |
| 485 | case EGL_BAD_NATIVE_PIXMAP: |
| 486 | errortext = "EGL_BAD_NATIVE_PIXMAP"; |
| 487 | description = "An EGLNativePixmapType argument does not refer to a validnative pixmap."; |
| 488 | break; |
| 489 | case EGL_BAD_NATIVE_WINDOW: |
| 490 | errortext = "EGL_BAD_NATIVE_WINDOW"; |
| 491 | description = "An EGLNativeWindowType argument does not refer to a validnative window."; |
| 492 | break; |
| 493 | case EGL_BAD_PARAMETER: |
| 494 | errortext = "EGL_BAD_PARAMETER"; |
| 495 | description = "One or more argument values are invalid."; |
| 496 | break; |
| 497 | case EGL_BAD_SURFACE: |
| 498 | errortext = "EGL_BAD_SURFACE"; |
| 499 | description = "An EGLSurface argument does not name a valid surface (window,pbuffer, or pixmap) configured for rendering"; |
| 500 | break; |
| 501 | case EGL_CONTEXT_LOST: |
| 502 | errortext = "EGL_CONTEXT_LOST"; |
| 503 | description = "A power management event has occurred. The application mustdestroy all contexts and reinitialise client API state and objects to continue rendering."; |
| 504 | break; |
| 505 | default: |
| 506 | errortext = "Unknown EGL Error"; |
| 507 | description = ""; |
| 508 | break; |
| 509 | } |
| 510 | |
| 511 | printf( "EGLport ERROR: EGL Error detected in file %s at line %d: %s (0x%X)\n Description: %s\n", file, line, errortext, error, description ); |
| 512 | return 1; |
| 513 | } |
| 514 | |
| 515 | return 0; |
| 516 | } |
| 517 | |
| 518 | #if 0 |
| 519 | |
| 520 | /** @brief Obtain a reference to the system's native display |
| 521 | * @param window : pointer to save the display reference |
| 522 | * @return : 0 if the function passed, else 1 |
| 523 | */ |
| 524 | int8_t GetNativeDisplay( void ) |
| 525 | { |
| 526 | if (eglSettings[CFG_MODE] == RENDER_RAW) /* RAW FB mode */ |
| 527 | { |
| 528 | printf( "EGLport: Using EGL_DEFAULT_DISPLAY\n" ); |
| 529 | nativeDisplay = EGL_DEFAULT_DISPLAY; |
| 530 | } |
| 531 | else if (eglSettings[CFG_MODE] == RENDER_SDL) /* SDL/X11 mode */ |
| 532 | { |
| 533 | #if defined(USE_EGL_SDL) |
| 534 | printf( "EGLport: Opening SDL/X11 display\n" ); |
| 535 | SDL_VERSION(&sysWmInfo.version); |
| 536 | SDL_GetWMInfo(&sysWmInfo); |
| 537 | nativeDisplay = (EGLNativeDisplayType)sysWmInfo.info.x11.display; |
| 538 | |
| 539 | if (nativeDisplay == 0) |
| 540 | { |
| 541 | printf( "EGLport ERROR: unable to get display!\n" ); |
| 542 | return 1; |
| 543 | } |
| 544 | #else |
| 545 | printf( "EGLport ERROR: SDL mode was not enabled in this compile!\n" ); |
| 546 | #endif |
| 547 | } |
| 548 | |
| 549 | return 0; |
| 550 | } |
| 551 | |
| 552 | /** @brief Obtain a reference to the system's native window |
| 553 | * @param width : desired pixel width of the window (not used by all platforms) |
| 554 | * @param height : desired pixel height of the window (not used by all platforms) |
| 555 | * @return : 0 if the function passed, else 1 |
| 556 | */ |
| 557 | int8_t GetNativeWindow( uint16_t width, uint16_t height ) |
| 558 | { |
| 559 | nativeWindow = 0; |
| 560 | |
| 561 | #if defined(WIZ) || defined(CAANOO) |
| 562 | |
| 563 | nativeWindow = (NativeWindowType)malloc(16*1024); |
| 564 | |
| 565 | if(nativeWindow == NULL) { |
| 566 | printf( "EGLport ERROR: Memory for window Failed\n" ); |
| 567 | return 1; |
| 568 | } |
| 569 | |
| 570 | #elif defined(RPI) |
| 571 | |
| 572 | EGLBoolean result; |
| 573 | uint32_t screen_width, screen_height; |
| 574 | static EGL_DISPMANX_WINDOW_T nativewindow; |
| 575 | DISPMANX_ELEMENT_HANDLE_T dispman_element; |
| 576 | DISPMANX_DISPLAY_HANDLE_T dispman_display; |
| 577 | DISPMANX_UPDATE_HANDLE_T dispman_update; |
| 578 | VC_RECT_T dst_rect; |
| 579 | VC_RECT_T src_rect; |
| 580 | |
| 581 | /* create an EGL window surface */ |
| 582 | result = graphics_get_display_size(0 /* LCD */, &screen_width, &screen_height); |
| 583 | if(result < 0) { |
| 584 | printf( "EGLport ERROR: RPi graphicget_display_size failed\n" ); |
| 585 | return 1; |
| 586 | } |
| 587 | |
| 588 | dst_rect.x = 0; |
| 589 | dst_rect.y = 0; |
| 590 | dst_rect.width = screen_width; |
| 591 | dst_rect.height = screen_height; |
| 592 | |
| 593 | src_rect.x = 0; |
| 594 | src_rect.y = 0; |
| 595 | src_rect.width = width << 16; |
| 596 | src_rect.height = height << 16; |
| 597 | |
| 598 | dispman_display = vc_dispmanx_display_open( 0 /* LCD */); |
| 599 | dispman_update = vc_dispmanx_update_start( 0 ); |
| 600 | dispman_element = vc_dispmanx_element_add ( dispman_update, dispman_display, |
| 601 | 0 /*layer*/, &dst_rect, 0 /*src*/, |
| 602 | &src_rect, DISPMANX_PROTECTION_NONE, (VC_DISPMANX_ALPHA_T*)0 /*alpha*/, (DISPMANX_CLAMP_T*)0 /*clamp*/, (DISPMANX_TRANSFORM_T)0 /*transform*/); |
| 603 | |
| 604 | nativewindow.element = dispman_element; |
| 605 | nativewindow.width = screen_width; |
| 606 | nativewindow.height = screen_height; |
| 607 | vc_dispmanx_update_submit_sync( dispman_update ); |
| 608 | |
| 609 | nativeWindow = (NativeWindowType)&nativewindow; |
| 610 | |
| 611 | #else /* default */ |
| 612 | |
| 613 | if (eglSettings[CFG_MODE] == RENDER_RAW) /* RAW FB mode */ |
| 614 | { |
| 615 | nativeWindow = 0; |
| 616 | } |
| 617 | else if(eglSettings[CFG_MODE] == RENDER_SDL) /* SDL/X11 mode */ |
| 618 | { |
| 619 | #if defined(USE_EGL_SDL) |
| 620 | /* SDL_GetWMInfo is populated when display was opened */ |
| 621 | nativeWindow = (NativeWindowType)sysWmInfo.info.x11.window; |
| 622 | |
| 623 | if (nativeWindow == 0) |
| 624 | { |
| 625 | printf( "EGLport ERROR: unable to get window!\n" ); |
| 626 | return 1; |
| 627 | } |
| 628 | #else |
| 629 | printf( "EGLport ERROR: SDL mode was not enabled in this compile!\n" ); |
| 630 | #endif |
| 631 | } |
| 632 | else |
| 633 | { |
| 634 | printf( "EGLport ERROR: Unknown EGL render mode %d!\n", eglSettings[CFG_MODE] ); |
| 635 | return 1; |
| 636 | } |
| 637 | |
| 638 | #endif /* WIZ / CAANOO */ |
| 639 | |
| 640 | return 0; |
| 641 | } |
| 642 | |
| 643 | #else |
| 644 | |
| 645 | #include <xf86drm.h> |
| 646 | #include <xf86drmMode.h> |
| 647 | #include <gbm.h> |
| 648 | #include <errno.h> |
| 649 | |
| 650 | static struct { |
| 651 | struct gbm_device *dev; |
| 652 | struct gbm_surface *surface; |
| 653 | } gbm; |
| 654 | |
| 655 | static struct { |
| 656 | int fd; |
| 657 | uint32_t crtc_id; |
| 658 | uint32_t connector_id; |
| 659 | //struct gbm_bo *bo; |
| 660 | } drm; |
| 661 | |
| 662 | int8_t GetNativeDisplay( void ) |
| 663 | { |
| 664 | drmModeRes *resources; |
| 665 | drmModeConnector *connector; |
| 666 | drmModeEncoder *encoder; |
| 667 | drmModeCrtc *crtc; |
| 668 | int i; |
| 669 | |
| 670 | errno = 0; |
| 671 | |
| 672 | /* init drm */ |
| 673 | drm.fd = drmOpen("omapdrm", NULL); |
| 674 | if (drm.fd < 0) { |
| 675 | perror("DRM: drmOpen omapdrm"); |
| 676 | exit(1); |
| 677 | } |
| 678 | |
| 679 | resources = drmModeGetResources(drm.fd); |
| 680 | if (resources == NULL) { |
| 681 | perror("DRM: drmModeGetResources"); |
| 682 | exit(1); |
| 683 | } |
| 684 | |
| 685 | /* find a connected connector: */ |
| 686 | for (i = 0; i < resources->count_connectors; i++) { |
| 687 | connector = drmModeGetConnector(drm.fd, resources->connectors[i]); |
| 688 | if (connector->connection == DRM_MODE_CONNECTED) |
| 689 | break; |
| 690 | drmModeFreeConnector(connector); |
| 691 | connector = NULL; |
| 692 | } |
| 693 | |
| 694 | if (connector == NULL) { |
| 695 | fprintf(stderr, "DRM: no connected connector\n"); |
| 696 | exit(1); |
| 697 | } |
| 698 | |
| 699 | encoder = drmModeGetEncoder(drm.fd, connector->encoder_id); |
| 700 | if (encoder == NULL) { |
| 701 | fprintf(stderr, "DRM: drmModeGetEncoder failed\n"); |
| 702 | exit(1); |
| 703 | } |
| 704 | |
| 705 | crtc = drmModeGetCrtc(drm.fd, encoder->crtc_id); |
| 706 | if (crtc == NULL) { |
| 707 | fprintf(stderr, "DRM: drmModeGetCrtc failed\n"); |
| 708 | exit(1); |
| 709 | } |
| 710 | |
| 711 | drm.crtc_id = encoder->crtc_id; |
| 712 | drm.connector_id = connector->connector_id; |
| 713 | |
| 714 | /* init gbm */ |
| 715 | gbm.dev = gbm_create_device(drm.fd); |
| 716 | if (gbm.dev == NULL) { |
| 717 | fprintf(stderr, "DRM: gbm_create_device failed\n"); |
| 718 | exit(1); |
| 719 | } |
| 720 | |
| 721 | gbm.surface = gbm_surface_create(gbm.dev, |
| 722 | crtc->width, crtc->height, |
| 723 | GBM_FORMAT_XRGB8888, |
| 724 | GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING); |
| 725 | if (!gbm.surface) { |
| 726 | fprintf(stderr, "DRM: failed to create gbm surface\n"); |
| 727 | exit(1); |
| 728 | } |
| 729 | |
| 730 | nativeDisplay = (EGLNativeDisplayType)gbm.dev; |
| 731 | nativeWindow = (NativeWindowType)gbm.surface; |
| 732 | |
| 733 | #if 0 |
| 734 | drm.bo = gbm_surface_lock_front_buffer(gbm.surface); |
| 735 | if (drm.bo == NULL) { |
| 736 | fprintf(stderr, "DRM: no initial bo?\n"); |
| 737 | exit(1); |
| 738 | } |
| 739 | #endif |
| 740 | |
| 741 | //ret = drmModeSetCrtc(drm.fd, drm.crtc_id, fb->fb_id, 0, 0, |
| 742 | // &drm.connector_id, 1, drm.mode); |
| 743 | |
| 744 | return 0; |
| 745 | } |
| 746 | |
| 747 | int8_t GetNativeWindow( uint16_t width, uint16_t height ) |
| 748 | { |
| 749 | /* already have nativeWindow, ignore width, height */ |
| 750 | return 0; |
| 751 | } |
| 752 | |
| 753 | static void |
| 754 | drm_fb_destroy_callback(struct gbm_bo *bo, void *data) |
| 755 | { |
| 756 | uint32_t fb_id = (uint32_t)(long)data; |
| 757 | |
| 758 | if (fb_id) |
| 759 | drmModeRmFB(drm.fd, fb_id); |
| 760 | } |
| 761 | |
| 762 | static uint32_t drm_fb_get_from_bo(struct gbm_bo *bo) |
| 763 | { |
| 764 | uint32_t fb_id = (uint32_t)(long)gbm_bo_get_user_data(bo); |
| 765 | uint32_t width, height, stride, handle; |
| 766 | int ret; |
| 767 | |
| 768 | if (fb_id) |
| 769 | return fb_id; |
| 770 | |
| 771 | width = gbm_bo_get_width(bo); |
| 772 | height = gbm_bo_get_height(bo); |
| 773 | stride = gbm_bo_get_stride(bo); |
| 774 | handle = gbm_bo_get_handle(bo).u32; |
| 775 | |
| 776 | ret = drmModeAddFB(drm.fd, width, height, 24, 32, stride, handle, &fb_id); |
| 777 | if (ret) { |
| 778 | printf("failed to create fb: %s\n", strerror(errno)); |
| 779 | return 0; |
| 780 | } |
| 781 | |
| 782 | gbm_bo_set_user_data(bo, (void *)(long)fb_id, drm_fb_destroy_callback); |
| 783 | |
| 784 | return fb_id; |
| 785 | } |
| 786 | |
| 787 | static void page_flip_handler(int fd, unsigned int frame, |
| 788 | unsigned int sec, unsigned int usec, void *data) |
| 789 | { |
| 790 | int *waiting_for_flip = (int *)data; |
| 791 | *waiting_for_flip = 0; |
| 792 | } |
| 793 | |
| 794 | /* to be called after eglSwapBuffers */ |
| 795 | static void drm_do_swap(void) |
| 796 | { |
| 797 | drmEventContext evctx = { 0, }; |
| 798 | int waiting_for_flip = 1; |
| 799 | struct gbm_bo *bo; |
| 800 | uint32_t fb_id; |
| 801 | fd_set fds; |
| 802 | int ret; |
| 803 | |
| 804 | bo = gbm_surface_lock_front_buffer(gbm.surface); |
| 805 | fb_id = drm_fb_get_from_bo(bo); |
| 806 | |
| 807 | ret = drmModePageFlip(drm.fd, drm.crtc_id, fb_id, |
| 808 | DRM_MODE_PAGE_FLIP_EVENT, &waiting_for_flip); |
| 809 | if (ret) |
| 810 | fprintf(stderr, "page flip error: %d %d\n", ret, errno); |
| 811 | |
| 812 | FD_ZERO(&fds); |
| 813 | //FD_SET(0, &fds); |
| 814 | FD_SET(drm.fd, &fds); |
| 815 | |
| 816 | evctx.version = DRM_EVENT_CONTEXT_VERSION; |
| 817 | evctx.page_flip_handler = page_flip_handler; |
| 818 | |
| 819 | while (waiting_for_flip) { |
| 820 | ret = select(drm.fd + 1, &fds, NULL, NULL, NULL); |
| 821 | if (ret <= 0) { |
| 822 | perror("select"); |
| 823 | return; |
| 824 | #if 0 |
| 825 | } else if (FD_ISSET(0, &fds)) { |
| 826 | printf("user interrupted!\n"); |
| 827 | exit(1); // ? |
| 828 | #endif |
| 829 | } |
| 830 | drmHandleEvent(drm.fd, &evctx); |
| 831 | } |
| 832 | |
| 833 | gbm_surface_release_buffer(gbm.surface, bo); |
| 834 | } |
| 835 | |
| 836 | #endif |
| 837 | |
| 838 | /** @brief Release the system's native display |
| 839 | */ |
| 840 | void FreeNativeDisplay( void ) |
| 841 | { |
| 842 | } |
| 843 | |
| 844 | /** @brief Release the system's native window |
| 845 | */ |
| 846 | void FreeNativeWindow( void ) |
| 847 | { |
| 848 | #if defined(WIZ) || defined(CAANOO) |
| 849 | if (nativeWindow != NULL) { |
| 850 | free( nativeWindow ); |
| 851 | } |
| 852 | nativeWindow = NULL; |
| 853 | #endif /* WIZ / CAANOO */ |
| 854 | } |
| 855 | |
| 856 | /** @brief Open any system specific resources |
| 857 | */ |
| 858 | void Platform_Open( void ) |
| 859 | { |
| 860 | #if defined(PANDORA) |
| 861 | /* Pandora VSync */ |
| 862 | fbdev = open( "/dev/fb0", O_RDONLY /* O_RDWR */ ); |
| 863 | if ( fbdev < 0 ) { |
| 864 | printf( "EGLport ERROR: Couldn't open /dev/fb0 for Pandora Vsync\n" ); |
| 865 | } |
| 866 | #elif defined(RPI) |
| 867 | bcm_host_init(); |
| 868 | #endif /* PANDORA */ |
| 869 | } |
| 870 | |
| 871 | /** @brief Release any system specific resources |
| 872 | */ |
| 873 | void Platform_Close( void ) |
| 874 | { |
| 875 | #if defined(PANDORA) |
| 876 | /* Pandora VSync */ |
| 877 | close( fbdev ); |
| 878 | fbdev = -1; |
| 879 | #endif /* PANDORA */ |
| 880 | } |
| 881 | |
| 882 | /** @brief Check the systems vsync state |
| 883 | */ |
| 884 | void Platform_VSync( void ) |
| 885 | { |
| 886 | #if defined(PANDORA) |
| 887 | /* Pandora VSync */ |
| 888 | if (fbdev >= 0) { |
| 889 | int arg = 0; |
| 890 | ioctl( fbdev, FBIO_WAITFORVSYNC, &arg ); |
| 891 | } |
| 892 | #endif /* PANDORA */ |
| 893 | } |
| 894 | |
| 895 | /** @brief Get the system tick time (ms) |
| 896 | */ |
| 897 | uint32_t Platform_GetTicks( void ) |
| 898 | { |
| 899 | uint32_t ticks = 0; |
| 900 | #if defined(USE_EGL_SDL) |
| 901 | ticks = SDL_GetTicks(); |
| 902 | #else |
| 903 | printf( "EGLport ERROR: SDL mode was not enabled in this compile!\n" ); |
| 904 | #endif |
| 905 | return ticks; |
| 906 | } |
| 907 | |
| 908 | // vim:ts=4:sw=4:expandtab |