/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

    Open Pandora SDL driver

    Copyright (C) 2009 David Carré

    (cpasjuste@gmail.com)

*/

/* SDL internals */

#include "SDL_config.h"

#include "../SDL_sysvideo.h"

#include "SDL_version.h"

#include "SDL_syswm.h"

#include "SDL_loadso.h"

#include "SDL_events.h"

#include "../../events/SDL_mouse_c.h"

#include "../../events/SDL_keyboard_c.h"

/* PND declarations */

#include "SDL_pandora.h"

#include "SDL_pandora_events.h"

static SDL_bool PND_initialized = SDL_FALSE;

static int

PND_available(void)

{

    return 1;

}

static void

PND_destroy(SDL_VideoDevice * device)

{

    SDL_VideoData *phdata = (SDL_VideoData *) device->driverdata;

    if (device->driverdata != NULL) {

        device->driverdata = NULL;

    }

}

static SDL_VideoDevice *

PND_create()

{

    SDL_VideoDevice *device;

    SDL_VideoData *phdata;

    int status;

    /* Check if pandora could be initialized */

    status = PND_available();

    if (status == 0) {

        /* PND could not be used */

        return NULL;

    }

    /* Initialize SDL_VideoDevice structure */

    device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));

    if (device == NULL) {

        SDL_OutOfMemory();

        return NULL;

    }

    /* Initialize internal Pandora specific data */

    phdata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));

    if (phdata == NULL) {

        SDL_OutOfMemory();

        SDL_free(device);

        return NULL;

    }

    device->driverdata = phdata;

    phdata->egl_initialized = SDL_TRUE;

    /* Setup amount of available displays and current display */

    device->num_displays = 1;

    device->current_display = 1;

    /* Set device free function */

    device->free = PND_destroy;

    /* Setup all functions which we can handle */

    device->VideoInit = PND_videoinit;

    device->VideoQuit = PND_videoquit;

    device->GetDisplayModes = PND_getdisplaymodes;

    device->SetDisplayMode = PND_setdisplaymode;

    device->SetDisplayPalette = PND_setdisplaypalette;

    device->GetDisplayPalette = PND_getdisplaypalette;

    device->SetDisplayGammaRamp = PND_setdisplaygammaramp;

    device->GetDisplayGammaRamp = PND_getdisplaygammaramp;

    device->CreateWindow = PND_createwindow;

    device->CreateWindowFrom = PND_createwindowfrom;

    device->SetWindowTitle = PND_setwindowtitle;

    device->SetWindowIcon = PND_setwindowicon;

    device->SetWindowPosition = PND_setwindowposition;

    device->SetWindowSize = PND_setwindowsize;

    device->ShowWindow = PND_showwindow;

    device->HideWindow = PND_hidewindow;

    device->RaiseWindow = PND_raisewindow;

    device->MaximizeWindow = PND_maximizewindow;

    device->MinimizeWindow = PND_minimizewindow;

    device->RestoreWindow = PND_restorewindow;

    device->SetWindowGrab = PND_setwindowgrab;

    device->DestroyWindow = PND_destroywindow;

    device->GetWindowWMInfo = PND_getwindowwminfo;

    device->GL_LoadLibrary = PND_gl_loadlibrary;

    device->GL_GetProcAddress = PND_gl_getprocaddres;

    device->GL_UnloadLibrary = PND_gl_unloadlibrary;

    device->GL_CreateContext = PND_gl_createcontext;

    device->GL_MakeCurrent = PND_gl_makecurrent;

    device->GL_SetSwapInterval = PND_gl_setswapinterval;

    device->GL_GetSwapInterval = PND_gl_getswapinterval;

    device->GL_SwapWindow = PND_gl_swapwindow;

    device->GL_DeleteContext = PND_gl_deletecontext;

    device->PumpEvents = PND_PumpEvents;

    return device;

}

VideoBootStrap PND_bootstrap = {

    "pandora",

    "SDL Pandora Video Driver",

    PND_available,

    PND_create

};

/*****************************************************************************/

/* SDL Video and Display initialization/handling functions                   */

/*****************************************************************************/

int

PND_videoinit(_THIS)

{

    SDL_VideoDisplay display;

    SDL_DisplayMode current_mode;

    SDL_zero(current_mode);

    current_mode.w = 800;

    current_mode.h = 480;

    current_mode.refresh_rate = 60;

    current_mode.format = SDL_PIXELFORMAT_RGB565;

    current_mode.driverdata = NULL;

    SDL_zero(display);

    display.desktop_mode = current_mode;

    display.current_mode = current_mode;

    display.driverdata = NULL;

    SDL_AddVideoDisplay(&display);

    return 1;

}

void

PND_videoquit(_THIS)

{

}

void

PND_getdisplaymodes(_THIS)

{

}

int

PND_setdisplaymode(_THIS, SDL_DisplayMode * mode)

{

    return 0;

}

int

PND_setdisplaypalette(_THIS, SDL_Palette * palette)

