@shopify/react-native-skia 1.3.12 → 1.4.0

package/cpp/skia/include/gpu/GrYUVABackendTextures.h

@@ -4,121 +4,5 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-
-#ifndef GrYUVABackendTextures_DEFINED
-#define GrYUVABackendTextures_DEFINED
-
-#include "include/core/SkYUVAInfo.h"
-#include "include/gpu/GrBackendSurface.h"
-
-#include <tuple>
-
-/**
- * A description of a set GrBackendTextures that hold the planar data described by a SkYUVAInfo.
- */
-class SK_API GrYUVABackendTextureInfo {
-public:
-    static constexpr auto kMaxPlanes = SkYUVAInfo::kMaxPlanes;
-
-    /** Default GrYUVABackendTextureInfo is invalid. */
-    GrYUVABackendTextureInfo() = default;
-
-    /**
-     * Initializes a GrYUVABackendTextureInfo to describe a set of textures that can store the
-     * planes indicated by the SkYUVAInfo. The texture dimensions are taken from the SkYUVAInfo's
-     * plane dimensions. All the described textures share a common origin. The planar image this
-     * describes will be mip mapped if all the textures are individually mip mapped as indicated
-     * by skgpu::Mipmapped. This will produce an invalid result (return false from isValid()) if the
-     * passed formats' channels don't agree with SkYUVAInfo.
-     */
-    GrYUVABackendTextureInfo(const SkYUVAInfo&,
-                             const GrBackendFormat[kMaxPlanes],
-                             skgpu::Mipmapped,
-                             GrSurfaceOrigin);
-
-    GrYUVABackendTextureInfo(const GrYUVABackendTextureInfo&) = default;
-
-    GrYUVABackendTextureInfo& operator=(const GrYUVABackendTextureInfo&) = default;
-
-    bool operator==(const GrYUVABackendTextureInfo&) const;
-    bool operator!=(const GrYUVABackendTextureInfo& that) const { return !(*this == that); }
-
-    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
-
-    SkYUVColorSpace yuvColorSpace() const { return fYUVAInfo.yuvColorSpace(); }
-
-    skgpu::Mipmapped mipmapped() const { return fMipmapped; }
-
-    GrSurfaceOrigin textureOrigin() const { return fTextureOrigin; }
-
-    /** The number of SkPixmap planes, 0 if this GrYUVABackendTextureInfo is invalid. */
-    int numPlanes() const { return fYUVAInfo.numPlanes(); }
-
-    /** Format of the ith plane, or invalid format if i >= numPlanes() */
-    const GrBackendFormat& planeFormat(int i) const { return fPlaneFormats[i]; }
-
-    /**
-     * Returns true if this has been configured with a valid SkYUVAInfo with compatible texture
-     * formats.
-     */
-    bool isValid() const { return fYUVAInfo.isValid(); }
-
-    /**
-     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
-     * valid if this->isValid().
-     */
-    SkYUVAInfo::YUVALocations toYUVALocations() const;
-
-private:
-    SkYUVAInfo fYUVAInfo;
-    GrBackendFormat fPlaneFormats[kMaxPlanes];
-    skgpu::Mipmapped fMipmapped = skgpu::Mipmapped::kNo;
-    GrSurfaceOrigin fTextureOrigin = kTopLeft_GrSurfaceOrigin;
-};
-
-/**
- * A set of GrBackendTextures that hold the planar data for an image described a SkYUVAInfo.
- */
-class SK_API GrYUVABackendTextures {
-public:
-    GrYUVABackendTextures() = default;
-    GrYUVABackendTextures(const GrYUVABackendTextures&) = delete;
-    GrYUVABackendTextures(GrYUVABackendTextures&&) = default;
-
-    GrYUVABackendTextures& operator=(const GrYUVABackendTextures&) = delete;
-    GrYUVABackendTextures& operator=(GrYUVABackendTextures&&) = default;
-
-    GrYUVABackendTextures(const SkYUVAInfo&,
-                          const GrBackendTexture[SkYUVAInfo::kMaxPlanes],
-                          GrSurfaceOrigin textureOrigin);
-
-    const std::array<GrBackendTexture, SkYUVAInfo::kMaxPlanes>& textures() const {
-        return fTextures;
-    }
-
-    GrBackendTexture texture(int i) const {
-        SkASSERT(i >= 0 && i < SkYUVAInfo::kMaxPlanes);
-        return fTextures[static_cast<size_t>(i)];
-    }
-
-    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
-
-    int numPlanes() const { return fYUVAInfo.numPlanes(); }
-
-    GrSurfaceOrigin textureOrigin() const { return fTextureOrigin; }
-
-    bool isValid() const { return fYUVAInfo.isValid(); }
-
-    /**
-     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
-     * valid if this->isValid().
-     */
-    SkYUVAInfo::YUVALocations toYUVALocations() const;
-
-private:
-    SkYUVAInfo fYUVAInfo;
-    std::array<GrBackendTexture, SkYUVAInfo::kMaxPlanes> fTextures;
-    GrSurfaceOrigin fTextureOrigin = kTopLeft_GrSurfaceOrigin;
-};
-
-#endif
+// TODO(kjlubick, egdaniel) Delete this after migrating clients.
+#include "include/gpu/ganesh/GrYUVABackendTextures.h"

