skia2/bench/ImageBench.cpp

179 lines
5.7 KiB
C++

/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "Benchmark.h"
#include "SkCanvas.h"
#include "SkImage.h"
#include "SkSurface.h"
class Image2RasterBench : public Benchmark {
public:
Image2RasterBench() {
fName.set("native_image_to_raster_surface");
}
bool isSuitableFor(Backend backend) override {
return kGPU_Backend == backend || kRaster_Backend == backend;
}
protected:
const char* onGetName() override {
return fName.c_str();
}
// We explicitly want to bench drawing a Image [cpu or gpu backed] into a raster target,
// to ensure that we can cache the read-back in the case of gpu -> raster
//
void onPerCanvasPreDraw(SkCanvas* canvas) override {
// create an Image reflecting the canvas (gpu or cpu)
SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
SkAutoTUnref<SkSurface> surface(canvas->newSurface(info));
canvas->drawColor(SK_ColorRED);
fImage.reset(surface->newImageSnapshot());
// create a cpu-backed Surface
fRasterSurface.reset(SkSurface::NewRaster(info));
}
void onPerCanvasPostDraw(SkCanvas*) override {
// Release the image and raster surface here to prevent out of order destruction
// between these and the gpu interface.
fRasterSurface.reset(nullptr);
fImage.reset(nullptr);
}
void onDraw(int loops, SkCanvas*) override {
for (int i = 0; i < loops; i++) {
for (int inner = 0; inner < 10; ++inner) {
fRasterSurface->getCanvas()->drawImage(fImage, 0, 0);
}
}
}
private:
SkString fName;
SkAutoTUnref<SkImage> fImage;
SkAutoTUnref<SkSurface> fRasterSurface;
typedef Benchmark INHERITED;
};
DEF_BENCH( return new Image2RasterBench; )
///////////////////////////////////////////////////////////////////////////////////////////////////
#include "SkOffsetImageFilter.h"
#if SK_SUPPORT_GPU
#include "SkGrPixelRef.h"
#endif
enum MyDrawType {
kSprite_Type,
kBitmap_Type,
kImage_Type,
};
/*
* Want to time drawing images/bitmaps via drawSprite, and via drawBitmap/drawImage but with
* a non-scaling matrix and a clip that is tight to the image bounds. In this scenario, we
* should be able to match the speed of drawSprite.
*
* An optimal result should be that all three types: sprite/bitmap/image draw at the same speed.
*/
class ImageFilterSpriteBench : public Benchmark {
SkAutoTUnref<SkImage> fImage;
SkBitmap fBitmap;
SkString fName;
MyDrawType fType;
public:
ImageFilterSpriteBench(MyDrawType dt, const char suffix[]) : fType(dt) {
fName.printf("image-filter-sprite-draw-%s", suffix);
}
bool isSuitableFor(Backend backend) override {
return kGPU_Backend == backend || kRaster_Backend == backend;
}
protected:
bool isVisual() override {
return true;
}
const char* onGetName() override {
return fName.c_str();
}
void onPerCanvasPreDraw(SkCanvas* canvas) override {
const SkImageInfo info = SkImageInfo::MakeN32Premul(500, 500);
SkAutoTUnref<SkSurface> surface(canvas->newSurface(info));
surface->getCanvas()->drawColor(SK_ColorRED);
fImage.reset(surface->newImageSnapshot());
fBitmap.setInfo(info);
if (fImage->getTexture()) {
#if SK_SUPPORT_GPU
fBitmap.setPixelRef(new SkGrPixelRef(info, fImage->getTexture()))->unref();
#endif
} else {
SkPixmap pmap;
if (!fImage->peekPixels(&pmap)) {
sk_throw();
}
fBitmap.installPixels(pmap);
}
}
void onPerCanvasPostDraw(SkCanvas*) override {
// Release the image and raster surface here to prevent out of order destruction
// between these and the gpu interface.
fImage.reset(nullptr);
fBitmap.reset();
}
void onDraw(int loops, SkCanvas* canvas) override {
// This clip is important; it allows the drawImage/drawBitmap code to fall into the
// fast (sprite) case, since the imagefilter's output should match.
//
// When we address skbug.com/4526 we should be able to remove the need for this clip.
//
canvas->clipRect(SkRect::MakeIWH(fImage->width(), fImage->height()));
const SkScalar kDelta = 10;
SkPaint paint;
for (int i = 0; i < loops; i++) {
for (int inner = 0; inner < 10; ++inner) {
// build the filter everytime, so we don't accidentally draw a cached version,
// since the point of this bench is to time the actual imagefilter
// handling/overhead.
SkAutoTUnref<SkImageFilter> filter(SkOffsetImageFilter::Create(kDelta, kDelta));
paint.setImageFilter(filter);
switch (fType) {
case kSprite_Type:
canvas->drawSprite(fBitmap, 0, 0, &paint);
break;
case kBitmap_Type:
canvas->drawBitmap(fBitmap, 0, 0, &paint);
break;
case kImage_Type:
canvas->drawImage(fImage, 0, 0, &paint);
break;
}
}
}
}
private:
typedef Benchmark INHERITED;
};
DEF_BENCH( return new ImageFilterSpriteBench(kSprite_Type, "sprite"); )
DEF_BENCH( return new ImageFilterSpriteBench(kBitmap_Type, "bitmap"); )
DEF_BENCH( return new ImageFilterSpriteBench(kImage_Type, "image"); )