76#if defined(SK_BUILD_FOR_WIN)
82#include <XpsObjectModel.h>
85#if defined(SK_ENABLE_SKOTTIE)
90#if defined(SK_ENABLE_SVG)
97#if defined(SK_GRAPHITE)
109#if defined(SK_ENABLE_PRECOMPILE)
124#if defined(SK_ENABLE_ANDROID_UTILS)
134static DEFINE_bool(RAW_threading,
true,
"Allow RAW decodes to run on multiple threads?");
147 std::unique_ptr<skiagm::GM> gm(fFactory());
148 if (gm->isBazelOnly()) {
156 switch (gpuSetupResult) {
164 switch (drawResult) {
176 std::unique_ptr<skiagm::GM> gm(fFactory());
177 return gm->getISize();
181 std::unique_ptr<skiagm::GM> gm(fFactory());
182 return gm->getName();
186 std::unique_ptr<skiagm::GM> gm(fFactory());
187 gm->modifyGrContextOptions(
options);
190#if defined(SK_GRAPHITE)
192 std::unique_ptr<skiagm::GM> gm(fFactory());
193 gm->modifyGraphiteContextOptions(
options);
203#ifdef SK_ENABLE_ANDROID_UTILS
207 , fDstColorType(dstColorType)
208 , fSampleSize(sampleSize)
211bool BRDSrc::veto(SinkFlags
flags)
const {
213 return flags.type != SinkFlags::kRaster
214 ||
flags.approach != SinkFlags::kDirect;
217static std::unique_ptr<android::skia::BitmapRegionDecoder> create_brd(Path path) {
232Result BRDSrc::draw(
SkCanvas* canvas, GraphiteTestContext*)
const {
235 CodecSrc::kGetFromCanvas_DstColorType != fDstColorType)
237 return Result::Skip(
"Testing non-565 to 565 is uninteresting.");
239 switch (fDstColorType) {
240 case CodecSrc::kGetFromCanvas_DstColorType:
242 case CodecSrc::kGrayscale_Always_DstColorType:
250 auto brd = create_brd(
fPath);
251 if (
nullptr == brd) {
252 return Result::Skip(
"Could not create brd for %s.",
fPath.c_str());
255 auto recommendedCT = brd->computeOutputColorType(
colorType);
257 return Result::Skip(
"Skip decoding non-opaque to 565.");
261 auto colorSpace = brd->computeOutputColorSpace(
colorType,
nullptr);
263 const uint32_t
width = brd->width();
264 const uint32_t
height = brd->height();
266 if ((
width / fSampleSize <= 10 ||
height / fSampleSize <= 10) && 1 != fSampleSize) {
267 return Result::Skip(
"Scaling very small images is uninteresting.");
270 case kFullImage_Mode: {
273 fSampleSize,
colorType,
false, colorSpace)) {
274 return Result::Fatal(
"Cannot decode (full) region.");
281 case kDivisor_Mode: {
282 const uint32_t divisor = 2;
284 return Result::Skip(
"Divisor is larger than image dimension.");
291 const uint32_t maxBorder = std::min(
width,
height) / (fSampleSize * divisor);
292 const uint32_t scaledBorder = std::min(5u, maxBorder);
293 const uint32_t unscaledBorder = scaledBorder * fSampleSize;
308 for (uint32_t
x = 0;
x < divisor;
x++) {
309 for (uint32_t
y = 0;
y < divisor;
y++) {
311 uint32_t subsetWidth =
width / divisor;
312 uint32_t subsetHeight =
height / divisor;
313 const int left =
x * subsetWidth;
314 const int top =
y * subsetHeight;
318 subsetWidth += (
x + 1 == divisor) ? (
width % divisor) : 0;
319 subsetHeight += (
y + 1 == divisor) ? (
height % divisor) : 0;
322 const int decodeLeft =
left - unscaledBorder;
323 const int decodeTop = top - unscaledBorder;
324 const uint32_t decodeWidth = subsetWidth + unscaledBorder * 2;
325 const uint32_t decodeHeight = subsetHeight + unscaledBorder * 2;
328 decodeTop, decodeWidth, decodeHeight), fSampleSize,
colorType,
false,
330 return Result::Fatal(
"Cannot decode region.");
336 (
SkScalar) (subsetWidth / fSampleSize),
337 (
SkScalar) (subsetHeight / fSampleSize)),
340 (
SkScalar) (subsetWidth / fSampleSize),
341 (
SkScalar) (subsetHeight / fSampleSize)),
350 return Result::Fatal(
"Error: Should not be reached.");
355 auto brd = create_brd(
fPath);
357 return {std::max(1, brd->width() / (
int)fSampleSize),
358 std::max(1, brd->height() / (
int)fSampleSize)};
363Name BRDSrc::name()
const {
366 if (1 == fSampleSize) {
377 if (!FLAGS_RAW_threading) {
378 static const char*
const exts[] = {
379 "arw",
"cr2",
"dng",
"nef",
"nrw",
"orf",
"raf",
"rw2",
"pef",
"srw",
380 "ARW",
"CR2",
"DNG",
"NEF",
"NRW",
"ORF",
"RAF",
"RW2",
"PEF",
"SRW",
382 const char* actualExt = strrchr(path.c_str(),
'.');
385 for (
auto* ext : exts) {
386 if (0 == strcmp(ext, actualExt)) {
399 , fDstColorType(dstColorType)
400 , fDstAlphaType(dstAlphaType)
416 for (
int y = 0;
y <
bitmap.height();
y++) {
417 uint32_t* row = (uint32_t*)
bitmap.getAddr(0,
y);
424 switch (dstColorType) {
436#ifdef SK_PMCOLOR_IS_RGBA
481 if (
nullptr == codec) {
494 std::unique_ptr<SkAndroidCodec> androidCodec;
497 size = androidCodec->getSampledDimensions(1 / fScale);
501 return Result::Skip(
"Test without scaling is uninteresting.");
507 return Result::Skip(
"Scaling very small images is uninteresting.");
512 const size_t rowBytes =
size.
width() * bpp;
532 if (fScale != 1.0f) {
535 auto dims = androidCodec->getSampledDimensions(androidOptions.
fSampleSize);
539 std::vector<SkCodec::FrameInfo> frameInfos = androidCodec
540 ? androidCodec->codec()->getFrameInfo() : codec->getFrameInfo();
541 if (frameInfos.size() <= 1) {
548 const float root = sqrt((
float) frameInfos.size());
554 for (
int i = 0;
static_cast<size_t>(i) < frameInfos.size(); i++) {
557 const int reqFrame = frameInfos[i].fRequiredFrame;
559 && priorFramePixels.
get()) {
561 memcpy(pixels.
get(), priorFramePixels.
get(), safeSize);
567 ? androidCodec->getAndroidPixels(decodeInfo, pixels.
get(), rowBytes,
569 : codec->getPixels(decodeInfo, pixels.
get(), rowBytes, &androidOptions);
585 if (
static_cast<size_t>(i+1) < frameInfos.size()
586 && frameInfos[i+1].fRequiredFrame == i) {
587 memcpy(priorFramePixels.
reset(safeSize), pixels.
get(), safeSize);
592 const int xTranslate = (i % factor) * decodeInfo.
width();
593 const int yTranslate = (i / factor) * decodeInfo.
height();
604 "Cannot decode frame %i to 565 (%s).", i, fPath.
c_str());
609 "Couldn't getPixels for frame %i in %s.", i, fPath.
c_str());
616 switch (codec->getPixels(decodeInfo, pixels.
get(), rowBytes, &
options)) {
632 void* dst = pixels.
get();
634 const bool useIncremental = [
this]() {
635 auto exts = {
"png",
"PNG",
"gif",
"GIF" };
636 for (
auto ext : exts) {
645 const bool ico = fPath.
endsWith(
"ico");
646 bool useOldScanlineMethod = !useIncremental && !ico;
647 if (useIncremental || ico) {
651 auto result = codec->incrementalDecode(&rowsDecoded);
653 codec->fillIncompleteImage(decodeInfo, dst, rowBytes,
658 if (useIncremental) {
664 useOldScanlineMethod =
true;
668 if (useOldScanlineMethod) {
675 codec->getScanlines(dst,
height, rowBytes);
685 const int stripeHeight = 37;
686 const int numStripes = (
height + stripeHeight - 1) / stripeHeight;
687 void* dst = pixels.
get();
700 for (
int i = 0; i < numStripes; i += 2) {
702 const int linesToSkip = std::min(stripeHeight,
height - i * stripeHeight);
703 codec->skipScanlines(linesToSkip);
706 const int startY = (i + 1) * stripeHeight;
707 const int linesToRead = std::min(stripeHeight,
height - startY);
708 if (linesToRead > 0) {
709 codec->getScanlines(SkTAddOffset<void>(dst, rowBytes * startY), linesToRead,
715 const SkCodec::Result startResult = codec->startScanlineDecode(decodeInfo);
717 return Result::Fatal(
"Failed to restart scanline decoder with same parameters.");
719 for (
int i = 0; i < numStripes; i += 2) {
721 const int startY = i * stripeHeight;
722 const int linesToRead = std::min(stripeHeight,
height - startY);
723 codec->getScanlines(SkTAddOffset<void>(dst, rowBytes * startY), linesToRead,
727 const int linesToSkip = std::min(stripeHeight,
height - (i + 1) * stripeHeight);
728 if (linesToSkip > 0) {
729 codec->skipScanlines(linesToSkip);
742 const int tileSize = 36;
744 for (
int x = 0;
x <
width;
x += tileSize) {
751 codec->getScanlines(SkTAddOffset<void>(pixels.
get(),
x * bpp),
height, rowBytes);
761 const int W = codec->getInfo().width();
762 const int H = codec->getInfo().height();
763 if (divisor >
W || divisor >
H) {
764 return Result::Skip(
"Cannot codec subset: divisor %d is too big "
765 "for %s with dimensions (%d x %d)", divisor,
776 void* dst = pixels.
get();
781 for (
int x = 0;
x <
W;
x +=
w) {
783 for (
int y = 0;
y <
H;
y+=
h) {
785 const int preScaleW = std::min(
w,
W -
x);
786 const int preScaleH = std::min(
h,
H -
y);
787 subset.
setXYWH(
x,
y, preScaleW, preScaleH);
793 decodeInfo = decodeInfo.
makeWH(scaledW, scaledH);
795 size_t subsetRowBytes = subsetBitmapInfo.
minRowBytes();
804 return Result::Fatal(
"subset codec failed to decode (%d, %d, %d, %d) "
805 "from %s with dimensions (%d x %d)\t error %d",
809 draw_to_canvas(canvas, subsetBitmapInfo, dst, subsetRowBytes, fDstColorType,
813 top += decodeInfo.
height();
830 if (
nullptr == codec) {
835 return codec->getScaledDimensions(fScale);
841 const size_t count = codec->getFrameInfo().size();
842 const float root = sqrt((
float)
count);
846 auto imageSize = androidCodec->getSampledDimensions(1 / fScale);
847 imageSize.fWidth = imageSize.fWidth * factor;
857 if (1.0f == fScale) {
868 , fDstColorType(dstColorType)
869 , fDstAlphaType(dstAlphaType)
870 , fSampleSize(sampleSize)
886 if (
nullptr == codec) {
897 SkISize size = codec->getSampledDimensions(fSampleSize);
902 return Result::Skip(
"Scaling very small images is uninteresting.");
922 switch (codec->getAndroidPixels(decodeInfo, pixels.
get(), rowBytes, &
options)) {
937 if (
nullptr == codec) {
940 return codec->getSampledDimensions(fSampleSize);
946 if (1 == fSampleSize) {
957 , fDstAlphaType(alphaType)
974 return Result::Skip(
"Uninteresting to test image generator to 565.");
982#if defined(SK_BUILD_FOR_WIN)
984 SkAutoCoInitialize com;
985 if (!com.succeeded()) {
990 std::unique_ptr<SkImageGenerator>
gen(
nullptr);
995 return Result::Fatal(
"Could not create codec image generator.");
999#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
1000 gen = SkImageGeneratorCG::MakeFromEncodedCG(encoded);
1001#elif defined(SK_BUILD_FOR_WIN)
1002 gen = SkImageGeneratorWIC::MakeFromEncodedWIC(encoded);
1003#elif defined(SK_ENABLE_NDK_IMAGES)
1004 gen = SkImageGeneratorNDK::MakeFromEncodedNDK(encoded);
1007 return Result::Fatal(
"Could not create platform image generator.");
1020 return Result::Fatal(
"Could not create image from codec image generator.");
1027 SkImageInfo decodeInfo =
gen->getInfo().makeAlphaType(fDstAlphaType);
1030 size_t rowBytes = decodeInfo.
width() * bpp;
1032 if (!
gen->getPixels(decodeInfo, pixels.
get(), rowBytes)) {
1034#if defined(SK_BUILD_FOR_WIN)
1054 if (
nullptr == codec) {
1057 return codec->getInfo().dimensions();
1067 , fDecodeToDst(decode_to_dst) {}
1081 if (
nullptr == codec) {
1097 return Result::Skip(
"Skipping decoding without color transform.");
1111 return Result::Skip(
"SkCodec can't decode to this format.");
1120 if (
nullptr == codec) {
1123 return {codec->getInfo().width(), codec->getInfo().height()};
1133 "Width & height of the viewport used to crop skp rendering.");
1138 struct DeserializationContext {
1140#if defined(SK_GRAPHITE)
1145#if defined(SK_GRAPHITE)
1157 DeserializationContext* context =
reinterpret_cast<DeserializationContext*
>(ctx);
1159 if (context->fDirectContext) {
1199 return info.fCullRect;
1224 class PathFindingCanvas :
public SkCanvas {
1244 int start = 0,
end = pathFinder.foundPaths().size();
1245 for (
const char* ch = fTrail.
c_str(); *ch; ++ch) {
1249 }
else if (
'r' == *ch) {
1254 for (
int i =
start; i <
end; ++i) {
1255 const FoundPath& path = pathFinder.foundPaths()[i];
1257 canvas->
concat(path.fViewMatrix);
1258 canvas->
drawPath(path.fPath, path.fPaint);
1266#if defined(SK_ENABLE_SKOTTIE)
1268 "Prioritize embedded glyph paths over native fonts.");
1270SkottieSrc::SkottieSrc(
Path path) :
fPath(
std::move(path)) {}
1272Result SkottieSrc::draw(
SkCanvas* canvas, GraphiteTestContext*)
const {
1281 static constexpr char kInterceptPrefix[] =
"__";
1282 auto precomp_interceptor =
1283 sk_make_sp<skottie_utils::ExternalAnimationPrecompInterceptor>(resource_provider,
1286 if (FLAGS_useLottieGlyphPaths) {
1302 const auto t_rate = 1.0f / (kTileCount * kTileCount - 1);
1307 static constexpr int frameOrder[] = { 4, 0, 3, 1, 2 };
1308 static_assert(std::size(frameOrder) == kTileCount,
"");
1310 for (
int i = 0; i < kTileCount; ++i) {
1311 const SkScalar y = frameOrder[i] * kTileSize;
1313 for (
int j = 0; j < kTileCount; ++j) {
1314 const SkScalar x = frameOrder[j] * kTileSize;
1317 const auto t = t_rate * (frameOrder[i] * kTileCount + frameOrder[j]);
1324 animation->render(canvas);
1332SkISize SkottieSrc::size()
const {
1338bool SkottieSrc::veto(SinkFlags
flags)
const {
1349#if defined(SK_ENABLE_SVG)
1351static const SkSize kDefaultSVGSize = {1000, 1000};
1354static const SkSize kMinimumSVGSize = {128, 128};
1356SVGSrc::SVGSrc(
Path path)
1382 const SkSize& sz = fDom->containerSize();
1385 fDom->setContainerSize(kDefaultSVGSize);
1387 fScale = std::max(1.f, std::max(kMinimumSVGSize.
width() / sz.
width(),
1392Result SVGSrc::draw(
SkCanvas* canvas, GraphiteTestContext*)
const {
1398 canvas->
scale(fScale, fScale);
1400 fDom->render(canvas);
1410 return SkSize{fDom->containerSize().
width() * fScale, fDom->containerSize().height() * fScale}
1414Name SVGSrc::name()
const {
return fName; }
1416bool SVGSrc::veto(SinkFlags
flags)
const {
1442 return i >= 0 && i < fPages.
size() ? fPages[i].fSize.toCeil() :
SkISize{0, 0};
1446 return this->
draw(FLAGS_mskpFrame, c, testContext);
1450 return Result::Fatal(
"Unable to parse MultiPictureDocument file: %s", fPath.
c_str());
1452 if (i >= fPages.
size() || i < 0) {
1453 return Result::Fatal(
"MultiPictureDocument page number out of range: %d", i);
1455 SkPicture* page = fPages[i].fPicture.get();
1462 return Result::Fatal(
"SkMultiPictureDocument reader failed on page %d: %s", i,
1465 page = fPages[i].fPicture.get();
1490 SkString errString(
"Pixels don't match reference");
1492 errString.
append(
"\nExpected: ");
1493 errString.
append(encoded);
1495 errString.
append(
"\nExpected image failed to encode: ");
1496 errString.
append(encoded);
1499 errString.
append(
"\nActual: ");
1500 errString.
append(encoded);
1502 errString.
append(
"\nActual image failed to encode: ");
1503 errString.
append(encoded);
1512static DEFINE_bool(gpuStats,
false,
"Append GPU stats to the log for each GPU task?");
1514 "Test abandoning the GrContext before running the test.");
1516 "Test abandoning the GrContext after running each test.");
1518 "Test releasing all gpu resources and abandoning the GrContext "
1519 "after running each test");
1520static DEFINE_bool(drawOpClip,
false,
"Clip each GrDrawOp to its device bounds for testing.");
1521static DEFINE_bool(programBinaryCache,
true,
"Use in-memory program binary cache");
1525 : fContextType(config->getContextType())
1526 , fContextOverrides(config->getContextOverrides())
1527 , fSurfType(config->getSurfType())
1528 , fSampleCount(config->getSamples())
1529 , fSurfaceFlags(config->getSurfaceFlags())
1531 , fAlphaType(config->getAlphaType())
1532 , fBaseContextOptions(grCtxOptions) {
1533 if (FLAGS_programBinaryCache) {
1539 return this->
onDraw(src, dst, dstStream, log, fBaseContextOptions);
1548 switch (fSurfType) {
1558 skgpu::Mipmapped::kNo,
1593 src.modifyGrContextOptions(&grOptions);
1600 initContext(direct);
1603 const int maxDimension = direct->priv().caps()->maxTextureSize();
1604 if (maxDimension < std::max(src.size().width(), src.size().height())) {
1605 return Result::Skip(
"Src too large to create a texture.\n");
1612 if (FLAGS_preAbandonGpuContext) {
1616 auto canvas =
surface->getCanvas();
1617 if (wrapCanvas !=
nullptr) {
1618 canvas = wrapCanvas(canvas);
1626 if (FLAGS_gpuStats) {
1627 direct->priv().dumpCacheStats(log);
1628 direct->priv().dumpGpuStats(log);
1629 direct->priv().dumpContextStats(log);
1634 if (FLAGS_abandonGpuContext) {
1636 }
else if (FLAGS_releaseAndAbandonGpuContext) {
1641 direct->storeVkPipelineCacheData();
1657 return onDraw(src, dst,
write, log, grOptions,
nullptr,
1659 testCanvas.
init(canvas);
1660 return testCanvas.
get();
1677 return onDraw(src, dst,
write, log, grOptions,
nullptr,
1679 testCanvas.
init(canvas);
1680 return testCanvas.
get();
1697 return onDraw(src, dst,
write, log, grOptions,
nullptr,
1699 testCanvas.
init(canvas);
1700 return testCanvas.
get();
1708 , fCacheType(config->getTestPersistentCache()) {}
1717 if (fCacheType == 2) {
1722 if (!
result.isOk() || !dst) {
1730 Result refResult = this->
onDraw(src, &reference, &refStream, &refLog, contextOptions);
1731 if (!refResult.
isOk()) {
1759 if (!
result.isOk() || !dst) {
1781 Result refResult = this->
onDraw(src, &reference, &refStream, &refLog, replayOptions,
1783 if (!refResult.
isOk()) {
1794 , fRecordingExecutor(
SkExecutor::MakeLIFOThreadPool(1))
1795 , fGPUExecutor(
SkExecutor::MakeFIFOThreadPool(1, false)) {
1798Result GPUDDLSink::ddlDraw(
const Src& src,
1811 auto size = src.size();
1826 sk_sp<SkPicture> newSKP = promiseImageHelper.recreateSKP(dContext, inputPicture.get());
1828 return Result::Fatal(
"GPUDDLSink: Couldn't recreate the SKP");
1839 promiseImageHelper.uploadAllToGPU(gpuTaskGroup, dContext);
1844 constexpr int kNumDivisions = 3;
1846 kNumDivisions, kNumDivisions,
1849 tiles.createBackendTextures(gpuTaskGroup, dContext);
1851 tiles.kickOffThreadedWork(recordingTaskGroup, gpuTaskGroup, dContext, newSKP.
get());
1856 recordingTaskGroup->
wait();
1860 if (FLAGS_preAbandonGpuContext) {
1868 gpuTaskGroup->
add([dstSurface, ddl =
tiles.composeDDL()]() {
1869 skgpu::ganesh::DrawDDL(dstSurface, ddl);
1873 gpuTaskGroup->
add([dContext]() {
1886 promiseImageHelper.deleteAllFromGPU(gpuTaskGroup, dContext);
1888 tiles.deleteBackendTextures(gpuTaskGroup, dContext);
1895 gpuTaskGroup->
wait();
1916 SkASSERT(mainCtx->priv().getGpu());
1929 SkASSERT(otherCtx->priv().getGpu());
1932 SkTaskGroup recordingTaskGroup(*fRecordingExecutor);
1944 mainTestCtx, mainCtx);
1952 if (FLAGS_gpuStats) {
1953 mainCtx->priv().dumpCacheStats(log);
1954 mainCtx->priv().dumpGpuStats(log);
1955 mainCtx->priv().dumpContextStats(log);
1958 otherCtx->priv().dumpCacheStats(log);
1959 otherCtx->priv().dumpGpuStats(log);
1960 otherCtx->priv().dumpContextStats(log);
1973 if (src.size().isEmpty()) {
1977 int pageCount = src.pageCount();
1978 for (
int i = 0; i < pageCount; ++i) {
1979 int width = src.size(i).width(),
height = src.size(i).height();
1983 return Result::Fatal(
"SkDocument::beginPage(w,h) returned nullptr");
1998 metadata.
fTitle = src.name();
1999 metadata.
fSubject =
"rendering correctness test";
2003#if SK_PDF_TEST_EXECUTOR
2009 return Result::Fatal(
"SkPDF::MakeDocument() returned nullptr");
2018#if defined(SK_SUPPORT_XPS)
2019static SkTScopedComPtr<IXpsOMObjectFactory> make_xps_factory() {
2020 IXpsOMObjectFactory* factory;
2021 HRN(CoCreateInstance(CLSID_XpsOMObjectFactory,
2023 CLSCTX_INPROC_SERVER,
2024 IID_PPV_ARGS(&factory)));
2025 return SkTScopedComPtr<IXpsOMObjectFactory>(factory);
2029 SkAutoCoInitialize com;
2030 if (!com.succeeded()) {
2033 SkTScopedComPtr<IXpsOMObjectFactory> factory = make_xps_factory();
2037 auto doc = SkXPS::MakeDocument(dst, factory.get());
2039 return Result::Fatal(
"SkXPS::MakeDocument() returned nullptr");
2045 return Result::Fatal(
"XPS not supported on this platform.");
2077 DebugCanvas debugCanvas(src.size().width(), src.size().height());
2086 debugCanvas.
toJSON(writer, dataManager, nullCanvas.get());
2097#if defined(SK_ENABLE_SVG)
2098 if (src.pageCount() > 1) {
2099 int pageCount = src.pageCount();
2100 if (fPageIndex > pageCount - 1) {
2101 return Result::Fatal(
"Page index %d too high for document with only %d pages.",
2102 fPageIndex, pageCount);
2105 return src.draw(fPageIndex,
2123 const SkISize size = src.size();
2124 if (size.isEmpty()) {
2126 SkStringPrintf(
"Skipping empty source: %s", src.name().c_str()));
2134 return src.draw(
surface->getCanvas(),
nullptr);
2139#if defined(SK_GRAPHITE)
2141GraphiteSink::GraphiteSink(
const SkCommandLineConfigGraphite* config)
2142 : fOptions(config->getOptions())
2143 , fContextType(config->getContextType())
2144 , fSurfaceType(config->getSurfaceType())
2146 , fAlphaType(config->getAlphaType()) {}
2148Result GraphiteSink::draw(
const Src& src,
2157 options.fContextOptions.fOptionsPriv = &optionsPriv;
2159 src.modifyGraphiteContextOptions(&
options.fContextOptions);
2168 std::unique_ptr<skgpu::graphite::Recorder> recorder =
2169 context->
makeRecorder(ToolUtils::CreateTestingRecorderOptions());
2186 if (!
dst->peekPixels(&pm) ||
2187 !
surface->readPixels(pm, 0, 0)) {
2192 std::unique_ptr<skgpu::graphite::Recording> recording = recorder->snap();
2211 switch (fSurfaceType) {
2215 case SurfaceType::kWrapTextureView:
2216 return sk_gpu_test::MakeBackendTextureViewSurface(recorder,
2218 skgpu::Mipmapped::kNo,
2219 skgpu::Protected::kNo,
2227#if defined(SK_ENABLE_PRECOMPILE)
2229GraphitePrecompileTestingSink::GraphitePrecompileTestingSink(
2230 const SkCommandLineConfigGraphite* config) : GraphiteSink(config) {}
2232GraphitePrecompileTestingSink::~GraphitePrecompileTestingSink() {}
2234Result GraphitePrecompileTestingSink::drawSrc(
2239 fRecorder = context->
makeRecorder(ToolUtils::CreateTestingRecorderOptions());
2254 std::unique_ptr<skgpu::graphite::Recording> recording = fRecorder->snap();
2271Result GraphitePrecompileTestingSink::resetAndRecreatePipelines(
2279 std::vector<skgpu::UniqueKey> origKeys;
2284 SkASSERT(numBeforeReset == (
int) origKeys.size());
2300 Precompile(context, rteDict, pipelineDesc, renderPassDesc);
2305 SkASSERT(numBeforeReset == postRecreate);
2308 std::vector<skgpu::UniqueKey> recreatedKeys;
2313 if(std::find(recreatedKeys.begin(), recreatedKeys.end(), origKey) ==
2314 recreatedKeys.end()) {
2327 &originalPipelineDesc,
2328 &originalRenderPassDesc);
2330 SkDebugf(
"------- Missing key from rebuilt keys:\n");
2331 origKey.dump(
"original key:");
2332 UniqueKeyUtils::DumpDescs(rendererProvider, dict,
2333 originalPipelineDesc,
2334 originalRenderPassDesc);
2337 SkDebugf(
"Have %d recreated keys -----------------\n", (
int) recreatedKeys.size());
2344 &recreatedPipelineDesc,
2345 &recreatedRenderPassDesc);
2348 recreatedKey.dump(
"recreated key:");
2349 UniqueKeyUtils::DumpDescs(rendererProvider, dict,
2350 recreatedPipelineDesc,
2351 recreatedRenderPassDesc);
2363Result GraphitePrecompileTestingSink::draw(
const Src& src,
2372 options.fContextOptions.fOptionsPriv = &optionsPriv;
2374 src.modifyGraphiteContextOptions(&
options.fContextOptions);
2395 result = this->resetAndRecreatePipelines(context);
2428 class ProxySrc :
public Src {
2432 return fDraw(canvas, testContext);
2434 Name name()
const override {
return "ProxySrc"; }
2435 SkISize size()
const override {
return fSize; }
2445static DEFINE_bool(
check,
true,
"If true, have most Via- modes fail if they affect the output.");
2451 if (FLAGS_check &&
bitmap) {
2470 matrix->mapRect(&bounds);
2471 matrix->postTranslate(-bounds.x(), -bounds.y());
2483 canvas->concat(matrix);
2484 return src.draw(canvas, testContext);
2527 auto size = src.size();
2543 canvas->drawPicture(deserialized);
2544 return Result::Ok();
2556 auto size = src.size();
2559 SkPictureRecorder recorder;
2560 sk_sp<SkPicture> pic;
2561 Result result = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
2562 SkIntToScalar(size.height())),
2564 if (!result.isOk()) {
2567 pic = recorder.finishRecordingAsPicture();
2590 if (std::optional<SkBlendMode> mode =
paint.asBlendMode()) {
2602 RuntimeBlendFilterCanvas runtimeBlendCanvas{canvas};
2603 return src.draw(&runtimeBlendCanvas, testContext);
2611 auto size = src.size();
2612 return draw_to_canvas(fSink.get(),
bitmap, stream, log, size,
2613 [&](
SkCanvas* canvas, Src::GraphiteTestContext* testContext) -> Result {
2614 SkDynamicMemoryWStream wstream;
2615 SkXMLStreamWriter writer(&wstream);
2616 Result result = src.draw(SkSVGCanvas::Make(SkRect::Make(size), &writer).get(),
2618 if (!result.isOk()) {
2628 std::unique_ptr<SkStream> rstream(wstream.detachAsStream());
2635 dom->render(canvas);
2637 return Result::Ok();
#define DEFINE_bool(name, defaultValue, helpString)
#define DEFINE_int(name, defaultValue, helpString)
#define DECLARE_int(name)
static void info(const char *fmt,...) SK_PRINTF_LIKE(1
static GrDirectContext * GrAsDirectContext(GrContext_Base *base)
@ kBottomLeft_GrSurfaceOrigin
@ kTopLeft_GrSurfaceOrigin
#define check(reporter, ref, unref, make, kill)
sk_sp< SkBlender > GetRuntimeBlendForBlendMode(SkBlendMode mode)
static constexpr T SkAlign2(T x)
@ kOpaque_SkAlphaType
pixel is opaque
#define SkAssertResult(cond)
#define SK_ABORT(message,...)
#define SkASSERT_RELEASE(cond)
@ kBGRA_8888_SkColorType
pixel with 8 bits for blue, green, red, alpha; in 32-bit word
@ kRGBA_F16_SkColorType
pixel with half floats for red, green, blue, alpha;
@ kAlpha_8_SkColorType
pixel with alpha in 8-bit byte
@ kGray_8_SkColorType
pixel with grayscale level in 8-bit byte
@ kRGB_565_SkColorType
pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word
@ kRGBA_8888_SkColorType
pixel with 8 bits for red, green, blue, alpha; in 32-bit word
constexpr SkColor SK_ColorWHITE
void SK_SPI SkDebugf(const char format[],...) SK_PRINTF_LIKE(1
static bool SkEncodedOriginSwapsWidthHeight(SkEncodedOrigin origin)
#define sk_float_ceil2int(x)
static SkColorType colorType(AImageDecoder *decoder, const AImageDecoderHeaderInfo *headerInfo)
static SkImage_Base * as_IB(SkImage *image)
SK_API std::unique_ptr< SkCanvas > SkMakeNullCanvas()
bool SkPicture_StreamIsSKP(SkStream *stream, SkPictInfo *pInfo)
static bool left(const SkPoint &p0, const SkPoint &p1)
#define INHERITED(method,...)
static SkScalar SkScalarSignAsScalar(SkScalar x)
#define SkScalarRoundToInt(x)
SK_API SkString static SkString SkStringPrintf()
static void draw(SkCanvas *canvas, SkRect &target, int x, int y)
SkISize size() const override
AndroidCodecSrc(Path, CodecSrc::DstColorType, SkAlphaType, int sampleSize)
bool veto(SinkFlags) const override
Result draw(SkCanvas *, GraphiteTestContext *) const override
Name name() const override
Result draw(SkCanvas *, GraphiteTestContext *) const override
BisectSrc(Path path, const char *trail)
bool veto(SinkFlags) const override
SkISize size() const override
@ kGetFromCanvas_DstColorType
@ kGrayscale_Always_DstColorType
@ kNonNative8888_Always_DstColorType
Name name() const override
Result draw(SkCanvas *, GraphiteTestContext *) const override
Result draw(SkCanvas *, GraphiteTestContext *) const override
Name name() const override
bool veto(SinkFlags) const override
ColorCodecSrc(Path, bool decode_to_dst)
SkISize size() const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
Name name() const override
Result draw(SkCanvas *, GraphiteTestContext *) const override
void modifyGrContextOptions(GrContextOptions *options) const override
SkISize size() const override
GPUDDLSink(const SkCommandLineConfigGpu *, const GrContextOptions &)
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
GPUPersistentCacheTestingSink(const SkCommandLineConfigGpu *, const GrContextOptions &)
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
GPUPrecompileTestingSink(const SkCommandLineConfigGpu *, const GrContextOptions &)
GPURemoteSlugSink(const SkCommandLineConfigGpu *, const GrContextOptions &)
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
GPUSerializeSlugSink(const SkCommandLineConfigGpu *, const GrContextOptions &)
const sk_gpu_test::GrContextFactory::ContextOverrides & contextOverrides() const
GPUSink(const SkCommandLineConfigGpu *, const GrContextOptions &)
skgpu::ContextType contextType() const
Result onDraw(const Src &, SkBitmap *, SkWStream *, SkString *, const GrContextOptions &baseOptions, std::function< void(GrDirectContext *)> initContext=nullptr, std::function< SkCanvas *(SkCanvas *)> wrapCanvas=nullptr) const
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
const GrContextOptions & baseContextOptions() const
bool readBack(SkSurface *, SkBitmap *dst) const
SkColorInfo colorInfo() const override
sk_sp< SkSurface > createDstSurface(GrDirectContext *, SkISize size) const
GPUSlugSink(const SkCommandLineConfigGpu *, const GrContextOptions &)
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
bool veto(SinkFlags) const override
Name name() const override
ImageGenSrc(Path, Mode, SkAlphaType, bool)
SkISize size() const override
Result draw(SkCanvas *, GraphiteTestContext *) const override
SkISize size() const override
Result draw(SkCanvas *c, GraphiteTestContext *) const override
int pageCount() const override
Name name() const override
Result draw(const Src &src, SkBitmap *, SkWStream *, SkString *) const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
SkColorInfo colorInfo() const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
Name name() const override
Result draw(SkCanvas *, GraphiteTestContext *) const override
SkISize size() const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
ViaMatrix(SkMatrix, Sink *)
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
ViaUpright(SkMatrix, Sink *)
std::unique_ptr< Sink > fSink
Result draw(const Src &, SkBitmap *, SkWStream *, SkString *) const override
void toJSON(SkJSONWriter &writer, UrlDataManager &urlDataManager, SkCanvas *)
bool submit(GrSyncCpu sync=GrSyncCpu::kNo)
GrSemaphoresSubmitted flush(const GrFlushInfo &info)
void abandonContext() override
static std::unique_ptr< SkAndroidCodec > MakeFromData(sk_sp< SkData >, SkPngChunkReader *=nullptr)
static std::unique_ptr< SkAndroidCodec > MakeFromCodec(std::unique_ptr< SkCodec >)
void * reset(size_t size=0, OnShrink shrink=kAlloc_OnShrink)
void allocPixels(const SkImageInfo &info, size_t rowBytes)
size_t computeByteSize() const
@ kZeroPixels_AllocFlag
zero pixel memory. No effect. This is the default.
void clipRect(const SkRect &rect, SkClipOp op, bool doAntiAlias)
void translate(SkScalar dx, SkScalar dy)
void drawColor(SkColor color, SkBlendMode mode=SkBlendMode::kSrcOver)
virtual GrRecordingContext * recordingContext() const
virtual skgpu::graphite::Recorder * recorder() const
virtual SkISize getBaseLayerSize() const
@ kStrict_SrcRectConstraint
sample only inside bounds; slower
void clear(SkColor color)
void drawImageRect(const SkImage *, const SkRect &src, const SkRect &dst, const SkSamplingOptions &, const SkPaint *, SrcRectConstraint)
void drawPath(const SkPath &path, const SkPaint &paint)
void scale(SkScalar sx, SkScalar sy)
void concat(const SkMatrix &matrix)
void drawPicture(const SkPicture *picture)
SkImageInfo imageInfo() const
bool readPixels(const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY)
void drawImage(const SkImage *image, SkScalar left, SkScalar top)
static std::unique_ptr< SkImageGenerator > MakeFromEncodedCodec(sk_sp< SkData >, std::optional< SkAlphaType >=std::nullopt)
static std::unique_ptr< SkCodec > MakeFromData(sk_sp< SkData >, SkSpan< const SkCodecs::Decoder > decoders, SkPngChunkReader *=nullptr)
@ kTopDown_SkScanlineOrder
static constexpr int kNoFrame
static sk_sp< SkColorSpace > MakeSRGB()
static sk_sp< SkData > MakeWithoutCopy(const void *data, size_t length)
static sk_sp< SkData > MakeFromFileName(const char path[])
SkCanvas * beginPage(SkScalar width, SkScalar height, const SkRect *content=nullptr)
static std::unique_ptr< SkExecutor > MakeFIFOThreadPool(int threads=0, bool allowBorrowing=true)
sk_sp< SkImage > makeRasterImage(GrDirectContext *, CachingHint cachingHint=kDisallow_CachingHint) const
void beginObject(const char *name=nullptr, bool multiline=true)
static SkMatrix RectToRect(const SkRect &src, const SkRect &dst, ScaleToFit mode=kFill_ScaleToFit)
SkScalar getSkewY() const
SkMatrix & setSkewX(SkScalar v)
@ kCenter_ScaleToFit
scales and aligns to center
SkScalar getSkewX() const
bool invert(SkMatrix *inverse) const
bool rectStaysRect() const
SkScalar getScaleX() const
static const SkMatrix & I()
SkScalar getScaleY() const
SkMatrix & setScaleY(SkScalar v)
SkMatrix & setSkewY(SkScalar v)
SkMatrix & setScaleX(SkScalar v)
static SkString Basename(const char *fullPath)
static SkString Dirname(const char *fullPath)
virtual bool onFilter(SkPaint &paint) const =0
SkCanvas * beginRecording(const SkRect &bounds, sk_sp< SkBBoxHierarchy > bbh)
sk_sp< SkPicture > finishRecordingAsPicture()
sk_sp< SkData > serialize(const SkSerialProcs *procs=nullptr) const
static sk_sp< SkPicture > MakeFromData(const SkData *data, const SkDeserialProcs *procs=nullptr)
static sk_sp< SkPicture > MakeFromStream(SkStream *stream, const SkDeserialProcs *procs=nullptr)
static std::unique_ptr< SkCanvas > Make(const SkRect &bounds, SkWStream *, uint32_t flags=0)
Builder & setTextShapingFactory(sk_sp< SkShapers::Factory >)
sk_sp< SkSVGDOM > make(SkStream &) const
Builder & setFontManager(sk_sp< SkFontMgr >)
Builder & setResourceProvider(sk_sp< skresources::ResourceProvider >)
static std::unique_ptr< SkStreamAsset > MakeFromFile(const char path[])
void append(const char text[])
bool endsWith(const char suffixStr[]) const
const char * c_str() const
T * init(Args &&... args)
void add(std::function< void(void)> fn)
static sk_sp< SkTypeface > MakeDeserialize(SkStream *, sk_sp< SkFontMgr > lastResortMgr)
static std::unique_ptr< BitmapRegionDecoder > Make(sk_sp< SkData > data)
GrDirectContext * directContext() const
TestContext * testContext() const
ContextInfo getContextInfo(ContextType type, ContextOverrides=ContextOverrides::kNone)
ContextInfo getSharedContextInfo(GrDirectContext *shareContext, uint32_t shareIndex=0)
void releaseResourcesAndAbandonContexts()
int numCacheMisses() const
int numCacheStores() const
void makeNotCurrent() const
const GlobalCache * globalCache() const
const RendererProvider * rendererProvider() const
const ShaderCodeDictionary * shaderCodeDictionary() const
std::unique_ptr< Recorder > makeRecorder(const RecorderOptions &={})
bool submit(SyncToCpu=SyncToCpu::kNo)
bool insertRecording(const InsertRecordingInfo &)
sk_sp< GraphicsPipeline > findGraphicsPipeline(const UniqueKey &) SK_EXCLUDES(fSpinLock)
void syncedSubmit(skgpu::graphite::Context *)
Builder & setResourceProvider(sk_sp< ResourceProvider >)
Builder & setFontManager(sk_sp< SkFontMgr >)
Builder & setPrecompInterceptor(sk_sp< PrecompInterceptor >)
Builder & setTextShapingFactory(sk_sp< SkShapers::Factory >)
sk_sp< Animation > makeFromFile(const char path[])
static sk_sp< DataURIResourceProviderProxy > Make(sk_sp< ResourceProvider > rp, ImageDecodeStrategy=ImageDecodeStrategy::kLazyDecode, sk_sp< const SkFontMgr > fontMgr=nullptr)
static sk_sp< FileResourceProvider > Make(SkString base_dir, ImageDecodeStrategy=ImageDecodeStrategy::kLazyDecode)
sk_sp< SkFontMgr > fontMgr
FlutterSemanticsFlag flags
static Result compare_bitmaps(const SkBitmap &reference, const SkBitmap &bitmap)
static SkSerialProcs serial_procs_using_png()
static bool serial_from_path_name(const SkString &path)
static void draw_to_canvas(SkCanvas *canvas, const SkImageInfo &info, void *pixels, size_t rowBytes, CodecSrc::DstColorType dstColorType, SkScalar left=0, SkScalar top=0)
static SkISize auto_compute_translate(SkMatrix *matrix, int srcW, int srcH)
static SkRect get_cull_rect_for_skp(const char *path)
static void set_bitmap_color_space(SkImageInfo *info)
static Result check_against_reference(const SkBitmap *bitmap, const Src &src, Sink *sink)
static SkString get_scaled_name(const Path &path, float scale)
static bool get_decode_info(SkImageInfo *decodeInfo, SkColorType canvasColorType, CodecSrc::DstColorType dstColorType, SkAlphaType dstAlphaType)
static Result draw_skdocument(const Src &src, SkDocument *doc, SkWStream *dst)
static void swap_rb_if_necessary(SkBitmap &bitmap, CodecSrc::DstColorType dstColorType)
std::function< DM::Result(SkCanvas *, Src::GraphiteTestContext *)> DrawToCanvasFn
SK_API sk_sp< SkImage > DeferredFromEncodedData(sk_sp< SkData > encoded, std::optional< SkAlphaType > alphaType=std::nullopt)
SK_API sk_sp< SkImage > DeferredFromGenerator(std::unique_ptr< SkImageGenerator > imageGenerator)
SK_API sk_sp< SkImage > TextureFromImage(GrDirectContext *, const SkImage *, skgpu::Mipmapped=skgpu::Mipmapped::kNo, skgpu::Budgeted=skgpu::Budgeted::kYes)
SK_API bool Read(SkStreamSeekable *src, SkDocumentPage *dstArray, int dstArrayCount, const SkDeserialProcs *=nullptr)
SK_API int ReadPageCount(SkStreamSeekable *src)
bool ReadPageSizes(SkStreamSeekable *stream, SkDocumentPage *dstArray, int dstArrayCount)
Swizzle_8888_u32 RGBA_to_BGRA
SK_API sk_sp< SkDocument > MakeDocument(SkWStream *stream, const Metadata &metadata)
SK_API SkImageInfo SwapWidthHeight(const SkImageInfo &info)
SK_API bool Encode(SkWStream *dst, const SkPixmap &src, const Options &options)
sk_sp< Factory > BestAvailable()
SK_API sk_sp< SkSurface > WrapPixels(const SkImageInfo &imageInfo, void *pixels, size_t rowBytes, const SkSurfaceProps *surfaceProps=nullptr)
SK_API sk_sp< SkSurface > RenderTarget(GrRecordingContext *context, skgpu::Budgeted budgeted, const SkImageInfo &imageInfo, int sampleCount, GrSurfaceOrigin surfaceOrigin, const SkSurfaceProps *surfaceProps, bool shouldCreateWithMips=false, bool isProtected=false)
void FetchUniqueKeys(GlobalCache *globalCache, std::vector< UniqueKey > *keys)
bool ExtractKeyDescs(Context *context, const UniqueKey &origKey, GraphicsPipelineDesc *pipelineDesc, RenderPassDesc *renderPassDesc)
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir path
sk_sp< SkSurface > MakeBackendRenderTargetSurface(GrDirectContext *dContext, const SkImageInfo &ii, GrSurfaceOrigin origin, int sampleCnt, GrProtected isProtected, const SkSurfaceProps *props)
sk_sp< SkSurface > MakeBackendTextureSurface(GrDirectContext *dContext, const SkImageInfo &ii, GrSurfaceOrigin origin, int sampleCnt, skgpu::Mipmapped mipmapped, GrProtected isProtected, const SkSurfaceProps *props)
SkYUVAPixmapInfo::SupportedDataTypes SupportedTextureFormats(const GrImageContext &context)
bool Precompile(Context *context, RuntimeEffectDictionary *rteDict, const GraphicsPipelineDesc &pipelineDesc, const RenderPassDesc &renderPassDesc)
std::function< std::unique_ptr< skiagm::GM >()> GMFactory
constexpr struct @268 tiles[]
void write(SkWStream *wStream, const T &text)
virtual Result draw(const Src &, SkBitmap *, SkWStream *, SkString *log) const =0
virtual void modifyGrContextOptions(GrContextOptions *) const
virtual void modifyGraphiteContextOptions(skgpu::graphite::ContextOptions *) const
PersistentCache * fPersistentCache
bool fSupportBilerpFromGlyphAtlas
int fRuntimeProgramCacheSize
ShaderCacheStrategy fShaderCacheStrategy
SkDeserialTypefaceProc fTypefaceProc
SkDeserialImageProc fImageProc
static constexpr SkIRect MakeWH(int32_t w, int32_t h)
void setXYWH(int32_t x, int32_t y, int32_t width, int32_t height)
static constexpr SkIRect MakeXYWH(int32_t x, int32_t y, int32_t w, int32_t h)
static constexpr SkISize Make(int32_t w, int32_t h)
constexpr int32_t width() const
constexpr int32_t height() const
SkImageInfo makeWH(int newWidth, int newHeight) const
SkImageInfo makeAlphaType(SkAlphaType newAlphaType) const
size_t minRowBytes() const
size_t computeByteSize(size_t rowBytes) const
SkImageInfo makeDimensions(SkISize newSize) const
SkColorSpace * colorSpace() const
int bytesPerPixel() const
SkISize dimensions() const
static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at)
SkAlphaType alphaType() const
SkColorType colorType() const
SkImageInfo makeColorType(SkColorType newColorType) const
static constexpr SkRect MakeEmpty()
bool intersect(const SkRect &r)
static SkRect MakeIWH(int w, int h)
static constexpr SkRect MakeXYWH(float x, float y, float w, float h)
void roundOut(SkIRect *dst) const
static constexpr SkRect MakeSize(const SkSize &size)
static constexpr SkRect MakeWH(float w, float h)
SkSerialImageProc fImageProc
static constexpr SkSize Make(SkScalar w, SkScalar h)
GraphiteTestContext * fTestContext
skgpu::graphite::Context * fContext