// At the time of writing, SkBitmap::erase() works when the color is zero for all formats,
// but some formats failed when the color is non-zero!
DEF_TEST(Bitmap_erase, r) {
SkColorType colorTypes[] = {
kRGB_565_SkColorType,
kARGB_4444_SkColorType,
kRGB_888x_SkColorType,
kRGBA_8888_SkColorType,
kBGRA_8888_SkColorType,
kRGB_101010x_SkColorType,
kRGBA_1010102_SkColorType,
};
for (SkColorType ct : colorTypes) {
SkImageInfo info = SkImageInfo::Make(1,1, (SkColorType)ct, kPremul_SkAlphaType);
SkBitmap bm;
bm.allocPixels(info);
bm.eraseColor(0x00000000);
if (SkColorTypeIsAlwaysOpaque(ct)) {
REPORTER_ASSERT(r, bm.getColor(0,0) == 0xff000000);
} else {
REPORTER_ASSERT(r, bm.getColor(0,0) == 0x00000000);
}
bm.eraseColor(0xaabbccdd);
REPORTER_ASSERT(r, bm.getColor(0,0) != 0xff000000);
REPORTER_ASSERT(r, bm.getColor(0,0) != 0x00000000);
}
}
/** Assumes that the ref draw was completely inside ref canvas --
implies that everything outside is "bgColor".
Checks that all overlap is the same and that all non-overlap on the
ref is "bgColor".
*/
static bool compare(const SkBitmap& ref, const SkIRect& iref,
const SkBitmap& test, const SkIRect& itest)
{
const int xOff = itest.fLeft - iref.fLeft;
const int yOff = itest.fTop - iref.fTop;
SkAutoLockPixels alpRef(ref);
SkAutoLockPixels alpTest(test);
for (int y = 0; y < test.height(); ++y) {
for (int x = 0; x < test.width(); ++x) {
SkColor testColor = test.getColor(x, y);
int refX = x + xOff;
int refY = y + yOff;
SkColor refColor;
if (refX >= 0 && refX < ref.width() &&
refY >= 0 && refY < ref.height())
{
refColor = ref.getColor(refX, refY);
} else {
refColor = bgColor;
}
if (refColor != testColor) {
return false;
}
}
}
return true;
}
static void test_interlaced_gif_data(skiatest::Reporter* r,
void* data,
size_t size) {
SkBitmap bm;
bool imageDecodeSuccess = decode_memory(data, size, &bm);
REPORTER_ASSERT(r, imageDecodeSuccess);
REPORTER_ASSERT(r, bm.width() == 9);
REPORTER_ASSERT(r, bm.height() == 9);
REPORTER_ASSERT(r, !(bm.empty()));
if (!(bm.empty())) {
REPORTER_ASSERT(r, bm.getColor(0, 0) == 0xffff0000);
REPORTER_ASSERT(r, bm.getColor(1, 0) == 0xffffff00);
REPORTER_ASSERT(r, bm.getColor(2, 0) == 0xff00ffff);
REPORTER_ASSERT(r, bm.getColor(0, 2) == 0xffffffff);
REPORTER_ASSERT(r, bm.getColor(1, 2) == 0xffff00ff);
REPORTER_ASSERT(r, bm.getColor(2, 2) == 0xff0000ff);
REPORTER_ASSERT(r, bm.getColor(0, 4) == 0xff808080);
REPORTER_ASSERT(r, bm.getColor(1, 4) == 0xff000000);
REPORTER_ASSERT(r, bm.getColor(2, 4) == 0xff00ff00);
REPORTER_ASSERT(r, bm.getColor(0, 6) == 0xffff0000);
REPORTER_ASSERT(r, bm.getColor(1, 6) == 0xffffff00);
REPORTER_ASSERT(r, bm.getColor(2, 6) == 0xff00ffff);
REPORTER_ASSERT(r, bm.getColor(0, 8) == 0xffffffff);
REPORTER_ASSERT(r, bm.getColor(1, 8) == 0xffff00ff);
REPORTER_ASSERT(r, bm.getColor(2, 8) == 0xff0000ff);
}
}
static void test_erasecolor_premul(skiatest::Reporter* reporter, SkColorType ct, SkColor input,
SkColor expected) {
SkBitmap bm;
bm.allocPixels(SkImageInfo::Make(1, 1, ct, kPremul_SkAlphaType));
bm.eraseColor(input);
INFOF(reporter, "expected: %x actual: %x\n", expected, bm.getColor(0, 0));
REPORTER_ASSERT(reporter, bm.getColor(0, 0) == expected);
}
static void TestDeferredCanvasFlush(skiatest::Reporter* reporter) {
SkBitmap store;
create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice device(store);
SkDeferredCanvas canvas(&device);
canvas.clear(0x00000000);
SkAutoLockPixels alp(store);
REPORTER_ASSERT(reporter, store.getColor(0,0) == 0xFFFFFFFF); //verify that clear was deferred
canvas.flush();
REPORTER_ASSERT(reporter, store.getColor(0,0) == 0x00000000); //verify that clear was executed
}
static void TestDeferredCanvasBitmapAccess(skiatest::Reporter* reporter) {
SkBitmap store;
create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice device(store);
SkDeferredCanvas canvas(&device);
canvas.clear(0x00000000);
SkAutoLockPixels alp(store);
REPORTER_ASSERT(reporter, store.getColor(0,0) == 0xFFFFFFFF); //verify that clear was deferred
SkBitmap accessed = canvas.getDevice()->accessBitmap(false);
REPORTER_ASSERT(reporter, store.getColor(0,0) == 0x00000000); //verify that clear was executed
REPORTER_ASSERT(reporter, accessed.pixelRef() == store.pixelRef());
}
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));
}
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, 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));
}
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));
}
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));
}
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));
}
}
}
static bool write_bitmap(const char outName[], const SkBitmap& bm) {
SkISize size = opaqueSize(bm);
SkBitmap dst;
setup_bitmap(&dst, size.width(), size.height());
for (int y = 0 ; y < dst.height(); y++) {
for (int x = 0 ; x < dst.width(); x++) {
SkColor color = bm.getColor(x, y);
if (SkColorGetA(color) != 0xff) {
int a = SkColorGetA(color);
int r = SkColorGetR(color);
int g = SkColorGetG(color);
int b = SkColorGetB(color);
if (a == 0) {
r = g = b = 0;
} else {
r = (r * a) / 255;
g = (g * a) / 255;
b = (b * a) / 255;
a = 255;
}
color = SkColorSetARGB((U8CPU)a, (U8CPU)r, (U8CPU)g, (U8CPU)b);
}
*dst.getAddr32(x, y) = color;
}
}
return SkImageEncoder::EncodeFile(outName, dst, SkImageEncoder::kPNG_Type, 100);
}
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));
}
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));
}
}
/**
* This test checks that getColor works for both swizzles.
*/
DEF_TEST(Bitmap_getColor_Swizzle, r) {
SkBitmap source;
source.allocN32Pixels(1,1);
source.eraseColor(SK_ColorRED);
SkColorType colorTypes[] = {
kRGBA_8888_SkColorType,
kBGRA_8888_SkColorType,
};
for (SkColorType ct : colorTypes) {
SkBitmap copy;
if (!sk_tool_utils::copy_to(©, ct, source)) {
ERRORF(r, "SkBitmap::copy failed %d", (int)ct);
continue;
}
REPORTER_ASSERT(r, source.getColor(0, 0) == copy.getColor(0, 0));
}
}
DEF_TEST(WebP, reporter) {
const unsigned char encodedWebP[] = {
0x52, 0x49, 0x46, 0x46, 0x2c, 0x01, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50,
0x56, 0x50, 0x38, 0x4c, 0x20, 0x01, 0x00, 0x00, 0x2f, 0x07, 0xc0, 0x01,
0x00, 0xff, 0x01, 0x45, 0x03, 0x00, 0xe2, 0xd5, 0xae, 0x60, 0x2b, 0xad,
0xd9, 0x68, 0x76, 0xb6, 0x8d, 0x6a, 0x1d, 0xc0, 0xe6, 0x19, 0xd6, 0x16,
0xb7, 0xb4, 0xef, 0xcf, 0xc3, 0x15, 0x6c, 0xb3, 0xbd, 0x77, 0x0d, 0x85,
0x6d, 0x1b, 0xa9, 0xb1, 0x2b, 0xdc, 0x3d, 0x83, 0xdb, 0x00, 0x00, 0xc8,
0x26, 0xe5, 0x01, 0x99, 0x8a, 0xd5, 0xdd, 0xfc, 0x82, 0xcd, 0xcd, 0x9a,
0x8c, 0x13, 0xcc, 0x1b, 0xba, 0xf5, 0x05, 0xdb, 0xee, 0x6a, 0xdb, 0x38,
0x60, 0xfe, 0x43, 0x2c, 0xd4, 0x6a, 0x99, 0x4d, 0xc6, 0xc0, 0xd3, 0x28,
0x1b, 0xc1, 0xb1, 0x17, 0x4e, 0x43, 0x0e, 0x3d, 0x27, 0xe9, 0xe4, 0x84,
0x4f, 0x24, 0x62, 0x69, 0x85, 0x43, 0x8d, 0xc2, 0x04, 0x00, 0x07, 0x59,
0x60, 0xfd, 0x8b, 0x4d, 0x60, 0x32, 0x72, 0xcf, 0x88, 0x0c, 0x2f, 0x2f,
0xad, 0x62, 0xbd, 0x27, 0x09, 0x16, 0x70, 0x78, 0x6c, 0xd9, 0x82, 0xef,
0x1a, 0xa2, 0xcc, 0xf0, 0xf1, 0x6f, 0xd8, 0x78, 0x2e, 0x39, 0xa1, 0xcf,
0x14, 0x4b, 0x89, 0xb4, 0x1b, 0x48, 0x15, 0x7c, 0x48, 0x6f, 0x8c, 0x20,
0xb7, 0x00, 0xcf, 0xfc, 0xdb, 0xd0, 0xe9, 0xe7, 0x42, 0x09, 0xa4, 0x03,
0x40, 0xac, 0xda, 0x40, 0x01, 0x00, 0x5f, 0xa1, 0x3d, 0x64, 0xe1, 0xf4,
0x03, 0x45, 0x29, 0xe0, 0xe2, 0x4a, 0xc3, 0xa2, 0xe8, 0xe0, 0x25, 0x12,
0x74, 0xc6, 0xe8, 0xfb, 0x93, 0x4f, 0x9f, 0x5e, 0xc0, 0xa6, 0x91, 0x1b,
0xa4, 0x24, 0x82, 0xc3, 0x61, 0x07, 0x4c, 0x49, 0x4f, 0x53, 0xae, 0x5f,
0x5d, 0x39, 0x36, 0xc0, 0x5b, 0x57, 0x54, 0x60, 0x10, 0x00, 0x00, 0xd1,
0x68, 0xb6, 0x6d, 0xdb, 0x36, 0x22, 0xfa, 0x1f, 0x35, 0x75, 0x22, 0xec,
0x31, 0xbc, 0x5d, 0x8f, 0x87, 0x53, 0xa2, 0x05, 0x8c, 0x2f, 0xcd, 0xa8,
0xa7, 0xf3, 0xa3, 0xbd, 0x83, 0x8b, 0x2a, 0xc8, 0x58, 0xf5, 0xac, 0x80,
0xe3, 0xfe, 0x66, 0xa4, 0x7c, 0x1b, 0x6c, 0xd1, 0xa9, 0xd8, 0x14, 0xd0,
0xc5, 0xb5, 0x39, 0x71, 0x97, 0x19, 0x19, 0x1b
};
SkAutoDataUnref encoded(SkData::NewWithCopy(encodedWebP,
sizeof(encodedWebP)));
SkBitmap bm;
bool success = SkInstallDiscardablePixelRef(
SkDecodingImageGenerator::Create(encoded,
SkDecodingImageGenerator::Options()), &bm);
REPORTER_ASSERT(reporter, success);
if (!success) {
return;
}
SkAutoLockPixels alp(bm);
bool rightSize = ((kExpectedWidth == bm.width())
&& (kExpectedHeight == bm.height()));
REPORTER_ASSERT(reporter, rightSize);
if (rightSize) {
bool error = false;
const SkColor* correctPixel = kExpectedPixels;
for (int y = 0; y < bm.height(); ++y) {
for (int x = 0; x < bm.width(); ++x) {
error |= (*correctPixel != bm.getColor(x, y));
++correctPixel;
}
}
REPORTER_ASSERT(reporter, !error);
}
}
static void compare_bitmaps(skiatest::Reporter* reporter,
const SkBitmap& b1, const SkBitmap& b2) {
REPORTER_ASSERT(reporter, b1.width() == b2.width());
REPORTER_ASSERT(reporter, b1.height() == b2.height());
if ((b1.width() != b2.width()) ||
(b1.height() != b2.height())) {
return;
}
int pixelErrors = 0;
for (int y = 0; y < b2.height(); ++y) {
for (int x = 0; x < b2.width(); ++x) {
if (b1.getColor(x, y) != b2.getColor(x, y))
++pixelErrors;
}
}
REPORTER_ASSERT(reporter, 0 == pixelErrors);
}
int SkDebugCanvas::getCommandAtPoint(int x, int y, int index) {
SkBitmap bitmap;
bitmap.allocPixels(SkImageInfo::MakeN32Premul(1, 1));
SkCanvas canvas(bitmap);
canvas.translate(SkIntToScalar(-x), SkIntToScalar(-y));
applyUserTransform(&canvas);
int layer = 0;
SkColor prev = bitmap.getColor(0,0);
for (int i = 0; i < index; i++) {
if (fCommandVector[i]->isVisible()) {
fCommandVector[i]->execute(&canvas);
}
if (prev != bitmap.getColor(0,0)) {
layer = i;
}
prev = bitmap.getColor(0,0);
}
return layer;
}
DEF_TEST(Image_NewFromGenerator, r) {
const TestImageGenerator::TestType testTypes[] = {
TestImageGenerator::kFailGetPixels_TestType,
TestImageGenerator::kSucceedGetPixels_TestType,
};
const SkColorType testColorTypes[] = {
kN32_SkColorType,
kRGB_565_SkColorType
};
for (size_t i = 0; i < SK_ARRAY_COUNT(testTypes); ++i) {
TestImageGenerator::TestType test = testTypes[i];
for (const SkColorType testColorType : testColorTypes) {
auto gen = skstd::make_unique<TestImageGenerator>(test, r, testColorType);
sk_sp<SkImage> image(SkImage::MakeFromGenerator(std::move(gen)));
if (nullptr == image) {
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());
REPORTER_ASSERT(r, image->isLazyGenerated());
SkBitmap bitmap;
bitmap.allocN32Pixels(TestImageGenerator::Width(), TestImageGenerator::Height());
SkCanvas canvas(bitmap);
const SkColor kDefaultColor = 0xffabcdef;
canvas.clear(kDefaultColor);
canvas.drawImage(image, 0, 0, nullptr);
if (TestImageGenerator::kSucceedGetPixels_TestType == test) {
REPORTER_ASSERT(
r, TestImageGenerator::Color() == bitmap.getColor(0, 0));
}
else {
REPORTER_ASSERT(r, kDefaultColor == bitmap.getColor(0, 0));
}
}
}
}
static void test_gif_data_no_colormap(skiatest::Reporter* r,
void* data,
size_t size) {
SkBitmap bm;
bool imageDecodeSuccess = decode_memory(data, size, &bm);
REPORTER_ASSERT(r, imageDecodeSuccess);
REPORTER_ASSERT(r, bm.width() == 1);
REPORTER_ASSERT(r, bm.height() == 1);
REPORTER_ASSERT(r, !(bm.empty()));
if (!(bm.empty())) {
REPORTER_ASSERT(r, bm.getColor(0, 0) == 0xFF000000);
}
}
static bool bitmapIsAllZero(const SkBitmap& bitmap)
{
bitmap.lockPixels();
bool result = true;
for (int x = 0; result && x < bitmap.width(); ++x) {
for (int y = 0; result && y < bitmap.height(); ++y) {
if (SkColorSetA(bitmap.getColor(x, y), 0) != SK_ColorTRANSPARENT)
result = false;
}
}
bitmap.unlockPixels();
return result;
}
static SkISize opaqueSize(const SkBitmap& bm) {
int width = 1;
int height = 1;
for (int y = 0 ; y < bm.height(); y++) {
for (int x = 0 ; x < bm.width(); x++) {
SkColor color = bm.getColor(x, y);
if (SkColorGetA(color) != 0) {
height = y + 1;
width = width > (x + 1) ? width : x + 1;
}
}
}
return SkISize::Make(width, height);
}
static void compare_bitmaps(skiatest::Reporter* reporter,
const SkBitmap& b1, const SkBitmap& b2,
bool pixelPerfect = true) {
REPORTER_ASSERT(reporter, b1.empty() == b2.empty());
REPORTER_ASSERT(reporter, b1.width() == b2.width());
REPORTER_ASSERT(reporter, b1.height() == b2.height());
REPORTER_ASSERT(reporter, b1.isNull() == b2.isNull());
SkAutoLockPixels autoLockPixels1(b1);
SkAutoLockPixels autoLockPixels2(b2);
REPORTER_ASSERT(reporter, b1.isNull() == b2.isNull());
if (b1.isNull() || b1.empty()) {
return;
}
REPORTER_ASSERT(reporter, b1.getPixels());
REPORTER_ASSERT(reporter, b2.getPixels());
if ((!(b1.getPixels())) || (!(b2.getPixels()))) {
return;
}
if ((b1.width() != b2.width()) ||
(b1.height() != b2.height())) {
return;
}
if (!pixelPerfect) {
return;
}
int pixelErrors = 0;
for (int y = 0; y < b2.height(); ++y) {
for (int x = 0; x < b2.width(); ++x) {
if (b1.getColor(x, y) != b2.getColor(x, y)) {
++pixelErrors;
}
}
}
REPORTER_ASSERT(reporter, 0 == pixelErrors);
}
DEF_TEST(DontOptimizeSaveLayerDrawDrawRestore, reporter) {
// This test is from crbug.com/344987.
// The commands are:
// saveLayer with paint that modifies alpha
// drawBitmapRect
// drawBitmapRect
// restore
// The bug was that this structure was modified so that:
// - The saveLayer and restore were eliminated
// - The alpha was only applied to the first drawBitmapRectToRect
// This test draws blue and red squares inside a 50% transparent
// layer. Both colours should show up muted.
// When the bug is present, the red square (the second bitmap)
// shows upwith full opacity.
SkBitmap blueBM;
make_bm(&blueBM, 100, 100, SkColorSetARGB(255, 0, 0, 255), true);
SkBitmap redBM;
make_bm(&redBM, 100, 100, SkColorSetARGB(255, 255, 0, 0), true);
SkPaint semiTransparent;
semiTransparent.setAlpha(0x80);
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(100, 100);
canvas->drawARGB(0, 0, 0, 0);
canvas->saveLayer(0, &semiTransparent);
canvas->drawBitmap(blueBM, 25, 25);
canvas->drawBitmap(redBM, 50, 50);
canvas->restore();
sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
// Now replay the picture back on another canvas
// and check a couple of its pixels.
SkBitmap replayBM;
make_bm(&replayBM, 100, 100, SK_ColorBLACK, false);
SkCanvas replayCanvas(replayBM);
picture->playback(&replayCanvas);
replayCanvas.flush();
// With the bug present, at (55, 55) we would get a fully opaque red
// intead of a dark red.
REPORTER_ASSERT(reporter, replayBM.getColor(30, 30) == 0xff000080);
REPORTER_ASSERT(reporter, replayBM.getColor(55, 55) == 0xff800000);
}
void BitmapImage::checkForSolidColor()
{
m_isSolidColor = false;
m_checkedForSolidColor = true;
if (frameCount() > 1)
return;
SkBitmap bitmap;
if (frameAtIndex(0, &bitmap) && size().width() == 1 && size().height() == 1) {
SkAutoLockPixels lock(bitmap);
if (!bitmap.getPixels())
return;
m_isSolidColor = true;
m_solidColor = Color(bitmap.getColor(0, 0));
}
}
TEST_F(DeferredImageDecoderTest, drawIntoSkPicture) {
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);
m_surface->getCanvas()->drawPicture(picture);
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));
}
/**
* This test case is a mirror of the Android CTS tests for MatrixColorFilter
* found in the android.graphics.ColorMatrixColorFilterTest class.
*/
static inline void test_colorMatrixCTS(skiatest::Reporter* reporter) {
SkBitmap bitmap;
bitmap.allocN32Pixels(1,1);
SkCanvas canvas(bitmap);
SkPaint paint;
float blueToCyan[20] = {
1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f, 0.0f };
paint.setColorFilter(SkColorFilters::Matrix(blueToCyan));
paint.setColor(SK_ColorBLUE);
canvas.drawPoint(0, 0, paint);
assert_color(reporter, SK_ColorCYAN, bitmap.getColor(0, 0));
paint.setColor(SK_ColorGREEN);
canvas.drawPoint(0, 0, paint);
assert_color(reporter, SK_ColorGREEN, bitmap.getColor(0, 0));
paint.setColor(SK_ColorRED);
canvas.drawPoint(0, 0, paint);
assert_color(reporter, SK_ColorRED, bitmap.getColor(0, 0));
// color components are clipped, not scaled
paint.setColor(SK_ColorMAGENTA);
canvas.drawPoint(0, 0, paint);
assert_color(reporter, SK_ColorWHITE, bitmap.getColor(0, 0));
float transparentRedAddBlue[20] = {
1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 64.0f/255,
-0.5f, 0.0f, 0.0f, 1.0f, 0.0f
};
paint.setColorFilter(SkColorFilters::Matrix(transparentRedAddBlue));
bitmap.eraseColor(SK_ColorTRANSPARENT);
paint.setColor(SK_ColorRED);
canvas.drawPoint(0, 0, paint);
assert_color(reporter, SkColorSetARGB(128, 255, 0, 64), bitmap.getColor(0, 0), 2);
paint.setColor(SK_ColorCYAN);
canvas.drawPoint(0, 0, paint);
// blue gets clipped
assert_color(reporter, SK_ColorCYAN, bitmap.getColor(0, 0));
// change array to filter out green
REPORTER_ASSERT(reporter, 1.0f == transparentRedAddBlue[6]);
transparentRedAddBlue[6] = 0.0f;
// check that changing the array has no effect
canvas.drawPoint(0, 0, paint);
assert_color(reporter, SK_ColorCYAN, bitmap.getColor(0, 0));
// create a new filter with the changed matrix
paint.setColorFilter(SkColorFilters::Matrix(transparentRedAddBlue));
canvas.drawPoint(0, 0, paint);
assert_color(reporter, SK_ColorBLUE, bitmap.getColor(0, 0));
}
/**
* Given either a SkStream or a SkData, try to decode the encoded
* image using the specified options and report errors.
*/
static void test_options(skiatest::Reporter* reporter,
const SkDecodingImageGenerator::Options& opts,
SkStreamRewindable* encodedStream,
SkData* encodedData,
bool useData,
const SkString& path) {
SkBitmap bm;
bool success = false;
if (useData) {
if (NULL == encodedData) {
return;
}
success = SkInstallDiscardablePixelRef(
SkDecodingImageGenerator::Create(encodedData, opts), &bm);
} else {
if (NULL == encodedStream) {
return;
}
success = SkInstallDiscardablePixelRef(
SkDecodingImageGenerator::Create(encodedStream->duplicate(), opts), &bm);
}
if (!success) {
if (opts.fUseRequestedColorType
&& (kARGB_4444_SkColorType == opts.fRequestedColorType)) {
return; // Ignore known conversion inabilities.
}
// If we get here, it's a failure and we will need more
// information about why it failed.
ERRORF(reporter, "Bounds decode failed [sampleSize=%d dither=%s "
"colorType=%s %s]", opts.fSampleSize, yn(opts.fDitherImage),
options_colorType(opts), path.c_str());
return;
}
#if defined(SK_BUILD_FOR_ANDROID) || defined(SK_BUILD_FOR_UNIX)
// Android is the only system that use Skia's image decoders in
// production. For now, we'll only verify that samplesize works
// on systems where it already is known to work.
REPORTER_ASSERT(reporter, check_rounding(bm.height(), kExpectedHeight,
opts.fSampleSize));
REPORTER_ASSERT(reporter, check_rounding(bm.width(), kExpectedWidth,
opts.fSampleSize));
// The ImageDecoder API doesn't guarantee that SampleSize does
// anything at all, but the decoders that this test excercises all
// produce an output size in the following range:
// (((sample_size * out_size) > (in_size - sample_size))
// && out_size <= SkNextPow2(((in_size - 1) / sample_size) + 1));
#endif // SK_BUILD_FOR_ANDROID || SK_BUILD_FOR_UNIX
SkAutoLockPixels alp(bm);
if (bm.getPixels() == NULL) {
ERRORF(reporter, "Pixel decode failed [sampleSize=%d dither=%s "
"colorType=%s %s]", opts.fSampleSize, yn(opts.fDitherImage),
options_colorType(opts), path.c_str());
return;
}
SkColorType requestedColorType = opts.fRequestedColorType;
REPORTER_ASSERT(reporter,
(!opts.fUseRequestedColorType)
|| (bm.colorType() == requestedColorType));
// Condition under which we should check the decoding results:
if ((kN32_SkColorType == bm.colorType())
&& (!path.endsWith(".jpg")) // lossy
&& (opts.fSampleSize == 1)) { // scaled
const SkColor* correctPixels = kExpectedPixels;
SkASSERT(bm.height() == kExpectedHeight);
SkASSERT(bm.width() == kExpectedWidth);
int pixelErrors = 0;
for (int y = 0; y < bm.height(); ++y) {
for (int x = 0; x < bm.width(); ++x) {
if (*correctPixels != bm.getColor(x, y)) {
++pixelErrors;
}
++correctPixels;
}
}
if (pixelErrors != 0) {
ERRORF(reporter, "Pixel-level mismatch (%d of %d) "
"[sampleSize=%d dither=%s colorType=%s %s]",
pixelErrors, kExpectedHeight * kExpectedWidth,
opts.fSampleSize, yn(opts.fDitherImage),
options_colorType(opts), path.c_str());
}
}
}
// Basic test of the SkSpecialImage public API (e.g., peekTexture, peekPixels & draw)
static void test_image(const sk_sp<SkSpecialImage>& img, skiatest::Reporter* reporter,
GrContext* context, bool peekTextureSucceeds,
int offset, int size) {
const SkIRect subset = img->subset();
REPORTER_ASSERT(reporter, offset == subset.left());
REPORTER_ASSERT(reporter, offset == subset.top());
REPORTER_ASSERT(reporter, kSmallerSize == subset.width());
REPORTER_ASSERT(reporter, kSmallerSize == subset.height());
//--------------
// Test that peekTexture reports the correct backing type
REPORTER_ASSERT(reporter, peekTextureSucceeds == img->isTextureBacked());
#if SK_SUPPORT_GPU
//--------------
// Test getTextureAsRef - as long as there is a context this should succeed
if (context) {
sk_sp<GrTexture> texture(img->asTextureRef(context));
REPORTER_ASSERT(reporter, texture);
}
#endif
//--------------
// Test getROPixels - this should always succeed regardless of backing store
SkBitmap bitmap;
REPORTER_ASSERT(reporter, img->getROPixels(&bitmap));
if (context) {
REPORTER_ASSERT(reporter, kSmallerSize == bitmap.width());
REPORTER_ASSERT(reporter, kSmallerSize == bitmap.height());
} else {
REPORTER_ASSERT(reporter, size == bitmap.width());
REPORTER_ASSERT(reporter, size == bitmap.height());
}
//--------------
// Test that draw restricts itself to the subset
SkImageInfo info = SkImageInfo::MakeN32(kFullSize, kFullSize, kOpaque_SkAlphaType);
sk_sp<SkSpecialSurface> surf(img->makeSurface(info));
SkCanvas* canvas = surf->getCanvas();
canvas->clear(SK_ColorBLUE);
img->draw(canvas, SkIntToScalar(kPad), SkIntToScalar(kPad), nullptr);
SkBitmap bm;
bm.allocN32Pixels(kFullSize, kFullSize, true);
bool result = canvas->readPixels(bm.info(), bm.getPixels(), bm.rowBytes(), 0, 0);
SkASSERT_RELEASE(result);
// Only the center (red) portion should've been drawn into the canvas
REPORTER_ASSERT(reporter, SK_ColorBLUE == bm.getColor(kPad-1, kPad-1));
REPORTER_ASSERT(reporter, SK_ColorRED == bm.getColor(kPad, kPad));
REPORTER_ASSERT(reporter, SK_ColorRED == bm.getColor(kSmallerSize+kPad-1,
kSmallerSize+kPad-1));
REPORTER_ASSERT(reporter, SK_ColorBLUE == bm.getColor(kSmallerSize+kPad,
kSmallerSize+kPad));
//--------------
// Test that makeTightSubset & makeTightSurface return appropriately sized objects
// of the correct backing type
SkIRect newSubset = SkIRect::MakeWH(subset.width(), subset.height());
{
sk_sp<SkImage> tightImg(img->makeTightSubset(newSubset));
REPORTER_ASSERT(reporter, tightImg->width() == subset.width());
REPORTER_ASSERT(reporter, tightImg->height() == subset.height());
REPORTER_ASSERT(reporter, peekTextureSucceeds == !!tightImg->getTexture());
SkPixmap tmpPixmap;
REPORTER_ASSERT(reporter, peekTextureSucceeds != !!tightImg->peekPixels(&tmpPixmap));
}
{
SkImageInfo info = SkImageInfo::MakeN32(subset.width(), subset.height(),
kPremul_SkAlphaType);
sk_sp<SkSurface> tightSurf(img->makeTightSurface(info));
REPORTER_ASSERT(reporter, tightSurf->width() == subset.width());
REPORTER_ASSERT(reporter, tightSurf->height() == subset.height());
REPORTER_ASSERT(reporter, peekTextureSucceeds ==
!!tightSurf->getTextureHandle(SkSurface::kDiscardWrite_BackendHandleAccess));
SkPixmap tmpPixmap;
REPORTER_ASSERT(reporter, peekTextureSucceeds != !!tightSurf->peekPixels(&tmpPixmap));
}
}
