/*

SDL - Simple DirectMedia Layer

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

SDL1.3 implementation by couriersud@arcor.de

*/

#include "SDL_config.h"

#include "SDL_DirectFB_video.h"

#include "SDL_DirectFB_render.h"

#include "../SDL_yuv_sw_c.h"

/* the following is not yet tested ... */

#define USE_DISPLAY_PALETTE (0)

/* GDI renderer implementation */

static SDL_Renderer *DirectFB_CreateRenderer(SDL_Window * window,

Uint32 flags);

static int DirectFB_DisplayModeChanged(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_UpdateTexture(SDL_Renderer * renderer,

SDL_Texture * texture,

const SDL_Rect * rect,

const void *pixels, int pitch);

SDL_Texture * texture,

const SDL_Rect * rect, int markDirty,

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_RenderDrawPoints(SDL_Renderer * renderer,

const SDL_Point * points, int count);

static int DirectFB_RenderDrawLines(SDL_Renderer * renderer,

const SDL_Point * points, int count);

static int DirectFB_RenderFillRects(SDL_Renderer * renderer,

const SDL_Rect ** rects, int count);

static int DirectFB_RenderCopy(SDL_Renderer * renderer,

SDL_Texture * texture,

const SDL_Rect * srcrect,

const SDL_Rect * 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);

#define SDL_DFB_WINDOWSURFACE(win) IDirectFBSurface *destsurf = ((DFB_WindowData *) ((win)->driverdata))->surface;

SDL_RenderDriver DirectFB_RenderDriver = {

DirectFB_CreateRenderer,

{

"directfb",

{

SDL_PIXELFORMAT_RGB332,

SDL_PIXELFORMAT_RGB555,

SDL_PIXELFORMAT_RGB565,

SDL_PIXELFORMAT_RGB888,

SDL_PIXELFORMAT_ARGB8888,

SDL_PIXELFORMAT_ARGB4444,

SDL_PIXELFORMAT_ARGB1555,

SDL_PIXELFORMAT_RGB24,

SDL_PIXELFORMAT_YV12,

SDL_PIXELFORMAT_IYUV,

SDL_PIXELFORMAT_YUY2,

SDL_PIXELFORMAT_UYVY},

0,

0}

};

typedef struct

{

DFBSurfaceFlipFlags flipflags;

int isyuvdirect;

int lastBlendMode;

DFBSurfaceBlittingFlags blitFlags;

DFBSurfaceDrawingFlags drawFlags;

} DirectFB_RenderData;

typedef struct

{

IDirectFBSurface *surface;

Uint32 format;

void *pixels;

int pitch;

SDL_VideoDisplay *display;

SDL_DirtyRectList dirty;

DFBSurfaceRenderOptions render_options;

#endif

} DirectFB_TextureData;

static __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 int

TextureHasAlpha(DirectFB_TextureData * data)

{

/* Drawing primitive ? */

if (!data)

return 0;

switch (data->format) {

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;

}

}

static void

SetBlendMode(DirectFB_RenderData * data, int blendMode,

DirectFB_TextureData * source)

{

SDL_DFB_WINDOWSURFACE(data->window);

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

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 temporay surface and premultiply

if (source && TextureHasAlpha(source))

SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE));

SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ONE));

break;

}

data->lastBlendMode = blendMode;

}

}

void

DirectFB_AddRenderDriver(_THIS)

{

int i;

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

}

SDL_Renderer *

DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)

