GradientTest.cpp revision d1aeddeb8aa2d678a24511542935f1f33c2eebcd 
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 "SkTLazy.h"
16#include "Test.h"
17
18// https://code.google.com/p/chromium/issues/detail?id=448299
19// Giant (inverse) matrix causes overflow when converting/computing using 32.32
20// Before the fix, we would assert (and then crash).
21static void test_big_grad(skiatest::Reporter* reporter) {
22    const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
23    const SkPoint pts[] = {{ 15, 14.7112684f }, { 0.709064007f, 12.6108112f }};
24    SkPaint paint;
25    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
26                                                 SkShader::kClamp_TileMode));
27
28    SkBitmap bm;
29    bm.allocN32Pixels(2000, 1);
30    SkCanvas c(bm);
31
32    const SkScalar affine[] = {
33        1.06608627e-06f, 4.26434525e-07f, 6.2855f, 2.6611f, 273.4393f, 244.0046f
34    };
35    SkMatrix matrix;
36    matrix.setAffine(affine);
37    c.concat(matrix);
38
39    c.drawPaint(paint);
40}
41
42struct GradRec {
43    int             fColorCount;
44    const SkColor*  fColors;
45    const SkScalar* fPos;
46    const SkPoint*  fPoint;   // 2
47    const SkScalar* fRadius; // 2
48    SkShader::TileMode fTileMode;
49
50    void gradCheck(skiatest::Reporter* reporter, const sk_sp<SkShader>& shader,
51                   SkShader::GradientInfo* info,
52                   SkShader::GradientType gt) const {
53        SkAutoTMalloc<SkColor> colorStorage(fColorCount);
54        SkAutoTMalloc<SkScalar> posStorage(fColorCount);
55
56        info->fColorCount = fColorCount;
57        info->fColors = colorStorage;
58        info->fColorOffsets = posStorage.get();
59        REPORTER_ASSERT(reporter, shader->asAGradient(info) == gt);
60
61        REPORTER_ASSERT(reporter, info->fColorCount == fColorCount);
62        REPORTER_ASSERT(reporter,
63                        !memcmp(info->fColors, fColors, fColorCount * sizeof(SkColor)));
64        REPORTER_ASSERT(reporter,
65                        !memcmp(info->fColorOffsets, fPos, fColorCount * sizeof(SkScalar)));
66        REPORTER_ASSERT(reporter, fTileMode == info->fTileMode);
67    }
68};
69
70
71static void none_gradproc(skiatest::Reporter* reporter, const GradRec&, const GradRec&) {
72    sk_sp<SkShader> s(SkShader::MakeEmptyShader());
73    REPORTER_ASSERT(reporter, SkShader::kNone_GradientType == s->asAGradient(nullptr));
74}
75
76static void color_gradproc(skiatest::Reporter* reporter, const GradRec& rec, const GradRec&) {
77    sk_sp<SkShader> s(new SkColorShader(rec.fColors[0]));
78    REPORTER_ASSERT(reporter, SkShader::kColor_GradientType == s->asAGradient(nullptr));
79
80    SkShader::GradientInfo info;
81    info.fColors = nullptr;
82    info.fColorCount = 0;
83    s->asAGradient(&info);
84    REPORTER_ASSERT(reporter, 1 == info.fColorCount);
85}
86
87static void linear_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
88                            const GradRec& checkRec) {
89    sk_sp<SkShader> s(SkGradientShader::MakeLinear(buildRec.fPoint, buildRec.fColors, buildRec.fPos,
90                                                   buildRec.fColorCount, buildRec.fTileMode));
91
92    SkShader::GradientInfo info;
93    checkRec.gradCheck(reporter, s, &info, SkShader::kLinear_GradientType);
94    REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint)));
95}
96
97static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
98                            const GradRec& checkRec) {
99    sk_sp<SkShader> s(SkGradientShader::MakeRadial(buildRec.fPoint[0], buildRec.fRadius[0],
100                                                   buildRec.fColors, buildRec.fPos,
101                                                   buildRec.fColorCount, buildRec.fTileMode));
102
103    SkShader::GradientInfo info;
104    checkRec.gradCheck(reporter, s, &info, SkShader::kRadial_GradientType);
105    REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]);
106    REPORTER_ASSERT(reporter, info.fRadius[0] == checkRec.fRadius[0]);
107}
108
109static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
110                           const GradRec& checkRec) {
111    sk_sp<SkShader> s(SkGradientShader::MakeSweep(buildRec.fPoint[0].fX, buildRec.fPoint[0].fY,
112                                                  buildRec.fColors, buildRec.fPos,
113                                                  buildRec.fColorCount));
114
115    SkShader::GradientInfo info;
116    checkRec.gradCheck(reporter, s, &info, SkShader::kSweep_GradientType);
117    REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]);
118}
119
120static void conical_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
121                             const GradRec& checkRec) {
122    sk_sp<SkShader> s(SkGradientShader::MakeTwoPointConical(buildRec.fPoint[0],
123                                                            buildRec.fRadius[0],
124                                                            buildRec.fPoint[1],
125                                                            buildRec.fRadius[1],
126                                                            buildRec.fColors,
127                                                            buildRec.fPos,
128                                                            buildRec.fColorCount,
129                                                            buildRec.fTileMode));
130
131    SkShader::GradientInfo info;
132    checkRec.gradCheck(reporter, s, &info, SkShader::kConical_GradientType);
133    REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint)));
134    REPORTER_ASSERT(reporter, !memcmp(info.fRadius, checkRec.fRadius, 2 * sizeof(SkScalar)));
135}
136
137// Ensure that repeated color gradients behave like drawing a single color
138static void TestConstantGradient(skiatest::Reporter*) {
139    const SkPoint pts[] = {
140        { 0, 0 },
141        { SkIntToScalar(10), 0 }
142    };
143    SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE };
144    const SkScalar pos[] = { 0, SK_Scalar1 };
145    SkPaint paint;
146    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
147    SkBitmap outBitmap;
148    outBitmap.allocN32Pixels(10, 1);
149    SkCanvas canvas(outBitmap);
150    canvas.drawPaint(paint);
151    for (int i = 0; i < 10; i++) {
152        // The following is commented out because it currently fails
153        // Related bug: https://code.google.com/p/skia/issues/detail?id=1098
154
155        // REPORTER_ASSERT(reporter, SK_ColorBLUE == outBitmap.getColor(i, 0));
156    }
157}
158
159typedef void (*GradProc)(skiatest::Reporter* reporter, const GradRec&, const GradRec&);
160
161static void TestGradientShaders(skiatest::Reporter* reporter) {
162    static const SkColor gColors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
163    static const SkScalar gPos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
164    static const SkPoint gPts[] = {
165        { 0, 0 },
166        { SkIntToScalar(10), SkIntToScalar(20) }
167    };
168    static const SkScalar gRad[] = { SkIntToScalar(1), SkIntToScalar(2) };
169
170    GradRec rec;
171    rec.fColorCount = SK_ARRAY_COUNT(gColors);
172    rec.fColors = gColors;
173    rec.fPos = gPos;
174    rec.fPoint = gPts;
175    rec.fRadius = gRad;
176    rec.fTileMode = SkShader::kClamp_TileMode;
177
178    static const GradProc gProcs[] = {
179        none_gradproc,
180        color_gradproc,
181        linear_gradproc,
182        radial_gradproc,
183        sweep_gradproc,
184        conical_gradproc,
185    };
186
187    for (size_t i = 0; i < SK_ARRAY_COUNT(gProcs); ++i) {
188        gProcs[i](reporter, rec, rec);
189    }
190}
191
192static void TestGradientOptimization(skiatest::Reporter* reporter) {
193    static const struct {
194        GradProc fProc;
195        bool     fIsClampRestricted;
196    } gProcInfo[] = {
197        { linear_gradproc , false },
198        { radial_gradproc , false },
199        { sweep_gradproc  , true  }, // sweep is funky in that it always pretends to be kClamp.
200        { conical_gradproc, false },
201    };
202
203    static const SkColor   gC_00[] = { 0xff000000, 0xff000000 };
204    static const SkColor   gC_01[] = { 0xff000000, 0xffffffff };
205    static const SkColor   gC_11[] = { 0xffffffff, 0xffffffff };
206    static const SkColor  gC_001[] = { 0xff000000, 0xff000000, 0xffffffff };
207    static const SkColor  gC_011[] = { 0xff000000, 0xffffffff, 0xffffffff };
208    static const SkColor gC_0011[] = { 0xff000000, 0xff000000, 0xffffffff, 0xffffffff };
209
210    static const SkScalar   gP_01[] = { 0, 1 };
211    static const SkScalar  gP_001[] = { 0,   0, 1 };
212    static const SkScalar  gP_011[] = { 0,   1, 1 };
213    static const SkScalar  gP_0x1[] = { 0, .5f, 1 };
214    static const SkScalar gP_0011[] = { 0, 0, 1, 1 };
215
216    static const SkPoint    gPts[] = { {0, 0}, {1, 1} };
217    static const SkScalar gRadii[] = { 1, 2 };
218
219    static const struct {
220        const SkColor*  fCol;
221        const SkScalar* fPos;
222        int             fCount;
223
224        const SkColor*  fExpectedCol;
225        const SkScalar* fExpectedPos;
226        int             fExpectedCount;
227        bool            fRequiresNonClamp;
228    } gTests[] = {
229        { gC_001,  gP_001, 3,  gC_01,  gP_01, 2, false },
230        { gC_001,  gP_011, 3,  gC_00,  gP_01, 2, true  },
231        { gC_001,  gP_0x1, 3, gC_001, gP_0x1, 3, false },
232        { gC_001, nullptr, 3, gC_001, gP_0x1, 3, false },
233
234        { gC_011,  gP_001, 3,  gC_11,  gP_01, 2, true  },
235        { gC_011,  gP_011, 3,  gC_01,  gP_01, 2, false },
236        { gC_011,  gP_0x1, 3, gC_011, gP_0x1, 3, false },
237        { gC_011, nullptr, 3, gC_011, gP_0x1, 3, false },
238
239        { gC_0011, gP_0011, 4, gC_0011, gP_0011, 4, false },
240    };
241
242    for (size_t i = 0; i < SK_ARRAY_COUNT(gProcInfo); ++i) {
243        for (int mode = 0; mode < SkShader::kTileModeCount; ++mode) {
244            if (gProcInfo[i].fIsClampRestricted && mode != SkShader::kClamp_TileMode) {
245                continue;
246            }
247
248            for (size_t t = 0; t < SK_ARRAY_COUNT(gTests); ++t) {
249                GradRec rec;
250                rec.fColorCount = gTests[t].fCount;
251                rec.fColors     = gTests[t].fCol;
252                rec.fPos        = gTests[t].fPos;
253                rec.fTileMode   = static_cast<SkShader::TileMode>(mode);
254                rec.fPoint      = gPts;
255                rec.fRadius     = gRadii;
256
257                GradRec expected = rec;
258                if (!gTests[t].fRequiresNonClamp || mode != SkShader::kClamp_TileMode) {
259                    expected.fColorCount = gTests[t].fExpectedCount;
260                    expected.fColors     = gTests[t].fExpectedCol;
261                    expected.fPos        = gTests[t].fExpectedPos;
262                }
263
264                gProcInfo[i].fProc(reporter, rec, expected);
265            }
266        }
267    }
268}
269
270static void test_nearly_vertical(skiatest::Reporter* reporter) {
271    auto surface(SkSurface::MakeRasterN32Premul(200, 200));
272
273    const SkPoint pts[] = {{ 100, 50 }, { 100.0001f, 50000 }};
274    const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
275    const SkScalar pos[] = { 0, 1 };
276    SkPaint paint;
277    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
278
279    surface->getCanvas()->drawPaint(paint);
280}
281
282static void test_vertical(skiatest::Reporter* reporter) {
283    auto surface(SkSurface::MakeRasterN32Premul(200, 200));
284
285    const SkPoint pts[] = {{ 100, 50 }, { 100, 50 }};
286    const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
287    const SkScalar pos[] = { 0, 1 };
288    SkPaint paint;
289    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
290
291    surface->getCanvas()->drawPaint(paint);
292}
293
294// A linear gradient interval can, due to numerical imprecision (likely in the divide)
295// finish an interval with the final fx not landing outside of [p0...p1].
296// The old code had an assert which this test triggered.
297// We now explicitly clamp the resulting fx value.
298static void test_linear_fuzz(skiatest::Reporter* reporter) {
299    auto surface(SkSurface::MakeRasterN32Premul(1300, 630));
300
301    const SkPoint pts[] = {{ 179.5f, -179.5f }, { 1074.5f, 715.5f }};
302    const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorBLACK, SK_ColorWHITE };
303    const SkScalar pos[] = {0, 0.200000003f, 0.800000012f, 1 };
304
305    SkPaint paint;
306    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode));
307
308    SkRect r = {0, 83, 1254, 620};
309    surface->getCanvas()->drawRect(r, paint);
310}
311
312// https://bugs.chromium.org/p/skia/issues/detail?id=5023
313// We should still shade pixels for which the radius is exactly 0.
314static void test_two_point_conical_zero_radius(skiatest::Reporter* reporter) {
315    auto surface(SkSurface::MakeRasterN32Premul(5, 5));
316    surface->getCanvas()->clear(SK_ColorRED);
317
318    const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE };
319    SkPaint p;
320    p.setShader(SkGradientShader::MakeTwoPointConical(
321        SkPoint::Make(2.5f, 2.5f), 0,
322        SkPoint::Make(3.0f, 3.0f), 10,
323        colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
324    surface->getCanvas()->drawPaint(p);
325
326    // r == 0 for the center pixel.
327    // verify that we draw it (no red bleed)
328    SkPMColor centerPMColor;
329    surface->readPixels(SkImageInfo::MakeN32Premul(1, 1), &centerPMColor, sizeof(SkPMColor), 2, 2);
330    REPORTER_ASSERT(reporter, SkGetPackedR32(centerPMColor) == 0);
331}
332
333// http://crbug.com/599458
334static void test_clamping_overflow(skiatest::Reporter*) {
335    SkPaint p;
336    const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
337    const SkPoint pts1[] = { SkPoint::Make(1001, 1000001), SkPoint::Make(1000.99f, 1000000) };
338
339    p.setShader(SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkShader::kClamp_TileMode));
340
341    sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
342    surface->getCanvas()->scale(100, 100);
343    surface->getCanvas()->drawPaint(p);
344
345    const SkPoint pts2[] = { SkPoint::Make(10000.99f, 1000000), SkPoint::Make(10001, 1000001) };
346    p.setShader(SkGradientShader::MakeLinear(pts2, colors, nullptr, 2, SkShader::kClamp_TileMode));
347    surface->getCanvas()->drawPaint(p);
348
349    // Passes if we don't trigger asserts.
350}
351
352// http://crbug.com/636194
353static void test_degenerate_linear(skiatest::Reporter*) {
354    SkPaint p;
355    const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
356    const SkPoint pts[] = {
357        SkPoint::Make(-46058024627067344430605278824628224.0f, 0),
358        SkPoint::Make(SK_ScalarMax, 0)
359    };
360
361    p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode));
362    sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
363    surface->getCanvas()->drawPaint(p);
364
365    // Passes if we don't trigger asserts.
366}
367
368// "Interesting" fuzzer values.
369static void test_linear_fuzzer(skiatest::Reporter*) {
370    static const SkColor gColors0[] = { 0x30303030, 0x30303030 };
371    static const SkColor gColors1[] = { 0x30303030, 0x30303030, 0x30303030 };
372
373    static const SkScalar gPos1[]   = { 0, 0, 1 };
374
375    static const SkScalar gMatrix0[9] = {
376        6.40969056e-10f, 0              , 6.40969056e-10f,
377        0              , 4.42539023e-39f, 6.40969056e-10f,
378        0              , 0              , 1
379    };
380    static const SkScalar gMatrix1[9] = {
381        -2.75294113f    , 6.40969056e-10f,  6.40969056e-10f,
382         6.40969056e-10f, 6.40969056e-10f, -3.32810161e+24f,
383         6.40969056e-10f, 6.40969056e-10f,  0
384    };
385    static const SkScalar gMatrix2[9] = {
386        7.93481258e+17f, 6.40969056e-10f, 6.40969056e-10f,
387        6.40969056e-10f, 6.40969056e-10f, 6.40969056e-10f,
388        6.40969056e-10f, 6.40969056e-10f, 0.688235283f
389    };
390    static const SkScalar gMatrix3[9] = {
391        1.89180674e+11f,     6.40969056e-10f, 6.40969056e-10f,
392        6.40969056e-10f,     6.40969056e-10f, 6.40969056e-10f,
393        6.40969056e-10f, 11276.0469f        , 8.12524808e+20f
394    };
395
396    static const struct {
397        SkPoint            fPts[2];
398        const SkColor*     fColors;
399        const SkScalar*    fPos;
400        int                fCount;
401        SkShader::TileMode fTileMode;
402        uint32_t           fFlags;
403        const SkScalar*    fLocalMatrix;
404        const SkScalar*    fGlobalMatrix;
405    } gConfigs[] = {
406        {
407            {{0, -2.752941f}, {0, 0}},
408            gColors0,
409            nullptr,
410            SK_ARRAY_COUNT(gColors0),
411            SkShader::kClamp_TileMode,
412            0,
413            gMatrix0,
414            nullptr
415        },
416        {
417            {{4.42539023e-39f, -4.42539023e-39f}, {9.78041162e-15f, 4.42539023e-39f}},
418            gColors1,
419            gPos1,
420            SK_ARRAY_COUNT(gColors1),
421            SkShader::kClamp_TileMode,
422            0,
423            nullptr,
424            gMatrix1
425        },
426        {
427            {{4.42539023e-39f, 6.40969056e-10f}, {6.40969056e-10f, 1.49237238e-19f}},
428            gColors1,
429            gPos1,
430            SK_ARRAY_COUNT(gColors1),
431            SkShader::kClamp_TileMode,
432            0,
433            nullptr,
434            gMatrix2
435        },
436        {
437            {{6.40969056e-10f, 6.40969056e-10f}, {6.40969056e-10f, -0.688235283f}},
438            gColors0,
439            nullptr,
440            SK_ARRAY_COUNT(gColors0),
441            SkShader::kClamp_TileMode,
442            0,
443            gMatrix3,
444            nullptr
445        },
446    };
447
448    sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
449    SkColorSpace* colorSpaces[] = {
450        nullptr,     // hits the legacy gradient impl
451        srgb.get(),  // triggers 4f/raster-pipeline
452    };
453
454    SkPaint paint;
455
456    for (auto colorSpace : colorSpaces) {
457
458        sk_sp<SkSurface> surface = SkSurface::MakeRaster(SkImageInfo::Make(100, 100,
459                                                                           kN32_SkColorType,
460                                                                           kPremul_SkAlphaType,
461                                                                           sk_ref_sp(colorSpace)));
462        SkCanvas* canvas = surface->getCanvas();
463
464        for (const auto& config : gConfigs) {
465            SkAutoCanvasRestore acr(canvas, false);
466            SkTLazy<SkMatrix> localMatrix;
467            if (config.fLocalMatrix) {
468                localMatrix.init();
469                localMatrix.get()->set9(config.fLocalMatrix);
470            }
471
472            paint.setShader(SkGradientShader::MakeLinear(config.fPts,
473                                                         config.fColors,
474                                                         config.fPos,
475                                                         config.fCount,
476                                                         config.fTileMode,
477                                                         config.fFlags,
478                                                         localMatrix.getMaybeNull()));
479            if (config.fGlobalMatrix) {
480                SkMatrix m;
481                m.set9(config.fGlobalMatrix);
482                canvas->save();
483                canvas->concat(m);
484            }
485
486            canvas->drawPaint(paint);
487        }
488    }
489}
490
491static void test_sweep_fuzzer(skiatest::Reporter*) {
492    static const SkColor gColors0[] = { 0x30303030, 0x30303030, 0x30303030 };
493    static const SkScalar   gPos0[] = { -47919293023455565225163489280.0f, 0, 1 };
494    static const SkScalar gMatrix0[9] = {
495        1.12116716e-13f,  0              ,  8.50489682e+16f,
496        4.1917041e-41f ,  3.51369881e-23f, -2.54344271e-26f,
497        9.61111907e+17f, -3.35263808e-29f, -1.35659403e+14f
498    };
499    static const struct {
500        SkPoint            fCenter;
501        const SkColor*     fColors;
502        const SkScalar*    fPos;
503        int                fCount;
504        const SkScalar*    fGlobalMatrix;
505    } gConfigs[] = {
506        {
507            { 0, 0 },
508            gColors0,
509            gPos0,
510            SK_ARRAY_COUNT(gColors0),
511            gMatrix0
512        },
513    };
514
515    sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(100, 100);
516    SkCanvas* canvas = surface->getCanvas();
517    SkPaint paint;
518
519    for (const auto& config : gConfigs) {
520        paint.setShader(SkGradientShader::MakeSweep(config.fCenter.x(),
521                                                    config.fCenter.y(),
522                                                    config.fColors,
523                                                    config.fPos,
524                                                    config.fCount));
525
526        SkAutoCanvasRestore acr(canvas, false);
527        if (config.fGlobalMatrix) {
528            SkMatrix m;
529            m.set9(config.fGlobalMatrix);
530            canvas->save();
531            canvas->concat(m);
532        }
533        canvas->drawPaint(paint);
534    }
535}
536
537DEF_TEST(Gradient, reporter) {
538    TestGradientShaders(reporter);
539    TestGradientOptimization(reporter);
540    TestConstantGradient(reporter);
541    test_big_grad(reporter);
542    test_nearly_vertical(reporter);
543    test_vertical(reporter);
544    test_linear_fuzz(reporter);
545    test_two_point_conical_zero_radius(reporter);
546    test_clamping_overflow(reporter);
547    test_degenerate_linear(reporter);
548    test_linear_fuzzer(reporter);
549    test_sweep_fuzzer(reporter);
550}
551