src/video/pandora/SDL_pandora.c
author Ryan C. Gordon <icculus@icculus.org>
Sun, 31 Mar 2013 12:48:50 -0400
changeset 7037 3fedf1f25b94
parent 6885 700f1b25f77f
child 7191 75360622e65f
permissions -rw-r--r--
Make SDL_SetError and friends unconditionally return -1.

This lets us change things like this...

if (Failed) {
SDL_SetError("We failed");
return -1;
}

...into this...

if (Failed) {
return SDL_SetError("We failed");
}


Fixes Bugzilla #1778.
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 #include "SDL_config.h"
    22 
    23 #if SDL_VIDEO_DRIVER_PANDORA
    24 
    25 /* SDL internals */
    26 #include "../SDL_sysvideo.h"
    27 #include "SDL_version.h"
    28 #include "SDL_syswm.h"
    29 #include "SDL_loadso.h"
    30 #include "SDL_events.h"
    31 #include "../../events/SDL_mouse_c.h"
    32 #include "../../events/SDL_keyboard_c.h"
    33 
    34 /* PND declarations */
    35 #include "SDL_pandora.h"
    36 #include "SDL_pandora_events.h"
    37 
    38 /* WIZ declarations */
    39 #include "GLES/gl.h"
    40 #ifdef WIZ_GLES_LITE
    41 static NativeWindowType hNativeWnd = 0; // A handle to the window we will create.
    42 #endif
    43 
    44 static SDL_bool PND_initialized = SDL_FALSE;
    45 
    46 static int
    47 PND_available(void)
    48 {
    49     return 1;
    50 }
    51 
    52 static void
    53 PND_destroy(SDL_VideoDevice * device)
    54 {
    55     SDL_VideoData *phdata = (SDL_VideoData *) device->driverdata;
    56 
    57     if (device->driverdata != NULL) {
    58         device->driverdata = NULL;
    59     }
    60 }
    61 
    62 static SDL_VideoDevice *
    63 PND_create()
    64 {
    65     SDL_VideoDevice *device;
    66     SDL_VideoData *phdata;
    67     int status;
    68 
    69     /* Check if pandora could be initialized */
    70     status = PND_available();
    71     if (status == 0) {
    72         /* PND could not be used */
    73         return NULL;
    74     }
    75 
    76     /* Initialize SDL_VideoDevice structure */
    77     device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
    78     if (device == NULL) {
    79         SDL_OutOfMemory();
    80         return NULL;
    81     }
    82 
    83     /* Initialize internal Pandora specific data */
    84     phdata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
    85     if (phdata == NULL) {
    86         SDL_OutOfMemory();
    87         SDL_free(device);
    88         return NULL;
    89     }
    90 
    91     device->driverdata = phdata;
    92 
    93     phdata->egl_initialized = SDL_TRUE;
    94 
    95 
    96     /* Setup amount of available displays and current display */
    97     device->num_displays = 0;
    98     device->current_display = 0;
    99 
   100     /* Set device free function */
   101     device->free = PND_destroy;
   102 
   103     /* Setup all functions which we can handle */
   104     device->VideoInit = PND_videoinit;
   105     device->VideoQuit = PND_videoquit;
   106     device->GetDisplayModes = PND_getdisplaymodes;
   107     device->SetDisplayMode = PND_setdisplaymode;
   108     device->CreateWindow = PND_createwindow;
   109     device->CreateWindowFrom = PND_createwindowfrom;
   110     device->SetWindowTitle = PND_setwindowtitle;
   111     device->SetWindowIcon = PND_setwindowicon;
   112     device->SetWindowPosition = PND_setwindowposition;
   113     device->SetWindowSize = PND_setwindowsize;
   114     device->ShowWindow = PND_showwindow;
   115     device->HideWindow = PND_hidewindow;
   116     device->RaiseWindow = PND_raisewindow;
   117     device->MaximizeWindow = PND_maximizewindow;
   118     device->MinimizeWindow = PND_minimizewindow;
   119     device->RestoreWindow = PND_restorewindow;
   120     device->SetWindowGrab = PND_setwindowgrab;
   121     device->DestroyWindow = PND_destroywindow;
   122     device->GetWindowWMInfo = PND_getwindowwminfo;
   123     device->GL_LoadLibrary = PND_gl_loadlibrary;
   124     device->GL_GetProcAddress = PND_gl_getprocaddres;
   125     device->GL_UnloadLibrary = PND_gl_unloadlibrary;
   126     device->GL_CreateContext = PND_gl_createcontext;
   127     device->GL_MakeCurrent = PND_gl_makecurrent;
   128     device->GL_SetSwapInterval = PND_gl_setswapinterval;
   129     device->GL_GetSwapInterval = PND_gl_getswapinterval;
   130     device->GL_SwapWindow = PND_gl_swapwindow;
   131     device->GL_DeleteContext = PND_gl_deletecontext;
   132     device->PumpEvents = PND_PumpEvents;
   133 
   134     /* !!! FIXME: implement SetWindowBordered */
   135 
   136     return device;
   137 }
   138 
   139 VideoBootStrap PND_bootstrap = {
   140 #ifdef WIZ_GLES_LITE
   141     "wiz",
   142     "SDL Wiz Video Driver",
   143 #else
   144     "pandora",
   145     "SDL Pandora Video Driver",
   146 #endif
   147     PND_available,
   148     PND_create
   149 };
   150 
   151 /*****************************************************************************/
   152 /* SDL Video and Display initialization/handling functions                   */
   153 /*****************************************************************************/
   154 int
   155 PND_videoinit(_THIS)
   156 {
   157     SDL_VideoDisplay display;
   158     SDL_DisplayMode current_mode;
   159 
   160     SDL_zero(current_mode);
   161 #ifdef WIZ_GLES_LITE
   162     current_mode.w = 320;
   163     current_mode.h = 240;
   164 #else
   165     current_mode.w = 800;
   166     current_mode.h = 480;
   167 #endif
   168     current_mode.refresh_rate = 60;
   169     current_mode.format = SDL_PIXELFORMAT_RGB565;
   170     current_mode.driverdata = NULL;
   171 
   172     SDL_zero(display);
   173     display.desktop_mode = current_mode;
   174     display.current_mode = current_mode;
   175     display.driverdata = NULL;
   176 
   177     SDL_AddVideoDisplay(&display);
   178 
   179     return 1;
   180 }
   181 
   182 void
   183 PND_videoquit(_THIS)
   184 {
   185 
   186 }
   187 
   188 void
   189 PND_getdisplaymodes(_THIS, SDL_VideoDisplay * display)
   190 {
   191 
   192 }
   193 
   194 int
   195 PND_setdisplaymode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
   196 {
   197     return 0;
   198 }
   199 
   200 int
   201 PND_createwindow(_THIS, SDL_Window * window)
   202 {
   203     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   204 
   205     SDL_WindowData *wdata;
   206 
   207     uint32_t winargc = 0;
   208     int32_t status;
   209 
   210 
   211     /* Allocate window internal data */
   212     wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData));
   213     if (wdata == NULL) {
   214         return SDL_OutOfMemory();
   215     }
   216 
   217     /* Setup driver data for this window */
   218     window->driverdata = wdata;
   219 
   220     /* Check if window must support OpenGL ES rendering */
   221     if ((window->flags & SDL_WINDOW_OPENGL) == SDL_WINDOW_OPENGL) {
   222 
   223         EGLBoolean initstatus;
   224 
   225         /* Mark this window as OpenGL ES compatible */
   226         wdata->uses_gles = SDL_TRUE;
   227 
   228         /* Create connection to OpenGL ES */
   229         if (phdata->egl_display == EGL_NO_DISPLAY) {
   230             phdata->egl_display = eglGetDisplay((NativeDisplayType) 0);
   231             if (phdata->egl_display == EGL_NO_DISPLAY) {
   232                 return SDL_SetError("PND: Can't get connection to OpenGL ES");
   233             }
   234 
   235             initstatus = eglInitialize(phdata->egl_display, NULL, NULL);
   236             if (initstatus != EGL_TRUE) {
   237                 return SDL_SetError("PND: Can't init OpenGL ES library");
   238             }
   239         }
   240 
   241         phdata->egl_refcount++;
   242     }
   243 
   244     /* Window has been successfully created */
   245     return 0;
   246 }
   247 
   248 int
   249 PND_createwindowfrom(_THIS, SDL_Window * window, const void *data)
   250 {
   251     return -1;
   252 }
   253 
   254 void
   255 PND_setwindowtitle(_THIS, SDL_Window * window)
   256 {
   257 }
   258 void
   259 PND_setwindowicon(_THIS, SDL_Window * window, SDL_Surface * icon)
   260 {
   261 }
   262 void
   263 PND_setwindowposition(_THIS, SDL_Window * window)
   264 {
   265 }
   266 void
   267 PND_setwindowsize(_THIS, SDL_Window * window)
   268 {
   269 }
   270 void
   271 PND_showwindow(_THIS, SDL_Window * window)
   272 {
   273 }
   274 void
   275 PND_hidewindow(_THIS, SDL_Window * window)
   276 {
   277 }
   278 void
   279 PND_raisewindow(_THIS, SDL_Window * window)
   280 {
   281 }
   282 void
   283 PND_maximizewindow(_THIS, SDL_Window * window)
   284 {
   285 }
   286 void
   287 PND_minimizewindow(_THIS, SDL_Window * window)
   288 {
   289 }
   290 void
   291 PND_restorewindow(_THIS, SDL_Window * window)
   292 {
   293 }
   294 void
   295 PND_setwindowgrab(_THIS, SDL_Window * window)
   296 {
   297     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   298     eglTerminate(phdata->egl_display);
   299 }
   300 void
   301 PND_destroywindow(_THIS, SDL_Window * window)
   302 {
   303     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   304     eglTerminate(phdata->egl_display);
   305 }
   306 
   307 /*****************************************************************************/
   308 /* SDL Window Manager function                                               */
   309 /*****************************************************************************/
   310 SDL_bool
   311 PND_getwindowwminfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info)
   312 {
   313     if (info->version.major <= SDL_MAJOR_VERSION) {
   314         return SDL_TRUE;
   315     } else {
   316         SDL_SetError("application not compiled with SDL %d.%d\n",
   317                      SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
   318         return SDL_FALSE;
   319     }
   320 
   321     /* Failed to get window manager information */
   322     return SDL_FALSE;
   323 }
   324 
   325 /*****************************************************************************/
   326 /* SDL OpenGL/OpenGL ES functions                                            */
   327 /*****************************************************************************/
   328 int
   329 PND_gl_loadlibrary(_THIS, const char *path)
   330 {
   331     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   332 
   333     /* Check if OpenGL ES library is specified for GF driver */
   334     if (path == NULL) {
   335         path = SDL_getenv("SDL_OPENGL_LIBRARY");
   336         if (path == NULL) {
   337             path = SDL_getenv("SDL_OPENGLES_LIBRARY");
   338         }
   339     }
   340 
   341     /* Check if default library loading requested */
   342     if (path == NULL) {
   343         /* Already linked with GF library which provides egl* subset of  */
   344         /* functions, use Common profile of OpenGL ES library by default */
   345 #ifdef WIZ_GLES_LITE
   346 	path = "/lib/libopengles_lite.so";
   347 #else
   348         path = "/usr/lib/libGLES_CM.so";
   349 #endif
   350     }
   351 
   352     /* Load dynamic library */
   353     _this->gl_config.dll_handle = SDL_LoadObject(path);
   354     if (!_this->gl_config.dll_handle) {
   355         /* Failed to load new GL ES library */
   356         return SDL_SetError("PND: Failed to locate OpenGL ES library");
   357     }
   358 
   359     /* Store OpenGL ES library path and name */
   360     SDL_strlcpy(_this->gl_config.driver_path, path,
   361                 SDL_arraysize(_this->gl_config.driver_path));
   362 
   363     /* New OpenGL ES library is loaded */
   364     return 0;
   365 }
   366 
   367 void *
   368 PND_gl_getprocaddres(_THIS, const char *proc)
   369 {
   370     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   371     void *function_address;
   372 
   373     /* Try to get function address through the egl interface */
   374     function_address = eglGetProcAddress(proc);
   375     if (function_address != NULL) {
   376         return function_address;
   377     }
   378 
   379     /* Then try to get function in the OpenGL ES library */
   380     if (_this->gl_config.dll_handle) {
   381         function_address =
   382             SDL_LoadFunction(_this->gl_config.dll_handle, proc);
   383         if (function_address != NULL) {
   384             return function_address;
   385         }
   386     }
   387 
   388     /* Failed to get GL ES function address pointer */
   389     SDL_SetError("PND: Cannot locate OpenGL ES function name");
   390     return NULL;
   391 }
   392 
   393 void
   394 PND_gl_unloadlibrary(_THIS)
   395 {
   396     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   397 
   398     if (phdata->egl_initialized == SDL_TRUE) {
   399         /* Unload OpenGL ES library */
   400         if (_this->gl_config.dll_handle) {
   401             SDL_UnloadObject(_this->gl_config.dll_handle);
   402             _this->gl_config.dll_handle = NULL;
   403         }
   404     } else {
   405         SDL_SetError("PND: GF initialization failed, no OpenGL ES support");
   406     }
   407 }
   408 
   409 SDL_GLContext
   410 PND_gl_createcontext(_THIS, SDL_Window * window)
   411 {
   412     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   413     SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
   414     SDL_DisplayData *didata =
   415         (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
   416     EGLBoolean status;
   417     int32_t gfstatus;
   418     EGLint configs;
   419     uint32_t attr_pos;
   420     EGLint attr_value;
   421     EGLint cit;
   422 
   423     /* Check if EGL was initialized */
   424     if (phdata->egl_initialized != SDL_TRUE) {
   425         SDL_SetError("PND: EGL initialization failed, no OpenGL ES support");
   426         return NULL;
   427     }
   428 
   429     /* Prepare attributes list to pass them to OpenGL ES */
   430     attr_pos = 0;
   431     wdata->gles_attributes[attr_pos++] = EGL_SURFACE_TYPE;
   432     wdata->gles_attributes[attr_pos++] = EGL_WINDOW_BIT;
   433     wdata->gles_attributes[attr_pos++] = EGL_RED_SIZE;
   434     wdata->gles_attributes[attr_pos++] = _this->gl_config.red_size;
   435     wdata->gles_attributes[attr_pos++] = EGL_GREEN_SIZE;
   436     wdata->gles_attributes[attr_pos++] = _this->gl_config.green_size;
   437     wdata->gles_attributes[attr_pos++] = EGL_BLUE_SIZE;
   438     wdata->gles_attributes[attr_pos++] = _this->gl_config.blue_size;
   439     wdata->gles_attributes[attr_pos++] = EGL_ALPHA_SIZE;
   440 
   441     /* Setup alpha size in bits */
   442     if (_this->gl_config.alpha_size) {
   443         wdata->gles_attributes[attr_pos++] = _this->gl_config.alpha_size;
   444     } else {
   445         wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   446     }
   447 
   448     /* Setup color buffer size */
   449     if (_this->gl_config.buffer_size) {
   450         wdata->gles_attributes[attr_pos++] = EGL_BUFFER_SIZE;
   451         wdata->gles_attributes[attr_pos++] = _this->gl_config.buffer_size;
   452     } else {
   453         wdata->gles_attributes[attr_pos++] = EGL_BUFFER_SIZE;
   454         wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   455     }
   456 
   457     /* Setup depth buffer bits */
   458     wdata->gles_attributes[attr_pos++] = EGL_DEPTH_SIZE;
   459     wdata->gles_attributes[attr_pos++] = _this->gl_config.depth_size;
   460 
   461     /* Setup stencil bits */
   462     if (_this->gl_config.stencil_size) {
   463         wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;
   464         wdata->gles_attributes[attr_pos++] = _this->gl_config.buffer_size;
   465     } else {
   466         wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;
   467         wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   468     }
   469 
   470     /* Set number of samples in multisampling */
   471     if (_this->gl_config.multisamplesamples) {
   472         wdata->gles_attributes[attr_pos++] = EGL_SAMPLES;
   473         wdata->gles_attributes[attr_pos++] =
   474             _this->gl_config.multisamplesamples;
   475     }
   476 
   477     /* Multisample buffers, OpenGL ES 1.0 spec defines 0 or 1 buffer */
   478     if (_this->gl_config.multisamplebuffers) {
   479         wdata->gles_attributes[attr_pos++] = EGL_SAMPLE_BUFFERS;
   480         wdata->gles_attributes[attr_pos++] =
   481             _this->gl_config.multisamplebuffers;
   482     }
   483 
   484     /* Finish attributes list */
   485     wdata->gles_attributes[attr_pos] = EGL_NONE;
   486 
   487     /* Request first suitable framebuffer configuration */
   488     status = eglChooseConfig(phdata->egl_display, wdata->gles_attributes,
   489                              wdata->gles_configs, 1, &configs);
   490     if (status != EGL_TRUE) {
   491         SDL_SetError("PND: Can't find closest configuration for OpenGL ES");
   492         return NULL;
   493     }
   494 
   495     /* Check if nothing has been found, try "don't care" settings */
   496     if (configs == 0) {
   497         int32_t it;
   498         int32_t jt;
   499         GLint depthbits[4] = { 32, 24, 16, EGL_DONT_CARE };
   500 
   501         for (it = 0; it < 4; it++) {
   502             for (jt = 16; jt >= 0; jt--) {
   503                 /* Don't care about color buffer bits, use what exist */
   504                 /* Replace previous set data with EGL_DONT_CARE       */
   505                 attr_pos = 0;
   506                 wdata->gles_attributes[attr_pos++] = EGL_SURFACE_TYPE;
   507                 wdata->gles_attributes[attr_pos++] = EGL_WINDOW_BIT;
   508                 wdata->gles_attributes[attr_pos++] = EGL_RED_SIZE;
   509                 wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   510                 wdata->gles_attributes[attr_pos++] = EGL_GREEN_SIZE;
   511                 wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   512                 wdata->gles_attributes[attr_pos++] = EGL_BLUE_SIZE;
   513                 wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   514                 wdata->gles_attributes[attr_pos++] = EGL_ALPHA_SIZE;
   515                 wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   516                 wdata->gles_attributes[attr_pos++] = EGL_BUFFER_SIZE;
   517                 wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   518 
   519                 /* Try to find requested or smallest depth */
   520                 if (_this->gl_config.depth_size) {
   521                     wdata->gles_attributes[attr_pos++] = EGL_DEPTH_SIZE;
   522                     wdata->gles_attributes[attr_pos++] = depthbits[it];
   523                 } else {
   524                     wdata->gles_attributes[attr_pos++] = EGL_DEPTH_SIZE;
   525                     wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   526                 }
   527 
   528                 if (_this->gl_config.stencil_size) {
   529                     wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;
   530                     wdata->gles_attributes[attr_pos++] = jt;
   531                 } else {
   532                     wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;
   533                     wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   534                 }
   535 
   536                 wdata->gles_attributes[attr_pos++] = EGL_SAMPLES;
   537                 wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   538                 wdata->gles_attributes[attr_pos++] = EGL_SAMPLE_BUFFERS;
   539                 wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
   540                 wdata->gles_attributes[attr_pos] = EGL_NONE;
   541 
   542                 /* Request first suitable framebuffer configuration */
   543                 status =
   544                     eglChooseConfig(phdata->egl_display,
   545                                     wdata->gles_attributes,
   546                                     wdata->gles_configs, 1, &configs);
   547 
   548                 if (status != EGL_TRUE) {
   549                     SDL_SetError
   550                         ("PND: Can't find closest configuration for OpenGL ES");
   551                     return NULL;
   552                 }
   553                 if (configs != 0) {
   554                     break;
   555                 }
   556             }
   557             if (configs != 0) {
   558                 break;
   559             }
   560         }
   561 
   562         /* No available configs */
   563         if (configs == 0) {
   564             SDL_SetError("PND: Can't find any configuration for OpenGL ES");
   565             return NULL;
   566         }
   567     }
   568 
   569     /* Initialize config index */
   570     wdata->gles_config = 0;
   571 
   572     /* Now check each configuration to find out the best */
   573     for (cit = 0; cit < configs; cit++) {
   574         uint32_t stencil_found;
   575         uint32_t depth_found;
   576 
   577         stencil_found = 0;
   578         depth_found = 0;
   579 
   580         if (_this->gl_config.stencil_size) {
   581             status =
   582                 eglGetConfigAttrib(phdata->egl_display,
   583                                    wdata->gles_configs[cit], EGL_STENCIL_SIZE,
   584                                    &attr_value);
   585             if (status == EGL_TRUE) {
   586                 if (attr_value != 0) {
   587                     stencil_found = 1;
   588                 }
   589             }
   590         } else {
   591             stencil_found = 1;
   592         }
   593 
   594         if (_this->gl_config.depth_size) {
   595             status =
   596                 eglGetConfigAttrib(phdata->egl_display,
   597                                    wdata->gles_configs[cit], EGL_DEPTH_SIZE,
   598                                    &attr_value);
   599             if (status == EGL_TRUE) {
   600                 if (attr_value != 0) {
   601                     depth_found = 1;
   602                 }
   603             }
   604         } else {
   605             depth_found = 1;
   606         }
   607 
   608         /* Exit from loop if found appropriate configuration */
   609         if ((depth_found != 0) && (stencil_found != 0)) {
   610             break;
   611         }
   612     }
   613 
   614     /* If best could not be found, use first */
   615     if (cit == configs) {
   616         cit = 0;
   617     }
   618     wdata->gles_config = cit;
   619 
   620     /* Create OpenGL ES context */
   621     wdata->gles_context =
   622         eglCreateContext(phdata->egl_display,
   623                          wdata->gles_configs[wdata->gles_config], NULL, NULL);
   624     if (wdata->gles_context == EGL_NO_CONTEXT) {
   625         SDL_SetError("PND: OpenGL ES context creation has been failed");
   626         return NULL;
   627     }
   628 
   629 #ifdef WIZ_GLES_LITE
   630     if( !hNativeWnd ) {
   631 	hNativeWnd = (NativeWindowType)malloc(16*1024);
   632 
   633 	if(!hNativeWnd)
   634 	    printf( "Error : Wiz framebuffer allocatation failed\n" ); 
   635 	else
   636 	    printf( "SDL13: Wiz framebuffer allocated: %X\n", hNativeWnd );
   637     }
   638     else {
   639 	printf( "SDL13: Wiz framebuffer already allocated: %X\n", hNativeWnd );
   640     }
   641 
   642     wdata->gles_surface =
   643 	eglCreateWindowSurface(phdata->egl_display, 
   644 			       wdata->gles_configs[wdata->gles_config],
   645 			       hNativeWnd, NULL );
   646 #else
   647     wdata->gles_surface =
   648         eglCreateWindowSurface(phdata->egl_display,
   649                                wdata->gles_configs[wdata->gles_config],
   650                                (NativeWindowType) 0, NULL);
   651 #endif
   652 
   653 
   654     if (wdata->gles_surface == 0) {
   655         SDL_SetError("Error : eglCreateWindowSurface failed;\n");
   656         return NULL;
   657     }
   658 
   659     /* Make just created context current */
   660     status =
   661         eglMakeCurrent(phdata->egl_display, wdata->gles_surface,
   662                        wdata->gles_surface, wdata->gles_context);
   663     if (status != EGL_TRUE) {
   664         /* Destroy OpenGL ES surface */
   665         eglDestroySurface(phdata->egl_display, wdata->gles_surface);
   666         eglDestroyContext(phdata->egl_display, wdata->gles_context);
   667         wdata->gles_context = EGL_NO_CONTEXT;
   668         SDL_SetError("PND: Can't set OpenGL ES context on creation");
   669         return NULL;
   670     }
   671 
   672     _this->gl_config.accelerated = 1;
   673 
   674     /* Always clear stereo enable, since OpenGL ES do not supports stereo */
   675     _this->gl_config.stereo = 0;
   676 
   677     /* Get back samples and samplebuffers configurations. Rest framebuffer */
   678     /* parameters could be obtained through the OpenGL ES API              */
   679     status =
   680         eglGetConfigAttrib(phdata->egl_display,
   681                            wdata->gles_configs[wdata->gles_config],
   682                            EGL_SAMPLES, &attr_value);
   683     if (status == EGL_TRUE) {
   684         _this->gl_config.multisamplesamples = attr_value;
   685     }
   686     status =
   687         eglGetConfigAttrib(phdata->egl_display,
   688                            wdata->gles_configs[wdata->gles_config],
   689                            EGL_SAMPLE_BUFFERS, &attr_value);
   690     if (status == EGL_TRUE) {
   691         _this->gl_config.multisamplebuffers = attr_value;
   692     }
   693 
   694     /* Get back stencil and depth buffer sizes */
   695     status =
   696         eglGetConfigAttrib(phdata->egl_display,
   697                            wdata->gles_configs[wdata->gles_config],
   698                            EGL_DEPTH_SIZE, &attr_value);
   699     if (status == EGL_TRUE) {
   700         _this->gl_config.depth_size = attr_value;
   701     }
   702     status =
   703         eglGetConfigAttrib(phdata->egl_display,
   704                            wdata->gles_configs[wdata->gles_config],
   705                            EGL_STENCIL_SIZE, &attr_value);
   706     if (status == EGL_TRUE) {
   707         _this->gl_config.stencil_size = attr_value;
   708     }
   709 
   710     /* Under PND OpenGL ES output can't be double buffered */
   711     _this->gl_config.double_buffer = 0;
   712 
   713     /* GL ES context was successfully created */
   714     return wdata->gles_context;
   715 }
   716 
   717 int
   718 PND_gl_makecurrent(_THIS, SDL_Window * window, SDL_GLContext context)
   719 {
   720     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   721     SDL_WindowData *wdata;
   722     EGLBoolean status;
   723 
   724     if (phdata->egl_initialized != SDL_TRUE) {
   725         return SDL_SetError("PND: GF initialization failed, no OpenGL ES support");
   726     }
   727 
   728     if ((window == NULL) && (context == NULL)) {
   729         status =
   730             eglMakeCurrent(phdata->egl_display, EGL_NO_SURFACE,
   731                            EGL_NO_SURFACE, EGL_NO_CONTEXT);
   732         if (status != EGL_TRUE) {
   733             /* Failed to set current GL ES context */
   734             return SDL_SetError("PND: Can't set OpenGL ES context");
   735         }
   736     } else {
   737         wdata = (SDL_WindowData *) window->driverdata;
   738         if (wdata->gles_surface == EGL_NO_SURFACE) {
   739             return SDL_SetError
   740                 ("PND: OpenGL ES surface is not initialized for this window");
   741         }
   742         if (wdata->gles_context == EGL_NO_CONTEXT) {
   743             return SDL_SetError
   744                 ("PND: OpenGL ES context is not initialized for this window");
   745         }
   746         if (wdata->gles_context != context) {
   747             return SDL_SetError
   748                 ("PND: OpenGL ES context is not belong to this window");
   749         }
   750         status =
   751             eglMakeCurrent(phdata->egl_display, wdata->gles_surface,
   752                            wdata->gles_surface, wdata->gles_context);
   753         if (status != EGL_TRUE) {
   754             /* Failed to set current GL ES context */
   755             return SDL_SetError("PND: Can't set OpenGL ES context");
   756         }
   757     }
   758     return 0;
   759 }
   760 
   761 int
   762 PND_gl_setswapinterval(_THIS, int interval)
   763 {
   764     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   765     EGLBoolean status;
   766 
   767     if (phdata->egl_initialized != SDL_TRUE) {
   768         return SDL_SetError("PND: EGL initialization failed, no OpenGL ES support");
   769     }
   770 
   771     /* Check if OpenGL ES connection has been initialized */
   772     if (phdata->egl_display != EGL_NO_DISPLAY) {
   773         /* Set swap OpenGL ES interval */
   774         status = eglSwapInterval(phdata->egl_display, interval);
   775         if (status == EGL_TRUE) {
   776             /* Return success to upper level */
   777             phdata->swapinterval = interval;
   778             return 0;
   779         }
   780     }
   781 
   782     /* Failed to set swap interval */
   783     return SDL_SetError("PND: Cannot set swap interval");
   784 }
   785 
   786 int
   787 PND_gl_getswapinterval(_THIS)
   788 {
   789     return ((SDL_VideoData *) _this->driverdata)->swapinterval;
   790 }
   791 
   792 void
   793 PND_gl_swapwindow(_THIS, SDL_Window * window)
   794 {
   795     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   796     SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
   797     SDL_DisplayData *didata =
   798         (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
   799 
   800 
   801     if (phdata->egl_initialized != SDL_TRUE) {
   802         SDL_SetError("PND: GLES initialization failed, no OpenGL ES support");
   803         return;
   804     }
   805 
   806     /* Many applications do not uses glFinish(), so we call it for them */
   807     glFinish();
   808 
   809     /* Wait until OpenGL ES rendering is completed */
   810     eglWaitGL();
   811 
   812     eglSwapBuffers(phdata->egl_display, wdata->gles_surface);
   813 }
   814 
   815 void
   816 PND_gl_deletecontext(_THIS, SDL_GLContext context)
   817 {
   818     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
   819     EGLBoolean status;
   820 
   821     if (phdata->egl_initialized != SDL_TRUE) {
   822         SDL_SetError("PND: GLES initialization failed, no OpenGL ES support");
   823         return;
   824     }
   825 
   826     /* Check if OpenGL ES connection has been initialized */
   827     if (phdata->egl_display != EGL_NO_DISPLAY) {
   828         if (context != EGL_NO_CONTEXT) {
   829             status = eglDestroyContext(phdata->egl_display, context);
   830             if (status != EGL_TRUE) {
   831                 /* Error during OpenGL ES context destroying */
   832                 SDL_SetError("PND: OpenGL ES context destroy error");
   833                 return;
   834             }
   835         }
   836     }
   837 
   838 #ifdef WIZ_GLES_LITE
   839     if( hNativeWnd != 0 )
   840     {
   841 	  free(hNativeWnd);
   842 	  hNativeWnd = 0;
   843 	  printf( "SDL13: Wiz framebuffer released\n" );
   844     }
   845 #endif
   846 
   847     return;
   848 }
   849 
   850 #endif /* SDL_VIDEO_DRIVER_PANDORA */
   851 
   852 /* vi: set ts=4 sw=4 expandtab: */