@shopify/react-native-skia 2.6.3 → 2.6.5

package/cpp/rnskia/RNDawnUtils.h

@@ -5,7 +5,7 @@
 #include "dawn/dawn_proc.h"
 #include "dawn/native/DawnNative.h"
 
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 #include "include/core/SkColorType.h"
 #include "include/gpu/graphite/dawn/DawnBackendContext.h"
 
@@ -206,12 +206,22 @@ createDawnBackendContext(dawn::native::Instance *instance) {
       wgpu::FeatureName::ImplicitDeviceSynchronization,
 #ifdef __APPLE__
       wgpu::FeatureName::SharedTextureMemoryIOSurface,
+      // Required to call SharedTextureMemory::EndAccess on Metal (it exports a
+      // MTLSharedEvent fence). importExternalTexture / importSharedTextureMemory
+      // end the access window after submit; without this EndAccess errors with
+      // "Required feature (SharedFenceMTLSharedEvent) is missing". Safe here
+      // because we always queue.submit() before EndAccess (the secondary device
+      // omits it on purpose — its camera path doesn't commit first).
+      wgpu::FeatureName::SharedFenceMTLSharedEvent,
       wgpu::FeatureName::DawnMultiPlanarFormats,
       wgpu::FeatureName::MultiPlanarFormatP010,
       wgpu::FeatureName::MultiPlanarFormatP210,
       wgpu::FeatureName::MultiPlanarFormatExtendedUsages,
 #else
       wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer,
+      // Vulkan equivalent of the above: EndAccess exports a sync-fd fence.
+      wgpu::FeatureName::SharedFenceSyncFD,
+      wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD,
 #endif
   };
 

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -9,11 +9,11 @@
 #include <utility>
 #include <vector>
 
-#include "JsiHostObject.h"
+#include "jsi/JsiHostObject.h"
 #include "RNSkPictureView.h"
 #include "RNSkPlatformContext.h"
 #include "RNSkView.h"
