FuzzGradients.cpp File Reference

#include "fuzz/Fuzz.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkSurface.h"
#include "include/effects/SkGradientShader.h"
#include "src/base/SkTLazy.h"
#include "src/core/SkDebugUtils.h"
#include "tools/flags/CommandLineFlags.h"
#include <algorithm>
#include <vector>

Go to the source code of this file.

Functions
static	DEFINE_bool2 (verbose, v, false, "log verbose linear gradient description")
void	makeMatrix (Fuzz *fuzz, SkMatrix *m)
void	initGradientParams (Fuzz *fuzz, std::vector< SkColor > *colors, std::vector< SkScalar > *pos, SkTileMode *mode)
static void	logOptionalMatrix (const char *label, const SkMatrix *m)
static void	logLinearGradient (const SkPoint pts[2], const std::vector< SkColor > &colors, const std::vector< SkScalar > &pos, SkTileMode mode, uint32_t flags, const SkMatrix *localMatrix, const SkMatrix *globalMatrix)
void	fuzzLinearGradient (Fuzz *fuzz)
void	fuzzRadialGradient (Fuzz *fuzz)
void	fuzzTwoPointConicalGradient (Fuzz *fuzz)
void	fuzzSweepGradient (Fuzz *fuzz)
	DEF_FUZZ (Gradients, fuzz)

Variables
const int	MAX_COUNT = 400

Function Documentation

DEF_FUZZ()

DEF_FUZZ	(	Gradients	,
		fuzz
	)

Definition at line 251 of file FuzzGradients.cpp.

                          {
    uint8_t i;
    fuzz->next(&i);
 
    switch(i) {
        case 0:
            SkDEBUGF("LinearGradient\n");
            fuzzLinearGradient(fuzz);
            return;
        case 1:
            SkDEBUGF("RadialGradient\n");
            fuzzRadialGradient(fuzz);
            return;
        case 2:
            SkDEBUGF("TwoPointConicalGradient\n");
            fuzzTwoPointConicalGradient(fuzz);
            return;
    }
    SkDEBUGF("SweepGradient\n");
    fuzzSweepGradient(fuzz);
    return;
}

DEFINE_bool2()

static DEFINE_bool2 ( verbose  , v  , false  , "log verbose linear gradient description"    )

static

fuzzLinearGradient()

void fuzzLinearGradient

(

Fuzz *

fuzz

)

Definition at line 105 of file FuzzGradients.cpp.

                                    {
    SkPoint pts[2];
    fuzz->next(&pts[0].fX, &pts[0].fY, &pts[1].fX, &pts[1].fY);
    bool useLocalMatrix, useGlobalMatrix;
    fuzz->next(&useLocalMatrix, &useGlobalMatrix);
 
    std::vector<SkColor> colors;
    std::vector<SkScalar> pos;
    SkTileMode mode;
    initGradientParams(fuzz, &colors, &pos, &mode);
 
    SkPaint p;
    uint32_t flags;
    fuzz->next(&flags);
 
    SkTLazy<SkMatrix> localMatrix;
    if (useLocalMatrix) {
        makeMatrix(fuzz, localMatrix.init());
    }
    p.setShader(SkGradientShader::MakeLinear(pts, colors.data(), pos.data(),
        colors.size(), mode, flags, localMatrix.getMaybeNull()));
 
    sk_sp<SkSurface> surface(SkSurfaces::Raster(SkImageInfo::MakeN32Premul(50, 50)));
    if (useGlobalMatrix) {
        SkMatrix gm;
        makeMatrix(fuzz, &gm);
        logLinearGradient(pts, colors, pos, mode, flags, localMatrix.getMaybeNull(), &gm);
        SkCanvas* c = surface->getCanvas();
        c->setMatrix(gm);
        c->drawPaint(p);
    } else {
        logLinearGradient(pts, colors, pos, mode, flags, localMatrix.getMaybeNull(), nullptr);
        surface->getCanvas()->drawPaint(p);
    }
}

