@shopify/react-native-skia 2.6.4 → 2.6.6

package/cpp/rnwgpu/api/GPUSharedTextureMemory.cpp

@@ -0,0 +1,135 @@
+#include "GPUSharedTextureMemory.h"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+std::shared_ptr<GPUTexture> GPUSharedTextureMemory::createTexture(
+    std::optional<std::shared_ptr<GPUTextureDescriptor>> descriptor) {
+  if (!descriptor.has_value() || descriptor.value() == nullptr) {
+    auto texture = _instance.CreateTexture();
+    // The texture aliases the shared memory; it doesn't own GPU allocation, so
+    // it doesn't report memory pressure.
+    return std::make_shared<GPUTexture>(texture, "", false);
+  }
+
+  wgpu::TextureDescriptor desc{};
+  Convertor conv;
+  if (!conv(desc, descriptor.value())) {
+    throw std::runtime_error(
+        "GPUSharedTextureMemory::createTexture(): Error with "
+        "GPUTextureDescriptor");
+  }
+  auto texture = _instance.CreateTexture(&desc);
+  return std::make_shared<GPUTexture>(
+      texture, descriptor.value()->label.value_or(""), false);
+}
+
+void GPUSharedTextureMemory::beginAccess(
+    std::shared_ptr<GPUTexture> texture, bool initialized,
+    std::optional<std::vector<std::shared_ptr<GPUSharedFenceState>>> fences) {
+  if (!texture) {
+    throw std::runtime_error(
+        "GPUSharedTextureMemory::beginAccess(): texture is null");
+  }
+  wgpu::SharedTextureMemoryBeginAccessDescriptor desc{};
+  desc.initialized = initialized;
+  desc.concurrentRead = false;
+
+  // Built in lockstep so fenceCount covers both arrays, and kept in locals so
+  // the raw pointers outlive the synchronous BeginAccess() below.
+  std::vector<wgpu::SharedFence> rawFences;
+  std::vector<uint64_t> values;
+  if (fences.has_value()) {
+    for (const auto &state : *fences) {
+      if (state && state->fence) {
+        rawFences.push_back(state->fence->get());
+        values.push_back(state->signaledValue);
+      }
+    }
+  }
+  if (!rawFences.empty()) {
+    desc.fenceCount = rawFences.size();
+    desc.fences = rawFences.data();
+    desc.signaledValues = values.data();
+  } else {
+    desc.fenceCount = 0;
+    desc.fences = nullptr;
+    desc.signaledValues = nullptr;
+  }
+
+#if defined(__ANDROID__)
+  // Dawn's Vulkan backend (AHardwareBuffer) validates that the begin-access
+  // descriptor chains a SharedTextureMemoryVkImageLayoutBeginState specifying
+  // the VkImageLayout to acquire the image into. UNDEFINED (= 0) on both ends
+  // is the canonical "no prior GPU producer" pattern: Dawn performs an
+  // external-queue acquire from VK_QUEUE_FAMILY_EXTERNAL which preserves the
+  // AHB contents, then transitions to whatever layout the texture's actual
+  // usage requires.
+  wgpu::SharedTextureMemoryVkImageLayoutBeginState vkLayout{};
+  vkLayout.oldLayout = 0;
+  vkLayout.newLayout = 0;
+  desc.nextInChain = &vkLayout;
+#endif
+
+  auto status = _instance.BeginAccess(texture->get(), &desc);
+  if (!status) {
+    throw std::runtime_error("GPUSharedTextureMemory::beginAccess() failed");
+  }
+}
+
+jsi::Value GPUSharedTextureMemory::endAccess(jsi::Runtime &runtime,
+                                             const jsi::Value &,
+                                             const jsi::Value *args,
+                                             size_t count) {
+  if (count < 1 || !args[0].isObject()) {
+    throw jsi::JSError(
+        runtime, "GPUSharedTextureMemory::endAccess(): expected (texture)");
+  }
+  auto texture = GPUTexture::fromValue(runtime, args[0]);
+
+  wgpu::SharedTextureMemoryEndAccessState state{};
+
+#if defined(__ANDROID__)
+  // Dawn's Vulkan backend writes the released old/new VkImageLayouts back into
+  // a chained SharedTextureMemoryVkImageLayoutEndState; validation requires
+  // the chain even when the caller doesn't read the values.
+  wgpu::SharedTextureMemoryVkImageLayoutEndState vkLayout{};
+  state.nextInChain = &vkLayout;
+#endif
+
+  auto status = _instance.EndAccess(texture->get(), &state);
+  if (!status) {
+    throw jsi::JSError(runtime, "GPUSharedTextureMemory::endAccess() failed");
+  }
+
+  // Copy each wgpu::SharedFence (ref-counted) into its own GPUSharedFence
+  // wrapper before `state` is destroyed.
+  jsi::Array fences(runtime, state.fenceCount);
+  for (size_t i = 0; i < state.fenceCount; i++) {
+    wgpu::SharedFence fence = state.fences[i];
+    auto wrapper = std::make_shared<GPUSharedFence>(std::move(fence), "");
+    jsi::Object entry(runtime);
+    entry.setProperty(runtime, "fence",
+                      GPUSharedFence::create(runtime, std::move(wrapper)));
+    entry.setProperty(
+        runtime, "signaledValue",
+        jsi::BigInt::fromUint64(runtime, state.signaledValues[i]));
+    fences.setValueAtIndex(runtime, i, std::move(entry));
+  }
+
+  jsi::Object result(runtime);
+  result.setProperty(runtime, "initialized",
+                     jsi::Value(static_cast<bool>(state.initialized)));
+  result.setProperty(runtime, "fences", std::move(fences));
+  return result;
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedTextureMemory.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUSharedFence.h"
+#include "GPUTexture.h"
+#include "descriptors/GPUSharedFenceState.h"
+#include "descriptors/GPUTextureDescriptor.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUSharedTextureMemory : public NativeObject<GPUSharedTextureMemory> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUSharedTextureMemory";
+
+  explicit GPUSharedTextureMemory(wgpu::SharedTextureMemory instance,
+                                  std::string label)
+      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
+        _label(std::move(label)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::shared_ptr<GPUTexture> createTexture(
+      std::optional<std::shared_ptr<GPUTextureDescriptor>> descriptor);
+
+  // Optional `fences` are wait fences: Dawn waits for each to reach its
+  // signaledValue before writing the surface. Throws on failure.
+  void beginAccess(
+      std::shared_ptr<GPUTexture> texture, bool initialized,
+      std::optional<std::vector<std::shared_ptr<GPUSharedFenceState>>> fences);
+
+  // endAccess(texture) -> { initialized, fences: { fence, signaledValue }[] }
+  // Surfaces the fences Dawn produced for the access. Throws on failure.
+  jsi::Value endAccess(jsi::Runtime &runtime, const jsi::Value &thisVal,
+                       const jsi::Value *args, size_t count);
+
+  std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand",
+                  &GPUSharedTextureMemory::getBrand);
+    installMethod(runtime, prototype, "createTexture",
+                  &GPUSharedTextureMemory::createTexture);
+    installMethod(runtime, prototype, "beginAccess",
+                  &GPUSharedTextureMemory::beginAccess);
+    installMethod(runtime, prototype, "endAccess",
+                  &GPUSharedTextureMemory::endAccess);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUSharedTextureMemory::getLabel,
+                        &GPUSharedTextureMemory::setLabel);
+  }
+
+  inline const wgpu::SharedTextureMemory get() { return _instance; }
+
+private:
+  wgpu::SharedTextureMemory _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "jsi2/NativeObject.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+// DRAFT — compile-unverified. Minimal ImageBitmap holding decoded, unpremul
+// RGBA8 pixels plus its dimensions. Produced by the global createImageBitmap()
+// binding (see RNSkManager.cpp). Decoding is done with Skia's own codec, so no
+// platform-specific image decoder is required.
+//
+// FOLLOW-UP: to make an ImageBitmap usable as a copyExternalImageToTexture
+// source, uncomment the `source` field + ImageBitmap converter in
+// rnwgpu/api/descriptors/GPUImageCopyExternalImage.h and upload `data()` in
+// GPUQueue::copyExternalImageToTexture. That GPU wiring is intentionally out of
+// scope for this draft.
+class ImageBitmap : public NativeObject<ImageBitmap> {
+public:
+  static constexpr const char *CLASS_NAME = "ImageBitmap";
+
+  ImageBitmap(std::vector<uint8_t> data, size_t width, size_t height)
+      : NativeObject(CLASS_NAME), _data(std::move(data)), _width(width),
+        _height(height) {}
+
+  size_t getWidth() { return _width; }
+
+  size_t getHeight() { return _height; }
+
+  // Per the spec, close() releases the bitmap's underlying pixels and zeroes
+  // its dimensions. Idempotent.
+  void close() {
+    _data.clear();
+    _data.shrink_to_fit();
+    _width = 0;
+    _height = 0;
+  }
+
+  // Decoded, unpremultiplied RGBA8 pixels (row-major, width*height*4 bytes).
+  const std::vector<uint8_t> &data() const { return _data; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "width", &ImageBitmap::getWidth);
+    installGetter(runtime, prototype, "height", &ImageBitmap::getHeight);
+    installMethod(runtime, prototype, "close", &ImageBitmap::close);
+  }
+
+  size_t getMemoryPressure() override { return _data.size(); }
+
+private:
+  std::vector<uint8_t> _data;
+  size_t _width;
+  size_t _height;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/NativeBufferUtils.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#if defined(__APPLE__)
+#include "AppleNativeBuffer.h"
+#elif defined(__ANDROID__)
+#include <android/hardware_buffer.h>
+#endif
+
+namespace rnwgpu {
+
+// Import a Skia NativeBuffer pointer (a CVPixelBufferRef on Apple, an
+// AHardwareBuffer* on Android, as returned by Skia.NativeBuffer.MakeFromImage /
+// MakeTestBuffer) as a wgpu::SharedTextureMemory on `device`. When non-null,
+// outWidth/outHeight receive the surface dimensions. Returns a null
+// SharedTextureMemory if the import itself fails (the caller decides how to
+// report that); throws std::runtime_error for pre-import failures (a buffer
+// with no IOSurface, or an unsupported platform).
+//
+// The platform-specific chained descriptor only needs to outlive the
+// ImportSharedTextureMemory call, so it lives entirely within this function.
+// Shared by GPUDevice::importSharedTextureMemory and
+// GPUExternalTexture::Create.
+inline wgpu::SharedTextureMemory importNativeBufferAsSharedTextureMemory(
+    const wgpu::Device &device, void *bufferPtr, const std::string &label,
+    uint32_t *outWidth, uint32_t *outHeight) {
+  wgpu::SharedTextureMemoryDescriptor memDesc{};
+  if (!label.empty()) {
+    memDesc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+
+  uint32_t width = 0;
+  uint32_t height = 0;
+  wgpu::SharedTextureMemory memory;
+
+#if defined(__APPLE__)
+  // Skia's NativeBuffer is a CVPixelBufferRef; extract its backing IOSurface
+  // (and dimensions) in Objective-C++ since CoreVideo isn't available here.
+  void *ioSurface = GetIOSurfaceFromNativeBuffer(bufferPtr, &width, &height);
+  if (ioSurface == nullptr) {
+    throw std::runtime_error(
+        "importNativeBufferAsSharedTextureMemory(): native "
+        "buffer has no IOSurface");
+  }
+  wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc{};
+  platformDesc.ioSurface = ioSurface;
+  // Default off: enabling it propagates StorageBinding into properties.usage,
+  // which then forces memory.createTexture() (no-descriptor form) to validate
+  // the format against storage capabilities. bgra8unorm (the standard
+  // CVPixelBuffer format) only supports storage when the device opts into the
+  // bgra8unorm-storage feature, so unconditionally setting this here breaks the
+  // common sample-only case.
+  platformDesc.allowStorageBinding = false;
+  memDesc.nextInChain = &platformDesc;
+  memory = device.ImportSharedTextureMemory(&memDesc);
+#elif defined(__ANDROID__)
+  auto *ahb = reinterpret_cast<AHardwareBuffer *>(bufferPtr);
+  AHardwareBuffer_Desc ahbDesc = {};
+  AHardwareBuffer_describe(ahb, &ahbDesc);
+  width = ahbDesc.width;
+  height = ahbDesc.height;
+  wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc{};
+  platformDesc.handle = ahb;
+  memDesc.nextInChain = &platformDesc;
+  memory = device.ImportSharedTextureMemory(&memDesc);
+#else
+  (void)device;
+  (void)bufferPtr;
+  throw std::runtime_error(
+      "importNativeBufferAsSharedTextureMemory(): unsupported platform");
+#endif
+
+  if (outWidth != nullptr) {
+    *outWidth = width;
+  }
+  if (outHeight != nullptr) {
+    *outHeight = height;
+  }
+  return memory;
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupEntry.h

@@ -20,7 +20,7 @@ struct GPUBindGroupEntry {
   std::shared_ptr<GPUSampler> sampler = nullptr;
   std::shared_ptr<GPUTextureView> textureView = nullptr;
   std::shared_ptr<GPUBufferBinding> buffer = nullptr;
-  // external textures
+  std::shared_ptr<GPUExternalTexture> externalTexture = nullptr;
 };
 
 } // namespace rnwgpu
@@ -45,6 +45,9 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
           } else if (obj.hasNativeState<rnwgpu::GPUTextureView>(runtime)) {
             result->textureView =
                 obj.getNativeState<rnwgpu::GPUTextureView>(runtime);
+          } else if (obj.hasNativeState<rnwgpu::GPUExternalTexture>(runtime)) {
+            result->externalTexture =
+                obj.getNativeState<rnwgpu::GPUExternalTexture>(runtime);
           } else if (obj.hasNativeState<rnwgpu::GPUBuffer>(runtime)) {
             auto binding = std::make_shared<rnwgpu::GPUBufferBinding>();
             binding->buffer = obj.getNativeState<rnwgpu::GPUBuffer>(runtime);

package/cpp/rnwgpu/api/descriptors/GPUCanvasConfiguration.h

@@ -7,7 +7,7 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "GPUDevice.h"
+#include "rnwgpu/api/GPUDevice.h"
 
 namespace jsi = facebook::jsi;
 

package/cpp/rnwgpu/api/descriptors/GPUDawnTogglesDescriptor.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Non-standard, Dawn-only. Mirrors wgpu::DawnTogglesDescriptor field-for-field
+// so the mapping to the native chained struct is 1:1. Chained onto the
+// wgpu::DeviceDescriptor in GPUAdapter::requestDevice.
+struct GPUDawnTogglesDescriptor {
+  std::optional<std::vector<std::string>> enabledToggles;  // Iterable<string>
+  std::optional<std::vector<std::string>> disabledToggles; // Iterable<string>
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDawnTogglesDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "enabledToggles")) {
+        auto prop = value.getProperty(runtime, "enabledToggles");
+        result->enabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "disabledToggles")) {
+        auto prop = value.getProperty(runtime, "disabledToggles");
+        result->disabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUDawnTogglesDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUDeviceDescriptor.h

@@ -9,6 +9,7 @@
 
 #include "jsi2/JSIConverter.h"
 
+#include "GPUDawnTogglesDescriptor.h"
 #include "GPUQueueDescriptor.h"
 
 namespace jsi = facebook::jsi;
@@ -23,6 +24,9 @@ struct GPUDeviceDescriptor {
   std::optional<std::shared_ptr<GPUQueueDescriptor>>
       defaultQueue;                 // GPUQueueDescriptor
   std::optional<std::string> label; // string
+  // Non-standard Dawn-only device toggles, chained onto the wgpu::Device
+  // descriptor in GPUAdapter::requestDevice.
+  std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>> dawnToggles;
 };
 
 } // namespace rnwgpu