-#include "ViewProperty.h"
+#include "jsi/ViewProperty.h"
 #include <jsi/jsi.h>
 
 namespace RNSkia {

package/cpp/rnskia/RNSkManager.cpp

@@ -5,22 +5,29 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkApi.h"
+#include "api/JsiSkApi.h"
 #include "RNSkJsiViewApi.h"
 #include "RNSkView.h"
 
-#include "RuntimeAwareCache.h"
+#include "jsi/RuntimeAwareCache.h"
 
 #ifdef SK_GRAPHITE
 #include "RNDawnContext.h"
+#include "rnwgpu/ArrayBuffer.h"
 #include "rnwgpu/api/GPU.h"
 #include "rnwgpu/api/GPUUncapturedErrorEvent.h"
+#include "rnwgpu/api/ImageBitmap.h"
 #include "rnwgpu/api/RNWebGPU.h"
 #include "rnwgpu/api/descriptors/GPUBufferUsage.h"
 #include "rnwgpu/api/descriptors/GPUColorWrite.h"
 #include "rnwgpu/api/descriptors/GPUMapMode.h"
 #include "rnwgpu/api/descriptors/GPUShaderStage.h"
 #include "rnwgpu/api/descriptors/GPUTextureUsage.h"
+#include "jsi2/Promise.h"
+
+#include "include/core/SkData.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkImageInfo.h"
 #endif
 
 namespace RNSkia {
@@ -114,6 +121,85 @@ void RNSkManager::installBindings() {
   auto rnWebGPU = std::make_shared<rnwgpu::RNWebGPU>(gpu, nullptr);
   _jsRuntime->global().setProperty(
       *_jsRuntime, "RNWebGPU", rnwgpu::RNWebGPU::create(*_jsRuntime, rnWebGPU));
+
+  // DRAFT — compile-unverified. Install the ImageBitmap constructor (so
+  // `instanceof ImageBitmap` works) and a global createImageBitmap() that
+  // accepts the non-standard encoded-BufferSource overload.
+  //
+  // The BufferSource is run through the shared rnwgpu::ArrayBuffer converter,
+  // which validates byteOffset/byteLength against the backing buffer and throws
+  // synchronously on a spoofed / out-of-bounds view — so createImageBitmap()
+  // rejects rather than reading out of bounds (see ArrayBufferBounds /
+  // ImageBitmapBounds specs). Decoding uses Skia's own codec; no platform image
+  // decoder is needed.
+  rnwgpu::ImageBitmap::installConstructor(*_jsRuntime);
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "createImageBitmap",
+      jsi::Function::createFromHostFunction(
+          *_jsRuntime,
+          jsi::PropNameID::forAscii(*_jsRuntime, "createImageBitmap"), 1,
+          [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+            if (count < 1 || !args[0].isObject()) {
+              throw jsi::JSError(
+                  rt, "createImageBitmap requires a BufferSource argument");
+            }
+            // Only the encoded ArrayBuffer / ArrayBufferView overload is
+            // supported here. Anything else (Blob, ImageData, …) is rejected.
+            auto obj = args[0].getObject(rt);
+            bool isBufferSource = obj.isArrayBuffer(rt);
+            if (!isBufferSource && obj.hasProperty(rt, "buffer")) {
+              auto bufferProp = obj.getProperty(rt, "buffer");
+              isBufferSource =
+                  bufferProp.isObject() &&
+                  bufferProp.getObject(rt).isArrayBuffer(rt);
+            }
+            if (!isBufferSource) {
+              throw jsi::JSError(rt, "createImageBitmap: unsupported source "
+                                     "(expected an ArrayBuffer or TypedArray "
+                                     "of encoded image bytes)");
+            }
+            // Validates bounds and THROWS synchronously on a spoofed view, so
+            // the bad pointer never reaches the copy below.
+            auto buffer =
+                rnwgpu::JSIConverter<std::shared_ptr<rnwgpu::ArrayBuffer>>::
+                    fromJSI(rt, args[0], false);
+            // Copy the encoded bytes off the JS-owned ArrayBuffer.
+            const uint8_t *bytes = buffer->data();
+            std::vector<uint8_t> encoded(bytes, bytes + buffer->size());
+
+            return rnwgpu::Promise::createPromise(
+                rt, [encoded = std::move(encoded)](
+                        jsi::Runtime &runtime,
+                        std::shared_ptr<rnwgpu::Promise> promise) mutable {
+                  auto skData =
+                      SkData::MakeWithCopy(encoded.data(), encoded.size());
+                  auto image = SkImages::DeferredFromEncodedData(skData);
+                  if (image == nullptr) {
+                    promise->reject(
+                        "createImageBitmap: failed to decode image data");
+                    return;
+                  }
+                  const int w = image->width();
+                  const int h = image->height();
+                  auto info =
+                      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType,
+                                        kUnpremul_SkAlphaType);
+                  std::vector<uint8_t> pixels(info.computeMinByteSize());
+                  // nullptr context: decode/read on the CPU (raster).
+                  if (!image->readPixels(nullptr, info, pixels.data(),
+                                         info.minRowBytes(), 0, 0)) {
+                    promise->reject(
+                        "createImageBitmap: failed to read decoded pixels");
+                    return;
+                  }
+                  auto bitmap = std::make_shared<rnwgpu::ImageBitmap>(
+                      std::move(pixels), static_cast<size_t>(w),
+                      static_cast<size_t>(h));
+                  promise->resolve(
+                      rnwgpu::ImageBitmap::create(runtime, bitmap));
+                });
+          }));
 #endif
 }
 } // namespace RNSkia

package/cpp/rnskia/RNSkPictureView.h

@@ -11,12 +11,12 @@
 #include <jsi/jsi.h>
 
 #include "RNSkView.h"
-#include "ViewProperty.h"
+#include "jsi/ViewProperty.h"
 
-#include "JsiSkPicture.h"
-#include "RNSkLog.h"
+#include "api/JsiSkPicture.h"
+#include "utils/RNSkLog.h"
 #include "RNSkPlatformContext.h"
-#include "RNSkTimingInfo.h"
+#include "utils/RNSkTimingInfo.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"

package/cpp/rnskia/RNSkPlatformContext.h

@@ -141,6 +141,13 @@ public:
 
   virtual uint64_t makeNativeBuffer(sk_sp<SkImage> image) = 0;
 
