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;
}
int
direct_strncasecmp( const char *a, const char *b, size_t bytes )
{
D_UNIMPLEMENTED();
return strncmp( a, b, bytes );
}
DirectResult
direct_signal_handler_remove( DirectSignalHandler *handler )
{
D_UNIMPLEMENTED();
return DR_OK;
}
DirectResult
fusion_ref_catch (FusionRef *ref)
{
D_UNIMPLEMENTED();
return DR_OK;
}
DirectResult
fusion_ref_throw (FusionRef *ref, FusionID catcher)
{
D_UNIMPLEMENTED();
return DR_OK;
}
DirectResult
fusion_call_add_permissions( FusionCall *call,
FusionID fusion_id,
FusionCallPermissions call_permissions )
{
D_UNIMPLEMENTED();
return DR_UNIMPLEMENTED;
}
DirectResult
fusion_ref_add_permissions( FusionRef *ref,
FusionID fusion_id,
FusionRefPermissions ref_permissions )
{
D_UNIMPLEMENTED();
return DR_UNIMPLEMENTED;
}
DirectResult
fusion_ref_inherit (FusionRef *ref, FusionRef *from)
{
D_ASSERT( ref != NULL );
D_ASSERT( from != NULL );
D_UNIMPLEMENTED();
return fusion_ref_up( ref, true );
}
DirectResult
direct_signal_handler_add( int num,
DirectSignalHandlerFunc func,
void *ctx,
DirectSignalHandler **ret_handler )
{
D_UNIMPLEMENTED();
return DR_OK;
}
/*
* Fetch one entry from the kernel keymap.
*/
static DFBResult
driver_get_keymap_entry( CoreInputDevice *device,
void *driver_data,
DFBInputDeviceKeymapEntry *entry )
{
D_DEBUG_AT( Input_Hub, "%s( ID %u )\n", __FUNCTION__, dfb_input_device_id(device) );
D_UNIMPLEMENTED();
return DFB_UNIMPLEMENTED;
}
DFBResult
unique_decoration_update( UniqueDecoration *decoration,
const DFBRegion *region )
{
D_MAGIC_ASSERT( decoration, UniqueDecoration );
DFB_REGION_ASSERT_IF( region );
D_UNIMPLEMENTED();
return DFB_UNIMPLEMENTED;
}
/*
* Obtain information about an axis (only absolute axis so far).
*/
static DFBResult
driver_get_axis_info( CoreInputDevice *device,
void *driver_data,
DFBInputDeviceAxisIdentifier axis,
DFBInputDeviceAxisInfo *ret_info )
{
D_DEBUG_AT( Input_Hub, "%s( ID %u, axis %u )\n", __FUNCTION__, dfb_input_device_id(device), axis );
D_UNIMPLEMENTED();
return DFB_UNIMPLEMENTED;
}
static DFBResult
crtc2TestOutputConfig( CoreScreen *screen,
void *driver_data,
void *screen_data,
int output,
const DFBScreenOutputConfig *config,
DFBScreenOutputConfigFlags *failed )
{
D_UNIMPLEMENTED();
return DFB_UNIMPLEMENTED;
}
long long
direct_clock_get_time( DirectClockType type )
{
long long micros;
struct timespec spec;
switch (type) {
case DIRECT_CLOCK_REALTIME:
ktime_get_real_ts( &spec );
break;
case DIRECT_CLOCK_SESSION:
case DIRECT_CLOCK_MONOTONIC:
// ktime_get_ts( &spec );
ktime_get_real_ts( &spec );
break;
case DIRECT_CLOCK_PROCESS_CPUTIME_ID:
D_UNIMPLEMENTED();
return DR_UNIMPLEMENTED;
case DIRECT_CLOCK_THREAD_CPUTIME_ID:
D_UNIMPLEMENTED();
return DR_UNIMPLEMENTED;
default:
D_BUG( "invalid clock type %d", type );
return DR_INVARG;
}
micros = spec.tv_sec * 1000000LL + spec.tv_nsec / 1000LL;
if (type == DIRECT_CLOCK_SESSION)
micros -= session_clock_offset;
return micros;
}
void
direct_thread_testcancel( DirectThread *thread )
{
D_MAGIC_ASSERT( thread, DirectThread );
D_ASSERT( thread->handle.thread != -1 );
D_ASSERT( pthread_equal( thread->handle.thread, pthread_self() ) );
/* Quick check before calling the pthread function. */
#ifndef DIRECT_BUILD_NO_PTHREAD_CANCEL
if (thread->canceled)
pthread_testcancel();
#else
D_UNIMPLEMENTED();
#endif
}
static DFBResult
wm_set_cursor_position( CoreWindow *window,
void *wm_data,
void *window_data,
int x,
int y )
{
D_ASSERT( window != NULL );
D_ASSERT( wm_data != NULL );
D_ASSERT( window_data != NULL );
D_UNIMPLEMENTED();
return DFB_UNIMPLEMENTED;
}
void
_fusion_shmpool_process( FusionWorld *world,
int pool_id,
FusionSHMPoolMessage *msg )
{
int i;
DirectResult ret;
FusionSHM *shm;
FusionSHMShared *shared;
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %d, %p )\n", __FUNCTION__, world, pool_id, msg );
D_MAGIC_ASSERT( world, FusionWorld );
shm = &world->shm;
D_MAGIC_ASSERT( shm, FusionSHM );
shared = shm->shared;
D_MAGIC_ASSERT( shared, FusionSHMShared );
ret = fusion_skirmish_prevail( &shared->lock );
if (ret)
return;
for (i=0; i<FUSION_SHM_MAX_POOLS; i++) {
if (shm->pools[i].attached) {
D_MAGIC_ASSERT( &shm->pools[i], FusionSHMPool );
if (shm->pools[i].pool_id == pool_id) {
switch (msg->type) {
case FSMT_REMAP:
break;
case FSMT_UNMAP:
D_UNIMPLEMENTED();
break;
}
break;
}
}
}
fusion_skirmish_dismiss( &shared->lock );
}
void
direct_thread_cancel( DirectThread *thread )
{
D_MAGIC_ASSERT( thread, DirectThread );
D_ASSERT( thread->handle.thread != -1 );
D_ASSERT( !pthread_equal( thread->handle.thread, pthread_self() ) );
D_ASSUME( !thread->canceled );
D_DEBUG_AT( Direct_Thread, "%s( %p, '%s' %d )\n", __FUNCTION__, thread->main, thread->name, thread->tid );
thread->canceled = true;
#ifndef DIRECT_BUILD_NO_PTHREAD_CANCEL
pthread_cancel( thread->handle.thread );
#else
D_UNIMPLEMENTED();
#endif
}
static void
write_glyph( DGIFFGlyphInfo *glyph, const DFBSurfaceDescription &desc, void *dst, int pitch )
{
D_DEBUG_AT( mkdgiff, "%s( %p, %p, %d ) <- size %ux%u\n",
__FUNCTION__, glyph, dst, pitch, desc.width, desc.height );
switch (m_format) {
case DSPF_ARGB:
dfb_convert_to_argb( desc.pixelformat, desc.preallocated[0].data, desc.preallocated[0].pitch,
NULL, 0, NULL, 0,
desc.height, (u32*) dst, pitch, desc.width, desc.height );
break;
default:
D_UNIMPLEMENTED();
break;
}
}
DirectResult
direct_clock_set_time( DirectClockType type,
long long micros )
{
DirectResult ret = DR_OK;
struct timespec spec;
clockid_t clock_id;
D_UNIMPLEMENTED();
return DR_UNIMPLEMENTED;
switch (type) {
case DIRECT_CLOCK_SESSION:
case DIRECT_CLOCK_REALTIME:
clock_id = CLOCK_REALTIME;
break;
case DIRECT_CLOCK_MONOTONIC:
clock_id = CLOCK_MONOTONIC;
break;
case DIRECT_CLOCK_PROCESS_CPUTIME_ID:
clock_id = CLOCK_PROCESS_CPUTIME_ID;
break;
case DIRECT_CLOCK_THREAD_CPUTIME_ID:
clock_id = CLOCK_THREAD_CPUTIME_ID;
break;
default:
D_BUG( "invalid clock type %d", type );
return DR_INVARG;
}
spec.tv_sec = micros / 1000000LL;
spec.tv_nsec = micros % 1000000LL * 1000LL;
if (1/*(ret = clock_settime( clock_id, &spec )) < 0*/) {
D_ERROR( "Direct/Clock: Could not set clock with id %d!\n", clock_id );
}
return ret;
}
DirectResult
direct_tgkill( int tgid, int tid, int sig )
{
int ret;
D_UNIMPLEMENTED();
return DR_UNIMPLEMENTED;
// sys_rt_sigqueueinfo( direct_getpid(), SIGKILL, &info );
// ret = sys_tgkill( tgid, tid, sig );
switch (ret) {
case -ESRCH:
return DR_TASK_NOT_FOUND;
default:
return errno2result( -ret );
case 0:
break;
}
return DR_OK;
}
void gBlit( CardState *state, DFBRectangle *rect, int dx, int dy )
{
GenefxState *gfxs = state->gfxs;
int h;
XopAdvanceFunc Aop_advance;
XopAdvanceFunc Bop_advance;
int Aop_X;
int Aop_Y;
int Bop_X;
int Bop_Y;
DFBSurfaceBlittingFlags rotflip_blittingflags = state->blittingflags;
dfb_simplify_blittingflags( &rotflip_blittingflags );
rotflip_blittingflags &= (DSBLIT_FLIP_HORIZONTAL | DSBLIT_FLIP_VERTICAL | DSBLIT_ROTATE90 );
D_ASSERT( gfxs != NULL );
if (dfb_config->software_warn) {
D_WARN( "Blit (%4d,%4d-%4dx%4d) %6s, flags 0x%08x, funcs %d/%d, color 0x%02x%02x%02x%02x, source (%4d,%4d) %6s",
dx, dy, rect->w, rect->h, dfb_pixelformat_name(gfxs->dst_format), state->blittingflags,
state->src_blend, state->dst_blend,
state->color.a, state->color.r, state->color.g, state->color.b, rect->x, rect->y,
dfb_pixelformat_name(gfxs->src_format) );
}
D_ASSERT( state->clip.x1 <= dx );
D_ASSERT( state->clip.y1 <= dy );
D_ASSERT( (rotflip_blittingflags & DSBLIT_ROTATE90) || state->clip.x2 >= (dx + rect->w - 1) );
D_ASSERT( (rotflip_blittingflags & DSBLIT_ROTATE90) || state->clip.y2 >= (dy + rect->h - 1) );
D_ASSERT( !(rotflip_blittingflags & DSBLIT_ROTATE90) || state->clip.x2 >= (dx + rect->h - 1) );
D_ASSERT( !(rotflip_blittingflags & DSBLIT_ROTATE90) || state->clip.y2 >= (dy + rect->w - 1) );
CHECK_PIPELINE();
if (!Genefx_ABacc_prepare( gfxs, rect->w ))
return;
switch (gfxs->src_format) {
case DSPF_A4:
case DSPF_YUY2:
case DSPF_UYVY:
rect->x &= ~1;
break;
default:
break;
}
switch (gfxs->dst_format) {
case DSPF_A4:
case DSPF_YUY2:
case DSPF_UYVY:
dx &= ~1;
break;
default:
break;
}
gfxs->length = rect->w;
if (gfxs->src_org[0] == gfxs->dst_org[0] && dy == rect->y && dx > rect->x)
/* we must blit from right to left */
gfxs->Astep = gfxs->Bstep = -1;
else
/* we must blit from left to right*/
gfxs->Astep = gfxs->Bstep = 1;
if (rotflip_blittingflags == (DSBLIT_FLIP_HORIZONTAL | DSBLIT_FLIP_VERTICAL)) { // 180 deg
gfxs->Astep *= -1;
Aop_X = dx + rect->w - 1;
Aop_Y = dy;
Bop_X = rect->x;
Bop_Y = rect->y + rect->h - 1;
Aop_advance = Genefx_Aop_next;
Bop_advance = Genefx_Bop_prev;
}
else if (rotflip_blittingflags == DSBLIT_FLIP_HORIZONTAL) {
gfxs->Astep *= -1;
Aop_X = dx + rect->w - 1;
Aop_Y = dy;
Bop_X = rect->x;
Bop_Y = rect->y;
Aop_advance = Genefx_Aop_next;
Bop_advance = Genefx_Bop_next;
}
else if (rotflip_blittingflags == DSBLIT_FLIP_VERTICAL) {
Aop_X = dx;
Aop_Y = dy + rect->h - 1;
Bop_X = rect->x;
Bop_Y = rect->y;
Aop_advance = Genefx_Aop_prev;
Bop_advance = Genefx_Bop_next;
}
else if (rotflip_blittingflags == (DSBLIT_ROTATE90 | DSBLIT_FLIP_HORIZONTAL | DSBLIT_FLIP_VERTICAL)) { // 270 deg ccw
if (gfxs->dst_bpp == 0) {
D_UNIMPLEMENTED();
return;
}
gfxs->Astep *= gfxs->dst_pitch / gfxs->dst_bpp;
Aop_X = dx;
Aop_Y = dy;
Bop_X = rect->x;
Bop_Y = rect->y + rect->h - 1;
Aop_advance = Genefx_Aop_crab;
Bop_advance = Genefx_Bop_prev;
}
else if (rotflip_blittingflags == DSBLIT_ROTATE90) { // 90 deg ccw
if (gfxs->dst_bpp == 0) {
D_UNIMPLEMENTED();
return;
}
gfxs->Astep *= -gfxs->dst_pitch / gfxs->dst_bpp;
Aop_X = dx;
Aop_Y = dy + rect->w - 1;
Bop_X = rect->x;
Bop_Y = rect->y;
Aop_advance = Genefx_Aop_crab;
Bop_advance = Genefx_Bop_next;
}
else if (rotflip_blittingflags == (DSBLIT_ROTATE90 | DSBLIT_FLIP_VERTICAL)) {
if (gfxs->dst_bpp == 0) {
D_UNIMPLEMENTED();
return;
}
gfxs->Astep *= -gfxs->dst_pitch / gfxs->dst_bpp;
Aop_X = dx + rect->h - 1;
Aop_Y = dy + rect->w - 1;
Bop_X = rect->x;
Bop_Y = rect->y;
Aop_advance = Genefx_Aop_prev_crab;
Bop_advance = Genefx_Bop_next;
}
else if (rotflip_blittingflags == (DSBLIT_ROTATE90 | DSBLIT_FLIP_HORIZONTAL)) {
if (gfxs->dst_bpp == 0) {
D_UNIMPLEMENTED();
return;
}
gfxs->Astep *= gfxs->dst_pitch / gfxs->dst_bpp;
Aop_X = dx;
Aop_Y = dy;
Bop_X = rect->x;
Bop_Y = rect->y;
Aop_advance = Genefx_Aop_crab;
Bop_advance = Genefx_Bop_next;
}
else if (gfxs->src_org[0] == gfxs->dst_org[0] && dy > rect->y && !(state->blittingflags & DSBLIT_DEINTERLACE)) {
/* we must blit from bottom to top */
Aop_X = dx;
Aop_Y = dy + rect->h - 1;
Bop_X = rect->x;
Bop_Y = rect->y + rect->h - 1;
Aop_advance = Genefx_Aop_prev;
Bop_advance = Genefx_Bop_prev;
}
else {
/* we must blit from top to bottom */
Aop_X = dx;
Aop_Y = dy;
Bop_X = rect->x;
Bop_Y = rect->y;
Aop_advance = Genefx_Aop_next;
Bop_advance = Genefx_Bop_next;
}
Genefx_Aop_xy( gfxs, Aop_X, Aop_Y );
Genefx_Bop_xy( gfxs, Bop_X, Bop_Y );
if (state->blittingflags & DSBLIT_DEINTERLACE) {
if (state->source->field) {
Aop_advance( gfxs );
Bop_advance( gfxs );
rect->h--;
}
for (h = rect->h/2; h; h--) {
RUN_PIPELINE();
Aop_advance( gfxs );
RUN_PIPELINE();
Aop_advance( gfxs );
Bop_advance( gfxs );
Bop_advance( gfxs );
}
} /* ! DSBLIT_DEINTERLACE */
else {
for (h = rect->h; h; h--) {
RUN_PIPELINE();
Aop_advance( gfxs );
Bop_advance( gfxs );
}
}
Genefx_ABacc_flush( gfxs );
}
static DirectResult
SendReceive( VoodooLink *link,
VoodooChunk *sends,
size_t num_send,
VoodooChunk *recvs,
size_t num_recv )
{
Link *l = link->priv;
size_t i;
ssize_t ret;
DWORD wait_result;
// direct_mutex_lock( &l->lock );
for (i=0; i<num_send; i++) {
//printf("writing %d\n",sends[i].length);
ret = send( l->socket, sends[i].ptr, sends[i].length, 0 );
//printf("wrote %d/%d\n",ret,sends[i].length);
if (ret < 0) {
if (WSAGetLastError() == 10035) {
break;
}
D_PERROR( "Voodoo/Link: Failed to send() data error %d!\n", WSAGetLastError() );
}
else {
sends[i].done = (size_t) ret;
if (sends[i].done != sends[i].length) {
D_UNIMPLEMENTED();
// direct_mutex_unlock( &l->lock );
return DR_UNIMPLEMENTED;
}
return DR_OK;
}
}
while (true) {
LONG events = 0;
WSANETWORKEVENTS WsaNetworkEvents;
if (num_recv) {
//printf("wait for recv\n");
events |= FD_READ;
}
if (num_send) {
//printf("wait for send\n");
events |= FD_WRITE;
}
WSAEventSelect( l->socket, l->event, events );
wait_result = WSAWaitForMultipleEvents( 1, &l->event, FALSE, 10, FALSE );
switch (wait_result) {
case WSA_WAIT_EVENT_0:
WSAResetEvent( l->event );
WSAEnumNetworkEvents(l->socket, l->event, &WsaNetworkEvents);
//printf("<-- events 0x%08x\n",WsaNetworkEvents.lNetworkEvents);
if (!WsaNetworkEvents.lNetworkEvents)
return DR_INTERRUPTED;
if (WsaNetworkEvents.lNetworkEvents & FD_WRITE) {
//printf("<-- event write\n");
for (i=0; i<num_send; i++) {
//printf("writing %d\n",sends[i].length);
ret = send( l->socket, sends[i].ptr, sends[i].length, 0 );
//printf("wrote %d/%d\n",ret,sends[i].length);
if (ret < 0) {
if (WSAGetLastError() == 10035) {
break;
}
D_PERROR( "Voodoo/Link: Failed to send() data error %d!\n", WSAGetLastError() );
return DR_IO;
}
else {
sends[i].done = (size_t) ret;
if (sends[i].done != sends[i].length) {
D_UNIMPLEMENTED();
// direct_mutex_unlock( &l->lock );
return DR_UNIMPLEMENTED;
}
return DR_OK;
}
}
}
if (WsaNetworkEvents.lNetworkEvents & FD_READ) {
//printf("<-- event read\n");
for (i=0; i<num_recv; i++) {
ret = recv( l->socket, recvs[i].ptr, recvs[i].length, 0 );
//printf("read %d\n",ret);
if (ret < 0) {
if (WSAGetLastError() == 10035) {
break;
}
D_PERROR( "Voodoo/Link: Failed to recv() data error %d!\n", WSAGetLastError() );
// direct_mutex_unlock( &l->lock );
return DR_IO;
}
recvs[i].done = (size_t) ret;
if (recvs[i].done < recvs[i].length)
return DR_OK;
return DR_OK;
}
}
break;
case WSA_WAIT_TIMEOUT:
//printf("<-- timeout\n");
return DR_TIMEOUT;
break;
default:
D_ERROR( "Voodoo/Link: WaitForMultipleObjects() failed!\n" );
return DR_FAILURE;
}
}
// direct_mutex_unlock( &l->lock );
return DR_OK;
}
void
direct_signals_block_all( void )
{
D_UNIMPLEMENTED();
}
DFBResult
dfb_surface_create( CoreDFB *core,
const CoreSurfaceConfig *config,
CoreSurfaceTypeFlags type,
unsigned long resource_id,
CorePalette *palette,
CoreSurface **ret_surface )
{
DFBResult ret = DFB_BUG;
int i, data_size;
int buffers;
CoreSurface *surface;
char buf[64];
D_ASSERT( core != NULL );
D_FLAGS_ASSERT( type, CSTF_ALL );
D_MAGIC_ASSERT_IF( palette, CorePalette );
D_ASSERT( ret_surface != NULL );
D_DEBUG_AT( Core_Surface, "dfb_surface_create( %p, %p, %p )\n", core, config, ret_surface );
surface = dfb_core_create_surface( core );
if (!surface)
return DFB_FUSION;
surface->data = NULL;
if (config) {
D_FLAGS_ASSERT( config->flags, CSCONF_ALL );
surface->config.flags = config->flags;
if (config->flags & CSCONF_SIZE) {
D_DEBUG_AT( Core_Surface, " -> %dx%d\n", config->size.w, config->size.h );
surface->config.size = config->size;
}
if (config->flags & CSCONF_FORMAT) {
D_DEBUG_AT( Core_Surface, " -> %s\n", dfb_pixelformat_name( config->format ) );
surface->config.format = config->format;
}
if (config->flags & CSCONF_CAPS) {
D_DEBUG_AT( Core_Surface, " -> caps 0x%08x\n", config->caps );
if (config->caps & DSCAPS_ROTATED)
D_UNIMPLEMENTED();
surface->config.caps = config->caps & ~DSCAPS_ROTATED;
}
if (config->flags & CSCONF_PREALLOCATED) {
D_DEBUG_AT( Core_Surface, " -> prealloc %p [%d]\n",
config->preallocated[0].addr,
config->preallocated[0].pitch );
direct_memcpy( surface->config.preallocated, config->preallocated, sizeof(config->preallocated) );
surface->config.preallocated_pool_id = config->preallocated_pool_id;
type |= CSTF_PREALLOCATED;
}
}
if (surface->config.caps & DSCAPS_SYSTEMONLY)
surface->type = (type & ~CSTF_EXTERNAL) | CSTF_INTERNAL;
else if (surface->config.caps & DSCAPS_VIDEOONLY)
surface->type = (type & ~CSTF_INTERNAL) | CSTF_EXTERNAL;
else
surface->type = type & ~(CSTF_INTERNAL | CSTF_EXTERNAL);
if (surface->config.caps & DSCAPS_SHARED)
surface->type |= CSTF_SHARED;
surface->resource_id = resource_id;
if (surface->config.caps & DSCAPS_TRIPLE)
buffers = 3;
else if (surface->config.caps & DSCAPS_DOUBLE)
buffers = 2;
else {
buffers = 1;
surface->config.caps &= ~DSCAPS_ROTATED;
}
surface->notifications = CSNF_ALL & ~CSNF_FLIP;
surface->alpha_ramp[0] = 0x00;
surface->alpha_ramp[1] = 0x55;
surface->alpha_ramp[2] = 0xaa;
surface->alpha_ramp[3] = 0xff;
if (surface->config.caps & DSCAPS_STATIC_ALLOC)
surface->config.min_size = surface->config.size;
surface->shmpool = dfb_core_shmpool( core );
direct_serial_init( &surface->serial );
snprintf( buf, sizeof(buf), "Surface %dx%d %s", surface->config.size.w,
surface->config.size.h, dfb_pixelformat_name(surface->config.format) );
fusion_ref_set_name( &surface->object.ref, buf );
fusion_skirmish_init2( &surface->lock, buf, dfb_core_world(core), fusion_config->secure_fusion );
// fusion_skirmish_add_permissions( &surface->lock, 0, FUSION_SKIRMISH_PERMIT_PREVAIL | FUSION_SKIRMISH_PERMIT_DISMISS );
D_MAGIC_SET( surface, CoreSurface );
if (dfb_config->warn.flags & DCWF_CREATE_SURFACE &&
dfb_config->warn.create_surface.min_size.w <= surface->config.size.w &&
dfb_config->warn.create_surface.min_size.h <= surface->config.size.h)
D_WARN( "create-surface %4dx%4d %6s, buffers %d, caps 0x%08x, type 0x%08x",
surface->config.size.w, surface->config.size.h, dfb_pixelformat_name(surface->config.format),
buffers, surface->config.caps, surface->type );
if (palette) {
dfb_surface_set_palette( surface, palette );
}
else if (DFB_PIXELFORMAT_IS_INDEXED( surface->config.format )) {
ret = dfb_surface_init_palette( core, surface );
if (ret)
goto error;
}
/* Create the system driver specific surface data information */
data_size = dfb_system_surface_data_size();
if (data_size) {
surface->data = SHCALLOC( surface->shmpool, 1, data_size );
if (!surface->data) {
ret = D_OOSHM();
goto error;
}
}
dfb_system_surface_data_init(surface,surface->data);
dfb_surface_lock( surface );
/* Create the Surface Buffers. */
for (i=0; i<buffers; i++) {
ret = dfb_surface_buffer_create( core, surface, CSBF_NONE, &surface->buffers[i] );
if (ret) {
D_DERROR( ret, "Core/Surface: Error creating surface buffer!\n" );
goto error;
}
surface->num_buffers++;
dfb_surface_buffer_globalize( surface->buffers[i] );
switch (i) {
case 0:
surface->buffer_indices[CSBR_FRONT] = i;
case 1:
surface->buffer_indices[CSBR_BACK] = i;
case 2:
surface->buffer_indices[CSBR_IDLE] = i;
}
}
dfb_surface_unlock( surface );
CoreSurface_Init_Dispatch( core, surface, &surface->call );
fusion_object_activate( &surface->object );
*ret_surface = surface;
return DFB_OK;
error:
for (i=0; i<MAX_SURFACE_BUFFERS; i++) {
if (surface->buffers[i])
dfb_surface_buffer_decouple( surface->buffers[i] );
}
/* release the system driver specific surface data */
if (surface->data) {
dfb_system_surface_data_destroy( surface, surface->data );
SHFREE( surface->shmpool, surface->data );
surface->data = NULL;
}
fusion_skirmish_destroy( &surface->lock );
direct_serial_deinit( &surface->serial );
D_MAGIC_CLEAR( surface );
fusion_object_destroy( &surface->object );
return ret;
}
DFBResult
dfb_surface_reconfig( CoreSurface *surface,
const CoreSurfaceConfig *config )
{
int i, buffers;
DFBResult ret;
CoreSurfaceConfig new_config;
D_DEBUG_AT( Core_Surface, "%s( %p, %dx%d %s -> %dx%d %s )\n", __FUNCTION__, surface,
surface->config.size.w, surface->config.size.h, dfb_pixelformat_name( surface->config.format ),
(config->flags & CSCONF_SIZE) ? config->size.w : surface->config.size.w,
(config->flags & CSCONF_SIZE) ? config->size.h : surface->config.size.h,
(config->flags & CSCONF_FORMAT) ? dfb_pixelformat_name( config->format ) :
dfb_pixelformat_name( surface->config.format ) );
D_MAGIC_ASSERT( surface, CoreSurface );
D_ASSERT( config != NULL );
if (config->flags & CSCONF_PREALLOCATED)
return DFB_UNSUPPORTED;
if (fusion_skirmish_prevail( &surface->lock ))
return DFB_FUSION;
if (surface->type & CSTF_PREALLOCATED) {
fusion_skirmish_dismiss( &surface->lock );
return DFB_UNSUPPORTED;
}
if ( (config->flags == CSCONF_SIZE ||
((config->flags == (CSCONF_SIZE | CSCONF_FORMAT)) && (config->format == surface->config.format))) &&
config->size.w <= surface->config.min_size.w &&
config->size.h <= surface->config.min_size.h)
{
surface->config.size = config->size;
fusion_skirmish_dismiss( &surface->lock );
return DFB_OK;
}
new_config = surface->config;
if (config->flags & CSCONF_SIZE)
new_config.size = config->size;
if (config->flags & CSCONF_FORMAT)
new_config.format = config->format;
if (config->flags & CSCONF_CAPS) {
if (config->caps & DSCAPS_ROTATED)
D_UNIMPLEMENTED();
new_config.caps = config->caps & ~DSCAPS_ROTATED;
}
if (new_config.caps & DSCAPS_SYSTEMONLY)
surface->type = (surface->type & ~CSTF_EXTERNAL) | CSTF_INTERNAL;
else if (new_config.caps & DSCAPS_VIDEOONLY)
surface->type = (surface->type & ~CSTF_INTERNAL) | CSTF_EXTERNAL;
else
surface->type = surface->type & ~(CSTF_INTERNAL | CSTF_EXTERNAL);
if (new_config.caps & DSCAPS_TRIPLE)
buffers = 3;
else if (new_config.caps & DSCAPS_DOUBLE)
buffers = 2;
else {
buffers = 1;
new_config.caps &= ~DSCAPS_ROTATED;
}
ret = Core_Resource_CheckSurfaceUpdate( surface, &new_config );
if (ret)
return ret;
/* Destroy the Surface Buffers. */
for (i=0; i<surface->num_buffers; i++) {
dfb_surface_buffer_decouple( surface->buffers[i] );
surface->buffers[i] = NULL;
}
surface->num_buffers = 0;
Core_Resource_UpdateSurface( surface, &new_config );
surface->config = new_config;
/* Recreate the Surface Buffers. */
for (i=0; i<buffers; i++) {
CoreSurfaceBuffer *buffer;
ret = dfb_surface_buffer_create( core_dfb, surface, CSBF_NONE, &buffer );
if (ret) {
D_DERROR( ret, "Core/Surface: Error creating surface buffer!\n" );
goto error;
}
dfb_surface_buffer_globalize( buffer );
surface->buffers[surface->num_buffers++] = buffer;
switch (i) {
case 0:
surface->buffer_indices[CSBR_FRONT] = i;
case 1:
surface->buffer_indices[CSBR_BACK] = i;
case 2:
surface->buffer_indices[CSBR_IDLE] = i;
}
}
dfb_surface_notify( surface, CSNF_SIZEFORMAT );
fusion_skirmish_dismiss( &surface->lock );
return DFB_OK;
error:
D_UNIMPLEMENTED();
fusion_skirmish_dismiss( &surface->lock );
return ret;
}
