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 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 ); }
/* * Render a blended rectangle using the current hardware state. * * As the hardware does not directly support this, we blit a single * pixel with blending. */ static bool pxa3xxFillRectangleBlend( void *drv, void *dev, DFBRectangle *rect ) { PXA3XXDriverData *pdrv = drv; PXA3XXDeviceData *pdev = dev; u32 *prep = start_buffer( pdrv, 22 ); const u32 format = pixel_formats[DFB_PIXELFORMAT_INDEX( DSPF_ARGB )]; D_DEBUG_AT( PXA3XX_BLT, "%s( %d, %d - %dx%d )\n", __FUNCTION__, DFB_RECTANGLE_VALS( rect ) ); DUMP_INFO(); /* Set fake destination. */ prep[0] = 0x020000A2; prep[1] = pdev->fake_phys; prep[2] = (format << 19) | 4; /* Fill rectangle. */ prep[3] = 0x40000014 | (format << 8); prep[4] = 0; prep[5] = 0; prep[6] = PXA3XX_WH( rect->w, 1 ); prep[7] = PIXEL_ARGB( pdev->color.a, pdev->color.r, pdev->color.g, pdev->color.b ); /* Restore destination. */ prep[8] = 0x020000A2; prep[9] = pdev->dst_phys; prep[10] = (pixel_formats[pdev->dst_index] << 19) | (pdev->dst_pitch << 5) | pdev->dst_bpp; /* Set fake buffer as source. */ prep[11] = 0x02000002; prep[12] = pdev->fake_phys; prep[13] = (format << 19) | 4; /* Blit with blending. */ prep[14] = 0x47000107; prep[15] = rect->x; prep[16] = rect->y; prep[17] = 0; prep[18] = 0; prep[19] = rect->x; prep[20] = rect->y; prep[21] = PXA3XX_WH( rect->w, rect->h ); submit_buffer( pdrv, 22 ); /* Clear the flag. */ PXA3XX_INVALIDATE( SOURCE ); return true; }
static inline void tdfx_validate_source2D( TDFXDriverData *tdrv, TDFXDeviceData *tdev, CardState *state ) { CoreSurface *source = state->source; Voodoo2D *voodoo2D = tdrv->voodoo2D; if (tdev->v_source2D) return; tdfx_waitfifo( tdrv, tdev, 2 ); voodoo2D->srcBaseAddr = state->src.offset & 0xFFFFFF; voodoo2D->srcFormat = (state->src.pitch & 0x3FFF) | (blitFormat[DFB_PIXELFORMAT_INDEX(source->config.format)] << 16); tdev->v_source2D = 1; }
static inline void tdfx_validate_destination2D( TDFXDriverData *tdrv, TDFXDeviceData *tdev, CardState *state ) { CoreSurface *destination = state->destination; Voodoo2D *voodoo2D = tdrv->voodoo2D; if (tdev->v_destination2D) return; tdfx_waitfifo( tdrv, tdev, 2 ); voodoo2D->dstBaseAddr = state->dst.offset; voodoo2D->dstFormat = (state->dst.pitch & 0x3FFF) | (blitFormat[DFB_PIXELFORMAT_INDEX(destination->config.format)] << 16); tdev->v_destination2D = 1; }
static DFBResult x11TestConfig( CoreSurfacePool *pool, void *pool_data, void *pool_local, CoreSurfaceBuffer *buffer, const CoreSurfaceConfig *config ) { x11PoolLocalData *local = pool_local; DFBX11 *x11 = local->x11; D_DEBUG_AT( X11_Surfaces, "%s()\n", __FUNCTION__ ); if (!x11->visuals[DFB_PIXELFORMAT_INDEX(config->format)]) { D_DEBUG_AT( X11_Surfaces, " -> NO VISUAL for %s\n", dfb_pixelformat_name(config->format) ); return DFB_UNSUPPORTED; } return DFB_OK; }
DFBResult x11ImageInit( DFBX11 *x11, x11Image *image, int width, int height, DFBSurfacePixelFormat format ) { int ret; Visual *visual; DFBX11Shared *shared = x11->shared; if (!x11->use_shm) return DFB_UNSUPPORTED; /* Lookup visual. */ visual = x11->visuals[DFB_PIXELFORMAT_INDEX(format)]; if (!visual) return DFB_UNSUPPORTED; /* For probing. */ if (!image) return DFB_OK; image->width = width; image->height = height; image->format = format; image->depth = DFB_COLOR_BITS_PER_PIXEL( format ); D_MAGIC_SET( image, x11Image ); if (fusion_call_execute( &shared->call, FCEF_NONE, X11_IMAGE_INIT, image, &ret )) { D_MAGIC_CLEAR( image ); return DFB_FUSION; } if (ret) { D_DERROR( ret, "X11/Image: X11_IMAGE_INIT call failed!\n" ); D_MAGIC_CLEAR( image ); return ret; } return DFB_OK; }
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 ); }
void pxa3xxCheckState( void *drv, void *dev, CardState *state, DFBAccelerationMask accel ) { D_DEBUG_AT( PXA3XX_BLT, "%s( %p, 0x%08x )\n", __FUNCTION__, state, accel ); /* Return if the desired function is not supported at all. */ if (accel & ~(PXA3XX_SUPPORTED_DRAWINGFUNCTIONS | PXA3XX_SUPPORTED_BLITTINGFUNCTIONS)) return; /* Return if the destination format is not supported. */ if (!pixel_formats[DFB_PIXELFORMAT_INDEX(state->destination->config.format)]) return; /* Check if drawing or blitting is requested. */ if (DFB_DRAWING_FUNCTION( accel )) { /* Return if unsupported drawing flags are set. */ if (state->drawingflags & ~PXA3XX_SUPPORTED_DRAWINGFLAGS) return; /* Return if blending with unsupported blend functions is requested. */ if (state->drawingflags & DSDRAW_BLEND) { /* Check blend functions. */ if (!check_blend_functions( state )) return; } /* Enable acceleration of drawing functions. */ state->accel |= PXA3XX_SUPPORTED_DRAWINGFUNCTIONS; } else { const DFBSurfaceBlittingFlags flags = state->blittingflags; /* Return if unsupported blitting flags are set. */ if (flags & ~PXA3XX_SUPPORTED_BLITTINGFLAGS) return; /* Return if the source format is not supported. */ if (!pixel_formats[DFB_PIXELFORMAT_INDEX(state->source->config.format)]) return; /* Return if blending with unsupported blend functions is requested. */ if (flags & (DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA)) { if (DFB_PIXELFORMAT_HAS_ALPHA( state->destination->config.format )) return; /* Rotated blits are not supported with blending. */ if (flags & ~(DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA | DSBLIT_COLORIZE)) return; /* Blending with alpha from color value is not supported * in combination with other blending functions. */ if (flags & DSBLIT_BLEND_COLORALPHA && flags != DSBLIT_BLEND_COLORALPHA) return; /* Check blend functions. */ if (!check_blend_functions( state )) return; } /* Colorizing is only supported for rendering ARGB glyphs. */ if (flags & DSBLIT_COLORIZE && (flags != (DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_COLORIZE) || ! (state->source->type & CSTF_FONT))) return; /* Enable acceleration of blitting functions. */ state->accel |= PXA3XX_SUPPORTED_BLITTINGFUNCTIONS; } }
static void set_configuration( void ) { DFBResult ret; DFBDisplayLayerConfig config; printf( "\n" ); printf( "%s\n", desc.name ); printf( "\n" ); config.flags = DLCONF_NONE; if (width) { config.flags |= DLCONF_WIDTH; config.width = width; } if (height) { config.flags |= DLCONF_HEIGHT; config.height = height; } if (format != DSPF_UNKNOWN) { config.flags |= DLCONF_PIXELFORMAT; config.pixelformat = format; } if (buffermode != -1) { config.flags |= DLCONF_BUFFERMODE; config.buffermode = buffermode; } /* Set the configuration if anything changed. */ if (config.flags) { ret = layer->TestConfiguration( layer, &config, NULL ); if (ret) { DirectFBError( "IDirectFBDisplayLayer::TestConfiguration() failed", ret ); return; } ret = layer->SetConfiguration( layer, &config ); if (ret) { DirectFBError( "IDirectFBDisplayLayer::SetConfiguration() failed", ret ); return; } } /* Get and show the current (new) configuration. */ ret = layer->GetConfiguration( layer, &config ); if (ret) { DirectFBError( "IDirectFBDisplayLayer::GetConfiguration() failed", ret ); return; } /* Set the opacity if requested. */ if (opacity != -1) { ret = layer->SetOpacity( layer, opacity ); if (ret == DFB_UNSUPPORTED) fprintf( stderr, "Opacity value (%d) not supported!\n\n", opacity ); else if (ret) DirectFBError( "IDirectFBDisplayLayer::SetOpacity() failed", ret ); } /* Set the level if requested. */ if (set_level) { ret = layer->SetLevel( layer, level ); if (ret == DFB_UNSUPPORTED) fprintf( stderr, "Level (%d) not supported!\n\n", level ); else if (ret) DirectFBError( "IDirectFBDisplayLayer::SetLevel() failed", ret ); } /* Set the rotation if requested. */ if (set_rotation) { ret = layer->SetRotation( layer, rotation ); if (ret == DFB_UNSUPPORTED) fprintf( stderr, "Rotation (%d) not supported!\n\n", level ); else if (ret) DirectFBError( "IDirectFBDisplayLayer::SetRotation() failed", ret ); } if (config.flags & DLCONF_WIDTH) printf( "Width %d\n", config.width ); if (config.flags & DLCONF_HEIGHT) printf( "Height %d\n", config.height ); if (config.flags & DLCONF_PIXELFORMAT) printf( "Format %s\n", format_names[DFB_PIXELFORMAT_INDEX(config.pixelformat)].name ); if (config.flags & DLCONF_BUFFERMODE) { printf( "Buffermode " ); switch (config.buffermode) { case DLBM_FRONTONLY: printf( "FRONTONLY\n" ); break; case DLBM_BACKVIDEO: printf( "BACKVIDEO\n" ); break; case DLBM_BACKSYSTEM: printf( "BACKSYSTEM\n" ); break; case DLBM_TRIPLE: printf( "TRIPLE\n" ); break; case DLBM_WINDOWS: printf( "WINDOWS\n" ); break; default: printf( "unknown!\n" ); break; } } if (config.flags & DLCONF_OPTIONS) { printf( "Options " ); if (config.options == DLOP_NONE) { printf( "none\n" ); } else { if (config.options & DLOP_ALPHACHANNEL) printf( "ALPHA CHANNEL " ); if (config.options & DLOP_DEINTERLACING) printf( "DEINTERLACING " ); if (config.options & DLOP_DST_COLORKEY) printf( "DST COLOR KEY " ); if (config.options & DLOP_FIELD_PARITY) printf( "FIELD PARITY " ); if (config.options & DLOP_FLICKER_FILTERING) printf( "FLICKER FILTERING " ); if (config.options & DLOP_OPACITY) printf( "OPACITY " ); if (config.options & DLOP_SRC_COLORKEY) printf( "SRC COLOR KEY " ); printf( "\n" ); } } /* Query current level. */ if (desc.caps & DLCAPS_LEVELS) { int l; ret = layer->GetLevel( layer, &l ); if (ret) DirectFBError( "IDirectFBDisplayLayer::GetLevel() failed", ret ); else printf( "Level %d\n", l ); } printf( "\n" ); }
static DFBResult Inspector_Run( Inspector *inspector ) { static const DFBSurfacePixelFormat formats[] = { DSPF_LUT8, DSPF_ALUT44, DSPF_RGB332, DSPF_RGB16, DSPF_RGB24, DSPF_RGB32, DSPF_ARGB1555, DSPF_RGBA5551, DSPF_ARGB2554, DSPF_ARGB4444, DSPF_ARGB8565, DSPF_ARGB, DSPF_AiRGB, DSPF_A1, DSPF_A1_LSB, DSPF_A8, DSPF_YUY2, DSPF_UYVY, DSPF_I420, DSPF_YV12, DSPF_YV16, DSPF_NV12, DSPF_NV21, DSPF_NV16, DSPF_AYUV, DSPF_YUV444P, DSPF_AVYU, DSPF_VYU, }; int i, j, n; DFBResult ret; DFBSurfaceDescription desc; IDirectFBSurface *surfaces[D_ARRAY_SIZE(formats)]; char buf[strlen( inspector->directory ? : "" ) + 23]; if (inspector->options & CREATE_FILES) { /* Create the directory. */ if (mkdir( inspector->directory, 0755 ) < 0 && errno != EEXIST) { D_PERROR( "Inspector/Init: Could not create directory '%s'!\n", inspector->directory ); return DFB_INIT; } /* Open file for writing supported format conversions (blitting). */ snprintf( buf, sizeof(buf), "%s/blit.formats", inspector->directory ); inspector->files.formats = fopen( buf, "w" ); if (!inspector->files.formats) { D_PERROR( "Inspector/Init: Could not open file '%s' for writing!\n", buf ); return DFB_INIT; } } desc.flags = (DFBSurfaceDescriptionFlags)(DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT); desc.width = 64; desc.height = 64; for (i=0; i<D_ARRAY_SIZE(formats); i++) { desc.pixelformat = formats[i]; ret = inspector->dfb->CreateSurface( inspector->dfb, &desc, &surfaces[i] ); if (ret) { D_DERROR( ret, "Inspector/Init: Could not create %s surface!\n", format_names[DFB_PIXELFORMAT_INDEX(formats[i])].name ); while (i--) surfaces[i]->Release( surfaces[i] ); return ret; } surfaces[i]->SetFont( surfaces[i], inspector->font ); if (inspector->files.formats) fprintf( inspector->files.formats, "%s%s", i ? "," : "", format_names[DFB_PIXELFORMAT_INDEX(formats[i])].name ); } if (inspector->files.formats) fprintf( inspector->files.formats, "\n" ); printf("\n"); printf("source ->"); for (i=0; i<D_ARRAY_SIZE(formats); i++) printf( "%9s", format_names[DFB_PIXELFORMAT_INDEX(formats[i])].name ); printf("\n"); printf("dest.\n"); for (i=0; i<D_ARRAY_SIZE(formats); i++) { printf( "%9s", format_names[DFB_PIXELFORMAT_INDEX(formats[i])].name ); for (j=0; j<D_ARRAY_SIZE(formats); j++) { DFBAccelerationMask mask; surfaces[i]->GetAccelerationMask( surfaces[i], surfaces[j], &mask ); if (mask & DFXL_DRAWSTRING) inspector->device_drawstring = true; printf( "%9s", (mask & DFXL_BLIT) ? "X" : "" ); if (inspector->files.formats) fputc( (mask & DFXL_BLIT) ? '1' : '0', inspector->files.formats ); } printf( " %s", format_names[DFB_PIXELFORMAT_INDEX(formats[i])].name ); printf("\n"); if (inspector->files.formats) fprintf( inspector->files.formats, "\n" ); } for (i=0; i<D_ARRAY_SIZE(formats); i++) surfaces[i]->Release( surfaces[i] ); if (inspector->options & CREATE_FILES) { FILE *f; DFBGraphicsDeviceDescription desc; if (inspector->files.formats) fclose( inspector->files.formats ); /* Query device and driver information. */ inspector->dfb->GetDeviceDescription( inspector->dfb, &desc ); if (inspector->device_drawstring) desc.acceleration_mask = (DFBAccelerationMask)(desc.acceleration_mask | DFXL_DRAWSTRING); /* Write device info to a file. */ snprintf( buf, sizeof(buf), "%s/device.info", inspector->directory ); f = fopen( buf, "w" ); if (!f) { D_PERROR( "Inspector/Init: Could not open file '%s' for writing!\n", buf ); return DFB_FAILURE; } fprintf( f, "name = %s\n", desc.name ); fprintf( f, "vendor = %s\n", desc.vendor ); fprintf( f, "acceleration_mask = " ); for (i=0, n=0; accelerationmask_names[i].mask; i++) { if (desc.acceleration_mask & accelerationmask_names[i].mask) fprintf( f, "%s%s", n++ ? "," : "", accelerationmask_names[i].name ); } fprintf( f, "\n" ); fprintf( f, "blitting_flags = " ); for (i=0, n=0; blittingflags_names[i].flag; i++) { if (desc.blitting_flags & blittingflags_names[i].flag) fprintf( f, "%s%s", n++ ? "," : "", blittingflags_names[i].name ); } fprintf( f, "\n" ); fprintf( f, "drawing_flags = " ); for (i=0, n=0; drawingflags_names[i].flag; i++) { if (desc.drawing_flags & drawingflags_names[i].flag) fprintf( f, "%s%s", n++ ? "," : "", drawingflags_names[i].name ); } fprintf( f, "\n" ); fclose( f ); /* Write driver info to a file. */ snprintf( buf, sizeof(buf), "%s/driver.info", inspector->directory ); f = fopen( buf, "w" ); if (!f) { D_PERROR( "Inspector/Init: Could not open file '%s' for writing!\n", buf ); return DFB_FAILURE; } fprintf( f, "name = %s\n", desc.driver.name ); fprintf( f, "vendor = %s\n", desc.driver.vendor ); fprintf( f, "version = %d.%d\n", desc.driver.major, desc.driver.minor ); fclose( f ); } return DFB_OK; }
void GP2DEngine::validate_DEST_CLIP( GP2DTask *mytask, CardState *state ) { __u32 *prep = mytask->start( 18 ); D_DEBUG_AT( GP2D_Engine, "%s( %p [%d] - %4d,%4d-%4dx%4d )\n", __FUNCTION__, state->dst.handle, state->dst.pitch, DFB_RECTANGLE_VALS_FROM_REGION( &state->clip ) ); prep[0] = GP2D_OPCODE_WPR; prep[1] = 0x0d4; prep[2] = GP2D_XY( state->clip.x1, state->clip.y1 ) ; prep[3] = GP2D_OPCODE_WPR; prep[4] = 0x0d8; prep[5] = GP2D_XY( state->clip.x2, state->clip.y2) ; if (mytask->v_flags & DEST) { mytask->submit( 6 ); } else { CoreSurface *surface = state->destination; CoreSurfaceBuffer *buffer = state->dst.buffer; mytask->dst_phys = (unsigned long) state->dst.handle; mytask->dst_pitch = state->dst.pitch; mytask->dst_bpp = DFB_BYTES_PER_PIXEL( buffer->format ); mytask->dst_index = DFB_PIXELFORMAT_INDEX( buffer->format ) % DFB_NUM_PIXELFORMATS; mytask->rclr &= ~0x00140000; switch (buffer->format) { case DSPF_RGB16: mytask->rclr |= 0x00040000; break; case DSPF_ARGB1555: mytask->rclr |= 0x00140000; break; default: D_BUG("Unexpected pixelformat\n"); return; } /* Set destination start address. */ prep[ 6] = GP2D_OPCODE_WPR; prep[ 7] = 0x50; prep[ 8] = mytask->dst_phys; /* Set destination stride. */ prep[ 9] = GP2D_OPCODE_WPR; prep[10] = 0x5c; prep[11] = mytask->dst_pitch / mytask->dst_bpp; /* Set destination pixelformat in rendering control. */ prep[12] = GP2D_OPCODE_WPR; prep[13] = 0xc0; prep[14] = mytask->rclr; /* Set system clipping rectangle. */ prep[15] = GP2D_OPCODE_WPR; prep[16] = 0xd0; prep[17] = GP2D_XY( surface->config.size.w - 1, surface->config.size.h - 1 ); mytask->submit( 18 ); } /* Set the flags. */ GP2D_VALIDATE( DEST_CLIP ); }
static bool stretch_hvx( CardState *state, DFBRectangle *srect, DFBRectangle *drect ) { GenefxState *gfxs; const StretchFunctionTable *table; StretchHVx stretch; bool down = false; void *dst; void *src; StretchCtx ctx; int idx = STRETCH_NONE; u32 colors[256]; D_ASSERT( state != NULL ); DFB_RECTANGLE_ASSERT( srect ); DFB_RECTANGLE_ASSERT( drect ); gfxs = state->gfxs; if (srect->w > drect->w && srect->h > drect->h) down = true; if (down) { if (!(state->render_options & DSRO_SMOOTH_DOWNSCALE)) return false; } else { if (!(state->render_options & DSRO_SMOOTH_UPSCALE)) return false; } switch (gfxs->dst_format) { case DSPF_NV12: case DSPF_NV21: return stretch_hvx_planar( state, srect, drect, down ); default: break; } if (state->blittingflags & ~(DSBLIT_COLORKEY_PROTECT | DSBLIT_SRC_COLORKEY | DSBLIT_SRC_PREMULTIPLY)) return false; if (state->blittingflags & DSBLIT_SRC_PREMULTIPLY && !DFB_PIXELFORMAT_IS_INDEXED( gfxs->src_format )) return false; if (DFB_PIXELFORMAT_INDEX(gfxs->dst_format) >= D_ARRAY_SIZE(stretch_tables)) return false; if (DFB_PIXELFORMAT_INDEX(gfxs->src_format) >= D_ARRAY_SIZE((stretch_tables[0])->f)) return false; table = stretch_tables[DFB_PIXELFORMAT_INDEX(gfxs->dst_format)]; if (!table) return false; if (state->blittingflags & DSBLIT_SRC_COLORKEY) idx |= STRETCH_SRCKEY; if (state->blittingflags & DSBLIT_COLORKEY_PROTECT) idx |= STRETCH_PROTECT; if (down) stretch = table->f[DFB_PIXELFORMAT_INDEX(gfxs->src_format)].down[idx]; else stretch = table->f[DFB_PIXELFORMAT_INDEX(gfxs->src_format)].up[idx]; if (!stretch) return false; ctx.clip = state->clip; if (!dfb_region_rectangle_intersect( &ctx.clip, drect )) return false; dfb_region_translate( &ctx.clip, - drect->x, - drect->y ); if (DFB_PIXELFORMAT_IS_INDEXED( gfxs->src_format )) { int i; const DFBColor *entries; u16 *colors16 = (void*) colors; D_ASSERT( gfxs->Blut != NULL ); entries = gfxs->Blut->entries; switch (gfxs->dst_format) { case DSPF_ARGB: if (state->blittingflags & DSBLIT_SRC_PREMULTIPLY) { for (i=0; i<gfxs->Blut->num_entries; i++) { int alpha = entries[i].a + 1; switch (alpha) { case 0: colors[i] = 0; break; case 255: colors[i] = PIXEL_ARGB( entries[i].a, entries[i].r, entries[i].g, entries[i].b ); break; default: colors[i] = PIXEL_ARGB( entries[i].a, (alpha * entries[i].r) >> 8, (alpha * entries[i].g) >> 8, (alpha * entries[i].b) >> 8 ); } } } else { for (i=0; i<gfxs->Blut->num_entries; i++) colors[i] = PIXEL_ARGB( entries[i].a, entries[i].r, entries[i].g, entries[i].b ); } break; case DSPF_RGB32: for (i=0; i<gfxs->Blut->num_entries; i++) colors[i] = PIXEL_RGB32( entries[i].r, entries[i].g, entries[i].b ); break; case DSPF_RGB16: for (i=0; i<gfxs->Blut->num_entries; i++) colors16[i] = PIXEL_RGB16( entries[i].r, entries[i].g, entries[i].b ); break; case DSPF_ARGB4444: if (state->blittingflags & DSBLIT_SRC_PREMULTIPLY) { for (i=0; i<gfxs->Blut->num_entries; i++) { int alpha = entries[i].a + 1; switch (alpha) { case 0: colors16[i] = 0; break; case 255: colors16[i] = PIXEL_ARGB4444( entries[i].a, entries[i].r, entries[i].g, entries[i].b ); break; default: colors16[i] = PIXEL_ARGB4444( entries[i].a, (alpha * entries[i].r) >> 8, (alpha * entries[i].g) >> 8, (alpha * entries[i].b) >> 8 ); } } } else { for (i=0; i<gfxs->Blut->num_entries; i++)
DFBResult dfb_x11_image_init_handler( DFBX11 *x11, x11Image *image ) { Visual *visual; XImage *ximage; D_MAGIC_ASSERT( image, x11Image ); if (!x11->use_shm) return DFB_UNSUPPORTED; /* Lookup visual. */ visual = x11->visuals[DFB_PIXELFORMAT_INDEX(image->format)]; if (!visual) return DFB_UNSUPPORTED; image->visual = visual; XLockDisplay( x11->display ); ximage = XShmCreateImage( x11->display, image->visual, image->depth, ZPixmap, NULL, &image->seginfo, image->width, image->height ); if (!ximage) { D_ERROR( "X11/ShmImage: Error creating shared image (XShmCreateImage)!\n"); XUnlockDisplay( x11->display ); return DFB_FAILURE; } /* we firstly create our shared memory segment with the size we need, and correct permissions for the owner, the group and the world --> 0777 */ image->seginfo.shmid = shmget( IPC_PRIVATE, ximage->bytes_per_line * ximage->height, IPC_CREAT | 0777 ); if (image->seginfo.shmid < 0) goto error; /* Then, we have to attach the segment to our process, and we let the function search the correct memory place --> NULL. It's safest ! */ image->seginfo.shmaddr = shmat( image->seginfo.shmid, NULL, 0 ); if (!image->seginfo.shmaddr) goto error_shmat; ximage->data = image->seginfo.shmaddr; /* We set the buffer in Read and Write mode */ image->seginfo.readOnly = False; if (!XShmAttach( x11->display, &image->seginfo )) goto error_xshmattach; image->ximage = ximage; image->pitch = ximage->bytes_per_line; image->pixmap = XShmCreatePixmap( x11->display, DefaultRootWindow(x11->display), ximage->data, &image->seginfo, image->width, image->height, image->depth ); image->gc = XCreateGC( x11->display, image->pixmap, 0, NULL ); XUnlockDisplay( x11->display ); return DFB_OK; error_xshmattach: shmdt( image->seginfo.shmaddr ); error_shmat: shmctl( image->seginfo.shmid, IPC_RMID, NULL ); error: XDestroyImage( ximage ); XUnlockDisplay( x11->display ); return DFB_FAILURE; }
static DFBResult x11AllocateKey( CoreSurfacePool *pool, void *pool_data, void *pool_local, CoreSurfaceBuffer *buffer, const char *key, u64 handle, CoreSurfaceAllocation *allocation, void *alloc_data ) { CoreSurface *surface; x11AllocationData *alloc = alloc_data; x11PoolLocalData *local = pool_local; DFBX11 *x11 = local->x11; D_DEBUG_AT( X11_Surfaces, "%s( %s, 0x%08llx )\n", __FUNCTION__, key, (unsigned long long) handle ); D_DEBUG_AT( X11_Surfaces, " -> allocation: %s\n", ToString_CoreSurfaceAllocation( allocation ) ); D_MAGIC_ASSERT( pool, CoreSurfacePool ); D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer ); surface = buffer->surface; D_MAGIC_ASSERT( surface, CoreSurface ); if (!strcmp( key, "Pixmap/X11" )) { D_DEBUG_AT( X11_Surfaces, " -> Pixmap/X11\n" ); alloc->type = X11_ALLOC_PIXMAP; } else if (!strcmp( key, "Window/X11" )) { D_DEBUG_AT( X11_Surfaces, " -> Window/X11\n" ); alloc->type = X11_ALLOC_WINDOW; } else { D_BUG( "unexpected key '%s'", key ); return DFB_BUG; } dfb_surface_calc_buffer_size( surface, 8, 8, &alloc->pitch, &allocation->size ); // alloc->depth = DefaultDepthOfScreen( x11->screenptr ); // alloc->visual = DefaultVisualOfScreen( x11->screenptr ); alloc->visual = x11->visuals[DFB_PIXELFORMAT_INDEX(buffer->format)]; alloc->depth = DFB_COLOR_BITS_PER_PIXEL( buffer->format ) + DFB_ALPHA_BITS_PER_PIXEL( buffer->format ); if (alloc->depth == DefaultDepthOfScreen( x11->screenptr )) alloc->visual = DefaultVisualOfScreen( x11->screenptr ); D_DEBUG_AT( X11_Surfaces, " -> visual %p (id %lu), depth %d\n", alloc->visual, alloc->visual->visualid, alloc->depth ); if (handle) { switch (alloc->type) { case X11_ALLOC_PIXMAP: XLockDisplay( x11->display ); alloc->xid = (unsigned long) handle; x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> pixmap 0x%08lx\n", (long) alloc->xid ); XUnlockDisplay( x11->display ); D_INFO( "X11/Windows: Import Pixmap 0x%08lx\n", alloc->xid ); break; case X11_ALLOC_WINDOW: { XLockDisplay( x11->display ); alloc->window = (unsigned long) handle; x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> window 0x%08lx\n", (long) alloc->window ); XCompositeRedirectWindow( x11->display, alloc->window, CompositeRedirectManual ); x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> redirected\n" ); alloc->xid = XCompositeNameWindowPixmap( x11->display, alloc->window ); // alloc->xid = alloc->window; x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> pixmap 0x%08lx\n", (long) alloc->xid ); XUnmapWindow( x11->display, alloc->window ); x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> unmapped\n" ); XUnlockDisplay( x11->display ); D_INFO( "X11/Windows: Import Window 0x%08lx with Pixmap handle 0x%08lx\n", alloc->window, alloc->xid ); break; } default: D_BUG( "unexpected allocation type %d\n", alloc->type ); return DFB_BUG; } } else { // alloc->type = X11_ALLOC_PIXMAP; switch (alloc->type) { case X11_ALLOC_PIXMAP: XLockDisplay( x11->display ); x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> creating pixmap...\n" ); alloc->xid = XCreatePixmap( x11->display, DefaultRootWindow(x11->display), allocation->config.size.w, allocation->config.size.h, alloc->depth ); x11->Sync( x11 ); XSync( x11->display, False ); D_DEBUG_AT( X11_Surfaces, " -> pixmap 0x%08lx\n", (long) alloc->xid ); XUnlockDisplay( x11->display ); D_INFO( "X11/Windows: New Pixmap 0x%08lx\n", alloc->xid ); alloc->created = true; break; case X11_ALLOC_WINDOW: { Window w = (Window) (long) buffer->surface->data; XSetWindowAttributes attr; attr.event_mask = ButtonPressMask | ButtonReleaseMask | PointerMotionMask | KeyPressMask | KeyReleaseMask | ExposureMask | StructureNotifyMask; attr.background_pixmap = 0; XLockDisplay( x11->display ); x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> creating window...\n" ); alloc->window = w?:XCreateWindow( x11->display, DefaultRootWindow(x11->display), 600, 200, allocation->config.size.w, allocation->config.size.h, 0, alloc->depth, InputOutput, alloc->visual, CWEventMask, &attr ); x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> window 0x%08lx\n", (long) alloc->window ); buffer->surface->data = (void*) (long) alloc->window; XMapRaised( x11->display, alloc->window ); x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> raised\n" ); XCompositeRedirectWindow( x11->display, alloc->window, CompositeRedirectManual ); x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> redirected\n" ); alloc->xid = XCompositeNameWindowPixmap( x11->display, alloc->window ); // alloc->xid = alloc->window; x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> pixmap 0x%08lx\n", (long) alloc->xid ); XUnmapWindow( x11->display, alloc->window ); x11->Sync( x11 ); D_DEBUG_AT( X11_Surfaces, " -> unmapped\n" ); XUnlockDisplay( x11->display ); D_INFO( "X11/Windows: New Window 0x%08lx with Pixmap handle 0x%08lx\n", alloc->window, alloc->xid ); alloc->created = !w; break; } default: D_BUG( "unexpected allocation type %d\n", alloc->type ); return DFB_BUG; } } alloc->gc = XCreateGC( x11->display, alloc->xid, 0, NULL ); allocation->offset = alloc->type; return DFB_OK; }
/* * Blit a glyph with alpha blending and colorizing using the current hardware state. */ static bool pxa3xxBlitGlyph( void *drv, void *dev, DFBRectangle *rect, int x, int y ) { PXA3XXDriverData *pdrv = drv; PXA3XXDeviceData *pdev = dev; u32 *prep = start_buffer( pdrv, 40 ); const u32 format = pixel_formats[DFB_PIXELFORMAT_INDEX( DSPF_ARGB )]; D_DEBUG_AT( PXA3XX_BLT, "%s( %d, %d - %dx%d )\n", __FUNCTION__, DFB_RECTANGLE_VALS( rect ) ); DUMP_INFO(); if (rect->w * (rect->h + 1) * 4 > pdev->fake_size) return false; /* Set fake destination. */ prep[0] = 0x020000A2; prep[1] = pdev->fake_phys; prep[2] = (format << 19) | ((rect->w << 2) << 5) | 4; /* Fill first row of fake buffer. */ prep[3] = 0x40000014 | (format << 8); prep[4] = 0; prep[5] = 0; prep[6] = PXA3XX_WH( rect->w, 1 ); prep[7] = PIXEL_ARGB( pdev->color.a, pdev->color.r, pdev->color.g, pdev->color.b ); /* Set first row of fake buffer as source1. */ prep[8] = 0x02000012; prep[9] = pdev->fake_phys; prep[10] = (format << 19) | 4; /* Blit with blending. */ prep[11] = 0x47000118; prep[12] = 0; prep[13] = 1; prep[14] = rect->x; prep[15] = rect->y; prep[16] = 0; prep[17] = 0; prep[18] = PXA3XX_WH( rect->w, rect->h ); prep[19] = 0; /* Restore destination. */ prep[20] = 0x020000A2; prep[21] = pdev->dst_phys; prep[22] = (pixel_formats[pdev->dst_index] << 19) | (pdev->dst_pitch << 5) | pdev->dst_bpp; /* Restore source1 to destination. */ prep[23] = 0x02000012; prep[24] = prep[21]; prep[25] = prep[22]; /* Set fake buffer as source0. */ prep[26] = 0x02000002; prep[27] = pdev->fake_phys; prep[28] = (format << 19) | ((rect->w << 2) << 5) | 4; /* Blit with blending. */ prep[29] = 0x47000107; prep[30] = x; prep[31] = y; prep[32] = 0; prep[33] = 1; prep[34] = x; prep[35] = y; prep[36] = PXA3XX_WH( rect->w, rect->h ); /* Restore source0. */ prep[37] = 0x02000002; prep[38] = pdev->src_phys; prep[39] = (pixel_formats[pdev->src_index] << 19) | (pdev->src_pitch << 5) | pdev->src_bpp; submit_buffer( pdrv, 40 ); return true; }
static DFBResult system_initialize( CoreDFB *core, void **data ) { int i, n; CoreScreen *screen; D_ASSERT( dfb_x11 == NULL ); dfb_x11 = (DFBX11*) SHCALLOC( dfb_core_shmpool(core), 1, sizeof(DFBX11) ); if (!dfb_x11) { D_ERROR( "DirectFB/X11: Couldn't allocate shared memory!\n" ); return D_OOSHM(); } dfb_x11_core = core; fusion_skirmish_init( &dfb_x11->lock, "X11 System", dfb_core_world(core) ); fusion_call_init( &dfb_x11->call, call_handler, NULL, dfb_core_world(core) ); dfb_surface_pool_initialize( core, &x11SurfacePoolFuncs, &dfb_x11->surface_pool ); screen = dfb_screens_register( NULL, NULL, &x11PrimaryScreenFuncs ); dfb_layers_register( screen, NULL, &x11PrimaryLayerFuncs ); fusion_arena_add_shared_field( dfb_core_arena( core ), "x11", dfb_x11 ); *data = dfb_x11; XInitThreads(); dfb_x11->data_shmpool = dfb_core_shmpool_data( core ); dfb_x11->display = XOpenDisplay(getenv("DISPLAY")); if (!dfb_x11->display) { D_ERROR("X11: Error in XOpenDisplay for '%s'\n", getenv("DISPLAY")); return DFB_INIT; } dfb_x11->screenptr = DefaultScreenOfDisplay(dfb_x11->display); dfb_x11->screennum = DefaultScreen(dfb_x11->display); for (i=0; i<dfb_x11->screenptr->ndepths; i++) { const Depth *depth = &dfb_x11->screenptr->depths[i]; for (n=0; n<depth->nvisuals; n++) { Visual *visual = &depth->visuals[n]; D_DEBUG( "X11/Visual: ID %02lu, depth %d, red 0x%06lx, green 0x%06lx, blue 0x%06lx, %d bits/rgb, %d entries\n", visual->visualid, depth->depth, visual->red_mask, visual->green_mask, visual->blue_mask, visual->bits_per_rgb, visual->map_entries ); switch (depth->depth) { case 24: if (visual->red_mask == 0xff0000 && visual->green_mask == 0x00ff00 && visual->blue_mask == 0x0000ff) { dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual; dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)] = visual; } break; case 16: if (visual->red_mask == 0xf800 && visual->green_mask == 0x07e0 && visual->blue_mask == 0x001f) dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)] = visual; break; case 15: if (visual->red_mask == 0x7c00 && visual->green_mask == 0x03e0 && visual->blue_mask == 0x001f) dfb_x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)] = visual; break; } } } return DFB_OK; }
static DFBResult InitLocal( DFBX11 *x11, DFBX11Shared *shared, CoreDFB *core ) { int i, n, d; XInitThreads(); x11->shared = shared; x11->core = core; x11->display = XOpenDisplay(getenv("DISPLAY")); if (!x11->display) { D_ERROR("X11: Error in XOpenDisplay for '%s'\n", getenv("DISPLAY")); return DFB_INIT; } x11->screenptr = DefaultScreenOfDisplay(x11->display); x11->screennum = DefaultScreen(x11->display); d = DefaultDepthOfScreen(x11->screenptr); for (i=0; i<x11->screenptr->ndepths; i++) { const Depth *depth = &x11->screenptr->depths[i]; for (n=0; n<depth->nvisuals; n++) { Visual *visual = &depth->visuals[n]; D_DEBUG_AT( X11_Core, "[Visual %d] ID 0x%02lx, depth %d, RGB 0x%06lx/0x%06lx/0x%06lx, %d bpRGB, %d entr.\n", n, visual->visualid, depth->depth, visual->red_mask, visual->green_mask, visual->blue_mask, visual->bits_per_rgb, visual->map_entries ); if (depth->depth != d) continue; switch (depth->depth) { case 32: if (visual->red_mask == 0xff0000 && visual->green_mask == 0x00ff00 && visual->blue_mask == 0x0000ff && !x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)]) x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)] = visual; break; case 24: if (visual->red_mask == 0xff0000 && visual->green_mask == 0x00ff00 && visual->blue_mask == 0x0000ff && !x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)]) x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual; break; case 16: if (visual->red_mask == 0xf800 && visual->green_mask == 0x07e0 && visual->blue_mask == 0x001f && !x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)]) x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)] = visual; break; case 15: if (visual->red_mask == 0x7c00 && visual->green_mask == 0x03e0 && visual->blue_mask == 0x001f && !x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)]) x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)] = visual; break; } } } if (XShmQueryExtension( x11->display )) XShmQueryVersion( x11->display, &x11->xshm_major, &x11->xshm_minor, &x11->use_shm ); x11->screen = dfb_screens_register( NULL, x11, x11PrimaryScreenFuncs ); dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs ); dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs ); dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs ); return DFB_OK; }
static DFBResult InitLocal( DFBX11 *x11, DFBX11Shared *shared, CoreDFB *core ) { int i, n; XInitThreads(); if (direct_config_get_int_value( "x11-sync" )) x11->Sync = sync_display; else x11->Sync = sync_display_noop; x11->shared = shared; x11->core = core; x11->display = XOpenDisplay(getenv("DISPLAY")); if (!x11->display) { D_ERROR("X11: Error in XOpenDisplay for '%s'\n", getenv("DISPLAY")); return DFB_INIT; } x11->screenptr = DefaultScreenOfDisplay(x11->display); x11->screennum = DefaultScreen(x11->display); D_DEBUG_AT( X11_Core, " -> ndepths %d\n", x11->screenptr->ndepths); for (i=0; i<x11->screenptr->ndepths; i++) { const Depth *depth = &x11->screenptr->depths[i]; D_DEBUG_AT( X11_Core, " -> [%d] depth %d, nvisuals %d\n", i, depth->depth, depth->nvisuals ); for (n=0; n<depth->nvisuals; n++) { Visual *visual = &depth->visuals[n]; D_DEBUG_AT( X11_Core, "[Visual %d] ID 0x%02lx, depth %d, RGB 0x%06lx/0x%06lx/0x%06lx, %d bpRGB, %d entr.\n", n, visual->visualid, depth->depth, visual->red_mask, visual->green_mask, visual->blue_mask, visual->bits_per_rgb, visual->map_entries ); //if (depth->depth != d) // continue; //if (visual->visualid == 0x24) { // x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual; // continue; //} switch (depth->depth) { case 32: if (visual->red_mask == 0xff0000 && visual->green_mask == 0x00ff00 && visual->blue_mask == 0x0000ff && !x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)]) x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)] = visual; break; case 24: if (visual->red_mask == 0xff0000 && visual->green_mask == 0x00ff00 && visual->blue_mask == 0x0000ff && !x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)]) x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual; break; case 16: if (visual->red_mask == 0xf800 && visual->green_mask == 0x07e0 && visual->blue_mask == 0x001f && !x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)]) x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)] = visual; break; case 15: if (visual->red_mask == 0x7c00 && visual->green_mask == 0x03e0 && visual->blue_mask == 0x001f && !x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)]) x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)] = visual; break; } } } DFBSurfacePixelFormat formats[] = { DSPF_ARGB, DSPF_RGB32, DSPF_RGB16, DSPF_RGB555 }; for (i=0; i<D_ARRAY_SIZE(formats); i++) { Visual *visual = x11->visuals[DFB_PIXELFORMAT_INDEX(formats[i])]; if (visual) { D_DEBUG_AT( X11_Core, " %-20s [Visual ID 0x%02lx] RGB 0x%06lx/0x%06lx/0x%06lx, %d bpRGB, %d entr.\n", dfb_pixelformat_name(formats[i]), visual->visualid, visual->red_mask, visual->green_mask, visual->blue_mask, visual->bits_per_rgb, visual->map_entries ); } else D_DEBUG_AT( X11_Core, " %-20s [NO VISUAL]\n", dfb_pixelformat_name(formats[i]) ); } if (XShmQueryExtension( x11->display )) XShmQueryVersion( x11->display, &x11->xshm_major, &x11->xshm_minor, &x11->use_shm ); x11->use_shm = 0; x11->screen = dfb_screens_register( NULL, x11, x11PrimaryScreenFuncs ); for (i=0; i<shared->outputs * shared->layers; i++) { if (!dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs )) return DFB_INIT; } return DFB_OK; }