/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2010 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 SDL 2D rendering system */

#include "SDL_render.h"

#include "SDL_sysrender.h"

#include "../video/SDL_pixels_c.h"

#define CHECK_RENDERER_MAGIC(renderer, retval) \

    if (!renderer || renderer->magic != &renderer_magic) { \

        SDL_SetError("Invalid renderer"); \

        return retval; \

    }

#define CHECK_TEXTURE_MAGIC(texture, retval) \

    if (!texture || texture->magic != &texture_magic) { \

        SDL_SetError("Invalid texture"); \

        return retval; \

    }

static const SDL_RenderDriver *render_drivers[] = {

#if SDL_VIDEO_RENDER_D3D

    &D3D_RenderDriver,

#endif

#if SDL_VIDEO_RENDER_OGL

    &GL_RenderDriver,

#endif

#if SDL_VIDEO_RENDER_OGL_ES

    &GL_ES_RenderDriver,

#endif

    &SW_RenderDriver

};

static char renderer_magic;

static char texture_magic;

int

SDL_GetNumRenderDrivers(void)

{

    return SDL_arraysize(render_drivers);

}

int

SDL_GetRenderDriverInfo(int index, SDL_RendererInfo * info)

{

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

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

                     SDL_GetNumRenderDrivers() - 1);

        return -1;

    }

    *info = render_drivers[index]->info;

    return 0;

}

static int

SDL_RendererEventWatch(void *userdata, SDL_Event *event)

{

    SDL_Renderer *renderer = (SDL_Renderer *)userdata;

    if (event->type == SDL_WINDOWEVENT && renderer->WindowEvent) {

        SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);

        if (window == renderer->window) {

            renderer->WindowEvent(renderer, &event->window);

        }

    }

    return 0;

}

SDL_Renderer *

SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)

{

    SDL_Renderer *renderer = NULL;

    int n = SDL_GetNumRenderDrivers();

    if (index < 0) {

        char *override = SDL_getenv("SDL_VIDEO_RENDERER");

        if (override) {

            for (index = 0; index < n; ++index) {

                const SDL_RenderDriver *driver = render_drivers[index];

                if (SDL_strcasecmp(override, driver->info.name) == 0) {

                    /* Create a new renderer instance */

                    renderer = driver->CreateRenderer(window, flags);

                    break;

                }

            }

        } else {

            for (index = 0; index < n; ++index) {

                const SDL_RenderDriver *driver = render_drivers[index];

                if ((driver->info.flags & flags) == flags) {

                    /* Create a new renderer instance */

                    renderer = driver->CreateRenderer(window, flags);

                    if (renderer) {

                        /* Yay, we got one! */

                        break;

                    }

                }

            }

        }

        if (index == n) {

            SDL_SetError("Couldn't find matching render driver");

            return NULL;

        }

    } else {

        if (index >= SDL_GetNumRenderDrivers()) {

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

                         SDL_GetNumRenderDrivers() - 1);

            return NULL;

        }

        /* Create a new renderer instance */

        renderer = render_drivers[index]->CreateRenderer(window, flags);

    }

    if (renderer) {

        renderer->magic = &renderer_magic;

        SDL_AddEventWatch(SDL_RendererEventWatch, renderer);

    }

    return renderer;

}

int

SDL_GetRendererInfo(SDL_Renderer * renderer, SDL_RendererInfo * info)

{

    CHECK_RENDERER_MAGIC(renderer, -1);

    *info = renderer->info;

    return 0;

}

static SDL_bool

IsSupportedFormat(SDL_Renderer * renderer, Uint32 format)

{

    Uint32 i;

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

        if (renderer->info.texture_formats[i] == format) {

            return SDL_TRUE;

        }

    }

    return SDL_FALSE;

}

static Uint32

GetClosestSupportedFormat(SDL_Renderer * renderer, Uint32 format)

{

    Uint32 i;

    SDL_bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format);

    /* We just want to match the first format that has the same channels */

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

        if (SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == hasAlpha) {

            return renderer->info.texture_formats[i];

        }

    }

    return renderer->info.texture_formats[0];

}

SDL_Texture *

SDL_CreateTexture(SDL_Renderer * renderer, Uint32 format, int access, int w, int h)

