#include <SkImage_Lazy.h>

Inheritance diagram for SkImage_Lazy:

Classes
class	ScopedGenerator

struct	Validator

Public Member Functions
	SkImage_Lazy (Validator *validator)

bool	isValid (GrRecordingContext *) const override

bool	onHasMipmaps () const override

bool	onIsProtected () const override

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

sk_sp< SkData >	onRefEncoded () const override

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

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

bool	getROPixels (GrDirectContext , SkBitmap , CachingHint) const override

SkImage_Base::Type	type () const override

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

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

void	addUniqueIDListener (sk_sp< SkIDChangeListener >) const

sk_sp< SkCachedData >	getPlanes (const SkYUVAPixmapInfo::SupportedDataTypes &supportedDataTypes, SkYUVAPixmaps *pixmaps) const

sk_sp< SharedGenerator >	generator () const

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 bool	onReadPixels (GrDirectContext , const SkImageInfo &dstInfo, void dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint) const =0

virtual bool	onHasMipmaps () const =0

virtual bool	onIsProtected () const =0

virtual SkMipmap *	onPeekMips () const

sk_sp< SkMipmap >	refMips () const

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

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

virtual GrImageContext *	context () const

virtual GrDirectContext *	directContext () const

virtual void	generatingSurfaceIsDeleted ()

virtual bool	getROPixels (GrDirectContext , SkBitmap , CachingHint=kAllow_CachingHint) const =0

virtual sk_sp< SkImage >	onMakeSubset (GrDirectContext *, const SkIRect &) const =0

virtual sk_sp< SkData >	onRefEncoded () const

virtual bool	onAsLegacyBitmap (GrDirectContext , SkBitmap ) const

virtual Type	type () const =0

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 >	onMakeColorTypeAndColorSpace (SkColorType, sk_sp< SkColorSpace >, GrDirectContext *) const =0

virtual sk_sp< SkImage >	onReinterpretColorSpace (sk_sp< SkColorSpace >) const =0

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

virtual sk_sp< SkImage >	onMakeSubset (skgpu::graphite::Recorder *, const SkIRect &, RequiredProperties) const =0

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

virtual bool	isTextureBacked () const =0

virtual size_t	textureSize () const =0

virtual bool	isValid (GrRecordingContext *context) const =0

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

virtual sk_sp< SkImage >	makeSubset (GrDirectContext *direct, const SkIRect &subset) const =0

virtual sk_sp< SkImage >	makeSubset (skgpu::graphite::Recorder *, const SkIRect &subset, RequiredProperties) const =0

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

virtual bool	isLazyGenerated () const =0

virtual sk_sp< SkImage >	makeColorSpace (GrDirectContext *direct, sk_sp< SkColorSpace > target) const =0

virtual sk_sp< SkImage >	makeColorSpace (skgpu::graphite::Recorder *, sk_sp< SkColorSpace > targetColorSpace, RequiredProperties) const =0

virtual sk_sp< SkImage >	makeColorTypeAndColorSpace (GrDirectContext *direct, SkColorType targetColorType, sk_sp< SkColorSpace > targetCS) const =0

virtual sk_sp< SkImage >	makeColorTypeAndColorSpace (skgpu::graphite::Recorder *, SkColorType targetColorType, sk_sp< SkColorSpace > targetColorSpace, RequiredProperties) const =0

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

Protected Member Functions
virtual bool	readPixelsProxy (GrDirectContext *, const SkPixmap &) const

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

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 >)

Detailed Description

Definition at line 38 of file SkImage_Lazy.h.

Constructor & Destructor Documentation

◆ SkImage_Lazy()

SkImage_Lazy::SkImage_Lazy ( Validator * validator )

Definition at line 100 of file SkImage_Lazy.cpp.

    : SkImage_Base(validator->fInfo, validator->fUniqueID)
    , fSharedGenerator(std::move(validator->fSharedGenerator))
{
    SkASSERT(fSharedGenerator);
}

