GrBackendTextureImageGenerator Class Reference

#include <GrBackendTextureImageGenerator.h>

Inheritance diagram for GrBackendTextureImageGenerator:

Public Member Functions
	~GrBackendTextureImageGenerator () override
Public Member Functions inherited from GrTextureGenerator
bool	isTextureGenerator () const final
GrSurfaceProxyView	generateTexture (GrRecordingContext *, const SkImageInfo &info, skgpu::Mipmapped mipmapped, GrImageTexGenPolicy)
virtual GrSurfaceOrigin	origin () const
Public Member Functions inherited from SkImageGenerator
virtual	~SkImageGenerator ()
uint32_t	uniqueID () const
sk_sp< SkData >	refEncodedData ()
const SkImageInfo &	getInfo () const
bool	isValid (GrRecordingContext *context) const
bool	isProtected () const
bool	getPixels (const SkImageInfo &info, void *pixels, size_t rowBytes)
bool	getPixels (const SkPixmap &pm)
bool	queryYUVAInfo (const SkYUVAPixmapInfo::SupportedDataTypes &supportedDataTypes, SkYUVAPixmapInfo *yuvaPixmapInfo) const
bool	getYUVAPlanes (const SkYUVAPixmaps &yuvaPixmaps)

Static Public Member Functions
static std::unique_ptr< GrTextureGenerator >	Make (const sk_sp< GrTexture > &, GrSurfaceOrigin, std::unique_ptr< GrSemaphore >, SkColorType, SkAlphaType, sk_sp< SkColorSpace >)

Protected Member Functions
bool	onIsValid (GrRecordingContext *context) const override
bool	onIsProtected () const override
GrSurfaceProxyView	onGenerateTexture (GrRecordingContext *, const SkImageInfo &, skgpu::Mipmapped mipmapped, GrImageTexGenPolicy) override
Protected Member Functions inherited from GrTextureGenerator
	GrTextureGenerator (const SkImageInfo &info, uint32_t uniqueId=kNeedNewImageUniqueID)
Protected Member Functions inherited from SkImageGenerator
	SkImageGenerator (const SkImageInfo &info, uint32_t uniqueId=kNeedNewImageUniqueID)
virtual sk_sp< SkData >	onRefEncodedData ()
virtual bool	onGetPixels (const SkImageInfo &, void *, size_t, const Options &)
virtual bool	onQueryYUVAInfo (const SkYUVAPixmapInfo::SupportedDataTypes &, SkYUVAPixmapInfo *) const
virtual bool	onGetYUVAPlanes (const SkYUVAPixmaps &)

Additional Inherited Members
Protected Attributes inherited from SkImageGenerator
const SkImageInfo	fInfo
Static Protected Attributes inherited from SkImageGenerator
static constexpr int	kNeedNewImageUniqueID = 0

Detailed Description

Definition at line 33 of file GrBackendTextureImageGenerator.h.

Constructor & Destructor Documentation

~GrBackendTextureImageGenerator()

GrBackendTextureImageGenerator::~GrBackendTextureImageGenerator ( )

override

Definition at line 75 of file GrBackendTextureImageGenerator.cpp.

                                                                {
    fRefHelper->unref();
}

Member Function Documentation

Make()

std::unique_ptr< GrTextureGenerator > GrBackendTextureImageGenerator::Make ( const sk_sp< GrTexture > &  texture, GrSurfaceOrigin  origin, std::unique_ptr< GrSemaphore >  semaphore, SkColorType  colorType, SkAlphaType  alphaType, sk_sp< SkColorSpace >  colorSpace  )

static

Definition at line 42 of file GrBackendTextureImageGenerator.cpp.

                                                                     {
    GrDirectContext* dContext = texture->getContext();
 
    if (!dContext->priv().caps()->areColorTypeAndFormatCompatible(
                SkColorTypeToGrColorType(colorType), texture->backendFormat())) {
        return nullptr;
    }
 
    SkColorInfo info(colorType, alphaType, std::move(colorSpace));
    return std::unique_ptr<GrTextureGenerator>(new GrBackendTextureImageGenerator(
            info,
            texture,
            origin,
            dContext->directContextID(),
            std::move(semaphore)));
}

