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

voiddfb_init(int argc, char *argv[]){     DFBCHECK(DirectFBInit( &argc, &argv ));     /* quiet option is no longer supported in DFB 1.2 */     /* DFBCHECK(DirectFBSetOption ("quiet", "")); */     /* create the super interface */     DFBCHECK(DirectFBCreate( &dfb ));     dfb->SetCooperativeLevel(dfb, DFSCL_FULLSCREEN);     DFBCHECK(dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer ));     layer->GetConfiguration (layer, &layer_config);     /* get the primary surface, i.e. the surface of the primary layer we have	exclusive access to */     memset( &dsc, 0, sizeof(DFBSurfaceDescription) );          dsc.flags = 	DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;     dsc.width = layer_config.width;     dsc.height = layer_config.height;     dsc.caps = DSCAPS_PRIMARY | DSCAPS_SYSTEMONLY /*| DSCAPS_FLIPPING */;     /* FIXME */     dsc.pixelformat = DSPF_RGB16;     DFBCHECK(dfb->CreateSurface(dfb, &dsc, &primary ));     primary->GetSize (primary, &opt.client.width, &opt.client.height);     DFBCHECK(dfb->GetInputDevice( dfb, DIDID_KEYBOARD, &keyboard ));     DFBCHECK(dfb->GetInputDevice( dfb, DIDID_MOUSE, &mouse ));     DFBCHECK (dfb->CreateInputEventBuffer (dfb, DICAPS_ALL, DFB_TRUE, &input_buffer));}

