/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

#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_rect_c.h"

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

#if SDL_VIDEO_OPENGL

#include "SDL_opengl.h"

#endif /* SDL_VIDEO_OPENGL */

#if SDL_VIDEO_OPENGL_ES

#include "SDL_opengles.h"

#endif /* SDL_VIDEO_OPENGL_ES */

#if SDL_VIDEO_OPENGL_ES2

#include "SDL_opengles2.h"

#endif /* SDL_VIDEO_OPENGL_ES2 */

#include "SDL_syswm.h"

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

#ifdef CreateWindow

#undef CreateWindow

#endif

/* 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_DIRECTFB

    &DirectFB_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_WINDOWS

    &WINDOWS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_BWINDOW

    &BWINDOW_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PANDORA

    &PND_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_NDS

    &NDS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_UIKIT

    &UIKIT_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_ANDROID

    &Android_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DUMMY

    &DUMMY_bootstrap,

#endif

    NULL

};

static SDL_VideoDevice *_this = NULL;

#define CHECK_WINDOW_MAGIC(window, retval) \

    if (!_this) { \

        SDL_UninitializedVideo(); \

        return retval; \

    } \

    if (!window || window->magic != &_this->window_magic) { \

        SDL_SetError("Invalid window"); \

        return retval; \

    }

#define CHECK_DISPLAY_INDEX(displayIndex, retval) \

    if (!_this) { \

        SDL_UninitializedVideo(); \

        return retval; \

    } \

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

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

                     _this->num_displays - 1); \

        return retval; \

    }

/* Support for framebuffer emulation using an accelerated renderer */

#define SDL_WINDOWTEXTUREDATA   "_SDL_WindowTextureData"

typedef struct {

    SDL_Renderer *renderer;

    SDL_Texture *texture;

    void *pixels;

    int pitch;

    int bytes_per_pixel;

} SDL_WindowTextureData;

static SDL_bool

ShouldUseTextureFramebuffer()

{

    const char *hint;

    /* If there's no native framebuffer support then there's no option */

    if (!_this->CreateWindowFramebuffer) {

        return SDL_TRUE;

    }

    /* If the user has specified a software renderer we can't use a

       texture framebuffer, or renderer creation will go recursive.

     */

    hint = SDL_GetHint(SDL_HINT_RENDER_DRIVER);

    if (hint && SDL_strcasecmp(hint, "software") == 0) {

        return SDL_FALSE;

    }

    /* See if the user or application wants a specific behavior */

    hint = SDL_GetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION);

    if (hint) {

        if (*hint == '0') {

            return SDL_FALSE;

        } else {

            return SDL_TRUE;

        }

    }

    /* Each platform has different performance characteristics */

#if defined(__WIN32__)

    /* GDI BitBlt() is way faster than Direct3D dynamic textures right now.

     */

    return SDL_FALSE;

#elif defined(__MACOSX__)

    /* Mac OS X uses OpenGL as the native fast path */

    return SDL_TRUE;

#elif defined(__LINUX__)

    /* Properly configured OpenGL drivers are faster than MIT-SHM */

#if SDL_VIDEO_OPENGL

    /* Ugh, find a way to cache this value! */

    {

        SDL_Window *window;

        SDL_GLContext context;

        SDL_bool hasAcceleratedOpenGL = SDL_FALSE;

        window = SDL_CreateWindow("OpenGL test", -32, -32, 32, 32, SDL_WINDOW_OPENGL|SDL_WINDOW_HIDDEN);

        if (window) {

            context = SDL_GL_CreateContext(window);

            if (context) {

                const GLubyte *(APIENTRY * glGetStringFunc) (GLenum);

                const char *vendor = NULL;

                glGetStringFunc = SDL_GL_GetProcAddress("glGetString");

                if (glGetStringFunc) {

                    vendor = (const char *) glGetStringFunc(GL_VENDOR);

                }

                /* Add more vendors here at will... */

                if (vendor &&

                    (SDL_strstr(vendor, "ATI Technologies") ||

                     SDL_strstr(vendor, "NVIDIA"))) {

                    hasAcceleratedOpenGL = SDL_TRUE;

                }

                SDL_GL_DeleteContext(context);

            }

            SDL_DestroyWindow(window);

        }

        return hasAcceleratedOpenGL;

    }

