AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
acc8d2e11a
skia2/fuzz/FilterFuzz.cpp
Ben Wagner c6c10b4518 Remove SkTypeface::Style from fuzzers and lua. 
Change-Id: I53be039e21a4c11ec3a4bc54c1424cd3e15afc6a
Reviewed-on: https://skia-review.googlesource.com/31643
Reviewed-by: Ben Wagner <bungeman@google.com>
Commit-Queue: Ben Wagner <bungeman@google.com>
2017-08-08 15:27:19 +00:00

869 lines
28 KiB
C++
Raw Blame History

/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "Fuzz.h"
#include "Sk1DPathEffect.h"
#include "Sk2DPathEffect.h"
#include "SkAlphaThresholdFilter.h"
#include "SkBlurImageFilter.h"
#include "SkBlurMaskFilter.h"
#include "SkCanvas.h"
#include "SkColorFilter.h"
#include "SkColorFilterImageFilter.h"
#include "SkColorMatrixFilter.h"
#include "SkComposeImageFilter.h"
#include "SkCornerPathEffect.h"
#include "SkDashPathEffect.h"
#include "SkData.h"
#include "SkDiscretePathEffect.h"
#include "SkDisplacementMapEffect.h"
#include "SkDropShadowImageFilter.h"
#include "SkEmbossMaskFilter.h"
#include "SkFlattenableSerialization.h"
#include "SkFontStyle.h"
#include "SkImageSource.h"
#include "SkLayerRasterizer.h"
#include "SkLightingImageFilter.h"
#include "SkLumaColorFilter.h"
#include "SkMagnifierImageFilter.h"
#include "SkMatrixConvolutionImageFilter.h"
#include "SkMergeImageFilter.h"
#include "SkMorphologyImageFilter.h"
#include "SkOffsetImageFilter.h"
#include "SkPaintImageFilter.h"
#include "SkPerlinNoiseShader.h"
#include "SkPictureImageFilter.h"
#include "SkPictureRecorder.h"
#include "SkPoint3.h"
#include "SkRandom.h"
#include "SkRegion.h"
#include "SkTableColorFilter.h"
#include "SkTileImageFilter.h"
#include "SkTypeface.h"
#include "SkXfermodeImageFilter.h"
#include <cmath>
#include <stdio.h>
#include <time.h>
#define SK_ADD_RANDOM_BIT_FLIPS
static Fuzz* fuzz;
static const int kBitmapSize = 24;
// There should be no more than one make_* used as a function argument.
static bool make_bool() {
bool b; fuzz->next(&b);
return b;
}
static float make_number(bool positiveOnly) {
float f;
fuzz->next(&f);
if (positiveOnly) {
return std::abs(f);
}
return f;
}
static SkString make_string() {
int length;
fuzz->nextRange(&length, 0, 1000);
SkString str(length);
for (int i = 0; i < length; ++i) {
char c;
fuzz->nextRange(&c, 0, 255);
str[i] = c;
}
return str;
}
static SkString make_font_name() {
int sel;
fuzz->nextRange(&sel, 0, 7);
switch(sel) {
case 0: return SkString("Courier New");
case 1: return SkString("Helvetica");
case 2: return SkString("monospace");
case 3: return SkString("sans-serif");
case 4: return SkString("serif");
case 5: return SkString("Times");
case 6: return SkString("Times New Roman");
case 7:
default:
return make_string();
}
}
static SkRect make_rect() {
SkScalar w, h;
fuzz->nextRange(&w, 0.0f, (float) kBitmapSize-1);
fuzz->nextRange(&h, 0.0f, (float) kBitmapSize-1);
return SkRect::MakeWH(w, h);
}
static SkRegion make_region() {
int32_t x, y, w, h;
fuzz->nextRange(&x, 0, kBitmapSize-1);
fuzz->nextRange(&y, 0, kBitmapSize-1);
fuzz->nextRange(&w, 0, kBitmapSize-1);
fuzz->nextRange(&h, 0, kBitmapSize-1);
SkIRect iRegion = SkIRect::MakeXYWH(x,y,w,h);
return SkRegion(iRegion);
}
static void init_matrix(SkMatrix* m) {
SkScalar mat[9];
fuzz->nextN(mat, 9);
m->set9(mat);
}
static SkBlendMode make_blendmode() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)SkBlendMode::kLastMode);
return static_cast<SkBlendMode>(i);
}
static SkPaint::Align make_paint_align() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)SkPaint::kRight_Align);
return static_cast<SkPaint::Align>(i);
}
static SkPaint::Hinting make_paint_hinting() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)SkPaint::kFull_Hinting);
return static_cast<SkPaint::Hinting>(i);
}
static SkPaint::Style make_paint_style() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)SkPaint::kStrokeAndFill_Style);
return static_cast<SkPaint::Style>(i);
}
static SkPaint::Cap make_paint_cap() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)SkPaint::kDefault_Cap);
return static_cast<SkPaint::Cap>(i);
}
static SkPaint::Join make_paint_join() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)SkPaint::kDefault_Join);
return static_cast<SkPaint::Join>(i);
}
static SkPaint::TextEncoding make_paint_text_encoding() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)SkPaint::kGlyphID_TextEncoding);
return static_cast<SkPaint::TextEncoding>(i);
}
static SkBlurStyle make_blur_style() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)kLastEnum_SkBlurStyle);
return static_cast<SkBlurStyle>(i);
}
static SkBlurMaskFilter::BlurFlags make_blur_mask_filter_flag() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)SkBlurMaskFilter::kAll_BlurFlag);
return static_cast<SkBlurMaskFilter::BlurFlags>(i);
}
static SkFilterQuality make_filter_quality() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)kHigh_SkFilterQuality);
return static_cast<SkFilterQuality>(i);
}
static SkFontStyle make_typeface_style() {
uint16_t weight;
fuzz->nextRange(&weight, SkFontStyle::kInvisible_Weight, SkFontStyle::kExtraBlack_Weight);
uint8_t width;
fuzz->nextRange(&width, SkFontStyle::kUltraCondensed_Width, SkFontStyle::kUltraExpanded_Width);
uint8_t slant;
fuzz->nextRange(&slant, SkFontStyle::kUpright_Slant, SkFontStyle::kOblique_Slant);
return SkFontStyle(weight, width, static_cast<SkFontStyle::Slant>(slant));
}
static SkPath1DPathEffect::Style make_path_1d_path_effect_style() {
uint8_t i;
fuzz->nextRange(&i, 0, (uint8_t)SkPath1DPathEffect::kLastEnum_Style);
return static_cast<SkPath1DPathEffect::Style>(i);
}
static SkColor make_color() {
return make_bool() ? 0xFFC0F0A0 : 0xFF000090;
}
static SkDropShadowImageFilter::ShadowMode make_shadow_mode() {
return make_bool() ? SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode :
SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode;
}
static SkPoint3 make_point() {
SkScalar a, b, c;
fuzz->next(&a, &b, &c);
c = std::abs(c);
return SkPoint3::Make(a, b, c);
}
static SkDisplacementMapEffect::ChannelSelectorType make_channel_selector_type() {
uint8_t i;
fuzz->nextRange(&i, 1, (uint8_t)SkDisplacementMapEffect::kA_ChannelSelectorType);
return static_cast<SkDisplacementMapEffect::ChannelSelectorType>(i);
}
static SkColorType rand_colortype() {
uint8_t i;
fuzz->nextRange(&i, 0, kLastEnum_SkColorType);
return (SkColorType) i;
}
static void rand_bitmap_for_canvas(SkBitmap* bitmap) {
SkImageInfo info = SkImageInfo::Make(kBitmapSize, kBitmapSize, rand_colortype(),
kPremul_SkAlphaType);
if (!bitmap->tryAllocPixels(info)){
SkDebugf("Bitmap not allocated\n");
}
}
static void make_g_bitmap(SkBitmap& bitmap) {
rand_bitmap_for_canvas(&bitmap);
SkCanvas canvas(bitmap);
canvas.clear(0x00000000);
SkPaint paint;
paint.setAntiAlias(true);
paint.setColor(0xFF884422);
paint.setTextSize(SkIntToScalar(kBitmapSize/2));
const char* str = "g";
canvas.drawString(str, SkIntToScalar(kBitmapSize/8),
SkIntToScalar(kBitmapSize/4), paint);
}
static void make_checkerboard_bitmap(SkBitmap& bitmap) {
rand_bitmap_for_canvas(&bitmap);
SkCanvas canvas(bitmap);
canvas.clear(0x00000000);
SkPaint darkPaint;
darkPaint.setColor(0xFF804020);
SkPaint lightPaint;
lightPaint.setColor(0xFF244484);
const int i = kBitmapSize / 8;
const SkScalar f = SkIntToScalar(i);
for (int y = 0; y < kBitmapSize; y += i) {
for (int x = 0; x < kBitmapSize; x += i) {
canvas.save();
canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
canvas.drawRect(SkRect::MakeXYWH(0, 0, f, f), darkPaint);
canvas.drawRect(SkRect::MakeXYWH(f, 0, f, f), lightPaint);
canvas.drawRect(SkRect::MakeXYWH(0, f, f, f), lightPaint);
canvas.drawRect(SkRect::MakeXYWH(f, f, f, f), darkPaint);
canvas.restore();
}
}
}
static const SkBitmap& make_bitmap() {
static SkBitmap bitmap[2];
static bool initialized = false;
if (!initialized) {
make_g_bitmap(bitmap[0]);
make_checkerboard_bitmap(bitmap[1]);
initialized = true;
}
uint8_t i;
fuzz->nextRange(&i, 0, 1);
return bitmap[i];
}
static sk_sp<SkData> make_3Dlut(int* cubeDimension, bool invR, bool invG, bool invB) {
uint8_t shift;
fuzz->nextRange(&shift, 0, 4);
int size = 4 << shift;
auto data = SkData::MakeUninitialized(sizeof(SkColor) * size * size * size);
SkColor* pixels = (SkColor*)(data->writable_data());
SkAutoTMalloc<uint8_t> lutMemory(size);
SkAutoTMalloc<uint8_t> invLutMemory(size);
uint8_t* lut = lutMemory.get();
uint8_t* invLut = invLutMemory.get();
const int maxIndex = size - 1;
for (int i = 0; i < size; i++) {
lut[i] = (i * 255) / maxIndex;
invLut[i] = ((maxIndex - i) * 255) / maxIndex;
}
for (int r = 0; r < size; ++r) {
for (int g = 0; g < size; ++g) {
for (int b = 0; b < size; ++b) {
pixels[(size * ((size * b) + g)) + r] = SkColorSetARGB(0xFF,
invR ? invLut[r] : lut[r],
invG ? invLut[g] : lut[g],
invB ? invLut[b] : lut[b]);
}
}
}
if (cubeDimension) {
*cubeDimension = size;
}
return data;
}
static void drawSomething(SkCanvas* canvas) {
SkPaint paint;
canvas->save();
canvas->scale(0.5f, 0.5f);
canvas->drawBitmap(make_bitmap(), 0, 0, nullptr);
canvas->restore();
paint.setAntiAlias(true);
paint.setColor(SK_ColorRED);
canvas->drawCircle(SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/3), paint);
paint.setColor(SK_ColorBLACK);
paint.setTextSize(SkIntToScalar(kBitmapSize/3));
canvas->drawString("Picture", SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
}
static sk_sp<SkColorFilter> make_color_filter() {
uint8_t s;
fuzz->nextRange(&s, 0, 5);
switch (s) {
case 0: {
SkScalar array[20];
fuzz->nextN(array, 20);
return SkColorFilter::MakeMatrixFilterRowMajor255(array);
}
case 1:
return SkLumaColorFilter::Make();
case 2: {
uint8_t tableA[256];
uint8_t tableR[256];
uint8_t tableG[256];
uint8_t tableB[256];
fuzz->nextN(tableA, 256);
fuzz->nextN(tableR, 256);
fuzz->nextN(tableG, 256);
fuzz->nextN(tableB, 256);
return SkTableColorFilter::MakeARGB(tableA, tableR, tableG, tableB);
}
case 3: {
SkColor c = make_color();
SkBlendMode mode = make_blendmode();
return SkColorFilter::MakeModeFilter(c, mode);
}
case 4: {
SkColor a = make_color();
SkColor b = make_color();
return SkColorMatrixFilter::MakeLightingFilter(a, b);
}
case 5:
default:
break;
}
return nullptr;
}
static SkPath make_path() {
SkPath path;
uint8_t numOps;
fuzz->nextRange(&numOps, 0, 30);
for (uint8_t i = 0; i < numOps; ++i) {
uint8_t op;
fuzz->nextRange(&op, 0, 5);
SkScalar a, b, c, d, e, f;
switch (op) {
case 0:
fuzz->next(&a, &b);
path.moveTo(a, b);
break;
case 1:
fuzz->next(&a, &b);
path.lineTo(a, b);
break;
case 2:
fuzz->next(&a, &b, &c, &d);
path.quadTo(a, b, c, d);
break;
case 3:
fuzz->next(&a, &b, &c, &d, &e);
path.conicTo(a, b, c, d, e);
break;
case 4:
fuzz->next(&a, &b, &c, &d, &e, &f);
path.cubicTo(a, b, c, d, e, f);
break;
case 5:
default:
fuzz->next(&a, &b, &c, &d, &e);
path.arcTo(a, b, c, d, e);
break;
}
}
path.close();
return path;
}
static sk_sp<SkPathEffect> make_path_effect(bool canBeNull = true) {
sk_sp<SkPathEffect> pathEffect;
uint8_t s;
fuzz->nextRange(&s, 0, 2);
if (canBeNull && s == 0) { return pathEffect; }
fuzz->nextRange(&s, 0, 7);
switch (s) {
case 0: {
SkPath path = make_path();
SkMatrix m;
init_matrix(&m);
pathEffect = SkPath2DPathEffect::Make(m, path);
break;
}
case 1: {
sk_sp<SkPathEffect> a = make_path_effect(false);
sk_sp<SkPathEffect> b = make_path_effect(false);
pathEffect = SkPathEffect::MakeCompose(a, b);
break;
}
case 2: {
SkScalar a = make_number(false);
pathEffect = SkCornerPathEffect::Make(a);
break;
}
case 3: {
uint8_t count;
fuzz->nextRange(&count, 0, 9);
SkScalar intervals[10];
fuzz->nextN(intervals, 10);
SkScalar a = make_number(false);
pathEffect = SkDashPathEffect::Make(intervals, count, a);
break;
}
case 4: {
SkScalar a, b;
fuzz->next(&a, &b);
pathEffect = SkDiscretePathEffect::Make(a, b);
break;
}
case 5: {
SkPath path = make_path();
SkScalar a, b;
fuzz->next(&a, &b);
SkPath1DPathEffect::Style style = make_path_1d_path_effect_style();
pathEffect = SkPath1DPathEffect::Make(path, a, b, style);
break;
}
case 6: {
SkScalar a = make_number(false);
SkMatrix m;
init_matrix(&m);
pathEffect = SkLine2DPathEffect::Make(a, m);
break;
}
case 7:
default: {
sk_sp<SkPathEffect> a = make_path_effect(false);
sk_sp<SkPathEffect> b = make_path_effect(false);
pathEffect = SkPathEffect::MakeCompose(a, b);
break;
}
}
return pathEffect;
}
static sk_sp<SkMaskFilter> make_mask_filter() {
sk_sp<SkMaskFilter> maskFilter;
uint8_t s;
fuzz->nextRange(&s, 0, 2);
switch (s) {
case 0: {
SkBlurStyle blur = make_blur_style();
SkScalar a = make_number(false);
SkBlurMaskFilter::BlurFlags flags = make_blur_mask_filter_flag();
maskFilter = SkBlurMaskFilter::Make(blur, a, flags);
break;
}
case 1: {
SkScalar a = make_number(false);
SkEmbossMaskFilter::Light light;
fuzz->nextN(light.fDirection, 3);
fuzz->nextRange(&light.fPad, 0, 65535);
fuzz->nextRange(&light.fAmbient, 0, 255);
fuzz->nextRange(&light.fSpecular, 0, 255);
maskFilter = SkEmbossMaskFilter::Make(a, light);
break;
}
case 2:
default:
break;
}
return maskFilter;
}
static sk_sp<SkImageFilter> make_image_filter(bool canBeNull = true);
static SkPaint make_paint() {
SkPaint paint;
if (fuzz->exhausted()) {
return paint;
}
paint.setHinting(make_paint_hinting());
paint.setAntiAlias(make_bool());
paint.setDither(make_bool());
paint.setLinearText(make_bool());
paint.setSubpixelText(make_bool());
paint.setLCDRenderText(make_bool());
paint.setEmbeddedBitmapText(make_bool());
paint.setAutohinted(make_bool());
paint.setVerticalText(make_bool());
paint.setFakeBoldText(make_bool());
paint.setDevKernText(make_bool());
paint.setFilterQuality(make_filter_quality());
paint.setStyle(make_paint_style());
paint.setColor(make_color());
paint.setStrokeWidth(make_number(false));
paint.setStrokeMiter(make_number(false));
paint.setStrokeCap(make_paint_cap());
paint.setStrokeJoin(make_paint_join());
paint.setColorFilter(make_color_filter());
paint.setBlendMode(make_blendmode());
paint.setPathEffect(make_path_effect());
paint.setMaskFilter(make_mask_filter());
if (false) {
// our validating buffer does not support typefaces yet, so skip this for now
paint.setTypeface(SkTypeface::MakeFromName(make_font_name().c_str(),make_typeface_style()));
}
SkLayerRasterizer::Builder rasterizerBuilder;
SkPaint paintForRasterizer;
if (make_bool()) {
paintForRasterizer = make_paint();
}
rasterizerBuilder.addLayer(paintForRasterizer);
paint.setRasterizer(rasterizerBuilder.detach());
paint.setImageFilter(make_image_filter());
bool a, b, c;
fuzz->next(&a, &b, &c);
sk_sp<SkData> data(make_3Dlut(nullptr, a, b, c));
paint.setTextAlign(make_paint_align());
SkScalar d, e, f;
fuzz->next(&d, &e, &f);
paint.setTextSize(d);
paint.setTextScaleX(e);
paint.setTextSkewX(f);
paint.setTextEncoding(make_paint_text_encoding());
return paint;
}
static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
sk_sp<SkImageFilter> filter;
// Add a 1 in 3 chance to get a nullptr input
uint8_t i;
fuzz->nextRange(&i, 0, 2);
if (fuzz->exhausted() || (canBeNull && i == 1)) {
return filter;
}
enum { ALPHA_THRESHOLD, MERGE, COLOR, BLUR, MAGNIFIER,
BLENDMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
uint8_t s;
fuzz->nextRange(&s, 0, NUM_FILTERS - 1);
switch (s) {
case ALPHA_THRESHOLD: {
SkRegion reg = make_region();
SkScalar innerMin, outerMax;
fuzz->next(&innerMin, &outerMax);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkAlphaThresholdFilter::Make(reg, innerMin, outerMax, fil);
break;
}
case MERGE: {
sk_sp<SkImageFilter> filA = make_image_filter();
sk_sp<SkImageFilter> filB = make_image_filter();
filter = SkMergeImageFilter::Make(filA, filB);
break;
}
case COLOR: {
sk_sp<SkColorFilter> cf(make_color_filter());
filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter())
: nullptr;
break;
}
case BLUR: {
SkScalar sX = make_number(true);
SkScalar sY = make_number(true);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkBlurImageFilter::Make(sX, sY, fil);
break;
}
case MAGNIFIER: {
SkRect rect = make_rect();
SkScalar inset = make_number(true);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkMagnifierImageFilter::Make(rect, inset, fil);
break;
}
case BLENDMODE: {
SkBlendMode mode = make_blendmode();
sk_sp<SkImageFilter> filA = make_image_filter();
sk_sp<SkImageFilter> filB = make_image_filter();
filter = SkXfermodeImageFilter::Make(mode, filA, filB, nullptr);
break;
}
case OFFSET: {
SkScalar dx, dy;
fuzz->next(&dx, &dy);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkOffsetImageFilter::Make(dx, dy, fil);
break;
}
case MATRIX: {
SkMatrix m;
init_matrix(&m);
int qual;
fuzz->nextRange(&qual, 0, SkFilterQuality::kLast_SkFilterQuality - 1);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkImageFilter::MakeMatrixFilter(m, (SkFilterQuality)qual, fil);
break;
}
case MATRIX_CONVOLUTION: {
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
int w, h;
fuzz->nextRange(&w, 1, 10);
fuzz->nextRange(&h, 1, 10);
SkISize size = SkISize::Make(w, h);
int arraySize = size.width() * size.height();
SkTArray<SkScalar> kernel(arraySize);
for (int i = 0; i < arraySize; ++i) {
kernel.push_back() = make_number(false);
}
fuzz->nextRange(&w, 0, size.width() - 1);
fuzz->nextRange(&h, 0, size.height() - 1);
SkIPoint kernelOffset = SkIPoint::Make(w, h);
int mode;
fuzz->nextRange(&mode, 0, SkMatrixConvolutionImageFilter::kMax_TileMode - 1);
bool convolveAlpha = make_bool();
SkScalar gain, bias;
fuzz->next(&gain, &bias);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkMatrixConvolutionImageFilter::Make(size,
kernel.begin(),
gain,
bias,
kernelOffset,
(SkMatrixConvolutionImageFilter::TileMode)mode,
convolveAlpha,
fil,
&cropR);
break;
}
case COMPOSE: {
sk_sp<SkImageFilter> filA = make_image_filter();
sk_sp<SkImageFilter> filB = make_image_filter();
filter = SkComposeImageFilter::Make(filA, filB);
break;
}
case DISTANT_LIGHT: {
SkPoint3 p = make_point();
SkColor c = make_color();
SkScalar ss, kd;
fuzz->next(&ss, &kd);
int shininess;
fuzz->nextRange(&shininess, 0, 9);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = make_bool()
? SkLightingImageFilter::MakeDistantLitDiffuse(p, c, ss, kd, fil)
: SkLightingImageFilter::MakeDistantLitSpecular(p, c, ss, kd, shininess, fil);
break;
}
case POINT_LIGHT: {
SkPoint3 p = make_point();
SkColor c = make_color();
SkScalar ss, kd;
fuzz->next(&ss, &kd);
int shininess;
fuzz->nextRange(&shininess, 0, 9);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = make_bool()
? SkLightingImageFilter::MakePointLitDiffuse(p, c, ss, kd, fil)
: SkLightingImageFilter::MakePointLitSpecular(p, c, ss, kd, shininess, fil);
break;
}
case SPOT_LIGHT: {
SkPoint3 p = make_point();
SkColor c = make_color();
SkScalar se, ca, ss, kd;
fuzz->next(&se, &ca, &ss, &kd);
int shininess;
fuzz->nextRange(&shininess, 0, 9);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = make_bool()
? SkLightingImageFilter::MakeSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
p, se, ca, c, ss, kd, fil)
: SkLightingImageFilter::MakeSpotLitSpecular(SkPoint3::Make(0, 0, 0),
p, se, ca, c, ss, kd,
shininess, fil);
break;
}
case NOISE: {
SkScalar bfx = make_number(true);
SkScalar bfy = make_number(true);
SkScalar seed = make_number(false);
int octaves;
fuzz->nextRange(&octaves, 0, 9);
sk_sp<SkShader> shader(make_bool()
? SkPerlinNoiseShader::MakeFractalNoise(bfx, bfy, octaves, seed)
: SkPerlinNoiseShader::MakeTurbulence(bfx, bfy, octaves, seed));
SkPaint paint;
paint.setShader(shader);
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
filter = SkPaintImageFilter::Make(paint, &cropR);
break;
}
case DROP_SHADOW: {
SkScalar dx, dy, sx, sy;
fuzz->next(&dx, &dy);
sx = make_number(true);
sy = make_number(true);
SkColor c = make_color();
SkDropShadowImageFilter::ShadowMode mode = make_shadow_mode();
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkDropShadowImageFilter::Make(dx, dy, sx, sy, c, mode, fil, nullptr);
break;
}
case MORPHOLOGY: {
int rx, ry;
fuzz->nextRange(&rx, 0, kBitmapSize);
fuzz->nextRange(&ry, 0, kBitmapSize);
sk_sp<SkImageFilter> fil = make_image_filter();
if (make_bool()) {
filter = SkDilateImageFilter::Make(rx, ry, fil);
} else {
filter = SkErodeImageFilter::Make(rx, ry, fil);
}
break;
}
case BITMAP: {
sk_sp<SkImage> image(SkImage::MakeFromBitmap(make_bitmap()));
if (make_bool()) {
filter = SkImageSource::Make(std::move(image),
make_rect(),
make_rect(),
kHigh_SkFilterQuality);
} else {
filter = SkImageSource::Make(std::move(image));
}
break;
}
case DISPLACE: {
SkDisplacementMapEffect::ChannelSelectorType x = make_channel_selector_type();
SkDisplacementMapEffect::ChannelSelectorType y = make_channel_selector_type();
SkScalar scale = make_number(false);
sk_sp<SkImageFilter> filA = make_image_filter(false);
sk_sp<SkImageFilter> filB = make_image_filter();
filter = SkDisplacementMapEffect::Make(x, y, scale, filA, filB);
break;
}
case TILE: {
SkRect src = make_rect();
SkRect dest = make_rect();
sk_sp<SkImageFilter> fil = make_image_filter(false);
filter = SkTileImageFilter::Make(src, dest, fil);
break;
}
case PICTURE: {
SkRTreeFactory factory;
SkPictureRecorder recorder;
SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize),
&factory, 0);
drawSomething(recordingCanvas);
sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
filter = SkPictureImageFilter::Make(pict, make_rect());
break;
}
case PAINT: {
SkImageFilter::CropRect cropR(make_rect());
filter = SkPaintImageFilter::Make(make_paint(), &cropR);
break;
}
default:
break;
}
return filter;
}
static sk_sp<SkImageFilter> make_serialized_image_filter() {
sk_sp<SkImageFilter> filter(make_image_filter(false));
sk_sp<SkData> data(SkValidatingSerializeFlattenable(filter.get()));
const unsigned char* ptr = static_cast<const unsigned char*>(data->data());
size_t len = data->size();
#ifdef SK_ADD_RANDOM_BIT_FLIPS
unsigned char* p = const_cast<unsigned char*>(ptr);
for (size_t i = 0; i < len; ++i, ++p) {
uint8_t j;
fuzz->nextRange(&j, 1, 250);
if (j == 1) { // 0.4% of the time, flip a bit or byte
uint8_t k;
fuzz->nextRange(&k, 1, 10);
if (k == 1) { // Then 10% of the time, change a whole byte
uint8_t s;
fuzz->nextRange(&s, 0, 2);
switch(s) {
case 0:
*p ^= 0xFF; // Flip entire byte
break;
case 1:
*p = 0xFF; // Set all bits to 1
break;
case 2:
*p = 0x00; // Set all bits to 0
break;
}
} else {
uint8_t s;
fuzz->nextRange(&s, 0, 7);
*p ^= (1 << 7);
}
}
}
#endif // SK_ADD_RANDOM_BIT_FLIPS
return SkValidatingDeserializeImageFilter(ptr, len);
}
static void drawClippedBitmap(SkCanvas* canvas, int x, int y, const SkPaint& paint) {
canvas->save();
canvas->clipRect(SkRect::MakeXYWH(SkIntToScalar(x), SkIntToScalar(y),
SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize)));
canvas->drawBitmap(make_bitmap(), SkIntToScalar(x), SkIntToScalar(y), &paint);
canvas->restore();
}
DEF_FUZZ(SerializedImageFilter, f) {
fuzz = f;
SkPaint paint;
paint.setImageFilter(make_serialized_image_filter());
SkBitmap bitmap;
SkCanvas canvas(bitmap);
drawClippedBitmap(&canvas, 0, 0, paint);
}
Reference in New Issue View Git Blame Copy Permalink