rngine 0.8.0 → 0.8.2

package/shared/skia/include/private/chromium/SkImageChromium.h

@@ -0,0 +1,117 @@
+/*
+ * 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 SkImageChromium_DEFINED
+#define SkImageChromium_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+class GrBackendFormat;
+class GrContextThreadSafeProxy;
+class GrPromiseImageTexture;
+class GrDirectContext;
+class GrYUVABackendTextureInfo;
+class SkColorSpace;
+class SkImage;
+enum SkAlphaType : int;
+enum SkColorType : int;
+enum GrSurfaceOrigin : int;
+namespace skgpu {
+enum class Mipmapped : bool;
+}
+struct SkISize;
+
+/**
+ * These functions expose features that are only for external use in Chromium.
+ */
+
+namespace SkImages {
+
+using PromiseImageTextureContext = void*;
+using PromiseImageTextureFulfillProc = sk_sp<GrPromiseImageTexture> (*)(PromiseImageTextureContext);
+using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
+
+/** Create a new GPU-backed SkImage that is very similar to an SkImage created by BorrowTextureFrom.
+    The difference is that the caller need not have created the texture nor populated it with the
+    image pixel data. Moreover, the SkImage may be created on a thread as the creation of the
+    image does not require access to the backend API or GrDirectContext. Instead of passing a
+    GrBackendTexture the client supplies a description of the texture consisting of
+    GrBackendFormat, width, height, and skgpu::Mipmapped state. The resulting SkImage can be drawn
+    to a GrDeferredDisplayListRecorder or directly to a GPU-backed SkSurface.
+    When the actual texture is required to perform a backend API draw, textureFulfillProc will
+    be called to receive a GrBackendTexture. The properties of the GrBackendTexture must match
+    those set during the SkImage creation, and it must refer to a valid existing texture in the
+    backend API context/device, and be populated with the image pixel data. The texture cannot
+    be deleted until textureReleaseProc is called.
+    There is at most one call to each of textureFulfillProc and textureReleaseProc.
+    textureReleaseProc is always called even if image creation fails or if the
+    image is never fulfilled (e.g. it is never drawn or all draws are clipped out)
+    @param gpuContextProxy     the thread-safe proxy of the gpu context. required.
+    @param backendFormat       format of promised gpu texture
+    @param dimensions          width & height of promised gpu texture
+    @param mipmapped           mip mapped state of promised gpu texture
+    @param origin              surface origin of promised gpu texture
+    @param colorType           color type of promised gpu texture
+    @param alphaType           alpha type of promised gpu texture
+    @param colorSpace          range of colors; may be nullptr
+    @param textureFulfillProc  function called to get actual gpu texture
+    @param textureReleaseProc  function called when texture can be deleted
+    @param textureContext      state passed to textureFulfillProc and textureReleaseProc
+    @return                    created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> PromiseTextureFrom(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
+                                         const GrBackendFormat& backendFormat,
+                                         SkISize dimensions,
+                                         skgpu::Mipmapped mipmapped,
+                                         GrSurfaceOrigin origin,
+                                         SkColorType colorType,
+                                         SkAlphaType alphaType,
+                                         sk_sp<SkColorSpace> colorSpace,
+                                         PromiseImageTextureFulfillProc textureFulfillProc,
+                                         PromiseImageTextureReleaseProc textureReleaseProc,
+                                         PromiseImageTextureContext textureContext);
+
+/** This is similar to 'PromiseTextureFrom' but it creates a GPU-backed SkImage from YUV[A] data.
+    The source data may be planar (i.e. spread across multiple textures). In
+    the extreme Y, U, V, and A are all in different planes and thus the image is specified by
+    four textures. 'backendTextureInfo' describes the planar arrangement, texture formats,
+    conversion to RGB, and origin of the textures. Separate 'textureFulfillProc' and
+    'textureReleaseProc' calls are made for each texture. Each texture has its own
+    PromiseImageTextureContext. If 'backendTextureInfo' is not valid then no release proc
+    calls are made. Otherwise, the calls will be made even on failure. 'textureContexts' has one
+    entry for each of the up to four textures, as indicated by 'backendTextureInfo'.
+    Currently the mip mapped property of 'backendTextureInfo' is ignored. However, in the
+    near future it will be required that if it is kYes then textureFulfillProc must return
+    a mip mapped texture for each plane in order to successfully draw the image.
+    @param gpuContextProxy     the thread-safe proxy of the gpu context. required.
+    @param backendTextureInfo  info about the promised yuva gpu texture
+    @param imageColorSpace     range of colors; may be nullptr
+    @param textureFulfillProc  function called to get actual gpu texture
+    @param textureReleaseProc  function called when texture can be deleted
+    @param textureContexts     state passed to textureFulfillProc and textureReleaseProc
+    @return                    created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> PromiseTextureFromYUVA(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
+                                             const GrYUVABackendTextureInfo& backendTextureInfo,
+                                             sk_sp<SkColorSpace> imageColorSpace,
+                                             PromiseImageTextureFulfillProc textureFulfillProc,
+                                             PromiseImageTextureReleaseProc textureReleaseProc,
+                                             PromiseImageTextureContext textureContexts[]);
+
+/** Returns the GPU context associated with this image or nullptr if the image is not Ganesh-backed.
+    We expose this only to help transition certain API calls and do not intend for this to stick
+    around forever.
+*/
+SK_API GrDirectContext* GetContext(const SkImage* src);
+inline GrDirectContext* GetContext(const sk_sp<const SkImage>& src) {
+    return GetContext(src.get());
+}
+
+}  // namespace SkImages
+
+#endif

