DFBResult
ICore_Requestor::WaitIdle(
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreDFBWaitIdle *args = (CoreDFBWaitIdle*) args_alloc( args_static, sizeof(CoreDFBWaitIdle) );
CoreDFBWaitIdleReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreDFBWaitIdleReturn*) args_alloc( return_args_static, sizeof(CoreDFBWaitIdleReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, CoreDFB_WaitIdle, args, sizeof(CoreDFBWaitIdle), return_args, sizeof(CoreDFBWaitIdleReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_WaitIdle ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreDFB_WaitIdle 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 DFBResult
system_initialize( CoreDFB *core, void **ret_data )
{
DFBResult ret;
MesaData *mesa;
MesaDataShared *shared;
FusionSHMPoolShared *pool;
D_ASSERT( m_data == NULL );
mesa = D_CALLOC( 1, sizeof(MesaData) );
if (!mesa)
return D_OOM();
mesa->core = core;
pool = dfb_core_shmpool( core );
shared = SHCALLOC( pool, 1, sizeof(MesaDataShared) );
if (!shared) {
D_FREE( mesa );
return D_OOSHM();
}
shared->shmpool = pool;
mesa->shared = shared;
m_data = mesa;
if (dfb_config->vt) {
ret = dfb_vt_initialize();
if (ret)
return DFB_INIT;
}
ret = InitLocal( mesa );
if (ret) {
if (dfb_config->vt)
dfb_vt_shutdown( false );
return ret;
}
*ret_data = m_data;
dfb_surface_pool_initialize( core, &mesaSurfacePoolFuncs, &shared->pool );
mesa->screen = dfb_screens_register( NULL, mesa, mesaScreenFuncs );
mesa->layer = dfb_layers_register( mesa->screen, mesa, mesaLayerFuncs );
core_arena_add_shared_field( core, "mesa", shared );
return DFB_OK;
}
static DFBResult
system_join( CoreDFB *core, void **data )
{
DFBResult ret;
void *ptr;
DFBX11 *x11;
DFBX11Shared *shared;
D_DEBUG_AT( X11_Core, "%s()\n", __FUNCTION__ );
x11 = D_CALLOC( 1, sizeof(DFBX11) );
if (!x11)
return D_OOM();
fusion_arena_get_shared_field( dfb_core_arena( core ), "x11", &ptr );
shared = ptr;
/*
* Local init (master and slave)
*/
ret = InitLocal( x11, shared, core );
if (ret) {
D_FREE( x11 );
return ret;
}
/*
* Must be set before joining the pools!
*/
*data = x11;
/*
* Slave init
*/
if (shared->x11image_pool)
dfb_surface_pool_join( core, shared->x11image_pool, &x11SurfacePoolFuncs );
#ifdef USE_GLX
if (shared->glx_pool)
dfb_surface_pool_join( core, shared->glx_pool, &glxSurfacePoolFuncs );
#endif
if (shared->vpsmem_pool)
dfb_surface_pool_join( core, shared->vpsmem_pool, &vpsmemSurfacePoolFuncs );
#ifdef USE_GLX
if (shared->x11_pool_bridge)
dfb_surface_pool_bridge_join( core, shared->x11_pool_bridge, &x11SurfacePoolBridgeFuncs, x11 );
#endif
return DFB_OK;
}
static DFBResult driver_open_device(CoreInputDevice *device,
unsigned int number,
InputDeviceInfo *info,
void **driver_data)
{
int fd;
MuTData *data;
/* open device */
fd = MuTOpenDevice (dfb_config->mut_device);
D_INFO("MuTouch:driver_open_device %s fd %d\n", dfb_config->mut_device,fd);
if (fd < 0) {
return DFB_INIT;
}
data = D_CALLOC (1, sizeof(MuTData));
if (!data) {
close (fd);
return D_OOM ();
}
data->fd = fd;
data->device = device;
/* Must define the correct resolution of screen */
data->screen_width = MuT_SCREENWIDTH;
data->screen_height = MuT_SCREENHEIGHT;
/* The following variable are defined to adjust the orientation of
* the touchscreen. Variables are either max screen height/width or 0.
*/
data->min_x = MuT_MINX;
data->min_y = MuT_MINY;
/* fill device info structure */
snprintf(info->desc.name, DFB_INPUT_DEVICE_DESC_NAME_LENGTH,
"MuTouch");
snprintf(info->desc.vendor, DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH,
"Microtouch");
info->prefered_id = DIDID_MOUSE;
info->desc.type = DIDTF_MOUSE;
info->desc.caps = DICAPS_AXES | DICAPS_BUTTONS;
info->desc.max_axis = DIAI_Y;
info->desc.max_button = DIBI_LEFT;
/* start input thread */
data->thread = direct_thread_create (DTT_INPUT, MuTouchEventThread, data, "MuTouch Input");
/* set private data pointer */
*driver_data = data;
return DFB_OK;
}
static DFBResult driver_open_device(CoreInputDevice *device,
unsigned int number,
InputDeviceInfo *info,
void **driver_data)
{
int fd;
eloData *data;
/* open device */
fd = eloOpenDevice(elo_DEVICE);
if(fd < 0) {
D_PERROR("DirectFB/elo: Error opening '"elo_DEVICE"'!\n");
return DFB_INIT;
}
data = D_CALLOC(1, sizeof(eloData));
if (!data) {
close(fd);
return D_OOM();
}
data->fd = fd;
data->device = device;
/* Must define the correct resolution of screen */
data->screen_width = elo_SCREENWIDTH;
data->screen_height = elo_SCREENHEIGHT;
/* The following variable are defined to adjust the orientation of
* the touchscreen. Variables are either max screen height/width or 0.
*/
data->min_x = elo_MINX;
data->min_y = elo_MINY;
/* fill device info structure */
snprintf(info->desc.name, DFB_INPUT_DEVICE_DESC_NAME_LENGTH,
"elo");
snprintf(info->desc.vendor, DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH,
"elo Systems");
info->prefered_id = DIDID_MOUSE;
info->desc.type = DIDTF_MOUSE;
info->desc.caps = DICAPS_AXES | DICAPS_BUTTONS;
info->desc.max_axis = DIAI_Y;
info->desc.max_button = DIBI_LEFT;
/* start input thread */
data->thread = direct_thread_create (DTT_INPUT, eloTouchEventThread, data, "ELO Touch Input");
/* set private data pointer */
*driver_data = data;
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **ret_data )
{
DFBResult ret;
DevMemData *data;
DevMemDataShared *shared;
FusionSHMPoolShared *pool;
D_ASSERT( m_data == NULL );
if (!dfb_config->video_phys || !dfb_config->video_length) {
D_ERROR( "System/DevMem: Please supply 'video-phys = 0xXXXXXXXX' and 'video-length = XXXX' options!\n" );
return DFB_INVARG;
}
if (dfb_config->mmio_phys && !dfb_config->mmio_length) {
D_ERROR( "System/DevMem: Please supply both 'mmio-phys = 0xXXXXXXXX' and 'mmio-length = XXXX' options or none!\n" );
return DFB_INVARG;
}
data = D_CALLOC( 1, sizeof(DevMemData) );
if (!data)
return D_OOM();
pool = dfb_core_shmpool( core );
shared = SHCALLOC( pool, 1, sizeof(DevMemDataShared) );
if (!shared) {
D_FREE( data );
return D_OOSHM();
}
shared->shmpool = pool;
data->shared = shared;
ret = MapMemAndReg( data,
dfb_config->video_phys, dfb_config->video_length,
dfb_config->mmio_phys, dfb_config->mmio_length );
if (ret) {
SHFREE( pool, shared );
D_FREE( data );
return ret;
}
*ret_data = m_data = data;
dfb_surface_pool_initialize( core, &devmemSurfacePoolFuncs, &shared->pool );
fusion_arena_add_shared_field( dfb_core_arena( core ), "devmem", shared );
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **ret_data )
{
DFBResult ret;
PVR2DData *data;
PVR2DDataShared *shared;
FusionSHMPoolShared *pool;
D_ASSERT( m_data == NULL );
data = D_CALLOC( 1, sizeof(PVR2DData) );
if (!data)
return D_OOM();
data->core = core;
pool = dfb_core_shmpool( core );
shared = SHCALLOC( pool, 1, sizeof(PVR2DDataShared) );
if (!shared) {
D_FREE( data );
return D_OOSHM();
}
shared->shmpool = pool;
data->shared = shared;
ret = InitPVR2D( data );
if (ret) {
SHFREE( pool, shared );
D_FREE( data );
return ret;
}
ret = InitEGL( data );
if (ret) {
SHFREE( pool, shared );
D_FREE( data );
return ret;
}
*ret_data = m_data = data;
data->screen = dfb_screens_register( NULL, data, pvr2dPrimaryScreenFuncs );
data->layer = dfb_layers_register( data->screen, data, pvr2dPrimaryLayerFuncs );
dfb_surface_pool_initialize( core, pvr2dSurfacePoolFuncs, &shared->pool );
fusion_arena_add_shared_field( dfb_core_arena( core ), "pvr2d", shared );
return DFB_OK;
}
DFBResult
CoreInputHubClient_Create( u32 remote_qid,
const CoreInputHubClientCallbacks *callbacks,
void *ctx,
CoreInputHubClient **ret_client )
{
DFBResult ret;
CoreInputHubClient *client;
D_DEBUG_AT( Core_InputHub, "%s( QID 0x%08x )\n", __FUNCTION__, remote_qid );
D_ASSERT( callbacks != NULL );
D_ASSERT( ret_client != NULL );
One_Initialize();
client = D_CALLOC( 1, sizeof(CoreInputHubClient) );
if (!client)
return D_OOM();
client->remote_qid = remote_qid;
client->callbacks = *callbacks;
client->ctx = ctx;
ret = OneQueue_New( ONE_QUEUE_NO_FLAGS, ONE_QID_NONE, &client->listen_qid );
if (ret)
goto error;
ret = OneThread_Create( "Input Hub Client", &client->thread );
if (ret)
goto error;
ret = OneThread_AddQueue( client->thread, client->listen_qid, CoreInputHubClient_Dispatch, client );
if (ret)
goto error;
*ret_client = client;
return DFB_OK;
error:
if (client->thread)
OneThread_Destroy( client->thread );
if (client->listen_qid)
OneQueue_Destroy( client->listen_qid );
D_FREE( client );
return ret;
}
DirectResult
direct_map_create( unsigned int initial_size,
DirectMapCompareFunc compare_func,
DirectMapHashFunc hash_func,
void *ctx,
DirectMap **ret_map )
{
DirectMap *map;
D_DEBUG_AT( Direct_Map, "%s( size %u, compare %p, hash %p )\n", __func__, initial_size, compare_func, hash_func );
D_ASSERT( compare_func != NULL );
D_ASSERT( hash_func != NULL );
D_ASSERT( ret_map != NULL );
if (initial_size < 3)
initial_size = 3;
map = D_CALLOC( 1, sizeof (DirectMap) );
if (!map)
return D_OOM();
map->entries = D_CALLOC( initial_size, sizeof(MapEntry) );
if (!map->entries) {
D_FREE( map );
return D_OOM();
}
map->size = initial_size;
map->compare = compare_func;
map->hash = hash_func;
map->ctx = ctx;
D_MAGIC_SET( map, DirectMap );
*ret_map = map;
return DR_OK;
}
DirectResult
voodoo_play_get_broadcast( VoodooPlayAddress **ret_addr,
size_t *ret_num )
{
DirectResult ret = DR_OK;
VoodooPlayAddress *addr;
// Get local host name
char szHostName[128] = "";
if (gethostname(szHostName, sizeof(szHostName))) {
ret = errno2result( errno );
D_PERROR( "Voodoo/Win32: gethostname() failed!\n" );
return ret;
}
// Get local IP addresses
struct hostent *pHost = 0;
pHost = gethostbyname(szHostName);
if (!pHost) {
ret = errno2result( errno );
D_PERROR( "Voodoo/Win32: gethostbyname('%s') failed!\n", szHostName );
return ret;
}
size_t iCnt, iTotal = 0;
for (iCnt = 0; pHost->h_addr_list[iCnt]; ++iCnt)
iTotal++;
addr = D_CALLOC( iTotal, sizeof(VoodooPlayAddress) );
if (!addr)
return D_OOM();
for (iCnt = 0; pHost->h_addr_list[iCnt]; ++iCnt) {
struct sockaddr_in SocketAddress;
memcpy(&SocketAddress.sin_addr, pHost->h_addr_list[iCnt], pHost->h_length);
voodoo_play_from_inet_addr( &addr[iCnt], SocketAddress.sin_addr.s_addr );
}
*ret_addr = addr;
*ret_num = iTotal;
return DR_OK;
}
DirectResult
direct_processor_init( DirectProcessor *processor,
const char *name,
const DirectProcessorFuncs *funcs,
unsigned int data_size,
void *context,
int idle_ms )
{
D_ASSERT( processor != NULL );
D_ASSERT( name != NULL );
D_ASSERT( funcs != NULL );
D_ASSERT( funcs->Process != NULL );
D_ASSERT( data_size > 0 );
D_DEBUG_AT( Direct_Processor, "%s( %p, %p, %p, %u, %p )\n", __FUNCTION__,
processor, name, funcs, data_size, context );
processor->name = D_STRDUP( name );
if (!processor->name)
return D_OOM();
processor->funcs = funcs;
processor->data_size = data_size;
processor->context = context;
processor->idle_ms = idle_ms;
processor->max_recycled = (8000 / data_size) + 1;
direct_fifo_init( &processor->commands );
direct_fifo_init( &processor->recycled );
#if 0
direct_waitqueue_init( &processor->lock_cond, NULL );
direct_mutex_init( &processor->lock_mutex, NULL );
#endif
D_MAGIC_SET( processor, DirectProcessor );
processor->thread = direct_thread_create( DTT_DEFAULT, processor_thread, processor, name );
if (!processor->thread) {
D_MAGIC_CLEAR( processor );
direct_fifo_destroy( &processor->commands );
direct_fifo_destroy( &processor->recycled );
D_FREE( processor->name );
return DR_INIT;
}
return DR_OK;
}
static DFBResult
driver_open_device( CoreInputDevice *device,
unsigned int number,
InputDeviceInfo *info,
void **driver_data )
{
int fd;
WM97xxTSData *data;
/* open device */
fd = open( "/dev/touchscreen/wm97xx", O_RDONLY | O_NOCTTY );
if (fd < 0) {
D_PERROR( "DirectFB/WM97xx: Error opening `/dev/touchscreen/wm97xx'!\n" );
return DFB_INIT;
}
/* fill device info structure */
snprintf( info->desc.name,
DFB_INPUT_DEVICE_DESC_NAME_LENGTH, "WM97xx Touchscreen" );
snprintf( info->desc.vendor,
DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH, "Wolfson Microelectronics" );
info->prefered_id = DIDID_MOUSE;
info->desc.type = DIDTF_MOUSE;
info->desc.caps = DICAPS_AXES | DICAPS_BUTTONS;
info->desc.max_axis = DIAI_Y;
info->desc.max_button = DIBI_LEFT;
/* allocate and fill private data */
data = D_CALLOC( 1, sizeof(WM97xxTSData) );
if (!data) {
close( fd );
return D_OOM();
}
data->fd = fd;
data->device = device;
/* start input thread */
data->thread = direct_thread_create( DTT_INPUT, wm97xxtsEventThread, data, "WM97xx TS Input" );
/* set private data pointer */
*driver_data = data;
return DFB_OK;
}
DirectResult
direct_hash_create( int size,
DirectHash **ret_hash )
{
DirectHash *hash;
hash = D_CALLOC( 1, sizeof (DirectHash) );
if (!hash)
return D_OOM();
direct_hash_init( hash, size );
*ret_hash = hash;
return DR_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **ret_data )
{
DFBResult ret;
AndroidData *android;
AndroidDataShared *shared;
FusionSHMPoolShared *pool;
D_ASSERT( m_data == NULL );
android = D_CALLOC( 1, sizeof(AndroidData) );
if (!android)
return D_OOM();
android->core = core;
pool = dfb_core_shmpool( core );
shared = SHCALLOC( pool, 1, sizeof(AndroidDataShared) );
if (!shared) {
D_FREE( android );
return D_OOSHM();
}
shared->shmpool = pool;
android->shared = shared;
m_data = android;
ret = InitLocal( android );
if (ret)
return ret;
*ret_data = m_data;
dfb_surface_pool_initialize( core, &androidSurfacePoolFuncs, &shared->pool );
android->screen = dfb_screens_register( NULL, android, androidScreenFuncs );
android->layer = dfb_layers_register( android->screen, android, androidLayerFuncs );
android->java_vm = native_data.app->activity->vm;
android->app_path = D_STRDUP( native_data.app->activity->internalDataPath) ;
core_arena_add_shared_field( core, "android", shared );
return DFB_OK;
}
static DFBResult
system_join( CoreDFB *core, void **ret_data )
{
DFBResult ret;
void *tmp;
DevMemData *data;
DevMemDataShared *shared;
D_ASSERT( m_data == NULL );
if (!dfb_config->video_phys || !dfb_config->video_length) {
D_ERROR( "System/DevMem: Please supply 'video-phys = 0xXXXXXXXX' and 'video-length = XXXX' options!\n" );
return DFB_INVARG;
}
if (dfb_config->mmio_phys && !dfb_config->mmio_length) {
D_ERROR( "System/DevMem: Please supply both 'mmio-phys = 0xXXXXXXXX' and 'mmio-length = XXXX' options or none!\n" );
return DFB_INVARG;
}
data = D_CALLOC( 1, sizeof(DevMemData) );
if (!data)
return D_OOM();
ret = fusion_arena_get_shared_field( dfb_core_arena( core ), "devmem", &tmp );
if (ret) {
D_FREE( data );
return ret;
}
data->shared = shared = tmp;
ret = MapMemAndReg( data,
dfb_config->video_phys, dfb_config->video_length,
dfb_config->mmio_phys, dfb_config->mmio_length );
if (ret) {
D_FREE( data );
return ret;
}
*ret_data = m_data = data;
dfb_surface_pool_join( core, shared->pool, &devmemSurfacePoolFuncs );
return DFB_OK;
}
DFBResult
ICore_Real::CreateImageProvider(
u32 buffer_call,
u32 *ret_call
)
{
DFBResult ret;
IDirectFBDataBuffer *buffer;
IDirectFBImageProvider *provider;
ImageProviderDispatch *dispatch;
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Real::%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( obj, CoreDFB );
D_ASSERT( ret_call != NULL );
DIRECT_ALLOCATE_INTERFACE( buffer, IDirectFBDataBuffer );
if (!buffer)
return (DFBResult) D_OOM();
/* Construct data buffer client */
ret = IDirectFBDataBuffer_Client_Construct( buffer, core, buffer_call );
if (ret)
return ret;
/* Create image provider */
ret = buffer->CreateImageProvider( buffer, &provider );
if (ret) {
buffer->Release( buffer );
return ret;
}
/* Create dispatch object */
ret = ImageProviderDispatch_Create( idirectfb_singleton, buffer, provider, &dispatch );
if (ret) {
provider->Release( provider );
buffer->Release( buffer );
return ret;
}
*ret_call = dispatch->call.call_id;
return DFB_OK;
}
String &
String::PrintF( const char *format, va_list args, size_t stack_buffer )
{
size_t len;
char buf[stack_buffer];
char *ptr = buf;
D_ASSERT( format != NULL );
// TODO: check if va_copy is required here
#ifdef __GNUC__
va_list ap2;
va_copy( ap2, args );
len = direct_vsnprintf( buf, sizeof(buf), format, ap2 );
va_end( ap2 );
#else
len = direct_vsnprintf( buf, sizeof(buf), format, args );
#endif
if (len < 0)
return *this;
if (len >= sizeof(buf)) {
ptr = (char*) direct_malloc( len+1 );
if (!ptr) {
D_OOM();
return *this;
}
len = direct_vsnprintf( ptr, len+1, format, args );
if (len < 0) {
direct_free( ptr );
return *this;
}
}
str.append( ptr );
if (ptr != buf)
direct_free( ptr );
return *this;
}
static DFBResult
system_join( CoreDFB *core, void **ret_data )
{
DFBResult ret;
void *tmp;
MesaData *mesa;
MesaDataShared *shared;
D_ASSERT( m_data == NULL );
if (dfb_config->vt) {
ret = dfb_vt_join();
if (ret)
return DFB_INIT;
}
mesa = D_CALLOC( 1, sizeof(MesaData) );
if (!mesa)
return D_OOM();
mesa->core = core;
ret = core_arena_get_shared_field( core, "mesa", &tmp );
if (ret) {
D_FREE( mesa );
return ret;
}
mesa->shared = shared = tmp;
ret = InitLocal( mesa );
if (ret)
return ret;
*ret_data = m_data = mesa;
dfb_surface_pool_join( core, shared->pool, &mesaSurfacePoolFuncs );
mesa->screen = dfb_screens_register( NULL, mesa, mesaScreenFuncs );
mesa->layer = dfb_layers_register( mesa->screen, mesa, mesaLayerFuncs );
return DFB_OK;
}
void
direct_perf_count( DirectPerfCounterInstallation *installation, int diff )
{
DirectPerfCounter *counter;
D_ASSERT( installation != NULL );
direct_mutex_lock( &counter_lock );
if (installation->counter_id == 0) {
counter = D_CALLOC( 1, sizeof(DirectPerfCounter) );
if (!counter) {
direct_mutex_unlock( &counter_lock );
D_OOM();
return;
}
installation->counter_id = ++counter_ids;
D_ASSERT( installation->counter_id != 0 );
D_ASSERT( installation->counter_id != ~0 ); // FIXME: can there be more than 4 billion counters?
direct_snputs( counter->name, installation->name, sizeof(counter->name) );
counter->reset_on_dump = installation->reset_on_dump;
direct_hash_insert( &counter_hash, installation->counter_id, counter );
}
else {
counter = direct_hash_lookup( &counter_hash, installation->counter_id );
if (!counter) {
direct_mutex_unlock( &counter_lock );
D_BUG( "unknown performance counter installation (%lu)", installation->counter_id );
return;
}
}
counter->count += diff;
if (!counter->start)
counter->start = direct_clock_get_time( DIRECT_CLOCK_SESSION );
direct_mutex_unlock( &counter_lock );
}
static DirectResult
resize_map( DirectMap *map,
unsigned int size )
{
unsigned int i, pos;
MapEntry *entries;
D_DEBUG_AT( Direct_Map, "%s( size %u )\n", __func__, size );
DIRECT_MAP_ASSERT( map );
D_ASSERT( size > 3 );
entries = D_CALLOC( size, sizeof(MapEntry) );
if (!entries)
return D_OOM();
for (i=0; i<map->size; i++) {
MapEntry *entry = &map->entries[i];
MapEntry *insertElement;
if (entry->object && entry->object != REMOVED) {
pos = entry->hash % size;
insertElement = &entries[pos];
while (insertElement->object && insertElement->object != REMOVED) {
if (++pos == size)
pos = 0;
insertElement = &entries[pos];
}
entries[pos] = *entry;
}
}
D_FREE( map->entries );
map->size = size;
map->entries = entries;
map->removed = 0;
return DR_OK;
}
DirectResult
direct_log_create( DirectLogType type,
const char *param,
DirectLog **ret_log )
{
DirectResult ret = DR_INVARG;
DirectLog *log;
log = D_CALLOC( 1, sizeof(DirectLog) );
if (!log)
return D_OOM();
log->type = type;
switch (type) {
case DLT_STDERR:
ret = init_stderr( log );
break;
case DLT_FILE:
ret = init_file( log, param );
break;
case DLT_UDP:
ret = init_udp( log, param );
break;
}
if (ret)
D_FREE( log );
else {
direct_util_recursive_pthread_mutex_init( &log->lock );
D_MAGIC_SET( log, DirectLog );
*ret_log = log;
}
return ret;
}
static DFBResult
system_join( CoreDFB *core, void **ret_data )
{
DFBResult ret;
void *tmp;
AndroidData *android;
AndroidDataShared *shared;
D_ASSERT( m_data == NULL );
android = D_CALLOC( 1, sizeof(AndroidData) );
if (!android)
return D_OOM();
android->core = core;
ret = core_arena_get_shared_field( core, "android", &tmp );
if (ret) {
D_FREE( android );
return ret;
}
android->shared = shared = tmp;
ret = InitLocal( android );
if (ret)
return ret;
*ret_data = m_data = android;
dfb_surface_pool_join( core, shared->pool, &androidSurfacePoolFuncs );
android->screen = dfb_screens_register( NULL, android, androidScreenFuncs );
android->layer = dfb_layers_register( android->screen, android, androidLayerFuncs );
return DFB_OK;
}
static void
InputHub_DeviceAdd( void *ctx,
DFBInputDeviceID device_id,
const DFBInputDeviceDescription *desc )
{
DirectResult ret;
InputHubDeviceNode *node;
D_DEBUG_AT( Input_Hub, "%s( ID %u, '%s' )\n", __FUNCTION__, device_id, desc->name );
node = direct_hash_lookup( m_nodes, device_id );
if (!node) {
node = D_CALLOC( 1, sizeof(InputHubDeviceNode) );
if (!node) {
D_OOM();
return;
}
node->device_id = device_id;
node->description = *desc;
ret = direct_hash_insert( m_nodes, device_id, node );
if (ret) {
D_FREE( node );
return;
}
ret = dfb_input_create_device( device_id, m_core, m_driver );
if (ret) {
direct_hash_remove( m_nodes, device_id );
D_FREE( node );
return;
}
}
else
D_WARN( "already have device (ID %u)", device_id );
}
static DirectResult
parse_host_addr( const char *hostport,
struct addrinfo **ret_addr )
{
int i, ret;
int size = strlen( hostport ) + 1;
char buf[size];
char *hoststr = buf;
char *portstr = NULL;
char *end;
struct addrinfo hints;
memcpy( buf, hostport, size );
for (i=0; i<size; i++) {
if (buf[i] == ':') {
buf[i] = 0;
portstr = &buf[i+1];
break;
}
}
if (!portstr) {
D_ERROR( "Direct/Log: Parse error in '%s' that should be '<host>:<port>'!\n", hostport );
return DR_INVARG;
}
strtoul( portstr, &end, 10 );
if (end && *end) {
D_ERROR( "Direct/Log: Parse error in port number '%s'!\n", portstr );
return DR_INVARG;
}
memset( &hints, 0, sizeof(hints) );
hints.ai_socktype = SOCK_DGRAM;
hints.ai_family = PF_UNSPEC;
ret = getaddrinfo( hoststr, portstr, &hints, ret_addr );
if (ret) {
switch (ret) {
case EAI_FAMILY:
D_ERROR( "Direct/Log: Unsupported address family!\n" );
return DR_UNSUPPORTED;
case EAI_SOCKTYPE:
D_ERROR( "Direct/Log: Unsupported socket type!\n" );
return DR_UNSUPPORTED;
case EAI_NONAME:
D_ERROR( "Direct/Log: Host not found!\n" );
return DR_FAILURE;
case EAI_SERVICE:
D_ERROR( "Direct/Log: Port %s is unreachable!\n", portstr );
return DR_FAILURE;
#ifdef EAI_ADDRFAMILY
case EAI_ADDRFAMILY:
#endif
case EAI_NODATA:
D_ERROR( "Direct/Log: Host found, but has no address!\n" );
return DR_FAILURE;
case EAI_MEMORY:
return D_OOM();
case EAI_FAIL:
D_ERROR( "Direct/Log: A non-recoverable name server error occurred!\n" );
return DR_FAILURE;
case EAI_AGAIN:
D_ERROR( "Direct/Log: Temporary error, try again!\n" );
return DR_TEMPUNAVAIL;
default:
D_ERROR( "Direct/Log: Unknown error occured!?\n" );
return DR_FAILURE;
}
}
return DR_OK;
}
void
_fusion_call_process( FusionWorld *world, int call_id, FusionCallMessage *msg, void *ptr )
{
FusionCallHandlerResult result = FCHR_RETURN;
FusionCallHandler call_handler;
FusionCallReturn call_ret = {
.val = 0
};
D_DEBUG_AT( Fusion_Call, "%s( call_id %d, msg %p, ptr %p)\n", __FUNCTION__, call_id, msg, ptr );
D_MAGIC_ASSERT( world, FusionWorld );
D_ASSERT( msg != NULL );
D_ASSERT( msg->handler != NULL );
call_handler = msg->handler;
if (direct_log_domain_check( &Fusion_Call )) // avoid call to direct_trace_lookup_symbol_at
D_DEBUG_AT( Fusion_Call, " -> %s\n", direct_trace_lookup_symbol_at( call_handler ) );
result = call_handler( msg->caller, msg->call_arg, ptr ? ptr : msg->call_ptr, msg->ctx, msg->serial, &call_ret.val );
switch (result) {
case FCHR_RETURN:
if (msg->serial) {
call_ret.serial = msg->serial;
call_ret.call_id = call_id;
while (ioctl (world->fusion_fd, FUSION_CALL_RETURN, &call_ret)) {
switch (errno) {
case EINTR:
continue;
case EIDRM:
D_WARN( "caller withdrawn (signal?)" );
return;
case EINVAL:
D_ERROR( "Fusion/Call: invalid call\n" );
return;
default:
D_PERROR( "FUSION_CALL_RETURN" );
return;
}
}
}
break;
case FCHR_RETAIN:
break;
default:
D_BUG( "unknown result %d from call handler", result );
}
}
void
_fusion_call_process3( FusionWorld *world, int call_id, FusionCallMessage3 *msg, void *ptr )
{
FusionCallHandlerResult result = FCHR_RETURN;
FusionCallHandler3 call_handler;
FusionCallReturn3 call_ret;
char *ret_ptr = NULL;
unsigned int ret_length = 0;
D_DEBUG_AT( Fusion_Call, "%s( call_id %d, msg %p, ptr %p)\n", __FUNCTION__, call_id, msg, ptr );
D_MAGIC_ASSERT( world, FusionWorld );
D_ASSERT( msg != NULL );
D_ASSERT( msg->handler != NULL );
call_handler = msg->handler;
if (direct_log_domain_check( &Fusion_Call )) // avoid call to direct_trace_lookup_symbol_at
D_DEBUG_AT( Fusion_Call, " -> %s\n", direct_trace_lookup_symbol_at( call_handler ) );
if (msg->ret_length > FUSION_CALL_RETURN_DATA_MAX) {
D_ERROR( "Fusion/Call: Maximum return data length (%u) exceeded (%u)!\n", FUSION_CALL_RETURN_DATA_MAX, msg->ret_length );
}
else {
if (msg->ret_length > FUSION_CALL_RETURN_DATA_MAX_ON_STACK) {
ret_ptr = D_MALLOC( msg->ret_length );
if (!ret_ptr)
D_OOM();
}
else
ret_ptr = alloca( msg->ret_length );
}
if (ret_ptr)
result = call_handler( msg->caller, msg->call_arg, ptr ? ptr : msg->call_ptr, msg->call_length, msg->ctx, msg->serial, ret_ptr, msg->ret_length, &ret_length );
switch (result) {
case FCHR_RETURN:
if (msg->serial) {
call_ret.call_id = call_id;
call_ret.serial = msg->serial;
call_ret.ptr = ret_ptr;
call_ret.length = ret_length;
while (ioctl (world->fusion_fd, FUSION_CALL_RETURN3, &call_ret)) {
switch (errno) {
case EINTR:
continue;
case EIDRM:
D_DEBUG_AT( Fusion_Call, " -> caller withdrawn (signal?)\n" );
goto out;
case EINVAL:
D_ERROR( "Fusion/Call: invalid call\n" );
goto out;
default:
D_PERROR( "FUSION_CALL_RETURN3" );
goto out;
}
}
}
break;
case FCHR_RETAIN:
break;
default:
D_BUG( "unknown result %d from call handler", result );
}
out:
if (msg->ret_length > FUSION_CALL_RETURN_DATA_MAX_ON_STACK)
D_FREE( ret_ptr );
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
DFBResult ret;
DFBX11 *x11;
DFBX11Shared *shared;
D_DEBUG_AT( X11_Core, "%s()\n", __FUNCTION__ );
x11 = D_CALLOC( 1, sizeof(DFBX11) );
if (!x11)
return D_OOM();
shared = SHCALLOC( dfb_core_shmpool( core ), 1, sizeof(DFBX11Shared) );
if (!shared) {
D_FREE( x11 );
return D_OOSHM();
}
/* we need the error handler to signal the error to us, so
use a global static */
shared_for_error_handler = shared;
XSetErrorHandler( error_handler );
/*
* Local init (master and slave)
*/
ret = InitLocal( x11, shared, core );
if (ret) {
SHFREE( dfb_core_shmpool( core ), shared );
D_FREE( x11 );
return ret;
}
/*
* Shared init (master only)
*/
shared->data_shmpool = dfb_core_shmpool_data( core );
shared->screen_size.w = x11->screenptr->width;
shared->screen_size.h = x11->screenptr->height;
fusion_skirmish_init( &shared->lock, "X11 System", dfb_core_world(core) );
fusion_call_init( &shared->call, call_handler, x11, dfb_core_world(core) );
/*
* Must be set before initializing the pools!
*/
*data = x11;
/*
* Master init
*/
dfb_surface_pool_initialize( core, &x11SurfacePoolFuncs, &shared->x11image_pool );
#ifdef USE_GLX
dfb_surface_pool_initialize( core, &glxSurfacePoolFuncs, &shared->glx_pool );
#endif
if (dfb_config->video_length) {
shared->vpsmem_length = dfb_config->video_length;
dfb_surface_pool_initialize( core, &vpsmemSurfacePoolFuncs, &shared->vpsmem_pool );
}
#ifdef USE_GLX
dfb_surface_pool_bridge_initialize( core, &x11SurfacePoolBridgeFuncs, x11, &shared->x11_pool_bridge );
#endif
fusion_arena_add_shared_field( dfb_core_arena( core ), "x11", shared );
return DFB_OK;
}
DFBResult
dfb_core_create( CoreDFB **ret_core )
{
int ret;
#if FUSION_BUILD_MULTI
char buf[16];
#endif
CoreDFB *core = NULL;
CoreDFBShared *shared = NULL;
D_ASSERT( ret_core != NULL );
D_ASSERT( dfb_config != NULL );
D_DEBUG_AT( DirectFB_Core, "%s...\n", __FUNCTION__ );
pthread_mutex_lock( &core_dfb_lock );
D_ASSERT( core_dfb == NULL || core_dfb->refs > 0 );
if (core_dfb) {
D_MAGIC_ASSERT( core_dfb, CoreDFB );
core_dfb->refs++;
*ret_core = core_dfb;
pthread_mutex_unlock( &core_dfb_lock );
return DFB_OK;
}
direct_initialize();
D_INFO( "DirectFB/Core: %s Application Core. ("BUILDTIME") %s%s\n",
FUSION_BUILD_MULTI ? "Multi" : "Single",
DIRECT_BUILD_DEBUG ? "[ DEBUG ]" : "",
DIRECT_BUILD_TRACE ? "[ TRACE ]" : "" );
#if defined(DFB_DYNAMIC_LINKING) && defined(SOPATH)
if (!dfb_lib_handle)
#ifdef RTLD_GLOBAL
dfb_lib_handle = dlopen(SOPATH, RTLD_GLOBAL|RTLD_LAZY);
#else
/* RTLD_GLOBAL is not defined on OpenBSD */
dfb_lib_handle = dlopen(SOPATH, RTLD_LAZY);
#endif
#endif
ret = dfb_system_lookup();
if (ret)
goto error;
/* Allocate local core structure. */
core = D_CALLOC( 1, sizeof(CoreDFB) );
if (!core) {
ret = D_OOM();
goto error;
}
core->refs = 1;
core->init_handler = direct_thread_add_init_handler( dfb_core_thread_init_handler, core );
#if FUSION_BUILD_MULTI
dfb_system_thread_init();
#endif
direct_find_best_memcpy();
D_MAGIC_SET( core, CoreDFB );
core_dfb = core;
ret = fusion_enter( dfb_config->session, DIRECTFB_CORE_ABI, FER_ANY, &core->world );
if (ret)
goto error;
core->fusion_id = fusion_id( core->world );
#if FUSION_BUILD_MULTI
D_DEBUG_AT( DirectFB_Core, "world %d, fusion id %d\n", fusion_world_index(core->world), core->fusion_id );
snprintf( buf, sizeof(buf), "%d", fusion_world_index(core->world) );
setenv( "DIRECTFB_SESSION", buf, true );
#endif
if (dfb_config->sync) {
D_INFO( "DirectFB/Core: calling sync()...\n" );
direct_sync();
}
if (dfb_config->core_sighandler)
direct_signal_handler_add( DIRECT_SIGNAL_ANY, dfb_core_signal_handler, core, &core->signal_handler );
if (fusion_arena_enter( core->world, "DirectFB/Core",
dfb_core_arena_initialize, dfb_core_arena_join,
core, &core->arena, &ret ) || ret)
{
ret = ret ? ret : DFB_FUSION;
goto error;
}
shared = core->shared;
D_MAGIC_ASSERT( shared, CoreDFBShared );
if (dfb_config->block_all_signals)
direct_signals_block_all();
if (dfb_config->deinit_check)
direct_cleanup_handler_add( dfb_core_deinit_check, NULL, &core->cleanup_handler );
fusion_skirmish_prevail( &shared->lock );
if (!core->master) {
while (!shared->active)
fusion_skirmish_wait( &shared->lock, 0 );
}
fusion_skirmish_dismiss( &shared->lock );
dfb_font_manager_create( core, &core->font_manager );
*ret_core = core;
pthread_mutex_unlock( &core_dfb_lock );
D_DEBUG_AT( DirectFB_Core, "Core successfully created.\n" );
return DFB_OK;
error:
if (core) {
if (core->world)
fusion_exit( core->world, false );
if (core->init_handler)
direct_thread_remove_init_handler( core->init_handler );
if (core->signal_handler)
direct_signal_handler_remove( core->signal_handler );
D_MAGIC_CLEAR( core );
D_FREE( core );
core_dfb = NULL;
}
pthread_mutex_unlock( &core_dfb_lock );
direct_shutdown();
return ret;
}
static DFBResult
IDirectFBImageProvider_JPEG2000_RenderTo( IDirectFBImageProvider *thiz,
IDirectFBSurface *destination,
const DFBRectangle *dest_rect )
{
IDirectFBSurface_data *dst_data;
CoreSurface *dst_surface;
CoreSurfaceBufferLock lock;
DFBRectangle rect;
DFBRegion clip;
DIRenderCallbackResult cb_result = DIRCR_OK;
DFBResult ret = DFB_OK;
DIRECT_INTERFACE_GET_DATA( IDirectFBImageProvider_JPEG2000 )
if (!destination)
return DFB_INVARG;
dst_data = destination->priv;
if (!dst_data || !dst_data->surface)
return DFB_DESTROYED;
dst_surface = dst_data->surface;
if (dest_rect) {
if (dest_rect->w < 1 || dest_rect->h < 1)
return DFB_INVARG;
rect = *dest_rect;
rect.x += dst_data->area.wanted.x;
rect.y += dst_data->area.wanted.y;
}
else {
rect = dst_data->area.wanted;
}
dfb_region_from_rectangle( &clip, &dst_data->area.current );
if (!dfb_rectangle_region_intersects( &rect, &clip ))
return DFB_OK;
ret = dfb_surface_lock_buffer( dst_surface, CSBR_BACK, CSAID_CPU, CSAF_WRITE, &lock );
if (ret)
return ret;
if (!data->buf) {
int cmptlut[3];
int width, height;
int tlx, tly;
int hs, vs;
int i, j;
bool direct, mono;
if (jas_image_numcmpts(data->image) > 1) {
cmptlut[0] = jas_image_getcmptbytype(data->image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
cmptlut[1] = jas_image_getcmptbytype(data->image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
cmptlut[2] = jas_image_getcmptbytype(data->image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
if (cmptlut[0] < 0 || cmptlut[1] < 0 || cmptlut[2] < 0) {
dfb_surface_unlock_buffer( dst_surface, &lock );
return DFB_UNSUPPORTED;
}
mono = false;
}
else {
cmptlut[0] = cmptlut[1] = cmptlut[2] = 0;
mono = true;
}
width = jas_image_width(data->image);
height = jas_image_height(data->image);
tlx = jas_image_cmpttlx(data->image, 0);
tly = jas_image_cmpttly(data->image, 0);
hs = jas_image_cmpthstep(data->image, 0);
vs = jas_image_cmptvstep(data->image, 0);
data->buf = D_MALLOC( width*height*4 );
if (!data->buf) {
dfb_surface_unlock_buffer( dst_surface, &lock );
return D_OOM();
}
direct = (rect.w == width && rect.h == height && data->render_callback);
#define GET_SAMPLE( n, x, y ) ({ \
int _s; \
_s = jas_image_readcmptsample(data->image, cmptlut[n], x, y); \
_s >>= jas_image_cmptprec(data->image, cmptlut[n]) - 8; \
if (_s > 255) \
_s = 255; \
else if (_s < 0) \
_s = 0; \
_s; \
})
for (i = 0; i < height; i++) {
u32 *dst = data->buf + i * width;
int x, y;
y = (i - tly) / vs;
if (y >= 0 && y < height) {
for (j = 0; j < width; j++) {
x = (j - tlx) / hs;
if (x >= 0 && x < width) {
unsigned int r, g, b;
if (mono) {
r = g = b = GET_SAMPLE(0, x, y);
}
else {
r = GET_SAMPLE(0, x, y);
g = GET_SAMPLE(1, x, y);
b = GET_SAMPLE(2, x, y);
}
*dst++ = 0xff000000 | (r << 16) | (g << 8) | b;
}
else {
*dst++ = 0;
}
}
}
else {
memset( dst, 0, width*4 );
}
if (direct) {
DFBRectangle r = { rect.x, rect.y+i, width, 1 };
dfb_copy_buffer_32( data->buf + i*width,
lock.addr, lock.pitch, &r, dst_surface, &clip );
if (data->render_callback) {
r = (DFBRectangle) { 0, i, width, 1 };
cb_result = data->render_callback( &r, data->render_callback_ctx );
if (cb_result != DIRCR_OK)
break;
}
}
}
if (!direct) {
dfb_scale_linear_32( data->buf, width, height,
lock.addr, lock.pitch, &rect, dst_surface, &clip );
if (data->render_callback) {
DFBRectangle r = { 0, 0, width, height };
data->render_callback( &r, data->render_callback_ctx );
}
}
if (cb_result != DIRCR_OK) {
D_FREE( data->buf );
data->buf = NULL;
ret = DFB_INTERRUPTED;
}
}
else {
int width = jas_image_width(data->image);
int height = jas_image_height(data->image);
dfb_scale_linear_32( data->buf, width, height,
lock.addr, lock.pitch, &rect, dst_surface, &clip );
if (data->render_callback) {
DFBRectangle r = {0, 0, width, height};
data->render_callback( &r, data->render_callback_ctx );
}
}
dfb_surface_unlock_buffer( dst_surface, &lock );
return ret;
}
static DFBResult
driver_open_device( CoreInputDevice *device,
unsigned int number,
InputDeviceInfo *info,
void **driver_data )
{
int fd;
char buttons, axes;
JoystickData *data;
char devicename[20];
/* open the right device */
snprintf( devicename, 20, "/dev/js%d", number );
fd = open( devicename, O_RDONLY );
if (fd < 0) {
/* try new-style device names */
snprintf( devicename, 20, "/dev/input/js%d", number );
fd = open( devicename, O_RDONLY );
if (fd < 0) {
D_PERROR( "DirectFB/Joystick: Could not open `%s'!\n",
devicename );
return DFB_INIT; /* no joystick available */
}
}
/* query number of buttons and axes */
if (ioctl( fd, JSIOCGBUTTONS, &buttons ) == -1)
buttons = 0;
if (ioctl( fd, JSIOCGAXES, &axes ) == -1)
axes = 0;
/* fill device info structure */
snprintf( info->desc.name,
DFB_INPUT_DEVICE_DESC_NAME_LENGTH, "Joystick" );
snprintf( info->desc.vendor,
DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH, "Unknown" );
info->prefered_id = DIDID_JOYSTICK;
info->desc.type = DIDTF_JOYSTICK;
#ifndef DIRECTFB_DISABLE_DEPRECATED
info->desc.caps = DICAPS_AXES | DICAPS_BUTTONS;
#else
info->desc.caps = DIDCAPS_AXES | DIDCAPS_BUTTONS;
#endif
info->desc.max_button = buttons - 1;
info->desc.max_axis = axes - 1;
/* allocate and fill private data */
data = D_CALLOC( 1, sizeof(JoystickData) );
if (!data) {
close( fd );
return D_OOM();
}
data->fd = fd;
data->device = device;
/* start input thread */
data->thread = direct_thread_create( DTT_INPUT, joystickEventThread, data, "Joystick Input" );
/* set private data pointer */
*driver_data = data;
return DFB_OK;
}
DFBResult
ILayerRegion_Requestor::FlipUpdate2(
const DFBRegion *left_update,
const DFBRegion *right_update,
DFBSurfaceFlipFlags flags,
s64 pts
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreLayerRegionFlipUpdate2 *args = (CoreLayerRegionFlipUpdate2*) args_alloc( args_static, sizeof(CoreLayerRegionFlipUpdate2) );
CoreLayerRegionFlipUpdate2Return *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreLayerRegionFlipUpdate2Return*) args_alloc( return_args_static, sizeof(CoreLayerRegionFlipUpdate2Return) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreLayerRegion, "ILayerRegion_Requestor::%s()\n", __FUNCTION__ );
if (left_update) {
args->left_update = *left_update;
args->left_update_set = true;
}
else
args->left_update_set = false;
if (right_update) {
args->right_update = *right_update;
args->right_update_set = true;
}
else
args->right_update_set = false;
args->flags = flags;
args->pts = pts;
ret = (DFBResult) CoreLayerRegion_Call( obj, FCEF_NONE, CoreLayerRegion_FlipUpdate2, args, sizeof(CoreLayerRegionFlipUpdate2), return_args, sizeof(CoreLayerRegionFlipUpdate2Return), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreLayerRegion_Call( CoreLayerRegion_FlipUpdate2 ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreLayerRegion_FlipUpdate2 failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
