From 17616469ddf8843033e00082843a48c11e611163 Mon Sep 17 00:00:00 2001 From: Kevin Lubick Date: Thu, 28 Oct 2021 15:06:25 -0400 Subject: [PATCH] Reland "Remove GPU-related calls from SkSurface.h when !SK_SUPPORT_GPU" This is a reland of 74105c5d09ce02e23ea73f875b692b0db17ced74 Original change's description: > Remove GPU-related calls from SkSurface.h when !SK_SUPPORT_GPU > > Change-Id: Idca02c40bd8f540919702f09ba2a809acc377e67 > Bug: skia:12584 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/464295 > Reviewed-by: Brian Osman Bug: skia:12584 Change-Id: Id679bd61eddb341598e149a7a87e3ba9f0dc8943 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/464976 Reviewed-by: Brian Osman --- RELEASE_NOTES.txt | 7 +- include/core/SkSurface.h | 208 ++++++++++++++++++++----------------- src/image/SkSurface.cpp | 90 +++++++--------- src/image/SkSurface_Base.h | 23 ++-- 4 files changed, 170 insertions(+), 158 deletions(-) diff --git a/RELEASE_NOTES.txt b/RELEASE_NOTES.txt index 149e884339..a5bb6b916e 100644 --- a/RELEASE_NOTES.txt +++ b/RELEASE_NOTES.txt @@ -14,8 +14,11 @@ Milestone 97 MakeFromYUVAPixmaps, MakePromiseTexture, MakePromiseYUVATexture, MakeBackendTextureFromSkImage, flush, flushAndSubmit, getBackendTexture, makeTextureImage. These were all no-ops anyway when just the CPU backend was compiled in. - -* * * + * The following functions and methods are not defined in SkSurface when SK_SUPPORT_GPU is 0: + MakeFromBackendTexture, MakeFromBackendRenderTarget, MakeRenderTarget, + getBackendTexture, getBackendRenderTarget, replaceBackendTexture. flush() with parameters + was removed as well. These were all no-ops anyway when just the CPU backend was compiled in + (noting that flush() and flushAndSubmit() are still no-ops on the CPU backend). Milestone 96 ------------ diff --git a/include/core/SkSurface.h b/include/core/SkSurface.h index 557dd377bf..5fd546b978 100644 --- a/include/core/SkSurface.h +++ b/include/core/SkSurface.h @@ -13,7 +13,9 @@ #include "include/core/SkRefCnt.h" #include "include/core/SkSurfaceProps.h" +#if SK_SUPPORT_GPU #include "include/gpu/GrTypes.h" +#endif #if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26 #include @@ -34,6 +36,7 @@ class GrBackendTexture; class GrDirectContext; class GrRecordingContext; class GrRenderTarget; +enum GrSurfaceOrigin: int; /** \class SkSurface SkSurface is responsible for managing the pixels that a canvas draws into. The pixels can be @@ -249,6 +252,110 @@ public: RenderTargetReleaseProc releaseProc = nullptr, ReleaseContext releaseContext = nullptr); + /** Returns SkSurface on GPU indicated by context. Allocates memory for + pixels, based on the width, height, and SkColorType in SkImageInfo. budgeted + selects whether allocation for pixels is tracked by context. imageInfo + describes the pixel format in SkColorType, and transparency in + SkAlphaType, and color matching in SkColorSpace. + + sampleCount requests the number of samples per pixel. + Pass zero to disable multi-sample anti-aliasing. The request is rounded + up to the next supported count, or rounded down if it is larger than the + maximum supported count. + + surfaceOrigin pins either the top-left or the bottom-left corner to the origin. + + shouldCreateWithMips hints that SkImage returned by makeImageSnapshot() is mip map. + + If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr. + + @param context GPU context + @param imageInfo width, height, SkColorType, SkAlphaType, SkColorSpace; + width, or height, or both, may be zero + @param sampleCount samples per pixel, or 0 to disable full scene anti-aliasing + @param surfaceProps LCD striping orientation and setting for device independent + fonts; may be nullptr + @param shouldCreateWithMips hint that SkSurface will host mip map images + @return SkSurface if all parameters are valid; otherwise, nullptr + */ + static sk_sp MakeRenderTarget(GrRecordingContext* context, SkBudgeted budgeted, + const SkImageInfo& imageInfo, + int sampleCount, GrSurfaceOrigin surfaceOrigin, + const SkSurfaceProps* surfaceProps, + bool shouldCreateWithMips = false); + + /** Returns SkSurface on GPU indicated by context. Allocates memory for + pixels, based on the width, height, and SkColorType in SkImageInfo. budgeted + selects whether allocation for pixels is tracked by context. imageInfo + describes the pixel format in SkColorType, and transparency in + SkAlphaType, and color matching in SkColorSpace. + + sampleCount requests the number of samples per pixel. + Pass zero to disable multi-sample anti-aliasing. The request is rounded + up to the next supported count, or rounded down if it is larger than the + maximum supported count. + + SkSurface bottom-left corner is pinned to the origin. + + @param context GPU context + @param imageInfo width, height, SkColorType, SkAlphaType, SkColorSpace, + of raster surface; width, or height, or both, may be zero + @param sampleCount samples per pixel, or 0 to disable multi-sample anti-aliasing + @param surfaceProps LCD striping orientation and setting for device independent + fonts; may be nullptr + @return SkSurface if all parameters are valid; otherwise, nullptr + */ + static sk_sp MakeRenderTarget(GrRecordingContext* context, SkBudgeted budgeted, + const SkImageInfo& imageInfo, int sampleCount, + const SkSurfaceProps* surfaceProps) { +#if SK_SUPPORT_GPU + return MakeRenderTarget(context, budgeted, imageInfo, sampleCount, + kBottomLeft_GrSurfaceOrigin, surfaceProps); +#else + // TODO(kjlubick, scroggo) Remove this once Android is updated. + return nullptr; +#endif + } + + /** Returns SkSurface on GPU indicated by context. Allocates memory for + pixels, based on the width, height, and SkColorType in SkImageInfo. budgeted + selects whether allocation for pixels is tracked by context. imageInfo + describes the pixel format in SkColorType, and transparency in + SkAlphaType, and color matching in SkColorSpace. + + SkSurface bottom-left corner is pinned to the origin. + + @param context GPU context + @param imageInfo width, height, SkColorType, SkAlphaType, SkColorSpace, + of raster surface; width, or height, or both, may be zero + @return SkSurface if all parameters are valid; otherwise, nullptr + */ + static sk_sp MakeRenderTarget(GrRecordingContext* context, SkBudgeted budgeted, + const SkImageInfo& imageInfo) { +#if SK_SUPPORT_GPU + if (!imageInfo.width() || !imageInfo.height()) { + return nullptr; + } + return MakeRenderTarget(context, budgeted, imageInfo, 0, kBottomLeft_GrSurfaceOrigin, + nullptr); +#else + // TODO(kjlubick, scroggo) Remove this once Android is updated. + return nullptr; +#endif + } + + /** Returns SkSurface on GPU indicated by context that is compatible with the provided + characterization. budgeted selects whether allocation for pixels is tracked by context. + + @param context GPU context + @param characterization description of the desired SkSurface + @return SkSurface if all parameters are valid; otherwise, nullptr + */ + static sk_sp MakeRenderTarget(GrRecordingContext* context, + const SkSurfaceCharacterization& characterization, + SkBudgeted budgeted); + + #if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26 /** Private. Creates SkSurface from Android hardware buffer. @@ -333,99 +440,6 @@ public: SK_API_AVAILABLE(macos(10.11), ios(9.0)); #endif - /** Returns SkSurface on GPU indicated by context. Allocates memory for - pixels, based on the width, height, and SkColorType in SkImageInfo. budgeted - selects whether allocation for pixels is tracked by context. imageInfo - describes the pixel format in SkColorType, and transparency in - SkAlphaType, and color matching in SkColorSpace. - - sampleCount requests the number of samples per pixel. - Pass zero to disable multi-sample anti-aliasing. The request is rounded - up to the next supported count, or rounded down if it is larger than the - maximum supported count. - - surfaceOrigin pins either the top-left or the bottom-left corner to the origin. - - shouldCreateWithMips hints that SkImage returned by makeImageSnapshot() is mip map. - - If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr. - - @param context GPU context - @param imageInfo width, height, SkColorType, SkAlphaType, SkColorSpace; - width, or height, or both, may be zero - @param sampleCount samples per pixel, or 0 to disable full scene anti-aliasing - @param surfaceProps LCD striping orientation and setting for device independent - fonts; may be nullptr - @param shouldCreateWithMips hint that SkSurface will host mip map images - @return SkSurface if all parameters are valid; otherwise, nullptr - */ - static sk_sp MakeRenderTarget(GrRecordingContext* context, SkBudgeted budgeted, - const SkImageInfo& imageInfo, - int sampleCount, GrSurfaceOrigin surfaceOrigin, - const SkSurfaceProps* surfaceProps, - bool shouldCreateWithMips = false); - - /** Returns SkSurface on GPU indicated by context. Allocates memory for - pixels, based on the width, height, and SkColorType in SkImageInfo. budgeted - selects whether allocation for pixels is tracked by context. imageInfo - describes the pixel format in SkColorType, and transparency in - SkAlphaType, and color matching in SkColorSpace. - - sampleCount requests the number of samples per pixel. - Pass zero to disable multi-sample anti-aliasing. The request is rounded - up to the next supported count, or rounded down if it is larger than the - maximum supported count. - - SkSurface bottom-left corner is pinned to the origin. - - @param context GPU context - @param imageInfo width, height, SkColorType, SkAlphaType, SkColorSpace, - of raster surface; width, or height, or both, may be zero - @param sampleCount samples per pixel, or 0 to disable multi-sample anti-aliasing - @param surfaceProps LCD striping orientation and setting for device independent - fonts; may be nullptr - @return SkSurface if all parameters are valid; otherwise, nullptr - */ - static sk_sp MakeRenderTarget(GrRecordingContext* context, SkBudgeted budgeted, - const SkImageInfo& imageInfo, int sampleCount, - const SkSurfaceProps* surfaceProps) { - return MakeRenderTarget(context, budgeted, imageInfo, sampleCount, - kBottomLeft_GrSurfaceOrigin, surfaceProps); - } - - /** Returns SkSurface on GPU indicated by context. Allocates memory for - pixels, based on the width, height, and SkColorType in SkImageInfo. budgeted - selects whether allocation for pixels is tracked by context. imageInfo - describes the pixel format in SkColorType, and transparency in - SkAlphaType, and color matching in SkColorSpace. - - SkSurface bottom-left corner is pinned to the origin. - - @param context GPU context - @param imageInfo width, height, SkColorType, SkAlphaType, SkColorSpace, - of raster surface; width, or height, or both, may be zero - @return SkSurface if all parameters are valid; otherwise, nullptr - */ - static sk_sp MakeRenderTarget(GrRecordingContext* context, SkBudgeted budgeted, - const SkImageInfo& imageInfo) { - if (!imageInfo.width() || !imageInfo.height()) { - return nullptr; - } - return MakeRenderTarget(context, budgeted, imageInfo, 0, kBottomLeft_GrSurfaceOrigin, - nullptr); - } - - /** Returns SkSurface on GPU indicated by context that is compatible with the provided - characterization. budgeted selects whether allocation for pixels is tracked by context. - - @param context GPU context - @param characterization description of the desired SkSurface - @return SkSurface if all parameters are valid; otherwise, nullptr - */ - static sk_sp MakeRenderTarget(GrRecordingContext* context, - const SkSurfaceCharacterization& characterization, - SkBudgeted budgeted); - /** Is this surface compatible with the provided characterization? This method can be used to determine if an existing SkSurface is a viable destination @@ -497,6 +511,7 @@ public: */ GrRecordingContext* recordingContext(); +#if SK_SUPPORT_GPU enum BackendHandleAccess { kFlushRead_BackendHandleAccess, //!< back-end object is readable kFlushWrite_BackendHandleAccess, //!< back-end object is writable @@ -559,6 +574,7 @@ public: ContentChangeMode mode = kRetain_ContentChangeMode, TextureReleaseProc textureReleaseProc = nullptr, ReleaseContext releaseContext = nullptr); +#endif /** Returns SkCanvas that draws into SkSurface. Subsequent calls return the same SkCanvas. SkCanvas returned is managed and owned by SkSurface, and is deleted when SkSurface @@ -887,6 +903,7 @@ public: kPresent, //!< back-end surface will be used for presenting to screen }; +#if SK_SUPPORT_GPU /** Issues pending SkSurface commands to the GPU-backed API objects and resolves any SkSurface MSAA. A call to GrDirectContext::submit is always required to ensure work is actually sent to the gpu. Some specific API details: @@ -921,7 +938,7 @@ public: the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the client is still responsible for deleting any initialized semaphores. - Regardleess of semaphore submission the context will still be flushed. It should be + Regardless of semaphore submission the context will still be flushed. It should be emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not happen. It simply means there were no semaphores submitted to the GPU. A caller should only take this as a failure if they passed in semaphores to be submitted. @@ -979,8 +996,9 @@ public: */ GrSemaphoresSubmitted flush(const GrFlushInfo& info, const GrBackendSurfaceMutableState* newState = nullptr); +#endif // SK_SUPPORT_GPU - void flush() { this->flush({}); } + void flush(); /** Inserts a list of GPU semaphores that the current GPU-backed API must wait on before executing any more commands on the GPU for this surface. If this call returns false, then diff --git a/src/image/SkSurface.cpp b/src/image/SkSurface.cpp index 253a946442..a604484a5d 100644 --- a/src/image/SkSurface.cpp +++ b/src/image/SkSurface.cpp @@ -8,7 +8,6 @@ #include #include #include "include/core/SkCanvas.h" -#include "include/gpu/GrBackendSurface.h" #include "src/core/SkAutoPixmapStorage.h" #include "src/core/SkImagePriv.h" #include "src/core/SkPaintPriv.h" @@ -16,6 +15,10 @@ #include "src/image/SkRescaleAndReadPixels.h" #include "src/image/SkSurface_Base.h" +#ifdef SK_SUPPORT_GPU +#include "include/gpu/GrBackendSurface.h" +#endif + SkSurfaceProps::SkSurfaceProps() : fFlags(0), fPixelGeometry(kUnknown_SkPixelGeometry) {} SkSurfaceProps::SkSurfaceProps(uint32_t flags, SkPixelGeometry pg) @@ -51,6 +54,7 @@ GrRecordingContext* SkSurface_Base::onGetRecordingContext() { return nullptr; } +#if SK_SUPPORT_GPU GrBackendTexture SkSurface_Base::onGetBackendTexture(BackendHandleAccess) { return GrBackendTexture(); // invalid } @@ -65,6 +69,7 @@ bool SkSurface_Base::onReplaceBackendTexture(const GrBackendTexture&, ReleaseContext) { return false; } +#endif void SkSurface_Base::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkSamplingOptions& sampling, const SkPaint* paint) { @@ -313,6 +318,28 @@ GrRecordingContext* SkSurface::recordingContext() { return asSB(this)->onGetRecordingContext(); } +bool SkSurface::wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores, + bool deleteSemaphoresAfterWait) { + return asSB(this)->onWait(numSemaphores, waitSemaphores, deleteSemaphoresAfterWait); +} + +bool SkSurface::characterize(SkSurfaceCharacterization* characterization) const { + return asConstSB(this)->onCharacterize(characterization); +} + +bool SkSurface::isCompatible(const SkSurfaceCharacterization& characterization) const { + return asConstSB(this)->onIsCompatible(characterization); +} + +bool SkSurface::draw(sk_sp ddl, int xOffset, int yOffset) { + if (xOffset != 0 || yOffset != 0) { + return false; // the offsets currently aren't supported + } + + return asSB(this)->onDraw(std::move(ddl), { xOffset, yOffset }); +} + +#if SK_SUPPORT_GPU GrBackendTexture SkSurface::getBackendTexture(BackendHandleAccess access) { return asSB(this)->onGetBackendTexture(access); } @@ -338,26 +365,20 @@ GrSemaphoresSubmitted SkSurface::flush(const GrFlushInfo& info, return asSB(this)->onFlush(BackendSurfaceAccess::kNoAccess, info, newState); } -bool SkSurface::wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores, - bool deleteSemaphoresAfterWait) { - return asSB(this)->onWait(numSemaphores, waitSemaphores, deleteSemaphoresAfterWait); +void SkSurface::flush() { + this->flush({}); } +#else +void SkSurface::flush() {} // Flush is a no-op for CPU surfaces -bool SkSurface::characterize(SkSurfaceCharacterization* characterization) const { - return asConstSB(this)->onCharacterize(characterization); -} - -bool SkSurface::isCompatible(const SkSurfaceCharacterization& characterization) const { - return asConstSB(this)->onIsCompatible(characterization); -} - -bool SkSurface::draw(sk_sp ddl, int xOffset, int yOffset) { - if (xOffset != 0 || yOffset != 0) { - return false; // the offsets currently aren't supported - } - - return asSB(this)->onDraw(std::move(ddl), { xOffset, yOffset }); +void SkSurface::flushAndSubmit(bool syncCpu) {} + +// TODO(kjlubick, scroggo) Remove this once Android is updated. +sk_sp SkSurface::MakeRenderTarget(GrRecordingContext*, SkBudgeted, const SkImageInfo&, + int, GrSurfaceOrigin, const SkSurfaceProps*, bool) { + return nullptr; } +#endif ////////////////////////////////////////////////////////////////////////////////////// #include "include/utils/SkNoDrawCanvas.h" @@ -388,38 +409,5 @@ sk_sp SkSurface::MakeNull(int width, int height) { ////////////////////////////////////////////////////////////////////////////////////// -#if !SK_SUPPORT_GPU -sk_sp SkSurface::MakeRenderTarget(GrRecordingContext*, SkBudgeted, const SkImageInfo&, - int, GrSurfaceOrigin, const SkSurfaceProps*, bool) { - return nullptr; -} -sk_sp SkSurface::MakeRenderTarget(GrRecordingContext*, const SkSurfaceCharacterization&, - SkBudgeted) { - return nullptr; -} - -sk_sp SkSurface::MakeFromBackendTexture(GrRecordingContext*, const GrBackendTexture&, - GrSurfaceOrigin origin, int sampleCnt, - SkColorType, sk_sp, - const SkSurfaceProps*, - TextureReleaseProc, ReleaseContext) { - return nullptr; -} - -sk_sp SkSurface::MakeFromBackendRenderTarget(GrRecordingContext*, - const GrBackendRenderTarget&, - GrSurfaceOrigin origin, - SkColorType, - sk_sp, - const SkSurfaceProps*, - RenderTargetReleaseProc, ReleaseContext) { - return nullptr; -} - -void SkSurface::flushAndSubmit(bool syncCpu) { - this->flush(BackendSurfaceAccess::kNoAccess, GrFlushInfo()); -} - -#endif diff --git a/src/image/SkSurface_Base.h b/src/image/SkSurface_Base.h index 557ecbd601..aeb3afbfff 100644 --- a/src/image/SkSurface_Base.h +++ b/src/image/SkSurface_Base.h @@ -22,6 +22,7 @@ public: virtual GrRecordingContext* onGetRecordingContext(); +#if SK_SUPPORT_GPU virtual GrBackendTexture onGetBackendTexture(BackendHandleAccess); virtual GrBackendRenderTarget onGetBackendRenderTarget(BackendHandleAccess); virtual bool onReplaceBackendTexture(const GrBackendTexture&, @@ -29,6 +30,18 @@ public: ContentChangeMode, TextureReleaseProc, ReleaseContext); + + /** + * Issue any pending surface IO to the current backend 3D API and resolve any surface MSAA. + * Inserts the requested number of semaphores for the gpu to signal when work is complete on the + * gpu and inits the array of GrBackendSemaphores with the signaled semaphores. + */ + virtual GrSemaphoresSubmitted onFlush(BackendSurfaceAccess access, const GrFlushInfo&, + const GrBackendSurfaceMutableState*) { + return GrSemaphoresSubmitted::kNo; + } +#endif + /** * 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 @@ -105,16 +118,6 @@ public: */ virtual void onRestoreBackingMutability() {} - /** - * Issue any pending surface IO to the current backend 3D API and resolve any surface MSAA. - * Inserts the requested number of semaphores for the gpu to signal when work is complete on the - * gpu and inits the array of GrBackendSemaphores with the signaled semaphores. - */ - virtual GrSemaphoresSubmitted onFlush(BackendSurfaceAccess access, const GrFlushInfo&, - const GrBackendSurfaceMutableState*) { - return GrSemaphoresSubmitted::kNo; - } - /** * Caused the current backend 3D API to wait on the passed in semaphores before executing new * commands on the gpu. Any previously submitting commands will not be blocked by these