/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrContext.h"
#include "GrBackendSemaphore.h"
#include "GrClip.h"
#include "GrContextOptions.h"
#include "GrContextPriv.h"
#include "GrDrawingManager.h"
#include "GrGpu.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrRenderTargetProxy.h"
#include "GrResourceCache.h"
#include "GrResourceProvider.h"
#include "GrSemaphore.h"
#include "GrSoftwarePathRenderer.h"
#include "GrSurfaceContext.h"
#include "GrSurfacePriv.h"
#include "GrSurfaceProxyPriv.h"
#include "GrTexture.h"
#include "GrTextureContext.h"
#include "GrTracing.h"
#include "SkConvertPixels.h"
#include "SkDeferredDisplayList.h"
#include "SkGr.h"
#include "SkImageInfoPriv.h"
#include "SkJSONWriter.h"
#include "SkMakeUnique.h"
#include "SkTaskGroup.h"
#include "SkUnPreMultiplyPriv.h"
#include "effects/GrConfigConversionEffect.h"
#include "gl/GrGLGpu.h"
#include "mock/GrMockGpu.h"
#include "text/GrTextBlobCache.h"
#ifdef SK_METAL
#include "mtl/GrMtlTrampoline.h"
#endif
#ifdef SK_VULKAN
#include "vk/GrVkGpu.h"
#endif
#define ASSERT_OWNED_PROXY(P) \
SkASSERT(!(P) || !((P)->priv().peekTexture()) || (P)->priv().peekTexture()->getContext() == this)
#define ASSERT_OWNED_PROXY_PRIV(P) \
SkASSERT(!(P) || !((P)->priv().peekTexture()) || (P)->priv().peekTexture()->getContext() == fContext)
#define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
#define ASSERT_SINGLE_OWNER \
SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(&fSingleOwner);)
#define ASSERT_SINGLE_OWNER_PRIV \
SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(&fContext->fSingleOwner);)
#define RETURN_IF_ABANDONED if (fDrawingManager->wasAbandoned()) { return; }
#define RETURN_IF_ABANDONED_PRIV if (fContext->fDrawingManager->wasAbandoned()) { return; }
#define RETURN_FALSE_IF_ABANDONED if (fDrawingManager->wasAbandoned()) { return false; }
#define RETURN_FALSE_IF_ABANDONED_PRIV if (fContext->fDrawingManager->wasAbandoned()) { return false; }
#define RETURN_NULL_IF_ABANDONED if (fDrawingManager->wasAbandoned()) { return nullptr; }
////////////////////////////////////////////////////////////////////////////////
class SK_API GrDirectContext : public GrContext {
public:
GrDirectContext(GrBackend backend)
: INHERITED(backend)
, fFullAtlasManager(nullptr) {
}
~GrDirectContext() override {
// this if-test protects against the case where the context is being destroyed
// before having been fully created
if (this->contextPriv().getGpu()) {
this->flush();
}
delete fFullAtlasManager;
}
void abandonContext() override {
INHERITED::abandonContext();
fFullAtlasManager->freeAll();
}
void releaseResourcesAndAbandonContext() override {
INHERITED::releaseResourcesAndAbandonContext();
fFullAtlasManager->freeAll();
}
void freeGpuResources() override {
this->flush();
fFullAtlasManager->freeAll();
INHERITED::freeGpuResources();
}
protected:
bool init(const GrContextOptions& options) override {
SkASSERT(fCaps); // should've been set in ctor
SkASSERT(!fThreadSafeProxy);
fThreadSafeProxy.reset(new GrContextThreadSafeProxy(fCaps, this->uniqueID(),
fBackend, options));
if (!INHERITED::initCommon(options)) {
return false;
}
GrDrawOpAtlas::AllowMultitexturing allowMultitexturing;
if (GrContextOptions::Enable::kNo == options.fAllowMultipleGlyphCacheTextures ||
// multitexturing supported only if range can represent the index + texcoords fully
!(fCaps->shaderCaps()->floatIs32Bits() || fCaps->shaderCaps()->integerSupport())) {
allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kNo;
} else {
allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kYes;
}
GrGlyphCache* glyphCache = this->contextPriv().getGlyphCache();
GrProxyProvider* proxyProvider = this->contextPriv().proxyProvider();
fFullAtlasManager = new GrAtlasManager(proxyProvider, glyphCache,
options.fGlyphCacheTextureMaximumBytes,
allowMultitexturing);
this->contextPriv().addOnFlushCallbackObject(fFullAtlasManager);
glyphCache->setGlyphSizeLimit(fFullAtlasManager->getGlyphSizeLimit());
return true;
}
GrRestrictedAtlasManager* onGetRestrictedAtlasManager() override { return fFullAtlasManager; }
GrAtlasManager* onGetFullAtlasManager() override { return fFullAtlasManager; }
private:
GrAtlasManager* fFullAtlasManager;
typedef GrContext INHERITED;
};
/**
* The DDL Context is the one in effect during DDL Recording. It isn't backed by a GrGPU and
* cannot allocate any GPU resources.
*/
class SK_API GrDDLContext : public GrContext {
public:
GrDDLContext(sk_sp<GrContextThreadSafeProxy> proxy)
: INHERITED(proxy->fBackend, proxy->fContextUniqueID)
, fRestrictedAtlasManager(nullptr) {
fCaps = proxy->fCaps;
fThreadSafeProxy = std::move(proxy);
}
~GrDDLContext() override {
// The GrDDLContext doesn't actually own the fRestrictedAtlasManager so don't delete it
}
void abandonContext() override {
SkASSERT(0); // abandoning in a DDL Recorder doesn't make a whole lot of sense
INHERITED::abandonContext();
}
void releaseResourcesAndAbandonContext() override {
SkASSERT(0); // abandoning in a DDL Recorder doesn't make a whole lot of sense
INHERITED::releaseResourcesAndAbandonContext();
}
void freeGpuResources() override {
SkASSERT(0); // freeing resources in a DDL Recorder doesn't make a whole lot of sense
INHERITED::freeGpuResources();
}
protected:
bool init(const GrContextOptions& options) override {
SkASSERT(fCaps); // should've been set in ctor
SkASSERT(fThreadSafeProxy); // should've been set in the ctor
if (!INHERITED::initCommon(options)) {
return false;
}
// DDL TODO: in DDL-mode grab a GrRestrictedAtlasManager from the thread-proxy and
// do not add an onFlushCB
return true;
}
GrRestrictedAtlasManager* onGetRestrictedAtlasManager() override {
return fRestrictedAtlasManager;
}
GrAtlasManager* onGetFullAtlasManager() override {
SkASSERT(0); // the DDL Recorders should never invoke this
return nullptr;
}
private:
GrRestrictedAtlasManager* fRestrictedAtlasManager;
typedef GrContext INHERITED;
};
GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext) {
GrContextOptions defaultOptions;
return Create(backend, backendContext, defaultOptions);
}
GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext,
const GrContextOptions& options) {
sk_sp<GrContext> context(new GrDirectContext(backend));
context->fGpu = GrGpu::Make(backend, backendContext, options, context.get());
if (!context->fGpu) {
return nullptr;
}
context->fCaps = context->fGpu->refCaps();
if (!context->init(options)) {
return nullptr;
}
return context.release();
}
sk_sp<GrContext> GrContext::MakeGL(sk_sp<const GrGLInterface> interface) {
GrContextOptions defaultOptions;
return MakeGL(std::move(interface), defaultOptions);
}
sk_sp<GrContext> GrContext::MakeGL(sk_sp<const GrGLInterface> interface,
const GrContextOptions& options) {
sk_sp<GrContext> context(new GrDirectContext(kOpenGL_GrBackend));
context->fGpu = GrGLGpu::Make(std::move(interface), options, context.get());
if (!context->fGpu) {
return nullptr;
}
context->fCaps = context->fGpu->refCaps();
if (!context->init(options)) {
return nullptr;
}
return context;
}
sk_sp<GrContext> GrContext::MakeGL(const GrGLInterface* interface) {
return MakeGL(sk_ref_sp(interface));
}
sk_sp<GrContext> GrContext::MakeGL(const GrGLInterface* interface,
const GrContextOptions& options) {
return MakeGL(sk_ref_sp(interface), options);
}
sk_sp<GrContext> GrContext::MakeMock(const GrMockOptions* mockOptions) {
GrContextOptions defaultOptions;
return MakeMock(mockOptions, defaultOptions);
}
sk_sp<GrContext> GrContext::MakeMock(const GrMockOptions* mockOptions,
const GrContextOptions& options) {
sk_sp<GrContext> context(new GrDirectContext(kMock_GrBackend));
context->fGpu = GrMockGpu::Make(mockOptions, options, context.get());
if (!context->fGpu) {
return nullptr;
}
context->fCaps = context->fGpu->refCaps();
if (!context->init(options)) {
return nullptr;
}
return context;
}
#ifdef SK_VULKAN
sk_sp<GrContext> GrContext::MakeVulkan(sk_sp<const GrVkBackendContext> backendContext) {
GrContextOptions defaultOptions;
return MakeVulkan(std::move(backendContext), defaultOptions);
}
sk_sp<GrContext> GrContext::MakeVulkan(sk_sp<const GrVkBackendContext> backendContext,
const GrContextOptions& options) {
sk_sp<GrContext> context(new GrDirectContext(kVulkan_GrBackend));
context->fGpu = GrVkGpu::Make(std::move(backendContext), options, context.get());
if (!context->fGpu) {
return nullptr;
}
context->fCaps = context->fGpu->refCaps();
if (!context->init(options)) {
return nullptr;
}
return context;
}
#endif
#ifdef SK_METAL
sk_sp<GrContext> GrContext::MakeMetal(void* device, void* queue) {
GrContextOptions defaultOptions;
return MakeMetal(device, queue, defaultOptions);
}
sk_sp<GrContext> GrContext::MakeMetal(void* device, void* queue, const GrContextOptions& options) {
sk_sp<GrContext> context(new GrDirectContext(kMetal_GrBackend));
context->fGpu = GrMtlTrampoline::MakeGpu(context.get(), options, device, queue);
if (!context->fGpu) {
return nullptr;
}
if (!context->init(options)) {
return nullptr;
}
return context;
}
#endif
static int32_t gNextID = 1;
static int32_t next_id() {
int32_t id;
do {
id = sk_atomic_inc(&gNextID);
} while (id == SK_InvalidGenID);
return id;
}
sk_sp<GrContext> GrContextPriv::MakeDDL(sk_sp<GrContextThreadSafeProxy> proxy) {
sk_sp<GrContext> context(new GrDDLContext(proxy));
// Note: we aren't creating a Gpu here. This causes the resource provider & cache to
// also not be created
if (!context->init(proxy->fOptions)) {
return nullptr;
}
return context;
}
GrContext::GrContext(GrBackend backend, int32_t id)
: fBackend(backend)
, fUniqueID(SK_InvalidGenID == id ? next_id() : id) {
fResourceCache = nullptr;
fResourceProvider = nullptr;
fProxyProvider = nullptr;
fGlyphCache = nullptr;
}
bool GrContext::initCommon(const GrContextOptions& options) {
ASSERT_SINGLE_OWNER
SkASSERT(fCaps); // needs to have been initialized by derived classes
SkASSERT(fThreadSafeProxy); // needs to have been initialized by derived classes
if (fGpu) {
fCaps = fGpu->refCaps();
fResourceCache = new GrResourceCache(fCaps.get(), fUniqueID);
fResourceProvider = new GrResourceProvider(fGpu.get(), fResourceCache, &fSingleOwner,
options.fExplicitlyAllocateGPUResources);
}
fProxyProvider = new GrProxyProvider(fResourceProvider, fResourceCache, fCaps, &fSingleOwner);
if (fResourceCache) {
fResourceCache->setProxyProvider(fProxyProvider);
}
fDisableGpuYUVConversion = options.fDisableGpuYUVConversion;
fSharpenMipmappedTextures = options.fSharpenMipmappedTextures;
fDidTestPMConversions = false;
GrPathRendererChain::Options prcOptions;
prcOptions.fAllowPathMaskCaching = options.fAllowPathMaskCaching;
#if GR_TEST_UTILS
prcOptions.fGpuPathRenderers = options.fGpuPathRenderers;
#endif
if (options.fDisableDistanceFieldPaths) {
prcOptions.fGpuPathRenderers &= ~GpuPathRenderers::kSmall;
}
if (!fResourceCache) {
// DDL TODO: remove this crippling of the path renderer chain
// Disable the small path renderer bc of the proxies in the atlas. They need to be
// unified when the opLists are added back to the destination drawing manager.
prcOptions.fGpuPathRenderers &= ~GpuPathRenderers::kSmall;
}
GrAtlasTextContext::Options atlasTextContextOptions;
atlasTextContextOptions.fMaxDistanceFieldFontSize = options.fGlyphsAsPathsFontSize;
atlasTextContextOptions.fMinDistanceFieldFontSize = options.fMinDistanceFieldFontSize;
atlasTextContextOptions.fDistanceFieldVerticesAlwaysHaveW = false;
#if SK_SUPPORT_ATLAS_TEXT
if (GrContextOptions::Enable::kYes == options.fDistanceFieldGlyphVerticesAlwaysHaveW) {
atlasTextContextOptions.fDistanceFieldVerticesAlwaysHaveW = true;
}
#endif
fDrawingManager.reset(new GrDrawingManager(this, prcOptions, atlasTextContextOptions,
&fSingleOwner, options.fSortRenderTargets));
fGlyphCache = new GrGlyphCache;
fTextBlobCache.reset(new GrTextBlobCache(TextBlobCacheOverBudgetCB,
this, this->uniqueID(), SkToBool(fGpu)));
// DDL TODO: we need to think through how the task group & persistent cache
// get passed on to/shared between all the DDLRecorders created with this context.
if (options.fExecutor) {
fTaskGroup = skstd::make_unique<SkTaskGroup>(*options.fExecutor);
}
fPersistentCache = options.fPersistentCache;
return true;
}
GrContext::~GrContext() {
ASSERT_SINGLE_OWNER
if (fDrawingManager) {
fDrawingManager->cleanup();
}
for (int i = 0; i < fCleanUpData.count(); ++i) {
(*fCleanUpData[i].fFunc)(this, fCleanUpData[i].fInfo);
}
delete fResourceProvider;
delete fResourceCache;
delete fProxyProvider;
delete fGlyphCache;
}
sk_sp<GrContextThreadSafeProxy> GrContext::threadSafeProxy() {
return fThreadSafeProxy;
}
SkSurfaceCharacterization GrContextThreadSafeProxy::createCharacterization(
size_t cacheMaxResourceBytes,
const SkImageInfo& ii, const GrBackendFormat& backendFormat,
int sampleCnt, GrSurfaceOrigin origin,
const SkSurfaceProps& surfaceProps,
bool isMipMapped) {
if (!backendFormat.isValid()) {
return SkSurfaceCharacterization(); // return an invalid characterization
}
// We're assuming GrFSAAType::kMixedSamples will never be specified via this code path
GrFSAAType FSAAType = sampleCnt > 1 ? GrFSAAType::kUnifiedMSAA : GrFSAAType::kNone;
if (!fCaps->mipMapSupport()) {
isMipMapped = false;
}
GrPixelConfig config = kUnknown_GrPixelConfig;
if (!fCaps->getConfigFromBackendFormat(backendFormat, ii.colorType(), &config)) {
return SkSurfaceCharacterization(); // return an invalid characterization
}
// This surface characterization factory assumes that the resulting characterization is
// textureable.
if (!fCaps->isConfigTexturable(config)) {
return SkSurfaceCharacterization(); // return an invalid characterization
}
return SkSurfaceCharacterization(sk_ref_sp<GrContextThreadSafeProxy>(this),
cacheMaxResourceBytes,
origin, ii.width(), ii.height(), config, FSAAType, sampleCnt,
SkSurfaceCharacterization::Textureable(true),
SkSurfaceCharacterization::MipMapped(isMipMapped),
ii.refColorSpace(), surfaceProps);
}
void GrContext::abandonContext() {
ASSERT_SINGLE_OWNER
fProxyProvider->abandon();
fResourceProvider->abandon();
// Need to abandon the drawing manager first so all the render targets
// will be released/forgotten before they too are abandoned.
fDrawingManager->abandon();
// abandon first to so destructors
// don't try to free the resources in the API.
fResourceCache->abandonAll();
fGpu->disconnect(GrGpu::DisconnectType::kAbandon);
fGlyphCache->freeAll();
fTextBlobCache->freeAll();
}
void GrContext::releaseResourcesAndAbandonContext() {
ASSERT_SINGLE_OWNER
fProxyProvider->abandon();
fResourceProvider->abandon();
// Need to abandon the drawing manager first so all the render targets
// will be released/forgotten before they too are abandoned.
fDrawingManager->abandon();
// Release all resources in the backend 3D API.
fResourceCache->releaseAll();
fGpu->disconnect(GrGpu::DisconnectType::kCleanup);
fGlyphCache->freeAll();
fTextBlobCache->freeAll();
}
void GrContext::resetContext(uint32_t state) {
ASSERT_SINGLE_OWNER
fGpu->markContextDirty(state);
}
void GrContext::freeGpuResources() {
ASSERT_SINGLE_OWNER
fGlyphCache->freeAll();
fDrawingManager->freeGpuResources();
fResourceCache->purgeAllUnlocked();
}
void GrContext::purgeUnlockedResources(bool scratchResourcesOnly) {
ASSERT_SINGLE_OWNER
fResourceCache->purgeUnlockedResources(scratchResourcesOnly);
fResourceCache->purgeAsNeeded();
fTextBlobCache->purgeStaleBlobs();
}
void GrContext::performDeferredCleanup(std::chrono::milliseconds msNotUsed) {
ASSERT_SINGLE_OWNER
fResourceCache->purgeAsNeeded();
fResourceCache->purgeResourcesNotUsedSince(GrStdSteadyClock::now() - msNotUsed);
fTextBlobCache->purgeStaleBlobs();
}
void GrContext::purgeUnlockedResources(size_t bytesToPurge, bool preferScratchResources) {
ASSERT_SINGLE_OWNER
fResourceCache->purgeUnlockedResources(bytesToPurge, preferScratchResources);
}
void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
ASSERT_SINGLE_OWNER
if (resourceCount) {
*resourceCount = fResourceCache->getBudgetedResourceCount();
}
if (resourceBytes) {
*resourceBytes = fResourceCache->getBudgetedResourceBytes();
}
}
size_t GrContext::getResourceCachePurgeableBytes() const {
ASSERT_SINGLE_OWNER
return fResourceCache->getPurgeableBytes();
}
////////////////////////////////////////////////////////////////////////////////
bool GrContext::colorTypeSupportedAsImage(SkColorType colorType) const {
GrPixelConfig config = SkImageInfo2GrPixelConfig(colorType, nullptr, *this->caps());
return this->caps()->isConfigTexturable(config);
}
int GrContext::maxSurfaceSampleCountForColorType(SkColorType colorType) const {
GrPixelConfig config = SkImageInfo2GrPixelConfig(colorType, nullptr, *this->caps());
return this->caps()->maxRenderTargetSampleCount(config);
}
////////////////////////////////////////////////////////////////////////////////
void GrContext::TextBlobCacheOverBudgetCB(void* data) {
SkASSERT(data);
// TextBlobs are drawn at the SkGpuDevice level, therefore they cannot rely on
// GrRenderTargetContext to perform a necessary flush. The solution is to move drawText calls
// to below the GrContext level, but this is not trivial because they call drawPath on
// SkGpuDevice.
GrContext* context = reinterpret_cast<GrContext*>(data);
context->flush();
}
////////////////////////////////////////////////////////////////////////////////
void GrContext::flush() {
ASSERT_SINGLE_OWNER
RETURN_IF_ABANDONED
fDrawingManager->flush(nullptr);
}
GrSemaphoresSubmitted GrContext::flushAndSignalSemaphores(int numSemaphores,
GrBackendSemaphore signalSemaphores[]) {
ASSERT_SINGLE_OWNER
if (fDrawingManager->wasAbandoned()) { return GrSemaphoresSubmitted::kNo; }
return fDrawingManager->flush(nullptr, numSemaphores, signalSemaphores);
}
void GrContextPriv::flush(GrSurfaceProxy* proxy) {
ASSERT_SINGLE_OWNER_PRIV
RETURN_IF_ABANDONED_PRIV
ASSERT_OWNED_PROXY_PRIV(proxy);
fContext->fDrawingManager->flush(proxy);
}
bool sw_convert_to_premul(GrColorType srcColorType, int width, int height, size_t inRowBytes,
const void* inPixels, size_t outRowBytes, void* outPixels) {
SkColorType colorType = GrColorTypeToSkColorType(srcColorType);
if (kUnknown_SkColorType == colorType || 4 != SkColorTypeBytesPerPixel(colorType)) {
return false;
}
for (int y = 0; y < height; y++) {
SkOpts::RGBA_to_rgbA((uint32_t*) outPixels, inPixels, width);
outPixels = SkTAddOffset<void>(outPixels, outRowBytes);
inPixels = SkTAddOffset<const void>(inPixels, inRowBytes);
}
return true;
}
// TODO: This will be removed when GrSurfaceContexts are aware of their color types.
// (skbug.com/6718)
static bool valid_premul_config(GrPixelConfig config) {
switch (config) {
case kUnknown_GrPixelConfig: return false;
case kAlpha_8_GrPixelConfig: return false;
case kGray_8_GrPixelConfig: return false;
case kRGB_565_GrPixelConfig: return false;
case kRGBA_4444_GrPixelConfig: return true;
case kRGBA_8888_GrPixelConfig: return true;
case kBGRA_8888_GrPixelConfig: return true;
case kSRGBA_8888_GrPixelConfig: return true;
case kSBGRA_8888_GrPixelConfig: return true;
case kRGBA_1010102_GrPixelConfig: return true;
case kRGBA_float_GrPixelConfig: return true;
case kRG_float_GrPixelConfig: return false;
case kAlpha_half_GrPixelConfig: return false;
case kRGBA_half_GrPixelConfig: return true;
case kAlpha_8_as_Alpha_GrPixelConfig: return false;
case kAlpha_8_as_Red_GrPixelConfig: return false;
case kAlpha_half_as_Red_GrPixelConfig: return false;
case kGray_8_as_Lum_GrPixelConfig: return false;
case kGray_8_as_Red_GrPixelConfig: return false;
}
SK_ABORT("Invalid GrPixelConfig");
return false;
}
static bool valid_premul_color_type(GrColorType ct) {
switch (ct) {
case GrColorType::kUnknown: return false;
case GrColorType::kAlpha_8: return false;
case GrColorType::kRGB_565: return false;
case GrColorType::kABGR_4444: return true;
case GrColorType::kRGBA_8888: return true;
case GrColorType::kBGRA_8888: return true;
case GrColorType::kRGBA_1010102: return true;
case GrColorType::kGray_8: return false;
case GrColorType::kAlpha_F16: return false;
case GrColorType::kRGBA_F16: return true;
case GrColorType::kRG_F32: return false;
case GrColorType::kRGBA_F32: return true;
}
SK_ABORT("Invalid GrColorType");
return false;
}
static bool valid_pixel_conversion(GrColorType cpuColorType, GrPixelConfig gpuConfig,
bool premulConversion) {
// We only allow premul <-> unpremul conversions for some formats
if (premulConversion &&
(!valid_premul_color_type(cpuColorType) || !valid_premul_config(gpuConfig))) {
return false;
}
return true;
}
static bool pm_upm_must_round_trip(GrColorType cpuColorType, const SkColorSpace* cpuColorSpace) {
return !cpuColorSpace &&
(GrColorType::kRGBA_8888 == cpuColorType || GrColorType::kBGRA_8888 == cpuColorType);
}
// TODO: This will be removed when GrSurfaceContexts are aware of their color types.
// (skbug.com/6718)
static bool pm_upm_must_round_trip(GrPixelConfig surfaceConfig,
const SkColorSpace* surfaceColorSpace) {
return !surfaceColorSpace &&
(kRGBA_8888_GrPixelConfig == surfaceConfig || kBGRA_8888_GrPixelConfig == surfaceConfig);
}
static GrSRGBConversion determine_write_pixels_srgb_conversion(GrColorType srcColorType,
const SkColorSpace* srcColorSpace,
GrSRGBEncoded dstSRGBEncoded,
const SkColorSpace* dstColorSpace,
const GrCaps& caps) {
// No support for sRGB-encoded alpha.
if (GrColorTypeIsAlphaOnly(srcColorType)) {
return GrSRGBConversion::kNone;
}
// No conversions without GPU support for sRGB. (Legacy mode)
if (!caps.srgbSupport()) {
return GrSRGBConversion::kNone;
}
// If the GrSurfaceContext has no color space then it is in legacy mode.
if (!dstColorSpace) {
return GrSRGBConversion::kNone;
}
bool srcColorSpaceIsSRGB = srcColorSpace && srcColorSpace->gammaCloseToSRGB();
bool dstColorSpaceIsSRGB = dstColorSpace->gammaCloseToSRGB();
// For now we are assuming that if color space of the dst does not have sRGB gamma then the
// texture format is not sRGB encoded and vice versa. Note that we already checked for "legacy"
// mode being forced on by caps above. This may change in the future. We will then have to
// perform shader based conversions.
SkASSERT(dstColorSpaceIsSRGB == (GrSRGBEncoded::kYes == dstSRGBEncoded));
if (srcColorSpaceIsSRGB == dstColorSpaceIsSRGB) {
return GrSRGBConversion::kNone;
}
return srcColorSpaceIsSRGB ? GrSRGBConversion::kSRGBToLinear : GrSRGBConversion::kLinearToSRGB;
}
static GrSRGBConversion determine_read_pixels_srgb_conversion(GrSRGBEncoded srcSRGBEncoded,
const SkColorSpace* srcColorSpace,
GrColorType dstColorType,
const SkColorSpace* dstColorSpace,
const GrCaps& caps) {
// This is symmetrical with the write version.
switch (determine_write_pixels_srgb_conversion(dstColorType, dstColorSpace, srcSRGBEncoded,
srcColorSpace, caps)) {
case GrSRGBConversion::kNone: return GrSRGBConversion::kNone;
case GrSRGBConversion::kLinearToSRGB: return GrSRGBConversion::kSRGBToLinear;
case GrSRGBConversion::kSRGBToLinear: return GrSRGBConversion::kLinearToSRGB;
}
return GrSRGBConversion::kNone;
}
bool GrContextPriv::writeSurfacePixels(GrSurfaceContext* dst, int left, int top, int width,
int height, GrColorType srcColorType,
SkColorSpace* srcColorSpace, const void* buffer,
size_t rowBytes, uint32_t pixelOpsFlags) {
#ifndef SK_LEGACY_GPU_PIXEL_OPS
return this->writeSurfacePixels2(dst, left, top, width, height, srcColorType, srcColorSpace,
buffer, rowBytes, pixelOpsFlags);
#endif
// TODO: Color space conversion
ASSERT_SINGLE_OWNER_PRIV
RETURN_FALSE_IF_ABANDONED_PRIV
SkASSERT(dst);
ASSERT_OWNED_PROXY_PRIV(dst->asSurfaceProxy());
GR_CREATE_TRACE_MARKER_CONTEXT("GrContextPriv", "writeSurfacePixels", fContext);
if (!dst->asSurfaceProxy()->instantiate(this->resourceProvider())) {
return false;
}
GrSurfaceProxy* dstProxy = dst->asSurfaceProxy();
GrSurface* dstSurface = dstProxy->priv().peekSurface();
// The src is unpremul but the dst is premul -> premul the src before or as part of the write
const bool premul = SkToBool(kUnpremul_PixelOpsFlag & pixelOpsFlags);
if (!valid_pixel_conversion(srcColorType, dstProxy->config(), premul)) {
return false;
}
// We need to guarantee round-trip conversion if we are reading and writing 8888 non-sRGB data,
// without any color spaces attached, and the caller wants us to premul.
bool useConfigConversionEffect =
premul && pm_upm_must_round_trip(srcColorType, srcColorSpace) &&
pm_upm_must_round_trip(dstProxy->config(), dst->colorSpaceInfo().colorSpace());
// Are we going to try to premul as part of a draw? For the non-legacy case, we always allow
// this. GrConfigConversionEffect fails on some GPUs, so only allow this if it works perfectly.
bool premulOnGpu = premul &&
(!useConfigConversionEffect || fContext->validPMUPMConversionExists());
// Trim the params here so that if we wind up making a temporary surface it can be as small as
// necessary and because GrGpu::getWritePixelsInfo requires it.
if (!GrSurfacePriv::AdjustWritePixelParams(dstSurface->width(), dstSurface->height(),
GrColorTypeBytesPerPixel(srcColorType), &left, &top,
&width, &height, &buffer, &rowBytes)) {
return false;
}
GrGpu::DrawPreference drawPreference = premulOnGpu ? GrGpu::kCallerPrefersDraw_DrawPreference
: GrGpu::kNoDraw_DrawPreference;
GrGpu::WritePixelTempDrawInfo tempDrawInfo;
GrSRGBConversion srgbConversion = determine_write_pixels_srgb_conversion(
srcColorType, srcColorSpace, GrPixelConfigIsSRGBEncoded(dstProxy->config()),
dst->colorSpaceInfo().colorSpace(), *fContext->caps());
if (!fContext->fGpu->getWritePixelsInfo(dstSurface, dstProxy->origin(), width, height,
srcColorType, srgbConversion, &drawPreference,
&tempDrawInfo)) {
return false;
}
if (!(kDontFlush_PixelOpsFlag & pixelOpsFlags) && dstSurface->surfacePriv().hasPendingIO()) {
this->flush(nullptr); // MDB TODO: tighten this
}
sk_sp<GrTextureProxy> tempProxy;
if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
tempProxy = this->proxyProvider()->createProxy(tempDrawInfo.fTempSurfaceDesc,
SkBackingFit::kApprox,
SkBudgeted::kYes);
if (!tempProxy && GrGpu::kRequireDraw_DrawPreference == drawPreference) {
return false;
}
}
// temp buffer for doing sw premul conversion, if needed.
SkAutoSTMalloc<128 * 128, uint32_t> tmpPixels(0);
// We need to do sw premul if we were unable to create a RT for drawing, or if we can't do the
// premul on the GPU
if (premul && (!tempProxy || !premulOnGpu)) {
size_t tmpRowBytes = 4 * width;
tmpPixels.reset(width * height);
if (!sw_convert_to_premul(srcColorType, width, height, rowBytes, buffer, tmpRowBytes,
tmpPixels.get())) {
return false;
}
rowBytes = tmpRowBytes;
buffer = tmpPixels.get();
}
if (tempProxy) {
auto fp = GrSimpleTextureEffect::Make(tempProxy, SkMatrix::I());
if (premulOnGpu) {
fp = fContext->createUPMToPMEffect(std::move(fp), useConfigConversionEffect);
}
fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), tempDrawInfo.fSwizzle);
if (!fp) {
return false;
}
if (!tempProxy->instantiate(this->resourceProvider())) {
return false;
}
GrTexture* texture = tempProxy->priv().peekTexture();
if (tempProxy->priv().hasPendingIO()) {
this->flush(tempProxy.get());
}
if (!fContext->fGpu->writePixels(texture, tempProxy->origin(), 0, 0, width, height,
tempDrawInfo.fWriteColorType, buffer, rowBytes)) {
return false;
}
tempProxy = nullptr;
SkMatrix matrix;
matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
GrRenderTargetContext* renderTargetContext = dst->asRenderTargetContext();
if (!renderTargetContext) {
return false;
}
GrPaint paint;
paint.addColorFragmentProcessor(std::move(fp));
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
paint.setAllowSRGBInputs(dst->colorSpaceInfo().isGammaCorrect() ||
GrPixelConfigIsSRGB(dst->colorSpaceInfo().config()));
SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, matrix, rect,
nullptr);
if (kFlushWrites_PixelOp & pixelOpsFlags) {
this->flushSurfaceWrites(renderTargetContext->asRenderTargetProxy());
}
} else {
return fContext->fGpu->writePixels(dstSurface, dstProxy->origin(), left, top, width, height,
srcColorType, buffer, rowBytes);
}
return true;
}
bool GrContextPriv::readSurfacePixels(GrSurfaceContext* src, int left, int top, int width,
int height, GrColorType dstColorType,
SkColorSpace* dstColorSpace, void* buffer, size_t rowBytes,
uint32_t flags) {
// TODO: Color space conversion
ASSERT_SINGLE_OWNER_PRIV
RETURN_FALSE_IF_ABANDONED_PRIV
SkASSERT(src);
ASSERT_OWNED_PROXY_PRIV(src->asSurfaceProxy());
GR_CREATE_TRACE_MARKER_CONTEXT("GrContextPriv", "readSurfacePixels", fContext);
// MDB TODO: delay this instantiation until later in the method
if (!src->asSurfaceProxy()->instantiate(this->resourceProvider())) {
return false;
}
GrSurfaceProxy* srcProxy = src->asSurfaceProxy();
GrSurface* srcSurface = srcProxy->priv().peekSurface();
// The src is premul but the dst is unpremul -> unpremul the src after or as part of the read
bool unpremul = SkToBool(kUnpremul_PixelOpsFlag & flags);
if (!valid_pixel_conversion(dstColorType, srcProxy->config(), unpremul)) {
return false;
}
// We need to guarantee round-trip conversion if we are reading and writing 8888 non-sRGB data,
// without any color spaces attached, and the caller wants us to unpremul.
bool useConfigConversionEffect =
unpremul &&
pm_upm_must_round_trip(srcProxy->config(), src->colorSpaceInfo().colorSpace()) &&
pm_upm_must_round_trip(dstColorType, dstColorSpace);
// Are we going to try to unpremul as part of a draw? For the non-legacy case, we always allow
// this. GrConfigConversionEffect fails on some GPUs, so only allow this if it works perfectly.
bool unpremulOnGpu = unpremul &&
(!useConfigConversionEffect || fContext->validPMUPMConversionExists());
// Adjust the params so that if we wind up using an intermediate surface we've already done
// all the trimming and the temporary can be the min size required.
if (!GrSurfacePriv::AdjustReadPixelParams(srcSurface->width(), srcSurface->height(),
GrColorTypeBytesPerPixel(dstColorType), &left, &top,
&width, &height, &buffer, &rowBytes)) {
return false;
}
GrGpu::DrawPreference drawPreference = unpremulOnGpu ? GrGpu::kCallerPrefersDraw_DrawPreference
: GrGpu::kNoDraw_DrawPreference;
GrGpu::ReadPixelTempDrawInfo tempDrawInfo;
GrSRGBConversion srgbConversion = determine_read_pixels_srgb_conversion(
GrPixelConfigIsSRGBEncoded(srcProxy->config()), src->colorSpaceInfo().colorSpace(),
dstColorType, dstColorSpace, *fContext->caps());
if (!fContext->fGpu->getReadPixelsInfo(srcSurface, srcProxy->origin(), width, height, rowBytes,
dstColorType, srgbConversion, &drawPreference,
&tempDrawInfo)) {
return false;
}
if (!(kDontFlush_PixelOpsFlag & flags) && srcSurface->surfacePriv().hasPendingWrite()) {
this->flush(nullptr); // MDB TODO: tighten this
}
sk_sp<GrSurfaceProxy> proxyToRead = src->asSurfaceProxyRef();
bool didTempDraw = false;
if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
if (SkBackingFit::kExact == tempDrawInfo.fTempSurfaceFit) {
// We only respect this when the entire src is being read. Otherwise we can trigger too
// many odd ball texture sizes and trash the cache.
if (width != srcSurface->width() || height != srcSurface->height()) {
tempDrawInfo.fTempSurfaceFit= SkBackingFit::kApprox;
}
}
// TODO: Need to decide the semantics of this function for color spaces. Do we support
// conversion to a passed-in color space? For now, specifying nullptr means that this
// path will do no conversion, so it will match the behavior of the non-draw path. For
// now we simply infer an sRGB color space if the config is sRGB in order to avoid an
// illegal combination.
sk_sp<SkColorSpace> colorSpace;
if (GrPixelConfigIsSRGB(tempDrawInfo.fTempSurfaceDesc.fConfig)) {
colorSpace = SkColorSpace::MakeSRGB();
}
sk_sp<GrRenderTargetContext> tempRTC =
fContext->makeDeferredRenderTargetContext(tempDrawInfo.fTempSurfaceFit,
tempDrawInfo.fTempSurfaceDesc.fWidth,
tempDrawInfo.fTempSurfaceDesc.fHeight,
tempDrawInfo.fTempSurfaceDesc.fConfig,
std::move(colorSpace),
tempDrawInfo.fTempSurfaceDesc.fSampleCnt,
GrMipMapped::kNo,
tempDrawInfo.fTempSurfaceDesc.fOrigin);
if (tempRTC) {
// Adding discard to appease vulkan validation warning about loading uninitialized data
// on draw
tempRTC->discard();
SkMatrix textureMatrix = SkMatrix::MakeTrans(SkIntToScalar(left), SkIntToScalar(top));
sk_sp<GrTextureProxy> proxy = src->asTextureProxyRef();
auto fp = GrSimpleTextureEffect::Make(std::move(proxy), textureMatrix);
if (unpremulOnGpu) {
fp = fContext->createPMToUPMEffect(std::move(fp), useConfigConversionEffect);
// We no longer need to do this on CPU after the read back.
unpremul = false;
}
fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), tempDrawInfo.fSwizzle);
if (!fp) {
return false;
}
GrPaint paint;
paint.addColorFragmentProcessor(std::move(fp));
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
paint.setAllowSRGBInputs(true);
SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
tempRTC->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(), rect,
nullptr);
proxyToRead = tempRTC->asTextureProxyRef();
left = 0;
top = 0;
didTempDraw = true;
}
}
if (!proxyToRead) {
return false;
}
if (GrGpu::kRequireDraw_DrawPreference == drawPreference && !didTempDraw) {
return false;
}
GrColorType colorTypeToRead = dstColorType;
if (didTempDraw) {
this->flushSurfaceWrites(proxyToRead.get());
colorTypeToRead = tempDrawInfo.fReadColorType;
}
if (!proxyToRead->instantiate(this->resourceProvider())) {
return false;
}
GrSurface* surfaceToRead = proxyToRead->priv().peekSurface();
if (!fContext->fGpu->readPixels(surfaceToRead, proxyToRead->origin(), left, top, width, height,
colorTypeToRead, buffer, rowBytes)) {
return false;
}
// Perform umpremul conversion if we weren't able to perform it as a draw.
if (unpremul) {
SkColorType colorType = GrColorTypeToSkColorType(dstColorType);
if (kUnknown_SkColorType == colorType || 4 != SkColorTypeBytesPerPixel(colorType)) {
return false;
}
for (int y = 0; y < height; y++) {
SkUnpremultiplyRow<false>((uint32_t*) buffer, (const uint32_t*) buffer, width);
buffer = SkTAddOffset<void>(buffer, rowBytes);
}
}
return true;
}
bool GrContextPriv::writeSurfacePixels2(GrSurfaceContext* dst, int left, int top, int width,
int height, GrColorType srcColorType,
SkColorSpace* srcColorSpace, const void* buffer,
size_t rowBytes, uint32_t pixelOpsFlags) {
ASSERT_SINGLE_OWNER_PRIV
RETURN_FALSE_IF_ABANDONED_PRIV
SkASSERT(dst);
SkASSERT(buffer);
ASSERT_OWNED_PROXY_PRIV(dst->asSurfaceProxy());
GR_CREATE_TRACE_MARKER_CONTEXT("GrContextPriv", "writeSurfacePixels2", fContext);
if (GrColorType::kUnknown == srcColorType) {
return false;
}
if (!dst->asSurfaceProxy()->instantiate(this->resourceProvider())) {
return false;
}
GrSurfaceProxy* dstProxy = dst->asSurfaceProxy();
GrSurface* dstSurface = dstProxy->priv().peekSurface();
if (!GrSurfacePriv::AdjustWritePixelParams(dstSurface->width(), dstSurface->height(),
GrColorTypeBytesPerPixel(srcColorType), &left, &top,
&width, &height, &buffer, &rowBytes)) {
return false;
}
if (!fContext->caps()->surfaceSupportsWritePixels(dstSurface)) {
GrSurfaceDesc desc;
desc.fConfig = dstProxy->config();
desc.fWidth = width;
desc.fHeight = height;
desc.fSampleCnt = 1;
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
auto tempProxy =
this->proxyProvider()->createProxy(desc, SkBackingFit::kApprox, SkBudgeted::kYes);
if (!tempProxy) {
return false;
}
auto tempCtx = this->drawingManager()->makeTextureContext(
tempProxy, dst->colorSpaceInfo().refColorSpace());
if (!tempCtx) {
return false;
}
if (!this->writeSurfacePixels2(tempCtx.get(), 0, 0, width, height, srcColorType,
srcColorSpace, buffer, rowBytes, pixelOpsFlags)) {
return false;
}
return dst->copy(tempProxy.get(), SkIRect::MakeWH(width, height), {left, top});
}
// TODO: Make GrSurfaceContext know its alpha type and pass src buffer's alpha type.
bool premul = SkToBool(kUnpremul_PixelOpsFlag & pixelOpsFlags);
bool convert = premul;
if (!valid_pixel_conversion(srcColorType, dstProxy->config(), premul)) {
return false;
}
GrColorType allowedColorType =
fContext->caps()->supportedWritePixelsColorType(dstProxy->config(), srcColorType);
convert = convert || (srcColorType != allowedColorType);
if (!dst->colorSpaceInfo().colorSpace()) {
// "Legacy" mode - no color space conversions.
srcColorSpace = nullptr;
}
convert = convert || !SkColorSpace::Equals(srcColorSpace, dst->colorSpaceInfo().colorSpace());
std::unique_ptr<char[]> tempBuffer;
if (convert) {
auto srcSkColorType = GrColorTypeToSkColorType(srcColorType);
auto dstSkColorType = GrColorTypeToSkColorType(allowedColorType);
if (kUnknown_SkColorType == srcSkColorType || kUnknown_SkColorType == dstSkColorType) {
return false;
}
auto srcAlphaType = premul ? kUnpremul_SkAlphaType : kPremul_SkAlphaType;
SkPixmap src(SkImageInfo::Make(width, height, srcSkColorType, srcAlphaType,
sk_ref_sp(srcColorSpace)),
buffer, rowBytes);
auto tempSrcII = SkImageInfo::Make(width, height, dstSkColorType, kPremul_SkAlphaType,
dst->colorSpaceInfo().refColorSpace());
auto size = tempSrcII.computeMinByteSize();
if (!size) {
return false;
}
tempBuffer.reset(new char[size]);
SkPixmap tempSrc(tempSrcII, tempBuffer.get(), tempSrcII.minRowBytes());
if (!src.readPixels(tempSrc)) {
return false;
}
srcColorType = allowedColorType;
buffer = tempSrc.addr();
rowBytes = tempSrc.rowBytes();
if (dstProxy->origin() == kBottomLeft_GrSurfaceOrigin) {
std::unique_ptr<char[]> row(new char[rowBytes]);
for (int y = 0; y < height / 2; ++y) {
memcpy(row.get(), tempSrc.addr(0, y), rowBytes);
memcpy(tempSrc.writable_addr(0, y), tempSrc.addr(0, height - 1 - y), rowBytes);
memcpy(tempSrc.writable_addr(0, height - 1 - y), row.get(), rowBytes);
}
top = dstProxy->height() - top - height;
}
} else if (dstProxy->origin() == kBottomLeft_GrSurfaceOrigin) {
size_t trimRowBytes = GrColorTypeBytesPerPixel(srcColorType) * width;
tempBuffer.reset(new char[trimRowBytes * height]);
char* dst = reinterpret_cast<char*>(tempBuffer.get()) + trimRowBytes * (height - 1);
const char* src = reinterpret_cast<const char*>(buffer);
for (int i = 0; i < height; ++i, src += rowBytes, dst -= trimRowBytes) {
memcpy(dst, src, trimRowBytes);
}
buffer = tempBuffer.get();
rowBytes = trimRowBytes;
top = dstProxy->height() - top - height;
}
if (!(kDontFlush_PixelOpsFlag & pixelOpsFlags) && dstSurface->surfacePriv().hasPendingIO()) {
this->flush(nullptr); // MDB TODO: tighten this
}
return this->getGpu()->writePixels(dstSurface, left, top, width, height, srcColorType, buffer,
rowBytes);
}
void GrContextPriv::prepareSurfaceForExternalIO(GrSurfaceProxy* proxy) {
ASSERT_SINGLE_OWNER_PRIV
RETURN_IF_ABANDONED_PRIV
SkASSERT(proxy);
ASSERT_OWNED_PROXY_PRIV(proxy);
fContext->fDrawingManager->prepareSurfaceForExternalIO(proxy, 0, nullptr);
}
void GrContextPriv::flushSurfaceWrites(GrSurfaceProxy* proxy) {
ASSERT_SINGLE_OWNER_PRIV
RETURN_IF_ABANDONED_PRIV
SkASSERT(proxy);
ASSERT_OWNED_PROXY_PRIV(proxy);
if (proxy->priv().hasPendingWrite()) {
this->flush(proxy);
}
}
void GrContextPriv::flushSurfaceIO(GrSurfaceProxy* proxy) {
ASSERT_SINGLE_OWNER_PRIV
RETURN_IF_ABANDONED_PRIV
SkASSERT(proxy);
ASSERT_OWNED_PROXY_PRIV(proxy);
if (proxy->priv().hasPendingIO()) {
this->flush(proxy);
}
}
////////////////////////////////////////////////////////////////////////////////
sk_sp<GrSurfaceContext> GrContextPriv::makeWrappedSurfaceContext(sk_sp<GrSurfaceProxy> proxy,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* props) {
ASSERT_SINGLE_OWNER_PRIV
// sRGB pixel configs may only be used with near-sRGB gamma color spaces.
if (GrPixelConfigIsSRGB(proxy->config())) {
if (!colorSpace || !colorSpace->gammaCloseToSRGB()) {
return nullptr;
}
}
if (proxy->asRenderTargetProxy()) {
return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
std::move(colorSpace), props);
} else {
SkASSERT(proxy->asTextureProxy());
SkASSERT(!props);
return this->drawingManager()->makeTextureContext(std::move(proxy), std::move(colorSpace));
}
}
sk_sp<GrSurfaceContext> GrContextPriv::makeDeferredSurfaceContext(const GrSurfaceDesc& dstDesc,
GrMipMapped mipMapped,
SkBackingFit fit,
SkBudgeted isDstBudgeted,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* props) {
sk_sp<GrTextureProxy> proxy;
if (GrMipMapped::kNo == mipMapped) {
proxy = this->proxyProvider()->createProxy(dstDesc, fit, isDstBudgeted);
} else {
SkASSERT(SkBackingFit::kExact == fit);
proxy = this->proxyProvider()->createMipMapProxy(dstDesc, isDstBudgeted);
}
if (!proxy) {
return nullptr;
}
return this->makeWrappedSurfaceContext(std::move(proxy), std::move(colorSpace), props);
}
sk_sp<GrTextureContext> GrContextPriv::makeBackendTextureContext(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
sk_sp<SkColorSpace> colorSpace) {
ASSERT_SINGLE_OWNER_PRIV
sk_sp<GrSurfaceProxy> proxy = this->proxyProvider()->createWrappedTextureProxy(tex, origin);
if (!proxy) {
return nullptr;
}
return this->drawingManager()->makeTextureContext(std::move(proxy), std::move(colorSpace));
}
sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureRenderTargetContext(
const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* props) {
ASSERT_SINGLE_OWNER_PRIV
SkASSERT(sampleCnt > 0);
sk_sp<GrTextureProxy> proxy(this->proxyProvider()->createWrappedTextureProxy(tex, origin,
sampleCnt));
if (!proxy) {
return nullptr;
}
return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
std::move(colorSpace), props);
}
sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendRenderTargetRenderTargetContext(
const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* surfaceProps) {
ASSERT_SINGLE_OWNER_PRIV
sk_sp<GrSurfaceProxy> proxy = this->proxyProvider()->createWrappedRenderTargetProxy(backendRT,
origin);
if (!proxy) {
return nullptr;
}
return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
std::move(colorSpace),
surfaceProps);
}
sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureAsRenderTargetRenderTargetContext(
const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* props) {
ASSERT_SINGLE_OWNER_PRIV
SkASSERT(sampleCnt > 0);
sk_sp<GrSurfaceProxy> proxy(this->proxyProvider()->createWrappedRenderTargetProxy(tex, origin,
sampleCnt));
if (!proxy) {
return nullptr;
}
return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
std::move(colorSpace),
props);
}
void GrContextPriv::addOnFlushCallbackObject(GrOnFlushCallbackObject* onFlushCBObject) {
fContext->fDrawingManager->addOnFlushCallbackObject(onFlushCBObject);
}
void GrContextPriv::moveOpListsToDDL(SkDeferredDisplayList* ddl) {
fContext->fDrawingManager->moveOpListsToDDL(ddl);
}
void GrContextPriv::copyOpListsFromDDL(const SkDeferredDisplayList* ddl,
GrRenderTargetProxy* newDest) {
fContext->fDrawingManager->copyOpListsFromDDL(ddl, newDest);
}
static inline GrPixelConfig GrPixelConfigFallback(GrPixelConfig config) {
switch (config) {
case kAlpha_8_GrPixelConfig:
case kRGB_565_GrPixelConfig:
case kRGBA_4444_GrPixelConfig:
case kBGRA_8888_GrPixelConfig:
case kRGBA_1010102_GrPixelConfig:
return kRGBA_8888_GrPixelConfig;
case kSBGRA_8888_GrPixelConfig:
return kSRGBA_8888_GrPixelConfig;
case kAlpha_half_GrPixelConfig:
return kRGBA_half_GrPixelConfig;
default:
return kUnknown_GrPixelConfig;
}
}
sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContextWithFallback(
SkBackingFit fit,
int width, int height,
GrPixelConfig config,
sk_sp<SkColorSpace> colorSpace,
int sampleCnt,
GrMipMapped mipMapped,
GrSurfaceOrigin origin,
const SkSurfaceProps* surfaceProps,
SkBudgeted budgeted) {
SkASSERT(sampleCnt > 0);
if (0 == this->caps()->getRenderTargetSampleCount(sampleCnt, config)) {
config = GrPixelConfigFallback(config);
}
return this->makeDeferredRenderTargetContext(fit, width, height, config, std::move(colorSpace),
sampleCnt, mipMapped, origin, surfaceProps,
budgeted);
}
sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContext(
SkBackingFit fit,
int width, int height,
GrPixelConfig config,
sk_sp<SkColorSpace> colorSpace,
int sampleCnt,
GrMipMapped mipMapped,
GrSurfaceOrigin origin,
const SkSurfaceProps* surfaceProps,
SkBudgeted budgeted) {
SkASSERT(sampleCnt > 0);
if (this->abandoned()) {
return nullptr;
}
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = origin;
desc.fWidth = width;
desc.fHeight = height;
desc.fConfig = config;
desc.fSampleCnt = sampleCnt;
sk_sp<GrTextureProxy> rtp;
if (GrMipMapped::kNo == mipMapped) {
rtp = fProxyProvider->createProxy(desc, fit, budgeted);
} else {
rtp = fProxyProvider->createMipMapProxy(desc, budgeted);
}
if (!rtp) {
return nullptr;
}
sk_sp<GrRenderTargetContext> renderTargetContext(
fDrawingManager->makeRenderTargetContext(std::move(rtp),
std::move(colorSpace),
surfaceProps));
if (!renderTargetContext) {
return nullptr;
}
renderTargetContext->discard();
return renderTargetContext;
}
bool GrContext::abandoned() const {
ASSERT_SINGLE_OWNER
return fDrawingManager->wasAbandoned();
}
std::unique_ptr<GrFragmentProcessor> GrContext::createPMToUPMEffect(
std::unique_ptr<GrFragmentProcessor> fp, bool useConfigConversionEffect) {
ASSERT_SINGLE_OWNER
// We have specialized effects that guarantee round-trip conversion for some formats
if (useConfigConversionEffect) {
// We should have already called this->validPMUPMConversionExists() in this case
SkASSERT(fDidTestPMConversions);
// ...and it should have succeeded
SkASSERT(this->validPMUPMConversionExists());
return GrConfigConversionEffect::Make(std::move(fp), PMConversion::kToUnpremul);
} else {
// For everything else (sRGB, half-float, etc...), it doesn't make sense to try and
// explicitly round the results. Just do the obvious, naive thing in the shader.
return GrFragmentProcessor::UnpremulOutput(std::move(fp));
}
}
std::unique_ptr<GrFragmentProcessor> GrContext::createUPMToPMEffect(
std::unique_ptr<GrFragmentProcessor> fp, bool useConfigConversionEffect) {
ASSERT_SINGLE_OWNER
// We have specialized effects that guarantee round-trip conversion for these formats
if (useConfigConversionEffect) {
// We should have already called this->validPMUPMConversionExists() in this case
SkASSERT(fDidTestPMConversions);
// ...and it should have succeeded
SkASSERT(this->validPMUPMConversionExists());
return GrConfigConversionEffect::Make(std::move(fp), PMConversion::kToPremul);
} else {
// For everything else (sRGB, half-float, etc...), it doesn't make sense to try and
// explicitly round the results. Just do the obvious, naive thing in the shader.
return GrFragmentProcessor::PremulOutput(std::move(fp));
}
}
bool GrContext::validPMUPMConversionExists() {
ASSERT_SINGLE_OWNER
if (!fDidTestPMConversions) {
fPMUPMConversionsRoundTrip = GrConfigConversionEffect::TestForPreservingPMConversions(this);
fDidTestPMConversions = true;
}
// The PM<->UPM tests fail or succeed together so we only need to check one.
return fPMUPMConversionsRoundTrip;
}
//////////////////////////////////////////////////////////////////////////////
// DDL TODO: remove 'maxResources'
void GrContext::getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const {
ASSERT_SINGLE_OWNER
if (maxResources) {
*maxResources = fResourceCache->getMaxResourceCount();
}
if (maxResourceBytes) {
*maxResourceBytes = fResourceCache->getMaxResourceBytes();
}
}
void GrContext::setResourceCacheLimits(int maxResources, size_t maxResourceBytes) {
ASSERT_SINGLE_OWNER
fResourceCache->setLimits(maxResources, maxResourceBytes);
}
//////////////////////////////////////////////////////////////////////////////
void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
ASSERT_SINGLE_OWNER
fResourceCache->dumpMemoryStatistics(traceMemoryDump);
}
//////////////////////////////////////////////////////////////////////////////
SkString GrContext::dump() const {
SkDynamicMemoryWStream stream;
SkJSONWriter writer(&stream, SkJSONWriter::Mode::kPretty);
writer.beginObject();
static const char* kBackendStr[] = {
"Metal",
"OpenGL",
"Vulkan",
"Mock",
};
GR_STATIC_ASSERT(0 == kMetal_GrBackend);
GR_STATIC_ASSERT(1 == kOpenGL_GrBackend);
GR_STATIC_ASSERT(2 == kVulkan_GrBackend);
GR_STATIC_ASSERT(3 == kMock_GrBackend);
writer.appendString("backend", kBackendStr[fBackend]);
writer.appendName("caps");
fCaps->dumpJSON(&writer);
writer.appendName("gpu");
fGpu->dumpJSON(&writer);
// Flush JSON to the memory stream
writer.endObject();
writer.flush();
// Null terminate the JSON data in the memory stream
stream.write8(0);
// Allocate a string big enough to hold all the data, then copy out of the stream
SkString result(stream.bytesWritten());
stream.copyToAndReset(result.writable_str());
return result;
}