react-native-webgpu 0.14.2 → 0.15.1

package/apple/ApplePlatformContext.mm

@@ -42,156 +42,279 @@ ApplePlatformContext::ApplePlatformContext(ViewLookup viewLookup)
 
 namespace {
 
-// Rasterize `request` on the main thread into tightly packed, premultiplied
-// BGRA8 pixels. Throws std::runtime_error with a user-facing message.
-ImageData snapshotViewOnMainThread(const ApplePlatformContext::ViewLookup &lookup,
-                                   const ViewSnapshotRequest &request) {
+// A view that UIKit declined to render (it is not in a window). The pixel
+// path would fail the same way, so there is no point falling back to it.
+struct ViewNotRenderable : std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+// The view, the output size and the rectangle to draw it in, resolved from a
+// request on the main thread. Throws std::runtime_error with a user-facing
+// message.
+struct ResolvedSnapshot {
+  RNWGPlatformView *view = nil;
+  CGRect bounds = CGRectZero;
+  // The source rectangle in points (view space).
+  double sourceX = 0;
+  double sourceY = 0;
+  double sourceWidth = 0;
+  double sourceHeight = 0;
+  // The output size in pixels.
+  uint32_t width = 0;
+  uint32_t height = 0;
+  CGFloat scaleX = 1;
+  CGFloat scaleY = 1;
+  // The view's bounds, scaled and offset so that the source rectangle covers
+  // the whole output, in pixels and with UIKit's top-left origin.
+  CGRect drawRect = CGRectZero;
+};
+
+ResolvedSnapshot resolveSnapshot(const ApplePlatformContext::ViewLookup &lookup,
+                                 const ViewSnapshotRequest &request) {
   if (!lookup) {
     throw std::runtime_error(
         "drawElementImageToTexture: no view registry is available");
   }
-  RNWGPlatformView *view = (__bridge RNWGPlatformView *)lookup(request.viewTag);
-  if (view == nil) {
+  ResolvedSnapshot snapshot;
+  snapshot.view = (__bridge RNWGPlatformView *)lookup(request.viewTag);
+  if (snapshot.view == nil) {
     throw std::runtime_error(
         "drawElementImageToTexture: no native view found for tag " +
         std::to_string(request.viewTag) +
         " (is the view mounted, and rendered with collapsable={false}?)");
   }
-  const CGRect bounds = view.bounds;
+  snapshot.bounds = snapshot.view.bounds;
+  const CGRect bounds = snapshot.bounds;
   if (bounds.size.width <= 0 || bounds.size.height <= 0) {
     throw std::runtime_error(
         "drawElementImageToTexture: the view has no size yet");
   }
 
   // Source rectangle in points (view space); the whole view by default.
-  const double sourceX = request.sourceX;
-  const double sourceY = request.sourceY;
-  const double sourceWidth =
+  snapshot.sourceX = request.sourceX;
+  snapshot.sourceY = request.sourceY;
+  snapshot.sourceWidth =
       request.sourceWidth > 0 ? request.sourceWidth : bounds.size.width;
-  const double sourceHeight =
+  snapshot.sourceHeight =
       request.sourceHeight > 0 ? request.sourceHeight : bounds.size.height;
 
   // Natural pixel size: points times the screen scale the view is shown at.
 #if !TARGET_OS_OSX
-  CGFloat scale = view.window.screen.scale;
+  CGFloat scale = snapshot.view.window.screen.scale;
   if (scale <= 0) {
     scale = UIScreen.mainScreen.scale;
   }
 #else
-  CGFloat scale = view.window.backingScaleFactor;
+  CGFloat scale = snapshot.view.window.backingScaleFactor;
   if (scale <= 0) {
     scale = NSScreen.mainScreen.backingScaleFactor;
   }
 #endif
-  const uint32_t width =
+  snapshot.width =
       request.width > 0
           ? request.width
-          : static_cast<uint32_t>(std::llround(sourceWidth * scale));
-  const uint32_t height =
+          : static_cast<uint32_t>(std::llround(snapshot.sourceWidth * scale));
+  snapshot.height =
       request.height > 0
           ? request.height
-          : static_cast<uint32_t>(std::llround(sourceHeight * scale));
-  if (width == 0 || height == 0) {
+          : static_cast<uint32_t>(std::llround(snapshot.sourceHeight * scale));
+  if (snapshot.width == 0 || snapshot.height == 0) {
     throw std::runtime_error(
         "drawElementImageToTexture: the source rectangle is empty");
   }
 
   // The view's bounds are drawn scaled so that the source rectangle covers
   // the whole output.
-  const CGFloat scaleX = static_cast<CGFloat>(width) / sourceWidth;
-  const CGFloat scaleY = static_cast<CGFloat>(height) / sourceHeight;
-  const CGRect drawRect =
-      CGRectMake(-sourceX * scaleX, -sourceY * scaleY,
-                 bounds.size.width * scaleX, bounds.size.height * scaleY);
+  snapshot.scaleX = static_cast<CGFloat>(snapshot.width) / snapshot.sourceWidth;
+  snapshot.scaleY =
+      static_cast<CGFloat>(snapshot.height) / snapshot.sourceHeight;
+  snapshot.drawRect = CGRectMake(-snapshot.sourceX * snapshot.scaleX,
+                                 -snapshot.sourceY * snapshot.scaleY,
+                                 bounds.size.width * snapshot.scaleX,
+                                 bounds.size.height * snapshot.scaleY);
+  return snapshot;
+}
+
+// A premultiplied BGRA8 Core Graphics context over `pixels`, the layout both
+// snapshot paths produce. Returns NULL when Core Graphics rejects it.
+CGContextRef createBgraContext(void *pixels, uint32_t width, uint32_t height,
+                               size_t bytesPerRow) {
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(
+      pixels, width, height, 8, bytesPerRow, colorSpace,
+      kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little);
+  CGColorSpaceRelease(colorSpace);
+  return context;
+}
 
-  CGImageRef cgImage = NULL;
 #if !TARGET_OS_OSX
-  // drawViewHierarchyInRect renders what is on screen (including Metal /
-  // CAMetalLayer content), which is what "the element as displayed" means.
-  // afterScreenUpdates:YES flushes pending layout and layer changes first, so
-  // a snapshot taken right after a state change reflects that change.
-  UIGraphicsImageRendererFormat *format =
-      [UIGraphicsImageRendererFormat defaultFormat];
-  format.scale = 1.0;
-  format.opaque = NO;
-  format.preferredRange = UIGraphicsImageRendererFormatRangeStandard;
-  UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc]
-      initWithSize:CGSizeMake(width, height)
-            format:format];
-  // drawViewHierarchyInRect returns NO and draws nothing when the view is not
-  // in a window (e.g. a screen pushed under another one). The image would
-  // then be fully transparent, so treat it as a failure instead.
-  __block BOOL drawn = NO;
-  UIImage *image = [renderer
-      imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull context) {
-        drawn = [view drawViewHierarchyInRect:drawRect afterScreenUpdates:YES];
-      }];
+// Draws the view hierarchy through `context`, a bitmap context of exactly
+// `snapshot.width` x `snapshot.height` pixels (Core Graphics orientation; the
+// flip to UIKit's top-left origin is applied here).
+//
+// drawViewHierarchyInRect renders what is on screen (including Metal /
+// CAMetalLayer content), which is what "the element as displayed" means.
+// afterScreenUpdates:YES flushes pending layout and layer changes first, so a
+// snapshot taken right after a state change reflects that change; NO draws
+// the last committed frame and skips that round trip to the render server.
+//
+// drawViewHierarchyInRect returns NO and draws nothing when the view is not
+// in a window (e.g. a screen pushed under another one). The output would then
+// be fully transparent, so that is reported as a failure instead.
+void drawViewHierarchy(const ResolvedSnapshot &snapshot, CGContextRef context,
+                       bool afterScreenUpdates) {
+  CGContextSaveGState(context);
+  CGContextTranslateCTM(context, 0, snapshot.height);
+  CGContextScaleCTM(context, 1, -1);
+  UIGraphicsPushContext(context);
+  const BOOL drawn =
+      [snapshot.view drawViewHierarchyInRect:snapshot.drawRect
+                          afterScreenUpdates:afterScreenUpdates ? YES : NO];
+  UIGraphicsPopContext();
+  CGContextRestoreGState(context);
   if (!drawn) {
-    throw std::runtime_error(
+    throw ViewNotRenderable(
         "drawElementImageToTexture: the view could not be rendered (is it "
         "attached to a window?)");
   }
-  cgImage = image.CGImage;
-  if (cgImage != NULL) {
-    CGImageRetain(cgImage);
-  }
-#else
-  NSBitmapImageRep *rep = [view bitmapImageRepForCachingDisplayInRect:bounds];
-  if (rep != nil) {
-    [view cacheDisplayInRect:bounds toBitmapImageRep:rep];
-    cgImage = rep.CGImage;
-    if (cgImage != NULL) {
-      CGImageRetain(cgImage);
+}
+
+// Releases a pixel buffer when it goes out of scope.
+struct PixelBufferRelease {
+  CVPixelBufferRef buffer;
+  ~PixelBufferRelease() {
+    if (buffer != NULL) {
+      CFRelease(buffer);
     }
   }
-#endif
-  if (cgImage == NULL) {
+};
+
+// The zero-copy path: renders the view into an IOSurface-backed BGRA pixel
+// buffer, which the caller imports as shared texture memory and draws into
+// the destination on the GPU (VideoFrameBlit, which also converts the
+// premultiplied pixels to straight alpha when asked). UIKit rasterizes
+// straight into the surface's memory through a Core Graphics context, so the
+// pixels are never copied or converted on the CPU. Throws on an allocation
+// failure, which the caller answers with the pixel path.
+VideoFrameHandle renderViewIntoSurface(const ResolvedSnapshot &snapshot,
+                                       bool afterScreenUpdates) {
+  NSDictionary *attributes = @{
+    (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
+    (NSString *)kCVPixelBufferMetalCompatibilityKey : @YES,
+  };
+  CVPixelBufferRef pixelBuffer = NULL;
+  const CVReturn created =
+      CVPixelBufferCreate(kCFAllocatorDefault, snapshot.width, snapshot.height,
+                          kCVPixelFormatType_32BGRA,
+                          (__bridge CFDictionaryRef)attributes, &pixelBuffer);
+  if (created != kCVReturnSuccess || pixelBuffer == NULL) {
     throw std::runtime_error(
-        "drawElementImageToTexture: the view could not be rendered");
+        "drawElementImageToTexture: could not allocate an IOSurface for the "
+        "view (CVPixelBufferCreate returned " +
+        std::to_string(created) + ")");
+  }
+  // wrapCVPixelBuffer retains its own reference for the frame.
+  PixelBufferRelease release{pixelBuffer};
+
+  if (CVPixelBufferLockBaseAddress(pixelBuffer, 0) != kCVReturnSuccess) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: could not lock the IOSurface");
+  }
+  CGContextRef context = createBgraContext(
+      CVPixelBufferGetBaseAddress(pixelBuffer), snapshot.width, snapshot.height,
+      CVPixelBufferGetBytesPerRow(pixelBuffer));
+  if (context == NULL) {
+    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+    throw std::runtime_error(
+        "drawElementImageToTexture: could not draw into the IOSurface");
+  }
+  try {
+    // A fresh surface holds whatever was in that memory, and the view may be
+    // transparent.
+    CGContextClearRect(context,
+                       CGRectMake(0, 0, snapshot.width, snapshot.height));
+    drawViewHierarchy(snapshot, context, afterScreenUpdates);
+  } catch (...) {
+    CGContextRelease(context);
+    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+    throw;
   }
+  CGContextRelease(context);
+  // Unlocking publishes the CPU writes to the GPU.
+  CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+  return wrapCVPixelBuffer(pixelBuffer);
+}
+#endif
 
-  // Normalize into premultiplied BGRA8 with no row padding, whatever the
-  // renderer produced.
+// The pixel path: rasterizes the view into tightly packed, premultiplied
+// BGRA8 pixels that the caller uploads with writeTexture.
+ImageData renderViewIntoPixels(const ResolvedSnapshot &snapshot,
+                               bool afterScreenUpdates) {
   ImageData result;
-  result.width = width;
-  result.height = height;
+  result.width = snapshot.width;
+  result.height = snapshot.height;
   result.format = wgpu::TextureFormat::BGRA8Unorm;
   result.premultiplied = true;
-  result.data.assign(static_cast<size_t>(width) * height * 4, 0);
-  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
-  CGContextRef context = CGBitmapContextCreate(
-      result.data.data(), width, height, 8, static_cast<size_t>(width) * 4,
-      colorSpace, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little);
-  CGColorSpaceRelease(colorSpace);
+  // Zeroed: the view may be transparent.
+  result.data.assign(static_cast<size_t>(snapshot.width) * snapshot.height * 4,
+                     0);
+  CGContextRef context =
+      createBgraContext(result.data.data(), snapshot.width, snapshot.height,
+                        static_cast<size_t>(snapshot.width) * 4);
   if (context == NULL) {
-    CGImageRelease(cgImage);
     throw std::runtime_error(
         "drawElementImageToTexture: could not allocate the pixel buffer");
   }
 #if !TARGET_OS_OSX
-  // The renderer already produced exactly width x height pixels.
-  const CGRect imageRect = CGRectMake(0, 0, width, height);
+  // UIKit draws straight into the vector; no intermediate image.
+  try {
+    drawViewHierarchy(snapshot, context, afterScreenUpdates);
+  } catch (...) {
+    CGContextRelease(context);
+    throw;
+  }
 #else
+  (void)afterScreenUpdates;
+  CGImageRef cgImage = NULL;
+  NSBitmapImageRep *rep =
+      [snapshot.view bitmapImageRepForCachingDisplayInRect:snapshot.bounds];
+  if (rep != nil) {
+    [snapshot.view cacheDisplayInRect:snapshot.bounds toBitmapImageRep:rep];
+    cgImage = rep.CGImage;
+    if (cgImage != NULL) {
+      CGImageRetain(cgImage);
+    }
+  }
+  if (cgImage == NULL) {
+    CGContextRelease(context);
+    throw std::runtime_error(
+        "drawElementImageToTexture: the view could not be rendered");
+  }
   // The cached display covers the whole view at the backing scale; draw it so
   // that the source rectangle fills the output. CoreGraphics' origin is the
   // bottom-left corner, hence the flipped vertical offset.
-  const CGRect imageRect = CGRectMake(
-      -sourceX * scaleX,
-      -(bounds.size.height - sourceY - sourceHeight) * scaleY,
-      bounds.size.width * scaleX, bounds.size.height * scaleY);
-#endif
+  const CGRect imageRect =
+      CGRectMake(-snapshot.sourceX * snapshot.scaleX,
+                 -(snapshot.bounds.size.height - snapshot.sourceY -
+                   snapshot.sourceHeight) *
+                     snapshot.scaleY,
+                 snapshot.bounds.size.width * snapshot.scaleX,
+                 snapshot.bounds.size.height * snapshot.scaleY);
   CGContextSetBlendMode(context, kCGBlendModeCopy);
   CGContextDrawImage(context, imageRect, cgImage);
-  CGContextRelease(context);
   CGImageRelease(cgImage);
+#endif
+  CGContextRelease(context);
   return result;
 }
 
 } // namespace
 
+// On iOS a caller that can draw a GPU frame (allowFrame) gets the view
+// rendered into an IOSurface; everything else, and macOS, gets pixels.
 void ApplePlatformContext::snapshotView(
-    const ViewSnapshotRequest &request,
-    std::function<void(ImageData)> onSuccess,
+    const ViewSnapshotRequest &request, 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 +322,29 @@ void ApplePlatformContext::snapshotView(
   dispatch_async(dispatch_get_main_queue(), ^{
     @autoreleasepool {
       try {
-        onSuccess(snapshotViewOnMainThread(lookup, snapshotRequest));
+        const ResolvedSnapshot snapshot =
+            resolveSnapshot(lookup, snapshotRequest);
+#if !TARGET_OS_OSX
+        if (snapshotRequest.allowFrame) {
+          try {
+            onFrame(renderViewIntoSurface(snapshot,
+                                          snapshotRequest.afterScreenUpdates));
+            return;
+          } catch (const ViewNotRenderable &) {
+            throw;
+          } catch (const std::exception &error) {
+            // An IOSurface could not be set up; the pixel path draws the
+            // same view.
+            NSLog(@"[WebGPU] drawElementImageToTexture: %s; reading the "
+                  @"pixels back instead",
+                  error.what());
+          }
+        }
+#else
+        (void)onFrame;
+#endif
+        onPixels(
+            renderViewIntoPixels(snapshot, snapshotRequest.afterScreenUpdates));
       } catch (const std::exception &error) {
         onError(error.what());
       } catch (...) {
@@ -322,12 +467,10 @@ void ApplePlatformContext::createImageBitmapFromDataAsync(
   });
 }
 
-VideoFrameHandle
-ApplePlatformContext::loadVideoFrame(const std::string &path) {
+VideoFrameHandle ApplePlatformContext::loadVideoFrame(const std::string &path) {
   NSString *nsPath = [NSString stringWithUTF8String:path.c_str()];
-  NSURL *url = [nsPath hasPrefix:@"file://"]
-                   ? [NSURL URLWithString:nsPath]
-                   : [NSURL fileURLWithPath:nsPath];
+  NSURL *url = [nsPath hasPrefix:@"file://"] ? [NSURL URLWithString:nsPath]
+                                             : [NSURL fileURLWithPath:nsPath];
   AVURLAsset *asset = [AVURLAsset assetWithURL:url];
 
   NSArray<AVAssetTrack *> *videoTracks =
@@ -347,8 +490,7 @@ ApplePlatformContext::loadVideoFrame(const std::string &path) {
   }
 
   NSDictionary *outputSettings = @{
-    (NSString *)kCVPixelBufferPixelFormatTypeKey :
-        @(kCVPixelFormatType_32BGRA),
+    (NSString *)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
     (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
     (NSString *)kCVPixelBufferMetalCompatibilityKey : @YES,
   };
@@ -402,7 +544,7 @@ ApplePlatformContext::loadVideoFrame(const std::string &path) {
 
 std::unique_ptr<IVideoPlayer>
 ApplePlatformContext::createVideoPlayer(const std::string &path,
-                                         VideoPixelFormat format) {
+                                        VideoPixelFormat format) {
   return createAppleVideoPlayer(path, format);
 }
 
@@ -414,8 +556,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;