The Tor Browser / file comparison

comparison: gfx/skia/patches/archive/skia_restrict_problem.patch

gfx/skia/patches/archive/skia_restrict_problem.patch

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:572ab1122227
1 diff --git a/gfx/skia/src/effects/SkGradientShader.cpp b/gfx/skia/src/effects/SkGradientShader.cpp
2 --- a/gfx/skia/src/effects/SkGradientShader.cpp
3 +++ b/gfx/skia/src/effects/SkGradientShader.cpp
4 @@ -1184,116 +1184,17 @@ public:
5 {
6 // make sure our table is insync with our current #define for kSQRT_TABLE_SIZE
7 SkASSERT(sizeof(gSqrt8Table) == kSQRT_TABLE_SIZE);
8
9 rad_to_unit_matrix(center, radius, &fPtsToUnit);
10 }
11
12 virtual void shadeSpan(int x, int y, SkPMColor* dstC, int count) SK_OVERRIDE;
13 - virtual void shadeSpan16(int x, int y, uint16_t* SK_RESTRICT dstC, int count) SK_OVERRIDE {
14 - SkASSERT(count > 0);
15 -
16 - SkPoint srcPt;
17 - SkMatrix::MapXYProc dstProc = fDstToIndexProc;
18 - TileProc proc = fTileProc;
19 - const uint16_t* SK_RESTRICT cache = this->getCache16();
20 - int toggle = ((x ^ y) & 1) << kCache16Bits;
21 -
22 - if (fDstToIndexClass != kPerspective_MatrixClass) {
23 - dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
24 - SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
25 - SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
26 - SkFixed dy, fy = SkScalarToFixed(srcPt.fY);
27 -
28 - if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
29 - SkFixed storage[2];
30 - (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &storage[0], &storage[1]);
31 - dx = storage[0];
32 - dy = storage[1];
33 - } else {
34 - SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
35 - dx = SkScalarToFixed(fDstToIndex.getScaleX());
36 - dy = SkScalarToFixed(fDstToIndex.getSkewY());
37 - }
38 -
39 - if (proc == clamp_tileproc) {
40 - const uint8_t* SK_RESTRICT sqrt_table = gSqrt8Table;
41 -
42 - /* knock these down so we can pin against +- 0x7FFF, which is an immediate load,
43 - rather than 0xFFFF which is slower. This is a compromise, since it reduces our
44 - precision, but that appears to be visually OK. If we decide this is OK for
45 - all of our cases, we could (it seems) put this scale-down into fDstToIndex,
46 - to avoid having to do these extra shifts each time.
47 - */
48 - fx >>= 1;
49 - dx >>= 1;
50 - fy >>= 1;
51 - dy >>= 1;
52 - if (dy == 0) { // might perform this check for the other modes, but the win will be a smaller % of the total
53 - fy = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
54 - fy *= fy;
55 - do {
56 - unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
57 - unsigned fi = (xx * xx + fy) >> (14 + 16 - kSQRT_TABLE_BITS);
58 - fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
59 - fx += dx;
60 - *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
61 - toggle ^= (1 << kCache16Bits);
62 - } while (--count != 0);
63 - } else {
64 - do {
65 - unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
66 - unsigned fi = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
67 - fi = (xx * xx + fi * fi) >> (14 + 16 - kSQRT_TABLE_BITS);
68 - fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
69 - fx += dx;
70 - fy += dy;
71 - *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
72 - toggle ^= (1 << kCache16Bits);
73 - } while (--count != 0);
74 - }
75 - } else if (proc == mirror_tileproc) {
76 - do {
77 - SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
78 - unsigned fi = mirror_tileproc(dist);
79 - SkASSERT(fi <= 0xFFFF);
80 - fx += dx;
81 - fy += dy;
82 - *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
83 - toggle ^= (1 << kCache16Bits);
84 - } while (--count != 0);
85 - } else {
86 - SkASSERT(proc == repeat_tileproc);
87 - do {
88 - SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
89 - unsigned fi = repeat_tileproc(dist);
90 - SkASSERT(fi <= 0xFFFF);
91 - fx += dx;
92 - fy += dy;
93 - *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
94 - toggle ^= (1 << kCache16Bits);
95 - } while (--count != 0);
96 - }
97 - } else { // perspective case
98 - SkScalar dstX = SkIntToScalar(x);
99 - SkScalar dstY = SkIntToScalar(y);
100 - do {
101 - dstProc(fDstToIndex, dstX, dstY, &srcPt);
102 - unsigned fi = proc(SkScalarToFixed(srcPt.length()));
103 - SkASSERT(fi <= 0xFFFF);
104 -
105 - int index = fi >> (16 - kCache16Bits);
106 - *dstC++ = cache[toggle + index];
107 - toggle ^= (1 << kCache16Bits);
108 -
109 - dstX += SK_Scalar1;
110 - } while (--count != 0);
111 - }
112 - }
113 + virtual void shadeSpan16(int x, int y, uint16_t* dstC, int count) SK_OVERRIDE;
114
115 virtual BitmapType asABitmap(SkBitmap* bitmap,
116 SkMatrix* matrix,
117 TileMode* xy,
118 SkScalar* twoPointRadialParams) const SK_OVERRIDE {
119 if (bitmap) {
120 this->commonAsABitmap(bitmap);
121 }
122 @@ -1507,16 +1408,117 @@ void Radial_Gradient::shadeSpan(int x, i
123 unsigned fi = proc(SkScalarToFixed(srcPt.length()));
124 SkASSERT(fi <= 0xFFFF);
125 *dstC++ = cache[fi >> (16 - kCache32Bits)];
126 dstX += SK_Scalar1;
127 } while (--count != 0);
128 }
129 }
130
131 +void Radial_Gradient::shadeSpan16(int x, int y, uint16_t* SK_RESTRICT dstC, int count) {
132 + SkASSERT(count > 0);
133 +
134 + SkPoint srcPt;
135 + SkMatrix::MapXYProc dstProc = fDstToIndexProc;
136 + TileProc proc = fTileProc;
137 + const uint16_t* SK_RESTRICT cache = this->getCache16();
138 + int toggle = ((x ^ y) & 1) << kCache16Bits;
139 +
140 + if (fDstToIndexClass != kPerspective_MatrixClass) {
141 + dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
142 + SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
143 + SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
144 + SkFixed dy, fy = SkScalarToFixed(srcPt.fY);
145 +
146 + if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
147 + SkFixed storage[2];
148 + (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &storage[0], &storage[1]);
149 + dx = storage[0];
150 + dy = storage[1];
151 + } else {
152 + SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
153 + dx = SkScalarToFixed(fDstToIndex.getScaleX());
154 + dy = SkScalarToFixed(fDstToIndex.getSkewY());
155 + }
156 +
157 + if (proc == clamp_tileproc) {
158 + const uint8_t* SK_RESTRICT sqrt_table = gSqrt8Table;
159 +
160 + /* knock these down so we can pin against +- 0x7FFF, which is an immediate load,
161 + rather than 0xFFFF which is slower. This is a compromise, since it reduces our
162 + precision, but that appears to be visually OK. If we decide this is OK for
163 + all of our cases, we could (it seems) put this scale-down into fDstToIndex,
164 + to avoid having to do these extra shifts each time.
165 + */
166 + fx >>= 1;
167 + dx >>= 1;
168 + fy >>= 1;
169 + dy >>= 1;
170 + if (dy == 0) { // might perform this check for the other modes, but the win will be a smaller % of the total
171 + fy = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
172 + fy *= fy;
173 + do {
174 + unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
175 + unsigned fi = (xx * xx + fy) >> (14 + 16 - kSQRT_TABLE_BITS);
176 + fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
177 + fx += dx;
178 + *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
179 + toggle ^= (1 << kCache16Bits);
180 + } while (--count != 0);
181 + } else {
182 + do {
183 + unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
184 + unsigned fi = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
185 + fi = (xx * xx + fi * fi) >> (14 + 16 - kSQRT_TABLE_BITS);
186 + fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
187 + fx += dx;
188 + fy += dy;
189 + *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
190 + toggle ^= (1 << kCache16Bits);
191 + } while (--count != 0);
192 + }
193 + } else if (proc == mirror_tileproc) {
194 + do {
195 + SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
196 + unsigned fi = mirror_tileproc(dist);
197 + SkASSERT(fi <= 0xFFFF);
198 + fx += dx;
199 + fy += dy;
200 + *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
201 + toggle ^= (1 << kCache16Bits);
202 + } while (--count != 0);
203 + } else {
204 + SkASSERT(proc == repeat_tileproc);
205 + do {
206 + SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
207 + unsigned fi = repeat_tileproc(dist);
208 + SkASSERT(fi <= 0xFFFF);
209 + fx += dx;
210 + fy += dy;
211 + *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
212 + toggle ^= (1 << kCache16Bits);
213 + } while (--count != 0);
214 + }
215 + } else { // perspective case
216 + SkScalar dstX = SkIntToScalar(x);
217 + SkScalar dstY = SkIntToScalar(y);
218 + do {
219 + dstProc(fDstToIndex, dstX, dstY, &srcPt);
220 + unsigned fi = proc(SkScalarToFixed(srcPt.length()));
221 + SkASSERT(fi <= 0xFFFF);
222 +
223 + int index = fi >> (16 - kCache16Bits);
224 + *dstC++ = cache[toggle + index];
225 + toggle ^= (1 << kCache16Bits);
226 +
227 + dstX += SK_Scalar1;
228 + } while (--count != 0);
229 + }
230 +}
231 +
232 /* Two-point radial gradients are specified by two circles, each with a center
233 point and radius. The gradient can be considered to be a series of
234 concentric circles, with the color interpolated from the start circle
235 (at t=0) to the end circle (at t=1).
236
237 For each point (x, y) in the span, we want to find the
238 interpolated circle that intersects that point. The center
239 of the desired circle (Cx, Cy) falls at some distance t
240 @@ -1661,109 +1663,17 @@ public:
241 info->fPoint[0] = fCenter1;
242 info->fPoint[1] = fCenter2;
243 info->fRadius[0] = fRadius1;
244 info->fRadius[1] = fRadius2;
245 }
246 return kRadial2_GradientType;
247 }
248
249 - virtual void shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC, int count) SK_OVERRIDE {
250 - SkASSERT(count > 0);
251 -
252 - // Zero difference between radii: fill with transparent black.
253 - // TODO: Is removing this actually correct? Two circles with the
254 - // same radius, but different centers doesn't sound like it
255 - // should be cleared
256 - if (fDiffRadius == 0 && fCenter1 == fCenter2) {
257 - sk_bzero(dstC, count * sizeof(*dstC));
258 - return;
259 - }
260 - SkMatrix::MapXYProc dstProc = fDstToIndexProc;
261 - TileProc proc = fTileProc;
262 - const SkPMColor* SK_RESTRICT cache = this->getCache32();
263 -
264 - SkScalar foura = fA * 4;
265 - bool posRoot = fDiffRadius < 0;
266 - if (fDstToIndexClass != kPerspective_MatrixClass) {
267 - SkPoint srcPt;
268 - dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
269 - SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
270 - SkScalar dx, fx = srcPt.fX;
271 - SkScalar dy, fy = srcPt.fY;
272 -
273 - if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
274 - SkFixed fixedX, fixedY;
275 - (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY);
276 - dx = SkFixedToScalar(fixedX);
277 - dy = SkFixedToScalar(fixedY);
278 - } else {
279 - SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
280 - dx = fDstToIndex.getScaleX();
281 - dy = fDstToIndex.getSkewY();
282 - }
283 - SkScalar b = (SkScalarMul(fDiff.fX, fx) +
284 - SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
285 - SkScalar db = (SkScalarMul(fDiff.fX, dx) +
286 - SkScalarMul(fDiff.fY, dy)) * 2;
287 - if (proc == clamp_tileproc) {
288 - for (; count > 0; --count) {
289 - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
290 - if (t < 0) {
291 - *dstC++ = cache[-1];
292 - } else if (t > 0xFFFF) {
293 - *dstC++ = cache[kCache32Count * 2];
294 - } else {
295 - SkASSERT(t <= 0xFFFF);
296 - *dstC++ = cache[t >> (16 - kCache32Bits)];
297 - }
298 - fx += dx;
299 - fy += dy;
300 - b += db;
301 - }
302 - } else if (proc == mirror_tileproc) {
303 - for (; count > 0; --count) {
304 - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
305 - SkFixed index = mirror_tileproc(t);
306 - SkASSERT(index <= 0xFFFF);
307 - *dstC++ = cache[index >> (16 - kCache32Bits)];
308 - fx += dx;
309 - fy += dy;
310 - b += db;
311 - }
312 - } else {
313 - SkASSERT(proc == repeat_tileproc);
314 - for (; count > 0; --count) {
315 - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
316 - SkFixed index = repeat_tileproc(t);
317 - SkASSERT(index <= 0xFFFF);
318 - *dstC++ = cache[index >> (16 - kCache32Bits)];
319 - fx += dx;
320 - fy += dy;
321 - b += db;
322 - }
323 - }
324 - } else { // perspective case
325 - SkScalar dstX = SkIntToScalar(x);
326 - SkScalar dstY = SkIntToScalar(y);
327 - for (; count > 0; --count) {
328 - SkPoint srcPt;
329 - dstProc(fDstToIndex, dstX, dstY, &srcPt);
330 - SkScalar fx = srcPt.fX;
331 - SkScalar fy = srcPt.fY;
332 - SkScalar b = (SkScalarMul(fDiff.fX, fx) +
333 - SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
334 - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
335 - SkFixed index = proc(t);
336 - SkASSERT(index <= 0xFFFF);
337 - *dstC++ = cache[index >> (16 - kCache32Bits)];
338 - dstX += SK_Scalar1;
339 - }
340 - }
341 - }
342 + virtual void shadeSpan(int x, int y, SkPMColor* dstC, int count) SK_OVERRIDE;
343
344 virtual bool setContext(const SkBitmap& device,
345 const SkPaint& paint,
346 const SkMatrix& matrix) SK_OVERRIDE {
347 if (!this->INHERITED::setContext(device, paint, matrix)) {
348 return false;
349 }
350
351 @@ -1817,16 +1727,110 @@ private:
352 fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1;
353 fOneOverTwoA = fA ? SkScalarInvert(fA * 2) : 0;
354
355 fPtsToUnit.setTranslate(-fCenter1.fX, -fCenter1.fY);
356 fPtsToUnit.postScale(inv, inv);
357 }
358 };
359
360 +void Two_Point_Radial_Gradient::shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC, int count) {
361 + SkASSERT(count > 0);
362 +
363 + // Zero difference between radii: fill with transparent black.
364 + // TODO: Is removing this actually correct? Two circles with the
365 + // same radius, but different centers doesn't sound like it
366 + // should be cleared
367 + if (fDiffRadius == 0 && fCenter1 == fCenter2) {
368 + sk_bzero(dstC, count * sizeof(*dstC));
369 + return;
370 + }
371 + SkMatrix::MapXYProc dstProc = fDstToIndexProc;
372 + TileProc proc = fTileProc;
373 + const SkPMColor* SK_RESTRICT cache = this->getCache32();
374 +
375 + SkScalar foura = fA * 4;
376 + bool posRoot = fDiffRadius < 0;
377 + if (fDstToIndexClass != kPerspective_MatrixClass) {
378 + SkPoint srcPt;
379 + dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
380 + SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
381 + SkScalar dx, fx = srcPt.fX;
382 + SkScalar dy, fy = srcPt.fY;
383 +
384 + if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
385 + SkFixed fixedX, fixedY;
386 + (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY);
387 + dx = SkFixedToScalar(fixedX);
388 + dy = SkFixedToScalar(fixedY);
389 + } else {
390 + SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
391 + dx = fDstToIndex.getScaleX();
392 + dy = fDstToIndex.getSkewY();
393 + }
394 + SkScalar b = (SkScalarMul(fDiff.fX, fx) +
395 + SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
396 + SkScalar db = (SkScalarMul(fDiff.fX, dx) +
397 + SkScalarMul(fDiff.fY, dy)) * 2;
398 + if (proc == clamp_tileproc) {
399 + for (; count > 0; --count) {
400 + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
401 + if (t < 0) {
402 + *dstC++ = cache[-1];
403 + } else if (t > 0xFFFF) {
404 + *dstC++ = cache[kCache32Count * 2];
405 + } else {
406 + SkASSERT(t <= 0xFFFF);
407 + *dstC++ = cache[t >> (16 - kCache32Bits)];
408 + }
409 + fx += dx;
410 + fy += dy;
411 + b += db;
412 + }
413 + } else if (proc == mirror_tileproc) {
414 + for (; count > 0; --count) {
415 + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
416 + SkFixed index = mirror_tileproc(t);
417 + SkASSERT(index <= 0xFFFF);
418 + *dstC++ = cache[index >> (16 - kCache32Bits)];
419 + fx += dx;
420 + fy += dy;
421 + b += db;
422 + }
423 + } else {
424 + SkASSERT(proc == repeat_tileproc);
425 + for (; count > 0; --count) {
426 + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
427 + SkFixed index = repeat_tileproc(t);
428 + SkASSERT(index <= 0xFFFF);
429 + *dstC++ = cache[index >> (16 - kCache32Bits)];
430 + fx += dx;
431 + fy += dy;
432 + b += db;
433 + }
434 + }
435 + } else { // perspective case
436 + SkScalar dstX = SkIntToScalar(x);
437 + SkScalar dstY = SkIntToScalar(y);
438 + for (; count > 0; --count) {
439 + SkPoint srcPt;
440 + dstProc(fDstToIndex, dstX, dstY, &srcPt);
441 + SkScalar fx = srcPt.fX;
442 + SkScalar fy = srcPt.fY;
443 + SkScalar b = (SkScalarMul(fDiff.fX, fx) +
444 + SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
445 + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
446 + SkFixed index = proc(t);
447 + SkASSERT(index <= 0xFFFF);
448 + *dstC++ = cache[index >> (16 - kCache32Bits)];
449 + dstX += SK_Scalar1;
450 + }
451 + }
452 +}
453 +
454 ///////////////////////////////////////////////////////////////////////////////
455
456 class Sweep_Gradient : public Gradient_Shader {
457 public:
458 Sweep_Gradient(SkScalar cx, SkScalar cy, const SkColor colors[],
459 const SkScalar pos[], int count, SkUnitMapper* mapper)
460 : Gradient_Shader(colors, pos, count, SkShader::kClamp_TileMode, mapper),
461 fCenter(SkPoint::Make(cx, cy))

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial