diff options
Diffstat (limited to 'gfx/skia/skia/src/image/SkImage_Raster.h')
-rw-r--r-- | gfx/skia/skia/src/image/SkImage_Raster.h | 147 |
1 files changed, 147 insertions, 0 deletions
diff --git a/gfx/skia/skia/src/image/SkImage_Raster.h b/gfx/skia/skia/src/image/SkImage_Raster.h new file mode 100644 index 0000000000..0fbbc0a5c1 --- /dev/null +++ b/gfx/skia/skia/src/image/SkImage_Raster.h @@ -0,0 +1,147 @@ +/* + * Copyright 2023 Google LLC + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkImage_Raster_DEFINED +#define SkImage_Raster_DEFINED + +#include "include/core/SkBitmap.h" +#include "include/core/SkImage.h" +#include "include/core/SkPixelRef.h" +#include "include/core/SkRefCnt.h" +#include "include/core/SkSamplingOptions.h" +#include "include/core/SkTypes.h" +#include "include/private/base/SkTo.h" +#include "src/core/SkImagePriv.h" +#include "src/core/SkMipmap.h" +#include "src/image/SkImage_Base.h" + +#include <cstddef> +#include <cstdint> +#include <memory> +#include <tuple> +#include <utility> + +class GrDirectContext; +class GrFragmentProcessor; +class GrRecordingContext; +class GrSurfaceProxyView; +class SkColorSpace; +class SkData; +class SkMatrix; +class SkPixmap; +enum SkColorType : int; +enum class GrColorType; +enum class GrImageTexGenPolicy : int; +enum class SkTileMode; +struct SkIRect; +struct SkImageInfo; +struct SkRect; + +#if defined(SK_GANESH) +#include "include/gpu/GrTypes.h" +#endif + +#if defined(SK_GRAPHITE) +#include "include/gpu/graphite/GraphiteTypes.h" +#include "include/gpu/graphite/Recorder.h" +#include "src/gpu/graphite/Buffer.h" +#include "src/gpu/graphite/Caps.h" +#include "src/gpu/graphite/CommandBuffer.h" +#include "src/gpu/graphite/RecorderPriv.h" +#include "src/gpu/graphite/TextureUtils.h" +#include "src/gpu/graphite/UploadTask.h" +#endif + +class SkImage_Raster : public SkImage_Base { +public: + SkImage_Raster(const SkImageInfo&, sk_sp<SkData>, size_t rb, + uint32_t id = kNeedNewImageUniqueID); + SkImage_Raster(const SkBitmap& bm, bool bitmapMayBeMutable = false); + ~SkImage_Raster() override; + + bool onReadPixels(GrDirectContext*, const SkImageInfo&, void*, size_t, int srcX, int srcY, + CachingHint) const override; + bool onPeekPixels(SkPixmap*) const override; + const SkBitmap* onPeekBitmap() const override { return &fBitmap; } + + bool getROPixels(GrDirectContext*, SkBitmap*, CachingHint) const override; + sk_sp<SkImage> onMakeSubset(const SkIRect&, GrDirectContext*) const override; +#if defined(SK_GRAPHITE) + sk_sp<SkImage> onMakeSubset(const SkIRect&, + skgpu::graphite::Recorder*, + RequiredImageProperties) const override; +#endif + + SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); } + + bool onAsLegacyBitmap(GrDirectContext*, SkBitmap*) const override; + + sk_sp<SkImage> onMakeColorTypeAndColorSpace(SkColorType, sk_sp<SkColorSpace>, + GrDirectContext*) const override; + + sk_sp<SkImage> onReinterpretColorSpace(sk_sp<SkColorSpace>) const override; + + bool onIsValid(GrRecordingContext* context) const override { return true; } + void notifyAddedToRasterCache() const override { + // We explicitly DON'T want to call INHERITED::notifyAddedToRasterCache. That ties the + // lifetime of derived/cached resources to the image. In this case, we only want cached + // data (eg mips) tied to the lifetime of the underlying pixelRef. + SkASSERT(fBitmap.pixelRef()); + fBitmap.pixelRef()->notifyAddedToCache(); + } + + SkImage_Base::Type type() const override { return SkImage_Base::Type::kRaster; } + + bool onHasMipmaps() const override { return SkToBool(fBitmap.fMips); } + + SkMipmap* onPeekMips() const override { return fBitmap.fMips.get(); } + + sk_sp<SkImage> onMakeWithMipmaps(sk_sp<SkMipmap> mips) const override { + // It's dangerous to have two SkBitmaps that share a SkPixelRef but have different SkMipmaps + // since various caches key on SkPixelRef's generation ID. Also, SkPixelRefs that back + // SkSurfaces are marked "temporarily immutable" and making an image that uses the same + // SkPixelRef can interact badly with SkSurface/SkImage copy-on-write. So we just always + // make a copy with a new ID. + static auto constexpr kCopyMode = SkCopyPixelsMode::kAlways_SkCopyPixelsMode; + sk_sp<SkImage> img = SkMakeImageFromRasterBitmap(fBitmap, kCopyMode); + auto imgRaster = static_cast<SkImage_Raster*>(img.get()); + if (mips) { + imgRaster->fBitmap.fMips = std::move(mips); + } else { + imgRaster->fBitmap.fMips.reset(SkMipmap::Build(fBitmap.pixmap(), nullptr)); + } + return img; + } + +protected: + SkBitmap fBitmap; + +private: +#if defined(SK_GANESH) + std::tuple<GrSurfaceProxyView, GrColorType> onAsView(GrRecordingContext*, + GrMipmapped, + GrImageTexGenPolicy) const override; + + std::unique_ptr<GrFragmentProcessor> onAsFragmentProcessor(GrRecordingContext*, + SkSamplingOptions, + const SkTileMode[2], + const SkMatrix&, + const SkRect*, + const SkRect*) const override; +#endif +#if defined(SK_GRAPHITE) + sk_sp<SkImage> onMakeTextureImage(skgpu::graphite::Recorder*, + RequiredImageProperties) const override; + sk_sp<SkImage> onMakeColorTypeAndColorSpace(SkColorType targetCT, + sk_sp<SkColorSpace> targetCS, + skgpu::graphite::Recorder*, + RequiredImageProperties) const override; +#endif + +}; + +#endif // SkImage_Raster_DEFINED |