// Tests that SkNewImageFromBitmap obeys pixelref origin.
DEF_TEST(SkImageFromBitmap_extractSubset, reporter) {
SkAutoTUnref<SkImage> image;
{
SkBitmap srcBitmap;
srcBitmap.allocN32Pixels(gWidth, gHeight);
srcBitmap.eraseColor(SK_ColorRED);
SkBitmapDevice dev(srcBitmap);
SkCanvas canvas(&dev);
SkIRect r = SkIRect::MakeXYWH(5, 5, gWidth - 5, gWidth - 5);
SkPaint p;
p.setColor(SK_ColorGREEN);
canvas.drawIRect(r, p);
SkBitmap dstBitmap;
srcBitmap.extractSubset(&dstBitmap, r);
image.reset(SkNewImageFromBitmap(dstBitmap, true, NULL));
}
SkBitmap tgt;
tgt.allocN32Pixels(gWidth, gHeight);
SkBitmapDevice dev(tgt);
SkCanvas canvas(&dev);
canvas.clear(SK_ColorTRANSPARENT);
canvas.drawImage(image, 0, 0, NULL);
uint32_t pixel = 0;
SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
canvas.readPixels(info, &pixel, 4, 0, 0);
REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
canvas.readPixels(info, &pixel, 4, gWidth - 6, gWidth - 6);
REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
canvas.readPixels(info, &pixel, 4, gWidth - 5, gWidth - 5);
REPORTER_ASSERT(reporter, pixel == SK_ColorTRANSPARENT);
}
TEST(DragImageTest, InterpolationNone)
{
SkBitmap expectedBitmap;
expectedBitmap.allocN32Pixels(4, 4);
{
SkAutoLockPixels lock(expectedBitmap);
expectedBitmap.eraseArea(SkIRect::MakeXYWH(0, 0, 2, 2), 0xFFFFFFFF);
expectedBitmap.eraseArea(SkIRect::MakeXYWH(0, 2, 2, 2), 0xFF000000);
expectedBitmap.eraseArea(SkIRect::MakeXYWH(2, 0, 2, 2), 0xFF000000);
expectedBitmap.eraseArea(SkIRect::MakeXYWH(2, 2, 2, 2), 0xFFFFFFFF);
}
SkBitmap testBitmap;
testBitmap.allocN32Pixels(2, 2);
{
SkAutoLockPixels lock(testBitmap);
testBitmap.eraseArea(SkIRect::MakeXYWH(0, 0, 1, 1), 0xFFFFFFFF);
testBitmap.eraseArea(SkIRect::MakeXYWH(0, 1, 1, 1), 0xFF000000);
testBitmap.eraseArea(SkIRect::MakeXYWH(1, 0, 1, 1), 0xFF000000);
testBitmap.eraseArea(SkIRect::MakeXYWH(1, 1, 1, 1), 0xFFFFFFFF);
}
RefPtr<TestImage> testImage = TestImage::create(adoptRef(SkImage::NewFromBitmap(testBitmap)));
OwnPtr<DragImage> dragImage = DragImage::create(testImage.get(), DoNotRespectImageOrientation, 1, InterpolationNone);
ASSERT_TRUE(dragImage);
dragImage->scale(2, 2);
const SkBitmap& dragBitmap = dragImage->bitmap();
{
SkAutoLockPixels lock1(dragBitmap);
SkAutoLockPixels lock2(expectedBitmap);
for (int x = 0; x < dragBitmap.width(); ++x)
for (int y = 0; y < dragBitmap.height(); ++y)
EXPECT_EQ(expectedBitmap.getColor(x, y), dragBitmap.getColor(x, y));
}
}
static void test_drawBitmap(skiatest::Reporter* reporter) {
SkBitmap src;
src.allocN32Pixels(10, 10);
src.eraseColor(SK_ColorWHITE);
SkBitmap dst;
dst.allocN32Pixels(10, 10);
dst.eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(dst);
SkPaint paint;
// we are initially transparent
REPORTER_ASSERT(reporter, 0 == *dst.getAddr32(5, 5));
// we see the bitmap drawn
canvas.drawBitmap(src, 0, 0, &paint);
REPORTER_ASSERT(reporter, 0xFFFFFFFF == *dst.getAddr32(5, 5));
// reverify we are clear again
dst.eraseColor(SK_ColorTRANSPARENT);
REPORTER_ASSERT(reporter, 0 == *dst.getAddr32(5, 5));
// if the bitmap is clipped out, we don't draw it
canvas.drawBitmap(src, SkIntToScalar(-10), 0, &paint);
REPORTER_ASSERT(reporter, 0 == *dst.getAddr32(5, 5));
// now install our looper, which will draw, since it internally translates
// to the left. The test is to ensure that canvas' quickReject machinary
// allows us through, even though sans-looper we would look like we should
// be clipped out.
paint.setLooper(sk_make_sp<TestLooper>());
canvas.drawBitmap(src, SkIntToScalar(-10), 0, &paint);
REPORTER_ASSERT(reporter, 0xFFFFFFFF == *dst.getAddr32(5, 5));
}
DEF_TEST(Image_NewFromGenerator, r) {
TestImageGenerator::TestType testTypes[] = {
TestImageGenerator::kFailGetPixels_TestType,
TestImageGenerator::kSucceedGetPixels_TestType,
};
for (size_t i = 0; i < SK_ARRAY_COUNT(testTypes); ++i) {
TestImageGenerator::TestType test = testTypes[i];
SkImageGenerator* gen = SkNEW_ARGS(TestImageGenerator, (test, r));
SkAutoTUnref<SkImage> image(SkImage::NewFromGenerator(gen));
if (NULL == image.get()) {
ERRORF(r, "SkImage::NewFromGenerator unexpecedly failed ["
SK_SIZE_T_SPECIFIER "]", i);
continue;
}
REPORTER_ASSERT(r, TestImageGenerator::Width() == image->width());
REPORTER_ASSERT(r, TestImageGenerator::Height() == image->height());
SkBitmap bitmap;
bitmap.allocN32Pixels(TestImageGenerator::Width(), TestImageGenerator::Height());
SkCanvas canvas(bitmap);
const SkColor kDefaultColor = 0xffabcdef;
canvas.clear(kDefaultColor);
canvas.drawImage(image, 0, 0, NULL);
if (TestImageGenerator::kSucceedGetPixels_TestType == test) {
REPORTER_ASSERT(
r, TestImageGenerator::Color() == *bitmap.getAddr32(0, 0));
} else {
REPORTER_ASSERT(r, kDefaultColor == bitmap.getColor(0,0));
}
}
}
DEF_TEST(FlatData, reporter) {
// Test flattening SkShader
SkPoint points[2];
points[0].set(0, 0);
points[1].set(SkIntToScalar(20), SkIntToScalar(20));
SkColor colors[2];
colors[0] = SK_ColorRED;
colors[1] = SK_ColorBLUE;
SkAutoTUnref<SkShader> shader(SkGradientShader::CreateLinear(points, colors, NULL, 2,
SkShader::kRepeat_TileMode));
testCreate<SkFlattenableTraits>(reporter, *shader);
// Test SkBitmap
{
SkBitmap bm;
bm.allocN32Pixels(50, 50);
SkCanvas canvas(bm);
SkPaint paint;
paint.setShader(shader);
canvas.drawPaint(paint);
testCreate<SkBitmapTraits>(reporter, bm);
}
// Test SkColorFilter
SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateLightingFilter(SK_ColorBLUE, SK_ColorRED));
testCreate<SkFlattenableTraits>(reporter, *cf);
// Test SkXfermode
SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kDstOver_Mode));
testCreate<SkFlattenableTraits>(reporter, *xfer);
}
ConstXTileBench(SkShader::TileMode xTile,
SkShader::TileMode yTile,
bool doFilter,
bool doTrans,
bool doScale)
: fDoFilter(doFilter)
, fDoTrans(doTrans)
, fDoScale(doScale) {
SkBitmap bm;
bm.allocN32Pixels(kWidth, kHeight, true);
bm.eraseColor(SK_ColorWHITE);
create_gradient(&bm);
fPaint.setShader(SkShader::MakeBitmapShader(bm, xTile, yTile));
fName.printf("constXTile_");
static const char* gTileModeStr[SkShader::kTileModeCount] = { "C", "R", "M" };
fName.append(gTileModeStr[xTile]);
fName.append(gTileModeStr[yTile]);
if (doFilter) {
fName.append("_filter");
}
if (doTrans) {
fName.append("_trans");
}
if (doScale) {
fName.append("_scale");
}
}
DEF_TEST(CanvasState_test_saveLayer_clip, reporter) {
const int WIDTH = 100;
const int HEIGHT = 100;
const int LAYER_WIDTH = 50;
const int LAYER_HEIGHT = 50;
SkBitmap bitmap;
bitmap.allocN32Pixels(WIDTH, HEIGHT);
SkCanvas canvas(bitmap);
SkRect bounds = SkRect::MakeWH(SkIntToScalar(LAYER_WIDTH), SkIntToScalar(LAYER_HEIGHT));
canvas.clipRect(SkRect::MakeWH(SkIntToScalar(WIDTH), SkIntToScalar(HEIGHT)));
// Check that saveLayer without the kClipToLayer_SaveFlag leaves the
// clip stack unchanged.
canvas.saveLayer(&bounds, NULL, SkCanvas::kARGB_NoClipLayer_SaveFlag);
SkRect clipStackBounds;
SkClipStack::BoundsType boundsType;
canvas.getClipStack()->getBounds(&clipStackBounds, &boundsType);
REPORTER_ASSERT(reporter, clipStackBounds.width() == WIDTH);
REPORTER_ASSERT(reporter, clipStackBounds.height() == HEIGHT);
canvas.restore();
// Check that saveLayer with the kClipToLayer_SaveFlag sets the clip
// stack to the layer bounds.
canvas.saveLayer(&bounds, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
canvas.getClipStack()->getBounds(&clipStackBounds, &boundsType);
REPORTER_ASSERT(reporter, clipStackBounds.width() == LAYER_WIDTH);
REPORTER_ASSERT(reporter, clipStackBounds.height() == LAYER_HEIGHT);
canvas.restore();
}
void drawMask(SkCanvas* canvas, const SkRect& r) {
SkPaint paint;
paint.setAntiAlias(true);
if (true) {
SkBitmap mask;
int w = SkScalarRoundToInt(r.width());
int h = SkScalarRoundToInt(r.height());
mask.allocN32Pixels(w, h);
mask.eraseColor(SK_ColorTRANSPARENT);
SkCanvas c(mask);
SkRect bounds = r;
bounds.offset(-bounds.fLeft, -bounds.fTop);
c.drawOval(bounds, paint);
paint.setBlendMode(SkBlendMode::kDstIn);
canvas->drawBitmap(mask, r.fLeft, r.fTop, &paint);
} else {
SkPath p;
p.addOval(r);
p.setFillType(SkPath::kInverseWinding_FillType);
paint.setBlendMode(SkBlendMode::kDstOut);
canvas->drawPath(p, paint);
}
}
TEST_F(DeferredImageDecoderTest, decodeOnOtherThread)
{
m_lazyDecoder->setData(*m_data, true);
RefPtr<SkImage> image = m_lazyDecoder->createFrameAtIndex(0);
ASSERT_TRUE(image);
EXPECT_EQ(1, image->width());
EXPECT_EQ(1, image->height());
SkPictureRecorder recorder;
SkCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
tempCanvas->drawImage(image.get(), 0, 0);
RefPtr<SkPicture> picture = adoptRef(recorder.endRecording());
EXPECT_EQ(0, m_decodeRequestCount);
// Create a thread to rasterize SkPicture.
OwnPtr<WebThread> thread = adoptPtr(Platform::current()->createThread("RasterThread"));
thread->taskRunner()->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(&rasterizeMain, AllowCrossThreadAccess(m_surface->getCanvas()), AllowCrossThreadAccess(picture.get()))));
thread.clear();
EXPECT_EQ(0, m_decodeRequestCount);
SkBitmap canvasBitmap;
canvasBitmap.allocN32Pixels(100, 100);
ASSERT_TRUE(m_surface->getCanvas()->readPixels(&canvasBitmap, 0, 0));
SkAutoLockPixels autoLock(canvasBitmap);
EXPECT_EQ(SkColorSetARGB(255, 255, 255, 255), canvasBitmap.getColor(0, 0));
}
// Ensure that repeated color gradients behave like drawing a single color
static void TestConstantGradient(skiatest::Reporter*) {
const SkPoint pts[] = {
{ 0, 0 },
{ SkIntToScalar(10), 0 }
};
SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE };
const SkScalar pos[] = { 0, SK_Scalar1 };
SkAutoTUnref<SkShader> s(SkGradientShader::CreateLinear(pts,
colors,
pos,
2,
SkShader::kClamp_TileMode));
SkBitmap outBitmap;
outBitmap.allocN32Pixels(10, 1);
SkPaint paint;
paint.setShader(s.get());
SkCanvas canvas(outBitmap);
canvas.drawPaint(paint);
SkAutoLockPixels alp(outBitmap);
for (int i = 0; i < 10; i++) {
// The following is commented out because it currently fails
// Related bug: https://code.google.com/p/skia/issues/detail?id=1098
// REPORTER_ASSERT(reporter, SK_ColorBLUE == outBitmap.getColor(i, 0));
}
}
TEST_F(DeferredImageDecoderTest, decodeOnOtherThread) {
m_lazyDecoder->setData(m_data, true);
sk_sp<SkImage> image = m_lazyDecoder->createFrameAtIndex(0);
ASSERT_TRUE(image);
EXPECT_EQ(1, image->width());
EXPECT_EQ(1, image->height());
SkPictureRecorder recorder;
SkCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
tempCanvas->drawImage(image.get(), 0, 0);
sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
EXPECT_EQ(0, m_decodeRequestCount);
// Create a thread to rasterize SkPicture.
std::unique_ptr<WebThread> thread =
WTF::wrapUnique(Platform::current()->createThread("RasterThread"));
thread->getWebTaskRunner()->postTask(
BLINK_FROM_HERE,
crossThreadBind(&rasterizeMain,
crossThreadUnretained(m_surface->getCanvas()),
crossThreadUnretained(picture.get())));
thread.reset();
EXPECT_EQ(0, m_decodeRequestCount);
SkBitmap canvasBitmap;
canvasBitmap.allocN32Pixels(100, 100);
ASSERT_TRUE(m_surface->getCanvas()->readPixels(&canvasBitmap, 0, 0));
SkAutoLockPixels autoLock(canvasBitmap);
EXPECT_EQ(SkColorSetARGB(255, 255, 255, 255), canvasBitmap.getColor(0, 0));
}
int main(int argc, char** argv) {
SkAutoGraphics ag;
SkCommandLineFlags::Parse(argc, argv);
if (FLAGS_stop) {
stop(FLAGS_control[0]);
}
if (!FLAGS_skp.isEmpty()) {
client(FLAGS_skp[0], FLAGS_data[0]);
}
if (!FLAGS_png.isEmpty()) {
SkBitmap bitmap;
bitmap.allocN32Pixels(1000, 1000);
SkCanvas canvas(bitmap);
canvas.clear(0xFFFFFFFF);
server(FLAGS_data[0], FLAGS_control[0], &canvas);
canvas.flush();
SkImageEncoder::EncodeFile(FLAGS_png[0], bitmap, SkImageEncoder::kPNG_Type, 100);
SkDebugf("Wrote %s.\n", FLAGS_png[0]);
}
return 0;
}
static void TestBitmapSerialization(const SkBitmap& validBitmap,
const SkBitmap& invalidBitmap,
bool shouldSucceed,
skiatest::Reporter* reporter) {
sk_sp<SkImage> validImage(SkImage::MakeFromBitmap(validBitmap));
sk_sp<SkImageFilter> validBitmapSource(SkImageSource::Make(std::move(validImage)));
sk_sp<SkImage> invalidImage(SkImage::MakeFromBitmap(invalidBitmap));
sk_sp<SkImageFilter> invalidBitmapSource(SkImageSource::Make(std::move(invalidImage)));
sk_sp<SkImageFilter> xfermodeImageFilter(
SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver,
std::move(invalidBitmapSource),
std::move(validBitmapSource), nullptr));
sk_sp<SkImageFilter> deserializedFilter(
TestFlattenableSerialization<SkImageFilter>(
xfermodeImageFilter.get(), shouldSucceed, reporter));
// Try to render a small bitmap using the invalid deserialized filter
// to make sure we don't crash while trying to render it
if (shouldSucceed) {
SkBitmap bitmap;
bitmap.allocN32Pixels(24, 24);
SkCanvas canvas(bitmap);
canvas.clear(0x00000000);
SkPaint paint;
paint.setImageFilter(deserializedFilter);
canvas.clipRect(SkRect::MakeXYWH(0, 0, SkIntToScalar(24), SkIntToScalar(24)));
canvas.drawBitmap(bitmap, 0, 0, &paint);
}
}
TEST_F(DeferredImageDecoderTest, decodeOnOtherThread)
{
m_lazyDecoder->setData(*m_data, true);
RefPtr<NativeImageSkia> image = m_lazyDecoder->frameBufferAtIndex(0)->asNewNativeImage();
EXPECT_EQ(1, image->bitmap().width());
EXPECT_EQ(1, image->bitmap().height());
EXPECT_FALSE(image->bitmap().isNull());
EXPECT_TRUE(image->bitmap().isImmutable());
SkPictureRecorder recorder;
SkCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
tempCanvas->drawBitmap(image->bitmap(), 0, 0);
RefPtr<SkPicture> picture = adoptRef(recorder.endRecording());
EXPECT_EQ(0, m_frameBufferRequestCount);
// Create a thread to rasterize SkPicture.
OwnPtr<WebThread> thread = adoptPtr(Platform::current()->createThread("RasterThread"));
thread->postTask(new Task(WTF::bind(&rasterizeMain, m_surface->getCanvas(), picture.get())));
thread.clear();
EXPECT_EQ(0, m_frameBufferRequestCount);
SkBitmap canvasBitmap;
canvasBitmap.allocN32Pixels(100, 100);
ASSERT_TRUE(m_surface->getCanvas()->readPixels(&canvasBitmap, 0, 0));
SkAutoLockPixels autoLock(canvasBitmap);
EXPECT_EQ(SkColorSetARGB(255, 255, 255, 255), canvasBitmap.getColor(0, 0));
}
DEF_TEST(Canvas_EmptyBitmap, r) {
SkBitmap dst;
dst.allocN32Pixels(10, 10);
SkCanvas canvas(dst);
test_draw_bitmaps(&canvas);
}
static void test_cubic2() {
const char* str = "M2242 -590088L-377758 9.94099e+07L-377758 9.94099e+07L2242 -590088Z";
SkPath path;
SkParsePath::FromSVGString(str, &path);
{
#ifdef SK_BUILD_FOR_WIN
// windows doesn't have strtof
float x = (float)strtod("9.94099e+07", NULL);
#else
float x = strtof("9.94099e+07", NULL);
#endif
int ix = (int)x;
int fx = (int)(x * 65536);
int ffx = SkScalarToFixed(x);
SkDebugf("%g %x %x %x\n", x, ix, fx, ffx);
SkRect r = path.getBounds();
SkIRect ir;
r.round(&ir);
SkDebugf("[%g %g %g %g] [%x %x %x %x]\n",
SkScalarToDouble(r.fLeft), SkScalarToDouble(r.fTop),
SkScalarToDouble(r.fRight), SkScalarToDouble(r.fBottom),
ir.fLeft, ir.fTop, ir.fRight, ir.fBottom);
}
SkBitmap bitmap;
bitmap.allocN32Pixels(300, 200);
SkCanvas canvas(bitmap);
SkPaint paint;
paint.setAntiAlias(true);
canvas.drawPath(path, paint);
}
TEST_F(DeferredImageDecoderTest, drawIntoSkPictureProgressive)
{
RefPtr<SharedBuffer> partialData = SharedBuffer::create(m_data->data(), m_data->size() - 10);
// Received only half the file.
m_lazyDecoder->setData(*partialData, false);
RefPtr<NativeImageSkia> image = m_lazyDecoder->frameBufferAtIndex(0)->asNewNativeImage();
SkPictureRecorder recorder;
SkCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
tempCanvas->drawBitmap(image->bitmap(), 0, 0);
RefPtr<SkPicture> picture = adoptRef(recorder.endRecording());
m_surface->getCanvas()->drawPicture(picture.get());
// Fully received the file and draw the SkPicture again.
m_lazyDecoder->setData(*m_data, true);
image = m_lazyDecoder->frameBufferAtIndex(0)->asNewNativeImage();
tempCanvas = recorder.beginRecording(100, 100, 0, 0);
tempCanvas->drawBitmap(image->bitmap(), 0, 0);
picture = adoptRef(recorder.endRecording());
m_surface->getCanvas()->drawPicture(picture.get());
SkBitmap canvasBitmap;
canvasBitmap.allocN32Pixels(100, 100);
ASSERT_TRUE(m_surface->getCanvas()->readPixels(&canvasBitmap, 0, 0));
SkAutoLockPixels autoLock(canvasBitmap);
EXPECT_EQ(SkColorSetARGB(255, 255, 255, 255), canvasBitmap.getColor(0, 0));
}
TEST_F(DeferredImageDecoderTest, drawIntoSkPicture)
{
m_lazyDecoder->setData(*m_data, true);
SkBitmap bitmap;
EXPECT_TRUE(m_lazyDecoder->createFrameAtIndex(0, &bitmap));
EXPECT_EQ(1, bitmap.width());
EXPECT_EQ(1, bitmap.height());
EXPECT_FALSE(bitmap.isNull());
EXPECT_TRUE(bitmap.isImmutable());
SkPictureRecorder recorder;
SkCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
tempCanvas->drawBitmap(bitmap, 0, 0);
RefPtr<SkPicture> picture = adoptRef(recorder.endRecording());
EXPECT_EQ(0, m_decodeRequestCount);
m_surface->getCanvas()->drawPicture(picture.get());
EXPECT_EQ(0, m_decodeRequestCount);
SkBitmap canvasBitmap;
canvasBitmap.allocN32Pixels(100, 100);
ASSERT_TRUE(m_surface->getCanvas()->readPixels(&canvasBitmap, 0, 0));
SkAutoLockPixels autoLock(canvasBitmap);
EXPECT_EQ(SkColorSetARGB(255, 255, 255, 255), canvasBitmap.getColor(0, 0));
}
static void test_mipmap_generation(int width, int height, int expectedMipLevelCount,
skiatest::Reporter* reporter) {
SkBitmap bm;
bm.allocN32Pixels(width, height);
bm.eraseColor(SK_ColorWHITE);
SkAutoTUnref<SkMipMap> mm(SkMipMap::Build(bm, nullptr));
const int mipLevelCount = mm->countLevels();
REPORTER_ASSERT(reporter, mipLevelCount == expectedMipLevelCount);
REPORTER_ASSERT(reporter, mipLevelCount == SkMipMap::ComputeLevelCount(width, height));
for (int i = 0; i < mipLevelCount; ++i) {
SkMipMap::Level level;
REPORTER_ASSERT(reporter, mm->getLevel(i, &level));
// Make sure the mipmaps contain valid data and that the sizes are correct
REPORTER_ASSERT(reporter, level.fPixmap.addr());
SkISize size = SkMipMap::ComputeLevelSize(width, height, i);
REPORTER_ASSERT(reporter, level.fPixmap.width() == size.width());
REPORTER_ASSERT(reporter, level.fPixmap.height() == size.height());
// + 1 because SkMipMap does not include the base mipmap level.
int twoToTheMipLevel = 1 << (i + 1);
int currentWidth = width / twoToTheMipLevel;
int currentHeight = height / twoToTheMipLevel;
REPORTER_ASSERT(reporter, level.fPixmap.width() == currentWidth);
REPORTER_ASSERT(reporter, level.fPixmap.height() == currentHeight);
}
}
TEST_F(DeferredImageDecoderTest, drawIntoSkPictureProgressive) {
RefPtr<SharedBuffer> partialData =
SharedBuffer::create(m_data->data(), m_data->size() - 10);
// Received only half the file.
m_lazyDecoder->setData(partialData, false);
sk_sp<SkImage> image = m_lazyDecoder->createFrameAtIndex(0);
ASSERT_TRUE(image);
SkPictureRecorder recorder;
SkCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
tempCanvas->drawImage(image.get(), 0, 0);
m_surface->getCanvas()->drawPicture(recorder.finishRecordingAsPicture());
// Fully received the file and draw the SkPicture again.
m_lazyDecoder->setData(m_data, true);
image = m_lazyDecoder->createFrameAtIndex(0);
ASSERT_TRUE(image);
tempCanvas = recorder.beginRecording(100, 100, 0, 0);
tempCanvas->drawImage(image.get(), 0, 0);
m_surface->getCanvas()->drawPicture(recorder.finishRecordingAsPicture());
SkBitmap canvasBitmap;
canvasBitmap.allocN32Pixels(100, 100);
ASSERT_TRUE(m_surface->getCanvas()->readPixels(&canvasBitmap, 0, 0));
SkAutoLockPixels autoLock(canvasBitmap);
EXPECT_EQ(SkColorSetARGB(255, 255, 255, 255), canvasBitmap.getColor(0, 0));
}
// Create a tetrahedral normal map
static SkBitmap make_tetra_normalmap(int texSize) {
SkBitmap tetra;
tetra.allocN32Pixels(texSize, texSize);
sk_tool_utils::create_tetra_normal_map(&tetra, SkIRect::MakeWH(texSize, texSize));
return tetra;
}
// Create a truncated pyramid normal map
static SkBitmap make_frustum_normalmap(int texSize) {
SkBitmap frustum;
frustum.allocN32Pixels(texSize, texSize);
sk_tool_utils::create_frustum_normal_map(&frustum, SkIRect::MakeWH(texSize, texSize));
return frustum;
}
// Create a hemispherical normal map
static SkBitmap make_hemi_normalmap(int texSize) {
SkBitmap hemi;
hemi.allocN32Pixels(texSize, texSize);
sk_tool_utils::create_hemi_normal_map(&hemi, SkIRect::MakeWH(texSize, texSize));
return hemi;
}
static SkBitmap make_bmp(int w, int h) {
SkBitmap bmp;
bmp.allocN32Pixels(w, h, true);
SkCanvas canvas(bmp);
SkScalar wScalar = SkIntToScalar(w);
SkScalar hScalar = SkIntToScalar(h);
SkPoint pt = { wScalar / 2, hScalar / 2 };
SkScalar radius = 3 * SkMaxScalar(wScalar, hScalar);
SkColor colors[] = {SK_ColorDKGRAY,
ToolUtils::color_to_565(0xFF222255),
ToolUtils::color_to_565(0xFF331133),
ToolUtils::color_to_565(0xFF884422),
ToolUtils::color_to_565(0xFF000022),
SK_ColorWHITE,
ToolUtils::color_to_565(0xFFAABBCC)};
SkScalar pos[] = {0,
SK_Scalar1 / 6,
2 * SK_Scalar1 / 6,
3 * SK_Scalar1 / 6,
4 * SK_Scalar1 / 6,
5 * SK_Scalar1 / 6,
SK_Scalar1};
SkPaint paint;
SkRect rect = SkRect::MakeWH(wScalar, hScalar);
SkMatrix mat = SkMatrix::I();
for (int i = 0; i < 4; ++i) {
paint.setShader(SkGradientShader::MakeRadial(
pt, radius,
colors, pos,
SK_ARRAY_COUNT(colors),
SkTileMode::kRepeat,
0, &mat));
canvas.drawRect(rect, paint);
rect.inset(wScalar / 8, hScalar / 8);
mat.preTranslate(6 * wScalar, 6 * hScalar);
mat.postScale(SK_Scalar1 / 3, SK_Scalar1 / 3);
}
SkFont font(ToolUtils::create_portable_typeface(), wScalar / 2.2f);
paint.setShader(nullptr);
paint.setColor(SK_ColorLTGRAY);
constexpr char kTxt[] = "Skia";
SkPoint texPos = { wScalar / 17, hScalar / 2 + font.getSize() / 2.5f };
canvas.drawSimpleText(kTxt, SK_ARRAY_COUNT(kTxt)-1, SkTextEncoding::kUTF8,
texPos.fX, texPos.fY, font, paint);
paint.setColor(SK_ColorBLACK);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SK_Scalar1);
canvas.drawSimpleText(kTxt, SK_ARRAY_COUNT(kTxt)-1, SkTextEncoding::kUTF8,
texPos.fX, texPos.fY, font, paint);
return bmp;
}
SkBitmap create_checkerboard_bitmap(int w, int h, SkColor c1, SkColor c2, int checkSize) {
SkBitmap bitmap;
bitmap.allocN32Pixels(w, h);
SkCanvas canvas(bitmap);
sk_tool_utils::draw_checkerboard(&canvas, c1, c2, checkSize);
return bitmap;
}
// http://crrev.com/834303005
static sk_sp<SkShader> create_checkerboard_shader(SkColor c1, SkColor c2, int size) {
SkBitmap bm;
bm.allocN32Pixels(2 * size, 2 * size);
bm.eraseColor(c1);
bm.eraseArea(SkIRect::MakeLTRB(0, 0, size, size), c2);
bm.eraseArea(SkIRect::MakeLTRB(size, size, 2 * size, 2 * size), c2);
return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
}
static SkBitmap draw_picture(SkPicture& picture) {
SkBitmap bitmap;
bitmap.allocN32Pixels(SkScalarCeilToInt(picture.cullRect().width()),
SkScalarCeilToInt(picture.cullRect().height()));
SkCanvas canvas(bitmap);
picture.playback(&canvas);
return bitmap;
}
static void draw_bitmap(SkCanvas* canvas, const SkRect& r, const SkPaint& p) {
SkBitmap bm;
bm.allocN32Pixels(64, 64);
SkCanvas temp(bm);
temp.clear(SK_ColorMAGENTA);
canvas->drawBitmapRect(bm, r, &p);
}
SkColor blend(SkColor one, SkColor two) {
SkBitmap temp;
temp.allocN32Pixels(1, 1);
SkCanvas canvas(temp);
canvas.drawColor(one);
canvas.drawColor(two);
void* pixels = temp.getPixels();
return *(SkColor*) pixels;
}
static SkBitmap make_bmp(int w, int h) {
SkBitmap bmp;
bmp.allocN32Pixels(w, h, true);
SkCanvas canvas(bmp);
SkScalar wScalar = SkIntToScalar(w);
SkScalar hScalar = SkIntToScalar(h);
SkPoint pt = { wScalar / 2, hScalar / 2 };
SkScalar radius = 3 * SkMaxScalar(wScalar, hScalar);
SkColor colors[] = { sk_tool_utils::color_to_565(SK_ColorDKGRAY),
sk_tool_utils::color_to_565(0xFF222255),
sk_tool_utils::color_to_565(0xFF331133),
sk_tool_utils::color_to_565(0xFF884422),
sk_tool_utils::color_to_565(0xFF000022), SK_ColorWHITE,
sk_tool_utils::color_to_565(0xFFAABBCC) };
SkScalar pos[] = {0,
SK_Scalar1 / 6,
2 * SK_Scalar1 / 6,
3 * SK_Scalar1 / 6,
4 * SK_Scalar1 / 6,
5 * SK_Scalar1 / 6,
SK_Scalar1};
SkPaint paint;
SkRect rect = SkRect::MakeWH(wScalar, hScalar);
SkMatrix mat = SkMatrix::I();
for (int i = 0; i < 4; ++i) {
paint.setShader(SkGradientShader::CreateRadial(
pt, radius,
colors, pos,
SK_ARRAY_COUNT(colors),
SkShader::kRepeat_TileMode,
0, &mat))->unref();
canvas.drawRect(rect, paint);
rect.inset(wScalar / 8, hScalar / 8);
mat.preTranslate(6 * wScalar, 6 * hScalar);
mat.postScale(SK_Scalar1 / 3, SK_Scalar1 / 3);
}
paint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&paint);
paint.setTextSize(wScalar / 2.2f);
paint.setShader(0);
paint.setColor(sk_tool_utils::color_to_565(SK_ColorLTGRAY));
static const char kTxt[] = "Skia";
SkPoint texPos = { wScalar / 17, hScalar / 2 + paint.getTextSize() / 2.5f };
canvas.drawText(kTxt, SK_ARRAY_COUNT(kTxt)-1, texPos.fX, texPos.fY, paint);
paint.setColor(SK_ColorBLACK);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SK_Scalar1);
canvas.drawText(kTxt, SK_ARRAY_COUNT(kTxt)-1, texPos.fX, texPos.fY, paint);
return bmp;
}
