static sk_sp<SkShader> sh_make_image() {
sk_sp<SkImage> image(GetResourceAsImage("mandrill_128.png"));
if (!image) {
return nullptr;
}
return image->makeShader(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
}
static void draw_image(SkCanvas* canvas, const char* resource, int x, int y) {
SkAutoTUnref<SkImage> image(GetResourceAsImage(resource));
if (image) {
canvas->drawImage(image, SkIntToScalar(x), SkIntToScalar(y));
} else {
SkDebugf("\nCould not decode file '%s'. Did you forget"
" to set the resourcePath?\n", resource);
}
}
DEF_TEST(Image_isAlphaOnly, reporter) {
SkPMColor pmColors = 0;
SkPixmap pmap = {
SkImageInfo::MakeN32Premul(1, 1),
&pmColors,
sizeof(pmColors)
};
for (auto& image : {
SkImage::MakeRasterCopy(pmap),
GetResourceAsImage("mandrill_128.png"),
GetResourceAsImage("color_wheel.jpg"),
SkImage::MakeFromPicture(make_picture(), { 10, 10 }, nullptr, nullptr),
})
{
REPORTER_ASSERT(reporter, image->isAlphaOnly() == false);
}
REPORTER_ASSERT(reporter, SkImage::MakeRasterCopy({
SkImageInfo::MakeA8(1, 1), (uint8_t*)&pmColors, 1})->isAlphaOnly() == true);
}
DEF_TEST(serial_procs_image, reporter) {
auto src_img = GetResourceAsImage("images/mandrill_128.png");
const char magic_str[] = "magic signature";
const SkSerialImageProc sprocs[] = {
[](SkImage* img, void* ctx) -> sk_sp<SkData> { return nullptr; },
[](SkImage* img, void* ctx) { return img->encodeToData(); },
[](SkImage* img, void* ctx) { return SkData::MakeWithCString(((State*)ctx)->fStr); },
};
const SkDeserialImageProc dprocs[] = {
[](const void* data, size_t length, void*) -> sk_sp<SkImage> {
return nullptr;
},
[](const void* data, size_t length, void*) {
return SkImage::MakeFromEncoded(SkData::MakeWithCopy(data, length));
},
[](const void* data, size_t length, void* ctx) -> sk_sp<SkImage> {
State* state = (State*)ctx;
if (length != strlen(state->fStr)+1 || memcmp(data, state->fStr, length)) {
return nullptr;
}
return sk_ref_sp(state->fImg);
},
};
sk_sp<SkPicture> pic;
{
SkPictureRecorder rec;
SkCanvas* canvas = rec.beginRecording(128, 128);
canvas->drawImage(src_img, 0, 0, nullptr);
pic = rec.finishRecordingAsPicture();
}
State state = { magic_str, src_img.get() };
SkSerialProcs sproc;
sproc.fImageCtx = &state;
SkDeserialProcs dproc;
dproc.fImageCtx = &state;
for (size_t i = 0; i < SK_ARRAY_COUNT(sprocs); ++i) {
sproc.fImageProc = sprocs[i];
auto data = pic->serialize(&sproc);
REPORTER_ASSERT(reporter, data);
dproc.fImageProc = dprocs[i];
auto new_pic = SkPicture::MakeFromData(data.get(), &dproc);
REPORTER_ASSERT(reporter, data);
auto dst_img = picture_to_image(new_pic);
REPORTER_ASSERT(reporter, ToolUtils::equal_pixels(src_img.get(), dst_img.get()));
}
}
void onPreDraw(SkCanvas*) override {
if (!fPixmap.addr()) {
sk_sp<SkImage> image = GetResourceAsImage(fFileName.c_str());
SkBitmap bm;
if (!as_IB(image)->getROPixels(&bm)) {
SkFAIL("Could not read resource");
}
bm.peekPixels(&fPixmap);
fCount = fPixmap.rowBytesAsPixels();
fDst.reset(fCount);
sk_bzero(fDst.get(), fPixmap.rowBytes());
}
}
// The table color filter uses the texture strip atlas. Make sure abandoning the context works.
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(TextureStripAtlasManagerColorFilterTest, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
sk_sp<SkImage> img = GetResourceAsImage("images/mandrill_128.png");
uint8_t identity[256];
for (int i = 0; i < 256; i++) {
identity[i] = i;
}
SkPaint p;
p.setColorFilter(SkTableColorFilter::Make(identity));
SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128);
auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
SkCanvas* canvas = surface->getCanvas();
canvas->drawImage(std::move(img), 0, 0, &p);
context->abandonContext();
}
static void test_blender(std::string resourceName, skiatest::Reporter* reporter) {
std::string fileName = resourceName + ".png";
sk_sp<SkImage> image = GetResourceAsImage(fileName.c_str());
if (image == nullptr) {
ERRORF(reporter, "image is NULL");
return;
}
SkBitmap bm;
if (!as_IB(image)->getROPixels(&bm)) {
ERRORF(reporter, "Could not read resource");
return;
}
SkPixmap pixmap;
bm.peekPixels(&pixmap);
SkASSERTF(pixmap.colorType() == kN32_SkColorType, "colorType: %d", pixmap.colorType());
SkASSERT(pixmap.alphaType() != kUnpremul_SkAlphaType);
const uint32_t* src = pixmap.addr32();
const int width = pixmap.rowBytesAsPixels();
SkASSERT(width > 0);
SkASSERT(width < 4000);
SkAutoTArray<uint32_t> correctDst(width);
SkAutoTArray<uint32_t> testDst(width);
for (int y = 0; y < pixmap.height(); y++) {
// TODO: zero is not the most interesting dst to test srcover...
sk_bzero(correctDst.get(), width * sizeof(uint32_t));
sk_bzero(testDst.get(), width * sizeof(uint32_t));
brute_force_srcover_srgb_srgb(correctDst.get(), src, width, width);
SkOpts:: srcover_srgb_srgb( testDst.get(), src, width, width);
for (int x = 0; x < width; x++) {
REPORTER_ASSERT_MESSAGE(
reporter, correctDst[x] == testDst[x],
mismatch_message(resourceName, x, y, src[x], correctDst[x], testDst[x]));
if (correctDst[x] != testDst[x]) break;
}
src += width;
}
}
void onOnceBeforeDraw() override {
fRRectPath.addRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(-130, -128.5, 130, 128.5), 4, 4));
fReferenceImage = GetResourceAsImage("shadowreference.png");
}
sk_tool_utils::draw_checkerboard(canvas, SkColorSetRGB(156, 154, 156),
SK_ColorWHITE, 12);
if (!image) {
return;
}
SkRect rect = SkRect::MakeLTRB(-68.0f, -68.0f, 68.0f, 68.0f);
SkPaint paint;
paint.setColor(SkColorSetRGB(49, 48, 49));
SkScalar scale = SkTMin(128.0f / image->width(),
128.0f / image->height());
SkScalar point[2] = {-0.5f * image->width(), -0.5f * image->height()};
for (int j = 0; j < 4; ++j) {
for (int i = 0; i < 4; ++i) {
SkAutoCanvasRestore autoCanvasRestore(canvas, true);
canvas->translate(96.0f + 192.0f * i, 96.0f + 192.0f * j);
canvas->rotate(18.0f * (i + 4 * j));
canvas->drawRect(rect, paint);
canvas->scale(scale, scale);
canvas->drawImage(image, point[0], point[1]);
}
}
}
DEF_SIMPLE_GM(repeated_bitmap, canvas, 576, 576) {
draw_rotated_image(canvas, GetResourceAsImage("randPixels.png").get());
}
DEF_SIMPLE_GM(repeated_bitmap_jpg, canvas, 576, 576) {
draw_rotated_image(canvas, GetResourceAsImage("color_wheel.jpg").get());
}
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm.h"
#include "sk_tool_utils.h"
#include "SkCanvas.h"
#include "SkImage.h"
#include "Resources.h"
#include "SkColorFilter.h"
DEF_SIMPLE_GM(srgb_colorfilter, canvas, 512, 256*3) {
auto img = GetResourceAsImage("mandrill_256.png");
const float array[] = {
1, 0, 0, 0, 0,
0, 1, 0, 0, 0,
0, 0, 1, 0, 0,
-1, 0, 0, 1, 0,
};
auto cf0 = SkColorFilter::MakeMatrixFilterRowMajor255(array);
auto cf1 = SkColorFilter::MakeLinearToSRGBGamma();
auto cf2 = SkColorFilter::MakeSRGBToLinearGamma();
SkPaint p;
p.setColorFilter(cf0);
canvas->drawImage(img, 0, 0, nullptr);
canvas->drawImage(img, 256, 0, &p);
