#include <Image_YUVA_Graphite.h>

Inheritance diagram for skgpu::graphite::Image_YUVA:

Public Member Functions
	~Image_YUVA () override

SkImage_Base::Type	type () const override

size_t	textureSize () const override

bool	onHasMipmaps () const override

bool	onIsProtected () const override

sk_sp< SkImage >	onReinterpretColorSpace (sk_sp< SkColorSpace >) const override

const TextureProxyView &	proxyView (int channelIndex) const

std::tuple< int, int >	uvSubsampleFactors () const

const SkYUVAInfo &	yuvaInfo () const

Public Member Functions inherited from skgpu::graphite::Image_Base
	~Image_Base () override

void	notifyInUse (Recorder *) const

bool	isDynamic () const

virtual sk_sp< Image >	copyImage (Recorder *, const SkIRect &subset, Budgeted, Mipmapped, SkBackingFit) const

bool	isValid (GrRecordingContext *) const override

sk_sp< SkImage >	onMakeSubset (Recorder *, const SkIRect &, RequiredProperties) const override

sk_sp< SkImage >	makeColorTypeAndColorSpace (Recorder *, SkColorType targetCT, sk_sp< SkColorSpace > targetCS, RequiredProperties) const override

bool	onReadPixels (GrDirectContext , const SkImageInfo &dstInfo, void dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint) const override

bool	getROPixels (GrDirectContext , SkBitmap , CachingHint=kAllow_CachingHint) const override

sk_sp< SkImage >	onMakeSubset (GrDirectContext *, const SkIRect &) const override

sk_sp< SkImage >	onMakeColorTypeAndColorSpace (SkColorType, sk_sp< SkColorSpace >, GrDirectContext *) const override

void	onAsyncRescaleAndReadPixels (const SkImageInfo &, SkIRect srcRect, RescaleGamma, RescaleMode, ReadPixelsCallback, ReadPixelsContext) const override

void	onAsyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace, bool readAlpha, sk_sp< SkColorSpace >, SkIRect srcRect, SkISize dstSize, RescaleGamma, RescaleMode, ReadPixelsCallback, ReadPixelsContext) const override

Public Member Functions inherited from SkImage_Base
	~SkImage_Base () override

sk_sp< SkImage >	makeColorSpace (GrDirectContext *, sk_sp< SkColorSpace >) const override

sk_sp< SkImage >	makeColorSpace (skgpu::graphite::Recorder *, sk_sp< SkColorSpace >, RequiredProperties) const override

sk_sp< SkImage >	makeColorTypeAndColorSpace (GrDirectContext *dContext, SkColorType targetColorType, sk_sp< SkColorSpace > targetCS) const override

sk_sp< SkImage >	makeColorTypeAndColorSpace (skgpu::graphite::Recorder *, SkColorType, sk_sp< SkColorSpace >, RequiredProperties) const override

sk_sp< SkImage >	makeSubset (GrDirectContext *direct, const SkIRect &subset) const override

sk_sp< SkImage >	makeSubset (skgpu::graphite::Recorder *, const SkIRect &, RequiredProperties) const override

size_t	textureSize () const override

virtual bool	onPeekPixels (SkPixmap *) const

virtual const SkBitmap *	onPeekBitmap () const

virtual SkMipmap *	onPeekMips () const

sk_sp< SkMipmap >	refMips () const

virtual GrImageContext *	context () const

virtual GrDirectContext *	directContext () const

virtual void	generatingSurfaceIsDeleted ()

virtual sk_sp< SkData >	onRefEncoded () const

virtual bool	onAsLegacyBitmap (GrDirectContext , SkBitmap ) const

bool	isLazyGenerated () const override

bool	isRasterBacked () const

bool	isGaneshBacked () const

bool	isGraphiteBacked () const

bool	isYUVA () const

bool	isTextureBacked () const override

virtual void	notifyAddedToRasterCache () const

virtual sk_sp< SkImage >	onMakeWithMipmaps (sk_sp< SkMipmap >) const

Public Member Functions inherited from SkImage
const SkImageInfo &	imageInfo () const

int	width () const

int	height () const

SkISize	dimensions () const

SkIRect	bounds () const

uint32_t	uniqueID () const

SkAlphaType	alphaType () const

SkColorType	colorType () const

SkColorSpace *	colorSpace () const

sk_sp< SkColorSpace >	refColorSpace () const

bool	isAlphaOnly () const

bool	isOpaque () const

sk_sp< SkShader >	makeShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &, const SkMatrix *localMatrix=nullptr) const