package/cpp/skia/include/gpu/d3d/GrD3DBackendContext.h

@@ -4,32 +4,5 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-
-#ifndef GrD3DBackendContext_DEFINED
-#define GrD3DBackendContext_DEFINED
-
-// GrD3DTypes.h includes d3d12.h, which in turn includes windows.h, which redefines many
-// common identifiers such as:
-// * interface
-// * small
-// * near
-// * far
-// * CreateSemaphore
-// * MemoryBarrier
-//
-// You should only include GrD3DBackendContext.h if you are prepared to rename those identifiers.
-#include "include/gpu/d3d/GrD3DTypes.h"
-
-#include "include/gpu/GrTypes.h"
-
-// The BackendContext contains all of the base D3D objects needed by the GrD3DGpu. The assumption
-// is that the client will set these up and pass them to the GrD3DGpu constructor.
-struct SK_API GrD3DBackendContext {
-    gr_cp<IDXGIAdapter1> fAdapter;
-    gr_cp<ID3D12Device> fDevice;
-    gr_cp<ID3D12CommandQueue> fQueue;
-    sk_sp<GrD3DMemoryAllocator> fMemoryAllocator;
-    GrProtected fProtectedContext = GrProtected::kNo;
-};
-
-#endif
+// TODO(kjlubick, egdaniel) Delete this after migrating clients.
+#include "include/gpu/ganesh/d3d/GrD3DBackendContext.h"

package/cpp/skia/include/gpu/d3d/GrD3DTypes.h

