#include <Image_Base_Graphite.h>

Inheritance diagram for skgpu::graphite::Image_Base:

Public Member Functions
	~Image_Base () override

void	notifyInUse (Recorder , DrawContext drawContext) const

bool	isDynamic () const

virtual sk_sp< Image >	copyImage (Recorder *, const SkIRect &subset, Budgeted, Mipmapped, SkBackingFit, std::string_view label) 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 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
	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)

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 29 of file Image_Base_Graphite.h.

Constructor & Destructor Documentation

◆ ~Image_Base()

skgpu::graphite::Image_Base::~Image_Base ( )

overridedefault

◆ Image_Base()

skgpu::graphite::Image_Base::Image_Base	(	const SkImageInfo &	info,
		uint32_t	uniqueID
	)

protected

Definition at line 24 of file Image_Base_Graphite.cpp.

25 : SkImage_Base(info, uniqueID) {}

info

static void info(const char *fmt,...) SK_PRINTF_LIKE(1

Definition: DM.cpp:213

SkImage::uniqueID

uint32_t uniqueID() const

Definition: SkImage.h:311

SkImage::SkImage_Base

friend class SkImage_Base

Definition: SkImage.h:936

Member Function Documentation

◆ copyImage()

sk_sp< Image > skgpu::graphite::Image_Base::copyImage	(	Recorder *	recorder,
		const SkIRect &	subset,
		Budgeted	budgeted,
		Mipmapped	mipmapped,
		SkBackingFit	backingFit,
		std::string_view	label
	)		const

virtual

Reimplemented in skgpu::graphite::Image.

Definition at line 141 of file Image_Base_Graphite.cpp.

                                                               {
    return CopyAsDraw(recorder, this, subset, this->imageInfo().colorInfo(),
                      budgeted, mipmapped, backingFit, std::move(label));
}

◆ getROPixels()

bool skgpu::graphite::Image_Base::getROPixels	(	GrDirectContext *	,
		SkBitmap *	,
		CachingHint	= `kAllow_CachingHint`
	)		const

inlineoverridevirtual

Implements SkImage_Base.

Definition at line 69 of file Image_Base_Graphite.h.

71 { return false; }

◆ isDynamic()

bool skgpu::graphite::Image_Base::isDynamic ( ) const

Definition at line 122 of file Image_Base_Graphite.cpp.

                                 {
    SkAutoSpinlock lock{fDeviceLinkLock};
    int emptyCount = 0;
    if (!fLinkedDevices.empty()) {
        for (sk_sp<Device>& device : fLinkedDevices) {
            if (!device || !device->recorder() || device->unique()) {
                device.reset();
                emptyCount++;
            }
        }
        if (emptyCount == fLinkedDevices.size()) {
            fLinkedDevices.clear();
            emptyCount = 0;
        }
    }
 
    return emptyCount > 0;
}

◆ isValid()

bool skgpu::graphite::Image_Base::isValid ( GrRecordingContext * context ) const

inlineoverridevirtual

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 51 of file Image_Base_Graphite.h.

51{ return true; }

◆ linkDevice()

void skgpu::graphite::Image_Base::linkDevice ( sk_sp< Device > device )

protected

Definition at line 38 of file Image_Base_Graphite.cpp.

                                                {
    // Technically this lock isn't needed since this is only called before the Image is returned to
    // user code that could expose it to multiple threads. But this quiets threading warnings and
    // should be uncontested.
    SkAutoSpinlock lock{fDeviceLinkLock};
    fLinkedDevices.push_back(std::move(device));
}

◆ linkDevices()

void skgpu::graphite::Image_Base::linkDevices ( const Image_Base * other )

protected

Definition at line 29 of file Image_Base_Graphite.cpp.

                                                    {
    SkASSERT(other);
 
    SkAutoSpinlock lock{other->fDeviceLinkLock};
    for (const auto& device : other->fLinkedDevices) {
        this->linkDevice(device);
    }
}

◆ makeColorTypeAndColorSpace()

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

overridevirtual

Experimental. Creates SkImage in target SkColorType and SkColorSpace. Returns nullptr if SkImage could not be created.

Returns original SkImage if it is in target SkColorType and SkColorSpace.

If this image is graphite-backed, the recorder parameter is required.

Parameters

targetColorType	SkColorType of returned SkImage
targetColorSpace	SkColorSpace of returned SkImage
recorder	The Recorder in which to create the new image
RequiredProperties	properties the returned SkImage must possess (e.g. mipmaps)

Returns: created SkImage in target SkColorType and SkColorSpace

Implements SkImage.

Definition at line 197 of file Image_Base_Graphite.cpp.

                                                                                              {
    SkColorInfo dstColorInfo{targetCT, this->alphaType(), std::move(targetCS)};
    // optimization : return self if there's no color type/space change and the image's texture
    // is immutable
    if (this->imageInfo().colorInfo() == dstColorInfo && !this->isDynamic()) {
        return sk_ref_sp(this);
    }
 
    TextureProxy* proxy = get_base_proxy_for_label(this);
    SkASSERT(proxy);
    std::string label = proxy->label();
    if (label.empty()) {
        label = "ImageMakeCTandCSTexture";
    } else {
        label += "_CTandCSConversion";
    }
 
    // Use CopyAsDraw directly to perform the color space changes. The copied image is not
    // considered budgeted because this is a client-invoked API and they will own the image.
    return CopyAsDraw(recorder,
                      this,
                      this->bounds(),
                      dstColorInfo,
                      Budgeted::kNo,
                      requiredProps.fMipmapped ? Mipmapped::kYes : Mipmapped::kNo,
                      SkBackingFit::kExact,
                      label);
}

◆ notifyInUse()

void skgpu::graphite::Image_Base::notifyInUse	(	Recorder *	recorder,
		DrawContext *	drawContext
	)		const

Definition at line 46 of file Image_Base_Graphite.cpp.

                                                                               {
    SkASSERT(recorder);
 
    // The ref counts stored on each linked device are thread safe, but the Image's sk_sp's that
    // track the refs its responsible for are *not* thread safe. Use a spin lock since the majority
    // of device-linked images will be used only on the Recorder's thread. Since it should be
    // uncontended, the empty check is also done inside the lock vs. a double-checked locking
    // pattern that is non-trivial to ensure correctness in C++.
    SkAutoSpinlock lock{fDeviceLinkLock};
 
    if (!fLinkedDevices.empty()) {
        int emptyCount = 0;
        for (sk_sp<Device>& device : fLinkedDevices) {
            if (!device) {
                emptyCount++; // Already unlinked but array isn't empty yet
            } else {
                if (device->isScratchDevice()) {
                    sk_sp<Task> deviceDrawTask = device->lastDrawTask();
                    if (deviceDrawTask) {
                        // Increment the pending read count for the device's target
                        recorder->priv().addPendingRead(device->target());
                        if (drawContext) {
                            // Add a reference to the device's drawTask to `drawContext` if that's
                            // provided.
                            drawContext->recordDependency(std::move(deviceDrawTask));
                        } else {
                            // If there's no `drawContext` this notify represents a copy, so for
                            // now append the task to the root task list since that is where the
                            // subsequent copy task will go as well.
                            recorder->priv().add(std::move(deviceDrawTask));
                        }
                    } else {
                        // If there's no draw task yet, the device is being drawn into a child
                        // scratch device (backdrop filter or init-from-prev layer), and the child
                        // will later on be drawn back into the device's `drawContext`. In this case
                        // `device` should already have performed an internal flush and have no
                        // pending work, and not yet be marked immutable. The correct action at this
                        // point in time is to do nothing: the final task order in the device's
                        // DrawTask will be pre-notified tasks into the device's target, then the
                        // child's DrawTask when it's drawn back into `device`, and then any post
                        // tasks that further modify the `device`'s target.
                        SkASSERT(device->recorder() && device->recorder() == recorder);
                    }
 
                    // Scratch devices are often already marked immutable, but they are also the
                    // way in which Image finds the last snapped DrawTask so we don't unlink
                    // scratch devices. The scratch image view will be short-lived as well, or the
                    // device will transition to a non-scratch device in a future Recording and then
                    // it will be unlinked then.
                } else {
                    // Automatic flushing of image views only happens when mixing reads and writes
                    // on the originating Recorder. Draws of the view on another Recorder will
                    // always see the texture content dependent on how Recordings are inserted.
                    if (device->recorder() == recorder) {
                        // Non-scratch devices push their tasks to the root task list to maintain
                        // an order consistent with the client-triggering actions. Because of this,
                        // there's no need to add references to the `drawContext` that the device
                        // is being drawn into.
                        device->flushPendingWorkToRecorder();
                    }
                    if (!device->recorder() || device->unique()) {
                        // The device will not record any more commands that modify the texture, so
                        // the image doesn't need to be linked
                        device.reset();
                        emptyCount++;
                    }
                }
            }
        }
 
        if (emptyCount == fLinkedDevices.size()) {
            fLinkedDevices.clear();
        }
    }
}

◆ onAsyncRescaleAndReadPixels()

void skgpu::graphite::Image_Base::onAsyncRescaleAndReadPixels	(	const SkImageInfo &	info,
		SkIRect	srcRect,
		RescaleGamma	rescaleGamma,
		RescaleMode	rescaleMode,
		ReadPixelsCallback	callback,
		ReadPixelsContext	context
	)		const

overridevirtual

Default implementation does a rescale/read and then calls the callback.

Reimplemented from SkImage_Base.

Definition at line 243 of file Image_Base_Graphite.cpp.

                                                                              {
    SKGPU_LOG_W("Cannot use Ganesh async API with Graphite-backed image, use API on Context");
    callback(context, nullptr);
}

◆ onAsyncRescaleAndReadPixelsYUV420()

void skgpu::graphite::Image_Base::onAsyncRescaleAndReadPixelsYUV420	(	SkYUVColorSpace	,
		bool	readAlpha,
		sk_sp< SkColorSpace >	dstColorSpace,
		SkIRect	srcRect,
		SkISize	dstSize,
		RescaleGamma	,
		RescaleMode	,
		ReadPixelsCallback	callback,
		ReadPixelsContext	context
	)		const

overridevirtual

Default implementation does a rescale/read/yuv conversion and then calls the callback.

Reimplemented from SkImage_Base.

Definition at line 253 of file Image_Base_Graphite.cpp.

                                                                                    {
    SKGPU_LOG_W("Cannot use Ganesh async API with Graphite-backed image, use API on Context");
    callback(context, nullptr);
}

◆ onMakeColorTypeAndColorSpace()

sk_sp< SkImage > skgpu::graphite::Image_Base::onMakeColorTypeAndColorSpace	(	SkColorType	,
		sk_sp< SkColorSpace >	,
		GrDirectContext *
	)		const

overridevirtual

Implements SkImage_Base.

Definition at line 236 of file Image_Base_Graphite.cpp.

                                                                                {
    SKGPU_LOG_W("Cannot convert Graphite-backed image to Ganesh");
    return nullptr;
}

◆ onMakeSubset() [1/2]

sk_sp< SkImage > skgpu::graphite::Image_Base::onMakeSubset	(	GrDirectContext *	,
		const SkIRect &
	)		const

overridevirtual

Implements SkImage_Base.

Definition at line 231 of file Image_Base_Graphite.cpp.

                                                                              {
    SKGPU_LOG_W("Cannot convert Graphite-backed image to Ganesh");
    return nullptr;
}

◆ onMakeSubset() [2/2]

sk_sp< SkImage > skgpu::graphite::Image_Base::onMakeSubset	(	Recorder *	recorder,
		const SkIRect &	subset,
		RequiredProperties	requiredProps
	)		const

overridevirtual

Implements SkImage_Base.

Definition at line 167 of file Image_Base_Graphite.cpp.

                                                                                {
    // optimization : return self if the subset == our bounds and requirements met and the image's
    // texture is immutable
    if (this->bounds() == subset &&
        (!requiredProps.fMipmapped || this->hasMipmaps()) &&
        !this->isDynamic()) {
        return sk_ref_sp(this);
    }
 
    TextureProxy* proxy = get_base_proxy_for_label(this);
    SkASSERT(proxy);
    std::string label = proxy->label();
    if (label.empty()) {
        label = "ImageSubsetTexture";
    } else {
        label += "_Subset";
    }
 
    // The copied image is not considered budgeted because this is a client-invoked API and they
    // will own the image.
    return this->copyImage(recorder,
                           subset,
                           Budgeted::kNo,
                           requiredProps.fMipmapped ? Mipmapped::kYes : Mipmapped::kNo,
                           SkBackingFit::kExact,
                           label);
}

◆ onReadPixels()

bool skgpu::graphite::Image_Base::onReadPixels	(	GrDirectContext *	,
		const SkImageInfo &	dstInfo,
		void *	dstPixels,
		size_t	dstRowBytes,
		int	srcX,
		int	srcY,
		CachingHint
	)		const

inlineoverridevirtual

Implements SkImage_Base.

Definition at line 61 of file Image_Base_Graphite.h.

67 { return false; }

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

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~Image_Base()

◆ Image_Base()

Member Function Documentation

◆ copyImage()

◆ getROPixels()

◆ isDynamic()

◆ isValid()

◆ linkDevice()

◆ linkDevices()

◆ makeColorTypeAndColorSpace()

◆ notifyInUse()

◆ onAsyncRescaleAndReadPixels()

◆ onAsyncRescaleAndReadPixelsYUV420()

◆ onMakeColorTypeAndColorSpace()

◆ onMakeSubset() [1/2]

◆ onMakeSubset() [2/2]

◆ onReadPixels()