/*

    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

*/

#include "SDL_config.h"

/* The high-level video driver subsystem */

#include "SDL.h"

#include "SDL_video.h"

#include "SDL_sysvideo.h"

#include "SDL_blit.h"

#include "SDL_pixels_c.h"

#include "SDL_renderer_gl.h"

#include "SDL_renderer_gles.h"

#include "SDL_renderer_sw.h"

#include "../events/SDL_sysevents.h"

#include "../events/SDL_events_c.h"

#if SDL_VIDEO_OPENGL_ES

#include "SDL_opengles.h"

#endif /* SDL_VIDEO_OPENGL_ES */

#if SDL_VIDEO_OPENGL

#include "SDL_opengl.h"

/* On Windows, windows.h defines CreateWindow */

#ifdef CreateWindow

#undef CreateWindow

#endif

#endif /* SDL_VIDEO_OPENGL */

/* Available video drivers */

static VideoBootStrap *bootstrap[] = {

#if SDL_VIDEO_DRIVER_COCOA

    &COCOA_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_X11

    &X11_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_FBCON

    &FBCON_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DIRECTFB

    &DirectFB_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PS2GS

    &PS2GS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PS3

    &PS3_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_SVGALIB

    &SVGALIB_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_GAPI

    &GAPI_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_WIN32

    &WIN32_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_BWINDOW

    &BWINDOW_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PHOTON

    &photon_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_QNXGF

    &qnxgf_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_EPOC

    &EPOC_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_RISCOS

    &RISCOS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_NDS

    &NDS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_UIKIT

    &UIKIT_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DUMMY

    &DUMMY_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PANDORA

    &PND_bootstrap,

#endif

    NULL

};

static SDL_VideoDevice *_this = NULL;

/* Various local functions */

static void SDL_UpdateWindowGrab(SDL_Window * window);

static int

cmpmodes(const void *A, const void *B)

{

    SDL_DisplayMode a = *(const SDL_DisplayMode *) A;

    SDL_DisplayMode b = *(const SDL_DisplayMode *) B;

    if (a.w != b.w) {

        return b.w - a.w;

    }

    if (a.h != b.h) {

        return b.h - a.h;

    }

    if (SDL_BITSPERPIXEL(a.format) != SDL_BITSPERPIXEL(b.format)) {

        return SDL_BITSPERPIXEL(b.format) - SDL_BITSPERPIXEL(a.format);

    }

    if (SDL_PIXELLAYOUT(a.format) != SDL_PIXELLAYOUT(b.format)) {

        return SDL_PIXELLAYOUT(b.format) - SDL_PIXELLAYOUT(a.format);

    }

    if (a.refresh_rate != b.refresh_rate) {

        return b.refresh_rate - a.refresh_rate;

    }

    return 0;

}

static void

SDL_UninitializedVideo()

{

    SDL_SetError("Video subsystem has not been initialized");

}

int

SDL_GetNumVideoDrivers(void)

{

    return SDL_arraysize(bootstrap) - 1;

}

const char *

SDL_GetVideoDriver(int index)

{

    if (index >= 0 && index < SDL_GetNumVideoDrivers()) {

        return bootstrap[index]->name;

    }

    return NULL;

}

/*

 * Initialize the video and event subsystems -- determine native pixel format

 */

int

SDL_VideoInit(const char *driver_name, Uint32 flags)

