DFBResult
dfb_layer_region_get_surface( CoreLayerRegion *region,
CoreSurface **ret_surface )
{
D_ASSERT( region != NULL );
D_ASSERT( ret_surface != NULL );
/* Lock the region. */
if (dfb_layer_region_lock( region ))
return DFB_FUSION;
D_ASSUME( region->surface != NULL );
/* Check for NULL surface. */
if (!region->surface) {
dfb_layer_region_unlock( region );
return DFB_UNSUPPORTED;
}
/* Increase the surface's reference counter. */
if (dfb_surface_ref( region->surface )) {
dfb_layer_region_unlock( region );
return DFB_FUSION;
}
/* Return the surface. */
*ret_surface = region->surface;
/* Unlock the region. */
dfb_layer_region_unlock( region );
return DFB_OK;
}
DFBResult
dfb_layer_region_disable( CoreLayerRegion *region )
{
DFBResult ret;
D_ASSERT( region != NULL );
/* Lock the region. */
if (dfb_layer_region_lock( region ))
return DFB_FUSION;
D_ASSUME( D_FLAGS_IS_SET( region->state, CLRSF_ENABLED ) );
if (! D_FLAGS_IS_SET( region->state, CLRSF_ENABLED )) {
dfb_layer_region_unlock( region );
return DFB_OK;
}
/* Unrealize the region if it's active. */
if (D_FLAGS_IS_SET( region->state, CLRSF_ACTIVE )) {
ret = unrealize_region( region );
if (ret)
return ret;
}
/* Update the region's state. */
D_FLAGS_CLEAR( region->state, CLRSF_ENABLED );
/* Unlock the region. */
dfb_layer_region_unlock( region );
return DFB_OK;
}
DFBResult
dfb_layer_region_set_surface( CoreLayerRegion *region,
CoreSurface *surface )
{
DFBResult ret;
D_ASSERT( region != NULL );
D_ASSERT( surface != NULL );
/* Lock the region. */
if (dfb_layer_region_lock( region ))
return DFB_FUSION;
if (region->surface != surface) {
/* Setup hardware for the new surface if the region is realized. */
if (D_FLAGS_IS_SET( region->state, CLRSF_REALIZED )) {
ret = set_region( region, ®ion->config, CLRCF_SURFACE | CLRCF_PALETTE, surface );
if (ret) {
dfb_layer_region_unlock( region );
return ret;
}
}
/* Throw away the old surface. */
if (region->surface) {
/* Detach the global listener. */
dfb_surface_detach_global( region->surface,
®ion->surface_reaction );
/* Unlink surface from structure. */
dfb_surface_unlink( ®ion->surface );
}
/* Take the new surface. */
if (surface) {
/* Link surface into structure. */
if (dfb_surface_link( ®ion->surface, surface )) {
D_WARN( "region lost it's surface" );
dfb_layer_region_unlock( region );
return DFB_FUSION;
}
/* Attach the global listener. */
dfb_surface_attach_global( region->surface,
DFB_LAYER_REGION_SURFACE_LISTENER,
region, ®ion->surface_reaction );
}
}
/* Unlock the region. */
dfb_layer_region_unlock( region );
return DFB_OK;
}
static void
handle_expose( const XExposeEvent *expose )
{
CoreLayer *layer = 0;
const DisplayLayerFuncs *funcs = 0;
CoreLayerContext *context;
int i;
/* find the correct layer */
for( i=0; i<dfb_layer_num(); i++ ) {
X11LayerData *lds;
layer = dfb_layer_at( i );
lds = (X11LayerData*)(layer->layer_data);
if( lds->xw && (lds->xw->window == expose->window) )
break;
}
/* layer not found? */
if( i==dfb_layer_num() )
return;
funcs = layer->funcs;
D_ASSERT( funcs != NULL );
D_ASSERT( funcs->UpdateRegion != NULL );
/* Get the currently active context. */
if (dfb_layer_get_active_context( layer, &context ) == DFB_OK) {
CoreLayerRegion *region;
/* Get the first region. */
if (dfb_layer_context_get_primary_region( context,
false, ®ion ) == DFB_OK)
{
/* Lock the region to avoid tearing due to concurrent updates. */
dfb_layer_region_lock( region );
/* Get the surface of the region. */
if (region->surface && region->left_buffer_lock.buffer) {
DFBRegion update = { expose->x, expose->y,
expose->x + expose->width - 1,
expose->y + expose->height - 1 };
funcs->UpdateRegion( layer, layer->driver_data, layer->layer_data,
region->region_data, region->surface, &update, ®ion->left_buffer_lock, NULL, NULL );
}
/* Unlock the region. */
dfb_layer_region_unlock( region );
/* Release the region. */
dfb_layer_region_unref( region );
}
/* Release the context. */
dfb_layer_context_unref( context );
}
}
DFBResult
dfb_layer_region_get_configuration( CoreLayerRegion *region,
CoreLayerRegionConfig *config )
{
D_ASSERT( region != NULL );
D_ASSERT( config != NULL );
D_ASSERT( D_FLAGS_IS_SET( region->state, CLRSF_CONFIGURED ) );
/* Lock the region. */
if (dfb_layer_region_lock( region ))
return DFB_FUSION;
/* Return the current configuration. */
*config = region->config;
/* Unlock the region. */
dfb_layer_region_unlock( region );
return DFB_OK;
}
/*
* listen to the layer's surface
*/
ReactionResult
_dfb_layer_region_surface_listener( const void *msg_data, void *ctx )
{
CoreSurfaceNotificationFlags flags;
CoreSurface *surface;
CoreLayer *layer;
CoreLayerShared *shared;
DisplayLayerFuncs *funcs;
const CoreSurfaceNotification *notification = msg_data;
CoreLayerRegion *region = ctx;
D_ASSERT( notification != NULL );
D_ASSERT( region != NULL );
D_ASSERT( region->context != NULL );
D_DEBUG_AT( Core_Layers, "_dfb_layer_region_surface_listener( %p, %p ) <- 0x%08x\n",
notification, region, notification->flags );
D_ASSERT( notification->surface != NULL );
D_ASSUME( notification->surface == region->surface );
if (notification->surface != region->surface)
return RS_OK;
layer = dfb_layer_at( region->context->layer_id );
D_ASSERT( layer != NULL );
D_ASSERT( layer->funcs != NULL );
D_ASSERT( layer->funcs->SetRegion != NULL );
D_ASSERT( layer->shared != NULL );
funcs = layer->funcs;
shared = layer->shared;
flags = notification->flags;
surface = notification->surface;
if (flags & CSNF_DESTROY) {
D_WARN( "layer region surface destroyed" );
region->surface = NULL;
return RS_REMOVE;
}
if (dfb_layer_region_lock( region ))
return RS_OK;
if (D_FLAGS_ARE_SET( region->state, CLRSF_REALIZED | CLRSF_CONFIGURED )) {
if (D_FLAGS_IS_SET( flags, CSNF_PALETTE_CHANGE | CSNF_PALETTE_UPDATE )) {
if (surface->palette)
funcs->SetRegion( layer,
layer->driver_data, layer->layer_data,
region->region_data, ®ion->config,
CLRCF_PALETTE, surface, surface->palette );
}
if ((flags & CSNF_FIELD) && funcs->SetInputField)
funcs->SetInputField( layer,
layer->driver_data, layer->layer_data,
region->region_data, surface->field );
if ((flags & CSNF_ALPHA_RAMP) && (shared->description.caps & DLCAPS_ALPHA_RAMP)) {
region->config.alpha_ramp[0] = surface->alpha_ramp[0];
region->config.alpha_ramp[1] = surface->alpha_ramp[1];
region->config.alpha_ramp[2] = surface->alpha_ramp[2];
region->config.alpha_ramp[3] = surface->alpha_ramp[3];
funcs->SetRegion( layer,
layer->driver_data, layer->layer_data,
region->region_data, ®ion->config,
CLRCF_ALPHA_RAMP, surface, surface->palette );
}
}
dfb_layer_region_unlock( region );
return RS_OK;
}
DFBResult
dfb_layer_region_set_configuration( CoreLayerRegion *region,
CoreLayerRegionConfig *config,
CoreLayerRegionConfigFlags flags )
{
DFBResult ret;
CoreLayer *layer;
DisplayLayerFuncs *funcs;
CoreLayerRegionConfig new_config;
D_ASSERT( region != NULL );
D_ASSERT( region->context != NULL );
D_ASSERT( config != NULL );
D_ASSERT( config->buffermode != DLBM_WINDOWS );
D_ASSERT( (flags == CLRCF_ALL) || (region->state & CLRSF_CONFIGURED) );
D_ASSUME( flags != CLRCF_NONE );
D_ASSUME( ! (flags & ~CLRCF_ALL) );
layer = dfb_layer_at( region->context->layer_id );
D_ASSERT( layer != NULL );
D_ASSERT( layer->funcs != NULL );
D_ASSERT( layer->funcs->TestRegion != NULL );
funcs = layer->funcs;
/* Lock the region. */
if (dfb_layer_region_lock( region ))
return DFB_FUSION;
/* Full configuration supplied? */
if (flags == CLRCF_ALL) {
new_config = *config;
}
else {
/* Use the current configuration. */
new_config = region->config;
/* Update each modified entry. */
if (flags & CLRCF_WIDTH)
new_config.width = config->width;
if (flags & CLRCF_HEIGHT)
new_config.height = config->height;
if (flags & CLRCF_FORMAT)
new_config.format = config->format;
if (flags & CLRCF_SURFACE_CAPS)
new_config.surface_caps = config->surface_caps;
if (flags & CLRCF_BUFFERMODE)
new_config.buffermode = config->buffermode;
if (flags & CLRCF_OPTIONS)
new_config.options = config->options;
if (flags & CLRCF_SOURCE_ID)
new_config.source_id = config->source_id;
if (flags & CLRCF_SOURCE)
new_config.source = config->source;
if (flags & CLRCF_DEST)
new_config.dest = config->dest;
if (flags & CLRCF_OPACITY)
new_config.opacity = config->opacity;
if (flags & CLRCF_ALPHA_RAMP) {
new_config.alpha_ramp[0] = config->alpha_ramp[0];
new_config.alpha_ramp[1] = config->alpha_ramp[1];
new_config.alpha_ramp[2] = config->alpha_ramp[2];
new_config.alpha_ramp[3] = config->alpha_ramp[3];
}
if (flags & CLRCF_SRCKEY)
new_config.src_key = config->src_key;
if (flags & CLRCF_DSTKEY)
new_config.dst_key = config->dst_key;
if (flags & CLRCF_PARITY)
new_config.parity = config->parity;
}
/* Check if the new configuration is supported. */
ret = funcs->TestRegion( layer, layer->driver_data, layer->layer_data,
&new_config, NULL );
if (ret) {
dfb_layer_region_unlock( region );
return ret;
}
/* Propagate new configuration to the driver if the region is realized. */
if (D_FLAGS_IS_SET( region->state, CLRSF_REALIZED )) {
ret = set_region( region, &new_config, flags, region->surface );
if (ret) {
dfb_layer_region_unlock( region );
return ret;
}
}
/* Update the region's current configuration. */
region->config = new_config;
/* Update the region's state. */
D_FLAGS_SET( region->state, CLRSF_CONFIGURED );
/* Unlock the region. */
dfb_layer_region_unlock( region );
return DFB_OK;
}
DFBResult
dfb_layer_region_flip_update( CoreLayerRegion *region,
const DFBRegion *update,
DFBSurfaceFlipFlags flags )
{
DFBResult ret = DFB_OK;
CoreLayer *layer;
CoreLayerContext *context;
CoreSurface *surface;
SurfaceBuffer *buffer;
DisplayLayerFuncs *funcs;
if (update)
D_DEBUG_AT( Core_Layers,
"dfb_layer_region_flip_update( %p, %p, 0x%08x ) <- [%d, %d - %dx%d]\n",
region, update, flags, DFB_RECTANGLE_VALS_FROM_REGION( update ) );
else
D_DEBUG_AT( Core_Layers,
"dfb_layer_region_flip_update( %p, %p, 0x%08x )\n", region, update, flags );
D_ASSERT( region != NULL );
D_ASSERT( region->context != NULL );
/* Lock the region. */
if (dfb_layer_region_lock( region ))
return DFB_FUSION;
D_ASSUME( region->surface != NULL );
/* Check for NULL surface. */
if (!region->surface) {
D_DEBUG_AT( Core_Layers, " -> No surface => no update!\n" );
dfb_layer_region_unlock( region );
return DFB_UNSUPPORTED;
}
context = region->context;
surface = region->surface;
buffer = surface->back_buffer;
layer = dfb_layer_at( context->layer_id );
D_ASSERT( layer->funcs != NULL );
funcs = layer->funcs;
/* Depending on the buffer mode... */
switch (region->config.buffermode) {
case DLBM_TRIPLE:
case DLBM_BACKVIDEO:
/* Check if simply swapping the buffers is possible... */
if (!(flags & DSFLIP_BLIT) &&
(!update || (update->x1 == 0 &&
update->y1 == 0 &&
update->x2 == surface->width - 1 &&
update->y2 == surface->height - 1)))
{
D_DEBUG_AT( Core_Layers, " -> Going to swap buffers...\n" );
/* Use the driver's routine if the region is realized. */
if (D_FLAGS_IS_SET( region->state, CLRSF_REALIZED )) {
D_ASSUME( funcs->FlipRegion != NULL );
D_DEBUG_AT( Core_Layers, " -> Waiting for pending writes...\n" );
if (buffer->video.access & VAF_HARDWARE_WRITE) {
dfb_gfxcard_wait_serial( &buffer->video.serial );
buffer->video.access &= ~VAF_HARDWARE_WRITE;
}
D_DEBUG_AT( Core_Layers, " -> Flipping region using driver...\n" );
if (funcs->FlipRegion)
ret = funcs->FlipRegion( layer,
layer->driver_data,
layer->layer_data,
region->region_data,
surface, flags );
}
else {
D_DEBUG_AT( Core_Layers, " -> Flipping region not using driver...\n" );
/* Just do the hardware independent work. */
dfb_surface_flip_buffers( surface, false );
}
break;
}
/* fall through */
case DLBM_BACKSYSTEM:
D_DEBUG_AT( Core_Layers, " -> Going to copy portion...\n" );
if ((flags & DSFLIP_WAITFORSYNC) == DSFLIP_WAITFORSYNC) {
D_DEBUG_AT( Core_Layers, " -> Waiting for VSync...\n" );
dfb_layer_wait_vsync( layer );
}
D_DEBUG_AT( Core_Layers, " -> Copying content from back to front buffer...\n" );
/* ...or copy updated contents from back to front buffer. */
dfb_back_to_front_copy( surface, update );
if ((flags & DSFLIP_WAITFORSYNC) == DSFLIP_WAIT) {
D_DEBUG_AT( Core_Layers, " -> Waiting for VSync...\n" );
dfb_layer_wait_vsync( layer );
}
/* fall through */
case DLBM_FRONTONLY:
/* Tell the driver about the update if the region is realized. */
if (funcs->UpdateRegion && D_FLAGS_IS_SET( region->state, CLRSF_REALIZED )) {
D_DEBUG_AT( Core_Layers, " -> Notifying driver about updated content...\n" );
ret = funcs->UpdateRegion( layer,
layer->driver_data,
layer->layer_data,
region->region_data,
surface, update );
}
break;
default:
D_BUG("unknown buffer mode");
ret = DFB_BUG;
}
D_DEBUG_AT( Core_Layers, " -> done.\n" );
/* Unlock the region. */
dfb_layer_region_unlock( region );
return ret;
}
static void
handle_expose_Async( void *ctx,
void *ctx2 )
{
DFBX11 *x11 = ctx;
DFBX11Shared *shared = x11->shared;
const XExposeEvent *expose = ctx2;
CoreLayer *layer;
CoreLayerContext *context;
int i;
X11LayerData *lds;
D_DEBUG_AT( X11_Input, "%s( %d,%d-%dx%d )\n", __FUNCTION__, expose->x, expose->y, expose->width, expose->height );
//D_INFO_LINE_MSG("handle_expose %d,%d-%dx%d", expose->x, expose->y, expose->width, expose->height);
/* find the correct layer */
for (i=0; i<shared->outputs; i++) {
if (shared->output[i].xw && (shared->output[i].xw->window == expose->window))
break;
}
/* layer not found? */
if (i == shared->outputs)
return;
lds = shared->output[i].layers[0];
layer = dfb_layer_at( lds->layer_id );
D_ASSERT( layer != NULL );
/* Get the currently active context. */
if (dfb_layer_get_active_context( layer, &context ) == DFB_OK) {
CoreLayerRegion *region;
/* Get the first region. */
if (dfb_layer_context_get_primary_region( context, false, ®ion ) == DFB_OK) {
/* Lock the region. */
dfb_layer_region_lock( region );
/* Get the surface of the region. */
if (region->surface && D_FLAGS_ARE_SET( region->state, CLRSF_REALIZED )) {
if (dfb_config->task_manager) {
DFBRegion update = { expose->x, expose->y,
expose->x + expose->width - 1,
expose->y + expose->height - 1 };
/* Tell the driver about the update if the region is realized. */
D_DEBUG_AT( X11_Input, " -> Issuing display task...\n" );
dfb_surface_lock( region->surface );
DisplayTask_Generate( region, &update, &update, DSFLIP_NONE, -1, NULL );
dfb_surface_unlock( region->surface );
}
else {
//if (lds->lock_left.buffer) {
DFBRegion update = { expose->x, expose->y,
expose->x + expose->width - 1,
expose->y + expose->height - 1 };
// dfb_x11_update_screen( x11, lds, &update, &update, &lds->lock_left, &lds->lock_right );
//}
dfb_x11_update_screen( x11, lds, &update, &update, NULL, NULL );
}
}
/* Unlock the region. */
dfb_layer_region_unlock( region );
/* Release the region. */
dfb_layer_region_unref( region );
}
/* Release the context. */
dfb_layer_context_unref( context );
}
}
DFBResult
dfb_layer_region_flip_update( CoreLayerRegion *region,
const DFBRegion *update,
DFBSurfaceFlipFlags flags )
{
DFBResult ret = DFB_OK;
DFBRegion rotated;
CoreLayer *layer;
CoreLayerContext *context;
CoreSurface *surface;
const DisplayLayerFuncs *funcs;
if (update)
D_DEBUG_AT( Core_Layers,
"dfb_layer_region_flip_update( %p, %p, 0x%08x ) <- [%d, %d - %dx%d]\n",
region, update, flags, DFB_RECTANGLE_VALS_FROM_REGION( update ) );
else
D_DEBUG_AT( Core_Layers,
"dfb_layer_region_flip_update( %p, %p, 0x%08x )\n", region, update, flags );
D_ASSERT( region != NULL );
D_ASSERT( region->context != NULL );
/* Lock the region. */
if (dfb_layer_region_lock( region ))
return DFB_FUSION;
D_ASSUME( region->surface != NULL );
/* Check for NULL surface. */
if (!region->surface) {
D_DEBUG_AT( Core_Layers, " -> No surface => no update!\n" );
dfb_layer_region_unlock( region );
return DFB_UNSUPPORTED;
}
context = region->context;
surface = region->surface;
layer = dfb_layer_at( context->layer_id );
D_ASSERT( layer->funcs != NULL );
funcs = layer->funcs;
/* Unfreeze region? */
if (D_FLAGS_IS_SET( region->state, CLRSF_FROZEN )) {
D_FLAGS_CLEAR( region->state, CLRSF_FROZEN );
if (D_FLAGS_IS_SET( region->state, CLRSF_REALIZED )) {
ret = set_region( region, ®ion->config, CLRCF_ALL, surface );
if (ret)
D_DERROR( ret, "Core/LayerRegion: set_region() in dfb_layer_region_flip_update() failed!\n" );
}
else if (D_FLAGS_ARE_SET( region->state, CLRSF_ENABLED | CLRSF_ACTIVE )) {
ret = realize_region( region );
if (ret)
D_DERROR( ret, "Core/LayerRegion: realize_region() in dfb_layer_region_flip_update() failed!\n" );
}
if (ret) {
dfb_layer_region_unlock( region );
return ret;
}
}
/* Depending on the buffer mode... */
switch (region->config.buffermode) {
case DLBM_TRIPLE:
case DLBM_BACKVIDEO:
/* Check if simply swapping the buffers is possible... */
if (!(flags & DSFLIP_BLIT) && !surface->rotation &&
(!update || (update->x1 == 0 &&
update->y1 == 0 &&
update->x2 == surface->config.size.w - 1 &&
update->y2 == surface->config.size.h - 1)))
{
D_DEBUG_AT( Core_Layers, " -> Going to swap buffers...\n" );
/* Use the driver's routine if the region is realized. */
if (D_FLAGS_IS_SET( region->state, CLRSF_REALIZED )) {
D_ASSUME( funcs->FlipRegion != NULL );
ret = region_buffer_lock( region, surface, CSBR_BACK );
if (ret) {
dfb_layer_region_unlock( region );
return ret;
}
D_DEBUG_AT( Core_Layers, " -> Flipping region using driver...\n" );
if (funcs->FlipRegion)
ret = funcs->FlipRegion( layer,
layer->driver_data,
layer->layer_data,
region->region_data,
surface, flags, ®ion->surface_lock );
dfb_surface_unlock( surface );
}
else {
D_DEBUG_AT( Core_Layers, " -> Flipping region not using driver...\n" );
/* Just do the hardware independent work. */
dfb_surface_lock( surface );
dfb_surface_flip( surface, false );
dfb_surface_unlock( surface );
}
break;
}
/* fall through */
case DLBM_BACKSYSTEM:
D_DEBUG_AT( Core_Layers, " -> Going to copy portion...\n" );
if ((flags & DSFLIP_WAITFORSYNC) == DSFLIP_WAITFORSYNC) {
D_DEBUG_AT( Core_Layers, " -> Waiting for VSync...\n" );
dfb_layer_wait_vsync( layer );
}
D_DEBUG_AT( Core_Layers, " -> Copying content from back to front buffer...\n" );
/* ...or copy updated contents from back to front buffer. */
dfb_back_to_front_copy_rotation( surface, update, surface->rotation );
if ((flags & DSFLIP_WAITFORSYNC) == DSFLIP_WAIT) {
D_DEBUG_AT( Core_Layers, " -> Waiting for VSync...\n" );
dfb_layer_wait_vsync( layer );
}
/* fall through */
case DLBM_FRONTONLY:
/* Tell the driver about the update if the region is realized. */
if (funcs->UpdateRegion && D_FLAGS_IS_SET( region->state, CLRSF_REALIZED )) {
if (surface) {
CoreSurfaceAllocation *allocation;
allocation = region->surface_lock.allocation;
D_ASSERT( allocation != NULL );
/* If hardware has written or is writing... */
if (allocation->accessed[CSAID_GPU] & CSAF_WRITE) {
D_DEBUG_AT( Core_Layers, " -> Waiting for pending writes...\n" );
/* ...wait for the operation to finish. */
if (!(flags & DSFLIP_PIPELINE))
dfb_gfxcard_sync(); /* TODO: wait for serial instead */
allocation->accessed[CSAID_GPU] &= ~CSAF_WRITE;
}
dfb_surface_lock( surface );
dfb_surface_allocation_update( allocation, CSAF_READ );
dfb_surface_unlock( surface );
}
D_DEBUG_AT( Core_Layers, " -> Notifying driver about updated content...\n" );
dfb_region_from_rotated( &rotated, update, &surface->config.size, surface->rotation );
ret = funcs->UpdateRegion( layer,
layer->driver_data,
layer->layer_data,
region->region_data,
surface, &rotated, ®ion->surface_lock );
}
break;
default:
D_BUG("unknown buffer mode");
ret = DFB_BUG;
}
D_DEBUG_AT( Core_Layers, " -> done.\n" );
/* Unlock the region. */
dfb_layer_region_unlock( region );
return ret;
}