blob: 8e3924ef602a53c3bb9a5455f410b2b8da9bb6d4 [file] [log] [blame]
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef DMSrcSink_DEFINED
#define DMSrcSink_DEFINED
#include "gm/gm.h"
#include "include/core/SkBBHFactory.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkData.h"
#include "include/core/SkPicture.h"
#include "include/docs/SkMultiPictureDocument.h"
#include "include/gpu/graphite/ContextOptions.h"
#include "tools/flags/CommonFlagsConfig.h"
#include "tools/gpu/MemoryCache.h"
#include "tools/graphite/TestOptions.h"
#include <functional>
//#define TEST_VIA_SVG
namespace skiagm::verifiers {
class VerifierList;
}
namespace DM {
// This is just convenience. It lets you use either return "foo" or return SkStringPrintf(...).
struct ImplicitString : public SkString {
template <typename T>
ImplicitString(const T& s) : SkString(s) {}
ImplicitString() : SkString("") {}
};
typedef ImplicitString Name;
typedef ImplicitString Path;
class Result {
public:
enum class Status : int { Ok, Fatal, Skip };
Result(Status status, SkString msg) : fMsg(std::move(msg)), fStatus(status) {}
Result(const Result&) = default;
Result& operator=(const Result&) = default;
static Result Ok() { return Result{Status::Ok, {}}; }
static Result Fatal(const char* fmt, ...) SK_PRINTF_LIKE(1, 2) {
SkString msg;
va_list args;
va_start(args, fmt);
msg.printVAList(fmt, args);
va_end(args);
return Result{Status::Fatal, std::move(msg)};
}
static Result Skip(const char* fmt, ...) SK_PRINTF_LIKE(1, 2) {
SkString msg;
va_list args;
va_start(args, fmt);
msg.printVAList(fmt, args);
va_end(args);
return Result{Status::Skip, std::move(msg)};
}
bool isOk() { return fStatus == Status::Ok; }
bool isFatal() { return fStatus == Status::Fatal; }
bool isSkip() { return fStatus == Status::Skip; }
const char* c_str() const { return fMsg.c_str(); }
Status status() const { return fStatus; }
private:
SkString fMsg;
Status fStatus;
};
struct SinkFlags {
enum Type { kNull, kGPU, kVector, kRaster } type;
enum Approach { kDirect, kIndirect } approach;
enum Multisampled { kNotMultisampled, kMultisampled } multisampled;
SinkFlags(Type t, Approach a, Multisampled ms = kNotMultisampled)
: type(t), approach(a), multisampled(ms) {}
};
struct Src {
using GraphiteTestContext = skiatest::graphite::GraphiteTestContext;
virtual ~Src() {}
[[nodiscard]] virtual Result draw(SkCanvas* canvas, GraphiteTestContext*) const = 0;
virtual SkISize size() const = 0;
virtual Name name() const = 0;
virtual void modifyGrContextOptions(GrContextOptions*) const {}
virtual void modifyGraphiteContextOptions(skgpu::graphite::ContextOptions*) const {}
virtual bool veto(SinkFlags) const { return false; }
virtual int pageCount() const { return 1; }
[[nodiscard]] virtual Result draw([[maybe_unused]] int page,
SkCanvas* canvas,
GraphiteTestContext* graphiteTestContext) const {
return this->draw(canvas, graphiteTestContext);
}
virtual SkISize size([[maybe_unused]] int page) const { return this->size(); }
// Force Tasks using this Src to run on the main thread?
virtual bool serial() const { return false; }
};
struct Sink {
virtual ~Sink() {}
// You may write to either the bitmap or stream. If you write to log, we'll print that out.
[[nodiscard]] virtual Result draw(const Src&, SkBitmap*, SkWStream*, SkString* log) const = 0;
// Override the color space of this Sink, after creation
virtual void setColorSpace(sk_sp<SkColorSpace>) {}
// Force Tasks using this Sink to run on the main thread?
virtual bool serial() const { return false; }
// File extension for the content draw() outputs, e.g. "png", "pdf".
virtual const char* fileExtension() const = 0;
virtual SinkFlags flags() const = 0;
/** Returns the color type and space used by the sink. */
virtual SkColorInfo colorInfo() const { return SkColorInfo(); }
};
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
class GMSrc : public Src {
public:
explicit GMSrc(skiagm::GMFactory);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
Name name() const override;
void modifyGrContextOptions(GrContextOptions* options) const override;
#if defined(SK_GRAPHITE)
void modifyGraphiteContextOptions(skgpu::graphite::ContextOptions*) const override;
#endif
private:
skiagm::GMFactory fFactory;
};
class CodecSrc : public Src {
public:
enum Mode {
kCodec_Mode,
// We choose to test only one mode with zero initialized memory.
// This will exercise all of the interesting cases in SkSwizzler
// without doubling the size of our test suite.
kCodecZeroInit_Mode,
kScanline_Mode,
kStripe_Mode, // Tests the skipping of scanlines
kCroppedScanline_Mode, // Tests (jpeg) cropped scanline optimization
kSubset_Mode, // For codecs that support subsets directly.
kAnimated_Mode, // For codecs that support animation.
};
enum DstColorType {
kGetFromCanvas_DstColorType,
kGrayscale_Always_DstColorType,
kNonNative8888_Always_DstColorType,
};
CodecSrc(Path, Mode, DstColorType, SkAlphaType, float);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
Name name() const override;
bool veto(SinkFlags) const override;
bool serial() const override { return fRunSerially; }
private:
Path fPath;
Mode fMode;
DstColorType fDstColorType;
SkAlphaType fDstAlphaType;
float fScale;
bool fRunSerially;
};
class AndroidCodecSrc : public Src {
public:
AndroidCodecSrc(Path, CodecSrc::DstColorType, SkAlphaType, int sampleSize);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
Name name() const override;
bool veto(SinkFlags) const override;
bool serial() const override { return fRunSerially; }
private:
Path fPath;
CodecSrc::DstColorType fDstColorType;
SkAlphaType fDstAlphaType;
int fSampleSize;
bool fRunSerially;
};
#ifdef SK_ENABLE_ANDROID_UTILS
// Allows for testing of various implementations of Android's BitmapRegionDecoder
class BRDSrc : public Src {
public:
enum Mode {
// Decode the entire image as one region.
kFullImage_Mode,
// Splits the image into multiple regions using a divisor and decodes the regions
// separately. Also, this test adds a border of a few pixels to each of the regions
// that it is decoding. This tests the behavior when a client asks for a region that
// does not fully fit in the image.
kDivisor_Mode,
};
BRDSrc(Path, Mode, CodecSrc::DstColorType, uint32_t);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
Name name() const override;
bool veto(SinkFlags) const override;
private:
Path fPath;
Mode fMode;
CodecSrc::DstColorType fDstColorType;
uint32_t fSampleSize;
};
#endif
class ImageGenSrc : public Src {
public:
enum Mode {
kCodec_Mode, // Use CodecImageGenerator
kPlatform_Mode, // Uses CG or WIC
};
ImageGenSrc(Path, Mode, SkAlphaType, bool);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
Name name() const override;
bool veto(SinkFlags) const override;
bool serial() const override { return fRunSerially; }
private:
Path fPath;
Mode fMode;
SkAlphaType fDstAlphaType;
bool fIsGpu;
bool fRunSerially;
};
class ColorCodecSrc : public Src {
public:
ColorCodecSrc(Path, bool decode_to_dst);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
Name name() const override;
bool veto(SinkFlags) const override;
private:
Path fPath;
bool fDecodeToDst;
};
class SKPSrc : public Src {
public:
explicit SKPSrc(Path path);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
Name name() const override;
private:
Path fPath;
};
// This class extracts all the paths from an SKP and then removes unwanted paths according to the
// provided l/r trail. It then just draws the remaining paths. (Non-path draws are thrown out.) It
// is useful for finding a reduced repo case for path drawing bugs.
class BisectSrc : public SKPSrc {
public:
explicit BisectSrc(Path path, const char* trail);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
private:
SkString fTrail;
using INHERITED = SKPSrc;
};
#if defined(SK_ENABLE_SKOTTIE)
class SkottieSrc final : public Src {
public:
explicit SkottieSrc(Path path);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
Name name() const override;
bool veto(SinkFlags) const override;
private:
// Generates a kTileCount x kTileCount filmstrip with evenly distributed frames.
inline static constexpr int kTileCount = 5;
// Fit kTileCount x kTileCount frames to a 1000x1000 film strip.
inline static constexpr SkScalar kTargetSize = 1000;
inline static constexpr SkScalar kTileSize = kTargetSize / kTileCount;
Path fPath;
};
#endif
#if defined(SK_ENABLE_SVG)
} // namespace DM
class SkSVGDOM;
namespace DM {
class SVGSrc : public Src {
public:
explicit SVGSrc(Path path);
Result draw(SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
Name name() const override;
bool veto(SinkFlags) const override;
private:
Name fName;
sk_sp<SkSVGDOM> fDom;
SkScalar fScale;
using INHERITED = Src;
};
#endif // SK_ENABLE_SVG
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
class MSKPSrc : public Src {
public:
explicit MSKPSrc(Path path);
int pageCount() const override;
Result draw(SkCanvas* c, GraphiteTestContext*) const override;
Result draw(int, SkCanvas*, GraphiteTestContext*) const override;
SkISize size() const override;
SkISize size(int) const override;
Name name() const override;
private:
Path fPath;
mutable skia_private::TArray<SkDocumentPage> fPages;
};
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
class NullSink : public Sink {
public:
NullSink() {}
Result draw(const Src& src, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override { return ""; }
SinkFlags flags() const override { return SinkFlags{ SinkFlags::kNull, SinkFlags::kDirect }; }
};
class GPUSink : public Sink {
public:
GPUSink(const SkCommandLineConfigGpu*, const GrContextOptions&);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
Result onDraw(const Src&, SkBitmap*, SkWStream*, SkString*,
const GrContextOptions& baseOptions,
std::function<void(GrDirectContext*)> initContext = nullptr,
std::function<SkCanvas*(SkCanvas*)> wrapCanvas = nullptr) const;
skgpu::ContextType contextType() const { return fContextType; }
const sk_gpu_test::GrContextFactory::ContextOverrides& contextOverrides() const {
return fContextOverrides;
}
SkCommandLineConfigGpu::SurfType surfType() const { return fSurfType; }
bool serial() const override { return true; }
const char* fileExtension() const override { return "png"; }
SinkFlags flags() const override {
SinkFlags::Multisampled ms = fSampleCount > 1 ? SinkFlags::kMultisampled
: SinkFlags::kNotMultisampled;
return SinkFlags{ SinkFlags::kGPU, SinkFlags::kDirect, ms };
}
const GrContextOptions& baseContextOptions() const { return fBaseContextOptions; }
void setColorSpace(sk_sp<SkColorSpace> colorSpace) override { fColorSpace = colorSpace; }
SkColorInfo colorInfo() const override {
return SkColorInfo(fColorType, fAlphaType, fColorSpace);
}
protected:
sk_sp<SkSurface> createDstSurface(GrDirectContext*, SkISize size) const;
bool readBack(SkSurface*, SkBitmap* dst) const;
private:
skgpu::ContextType fContextType;
sk_gpu_test::GrContextFactory::ContextOverrides fContextOverrides;
SkCommandLineConfigGpu::SurfType fSurfType;
int fSampleCount;
uint32_t fSurfaceFlags;
SkColorType fColorType;
SkAlphaType fAlphaType;
sk_sp<SkColorSpace> fColorSpace;
GrContextOptions fBaseContextOptions;
sk_gpu_test::MemoryCache fMemoryCache;
};
// Wrap a gpu canvas in one that routes all text draws through Slugs.
// Note that text blobs that have an RSXForm aren't converted.
class GPUSlugSink : public GPUSink {
public:
GPUSlugSink(const SkCommandLineConfigGpu*, const GrContextOptions&);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
};
class GPUSerializeSlugSink : public GPUSink {
public:
GPUSerializeSlugSink(const SkCommandLineConfigGpu*, const GrContextOptions&);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
};
class GPURemoteSlugSink : public GPUSink {
public:
GPURemoteSlugSink(const SkCommandLineConfigGpu*, const GrContextOptions&);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
};
class GPUPersistentCacheTestingSink : public GPUSink {
public:
GPUPersistentCacheTestingSink(const SkCommandLineConfigGpu*, const GrContextOptions&);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override {
// Suppress writing out results from this config - we just want to do our matching test
return nullptr;
}
private:
int fCacheType;
using INHERITED = GPUSink;
};
class GPUPrecompileTestingSink : public GPUSink {
public:
GPUPrecompileTestingSink(const SkCommandLineConfigGpu*, const GrContextOptions&);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override {
// Suppress writing out results from this config - we just want to do our matching test
return nullptr;
}
private:
using INHERITED = GPUSink;
};
// This sink attempts to better simulate the Chrome DDL use-case. It:
// creates the DDLs on separate recording threads
// performs all the GPU work on a separate GPU thread
// In the future this should be expanded to:
// upload on a utility thread w/ access to a shared context
// compile the programs on the utility thread
// perform fine grained scheduling of gpu tasks based on their image and program prerequisites
// create a single "compositing" DDL that is replayed last
class GPUDDLSink : public GPUSink {
public:
GPUDDLSink(const SkCommandLineConfigGpu*, const GrContextOptions&);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
private:
Result ddlDraw(const Src&,
sk_sp<SkSurface> dstSurface,
SkTaskGroup* recordingTaskGroup,
SkTaskGroup* gpuTaskGroup,
sk_gpu_test::TestContext* gpuTestCtx,
GrDirectContext* gpuThreadCtx) const;
std::unique_ptr<SkExecutor> fRecordingExecutor;
std::unique_ptr<SkExecutor> fGPUExecutor;
using INHERITED = GPUSink;
};
class PDFSink : public Sink {
public:
PDFSink(bool pdfa, SkScalar rasterDpi) : fPDFA(pdfa), fRasterDpi(rasterDpi) {}
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override { return "pdf"; }
SinkFlags flags() const override { return SinkFlags{ SinkFlags::kVector, SinkFlags::kDirect }; }
bool fPDFA;
SkScalar fRasterDpi;
};
class XPSSink : public Sink {
public:
XPSSink();
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override { return "xps"; }
SinkFlags flags() const override { return SinkFlags{ SinkFlags::kVector, SinkFlags::kDirect }; }
};
class RasterSink : public Sink {
public:
explicit RasterSink(SkColorType);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override { return "png"; }
SinkFlags flags() const override { return SinkFlags{ SinkFlags::kRaster, SinkFlags::kDirect }; }
void setColorSpace(sk_sp<SkColorSpace> colorSpace) override { fColorSpace = colorSpace; }
SkColorInfo colorInfo() const override {
// 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);
return SkColorInfo(fColorType, alphaType, fColorSpace);
}
private:
SkColorType fColorType;
sk_sp<SkColorSpace> fColorSpace;
};
class SKPSink : public Sink {
public:
SKPSink();
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override { return "skp"; }
SinkFlags flags() const override { return SinkFlags{ SinkFlags::kVector, SinkFlags::kDirect }; }
};
class DebugSink : public Sink {
public:
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override { return "json"; }
SinkFlags flags() const override { return SinkFlags{ SinkFlags::kVector, SinkFlags::kDirect }; }
};
class SVGSink : public Sink {
public:
SVGSink(int pageIndex = 0);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override { return "svg"; }
SinkFlags flags() const override { return SinkFlags{ SinkFlags::kVector, SinkFlags::kDirect }; }
private:
int fPageIndex;
};
#if defined(SK_GRAPHITE)
class GraphiteSink : public Sink {
public:
GraphiteSink(const SkCommandLineConfigGraphite*, const skiatest::graphite::TestOptions&);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
bool serial() const override { return true; }
const char* fileExtension() const override { return "png"; }
SinkFlags flags() const override { return SinkFlags{SinkFlags::kGPU, SinkFlags::kDirect}; }
void setColorSpace(sk_sp<SkColorSpace> colorSpace) override { fColorSpace = colorSpace; }
SkColorInfo colorInfo() const override {
return SkColorInfo(fColorType, fAlphaType, fColorSpace);
}
protected:
sk_sp<SkSurface> makeSurface(skgpu::graphite::Recorder*, SkISize) const;
skiatest::graphite::TestOptions fOptions;
skgpu::ContextType fContextType;
SkColorType fColorType;
SkAlphaType fAlphaType;
sk_sp<SkColorSpace> fColorSpace;
};
#if defined(SK_ENABLE_PRECOMPILE)
// In general this sink:
// renders a gm, skp or svg (in drawSrc)
// collects all the UniqueKeys |
// clears the pipeline cache | (in resetAndRecreatePipelines)
// recreates the pipelines from the UniqueKeys |
// renders a second time (in drawSrc)
// asserts that no new pipelines were created
class GraphitePrecompileTestingSink : public GraphiteSink {
public:
GraphitePrecompileTestingSink(const SkCommandLineConfigGraphite*,
const skiatest::graphite::TestOptions&);
~GraphitePrecompileTestingSink() override;
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
const char* fileExtension() const override {
// Suppress writing out results from this config - we just want to check that
// the precompilation API is expressive enough and prepopulates the cache.
// If desired, this could be updated to save the result of the precompiled rendering.
// However; if all the keys match, as is expected, the images should always match.
return nullptr;
}
private:
Result drawSrc(const Src&,
skgpu::graphite::Context*,
skiatest::graphite::GraphiteTestContext*) const;
Result resetAndRecreatePipelines(skgpu::graphite::Context*) const;
mutable std::unique_ptr<skgpu::graphite::Recorder> fRecorder;
};
#endif // SK_ENABLE_PRECOMPILE
#endif // SK_GRAPHITE
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
class Via : public Sink {
public:
explicit Via(Sink* sink) : fSink(sink) {}
const char* fileExtension() const override { return fSink->fileExtension(); }
bool serial() const override { return fSink->serial(); }
SinkFlags flags() const override {
SinkFlags flags = fSink->flags();
flags.approach = SinkFlags::kIndirect;
return flags;
}
void setColorSpace(sk_sp<SkColorSpace> colorSpace) override {
fSink->setColorSpace(colorSpace);
}
protected:
std::unique_ptr<Sink> fSink;
};
class ViaMatrix : public Via {
public:
ViaMatrix(SkMatrix, Sink*);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
private:
const SkMatrix fMatrix;
};
class ViaUpright : public Via {
public:
ViaUpright(SkMatrix, Sink*);
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
private:
const SkMatrix fMatrix;
};
class ViaSerialization : public Via {
public:
explicit ViaSerialization(Sink* sink) : Via(sink) {}
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
};
class ViaPicture : public Via {
public:
explicit ViaPicture(Sink* sink) : Via(sink) {}
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
};
class ViaRuntimeBlend : public Via {
public:
explicit ViaRuntimeBlend(Sink* sink) : Via(sink) {}
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
};
class ViaSVG : public Via {
public:
explicit ViaSVG(Sink* sink) : Via(sink) {}
Result draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
};
} // namespace DM
#endif//DMSrcSink_DEFINED