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