react-native-webgpu 0.11.0 → 0.11.1

package/cpp/rnwgpu/PlatformContext.h

@@ -59,7 +59,8 @@ struct VideoFrameHandle {
 };
 
 // Platform-implemented video source that hands out fresh IOSurface /
-// AHardwareBuffer-backed frames as a video plays.
+// AHardwareBuffer-backed frames as a video plays, with the playback controls
+// of an HTMLMediaElement (times in seconds).
 class IVideoPlayer {
 public:
   virtual ~IVideoPlayer() = default;
@@ -71,6 +72,26 @@ public:
 
   virtual void play() = 0;
   virtual void pause() = 0;
+  virtual bool paused() = 0;
+
+  // Playback position and length, in seconds. The duration is 0 until the
+  // metadata of the media has loaded.
+  virtual double currentTime() = 0;
+  virtual void seek(double seconds) = 0;
+  virtual double duration() = 0;
+
+  virtual double volume() = 0;
+  virtual void setVolume(double volume) = 0;
+  virtual bool loop() = 0;
+  virtual void setLoop(bool loop) = 0;
+
+  // The geometry of the frames, 0 until the metadata has loaded: their coded
+  // size, the clockwise rotation (0, 90, 180 or 270) to apply when displaying
+  // them, and the nominal frame rate of the video track.
+  virtual uint32_t videoWidth() = 0;
+  virtual uint32_t videoHeight() = 0;
+  virtual int rotation() = 0;
+  virtual double frameRate() = 0;
 };
 
 // A request to rasterize a native React Native view (looked up by its React
@@ -117,10 +138,9 @@ public:
   // pixel, `format` is rgba8unorm or bgra8unorm depending on what the platform
   // rasterizer produces natively, and `premultiplied` reports its alpha
   // representation.
