@shopify/react-native-skia 1.3.12 → 1.4.0

package/cpp/skia/src/base/SkMathPriv.h

@@ -0,0 +1,337 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkMathPriv_DEFINED
+#define SkMathPriv_DEFINED
+
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkCPUTypes.h"
+#include "include/private/base/SkTemplates.h"
+
+#include <cstddef>
+#include <cstdint>
+
+/**
+ *  Return the integer square root of value, with a bias of bitBias
+ */
+int32_t SkSqrtBits(int32_t value, int bitBias);
+
+/** Return the integer square root of n, treated as a SkFixed (16.16)
+ */
+static inline int32_t SkSqrt32(int32_t n) { return SkSqrtBits(n, 15); }
+
+/**
+ *  Returns (value < 0 ? 0 : value) efficiently (i.e. no compares or branches)
+ */
+static inline int SkClampPos(int value) {
+    return value & ~(value >> 31);
+}
+
+/**
+ * Stores numer/denom and numer%denom into div and mod respectively.
+ */
+template <typename In, typename Out>
+inline void SkTDivMod(In numer, In denom, Out* div, Out* mod) {
+    *div = static_cast<Out>(numer/denom);
+    *mod = static_cast<Out>(numer%denom);
+}
+
+/** Returns -1 if n < 0, else returns 0
+ */
+#define SkExtractSign(n)    ((int32_t)(n) >> 31)
+
+/** If sign == -1, returns -n, else sign must be 0, and returns n.
+ Typically used in conjunction with SkExtractSign().
+ */
+static inline int32_t SkApplySign(int32_t n, int32_t sign) {
+    SkASSERT(sign == 0 || sign == -1);
+    return (n ^ sign) - sign;
+}
+
+/** Return x with the sign of y */
+static inline int32_t SkCopySign32(int32_t x, int32_t y) {
+    return SkApplySign(x, SkExtractSign(x ^ y));
+}
+
+/** Given a positive value and a positive max, return the value
+ pinned against max.
+ Note: only works as long as max - value doesn't wrap around
+ @return max if value >= max, else value
+ */
+static inline unsigned SkClampUMax(unsigned value, unsigned max) {
+    if (value > max) {
+        value = max;
+    }
+    return value;
+}
+
+// If a signed int holds min_int (e.g. 0x80000000) it is undefined what happens when
+// we negate it (even though we *know* we're 2's complement and we'll get the same
+// value back). So we create this helper function that casts to size_t (unsigned) first,
+// to avoid the complaint.
+static inline size_t sk_negate_to_size_t(int32_t value) {
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4146)  // Thanks MSVC, we know what we're negating an unsigned
+#endif
+    return -static_cast<size_t>(value);
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/** Return a*b/255, truncating away any fractional bits. Only valid if both
+ a and b are 0..255
+ */
+static inline U8CPU SkMulDiv255Trunc(U8CPU a, U8CPU b) {
+    SkASSERT((uint8_t)a == a);
+    SkASSERT((uint8_t)b == b);
+    unsigned prod = a*b + 1;
+    return (prod + (prod >> 8)) >> 8;
+}
+
+/** Return (a*b)/255, taking the ceiling of any fractional bits. Only valid if
+ both a and b are 0..255. The expected result equals (a * b + 254) / 255.
+ */
+static inline U8CPU SkMulDiv255Ceiling(U8CPU a, U8CPU b) {
+    SkASSERT((uint8_t)a == a);
+    SkASSERT((uint8_t)b == b);
+    unsigned prod = a*b + 255;
+    return (prod + (prod >> 8)) >> 8;
+}
+
+/** Just the rounding step in SkDiv255Round: round(value / 255)
+ */
+static inline unsigned SkDiv255Round(unsigned prod) {
+    prod += 128;
+    return (prod + (prod >> 8)) >> 8;
+}
+
+/**
+ * Swap byte order of a 4-byte value, e.g. 0xaarrggbb -> 0xbbggrraa.
+ */
+#if defined(_MSC_VER)
+    #include <stdlib.h>
+    static inline uint32_t SkBSwap32(uint32_t v) { return _byteswap_ulong(v); }
+#else
+    static inline uint32_t SkBSwap32(uint32_t v) { return __builtin_bswap32(v); }
+#endif
+
+/*
+ * Return the number of set bits (i.e., the population count) in the provided uint32_t.
+ */
+int SkPopCount_portable(uint32_t n);
+
+#if defined(__GNUC__) || defined(__clang__)
+    static inline int SkPopCount(uint32_t n) {
+        return __builtin_popcount(n);
+    }
+#else
+    static inline int SkPopCount(uint32_t n) {
+        return SkPopCount_portable(n);
+    }
+#endif
+
+/*
+ * Return the 0-based index of the nth bit set in target
+ * Returns 32 if there is no nth bit set.
+ */
+int SkNthSet(uint32_t target, int n);
+
+//! Returns the number of leading zero bits (0...32)
+// From Hacker's Delight 2nd Edition
+constexpr int SkCLZ_portable(uint32_t x) {
+    int n = 32;
+    uint32_t y = x >> 16; if (y != 0) {n -= 16; x = y;}
+             y = x >>  8; if (y != 0) {n -=  8; x = y;}
+             y = x >>  4; if (y != 0) {n -=  4; x = y;}
+             y = x >>  2; if (y != 0) {n -=  2; x = y;}
+             y = x >>  1; if (y != 0) {return n - 2;}
+    return n - static_cast<int>(x);
+}
+
+static_assert(32 == SkCLZ_portable(0));
+static_assert(31 == SkCLZ_portable(1));
+static_assert( 1 == SkCLZ_portable(1 << 30));
+static_assert( 1 == SkCLZ_portable((1 << 30) | (1 << 24) | 1));
+static_assert( 0 == SkCLZ_portable(~0U));
+
+#if defined(SK_BUILD_FOR_WIN)
+    #include <intrin.h>
+
+    static inline int SkCLZ(uint32_t mask) {
+        if (mask) {
+            unsigned long index = 0;
+            _BitScanReverse(&index, mask);
+            // Suppress this bogus /analyze warning. The check for non-zero
+            // guarantees that _BitScanReverse will succeed.
+            #pragma warning(push)
+            #pragma warning(suppress : 6102) // Using 'index' from failed function call
+            return static_cast<int>(index ^ 0x1F);
+            #pragma warning(pop)
+        } else {
+            return 32;
+        }
+    }
+#elif defined(SK_CPU_ARM32) || defined(__GNUC__) || defined(__clang__)
+    static inline int SkCLZ(uint32_t mask) {
+        // __builtin_clz(0) is undefined, so we have to detect that case.
+        return mask ? __builtin_clz(mask) : 32;
+    }
+#else
+    static inline int SkCLZ(uint32_t mask) {
+        return SkCLZ_portable(mask);
+    }
+#endif
+
+//! Returns the number of trailing zero bits (0...32)
+// From Hacker's Delight 2nd Edition
+constexpr int SkCTZ_portable(uint32_t x) {
+    return 32 - SkCLZ_portable(~x & (x - 1));
+}
+
+static_assert(32 == SkCTZ_portable(0));
+static_assert( 0 == SkCTZ_portable(1));
+static_assert(30 == SkCTZ_portable(1 << 30));
+static_assert( 2 == SkCTZ_portable((1 << 30) | (1 << 24) | (1 << 2)));
+static_assert( 0 == SkCTZ_portable(~0U));
+
+#if defined(SK_BUILD_FOR_WIN)
+    #include <intrin.h>
+
+    static inline int SkCTZ(uint32_t mask) {
+        if (mask) {
+            unsigned long index = 0;
+            _BitScanForward(&index, mask);
+            // Suppress this bogus /analyze warning. The check for non-zero
+            // guarantees that _BitScanReverse will succeed.
+            #pragma warning(push)
+            #pragma warning(suppress : 6102) // Using 'index' from failed function call
+            return static_cast<int>(index);
+            #pragma warning(pop)
+        } else {
+            return 32;
+        }
+    }
+#elif defined(SK_CPU_ARM32) || defined(__GNUC__) || defined(__clang__)
+    static inline int SkCTZ(uint32_t mask) {
+        // __builtin_ctz(0) is undefined, so we have to detect that case.
+        return mask ? __builtin_ctz(mask) : 32;
+    }
+#else
+    static inline int SkCTZ(uint32_t mask) {
+        return SkCTZ_portable(mask);
+    }
+#endif
+
+/**
+ *  Returns the log2 of the specified value, were that value to be rounded up
+ *  to the next power of 2. It is undefined to pass 0. Examples:
+ *  SkNextLog2(1) -> 0
+ *  SkNextLog2(2) -> 1
+ *  SkNextLog2(3) -> 2
+ *  SkNextLog2(4) -> 2
+ *  SkNextLog2(5) -> 3
+ */
+static inline int SkNextLog2(uint32_t value) {
+    SkASSERT(value != 0);
+    return 32 - SkCLZ(value - 1);
+}
+
+constexpr int SkNextLog2_portable(uint32_t value) {
+    SkASSERT(value != 0);
+    return 32 - SkCLZ_portable(value - 1);
+}
+
+/**
+*  Returns the log2 of the specified value, were that value to be rounded down
+*  to the previous power of 2. It is undefined to pass 0. Examples:
+*  SkPrevLog2(1) -> 0
+*  SkPrevLog2(2) -> 1
+*  SkPrevLog2(3) -> 1
+*  SkPrevLog2(4) -> 2
+*  SkPrevLog2(5) -> 2
+*/
+static inline int SkPrevLog2(uint32_t value) {
+    SkASSERT(value != 0);
+    return 32 - SkCLZ(value >> 1);
+}
+
+constexpr int SkPrevLog2_portable(uint32_t value) {
+    SkASSERT(value != 0);
+    return 32 - SkCLZ_portable(value >> 1);
+}
+
+/**
+ *  Returns the smallest power-of-2 that is >= the specified value. If value
+ *  is already a power of 2, then it is returned unchanged. It is undefined
+ *  if value is <= 0.
+ */
+static inline int SkNextPow2(int value) {
+    SkASSERT(value > 0);
+    return 1 << SkNextLog2(static_cast<uint32_t>(value));
+}
+
+constexpr int SkNextPow2_portable(int value) {
+    SkASSERT(value > 0);
+    return 1 << SkNextLog2_portable(static_cast<uint32_t>(value));
+}
+
+/**
+*  Returns the largest power-of-2 that is <= the specified value. If value
+*  is already a power of 2, then it is returned unchanged. It is undefined
+*  if value is <= 0.
+*/
+static inline int SkPrevPow2(int value) {
+    SkASSERT(value > 0);
+    return 1 << SkPrevLog2(static_cast<uint32_t>(value));
+}
+
+constexpr int SkPrevPow2_portable(int value) {
+    SkASSERT(value > 0);
+    return 1 << SkPrevLog2_portable(static_cast<uint32_t>(value));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Return the smallest power-of-2 >= n.
+ */
+static inline uint32_t GrNextPow2(uint32_t n) {
+    return n ? (1 << (32 - SkCLZ(n - 1))) : 1;
+}
+
+/**
+ * Returns the next power of 2 >= n or n if the next power of 2 can't be represented by size_t.
+ */
+static inline size_t GrNextSizePow2(size_t n) {
+    constexpr int kNumSizeTBits = 8 * sizeof(size_t);
+    constexpr size_t kHighBitSet = size_t(1) << (kNumSizeTBits - 1);
+
+    if (!n) {
+        return 1;
+    } else if (n >= kHighBitSet) {
+        return n;
+    }
+
+    n--;
+    uint32_t shift = 1;
+    while (shift < kNumSizeTBits) {
+        n |= n >> shift;
+        shift <<= 1;
+    }
+    return n + 1;
+}
+
+// conservative check. will return false for very large values that "could" fit
+template <typename T> static inline bool SkFitsInFixed(T x) {
+    return SkTAbs(x) <= 32767.0f;
+}
+
+#endif

package/cpp/skia/src/base/SkTLazy.h

@@ -0,0 +1,208 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTLazy_DEFINED
+#define SkTLazy_DEFINED
+
+#include "include/private/base/SkAssert.h"
+
+#include <optional>
+#include <utility>
+
+/**
+ *  Efficient way to defer allocating/initializing a class until it is needed
+ *  (if ever).
+ */
+template <typename T> class SkTLazy {
+public:
+    SkTLazy() = default;
+    explicit SkTLazy(const T* src) : fValue(src ? std::optional<T>(*src) : std::nullopt) {}
+    SkTLazy(const SkTLazy& that) : fValue(that.fValue) {}
+    SkTLazy(SkTLazy&& that) : fValue(std::move(that.fValue)) {}
+
+    ~SkTLazy() = default;
+
+    SkTLazy& operator=(const SkTLazy& that) {
+        fValue = that.fValue;
+        return *this;
+    }
+
+    SkTLazy& operator=(SkTLazy&& that) {
+        fValue = std::move(that.fValue);
+        return *this;
+    }
+
+    /**
+     *  Return a pointer to an instance of the class initialized with 'args'.
+     *  If a previous instance had been initialized (either from init() or
+     *  set()) it will first be destroyed, so that a freshly initialized
+     *  instance is always returned.
+     */
+    template <typename... Args> T* init(Args&&... args) {
+        fValue.emplace(std::forward<Args>(args)...);
+        return this->get();
+    }
+
+    /**
+     *  Copy src into this, and return a pointer to a copy of it. Note this
+     *  will always return the same pointer, so if it is called on a lazy that
+     *  has already been initialized, then this will copy over the previous
+     *  contents.
+     */
+    T* set(const T& src) {
+        fValue = src;
+        return this->get();
+    }
+
+    T* set(T&& src) {
+        fValue = std::move(src);
+        return this->get();
+    }
+
+    /**
+     * Destroy the lazy object (if it was created via init() or set())
+     */
+    void reset() {
+        fValue.reset();
+    }
+
+    /**
+     *  Returns true if a valid object has been initialized in the SkTLazy,
+     *  false otherwise.
+     */
+    bool isValid() const { return fValue.has_value(); }
+
+    /**
+     * Returns the object. This version should only be called when the caller
+     * knows that the object has been initialized.
+     */
+    T* get() {
+        SkASSERT(fValue.has_value());
+        return &fValue.value();
+    }
+    const T* get() const {
+        SkASSERT(fValue.has_value());
+        return &fValue.value();
+    }
+
+    T* operator->() { return this->get(); }
+    const T* operator->() const { return this->get(); }
+
+    T& operator*() {
+        SkASSERT(fValue.has_value());
+        return *fValue;
+    }
+    const T& operator*() const {
+        SkASSERT(fValue.has_value());
+        return *fValue;
+    }
+
+    /**
+     * Like above but doesn't assert if object isn't initialized (in which case
+     * nullptr is returned).
+     */
+    const T* getMaybeNull() const { return fValue.has_value() ? this->get() : nullptr; }
+          T* getMaybeNull()       { return fValue.has_value() ? this->get() : nullptr; }
+
+private:
+    std::optional<T> fValue;
+};
+
+/**
+ * A helper built on top of std::optional to do copy-on-first-write. The object is initialized
+ * with a const pointer but provides a non-const pointer accessor. The first time the
+ * accessor is called (if ever) the object is cloned.
+ *
+ * In the following example at most one copy of constThing is made:
+ *
+ * SkTCopyOnFirstWrite<Thing> thing(&constThing);
+ * ...
+ * function_that_takes_a_const_thing_ptr(thing); // constThing is passed
+ * ...
+ * if (need_to_modify_thing()) {
+ *    thing.writable()->modifyMe(); // makes a copy of constThing
+ * }
+ * ...
+ * x = thing->readSomething();
+ * ...
+ * if (need_to_modify_thing_now()) {
+ *    thing.writable()->changeMe(); // makes a copy of constThing if we didn't call modifyMe()
+ * }
+ *
+ * consume_a_thing(thing); // could be constThing or a modified copy.
+ */
+template <typename T>
+class SkTCopyOnFirstWrite {
+public:
+    explicit SkTCopyOnFirstWrite(const T& initial) : fObj(&initial) {}
+
+    explicit SkTCopyOnFirstWrite(const T* initial) : fObj(initial) {}
+
+    // Constructor for delayed initialization.
+    SkTCopyOnFirstWrite() : fObj(nullptr) {}
+
+    SkTCopyOnFirstWrite(const SkTCopyOnFirstWrite&  that) { *this = that;            }
+    SkTCopyOnFirstWrite(      SkTCopyOnFirstWrite&& that) { *this = std::move(that); }
+
+    SkTCopyOnFirstWrite& operator=(const SkTCopyOnFirstWrite& that) {
+        fLazy = that.fLazy;
+        fObj  = fLazy.has_value() ? &fLazy.value() : that.fObj;
+        return *this;
+    }
+
+    SkTCopyOnFirstWrite& operator=(SkTCopyOnFirstWrite&& that) {
+        fLazy = std::move(that.fLazy);
+        fObj  = fLazy.has_value() ? &fLazy.value() : that.fObj;
+        return *this;
+    }
+
+    // Should only be called once, and only if the default constructor was used.
+    void init(const T& initial) {
+        SkASSERT(!fObj);
+        SkASSERT(!fLazy.has_value());
+        fObj = &initial;
+    }
+
+    // If not already initialized, in-place instantiates the writable object
+    template <typename... Args>
+    void initIfNeeded(Args&&... args) {
+        if (!fObj) {
+            SkASSERT(!fLazy.has_value());
+            fObj = &fLazy.emplace(std::forward<Args>(args)...);
+        }
+    }
+
+    /**
+     * Returns a writable T*. The first time this is called the initial object is cloned.
+     */
+    T* writable() {
+        SkASSERT(fObj);
+        if (!fLazy.has_value()) {
+            fLazy = *fObj;
+            fObj = &fLazy.value();
+        }
+        return &fLazy.value();
+    }
+
+    const T* get() const { return fObj; }
+
+    /**
+     * Operators for treating this as though it were a const pointer.
+     */
+
+    const T *operator->() const { return fObj; }
+
+    operator const T*() const { return fObj; }
+
+    const T& operator *() const { return *fObj; }
+
+private:
+    const T*         fObj;
+    std::optional<T> fLazy;
+};
+
+#endif

package/cpp/skia/src/core/SkTHash.h

@@ -9,6 +9,7 @@
 #define SkTHash_DEFINED
 
 #include "include/core/SkTypes.h"
+#include "src/base/SkMathPriv.h"
 #include "src/core/SkChecksum.h"
 
 #include <initializer_list>
@@ -73,6 +74,17 @@ public:
     // Approximately how many bytes of memory do we use beyond sizeof(*this)?
     size_t approxBytesUsed() const { return fCapacity * sizeof(Slot); }
 
+    // Exchange two hash tables.
+    void swap(THashTable& that) {
+        std::swap(fCount, that.fCount);
+        std::swap(fCapacity, that.fCapacity);
+        std::swap(fSlots, that.fSlots);
+    }
+
+    void swap(THashTable&& that) {
+        *this = std::move(that);
+    }
+
     // !!!!!!!!!!!!!!!!!                 CAUTION                   !!!!!!!!!!!!!!!!!
     // set(), find() and foreach() all allow mutable access to table entries.
     // If you change an entry so that it no longer has the same key, all hell
@@ -130,11 +142,11 @@ public:
                 return false;
             }
             if (hash == s.fHash && key == Traits::GetKey(*s)) {
-               this->removeSlot(index);
-               if (4 * fCount <= fCapacity && fCapacity > 4) {
-                   this->resize(fCapacity / 2);
-               }
-               return true;
+                this->removeSlot(index);
+                if (4 * fCount <= fCapacity && fCapacity > 4) {
+                    this->resize(fCapacity / 2);
+                }
+                return true;
             }
             index = this->next(index);
         }
