AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
3036defd9e
skia2/fuzz/FuzzDrawFunctions.cpp
Mike Reed 7cee3efb6b FilterQuality should no longer be needed. 
Start to clean up.

Change-Id: I6dea9344d8a19010d6e22ee8d0cd2b795910a82c
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/386843
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>
2021-03-20 14:30:06 +00:00

328 lines
8.5 KiB
C++
Raw Blame History

/*
* Copyright 2016 Mozilla Foundation
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "fuzz/Fuzz.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkFont.h"
#include "include/core/SkImage.h"
#include "include/core/SkPath.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTextBlob.h"
#include "include/core/SkTypeface.h"
#include "src/core/SkClipOpPriv.h"
#include "src/core/SkPaintPriv.h"
static const int kBmpSize = 24;
static const int kMaxX = 250;
static const int kMaxY = 250;
static const int kPtsLen = 10;
static const int kTxtLen = 5;
static void init_string(Fuzz* fuzz, char* str, size_t bufSize) {
for (size_t i = 0; i < bufSize-1; ++i) {
fuzz->nextRange(&str[i], 0x20, 0x7E); // printable ASCII
}
str[bufSize-1] = '\0';
}
// make_paint mostly borrowed from FilterFuzz.cpp
static void init_paint(Fuzz* fuzz, SkPaint* p) {
bool b;
fuzz->next(&b);
p->setAntiAlias(b);
uint8_t tmp_u8;
fuzz->nextRange(&tmp_u8, 0, (int)SkBlendMode::kLastMode);
p->setBlendMode(static_cast<SkBlendMode>(tmp_u8));
SkColor co;
fuzz->next(&co);
p->setColor(co);
fuzz->next(&b);
p->setDither(b);
fuzz->nextRange(&tmp_u8, 0, (int)SkPaint::kLast_Cap);
p->setStrokeCap(static_cast<SkPaint::Cap>(tmp_u8));
fuzz->nextRange(&tmp_u8, 0, (int)SkPaint::kLast_Join);
p->setStrokeJoin(static_cast<SkPaint::Join>(tmp_u8));
SkScalar sc;
fuzz->next(&sc);
p->setStrokeMiter(sc);
fuzz->next(&sc);
p->setStrokeWidth(sc);
fuzz->nextRange(&tmp_u8, 0, (int)SkPaint::kStrokeAndFill_Style);
p->setStyle(static_cast<SkPaint::Style>(tmp_u8));
}
static void init_bitmap(Fuzz* fuzz, SkBitmap* bmp) {
uint8_t colorType;
fuzz->nextRange(&colorType, 0, (int)kLastEnum_SkColorType);
// ColorType needs to match what the system configuration is.
if (colorType == kRGBA_8888_SkColorType || colorType == kBGRA_8888_SkColorType) {
colorType = kN32_SkColorType;
}
bool b;
fuzz->next(&b);
SkImageInfo info = SkImageInfo::Make(kBmpSize,
kBmpSize,
(SkColorType)colorType,
b ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
if (!bmp->tryAllocPixels(info)) {
SkDEBUGF("Bitmap not allocated\n");
}
SkColor c;
fuzz->next(&c);
bmp->eraseColor(c);
fuzz->next(&b);
SkPaint p;
if (b) {
init_paint(fuzz, &p);
}
else {
fuzz->next(&c);
p.setColor(c);
}
}
static void init_surface(Fuzz* fuzz, sk_sp<SkSurface>* s) {
uint8_t x, y;
fuzz->nextRange(&x, 1, kMaxX);
fuzz->nextRange(&y, 1, kMaxY);
*s = SkSurface::MakeRasterN32Premul(x, y);
if (!*s) {
// Was possibly too big for the memory constrained fuzzing environments
*s = SkSurface::MakeNull(x, y);
}
}
static void fuzz_drawText(Fuzz* fuzz, sk_sp<SkTypeface> typeface) {
SkFont font(typeface);
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
char text[kTxtLen];
init_string(fuzz, text, kTxtLen);
SkScalar x, y;
fuzz->next(&x, &y);
// populate pts array
SkPoint pts[kPtsLen];
for (uint8_t i = 0; i < kPtsLen; ++i) {
pts[i].set(x, y);
x += font.getSize();
}
bool b;
fuzz->next(&b);
font.setForceAutoHinting(b);
fuzz->next(&b);
font.setEmbeddedBitmaps(b);
fuzz->next(&b);
font.setEmbolden(b);
fuzz->next(&b);
font.setEdging(b ? SkFont::Edging::kAntiAlias : SkFont::Edging::kSubpixelAntiAlias);
fuzz->next(&b);
font.setLinearMetrics(b);
fuzz->next(&b);
font.setSubpixel(b);
fuzz->next(&x);
font.setScaleX(x);
fuzz->next(&x);
font.setSkewX(x);
fuzz->next(&x);
font.setSize(x);
SkCanvas* cnv = surface->getCanvas();
fuzz->next(&x);
fuzz->next(&y);
cnv->drawTextBlob(SkTextBlob::MakeFromPosText(text, kTxtLen-1, pts, font), x, y, p);
}
static void fuzz_drawCircle(Fuzz* fuzz) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
SkScalar a, b, c;
fuzz->next(&a, &b, &c);
surface->getCanvas()->drawCircle(a, b, c, p);
}
static void fuzz_drawLine(Fuzz* fuzz) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
SkScalar a, b, c, d;
fuzz->next(&a, &b, &c, &d);
surface->getCanvas()->drawLine(a, b, c, d, p);
}
static void fuzz_drawRect(Fuzz* fuzz) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
SkScalar a, b, c, d;
fuzz->next(&a, &b, &c, &d);
SkRect r;
r = SkRect::MakeXYWH(a, b, c, d);
SkCanvas* cnv = surface->getCanvas();
cnv->drawRect(r, p);
bool bl;
fuzz->next(&bl);
fuzz->next(&a, &b, &c, &d);
r = SkRect::MakeXYWH(a, b, c, d);
cnv->clipRect(r, kIntersect_SkClipOp, bl);
}
static void fuzz_drawPath(Fuzz* fuzz) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
// TODO(kjlubick): put the ability to fuzz a path in shared file, with
// other common things (e.g. rects, lines)
uint8_t i, j;
fuzz->nextRange(&i, 0, 10); // set i to number of operations to perform
SkPath path;
SkScalar a, b, c, d, e, f;
for (int k = 0; k < i; ++k) {
fuzz->nextRange(&j, 0, 5); // set j to choose operation to perform
switch (j) {
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:
fuzz->next(&a, &b, &c, &d, &e);
path.arcTo(a, b, c, d, e);
break;
}
}
path.close();
SkCanvas* cnv = surface->getCanvas();
cnv->drawPath(path, p);
bool bl;
fuzz->next(&bl);
cnv->clipPath(path, kIntersect_SkClipOp, bl);
}
static void fuzz_drawImage(Fuzz* fuzz) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
SkBitmap bmp;
init_bitmap(fuzz, &bmp);
sk_sp<SkImage> image(bmp.asImage());
bool bl;
fuzz->next(&bl);
SkScalar a, b;
fuzz->next(&a, &b);
if (bl) {
surface->getCanvas()->drawImage(image, a, b, SkSamplingOptions(), &p);
}
else {
SkRect dst = SkRect::MakeWH(a, b);
fuzz->next(&a, &b);
SkRect src = SkRect::MakeWH(a, b);
uint8_t x;
fuzz->nextRange(&x, 0, 1);
SkCanvas::SrcRectConstraint cst = (SkCanvas::SrcRectConstraint)x;
surface->getCanvas()->drawImageRect(image.get(), src, dst, SkSamplingOptions(), &p, cst);
}
}
static void fuzz_drawPaint(Fuzz* fuzz) {
SkPaint l, p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
surface->getCanvas()->drawPaint(p);
}
DEF_FUZZ(DrawFunctions, fuzz) {
uint8_t i;
fuzz->next(&i);
switch(i) {
case 0: {
sk_sp<SkTypeface> f = SkTypeface::MakeDefault();
if (f == nullptr) {
SkDebugf("Could not initialize font.\n");
fuzz->signalBug();
}
SkDEBUGF("Fuzz DrawText\n");
fuzz_drawText(fuzz, f);
return;
}
case 1:
SkDEBUGF("Fuzz DrawRect\n");
fuzz_drawRect(fuzz);
return;
case 2:
SkDEBUGF("Fuzz DrawCircle\n");
fuzz_drawCircle(fuzz);
return;
case 3:
SkDEBUGF("Fuzz DrawLine\n");
fuzz_drawLine(fuzz);
return;
case 4:
SkDEBUGF("Fuzz DrawPath\n");
fuzz_drawPath(fuzz);
return;
case 5:
SkDEBUGF("Fuzz DrawImage/DrawImageRect\n");
fuzz_drawImage(fuzz);
return;
case 6:
SkDEBUGF("Fuzz DrawPaint\n");
fuzz_drawPaint(fuzz);
return;
}
}
Reference in New Issue View Git Blame Copy Permalink