{

    SDL_VideoDevice *video;

    int index;

    int i;

    /* Toggle the event thread flags, based on OS requirements */

#if defined(MUST_THREAD_EVENTS)

    flags |= SDL_INIT_EVENTTHREAD;

#elif defined(CANT_THREAD_EVENTS)

    if ((flags & SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD) {

        SDL_SetError("OS doesn't support threaded events");

        return -1;

    }

#endif

    /* Start the event loop */

    if (SDL_StartEventLoop(flags) < 0) {

        return -1;

    }

    /* Check to make sure we don't overwrite '_this' */

    if (_this != NULL) {

        SDL_VideoQuit();

    }

    /* Select the proper video driver */

    index = 0;

    video = NULL;

    if (driver_name == NULL) {

        driver_name = SDL_getenv("SDL_VIDEODRIVER");

    }

    if (driver_name != NULL) {

        for (i = 0; bootstrap[i]; ++i) {

            if (SDL_strcasecmp(bootstrap[i]->name, driver_name) == 0) {

                video = bootstrap[i]->create(index);

                break;

            }

        }

    } else {

        for (i = 0; bootstrap[i]; ++i) {

            if (bootstrap[i]->available()) {

                video = bootstrap[i]->create(index);

                if (video != NULL) {

                    break;

                }

            }

        }

    }

    if (video == NULL) {

        if (driver_name) {

            SDL_SetError("%s not available", driver_name);

        } else {

            SDL_SetError("No available video device");

        }

        return -1;

    }

    _this = video;

    _this->name = bootstrap[i]->name;

    _this->next_object_id = 1;

    /* Set some very sane GL defaults */

    _this->gl_config.driver_loaded = 0;

    _this->gl_config.dll_handle = NULL;

    _this->gl_config.red_size = 3;

    _this->gl_config.green_size = 3;

    _this->gl_config.blue_size = 2;

    _this->gl_config.alpha_size = 0;

    _this->gl_config.buffer_size = 0;

    _this->gl_config.depth_size = 16;

    _this->gl_config.stencil_size = 0;

    _this->gl_config.double_buffer = 1;

    _this->gl_config.accum_red_size = 0;

    _this->gl_config.accum_green_size = 0;

    _this->gl_config.accum_blue_size = 0;

    _this->gl_config.accum_alpha_size = 0;

    _this->gl_config.stereo = 0;

    _this->gl_config.multisamplebuffers = 0;

    _this->gl_config.multisamplesamples = 0;

    _this->gl_config.retained_backing = 1;

    _this->gl_config.accelerated = -1;  /* not known, don't set */

    _this->gl_config.major_version = 2;

    _this->gl_config.minor_version = 1;

    /* Initialize the video subsystem */

    if (_this->VideoInit(_this) < 0) {

        SDL_VideoQuit();

        return -1;

    }

    /* Make sure some displays were added */

    if (_this->num_displays == 0) {

        SDL_SetError("The video driver did not add any displays");

        SDL_VideoQuit();

        return (-1);

    }

    /* The software renderer is always available */

    for (i = 0; i < _this->num_displays; ++i) {

        SDL_VideoDisplay *display = &_this->displays[i];

        if (_this->GL_CreateContext) {

#if SDL_VIDEO_RENDER_OGL

            SDL_AddRenderDriver(display, &GL_RenderDriver);

#endif

#if SDL_VIDEO_RENDER_OGL_ES

            SDL_AddRenderDriver(display, &GL_ES_RenderDriver);

#endif

        }

        if (display->num_render_drivers > 0) {

            SDL_AddRenderDriver(display, &SW_RenderDriver);

        }

    }

    /* We're ready to go! */

    return 0;

}

const char *

SDL_GetCurrentVideoDriver()

{

    if (!_this) {

        SDL_UninitializedVideo();

        return NULL;

    }

    return _this->name;

}

SDL_VideoDevice *

SDL_GetVideoDevice()

{

    return _this;

}

int

SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode)

{

    SDL_VideoDisplay display;

    SDL_zero(display);

    if (desktop_mode) {

        display.desktop_mode = *desktop_mode;

    }

    display.current_mode = display.desktop_mode;

    return SDL_AddVideoDisplay(&display);

}

int

SDL_AddVideoDisplay(const SDL_VideoDisplay * display)

{

    SDL_VideoDisplay *displays;

    int index = -1;

    displays =

        SDL_realloc(_this->displays,

                    (_this->num_displays + 1) * sizeof(*displays));

    if (displays) {

        index = _this->num_displays++;

        displays[index] = *display;

        displays[index].device = _this;

        _this->displays = displays;

    } else {

        SDL_OutOfMemory();

    }

    return index;

}

int

SDL_GetNumVideoDisplays(void)

{

    if (!_this) {

        SDL_UninitializedVideo();

        return 0;

    }

    return _this->num_displays;

}

int