Member Function Documentation

◆ addUniqueIDListener()

void SkImage_Lazy::addUniqueIDListener ( sk_sp< SkIDChangeListener > listener ) const

Definition at line 275 of file SkImage_Lazy.cpp.

                                                                               {
    fUniqueIDListeners.add(std::move(listener));
}

◆ generator()

sk_sp< SharedGenerator > SkImage_Lazy::generator ( ) const

Definition at line 153 of file SkImage_Lazy.cpp.

                                                     {
    return fSharedGenerator;
}

◆ getPlanes()

sk_sp< SkCachedData > SkImage_Lazy::getPlanes	(	const SkYUVAPixmapInfo::SupportedDataTypes &	supportedDataTypes,
		SkYUVAPixmaps *	pixmaps
	)		const

Definition at line 245 of file SkImage_Lazy.cpp.

                                          {
    ScopedGenerator generator(fSharedGenerator);
 
    sk_sp<SkCachedData> data(SkYUVPlanesCache::FindAndRef(generator->uniqueID(), yuvaPixmaps));
 
    if (data) {
        SkASSERT(yuvaPixmaps->isValid());
        SkASSERT(yuvaPixmaps->yuvaInfo().dimensions() == this->dimensions());
        return data;
    }
    SkYUVAPixmapInfo yuvaPixmapInfo;
    if (!generator->queryYUVAInfo(supportedDataTypes, &yuvaPixmapInfo) ||
        yuvaPixmapInfo.yuvaInfo().dimensions() != this->dimensions()) {
        return nullptr;
    }
    data.reset(SkResourceCache::NewCachedData(yuvaPixmapInfo.computeTotalBytes()));
    SkYUVAPixmaps tempPixmaps = SkYUVAPixmaps::FromExternalMemory(yuvaPixmapInfo,
                                                                  data->writable_data());
    SkASSERT(tempPixmaps.isValid());
    if (!generator->getYUVAPlanes(tempPixmaps)) {
        return nullptr;
    }
    // Decoding is done, cache the resulting YUV planes
    *yuvaPixmaps = tempPixmaps;
    SkYUVPlanesCache::Add(this->uniqueID(), data.get(), *yuvaPixmaps);
    return data;
}

◆ getROPixels()

bool SkImage_Lazy::getROPixels	(	GrDirectContext *	ctx,
		SkBitmap *	bitmap,
		SkImage::CachingHint	chint
	)		const

overridevirtual

Implements SkImage_Base.

Definition at line 107 of file SkImage_Lazy.cpp.

                                                               {
    auto check_output_bitmap = [bitmap]() {
        SkASSERT(bitmap->isImmutable());
        SkASSERT(bitmap->getPixels());
        (void)bitmap;
    };
 
    auto desc = SkBitmapCacheDesc::Make(this);
    if (SkBitmapCache::Find(desc, bitmap)) {
        check_output_bitmap();
        return true;
    }
 
    if (SkImage::kAllow_CachingHint == chint) {
        SkPixmap pmap;
        SkBitmapCache::RecPtr cacheRec = SkBitmapCache::Alloc(desc, this->imageInfo(), &pmap);
        if (!cacheRec) {
            return false;
        }
        bool success = false;
        {   // make sure ScopedGenerator goes out of scope before we try readPixelsProxy
            success = ScopedGenerator(fSharedGenerator)->getPixels(pmap);
        }
        if (!success && !this->readPixelsProxy(ctx, pmap)) {
            return false;
        }
        SkBitmapCache::Add(std::move(cacheRec), bitmap);
        this->notifyAddedToRasterCache();
    } else {
        if (!bitmap->tryAllocPixels(this->imageInfo())) {
            return false;
        }
        bool success = false;
        {   // make sure ScopedGenerator goes out of scope before we try readPixelsProxy
            success = ScopedGenerator(fSharedGenerator)->getPixels(bitmap->pixmap());
        }
        if (!success && !this->readPixelsProxy(ctx, bitmap->pixmap())) {
            return false;
        }
        bitmap->setImmutable();
    }
    check_output_bitmap();
    return true;
}

