SDL_GLContext
DirectFB_GL_CreateContext(_THIS, SDL_Window * window)
{
SDL_DFB_WINDOWDATA(window);
DirectFB_GLContext *context;
int ret;
SDL_DFB_CALLOC(context, 1, sizeof(*context));
SDL_DFB_CHECKERR(windata->surface->GetGL(windata->surface,
&context->context));
if (!context->context)
return NULL;
SDL_DFB_CHECKERR(context->context->Unlock(context->context));
context->next = _this->gl_data->firstgl;
_this->gl_data->firstgl = context;
if (DirectFB_GL_MakeCurrent(_this, window, context) < 0) {
DirectFB_GL_DeleteContext(_this, context);
return NULL;
}
return context;
error:
return NULL;
}
void
DirectFB_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
{
SDL_DFB_DEVICEDATA(_this);
DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;
SDL_DisplayMode mode;
struct modes_callback_t data;
int i;
data.nummodes = 0;
/* Enumerate the available fullscreen modes */
SDL_DFB_CALLOC(data.modelist, DFB_MAX_MODES, sizeof(SDL_DisplayMode));
SDL_DFB_CHECKERR(devdata->dfb->EnumVideoModes(devdata->dfb,
EnumModesCallback, &data));
for (i = 0; i < data.nummodes; ++i) {
mode = data.modelist[i];
mode.format = SDL_PIXELFORMAT_ARGB8888;
CheckSetDisplayMode(_this, display, dispdata, &mode);
mode.format = SDL_PIXELFORMAT_RGB888;
CheckSetDisplayMode(_this, display, dispdata, &mode);
mode.format = SDL_PIXELFORMAT_RGB24;
CheckSetDisplayMode(_this, display, dispdata, &mode);
mode.format = SDL_PIXELFORMAT_RGB565;
CheckSetDisplayMode(_this, display, dispdata, &mode);
mode.format = SDL_PIXELFORMAT_INDEX8;
CheckSetDisplayMode(_this, display, dispdata, &mode);
}
SDL_DFB_FREE(data.modelist);
error:
return;
}
static SDL_VideoDevice *
DirectFB_CreateDevice(int devindex)
{
SDL_VideoDevice *device;
if (!SDL_DirectFB_LoadLibrary())
return NULL;
/* Initialize all variables that we clean on shutdown */
SDL_DFB_CALLOC(device, 1, sizeof(SDL_VideoDevice));
/* Set the function pointers */
/* Set the function pointers */
device->VideoInit = DirectFB_VideoInit;
device->VideoQuit = DirectFB_VideoQuit;
device->GetDisplayModes = DirectFB_GetDisplayModes;
device->SetDisplayMode = DirectFB_SetDisplayMode;
device->PumpEvents = DirectFB_PumpEventsWindow;
device->CreateWindow = DirectFB_CreateWindow;
device->CreateWindowFrom = DirectFB_CreateWindowFrom;
device->SetWindowTitle = DirectFB_SetWindowTitle;
device->SetWindowIcon = DirectFB_SetWindowIcon;
device->SetWindowPosition = DirectFB_SetWindowPosition;
device->SetWindowSize = DirectFB_SetWindowSize;
device->ShowWindow = DirectFB_ShowWindow;
device->HideWindow = DirectFB_HideWindow;
device->RaiseWindow = DirectFB_RaiseWindow;
device->MaximizeWindow = DirectFB_MaximizeWindow;
device->MinimizeWindow = DirectFB_MinimizeWindow;
device->RestoreWindow = DirectFB_RestoreWindow;
device->SetWindowGrab = DirectFB_SetWindowGrab;
device->DestroyWindow = DirectFB_DestroyWindow;
device->GetWindowWMInfo = DirectFB_GetWindowWMInfo;
#if SDL_DIRECTFB_OPENGL
device->GL_LoadLibrary = DirectFB_GL_LoadLibrary;
device->GL_GetProcAddress = DirectFB_GL_GetProcAddress;
device->GL_MakeCurrent = DirectFB_GL_MakeCurrent;
device->GL_CreateContext = DirectFB_GL_CreateContext;
device->GL_SetSwapInterval = DirectFB_GL_SetSwapInterval;
device->GL_GetSwapInterval = DirectFB_GL_GetSwapInterval;
device->GL_SwapWindow = DirectFB_GL_SwapWindow;
device->GL_DeleteContext = DirectFB_GL_DeleteContext;
#endif
device->free = DirectFB_DeleteDevice;
return device;
error:
if (device)
free(device);
return (0);
}
static int
DirectFB_VideoInit(_THIS)
{
IDirectFB *dfb = NULL;
DFB_DeviceData *devdata = NULL;
char *stemp;
DFBResult ret;
SDL_DFB_CALLOC(devdata, 1, sizeof(*devdata));
SDL_DFB_CHECKERR(DirectFBInit(NULL, NULL));
/* avoid switching to the framebuffer when we
* are running X11 */
stemp = SDL_getenv(DFBENV_USE_X11_CHECK);
if (stemp)
ret = atoi(stemp);
else
ret = 1;
if (ret) {
if (SDL_getenv("DISPLAY"))
DirectFBSetOption("system", "x11");
else
DirectFBSetOption("disable-module", "x11input");
}
devdata->use_linux_input = 1; /* default: on */
stemp = SDL_getenv(DFBENV_USE_LINUX_INPUT);
if (stemp)
devdata->use_linux_input = atoi(stemp);
if (!devdata->use_linux_input)
DirectFBSetOption("disable-module", "linux_input");
SDL_DFB_CHECKERR(DirectFBCreate(&dfb));
DirectFB_DeviceInformation(dfb);
devdata->use_yuv_underlays = 0; /* default: off */
stemp = SDL_getenv(DFBENV_USE_YUV_UNDERLAY);
if (stemp)
devdata->use_yuv_underlays = atoi(stemp);
/* Create global Eventbuffer for axis events */
if (devdata->use_linux_input) {
SDL_DFB_CHECKERR(dfb->CreateInputEventBuffer(dfb, DICAPS_ALL,
DFB_TRUE,
&devdata->events));
} else {
SDL_DFB_CHECKERR(dfb->CreateInputEventBuffer(dfb, DICAPS_AXES
/*DICAPS_ALL */ ,
DFB_TRUE,
&devdata->events));
}
devdata->initialized = 1;
/* simple window manager support */
stemp = SDL_getenv(DFBENV_USE_WM);
if (stemp)
devdata->has_own_wm = atoi(stemp);
else
devdata->has_own_wm = 0;
devdata->dfb = dfb;
devdata->firstwin = NULL;
_this->driverdata = devdata;
DirectFB_InitModes(_this);
#if SDL_DIRECTFB_OPENGL
DirectFB_GL_Initialize(_this);
#endif
DirectFB_AddRenderDriver(_this);
DirectFB_InitMouse(_this);
DirectFB_InitKeyboard(_this);
return 0;
error:
SDL_DFB_FREE(devdata);
SDL_DFB_RELEASE(dfb);
return -1;
}
int
DirectFB_CreateWindow(_THIS, SDL_Window * window)
{
SDL_DFB_DEVICEDATA(_this);
SDL_DFB_DISPLAYDATA(_this, window);
DFB_WindowData *windata = NULL;
DFBWindowOptions wopts;
DFBWindowDescription desc;
IDirectFBFont *font;
int ret, x, y;
SDL_DFB_CALLOC(window->driverdata, 1, sizeof(DFB_WindowData));
windata = (DFB_WindowData *) window->driverdata;
windata->is_managed = devdata->has_own_wm;
SDL_DFB_CHECKERR(devdata->dfb->SetCooperativeLevel(devdata->dfb,
DFSCL_NORMAL));
SDL_DFB_CHECKERR(dispdata->layer->SetCooperativeLevel(dispdata->layer,
DLSCL_ADMINISTRATIVE));
/* Fill the window description. */
if (window->x == SDL_WINDOWPOS_CENTERED) {
x = (dispdata->cw - window->w) / 2;
} else if (window->x == SDL_WINDOWPOS_UNDEFINED) {
x = 0;
} else {
x = window->x;
}
if (window->y == SDL_WINDOWPOS_CENTERED) {
y = (dispdata->ch - window->h) / 2;
} else if (window->y == SDL_WINDOWPOS_UNDEFINED) {
y = 0;
} else {
y = window->y;
}
if (window->flags & SDL_WINDOW_FULLSCREEN) {
x = 0;
y = 0;
}
DirectFB_WM_AdjustWindowLayout(window);
/* Create Window */
desc.flags =
DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_PIXELFORMAT | DWDESC_POSX
| DWDESC_POSY | DWDESC_SURFACE_CAPS;
desc.posx = x;
desc.posy = y;
desc.width = windata->size.w;
desc.height = windata->size.h;
desc.pixelformat = dispdata->pixelformat;
desc.surface_caps = DSCAPS_PREMULTIPLIED;
/* Create the window. */
SDL_DFB_CHECKERR(dispdata->layer->CreateWindow(dispdata->layer, &desc,
&windata->window));
/* Set Options */
windata->window->GetOptions(windata->window, &wopts);
if (window->flags & SDL_WINDOW_RESIZABLE)
wopts |= DWOP_SCALE;
else
wopts |= DWOP_KEEP_SIZE;
if (window->flags & SDL_WINDOW_FULLSCREEN) {
wopts |= DWOP_KEEP_POSITION | DWOP_KEEP_STACKING | DWOP_KEEP_SIZE;
windata->window->SetStackingClass(windata->window, DWSC_UPPER);
}
windata->window->SetOptions(windata->window, wopts);
/* See what we got */
SDL_DFB_CHECKERR(DirectFB_WM_GetClientSize
(_this, window, &window->w, &window->h));
/* Get the window's surface. */
SDL_DFB_CHECKERR(windata->window->GetSurface(windata->window,
&windata->window_surface));
/* And get a subsurface for rendering */
SDL_DFB_CHECKERR(windata->window_surface->
GetSubSurface(windata->window_surface, &windata->client,
&windata->surface));
windata->window->SetOpacity(windata->window, 0xFF);
/* Create Eventbuffer */
SDL_DFB_CHECKERR(windata->window->CreateEventBuffer(windata->window,
&windata->
eventbuffer));
SDL_DFB_CHECKERR(windata->window->
EnableEvents(windata->window, DWET_ALL));
/* Create a font */
/* FIXME: once during Video_Init */
if (windata->is_managed) {
DFBFontDescription fdesc;
fdesc.flags = DFDESC_HEIGHT;
fdesc.height = windata->theme.font_size;
font = NULL;
SDL_DFB_CHECK(devdata->
dfb->CreateFont(devdata->dfb, windata->theme.font,
&fdesc, &font));
windata->window_surface->SetFont(windata->window_surface, font);
SDL_DFB_RELEASE(font);
}
/* Make it the top most window. */
windata->window->RaiseToTop(windata->window);
/* remember parent */
windata->window = window;
/* Add to list ... */
windata->next = devdata->firstwin;
windata->opacity = 0xFF;
devdata->firstwin = windata;
/* Draw Frame */
DirectFB_WM_RedrawLayout(window);
return 0;
error:
SDL_DFB_RELEASE(windata->window);
SDL_DFB_RELEASE(windata->surface);
return -1;
}
static int
DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
SDL_DFB_DEVICEDATA(display->device);
DirectFB_TextureData *data;
DFBResult ret;
DFBSurfaceDescription dsc;
SDL_DFB_CALLOC(data, 1, sizeof(*data));
texture->driverdata = data;
data->format = texture->format;
data->pitch = (texture->w * SDL_BYTESPERPIXEL(data->format));
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;
/* <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
/* find the right pixelformat */
dsc.pixelformat = SDLToDFBPixelFormat(data->format);
if (dsc.pixelformat == DSPF_UNKNOWN) {
SDL_SetError("Unknown pixel format %d\n", data->format);
goto error;
}
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)) {
SDL_DFB_CHECKERR(data->surface->GetPalette(data->surface,
&data->palette));
}
}
#if (DFB_VERSION_ATLEAST(1,2,0))
data->render_options = DSRO_NONE;
#endif
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
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;
}
SDL_Renderer *
DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_DFB_WINDOWDATA(window);
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
SDL_Renderer *renderer = NULL;
DirectFB_RenderData *data = NULL;
DFBResult ret;
DFBSurfaceCapabilities scaps;
char *p;
SDL_DFB_CALLOC(renderer, 1, sizeof(*renderer));
SDL_DFB_CALLOC(data, 1, sizeof(*data));
renderer->DisplayModeChanged = DirectFB_DisplayModeChanged;
renderer->ActivateRenderer = DirectFB_ActivateRenderer;
renderer->CreateTexture = DirectFB_CreateTexture;
renderer->QueryTexturePixels = DirectFB_QueryTexturePixels;
renderer->SetTexturePalette = DirectFB_SetTexturePalette;
renderer->GetTexturePalette = DirectFB_GetTexturePalette;
renderer->SetTextureAlphaMod = DirectFB_SetTextureAlphaMod;
renderer->SetTextureColorMod = DirectFB_SetTextureColorMod;
renderer->SetTextureBlendMode = DirectFB_SetTextureBlendMode;
renderer->SetTextureScaleMode = DirectFB_SetTextureScaleMode;
renderer->UpdateTexture = DirectFB_UpdateTexture;
renderer->LockTexture = DirectFB_LockTexture;
renderer->UnlockTexture = DirectFB_UnlockTexture;
renderer->DirtyTexture = DirectFB_DirtyTexture;
renderer->RenderPoint = DirectFB_RenderPoint;
renderer->RenderLine = DirectFB_RenderLine;
renderer->RenderFill = DirectFB_RenderFill;
renderer->RenderCopy = DirectFB_RenderCopy;
renderer->RenderPresent = DirectFB_RenderPresent;
renderer->DestroyTexture = DirectFB_DestroyTexture;
renderer->DestroyRenderer = DirectFB_DestroyRenderer;
renderer->info = DirectFB_RenderDriver.info;
renderer->window = window->id; /* SDL window id */
renderer->driverdata = data;
renderer->info.flags =
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTDISCARD;
data->window = window;
data->flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT;
if (flags & SDL_RENDERER_PRESENTVSYNC) {
data->flipflags |= DSFLIP_WAITFORSYNC;
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} else
data->flipflags |= DSFLIP_ONSYNC;
SDL_DFB_CHECKERR(windata->surface->
GetCapabilities(windata->surface, &scaps));
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;
data->isyuvdirect = 0; /* default is off! */
p = SDL_getenv(DFBENV_USE_YUV_DIRECT);
if (p)
data->isyuvdirect = atoi(p);
/* Set up a palette watch on the display palette */
if (display->palette) {
SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data);
}
return renderer;
error:
SDL_DFB_FREE(renderer);
SDL_DFB_FREE(data);
return NULL;
}