SDL_GetDisplayBounds(int index, SDL_Rect * rect)

{

    if (!_this) {

        SDL_UninitializedVideo();

        return -1;

    }

    if (index < 0 || index >= _this->num_displays) {

        SDL_SetError("index must be in the range 0 - %d",

                     _this->num_displays - 1);

        return -1;

    }

    if (rect) {

        SDL_VideoDisplay *display = &_this->displays[index];

        if (_this->GetDisplayBounds) {

            if (_this->GetDisplayBounds(_this, display, rect) < 0) {

                return -1;

            }

        } else {

            /* Assume that the displays are left to right */

            if (index == 0) {

                rect->x = 0;

                rect->y = 0;

            } else {

                SDL_GetDisplayBounds(index-1, rect);

                rect->x += rect->w;

            }

            rect->w = display->desktop_mode.w;

            rect->h = display->desktop_mode.h;

        }

    }

    return 0;

}

int

SDL_SelectVideoDisplay(int index)

{

    if (!_this) {

        SDL_UninitializedVideo();

        return (-1);

    }

    if (index < 0 || index >= _this->num_displays) {

        SDL_SetError("index must be in the range 0 - %d",

                     _this->num_displays - 1);

        return -1;

    }

    _this->current_display = index;

    return 0;

}

int

SDL_GetCurrentVideoDisplay(void)

{

    if (!_this) {

        SDL_UninitializedVideo();

        return (-1);

    }

    return _this->current_display;

}

SDL_bool

SDL_AddDisplayMode(SDL_VideoDisplay * display,  const SDL_DisplayMode * mode)

{

    SDL_DisplayMode *modes;

    int i, nmodes;

    /* Make sure we don't already have the mode in the list */

    modes = display->display_modes;

    nmodes = display->num_display_modes;

    for (i = nmodes; i--;) {

        if (SDL_memcmp(mode, &modes[i], sizeof(*mode)) == 0) {

            return SDL_FALSE;

        }

    }

    /* Go ahead and add the new mode */

    if (nmodes == display->max_display_modes) {

        modes =

            SDL_realloc(modes,

                        (display->max_display_modes + 32) * sizeof(*modes));

        if (!modes) {

            return SDL_FALSE;

        }

        display->display_modes = modes;

        display->max_display_modes += 32;

    }

    modes[nmodes] = *mode;

    display->num_display_modes++;

    /* Re-sort video modes */

    SDL_qsort(display->display_modes, display->num_display_modes,

              sizeof(SDL_DisplayMode), cmpmodes);

    return SDL_TRUE;

}

int

SDL_GetNumDisplayModesForDisplay(SDL_VideoDisplay * display)

{

    if (!display->num_display_modes && _this->GetDisplayModes) {

        _this->GetDisplayModes(_this, display);

        SDL_qsort(display->display_modes, display->num_display_modes,

                  sizeof(SDL_DisplayMode), cmpmodes);

    }

    return display->num_display_modes;

}

int

SDL_GetNumDisplayModes()

{

    if (_this) {

        return SDL_GetNumDisplayModesForDisplay(&SDL_CurrentDisplay);

    }

    return 0;

}

int

SDL_GetDisplayModeForDisplay(SDL_VideoDisplay * display, int index, SDL_DisplayMode * mode)

{

    if (index < 0 || index >= SDL_GetNumDisplayModesForDisplay(display)) {

        SDL_SetError("index must be in the range of 0 - %d",

                     SDL_GetNumDisplayModesForDisplay(display) - 1);

        return -1;

    }

    if (mode) {

        *mode = display->display_modes[index];

    }

    return 0;

}

int

SDL_GetDisplayMode(int index, SDL_DisplayMode * mode)

{

    return SDL_GetDisplayModeForDisplay(&SDL_CurrentDisplay, index, mode);

}

int

SDL_GetDesktopDisplayModeForDisplay(SDL_VideoDisplay * display, SDL_DisplayMode * mode)

{

    if (mode) {

        *mode = display->desktop_mode;

    }

    return 0;

}

int

SDL_GetDesktopDisplayMode(SDL_DisplayMode * mode)

{

    if (!_this) {