{

    SDL_Texture *texture;

    CHECK_RENDERER_MAGIC(renderer, NULL);

    if (SDL_ISPIXELFORMAT_INDEXED(format)) {

        SDL_SetError("Palettized textures are not supported");

        return NULL;

    }

    if (w <= 0 || h <= 0) {

        SDL_SetError("Texture dimensions can't be 0");

        return NULL;

    }

    texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));

    if (!texture) {

        SDL_OutOfMemory();

        return NULL;

    }

    texture->magic = &texture_magic;

    texture->format = format;

    texture->access = access;

    texture->w = w;

    texture->h = h;

    texture->r = 255;

    texture->g = 255;

    texture->b = 255;

    texture->a = 255;

    texture->renderer = renderer;

    texture->next = renderer->textures;

    if (renderer->textures) {

        renderer->textures->prev = texture;

    }

    renderer->textures = texture;

    if (IsSupportedFormat(renderer, format)) {

        if (renderer->CreateTexture(renderer, texture) < 0) {

            SDL_DestroyTexture(texture);

            return 0;

        }

    } else {

        texture->native = SDL_CreateTexture(renderer,

                                GetClosestSupportedFormat(renderer, format),

                                access, w, h);

        if (!texture->native) {

            SDL_DestroyTexture(texture);

            return NULL;

        }

        if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {

            texture->yuv = SDL_SW_CreateYUVTexture(format, w, h);

            if (!texture->yuv) {

                SDL_DestroyTexture(texture);

                return NULL;

            }

        } else if (access == SDL_TEXTUREACCESS_STREAMING) {

            /* The pitch is 4 byte aligned */

            texture->pitch = (((w * SDL_BYTESPERPIXEL(format)) + 3) & ~3);

            texture->pixels = SDL_malloc(texture->pitch * h);

            if (!texture->pixels) {

                SDL_DestroyTexture(texture);

                return NULL;

            }

        }

    }

    return texture;

}

SDL_Texture *

SDL_CreateTextureFromSurface(SDL_Renderer * renderer, Uint32 format, SDL_Surface * surface)

