static void
app_update( App *app )
{
static const DFBColor colors[3] = {
{ 0xff, 0x30, 0xc0, 0xff },
{ 0xff, 0xff, 0xff, 0x30 },
{ 0xff, 0x30, 0xff, 0xc0 }
};
IDirectFBSurface *surface = app->surface;
surface->Clear( surface, 0xff, 0xff, 0xff, 0x20 );
surface->SetColor( surface, colors[app->index].r, colors[app->index].g, colors[app->index].b, colors[app->index].a );
surface->FillRectangle( surface, app->anim_x, app->anim_y, 40, 300 );
surface->Flip( surface, NULL, DSFLIP_WAITFORSYNC );
app->anim_x += app->anim_dirx;
if (app->anim_x >= app->resolution.w - 40)
app->anim_dirx = -5;
else if (app->anim_x <= 0)
app->anim_dirx = 5;
app->anim_y += app->anim_diry;
if (app->anim_y >= app->resolution.h - 300)
app->anim_diry = -5;
else if (app->anim_y <= 0)
app->anim_diry = 5;
}
void DFBDeviceScreen::releaseSurface(void* sur) {
set<IDirectFBSurface*>::iterator i;
IDirectFBSurface* s;
s = (IDirectFBSurface*)sur;
pthread_mutex_lock(&surMutex);
if (surfacePool != NULL) {
i = surfacePool->find(s);
if (i != surfacePool->end()) {
surfacePool->erase(i);
pthread_mutex_unlock(&surMutex);
} else {
pthread_mutex_unlock(&surMutex);
}
} else {
pthread_mutex_unlock(&surMutex);
}
s->Clear(s, 0, 0, 0, 0);
s->Release(s);
s = NULL;
sur = NULL;
}
/* render callback */
virtual void Render( IDirectFBSurface &surface ) {
int x = ((int) surface.GetWidth() - (int) m_image.GetWidth()) / 2;
int y = ((int) surface.GetHeight() - (int) m_image.GetHeight()) / 2;
surface.Clear();
m_image.PrepareTarget( surface );
surface.Blit( m_image, NULL, x, y );
}
static mrb_value surface_clear(mrb_state *mrb, mrb_value self)
{
IDirectFBSurface* surface = mrb_directfb_surface(mrb, self);
DFBResult ret = -1;
if (surface != NULL) {
mrb_int r, g, b, a;
mrb_get_args(mrb, "iiii", &r, &g, &b, &a);
ret = surface->Clear(surface, r, g, b, a);
}
return mrb_fixnum_value(ret);
}
/* render callback */
virtual void Render( IDirectFBSurface &surface ) {
surface.Clear( 0, 0, 255, 255 );
surface.SetFont( font );
surface.SetColor( 0, 0, 0, 255 );
surface.SetSrcBlendFunction( DSBF_INVSRCALPHA );
surface.SetDstBlendFunction( DSBF_INVSRCALPHA );
surface.DrawString( "Test Text", -1, 10, 10, (DFBSurfaceTextFlags)(DSTF_TOPLEFT | DSTF_BLEND_FUNCS) );
}
int
DirectFB_RenderClear(SDL_Renderer * renderer)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
IDirectFBSurface *destsurf = data->target;
DirectFB_ActivateRenderer(renderer);
PrepareDraw(renderer);
destsurf->Clear(destsurf, renderer->r, renderer->g, renderer->b, renderer->a);
return 0;
}
static int l_new (lua_State* L)
{
Canvas* canvas = CHECKCANVAS(L);
IDirectFBSurface* sfc = NULL;
int type = lua_type(L, 2);
switch (type)
{
// IMAGE
// [ canvas | img_path ]
case LUA_TSTRING: {
Surface* _sfc =
ImagePlayer::renderImage((char*)luaL_checkstring(L, 2));
sfc = (IDirectFBSurface*)(_sfc->getContent());
_sfc->setContent(NULL);
delete _sfc;
break;
}
// NEW { w, h }
// [ canvas | w | h ]
case LUA_TNUMBER: {
DFBSurfaceDescription dsc;
dsc.width = luaL_checkint(L, 2);
dsc.height = luaL_checkint(L, 3);
dsc.flags = (DFBSurfaceDescriptionFlags)
(DSDESC_WIDTH | DSDESC_HEIGHT);
sfc = (IDirectFBSurface*)(
OutputManager::getInstance()->createSurface(&dsc));
DFBCHECK( sfc->Clear(sfc, canvas->color->getR(),
canvas->color->getG(), canvas->color->getB(),
canvas->color->getAlpha()) );
break;
}
default:
return luaL_argerror(L, 2, NULL);
}
return lua_createcanvas(L, sfc, 1); // [ ... | canvas ] -> canvas
}
static IDirectFBSurface *
load_image (const char *filename)
{
IDirectFBImageProvider *provider;
IDirectFBSurface *tmp = NULL;
IDirectFBSurface *surface = NULL;
DFBSurfaceDescription dsc;
DFBResult err;
err = dfb->CreateImageProvider( dfb, filename, &provider );
if (err != DFB_OK) {
fprintf( stderr, "Couldn't load image from file '%s': %s\n",
filename, DirectFBErrorString( err ));
return NULL;
}
provider->GetSurfaceDescription( provider, &dsc );
dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;
dsc.pixelformat = DSPF_ARGB;
if (dfb->CreateSurface( dfb, &dsc, &tmp ) == DFB_OK)
provider->RenderTo( provider, tmp, NULL );
provider->Release( provider );
if (tmp) {
primary->GetPixelFormat( primary, &dsc.pixelformat );
if (dfb->CreateSurface( dfb, &dsc, &surface ) == DFB_OK) {
surface->Clear( surface, 0, 0, 0, 0xFF );
surface->SetBlittingFlags( surface, DSBLIT_BLEND_ALPHACHANNEL );
surface->Blit( surface, tmp, NULL, 0, 0 );
}
tmp->Release( tmp );
}
return surface;
}
int
main( int argc, char *argv[] )
{
int i;
DFBResult ret;
DFBSurfaceDescription desc;
IDirectFB *dfb;
IDirectFBImageProvider *provider = NULL;
IDirectFBSurface *source = NULL;
IDirectFBSurface *dest = NULL;
IDirectFBSurface *dest2 = NULL;
const char *url = NULL;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/Scale: DirectFBInit() failed!\n" );
return ret;
}
/* Parse arguments. */
for (i=1; i<argc; i++) {
if (!strcmp( argv[i], "-h" ))
return show_usage( argv[0] );
else if (!url)
url = argv[i];
else
return show_usage( argv[0] );
}
/* Check if we got an URL. */
if (!url)
return show_usage( argv[0] );
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Scale: DirectFBCreate() failed!\n" );
return ret;
}
/* Create an image provider for the image to be loaded. */
ret = dfb->CreateImageProvider( dfb, url, &provider );
if (ret) {
D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateImageProvider( '%s' ) failed!\n", url );
goto out;
}
/* Get the surface description. */
ret = provider->GetSurfaceDescription( provider, &desc );
if (ret) {
D_DERROR( ret, "DFBTest/Scale: IDirectFBImageProvider::GetSurfaceDescription() failed!\n" );
goto out;
}
desc.pixelformat = DSPF_NV21;
D_INFO( "DFBTest/Scale: Source is %dx%d using %s\n",
desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) );
/* Create a surface for the image. */
ret = dfb->CreateSurface( dfb, &desc, &source );
if (ret) {
D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" );
goto out;
}
ret = provider->RenderTo( provider, source, NULL );
if (ret) {
D_DERROR( ret, "DFBTest/Scale: IDirectFBImageProvider::RenderTo() failed!\n" );
goto out;
}
desc.width = desc.width * 3 / 4;
desc.height = desc.height * 3 / 4;
D_INFO( "DFBTest/Scale: Destination is %dx%d using %s\n",
desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) );
/* Create a surface for the image. */
ret = dfb->CreateSurface( dfb, &desc, &dest );
if (ret) {
D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" );
goto out;
}
DFBRectangle srect = {
10, 10, 200, 200
};
DFBRectangle drect = {
10, 10, 300, 300
};
DFBRegion clip = {
40, 40, 199, 199
};
dest->Clear( dest, 0xff, 0xff, 0xff, 0xff );
dest->SetClip( dest, &clip );
dest->StretchBlit( dest, source, &srect, &drect );
desc.pixelformat = DSPF_ARGB;
D_INFO( "DFBTest/Scale: Destination2 is %dx%d using %s\n",
desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) );
/* Create a surface for the image. */
ret = dfb->CreateSurface( dfb, &desc, &dest2 );
if (ret) {
D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" );
goto out;
}
dest2->Blit( dest2, dest, NULL, 0, 0 );
dest2->Dump( dest2, "dfbtest_scale_nv21", NULL );
out:
if (dest2)
dest2->Release( dest2 );
if (dest)
dest->Release( dest );
if (source)
source->Release( source );
if (provider)
provider->Release( provider );
/* Shutdown DirectFB. */
dfb->Release( dfb );
return ret;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
int i;
DFBSurfaceDescription desc;
IDirectFB *dfb;
IDirectFBSurface *dest = NULL;
DFBSurfacePixelFormat dest_format = DSPF_UNKNOWN;
char pixel_buffer[100*100*4];
IDirectFBSurface *source = NULL;
IDirectFBEventBuffer *keybuffer;
DFBInputEvent evt;
bool quit = false;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/PreAlloc: 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 if (strcmp (arg, "-d") == 0 || strcmp (arg, "--dest") == 0) {
if (++i == argc) {
print_usage (argv[0]);
return false;
}
if (!parse_format( argv[i], &dest_format ))
return false;
}
else if (strcmp (arg, "-s") == 0 || strcmp (arg, "--static") == 0) {
static_caps = DSCAPS_STATIC_ALLOC;
}
else
return print_usage( argv[0] );
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/PreAlloc: DirectFBCreate() failed!\n" );
return ret;
}
/* Fill description for a primary surface. */
desc.flags = DSDESC_CAPS;
desc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING;
if (dest_format != DSPF_UNKNOWN) {
desc.flags |= DSDESC_PIXELFORMAT;
desc.pixelformat = dest_format;
}
dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN );
/* Create an input buffer for key events */
dfb->CreateInputEventBuffer( dfb, DICAPS_KEYS,
DFB_TRUE, &keybuffer);
/* Create a primary surface. */
ret = dfb->CreateSurface( dfb, &desc, &dest );
if (ret) {
D_DERROR( ret, "DFBTest/PreAlloc: IDirectFB::CreateSurface() for the destination failed!\n" );
goto out;
}
dest->GetSize( dest, &desc.width, &desc.height );
dest->GetPixelFormat( dest, &desc.pixelformat );
D_INFO( "DFBTest/PreAlloc: Destination is %dx%d using %s\n",
desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) );
/* Create a preallocated surface. */
desc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS | DSDESC_PREALLOCATED;
desc.width = 100;
desc.height = 100;
desc.pixelformat = DSPF_ARGB;
desc.caps = static_caps;
desc.preallocated[0].data = pixel_buffer;
desc.preallocated[0].pitch = 100 * 4;
ret = dfb->CreateSurface( dfb, &desc, &source );
if (ret) {
D_DERROR( ret, "DFBTest/PreAlloc: IDirectFB::CreateSurface() for the preallocated source failed!\n" );
goto out;
}
/* Before any other operation the pixel data can be written to without locking */
gen_pixels( pixel_buffer, 100 * 4, 100 );
while (!quit) {
void *ptr;
int pitch;
/* Lock source surface for writing before making updates to the pixel buffer */
source->Lock( source, DSLF_WRITE, &ptr, &pitch );
if (ptr == pixel_buffer)
D_INFO( "DFBTest/PreAlloc: Locking preallocated source gave original preallocated pixel buffer :-)\n" );
else {
if (static_caps)
D_INFO( "DFBTest/PreAlloc: Locking preallocated source gave different pixel buffer, ERROR with static alloc!\n" );
else
D_INFO( "DFBTest/PreAlloc: Locking preallocated source gave different pixel buffer, but OK (no static alloc)\n" );
}
update_pixels( ptr, pitch, 100 );
/* Unlock source surface after writing, before making further Blits,
to have the buffer be transfered to master again */
source->Unlock( source );
dest->Clear( dest, 0, 0, 0, 0xff );
/* First Blit from preallocated source, data will be transfered to master */
dest->Blit( dest, source, NULL, 50, 50 );
/* Second Blit from preallocated source, data is already master */
dest->Blit( dest, source, NULL, 150, 150 );
dest->Flip( dest, NULL, DSFLIP_NONE );
/* This will upload again the preallocated buffer to the master, where it is
modified and outdates the preallocated buffer. Now it depends on the static
alloc flag whether the next Lock will directly go into the shared memory
allocation or the preallocated buffer again (with a transfer back from master
to us). */
source->FillRectangle( source, 0, 0, 10, 10 );
/* Process keybuffer */
while (keybuffer->GetEvent( keybuffer, DFB_EVENT(&evt)) == DFB_OK)
{
if (evt.type == DIET_KEYPRESS) {
switch (DFB_LOWER_CASE(evt.key_symbol)) {
case DIKS_ESCAPE:
case DIKS_SMALL_Q:
case DIKS_BACK:
case DIKS_STOP:
case DIKS_EXIT:
/* Quit main loop & test thread */
quit = true;
break;
default:
break;
}
}
}
if (!quit)
sleep( 5 );
}
out:
if (source)
source->Release( source );
if (dest)
dest->Release( dest );
keybuffer->Release( keybuffer );
/* Shutdown DirectFB. */
dfb->Release( dfb );
return ret;
}
DFBResult
lite_theme_frame_load( LiteThemeFrame *frame,
const char **filenames )
{
int i, y;
int width = 0;
int height = 0;
DFBResult ret;
D_ASSERT( frame != NULL );
D_ASSERT( filenames != NULL );
for (i=0; i<_LITE_THEME_FRAME_PART_NUM; i++) {
D_ASSERT( filenames[i] != NULL );
ret = lite_util_load_image( filenames[i],
DSPF_UNKNOWN,
&frame->parts[i].source,
&frame->parts[i].rect.w,
&frame->parts[i].rect.h,
NULL );
if (ret) {
D_DERROR( ret, "Lite/ThemeFrame: Loading '%s' failed!\n", filenames[i] );
while (i--)
frame->parts[i].source->Release( frame->parts[i].source );
return ret;
}
if (width < frame->parts[i].rect.w)
width = frame->parts[i].rect.w;
height += frame->parts[i].rect.h;
}
IDirectFB *dfb;
IDirectFBSurface *compact;
DFBSurfaceDescription desc;
desc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;
desc.width = width;
desc.height = height;
desc.pixelformat = DSPF_ARGB; //FIXME
DirectFBCreate( &dfb );
dfb->CreateSurface( dfb, &desc, &compact );
compact->Clear( compact, 0, 0, 0, 0 );
for (i=0, y=0; i<_LITE_THEME_FRAME_PART_NUM; i++) {
compact->Blit( compact, frame->parts[i].source, &frame->parts[i].rect, 0, y );
compact->AddRef( compact );
frame->parts[i].source->Release( frame->parts[i].source );
frame->parts[i].source = compact;
frame->parts[i].rect.x = 0;
frame->parts[i].rect.y = y;
y += frame->parts[i].rect.h;
}
compact->ReleaseSource( compact );
compact->Release( compact );
dfb->Release( dfb );
D_MAGIC_SET( frame, LiteThemeFrame );
return DFB_OK;
}
static DFBResult
Test_CreateSubWindow( IDirectFBDisplayLayer *layer, void *arg )
{
IDirectFBWindow *window;
DFBWindowID window_id;
DFBDimension size = { m_desc_sub.width, m_desc_sub.height };
D_ASSERT( m_toplevel_id != 0 );
/* Write window ID of top level into description */
m_desc_sub.toplevel_id = m_toplevel_id;
/*
* Create a new sub window with 75% width/height and positioned at 20,20 within top level window
*/
SHOW_TEST( "CreateWindow( %d,%d - %dx%d %s + toplevel ID %u, options 0x%08x )...",
m_desc_sub.posx, m_desc_sub.posy, m_desc_sub.width, m_desc_sub.height,
dfb_pixelformat_name( m_desc_sub.pixelformat ), m_desc_sub.toplevel_id, m_desc_top.options );
_T( layer->CreateWindow( layer, &m_desc_sub, &window ) );
if (m_subcolor.valid) {
DFBColor c = m_subcolor.color;
SHOW_INFO( " - SetColor( 0x%02x, 0x%02x, 0x%02x, 0x%02x )...", c.r, c.g, c.b, c.a );
_T( window->SetColor( window, c.r, c.g, c.b, c.a ) );
}
/*
* Query its surface and clear it with light gray (if not input or color only)
*/
if (!(m_desc_sub.caps & (DWCAPS_INPUTONLY | DWCAPS_COLOR) )) {
IDirectFBSurface *surface;
SHOW_INFO( " - GetSurface()..." );
_T( window->GetSurface( window, &surface ) );
SHOW_INFO( " - Clear( 0xC0, 0xC0, 0xC0, 0xFF )..." );
_T( surface->Clear( surface, 0xC0, 0xC0, 0xC0, 0xFF ) );
_T( surface->DrawRectangle( surface, 0, 0, size.w, size.h ) );
_T( surface->FillRectangle( surface, size.w / 2, 1, 1, size.h - 2 ) );
_T( surface->FillRectangle( surface, 1, size.h / 2, size.w - 2, 1 ) );
surface->Release( surface );
}
/*
* Show the window
*/
SHOW_INFO( " - SetOpacity( 255 )..." );
_T( window->SetOpacity( window, 0xff ) );
/*
* Query and print ID of new window
*/
SHOW_INFO( " - GetID()..." );
_T( window->GetID( window, &window_id ) );
/*
* Set association of new window
*/
if (m_desc_sub.parent_id) {
SHOW_INFO( " - SetAssociation( %u )...", m_desc_sub.parent_id );
_T( window->SetAssociation( window, m_desc_sub.parent_id ) );
}
/*
* Set top level window ID (user hasn't specified one)
*/
m_subwindow_id = window_id;
m_subwindow = window;
SHOW_RESULT( "...CreateWindow( %d,%d - %dx%d %s + toplevel ID %u ) done. => Sub Window ID %u",
m_desc_sub.posx, m_desc_sub.posy, m_desc_sub.width, m_desc_sub.height,
dfb_pixelformat_name( m_desc_sub.pixelformat ), m_desc_sub.toplevel_id, window_id );
return DFB_OK;
}
/** entry point */
int main(int argc, char *argv[])
{
const char *uuid = NULL;
int c;
int listHostModes = 0;
int quit = 0;
const struct option options[] =
{
{ "help", no_argument, NULL, 'h' },
{ "startvm", required_argument, NULL, 's' },
{ "fixedres", required_argument, NULL, 'f' },
{ "listhostmodes", no_argument, NULL, 'l' },
{ "scale", no_argument, NULL, 'c' }
};
printf("VirtualBox DirectFB GUI built %s %s\n"
"(C) 2004-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
"(C) 2004-2005 secunet Security Networks AG\n", __DATE__, __TIME__);
for (;;)
{
c = getopt_long(argc, argv, "s:", options, NULL);
if (c == -1)
break;
switch (c)
{
case 'h':
{
showusage();
exit(0);
break;
}
case 's':
{
// UUID as string, parse it
RTUUID buuid;
if (!RT_SUCCESS(RTUuidFromStr((PRTUUID)&buuid, optarg)))
{
printf("Error, invalid UUID format given!\n");
showusage();
exit(-1);
}
uuid = optarg;
break;
}
case 'f':
{
if (sscanf(optarg, "%ux%ux%u", &fixedVideoMode.width, &fixedVideoMode.height,
&fixedVideoMode.bpp) != 3)
{
printf("Error, invalid resolution argument!\n");
showusage();
exit(-1);
}
useFixedVideoMode = 1;
break;
}
case 'l':
{
listHostModes = 1;
break;
}
case 'c':
{
scaleGuest = 1;
break;
}
default:
break;
}
}
// check if we got a UUID
if (!uuid)
{
printf("Error, no UUID given!\n");
showusage();
exit(-1);
}
/**
* XPCOM setup
*/
nsresult rc;
/*
* Note that we scope all nsCOMPtr variables in order to have all XPCOM
* objects automatically released before we call NS_ShutdownXPCOM at the
* end. This is an XPCOM requirement.
*/
{
nsCOMPtr<nsIServiceManager> serviceManager;
rc = NS_InitXPCOM2(getter_AddRefs(serviceManager), nsnull, nsnull);
if (NS_FAILED(rc))
{
printf("Error: XPCOM could not be initialized! rc=0x%x\n", rc);
exit(-1);
}
// register our component
nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(serviceManager);
if (!registrar)
{
printf("Error: could not query nsIComponentRegistrar interface!\n");
exit(-1);
}
registrar->AutoRegister(nsnull);
/*
* Make sure the main event queue is created. This event queue is
* responsible for dispatching incoming XPCOM IPC messages. The main
* thread should run this event queue's loop during lengthy non-XPCOM
* operations to ensure messages from the VirtualBox server and other
* XPCOM IPC clients are processed. This use case doesn't perform such
* operations so it doesn't run the event loop.
*/
nsCOMPtr<nsIEventQueue> eventQ;
rc = NS_GetMainEventQ(getter_AddRefs (eventQ));
if (NS_FAILED(rc))
{
printf("Error: could not get main event queue! rc=%08X\n", rc);
return -1;
}
/*
* Now XPCOM is ready and we can start to do real work.
* IVirtualBox is the root interface of VirtualBox and will be
* retrieved from the XPCOM component manager. We use the
* XPCOM provided smart pointer nsCOMPtr for all objects because
* that's very convenient and removes the need deal with reference
* counting and freeing.
*/
nsCOMPtr<nsIComponentManager> manager;
rc = NS_GetComponentManager (getter_AddRefs (manager));
if (NS_FAILED(rc))
{
printf("Error: could not get component manager! rc=%08X\n", rc);
exit(-1);
}
nsCOMPtr<IVirtualBox> virtualBox;
rc = manager->CreateInstanceByContractID(NS_VIRTUALBOX_CONTRACTID,
nsnull,
NS_GET_IID(IVirtualBox),
getter_AddRefs(virtualBox));
if (NS_FAILED(rc))
{
printf("Error, could not instantiate object! rc=0x%x\n", rc);
exit(-1);
}
nsCOMPtr<ISession> session;
rc = manager->CreateInstance(CLSID_Session,
nsnull,
NS_GET_IID(ISession),
getter_AddRefs(session));
if (NS_FAILED(rc))
{
printf("Error: could not instantiate Session object! rc = %08X\n", rc);
exit(-1);
}
// open session for this VM
rc = virtualBox->OpenSession(session, NS_ConvertUTF8toUTF16(uuid).get());
if (NS_FAILED(rc))
{
printf("Error: given machine not found!\n");
exit(-1);
}
nsCOMPtr<IMachine> machine;
session->GetMachine(getter_AddRefs(machine));
if (!machine)
{
printf("Error: given machine not found!\n");
exit(-1);
}
nsCOMPtr<IConsole> console;
session->GetConsole(getter_AddRefs(console));
if (!console)
{
printf("Error: cannot get console!\n");
exit(-1);
}
nsCOMPtr<IDisplay> display;
console->GetDisplay(getter_AddRefs(display));
if (!display)
{
printf("Error: could not get display object!\n");
exit(-1);
}
nsCOMPtr<IKeyboard> keyboard;
nsCOMPtr<IMouse> mouse;
VBoxDirectFB *frameBuffer = NULL;
/**
* Init DirectFB
*/
IDirectFB *dfb = NULL;
IDirectFBSurface *surface = NULL;
IDirectFBInputDevice *dfbKeyboard = NULL;
IDirectFBInputDevice *dfbMouse = NULL;
IDirectFBEventBuffer *dfbEventBuffer = NULL;
DFBSurfaceDescription dsc;
int screen_width, screen_height;
DFBCHECK(DirectFBInit(&argc, &argv));
DFBCHECK(DirectFBCreate(&dfb));
DFBCHECK(dfb->SetCooperativeLevel(dfb, DFSCL_FULLSCREEN));
// populate our structure of supported video modes
DFBCHECK(dfb->EnumVideoModes(dfb, enumVideoModesHandler, NULL));
if (listHostModes)
{
printf("*****************************************************\n");
printf("Number of available host video modes: %u\n", numVideoModes);
for (uint32_t i = 0; i < numVideoModes; i++)
{
printf("Mode %u: xres = %u, yres = %u, bpp = %u\n", i,
videoModes[i].width, videoModes[i].height, videoModes[i].bpp);
}
printf("Note: display modes with bpp < have been filtered out\n");
printf("*****************************************************\n");
goto Leave;
}
if (useFixedVideoMode)
{
int32_t bestVideoMode = getBestVideoMode(fixedVideoMode.width,
fixedVideoMode.height,
fixedVideoMode.bpp);
// validate the fixed mode
if ((bestVideoMode == -1) ||
((fixedVideoMode.width != videoModes[bestVideoMode].width) ||
(fixedVideoMode.height != videoModes[bestVideoMode].height) ||
(fixedVideoMode.bpp != videoModes[bestVideoMode].bpp)))
{
printf("Error: the specified fixed video mode is not available!\n");
exit(-1);
}
} else
{
initialVideoMode = getBestVideoMode(640, 480, 16);
if (initialVideoMode == -1)
{
printf("Error: initial video mode 640x480x16 is not available!\n");
exit(-1);
}
}
dsc.flags = DSDESC_CAPS;
dsc.caps = DSCAPS_PRIMARY;
DFBCHECK(dfb->CreateSurface(dfb, &dsc, &surface));
DFBCHECK(surface->Clear(surface, 0, 0, 0, 0));
DFBCHECK(surface->GetSize(surface, &screen_width, &screen_height));
DFBCHECK(dfb->GetInputDevice(dfb, DIDID_KEYBOARD, &dfbKeyboard));
DFBCHECK(dfbKeyboard->CreateEventBuffer(dfbKeyboard, &dfbEventBuffer));
DFBCHECK(dfb->GetInputDevice(dfb, DIDID_MOUSE, &dfbMouse));
DFBCHECK(dfbMouse->AttachEventBuffer(dfbMouse, dfbEventBuffer));
if (useFixedVideoMode)
{
printf("Information: setting video mode to %ux%ux%u\n", fixedVideoMode.width,
fixedVideoMode.height, fixedVideoMode.bpp);
DFBCHECK(dfb->SetVideoMode(dfb, fixedVideoMode.width,
fixedVideoMode.height, fixedVideoMode.bpp));
} else
{
printf("Information: starting with default video mode %ux%ux%u\n",
videoModes[initialVideoMode].width, videoModes[initialVideoMode].height,
videoModes[initialVideoMode].bpp);
DFBCHECK(dfb->SetVideoMode(dfb, videoModes[initialVideoMode].width,
videoModes[initialVideoMode].height,
videoModes[initialVideoMode].bpp));
}
// register our framebuffer
frameBuffer = new VBoxDirectFB(dfb, surface);
display->SetFramebuffer(0, frameBuffer);
/**
* Start the VM execution thread
*/
console->PowerUp(NULL);
console->GetKeyboard(getter_AddRefs(keyboard));
console->GetMouse(getter_AddRefs(mouse));
/**
* Main event loop
*/
#define MAX_KEYEVENTS 10
PRInt32 keyEvents[MAX_KEYEVENTS];
int numKeyEvents;
while (!quit)
{
DFBInputEvent event;
numKeyEvents = 0;
DFBCHECK(dfbEventBuffer->WaitForEvent(dfbEventBuffer));
while (dfbEventBuffer->GetEvent(dfbEventBuffer, DFB_EVENT(&event)) == DFB_OK)
{
int mouseXDelta = 0;
int mouseYDelta = 0;
int mouseZDelta = 0;
switch (event.type)
{
#define QUEUEEXT() keyEvents[numKeyEvents++] = 0xe0
#define QUEUEKEY(scan) keyEvents[numKeyEvents++] = scan | (event.type == DIET_KEYRELEASE ? 0x80 : 0x00)
#define QUEUEKEYRAW(scan) keyEvents[numKeyEvents++] = scan
case DIET_KEYPRESS:
case DIET_KEYRELEASE:
{
// @@@AH development hack to get out of it!
if ((event.key_id == DIKI_ESCAPE) && (event.modifiers & (DIMM_CONTROL | DIMM_ALT)))
quit = 1;
if (numKeyEvents < MAX_KEYEVENTS)
{
//printf("%s: key_code: 0x%x\n", event.type == DIET_KEYPRESS ? "DIET_KEYPRESS" : "DIET_KEYRELEASE", event.key_code);
switch ((uint32_t)event.key_id)
{
case DIKI_CONTROL_R:
QUEUEEXT();
QUEUEKEY(0x1d);
break;
case DIKI_INSERT:
QUEUEEXT();
QUEUEKEY(0x52);
break;
case DIKI_DELETE:
QUEUEEXT();
QUEUEKEY(0x53);
break;
case DIKI_HOME:
QUEUEEXT();
QUEUEKEY(0x47);
break;
case DIKI_END:
QUEUEEXT();
QUEUEKEY(0x4f);
break;
case DIKI_PAGE_UP:
QUEUEEXT();
QUEUEKEY(0x49);
break;
case DIKI_PAGE_DOWN:
QUEUEEXT();
QUEUEKEY(0x51);
break;
case DIKI_LEFT:
QUEUEEXT();
QUEUEKEY(0x4b);
break;
case DIKI_RIGHT:
QUEUEEXT();
QUEUEKEY(0x4d);
break;
case DIKI_UP:
QUEUEEXT();
QUEUEKEY(0x48);
break;
case DIKI_DOWN:
QUEUEEXT();
QUEUEKEY(0x50);
break;
case DIKI_KP_DIV:
QUEUEEXT();
QUEUEKEY(0x35);
break;
case DIKI_KP_ENTER:
QUEUEEXT();
QUEUEKEY(0x1c);
break;
case DIKI_PRINT:
// the break code is inverted!
if (event.type == DIET_KEYPRESS)
{
QUEUEEXT();
QUEUEKEY(0x2a);
QUEUEEXT();
QUEUEKEY(0x37);
} else
{
QUEUEEXT();
QUEUEKEY(0x37);
QUEUEEXT();
QUEUEKEY(0x2a);
}
break;
case DIKI_PAUSE:
// This is a super weird key. No break code and a 6 byte
// combination.
if (event.type == DIET_KEYPRESS)
{
QUEUEKEY(0xe1);
QUEUEKEY(0x1d);
QUEUEKEY(0x45);
QUEUEKEY(0xe1);
QUEUEKEY(0x9d);
QUEUEKEY(0xc5);
}
break;
case DIKI_META_L:
// the left Windows logo is a bit different
if (event.type == DIET_KEYPRESS)
{
QUEUEEXT();
QUEUEKEYRAW(0x1f);
} else
{
QUEUEEXT();
QUEUEKEYRAW(0xf0);
QUEUEKEYRAW(0x1f);
}
break;
case DIKI_META_R:
// the right Windows logo is a bit different
if (event.type == DIET_KEYPRESS)
{
QUEUEEXT();
QUEUEKEYRAW(0x27);
} else
{
QUEUEEXT();
QUEUEKEYRAW(0xf0);
QUEUEKEYRAW(0x27);
}
break;
case DIKI_SUPER_R:
// the popup menu is a bit different
if (event.type == DIET_KEYPRESS)
{
QUEUEEXT();
QUEUEKEYRAW(0x2f);
} else
{
QUEUEEXT();
QUEUEKEYRAW(0xf0);
QUEUEKEYRAW(0x2f);
}
break;
default:
// check if we got a hardware scancode
if (event.key_code != -1)
{
// take the scancode from DirectFB as is
QUEUEKEY(event.key_code);
} else
{
// XXX need extra handling!
}
}
}
break;
}
#undef QUEUEEXT
#undef QUEUEKEY
#undef QUEUEKEYRAW
case DIET_AXISMOTION:
{
switch (event.axis)
{
case DIAI_X:
mouseXDelta += event.axisrel;
break;
case DIAI_Y:
mouseYDelta += event.axisrel;
break;
case DIAI_Z:
mouseZDelta += event.axisrel;
break;
default:
break;
}
// fall through
}
case DIET_BUTTONPRESS:
// fall through;
case DIET_BUTTONRELEASE:
{
int buttonState = 0;
if (event.buttons & DIBM_LEFT)
buttonState |= MouseButtonState::LeftButton;
if (event.buttons & DIBM_RIGHT)
buttonState |= MouseButtonState::RightButton;
if (event.buttons & DIBM_MIDDLE)
buttonState |= MouseButtonState::MiddleButton;
mouse->PutMouseEvent(mouseXDelta, mouseYDelta, mouseZDelta,
buttonState);
break;
}
default:
break;
}
}
// did we get any keyboard events?
if (numKeyEvents > 0)
{
uint32_t codesStored;
if (numKeyEvents > 1)
{
keyboard->PutScancodes(numKeyEvents, keyEvents,
&codesStored);
} else
{
keyboard->PutScancode(keyEvents[0]);
}
}
}
{
nsCOMPtr<IProgress> progress;
console->PowerDown(getter_AddRefs(progress));
progress->WaitForCompletion(-1);
}
}
Leave:
/*
* Perform the standard XPCOM shutdown procedure.
*/
NS_ShutdownXPCOM(nsnull);
return 0;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
bool quit = false;
int i;
IDirectFB dfb;
IDirectFBDisplayLayer layer;
IDirectFBSurface surface;
DFBDisplayLayerConfig config;
DFBDimension sizes[2] = { {400, 400}, {600, 600} };
size_t num_sizes = D_ARRAY_SIZE(sizes);
DFBInputEvent evt;
IDirectFBEventBuffer keybuffer;
/* Initialize DirectFB. */
DirectFB::Init( &argc, &argv );
/* Create super interface. */
dfb = DirectFB::Create();
layer = dfb.GetDisplayLayer( DLID_PRIMARY );
/* Create an input buffer for key events */
keybuffer = dfb.CreateInputEventBuffer( DICAPS_KEYS, DFB_TRUE );
layer.SetCooperativeLevel( DLSCL_EXCLUSIVE );
layer.GetConfiguration( &config );
config.width = sizes[0].w;
config.height = sizes[0].h;
layer.SetConfiguration( config );
surface = layer.GetSurface();
while (true) {
surface.Clear( 0, 0, 0, 0xff );
surface.SetColor( 0x00, 0xff, 0x00, 0xff );
surface.DrawRectangle( 0, 0, config.width, config.height );
surface.Flip( NULL, DSFLIP_NONE );
keybuffer.WaitForEventWithTimeout( 3, 0 );
/* Process keybuffer */
while (keybuffer.GetEvent( DFB_EVENT(&evt) )) {
if (evt.type == DIET_KEYPRESS) {
switch (DFB_LOWER_CASE(evt.key_symbol)) {
case DIKS_ESCAPE:
case DIKS_SMALL_Q:
case DIKS_BACK:
case DIKS_STOP:
case DIKS_EXIT:
/* Quit main loop & test thread */
quit = 1;
break;
case DIKS_SPACE:
case DIKS_OK:
i++;
config.width = sizes[i % num_sizes].w;
config.height = sizes[i % num_sizes].h;
layer.SetConfiguration( config );
break;
default:
break;
}
}
}
}
return 0;
}
//---------------------------------------------------------------------------------
//--------------------------wael work----------------------
//---------------------------------------------------------------------------------
status_t ServerWindow::CreateWindow (IDirectFBDisplayLayer *layer){
DFBFontDescription font_dsc;
DFBWindowDescription wdsc;
IDirectFBSurface *wsurface = NULL;
DFBSurfaceDescription dsc;
// char *title;TODO: I need to convert the fTitle from BString to char *
char title[fTitle.CountChars()+1];
fTitle.CopyInto(title, 0, fTitle.CountChars());
DFBRectangle frame;
frame.x=(int)fFrame.LeftTop().x;
frame.y=(int)fFrame.LeftTop().y;
frame.w=(int)fFrame.IntegerWidth();
frame.h=(int)fFrame.IntegerHeight();
int width1, width2, width3;
int height1, height2, height3;
//create window inside the primary layer
wdsc.flags = (DFBWindowDescriptionFlags)(DWDESC_CAPS | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_POSX | DWDESC_POSY | DWDESC_SURFACE_CAPS);
wdsc.caps = DWCAPS_ALPHACHANNEL;
wdsc.width = frame.w;
wdsc.height = frame.h;
wdsc.posx = frame.x;
wdsc.posy = frame.y;
wdsc.surface_caps = DSCAPS_FLIPPING;
DFBCHECK(layer->CreateWindow(layer, &wdsc, &window));
//Get the window surface and clear it
DFBCHECK(window->GetSurface(window, &wsurface));
DFBCHECK(wsurface->Clear (wsurface, 0x00, 0x00, 0x00, 0x00));
DFBCHECK(window->SetOpaqueRegion (window, 0, 0, frame.h, frame.w));
//Set the window options to be transparent
DFBWindowOptions options;
window->GetOptions (window, &options);
options = (DFBWindowOptions) ( options | DWOP_SHAPED );
DFBCHECK(window->SetOptions (window, options));
wsurface->SetSrcColorKey(wsurface, R, G, B);
wsurface->SetBlittingFlags(wsurface, DSBLIT_SRC_COLORKEY);
if (fType==B_FLOATING_WINDOW){
DFBCHECK (shead->GetSize(shead, &width1, &height1));
DFBCHECK (sok_button->GetSize(sok_button, &width2, &height2));
DFBCHECK (sclose_button->GetSize(sclose_button, &width3, &height3));
DFBRectangle rect;
rect.x = 0;
rect.y = 0;
rect.h = height1;
rect.w = frame.w-width2-width3;
DFBCHECK (wsurface->StretchBlit (wsurface, shead, NULL, &rect));
DFBCHECK (wsurface->Blit (wsurface, sok_button, NULL, rect.w, 0));
DFBCHECK (wsurface->Blit (wsurface, sclose_button, NULL, rect.w+width2, 0));
// Draw the window title
font_dsc.flags = DFDESC_HEIGHT;
font_dsc.height = 10;
font_dsc.width = 10;
DFBCHECK (app_server->dfb->CreateFont (app_server->dfb, "./decker.ttf", &font_dsc, &font));
DFBCHECK (wsurface->SetFont (wsurface, font));
DFBCHECK (wsurface->SetColor (wsurface, 0xff, 0x0, 0x0, 0xFF));
int size = 0;
DFBRectangle rect1;
DFBCHECK (font->GetStringExtents (font, title, -1, NULL, &rect1));
if (rect1.w > rect.w){
do{
size++;
DFBCHECK (font->GetStringExtents (font, title, size, NULL, &rect1));
}while (rect1.w < rect.w);
size--;
}
DFBCHECK (wsurface->DrawString (wsurface, title, size-1, 5, 2*height1/3, DSTF_LEFT));
rect.x = 0;
rect.y = height1;
rect.w = frame.w;
rect.h = frame.h-height1;
DFBCHECK (wsurface->StretchBlit (wsurface, body, NULL, &rect));
}
else if (fType==B_TITLED_WINDOW){
DFBCHECK (head->GetSize(head, &width1, &height1));
DFBCHECK (ok_button->GetSize(ok_button, &width2, &height2));
DFBCHECK (close_button->GetSize(close_button, &width3, &height3));
DFBRectangle rect;
rect.x = 0;
rect.y = 0;
rect.h = height1;
rect.w = frame.w-width2-width3;
DFBCHECK (wsurface->StretchBlit (wsurface, head, NULL, &rect));
DFBCHECK (wsurface->Blit (wsurface, ok_button, NULL, rect.w, 0));
DFBCHECK (wsurface->Blit (wsurface, close_button, NULL, rect.w+width2, 0));
// Draw the window title
font_dsc.flags = DFDESC_HEIGHT;
font_dsc.height = 15;
font_dsc.width = 15;
DFBCHECK (app_server->dfb->CreateFont (app_server->dfb, "./decker.ttf", &font_dsc, &font));
DFBCHECK (wsurface->SetFont (wsurface, font));
DFBCHECK (wsurface->SetColor (wsurface, 0x0, 0x10, 0xfa, 0xFF));
int size = 0;
DFBRectangle rect1;
DFBCHECK (font->GetStringExtents (font, title, -1, NULL, &rect1));
if (rect1.w > rect.w){
do{
size++;
DFBCHECK (font->GetStringExtents (font, title, size, NULL, &rect1));
}while (rect1.w < rect.w);
size-=2;
}
DFBCHECK (wsurface->DrawString (wsurface, title, -1, 6, 2*height1/3, DSTF_LEFT));
rect.x = 0;
rect.y = height1;
rect.w = frame.w;
rect.h = frame.h-height1;
DFBCHECK (wsurface->StretchBlit (wsurface, body, NULL, &rect));
}
else if (fType==B_MODAL_WINDOW){
}
created = true;
}
int main (int argc,char *argv[])
{
int videofd1 = open("/dev/video0",O_RDWR);
int videofd2 = open("/dev/video0",O_RDWR);
IDirectFBSurface *SurfaceHandle;
IDirectFBSurface *SurfaceHandle2;
void *ptr,*ptr2;
int pitch,pitch2;
int colour_palette[256];
int colour_palette2_real[256]; /* random... */
int *colour_palette2 = colour_palette2_real;
int is_lut8;
is_lut8 = (argc > 1 && !strcmp (argv[1], "both"));
memset(&colour_palette,0x0,4*256);
//memset(&colour_palette[1],0xff,255*4);
colour_palette[0] = 0xff000000; // black
colour_palette[1] = 0xffff0000; // red
colour_palette[2] = 0xff00ff00; // green
colour_palette[3] = 0xff0000ff; // blue
colour_palette[4] = 0xffffffff; // white
colour_palette[5] = 0x80808000; // half-transp yellow
colour_palette[6] = 0x00000000; // transp black
if (videofd1 < 0)
perror("Couldn't open video device 1\n");
if (videofd2 < 0)
perror("Couldn't open video device 2\n");
v4l2_list_outputs (videofd1);
fb_make_transparent();
init_dfb(&SurfaceHandle,is_lut8);
init_dfb(&SurfaceHandle2,1);
v4l2_set_output_by_name (videofd1, "RGB1");
v4l2_set_output_by_name (videofd2, "RGB2");
init_v4l(videofd1,0,0,1280,720,is_lut8);
init_v4l(videofd2,0,0,1280,720,1);
printf("%s:%d\n",__FUNCTION__,__LINE__);
// memcpy (colour_palette, colour_palette2, sizeof (colour_palette));
colour_palette2 = colour_palette;
{
int coords = 60;
int size = 100;
// clear
if (!is_lut8) SurfaceHandle->Clear (SurfaceHandle, 0x00, 0x00, 0x00, 0x00);
else {
SurfaceHandle->SetColorIndex (SurfaceHandle, 0x6);
SurfaceHandle->FillRectangle (SurfaceHandle, 0, 0, 600, 600);
}
// White
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x4);
else SurfaceHandle->SetColor (SurfaceHandle, 0xff, 0xff, 0xff, 0xff);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// Red
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x1);
else SurfaceHandle->SetColor (SurfaceHandle, 0xff, 0x00, 0x00, 0xff);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// Green
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x2);
else SurfaceHandle->SetColor (SurfaceHandle, 0x00, 0xff, 0x00, 0xff);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// Blue
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x3);
else SurfaceHandle->SetColor (SurfaceHandle, 0x00, 0x00, 0xff, 0xff);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// half transp yellow
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x5);
else SurfaceHandle->SetColor (SurfaceHandle, 0x80, 0x80, 0x00, 0x80);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// transp
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x6);
else SurfaceHandle->SetColor (SurfaceHandle, 0x00, 0x00, 0x00, 0x00);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
}
{
int xcoords = 60 + (100 * 6), ycoords = 60;
int size = 100;
// clear
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x6);
SurfaceHandle2->FillRectangle (SurfaceHandle2, 220, 220, 440, 440);
// transp
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x6);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// half transp yellow
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x5);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// Blue
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x3);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// Green
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x2);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// Red
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x1);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// White
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x4);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
}
DFBCHECK (SurfaceHandle->Lock (SurfaceHandle, DSLF_READ, &ptr, &pitch));
DFBCHECK (SurfaceHandle2->Lock (SurfaceHandle2, DSLF_READ, &ptr2, &pitch2));
printf("%s:%d\n",__FUNCTION__,__LINE__);
zorder(videofd2,V4L2_CID_STM_Z_ORDER_RGB2,1);
zorder(videofd1,V4L2_CID_STM_Z_ORDER_RGB1,2);
queue_buffer( videofd1, ptr, (is_lut8 ? colour_palette : 0), 0ULL);
stream_on( videofd1 );
getchar();
queue_buffer( videofd2, ptr2, colour_palette2, 0ULL);
printf("%s:%d\n",__FUNCTION__,__LINE__);
stream_on( videofd2 );
printf("%s:%d\n",__FUNCTION__,__LINE__);
getchar();
zorder(videofd2,V4L2_CID_STM_Z_ORDER_RGB2,2);
zorder(videofd1,V4L2_CID_STM_Z_ORDER_RGB1,1);
fprintf(stderr,"Press Return/Enter to quit\n");
getchar();
// This seems to dequeue all buffers too, but that's what the spec says
// so this is ok.
stream_off( videofd1 );
stream_off( videofd2 );
deinit_dfb();
close(videofd1);
return 0;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
int i;
int x, y;
int dx, dy;
int sw3, sh3;
int opacity = 255;
int opacity_delta = -1;
IDirectFB *dfb;
IDirectFBDisplayLayer *layer;
IDirectFBSurface *surface;
DFBDisplayLayerConfig config;
DFBDimension size;
DFBInputEvent evt;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/Layer: DirectFBInit() failed!\n" );
return ret;
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Layer: DirectFBCreate() failed!\n" );
return ret;
}
dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer );
/* Create an input buffer for key events */
dfb->CreateInputEventBuffer( dfb, DICAPS_KEYS,
DFB_TRUE, &keybuffer);
layer->SetCooperativeLevel( layer, DFSCL_EXCLUSIVE );
layer->GetConfiguration( layer, &config );
config.options = DLOP_OPACITY | DLOP_SRC_COLORKEY;
config.buffermode = DLBM_FRONTONLY;
layer->SetConfiguration( layer, &config );
layer->SetSrcColorKey( layer, 0x00, 0xff, 0x00 );
ret = layer->GetSurface( layer, &surface );
if (ret) {
D_DERROR( ret, "DFBTest/Layer: GetSurface() failed!\n" );
dfb->Release( dfb );
return ret;
}
surface->GetSize( surface, &size.w, &size.h );
sw3 = ((size.w / 3) + 1) & ~1;
sh3 = ((size.h / 3) + 1) & ~1;
surface->Clear( surface, 0, 0, 0, 0xff );
for (i=0; i<10; i++) {
surface->SetColor( surface, 0xff - i*16, 0xff - i*16, 0xff - i*16, 0xff );
surface->DrawRectangle( surface, i, i, size.w - i*2, size.h - i*2 );
}
surface->FillRectangle( surface, 10, size.h/2, size.w - 20, 1 );
surface->FillRectangle( surface, size.w/2, 10, 1, size.h - 20 );
surface->SetColor( surface, 0xff, 0x00, 0x00, 0xff );
surface->FillRectangle( surface, size.w/3, size.h/3, size.w/3, size.h/3 );
surface->SetColor( surface, 0x00, 0xff, 0x00, 0xff );
surface->FillRectangle( surface, size.w/3 + size.w/9, size.h/3 + size.h/9, size.w/9, size.h/9 );
surface->Flip( surface, NULL, DSFLIP_NONE );
#ifdef BUILD_AUTOMATION
sleep( 2 );
#else
sleep( 12 );
#endif
layer->SetSourceRectangle( layer, 0, 0, size.w - sw3, size.h - sh3 );
layer->SetScreenPosition( layer, 100, 100 );
layer->SetScreenRectangle( layer, 100, 100, size.w - sw3, size.h - sh3 );
sleep( 2 );
#ifdef BUILD_AUTOMATION
sleep( 20 );
quit = 1;
#endif
for (x=0, y=0, dx=1, dy=1; !quit ; x+=dx, y+=dy) {
layer->SetOpacity( layer, opacity );
if (opacity == 255)
opacity_delta = -1;
else if (opacity == 0)
opacity_delta = 1;
opacity += opacity_delta;
layer->SetSourceRectangle( layer, x, y, size.w - sw3, size.h - sh3 );
surface->Flip( surface, NULL, DSFLIP_UPDATE );
if (dx > 0) {
if (x == size.w/3) {
dx = -1;
usleep( 500000 );
}
}
else if (x == 0) {
dx = 1;
usleep( 500000 );
}
if (dy > 0) {
if (y == size.h/3) {
dy = -1;
usleep( 500000 );
}
}
else if (y == 0) {
dy = 1;
usleep( 500000 );
}
usleep( 10000 );
/* Process keybuffer */
while (keybuffer->GetEvent( keybuffer, DFB_EVENT(&evt)) == DFB_OK)
{
if (evt.type == DIET_KEYPRESS) {
switch (DFB_LOWER_CASE(evt.key_symbol)) {
case DIKS_ESCAPE:
case DIKS_SMALL_Q:
case DIKS_BACK:
case DIKS_STOP:
case DIKS_EXIT:
/* Quit main loop & test thread */
quit = 1;
break;
default:
break;
}
}
}
}
surface->Release( surface );
layer->Release( layer );
/* Shutdown DirectFB. */
dfb->Release( dfb );
return ret;
}
static DFBResult
app_init( App *app,
IDirectFBDisplayLayer *layer,
int x,
int y,
int width,
int height,
int index )
{
DFBResult ret;
DFBWindowDescription desc;
IDirectFBWindow *window;
IDirectFBSurface *surface;
desc.flags = DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_POSX | DWDESC_POSY | DWDESC_CAPS;
desc.width = width;
desc.height = height;
desc.posx = x;
desc.posy = y;
desc.caps = DWCAPS_NONE; //| DWCAPS_ALPHACHANNEL | DWCAPS_DOUBLEBUFFER;
/* Create a surface for the image. */
ret = layer->CreateWindow( layer, &desc, &window );
if (ret) {
D_DERROR( ret, "DFBTest/WindowFlip: IDirectFBDisplayLayer::CreateWindow() failed!\n" );
return ret;
}
/* Get the surface. */
ret = window->GetSurface( window, &surface );
if (ret) {
D_DERROR( ret, "DFBTest/WindowFlip: IDirectFBWindow::GetSurface() failed!\n" );
return ret;
}
surface->Clear( surface, 0xff, 0xff, 0xff, 0xff );
surface->Flip( surface, NULL, DSFLIP_NONE );
direct_thread_sleep( 2000000 );
D_INFO( "Showing window...\n" );
direct_thread_sleep( 500000 );
window->SetOpacity( window, 0xff );
direct_thread_sleep( 500000 );
D_INFO( "Done.\n" );
direct_thread_sleep( 1000000 );
app->window = window;
app->surface = surface;
app->index = index;
app->resolution.w = width;
app->resolution.h = height;
app->anim_dirx = 5;
app->anim_diry = 5;
app->anim_x = 0;
app->anim_y = 0;
return DFB_OK;
}
void BeginRender(const Rect &inRect,bool inForHitTest)
{
mPrimarySurface->Clear(mPrimarySurface, 0xFF, 0xFF, 0xFF, 0xFF);
}