blob: aaa451e6bd7e6cd9130a0ffe0ddb05cb54bccebb [file] [log] [blame]
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <atomic>
#include <cmath>
#include "include/core/SkCanvas.h"
#include "include/core/SkCapabilities.h"
#include "src/core/SkAutoPixmapStorage.h"
#include "src/core/SkImagePriv.h"
#include "src/core/SkPaintPriv.h"
#include "src/image/SkImage_Base.h"
#include "src/image/SkRescaleAndReadPixels.h"
#include "src/image/SkSurface_Base.h"
#if SK_SUPPORT_GPU
#include "include/gpu/GrBackendSurface.h"
#endif
SkSurfaceProps::SkSurfaceProps() : fFlags(0), fPixelGeometry(kUnknown_SkPixelGeometry) {}
SkSurfaceProps::SkSurfaceProps(uint32_t flags, SkPixelGeometry pg)
: fFlags(flags), fPixelGeometry(pg)
{}
SkSurfaceProps::SkSurfaceProps(const SkSurfaceProps&) = default;
SkSurfaceProps& SkSurfaceProps::operator=(const SkSurfaceProps&) = default;
///////////////////////////////////////////////////////////////////////////////
SkSurface_Base::SkSurface_Base(int width, int height, const SkSurfaceProps* props)
: INHERITED(width, height, props) {
}
SkSurface_Base::SkSurface_Base(const SkImageInfo& info, const SkSurfaceProps* props)
: INHERITED(info, props) {
}
SkSurface_Base::~SkSurface_Base() {
// in case the canvas outsurvives us, we null the callback
if (fCachedCanvas) {
fCachedCanvas->setSurfaceBase(nullptr);
}
#if SK_SUPPORT_GPU
if (fCachedImage) {
as_IB(fCachedImage.get())->generatingSurfaceIsDeleted();
}
#endif
}
GrRecordingContext* SkSurface_Base::onGetRecordingContext() {
return nullptr;
}
skgpu::graphite::Recorder* SkSurface_Base::onGetRecorder() {
return nullptr;
}
#if SK_SUPPORT_GPU
GrBackendTexture SkSurface_Base::onGetBackendTexture(BackendHandleAccess) {
return GrBackendTexture(); // invalid
}
GrBackendRenderTarget SkSurface_Base::onGetBackendRenderTarget(BackendHandleAccess) {
return GrBackendRenderTarget(); // invalid
}
bool SkSurface_Base::onReplaceBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin, ContentChangeMode,
TextureReleaseProc,
ReleaseContext) {
return false;
}
#endif
void SkSurface_Base::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y,
const SkSamplingOptions& sampling, const SkPaint* paint) {
auto image = this->makeImageSnapshot();
if (image) {
canvas->drawImage(image.get(), x, y, sampling, paint);
}
}
void SkSurface_Base::onAsyncRescaleAndReadPixels(const SkImageInfo& info,
SkIRect origSrcRect,
SkSurface::RescaleGamma rescaleGamma,
RescaleMode rescaleMode,
SkSurface::ReadPixelsCallback callback,
SkSurface::ReadPixelsContext context) {
SkBitmap src;
SkPixmap peek;
SkIRect srcRect;
if (this->peekPixels(&peek)) {
src.installPixels(peek);
srcRect = origSrcRect;
} else {
src.setInfo(this->imageInfo().makeDimensions(origSrcRect.size()));
src.allocPixels();
if (!this->readPixels(src, origSrcRect.x(), origSrcRect.y())) {
callback(context, nullptr);
return;
}
srcRect = SkIRect::MakeSize(src.dimensions());
}
return SkRescaleAndReadPixels(src, info, srcRect, rescaleGamma, rescaleMode, callback,
context);
}
void SkSurface_Base::onAsyncRescaleAndReadPixelsYUV420(
SkYUVColorSpace yuvColorSpace, sk_sp<SkColorSpace> dstColorSpace, SkIRect srcRect,
SkISize dstSize, RescaleGamma rescaleGamma, RescaleMode,
ReadPixelsCallback callback, ReadPixelsContext context) {
// TODO: Call non-YUV asyncRescaleAndReadPixels and then make our callback convert to YUV and
// call client's callback.
callback(context, nullptr);
}
bool SkSurface_Base::outstandingImageSnapshot() const {
return fCachedImage && !fCachedImage->unique();
}
bool SkSurface_Base::aboutToDraw(ContentChangeMode mode) {
this->dirtyGenerationID();
SkASSERT(!fCachedCanvas || fCachedCanvas->getSurfaceBase() == this);
if (fCachedImage) {
// the surface may need to fork its backend, if its sharing it with
// the cached image. Note: we only call if there is an outstanding owner
// on the image (besides us).
bool unique = fCachedImage->unique();
if (!unique) {
if (!this->onCopyOnWrite(mode)) {
return false;
}
}
// regardless of copy-on-write, we must drop our cached image now, so
// that the next request will get our new contents.
fCachedImage.reset();
if (unique) {
// Our content isn't held by any image now, so we can consider that content mutable.
// Raster surfaces need to be told it's safe to consider its pixels mutable again.
// We make this call after the ->unref() so the subclass can assert there are no images.
this->onRestoreBackingMutability();
}
} else if (kDiscard_ContentChangeMode == mode) {
this->onDiscard();
}
return true;
}
uint32_t SkSurface_Base::newGenerationID() {
SkASSERT(!fCachedCanvas || fCachedCanvas->getSurfaceBase() == this);
static std::atomic<uint32_t> nextID{1};
return nextID.fetch_add(1, std::memory_order_relaxed);
}
sk_sp<const SkCapabilities> SkSurface_Base::onCapabilities() {
return SkCapabilities::RasterBackend();
}
static SkSurface_Base* asSB(SkSurface* surface) {
return static_cast<SkSurface_Base*>(surface);
}
static const SkSurface_Base* asConstSB(const SkSurface* surface) {
return static_cast<const SkSurface_Base*>(surface);
}
///////////////////////////////////////////////////////////////////////////////
SkSurface::SkSurface(int width, int height, const SkSurfaceProps* props)
: fProps(SkSurfacePropsCopyOrDefault(props)), fWidth(width), fHeight(height)
{
SkASSERT(fWidth > 0);
SkASSERT(fHeight > 0);
fGenerationID = 0;
}
SkSurface::SkSurface(const SkImageInfo& info, const SkSurfaceProps* props)
: fProps(SkSurfacePropsCopyOrDefault(props)), fWidth(info.width()), fHeight(info.height())
{
SkASSERT(fWidth > 0);
SkASSERT(fHeight > 0);
fGenerationID = 0;
}
uint32_t SkSurface::generationID() {
if (0 == fGenerationID) {
fGenerationID = asSB(this)->newGenerationID();
}
return fGenerationID;
}
void SkSurface::notifyContentWillChange(ContentChangeMode mode) {
sk_ignore_unused_variable(asSB(this)->aboutToDraw(mode));
}
SkCanvas* SkSurface::getCanvas() {
return asSB(this)->getCachedCanvas();
}
sk_sp<const SkCapabilities> SkSurface::capabilities() {
return asSB(this)->onCapabilities();
}
sk_sp<SkImage> SkSurface::makeImageSnapshot() {
return asSB(this)->refCachedImage();
}
sk_sp<SkImage> SkSurface::makeImageSnapshot(const SkIRect& srcBounds) {
const SkIRect surfBounds = { 0, 0, fWidth, fHeight };
SkIRect bounds = srcBounds;
if (!bounds.intersect(surfBounds)) {
return nullptr;
}
SkASSERT(!bounds.isEmpty());
if (bounds == surfBounds) {
return this->makeImageSnapshot();
} else {
return asSB(this)->onNewImageSnapshot(&bounds);
}
}
#ifdef SK_GRAPHITE_ENABLED
#include "src/gpu/graphite/Log.h"
sk_sp<SkImage> SkSurface::asImage() {
if (asSB(this)->fCachedImage) {
SKGPU_LOG_W("Intermingling makeImageSnapshot and asImage calls may produce "
"unexpected results. Please use either the old _or_ new API.");
}
return asSB(this)->onAsImage();
}
sk_sp<SkImage> SkSurface::makeImageCopy(const SkIRect* subset,
skgpu::graphite::Mipmapped mipmapped) {
if (asSB(this)->fCachedImage) {
SKGPU_LOG_W("Intermingling makeImageSnapshot and makeImageCopy calls may produce "
"unexpected results. Please use either the old _or_ new API.");
}
return asSB(this)->onMakeImageCopy(subset, mipmapped);
}
#endif
sk_sp<SkSurface> SkSurface::makeSurface(const SkImageInfo& info) {
return asSB(this)->onNewSurface(info);
}
sk_sp<SkSurface> SkSurface::makeSurface(int width, int height) {
return this->makeSurface(this->imageInfo().makeWH(width, height));
}
void SkSurface::draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkSamplingOptions& sampling,
const SkPaint* paint) {
asSB(this)->onDraw(canvas, x, y, sampling, paint);
}
bool SkSurface::peekPixels(SkPixmap* pmap) {
return this->getCanvas()->peekPixels(pmap);
}
bool SkSurface::readPixels(const SkPixmap& pm, int srcX, int srcY) {
return this->getCanvas()->readPixels(pm, srcX, srcY);
}
bool SkSurface::readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
int srcX, int srcY) {
return this->readPixels({dstInfo, dstPixels, dstRowBytes}, srcX, srcY);
}
bool SkSurface::readPixels(const SkBitmap& bitmap, int srcX, int srcY) {
SkPixmap pm;
return bitmap.peekPixels(&pm) && this->readPixels(pm, srcX, srcY);
}
void SkSurface::asyncRescaleAndReadPixels(const SkImageInfo& info,
const SkIRect& srcRect,
RescaleGamma rescaleGamma,
RescaleMode rescaleMode,
ReadPixelsCallback callback,
ReadPixelsContext context) {
if (!SkIRect::MakeWH(this->width(), this->height()).contains(srcRect) ||
!SkImageInfoIsValid(info)) {
callback(context, nullptr);
return;
}
asSB(this)->onAsyncRescaleAndReadPixels(
info, srcRect, rescaleGamma, rescaleMode, callback, context);
}
void SkSurface::asyncRescaleAndReadPixelsYUV420(SkYUVColorSpace yuvColorSpace,
sk_sp<SkColorSpace> dstColorSpace,
const SkIRect& srcRect,
const SkISize& dstSize,
RescaleGamma rescaleGamma,
RescaleMode rescaleMode,
ReadPixelsCallback callback,
ReadPixelsContext context) {
if (!SkIRect::MakeWH(this->width(), this->height()).contains(srcRect) || dstSize.isZero() ||
(dstSize.width() & 0b1) || (dstSize.height() & 0b1)) {
callback(context, nullptr);
return;
}
asSB(this)->onAsyncRescaleAndReadPixelsYUV420(yuvColorSpace,
std::move(dstColorSpace),
srcRect,
dstSize,
rescaleGamma,
rescaleMode,
callback,
context);
}
void SkSurface::writePixels(const SkPixmap& pmap, int x, int y) {
if (pmap.addr() == nullptr || pmap.width() <= 0 || pmap.height() <= 0) {
return;
}
const SkIRect srcR = SkIRect::MakeXYWH(x, y, pmap.width(), pmap.height());
const SkIRect dstR = SkIRect::MakeWH(this->width(), this->height());
if (SkIRect::Intersects(srcR, dstR)) {
ContentChangeMode mode = kRetain_ContentChangeMode;
if (srcR.contains(dstR)) {
mode = kDiscard_ContentChangeMode;
}
if (!asSB(this)->aboutToDraw(mode)) {
return;
}
asSB(this)->onWritePixels(pmap, x, y);
}
}
void SkSurface::writePixels(const SkBitmap& src, int x, int y) {
SkPixmap pm;
if (src.peekPixels(&pm)) {
this->writePixels(pm, x, y);
}
}
GrRecordingContext* SkSurface::recordingContext() {
return asSB(this)->onGetRecordingContext();
}
skgpu::graphite::Recorder* SkSurface::recorder() {
return asSB(this)->onGetRecorder();
}
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<const SkDeferredDisplayList> 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);
}
GrBackendRenderTarget SkSurface::getBackendRenderTarget(BackendHandleAccess access) {
return asSB(this)->onGetBackendRenderTarget(access);
}
bool SkSurface::replaceBackendTexture(const GrBackendTexture& backendTexture,
GrSurfaceOrigin origin, ContentChangeMode mode,
TextureReleaseProc textureReleaseProc,
ReleaseContext releaseContext) {
return asSB(this)->onReplaceBackendTexture(backendTexture, origin, mode, textureReleaseProc,
releaseContext);
}
void SkSurface::resolveMSAA() {
asSB(this)->onResolveMSAA();
}
GrSemaphoresSubmitted SkSurface::flush(BackendSurfaceAccess access, const GrFlushInfo& flushInfo) {
return asSB(this)->onFlush(access, flushInfo, nullptr);
}
GrSemaphoresSubmitted SkSurface::flush(const GrFlushInfo& info,
const skgpu::MutableTextureState* newState) {
return asSB(this)->onFlush(BackendSurfaceAccess::kNoAccess, info, newState);
}
void SkSurface::flush() {
this->flush({});
}
#else
void SkSurface::flush() {} // Flush is a no-op for CPU surfaces
void SkSurface::flushAndSubmit(bool syncCpu) {}
// TODO(kjlubick, scroggo) Remove this once Android is updated.
sk_sp<SkSurface> SkSurface::MakeRenderTarget(GrRecordingContext*,
skgpu::Budgeted,
const SkImageInfo&,
int,
GrSurfaceOrigin,
const SkSurfaceProps*,
bool) {
return nullptr;
}
#endif
//////////////////////////////////////////////////////////////////////////////////////
#include "include/utils/SkNoDrawCanvas.h"
class SkNullSurface : public SkSurface_Base {
public:
SkNullSurface(int width, int height) : SkSurface_Base(width, height, nullptr) {}
protected:
SkCanvas* onNewCanvas() override {
return new SkNoDrawCanvas(this->width(), this->height());
}
sk_sp<SkSurface> onNewSurface(const SkImageInfo& info) override {
return MakeNull(info.width(), info.height());
}
sk_sp<SkImage> onNewImageSnapshot(const SkIRect* subsetOrNull) override { return nullptr; }
void onWritePixels(const SkPixmap&, int x, int y) override {}
void onDraw(SkCanvas*, SkScalar, SkScalar, const SkSamplingOptions&, const SkPaint*) override {}
bool onCopyOnWrite(ContentChangeMode) override { return true; }
sk_sp<const SkCapabilities> onCapabilities() override {
// Not really, but we have to return *something*
return SkCapabilities::RasterBackend();
}
SkImageInfo imageInfo() const override {
return SkImageInfo::MakeUnknown(this->width(), this->height());
}
};
sk_sp<SkSurface> SkSurface::MakeNull(int width, int height) {
if (width < 1 || height < 1) {
return nullptr;
}
return sk_sp<SkSurface>(new SkNullSurface(width, height));
}
//////////////////////////////////////////////////////////////////////////////////////