/*

    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"

#if SDL_VIDEO_RENDER_X11

#include <limits.h> /* For INT_MIN and INT_MAX */

#include "SDL_x11video.h"

#include "../SDL_rect_c.h"

#include "../SDL_pixels_c.h"

#include "../SDL_yuv_sw_c.h"

/* X11 renderer implementation */

static SDL_Renderer *X11_CreateRenderer(SDL_Window * window, Uint32 flags);

static int X11_DisplayModeChanged(SDL_Renderer * renderer);

static int X11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);

static int X11_QueryTexturePixels(SDL_Renderer * renderer,

                                  SDL_Texture * texture, void **pixels,

                                  int *pitch);

static int X11_SetTextureBlendMode(SDL_Renderer * renderer,

                                   SDL_Texture * texture);

static int X11_SetTextureScaleMode(SDL_Renderer * renderer,

                                   SDL_Texture * texture);

static int X11_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,

                             const SDL_Rect * rect, const void *pixels,

                             int pitch);

static int X11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,

                           const SDL_Rect * rect, int markDirty,

                           void **pixels, int *pitch);

static void X11_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);

static int X11_SetDrawBlendMode(SDL_Renderer * renderer);

static int X11_RenderDrawPoints(SDL_Renderer * renderer,

                                const SDL_Point * points, int count);

static int X11_RenderDrawLines(SDL_Renderer * renderer,

                               const SDL_Point * points, int count);

static int X11_RenderDrawRects(SDL_Renderer * renderer,

                               const SDL_Rect ** rects, int count);

static int X11_RenderFillRects(SDL_Renderer * renderer,

                               const SDL_Rect ** rects, int count);

static int X11_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,

                          const SDL_Rect * srcrect, const SDL_Rect * dstrect);

static int X11_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,

                                Uint32 format, void * pixels, int pitch);

static int X11_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,

                                 Uint32 format, const void * pixels, int pitch);

static void X11_RenderPresent(SDL_Renderer * renderer);

static void X11_DestroyTexture(SDL_Renderer * renderer,

                               SDL_Texture * texture);

static void X11_DestroyRenderer(SDL_Renderer * renderer);

SDL_RenderDriver X11_RenderDriver = {

    X11_CreateRenderer,

    {

     "x11",

     (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |

      SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |

      SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_ACCELERATED),

     SDL_TEXTUREMODULATE_NONE,

     SDL_BLENDMODE_NONE,

     SDL_TEXTURESCALEMODE_NONE,

     0,

     {0},

     0,

     0}

};

typedef struct

{

    Display *display;

    int screen;

    Visual *visual;

    int depth;

    int scanline_pad;

    Window xwindow;

    Pixmap pixmaps[3];

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

    Pixmap mask;

    Picture xwindow_pict;

    Picture pixmap_picts[3];

    Picture drawable_pict;

    Picture mask_pict;

    int blend_op;

    XRenderPictFormat* xwindow_pict_fmt;

    GC mask_gc;

    SDL_bool use_xrender;

#endif

    int current_pixmap;

    Drawable drawable;

    SDL_PixelFormat format;

    GC gc;

    SDL_DirtyRectList dirty;

    SDL_bool makedirty;

} X11_RenderData;

typedef struct

{

    SDL_SW_YUVTexture *yuv;

    Uint32 format;

    Pixmap pixmap;

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

    Picture picture;

    XRenderPictFormat* picture_fmt;

    int blend_op;

//    SDL_bool use_xrender;

#endif

    XImage *image;

#ifndef NO_SHARED_MEMORY

    /* MIT shared memory extension information */

    XShmSegmentInfo shminfo;

#endif

    XImage *scaling_image;

    void *pixels;

    int pitch;

} X11_TextureData;

#ifndef NO_SHARED_MEMORY

/* Shared memory error handler routine */

static int shm_error;

static int (*X_handler) (Display *, XErrorEvent *) = NULL;

static int

shm_errhandler(Display * d, XErrorEvent * e)

{

    if (e->error_code == BadAccess) {

        shm_error = True;

        return (0);

    } else {

        return (X_handler(d, e));

    }

}

#endif /* ! NO_SHARED_MEMORY */

static void

UpdateYUVTextureData(SDL_Texture * texture)