◆ isValid()

bool SkImage_Lazy::isValid ( GrRecordingContext * context ) const

overridevirtual

Returns true if SkImage can be drawn on either raster surface or GPU surface. If context is nullptr, tests if SkImage draws on raster surface; otherwise, tests if SkImage draws on GPU surface associated with context.

SkImage backed by GPU texture may become invalid if associated context is invalid. lazy image may be invalid and may not draw to raster surface or GPU surface or both.

Parameters

context GPU context

Returns: true if SkImage can be drawn

example: https://fiddle.skia.org/c/@Image_isValid

Implements SkImage.

Definition at line 185 of file SkImage_Lazy.cpp.

                                                            {
    ScopedGenerator generator(fSharedGenerator);
    return generator->isValid(context);
}

◆ onHasMipmaps()

bool SkImage_Lazy::onHasMipmaps ( ) const

inlineoverridevirtual

Implements SkImage_Base.

Definition at line 57 of file SkImage_Lazy.h.

                                       {
        // TODO: Should we defer to the generator? The generator interface currently doesn't have
        // a way to provide content for levels other than via SkImageGenerator::generateTexture().
        return false;
    }

◆ onIsProtected()

bool SkImage_Lazy::onIsProtected ( ) const

overridevirtual

Implements SkImage_Base.

Definition at line 157 of file SkImage_Lazy.cpp.

                                       {
    ScopedGenerator generator(fSharedGenerator);
    return generator->isProtected();
}

◆ onMakeColorTypeAndColorSpace()

sk_sp< SkImage > SkImage_Lazy::onMakeColorTypeAndColorSpace	(	SkColorType	targetCT,
		sk_sp< SkColorSpace >	targetCS,
		GrDirectContext *
	)		const

overridevirtual

Implements SkImage_Base.

Definition at line 210 of file SkImage_Lazy.cpp.

                                                                                  {
    SkAutoMutexExclusive autoAquire(fOnMakeColorTypeAndSpaceMutex);
    if (fOnMakeColorTypeAndSpaceResult &&
        targetCT == fOnMakeColorTypeAndSpaceResult->colorType() &&
        SkColorSpace::Equals(targetCS.get(), fOnMakeColorTypeAndSpaceResult->colorSpace())) {
        return fOnMakeColorTypeAndSpaceResult;
    }
    Validator validator(fSharedGenerator, &targetCT, targetCS);
    sk_sp<SkImage> result = validator ? sk_sp<SkImage>(new SkImage_Lazy(&validator)) : nullptr;
    if (result) {
        fOnMakeColorTypeAndSpaceResult = result;
    }
    return result;
}

◆ onMakeSubset() [1/2]

sk_sp< SkImage > SkImage_Lazy::onMakeSubset	(	GrDirectContext *	,
		const SkIRect &	subset
	)		const

overridevirtual

Implements SkImage_Base.

Definition at line 191 of file SkImage_Lazy.cpp.

                                                                                       {
    // neither picture-backed nor codec-backed lazy images need the context to do readbacks.
    // The subclass for cross-context images *does* use the direct context.
    auto pixels = this->makeRasterImage(nullptr);
    return pixels ? pixels->makeSubset(nullptr, subset) : nullptr;
}

◆ onMakeSubset() [2/2]

sk_sp< SkImage > SkImage_Lazy::onMakeSubset	(	skgpu::graphite::Recorder *	,
		const SkIRect &	subset,
		RequiredProperties	props
	)		const

overridevirtual

Implements SkImage_Base.