{

    SDL_DisplayData *didata =

        (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;

    /* Setting display palette operation has been failed */

    return -1;

}

int

PND_getdisplaypalette(_THIS, SDL_Palette * palette)

{

    SDL_DisplayData *didata =

        (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;

    /* Getting display palette operation has been failed */

    return -1;

}

int

PND_setdisplaygammaramp(_THIS, Uint16 * ramp)

{

    SDL_DisplayData *didata =

        (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;

    /* Setting display gamma ramp operation has been failed */

    return -1;

}

int

PND_getdisplaygammaramp(_THIS, Uint16 * ramp)

{

    /* Getting display gamma ramp operation has been failed */

    return -1;

}

int

PND_createwindow(_THIS, SDL_Window * window)

{

    SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;

    SDL_WindowData *wdata;

    uint32_t winargc = 0;

    int32_t status;

    /* Allocate window internal data */

    wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData));

    if (wdata == NULL) {

        SDL_OutOfMemory();

        return -1;

    }

    /* Setup driver data for this window */

    window->driverdata = wdata;

    /* Check if window must support OpenGL ES rendering */

    if ((window->flags & SDL_WINDOW_OPENGL) == SDL_WINDOW_OPENGL) {

        EGLBoolean initstatus;

        /* Mark this window as OpenGL ES compatible */

        wdata->uses_gles = SDL_TRUE;

        /* Create connection to OpenGL ES */

        if (phdata->egl_display == EGL_NO_DISPLAY) {

            phdata->egl_display = eglGetDisplay((NativeDisplayType) 0);

            if (phdata->egl_display == EGL_NO_DISPLAY) {

                SDL_SetError("PND: Can't get connection to OpenGL ES");

                return -1;

            }

            initstatus = eglInitialize(phdata->egl_display, NULL, NULL);

            if (initstatus != EGL_TRUE) {

                SDL_SetError("PND: Can't init OpenGL ES library");

                return -1;

            }

        }

        phdata->egl_refcount++;

    }

    /* Window has been successfully created */

    return 0;

}

int

PND_createwindowfrom(_THIS, SDL_Window * window, const void *data)

{

    return -1;

}

void

PND_setwindowtitle(_THIS, SDL_Window * window)

{

}

void

PND_setwindowicon(_THIS, SDL_Window * window, SDL_Surface * icon)

{

}

void

PND_setwindowposition(_THIS, SDL_Window * window)

{

}

void

PND_setwindowsize(_THIS, SDL_Window * window)

{

}

void

PND_showwindow(_THIS, SDL_Window * window)

{

}

void

PND_hidewindow(_THIS, SDL_Window * window)

{

}

void

PND_raisewindow(_THIS, SDL_Window * window)

{

}

void

PND_maximizewindow(_THIS, SDL_Window * window)

{

}

void

PND_minimizewindow(_THIS, SDL_Window * window)

{

}

void

PND_restorewindow(_THIS, SDL_Window * window)

{

}

void

PND_setwindowgrab(_THIS, SDL_Window * window)

{

}

void

PND_destroywindow(_THIS, SDL_Window * window)

{

}

/*****************************************************************************/

/* SDL Window Manager function                                               */

/*****************************************************************************/

SDL_bool

PND_getwindowwminfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info)

{

    if (info->version.major <= SDL_MAJOR_VERSION) {

        return SDL_TRUE;

    } else {

        SDL_SetError("application not compiled with SDL %d.%d\n",

                     SDL_MAJOR_VERSION, SDL_MINOR_VERSION);

        return SDL_FALSE;

    }

    /* Failed to get window manager information */

    return SDL_FALSE;

}

/*****************************************************************************/

/* SDL OpenGL/OpenGL ES functions                                            */

/*****************************************************************************/

int

PND_gl_loadlibrary(_THIS, const char *path)

{

    SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;

    /* Check if OpenGL ES library is specified for GF driver */

    if (path == NULL) {

        path = SDL_getenv("SDL_OPENGL_LIBRARY");

        if (path == NULL) {

            path = SDL_getenv("SDL_OPENGLES_LIBRARY");

        }

    }

    /* Check if default library loading requested */

    if (path == NULL) {

        /* Already linked with GF library which provides egl* subset of  */

        /* functions, use Common profile of OpenGL ES library by default */

        path = "/usr/lib/libGLES_CM.so";

    }

    /* Load dynamic library */

    _this->gl_config.dll_handle = SDL_LoadObject(path);

    if (!_this->gl_config.dll_handle) {

        /* Failed to load new GL ES library */

        SDL_SetError("PND: Failed to locate OpenGL ES library");

        return -1;

    }

    /* Store OpenGL ES library path and name */

    SDL_strlcpy(_this->gl_config.driver_path, path,

                SDL_arraysize(_this->gl_config.driver_path));

    /* New OpenGL ES library is loaded */

    return 0;

}

void *

PND_gl_getprocaddres(_THIS, const char *proc)

