@shopify/react-native-skia 0.1.192 → 0.1.193

package/cpp/skia/include/core/SkSurface.h

@@ -9,41 +9,61 @@
 #define SkSurface_DEFINED
 
 #include "include/core/SkImage.h"
+#include "include/core/SkImageInfo.h"
 #include "include/core/SkPixmap.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSamplingOptions.h"
+#include "include/core/SkScalar.h"
 #include "include/core/SkSurfaceProps.h"
+#include "include/core/SkTypes.h"
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
 #include "include/gpu/GrTypes.h"
+#else
+enum GrSurfaceOrigin: int;
+#endif
+
+#if defined(SK_GRAPHITE)
+#include "include/gpu/GpuTypes.h"
+namespace skgpu::graphite {
+class BackendTexture;
+}
 #endif
 
 #if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26
 #include <android/hardware_buffer.h>
+class GrDirectContext;
 #endif
 
-#if SK_SUPPORT_GPU && defined(SK_METAL)
+#if defined(SK_GANESH) && defined(SK_METAL)
 #include "include/gpu/mtl/GrMtlTypes.h"
 #endif
 
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+class GrBackendRenderTarget;
+class GrBackendSemaphore;
+class GrBackendTexture;
+class GrRecordingContext;
+class SkBitmap;
 class SkCanvas;
 class SkCapabilities;
+class SkColorSpace;
 class SkDeferredDisplayList;
 class SkPaint;
 class SkSurfaceCharacterization;
-class GrBackendRenderTarget;
-class GrBackendSemaphore;
-class GrBackendTexture;
-class GrDirectContext;
-class GrRecordingContext;
-class GrRenderTarget;
-enum GrSurfaceOrigin: int;
+enum SkColorType : int;
+struct SkIRect;
+struct SkISize;
 
 namespace skgpu {
 class MutableTextureState;
+enum class Budgeted : bool;
 }
 
 namespace skgpu::graphite {
-class BackendTexture;
 class Recorder;
 }
 
@@ -206,7 +226,7 @@ public:
         backend API (accounting only for use of the texture by this surface). If SkSurface creation
         fails textureReleaseProc is called before this function returns.
 
-        If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.
+        If defined(SK_GANESH) is defined as zero, has no effect and returns nullptr.
 
         @param context             GPU context
         @param backendTexture      texture residing on GPU
@@ -241,7 +261,7 @@ public:
         backend API (accounting only for use of the render target by this surface). If SkSurface
         creation fails releaseProc is called before this function returns.
 
-        If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.
+        If defined(SK_GANESH) is defined as zero, has no effect and returns nullptr.
 
         @param context                  GPU context
         @param backendRenderTarget      GPU intermediate memory buffer
@@ -276,7 +296,7 @@ public:
 
         shouldCreateWithMips hints that SkImage returned by makeImageSnapshot() is mip map.
 
-        If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.
+        If defined(SK_GANESH) is defined as zero, has no effect and returns nullptr.
 
         @param context               GPU context
         @param imageInfo             width, height, SkColorType, SkAlphaType, SkColorSpace;
@@ -287,9 +307,11 @@ public:
         @param shouldCreateWithMips  hint that SkSurface will host mip map images
         @return                      SkSurface if all parameters are valid; otherwise, nullptr
     */