{

    X11_TextureData *data = (X11_TextureData *) texture->driverdata;

    SDL_Rect rect;

    rect.x = 0;

    rect.y = 0;

    rect.w = texture->w;

    rect.h = texture->h;

    SDL_SW_CopyYUVToRGB(data->yuv, &rect, data->format, texture->w,

                        texture->h, data->pixels, data->pitch);

}

void

X11_AddRenderDriver(_THIS)

{

    SDL_RendererInfo *info = &X11_RenderDriver.info;

    SDL_DisplayMode *mode = &SDL_CurrentDisplay->desktop_mode;

    int i;

    info->texture_formats[info->num_texture_formats++] = mode->format;

    info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_YV12;

    info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_IYUV;

    info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_YUY2;

    info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_UYVY;

    info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_YVYU;

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

        SDL_AddRenderDriver(&_this->displays[i], &X11_RenderDriver);

    }

}

SDL_Renderer *

X11_CreateRenderer(SDL_Window * window, Uint32 flags)

{

    SDL_VideoDisplay *display = window->display;

    SDL_DisplayData *displaydata = (SDL_DisplayData *) display->driverdata;

    SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata;

    SDL_Renderer *renderer;

    X11_RenderData *data;

    XGCValues gcv;

    int i, n;

    int bpp;

    Uint32 Rmask, Gmask, Bmask, Amask;

    renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));

    if (!renderer) {

        SDL_OutOfMemory();

        return NULL;

    }

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

    if (!data) {

        X11_DestroyRenderer(renderer);

        SDL_OutOfMemory();

        return NULL;

    }

    data->display = windowdata->videodata->display;

    data->screen = displaydata->screen;

    data->visual = displaydata->visual;

    data->depth = displaydata->depth;

    data->scanline_pad = displaydata->scanline_pad;

    data->xwindow = windowdata->xwindow;

    renderer->DisplayModeChanged = X11_DisplayModeChanged;

    renderer->CreateTexture = X11_CreateTexture;

    renderer->QueryTexturePixels = X11_QueryTexturePixels;

    renderer->SetTextureBlendMode = X11_SetTextureBlendMode;

    renderer->SetTextureScaleMode = X11_SetTextureScaleMode;

    renderer->UpdateTexture = X11_UpdateTexture;

    renderer->LockTexture = X11_LockTexture;

    renderer->UnlockTexture = X11_UnlockTexture;

    renderer->SetDrawBlendMode = X11_SetDrawBlendMode;

    renderer->RenderDrawPoints = X11_RenderDrawPoints;

    renderer->RenderDrawLines = X11_RenderDrawLines;

    renderer->RenderDrawRects = X11_RenderDrawRects;

    renderer->RenderFillRects = X11_RenderFillRects;

    renderer->RenderCopy = X11_RenderCopy;

    renderer->RenderReadPixels = X11_RenderReadPixels;

    renderer->RenderWritePixels = X11_RenderWritePixels;

    renderer->RenderPresent = X11_RenderPresent;

    renderer->DestroyTexture = X11_DestroyTexture;

    renderer->DestroyRenderer = X11_DestroyRenderer;

    renderer->info = X11_RenderDriver.info;

    renderer->window = window;

    renderer->driverdata = data;

    renderer->info.flags = SDL_RENDERER_ACCELERATED;

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

        data->xwindow_pict_fmt = XRenderFindVisualFormat(data->display,

                                                         data->visual);

        data->xwindow_pict = XRenderCreatePicture(data->display,

                                                  data->xwindow,

                                                  data->xwindow_pict_fmt,

                                                  0, NULL);

        XRenderComposite(data->display,

                         PictOpClear,

                         data->xwindow_pict,

                         None,

                         data->xwindow_pict,

                         0, 0,

                         0, 0,

                         0, 0,

                         window->w, window->h);

        renderer->info.blend_modes |=

            (SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MASK);

        data->mask = XCreatePixmap(data->display, data->xwindow,

                                   window->w, window->h, 1);

        data->mask_pict =

            XRenderCreatePicture(data->display, data->mask,

                                 XRenderFindStandardFormat(data->display,

                                                           PictStandardA1),

                                 0, NULL);

        XGCValues gcv_mask;

        gcv_mask.foreground = 1;

        gcv_mask.background = 0;

        data->mask_gc = XCreateGC(data->display, data->mask,

                                  GCBackground | GCForeground, &gcv_mask);

        renderer->blendMode = SDL_BLENDMODE_BLEND;

        data->blend_op = PictOpOver;

    }