@@ -86,6 +90,12 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
         result->label = JSIConverter<std::optional<std::string>>::fromJSI(
             runtime, prop, false);
       }
+      if (value.hasProperty(runtime, "dawnToggles")) {
+        auto prop = value.getProperty(runtime, "dawnToggles");
+        result->dawnToggles = JSIConverter<std::optional<
+            std::shared_ptr<GPUDawnTogglesDescriptor>>>::fromJSI(runtime, prop,
+                                                                 false);
+      }
     }
 
     return result;

package/cpp/rnwgpu/api/descriptors/GPUExternalTextureDescriptor.h

@@ -1,26 +1,36 @@
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <optional>
 #include <string>
-#include <variant>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Convertors.h"
-
 #include "jsi2/JSIConverter.h"
 
 namespace jsi = facebook::jsi;
 
 namespace rnwgpu {
 
+// Mirror of GPUExternalTextureDescriptor from the WebGPU spec, adapted to
+// Skia's binding. Skia has no VideoFrame; instead `source` is a native buffer
+// pointer (the BigInt returned by Skia.NativeBuffer.MakeFromImage): a
+// CVPixelBufferRef on Apple, an AHardwareBuffer* on Android. The pointer's
+// lifetime is owned by the caller (Skia.NativeBuffer.Release); the imported
+// texture must not outlive it.
+//
+// We don't expose colorSpace yet; the C++ side picks dst-sRGB and identity
+// gamut, the right default for "render this BGRA frame to an sRGB framebuffer".
+//
+// `rotation` / `mirrored` are a non-spec extension baked into Dawn's sampling
+// transform. `rotation` is in degrees and must be one of 0 / 90 / 180 / 270.
 struct GPUExternalTextureDescriptor {
-  // std::variant<std::shared_ptr<HTMLVideoElement>,
-  // std::shared_ptr<VideoFrame>>
-  //     source; // | HTMLVideoElement | VideoFrame
-  // std::optional<wgpu::DefinedColorSpace> colorSpace; // PredefinedColorSpace
-  std::optional<std::string> label; // string
+  // native buffer pointer (CVPixelBufferRef / AHardwareBuffer*)
+  uint64_t source = 0;
+  std::optional<std::string> label;
+  std::optional<double> rotation;
+  std::optional<bool> mirrored;
 };
 
 } // namespace rnwgpu