onGenerateTexture()

GrSurfaceProxyView GrBackendTextureImageGenerator::onGenerateTexture ( GrRecordingContext *  rContext, const SkImageInfo &  info, skgpu::Mipmapped  mipmapped, GrImageTexGenPolicy  texGenPolicy  )

overrideprotectedvirtual

Implements GrTextureGenerator.

Definition at line 94 of file GrBackendTextureImageGenerator.cpp.

                                          {
    SkASSERT(rContext);
    SkASSERT_RELEASE(info.dimensions() == fBackendTexture.dimensions());
 
    // We currently limit GrBackendTextureImageGenerators to direct contexts since
    // only Flutter uses them and doesn't use recording/DDL contexts. Ideally, the
    // cross context texture functionality can be subsumed by the thread-safe cache
    // working with utility contexts.
    auto dContext = rContext->asDirectContext();
    if (!dContext) {
        return {};
    }
 
    if (dContext->backend() != fBackendTexture.backend()) {
        return {};
    }
    if (info.colorType() != this->getInfo().colorType()) {
        return {};
    }
 
    auto proxyProvider = dContext->priv().proxyProvider();
 
    fBorrowingMutex.acquire();
    sk_sp<skgpu::RefCntedCallback> releaseProcHelper;
    if (fRefHelper->fBorrowingContextID.isValid()) {
        if (fRefHelper->fBorrowingContextID != dContext->directContextID()) {
            fBorrowingMutex.release();
            rContext->priv().printWarningMessage(
                    "GrBackendTextureImageGenerator: Trying to use texture on two GrContexts!\n");
            return {};
        } else {
            SkASSERT(fRefHelper->fBorrowingContextReleaseProc);
            // Ref the release proc to be held by the proxy we make below
            releaseProcHelper = sk_ref_sp(fRefHelper->fBorrowingContextReleaseProc);
        }
    } else {
        SkASSERT(!fRefHelper->fBorrowingContextReleaseProc);
        // The ref we add to fRefHelper here will be passed into and owned by the
        // skgpu::RefCntedCallback.
        fRefHelper->ref();
        releaseProcHelper =
                skgpu::RefCntedCallback::Make(ReleaseRefHelper_TextureReleaseProc, fRefHelper);
        fRefHelper->fBorrowingContextReleaseProc = releaseProcHelper.get();
    }
    fRefHelper->fBorrowingContextID = dContext->directContextID();
    if (!fRefHelper->fBorrowedTextureKey.isValid()) {
        static const auto kDomain = skgpu::UniqueKey::GenerateDomain();
        skgpu::UniqueKey::Builder builder(&fRefHelper->fBorrowedTextureKey, kDomain, 1);
        builder[0] = this->uniqueID();
    }
    fBorrowingMutex.release();
 
    SkASSERT(fRefHelper->fBorrowingContextID == dContext->directContextID());
 
    GrBackendFormat backendFormat = fBackendTexture.getBackendFormat();
    SkASSERT(backendFormat.isValid());
 
    GrColorType grColorType = SkColorTypeToGrColorType(info.colorType());
 
    skgpu::Mipmapped textureIsMipMapped =
            fBackendTexture.hasMipmaps() ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo;
 
    // Ganesh assumes that, when wrapping a mipmapped backend texture from a client, that its
    // mipmaps are fully fleshed out.
    GrMipmapStatus mipmapStatus = fBackendTexture.hasMipmaps()
            ? GrMipmapStatus::kValid : GrMipmapStatus::kNotAllocated;
 
    skgpu::Swizzle readSwizzle = dContext->priv().caps()->getReadSwizzle(backendFormat,
                                                                         grColorType);
 
    // Must make copies of member variables to capture in the lambda since this image generator may
    // be deleted before we actually execute the lambda.
    sk_sp<GrTextureProxy> proxy = proxyProvider->createLazyProxy(
            [refHelper = fRefHelper, releaseProcHelper, backendTexture = fBackendTexture](
                    GrResourceProvider* resourceProvider,
                    const GrSurfaceProxy::LazySurfaceDesc&) -> GrSurfaceProxy::LazyCallbackResult {
                if (refHelper->fSemaphore) {
                    resourceProvider->priv().gpu()->waitSemaphore(refHelper->fSemaphore.get());
                }
 
                // If a client re-draws the same image multiple times, the texture we return
                // will be cached and re-used. If they draw a subset, though, we may be
                // re-called. In that case, we want to re-use the borrowed texture we've
                // previously created.
                sk_sp<GrTexture> tex;
                SkASSERT(refHelper->fBorrowedTextureKey.isValid());
                auto surf = resourceProvider->findByUniqueKey<GrSurface>(
                        refHelper->fBorrowedTextureKey);
                if (surf) {
                    SkASSERT(surf->asTexture());
                    tex = sk_ref_sp(surf->asTexture());
                } else {
                    // We just gained access to the texture. If we're on the original
                    // context, we could use the original texture, but we'd have no way of
                    // detecting that it's no longer in-use. So we always make a wrapped
                    // copy, where the release proc informs us that the context is done with
                    // it. This is unfortunate - we'll have two texture objects referencing
                    // the same GPU object. However, no client can ever see the original
                    // texture, so this should be safe. We make the texture uncacheable so
                    // that the release proc is called ASAP.
                    tex = resourceProvider->wrapBackendTexture(
                            backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
                            kRead_GrIOType);
                    if (!tex) {
                        return {};
                    }
                    tex->setRelease(releaseProcHelper);
                    tex->resourcePriv().setUniqueKey(refHelper->fBorrowedTextureKey);
                }
                // We use keys to avoid re-wrapping the GrBackendTexture in a GrTexture.
                // This is unrelated to the whatever SkImage key may be assigned to the
                // proxy.
                return {std::move(tex), true, GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced};
            },
            backendFormat,
            fBackendTexture.dimensions(),
            textureIsMipMapped,
            mipmapStatus,
            GrInternalSurfaceFlags::kReadOnly,
            SkBackingFit::kExact,
            skgpu::Budgeted::kNo,
            GrProtected::kNo,
            GrSurfaceProxy::UseAllocator::kYes,
            "BackendTextureImageGenerator");
    if (!proxy) {
        return {};
    }
 
    if (texGenPolicy == GrImageTexGenPolicy::kDraw &&
        (mipmapped == skgpu::Mipmapped::kNo || proxy->mipmapped() == skgpu::Mipmapped::kYes)) {
        // If we have the correct mip support, we're done
        return GrSurfaceProxyView(std::move(proxy), fSurfaceOrigin, readSwizzle);
    } else {
        skgpu::Budgeted budgeted = texGenPolicy == GrImageTexGenPolicy::kNew_Uncached_Unbudgeted
                                           ? skgpu::Budgeted::kNo
                                           : skgpu::Budgeted::kYes;
 
        auto copy = GrSurfaceProxy::Copy(dContext,
                                         std::move(proxy),
                                         fSurfaceOrigin,
                                         mipmapped,
                                         SkIRect::MakeWH(info.width(), info.height()),
                                         SkBackingFit::kExact,
                                         budgeted,
                                         /*label=*/"BackendTextureImageGenerator_GenerateTexture");
        return {std::move(copy), fSurfaceOrigin, readSwizzle};
    }
}

onIsProtected()

bool GrBackendTextureImageGenerator::onIsProtected ( ) const

overrideprotectedvirtual

Reimplemented from SkImageGenerator.

Definition at line 79 of file GrBackendTextureImageGenerator.cpp.

                                                         {
    return fBackendTexture.isProtected();
}

onIsValid()

bool GrBackendTextureImageGenerator::onIsValid ( GrRecordingContext *  context ) const

inlineoverrideprotectedvirtual

Reimplemented from SkImageGenerator.

Definition at line 42 of file GrBackendTextureImageGenerator.h.

                                                               {
        if (context && context->abandoned()) {
            return false;
        }
        return true;
    }

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/GrBackendTextureImageGenerator.h
• third_party/skia/src/gpu/ganesh/GrBackendTextureImageGenerator.cpp