{

    SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;

    void *function_address;

    /* Try to get function address through the egl interface */

    function_address = eglGetProcAddress(proc);

    if (function_address != NULL) {

        return function_address;

    }

    /* Then try to get function in the OpenGL ES library */

    if (_this->gl_config.dll_handle) {

        function_address =

            SDL_LoadFunction(_this->gl_config.dll_handle, proc);

        if (function_address != NULL) {

            return function_address;

        }

    }

    /* Failed to get GL ES function address pointer */

    SDL_SetError("PND: Cannot locate OpenGL ES function name");

    return NULL;

}

void

PND_gl_unloadlibrary(_THIS)

{

    SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;

    if (phdata->egl_initialized == SDL_TRUE) {

        /* Unload OpenGL ES library */

        if (_this->gl_config.dll_handle) {

            SDL_UnloadObject(_this->gl_config.dll_handle);

            _this->gl_config.dll_handle = NULL;

        }

    } else {

        SDL_SetError("PND: GF initialization failed, no OpenGL ES support");

    }

}

SDL_GLContext

PND_gl_createcontext(_THIS, SDL_Window * window)

{

    SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;

    SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;

    SDL_DisplayData *didata =

        (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;

    EGLBoolean status;

    int32_t gfstatus;

    EGLint configs;

    uint32_t attr_pos;

    EGLint attr_value;

    EGLint cit;

    /* Check if EGL was initialized */

    if (phdata->egl_initialized != SDL_TRUE) {

        SDL_SetError("PND: EGL initialization failed, no OpenGL ES support");

        return NULL;

    }

    /* Prepare attributes list to pass them to OpenGL ES */

    attr_pos = 0;

    wdata->gles_attributes[attr_pos++] = EGL_SURFACE_TYPE;

    wdata->gles_attributes[attr_pos++] = EGL_WINDOW_BIT;

    wdata->gles_attributes[attr_pos++] = EGL_RED_SIZE;

    wdata->gles_attributes[attr_pos++] = _this->gl_config.red_size;

    wdata->gles_attributes[attr_pos++] = EGL_GREEN_SIZE;

    wdata->gles_attributes[attr_pos++] = _this->gl_config.green_size;

    wdata->gles_attributes[attr_pos++] = EGL_BLUE_SIZE;

    wdata->gles_attributes[attr_pos++] = _this->gl_config.blue_size;

    wdata->gles_attributes[attr_pos++] = EGL_ALPHA_SIZE;

    /* Setup alpha size in bits */

    if (_this->gl_config.alpha_size) {

        wdata->gles_attributes[attr_pos++] = _this->gl_config.alpha_size;

    } else {

        wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;

    }

    /* Setup color buffer size */

    if (_this->gl_config.buffer_size) {

        wdata->gles_attributes[attr_pos++] = EGL_BUFFER_SIZE;

        wdata->gles_attributes[attr_pos++] = _this->gl_config.buffer_size;

    } else {

        wdata->gles_attributes[attr_pos++] = EGL_BUFFER_SIZE;

        wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;

    }

    /* Setup depth buffer bits */

    wdata->gles_attributes[attr_pos++] = EGL_DEPTH_SIZE;

    wdata->gles_attributes[attr_pos++] = _this->gl_config.depth_size;

    /* Setup stencil bits */

    if (_this->gl_config.stencil_size) {

        wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;

        wdata->gles_attributes[attr_pos++] = _this->gl_config.buffer_size;

    } else {

        wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;

        wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;

    }

    /* Set number of samples in multisampling */

    if (_this->gl_config.multisamplesamples) {

        wdata->gles_attributes[attr_pos++] = EGL_SAMPLES;

        wdata->gles_attributes[attr_pos++] =

            _this->gl_config.multisamplesamples;

    }

    /* Multisample buffers, OpenGL ES 1.0 spec defines 0 or 1 buffer */

    if (_this->gl_config.multisamplebuffers) {

        wdata->gles_attributes[attr_pos++] = EGL_SAMPLE_BUFFERS;

        wdata->gles_attributes[attr_pos++] =

            _this->gl_config.multisamplebuffers;

    }

    /* Finish attributes list */

    wdata->gles_attributes[attr_pos] = EGL_NONE;

    /* Request first suitable framebuffer configuration */

    status = eglChooseConfig(phdata->egl_display, wdata->gles_attributes,

                             wdata->gles_configs, 1, &configs);

    if (status != EGL_TRUE) {

        SDL_SetError("PND: Can't find closest configuration for OpenGL ES");

        return NULL;

    }

    /* Check if nothing has been found, try "don't care" settings */

    if (configs == 0) {

        int32_t it;

        int32_t jt;

        GLint depthbits[4] = { 32, 24, 16, EGL_DONT_CARE };

        for (it = 0; it < 4; it++) {

            for (jt = 16; jt >= 0; jt--) {

                /* Don't care about color buffer bits, use what exist */

                /* Replace previous set data with EGL_DONT_CARE       */