#elif SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2

    /* Let's be optimistic about this! */

    return SDL_TRUE;

#else

    return SDL_FALSE;

#endif

#else

    /* Play it safe, assume that if there is a framebuffer driver that it's

       optimized for the current platform.

    */

    return SDL_FALSE;

#endif

}

static int

SDL_CreateWindowTexture(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch)

{

    SDL_WindowTextureData *data;

    SDL_RendererInfo info;

    Uint32 i;

    data = SDL_GetWindowData(window, SDL_WINDOWTEXTUREDATA);

    if (!data) {

        SDL_Renderer *renderer = NULL;

        SDL_RendererInfo info;

        int i;

        const char *hint = SDL_GetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION);

        /* Check to see if there's a specific driver requested */

        if (hint && *hint != '0' && *hint != '1' &&

            SDL_strcasecmp(hint, "software") != 0) {

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

                SDL_GetRenderDriverInfo(i, &info);

                if (SDL_strcasecmp(info.name, hint) == 0) {

                    renderer = SDL_CreateRenderer(window, i, 0);

                    break;

                }

            }

        }

        if (!renderer) {

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

                SDL_GetRenderDriverInfo(i, &info);

                if (SDL_strcmp(info.name, "software") != 0) {

                    renderer = SDL_CreateRenderer(window, i, 0);

                    if (renderer) {

                        break;

                    }

                }

            }

        }

        if (!renderer) {

            SDL_SetError("No hardware accelerated renderers available");

            return -1;

        }

        /* Create the data after we successfully create the renderer (bug #1116) */

        data = (SDL_WindowTextureData *)SDL_calloc(1, sizeof(*data));

        if (!data) {

            SDL_DestroyRenderer(renderer);

            SDL_OutOfMemory();

            return -1;

        }

        SDL_SetWindowData(window, SDL_WINDOWTEXTUREDATA, data);

        data->renderer = renderer;

    }

    /* Free any old texture and pixel data */

    if (data->texture) {

        SDL_DestroyTexture(data->texture);

        data->texture = NULL;

    }

    if (data->pixels) {

        SDL_free(data->pixels);

        data->pixels = NULL;

    }

    if (SDL_GetRendererInfo(data->renderer, &info) < 0) {

        return -1;

    }

    /* Find the first format without an alpha channel */

    *format = info.texture_formats[0];

    for (i = 0; i < info.num_texture_formats; ++i) {

        if (!SDL_ISPIXELFORMAT_FOURCC(info.texture_formats[i]) &&

            !SDL_ISPIXELFORMAT_ALPHA(info.texture_formats[i])) {

            *format = info.texture_formats[i];

            break;

        }

    }

    data->texture = SDL_CreateTexture(data->renderer, *format,

                                      SDL_TEXTUREACCESS_STREAMING,

                                      window->w, window->h);

    if (!data->texture) {

        return -1;

    }

    /* Create framebuffer data */

    data->bytes_per_pixel = SDL_BYTESPERPIXEL(*format);

    data->pitch = (((window->w * data->bytes_per_pixel) + 3) & ~3);

    data->pixels = SDL_malloc(window->h * data->pitch);

    if (!data->pixels) {

        SDL_OutOfMemory();

        return -1;

    }

    *pixels = data->pixels;

    *pitch = data->pitch;

    /* Make sure we're not double-scaling the viewport */

    SDL_RenderSetViewport(data->renderer, NULL);

    return 0;

}

static int

SDL_UpdateWindowTexture(_THIS, SDL_Window * window, SDL_Rect * rects, int numrects)

