#include <SkSurface_Raster.h>

Inheritance diagram for SkSurface_Raster:

Public Member Functions
	SkSurface_Raster (const SkImageInfo &, void , size_t rb, void(releaseProc)(void pixels, void context), void context, const SkSurfaceProps )

	SkSurface_Raster (const SkImageInfo &info, sk_sp< SkPixelRef >, const SkSurfaceProps *)

SkImageInfo	imageInfo () const override

SkSurface_Base::Type	type () const override

SkCanvas *	onNewCanvas () override

sk_sp< SkSurface >	onNewSurface (const SkImageInfo &) override

sk_sp< SkImage >	onNewImageSnapshot (const SkIRect *subset) override

void	onWritePixels (const SkPixmap &, int x, int y) override

void	onDraw (SkCanvas , SkScalar, SkScalar, const SkSamplingOptions &, const SkPaint ) override

bool	onCopyOnWrite (ContentChangeMode) override

void	onRestoreBackingMutability () override

sk_sp< const SkCapabilities >	onCapabilities () override

Public Member Functions inherited from SkSurface_Base
	SkSurface_Base (int width, int height, const SkSurfaceProps *)

	SkSurface_Base (const SkImageInfo &, const SkSurfaceProps *)

	~SkSurface_Base () override

bool	replaceBackendTexture (const GrBackendTexture &, GrSurfaceOrigin, ContentChangeMode, TextureReleaseProc, ReleaseContext) override

bool	isRasterBacked () const

bool	isGaneshBacked () const

bool	isGraphiteBacked () const

virtual GrRecordingContext *	onGetRecordingContext () const

virtual skgpu::graphite::Recorder *	onGetRecorder () const

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

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

virtual void	onDiscard ()

virtual bool	onWait (int numSemaphores, const GrBackendSemaphore *waitSemaphores, bool deleteSemaphoresAfterWait)

virtual bool	onCharacterize (GrSurfaceCharacterization *) const

virtual bool	onIsCompatible (const GrSurfaceCharacterization &) const

SkCanvas *	getCachedCanvas ()

sk_sp< SkImage >	refCachedImage ()

bool	hasCachedImage () const

uint32_t	newGenerationID ()

Public Member Functions inherited from SkSurface
bool	isCompatible (const GrSurfaceCharacterization &characterization) const

int	width () const

int	height () const

uint32_t	generationID ()

void	notifyContentWillChange (ContentChangeMode mode)

GrRecordingContext *	recordingContext () const

skgpu::graphite::Recorder *	recorder () const

SkCanvas *	getCanvas ()

sk_sp< const SkCapabilities >	capabilities ()

sk_sp< SkSurface >	makeSurface (const SkImageInfo &imageInfo)

sk_sp< SkSurface >	makeSurface (int width, int height)

sk_sp< SkImage >	makeImageSnapshot ()

sk_sp< SkImage >	makeImageSnapshot (const SkIRect &bounds)

void	draw (SkCanvas canvas, SkScalar x, SkScalar y, const SkSamplingOptions &sampling, const SkPaint paint)

void	draw (SkCanvas canvas, SkScalar x, SkScalar y, const SkPaint paint=nullptr)

bool	peekPixels (SkPixmap *pixmap)

bool	readPixels (const SkPixmap &dst, int srcX, int srcY)

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

bool	readPixels (const SkBitmap &dst, int srcX, int srcY)

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

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

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

void	writePixels (const SkPixmap &src, int dstX, int dstY)

void	writePixels (const SkBitmap &src, int dstX, int dstY)

const SkSurfaceProps &	props () const

bool	wait (int numSemaphores, const GrBackendSemaphore *waitSemaphores, bool deleteSemaphoresAfterWait=true)

bool	characterize (GrSurfaceCharacterization *characterization) const

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Additional Inherited Members
Public Types inherited from SkSurface_Base
enum class	Type { kNull , kGanesh , kGraphite , kRaster }

Public Types inherited from SkSurface
enum	ContentChangeMode { kDiscard_ContentChangeMode , kRetain_ContentChangeMode }

enum class	BackendHandleAccess { kFlushRead , kFlushWrite , kDiscardWrite , kFlushRead_BackendHandleAccess = kFlushRead , kFlushWrite_BackendHandleAccess = kFlushWrite , kDiscardWrite_BackendHandleAccess = kDiscardWrite }

using	ReleaseContext = void *

using	TextureReleaseProc = void(*)(ReleaseContext)

using	AsyncReadResult = SkImage::AsyncReadResult

using	ReadPixelsContext = void *

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

