2012-09-14 21:26:37 +04:00
|
|
|
/*
|
|
|
|
* Copyright 2012 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
2013-12-13 01:11:12 +04:00
|
|
|
|
2013-08-29 15:54:56 +04:00
|
|
|
#include "SkBitmapDevice.h"
|
2012-10-02 21:42:15 +04:00
|
|
|
#include "SkCanvas.h"
|
2012-11-30 01:00:39 +04:00
|
|
|
#include "SkColorPriv.h"
|
|
|
|
#include "SkData.h"
|
2013-12-13 23:45:58 +04:00
|
|
|
#include "SkDecodingImageGenerator.h"
|
2013-04-25 22:29:32 +04:00
|
|
|
#include "SkError.h"
|
Add Options to SkDecodingImageGenerator, simplify API.
Motivation: We want to remove redundant classes from Skia. To
that end we want to remove SkImageRef and its subclasses and
replace their uses with SkDiscardablePixelRef +
SkDecodingImageGenerator. Since Android uses SkImageRef, we need
to make sure that SkDecodingImageGenerator allows all of the
settings that Android exposes in BitmapFactory.Options.
To that end, we have created an Options struct for the
SkDecodingImageGenerator which lets the client of the generator set
sample size, dithering, and bitmap config.
We have made the SkDecodingImageGenerator constructor private
and replaced the SkDecodingImageGenerator::Install functions
with a SkDecodingImageGenerator::Create functions (one for
SkData and one for SkStream) which now take a
SkDecodingImageGenerator::Options struct.
Also added a ImageDecoderOptions test which loops through a list
of sets of options and tries them on a set of 5 small encoded
images.
Also updated several users of SkDecodingImageGenerator::Install to
follow new call signature - gm/factory.cpp, LazyDecodeBitmap.cpp,
and PictureTest.cpp, CachedDecodingPixelRefTest.cpp.
We also added a new ImprovedBitmapFactory Test which simulates the
exact function that Android will need to modify to use this,
installPixelRef() in BitmapFactory.
R=reed@google.com, scroggo@google.com
Committed: https://code.google.com/p/skia/source/detail?r=12744
Review URL: https://codereview.chromium.org/93703004
git-svn-id: http://skia.googlecode.com/svn/trunk@12855 2bbb7eff-a529-9590-31e7-b0007b416f81
2014-01-02 17:15:13 +04:00
|
|
|
#include "SkImageEncoder.h"
|
|
|
|
#include "SkImageGenerator.h"
|
2012-10-02 21:42:15 +04:00
|
|
|
#include "SkPaint.h"
|
2012-09-14 21:26:37 +04:00
|
|
|
#include "SkPicture.h"
|
2013-08-29 15:54:56 +04:00
|
|
|
#include "SkPictureUtils.h"
|
2014-03-18 21:45:32 +04:00
|
|
|
#include "SkQuadTreePicture.h"
|
2013-01-24 22:27:42 +04:00
|
|
|
#include "SkRRect.h"
|
2014-01-25 00:56:26 +04:00
|
|
|
#include "SkRandom.h"
|
2012-11-30 01:00:39 +04:00
|
|
|
#include "SkShader.h"
|
2012-09-14 21:26:37 +04:00
|
|
|
#include "SkStream.h"
|
2014-03-18 21:45:32 +04:00
|
|
|
#include "SkTileGrid.h"
|
2014-01-25 00:56:26 +04:00
|
|
|
#include "Test.h"
|
2012-09-14 21:26:37 +04:00
|
|
|
|
2014-01-09 23:20:45 +04:00
|
|
|
static const int gColorScale = 30;
|
|
|
|
static const int gColorOffset = 60;
|
2012-11-30 01:00:39 +04:00
|
|
|
|
|
|
|
static void make_bm(SkBitmap* bm, int w, int h, SkColor color, bool immutable) {
|
2014-02-13 18:41:43 +04:00
|
|
|
bm->allocN32Pixels(w, h);
|
2012-11-30 01:00:39 +04:00
|
|
|
bm->eraseColor(color);
|
|
|
|
if (immutable) {
|
|
|
|
bm->setImmutable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-09 23:45:29 +04:00
|
|
|
static void make_checkerboard(SkBitmap* bm, int w, int h, bool immutable) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkASSERT(w % 2 == 0);
|
|
|
|
SkASSERT(h % 2 == 0);
|
2014-02-13 18:41:43 +04:00
|
|
|
bm->allocPixels(SkImageInfo::Make(w, h, kAlpha_8_SkColorType,
|
|
|
|
kPremul_SkAlphaType));
|
2014-01-09 23:20:45 +04:00
|
|
|
SkAutoLockPixels lock(*bm);
|
|
|
|
for (int y = 0; y < h; y += 2) {
|
|
|
|
uint8_t* s = bm->getAddr8(0, y);
|
|
|
|
for (int x = 0; x < w; x += 2) {
|
|
|
|
*s++ = 0xFF;
|
|
|
|
*s++ = 0x00;
|
|
|
|
}
|
|
|
|
s = bm->getAddr8(0, y + 1);
|
|
|
|
for (int x = 0; x < w; x += 2) {
|
|
|
|
*s++ = 0x00;
|
|
|
|
*s++ = 0xFF;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (immutable) {
|
|
|
|
bm->setImmutable();
|
|
|
|
}
|
|
|
|
}
|
2012-11-30 01:00:39 +04:00
|
|
|
|
2014-01-09 23:20:45 +04:00
|
|
|
static void init_paint(SkPaint* paint, const SkBitmap &bm) {
|
|
|
|
SkShader* shader = SkShader::CreateBitmapShader(bm,
|
|
|
|
SkShader::kClamp_TileMode,
|
|
|
|
SkShader::kClamp_TileMode);
|
|
|
|
paint->setShader(shader)->unref();
|
2012-11-30 01:00:39 +04:00
|
|
|
}
|
|
|
|
|
2014-01-14 11:01:42 +04:00
|
|
|
typedef void (*DrawBitmapProc)(SkCanvas*, const SkBitmap&,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap&, const SkPoint&,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs);
|
2014-01-09 23:20:45 +04:00
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawpaint_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
|
|
|
|
canvas->drawPaint(paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2012-11-30 01:00:39 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawpoints_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
|
2014-01-13 17:33:26 +04:00
|
|
|
// draw a rect
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPoint points[5] = {
|
2014-01-14 11:01:42 +04:00
|
|
|
{ pos.fX, pos.fY },
|
|
|
|
{ pos.fX + bm.width() - 1, pos.fY },
|
|
|
|
{ pos.fX + bm.width() - 1, pos.fY + bm.height() - 1 },
|
|
|
|
{ pos.fX, pos.fY + bm.height() - 1 },
|
|
|
|
{ pos.fX, pos.fY },
|
2012-11-30 01:00:39 +04:00
|
|
|
};
|
|
|
|
|
2014-01-09 23:20:45 +04:00
|
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, 5, points, paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawrect_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2012-11-30 01:00:39 +04:00
|
|
|
SkPaint paint;
|
2014-01-09 23:20:45 +04:00
|
|
|
init_paint(&paint, bm);
|
|
|
|
|
|
|
|
SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
|
|
|
|
r.offset(pos.fX, pos.fY);
|
|
|
|
|
2012-11-30 01:00:39 +04:00
|
|
|
canvas->drawRect(r, paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawoval_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
|
|
|
|
SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
|
|
|
|
r.offset(pos.fX, pos.fY);
|
|
|
|
|
2013-01-24 22:27:42 +04:00
|
|
|
canvas->drawOval(r, paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawrrect_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
2014-01-10 11:08:11 +04:00
|
|
|
|
2014-01-09 23:20:45 +04:00
|
|
|
SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
|
|
|
|
r.offset(pos.fX, pos.fY);
|
|
|
|
|
2013-01-24 22:27:42 +04:00
|
|
|
SkRRect rr;
|
2014-01-09 23:20:45 +04:00
|
|
|
rr.setRectXY(r, SkIntToScalar(bm.width())/4, SkIntToScalar(bm.height())/4);
|
2013-01-24 22:27:42 +04:00
|
|
|
canvas->drawRRect(rr, paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2012-11-30 01:00:39 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawpath_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
|
|
|
|
SkPath path;
|
|
|
|
path.lineTo(bm.width()/2.0f, SkIntToScalar(bm.height()));
|
|
|
|
path.lineTo(SkIntToScalar(bm.width()), 0);
|
|
|
|
path.close();
|
|
|
|
path.offset(pos.fX, pos.fY);
|
|
|
|
|
|
|
|
canvas->drawPath(path, paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawbitmap_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
canvas->drawBitmap(bm, pos.fX, pos.fY, NULL);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawbitmap_withshader_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
|
|
|
|
// The bitmap in the paint is ignored unless we're drawing an A8 bitmap
|
|
|
|
canvas->drawBitmap(altBM, pos.fX, pos.fY, &paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
|
|
|
*usedPixRefs->append() = altBM.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawsprite_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
const SkMatrix& ctm = canvas->getTotalMatrix();
|
|
|
|
|
|
|
|
SkPoint p(pos);
|
|
|
|
ctm.mapPoints(&p, 1);
|
|
|
|
|
|
|
|
canvas->drawSprite(bm, (int)p.fX, (int)p.fY, NULL);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
// Although specifiable, this case doesn't seem to make sense (i.e., the
|
|
|
|
// bitmap in the shader is never used).
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawsprite_withshader_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
|
|
|
|
const SkMatrix& ctm = canvas->getTotalMatrix();
|
|
|
|
|
|
|
|
SkPoint p(pos);
|
|
|
|
ctm.mapPoints(&p, 1);
|
|
|
|
|
|
|
|
canvas->drawSprite(altBM, (int)p.fX, (int)p.fY, &paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
|
|
|
*usedPixRefs->append() = altBM.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawbitmaprect_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
|
|
|
|
|
|
|
|
r.offset(pos.fX, pos.fY);
|
|
|
|
canvas->drawBitmapRectToRect(bm, NULL, r, NULL);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawbitmaprect_withshader_proc(SkCanvas* canvas,
|
|
|
|
const SkBitmap& bm,
|
|
|
|
const SkBitmap& altBM,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
|
|
|
|
SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
|
|
|
|
r.offset(pos.fX, pos.fY);
|
|
|
|
|
|
|
|
// The bitmap in the paint is ignored unless we're drawing an A8 bitmap
|
|
|
|
canvas->drawBitmapRectToRect(altBM, NULL, r, &paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
|
|
|
*usedPixRefs->append() = altBM.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawtext_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
paint.setTextSize(SkIntToScalar(1.5*bm.width()));
|
|
|
|
|
|
|
|
canvas->drawText("0", 1, pos.fX, pos.fY+bm.width(), paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawpostext_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
paint.setTextSize(SkIntToScalar(1.5*bm.width()));
|
|
|
|
|
|
|
|
SkPoint point = { pos.fX, pos.fY + bm.height() };
|
|
|
|
canvas->drawPosText("O", 1, &point, paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawtextonpath_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
paint.setTextSize(SkIntToScalar(1.5*bm.width()));
|
|
|
|
|
|
|
|
SkPath path;
|
|
|
|
path.lineTo(SkIntToScalar(bm.width()), 0);
|
|
|
|
path.offset(pos.fX, pos.fY+bm.height());
|
|
|
|
|
|
|
|
canvas->drawTextOnPath("O", 1, path, NULL, paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
static void drawverts_proc(SkCanvas* canvas, const SkBitmap& bm,
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkBitmap& altBM, const SkPoint& pos,
|
|
|
|
SkTDArray<SkPixelRef*>* usedPixRefs) {
|
2014-01-09 23:20:45 +04:00
|
|
|
SkPaint paint;
|
|
|
|
init_paint(&paint, bm);
|
|
|
|
|
2014-01-14 11:01:42 +04:00
|
|
|
SkPoint verts[4] = {
|
|
|
|
{ pos.fX, pos.fY },
|
|
|
|
{ pos.fX + bm.width(), pos.fY },
|
|
|
|
{ pos.fX + bm.width(), pos.fY + bm.height() },
|
|
|
|
{ pos.fX, pos.fY + bm.height() }
|
2014-01-09 23:20:45 +04:00
|
|
|
};
|
2014-01-10 11:08:11 +04:00
|
|
|
SkPoint texs[4] = { { 0, 0 },
|
|
|
|
{ SkIntToScalar(bm.width()), 0 },
|
|
|
|
{ SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) },
|
2014-01-09 23:20:45 +04:00
|
|
|
{ 0, SkIntToScalar(bm.height()) } };
|
|
|
|
uint16_t indices[6] = { 0, 1, 2, 0, 2, 3 };
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
canvas->drawVertices(SkCanvas::kTriangles_VertexMode, 4, verts, texs, NULL, NULL,
|
2014-01-09 23:20:45 +04:00
|
|
|
indices, 6, paint);
|
2014-01-13 17:33:26 +04:00
|
|
|
*usedPixRefs->append() = bm.pixelRef();
|
2014-01-09 23:20:45 +04:00
|
|
|
}
|
|
|
|
|
2012-11-30 01:00:39 +04:00
|
|
|
// Return a picture with the bitmaps drawn at the specified positions.
|
2014-01-14 11:01:42 +04:00
|
|
|
static SkPicture* record_bitmaps(const SkBitmap bm[],
|
2014-01-13 17:33:26 +04:00
|
|
|
const SkPoint pos[],
|
|
|
|
SkTDArray<SkPixelRef*> analytic[],
|
2014-01-14 11:01:42 +04:00
|
|
|
int count,
|
2014-01-13 17:33:26 +04:00
|
|
|
DrawBitmapProc proc) {
|
2012-11-30 01:00:39 +04:00
|
|
|
SkPicture* pic = new SkPicture;
|
|
|
|
SkCanvas* canvas = pic->beginRecording(1000, 1000);
|
|
|
|
for (int i = 0; i < count; ++i) {
|
2014-01-13 17:33:26 +04:00
|
|
|
analytic[i].rewind();
|
2014-01-09 23:20:45 +04:00
|
|
|
canvas->save();
|
|
|
|
SkRect clipRect = SkRect::MakeXYWH(pos[i].fX, pos[i].fY,
|
|
|
|
SkIntToScalar(bm[i].width()),
|
|
|
|
SkIntToScalar(bm[i].height()));
|
|
|
|
canvas->clipRect(clipRect, SkRegion::kIntersect_Op);
|
2014-01-13 17:33:26 +04:00
|
|
|
proc(canvas, bm[i], bm[count+i], pos[i], &analytic[i]);
|
2014-01-09 23:20:45 +04:00
|
|
|
canvas->restore();
|
2012-11-30 01:00:39 +04:00
|
|
|
}
|
|
|
|
pic->endRecording();
|
|
|
|
return pic;
|
|
|
|
}
|
|
|
|
|
2013-09-10 00:09:12 +04:00
|
|
|
static void rand_rect(SkRect* rect, SkRandom& rand, SkScalar W, SkScalar H) {
|
2012-11-30 01:00:39 +04:00
|
|
|
rect->fLeft = rand.nextRangeScalar(-W, 2*W);
|
|
|
|
rect->fTop = rand.nextRangeScalar(-H, 2*H);
|
|
|
|
rect->fRight = rect->fLeft + rand.nextRangeScalar(0, W);
|
|
|
|
rect->fBottom = rect->fTop + rand.nextRangeScalar(0, H);
|
|
|
|
|
|
|
|
// we integralize rect to make our tests more predictable, since Gather is
|
|
|
|
// a little sloppy.
|
|
|
|
SkIRect ir;
|
|
|
|
rect->round(&ir);
|
|
|
|
rect->set(ir);
|
|
|
|
}
|
|
|
|
|
2014-01-09 23:20:45 +04:00
|
|
|
static void draw(SkPicture* pic, int width, int height, SkBitmap* result) {
|
|
|
|
make_bm(result, width, height, SK_ColorBLACK, false);
|
2012-11-30 01:00:39 +04:00
|
|
|
|
|
|
|
SkCanvas canvas(*result);
|
|
|
|
canvas.drawPicture(*pic);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T> int find_index(const T* array, T elem, int count) {
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
|
if (array[i] == elem) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return true if 'ref' is found in array[]
|
|
|
|
static bool find(SkPixelRef const * const * array, SkPixelRef const * ref, int count) {
|
|
|
|
return find_index<const SkPixelRef*>(array, ref, count) >= 0;
|
|
|
|
}
|
|
|
|
|
2014-01-10 11:08:11 +04:00
|
|
|
// Look at each pixel that is inside 'subset', and if its color appears in
|
|
|
|
// colors[], find the corresponding value in refs[] and append that ref into
|
2014-01-09 23:20:45 +04:00
|
|
|
// array, skipping duplicates of the same value.
|
|
|
|
// Note that gathering pixelRefs from rendered colors suffers from the problem
|
|
|
|
// that multiple simultaneous textures (e.g., A8 for alpha and 8888 for color)
|
|
|
|
// isn't easy to reconstruct.
|
|
|
|
static void gather_from_image(const SkBitmap& bm, SkPixelRef* const refs[],
|
|
|
|
int count, SkTDArray<SkPixelRef*>* array,
|
|
|
|
const SkRect& subset) {
|
|
|
|
SkIRect ir;
|
|
|
|
subset.roundOut(&ir);
|
|
|
|
|
|
|
|
if (!ir.intersect(0, 0, bm.width()-1, bm.height()-1)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-11-30 01:00:39 +04:00
|
|
|
// Since we only want to return unique values in array, when we scan we just
|
|
|
|
// set a bit for each index'd color found. In practice we only have a few
|
|
|
|
// distinct colors, so we just use an int's bits as our array. Hence the
|
|
|
|
// assert that count <= number-of-bits-in-our-int.
|
|
|
|
SkASSERT((unsigned)count <= 32);
|
|
|
|
uint32_t bitarray = 0;
|
|
|
|
|
|
|
|
SkAutoLockPixels alp(bm);
|
|
|
|
|
2014-01-09 23:20:45 +04:00
|
|
|
for (int y = ir.fTop; y < ir.fBottom; ++y) {
|
|
|
|
for (int x = ir.fLeft; x < ir.fRight; ++x) {
|
2012-11-30 01:00:39 +04:00
|
|
|
SkPMColor pmc = *bm.getAddr32(x, y);
|
|
|
|
// the only good case where the color is not found would be if
|
|
|
|
// the color is transparent, meaning no bitmap was drawn in that
|
|
|
|
// pixel.
|
|
|
|
if (pmc) {
|
2013-01-08 21:24:44 +04:00
|
|
|
uint32_t index = SkGetPackedR32(pmc);
|
2012-11-30 01:00:39 +04:00
|
|
|
SkASSERT(SkGetPackedG32(pmc) == index);
|
|
|
|
SkASSERT(SkGetPackedB32(pmc) == index);
|
2014-01-09 23:20:45 +04:00
|
|
|
if (0 == index) {
|
|
|
|
continue; // background color
|
|
|
|
}
|
|
|
|
SkASSERT(0 == (index - gColorOffset) % gColorScale);
|
|
|
|
index = (index - gColorOffset) / gColorScale;
|
2013-01-08 22:42:20 +04:00
|
|
|
SkASSERT(static_cast<int>(index) < count);
|
2012-11-30 01:00:39 +04:00
|
|
|
bitarray |= 1 << index;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
|
if (bitarray & (1 << i)) {
|
|
|
|
*array->append() = refs[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-13 17:46:45 +04:00
|
|
|
static void gather_from_analytic(const SkPoint pos[], SkScalar w, SkScalar h,
|
2014-01-14 11:01:42 +04:00
|
|
|
const SkTDArray<SkPixelRef*> analytic[],
|
|
|
|
int count,
|
|
|
|
SkTDArray<SkPixelRef*>* result,
|
2014-01-13 17:46:45 +04:00
|
|
|
const SkRect& subset) {
|
2014-01-13 17:33:26 +04:00
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
|
SkRect rect = SkRect::MakeXYWH(pos[i].fX, pos[i].fY, w, h);
|
|
|
|
|
|
|
|
if (SkRect::Intersects(subset, rect)) {
|
|
|
|
result->append(analytic[i].count(), analytic[i].begin());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-06 00:59:45 +04:00
|
|
|
|
|
|
|
static const struct {
|
|
|
|
const DrawBitmapProc proc;
|
|
|
|
const char* const desc;
|
|
|
|
} gProcs[] = {
|
|
|
|
{drawpaint_proc, "drawpaint"},
|
|
|
|
{drawpoints_proc, "drawpoints"},
|
|
|
|
{drawrect_proc, "drawrect"},
|
|
|
|
{drawoval_proc, "drawoval"},
|
|
|
|
{drawrrect_proc, "drawrrect"},
|
|
|
|
{drawpath_proc, "drawpath"},
|
|
|
|
{drawbitmap_proc, "drawbitmap"},
|
|
|
|
{drawbitmap_withshader_proc, "drawbitmap_withshader"},
|
|
|
|
{drawsprite_proc, "drawsprite"},
|
2014-01-13 17:33:26 +04:00
|
|
|
#if 0
|
2014-03-06 00:59:45 +04:00
|
|
|
{drawsprite_withshader_proc, "drawsprite_withshader"},
|
2014-01-13 17:33:26 +04:00
|
|
|
#endif
|
2014-03-06 00:59:45 +04:00
|
|
|
{drawbitmaprect_proc, "drawbitmaprect"},
|
|
|
|
{drawbitmaprect_withshader_proc, "drawbitmaprect_withshader"},
|
|
|
|
{drawtext_proc, "drawtext"},
|
|
|
|
{drawpostext_proc, "drawpostext"},
|
|
|
|
{drawtextonpath_proc, "drawtextonpath"},
|
|
|
|
{drawverts_proc, "drawverts"},
|
2014-01-13 17:33:26 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
static void create_textures(SkBitmap* bm, SkPixelRef** refs, int num, int w, int h) {
|
2014-01-14 11:01:42 +04:00
|
|
|
// Our convention is that the color components contain an encoding of
|
|
|
|
// the index of their corresponding bitmap/pixelref. (0,0,0,0) is
|
2014-01-13 17:33:26 +04:00
|
|
|
// reserved for the background
|
|
|
|
for (int i = 0; i < num; ++i) {
|
2014-01-14 11:01:42 +04:00
|
|
|
make_bm(&bm[i], w, h,
|
|
|
|
SkColorSetARGB(0xFF,
|
|
|
|
gColorScale*i+gColorOffset,
|
|
|
|
gColorScale*i+gColorOffset,
|
|
|
|
gColorScale*i+gColorOffset),
|
2014-01-13 17:33:26 +04:00
|
|
|
true);
|
|
|
|
refs[i] = bm[i].pixelRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
// The A8 alternate bitmaps are all BW checkerboards
|
|
|
|
for (int i = 0; i < num; ++i) {
|
|
|
|
make_checkerboard(&bm[num+i], w, h, true);
|
|
|
|
refs[num+i] = bm[num+i].pixelRef();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-30 01:00:39 +04:00
|
|
|
static void test_gatherpixelrefs(skiatest::Reporter* reporter) {
|
2014-01-09 23:20:45 +04:00
|
|
|
const int IW = 32;
|
2012-11-30 01:00:39 +04:00
|
|
|
const int IH = IW;
|
|
|
|
const SkScalar W = SkIntToScalar(IW);
|
|
|
|
const SkScalar H = W;
|
|
|
|
|
|
|
|
static const int N = 4;
|
2014-01-09 23:20:45 +04:00
|
|
|
SkBitmap bm[2*N];
|
|
|
|
SkPixelRef* refs[2*N];
|
2014-01-13 17:33:26 +04:00
|
|
|
SkTDArray<SkPixelRef*> analytic[N];
|
2012-11-30 01:00:39 +04:00
|
|
|
|
2014-01-09 23:20:45 +04:00
|
|
|
const SkPoint pos[N] = {
|
2012-11-30 01:00:39 +04:00
|
|
|
{ 0, 0 }, { W, 0 }, { 0, H }, { W, H }
|
|
|
|
};
|
|
|
|
|
2014-01-13 17:33:26 +04:00
|
|
|
create_textures(bm, refs, N, IW, IH);
|
2012-11-30 01:00:39 +04:00
|
|
|
|
2013-09-10 00:09:12 +04:00
|
|
|
SkRandom rand;
|
2014-01-13 17:33:26 +04:00
|
|
|
for (size_t k = 0; k < SK_ARRAY_COUNT(gProcs); ++k) {
|
2014-03-06 00:59:45 +04:00
|
|
|
SkAutoTUnref<SkPicture> pic(
|
|
|
|
record_bitmaps(bm, pos, analytic, N, gProcs[k].proc));
|
2012-11-30 01:00:39 +04:00
|
|
|
|
2013-10-24 15:12:47 +04:00
|
|
|
REPORTER_ASSERT(reporter, pic->willPlayBackBitmaps() || N == 0);
|
2012-11-30 01:00:39 +04:00
|
|
|
// quick check for a small piece of each quadrant, which should just
|
2014-01-13 17:33:26 +04:00
|
|
|
// contain 1 or 2 bitmaps.
|
2012-11-30 01:00:39 +04:00
|
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(pos); ++i) {
|
|
|
|
SkRect r;
|
|
|
|
r.set(2, 2, W - 2, H - 2);
|
|
|
|
r.offset(pos[i].fX, pos[i].fY);
|
|
|
|
SkAutoDataUnref data(SkPictureUtils::GatherPixelRefs(pic, r));
|
2014-03-06 00:59:45 +04:00
|
|
|
if (!data) {
|
|
|
|
ERRORF(reporter, "SkPictureUtils::GatherPixelRefs returned "
|
|
|
|
"NULL for %s.", gProcs[k].desc);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
SkPixelRef** gatheredRefs = (SkPixelRef**)data->data();
|
|
|
|
int count = static_cast<int>(data->size() / sizeof(SkPixelRef*));
|
|
|
|
REPORTER_ASSERT(reporter, 1 == count || 2 == count);
|
|
|
|
if (1 == count) {
|
|
|
|
REPORTER_ASSERT(reporter, gatheredRefs[0] == refs[i]);
|
|
|
|
} else if (2 == count) {
|
|
|
|
REPORTER_ASSERT(reporter,
|
|
|
|
(gatheredRefs[0] == refs[i] && gatheredRefs[1] == refs[i+N]) ||
|
|
|
|
(gatheredRefs[1] == refs[i] && gatheredRefs[0] == refs[i+N]));
|
2013-07-09 20:04:32 +04:00
|
|
|
}
|
2012-11-30 01:00:39 +04:00
|
|
|
}
|
|
|
|
|
2014-01-09 23:20:45 +04:00
|
|
|
SkBitmap image;
|
|
|
|
draw(pic, 2*IW, 2*IH, &image);
|
|
|
|
|
2012-11-30 01:00:39 +04:00
|
|
|
// Test a bunch of random (mostly) rects, and compare the gather results
|
|
|
|
// with a deduced list of refs by looking at the colors drawn.
|
|
|
|
for (int j = 0; j < 100; ++j) {
|
|
|
|
SkRect r;
|
|
|
|
rand_rect(&r, rand, 2*W, 2*H);
|
|
|
|
|
2014-01-13 17:33:26 +04:00
|
|
|
SkTDArray<SkPixelRef*> fromImage;
|
|
|
|
gather_from_image(image, refs, N, &fromImage, r);
|
|
|
|
|
|
|
|
SkTDArray<SkPixelRef*> fromAnalytic;
|
|
|
|
gather_from_analytic(pos, W, H, analytic, N, &fromAnalytic, r);
|
2012-11-30 01:00:39 +04:00
|
|
|
|
|
|
|
SkData* data = SkPictureUtils::GatherPixelRefs(pic, r);
|
|
|
|
size_t dataSize = data ? data->size() : 0;
|
2013-10-16 21:48:11 +04:00
|
|
|
int gatherCount = static_cast<int>(dataSize / sizeof(SkPixelRef*));
|
2012-11-30 01:00:39 +04:00
|
|
|
SkASSERT(gatherCount * sizeof(SkPixelRef*) == dataSize);
|
|
|
|
SkPixelRef** gatherRefs = data ? (SkPixelRef**)(data->data()) : NULL;
|
|
|
|
SkAutoDataUnref adu(data);
|
|
|
|
|
2014-01-13 17:33:26 +04:00
|
|
|
// Everything that we saw drawn should appear in the analytic list
|
|
|
|
// but the analytic list may contain some pixelRefs that were not
|
|
|
|
// seen in the image (e.g., A8 textures used as masks)
|
|
|
|
for (int i = 0; i < fromImage.count(); ++i) {
|
2014-03-06 00:59:45 +04:00
|
|
|
if (-1 == fromAnalytic.find(fromImage[i])) {
|
|
|
|
ERRORF(reporter, "PixelRef missing %d %s",
|
|
|
|
i, gProcs[k].desc);
|
|
|
|
}
|
2014-01-13 17:33:26 +04:00
|
|
|
}
|
2012-11-30 06:01:24 +04:00
|
|
|
|
2012-11-30 01:00:39 +04:00
|
|
|
/*
|
|
|
|
* GatherPixelRefs is conservative, so it can return more bitmaps
|
2014-01-13 17:33:26 +04:00
|
|
|
* than are strictly required. Thus our check here is only that
|
|
|
|
* Gather didn't miss any that we actually needed. Even that isn't
|
2012-11-30 01:00:39 +04:00
|
|
|
* a strict requirement on Gather, which is meant to be quick and
|
|
|
|
* only mostly-correct, but at the moment this test should work.
|
|
|
|
*/
|
2014-01-13 17:33:26 +04:00
|
|
|
for (int i = 0; i < fromAnalytic.count(); ++i) {
|
|
|
|
bool found = find(gatherRefs, fromAnalytic[i], gatherCount);
|
2014-03-06 00:59:45 +04:00
|
|
|
if (!found) {
|
|
|
|
ERRORF(reporter, "PixelRef missing %d %s",
|
|
|
|
i, gProcs[k].desc);
|
|
|
|
}
|
2012-11-30 01:00:39 +04:00
|
|
|
#if 0
|
|
|
|
// enable this block of code to debug failures, as it will rerun
|
|
|
|
// the case that failed.
|
|
|
|
if (!found) {
|
|
|
|
SkData* data = SkPictureUtils::GatherPixelRefs(pic, r);
|
|
|
|
size_t dataSize = data ? data->size() : 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-13 17:33:26 +04:00
|
|
|
static void test_gatherpixelrefsandrects(skiatest::Reporter* reporter) {
|
|
|
|
const int IW = 32;
|
|
|
|
const int IH = IW;
|
|
|
|
const SkScalar W = SkIntToScalar(IW);
|
|
|
|
const SkScalar H = W;
|
|
|
|
|
|
|
|
static const int N = 4;
|
|
|
|
SkBitmap bm[2*N];
|
|
|
|
SkPixelRef* refs[2*N];
|
|
|
|
SkTDArray<SkPixelRef*> analytic[N];
|
|
|
|
|
|
|
|
const SkPoint pos[N] = {
|
|
|
|
{ 0, 0 }, { W, 0 }, { 0, H }, { W, H }
|
|
|
|
};
|
|
|
|
|
|
|
|
create_textures(bm, refs, N, IW, IH);
|
|
|
|
|
|
|
|
SkRandom rand;
|
|
|
|
for (size_t k = 0; k < SK_ARRAY_COUNT(gProcs); ++k) {
|
2014-03-06 00:59:45 +04:00
|
|
|
SkAutoTUnref<SkPicture> pic(
|
|
|
|
record_bitmaps(bm, pos, analytic, N, gProcs[k].proc));
|
2014-01-13 17:33:26 +04:00
|
|
|
|
|
|
|
REPORTER_ASSERT(reporter, pic->willPlayBackBitmaps() || N == 0);
|
|
|
|
|
|
|
|
SkAutoTUnref<SkPictureUtils::SkPixelRefContainer> prCont(
|
|
|
|
new SkPictureUtils::SkPixelRefsAndRectsList);
|
|
|
|
|
|
|
|
SkPictureUtils::GatherPixelRefsAndRects(pic, prCont);
|
|
|
|
|
|
|
|
// quick check for a small piece of each quadrant, which should just
|
|
|
|
// contain 1 or 2 bitmaps.
|
|
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(pos); ++i) {
|
|
|
|
SkRect r;
|
|
|
|
r.set(2, 2, W - 2, H - 2);
|
|
|
|
r.offset(pos[i].fX, pos[i].fY);
|
|
|
|
|
|
|
|
SkTDArray<SkPixelRef*> gatheredRefs;
|
|
|
|
prCont->query(r, &gatheredRefs);
|
|
|
|
|
|
|
|
int count = gatheredRefs.count();
|
|
|
|
REPORTER_ASSERT(reporter, 1 == count || 2 == count);
|
|
|
|
if (1 == count) {
|
|
|
|
REPORTER_ASSERT(reporter, gatheredRefs[0] == refs[i]);
|
|
|
|
} else if (2 == count) {
|
2014-01-14 11:01:42 +04:00
|
|
|
REPORTER_ASSERT(reporter,
|
2014-01-13 17:33:26 +04:00
|
|
|
(gatheredRefs[0] == refs[i] && gatheredRefs[1] == refs[i+N]) ||
|
|
|
|
(gatheredRefs[1] == refs[i] && gatheredRefs[0] == refs[i+N]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SkBitmap image;
|
|
|
|
draw(pic, 2*IW, 2*IH, &image);
|
|
|
|
|
|
|
|
// Test a bunch of random (mostly) rects, and compare the gather results
|
|
|
|
// with the analytic results and the pixel refs seen in a rendering.
|
|
|
|
for (int j = 0; j < 100; ++j) {
|
|
|
|
SkRect r;
|
|
|
|
rand_rect(&r, rand, 2*W, 2*H);
|
|
|
|
|
|
|
|
SkTDArray<SkPixelRef*> fromImage;
|
|
|
|
gather_from_image(image, refs, N, &fromImage, r);
|
|
|
|
|
|
|
|
SkTDArray<SkPixelRef*> fromAnalytic;
|
|
|
|
gather_from_analytic(pos, W, H, analytic, N, &fromAnalytic, r);
|
|
|
|
|
|
|
|
SkTDArray<SkPixelRef*> gatheredRefs;
|
|
|
|
prCont->query(r, &gatheredRefs);
|
|
|
|
|
|
|
|
// Everything that we saw drawn should appear in the analytic list
|
|
|
|
// but the analytic list may contain some pixelRefs that were not
|
|
|
|
// seen in the image (e.g., A8 textures used as masks)
|
|
|
|
for (int i = 0; i < fromImage.count(); ++i) {
|
|
|
|
REPORTER_ASSERT(reporter, -1 != fromAnalytic.find(fromImage[i]));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Everything in the analytic list should appear in the gathered
|
2014-01-14 11:01:42 +04:00
|
|
|
// list.
|
2014-01-13 17:33:26 +04:00
|
|
|
for (int i = 0; i < fromAnalytic.count(); ++i) {
|
|
|
|
REPORTER_ASSERT(reporter, -1 != gatheredRefs.find(fromAnalytic[i]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-14 21:26:37 +04:00
|
|
|
#ifdef SK_DEBUG
|
|
|
|
// Ensure that deleting SkPicturePlayback does not assert. Asserts only fire in debug mode, so only
|
|
|
|
// run in debug mode.
|
|
|
|
static void test_deleting_empty_playback() {
|
|
|
|
SkPicture picture;
|
|
|
|
// Creates an SkPictureRecord
|
|
|
|
picture.beginRecording(0, 0);
|
|
|
|
// Turns that into an SkPicturePlayback
|
|
|
|
picture.endRecording();
|
|
|
|
// Deletes the old SkPicturePlayback, and creates a new SkPictureRecord
|
|
|
|
picture.beginRecording(0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure that serializing an empty picture does not assert. Likewise only runs in debug mode.
|
|
|
|
static void test_serializing_empty_picture() {
|
|
|
|
SkPicture picture;
|
|
|
|
picture.beginRecording(0, 0);
|
|
|
|
picture.endRecording();
|
|
|
|
SkDynamicMemoryWStream stream;
|
|
|
|
picture.serialize(&stream);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-09-10 00:09:12 +04:00
|
|
|
static void rand_op(SkCanvas* canvas, SkRandom& rand) {
|
2012-10-02 21:42:15 +04:00
|
|
|
SkPaint paint;
|
|
|
|
SkRect rect = SkRect::MakeWH(50, 50);
|
|
|
|
|
|
|
|
SkScalar unit = rand.nextUScalar1();
|
|
|
|
if (unit <= 0.3) {
|
|
|
|
// SkDebugf("save\n");
|
|
|
|
canvas->save();
|
|
|
|
} else if (unit <= 0.6) {
|
|
|
|
// SkDebugf("restore\n");
|
|
|
|
canvas->restore();
|
|
|
|
} else if (unit <= 0.9) {
|
|
|
|
// SkDebugf("clip\n");
|
|
|
|
canvas->clipRect(rect);
|
|
|
|
} else {
|
|
|
|
// SkDebugf("draw\n");
|
|
|
|
canvas->drawPaint(paint);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-13 20:00:51 +04:00
|
|
|
static void set_canvas_to_save_count_4(SkCanvas* canvas) {
|
|
|
|
canvas->restoreToCount(1);
|
|
|
|
canvas->save();
|
|
|
|
canvas->save();
|
|
|
|
canvas->save();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_unbalanced_save_restores(skiatest::Reporter* reporter) {
|
|
|
|
SkCanvas testCanvas(100, 100);
|
|
|
|
set_canvas_to_save_count_4(&testCanvas);
|
|
|
|
|
|
|
|
REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
|
|
|
|
|
|
|
|
SkPaint paint;
|
|
|
|
SkRect rect = SkRect::MakeLTRB(-10000000, -10000000, 10000000, 10000000);
|
|
|
|
|
|
|
|
SkPicture extra_save_picture;
|
|
|
|
extra_save_picture.beginRecording(100, 100);
|
|
|
|
extra_save_picture.getRecordingCanvas()->save();
|
|
|
|
extra_save_picture.getRecordingCanvas()->translate(10, 10);
|
|
|
|
extra_save_picture.getRecordingCanvas()->drawRect(rect, paint);
|
|
|
|
extra_save_picture.getRecordingCanvas()->save();
|
|
|
|
extra_save_picture.getRecordingCanvas()->translate(10, 10);
|
|
|
|
extra_save_picture.getRecordingCanvas()->drawRect(rect, paint);
|
|
|
|
|
|
|
|
testCanvas.drawPicture(extra_save_picture);
|
|
|
|
REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
|
|
|
|
|
|
|
|
set_canvas_to_save_count_4(&testCanvas);
|
|
|
|
|
|
|
|
SkPicture extra_restore_picture;
|
|
|
|
extra_restore_picture.beginRecording(100, 100);
|
|
|
|
extra_restore_picture.getRecordingCanvas()->save();
|
|
|
|
extra_restore_picture.getRecordingCanvas()->translate(10, 10);
|
|
|
|
extra_restore_picture.getRecordingCanvas()->drawRect(rect, paint);
|
|
|
|
extra_restore_picture.getRecordingCanvas()->save();
|
|
|
|
extra_restore_picture.getRecordingCanvas()->translate(10, 10);
|
|
|
|
extra_restore_picture.getRecordingCanvas()->drawRect(rect, paint);
|
|
|
|
extra_restore_picture.getRecordingCanvas()->restore();
|
|
|
|
extra_restore_picture.getRecordingCanvas()->restore();
|
|
|
|
extra_restore_picture.getRecordingCanvas()->restore();
|
|
|
|
extra_restore_picture.getRecordingCanvas()->restore();
|
|
|
|
|
|
|
|
testCanvas.drawPicture(extra_save_picture);
|
|
|
|
REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
|
|
|
|
|
|
|
|
SkPicture no_save_picture;
|
|
|
|
extra_restore_picture.beginRecording(100, 100);
|
|
|
|
extra_restore_picture.getRecordingCanvas()->translate(10, 10);
|
|
|
|
extra_restore_picture.getRecordingCanvas()->drawRect(rect, paint);
|
|
|
|
|
|
|
|
testCanvas.drawPicture(extra_save_picture);
|
|
|
|
REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
|
|
|
|
REPORTER_ASSERT(reporter, testCanvas.getTotalMatrix().isIdentity());
|
|
|
|
}
|
|
|
|
|
2013-02-27 23:17:41 +04:00
|
|
|
static void test_peephole() {
|
2013-09-10 00:09:12 +04:00
|
|
|
SkRandom rand;
|
2012-10-02 21:42:15 +04:00
|
|
|
|
|
|
|
for (int j = 0; j < 100; j++) {
|
2013-09-10 00:09:12 +04:00
|
|
|
SkRandom rand2(rand); // remember the seed
|
2012-10-02 21:42:15 +04:00
|
|
|
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(100, 100);
|
|
|
|
|
|
|
|
for (int i = 0; i < 1000; ++i) {
|
|
|
|
rand_op(canvas, rand);
|
|
|
|
}
|
|
|
|
picture.endRecording();
|
2013-03-04 17:56:38 +04:00
|
|
|
|
|
|
|
rand = rand2;
|
2012-10-02 21:42:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(100, 100);
|
|
|
|
SkRect rect = SkRect::MakeWH(50, 50);
|
2012-10-03 06:01:13 +04:00
|
|
|
|
2012-10-02 21:42:15 +04:00
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
|
|
canvas->save();
|
|
|
|
}
|
|
|
|
while (canvas->getSaveCount() > 1) {
|
|
|
|
canvas->clipRect(rect);
|
|
|
|
canvas->restore();
|
|
|
|
}
|
|
|
|
picture.endRecording();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-04 19:08:56 +04:00
|
|
|
#ifndef SK_DEBUG
|
|
|
|
// Only test this is in release mode. We deliberately crash in debug mode, since a valid caller
|
|
|
|
// should never do this.
|
|
|
|
static void test_bad_bitmap() {
|
|
|
|
// This bitmap has a width and height but no pixels. As a result, attempting to record it will
|
|
|
|
// fail.
|
|
|
|
SkBitmap bm;
|
2014-02-13 18:41:43 +04:00
|
|
|
bm.setConfig(SkImageInfo::MakeN32Premul(100, 100));
|
2012-12-04 19:08:56 +04:00
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* recordingCanvas = picture.beginRecording(100, 100);
|
|
|
|
recordingCanvas->drawBitmap(bm, 0, 0);
|
|
|
|
picture.endRecording();
|
|
|
|
|
|
|
|
SkCanvas canvas;
|
|
|
|
canvas.drawPicture(picture);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-01-08 19:42:01 +04:00
|
|
|
static SkData* encode_bitmap_to_data(size_t*, const SkBitmap& bm) {
|
2013-05-22 00:31:23 +04:00
|
|
|
return SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, 100);
|
2012-12-10 19:40:55 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static SkData* serialized_picture_from_bitmap(const SkBitmap& bitmap) {
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(bitmap.width(), bitmap.height());
|
|
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
|
|
SkDynamicMemoryWStream wStream;
|
2013-05-22 00:31:23 +04:00
|
|
|
picture.serialize(&wStream, &encode_bitmap_to_data);
|
2012-12-10 19:40:55 +04:00
|
|
|
return wStream.copyToData();
|
|
|
|
}
|
|
|
|
|
2013-04-25 22:29:32 +04:00
|
|
|
struct ErrorContext {
|
|
|
|
int fErrors;
|
|
|
|
skiatest::Reporter* fReporter;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void assert_one_parse_error_cb(SkError error, void* context) {
|
|
|
|
ErrorContext* errorContext = static_cast<ErrorContext*>(context);
|
|
|
|
errorContext->fErrors++;
|
|
|
|
// This test only expects one error, and that is a kParseError. If there are others,
|
|
|
|
// there is some unknown problem.
|
|
|
|
REPORTER_ASSERT_MESSAGE(errorContext->fReporter, 1 == errorContext->fErrors,
|
|
|
|
"This threw more errors than expected.");
|
|
|
|
REPORTER_ASSERT_MESSAGE(errorContext->fReporter, kParseError_SkError == error,
|
|
|
|
SkGetLastErrorString());
|
|
|
|
}
|
|
|
|
|
2012-12-10 19:40:55 +04:00
|
|
|
static void test_bitmap_with_encoded_data(skiatest::Reporter* reporter) {
|
|
|
|
// Create a bitmap that will be encoded.
|
|
|
|
SkBitmap original;
|
|
|
|
make_bm(&original, 100, 100, SK_ColorBLUE, true);
|
|
|
|
SkDynamicMemoryWStream wStream;
|
|
|
|
if (!SkImageEncoder::EncodeStream(&wStream, original, SkImageEncoder::kPNG_Type, 100)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
SkAutoDataUnref data(wStream.copyToData());
|
|
|
|
|
|
|
|
SkBitmap bm;
|
Add Options to SkDecodingImageGenerator, simplify API.
Motivation: We want to remove redundant classes from Skia. To
that end we want to remove SkImageRef and its subclasses and
replace their uses with SkDiscardablePixelRef +
SkDecodingImageGenerator. Since Android uses SkImageRef, we need
to make sure that SkDecodingImageGenerator allows all of the
settings that Android exposes in BitmapFactory.Options.
To that end, we have created an Options struct for the
SkDecodingImageGenerator which lets the client of the generator set
sample size, dithering, and bitmap config.
We have made the SkDecodingImageGenerator constructor private
and replaced the SkDecodingImageGenerator::Install functions
with a SkDecodingImageGenerator::Create functions (one for
SkData and one for SkStream) which now take a
SkDecodingImageGenerator::Options struct.
Also added a ImageDecoderOptions test which loops through a list
of sets of options and tries them on a set of 5 small encoded
images.
Also updated several users of SkDecodingImageGenerator::Install to
follow new call signature - gm/factory.cpp, LazyDecodeBitmap.cpp,
and PictureTest.cpp, CachedDecodingPixelRefTest.cpp.
We also added a new ImprovedBitmapFactory Test which simulates the
exact function that Android will need to modify to use this,
installPixelRef() in BitmapFactory.
R=reed@google.com, scroggo@google.com
Committed: https://code.google.com/p/skia/source/detail?r=12744
Review URL: https://codereview.chromium.org/93703004
git-svn-id: http://skia.googlecode.com/svn/trunk@12855 2bbb7eff-a529-9590-31e7-b0007b416f81
2014-01-02 17:15:13 +04:00
|
|
|
bool installSuccess = SkInstallDiscardablePixelRef(
|
|
|
|
SkDecodingImageGenerator::Create(data, SkDecodingImageGenerator::Options()), &bm, NULL);
|
2013-12-13 23:45:58 +04:00
|
|
|
REPORTER_ASSERT(reporter, installSuccess);
|
2012-12-10 19:40:55 +04:00
|
|
|
|
|
|
|
// Write both bitmaps to pictures, and ensure that the resulting data streams are the same.
|
|
|
|
// Flattening original will follow the old path of performing an encode, while flattening bm
|
|
|
|
// will use the already encoded data.
|
|
|
|
SkAutoDataUnref picture1(serialized_picture_from_bitmap(original));
|
|
|
|
SkAutoDataUnref picture2(serialized_picture_from_bitmap(bm));
|
|
|
|
REPORTER_ASSERT(reporter, picture1->equals(picture2));
|
2013-04-25 22:29:32 +04:00
|
|
|
// Now test that a parse error was generated when trying to create a new SkPicture without
|
|
|
|
// providing a function to decode the bitmap.
|
|
|
|
ErrorContext context;
|
|
|
|
context.fErrors = 0;
|
|
|
|
context.fReporter = reporter;
|
|
|
|
SkSetErrorCallback(assert_one_parse_error_cb, &context);
|
|
|
|
SkMemoryStream pictureStream(picture1);
|
|
|
|
SkClearLastError();
|
2013-06-29 01:32:00 +04:00
|
|
|
SkAutoUnref pictureFromStream(SkPicture::CreateFromStream(&pictureStream, NULL));
|
|
|
|
REPORTER_ASSERT(reporter, pictureFromStream.get() != NULL);
|
2013-04-25 22:29:32 +04:00
|
|
|
SkClearLastError();
|
|
|
|
SkSetErrorCallback(NULL, NULL);
|
2012-12-10 19:40:55 +04:00
|
|
|
}
|
|
|
|
|
2013-01-29 01:04:44 +04:00
|
|
|
static void test_clone_empty(skiatest::Reporter* reporter) {
|
|
|
|
// This is a regression test for crbug.com/172062
|
|
|
|
// Before the fix, we used to crash accessing a null pointer when we
|
|
|
|
// had a picture with no paints. This test passes by not crashing.
|
|
|
|
{
|
|
|
|
SkPicture picture;
|
|
|
|
picture.beginRecording(1, 1);
|
|
|
|
picture.endRecording();
|
|
|
|
SkPicture* destPicture = picture.clone();
|
|
|
|
REPORTER_ASSERT(reporter, NULL != destPicture);
|
|
|
|
destPicture->unref();
|
|
|
|
}
|
|
|
|
{
|
|
|
|
// Test without call to endRecording
|
|
|
|
SkPicture picture;
|
|
|
|
picture.beginRecording(1, 1);
|
|
|
|
SkPicture* destPicture = picture.clone();
|
|
|
|
REPORTER_ASSERT(reporter, NULL != destPicture);
|
|
|
|
destPicture->unref();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-18 21:45:32 +04:00
|
|
|
static void test_draw_empty(skiatest::Reporter* reporter) {
|
|
|
|
SkBitmap result;
|
|
|
|
make_bm(&result, 2, 2, SK_ColorBLACK, false);
|
|
|
|
|
|
|
|
SkCanvas canvas(result);
|
|
|
|
|
|
|
|
{
|
|
|
|
// stock SkPicture
|
|
|
|
SkPicture picture;
|
|
|
|
picture.beginRecording(1, 1);
|
|
|
|
picture.endRecording();
|
|
|
|
|
|
|
|
canvas.drawPicture(picture);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// tile grid
|
|
|
|
SkTileGridPicture::TileGridInfo gridInfo;
|
|
|
|
gridInfo.fMargin.setEmpty();
|
|
|
|
gridInfo.fOffset.setZero();
|
|
|
|
gridInfo.fTileInterval.set(1, 1);
|
|
|
|
|
|
|
|
SkTileGridPicture picture(1, 1, gridInfo);
|
|
|
|
picture.beginRecording(1, 1, SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
|
|
|
|
picture.endRecording();
|
|
|
|
|
|
|
|
canvas.drawPicture(picture);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// RTree
|
|
|
|
SkPicture picture;
|
|
|
|
picture.beginRecording(1, 1, SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
|
|
|
|
picture.endRecording();
|
|
|
|
|
|
|
|
canvas.drawPicture(picture);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// quad tree
|
|
|
|
SkQuadTreePicture picture(SkIRect::MakeWH(1, 1));
|
|
|
|
picture.beginRecording(1, 1, SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
|
|
|
|
picture.endRecording();
|
|
|
|
|
|
|
|
canvas.drawPicture(picture);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-08 19:39:13 +04:00
|
|
|
static void test_clip_bound_opt(skiatest::Reporter* reporter) {
|
|
|
|
// Test for crbug.com/229011
|
|
|
|
SkRect rect1 = SkRect::MakeXYWH(SkIntToScalar(4), SkIntToScalar(4),
|
|
|
|
SkIntToScalar(2), SkIntToScalar(2));
|
|
|
|
SkRect rect2 = SkRect::MakeXYWH(SkIntToScalar(7), SkIntToScalar(7),
|
|
|
|
SkIntToScalar(1), SkIntToScalar(1));
|
|
|
|
SkRect rect3 = SkRect::MakeXYWH(SkIntToScalar(6), SkIntToScalar(6),
|
|
|
|
SkIntToScalar(1), SkIntToScalar(1));
|
|
|
|
|
|
|
|
SkPath invPath;
|
|
|
|
invPath.addOval(rect1);
|
|
|
|
invPath.setFillType(SkPath::kInverseEvenOdd_FillType);
|
|
|
|
SkPath path;
|
|
|
|
path.addOval(rect2);
|
|
|
|
SkPath path2;
|
|
|
|
path2.addOval(rect3);
|
|
|
|
SkIRect clipBounds;
|
|
|
|
// Minimalist test set for 100% code coverage of
|
|
|
|
// SkPictureRecord::updateClipConservativelyUsingBounds
|
|
|
|
{
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(10, 10,
|
|
|
|
SkPicture::kUsePathBoundsForClip_RecordingFlag);
|
|
|
|
canvas->clipPath(invPath, SkRegion::kIntersect_Op);
|
|
|
|
bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
|
|
|
|
REPORTER_ASSERT(reporter, true == nonEmpty);
|
|
|
|
REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
|
|
|
|
REPORTER_ASSERT(reporter, 0 == clipBounds.fTop);
|
|
|
|
REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom);
|
|
|
|
REPORTER_ASSERT(reporter, 10 == clipBounds.fRight);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(10, 10,
|
|
|
|
SkPicture::kUsePathBoundsForClip_RecordingFlag);
|
|
|
|
canvas->clipPath(path, SkRegion::kIntersect_Op);
|
|
|
|
canvas->clipPath(invPath, SkRegion::kIntersect_Op);
|
|
|
|
bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
|
|
|
|
REPORTER_ASSERT(reporter, true == nonEmpty);
|
|
|
|
REPORTER_ASSERT(reporter, 7 == clipBounds.fLeft);
|
|
|
|
REPORTER_ASSERT(reporter, 7 == clipBounds.fTop);
|
|
|
|
REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
|
|
|
|
REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(10, 10,
|
|
|
|
SkPicture::kUsePathBoundsForClip_RecordingFlag);
|
|
|
|
canvas->clipPath(path, SkRegion::kIntersect_Op);
|
|
|
|
canvas->clipPath(invPath, SkRegion::kUnion_Op);
|
|
|
|
bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
|
|
|
|
REPORTER_ASSERT(reporter, true == nonEmpty);
|
|
|
|
REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
|
|
|
|
REPORTER_ASSERT(reporter, 0 == clipBounds.fTop);
|
|
|
|
REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom);
|
|
|
|
REPORTER_ASSERT(reporter, 10 == clipBounds.fRight);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(10, 10,
|
|
|
|
SkPicture::kUsePathBoundsForClip_RecordingFlag);
|
|
|
|
canvas->clipPath(path, SkRegion::kDifference_Op);
|
|
|
|
bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
|
|
|
|
REPORTER_ASSERT(reporter, true == nonEmpty);
|
|
|
|
REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
|
|
|
|
REPORTER_ASSERT(reporter, 0 == clipBounds.fTop);
|
|
|
|
REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom);
|
|
|
|
REPORTER_ASSERT(reporter, 10 == clipBounds.fRight);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(10, 10,
|
|
|
|
SkPicture::kUsePathBoundsForClip_RecordingFlag);
|
|
|
|
canvas->clipPath(path, SkRegion::kReverseDifference_Op);
|
|
|
|
bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
|
|
|
|
// True clip is actually empty in this case, but the best
|
|
|
|
// determination we can make using only bounds as input is that the
|
|
|
|
// clip is included in the bounds of 'path'.
|
|
|
|
REPORTER_ASSERT(reporter, true == nonEmpty);
|
|
|
|
REPORTER_ASSERT(reporter, 7 == clipBounds.fLeft);
|
|
|
|
REPORTER_ASSERT(reporter, 7 == clipBounds.fTop);
|
|
|
|
REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
|
|
|
|
REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(10, 10,
|
|
|
|
SkPicture::kUsePathBoundsForClip_RecordingFlag);
|
|
|
|
canvas->clipPath(path, SkRegion::kIntersect_Op);
|
|
|
|
canvas->clipPath(path2, SkRegion::kXOR_Op);
|
|
|
|
bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
|
|
|
|
REPORTER_ASSERT(reporter, true == nonEmpty);
|
|
|
|
REPORTER_ASSERT(reporter, 6 == clipBounds.fLeft);
|
|
|
|
REPORTER_ASSERT(reporter, 6 == clipBounds.fTop);
|
|
|
|
REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
|
|
|
|
REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-27 19:50:19 +04:00
|
|
|
/**
|
|
|
|
* A canvas that records the number of clip commands.
|
|
|
|
*/
|
|
|
|
class ClipCountingCanvas : public SkCanvas {
|
|
|
|
public:
|
2014-01-31 23:42:58 +04:00
|
|
|
explicit ClipCountingCanvas(int width, int height)
|
|
|
|
: INHERITED(width, height)
|
2013-08-27 19:50:19 +04:00
|
|
|
, fClipCount(0){
|
|
|
|
}
|
|
|
|
|
2014-03-01 07:02:09 +04:00
|
|
|
virtual void onClipRect(const SkRect& r,
|
|
|
|
SkRegion::Op op,
|
2014-02-28 22:19:39 +04:00
|
|
|
ClipEdgeStyle edgeStyle) SK_OVERRIDE {
|
2013-08-27 19:50:19 +04:00
|
|
|
fClipCount += 1;
|
2014-02-28 22:19:39 +04:00
|
|
|
this->INHERITED::onClipRect(r, op, edgeStyle);
|
2013-08-27 19:50:19 +04:00
|
|
|
}
|
|
|
|
|
2014-03-01 07:02:09 +04:00
|
|
|
virtual void onClipRRect(const SkRRect& rrect,
|
|
|
|
SkRegion::Op op,
|
2014-02-28 22:19:39 +04:00
|
|
|
ClipEdgeStyle edgeStyle)SK_OVERRIDE {
|
2013-08-27 19:50:19 +04:00
|
|
|
fClipCount += 1;
|
2014-02-28 22:19:39 +04:00
|
|
|
this->INHERITED::onClipRRect(rrect, op, edgeStyle);
|
2013-08-27 19:50:19 +04:00
|
|
|
}
|
|
|
|
|
2014-03-01 07:02:09 +04:00
|
|
|
virtual void onClipPath(const SkPath& path,
|
|
|
|
SkRegion::Op op,
|
2014-02-28 22:19:39 +04:00
|
|
|
ClipEdgeStyle edgeStyle) SK_OVERRIDE {
|
2013-08-27 19:50:19 +04:00
|
|
|
fClipCount += 1;
|
2014-02-28 22:19:39 +04:00
|
|
|
this->INHERITED::onClipPath(path, op, edgeStyle);
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) SK_OVERRIDE {
|
|
|
|
fClipCount += 1;
|
|
|
|
this->INHERITED::onClipRegion(deviceRgn, op);
|
2013-08-27 19:50:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned getClipCount() const { return fClipCount; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
unsigned fClipCount;
|
|
|
|
|
|
|
|
typedef SkCanvas INHERITED;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void test_clip_expansion(skiatest::Reporter* reporter) {
|
|
|
|
SkPicture picture;
|
|
|
|
SkCanvas* canvas = picture.beginRecording(10, 10, 0);
|
|
|
|
|
|
|
|
canvas->clipRect(SkRect::MakeEmpty(), SkRegion::kReplace_Op);
|
|
|
|
// The following expanding clip should not be skipped.
|
|
|
|
canvas->clipRect(SkRect::MakeXYWH(4, 4, 3, 3), SkRegion::kUnion_Op);
|
|
|
|
// Draw something so the optimizer doesn't just fold the world.
|
|
|
|
SkPaint p;
|
|
|
|
p.setColor(SK_ColorBLUE);
|
|
|
|
canvas->drawPaint(p);
|
|
|
|
|
2014-01-31 23:42:58 +04:00
|
|
|
ClipCountingCanvas testCanvas(10, 10);
|
2013-08-27 19:50:19 +04:00
|
|
|
picture.draw(&testCanvas);
|
|
|
|
|
|
|
|
// Both clips should be present on playback.
|
|
|
|
REPORTER_ASSERT(reporter, testCanvas.getClipCount() == 2);
|
|
|
|
}
|
|
|
|
|
2013-10-24 15:12:47 +04:00
|
|
|
static void test_hierarchical(skiatest::Reporter* reporter) {
|
|
|
|
SkBitmap bm;
|
|
|
|
make_bm(&bm, 10, 10, SK_ColorRED, true);
|
|
|
|
|
|
|
|
SkCanvas* canvas;
|
|
|
|
|
|
|
|
SkPicture childPlain;
|
|
|
|
childPlain.beginRecording(10, 10);
|
|
|
|
childPlain.endRecording();
|
|
|
|
REPORTER_ASSERT(reporter, !childPlain.willPlayBackBitmaps()); // 0
|
|
|
|
|
|
|
|
SkPicture childWithBitmap;
|
|
|
|
childWithBitmap.beginRecording(10, 10)->drawBitmap(bm, 0, 0);
|
|
|
|
childWithBitmap.endRecording();
|
|
|
|
REPORTER_ASSERT(reporter, childWithBitmap.willPlayBackBitmaps()); // 1
|
|
|
|
|
|
|
|
SkPicture parentPP;
|
|
|
|
canvas = parentPP.beginRecording(10, 10);
|
|
|
|
canvas->drawPicture(childPlain);
|
|
|
|
parentPP.endRecording();
|
|
|
|
REPORTER_ASSERT(reporter, !parentPP.willPlayBackBitmaps()); // 0
|
|
|
|
|
|
|
|
SkPicture parentPWB;
|
|
|
|
canvas = parentPWB.beginRecording(10, 10);
|
|
|
|
canvas->drawPicture(childWithBitmap);
|
|
|
|
parentPWB.endRecording();
|
|
|
|
REPORTER_ASSERT(reporter, parentPWB.willPlayBackBitmaps()); // 1
|
|
|
|
|
|
|
|
SkPicture parentWBP;
|
|
|
|
canvas = parentWBP.beginRecording(10, 10);
|
|
|
|
canvas->drawBitmap(bm, 0, 0);
|
|
|
|
canvas->drawPicture(childPlain);
|
|
|
|
parentWBP.endRecording();
|
|
|
|
REPORTER_ASSERT(reporter, parentWBP.willPlayBackBitmaps()); // 1
|
|
|
|
|
|
|
|
SkPicture parentWBWB;
|
|
|
|
canvas = parentWBWB.beginRecording(10, 10);
|
|
|
|
canvas->drawBitmap(bm, 0, 0);
|
|
|
|
canvas->drawPicture(childWithBitmap);
|
|
|
|
parentWBWB.endRecording();
|
|
|
|
REPORTER_ASSERT(reporter, parentWBWB.willPlayBackBitmaps()); // 2
|
|
|
|
}
|
|
|
|
|
2014-04-03 03:51:13 +04:00
|
|
|
static void test_gen_id(skiatest::Reporter* reporter) {
|
|
|
|
|
|
|
|
SkPicture hasData, empty, midRecord;
|
|
|
|
|
|
|
|
uint32_t beforeID = hasData.getGenerationID();
|
|
|
|
REPORTER_ASSERT(reporter, SkPicture::kInvalidGenID != beforeID);
|
|
|
|
|
|
|
|
// all 3 pictures should have different ids
|
|
|
|
REPORTER_ASSERT(reporter, beforeID != empty.getGenerationID());
|
|
|
|
REPORTER_ASSERT(reporter, beforeID != midRecord.getGenerationID());
|
|
|
|
REPORTER_ASSERT(reporter, empty.getGenerationID() != midRecord.getGenerationID());
|
|
|
|
|
|
|
|
hasData.beginRecording(1, 1);
|
|
|
|
// gen ID should be invalid mid-record
|
|
|
|
REPORTER_ASSERT(reporter, SkPicture::kInvalidGenID == hasData.getGenerationID());
|
|
|
|
hasData.endRecording();
|
|
|
|
// picture should get a new (non-zero) id after recording
|
|
|
|
REPORTER_ASSERT(reporter, hasData.getGenerationID() != beforeID);
|
|
|
|
REPORTER_ASSERT(reporter, hasData.getGenerationID() != SkPicture::kInvalidGenID);
|
|
|
|
|
|
|
|
midRecord.beginRecording(1, 1);
|
|
|
|
REPORTER_ASSERT(reporter, SkPicture::kInvalidGenID == midRecord.getGenerationID());
|
|
|
|
|
|
|
|
// test out copy constructor
|
|
|
|
SkPicture copyWithData(hasData);
|
|
|
|
REPORTER_ASSERT(reporter, hasData.getGenerationID() == copyWithData.getGenerationID());
|
|
|
|
|
|
|
|
SkPicture emptyCopy(empty);
|
|
|
|
REPORTER_ASSERT(reporter, empty.getGenerationID() != emptyCopy.getGenerationID());
|
2014-04-03 07:04:26 +04:00
|
|
|
|
2014-04-03 03:51:13 +04:00
|
|
|
SkPicture copyMidRecord(midRecord);
|
|
|
|
REPORTER_ASSERT(reporter, midRecord.getGenerationID() != copyMidRecord.getGenerationID());
|
|
|
|
REPORTER_ASSERT(reporter, copyMidRecord.getGenerationID() != SkPicture::kInvalidGenID);
|
|
|
|
|
|
|
|
// test out swap
|
|
|
|
beforeID = copyMidRecord.getGenerationID();
|
|
|
|
copyWithData.swap(copyMidRecord);
|
|
|
|
REPORTER_ASSERT(reporter, copyWithData.getGenerationID() == beforeID);
|
|
|
|
REPORTER_ASSERT(reporter, copyMidRecord.getGenerationID() == hasData.getGenerationID());
|
|
|
|
|
|
|
|
// test out clone
|
|
|
|
SkAutoTUnref<SkPicture> cloneWithData(hasData.clone());
|
|
|
|
REPORTER_ASSERT(reporter, hasData.getGenerationID() == cloneWithData->getGenerationID());
|
|
|
|
|
|
|
|
SkAutoTUnref<SkPicture> emptyClone(empty.clone());
|
|
|
|
REPORTER_ASSERT(reporter, empty.getGenerationID() != emptyClone->getGenerationID());
|
|
|
|
|
|
|
|
SkAutoTUnref<SkPicture> cloneMidRecord(midRecord.clone());
|
|
|
|
REPORTER_ASSERT(reporter, midRecord.getGenerationID() != cloneMidRecord->getGenerationID());
|
|
|
|
REPORTER_ASSERT(reporter, cloneMidRecord->getGenerationID() != SkPicture::kInvalidGenID);
|
|
|
|
}
|
|
|
|
|
2013-12-13 01:11:12 +04:00
|
|
|
DEF_TEST(Picture, reporter) {
|
2012-09-14 21:26:37 +04:00
|
|
|
#ifdef SK_DEBUG
|
|
|
|
test_deleting_empty_playback();
|
|
|
|
test_serializing_empty_picture();
|
2012-12-04 19:08:56 +04:00
|
|
|
#else
|
|
|
|
test_bad_bitmap();
|
2012-09-14 21:26:37 +04:00
|
|
|
#endif
|
2014-02-13 20:00:51 +04:00
|
|
|
test_unbalanced_save_restores(reporter);
|
2013-02-27 23:17:41 +04:00
|
|
|
test_peephole();
|
2012-11-30 01:00:39 +04:00
|
|
|
test_gatherpixelrefs(reporter);
|
2014-01-13 17:33:26 +04:00
|
|
|
test_gatherpixelrefsandrects(reporter);
|
2012-12-10 19:40:55 +04:00
|
|
|
test_bitmap_with_encoded_data(reporter);
|
2013-01-29 01:04:44 +04:00
|
|
|
test_clone_empty(reporter);
|
2014-03-18 21:45:32 +04:00
|
|
|
test_draw_empty(reporter);
|
2013-05-08 19:39:13 +04:00
|
|
|
test_clip_bound_opt(reporter);
|
2013-08-27 19:50:19 +04:00
|
|
|
test_clip_expansion(reporter);
|
2013-10-24 15:12:47 +04:00
|
|
|
test_hierarchical(reporter);
|
2014-04-03 03:51:13 +04:00
|
|
|
test_gen_id(reporter);
|
2012-09-14 21:26:37 +04:00
|
|
|
}
|
2014-02-10 22:29:10 +04:00
|
|
|
|
|
|
|
static void draw_bitmaps(const SkBitmap bitmap, SkCanvas* canvas) {
|
|
|
|
const SkPaint paint;
|
|
|
|
const SkRect rect = { 5.0f, 5.0f, 8.0f, 8.0f };
|
|
|
|
const SkIRect irect = { 2, 2, 3, 3 };
|
|
|
|
|
|
|
|
// Don't care what these record, as long as they're legal.
|
|
|
|
canvas->drawBitmap(bitmap, 0.0f, 0.0f, &paint);
|
|
|
|
canvas->drawBitmapRectToRect(bitmap, &rect, rect, &paint, SkCanvas::kNone_DrawBitmapRectFlag);
|
|
|
|
canvas->drawBitmapMatrix(bitmap, SkMatrix::I(), &paint);
|
|
|
|
canvas->drawBitmapNine(bitmap, irect, rect, &paint);
|
|
|
|
canvas->drawSprite(bitmap, 1, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_draw_bitmaps(SkCanvas* canvas) {
|
|
|
|
SkBitmap empty;
|
|
|
|
draw_bitmaps(empty, canvas);
|
2014-02-13 18:41:43 +04:00
|
|
|
empty.setConfig(SkImageInfo::MakeN32Premul(10, 10));
|
2014-02-10 22:29:10 +04:00
|
|
|
draw_bitmaps(empty, canvas);
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(Picture_EmptyBitmap, r) {
|
|
|
|
SkPicture picture;
|
|
|
|
test_draw_bitmaps(picture.beginRecording(10, 10));
|
|
|
|
picture.endRecording();
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(Canvas_EmptyBitmap, r) {
|
|
|
|
SkBitmap dst;
|
2014-02-13 18:41:43 +04:00
|
|
|
dst.allocN32Pixels(10, 10);
|
2014-02-10 22:29:10 +04:00
|
|
|
SkCanvas canvas(dst);
|
|
|
|
|
|
|
|
test_draw_bitmaps(&canvas);
|
|
|
|
}
|