@@ -1,248 +1,8 @@
-
 /*
  * 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 GrD3DTypes_DEFINED
-#define GrD3DTypes_DEFINED
-
-// This file includes d3d12.h, which in turn includes windows.h, which redefines many
-// common identifiers such as:
-// * interface
-// * small
-// * near
-// * far
-// * CreateSemaphore
-// * MemoryBarrier
-//
-// You should only include this header if you need the Direct3D definitions and are
-// prepared to rename those identifiers.
-
-#include "include/core/SkRefCnt.h"
-#include "include/gpu/GpuTypes.h"
-#include <d3d12.h>
-#include <dxgi1_4.h>
-
-class GrD3DGpu;
-
- /** Check if the argument is non-null, and if so, call obj->AddRef() and return obj.
-  */
-template <typename T> static inline T* GrSafeComAddRef(T* obj) {
-    if (obj) {
-        obj->AddRef();
-    }
-    return obj;
-}
-
-/** Check if the argument is non-null, and if so, call obj->Release()
- */
-template <typename T> static inline void GrSafeComRelease(T* obj) {
-    if (obj) {
-        obj->Release();
-    }
-}
-
-template <typename T> class gr_cp {
-public:
-    using element_type = T;
-
-    constexpr gr_cp() : fObject(nullptr) {}
-    constexpr gr_cp(std::nullptr_t) : fObject(nullptr) {}
-
-    /**
-     *  Shares the underlying object by calling AddRef(), so that both the argument and the newly
-     *  created gr_cp both have a reference to it.
-     */
-    gr_cp(const gr_cp<T>& that) : fObject(GrSafeComAddRef(that.get())) {}
-
-    /**
-     *  Move the underlying object from the argument to the newly created gr_cp. Afterwards only
-     *  the new gr_cp will have a reference to the object, and the argument will point to null.
-     *  No call to AddRef() or Release() will be made.
-     */
-    gr_cp(gr_cp<T>&& that) : fObject(that.release()) {}
-
-    /**
-     *  Adopt the bare object into the newly created gr_cp.
-     *  No call to AddRef() or Release() will be made.
-     */
-    explicit gr_cp(T* obj) {
-        fObject = obj;
-    }
-
-    /**
-     *  Calls Release() on the underlying object pointer.
-     */
-    ~gr_cp() {
-        GrSafeComRelease(fObject);
-        SkDEBUGCODE(fObject = nullptr);
-    }
-
-    /**
-     *  Shares the underlying object referenced by the argument by calling AddRef() on it. If this
-     *  gr_cp previously had a reference to an object (i.e. not null) it will call Release()
-     *  on that object.
-     */
-    gr_cp<T>& operator=(const gr_cp<T>& that) {
-        if (this != &that) {
-            this->reset(GrSafeComAddRef(that.get()));
-        }
-        return *this;
-    }
-
-    /**
-     *  Move the underlying object from the argument to the gr_cp. If the gr_cp
-     *  previously held a reference to another object, Release() will be called on that object.
-     *  No call to AddRef() will be made.
-     */
-    gr_cp<T>& operator=(gr_cp<T>&& that) {
-        this->reset(that.release());
-        return *this;
-    }
-
-    explicit operator bool() const { return this->get() != nullptr; }
-
-    T* get() const { return fObject; }
-    T* operator->() const { return fObject; }
-    T** operator&() { return &fObject; }
-
-    /**
-     *  Adopt the new object, and call Release() on any previously held object (if not null).
-     *  No call to AddRef() will be made.
-     */
-    void reset(T* object = nullptr) {
-        T* oldObject = fObject;
-        fObject = object;
-        GrSafeComRelease(oldObject);
-    }
-
-    /**
-     *  Shares the new object by calling AddRef() on it. If this gr_cp previously had a
-     *  reference to an object (i.e. not null) it will call Release() on that object.
-     */
-    void retain(T* object) {
-        if (this->fObject != object) {
-            this->reset(GrSafeComAddRef(object));
-        }
-    }
-
-    /**
-     *  Return the original object, and set the internal object to nullptr.
-     *  The caller must assume ownership of the object, and manage its reference count directly.
-     *  No call to Release() will be made.
-     */
-    [[nodiscard]] T* release() {
-        T* obj = fObject;
-        fObject = nullptr;
-        return obj;
-    }
-
-private:
-    T* fObject;
-};
-
-template <typename T> inline bool operator==(const gr_cp<T>& a,
-                                             const gr_cp<T>& b) {
-    return a.get() == b.get();
-}
-
-template <typename T> inline bool operator!=(const gr_cp<T>& a,
-                                             const gr_cp<T>& b) {
-    return a.get() != b.get();
-}
-
-// interface classes for the GPU memory allocator
-class GrD3DAlloc : public SkRefCnt {
-public:
-    ~GrD3DAlloc() override = default;
-};
-
-class GrD3DMemoryAllocator : public SkRefCnt {
-public:
-    virtual gr_cp<ID3D12Resource> createResource(D3D12_HEAP_TYPE, const D3D12_RESOURCE_DESC*,
-                                                 D3D12_RESOURCE_STATES initialResourceState,
-                                                 sk_sp<GrD3DAlloc>* allocation,
-                                                 const D3D12_CLEAR_VALUE*) = 0;
-    virtual gr_cp<ID3D12Resource> createAliasingResource(sk_sp<GrD3DAlloc>& allocation,
-                                                         uint64_t localOffset,
-                                                         const D3D12_RESOURCE_DESC*,
-                                                         D3D12_RESOURCE_STATES initialResourceState,
-                                                         const D3D12_CLEAR_VALUE*) = 0;
-};
-
-// Note: there is no notion of Borrowed or Adopted resources in the D3D backend,
-// so Ganesh will ref fResource once it's asked to wrap it.
-// Clients are responsible for releasing their own ref to avoid memory leaks.
-struct GrD3DTextureResourceInfo {
-    gr_cp<ID3D12Resource>    fResource             = nullptr;
-    sk_sp<GrD3DAlloc>        fAlloc                = nullptr;
-    D3D12_RESOURCE_STATES    fResourceState        = D3D12_RESOURCE_STATE_COMMON;
-    DXGI_FORMAT              fFormat               = DXGI_FORMAT_UNKNOWN;
-    uint32_t                 fSampleCount          = 1;
-    uint32_t                 fLevelCount           = 0;
-    unsigned int             fSampleQualityPattern = DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;
-    skgpu::Protected         fProtected            = skgpu::Protected::kNo;
-
-    GrD3DTextureResourceInfo() = default;
-
-    GrD3DTextureResourceInfo(ID3D12Resource* resource,
-                             const sk_sp<GrD3DAlloc> alloc,
-                             D3D12_RESOURCE_STATES resourceState,
-                             DXGI_FORMAT format,
-                             uint32_t sampleCount,
-                             uint32_t levelCount,
-                             unsigned int sampleQualityLevel,
-                             skgpu::Protected isProtected = skgpu::Protected::kNo)
-            : fResource(resource)
-            , fAlloc(alloc)
-            , fResourceState(resourceState)
-            , fFormat(format)
-            , fSampleCount(sampleCount)
-            , fLevelCount(levelCount)
-            , fSampleQualityPattern(sampleQualityLevel)
-            , fProtected(isProtected) {}
-
-    GrD3DTextureResourceInfo(const GrD3DTextureResourceInfo& info,
-                             D3D12_RESOURCE_STATES resourceState)
-            : fResource(info.fResource)
-            , fAlloc(info.fAlloc)
-            , fResourceState(resourceState)
-            , fFormat(info.fFormat)
-            , fSampleCount(info.fSampleCount)
-            , fLevelCount(info.fLevelCount)
-            , fSampleQualityPattern(info.fSampleQualityPattern)
-            , fProtected(info.fProtected) {}
-
-#if defined(GR_TEST_UTILS)
-    bool operator==(const GrD3DTextureResourceInfo& that) const {
-        return fResource == that.fResource && fResourceState == that.fResourceState &&
-               fFormat == that.fFormat && fSampleCount == that.fSampleCount &&
-               fLevelCount == that.fLevelCount &&
-               fSampleQualityPattern == that.fSampleQualityPattern && fProtected == that.fProtected;
-    }
-#endif
-};
-
-struct GrD3DFenceInfo {
-    GrD3DFenceInfo()
-        : fFence(nullptr)
-        , fValue(0) {
-    }
-
-    gr_cp<ID3D12Fence> fFence;
-    uint64_t           fValue;  // signal value for the fence
-};
-
-struct GrD3DSurfaceInfo {
-    uint32_t fSampleCount = 1;
-    uint32_t fLevelCount = 0;
-    skgpu::Protected fProtected = skgpu::Protected::kNo;
-
-    DXGI_FORMAT fFormat = DXGI_FORMAT_UNKNOWN;
-    unsigned int fSampleQualityPattern = DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;
-};
-
-#endif
+// TODO(kjlubick, egdaniel) Delete this after migrating clients.
+#include "include/gpu/ganesh/d3d/GrD3DTypes.h"

