/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2011 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 "../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; \

    }

/* Various local functions */

static void SDL_UpdateWindowGrab(SDL_Window * window);

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

        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;

    }

#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_Renderer *renderer;

    SDL_RendererInfo info;

    Uint32 i;

    data = SDL_GetWindowData(window, SDL_WINDOWTEXTUREDATA);

    if (!data) {

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

        if (!data) {

            SDL_OutOfMemory();

            return -1;

        }

        SDL_SetWindowData(window, SDL_WINDOWTEXTUREDATA, data);

    }

    renderer = data->renderer;

    if (!renderer) {

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

            return -1;

        }

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

            *format = info.texture_formats[i];

            break;

        }

    }

    data->texture = SDL_CreateTexture(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;

    return 0;

}

static int

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

{

    SDL_WindowTextureData *data;

#ifdef UPDATE_TEXTURE_SUBRECTS

    void *src, *dst;

    int src_pitch;

    int dst_pitch;

    int i, row, length;

#endif

    data = SDL_GetWindowData(window, SDL_WINDOWTEXTUREDATA);

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

        SDL_SetError("No window texture data");

        return -1;

    }

#ifdef UPDATE_TEXTURE_SUBRECTS

    src_pitch = data->pitch;

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

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

                        rects[i].y * src_pitch +

                        rects[i].x * data->bytes_per_pixel);

        if (SDL_LockTexture(data->texture, &rects[i], &dst, &dst_pitch) < 0) {

            return -1;

        }

        length = rects[i].w * data->bytes_per_pixel;

        for (row = rects[i].h; row--; ) {

            SDL_memcpy(dst, src, length);

            src = (Uint8*)src + src_pitch;

            dst = (Uint8*)dst + dst_pitch;

        }

        SDL_UnlockTexture(data->texture);

    }

#else

    if (SDL_UpdateTexture(data->texture, NULL, data->pixels, data->pitch) < 0) {

        return -1;

    }

#endif

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