DFBResult
CoreGraphicsStateClient_StretchBlit( CoreGraphicsStateClient *client,
const DFBRectangle *srects,
const DFBRectangle *drects,
unsigned int num )
{
D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )\n", __FUNCTION__, client );
D_MAGIC_ASSERT( client, CoreGraphicsStateClient );
D_ASSERT( srects != NULL );
D_ASSERT( drects != NULL );
if (num == 0)
return DFB_OK;
if (num != 1)
D_UNIMPLEMENTED();
if (dfb_core_is_master( client->core ) || !fusion_config->secure_fusion) {
// FIXME: will overwrite rects
dfb_gfxcard_stretchblit( (DFBRectangle*) srects, (DFBRectangle*) drects, client->state );
}
else {
DFBResult ret;
CoreGraphicsStateClient_Update( client, DFXL_STRETCHBLIT, client->state );
ret = CoreGraphicsState_StretchBlit( client->gfx_state, srects, drects, num );
if (ret)
return ret;
}
return DFB_OK;
}
static void* FrameThread( void *ctx )
{
IDirectFBVideoProvider_Swf_data *data = (IDirectFBVideoProvider_Swf_data*)ctx;
struct timeval wd2,now,tv;
long cmd;
long wakeUp;
long delay = 0;
cmd = FLASH_WAKEUP;
wakeUp = FlashExec (data->flashHandle, cmd, 0, &wd2);
while (1) {
pthread_testcancel();
gettimeofday (&now, 0);
delay = (wd2.tv_sec - now.tv_sec) * 1000 + (wd2.tv_usec - now.tv_usec) / 1000;
if (delay < 0)
delay = 20;
if (data->flashDisplay.flash_refresh) {
DFBRectangle rect, drect;
rect.x=0;
rect.y=0;
rect.w=(int) data->flashInfo.frameWidth / 20;
rect.h=(int) data->flashInfo.frameHeight / 20;
drect = data->dest_rect;
dfb_gfxcard_stretchblit( &rect, &drect, &data->state );
data->flashDisplay.flash_refresh = 0;
if (data->callback)
data->callback (data->ctx);
}
if (wakeUp) {
tv.tv_sec = 0;
tv.tv_usec = delay * 1000;
select( 0, 0, 0, 0, &tv );
cmd = FLASH_WAKEUP;
wakeUp = FlashExec (data->flashHandle, cmd, 0, &wd2);
}
else
return NULL;
}
}
void
dfb_gfx_stretch_to( CoreSurface *source, CoreSurface *destination,
const DFBRectangle *srect, const DFBRectangle *drect, bool from_back )
{
DFBRectangle sourcerect = { 0, 0, source->config.size.w, source->config.size.h };
DFBRectangle destrect = { 0, 0, destination->config.size.w, destination->config.size.h };
if (srect) {
if (!dfb_rectangle_intersect( &sourcerect, srect ))
return;
}
if (drect) {
if (!dfb_rectangle_intersect( &destrect, drect ))
return;
}
pthread_mutex_lock( ©_lock );
if (!copy_state_inited) {
dfb_state_init( ©_state, NULL );
copy_state_inited = true;
}
copy_state.modified |= SMF_CLIP | SMF_SOURCE | SMF_DESTINATION;
copy_state.clip.x2 = destination->config.size.w - 1;
copy_state.clip.y2 = destination->config.size.h - 1;
copy_state.source = source;
copy_state.destination = destination;
copy_state.from = from_back ? CSBR_BACK : CSBR_FRONT;
dfb_gfxcard_stretchblit( &sourcerect, &destrect, ©_state );
/* Signal end of sequence. */
dfb_state_stop_drawing( ©_state );
pthread_mutex_unlock( ©_lock );
}
DFBResult
IGraphicsState_Real__StretchBlit(
CoreGraphicsState *obj,
const DFBRectangle *srects,
const DFBRectangle *drects,
u32 num
)
{
D_DEBUG_AT( DirectFB_CoreGraphicsState, "%s()\n", __FUNCTION__ );
D_ASSERT( srects != NULL );
D_ASSERT( drects != NULL );
if (!obj->state.destination || !obj->state.source)
return DFB_NOCONTEXT;
if ((obj->state.blittingflags & (DSBLIT_SRC_MASK_ALPHA | DSBLIT_SRC_MASK_COLOR)) && !obj->state.source_mask)
return DFB_NOCONTEXT;
for (u32 i=0; i<num; i++)
dfb_gfxcard_stretchblit( (DFBRectangle*) &srects[i], (DFBRectangle*) &drects[i], &obj->state );
return DFB_OK;
}
static DFBResult
DisplaySurface( DFBX11 *x11,
X11LayerData *lds,
VdpPresentationQueue queue,
CoreSurfaceBufferLock *lock )
{
DirectResult ret;
DFBX11Shared *shared = x11->shared;
DFBX11CallPresentationQueueDisplay display;
display.presentation_queue = queue;
display.clip_width = 0;
display.clip_height = 0;
display.earliest_presentation_time = 0;
if (lock &&
lds->config.dest.x == 0 && lds->config.dest.y == 0 &&
lds->config.dest.w == shared->screen_size.w &&
lds->config.dest.h == shared->screen_size.h)
{
display.surface = (VdpOutputSurface) (unsigned long) lock->handle;
}
else {
CardState state;
DFBRectangle rect;
dfb_state_init( &state, x11->core );
state.destination = shared->vdp_core_surface;
state.source = lock ? lock->buffer->surface : NULL;
state.clip.x1 = 0;
state.clip.y1 = 0;
state.clip.x2 = shared->screen_size.w - 1;
state.clip.y2 = shared->screen_size.h - 1;
rect.x = 0;
rect.y = 0;
rect.w = shared->screen_size.w;
rect.h = shared->screen_size.h;
dfb_gfxcard_fillrectangles( &rect, 1, &state );
if (lock)
dfb_gfxcard_stretchblit( &lds->config.source, &lds->config.dest, &state );
dfb_gfxcard_sync();
state.destination = NULL;
state.source = NULL;
dfb_state_destroy( &state );
display.surface = shared->vdp_surface;
}
ret = fusion_call_execute2( &x11->shared->call, FCEF_ONEWAY,
X11_VDPAU_PRESENTATION_QUEUE_DISPLAY, &display, sizeof(display), NULL );
if (ret) {
D_DERROR( ret, "DirectFB/X11/VDPAU: fusion_call_execute2() failed!\n" );
return ret;
}
return DFB_OK;
}
static void
root_update( StretRegion *region,
void *region_data,
void *update_data,
unsigned long arg,
int x,
int y,
const DFBRegion *updates,
int num )
{
int i;
CoreWindowStack *stack;
UniqueContext *context = region_data;
CardState *state = update_data;
D_ASSERT( region != NULL );
D_ASSERT( region_data != NULL );
D_ASSERT( update_data != NULL );
D_ASSERT( updates != NULL );
D_ASSERT( x == 0 );
D_ASSERT( y == 0 );
D_MAGIC_ASSERT( context, UniqueContext );
D_MAGIC_ASSERT( state, CardState );
stack = context->stack;
D_ASSERT( stack != NULL );
D_ASSERT( stack->bg.image != NULL || (stack->bg.mode != DLBM_IMAGE &&
stack->bg.mode != DLBM_TILE) );
D_DEBUG_AT( UniQuE_Root, "root_update( region %p, num %d )\n", region, num );
#if D_DEBUG_ENABLED
for (i=0; i<num; i++) {
D_DEBUG_AT( UniQuE_Root, " (%d) %4d,%4d - %4dx%4d\n",
i, DFB_RECTANGLE_VALS_FROM_REGION( &updates[i] ) );
}
#endif
switch (stack->bg.mode) {
case DLBM_COLOR: {
CoreSurface *dest = state->destination;
DFBColor *color = &stack->bg.color;
DFBRectangle rects[num];
/* Set the background color. */
if (DFB_PIXELFORMAT_IS_INDEXED( dest->config.format ))
dfb_state_set_color_index( state,
dfb_palette_search( dest->palette, color->r,
color->g, color->b, color->a ) );
else
dfb_state_set_color( state, color );
for (i=0; i<num; i++)
dfb_rectangle_from_region( &rects[i], &updates[i] );
/* Simply fill the background. */
dfb_gfxcard_fillrectangles( rects, num, state );
break;
}
case DLBM_IMAGE: {
CoreSurface *bg = stack->bg.image;
/* Set blitting source. */
state->source = bg;
state->modified |= SMF_SOURCE;
/* Set blitting flags. */
dfb_state_set_blitting_flags( state, DSBLIT_NOFX );
/* Check the size of the background image. */
if (bg->config.size.w == stack->width && bg->config.size.h == stack->height) {
for (i=0; i<num; i++) {
DFBRectangle dst = DFB_RECTANGLE_INIT_FROM_REGION( &updates[i] );
/* Simple blit for 100% fitting background image. */
dfb_gfxcard_blit( &dst, dst.x, dst.y, state );
}
}
else {
DFBRegion clip = state->clip;
for (i=0; i<num; i++) {
DFBRectangle src = { 0, 0, bg->config.size.w, bg->config.size.h };
DFBRectangle dst = { 0, 0, stack->width, stack->height };
/* Change clipping region. */
dfb_state_set_clip( state, &updates[i] );
/* Stretch blit for non fitting background images. */
dfb_gfxcard_stretchblit( &src, &dst, state );
}
/* Restore clipping region. */
dfb_state_set_clip( state, &clip );
}
/* Reset blitting source. */
state->source = NULL;
state->modified |= SMF_SOURCE;
break;
}
case DLBM_TILE: {
CoreSurface *bg = stack->bg.image;
DFBRegion clip = state->clip;
/* Set blitting source. */
state->source = bg;
state->modified |= SMF_SOURCE;
/* Set blitting flags. */
dfb_state_set_blitting_flags( state, DSBLIT_NOFX );
for (i=0; i<num; i++) {
DFBRectangle src = { 0, 0, bg->config.size.w, bg->config.size.h };
/* Change clipping region. */
dfb_state_set_clip( state, &updates[i] );
/* Tiled blit (aligned). */
dfb_gfxcard_tileblit( &src, 0, 0, stack->width, stack->height, state );
}
/* Restore clipping region. */
dfb_state_set_clip( state, &clip );
/* Reset blitting source. */
state->source = NULL;
state->modified |= SMF_SOURCE;
break;
}
case DLBM_DONTCARE:
break;
default:
D_BUG( "unknown background mode" );
break;
}
}
