bool Surface::createDFBSubSurfaceStereo(const Rectangle& geometry, IDirectFBSurface* parent, int zIndex) { release(); DFBRectangle r = geometry.dfbRect(); _parentSurface = parent; r.x += zIndex; DFBResult ret = _parentSurface->GetSubSurface(_parentSurface, &r, &_dfbSurface); if (ret) { ILOG_ERROR( ILX_SURFACE, "Cannot get sub-surface left: %s", DirectFBErrorString(ret)); return false; } ret = _dfbSurface->SetBlittingFlags(_dfbSurface, DSBLIT_BLEND_ALPHACHANNEL); _dfbSurface->SetStereoEye(_dfbSurface, DSSE_LEFT); r.x -= zIndex + zIndex; ret = _parentSurface->GetSubSurface(_parentSurface, &r, &_rightSurface); if (ret) { ILOG_ERROR( ILX_SURFACE, "Cannot get sub-surface right: %s", DirectFBErrorString(ret)); return false; } ret = _rightSurface->SetBlittingFlags(_rightSurface, DSBLIT_BLEND_ALPHACHANNEL); _rightSurface->SetStereoEye(_rightSurface, DSSE_RIGHT); return true; }
static DFBResult server_run() { DFBResult ret; VoodooServer *server; ret = voodoo_server_create( &server ); if (ret) { D_ERROR( "Voodoo/Proxy: Could not create the server (%s)!\n", DirectFBErrorString(ret) ); return ret; } ret = voodoo_server_register( server, "IDirectFB", ConstructDispatcher, NULL ); if (ret) { D_ERROR( "Voodoo/Proxy: Could not register super interface 'IDirectFB'!\n" ); voodoo_server_destroy( server ); return ret; } ret = voodoo_server_run( server ); if (ret) D_ERROR( "Voodoo/Proxy: Server exiting with error (%s)!\n", DirectFBErrorString(ret) ); voodoo_server_destroy( server ); return DFB_OK; }
DFBResult DirectFBError( const char *msg, DFBResult error ) { if (msg) direct_log_printf( NULL, "(#) DirectFBError [%s]: %s\n", msg, DirectFBErrorString( error ) ); else direct_log_printf( NULL, "(#) DirectFBError: %s\n", DirectFBErrorString( error ) ); return error; }
DFBResult dfb_core_part_leave( CoreDFB *core, CorePart *core_part, bool emergency ) { DFBResult ret; if (!core_part->initialized) return DFB_OK; D_DEBUG_AT( Core_Parts, "Going to leave '%s' core...\n", core_part->name ); ret = core_part->Leave( core_part->data_local, emergency ); if (ret) D_ERROR( "DirectFB/Core: Could not leave '%s' core!\n" " --> %s\n", core_part->name, DirectFBErrorString( ret ) ); if (core_part->data_local) D_FREE( core_part->data_local ); core_part->data_local = NULL; core_part->data_shared = NULL; core_part->initialized = false; return DFB_OK; }
DFBResult dfb_core_part_shutdown( CoreDFB *core, CorePart *core_part, bool emergency ) { DFBResult ret; FusionSHMPoolShared *pool; pool = dfb_core_shmpool( core ); if (!core_part->initialized) return DFB_OK; D_DEBUG_AT( Core_Parts, "Going to shutdown '%s' core...\n", core_part->name ); ret = core_part->Shutdown( core_part->data_local, emergency ); if (ret) D_ERROR( "DirectFB/Core: Could not shutdown '%s' core!\n" " --> %s\n", core_part->name, DirectFBErrorString( ret ) ); if (core_part->data_shared) SHFREE( pool, core_part->data_shared ); if (core_part->data_local) D_FREE( core_part->data_local ); core_part->data_local = NULL; core_part->data_shared = NULL; core_part->initialized = false; return DFB_OK; }
static IDirectFBSurface* _create_surface(IDirectFB* dfb, guint width, guint height) { g_assert(dfb != NULL); g_assert(width > 0); g_assert(height > 0); DFBResult err; IDirectFBSurface *ret = NULL; DFBSurfaceDescription sdesc; sdesc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT; sdesc.width = width; sdesc.height = height; sdesc.pixelformat = DSPF_RGB32; err = dfb->CreateSurface(dfb, &sdesc, &ret); if (err != DFB_OK) { DEBUG_WARN("DirectFB::CreateSurface failed:%s", DirectFBErrorString(err)); return NULL; } return ret; }
static DFBResult fbdevTestConfig( CoreSurfacePool *pool, void *pool_data, void *pool_local, CoreSurfaceBuffer *buffer, const CoreSurfaceConfig *config ) { DFBResult ret; CoreSurface *surface; FBDevPoolData *data = pool_data; FBDevPoolLocalData *local = pool_local; D_DEBUG_AT( FBDev_Surfaces, "%s( %p )\n", __FUNCTION__, buffer ); D_MAGIC_ASSERT( pool, CoreSurfacePool ); D_MAGIC_ASSERT( data, FBDevPoolData ); D_MAGIC_ASSERT( local, FBDevPoolLocalData ); D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer ); surface = buffer->surface; D_MAGIC_ASSERT( surface, CoreSurface ); if (surface->type & CSTF_LAYER) return DFB_OK; ret = dfb_surfacemanager_allocate( local->core, data->manager, buffer, NULL, NULL ); D_DEBUG_AT( FBDev_Surfaces, " -> %s\n", DirectFBErrorString(ret) ); return ret; }
bool Surface::createDFBSurface(int width, int height, DFBSurfaceCapabilities caps) { ILOG_TRACE(ILX_SURFACE); release(); DFBSurfaceDescription desc; desc.flags = (DFBSurfaceDescriptionFlags) (DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS); desc.width = width; desc.height = height; desc.pixelformat = PlatformManager::instance().forcedPixelFormat(); if(_flags & ForceSingleSurface) desc.caps = caps; else desc.caps = (DFBSurfaceCapabilities) (caps | PlatformManager::instance().getWindowSurfaceCaps()); desc.hints = DSHF_FONT; DFBResult ret = PlatformManager::instance().getDFB()->CreateSurface(PlatformManager::instance().getDFB(), &desc, &_dfbSurface); if (ret) { ILOG_ERROR(ILX_SURFACE, "Cannot create surface: %s\n", DirectFBErrorString(ret)); return false; } _dfbSurface->SetBlittingFlags(_dfbSurface, DSBLIT_BLEND_ALPHACHANNEL); ILOG_DEBUG(ILX_SURFACE, "[%p] %s(width %d, height %d)\n", this, __FUNCTION__, width, height); ILOG_DEBUG(ILX_SURFACE, " -> Created dfb surface %p\n", _dfbSurface); return true; }
static void _dfb_blit_accel_caps_print(IDirectFBSurface *dst, IDirectFBSurface *src) { #ifdef DFB_DEBUG_ACCELERATION DFBAccelerationMask mask; DFBResult r; r = dst->GetAccelerationMask(dst, src, &mask); if (r != DFB_OK) { ERR("Could not retrieve acceleration mask: %s", DirectFBErrorString(r)); return; } DBG("Acceleration: "); #define O(m) if (mask & m) DBG(#m " ") O(DFXL_FILLRECTANGLE); O(DFXL_DRAWRECTANGLE); O(DFXL_DRAWLINE); O(DFXL_FILLTRIANGLE); O(DFXL_BLIT); O(DFXL_STRETCHBLIT); O(DFXL_TEXTRIANGLES); O(DFXL_DRAWSTRING); #undef O if (mask == DFXL_NONE) DBG("<NONE>"); #endif /* DFB_DEBUG_ACCELERATION */ }
void Surface::flip() { ILOG_TRACE(ILX_SURFACE); DFBResult ret; switch (PlatformManager::instance().getLayerFlipMode(_owner->_rootWindow->layerName())) { case FlipNone: ILOG_DEBUG(ILX_SURFACE, " -> Flip using DSFLIP_NONE\n"); ret = _dfbSurface->Flip(_dfbSurface, NULL, DSFLIP_NONE); break; case FlipOnSync: ILOG_DEBUG(ILX_SURFACE, " -> Flip using DSFLIP_ONSYNC\n"); ret = _dfbSurface->Flip(_dfbSurface, NULL, DSFLIP_ONSYNC); break; case FlipWaitForSync: ILOG_DEBUG(ILX_SURFACE, " -> Flip using DSFLIP_WAITFORSYNC\n"); ret = _dfbSurface->Flip(_dfbSurface, NULL, DSFLIP_WAITFORSYNC); break; case FlipNew: ILOG_DEBUG(ILX_SURFACE, " -> Flip using DSFLIP_ONSYNC\n"); ret = _dfbSurface->Flip(_dfbSurface, NULL, DSFLIP_ONSYNC); break; default: ILOG_DEBUG(ILX_SURFACE, " -> Flip using DSFLIP_NONE\n"); ret = _dfbSurface->Flip(_dfbSurface, NULL, DSFLIP_NONE); break; } if (ret) ILOG_ERROR(ILX_SURFACE, " -> Flip error: %s\n", DirectFBErrorString(ret)); }
static DFBResult stmfbdevTestConfig (CoreSurfacePool *pool, void *pool_data, void *pool_local, CoreSurfaceBuffer *buffer, const CoreSurfaceConfig *config) { CoreSurface *surface; STMfbdevPoolData * const data = pool_data; STMfbdevPoolLocalData * const local = pool_local; DFBResult ret; D_DEBUG_AT (STMfbdev_Surfaces, "%s (%p)\n", __FUNCTION__, buffer); D_MAGIC_ASSERT (pool, CoreSurfacePool); D_MAGIC_ASSERT (data, STMfbdevPoolData); D_MAGIC_ASSERT (local, STMfbdevPoolLocalData); D_MAGIC_ASSERT (buffer, CoreSurfaceBuffer); D_ASSERT (config != NULL); surface = buffer->surface; D_MAGIC_ASSERT (surface, CoreSurface); D_DEBUG_AT (STMfbdev_Surfaces, " -> buffer/type/id %p/0x%x/%lu\n", buffer, surface->type, surface->resource_id); ret = dfb_surfacemanager_allocate (local->core, data->manager, buffer, NULL, NULL); D_DEBUG_AT (STMfbdev_Surfaces, " -> %s\n", DirectFBErrorString (ret)); return ret; }
static IDirectFBSurface * _dfb_surface_from_data(IDirectFB *dfb, int w, int h, void *data) { IDirectFBSurface *s; DFBSurfaceDescription desc; DFBResult r; desc.flags = (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_PREALLOCATED); desc.caps = DSCAPS_PREMULTIPLIED; desc.width = w; desc.height = h; desc.preallocated[0].data = data; desc.preallocated[0].pitch = w * 4; desc.preallocated[1].data = NULL; desc.preallocated[1].pitch = 0; desc.pixelformat = DSPF_ARGB; r = dfb->CreateSurface(dfb, &desc, &s); if (r != DFB_OK) { ERR("Cannot create DirectFB surface: %s", DirectFBErrorString(r)); return NULL; } s->SetPorterDuff(s, DSPD_SRC_OVER); return s; }
/* * Wait for the blitter to be idle. * * This function is called before memory that has been written to by the hardware is about to be * accessed by the CPU (software driver) or another hardware entity like video encoder (by Flip()). * It can also be called by applications explicitly, e.g. at the end of a benchmark loop to include * execution time of queued commands in the measurement. */ DFBResult davinciEngineSync( void *drv, void *dev ) { DFBResult ret; DavinciDriverData *ddrv = drv; DavinciDeviceData *ddev = dev; D_DEBUG_AT( Davinci_2D, "%s()\n", __FUNCTION__ ); if (!ddev->synced) { D_DEBUG_AT( Davinci_2D, " -> syncing...\n" ); ret = davinci_c64x_wait_low( &ddrv->c64x ); if (ret) { D_DEBUG_AT( Davinci_2D, " -> ERROR (%s)\n", DirectFBErrorString(ret) ); return ret; } D_DEBUG_AT( Davinci_2D, " => syncing done.\n" ); ddev->synced = true; } else D_DEBUG_AT( Davinci_2D, " => already synced!\n" ); return DFB_OK; }
int main( int argc, char *argv[] ) { DFBResult ret; int i; VoodooPlayInfo info; VoodooPlayer *player = NULL; /* Initialize DirectFB including command line parsing. */ ret = DirectFBInit( &argc, &argv ); if (ret) { DirectFBError( "DirectFBInit() failed", ret ); return -1; } /* Parse the command line. */ if (!parse_command_line( argc, argv )) return -2; if (m_name) { direct_snputs( info.name, m_name, VOODOO_PLAYER_NAME_LENGTH ); } ret = voodoo_player_create( m_name ? &info : NULL, &player ); if (ret) { D_ERROR( "Voodoo/Play: Could not create the player (%s)!\n", DirectFBErrorString(ret) ); goto out; } do { voodoo_player_broadcast( player ); direct_thread_sleep( 100000 ); voodoo_player_enumerate( player, player_callback, NULL ); if (m_lookup) { for (i=1; i<argc; i++) { char buf[100]; if (voodoo_player_lookup( player, (const u8 *)argv[i], NULL, buf, sizeof(buf) )) { D_ERROR( "Voodoo/Play: No '%s' found!\n", argv[i] ); continue; } D_INFO( "Voodoo/Play: Found '%s' with address %s\n", argv[i], buf ); } } direct_thread_sleep( 2000000 ); } while (m_run); out: if (player) voodoo_player_destroy( player ); return ret; }
IDirectFBSurface *load_image(const char *filename, IDirectFB *dfb, float x_ratio, float y_ratio) { IDirectFBImageProvider *provider; IDirectFBSurface *image = NULL; DFBSurfaceDescription dsc; DFBResult err; if (access(filename, R_OK)) { WRITELOG(ERROR, "Cannot load image: file '%s' does not exist!\n", filename); return NULL; } err = dfb->CreateImageProvider (dfb, filename, &provider); if (err != DFB_OK) { WRITELOG(ERROR, "Couldn't load image from file '%s': %s\n", filename, DirectFBErrorString (err)); return NULL; } provider->GetSurfaceDescription (provider, &dsc); dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT; dsc.pixelformat = DSPF_ARGB; dsc.width = (float)dsc.width * (float)x_ratio; dsc.height = (float)dsc.height * (float)y_ratio; if (dfb->CreateSurface (dfb, &dsc, &image) == DFB_OK) provider->RenderTo (provider, image, NULL); return image; }
void Surface::setStereoGeometry(int x, int y, int width, int height, int zIndex) { DFBRectangle r = { x, y, width, height }; if (_parentSurface) { r.x += zIndex; DFBResult ret = _dfbSurface->MakeSubSurface(_dfbSurface, _parentSurface, &r); if (ret) ILOG_ERROR( ILX_SURFACE, "Cannot set left geometry: %s\n", DirectFBErrorString(ret)); r.x -= zIndex + zIndex; ret = _rightSurface->MakeSubSurface(_rightSurface, _parentSurface, &r); if (ret) ILOG_ERROR( ILX_SURFACE, "Cannot set right geometry: %s\n", DirectFBErrorString(ret)); } else ILOG_ERROR(ILX_SURFACE, "No Parent Surface, need to create surface again!\n"); }
void Surface::clear() { ILOG_TRACE(ILX_SURFACE); DFBResult ret = _dfbSurface->Clear(_dfbSurface, 0, 0, 0, 0); if (ret) ILOG_ERROR(ILX_SURFACE, "Clear error: %s\n", DirectFBErrorString(ret)); else ILOG_DEBUG(ILX_SURFACE, " -> Cleared surface.\n"); }
void Surface::flipStereo(const Rectangle& left, const Rectangle& right) { DFBRegion l = left.dfbRegion(); DFBRegion r = right.dfbRegion(); ILOG_DEBUG(ILX_SURFACE, "[%p] %s Left(%d,%d,%d,%d) Right(%d,%d,%d,%d)\n", this, __FUNCTION__, left.x(), left.y(), left.width(), left.height(), right.x(), right.y(), right.width(), right.height()); DFBResult ret = _dfbSurface->FlipStereo(_dfbSurface, &l, &r, DSFLIP_WAITFORSYNC); if (ret) ILOG_ERROR(ILX_SURFACE, "Flip error: %s\n", DirectFBErrorString(ret)); }
static int _dfb_surface_set_blit_params(DirectFB_Engine_Image_Entry *d, DirectFB_Engine_Image_Entry *s, RGBA_Draw_Context *dc) { IDirectFBSurface *surface; DFBSurfaceBlittingFlags blit_flags = DSBLIT_NOFX; DFBResult res; int r, g, b, a; _context_get_color(dc, &r, &g, &b, &a); if (a == 0) return 0; if (a != 255) blit_flags = DSBLIT_BLEND_COLORALPHA | DSBLIT_SRC_PREMULTCOLOR; if ((r != a) || (g != a) || (b != a)) { blit_flags |= DSBLIT_COLORIZE; r = 0xff * r / a; g = 0xff * g / a; b = 0xff * b / a; } if (s->cache_entry.src->flags.alpha) blit_flags |= DSBLIT_BLEND_ALPHACHANNEL; surface = d->surface; if (blit_flags & (DSBLIT_BLEND_COLORALPHA | DSBLIT_SRC_PREMULTCOLOR | DSBLIT_COLORIZE)) { res = surface->SetColor(surface, r, g, b, a); if (res != DFB_OK) goto error; } res = surface->SetBlittingFlags(surface, blit_flags); if (res != DFB_OK) goto error; #ifdef DFB_DEBUG_FLAGS DBG("sfunc=%s, dfunc=%s, color=%d %d %d %d, blit=%s, draw=%s", _dfb_blend_func_str(src_func), _dfb_blend_func_str(dst_func), r, g, b, a, _dfb_blit_flags_str(blit_flags), _dfb_draw_flags_str(draw_flags)); #endif /* DFB_DEBUG_FLAGS */ return 1; error: ERR("Could not set blit params: %s", DirectFBErrorString(res)); return 0; }
DFBResult dfb_core_part_initialize( CoreDFB *core, CorePart *core_part ) { DFBResult ret; void *local = NULL; void *shared = NULL; FusionSHMPoolShared *pool; pool = dfb_core_shmpool( core ); if (core_part->initialized) { D_BUG( "%s already initialized", core_part->name ); return DFB_BUG; } D_DEBUG_AT( Core_Parts, "Going to initialize '%s' core...\n", core_part->name ); if (core_part->size_local) local = D_CALLOC( 1, core_part->size_local ); if (core_part->size_shared) shared = SHCALLOC( pool, 1, core_part->size_shared ); D_INFO("Going to initialize '%s' core...\n", core_part->name ); ret = core_part->Initialize( core, local, shared ); D_INFO("Core '%s' initialized ...\n", core_part->name ); if (ret) { D_ERROR( "DirectFB/Core: Could not initialize '%s' core!\n" " --> %s\n", core_part->name, DirectFBErrorString( ret ) ); if (shared) SHFREE( pool, shared ); if (local) D_FREE( local ); return ret; } if (shared) fusion_arena_add_shared_field( dfb_core_arena( core ), core_part->name, shared ); core_part->data_local = local; core_part->data_shared = shared; core_part->initialized = true; return DFB_OK; }
void Surface::setGeometry(int x, int y, int width, int height) { ILOG_TRACE(ILX_SURFACE); DFBRectangle r = { x, y, width, height }; if (_parentSurface) { DFBResult ret = _dfbSurface->MakeSubSurface(_dfbSurface, _parentSurface, &r); if (ret) ILOG_ERROR(ILX_SURFACE, "Cannot set geometry: %s\n", DirectFBErrorString(ret)); } else ILOG_ERROR(ILX_SURFACE, "Cannot set geometry without a parent surface!\n"); }
string MMSFB_ErrorString(const int rc, const string msg) { if (rc) { #ifdef __HAVE_DIRECTFB__ string s1 = msg; string s2 = DirectFBErrorString((DFBResult)rc); return s1 + " [" + s2 + "]"; #else return msg; #endif } else return msg; }
bool Surface::createDFBSubSurface(const Rectangle& geometry, IDirectFBSurface* parent) { ILOG_TRACE(ILX_SURFACE); release(); DFBRectangle r = geometry.dfbRect(); _parentSurface = parent; DFBResult ret = _parentSurface->GetSubSurface(_parentSurface, &r, &_dfbSurface); if (ret) { ILOG_ERROR(ILX_SURFACE, "Cannot get sub-surface: %s", DirectFBErrorString(ret)); return false; } ret = _dfbSurface->SetBlittingFlags(_dfbSurface, DSBLIT_BLEND_ALPHACHANNEL); if (ret) { ILOG_ERROR(ILX_SURFACE, "Cannot set blitting flags of sub-surface: %s", DirectFBErrorString(ret)); return false; } ILOG_DEBUG(ILX_SURFACE, "[%p] %s(x %d, y %d, w %d, h %d, parent %p)\n", this, __FUNCTION__, geometry.x(), geometry.y(), geometry.width(), geometry.height(), parent); ILOG_DEBUG(ILX_SURFACE, " -> Created dfb surface %p\n", _dfbSurface); return true; }
static void _dfb_surface_update(IDirectFBSurface *surface, int x, int y, int w, int h) { DFBRegion cr; DFBResult r; cr.x1 = x; cr.y1 = y; cr.x2 = x + w - 1; cr.y2 = y + h - 1; r = surface->Flip(surface, &cr, DSFLIP_NONE); if (r != DFB_OK) WRN("Could not update surface: %s", DirectFBErrorString(r)); }
int main( int argc, char *argv[] ) { DFBResult ret; VoodooPlayInfo info; VoodooPlayer *player = NULL; /* Initialize DirectFB including command line parsing. */ ret = DirectFBInit( &argc, &argv ); if (ret) { DirectFBError( "DirectFBInit() failed", ret ); return -1; } /* Parse the command line. */ if (!parse_command_line( argc, argv )) return -2; if (m_name) { direct_snputs( info.name, m_name, VOODOO_PLAYER_NAME_LENGTH ); } ret = voodoo_player_create( m_name ? &info : NULL, &player ); if (ret) { D_ERROR( "Voodoo/Play: Could not create the player (%s)!\n", DirectFBErrorString(ret) ); goto out; } voodoo_player_broadcast( player ); sleep( 1 ); voodoo_player_enumerate( player, player_callback, NULL ); out: if (player) voodoo_player_destroy( player ); return ret; }
void Surface::blit(IDirectFBSurface* source, int x, int y) { if (source && _dfbSurface) { DFBResult ret; #ifdef ILIXI_STEREO_OUTPUT if (_eye == PaintEvent::LeftEye) #endif ret = _dfbSurface->Blit(_dfbSurface, source, NULL, x, y); #ifdef ILIXI_STEREO_OUTPUT else ret = _rightSurface->Blit(_rightSurface, source, NULL, x, y); #endif if (ret) ILOG_ERROR(ILX_SURFACE, "Blit error: %s\n", DirectFBErrorString(ret)); else ILOG_DEBUG(ILX_SURFACE, "[%p] %s P(%d, %d)\n", this, __FUNCTION__, x, y); } }
DFBResult dfb_core_part_join( CoreDFB *core, CorePart *core_part ) { DFBResult ret; void *local = NULL; void *shared = NULL; if (core_part->initialized) { D_BUG( "%s already joined", core_part->name ); return DFB_BUG; } D_DEBUG_AT( Core_Parts, "Going to join '%s' core...\n", core_part->name ); if (core_part->size_shared && fusion_arena_get_shared_field( dfb_core_arena( core ), core_part->name, &shared )) return DFB_FUSION; if (core_part->size_local) local = D_CALLOC( 1, core_part->size_local ); ret = core_part->Join( core, local, shared ); if (ret) { D_ERROR( "DirectFB/Core: Could not join '%s' core!\n" " --> %s\n", core_part->name, DirectFBErrorString( ret ) ); if (local) D_FREE( local ); return ret; } core_part->data_local = local; core_part->data_shared = shared; core_part->initialized = true; return DFB_OK; }
static void _image_autoset_alpha(DirectFB_Engine_Image_Entry *image) { DFBResult r; DFBSurfacePixelFormat fmt; IDirectFBSurface *surface; RGBA_Image *im; int has_alpha; surface = image->surface; r = surface->GetPixelFormat(surface, &fmt); if (r != DFB_OK) { ERR("Could not get pixel format: %s", DirectFBErrorString(r)); return; } /* XXX: check this in more depth in future, if other PF are supported */ image->cache_entry.src->flags.alpha = (fmt == DSPF_ARGB); }
void Surface::blit(IDirectFBSurface* source, const Rectangle& crop, int x, int y) { if (source && _dfbSurface) { DFBRectangle r = crop.dfbRect(); DFBResult ret; #ifdef ILIXI_STEREO_OUTPUT if (_eye == PaintEvent::LeftEye) #endif ret = _dfbSurface->Blit(_dfbSurface, source, &r, x, y); #ifdef ILIXI_STEREO_OUTPUT else ret = _rightSurface->Blit(_rightSurface, source, &r, x, y); #endif if (ret) ILOG_ERROR(ILX_SURFACE, " -> Blit error: %s - Rect(%d, %d, %d, %d)\n", DirectFBErrorString(ret), crop.x(), crop.y(), crop.width(), crop.height()); else ILOG_DEBUG(ILX_SURFACE, "[%p] %s Rect(%d, %d, %d, %d) P(%d, %d)\n", this, __FUNCTION__, crop.x(), crop.y(), crop.width(), crop.height(), x, y); } }
static IDirectFBSurface * load_image (const char *filename) { IDirectFBImageProvider *provider; IDirectFBSurface *tmp = NULL; IDirectFBSurface *surface = NULL; DFBSurfaceDescription dsc; DFBResult err; err = dfb->CreateImageProvider( dfb, filename, &provider ); if (err != DFB_OK) { fprintf( stderr, "Couldn't load image from file '%s': %s\n", filename, DirectFBErrorString( err )); return NULL; } provider->GetSurfaceDescription( provider, &dsc ); dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT; dsc.pixelformat = DSPF_ARGB; if (dfb->CreateSurface( dfb, &dsc, &tmp ) == DFB_OK) provider->RenderTo( provider, tmp, NULL ); provider->Release( provider ); if (tmp) { primary->GetPixelFormat( primary, &dsc.pixelformat ); if (dfb->CreateSurface( dfb, &dsc, &surface ) == DFB_OK) { surface->Clear( surface, 0, 0, 0, 0xFF ); surface->SetBlittingFlags( surface, DSBLIT_BLEND_ALPHACHANNEL ); surface->Blit( surface, tmp, NULL, 0, 0 ); } tmp->Release( tmp ); } return surface; }