#endif

    if (flags & SDL_RENDERER_SINGLEBUFFER) {

        renderer->info.flags |=

            (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY);

        n = 0;

    } else if (flags & SDL_RENDERER_PRESENTFLIP2) {

        renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;

        n = 2;

    } else if (flags & SDL_RENDERER_PRESENTFLIP3) {

        renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;

        n = 3;

    } else {

        renderer->info.flags |= SDL_RENDERER_PRESENTCOPY;

        n = 1;

    }

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

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

        if (data->use_xrender) {

            data->pixmaps[i] = XCreatePixmap(data->display,

                                             data->xwindow,

                                             window->w,

                                             window->h,

                                             32);

        }

        else

#endif

        {

            data->pixmaps[i] =

                XCreatePixmap(data->display, data->xwindow, window->w, window->h,

                              displaydata->depth);

        }

        if (data->pixmaps[i] == None) {

            X11_DestroyRenderer(renderer);

            SDL_SetError("XCreatePixmap() failed");

            return NULL;

        }

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

            data->pixmap_picts[i] = 

                XRenderCreatePicture(data->display,

                                     data->pixmaps[i],

                                     XRenderFindStandardFormat(data->display,

                                                               PictStandardARGB32),

                                     0, None);

        }

#endif

    }

    if (n > 0) {

        data->drawable = data->pixmaps[0];

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

        if(data->use_xrender == SDL_TRUE)

            data->drawable_pict = data->pixmap_picts[0];

#endif

        data->makedirty = SDL_TRUE;

    } else {

        data->drawable = data->xwindow;

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

        if(data->use_xrender == SDL_TRUE)

            data->drawable_pict = data->xwindow_pict;

#endif

        data->makedirty = SDL_FALSE;

    }

    data->current_pixmap = 0;

    /* Get the format of the window */

    if (!SDL_PixelFormatEnumToMasks

        (display->current_mode.format, &bpp, &Rmask, &Gmask, &Bmask,

         &Amask)) {

        SDL_SetError("Unknown display format");

        X11_DestroyRenderer(renderer);

        return NULL;

    }

    SDL_InitFormat(&data->format, bpp, Rmask, Gmask, Bmask, Amask);

    /* Create the drawing context */

    gcv.graphics_exposures = False;

    data->gc =

        XCreateGC(data->display, data->xwindow, GCGraphicsExposures, &gcv);

    if (!data->gc) {

        X11_DestroyRenderer(renderer);

        SDL_SetError("XCreateGC() failed");

        return NULL;

    }

    return renderer;

}

static int

X11_DisplayModeChanged(SDL_Renderer * renderer)

{

    X11_RenderData *data = (X11_RenderData *) renderer->driverdata;

    SDL_Window *window = renderer->window;

    int i, n;

    if (renderer->info.flags & SDL_RENDERER_SINGLEBUFFER) {

        n = 0;

    } else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) {

        n = 2;

    } else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP3) {

        n = 3;

    } else {

        n = 1;

    }

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

        if (data->pixmaps[i] != None) {

            XFreePixmap(data->display, data->pixmaps[i]);

            data->pixmaps[i] = None;

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

            data->pixmap_picts[i] = None;

#endif

        }

    }

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

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

        if (data->use_xrender) {

            data->pixmaps[i] =

                XCreatePixmap(data->display,

                              data->xwindow,

                              window->w,

                              window->h,

                              32);

        }

        else

#endif

        {

            data->pixmaps[i] =

                XCreatePixmap(data->display, data->xwindow, window->w, window->h,

                              data->depth);

        }

        if (data->pixmaps[i] == None) {

            SDL_SetError("XCreatePixmap() failed");

            return -1;

        }

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

            data->pixmap_picts[i] = 

                XRenderCreatePicture(data->display,

                                     data->pixmaps[i],

                                     XRenderFindStandardFormat(data->display,

                                                               PictStandardARGB32),

                                     0, None);

            XRenderComposite(data->display,

                             PictOpClear,

                             data->pixmap_picts[i],

                             None,

                             data->pixmap_picts[i],

                             0, 0,

                             0, 0,

                             0, 0,

                             window->w, window->h);

       }

#endif

    }

    if (n > 0) {

        data->drawable = data->pixmaps[0];

#ifdef SDL_VIDEO_DRIVER_X11_XRENDER

        data->drawable_pict = data->pixmap_picts[0];

#endif

    }

    data->current_pixmap = 0;

    return 0;

}