-    static sk_sp<SkSurface> MakeRenderTarget(GrRecordingContext* context, SkBudgeted budgeted,
+    static sk_sp<SkSurface> MakeRenderTarget(GrRecordingContext* context,
+                                             skgpu::Budgeted budgeted,
                                              const SkImageInfo& imageInfo,
-                                             int sampleCount, GrSurfaceOrigin surfaceOrigin,
+                                             int sampleCount,
+                                             GrSurfaceOrigin surfaceOrigin,
                                              const SkSurfaceProps* surfaceProps,
                                              bool shouldCreateWithMips = false);
 
@@ -314,10 +336,12 @@ public:
                             fonts; may be nullptr
         @return             SkSurface if all parameters are valid; otherwise, nullptr
     */
-    static sk_sp<SkSurface> MakeRenderTarget(GrRecordingContext* context, SkBudgeted budgeted,
-                                             const SkImageInfo& imageInfo, int sampleCount,
+    static sk_sp<SkSurface> MakeRenderTarget(GrRecordingContext* context,
+                                             skgpu::Budgeted budgeted,
+                                             const SkImageInfo& imageInfo,
+                                             int sampleCount,
                                              const SkSurfaceProps* surfaceProps) {
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
         return MakeRenderTarget(context, budgeted, imageInfo, sampleCount,
                                 kBottomLeft_GrSurfaceOrigin, surfaceProps);
 #else
@@ -339,9 +363,10 @@ public:
                           of raster surface; width, or height, or both, may be zero
         @return           SkSurface if all parameters are valid; otherwise, nullptr
     */
-    static sk_sp<SkSurface> MakeRenderTarget(GrRecordingContext* context, SkBudgeted budgeted,
+    static sk_sp<SkSurface> MakeRenderTarget(GrRecordingContext* context,
+                                             skgpu::Budgeted budgeted,
                                              const SkImageInfo& imageInfo) {
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
         if (!imageInfo.width() || !imageInfo.height()) {
             return nullptr;
         }
@@ -362,8 +387,7 @@ public:
     */
     static sk_sp<SkSurface> MakeRenderTarget(GrRecordingContext* context,
                                              const SkSurfaceCharacterization& characterization,
-                                             SkBudgeted budgeted);
-
+                                             skgpu::Budgeted budgeted);
 
 #if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26
     /** Private.
@@ -398,7 +422,7 @@ public:
                                                     );
 #endif
 
-#ifdef SK_GRAPHITE_ENABLED
+#if defined(SK_GRAPHITE)
     /**
      * In Graphite, while clients hold a ref on an SkSurface, the backing gpu object does _not_
      * count against the budget. Once an SkSurface is freed, the backing gpu object may or may
@@ -408,7 +432,7 @@ public:
     static sk_sp<SkSurface> MakeGraphite(
             skgpu::graphite::Recorder*,
             const SkImageInfo& imageInfo,
-            skgpu::graphite::Mipmapped = skgpu::graphite::Mipmapped::kNo,
+            skgpu::Mipmapped = skgpu::Mipmapped::kNo,
             const SkSurfaceProps* surfaceProps = nullptr);
 
     /**
@@ -430,9 +454,9 @@ public:
                                                            sk_sp<SkColorSpace> colorSpace,
                                                            const SkSurfaceProps* props);
 
-#endif // SK_GRAPHITE_ENABLED
+#endif // SK_GRAPHITE
 
-#if SK_SUPPORT_GPU && defined(SK_METAL)
+#if defined(SK_GANESH) && defined(SK_METAL)
     /** Creates SkSurface from CAMetalLayer.
         Returned SkSurface takes a reference on the CAMetalLayer. The ref on the layer will be
         released when the SkSurface is destroyed.
@@ -525,7 +549,7 @@ public:
 
     /** Returns an ImageInfo describing the surface.
      */
-    SkImageInfo imageInfo();
+    virtual SkImageInfo imageInfo() const { return SkImageInfo::MakeUnknown(fWidth, fHeight); }
 
     /** Returns unique value identifying the content of SkSurface. Returned value changes
         each time the content changes. Content is changed by drawing, or by calling
@@ -566,7 +590,7 @@ public:
      */
     skgpu::graphite::Recorder* recorder();
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
     enum BackendHandleAccess {
         kFlushRead_BackendHandleAccess,    //!< back-end object is readable
         kFlushWrite_BackendHandleAccess,   //!< back-end object is writable
@@ -669,7 +693,7 @@ public:
 
     /** Returns SkImage capturing SkSurface contents. Subsequent drawing to SkSurface contents
         are not captured. SkImage allocation is accounted for if SkSurface was created with
-        SkBudgeted::kYes.
+        skgpu::Budgeted::kYes.
 
         @return  SkImage initialized with SkSurface contents
 
@@ -690,6 +714,34 @@ public:
      */
     sk_sp<SkImage> makeImageSnapshot(const SkIRect& bounds);
 
+#if defined(SK_GRAPHITE)
+    /**
+     * The 'asImage' and 'makeImageCopy' API/entry points are currently only available for
+     * Graphite.
+     *
+     * In this API, SkSurface no longer supports copy-on-write behavior. Instead, when creating
+     * an image for a surface, the client must explicitly indicate if a copy should be made.
+     * In both of the below calls the resource backing the surface will never change.
+     *
+     * The 'asImage' entry point has some major ramifications for the mutability of the
+     * returned SkImage. Since the originating surface and the returned image share the
+     * same backing, care must be taken by the client to ensure that the contents of the image
+     * reflect the desired contents when it is consumed by the gpu.
+     * Note: if the backing GPU buffer isn't textureable this method will return null. Graphite
+     * will not attempt to make a copy.
+     * Note: For 'asImage', the mipmapping of the image will match that of the source surface.
+     *
+     * The 'makeImageCopy' entry point allows subsetting and the addition of mipmaps (since
+     * a copy is already being made).
+     *
+     * In Graphite, the legacy API call (i.e., makeImageSnapshot) will just always make a copy.
+     */
+    sk_sp<SkImage> asImage();
+
+    sk_sp<SkImage> makeImageCopy(const SkIRect* subset = nullptr,
+                                 skgpu::Mipmapped mipmapped = skgpu::Mipmapped::kNo);
+#endif
+
     /** Draws SkSurface contents to canvas, with its top-left corner at (x, y).
 
         If SkPaint paint is not nullptr, apply SkColorFilter, alpha, SkImageFilter, and SkBlendMode.
@@ -834,36 +886,6 @@ public:
     using RescaleGamma = SkImage::RescaleGamma;
     using RescaleMode  = SkImage::RescaleMode;
 
-    /** Makes surface pixel data available to caller, possibly asynchronously.
-
-        Currently asynchronous reads are only supported on the GPU backend and only when the
-        underlying 3D API supports transfer buffers and CPU/GPU synchronization primitives. In all
-        other cases this operates synchronously.
-
-        Data is read from the source sub-rectangle, then converted to the color space, color type,
-        and alpha type of 'info'. A 'srcRect' that is not contained by the bounds of the surface
-        causes failure.
-
-        When the pixel data is ready the caller's ReadPixelsCallback is called with a
-        AsyncReadResult containing pixel data in the requested color type, alpha type, and color
-        space. The AsyncReadResult will have count() == 1. Upon failure the callback is called
-        with nullptr for AsyncReadResult. For a GPU surface this flushes work but a submit must
-        occur to guarantee a finite time before the callback is called.
-
-        The data is valid for the lifetime of AsyncReadResult with the exception that if the
-        SkSurface is GPU-backed the data is immediately invalidated if the context is abandoned
-        or destroyed.
-
-        @param info            info of the requested pixels
-        @param srcRect         subrectangle of surface to read
-        @param callback        function to call with result of the read
-        @param context         passed to callback
-     */
-    void asyncReadPixels(const SkImageInfo& info,
-                         const SkIRect& srcRect,
-                         ReadPixelsCallback callback,
-                         ReadPixelsContext context);
-
     /** Makes surface pixel data available to caller, possibly asynchronously. It can also rescale
         the surface pixels.
 
@@ -994,7 +1016,7 @@ public:
         kPresent,   //!< back-end surface will be used for presenting to screen
     };
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
     /** If a surface is GPU texture backed, is being drawn with MSAA, and there is a resolve
         texture, this call will insert a resolve command into the stream of gpu commands. In order
         for the resolve to actually have an effect, the work still needs to be flushed and submitted
@@ -1100,7 +1122,7 @@ public:
     */
     GrSemaphoresSubmitted flush(const GrFlushInfo& info,
                                 const skgpu::MutableTextureState* newState = nullptr);
-#endif // SK_SUPPORT_GPU
+#endif // defined(SK_GANESH)
 
     void flush();
 

package/cpp/skia/include/core/SkSurfaceCharacterization.h

@@ -17,7 +17,7 @@
 class SkColorSpace;
 
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
 #include "include/gpu/GrBackendSurface.h"
 #include "include/gpu/GrContextThreadSafeProxy.h"
 #include "include/gpu/GrTypes.h"
@@ -118,7 +118,7 @@ public:
     bool isCompatible(const GrBackendTexture&) const;
 
 private:
-    friend class SkSurface_Gpu; // for 'set' & 'config'
+    friend class SkSurface_Ganesh;           // for 'set' & 'config'
     friend class GrVkSecondaryCBDrawContext; // for 'set' & 'config'
     friend class GrContextThreadSafeProxy; // for private ctor
     friend class SkDeferredDisplayListRecorder; // for 'config'
@@ -210,7 +210,7 @@ private:
     SkSurfaceProps                  fSurfaceProps;
 };
 
-#else// !SK_SUPPORT_GPU
+#else// !defined(SK_GANESH)
 class GrBackendFormat;
 
 class SK_API SkSurfaceCharacterization {

package/cpp/skia/include/core/SkSurfaceProps.h

@@ -9,6 +9,7 @@
 #define SkSurfaceProps_DEFINED
 
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkTo.h"
 
 /**
  *  Description of how the LCD strips are arranged for each pixel. If this is unknown, or the
@@ -53,7 +54,10 @@ public:
     enum Flags {
         kUseDeviceIndependentFonts_Flag = 1 << 0,
         // Use internal MSAA to render to non-MSAA GPU surfaces.
-        kDynamicMSAA_Flag               = 1 << 1
+        kDynamicMSAA_Flag               = 1 << 1,
+        // If set, all rendering will have dithering enabled
+        // Currently this only impacts GPU backends
+        kAlwaysDither_Flag              = 1 << 2,
     };
     /** Deprecated alias used by Chromium. Will be removed. */
     static const Flags kUseDistanceFieldFonts_Flag = kUseDeviceIndependentFonts_Flag;
@@ -76,6 +80,10 @@ public:
         return SkToBool(fFlags & kUseDeviceIndependentFonts_Flag);
     }
 
+    bool isAlwaysDither() const {
+        return SkToBool(fFlags & kAlwaysDither_Flag);
+    }
+
     bool operator==(const SkSurfaceProps& that) const {
         return fFlags == that.fFlags && fPixelGeometry == that.fPixelGeometry;
     }

package/cpp/skia/include/core/SkTextBlob.h

@@ -12,7 +12,7 @@
 #include "include/core/SkPaint.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkString.h"
-#include "include/private/SkTemplates.h"
+#include "include/private/base/SkTemplates.h"
 
 #include <atomic>
 
@@ -491,7 +491,7 @@ private:
     friend class SkTextBlobPriv;
     friend class SkTextBlobBuilderPriv;
 
-    SkAutoTMalloc<uint8_t> fStorage;
+    skia_private::AutoTMalloc<uint8_t> fStorage;
     size_t                 fStorageSize;
     size_t                 fStorageUsed;
 

package/cpp/skia/include/core/SkTextureCompressionType.h

@@ -0,0 +1,30 @@
+/*
+ * 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 SkTextureCompressionType_DEFINED
+#define SkTextureCompressionType_DEFINED
+/*
+ *   Skia                | GL_COMPRESSED_*     | MTLPixelFormat*      | VK_FORMAT_*_BLOCK
+ *  --------------------------------------------------------------------------------------
+ *   kETC2_RGB8_UNORM    | ETC1_RGB8           | ETC2_RGB8 (iOS-only) | ETC2_R8G8B8_UNORM
+ *                       | RGB8_ETC2           |                      |
+ *  --------------------------------------------------------------------------------------
+ *   kBC1_RGB8_UNORM     | RGB_S3TC_DXT1_EXT   | N/A                  | BC1_RGB_UNORM
+ *  --------------------------------------------------------------------------------------
+ *   kBC1_RGBA8_UNORM    | RGBA_S3TC_DXT1_EXT  | BC1_RGBA (macOS-only)| BC1_RGBA_UNORM
+ */
+enum class SkTextureCompressionType {
+    kNone,
+    kETC2_RGB8_UNORM,
+
+    kBC1_RGB8_UNORM,
+    kBC1_RGBA8_UNORM,
+    kLast = kBC1_RGBA8_UNORM,
+    kETC1_RGB8 = kETC2_RGB8_UNORM,
+};
+
+#endif

package/cpp/skia/include/core/SkTime.h

@@ -11,7 +11,7 @@
 #define SkTime_DEFINED
 
 #include "include/core/SkTypes.h"
-#include "include/private/SkMacros.h"
+#include "include/private/base/SkMacros.h"
 
 #include <cinttypes>
 

package/cpp/skia/include/core/SkTypeface.h

@@ -14,8 +14,8 @@
 #include "include/core/SkFontTypes.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkString.h"
-#include "include/private/SkOnce.h"
 #include "include/private/SkWeakRefCnt.h"
+#include "include/private/base/SkOnce.h"
 
 class SkData;
 class SkDescriptor;
@@ -360,6 +360,12 @@ public:
         return this->onGetCTFontRef();
     }
 
+    /* Skia reserves all tags that begin with a lower case letter and 0 */
+    using FactoryId = SkFourByteTag;
+    static void Register(
+            FactoryId id,
+            sk_sp<SkTypeface> (*make)(std::unique_ptr<SkStreamAsset>, const SkFontArguments&));
+
 protected:
     explicit SkTypeface(const SkFontStyle& style, bool isFixedPitch = false);
     ~SkTypeface() override;
@@ -435,7 +441,8 @@ private:
      *  typefaces that contain a COLR table.
      */
     bool glyphMaskNeedsCurrentColor() const;
-    friend class SkStrikeServerImpl; // glyphMaskNeedsCurrentColor
+    friend class SkStrikeServerImpl;  // glyphMaskNeedsCurrentColor
+    friend class SkTypefaceProxyPrototype;  // glyphMaskNeedsCurrentColor
 
     /** Retrieve detailed typeface metrics.  Used by the PDF backend.  */
     std::unique_ptr<SkAdvancedTypefaceMetrics> getAdvancedMetrics() const;