package/cpp/skia/include/gpu/ganesh/GrBackendSemaphore.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrBackendSemaphore_DEFINED
+#define GrBackendSemaphore_DEFINED
+
+#include "include/gpu/ganesh/GrTypes.h"  // IWYU pragma: keep
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAnySubclass.h"
+
+#ifdef SK_DIRECT3D
+#include "include/private/gpu/ganesh/GrD3DTypesMinimal.h"
+#endif
+
+#include <cstddef>
+
+class GrBackendSemaphoreData;
+
+/**
+ * Wrapper class for passing into and receiving data from Ganesh about a backend semaphore object.
+ */
+class SK_API GrBackendSemaphore {
+public:
+    // The GrBackendSemaphore cannot be used until either init* is called, which will set the
+    // appropriate GrBackend.
+    GrBackendSemaphore();
+    ~GrBackendSemaphore();
+    GrBackendSemaphore(const GrBackendSemaphore&);
+    GrBackendSemaphore& operator=(const GrBackendSemaphore&);
+
+#ifdef SK_DIRECT3D
+    void initDirect3D(const GrD3DFenceInfo& info) {
+        fBackend = GrBackendApi::kDirect3D;
+        this->assignD3DFenceInfo(info);
+        fIsInitialized = true;
+    }
+#endif
+
+    bool isInitialized() const { return fIsInitialized; }
+    GrBackendApi backend() const { return fBackend; }
+
+#ifdef SK_DIRECT3D
+    bool getD3DFenceInfo(GrD3DFenceInfo* outInfo) const;
+#endif
+
+private:
+    friend class GrBackendSemaphorePriv;
+    friend class GrBackendSemaphoreData;
+    // Size determined by looking at the GrBackendSemaphoreData subclasses, then
+    // guessing-and-checking. Compiler will complain if this is too small - in that case,
+    // just increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 24;
+    using AnySemaphoreData = SkAnySubclass<GrBackendSemaphoreData, kMaxSubclassSize>;
+
+    template <typename SemaphoreData>
+    GrBackendSemaphore(GrBackendApi api, SemaphoreData data) : fBackend(api), fIsInitialized(true) {
+        fSemaphoreData.emplace<SemaphoreData>(data);
+    }
+
+#ifdef SK_DIRECT3D
+    void assignD3DFenceInfo(const GrD3DFenceInfo& info);
+#endif
+
+    GrBackendApi fBackend;
+    AnySemaphoreData fSemaphoreData;
+
+    union {
+        void* fPlaceholder;  // TODO(293490566)
+#ifdef SK_DIRECT3D
+        GrD3DFenceInfo* fD3DFenceInfo;
+#endif
+    };
+    bool fIsInitialized;
+};
+
+#endif