static DFBResult
update_screen( DFBX11 *x11, const DFBRectangle *clip, CoreSurfaceBufferLock *lock, XWindow *xw )
{
void *dst;
void *src;
unsigned int offset = 0;
XImage *ximage;
CoreSurface *surface;
CoreSurfaceAllocation *allocation;
DFBX11Shared *shared;
DFBRectangle rect;
bool direct = false;
D_ASSERT( x11 != NULL );
DFB_RECTANGLE_ASSERT( clip );
D_DEBUG_AT( X11_Update, "%s( %4d,%4d-%4dx%4d )\n", __FUNCTION__, DFB_RECTANGLE_VALS( clip ) );
CORE_SURFACE_BUFFER_LOCK_ASSERT( lock );
shared = x11->shared;
D_ASSERT( shared != NULL );
XLockDisplay( x11->display );
if (!xw) {
XUnlockDisplay( x11->display );
return DFB_OK;
}
allocation = lock->allocation;
CORE_SURFACE_ALLOCATION_ASSERT( allocation );
surface = allocation->surface;
D_ASSERT( surface != NULL );
rect.x = rect.y = 0;
rect.w = xw->width;
rect.h = xw->height;
if (!dfb_rectangle_intersect( &rect, clip )) {
XUnlockDisplay( x11->display );
return DFB_OK;
}
D_DEBUG_AT( X11_Update, " -> %4d,%4d-%4dx%4d\n", DFB_RECTANGLE_VALS( &rect ) );
#ifdef USE_GLX
/* Check for GLX allocation... */
if (allocation->pool == shared->glx_pool && lock->handle) {
LocalPixmap *pixmap = lock->handle;
D_MAGIC_ASSERT( pixmap, LocalPixmap );
/* ...and just call SwapBuffers... */
//D_DEBUG_AT( X11_Update, " -> Calling glXSwapBuffers( 0x%lx )...\n", alloc->drawable );
//glXSwapBuffers( x11->display, alloc->drawable );
D_DEBUG_AT( X11_Update, " -> Copying from GLXPixmap...\n" );
glXWaitGL();
XCopyArea( x11->display, pixmap->pixmap, xw->window, xw->gc,
rect.x, rect.y, rect.w, rect.h, rect.x, rect.y );
glXWaitX();
XUnlockDisplay( x11->display );
return DFB_OK;
}
#endif
/* Check for our special native allocation... */
if (allocation->pool == shared->x11image_pool && lock->handle) {
x11Image *image = lock->handle;
D_MAGIC_ASSERT( image, x11Image );
/* ...and directly XShmPutImage from that. */
ximage = image->ximage;
direct = true;
}
else {
/* ...or copy or convert into XShmImage or XImage allocated with the XWindow. */
ximage = xw->ximage;
offset = xw->ximage_offset;
xw->ximage_offset = (offset ? 0 : ximage->height / 2);
/* make sure the 16-bit input formats are properly 2-pixel-clipped */
switch (surface->config.format) {
case DSPF_I420:
case DSPF_YV12:
case DSPF_NV12:
case DSPF_NV21:
if (rect.y & 1) {
rect.y--;
rect.h++;
}
/* fall through */
case DSPF_YUY2:
case DSPF_UYVY:
case DSPF_NV16:
if (rect.x & 1) {
rect.x--;
rect.w++;
}
default: /* no action */
break;
}
dst = xw->virtualscreen + rect.x * xw->bpp + (rect.y + offset) * ximage->bytes_per_line;
src = lock->addr + DFB_BYTES_PER_LINE( surface->config.format, rect.x ) + rect.y * lock->pitch;
switch (xw->depth) {
case 32:
dfb_convert_to_argb( surface->config.format, src, lock->pitch,
surface->config.size.h, dst, ximage->bytes_per_line, rect.w, rect.h );
break;
case 24:
dfb_convert_to_rgb32( surface->config.format, src, lock->pitch,
surface->config.size.h, dst, ximage->bytes_per_line, rect.w, rect.h );
break;
case 16:
if (surface->config.format == DSPF_LUT8) {
int width = rect.w; int height = rect.h;
const u8 *src8 = src;
u16 *dst16 = dst;
CorePalette *palette = surface->palette;
int x;
while (height--) {
for (x=0; x<width; x++) {
DFBColor color = palette->entries[src8[x]];
dst16[x] = PIXEL_RGB16( color.r, color.g, color.b );
}
src8 += lock->pitch;
dst16 += ximage->bytes_per_line / 2;
}
}
else {
dfb_convert_to_rgb16( surface->config.format, src, lock->pitch,
surface->config.size.h, dst, ximage->bytes_per_line, rect.w, rect.h );
}
break;
case 15:
dfb_convert_to_rgb555( surface->config.format, src, lock->pitch,
surface->config.size.h, dst, ximage->bytes_per_line, rect.w, rect.h );
break;
default:
D_ONCE( "unsupported depth %d", xw->depth );
}
}
D_ASSERT( ximage != NULL );
/* Wait for previous data to be processed... */
XSync( x11->display, False );
/* ...and immediately queue or send the next! */
if (x11->use_shm) {
/* Just queue the command, it's XShm :) */
XShmPutImage( xw->display, xw->window, xw->gc, ximage,
rect.x, rect.y + offset, rect.x, rect.y, rect.w, rect.h, False );
/* Make sure the queue has really happened! */
XFlush( x11->display );
}
else
/* Initiate transfer of buffer... */
XPutImage( xw->display, xw->window, xw->gc, ximage,
rect.x, rect.y + offset, rect.x, rect.y, rect.w, rect.h );
/* Wait for display if single buffered and not converted... */
if (direct && !(surface->config.caps & DSCAPS_FLIPPING))
XSync( x11->display, False );
XUnlockDisplay( x11->display );
return DFB_OK;
}
static DFBResult
update_screen( int x, int y, int w, int h )
{
#if 0
int i, n;
void *dst;
void *src;
DFBResult ret;
CoreSurface *surface;
CoreSurfaceBuffer *buffer;
CoreSurfaceBufferLock lock;
u16 *src16, *dst16;
u8 *src8;
#endif
D_DEBUG_AT( SDL_Updates, "%s( %d, %d, %d, %d )\n", __FUNCTION__, x, y, w, h );
D_DEBUG_AT( SDL_Updates, " -> locking sdl lock...\n" );
fusion_skirmish_prevail( &dfb_sdl->lock );
#if 0
surface = dfb_sdl->primary;
D_MAGIC_ASSERT_IF( surface, CoreSurface );
D_DEBUG_AT( SDL_Updates, " -> primary is %p\n", surface );
if (!surface) {
D_DEBUG_AT( SDL_Updates, " -> unlocking sdl lock...\n" );
fusion_skirmish_dismiss( &dfb_sdl->lock );
D_DEBUG_AT( SDL_Updates, " -> done.\n" );
return DFB_OK;
}
buffer = dfb_surface_get_buffer( surface, CSBR_FRONT );
D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
D_DEBUG_AT( SDL_Updates, " -> locking sdl surface...\n" );
if (SDL_LockSurface( screen ) < 0) {
D_ERROR( "DirectFB/SDL: "
"Couldn't lock the display surface: %s\n", SDL_GetError() );
fusion_skirmish_dismiss( &dfb_sdl->lock );
return DFB_FAILURE;
}
D_DEBUG_AT( SDL_Updates, " -> locking dfb surface...\n" );
ret = dfb_surface_buffer_lock( buffer, CSAF_CPU_READ, &lock );
if (ret) {
D_ERROR( "DirectFB/SDL: Couldn't lock layer surface: %s\n",
DirectFBErrorString( ret ) );
SDL_UnlockSurface(screen);
fusion_skirmish_dismiss( &dfb_sdl->lock );
return ret;
}
src = lock.addr;
dst = screen->pixels;
src += DFB_BYTES_PER_LINE( surface->config.format, x ) + y * lock.pitch;
dst += DFB_BYTES_PER_LINE( surface->config.format, x ) + y * screen->pitch;
D_DEBUG_AT( SDL_Updates, " -> copying pixels...\n" );
switch (screen->format->BitsPerPixel) {
case 16:
dfb_convert_to_rgb16( surface->config.format,
src, lock.pitch, surface->config.size.h,
dst, screen->pitch, w, h );
break;
default:
direct_memcpy( dst, src, DFB_BYTES_PER_LINE( surface->config.format, w ) );
}
D_DEBUG_AT( SDL_Updates, " -> unlocking dfb surface...\n" );
dfb_surface_buffer_unlock( &lock );
D_DEBUG_AT( SDL_Updates, " -> unlocking sdl surface...\n" );
SDL_UnlockSurface( screen );
#endif
D_DEBUG_AT( SDL_Updates, " -> calling SDL_UpdateRect()...\n" );
SDL_UpdateRect( dfb_sdl->screen, x, y, w, h );
D_DEBUG_AT( SDL_Updates, " -> unlocking sdl lock...\n" );
fusion_skirmish_dismiss( &dfb_sdl->lock );
D_DEBUG_AT( SDL_Updates, " -> done.\n" );
return DFB_OK;
}
