bool
davinciStretchBlit32( void *drv, void *dev, DFBRectangle *srect, DFBRectangle *drect )
{
DavinciDriverData *ddrv = drv;
DavinciDeviceData *ddev = dev;
DFBRegion clip = DFB_REGION_INIT_FROM_RECTANGLE( drect );
D_DEBUG_AT( Davinci_2D, "%s( %4d,%4d-%4dx%4d <- %4d,%4d-%4dx%4d )\n",
__FUNCTION__, DFB_RECTANGLE_VALS(drect), DFB_RECTANGLE_VALS(srect) );
if (!dfb_region_region_intersect( &clip, &ddev->clip ))
return true;
dfb_region_translate( &clip, -drect->x, -drect->y );
davinci_c64x_stretch_32__L( &ddrv->tasks,
ddev->dst_phys + ddev->dst_pitch * drect->y + ddev->dst_bpp * drect->x,
ddev->dst_pitch,
ddev->src_phys + ddev->src_pitch * srect->y + ddev->src_bpp * srect->x,
ddev->src_pitch,
drect->w, drect->h,
srect->w, srect->h,
&clip );
return true;
}
static DFBResult
primaryUpdateRegion( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreSurface *surface,
const DFBRegion *left_update,
CoreSurfaceBufferLock *left_lock,
const DFBRegion *right_update,
CoreSurfaceBufferLock *right_lock )
{
DFBX11 *x11 = driver_data;
DFBX11Shared *shared = x11->shared;
X11LayerData *lds = layer_data;
DFBRegion region = DFB_REGION_INIT_FROM_DIMENSION( &surface->config.size );
D_DEBUG_AT( X11_Layer, "%s()\n", __FUNCTION__ );
if (left_update && !dfb_region_region_intersect( ®ion, left_update ))
return DFB_OK;
lds->shown = true;
return DisplaySurface( x11, layer_data, shared->vdp_queue, left_lock );
}
static DFBResult
IDirectFBSurface_Layer_Flip( IDirectFBSurface *thiz,
const DFBRegion *region,
DFBSurfaceFlipFlags flags )
{
DFBRegion reg;
DIRECT_INTERFACE_GET_DATA(IDirectFBSurface_Layer)
D_DEBUG_AT( Surface, "%s( %p, %p, 0x%08x )\n", __FUNCTION__, thiz, region, flags );
if (!data->base.surface)
return DFB_DESTROYED;
if (data->base.locked)
return DFB_LOCKED;
if (!data->base.area.current.w || !data->base.area.current.h ||
(region && (region->x1 > region->x2 || region->y1 > region->y2)))
return DFB_INVAREA;
IDirectFBSurface_StopAll( &data->base );
if (data->base.parent) {
IDirectFBSurface_data *parent_data;
DIRECT_INTERFACE_GET_DATA_FROM( data->base.parent, parent_data, IDirectFBSurface );
if (parent_data) {
/* Signal end of sequence of operations. */
dfb_state_lock( &parent_data->state );
dfb_state_stop_drawing( &parent_data->state );
dfb_state_unlock( &parent_data->state );
}
}
dfb_region_from_rectangle( ®, &data->base.area.current );
if (region) {
DFBRegion clip = DFB_REGION_INIT_TRANSLATED( region,
data->base.area.wanted.x,
data->base.area.wanted.y );
if (!dfb_region_region_intersect( ®, &clip ))
return DFB_INVAREA;
}
D_DEBUG_AT( Surface, " -> FLIP %4d,%4d-%4dx%4d\n", DFB_RECTANGLE_VALS_FROM_REGION( ® ) );
return CoreLayerRegion_FlipUpdate( data->region, ®, flags );
}
void
dfb_updates_add( DFBUpdates *updates,
const DFBRegion *region )
{
int i;
D_MAGIC_ASSERT( updates, DFBUpdates );
DFB_REGION_ASSERT( region );
D_ASSERT( updates->regions != NULL );
D_ASSERT( updates->num_regions >= 0 );
D_ASSERT( updates->num_regions <= updates->max_regions );
if (updates->num_regions == 0) {
updates->regions[0] = updates->bounding = *region;
updates->num_regions = 1;
return;
}
for (i=0; i<updates->num_regions; i++) {
DFBRegion inter = updates->regions[i];
if (dfb_region_region_intersect( &inter, region )) {
DFBRegion uni = updates->regions[i];
dfb_region_region_union( &uni, region );
updates->regions[i] = uni;
dfb_region_region_union( &updates->bounding, &uni );
return;
}
}
if (updates->num_regions == updates->max_regions) {
dfb_region_region_union( &updates->bounding, region );
updates->regions[0] = updates->bounding;
updates->num_regions = 1;
}
else {
updates->regions[updates->num_regions++] = *region;
dfb_region_region_union( &updates->bounding, region );
}
}
static DFBResult
primaryUpdateRegion( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreSurface *surface,
const DFBRegion *update,
CoreSurfaceBufferLock *lock )
{
DFBX11 *x11 = driver_data;
DFBRegion region = DFB_REGION_INIT_FROM_DIMENSION( &surface->config.size );
if (update && !dfb_region_region_intersect( ®ion, update ))
return DFB_OK;
return dfb_x11_update_screen( x11, ®ion, lock );
}
static DFBResult
primaryUpdateRegion( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreSurface *surface,
const DFBRegion *update,
CoreSurfaceBufferLock *lock )
{
DFBX11 *x11 = driver_data;
X11LayerData *lds = layer_data;
DFBRegion region = DFB_REGION_INIT_FROM_DIMENSION( &surface->config.size );
D_DEBUG_AT( X11_Layer, "%s()\n", __FUNCTION__ );
if (x11->shared->x_error)
return DFB_FAILURE;
if (update && !dfb_region_region_intersect( ®ion, update ))
return DFB_OK;
return dfb_x11_update_screen( x11, lds, ®ion, lock );
}
void
dfb_clip_blit_flipped_rotated( const DFBRegion *clip,
DFBRectangle *srect, DFBRectangle *drect, DFBSurfaceBlittingFlags flags )
{
DFBRegion dest = DFB_REGION_INIT_FROM_RECTANGLE( drect );
DFBRegion clipped = dest;
D_ASSERT( !(flags & (DSBLIT_ROTATE270 | DSBLIT_ROTATE180)) );
if (flags & DSBLIT_ROTATE90) {
D_ASSERT( srect->w == drect->h );
D_ASSERT( srect->h == drect->w );
}
else {
D_ASSERT( srect->w == drect->w );
D_ASSERT( srect->h == drect->h );
}
dfb_region_region_intersect( &clipped, clip );
dfb_rectangle_from_region( drect, &clipped );
switch (flags & (DSBLIT_FLIP_HORIZONTAL | DSBLIT_FLIP_VERTICAL | DSBLIT_ROTATE90)) {
case DSBLIT_NOFX:
srect->x += clipped.x1 - dest.x1;
srect->y += clipped.y1 - dest.y1;
break;
case DSBLIT_FLIP_HORIZONTAL:
srect->x += dest.x2 - clipped.x2;
srect->y += clipped.y1 - dest.y1;
break;
case DSBLIT_FLIP_VERTICAL:
srect->x += clipped.x1 - dest.x1;
srect->y += dest.y2 - clipped.y2;
break;
case DSBLIT_ROTATE90:
srect->x += dest.y2 - clipped.y2;
srect->y += clipped.x1 - dest.x1;
break;
case (DSBLIT_FLIP_HORIZONTAL | DSBLIT_FLIP_VERTICAL): // ROTATE180
srect->x += dest.x2 - clipped.x2;
srect->y += dest.y2 - clipped.y2;
break;
case (DSBLIT_ROTATE90 | DSBLIT_FLIP_VERTICAL | DSBLIT_FLIP_HORIZONTAL): // ROTATE270
srect->x += clipped.y1 - dest.y1;
srect->y += dest.x2 - clipped.x2;
break;
case (DSBLIT_ROTATE90 | DSBLIT_FLIP_HORIZONTAL):
srect->x += clipped.y1 - dest.y1;
srect->y += clipped.x1 - dest.x1;
break;
case (DSBLIT_ROTATE90 | DSBLIT_FLIP_VERTICAL):
srect->x += dest.y2 - clipped.y2;
srect->y += dest.x2 - clipped.x2;
break;
}
if (flags & DSBLIT_ROTATE90) {
srect->w = drect->h;
srect->h = drect->w;
}
else {
srect->w = drect->w;
srect->h = drect->h;
}
D_DEBUG_AT( Core_Clipping, " => %4d,%4d-%4dx%4d -> %4d,%4d-%4dx%4d\n",
DFB_RECTANGLE_VALS(srect), DFB_RECTANGLE_VALS(drect) );
}
