/*
|
* 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 "GrBackendSurface.h"
|
#include "SkCanvas.h"
|
#include "SkFontLCDConfig.h"
|
#include "SkImagePriv.h"
|
#include "SkSurface_Base.h"
|
#include <atomic>
|
|
static SkPixelGeometry compute_default_geometry() {
|
SkFontLCDConfig::LCDOrder order = SkFontLCDConfig::GetSubpixelOrder();
|
if (SkFontLCDConfig::kNONE_LCDOrder == order) {
|
return kUnknown_SkPixelGeometry;
|
} else {
|
// Bit0 is RGB(0), BGR(1)
|
// Bit1 is H(0), V(1)
|
const SkPixelGeometry gGeo[] = {
|
kRGB_H_SkPixelGeometry,
|
kBGR_H_SkPixelGeometry,
|
kRGB_V_SkPixelGeometry,
|
kBGR_V_SkPixelGeometry,
|
};
|
int index = 0;
|
if (SkFontLCDConfig::kBGR_LCDOrder == order) {
|
index |= 1;
|
}
|
if (SkFontLCDConfig::kVertical_LCDOrientation == SkFontLCDConfig::GetSubpixelOrientation()){
|
index |= 2;
|
}
|
return gGeo[index];
|
}
|
}
|
|
SkSurfaceProps::SkSurfaceProps() : fFlags(0), fPixelGeometry(kUnknown_SkPixelGeometry) {}
|
|
SkSurfaceProps::SkSurfaceProps(InitType) : fFlags(0), fPixelGeometry(compute_default_geometry()) {}
|
|
SkSurfaceProps::SkSurfaceProps(uint32_t flags, InitType)
|
: fFlags(flags)
|
, fPixelGeometry(compute_default_geometry())
|
{}
|
|
SkSurfaceProps::SkSurfaceProps(uint32_t flags, SkPixelGeometry pg)
|
: fFlags(flags), fPixelGeometry(pg)
|
{}
|
|
SkSurfaceProps::SkSurfaceProps(const SkSurfaceProps& other)
|
: fFlags(other.fFlags)
|
, fPixelGeometry(other.fPixelGeometry)
|
{}
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
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);
|
}
|
}
|
|
GrBackendTexture SkSurface_Base::onGetBackendTexture(BackendHandleAccess) {
|
return GrBackendTexture(); // invalid
|
}
|
|
GrBackendRenderTarget SkSurface_Base::onGetBackendRenderTarget(BackendHandleAccess) {
|
return GrBackendRenderTarget(); // invalid
|
}
|
|
void SkSurface_Base::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) {
|
auto image = this->makeImageSnapshot();
|
if (image) {
|
canvas->drawImage(image, x, y, paint);
|
}
|
}
|
|
bool SkSurface_Base::outstandingImageSnapshot() const {
|
return fCachedImage && !fCachedImage->unique();
|
}
|
|
void 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) {
|
this->onCopyOnWrite(mode);
|
}
|
|
// 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();
|
}
|
}
|
|
uint32_t SkSurface_Base::newGenerationID() {
|
SkASSERT(!fCachedCanvas || fCachedCanvas->getSurfaceBase() == this);
|
static std::atomic<uint32_t> nextID{1};
|
return nextID++;
|
}
|
|
static SkSurface_Base* asSB(SkSurface* surface) {
|
return static_cast<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) {
|
asSB(this)->aboutToDraw(mode);
|
}
|
|
SkCanvas* SkSurface::getCanvas() {
|
return asSB(this)->getCachedCanvas();
|
}
|
|
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);
|
}
|
}
|
|
sk_sp<SkSurface> SkSurface::makeSurface(const SkImageInfo& info) {
|
return asSB(this)->onNewSurface(info);
|
}
|
|
void SkSurface::draw(SkCanvas* canvas, SkScalar x, SkScalar y,
|
const SkPaint* paint) {
|
return asSB(this)->onDraw(canvas, x, y, 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::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;
|
}
|
asSB(this)->aboutToDraw(mode);
|
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);
|
}
|
}
|
|
GrBackendTexture SkSurface::getBackendTexture(BackendHandleAccess access) {
|
return asSB(this)->onGetBackendTexture(access);
|
}
|
|
GrBackendRenderTarget SkSurface::getBackendRenderTarget(BackendHandleAccess access) {
|
return asSB(this)->onGetBackendRenderTarget(access);
|
}
|
|
void SkSurface::prepareForExternalIO() {
|
this->flush();
|
}
|
|
void SkSurface::flush() {
|
asSB(this)->onFlush(0, nullptr);
|
}
|
|
GrSemaphoresSubmitted SkSurface::flushAndSignalSemaphores(int numSemaphores,
|
GrBackendSemaphore signalSemaphores[]) {
|
return asSB(this)->onFlush(numSemaphores, signalSemaphores);
|
}
|
|
bool SkSurface::wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
|
return asSB(this)->onWait(numSemaphores, waitSemaphores);
|
}
|
|
bool SkSurface::characterize(SkSurfaceCharacterization* characterization) const {
|
return asSB(const_cast<SkSurface*>(this))->onCharacterize(characterization);
|
}
|
|
bool SkSurface::draw(SkDeferredDisplayList* ddl) {
|
return asSB(this)->onDraw(ddl);
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
#include "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 x, SkScalar y, const SkPaint*) override {}
|
void onCopyOnWrite(ContentChangeMode) override {}
|
};
|
|
sk_sp<SkSurface> SkSurface::MakeNull(int width, int height) {
|
if (width < 1 || height < 1) {
|
return nullptr;
|
}
|
return sk_sp<SkSurface>(new SkNullSurface(width, height));
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
#if !SK_SUPPORT_GPU
|
|
sk_sp<SkSurface> SkSurface::MakeRenderTarget(GrContext*, SkBudgeted, const SkImageInfo&, int,
|
GrSurfaceOrigin, const SkSurfaceProps*, bool) {
|
return nullptr;
|
}
|
|
sk_sp<SkSurface> SkSurface::MakeRenderTarget(GrContext*, const SkSurfaceCharacterization&,
|
SkBudgeted) {
|
return nullptr;
|
}
|
|
sk_sp<SkSurface> SkSurface::MakeFromBackendTexture(GrContext*, const GrBackendTexture&,
|
GrSurfaceOrigin origin, int sampleCnt,
|
SkColorType, sk_sp<SkColorSpace>,
|
const SkSurfaceProps*) {
|
return nullptr;
|
}
|
|
sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext*,
|
const GrBackendRenderTarget&,
|
GrSurfaceOrigin origin,
|
SkColorType,
|
sk_sp<SkColorSpace>,
|
const SkSurfaceProps*) {
|
return nullptr;
|
}
|
|
sk_sp<SkSurface> SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext*,
|
const GrBackendTexture&,
|
GrSurfaceOrigin origin,
|
int sampleCnt,
|
SkColorType,
|
sk_sp<SkColorSpace>,
|
const SkSurfaceProps*) {
|
return nullptr;
|
}
|
|
#endif
|