{

    SDL_WindowTextureData *data;

    SDL_Rect rect;

    void *src;

    data = SDL_GetWindowData(window, SDL_WINDOWTEXTUREDATA);

    if (!data || !data->texture) {

        SDL_SetError("No window texture data");

        return -1;

    }

    /* Update a single rect that contains subrects for best DMA performance */

    if (SDL_GetSpanEnclosingRect(window->w, window->h, numrects, rects, &rect)) {

        src = (void *)((Uint8 *)data->pixels +

                        rect.y * data->pitch +

                        rect.x * data->bytes_per_pixel);

        if (SDL_UpdateTexture(data->texture, &rect, src, data->pitch) < 0) {

            return -1;

        }

        if (SDL_RenderCopy(data->renderer, data->texture, NULL, NULL) < 0) {

            return -1;

        }

        SDL_RenderPresent(data->renderer);

    }

    return 0;

}

static void

SDL_DestroyWindowTexture(_THIS, SDL_Window * window)

{

    SDL_WindowTextureData *data;

    data = SDL_SetWindowData(window, SDL_WINDOWTEXTUREDATA, NULL);

    if (!data) {

        return;

    }

    if (data->texture) {

        SDL_DestroyTexture(data->texture);

    }

    if (data->renderer) {

        SDL_DestroyRenderer(data->renderer);

    }

    if (data->pixels) {

        SDL_free(data->pixels);

    }

    SDL_free(data);

}

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)

{

    SDL_VideoDevice *video;

    int index;

    int i;

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

    if (_this != NULL) {

        SDL_VideoQuit();

    }

    /* Start the event loop */

    if (SDL_StartEventLoop() < 0 ||

        SDL_KeyboardInit() < 0 ||

        SDL_MouseInit() < 0 ||

        SDL_TouchInit() < 0 ||

        SDL_QuitInit() < 0) {

        return -1;

    }

    /* 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_strncasecmp(bootstrap[i]->name, driver_name, SDL_strlen(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;  /* accelerated or not, both are fine */

#if SDL_VIDEO_OPENGL

    _this->gl_config.major_version = 2;

    _this->gl_config.minor_version = 1;

    _this->gl_config.use_egl = 0;

#elif SDL_VIDEO_OPENGL_ES

    _this->gl_config.major_version = 1;

    _this->gl_config.minor_version = 1;

    _this->gl_config.use_egl = 1;

#elif SDL_VIDEO_OPENGL_ES2

    _this->gl_config.major_version = 2;

    _this->gl_config.minor_version = 0;

    _this->gl_config.use_egl = 1;

#endif

    _this->gl_config.flags = 0;

    _this->gl_config.profile_mask = 0;

    _this->gl_config.share_with_current_context = 0;

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

    }

    /* Add the renderer framebuffer emulation if desired */

    if (ShouldUseTextureFramebuffer()) {

        _this->CreateWindowFramebuffer = SDL_CreateWindowTexture;

        _this->UpdateWindowFramebuffer = SDL_UpdateWindowTexture;

        _this->DestroyWindowFramebuffer = SDL_DestroyWindowTexture;

    }

    /* If we don't use a screen keyboard, turn on text input by default,

       otherwise programs that expect to get text events without enabling

       UNICODE input won't get any events.

       Actually, come to think of it, you needed to call SDL_EnableUNICODE(1)

       in SDL 1.2 before you got text input events.  Hmm...

     */

    if (!SDL_HasScreenKeyboardSupport()) {

        SDL_StartTextInput();

    }

    /* We're ready to go! */

    return 0;

}

const char *

SDL_GetCurrentVideoDriver()

{

    if (!_this) {

        SDL_UninitializedVideo();

        return NULL;

    }

    return _this->name;

}

SDL_VideoDevice *

SDL_GetVideoDevice(void)

{

    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;

        if (display->name) {

            displays[index].name = SDL_strdup(display->name);

        } else {

            char name[32];

            SDL_itoa(index, name, 10);

            displays[index].name = SDL_strdup(name);

        }

    } else {

        SDL_OutOfMemory();

    }

    return index;

}

int

SDL_GetNumVideoDisplays(void)

{

    if (!_this) {

        SDL_UninitializedVideo();

        return 0;

    }

    return _this->num_displays;

}

static int

SDL_GetIndexOfDisplay(SDL_VideoDisplay *display)

