alphatau 0.1.0

data/ext/alphatau/native/sdl/src/video/directfb/SDL_DirectFB_opengl.h

@@ -0,0 +1,64 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2018 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.
+*/
+
+
+#ifndef SDL_directfb_opengl_h_
+#define SDL_directfb_opengl_h_
+
+#include "SDL_DirectFB_video.h"
+
+#if SDL_DIRECTFB_OPENGL
+
+#include "SDL_opengl.h"
+
+typedef struct _DirectFB_GLContext DirectFB_GLContext;
+struct _DirectFB_GLContext
+{
+    IDirectFBGL         *context;
+    DirectFB_GLContext  *next;
+
+    SDL_Window          *sdl_window;
+    int                 is_locked;
+};
+
+/* OpenGL functions */
+extern int DirectFB_GL_Initialize(_THIS);
+extern void DirectFB_GL_Shutdown(_THIS);
+
+extern int DirectFB_GL_LoadLibrary(_THIS, const char *path);
+extern void *DirectFB_GL_GetProcAddress(_THIS, const char *proc);
+extern SDL_GLContext DirectFB_GL_CreateContext(_THIS, SDL_Window * window);
+extern int DirectFB_GL_MakeCurrent(_THIS, SDL_Window * window,
+                                   SDL_GLContext context);
+extern int DirectFB_GL_SetSwapInterval(_THIS, int interval);
+extern int DirectFB_GL_GetSwapInterval(_THIS);
+extern int DirectFB_GL_SwapWindow(_THIS, SDL_Window * window);
+extern void DirectFB_GL_DeleteContext(_THIS, SDL_GLContext context);
+
+extern void DirectFB_GL_FreeWindowContexts(_THIS, SDL_Window * window);
+extern void DirectFB_GL_ReAllocWindowContexts(_THIS, SDL_Window * window);
+extern void DirectFB_GL_DestroyWindowContexts(_THIS, SDL_Window * window);
+
+#endif /* SDL_DIRECTFB_OPENGL */
+
+#endif /* SDL_directfb_opengl_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */

data/ext/alphatau/native/sdl/src/video/directfb/SDL_DirectFB_render.c