{

SDL_DFB_WINDOWDATA(window);

SDL_Renderer *renderer = NULL;

DirectFB_RenderData *data = NULL;

char *p;

SDL_DFB_CALLOC(renderer, 1, sizeof(*renderer));

SDL_DFB_CALLOC(data, 1, sizeof(*data));

renderer->DisplayModeChanged = DirectFB_DisplayModeChanged;

renderer->CreateTexture = DirectFB_CreateTexture;

renderer->QueryTexturePixels = DirectFB_QueryTexturePixels;

renderer->UpdateTexture = DirectFB_UpdateTexture;

renderer->LockTexture = DirectFB_LockTexture;

renderer->UnlockTexture = DirectFB_UnlockTexture;

renderer->DirtyTexture = DirectFB_DirtyTexture;

renderer->RenderDrawPoints = DirectFB_RenderDrawPoints;

renderer->RenderDrawLines = DirectFB_RenderDrawLines;

renderer->RenderFillRects = DirectFB_RenderFillRects;

/* RenderDrawEllipse - no reference implementation yet */

/* RenderFillEllipse - no reference implementation yet */

renderer->RenderCopy = DirectFB_RenderCopy;

renderer->RenderPresent = DirectFB_RenderPresent;

/* RenderReadPixels is difficult to implement */

/* RenderWritePixels is difficult to implement */

renderer->DestroyTexture = DirectFB_DestroyTexture;

renderer->DestroyRenderer = DirectFB_DestroyRenderer;

renderer->info = DirectFB_RenderDriver.info;

renderer->driverdata = data;

data->flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT;

if (flags & SDL_RENDERER_PRESENTVSYNC) {

} else

data->flipflags |= DSFLIP_ONSYNC;

if (p)

data->isyuvdirect = atoi(p);

return renderer;

error:

SDL_DFB_FREE(renderer);

SDL_DFB_FREE(data);

return NULL;

}

static DFBSurfacePixelFormat

SDLToDFBPixelFormat(Uint32 format)

{

switch (format) {

case SDL_PIXELFORMAT_RGB332:

return DSPF_RGB332;

case SDL_PIXELFORMAT_RGB555:

return DSPF_ARGB1555;

case SDL_PIXELFORMAT_ARGB4444:

return DSPF_ARGB4444;

case SDL_PIXELFORMAT_ARGB1555:

return DSPF_ARGB1555;

case SDL_PIXELFORMAT_RGB565:

return DSPF_RGB16;

case SDL_PIXELFORMAT_RGB24:

return DSPF_RGB24;

case SDL_PIXELFORMAT_RGB888:

return DSPF_RGB32;

case SDL_PIXELFORMAT_ARGB8888:

return DSPF_ARGB;

case SDL_PIXELFORMAT_YV12:

return DSPF_YV12; /* Planar mode: Y + V + U (3 planes) */

case SDL_PIXELFORMAT_IYUV:

return DSPF_I420; /* Planar mode: Y + U + V (3 planes) */

case SDL_PIXELFORMAT_YUY2:

return DSPF_YUY2; /* Packed mode: Y0+U0+Y1+V0 (1 plane) */

case SDL_PIXELFORMAT_UYVY:

return DSPF_UYVY; /* Packed mode: U0+Y0+V0+Y1 (1 plane) */

case SDL_PIXELFORMAT_YVYU:

return DSPF_UNKNOWN; /* Packed mode: Y0+V0+Y1+U0 (1 plane) */

return DSPF_RGB444;

#endif

case SDL_PIXELFORMAT_BGR24:

return DSPF_UNKNOWN;

case SDL_PIXELFORMAT_BGR888:

return DSPF_UNKNOWN;

case SDL_PIXELFORMAT_RGBA8888:

return DSPF_UNKNOWN;

case SDL_PIXELFORMAT_ABGR8888:

return DSPF_UNKNOWN;

case SDL_PIXELFORMAT_BGRA8888:

return DSPF_UNKNOWN;

case SDL_PIXELFORMAT_ARGB2101010:

return DSPF_UNKNOWN;

default:

return DSPF_UNKNOWN;

}

}

static int

{

SDL_DFB_RENDERERDATA(renderer);

SDL_DFB_WINDOWDATA(window);

return 0;

}

static int

DirectFB_DisplayModeChanged(SDL_Renderer * renderer)

{

SDL_DFB_RENDERERDATA(renderer);

renddata->size_changed = SDL_TRUE;

return 0;

}

