react-native-webgpu 0.14.1 → 0.15.0

package/android/src/main/java/com/webgpu/WebGPUModule.java

@@ -1,6 +1,8 @@
 package com.webgpu;
 
 import android.graphics.Bitmap;
+import android.hardware.HardwareBuffer;
+import android.os.Build;
 import android.util.Log;
 import android.view.View;
 
@@ -57,9 +59,12 @@ public class WebGPUModule extends NativeWebGPUModuleSpec {
    * Called from C++ (AndroidPlatformContext::snapshotView) on an arbitrary
    * thread for GPUQueue.drawElementImageToTexture. Hops to the UI thread,
    * resolves the view for {@code tag}, rasterizes the requested rectangle and
-   * always reports back through {@link #onViewSnapshot}, with either a bitmap
-   * or an error message. {@code callback} is an opaque native pointer that
-   * must be handed back exactly once.
+   * always reports back exactly once: through {@link #onViewSnapshotBuffer}
+   * with the buffer the hardware renderer drew into, when the caller allows
+   * it and the platform can tell when the drawing is done (API 33), or else
+   * through {@link #onViewSnapshot} with a bitmap or an error message.
+   * {@code callback} is an opaque native pointer that must be handed back
+   * exactly once.
    *
    * The source rectangle is in density-independent points (React Native
    * layout units) and is converted to pixels here; a non-positive
@@ -75,11 +80,15 @@ public class WebGPUModule extends NativeWebGPUModuleSpec {
       final double sourceHeight,
       final int width,
       final int height,
+      final boolean allowHardwareBuffer,
       final long callback) {
     UiThreadUtil.runOnUiThread(
         () -> {
           Bitmap bitmap = null;
           String error = null;
+          // Set once the callback was handed to onViewSnapshotBuffer; nothing
+          // may report again after that.
+          final boolean[] handedOver = {false};
           try {
             ReactApplicationContext context = getReactApplicationContext();
             UIManager uiManager = UIManagerHelper.getUIManagerForReactTag(context, tag);
@@ -105,17 +114,72 @@ public class WebGPUModule extends NativeWebGPUModuleSpec {
               throw new IllegalArgumentException(
                   "drawElementImageToTexture: the source rectangle is empty");
             }
-            bitmap = ViewSnapshot.snapshot(view, sx, sy, sw, sh, w, h);
+            // The zero-copy path: the renderer's buffer goes to the GPU with
+            // the fence that says when the drawing is done. The fence is
+            // exposed from API 33; before that, and when the hardware render
+            // fails, the pixels are read back into a bitmap as usual.
+            if (allowHardwareBuffer
+                && Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
+                && view.isHardwareAccelerated()) {
+              try {
+                ViewSnapshot.renderHardware(
+                    view,
+                    sx,
+                    sy,
+                    sw,
+                    sh,
+                    w,
+                    h,
+                    image -> {
+                      HardwareBuffer buffer = image.getHardwareBuffer();
+                      if (buffer == null) {
+                        throw new IllegalStateException(
+                            "HardwareRenderer image has no HardwareBuffer");
+                      }
+                      int fenceFd = SyncFences.acquireFenceFd(image);
+                      // Native acquires its own reference to the buffer and
+                      // adopts the fence descriptor.
+                      handedOver[0] = true;
+                      onViewSnapshotBuffer(callback, buffer, fenceFd);
+                      buffer.close();
+                      return null;
+                    });
+              } catch (Throwable t) {
+                if (handedOver[0]) {
+                  throw t;
+                }
+                Log.w(NAME, "HardwareRenderer snapshot failed, reading the pixels back instead", t);
+              }
+            }
+            if (!handedOver[0]) {
+              bitmap = ViewSnapshot.snapshot(view, sx, sy, sw, sh, w, h);
+            }
           } catch (Throwable t) {
+            if (handedOver[0]) {
+              // The result is already on its way; only the cleanup failed.
+              Log.w(NAME, "drawElementImageToTexture: cleanup after the snapshot failed", t);
+              return;
+            }
             error = t.getMessage() != null ? t.getMessage() : t.toString();
           }
-          onViewSnapshot(callback, bitmap, error);
+          if (!handedOver[0]) {
+            onViewSnapshot(callback, bitmap, error);
+          }
         });
   }
 
   @DoNotStrip
   private native void onViewSnapshot(long callback, Bitmap bitmap, String error);
 
+  /**
+   * The zero-copy completion of {@link #snapshotView}: the buffer the hardware
+   * renderer drew the view into and the fence that signals when the drawing
+   * is done (a sync file descriptor native takes ownership of, -1 for none).
+   * Native acquires its own reference to the buffer before returning.
+   */
+  @DoNotStrip
+  private native void onViewSnapshotBuffer(long callback, HardwareBuffer buffer, int fenceFd);
+
   /**
    * Called from C++ (AndroidPlatformContext::createVideoPlayer) for
    * RNWebGPU.createVideoPlayer. Throws when the source cannot be opened; the

package/android/src/main/java/com/webgpu/WebGPUVideoPlayer.java

@@ -61,6 +61,23 @@ public class WebGPUVideoPlayer {
   private volatile int rotation = 0;
   private volatile double frameRate = 0;
   private volatile double durationSeconds = 0;
+  // The color space of the video track as the container declares it, packed
+  // like a data space (see dataSpaceFromContainer); 0 when it says nothing.
+  private volatile int containerDataSpace = 0;
+
+  // The layout of android.hardware.DataSpace (API 33), which is also the
+  // ADataSpace of the NDK: standard << 16, transfer << 22, range << 27. Spelled
+  // out so that the mapping compiles and runs on every supported API level.
+  private static final int DATASPACE_STANDARD_BT709 = 1 << 16;
+  private static final int DATASPACE_STANDARD_BT601_625 = 2 << 16;
+  private static final int DATASPACE_STANDARD_BT601_525 = 4 << 16;
+  private static final int DATASPACE_STANDARD_BT2020 = 6 << 16;
+  private static final int DATASPACE_TRANSFER_LINEAR = 1 << 22;
+  private static final int DATASPACE_TRANSFER_SMPTE_170M = 3 << 22;
+  private static final int DATASPACE_TRANSFER_ST2084 = 7 << 22;
+  private static final int DATASPACE_TRANSFER_HLG = 8 << 22;
+  private static final int DATASPACE_RANGE_FULL = 1 << 27;
+  private static final int DATASPACE_RANGE_LIMITED = 2 << 27;
 
   WebGPUVideoPlayer(Context context, String source) {
     Uri uri = parseSource(source);
@@ -160,6 +177,17 @@ public class WebGPUVideoPlayer {
                     if (format.containsKey(MediaFormat.KEY_FRAME_RATE)) {
                       frameRate = format.getInteger(MediaFormat.KEY_FRAME_RATE);
                     }
+                    containerDataSpace =
+                        dataSpaceFromContainer(
+                            format.containsKey(MediaFormat.KEY_COLOR_STANDARD)
+                                ? format.getInteger(MediaFormat.KEY_COLOR_STANDARD)
+                                : 0,
+                            format.containsKey(MediaFormat.KEY_COLOR_TRANSFER)
+                                ? format.getInteger(MediaFormat.KEY_COLOR_TRANSFER)
+                                : 0,
+                            format.containsKey(MediaFormat.KEY_COLOR_RANGE)
+                                ? format.getInteger(MediaFormat.KEY_COLOR_RANGE)
+                                : 0);
                     break;
                   }
                 }
@@ -185,6 +213,77 @@ public class WebGPUVideoPlayer {
     }
   }
 
+  // The MediaFormat color keys of the video track (KEY_COLOR_STANDARD,
+  // KEY_COLOR_TRANSFER, KEY_COLOR_RANGE; 0 when absent) packed like a data
+  // space, so that the native side reads one representation whatever its
+  // source.
+  private static int dataSpaceFromContainer(int standard, int transfer, int range) {
+    int dataSpace = 0;
+    switch (standard) {
+      case MediaFormat.COLOR_STANDARD_BT709:
+        dataSpace |= DATASPACE_STANDARD_BT709;
+        break;
+      case MediaFormat.COLOR_STANDARD_BT601_PAL:
+        dataSpace |= DATASPACE_STANDARD_BT601_625;
+        break;
+      case MediaFormat.COLOR_STANDARD_BT601_NTSC:
+        dataSpace |= DATASPACE_STANDARD_BT601_525;
+        break;
+      case MediaFormat.COLOR_STANDARD_BT2020:
+        dataSpace |= DATASPACE_STANDARD_BT2020;
+        break;
+      default:
+        break;
+    }
+    switch (transfer) {
+      case MediaFormat.COLOR_TRANSFER_LINEAR:
+        dataSpace |= DATASPACE_TRANSFER_LINEAR;
+        break;
+      case MediaFormat.COLOR_TRANSFER_SDR_VIDEO:
+        dataSpace |= DATASPACE_TRANSFER_SMPTE_170M;
+        break;
+      case MediaFormat.COLOR_TRANSFER_ST2084:
+        dataSpace |= DATASPACE_TRANSFER_ST2084;
+        break;
+      case MediaFormat.COLOR_TRANSFER_HLG:
+        dataSpace |= DATASPACE_TRANSFER_HLG;
+        break;
+      default:
+        break;
+    }
+    switch (range) {
+      case MediaFormat.COLOR_RANGE_FULL:
+        dataSpace |= DATASPACE_RANGE_FULL;
+        break;
+      case MediaFormat.COLOR_RANGE_LIMITED:
+        dataSpace |= DATASPACE_RANGE_LIMITED;
+        break;
+      default:
+        break;
+    }
+    return dataSpace;
+  }
+
+  /**
+   * The color space of a frame returned by {@link #copyLatestFrame}, as a data space (the
+   * packing of {@code android.hardware.DataSpace}): the one the decoder stamps on the frame
+   * (API 33), or what the container declares for the video track. 0 when neither says anything.
+   */
+  @DoNotStrip
+  public int frameDataSpace(Image image) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      try {
+        int dataSpace = image.getDataSpace();
+        if (dataSpace != 0) {
+          return dataSpace;
+        }
+      } catch (IllegalStateException e) {
+        // The frame was closed under us; fall back to the container.
+      }
+    }
+    return containerDataSpace;
+  }
+
   // The decoder reports the frame size (possibly more than once for adaptive
   // streams); the ImageReader that receives the frames is sized accordingly.
   private void onVideoSizeChanged(int w, int h) {
@@ -273,6 +372,16 @@ public class WebGPUVideoPlayer {
     return image;
   }
 
+  /**
+   * The acquire fence of a frame returned by {@link #copyLatestFrame}, as a sync file descriptor
+   * the caller owns, or -1 when there is none. The decoder may still be writing the frame when it
+   * is acquired; the GPU work that samples it has to wait on this fence (see {@link SyncFences}).
+   */
+  @DoNotStrip
+  public static int acquireFenceFd(Image image) {
+    return SyncFences.acquireFenceFd(image);
+  }
+
   /** Hands the buffer of a frame returned by {@link #copyLatestFrame} back to the decoder. */
   @DoNotStrip
   public void closeImage(Image image) {

package/apple/ApplePlatformContext.h

@@ -17,7 +17,8 @@ public:
   ~ApplePlatformContext() = default;
 
   void snapshotView(const ViewSnapshotRequest &request,
-                    std::function<void(ImageData)> onSuccess,
+                    std::function<void(ImageData)> onPixels,
+                    std::function<void(VideoFrameHandle)> onFrame,
                     std::function<void(std::string)> onError) override;
 
   ImageData createImageBitmap(std::string blobId, double offset,
@@ -36,12 +37,11 @@ public:
 
   VideoFrameHandle loadVideoFrame(const std::string &path) override;
 
-  VideoFrameHandle createTestVideoFrame(uint32_t width,
-                                        uint32_t height) override;
+  VideoFrameHandle createTestVideoFrame(uint32_t width, uint32_t height,
+                                        VideoPixelFormat format) override;
 
   std::unique_ptr<IVideoPlayer>
-  createVideoPlayer(const std::string &path,
-                    VideoPixelFormat format) override;
+  createVideoPlayer(const std::string &path, VideoPixelFormat format) override;
 
   std::string writeTestVideoFile() override;
 

package/apple/ApplePlatformContext.mm

@@ -189,9 +189,12 @@ ImageData snapshotViewOnMainThread(const ApplePlatformContext::ViewLookup &looku
 
 } // namespace
 
+// Always delivers pixels: the view is drawn into a CPU bitmap, so there is no
+// GPU frame to hand over (onFrame is unused).
 void ApplePlatformContext::snapshotView(
     const ViewSnapshotRequest &request,
-    std::function<void(ImageData)> onSuccess,
+    std::function<void(ImageData)> onPixels,
+    std::function<void(VideoFrameHandle)> /* onFrame */,
     std::function<void(std::string)> onError) {
   // Copies: the block outlives this call.
   ViewLookup lookup = _viewLookup;
@@ -199,7 +202,7 @@ void ApplePlatformContext::snapshotView(
   dispatch_async(dispatch_get_main_queue(), ^{
     @autoreleasepool {
       try {
-        onSuccess(snapshotViewOnMainThread(lookup, snapshotRequest));
+        onPixels(snapshotViewOnMainThread(lookup, snapshotRequest));
       } catch (const std::exception &error) {
         onError(error.what());
       } catch (...) {
@@ -414,8 +417,77 @@ VideoFrameHandle ApplePlatformContext::wrapNativeBuffer(void *pointer) {
   return wrapCVPixelBuffer(static_cast<CVPixelBufferRef>(pointer));
 }
 
+// The NV12 variant of createTestVideoFrame: a biplanar BT.709 limited-range
+// frame, red on the left half and green on the right, whose attachments
+// declare its color space the way the decoder's frames do, so that the
+// conversion of importExternalTexture is fully determined.
+static VideoFrameHandle createTestYuvFrame(uint32_t width, uint32_t height) {
+  NSDictionary *attrs = @{
+    (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
+    (NSString *)kCVPixelBufferMetalCompatibilityKey : @YES,
+  };
+  CVPixelBufferRef pixelBuffer = NULL;
+  CVReturn err =
+      CVPixelBufferCreate(kCFAllocatorDefault, width, height,
+                          kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange,
+                          (__bridge CFDictionaryRef)attrs, &pixelBuffer);
+  if (err != kCVReturnSuccess || !pixelBuffer) {
+    throw std::runtime_error("createTestVideoFrame: unsupported: "
+                             "CVPixelBufferCreate failed for a biplanar "
+                             "YUV buffer");
+  }
+  CVBufferSetAttachment(pixelBuffer, kCVImageBufferYCbCrMatrixKey,
+                        kCVImageBufferYCbCrMatrix_ITU_R_709_2,
+                        kCVAttachmentMode_ShouldPropagate);
+  CVBufferSetAttachment(pixelBuffer, kCVImageBufferColorPrimariesKey,
+                        kCVImageBufferColorPrimaries_ITU_R_709_2,
+                        kCVAttachmentMode_ShouldPropagate);
+  CVBufferSetAttachment(pixelBuffer, kCVImageBufferTransferFunctionKey,
+                        kCVImageBufferTransferFunction_ITU_R_709_2,
+                        kCVAttachmentMode_ShouldPropagate);
+
+  CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+  uint8_t *luma = static_cast<uint8_t *>(
+      CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0));
+  size_t lumaRowBytes = CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 0);
+  for (uint32_t y = 0; y < height; ++y) {
+    uint8_t *row = luma + y * lumaRowBytes;
+    for (uint32_t x = 0; x < width; ++x) {
+      row[x] = x < width / 2 ? test_yuv_frame::kRedY : test_yuv_frame::kGreenY;
+    }
+  }
+  // The chroma plane is subsampled by two on both axes and interleaves Cb, Cr.
+  uint8_t *chroma = static_cast<uint8_t *>(
+      CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 1));
+  size_t chromaRowBytes = CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 1);
+  size_t chromaWidth = CVPixelBufferGetWidthOfPlane(pixelBuffer, 1);
+  size_t chromaHeight = CVPixelBufferGetHeightOfPlane(pixelBuffer, 1);
+  for (size_t y = 0; y < chromaHeight; ++y) {
+    uint8_t *row = chroma + y * chromaRowBytes;
+    for (size_t x = 0; x < chromaWidth; ++x) {
+      bool red = x < chromaWidth / 2;
+      row[x * 2 + 0] = red ? test_yuv_frame::kRedCb : test_yuv_frame::kGreenCb;
+      row[x * 2 + 1] = red ? test_yuv_frame::kRedCr : test_yuv_frame::kGreenCr;
+    }
+  }
+  CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+
+  try {
+    auto handle = wrapCVPixelBuffer(pixelBuffer);
+    CFRelease(pixelBuffer); // wrapCVPixelBuffer retained its own reference
+    return handle;
+  } catch (...) {
+    CFRelease(pixelBuffer);
+    throw;
+  }
+}
+
 VideoFrameHandle
-ApplePlatformContext::createTestVideoFrame(uint32_t width, uint32_t height) {
+ApplePlatformContext::createTestVideoFrame(uint32_t width, uint32_t height,
+                                           VideoPixelFormat format) {
+  if (format == VideoPixelFormat::NV12) {
+    return createTestYuvFrame(width, height);
+  }
   NSDictionary *attrs = @{
     (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
     (NSString *)kCVPixelBufferMetalCompatibilityKey : @YES,

package/apple/AppleVideoPlayer.mm

@@ -12,47 +12,80 @@ namespace rnwgpu {
 
 namespace {
 
-// 3x4 row-major matrices mapping [Y, Cb, Cr, 1] to gamma-encoded R'G'B' (NOT
-// linear): YCbCr is derived from gamma-encoded RGB, so this conversion stays in
-// the encoded domain. The sRGB decode in srcTransferFunctionParameters
-// linearizes afterward (see GPUExternalTexture.cpp). Limited-range (video
-// range) means luma is 16..235, chroma is 16..240 (8-bit).
-// Reference: https://en.wikipedia.org/wiki/YCbCr (BT.601 / BT.709).
-static constexpr float kBT709LimitedToRgb[12] = {
-    1.164383f, 0.000000f,  1.792741f,  -0.972945f, //
-    1.164383f, -0.213249f, -0.532909f, 0.301517f,  //
-    1.164383f, 2.112402f,  0.000000f,  -1.133402f, //
-};
-static constexpr float kBT601LimitedToRgb[12] = {
-    1.164383f, 0.000000f,  1.596027f,  -0.874202f, //
-    1.164383f, -0.391762f, -0.812968f, 0.531668f,  //
-    1.164383f, 2.017232f,  0.000000f,  -1.085631f, //
-};
-static constexpr float kBT2020LimitedToRgb[12] = {
-    1.164383f, 0.000000f,  1.678674f,  -0.915688f, //
-    1.164383f, -0.187326f, -0.650424f, 0.347459f,  //
-    1.164383f, 2.141772f,  0.000000f,  -1.148145f, //
-};
+// The string attachment of a pixel buffer, or null when absent or not a string.
+static CFStringRef stringAttachment(CVPixelBufferRef pixelBuffer,
+                                    CFStringRef key) {
+  CFTypeRef value = CVBufferGetAttachment(pixelBuffer, key, nullptr);
+  if (value == nullptr || CFGetTypeID(value) != CFStringGetTypeID()) {
+    return nullptr;
+  }
+  return static_cast<CFStringRef>(value);
+}
 
-// Pick the right YUV→RGB matrix from the pixel buffer's color attachments.
-// Falls back to BT.709 limited range (the right call for ≥720p H.264, which
-// is what AVPlayer hands us for Big Buck Bunny and most streamed media).
-static void fillYuvMatrix(CVPixelBufferRef pixelBuffer, float out[12]) {
-  CFTypeRef matrixKey =
-      CVBufferGetAttachment(pixelBuffer, kCVImageBufferYCbCrMatrixKey, nullptr);
-  const float *src = kBT709LimitedToRgb;
-  if (matrixKey) {
-    auto matrix = (CFStringRef)matrixKey;
+// The color space of a YUV pixel buffer, from its attachments: the YCbCr matrix
+// (kCVImageBufferYCbCrMatrixKey), the range (the full-range pixel formats),
+// the primaries and the transfer function. What the buffer does not declare
+// stays unset and resolves at import time to BT.709 limited range, the norm
+// for HD video (GPUExternalTexture.cpp).
+static VideoFrameColorSpace
+colorSpaceFromCVPixelBuffer(CVPixelBufferRef pixelBuffer) {
+  VideoFrameColorSpace colorSpace;
+  if (CFStringRef matrix =
+          stringAttachment(pixelBuffer, kCVImageBufferYCbCrMatrixKey)) {
     if (CFEqual(matrix, kCVImageBufferYCbCrMatrix_ITU_R_601_4) ||
         CFEqual(matrix, kCVImageBufferYCbCrMatrix_SMPTE_240M_1995)) {
-      src = kBT601LimitedToRgb;
+      colorSpace.matrix = wgpu::ColorSpaceYCbCrMatrixDawn::Rec601;
+    } else if (CFEqual(matrix, kCVImageBufferYCbCrMatrix_ITU_R_709_2)) {
+      colorSpace.matrix = wgpu::ColorSpaceYCbCrMatrixDawn::Rec709;
     } else if (CFEqual(matrix, kCVImageBufferYCbCrMatrix_ITU_R_2020)) {
-      src = kBT2020LimitedToRgb;
+      colorSpace.matrix = wgpu::ColorSpaceYCbCrMatrixDawn::Rec2020;
+    }
+  }
+  switch (CVPixelBufferGetPixelFormatType(pixelBuffer)) {
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+    colorSpace.range = wgpu::ColorSpaceYCbCrRangeDawn::Full;
+    break;
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+    colorSpace.range = wgpu::ColorSpaceYCbCrRangeDawn::Narrow;
+    break;
+  default:
+    break;
+  }
+  if (CFStringRef primaries =
+          stringAttachment(pixelBuffer, kCVImageBufferColorPrimariesKey)) {
+    if (CFEqual(primaries, kCVImageBufferColorPrimaries_ITU_R_709_2)) {
+      // BT.709 shares the sRGB primaries (Dawn's helper only knows them under
+      // that name).
+      colorSpace.primaries = wgpu::ColorSpacePrimariesDawn::SRGB;
+    } else if (CFEqual(primaries, kCVImageBufferColorPrimaries_EBU_3213) ||
+               CFEqual(primaries, kCVImageBufferColorPrimaries_SMPTE_C)) {
+      colorSpace.primaries = wgpu::ColorSpacePrimariesDawn::Rec601;
+    } else if (CFEqual(primaries, kCVImageBufferColorPrimaries_ITU_R_2020)) {
+      colorSpace.primaries = wgpu::ColorSpacePrimariesDawn::Rec2020;
+    } else if (CFEqual(primaries, kCVImageBufferColorPrimaries_P3_D65)) {
+      colorSpace.primaries = wgpu::ColorSpacePrimariesDawn::DisplayP3;
     }
   }
-  for (int i = 0; i < 12; ++i) {
-    out[i] = src[i];
+  if (CFStringRef transfer =
+          stringAttachment(pixelBuffer, kCVImageBufferTransferFunctionKey)) {
+    if (CFEqual(transfer, kCVImageBufferTransferFunction_ITU_R_709_2) ||
+        CFEqual(transfer, kCVImageBufferTransferFunction_SMPTE_240M_1995) ||
+        CFEqual(transfer, kCVImageBufferTransferFunction_ITU_R_2020)) {
+      // The SDR video OETF; SMPTE 170M is Dawn's name for its inverse.
+      colorSpace.transfer = wgpu::ColorSpaceTransferDawn::SMPTE_170M;
+    } else if (CFEqual(transfer, kCVImageBufferTransferFunction_sRGB)) {
+      colorSpace.transfer = wgpu::ColorSpaceTransferDawn::SRGB;
+    } else if (CFEqual(transfer, kCVImageBufferTransferFunction_Linear)) {
+      colorSpace.transfer = wgpu::ColorSpaceTransferDawn::Identity;
+    } else if (CFEqual(transfer,
+                       kCVImageBufferTransferFunction_SMPTE_ST_2084_PQ)) {
+      colorSpace.transfer = wgpu::ColorSpaceTransferDawn::PQ;
+    } else if (CFEqual(transfer,
+                       kCVImageBufferTransferFunction_ITU_R_2100_HLG)) {
+      colorSpace.transfer = wgpu::ColorSpaceTransferDawn::HLG;
+    }
   }
+  return colorSpace;
 }
 
 // Map a CVPixelBuffer's pixel format to our VideoPixelFormat enum.
@@ -257,7 +290,7 @@ VideoFrameHandle wrapCVPixelBuffer(CVPixelBufferRef pixelBuffer) {
   handle.height = static_cast<uint32_t>(CVPixelBufferGetHeight(pixelBuffer));
   handle.pixelFormat = pixelFormatFromCVPixelBuffer(pixelBuffer);
   if (handle.pixelFormat == VideoPixelFormat::NV12) {
-    fillYuvMatrix(pixelBuffer, handle.yuvToRgbMatrix);
+    handle.colorSpace = colorSpaceFromCVPixelBuffer(pixelBuffer);
   }
   handle.deleter = [pixelBuffer]() { CFRelease(pixelBuffer); };
   return handle;

package/cpp/dawn/common/ExternalTextureParams.h

@@ -0,0 +1,67 @@
+// Copyright 2026 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// DAWN_VENDORED_EXTERNAL_TEXTURE_PARAMS
+//
+// Vendored from Dawn's src/dawn/common/ExternalTextureParams.h, unchanged. The
+// functions it declares are compiled into the Dawn binaries that
+// react-native-webgpu-dawn ships (libwebgpu_dawn.so, libwebgpu_dawn.a), which
+// export them, but the package only ships Dawn's public headers. The copy is
+// pinned to the Dawn commit of the package in scripts/check-dawn.ts: on a Dawn
+// bump, diff it against the new commit's file and re-sync it.
+
+#ifndef SRC_DAWN_COMMON_EXTERNALTEXTUREPARAMS_H_
+#define SRC_DAWN_COMMON_EXTERNALTEXTUREPARAMS_H_
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <array>
+
+namespace dawn {
+
+// Color space parameters that can be passed to an ExternalTexture.
+struct ExternalTextureColorSpaceParams {
+    // Stored row-major to save uniform buffer space. (so one full row after another)
+    // TODO(https://crbug.com/496604550): That's an implementation detail that should not be exposed
+    // in the API, Dawn can transpose internally.
+    std::array<float, 12> yuvToRgbConversionMatrix{};
+    std::array<float, 7> srcTransferFunction = {};
+    std::array<float, 7> dstTransferFunction = {};  // Really the inverse transfer function.
+    // Stored column major to match WGSL. (so one full column after another)
+    std::array<float, 9> gamutConversionMatrix{};
+};
+
+// Helper function to make parameters for an ExternalTextureDescriptor
+wgpu::Status ComputeExternalTextureParams(const wgpu::ColorSpaceDawn& srcColorSpace,
+                                          wgpu::PredefinedColorSpace dstColorSpace,
+                                          ExternalTextureColorSpaceParams* out);
+
+ExternalTextureColorSpaceParams GetNoopColorSpaceParams();
+
+}  // namespace dawn
+
+#endif  // SRC_DAWN_COMMON_EXTERNALTEXTUREPARAMS_H_