package/shared/skia/include/private/chromium/SkPMColor.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPMColor_DEFINED
+#define SkPMColor_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/private/SkAPI.h"
+
+#include <cstdint>
+
+/** Returns a SkPMColor value from already premultiplied 8-bit component values.
+
+    @param a  amount of alpha, from fully transparent (0) to fully opaque (255)
+    @param r  amount of red, from no red (0) to full red (255)
+    @param g  amount of green, from no green (0) to full green (255)
+    @param b  amount of blue, from no blue (0) to full blue (255)
+    @return   premultiplied color
+*/
+SK_API SkPMColor SkPMColorSetARGB(SkAlpha a, uint8_t r, uint8_t g, uint8_t b);
+
+/** Returns alpha component of premultiplied color. */
+SK_API SkAlpha SkPMColorGetA(SkPMColor);
+
+/** Returns red component of premultiplied color. */
+SK_API uint8_t SkPMColorGetR(SkPMColor);
+
+/** Returns green component of premultiplied color. */
+SK_API uint8_t SkPMColorGetG(SkPMColor);
+
+/** Returns blue component of premultiplied color. */
+SK_API uint8_t SkPMColorGetB(SkPMColor);
+
+#endif

package/shared/skia/include/private/chromium/Slug.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef sktext_gpu_Slug_DEFINED
+#define sktext_gpu_Slug_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+#include <cstddef>
+#include <cstdint>
+
+class SkCanvas;
+class SkData;
+class SkPaint;
+class SkReadBuffer;
+class SkStrikeClient;
+class SkTextBlob;
+class SkWriteBuffer;
+struct SkDeserialProcs;
+struct SkPoint;
+
+namespace sktext::gpu {
+// Slug encapsulates an SkTextBlob at a specific origin, using a specific paint. It can be
+// manipulated using matrix and clip changes to the canvas. If the canvas is transformed, then
+// the Slug will also transform with smaller glyphs using bi-linear interpolation to render. You
+// can think of a Slug as making a rubber stamp out of a SkTextBlob.
+class SK_API Slug : public SkRefCnt {
+public:
+    // Return nullptr if the blob would not draw. This is not because of clipping, but because of
+    // some paint optimization. The Slug is captured as if drawn using drawTextBlob.
+    static sk_sp<Slug> ConvertBlob(
+            SkCanvas* canvas, const SkTextBlob& blob, SkPoint origin, const SkPaint& paint);
+
+    // Serialize the slug.
+    sk_sp<SkData> serialize() const;
+    size_t serialize(void* buffer, size_t size) const;
+
+    // Set the client parameter to the appropriate SkStrikeClient when typeface ID translation
+    // is needed.
+    static sk_sp<Slug> Deserialize(const void* data,
+                                   size_t size,
+                                   const SkStrikeClient* client = nullptr);
+    static sk_sp<Slug> MakeFromBuffer(SkReadBuffer& buffer);
+
+    // Allows clients to deserialize SkPictures that contain slug data
+    static void AddDeserialProcs(SkDeserialProcs* procs, const SkStrikeClient* client = nullptr);
+
+    // Draw the Slug obeying the canvas's mapping and clipping.
+    void draw(SkCanvas* canvas, const SkPaint& paint) const;
+
+    virtual SkRect sourceBounds() const = 0;
+    virtual SkRect sourceBoundsWithOrigin () const = 0;
+
+    virtual void doFlatten(SkWriteBuffer&) const = 0;
+
+    uint32_t uniqueID() const { return fUniqueID; }
+
+private:
+    static uint32_t NextUniqueID();
+    const uint32_t  fUniqueID{NextUniqueID()};
+};
+
+
+}  // namespace sktext::gpu
+
+#endif  // sktext_gpu_Slug_DEFINED

