Skip to content

L
libSDL
Commit 8a2b5b9e authored by Sam Lantinga's avatar Sam Lantinga
Browse files
Options

Date: Fri, 23 Aug 2002 11:48:56 +0200 

From: Denis Oliver Kropp
Subject: Another patch

this is another patch fixing key code mapping
along with some other fixes and better mode handling.

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%40465
parent 96910098
Hide whitespace changes
Inline Side-by-side
Showing with 275 additions and 185 deletions
src/video/directfb/SDL_DirectFB_events.c
View file @ 8a2b5b9e
......@@ -100,88 +100,88 @@ void DirectFB_InitOSKeymap (_THIS)
for (i=0; i<SDL_TABLESIZE(keymap); ++i)
keymap[i] = SDLK_UNKNOWN;
keymap[DIKI_A] = SDLK_a;
keymap[DIKI_B] = SDLK_b;
keymap[DIKI_C] = SDLK_c;
keymap[DIKI_D] = SDLK_d;
keymap[DIKI_E] = SDLK_e;
keymap[DIKI_F] = SDLK_f;
keymap[DIKI_G] = SDLK_g;
keymap[DIKI_H] = SDLK_h;
keymap[DIKI_I] = SDLK_i;
keymap[DIKI_J] = SDLK_j;
keymap[DIKI_K] = SDLK_k;
keymap[DIKI_L] = SDLK_l;
keymap[DIKI_M] = SDLK_m;
keymap[DIKI_N] = SDLK_n;
keymap[DIKI_O] = SDLK_o;
keymap[DIKI_P] = SDLK_p;
keymap[DIKI_Q] = SDLK_q;
keymap[DIKI_R] = SDLK_r;
keymap[DIKI_S] = SDLK_s;
keymap[DIKI_T] = SDLK_t;
keymap[DIKI_U] = SDLK_u;
keymap[DIKI_V] = SDLK_v;
keymap[DIKI_W] = SDLK_w;
keymap[DIKI_X] = SDLK_x;
keymap[DIKI_Y] = SDLK_y;
keymap[DIKI_Z] = SDLK_z;
keymap[DIKI_A - DIKI_UNKNOWN] = SDLK_a;
keymap[DIKI_B - DIKI_UNKNOWN] = SDLK_b;
keymap[DIKI_C - DIKI_UNKNOWN] = SDLK_c;
keymap[DIKI_D - DIKI_UNKNOWN] = SDLK_d;
keymap[DIKI_E - DIKI_UNKNOWN] = SDLK_e;
keymap[DIKI_F - DIKI_UNKNOWN] = SDLK_f;
keymap[DIKI_G - DIKI_UNKNOWN] = SDLK_g;
keymap[DIKI_H - DIKI_UNKNOWN] = SDLK_h;
keymap[DIKI_I - DIKI_UNKNOWN] = SDLK_i;
keymap[DIKI_J - DIKI_UNKNOWN] = SDLK_j;
keymap[DIKI_K - DIKI_UNKNOWN] = SDLK_k;
keymap[DIKI_L - DIKI_UNKNOWN] = SDLK_l;
keymap[DIKI_M - DIKI_UNKNOWN] = SDLK_m;
keymap[DIKI_N - DIKI_UNKNOWN] = SDLK_n;
keymap[DIKI_O - DIKI_UNKNOWN] = SDLK_o;
keymap[DIKI_P - DIKI_UNKNOWN] = SDLK_p;
keymap[DIKI_Q - DIKI_UNKNOWN] = SDLK_q;
keymap[DIKI_R - DIKI_UNKNOWN] = SDLK_r;
keymap[DIKI_S - DIKI_UNKNOWN] = SDLK_s;
keymap[DIKI_T - DIKI_UNKNOWN] = SDLK_t;
keymap[DIKI_U - DIKI_UNKNOWN] = SDLK_u;
keymap[DIKI_V - DIKI_UNKNOWN] = SDLK_v;
keymap[DIKI_W - DIKI_UNKNOWN] = SDLK_w;
keymap[DIKI_X - DIKI_UNKNOWN] = SDLK_x;
keymap[DIKI_Y - DIKI_UNKNOWN] = SDLK_y;
keymap[DIKI_Z - DIKI_UNKNOWN] = SDLK_z;
keymap[DIKI_0] = SDLK_0;
keymap[DIKI_1] = SDLK_1;
keymap[DIKI_2] = SDLK_2;
keymap[DIKI_3] = SDLK_3;
keymap[DIKI_4] = SDLK_4;
keymap[DIKI_5] = SDLK_5;
keymap[DIKI_6] = SDLK_6;
keymap[DIKI_7] = SDLK_7;
keymap[DIKI_8] = SDLK_8;
keymap[DIKI_9] = SDLK_9;
keymap[DIKI_0 - DIKI_UNKNOWN] = SDLK_0;
keymap[DIKI_1 - DIKI_UNKNOWN] = SDLK_1;
keymap[DIKI_2 - DIKI_UNKNOWN] = SDLK_2;
keymap[DIKI_3 - DIKI_UNKNOWN] = SDLK_3;
keymap[DIKI_4 - DIKI_UNKNOWN] = SDLK_4;
keymap[DIKI_5 - DIKI_UNKNOWN] = SDLK_5;
keymap[DIKI_6 - DIKI_UNKNOWN] = SDLK_6;
keymap[DIKI_7 - DIKI_UNKNOWN] = SDLK_7;
keymap[DIKI_8 - DIKI_UNKNOWN] = SDLK_8;
keymap[DIKI_9 - DIKI_UNKNOWN] = SDLK_9;
keymap[DIKI_F1] = SDLK_F1;
keymap[DIKI_F2] = SDLK_F2;
keymap[DIKI_F3] = SDLK_F3;
keymap[DIKI_F4] = SDLK_F4;
keymap[DIKI_F5] = SDLK_F5;
keymap[DIKI_F6] = SDLK_F6;
keymap[DIKI_F7] = SDLK_F7;
keymap[DIKI_F8] = SDLK_F8;
keymap[DIKI_F9] = SDLK_F9;
keymap[DIKI_F10] = SDLK_F10;
keymap[DIKI_F11] = SDLK_F11;
keymap[DIKI_F12] = SDLK_F12;
keymap[DIKI_F1 - DIKI_UNKNOWN] = SDLK_F1;
keymap[DIKI_F2 - DIKI_UNKNOWN] = SDLK_F2;
keymap[DIKI_F3 - DIKI_UNKNOWN] = SDLK_F3;
keymap[DIKI_F4 - DIKI_UNKNOWN] = SDLK_F4;
keymap[DIKI_F5 - DIKI_UNKNOWN] = SDLK_F5;
keymap[DIKI_F6 - DIKI_UNKNOWN] = SDLK_F6;
keymap[DIKI_F7 - DIKI_UNKNOWN] = SDLK_F7;
keymap[DIKI_F8 - DIKI_UNKNOWN] = SDLK_F8;
keymap[DIKI_F9 - DIKI_UNKNOWN] = SDLK_F9;
keymap[DIKI_F10 - DIKI_UNKNOWN] = SDLK_F10;
keymap[DIKI_F11 - DIKI_UNKNOWN] = SDLK_F11;
keymap[DIKI_F12 - DIKI_UNKNOWN] = SDLK_F12;
keymap[DIKI_ESCAPE] = SDLK_ESCAPE;
keymap[DIKI_LEFT] = SDLK_LEFT;
keymap[DIKI_RIGHT] = SDLK_RIGHT;
keymap[DIKI_UP] = SDLK_UP;
keymap[DIKI_DOWN] = SDLK_DOWN;
keymap[DIKI_CONTROL_L] = SDLK_LCTRL;
keymap[DIKI_CONTROL_R] = SDLK_RCTRL;
keymap[DIKI_SHIFT_L] = SDLK_LSHIFT;
keymap[DIKI_SHIFT_R] = SDLK_RSHIFT;
keymap[DIKI_ALT_L] = SDLK_LALT;
keymap[DIKI_ALTGR] = SDLK_RALT;
keymap[DIKI_TAB] = SDLK_TAB;
keymap[DIKI_ENTER] = SDLK_RETURN;
keymap[DIKI_SPACE] = SDLK_SPACE;
keymap[DIKI_BACKSPACE] = SDLK_BACKSPACE;
keymap[DIKI_INSERT] = SDLK_INSERT;
keymap[DIKI_DELETE] = SDLK_DELETE;
keymap[DIKI_HOME] = SDLK_HOME;
keymap[DIKI_END] = SDLK_END;
keymap[DIKI_PAGE_UP] = SDLK_PAGEUP;
keymap[DIKI_PAGE_DOWN] = SDLK_PAGEDOWN;
keymap[DIKI_CAPS_LOCK] = SDLK_CAPSLOCK;
keymap[DIKI_NUM_LOCK] = SDLK_NUMLOCK;
keymap[DIKI_SCROLL_LOCK] = SDLK_SCROLLOCK;
keymap[DIKI_PRINT] = SDLK_PRINT;
keymap[DIKI_PAUSE] = SDLK_PAUSE;
keymap[DIKI_KP_DIV] = SDLK_KP_DIVIDE;
keymap[DIKI_KP_MULT] = SDLK_KP_MULTIPLY;
keymap[DIKI_KP_MINUS] = SDLK_KP_MINUS;
keymap[DIKI_KP_PLUS] = SDLK_KP_PLUS;
keymap[DIKI_KP_ENTER] = SDLK_KP_ENTER;
keymap[DIKI_ESCAPE - DIKI_UNKNOWN] = SDLK_ESCAPE;
keymap[DIKI_LEFT - DIKI_UNKNOWN] = SDLK_LEFT;
keymap[DIKI_RIGHT - DIKI_UNKNOWN] = SDLK_RIGHT;
keymap[DIKI_UP - DIKI_UNKNOWN] = SDLK_UP;
keymap[DIKI_DOWN - DIKI_UNKNOWN] = SDLK_DOWN;
keymap[DIKI_CONTROL_L - DIKI_UNKNOWN] = SDLK_LCTRL;
keymap[DIKI_CONTROL_R - DIKI_UNKNOWN] = SDLK_RCTRL;
keymap[DIKI_SHIFT_L - DIKI_UNKNOWN] = SDLK_LSHIFT;
keymap[DIKI_SHIFT_R - DIKI_UNKNOWN] = SDLK_RSHIFT;
keymap[DIKI_ALT_L - DIKI_UNKNOWN] = SDLK_LALT;
keymap[DIKI_ALTGR - DIKI_UNKNOWN] = SDLK_RALT;
keymap[DIKI_TAB - DIKI_UNKNOWN] = SDLK_TAB;
keymap[DIKI_ENTER - DIKI_UNKNOWN] = SDLK_RETURN;
keymap[DIKI_SPACE - DIKI_UNKNOWN] = SDLK_SPACE;
keymap[DIKI_BACKSPACE - DIKI_UNKNOWN] = SDLK_BACKSPACE;
keymap[DIKI_INSERT - DIKI_UNKNOWN] = SDLK_INSERT;
keymap[DIKI_DELETE - DIKI_UNKNOWN] = SDLK_DELETE;
keymap[DIKI_HOME - DIKI_UNKNOWN] = SDLK_HOME;
keymap[DIKI_END - DIKI_UNKNOWN] = SDLK_END;
keymap[DIKI_PAGE_UP - DIKI_UNKNOWN] = SDLK_PAGEUP;
keymap[DIKI_PAGE_DOWN - DIKI_UNKNOWN] = SDLK_PAGEDOWN;
keymap[DIKI_CAPS_LOCK - DIKI_UNKNOWN] = SDLK_CAPSLOCK;
keymap[DIKI_NUM_LOCK - DIKI_UNKNOWN] = SDLK_NUMLOCK;
keymap[DIKI_SCROLL_LOCK - DIKI_UNKNOWN] = SDLK_SCROLLOCK;
keymap[DIKI_PRINT - DIKI_UNKNOWN] = SDLK_PRINT;
keymap[DIKI_PAUSE - DIKI_UNKNOWN] = SDLK_PAUSE;
keymap[DIKI_KP_DIV - DIKI_UNKNOWN] = SDLK_KP_DIVIDE;
keymap[DIKI_KP_MULT - DIKI_UNKNOWN] = SDLK_KP_MULTIPLY;
keymap[DIKI_KP_MINUS - DIKI_UNKNOWN] = SDLK_KP_MINUS;
keymap[DIKI_KP_PLUS - DIKI_UNKNOWN] = SDLK_KP_PLUS;
keymap[DIKI_KP_ENTER - DIKI_UNKNOWN] = SDLK_KP_ENTER;
}
......@@ -195,7 +195,7 @@ static SDL_keysym *DirectFB_TranslateKey (DFBInputEvent *ev, SDL_keysym *keysym)
if (ev->key_symbol > 0 && ev->key_symbol < 128)
keysym->sym = ev->key_symbol;
else
keysym->sym = keymap[ev->key_id];
keysym->sym = keymap[ev->key_id - DIKI_UNKNOWN];
return keysym;
}
......
src/video/directfb/SDL_DirectFB_video.c
View file @ 8a2b5b9e
......@@ -29,6 +29,7 @@ static char rcsid =
*/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
......@@ -78,7 +79,7 @@ struct DirectFBEnumRect {
struct DirectFBEnumRect* next;
};
static struct DirectFBEnumRect *enumlists[NUM_MODELISTS];
static struct DirectFBEnumRect *enumlist = NULL;
/* DirectFB driver bootstrap functions */
......@@ -150,6 +151,31 @@ VideoBootStrap DirectFB_bootstrap = {
DirectFB_Available, DirectFB_CreateDevice
};
static DFBSurfacePixelFormat GetFormatForBpp (int bpp, IDirectFBDisplayLayer *layer)
{
DFBDisplayLayerConfig dlc;
int bytes = (bpp + 7) / 8;
layer->GetConfiguration (layer, &dlc);
if (bytes == DFB_BYTES_PER_PIXEL(dlc.pixelformat))
return dlc.pixelformat;
switch (bytes)
{
case 1:
return DSPF_RGB332;
case 2:
return DSPF_RGB16;
case 3:
return DSPF_RGB24;
case 4:
return DSPF_RGB32;
}
return DSPF_UNKNOWN;
}
static DFBEnumerationResult EnumModesCallback (unsigned int width,
unsigned int height,
unsigned int bpp,
......@@ -158,30 +184,21 @@ static DFBEnumerationResult EnumModesCallback (unsigned int width,
SDL_VideoDevice *this = (SDL_VideoDevice *)data;
struct DirectFBEnumRect *enumrect;
switch (bpp)
{
case 8:
case 15:
case 16:
case 24:
case 32:
bpp /= 8; --bpp;
++HIDDEN->SDL_nummodes[bpp];
enumrect = (struct DirectFBEnumRect*)malloc(sizeof(struct DirectFBEnumRect));
if ( !enumrect )
{
SDL_OutOfMemory();
return DFENUM_CANCEL;
}
enumrect->r.x = 0;
enumrect->r.y = 0;
enumrect->r.w = width;
enumrect->r.h = height;
enumrect->next = enumlists[bpp];
enumlists[bpp] = enumrect;
break;
HIDDEN->nummodes++;
enumrect = calloc(1, sizeof(struct DirectFBEnumRect));
if (!enumrect)
{
SDL_OutOfMemory();
return DFENUM_CANCEL;
}
enumrect->r.w = width;
enumrect->r.h = height;
enumrect->next = enumlist;
enumlist = enumrect;
return DFENUM_OK;
}
......@@ -219,13 +236,20 @@ static DFBSurfacePixelFormat SDLToDFBPixelFormat (SDL_PixelFormat *format)
return DSPF_RGB15;
break;
case 8:
if (format->Rmask == 0xE0 &&
format->Gmask == 0x1C &&
format->Bmask == 0x03)
return DSPF_RGB332;
break;
case 24:
if (format->Rmask == 0xFF0000 &&
format->Gmask == 0x00FF00 &&
format->Bmask == 0x0000FF)
return DSPF_RGB24;
break;
case 32:
if (format->Rmask == 0xFF0000 &&
format->Gmask == 0x00FF00 &&
......@@ -243,6 +267,8 @@ static DFBSurfacePixelFormat SDLToDFBPixelFormat (SDL_PixelFormat *format)
{
switch (format->BitsPerPixel)
{
case 8:
return DSPF_RGB332;
case 15:
return DSPF_RGB15;
case 16:
......@@ -257,28 +283,67 @@ static DFBSurfacePixelFormat SDLToDFBPixelFormat (SDL_PixelFormat *format)
return DSPF_UNKNOWN;
}
static const __u8 lookup3to8[] = { 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff };
static const __u8 lookup2to8[] = { 0x00, 0x55, 0xaa, 0xff };
static SDL_Palette *GenerateRGB332Palette()
{
int i;
SDL_Palette *palette;
SDL_Color *colors;
palette = calloc (1, sizeof(SDL_Palette));
if (!palette)
{
SDL_OutOfMemory();
return NULL;
}
colors = calloc (256, sizeof(SDL_Color));
if (!colors)
{
SDL_OutOfMemory();
return NULL;
}
for (i=0; i<256; i++)
{
colors[i].r = lookup3to8[ i >> 5 ];
colors[i].g = lookup3to8[ (i >> 2) & 7 ];
colors[i].g = lookup2to8[ i & 3 ];
}
palette->ncolors = 256;
palette->colors = colors;
return palette;
}
static int DFBToSDLPixelFormat (DFBSurfacePixelFormat pixelformat, SDL_PixelFormat *format)
{
format->BitsPerPixel = 0;
format->Amask = format->Rmask = format->Gmask = format->Bmask = 0;
format->BitsPerPixel = format->BytesPerPixel = 0;
switch (pixelformat)
{
case DSPF_A8:
format->Amask = 0x000000FF;
break;
case DSPF_RGB15:
format->Rmask = 0x00007C00;
format->Gmask = 0x000003E0;
format->Bmask = 0x0000001F;
break;
case DSPF_RGB16:
format->Rmask = 0x0000F800;
format->Gmask = 0x000007E0;
format->Bmask = 0x0000001F;
break;
case DSPF_ARGB:
format->Amask = 0xFF000000;
format->Amask = 0; /* apps don't seem to like that: 0xFF000000; */
/* fall through */
case DSPF_RGB24:
case DSPF_RGB32:
......@@ -286,11 +351,21 @@ static int DFBToSDLPixelFormat (DFBSurfacePixelFormat pixelformat, SDL_PixelForm
format->Gmask = 0x0000FF00;
format->Bmask = 0x000000FF;
break;
case DSPF_RGB332:
format->Rmask = 0x000000E0;
format->Gmask = 0x0000001C;
format->Bmask = 0x00000003;
format->palette = GenerateRGB332Palette();
break;
default:
return -1;
}
format->BitsPerPixel = DFB_BITS_PER_PIXEL(pixelformat);
format->BitsPerPixel = DFB_BYTES_PER_PIXEL(pixelformat) * 8;
format->BytesPerPixel = DFB_BYTES_PER_PIXEL(pixelformat);
return 0;
}
......@@ -298,44 +373,43 @@ static int DFBToSDLPixelFormat (DFBSurfacePixelFormat pixelformat, SDL_PixelForm
int DirectFB_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
int i, j;
DFBResult ret;
IDirectFB *dfb;
DFBCardCapabilities caps;
IDirectFBDisplayLayer *layer;
DFBDisplayLayerConfig dlc;
IDirectFBEventBuffer *eventbuffer;
int i;
DFBResult ret;
DFBCardCapabilities caps;
DFBDisplayLayerConfig dlc;
DFBSurfacePixelFormat format;
struct DirectFBEnumRect *rect;
IDirectFB *dfb = NULL;
IDirectFBDisplayLayer *layer = NULL;
IDirectFBEventBuffer *events = NULL;
ret = DirectFBInit (NULL, NULL);
if (ret)
{
SetDirectFBerror ("DirectFBInit", ret);
return -1;
goto error;
}
ret = DirectFBCreate (&dfb);
if (ret)
{
SetDirectFBerror ("DirectFBCreate", ret);
return -1;
goto error;
}
ret = dfb->GetDisplayLayer (dfb, DLID_PRIMARY, &layer);
if (ret)
{
SetDirectFBerror ("dfb->GetDisplayLayer", ret);
dfb->Release (dfb);
return -1;
goto error;
}
ret = dfb->CreateEventBuffer (dfb, DICAPS_ALL, &eventbuffer);
ret = dfb->CreateEventBuffer (dfb, DICAPS_ALL, &events);
if (ret)
{
SetDirectFBerror ("dfb->CreateEventBuffer", ret);
layer->Release (layer);
dfb->Release (dfb);
return -1;
goto error;
}
layer->EnableCursor (layer, 1);
......@@ -343,43 +417,39 @@ int DirectFB_VideoInit(_THIS, SDL_PixelFormat *vformat)
/* Query layer configuration to determine the current mode and pixelformat */
layer->GetConfiguration (layer, &dlc);
if (DFBToSDLPixelFormat (dlc.pixelformat, vformat))
/* FIXME: Returning RGB332 as the default mode doesn't work (everything is black) */
if ((format = dlc.pixelformat) == DSPF_RGB332)
format = DSPF_RGB16;
if (DFBToSDLPixelFormat (format, vformat))
{
SDL_SetError ("Unsupported pixelformat");
layer->Release (layer);
dfb->Release (dfb);
return -1;
goto error;
}
/* Enumerate the available fullscreen modes */
for ( i=0; i<NUM_MODELISTS; ++i )
enumlists[i] = NULL;
ret = dfb->EnumVideoModes (dfb, EnumModesCallback, this);
if (ret)
{
SetDirectFBerror ("dfb->EnumVideoModes", ret);
layer->Release (layer);
dfb->Release (dfb);
return(-1);
goto error;
}
for ( i=0; i<NUM_MODELISTS; ++i )
HIDDEN->modelist = calloc (HIDDEN->nummodes + 1, sizeof(SDL_Rect *));
if (!HIDDEN->modelist)
{
struct DirectFBEnumRect *rect;
HIDDEN->SDL_modelist[i] = (SDL_Rect **) malloc
((HIDDEN->SDL_nummodes[i]+1)*sizeof(SDL_Rect *));
if ( HIDDEN->SDL_modelist[i] == NULL )
{
SDL_OutOfMemory();
return(-1);
}
for ( j = 0, rect = enumlists[i]; rect; ++j, rect = rect->next )
{
HIDDEN->SDL_modelist[i][j]=(SDL_Rect *)rect;
}
HIDDEN->SDL_modelist[i][j] = NULL;
SDL_OutOfMemory();
goto error;
}
for (i = 0, rect = enumlist; rect; ++i, rect = rect->next )
{
HIDDEN->modelist[i] = &rect->r;
}
HIDDEN->modelist[i] = NULL;
/* Query card capabilities to get the video memory size */
dfb->GetCardCapabilities (dfb, &caps);
......@@ -394,15 +464,27 @@ int DirectFB_VideoInit(_THIS, SDL_PixelFormat *vformat)
HIDDEN->initialized = 1;
HIDDEN->dfb = dfb;
HIDDEN->layer = layer;
HIDDEN->eventbuffer = eventbuffer;
HIDDEN->eventbuffer = events;
return 0;
error:
if (events)
events->Release (events);
if (layer)
layer->Release (layer);
if (dfb)
dfb->Release (dfb);
return -1;
}
static SDL_Rect **DirectFB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
{
if (flags & SDL_FULLSCREEN)
return HIDDEN->SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1];
return HIDDEN->modelist;
else
if (SDLToDFBPixelFormat (format) != DSPF_UNKNOWN)
return (SDL_Rect**) -1;
......@@ -410,7 +492,7 @@ static SDL_Rect **DirectFB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flag
return NULL;
}
SDL_Surface *DirectFB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
static SDL_Surface *DirectFB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
{
DFBResult ret;
DFBSurfaceDescription dsc;
......@@ -430,13 +512,12 @@ SDL_Surface *DirectFB_SetVideoMode(_THIS, SDL_Surface *current, int width, int h
else if (!current->hwdata)
{
/* Allocate the hardware acceleration data */
current->hwdata = (struct private_hwdata *) malloc (sizeof(*current->hwdata));
current->hwdata = (struct private_hwdata *) calloc (1, sizeof(*current->hwdata));
if (!current->hwdata)
{
SDL_OutOfMemory();
return NULL;
}
memset (current->hwdata, 0, sizeof(*current->hwdata));
}
/* Set cooperative level depending on flag SDL_FULLSCREEN */
......@@ -471,8 +552,9 @@ SDL_Surface *DirectFB_SetVideoMode(_THIS, SDL_Surface *current, int width, int h
}
/* Create primary surface */
dsc.flags = DSDESC_CAPS;
dsc.caps = DSCAPS_PRIMARY | ((flags & SDL_DOUBLEBUF) ? DSCAPS_FLIPPING : 0);
dsc.flags = DSDESC_CAPS | DSDESC_PIXELFORMAT;
dsc.caps = DSCAPS_PRIMARY | ((flags & SDL_DOUBLEBUF) ? DSCAPS_FLIPPING : 0);
dsc.pixelformat = GetFormatForBpp (bpp, HIDDEN->layer);
ret = HIDDEN->dfb->CreateSurface (HIDDEN->dfb, &dsc, &current->hwdata->surface);
if (ret && (flags & SDL_DOUBLEBUF))
......@@ -524,7 +606,7 @@ static int DirectFB_AllocHWSurface(_THIS, SDL_Surface *surface)
dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS;
dsc.width = surface->w;
dsc.height = surface->h;
dsc.caps = surface->flags & SDL_DOUBLEBUF ? DSCAPS_FLIPPING : 0;
dsc.caps = (surface->flags & SDL_DOUBLEBUF) ? DSCAPS_FLIPPING : 0;
/* find the right pixelformat */
dsc.pixelformat = SDLToDFBPixelFormat (surface->format);
......@@ -532,7 +614,7 @@ static int DirectFB_AllocHWSurface(_THIS, SDL_Surface *surface)
return -1;
/* Allocate the hardware acceleration data */
surface->hwdata = (struct private_hwdata *) malloc (sizeof(*surface->hwdata));
surface->hwdata = (struct private_hwdata *) calloc (1, sizeof(*surface->hwdata));
if (surface->hwdata == NULL)
{
SDL_OutOfMemory();
......@@ -581,21 +663,12 @@ static int DirectFB_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst)
static int DirectFB_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
SDL_Surface *dst, SDL_Rect *dstrect)
{
DFBRectangle sr, dr;
IDirectFBSurface *surface;
DFBSurfaceBlittingFlags flags = DSBLIT_NOFX;
DFBSurfaceBlittingFlags flags = DSBLIT_NOFX;
sr.x = srcrect->x;
sr.y = srcrect->y;
sr.w = srcrect->w;
sr.h = srcrect->h;
DFBRectangle sr = { srcrect->x, srcrect->y, srcrect->w, srcrect->h };
DFBRectangle dr = { dstrect->x, dstrect->y, dstrect->w, dstrect->h };
dr.x = dstrect->x;
dr.y = dstrect->y;
dr.w = dstrect->w;
dr.h = dstrect->h;
surface = dst->hwdata->surface;
IDirectFBSurface *surface = dst->hwdata->surface;
if (src->flags & SDL_SRCCOLORKEY)
{
......@@ -737,28 +810,46 @@ static void DirectFB_WindowedUpdate(_THIS, int numrects, SDL_Rect *rects)
int DirectFB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
{
fprintf(stderr, "SDL: Unimplemented DirectFB_SetColors!\n");
return 0;
return -1;
}
void DirectFB_VideoQuit(_THIS)
{
int i, j;
struct DirectFBEnumRect *rect = enumlist;
if (HIDDEN->eventbuffer)
{
HIDDEN->eventbuffer->Release (HIDDEN->eventbuffer);
HIDDEN->eventbuffer = NULL;
}
HIDDEN->eventbuffer->Release (HIDDEN->eventbuffer);
HIDDEN->layer->Release (HIDDEN->layer);
HIDDEN->dfb->Release (HIDDEN->dfb);
if (HIDDEN->layer)
{
HIDDEN->layer->Release (HIDDEN->layer);
HIDDEN->layer = NULL;
}
/* Free video mode lists */
for ( i=0; i<NUM_MODELISTS; ++i )
if (HIDDEN->dfb)
{
if ( HIDDEN->SDL_modelist[i] != NULL )
{
for ( j=0; HIDDEN->SDL_modelist[i][j]; ++j )
free(HIDDEN->SDL_modelist[i][j]);
free(HIDDEN->SDL_modelist[i]);
HIDDEN->SDL_modelist[i] = NULL;
}
HIDDEN->dfb->Release (HIDDEN->dfb);
HIDDEN->dfb = NULL;
}
/* Free video mode list */
if (HIDDEN->modelist)
{
free (HIDDEN->modelist);
HIDDEN->modelist = NULL;
}
/* Free mode enumeration list */
while (rect)
{
struct DirectFBEnumRect *next = rect->next;
free (rect);
rect = next;
}
enumlist = NULL;
HIDDEN->initialized = 0;
}
......
src/video/directfb/SDL_DirectFB_video.h
View file @ 8a2b5b9e
......@@ -45,9 +45,8 @@ struct SDL_PrivateVideoData
IDirectFBDisplayLayer *layer;
IDirectFBEventBuffer *eventbuffer;
#define NUM_MODELISTS 4 /* 8, 16, 24, and 32 bits-per-pixel */
int SDL_nummodes[NUM_MODELISTS];
SDL_Rect **SDL_modelist[NUM_MODELISTS];
int nummodes;
SDL_Rect **modelist;
};
#define HIDDEN (this->hidden)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment