static DFBResult
dfb_sdl_set_video_mode_handler( CoreSurfaceConfig *config )
{
int depth = get_pixelformat_target_depth( config->format );
Uint32 flags = SDL_HWSURFACE | SDL_RESIZABLE;// | SDL_ASYNCBLIT | SDL_FULLSCREEN;
SDL_Surface *screen;
if (config->caps & DSCAPS_FLIPPING)
flags |= SDL_DOUBLEBUF;
fusion_skirmish_prevail( &dfb_sdl->lock );
D_DEBUG_AT( SDL_Screen, " -> SDL_SetVideoMode( %dx%d, %d, 0x%08x )\n",
config->size.w, config->size.h, DFB_BITS_PER_PIXEL(config->format), flags );
/* Set video mode */
screen = SDL_SetVideoMode( config->size.w, config->size.h, depth, flags );
if (!screen) {
D_ERROR( "DirectFB/SDL: Couldn't set %dx%dx%d video mode: %s\n",
config->size.w, config->size.h, depth, SDL_GetError());
fusion_skirmish_dismiss( &dfb_sdl->lock );
return DFB_FAILURE;
}
dfb_sdl->screen = screen;
/* Hide SDL's cursor */
SDL_ShowCursor( SDL_DISABLE );
fusion_skirmish_dismiss( &dfb_sdl->lock );
return DFB_OK;
}
DFBResult
dfb_surface_deallocate_buffers( CoreSurface *surface )
{
int i;
D_DEBUG_AT( Core_Surface, "%s( %p )\n", __FUNCTION__, surface );
D_MAGIC_ASSERT( surface, CoreSurface );
if (fusion_skirmish_prevail( &surface->lock ))
return DFB_FUSION;
if (surface->type & CSTF_PREALLOCATED) {
fusion_skirmish_dismiss( &surface->lock );
return DFB_UNSUPPORTED;
}
/* Deallocate the Surface Buffers. */
for (i = 0; i < surface->num_buffers; i++)
dfb_surface_buffer_deallocate( surface->buffers[i] );
fusion_skirmish_dismiss( &surface->lock );
return DFB_OK;
}
DFBResult
dfb_surface_dump_buffer( CoreSurface *surface,
CoreSurfaceBufferRole role,
const char *path,
const char *prefix )
{
DFBResult ret;
CoreSurfaceBuffer *buffer;
D_MAGIC_ASSERT( surface, CoreSurface );
D_ASSERT( path != NULL );
D_ASSERT( prefix != NULL );
if (fusion_skirmish_prevail( &surface->lock ))
return DFB_FUSION;
if (surface->num_buffers == 0) {
fusion_skirmish_dismiss( &surface->lock );
return DFB_SUSPENDED;
}
buffer = dfb_surface_get_buffer( surface, role );
D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
ret = dfb_surface_buffer_dump( buffer, path, prefix );
fusion_skirmish_dismiss( &surface->lock );
return ret;
}
static DFBResult
dfb_rtd_set_video_mode_handler( CoreLayerRegionConfig *config )
{
#if 0
int argc = 0;
char** argv = NULL;
D_DEBUG( "DirectFB/RTD: layer config properties\n");
if(rfb_screen) /*!!! FIXME*/
return DFB_OK;
fusion_skirmish_prevail( &dfb_rtd->lock );
/* Set video mode */
rfb_screen = rfbGetScreen(&argc, argv, config->width, config->height, DFB_BITS_PER_PIXEL(config->format)/3, 3, 4);
D_DEBUG( "DirectFB/RTD: rfbGetScreen parameters: width %d height %d bitspersample %d samplesperpixel %d bytesperpixel %d\n", config->width, config->height, DFB_BITS_PER_PIXEL(config->format)/3, 3, 4);
/*screen = rfbGetScreen(&argc, argv, config->width, config->height, 8, 3, 4);*/
if ( rfb_screen == NULL )
{
D_ERROR( "DirectFB/RTD: Couldn't set %dx%dx%d video mode\n",
config->width, config->height,
DFB_COLOR_BITS_PER_PIXEL(config->format) );
fusion_skirmish_dismiss( &dfb_rtd->lock );
return DFB_FAILURE;
}
if(DFB_COLOR_BITS_PER_PIXEL(config->format) == DSPF_RGB16)
{
rfb_screen->serverFormat.redShift = 11;
rfb_screen->serverFormat.greenShift = 5;
rfb_screen->serverFormat.blueShift = 0;
rfb_screen->serverFormat.redMax = 31;
rfb_screen->serverFormat.greenMax = 63;
rfb_screen->serverFormat.blueMax = 31;
}
/* screen->serverFormat.trueColour=FALSE; */
rfb_screen->frameBuffer = malloc(rfb_screen->width * rfb_screen->height * rfb_screen->depth / 8) ;
if ( ! rfb_screen->frameBuffer )
{
fusion_skirmish_dismiss( &dfb_rtd->lock );
return DFB_NOSYSTEMMEMORY;
}
fusion_skirmish_dismiss( &dfb_rtd->lock );
#endif
return DFB_OK;
}
/*
* Input thread reading from device.
* Generates events on incoming data.
*/
static void*
osxEventThread( DirectThread *thread, void *driver_data )
{
OSXInputData *data = (OSXInputData*) driver_data;
DFBOSX *dfb_osx = data->dfb_osx;
while (!data->stop) {
DFBInputEvent evt;
EventRecord event;
fusion_skirmish_prevail( &dfb_osx->lock );
/* Check for events */
while ( WaitNextEvent( everyEvent, &event, 0, nil) ) {
fusion_skirmish_dismiss( &dfb_osx->lock );
switch (event.what) {
case keyDown:
case keyUp:
case autoKey:
if (event.what == keyUp)
evt.type = DIET_KEYRELEASE;
else
evt.type = DIET_KEYPRESS;
if (translate_key( event.message & (charCodeMask | keyCodeMask), &evt )) {
dfb_input_dispatch( data->device, &evt );
}
break;
case mouseDown:
evt.type = DIET_BUTTONPRESS;
evt.button = DIBI_LEFT;
dfb_input_dispatch( data->device, &evt );
break;
case mouseUp:
evt.type = DIET_BUTTONRELEASE;
evt.button = DIBI_LEFT;
dfb_input_dispatch( data->device, &evt );
break;
default:
printf("%d\n",event.what);
break;
}
fusion_skirmish_prevail( &dfb_osx->lock );
}
fusion_skirmish_dismiss( &dfb_osx->lock );
usleep(10000);
direct_thread_testcancel( thread );
}
return NULL;
}
DirectResult
fusion_shm_pool_destroy( FusionWorld *world,
FusionSHMPoolShared *pool )
{
DirectResult ret;
FusionSHM *shm;
FusionSHMShared *shared;
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p )\n", __FUNCTION__, world, pool );
D_MAGIC_ASSERT( world, FusionWorld );
D_MAGIC_ASSERT( pool, FusionSHMPoolShared );
shm = &world->shm;
D_MAGIC_ASSERT( shm, FusionSHM );
shared = shm->shared;
D_MAGIC_ASSERT( shared, FusionSHMShared );
D_ASSERT( shared == pool->shm );
ret = fusion_skirmish_prevail( &shared->lock );
if (ret)
return ret;
ret = fusion_skirmish_prevail( &pool->lock );
if (ret) {
fusion_skirmish_dismiss( &shared->lock );
return ret;
}
D_ASSERT( pool->active );
D_ASSERT( pool->index >= 0 );
D_ASSERT( pool->index < FUSION_SHM_MAX_POOLS );
D_ASSERT( pool->pool_id == shm->pools[pool->index].pool_id );
D_ASSERT( pool == &shared->pools[pool->index] );
D_MAGIC_ASSERT( &shm->pools[pool->index], FusionSHMPool );
shutdown_pool( shm, &shm->pools[pool->index], pool );
shared->num_pools--;
fusion_skirmish_dismiss( &shared->lock );
return DR_OK;
}
static DFBResult
dfb_rtd_set_palette_handler( CorePalette *palette )
{
#if 0
unsigned int i;
uint8_t* map;
rfb_screen->colourMap.count = palette->num_entries;
rfb_screen->colourMap.is16 = false;
rfb_screen->serverFormat.trueColour=FALSE;
D_DEBUG( "DirectFB/RTD: setting colourmap of size %d\n", palette->num_entries);
if( (map = (uint8_t*) malloc(rfb_screen->colourMap.count*sizeof(uint8_t)*3)) == NULL )
return DFB_NOSYSTEMMEMORY;
for (i=0; i<palette->num_entries; i++) {
*(map++) = palette->entries[i].r;
*(map++) = palette->entries[i].g;
*(map++) = palette->entries[i].b;
}
fusion_skirmish_prevail( &dfb_rtd->lock );
if( rfb_screen->colourMap.data.bytes )
free(rfb_screen->colourMap.data.bytes);
rfb_screen->colourMap.data.bytes = map;
fusion_skirmish_dismiss( &dfb_rtd->lock );
#endif
return DFB_OK;
}
DirectResult
fusion_ref_watch (FusionRef *ref, FusionCall *call, int call_arg)
{
DirectResult ret;
D_ASSERT( ref != NULL );
D_ASSERT( call != NULL );
ret = fusion_skirmish_prevail( &ref->multi.builtin.lock );
if (ret)
return ret;
if (ref->multi.builtin.local+ref->multi.builtin.global == 0) {
D_BUG( "ref has no references" );
ret = DR_BUG;
}
else if (ref->multi.builtin.call) {
ret = DR_BUSY;
}
else {
ref->multi.builtin.call = call;
ref->multi.builtin.call_arg = call_arg;
fusion_skirmish_notify( &ref->multi.builtin.lock );
}
fusion_skirmish_dismiss( &ref->multi.builtin.lock );
return ret;
}
static void
bench_skirmish()
{
DirectResult ret;
FusionSkirmish skirmish;
ret = fusion_skirmish_init( &skirmish, "Benchmark", world );
if (ret) {
fprintf( stderr, "Fusion Error %d\n", ret );
return;
}
/* skirmish prevail/dismiss */
BENCH_START();
BENCH_LOOP() {
fusion_skirmish_prevail( &skirmish );
fusion_skirmish_dismiss( &skirmish );
}
BENCH_STOP();
printf( "skirmish prevail/dismiss -> %8.2f k/sec\n", BENCH_RESULT() );
fusion_skirmish_destroy( &skirmish );
printf( "\n" );
}
DirectResult
dfb_layer_region_unlock( CoreLayerRegion *region )
{
D_ASSERT( region != NULL );
return fusion_skirmish_dismiss( ®ion->lock );
}
static DFBResult
sh7722RemoveRegion( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data )
{
int n;
SH7722DriverData *sdrv = driver_data;
SH7722DeviceData *sdev = sdrv->dev;
SH7722MultiRegionData *sreg = region_data;
D_DEBUG_AT( SH7722_Layer, "%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( sreg, SH7722MultiRegionData );
n = sreg->index;
D_ASSERT( n >= 0 );
D_ASSERT( n <= 3 );
fusion_skirmish_prevail( &sdev->beu_lock );
/* Wait for idle BEU. */
BEU_Wait( sdrv, sdev );
/* Disable multi window. */
SH7722_SETREG32( sdrv, BMWCR0, SH7722_GETREG32( sdrv, BMWCR0 ) & ~(1 << n) );
/* Start operation! */
BEU_Start( sdrv, sdev );
fusion_skirmish_dismiss( &sdev->beu_lock );
return DFB_OK;
}
DirectResult
fusion_shm_pool_attach( FusionSHM *shm,
FusionSHMPoolShared *pool )
{
DirectResult ret;
FusionSHMShared *shared;
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p )\n", __FUNCTION__, shm, pool );
D_MAGIC_ASSERT( shm, FusionSHM );
D_MAGIC_ASSERT( pool, FusionSHMPoolShared );
shared = shm->shared;
D_MAGIC_ASSERT( shared, FusionSHMShared );
D_ASSERT( shared == pool->shm );
ret = fusion_skirmish_prevail( &pool->lock );
if (ret) {
return ret;
}
D_ASSERT( pool->active );
D_ASSERT( pool->index >= 0 );
D_ASSERT( pool->index < FUSION_SHM_MAX_POOLS );
D_ASSERT( pool == &shared->pools[pool->index] );
D_ASSERT( !shm->pools[pool->index].attached );
ret = join_pool( shm, &shm->pools[pool->index], pool );
fusion_skirmish_dismiss( &pool->lock );
return ret;
}
DFBResult
dfb_surface_set_palette( CoreSurface *surface,
CorePalette *palette )
{
D_MAGIC_ASSERT( surface, CoreSurface );
D_MAGIC_ASSERT_IF( palette, CorePalette );
if (fusion_skirmish_prevail( &surface->lock ))
return DFB_FUSION;
if (surface->palette != palette) {
if (surface->palette) {
dfb_palette_detach_global( surface->palette, &surface->palette_reaction );
dfb_palette_unlink( &surface->palette );
}
if (palette) {
dfb_palette_link( &surface->palette, palette );
dfb_palette_attach_global( palette, DFB_SURFACE_PALETTE_LISTENER,
surface, &surface->palette_reaction );
}
dfb_surface_notify( surface, CSNF_PALETTE_CHANGE );
}
fusion_skirmish_dismiss( &surface->lock );
return DFB_OK;
}
DFBResult
dfb_surface_clear_buffers( CoreSurface *surface )
{
DFBResult ret = DFB_OK;
D_MAGIC_ASSERT( surface, CoreSurface );
if (surface->num_buffers == 0)
return DFB_SUSPENDED;
if (fusion_skirmish_prevail( &surface->lock ))
return DFB_FUSION;
dfb_gfx_clear( surface, CSBR_FRONT );
if (surface->config.caps & DSCAPS_FLIPPING)
dfb_gfx_clear( surface, CSBR_BACK );
if (surface->config.caps & DSCAPS_TRIPLE)
dfb_gfx_clear( surface, CSBR_IDLE );
fusion_skirmish_dismiss( &surface->lock );
return ret;
}
DFBResult
dfb_surface_write_buffer( CoreSurface *surface,
CoreSurfaceBufferRole role,
const void *source,
int pitch,
const DFBRectangle *rect )
{
DFBResult ret;
CoreSurfaceBuffer *buffer;
D_MAGIC_ASSERT( surface, CoreSurface );
D_ASSERT( source != NULL );
D_ASSERT( pitch > 0 );
DFB_RECTANGLE_ASSERT_IF( rect );
if (fusion_skirmish_prevail( &surface->lock ))
return DFB_FUSION;
buffer = dfb_surface_get_buffer( surface, role );
D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
ret = dfb_surface_buffer_write( buffer, source, pitch, rect );
fusion_skirmish_dismiss( &surface->lock );
return ret;
}
DirectResult
fusion_shm_pool_deallocate( FusionSHMPoolShared *pool,
void *data,
bool lock )
{
DirectResult ret;
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p )\n", __FUNCTION__, pool, data );
D_MAGIC_ASSERT( pool, FusionSHMPoolShared );
D_ASSERT( data != NULL );
D_ASSERT( data >= pool->addr_base );
D_ASSERT( data < pool->addr_base + pool->max_size );
if (lock) {
ret = fusion_skirmish_prevail( &pool->lock );
if (ret)
return ret;
}
__shmalloc_brk( pool->heap, 0 );
_fusion_shfree( pool->heap, data );
if (lock)
fusion_skirmish_dismiss( &pool->lock );
return DR_OK;
}
void
dfb_colorhash_detach( DFBColorHashCore *core,
CorePalette *palette )
{
DFBColorHashCoreShared *shared;
D_ASSUME( core != NULL );
if (core) {
D_MAGIC_ASSERT( core, DFBColorHashCore );
D_MAGIC_ASSERT( core->shared, DFBColorHashCoreShared );
}
else
core = core_colorhash;
shared = core->shared;
D_ASSERT( shared->hash_users > 0 );
D_ASSERT( shared->hash != NULL );
fusion_skirmish_prevail( &shared->hash_lock );
shared->hash_users--;
if (!shared->hash_users) {
/* no more users, free allocated resources */
SHFREE( shared->shmpool, shared->hash );
shared->hash = NULL;
}
fusion_skirmish_dismiss( &shared->hash_lock );
}
void
dfb_colorhash_attach( DFBColorHashCore *core,
CorePalette *palette )
{
DFBColorHashCoreShared *shared;
D_ASSUME( core != NULL );
if (core) {
D_MAGIC_ASSERT( core, DFBColorHashCore );
D_MAGIC_ASSERT( core->shared, DFBColorHashCoreShared );
}
else
core = core_colorhash;
shared = core->shared;
fusion_skirmish_prevail( &shared->hash_lock );
if (!shared->hash) {
D_ASSERT( shared->hash_users == 0 );
shared->hash = SHCALLOC( shared->shmpool, HASH_SIZE, sizeof (Colorhash) );
}
shared->hash_users++;
fusion_skirmish_dismiss( &shared->hash_lock );
}
DFBResult
dfb_surface_destroy_buffers( CoreSurface *surface )
{
int i;
D_MAGIC_ASSERT( surface, CoreSurface );
if (surface->type & CSTF_PREALLOCATED)
return DFB_UNSUPPORTED;
if (fusion_skirmish_prevail( &surface->lock ))
return DFB_FUSION;
/* Destroy the Surface Buffers. */
for (i=0; i<surface->num_buffers; i++) {
dfb_surface_buffer_destroy( surface->buffers[i] );
surface->buffers[i] = NULL;
}
surface->num_buffers = 0;
fusion_skirmish_dismiss( &surface->lock );
return DFB_OK;
}
DirectResult
_fusion_ref_change (FusionRef *ref, int add, bool global)
{
DirectResult ret;
D_ASSERT( ref != NULL );
D_ASSERT( add != 0 );
ret = fusion_skirmish_prevail( &ref->multi.builtin.lock );
if (ret)
return ret;
if (global) {
if (ref->multi.builtin.global+add < 0) {
D_BUG( "ref has no global references" );
fusion_skirmish_dismiss( &ref->multi.builtin.lock );
return DR_BUG;
}
ref->multi.builtin.global += add;
}
else {
if (ref->multi.builtin.local+add < 0) {
D_BUG( "ref has no local references" );
fusion_skirmish_dismiss( &ref->multi.builtin.lock );
return DR_BUG;
}
ref->multi.builtin.local += add;
_fusion_add_local( _fusion_world(ref->multi.shared), ref, add );
}
if (ref->multi.builtin.local+ref->multi.builtin.global == 0) {
fusion_skirmish_notify( &ref->multi.builtin.lock );
if (ref->multi.builtin.call) {
fusion_skirmish_dismiss( &ref->multi.builtin.lock );
return fusion_call_execute( ref->multi.builtin.call, FCEF_ONEWAY,
ref->multi.builtin.call_arg, NULL, NULL );
}
}
fusion_skirmish_dismiss( &ref->multi.builtin.lock );
return DR_OK;
}
DirectResult
fusion_shm_deinit( FusionWorld *world )
{
int i;
DirectResult ret;
FusionSHM *shm;
FusionSHMShared *shared;
D_MAGIC_ASSERT( world, FusionWorld );
shm = &world->shm;
D_MAGIC_ASSERT( shm, FusionSHM );
shared = shm->shared;
D_MAGIC_ASSERT( shared, FusionSHMShared );
ret = fusion_skirmish_prevail( &shared->lock );
if (ret)
return ret;
/* Deinitialize shared data. */
if (fusion_master( world )) {
D_ASSUME( shared->num_pools == 0 );
for (i=0; i<FUSION_SHM_MAX_POOLS; i++) {
if (shared->pools[i].active) {
D_MAGIC_ASSERT( &shared->pools[i], FusionSHMPoolShared );
D_MAGIC_ASSERT( &shm->pools[i], FusionSHMPool );
D_WARN( "destroying remaining '%s'", shared->pools[i].name );
fusion_shm_pool_destroy( world, &shared->pools[i] );
}
}
/* Destroy shared lock. */
fusion_skirmish_destroy( &shared->lock );
D_MAGIC_CLEAR( shared );
}
else {
for (i=0; i<FUSION_SHM_MAX_POOLS; i++) {
if (shared->pools[i].active) {
D_MAGIC_ASSERT( &shared->pools[i], FusionSHMPoolShared );
D_MAGIC_ASSERT( &shm->pools[i], FusionSHMPool );
fusion_shm_pool_detach( shm, &shared->pools[i] );
}
}
fusion_skirmish_dismiss( &shared->lock );
}
D_MAGIC_CLEAR( shm );
return DR_OK;
}
static DFBResult
sh7722FlipRegion( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreSurface *surface,
DFBSurfaceFlipFlags flags,
CoreSurfaceBufferLock *left_lock,
CoreSurfaceBufferLock *right_lock )
{
int n;
SH7722DriverData *sdrv = driver_data;
SH7722DeviceData *sdev = sdrv->dev;
SH7722LayerData *slay = layer_data;
D_DEBUG_AT( SH7722_Layer, "%s()\n", __FUNCTION__ );
D_ASSERT( surface != NULL );
D_ASSERT( sdrv != NULL );
D_ASSERT( sdev != NULL );
D_ASSERT( slay != NULL );
n = slay->layer - SH7722_LAYER_INPUT1;
D_ASSERT( n >= 0 );
D_ASSERT( n <= 2 );
D_ASSERT( lock->buffer != NULL );
fusion_skirmish_prevail( &sdev->beu_lock );
/* set new physical address for layer */
sdev->shbeu_src[n].s.py = left_lock->addr;
/* libshbeu: reorder src surfaces and start blending. */
if (sdev->input_mask) {
struct shbeu_surface * src[3] = {NULL, NULL, NULL};
int nr_surfaces = 0;
if (sdev->input_mask & 1) {
src[nr_surfaces] = &sdev->shbeu_src[0];
nr_surfaces++;
}
if (sdev->input_mask & 2) {
src[nr_surfaces] = &sdev->shbeu_src[1];
nr_surfaces++;
}
if (sdev->input_mask & 4) {
src[nr_surfaces] = &sdev->shbeu_src[2];
nr_surfaces++;
}
shbeu_blend(sdrv->shbeu, src[0], src[1], src[2], &sdev->shbeu_dest);
}
fusion_skirmish_dismiss( &sdev->beu_lock );
dfb_surface_flip( surface, false );
return DFB_OK;
}
DFBResult
dfb_clipboard_set( DFBClipboardCore *core,
const char *mime_type,
const void *data,
unsigned int size,
struct timeval *timestamp )
{
DFBClipboardCoreShared *shared;
char *new_mime;
void *new_data;
D_MAGIC_ASSERT( core, DFBClipboardCore );
D_ASSERT( mime_type != NULL );
D_ASSERT( data != NULL );
D_ASSERT( size > 0 );
shared = core->shared;
D_MAGIC_ASSERT( shared, DFBClipboardCoreShared );
new_mime = SHSTRDUP( shared->shmpool, mime_type );
if (!new_mime)
return D_OOSHM();
new_data = SHMALLOC( shared->shmpool, size );
if (!new_data) {
SHFREE( shared->shmpool, new_mime );
return D_OOSHM();
}
direct_memcpy( new_data, data, size );
if (fusion_skirmish_prevail( &shared->lock )) {
SHFREE( shared->shmpool, new_data );
SHFREE( shared->shmpool, new_mime );
return DFB_FUSION;
}
if (shared->data)
SHFREE( shared->shmpool, shared->data );
if (shared->mime_type)
SHFREE( shared->shmpool, shared->mime_type );
shared->mime_type = new_mime;
shared->data = new_data;
shared->size = size;
gettimeofday( &shared->timestamp, NULL );
if (timestamp)
*timestamp = shared->timestamp;
fusion_skirmish_dismiss( &shared->lock );
return DFB_OK;
}
DirectResult
fusion_ref_unlock (FusionRef *ref)
{
D_ASSERT( ref != NULL );
fusion_skirmish_dismiss( &ref->multi.builtin.lock );
return DR_OK;
}
DirectResult
fusion_shm_pool_reallocate( FusionSHMPoolShared *pool,
void *data,
int size,
bool lock,
void **ret_data )
{
DirectResult ret;
void *new_data;
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p, %d, %p )\n",
__FUNCTION__, pool, data, size, ret_data );
D_MAGIC_ASSERT( pool, FusionSHMPoolShared );
D_ASSERT( data != NULL );
D_ASSERT( data >= pool->addr_base );
D_ASSERT( data < pool->addr_base + pool->max_size );
D_ASSERT( size > 0 );
D_ASSERT( ret_data != NULL );
if (lock) {
ret = fusion_skirmish_prevail( &pool->lock );
if (ret)
return ret;
}
__shmalloc_brk( pool->heap, 0 );
new_data = _fusion_shrealloc( pool->heap, data, size );
if (!new_data) {
if (lock)
fusion_skirmish_dismiss( &pool->lock );
return DR_NOSHAREDMEMORY;
}
*ret_data = new_data;
if (lock)
fusion_skirmish_dismiss( &pool->lock );
return DR_OK;
}
DirectResult
fusion_shm_pool_allocate( FusionSHMPoolShared *pool,
int size,
bool clear,
bool lock,
void **ret_data )
{
DirectResult ret;
void *data;
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %d, %sclear, %p )\n", __FUNCTION__,
pool, size, clear ? "" : "un", ret_data );
D_MAGIC_ASSERT( pool, FusionSHMPoolShared );
D_ASSERT( size > 0 );
D_ASSERT( ret_data != NULL );
if (lock) {
ret = fusion_skirmish_prevail( &pool->lock );
if (ret)
return ret;
}
__shmalloc_brk( pool->heap, 0 );
data = _fusion_shmalloc( pool->heap, size );
if (!data) {
if (lock)
fusion_skirmish_dismiss( &pool->lock );
return DR_NOSHAREDMEMORY;
}
if (clear)
memset( data, 0, size );
*ret_data = data;
if (lock)
fusion_skirmish_dismiss( &pool->lock );
return DR_OK;
}
static void *
prevail_dismiss_loop( void *arg )
{
FusionSkirmish *skirmish = (FusionSkirmish *) arg;
BENCH_LOOP() {
fusion_skirmish_prevail( skirmish );
fusion_skirmish_dismiss( skirmish );
}
return NULL;
}
DFBResult
dfb_clipboard_get( DFBClipboardCore *core,
char **mime_type,
void **data,
unsigned int *size )
{
DFBClipboardCoreShared *shared;
D_MAGIC_ASSERT( core, DFBClipboardCore );
shared = core->shared;
D_MAGIC_ASSERT( shared, DFBClipboardCoreShared );
if (fusion_skirmish_prevail( &shared->lock ))
return DFB_FUSION;
if (!shared->mime_type || !shared->data) {
fusion_skirmish_dismiss( &shared->lock );
return DFB_BUFFEREMPTY;
}
if (mime_type)
*mime_type = strdup( shared->mime_type );
if (data) {
*data = malloc( shared->size );
direct_memcpy( *data, shared->data, shared->size );
}
if (size)
*size = shared->size;
fusion_skirmish_dismiss( &shared->lock );
return DFB_OK;
}
static DFBResult
sh7722RemoveRegion( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data )
{
int n;
SH7722DriverData *sdrv = driver_data;
SH7722DeviceData *sdev = sdrv->dev;
SH7722LayerData *slay = layer_data;
D_DEBUG_AT( SH7722_Layer, "%s()\n", __FUNCTION__ );
D_ASSERT( sdev != NULL );
D_ASSERT( slay != NULL );
n = slay->layer - SH7722_LAYER_INPUT1;
D_ASSERT( n >= 0 );
D_ASSERT( n <= 2 );
fusion_skirmish_prevail( &sdev->beu_lock );
sdev->input_mask &= ~(1 << n);
/* libshbeu: reorder src surfaces and start blending. */
if (sdev->input_mask) {
struct shbeu_surface * src[3] = {NULL, NULL, NULL};
int nr_surfaces = 0;
if (sdev->input_mask & 1) {
src[nr_surfaces] = &sdev->shbeu_src[0];
nr_surfaces++;
}
if (sdev->input_mask & 2) {
src[nr_surfaces] = &sdev->shbeu_src[1];
nr_surfaces++;
}
if (sdev->input_mask & 4) {
src[nr_surfaces] = &sdev->shbeu_src[2];
nr_surfaces++;
}
shbeu_blend(sdrv->shbeu, src[0], src[1], src[2], &sdev->shbeu_dest);
}
fusion_skirmish_dismiss( &sdev->beu_lock );
return DFB_OK;
}
/*
* Open the device, fill out information about it,
* allocate and fill private data, start input thread.
* Called during initialization, resuming or taking over mastership.
*/
static DFBResult
driver_open_device( CoreInputDevice *device,
unsigned int number,
InputDeviceInfo *info,
void **driver_data )
{
SDLInputData *data;
DFBSDL *dfb_sdl = dfb_system_data();
fusion_skirmish_prevail( &dfb_sdl->lock );
SDL_EnableUNICODE( true );
SDL_EnableKeyRepeat( 250, 40 );
fusion_skirmish_dismiss( &dfb_sdl->lock );
/* set device name */
snprintf( info->desc.name,
DFB_INPUT_DEVICE_DESC_NAME_LENGTH, "SDL Input" );
/* set device vendor */
snprintf( info->desc.vendor,
DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH, "SDL" );
/* set one of the primary input device IDs */
info->prefered_id = DIDID_KEYBOARD;
/* set type flags */
info->desc.type = DIDTF_JOYSTICK | DIDTF_KEYBOARD | DIDTF_MOUSE;
/* set capabilities */
info->desc.caps = DICAPS_ALL;
/* allocate and fill private data */
data = D_CALLOC( 1, sizeof(SDLInputData) );
data->device = device;
data->dfb_sdl = dfb_sdl;
/* start input thread */
data->thread = direct_thread_create( DTT_INPUT, sdlEventThread, data, "SDL Input" );
/* set private data pointer */
*driver_data = data;
return DFB_OK;
}