src/third_party/skia/tests/RecordingXfermodeTest.cpp

   1 /*
   2  * Copyright 2014 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "Test.h"
   9
  10 #include "../include/core/SkCanvas.h"
  11 #include "../include/core/SkPicture.h"
  12 #include "../include/core/SkStream.h"
  13 #include "../include/core/SkString.h"
  14 #include "../include/core/SkPictureRecorder.h"
  15 #include <cstring>
  16
  17 // Verify that replay of a recording into a clipped canvas
  18 // produces the correct bitmap.
  19 // This arose from http://crbug.com/401593 which has
  20 // https://code.google.com/p/skia/issues/detail?id=1291 as its root cause.
  21
  22 namespace {
  23
  24 class Drawer {
  25  public:
  26     explicit Drawer() : fImageInfo(SkImageInfo::MakeN32Premul(200, 100)) {
  27         fCircleBM.allocPixels(SkImageInfo::MakeN32Premul(100, 100));
  28         SkCanvas canvas(fCircleBM);
  29         canvas.clear(0xffffffff);
  30         SkPaint circlePaint;
  31         circlePaint.setColor(0xff000000);
  32         canvas.drawCircle(50, 50, 50, circlePaint);
  33     }
  34
  35     const SkImageInfo& imageInfo() const { return fImageInfo; }
  36
  37     void draw(SkCanvas* canvas, const SkRect& clipRect, SkXfermode::Mode mode) const {
  38         SkPaint greenPaint;
  39         greenPaint.setColor(0xff008000);
  40         SkPaint blackPaint;
  41         blackPaint.setColor(0xff000000);
  42         SkPaint whitePaint;
  43         whitePaint.setColor(0xffffffff);
  44         SkPaint layerPaint;
  45         layerPaint.setColor(0xff000000);
  46         layerPaint.setXfermodeMode(mode);
  47         SkRect canvasRect(SkRect::MakeWH(SkIntToScalar(fImageInfo.width()),
  48                                          SkIntToScalar(fImageInfo.height())));
  49
  50         canvas->clipRect(clipRect);
  51         canvas->clear(0xff000000);
  52
  53         canvas->saveLayer(NULL, &blackPaint);
  54             canvas->drawRect(canvasRect, greenPaint);
  55             canvas->saveLayer(NULL, &layerPaint);
  56                 canvas->drawBitmapRect(fCircleBM, SkRect::MakeXYWH(20,20,60,60), &blackPaint);
  57             canvas->restore();
  58         canvas->restore();
  59     }
  60
  61  private:
  62     const SkImageInfo fImageInfo;
  63     SkBitmap fCircleBM;
  64 };
  65
  66 class RecordingStrategy {
  67  public:
  68     virtual ~RecordingStrategy() {}
  69     virtual const SkBitmap& recordAndReplay(const Drawer& drawer,
  70                                             const SkRect& intoClip,
  71                                             SkXfermode::Mode) = 0;
  72 };
  73
  74 class BitmapBackedCanvasStrategy : public RecordingStrategy {
  75     // This version just draws into a bitmap-backed canvas.
  76  public:
  77     BitmapBackedCanvasStrategy(const SkImageInfo& imageInfo) {
  78         fBitmap.allocPixels(imageInfo);
  79     }
  80
  81     virtual const SkBitmap& recordAndReplay(const Drawer& drawer,
  82                                             const SkRect& intoClip,
  83                                             SkXfermode::Mode mode) {
  84         SkCanvas canvas(fBitmap);
  85         canvas.clear(0xffffffff);
  86         // Note that the scene is drawn just into the clipped region!
  87         canvas.clipRect(intoClip);
  88         drawer.draw(&canvas, intoClip, mode); // Shouild be canvas-wide...
  89         return fBitmap;
  90     }
  91
  92  private:
  93     SkBitmap fBitmap;
  94 };
  95
  96 class PictureStrategy : public RecordingStrategy {
  97     // This version draws the entire scene into an SkPictureRecorder.
  98     // Then it then replays the scene through a clip rectangle.
  99     // This backend proved to be buggy.
 100  public:
 101     PictureStrategy(const SkImageInfo& imageInfo) {
 102         fBitmap.allocPixels(imageInfo);
 103         fWidth  = imageInfo.width();
 104         fHeight = imageInfo.height();
 105     }
 106
 107     virtual const SkBitmap& recordAndReplay(const Drawer& drawer,
 108                                             const SkRect& intoClip,
 109                                             SkXfermode::Mode mode) {
 110         SkTileGridFactory::TileGridInfo tileGridInfo = { {100,100}, {0,0}, {0,0} };
 111         SkTileGridFactory factory(tileGridInfo);
 112         SkPictureRecorder recorder;
 113         SkRect canvasRect(SkRect::MakeWH(SkIntToScalar(fWidth),SkIntToScalar(fHeight)));
 114         SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(fWidth),
 115                                                    SkIntToScalar(fHeight),
 116                                                    &factory);
 117         drawer.draw(canvas, canvasRect, mode);
 118         SkAutoTDelete<SkPicture> picture(recorder.endRecording());
 119
 120         SkCanvas replayCanvas(fBitmap);
 121         replayCanvas.clear(0xffffffff);
 122         replayCanvas.clipRect(intoClip);
 123         picture->playback(&replayCanvas);
 124         return fBitmap;
 125     }
 126
 127  private:
 128     SkBitmap fBitmap;
 129     int fWidth;
 130     int fHeight;
 131 };
 132
 133 } // namespace
 134
 135
 136 DEF_TEST(SkRecordingAccuracyXfermode, reporter) {
 137 #define FINEGRAIN 0
 138     const Drawer drawer;
 139
 140     BitmapBackedCanvasStrategy golden(drawer.imageInfo());
 141     PictureStrategy picture(drawer.imageInfo());
 142
 143 #if !FINEGRAIN
 144     unsigned numErrors = 0;
 145     SkString errors;
 146 #endif
 147
 148     for (int iMode = 0; iMode < int(SkXfermode::kLastMode); iMode++) {
 149         const SkRect& clip = SkRect::MakeXYWH(100, 0, 100, 100);
 150         SkXfermode::Mode mode = SkXfermode::Mode(iMode);
 151
 152         const SkBitmap& goldenBM = golden.recordAndReplay(drawer, clip, mode);
 153         const SkBitmap& pictureBM = picture.recordAndReplay(drawer, clip, mode);
 154
 155         size_t pixelsSize = goldenBM.getSize();
 156         REPORTER_ASSERT(reporter, pixelsSize == pictureBM.getSize());
 157
 158         // The pixel arrays should match.
 159 #if FINEGRAIN
 160         REPORTER_ASSERT(reporter,
 161                         0 == memcmp(goldenBM.getPixels(), pictureBM.getPixels(), pixelsSize));
 162 #else
 163         if (memcmp(goldenBM.getPixels(), pictureBM.getPixels(), pixelsSize)) {
 164             numErrors++;
 165             errors.appendf("For SkXfermode %d %s:    SkPictureRecorder bitmap is wrong\n",
 166                            iMode, SkXfermode::ModeName(mode));
 167         }
 168 #endif
 169     }
 170
 171 #if !FINEGRAIN
 172     REPORTER_ASSERT_MESSAGE(reporter, 0 == numErrors, errors.c_str());
 173 #endif
 174 }