{

    int displayIndex;

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

        if (display == &_this->displays[displayIndex]) {

            return displayIndex;

        }

    }

    /* Couldn't find the display, just use index 0 */

    return 0;

}

const char *

SDL_GetDisplayName(int displayIndex)

{

    CHECK_DISPLAY_INDEX(displayIndex, NULL);

    return _this->displays[displayIndex].name;

}

int

SDL_GetDisplayBounds(int displayIndex, SDL_Rect * rect)

{

    CHECK_DISPLAY_INDEX(displayIndex, -1);

    if (rect) {

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

        if (_this->GetDisplayBounds) {

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

                return 0;

            }

        }

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

        if (displayIndex == 0) {

            rect->x = 0;

            rect->y = 0;

        } else {

            SDL_GetDisplayBounds(displayIndex-1, rect);

            rect->x += rect->w;

        }

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

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

    }

    return 0;

}

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;

}

static 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(int displayIndex)

{

    CHECK_DISPLAY_INDEX(displayIndex, -1);

    return SDL_GetNumDisplayModesForDisplay(&_this->displays[displayIndex]);

}

int

SDL_GetDisplayMode(int displayIndex, int index, SDL_DisplayMode * mode)

{

    SDL_VideoDisplay *display;

    CHECK_DISPLAY_INDEX(displayIndex, -1);

    display = &_this->displays[displayIndex];

    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_GetDesktopDisplayMode(int displayIndex, SDL_DisplayMode * mode)

{

    SDL_VideoDisplay *display;

    CHECK_DISPLAY_INDEX(displayIndex, -1);

    display = &_this->displays[displayIndex];

    if (mode) {

        *mode = display->desktop_mode;

    }

    return 0;

}

int

SDL_GetCurrentDisplayMode(int displayIndex, SDL_DisplayMode * mode)

{

    SDL_VideoDisplay *display;

    CHECK_DISPLAY_INDEX(displayIndex, -1);

    display = &_this->displays[displayIndex];

    if (mode) {

        *mode = display->current_mode;

    }

    return 0;

}

static SDL_DisplayMode *

SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay * display,

                                    const SDL_DisplayMode * mode,

                                    SDL_DisplayMode * closest)

{

    Uint32 target_format;

    int target_refresh_rate;

    int i;

    SDL_DisplayMode *current, *match;

    if (!mode || !closest) {

        SDL_SetError("Missing desired mode or closest mode parameter");

        return NULL;

    }

    /* Default to the desktop format */

    if (mode->format) {

        target_format = mode->format;

    } else {

        target_format = display->desktop_mode.format;

    }

    /* Default to the desktop refresh rate */

    if (mode->refresh_rate) {

        target_refresh_rate = mode->refresh_rate;

    } else {

        target_refresh_rate = display->desktop_mode.refresh_rate;

    }

    match = NULL;

    for (i = 0; i < SDL_GetNumDisplayModesForDisplay(display); ++i) {

        current = &display->display_modes[i];

        if (current->w && (current->w < mode->w)) {

            /* Out of sorted modes large enough here */

            break;

        }

        if (current->h && (current->h < mode->h)) {

            if (current->w && (current->w == mode->w)) {

                /* Out of sorted modes large enough here */

                break;

            }

            /* Wider, but not tall enough, due to a different

               aspect ratio. This mode must be skipped, but closer

               modes may still follow. */

            continue;

        }

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

                 SDL_PIXELTYPE(target_format))) {

                match = current;

            }

            continue;

        }

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

            /* Sorted highest refresh to lowest */

            if (current->refresh_rate >= target_refresh_rate) {

                match = current;

            }

        }

    }

    if (match) {

        if (match->format) {

            closest->format = match->format;

        } else {

            closest->format = mode->format;

        }

        if (match->w && match->h) {

            closest->w = match->w;

            closest->h = match->h;

        } else {

            closest->w = mode->w;

            closest->h = mode->h;

        }

        if (match->refresh_rate) {

            closest->refresh_rate = match->refresh_rate;

        } else {

            closest->refresh_rate = mode->refresh_rate;

        }

        closest->driverdata = match->driverdata;

        /*

         * Pick some reasonable defaults if the app and driver don't

         * care

         */

        if (!closest->format) {

            closest->format = SDL_PIXELFORMAT_RGB888;

        }

        if (!closest->w) {

            closest->w = 640;

        }

        if (!closest->h) {

            closest->h = 480;

        }

        return closest;

    }

    return NULL;

}