sk_sp< SkShader >	makeShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeShader (const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeShader (const SkSamplingOptions &sampling, const SkMatrix *lm=nullptr) const

sk_sp< SkShader >	makeRawShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &, const SkMatrix *localMatrix=nullptr) const

sk_sp< SkShader >	makeRawShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeRawShader (const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeRawShader (const SkSamplingOptions &sampling, const SkMatrix *lm=nullptr) const

bool	peekPixels (SkPixmap *pixmap) const

bool	readPixels (GrDirectContext context, const SkImageInfo &dstInfo, void dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const

bool	readPixels (GrDirectContext *context, const SkPixmap &dst, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const

bool	readPixels (const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const

bool	readPixels (const SkPixmap &dst, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const

void	asyncRescaleAndReadPixels (const SkImageInfo &info, const SkIRect &srcRect, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) const

void	asyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) const

void	asyncRescaleAndReadPixelsYUVA420 (SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) const

bool	scalePixels (const SkPixmap &dst, const SkSamplingOptions &, CachingHint cachingHint=kAllow_CachingHint) const

sk_sp< SkData >	refEncodedData () const

bool	hasMipmaps () const

bool	isProtected () const

sk_sp< SkImage >	withDefaultMipmaps () const

sk_sp< SkImage >	makeNonTextureImage (GrDirectContext *=nullptr) const

sk_sp< SkImage >	makeRasterImage (GrDirectContext *, CachingHint cachingHint=kDisallow_CachingHint) const

sk_sp< SkImage >	makeRasterImage (CachingHint cachingHint=kDisallow_CachingHint) const

bool	asLegacyBitmap (SkBitmap *bitmap, LegacyBitmapMode legacyBitmapMode=kRO_LegacyBitmapMode) const

sk_sp< SkImage >	reinterpretColorSpace (sk_sp< SkColorSpace > newColorSpace) const

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Static Public Member Functions
static sk_sp< Image_YUVA >	Make (const Caps *caps, const SkYUVAInfo &yuvaInfo, SkSpan< TextureProxyView > planes, sk_sp< SkColorSpace > imageColorSpace)

static sk_sp< Image_YUVA >	WrapImages (const Caps *caps, const SkYUVAInfo &yuvaInfo, SkSpan< const sk_sp< SkImage > > images, sk_sp< SkColorSpace > imageColorSpace)

Additional Inherited Members
Public Types inherited from SkImage_Base
enum class	Type { kRaster , kRasterPinnable , kLazy , kLazyPicture , kGanesh , kGaneshYUVA , kGraphite , kGraphiteYUVA }

Public Types inherited from SkImage
enum	CachingHint { kAllow_CachingHint , kDisallow_CachingHint }

enum class	RescaleGamma : bool { kSrc , kLinear }

enum class	RescaleMode { kNearest , kLinear , kRepeatedLinear , kRepeatedCubic }

enum	LegacyBitmapMode { kRO_LegacyBitmapMode }

using	ReadPixelsContext = void *

using	ReadPixelsCallback = void(ReadPixelsContext, std::unique_ptr< const AsyncReadResult >)

Protected Member Functions inherited from skgpu::graphite::Image_Base
	Image_Base (const SkImageInfo &info, uint32_t uniqueID)

void	linkDevices (const Image_Base *)

void	linkDevice (sk_sp< Device >)

Protected Member Functions inherited from SkImage_Base
	SkImage_Base (const SkImageInfo &info, uint32_t uniqueID)

Static Protected Member Functions inherited from skgpu::graphite::Image_Base
static sk_sp< Image >	CopyAsDraw (Recorder , const Image_Base , const SkIRect &subset, const SkColorInfo &dstColorInfo, Budgeted, Mipmapped, SkBackingFit)

Detailed Description

Definition at line 21 of file Image_YUVA_Graphite.h.

Constructor & Destructor Documentation

◆ ~Image_YUVA()

skgpu::graphite::Image_YUVA::~Image_YUVA ( )

overridedefault

Member Function Documentation

◆ Make()

sk_sp< Image_YUVA > skgpu::graphite::Image_YUVA::Make	(	const Caps *	caps,
		const SkYUVAInfo &	yuvaInfo,
		SkSpan< TextureProxyView >	planes,
		sk_sp< SkColorSpace >	imageColorSpace
	)

static

Definition at line 81 of file Image_YUVA_Graphite.cpp.

                                                                        {
    if (!yuvaInfo.isValid()) {
        return nullptr;
    }
    SkImageInfo info = SkImageInfo::Make(
            yuvaInfo.dimensions(), kAssumedColorType, yuva_alpha_type(yuvaInfo), imageColorSpace);
    if (!SkImageInfoIsValid(info)) {
        return nullptr;
    }
 
    // Invoke the PlaneProxyFactoryFn for each plane and validate it against the plane config
    const int numPlanes = yuvaInfo.numPlanes();
    SkISize planeDimensions[SkYUVAInfo::kMaxPlanes];
    if (numPlanes != yuvaInfo.planeDimensions(planeDimensions)) {
        return nullptr;
    }
    uint32_t pixmapChannelmasks[SkYUVAInfo::kMaxPlanes];
    for (int i = 0; i < numPlanes; ++i) {
        if (!planes[i] || !caps->isTexturable(planes[i].proxy()->textureInfo())) {
            return nullptr;
        }
        if (planes[i].dimensions() != planeDimensions[i]) {
            return nullptr;
        }
        pixmapChannelmasks[i] = caps->channelMask(planes[i].proxy()->textureInfo());
    }
 
    // Re-arrange the proxies from planes to channels
    SkYUVAInfo::YUVALocations locations = yuvaInfo.toYUVALocations(pixmapChannelmasks);
    int expectedPlanes;
    if (!SkYUVAInfo::YUVALocation::AreValidLocations(locations, &expectedPlanes) ||
        expectedPlanes != numPlanes) {
        return nullptr;
    }
    // Y channel should match the YUVAInfo dimensions
    if (planes[locations[kY].fPlane].dimensions() != yuvaInfo.dimensions()) {
        return nullptr;
    }
    // UV channels should have planes with the same dimensions and subsampling factor.
    if (planes[locations[kU].fPlane].dimensions() != planes[locations[kV].fPlane].dimensions()) {
        return nullptr;
    }
    // If A channel is present, it should match the Y channel
    if (locations[kA].fPlane >= 0 &&
        planes[locations[kA].fPlane].dimensions() != yuvaInfo.dimensions()) {
        return nullptr;
    }
 
    if (yuvaInfo.planeSubsamplingFactors(locations[kU].fPlane) !=
        yuvaInfo.planeSubsamplingFactors(locations[kV].fPlane)) {
        return nullptr;
    }
 
    // Re-arrange into YUVA channel order and apply the location to the swizzle
    YUVAProxies channelProxies;
    for (int i = 0; i < SkYUVAInfo::kYUVAChannelCount; ++i) {
        auto [plane, channel] = locations[i];
        if (plane >= 0) {
            // Compose the YUVA location with the data swizzle. replaceSwizzle() is used since
            // selectChannelInR() effectively does the composition (vs. Swizzle::Concat).
            Swizzle channelSwizzle = planes[plane].swizzle().selectChannelInR((int) channel);
            channelProxies[i] = planes[plane].replaceSwizzle(channelSwizzle);
        } else if (i == kA) {
            // The alpha channel is allowed to be not provided, set it to an empty view
            channelProxies[i] = {};
        } else {
            SKGPU_LOG_W("YUVA channel %d does not have a valid location", i);
            return nullptr;
        }
    }
 
    return sk_sp<Image_YUVA>(new Image_YUVA(std::move(channelProxies),
                                            yuvaInfo,
                                            std::move(imageColorSpace)));
}

◆ onHasMipmaps()

bool skgpu::graphite::Image_YUVA::onHasMipmaps ( ) const

inlineoverridevirtual

Implements SkImage_Base.

Definition at line 43 of file Image_YUVA_Graphite.h.

43{ return fMipmapped == Mipmapped::kYes; }

◆ onIsProtected()

bool skgpu::graphite::Image_YUVA::onIsProtected ( ) const

inlineoverridevirtual

Implements SkImage_Base.

Definition at line 45 of file Image_YUVA_Graphite.h.

45{ return fProtected == Protected::kYes; }

◆ onReinterpretColorSpace()

sk_sp< SkImage > skgpu::graphite::Image_YUVA::onReinterpretColorSpace ( sk_sp< SkColorSpace > newCS ) const

overridevirtual

Implements SkImage_Base.

Definition at line 225 of file Image_YUVA_Graphite.cpp.

                                                                                  {
    sk_sp<Image_YUVA> view{new Image_YUVA(fProxies,
                                          fYUVAInfo,
                                          std::move(newCS))};
    // The new Image object shares the same texture planes, so it should also share linked Devices
    view->linkDevices(this);
    return view;
}

◆ proxyView()

const TextureProxyView & skgpu::graphite::Image_YUVA::proxyView ( int channelIndex ) const

inline

Definition at line 52 of file Image_YUVA_Graphite.h.

                                                              {
        SkASSERT(channelIndex >= 0 && channelIndex < SkYUVAInfo::kYUVAChannelCount);
        return fProxies[channelIndex];
    }

◆ textureSize()

size_t skgpu::graphite::Image_YUVA::textureSize ( ) const

overridevirtual

Returns an approximation of the amount of texture memory used by the image. Returns zero if the image is not texture backed or if the texture has an external format.

Implements SkImage.

Definition at line 194 of file Image_YUVA_Graphite.cpp.

                                     {
    // We could look at the plane config and plane count to determine how many different textures
    // to expect, but it's theoretically possible for an Image_YUVA to be constructed where the
    // same TextureProxy is aliased to both the U and the V planes (and similarly for the Y and A)
    // even when the plane config specifies that those channels are not packed into the same texture
    //
    // Given that it's simpler to just sum the total gpu memory of non-duplicate textures.
    size_t size = 0;
    for (int i = 0; i < SkYUVAInfo::kYUVAChannelCount; ++i) {
        if (!fProxies[i]) {
            continue; // Null channels (A) have no size.
        }
        bool repeat = false;
        for (int j = 0; j < i - 1; ++j) {
            if (fProxies[i].proxy() == fProxies[j].proxy()) {
                repeat = true;
                break;
            }
        }
        if (!repeat) {
            if (fProxies[i].proxy()->isInstantiated()) {
                size += fProxies[i].proxy()->texture()->gpuMemorySize();
            } else {
                size += fProxies[i].proxy()->uninstantiatedGpuMemorySize();
            }
        }
    }
 
    return size;
}

◆ type()

SkImage_Base::Type skgpu::graphite::Image_YUVA::type ( ) const

inlineoverridevirtual

Implements SkImage_Base.

Definition at line 39 of file Image_YUVA_Graphite.h.

39{ return SkImage_Base::Type::kGraphiteYUVA; }

SkImage_Base::Type::kGraphiteYUVA

@ kGraphiteYUVA

◆ uvSubsampleFactors()

std::tuple< int, int > skgpu::graphite::Image_YUVA::uvSubsampleFactors ( ) const

inline

Definition at line 57 of file Image_YUVA_Graphite.h.

57{ return fUVSubsampleFactors; }

◆ WrapImages()

sk_sp< Image_YUVA > skgpu::graphite::Image_YUVA::WrapImages	(	const Caps *	caps,
		const SkYUVAInfo &	yuvaInfo,
		SkSpan< const sk_sp< SkImage > >	images,
		sk_sp< SkColorSpace >	imageColorSpace
	)

static

Definition at line 160 of file Image_YUVA_Graphite.cpp.

                                                                              {
    if (SkTo<int>(images.size()) < yuvaInfo.numPlanes()) {
        return nullptr;
    }
 
    TextureProxyView planes[SkYUVAInfo::kMaxPlanes];
    for (int i = 0; i < yuvaInfo.numPlanes(); ++i) {
        planes[i] = AsView(images[i]);
        if (!planes[i]) {
            // A null image, or not graphite-backed, or not backed by a single texture.
            return nullptr;
        }
        // The YUVA shader expects to sample from the red channel for single-channel textures, so
        // reset the swizzle for alpha-only textures to compensate for that
        if (images[i]->isAlphaOnly()) {
            planes[i] = planes[i].makeSwizzle(Swizzle("aaaa"));
        }
    }
 
    sk_sp<Image_YUVA> image = Make(caps, yuvaInfo, SkSpan(planes), std::move(imageColorSpace));
    if (image) {
        // Unlike the other factories, this YUVA image shares the texture proxies with each plane
        // Image, so if those are linked to Devices, it must inherit those same links.
        for (int plane = 0; plane < yuvaInfo.numPlanes(); ++plane) {
            SkASSERT(as_IB(images[plane])->isGraphiteBacked());
            image->linkDevices(static_cast<Image_Base*>(images[plane].get()));
        }
    }
    return image;
}

◆ yuvaInfo()

const SkYUVAInfo & skgpu::graphite::Image_YUVA::yuvaInfo ( ) const

inline

Definition at line 59 of file Image_YUVA_Graphite.h.

59{ return fYUVAInfo; }

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

third_party/skia/src/gpu/graphite/Image_YUVA_Graphite.h
third_party/skia/src/gpu/graphite/Image_YUVA_Graphite.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~Image_YUVA()

Member Function Documentation

◆ Make()

◆ onHasMipmaps()

◆ onIsProtected()

◆ onReinterpretColorSpace()

◆ proxyView()

◆ textureSize()

◆ type()

◆ uvSubsampleFactors()

◆ WrapImages()

◆ yuvaInfo()