/*

    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 *

{

    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;

    } else {

        }

    }

    }

    if (!texture) {

    }

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

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

        if (SDL_MUSTLOCK(surface)) {

            SDL_LockSurface(surface);

            SDL_UnlockSurface(surface);

        } else {

        }

    } else {

        SDL_PixelFormat dst_fmt;

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

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

            SDL_DestroyTexture(texture);

        }

    }

    {

        Uint8 r, g, b, a;

        SDL_BlendMode blendMode;

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

        SDL_SetTextureColorMod(texture, r, g, b);

        SDL_GetSurfaceAlphaMod(surface, &a);

        SDL_SetTextureAlphaMod(texture, a);

        if (SDL_GetColorKey(surface, NULL) == 0) {

            /* We converted to a texture with alpha format */

            SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);

        } else {

            SDL_GetSurfaceBlendMode(surface, &blendMode);

            SDL_SetTextureBlendMode(texture, blendMode);

        }

    }

    return texture;

}

int

SDL_QueryTexture(SDL_Texture * texture, Uint32 * format, int *access,

                 int *w, int *h)

{

    CHECK_TEXTURE_MAGIC(texture, -1);

    if (format) {

        *format = texture->format;

    }

    if (access) {

        *access = texture->access;

    }

    if (w) {

        *w = texture->w;

    }

    if (h) {

        *h = texture->h;

    }

    return 0;

}

int

SDL_SetTextureColorMod(SDL_Texture * texture, Uint8 r, Uint8 g, Uint8 b)

{

    SDL_Renderer *renderer;

    CHECK_TEXTURE_MAGIC(texture, -1);

    renderer = texture->renderer;

    if (r < 255 || g < 255 || b < 255) {

        texture->modMode |= SDL_TEXTUREMODULATE_COLOR;

    } else {

        texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;

    }

    texture->r = r;

    texture->g = g;

    texture->b = b;

    if (texture->native) {

        return SDL_SetTextureColorMod(texture->native, r, g, b);

    } else if (renderer->SetTextureColorMod) {

        return renderer->SetTextureColorMod(renderer, texture);

    } else {

        return 0;

    }

}

int

SDL_GetTextureColorMod(SDL_Texture * texture, Uint8 * r, Uint8 * g,

                       Uint8 * b)

{

    SDL_Renderer *renderer;

    CHECK_TEXTURE_MAGIC(texture, -1);

    renderer = texture->renderer;

    if (r) {

        *r = texture->r;

    }

    if (g) {

        *g = texture->g;

    }

    if (b) {

        *b = texture->b;

    }

    return 0;

}

int

SDL_SetTextureAlphaMod(SDL_Texture * texture, Uint8 alpha)

{

    SDL_Renderer *renderer;

    CHECK_TEXTURE_MAGIC(texture, -1);

    renderer = texture->renderer;

    if (alpha < 255) {

        texture->modMode |= SDL_TEXTUREMODULATE_ALPHA;

    } else {

        texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;

    }

    texture->a = alpha;

    if (texture->native) {

        return SDL_SetTextureAlphaMod(texture->native, alpha);

    } else if (renderer->SetTextureAlphaMod) {

        return renderer->SetTextureAlphaMod(renderer, texture);

    } else {

        return 0;

    }

}

int

SDL_GetTextureAlphaMod(SDL_Texture * texture, Uint8 * alpha)

{

    CHECK_TEXTURE_MAGIC(texture, -1);

    if (alpha) {

        *alpha = texture->a;

    }

    return 0;

}

int

SDL_SetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode blendMode)

{

    SDL_Renderer *renderer;

    CHECK_TEXTURE_MAGIC(texture, -1);

    renderer = texture->renderer;

    texture->blendMode = blendMode;

    if (texture->native) {

        return SDL_SetTextureBlendMode(texture, blendMode);

    } else if (renderer->SetTextureBlendMode) {

        return renderer->SetTextureBlendMode(renderer, texture);

    } else {

        return 0;

    }

}

int

SDL_GetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode *blendMode)

{

    CHECK_TEXTURE_MAGIC(texture, -1);

    if (blendMode) {

        *blendMode = texture->blendMode;

    }

    return 0;

}

static int

SDL_UpdateTextureYUV(SDL_Texture * texture, const SDL_Rect * rect,

                     const void *pixels, int pitch)

{

    SDL_Texture *native = texture->native;

    SDL_Rect full_rect;

    if (SDL_SW_UpdateYUVTexture(texture->yuv, rect, pixels, pitch) < 0) {

        return -1;

    }

    full_rect.x = 0;

    full_rect.y = 0;

    full_rect.w = texture->w;

    full_rect.h = texture->h;

    rect = &full_rect;

    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {

        /* We can lock the texture and copy to it */

        void *native_pixels;

        int native_pitch;

        if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {

            return -1;

        }

        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,

                            rect->w, rect->h, native_pixels, native_pitch);

        SDL_UnlockTexture(native);

    } else {

        /* Use a temporary buffer for updating */

        void *temp_pixels;

        int temp_pitch;

        temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);

        temp_pixels = SDL_malloc(rect->h * temp_pitch);

        if (!temp_pixels) {

            SDL_OutOfMemory();

            return -1;

        }

        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,

                            rect->w, rect->h, temp_pixels, temp_pitch);

        SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);

        SDL_free(temp_pixels);