/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 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_sysvideo.h"

#include "SDL_blit.h"

#include "SDL_pixels_c.h"

#include "SDL_renderer_sw.h"

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

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

/* Available video drivers */

static VideoBootStrap *bootstrap[] = {

#if SDL_VIDEO_DRIVER_QUARTZ

    &QZ_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_X11

    &X11_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DGA

    &DGA_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_NANOX

    &NX_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_IPOD

    &iPod_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_QTOPIA

    &Qtopia_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_WSCONS

    &WSCONS_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_GGI

    &GGI_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_VGL

    &VGL_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_TOOLBOX

    &TOOLBOX_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DRAWSPROCKET

    &DSp_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_CYBERGRAPHICS

    &CGX_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PHOTON

    &ph_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_EPOC

    &EPOC_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_XBIOS

    &XBIOS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_GEM

    &GEM_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PICOGUI

    &PG_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DC

    &DC_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_RISCOS

    &RISCOS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_OS2FS

    &OS2FSLib_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_AALIB

    &AALIB_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DUMMY

    &DUMMY_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_GLSDL

    &glSDL_bootstrap,

#endif

    NULL

};

static SDL_VideoDevice *_this = NULL;

/* Various local functions */

int SDL_VideoInit(const char *driver_name, Uint32 flags);

void SDL_VideoQuit(void);

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 (a.refresh_rate != b.refresh_rate) {

        return b.refresh_rate - a.refresh_rate;

    }

    return 0;

}

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_strncmp(bootstrap[i]->name, driver_name,

                            SDL_strlen(bootstrap[i]->name)) == 0) {

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

                    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.accelerated = -1;  /* not known, don't set */

    /* 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) {

        if (_this->displays[i].num_render_drivers > 0) {

            SDL_AddRenderDriver(i, &SDL_SW_RenderDriver);

        }

    }

    /* We're ready to go! */

    return 0;

}

const char *

SDL_GetCurrentVideoDriver()

{

    if (!_this) {

        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) {

        return 0;

    }

    return _this->num_displays;

}

int

SDL_SelectVideoDisplay(int index)

{

    if (!_this) {

        return (-1);

    }

    if (index >= 0) {

        if (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 _this->current_display;

}

SDL_bool

SDL_AddDisplayMode(int displayIndex, const SDL_DisplayMode * mode)

{

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

    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++;

    return SDL_TRUE;

}

int

SDL_GetNumDisplayModes()

{

    if (_this) {

        SDL_VideoDisplay *display = &SDL_CurrentDisplay;

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

            _this->GetDisplayModes(_this);

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

                      sizeof(SDL_DisplayMode), cmpmodes);

        }

        return display->num_display_modes;

    }

    return 0;

}

const SDL_DisplayMode *

SDL_GetDisplayMode(int index)

{

    if (index < 0 || index >= SDL_GetNumDisplayModes()) {

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

                     SDL_GetNumDisplayModes() - 1);

        return NULL;

    }

    return &SDL_CurrentDisplay.display_modes[index];

}

const SDL_DisplayMode *

SDL_GetDesktopDisplayMode(void)

{

    if (_this) {

        return &SDL_CurrentDisplay.desktop_mode;

    }

    return NULL;

}

const SDL_DisplayMode *

SDL_GetCurrentDisplayMode(void)

{

    if (_this) {

        return &SDL_CurrentDisplay.current_mode;

    }

    return NULL;

}

SDL_DisplayMode *

SDL_GetClosestDisplayMode(const SDL_DisplayMode * mode,

                          SDL_DisplayMode * closest)

{

    Uint32 target_format;

    int target_refresh_rate;

    int i;

    SDL_DisplayMode *current, *match;

    if (!_this || !mode || !closest) {

        return NULL;

    }

    /* Default to the desktop format */

    if (mode->format) {

        target_format = mode->format;

    } else {

        target_format = SDL_CurrentDisplay.desktop_mode.format;

    }

    /* Default to the desktop refresh rate */

    if (mode->refresh_rate) {

        target_refresh_rate = mode->refresh_rate;

    } else {

        target_refresh_rate = SDL_CurrentDisplay.desktop_mode.refresh_rate;

    }

    match = NULL;

    for (i = 0; i < SDL_GetNumDisplayModes(); ++i) {

        current = &SDL_CurrentDisplay.display_modes[i];

        if ((current->w && current->h) &&

            (current->w < mode->w || current->h < mode->h)) {

            /* Out of sorted modes large enough here */

            break;

        }

        if (!match || current->w < match->w || current->h < match->h) {

            match = current;

            continue;

        }

        if (current->format != match->format) {

            /* Sorted highest depth to lowest */

            if (current->format == target_format ||

                (SDL_BITSPERPIXEL(current->format) >=

                 SDL_BITSPERPIXEL(target_format)

                 && SDL_PIXELTYPE(current->format) ==