package/shared/skia/include/private/gpu/ganesh/GrContext_Base.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrContext_Base_DEFINED
+#define GrContext_Base_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/ganesh/GrTypes.h"
+#include "include/private/SkAPI.h"
+
+#include <cstdint>
+
+class GrBaseContextPriv;
+class GrCaps;
+class GrContextThreadSafeProxy;
+class GrDirectContext;
+class GrImageContext;
+class GrRecordingContext;
+enum SkColorType : int;
+enum class SkTextureCompressionType;
+struct GrContextOptions;
+class GrBackendFormat;
+
+class GrContext_Base : public SkRefCnt {
+public:
+    ~GrContext_Base() override;
+
+    /*
+     * Safely downcast to a GrDirectContext.
+     */
+    virtual GrDirectContext* asDirectContext() { return nullptr; }
+
+    /*
+     * The 3D API backing this context
+     */
+    SK_API GrBackendApi backend() const;
+
+    /*
+     * Retrieve the default GrBackendFormat for a given SkColorType and renderability.
+     * It is guaranteed that this backend format will be the one used by the GrContext
+     * SkColorType and GrSurfaceCharacterization-based createBackendTexture methods.
+     *
+     * The caller should check that the returned format is valid.
+     */
+    SK_API GrBackendFormat defaultBackendFormat(SkColorType, GrRenderable) const;
+
+    SK_API GrBackendFormat compressedBackendFormat(SkTextureCompressionType) const;
+
+    /**
+     * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA
+     * rendering is supported for the color type. 0 is returned if rendering to this color type
+     * is not supported at all.
+     */
+    SK_API int maxSurfaceSampleCountForColorType(SkColorType colorType) const;
+
+    // TODO: When the public version is gone, rename to refThreadSafeProxy and add raw ptr ver.
+    sk_sp<GrContextThreadSafeProxy> threadSafeProxy();
+
+    // Provides access to functions that aren't part of the public API.
+    GrBaseContextPriv priv();
+    const GrBaseContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class GrBaseContextPriv; // for hidden functions
+
+    explicit GrContext_Base(sk_sp<GrContextThreadSafeProxy>);
+
+    virtual bool init();
+
+    /**
+     * An identifier for this context. The id is used by all compatible contexts. For example,
+     * if SkImages are created on one thread using an image creation context, then fed into a
+     * DDL Recorder on second thread (which has a recording context) and finally replayed on
+     * a third thread with a direct context, then all three contexts will report the same id.
+     * It is an error for an image to be used with contexts that report different ids.
+     */
+    uint32_t contextID() const;
+
+    bool matches(GrContext_Base* candidate) const {
+        return candidate && candidate->contextID() == this->contextID();
+    }
+
+    /*
+     * The options in effect for this context
+     */
+    const GrContextOptions& options() const;
+
+    const GrCaps* caps() const;
+    sk_sp<const GrCaps> refCaps() const;
+
+    virtual GrImageContext* asImageContext() { return nullptr; }
+    virtual GrRecordingContext* asRecordingContext() { return nullptr; }
+
+    sk_sp<GrContextThreadSafeProxy>         fThreadSafeProxy;
+
+private:
+    using INHERITED = SkRefCnt;
+};
+
+#endif

