static DFBResult
uc_ovl_flip_region( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreSurface *surface,
DFBSurfaceFlipFlags flags )
{
//printf("Entering %s ... \n", __PRETTY_FUNCTION__);
UcDriverData* ucdrv = (UcDriverData*) driver_data;
UcOverlayData* ucovl = (UcOverlayData*) layer_data;
DFBResult ret;
if (((flags & DSFLIP_WAITFORSYNC) == DSFLIP_WAITFORSYNC) &&
!dfb_config->pollvsync_after)
dfb_layer_wait_vsync( layer );
dfb_surface_flip_buffers(surface, false);
ucovl->field = 0;
ret = uc_ovl_update(ucdrv, ucovl, UC_OVL_FLIP, surface);
if (ret)
return ret;
if ((flags & DSFLIP_WAIT) &&
(dfb_config->pollvsync_after || !(flags & DSFLIP_ONSYNC)))
dfb_layer_wait_vsync(layer);
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;
}
