@shopify/react-native-skia 2.6.4 → 2.6.6

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -7,6 +7,7 @@
 #include <vector>
 
 #include "Convertors.h"
+#include "NativeBufferUtils.h"
 #include "jsi2/JSIConverter.h"
 
 #include "GPUFeatures.h"
@@ -234,8 +235,83 @@ std::shared_ptr<GPUPipelineLayout> GPUDevice::createPipelineLayout(
 
 std::shared_ptr<GPUExternalTexture> GPUDevice::importExternalTexture(
     std::shared_ptr<GPUExternalTextureDescriptor> descriptor) {
-  throw std::runtime_error(
-      "GPUDevice::importExternalTexture(): Not implemented");
+  // The import / begin-access / descriptor-build logic, plus the matching
+  // EndAccess, all live on GPUExternalTexture so the begin/end lifecycle stays
+  // in one translation unit (see GPUExternalTexture.cpp).
+  return GPUExternalTexture::Create(_instance, std::move(descriptor));
+}
+
+std::shared_ptr<GPUSharedTextureMemory> GPUDevice::importSharedTextureMemory(
+    std::shared_ptr<GPUSharedTextureMemoryDescriptor> descriptor) {
+  if (!descriptor || descriptor->handle == 0) {
+    throw std::runtime_error(
+        "GPUDevice::importSharedTextureMemory(): handle must be a non-null "
+        "native buffer pointer (from Skia.NativeBuffer.MakeFromImage)");
+  }
+  void *bufferPtr =
+      reinterpret_cast<void *>(static_cast<uintptr_t>(descriptor->handle));
+  std::string label = descriptor->label.value_or("");
+
+  auto memory = importNativeBufferAsSharedTextureMemory(
+      _instance, bufferPtr, label, /*outWidth=*/nullptr, /*outHeight=*/nullptr);
+  if (memory == nullptr) {
+    throw std::runtime_error(
+        "GPUDevice::importSharedTextureMemory(): ImportSharedTextureMemory "
+        "returned null - is the 'shared-texture-memory-iosurface' (Apple) or "
+        "'shared-texture-memory-ahardware-buffer' (Android) feature enabled on "
+        "the device?");
+  }
+  return std::make_shared<GPUSharedTextureMemory>(std::move(memory),
+                                                  std::move(label));
+}
+
+std::shared_ptr<GPUSharedFence> GPUDevice::importSharedFence(
+    std::shared_ptr<GPUSharedFenceDescriptor> descriptor) {
+  if (!descriptor || descriptor->handle == nullptr) {
+    throw std::runtime_error("GPUDevice::importSharedFence(): handle must be a "
+                             "non-null native handle");
+  }
+
+  wgpu::SharedFenceDescriptor desc{};
+  std::string label = descriptor->label.value_or("");
+  if (!label.empty()) {
+    desc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+
+  // The chained platform descriptor must outlive the synchronous
+  // ImportSharedFence() below; declare them all and chain the matching one.
+  wgpu::SharedFenceMTLSharedEventDescriptor mtlDesc{};
+  wgpu::SharedFenceSyncFDDescriptor syncFdDesc{};
+  wgpu::SharedFenceVkSemaphoreOpaqueFDDescriptor vkFdDesc{};
+
+  const std::string &type = descriptor->type;
+  if (type == "mtl-shared-event") {
+    // handle is an id<MTLSharedEvent> pointer.
+    mtlDesc.sharedEvent = descriptor->handle;
+    desc.nextInChain = &mtlDesc;
+  } else if (type == "sync-fd") {
+    // handle is an OS file descriptor.
+    syncFdDesc.handle =
+        static_cast<int>(reinterpret_cast<uintptr_t>(descriptor->handle));
+    desc.nextInChain = &syncFdDesc;
+  } else if (type == "vk-semaphore-opaque-fd") {
+    vkFdDesc.handle =
+        static_cast<int>(reinterpret_cast<uintptr_t>(descriptor->handle));
+    desc.nextInChain = &vkFdDesc;
+  } else {
+    throw std::runtime_error(
+        "GPUDevice::importSharedFence(): unsupported fence type '" + type +
+        "' (expected 'mtl-shared-event', 'sync-fd' or "
+        "'vk-semaphore-opaque-fd')");
+  }
+
+  auto fence = _instance.ImportSharedFence(&desc);
+  if (fence == nullptr) {
+    throw std::runtime_error(
+        "GPUDevice::importSharedFence(): ImportSharedFence returned null - is "
+        "the matching 'shared-fence-*' feature enabled on the device?");
+  }
+  return std::make_shared<GPUSharedFence>(std::move(fence), std::move(label));
 }
 
 async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
@@ -262,7 +338,7 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
         &desc, wgpu::CallbackMode::AllowProcessEvents,
         [pipelineHolder, resolve,
          reject](wgpu::CreatePipelineAsyncStatus status,
-                 wgpu::ComputePipeline pipeline, const char *msg) mutable {
+                 wgpu::ComputePipeline pipeline, wgpu::StringView msg) {
           if (status == wgpu::CreatePipelineAsyncStatus::Success && pipeline) {
             pipelineHolder->_instance = pipeline;
             resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
@@ -271,7 +347,8 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
             });
           } else {
             std::string error =
-                msg ? std::string(msg) : "Failed to create compute pipeline";
+                msg.length ? std::string(msg.data, msg.length)
+                           : "Failed to create compute pipeline";
             reject(std::move(error));
           }
         });
