static DFBResult
dfb_colorhash_core_initialize( CoreDFB *core,
DFBColorHashCore *data,
DFBColorHashCoreShared *shared )
{
D_DEBUG_AT( Core_ColorHash, "dfb_colorhash_core_initialize( %p, %p, %p )\n", core, data, shared );
D_ASSERT( data != NULL );
D_ASSERT( shared != NULL );
core_colorhash = data; /* FIXME */
data->core = core;
data->shared = shared;
data->hash = D_CALLOC( HASH_SIZE, sizeof (Colorhash) );
if (!data->hash)
return D_OOM();
direct_mutex_init( &data->hash_lock );
D_MAGIC_SET( data, DFBColorHashCore );
D_MAGIC_SET( shared, DFBColorHashCoreShared );
return DFB_OK;
}
static DFBResult
mesaInitPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data,
CoreSurfacePoolDescription *ret_desc )
{
MesaPoolData *data = pool_data;
MesaPoolLocalData *local = pool_local;
MesaData *mesa = system_data;
D_DEBUG_AT( Mesa_Surfaces, "%s()\n", __FUNCTION__ );
D_ASSERT( core != NULL );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_ASSERT( data != NULL );
D_ASSERT( local != NULL );
D_ASSERT( mesa != NULL );
D_ASSERT( mesa->shared != NULL );
D_ASSERT( ret_desc != NULL );
ret_desc->caps = CSPCAPS_VIRTUAL;
// ret_desc->access[CSAID_CPU] = CSAF_READ | CSAF_WRITE | CSAF_SHARED;
ret_desc->access[CSAID_GPU] = CSAF_READ | CSAF_WRITE | CSAF_SHARED;
ret_desc->access[CSAID_ACCEL1] = CSAF_READ | CSAF_WRITE | CSAF_SHARED;
ret_desc->types = CSTF_LAYER | CSTF_WINDOW | CSTF_CURSOR | CSTF_FONT | CSTF_SHARED | CSTF_EXTERNAL;
ret_desc->priority = CSPP_DEFAULT;
ret_desc->size = dfb_config->video_length;
/* For hardware layers */
ret_desc->access[CSAID_LAYER0] = CSAF_READ;
ret_desc->access[CSAID_LAYER1] = CSAF_READ;
ret_desc->access[CSAID_LAYER2] = CSAF_READ;
ret_desc->access[CSAID_LAYER3] = CSAF_READ;
ret_desc->access[CSAID_LAYER4] = CSAF_READ;
ret_desc->access[CSAID_LAYER5] = CSAF_READ;
ret_desc->access[CSAID_LAYER6] = CSAF_READ;
ret_desc->access[CSAID_LAYER7] = CSAF_READ;
ret_desc->access[CSAID_LAYER8] = CSAF_READ;
ret_desc->access[CSAID_LAYER9] = CSAF_READ;
ret_desc->access[CSAID_LAYER10] = CSAF_READ;
ret_desc->access[CSAID_LAYER11] = CSAF_READ;
ret_desc->access[CSAID_LAYER12] = CSAF_READ;
ret_desc->access[CSAID_LAYER13] = CSAF_READ;
ret_desc->access[CSAID_LAYER14] = CSAF_READ;
ret_desc->access[CSAID_LAYER15] = CSAF_READ;
snprintf( ret_desc->name, DFB_SURFACE_POOL_DESC_NAME_LENGTH, "Mesa" );
local->mesa = mesa;
D_MAGIC_SET( data, MesaPoolData );
D_MAGIC_SET( local, MesaPoolLocalData );
return DFB_OK;
}
static DFBResult
osdJoinPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data )
{
OSDPoolData *data = pool_data;
OSDPoolLocalData *local = pool_local;
DavinciDriverData *ddrv = dfb_gfxcard_get_driver_data();
DavinciDeviceData *ddev = dfb_gfxcard_get_device_data();
D_DEBUG_AT( OSD_Surfaces, "%s()\n", __FUNCTION__ );
D_ASSERT( core != NULL );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_MAGIC_ASSERT( data, OSDPoolData );
D_ASSERT( local != NULL );
(void) data;
local->core = core;
local->mem = ddrv->fb[OSD0].mem;
local->phys = ddev->fix[OSD0].smem_start;
D_MAGIC_SET( local, OSDPoolLocalData );
return DFB_OK;
}
static DFBResult
devmemJoinPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data )
{
DevMemPoolData *data = pool_data;
DevMemPoolLocalData *local = pool_local;
DevMemData *devmem = system_data;
D_DEBUG_AT( DevMem_Surfaces, "%s()\n", __FUNCTION__ );
D_ASSERT( core != NULL );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_MAGIC_ASSERT( data, DevMemPoolData );
D_ASSERT( local != NULL );
D_ASSERT( devmem != NULL );
D_ASSERT( devmem->shared != NULL );
(void) data;
local->core = core;
local->mem = devmem->mem;
D_MAGIC_SET( local, DevMemPoolLocalData );
return DFB_OK;
}
static DFBResult
sh7722AddRegion( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreLayerRegionConfig *config )
{
int n;
SH7722MultiRegionData *sreg = region_data;
SH7722MultiLayerData *slay = layer_data;
D_DEBUG_AT( SH7722_Layer, "%s()\n", __FUNCTION__ );
if (slay->added == 0xF)
return DFB_LIMITEXCEEDED;
for (n=0; n<4; n++)
if (! (slay->added & (1 << n)))
break;
D_ASSERT( n < 4 );
sreg->config = *config;
slay->added |= 1 << n;
D_MAGIC_SET( sreg, SH7722MultiRegionData );
return DFB_OK;
}
CoreFont *
dfb_font_create( CoreDFB *core )
{
CoreFont *font;
font = (CoreFont *) D_CALLOC( 1, sizeof(CoreFont) );
font->core = core;
direct_util_recursive_pthread_mutex_init( &font->lock );
/* the proposed pixel_format, may be changed by the font provider */
font->pixel_format = dfb_config->font_format ? : DSPF_A8;
/* the state used to blit the glyphs, may be changed by the font
provider */
dfb_state_init( &font->state );
font->state.blittingflags = DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_COLORIZE;
font->glyph_infos = direct_tree_new();
D_MAGIC_SET( font, CoreFont );
return font;
}
DFBResult
ImageProviderDispatch_Create( IDirectFB *idirectfb,
IDirectFBDataBuffer *buffer,
IDirectFBImageProvider *provider,
ImageProviderDispatch **ret_dispatch )
{
ImageProviderDispatch *dispatch;
dispatch = (ImageProviderDispatch*) D_CALLOC( 1, sizeof(ImageProviderDispatch) );
if (!dispatch)
return (DFBResult) D_OOM();
dispatch->idirectfb = idirectfb;
dispatch->buffer = buffer;
dispatch->provider = provider;
ImageProvider_Init_Dispatch( core_dfb, dispatch, &dispatch->call );
fusion_call_add_permissions( &dispatch->call, Core_GetIdentity(), FUSION_CALL_PERMIT_EXECUTE );
Core_Resource_AddCleanup( Core_GetIdentity(), ImageProviderDispatch_cleanup, dispatch, NULL, &dispatch->cleanup );
D_MAGIC_SET( dispatch, ImageProviderDispatch );
*ret_dispatch = dispatch;
return DFB_OK;
}
int
OneTarget_New( OneTarget_InitFunc Init,
void *ctx,
size_t data_size,
OneTarget **ret_target )
{
int ret;
OneTarget *target;
ONE_DEBUG( "%s()\n", __FUNCTION__ );
target = one_core_malloc( one_core, sizeof(OneTarget) + data_size );
if (!target)
return -ENOMEM;
memset( target, 0, sizeof(OneTarget) + data_size );
target->data = target + 1;
ret = Init( target, ctx );
if (ret) {
one_core_free( one_core, target );
return ret;
}
D_MAGIC_SET( target, OneTarget );
*ret_target = target;
return 0;
}
DirectThreadInitHandler *
direct_thread_add_init_handler( DirectThreadInitFunc func,
void *arg )
{
DirectThreadInitHandler *handler;
handler = D_CALLOC( 1, sizeof(DirectThreadInitHandler) );
if (!handler) {
D_WARN( "out of memory" );
return NULL;
}
handler->func = func;
handler->arg = arg;
D_MAGIC_SET( handler, DirectThreadInitHandler );
pthread_mutex_lock( &handler_lock );
direct_list_append( &handlers, &handler->link );
pthread_mutex_unlock( &handler_lock );
return handler;
}
DirectThread *
direct_thread_self( void )
{
DirectThread *thread;
direct_once( &thread_init_once, init_once );
thread = pthread_getspecific( thread_key );
// D_MAGIC_ASSERT_IF( thread, DirectThread );
/* Support this function for non-direct threads. */
if (!thread) {
// D_DEBUG_AT( Direct_Thread, " -> attaching unknown thread %d\n", direct_gettid() );
thread = direct_calloc( 1, sizeof(DirectThread) );
if (!thread) {
D_OOM();
return NULL;
}
thread->handle.thread = pthread_self();
thread->tid = direct_gettid();
D_MAGIC_SET( thread, DirectThread );
pthread_setspecific( thread_key, thread );
}
return thread;
}
static DFBResult
stmfbdevJoinPool (CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data)
{
STMfbdevPoolData * const data = pool_data;
STMfbdevPoolLocalData * const local = pool_local;
STMfbdev * const stmfbdev = dfb_system_data ();
D_DEBUG_AT (STMfbdev_Surfaces, "%s()\n", __FUNCTION__);
D_ASSERT (core != NULL);
D_MAGIC_ASSERT (pool, CoreSurfacePool);
D_MAGIC_ASSERT (data, STMfbdevPoolData);
D_ASSERT (local != NULL);
D_MAGIC_ASSERT (stmfbdev, STMfbdev);
(void) data;
D_MAGIC_SET (local, STMfbdevPoolLocalData);
local->mem = stmfbdev->framebuffer_base;
D_ASSERT (local->mem != NULL);
local->core = core;
return DFB_OK;
}
static Chunk* split_chunk( Chunk *c, int length )
{
Chunk *newchunk;
D_MAGIC_ASSERT( c, _Chunk_ );
if (c->length == length) /* does not need be splitted */
return c;
newchunk = (Chunk*) SHCALLOC( 1, sizeof(Chunk) );
/* calculate offsets and lengths of resulting chunks */
newchunk->offset = c->offset + c->length - length;
newchunk->length = length;
c->length -= newchunk->length;
/* insert newchunk after chunk c */
newchunk->prev = c;
newchunk->next = c->next;
if (c->next)
c->next->prev = newchunk;
c->next = newchunk;
D_MAGIC_SET( newchunk, _Chunk_ );
return newchunk;
}
static CallTLS *
Call_GetTLS( FusionWorld *world )
{
CallTLS *call_tls;
call_tls = direct_tls_get( call_tls_key );
if (!call_tls) {
call_tls = D_CALLOC( 1, sizeof(CallTLS) + sizeof(FusionCallExecute3) * fusion_config->call_bin_max_num + fusion_config->call_bin_max_data );
if (!call_tls) {
D_OOM();
return NULL;
}
DirectThread *self = direct_thread_self();
if (self)
call_tls->dispatcher = fusion_dispatcher_tid( world ) == direct_thread_get_tid( self );
call_tls->world = world;
call_tls->bins = (FusionCallExecute3*) (call_tls + 1);
call_tls->bins_data = (char*) (call_tls->bins + fusion_config->call_bin_max_num);
D_MAGIC_SET( call_tls, CallTLS );
direct_tls_set( call_tls_key, call_tls );
}
D_MAGIC_ASSERT( call_tls, CallTLS );
return call_tls;
}
DirectResult
direct_signal_handler_add( int num,
DirectSignalHandlerFunc func,
void *ctx,
DirectSignalHandler **ret_handler )
{
DirectSignalHandler *handler;
D_ASSERT( func != NULL );
D_ASSERT( ret_handler != NULL );
D_DEBUG_AT( Direct_Signals,
"Adding handler %p for signal %d with context %p...\n", func, num, ctx );
handler = D_CALLOC( 1, sizeof(DirectSignalHandler) );
if (!handler) {
D_WARN( "out of memory" );
return DR_NOLOCALMEMORY;
}
handler->num = num;
handler->func = func;
handler->ctx = ctx;
D_MAGIC_SET( handler, DirectSignalHandler );
direct_mutex_lock( &handlers_lock );
direct_list_append( &handlers, &handler->link );
direct_mutex_unlock( &handlers_lock );
*ret_handler = handler;
return DR_OK;
}
DirectResult
fusion_shm_pool_create( FusionWorld *world,
const char *name,
unsigned int max_size,
bool debug,
FusionSHMPoolShared **ret_pool )
{
FusionSHMPoolShared *pool;
#if !DIRECT_BUILD_DEBUGS
debug = false;
#endif
pool = D_CALLOC( 1, sizeof(FusionSHMPoolShared) );
if (!pool)
return D_OOM();
pool->debug = debug;
D_MAGIC_SET( pool, FusionSHMPoolShared );
*ret_pool = pool;
return DR_OK;
}
static DFBResult
fbdevJoinPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data )
{
FBDevPoolData *data = pool_data;
FBDevPoolLocalData *local = pool_local;
D_DEBUG_AT( FBDev_Surfaces, "%s()\n", __FUNCTION__ );
D_ASSERT( core != NULL );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_MAGIC_ASSERT( data, FBDevPoolData );
D_ASSERT( local != NULL );
(void) data;
local->core = core;
D_MAGIC_SET( local, FBDevPoolLocalData );
return DFB_OK;
}
DFBResult
unique_decoration_create( UniqueWindow *window,
UniqueDecorationFlags flags,
UniqueDecoration **ret_decoration )
{
DFBResult ret;
UniqueDecoration *decoration;
UniqueContext *context;
D_ASSERT( window != NULL );
D_ASSERT( D_FLAGS_ARE_IN( flags, UDF_ALL ) );
D_ASSERT( ret_decoration != NULL );
context = window->context;
D_MAGIC_ASSERT( context, UniqueContext );
/* Create a decoration object. */
decoration = unique_wm_create_decoration();
if (!decoration)
return DFB_FUSION;
/* Initialize deocration data. */
decoration->flags = flags;
ret = unique_window_link( &decoration->window, window );
if (ret)
goto error;
ret = unique_context_link( &decoration->context, window->context );
if (ret)
goto error;
D_MAGIC_SET( decoration, UniqueDecoration );
/* Change global reaction lock. */
fusion_object_set_lock( &decoration->object, &context->stack->context->lock );
/* activate object */
fusion_object_activate( &decoration->object );
/* return the new decoration */
*ret_decoration = decoration;
return DFB_OK;
error:
if (decoration->context)
unique_context_unlink( &decoration->context );
if (decoration->window)
unique_window_unlink( &decoration->window );
fusion_object_destroy( &decoration->object );
return ret;
}
DFBResult
CoreGraphicsStateClient_Init( CoreGraphicsStateClient *client,
CardState *state )
{
DFBResult ret;
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p, state %p )\n", __FUNCTION__, client, state );
D_ASSERT( client != NULL );
D_MAGIC_ASSERT( state, CardState );
D_MAGIC_ASSERT( state->core, CoreDFB );
client->magic = 0;
client->core = state->core;
client->state = state;
ret = CoreDFB_CreateState( state->core, &client->gfx_state );
if (ret)
return ret;
D_MAGIC_SET( client, CoreGraphicsStateClient );
client_list.AddClient( client );
return DFB_OK;
}
static DFBResult
mesaJoinPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data )
{
MesaPoolData *data = pool_data;
MesaPoolLocalData *local = pool_local;
MesaData *mesa = system_data;
D_DEBUG_AT( Mesa_Surfaces, "%s()\n", __FUNCTION__ );
D_ASSERT( core != NULL );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_MAGIC_ASSERT( data, MesaPoolData );
D_ASSERT( local != NULL );
D_ASSERT( mesa != NULL );
D_ASSERT( mesa->shared != NULL );
(void) data;
local->mesa = mesa;
D_MAGIC_SET( local, MesaPoolLocalData );
return DFB_OK;
}
void *
direct_processor_allocate( DirectProcessor *processor )
{
ProcessorCommand *command;
D_MAGIC_ASSERT( processor, DirectProcessor );
D_DEBUG_AT( Direct_Processor_Alloc, "%s( %p '%s' )\n", __FUNCTION__, processor, processor->name );
command = direct_fifo_pop( &processor->recycled );
if (command) {
D_MAGIC_ASSERT( command, ProcessorCommand );
}
else {
command = D_CALLOC( 1, sizeof(ProcessorCommand) + processor->data_size );
if (!command) {
D_OOM();
return NULL;
}
D_MAGIC_SET( command, ProcessorCommand );
}
D_DEBUG_AT( Direct_Processor_Alloc, " -> %p - %p\n", command, command + 1 );
return command + 1;
}
static DFBResult
localAllocateBuffer( CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
CoreSurfaceBuffer *buffer,
CoreSurfaceAllocation *allocation,
void *alloc_data )
{
CoreSurface *surface;
LocalAllocationData *alloc = alloc_data;
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
D_ASSERT( alloc != NULL );
surface = buffer->surface;
D_MAGIC_ASSERT( surface, CoreSurface );
#ifndef ANDROID_NDK
/* Create aligned local system surface buffer if both base address and pitch are non-zero. */
if (dfb_config->system_surface_align_base && dfb_config->system_surface_align_pitch) {
/* Make sure base address and pitch are a positive power of two. */
D_ASSERT( dfb_config->system_surface_align_base >= 4 );
D_ASSERT( !(dfb_config->system_surface_align_base & (dfb_config->system_surface_align_base-1)) );
D_ASSERT( dfb_config->system_surface_align_pitch >= 2 );
D_ASSERT( !(dfb_config->system_surface_align_pitch & (dfb_config->system_surface_align_pitch-1)) );
dfb_surface_calc_buffer_size( surface, dfb_config->system_surface_align_pitch, 0,
&alloc->pitch, &alloc->size );
/* Note: The posix_memalign function requires base alignment to actually be at least four. */
int tempRet = posix_memalign( &alloc->addr, dfb_config->system_surface_align_base, alloc->size );
if ( tempRet != 0 ) {
D_ERROR( "Local surface pool: Error from posix_memalign:%d with base alignment value:%d. "
"%s()-%s:%d\n",
tempRet, dfb_config->system_surface_align_base,
__FUNCTION__, __FILE__, __LINE__ );
return DFB_FAILURE;
}
}
else {
#endif
/* Create un-aligned local system surface buffer. */
dfb_surface_calc_buffer_size( surface, 8, 0, &alloc->pitch, &alloc->size );
alloc->addr = D_MALLOC( alloc->size );
if (!alloc->addr)
return D_OOM();
#ifndef ANDROID_NDK
}
#endif
D_MAGIC_SET( alloc, LocalAllocationData );
allocation->flags = CSALF_VOLATILE;
allocation->size = alloc->size;
return DFB_OK;
}
VoodooInstance::VoodooInstance()
:
magic(0),
refs(1)
{
D_DEBUG_AT( Voodoo_Instance, "VoodooInstance::%s( %p )\n", __func__, this );
D_MAGIC_SET( this, VoodooInstance );
}
static DFBResult
wm_add_window( CoreWindowStack *stack,
void *wm_data,
void *stack_data,
CoreWindow *window,
void *window_data )
{
DFBResult ret;
StackData *sdata = stack_data;
WindowData *data = window_data;
WMData *wmdata = wm_data;
D_ASSERT( stack != NULL );
D_ASSERT( wm_data != NULL );
D_ASSERT( stack_data != NULL );
D_ASSERT( window != NULL );
D_ASSERT( window_data != NULL );
D_MAGIC_ASSERT( sdata, StackData );
D_MAGIC_ASSERT( sdata->context, UniqueContext );
data->context = sdata->context;
/* Create the unique window. */
ret = unique_window_create( wmdata->core, window, data->context,
window->caps, &window->config, &data->window );
if (ret) {
D_DERROR( ret, "WM/UniQuE: Could not create window!\n" );
return ret;
}
/* Attach the global window listener. */
ret = unique_window_attach_global( data->window,
UNIQUE_WM_MODULE_WINDOW_LISTENER,
data, &data->window_reaction );
if (ret) {
unique_window_unref( data->window );
D_DERROR( ret, "WM/UniQuE: Could not attach global window listener!\n" );
return ret;
}
/* Inherit all local references from the layer window. */
ret = unique_window_inherit( data->window, window );
unique_window_unref( data->window );
if (ret) {
unique_window_detach_global( data->window, &data->window_reaction );
D_DERROR( ret, "WM/UniQuE: Could not inherit from core window!\n" );
return ret;
}
unique_window_get_config( data->window, &window->config );
D_MAGIC_SET( data, WindowData );
return DFB_OK;
}
static DFBResult
fbdevInitPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data,
CoreSurfacePoolDescription *ret_desc )
{
DFBResult ret;
FBDevPoolData *data = pool_data;
FBDevPoolLocalData *local = pool_local;
D_DEBUG_AT( FBDev_Surfaces, "%s()\n", __FUNCTION__ );
D_ASSERT( core != NULL );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_ASSERT( data != NULL );
D_ASSERT( local != NULL );
D_ASSERT( ret_desc != NULL );
ret = dfb_surfacemanager_create( core, dfb_fbdev->shared->fix.smem_len, &data->manager );
if (ret)
return ret;
ret_desc->caps = CSPCAPS_NONE;
ret_desc->access = CSAF_CPU_READ | CSAF_CPU_WRITE | CSAF_GPU_READ | CSAF_GPU_WRITE | CSAF_SHARED;
ret_desc->types = CSTF_LAYER | CSTF_WINDOW | CSTF_CURSOR | CSTF_FONT | CSTF_SHARED | CSTF_EXTERNAL;
ret_desc->priority = CSPP_DEFAULT;
snprintf( ret_desc->name, DFB_SURFACE_POOL_DESC_NAME_LENGTH, "Frame Buffer Memory" );
local->core = core;
D_MAGIC_SET( data, FBDevPoolData );
D_MAGIC_SET( local, FBDevPoolLocalData );
D_ASSERT( dfb_fbdev != NULL );
D_ASSERT( dfb_fbdev->shared != NULL );
dfb_fbdev->shared->manager = data->manager;
return DFB_OK;
}
VoodooConnection::VoodooConnection( VoodooLink *link )
:
magic(0),
manager(NULL),
link(link)
{
D_DEBUG_AT( Voodoo_Connection, "VoodooConnection::%s( %p )\n", __func__, this );
D_MAGIC_SET( this, VoodooConnection );
}
static void
init_fallback_log( void )
{
fallback_log.type = DLT_STDERR;
fallback_log.fd = fileno( stderr );
direct_util_recursive_pthread_mutex_init( &fallback_log.lock );
D_MAGIC_SET( &fallback_log, DirectLog );
}
static int
dfb_core_arena_initialize( FusionArena *arena,
void *ctx )
{
DFBResult ret;
CoreDFB *core = ctx;
CoreDFBShared *shared;
FusionSHMPoolShared *pool;
D_MAGIC_ASSERT( core, CoreDFB );
D_DEBUG_AT( DirectFB_Core, "Initializing...\n" );
/* Create the shared memory pool first! */
ret = fusion_shm_pool_create( core->world, "DirectFB Main Pool", 0x400000,
fusion_config->debugshm, &pool );
if (ret)
return ret;
/* Allocate shared structure in the new pool. */
shared = SHCALLOC( pool, 1, sizeof(CoreDFBShared) );
if (!shared) {
fusion_shm_pool_destroy( core->world, pool );
return D_OOSHM();
}
core->shared = shared;
core->master = true;
shared->shmpool = pool;
D_MAGIC_SET( shared, CoreDFBShared );
/* Initialize. */
ret = dfb_core_initialize( core );
if (ret) {
D_MAGIC_CLEAR( shared );
SHFREE( pool, shared );
fusion_shm_pool_destroy( core->world, pool );
return ret;
}
fusion_skirmish_init( &shared->lock, "DirectFB Core", core->world );
CoreDFB_Init_Dispatch( core, core, &shared->call );
fusion_call_add_permissions( &shared->call, 0, FUSION_CALL_PERMIT_EXECUTE );
/* Register shared data. */
fusion_arena_add_shared_field( arena, "Core/Shared", shared );
return DFB_OK;
}
static DFBResult
dfb_clipboard_core_initialize( CoreDFB *core,
DFBClipboardCore *data,
DFBClipboardCoreShared *shared )
{
D_DEBUG_AT( Core_Clipboard, "dfb_clipboard_core_initialize( %p, %p, %p )\n", core, data, shared );
D_ASSERT( data != NULL );
D_ASSERT( shared != NULL );
data->core = core;
data->shared = shared;
shared->shmpool = dfb_core_shmpool( core );
fusion_skirmish_init( &shared->lock, "Clipboard Core", dfb_core_world(core) );
D_MAGIC_SET( data, DFBClipboardCore );
D_MAGIC_SET( shared, DFBClipboardCoreShared );
return DFB_OK;
}
void
direct_thread_set_name( const char *name )
{
char *copy;
DirectThread *thread = pthread_getspecific( thread_key );
D_DEBUG_AT( Direct_Thread, "%s( '%s' )\n", __FUNCTION__, name );
/* Support this function for non-direct threads. */
if (!thread) {
D_DEBUG_AT( Direct_Thread, " -> attaching unknown thread %d\n", direct_gettid() );
/* Create the key for the TSD (thread specific data). */
pthread_mutex_lock( &key_lock );
if (thread_key == -1)
pthread_key_create( &thread_key, NULL );
pthread_mutex_unlock( &key_lock );
thread = D_CALLOC( 1, sizeof(DirectThread) );
if (!thread) {
D_OOM();
return;
}
thread->thread = pthread_self();
thread->tid = direct_gettid();
D_MAGIC_SET( thread, DirectThread );
pthread_setspecific( thread_key, thread );
}
else
D_DEBUG_AT( Direct_Thread, " -> was '%s' (%d)\n", thread->name, direct_gettid() );
/* Duplicate string. */
copy = D_STRDUP( name );
if (!copy) {
D_OOM();
return;
}
/* Free old string. */
if (thread->name)
D_FREE( thread->name );
/* Keep the copy. */
thread->name = copy;
}
SurfaceManager *
dfb_surfacemanager_create( unsigned int length,
CardLimitations *limits )
{
Chunk *chunk;
SurfaceManager *manager;
manager = SHCALLOC( 1, sizeof(SurfaceManager) );
if (!manager)
return NULL;
chunk = SHCALLOC( 1, sizeof(Chunk) );
if (!chunk) {
SHFREE( manager );
return NULL;
}
chunk->offset = 0;
chunk->length = length;
manager->chunks = chunk;
manager->length = length;
manager->available = length;
manager->byteoffset_align = limits->surface_byteoffset_alignment;
manager->pixelpitch_align = limits->surface_pixelpitch_alignment;
manager->bytepitch_align = limits->surface_bytepitch_alignment;
manager->max_power_of_two_pixelpitch = limits->surface_max_power_of_two_pixelpitch;
manager->max_power_of_two_bytepitch = limits->surface_max_power_of_two_bytepitch;
manager->max_power_of_two_height = limits->surface_max_power_of_two_height;
fusion_skirmish_init( &manager->lock, "Surface Manager" );
D_MAGIC_SET( chunk, _Chunk_ );
D_MAGIC_SET( manager, SurfaceManager );
return manager;
}