@@ -150,7 +162,12 @@ public:
     // Hash tables will automatically resize themselves when set() and remove() are called, but
     // resize() can be called to manually grow capacity before a bulk insertion.
     void resize(int capacity) {
+        // We must have enough capacity to hold every key.
         SkASSERT(capacity >= fCount);
+        // `capacity` must be a power of two, because we use `hash & (capacity-1)` to look up keys
+        // in the table (since this is faster than a modulo).
+        SkASSERT((capacity & (capacity - 1)) == 0);
+
         int oldCapacity = fCapacity;
         SkDEBUGCODE(int oldCount = fCount);
 
@@ -168,6 +185,22 @@ public:
         SkASSERT(fCount == oldCount);
     }
 
+    // Reserve extra capacity. This only grows capacity; requests to shrink are ignored.
+    // We assume that the passed-in value represents the number of items that the caller wants to
+    // store in the table. The passed-in value is adjusted to honor the following rules:
+    // - Hash tables must have a power-of-two capacity.
+    // - Hash tables grow when they exceed 3/4 capacity, not when they are full.
+    void reserve(int n) {
+        int newCapacity = SkNextPow2(n);
+        if (n * 4 > newCapacity * 3) {
+            newCapacity *= 2;
+        }
+
+        if (newCapacity > fCapacity) {
+            this->resize(newCapacity);
+        }
+    }
+
     // Call fn on every entry in the table.  You may mutate the entries, but be very careful.
     template <typename Fn>  // f(T*)
     void foreach(Fn&& fn) {
@@ -447,7 +480,9 @@ public:
     };
 
     THashMap(std::initializer_list<Pair> pairs) {
-        fTable.resize(pairs.size() * 5 / 3);
+        int capacity = pairs.size() >= 4 ? SkNextPow2(pairs.size() * 4 / 3)
+                                         : 4;
+        fTable.resize(capacity);
         for (const Pair& p : pairs) {
             fTable.set(p);
         }
@@ -465,6 +500,13 @@ public:
     // Approximately how many bytes of memory do we use beyond sizeof(*this)?
     size_t approxBytesUsed() const { return fTable.approxBytesUsed(); }
 
+    // Reserve extra capacity.
+    void reserve(int n) { fTable.reserve(n); }
+
+    // Exchange two hash maps.
+    void swap(THashMap& that) { fTable.swap(that.fTable); }
+    void swap(THashMap&& that) { fTable.swap(std::move(that.fTable)); }
+
     // N.B. The pointers returned by set() and find() are valid only until the next call to set().
 
     // Set key to val in the table, replacing any previous value with the same key.
@@ -551,7 +593,9 @@ public:
 
     // Construct with an initializer list of Ts.
     THashSet(std::initializer_list<T> vals) {
-        fTable.resize(vals.size() * 5 / 3);
+        int capacity = vals.size() >= 4 ? SkNextPow2(vals.size() * 4 / 3)
+                                        : 4;
+        fTable.resize(capacity);
         for (const T& val : vals) {
             fTable.set(val);
         }
@@ -569,6 +613,13 @@ public:
     // Approximately how many bytes of memory do we use beyond sizeof(*this)?
     size_t approxBytesUsed() const { return fTable.approxBytesUsed(); }
 
+    // Reserve extra capacity.
+    void reserve(int n) { fTable.reserve(n); }
+
+    // Exchange two hash sets.
+    void swap(THashSet& that) { fTable.swap(that.fTable); }
+    void swap(THashSet&& that) { fTable.swap(std::move(that.fTable)); }
+
     // Copy an item into the set.
     void add(T item) { fTable.set(std::move(item)); }
 

package/cpp/skia/src/gpu/ganesh/gl/GrGLDefines.h

@@ -1155,4 +1155,7 @@
 #define GR_UNMASKED_VENDOR_WEBGL                            0x9245
 #define GR_UNMASKED_RENDERER_WEBGL                          0x9246
 
+/* GL_ANGLE_client_arrays */
+#define GR_GL_CLIENT_ARRAYS_ANGLE                           0x93AA
+
 #endif

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.h

@@ -67,6 +67,9 @@ public:
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override;
 
+  std::shared_ptr<SkiaContext>
+  makeContextFromNativeSurface(void *surface, int width, int height) override;
+
   virtual void performStreamOperation(
       const std::string &sourceUri,
       const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override;

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.mm

@@ -149,6 +149,13 @@ RNSkiOSPlatformContext::createVideo(const std::string &url) {
   return std::make_shared<RNSkiOSVideo>(url, this);
 }
 
+std::shared_ptr<SkiaContext>
+RNSkiOSPlatformContext::makeContextFromNativeSurface(void *surface, int width,
+                                                     int height) {
+  return SkiaMetalSurfaceFactory::makeContext((__bridge CALayer *)surface,
+                                              width, height);
+}
+
 void RNSkiOSPlatformContext::raiseError(const std::exception &err) {
   RCTFatal(RCTErrorWithMessage([NSString stringWithUTF8String:err.what()]));
 }