+  // Allocate a platform native buffer (IOSurface on Apple, AHardwareBuffer on
+  // Android) of the given size filled with a procedural test pattern (RGB
+  // gradient + diagonal stripes), entirely on the CPU. Intended for examples
+  // and tests that need a buffer to feed into importExternalTexture without a
+  // camera/video source. Release it with releaseNativeBuffer().
+  virtual uint64_t makeTestNativeBuffer(int width, int height) = 0;
+
   virtual std::shared_ptr<RNSkVideo> createVideo(const std::string &url) = 0;
 
   /**

package/cpp/rnskia/RNSkView.h

@@ -7,11 +7,11 @@
 #include <vector>
 
 #include "RNSkPlatformContext.h"
-#include "ViewProperty.h"
+#include "jsi/ViewProperty.h"
 
-#include "JsiSkImage.h"
-#include "JsiSkPoint.h"
-#include "JsiSkRect.h"
+#include "api/JsiSkImage.h"
+#include "api/JsiSkPoint.h"
+#include "api/JsiSkRect.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -94,8 +94,11 @@ public:
       image = _surface->makeImageSnapshot();
     }
 #if defined(SK_GRAPHITE)
-    DawnContext::getInstance().submitRecording(
-        _surface->recorder()->snap().get());
+    // Only Graphite-backed surfaces have a recorder to snap/submit; a raster
+    // surface's snapshot is already a valid CPU image.
+    if (auto *recorder = _surface->recorder()) {
+      DawnContext::getInstance().submitRecording(recorder->snap().get());
+    }
     return DawnContext::getInstance().MakeRasterImage(image);
 #else
     auto grContext = _context->getDirectContext();

package/cpp/rnwgpu/ArrayBuffer.h

@@ -1,6 +1,8 @@
 #pragma once
 #include <jsi/jsi.h>
 
+#include <cmath>
+#include <cstdint>
 #include <memory>
 
 #include "jsi2/JSIConverter.h"
@@ -47,16 +49,58 @@ template <> struct JSIConverter<std::shared_ptr<ArrayBuffer>> {
         if (bufferProp.isObject() &&
             bufferProp.getObject(runtime).isArrayBuffer(runtime)) {
           auto buff = bufferProp.getObject(runtime);
-          auto bytesPerElements =
-              obj.getProperty(runtime, "BYTES_PER_ELEMENT").asNumber();
           auto arrayBuffer = buff.getArrayBuffer(runtime);
-          auto byteOffset = static_cast<size_t>(
-              obj.getProperty(runtime, "byteOffset").asNumber());
-          auto byteLength = static_cast<size_t>(
-              obj.getProperty(runtime, "byteLength").asNumber());
+          const size_t bufferSize = arrayBuffer.size(runtime);
+
+          // byteOffset / byteLength are user-readable JS properties, not values
+          // the engine guarantees (unlike Dawn's node binding, which reads them
+          // off the engine's typed-array view). Read them as doubles so we can
+          // reject negative, non-integral, NaN/Inf, or oversized values before
+          // they wrap around when cast to size_t.
+          const double byteOffsetValue =
+              obj.getProperty(runtime, "byteOffset").asNumber();
+          const double byteLengthValue =
+              obj.getProperty(runtime, "byteLength").asNumber();
+
+          auto isValidByteIndex = [](double value) {
+            return std::isfinite(value) && value >= 0.0 &&
+                   value <= static_cast<double>(SIZE_MAX) &&
+                   std::floor(value) == value;
+          };
+          if (!isValidByteIndex(byteOffsetValue) ||
+              !isValidByteIndex(byteLengthValue)) {
+            throw std::runtime_error(
+                "ArrayBuffer::fromJSI: invalid byteOffset/byteLength");
+          }
+
+          const size_t byteOffset = static_cast<size_t>(byteOffsetValue);
+          const size_t byteLength = static_cast<size_t>(byteLengthValue);
+
+          // Overflow-safe bounds check: byteOffset + byteLength <= bufferSize.
+          if (byteOffset > bufferSize ||
+              byteLength > bufferSize - byteOffset) {
+            throw std::runtime_error(
+                "ArrayBuffer::fromJSI: view bounds [byteOffset, byteOffset + "
+                "byteLength) exceed the backing ArrayBuffer size");
+          }
+
+          // BYTES_PER_ELEMENT is absent on a DataView; default to 1. A spoofed
+          // object could report 0 (or a negative/NaN value), so clamp to a
+          // minimum of 1 to avoid a later division by zero in writeBuffer.
+          size_t bytesPerElements = 1;
+          if (obj.hasProperty(runtime, "BYTES_PER_ELEMENT")) {
+            auto bpe = obj.getProperty(runtime, "BYTES_PER_ELEMENT");
+            if (bpe.isNumber()) {
+              const double value = bpe.asNumber();
+              if (std::isfinite(value) && value >= 1.0) {
+                bytesPerElements = static_cast<size_t>(value);
+              }
+            }
+          }
+
           return std::make_shared<ArrayBuffer>(
               arrayBuffer.data(runtime) + byteOffset, byteLength,
-              static_cast<size_t>(bytesPerElements));
+              bytesPerElements);
         }
       }
     }

package/cpp/rnwgpu/api/AppleNativeBuffer.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#if defined(__APPLE__)
+
+#include <cstdint>
+
+namespace rnwgpu {
+
+// Extract the backing IOSurface and dimensions from a CVPixelBufferRef pointer
+// (the value Skia's NativeBuffer.MakeFromImage returns on Apple). The returned
+// IOSurfaceRef is owned by the CVPixelBuffer; the caller must keep the
+// CVPixelBuffer alive while the IOSurface is in use. Returns nullptr (and
+// leaves the out-params at 0) if the buffer has no IOSurface.
+//
+// Defined in apple/RNWebGPUAppleNativeBuffer.mm (Objective-C++ so it can use
+// CoreVideo, which isn't available from the cpp/ translation units).
+void *GetIOSurfaceFromNativeBuffer(void *cvPixelBuffer, uint32_t *outWidth,
+                                   uint32_t *outHeight);
+
+} // namespace rnwgpu
+
+#endif // __APPLE__

package/cpp/rnwgpu/api/Convertors.h

@@ -252,13 +252,24 @@ public:
 
   [[nodiscard]] bool Convert(wgpu::BindGroupLayoutEntry &out,
                              const GPUBindGroupLayoutEntry &in) {
-    return Convert(out.binding, in.binding) &&
-           Convert(out.visibility, in.visibility) &&
-           Convert(out.buffer, in.buffer) && Convert(out.sampler, in.sampler) &&
-           Convert(out.texture, in.texture) &&
-           Convert(out.storageTexture, in.storageTexture);
-    // no external textures here
-    //&& Convert(out.externalTexture, in.externalTexture);
+    out = {};
+    if (!Convert(out.binding, in.binding) ||
+        !Convert(out.visibility, in.visibility) ||
+        !Convert(out.buffer, in.buffer) || !Convert(out.sampler, in.sampler) ||
+        !Convert(out.texture, in.texture) ||
+        !Convert(out.storageTexture, in.storageTexture)) {
+      return false;
+    }
+    if (in.externalTexture.has_value() &&
+        in.externalTexture.value() != nullptr) {
+      // External texture layouts bind via a chained struct rather than a
+      // direct field on BindGroupLayoutEntry. The chained struct must outlive
+      // the BindGroupLayoutEntry until Device::CreateBindGroupLayout returns,
+      // so we allocate it on the Convertor's arena.
+      auto *chain = Allocate<wgpu::ExternalTextureBindingLayout>();
+      out.nextInChain = chain;
+    }
+    return true;
   }
 
   [[nodiscard]] bool Convert(wgpu::BlendComponent &out,
@@ -422,9 +433,11 @@ public:
   }
 
   [[nodiscard]] bool Convert(wgpu::ExternalTextureBindingLayout &out,
-                             const GPUExternalTextureBindingLayout &in) {
-    // no external textures at the moment
-    return false;
+                             const GPUExternalTextureBindingLayout & /*in*/) {
+    // ExternalTextureBindingLayout carries no fields of its own; its presence
+    // (as a chained struct) is what marks the entry as an external texture.
+    out = {};
+    return true;
   }
 
   [[nodiscard]] bool Convert(wgpu::ConstantEntry &out, const std::string &key,
@@ -729,7 +742,16 @@ public:
       out.buffer = buffer->get();
       return true;
     }