@@ -31,23 +41,21 @@ template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUExternalTextureDescriptor>();
+    auto result = std::make_shared<rnwgpu::GPUExternalTextureDescriptor>();
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "source")) {
         auto prop = value.getProperty(runtime, "source");
-        // result->source = JSIConverter<
-        //     std::variant<std::shared_ptr<HTMLVideoElement>,
-        //                  std::shared_ptr<VideoFrame>>>::fromJSI(runtime,
-        //                  prop,
-        //                                                         false);
-      }
-      if (value.hasProperty(runtime, "colorSpace")) {
-        auto prop = value.getProperty(runtime, "colorSpace");
-        if (!prop.isUndefined()) {
-          // result->colorSpace =
-          //     JSIConverter<std::optional<wgpu::definedColorSpace>>::fromJSI(
-          //         runtime, prop, false);
+        // The native buffer pointer arrives as a BigInt (uintptr_t value). It
+        // must be a BigInt: a JS number can't represent a 64-bit pointer
+        // without truncation, so we reject it rather than corrupt the address.
+        if (prop.isBigInt()) {
+          result->source = prop.asBigInt(runtime).asUint64(runtime);
+        } else if (!prop.isUndefined() && !prop.isNull()) {
+          throw jsi::JSError(
+              runtime, "GPUExternalTextureDescriptor.source must be a "
+                       "NativeBuffer (BigInt) from "
+                       "Skia.NativeBuffer.MakeFromImage / MakeTestBuffer");
         }
       }
       if (value.hasProperty(runtime, "label")) {
@@ -57,13 +65,24 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
               runtime, prop, false);
         }
       }