package/shared/skia/include/private/gpu/ganesh/GrD3DTypesMinimal.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrD3DTypesMinimal_DEFINED
+#define GrD3DTypesMinimal_DEFINED
+
+// Minimal definitions of Direct3D types, without including d3d12.h
+
+#include "include/core/SkRefCnt.h"
+
+#include <dxgiformat.h>
+#include <memory>
+
+#include "include/gpu/ganesh/GrTypes.h"
+
+struct ID3D12Resource;
+class GrD3DResourceState;
+typedef int GrD3DResourceStateEnum;
+struct GrD3DSurfaceInfo;
+struct GrD3DTextureResourceInfo;
+struct GrD3DTextureResourceSpec;
+struct GrD3DFenceInfo;
+
+// This struct is to used to store the the actual information about the Direct3D backend image on
+// GrBackendTexture and GrBackendRenderTarget. When a client calls getD3DTextureInfo on a
+// GrBackendTexture/RenderTarget, we use the GrD3DBackendSurfaceInfo to create a snapshot
+// GrD3DTextureResourceInfo object. Internally, this uses a ref count GrD3DResourceState object to
+// track the current D3D12_RESOURCE_STATES which can be shared with an internal GrD3DTextureResource
+// so that state updates can be seen by all users of the texture.
+struct GrD3DBackendSurfaceInfo {
+    GrD3DBackendSurfaceInfo(const GrD3DTextureResourceInfo& info, sk_sp<GrD3DResourceState> state);
+    ~GrD3DBackendSurfaceInfo();
+
+    GrD3DBackendSurfaceInfo(const GrD3DBackendSurfaceInfo&);
+    GrD3DBackendSurfaceInfo& operator=(const GrD3DBackendSurfaceInfo&);
+
+    GrD3DBackendSurfaceInfo(GrD3DBackendSurfaceInfo&&);
+    GrD3DBackendSurfaceInfo& operator=(GrD3DBackendSurfaceInfo&&);
+
+    void setResourceState(GrD3DResourceStateEnum state);
+
+    sk_sp<GrD3DResourceState> getResourceState() const;
+
+    GrD3DTextureResourceInfo snapTextureResourceInfo() const;
+
+    bool isProtected() const;
+#if defined(GPU_TEST_UTILS)
+    bool operator==(const GrD3DBackendSurfaceInfo& that) const;
+#endif
+
+private:
+    std::unique_ptr<GrD3DTextureResourceInfo> fTextureResourceInfo;
+    sk_sp<GrD3DResourceState> fResourceState;
+};
+
+#endif

