void QDirectFBPixmapData::resize(int width, int height)
{
if (width <= 0 || height <= 0) {
setSerialNumber(0);
return;
}
IDirectFB *dfb = QDirectFBScreen::instance()->dfb();
if (!dfb)
qFatal("QDirectFBPixmapData::resize(): "
"Unable to get DirectFB handle!");
DFBSurfaceDescription description;
description.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH |
DSDESC_HEIGHT);
description.width = width;
description.height = height;
DFBResult result = dfb->CreateSurface(dfb, &description, &surface);
if (result != DFB_OK) {
DirectFBErrorFatal("QDirectFBPixmapData::resize(): "
"Unable to allocate surface", result);
}
setSerialNumber(++global_ser_no);
}
IDirectFBSurface *QDirectFbTextureGlyphCache::sourceSurface()
{
if (m_surface.isNull()) {
const QImage &source = image();
DFBSurfaceDescription desc;
memset(&desc, 0, sizeof(desc));
desc.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_PREALLOCATED | DSDESC_CAPS);
desc.width = source.width();
desc.height = source.height();
desc.caps = DSCAPS_SYSTEMONLY;
switch (source.format()) {
case QImage::Format_Mono:
desc.pixelformat = DSPF_A1;
break;
case QImage::Format_Alpha8:
desc.pixelformat = DSPF_A8;
break;
default:
qFatal("QDirectFBTextureGlyphCache: Unsupported source texture image format.");
break;
}
desc.preallocated[0].data = const_cast<void*>(static_cast<const void*>(source.bits()));
desc.preallocated[0].pitch = source.bytesPerLine();
desc.preallocated[1].data = 0;
desc.preallocated[1].pitch = 0;
IDirectFB *dfb = QDirectFbConvenience::dfbInterface();
dfb->CreateSurface(dfb , &desc, m_surface.outPtr());
}
return m_surface.data();
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
IDirectFB *dfb;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/Resize: DirectFBInit() failed!\n" );
return ret;
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Resize: DirectFBCreate() failed!\n" );
return ret;
}
/* Required for keyboard access */
dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN );
TestResize( dfb );
/* Shutdown DirectFB. */
dfb->Release( dfb );
return ret;
}
int testing_multicore() {
IDirectFB *dfb = NULL;
IDirectFBSurface *surface = NULL;
DFBSurfaceDescription dsc;
pid_t n_pid = fork();
if (n_pid) {
sleep(1);
}
DFBCHECK(DirectFBInit(NULL, NULL));
DFBCHECK(DirectFBCreate(&dfb));
push_release(dfb, dfb->Release);
DFBCHECK(dfb->SetCooperativeLevel (dfb, DFSCL_FULLSCREEN));
dsc.flags = DSDESC_CAPS;
dsc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING;
DFBCHECK (dfb->CreateSurface( dfb, &dsc, &surface ));
push_release(surface, surface->Release);
if (!n_pid) {
sleep(1);
}
sleep(2);
//DFBCHECK(surface->Release(surface));
//DFBCHECK(dfb->Release(dfb));
release_all();
if (n_pid) {
wait(NULL);
}
return 0;
}
QDirectFbBlitter::QDirectFbBlitter(const QSize &rect, bool alpha)
: QBlittable(rect, dfb_blitter_capabilities())
, m_premult(false)
, m_debugPaint(false)
{
DFBSurfaceDescription surfaceDesc;
memset(&surfaceDesc,0,sizeof(DFBSurfaceDescription));
surfaceDesc.width = rect.width();
surfaceDesc.height = rect.height();
// force alpha format to get AlphaFillRectCapability and ExtendedPixmapCapability support
alpha = true;
if (alpha) {
m_premult = true;
surfaceDesc.caps = DSCAPS_PREMULTIPLIED;
surfaceDesc.pixelformat = QDirectFbBlitter::alphaPixmapFormat();
surfaceDesc.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_CAPS | DSDESC_PIXELFORMAT);
} else {
surfaceDesc.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT);
surfaceDesc.pixelformat = QDirectFbBlitter::pixmapFormat();
}
if (qEnvironmentVariableIntValue("QT_DIRECTFB_BLITTER_DEBUGPAINT"))
m_debugPaint = true;
IDirectFB *dfb = QDirectFbConvenience::dfbInterface();
dfb->CreateSurface(dfb , &surfaceDesc, m_surface.outPtr());
m_surface->Clear(m_surface.data(), 0, 0, 0, 0);
}
bool QDirectFBPixmapData::fromDataBufferDescription(const DFBDataBufferDescription &dataBufferDescription)
{
IDirectFB *dfb = screen->dfb();
Q_ASSERT(dfb);
DFBResult result = DFB_OK;
IDirectFBDataBuffer *dataBufferPtr;
if ((result = dfb->CreateDataBuffer(dfb, &dataBufferDescription, &dataBufferPtr)) != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fromDataBufferDescription()", result);
return false;
}
QDirectFBPointer<IDirectFBDataBuffer> dataBuffer(dataBufferPtr);
IDirectFBImageProvider *providerPtr;
if ((result = dataBuffer->CreateImageProvider(dataBuffer.data(), &providerPtr)) != DFB_OK)
return false;
QDirectFBPointer<IDirectFBImageProvider> provider(providerPtr);
DFBImageDescription imageDescription;
result = provider->GetImageDescription(provider.data(), &imageDescription);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fromSurfaceDescription(): Can't get image description", result);
return false;
}
if (imageDescription.caps & DICAPS_COLORKEY) {
return false;
}
DFBSurfaceDescription surfaceDescription;
if ((result = provider->GetSurfaceDescription(provider.data(), &surfaceDescription)) != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fromDataBufferDescription(): Can't get surface description", result);
return false;
}
alpha = imageDescription.caps & DICAPS_ALPHACHANNEL;
imageFormat = alpha ? screen->alphaPixmapFormat() : screen->pixelFormat();
dfbSurface = screen->createDFBSurface(QSize(surfaceDescription.width, surfaceDescription.height),
imageFormat, QDirectFBScreen::TrackSurface);
result = provider->RenderTo(provider.data(), dfbSurface, 0);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fromSurfaceDescription(): Can't render to surface", result);
return false;
}
w = surfaceDescription.width;
h = surfaceDescription.height;
is_null = (w <= 0 || h <= 0);
d = QDirectFBScreen::depth(imageFormat);
setSerialNumber(++global_ser_no);
#if defined QT_DIRECTFB_IMAGEPROVIDER_KEEPALIVE
screen->setDirectFBImageProvider(providerPtr);
provider.take();
#endif
return true;
}
int get_display_layer_window() {
IDirectFB *dfb = NULL;
IDirectFBDisplayLayer *layer = NULL;
IDirectFBWindow *window = NULL;
DFBWindowDescription desc;
DFBCHECK(DirectFBInit(NULL, NULL));
DFBCHECK(DirectFBCreate(&dfb));
push_release(dfb,dfb->Release);
DFBCHECK(dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &layer));
push_release(layer, layer->Release);
desc.flags = DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_POSX | DWDESC_POSY;
desc.posx = desc.posy = desc.width = desc.height = 20;
DFBCHECK(layer->CreateWindow(layer, &desc, &window));
push_release(window, window->Release);
/* check window */
release_all();
return 0;
}
static int OpenDisplay(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
DFBSurfaceDescription dsc;
/*dsc.flags = DSDESC_CAPS | DSDESC_HEIGHT | DSDESC_WIDTH;*/
dsc.flags = DSDESC_CAPS;
dsc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING;
/*dsc.width = 352;*/
/*dsc.height = 240;*/
IDirectFB *directfb = NULL;
if (DirectFBCreate(&directfb) != DFB_OK || !directfb)
return VLC_EGENERIC;
sys->directfb = directfb;
IDirectFBSurface *primary = NULL;
if (directfb->CreateSurface(directfb, &dsc, &primary) || !primary)
return VLC_EGENERIC;
sys->primary = primary;
primary->GetSize(primary, &sys->width, &sys->height);
primary->GetPixelFormat(primary, &sys->pixel_format);
primary->FillRectangle(primary, 0, 0, sys->width, sys->height);
primary->Flip(primary, NULL, 0);
return VLC_SUCCESS;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
IDirectFB *dfb;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/Init: DirectFBInit() failed!\n" );
return ret;
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Init: DirectFBCreate() failed!\n" );
return ret;
}
/* Shutdown DirectFB. */
ret = dfb->Release( dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Init: IDirectFB::Release() failed!\n" );
return ret;
}
return 0;
}
int
main( int argc, char** argv )
{
IDirectFB *dfb = NULL;
ISaWMan *saw = NULL;
ISaWManManager *manager = NULL;
D_INFO( "SaWMan/Sample1: Initializing...\n" );
CHECK( DirectFBInit( &argc, &argv ) );
CHECK( DirectFBCreate( &dfb ) );
CHECK( SaWManCreate( &saw ) );
CHECK( saw->CreateManager( saw, &callbacks, NULL, &manager ) );
pause();
out:
D_INFO( "SaWMan/Sample1: Shutting down...\n" );
if (manager)
manager->Release( manager );
if (saw)
saw->Release( saw );
if (dfb)
dfb->Release( dfb );
return 0;
}
DFBImageProvider::DFBImageProvider(const char* mrl) {
IDirectFB* dfb = NULL;
decoder = NULL;
if (mrl != NULL) {
dfb = (IDirectFB*)(LocalDeviceManager::getInstance()->getGfxRoot());
DFBCHECK(dfb->CreateImageProvider(dfb, mrl, &decoder));
}
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
int i;
IDirectFB *dfb;
DFBInputDeviceID device_id = 0;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/Input: DirectFBInit() failed!\n" );
return ret;
}
/* Parse arguments. */
for (i=1; i<argc; i++) {
const char *arg = argv[i];
if (strcmp( arg, "-h" ) == 0 || strcmp (arg, "--help") == 0)
return print_usage( argv[0] );
else if (strcmp (arg, "-v") == 0 || strcmp (arg, "--version") == 0) {
fprintf (stderr, "dfbtest_input version %s\n", DIRECTFB_VERSION);
return false;
}
else if (strcmp (arg, "-d") == 0 || strcmp (arg, "--device") == 0) {
if (++i == argc) {
print_usage (argv[0]);
return false;
}
if (!parse_id( argv[i], &device_id ))
return false;
}
else
return print_usage( argv[0] );
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Input: DirectFBCreate() failed!\n" );
return ret;
}
Test_Sensitivity( dfb, device_id );
/* Shutdown DirectFB. */
ret = dfb->Release( dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Input: IDirectFB::Release() failed!\n" );
return ret;
}
return 0;
}
int
main( int argc, char *argv[] )
{
int i;
DFBResult ret;
IDirectFB *dfb;
IDirectFBDisplayLayer *layer = NULL;
App apps[1];
DFBDisplayLayerConfig config;
/* Parse arguments. */
for (i=1; i<argc; i++) {
if (!strcmp( argv[i], "-h" ))
return show_usage( argv[0] );
}
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/WindowFlip: DirectFBInit() failed!\n" );
return ret;
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/WindowFlip: DirectFBCreate() failed!\n" );
return ret;
}
/* Get primary layer. */
ret = dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer );
if (ret) {
D_DERROR( ret, "DFBTest/WindowFlip: IDirectFB::GetDisplayLayer( PRIMARY ) failed!\n" );
goto out;
}
layer->GetConfiguration( layer, &config );
app_init( &apps[0], layer, 100, 50, config.width-300, config.height-150, 0 );
while (true) {
direct_thread_sleep( 1000000 );
app_update( &apps[0] );
}
out:
/* Shutdown DirectFB. */
dfb->Release( dfb );
return ret;
}
static void CloseDisplay(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
IDirectFBSurface *primary = sys->primary;
if (primary)
primary->Release(primary);
IDirectFB *directfb = sys->directfb;
if (directfb)
directfb->Release(directfb);
}
bool QDirectFbBlitterPlatformPixmap::fromDataBufferDescription(const DFBDataBufferDescription &dataBufferDescription)
{
DFBResult result;
IDirectFB *dfb = QDirectFbConvenience::dfbInterface();
// Create a data buffer
QDirectFBPointer<IDirectFBDataBuffer> dataBuffer;
result = dfb->CreateDataBuffer(dfb, &dataBufferDescription, dataBuffer.outPtr());
if (result != DFB_OK) {
DirectFBError(QDFB_PRETTY, result);
return false;
}
// Create the image provider
QDirectFBPointer<IDirectFBImageProvider> provider;
result = dataBuffer->CreateImageProvider(dataBuffer.data(), provider.outPtr());
if (result != DFB_OK) {
DirectFBError(QDFB_PRETTY, result);
return false;
}
// Extract image information
DFBImageDescription imageDescription;
result = provider->GetImageDescription(provider.data(), &imageDescription);
if (result != DFB_OK) {
DirectFBError(QDFB_PRETTY, result);
return false;
}
// Can we handle this directlu?
if (imageDescription.caps & DICAPS_COLORKEY)
return false;
DFBSurfaceDescription surfaceDescription;
result = provider->GetSurfaceDescription(provider.data(), &surfaceDescription);
if (result != DFB_OK) {
DirectFBError(QDFB_PRETTY, result);
return false;
}
m_alpha = imageDescription.caps & DICAPS_ALPHACHANNEL;
resize(surfaceDescription.width, surfaceDescription.height);
// TODO: FIXME; update d
result = provider->RenderTo(provider.data(), dfbBlitter()->dfbSurface(), 0);
if (result != DFB_OK) {
DirectFBError(QDFB_PRETTY, result);
return false;
}
return true;
}
DFBFontProvider::DFBFontProvider(const char* fontUri, int heightInPixel) {
IDirectFB* dfb;
DFBFontDescription desc;
dfb = (IDirectFB*)(LocalDeviceManager::getInstance()->getGfxRoot());
desc.flags = (DFBFontDescriptionFlags)(
DFDESC_HEIGHT | DFDESC_ATTRIBUTES);
desc.height = heightInPixel;
desc.attributes = (DFBFontAttributes)0;
DFBCHECK(dfb->CreateFont(dfb, fontUri, &desc, &font));
}
DFBEventBuffer::DFBEventBuffer() {
IDirectFB* dfb;
dfb = (IDirectFB*)(LocalDeviceManager::getInstance()->getGfxRoot());
//dfb_true => the focus doesn't matter
DFBCHECK(dfb->CreateInputEventBuffer(
dfb,
DICAPS_ALL,
DFB_TRUE,
&eventBuffer));
pool->insert(eventBuffer);
}
void QDirectFBPixmapData::fill(const QColor &color)
{
if (!serialNumber())
return;
Q_ASSERT(surface);
if (color.alpha() < 255 && !hasAlphaChannel()) {
// convert to surface supporting alpha channel
DFBSurfacePixelFormat format;
surface->GetPixelFormat(surface, &format);
switch (format) {
case DSPF_YUY2:
case DSPF_UYVY:
format = DSPF_AYUV;
break;
#if (Q_DIRECTFB_VERSION >= 0x010100)
case DSPF_RGB444:
format = DSPF_ARGB4444;
break;
case DSPF_RGB555:
#endif
case DSPF_RGB18:
format = DSPF_ARGB6666;
break;
default:
format = DSPF_ARGB;
break;
}
DFBSurfaceDescription description;
description.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH |
DSDESC_HEIGHT |
DSDESC_PIXELFORMAT);
surface->GetSize(surface, &description.width, &description.height);
description.pixelformat = format;
surface->Release(surface); // release old surface
IDirectFB *fb = QDirectFBScreen::instance()->dfb();
DFBResult result = fb->CreateSurface(fb, &description, &surface);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fill()", result);
setSerialNumber(0);
return;
}
}
surface->Clear(surface, color.red(), color.green(), color.blue(),
color.alpha());
}
QImage QDirectFBPixmapData::toImage() const
{
if (!surface)
return QImage();
#ifdef QT_NO_DIRECTFB_PREALLOCATED
QDirectFBPixmapData *that = const_cast<QDirectFBPixmapData*>(this);
const QImage *img = that->buffer();
const QImage copied = img->copy();
that->unlockDirectFB();
return copied;
#else
int w, h;
surface->GetSize(surface, &w, &h);
DFBSurfacePixelFormat format;
surface->GetPixelFormat(surface, &format);
QImage::Format imageFormat = QDirectFBScreen::getImageFormat(format);
if (imageFormat == QImage::Format_Invalid)
imageFormat = QImage::Format_ARGB32_Premultiplied;
imageFormat = QImage::Format_ARGB32;
QImage image(w, h, imageFormat);
DFBSurfaceDescription description;
description = QDirectFBScreen::getSurfaceDescription(image);
IDirectFB *fb = QDirectFBScreen::instance()->dfb();
IDirectFBSurface *imgSurface;
DFBResult result = fb->CreateSurface(fb, &description, &imgSurface);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::toImage()", result);
return QImage();
}
imgSurface->SetBlittingFlags(imgSurface, DSBLIT_NOFX);
result = imgSurface->Blit(imgSurface, surface, 0, 0, 0);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::toImage() blit failed", result);
return QImage();
}
imgSurface->Release(imgSurface);
return image;
#endif // QT_NO_DIRECTFB_PREALLOCATED
}
DFBDataBuffer::DFBDataBuffer(void* data, unsigned int dataSize) : Thread() {
IDirectFB* dfb = NULL;
deviceUri = NULL;
deviceFd = -1;
this->dataSize = dataSize;
this->data = new char[dataSize];
desc.file = NULL;
desc.memory.data = data;
desc.memory.length = dataSize;
desc.flags = (DFBDataBufferDescriptionFlags)DBDESC_MEMORY;
dfb = (IDirectFB*)(LocalDeviceManager::getInstance()->getGfxRoot());
dfb->CreateDataBuffer(dfb, &desc, &dataBuffer);
}
static int l_new (lua_State* L)
{
// [ IDFBSurface | dfb | dsc ]
IDirectFB* dfb = * (IDirectFB**) luaL_checkudata(L, 2, "ldirectfb.IDirectFB");
DFBSurfaceDescription dsc;
table2DFBSurfaceDescription (L, &dsc);
IDirectFBSurface* sfc;
//dsc.flags = dsc.flags & DSDESC_PIXELFORMAT;
//dsc.pixelformat = DSPF_LUT8;
//dsc.caps = DSCAPS_ALL;
//printf("SFC: %d, %d\n", dsc.width, dsc.height);
DFBCHECK( dfb->CreateSurface(dfb, &dsc, &sfc) );
lua_pushlightuserdata(L, sfc); // [ IDFBSurface | dfb | dsc | win ]
l_IDirectFBSurface_toudata(L); // [ IDFBSurface | dfb | dsc | _win ]
return 1;
}
int get_display_layer() {
IDirectFB *dfb = NULL;
IDirectFBDisplayLayer *layer = NULL;
DFBCHECK(DirectFBInit(NULL, NULL));
DFBCHECK(DirectFBCreate(&dfb));
push_release(dfb, dfb->Release);
DFBCHECK(dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &layer));
push_release(layer, layer->Release);
release_all();
return 0;
}
int list_layers() {
IDirectFB *dfb = NULL;
//IDirectFBSurface *surface = NULL;
//IDirectFBLayer *layer = NULL;
DFBCHECK(DirectFBInit(NULL, NULL));
DFBCHECK(DirectFBCreate(&dfb));
push_release(dfb, dfb->Release);
DFBCHECK(dfb->EnumDisplayLayers(dfb, layer_cb, dfb));
sleep(1);
release_all();
return 0;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
int i;
IDirectFB *dfb;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/Blit: DirectFBInit() failed!\n" );
return ret;
}
/* Parse arguments. */
for (i=1; i<argc; i++) {
const char *arg = argv[i];
if (strcmp( arg, "-h" ) == 0 || strcmp (arg, "--help") == 0)
return print_usage( argv[0] );
else if (strcmp (arg, "-v") == 0 || strcmp (arg, "--version") == 0) {
fprintf (stderr, "dfbtest_blit version %s\n", DIRECTFB_VERSION);
return false;
}
else
return print_usage( argv[0] );
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Blit: DirectFBCreate() failed!\n" );
return ret;
}
Test_Clipboard_Set( dfb, "text/plain", "This is a test string for clipboard" );
Test_Clipboard_Get( dfb );
/* Shutdown DirectFB. */
dfb->Release( dfb );
return ret;
}
int main(int argc, char** argv) {
IDirectFB *dfb = NULL;
IDirectFBDisplayLayer *layer = NULL;
IDirectFBSurface *surface = NULL;
IDirectFBVideoProvider *vp = NULL;
CHECK(DirectFBInit (&argc, &argv));
if (argc != 2) {
return 1;
}
CHECK(DirectFBCreate(&dfb));
/* Signals */
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGUSR1, signal_handler);
signal(SIGUSR2, signal_handler);
CHECK(dfb->GetDisplayLayer(dfb, 0, &layer));
CHECK(dfb->CreateVideoProvider(dfb, argv[1], &vp));
CHECK(layer->GetSurface(layer, &surface));
CHECK(vp->PlayTo(vp, surface, NULL, flip, surface));
while(to_exit == 0) {
sleep(1);
}
CHECK(vp->Stop(vp));
CHECK(vp->Release(vp));
CHECK(surface->Release(surface));
CHECK(layer->Release(layer));
CHECK(dfb->Release(dfb));
return 0;
}
void QDirectFBPixmapData::copy(const QPixmapData *data, const QRect &rect)
{
if (data->classId() != DirectFBClass) {
QPixmapData::copy(data, rect);
return;
}
IDirectFBSurface *src = static_cast<const QDirectFBPixmapData*>(data)->surface;
DFBSurfaceDescription description;
description.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH |
DSDESC_HEIGHT |
DSDESC_PIXELFORMAT);
description.width = rect.width();
description.height = rect.height();
src->GetPixelFormat(src, &description.pixelformat);
IDirectFB *fb = QDirectFBScreen::instance()->dfb();
DFBResult result = fb->CreateSurface(fb, &description, &surface);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::copy()", result);
setSerialNumber(0);
return;
}
#ifndef QT_NO_DIRECTFB_PALETTE
IDirectFBPalette *palette;
src->GetPalette(src, &palette);
surface->SetPalette(surface, palette);
#endif
surface->SetBlittingFlags(surface, DSBLIT_NOFX);
const DFBRectangle blitRect = { rect.x(), rect.y(),
rect.width(), rect.height() };
result = surface->Blit(surface, src, &blitRect, 0, 0);
if (result != DFB_OK)
DirectFBError("QDirectFBPixmapData::copy()", result);
setSerialNumber(++global_ser_no);
}
QDirectFbBlitter::QDirectFbBlitter(const QSize &rect, bool alpha)
: QBlittable(rect, dfb_blitter_capabilities())
{
DFBSurfaceDescription surfaceDesc;
memset(&surfaceDesc,0,sizeof(DFBSurfaceDescription));
surfaceDesc.width = rect.width();
surfaceDesc.height = rect.height();
if (alpha) {
surfaceDesc.caps = DSCAPS_PREMULTIPLIED;
surfaceDesc.pixelformat = QDirectFbBlitter::alphaPixmapFormat();
surfaceDesc.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_CAPS | DSDESC_PIXELFORMAT);
} else {
surfaceDesc.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT);
surfaceDesc.pixelformat = QDirectFbBlitter::pixmapFormat();
}
IDirectFB *dfb = QDirectFbConvenience::dfbInterface();
dfb->CreateSurface(dfb , &surfaceDesc, m_surface.outPtr());
m_surface->Clear(m_surface.data(), 0, 0, 0, 0);
}
GdkColormap*
gdk_colormap_new (GdkVisual *visual,
gboolean private_cmap)
{
GdkColormap *colormap;
gint i;
g_return_val_if_fail (visual != NULL, NULL);
colormap = g_object_new (gdk_colormap_get_type (), NULL);
colormap->visual = visual;
colormap->size = visual->colormap_size;
switch (visual->type)
{
case GDK_VISUAL_PSEUDO_COLOR:
{
IDirectFB *dfb = _gdk_display->directfb;
IDirectFBPalette *palette;
GdkColormapPrivateDirectFB *private;
DFBPaletteDescription dsc;
dsc.flags = DPDESC_SIZE;
dsc.size = colormap->size;
if (!dfb->CreatePalette (dfb, &dsc, &palette))
return NULL;
colormap->colors = g_new0 (GdkColor, colormap->size);
private = g_new0 (GdkColormapPrivateDirectFB, 1);
private->info = g_new0 (GdkColorInfo, colormap->size);
if (visual == gdk_visual_get_system())
{
/* save the first (transparent) palette entry */
private->info[0].ref_count++;
}
int
main( int argc, char** argv )
{
IDirectFB *dfb = NULL;
ISaWMan *saw = NULL;
pid_t pid;
D_INFO( "SaWMan/TestRun: Initializing...\n" );
CHECK( DirectFBInit( &argc, &argv ) );
CHECK( DirectFBCreate( &dfb ) );
CHECK( SaWManCreate( &saw ) );
CHECK( saw->Start( saw, ((argc > 1) && argv[1]) ? argv[1] : "Test Application", &pid ) );
D_INFO( "SaWMan/TestRun: New process has pid %d.\n", pid );
// sleep( 2 );
// CHECK( saw->Stop( saw, pid ) );
out:
D_INFO( "SaWMan/TestRun: Shutting down...\n" );
if (saw)
saw->Release( saw );
if (dfb)
dfb->Release( dfb );
return 0;
}
Surface( EGL &egl,
IDirectFB dfb,
int width,
int height,
IDirectFBEventBuffer events )
:
egl( egl )
{
DFBSurfaceDescription desc;
/* Fill description for a shared offscreen surface. */
desc.flags = (DFBSurfaceDescriptionFlags)(DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
desc.caps = (DFBSurfaceCapabilities)(DSCAPS_SHARED | DSCAPS_TRIPLE);
desc.width = width;
desc.height = height;
/* Create a primary surface. */
surface = dfb.CreateSurface( desc );
surface.MakeClient();
/* Create event buffer */
surface.AttachEventBuffer( events );
surface_id = surface.GetID();
surface.AllowAccess( "*" );
surface.Clear( 0xff, 0xff, 0xff, 0xff );
D_INFO( "DFBTest/EGLCompositor: Created new surface with ID %u\n", surface_id );
image = egl.CreateImage( EGL_NO_CONTEXT, EGL_IMAGE_IDIRECTFBSURFACE_DIRECTFB, (EGLClientBuffer) surface.iface, NULL );
glGenTextures( 1, &tex );
glBindTexture( GL_TEXTURE_2D, tex );
egl.EGLImageTargetTexture2D( GL_TEXTURE_2D, image );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glDisable( GL_CULL_FACE );
glDisable( GL_DEPTH_TEST );
}
