remove last remnant of SK_SCALAR_IS_FIXED code
move SkScalarMean into its only caller, reducing out public API exposure
BUG=
Review URL: https://codereview.chromium.org/117133004
git-svn-id: http://skia.googlecode.com/svn/trunk@12733 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/core/SkMatrix.cpp b/src/core/SkMatrix.cpp
index 2c850b3..d3d1610 100644
--- a/src/core/SkMatrix.cpp
+++ b/src/core/SkMatrix.cpp
@@ -313,11 +313,6 @@
return true;
}
-#ifdef SK_SCALAR_IS_FIXED
- SkMatrix m;
- m.setScale(sx, sy);
- return this->preConcat(m);
-#else
// the assumption is that these multiplies are very cheap, and that
// a full concat and/or just computing the matrix type is more expensive.
// Also, the fixed-point case checks for overflow, but the float doesn't,
@@ -333,7 +328,6 @@
this->orTypeMask(kScale_Mask);
return true;
-#endif
}
bool SkMatrix::postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
@@ -354,19 +348,6 @@
return this->postConcat(m);
}
-#ifdef SK_SCALAR_IS_FIXED
- static inline SkFixed roundidiv(SkFixed numer, int denom) {
- int ns = numer >> 31;
- int ds = denom >> 31;
- numer = (numer ^ ns) - ns;
- denom = (denom ^ ds) - ds;
-
- SkFixed answer = (numer + (denom >> 1)) / denom;
- int as = ns ^ ds;
- return (answer ^ as) - as;
- }
-#endif
-
// this guy perhaps can go away, if we have a fract/high-precision way to
// scale matrices
bool SkMatrix::postIDiv(int divx, int divy) {
@@ -374,15 +355,6 @@
return false;
}
-#ifdef SK_SCALAR_IS_FIXED
- fMat[kMScaleX] = roundidiv(fMat[kMScaleX], divx);
- fMat[kMSkewX] = roundidiv(fMat[kMSkewX], divx);
- fMat[kMTransX] = roundidiv(fMat[kMTransX], divx);
-
- fMat[kMScaleY] = roundidiv(fMat[kMScaleY], divy);
- fMat[kMSkewY] = roundidiv(fMat[kMSkewY], divy);
- fMat[kMTransY] = roundidiv(fMat[kMTransY], divy);
-#else
const float invX = 1.f / divx;
const float invY = 1.f / divy;
@@ -393,7 +365,6 @@
fMat[kMScaleY] *= invY;
fMat[kMSkewY] *= invY;
fMat[kMTransY] *= invY;
-#endif
this->setTypeMask(kUnknown_Mask);
return true;
@@ -856,57 +827,7 @@
inv->fMat[kMPersp0] = SkScalarMulShift(SkScalarMul(fMat[kMSkewY], fMat[kMPersp1]) - SkScalarMul(fMat[kMScaleY], fMat[kMPersp0]), scale, shift);
inv->fMat[kMPersp1] = SkScalarMulShift(SkScalarMul(fMat[kMSkewX], fMat[kMPersp0]) - SkScalarMul(fMat[kMScaleX], fMat[kMPersp1]), scale, shift);
inv->fMat[kMPersp2] = SkScalarMulShift(SkScalarMul(fMat[kMScaleX], fMat[kMScaleY]) - SkScalarMul(fMat[kMSkewX], fMat[kMSkewY]), scale, shift);
-#ifdef SK_SCALAR_IS_FIXED
- if (SkAbs32(inv->fMat[kMPersp2]) > SK_Fixed1) {
- Sk64 tmp;
-
- tmp.set(SK_Fract1);
- tmp.shiftLeft(16);
- tmp.div(inv->fMat[kMPersp2], Sk64::kRound_DivOption);
-
- SkFract scale = tmp.get32();
-
- for (int i = 0; i < 9; i++) {
- inv->fMat[i] = SkFractMul(inv->fMat[i], scale);
- }
- }
- inv->fMat[kMPersp2] = SkFixedToFract(inv->fMat[kMPersp2]);
-#endif
} else { // not perspective
-#ifdef SK_SCALAR_IS_FIXED
- Sk64 tx, ty;
- int clzNumer;
-
- // check the 2x2 for overflow
- {
- int32_t value = SkAbs32(fMat[kMScaleY]);
- value |= SkAbs32(fMat[kMSkewX]);
- value |= SkAbs32(fMat[kMScaleX]);
- value |= SkAbs32(fMat[kMSkewY]);
- clzNumer = SkCLZ(value);
- if (shift - clzNumer > 31)
- return false; // overflow
- }
-
- set_muladdmul(&tx, fMat[kMSkewX], fMat[kMTransY], -fMat[kMScaleY], fMat[kMTransX]);
- set_muladdmul(&ty, fMat[kMSkewY], fMat[kMTransX], -fMat[kMScaleX], fMat[kMTransY]);
- // check tx,ty for overflow
- clzNumer = SkCLZ(SkAbs32(tx.fHi) | SkAbs32(ty.fHi));
- if (shift - clzNumer > 14) {
- return false; // overflow
- }
-
- int fixedShift = 61 - shift;
- int sk64shift = 44 - shift + clzNumer;
-
- inv->fMat[kMScaleX] = SkMulShift(fMat[kMScaleY], scale, fixedShift);
- inv->fMat[kMSkewX] = SkMulShift(-fMat[kMSkewX], scale, fixedShift);
- inv->fMat[kMTransX] = SkMulShift(tx.getShiftRight(33 - clzNumer), scale, sk64shift);
-
- inv->fMat[kMSkewY] = SkMulShift(-fMat[kMSkewY], scale, fixedShift);
- inv->fMat[kMScaleY] = SkMulShift(fMat[kMScaleX], scale, fixedShift);
- inv->fMat[kMTransY] = SkMulShift(ty.getShiftRight(33 - clzNumer), scale, sk64shift);
-#else
inv->fMat[kMScaleX] = SkDoubleToFloat(fMat[kMScaleY] * scale);
inv->fMat[kMSkewX] = SkDoubleToFloat(-fMat[kMSkewX] * scale);
inv->fMat[kMTransX] = mul_diff_scale(fMat[kMSkewX], fMat[kMTransY],
@@ -916,7 +837,7 @@
inv->fMat[kMScaleY] = SkDoubleToFloat(fMat[kMScaleX] * scale);
inv->fMat[kMTransY] = mul_diff_scale(fMat[kMSkewY], fMat[kMTransX],
fMat[kMScaleX], fMat[kMTransY], scale);
-#endif
+
inv->fMat[kMPersp0] = 0;
inv->fMat[kMPersp1] = 0;
inv->fMat[kMPersp2] = kMatrix22Elem;
@@ -1038,10 +959,6 @@
const SkPoint src[], int count) {
SkASSERT(m.hasPerspective());
-#ifdef SK_SCALAR_IS_FIXED
- SkFixed persp2 = SkFractToFixed(m.fMat[kMPersp2]);
-#endif
-
if (count > 0) {
do {
SkScalar sy = src->fY;
@@ -1052,13 +969,8 @@
SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
-#ifdef SK_SCALAR_IS_FIXED
- SkFixed z = SkFractMul(sx, m.fMat[kMPersp0]) +
- SkFractMul(sy, m.fMat[kMPersp1]) + persp2;
-#else
- float z = SkScalarMul(sx, m.fMat[kMPersp0]) +
- SkScalarMulAdd(sy, m.fMat[kMPersp1], m.fMat[kMPersp2]);
-#endif
+ SkScalar z = SkScalarMul(sx, m.fMat[kMPersp0]) +
+ SkScalarMulAdd(sy, m.fMat[kMPersp1], m.fMat[kMPersp2]);
if (z) {
z = SkScalarFastInvert(z);
}
@@ -1191,14 +1103,8 @@
SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
-#ifdef SK_SCALAR_IS_FIXED
- SkFixed z = SkFractMul(sx, m.fMat[kMPersp0]) +
- SkFractMul(sy, m.fMat[kMPersp1]) +
- SkFractToFixed(m.fMat[kMPersp2]);
-#else
- float z = SkScalarMul(sx, m.fMat[kMPersp0]) +
- SkScalarMul(sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
-#endif
+ SkScalar z = SkScalarMul(sx, m.fMat[kMPersp0]) +
+ SkScalarMul(sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
if (z) {
z = SkScalarFastInvert(z);
}
@@ -1206,33 +1112,14 @@
pt->fY = SkScalarMul(y, z);
}
-#ifdef SK_SCALAR_IS_FIXED
-static SkFixed fixmuladdmul(SkFixed a, SkFixed b, SkFixed c, SkFixed d) {
- Sk64 tmp, tmp1;
-
- tmp.setMul(a, b);
- tmp1.setMul(c, d);
- return tmp.addGetFixed(tmp1);
-// tmp.add(tmp1);
-// return tmp.getFixed();
-}
-#endif
-
void SkMatrix::RotTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
SkPoint* pt) {
SkASSERT((m.getType() & (kAffine_Mask | kPerspective_Mask)) == kAffine_Mask);
-#ifdef SK_SCALAR_IS_FIXED
- pt->fX = fixmuladdmul(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX]) +
- m.fMat[kMTransX];
- pt->fY = fixmuladdmul(sx, m.fMat[kMSkewY], sy, m.fMat[kMScaleY]) +
- m.fMat[kMTransY];
-#else
pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
-#endif
}
void SkMatrix::Rot_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
@@ -1241,15 +1128,10 @@
SkASSERT(0 == m.fMat[kMTransX]);
SkASSERT(0 == m.fMat[kMTransY]);
-#ifdef SK_SCALAR_IS_FIXED
- pt->fX = fixmuladdmul(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX]);
- pt->fY = fixmuladdmul(sx, m.fMat[kMSkewY], sy, m.fMat[kMScaleY]);
-#else
pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
-#endif
}
void SkMatrix::ScaleTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
@@ -1303,13 +1185,7 @@
///////////////////////////////////////////////////////////////////////////////
// if its nearly zero (just made up 26, perhaps it should be bigger or smaller)
-#ifdef SK_SCALAR_IS_FIXED
- typedef SkFract SkPerspElemType;
- #define PerspNearlyZero(x) (SkAbs32(x) < (SK_Fract1 >> 26))
-#else
- typedef float SkPerspElemType;
- #define PerspNearlyZero(x) SkScalarNearlyZero(x, (1.0f / (1 << 26)))
-#endif
+#define PerspNearlyZero(x) SkScalarNearlyZero(x, (1.0f / (1 << 26)))
bool SkMatrix::fixedStepInX(SkScalar y, SkFixed* stepX, SkFixed* stepY) const {
if (PerspNearlyZero(fMat[kMPersp0])) {
@@ -1323,12 +1199,7 @@
*stepY = SkScalarToFixed(fMat[kMSkewY]);
}
} else {
-#ifdef SK_SCALAR_IS_FIXED
- SkFixed z = SkFractMul(y, fMat[kMPersp1]) +
- SkFractToFixed(fMat[kMPersp2]);
-#else
- float z = y * fMat[kMPersp1] + fMat[kMPersp2];
-#endif
+ SkScalar z = y * fMat[kMPersp1] + fMat[kMPersp2];
if (stepX) {
*stepX = SkScalarToFixed(SkScalarDiv(fMat[kMScaleX], z));
}
@@ -1395,143 +1266,6 @@
///////////////////////////////////////////////////////////////////////////////
-#ifdef SK_SCALAR_IS_FIXED
-
-static inline bool poly_to_point(SkPoint* pt, const SkPoint poly[], int count) {
- SkFixed x = SK_Fixed1, y = SK_Fixed1;
- SkPoint pt1, pt2;
- Sk64 w1, w2;
-
- if (count > 1) {
- pt1.fX = poly[1].fX - poly[0].fX;
- pt1.fY = poly[1].fY - poly[0].fY;
- y = SkPoint::Length(pt1.fX, pt1.fY);
- if (y == 0) {
- return false;
- }
- switch (count) {
- case 2:
- break;
- case 3:
- pt2.fX = poly[0].fY - poly[2].fY;
- pt2.fY = poly[2].fX - poly[0].fX;
- goto CALC_X;
- default:
- pt2.fX = poly[0].fY - poly[3].fY;
- pt2.fY = poly[3].fX - poly[0].fX;
- CALC_X:
- w1.setMul(pt1.fX, pt2.fX);
- w2.setMul(pt1.fY, pt2.fY);
- w1.add(w2);
- w1.div(y, Sk64::kRound_DivOption);
- if (!w1.is32()) {
- return false;
- }
- x = w1.get32();
- break;
- }
- }
- pt->set(x, y);
- return true;
-}
-
-bool SkMatrix::Poly2Proc(const SkPoint srcPt[], SkMatrix* dst,
- const SkPoint& scalePt) {
- // need to check if SkFixedDiv overflows...
-
- const SkFixed scale = scalePt.fY;
- dst->fMat[kMScaleX] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale);
- dst->fMat[kMSkewY] = SkFixedDiv(srcPt[0].fX - srcPt[1].fX, scale);
- dst->fMat[kMPersp0] = 0;
- dst->fMat[kMSkewX] = SkFixedDiv(srcPt[1].fX - srcPt[0].fX, scale);
- dst->fMat[kMScaleY] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale);
- dst->fMat[kMPersp1] = 0;
- dst->fMat[kMTransX] = srcPt[0].fX;
- dst->fMat[kMTransY] = srcPt[0].fY;
- dst->fMat[kMPersp2] = SK_Fract1;
- dst->setTypeMask(kUnknown_Mask);
- return true;
-}
-
-bool SkMatrix::Poly3Proc(const SkPoint srcPt[], SkMatrix* dst,
- const SkPoint& scale) {
- // really, need to check if SkFixedDiv overflow'd
-
- dst->fMat[kMScaleX] = SkFixedDiv(srcPt[2].fX - srcPt[0].fX, scale.fX);
- dst->fMat[kMSkewY] = SkFixedDiv(srcPt[2].fY - srcPt[0].fY, scale.fX);
- dst->fMat[kMPersp0] = 0;
- dst->fMat[kMSkewX] = SkFixedDiv(srcPt[1].fX - srcPt[0].fX, scale.fY);
- dst->fMat[kMScaleY] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale.fY);
- dst->fMat[kMPersp1] = 0;
- dst->fMat[kMTransX] = srcPt[0].fX;
- dst->fMat[kMTransY] = srcPt[0].fY;
- dst->fMat[kMPersp2] = SK_Fract1;
- dst->setTypeMask(kUnknown_Mask);
- return true;
-}
-
-bool SkMatrix::Poly4Proc(const SkPoint srcPt[], SkMatrix* dst,
- const SkPoint& scale) {
- SkFract a1, a2;
- SkFixed x0, y0, x1, y1, x2, y2;
-
- x0 = srcPt[2].fX - srcPt[0].fX;
- y0 = srcPt[2].fY - srcPt[0].fY;
- x1 = srcPt[2].fX - srcPt[1].fX;
- y1 = srcPt[2].fY - srcPt[1].fY;
- x2 = srcPt[2].fX - srcPt[3].fX;
- y2 = srcPt[2].fY - srcPt[3].fY;
-
- /* check if abs(x2) > abs(y2) */
- if ( x2 > 0 ? y2 > 0 ? x2 > y2 : x2 > -y2 : y2 > 0 ? -x2 > y2 : x2 < y2) {
- SkFixed denom = SkMulDiv(x1, y2, x2) - y1;
- if (0 == denom) {
- return false;
- }
- a1 = SkFractDiv(SkMulDiv(x0 - x1, y2, x2) - y0 + y1, denom);
- } else {
- SkFixed denom = x1 - SkMulDiv(y1, x2, y2);
- if (0 == denom) {
- return false;
- }
- a1 = SkFractDiv(x0 - x1 - SkMulDiv(y0 - y1, x2, y2), denom);
- }
-
- /* check if abs(x1) > abs(y1) */
- if ( x1 > 0 ? y1 > 0 ? x1 > y1 : x1 > -y1 : y1 > 0 ? -x1 > y1 : x1 < y1) {
- SkFixed denom = y2 - SkMulDiv(x2, y1, x1);
- if (0 == denom) {
- return false;
- }
- a2 = SkFractDiv(y0 - y2 - SkMulDiv(x0 - x2, y1, x1), denom);
- } else {
- SkFixed denom = SkMulDiv(y2, x1, y1) - x2;
- if (0 == denom) {
- return false;
- }
- a2 = SkFractDiv(SkMulDiv(y0 - y2, x1, y1) - x0 + x2, denom);
- }
-
- // need to check if SkFixedDiv overflows...
- dst->fMat[kMScaleX] = SkFixedDiv(SkFractMul(a2, srcPt[3].fX) +
- srcPt[3].fX - srcPt[0].fX, scale.fX);
- dst->fMat[kMSkewY] = SkFixedDiv(SkFractMul(a2, srcPt[3].fY) +
- srcPt[3].fY - srcPt[0].fY, scale.fX);
- dst->fMat[kMPersp0] = SkFixedDiv(a2, scale.fX);
- dst->fMat[kMSkewX] = SkFixedDiv(SkFractMul(a1, srcPt[1].fX) +
- srcPt[1].fX - srcPt[0].fX, scale.fY);
- dst->fMat[kMScaleY] = SkFixedDiv(SkFractMul(a1, srcPt[1].fY) +
- srcPt[1].fY - srcPt[0].fY, scale.fY);
- dst->fMat[kMPersp1] = SkFixedDiv(a1, scale.fY);
- dst->fMat[kMTransX] = srcPt[0].fX;
- dst->fMat[kMTransY] = srcPt[0].fY;
- dst->fMat[kMPersp2] = SK_Fract1;
- dst->setTypeMask(kUnknown_Mask);
- return true;
-}
-
-#else /* Scalar is float */
-
static inline bool checkForZero(float x) {
return x*x == 0;
}
@@ -1664,8 +1398,6 @@
return true;
}
-#endif
-
typedef bool (*PolyMapProc)(const SkPoint[], SkMatrix*, const SkPoint&);
/* Taken from Rob Johnson's original sample code in QuickDraw GX