fuzzRadialGradient()

void fuzzRadialGradient

(

Fuzz *

fuzz

)

Definition at line 141 of file FuzzGradients.cpp.

                                    {
    SkPoint center;
    fuzz->next(&center.fX, &center.fY);
    SkScalar radius;
    bool useLocalMatrix, useGlobalMatrix;
    fuzz->next(&radius, &useLocalMatrix, &useGlobalMatrix);
 
 
    std::vector<SkColor> colors;
    std::vector<SkScalar> pos;
    SkTileMode mode;
    initGradientParams(fuzz, &colors, &pos, &mode);
 
    SkPaint p;
    uint32_t flags;
    fuzz->next(&flags);
 
    SkTLazy<SkMatrix> localMatrix;
    if (useLocalMatrix) {
        makeMatrix(fuzz, localMatrix.init());
    }
    p.setShader(SkGradientShader::MakeRadial(center, radius, colors.data(),
        pos.data(), colors.size(), mode, flags, localMatrix.getMaybeNull()));
 
    sk_sp<SkSurface> surface(SkSurfaces::Raster(SkImageInfo::MakeN32Premul(50, 50)));
    if (useGlobalMatrix) {
        SkMatrix gm;
        makeMatrix(fuzz, &gm);
        SkCanvas* c = surface->getCanvas();
        c->setMatrix(gm);
        c->drawPaint(p);
    } else {
        surface->getCanvas()->drawPaint(p);
    }
}

fuzzSweepGradient()

void fuzzSweepGradient

(

Fuzz *

fuzz

)

Definition at line 215 of file FuzzGradients.cpp.

                                   {
    SkScalar cx, cy;
    bool useLocalMatrix, useGlobalMatrix;
    fuzz->next(&cx, &cy, &useLocalMatrix, &useGlobalMatrix);
 
    std::vector<SkColor> colors;
    std::vector<SkScalar> pos;
    SkTileMode mode;
    initGradientParams(fuzz, &colors, &pos, &mode);
 
    SkPaint p;
    if (useLocalMatrix) {
        SkMatrix m;
        makeMatrix(fuzz, &m);
        uint32_t flags;
        fuzz->next(&flags);
 
        p.setShader(SkGradientShader::MakeSweep(cx, cy, colors.data(),
            pos.data(), colors.size(), flags, &m));
    } else {
        p.setShader(SkGradientShader::MakeSweep(cx, cy, colors.data(),
            pos.data(), colors.size()));
    }
 
    sk_sp<SkSurface> surface(SkSurfaces::Raster(SkImageInfo::MakeN32Premul(50, 50)));
    if (useGlobalMatrix) {
        SkMatrix gm;
        makeMatrix(fuzz, &gm);
        SkCanvas* c = surface->getCanvas();
        c->setMatrix(gm);
        c->drawPaint(p);
    } else {
        surface->getCanvas()->drawPaint(p);
    }
}

fuzzTwoPointConicalGradient()

void fuzzTwoPointConicalGradient

(

Fuzz *

fuzz

)

Definition at line 177 of file FuzzGradients.cpp.

                                             {
    SkPoint start;
    fuzz->next(&start.fX, &start.fY);
    SkPoint end;
    fuzz->next(&end.fX, &end.fY);
    SkScalar startRadius, endRadius;
    bool useLocalMatrix, useGlobalMatrix;
    fuzz->next(&startRadius, &endRadius, &useLocalMatrix, &useGlobalMatrix);
 
    std::vector<SkColor> colors;
    std::vector<SkScalar> pos;
    SkTileMode mode;
    initGradientParams(fuzz, &colors, &pos, &mode);
 
    SkPaint p;
    uint32_t flags;
    fuzz->next(&flags);
 
    SkTLazy<SkMatrix> localMatrix;
    if (useLocalMatrix) {
        makeMatrix(fuzz, localMatrix.init());
    }
    p.setShader(SkGradientShader::MakeTwoPointConical(start, startRadius,
        end, endRadius, colors.data(), pos.data(), colors.size(), mode,
        flags, localMatrix.getMaybeNull()));
 
    sk_sp<SkSurface> surface(SkSurfaces::Raster(SkImageInfo::MakeN32Premul(50, 50)));
    if (useGlobalMatrix) {
        SkMatrix gm;
        makeMatrix(fuzz, &gm);
        SkCanvas* c = surface->getCanvas();
        c->setMatrix(gm);
        c->drawPaint(p);
    } else {
        surface->getCanvas()->drawPaint(p);
    }
}

