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

intmain( int argc, char *argv[] ){     DFBResult  ret;     IDirectFB *dfb;     /* Initialize DirectFB. */     ret = DirectFBInit( &argc, &argv );     if (ret) {          D_DERROR( ret, "DFBTest/Init: DirectFBInit() failed!/n" );          return ret;     }     /* Create super interface. */     ret = DirectFBCreate( &dfb );     if (ret) {          D_DERROR( ret, "DFBTest/Init: DirectFBCreate() failed!/n" );          return ret;     }     /* Shutdown DirectFB. */     ret = dfb->Release( dfb );     if (ret) {          D_DERROR( ret, "DFBTest/Init: IDirectFB::Release() failed!/n" );          return ret;     }     return 0;}

intmain( int argc, char *argv[] ){     DFBResult  ret;     IDirectFB *dfb;     /* Initialize DirectFB. */     ret = DirectFBInit( &argc, &argv );     if (ret) {          D_DERROR( ret, "DFBTest/Resize: DirectFBInit() failed!/n" );          return ret;     }     /* Create super interface. */     ret = DirectFBCreate( &dfb );     if (ret) {          D_DERROR( ret, "DFBTest/Resize: DirectFBCreate() failed!/n" );          return ret;     }     /* Required for keyboard access */     dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN );     TestResize( dfb );     /* Shutdown DirectFB. */     dfb->Release( dfb );     return ret;}

static DFBResultTest_Clipboard_Get( IDirectFB *dfb ){     DFBResult       ret;     struct timeval  tv;     char           *mime_type;     void           *data;     unsigned int    data_size;     ret = dfb->GetClipboardTimeStamp( dfb, &tv );     if (ret) {          D_DERROR( ret, "DFBTest/Clipboard: IDirectFB::GetClipboardTimeStamp() failed!/n" );          return ret;     }     ret = dfb->GetClipboardData( dfb, &mime_type, &data, &data_size );     if (ret) {          D_DERROR( ret, "DFBTest/Clipboard: IDirectFB::GetClipboardData() failed!/n" );          return ret;     }     direct_log_printf( NULL, "Got clipboard data of mime type '%s' with data '%s'/n", mime_type, (const char*) data );     direct_log_printf( NULL, "Got clipboard timestamp %ld.%06ld/n", tv.tv_sec, tv.tv_usec );     return ret;}

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

DFBResultILayer_Requestor::GetPrimaryContext(                    bool                                       activate,                    CoreLayerContext                         **ret_context){    DFBResult           ret = DFB_OK;    CoreLayerContext *context = NULL;    char        args_static[FLUXED_ARGS_BYTES];    char        return_args_static[FLUXED_ARGS_BYTES];    CoreLayerGetPrimaryContext       *args = (CoreLayerGetPrimaryContext*) args_alloc( args_static, sizeof(CoreLayerGetPrimaryContext) );    CoreLayerGetPrimaryContextReturn *return_args;    if (!args)        return (DFBResult) D_OOM();    return_args = (CoreLayerGetPrimaryContextReturn*) args_alloc( return_args_static, sizeof(CoreLayerGetPrimaryContextReturn) );    if (!return_args) {        args_free( args_static, args );        return (DFBResult) D_OOM();    }    D_DEBUG_AT( DirectFB_CoreLayer, "ILayer_Requestor::%s()/n", __FUNCTION__ );    D_ASSERT( ret_context != NULL );    args->activate = activate;    ret = (DFBResult) CoreLayer_Call( obj, FCEF_NONE, CoreLayer_GetPrimaryContext, args, sizeof(CoreLayerGetPrimaryContext), return_args, sizeof(CoreLayerGetPrimaryContextReturn), NULL );    if (ret) {        D_DERROR( ret, "%s: CoreLayer_Call( CoreLayer_GetPrimaryContext ) failed!/n", __FUNCTION__ );        goto out;    }    if (return_args->result) {        /*D_DERROR( return_args->result, "%s: CoreLayer_GetPrimaryContext failed!/n", __FUNCTION__ );*/        ret = return_args->result;        goto out;    }    ret = (DFBResult) CoreLayerContext_Catch( core, return_args->context_ptr, &context );    if (ret) {         D_DERROR( ret, "%s: Catching context by ID %u failed!/n", __FUNCTION__, return_args->context_id );         goto out;    }    *ret_context = context;out:    args_free( return_args_static, return_args );    args_free( args_static, args );    return ret;}