@@ -303,7 +380,7 @@ async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
         &desc, wgpu::CallbackMode::AllowProcessEvents,
         [pipelineHolder, resolve,
          reject](wgpu::CreatePipelineAsyncStatus status,
-                 wgpu::RenderPipeline pipeline, const char *msg) mutable {
+                 wgpu::RenderPipeline pipeline, wgpu::StringView msg) {
           if (status == wgpu::CreatePipelineAsyncStatus::Success && pipeline) {
             pipelineHolder->_instance = pipeline;
             resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
@@ -312,7 +389,8 @@ async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
             });
           } else {
             std::string error =
-                msg ? std::string(msg) : "Failed to create render pipeline";
+                msg.length ? std::string(msg.data, msg.length)
+                           : "Failed to create render pipeline";
             reject(std::move(error));
           }
         });

package/cpp/rnwgpu/api/GPUDevice.h

@@ -37,6 +37,8 @@
 #include "GPURenderPipeline.h"
 #include "GPUSampler.h"
 #include "GPUShaderModule.h"
+#include "GPUSharedFence.h"
+#include "GPUSharedTextureMemory.h"
 #include "GPUSupportedLimits.h"
 #include "GPUTexture.h"
 #include "descriptors/GPUBindGroupDescriptor.h"
@@ -51,6 +53,8 @@
 #include "descriptors/GPURenderPipelineDescriptor.h"
 #include "descriptors/GPUSamplerDescriptor.h"
 #include "descriptors/GPUShaderModuleDescriptor.h"