package/shared/skia/include/private/gpu/ganesh/GrImageContext.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrImageContext_DEFINED
+#define GrImageContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SingleOwner.h"
+#include "include/private/SkAPI.h"
+#include "include/private/gpu/ganesh/GrContext_Base.h"
+
+class GrContextThreadSafeProxy;
+class GrImageContextPriv;
+
+// This is now just a view on a ThreadSafeProxy, that SkImages can attempt to
+// downcast to a GrDirectContext as a backdoor to some operations. Once we remove the backdoors,
+// this goes away and SkImages just hold ThreadSafeProxies.
+class GrImageContext : public GrContext_Base {
+public:
+    ~GrImageContext() override;
+
+    // Provides access to functions that aren't part of the public API.
+    GrImageContextPriv priv();
+    const GrImageContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class GrImageContextPriv; // for hidden functions
+
+    explicit GrImageContext(sk_sp<GrContextThreadSafeProxy>);
+
+    SK_API virtual void abandonContext();
+    SK_API virtual bool abandoned();
+
+    /** This is only useful for debug purposes */
+    skgpu::SingleOwner* singleOwner() const { return &fSingleOwner; }
+
+    GrImageContext* asImageContext() override { return this; }
+
+private:
+    // When making promise images, we currently need a placeholder GrImageContext instance to give
+    // to the SkImage that has no real power, just a wrapper around the ThreadSafeProxy.
+    // TODO: De-power SkImage to ThreadSafeProxy or at least figure out a way to share one instance.
+    static sk_sp<GrImageContext> MakeForPromiseImage(sk_sp<GrContextThreadSafeProxy>);
+
+    // In debug builds we guard against improper thread handling
+    // This guard is passed to the GrDrawingManager and, from there to all the
+    // GrSurfaceDrawContexts.  It is also passed to the GrResourceProvider and SkGpuDevice.
+    // TODO: Move this down to GrRecordingContext.
+    mutable skgpu::SingleOwner fSingleOwner;
+};
+
+#endif

package/shared/skia/include/private/gpu/ganesh/GrTextureGenerator.h

@@ -0,0 +1,66 @@
+/*
+ * 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 GrTextureGenerator_DEFINED
+#define GrTextureGenerator_DEFINED
+
+#include "include/core/SkImageGenerator.h"
+#include "include/gpu/ganesh/GrTypes.h"
+#include "include/private/SkAPI.h"
+
+#include <cstdint>
+
+class GrRecordingContext;
+class GrSurfaceProxyView;
+enum class GrImageTexGenPolicy : int;
+namespace skgpu { enum class Mipmapped : bool; }
+struct SkImageInfo;
+
+class SK_API GrTextureGenerator : public SkImageGenerator {
+public:
+     bool isTextureGenerator() const final { return true; }
+
+    /**
+     *  If the generator can natively/efficiently return its pixels as a GPU image (backed by a
+     *  texture) this will return that image. If not, this will return NULL.
+     *
+     *  Regarding the GrRecordingContext parameter:
+     *
+     *  It must be non-NULL. The generator should only succeed if:
+     *  - its internal context is the same
+     *  - it can somehow convert its texture into one that is valid for the provided context.
+     *
+     *  If the mipmapped parameter is kYes, the generator should try to create a TextureProxy that
+     *  at least has the mip levels allocated and the base layer filled in. If this is not possible,
+     *  the generator is allowed to return a non mipped proxy, but this will have some additional
+     *  overhead in later allocating mips and copying of the base layer.
+     *
+     *  GrImageTexGenPolicy determines whether or not a new texture must be created (and its budget
+     *  status) or whether this may (but is not required to) return a pre-existing texture that is
+     *  retained by the generator (kDraw).
+     */
+    GrSurfaceProxyView generateTexture(GrRecordingContext*,
+                                       const SkImageInfo& info,
+                                       skgpu::Mipmapped mipmapped,
+                                       GrImageTexGenPolicy);
+
+    // External clients should override GrExternalTextureGenerator instead of trying to implement
+    // this (which uses private Skia types)
+    virtual GrSurfaceProxyView onGenerateTexture(GrRecordingContext*, const SkImageInfo&,
+                                                 skgpu::Mipmapped, GrImageTexGenPolicy) = 0;
+
+    // Most internal SkImageGenerators produce textures and views that use kTopLeft_GrSurfaceOrigin.
+    // If the generator may produce textures with different origins (e.g.
+    // GrAHardwareBufferImageGenerator) it should override this function to return the correct
+    // origin. Implementations should be thread-safe.
+    virtual GrSurfaceOrigin origin() const { return kTopLeft_GrSurfaceOrigin; }
+
+protected:
+    GrTextureGenerator(const SkImageInfo& info, uint32_t uniqueId = kNeedNewImageUniqueID);
+};
+
+#endif  // GrTextureGenerator_DEFINED