-    // Not external textures at the moment
+    if (in.externalTexture != nullptr) {
+      // External textures bind via a chained struct rather than a direct field
+      // on BindGroupEntry. The chained struct must outlive the BindGroupEntry
+      // until Device::CreateBindGroup returns, so we allocate it on the
+      // Convertor's arena.
+      auto *chain = Allocate<wgpu::ExternalTextureBindingEntry>();
+      chain->externalTexture = in.externalTexture->get();
+      out.nextInChain = chain;
+      return true;
+    }
     return false;
   }
 

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -109,9 +109,35 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
        deviceLostBinding,
        creationRuntime](const async::AsyncTaskHandle::ResolveFunction &resolve,
                         const async::AsyncTaskHandle::RejectFunction &reject) {
-        (void)descriptor;
+        // Build a local mutable copy so we can chain Dawn's device toggles.
+        // The toggle name strings are owned by `descriptor` (captured above),
+        // and the const char* / DawnTogglesDescriptor locals live for the
+        // whole synchronous RequestDevice call below, which is when Dawn reads
+        // the chained struct.
+        wgpu::DeviceDescriptor deviceDesc = aDescriptor;
+        wgpu::DawnTogglesDescriptor toggles{};
+        std::vector<const char *> enabledToggles;
+        std::vector<const char *> disabledToggles;
+        if (descriptor.has_value() && descriptor.value()->dawnToggles) {
+          const auto &dawnToggles = descriptor.value()->dawnToggles.value();
+          if (dawnToggles->enabledToggles) {
+            for (const auto &t : dawnToggles->enabledToggles.value()) {
+              enabledToggles.push_back(t.c_str());
+            }
+            toggles.enabledToggleCount = enabledToggles.size();
+            toggles.enabledToggles = enabledToggles.data();
+          }
+          if (dawnToggles->disabledToggles) {
+            for (const auto &t : dawnToggles->disabledToggles.value()) {
+              disabledToggles.push_back(t.c_str());
+            }
+            toggles.disabledToggleCount = disabledToggles.size();
+            toggles.disabledToggles = disabledToggles.data();
+          }
+          deviceDesc.nextInChain = &toggles;
+        }
         _instance.RequestDevice(
-            &aDescriptor, wgpu::CallbackMode::AllowProcessEvents,
+            &deviceDesc, wgpu::CallbackMode::AllowProcessEvents,
             [asyncRunner = _async, resolve, reject, label, creationRuntime,
              deviceLostBinding](wgpu::RequestDeviceStatus status,
                                 wgpu::Device device,

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -14,7 +14,7 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "ArrayBuffer.h"
+#include "rnwgpu/ArrayBuffer.h"
 
 namespace rnwgpu {
 

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,34 @@ 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));
 }
 
 async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(

package/cpp/rnwgpu/api/GPUDevice.h

@@ -37,6 +37,7 @@
 #include "GPURenderPipeline.h"
 #include "GPUSampler.h"
 #include "GPUShaderModule.h"
+#include "GPUSharedTextureMemory.h"
 #include "GPUSupportedLimits.h"
 #include "GPUTexture.h"
 #include "descriptors/GPUBindGroupDescriptor.h"
@@ -51,6 +52,7 @@
 #include "descriptors/GPURenderPipelineDescriptor.h"
 #include "descriptors/GPUSamplerDescriptor.h"
 #include "descriptors/GPUShaderModuleDescriptor.h"
+#include "descriptors/GPUSharedTextureMemoryDescriptor.h"
 #include "descriptors/GPUTextureDescriptor.h"
 
 namespace rnwgpu {
@@ -120,6 +122,8 @@ 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<GPUBindGroupLayout> createBindGroupLayout(
       std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
   std::shared_ptr<GPUPipelineLayout>
@@ -173,6 +177,8 @@ public:
                   &GPUDevice::createSampler);
     installMethod(runtime, prototype, "importExternalTexture",
                   &GPUDevice::importExternalTexture);
+    installMethod(runtime, prototype, "importSharedTextureMemory",
+                  &GPUDevice::importSharedTextureMemory);
     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