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;
}
DFBResult
ISurface_Real__PreLockBuffer2(
CoreSurface *obj,
CoreSurfaceBufferRole role,
CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access,
bool lock,
CoreSurfaceAllocation **ret_allocation
)
{
DFBResult ret;
CoreSurfaceBuffer *buffer;
CoreSurfaceAllocation *allocation;
CoreSurface *surface = obj;
bool allocated = false;
D_DEBUG_AT( DirectFB_CoreSurface, "%s( surface %p, role %d, accessor 0x%02x, access 0x%02x, %slock )\n",
__FUNCTION__, surface, role, accessor, access, lock ? "" : "no " );
ret = (DFBResult) dfb_surface_lock( surface );
if (ret)
return ret;
if (surface->num_buffers < 1) {
dfb_surface_unlock( surface );
return DFB_BUFFEREMPTY;
}
buffer = dfb_surface_get_buffer( surface, role );
D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
D_DEBUG_AT( DirectFB_CoreSurface, " -> buffer %p\n", buffer );
if (!lock && access & CSAF_READ) {
if (fusion_vector_is_empty( &buffer->allocs )) {
dfb_surface_unlock( surface );
return DFB_NOALLOCATION;
}
}
/* Look for allocation with proper access. */
allocation = dfb_surface_buffer_find_allocation( buffer, accessor, access, lock );
if (!allocation) {
/* If no allocation exists, create one. */
ret = dfb_surface_pools_allocate( buffer, accessor, access, &allocation );
if (ret) {
if (ret != DFB_NOVIDEOMEMORY && ret != DFB_UNSUPPORTED)
D_DERROR( ret, "Core/SurfBuffer: Buffer allocation failed!\n" );
goto out;
}
allocated = true;
}
CORE_SURFACE_ALLOCATION_ASSERT( allocation );
/* Synchronize with other allocations. */
ret = dfb_surface_allocation_update( allocation, access );
if (ret) {
/* Destroy if newly created. */
if (allocated)
dfb_surface_allocation_decouple( allocation );
goto out;
}
if (!lock) {
if (access & CSAF_WRITE) {
if (!(allocation->pool->desc.caps & CSPCAPS_WRITE))
lock = true;
}
else if (access & CSAF_READ) {
if (!(allocation->pool->desc.caps & CSPCAPS_READ))
lock = true;
}
}
if (lock) {
ret = dfb_surface_pool_prelock( allocation->pool, allocation, accessor, access );
if (ret) {
/* Destroy if newly created. */
if (allocated)
dfb_surface_allocation_decouple( allocation );
goto out;
}
manage_interlocks( allocation, accessor, access );
}
dfb_surface_allocation_ref( allocation );
*ret_allocation = allocation;
out:
dfb_surface_unlock( surface );
return ret;
}
DFBResult
ISurface_Real__PreWriteBuffer(
CoreSurface *obj,
CoreSurfaceBuffer *buffer,
const DFBRectangle *rect,
CoreSurfaceAllocation **ret_allocation
)
{
DFBResult ret;
CoreSurfaceAllocation *allocation;
CoreSurface *surface = obj;
bool allocated = false;
D_DEBUG_AT( DirectFB_CoreSurface, "%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
dfb_surface_lock( surface );
if (!buffer->surface) {
dfb_surface_unlock( surface );
return DFB_BUFFEREMPTY;
}
/* Use last read allocation if it's up to date... */
if (buffer->read && direct_serial_check( &buffer->read->serial, &buffer->serial ))
allocation = buffer->read;
else {
/* ...otherwise look for allocation with CPU access. */
allocation = dfb_surface_buffer_find_allocation( buffer, CSAID_CPU, CSAF_WRITE, false );
if (!allocation) {
/* If no allocation exists, create one. */
ret = dfb_surface_pools_allocate( buffer, CSAID_CPU, CSAF_WRITE, &allocation );
if (ret) {
D_DERROR( ret, "Core/SurfBuffer: Buffer allocation failed!\n" );
goto out;
}
allocated = true;
}
}
CORE_SURFACE_ALLOCATION_ASSERT( allocation );
/* Synchronize with other allocations. */
ret = dfb_surface_allocation_update( allocation, CSAF_WRITE );
if (ret) {
/* Destroy if newly created. */
if (allocated)
dfb_surface_allocation_decouple( allocation );
goto out;
}
if (!(allocation->pool->desc.caps & CSPCAPS_WRITE)) {
ret = dfb_surface_pool_prelock( allocation->pool, allocation, CSAID_CPU, CSAF_WRITE );
if (ret) {
/* Destroy if newly created. */
if (allocated)
dfb_surface_allocation_decouple( allocation );
goto out;
}
manage_interlocks( allocation, CSAID_CPU, CSAF_WRITE );
}
dfb_surface_allocation_ref( allocation );
*ret_allocation = allocation;
out:
dfb_surface_unlock( surface );
return ret;
}
DFBResult
ISurface_Real__PreLockBuffer(
CoreSurface *obj,
CoreSurfaceBuffer *buffer,
CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access,
CoreSurfaceAllocation **ret_allocation
)
{
DFBResult ret;
CoreSurfaceAllocation *allocation;
CoreSurface *surface = obj;
bool allocated = false;
D_DEBUG_AT( DirectFB_CoreSurface, "%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
dfb_surface_lock( surface );
if (!buffer->surface) {
dfb_surface_unlock( surface );
return DFB_BUFFEREMPTY;
}
/* Look for allocation with proper access. */
allocation = dfb_surface_buffer_find_allocation( buffer, accessor, access, true );
if (!allocation) {
/* If no allocation exists, create one. */
ret = dfb_surface_pools_allocate( buffer, accessor, access, &allocation );
if (ret) {
if (ret != DFB_NOVIDEOMEMORY && ret != DFB_UNSUPPORTED)
D_DERROR( ret, "Core/SurfBuffer: Buffer allocation failed!\n" );
goto out;
}
allocated = true;
}
CORE_SURFACE_ALLOCATION_ASSERT( allocation );
/* Synchronize with other allocations. */
ret = dfb_surface_allocation_update( allocation, access );
if (ret) {
/* Destroy if newly created. */
if (allocated)
dfb_surface_allocation_decouple( allocation );
goto out;
}
ret = dfb_surface_pool_prelock( allocation->pool, allocation, accessor, access );
if (ret) {
/* Destroy if newly created. */
if (allocated)
dfb_surface_allocation_decouple( allocation );
goto out;
}
manage_interlocks( allocation, accessor, access );
dfb_surface_allocation_ref( allocation );
*ret_allocation = allocation;
out:
dfb_surface_unlock( surface );
return ret;
}