int dfb_init(int argc, char** argv, unsigned short width, unsigned short height) {	DFBCHECK(DirectFBInit (&argc, &argv));	DFBCHECK(DirectFBCreate (&DFBC_INTERFACE_));	DFBCHECK(DFBC_INTERFACE_->SetCooperativeLevel (DFBC_INTERFACE_, DFSCL_FULLSCREEN));	DFBC_ESCAPECTRL_ = DIKS_UP;	DFBC_SURFACE_DESC_.flags = DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT;	DFBC_SURFACE_DESC_.height = height;	DFBC_SURFACE_DESC_.width = width;	DFBC_SURFACE_DESC_.caps  = DSCAPS_PRIMARY | DSCAPS_FLIPPING;	DFBCHECK(DFBC_INTERFACE_->CreateSurface(DFBC_INTERFACE_, &DFBC_SURFACE_DESC_, &DFBC_SURFACE_));	DFBCHECK(DFBC_SURFACE_->GetSize (DFBC_SURFACE_, &DFB_SCREENW, &DFB_SCREENH));	//Hide the cursor	DFBC_INTERFACE_->GetDisplayLayer(DFBC_INTERFACE_, 0x00, &DFBC_LAYER_);	DFBC_LAYER_->SetCooperativeLevel(DFBC_LAYER_, DLSCL_ADMINISTRATIVE);	DFBC_LAYER_->SetCursorOpacity(DFBC_LAYER_, 0);	/*	 * TO-DO	 * Return code	 */	return 0;}

intmain( int argc, char** argv ){     IDirectFB      *dfb     = NULL;      ISaWMan        *saw     = NULL;      ISaWManManager *manager = NULL;      D_INFO( "SaWMan/Sample1: Initializing.../n" );     CHECK( DirectFBInit( &argc, &argv ) );     CHECK( DirectFBCreate( &dfb ) );     CHECK( SaWManCreate( &saw ) );     CHECK( saw->CreateManager( saw, &callbacks, NULL, &manager ) );     pause();out:     D_INFO( "SaWMan/Sample1: Shutting down.../n" );     if (manager)          manager->Release( manager );     if (saw)          saw->Release( saw );     if (dfb)          dfb->Release( dfb );     return 0;}

int directfb_init(int argc, char *argv[]){    DFBSurfaceDescription dsc;    DFBFontDescription font_dsc;    DFBCHECK (DirectFBInit (&argc, &argv));    DFBCHECK (DirectFBCreate (&dfb));    DFBCHECK (dfb->SetCooperativeLevel (dfb, DFSCL_NORMAL));    dsc.flags = DSDESC_CAPS | DSDESC_PIXELFORMAT;    dsc.caps  = DSCAPS_PRIMARY | DSCAPS_INTERLACED | DSCAPS_FLIPPING;     dsc.pixelformat = DSPF_YUY2;    DFBCHECK (dfb->CreateSurface( dfb, &dsc, &primary ));    DFBCHECK (primary->GetSize (primary, &screen_width, &screen_height));    font_dsc.flags = DFDESC_HEIGHT;    font_dsc.height = 48;    DFBCHECK (dfb->CreateFont (dfb, "Vera.ttf", &font_dsc, &font));    DFBCHECK (primary->SetFont(primary, font));    /* Blank screen */    DFBCHECK (primary->SetColor (primary, 0x0, 0x0, 0x0, 0xFF));    DFBCHECK (primary->FillRectangle (primary, 0, 0, screen_width, screen_height));    /* Print text */    DFBCHECK (primary->SetColor (primary, 0x80, 0x0, 0x20, 0xFF));    DFBCHECK (primary->DrawString (primary, title, -1, 10, screen_height-100, DSTF_LEFT));    /* Flip the front and back buffer, but wait for the vertical retrace to avoid tearing. */    DFBCHECK (primary->Flip (primary, NULL, DSFLIP_WAITFORSYNC));    font->Release (font);    return 23;}

// Prepare things before the very first graphic renderingBoolean v4pDisplayInit(int quality, Boolean fullscreen) {   int rc = success;      /* Get screen size from display structure macro */   int wantedWidth = defaultScreenWidth * 2 / (3 - quality);   int wantedHeight = defaultScreenHeight * 2 / (3 - quality);   int argc = 0;   char *argv[] = {"directFB"};   DirectFBInit(&argc, &argv);   DirectFBCreate(&dfb);   if (fullscreen) {	   dfb->SetCooperativeLevel (dfb, DFSCL_FULLSCREEN);	}   DFBSurfaceDescription dsc;   /* dsc.flags = DSDESC_CAPS|DSDESC_WIDTH|DSDESC_HEIGHT; */   dsc.flags = DSDESC_CAPS;   dsc.caps  = DSCAPS_PRIMARY /* | DSCAPS_FLIPPING */;   dsc.width = wantedWidth;   dsc.height = wantedHeight;      dfb->CreateSurface( dfb, &dsc, &v4pDisplayDefaultContextS.surface);   v4pDisplayDefaultContextS.surface->GetSize (                     v4pDisplayDefaultContextS.surface,                     &v4pDisplayDefaultContextS.width,                     &v4pDisplayDefaultContextS.height);    v4pDisplaySetContext(v4pDisplayDefaultContext);      return rc;}

DirectFBFrame *createWindowFrame(const char *inTitle, int inWidth, int inHeight, unsigned int inFlags){   putenv ((char*)"DFBARGS=system=x11");      DirectFBInit(0, NULL);   DirectFBCreate(&dfb);      bool fullscreen = (inFlags & wfFullScreen) != 0;   if (fullscreen)   {      dfb->SetCooperativeLevel(dfb, DFSCL_FULLSCREEN);   }   else   {      //dfb->SetCooperativeLevel(dfb, DFSCL_NORMAL);      dfb->SetCooperativeLevel(dfb, DFSCL_FULLSCREEN);   }      dfb->SetVideoMode(dfb, inWidth, inHeight, 32);   dfb->CreateInputEventBuffer(dfb, (DFBInputDeviceCapabilities)(DICAPS_KEYS | DICAPS_BUTTONS), DFB_FALSE, &sgEventBuffer);      DFBSurfaceDescription dsc;   dsc.flags = DSDESC_CAPS;   dsc.caps = (DFBSurfaceCapabilities)(DSCAPS_PRIMARY | DSCAPS_FLIPPING);   dsc.width = inWidth;   dsc.height = inHeight;      IDirectFBSurface *surface = NULL;   dfb->CreateSurface(dfb, &dsc, &surface);      return new DirectFBFrame(surface, inWidth, inHeight);}

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;     int             i;     VoodooPlayInfo  info;     VoodooPlayer   *player = NULL;     /* Initialize DirectFB including command line parsing. */     ret = DirectFBInit( &argc, &argv );     if (ret) {          DirectFBError( "DirectFBInit() failed", ret );          return -1;     }     /* Parse the command line. */     if (!parse_command_line( argc, argv ))          return -2;     if (m_name) {          direct_snputs( info.name, m_name, VOODOO_PLAYER_NAME_LENGTH );     }     ret = voodoo_player_create( m_name ? &info : NULL, &player );     if (ret) {          D_ERROR( "Voodoo/Play: Could not create the player (%s)!/n", DirectFBErrorString(ret) );          goto out;     }     do {          voodoo_player_broadcast( player );          direct_thread_sleep( 100000 );          voodoo_player_enumerate( player, player_callback, NULL );          if (m_lookup) {               for (i=1; i<argc; i++) {                    char buf[100];                    if (voodoo_player_lookup( player, (const u8 *)argv[i], NULL, buf, sizeof(buf) )) {                         D_ERROR( "Voodoo/Play: No '%s' found!/n", argv[i] );                         continue;                    }                    D_INFO( "Voodoo/Play: Found '%s' with address %s/n", argv[i], buf );               }          }          direct_thread_sleep( 2000000 );     } while (m_run);out:     if (player)          voodoo_player_destroy( player );     return ret;}

g_error directfb_init(void) {   DFBResult err;   DFBSurfaceDescription dsc;   err = DirectFBInit(NULL, NULL); /* no argc/argv */   dfb_errcheck_die;   err = DirectFBCreate (&directfb);   dfb_errcheck_die;   //directfb->SetCooperativeLevel (directfb, DFSCL_FULLSCREEN);   dsc.flags = DSDESC_CAPS;   dsc.caps  = DSCAPS_PRIMARY | DSCAPS_FLIPPING;   err = directfb->CreateSurface(directfb, &dsc, &primary);   dfb_errcheck_die;   err = primary->GetSize (primary, &vid->xres, &vid->yres);   dfb_errcheck_die;   vid->display = NULL;   // FIXME   if (!vid->bpp) vid->bpp = 32;#ifdef DRIVER_DIRECTFBINPUT   /* Load a main input driver */   return load_inlib(&directfbinput_regfunc,&inlib_main);#else   return success;#endif}

int testing_multicore() {    IDirectFB *dfb = NULL;    IDirectFBSurface *surface = NULL;    DFBSurfaceDescription dsc;    pid_t n_pid = fork();    if (n_pid) {        sleep(1);    }    DFBCHECK(DirectFBInit(NULL, NULL));    DFBCHECK(DirectFBCreate(&dfb));    push_release(dfb, dfb->Release);    DFBCHECK(dfb->SetCooperativeLevel (dfb, DFSCL_FULLSCREEN));    dsc.flags = DSDESC_CAPS;    dsc.caps  = DSCAPS_PRIMARY | DSCAPS_FLIPPING;    DFBCHECK (dfb->CreateSurface( dfb, &dsc, &surface ));    push_release(surface, surface->Release);    if (!n_pid) {        sleep(1);    }    sleep(2);    //DFBCHECK(surface->Release(surface));    //DFBCHECK(dfb->Release(dfb));    release_all();    if (n_pid) {        wait(NULL);    }    return 0;}

int main(int, char **){    DFBResult result = DFB_OK;    result = DirectFBInit(0, 0);    return (result == DFB_OK);}

int get_display_layer_window() {    IDirectFB *dfb = NULL;    IDirectFBDisplayLayer   *layer   = NULL;    IDirectFBWindow         *window  = NULL;    DFBWindowDescription desc;    DFBCHECK(DirectFBInit(NULL, NULL));    DFBCHECK(DirectFBCreate(&dfb));    push_release(dfb,dfb->Release);    DFBCHECK(dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &layer));    push_release(layer, layer->Release);    desc.flags = DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_POSX | DWDESC_POSY;    desc.posx = desc.posy = desc.width = desc.height = 20;        DFBCHECK(layer->CreateWindow(layer, &desc, &window));    push_release(window, window->Release);    /* check window */    release_all();    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;}

/** Opens application window and return pointer to offscreen buffer for  */char *directfbapp_open_window() {    DFBWindowDescription wdesc;    DFBDisplayLayerConfig lconfig;    static char *argv_array[] = {        "CVM",        "--dfb:system=FBDev"            ",force-windowed"   /* use windows instead of surfaces */            ",no-vt-switch"     /* do not switch between Linux' VT */            ",no-cursor"        /* do not use pointer */            // ",no-deinit-check" /* do not check for deinit */        ,NULL    };    int argc = sizeof argv_array / sizeof argv_array[0] - 1;    char **argv = argv_array;    IDirectFBDisplayLayer *dlayer;    char *dst;    int pitch;    unsigned int win_id;    int win_x, win_y;    DFBCHECK(DirectFBInit(&argc, &argv));    DFBCHECK(DirectFBCreate(&dfb));    DFBCHECK(dfb->SetCooperativeLevel(dfb, DFSCL_NORMAL));    DFBCHECK(dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &dlayer));    DFBCHECK(dlayer->GetConfiguration(dlayer, &lconfig));    wdesc.caps = DWCAPS_DOUBLEBUFFER;    wdesc.surface_caps = DSCAPS_DOUBLE;    wdesc.pixelformat = DSPF_RGB16;    wdesc.width = CHAM_WIDTH;    wdesc.height = CHAM_HEIGHT;    wdesc.flags = DWDESC_CAPS | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_PIXELFORMAT |        DWDESC_SURFACE_CAPS;    DFBCHECK(dlayer->CreateWindow(dlayer, &wdesc, &window));    releaseInterface(dlayer);    if ((lconfig.flags & (DLCONF_WIDTH | DLCONF_HEIGHT)) == (DLCONF_WIDTH | DLCONF_HEIGHT)) {        DFBCHECK(window->GetID(window, &win_id));        set_win_position(win_id, lconfig.width, lconfig.height, win_x, win_y);        DFBCHECK(window->MoveTo(window, win_x, win_y));    }    DFBCHECK(window->RaiseToTop(window));    DFBCHECK(window->SetOpacity(window, 0xff));    DFBCHECK(window->RequestFocus(window));    DFBCHECK(window->GetSurface(window, &screen));    DFBCHECK(screen->GetSize(screen, &screen_width, &screen_height));    DFBCHECK(screen->Lock(screen, DSLF_WRITE, (void**)(void*)&dst, &pitch));    if (pitch != (int)sizeof(gxj_pixel_type) * screen_width) {        REPORT_ERROR(LC_LOWUI,            "Invalid pixel format: Supports only 16-bit, 5:6:5 display");        goto dfb_err;    }    return dst;dfb_err:;    directfbapp_finalize();    exit(1); /* TODO: exit from Java */    /* return NULL; */}

int main(int argc, char* argv[]){	int status;	pthread_t thread;	freerdp* instance;	dfContext* context;	rdpChannels* channels;	struct thread_data* data;	setlocale(LC_ALL, "");	freerdp_channels_global_init();	g_sem = CreateSemaphore(NULL, 0, 1, NULL);	instance = freerdp_new();	instance->PreConnect = df_pre_connect;	instance->PostConnect = df_post_connect;	instance->VerifyCertificate = df_verify_certificate;	instance->ReceiveChannelData = df_receive_channel_data;	instance->ContextSize = sizeof(dfContext);	instance->ContextNew = df_context_new;	instance->ContextFree = df_context_free;	freerdp_context_new(instance);	context = (dfContext*) instance->context;	channels = instance->context->channels;	DirectFBInit(&argc, &argv);	instance->context->argc = argc;	instance->context->argv = argv;	status = freerdp_client_parse_command_line_arguments(argc, argv, instance->settings);	if (status < 0)		exit(0);	freerdp_client_load_addins(instance->context->channels, instance->settings);	data = (struct thread_data*) malloc(sizeof(struct thread_data));	ZeroMemory(data, sizeof(sizeof(struct thread_data)));	data->instance = instance;	g_thread_count++;	pthread_create(&thread, 0, thread_func, data);	while (g_thread_count > 0)	{		WaitForSingleObject(g_sem, INFINITE);	}	freerdp_channels_global_uninit();	return 0;}

int init_n_close() {    IDirectFB *dfb = NULL;    DFBCHECK(DirectFBInit(NULL, NULL));    DFBCHECK(DirectFBCreate(&dfb));    push_release(dfb, dfb->Release);    release_all();    return 0;}

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

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

void Renderer::initialize(int argc, char **argv, NMTSettings * nmtSettings){  if (DirectFBInit(&argc, &argv) != DFB_OK) {    fprintf(stderr, "Error in DirectFBInit!/n");  }  else {    BOOST_ASSERT(nmtSettings != NULL);    m_videoMode = nmtSettings->getVideoMode();    init();  }}

intmain( int argc, char *argv[] ){     DFBResult ret;     Reaction  reaction;     /* Initialize DirectFB including command line parsing. */     ret = DirectFBInit( &argc, &argv );     if (ret) {          DirectFBError( "DirectFBInit() failed", ret );          return -1;     }     /* Parse the command line. */     if (!parse_command_line( argc, argv ))          return -2;     /* Create the super interface. */     ret = DirectFBCreate( &dfb );     if (ret) {          DirectFBError( "DirectFBCreate() failed", ret );          return -3;     }     if (!unique_wm_running()) {          D_ERROR( "UniQuE/Test: This session doesn't run UniQuE!/n" );          dfb->Release( dfb );          return EXIT_FAILURE;     }     unique_wm_enum_contexts( context_callback, NULL );     if (!context) {          D_ERROR( "UniQuE/Test: No context available!/n" );          dfb->Release( dfb );          return EXIT_FAILURE;     }     unique_input_channel_attach( context->foo_channel, foo_channel_listener, context, &reaction );     pause();     unique_input_channel_detach( context->foo_channel, &reaction );     unique_context_unref( context );     /* Release the super interface. */     dfb->Release( dfb );     return EXIT_SUCCESS;}

bool wxApp::Initialize(int& argc, wxChar **argv){    if ( !wxAppBase::Initialize(argc, argv) )        return false;    if ( !wxDfbCheckReturn(DirectFBInit(&argc, &argv)) )        return false;    if ( !wxIDirectFB::Get() )        return false;    return true;}

intmain( int argc, char *argv[] ){     DirectResult ret;     /* Initialize DirectFB. */     ret = DirectFBInit( &argc, &argv );     if (ret)          return DirectFBError( "DirectFBInit()", ret );     dfb_system_lookup();     ret = fusion_enter( -1, 0, FER_MASTER, &world );     if (ret)          return DirectFBError( "fusion_enter()", ret );     printf( "/n" );#if FUSION_BUILD_MULTI     printf( "Fusion Benchmark (Multi Application Core)/n" );#else     printf( "Fusion Benchmark (Single Application Core)/n" );#endif     printf( "/n" );     bench_flock();     bench_mutex();     bench_mutex_threaded();     bench_skirmish();     bench_skirmish_threaded();     //bench_spinlock_threaded();     bench_property();     bench_ref();     bench_reactor();     bench_shmpool( false );     bench_shmpool( true );     printf( "/n" );     fusion_exit( world, false );     return 0;}

intmain( int argc, char *argv[] ){     DFBResult ret;     /* Initialize DirectFB including command line parsing. */     ret = DirectFBInit( &argc, &argv );     if (ret) {          DirectFBError( "DirectFBInit() failed", ret );          return -1;     }     /* Parse the command line. */     if (!parse_command_line( argc, argv ))          return -2;     /* Create the super interface. */     ret = DirectFBCreate( &dfb );     if (ret) {          DirectFBError( "DirectFBCreate() failed", ret );          return -3;     }     if (!prophecy_wm_running()) {          D_ERROR( "Prophecy/Test: This session doesn't run Prophecy!/n" );          dfb->Release( dfb );          return EXIT_FAILURE;     }     prophecy_wm_enum_contexts( context_callback, NULL );     if (!context) {          D_ERROR( "Prophecy/Test: No context available!/n" );          dfb->Release( dfb );          return EXIT_FAILURE;     }     /* Set the background according to the users wishes. */     if (color)          set_color();     prophecy_context_unref( context );     /* Release the super interface. */     dfb->Release( dfb );     return EXIT_SUCCESS;}

int main(int argc, char* argv[]){	pthread_t thread;	freerdp* instance;	dfContext* context;	rdpChannels* channels;	struct thread_data* data;	setlocale(LC_ALL, "");	freerdp_channels_global_init();	g_sem = freerdp_sem_new(1);	instance = freerdp_new();	instance->PreConnect = df_pre_connect;	instance->PostConnect = df_post_connect;	instance->VerifyCertificate = df_verify_certificate;	instance->ReceiveChannelData = df_receive_channel_data;	instance->context_size = sizeof(dfContext);	instance->ContextNew = df_context_new;	instance->ContextFree = df_context_free;	freerdp_context_new(instance);	context = (dfContext*) instance->context;	channels = instance->context->channels;	DirectFBInit(&argc, &argv);	freerdp_parse_args(instance->settings, argc, argv, df_process_plugin_args, channels, NULL, NULL);	data = (struct thread_data*) xzalloc(sizeof(struct thread_data));	data->instance = instance;	g_thread_count++;	pthread_create(&thread, 0, thread_func, data);	while (g_thread_count > 0)	{                freerdp_sem_wait(g_sem);	}	freerdp_channels_global_uninit();	return 0;}

int get_display_layer() {    IDirectFB *dfb = NULL;    IDirectFBDisplayLayer   *layer   = NULL;    DFBCHECK(DirectFBInit(NULL, NULL));    DFBCHECK(DirectFBCreate(&dfb));    push_release(dfb, dfb->Release);    DFBCHECK(dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &layer));    push_release(layer, layer->Release);    release_all();    return 0;}

int open_display(int w, int h){	DirectFBInit(NULL, NULL);	DirectFBCreate( &dfb );	width = w;	height = h;	dfb->SetCooperativeLevel(dfb, DFSCL_EXCLUSIVE);	dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &layer);	layer->GetSurface(layer, &surface);	return 0;}

Eina_Boolengine_directfb_args(const char *engine, int width, int height){   Evas_Engine_Info_DirectFB *einfo;   DFBWindowDescription desc;   int i;   evas_output_method_set(evas, evas_render_method_lookup("directfb"));   einfo = (Evas_Engine_Info_DirectFB *)evas_engine_info_get(evas);   if (!einfo)     {	printf("Evas does not support the DirectFB Engine/n");	return EINA_FALSE;     }   DFBCHECK(DirectFBInit(NULL, NULL));   DFBCHECK(DirectFBCreate(&_dfb));   DFBCHECK(_dfb->GetDisplayLayer(_dfb, DLID_PRIMARY, &_layer));   DFBCHECK(_dfb->CreateEventBuffer(_dfb, &_window_event));   DFBCHECK(_dfb->CreateInputEventBuffer(_dfb, DICAPS_ALL, DFB_FALSE, &_input_event));   memset(&desc, 0, sizeof(DFBWindowDescription));   desc.flags = (DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_PIXELFORMAT);   desc.posx = 0;   desc.posy = 0;   desc.width = width;   desc.height = height;   desc.pixelformat = DSPF_ARGB;   DFBCHECK(_layer->CreateWindow(_layer, &desc, &_dfb_window));   DFBCHECK(_dfb_window->AttachEventBuffer(_dfb_window, _window_event));   DFBCHECK(_dfb_window->SetOptions(_dfb_window, DWOP_NONE));   DFBCHECK(_dfb_window->SetOpacity(_dfb_window, 0xFF));   DFBCHECK(_dfb_window->GetSurface(_dfb_window, &_dfb_surface));   DFBCHECK(_dfb_surface->SetPorterDuff(_dfb_surface, DSPD_SRC_OVER));   einfo->info.dfb = _dfb;   einfo->info.surface = _dfb_surface;   if (!evas_engine_info_set(evas, (Evas_Engine_Info *) einfo))     {	printf("Evas can not setup the informations of the DirectFB Engine/n");	return EINA_FALSE;     }   return EINA_TRUE;}

static voidinit_application( int *argc, char **argv[] ){     DFBResult             ret;     DFBSurfaceDescription desc;     /* Initialize DirectFB including command line parsing. */     ret = DirectFBInit( argc, argv );     if (ret) {          DirectFBError( "DirectFBInit() failed", ret );          exit_application( 1 );     }     /* Create the super interface. */     ret = DirectFBCreate( &dfb );     if (ret) {          DirectFBError( "DirectFBCreate() failed", ret );          exit_application( 2 );     }     /* Request fullscreen mode. */     dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN );     /* Fill the surface description. */     desc.flags       = DSDESC_CAPS | DSDESC_PIXELFORMAT;     desc.caps        = DSCAPS_PRIMARY | DSCAPS_DOUBLE;     desc.pixelformat = DSPF_ARGB;          /* Create an 8 bit palette surface. */     ret = dfb->CreateSurface( dfb, &desc, &primary );     if (ret) {          DirectFBError( "IDirectFB::CreateSurface() failed", ret );          exit_application( 3 );     }          /* Create an event buffer with key capable devices attached. */     ret = dfb->CreateInputEventBuffer( dfb, DICAPS_KEYS, DFB_FALSE, &events );     if (ret) {          DirectFBError( "IDirectFB::CreateEventBuffer() failed", ret );          exit_application( 4 );     }          /* Clear with black. */     primary->Clear( primary, 0x00, 0x00, 0x00, 0xff );     primary->Flip( primary, NULL, 0 );}

intmain( int argc, char *argv[] ){     DFBResult ret;     Inspector inspector;     ret = DirectFBInit( &argc, &argv );     if (ret) {          D_DERROR( ret, "Inspector/Init: DirectFBInit() failed!/n" );          return ret;     }     ret = Inspector_Init( &inspector, argc, argv );     if (ret)          return ret;               return Inspector_Run( &inspector );}