+#include "descriptors/GPUSharedFenceDescriptor.h"
+#include "descriptors/GPUSharedTextureMemoryDescriptor.h"
 #include "descriptors/GPUTextureDescriptor.h"
 
 namespace rnwgpu {
@@ -120,6 +124,10 @@ public:
       std::optional<std::shared_ptr<GPUSamplerDescriptor>> descriptor);
   std::shared_ptr<GPUExternalTexture> importExternalTexture(
       std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
+  std::shared_ptr<GPUSharedTextureMemory> importSharedTextureMemory(
+      std::shared_ptr<GPUSharedTextureMemoryDescriptor> descriptor);
+  std::shared_ptr<GPUSharedFence>
+  importSharedFence(std::shared_ptr<GPUSharedFenceDescriptor> descriptor);
   std::shared_ptr<GPUBindGroupLayout> createBindGroupLayout(
       std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
   std::shared_ptr<GPUPipelineLayout>
@@ -173,6 +181,10 @@ public:
                   &GPUDevice::createSampler);
     installMethod(runtime, prototype, "importExternalTexture",
                   &GPUDevice::importExternalTexture);
+    installMethod(runtime, prototype, "importSharedTextureMemory",
+                  &GPUDevice::importSharedTextureMemory);
+    installMethod(runtime, prototype, "importSharedFence",
+                  &GPUDevice::importSharedFence);
     installMethod(runtime, prototype, "createBindGroupLayout",
                   &GPUDevice::createBindGroupLayout);
     installMethod(runtime, prototype, "createPipelineLayout",

package/cpp/rnwgpu/api/GPUExternalTexture.cpp

@@ -0,0 +1,139 @@
+#include "GPUExternalTexture.h"
+
+#include <cmath>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "NativeBufferUtils.h"
+#include "descriptors/GPUExternalTextureDescriptor.h"
+
+namespace rnwgpu {
+
+// Identity gamut (same primaries) as a 3x3 column-major matrix.
+static const float kIdentityGamutMatrix[9] = {
+    1.0f, 0.0f, 0.0f, //
+    0.0f, 1.0f, 0.0f, //
+    0.0f, 0.0f, 1.0f, //
+};
+
+// Identity transfer (y = x). The native buffers produced by Skia's NativeBuffer
+// API are single-plane BGRA/RGBA already in the render target's color space, so
+// no conversion is wanted. Dawn dereferences the transfer-function arrays
+// unconditionally (ComputeExternalTextureParams), so these must be non-null.
+static const float kIdentityTransferParams[7] = {
+    1.0f, // G
+    1.0f, // A
+    0.0f, // B
+    0.0f, // C
+    0.0f, // D
+    0.0f, // E
+    0.0f, // F
+};
+
+// Map a rotation in degrees (0 / 90 / 180 / 270) to Dawn's enum. Anything that
+// isn't a clean multiple of 90 snaps to the nearest quadrant; Dawn only
+// supports those four steps for external textures.
+static wgpu::ExternalTextureRotation toExternalTextureRotation(double degrees) {
+  int quadrant = static_cast<int>(std::lround(degrees / 90.0));
+  quadrant = ((quadrant % 4) + 4) % 4;
+  switch (quadrant) {
+  case 1:
+    return wgpu::ExternalTextureRotation::Rotate90Degrees;
+  case 2:
+    return wgpu::ExternalTextureRotation::Rotate180Degrees;
+  case 3:
+    return wgpu::ExternalTextureRotation::Rotate270Degrees;
+  default:
+    return wgpu::ExternalTextureRotation::Rotate0Degrees;
+  }
+}
+
+std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
+    wgpu::Device device,
+    std::shared_ptr<GPUExternalTextureDescriptor> descriptor) {
+  if (!descriptor || descriptor->source == 0) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): descriptor.source (a native buffer "
+        "pointer from Skia.NativeBuffer.MakeFromImage) is required");
+  }
+  void *bufferPtr =
+      reinterpret_cast<void *>(static_cast<uintptr_t>(descriptor->source));
+  std::string label = descriptor->label.value_or("external-texture");
+
+  // 1. Import the native buffer as SharedTextureMemory and read its dimensions.
+  uint32_t width = 0;
+  uint32_t height = 0;
+  wgpu::SharedTextureMemory memory = importNativeBufferAsSharedTextureMemory(
+      device, bufferPtr, label, &width, &height);
+  if (memory == nullptr) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): ImportSharedTextureMemory returned "
+        "null");
+  }
+
+  // 2. Create the texture from the surface (Dawn picks the single-plane
+  //    BGRA/RGBA format).
+  auto texture = memory.CreateTexture();
+  if (texture == nullptr) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): CreateTexture returned null");
+  }
+
+  // 3. Begin access. The matching EndAccess runs when the GPUExternalTexture is
+  //    destroyed (explicitly via destroy() or at GC).
+  wgpu::SharedTextureMemoryBeginAccessDescriptor begin{};
+  begin.initialized = true;
+  begin.concurrentRead = false;
+#if defined(__ANDROID__)
+  // Dawn's Vulkan backend requires the acquired VkImageLayout to be chained.
+  // UNDEFINED (= 0) on both ends is the canonical "no prior GPU producer"
+  // pattern (matches GPUSharedTextureMemory::beginAccess).
+  wgpu::SharedTextureMemoryVkImageLayoutBeginState vkBegin{};
+  vkBegin.oldLayout = 0;
+  vkBegin.newLayout = 0;
+  begin.nextInChain = &vkBegin;
+#endif
+  if (!memory.BeginAccess(texture, &begin)) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): BeginAccess failed");
+  }
+
+  // 4. Single-plane view (the whole BGRA/RGBA surface).
+  auto plane0 = texture.CreateView();
+
+  // 5. Build the ExternalTextureDescriptor. The surface is already RGB in the
+  //    target color space, so pass it through with identity transfer/gamut.
+  wgpu::ExternalTextureDescriptor extDesc{};
+  if (!label.empty()) {
+    extDesc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+  extDesc.plane0 = plane0;
+  extDesc.gamutConversionMatrix = kIdentityGamutMatrix;
+  extDesc.srcTransferFunctionParameters = kIdentityTransferParams;
+  extDesc.dstTransferFunctionParameters = kIdentityTransferParams;
+  extDesc.cropOrigin = {0, 0};
+  extDesc.cropSize = {width, height};
+  extDesc.apparentSize = {width, height};
+  extDesc.mirrored = descriptor->mirrored.value_or(false);
+  extDesc.rotation =
+      toExternalTextureRotation(descriptor->rotation.value_or(0));
+
+  auto external = device.CreateExternalTexture(&extDesc);
+  if (external == nullptr) {
+    wgpu::SharedTextureMemoryEndAccessState state{};
+#if defined(__ANDROID__)
+    wgpu::SharedTextureMemoryVkImageLayoutEndState vkEnd{};
+    state.nextInChain = &vkEnd;
+#endif
+    (void)memory.EndAccess(texture, &state);
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): CreateExternalTexture returned null");
+  }
+
+  return std::make_shared<GPUExternalTexture>(
+      std::move(external), std::move(memory), std::move(texture),
+      std::move(label));
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <memory>
 #include <string>
