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 DFBImageProvider::playOver(ISurface* surface) { IDirectFBImageProvider* ip; ip = (IDirectFBImageProvider*)decoder; IDirectFBSurface* s; s = (IDirectFBSurface*)(surface->getContent()); DFBCHECK(ip->RenderTo(ip, s, NULL)); }
Image *Renderer::loadImage(const char *path, float scaleFactor, const char *prescaled) { if (!path || !path[0]) return NULL; unsigned key = hash(path) + (unsigned)(100*scaleFactor); if (m_image_cache.find(key) == m_image_cache.end()) { Image *image = new Image; image->surface = NULL; image->dsc.preallocated[0].data = NULL; IDirectFBImageProvider *provider = NULL; DFBSurfaceDescription &dsc = image->dsc; if (prescaled) path = prescaled; if (m_dfb->CreateImageProvider(m_dfb, path, &provider) == DFB_OK) { if (provider->GetSurfaceDescription(provider, &dsc) == DFB_OK) { if (!prescaled) { dsc.width = (int)(dsc.width * scaleFactor * m_scale); dsc.height = (int)(dsc.height * scaleFactor * m_scale); } dsc.flags = (DFBSurfaceDescriptionFlags)(dsc.flags | DSDESC_CAPS); dsc.caps = (DFBSurfaceCapabilities)(DSCAPS_VIDEOONLY); if ((image->surface = createSurface(&dsc))) { void *data; int pitch; provider->RenderTo(provider, image->surface, NULL); dsc.flags = (DFBSurfaceDescriptionFlags)(dsc.flags | DSDESC_PREALLOCATED); image->surface->Lock(image->surface, DSLF_READ, &data, &pitch); if ((dsc.preallocated[0].data = malloc(pitch * dsc.height))) { memcpy(dsc.preallocated[0].data, data, pitch * dsc.height); dsc.preallocated[0].pitch = pitch; dsc.preallocated[1].data = NULL; dsc.preallocated[1].pitch = 0; } image->surface->Unlock(image->surface); } else { debug("CreateSurface failed\n"); } } else { debug("GetSurfaceDescription failed\n"); } provider->Release(provider); } else { debug("CreateImageProvider failed\n"); } m_image_cache[key] = image; } return m_image_cache[key]; }
DFBResult ICore_Real::CreateImageProvider( u32 buffer_call, u32 *ret_call ) { DFBResult ret; IDirectFBDataBuffer *buffer; IDirectFBImageProvider *provider; ImageProviderDispatch *dispatch; D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Real::%s()\n", __FUNCTION__ ); D_MAGIC_ASSERT( obj, CoreDFB ); D_ASSERT( ret_call != NULL ); DIRECT_ALLOCATE_INTERFACE( buffer, IDirectFBDataBuffer ); if (!buffer) return (DFBResult) D_OOM(); /* Construct data buffer client */ ret = IDirectFBDataBuffer_Client_Construct( buffer, core, buffer_call ); if (ret) return ret; /* Create image provider */ ret = buffer->CreateImageProvider( buffer, &provider ); if (ret) { buffer->Release( buffer ); return ret; } /* Create dispatch object */ ret = ImageProviderDispatch_Create( idirectfb_singleton, buffer, provider, &dispatch ); if (ret) { provider->Release( provider ); buffer->Release( buffer ); return ret; } *ret_call = dispatch->call.call_id; return DFB_OK; }
void load_stars() { IDirectFBImageProvider *provider; DFBSurfaceDescription dsc; int i; char name[ strlen(DATADIR"/star.png") + 4 ]; for (i=0; i<NUM_STARS; i++) { sprintf( name, DATADIR"/star%d.png", i+1 ); DFBCHECK( dfb->CreateImageProvider( dfb, name, &provider ) ); DFBCHECK( provider->GetSurfaceDescription (provider, &dsc) ); DFBCHECK( dfb->CreateSurface( dfb, &dsc, &stars[i] ) ); DFBCHECK( provider->RenderTo( provider, stars[i], NULL ) ); provider->Release( provider ); stars[i]->SetSrcColorKey( stars[i], 0xFF, 0x00, 0xFF ); } }
static void load_images (void) { DFBSurfaceDescription dsc; IDirectFBImageProvider *provider; int i; for (i = 0; i < N_IMAGES; i++) { DFBCHECK(dfb->CreateImageProvider (dfb, image_names[i], &provider)); DFBCHECK(provider->GetSurfaceDescription (provider, &dsc)); image_widths[i] = dsc.width; image_heights[i] = dsc.height; DFBCHECK(dfb->CreateSurface (dfb, &dsc, &images[i])); provider->RenderTo (provider, images[i], NULL); provider->Release (provider); } }
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; }
int main( int argc, char *argv[] ) { int i; DFBResult ret; DFBSurfaceDescription desc; IDirectFB *dfb; IDirectFBImageProvider *provider = NULL; IDirectFBSurface *source = NULL; IDirectFBSurface *dest = NULL; const char *url = NULL; /* Parse arguments. */ for (i=1; i<argc; i++) { if (!strcmp( argv[i], "-h" )) return show_usage( argv[0] ); else if (!url) url = argv[i]; else return show_usage( argv[0] ); } /* Check if we got an URL. */ if (!url) return show_usage( argv[0] ); /* Initialize DirectFB. */ ret = DirectFBInit( &argc, &argv ); if (ret) { D_DERROR( ret, "DFBTest/Scale: DirectFBInit() failed!\n" ); return ret; } /* Create super interface. */ ret = DirectFBCreate( &dfb ); if (ret) { D_DERROR( ret, "DFBTest/Scale: DirectFBCreate() failed!\n" ); return ret; } /* Create an image provider for the image to be loaded. */ ret = dfb->CreateImageProvider( dfb, url, &provider ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateImageProvider( '%s' ) failed!\n", url ); goto out; } /* Get the surface description. */ ret = provider->GetSurfaceDescription( provider, &desc ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFBImageProvider::GetSurfaceDescription() failed!\n" ); goto out; } desc.pixelformat = DSPF_LUT8; D_INFO( "DFBTest/Scale: Source is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); /* Create a surface for the image. */ ret = dfb->CreateSurface( dfb, &desc, &source ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" ); goto out; } ret = provider->RenderTo( provider, source, NULL ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFBImageProvider::RenderTo() failed!\n" ); goto out; } desc.width = desc.width * 3 / 4; desc.height = desc.height * 3 / 4; if (DFB_PIXELFORMAT_IS_INDEXED( desc.pixelformat )) desc.pixelformat = DSPF_ARGB; D_INFO( "DFBTest/Scale: Destination is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); /* Create a surface for the image. */ ret = dfb->CreateSurface( dfb, &desc, &dest ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" ); goto out; } dest->SetBlittingFlags( dest, DSBLIT_SRC_PREMULTIPLY ); dest->StretchBlit( dest, source, NULL, NULL ); dest->Dump( dest, "dfbtest_scale", NULL ); out: if (dest) dest->Release( dest ); if (source) source->Release( source ); if (provider) provider->Release( provider ); /* Shutdown DirectFB. */ dfb->Release( dfb ); return ret; }
int main (int argc, char **argv) { DFBSurfaceDescription dsc; DFBSurfaceDescription back_dsc; DFBRectangle rect; IDirectFBImageProvider *provider; IDirectFBEventBuffer *keybuffer; DFBInputEvent evt; int width; int height; int quit; unsigned int cycle_len; struct timeval tv; long start_time; long current_time; long frame_delay; long delay; frame_delay = delay = FRAME_DELAY; cycle_len = CYCLE_LEN; quit = FALSE; DFBCHECK (DirectFBInit (&argc, &argv)); if (argc > 1 && argv[1] && strcmp (argv[1], "--on-crack") == 0) on_crack = TRUE; /* create the super interface */ DFBCHECK (DirectFBCreate (&dfb)); dfb->SetCooperativeLevel (dfb, DFSCL_FULLSCREEN); DFBCHECK (dfb->CreateInputEventBuffer (dfb, DICAPS_KEYS, DFB_FALSE, &keybuffer)); /* create the primary surface */ dsc.flags = DSDESC_CAPS; dsc.caps = DSCAPS_PRIMARY; if (!on_crack) { dsc.caps |= DSCAPS_TRIPLE; if (dfb->CreateSurface (dfb, &dsc, &primary) != DFB_OK) { dsc.caps = (dsc.caps & ~DSCAPS_TRIPLE) | DSCAPS_DOUBLE; DFBCHECK (dfb->CreateSurface (dfb, &dsc, &primary)); } } else DFBCHECK (dfb->CreateSurface (dfb, &dsc, &primary)); /* load size of background image */ DFBCHECK (dfb->CreateImageProvider (dfb, BACKGROUND_NAME, &provider)); DFBCHECK (provider->GetSurfaceDescription (provider, &back_dsc)); back_width = back_dsc.width; back_height = back_dsc.height; if (!back_width || !back_height) return -1; /* create the background surface */ DFBCHECK (dfb->CreateSurface (dfb, &back_dsc, &background)); provider->RenderTo (provider, background, NULL); provider->Release (provider); /* create subsurface in the middle of the screen */ primary->GetSize (primary, &width, &height); rect.x = (width - back_width) / 2; rect.y = (height - back_height) / 2; rect.w = back_width; rect.h = back_height; primary->GetSubSurface (primary, &rect, &sub); if (on_crack) { /* clear screen */ primary->Clear (primary, 0, 0, 0, 0xff); } else { /* fill screen and backbuffers with tiled background */ primary->TileBlit (primary, background, NULL, rect.x, rect.y); primary->Flip (primary, NULL, 0) ; primary->TileBlit (primary, background, NULL, rect.x, rect.y); primary->Flip (primary, NULL, 0) ; primary->TileBlit (primary, background, NULL, rect.x, rect.y); primary->SetClip (primary, NULL); } /* load the remaining images */ load_images (); frame_num = 0; while (!quit) { gettimeofday (&tv, NULL); start_time = tv.tv_sec * 1000 + tv.tv_usec / 1000; timeout (cycle_len); while (keybuffer->GetEvent (keybuffer, DFB_EVENT(&evt)) == DFB_OK) { if (evt.type == DIET_KEYPRESS) { switch (evt.key_id) { case DIKI_LEFT: frame_delay = MIN (500, frame_delay + 5); break; case DIKI_RIGHT: frame_delay = MAX (0, frame_delay - 5); break; case DIKI_UP: cycle_len = MIN (600, cycle_len + 6); break; case DIKI_DOWN: cycle_len = cycle_len > 6 ? cycle_len - 6 : 6; break; case DIKI_SPACE: case DIKI_ENTER: colorize = !colorize; break; case DIKI_A: alpha = !alpha; break; case DIKI_HOME: cycle_len = CYCLE_LEN; frame_delay = FRAME_DELAY; colorize = TRUE; alpha = TRUE; break; case DIKI_ESCAPE: case DIKI_Q: quit = TRUE; break; default: break; } switch (evt.key_symbol) { case DIKS_OK: colorize = !colorize; break; case DIKS_BACK: case DIKS_STOP: quit = TRUE; break; default: break; } } } if (frame_delay) { gettimeofday (&tv, NULL); current_time = tv.tv_sec * 1000 + tv.tv_usec / 1000; delay = frame_delay - (current_time - start_time); if (delay > 0) usleep (1000 * delay); } } keybuffer->Release (keybuffer); release_images (); background->Release (background); sub->Release (sub); primary->Release (primary); dfb->Release (dfb); return 0; }
void DFBDeviceScreen::setBackgroundImage(string uri) { DFBResult ret; DFBSurfaceDescription desc; IDirectFBSurface *surface; IDirectFBImageProvider *provider; ret = dfb->CreateImageProvider(dfb, uri.c_str(), &provider); if (ret) { DirectFBError("IDirectFB::CreateImageProvider() failed", ret); return; } ret = provider->GetSurfaceDescription(provider, &desc); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage surdsc failed", ret); provider->Release(provider); return; } desc.width = this->wRes; desc.height = this->hRes; ret = dfb->CreateSurface(dfb, &desc, &surface); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage sur failed", ret); provider->Release(provider); return; } ret = provider->RenderTo(provider, surface, NULL); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage renderto failed", ret); surface->Release(surface); provider->Release(provider); return; } ret = gfxLayer->SetBackgroundImage(gfxLayer, surface); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage bg failed", ret); surface->Release(surface); provider->Release(provider); return; } ret = gfxLayer->SetBackgroundMode(gfxLayer, DLBM_IMAGE); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage bgm failed", ret); } surface->Release(surface); provider->Release(provider); cout << endl << endl; cout << "DFBScreen::setBackgroundImage '" << uri << "'" << endl; cout << endl << endl; }
ISurface* DFBImageProvider::prepare(bool isGif) { ISurface* renderedSurface = NULL; IDirectFBImageProvider* ip; ip = (IDirectFBImageProvider*)decoder; DFBImageDescription imgDsc; IDirectFBSurface* destination = NULL; DFBSurfaceDescription surDsc; IColor* chromaKey = NULL; //IDirectFBSurface* source; if ((ip->GetImageDescription(ip, &imgDsc) == DFB_OK) && (ip->GetSurfaceDescription(ip, &surDsc) == DFB_OK)) { destination = (IDirectFBSurface*)( LocalDeviceManager::getInstance()->createSurface(&surDsc)); renderedSurface = new DFBSurface(destination); if (imgDsc.caps & DICAPS_ALPHACHANNEL) { /*cout << "ImagePlayer::ImagePlayer(" << mrl << ")"; cout << " setted alphachannel: ";*/ //alpha channel of gif does not exists anymore, it turn into //black src color key (marcio 20/04/2007) if (isGif) { chromaKey = new Color(0, 0, 0); renderedSurface->setChromaColor(chromaKey); //outputDisplay->setColorKey(0, 0, 0); //cout << "black color cause it is a gif image" << endl; } else { renderedSurface->setCaps(DWCAPS_ALPHACHANNEL); } //cout << " trying to blit image alpha channel" << endl; DFBCHECK(destination->SetBlittingFlags(destination, (DFBSurfaceBlittingFlags)(DSBLIT_BLEND_ALPHACHANNEL))); /*cout << "ImagePlayer::ImagePlayer(" << mrl << ")"; cout << " setted alpha: '"; cout << (((int)(imgDsc.colorkey_r & 0xFF)) & 0xFF); cout << ", " << (((int)(imgDsc.colorkey_g)) & 0xFF); cout << ", " << (((int)(imgDsc.colorkey_b)) & 0xFF); cout << "'" << endl;*/ } if (imgDsc.caps & DICAPS_COLORKEY) { chromaKey = new Color( imgDsc.colorkey_r, imgDsc.colorkey_g, imgDsc.colorkey_b); DFBCHECK(destination->SetBlittingFlags(destination, (DFBSurfaceBlittingFlags)( DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_SRC_COLORKEY))); renderedSurface->setChromaColor(chromaKey); /*cout << "ImagePlayer::ImagePlayer(" << mrl << ")"; cout << " setted colorkey: '"; cout << (((int)(imgDsc.colorkey_r & 0xFF)) & 0xFF); cout << ", " << (((int)(imgDsc.colorkey_g)) & 0xFF); cout << ", " << (((int)(imgDsc.colorkey_b)) & 0xFF); cout << "'" << endl;*/ } if (imgDsc.caps & DICAPS_NONE) { DFBCHECK(destination->SetBlittingFlags(destination, (DFBSurfaceBlittingFlags)DSBLIT_NOFX)); renderedSurface->setCaps(DWCAPS_NONE); /*cout << "ImagePlayer::ImagePlayer(" << mrl << ")"; cout << " NOFX" << endl;*/ } } if (destination != NULL && renderedSurface != NULL) { DFBCHECK(ip->RenderTo( ip, (IDirectFBSurface*)(renderedSurface->getContent()), NULL)); } return renderedSurface; }
void render() { IDirectFBImageProvider *provider; IDirectFBSurface *logoSurface; IDirectFBFont *fontInterface; DFBFontDescription fontDesc; char imageName[15]; int32_t logoHeight; int32_t logoWidth; char prog[32]; char date[32]; char telxt[32]; char audio[32]; char video[32]; // Fetch the screen size and clear screen. DFBCHECK(primary->SetColor(primary, 0x00, 0x00, 0x00, 0x00)); DFBCHECK(primary->FillRectangle(primary, 0, 0, screenWidth, screenHeight)); if (volumeBar.visible) { // Make a new name. sprintf(imageName, "volume_%hu.png", volumeBar.volume); // Read image, prepare surface descriptor and render image to given surface. DFBCHECK(dfbInterface->CreateImageProvider(dfbInterface, imageName, &provider)); DFBCHECK(provider->GetSurfaceDescription(provider, &surfaceDesc)); DFBCHECK(dfbInterface->CreateSurface(dfbInterface, &surfaceDesc, &logoSurface)); DFBCHECK(provider->RenderTo(provider, logoSurface, NULL)); provider->Release(provider); // Fetch the logo size and add it to the screen buffer. DFBCHECK(logoSurface->GetSize(logoSurface, &logoWidth, &logoHeight)); DFBCHECK(primary->Blit(primary, logoSurface, NULL, VOLUME_X_COOR, VOLUME_Y_COOR)); } if (infoBar.visible) { // Prepare strings for info bar. sprintf(prog, "Program %hu", infoBar.channelNumber); sprintf(date, "Naziv dana u nedelji %s", infoBar.date); sprintf(audio, "Audio PID %hu", infoBar.audioPID); sprintf(video, "Video PID %hu", infoBar.videoPID); if (infoBar.teletextExist) { sprintf(telxt, "Teletekst postoji"); } else { sprintf(telxt, "Teletekst ne postoji"); } // Prepare text font, color and size. Then create font and draw it. fontDesc.flags = DFDESC_HEIGHT; fontDesc.height = 40; DFBCHECK(dfbInterface->CreateFont(dfbInterface, "/home/galois/fonts/DejaVuSans.ttf", &fontDesc, &fontInterface)); DFBCHECK(primary->SetFont(primary, fontInterface)); // Draw a rectangle representing info bar. DFBCHECK(primary->SetColor(primary, INFO_BAR_RED, INFO_BAR_GREEN, INFO_BAR_BLUE, 0xff)); DFBCHECK(primary->FillRectangle(primary, screenWidth/6, 4*screenHeight/5, 4*screenWidth/6, screenHeight/6)); // Write program number, date and teletext to info bar. DFBCHECK(primary->SetColor(primary, TEXT_RED, TEXT_GREEN, TEXT_BLUE, 0xff)); DFBCHECK(primary->DrawString(primary, prog, -1, screenWidth/5, 17*screenHeight/20, DSTF_LEFT)); DFBCHECK(primary->DrawString(primary, audio, -1, screenWidth/5, 18*screenHeight/20, DSTF_LEFT)); DFBCHECK(primary->DrawString(primary, video, -1, screenWidth/5, 19*screenHeight/20, DSTF_LEFT)); DFBCHECK(primary->DrawString(primary, date, -1, 4*screenWidth/9, 19*screenHeight/20, DSTF_LEFT)); DFBCHECK(primary->DrawString(primary, telxt, -1, 4*screenWidth/9, 17*screenHeight/20, DSTF_LEFT)); } // Switch buffers. DFBCHECK(primary->Flip(primary, NULL, 0)); }
//------------------------------------------------------------------------------ // Unit Test main //------------------------------------------------------------------------------ int main (int argc, char **argv) { int i, j; DFBResult rle_build_databuffer_err; // File name to load logo image from char *filename = NULL; // Basic directfb elements IDirectFB *dfb = NULL; IDirectFBSurface *primary = NULL; int screen_width = 0; int screen_height = 0; // The image is to be loaded into a surface that we can blit from. IDirectFBSurface *logo = NULL; // Loading an image is done with an Image Provider. IDirectFBImageProvider *provider = NULL; // An Image provider instance can also be created from a directfb buffer IDirectFBDataBuffer *databuffer = NULL; // Surface description DFBSurfaceDescription surface_dsc; // Initialize directfb first DFBCHECK (DirectFBInit (&argc, &argv)); DFBCHECK (DirectFBCreate (&dfb)); DFBCHECK (dfb->SetCooperativeLevel (dfb, DFSCL_FULLSCREEN)); // Create primary surface surface_dsc.flags = DSDESC_CAPS; surface_dsc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING; DFBCHECK (dfb->CreateSurface( dfb, &surface_dsc, &primary )); DFBCHECK (primary->GetSize (primary, &screen_width, &screen_height)); if (argc==1) { argv[1] = "./data/directfb.rle"; argc++; } DISPLAY_INFO ("Rendering %d files\n",argc-1); for (j=1; j<argc; j++) { // // --- WE CREATE OUR IMAGE PROVIDER INSTANCE HERE // filename = argv[j]; DISPLAY_INFO ("Rendering : %s\n",filename); // We create a directfb data buffer holding RLE image contents that we // pick up from a file (could get the RLE contents from memory as well). // "rle_build_databuffer" details the process of dealing with a memory // RLE packet as a matter of fact. rle_build_databuffer_err = rle_build_databuffer (dfb, filename, &databuffer); if (rle_build_databuffer_err == DFB_OK) { // We want to create an Image Provider tied to a directfb data buffer. // DirectFB will find (or not) an Image Provider for the data type // depending on Image Providers probe method (sniffing data headers) DFBCHECK (databuffer->CreateImageProvider (databuffer, &provider)); } else { # ifdef USE_PACKET_BUILDER_ONLY DFBFAIL(rle_build_databuffer_err); # else // We could also create an Image Provider by passing a filename. // DirectFB will find (or not) an Image Provider matching the file type. DFBCHECK (dfb->CreateImageProvider (dfb, filename, &provider)); # endif } // Get a surface description from the provider. It will contain the width, // height, bits per pixel and the flag for an alphachannel if the image // has one. If the image has no alphachannel the bits per pixel is set to // the bits per pixel of the primary layer to use simple blitting without // pixel format conversion. DFBCHECK (provider->GetSurfaceDescription (provider, &surface_dsc)); // Create a surface based on the description of the provider. DFBCHECK (dfb->CreateSurface( dfb, &surface_dsc, &logo )); // Let the provider render to our surface. Image providers are supposed // to support every destination pixel format and size. If the size // differs the image will be scaled (bilinear). The last parameter allows // to specify an optional destination rectangle. We use NULL here so that // our image covers the whole logo surface. DFBCHECK (provider->RenderTo (provider, logo, NULL)); // Note: RLE Image Provider allows for direct non-scaled LUT-8 surface // rendering without any attached colormap. #ifdef CLEVER_APPROACH // Let's setup our logo surface palette outside of the RLE Image // Provider if we got a colormap from rle_build_databuffer ... if (color_palette) { IDirectFBPalette *palette; DFBCHECK (logo->GetPalette (logo, &palette)); palette->SetEntries (palette, color_palette, number_of_colors, 0); palette->Release (palette); } #endif // // --- WE GET RID OF OUR IMAGE PROVIDER INSTANCE HERE // // Release the provider, we don't need it anymore. provider->Release (provider); provider = NULL; // Destroy the databuffer as well, we don't need it anymore. rle_destroy_databuffer (databuffer); databuffer = NULL; # ifndef SUBTITLES_MODE // We want to let the logo slide in on the left and slide out on the // right. for (i = -surface_dsc.width; i < screen_width; i++) # else // We want to let the logo slide in on the right and slide out on the // left. for (i = screen_width-1; i >= -surface_dsc.width; i--) # endif { // Clear the screen. DFBCHECK (primary->FillRectangle (primary, 0, 0, screen_width, screen_height)); // Blit the logo vertically centered with "i" as the X coordinate. // NULL means that we want to blit the whole surface. DFBCHECK (primary->Blit (primary, logo, NULL, i, (screen_height - surface_dsc.height) / 2)); // Flip the front and back buffer, but wait for the vertical // retrace to avoid tearing. DFBCHECK (primary->Flip (primary, NULL, DSFLIP_WAITFORSYNC)); if (argc < 3) { usleep(1000*5); } } // Release the image. if (logo) { logo->Release (logo); } } // Release everything else primary->Release (primary); dfb->Release (dfb); return 0; }
int main( int argc, char *argv[] ) { int i; DFBResult ret; DFBSurfaceDescription desc; IDirectFB *dfb; IDirectFBImageProvider *provider = NULL; IDirectFBSurface *source = NULL; IDirectFBSurface *dest = NULL; const char *url = NULL; DFBSurfacePixelFormat source_format = DSPF_UNKNOWN; DFBSurfacePixelFormat dest_format = DSPF_UNKNOWN; bool dest_resize = false; /* 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 if (strcmp (arg, "-s") == 0 || strcmp (arg, "--source") == 0) { if (++i == argc) { print_usage (argv[0]); return false; } if (!parse_format( argv[i], &source_format )) return false; } else if (strcmp (arg, "-d") == 0 || strcmp (arg, "--dest") == 0) { if (++i == argc) { print_usage (argv[0]); return false; } if (!parse_format( argv[i], &dest_format )) return false; } else if (strcmp (arg, "-r") == 0 || strcmp (arg, "--resize") == 0) dest_resize = true; else if (!url) url = arg; else return print_usage( argv[0] ); } /* Check if we got an URL. */ if (!url) return print_usage( argv[0] ); /* Create super interface. */ ret = DirectFBCreate( &dfb ); if (ret) { D_DERROR( ret, "DFBTest/Blit: DirectFBCreate() failed!\n" ); return ret; } /* Create an image provider for the image to be loaded. */ ret = dfb->CreateImageProvider( dfb, url, &provider ); if (ret) { D_DERROR( ret, "DFBTest/Blit: IDirectFB::CreateImageProvider( '%s' ) failed!\n", url ); goto out; } /* Get the surface description. */ ret = provider->GetSurfaceDescription( provider, &desc ); if (ret) { D_DERROR( ret, "DFBTest/Blit: IDirectFBImageProvider::GetSurfaceDescription() failed!\n" ); goto out; } if (source_format != DSPF_UNKNOWN) desc.pixelformat = source_format; D_INFO( "DFBTest/Blit: Source is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); /* Create a surface for the image. */ ret = dfb->CreateSurface( dfb, &desc, &source ); if (ret) { D_DERROR( ret, "DFBTest/Blit: IDirectFB::CreateSurface() failed!\n" ); goto out; } ret = provider->RenderTo( provider, source, NULL ); if (ret) { D_DERROR( ret, "DFBTest/Blit: IDirectFBImageProvider::RenderTo() failed!\n" ); goto out; } /* Fill description for a primary surface. */ desc.flags = DSDESC_CAPS; desc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING; if (dest_format != DSPF_UNKNOWN) { desc.flags |= DSDESC_PIXELFORMAT; desc.pixelformat = dest_format; } if (dest_resize) desc.flags |= DSDESC_WIDTH | DSDESC_HEIGHT; dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN ); /* Create a primary surface. */ ret = dfb->CreateSurface( dfb, &desc, &dest ); if (ret) { D_DERROR( ret, "DFBTest/Blit: IDirectFB::CreateSurface() failed!\n" ); goto out; } dest->GetSize( dest, &desc.width, &desc.height ); dest->GetPixelFormat( dest, &desc.pixelformat ); D_INFO( "DFBTest/Blit: Destination is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); for (i=0; i<100000; i++) { int j,n = rand()%100; for (j=0; j<n; j++) { switch (rand()%3) { case 0: dest->SetDrawingFlags( dest, rand() & (DSDRAW_BLEND) ); dest->FillRectangle( dest, rand()%100, rand()%100, rand()%100, rand()%100 ); break; case 1: dest->SetBlittingFlags( dest, rand() & (DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA | DSBLIT_COLORIZE | DSBLIT_ROTATE90) ); dest->Blit( dest, source, NULL, rand()%100, rand()%100 ); break; case 2: dest->SetBlittingFlags( dest, rand() & (DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA | DSBLIT_COLORIZE | DSBLIT_ROTATE90) ); dest->StretchBlit( dest, source, NULL, NULL ); break; } } dfb->WaitIdle( dfb ); dest->Flip( dest, NULL, DSFLIP_NONE ); } out: if (dest) dest->Release( dest ); if (source) source->Release( source ); if (provider) provider->Release( provider ); /* Shutdown DirectFB. */ dfb->Release( dfb ); return ret; }
int main( int argc, char *argv[] ) { IDirectFB *dfb; IDirectFBDisplayLayer *layer; IDirectFBSurface *bgsurface; IDirectFBImageProvider *provider; IDirectFBWindow *window1; IDirectFBWindow *window2; IDirectFBSurface *window_surface1; IDirectFBSurface *window_surface2; IDirectFBEventBuffer *buffer; DFBDisplayLayerConfig layer_config; #if ((DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23)) DFBCardCapabilities caps; #else DFBGraphicsDeviceDescription caps; #endif IDirectFBWindow* upper; DFBWindowID id1; IDirectFBFont *font; int fontheight; int err; int quit = 0; DFBCHECK(DirectFBInit( &argc, &argv )); DFBCHECK(DirectFBCreate( &dfb )); #if ((DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23)) dfb->GetCardCapabilities( dfb, &caps ); #else dfb->GetDeviceDescription( dfb, &caps ); #endif dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer ); if (!((caps.blitting_flags & DSBLIT_BLEND_ALPHACHANNEL) && (caps.blitting_flags & DSBLIT_BLEND_COLORALPHA ))) { layer_config.flags = DLCONF_BUFFERMODE; layer_config.buffermode = DLBM_BACKSYSTEM; layer->SetConfiguration( layer, &layer_config ); } layer->GetConfiguration( layer, &layer_config ); layer->EnableCursor ( layer, 1 ); { DFBFontDescription desc; desc.flags = DFDESC_HEIGHT; desc.height = layer_config.width/50; DFBCHECK(dfb->CreateFont( dfb, PACKAGE_DATA_DIR"/grunge.ttf", &desc, &font )); font->GetHeight( font, &fontheight ); } { DFBSurfaceDescription desc; DFBCHECK(dfb->CreateImageProvider( dfb, PACKAGE_DATA_DIR"/bg.png", &provider )); desc.flags = DSDESC_WIDTH | DSDESC_HEIGHT; desc.width = layer_config.width; desc.height = layer_config.height; DFBCHECK(dfb->CreateSurface( dfb, &desc, &bgsurface ) ); provider->RenderTo( provider, bgsurface, NULL ); provider->Release( provider ); DFBCHECK(bgsurface->SetFont( bgsurface, font )); bgsurface->SetColor( bgsurface, 0xCF, 0xCF, 0xFF, 0xFF ); bgsurface->DrawString( bgsurface, "Move the mouse over a window to activate it.", -1, 10, 0, DSTF_LEFT | DSTF_TOP ); bgsurface->SetColor( bgsurface, 0xFF, 0xCF, 0xFF, 0xFF ); bgsurface->DrawString( bgsurface, "You can drag them around, too, if you want.", -1, 10 , 40, DSTF_LEFT | DSTF_TOP ); bgsurface->SetColor( bgsurface, 0xCF, 0xCF, 0xFF, 0xFF ); bgsurface->DrawString( bgsurface, "The one with funky stuff happening and things flying around is an evas.", -1, 10, 80, DSTF_LEFT | DSTF_TOP ); layer->SetBackgroundImage( layer, bgsurface ); layer->SetBackgroundMode( layer, DLBM_IMAGE ); } { DFBWindowDescription desc; desc.flags = ( DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_CAPS ); desc.posx = 20; desc.posy = 120; desc.width = 200; desc.height = 200; desc.caps = DWCAPS_ALPHACHANNEL; DFBCHECK( layer->CreateWindow( layer, &desc, &window2 ) ); window2->GetSurface( window2, &window_surface2 ); window2->SetOpacity( window2, 0xFF ); window2->CreateEventBuffer( window2, &buffer ); { window_surface2->SetColor( window_surface2, 0x00, 0x30, 0x10, 0xc0 ); window_surface2->DrawRectangle( window_surface2, 0, 0, desc.width, desc.height ); window_surface2->SetColor( window_surface2, 0x80, 0xa0, 0x00, 0x90 ); window_surface2->FillRectangle( window_surface2, 1, 1, desc.width-2, desc.height-2 ); DFBCHECK(window_surface2->SetFont(window_surface2, font )); window_surface2->SetColor( window_surface2, 0xCF, 0xFF, 0xCF, 0xFF ); window_surface2->DrawString( window_surface2, "Pants!", -1,10, fontheight + 5, DSTF_LEFT | DSTF_TOP ); } window_surface2->Flip( window_surface2, NULL, 0 ); } { DFBWindowDescription desc; desc.flags = ( DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_CAPS ); desc.posx = 200; desc.posy = 200; desc.width = 240; desc.height = 320; desc.caps = DWCAPS_ALPHACHANNEL; DFBCHECK(layer->CreateWindow( layer, &desc, &window1 ) ); window1->GetSurface( window1, &window_surface1 ); window_surface1->SetColor( window_surface1, 0xFF, 0x20, 0x20, 0x90 ); window_surface1->DrawRectangle( window_surface1, 0, 0, desc.width, desc.height ); window_surface1->Flip( window_surface1, NULL, 0 ); window1->SetOpacity( window1, 0xFF ); window1->GetID( window1, &id1 ); window1->AttachEventBuffer( window1, buffer ); } window1->RequestFocus( window1 ); window1->RaiseToTop( window1 ); upper = window1; { evas_init(); evas = evas_new(); evas_output_method_set(evas, evas_render_method_lookup("directfb")); evas_output_size_set(evas, 240, 320); evas_output_viewport_set(evas, 0, 0, 240, 320); { Evas_Engine_Info_DirectFB *einfo; einfo = (Evas_Engine_Info_DirectFB *) evas_engine_info_get(evas); einfo->info.dfb = dfb; einfo->info.surface = window_surface1; einfo->info.flags = DSDRAW_BLEND; evas_engine_info_set(evas, (Evas_Engine_Info *) einfo); } setup(); evas_render(evas); start_time = get_time(); } while (!quit) { static IDirectFBWindow* active = NULL; static int grabbed = 0; static int startx = 0; static int starty = 0; static int endx = 0; static int endy = 0; DFBWindowEvent evt; buffer->WaitForEventWithTimeout( buffer, 0, 10 ); while (buffer->GetEvent( buffer, DFB_EVENT(&evt) ) == DFB_OK) { IDirectFBWindow* window; if (evt.window_id == id1) window = window1; else window = window2; if (active) { switch (evt.type) { case DWET_BUTTONDOWN: if (!grabbed && evt.button == DIBI_LEFT) { grabbed = 1; layer->GetCursorPosition( layer, &startx, &starty ); window->GrabPointer( window ); } break; case DWET_BUTTONUP: switch (evt.button) { case DIBI_LEFT: if (grabbed) { window->UngrabPointer( window ); grabbed = 0; } break; case DIBI_MIDDLE: upper->LowerToBottom( upper ); upper = (upper == window1) ? window2 : window1; break; case DIBI_RIGHT: quit = DIKS_DOWN; break; default: break; } break; case DWET_KEYDOWN: if (grabbed) break; switch (evt.key_id) { case DIKI_RIGHT: active->Move (active, 1, 0); break; case DIKI_LEFT: active->Move (active, -1, 0); break; case DIKI_UP: active->Move (active, 0, -1); break; case DIKI_DOWN: active->Move (active, 0, 1); break; default: break; } break; case DWET_LOSTFOCUS: if (!grabbed) active = NULL; break; default: break; } } else if (evt.type == DWET_GOTFOCUS) active = window; switch (evt.type) { case DWET_MOTION: endx = evt.cx; endy = evt.cy; break; case DWET_KEYDOWN: switch (evt.key_symbol) { case DIKS_ESCAPE: case DIKS_SMALL_Q: case DIKS_CAPITAL_Q: case DIKS_BACK: case DIKS_STOP: quit = 1; break; default: break; } break; default: break; } } if (active) { if (grabbed) { active->Move( active, endx - startx, endy - starty); startx = endx; starty = endy; } active->SetOpacity( active, (sin( myclock()/300.0 ) * 85) + 170 ); } loop(); { Eina_List *updates; updates = evas_render_updates(evas); /* efficient update.. only flip the rectangle regions that changed! */ if (updates) { DFBRegion region; Eina_List *l; for (l = updates; l; l = l->next) { Evas_Rectangle *rect; rect = l->data; region.x1 = rect->x; region.y1 = rect->y; region.x2 = rect->x + rect->w - 1; region.y2 = rect->y + rect->h - 1; window_surface1->Flip(window_surface1, ®ion, DSFLIP_BLIT); } evas_render_updates_free(updates); } } } buffer->Release( buffer ); window_surface2->Release( window_surface2 ); window_surface1->Release( window_surface1 ); window2->Release( window2 ); window1->Release( window1 ); layer->Release( layer ); bgsurface->Release( bgsurface ); dfb->Release( dfb ); evas_shutdown(); return 0; }
int main( int argc, char *argv[] ) { int i; int step; DFBResult err; DFBSurfaceDescription sdsc; DFBFontDescription fdsc; IDirectFBImageProvider *provider; DFBCHECK(DirectFBInit( &argc, &argv )); /* create the super interface */ DFBCHECK(DirectFBCreate( &dfb )); /* create an event buffer with all devices attached that have keys */ DFBCHECK(dfb->CreateInputEventBuffer( dfb, DIDCAPS_KEYS, DFB_FALSE, &events )); /* set our cooperative level to DFSCL_FULLSCREEN for exclusive access to the primary layer */ dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN ); /* get the primary surface, i.e. the surface of the primary layer we have exclusive access to */ sdsc.flags = DSDESC_CAPS; sdsc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING | DSCAPS_PREMULTIPLIED; DFBCHECK(dfb->CreateSurface( dfb, &sdsc, &primary )); primary->Clear( primary, 0, 0, 0, 0 ); primary->Flip( primary, NULL, DSFLIP_NONE ); primary->GetSize( primary, &screen_width, &screen_height ); step = screen_width / 5; /* create the temporary surface */ sdsc.flags = DSDESC_CAPS | DSDESC_PIXELFORMAT | DSDESC_WIDTH | DSDESC_HEIGHT; sdsc.caps = DSCAPS_PREMULTIPLIED; sdsc.pixelformat = DSPF_ARGB; sdsc.width = screen_width; sdsc.height = screen_height; DFBCHECK(dfb->CreateSurface( dfb, &sdsc, &tempsurf )); /* Load background image. */ DFBCHECK(dfb->CreateImageProvider( dfb, DATADIR"/wood_andi.jpg", &provider )); /* Render to temporary surface. */ provider->RenderTo( provider, tempsurf, NULL ); provider->Release( provider ); /* Blit background onto primary surface (dimmed). */ primary->SetBlittingFlags( primary, DSBLIT_COLORIZE ); primary->SetColor( primary, 190, 200, 180, 0 ); primary->Blit( primary, tempsurf, NULL, 0, 0 ); tempsurf->Clear( tempsurf, 0, 0, 0, 0 ); tempsurf->SetDrawingFlags( tempsurf, DSDRAW_SRC_PREMULTIPLY | DSDRAW_BLEND ); tempsurf->SetPorterDuff( tempsurf, DSPD_SRC ); fdsc.flags = DFDESC_HEIGHT; fdsc.height = screen_width/24; DFBCHECK(dfb->CreateFont( dfb, FONT, &fdsc, &font )); DFBCHECK(tempsurf->SetFont( tempsurf, font )); tempsurf->SetColor( tempsurf, 0xFF, 0xFF, 0xFF, 0xFF ); tempsurf->DrawString( tempsurf, "Porter/Duff Demo", -1, screen_width/2, 20, DSTF_TOPCENTER ); font->Release( font ); fdsc.height = screen_width/32; DFBCHECK(dfb->CreateFont( dfb, FONT, &fdsc, &font )); DFBCHECK(tempsurf->SetFont( tempsurf, font )); for (i=0; i<num_rules; i++) { int x = (1 + i % 4) * step; int y = (0 + i / 4) * 180; DFBAccelerationMask mask; char *str; str = strdup( rules[i] ); tempsurf->SetPorterDuff( tempsurf, DSPD_SRC ); tempsurf->SetColor( tempsurf, 255, 0, 0, 140 ); tempsurf->FillRectangle( tempsurf, x - 50, y + 100, 80, 70 ); tempsurf->SetPorterDuff( tempsurf, i+1 ); tempsurf->SetColor( tempsurf, 0, 0, 255, 200 ); tempsurf->FillRectangle( tempsurf, x - 30, y + 130, 80, 70 ); tempsurf->GetAccelerationMask( tempsurf, NULL, &mask ); if (mask & DFXL_FILLRECTANGLE) str[0] = '*'; tempsurf->SetPorterDuff( tempsurf, DSPD_SRC_OVER ); tempsurf->SetColor( tempsurf, 6*0x1F, 6*0x10+0x7f, 0xFF, 0xFF ); tempsurf->DrawString( tempsurf, str, -1, x, y + 210, DSTF_CENTER | DSTF_TOP ); free( str ); } font->Release( font ); primary->SetBlittingFlags( primary, DSBLIT_BLEND_ALPHACHANNEL ); primary->SetPorterDuff( primary, DSPD_SRC_OVER ); primary->Blit( primary, tempsurf, NULL, 0, 0 ); primary->Flip( primary, NULL, DSFLIP_NONE ); while (1) { DFBInputEvent ev; events->WaitForEvent( events ); events->GetEvent( events, DFB_EVENT(&ev) ); if (ev.type == DIET_KEYRELEASE && ev.key_symbol == DIKS_ESCAPE) break; } /* release our interfaces to shutdown DirectFB */ tempsurf->Release( tempsurf ); primary->Release( primary ); events->Release( events ); dfb->Release( dfb ); return 0; }
void cVideo::ShowPicture(const char * fname) { lt_debug("%s(%s)\n", __FUNCTION__, fname); char destname[512]; char cmd[512]; char *p; void *data; int mfd; struct stat st; strcpy(destname, "/var/cache"); mkdir(destname, 0755); /* the cache filename is (example for /share/tuxbox/neutrino/icons/radiomode.jpg): /var/cache/share.tuxbox.neutrino.icons.radiomode.jpg.m2v build that filename first... TODO: this could cause name clashes, use a hashing function instead... */ strcat(destname, fname); p = &destname[strlen("/var/cache/")]; while ((p = strchr(p, '/')) != NULL) *p = '.'; strcat(destname, ".m2v"); /* ...then check if it exists already... TODO: check if the cache file is older than the jpeg file... */ if (access(destname, R_OK)) { /* it does not exist, so call ffmpeg to create it... */ sprintf(cmd, "ffmpeg -y -f mjpeg -i '%s' -s 704x576 '%s' </dev/null", fname, destname); system(cmd); /* TODO: use libavcodec to directly convert it */ } /* the mutex is a workaround: setBlank is apparently called from a differnt thread and takes slightly longer, so that the decoder was blanked immediately after displaying the image, which is not what we want. the mutex ensures proper ordering. */ pthread_mutex_lock(&stillp_mutex); mfd = open(destname, O_RDONLY); if (mfd < 0) { lt_info("%s cannot open %s: %m", __FUNCTION__, destname); goto out; } if (fstat(mfd, &st) != -1 && st.st_size > 0) { data = malloc(st.st_size); if (! data) lt_info("%s malloc failed (%m)\n", __FUNCTION__); else if (read(mfd, data, st.st_size) != st.st_size) lt_info("%s short read (%m)\n", __FUNCTION__); else { BUFINFO buf; buf.ulLen = st.st_size; buf.ulStartAdrOff = (int)data; Stop(false); fop(ioctl, MPEG_VID_STILLP_WRITE, &buf); } free(data); } close(mfd); out: pthread_mutex_unlock(&stillp_mutex); return; #if 0 /* DirectFB based picviewer: works, but is slow and the infobar draws in the same plane */ int width; int height; if (!fname) return; IDirectFBImageProvider *provider; DFBResult err = dfb->CreateImageProvider(dfb, fname, &provider); if (err) { fprintf(stderr, "cVideo::ShowPicture: CreateImageProvider error!\n"); return; } DFBSurfaceDescription desc; provider->GetSurfaceDescription (provider, &desc); width = desc.width; height = desc.height; provider->RenderTo(provider, dfbdest, NULL); provider->Release(provider); #endif }
int main( int argc, char *argv[] ) { int i; DFBResult ret; DFBSurfaceDescription desc; IDirectFB *dfb; IDirectFBImageProvider *provider = NULL; IDirectFBSurface *source = NULL; IDirectFBSurface *dest = NULL; IDirectFBSurface *dest2 = NULL; const char *url = NULL; /* Initialize DirectFB. */ ret = DirectFBInit( &argc, &argv ); if (ret) { D_DERROR( ret, "DFBTest/Scale: DirectFBInit() failed!\n" ); return ret; } /* Parse arguments. */ for (i=1; i<argc; i++) { if (!strcmp( argv[i], "-h" )) return show_usage( argv[0] ); else if (!url) url = argv[i]; else return show_usage( argv[0] ); } /* Check if we got an URL. */ if (!url) return show_usage( argv[0] ); /* Create super interface. */ ret = DirectFBCreate( &dfb ); if (ret) { D_DERROR( ret, "DFBTest/Scale: DirectFBCreate() failed!\n" ); return ret; } /* Create an image provider for the image to be loaded. */ ret = dfb->CreateImageProvider( dfb, url, &provider ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateImageProvider( '%s' ) failed!\n", url ); goto out; } /* Get the surface description. */ ret = provider->GetSurfaceDescription( provider, &desc ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFBImageProvider::GetSurfaceDescription() failed!\n" ); goto out; } desc.pixelformat = DSPF_NV21; D_INFO( "DFBTest/Scale: Source is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); /* Create a surface for the image. */ ret = dfb->CreateSurface( dfb, &desc, &source ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" ); goto out; } ret = provider->RenderTo( provider, source, NULL ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFBImageProvider::RenderTo() failed!\n" ); goto out; } desc.width = desc.width * 3 / 4; desc.height = desc.height * 3 / 4; D_INFO( "DFBTest/Scale: Destination is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); /* Create a surface for the image. */ ret = dfb->CreateSurface( dfb, &desc, &dest ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" ); goto out; } DFBRectangle srect = { 10, 10, 200, 200 }; DFBRectangle drect = { 10, 10, 300, 300 }; DFBRegion clip = { 40, 40, 199, 199 }; dest->Clear( dest, 0xff, 0xff, 0xff, 0xff ); dest->SetClip( dest, &clip ); dest->StretchBlit( dest, source, &srect, &drect ); desc.pixelformat = DSPF_ARGB; D_INFO( "DFBTest/Scale: Destination2 is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); /* Create a surface for the image. */ ret = dfb->CreateSurface( dfb, &desc, &dest2 ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" ); goto out; } dest2->Blit( dest2, dest, NULL, 0, 0 ); dest2->Dump( dest2, "dfbtest_scale_nv21", NULL ); out: if (dest2) dest2->Release( dest2 ); if (dest) dest->Release( dest ); if (source) source->Release( source ); if (provider) provider->Release( provider ); /* Shutdown DirectFB. */ dfb->Release( dfb ); return ret; }