{

    SDL_Texture *texture;

    Uint32 requested_format = format;

    SDL_PixelFormat *fmt;

    int bpp;

    Uint32 Rmask, Gmask, Bmask, Amask;

    CHECK_RENDERER_MAGIC(renderer, NULL);

    if (!surface) {

        SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");

        return NULL;

    }

    fmt = surface->format;

    if (format) {

        if (!SDL_PixelFormatEnumToMasks

            (format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {

            SDL_SetError("Unknown pixel format");

            return 0;

        }

    } else {

        SDL_bool hasColorkey;

        SDL_BlendMode blendMode;

        SDL_bool hasBlending;

        hasColorkey = (SDL_GetColorKey(surface, NULL) == 0);

        SDL_GetSurfaceBlendMode(surface, &blendMode);

        hasBlending = (blendMode == SDL_BLENDMODE_BLEND);

        if (surface->format->Amask || (!hasColorkey && !hasBlending)) {

            Uint32 it;

            int pfmt;

            /* Pixel formats, sorted by best first */

            static const Uint32 sdl_pformats[] = {

                SDL_PIXELFORMAT_ARGB8888,

                SDL_PIXELFORMAT_RGBA8888,

                SDL_PIXELFORMAT_ABGR8888,

                SDL_PIXELFORMAT_BGRA8888,

                SDL_PIXELFORMAT_RGB888,

                SDL_PIXELFORMAT_BGR888,

                SDL_PIXELFORMAT_RGB24,

                SDL_PIXELFORMAT_BGR24,

                SDL_PIXELFORMAT_RGB565,

                SDL_PIXELFORMAT_BGR565,

                SDL_PIXELFORMAT_ARGB1555,

                SDL_PIXELFORMAT_RGBA5551,

                SDL_PIXELFORMAT_ABGR1555,

                SDL_PIXELFORMAT_BGRA5551,

                SDL_PIXELFORMAT_RGB555,

                SDL_PIXELFORMAT_BGR555,

                SDL_PIXELFORMAT_ARGB4444,

                SDL_PIXELFORMAT_RGBA4444,

                SDL_PIXELFORMAT_ABGR4444,

                SDL_PIXELFORMAT_BGRA4444,

                SDL_PIXELFORMAT_RGB444,

                SDL_PIXELFORMAT_ARGB2101010,

                SDL_PIXELFORMAT_RGB332,

                SDL_PIXELFORMAT_UNKNOWN

            };

            bpp = fmt->BitsPerPixel;

            Rmask = fmt->Rmask;

            Gmask = fmt->Gmask;

            Bmask = fmt->Bmask;

            Amask = fmt->Amask;

            format =

                SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);

            if (!format) {

                SDL_SetError("Unknown pixel format");

                return 0;

            }

            /* Search requested format in the supported texture */

            /* formats by current renderer                      */

            for (it = 0; it < renderer->info.num_texture_formats; it++) {

                if (renderer->info.texture_formats[it] == format) {

                    break;

                }

            }

            /* If requested format can't be found, search any best */

            /* format which renderer provides                      */

            if (it == renderer->info.num_texture_formats) {

                pfmt = 0;

                for (;;) {

                    if (sdl_pformats[pfmt] == SDL_PIXELFORMAT_UNKNOWN) {

                        break;

                    }

                    for (it = 0; it < renderer->info.num_texture_formats;

                         it++) {

                        if (renderer->info.texture_formats[it] ==

                            sdl_pformats[pfmt]) {

                            break;

                        }

                    }

                    if (it != renderer->info.num_texture_formats) {

                        /* The best format has been found */

                        break;

                    }

                    pfmt++;

                }

                /* If any format can't be found, then return an error */

                if (it == renderer->info.num_texture_formats) {

                    SDL_SetError

                        ("Any of the supported pixel formats can't be found");

                    return 0;

                }

                /* Convert found pixel format back to color masks */

                if (SDL_PixelFormatEnumToMasks

                    (renderer->info.texture_formats[it], &bpp, &Rmask, &Gmask,

                     &Bmask, &Amask) != SDL_TRUE) {

                    SDL_SetError("Unknown pixel format");

                    return 0;

                }

            }

        } else {

            /* Need a format with alpha */

            Uint32 it;

            int apfmt;

            /* Pixel formats with alpha, sorted by best first */

            static const Uint32 sdl_alpha_pformats[] = {

                SDL_PIXELFORMAT_ARGB8888,

                SDL_PIXELFORMAT_RGBA8888,

                SDL_PIXELFORMAT_ABGR8888,

                SDL_PIXELFORMAT_BGRA8888,

                SDL_PIXELFORMAT_ARGB1555,

                SDL_PIXELFORMAT_RGBA5551,

                SDL_PIXELFORMAT_ABGR1555,

                SDL_PIXELFORMAT_BGRA5551,

                SDL_PIXELFORMAT_ARGB4444,

                SDL_PIXELFORMAT_RGBA4444,

                SDL_PIXELFORMAT_ABGR4444,

                SDL_PIXELFORMAT_BGRA4444,

                SDL_PIXELFORMAT_ARGB2101010,

                SDL_PIXELFORMAT_UNKNOWN

            };

            if (surface->format->Amask) {

                /* If surface already has alpha, then try an original */

                /* surface format first                               */

                bpp = fmt->BitsPerPixel;

                Rmask = fmt->Rmask;

                Gmask = fmt->Gmask;

                Bmask = fmt->Bmask;

                Amask = fmt->Amask;

            } else {

                bpp = 32;

                Rmask = 0x00FF0000;

                Gmask = 0x0000FF00;

                Bmask = 0x000000FF;

                Amask = 0xFF000000;

            }

            format =

                SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);

            if (!format) {

                SDL_SetError("Unknown pixel format");

                return 0;

            }

            /* Search this format in the supported texture formats */

            /* by current renderer                                 */

            for (it = 0; it < renderer->info.num_texture_formats; it++) {

                if (renderer->info.texture_formats[it] == format) {

                    break;

                }

            }

            /* If this format can't be found, search any best       */

            /* compatible format with alpha which renderer provides */

            if (it == renderer->info.num_texture_formats) {

                apfmt = 0;

                for (;;) {

                    if (sdl_alpha_pformats[apfmt] == SDL_PIXELFORMAT_UNKNOWN) {

                        break;

                    }

                    for (it = 0; it < renderer->info.num_texture_formats;

                         it++) {

                        if (renderer->info.texture_formats[it] ==

                            sdl_alpha_pformats[apfmt]) {

                            break;

                        }

                    }

                    if (it != renderer->info.num_texture_formats) {

                        /* Compatible format has been found */

                        break;

                    }

                    apfmt++;

                }

                /* If compatible format can't be found, then return an error */

                if (it == renderer->info.num_texture_formats) {

                    SDL_SetError("Compatible pixel format can't be found");

                    return 0;

                }

                /* Convert found pixel format back to color masks */

                if (SDL_PixelFormatEnumToMasks

                    (renderer->info.texture_formats[it], &bpp, &Rmask, &Gmask,

                     &Bmask, &Amask) != SDL_TRUE) {

                    SDL_SetError("Unknown pixel format");

                    return 0;

                }

            }

        }

        format = SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);

        if (!format) {

            SDL_SetError("Unknown pixel format");

            return 0;

        }

    }

    texture =

        SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_STATIC,

                          surface->w, surface->h);

    if (!texture && !requested_format) {

        SDL_DisplayMode desktop_mode;

        SDL_GetDesktopDisplayMode(&desktop_mode);

        format = desktop_mode.format;

        texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_STATIC,

                                    surface->w, surface->h);

    }

    if (!texture) {

        return 0;

    }

    if (bpp == fmt->BitsPerPixel && Rmask == fmt->Rmask && Gmask == fmt->Gmask

        && Bmask == fmt->Bmask && Amask == fmt->Amask) {

        if (SDL_MUSTLOCK(surface)) {

            SDL_LockSurface(surface);

            SDL_UpdateTexture(texture, NULL, surface->pixels,

                              surface->pitch);

            SDL_UnlockSurface(surface);

        } else {

            SDL_UpdateTexture(texture, NULL, surface->pixels,

                              surface->pitch);

        }

    } else {

        SDL_PixelFormat dst_fmt;

        SDL_Surface *dst = NULL;

        /* Set up a destination surface for the texture update */

        SDL_InitFormat(&dst_fmt, bpp, Rmask, Gmask, Bmask, Amask);

        dst = SDL_ConvertSurface(surface, &dst_fmt, 0);

        if (dst) {

            SDL_UpdateTexture(texture, NULL, dst->pixels, dst->pitch);

            SDL_FreeSurface(dst);

        }

        if (!dst) {

            SDL_DestroyTexture(texture);

            return 0;

        }

    }

    {

        Uint8 r, g, b, a;

        SDL_BlendMode blendMode;

        SDL_GetSurfaceColorMod(surface, &r, &g, &b);

        SDL_SetTextureColorMod(texture, r, g, b);