GradientTest.cpp revision c52310402c56e535e574a0a53e2355e5350e952d 
1/*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "SkCanvas.h"
9#include "SkColorPriv.h"
10#include "SkColorShader.h"
11#include "SkGradientShader.h"
12#include "SkShader.h"
13#include "SkSurface.h"
14#include "SkTemplates.h"
15#include "Test.h"
16
17// https://code.google.com/p/chromium/issues/detail?id=448299
18// Giant (inverse) matrix causes overflow when converting/computing using 32.32
19// Before the fix, we would assert (and then crash).
20static void test_big_grad(skiatest::Reporter* reporter) {
21    const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
22    const SkPoint pts[] = {{ 15, 14.7112684f }, { 0.709064007f, 12.6108112f }};
23    SkPaint paint;
24    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
25                                                 SkShader::kClamp_TileMode));
26
27    SkBitmap bm;
28    bm.allocN32Pixels(2000, 1);
29    SkCanvas c(bm);
30
31    const SkScalar affine[] = {
32        1.06608627e-06f, 4.26434525e-07f, 6.2855f, 2.6611f, 273.4393f, 244.0046f
33    };
34    SkMatrix matrix;
35    matrix.setAffine(affine);
36    c.concat(matrix);
37
38    c.drawPaint(paint);
39}
40
41struct GradRec {
42    int             fColorCount;
43    const SkColor*  fColors;
44    const SkScalar* fPos;
45    const SkPoint*  fPoint;   // 2
46    const SkScalar* fRadius; // 2
47    SkShader::TileMode fTileMode;
48
49    void gradCheck(skiatest::Reporter* reporter, const sk_sp<SkShader>& shader,
50                   SkShader::GradientInfo* info,
51                   SkShader::GradientType gt) const {
52        SkAutoTMalloc<SkColor> colorStorage(fColorCount);
53        SkAutoTMalloc<SkScalar> posStorage(fColorCount);
54
55        info->fColorCount = fColorCount;
56        info->fColors = colorStorage;
57        info->fColorOffsets = posStorage.get();
58        REPORTER_ASSERT(reporter, shader->asAGradient(info) == gt);
59
60        REPORTER_ASSERT(reporter, info->fColorCount == fColorCount);
61        REPORTER_ASSERT(reporter,
62                        !memcmp(info->fColors, fColors, fColorCount * sizeof(SkColor)));
63        REPORTER_ASSERT(reporter,
64                        !memcmp(info->fColorOffsets, fPos, fColorCount * sizeof(SkScalar)));
65        REPORTER_ASSERT(reporter, fTileMode == info->fTileMode);
66    }
67};
68
69
70static void none_gradproc(skiatest::Reporter* reporter, const GradRec&) {
71    sk_sp<SkShader> s(SkShader::MakeEmptyShader());
72    REPORTER_ASSERT(reporter, SkShader::kNone_GradientType == s->asAGradient(nullptr));
73}
74
75static void color_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
76    SkAutoTUnref<SkShader> s(new SkColorShader(rec.fColors[0]));
77    REPORTER_ASSERT(reporter, SkShader::kColor_GradientType == s->asAGradient(nullptr));
78
79    SkShader::GradientInfo info;
80    info.fColors = nullptr;
81    info.fColorCount = 0;
82    s->asAGradient(&info);
83    REPORTER_ASSERT(reporter, 1 == info.fColorCount);
84}
85
86static void linear_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
87    sk_sp<SkShader> s(SkGradientShader::MakeLinear(rec.fPoint, rec.fColors, rec.fPos,
88                                                   rec.fColorCount, rec.fTileMode));
89
90    SkShader::GradientInfo info;
91    rec.gradCheck(reporter, s, &info, SkShader::kLinear_GradientType);
92    REPORTER_ASSERT(reporter, !memcmp(info.fPoint, rec.fPoint, 2 * sizeof(SkPoint)));
93}
94
95static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
96    sk_sp<SkShader> s(SkGradientShader::MakeRadial(rec.fPoint[0], rec.fRadius[0], rec.fColors,
97                                                   rec.fPos, rec.fColorCount, rec.fTileMode));
98
99    SkShader::GradientInfo info;
100    rec.gradCheck(reporter, s, &info, SkShader::kRadial_GradientType);
101    REPORTER_ASSERT(reporter, info.fPoint[0] == rec.fPoint[0]);
102    REPORTER_ASSERT(reporter, info.fRadius[0] == rec.fRadius[0]);
103}
104
105static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
106    sk_sp<SkShader> s(SkGradientShader::MakeSweep(rec.fPoint[0].fX, rec.fPoint[0].fY, rec.fColors,
107                                                  rec.fPos, rec.fColorCount));
108
109    SkShader::GradientInfo info;
110    rec.gradCheck(reporter, s, &info, SkShader::kSweep_GradientType);
111    REPORTER_ASSERT(reporter, info.fPoint[0] == rec.fPoint[0]);
112}
113
114static void conical_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
115    sk_sp<SkShader> s(SkGradientShader::MakeTwoPointConical(rec.fPoint[0],
116                                                            rec.fRadius[0],
117                                                            rec.fPoint[1],
118                                                            rec.fRadius[1],
119                                                            rec.fColors,
120                                                            rec.fPos,
121                                                            rec.fColorCount,
122                                                            rec.fTileMode));
123
124    SkShader::GradientInfo info;
125    rec.gradCheck(reporter, s, &info, SkShader::kConical_GradientType);
126    REPORTER_ASSERT(reporter, !memcmp(info.fPoint, rec.fPoint, 2 * sizeof(SkPoint)));
127    REPORTER_ASSERT(reporter, !memcmp(info.fRadius, rec.fRadius, 2 * sizeof(SkScalar)));
128}
129
130// Ensure that repeated color gradients behave like drawing a single color
131static void TestConstantGradient(skiatest::Reporter*) {
132    const SkPoint pts[] = {
133        { 0, 0 },
134        { SkIntToScalar(10), 0 }
135    };
136    SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE };
137    const SkScalar pos[] = { 0, SK_Scalar1 };
138    SkPaint paint;
139    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
140    SkBitmap outBitmap;
141    outBitmap.allocN32Pixels(10, 1);
142    SkCanvas canvas(outBitmap);
143    canvas.drawPaint(paint);
144    SkAutoLockPixels alp(outBitmap);
145    for (int i = 0; i < 10; i++) {
146        // The following is commented out because it currently fails
147        // Related bug: https://code.google.com/p/skia/issues/detail?id=1098
148
149        // REPORTER_ASSERT(reporter, SK_ColorBLUE == outBitmap.getColor(i, 0));
150    }
151}
152
153typedef void (*GradProc)(skiatest::Reporter* reporter, const GradRec&);
154
155static void TestGradientShaders(skiatest::Reporter* reporter) {
156    static const SkColor gColors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
157    static const SkScalar gPos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
158    static const SkPoint gPts[] = {
159        { 0, 0 },
160        { SkIntToScalar(10), SkIntToScalar(20) }
161    };
162    static const SkScalar gRad[] = { SkIntToScalar(1), SkIntToScalar(2) };
163
164    GradRec rec;
165    rec.fColorCount = SK_ARRAY_COUNT(gColors);
166    rec.fColors = gColors;
167    rec.fPos = gPos;
168    rec.fPoint = gPts;
169    rec.fRadius = gRad;
170    rec.fTileMode = SkShader::kClamp_TileMode;
171
172    static const GradProc gProcs[] = {
173        none_gradproc,
174        color_gradproc,
175        linear_gradproc,
176        radial_gradproc,
177        sweep_gradproc,
178        conical_gradproc,
179    };
180
181    for (size_t i = 0; i < SK_ARRAY_COUNT(gProcs); ++i) {
182        gProcs[i](reporter, rec);
183    }
184}
185
186static void test_nearly_vertical(skiatest::Reporter* reporter) {
187    auto surface(SkSurface::MakeRasterN32Premul(200, 200));
188
189    const SkPoint pts[] = {{ 100, 50 }, { 100.0001f, 50000 }};
190    const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
191    const SkScalar pos[] = { 0, 1 };
192    SkPaint paint;
193    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
194
195    surface->getCanvas()->drawPaint(paint);
196}
197
198// A linear gradient interval can, due to numerical imprecision (likely in the divide)
199// finish an interval with the final fx not landing outside of [p0...p1].
200// The old code had an assert which this test triggered.
201// We now explicitly clamp the resulting fx value.
202static void test_linear_fuzz(skiatest::Reporter* reporter) {
203    auto surface(SkSurface::MakeRasterN32Premul(1300, 630));
204
205    const SkPoint pts[] = {{ 179.5f, -179.5f }, { 1074.5f, 715.5f }};
206    const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorBLACK, SK_ColorWHITE };
207    const SkScalar pos[] = {0, 0.200000003f, 0.800000012f, 1 };
208
209    SkPaint paint;
210    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode));
211
212    SkRect r = {0, 83, 1254, 620};
213    surface->getCanvas()->drawRect(r, paint);
214}
215
216// https://bugs.chromium.org/p/skia/issues/detail?id=5023
217// We should still shade pixels for which the radius is exactly 0.
218static void test_two_point_conical_zero_radius(skiatest::Reporter* reporter) {
219    auto surface(SkSurface::MakeRasterN32Premul(5, 5));
220    surface->getCanvas()->clear(SK_ColorRED);
221
222    const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE };
223    SkPaint p;
224    p.setShader(SkGradientShader::MakeTwoPointConical(
225        SkPoint::Make(2.5f, 2.5f), 0,
226        SkPoint::Make(3.0f, 3.0f), 10,
227        colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
228    surface->getCanvas()->drawPaint(p);
229
230    // r == 0 for the center pixel.
231    // verify that we draw it (no red bleed)
232    SkPMColor centerPMColor;
233    surface->readPixels(SkImageInfo::MakeN32Premul(1, 1), &centerPMColor, sizeof(SkPMColor), 2, 2);
234    REPORTER_ASSERT(reporter, SkGetPackedR32(centerPMColor) == 0);
235}
236
237// http://crbug.com/599458
238static void test_clamping_overflow(skiatest::Reporter*) {
239    SkPaint p;
240    const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
241    const SkPoint pts1[] = { SkPoint::Make(1001, 1000001), SkPoint::Make(1000.99f, 1000000) };
242
243    p.setShader(SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkShader::kClamp_TileMode));
244
245    sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
246    surface->getCanvas()->scale(100, 100);
247    surface->getCanvas()->drawPaint(p);
248
249    const SkPoint pts2[] = { SkPoint::Make(10000.99f, 1000000), SkPoint::Make(10001, 1000001) };
250    p.setShader(SkGradientShader::MakeLinear(pts2, colors, nullptr, 2, SkShader::kClamp_TileMode));
251    surface->getCanvas()->drawPaint(p);
252
253    // Passes if we don't trigger asserts.
254}
255
256// http://crbug.com/636194
257static void text_degenerate_linear(skiatest::Reporter*) {
258    SkPaint p;
259    const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
260    const SkPoint pts[] = {
261        SkPoint::Make(-46058024627067344430605278824628224.0f, 0),
262        SkPoint::Make(SK_ScalarMax, 0)
263    };
264
265    p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode));
266    sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
267    surface->getCanvas()->drawPaint(p);
268
269    // Passes if we don't trigger asserts.
270}
271
272DEF_TEST(Gradient, reporter) {
273    TestGradientShaders(reporter);
274    TestConstantGradient(reporter);
275    test_big_grad(reporter);
276    test_nearly_vertical(reporter);
277    test_linear_fuzz(reporter);
278    test_two_point_conical_zero_radius(reporter);
279    test_clamping_overflow(reporter);
280    text_degenerate_linear(reporter);
281}
282