intmain( int argc, char *argv[] ){     DFBResult         ret;     int               i;     IDirectFB        *dfb;     DFBInputDeviceID  device_id = 0;     /* Initialize DirectFB. */     ret = DirectFBInit( &argc, &argv );     if (ret) {          D_DERROR( ret, "DFBTest/Input: DirectFBInit() failed!/n" );          return ret;     }     /* Parse arguments. */     for (i=1; i<argc; i++) {          const char *arg = argv[i];          if (strcmp( arg, "-h" ) == 0 || strcmp (arg, "--help") == 0)               return print_usage( argv[0] );          else if (strcmp (arg, "-v") == 0 || strcmp (arg, "--version") == 0) {               fprintf (stderr, "dfbtest_input version %s/n", DIRECTFB_VERSION);               return false;          }          else if (strcmp (arg, "-d") == 0 || strcmp (arg, "--device") == 0) {               if (++i == argc) {                    print_usage (argv[0]);                    return false;               }               if (!parse_id( argv[i], &device_id ))                    return false;          }          else               return print_usage( argv[0] );     }     /* Create super interface. */     ret = DirectFBCreate( &dfb );     if (ret) {          D_DERROR( ret, "DFBTest/Input: DirectFBCreate() failed!/n" );          return ret;     }     Test_Sensitivity( dfb, device_id );     /* Shutdown DirectFB. */     ret = dfb->Release( dfb );     if (ret) {          D_DERROR( ret, "DFBTest/Input: IDirectFB::Release() failed!/n" );          return ret;     }     return 0;}

DFBResultICore_Requestor::GetSurface(                    u32                                        surface_id,                    CoreSurface                              **ret_surface){    DFBResult           ret = DFB_OK;    CoreSurface *surface = NULL;    char        args_static[FLUXED_ARGS_BYTES];    char        return_args_static[FLUXED_ARGS_BYTES];    CoreDFBGetSurface       *args = (CoreDFBGetSurface*) args_alloc( args_static, sizeof(CoreDFBGetSurface) );    CoreDFBGetSurfaceReturn *return_args;    if (!args)        return (DFBResult) D_OOM();    return_args = (CoreDFBGetSurfaceReturn*) args_alloc( return_args_static, sizeof(CoreDFBGetSurfaceReturn) );    if (!return_args) {        args_free( args_static, args );        return (DFBResult) D_OOM();    }    D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()/n", __FUNCTION__ );    D_ASSERT( ret_surface != NULL );    args->surface_id = surface_id;    ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, CoreDFB_GetSurface, args, sizeof(CoreDFBGetSurface), return_args, sizeof(CoreDFBGetSurfaceReturn), NULL );    if (ret) {        D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_GetSurface ) failed!/n", __FUNCTION__ );        goto out;    }    if (return_args->result) {        /*D_DERROR( return_args->result, "%s: CoreDFB_GetSurface failed!/n", __FUNCTION__ );*/        ret = return_args->result;        goto out;    }    ret = (DFBResult) CoreSurface_Catch( core, return_args->surface_ptr, &surface );    if (ret) {         D_DERROR( ret, "%s: Catching surface by ID %u failed!/n", __FUNCTION__, return_args->surface_id );         goto out;    }    *ret_surface = surface;out:    args_free( return_args_static, return_args );    args_free( args_static, args );    return ret;}

intmain( int argc, char *argv[] ){     int                    i;     DFBResult              ret;     IDirectFB             *dfb;     IDirectFBDisplayLayer *layer  = NULL;     App                    apps[1];     DFBDisplayLayerConfig  config;     /* Parse arguments. */     for (i=1; i<argc; i++) {          if (!strcmp( argv[i], "-h" ))               return show_usage( argv[0] );     }     /* Initialize DirectFB. */     ret = DirectFBInit( &argc, &argv );     if (ret) {          D_DERROR( ret, "DFBTest/WindowFlip: DirectFBInit() failed!/n" );          return ret;     }     /* Create super interface. */     ret = DirectFBCreate( &dfb );     if (ret) {          D_DERROR( ret, "DFBTest/WindowFlip: DirectFBCreate() failed!/n" );          return ret;     }     /* Get primary layer. */     ret = dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer );     if (ret) {          D_DERROR( ret, "DFBTest/WindowFlip: IDirectFB::GetDisplayLayer( PRIMARY ) failed!/n" );          goto out;     }          layer->GetConfiguration( layer, &config );     app_init( &apps[0], layer, 100, 50, config.width-300, config.height-150, 0 );     while (true) {          direct_thread_sleep( 1000000 );          app_update( &apps[0] );     }out:     /* Shutdown DirectFB. */     dfb->Release( dfb );     return ret;}

gfxDirectFBSurface::gfxDirectFBSurface(const gfxIntSize& size, gfxImageFormat format) :    mDFB(nsnull), mDFBSurface(nsnull){    DFBResult             ret;    DFBSurfaceDescription desc;    if (!CheckSurfaceSize(size) || size.width <= 0 || size.height <= 0)        return;    /* Lightweight, getting singleton */    ret = DirectFBCreate( &mDFB );    if (ret) {        D_DERROR( (DirectResult) ret, "gfxDirectFBSurface: DirectFBCreate() failed!/n" );        return;    }    desc.flags  = (DFBSurfaceDescriptionFlags)( DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT );    desc.width  = size.width;    desc.height = size.height;    switch (format) {    case gfxASurface::ImageFormatARGB32:        desc.pixelformat = DSPF_ARGB;        break;    case gfxASurface::ImageFormatRGB24:        desc.pixelformat = DSPF_RGB32;        break;    case gfxASurface::ImageFormatA8:        desc.pixelformat = DSPF_A8;        break;    case gfxASurface::ImageFormatA1:        desc.pixelformat = DSPF_A1;        break;    default:        D_BUG( "unknown format" );        return;    }    ret = mDFB->CreateSurface( mDFB, &desc, &mDFBSurface );    if (ret) {        D_DERROR( (DirectResult) ret, "gfxDirectFBSurface: "                  "IDirectFB::CreateSurface( %dx%d ) failed!/n", desc.width, desc.height );        return;    }    cairo_surface_t *surface = cairo_directfb_surface_create(mDFB, mDFBSurface);    Init(surface);}

static void *TestThread( DirectThread *thread,            void         *arg ){     DFBResult         ret;     IDirectFBSurface *surface = arg;     DFBRectangle      rect    = { 0, 0, 500, 1 };     while (!quit) {          void *data;          int   pitch;          ret = surface->Lock( surface, DSLF_WRITE, &data, &pitch );          if (ret) {               D_DERROR( ret, "DFBTest/Resize: Lock() failed!/n" );               return NULL;          }          if (!data) {               D_DERROR( ret, "DFBTest/Resize:invalid pointer!/n" );               return NULL;          }          memset( data, 0, pitch * 400 );          surface->Unlock( surface );          data = malloc( pitch );          ret = surface->Read( surface, &rect, data, pitch );          if (ret) {               D_DERROR( ret, "DFBTest/Resize: Read() failed!/n" );               free (data);               return NULL;          }          ret = surface->Write( surface, &rect, data, pitch );          if (ret) {               D_DERROR( ret, "DFBTest/Resize: Write() failed!/n" );               free(data);               return NULL;          }          free(data);     }     return NULL;}

DFBResultDaleDFB::showOSK(const Rectangle& rect, TextInputMode mode){    ILOG_TRACE_F(ILX_DALEDFB);    if (getOSKComp() == DFB_FAILURE)        return DFB_FAILURE;    OSKRequest request;    request.inputRect = rect.dfbRect();    request.mode = mode;    request.process = getpid();    void *ptr;    __coma->GetLocal(__coma, sizeof(OSKRequest), &ptr);    OSKRequest* req = (OSKRequest*) ptr;    *req = request;    int ret_val;    DirectResult ret = __oskComp->Call(__oskComp, 0, (void*) req, &ret_val);    if (ret)    {        D_DERROR(ret, "WebKit/DFB: %s() failed!/n", __FUNCTION__);        return (DFBResult) ret;    }    return DFB_OK;}

