8472a3d01c
This better matches Chrome's use of DDLs.
With path, image, and text draws stripped out, here is the perf impact of this change:
before CL after CL
w/ DDLs 7.792 1.038
w/o DDLs 0.800 0.876
This perf improvement (in the DDL case) is from backend texture wrapping SkSurfaces being created w/o initialization. The prior method of SkSurface creation was resulting in double clearing of all the surfaces.
This perf improvement won't be seen by Chrome since they've always being using wrapped backend texture SkSurfaces.
TBR=bsalomon@google.com
Bug: 1056730
Change-Id: Ic04d322cad96df845e75437211208495862c6555
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/283866
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
2206 lines
87 KiB
C++
2206 lines
87 KiB
C++
/*
|
|
* Copyright 2015 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "dm/DMSrcSink.h"
|
|
#include "gm/verifiers/gmverifier.h"
|
|
#include "include/codec/SkAndroidCodec.h"
|
|
#include "include/codec/SkCodec.h"
|
|
#include "include/core/SkColorSpace.h"
|
|
#include "include/core/SkData.h"
|
|
#include "include/core/SkDeferredDisplayListRecorder.h"
|
|
#include "include/core/SkDocument.h"
|
|
#include "include/core/SkExecutor.h"
|
|
#include "include/core/SkImageGenerator.h"
|
|
#include "include/core/SkMallocPixelRef.h"
|
|
#include "include/core/SkPictureRecorder.h"
|
|
#include "include/core/SkStream.h"
|
|
#include "include/core/SkSurface.h"
|
|
#include "include/core/SkSurfaceCharacterization.h"
|
|
#include "include/docs/SkPDFDocument.h"
|
|
#include "include/gpu/GrBackendSurface.h"
|
|
#include "include/ports/SkImageGeneratorCG.h"
|
|
#include "include/ports/SkImageGeneratorWIC.h"
|
|
#include "include/private/SkImageInfoPriv.h"
|
|
#include "include/private/SkTLogic.h"
|
|
#include "include/third_party/skcms/skcms.h"
|
|
#include "include/utils/SkNullCanvas.h"
|
|
#include "include/utils/SkRandom.h"
|
|
#include "src/codec/SkCodecImageGenerator.h"
|
|
#include "src/codec/SkSwizzler.h"
|
|
#include "src/core/SkAutoMalloc.h"
|
|
#include "src/core/SkAutoPixmapStorage.h"
|
|
#include "src/core/SkOSFile.h"
|
|
#include "src/core/SkOpts.h"
|
|
#include "src/core/SkPictureCommon.h"
|
|
#include "src/core/SkPictureData.h"
|
|
#include "src/core/SkRecordDraw.h"
|
|
#include "src/core/SkRecorder.h"
|
|
#include "src/core/SkTaskGroup.h"
|
|
#include "src/gpu/GrContextPriv.h"
|
|
#include "src/gpu/GrGpu.h"
|
|
#include "src/utils/SkMultiPictureDocumentPriv.h"
|
|
#include "src/utils/SkOSPath.h"
|
|
#include "tools/DDLPromiseImageHelper.h"
|
|
#include "tools/DDLTileHelper.h"
|
|
#include "tools/Resources.h"
|
|
#include "tools/debugger/DebugCanvas.h"
|
|
#include "tools/gpu/MemoryCache.h"
|
|
#if defined(SK_BUILD_FOR_WIN)
|
|
#include "include/docs/SkXPSDocument.h"
|
|
#include "src/utils/win/SkAutoCoInitialize.h"
|
|
#include "src/utils/win/SkHRESULT.h"
|
|
#include "src/utils/win/SkTScopedComPtr.h"
|
|
#include <XpsObjectModel.h>
|
|
#endif
|
|
|
|
#if defined(SK_ENABLE_SKOTTIE)
|
|
#include "modules/skottie/include/Skottie.h"
|
|
#include "modules/skresources/include/SkResources.h"
|
|
#endif
|
|
|
|
#if defined(SK_XML)
|
|
#include "experimental/svg/model/SkSVGDOM.h"
|
|
#include "include/svg/SkSVGCanvas.h"
|
|
#include "src/xml/SkXMLWriter.h"
|
|
#endif
|
|
#include "tests/TestUtils.h"
|
|
|
|
#include <cmath>
|
|
#include <functional>
|
|
|
|
static DEFINE_bool(multiPage, false,
|
|
"For document-type backends, render the source into multiple pages");
|
|
static DEFINE_bool(RAW_threading, true, "Allow RAW decodes to run on multiple threads?");
|
|
|
|
DECLARE_int(gpuThreads);
|
|
|
|
using sk_gpu_test::GrContextFactory;
|
|
using sk_gpu_test::ContextInfo;
|
|
|
|
namespace DM {
|
|
|
|
GMSrc::GMSrc(skiagm::GMFactory factory) : fFactory(factory) {}
|
|
|
|
Result GMSrc::draw(SkCanvas* canvas) const {
|
|
std::unique_ptr<skiagm::GM> gm(fFactory());
|
|
SkString msg;
|
|
skiagm::DrawResult drawResult = gm->draw(canvas, &msg);
|
|
switch (drawResult) {
|
|
case skiagm::DrawResult::kOk : return Result(Result::Status::Ok, msg);
|
|
case skiagm::DrawResult::kFail: return Result(Result::Status::Fatal, msg);
|
|
case skiagm::DrawResult::kSkip: return Result(Result::Status::Skip, msg);
|
|
default: SK_ABORT("");
|
|
}
|
|
}
|
|
|
|
SkISize GMSrc::size() const {
|
|
std::unique_ptr<skiagm::GM> gm(fFactory());
|
|
return gm->getISize();
|
|
}
|
|
|
|
Name GMSrc::name() const {
|
|
std::unique_ptr<skiagm::GM> gm(fFactory());
|
|
return gm->getName();
|
|
}
|
|
|
|
void GMSrc::modifyGrContextOptions(GrContextOptions* options) const {
|
|
std::unique_ptr<skiagm::GM> gm(fFactory());
|
|
gm->modifyGrContextOptions(options);
|
|
}
|
|
|
|
std::unique_ptr<skiagm::verifiers::VerifierList> GMSrc::getVerifiers() const {
|
|
std::unique_ptr<skiagm::GM> gm(fFactory());
|
|
return gm->getVerifiers();
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
BRDSrc::BRDSrc(Path path, Mode mode, CodecSrc::DstColorType dstColorType, uint32_t sampleSize)
|
|
: fPath(path)
|
|
, fMode(mode)
|
|
, fDstColorType(dstColorType)
|
|
, fSampleSize(sampleSize)
|
|
{}
|
|
|
|
bool BRDSrc::veto(SinkFlags flags) const {
|
|
// No need to test to non-raster or indirect backends.
|
|
return flags.type != SinkFlags::kRaster
|
|
|| flags.approach != SinkFlags::kDirect;
|
|
}
|
|
|
|
static SkBitmapRegionDecoder* create_brd(Path path) {
|
|
sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
|
|
if (!encoded) {
|
|
return nullptr;
|
|
}
|
|
return SkBitmapRegionDecoder::Create(encoded, SkBitmapRegionDecoder::kAndroidCodec_Strategy);
|
|
}
|
|
|
|
static inline void alpha8_to_gray8(SkBitmap* bitmap) {
|
|
// Android requires kGray8 bitmaps to be tagged as kAlpha8. Here we convert
|
|
// them back to kGray8 so our test framework can draw them correctly.
|
|
if (kAlpha_8_SkColorType == bitmap->info().colorType()) {
|
|
SkImageInfo newInfo = bitmap->info().makeColorType(kGray_8_SkColorType)
|
|
.makeAlphaType(kOpaque_SkAlphaType);
|
|
*const_cast<SkImageInfo*>(&bitmap->info()) = newInfo;
|
|
}
|
|
}
|
|
|
|
Result BRDSrc::draw(SkCanvas* canvas) const {
|
|
SkColorType colorType = canvas->imageInfo().colorType();
|
|
if (kRGB_565_SkColorType == colorType &&
|
|
CodecSrc::kGetFromCanvas_DstColorType != fDstColorType)
|
|
{
|
|
return Result::Skip("Testing non-565 to 565 is uninteresting.");
|
|
}
|
|
switch (fDstColorType) {
|
|
case CodecSrc::kGetFromCanvas_DstColorType:
|
|
break;
|
|
case CodecSrc::kGrayscale_Always_DstColorType:
|
|
colorType = kGray_8_SkColorType;
|
|
break;
|
|
default:
|
|
SkASSERT(false);
|
|
break;
|
|
}
|
|
|
|
std::unique_ptr<SkBitmapRegionDecoder> brd(create_brd(fPath));
|
|
if (nullptr == brd.get()) {
|
|
return Result::Skip("Could not create brd for %s.", fPath.c_str());
|
|
}
|
|
|
|
auto recommendedCT = brd->computeOutputColorType(colorType);
|
|
if (kRGB_565_SkColorType == colorType && recommendedCT != colorType) {
|
|
return Result::Skip("Skip decoding non-opaque to 565.");
|
|
}
|
|
colorType = recommendedCT;
|
|
|
|
auto colorSpace = brd->computeOutputColorSpace(colorType, nullptr);
|
|
|
|
const uint32_t width = brd->width();
|
|
const uint32_t height = brd->height();
|
|
// Visually inspecting very small output images is not necessary.
|
|
if ((width / fSampleSize <= 10 || height / fSampleSize <= 10) && 1 != fSampleSize) {
|
|
return Result::Skip("Scaling very small images is uninteresting.");
|
|
}
|
|
switch (fMode) {
|
|
case kFullImage_Mode: {
|
|
SkBitmap bitmap;
|
|
if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(0, 0, width, height),
|
|
fSampleSize, colorType, false, colorSpace)) {
|
|
return Result::Fatal("Cannot decode (full) region.");
|
|
}
|
|
alpha8_to_gray8(&bitmap);
|
|
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
return Result::Ok();
|
|
}
|
|
case kDivisor_Mode: {
|
|
const uint32_t divisor = 2;
|
|
if (width < divisor || height < divisor) {
|
|
return Result::Skip("Divisor is larger than image dimension.");
|
|
}
|
|
|
|
// Use a border to test subsets that extend outside the image.
|
|
// We will not allow the border to be larger than the image dimensions. Allowing
|
|
// these large borders causes off by one errors that indicate a problem with the
|
|
// test suite, not a problem with the implementation.
|
|
const uint32_t maxBorder = std::min(width, height) / (fSampleSize * divisor);
|
|
const uint32_t scaledBorder = std::min(5u, maxBorder);
|
|
const uint32_t unscaledBorder = scaledBorder * fSampleSize;
|
|
|
|
// We may need to clear the canvas to avoid uninitialized memory.
|
|
// Assume we are scaling a 780x780 image with sampleSize = 8.
|
|
// The output image should be 97x97.
|
|
// Each subset will be 390x390.
|
|
// Each scaled subset be 48x48.
|
|
// Four scaled subsets will only fill a 96x96 image.
|
|
// The bottom row and last column will not be touched.
|
|
// This is an unfortunate result of our rounding rules when scaling.
|
|
// Maybe we need to consider testing scaled subsets without trying to
|
|
// combine them to match the full scaled image? Or maybe this is the
|
|
// best we can do?
|
|
canvas->clear(0);
|
|
|
|
for (uint32_t x = 0; x < divisor; x++) {
|
|
for (uint32_t y = 0; y < divisor; y++) {
|
|
// Calculate the subset dimensions
|
|
uint32_t subsetWidth = width / divisor;
|
|
uint32_t subsetHeight = height / divisor;
|
|
const int left = x * subsetWidth;
|
|
const int top = y * subsetHeight;
|
|
|
|
// Increase the size of the last subset in each row or column, when the
|
|
// divisor does not divide evenly into the image dimensions
|
|
subsetWidth += (x + 1 == divisor) ? (width % divisor) : 0;
|
|
subsetHeight += (y + 1 == divisor) ? (height % divisor) : 0;
|
|
|
|
// Increase the size of the subset in order to have a border on each side
|
|
const int decodeLeft = left - unscaledBorder;
|
|
const int decodeTop = top - unscaledBorder;
|
|
const uint32_t decodeWidth = subsetWidth + unscaledBorder * 2;
|
|
const uint32_t decodeHeight = subsetHeight + unscaledBorder * 2;
|
|
SkBitmap bitmap;
|
|
if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(decodeLeft,
|
|
decodeTop, decodeWidth, decodeHeight), fSampleSize, colorType, false,
|
|
colorSpace)) {
|
|
return Result::Fatal("Cannot decode region.");
|
|
}
|
|
|
|
alpha8_to_gray8(&bitmap);
|
|
canvas->drawBitmapRect(bitmap,
|
|
SkRect::MakeXYWH((SkScalar) scaledBorder, (SkScalar) scaledBorder,
|
|
(SkScalar) (subsetWidth / fSampleSize),
|
|
(SkScalar) (subsetHeight / fSampleSize)),
|
|
SkRect::MakeXYWH((SkScalar) (left / fSampleSize),
|
|
(SkScalar) (top / fSampleSize),
|
|
(SkScalar) (subsetWidth / fSampleSize),
|
|
(SkScalar) (subsetHeight / fSampleSize)),
|
|
nullptr);
|
|
}
|
|
}
|
|
return Result::Ok();
|
|
}
|
|
default:
|
|
SkASSERT(false);
|
|
return Result::Fatal("Error: Should not be reached.");
|
|
}
|
|
}
|
|
|
|
SkISize BRDSrc::size() const {
|
|
std::unique_ptr<SkBitmapRegionDecoder> brd(create_brd(fPath));
|
|
if (brd) {
|
|
return {std::max(1, brd->width() / (int)fSampleSize),
|
|
std::max(1, brd->height() / (int)fSampleSize)};
|
|
}
|
|
return {0, 0};
|
|
}
|
|
|
|
static SkString get_scaled_name(const Path& path, float scale) {
|
|
return SkStringPrintf("%s_%.3f", SkOSPath::Basename(path.c_str()).c_str(), scale);
|
|
}
|
|
|
|
Name BRDSrc::name() const {
|
|
// We will replicate the names used by CodecSrc so that images can
|
|
// be compared in Gold.
|
|
if (1 == fSampleSize) {
|
|
return SkOSPath::Basename(fPath.c_str());
|
|
}
|
|
return get_scaled_name(fPath, 1.0f / (float) fSampleSize);
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
static bool serial_from_path_name(const SkString& path) {
|
|
if (!FLAGS_RAW_threading) {
|
|
static const char* const exts[] = {
|
|
"arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
|
|
"ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
|
|
};
|
|
const char* actualExt = strrchr(path.c_str(), '.');
|
|
if (actualExt) {
|
|
actualExt++;
|
|
for (auto* ext : exts) {
|
|
if (0 == strcmp(ext, actualExt)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
CodecSrc::CodecSrc(Path path, Mode mode, DstColorType dstColorType, SkAlphaType dstAlphaType,
|
|
float scale)
|
|
: fPath(path)
|
|
, fMode(mode)
|
|
, fDstColorType(dstColorType)
|
|
, fDstAlphaType(dstAlphaType)
|
|
, fScale(scale)
|
|
, fRunSerially(serial_from_path_name(path))
|
|
{}
|
|
|
|
bool CodecSrc::veto(SinkFlags flags) const {
|
|
// Test to direct raster backends (8888 and 565).
|
|
return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
|
|
}
|
|
|
|
// Allows us to test decodes to non-native 8888.
|
|
static void swap_rb_if_necessary(SkBitmap& bitmap, CodecSrc::DstColorType dstColorType) {
|
|
if (CodecSrc::kNonNative8888_Always_DstColorType != dstColorType) {
|
|
return;
|
|
}
|
|
|
|
for (int y = 0; y < bitmap.height(); y++) {
|
|
uint32_t* row = (uint32_t*) bitmap.getAddr(0, y);
|
|
SkOpts::RGBA_to_BGRA(row, row, bitmap.width());
|
|
}
|
|
}
|
|
|
|
static bool get_decode_info(SkImageInfo* decodeInfo, SkColorType canvasColorType,
|
|
CodecSrc::DstColorType dstColorType, SkAlphaType dstAlphaType) {
|
|
switch (dstColorType) {
|
|
case CodecSrc::kGrayscale_Always_DstColorType:
|
|
if (kRGB_565_SkColorType == canvasColorType) {
|
|
return false;
|
|
}
|
|
*decodeInfo = decodeInfo->makeColorType(kGray_8_SkColorType);
|
|
break;
|
|
case CodecSrc::kNonNative8888_Always_DstColorType:
|
|
if (kRGB_565_SkColorType == canvasColorType
|
|
|| kRGBA_F16_SkColorType == canvasColorType) {
|
|
return false;
|
|
}
|
|
#ifdef SK_PMCOLOR_IS_RGBA
|
|
*decodeInfo = decodeInfo->makeColorType(kBGRA_8888_SkColorType);
|
|
#else
|
|
*decodeInfo = decodeInfo->makeColorType(kRGBA_8888_SkColorType);
|
|
#endif
|
|
break;
|
|
default:
|
|
if (kRGB_565_SkColorType == canvasColorType &&
|
|
kOpaque_SkAlphaType != decodeInfo->alphaType()) {
|
|
return false;
|
|
}
|
|
|
|
*decodeInfo = decodeInfo->makeColorType(canvasColorType);
|
|
break;
|
|
}
|
|
|
|
*decodeInfo = decodeInfo->makeAlphaType(dstAlphaType);
|
|
return true;
|
|
}
|
|
|
|
static void draw_to_canvas(SkCanvas* canvas, const SkImageInfo& info, void* pixels, size_t rowBytes,
|
|
CodecSrc::DstColorType dstColorType,
|
|
SkScalar left = 0, SkScalar top = 0) {
|
|
SkBitmap bitmap;
|
|
bitmap.installPixels(info, pixels, rowBytes);
|
|
swap_rb_if_necessary(bitmap, dstColorType);
|
|
canvas->drawBitmap(bitmap, left, top);
|
|
}
|
|
|
|
// For codec srcs, we want the "draw" step to be a memcpy. Any interesting color space or
|
|
// color format conversions should be performed by the codec. Sometimes the output of the
|
|
// decode will be in an interesting color space. On our srgb and f16 backends, we need to
|
|
// "pretend" that the color space is standard sRGB to avoid triggering color conversion
|
|
// at draw time.
|
|
static void set_bitmap_color_space(SkImageInfo* info) {
|
|
*info = info->makeColorSpace(SkColorSpace::MakeSRGB());
|
|
}
|
|
|
|
Result CodecSrc::draw(SkCanvas* canvas) const {
|
|
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
|
|
if (!encoded) {
|
|
return Result::Fatal("Couldn't read %s.", fPath.c_str());
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(encoded));
|
|
if (nullptr == codec.get()) {
|
|
return Result::Fatal("Couldn't create codec for %s.", fPath.c_str());
|
|
}
|
|
|
|
SkImageInfo decodeInfo = codec->getInfo();
|
|
if (!get_decode_info(&decodeInfo, canvas->imageInfo().colorType(), fDstColorType,
|
|
fDstAlphaType)) {
|
|
return Result::Skip("Skipping uninteresting test.");
|
|
}
|
|
|
|
// Try to scale the image if it is desired
|
|
SkISize size = codec->getScaledDimensions(fScale);
|
|
if (size == decodeInfo.dimensions() && 1.0f != fScale) {
|
|
return Result::Skip("Test without scaling is uninteresting.");
|
|
}
|
|
|
|
// Visually inspecting very small output images is not necessary. We will
|
|
// cover these cases in unit testing.
|
|
if ((size.width() <= 10 || size.height() <= 10) && 1.0f != fScale) {
|
|
return Result::Skip("Scaling very small images is uninteresting.");
|
|
}
|
|
decodeInfo = decodeInfo.makeDimensions(size);
|
|
|
|
const int bpp = decodeInfo.bytesPerPixel();
|
|
const size_t rowBytes = size.width() * bpp;
|
|
const size_t safeSize = decodeInfo.computeByteSize(rowBytes);
|
|
SkAutoMalloc pixels(safeSize);
|
|
|
|
SkCodec::Options options;
|
|
if (kCodecZeroInit_Mode == fMode) {
|
|
memset(pixels.get(), 0, size.height() * rowBytes);
|
|
options.fZeroInitialized = SkCodec::kYes_ZeroInitialized;
|
|
}
|
|
|
|
SkImageInfo bitmapInfo = decodeInfo;
|
|
set_bitmap_color_space(&bitmapInfo);
|
|
if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
|
|
kBGRA_8888_SkColorType == decodeInfo.colorType()) {
|
|
bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
|
|
}
|
|
|
|
switch (fMode) {
|
|
case kAnimated_Mode: {
|
|
std::vector<SkCodec::FrameInfo> frameInfos = codec->getFrameInfo();
|
|
if (frameInfos.size() <= 1) {
|
|
return Result::Fatal("%s is not an animated image.", fPath.c_str());
|
|
}
|
|
|
|
// As in CodecSrc::size(), compute a roughly square grid to draw the frames
|
|
// into. "factor" is the number of frames to draw on one row. There will be
|
|
// up to "factor" rows as well.
|
|
const float root = sqrt((float) frameInfos.size());
|
|
const int factor = sk_float_ceil2int(root);
|
|
|
|
// Used to cache a frame that future frames will depend on.
|
|
SkAutoMalloc priorFramePixels;
|
|
int cachedFrame = SkCodec::kNoFrame;
|
|
for (int i = 0; static_cast<size_t>(i) < frameInfos.size(); i++) {
|
|
options.fFrameIndex = i;
|
|
// Check for a prior frame
|
|
const int reqFrame = frameInfos[i].fRequiredFrame;
|
|
if (reqFrame != SkCodec::kNoFrame && reqFrame == cachedFrame
|
|
&& priorFramePixels.get()) {
|
|
// Copy into pixels
|
|
memcpy(pixels.get(), priorFramePixels.get(), safeSize);
|
|
options.fPriorFrame = reqFrame;
|
|
} else {
|
|
options.fPriorFrame = SkCodec::kNoFrame;
|
|
}
|
|
SkCodec::Result result = codec->getPixels(decodeInfo, pixels.get(),
|
|
rowBytes, &options);
|
|
if (SkCodec::kInvalidInput == result && i > 0) {
|
|
// Some of our test images have truncated later frames. Treat that
|
|
// the same as incomplete.
|
|
result = SkCodec::kIncompleteInput;
|
|
}
|
|
switch (result) {
|
|
case SkCodec::kSuccess:
|
|
case SkCodec::kErrorInInput:
|
|
case SkCodec::kIncompleteInput: {
|
|
// If the next frame depends on this one, store it in priorFrame.
|
|
// It is possible that we may discard a frame that future frames depend on,
|
|
// but the codec will simply redecode the discarded frame.
|
|
// Do this before calling draw_to_canvas, which premultiplies in place. If
|
|
// we're decoding to unpremul, we want to pass the unmodified frame to the
|
|
// codec for decoding the next frame.
|
|
if (static_cast<size_t>(i+1) < frameInfos.size()
|
|
&& frameInfos[i+1].fRequiredFrame == i) {
|
|
memcpy(priorFramePixels.reset(safeSize), pixels.get(), safeSize);
|
|
cachedFrame = i;
|
|
}
|
|
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
const int xTranslate = (i % factor) * decodeInfo.width();
|
|
const int yTranslate = (i / factor) * decodeInfo.height();
|
|
canvas->translate(SkIntToScalar(xTranslate), SkIntToScalar(yTranslate));
|
|
draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, fDstColorType);
|
|
if (result != SkCodec::kSuccess) {
|
|
return Result::Ok();
|
|
}
|
|
break;
|
|
}
|
|
case SkCodec::kInvalidConversion:
|
|
if (i > 0 && (decodeInfo.colorType() == kRGB_565_SkColorType)) {
|
|
return Result::Skip(
|
|
"Cannot decode frame %i to 565 (%s).", i, fPath.c_str());
|
|
}
|
|
// Fall through.
|
|
default:
|
|
return Result::Fatal(
|
|
"Couldn't getPixels for frame %i in %s.", i, fPath.c_str());
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case kCodecZeroInit_Mode:
|
|
case kCodec_Mode: {
|
|
switch (codec->getPixels(decodeInfo, pixels.get(), rowBytes, &options)) {
|
|
case SkCodec::kSuccess:
|
|
// We consider these to be valid, since we should still decode what is
|
|
// available.
|
|
case SkCodec::kErrorInInput:
|
|
case SkCodec::kIncompleteInput:
|
|
break;
|
|
default:
|
|
// Everything else is considered a failure.
|
|
return Result::Fatal("Couldn't getPixels %s.", fPath.c_str());
|
|
}
|
|
|
|
draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, fDstColorType);
|
|
break;
|
|
}
|
|
case kScanline_Mode: {
|
|
void* dst = pixels.get();
|
|
uint32_t height = decodeInfo.height();
|
|
const bool useIncremental = [this]() {
|
|
auto exts = { "png", "PNG", "gif", "GIF" };
|
|
for (auto ext : exts) {
|
|
if (fPath.endsWith(ext)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}();
|
|
// ico may use the old scanline method or the new one, depending on whether it
|
|
// internally holds a bmp or a png.
|
|
const bool ico = fPath.endsWith("ico");
|
|
bool useOldScanlineMethod = !useIncremental && !ico;
|
|
if (useIncremental || ico) {
|
|
if (SkCodec::kSuccess == codec->startIncrementalDecode(decodeInfo, dst,
|
|
rowBytes, &options)) {
|
|
int rowsDecoded;
|
|
auto result = codec->incrementalDecode(&rowsDecoded);
|
|
if (SkCodec::kIncompleteInput == result || SkCodec::kErrorInInput == result) {
|
|
codec->fillIncompleteImage(decodeInfo, dst, rowBytes,
|
|
SkCodec::kNo_ZeroInitialized, height,
|
|
rowsDecoded);
|
|
}
|
|
} else {
|
|
if (useIncremental) {
|
|
// Error: These should support incremental decode.
|
|
return Result::Fatal("Could not start incremental decode");
|
|
}
|
|
// Otherwise, this is an ICO. Since incremental failed, it must contain a BMP,
|
|
// which should work via startScanlineDecode
|
|
useOldScanlineMethod = true;
|
|
}
|
|
}
|
|
|
|
if (useOldScanlineMethod) {
|
|
if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo)) {
|
|
return Result::Fatal("Could not start scanline decoder");
|
|
}
|
|
|
|
// We do not need to check the return value. On an incomplete
|
|
// image, memory will be filled with a default value.
|
|
codec->getScanlines(dst, height, rowBytes);
|
|
}
|
|
|
|
draw_to_canvas(canvas, bitmapInfo, dst, rowBytes, fDstColorType);
|
|
break;
|
|
}
|
|
case kStripe_Mode: {
|
|
const int height = decodeInfo.height();
|
|
// This value is chosen arbitrarily. We exercise more cases by choosing a value that
|
|
// does not align with image blocks.
|
|
const int stripeHeight = 37;
|
|
const int numStripes = (height + stripeHeight - 1) / stripeHeight;
|
|
void* dst = pixels.get();
|
|
|
|
// Decode odd stripes
|
|
if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, &options)) {
|
|
return Result::Fatal("Could not start scanline decoder");
|
|
}
|
|
|
|
// This mode was designed to test the new skip scanlines API in libjpeg-turbo.
|
|
// Jpegs have kTopDown_SkScanlineOrder, and at this time, it is not interesting
|
|
// to run this test for image types that do not have this scanline ordering.
|
|
// We only run this on Jpeg, which is always kTopDown.
|
|
SkASSERT(SkCodec::kTopDown_SkScanlineOrder == codec->getScanlineOrder());
|
|
|
|
for (int i = 0; i < numStripes; i += 2) {
|
|
// Skip a stripe
|
|
const int linesToSkip = std::min(stripeHeight, height - i * stripeHeight);
|
|
codec->skipScanlines(linesToSkip);
|
|
|
|
// Read a stripe
|
|
const int startY = (i + 1) * stripeHeight;
|
|
const int linesToRead = std::min(stripeHeight, height - startY);
|
|
if (linesToRead > 0) {
|
|
codec->getScanlines(SkTAddOffset<void>(dst, rowBytes * startY), linesToRead,
|
|
rowBytes);
|
|
}
|
|
}
|
|
|
|
// Decode even stripes
|
|
const SkCodec::Result startResult = codec->startScanlineDecode(decodeInfo);
|
|
if (SkCodec::kSuccess != startResult) {
|
|
return Result::Fatal("Failed to restart scanline decoder with same parameters.");
|
|
}
|
|
for (int i = 0; i < numStripes; i += 2) {
|
|
// Read a stripe
|
|
const int startY = i * stripeHeight;
|
|
const int linesToRead = std::min(stripeHeight, height - startY);
|
|
codec->getScanlines(SkTAddOffset<void>(dst, rowBytes * startY), linesToRead,
|
|
rowBytes);
|
|
|
|
// Skip a stripe
|
|
const int linesToSkip = std::min(stripeHeight, height - (i + 1) * stripeHeight);
|
|
if (linesToSkip > 0) {
|
|
codec->skipScanlines(linesToSkip);
|
|
}
|
|
}
|
|
|
|
draw_to_canvas(canvas, bitmapInfo, dst, rowBytes, fDstColorType);
|
|
break;
|
|
}
|
|
case kCroppedScanline_Mode: {
|
|
const int width = decodeInfo.width();
|
|
const int height = decodeInfo.height();
|
|
// This value is chosen because, as we move across the image, it will sometimes
|
|
// align with the jpeg block sizes and it will sometimes not. This allows us
|
|
// to test interestingly different code paths in the implementation.
|
|
const int tileSize = 36;
|
|
SkIRect subset;
|
|
for (int x = 0; x < width; x += tileSize) {
|
|
subset = SkIRect::MakeXYWH(x, 0, std::min(tileSize, width - x), height);
|
|
options.fSubset = ⊂
|
|
if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, &options)) {
|
|
return Result::Fatal("Could not start scanline decoder.");
|
|
}
|
|
|
|
codec->getScanlines(SkTAddOffset<void>(pixels.get(), x * bpp), height, rowBytes);
|
|
}
|
|
|
|
draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, fDstColorType);
|
|
break;
|
|
}
|
|
case kSubset_Mode: {
|
|
// Arbitrarily choose a divisor.
|
|
int divisor = 2;
|
|
// Total width/height of the image.
|
|
const int W = codec->getInfo().width();
|
|
const int H = codec->getInfo().height();
|
|
if (divisor > W || divisor > H) {
|
|
return Result::Skip("Cannot codec subset: divisor %d is too big "
|
|
"for %s with dimensions (%d x %d)", divisor,
|
|
fPath.c_str(), W, H);
|
|
}
|
|
// subset dimensions
|
|
// SkWebpCodec, the only one that supports subsets, requires even top/left boundaries.
|
|
const int w = SkAlign2(W / divisor);
|
|
const int h = SkAlign2(H / divisor);
|
|
SkIRect subset;
|
|
options.fSubset = ⊂
|
|
SkBitmap subsetBm;
|
|
// We will reuse pixel memory from bitmap.
|
|
void* dst = pixels.get();
|
|
// Keep track of left and top (for drawing subsetBm into canvas). We could use
|
|
// fScale * x and fScale * y, but we want integers such that the next subset will start
|
|
// where the last one ended. So we'll add decodeInfo.width() and height().
|
|
int left = 0;
|
|
for (int x = 0; x < W; x += w) {
|
|
int top = 0;
|
|
for (int y = 0; y < H; y+= h) {
|
|
// Do not make the subset go off the edge of the image.
|
|
const int preScaleW = std::min(w, W - x);
|
|
const int preScaleH = std::min(h, H - y);
|
|
subset.setXYWH(x, y, preScaleW, preScaleH);
|
|
// And scale
|
|
// FIXME: Should we have a version of getScaledDimensions that takes a subset
|
|
// into account?
|
|
const int scaledW = std::max(1, SkScalarRoundToInt(preScaleW * fScale));
|
|
const int scaledH = std::max(1, SkScalarRoundToInt(preScaleH * fScale));
|
|
decodeInfo = decodeInfo.makeWH(scaledW, scaledH);
|
|
SkImageInfo subsetBitmapInfo = bitmapInfo.makeWH(scaledW, scaledH);
|
|
size_t subsetRowBytes = subsetBitmapInfo.minRowBytes();
|
|
const SkCodec::Result result = codec->getPixels(decodeInfo, dst, subsetRowBytes,
|
|
&options);
|
|
switch (result) {
|
|
case SkCodec::kSuccess:
|
|
case SkCodec::kErrorInInput:
|
|
case SkCodec::kIncompleteInput:
|
|
break;
|
|
default:
|
|
return Result::Fatal("subset codec failed to decode (%d, %d, %d, %d) "
|
|
"from %s with dimensions (%d x %d)\t error %d",
|
|
x, y, decodeInfo.width(), decodeInfo.height(),
|
|
fPath.c_str(), W, H, result);
|
|
}
|
|
draw_to_canvas(canvas, subsetBitmapInfo, dst, subsetRowBytes, fDstColorType,
|
|
SkIntToScalar(left), SkIntToScalar(top));
|
|
|
|
// translate by the scaled height.
|
|
top += decodeInfo.height();
|
|
}
|
|
// translate by the scaled width.
|
|
left += decodeInfo.width();
|
|
}
|
|
return Result::Ok();
|
|
}
|
|
default:
|
|
SkASSERT(false);
|
|
return Result::Fatal("Invalid fMode");
|
|
}
|
|
return Result::Ok();
|
|
}
|
|
|
|
SkISize CodecSrc::size() const {
|
|
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(encoded));
|
|
if (nullptr == codec) {
|
|
return {0, 0};
|
|
}
|
|
|
|
auto imageSize = codec->getScaledDimensions(fScale);
|
|
if (fMode == kAnimated_Mode) {
|
|
// We'll draw one of each frame, so make it big enough to hold them all
|
|
// in a grid. The grid will be roughly square, with "factor" frames per
|
|
// row and up to "factor" rows.
|
|
const size_t count = codec->getFrameInfo().size();
|
|
const float root = sqrt((float) count);
|
|
const int factor = sk_float_ceil2int(root);
|
|
imageSize.fWidth = imageSize.fWidth * factor;
|
|
imageSize.fHeight = imageSize.fHeight * sk_float_ceil2int((float) count / (float) factor);
|
|
}
|
|
return imageSize;
|
|
}
|
|
|
|
Name CodecSrc::name() const {
|
|
if (1.0f == fScale) {
|
|
Name name = SkOSPath::Basename(fPath.c_str());
|
|
if (fMode == kAnimated_Mode) {
|
|
name.append("_animated");
|
|
}
|
|
return name;
|
|
}
|
|
SkASSERT(fMode != kAnimated_Mode);
|
|
return get_scaled_name(fPath, fScale);
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
AndroidCodecSrc::AndroidCodecSrc(Path path, CodecSrc::DstColorType dstColorType,
|
|
SkAlphaType dstAlphaType, int sampleSize)
|
|
: fPath(path)
|
|
, fDstColorType(dstColorType)
|
|
, fDstAlphaType(dstAlphaType)
|
|
, fSampleSize(sampleSize)
|
|
, fRunSerially(serial_from_path_name(path))
|
|
{}
|
|
|
|
bool AndroidCodecSrc::veto(SinkFlags flags) const {
|
|
// No need to test decoding to non-raster or indirect backend.
|
|
return flags.type != SinkFlags::kRaster
|
|
|| flags.approach != SinkFlags::kDirect;
|
|
}
|
|
|
|
Result AndroidCodecSrc::draw(SkCanvas* canvas) const {
|
|
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
|
|
if (!encoded) {
|
|
return Result::Fatal("Couldn't read %s.", fPath.c_str());
|
|
}
|
|
std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::MakeFromData(encoded));
|
|
if (nullptr == codec) {
|
|
return Result::Fatal("Couldn't create android codec for %s.", fPath.c_str());
|
|
}
|
|
|
|
SkImageInfo decodeInfo = codec->getInfo();
|
|
if (!get_decode_info(&decodeInfo, canvas->imageInfo().colorType(), fDstColorType,
|
|
fDstAlphaType)) {
|
|
return Result::Skip("Skipping uninteresting test.");
|
|
}
|
|
|
|
// Scale the image if it is desired.
|
|
SkISize size = codec->getSampledDimensions(fSampleSize);
|
|
|
|
// Visually inspecting very small output images is not necessary. We will
|
|
// cover these cases in unit testing.
|
|
if ((size.width() <= 10 || size.height() <= 10) && 1 != fSampleSize) {
|
|
return Result::Skip("Scaling very small images is uninteresting.");
|
|
}
|
|
decodeInfo = decodeInfo.makeDimensions(size);
|
|
|
|
int bpp = decodeInfo.bytesPerPixel();
|
|
size_t rowBytes = size.width() * bpp;
|
|
SkAutoMalloc pixels(size.height() * rowBytes);
|
|
|
|
SkBitmap bitmap;
|
|
SkImageInfo bitmapInfo = decodeInfo;
|
|
set_bitmap_color_space(&bitmapInfo);
|
|
if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
|
|
kBGRA_8888_SkColorType == decodeInfo.colorType()) {
|
|
bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
|
|
}
|
|
|
|
// Create options for the codec.
|
|
SkAndroidCodec::AndroidOptions options;
|
|
options.fSampleSize = fSampleSize;
|
|
|
|
switch (codec->getAndroidPixels(decodeInfo, pixels.get(), rowBytes, &options)) {
|
|
case SkCodec::kSuccess:
|
|
case SkCodec::kErrorInInput:
|
|
case SkCodec::kIncompleteInput:
|
|
break;
|
|
default:
|
|
return Result::Fatal("Couldn't getPixels %s.", fPath.c_str());
|
|
}
|
|
draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, fDstColorType);
|
|
return Result::Ok();
|
|
}
|
|
|
|
SkISize AndroidCodecSrc::size() const {
|
|
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
|
|
std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::MakeFromData(encoded));
|
|
if (nullptr == codec) {
|
|
return {0, 0};
|
|
}
|
|
return codec->getSampledDimensions(fSampleSize);
|
|
}
|
|
|
|
Name AndroidCodecSrc::name() const {
|
|
// We will replicate the names used by CodecSrc so that images can
|
|
// be compared in Gold.
|
|
if (1 == fSampleSize) {
|
|
return SkOSPath::Basename(fPath.c_str());
|
|
}
|
|
return get_scaled_name(fPath, 1.0f / (float) fSampleSize);
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
ImageGenSrc::ImageGenSrc(Path path, Mode mode, SkAlphaType alphaType, bool isGpu)
|
|
: fPath(path)
|
|
, fMode(mode)
|
|
, fDstAlphaType(alphaType)
|
|
, fIsGpu(isGpu)
|
|
, fRunSerially(serial_from_path_name(path))
|
|
{}
|
|
|
|
bool ImageGenSrc::veto(SinkFlags flags) const {
|
|
if (fIsGpu) {
|
|
// MSAA runs tend to run out of memory and tests the same code paths as regular gpu configs.
|
|
return flags.type != SinkFlags::kGPU || flags.approach != SinkFlags::kDirect ||
|
|
flags.multisampled == SinkFlags::kMultisampled;
|
|
}
|
|
|
|
return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
|
|
}
|
|
|
|
Result ImageGenSrc::draw(SkCanvas* canvas) const {
|
|
if (kRGB_565_SkColorType == canvas->imageInfo().colorType()) {
|
|
return Result::Skip("Uninteresting to test image generator to 565.");
|
|
}
|
|
|
|
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
|
|
if (!encoded) {
|
|
return Result::Fatal("Couldn't read %s.", fPath.c_str());
|
|
}
|
|
|
|
#if defined(SK_BUILD_FOR_WIN)
|
|
// Initialize COM in order to test with WIC.
|
|
SkAutoCoInitialize com;
|
|
if (!com.succeeded()) {
|
|
return Result::Fatal("Could not initialize COM.");
|
|
}
|
|
#endif
|
|
|
|
std::unique_ptr<SkImageGenerator> gen(nullptr);
|
|
switch (fMode) {
|
|
case kCodec_Mode:
|
|
gen = SkCodecImageGenerator::MakeFromEncodedCodec(encoded);
|
|
if (!gen) {
|
|
return Result::Fatal("Could not create codec image generator.");
|
|
}
|
|
break;
|
|
case kPlatform_Mode: {
|
|
#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
|
|
gen = SkImageGeneratorCG::MakeFromEncodedCG(encoded);
|
|
#elif defined(SK_BUILD_FOR_WIN)
|
|
gen = SkImageGeneratorWIC::MakeFromEncodedWIC(encoded);
|
|
#endif
|
|
if (!gen) {
|
|
return Result::Fatal("Could not create platform image generator.");
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
SkASSERT(false);
|
|
return Result::Fatal("Invalid image generator mode");
|
|
}
|
|
|
|
// Test deferred decoding path on GPU
|
|
if (fIsGpu) {
|
|
sk_sp<SkImage> image(SkImage::MakeFromGenerator(std::move(gen), nullptr));
|
|
if (!image) {
|
|
return Result::Fatal("Could not create image from codec image generator.");
|
|
}
|
|
canvas->drawImage(image, 0, 0);
|
|
return Result::Ok();
|
|
}
|
|
|
|
// Test various color and alpha types on CPU
|
|
SkImageInfo decodeInfo = gen->getInfo().makeAlphaType(fDstAlphaType);
|
|
|
|
int bpp = decodeInfo.bytesPerPixel();
|
|
size_t rowBytes = decodeInfo.width() * bpp;
|
|
SkAutoMalloc pixels(decodeInfo.height() * rowBytes);
|
|
if (!gen->getPixels(decodeInfo, pixels.get(), rowBytes)) {
|
|
Result::Status status = Result::Status::Fatal;
|
|
#if defined(SK_BUILD_FOR_WIN)
|
|
if (kPlatform_Mode == fMode) {
|
|
// Do not issue a fatal error for WIC flakiness.
|
|
status = Result::Status::Skip;
|
|
}
|
|
#endif
|
|
return Result(status, "Image generator could not getPixels() for %s\n", fPath.c_str());
|
|
}
|
|
|
|
set_bitmap_color_space(&decodeInfo);
|
|
draw_to_canvas(canvas, decodeInfo, pixels.get(), rowBytes,
|
|
CodecSrc::kGetFromCanvas_DstColorType);
|
|
return Result::Ok();
|
|
}
|
|
|
|
SkISize ImageGenSrc::size() const {
|
|
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(encoded));
|
|
if (nullptr == codec) {
|
|
return {0, 0};
|
|
}
|
|
return codec->getInfo().dimensions();
|
|
}
|
|
|
|
Name ImageGenSrc::name() const {
|
|
return SkOSPath::Basename(fPath.c_str());
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
ColorCodecSrc::ColorCodecSrc(Path path, bool decode_to_dst) : fPath(path)
|
|
, fDecodeToDst(decode_to_dst) {}
|
|
|
|
bool ColorCodecSrc::veto(SinkFlags flags) const {
|
|
// Test to direct raster backends (8888 and 565).
|
|
return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
|
|
}
|
|
|
|
Result ColorCodecSrc::draw(SkCanvas* canvas) const {
|
|
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
|
|
if (!encoded) {
|
|
return Result::Fatal("Couldn't read %s.", fPath.c_str());
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(encoded));
|
|
if (nullptr == codec) {
|
|
return Result::Fatal("Couldn't create codec for %s.", fPath.c_str());
|
|
}
|
|
|
|
SkImageInfo info = codec->getInfo();
|
|
if (fDecodeToDst) {
|
|
SkImageInfo canvasInfo = canvas->imageInfo();
|
|
if (!canvasInfo.colorSpace()) {
|
|
// This will skip color conversion, and the resulting images will
|
|
// look different from images they are compared against in Gold, but
|
|
// that doesn't mean they are wrong. We have a test verifying that
|
|
// passing a null SkColorSpace skips conversion, so skip this
|
|
// misleading test.
|
|
return Result::Skip("Skipping decoding without color transform.");
|
|
}
|
|
info = canvasInfo.makeDimensions(info.dimensions());
|
|
}
|
|
|
|
SkBitmap bitmap;
|
|
if (!bitmap.tryAllocPixels(info)) {
|
|
return Result::Fatal("Image(%s) is too large (%d x %d)",
|
|
fPath.c_str(), info.width(), info.height());
|
|
}
|
|
|
|
switch (auto r = codec->getPixels(info, bitmap.getPixels(), bitmap.rowBytes())) {
|
|
case SkCodec::kSuccess:
|
|
case SkCodec::kErrorInInput:
|
|
case SkCodec::kIncompleteInput:
|
|
canvas->drawBitmap(bitmap, 0,0);
|
|
return Result::Ok();
|
|
case SkCodec::kInvalidConversion:
|
|
// TODO(mtklein): why are there formats we can't decode to?
|
|
return Result::Skip("SkCodec can't decode to this format.");
|
|
default:
|
|
return Result::Fatal("Couldn't getPixels %s. Error code %d", fPath.c_str(), r);
|
|
}
|
|
}
|
|
|
|
SkISize ColorCodecSrc::size() const {
|
|
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(encoded));
|
|
if (nullptr == codec) {
|
|
return {0, 0};
|
|
}
|
|
return {codec->getInfo().width(), codec->getInfo().height()};
|
|
}
|
|
|
|
Name ColorCodecSrc::name() const {
|
|
return SkOSPath::Basename(fPath.c_str());
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
static DEFINE_int(skpViewportSize, 1000,
|
|
"Width & height of the viewport used to crop skp rendering.");
|
|
|
|
SKPSrc::SKPSrc(Path path) : fPath(path) { }
|
|
|
|
Result SKPSrc::draw(SkCanvas* canvas) const {
|
|
std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(fPath.c_str());
|
|
if (!stream) {
|
|
return Result::Fatal("Couldn't read %s.", fPath.c_str());
|
|
}
|
|
sk_sp<SkPicture> pic(SkPicture::MakeFromStream(stream.get()));
|
|
if (!pic) {
|
|
return Result::Fatal("Couldn't parse file %s.", fPath.c_str());
|
|
}
|
|
stream = nullptr; // Might as well drop this when we're done with it.
|
|
canvas->clipRect(SkRect::MakeWH(FLAGS_skpViewportSize, FLAGS_skpViewportSize));
|
|
canvas->drawPicture(pic);
|
|
return Result::Ok();
|
|
}
|
|
|
|
static SkRect get_cull_rect_for_skp(const char* path) {
|
|
std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(path);
|
|
if (!stream) {
|
|
return SkRect::MakeEmpty();
|
|
}
|
|
SkPictInfo info;
|
|
if (!SkPicture_StreamIsSKP(stream.get(), &info)) {
|
|
return SkRect::MakeEmpty();
|
|
}
|
|
|
|
return info.fCullRect;
|
|
}
|
|
|
|
SkISize SKPSrc::size() const {
|
|
SkRect viewport = get_cull_rect_for_skp(fPath.c_str());
|
|
if (!viewport.intersect((SkRect::MakeWH(FLAGS_skpViewportSize, FLAGS_skpViewportSize)))) {
|
|
return {0, 0};
|
|
}
|
|
return viewport.roundOut().size();
|
|
}
|
|
|
|
Name SKPSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
BisectSrc::BisectSrc(Path path, const char* trail) : INHERITED(path), fTrail(trail) {}
|
|
|
|
Result BisectSrc::draw(SkCanvas* canvas) const {
|
|
struct FoundPath {
|
|
SkPath fPath;
|
|
SkPaint fPaint;
|
|
SkMatrix fViewMatrix;
|
|
};
|
|
|
|
// This subclass of SkCanvas just extracts all the SkPaths (drawn via drawPath) from an SKP.
|
|
class PathFindingCanvas : public SkCanvas {
|
|
public:
|
|
PathFindingCanvas(int width, int height) : SkCanvas(width, height, nullptr) {}
|
|
const SkTArray<FoundPath>& foundPaths() const { return fFoundPaths; }
|
|
|
|
private:
|
|
void onDrawPath(const SkPath& path, const SkPaint& paint) override {
|
|
fFoundPaths.push_back() = {path, paint, this->getTotalMatrix()};
|
|
}
|
|
|
|
SkTArray<FoundPath> fFoundPaths;
|
|
};
|
|
|
|
PathFindingCanvas pathFinder(canvas->getBaseLayerSize().width(),
|
|
canvas->getBaseLayerSize().height());
|
|
Result result = this->INHERITED::draw(&pathFinder);
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
|
|
int start = 0, end = pathFinder.foundPaths().count();
|
|
for (const char* ch = fTrail.c_str(); *ch; ++ch) {
|
|
int midpt = (start + end) / 2;
|
|
if ('l' == *ch) {
|
|
start = midpt;
|
|
} else if ('r' == *ch) {
|
|
end = midpt;
|
|
}
|
|
}
|
|
|
|
for (int i = start; i < end; ++i) {
|
|
const FoundPath& path = pathFinder.foundPaths()[i];
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
canvas->concat(path.fViewMatrix);
|
|
canvas->drawPath(path.fPath, path.fPaint);
|
|
}
|
|
|
|
return Result::Ok();
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
#if defined(SK_ENABLE_SKOTTIE)
|
|
SkottieSrc::SkottieSrc(Path path) : fPath(std::move(path)) {}
|
|
|
|
Result SkottieSrc::draw(SkCanvas* canvas) const {
|
|
auto animation = skottie::Animation::Builder()
|
|
.setResourceProvider(
|
|
skresources::DataURIResourceProviderProxy::Make(
|
|
skresources::FileResourceProvider::Make(SkOSPath::Dirname(fPath.c_str()),
|
|
/*predecode=*/true),
|
|
/*predecode=*/true))
|
|
.makeFromFile(fPath.c_str());
|
|
if (!animation) {
|
|
return Result::Fatal("Unable to parse file: %s", fPath.c_str());
|
|
}
|
|
|
|
canvas->drawColor(SK_ColorWHITE);
|
|
|
|
const auto t_rate = 1.0f / (kTileCount * kTileCount - 1);
|
|
|
|
// Draw the frames in a shuffled order to exercise non-linear
|
|
// frame progression. The film strip will still be in order left-to-right,
|
|
// top-down, just not drawn in that order.
|
|
static constexpr int frameOrder[] = { 4, 0, 3, 1, 2 };
|
|
static_assert(SK_ARRAY_COUNT(frameOrder) == kTileCount, "");
|
|
|
|
for (int i = 0; i < kTileCount; ++i) {
|
|
const SkScalar y = frameOrder[i] * kTileSize;
|
|
|
|
for (int j = 0; j < kTileCount; ++j) {
|
|
const SkScalar x = frameOrder[j] * kTileSize;
|
|
SkRect dest = SkRect::MakeXYWH(x, y, kTileSize, kTileSize);
|
|
|
|
const auto t = t_rate * (frameOrder[i] * kTileCount + frameOrder[j]);
|
|
{
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
canvas->clipRect(dest, true);
|
|
canvas->concat(SkMatrix::MakeRectToRect(SkRect::MakeSize(animation->size()),
|
|
dest,
|
|
SkMatrix::kCenter_ScaleToFit));
|
|
animation->seek(t);
|
|
animation->render(canvas);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Result::Ok();
|
|
}
|
|
|
|
SkISize SkottieSrc::size() const {
|
|
return SkISize::Make(kTargetSize, kTargetSize);
|
|
}
|
|
|
|
Name SkottieSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
|
|
|
|
bool SkottieSrc::veto(SinkFlags flags) const {
|
|
// No need to test to non-(raster||gpu||vector) or indirect backends.
|
|
bool type_ok = flags.type == SinkFlags::kRaster
|
|
|| flags.type == SinkFlags::kGPU
|
|
|| flags.type == SinkFlags::kVector;
|
|
|
|
return !type_ok || flags.approach != SinkFlags::kDirect;
|
|
}
|
|
#endif
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
#if defined(SK_XML)
|
|
// Used when the image doesn't have an intrinsic size.
|
|
static const SkSize kDefaultSVGSize = {1000, 1000};
|
|
|
|
// Used to force-scale tiny fixed-size images.
|
|
static const SkSize kMinimumSVGSize = {128, 128};
|
|
|
|
SVGSrc::SVGSrc(Path path)
|
|
: fName(SkOSPath::Basename(path.c_str()))
|
|
, fScale(1) {
|
|
|
|
sk_sp<SkData> data(SkData::MakeFromFileName(path.c_str()));
|
|
if (!data) {
|
|
return;
|
|
}
|
|
|
|
SkMemoryStream stream(std::move(data));
|
|
fDom = SkSVGDOM::MakeFromStream(stream);
|
|
if (!fDom) {
|
|
return;
|
|
}
|
|
|
|
const SkSize& sz = fDom->containerSize();
|
|
if (sz.isEmpty()) {
|
|
// no intrinsic size
|
|
fDom->setContainerSize(kDefaultSVGSize);
|
|
} else {
|
|
fScale = std::max(1.f, std::max(kMinimumSVGSize.width() / sz.width(),
|
|
kMinimumSVGSize.height() / sz.height()));
|
|
}
|
|
}
|
|
|
|
Result SVGSrc::draw(SkCanvas* canvas) const {
|
|
if (!fDom) {
|
|
return Result::Fatal("Unable to parse file: %s", fName.c_str());
|
|
}
|
|
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
canvas->scale(fScale, fScale);
|
|
fDom->render(canvas);
|
|
|
|
return Result::Ok();
|
|
}
|
|
|
|
SkISize SVGSrc::size() const {
|
|
if (!fDom) {
|
|
return {0, 0};
|
|
}
|
|
|
|
return SkSize{fDom->containerSize().width() * fScale, fDom->containerSize().height() * fScale}
|
|
.toRound();
|
|
}
|
|
|
|
Name SVGSrc::name() const { return fName; }
|
|
|
|
bool SVGSrc::veto(SinkFlags flags) const {
|
|
// No need to test to non-(raster||gpu||vector) or indirect backends.
|
|
bool type_ok = flags.type == SinkFlags::kRaster
|
|
|| flags.type == SinkFlags::kGPU
|
|
|| flags.type == SinkFlags::kVector;
|
|
|
|
return !type_ok || flags.approach != SinkFlags::kDirect;
|
|
}
|
|
|
|
#endif // defined(SK_XML)
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
MSKPSrc::MSKPSrc(Path path) : fPath(path) {
|
|
std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(fPath.c_str());
|
|
int count = SkMultiPictureDocumentReadPageCount(stream.get());
|
|
if (count > 0) {
|
|
fPages.reset(count);
|
|
(void)SkMultiPictureDocumentReadPageSizes(stream.get(), &fPages[0], fPages.count());
|
|
}
|
|
}
|
|
|
|
int MSKPSrc::pageCount() const { return fPages.count(); }
|
|
|
|
SkISize MSKPSrc::size() const { return this->size(0); }
|
|
SkISize MSKPSrc::size(int i) const {
|
|
return i >= 0 && i < fPages.count() ? fPages[i].fSize.toCeil() : SkISize{0, 0};
|
|
}
|
|
|
|
Result MSKPSrc::draw(SkCanvas* c) const { return this->draw(0, c); }
|
|
Result MSKPSrc::draw(int i, SkCanvas* canvas) const {
|
|
if (this->pageCount() == 0) {
|
|
return Result::Fatal("Unable to parse MultiPictureDocument file: %s", fPath.c_str());
|
|
}
|
|
if (i >= fPages.count() || i < 0) {
|
|
return Result::Fatal("MultiPictureDocument page number out of range: %d", i);
|
|
}
|
|
SkPicture* page = fPages[i].fPicture.get();
|
|
if (!page) {
|
|
std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(fPath.c_str());
|
|
if (!stream) {
|
|
return Result::Fatal("Unable to open file: %s", fPath.c_str());
|
|
}
|
|
if (!SkMultiPictureDocumentRead(stream.get(), &fPages[0], fPages.count())) {
|
|
return Result::Fatal("SkMultiPictureDocument reader failed on page %d: %s", i,
|
|
fPath.c_str());
|
|
}
|
|
page = fPages[i].fPicture.get();
|
|
}
|
|
canvas->drawPicture(page);
|
|
return Result::Ok();
|
|
}
|
|
|
|
Name MSKPSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
Result NullSink::draw(const Src& src, SkBitmap*, SkWStream*, SkString*) const {
|
|
return src.draw(SkMakeNullCanvas().get());
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
static Result compare_bitmaps(const SkBitmap& reference, const SkBitmap& bitmap) {
|
|
// The dimensions are a property of the Src only, and so should be identical.
|
|
SkASSERT(reference.computeByteSize() == bitmap.computeByteSize());
|
|
if (reference.computeByteSize() != bitmap.computeByteSize()) {
|
|
return Result::Fatal("Dimensions don't match reference");
|
|
}
|
|
// All SkBitmaps in DM are tight, so this comparison is easy.
|
|
if (0 != memcmp(reference.getPixels(), bitmap.getPixels(), reference.computeByteSize())) {
|
|
SkString encoded;
|
|
SkString errString("Pixels don't match reference");
|
|
if (BipmapToBase64DataURI(reference, &encoded)) {
|
|
errString.append("\nExpected: ");
|
|
errString.append(encoded);
|
|
} else {
|
|
errString.append("\nExpected image failed to encode: ");
|
|
errString.append(encoded);
|
|
}
|
|
if (BipmapToBase64DataURI(bitmap, &encoded)) {
|
|
errString.append("\nActual: ");
|
|
errString.append(encoded);
|
|
} else {
|
|
errString.append("\nActual image failed to encode: ");
|
|
errString.append(encoded);
|
|
}
|
|
return Result::Fatal(errString);
|
|
}
|
|
return Result::Ok();
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
static DEFINE_bool(gpuStats, false, "Append GPU stats to the log for each GPU task?");
|
|
static DEFINE_bool(preAbandonGpuContext, false,
|
|
"Test abandoning the GrContext before running the test.");
|
|
static DEFINE_bool(abandonGpuContext, false,
|
|
"Test abandoning the GrContext after running each test.");
|
|
static DEFINE_bool(releaseAndAbandonGpuContext, false,
|
|
"Test releasing all gpu resources and abandoning the GrContext "
|
|
"after running each test");
|
|
static DEFINE_bool(drawOpClip, false, "Clip each GrDrawOp to its device bounds for testing.");
|
|
static DEFINE_bool(programBinaryCache, true, "Use in-memory program binary cache");
|
|
|
|
GPUSink::GPUSink(const SkCommandLineConfigGpu* config,
|
|
const GrContextOptions& grCtxOptions)
|
|
: fContextType(config->getContextType())
|
|
, fContextOverrides(config->getContextOverrides())
|
|
, fSurfType(config->getSurfType())
|
|
, fSampleCount(config->getSamples())
|
|
, fUseDIText(config->getUseDIText())
|
|
, fColorType(config->getColorType())
|
|
, fAlphaType(config->getAlphaType())
|
|
, fColorSpace(sk_ref_sp(config->getColorSpace()))
|
|
, fBaseContextOptions(grCtxOptions) {
|
|
if (FLAGS_programBinaryCache) {
|
|
fBaseContextOptions.fPersistentCache = &fMemoryCache;
|
|
}
|
|
}
|
|
|
|
Result GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream* dstStream, SkString* log) const {
|
|
return this->onDraw(src, dst, dstStream, log, fBaseContextOptions);
|
|
}
|
|
|
|
sk_sp<SkSurface> GPUSink::createDstSurface(GrContext* context, SkISize size,
|
|
GrBackendTexture* backendTexture,
|
|
GrBackendRenderTarget* backendRT) const {
|
|
sk_sp<SkSurface> surface;
|
|
|
|
SkImageInfo info = SkImageInfo::Make(size, fColorType, fAlphaType, fColorSpace);
|
|
uint32_t flags = fUseDIText ? SkSurfaceProps::kUseDeviceIndependentFonts_Flag : 0;
|
|
SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
|
|
|
|
switch (fSurfType) {
|
|
case SkCommandLineConfigGpu::SurfType::kDefault:
|
|
surface = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, fSampleCount,
|
|
&props);
|
|
break;
|
|
case SkCommandLineConfigGpu::SurfType::kBackendTexture:
|
|
*backendTexture = context->createBackendTexture(
|
|
info.width(), info.height(), info.colorType(), SkColors::kTransparent,
|
|
GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo);
|
|
surface = SkSurface::MakeFromBackendTexture(context, *backendTexture,
|
|
kTopLeft_GrSurfaceOrigin, fSampleCount,
|
|
fColorType, info.refColorSpace(), &props);
|
|
break;
|
|
case SkCommandLineConfigGpu::SurfType::kBackendRenderTarget:
|
|
if (1 == fSampleCount) {
|
|
auto colorType = SkColorTypeToGrColorType(info.colorType());
|
|
*backendRT = context->priv().getGpu()->createTestingOnlyBackendRenderTarget(
|
|
info.width(), info.height(), colorType);
|
|
surface = SkSurface::MakeFromBackendRenderTarget(
|
|
context, *backendRT, kBottomLeft_GrSurfaceOrigin, info.colorType(),
|
|
info.refColorSpace(), &props);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return surface;
|
|
}
|
|
|
|
bool GPUSink::readBack(SkSurface* surface, SkBitmap* dst) const {
|
|
SkCanvas* canvas = surface->getCanvas();
|
|
SkISize size = surface->imageInfo().dimensions();
|
|
|
|
SkImageInfo info = SkImageInfo::Make(size, fColorType, fAlphaType, fColorSpace);
|
|
if (info.colorType() == kRGB_565_SkColorType || info.colorType() == kARGB_4444_SkColorType ||
|
|
info.colorType() == kRGB_888x_SkColorType) {
|
|
// We don't currently support readbacks into these formats on the GPU backend. Convert to
|
|
// 32 bit.
|
|
info = SkImageInfo::Make(size, kRGBA_8888_SkColorType, kPremul_SkAlphaType, fColorSpace);
|
|
}
|
|
dst->allocPixels(info);
|
|
return canvas->readPixels(*dst, 0, 0);
|
|
}
|
|
|
|
Result GPUSink::onDraw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log,
|
|
const GrContextOptions& baseOptions,
|
|
std::function<void(GrContext*)> initContext) const {
|
|
GrContextOptions grOptions = baseOptions;
|
|
|
|
// We don't expect the src to mess with the persistent cache or the executor.
|
|
SkDEBUGCODE(auto cache = grOptions.fPersistentCache);
|
|
SkDEBUGCODE(auto exec = grOptions.fExecutor);
|
|
src.modifyGrContextOptions(&grOptions);
|
|
SkASSERT(cache == grOptions.fPersistentCache);
|
|
SkASSERT(exec == grOptions.fExecutor);
|
|
|
|
GrContextFactory factory(grOptions);
|
|
GrContext* context = factory.getContextInfo(fContextType, fContextOverrides).grContext();
|
|
if (initContext) {
|
|
initContext(context);
|
|
}
|
|
|
|
const int maxDimension = context->priv().caps()->maxTextureSize();
|
|
if (maxDimension < std::max(src.size().width(), src.size().height())) {
|
|
return Result::Skip("Src too large to create a texture.\n");
|
|
}
|
|
|
|
GrBackendTexture backendTexture;
|
|
GrBackendRenderTarget backendRT;
|
|
sk_sp<SkSurface> surface = this->createDstSurface(context, src.size(),
|
|
&backendTexture, &backendRT);
|
|
if (!surface) {
|
|
return Result::Fatal("Could not create a surface.");
|
|
}
|
|
if (FLAGS_preAbandonGpuContext) {
|
|
factory.abandonContexts();
|
|
}
|
|
SkCanvas* canvas = surface->getCanvas();
|
|
Result result = src.draw(canvas);
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
surface->flush();
|
|
if (FLAGS_gpuStats) {
|
|
canvas->getGrContext()->priv().dumpCacheStats(log);
|
|
canvas->getGrContext()->priv().dumpGpuStats(log);
|
|
}
|
|
|
|
this->readBack(surface.get(), dst);
|
|
|
|
if (FLAGS_abandonGpuContext) {
|
|
factory.abandonContexts();
|
|
} else if (FLAGS_releaseAndAbandonGpuContext) {
|
|
factory.releaseResourcesAndAbandonContexts();
|
|
}
|
|
if (!context->abandoned()) {
|
|
surface.reset();
|
|
if (backendTexture.isValid()) {
|
|
context->deleteBackendTexture(backendTexture);
|
|
}
|
|
if (backendRT.isValid()) {
|
|
context->priv().getGpu()->deleteTestingOnlyBackendRenderTarget(backendRT);
|
|
}
|
|
}
|
|
if (grOptions.fPersistentCache) {
|
|
context->storeVkPipelineCacheData();
|
|
}
|
|
return Result::Ok();
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
GPUThreadTestingSink::GPUThreadTestingSink(const SkCommandLineConfigGpu* config,
|
|
const GrContextOptions& grCtxOptions)
|
|
: INHERITED(config, grCtxOptions)
|
|
, fExecutor(SkExecutor::MakeFIFOThreadPool(FLAGS_gpuThreads)) {
|
|
SkASSERT(fExecutor);
|
|
}
|
|
|
|
Result GPUThreadTestingSink::draw(const Src& src, SkBitmap* dst, SkWStream* wStream,
|
|
SkString* log) const {
|
|
// Draw twice, once with worker threads, and once without. Verify that we get the same result.
|
|
// Also, force us to only use the software path renderer, so we really stress-test the threaded
|
|
// version of that code.
|
|
GrContextOptions contextOptions = this->baseContextOptions();
|
|
contextOptions.fGpuPathRenderers = GpuPathRenderers::kNone;
|
|
contextOptions.fExecutor = fExecutor.get();
|
|
|
|
Result result = this->onDraw(src, dst, wStream, log, contextOptions);
|
|
if (!result.isOk() || !dst) {
|
|
return result;
|
|
}
|
|
|
|
SkBitmap reference;
|
|
SkString refLog;
|
|
SkDynamicMemoryWStream refStream;
|
|
contextOptions.fExecutor = nullptr;
|
|
Result refResult = this->onDraw(src, &reference, &refStream, &refLog, contextOptions);
|
|
if (!refResult.isOk()) {
|
|
return refResult;
|
|
}
|
|
|
|
return compare_bitmaps(reference, *dst);
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
GPUPersistentCacheTestingSink::GPUPersistentCacheTestingSink(const SkCommandLineConfigGpu* config,
|
|
const GrContextOptions& grCtxOptions)
|
|
: INHERITED(config, grCtxOptions)
|
|
, fCacheType(config->getTestPersistentCache()) {}
|
|
|
|
Result GPUPersistentCacheTestingSink::draw(const Src& src, SkBitmap* dst, SkWStream* wStream,
|
|
SkString* log) const {
|
|
// Draw twice, once with a cold cache, and again with a warm cache. Verify that we get the same
|
|
// result.
|
|
sk_gpu_test::MemoryCache memoryCache;
|
|
GrContextOptions contextOptions = this->baseContextOptions();
|
|
contextOptions.fPersistentCache = &memoryCache;
|
|
if (fCacheType == 2) {
|
|
contextOptions.fShaderCacheStrategy = GrContextOptions::ShaderCacheStrategy::kBackendSource;
|
|
}
|
|
|
|
Result result = this->onDraw(src, dst, wStream, log, contextOptions);
|
|
if (!result.isOk() || !dst) {
|
|
return result;
|
|
}
|
|
|
|
SkBitmap reference;
|
|
SkString refLog;
|
|
SkDynamicMemoryWStream refStream;
|
|
memoryCache.resetNumCacheMisses();
|
|
Result refResult = this->onDraw(src, &reference, &refStream, &refLog, contextOptions);
|
|
if (!refResult.isOk()) {
|
|
return refResult;
|
|
}
|
|
SkASSERT(!memoryCache.numCacheMisses());
|
|
|
|
return compare_bitmaps(reference, *dst);
|
|
}
|
|
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
GPUPrecompileTestingSink::GPUPrecompileTestingSink(const SkCommandLineConfigGpu* config,
|
|
const GrContextOptions& grCtxOptions)
|
|
: INHERITED(config, grCtxOptions) {}
|
|
|
|
Result GPUPrecompileTestingSink::draw(const Src& src, SkBitmap* dst, SkWStream* wStream,
|
|
SkString* log) const {
|
|
// Three step process:
|
|
// 1) Draw once with an SkSL cache, and store off the shader blobs.
|
|
// 2) For the second context, pre-compile the shaders to warm the cache.
|
|
// 3) Draw with the second context, ensuring that we get the same result, and no cache misses.
|
|
sk_gpu_test::MemoryCache memoryCache;
|
|
GrContextOptions contextOptions = this->baseContextOptions();
|
|
contextOptions.fPersistentCache = &memoryCache;
|
|
contextOptions.fShaderCacheStrategy = GrContextOptions::ShaderCacheStrategy::kSkSL;
|
|
|
|
Result result = this->onDraw(src, dst, wStream, log, contextOptions);
|
|
if (!result.isOk() || !dst) {
|
|
return result;
|
|
}
|
|
|
|
auto precompileShaders = [&memoryCache](GrContext* context) {
|
|
memoryCache.foreach([context](sk_sp<const SkData> key, sk_sp<SkData> data, int /*count*/) {
|
|
SkAssertResult(context->precompileShader(*key, *data));
|
|
});
|
|
};
|
|
|
|
sk_gpu_test::MemoryCache replayCache;
|
|
GrContextOptions replayOptions = this->baseContextOptions();
|
|
// Ensure that the runtime cache is large enough to hold all of the shaders we pre-compile
|
|
replayOptions.fRuntimeProgramCacheSize = memoryCache.numCacheMisses();
|
|
replayOptions.fPersistentCache = &replayCache;
|
|
|
|
SkBitmap reference;
|
|
SkString refLog;
|
|
SkDynamicMemoryWStream refStream;
|
|
Result refResult = this->onDraw(src, &reference, &refStream, &refLog, replayOptions,
|
|
precompileShaders);
|
|
if (!refResult.isOk()) {
|
|
return refResult;
|
|
}
|
|
SkASSERT(!replayCache.numCacheMisses());
|
|
|
|
return compare_bitmaps(reference, *dst);
|
|
}
|
|
|
|
GPUDDLSink::GPUDDLSink(const SkCommandLineConfigGpu* config, const GrContextOptions& grCtxOptions)
|
|
: INHERITED(config, grCtxOptions)
|
|
, fRecordingThreadPool(SkExecutor::MakeLIFOThreadPool(1)) // TODO: this should be at least 2
|
|
, fGPUThread(SkExecutor::MakeFIFOThreadPool(1)) {
|
|
}
|
|
|
|
Result GPUDDLSink::ddlDraw(const Src& src,
|
|
sk_sp<SkSurface> dstSurface,
|
|
SkTaskGroup* recordingTaskGroup,
|
|
SkTaskGroup* gpuTaskGroup,
|
|
sk_gpu_test::TestContext* gpuTestCtx,
|
|
GrContext* gpuThreadCtx) const {
|
|
|
|
// We have to do this here bc characterization can hit the SkGpuDevice's thread guard (i.e.,
|
|
// leaving it until the DDLTileHelper ctor will result in multiple threads trying to use the
|
|
// same context (this thread and the gpuThread - which will be uploading textures)).
|
|
SkSurfaceCharacterization dstCharacterization;
|
|
SkAssertResult(dstSurface->characterize(&dstCharacterization));
|
|
|
|
// 'gpuTestCtx/gpuThreadCtx' is being shifted to the gpuThread. Leave the main (this)
|
|
// thread w/o a context.
|
|
gpuTestCtx->makeNotCurrent();
|
|
|
|
// Job one for the GPU thread is to make 'gpuTestCtx' current!
|
|
gpuTaskGroup->add([gpuTestCtx] { gpuTestCtx->makeCurrent(); });
|
|
|
|
auto size = src.size();
|
|
SkPictureRecorder recorder;
|
|
Result result = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
|
|
SkIntToScalar(size.height())));
|
|
if (!result.isOk()) {
|
|
gpuTaskGroup->add([gpuTestCtx] { gpuTestCtx->makeNotCurrent(); });
|
|
gpuTaskGroup->wait();
|
|
return result;
|
|
}
|
|
sk_sp<SkPicture> inputPicture(recorder.finishRecordingAsPicture());
|
|
|
|
// this is our ultimate final drawing area/rect
|
|
SkIRect viewport = SkIRect::MakeWH(size.fWidth, size.fHeight);
|
|
|
|
DDLPromiseImageHelper promiseImageHelper;
|
|
sk_sp<SkData> compressedPictureData = promiseImageHelper.deflateSKP(inputPicture.get());
|
|
if (!compressedPictureData) {
|
|
gpuTaskGroup->add([gpuTestCtx] { gpuTestCtx->makeNotCurrent(); });
|
|
gpuTaskGroup->wait();
|
|
return Result::Fatal("GPUDDLSink: Couldn't deflate SkPicture");
|
|
}
|
|
|
|
promiseImageHelper.createCallbackContexts(gpuThreadCtx);
|
|
|
|
// TODO: move the image upload to the utility thread
|
|
promiseImageHelper.uploadAllToGPU(gpuTaskGroup, gpuThreadCtx);
|
|
|
|
constexpr int kNumDivisions = 3;
|
|
DDLTileHelper tiles(dstSurface, dstCharacterization, viewport, kNumDivisions);
|
|
|
|
tiles.createBackendTextures(gpuTaskGroup, gpuThreadCtx);
|
|
|
|
// Reinflate the compressed picture individually for each thread.
|
|
tiles.createSKPPerTile(compressedPictureData.get(), promiseImageHelper);
|
|
|
|
tiles.kickOffThreadedWork(recordingTaskGroup, gpuTaskGroup, gpuThreadCtx);
|
|
// Apparently adding to a taskGroup isn't thread safe. Wait for the recording task group
|
|
// to add all its gpuThread work before adding the flush
|
|
recordingTaskGroup->wait();
|
|
|
|
// This should be the only explicit flush for the entire DDL draw
|
|
gpuTaskGroup->add([gpuThreadCtx]() {
|
|
// We need to ensure all the GPU work is finished so
|
|
// the following 'deleteAllFromGPU' call will work
|
|
// on Vulkan.
|
|
// TODO: switch over to using the promiseImage callbacks
|
|
// to free the backendTextures. This is complicated a
|
|
// bit by which thread possesses the direct context.
|
|
GrFlushInfo flushInfoSyncCpu;
|
|
flushInfoSyncCpu.fFlags = kSyncCpu_GrFlushFlag;
|
|
gpuThreadCtx->flush(flushInfoSyncCpu);
|
|
});
|
|
|
|
// The backend textures are created on the gpuThread by the 'uploadAllToGPU' call.
|
|
// It is simpler to also delete them at this point on the gpuThread.
|
|
promiseImageHelper.deleteAllFromGPU(gpuTaskGroup, gpuThreadCtx);
|
|
|
|
tiles.deleteBackendTextures(gpuTaskGroup, gpuThreadCtx);
|
|
|
|
// A flush has already been scheduled on the gpu thread along with the clean up of the backend
|
|
// textures so it is safe to schedule making 'gpuTestCtx' not current on the gpuThread.
|
|
gpuTaskGroup->add([gpuTestCtx] { gpuTestCtx->makeNotCurrent(); });
|
|
|
|
// All the work is scheduled on the gpu thread, we just need to wait
|
|
gpuTaskGroup->wait();
|
|
|
|
return Result::Ok();
|
|
}
|
|
|
|
Result GPUDDLSink::draw(const Src& src, SkBitmap* dst, SkWStream* stream, SkString* log) const {
|
|
GrContextOptions contextOptions = this->baseContextOptions();
|
|
src.modifyGrContextOptions(&contextOptions);
|
|
contextOptions.fPersistentCache = nullptr;
|
|
contextOptions.fExecutor = nullptr;
|
|
|
|
GrContextFactory factory(contextOptions);
|
|
|
|
// This captures the context destined to be the main gpu context
|
|
ContextInfo mainCtxInfo = factory.getContextInfo(this->contextType(), this->contextOverrides());
|
|
sk_gpu_test::TestContext* mainTestCtx = mainCtxInfo.testContext();
|
|
GrContext* mainCtx = mainCtxInfo.grContext();
|
|
if (!mainCtx) {
|
|
return Result::Fatal("Could not create context.");
|
|
}
|
|
|
|
SkASSERT(mainCtx->priv().getGpu());
|
|
|
|
// TODO: make use of 'otherCtx' for uploads & compilation
|
|
#if 0
|
|
// This captures the context destined to be the utility context. It is in a share group
|
|
// with the main context
|
|
ContextInfo otherCtxInfo = factory.getSharedContextInfo(mainCtx);
|
|
sk_gpu_test::TestContext* otherTestCtx = otherCtxInfo.testContext();
|
|
GrContext* otherCtx = otherCtxInfo.grContext();
|
|
if (!otherCtx) {
|
|
return Result::Fatal("Cound not create shared context.");
|
|
}
|
|
|
|
SkASSERT(otherCtx->priv().getGpu());
|
|
#endif
|
|
|
|
SkTaskGroup recordingTaskGroup(*fRecordingThreadPool);
|
|
SkTaskGroup gpuTaskGroup(*fGPUThread);
|
|
|
|
// Make sure 'mainCtx' is current
|
|
mainTestCtx->makeCurrent();
|
|
|
|
GrBackendTexture backendTexture;
|
|
GrBackendRenderTarget backendRT;
|
|
sk_sp<SkSurface> surface = this->createDstSurface(mainCtx, src.size(),
|
|
&backendTexture, &backendRT);
|
|
if (!surface) {
|
|
return Result::Fatal("Could not create a surface.");
|
|
}
|
|
|
|
Result result = this->ddlDraw(src, surface, &recordingTaskGroup, &gpuTaskGroup,
|
|
mainTestCtx, mainCtx);
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
|
|
// 'ddlDraw' will have made 'mainCtx' not current on the gpuThread
|
|
mainTestCtx->makeCurrent();
|
|
|
|
if (FLAGS_gpuStats) {
|
|
mainCtx->priv().dumpCacheStats(log);
|
|
mainCtx->priv().dumpGpuStats(log);
|
|
|
|
#if 0
|
|
otherCtx->priv().dumpCacheStats(log);
|
|
otherCtx->priv().dumpGpuStats(log);
|
|
#endif
|
|
}
|
|
|
|
if (!this->readBack(surface.get(), dst)) {
|
|
return Result::Fatal("Could not readback from surface.");
|
|
}
|
|
|
|
surface.reset();
|
|
if (backendTexture.isValid()) {
|
|
mainCtx->deleteBackendTexture(backendTexture);
|
|
}
|
|
if (backendRT.isValid()) {
|
|
mainCtx->priv().getGpu()->deleteTestingOnlyBackendRenderTarget(backendRT);
|
|
}
|
|
|
|
return Result::Ok();
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
static Result draw_skdocument(const Src& src, SkDocument* doc, SkWStream* dst) {
|
|
if (src.size().isEmpty()) {
|
|
return Result::Fatal("Source has empty dimensions");
|
|
}
|
|
SkASSERT(doc);
|
|
int pageCount = src.pageCount();
|
|
for (int i = 0; i < pageCount; ++i) {
|
|
int width = src.size(i).width(), height = src.size(i).height();
|
|
SkCanvas* canvas =
|
|
doc->beginPage(SkIntToScalar(width), SkIntToScalar(height));
|
|
if (!canvas) {
|
|
return Result::Fatal("SkDocument::beginPage(w,h) returned nullptr");
|
|
}
|
|
Result result = src.draw(i, canvas);
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
doc->endPage();
|
|
}
|
|
doc->close();
|
|
dst->flush();
|
|
return Result::Ok();
|
|
}
|
|
|
|
Result PDFSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
|
|
SkPDF::Metadata metadata;
|
|
metadata.fTitle = src.name();
|
|
metadata.fSubject = "rendering correctness test";
|
|
metadata.fCreator = "Skia/DM";
|
|
metadata.fRasterDPI = fRasterDpi;
|
|
metadata.fPDFA = fPDFA;
|
|
#if SK_PDF_TEST_EXECUTOR
|
|
std::unique_ptr<SkExecutor> executor = SkExecutor::MakeFIFOThreadPool();
|
|
metadata.fExecutor = executor.get();
|
|
#endif
|
|
auto doc = SkPDF::MakeDocument(dst, metadata);
|
|
if (!doc) {
|
|
return Result::Fatal("SkPDF::MakeDocument() returned nullptr");
|
|
}
|
|
return draw_skdocument(src, doc.get(), dst);
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
XPSSink::XPSSink() {}
|
|
|
|
#if defined(SK_SUPPORT_XPS)
|
|
static SkTScopedComPtr<IXpsOMObjectFactory> make_xps_factory() {
|
|
IXpsOMObjectFactory* factory;
|
|
HRN(CoCreateInstance(CLSID_XpsOMObjectFactory,
|
|
nullptr,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_PPV_ARGS(&factory)));
|
|
return SkTScopedComPtr<IXpsOMObjectFactory>(factory);
|
|
}
|
|
|
|
Result XPSSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
|
|
SkAutoCoInitialize com;
|
|
if (!com.succeeded()) {
|
|
return Result::Fatal("Could not initialize COM.");
|
|
}
|
|
SkTScopedComPtr<IXpsOMObjectFactory> factory = make_xps_factory();
|
|
if (!factory) {
|
|
return Result::Fatal("Failed to create XPS Factory.");
|
|
}
|
|
auto doc = SkXPS::MakeDocument(dst, factory.get());
|
|
if (!doc) {
|
|
return Result::Fatal("SkXPS::MakeDocument() returned nullptr");
|
|
}
|
|
return draw_skdocument(src, doc.get(), dst);
|
|
}
|
|
#else
|
|
Result XPSSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
|
|
return Result::Fatal("XPS not supported on this platform.");
|
|
}
|
|
#endif
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
SKPSink::SKPSink() {}
|
|
|
|
Result SKPSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
|
|
auto size = SkSize::Make(src.size());
|
|
SkPictureRecorder recorder;
|
|
Result result = src.draw(recorder.beginRecording(size.width(), size.height()));
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
recorder.finishRecordingAsPicture()->serialize(dst);
|
|
return Result::Ok();
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
Result DebugSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
|
|
DebugCanvas debugCanvas(src.size().width(), src.size().height());
|
|
Result result = src.draw(&debugCanvas);
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
std::unique_ptr<SkCanvas> nullCanvas = SkMakeNullCanvas();
|
|
UrlDataManager dataManager(SkString("data"));
|
|
SkJSONWriter writer(dst, SkJSONWriter::Mode::kPretty);
|
|
writer.beginObject(); // root
|
|
debugCanvas.toJSON(writer, dataManager, nullCanvas.get());
|
|
writer.endObject(); // root
|
|
writer.flush();
|
|
return Result::Ok();
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
SVGSink::SVGSink(int pageIndex) : fPageIndex(pageIndex) {}
|
|
|
|
Result SVGSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
|
|
#if defined(SK_XML)
|
|
if (src.pageCount() > 1) {
|
|
int pageCount = src.pageCount();
|
|
if (fPageIndex > pageCount - 1) {
|
|
return Result::Fatal("Page index %d too high for document with only %d pages.",
|
|
fPageIndex, pageCount);
|
|
}
|
|
}
|
|
return src.draw(fPageIndex,
|
|
SkSVGCanvas::Make(SkRect::MakeWH(SkIntToScalar(src.size().width()),
|
|
SkIntToScalar(src.size().height())),
|
|
dst)
|
|
.get());
|
|
#else
|
|
(void)fPageIndex;
|
|
return Result::Fatal("SVG sink is disabled.");
|
|
#endif // SK_XML
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
RasterSink::RasterSink(SkColorType colorType, sk_sp<SkColorSpace> colorSpace)
|
|
: fColorType(colorType)
|
|
, fColorSpace(std::move(colorSpace)) {}
|
|
|
|
Result RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString*) const {
|
|
const SkISize size = src.size();
|
|
// If there's an appropriate alpha type for this color type, use it, otherwise use premul.
|
|
SkAlphaType alphaType = kPremul_SkAlphaType;
|
|
(void)SkColorTypeValidateAlphaType(fColorType, alphaType, &alphaType);
|
|
|
|
dst->allocPixelsFlags(SkImageInfo::Make(size, fColorType, alphaType, fColorSpace),
|
|
SkBitmap::kZeroPixels_AllocFlag);
|
|
|
|
SkCanvas canvas(*dst);
|
|
return src.draw(&canvas);
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
// Handy for front-patching a Src. Do whatever up-front work you need, then call draw_to_canvas(),
|
|
// passing the Sink draw() arguments, a size, and a function draws into an SkCanvas.
|
|
// Several examples below.
|
|
|
|
template <typename Fn>
|
|
static Result draw_to_canvas(Sink* sink, SkBitmap* bitmap, SkWStream* stream, SkString* log,
|
|
SkISize size, const Fn& draw) {
|
|
class ProxySrc : public Src {
|
|
public:
|
|
ProxySrc(SkISize size, const Fn& draw) : fSize(size), fDraw(draw) {}
|
|
Result draw(SkCanvas* canvas) const override { return fDraw(canvas); }
|
|
Name name() const override { return "ProxySrc"; }
|
|
SkISize size() const override { return fSize; }
|
|
private:
|
|
SkISize fSize;
|
|
const Fn& fDraw;
|
|
};
|
|
return sink->draw(ProxySrc(size, draw), bitmap, stream, log);
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
static DEFINE_bool(check, true, "If true, have most Via- modes fail if they affect the output.");
|
|
|
|
// Is *bitmap identical to what you get drawing src into sink?
|
|
static Result check_against_reference(const SkBitmap* bitmap, const Src& src, Sink* sink) {
|
|
// We can only check raster outputs.
|
|
// (Non-raster outputs like .pdf, .skp, .svg may differ but still draw identically.)
|
|
if (FLAGS_check && bitmap) {
|
|
SkBitmap reference;
|
|
SkString log;
|
|
SkDynamicMemoryWStream wStream;
|
|
Result result = sink->draw(src, &reference, &wStream, &log);
|
|
// If we can draw into this Sink via some pipeline, we should be able to draw directly.
|
|
SkASSERT(result.isOk());
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
return compare_bitmaps(reference, *bitmap);
|
|
}
|
|
return Result::Ok();
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
static SkISize auto_compute_translate(SkMatrix* matrix, int srcW, int srcH) {
|
|
SkRect bounds = SkRect::MakeIWH(srcW, srcH);
|
|
matrix->mapRect(&bounds);
|
|
matrix->postTranslate(-bounds.x(), -bounds.y());
|
|
return {SkScalarRoundToInt(bounds.width()), SkScalarRoundToInt(bounds.height())};
|
|
}
|
|
|
|
ViaMatrix::ViaMatrix(SkMatrix matrix, Sink* sink) : Via(sink), fMatrix(matrix) {}
|
|
|
|
Result ViaMatrix::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
|
|
SkMatrix matrix = fMatrix;
|
|
SkISize size = auto_compute_translate(&matrix, src.size().width(), src.size().height());
|
|
return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) {
|
|
canvas->concat(matrix);
|
|
return src.draw(canvas);
|
|
});
|
|
}
|
|
|
|
// Undoes any flip or 90 degree rotate without changing the scale of the bitmap.
|
|
// This should be pixel-preserving.
|
|
ViaUpright::ViaUpright(SkMatrix matrix, Sink* sink) : Via(sink), fMatrix(matrix) {}
|
|
|
|
Result ViaUpright::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
|
|
Result result = fSink->draw(src, bitmap, stream, log);
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
|
|
SkMatrix inverse;
|
|
if (!fMatrix.rectStaysRect() || !fMatrix.invert(&inverse)) {
|
|
return Result::Fatal("Cannot upright --matrix.");
|
|
}
|
|
SkMatrix upright = SkMatrix::I();
|
|
upright.setScaleX(SkScalarSignAsScalar(inverse.getScaleX()));
|
|
upright.setScaleY(SkScalarSignAsScalar(inverse.getScaleY()));
|
|
upright.setSkewX(SkScalarSignAsScalar(inverse.getSkewX()));
|
|
upright.setSkewY(SkScalarSignAsScalar(inverse.getSkewY()));
|
|
|
|
SkBitmap uprighted;
|
|
SkISize size = auto_compute_translate(&upright, bitmap->width(), bitmap->height());
|
|
uprighted.allocPixels(bitmap->info().makeDimensions(size));
|
|
|
|
SkCanvas canvas(uprighted);
|
|
canvas.concat(upright);
|
|
SkPaint paint;
|
|
paint.setBlendMode(SkBlendMode::kSrc);
|
|
canvas.drawBitmap(*bitmap, 0, 0, &paint);
|
|
|
|
*bitmap = uprighted;
|
|
return Result::Ok();
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
Result ViaSerialization::draw(
|
|
const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
|
|
// Record our Src into a picture.
|
|
auto size = src.size();
|
|
SkPictureRecorder recorder;
|
|
Result result = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
|
|
SkIntToScalar(size.height())));
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
sk_sp<SkPicture> pic(recorder.finishRecordingAsPicture());
|
|
|
|
// Serialize it and then deserialize it.
|
|
sk_sp<SkPicture> deserialized(SkPicture::MakeFromData(pic->serialize().get()));
|
|
|
|
result = draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) {
|
|
canvas->drawPicture(deserialized);
|
|
return Result::Ok();
|
|
});
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
|
|
return check_against_reference(bitmap, src, fSink.get());
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
ViaDDL::ViaDDL(int numReplays, int numDivisions, Sink* sink)
|
|
: Via(sink), fNumReplays(numReplays), fNumDivisions(numDivisions) {}
|
|
|
|
Result ViaDDL::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
|
|
auto size = src.size();
|
|
SkPictureRecorder recorder;
|
|
Result result = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
|
|
SkIntToScalar(size.height())));
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
sk_sp<SkPicture> inputPicture(recorder.finishRecordingAsPicture());
|
|
|
|
// this is our ultimate final drawing area/rect
|
|
SkIRect viewport = SkIRect::MakeWH(size.fWidth, size.fHeight);
|
|
|
|
DDLPromiseImageHelper promiseImageHelper;
|
|
sk_sp<SkData> compressedPictureData = promiseImageHelper.deflateSKP(inputPicture.get());
|
|
if (!compressedPictureData) {
|
|
return Result::Fatal("ViaDDL: Couldn't deflate SkPicture");
|
|
}
|
|
auto draw = [&](SkCanvas* canvas) -> Result {
|
|
GrContext* context = canvas->getGrContext();
|
|
if (!context || !context->priv().getGpu()) {
|
|
return Result::Fatal("ViaDDL: DDLs are GPU only");
|
|
}
|
|
SkSurface* tmp = canvas->getSurface();
|
|
if (!tmp) {
|
|
return Result::Fatal("ViaDDL: cannot get surface from canvas");
|
|
}
|
|
sk_sp<SkSurface> dstSurface = sk_ref_sp(tmp);
|
|
|
|
SkSurfaceCharacterization dstCharacterization;
|
|
SkAssertResult(dstSurface->characterize(&dstCharacterization));
|
|
|
|
promiseImageHelper.createCallbackContexts(context);
|
|
|
|
// This is here bc this is the first point where we have access to the context
|
|
promiseImageHelper.uploadAllToGPU(nullptr, context);
|
|
// We draw N times, with a clear between.
|
|
for (int replay = 0; replay < fNumReplays; ++replay) {
|
|
if (replay > 0) {
|
|
// Clear the drawing of the previous replay
|
|
canvas->clear(SK_ColorTRANSPARENT);
|
|
}
|
|
// First, create all the tiles (including their individual dest surfaces)
|
|
DDLTileHelper tiles(dstSurface, dstCharacterization, viewport, fNumDivisions);
|
|
|
|
tiles.createBackendTextures(nullptr, context);
|
|
|
|
// Second, reinflate the compressed picture individually for each thread
|
|
// This recreates the promise SkImages on each replay iteration. We are currently
|
|
// relying on this to test using a SkPromiseImageTexture to fulfill different
|
|
// SkImages. On each replay the promise SkImages are recreated in createSKPPerTile.
|
|
tiles.createSKPPerTile(compressedPictureData.get(), promiseImageHelper);
|
|
|
|
// Third, create the DDLs in parallel
|
|
tiles.createDDLsInParallel();
|
|
|
|
if (replay == fNumReplays - 1) {
|
|
// This drops the promiseImageHelper's refs on all the promise images if we're in
|
|
// the last run.
|
|
promiseImageHelper.reset();
|
|
}
|
|
|
|
// Fourth, synchronously render the display lists into the dest tiles
|
|
// TODO: it would be cool to not wait until all the tiles are drawn to begin
|
|
// drawing to the GPU and composing to the final surface
|
|
tiles.precompileAndDrawAllTiles(context);
|
|
|
|
// Finally, compose the drawn tiles into the result
|
|
// Note: the separation between the tiles and the final composition better
|
|
// matches Chrome but costs us a copy
|
|
tiles.composeAllTiles(context);
|
|
|
|
// We need to ensure all the GPU work is finished so the following
|
|
// 'deleteBackendTextures' call will work on Vulkan.
|
|
GrFlushInfo flushInfoSyncCpu;
|
|
flushInfoSyncCpu.fFlags = kSyncCpu_GrFlushFlag;
|
|
context->flush(flushInfoSyncCpu);
|
|
|
|
tiles.deleteBackendTextures(nullptr, context);
|
|
}
|
|
return Result::Ok();
|
|
};
|
|
return draw_to_canvas(fSink.get(), bitmap, stream, log, size, draw);
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
Result ViaPicture::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
|
|
auto size = src.size();
|
|
Result result = draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) {
|
|
SkPictureRecorder recorder;
|
|
sk_sp<SkPicture> pic;
|
|
Result result = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
|
|
SkIntToScalar(size.height())));
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
pic = recorder.finishRecordingAsPicture();
|
|
canvas->drawPicture(pic);
|
|
return result;
|
|
});
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
|
|
return check_against_reference(bitmap, src, fSink.get());
|
|
}
|
|
|
|
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
#ifdef TEST_VIA_SVG
|
|
#include "experimental/svg/model/SkSVGDOM.h"
|
|
#include "include/svg/SkSVGCanvas.h"
|
|
#include "src/xml/SkXMLWriter.h"
|
|
|
|
Result ViaSVG::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
|
|
auto size = src.size();
|
|
return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) -> Result {
|
|
SkDynamicMemoryWStream wstream;
|
|
SkXMLStreamWriter writer(&wstream);
|
|
Result result = src.draw(SkSVGCanvas::Make(SkRect::Make(size), &writer).get());
|
|
if (!result.isOk()) {
|
|
return result;
|
|
}
|
|
std::unique_ptr<SkStream> rstream(wstream.detachAsStream());
|
|
auto dom = SkSVGDOM::MakeFromStream(*rstream);
|
|
if (dom) {
|
|
dom->setContainerSize(SkSize::Make(size));
|
|
dom->render(canvas);
|
|
}
|
|
return Result::Ok();
|
|
});
|
|
}
|
|
#endif
|
|
|
|
} // namespace DM
|