自学教程：C++ D_MAGIC_SET函数代码示例

static DFBResultdfb_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 DFBResultmesaInitPool( 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 DFBResultosdJoinPool( 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 DFBResultdevmemJoinPool( 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 DFBResultsh7722AddRegion( 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;}

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

intOneTarget_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 DFBResultstmfbdevJoinPool (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;}

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

DirectResultfusion_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 DFBResultfbdevJoinPool( 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;}

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

DFBResultCoreGraphicsStateClient_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 DFBResultmesaJoinPool( 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 DFBResultlocalAllocateBuffer( 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 DFBResultwm_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 DFBResultfbdevInitPool( 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 voidinit_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 intdfb_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 DFBResultdfb_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;}

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