static DFBResultInitGL( Test *test ){     DFBResult ret;     /*       * Bind the OpenGL rendering context to our primary surface      */     ret = test->gl2context->Bind( test->gl2context, test->primary, test->primary );     if (ret) {          D_DERROR( ret, "IDirectFBGL2Context::Bind() failed!/n" );          return ret;     }     gears_init();     /* Update the projection matrix */     perspective(ProjectionMatrix, 60.0, test->size.w / (float)test->size.h, 1.0, 1024.0);     /* Setup the viewport */     glViewport( 0, 0, (GLint) test->size.w, (GLint) test->size.h );     /* Unbind the OpenGL rendering context */     test->gl2context->Unbind( test->gl2context );     return DFB_OK;}

EGLintSurface::SwapBuffers(){     D_DEBUG_AT( DFBEGL_Surface, "EGL::Surface::%s( %p )/n", __FUNCTION__, this );     if (surface == NULL) {          D_DEBUG_AT( DFBEGL_Surface, "  -> NO SURFACE/n" );          return EGL_BAD_SURFACE;     }     if (gfx_peer) {          DFBResult ret;          ret = gfx_peer->Flip( NULL, DSFLIP_NONE );          if (ret) {               D_DERROR( ret, "DFBEGL/Display: Graphics::SurfacePeer::Flip() failed!/n" );               return EGL_BAD_SURFACE;          }     }     else          D_DEBUG_AT( DFBEGL_Surface, "  -> NO PEER/n" );     Dispatch< Surface::SwapBuffersFunc >( "SwapBuffers", this );     return EGL_SUCCESS;}

static DFBResultx11JoinPool( CoreDFB                    *core,             CoreSurfacePool            *pool,             void                       *pool_data,             void                       *pool_local,             void                       *system_data ){     DFBResult         ret;     x11PoolLocalData *local = pool_local;     DFBX11           *x11   = system_data;     D_DEBUG_AT( X11_Surfaces, "%s()/n", __FUNCTION__ );     D_MAGIC_ASSERT( pool, CoreSurfacePool );     local->x11 = x11;     ret = direct_hash_create( 7, &local->hash );     if (ret) {          D_DERROR( ret, "X11/Surfaces: Could not create local hash table!/n" );          return ret;     }     pthread_mutex_init( &local->lock, NULL );     return DFB_OK;}

DFBResultIInputDevice_Requestor__ReloadKeymap( CoreInputDevice *obj){    DFBResult           ret;    CoreInputDeviceReloadKeymap       *args = (CoreInputDeviceReloadKeymap*) alloca( sizeof(CoreInputDeviceReloadKeymap) );    CoreInputDeviceReloadKeymapReturn *return_args = (CoreInputDeviceReloadKeymapReturn*) alloca( sizeof(CoreInputDeviceReloadKeymapReturn) );    D_DEBUG_AT( DirectFB_CoreInputDevice, "IInputDevice_Requestor::%s()/n", __FUNCTION__ );    ret = (DFBResult) CoreInputDevice_Call( obj, FCEF_NONE, _CoreInputDevice_ReloadKeymap, args, sizeof(CoreInputDeviceReloadKeymap), return_args, sizeof(CoreInputDeviceReloadKeymapReturn), NULL );    if (ret) {        D_DERROR( ret, "%s: CoreInputDevice_Call( CoreInputDevice_ReloadKeymap ) failed!/n", __FUNCTION__ );        return ret;    }    if (return_args->result) {         /*D_DERROR( return_args->result, "%s: CoreInputDevice_ReloadKeymap failed!/n", __FUNCTION__ );*/         return return_args->result;    }    return DFB_OK;}