using	RescaleGamma = SkImage::RescaleGamma

using	RescaleMode = SkImage::RescaleMode

Static Public Attributes inherited from SkSurface
static constexpr BackendHandleAccess	kFlushRead_BackendHandleAccess

static constexpr BackendHandleAccess	kFlushWrite_BackendHandleAccess

static constexpr BackendHandleAccess	kDiscardWrite_BackendHandleAccess

Protected Member Functions inherited from SkSurface
	SkSurface (int width, int height, const SkSurfaceProps *surfaceProps)

	SkSurface (const SkImageInfo &imageInfo, const SkSurfaceProps *surfaceProps)

void	dirtyGenerationID ()

Detailed Description

Definition at line 30 of file SkSurface_Raster.h.

Constructor & Destructor Documentation

◆ SkSurface_Raster() [1/2]

SkSurface_Raster::SkSurface_Raster	(	const SkImageInfo &	info,
		void *	pixels,
		size_t	rb,
		void()(void pixels, void *context)	releaseProc,
		void *	context,
		const SkSurfaceProps *	props
	)

Definition at line 58 of file SkSurface_Raster.cpp.

    : INHERITED(info, props)
{
    fBitmap.installPixels(info, pixels, rb, releaseProc, context);
    fWeOwnThePixels = false;    // We are "Direct"
}

◆ SkSurface_Raster() [2/2]

SkSurface_Raster::SkSurface_Raster	(	const SkImageInfo &	info,
		sk_sp< SkPixelRef >	pr,
		const SkSurfaceProps *	props
	)

Definition at line 67 of file SkSurface_Raster.cpp.

    : INHERITED(pr->width(), pr->height(), props)
{
    fBitmap.setInfo(info, pr->rowBytes());
    fBitmap.setPixelRef(std::move(pr), 0, 0);
    fWeOwnThePixels = true;
}

Member Function Documentation

◆ imageInfo()

SkImageInfo SkSurface_Raster::imageInfo ( ) const

inlineoverridevirtual

Returns an ImageInfo describing the surface.

Reimplemented from SkSurface.

Definition at line 38 of file SkSurface_Raster.h.

38{ return fBitmap.info(); }

SkBitmap::info

const SkImageInfo & info() const

Definition SkBitmap.h:139

◆ onCapabilities()

sk_sp< const SkCapabilities > SkSurface_Raster::onCapabilities ( )

overridevirtual

Reimplemented from SkSurface_Base.

Definition at line 154 of file SkSurface_Raster.cpp.

                                                             {
    return SkCapabilities::RasterBackend();
}

◆ onCopyOnWrite()

bool SkSurface_Raster::onCopyOnWrite ( ContentChangeMode )

overridevirtual

If the surface is about to change, we call this so that our subclass can optionally fork their backend (copy-on-write) in case it was being shared with the cachedImage.

Returns false if the backing cannot be un-shared.

Implements SkSurface_Base.

Definition at line 124 of file SkSurface_Raster.cpp.

                                                           {
    // are we sharing pixelrefs with the image?
    sk_sp<SkImage> cached(this->refCachedImage());
    SkASSERT(cached);
    if (SkBitmapImageGetPixelRef(cached.get()) == fBitmap.pixelRef()) {
        SkASSERT(fWeOwnThePixels);
        if (kDiscard_ContentChangeMode == mode) {
            if (!fBitmap.tryAllocPixels()) {
                return false;
            }
        } else {
            SkBitmap prev(fBitmap);
            if (!fBitmap.tryAllocPixels()) {
                return false;
            }
            SkASSERT(prev.info() == fBitmap.info());
            SkASSERT(prev.rowBytes() == fBitmap.rowBytes());
            memcpy(fBitmap.getPixels(), prev.getPixels(), fBitmap.computeByteSize());
        }
 
        // Now fBitmap is a deep copy of itself (and therefore different from
        // what is being used by the image. Next we update the canvas to use
        // this as its backend, so we can't modify the image's pixels anymore.
        SkASSERT(this->getCachedCanvas());
        SkBitmapDevice* bmDev = static_cast<SkBitmapDevice*>(this->getCachedCanvas()->rootDevice());
        bmDev->replaceBitmapBackendForRasterSurface(fBitmap);
    }
    return true;
}

◆ onDraw()

void SkSurface_Raster::onDraw	(	SkCanvas *	canvas,
		SkScalar	x,
		SkScalar	y,
		const SkSamplingOptions &	sampling,
		const SkPaint *	paint
	)

overridevirtual

Default implementation:

image = this->newImageSnapshot(); if (image) { image->draw(canvas, ...); image->unref(); }

Reimplemented from SkSurface_Base.

Definition at line 82 of file SkSurface_Raster.cpp.

                                                                                       {
    canvas->drawImage(fBitmap.asImage().get(), x, y, sampling, paint);
}

◆ onNewCanvas()

SkCanvas * SkSurface_Raster::onNewCanvas ( )

overridevirtual

Allocate a canvas that will draw into this surface. We will cache this canvas, to return the same object to the caller multiple times. We take ownership, and will call unref() on the canvas when we go out of scope.

Implements SkSurface_Base.

Definition at line 76 of file SkSurface_Raster.cpp.

76{ return new SkCanvas(fBitmap, this->props()); }

SkSurface_Base::SkCanvas

friend class SkCanvas

Definition SkSurface_Base.h:188

◆ onNewImageSnapshot()

sk_sp< SkImage > SkSurface_Raster::onNewImageSnapshot ( const SkIRect * subset )

overridevirtual

Allocate an SkImage that represents the current contents of the surface. This needs to be able to outlive the surface itself (if need be), and must faithfully represent the current contents, even if the surface is changed after this called (e.g. it is drawn to via its canvas).

If a subset is specified, the the impl must make a copy, rather than try to wait on copy-on-write.

Reimplemented from SkSurface_Base.

Definition at line 87 of file SkSurface_Raster.cpp.

                                                                         {
    if (subset) {
        SkASSERT(SkIRect::MakeWH(fBitmap.width(), fBitmap.height()).contains(*subset));
        SkBitmap dst;
        dst.allocPixels(fBitmap.info().makeDimensions(subset->size()));
        SkAssertResult(fBitmap.readPixels(dst.pixmap(), subset->left(), subset->top()));
        dst.setImmutable(); // key, so MakeFromBitmap doesn't make a copy of the buffer
        return dst.asImage();
    }
 
    SkCopyPixelsMode cpm = kIfMutable_SkCopyPixelsMode;
    if (fWeOwnThePixels) {
        // SkImage_raster requires these pixels are immutable for its full lifetime.
        // We'll undo this via onRestoreBackingMutability() if we can avoid the COW.
        if (SkPixelRef* pr = fBitmap.pixelRef()) {
            pr->setTemporarilyImmutable();
        }
    } else {
        cpm = kAlways_SkCopyPixelsMode;
    }
 
    // Our pixels are in memory, so read access on the snapshot SkImage could be cheap.
    // Lock the shared pixel ref to ensure peekPixels() is usable.
    return SkMakeImageFromRasterBitmap(fBitmap, cpm);
}

◆ onNewSurface()

sk_sp< SkSurface > SkSurface_Raster::onNewSurface ( const SkImageInfo & info )

overridevirtual

Implements SkSurface_Base.

Definition at line 78 of file SkSurface_Raster.cpp.

                                                                       {
    return SkSurfaces::Raster(info, &this->props());
}

◆ onRestoreBackingMutability()

void SkSurface_Raster::onRestoreBackingMutability ( )

overridevirtual

Signal the surface to remind its backing store that it's mutable again. Called only when we didn't copy-on-write; we assume the copies start mutable.

Reimplemented from SkSurface_Base.

Definition at line 117 of file SkSurface_Raster.cpp.

                                                  {
    SkASSERT(!this->hasCachedImage());  // Shouldn't be any snapshots out there.
    if (SkPixelRef* pr = fBitmap.pixelRef()) {
        pr->restoreMutability();
    }
}

◆ onWritePixels()

void SkSurface_Raster::onWritePixels	(	const SkPixmap &	src,
		int	x,
		int	y
	)

overridevirtual

Implements SkSurface_Base.

Definition at line 113 of file SkSurface_Raster.cpp.

                                                                      {
    fBitmap.writePixels(src, x, y);
}

◆ type()

SkSurface_Base::Type SkSurface_Raster::type ( ) const

inlineoverridevirtual

Reimplemented from SkSurface_Base.

Definition at line 41 of file SkSurface_Raster.h.

41{ return SkSurface_Base::Type::kRaster; }

SkSurface_Base::Type::kRaster

@ kRaster

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

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SkSurface_Raster() [1/2]

◆ SkSurface_Raster() [2/2]

Member Function Documentation

◆ imageInfo()

◆ onCapabilities()

◆ onCopyOnWrite()

◆ onDraw()

◆ onNewCanvas()

◆ onNewImageSnapshot()

◆ onNewSurface()

◆ onRestoreBackingMutability()

◆ onWritePixels()

◆ type()