-  virtual void
-  snapshotView(const ViewSnapshotRequest &request,
-               std::function<void(ImageData)> onSuccess,
-               std::function<void(std::string)> onError) = 0;
+  virtual void snapshotView(const ViewSnapshotRequest &request,
+                            std::function<void(ImageData)> onSuccess,
+                            std::function<void(std::string)> onError) = 0;
 
   virtual wgpu::Surface makeSurface(wgpu::Instance instance, void *surface,
                                     int width, int height) = 0;

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -133,7 +133,8 @@ std::shared_ptr<GPUSupportedLimits> GPUDevice::getLimits() {
 
 std::shared_ptr<GPUQueue> GPUDevice::getQueue() {
   auto result = _instance.GetQueue();
-  return std::make_shared<GPUQueue>(result, _async, _label);
+  return std::make_shared<GPUQueue>(_instance, result, _async, _videoFrameBlit,
+                                    _label);
 }
 
 std::shared_ptr<GPUCommandEncoder> GPUDevice::createCommandEncoder(

package/cpp/rnwgpu/api/GPUDevice.h

@@ -54,6 +54,7 @@
 #include "GPUTexture.h"
 #include "GPUTextureDescriptor.h"
 #include "GPUUncapturedErrorEvent.h"
+#include "VideoFrameBlit.h"
 
 namespace rnwgpu {
 
@@ -285,6 +286,11 @@ private:
   wgpu::Device _instance;
   std::shared_ptr<async::RuntimeContext> _async;
   std::string _label;
+  // Renders native video frames into textures for
+  // GPUQueue.copyExternalImageToTexture; shared by every GPUQueue wrapper of
+  // this device so the pipelines are created once.
+  std::shared_ptr<VideoFrameBlit> _videoFrameBlit =
+      std::make_shared<VideoFrameBlit>();
   // Guards the device-lost state below. getLost() runs on a JS thread, but
   // Dawn's AllowSpontaneous device-lost callback (and device destruction) can
   // fire notifyDeviceLost() from other threads, so the mutex keeps these

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -109,6 +109,68 @@ async::AsyncTaskHandle GPUQueue::onSubmittedWorkDone(jsi::Runtime &runtime) {
       });
 }
 
+void GPUQueue::copyVideoFrameToTexture(
+    const GPUImageCopyExternalImage &source,
+    const GPUImageCopyTextureTagged &destination, const wgpu::Extent3D &size) {
+  if (!destination.texture) {
+    throw std::runtime_error(
+        "copyExternalImageToTexture: destination.texture is required");
+  }
+  if (destination.aspect.value_or(wgpu::TextureAspect::All) !=
+      wgpu::TextureAspect::All) {
+    throw std::runtime_error(
+        "copyExternalImageToTexture: a native frame can only be copied into "
+        "the color aspect");
+  }
+  if (size.depthOrArrayLayers > 1) {
+    throw std::runtime_error(
+        "copyExternalImageToTexture: a native frame is a single 2D image");
+  }
+  constexpr double kMaxCoordinate =
+      static_cast<double>(std::numeric_limits<uint32_t>::max());
+  auto coordinate = [&](double value, const char *name) {
+    if (!(value >= 0) || value > kMaxCoordinate) {
+      throw std::runtime_error(std::string("copyExternalImageToTexture: ") +
+                               name +
+                               " must be a non-negative integer coordinate");
+    }
+    return static_cast<uint32_t>(value);
+  };
+  const double rotation = source.rotation.value_or(0);
+  if (rotation != 0 && rotation != 90 && rotation != 180 && rotation != 270) {
+    throw std::runtime_error(
+        "copyExternalImageToTexture: rotation must be 0, 90, 180 or 270");
+  }
+
+  VideoFrameBlit::Request request;
+  request.frame = source.videoFrame;
+  if (const auto origin = source.origin.value_or(nullptr)) {
+    request.originX = coordinate(origin->x, "origin.x");
+    request.originY = coordinate(origin->y, "origin.y");
+  }
+  request.width = size.width;
+  request.height = size.height;
+  request.flipY = source.flipY.value_or(false);
+  request.rotation = rotation;
+  request.mirrored = source.mirrored.value_or(false);
+  request.texture = destination.texture->get();
+  request.mipLevel = coordinate(destination.mipLevel.value_or(0), "mipLevel");
+  wgpu::Origin3D dstOrigin{};
+  Convertor conv;
+  if (!conv(dstOrigin, destination.origin)) {
+    throw std::runtime_error(
+        "copyExternalImageToTexture: invalid destination origin");
+  }
+  if (dstOrigin.z != 0) {
+    throw std::runtime_error(
+        "copyExternalImageToTexture: a native frame can only be copied into "
+        "the first layer of the texture");
+  }
+  request.dstX = dstOrigin.x;
+  request.dstY = dstOrigin.y;
+  _videoFrameBlit->copy(_device, _instance, request);
+}
+
 void GPUQueue::copyExternalImageToTexture(
     std::shared_ptr<GPUImageCopyExternalImage> source,
     std::shared_ptr<GPUImageCopyTextureTagged> destination,
@@ -117,6 +179,17 @@ void GPUQueue::copyExternalImageToTexture(
   wgpu::TexelCopyBufferLayout layout{};
   wgpu::Extent3D sz{};
   Convertor conv;
+  if (source->videoFrame) {
+    if (!conv(sz, size)) {
+      throw std::runtime_error("copyExternalImageToTexture: invalid copy size");
+    }
+    copyVideoFrameToTexture(*source, *destination, sz);
+    return;
+  }
+  if (!source->source) {
+    throw std::runtime_error("copyExternalImageToTexture: the source must be "
+                             "an ImageBitmap or a NativeVideoFrame");
+  }
   uint32_t bytesPerPixel =
       source->source->getSize() /
       (source->source->getWidth() * source->source->getHeight());
@@ -145,10 +218,8 @@ void GPUQueue::copyExternalImageToTexture(
     throw std::runtime_error(
         "The source origin must be a non-negative integer coordinate.");
   }
-  const size_t sourceOriginX =
-      origin ? static_cast<size_t>(origin->x) : 0;
-  const size_t sourceOriginY =
-      origin ? static_cast<size_t>(origin->y) : 0;
+  const size_t sourceOriginX = origin ? static_cast<size_t>(origin->x) : 0;
+  const size_t sourceOriginY = origin ? static_cast<size_t>(origin->y) : 0;
   if (sourceOriginX > source->source->getWidth() ||
       sz.width > source->source->getWidth() - sourceOriginX ||
       sourceOriginY > source->source->getHeight() ||
@@ -220,8 +291,7 @@ async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
   Convertor conv;
   if (!conv(dst.aspect, info->aspect) || !conv(dst.mipLevel, info->mipLevel) ||
       !conv(dst.origin, info->origin) || !conv(dst.texture, info->texture)) {
-    throw std::runtime_error(
-        "drawElementImageToTexture: invalid destination");
+    throw std::runtime_error("drawElementImageToTexture: invalid destination");
   }
   const wgpu::Texture texture = info->texture->get();
   bool destinationIsBgra = false;
@@ -335,10 +405,10 @@ async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
                        "pixels (is it mounted with a non-zero size?)");
                 return;
               }
-              if (image.width > mipWidth - std::min<uint32_t>(dst.origin.x,
-                                                              mipWidth) ||
-                  image.height > mipHeight - std::min<uint32_t>(dst.origin.y,
-                                                                mipHeight)) {
+              if (image.width >
+                      mipWidth - std::min<uint32_t>(dst.origin.x, mipWidth) ||
+                  image.height >
+                      mipHeight - std::min<uint32_t>(dst.origin.y, mipHeight)) {
                 reject("drawElementImageToTexture: the view's natural pixel "
                        "size (" +
                        std::to_string(image.width) + "x" +

package/cpp/rnwgpu/api/GPUQueue.h

@@ -20,6 +20,7 @@
 #include "GPUDrawElementImageSource.h"
 #include "GPUImageCopyExternalImage.h"
 #include "GPUImageCopyTextureTagged.h"
+#include "VideoFrameBlit.h"
 
 namespace rnwgpu {
 
@@ -29,10 +30,12 @@ class GPUQueue : public NativeObject<GPUQueue> {
 public:
   static constexpr const char *CLASS_NAME = "GPUQueue";
 
-  explicit GPUQueue(wgpu::Queue instance,
+  explicit GPUQueue(wgpu::Device device, wgpu::Queue instance,
                     std::shared_ptr<async::RuntimeContext> async,
+                    std::shared_ptr<VideoFrameBlit> videoFrameBlit,
                     std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _async(async),
+      : NativeObject(CLASS_NAME), _device(device), _instance(instance),
+        _async(async), _videoFrameBlit(std::move(videoFrameBlit)),
         _label(label) {}
 
 public:
@@ -48,6 +51,9 @@ public:
                     std::shared_ptr<ArrayBuffer> data,
                     std::shared_ptr<GPUImageDataLayout> dataLayout,
                     std::shared_ptr<GPUExtent3D> size);
+  // The source is an ImageBitmap (uploaded from the CPU) or, as a React
+  // Native extension, a NativeVideoFrame rendered into the destination through
+  // an external texture (see VideoFrameBlit).
   void copyExternalImageToTexture(
       std::shared_ptr<GPUImageCopyExternalImage> source,
       std::shared_ptr<GPUImageCopyTextureTagged> destination,
@@ -61,8 +67,7 @@ public:
   // runtime's thread right before the promise resolves, so work submitted
   // after `await` observes the new contents.
   async::AsyncTaskHandle drawElementImageToTexture(
-      jsi::Runtime &runtime,
-      std::shared_ptr<GPUDrawElementImageSource> source,
+      jsi::Runtime &runtime, std::shared_ptr<GPUDrawElementImageSource> source,
       std::shared_ptr<GPUDrawElementImageDestination> destination);
 
   std::string getLabel() { return _label; }
@@ -89,8 +94,14 @@ public:
   inline const wgpu::Queue get() { return _instance; }
 
 private:
+  void copyVideoFrameToTexture(const GPUImageCopyExternalImage &source,
+                               const GPUImageCopyTextureTagged &destination,
+                               const wgpu::Extent3D &size);
+
+  wgpu::Device _device;
   wgpu::Queue _instance;
   std::shared_ptr<async::RuntimeContext> _async;
+  std::shared_ptr<VideoFrameBlit> _videoFrameBlit;
   std::string _label;
 };
 

package/cpp/rnwgpu/api/VideoFrameBlit.h

@@ -0,0 +1,355 @@
+#pragma once
+
+#include <array>
+#include <cstring>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUExternalTexture.h"
+#include "GPUExternalTextureDescriptor.h"
+#include "VideoFrame.h"
+
+namespace rnwgpu {
+
+// Renders a native video frame into a region of a regular texture. The frame
+// is imported as an external texture, so Dawn does the YUV to RGB conversion
+// and applies the rotation and the mirroring; a full-screen triangle then
+// samples it into the destination. This is what backs
+// GPUQueue.copyExternalImageToTexture for NativeVideoFrame sources.
+//
+// One instance per device, shared by its GPUQueue wrappers (a new wrapper is
+// created on every `device.queue` access): it caches the shader, the layouts
+// and one pipeline per destination format.
+class VideoFrameBlit {
+public:
+  struct Request {
+    std::shared_ptr<VideoFrame> frame;
+    // The region of the upright frame (after rotation and mirroring) to copy.
+    uint32_t originX = 0;
+    uint32_t originY = 0;
+    uint32_t width = 0;
+    uint32_t height = 0;
+    bool flipY = false;
+    double rotation = 0;
+    bool mirrored = false;
+    // The destination region.
+    wgpu::Texture texture;
+    uint32_t mipLevel = 0;
+    uint32_t dstX = 0;
+    uint32_t dstY = 0;
+  };
+
+  void copy(const wgpu::Device &device, const wgpu::Queue &queue,
+            const Request &request) {
+    if (!request.frame || request.frame->handle().handle == nullptr) {
+      throw std::runtime_error(
+          "copyExternalImageToTexture: the NativeVideoFrame was released");
+    }
+    if (!request.texture) {
+      throw std::runtime_error(
+          "copyExternalImageToTexture: destination.texture is required");
+    }
+    if (!(request.texture.GetUsage() & wgpu::TextureUsage::RenderAttachment)) {
+      throw std::runtime_error(
+          "copyExternalImageToTexture: a native frame is rendered into the "
+          "destination, which needs GPUTextureUsage.RENDER_ATTACHMENT");
+    }
+    const wgpu::TextureFormat format = request.texture.GetFormat();
+    if (!isSupportedDestination(format)) {
+      throw std::runtime_error(
+          "copyExternalImageToTexture: a native frame can only be copied "
+          "into an rgba8unorm, bgra8unorm (or -srgb), rgba16float or "
+          "rgb10a2unorm texture");
+    }
+    if (request.mipLevel >= request.texture.GetMipLevelCount()) {
+      throw std::runtime_error(
+          "copyExternalImageToTexture: destination.mipLevel is out of range");
+    }
+    const uint32_t mipWidth =
+        std::max(1u, request.texture.GetWidth() >> request.mipLevel);
+    const uint32_t mipHeight =
+        std::max(1u, request.texture.GetHeight() >> request.mipLevel);
+    if (request.width == 0 || request.height == 0) {
+      return;
+    }
+    if (request.dstX > mipWidth || request.width > mipWidth - request.dstX ||
+        request.dstY > mipHeight || request.height > mipHeight - request.dstY) {
+      throw std::runtime_error(
+          "copyExternalImageToTexture: the destination region is outside "
+          "the texture");
+    }
+
+    // The frame as the shader sees it: Dawn swaps the apparent size of a
+    // frame rotated by 90 or 270 degrees.
+    const auto &handle = request.frame->handle();
+    const int quadrant = static_cast<int>(request.rotation / 90.0) & 3;
+    const bool swapped = quadrant == 1 || quadrant == 3;
+    const uint32_t frameWidth = swapped ? handle.height : handle.width;
+    const uint32_t frameHeight = swapped ? handle.width : handle.height;
+    if (request.originX > frameWidth ||
+        request.width > frameWidth - request.originX ||
+        request.originY > frameHeight ||
+        request.height > frameHeight - request.originY) {
+      throw std::runtime_error(
+          "copyExternalImageToTexture: the source region is outside the "
+          "frame");
+    }
+
+    // Importing the frame begins the access to its surface; destroy() ends
+    // it once the commands that sample it are submitted.
+    auto descriptor = std::make_shared<GPUExternalTextureDescriptor>();
+    descriptor->source = request.frame;
+    descriptor->label = "copyExternalImageToTexture";
+    descriptor->rotation = request.rotation;
+    descriptor->mirrored = request.mirrored;
+    auto external = GPUExternalTexture::Create(device, descriptor);
+
+    const Resources &resources = resourcesFor(device, format);
+
+    // uv = position01 * uvScale + uvOffset, with position01 running from the
+    // top-left corner of the copy region; flipY reads the rows bottom-up.
+    const float scaleX =
+        static_cast<float>(request.width) / static_cast<float>(frameWidth);
+    const float scaleY =
+        static_cast<float>(request.height) / static_cast<float>(frameHeight);
+    const float offsetX =
+        static_cast<float>(request.originX) / static_cast<float>(frameWidth);
+    const float offsetY =
+        static_cast<float>(request.originY) / static_cast<float>(frameHeight);
+    std::array<float, 20> uniforms = {};
+    const std::vector<double> matrix = external->getYuvToRgbMatrix();
+    for (size_t i = 0; i < 12 && i < matrix.size(); i++) {
+      uniforms[i] = static_cast<float>(matrix[i]);
+    }
+    uniforms[12] = scaleX;
+    uniforms[13] = request.flipY ? -scaleY : scaleY;
+    uniforms[14] = offsetX;
+    uniforms[15] = request.flipY ? offsetY + scaleY : offsetY;
+    const uint32_t decodeSrgb = isSrgb(format) ? 1u : 0u;
+    std::memcpy(&uniforms[16], &decodeSrgb, sizeof(decodeSrgb));
+
+    wgpu::BufferDescriptor bufferDesc = {};
+    bufferDesc.label = "copyExternalImageToTexture uniforms";
+    bufferDesc.size = sizeof(uniforms);
+    bufferDesc.usage = wgpu::BufferUsage::Uniform;
+    bufferDesc.mappedAtCreation = true;
+    wgpu::Buffer uniformBuffer = device.CreateBuffer(&bufferDesc);
+    std::memcpy(uniformBuffer.GetMappedRange(), uniforms.data(),
+                sizeof(uniforms));
+    uniformBuffer.Unmap();
+
+    wgpu::ExternalTextureBindingEntry externalEntry = {};
+    externalEntry.externalTexture = external->get();
+    std::array<wgpu::BindGroupEntry, 3> entries = {};
+    entries[0].binding = 0;
+    entries[0].nextInChain = &externalEntry;
+    entries[1].binding = 1;
+    entries[1].sampler = resources.sampler;
+    entries[2].binding = 2;
+    entries[2].buffer = uniformBuffer;
+    entries[2].size = sizeof(uniforms);
+    wgpu::BindGroupDescriptor bindGroupDesc = {};
+    bindGroupDesc.layout = resources.bindGroupLayout;
+    bindGroupDesc.entryCount = entries.size();
+    bindGroupDesc.entries = entries.data();
+    wgpu::BindGroup bindGroup = device.CreateBindGroup(&bindGroupDesc);
+
+    wgpu::TextureViewDescriptor viewDesc = {};
+    viewDesc.baseMipLevel = request.mipLevel;
+    viewDesc.mipLevelCount = 1;
+    viewDesc.baseArrayLayer = 0;
+    viewDesc.arrayLayerCount = 1;
+    viewDesc.dimension = wgpu::TextureViewDimension::e2D;
+    wgpu::TextureView target = request.texture.CreateView(&viewDesc);
+
+    // The rest of the texture is left untouched: the pass loads the existing
+    // contents and the viewport and scissor confine the draw to the region.
+    wgpu::RenderPassColorAttachment attachment = {};
+    attachment.view = target;
+    attachment.loadOp = wgpu::LoadOp::Load;
+    attachment.storeOp = wgpu::StoreOp::Store;
+    wgpu::RenderPassDescriptor passDesc = {};
+    passDesc.label = "copyExternalImageToTexture";
+    passDesc.colorAttachmentCount = 1;
+    passDesc.colorAttachments = &attachment;
+
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+    wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&passDesc);
+    pass.SetPipeline(resources.pipeline);
+    pass.SetBindGroup(0, bindGroup);
+    pass.SetViewport(static_cast<float>(request.dstX),
+                     static_cast<float>(request.dstY),
+                     static_cast<float>(request.width),
+                     static_cast<float>(request.height), 0.0f, 1.0f);
+    pass.SetScissorRect(request.dstX, request.dstY, request.width,
+                        request.height);
+    pass.Draw(3);
+    pass.End();
+    wgpu::CommandBuffer commands = encoder.Finish();
+    queue.Submit(1, &commands);
+    external->destroy();
+  }
+
+private:
+  struct Resources {
+    wgpu::BindGroupLayout bindGroupLayout;
+    wgpu::Sampler sampler;
+    wgpu::RenderPipeline pipeline;
+  };
+
+  static bool isSrgb(wgpu::TextureFormat format) {
+    return format == wgpu::TextureFormat::RGBA8UnormSrgb ||
+           format == wgpu::TextureFormat::BGRA8UnormSrgb;
+  }
+
+  static bool isSupportedDestination(wgpu::TextureFormat format) {
+    switch (format) {
+    case wgpu::TextureFormat::RGBA8Unorm:
+    case wgpu::TextureFormat::RGBA8UnormSrgb:
+    case wgpu::TextureFormat::BGRA8Unorm:
+    case wgpu::TextureFormat::BGRA8UnormSrgb:
+    case wgpu::TextureFormat::RGBA16Float:
+    case wgpu::TextureFormat::RGB10A2Unorm:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  static constexpr const char *kShader = R"(
+struct Uniforms {
+  // The rows of the 3x4 matrix mapping the sampled texel to R'G'B'
+  // (GPUExternalTexture.yuvToRgbMatrix; the identity outside Android YUV).
+  yuvToRgb0: vec4f,
+  yuvToRgb1: vec4f,
+  yuvToRgb2: vec4f,
+  // uv = position01 * uvScale + uvOffset
+  uvScale: vec2f,
+  uvOffset: vec2f,
+  // x: decode sRGB to linear, for an sRGB destination that re-encodes on write
+  flags: vec4u,
+};
+
+@group(0) @binding(0) var frame: texture_external;
+@group(0) @binding(1) var frameSampler: sampler;
+@group(0) @binding(2) var<uniform> u: Uniforms;
+
+struct VsOut {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+};
+
+@vertex fn vs(@builtin(vertex_index) index: u32) -> VsOut {
+  // A triangle covering the viewport; position01 runs from its top-left
+  // corner, like image coordinates.
+  var corners = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0));
+  let corner = corners[index];
+  var out: VsOut;
+  out.position = vec4f(corner, 0.0, 1.0);
+  let position01 = vec2f(corner.x * 0.5 + 0.5, 0.5 - corner.y * 0.5);
+  out.uv = position01 * u.uvScale + u.uvOffset;
+  return out;
+}
+
+fn srgbToLinear(c: vec3f) -> vec3f {
+  let low = c / 12.92;
+  let high = pow((c + 0.055) / 1.055, vec3f(2.4));
+  return select(high, low, c <= vec3f(0.04045));
+}
+
+@fragment fn fs(in: VsOut) -> @location(0) vec4f {
+  let sampled = textureSampleBaseClampToEdge(frame, frameSampler, in.uv);
+  let texel = vec4f(sampled.rgb, 1.0);
+  var rgb = vec3f(dot(u.yuvToRgb0, texel), dot(u.yuvToRgb1, texel), dot(u.yuvToRgb2, texel));
+  rgb = clamp(rgb, vec3f(0.0), vec3f(1.0));
+  if (u.flags.x == 1u) {
+    rgb = srgbToLinear(rgb);
+  }
+  return vec4f(rgb, 1.0);
+}
+)";
+
+  const Resources &resourcesFor(const wgpu::Device &device,
+                                wgpu::TextureFormat format) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    auto found = _resources.find(static_cast<WGPUTextureFormat>(format));
+    if (found != _resources.end()) {
+      return found->second;
+    }
+    if (!_module) {
+      wgpu::ShaderSourceWGSL wgsl = {};
+      wgsl.code = kShader;
+      wgpu::ShaderModuleDescriptor moduleDesc = {};
+      moduleDesc.label = "copyExternalImageToTexture";
+      moduleDesc.nextInChain = &wgsl;
+      _module = device.CreateShaderModule(&moduleDesc);
+
+      wgpu::ExternalTextureBindingLayout externalLayout = {};
+      std::array<wgpu::BindGroupLayoutEntry, 3> entries = {};
+      entries[0].binding = 0;
+      entries[0].visibility = wgpu::ShaderStage::Fragment;
+      entries[0].nextInChain = &externalLayout;
+      entries[1].binding = 1;
+      entries[1].visibility = wgpu::ShaderStage::Fragment;
+      entries[1].sampler.type = wgpu::SamplerBindingType::Filtering;
+      entries[2].binding = 2;
+      entries[2].visibility =
+          wgpu::ShaderStage::Vertex | wgpu::ShaderStage::Fragment;
+      entries[2].buffer.type = wgpu::BufferBindingType::Uniform;
+      wgpu::BindGroupLayoutDescriptor layoutDesc = {};
+      layoutDesc.label = "copyExternalImageToTexture";
+      layoutDesc.entryCount = entries.size();
+      layoutDesc.entries = entries.data();
+      _bindGroupLayout = device.CreateBindGroupLayout(&layoutDesc);
+
+      wgpu::PipelineLayoutDescriptor pipelineLayoutDesc = {};
+      pipelineLayoutDesc.bindGroupLayoutCount = 1;
+      pipelineLayoutDesc.bindGroupLayouts = &_bindGroupLayout;
+      _pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDesc);
+
+      wgpu::SamplerDescriptor samplerDesc = {};
+      samplerDesc.magFilter = wgpu::FilterMode::Linear;
+      samplerDesc.minFilter = wgpu::FilterMode::Linear;
+      _sampler = device.CreateSampler(&samplerDesc);
+    }
+
+    wgpu::ColorTargetState target = {};
+    target.format = format;
+    wgpu::FragmentState fragment = {};
+    fragment.module = _module;
+    fragment.entryPoint = "fs";
+    fragment.targetCount = 1;
+    fragment.targets = &target;
+    wgpu::RenderPipelineDescriptor pipelineDesc = {};
+    pipelineDesc.label = "copyExternalImageToTexture";
+    pipelineDesc.layout = _pipelineLayout;
+    pipelineDesc.vertex.module = _module;
+    pipelineDesc.vertex.entryPoint = "vs";
+    pipelineDesc.fragment = &fragment;
+    pipelineDesc.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
+
+    Resources resources;
+    resources.bindGroupLayout = _bindGroupLayout;
+    resources.sampler = _sampler;
+    resources.pipeline = device.CreateRenderPipeline(&pipelineDesc);
+    auto inserted = _resources.emplace(static_cast<WGPUTextureFormat>(format),
+                                       std::move(resources));
+    return inserted.first->second;
+  }
+
+  std::mutex _mutex;
+  wgpu::ShaderModule _module;
+  wgpu::BindGroupLayout _bindGroupLayout;
+  wgpu::PipelineLayout _pipelineLayout;
+  wgpu::Sampler _sampler;
+  std::unordered_map<WGPUTextureFormat, Resources> _resources;
+};
+
+} // namespace rnwgpu