voiddirect_processor_post( DirectProcessor *processor,                       void            *data ){     ProcessorCommand *command = (ProcessorCommand*) data - 1;     D_MAGIC_ASSERT( processor, DirectProcessor );     D_MAGIC_ASSERT( command, ProcessorCommand );     D_DEBUG_AT( Direct_Processor_Post, "%s( %p '%s' <---= %p )/n", __FUNCTION__, processor, processor->name, data );     if (processor->direct) {          DirectResult                ret;          const DirectProcessorFuncs *funcs;//          D_ASSUME( !processor->commands.count );          funcs = processor->funcs;          D_ASSERT( funcs != NULL );          D_ASSERT( funcs->Process != NULL );                    ret = funcs->Process( processor, data, processor->context );          if (ret)               D_DERROR( ret, "Direct/Processor: Processing directly failed! (%s)/n", processor->name );     }     else          direct_fifo_push( &processor->commands, &command->item );}

DFBResultICoreSlave_Requestor__PutData( CoreSlave *obj,                    void*                                      address,                    u32                                        bytes,                    const u8                                  *data){    DFBResult           ret;    CoreSlavePutData       *args = (CoreSlavePutData*) alloca( sizeof(CoreSlavePutData) + bytes * sizeof(u8) );    CoreSlavePutDataReturn *return_args = (CoreSlavePutDataReturn*) alloca( sizeof(CoreSlavePutDataReturn) );    D_DEBUG_AT( DirectFB_CoreSlave, "ICoreSlave_Requestor::%s()/n", __FUNCTION__ );    args->address = address;    args->bytes = bytes;    direct_memcpy( (char*) (args + 1), data, bytes * sizeof(u8) );    ret = (DFBResult) CoreSlave_Call( obj, FCEF_NONE, _CoreSlave_PutData, args, sizeof(CoreSlavePutData) + bytes * sizeof(u8), return_args, sizeof(CoreSlavePutDataReturn), NULL );    if (ret) {        D_DERROR( ret, "%s: CoreSlave_Call( CoreSlave_PutData ) failed!/n", __FUNCTION__ );        return ret;    }    if (return_args->result) {         /*D_DERROR( return_args->result, "%s: CoreSlave_PutData failed!/n", __FUNCTION__ );*/         return return_args->result;    }    return DFB_OK;}

DFBResultdfb_surface_init_palette( CoreDFB     *core,                          CoreSurface *surface ){     DFBResult    ret;     CorePalette *palette;     ret = dfb_palette_create( core,                               1 << DFB_COLOR_BITS_PER_PIXEL( surface->config.format ),                               &palette );     if (ret) {          D_DERROR( ret, "Core/Surface: Error creating palette!/n" );          return ret;     }     switch (surface->config.format) {          case DSPF_LUT8:               dfb_palette_generate_rgb332_map( palette );               break;          case DSPF_ALUT44:               dfb_palette_generate_rgb121_map( palette );               break;          default:               break;     }     dfb_surface_set_palette( surface, palette );     dfb_palette_unref( palette );     return DFB_OK;}

DFBResultIInputDevice_Requestor__SetKeymapEntry( CoreInputDevice *obj,                    s32                                        key_code,                    const DFBInputDeviceKeymapEntry           *entry){    DFBResult           ret;    CoreInputDeviceSetKeymapEntry       *args = (CoreInputDeviceSetKeymapEntry*) alloca( sizeof(CoreInputDeviceSetKeymapEntry) );    CoreInputDeviceSetKeymapEntryReturn *return_args = (CoreInputDeviceSetKeymapEntryReturn*) alloca( sizeof(CoreInputDeviceSetKeymapEntryReturn) );    D_DEBUG_AT( DirectFB_CoreInputDevice, "IInputDevice_Requestor::%s()/n", __FUNCTION__ );    D_ASSERT( entry != NULL );    args->key_code = key_code;    args->entry = *entry;    ret = (DFBResult) CoreInputDevice_Call( obj, FCEF_NONE, _CoreInputDevice_SetKeymapEntry, args, sizeof(CoreInputDeviceSetKeymapEntry), return_args, sizeof(CoreInputDeviceSetKeymapEntryReturn), NULL );    if (ret) {        D_DERROR( ret, "%s: CoreInputDevice_Call( CoreInputDevice_SetKeymapEntry ) failed!/n", __FUNCTION__ );        return ret;    }    if (return_args->result) {         /*D_DERROR( return_args->result, "%s: CoreInputDevice_SetKeymapEntry failed!/n", __FUNCTION__ );*/         return return_args->result;    }    return DFB_OK;}

static DirectResultRUN_create( int index ){    DirectResult      ret;    ComaTestInstance *instance;    char              buf[20];    snprintf( buf, sizeof(buf), "Tuner_%02d", index );    instance = D_CALLOC( 1, sizeof(ComaTestInstance) );    if (!instance)        return D_OOM();    ret = coma->CreateComponent( coma, buf, ComaTestMethodFunc,                                 0,                                 instance, &instance->component );    if (ret) {        D_DERROR( ret, "IComa::CreateComponent( '%s' ) failed!/n", buf );        return ret;    }    instance->component->Activate( instance->component );    return DR_OK;}

static voidset_color(){     DFBResult  ret;     char      *error;     u32        argb;     DFBColor   color;     if (*filename == '#')          filename++;     argb = strtoul( filename, &error, 16 );     if (*error) {          fprintf( stderr, "Invalid characters in color string: '%s'/n", error );          return;     }     color.a = (argb & 0xFF000000) >> 24;     color.r = (argb & 0xFF0000) >> 16;     color.g = (argb & 0xFF00) >> 8;     color.b = (argb & 0xFF);     ret = prophecy_context_set_color( context, &color );     if (ret)          D_DERROR( ret, "Prophecy/Test: prophecy_context_set_color() failed!/n" );}

static DFBResultunrealize_region( CoreLayerRegion *region ){     DFBResult                ret;     int                      index;     CoreLayer               *layer;     CoreLayerShared         *shared;     const DisplayLayerFuncs *funcs;     D_ASSERT( region != NULL );     D_ASSERT( region->context != NULL );     D_ASSERT( D_FLAGS_IS_SET( region->state, CLRSF_REALIZED ) );     layer = dfb_layer_at( region->context->layer_id );     D_ASSERT( layer != NULL );     D_ASSERT( layer->shared != NULL );     D_ASSERT( layer->funcs != NULL );     shared = layer->shared;     funcs  = layer->funcs;     D_ASSERT( fusion_vector_contains( &shared->added_regions, region ) );     index = fusion_vector_index_of( &shared->added_regions, region );     D_DEBUG_AT( Core_Layers, "Removing region (%d, %d - %dx%d) from '%s'./n",                 DFB_RECTANGLE_VALS( &region->config.dest ), shared->description.name );     /* Remove the region from hardware and driver. */     if (funcs->RemoveRegion) {          ret = funcs->RemoveRegion( layer, layer->driver_data,                                     layer->layer_data, region->region_data );          if (ret) {               D_DERROR( ret, "Core/Layers: Could not remove region!/n" );               return ret;          }     }     /* Remove the region from the 'added' list. */     fusion_vector_remove( &shared->added_regions, index );     /* Deallocate the driver's region data. */     if (region->region_data) {          SHFREE( shared->shmpool, region->region_data );          region->region_data = NULL;     }     /* Update the region's state. */     D_FLAGS_CLEAR( region->state, CLRSF_REALIZED );     D_FLAGS_SET( region->state, CLRSF_FROZEN );     if (region->surface && region->surface_lock.buffer) {          dfb_surface_unlock_buffer( region->surface, &region->surface_lock );          dfb_surface_destroy_buffers( region->surface );     }     return DFB_OK;}

DFBResultILayerRegion_Requestor::FlipUpdateStereo(                    const DFBRegion                           *left,                    const DFBRegion                           *right,                    DFBSurfaceFlipFlags                        flags){    DFBResult           ret = DFB_OK;    char        args_static[FLUXED_ARGS_BYTES];    char        return_args_static[FLUXED_ARGS_BYTES];    CoreLayerRegionFlipUpdateStereo       *args = (CoreLayerRegionFlipUpdateStereo*) args_alloc( args_static, sizeof(CoreLayerRegionFlipUpdateStereo) );    CoreLayerRegionFlipUpdateStereoReturn *return_args;    if (!args)        return (DFBResult) D_OOM();    return_args = (CoreLayerRegionFlipUpdateStereoReturn*) args_alloc( return_args_static, sizeof(CoreLayerRegionFlipUpdateStereoReturn) );    if (!return_args) {        args_free( args_static, args );        return (DFBResult) D_OOM();    }    D_DEBUG_AT( DirectFB_CoreLayerRegion, "ILayerRegion_Requestor::%s()/n", __FUNCTION__ );  if (left) {    args->left = *left;    args->left_set = true;  }  else    args->left_set = false;  if (right) {    args->right = *right;    args->right_set = true;  }  else    args->right_set = false;    args->flags = flags;    ret = (DFBResult) CoreLayerRegion_Call( obj, FCEF_NONE, CoreLayerRegion_FlipUpdateStereo, args, sizeof(CoreLayerRegionFlipUpdateStereo), return_args, sizeof(CoreLayerRegionFlipUpdateStereoReturn), NULL );    if (ret) {        D_DERROR( ret, "%s: CoreLayerRegion_Call( CoreLayerRegion_FlipUpdateStereo ) failed!/n", __FUNCTION__ );        goto out;    }    if (return_args->result) {        /*D_DERROR( return_args->result, "%s: CoreLayerRegion_FlipUpdateStereo failed!/n", __FUNCTION__ );*/        ret = return_args->result;        goto out;    }out:    args_free( return_args_static, return_args );    args_free( args_static, args );    return ret;}

static DFBResultinit_bridge( CoreDFB                      *core,             CoreSurfacePoolBridge        *bridge,             const SurfacePoolBridgeFuncs *funcs,             void                         *context ){     DFBResult ret;     D_MAGIC_ASSERT( bridge, CoreSurfacePoolBridge );     D_ASSERT( funcs != NULL );     D_ASSERT( funcs->InitPoolBridge != NULL );     D_DEBUG_AT( Core_SurfPoolBridge, "%s( %p, %p )/n", __FUNCTION__, bridge, funcs );     if (funcs->PoolBridgeDataSize)          bridge->bridge_data_size = funcs->PoolBridgeDataSize();     if (funcs->PoolBridgeLocalDataSize)          bridge->bridge_local_data_size = funcs->PoolBridgeLocalDataSize();     if (funcs->PoolTransferDataSize)          bridge->transfer_data_size = funcs->PoolTransferDataSize();     /* Allocate shared bridge data. */     if (bridge->bridge_data_size) {          bridge->data = SHCALLOC( bridge->shmpool, 1, bridge->bridge_data_size );          if (!bridge->data)               return D_OOSHM();     }     /* Allocate local bridge data. */     if (bridge->bridge_local_data_size &&         !(bridge_locals[bridge->bridge_id] = D_CALLOC( 1, bridge->bridge_local_data_size )))     {          SHFREE( bridge->shmpool, bridge->data );          return D_OOM();     }     ret = funcs->InitPoolBridge( core, bridge, bridge->data, get_local(bridge), context, &bridge->desc );     if (ret) {          D_DERROR( ret, "Core/SurfacePoolBridge: Initializing '%s' failed!/n", bridge->desc.name );          if (bridge_locals[bridge->bridge_id]) {               D_FREE( bridge_locals[bridge->bridge_id] );               bridge_locals[bridge->bridge_id] = NULL;          }          if (bridge->data) {               SHFREE( bridge->shmpool, bridge->data );               bridge->data = NULL;          }          return ret;     }     fusion_skirmish_init2( &bridge->lock, bridge->desc.name, dfb_core_world(core), fusion_config->secure_fusion );     return DFB_OK;}

static DirectResultRUN_call( int index ){    DirectResult    ret;    int             result;    IComaComponent *instance;    char            buf[20];    void           *ptr;    int             seed = 0;    snprintf( buf, sizeof(buf), "Tuner_%02d", index );    ret = coma->GetComponent( coma, buf, 99999, &instance );    if (ret) {        D_DERROR( ret, "IComa::GetComponent( '%s' ) failed!/n", buf );        return ret;    }    while (true) {        ret = coma->GetLocal( coma, sizeof(DataCall1), &ptr );        if (ret) {            D_DERROR( ret, "IComa::GetLocal( %zu ) failed!/n", sizeof(DataCall1) );        }        else {            int        i;            DataCall1 *data = ptr;            for (i=0; i<20; i++)                data->bytes[i] = seed + i;            ret = instance->Call( instance, COMA_TEST_CALL1, data, &result );            if (ret)                D_DERROR( ret, "IComaComponent::Call( COMA_TEST_CALL1 ) failed!/n" );            for (i=0; i<20; i++) {                if (data->bytes[i] != (seed + i) * 3)                    D_BUG( "byte %d being %d does not match %d", i, data->bytes[i], (seed + i) * 3 );            }        }    }    return DR_OK;}

intmain( int argc, char *argv[] ){     DFBResult  ret;     int        i;     IDirectFB *dfb;     /* Initialize DirectFB. */     ret = DirectFBInit( &argc, &argv );     if (ret) {          D_DERROR( ret, "DFBTest/Blit: DirectFBInit() failed!/n" );          return ret;     }     /* Parse arguments. */     for (i=1; i<argc; i++) {          const char *arg = argv[i];          if (strcmp( arg, "-h" ) == 0 || strcmp (arg, "--help") == 0)               return print_usage( argv[0] );          else if (strcmp (arg, "-v") == 0 || strcmp (arg, "--version") == 0) {               fprintf (stderr, "dfbtest_blit version %s/n", DIRECTFB_VERSION);               return false;          }          else               return print_usage( argv[0] );     }     /* Create super interface. */     ret = DirectFBCreate( &dfb );     if (ret) {          D_DERROR( ret, "DFBTest/Blit: DirectFBCreate() failed!/n" );          return ret;     }     Test_Clipboard_Set( dfb, "text/plain", "This is a test string for clipboard" );     Test_Clipboard_Get( dfb );     /* Shutdown DirectFB. */     dfb->Release( dfb );     return ret;}

static DFBResultregion_buffer_lock( CoreLayerRegion       *region,                    CoreSurface           *surface,                    CoreSurfaceBufferRole  role ){     DFBResult              ret;     CoreSurfaceBuffer     *buffer;     CoreSurfaceAllocation *allocation;     CoreLayerContext      *context;     D_ASSERT( region != NULL );     D_MAGIC_ASSERT( surface, CoreSurface );     context = region->context;     D_MAGIC_ASSERT( context, CoreLayerContext );     /* First unlock any previously locked buffer. */     if (region->surface_lock.buffer) {          D_MAGIC_ASSERT( region->surface_lock.buffer, CoreSurfaceBuffer );          dfb_surface_unlock_buffer( region->surface_lock.buffer->surface, &region->surface_lock );     }     if (dfb_surface_lock( surface ))          return DFB_FUSION;     buffer = dfb_surface_get_buffer( surface, role );     D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );     /* Lock the surface buffer. */     ret = dfb_surface_buffer_lock( buffer, CSAID_LAYER0 + context->layer_id, CSAF_READ, &region->surface_lock );     if (ret) {          D_DERROR( ret, "Core/LayerRegion: Could not lock region surface for SetRegion()!/n" );          dfb_surface_unlock( surface );          return ret;     }     allocation = region->surface_lock.allocation;     D_ASSERT( allocation != NULL );     /* If hardware has written or is writing... */     if (allocation->accessed[CSAID_GPU] & CSAF_WRITE) {          D_DEBUG_AT( Core_Layers, "  -> Waiting for pending writes.../n" );          /* ...wait for the operation to finish. */          dfb_gfxcard_sync(); /* TODO: wait for serial instead */          allocation->accessed[CSAID_GPU] &= ~CSAF_WRITE;     }     /* surface is unlocked by caller */     return DFB_OK;}