SDL_DisplayMode *

SDL_GetClosestDisplayMode(int displayIndex,

                          const SDL_DisplayMode * mode,

                          SDL_DisplayMode * closest)

{

    SDL_VideoDisplay *display;

    CHECK_DISPLAY_INDEX(displayIndex, NULL);

    display = &_this->displays[displayIndex];

    return SDL_GetClosestDisplayModeForDisplay(display, mode, closest);

}

static int

SDL_SetDisplayModeForDisplay(SDL_VideoDisplay * display, const SDL_DisplayMode * mode)

{

    SDL_DisplayMode display_mode;

    SDL_DisplayMode current_mode;

    if (mode) {

        display_mode = *mode;

        /* Default to the current mode */

        if (!display_mode.format) {

            display_mode.format = display->current_mode.format;

        }

        if (!display_mode.w) {

            display_mode.w = display->current_mode.w;

        }

        if (!display_mode.h) {

            display_mode.h = display->current_mode.h;

        }

        if (!display_mode.refresh_rate) {

            display_mode.refresh_rate = display->current_mode.refresh_rate;

        }

        /* Get a good video mode, the closest one possible */

        if (!SDL_GetClosestDisplayModeForDisplay(display, &display_mode, &display_mode)) {

            SDL_SetError("No video mode large enough for %dx%d",

                         display_mode.w, display_mode.h);

            return -1;

        }

    } else {

        display_mode = display->desktop_mode;

    }

    /* See if there's anything left to do */

    current_mode = display->current_mode;

    if (SDL_memcmp(&display_mode, &current_mode, sizeof(display_mode)) == 0) {

        return 0;

    }

    /* Actually change the display mode */

    if (!_this->SetDisplayMode) {

        SDL_SetError("Video driver doesn't support changing display mode");

        return -1;

    }

    if (_this->SetDisplayMode(_this, display, &display_mode) < 0) {

        return -1;

    }

    display->current_mode = display_mode;

    return 0;

}

int

SDL_GetWindowDisplayIndex(SDL_Window * window)

{

    int displayIndex;

    int i, dist;

    int closest = -1;

    int closest_dist = 0x7FFFFFFF;

    SDL_Point center;

    SDL_Point delta;

    SDL_Rect rect;

    CHECK_WINDOW_MAGIC(window, -1);

    if (SDL_WINDOWPOS_ISUNDEFINED(window->x) ||

        SDL_WINDOWPOS_ISCENTERED(window->x)) {

        displayIndex = (window->x & 0xFFFF);

        if (displayIndex >= _this->num_displays) {

            displayIndex = 0;

        }

        return displayIndex;

    }

    if (SDL_WINDOWPOS_ISUNDEFINED(window->y) ||

        SDL_WINDOWPOS_ISCENTERED(window->y)) {

        displayIndex = (window->y & 0xFFFF);

        if (displayIndex >= _this->num_displays) {

            displayIndex = 0;

        }

        return displayIndex;

    }

    /* Find the display containing the window */

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

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

        if (display->fullscreen_window == window) {

            return i;

        }

    }

    center.x = window->x + window->w / 2;

    center.y = window->y + window->h / 2;

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

        SDL_GetDisplayBounds(i, &rect);

        if (SDL_EnclosePoints(&center, 1, &rect, NULL)) {

            return i;

        }

        delta.x = center.x - (rect.x + rect.w / 2);

        delta.y = center.y - (rect.y + rect.h / 2);

        dist = (delta.x*delta.x + delta.y*delta.y);

        if (dist < closest_dist) {

            closest = i;

            closest_dist = dist;

        }

    }

    if (closest < 0) {

        SDL_SetError("Couldn't find any displays");

    }

    return closest;

}

SDL_VideoDisplay *