Definition at line 198 of file SkImage_Lazy.cpp.

                                                                          {
    // TODO: can we do this more efficiently, by telling the generator we want to
    //       "realize" a subset?
    sk_sp<SkImage> nonLazyImg = this->makeRasterImage(nullptr);
    if (!nonLazyImg) {
        return nullptr;
    }
    return nonLazyImg->makeSubset(nullptr, subset, props);
}

◆ onReadPixels()

bool SkImage_Lazy::onReadPixels	(	GrDirectContext *	dContext,
		const SkImageInfo &	dstInfo,
		void *	dstPixels,
		size_t	dstRB,
		int	srcX,
		int	srcY,
		CachingHint	chint
	)		const

overridevirtual

Implements SkImage_Base.

Definition at line 162 of file SkImage_Lazy.cpp.

                                                         {
    SkBitmap bm;
    if (this->getROPixels(dContext, &bm, chint)) {
        return bm.readPixels(dstInfo, dstPixels, dstRB, srcX, srcY);
    }
    return false;
}

◆ onRefEncoded()

sk_sp< SkData > SkImage_Lazy::onRefEncoded ( ) const

overridevirtual

Reimplemented from SkImage_Base.

Definition at line 176 of file SkImage_Lazy.cpp.

                                               {
    // check that we aren't a subset or colortype/etc modification of the original
    if (fSharedGenerator->fGenerator->uniqueID() == this->uniqueID()) {
        ScopedGenerator generator(fSharedGenerator);
        return generator->refEncodedData();
    }
    return nullptr;
}

◆ onReinterpretColorSpace()

sk_sp< SkImage > SkImage_Lazy::onReinterpretColorSpace ( sk_sp< SkColorSpace > newCS ) const

finalvirtual

Implements SkImage_Base.

Definition at line 227 of file SkImage_Lazy.cpp.

                                                                                    {
    // TODO: The correct thing is to clone the generator, and modify its color space. That's hard,
    // because we don't have a clone method, and generator is public (and derived-from by clients).
    // So do the simple/inefficient thing here, and fallback to raster when this is called.
 
    // We allocate the bitmap with the new color space, then generate the image using the original.
    SkBitmap bitmap;
    if (bitmap.tryAllocPixels(this->imageInfo().makeColorSpace(std::move(newCS)))) {
        SkPixmap pixmap = bitmap.pixmap();
        pixmap.setColorSpace(this->refColorSpace());
        if (ScopedGenerator(fSharedGenerator)->getPixels(pixmap)) {
            bitmap.setImmutable();
            return bitmap.asImage();
        }
    }
    return nullptr;
}

◆ readPixelsProxy()

virtual bool SkImage_Lazy::readPixelsProxy	(	GrDirectContext *	,
		const SkPixmap &
	)		const

inlineprotectedvirtual

Reimplemented in SkImage_LazyTexture.

Definition at line 87 of file SkImage_Lazy.h.

87{ return false; }

◆ type()

SkImage_Base::Type SkImage_Lazy::type ( ) const

inlineoverridevirtual

Implements SkImage_Base.

Reimplemented in SkImage_Picture.

Definition at line 73 of file SkImage_Lazy.h.

73{ return SkImage_Base::Type::kLazy; }

SkImage_Base::Type::kLazy

@ kLazy

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

third_party/skia/src/image/SkImage_Lazy.h
third_party/skia/src/image/SkImage_Lazy.cpp

Classes

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SkImage_Lazy()

Member Function Documentation

◆ addUniqueIDListener()

◆ generator()

◆ getPlanes()

◆ getROPixels()

◆ isValid()

◆ onHasMipmaps()

◆ onIsProtected()

◆ onMakeColorTypeAndColorSpace()

◆ onMakeSubset() [1/2]

◆ onMakeSubset() [2/2]

◆ onReadPixels()

◆ onRefEncoded()

◆ onReinterpretColorSpace()

◆ readPixelsProxy()

◆ type()