void mach64_set_destination( Mach64DriverData *mdrv, Mach64DeviceData *mdev, CardState *state ) { volatile u8 *mmio = mdrv->mmio_base; CoreSurface *destination = state->destination; unsigned int pitch = state->dst.pitch / DFB_BYTES_PER_PIXEL( destination->config.format ); mdev->pix_width &= ~DST_PIX_WIDTH; switch (destination->config.format) { case DSPF_RGB332: mdev->pix_width |= DST_PIX_WIDTH_8BPP; break; case DSPF_RGB555: case DSPF_ARGB1555: mdev->pix_width |= DST_PIX_WIDTH_15BPP; break; case DSPF_RGB16: mdev->pix_width |= DST_PIX_WIDTH_16BPP; break; case DSPF_RGB32: case DSPF_ARGB: mdev->pix_width |= DST_PIX_WIDTH_32BPP; break; default: D_BUG( "unexpected pixelformat!" ); return; } mach64_waitfifo( mdrv, mdev, 1 ); mach64_out32( mmio, DST_OFF_PITCH, (state->dst.offset/8) | ((pitch/8) << 22) ); }
static inline void savage4_validate_pbd( Savage4DriverData *sdrv, Savage4DeviceData *sdev, CardState *state ) { u32 BitmapDescriptor; CoreSurface *source; int bpp; if (sdev->v_pbd) return; source = state->source; bpp = DFB_BYTES_PER_PIXEL(source->config.format); BitmapDescriptor = BCI_BD_BW_DISABLE; BCI_BD_SET_BPP( BitmapDescriptor, bpp * 8 ); BCI_BD_SET_STRIDE( BitmapDescriptor, state->src.pitch / bpp ); savage4_waitidle( sdrv, sdev ); BCI_SEND( BCI_CMD_SETREG | (1 << 16) | BCI_PBD1 ); BCI_SEND( state->src.offset ); BCI_SEND( BCI_CMD_SETREG | (1 << 16) | BCI_PBD2 ); BCI_SEND( BitmapDescriptor ); sdev->v_pbd = 1; }
static inline void savage4_validate_gbd( Savage4DriverData *sdrv, Savage4DeviceData *sdev, CardState *state ) { u32 BitmapDescriptor; CoreSurface *destination; int bpp; if (sdev->v_gbd) return; destination = state->destination; bpp = DFB_BYTES_PER_PIXEL(destination->config.format); BitmapDescriptor = BCI_BD_BW_DISABLE | 8 | 1; BCI_BD_SET_BPP( BitmapDescriptor, bpp * 8 ); BCI_BD_SET_STRIDE( BitmapDescriptor, state->dst.pitch / bpp ); /* strange effects if we don't wait here for the Savage4 being idle */ savage4_waitidle( sdrv, sdev ); BCI_SEND( BCI_CMD_SETREG | (1 << 16) | BCI_GBD1 ); BCI_SEND( state->dst.offset ); BCI_SEND( BCI_CMD_SETREG | (1 << 16) | BCI_GBD2 ); BCI_SEND( BitmapDescriptor ); sdev->v_gbd = 1; }
LOCAL void dfb_drawbuffer(DFBDISPLAY *mod, struct TVRequest *req) { DFBWINDOW *v = req->tvr_Op.DrawBuffer.Window; TINT w = req->tvr_Op.DrawBuffer.RRect[2]; TINT h = req->tvr_Op.DrawBuffer.RRect[3]; TINT xd = req->tvr_Op.DrawBuffer.RRect[0]; TINT yd = req->tvr_Op.DrawBuffer.RRect[1]; TAPTR buf = req->tvr_Op.DrawBuffer.Buf; if (!buf) return; TINT totw = req->tvr_Op.DrawBuffer.TotWidth; IDirectFBSurface *surface = NULL; DFBSurfaceDescription dsc; DFBRectangle rect = { 0, 0, w, h }; dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_PREALLOCATED; dsc.width = w; dsc.height = h; dsc.pixelformat = DSPF_RGB32; dsc.preallocated[0].data = buf; dsc.preallocated[0].pitch = totw * DFB_BYTES_PER_PIXEL(DSPF_RGB32); if (mod->dfb_DFB->CreateSurface(mod->dfb_DFB, &dsc, &surface) == DFB_OK) { v->winsurface->Blit(v->winsurface, surface, &rect, xd, yd); surface->Release(surface); } }
static inline void pxa3xx_validate_DEST( PXA3XXDriverData *pdrv, PXA3XXDeviceData *pdev, CardState *state ) { CoreSurfaceBuffer *buffer = state->dst.buffer; u32 *prep = start_buffer( pdrv, 6 ); D_DEBUG_AT( PXA3XX_BLT, "%s( 0x%08lx [%d] )\n", __FUNCTION__, state->dst.phys, state->dst.pitch ); pdev->dst_phys = state->dst.phys; pdev->dst_pitch = state->dst.pitch; pdev->dst_bpp = DFB_BYTES_PER_PIXEL( buffer->format ); pdev->dst_index = DFB_PIXELFORMAT_INDEX( buffer->format ) % DFB_NUM_PIXELFORMATS; /* Set destination. */ prep[0] = 0x020000A2; prep[1] = pdev->dst_phys; prep[2] = (pixel_formats[pdev->dst_index] << 19) | (pdev->dst_pitch << 5) | pdev->dst_bpp; prep[3] = 0x02000012; prep[4] = prep[1]; prep[5] = prep[2]; submit_buffer( pdrv, 6 ); /* Set the flags. */ PXA3XX_VALIDATE( DEST ); }
void GP2DEngine::validate_SOURCE( GP2DTask *mytask, CardState *state ) { __u32 *prep = mytask->start( 6 ); CoreSurfaceBuffer *buffer = state->src.buffer; mytask->src_phys = (unsigned long) state->src.handle; mytask->src_pitch = state->src.pitch; mytask->src_bpp = DFB_BYTES_PER_PIXEL( buffer->format ); mytask->src_index = DFB_PIXELFORMAT_INDEX( buffer->format ) % DFB_NUM_PIXELFORMATS; /* Set source start address. */ prep[0] = GP2D_OPCODE_WPR; prep[1] = 0x4c; prep[2] = mytask->src_phys; /* Set source stride. */ prep[3] = GP2D_OPCODE_WPR; prep[4] = 0x58; prep[5] = mytask->src_pitch / mytask->src_bpp; mytask->submit( 6 ); /* Set the flags. */ GP2D_VALIDATE( SOURCE ); }
static int DirectFB_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * rect, const void *pixels, int pitch) { DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata; DFBResult ret; Uint8 *dpixels; int dpitch; Uint8 *src, *dst; int row; size_t length; int bpp = DFB_BYTES_PER_PIXEL(SDLToDFBPixelFormat(texture->format)); // FIXME: SDL_BYTESPERPIXEL(texture->format) broken for yuv yv12 3 planes SDL_DFB_CHECKERR(data->surface->Lock(data->surface, DSLF_WRITE | DSLF_READ, ((void **) &dpixels), &dpitch)); src = (Uint8 *) pixels; dst = (Uint8 *) dpixels + rect->y * dpitch + rect->x * bpp; length = rect->w * bpp; for (row = 0; row < rect->h; ++row) { SDL_memcpy(dst, src, length); src += pitch; dst += dpitch; } SDL_DFB_CHECKERR(data->surface->Unlock(data->surface)); return 0; error: return 1; }
static void print_usage (const char *prg_name) { int i = 0; fprintf (stderr, "\nDirectFB Layer Configuration (version %s)\n\n", DIRECTFB_VERSION); fprintf (stderr, "Usage: %s [options]\n\n", prg_name); fprintf (stderr, "Options:\n"); fprintf (stderr, " -l, --layer <id> Use the specified layer, default is primary\n"); fprintf (stderr, " -m, --mode <width>x<height> Change the resolution (pixels)\n"); fprintf (stderr, " -f, --format <pixelformat> Change the pixel format\n"); fprintf (stderr, " -b, --buffer <buffermode> Change the buffer mode (single/video/system)\n"); fprintf (stderr, " -o, --opacity <opacity> Change the layer's opacity (0-255)\n"); fprintf (stderr, " -L, --level <level> Change the layer's level\n"); fprintf (stderr, " -R, --rotate <degree> Change the layer rotation\n"); fprintf (stderr, " -h, --help Show this help message\n"); fprintf (stderr, " -v, --version Print version information\n"); fprintf (stderr, "\n"); fprintf (stderr, "Known pixel formats:\n"); while (format_names[i].format != DSPF_UNKNOWN) { DFBSurfacePixelFormat format = format_names[i].format; fprintf (stderr, " %-10s %2d bits, %d bytes", format_names[i].name, DFB_BITS_PER_PIXEL(format), DFB_BYTES_PER_PIXEL(format)); if (DFB_PIXELFORMAT_HAS_ALPHA(format)) fprintf (stderr, " ALPHA"); if (DFB_PIXELFORMAT_IS_INDEXED(format)) fprintf (stderr, " INDEXED"); if (DFB_PLANAR_PIXELFORMAT(format)) { int planes = DFB_PLANE_MULTIPLY(format, 1000); fprintf (stderr, " PLANAR (x%d.%03d)", planes / 1000, planes % 1000); } fprintf (stderr, "\n"); ++i; } fprintf (stderr, "\n"); fprintf (stderr, "Valid buffer modes:\n"); fprintf (stderr, " FRONTONLY or 'single'\n"); fprintf (stderr, " BACKVIDEO or 'video'\n"); fprintf (stderr, " BACKSYSTEM or 'system'\n"); fprintf (stderr, " TRIPLE\n"); fprintf (stderr, " WINDOWS\n"); fprintf (stderr, "\n"); fprintf (stderr, "Specifying neither mode nor format just displays the current configuration.\n"); fprintf (stderr, "\n"); }
static int DirectFB_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * rect, const void *pixels, int pitch) { DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata; Uint8 *dpixels; int dpitch; Uint8 *src, *dst; int row; size_t length; int bpp = DFB_BYTES_PER_PIXEL(DirectFB_SDLToDFBPixelFormat(texture->format)); /* FIXME: SDL_BYTESPERPIXEL(texture->format) broken for yuv yv12 3 planes */ DirectFB_ActivateRenderer(renderer); if ((texture->format == SDL_PIXELFORMAT_YV12) || (texture->format == SDL_PIXELFORMAT_IYUV)) { bpp = 1; } SDL_DFB_CHECKERR(data->surface->Lock(data->surface, DSLF_WRITE | DSLF_READ, ((void **) &dpixels), &dpitch)); src = (Uint8 *) pixels; dst = (Uint8 *) dpixels + rect->y * dpitch + rect->x * bpp; length = rect->w * bpp; for (row = 0; row < rect->h; ++row) { SDL_memcpy(dst, src, length); src += pitch; dst += dpitch; } /* copy other planes for 3 plane formats */ if ((texture->format == SDL_PIXELFORMAT_YV12) || (texture->format == SDL_PIXELFORMAT_IYUV)) { src = (Uint8 *) pixels + texture->h * pitch; dst = (Uint8 *) dpixels + texture->h * dpitch + rect->y * dpitch / 4 + rect->x * bpp / 2; for (row = 0; row < rect->h / 2 + (rect->h & 1); ++row) { SDL_memcpy(dst, src, length / 2); src += pitch / 2; dst += dpitch / 2; } src = (Uint8 *) pixels + texture->h * pitch + texture->h * pitch / 4; dst = (Uint8 *) dpixels + texture->h * dpitch + texture->h * dpitch / 4 + rect->y * dpitch / 4 + rect->x * bpp / 2; for (row = 0; row < rect->h / 2 + (rect->h & 1); ++row) { SDL_memcpy(dst, src, length / 2); src += pitch / 2; dst += dpitch / 2; } } SDL_DFB_CHECKERR(data->surface->Unlock(data->surface)); data->isDirty = 0; return 0; error: return 1; }
static void gxCheckState(void *drv, void *dev, CardState *state, DFBAccelerationMask accel) { #if NSC_ACCEL NSCDriverData *gxdrv = (NSCDriverData *) drv; NSCDeviceData *gxdev = (NSCDeviceData *) dev; if(state->destination->config.format != DSPF_RGB16) return; if (DFB_BLITTING_FUNCTION(accel)) { if(state->source->config.format != DSPF_RGB16) return; if (gxdrv->cpu) { /* GU2 - if there are no other blitting flags than the supported * and the source and destination formats are the same */ if (!(state->blittingflags & ~GX_SUPPORTED_BLITTINGFLAGS) && state->source && state->source->config.format != DSPF_RGB24) { state->accel |= GX_SUPPORTED_BLITTINGFUNCTIONS; } } else{ /* GU1 - source width must match frame buffer strid */ if(state->source) { int src_pitch = 0; int dst_pitch = 0; if(state->source) { src_pitch = state->source->config.size.w * DFB_BYTES_PER_PIXEL(state->source->config.format); } if (state->modified & SMF_DESTINATION) { if(state->destination && state->dst.buffer) dst_pitch = state->dst.pitch; } if(dst_pitch == 0) { dst_pitch = gxdev->dst_pitch; } if(src_pitch == dst_pitch && state->source) { state->accel |= GX_SUPPORTED_BLITTINGFUNCTIONS; } } } } else { /* if there are no other drawing flags than the supported */ if (!(state->drawingflags & ~GX_SUPPORTED_DRAWINGFLAGS)) { state->accel |= GX_SUPPORTED_DRAWINGFUNCTIONS; } } #endif /* NSC_ACCEL */ }
/* * Called by vmwareSetState() to ensure that the destination registers are properly set * for execution of rendering functions. */ static inline void vmware_validate_DESTINATION( VMWareDeviceData *vdev, CardState *state ) { /* Remember destination parameters for usage in rendering functions. */ vdev->dst_addr = state->dst.addr; vdev->dst_pitch = state->dst.pitch; vdev->dst_format = state->dst.buffer->format; vdev->dst_bpp = DFB_BYTES_PER_PIXEL( vdev->dst_format ); /* Set the flag. */ VMWARE_VALIDATE( DESTINATION ); }
/* * Called by vmwareSetState() to ensure that the source registers are properly set * for execution of blitting functions. */ static inline void vmware_validate_SOURCE( VMWareDeviceData *vdev, CardState *state ) { /* Remember source parameters for usage in rendering functions. */ vdev->src_addr = state->src.addr; vdev->src_pitch = state->src.pitch; vdev->src_format = state->src.buffer->format; vdev->src_bpp = DFB_BYTES_PER_PIXEL( vdev->src_format ); /* Set the flag. */ VMWARE_VALIDATE( SOURCE ); }
static int print_usage( const char *prg ) { int i = 0; fprintf (stderr, "\n"); fprintf (stderr, "== DirectFB Blitting Test (version %s) ==\n", DIRECTFB_VERSION); fprintf (stderr, "\n"); fprintf (stderr, "Known pixel formats:\n"); while (format_names[i].format != DSPF_UNKNOWN) { DFBSurfacePixelFormat format = format_names[i].format; fprintf (stderr, " %-10s %2d bits, %d bytes", format_names[i].name, DFB_BITS_PER_PIXEL(format), DFB_BYTES_PER_PIXEL(format)); if (DFB_PIXELFORMAT_HAS_ALPHA(format)) fprintf (stderr, " ALPHA"); if (DFB_PIXELFORMAT_IS_INDEXED(format)) fprintf (stderr, " INDEXED"); if (DFB_PLANAR_PIXELFORMAT(format)) { int planes = DFB_PLANE_MULTIPLY(format, 1000); fprintf (stderr, " PLANAR (x%d.%03d)", planes / 1000, planes % 1000); } fprintf (stderr, "\n"); ++i; } fprintf (stderr, "\n"); fprintf (stderr, "\n"); fprintf (stderr, "Usage: %s [options]\n", prg); fprintf (stderr, "\n"); fprintf (stderr, "Options:\n"); fprintf (stderr, " -h, --help Show this help message\n"); fprintf (stderr, " -v, --version Print version information\n"); fprintf (stderr, " -s, --source <pixelformat> Source pixel format\n"); fprintf (stderr, " -d, --dest <pixelformat> Destination pixel format\n"); fprintf (stderr, " -r, --resize Set destination from source size\n"); fprintf (stderr, " -b, --benchmark Enable benchmarking mode\n"); fprintf (stderr, " -R, --rerender Rerender before every blit (benchmark)\n"); return -1; }
static int print_usage( const char *prg ) { int i = 0; fprintf (stderr, "\n"); fprintf (stderr, "== DirectFB Font Test (version %s) ==\n", DIRECTFB_VERSION); fprintf (stderr, "\n"); fprintf (stderr, "Known pixel formats:\n"); while (format_names[i].format != DSPF_UNKNOWN) { DFBSurfacePixelFormat format = format_names[i].format; fprintf (stderr, " %-10s %2d bits, %d bytes", format_names[i].name, DFB_BITS_PER_PIXEL(format), DFB_BYTES_PER_PIXEL(format)); if (DFB_PIXELFORMAT_HAS_ALPHA(format)) fprintf (stderr, " ALPHA"); if (DFB_PIXELFORMAT_IS_INDEXED(format)) fprintf (stderr, " INDEXED"); if (DFB_PLANAR_PIXELFORMAT(format)) { int planes = DFB_PLANE_MULTIPLY(format, 1000); fprintf (stderr, " PLANAR (x%d.%03d)", planes / 1000, planes % 1000); } fprintf (stderr, "\n"); ++i; } fprintf (stderr, "\n"); fprintf (stderr, "\n"); fprintf (stderr, "Usage: %s [options] <file>\n", prg); fprintf (stderr, "\n"); fprintf (stderr, "Options:\n"); fprintf (stderr, " -h, --help Show this help message\n"); fprintf (stderr, " -v, --version Print version information\n"); fprintf (stderr, " -o, --outline Render outlined fonts\n"); fprintf (stderr, " -ow, --outline-width <width> Change outline width (default 1)\n"); fprintf (stderr, " -oo, --outline-opacity <opacity> Change outline opacity (default 255)\n"); return -1; }
static int print_usage( const char *prg ) { int i = 0; fprintf (stderr, "\n"); fprintf (stderr, "== DirectFB Fill Rectangle Test (version %s) ==\n", DIRECTFB_VERSION); fprintf (stderr, "\n"); fprintf (stderr, "Known pixel formats:\n"); while (format_names[i].format != DSPF_UNKNOWN) { DFBSurfacePixelFormat format = format_names[i].format; fprintf (stderr, " %-10s %2d bits, %d bytes", format_names[i].name, DFB_BITS_PER_PIXEL(format), DFB_BYTES_PER_PIXEL(format)); if (DFB_PIXELFORMAT_HAS_ALPHA(format)) fprintf (stderr, " ALPHA"); if (DFB_PIXELFORMAT_IS_INDEXED(format)) fprintf (stderr, " INDEXED"); if (DFB_PLANAR_PIXELFORMAT(format)) { int planes = DFB_PLANE_MULTIPLY(format, 1000); fprintf (stderr, " PLANAR (x%d.%03d)", planes / 1000, planes % 1000); } fprintf (stderr, "\n"); ++i; } fprintf (stderr, "\n"); fprintf (stderr, "\n"); fprintf (stderr, "Usage: %s [options]\n", prg); fprintf (stderr, "\n"); fprintf (stderr, "Options:\n"); fprintf (stderr, " -h, --help Show this help message\n"); fprintf (stderr, " -v, --version Print version information\n"); fprintf (stderr, " -d, --dest <pixelformat> Destination pixel format\n"); fprintf (stderr, " -s, --static Use DSCAPS_STATIC_ALLOC\n"); return -1; }
/* * Called by davinciSetState() to ensure that the source registers are properly set * for execution of blitting functions. */ static inline void davinci_validate_SOURCE( DavinciDeviceData *ddev, CardState *state ) { /* Remember source parameters for usage in rendering functions. */ ddev->src_addr = state->src.addr; ddev->src_phys = state->src.phys; ddev->src_pitch = state->src.pitch; ddev->src_format = state->src.buffer->format; ddev->src_bpp = DFB_BYTES_PER_PIXEL( ddev->src_format ); D_DEBUG_AT( Davinci_2D, " => SOURCE: 0x%08lx\n", ddev->src_phys ); /* Set the flag. */ DAVINCI_VALIDATE( SOURCE ); }
static DFBResult sh7722InitLayer( CoreLayer *layer, void *driver_data, void *layer_data, DFBDisplayLayerDescription *description, DFBDisplayLayerConfig *config, DFBColorAdjustment *adjustment ) { SH7722DriverData *sdrv = driver_data; SH7722DeviceData *sdev = sdrv->dev; SH7722LayerData *data = layer_data; D_DEBUG_AT( SH7722_Layer, "%s()\n", __FUNCTION__ ); /* initialize layer data */ data->layer = SH7722_LAYER_INPUT1 + sdrv->num_inputs++; /* set capabilities and type */ description->caps = DLCAPS_SURFACE | DLCAPS_ALPHACHANNEL | DLCAPS_OPACITY | DLCAPS_SCREEN_POSITION | DLCAPS_SRC_COLORKEY; description->type = DLTF_STILL_PICTURE | DLTF_GRAPHICS | DLTF_VIDEO; /* set name */ snprintf( description->name, DFB_DISPLAY_LAYER_DESC_NAME_LENGTH, "Input %d", sdrv->num_inputs ); /* fill out the default configuration */ config->flags = DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT | DLCONF_BUFFERMODE | DLCONF_OPTIONS; config->width = sdev->lcd_width; config->height = sdev->lcd_height; config->pixelformat = DSPF_RGB16; config->buffermode = DLBM_FRONTONLY; config->options = DLOP_ALPHACHANNEL; /* libshbeu */ sdev->shbeu_src[data->layer].s.w = sdev->lcd_width; sdev->shbeu_src[data->layer].s.h = sdev->lcd_height; sdev->shbeu_src[data->layer].s.pitch = sdev->lcd_pitch/DFB_BYTES_PER_PIXEL(config->pixelformat); sdev->shbeu_src[data->layer].s.format = REN_RGB565; sdev->shbeu_src[data->layer].alpha = 0xff; sdev->shbeu_src[data->layer].x = 0; sdev->shbeu_src[data->layer].y = 0; return DFB_OK; }
static inline void neo2200_validate_src( Neo2200DriverData *ndrv, Neo2200DeviceData *ndev, CoreSurface *src, CoreSurfaceBufferLock *lock ) { if (ndev->n_src) return; ndev->srcOrg = lock->offset; ndev->srcPitch = lock->pitch; ndev->srcPixelWidth = DFB_BYTES_PER_PIXEL(src->config.format); neo2200_waitfifo( ndrv, ndev, 1 ); ndrv->neo2200->pitch = (ndev->dstPitch << 16) | (ndev->srcPitch & 0xffff); ndev->n_src = 1; }
/* * Called by davinciSetState() to ensure that the destination registers are properly set * for execution of rendering functions. */ static inline void davinci_validate_DESTINATION( DavinciDeviceData *ddev, CardState *state ) { /* Remember destination parameters for usage in rendering functions. */ ddev->dst_addr = state->dst.addr; ddev->dst_phys = state->dst.phys; ddev->dst_size = state->dst.allocation->size; ddev->dst_pitch = state->dst.pitch; ddev->dst_format = state->dst.buffer->format; ddev->dst_bpp = DFB_BYTES_PER_PIXEL( ddev->dst_format ); D_DEBUG_AT( Davinci_2D, " => DESTINATION: 0x%08lx\n", ddev->dst_phys ); /* Set the flag. */ DAVINCI_VALIDATE( DESTINATION ); }
void mach64gt_set_destination( Mach64DriverData *mdrv, Mach64DeviceData *mdev, CardState *state ) { volatile u8 *mmio = mdrv->mmio_base; CoreSurface *destination = state->destination; unsigned int pitch = state->dst.pitch / DFB_BYTES_PER_PIXEL( destination->config.format ); mdev->pix_width &= ~DST_PIX_WIDTH; switch (destination->config.format) { case DSPF_RGB332: mdev->pix_width |= DST_PIX_WIDTH_RGB332; break; case DSPF_RGB555: case DSPF_ARGB1555: mdev->pix_width |= DST_PIX_WIDTH_ARGB1555; break; case DSPF_RGB444: case DSPF_ARGB4444: mdev->pix_width |= DST_PIX_WIDTH_ARGB4444; break; case DSPF_RGB16: mdev->pix_width |= DST_PIX_WIDTH_RGB565; break; case DSPF_RGB32: case DSPF_ARGB: mdev->pix_width |= DST_PIX_WIDTH_ARGB8888; break; default: D_BUG( "unexpected pixelformat!" ); return; } mdev->draw_blend &= ~DITHER_EN; mdev->blit_blend &= ~DITHER_EN; if (DFB_COLOR_BITS_PER_PIXEL( destination->config.format ) < 24) { mdev->draw_blend |= DITHER_EN; mdev->blit_blend |= DITHER_EN; } mach64_waitfifo( mdrv, mdev, 1 ); mach64_out32( mmio, DST_OFF_PITCH, (state->dst.offset/8) | ((pitch/8) << 22) ); }
static void print_usage (const char *prg_name) { int i = 0; fprintf (stderr, "\nDirectFB Render Test (version %s)\n\n", DIRECTFB_VERSION); fprintf (stderr, "Usage: %s [options]\n\n", prg_name); fprintf (stderr, "Options:\n"); fprintf (stderr, " -m, --mode <width>x<height> Set test surface size (default 800x600)\n"); fprintf (stderr, " -f, --format <pixelformat> Change the pixel format\n"); fprintf (stderr, " -h, --help Show this help message\n"); fprintf (stderr, " -v, --version Print version information\n"); fprintf (stderr, "\n"); fprintf (stderr, "Known pixel formats:\n"); while (format_names[i].format != DSPF_UNKNOWN) { DFBSurfacePixelFormat format = format_names[i].format; fprintf (stderr, " %-10s %2d bits, %d bytes", format_names[i].name, DFB_BITS_PER_PIXEL(format), DFB_BYTES_PER_PIXEL(format)); if (DFB_PIXELFORMAT_HAS_ALPHA(format)) fprintf (stderr, " ALPHA"); if (DFB_PIXELFORMAT_IS_INDEXED(format)) fprintf (stderr, " INDEXED"); if (DFB_PLANAR_PIXELFORMAT(format)) { int planes = DFB_PLANE_MULTIPLY(format, 1000); fprintf (stderr, " PLANAR (x%d.%03d)", planes / 1000, planes % 1000); } fprintf (stderr, "\n"); ++i; } fprintf (stderr, "\n"); }
static unsigned char * directfb_fb_init_driver (unsigned char *param, unsigned char *display) { DFBDisplayLayerConfig config; DFBResult ret; /*if (dfb) return NULL; DirectFBInit (&g_argc, (char ***) &g_argv); ret = DirectFBCreate (&dfb); if (ret) { char message[128]; snprintf (message, sizeof (message), "%s\n", DirectFBErrorString (ret)); return stracpy (message); }*/ dfb->GetDisplayLayer (dfb, DLID_PRIMARY, &layer); layer->GetConfiguration (layer, &config); pixelformat = config.pixelformat; directfb_driver.depth = (((DFB_BYTES_PER_PIXEL (pixelformat) & 0x7)) | ((DFB_BITS_PER_PIXEL (pixelformat) & 0x1F) << 3)); /* endian test */ if (htons (0x1234) == 0x1234) directfb_driver.depth |= 0x100; directfb_driver.x = config.width; directfb_driver.y = config.height; memset (directfb_hash_table, 0, sizeof (directfb_hash_table)); arrow = NULL; return NULL; }
static void print_usage (const char *prg_name) { int i = 0; fprintf (stderr, "\nDirectFB Glyph Image File Format Tool (version %s)\n\n", DIRECTFB_VERSION); fprintf (stderr, "Usage: %s [options]\n\n", prg_name); fprintf (stderr, "Options:\n"); fprintf (stderr, " -f, --format <pixelformat> Choose the pixel format (default ARGB)\n"); fprintf (stderr, " -s, --sizes <s1>[,s2...] Choose sizes to generate glyph images for\n"); fprintf (stderr, " -h, --help Show this help message\n"); fprintf (stderr, " -v, --version Print version information\n"); fprintf (stderr, "\n"); fprintf (stderr, "Known pixel formats with alpha:\n"); while (format_names[i].format != DSPF_UNKNOWN) { DFBSurfacePixelFormat format = format_names[i].format; if (DFB_PIXELFORMAT_HAS_ALPHA(format)) { fprintf (stderr, " %-10s %2d bits, %d bytes", format_names[i].name, DFB_BITS_PER_PIXEL(format), DFB_BYTES_PER_PIXEL(format)); if (DFB_PIXELFORMAT_IS_INDEXED(format)) fprintf (stderr, " INDEXED"); if (DFB_PLANAR_PIXELFORMAT(format)) { int planes = DFB_PLANE_MULTIPLY(format, 1000); fprintf (stderr, " PLANAR (x%d.%03d)", planes / 1000, planes % 1000); } fprintf (stderr, "\n"); } ++i; } fprintf (stderr, "\n"); }
void mach64gt_set_source( Mach64DriverData *mdrv, Mach64DeviceData *mdev, CardState *state ) { volatile u8 *mmio = mdrv->mmio_base; CoreSurface *source = state->source; unsigned int pitch = state->src.pitch / DFB_BYTES_PER_PIXEL( source->config.format ); if (MACH64_IS_VALID( m_source )) return; mdev->pix_width &= ~SRC_PIX_WIDTH; switch (source->config.format) { case DSPF_RGB332: mdev->pix_width |= SRC_PIX_WIDTH_RGB332; break; case DSPF_RGB555: case DSPF_ARGB1555: mdev->pix_width |= SRC_PIX_WIDTH_ARGB1555; break; case DSPF_RGB444: case DSPF_ARGB4444: mdev->pix_width |= SRC_PIX_WIDTH_ARGB4444; break; case DSPF_RGB16: mdev->pix_width |= SRC_PIX_WIDTH_RGB565; break; case DSPF_RGB32: case DSPF_ARGB: mdev->pix_width |= SRC_PIX_WIDTH_ARGB8888; break; default: D_BUG( "unexpected pixelformat!" ); return; } mach64_waitfifo( mdrv, mdev, 1 ); mach64_out32( mmio, SRC_OFF_PITCH, (state->src.offset/8) | ((pitch/8) << 22) ); MACH64_VALIDATE( m_source ); }
static inline void neo2200_validate_bltMode_dst( Neo2200DriverData *ndrv, Neo2200DeviceData *ndev, CoreSurface *dst, CoreSurfaceBufferLock *lock ) { int bltMode = 0; if (ndev->n_bltMode_dst) return; switch (dst->config.format) { case DSPF_A8: case DSPF_LUT8: case DSPF_RGB332: bltMode |= NEO_MODE1_DEPTH8; break; case DSPF_ARGB1555: case DSPF_RGB16: case DSPF_YUY2: bltMode |= NEO_MODE1_DEPTH16; break; default: D_BUG( "unexpected pixelformat!" ); break; } ndev->dstOrg = lock->offset; ndev->dstPitch = lock->pitch; ndev->dstPixelWidth = DFB_BYTES_PER_PIXEL(dst->config.format); neo2200_waitfifo( ndrv, ndev, 2 ); ndrv->neo2200->bltStat = bltMode << 16; ndrv->neo2200->pitch = (ndev->dstPitch << 16) | (ndev->srcPitch & 0xffff); ndev->n_bltMode_dst = 1; }
static int DirectFB_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * rect, void **pixels, int *pitch) { DirectFB_TextureData *texturedata = (DirectFB_TextureData *) texture->driverdata; DirectFB_ActivateRenderer(renderer); #if 0 if (markDirty) { SDL_AddDirtyRect(&texturedata->dirty, rect); } #endif if (texturedata->display) { void *fdata; int fpitch; SDL_DFB_CHECKERR(texturedata->surface->Lock(texturedata->surface, DSLF_WRITE | DSLF_READ, &fdata, &fpitch)); *pitch = fpitch; *pixels = fdata; } else { *pixels = (void *) ((Uint8 *) texturedata->pixels + rect->y * texturedata->pitch + rect->x * DFB_BYTES_PER_PIXEL(DirectFB_SDLToDFBPixelFormat(texture->format))); *pitch = texturedata->pitch; texturedata->isDirty = 1; } return 0; error: return -1; }
static inline void pxa3xx_validate_SOURCE( PXA3XXDriverData *pdrv, PXA3XXDeviceData *pdev, CardState *state ) { CoreSurfaceBuffer *buffer = state->src.buffer; u32 *prep = start_buffer( pdrv, 3 ); pdev->src_phys = state->src.phys; pdev->src_pitch = state->src.pitch; pdev->src_bpp = DFB_BYTES_PER_PIXEL( buffer->format ); pdev->src_index = DFB_PIXELFORMAT_INDEX( buffer->format ) % DFB_NUM_PIXELFORMATS; pdev->src_alpha = DFB_PIXELFORMAT_HAS_ALPHA( buffer->format ); /* Set source. */ prep[0] = 0x02000002; prep[1] = pdev->src_phys; prep[2] = (pixel_formats[pdev->src_index] << 19) | (pdev->src_pitch << 5) | pdev->src_bpp; submit_buffer( pdrv, 3 ); /* Set the flag. */ PXA3XX_VALIDATE( SOURCE ); }
static void print_usage (const char *prg_name) { int i = 0; fprintf (stderr, "\n"); fprintf (stderr, "== DirectFB Window Test (version %s) ==\n", DIRECTFB_VERSION); fprintf (stderr, "\n"); fprintf (stderr, "Known pixel formats:\n"); while (format_names[i].format != DSPF_UNKNOWN) { DFBSurfacePixelFormat format = format_names[i].format; fprintf (stderr, " %-10s %2d bits, %d bytes", format_names[i].name, DFB_BITS_PER_PIXEL(format), DFB_BYTES_PER_PIXEL(format)); if (DFB_PIXELFORMAT_HAS_ALPHA(format)) fprintf (stderr, " ALPHA"); if (DFB_PIXELFORMAT_IS_INDEXED(format)) fprintf (stderr, " INDEXED"); if (DFB_PLANAR_PIXELFORMAT(format)) { int planes = DFB_PLANE_MULTIPLY(format, 1000); fprintf (stderr, " PLANAR (x%d.%03d)", planes / 1000, planes % 1000); } fprintf (stderr, "\n"); ++i; } fprintf (stderr, "\n"); fprintf (stderr, "Known window capabilities:\n"); for (i=0; caps_names[i].capability != DWCAPS_NONE; i++) fprintf (stderr, " %s\n", caps_names[i].name); fprintf (stderr, "\n"); fprintf (stderr, "Known window options:\n"); for (i=0; options_names[i].option != DWOP_NONE; i++) fprintf (stderr, " %s\n", options_names[i].name); fprintf (stderr, "\n"); fprintf (stderr, "\n"); fprintf (stderr, "Usage: %s [options]\n", prg_name); fprintf (stderr, "\n"); fprintf (stderr, "Options:\n"); fprintf (stderr, " -h, --help Show this help message\n"); fprintf (stderr, " -v, --version Print version information\n"); fprintf (stderr, " -T, --top-level <toplevel_id> WindowID (skips top creation)\n"); fprintf (stderr, " -W, --wait-at-end Wait at the end (don't exit)\n"); fprintf (stderr, "\n"); fprintf (stderr, "Top window:\n"); fprintf (stderr, " -r, --run <test> Run test (see list below)\n"); fprintf (stderr, " -p, --pos <posx>,<posy> Position (%d,%d)\n", m_desc_top.posx, m_desc_top.posy); fprintf (stderr, " -s, --size <width>x<height> Size (%dx%d)\n", m_desc_top.width, m_desc_top.height); fprintf (stderr, " -f, --format <pixelformat> Pixel Format (%s)\n", dfb_pixelformat_name(m_desc_top.pixelformat)); fprintf (stderr, " -c, --caps <window_caps> Capabilities (NONE)\n"); fprintf (stderr, " -l, --color <aarrggbb> Fixed Color (NONE)\n"); fprintf (stderr, " -o, --option <window_option> Options (NONE)\n"); fprintf (stderr, " -a, --associate <parent_id> Association (N/A)\n"); fprintf (stderr, "\n"); fprintf (stderr, "Sub window:\n"); fprintf (stderr, " -R, --sub-run <test> Run test (see list below)\n"); fprintf (stderr, " -P, --sub-pos <posx>,<posy> Position (%d,%d)\n", m_desc_sub.posx, m_desc_sub.posy); fprintf (stderr, " -S, --sub-size <width>x<height> Size (%dx%d)\n", m_desc_sub.width, m_desc_sub.height); fprintf (stderr, " -F, --sub-format <pixelformat> Format (%s)\n", dfb_pixelformat_name(m_desc_sub.pixelformat)); fprintf (stderr, " -C, --sub-caps <window_caps> Capabilities (NONE)\n"); fprintf (stderr, " -L, --sub-color <aarrggbb> Fixed Color (NONE)\n"); fprintf (stderr, " -O, --sub-option <window_option> Options (NONE)\n"); fprintf (stderr, " -A, --sub-associate <parent_id> Association (N/A)\n"); fprintf (stderr, "\n"); fprintf (stderr, "Available tests:\n"); for (i=0; i<D_ARRAY_SIZE(m_tests); i++) fprintf (stderr, " %s\n", m_tests[i].name); fprintf (stderr, "\n"); }
static int DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) { SDL_Window *window = renderer->window; SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window); SDL_DFB_DEVICEDATA(display->device); DirectFB_TextureData *data; DFBSurfaceDescription dsc; DFBSurfacePixelFormat pixelformat; DirectFB_ActivateRenderer(renderer); SDL_DFB_ALLOC_CLEAR(data, sizeof(*data)); texture->driverdata = data; /* find the right pixelformat */ pixelformat = DirectFB_SDLToDFBPixelFormat(texture->format); if (pixelformat == DSPF_UNKNOWN) { SDL_SetError("Unknown pixel format %d\n", data->format); goto error; } data->format = texture->format; data->pitch = texture->w * DFB_BYTES_PER_PIXEL(pixelformat); if (DirectFB_AcquireVidLayer(renderer, texture) != 0) { /* fill surface description */ dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS; dsc.width = texture->w; dsc.height = texture->h; if(texture->format == SDL_PIXELFORMAT_YV12 || texture->format == SDL_PIXELFORMAT_IYUV) { /* dfb has problems with odd sizes -make them even internally */ dsc.width += (dsc.width % 2); dsc.height += (dsc.height % 2); } /* <1.2 Never use DSCAPS_VIDEOONLY here. It kills performance * No DSCAPS_SYSTEMONLY either - let dfb decide * 1.2: DSCAPS_SYSTEMONLY boosts performance by factor ~8 * Depends on other settings as well. Let dfb decide. */ dsc.caps = DSCAPS_PREMULTIPLIED; #if 0 if (texture->access == SDL_TEXTUREACCESS_STREAMING) dsc.caps |= DSCAPS_SYSTEMONLY; else dsc.caps |= DSCAPS_VIDEOONLY; #endif dsc.pixelformat = pixelformat; data->pixels = NULL; /* Create the surface */ SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc, &data->surface)); if (SDL_ISPIXELFORMAT_INDEXED(data->format) && !SDL_ISPIXELFORMAT_FOURCC(data->format)) { #if 1 SDL_DFB_CHECKERR(data->surface->GetPalette(data->surface, &data->palette)); #else /* DFB has issues with blitting LUT8 surfaces. * Creating a new palette does not help. */ DFBPaletteDescription pal_desc; pal_desc.flags = DPDESC_SIZE; /* | DPDESC_ENTRIES */ pal_desc.size = 256; SDL_DFB_CHECKERR(devdata->dfb->CreatePalette(devdata->dfb, &pal_desc,&data->palette)); SDL_DFB_CHECKERR(data->surface->SetPalette(data->surface, data->palette)); #endif } } #if (DFB_VERSION_ATLEAST(1,2,0)) data->render_options = DSRO_NONE; #endif if (texture->access == SDL_TEXTUREACCESS_STREAMING) { /* 3 plane YUVs return 1 bpp, but we need more space for other planes */ if(texture->format == SDL_PIXELFORMAT_YV12 || texture->format == SDL_PIXELFORMAT_IYUV) { SDL_DFB_ALLOC_CLEAR(data->pixels, (texture->h * data->pitch + ((texture->h + texture->h % 2) * (data->pitch + data->pitch % 2) * 2) / 4)); } else { SDL_DFB_ALLOC_CLEAR(data->pixels, texture->h * data->pitch); } } return 0; error: SDL_DFB_RELEASE(data->palette); SDL_DFB_RELEASE(data->surface); SDL_DFB_FREE(texture->driverdata); return -1; }
static int DirectFB_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * srcrect, const SDL_FRect * dstrect) { DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata; IDirectFBSurface *destsurf = data->target; DirectFB_TextureData *texturedata = (DirectFB_TextureData *) texture->driverdata; Uint8 alpha, r, g, b; DFBRegion clip_region; DFBRectangle sr, dr; DirectFB_ActivateRenderer(renderer); SDLtoDFBRect(srcrect, &sr); SDLtoDFBRect_Float(dstrect, &dr); destsurf->GetClip(destsurf, &clip_region); dr.x += clip_region.x1; dr.y += clip_region.y1; if (texturedata->display) { int px, py; SDL_Window *window = renderer->window; IDirectFBWindow *dfbwin = get_dfb_window(window); SDL_DFB_WINDOWDATA(window); SDL_VideoDisplay *display = texturedata->display; DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata; SDL_DFB_CHECKERR(dispdata-> vidlayer->SetSourceRectangle(dispdata->vidlayer, sr.x, sr.y, sr.w, sr.h)); dfbwin->GetPosition(dfbwin, &px, &py); px += windata->client.x; py += windata->client.y; SDL_DFB_CHECKERR(dispdata-> vidlayer->SetScreenRectangle(dispdata->vidlayer, px + dr.x, py + dr.y, dr.w, dr.h)); } else { DFBSurfaceBlittingFlags flags = 0; #if 0 if (texturedata->dirty.list) { SDL_DirtyRect *dirty; void *pixels; int bpp = DFB_BYTES_PER_PIXEL(DirectFB_SDLToDFBPixelFormat(texture->format)); int pitch = texturedata->pitch; for (dirty = texturedata->dirty.list; dirty; dirty = dirty->next) { SDL_Rect *rect = &dirty->rect; pixels = (void *) ((Uint8 *) texturedata->pixels + rect->y * pitch + rect->x * bpp); DirectFB_UpdateTexture(renderer, texture, rect, pixels, texturedata->pitch); } SDL_ClearDirtyRects(&texturedata->dirty); } #endif if (texturedata->isDirty) { SDL_Rect rect; rect.x = 0; rect.y = 0; rect.w = texture->w; rect.h = texture->h; DirectFB_UpdateTexture(renderer, texture, &rect, texturedata->pixels, texturedata->pitch); } alpha = r = g = b = 0xff; if (texture->modMode & SDL_TEXTUREMODULATE_ALPHA){ alpha = texture->a; flags |= DSBLIT_BLEND_COLORALPHA; } if (texture->modMode & SDL_TEXTUREMODULATE_COLOR) { r = texture->r; g = texture->g; b = texture->b; flags |= DSBLIT_COLORIZE; } SDL_DFB_CHECKERR(destsurf-> SetColor(destsurf, r, g, b, alpha)); /* ???? flags |= DSBLIT_SRC_PREMULTCOLOR; */ SetBlendMode(data, texture->blendMode, texturedata); SDL_DFB_CHECKERR(destsurf->SetBlittingFlags(destsurf, data->blitFlags | flags)); #if (DFB_VERSION_ATLEAST(1,2,0)) SDL_DFB_CHECKERR(destsurf->SetRenderOptions(destsurf, texturedata-> render_options)); #endif if (srcrect->w == dstrect->w && srcrect->h == dstrect->h) { SDL_DFB_CHECKERR(destsurf->Blit(destsurf, texturedata->surface, &sr, dr.x, dr.y)); } else { SDL_DFB_CHECKERR(destsurf->StretchBlit(destsurf, texturedata->surface, &sr, &dr)); } } return 0; error: return -1; }