+#include <utility>
 
 #include "descriptors/Unions.h"
 
@@ -12,16 +14,61 @@ namespace rnwgpu {
 
 namespace jsi = facebook::jsi;
 
+struct GPUExternalTextureDescriptor;
+
 class GPUExternalTexture : public NativeObject<GPUExternalTexture> {
 public:
   static constexpr const char *CLASS_NAME = "GPUExternalTexture";
 
-  explicit GPUExternalTexture(wgpu::ExternalTexture instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+  // Import a native buffer (via descriptor.source, a CVPixelBufferRef /
+  // AHardwareBuffer* from Skia's NativeBuffer API) as a GPUExternalTexture on
+  // `device`: imports the native surface as SharedTextureMemory, begins access,
+  // and wraps the resulting wgpu::ExternalTexture together with the resources
+  // whose lifetime it owns. The matching EndAccess runs in destroy() / the
+  // destructor. Defined in GPUExternalTexture.cpp.
+  static std::shared_ptr<GPUExternalTexture>
+  Create(wgpu::Device device,
+         std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
+
+  // Construct from an already-built wgpu::ExternalTexture plus the underlying
+  // shared-memory resources we need to keep alive. The wrapper takes ownership
+  // of the SharedTextureMemory + Texture and calls EndAccess on destruction so
+  // the producer (the native buffer's surface) can reclaim it.
+  GPUExternalTexture(wgpu::ExternalTexture instance,
+                     wgpu::SharedTextureMemory memory, wgpu::Texture texture,
+                     std::string label)
+      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
+        _memory(std::move(memory)), _texture(std::move(texture)),
+        _label(std::move(label)) {}
+
+  ~GPUExternalTexture() override { destroy(); }
 
 public:
   std::string getBrand() { return CLASS_NAME; }
 
+  // End the shared-memory access window and release the underlying resources.
+  // Idempotent: safe to call more than once, and the destructor calls it as a
+  // garbage-collection fallback. Call it right after the queue.submit() that
+  // sampled this texture (never before): a GPUExternalTexture's access window
+  // is owned by this wrapper's lifetime, not by submit, so without an explicit
+  // destroy() the producer's surface stays claimed until GC runs. EndAccess is
+  // the designed post-submit call: Dawn keeps the texture alive for in-flight
+  // GPU work via the fences it returns.
+  void destroy() {
+    if (_memory && _texture) {
+      wgpu::SharedTextureMemoryEndAccessState state{};
+#if defined(__ANDROID__)
+      // Dawn's Vulkan backend requires the released VkImageLayout to be chained
+      // (matches BeginAccess in GPUExternalTexture::Create).
+      wgpu::SharedTextureMemoryVkImageLayoutEndState vkEnd{};
+      state.nextInChain = &vkEnd;
+#endif
+      (void)_memory.EndAccess(_texture, &state);
+    }
+    _texture = nullptr;
+    _memory = nullptr;
+  }
+
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
     _label = label;
@@ -33,12 +80,15 @@ public:
     installGetterSetter(runtime, prototype, "label",
                         &GPUExternalTexture::getLabel,
                         &GPUExternalTexture::setLabel);
+    installMethod(runtime, prototype, "destroy", &GPUExternalTexture::destroy);
   }
 
   inline const wgpu::ExternalTexture get() { return _instance; }
 
 private:
   wgpu::ExternalTexture _instance;
+  wgpu::SharedTextureMemory _memory;
+  wgpu::Texture _texture;
   std::string _label;
 };
 

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -1,5 +1,6 @@
 #include "GPUQueue.h"
 
+#include <cstring>
 #include <limits>
 #include <memory>
 #include <vector>
@@ -103,51 +104,55 @@ void GPUQueue::copyExternalImageToTexture(
     std::shared_ptr<GPUImageCopyExternalImage> source,
     std::shared_ptr<GPUImageCopyTextureTagged> destination,
     std::shared_ptr<GPUExtent3D> size) {
-  //  wgpu::TexelCopyTextureInfo dst{};
-  //  wgpu::TexelCopyBufferLayout layout{};
-  //  wgpu::Extent3D sz{};
-  //  Convertor conv;
-  //  uint32_t bytesPerPixel =
-  //      source->source->getSize() /
-  //      (source->source->getWidth() * source->source->getHeight());
-  //  auto dataLayout = std::make_shared<GPUImageDataLayout>(GPUImageDataLayout{
-  //      std::optional<double>{0.0},
-  //      std::optional<double>{
-  //          static_cast<double>(bytesPerPixel * source->source->getWidth())},
-  //      std::optional<double>{static_cast<double>(source->source->getHeight())}});
-  //  if (!conv(dst.aspect, destination->aspect) ||
-  //      !conv(dst.mipLevel, destination->mipLevel) ||
-  //      !conv(dst.origin, destination->origin) ||
-  //      !conv(dst.texture, destination->texture) ||
-  //      !conv(layout, dataLayout) || //
-  //      !conv(sz, size)) {
-  //    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
-  //  }
-  //
-  //  if (source->flipY.value_or(false)) {
-  //    // Calculate the row size and total size
-  //    uint32_t rowSize = bytesPerPixel * source->source->getWidth();
-  //    uint32_t totalSize = source->source->getSize();
-  //
-  //    // Create a new buffer for the flipped data
-  //    std::vector<uint8_t> flippedData(totalSize);
-  //
-  //    // Flip the data vertically
-  //    for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
-  //      std::memcpy(flippedData.data() +
-  //                      (source->source->getHeight() - 1 - row) * rowSize,
-  //                  static_cast<const uint8_t *>(source->source->getData()) +
-  //                      row * rowSize,
-  //                  rowSize);
-  //    }
-  //    // Use the flipped data for writing to texture
-  //    _instance.WriteTexture(&dst, flippedData.data(), totalSize, &layout,
-  //    &sz);
-  //  } else {
-  //
-  //    _instance.WriteTexture(&dst, source->source->getData(),
-  //                           source->source->getSize(), &layout, &sz);
-  //  }
+  if (!source || source->source == nullptr) {
+    throw std::runtime_error("GPUQueue::copyExternalImageToTexture(): "
+                             "source.source (ImageBitmap) is required");
+  }
+  // ImageBitmap holds decoded, row-major RGBA8 pixels. We upload them with
+  // WriteTexture (a CPU staging copy) rather than a GPU blit; that is enough
+  // for the common "decode an image, sample it" path and avoids needing a
+  // source GPUTexture.
+  const auto &pixels = source->source->data();
+  auto width = static_cast<uint32_t>(source->source->getWidth());
+  auto height = static_cast<uint32_t>(source->source->getHeight());
+  if (pixels.empty() || width == 0 || height == 0) {
+    throw std::runtime_error("GPUQueue::copyExternalImageToTexture(): "
+                             "ImageBitmap has no pixels (was it closed?)");
+  }
+  auto bytesPerPixel = static_cast<uint32_t>(
+      pixels.size() / (static_cast<size_t>(width) * height));
+  uint32_t rowSize = bytesPerPixel * width;
+
+  wgpu::TexelCopyTextureInfo dst{};
+  wgpu::TexelCopyBufferLayout layout{};
+  wgpu::Extent3D sz{};
+  Convertor conv;
+  auto dataLayout = std::make_shared<GPUImageDataLayout>(
+      GPUImageDataLayout{std::optional<double>{0.0},
+                         std::optional<double>{static_cast<double>(rowSize)},
+                         std::optional<double>{static_cast<double>(height)}});
+  if (!conv(dst.aspect, destination->aspect) ||
+      !conv(dst.mipLevel, destination->mipLevel) ||
+      !conv(dst.origin, destination->origin) ||
+      !conv(dst.texture, destination->texture) || !conv(layout, dataLayout) ||
+      !conv(sz, size)) {
+    throw std::runtime_error(
+        "Invalid input for GPUQueue::copyExternalImageToTexture()");
+  }
+
+  if (source->flipY.value_or(false)) {
+    // Flip rows so the image is uploaded bottom-up (matches the WebGPU
+    // copyExternalImageToTexture flipY semantics).
+    std::vector<uint8_t> flippedData(pixels.size());
+    for (uint32_t row = 0; row < height; ++row) {
+      std::memcpy(flippedData.data() + (height - 1 - row) * rowSize,
+                  pixels.data() + row * rowSize, rowSize);
+    }
+    _instance.WriteTexture(&dst, flippedData.data(), flippedData.size(),
+                           &layout, &sz);
+  } else {
+    _instance.WriteTexture(&dst, pixels.data(), pixels.size(), &layout, &sz);
+  }
 }
 
 void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -18,7 +18,7 @@ async::AsyncTaskHandle GPUShaderModule::getCompilationInfo() {
             wgpu::CallbackMode::AllowProcessEvents,
             [result, resolve,
              reject](wgpu::CompilationInfoRequestStatus status,
-                     const wgpu::CompilationInfo *compilationInfo) mutable {
+                     const wgpu::CompilationInfo *compilationInfo) {
               if (status != wgpu::CompilationInfoRequestStatus::Success ||
                   compilationInfo == nullptr) {
                 reject("Failed to get compilation info");

package/cpp/rnwgpu/api/GPUSharedFence.cpp

@@ -0,0 +1,80 @@
+#include "GPUSharedFence.h"
+
+#include <cstdint>
+#include <string>
+
+#if defined(__ANDROID__)
+#include <fcntl.h>
+#endif
+
+namespace rnwgpu {
+
+namespace {
+
+// Kebab-case names matching the shared-fence-* feature strings (see Unions.h /
+// GPUFeatures.h).
+std::string sharedFenceTypeToString(wgpu::SharedFenceType type) {
+  switch (type) {
+  case wgpu::SharedFenceType::MTLSharedEvent:
+    return "mtl-shared-event";
+  case wgpu::SharedFenceType::SyncFD:
+    return "sync-fd";
+  case wgpu::SharedFenceType::VkSemaphoreOpaqueFD:
+    return "vk-semaphore-opaque-fd";
+  case wgpu::SharedFenceType::VkSemaphoreZirconHandle:
+    return "vk-semaphore-zircon-handle";
+  case wgpu::SharedFenceType::DXGISharedHandle:
+    return "dxgi-shared-handle";
+  case wgpu::SharedFenceType::EGLSync:
+    return "egl-sync";
+  default:
+    return "";
+  }
+}
+
+} // namespace
+
+jsi::Value GPUSharedFence::exportInfo(jsi::Runtime &runtime, const jsi::Value &,
+                                      const jsi::Value *, size_t) {
+  wgpu::SharedFenceExportInfo info{};
+  uint64_t handle = 0;
+
+#if defined(__APPLE__)
+  // Apple: the handle is an id<MTLSharedEvent> pointer.
+  wgpu::SharedFenceMTLSharedEventExportInfo mtlInfo{};
+  info.nextInChain = &mtlInfo;
+  _instance.ExportInfo(&info);
+  handle = reinterpret_cast<uint64_t>(mtlInfo.sharedEvent);
+#elif defined(__ANDROID__)
+  // Android: the handle is an OS file descriptor (sync_fd). Dawn's ExportInfo
+  // returns a BORROWED fd: it is owned by the SharedFence and closed when the
+  // fence is destroyed. This exported handle is documented as caller-owned (the
+  // caller must close() it), so dup() it. Without the dup the same fd is closed
+  // twice (once by the caller and once by Dawn on fence destruction), tripping
+  // Android's fdsan (double-close abort).
+  wgpu::SharedFenceSyncFDExportInfo fdInfo{};
+  info.nextInChain = &fdInfo;
+  _instance.ExportInfo(&info);
+  int exportedFd = fdInfo.handle >= 0
+                       ? ::fcntl(fdInfo.handle, F_DUPFD_CLOEXEC, 0)
+                       : fdInfo.handle;
+  handle = static_cast<uint64_t>(static_cast<uint32_t>(exportedFd));
+#else
+  // react-native-skia only targets Apple (Metal) and Android (Vulkan). On any
+  // other platform there is no native handle convention to expose, so fail
+  // loudly rather than handing back a meaningless handle of 0.
+  throw jsi::JSError(runtime,
+                     "GPUSharedFence::export(): unsupported platform (only "
+                     "Apple/Metal and Android/Vulkan are supported)");
+#endif
+
+  jsi::Object result(runtime);
+  result.setProperty(
+      runtime, "type",
+      jsi::String::createFromUtf8(runtime, sharedFenceTypeToString(info.type)));
+  result.setProperty(runtime, "handle",
+                     jsi::BigInt::fromUint64(runtime, handle));
+  return result;
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedFence.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+// Wraps a wgpu::SharedFence: a native GPU sync primitive (id<MTLSharedEvent> on
+// Apple, sync-fd / VkSemaphore on Android).
+class GPUSharedFence : public NativeObject<GPUSharedFence> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUSharedFence";
+
+  explicit GPUSharedFence(wgpu::SharedFence instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
+        _label(std::move(label)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  // export() -> { type, handle }: exposes the native handle (as a BigInt) so
+  // app code can wait on or signal the fence. The caller owns the returned
+  // handle (e.g. an exported sync-fd must be close()d).
+  jsi::Value exportInfo(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", &GPUSharedFence::getBrand);
+    installMethod(runtime, prototype, "export", &GPUSharedFence::exportInfo);
+    installGetterSetter(runtime, prototype, "label", &GPUSharedFence::getLabel,
+                        &GPUSharedFence::setLabel);
+  }
+
+  inline wgpu::SharedFence get() { return _instance; }
+
+private:
+  wgpu::SharedFence _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu