1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/gfx/skia/patches/archive/skia_restrict_problem.patch Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,461 @@
1.4 +diff --git a/gfx/skia/src/effects/SkGradientShader.cpp b/gfx/skia/src/effects/SkGradientShader.cpp
1.5 +--- a/gfx/skia/src/effects/SkGradientShader.cpp
1.6 ++++ b/gfx/skia/src/effects/SkGradientShader.cpp
1.7 +@@ -1184,116 +1184,17 @@ public:
1.8 + {
1.9 + // make sure our table is insync with our current #define for kSQRT_TABLE_SIZE
1.10 + SkASSERT(sizeof(gSqrt8Table) == kSQRT_TABLE_SIZE);
1.11 +
1.12 + rad_to_unit_matrix(center, radius, &fPtsToUnit);
1.13 + }
1.14 +
1.15 + virtual void shadeSpan(int x, int y, SkPMColor* dstC, int count) SK_OVERRIDE;
1.16 +- virtual void shadeSpan16(int x, int y, uint16_t* SK_RESTRICT dstC, int count) SK_OVERRIDE {
1.17 +- SkASSERT(count > 0);
1.18 +-
1.19 +- SkPoint srcPt;
1.20 +- SkMatrix::MapXYProc dstProc = fDstToIndexProc;
1.21 +- TileProc proc = fTileProc;
1.22 +- const uint16_t* SK_RESTRICT cache = this->getCache16();
1.23 +- int toggle = ((x ^ y) & 1) << kCache16Bits;
1.24 +-
1.25 +- if (fDstToIndexClass != kPerspective_MatrixClass) {
1.26 +- dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
1.27 +- SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
1.28 +- SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
1.29 +- SkFixed dy, fy = SkScalarToFixed(srcPt.fY);
1.30 +-
1.31 +- if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
1.32 +- SkFixed storage[2];
1.33 +- (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &storage[0], &storage[1]);
1.34 +- dx = storage[0];
1.35 +- dy = storage[1];
1.36 +- } else {
1.37 +- SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
1.38 +- dx = SkScalarToFixed(fDstToIndex.getScaleX());
1.39 +- dy = SkScalarToFixed(fDstToIndex.getSkewY());
1.40 +- }
1.41 +-
1.42 +- if (proc == clamp_tileproc) {
1.43 +- const uint8_t* SK_RESTRICT sqrt_table = gSqrt8Table;
1.44 +-
1.45 +- /* knock these down so we can pin against +- 0x7FFF, which is an immediate load,
1.46 +- rather than 0xFFFF which is slower. This is a compromise, since it reduces our
1.47 +- precision, but that appears to be visually OK. If we decide this is OK for
1.48 +- all of our cases, we could (it seems) put this scale-down into fDstToIndex,
1.49 +- to avoid having to do these extra shifts each time.
1.50 +- */
1.51 +- fx >>= 1;
1.52 +- dx >>= 1;
1.53 +- fy >>= 1;
1.54 +- dy >>= 1;
1.55 +- if (dy == 0) { // might perform this check for the other modes, but the win will be a smaller % of the total
1.56 +- fy = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
1.57 +- fy *= fy;
1.58 +- do {
1.59 +- unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
1.60 +- unsigned fi = (xx * xx + fy) >> (14 + 16 - kSQRT_TABLE_BITS);
1.61 +- fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
1.62 +- fx += dx;
1.63 +- *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
1.64 +- toggle ^= (1 << kCache16Bits);
1.65 +- } while (--count != 0);
1.66 +- } else {
1.67 +- do {
1.68 +- unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
1.69 +- unsigned fi = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
1.70 +- fi = (xx * xx + fi * fi) >> (14 + 16 - kSQRT_TABLE_BITS);
1.71 +- fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
1.72 +- fx += dx;
1.73 +- fy += dy;
1.74 +- *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
1.75 +- toggle ^= (1 << kCache16Bits);
1.76 +- } while (--count != 0);
1.77 +- }
1.78 +- } else if (proc == mirror_tileproc) {
1.79 +- do {
1.80 +- SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
1.81 +- unsigned fi = mirror_tileproc(dist);
1.82 +- SkASSERT(fi <= 0xFFFF);
1.83 +- fx += dx;
1.84 +- fy += dy;
1.85 +- *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
1.86 +- toggle ^= (1 << kCache16Bits);
1.87 +- } while (--count != 0);
1.88 +- } else {
1.89 +- SkASSERT(proc == repeat_tileproc);
1.90 +- do {
1.91 +- SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
1.92 +- unsigned fi = repeat_tileproc(dist);
1.93 +- SkASSERT(fi <= 0xFFFF);
1.94 +- fx += dx;
1.95 +- fy += dy;
1.96 +- *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
1.97 +- toggle ^= (1 << kCache16Bits);
1.98 +- } while (--count != 0);
1.99 +- }
1.100 +- } else { // perspective case
1.101 +- SkScalar dstX = SkIntToScalar(x);
1.102 +- SkScalar dstY = SkIntToScalar(y);
1.103 +- do {
1.104 +- dstProc(fDstToIndex, dstX, dstY, &srcPt);
1.105 +- unsigned fi = proc(SkScalarToFixed(srcPt.length()));
1.106 +- SkASSERT(fi <= 0xFFFF);
1.107 +-
1.108 +- int index = fi >> (16 - kCache16Bits);
1.109 +- *dstC++ = cache[toggle + index];
1.110 +- toggle ^= (1 << kCache16Bits);
1.111 +-
1.112 +- dstX += SK_Scalar1;
1.113 +- } while (--count != 0);
1.114 +- }
1.115 +- }
1.116 ++ virtual void shadeSpan16(int x, int y, uint16_t* dstC, int count) SK_OVERRIDE;
1.117 +
1.118 + virtual BitmapType asABitmap(SkBitmap* bitmap,
1.119 + SkMatrix* matrix,
1.120 + TileMode* xy,
1.121 + SkScalar* twoPointRadialParams) const SK_OVERRIDE {
1.122 + if (bitmap) {
1.123 + this->commonAsABitmap(bitmap);
1.124 + }
1.125 +@@ -1507,16 +1408,117 @@ void Radial_Gradient::shadeSpan(int x, i
1.126 + unsigned fi = proc(SkScalarToFixed(srcPt.length()));
1.127 + SkASSERT(fi <= 0xFFFF);
1.128 + *dstC++ = cache[fi >> (16 - kCache32Bits)];
1.129 + dstX += SK_Scalar1;
1.130 + } while (--count != 0);
1.131 + }
1.132 + }
1.133 +
1.134 ++void Radial_Gradient::shadeSpan16(int x, int y, uint16_t* SK_RESTRICT dstC, int count) {
1.135 ++ SkASSERT(count > 0);
1.136 ++
1.137 ++ SkPoint srcPt;
1.138 ++ SkMatrix::MapXYProc dstProc = fDstToIndexProc;
1.139 ++ TileProc proc = fTileProc;
1.140 ++ const uint16_t* SK_RESTRICT cache = this->getCache16();
1.141 ++ int toggle = ((x ^ y) & 1) << kCache16Bits;
1.142 ++
1.143 ++ if (fDstToIndexClass != kPerspective_MatrixClass) {
1.144 ++ dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
1.145 ++ SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
1.146 ++ SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
1.147 ++ SkFixed dy, fy = SkScalarToFixed(srcPt.fY);
1.148 ++
1.149 ++ if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
1.150 ++ SkFixed storage[2];
1.151 ++ (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &storage[0], &storage[1]);
1.152 ++ dx = storage[0];
1.153 ++ dy = storage[1];
1.154 ++ } else {
1.155 ++ SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
1.156 ++ dx = SkScalarToFixed(fDstToIndex.getScaleX());
1.157 ++ dy = SkScalarToFixed(fDstToIndex.getSkewY());
1.158 ++ }
1.159 ++
1.160 ++ if (proc == clamp_tileproc) {
1.161 ++ const uint8_t* SK_RESTRICT sqrt_table = gSqrt8Table;
1.162 ++
1.163 ++ /* knock these down so we can pin against +- 0x7FFF, which is an immediate load,
1.164 ++ rather than 0xFFFF which is slower. This is a compromise, since it reduces our
1.165 ++ precision, but that appears to be visually OK. If we decide this is OK for
1.166 ++ all of our cases, we could (it seems) put this scale-down into fDstToIndex,
1.167 ++ to avoid having to do these extra shifts each time.
1.168 ++ */
1.169 ++ fx >>= 1;
1.170 ++ dx >>= 1;
1.171 ++ fy >>= 1;
1.172 ++ dy >>= 1;
1.173 ++ if (dy == 0) { // might perform this check for the other modes, but the win will be a smaller % of the total
1.174 ++ fy = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
1.175 ++ fy *= fy;
1.176 ++ do {
1.177 ++ unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
1.178 ++ unsigned fi = (xx * xx + fy) >> (14 + 16 - kSQRT_TABLE_BITS);
1.179 ++ fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
1.180 ++ fx += dx;
1.181 ++ *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
1.182 ++ toggle ^= (1 << kCache16Bits);
1.183 ++ } while (--count != 0);
1.184 ++ } else {
1.185 ++ do {
1.186 ++ unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
1.187 ++ unsigned fi = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
1.188 ++ fi = (xx * xx + fi * fi) >> (14 + 16 - kSQRT_TABLE_BITS);
1.189 ++ fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
1.190 ++ fx += dx;
1.191 ++ fy += dy;
1.192 ++ *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
1.193 ++ toggle ^= (1 << kCache16Bits);
1.194 ++ } while (--count != 0);
1.195 ++ }
1.196 ++ } else if (proc == mirror_tileproc) {
1.197 ++ do {
1.198 ++ SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
1.199 ++ unsigned fi = mirror_tileproc(dist);
1.200 ++ SkASSERT(fi <= 0xFFFF);
1.201 ++ fx += dx;
1.202 ++ fy += dy;
1.203 ++ *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
1.204 ++ toggle ^= (1 << kCache16Bits);
1.205 ++ } while (--count != 0);
1.206 ++ } else {
1.207 ++ SkASSERT(proc == repeat_tileproc);
1.208 ++ do {
1.209 ++ SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
1.210 ++ unsigned fi = repeat_tileproc(dist);
1.211 ++ SkASSERT(fi <= 0xFFFF);
1.212 ++ fx += dx;
1.213 ++ fy += dy;
1.214 ++ *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
1.215 ++ toggle ^= (1 << kCache16Bits);
1.216 ++ } while (--count != 0);
1.217 ++ }
1.218 ++ } else { // perspective case
1.219 ++ SkScalar dstX = SkIntToScalar(x);
1.220 ++ SkScalar dstY = SkIntToScalar(y);
1.221 ++ do {
1.222 ++ dstProc(fDstToIndex, dstX, dstY, &srcPt);
1.223 ++ unsigned fi = proc(SkScalarToFixed(srcPt.length()));
1.224 ++ SkASSERT(fi <= 0xFFFF);
1.225 ++
1.226 ++ int index = fi >> (16 - kCache16Bits);
1.227 ++ *dstC++ = cache[toggle + index];
1.228 ++ toggle ^= (1 << kCache16Bits);
1.229 ++
1.230 ++ dstX += SK_Scalar1;
1.231 ++ } while (--count != 0);
1.232 ++ }
1.233 ++}
1.234 ++
1.235 + /* Two-point radial gradients are specified by two circles, each with a center
1.236 + point and radius. The gradient can be considered to be a series of
1.237 + concentric circles, with the color interpolated from the start circle
1.238 + (at t=0) to the end circle (at t=1).
1.239 +
1.240 + For each point (x, y) in the span, we want to find the
1.241 + interpolated circle that intersects that point. The center
1.242 + of the desired circle (Cx, Cy) falls at some distance t
1.243 +@@ -1661,109 +1663,17 @@ public:
1.244 + info->fPoint[0] = fCenter1;
1.245 + info->fPoint[1] = fCenter2;
1.246 + info->fRadius[0] = fRadius1;
1.247 + info->fRadius[1] = fRadius2;
1.248 + }
1.249 + return kRadial2_GradientType;
1.250 + }
1.251 +
1.252 +- virtual void shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC, int count) SK_OVERRIDE {
1.253 +- SkASSERT(count > 0);
1.254 +-
1.255 +- // Zero difference between radii: fill with transparent black.
1.256 +- // TODO: Is removing this actually correct? Two circles with the
1.257 +- // same radius, but different centers doesn't sound like it
1.258 +- // should be cleared
1.259 +- if (fDiffRadius == 0 && fCenter1 == fCenter2) {
1.260 +- sk_bzero(dstC, count * sizeof(*dstC));
1.261 +- return;
1.262 +- }
1.263 +- SkMatrix::MapXYProc dstProc = fDstToIndexProc;
1.264 +- TileProc proc = fTileProc;
1.265 +- const SkPMColor* SK_RESTRICT cache = this->getCache32();
1.266 +-
1.267 +- SkScalar foura = fA * 4;
1.268 +- bool posRoot = fDiffRadius < 0;
1.269 +- if (fDstToIndexClass != kPerspective_MatrixClass) {
1.270 +- SkPoint srcPt;
1.271 +- dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
1.272 +- SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
1.273 +- SkScalar dx, fx = srcPt.fX;
1.274 +- SkScalar dy, fy = srcPt.fY;
1.275 +-
1.276 +- if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
1.277 +- SkFixed fixedX, fixedY;
1.278 +- (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY);
1.279 +- dx = SkFixedToScalar(fixedX);
1.280 +- dy = SkFixedToScalar(fixedY);
1.281 +- } else {
1.282 +- SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
1.283 +- dx = fDstToIndex.getScaleX();
1.284 +- dy = fDstToIndex.getSkewY();
1.285 +- }
1.286 +- SkScalar b = (SkScalarMul(fDiff.fX, fx) +
1.287 +- SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
1.288 +- SkScalar db = (SkScalarMul(fDiff.fX, dx) +
1.289 +- SkScalarMul(fDiff.fY, dy)) * 2;
1.290 +- if (proc == clamp_tileproc) {
1.291 +- for (; count > 0; --count) {
1.292 +- SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
1.293 +- if (t < 0) {
1.294 +- *dstC++ = cache[-1];
1.295 +- } else if (t > 0xFFFF) {
1.296 +- *dstC++ = cache[kCache32Count * 2];
1.297 +- } else {
1.298 +- SkASSERT(t <= 0xFFFF);
1.299 +- *dstC++ = cache[t >> (16 - kCache32Bits)];
1.300 +- }
1.301 +- fx += dx;
1.302 +- fy += dy;
1.303 +- b += db;
1.304 +- }
1.305 +- } else if (proc == mirror_tileproc) {
1.306 +- for (; count > 0; --count) {
1.307 +- SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
1.308 +- SkFixed index = mirror_tileproc(t);
1.309 +- SkASSERT(index <= 0xFFFF);
1.310 +- *dstC++ = cache[index >> (16 - kCache32Bits)];
1.311 +- fx += dx;
1.312 +- fy += dy;
1.313 +- b += db;
1.314 +- }
1.315 +- } else {
1.316 +- SkASSERT(proc == repeat_tileproc);
1.317 +- for (; count > 0; --count) {
1.318 +- SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
1.319 +- SkFixed index = repeat_tileproc(t);
1.320 +- SkASSERT(index <= 0xFFFF);
1.321 +- *dstC++ = cache[index >> (16 - kCache32Bits)];
1.322 +- fx += dx;
1.323 +- fy += dy;
1.324 +- b += db;
1.325 +- }
1.326 +- }
1.327 +- } else { // perspective case
1.328 +- SkScalar dstX = SkIntToScalar(x);
1.329 +- SkScalar dstY = SkIntToScalar(y);
1.330 +- for (; count > 0; --count) {
1.331 +- SkPoint srcPt;
1.332 +- dstProc(fDstToIndex, dstX, dstY, &srcPt);
1.333 +- SkScalar fx = srcPt.fX;
1.334 +- SkScalar fy = srcPt.fY;
1.335 +- SkScalar b = (SkScalarMul(fDiff.fX, fx) +
1.336 +- SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
1.337 +- SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
1.338 +- SkFixed index = proc(t);
1.339 +- SkASSERT(index <= 0xFFFF);
1.340 +- *dstC++ = cache[index >> (16 - kCache32Bits)];
1.341 +- dstX += SK_Scalar1;
1.342 +- }
1.343 +- }
1.344 +- }
1.345 ++ virtual void shadeSpan(int x, int y, SkPMColor* dstC, int count) SK_OVERRIDE;
1.346 +
1.347 + virtual bool setContext(const SkBitmap& device,
1.348 + const SkPaint& paint,
1.349 + const SkMatrix& matrix) SK_OVERRIDE {
1.350 + if (!this->INHERITED::setContext(device, paint, matrix)) {
1.351 + return false;
1.352 + }
1.353 +
1.354 +@@ -1817,16 +1727,110 @@ private:
1.355 + fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1;
1.356 + fOneOverTwoA = fA ? SkScalarInvert(fA * 2) : 0;
1.357 +
1.358 + fPtsToUnit.setTranslate(-fCenter1.fX, -fCenter1.fY);
1.359 + fPtsToUnit.postScale(inv, inv);
1.360 + }
1.361 + };
1.362 +
1.363 ++void Two_Point_Radial_Gradient::shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC, int count) {
1.364 ++ SkASSERT(count > 0);
1.365 ++
1.366 ++ // Zero difference between radii: fill with transparent black.
1.367 ++ // TODO: Is removing this actually correct? Two circles with the
1.368 ++ // same radius, but different centers doesn't sound like it
1.369 ++ // should be cleared
1.370 ++ if (fDiffRadius == 0 && fCenter1 == fCenter2) {
1.371 ++ sk_bzero(dstC, count * sizeof(*dstC));
1.372 ++ return;
1.373 ++ }
1.374 ++ SkMatrix::MapXYProc dstProc = fDstToIndexProc;
1.375 ++ TileProc proc = fTileProc;
1.376 ++ const SkPMColor* SK_RESTRICT cache = this->getCache32();
1.377 ++
1.378 ++ SkScalar foura = fA * 4;
1.379 ++ bool posRoot = fDiffRadius < 0;
1.380 ++ if (fDstToIndexClass != kPerspective_MatrixClass) {
1.381 ++ SkPoint srcPt;
1.382 ++ dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
1.383 ++ SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
1.384 ++ SkScalar dx, fx = srcPt.fX;
1.385 ++ SkScalar dy, fy = srcPt.fY;
1.386 ++
1.387 ++ if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
1.388 ++ SkFixed fixedX, fixedY;
1.389 ++ (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY);
1.390 ++ dx = SkFixedToScalar(fixedX);
1.391 ++ dy = SkFixedToScalar(fixedY);
1.392 ++ } else {
1.393 ++ SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
1.394 ++ dx = fDstToIndex.getScaleX();
1.395 ++ dy = fDstToIndex.getSkewY();
1.396 ++ }
1.397 ++ SkScalar b = (SkScalarMul(fDiff.fX, fx) +
1.398 ++ SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
1.399 ++ SkScalar db = (SkScalarMul(fDiff.fX, dx) +
1.400 ++ SkScalarMul(fDiff.fY, dy)) * 2;
1.401 ++ if (proc == clamp_tileproc) {
1.402 ++ for (; count > 0; --count) {
1.403 ++ SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
1.404 ++ if (t < 0) {
1.405 ++ *dstC++ = cache[-1];
1.406 ++ } else if (t > 0xFFFF) {
1.407 ++ *dstC++ = cache[kCache32Count * 2];
1.408 ++ } else {
1.409 ++ SkASSERT(t <= 0xFFFF);
1.410 ++ *dstC++ = cache[t >> (16 - kCache32Bits)];
1.411 ++ }
1.412 ++ fx += dx;
1.413 ++ fy += dy;
1.414 ++ b += db;
1.415 ++ }
1.416 ++ } else if (proc == mirror_tileproc) {
1.417 ++ for (; count > 0; --count) {
1.418 ++ SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
1.419 ++ SkFixed index = mirror_tileproc(t);
1.420 ++ SkASSERT(index <= 0xFFFF);
1.421 ++ *dstC++ = cache[index >> (16 - kCache32Bits)];
1.422 ++ fx += dx;
1.423 ++ fy += dy;
1.424 ++ b += db;
1.425 ++ }
1.426 ++ } else {
1.427 ++ SkASSERT(proc == repeat_tileproc);
1.428 ++ for (; count > 0; --count) {
1.429 ++ SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
1.430 ++ SkFixed index = repeat_tileproc(t);
1.431 ++ SkASSERT(index <= 0xFFFF);
1.432 ++ *dstC++ = cache[index >> (16 - kCache32Bits)];
1.433 ++ fx += dx;
1.434 ++ fy += dy;
1.435 ++ b += db;
1.436 ++ }
1.437 ++ }
1.438 ++ } else { // perspective case
1.439 ++ SkScalar dstX = SkIntToScalar(x);
1.440 ++ SkScalar dstY = SkIntToScalar(y);
1.441 ++ for (; count > 0; --count) {
1.442 ++ SkPoint srcPt;
1.443 ++ dstProc(fDstToIndex, dstX, dstY, &srcPt);
1.444 ++ SkScalar fx = srcPt.fX;
1.445 ++ SkScalar fy = srcPt.fY;
1.446 ++ SkScalar b = (SkScalarMul(fDiff.fX, fx) +
1.447 ++ SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
1.448 ++ SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
1.449 ++ SkFixed index = proc(t);
1.450 ++ SkASSERT(index <= 0xFFFF);
1.451 ++ *dstC++ = cache[index >> (16 - kCache32Bits)];
1.452 ++ dstX += SK_Scalar1;
1.453 ++ }
1.454 ++ }
1.455 ++}
1.456 ++
1.457 + ///////////////////////////////////////////////////////////////////////////////
1.458 +
1.459 + class Sweep_Gradient : public Gradient_Shader {
1.460 + public:
1.461 + Sweep_Gradient(SkScalar cx, SkScalar cy, const SkColor colors[],
1.462 + const SkScalar pos[], int count, SkUnitMapper* mapper)
1.463 + : Gradient_Shader(colors, pos, count, SkShader::kClamp_TileMode, mapper),
1.464 + fCenter(SkPoint::Make(cx, cy))