+      if (value.hasProperty(runtime, "rotation")) {
+        auto prop = value.getProperty(runtime, "rotation");
+        if (prop.isNumber()) {
+          result->rotation = prop.asNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "mirrored")) {
+        auto prop = value.getProperty(runtime, "mirrored");
+        if (prop.isBool()) {
+          result->mirrored = prop.getBool();
+        }
+      }
     }
-
     return result;
   }
   static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> arg) {
+  toJSI(jsi::Runtime & /*runtime*/,
+        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> /*arg*/) {
     throw std::runtime_error("Invalid GPUExternalTextureDescriptor::toJSI()");
   }
 };

package/cpp/rnwgpu/api/descriptors/GPUImageCopyExternalImage.h

@@ -7,17 +7,18 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Convertors.h"
+#include "rnwgpu/api/Convertors.h"
 #include "jsi2/JSIConverter.h"
 
-#include "GPUOrigin2D.h"
+#include "rnwgpu/api/GPUOrigin2D.h"
+#include "rnwgpu/api/ImageBitmap.h"
 
 namespace jsi = facebook::jsi;
 
 namespace rnwgpu {
 
 struct GPUImageCopyExternalImage {
-  // std::shared_ptr<ImageBitmap> source; // GPUImageCopyExternalImageSource
+  std::shared_ptr<ImageBitmap> source; // GPUImageCopyExternalImageSource
   std::optional<std::shared_ptr<GPUOrigin2D>> origin; // GPUOrigin2DStrict
   std::optional<bool> flipY;                          // boolean
 };
@@ -33,12 +34,11 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>> {
     auto result = std::make_unique<rnwgpu::GPUImageCopyExternalImage>();
     if (!outOfBounds && arg.isObject()) {
       auto obj = arg.getObject(runtime);
-      //      if (obj.hasProperty(runtime, "source")) {
-      //        auto prop = obj.getProperty(runtime, "source");
-      //        result->source =
-      //        JSIConverter<std::shared_ptr<ImageBitmap>>::fromJSI(
-      //            runtime, prop, false);
-      //      }
+      if (obj.hasProperty(runtime, "source")) {
+        auto prop = obj.getProperty(runtime, "source");
+        result->source = JSIConverter<std::shared_ptr<ImageBitmap>>::fromJSI(
+            runtime, prop, false);
+      }
       if (obj.hasProperty(runtime, "origin")) {
         auto prop = obj.getProperty(runtime, "origin");
         result->origin = JSIConverter<std::shared_ptr<GPUOrigin2D>>::fromJSI(

package/cpp/rnwgpu/api/descriptors/GPUImageCopyTexture.h

@@ -6,7 +6,7 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "GPUOrigin3D.h"
+#include "rnwgpu/api/GPUOrigin3D.h"
 #include "rnwgpu/api/GPUTexture.h"
 
 namespace jsi = facebook::jsi;

package/cpp/rnwgpu/api/descriptors/GPUImageCopyTextureTagged.h

@@ -6,8 +6,8 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "External.h"
-#include "GPUOrigin3D.h"
+#include "rnwgpu/api/External.h"
+#include "rnwgpu/api/GPUOrigin3D.h"
 #include "rnwgpu/api/GPUTexture.h"
 
 namespace jsi = facebook::jsi;