{

SDL_DFB_RENDERERDATA(renderer);

SDL_DFB_DEVICEDATA(display->device);

DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;

if (renddata->isyuvdirect && (dispdata->vidID >= 0)

layconf.flags =

DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT |

DLCONF_SURFACE_CAPS;

layconf.width = texture->w;

layconf.height = texture->h;

layconf.pixelformat = SDLToDFBPixelFormat(data->format);

SDL_DFB_CHECKERR(devdata->dfb->GetDisplayLayer(devdata->dfb,

dispdata->vidID,

&dispdata->vidlayer));

SDL_DFB_CHECKERR(dispdata->

vidlayer->SetCooperativeLevel(dispdata->vidlayer,

DLSCL_EXCLUSIVE));

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

error:

SDL_DFB_CHECKERR(dispdata->

vidlayer->SetCooperativeLevel(dispdata->vidlayer,

DLSCL_ADMINISTRATIVE));

}

return 1;

}

static int

DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)

{

SDL_DFB_DEVICEDATA(display->device);

DirectFB_TextureData *data;

DFBSurfaceDescription dsc;

SDL_DFB_CALLOC(data, 1, sizeof(*data));

texture->driverdata = data;

/* find the right pixelformat */

pixelformat = SDLToDFBPixelFormat(texture->format);

if (pixelformat == DSPF_UNKNOWN) {

SDL_SetError("Unknown pixel format %d\n", data->format);

goto error;

}

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->access == SDL_TEXTUREACCESS_STREAMING)

dsc.caps |= DSCAPS_SYSTEMONLY;

else

dsc.caps |= DSCAPS_VIDEOONLY;

data->pixels = NULL;

/* Create the surface */

SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc,

&data->surface));

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_CALLOC(data->pixels, 1, (texture->h * data->pitch * 3 + texture->h * data->pitch * 3 % 2) / 2);

} else {

SDL_DFB_CALLOC(data->pixels, 1, 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_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)

{

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

case SDL_SCALEMODE_NONE:

case SDL_SCALEMODE_FAST:

data->render_options = DSRO_NONE;

break;

data->render_options = DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE;

break;

data->render_options =

DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE | DSRO_ANTIALIAS;

break;

default:

SDL_Unsupported();

return -1;

}

return 0;

}

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 *src, *dst;

int row;

size_t length;

int bpp = DFB_BYTES_PER_PIXEL(SDLToDFBPixelFormat(texture->format));

// FIXME: SDL_BYTESPERPIXEL(texture->format) broken for yuv yv12 3 planes

SDL_DFB_CHECKERR(data->surface->Lock(data->surface,

DSLF_WRITE | DSLF_READ,

((void **) &dpixels), &dpitch));

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; ++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; ++row) {

SDL_memcpy(dst, src, length / 2);

src += pitch / 2;

dst += dpitch / 2;

}

}

error:

return 1;

}

static int

DirectFB_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect, int markDirty,

void **pixels, int *pitch)

DirectFB_TextureData *texturedata =

(DirectFB_TextureData *) texture->driverdata;

if (markDirty) {

SDL_AddDirtyRect(&texturedata->dirty, rect);

}

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 +

*pitch = texturedata->pitch;

}

error:

return -1;

}

static void

DirectFB_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)

{

DirectFB_TextureData *texturedata =

(DirectFB_TextureData *) texture->driverdata;

texturedata->pixels = NULL;

}

}

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]);

}

}

static int

PrepareDraw(SDL_Renderer * renderer)

{

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

Uint8 r, g, b, a;

r = renderer->r;

g = renderer->g;

b = renderer->b;

a = renderer->a;

SetBlendMode(data, renderer->blendMode, NULL);

switch (renderer->blendMode) {

case SDL_BLENDMODE_NONE:

case SDL_BLENDMODE_BLEND:

break;

case SDL_BLENDMODE_ADD:

r = ((int) r * (int) a) / 255;

g = ((int) g * (int) a) / 255;

b = ((int) b * (int) a) / 255;

a = 255;

break;

}

return 0;

error:

return -1;

}

static int DirectFB_RenderDrawPoints(SDL_Renderer * renderer,

const SDL_Point * points, int count)

{

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

PrepareDraw(renderer);

for (i=0; i < count; i++)

SDL_DFB_CHECKERR(destsurf->DrawLine(destsurf, points[i].x, points[i].y, points[i].x, points[i].y));

return 0;

error:

return -1;

}

static int DirectFB_RenderDrawLines(SDL_Renderer * renderer,

const SDL_Point * points, int count)

{

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