void GGLAssembler::expand(integer_t& dst, const integer_t& src, int dbits)
{
assert(src.size());
int sbits = src.size();
int s = src.reg;
int d = dst.reg;
// be sure to set 'dst' after we read 'src' as they may be identical
dst.s = dbits;
dst.flags = 0;
if (dbits<=sbits) {
if (s != d) {
MOV(AL, 0, d, s);
}
return;
}
if (sbits == 1) {
RSB(AL, 0, d, s, reg_imm(s, LSL, dbits));
// d = (s<<dbits) - s;
return;
}
if (dbits % sbits) {
MOV(AL, 0, d, reg_imm(s, LSL, dbits-sbits));
// d = s << (dbits-sbits);
dbits -= sbits;
do {
ORR(AL, 0, d, d, reg_imm(d, LSR, sbits));
// d |= d >> sbits;
dbits -= sbits;
sbits *= 2;
} while(dbits>0);
return;
}
dbits -= sbits;
do {
ORR(AL, 0, d, s, reg_imm(s, LSL, sbits));
// d |= d<<sbits;
s = d;
dbits -= sbits;
if (sbits*2 < dbits) {
sbits *= 2;
}
} while(dbits>0);
}
void GGLAssembler::build_blendOneMinusFF(
component_t& temp,
const integer_t& factor,
const integer_t& fragment,
const integer_t& fb)
{
// R = S*f + D*(1-f) = (S-D)*f + D
Scratch scratches(registerFile());
// compute D-S
integer_t diff(fb.flags & CORRUPTIBLE ?
fb.reg : scratches.obtain(), fb.size(), CORRUPTIBLE);
const int shift = fragment.size() - fb.size();
if (shift>0) SUB(AL, 0, diff.reg, fb.reg, reg_imm(fragment.reg, LSR, shift));
else if (shift<0) SUB(AL, 0, diff.reg, fb.reg, reg_imm(fragment.reg, LSL,-shift));
else SUB(AL, 0, diff.reg, fb.reg, fragment.reg);
mul_factor_add(temp, diff, factor, component_t(fragment));
}
void GGLAssembler::component_add(component_t& d,
const integer_t& dst, const integer_t& src)
{
// here we're guaranteed that fragment.size() >= fb.size()
const int shift = src.size() - dst.size();
if (!shift) {
ADD(AL, 0, d.reg, src.reg, dst.reg);
} else {
ADD(AL, 0, d.reg, src.reg, reg_imm(dst.reg, LSL, shift));
}
d.h = src.size();
if (mDithering) {
d.l = 0;
} else {
d.l = shift;
d.flags |= CLEAR_LO;
}
}
void GGLAssembler::mul_factor_add( component_t& d,
const integer_t& v,
const integer_t& f,
const component_t& a)
{
// XXX: we could have special cases for 1 bit mul
Scratch scratches(registerFile());
int vs = v.size();
int fs = f.size();
int as = a.h;
int ms = vs+fs;
ALOGE_IF(ms>=32, "mul_factor_add overflow vs=%d, fs=%d, as=%d", vs, fs, as);
integer_t add(a.reg, a.h, a.flags);
// 'a' is a component_t but it is guaranteed to have
// its high bits set to 0. However in the dithering case,
// we can't get away with truncating the potentially bad bits
// so extraction is needed.
if ((mDithering) && (a.size() < ms)) {
// we need to expand a
if (!(a.flags & CORRUPTIBLE)) {
// ... but it's not corruptible, so we need to pick a
// temporary register.
// Try to uses the destination register first (it's likely
// to be usable, unless it aliases an input).
if (d.reg!=a.reg && d.reg!=v.reg && d.reg!=f.reg) {
add.reg = d.reg;
} else {
add.reg = scratches.obtain();
}
}
expand(add, a, ms); // extracts and expands
as = ms;
}
if (ms == as) {
if (vs<16 && fs<16) SMLABB(AL, d.reg, v.reg, f.reg, add.reg);
else MLA(AL, 0, d.reg, v.reg, f.reg, add.reg);
} else {
int temp = d.reg;
if (temp == add.reg) {
// the mul will modify add.reg, we need an intermediary reg
if (v.flags & CORRUPTIBLE) temp = v.reg;
else if (f.flags & CORRUPTIBLE) temp = f.reg;
else temp = scratches.obtain();
}
if (vs<16 && fs<16) SMULBB(AL, temp, v.reg, f.reg);
else MUL(AL, 0, temp, v.reg, f.reg);
if (ms>as) {
ADD(AL, 0, d.reg, temp, reg_imm(add.reg, LSL, ms-as));
} else if (ms<as) {
// not sure if we should expand the mul instead?
ADD(AL, 0, d.reg, temp, reg_imm(add.reg, LSR, as-ms));
}
}
d.h = ms;
if (mDithering) {
d.l = a.l;
} else {
d.l = fs>a.l ? fs : a.l;
d.flags |= CLEAR_LO;
}
}
void GGLAssembler::mul_factor( component_t& d,
const integer_t& v,
const integer_t& f)
{
int vs = v.size();
int fs = f.size();
int ms = vs+fs;
// XXX: we could have special cases for 1 bit mul
// all this code below to use the best multiply instruction
// wrt the parameters size. We take advantage of the fact
// that the 16-bits multiplies allow a 16-bit shift
// The trick is that we just make sure that we have at least 8-bits
// per component (which is enough for a 8 bits display).
int xy;
int vshift = 0;
int fshift = 0;
int smulw = 0;
if (vs<16) {
if (fs<16) {
xy = xyBB;
} else if (GGL_BETWEEN(fs, 24, 31)) {
ms -= 16;
xy = xyTB;
} else {
// eg: 15 * 18 -> 15 * 15
fshift = fs - 15;
ms -= fshift;
xy = xyBB;
}
} else if (GGL_BETWEEN(vs, 24, 31)) {
if (fs<16) {
ms -= 16;
xy = xyTB;
} else if (GGL_BETWEEN(fs, 24, 31)) {
ms -= 32;
xy = xyTT;
} else {
// eg: 24 * 18 -> 8 * 18
fshift = fs - 15;
ms -= 16 + fshift;
xy = xyTB;
}
} else {
if (fs<16) {
// eg: 18 * 15 -> 15 * 15
vshift = vs - 15;
ms -= vshift;
xy = xyBB;
} else if (GGL_BETWEEN(fs, 24, 31)) {
// eg: 18 * 24 -> 15 * 8
vshift = vs - 15;
ms -= 16 + vshift;
xy = xyBT;
} else {
// eg: 18 * 18 -> (15 * 18)>>16
fshift = fs - 15;
ms -= 16 + fshift;
xy = yB; //XXX SMULWB
smulw = 1;
}
}
ALOGE_IF(ms>=32, "mul_factor overflow vs=%d, fs=%d", vs, fs);
int vreg = v.reg;
int freg = f.reg;
if (vshift) {
MOV(AL, 0, d.reg, reg_imm(vreg, LSR, vshift));
vreg = d.reg;
}
if (fshift) {
MOV(AL, 0, d.reg, reg_imm(vreg, LSR, fshift));
freg = d.reg;
}
if (smulw) SMULW(AL, xy, d.reg, vreg, freg);
else SMUL(AL, xy, d.reg, vreg, freg);
d.h = ms;
if (mDithering) {
d.l = 0;
} else {
d.l = fs;
d.flags |= CLEAR_LO;
}
}
void GGLAssembler::build_blend_factor(
integer_t& factor, int f, int component,
const pixel_t& dst_pixel,
integer_t& fragment,
integer_t& fb,
Scratch& scratches)
{
integer_t src_alpha(fragment);
// src_factor/dst_factor won't be used after blending,
// so it's fine to mark them as CORRUPTIBLE (if not aliased)
factor.flags |= CORRUPTIBLE;
switch(f) {
case GGL_ONE_MINUS_SRC_ALPHA:
case GGL_SRC_ALPHA:
if (component==GGLFormat::ALPHA && !isAlphaSourceNeeded()) {
// we're processing alpha, so we already have
// src-alpha in fragment, and we need src-alpha just this time.
} else {
// alpha-src will be needed for other components
if (!mBlendFactorCached || mBlendFactorCached==f) {
src_alpha = mAlphaSource;
factor = mAlphaSource;
factor.flags &= ~CORRUPTIBLE;
// we already computed the blend factor before, nothing to do.
if (mBlendFactorCached)
return;
// this is the first time, make sure to compute the blend
// factor properly.
mBlendFactorCached = f;
break;
} else {
// we have a cached alpha blend factor, but we want another one,
// this should really not happen because by construction,
// we cannot have BOTH source and destination
// blend factors use ALPHA *and* ONE_MINUS_ALPHA (because
// the blending stage uses the f/(1-f) optimization
// for completeness, we handle this case though. Since there
// are only 2 choices, this meens we want "the other one"
// (1-factor)
factor = mAlphaSource;
factor.flags &= ~CORRUPTIBLE;
RSB(AL, 0, factor.reg, factor.reg, imm((1<<factor.s)));
mBlendFactorCached = f;
return;
}
}
// fall-through...
case GGL_ONE_MINUS_DST_COLOR:
case GGL_DST_COLOR:
case GGL_ONE_MINUS_SRC_COLOR:
case GGL_SRC_COLOR:
case GGL_ONE_MINUS_DST_ALPHA:
case GGL_DST_ALPHA:
case GGL_SRC_ALPHA_SATURATE:
// help us find out what register we can use for the blend-factor
// CORRUPTIBLE registers are chosen first, or a new one is allocated.
if (fragment.flags & CORRUPTIBLE) {
factor.setTo(fragment.reg, 32, CORRUPTIBLE);
fragment.flags &= ~CORRUPTIBLE;
} else if (fb.flags & CORRUPTIBLE) {
factor.setTo(fb.reg, 32, CORRUPTIBLE);
fb.flags &= ~CORRUPTIBLE;
} else {
factor.setTo(scratches.obtain(), 32, CORRUPTIBLE);
}
break;
}
// XXX: doesn't work if size==1
switch(f) {
case GGL_ONE_MINUS_DST_COLOR:
case GGL_DST_COLOR:
factor.s = fb.s;
ADD(AL, 0, factor.reg, fb.reg, reg_imm(fb.reg, LSR, fb.s-1));
break;
case GGL_ONE_MINUS_SRC_COLOR:
case GGL_SRC_COLOR:
factor.s = fragment.s;
ADD(AL, 0, factor.reg, fragment.reg,
reg_imm(fragment.reg, LSR, fragment.s-1));
break;
case GGL_ONE_MINUS_SRC_ALPHA:
case GGL_SRC_ALPHA:
factor.s = src_alpha.s;
ADD(AL, 0, factor.reg, src_alpha.reg,
reg_imm(src_alpha.reg, LSR, src_alpha.s-1));
break;
case GGL_ONE_MINUS_DST_ALPHA:
case GGL_DST_ALPHA:
// XXX: should be precomputed
extract(factor, dst_pixel, GGLFormat::ALPHA);
ADD(AL, 0, factor.reg, factor.reg,
reg_imm(factor.reg, LSR, factor.s-1));
break;
case GGL_SRC_ALPHA_SATURATE:
// XXX: should be precomputed
// XXX: f = min(As, 1-Ad)
// btw, we're guaranteed that Ad's size is <= 8, because
// it's extracted from the framebuffer
break;
}
switch(f) {
case GGL_ONE_MINUS_DST_COLOR:
case GGL_ONE_MINUS_SRC_COLOR:
case GGL_ONE_MINUS_DST_ALPHA:
case GGL_ONE_MINUS_SRC_ALPHA:
RSB(AL, 0, factor.reg, factor.reg, imm((1<<factor.s)));
}
// don't need more than 8-bits for the blend factor
// and this will prevent overflows in the multiplies later
if (factor.s > 8) {
MOV(AL, 0, factor.reg, reg_imm(factor.reg, LSR, factor.s-8));
factor.s = 8;
}
}
