blob: 34e0097b83616872ca78432ad827cd9013f3e512 [file] [log] [blame]
/*
* Copyright 2019 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkImage.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkShader.h"
#include "include/core/SkStream.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTileMode.h"
#include "include/encode/SkJpegEncoder.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/gpu/ganesh/SkImageGanesh.h"
#include "src/base/SkRandom.h"
#include "src/core/SkCachedData.h"
#include "src/image/SkImage_Base.h"
#include "tools/DecodeUtils.h"
#include "tools/Resources.h"
#include "tools/gpu/YUVUtils.h"
static constexpr int kScale = 10;
static constexpr SkISize kImageDim = {5, 5};
static sk_sp<SkImage> make_image(GrRecordingContext* rContext,
skgpu::graphite::Recorder* recorder) {
// Generate a small jpeg with odd dimensions.
SkBitmap bmp;
bmp.allocPixels(SkImageInfo::Make(kImageDim, kRGBA_8888_SkColorType, kPremul_SkAlphaType));
SkRandom random;
// These random values won't compress well, but it doesn't matter. This test exists to
// compare the GPU YUV code path to the SW.
for (int y = 0; y < bmp.height(); ++y) {
for (int x = 0; x < bmp.width(); ++x) {
*bmp.getAddr32(x, y) = random.nextU() | 0xFF000000;
}
}
bmp.notifyPixelsChanged();
SkDynamicMemoryWStream stream;
SkJpegEncoder::Options options;
options.fDownsample = SkJpegEncoder::Downsample::k420;
options.fQuality = 100;
if (!SkJpegEncoder::Encode(&stream, bmp.pixmap(), options)) {
return nullptr;
}
auto imageHelper = sk_gpu_test::LazyYUVImage::Make(stream.detachAsData());
if (!imageHelper) {
return nullptr;
}
#if defined(SK_GRAPHITE)
if (recorder) {
return imageHelper->refImage(recorder, sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
} else
#endif
{
return imageHelper->refImage(rContext, sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
}
}
// This GM tests that the YUVA image code path in the GPU backend handles odd sized images with
// 420 chroma subsampling correctly.
DEF_SIMPLE_GM_CAN_FAIL(yuv420_odd_dim, canvas, errMsg,
kScale* kImageDim.width(), kScale* kImageDim.height()) {
auto rContext = canvas->recordingContext();
skgpu::graphite::Recorder* recorder = nullptr;
#if defined(SK_GRAPHITE)
recorder = canvas->recorder();
#endif
if (!rContext && !recorder) {
// This GM exists to exercise GPU planar images.
return skiagm::DrawResult::kSkip;
}
auto image = make_image(rContext, recorder);
if (!image) {
if (rContext) {
return rContext->abandoned() ? skiagm::DrawResult::kOk : skiagm::DrawResult::kFail;
} else {
return skiagm::DrawResult::kFail;
}
}
// We draw the image offscreen and then blow it up using nearest filtering by kScale.
// This avoids skbug.com/9693
sk_sp<SkSurface> surface;
if (auto origSurface = canvas->getSurface()) {
surface = origSurface->makeSurface(image->width(), image->height());
} else {
auto ct = canvas->imageInfo().colorType();
if (ct == kUnknown_SkColorType) {
ct = image->colorType();
}
auto info = canvas->imageInfo().makeColorType(ct);
info = info.makeAlphaType(kPremul_SkAlphaType);
surface = SkSurfaces::Raster(info);
}
surface->getCanvas()->drawImage(image, 0, 0);
canvas->scale(kScale, kScale);
canvas->drawImage(surface->makeImageSnapshot(), 0, 0);
return skiagm::DrawResult::kOk;
}
// crbug.com/1210557 Subsampled planes weren't repeated at the correct frequency.
DEF_SIMPLE_GM_CAN_FAIL(yuv420_odd_dim_repeat, canvas, errMsg,
1000,
500) {
auto rContext = canvas->recordingContext();
skgpu::graphite::Recorder* recorder = nullptr;
#if defined(SK_GRAPHITE)
recorder = canvas->recorder();
#endif
if (!rContext && !recorder) {
// This GM exists to exercise GPU planar images.
return skiagm::DrawResult::kSkip;
}
auto image = ToolUtils::GetResourceAsImage("images/mandrill_256.png");
if (!image) {
if (rContext) {
return rContext->abandoned() ? skiagm::DrawResult::kOk : skiagm::DrawResult::kFail;
} else {
return skiagm::DrawResult::kFail;
}
}
// Make sure the image is odd dimensioned.
int w = image->width() & 0b1 ? image->width() : image->width() - 1;
int h = image->height() & 0b1 ? image->height() : image->height() - 1;
image = image->makeSubset(nullptr, SkIRect::MakeWH(w, h));
auto [planes, yuvaInfo] = sk_gpu_test::MakeYUVAPlanesAsA8(image.get(),
kJPEG_SkYUVColorSpace,
SkYUVAInfo::Subsampling::k420,
nullptr);
SkPixmap pixmaps[4];
for (int i = 0; i < yuvaInfo.numPlanes(); ++i) {
planes[i]->peekPixels(&pixmaps[i]);
}
auto yuvaPixmaps = SkYUVAPixmaps::FromExternalPixmaps(yuvaInfo, pixmaps);
auto lazyYUV = sk_gpu_test::LazyYUVImage::Make(yuvaPixmaps, skgpu::Mipmapped::kYes);
#if defined(SK_GRAPHITE)
if (recorder) {
image = lazyYUV->refImage(recorder, sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
} else
#endif
{
image = lazyYUV->refImage(rContext, sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
}
if (!image) {
*errMsg = "Could not make YUVA image";
if (rContext) {
return rContext->abandoned() ? skiagm::DrawResult::kOk : skiagm::DrawResult::kFail;
} else {
return skiagm::DrawResult::kFail;
}
}
int i = 0;
for (SkMipmapMode mm : {SkMipmapMode::kNone, SkMipmapMode::kLinear}) {
int j = 0;
for (SkFilterMode filter : {SkFilterMode::kNearest, SkFilterMode::kLinear}) {
canvas->save();
canvas->clipRect(SkRect::MakeXYWH(500.f*j, 250.f*i, 500.f, 250.f));
canvas->rotate(30.f);
canvas->scale(0.4f, 0.4f); // so mipmaps sampling doesn't just use base level.
// Large translation so that if U/V planes aren't repeated correctly WRT to Y plane we
// accumulate a lot of error.
canvas->translate(-240000.f, -240000.f);
auto shader = image->makeShader(SkTileMode::kRepeat,
SkTileMode::kRepeat,
SkSamplingOptions(filter, mm));
SkPaint paint;
paint.setShader(std::move(shader));
canvas->drawPaint(paint);
canvas->restore();
++j;
}
++i;
}
return skiagm::DrawResult::kOk;
}