diff options
Diffstat (limited to 'gfx/skia/skia/src/core/SkSpecialImage.h')
| -rw-r--r-- | gfx/skia/skia/src/core/SkSpecialImage.h | 263 |
1 files changed, 263 insertions, 0 deletions
diff --git a/gfx/skia/skia/src/core/SkSpecialImage.h b/gfx/skia/skia/src/core/SkSpecialImage.h new file mode 100644 index 0000000000..33bcfae2df --- /dev/null +++ b/gfx/skia/skia/src/core/SkSpecialImage.h @@ -0,0 +1,263 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file + */ + +#ifndef SkSpecialImage_DEFINED +#define SkSpecialImage_DEFINED + +#include "include/core/SkImageInfo.h" +#include "include/core/SkRefCnt.h" +#include "include/core/SkSamplingOptions.h" +#include "include/core/SkSurfaceProps.h" +#include "src/core/SkNextID.h" + +#if defined(SK_GANESH) +#include "include/private/gpu/ganesh/GrTypesPriv.h" +#include "src/gpu/ganesh/GrSurfaceProxyView.h" +#endif + +class GrColorInfo; +class GrRecordingContext; +class GrTextureProxy; +class SkBitmap; +class SkCanvas; +class SkImage; +struct SkImageInfo; +class SkMatrix; +class SkPaint; +class SkPixmap; +class SkShader; +class SkSpecialSurface; +class SkSurface; +enum class SkTileMode; + +namespace skgpu::graphite { +class Recorder; +class TextureProxyView; +} + +enum { + kNeedNewImageUniqueID_SpecialImage = 0 +}; + +/** + * This is a restricted form of SkImage solely intended for internal use. It + * differs from SkImage in that: + * - it can only be backed by raster or gpu (no generators) + * - it can be backed by a GrTextureProxy larger than its nominal bounds + * - it can't be drawn tiled + * - it can't be drawn with MIPMAPs + * It is similar to SkImage in that it abstracts how the pixels are stored/represented. + * + * Note: the contents of the backing storage outside of the subset rect are undefined. + */ +class SkSpecialImage : public SkRefCnt { +public: + typedef void* ReleaseContext; + typedef void(*RasterReleaseProc)(void* pixels, ReleaseContext); + + const SkSurfaceProps& props() const { return fProps; } + + int width() const { return fSubset.width(); } + int height() const { return fSubset.height(); } + SkISize dimensions() const { return { this->width(), this->height() }; } + const SkIRect& subset() const { return fSubset; } + + uint32_t uniqueID() const { return fUniqueID; } + + virtual size_t getSize() const = 0; + + const SkColorInfo& colorInfo() const { return fColorInfo; } + SkAlphaType alphaType() const { return fColorInfo.alphaType(); } + SkColorType colorType() const { return fColorInfo.colorType(); } + SkColorSpace* getColorSpace() const { return fColorInfo.colorSpace(); } + + /** + * Draw this SpecialImage into the canvas, automatically taking into account the image's subset + */ + void draw(SkCanvas* canvas, + SkScalar x, SkScalar y, + const SkSamplingOptions& sampling, + const SkPaint* paint) const { + return this->onDraw(canvas, x, y, sampling, paint); + } + void draw(SkCanvas* canvas, SkScalar x, SkScalar y) const { + this->draw(canvas, x, y, SkSamplingOptions(), nullptr); + } + + static sk_sp<SkSpecialImage> MakeFromImage(GrRecordingContext*, + const SkIRect& subset, + sk_sp<SkImage>, + const SkSurfaceProps&); + static sk_sp<SkSpecialImage> MakeFromRaster(const SkIRect& subset, + const SkBitmap&, + const SkSurfaceProps&); + static sk_sp<SkSpecialImage> CopyFromRaster(const SkIRect& subset, + const SkBitmap&, + const SkSurfaceProps&); +#if defined(SK_GANESH) + static sk_sp<SkSpecialImage> MakeDeferredFromGpu(GrRecordingContext*, + const SkIRect& subset, + uint32_t uniqueID, + GrSurfaceProxyView, + const GrColorInfo&, + const SkSurfaceProps&); +#endif + +#if defined(SK_GRAPHITE) + static sk_sp<SkSpecialImage> MakeGraphite(skgpu::graphite::Recorder*, + const SkIRect& subset, + uint32_t uniqueID, + skgpu::graphite::TextureProxyView, + const SkColorInfo&, + const SkSurfaceProps&); +#endif + + /** + * Create a new special surface with a backend that is compatible with this special image. + */ + sk_sp<SkSpecialSurface> makeSurface(SkColorType, + const SkColorSpace*, + const SkISize& size, + SkAlphaType, + const SkSurfaceProps&) const; + + /** + * Create a new surface with a backend that is compatible with this special image. + * TODO: switch this to makeSurface once we resolved the naming issue + * TODO (michaelludwig) - This is only used by SkTileImageFilter, which appears should be + * updated to work correctly with subsets and then makeTightSurface() can go away entirely. + */ + sk_sp<SkSurface> makeTightSurface(SkColorType, + const SkColorSpace*, + const SkISize& size, + SkAlphaType = kPremul_SkAlphaType) const; + + /** + * Extract a subset of this special image and return it as a special image. + * It may or may not point to the same backing memory. The input 'subset' is relative to the + * special image's content rect. + */ + sk_sp<SkSpecialImage> makeSubset(const SkIRect& subset) const { + SkIRect absolute = subset.makeOffset(this->subset().topLeft()); + return this->onMakeSubset(absolute); + } + + /** + * Create an SkImage from the contents of this special image optionally extracting a subset. + * It may or may not point to the same backing memory. + * Note: when no 'subset' parameter is specified the the entire SkSpecialImage will be + * returned - including whatever extra padding may have resulted from a loose fit! + * When the 'subset' parameter is specified the returned image will be tight even if that + * entails a copy! The 'subset' is relative to this special image's content rect. + */ + // TODO: The only version that uses the subset is the tile image filter, and that doesn't need + // to if it can be rewritten to use asShader() and SkTileModes. Similarly, the only use case of + // asImage() w/o a subset is SkImage::makeFiltered() and that could/should return an SkShader so + // that users don't need to worry about correctly applying the subset, etc. + sk_sp<SkImage> asImage(const SkIRect* subset = nullptr) const; + + /** + * Create an SkShader that samples the contents of this special image, applying tile mode for + * any sample that falls outside its internal subset. + */ + sk_sp<SkShader> asShader(SkTileMode, const SkSamplingOptions&, const SkMatrix& lm) const; + sk_sp<SkShader> asShader(const SkSamplingOptions& sampling) const; + sk_sp<SkShader> asShader(const SkSamplingOptions& sampling, const SkMatrix& lm) const; + + /** + * If the SpecialImage is backed by a gpu texture, return true. + */ + bool isTextureBacked() const { return SkToBool(this->onGetContext()); } + + /** + * Return the GrRecordingContext if the SkSpecialImage is GrTexture-backed + */ + GrRecordingContext* getContext() const { return this->onGetContext(); } + +#if defined(SK_GANESH) + /** + * Regardless of how the underlying backing data is stored, returns the contents as a + * GrSurfaceProxyView. The returned view's proxy represents the entire backing image, so texture + * coordinates must be mapped from the content rect (e.g. relative to 'subset()') to the proxy's + * space (offset by subset().topLeft()). + */ + GrSurfaceProxyView view(GrRecordingContext* context) const { return this->onView(context); } +#endif + +#if defined(SK_GRAPHITE) + bool isGraphiteBacked() const; + + skgpu::graphite::TextureProxyView textureProxyView() const; +#endif + + /** + * Regardless of the underlying backing store, return the contents as an SkBitmap. + * The returned bitmap represents the subset accessed by this image, thus (0,0) refers to the + * top-left corner of 'subset'. + */ + bool getROPixels(SkBitmap* bm) const { + return this->onGetROPixels(bm); + } + +protected: + SkSpecialImage(const SkIRect& subset, + uint32_t uniqueID, + const SkColorInfo&, + const SkSurfaceProps&); + + virtual void onDraw(SkCanvas*, + SkScalar x, SkScalar y, + const SkSamplingOptions&, + const SkPaint*) const = 0; + + virtual bool onGetROPixels(SkBitmap*) const = 0; + + virtual GrRecordingContext* onGetContext() const { return nullptr; } + +#if defined(SK_GANESH) + virtual GrSurfaceProxyView onView(GrRecordingContext*) const = 0; +#endif + +#if defined(SK_GRAPHITE) + virtual skgpu::graphite::TextureProxyView onTextureProxyView() const; +#endif + + // This subset is relative to the backing store's coordinate frame, it has already been mapped + // from the content rect by the non-virtual makeSubset(). + virtual sk_sp<SkSpecialImage> onMakeSubset(const SkIRect& subset) const = 0; + + virtual sk_sp<SkSpecialSurface> onMakeSurface(SkColorType colorType, + const SkColorSpace* colorSpace, + const SkISize& size, + SkAlphaType at, + const SkSurfaceProps&) const = 0; + + // This subset (when not null) is relative to the backing store's coordinate frame, it has + // already been mapped from the content rect by the non-virtual asImage(). + virtual sk_sp<SkImage> onAsImage(const SkIRect* subset) const = 0; + + virtual sk_sp<SkShader> onAsShader(SkTileMode, + const SkSamplingOptions&, + const SkMatrix&) const = 0; + + virtual sk_sp<SkSurface> onMakeTightSurface(SkColorType colorType, + const SkColorSpace* colorSpace, + const SkISize& size, + SkAlphaType at) const = 0; + +#ifdef SK_DEBUG + static bool RectFits(const SkIRect& rect, int width, int height); +#endif + +private: + const SkIRect fSubset; + const uint32_t fUniqueID; + const SkColorInfo fColorInfo; + const SkSurfaceProps fProps; +}; + +#endif // SkSpecialImage_DEFINED |