static int
TextureHasAlpha(DirectFB_TextureData * data)
{
/* Drawing primitive ? */
if (!data)
return 0;
return (DFB_PIXELFORMAT_HAS_ALPHA(DirectFB_SDLToDFBPixelFormat(data->format)) ? 1 : 0);
#if 0
switch (data->format) {
case SDL_PIXELFORMAT_INDEX4LSB:
case SDL_PIXELFORMAT_INDEX4MSB:
case SDL_PIXELFORMAT_ARGB4444:
case SDL_PIXELFORMAT_ARGB1555:
case SDL_PIXELFORMAT_ARGB8888:
case SDL_PIXELFORMAT_RGBA8888:
case SDL_PIXELFORMAT_ABGR8888:
case SDL_PIXELFORMAT_BGRA8888:
case SDL_PIXELFORMAT_ARGB2101010:
return 1;
default:
return 0;
}
#endif
}
static DFBResult
IDirectFBImageProvider_ANDROID_GetSurfaceDescription( IDirectFBImageProvider *thiz,
DFBSurfaceDescription *desc )
{
DFBResult ret;
DFBSurfacePixelFormat primary_format = dfb_primary_layer_pixelformat();
DIRECT_INTERFACE_GET_DATA (IDirectFBImageProvider_ANDROID)
if (!desc)
return DFB_INVARG;
ret = decodeImage( data );
if (ret)
return ret;
desc->flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;
if (data->alpha)
desc->pixelformat = DFB_PIXELFORMAT_HAS_ALPHA(primary_format) ? primary_format : DSPF_ARGB;
//desc->pixelformat = DSPF_ABGR;
else
desc->pixelformat = primary_format;
desc->width = data->width;
desc->height = data->height;
D_DEBUG_AT( imageProviderANDROID, "GetSurfaceDescription: width=%d height=%d pitch=%d has_alpha=%d pixelformat=%s/%s\n",
data->width, data->height, data->pitch, data->alpha, dfb_pixelformat_name(data->format), dfb_pixelformat_name(desc->pixelformat) );
return DFB_OK;
}
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
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;
}
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 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");
}
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 );
}
/// Map DFBSurfaceBlittingFlags to the hardware
inline void
uc_map_blitflags( struct uc_hw_texture *tex,
DFBSurfaceBlittingFlags bflags,
DFBSurfacePixelFormat sformat,
DFBSurfacePixelFormat dformat )
{
bool gotalpha = DFB_PIXELFORMAT_HAS_ALPHA(sformat);
bool invalpha = DFB_PIXELFORMAT_INV_ALPHA(sformat) ||
(!DFB_PIXELFORMAT_INV_ALPHA(sformat) && DFB_PIXELFORMAT_INV_ALPHA(dformat));
if (bflags & DSBLIT_COLORIZE) {
// Cv0 = Ct*Cf
// Hw setting:
// Ca = Ct, Cb = Cf, Cop = +, Cc = 0, Cbias = 0, Cshift = No.
tex->regHTXnTBLCsat_0 = HC_HTXnTBLCsat_MASK |
HC_HTXnTBLCa_TOPC | HC_HTXnTBLCa_Tex |
HC_HTXnTBLCb_TOPC | HC_HTXnTBLCb_Dif |
HC_HTXnTBLCc_TOPC | HC_HTXnTBLCc_0;
tex->regHTXnTBLCop_0 = HC_HTXnTBLCop_Add |
HC_HTXnTBLCbias_Cbias | HC_HTXnTBLCbias_0 |
HC_HTXnTBLCshift_No;
tex->regHTXnTBLMPfog_0 = HC_HTXnTBLMPfog_0;
}
else {
// Cv0 = Ct
// Hw setting:
// Ca = 0, Cb = 0, Cop = +, Cc = 0, Cbias = Ct, Cshift = No.
tex->regHTXnTBLCsat_0 = HC_HTXnTBLCsat_MASK |
HC_HTXnTBLCa_TOPC | HC_HTXnTBLCa_0 |
HC_HTXnTBLCb_TOPC | HC_HTXnTBLCb_0 |
HC_HTXnTBLCc_TOPC | HC_HTXnTBLCc_0;
tex->regHTXnTBLCop_0 = HC_HTXnTBLCop_Add |
HC_HTXnTBLCbias_Cbias | HC_HTXnTBLCbias_Tex |
HC_HTXnTBLCshift_No;
tex->regHTXnTBLMPfog_0 = HC_HTXnTBLMPfog_0;
}
if (bflags & DSBLIT_BLEND_COLORALPHA) {
if ((bflags & DSBLIT_BLEND_ALPHACHANNEL) && gotalpha) {
// Av0 = At*Af
// Hw setting:
// Aa = At, Ab = Af, Cop = +, Ac = 0, Abias = 0, Ashift = No.
tex->regHTXnTBLAsat_0 = HC_HTXnTBLAsat_MASK |
HC_HTXnTBLAa_TOPA | HC_HTXnTBLAa_Atex |
HC_HTXnTBLAb_TOPA | HC_HTXnTBLAb_Adif |
HC_HTXnTBLAc_TOPA | HC_HTXnTBLAc_HTXnTBLRA;
tex->regHTXnTBLCop_0 |= HC_HTXnTBLAop_Add |
HC_HTXnTBLAbias_HTXnTBLRAbias | HC_HTXnTBLAshift_No;
tex->regHTXnTBLRAa_0 = 0x0;
tex->regHTXnTBLRFog_0 = 0x0;
}
else {
// (!(bflags & DSBLIT_BLEND_ALPHACHANNEL) && gotalpha) || !gotalpha
// Av0 = Af
// Hw setting:
// Aa = 0, Ab = 0, Cop = +, Ac = 0, Abias = Af, Ashift = No.
tex->regHTXnTBLAsat_0 = HC_HTXnTBLAsat_MASK |
HC_HTXnTBLAa_TOPA | HC_HTXnTBLAa_HTXnTBLRA |
HC_HTXnTBLAb_TOPA | HC_HTXnTBLAb_HTXnTBLRA |
HC_HTXnTBLAc_TOPA | HC_HTXnTBLAc_HTXnTBLRA;
tex->regHTXnTBLCop_0 |= HC_HTXnTBLAop_Add |
HC_HTXnTBLAbias_Adif | HC_HTXnTBLAshift_No;
tex->regHTXnTBLRAa_0 = 0x0;
tex->regHTXnTBLRFog_0 = 0x0;
}
}
else { // !(bflags & DSBLIT_BLEND_COLORALPHA)
if (gotalpha && ((bflags & DSBLIT_BLEND_ALPHACHANNEL) || invalpha)) {
// Av0 = At
// Hw setting:
// Aa = 0, Ab = 0, Cop = +, Ac = 0, Abias = At, Ashift = No.
tex->regHTXnTBLAsat_0 = HC_HTXnTBLAsat_MASK |
HC_HTXnTBLAa_TOPA | HC_HTXnTBLAa_HTXnTBLRA |
HC_HTXnTBLAb_TOPA | HC_HTXnTBLAb_HTXnTBLRA |
HC_HTXnTBLAc_TOPA | HC_HTXnTBLAc_HTXnTBLRA;
tex->regHTXnTBLCop_0 |= HC_HTXnTBLAop_Add |
HC_HTXnTBLAbias_Atex | HC_HTXnTBLAshift_No;
if (invalpha)
tex->regHTXnTBLCop_0 |= HC_HTXnTBLAbias_Inv;
tex->regHTXnTBLRAa_0 = 0x0;
tex->regHTXnTBLRFog_0 = 0x0;
}
else { // !gotalpha
// Av0 = 1.0
// D_BUG warning: I'm guessing where values should go,
// and how big (0xff = 1.0 ?) it should be.
// Hw setting:
// Aa = 1.0, Ab = 1.0, Cop = -, Ac = 1.0, Abias = 1.0, Ashift = No.
// => Av = Aa*(Ab-Ac) + Abias = 1*(1-1)+1 = 1
tex->regHTXnTBLAsat_0 = HC_HTXnTBLAsat_MASK |
HC_HTXnTBLAa_TOPA | HC_HTXnTBLAa_HTXnTBLRA |
HC_HTXnTBLAb_TOPA | HC_HTXnTBLAb_HTXnTBLRA |
HC_HTXnTBLAc_TOPA | HC_HTXnTBLAc_HTXnTBLRA;
tex->regHTXnTBLCop_0 |= HC_HTXnTBLAop_Add |
HC_HTXnTBLAbias_Inv | HC_HTXnTBLAbias_HTXnTBLRAbias | HC_HTXnTBLAshift_No;
tex->regHTXnTBLRAa_0 = 0x0;
tex->regHTXnTBLRFog_0 = 0x0;
}
}
}
/// Map DirectFB blending functions to hardware
inline void
uc_map_blending_fn( struct uc_hw_alpha *hwalpha,
DFBSurfaceBlendFunction sblend,
DFBSurfaceBlendFunction dblend,
DFBSurfacePixelFormat dst_format )
{
bool dst_alpha = DFB_PIXELFORMAT_HAS_ALPHA(dst_format);
// The HW's blending equation is:
// (Ca * FCa + Cbias + Cb * FCb) << Cshift
// Set source blending function
// Ca -- always from source color.
hwalpha->regHABLCsat = HC_HABLCsat_MASK | HC_HABLCa_OPC | HC_HABLCa_Csrc;
// Aa -- always from source alpha.
hwalpha->regHABLAsat = HC_HABLAsat_MASK | HC_HABLAa_OPA | HC_HABLAa_Asrc;
// FCa and FAa depend on the following condition.
switch (sblend) {
case DSBF_ZERO:
// GL_ZERO -- (0, 0, 0, 0)
hwalpha->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
hwalpha->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_HABLFRA;
hwalpha->regHABLRFCa = 0x0;
hwalpha->regHABLRAa = 0x0;
break;
case DSBF_ONE:
// GL_ONE -- (1, 1, 1, 1)
hwalpha->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_HABLRCa;
hwalpha->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
hwalpha->regHABLRFCa = 0x0;
hwalpha->regHABLRAa = 0x0;
break;
case DSBF_SRCCOLOR:
// GL_SRC_COLOR -- (Rs, Gs, Bs, As)
hwalpha->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Csrc;
hwalpha->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Asrc;
break;
case DSBF_INVSRCCOLOR:
// GL_ONE_MINUS_SRC_COLOR -- (1, 1, 1, 1) - (Rs, Gs, Bs, As)
hwalpha->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Csrc;
hwalpha->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Asrc;
break;
case DSBF_SRCALPHA:
// GL_SRC_ALPHA -- (As, As, As, As)
hwalpha->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Asrc;
hwalpha->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Asrc;
break;
case DSBF_INVSRCALPHA:
// GL_ONE_MINUS_SRC_ALPHA -- (1, 1, 1, 1) - (As, As, As, As)
hwalpha->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Asrc;
hwalpha->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Asrc;
break;
case DSBF_DESTALPHA:
// GL_DST_ALPHA
if (!dst_alpha) { // (1, 1, 1, 1)
hwalpha->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_HABLRCa;
hwalpha->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
hwalpha->regHABLRFCa = 0x0;
hwalpha->regHABLRAa = 0x0;
}
else { // (Ad, Ad, Ad, Ad)
hwalpha->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Adst;
hwalpha->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Adst;
}
break;
case DSBF_INVDESTALPHA:
// GL_ONE_MINUS_DST_ALPHA
if (!dst_alpha) { // (1, 1, 1, 1) - (1, 1, 1, 1) = (0, 0, 0, 0)
hwalpha->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
hwalpha->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_HABLFRA;
hwalpha->regHABLRFCa = 0x0;
hwalpha->regHABLRAa = 0x0;
}
else { // (1, 1, 1, 1) - (Ad, Ad, Ad, Ad)
hwalpha->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Adst;
hwalpha->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Adst;
}
break;
case DSBF_DESTCOLOR:
// GL_DST_COLOR -- (Rd, Gd, Bd, Ad)
hwalpha->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Cdst;
hwalpha->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Adst;
break;
case DSBF_INVDESTCOLOR:
// GL_ONE_MINUS_DST_COLOR -- (1, 1, 1, 1) - (Rd, Gd, Bd, Ad)
hwalpha->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Cdst;
hwalpha->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Adst;
break;
case DSBF_SRCALPHASAT:
// GL_SRC_ALPHA_SATURATE
if (!dst_alpha) {
// (f, f, f, 1), f = min(As, 1 - Ad) = min(As, 1 - 1) = 0
// So (f, f, f, 1) = (0, 0, 0, 1)
hwalpha->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
hwalpha->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
hwalpha->regHABLRFCa = 0x0;
hwalpha->regHABLRAa = 0x0;
}
else {
// (f, f, f, 1), f = min(As, 1 - Ad)
hwalpha->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_mimAsrcInvAdst;
hwalpha->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
hwalpha->regHABLRFCa = 0x0;
hwalpha->regHABLRAa = 0x0;
}
break;
}
// Set destination blending function
// Op is add.
// bias is 0.
hwalpha->regHABLCsat |= HC_HABLCbias_HABLRCbias;
hwalpha->regHABLAsat |= HC_HABLAbias_HABLRAbias;
// Cb -- always from destination color.
hwalpha->regHABLCop = HC_HABLCb_OPC | HC_HABLCb_Cdst;
// Ab -- always from destination alpha.
hwalpha->regHABLAop = HC_HABLAb_OPA | HC_HABLAb_Adst;
// FCb -- depends on the following condition.
switch (dblend) {
case DSBF_ZERO:
// GL_ZERO -- (0, 0, 0, 0)
hwalpha->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_HABLRCb;
hwalpha->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_HABLFRA;
hwalpha->regHABLRFCb = 0x0;
hwalpha->regHABLRAb = 0x0;
break;
case DSBF_ONE:
// GL_ONE -- (1, 1, 1, 1)
hwalpha->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_HABLRCb;
hwalpha->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_HABLFRA;
hwalpha->regHABLRFCb = 0x0;
hwalpha->regHABLRAb = 0x0;
break;
case DSBF_SRCCOLOR:
// GL_SRC_COLOR -- (Rs, Gs, Bs, As)
hwalpha->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Csrc;
hwalpha->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Asrc;
break;
case DSBF_INVSRCCOLOR:
// GL_ONE_MINUS_SRC_COLOR -- (1, 1, 1, 1) - (Rs, Gs, Bs, As)
hwalpha->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Csrc;
hwalpha->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Asrc;
break;
case DSBF_SRCALPHA:
// GL_SRC_ALPHA -- (As, As, As, As)
hwalpha->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Asrc;
hwalpha->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Asrc;
break;
case DSBF_INVSRCALPHA:
// GL_ONE_MINUS_SRC_ALPHA -- (1, 1, 1, 1) - (As, As, As, As)
hwalpha->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Asrc;
hwalpha->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_0;
break;
case DSBF_DESTALPHA:
// GL_DST_ALPHA
if (!dst_alpha) { // (1, 1, 1, 1)
hwalpha->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_HABLRCb;
hwalpha->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_HABLFRA;
hwalpha->regHABLRFCb = 0x0;
hwalpha->regHABLRAb = 0x0;
}
else { // (Ad, Ad, Ad, Ad)
hwalpha->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Adst;
hwalpha->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Adst;
}
break;
case DSBF_INVDESTALPHA:
// GL_ONE_MINUS_DST_ALPHA
if (!dst_alpha) { // (1, 1, 1, 1) - (1, 1, 1, 1) = (0, 0, 0, 0)
hwalpha->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_HABLRCb;
hwalpha->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_HABLFRA;
hwalpha->regHABLRFCb = 0x0;
hwalpha->regHABLRAb = 0x0;
}
else { // (1, 1, 1, 1) - (Ad, Ad, Ad, Ad)
hwalpha->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Adst;
hwalpha->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Adst;
}
break;
case DSBF_DESTCOLOR:
// GL_DST_COLOR -- (Rd, Gd, Bd, Ad)
hwalpha->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Cdst;
hwalpha->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Adst;
break;
case DSBF_INVDESTCOLOR:
// GL_ONE_MINUS_DST_COLOR -- (1, 1, 1, 1) - (Rd, Gd, Bd, Ad)
hwalpha->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Cdst;
hwalpha->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Adst;
break;
case DSBF_SRCALPHASAT:
// Unsupported?
default:
hwalpha->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_HABLRCb;
hwalpha->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_HABLFRA;
hwalpha->regHABLRFCb = 0x0;
hwalpha->regHABLRAb = 0x0;
break;
}
}
static DFBResult
sh7722SetRegion( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreLayerRegionConfig *config,
CoreLayerRegionConfigFlags updated,
CoreSurface *surface,
CorePalette *palette,
CoreSurfaceBufferLock *left_lock,
CoreSurfaceBufferLock *right_lock )
{
int n;
SH7722DriverData *sdrv = driver_data;
SH7722DeviceData *sdev = sdrv->dev;
SH7722RegionData *sreg = region_data;
SH7722LayerData *slay = layer_data;
D_DEBUG_AT( SH7722_Layer, "%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( sreg, SH7722RegionData );
n = slay->layer - SH7722_LAYER_INPUT1;
D_ASSERT( n >= 0 );
D_ASSERT( n <= 2 );
fusion_skirmish_prevail( &sdev->beu_lock );
/* Update position? */
if (updated & CLRCF_DEST) {
/* libshbeu: Set horizontal and vertical offset. */
sdev->shbeu_src[n].x = config->dest.x;
sdev->shbeu_src[n].y = config->dest.y;
}
/* Update size? */
if (updated & (CLRCF_WIDTH | CLRCF_HEIGHT)) {
int cw = config->width;
int ch = config->height;
if (config->dest.x + cw > sdev->lcd_width)
cw = sdev->lcd_width - config->dest.x;
if (config->dest.y + ch > sdev->lcd_height)
ch = sdev->lcd_height - config->dest.y;
/* libshbeu: Set width and height. */
sdev->shbeu_src[n].s.h = ch;
sdev->shbeu_src[n].s.w = cw;
}
/* Update surface? */
if (updated & CLRCF_SURFACE) {
CoreSurfaceBuffer *buffer = left_lock->buffer;
/* libshbeu: Set buffer pitch. */
sdev->shbeu_src[n].s.pitch = left_lock->pitch / DFB_BYTES_PER_PIXEL(buffer->format);
/* libshbeu: Set buffer offset (Y plane or RGB packed). */
sdev->shbeu_src[n].s.py = left_lock->addr;
sdev->shbeu_src[n].s.pc = NULL;
sdev->shbeu_src[n].s.pa = NULL;
/* libshbeu: Set alpha plane to same physical address as RGB plane if layer uses alpha */
if (DFB_PIXELFORMAT_HAS_ALPHA(buffer->format) && (config->options & DLOP_ALPHACHANNEL))
sdev->shbeu_src[n].s.pa = left_lock->addr;
/* Set buffer offset (UV plane). */
if (DFB_PLANAR_PIXELFORMAT(buffer->format)) {
D_ASSUME( buffer->format == DSPF_NV12 || buffer->format == DSPF_NV16 );
sdev->shbeu_src[n].s.pc = left_lock->addr + left_lock->pitch * surface->config.size.h;
}
sreg->surface = surface;
}
/* Update format? */
if (updated & CLRCF_FORMAT) {
/* Set pixel format. */
switch (config->format) {
case DSPF_NV12:
sdev->shbeu_src[n].s.format = REN_NV12;
break;
case DSPF_NV16:
sdev->shbeu_src[n].s.format = REN_NV16;
break;
case DSPF_ARGB:
case DSPF_RGB32:
sdev->shbeu_src[n].s.format = REN_RGB32;
break;
case DSPF_RGB24:
sdev->shbeu_src[n].s.format = REN_BGR24;
break;
case DSPF_RGB16:
sdev->shbeu_src[n].s.format = REN_RGB565;
break;
/* Currently not supported
case DSPF_LUT8:
sdev->shbeu_src[n].s.format = REN_PAL8; //FIXME: implement in libshbeu
break;
*/
default:
break;
}
}
/* Update options or opacity? */
if (updated & (CLRCF_OPTIONS | CLRCF_OPACITY | CLRCF_FORMAT)) {
/* libshbeu: Set opacity value. */
sdev->shbeu_src[n].alpha = (config->options & DLOP_OPACITY) ? config->opacity : 0xff;
/* libshbeu: Enable/disable alpha channel. */
if ((config->options & DLOP_ALPHACHANNEL) && DFB_PIXELFORMAT_HAS_ALPHA(config->format))
sdev->shbeu_src[n].s.pa = sdev->shbeu_src[n].s.py;
else
sdev->shbeu_src[n].s.pa = 0;
}
//TODO: Implement CLUT in libshbeu
/*
// Update CLUT?
if (updated & CLRCF_PALETTE && palette) {
const DFBColor *entries = palette->entries;
for (i=0; i<256; i++) {
SH7722_SETREG32( sdrv, BCLUT(i), PIXEL_ARGB( entries[i].a,
entries[i].r,
entries[i].g,
entries[i].b ) );
}
}
*/
/* Enable or disable input. */
if ((config->options & DLOP_OPACITY) && !config->opacity)
sdev->input_mask &= ~(1 << n);
else
sdev->input_mask |= (1 << n);
fusion_skirmish_dismiss( &sdev->beu_lock );
sreg->config = *config;
return DFB_OK;
}
void sawman_draw_cursor ( CoreWindowStack *stack,
CardState *state,
CoreSurface *surface,
DFBRegion *region,
int x,
int y )
{
DFBRectangle src;
DFBRectangle clip;
DFBSurfaceBlittingFlags flags = DSBLIT_BLEND_ALPHACHANNEL;
D_ASSERT( stack != NULL );
D_MAGIC_ASSERT( state, CardState );
DFB_REGION_ASSERT( region );
D_ASSUME( stack->cursor.opacity > 0 );
D_DEBUG_AT( SaWMan_Draw, "%s( %p, %d,%d-%dx%d )\n", __FUNCTION__,
stack, DFB_RECTANGLE_VALS_FROM_REGION( region ) );
/* Initialize source rectangle. */
src.x = region->x1 - x + stack->cursor.hot.x;
src.y = region->y1 - y + stack->cursor.hot.y;
src.w = region->x2 - region->x1 + 1;
src.h = region->y2 - region->y1 + 1;
D_DEBUG_AT( SaWMan_Draw, " -> cursor surface %p\n", stack->cursor.surface );
/* Initialize source clipping rectangle */
clip.x = clip.y = 0;
clip.w = stack->cursor.surface->config.size.w;
clip.h = stack->cursor.surface->config.size.h;
/* Intersect rectangles */
if (!dfb_rectangle_intersect( &src, &clip ))
return;
/* Set destination. */
if (surface) {
state->destination = surface;
state->modified |= SMF_DESTINATION;
}
/* Use global alpha blending. */
if (stack->cursor.opacity != 0xFF) {
flags |= DSBLIT_BLEND_COLORALPHA;
if (stack->cursor.surface->config.caps & DSCAPS_PREMULTIPLIED) {
/* Need to premultiply source with Ac? */
flags |= DSBLIT_SRC_PREMULTCOLOR;
dfb_state_set_src_blend( state, DSBF_ONE );
}
else
dfb_state_set_src_blend( state, DSBF_SRCALPHA );
/* Set opacity as blending factor. */
if (state->color.a != stack->cursor.opacity) {
state->color.a = stack->cursor.opacity;
state->modified |= SMF_COLOR;
}
}
/* Different compositing methods depending on destination format. */
if (flags & DSBLIT_BLEND_ALPHACHANNEL) {
if (DFB_PIXELFORMAT_HAS_ALPHA( state->destination->config.format )) {
/*
* Always use compliant Porter/Duff SRC_OVER,
* if the destination has an alpha channel.
*
* Cd = destination color (non-premultiplied)
* Ad = destination alpha
*
* Cs = source color (non-premultiplied)
* As = source alpha
*
* Ac = color alpha
*
* cd = Cd * Ad (premultiply destination)
* cs = Cs * As (premultiply source)
*
* The full equation to calculate resulting color and alpha (premultiplied):
*
* cx = cd * (1-As*Ac) + cs * Ac
* ax = Ad * (1-As*Ac) + As * Ac
*/
dfb_state_set_src_blend( state, DSBF_ONE );
/* Need to premultiply source with As*Ac or only with Ac? */
if (! (stack->cursor.surface->config.caps & DSCAPS_PREMULTIPLIED))
flags |= DSBLIT_SRC_PREMULTIPLY;
else if (flags & DSBLIT_BLEND_COLORALPHA)
flags |= DSBLIT_SRC_PREMULTCOLOR;
/* Need to premultiply/demultiply destination? */
// if (! (state->destination->caps & DSCAPS_PREMULTIPLIED))
// flags |= DSBLIT_DST_PREMULTIPLY | DSBLIT_DEMULTIPLY;
}
else {
/*
* We can avoid DSBLIT_SRC_PREMULTIPLY for destinations without an alpha channel
* by using another blending function, which is more likely that it's accelerated
* than premultiplication at this point in time.
*
* This way the resulting alpha (ax) doesn't comply with SRC_OVER,
* but as the destination doesn't have an alpha channel it's no problem.
*
* As the destination's alpha value is always 1.0 there's no need for
* premultiplication. The resulting alpha value will also be 1.0 without
* exceptions, therefore no need for demultiplication.
*
* cx = Cd * (1-As*Ac) + Cs*As * Ac (still same effect as above)
* ax = Ad * (1-As*Ac) + As*As * Ac (wrong, but discarded anyways)
*/
if (stack->cursor.surface->config.caps & DSCAPS_PREMULTIPLIED) {
/* Need to premultiply source with Ac? */
if (flags & DSBLIT_BLEND_COLORALPHA)
flags |= DSBLIT_SRC_PREMULTCOLOR;
dfb_state_set_src_blend( state, DSBF_ONE );
}
else
dfb_state_set_src_blend( state, DSBF_SRCALPHA );
}
}
/* Set blitting flags. */
dfb_state_set_blitting_flags( state, flags );
/* Set blitting source. */
state->source = stack->cursor.surface;
state->from_eye = DSSE_LEFT;
state->modified |= SMF_SOURCE | SMF_FROM;
/* Set clipping region. */
dfb_state_set_clip( state, region );
/* Blit from the window to the region being updated. */
DFBPoint point = {
region->x1, region->y1
};
D_DEBUG_AT( SaWMan_Draw, " -> client %p\n", state->client );
CoreGraphicsStateClient_Blit( state->client, &src, &point, 1 );
/* Reset blitting source. */
state->source = NULL;
state->modified |= SMF_SOURCE;
/* Reset destination. */
if (surface) {
state->destination = NULL;
state->modified |= SMF_DESTINATION;
}
}
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
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 void
draw_window( SaWManTier *tier,
SaWManWindow *sawwin,
SaWManWindow *sawwin2,
CardState *state,
DFBRegion *region,
bool alpha_channel,
bool right_eye )
{
SaWMan *sawman;
CoreWindow *window;
DFBSurfaceBlittingFlags flags = DSBLIT_NOFX;
DFBRectangle dst;
DFBRectangle src;
DFBRegion clip;
DFBRegion old_clip;
int offset;
D_MAGIC_ASSERT( sawwin, SaWManWindow );
D_MAGIC_ASSERT( state, CardState );
DFB_REGION_ASSERT( region );
sawman = sawwin->sawman;
window = sawwin->window;
dst = sawwin->dst;
src = sawwin->src;
D_MAGIC_ASSERT( sawman, SaWMan );
D_ASSERT( window != NULL );
D_ASSERT( window->surface != NULL );
D_DEBUG_AT( SaWMan_Draw, "%s( %p, %d,%d-%dx%d )\n", __FUNCTION__,
sawwin, DFB_RECTANGLE_VALS_FROM_REGION( region ) );
if (window->config.options & DWOP_STEREO_SIDE_BY_SIDE_HALF) {
src.x /= 2;
src.w /= 2;
if (right_eye)
src.x += window->surface->config.size.w / 2;
}
/* Modify dst for stereo offset. */
offset = window->config.z;
offset *= right_eye ? -1 : 1;
dfb_rectangle_translate( &dst, offset, 0 );
/* Setup clipping region. */
clip = *region;
if (!dfb_region_rectangle_intersect( &clip, &dst ))
return;
sawman_dispatch_blit( sawman, sawwin, right_eye, &sawwin->src, &dst, &clip );
if (sawwin2)
sawman_dispatch_blit( sawman, sawwin2, right_eye, &sawwin2->src, &dst, &clip );
/* Backup clipping region. */
old_clip = state->clip;
/* Use per pixel alpha blending. */
if (alpha_channel && (window->config.options & DWOP_ALPHACHANNEL))
flags |= DSBLIT_BLEND_ALPHACHANNEL;
/* Use global alpha blending. */
if (window->config.opacity != 0xFF) {
flags |= DSBLIT_BLEND_COLORALPHA;
if (window->surface->config.caps & DSCAPS_PREMULTIPLIED) {
/* Need to premultiply source with Ac? */
flags |= DSBLIT_SRC_PREMULTCOLOR;
dfb_state_set_src_blend( state, DSBF_ONE );
}
else
dfb_state_set_src_blend( state, DSBF_SRCALPHA );
/* Set opacity as blending factor. */
if (state->color.a != window->config.opacity) {
state->color.a = window->config.opacity;
state->modified |= SMF_COLOR;
}
}
/* if we specified some kind of color, we will colorise. no DWCAPS_COLOR here. */
if (window->config.color.a != 0) {
DFBColor c;
flags |= DSBLIT_COLORIZE;
c = window->config.color;
c.a = state->color.a;
if (! DFB_COLOR_EQUAL( c, state->color )) {
state->color = c;
state->modified |= SMF_COLOR;
}
}
/* Use source color keying. */
if (window->config.options & DWOP_COLORKEYING) {
flags |= DSBLIT_SRC_COLORKEY;
D_DEBUG_AT( SaWMan_Draw, " -> key 0x%08x\n", window->config.color_key );
/* Set window color key. */
dfb_state_set_src_colorkey( state, window->config.color_key );
}
/* Use automatic deinterlacing. */
if (window->surface->config.caps & DSCAPS_INTERLACED)
flags |= DSBLIT_DEINTERLACE;
/* Different compositing methods depending on destination format. */
if (flags & DSBLIT_BLEND_ALPHACHANNEL) {
if (DFB_PIXELFORMAT_HAS_ALPHA( state->destination->config.format )) {
/*
* Always use compliant Porter/Duff SRC_OVER,
* if the destination has an alpha channel.
*
* Cd = destination color (non-premultiplied)
* Ad = destination alpha
*
* Cs = source color (non-premultiplied)
* As = source alpha
*
* Ac = color alpha
*
* cd = Cd * Ad (premultiply destination)
* cs = Cs * As (premultiply source)
*
* The full equation to calculate resulting color and alpha (premultiplied):
*
* cx = cd * (1-As*Ac) + cs * Ac
* ax = Ad * (1-As*Ac) + As * Ac
*/
dfb_state_set_src_blend( state, DSBF_ONE );
/* Need to premultiply source with As*Ac or only with Ac? */
if (! (window->surface->config.caps & DSCAPS_PREMULTIPLIED))
flags |= DSBLIT_SRC_PREMULTIPLY;
else if (flags & DSBLIT_BLEND_COLORALPHA)
flags |= DSBLIT_SRC_PREMULTCOLOR;
/* Need to premultiply/demultiply destination? */
// if (! (state->destination->caps & DSCAPS_PREMULTIPLIED))
// flags |= DSBLIT_DST_PREMULTIPLY | DSBLIT_DEMULTIPLY;
}
else {
/*
* We can avoid DSBLIT_SRC_PREMULTIPLY for destinations without an alpha channel
* by using another blending function, which is more likely that it's accelerated
* than premultiplication at this point in time.
*
* This way the resulting alpha (ax) doesn't comply with SRC_OVER,
* but as the destination doesn't have an alpha channel it's no problem.
*
* As the destination's alpha value is always 1.0 there's no need for
* premultiplication. The resulting alpha value will also be 1.0 without
* exceptions, therefore no need for demultiplication.
*
* cx = Cd * (1-As*Ac) + Cs*As * Ac (still same effect as above)
* ax = Ad * (1-As*Ac) + As*As * Ac (wrong, but discarded anyways)
*/
if (window->surface->config.caps & DSCAPS_PREMULTIPLIED) {
/* Need to premultiply source with Ac? */
if (flags & DSBLIT_BLEND_COLORALPHA)
flags |= DSBLIT_SRC_PREMULTCOLOR;
dfb_state_set_src_blend( state, DSBF_ONE );
}
else
dfb_state_set_src_blend( state, DSBF_SRCALPHA );
}
}
/* Use color (key) protection if layer is keyed. */
if (tier->context->config.options & DLOP_SRC_COLORKEY) {
flags |= DSBLIT_COLORKEY_PROTECT;
dfb_state_set_colorkey( state, &tier->key );
}
/* Set blitting flags. */
dfb_state_set_blitting_flags( state, flags );
/* Set render options. */
if (sawman->scaling_mode == SWMSM_SMOOTH)
dfb_state_set_render_options( state, DSRO_SMOOTH_DOWNSCALE | DSRO_SMOOTH_UPSCALE );
else
dfb_state_set_render_options( state, DSRO_NONE );
/* Set blitting source. */
state->source = window->surface;
state->from_eye = (right_eye && (sawwin->caps & DWCAPS_STEREO)) ? DSSE_RIGHT : DSSE_LEFT;
state->modified |= SMF_SOURCE | SMF_FROM;
D_DEBUG_AT( SaWMan_Draw, " [][] %4d,%4d-%4dx%4d\n", DFB_RECTANGLE_VALS_FROM_REGION( &clip ) );
/* Change clipping region. */
dfb_state_set_clip( state, &clip );
D_DEBUG_AT( SaWMan_Draw, " => %4d,%4d-%4dx%4d <- %4d,%4d-%4dx%4d\n",
DFB_RECTANGLE_VALS( &dst ), DFB_RECTANGLE_VALS( &src ) );
#ifndef OLD_COREWINDOWS_STRUCTURE
if (sawwin2) {
CoreWindow *window2;
DFBRectangle *src2;
DFBPoint p1,p2,p;
D_MAGIC_ASSERT( sawwin2, SaWManWindow );
window2 = sawwin2->window;
D_ASSERT( window2 != NULL );
D_ASSERT( window2->surface != NULL );
src2 = &sawwin2->src;
state->source2 = window2->surface;
state->modified = SMF_SOURCE2;
p1.x = src2->x + (sawwin->dst.x - sawwin2->dst.x);
p1.y = src2->y + (sawwin->dst.y - sawwin2->dst.y);
p2.x = sawwin->dst.x;
p2.y = sawwin->dst.y;
p.x = p1.x;
p.y = p1.y;
p1.x = src.x;
p1.y = src.y;
src.x = p.x;
src.y = p.y;
CoreGraphicsStateClient_Blit2( state->client, &src, &p2, &p1, 1 );
}
else
#endif
{
/* Scale window to the screen clipped by the region being updated. */
CoreGraphicsStateClient_StretchBlit( state->client, &src, &dst, 1 );
}
/* Restore clipping region. */
dfb_state_set_clip( state, &old_clip );
}
DFBResult
dfb_window_create( CoreWindowStack *stack,
int x,
int y,
int width,
int height,
DFBWindowCapabilities caps,
DFBSurfaceCapabilities surface_caps,
DFBSurfacePixelFormat pixelformat,
CoreWindow **window )
{
DFBResult ret;
CoreSurface *surface;
CoreSurfacePolicy surface_policy;
CoreWindow *w;
DisplayLayer *layer = dfb_layer_at( stack->layer_id );
CoreSurface *layer_surface = dfb_layer_surface( layer );
surface_caps &= DSCAPS_INTERLACED | DSCAPS_SEPERATED |
DSCAPS_STATIC_ALLOC | DSCAPS_SYSTEMONLY | DSCAPS_VIDEOONLY;
if (caps & DWCAPS_ALPHACHANNEL) {
if (pixelformat == DSPF_UNKNOWN)
pixelformat = DSPF_ARGB;
else if (! DFB_PIXELFORMAT_HAS_ALPHA(pixelformat))
return DFB_INVARG;
surface_policy = stack->wsp_alpha;
}
else {
surface_policy = stack->wsp_opaque;
if (pixelformat == DSPF_UNKNOWN)
pixelformat = layer_surface->format;
}
if (surface_caps & DSCAPS_VIDEOONLY)
surface_policy = CSP_VIDEOONLY;
else if (surface_caps & DSCAPS_SYSTEMONLY)
surface_policy = CSP_SYSTEMONLY;
else if (layer_surface->back_buffer->policy == CSP_SYSTEMONLY)
surface_policy = CSP_SYSTEMONLY;
if (caps & DWCAPS_DOUBLEBUFFER)
surface_caps |= DSCAPS_FLIPPING;
/* Create the window object. */
w = (CoreWindow*) fusion_object_create( stack->pool );
/* Create the window's surface using the layer's palette. */
if (! (caps & DWCAPS_INPUTONLY)) {
ret = dfb_surface_create( width, height, pixelformat, surface_policy,
surface_caps, layer_surface->palette,
&surface );
if (ret) {
fusion_object_destroy( &w->object );
return ret;
}
dfb_surface_link( &w->surface, surface );
dfb_surface_unref( surface );
}
w->id = new_window_id( stack );
w->x = x;
w->y = y;
w->width = width;
w->height = height;
w->caps = caps;
w->opacity = 0;
if (caps & DWCAPS_ALPHACHANNEL)
w->options = DWOP_ALPHACHANNEL;
w->stack = stack;
w->events = DWET_ALL;
*window = w;
return DFB_OK;;
}
data->base.render_callback = callback;
data->base.render_callback_context = ctx;
return DFB_OK;
}
static DFBResult
IDirectFBImageProvider_WebP_GetImageDescription( IDirectFBImageProvider *thiz,
DFBImageDescription *desc )
{
DIRECT_INTERFACE_GET_DATA( IDirectFBImageProvider_WebP )
if (!desc)
return DFB_INVARG;
desc->caps = DFB_PIXELFORMAT_HAS_ALPHA( data->pixelformat ) ? DICAPS_ALPHACHANNEL : DICAPS_NONE;
return DFB_OK;
}
static DFBResult
IDirectFBImageProvider_WebP_GetSurfaceDescription( IDirectFBImageProvider *thiz,
DFBSurfaceDescription *desc )
{
DIRECT_INTERFACE_GET_DATA( IDirectFBImageProvider_WebP )
if (!desc)
return DFB_INVARG;
desc->flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS;
