test(compositor): check the P010 and full-range views without a media file

Address review on #1408: build each VideoToolbox biplanar format in process
and assert the plane formats and full-range flag nv12_srvs picks, so CI
covers the path. Also pass the opt-in source path through unchanged.

Author: EtienneLescot

crates/compositor/src/compositor_macos.rs

@@ -3860,6 +3860,10 @@ mod tests {
         fn from_planes(w: u32, h: u32, y: &[u8], uv: &[u8]) -> FakeFrame {
             let pb = crate::mac_frames::nv12_pixel_buffer_from_planes(w, h, y, uv)
                 .expect("CVPixelBuffer NV12");
+            FakeFrame::from_pixel_buffer(w, h, pb)
+        }
+
+        fn from_pixel_buffer(w: u32, h: u32, pb: crate::mac_frames::CVPixelBufferRef) -> FakeFrame {
             let mut frame: Box<AVFrame> = Box::new(unsafe { std::mem::zeroed() });
             frame.format = crate::ffi::AVPixelFormat::AV_PIX_FMT_VIDEOTOOLBOX as i32;
             frame.data[3] = pb.as_ptr() as *mut u8;
@@ -3873,6 +3877,44 @@ mod tests {
         }
     }
 
+    /// Les vues que `nv12_srvs` tire de chaque format biplanaire de VideoToolbox, sans
+    /// décoder ni fichier média. Un flux 10 bits (`x420`, `xf20`) se lit en plans 16 bits,
+    /// sinon l'image part en bandes (#1390). Une frame pleine plage (`420f`, `xf20`) porte un
+    /// 1 dans le bleu de sa vue CbCr : c'est le drapeau que `sample_yuv` lit.
+    #[test]
+    fn nv12_srvs_reads_bit_depth_and_range_from_the_pixel_format() {
+        use metal::MTLPixelFormat::{R16Unorm, R8Unorm, RG16Unorm, RG8Unorm};
+        use objc::{msg_send, sel, sel_impl};
+        #[repr(C)]
+        struct Swizzle([u8; 4]);
+        const SWIZZLE_ONE: u8 = 1;
+
+        let Ok(gpu) = crate::d3d::Gpu::create(false) else {
+            eprintln!("pas de device Metal — test sauté");
+            return;
+        };
+        let comp = super::Compositor::new_sized(&gpu, 64, 64).expect("Compositor::new_sized");
+        for (fourcc, y_fmt, uv_fmt, full_range) in [
+            (b"420v", R8Unorm, RG8Unorm, false),
+            (b"420f", R8Unorm, RG8Unorm, true),
+            (b"x420", R16Unorm, RG16Unorm, false),
+            (b"xf20", R16Unorm, RG16Unorm, true),
+        ] {
+            let name = std::str::from_utf8(fourcc).unwrap();
+            let pb = unsafe {
+                crate::mac_frames::create_nv12_pixel_buffer(64, 64, u32::from_be_bytes(*fourcc))
+            }
+            .unwrap_or_else(|e| panic!("{name} : {e}"));
+            let frame = FakeFrame::from_pixel_buffer(64, 64, pb);
+            let (y, uv) = unsafe { comp.nv12_srvs(frame.as_ptr()) }
+                .unwrap_or_else(|e| panic!("{name} : {e}"));
+            assert_eq!(y.pixel_format(), y_fmt, "{name} : plan Y");
+            assert_eq!(uv.pixel_format(), uv_fmt, "{name} : plan CbCr");
+            let swizzle: Swizzle = unsafe { msg_send![uv, swizzle] };
+            assert_eq!(swizzle.0[2] == SWIZZLE_ONE, full_range, "{name} : drapeau pleine plage");
+        }
+    }
+
     /// Scène PiP minimale. `effect` est le JSON de `webcamEffect` (`"null"` pour aucun).
     ///
     /// `effects.shadow` vaut 0 À DESSEIN : ce curseur ne pilote plus que l'ombre de l'écran,

crates/compositor/src/mac_frames.rs

@@ -105,11 +105,17 @@ extern "C" {
 }
 
 /// Crée un `CVPixelBufferRef` NV12 IOSurface-backed, dimensions paires `(w, h)`.
+/// `format` est le fourcc CoreVideo : `420v` partout, sauf les tests qui fabriquent les
+/// autres formats biplanaires que VideoToolbox sort (`420f`, `x420`, `xf20`).
 ///
 /// NV12 impose des dimensions paires : on arrondit AU-DESSUS pour le buffer et on
 /// laisse `present.width/height` aux dimensions visibles — c'est le même écart
 /// texture/visible que produit l'alignement macrobloc de D3D11VA (1080 → 1088).
-unsafe fn create_nv12_pixel_buffer(w: usize, h: usize) -> Result<CVPixelBufferRef> {
+pub(crate) unsafe fn create_nv12_pixel_buffer(
+    w: usize,
+    h: usize,
+    format: u32,
+) -> Result<CVPixelBufferRef> {
     // `{ IOSurfaceProperties: {}, MetalCompatibility: true }` — un dictionnaire
     // IOSurface vide suffit à demander le backing, `MetalCompatibility` fait valider
     // par CoreVideo que le résultat est utilisable depuis Metal.
@@ -130,7 +136,7 @@ unsafe fn create_nv12_pixel_buffer(w: usize, h: usize) -> Result<CVPixelBufferRe
         ptr::null(), // default allocator
         w,
         h,
-        K_CV_PIXEL_FORMAT_TYPE_420_Y_P_C_B_CR_8_BI_PLANAR_VIDEO_RANGE,
+        format,
         attributes.as_concrete_TypeRef() as *const std::ffi::c_void,
         &mut pixel_buffer,
     );
@@ -256,7 +262,11 @@ impl CpuFrames {
         if self.pixel_buffer.is_some() && self.pixel_buffer_dims == dims {
             return Ok(());
         }
-        let pb = create_nv12_pixel_buffer(dims.0 as usize, dims.1 as usize)?;
+        let pb = create_nv12_pixel_buffer(
+            dims.0 as usize,
+            dims.1 as usize,
+            K_CV_PIXEL_FORMAT_TYPE_420_Y_P_C_B_CR_8_BI_PLANAR_VIDEO_RANGE,
+        )?;
         self.pixel_buffer = Some(pb);
         self.pixel_buffer_dims = dims;
         Ok(())
@@ -401,7 +411,11 @@ pub(crate) fn nv12_pixel_buffer_from_planes(
         );
     }
     unsafe {
-        let pb = create_nv12_pixel_buffer(w, h)?;
+        let pb = create_nv12_pixel_buffer(
+            w,
+            h,
+            K_CV_PIXEL_FORMAT_TYPE_420_Y_P_C_B_CR_8_BI_PLANAR_VIDEO_RANGE,
+        )?;
         if CVPixelBufferLockBaseAddress(pb.as_ptr(), 0) != 0 {
             bail!("CVPixelBufferLockBaseAddress (fixture NV12)");
         }

crates/compositor/tests/hevc10_decode.rs

@@ -39,7 +39,7 @@ fn scene_json(source: &str) -> String {
 
 /// La frame 10 de `source`, rendue seule sur un fond uni, sans effet.
 fn render_frame_10(source: &str) -> RenderedFrame {
-    let source = source.replace('\\', "/");
+    let source = source.to_owned();
     let gpu = Gpu::create_auto(false).expect("device");
     let clips = [ClipSource {
         screen: source.clone(),