static int
Packet_Write( Packet *packet,
int type,
int msg_id,
int channel,
const void *msg_data,
int msg_size,
const void *extra_data,
int extra_size,
bool from_user )
{
size_t total = sizeof(FusionReadMessage) + msg_size + extra_size;
size_t aligned = (total + 3) & ~3;
FusionReadMessage *header = (FusionReadMessage *)( packet->buf + packet->size );
FUSION_DEBUG( "%s( %p, msg_id %d, channel %d, size %d, extra %d, total %zu )\n",
__FUNCTION__, packet, msg_id, channel, msg_size, extra_size, total );
D_MAGIC_ASSERT( packet, Packet );
FUSION_ASSERT( packet->size + aligned <= FUSION_MAX_PACKET_SIZE );
header->msg_type = type;
header->msg_id = msg_id;
header->msg_channel = channel;
header->msg_size = msg_size + extra_size;
if (from_user) {
if (copy_from_user( header + 1, msg_data, msg_size ))
return -EFAULT;
}
else
memcpy( header + 1, msg_data, msg_size );
if (extra_data && extra_size) {
if (copy_from_user( (char*)(header + 1) + msg_size, extra_data, extra_size ))
return -EFAULT;
}
while (total < aligned)
packet->buf[packet->size + total++] = 0;
packet->size += aligned;
return 0;
}
static DFBResult
sharedDeallocateBuffer( CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
CoreSurfaceBuffer *buffer,
CoreSurfaceAllocation *allocation,
void *alloc_data )
{
SharedPoolData *data = pool_data;
SharedAllocationData *alloc = alloc_data;
D_MAGIC_ASSERT( pool, CoreSurfacePool );
SHFREE( data->shmpool, alloc->addr );
return DFB_OK;
}
static DFBResult
x11InitPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data,
CoreSurfacePoolDescription *ret_desc )
{
DFBResult ret;
x11PoolLocalData *local = pool_local;
DFBX11 *x11 = system_data;
D_DEBUG_AT( X11_Surfaces, "%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_ASSERT( ret_desc != NULL );
local->x11 = x11;
ret_desc->caps = CSPCAPS_NONE;
ret_desc->types = CSTF_LAYER | CSTF_WINDOW | CSTF_SHARED | CSTF_EXTERNAL;
ret_desc->priority = CSPP_ULTIMATE;
/* For showing our X11 window */
ret_desc->access[CSAID_LAYER0] = CSAF_READ;
ret_desc->access[CSAID_LAYER1] = CSAF_READ;
ret_desc->access[CSAID_LAYER2] = CSAF_READ;
snprintf( ret_desc->name, DFB_SURFACE_POOL_DESC_NAME_LENGTH, "X11 Windows" );
ret = direct_hash_create( 7, &local->hash );
if (ret) {
D_DERROR( ret, "X11/Surfaces: Could not create local hash table!\n" );
return ret;
}
pthread_mutex_init( &local->lock, NULL );
int event_base_return, error_base_return;
XLockDisplay( x11->display );
XCompositeQueryExtension( x11->display, &event_base_return, &error_base_return );
x11->Sync( x11 );
XUnlockDisplay( x11->display );
return DFB_OK;
}
void
VoodooInstance::Release()
{
D_DEBUG_AT( Voodoo_Instance, "VoodooInstance::%s( %p )\n", __func__, this );
D_MAGIC_ASSERT( this, VoodooInstance );
D_ASSERT( refs > 0 );
if (!--refs) {
D_DEBUG_AT( Voodoo_Instance, " -> zero refs, deleting instance...\n" );
#ifndef WIN32 //FIXME: why does delete this crash with MSVC?
delete this;
#endif
}
}
DFBResult
unique_decoration_notify( UniqueDecoration *decoration,
UniqueDecorationNotificationFlags flags )
{
UniqueDecorationNotification notification;
D_MAGIC_ASSERT( decoration, UniqueDecoration );
D_ASSERT( flags != UDNF_NONE );
D_ASSERT( ! (flags & ~UDNF_ALL) );
notification.flags = flags;
notification.decoration = decoration;
return unique_decoration_dispatch( decoration, ¬ification, unique_decoration_globals );
}
static DFBResult
dfb_clipboard_core_join( CoreDFB *core,
DFBClipboardCore *data,
DFBClipboardCoreShared *shared )
{
D_DEBUG_AT( Core_Clipboard, "dfb_clipboard_core_join( %p, %p, %p )\n", core, data, shared );
D_ASSERT( data != NULL );
D_MAGIC_ASSERT( shared, DFBClipboardCoreShared );
data->core = core;
data->shared = shared;
D_MAGIC_SET( data, DFBClipboardCore );
return DFB_OK;
}
DFBResult
dfb_surface_set_field( CoreSurface *surface,
int field )
{
D_MAGIC_ASSERT( surface, CoreSurface );
if (fusion_skirmish_prevail( &surface->lock ))
return DFB_FUSION;
surface->field = field;
dfb_surface_notify( surface, CSNF_FIELD );
fusion_skirmish_dismiss( &surface->lock );
return DFB_OK;
}
void
fusion_vector_destroy( FusionVector *vector )
{
D_MAGIC_ASSERT( vector, FusionVector );
D_ASSERT( vector->count == 0 || vector->elements != NULL );
if (vector->elements) {
if (vector->pool)
SHFREE( vector->pool, vector->elements );
else
D_FREE( vector->elements );
vector->elements = NULL;
}
D_MAGIC_CLEAR( vector );
}
static DFBResult
x11LeavePool( CoreSurfacePool *pool,
void *pool_data,
void *pool_local )
{
x11PoolLocalData *local = pool_local;
D_DEBUG_AT( X11_Surfaces, "%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
pthread_mutex_destroy( &local->lock );
direct_hash_destroy( local->hash );
return DFB_OK;
}
DFBResult
dfb_surface_unlock_buffer( CoreSurface *surface,
CoreSurfaceBufferLock *lock )
{
DFBResult ret;
D_MAGIC_ASSERT( surface, CoreSurface );
if (fusion_skirmish_prevail( &surface->lock ))
return DFB_FUSION;
ret = dfb_surface_buffer_unlock( lock );
fusion_skirmish_dismiss( &surface->lock );
return ret;
}
DFBResult
dfb_state_set_source_2( CardState *state,
CoreSurface *source,
u32 flip_count )
{
D_MAGIC_ASSERT( state, CardState );
dfb_state_lock( state );
if (state->source != source || state->source_flip_count != flip_count || !state->source_flip_count_used) {
bool ref = true;//!fusion_config->secure_fusion || dfb_core_is_master( core_dfb );
if (source && ref && dfb_surface_ref( source )) {
D_WARN( "could not ref() source" );
dfb_state_unlock( state );
return DFB_DEAD;
}
if (state->source) {
D_ASSERT( D_FLAGS_IS_SET( state->flags, CSF_SOURCE ) );
if (ref)
dfb_surface_unref( state->source );
}
state->source = source;
state->modified |= SMF_SOURCE;
state->source_flip_count = flip_count;
state->source_flip_count_used = true;
if (source) {
direct_serial_copy( &state->src_serial, &source->serial );
D_FLAGS_SET( state->flags, CSF_SOURCE );
}
else
D_FLAGS_CLEAR( state->flags, CSF_SOURCE );
}
dfb_state_unlock( state );
return DFB_OK;
}
DirectResult
voodoo_manager_destroy( VoodooManager *manager )
{
D_MAGIC_ASSERT( manager, VoodooManager );
D_DEBUG( "Voodoo/Manager: Destroying manager at %p!\n", manager );
if (!manager->quit)
voodoo_manager_quit( manager );
/* Wait for manager threads exiting. */
direct_thread_join( manager->input.thread );
direct_thread_destroy( manager->input.thread );
direct_thread_join( manager->dispatcher );
direct_thread_destroy( manager->dispatcher );
direct_thread_join( manager->output.thread );
direct_thread_destroy( manager->output.thread );
/* Destroy conditions. */
pthread_cond_destroy( &manager->input.wait );
pthread_cond_destroy( &manager->response.wait );
pthread_cond_destroy( &manager->output.wait );
/* Destroy locks. */
pthread_mutex_destroy( &manager->instances.lock );
pthread_mutex_destroy( &manager->input.lock );
pthread_mutex_destroy( &manager->response.lock );
pthread_mutex_destroy( &manager->output.lock );
/* Release all remaining interfaces. */
direct_hash_iterate( manager->instances.local, instance_iterator, (void*) false );
direct_hash_iterate( manager->instances.local, instance_iterator, (void*) true );
direct_hash_destroy( manager->instances.local );
direct_hash_destroy( manager->instances.remote );
D_MAGIC_CLEAR( manager );
/* Deallocate manager structure. */
D_FREE( manager );
return DR_OK;
}
void
direct_thread_cancel( DirectThread *thread )
{
D_MAGIC_ASSERT( thread, DirectThread );
D_ASSERT( thread->handle.thread != -1 );
D_ASSERT( !pthread_equal( thread->handle.thread, pthread_self() ) );
D_ASSUME( !thread->canceled );
D_DEBUG_AT( Direct_Thread, "%s( %p, '%s' %d )\n", __FUNCTION__, thread->main, thread->name, thread->tid );
thread->canceled = true;
#ifndef DIRECT_BUILD_NO_PTHREAD_CANCEL
pthread_cancel( thread->handle.thread );
#else
D_UNIMPLEMENTED();
#endif
}
static DFBResult
wm_request_focus( CoreWindow *window,
void *wm_data,
void *window_data )
{
WindowData *data = window_data;
D_ASSERT( window != NULL );
D_ASSERT( wm_data != NULL );
D_ASSERT( window_data != NULL );
D_MAGIC_ASSERT( data, WindowData );
if (!data->window)
return DFB_DESTROYED;
return unique_window_request_focus( data->window );
}
static DFBResult
wm_flush_keys( CoreWindowStack *stack,
void *wm_data,
void *stack_data )
{
StackData *data = stack_data;
D_ASSERT( stack != NULL );
D_ASSERT( wm_data != NULL );
D_ASSERT( stack_data != NULL );
D_MAGIC_ASSERT( data, StackData );
if (!data->context)
return DFB_DESTROYED;
return unique_context_flush_keys( data->context );
}
void
VoodooConnectionLink::PutPacket( VoodooPacket *packet, bool flush )
{
D_DEBUG_AT( Voodoo_Connection, "VoodooConnectionLink::%s( %p, %sflush )\n", __func__, this, flush ? "" : "NO " );
D_MAGIC_ASSERT( this, VoodooConnection );
Packets *packets = (Packets*) direct_tls_get( output.tls );
D_ASSERT( packets != NULL );
D_ASSERT( packet == packets->active );
if (flush) {
Flush( packet );
packets->active = NULL;
}
}
void
direct_thread_notify( DirectThread *thread )
{
D_MAGIC_ASSERT( thread, DirectThread );
D_ASSERT( thread->thread != -1 );
D_ASSUME( !thread->canceled );
D_DEBUG_AT( Direct_Thread, "%s( %p, '%s' %d )\n", __FUNCTION__, thread->main, thread->name, thread->tid );
pthread_mutex_lock( &thread->lock );
thread->counter++;
pthread_mutex_unlock( &thread->lock );
pthread_cond_broadcast( &thread->cond );
}
DirectResult
fusion_property_init (FusionProperty *property, const FusionWorld *world)
{
D_ASSERT( property != NULL );
D_MAGIC_ASSERT( world, FusionWorld );
/* Set state to available. */
property->multi.builtin.state = FUSION_PROPERTY_AVAILABLE;
property->multi.builtin.owner = 0;
property->multi.builtin.requested = false;
property->multi.builtin.destroyed = false;
/* Keep back pointer to shared world data. */
property->multi.shared = world->shared;
return DR_OK;
}
DirectResult
fusion_vector_remove( FusionVector *vector,
int index )
{
D_MAGIC_ASSERT( vector, FusionVector );
D_ASSERT( index >= 0 );
D_ASSERT( index < vector->count );
/* Move elements after this element one down. */
memmove( &vector->elements[ index ],
&vector->elements[ index + 1 ],
(vector->count - index - 1) * sizeof(void*) );
/* Decrease the element counter. */
vector->count--;
return DR_OK;
}
void
DirectUnregisterInterface( DirectInterfaceFuncs *funcs )
{
DirectInterfaceImplementation *impl;
D_DEBUG_AT( Direct_Interface, "%s( %p )\n", __FUNCTION__, funcs );
direct_mutex_lock( &implementations_mutex );
direct_list_foreach (impl, implementations) {
D_MAGIC_ASSERT( impl, DirectInterfaceImplementation );
if (impl->funcs == funcs) {
direct_list_remove( &implementations, &impl->link );
break;
}
}
void
dfb_state_set_matrix( CardState *state,
const s32 *matrix )
{
D_MAGIC_ASSERT( state, CardState );
D_ASSERT( matrix != NULL );
if (memcmp( state->matrix, matrix, sizeof(state->matrix) )) {
direct_memcpy( state->matrix, matrix, sizeof(state->matrix) );
state->affine_matrix = (matrix[6] == 0x00000 &&
matrix[7] == 0x00000 &&
matrix[8] == 0x10000);
state->modified |= SMF_MATRIX;
}
}
DFBResult
IWindow_Real::SetCursorPosition( int x,
int y )
{
DFBResult ret;
D_DEBUG_AT( Core_Window, "IWindow_Real::%s( %p )\n", __FUNCTION__, obj );
D_MAGIC_ASSERT( obj, CoreWindow );
dfb_windowstack_lock( obj->stack );
ret = dfb_wm_set_cursor_position( obj, x, y );
dfb_windowstack_unlock( obj->stack );
return ret;
}
static DFBResult
stmfbdevLock (CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
CoreSurfaceAllocation *allocation,
void *alloc_data,
CoreSurfaceBufferLock *lock)
{
const STMfbdevPoolData * const data = pool_data;
const STMfbdevPoolLocalData * const local = pool_local;
const STMfbdevPoolAllocationData * const alloc = alloc_data;
const Chunk *chunk;
D_DEBUG_AT (STMfbdev_SurfLock, "%s (%p)\n", __FUNCTION__, lock->buffer);
D_MAGIC_ASSERT (pool, CoreSurfacePool);
D_MAGIC_ASSERT (data, STMfbdevPoolData);
D_MAGIC_ASSERT (local, STMfbdevPoolLocalData);
D_MAGIC_ASSERT (allocation, CoreSurfaceAllocation);
D_MAGIC_ASSERT (alloc, STMfbdevPoolAllocationData);
D_MAGIC_ASSERT (lock, CoreSurfaceBufferLock);
D_MAGIC_ASSERT (alloc->chunk, Chunk);
chunk = alloc->chunk;
#if D_DEBUG_ENABLED
{
/* heavy performance hit */
char *accessor = _accessor_str (lock->accessor);
char *access = _access_str (lock->access);
D_DEBUG_AT (STMfbdev_SurfLock, " -> by %s for %s\n", accessor, access);
free (access);
free (accessor);
}
#endif
lock->pitch = chunk->pitch;
lock->offset = chunk->offset;
lock->addr = local->mem + chunk->offset;
lock->phys = data->physical + chunk->offset;
D_DEBUG_AT (STMfbdev_SurfLock,
" -> offset 0x%.8lx (%lu), pitch %d, addr %p, phys 0x%.8lx\n",
lock->offset, lock->offset, lock->pitch, lock->addr, lock->phys);
return DFB_OK;
}
static int
dfb_core_join( CoreDFB *core )
{
int i;
D_MAGIC_ASSERT( core, CoreDFB );
for (i=0; i<D_ARRAY_SIZE(core_parts); i++) {
DFBResult ret;
if ((ret = dfb_core_part_join( core, core_parts[i] ))) {
dfb_core_leave( core, true );
return ret;
}
}
return DFB_OK;
}
DirectResult
direct_signal_handler_remove( DirectSignalHandler *handler )
{
D_MAGIC_ASSERT( handler, DirectSignalHandler );
D_DEBUG_AT( Direct_Signals, "Removing handler %p for signal %d with context %p...\n",
handler->func, handler->num, handler->ctx );
direct_mutex_lock( &handlers_lock );
direct_list_remove( &handlers, &handler->link );
direct_mutex_unlock( &handlers_lock );
D_MAGIC_CLEAR( handler );
D_FREE( handler );
return DR_OK;
}
DirectResult
direct_log_destroy( DirectLog *log )
{
D_MAGIC_ASSERT( log, DirectLog );
D_ASSERT( &fallback_log != log );
if (log == default_log)
default_log = NULL;
close( log->fd );
D_MAGIC_CLEAR( log );
D_FREE( log );
return DR_OK;
}
static DFBResult
fbdevInitPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data,
CoreSurfacePoolDescription *ret_desc )
{
DFBResult ret;
FBDevPoolData *data = pool_data;
FBDevPoolLocalData *local = pool_local;
D_DEBUG_AT( FBDev_Surfaces, "%s()\n", __FUNCTION__ );
D_ASSERT( core != NULL );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_ASSERT( data != NULL );
D_ASSERT( local != NULL );
D_ASSERT( ret_desc != NULL );
ret = dfb_surfacemanager_create( core, dfb_fbdev->shared->fix.smem_len, &data->manager );
if (ret)
return ret;
ret_desc->caps = CSPCAPS_NONE;
ret_desc->access = CSAF_CPU_READ | CSAF_CPU_WRITE | CSAF_GPU_READ | CSAF_GPU_WRITE | CSAF_SHARED;
ret_desc->types = CSTF_LAYER | CSTF_WINDOW | CSTF_CURSOR | CSTF_FONT | CSTF_SHARED | CSTF_EXTERNAL;
ret_desc->priority = CSPP_DEFAULT;
snprintf( ret_desc->name, DFB_SURFACE_POOL_DESC_NAME_LENGTH, "Frame Buffer Memory" );
local->core = core;
D_MAGIC_SET( data, FBDevPoolData );
D_MAGIC_SET( local, FBDevPoolLocalData );
D_ASSERT( dfb_fbdev != NULL );
D_ASSERT( dfb_fbdev->shared != NULL );
dfb_fbdev->shared->manager = data->manager;
return DFB_OK;
}
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;
}
static int
dfb_core_arena_leave( FusionArena *arena,
void *ctx,
bool emergency)
{
DFBResult ret;
CoreDFB *core = ctx;
D_MAGIC_ASSERT( core, CoreDFB );
D_DEBUG_AT( DirectFB_Core, "Leaving...\n" );
/* Leave. */
ret = dfb_core_leave( core, emergency );
if (ret)
return ret;
return DFB_OK;
}
DFBResult
x11ImageDestroy( x11Image *image )
{
int ret;
D_MAGIC_ASSERT( image, x11Image );
if (fusion_call_execute( &dfb_x11->call, FCEF_NONE, X11_IMAGE_DESTROY, image, &ret ))
return DFB_FUSION;
if (ret) {
D_DERROR( ret, "X11/Image: X11_IMAGE_DESTROY call failed!\n" );
return ret;
}
D_MAGIC_CLEAR( image );
return DFB_OK;
}
