static DFBResult
driver_init_driver( GraphicsDevice *device,
GraphicsDeviceFuncs *funcs,
void *driver_data )
{
ATI128DriverData *adrv = (ATI128DriverData*) driver_data;
adrv->mmio_base = (volatile __u8*) dfb_gfxcard_map_mmio( device, 0, -1 );
if (!adrv->mmio_base)
return DFB_IO;
funcs->CheckState = ati128CheckState;
funcs->SetState = ati128SetState;
funcs->EngineSync = ati128EngineSync;
funcs->FillRectangle = ati128FillRectangle;
funcs->DrawRectangle = ati128DrawRectangle;
funcs->DrawLine = ati128DrawLine;
funcs->Blit = ati128Blit;
funcs->StretchBlit = ati128StretchBlit;
/* overlay support */
dfb_layers_register( device, driver_data, &atiOverlayFuncs );
return DFB_OK;
}
static DFBResult
driver_init_driver( CoreGraphicsDevice *device,
GraphicsDeviceFuncs *funcs,
void *driver_data,
void *device_data,
CoreDFB *core )
{
DFBResult ret;
I830DriverData *idrv = driver_data;
I830DeviceData *idev = device_data;
idrv->idev = device_data;
idrv->mmio_base = (volatile u8*) dfb_gfxcard_map_mmio( device, 0, -1 );
if (!idrv->mmio_base)
return DFB_IO;
ret = i830_agp_setup( device, idrv, idev );
if (ret) {
dfb_gfxcard_unmap_mmio( device, idrv->mmio_base, -1 );
return ret;
}
idrv->info = idev->info;
funcs->CheckState = i830CheckState;
funcs->SetState = i830SetState;
funcs->EngineSync = i830EngineSync;
funcs->FlushTextureCache = i830FlushTextureCache;
dfb_layers_register( dfb_screens_at(DSCID_PRIMARY), driver_data, &i830OverlayFuncs );
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
char *driver;
CoreScreen *screen;
D_ASSERT( dfb_osx == NULL );
dfb_osx = (DFBOSX*) SHCALLOC( dfb_core_shmpool(dfb_osx_core), 1, sizeof(DFBOSX) );
if (!dfb_osx) {
D_ERROR( "DirectFB/OSX: Couldn't allocate shared memory!\n" );
return D_OOSHM();
}
dfb_osx_core = core;
/* Initialize OSX */
fusion_skirmish_init( &dfb_osx->lock, "OSX System", dfb_core_world(core) );
fusion_call_init( &dfb_osx->call, dfb_osx_call_handler, NULL, dfb_core_world(core) );
screen = dfb_screens_register( NULL, NULL, &osxPrimaryScreenFuncs );
dfb_layers_register( screen, NULL, &osxPrimaryLayerFuncs );
fusion_arena_add_shared_field( dfb_core_arena( core ), "OSX", dfb_osx );
*data = dfb_osx;
return DFB_OK;
}
static DFBResult
system_join( CoreDFB *core, void **ret_data )
{
DFBResult ret;
void *tmp;
PVR2DData *data;
PVR2DDataShared *shared;
D_ASSERT( m_data == NULL );
data = D_CALLOC( 1, sizeof(PVR2DData) );
if (!data)
return D_OOM();
data->core = core;
ret = fusion_arena_get_shared_field( dfb_core_arena( core ), "pvr2d", &tmp );
if (ret) {
D_FREE( data );
return ret;
}
data->shared = shared = tmp;
*ret_data = m_data = data;
data->screen = dfb_screens_register( NULL, data, pvr2dPrimaryScreenFuncs );
data->layer = dfb_layers_register( data->screen, data, pvr2dPrimaryLayerFuncs );
dfb_surface_pool_join( core, shared->pool, pvr2dSurfacePoolFuncs );
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
CoreScreen *core_screen;
D_ASSERT( dfb_vnc == NULL );
dfb_vnc = (DFBVNC*) SHCALLOC( dfb_core_shmpool(core), 1, sizeof(DFBVNC) );
if (!dfb_vnc) {
D_ERROR( "DirectFB/VNC: Couldn't allocate shared memory!\n" );
return D_OOSHM();
}
dfb_vnc_core = core;
fusion_skirmish_init( &dfb_vnc->lock, "VNC System", dfb_core_world(core) );
fusion_call_init( &dfb_vnc->call, dfb_vnc_call_handler, NULL, dfb_core_world(core) );
core_screen = dfb_screens_register( NULL, NULL, &vncPrimaryScreenFuncs );
dfb_layers_register( core_screen, NULL, &vncPrimaryLayerFuncs );
fusion_arena_add_shared_field( dfb_core_arena( core ), "vnc", dfb_vnc );
*data = dfb_vnc;
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **ret_data )
{
DFBResult ret;
MesaData *mesa;
MesaDataShared *shared;
FusionSHMPoolShared *pool;
D_ASSERT( m_data == NULL );
mesa = D_CALLOC( 1, sizeof(MesaData) );
if (!mesa)
return D_OOM();
mesa->core = core;
pool = dfb_core_shmpool( core );
shared = SHCALLOC( pool, 1, sizeof(MesaDataShared) );
if (!shared) {
D_FREE( mesa );
return D_OOSHM();
}
shared->shmpool = pool;
mesa->shared = shared;
m_data = mesa;
if (dfb_config->vt) {
ret = dfb_vt_initialize();
if (ret)
return DFB_INIT;
}
ret = InitLocal( mesa );
if (ret) {
if (dfb_config->vt)
dfb_vt_shutdown( false );
return ret;
}
*ret_data = m_data;
dfb_surface_pool_initialize( core, &mesaSurfacePoolFuncs, &shared->pool );
mesa->screen = dfb_screens_register( NULL, mesa, mesaScreenFuncs );
mesa->layer = dfb_layers_register( mesa->screen, mesa, mesaLayerFuncs );
core_arena_add_shared_field( core, "mesa", shared );
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **ret_data )
{
DFBResult ret;
PVR2DData *data;
PVR2DDataShared *shared;
FusionSHMPoolShared *pool;
D_ASSERT( m_data == NULL );
data = D_CALLOC( 1, sizeof(PVR2DData) );
if (!data)
return D_OOM();
data->core = core;
pool = dfb_core_shmpool( core );
shared = SHCALLOC( pool, 1, sizeof(PVR2DDataShared) );
if (!shared) {
D_FREE( data );
return D_OOSHM();
}
shared->shmpool = pool;
data->shared = shared;
ret = InitPVR2D( data );
if (ret) {
SHFREE( pool, shared );
D_FREE( data );
return ret;
}
ret = InitEGL( data );
if (ret) {
SHFREE( pool, shared );
D_FREE( data );
return ret;
}
*ret_data = m_data = data;
data->screen = dfb_screens_register( NULL, data, pvr2dPrimaryScreenFuncs );
data->layer = dfb_layers_register( data->screen, data, pvr2dPrimaryLayerFuncs );
dfb_surface_pool_initialize( core, pvr2dSurfacePoolFuncs, &shared->pool );
fusion_arena_add_shared_field( dfb_core_arena( core ), "pvr2d", shared );
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
char *driver;
CoreScreen *screen;
D_ASSERT( dfb_sdl == NULL );
dfb_sdl = (DFBSDL*) SHCALLOC( dfb_core_shmpool(core), 1, sizeof(DFBSDL) );
if (!dfb_sdl) {
D_ERROR( "DirectFB/SDL: Couldn't allocate shared memory!\n" );
return D_OOSHM();
}
dfb_sdl_core = core;
dfb_fbdev_read_modes(); /* use same mode list as a fake */
driver = getenv( "SDL_VIDEODRIVER" );
if (driver && !strcasecmp( driver, "directfb" )) {
D_INFO( "DirectFB/SDL: SDL_VIDEODRIVER is 'directfb', unsetting it.\n" );
unsetenv( "SDL_VIDEODRIVER" );
}
/* Initialize SDL */
if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
D_ERROR( "DirectFB/SDL: Couldn't initialize SDL: %s\n", SDL_GetError() );
SHFREE( dfb_core_shmpool(core), dfb_sdl );
dfb_sdl = NULL;
return DFB_INIT;
}
fusion_skirmish_init( &dfb_sdl->lock, "SDL System", dfb_core_world(core) );
fusion_call_init( &dfb_sdl->call, dfb_sdl_call_handler, NULL, dfb_core_world(core) );
screen = dfb_screens_register( NULL, NULL, sdlPrimaryScreenFuncs );
dfb_layers_register( screen, NULL, sdlPrimaryLayerFuncs );
fusion_arena_add_shared_field( dfb_core_arena( core ), "sdl", dfb_sdl );
dfb_surface_pool_initialize( core, &sdlSurfacePoolFuncs, &dfb_sdl->sdl_pool );
*data = dfb_sdl;
return DFB_OK;
}
static DFBResult
system_initialize( CoreDFB *core, void **ret_data )
{
DFBResult ret;
AndroidData *android;
AndroidDataShared *shared;
FusionSHMPoolShared *pool;
D_ASSERT( m_data == NULL );
android = D_CALLOC( 1, sizeof(AndroidData) );
if (!android)
return D_OOM();
android->core = core;
pool = dfb_core_shmpool( core );
shared = SHCALLOC( pool, 1, sizeof(AndroidDataShared) );
if (!shared) {
D_FREE( android );
return D_OOSHM();
}
shared->shmpool = pool;
android->shared = shared;
m_data = android;
ret = InitLocal( android );
if (ret)
return ret;
*ret_data = m_data;
dfb_surface_pool_initialize( core, &androidSurfacePoolFuncs, &shared->pool );
android->screen = dfb_screens_register( NULL, android, androidScreenFuncs );
android->layer = dfb_layers_register( android->screen, android, androidLayerFuncs );
android->java_vm = native_data.app->activity->vm;
android->app_path = D_STRDUP( native_data.app->activity->internalDataPath) ;
core_arena_add_shared_field( core, "android", shared );
return DFB_OK;
}
static DFBResult
system_join( CoreDFB *core, void **ret_data )
{
DFBResult ret;
void *tmp;
MesaData *mesa;
MesaDataShared *shared;
D_ASSERT( m_data == NULL );
if (dfb_config->vt) {
ret = dfb_vt_join();
if (ret)
return DFB_INIT;
}
mesa = D_CALLOC( 1, sizeof(MesaData) );
if (!mesa)
return D_OOM();
mesa->core = core;
ret = core_arena_get_shared_field( core, "mesa", &tmp );
if (ret) {
D_FREE( mesa );
return ret;
}
mesa->shared = shared = tmp;
ret = InitLocal( mesa );
if (ret)
return ret;
*ret_data = m_data = mesa;
dfb_surface_pool_join( core, shared->pool, &mesaSurfacePoolFuncs );
mesa->screen = dfb_screens_register( NULL, mesa, mesaScreenFuncs );
mesa->layer = dfb_layers_register( mesa->screen, mesa, mesaLayerFuncs );
return DFB_OK;
}
static DFBResult
system_join( CoreDFB *core, void **data )
{
void *ret;
CoreScreen *core_screen;
D_ASSERT( dfb_vnc == NULL );
fusion_arena_get_shared_field( dfb_core_arena( core ), "vnc", &ret );
dfb_vnc = ret;
dfb_vnc_core = core;
core_screen = dfb_screens_register( NULL, NULL, &vncPrimaryScreenFuncs );
dfb_layers_register( core_screen, NULL, &vncPrimaryLayerFuncs );
*data = dfb_vnc;
return DFB_OK;
}
static DFBResult
system_join( CoreDFB *core, void **data )
{
void *ret;
CoreScreen *screen;
D_ASSERT( dfb_sdl == NULL );
fusion_arena_get_shared_field( dfb_core_arena( core ), "sdl", &ret );
dfb_sdl = ret;
dfb_sdl_core = core;
screen = dfb_screens_register( NULL, NULL, sdlPrimaryScreenFuncs );
dfb_layers_register( screen, NULL, sdlPrimaryLayerFuncs );
dfb_surface_pool_join( core, dfb_sdl->sdl_pool, &sdlSurfacePoolFuncs );
*data = dfb_sdl;
return DFB_OK;
}
static DFBResult
system_join( CoreDFB *core, void **ret_data )
{
DFBResult ret;
void *tmp;
AndroidData *android;
AndroidDataShared *shared;
D_ASSERT( m_data == NULL );
android = D_CALLOC( 1, sizeof(AndroidData) );
if (!android)
return D_OOM();
android->core = core;
ret = core_arena_get_shared_field( core, "android", &tmp );
if (ret) {
D_FREE( android );
return ret;
}
android->shared = shared = tmp;
ret = InitLocal( android );
if (ret)
return ret;
*ret_data = m_data = android;
dfb_surface_pool_join( core, shared->pool, &androidSurfacePoolFuncs );
android->screen = dfb_screens_register( NULL, android, androidScreenFuncs );
android->layer = dfb_layers_register( android->screen, android, androidLayerFuncs );
return DFB_OK;
}
DFBResult
neo2200_init_driver( CoreGraphicsDevice *device,
GraphicsDeviceFuncs *funcs,
void *driver_data )
{
Neo2200DriverData *ndrv = (Neo2200DriverData*) driver_data;
ndrv->neo2200 = (Neo2200*) ndrv->neo.mmio_base;
funcs->CheckState = neo2200CheckState;
funcs->SetState = neo2200SetState;
funcs->EngineSync = neo2200EngineSync;
funcs->FillRectangle = neo2200FillRectangle;
funcs->DrawRectangle = neo2200DrawRectangle;
// funcs->DrawLine = neoDrawLine2D;
funcs->Blit = neo2200Blit;
// funcs->StretchBlit = neoStretchBlit;
/* overlay support */
dfb_layers_register( dfb_screens_at(DSCID_PRIMARY),
driver_data, &neoOverlayFuncs );
return DFB_OK;
}
static DFBResult
driver_init_driver( CoreGraphicsDevice *device,
GraphicsDeviceFuncs *funcs,
void *driver_data,
void *device_data,
CoreDFB *core )
{
SH7722DriverData *sdrv = driver_data;
SH7722DeviceData *sdev = device_data;
D_DEBUG_AT( SH7722_Driver, "%s()\n", __FUNCTION__ );
/* Keep pointer to shared device data. */
sdrv->dev = device_data;
/* Keep core and device pointer. */
sdrv->core = core;
sdrv->device = device;
/* Open the drawing engine device. */
sdrv->gfx_fd = direct_try_open( "/dev/sh7722gfx", "/dev/misc/sh7722gfx", O_RDWR, true );
if (sdrv->gfx_fd < 0)
return DFB_INIT;
/* Map its shared data. */
sdrv->gfx_shared = mmap( NULL, direct_page_align( sizeof(SH7722GfxSharedArea) ),
PROT_READ | PROT_WRITE,
MAP_SHARED, sdrv->gfx_fd, 0 );
if (sdrv->gfx_shared == MAP_FAILED) {
D_PERROR( "SH7722/Driver: Could not map shared area!\n" );
close( sdrv->gfx_fd );
return DFB_INIT;
}
sdrv->mmio_base = dfb_gfxcard_map_mmio( device, 0, -1 );
if (!sdrv->mmio_base) {
D_PERROR( "SH7722/Driver: Could not map MMIO area!\n" );
munmap( (void*) sdrv->gfx_shared, direct_page_align( sizeof(SH7722GfxSharedArea) ) );
close( sdrv->gfx_fd );
return DFB_INIT;
}
/* Check the magic value. */
if (sdrv->gfx_shared->magic != SH7722GFX_SHARED_MAGIC) {
D_ERROR( "SH7722/Driver: Magic value 0x%08x doesn't match 0x%08x!\n",
sdrv->gfx_shared->magic, SH7722GFX_SHARED_MAGIC );
dfb_gfxcard_unmap_mmio( device, sdrv->mmio_base, -1 );
munmap( (void*) sdrv->gfx_shared, direct_page_align( sizeof(SH7722GfxSharedArea) ) );
close( sdrv->gfx_fd );
return DFB_INIT;
}
/* Get virtual addresses for LCD buffer and JPEG reload buffers in slaves here,
master does it in driver_init_device(). */
if (!dfb_core_is_master( core )) {
sdrv->lcd_virt = dfb_gfxcard_memory_virtual( device, sdev->lcd_offset );
sdrv->jpeg_virt = dfb_gfxcard_memory_virtual( device, sdev->jpeg_offset );
}
/* Initialize function table. */
funcs->EngineReset = sh7722EngineReset;
funcs->EngineSync = sh7722EngineSync;
funcs->EmitCommands = sh7722EmitCommands;
funcs->CheckState = sh7722CheckState;
funcs->SetState = sh7722SetState;
funcs->FillTriangle = sh7722FillTriangle;
funcs->Blit = sh7722Blit;
funcs->StretchBlit = sh7722StretchBlit;
funcs->FlushTextureCache = sh7722FlushTextureCache;
/* Register primary screen. */
sdrv->screen = dfb_screens_register( device, driver_data, &sh7722ScreenFuncs );
/* Register three input system layers. */
sdrv->input1 = dfb_layers_register( sdrv->screen, driver_data, &sh7722LayerFuncs );
sdrv->input2 = dfb_layers_register( sdrv->screen, driver_data, &sh7722LayerFuncs );
sdrv->input3 = dfb_layers_register( sdrv->screen, driver_data, &sh7722LayerFuncs );
/* Register multi window layer. */
sdrv->multi = dfb_layers_register( sdrv->screen, driver_data, &sh7722MultiLayerFuncs );
return DFB_OK;
}
static DFBResult
drmkmsInitScreen( CoreScreen *screen,
CoreGraphicsDevice *device,
void *driver_data,
void *screen_data,
DFBScreenDescription *description )
{
DRMKMSData *drmkms = driver_data;
DRMKMSDataShared *shared = drmkms->shared;
drmModeRes *resources;
drmModeConnector *connector = NULL;
drmModeEncoder *encoder = NULL;
uint32_t crtc = 0;
int i, j, k, l, found;
description->caps = DSCCAPS_ENCODERS | DSCCAPS_OUTPUTS;
description->encoders = 0;
shared->enabled_crtcs = 0;
direct_snputs( description->name, "DRMKMS Screen", DFB_SCREEN_DESC_NAME_LENGTH );
resources = drmkms->resources;
D_INFO( "DirectFB/DRMKMS: Got %d connectors, %d encoders\n", resources->count_connectors, resources->count_encoders );
for (i = 0; i < resources->count_connectors; i++) {
crtc = 0;
connector = drmModeGetConnector( drmkms->fd, resources->connectors[i] );
if (!connector)
continue;
if ((connector->connection == DRM_MODE_CONNECTED || connector->connection == DRM_MODE_UNKNOWNCONNECTION) && connector->count_modes > 0) {
D_INFO( "DirectFB/DRMKMS: found connected connector id %d.\n", connector->connector_id );
if (connector->encoder_id) {
D_INFO( "DirectFB/DRMKMS: connector %d is already bound to encoder %d.\n", connector->connector_id, connector->encoder_id );
encoder = drmModeGetEncoder(drmkms->fd, connector->encoder_id);
}
if (encoder)
crtc = encoder->crtc_id;
if (crtc)
D_INFO( "DirectFB/DRMKMS: encoder %d is already bound to ctrc %d.\n", connector->encoder_id, encoder->crtc_id );
else {
D_INFO( "DirectFB/DRMKMS: Seaching for appropriate encoder/crtc for connector %d.\n", connector->connector_id );
for (j = 0; j < resources->count_encoders; j++) {
int busy = 0;
encoder = drmModeGetEncoder( drmkms->fd, resources->encoders[j] );
if (encoder == NULL)
continue;
for (k=0; k<shared->enabled_crtcs; k++) {
if (drmkms->encoder[k]->encoder_id == encoder->encoder_id) {
D_INFO( "DirectFB/DRMKMS: encoder %d is already in use by connector %d\n", encoder->encoder_id, drmkms->connector[k]->connector_id );
busy = 1;
}
}
if (busy)
continue;
found = 0;
for (k = 0; k < resources->count_crtcs; k++) {
busy = 0;
if (!(encoder->possible_crtcs & (1 << k)))
continue;
for (l=0; l<shared->enabled_crtcs; l++) {
if (drmkms->encoder[l]->crtc_id == resources->crtcs[k])
busy = 1;
}
if (busy)
continue;
crtc = resources->crtcs[k];
D_INFO( "DirectFB/DRMKMS: using encoder %d and crtc %d for connector %d.\n", encoder->encoder_id, crtc, connector->connector_id );
found = 1;
break;
}
if (found)
break;
}
}
if (encoder && crtc) {
drmkms->connector[shared->enabled_crtcs] = connector;
drmkms->encoder[shared->enabled_crtcs] = encoder;
drmkms->encoder[shared->enabled_crtcs]->crtc_id = crtc;
shared->mode[shared->enabled_crtcs] = connector->modes[0];
shared->enabled_crtcs++;
if (!shared->multihead && !shared->mirror_outputs)
break;
if (shared->multihead && shared->enabled_crtcs > 1) {
dfb_layers_register( drmkms->screen, drmkms, drmkmsLayerFuncs );
}
}
else if (encoder)
drmModeFreeEncoder( encoder );
encoder = NULL;
}
else
drmModeFreeConnector( connector );
}
if (!shared->enabled_crtcs) {
D_ERROR( "DirectFB/DRMKMS: No currently active connector found.\n");
return DFB_INIT;
}
if (dfb_config->mode.width && dfb_config->mode.height) {
drmModeModeInfo *mode = drmkms_find_mode( 0, dfb_config->mode.width, dfb_config->mode.height, 0 );
if (mode)
shared->mode[0] = *mode;
}
if (shared->mirror_outputs || (dfb_config->mode.width && dfb_config->mode.height)) {
for (int i=1; i<shared->enabled_crtcs; i++)
shared->mode[i] = shared->mode[0];
}
if (shared->clone_outputs) {
if (drmkms->encoder[0]->possible_clones) {
for (i = 0; i < resources->count_crtcs; i++) {
if (drmkms->encoder[0]->possible_clones & (1 << i)) {
shared->cloned_connectors[shared->cloned_count++] = resources->connectors[0];
shared->cloned_connectors[shared->cloned_count++] = resources->connectors[1];
D_INFO( "DirectFB/DRMKMS: cloning on connector %d and %d enabled \n", resources->connectors[0], resources->connectors[1]);
break;
}
}
if (shared->cloned_count < 2) {
D_WARN( "DirectFB/DRMKMS: cloning is not possible on enough connectors, disabling.\n" );
shared->cloned_count = 0;
shared->clone_outputs = false;
}
}
else {
D_WARN( "DirectFB/DRMKMS: cloning is not possible, disabling.\n" );
shared->clone_outputs = false;
}
}
D_INFO( "DirectFB/DRMKMS: Default mode is %dx%d, we have %d modes in total\n", shared->mode[0].hdisplay, shared->mode[0].vdisplay, drmkms->connector[0]->count_modes );
drmkms->resources = resources;
drmkms->saved_crtc = drmModeGetCrtc( drmkms->fd, drmkms->encoder[0]->crtc_id );
description->outputs = shared->enabled_crtcs;
description->encoders = shared->enabled_crtcs;
return DFB_OK;
}
CoreLayer *
sh_du_layer_register( CoreScreen *screen, void *driver_data)
{
return dfb_layers_register( screen, driver_data, &sh_du_layer_funcs );
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
int i, n;
CoreScreen *screen;
D_ASSERT( dfb_x11 == NULL );
dfb_x11 = (DFBX11*) SHCALLOC( dfb_core_shmpool(core), 1, sizeof(DFBX11) );
if (!dfb_x11) {
D_ERROR( "DirectFB/X11: Couldn't allocate shared memory!\n" );
return D_OOSHM();
}
dfb_x11_core = core;
fusion_skirmish_init( &dfb_x11->lock, "X11 System", dfb_core_world(core) );
fusion_call_init( &dfb_x11->call, call_handler, NULL, dfb_core_world(core) );
dfb_surface_pool_initialize( core, &x11SurfacePoolFuncs, &dfb_x11->surface_pool );
screen = dfb_screens_register( NULL, NULL, &x11PrimaryScreenFuncs );
dfb_layers_register( screen, NULL, &x11PrimaryLayerFuncs );
fusion_arena_add_shared_field( dfb_core_arena( core ), "x11", dfb_x11 );
*data = dfb_x11;
XInitThreads();
dfb_x11->data_shmpool = dfb_core_shmpool_data( core );
dfb_x11->display = XOpenDisplay(getenv("DISPLAY"));
if (!dfb_x11->display) {
D_ERROR("X11: Error in XOpenDisplay for '%s'\n", getenv("DISPLAY"));
return DFB_INIT;
}
dfb_x11->screenptr = DefaultScreenOfDisplay(dfb_x11->display);
dfb_x11->screennum = DefaultScreen(dfb_x11->display);
for (i=0; i<dfb_x11->screenptr->ndepths; i++) {
const Depth *depth = &dfb_x11->screenptr->depths[i];
for (n=0; n<depth->nvisuals; n++) {
Visual *visual = &depth->visuals[n];
D_DEBUG( "X11/Visual: ID %02lu, depth %d, red 0x%06lx, green 0x%06lx, blue 0x%06lx, %d bits/rgb, %d entries\n",
visual->visualid, depth->depth,
visual->red_mask, visual->green_mask, visual->blue_mask,
visual->bits_per_rgb, visual->map_entries );
switch (depth->depth) {
case 24:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff) {
dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual;
dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)] = visual;
}
break;
case 16:
if (visual->red_mask == 0xf800 &&
visual->green_mask == 0x07e0 &&
visual->blue_mask == 0x001f)
dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)] = visual;
break;
case 15:
if (visual->red_mask == 0x7c00 &&
visual->green_mask == 0x03e0 &&
visual->blue_mask == 0x001f)
dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)] = visual;
break;
}
}
}
return DFB_OK;
}
static DFBResult
InitLocal( DFBX11 *x11, DFBX11Shared *shared, CoreDFB *core )
{
int i, n, d;
XInitThreads();
x11->shared = shared;
x11->core = core;
x11->display = XOpenDisplay(getenv("DISPLAY"));
if (!x11->display) {
D_ERROR("X11: Error in XOpenDisplay for '%s'\n", getenv("DISPLAY"));
return DFB_INIT;
}
x11->screenptr = DefaultScreenOfDisplay(x11->display);
x11->screennum = DefaultScreen(x11->display);
d = DefaultDepthOfScreen(x11->screenptr);
for (i=0; i<x11->screenptr->ndepths; i++) {
const Depth *depth = &x11->screenptr->depths[i];
for (n=0; n<depth->nvisuals; n++) {
Visual *visual = &depth->visuals[n];
D_DEBUG_AT( X11_Core, "[Visual %d] ID 0x%02lx, depth %d, RGB 0x%06lx/0x%06lx/0x%06lx, %d bpRGB, %d entr.\n",
n, visual->visualid, depth->depth,
visual->red_mask, visual->green_mask, visual->blue_mask,
visual->bits_per_rgb, visual->map_entries );
if (depth->depth != d)
continue;
switch (depth->depth) {
case 32:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)] = visual;
break;
case 24:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual;
break;
case 16:
if (visual->red_mask == 0xf800 &&
visual->green_mask == 0x07e0 &&
visual->blue_mask == 0x001f &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)] = visual;
break;
case 15:
if (visual->red_mask == 0x7c00 &&
visual->green_mask == 0x03e0 &&
visual->blue_mask == 0x001f &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)] = visual;
break;
}
}
}
if (XShmQueryExtension( x11->display ))
XShmQueryVersion( x11->display, &x11->xshm_major, &x11->xshm_minor, &x11->use_shm );
x11->screen = dfb_screens_register( NULL, x11, x11PrimaryScreenFuncs );
dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs );
dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs );
dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs );
return DFB_OK;
}
static DFBResult
InitLocal( DFBX11 *x11, DFBX11Shared *shared, CoreDFB *core )
{
int i, n;
XInitThreads();
if (direct_config_get_int_value( "x11-sync" ))
x11->Sync = sync_display;
else
x11->Sync = sync_display_noop;
x11->shared = shared;
x11->core = core;
x11->display = XOpenDisplay(getenv("DISPLAY"));
if (!x11->display) {
D_ERROR("X11: Error in XOpenDisplay for '%s'\n", getenv("DISPLAY"));
return DFB_INIT;
}
x11->screenptr = DefaultScreenOfDisplay(x11->display);
x11->screennum = DefaultScreen(x11->display);
D_DEBUG_AT( X11_Core, " -> ndepths %d\n", x11->screenptr->ndepths);
for (i=0; i<x11->screenptr->ndepths; i++) {
const Depth *depth = &x11->screenptr->depths[i];
D_DEBUG_AT( X11_Core, " -> [%d] depth %d, nvisuals %d\n", i, depth->depth, depth->nvisuals );
for (n=0; n<depth->nvisuals; n++) {
Visual *visual = &depth->visuals[n];
D_DEBUG_AT( X11_Core, "[Visual %d] ID 0x%02lx, depth %d, RGB 0x%06lx/0x%06lx/0x%06lx, %d bpRGB, %d entr.\n",
n, visual->visualid, depth->depth,
visual->red_mask, visual->green_mask, visual->blue_mask,
visual->bits_per_rgb, visual->map_entries );
//if (depth->depth != d)
// continue;
//if (visual->visualid == 0x24) {
// x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual;
// continue;
//}
switch (depth->depth) {
case 32:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)] = visual;
break;
case 24:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual;
break;
case 16:
if (visual->red_mask == 0xf800 &&
visual->green_mask == 0x07e0 &&
visual->blue_mask == 0x001f &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)] = visual;
break;
case 15:
if (visual->red_mask == 0x7c00 &&
visual->green_mask == 0x03e0 &&
visual->blue_mask == 0x001f &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)] = visual;
break;
}
}
}
DFBSurfacePixelFormat formats[] = { DSPF_ARGB, DSPF_RGB32, DSPF_RGB16, DSPF_RGB555 };
for (i=0; i<D_ARRAY_SIZE(formats); i++) {
Visual *visual = x11->visuals[DFB_PIXELFORMAT_INDEX(formats[i])];
if (visual) {
D_DEBUG_AT( X11_Core, " %-20s [Visual ID 0x%02lx] RGB 0x%06lx/0x%06lx/0x%06lx, %d bpRGB, %d entr.\n",
dfb_pixelformat_name(formats[i]), visual->visualid, visual->red_mask, visual->green_mask, visual->blue_mask,
visual->bits_per_rgb, visual->map_entries );
}
else
D_DEBUG_AT( X11_Core, " %-20s [NO VISUAL]\n", dfb_pixelformat_name(formats[i]) );
}
if (XShmQueryExtension( x11->display ))
XShmQueryVersion( x11->display, &x11->xshm_major, &x11->xshm_minor, &x11->use_shm );
x11->use_shm = 0;
x11->screen = dfb_screens_register( NULL, x11, x11PrimaryScreenFuncs );
for (i=0; i<shared->outputs * shared->layers; i++) {
if (!dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs ))
return DFB_INIT;
}
return DFB_OK;
}