initGradientParams()

void initGradientParams	(	Fuzz *	fuzz,
		std::vector< SkColor > *	colors,
		std::vector< SkScalar > *	pos,
		SkTileMode *	mode
	)

Definition at line 29 of file FuzzGradients.cpp.

                                                                    {
    int count;
    fuzz->nextRange(&count, 0, MAX_COUNT);
 
    // Use a uint8_t to conserve bytes.  This makes our "fuzzed bytes footprint"
    // smaller, which leads to more efficient fuzzing.
    uint8_t m;
    fuzz->nextRange(&m, 0, 2);
    *mode = static_cast<SkTileMode>(m);
 
    colors->clear();
    pos   ->clear();
    for (int i = 0; i < count; i++) {
        SkColor c;
        SkScalar s;
        fuzz->next(&c, &s);
        colors->push_back(c);
        pos   ->push_back(s);
    }
    if (count) {
        std::sort(pos->begin(), pos->end());
        // The order matters.  If count == 1, we want pos == 0.
        (*pos)[count - 1] = 1;
        (*pos)[0]         = 0;
    }
}

logLinearGradient()

static void logLinearGradient ( const SkPoint  pts[2], const std::vector< SkColor > &  colors, const std::vector< SkScalar > &  pos, SkTileMode  mode, uint32_t  flags, const SkMatrix *  localMatrix, const SkMatrix *  globalMatrix  )

static

Definition at line 69 of file FuzzGradients.cpp.

                                                            {
    if (!FLAGS_verbose) {
        return;
    }
 
    SkDebugf("--- fuzzLinearGradient ---\n");
    SkDebugf("  pts:\t\t[ (%.9g %.9g) (%.9g %.9g) ]\n",
             pts[0].x(), pts[0].y(), pts[1].x(), pts[1].y());
    SkDebugf("  colors:\t[ ");
    for (auto color : colors) {
        SkDebugf("0x%x ", color);
    }
 
    SkDebugf("]\n  pos:\t\t");
    if (pos.empty()) {
        SkDebugf("nullptr");
    } else {
        SkDebugf("[ ");
        for (auto p : pos) {
            SkDebugf("%f ", p);
        }
    }
    SkDebugf("]\n");
 
    SkDebugf("  mode:\t\t%s\n", SkTileModeToStr(mode));
    SkDebugf("  flags:\t0x%x\n", flags);
    logOptionalMatrix("local matrix", localMatrix);
    logOptionalMatrix("global matrix", globalMatrix);
}

logOptionalMatrix()

static void logOptionalMatrix ( const char *  label, const SkMatrix *  m  )

static

Definition at line 57 of file FuzzGradients.cpp.

                                                                    {
    if (!m) {
        return;
    }
 
    SkDEBUGF("  %s: [ ", label);
    for (int i = 0; i < 9; ++i) {
        SkDEBUGF("%.9g ", m->get(i));
    }
    SkDEBUGF("]\n");
}

makeMatrix()

void makeMatrix	(	Fuzz *	fuzz,
		SkMatrix *	m
	)

Definition at line 23 of file FuzzGradients.cpp.

                                         {
    SkScalar mat[9];
    fuzz->nextN(mat, 9);
    m->set9(mat);
}

Variable Documentation

MAX_COUNT

const int MAX_COUNT = 400

Definition at line 21 of file FuzzGradients.cpp.