| /* |
| * 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"); ) |
| |