@@ -0,0 +1,1335 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2018 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_internal.h"
+
+#if SDL_VIDEO_DRIVER_DIRECTFB
+#include "SDL_DirectFB_window.h"
+#include "SDL_DirectFB_modes.h"
+
+#include "SDL_syswm.h"
+#include "SDL_DirectFB_shape.h"
+
+#include "../SDL_sysvideo.h"
+#include "../../render/SDL_sysrender.h"
+
+#ifndef DFB_VERSION_ATLEAST
+
+#define DFB_VERSIONNUM(X, Y, Z)                     \
+    ((X)*1000 + (Y)*100 + (Z))
+
+#define DFB_COMPILEDVERSION \
+    DFB_VERSIONNUM(DIRECTFB_MAJOR_VERSION, DIRECTFB_MINOR_VERSION, DIRECTFB_MICRO_VERSION)
+
+#define DFB_VERSION_ATLEAST(X, Y, Z) \
+    (DFB_COMPILEDVERSION >= DFB_VERSIONNUM(X, Y, Z))
+
+#define SDL_DFB_CHECK(x)    x
+
+#endif
+
+/* the following is not yet tested ... */
+#define USE_DISPLAY_PALETTE         (0)
+
+
+#define SDL_DFB_RENDERERDATA(rend) DirectFB_RenderData *renddata = ((rend) ? (DirectFB_RenderData *) (rend)->driverdata : NULL)
+
+
+/* DirectFB renderer implementation */
+
+static SDL_Renderer *DirectFB_CreateRenderer(SDL_Window * window,
+                                             Uint32 flags);
+static void DirectFB_ActivateRenderer(SDL_Renderer * renderer);
+static int DirectFB_CreateTexture(SDL_Renderer * renderer,
+                                  SDL_Texture * texture);
+static int DirectFB_QueryTexturePixels(SDL_Renderer * renderer,
+                                       SDL_Texture * texture,
+                                       void **pixels, int *pitch);
+static int DirectFB_SetTexturePalette(SDL_Renderer * renderer,
+                                      SDL_Texture * texture,
+                                      const SDL_Color * colors,
+                                      int firstcolor, int ncolors);
+static int DirectFB_GetTexturePalette(SDL_Renderer * renderer,
+                                      SDL_Texture * texture,
+                                      SDL_Color * colors,
+                                      int firstcolor, int ncolors);
+static int DirectFB_SetTextureAlphaMod(SDL_Renderer * renderer,
+                                       SDL_Texture * texture);
+static int DirectFB_SetTextureColorMod(SDL_Renderer * renderer,
+                                       SDL_Texture * texture);
+static int DirectFB_SetTextureBlendMode(SDL_Renderer * renderer,
+                                        SDL_Texture * texture);
+static int DirectFB_SetTextureScaleMode(SDL_Renderer * renderer,
+                                        SDL_Texture * texture);
+static int DirectFB_UpdateTexture(SDL_Renderer * renderer,
+                                  SDL_Texture * texture,
+                                  const SDL_Rect * rect,
+                                  const void *pixels, int pitch);
+static int DirectFB_LockTexture(SDL_Renderer * renderer,
+                                SDL_Texture * texture,
+                                const SDL_Rect * rect,
+                                void **pixels, int *pitch);
+static void DirectFB_UnlockTexture(SDL_Renderer * renderer,
+                                   SDL_Texture * texture);
+static void DirectFB_DirtyTexture(SDL_Renderer * renderer,
+                                  SDL_Texture * texture, int numrects,
+                                  const SDL_Rect * rects);
+static int DirectFB_SetDrawBlendMode(SDL_Renderer * renderer);
+static int DirectFB_RenderDrawPoints(SDL_Renderer * renderer,
+                                const SDL_FPoint * points, int count);
+static int DirectFB_RenderDrawLines(SDL_Renderer * renderer,
+                               const SDL_FPoint * points, int count);
+static int DirectFB_RenderDrawRects(SDL_Renderer * renderer,
+        const SDL_Rect ** rects, int count);
+static int DirectFB_RenderFillRects(SDL_Renderer * renderer,
+        const SDL_FRect * rects, int count);
+static int DirectFB_RenderCopy(SDL_Renderer * renderer,
+                               SDL_Texture * texture,
+                               const SDL_Rect * srcrect,
+                               const SDL_FRect * dstrect);
+static void DirectFB_RenderPresent(SDL_Renderer * renderer);
+static void DirectFB_DestroyTexture(SDL_Renderer * renderer,
+                                    SDL_Texture * texture);
+static void DirectFB_DestroyRenderer(SDL_Renderer * renderer);
+static int DirectFB_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
+                     Uint32 format, void * pixels, int pitch);
+static int DirectFB_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
+                      Uint32 format, const void * pixels, int pitch);
+static int DirectFB_UpdateViewport(SDL_Renderer * renderer);
+static int DirectFB_UpdateClipRect(SDL_Renderer * renderer);
+static int DirectFB_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture);
+
+static int PrepareDraw(SDL_Renderer * renderer);
+
+
+#define SDL_DFB_WINDOWSURFACE(win)  IDirectFBSurface *destsurf = ((DFB_WindowData *) ((win)->driverdata))->surface;
+
+SDL_RenderDriver DirectFB_RenderDriver = {
+    DirectFB_CreateRenderer,
+    {
+     "directfb",
+     (SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
+     /* (SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
+      SDL_TEXTUREMODULATE_ALPHA),
+      (SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK | SDL_BLENDMODE_BLEND |
+      SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
+     (SDL_SCALEMODE_NONE | SDL_SCALEMODE_FAST |
+      SDL_SCALEMODE_SLOW | SDL_SCALEMODE_BEST), */
+     0,
+     {
+             /* formats filled in later */
+     },
+     0,
+     0}
+};
+
+typedef struct
+{
+    SDL_Window *window;
+    DFBSurfaceFlipFlags flipflags;
+    int size_changed;
+    int lastBlendMode;
+    DFBSurfaceBlittingFlags blitFlags;
+    DFBSurfaceDrawingFlags drawFlags;
+    IDirectFBSurface* target;
+} DirectFB_RenderData;
+
+typedef struct
+{
+    IDirectFBSurface *surface;
+    Uint32 format;
+    void *pixels;
+    int pitch;
+    IDirectFBPalette *palette;
+    int isDirty;
+
+    SDL_VideoDisplay *display;      /* only for yuv textures */
+
+#if (DFB_VERSION_ATLEAST(1,2,0))
+    DFBSurfaceRenderOptions render_options;
+#endif
+} DirectFB_TextureData;
+
+static SDL_INLINE void
+SDLtoDFBRect(const SDL_Rect * sr, DFBRectangle * dr)
+{
+    dr->x = sr->x;
+    dr->y = sr->y;
+    dr->h = sr->h;
+    dr->w = sr->w;
+}
+static SDL_INLINE void
+SDLtoDFBRect_Float(const SDL_FRect * sr, DFBRectangle * dr)
+{
+    dr->x = sr->x;
+    dr->y = sr->y;
+    dr->h = sr->h;
+    dr->w = sr->w;
+}
+
+
+static int
+TextureHasAlpha(DirectFB_TextureData * data)
+{
+    /* Drawing primitive ? */
+    if (!data)
+        return 0;
+
+    return (DFB_PIXELFORMAT_HAS_ALPHA(DirectFB_SDLToDFBPixelFormat(data->format)) ? 1 : 0);
+#if 0
+    switch (data->format) {
+    case SDL_PIXELFORMAT_INDEX4LSB:
+    case SDL_PIXELFORMAT_INDEX4MSB:
+    case SDL_PIXELFORMAT_ARGB4444:
+    case SDL_PIXELFORMAT_ARGB1555:
+    case SDL_PIXELFORMAT_ARGB8888:
+    case SDL_PIXELFORMAT_RGBA8888:
+    case SDL_PIXELFORMAT_ABGR8888:
+    case SDL_PIXELFORMAT_BGRA8888:
+    case SDL_PIXELFORMAT_ARGB2101010:
+       return 1;
+    default:
+        return 0;
+    }
+#endif
+}
+
+static SDL_INLINE IDirectFBSurface *get_dfb_surface(SDL_Window *window)
+{
+    SDL_SysWMinfo wm_info;
+    SDL_memset(&wm_info, 0, sizeof(SDL_SysWMinfo));
+
+    SDL_VERSION(&wm_info.version);
+    if (!SDL_GetWindowWMInfo(window, &wm_info)) {
+        return NULL;
+    }
+
+    return wm_info.info.dfb.surface;
+}
+
+static SDL_INLINE IDirectFBWindow *get_dfb_window(SDL_Window *window)
+{
+    SDL_SysWMinfo wm_info;
+    SDL_memset(&wm_info, 0, sizeof(SDL_SysWMinfo));
+
+    SDL_VERSION(&wm_info.version);
+    if (!SDL_GetWindowWMInfo(window, &wm_info)) {
+        return NULL;
+    }
+
+    return wm_info.info.dfb.window;
+}
+
+static void
+SetBlendMode(DirectFB_RenderData * data, int blendMode,
+             DirectFB_TextureData * source)
+{
+    IDirectFBSurface *destsurf = data->target;
+
+    /* FIXME: check for format change */
+    if (1 || data->lastBlendMode != blendMode) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_NONE:
+                                           /**< No blending */
+            data->blitFlags = DSBLIT_NOFX;
+            data->drawFlags = DSDRAW_NOFX;
+            SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE));
+            SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ZERO));
+            break;
+#if 0
+        case SDL_BLENDMODE_MASK:
+            data->blitFlags =  DSBLIT_BLEND_ALPHACHANNEL;
+            data->drawFlags = DSDRAW_BLEND;
+            SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
+            SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_INVSRCALPHA));
+            break;
+#endif
+        case SDL_BLENDMODE_BLEND:
+            data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
+            data->drawFlags = DSDRAW_BLEND;
+            SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
+            SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_INVSRCALPHA));
+            break;
+        case SDL_BLENDMODE_ADD:
+            data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
+            data->drawFlags = DSDRAW_BLEND;
+            /* FIXME: SRCALPHA kills performance on radeon ...
+             * It will be cheaper to copy the surface to a temporary surface and premultiply
+             */
+            if (source && TextureHasAlpha(source))
+                SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
+            else
+                SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE));
+            SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ONE));
+            break;
+        case SDL_BLENDMODE_MOD:
+            data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
+            data->drawFlags = DSDRAW_BLEND;
+            SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ZERO));
+            SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_SRCCOLOR));
+
+            break;
+        }
+        data->lastBlendMode = blendMode;
+    }
+}
+
+static int
+DisplayPaletteChanged(void *userdata, SDL_Palette * palette)
+{
+#if USE_DISPLAY_PALETTE
+    DirectFB_RenderData *data = (DirectFB_RenderData *) userdata;
+    SDL_DFB_WINDOWSURFACE(data->window);
+    IDirectFBPalette *surfpal;
+
+    int i;
+    int ncolors;
+    DFBColor entries[256];
+
+    SDL_DFB_CHECKERR(destsurf->GetPalette(destsurf, &surfpal));
+
+    /* FIXME: number of colors */
+    ncolors = (palette->ncolors < 256 ? palette->ncolors : 256);
+
+    for (i = 0; i < ncolors; ++i) {
+        entries[i].r = palette->colors[i].r;
+        entries[i].g = palette->colors[i].g;
+        entries[i].b = palette->colors[i].b;
+        entries[i].a = palette->colors[i].a;
+    }
+    SDL_DFB_CHECKERR(surfpal->SetEntries(surfpal, entries, ncolors, 0));
+    return 0;
+  error:
+#else
+    SDL_Unsupported();
+#endif
+    return -1;
+}
+
+static void
+DirectFB_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
+{
+    SDL_DFB_RENDERERDATA(renderer);
+
+    if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {
+        /* Rebind the context to the window area and update matrices */
+        /* SDL_CurrentContext = NULL; */
+        /* data->updateSize = SDL_TRUE; */
+        renddata->size_changed = SDL_TRUE;
+   }
+}
+
+static int
+DirectFB_RenderClear(SDL_Renderer * renderer)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *destsurf = data->target;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    PrepareDraw(renderer);
+
+    destsurf->Clear(destsurf, renderer->r, renderer->g, renderer->b, renderer->a);
+
+    return 0;
+}
+
+SDL_Renderer *
+DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)
+{
+    IDirectFBSurface *winsurf = get_dfb_surface(window);
+    SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
+    SDL_Renderer *renderer = NULL;
+    DirectFB_RenderData *data = NULL;
+    DFBSurfaceCapabilities scaps;
+
+    if (!winsurf) {
+        return NULL;
+    }
+
+    SDL_DFB_ALLOC_CLEAR(renderer, sizeof(*renderer));
+    SDL_DFB_ALLOC_CLEAR(data, sizeof(*data));
+
+    renderer->WindowEvent = DirectFB_WindowEvent;
+    renderer->CreateTexture = DirectFB_CreateTexture;
+    renderer->SetTextureAlphaMod = DirectFB_SetTextureAlphaMod;
+    renderer->SetTextureColorMod = DirectFB_SetTextureColorMod;
+    renderer->SetTextureBlendMode = DirectFB_SetTextureBlendMode;
+    renderer->UpdateTexture = DirectFB_UpdateTexture;
+    renderer->LockTexture = DirectFB_LockTexture;
+    renderer->RenderClear = DirectFB_RenderClear;
+    renderer->UnlockTexture = DirectFB_UnlockTexture;
+    renderer->RenderDrawPoints = DirectFB_RenderDrawPoints;
+    renderer->RenderDrawLines = DirectFB_RenderDrawLines;
+    /* SetDrawColor - no needed */
+    renderer->RenderFillRects = DirectFB_RenderFillRects;
+
+    renderer->RenderCopy = DirectFB_RenderCopy;
+    renderer->RenderPresent = DirectFB_RenderPresent;
+
+    /* FIXME: Yet to be tested */
+    renderer->RenderReadPixels = DirectFB_RenderReadPixels;
+    /* renderer->RenderWritePixels = DirectFB_RenderWritePixels; */
+
+    renderer->DestroyTexture = DirectFB_DestroyTexture;
+    renderer->DestroyRenderer = DirectFB_DestroyRenderer;
+    renderer->UpdateViewport = DirectFB_UpdateViewport;
+    renderer->UpdateClipRect = DirectFB_UpdateClipRect;
+    renderer->SetRenderTarget = DirectFB_SetRenderTarget;
+
+#if 0
+    renderer->QueryTexturePixels = DirectFB_QueryTexturePixels;
+    renderer->SetTexturePalette = DirectFB_SetTexturePalette;
+    renderer->GetTexturePalette = DirectFB_GetTexturePalette;
+    renderer->SetTextureScaleMode = DirectFB_SetTextureScaleMode;
+    renderer->DirtyTexture = DirectFB_DirtyTexture;
+    renderer->SetDrawBlendMode = DirectFB_SetDrawBlendMode;
+    renderer->RenderDrawRects = DirectFB_RenderDrawRects;
+#endif
+
+    renderer->info = DirectFB_RenderDriver.info;
+    renderer->window = window;      /* SDL window */
+    renderer->driverdata = data;
+
+    renderer->info.flags =
+        SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
+
+    data->window = window;
+    data->target = winsurf;
+
+    data->flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT;
+
+    if (flags & SDL_RENDERER_PRESENTVSYNC) {
+        data->flipflags |= DSFLIP_WAITFORSYNC | DSFLIP_ONSYNC;
+        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
+    } else
+        data->flipflags |= DSFLIP_ONSYNC;
+
+    SDL_DFB_CHECKERR(winsurf->GetCapabilities(winsurf, &scaps));
+
+#if 0
+    if (scaps & DSCAPS_DOUBLE)
+        renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;
+    else if (scaps & DSCAPS_TRIPLE)
+        renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;
+    else
+        renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER;
+#endif
+
+    DirectFB_SetSupportedPixelFormats(&renderer->info);
+
+#if 0
+    /* Set up a palette watch on the display palette */
+    if (display-> palette) {
+        SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data);
+    }
+#endif
+
+    return renderer;
+
+  error:
+    SDL_DFB_FREE(renderer);
+    SDL_DFB_FREE(data);
+    return NULL;
+}
+
+static void
+DirectFB_ActivateRenderer(SDL_Renderer * renderer)
+{
+    SDL_DFB_RENDERERDATA(renderer);
+    SDL_Window *window = renderer->window;
+    SDL_DFB_WINDOWDATA(window);
+
+    if (renddata->size_changed /* || windata->wm_needs_redraw */) {
+        renddata->size_changed = SDL_FALSE;
+    }
+}
+
+
+static int
+DirectFB_AcquireVidLayer(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    SDL_Window *window = renderer->window;
+    SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
+    SDL_DFB_DEVICEDATA(display->device);
+    DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;
+    DirectFB_TextureData *data = texture->driverdata;
+    DFBDisplayLayerConfig layconf;
+    DFBResult ret;
+
+    if (devdata->use_yuv_direct && (dispdata->vidID >= 0)
+        && (!dispdata->vidIDinuse)
+        && SDL_ISPIXELFORMAT_FOURCC(data->format)) {
+        layconf.flags =
+            DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT |
+            DLCONF_SURFACE_CAPS;
+        layconf.width = texture->w;
+        layconf.height = texture->h;
+        layconf.pixelformat = DirectFB_SDLToDFBPixelFormat(data->format);
+        layconf.surface_caps = DSCAPS_VIDEOONLY | DSCAPS_DOUBLE;
+
+        SDL_DFB_CHECKERR(devdata->dfb->GetDisplayLayer(devdata->dfb,
+                                                       dispdata->vidID,
+                                                       &dispdata->vidlayer));
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetCooperativeLevel(dispdata->vidlayer,
+                                                       DLSCL_EXCLUSIVE));
+
+        if (devdata->use_yuv_underlays) {
+            ret = dispdata->vidlayer->SetLevel(dispdata->vidlayer, -1);
+            if (ret != DFB_OK)
+                SDL_DFB_DEBUG("Underlay Setlevel not supported\n");
+        }
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetConfiguration(dispdata->vidlayer,
+                                                    &layconf));
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->GetSurface(dispdata->vidlayer,
+                                              &data->surface));
+        dispdata->vidIDinuse = 1;
+        data->display = display;
+        return 0;
+    }
+    return 1;
+  error:
+    if (dispdata->vidlayer) {
+        SDL_DFB_RELEASE(data->surface);
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetCooperativeLevel(dispdata->vidlayer,
+                                                       DLSCL_ADMINISTRATIVE));
+        SDL_DFB_RELEASE(dispdata->vidlayer);
+    }
+    return 1;
+}
+
+static int
+DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    SDL_Window *window = renderer->window;
+    SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
+    SDL_DFB_DEVICEDATA(display->device);
+    DirectFB_TextureData *data;
+    DFBSurfaceDescription dsc;
+    DFBSurfacePixelFormat pixelformat;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    SDL_DFB_ALLOC_CLEAR(data, sizeof(*data));
+    texture->driverdata = data;
+
+    /* find the right pixelformat */
+    pixelformat = DirectFB_SDLToDFBPixelFormat(texture->format);
+    if (pixelformat == DSPF_UNKNOWN) {
+        SDL_SetError("Unknown pixel format %d", data->format);
+        goto error;
+    }
+
+    data->format = texture->format;
+    data->pitch = texture->w * DFB_BYTES_PER_PIXEL(pixelformat);
+
+    if (DirectFB_AcquireVidLayer(renderer, texture) != 0) {
+        /* fill surface description */
+        dsc.flags =
+            DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS;
+        dsc.width = texture->w;
+        dsc.height = texture->h;
+        if(texture->format == SDL_PIXELFORMAT_YV12 ||
+           texture->format == SDL_PIXELFORMAT_IYUV) {
+           /* dfb has problems with odd sizes -make them even internally */
+           dsc.width += (dsc.width % 2);
+           dsc.height += (dsc.height % 2);
+        }
+        /* <1.2 Never use DSCAPS_VIDEOONLY here. It kills performance
+         * No DSCAPS_SYSTEMONLY either - let dfb decide
+         * 1.2: DSCAPS_SYSTEMONLY boosts performance by factor ~8
+         * Depends on other settings as well. Let dfb decide.
+         */
+        dsc.caps = DSCAPS_PREMULTIPLIED;
+#if 0
+        if (texture->access == SDL_TEXTUREACCESS_STREAMING)
+            dsc.caps |= DSCAPS_SYSTEMONLY;
+        else
+            dsc.caps |= DSCAPS_VIDEOONLY;
+#endif
+
+        dsc.pixelformat = pixelformat;
+        data->pixels = NULL;
+
+        /* Create the surface */
+        SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc,
+                                                     &data->surface));
+        if (SDL_ISPIXELFORMAT_INDEXED(data->format)
+            && !SDL_ISPIXELFORMAT_FOURCC(data->format)) {
+#if 1
+            SDL_DFB_CHECKERR(data->surface->GetPalette(data->surface, &data->palette));
+#else
+            /* DFB has issues with blitting LUT8 surfaces.
+             * Creating a new palette does not help.
+             */
+            DFBPaletteDescription pal_desc;
+            pal_desc.flags = DPDESC_SIZE; /* | DPDESC_ENTRIES */
+            pal_desc.size = 256;
+            SDL_DFB_CHECKERR(devdata->dfb->CreatePalette(devdata->dfb, &pal_desc,&data->palette));
+            SDL_DFB_CHECKERR(data->surface->SetPalette(data->surface, data->palette));
+#endif
+        }
+
+    }
+#if (DFB_VERSION_ATLEAST(1,2,0))
+    data->render_options = DSRO_NONE;
+#endif
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        /* 3 plane YUVs return 1 bpp, but we need more space for other planes */
+        if(texture->format == SDL_PIXELFORMAT_YV12 ||
+           texture->format == SDL_PIXELFORMAT_IYUV) {
+            SDL_DFB_ALLOC_CLEAR(data->pixels, (texture->h * data->pitch  + ((texture->h + texture->h % 2) * (data->pitch + data->pitch % 2) * 2) / 4));
+        } else {
+            SDL_DFB_ALLOC_CLEAR(data->pixels, texture->h * data->pitch);
+        }
+    }
+
+    return 0;
+
+  error:
+    SDL_DFB_RELEASE(data->palette);
+    SDL_DFB_RELEASE(data->surface);
+    SDL_DFB_FREE(texture->driverdata);
+    return -1;
+}
+
+static int
+DirectFB_QueryTexturePixels(SDL_Renderer * renderer,
+                            SDL_Texture * texture, void **pixels, int *pitch)
+{
+    DirectFB_TextureData *texturedata =
+        (DirectFB_TextureData *) texture->driverdata;
+
+    if (texturedata->display) {
+        return -1;
+    } else {
+        *pixels = texturedata->pixels;
+        *pitch = texturedata->pitch;
+    }
+    return 0;
+}
+
+static int
+DirectFB_SetTexturePalette(SDL_Renderer * renderer,
+                           SDL_Texture * texture,
+                           const SDL_Color * colors, int firstcolor,
+                           int ncolors)
+{
+    DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
+    if (SDL_ISPIXELFORMAT_INDEXED(data->format)
+        && !SDL_ISPIXELFORMAT_FOURCC(data->format)) {
+        DFBColor entries[256];
+        int i;
+
+        if (ncolors > 256)
+            ncolors = 256;
+
+        for (i = 0; i < ncolors; ++i) {
+            entries[i].r = colors[i].r;
+            entries[i].g = colors[i].g;
+            entries[i].b = colors[i].b;
+            entries[i].a = 0xff;
+        }
+        SDL_DFB_CHECKERR(data->
+                         palette->SetEntries(data->palette, entries, ncolors, firstcolor));
+        return 0;
+    } else {
+        return SDL_SetError("YUV textures don't have a palette");
+    }
+  error:
+    return -1;
+}
+
+static int
+DirectFB_GetTexturePalette(SDL_Renderer * renderer,
+                           SDL_Texture * texture, SDL_Color * colors,
+                           int firstcolor, int ncolors)
+{
+    DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
+
+    if (SDL_ISPIXELFORMAT_INDEXED(data->format)
+        && !SDL_ISPIXELFORMAT_FOURCC(data->format)) {
+        DFBColor entries[256];
+        int i;
+
+        SDL_DFB_CHECKERR(data->
+                         palette->GetEntries(data->palette, entries, ncolors,
+                                             firstcolor));
+
+        for (i = 0; i < ncolors; ++i) {
+            colors[i].r = entries[i].r;
+            colors[i].g = entries[i].g;
+            colors[i].b = entries[i].b;
+            colors[i].a = SDL_ALPHA_OPAQUE;
+        }
+        return 0;
+    } else {
+        return SDL_SetError("YUV textures don't have a palette");
+    }
+  error:
+    return -1;
+}
+
+static int
+DirectFB_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    return 0;
+}
+
+static int
+DirectFB_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    return 0;
+}
+
+static int
+DirectFB_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    switch (texture->blendMode) {
+    case SDL_BLENDMODE_NONE:
+    /* case SDL_BLENDMODE_MASK: */
+    case SDL_BLENDMODE_BLEND:
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_MOD:
+        return 0;
+    default:
+        texture->blendMode = SDL_BLENDMODE_NONE;
+        return SDL_Unsupported();
+    }
+}
+
+static int
+DirectFB_SetDrawBlendMode(SDL_Renderer * renderer)
+{
+    switch (renderer->blendMode) {
+    case SDL_BLENDMODE_NONE:
+    /* case SDL_BLENDMODE_MASK: */
+    case SDL_BLENDMODE_BLEND:
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_MOD:
+        return 0;
+    default:
+        renderer->blendMode = SDL_BLENDMODE_NONE;
+        return SDL_Unsupported();
+    }
+}
+
+#if 0
+static int
+DirectFB_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+#if (DFB_VERSION_ATLEAST(1,2,0))
+
+    DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
+
+    switch (texture->scaleMode) {
+    case SDL_SCALEMODE_NONE:
+    case SDL_SCALEMODE_FAST:
+        data->render_options = DSRO_NONE;
+        break;
+    case SDL_SCALEMODE_SLOW:
+        data->render_options = DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE;
+        break;
+    case SDL_SCALEMODE_BEST:
+        data->render_options =
+            DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE | DSRO_ANTIALIAS;
+        break;
+    default:
+        data->render_options = DSRO_NONE;
+        texture->scaleMode = SDL_SCALEMODE_NONE;
+        return SDL_Unsupported();
+    }
+#endif
+    return 0;
+}
+#endif
+
+static int
+DirectFB_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+                       const SDL_Rect * rect, const void *pixels, int pitch)
+{
+    DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
+    Uint8 *dpixels;
+    int dpitch;
+    Uint8 *src, *dst;
+    int row;
+    size_t length;
+    int bpp = DFB_BYTES_PER_PIXEL(DirectFB_SDLToDFBPixelFormat(texture->format));
+    /* FIXME: SDL_BYTESPERPIXEL(texture->format) broken for yuv yv12 3 planes */
+
+    DirectFB_ActivateRenderer(renderer);
+
+    if ((texture->format == SDL_PIXELFORMAT_YV12) ||
+        (texture->format == SDL_PIXELFORMAT_IYUV)) {
+        bpp = 1;
+    }
+
+    SDL_DFB_CHECKERR(data->surface->Lock(data->surface,
+                                         DSLF_WRITE | DSLF_READ,
+                                         ((void **) &dpixels), &dpitch));
+    src = (Uint8 *) pixels;
+    dst = (Uint8 *) dpixels + rect->y * dpitch + rect->x * bpp;
+    length = rect->w * bpp;
+    for (row = 0; row < rect->h; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += pitch;
+        dst += dpitch;
+    }
+    /* copy other planes for 3 plane formats */
+    if ((texture->format == SDL_PIXELFORMAT_YV12) ||
+        (texture->format == SDL_PIXELFORMAT_IYUV)) {
+        src = (Uint8 *) pixels + texture->h * pitch;
+        dst = (Uint8 *) dpixels + texture->h * dpitch + rect->y * dpitch / 4 + rect->x * bpp / 2;
+        for (row = 0; row < rect->h / 2 + (rect->h & 1); ++row) {
+            SDL_memcpy(dst, src, length / 2);
+            src += pitch / 2;
+            dst += dpitch / 2;
+        }
+        src = (Uint8 *) pixels + texture->h * pitch + texture->h * pitch / 4;
+        dst = (Uint8 *) dpixels + texture->h * dpitch + texture->h * dpitch / 4 + rect->y * dpitch / 4 + rect->x * bpp / 2;
+        for (row = 0; row < rect->h / 2 + (rect->h & 1); ++row) {
+            SDL_memcpy(dst, src, length / 2);
+            src += pitch / 2;
+            dst += dpitch / 2;
+        }
+    }
+    SDL_DFB_CHECKERR(data->surface->Unlock(data->surface));
+    data->isDirty = 0;
+    return 0;
+  error:
+    return 1;
+
+}
+
+static int
+DirectFB_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+                     const SDL_Rect * rect, void **pixels, int *pitch)
+{
+    DirectFB_TextureData *texturedata =
+        (DirectFB_TextureData *) texture->driverdata;
+
+    DirectFB_ActivateRenderer(renderer);
+
+#if 0
+    if (markDirty) {
+        SDL_AddDirtyRect(&texturedata->dirty, rect);
+    }
+#endif
+
+    if (texturedata->display) {
+        void *fdata;
+        int fpitch;
+
+        SDL_DFB_CHECKERR(texturedata->surface->Lock(texturedata->surface,
+                                                    DSLF_WRITE | DSLF_READ,
+                                                    &fdata, &fpitch));
+        *pitch = fpitch;
+        *pixels = fdata;
+    } else {
+        *pixels =
+            (void *) ((Uint8 *) texturedata->pixels +
+                      rect->y * texturedata->pitch +
+                      rect->x * DFB_BYTES_PER_PIXEL(DirectFB_SDLToDFBPixelFormat(texture->format)));
+        *pitch = texturedata->pitch;
+        texturedata->isDirty = 1;
+    }
+    return 0;
+
+  error:
+    return -1;
+}
+
+static void
+DirectFB_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    DirectFB_TextureData *texturedata =
+        (DirectFB_TextureData *) texture->driverdata;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    if (texturedata->display) {
+        SDL_DFB_CHECK(texturedata->surface->Unlock(texturedata->surface));
+        texturedata->pixels = NULL;
+    }
+}
+
+#if 0
+static void
+DirectFB_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+                      int numrects, const SDL_Rect * rects)
+{
+    DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
+    int i;
+
+    for (i = 0; i < numrects; ++i) {
+        SDL_AddDirtyRect(&data->dirty, &rects[i]);
+    }
+}
+#endif
+
+static int DirectFB_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    DirectFB_TextureData *tex_data = NULL;
+
+    DirectFB_ActivateRenderer(renderer);
+    if (texture) {
+        tex_data = (DirectFB_TextureData *) texture->driverdata;
+        data->target = tex_data->surface;
+    } else {
+        data->target = get_dfb_surface(data->window);
+    }
+    data->lastBlendMode = 0;
+    return 0;
+}
+
+
+static int
+PrepareDraw(SDL_Renderer * renderer)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *destsurf = data->target;
+
+    Uint8 r, g, b, a;
+
+    r = renderer->r;
+    g = renderer->g;
+    b = renderer->b;
+    a = renderer->a;
+
+    SetBlendMode(data, renderer->blendMode, NULL);
+    SDL_DFB_CHECKERR(destsurf->SetDrawingFlags(destsurf, data->drawFlags));
+
+    switch (renderer->blendMode) {
+    case SDL_BLENDMODE_NONE:
+    /* case SDL_BLENDMODE_MASK: */
+    case SDL_BLENDMODE_BLEND:
+        break;
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_MOD:
+        r = ((int) r * (int) a) / 255;
+        g = ((int) g * (int) a) / 255;
+        b = ((int) b * (int) a) / 255;
+        a = 255;
+        break;
+    }
+
+    SDL_DFB_CHECKERR(destsurf->SetColor(destsurf, r, g, b, a));
+    return 0;
+  error:
+    return -1;
+}
+
+static int DirectFB_RenderDrawPoints(SDL_Renderer * renderer,
+                                const SDL_FPoint * points, int count)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *destsurf = data->target;
+    DFBRegion clip_region;
+    int i;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    PrepareDraw(renderer);
+    destsurf->GetClip(destsurf, &clip_region);
+    for (i=0; i < count; i++) {
+        int x = points[i].x + clip_region.x1;
+        int y = points[i].y + clip_region.y1;
+        SDL_DFB_CHECKERR(destsurf->DrawLine(destsurf, x, y, x, y));
+    }
+    return 0;
+  error:
+    return -1;
+}
+
+static int DirectFB_RenderDrawLines(SDL_Renderer * renderer,
+                               const SDL_FPoint * points, int count)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *destsurf = data->target;
+    DFBRegion clip_region;
+    int i;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    PrepareDraw(renderer);
+    /* Use antialiasing when available */
+#if (DFB_VERSION_ATLEAST(1,2,0))
+    SDL_DFB_CHECKERR(destsurf->SetRenderOptions(destsurf, DSRO_ANTIALIAS));
+#endif
+
+    destsurf->GetClip(destsurf, &clip_region);
+    for (i=0; i < count - 1; i++) {
+        int x1 = points[i].x + clip_region.x1;
+        int y1 = points[i].y + clip_region.y1;
+        int x2 = points[i + 1].x + clip_region.x1;
+        int y2 = points[i + 1].y + clip_region.y1;
+        SDL_DFB_CHECKERR(destsurf->DrawLine(destsurf, x1, y1, x2, y2));
+    }
+
+    return 0;
+  error:
+    return -1;
+}
+
+static int
+DirectFB_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *destsurf = data->target;
+    DFBRegion clip_region;
+    int i;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    PrepareDraw(renderer);
+
+    destsurf->GetClip(destsurf, &clip_region);
+    for (i=0; i<count; i++) {
+        SDL_Rect dst = {rects[i]->x, rects[i]->y, rects[i]->w, rects[i]->h};
+        dst.x += clip_region.x1;
+        dst.y += clip_region.y1;
+        SDL_DFB_CHECKERR(destsurf->DrawRectangle(destsurf, dst.x, dst.y,
+                dst.w, dst.h));
+    }
+
+    return 0;
+  error:
+    return -1;
+}
+
+static int
+DirectFB_RenderFillRects(SDL_Renderer * renderer, const SDL_FRect * rects, int count)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *destsurf = data->target;
+    DFBRegion clip_region;
+    int i;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    PrepareDraw(renderer);
+
+    destsurf->GetClip(destsurf, &clip_region);
+    for (i=0; i<count; i++) {
+        SDL_Rect dst = {rects[i].x, rects[i].y, rects[i].w, rects[i].h};
+        dst.x += clip_region.x1;
+        dst.y += clip_region.y1;
+        SDL_DFB_CHECKERR(destsurf->FillRectangle(destsurf, dst.x, dst.y,
+                dst.w, dst.h));
+    }
+
+    return 0;
+  error:
+    return -1;
+}
+
+static int
+DirectFB_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
+                    const SDL_Rect * srcrect, const SDL_FRect * dstrect)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *destsurf = data->target;
+    DirectFB_TextureData *texturedata =
+        (DirectFB_TextureData *) texture->driverdata;
+    Uint8 alpha, r, g, b;
+    DFBRegion clip_region;
+    DFBRectangle sr, dr;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    SDLtoDFBRect(srcrect, &sr);
+    SDLtoDFBRect_Float(dstrect, &dr);
+
+    destsurf->GetClip(destsurf, &clip_region);
+    dr.x += clip_region.x1;
+    dr.y += clip_region.y1;
+
+    if (texturedata->display) {
+        int px, py;
+        SDL_Window *window = renderer->window;
+        IDirectFBWindow *dfbwin = get_dfb_window(window);
+        SDL_DFB_WINDOWDATA(window);
+        SDL_VideoDisplay *display = texturedata->display;
+        DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;
+
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetSourceRectangle(dispdata->vidlayer,
+                                                      sr.x, sr.y, sr.w, sr.h));
+        dfbwin->GetPosition(dfbwin, &px, &py);
+        px += windata->client.x;
+        py += windata->client.y;
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetScreenRectangle(dispdata->vidlayer,
+                                                      px + dr.x,
+                                                      py + dr.y,
+                                                      dr.w,
+                                                      dr.h));
+    } else {
+        DFBSurfaceBlittingFlags flags = 0;
+
+#if 0
+        if (texturedata->dirty.list) {
+            SDL_DirtyRect *dirty;
+            void *pixels;
+            int bpp = DFB_BYTES_PER_PIXEL(DirectFB_SDLToDFBPixelFormat(texture->format));
+            int pitch = texturedata->pitch;
+
+            for (dirty = texturedata->dirty.list; dirty; dirty = dirty->next) {
+                SDL_Rect *rect = &dirty->rect;
+                pixels =
+                    (void *) ((Uint8 *) texturedata->pixels +
+                              rect->y * pitch + rect->x * bpp);
+                DirectFB_UpdateTexture(renderer, texture, rect,
+                                       pixels,
+                                       texturedata->pitch);
+            }
+            SDL_ClearDirtyRects(&texturedata->dirty);
+        }
+#endif
+        if (texturedata->isDirty)
+        {
+            SDL_Rect rect;
+
+            rect.x = 0;
+            rect.y = 0;
+            rect.w = texture->w;
+            rect.h = texture->h;
+
+            DirectFB_UpdateTexture(renderer, texture, &rect, texturedata->pixels, texturedata->pitch);
+        }
+
+        alpha = r = g = b = 0xff;
+        if (texture->modMode & SDL_TEXTUREMODULATE_ALPHA){
+            alpha = texture->a;
+            flags |= DSBLIT_BLEND_COLORALPHA;
+        }
+
+        if (texture->modMode & SDL_TEXTUREMODULATE_COLOR) {
+            r = texture->r;
+            g = texture->g;
+            b = texture->b;
+            flags |= DSBLIT_COLORIZE;
+        }
+        SDL_DFB_CHECKERR(destsurf->
+                         SetColor(destsurf, r, g, b, alpha));
+
+        /* ???? flags |= DSBLIT_SRC_PREMULTCOLOR; */
+
+        SetBlendMode(data, texture->blendMode, texturedata);
+
+        SDL_DFB_CHECKERR(destsurf->SetBlittingFlags(destsurf,
+                                                    data->blitFlags | flags));
+
+#if (DFB_VERSION_ATLEAST(1,2,0))
+        SDL_DFB_CHECKERR(destsurf->SetRenderOptions(destsurf,
+                                                    texturedata->
+                                                    render_options));
+#endif
+
+        if (srcrect->w == dstrect->w && srcrect->h == dstrect->h) {
+            SDL_DFB_CHECKERR(destsurf->Blit(destsurf,
+                                            texturedata->surface,
+                                            &sr, dr.x, dr.y));
+        } else {
+            SDL_DFB_CHECKERR(destsurf->StretchBlit(destsurf,
+                                                   texturedata->surface,
+                                                   &sr, &dr));
+        }
+    }
+    return 0;
+  error:
+    return -1;
+}
+
+static void
+DirectFB_RenderPresent(SDL_Renderer * renderer)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    SDL_Window *window = renderer->window;
+    SDL_DFB_WINDOWDATA(window);
+    SDL_ShapeData *shape_data = (window->shaper ? window->shaper->driverdata : NULL);
+
+    DirectFB_ActivateRenderer(renderer);
+
+    if (shape_data && shape_data->surface) {
+        /* saturate the window surface alpha channel */
+        SDL_DFB_CHECK(windata->window_surface->SetSrcBlendFunction(windata->window_surface, DSBF_ONE));
+        SDL_DFB_CHECK(windata->window_surface->SetDstBlendFunction(windata->window_surface, DSBF_ONE));
+        SDL_DFB_CHECK(windata->window_surface->SetDrawingFlags(windata->window_surface, DSDRAW_BLEND));
+        SDL_DFB_CHECK(windata->window_surface->SetColor(windata->window_surface, 0, 0, 0, 0xff));
+        SDL_DFB_CHECK(windata->window_surface->FillRectangle(windata->window_surface, 0,0, windata->size.w, windata->size.h));
+
+        /* blit the mask */
+        SDL_DFB_CHECK(windata->surface->SetSrcBlendFunction(windata->surface, DSBF_DESTCOLOR));
+        SDL_DFB_CHECK(windata->surface->SetDstBlendFunction(windata->surface, DSBF_ZERO));
+        SDL_DFB_CHECK(windata->surface->SetBlittingFlags(windata->surface, DSBLIT_BLEND_ALPHACHANNEL));
+#if (DFB_VERSION_ATLEAST(1,2,0))
+        SDL_DFB_CHECK(windata->surface->SetRenderOptions(windata->surface, DSRO_NONE));
+#endif
+        SDL_DFB_CHECK(windata->surface->Blit(windata->surface, shape_data->surface, NULL, 0, 0));
+    }
+
+    /* Send the data to the display */
+    SDL_DFB_CHECK(windata->window_surface->Flip(windata->window_surface, NULL,
+                                                data->flipflags));
+}
+
+static void
+DirectFB_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    if (!data) {
+        return;
+    }
+    SDL_DFB_RELEASE(data->palette);
+    SDL_DFB_RELEASE(data->surface);
+    if (data->display) {
+        DFB_DisplayData *dispdata =
+            (DFB_DisplayData *) data->display->driverdata;
+        dispdata->vidIDinuse = 0;
+        /* FIXME: Shouldn't we reset the cooperative level */
+        SDL_DFB_CHECK(dispdata->vidlayer->SetCooperativeLevel(dispdata->vidlayer,
+                                                DLSCL_ADMINISTRATIVE));
+        SDL_DFB_RELEASE(dispdata->vidlayer);
+    }
+    SDL_DFB_FREE(data->pixels);
+    SDL_free(data);
+    texture->driverdata = NULL;
+}
+
+static void
+DirectFB_DestroyRenderer(SDL_Renderer * renderer)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    SDL_VideoDisplay *display = SDL_GetDisplayForWindow(data->window);
+#if 0
+    if (display->palette) {
+        SDL_DelPaletteWatch(display->palette, DisplayPaletteChanged, data);
+    }
+#endif
+
+    SDL_free(data);
+    SDL_free(renderer);
+}
+
+static int
+DirectFB_UpdateViewport(SDL_Renderer * renderer)
+{
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *winsurf = data->target;
+    DFBRegion dreg;
+
+    dreg.x1 = renderer->viewport.x;
+    dreg.y1 = renderer->viewport.y;
+    dreg.x2 = dreg.x1 + renderer->viewport.w - 1;
+    dreg.y2 = dreg.y1 + renderer->viewport.h - 1;
+
+    winsurf->SetClip(winsurf, &dreg);
+    return 0;
+}
+
+static int
+DirectFB_UpdateClipRect(SDL_Renderer * renderer)
+{
+    const SDL_Rect *rect = &renderer->clip_rect;
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *destsurf = get_dfb_surface(data->window);
+    DFBRegion region;
+
+    if (!SDL_RectEmpty(rect)) {
+        region.x1 = rect->x;
+        region.x2 = rect->x + rect->w;
+        region.y1 = rect->y;
+        region.y2 = rect->y + rect->h;
+        SDL_DFB_CHECKERR(destsurf->SetClip(destsurf, &region));
+    } else {
+        SDL_DFB_CHECKERR(destsurf->SetClip(destsurf, NULL));
+    }
+    return 0;
+  error:
+    return -1;
+}
+
+static int
+DirectFB_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
+                     Uint32 format, void * pixels, int pitch)
+{
+    Uint32 sdl_format;
+    unsigned char* laypixels;
+    int laypitch;
+    DFBSurfacePixelFormat dfb_format;
+    DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
+    IDirectFBSurface *winsurf = data->target;
+
+    DirectFB_ActivateRenderer(renderer);
+
+    winsurf->GetPixelFormat(winsurf, &dfb_format);
+    sdl_format = DirectFB_DFBToSDLPixelFormat(dfb_format);
+    winsurf->Lock(winsurf, DSLF_READ, (void **) &laypixels, &laypitch);
+
+    laypixels += (rect->y * laypitch + rect->x * SDL_BYTESPERPIXEL(sdl_format) );
+    SDL_ConvertPixels(rect->w, rect->h,
+                      sdl_format, laypixels, laypitch,
+                      format, pixels, pitch);
+
+    winsurf->Unlock(winsurf);
+
+    return 0;
+}
+
+#if 0
+static int
+DirectFB_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
+                      Uint32 format, const void * pixels, int pitch)
+{
+    SDL_Window *window = renderer->window;
+    SDL_DFB_WINDOWDATA(window);
+    Uint32 sdl_format;
+    unsigned char* laypixels;
+    int laypitch;
+    DFBSurfacePixelFormat dfb_format;
+
+    SDL_DFB_CHECK(windata->surface->GetPixelFormat(windata->surface, &dfb_format));
+    sdl_format = DirectFB_DFBToSDLPixelFormat(dfb_format);
+
+    SDL_DFB_CHECK(windata->surface->Lock(windata->surface, DSLF_WRITE, (void **) &laypixels, &laypitch));
+
+    laypixels += (rect->y * laypitch + rect->x * SDL_BYTESPERPIXEL(sdl_format) );
+    SDL_ConvertPixels(rect->w, rect->h,
+                      format, pixels, pitch,
+                      sdl_format, laypixels, laypitch);
+
+    SDL_DFB_CHECK(windata->surface->Unlock(windata->surface));
+
+    return 0;
+}
+#endif
+
+#endif /* SDL_VIDEO_DRIVER_DIRECTFB */
+
+/* vi: set ts=4 sw=4 expandtab: */