grafting 0.3.0

Native texture interop helpers for importing offscreen producer frames into host-owned wgpu textures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! IOSurface-to-wgpu import via Metal (Apple platforms).
//!
//! Imports an IOSurface into a `wgpu::Texture` by:
//! 1. Creating a Metal texture backed by the IOSurface
//! 2. Wrapping it as a wgpu HAL texture
//! 3. Normalizing from BGRA8Unorm (Metal native) to RGBA8Unorm with Y-flip

use dpi::PhysicalSize;
use foreign_types_shared::ForeignType;
use objc2::runtime::NSObject;
use objc2::{msg_send, rc::Retained};
use objc2_io_surface::IOSurfaceRef;
use objc2_metal::{MTLPixelFormat, MTLTextureDescriptor, MTLTextureType, MTLTextureUsage};

use crate::InteropError;

use super::texture_normalizer::ImportedTextureNormalizer;

/// Caches the normalization pipeline for repeated IOSurface imports.
///
/// Create once and reuse across frames to avoid repeated shader compilation.
pub struct MetalImporter {
    normalizer: ImportedTextureNormalizer,
}

impl MetalImporter {
    pub fn new(device: &wgpu::Device) -> Self {
        Self {
            normalizer: ImportedTextureNormalizer::new(device),
        }
    }

    /// Import an IOSurface into a normalized `wgpu::Texture`.
    ///
    /// The returned texture is Rgba8Unorm with top-left origin.
    pub fn import(
        &self,
        iosurface: &IOSurfaceRef,
        size: PhysicalSize<u32>,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
    ) -> Result<wgpu::Texture, InteropError> {
        let metal_texture = self.create_metal_texture(device, iosurface, size)?;
        let hal_texture = self.wrap_as_wgpu_hal(device, metal_texture, size)?;
        Ok(self.normalizer.normalize(device, queue, &hal_texture, size))
    }

    fn create_metal_texture(
        &self,
        wgpu_device: &wgpu::Device,
        iosurface: &IOSurfaceRef,
        size: PhysicalSize<u32>,
    ) -> Result<Retained<NSObject>, InteropError> {
        unsafe {
            let metal_device = wgpu_device.as_hal::<wgpu::wgc::api::Metal>().ok_or(
                InteropError::BackendMismatch {
                    expected: "Metal",
                    actual: "non-Metal",
                },
            )?;

            let device_raw = metal_device.raw_device().clone();

            let descriptor = MTLTextureDescriptor::new();
            descriptor.setDepth(1);
            descriptor.setSampleCount(1);
            descriptor.setWidth(size.width as usize);
            descriptor.setHeight(size.height as usize);
            descriptor.setMipmapLevelCount(1);
            descriptor.setUsage(MTLTextureUsage::ShaderRead);
            descriptor.setPixelFormat(MTLPixelFormat::BGRA8Unorm);
            descriptor.setTextureType(MTLTextureType::Type2D);

            let texture: Option<Retained<NSObject>> = msg_send![
                &*(device_raw.as_ptr() as *mut objc2::runtime::NSObject),
                newTextureWithDescriptor:&*descriptor,
                iosurface:iosurface,
                plane: 0usize
            ];

            texture.ok_or_else(|| {
                InteropError::Metal("failed to create Metal texture from IOSurface".to_string())
            })
        }
    }

    fn wrap_as_wgpu_hal(
        &self,
        wgpu_device: &wgpu::Device,
        metal_texture: Retained<NSObject>,
        size: PhysicalSize<u32>,
    ) -> Result<wgpu::Texture, InteropError> {
        unsafe {
            let ptr: *mut objc2_foundation::NSObject = Retained::into_raw(metal_texture);
            let metal_texture = metal::Texture::from_ptr(ptr as *mut _);

            let hal_texture = wgpu::hal::metal::Device::texture_from_raw(
                metal_texture,
                wgpu::TextureFormat::Bgra8Unorm,
                metal::MTLTextureType::D2,
                0,
                0,
                wgpu::hal::CopyExtent {
                    width: size.width,
                    height: size.height,
                    depth: 0,
                },
            );

            Ok(
                wgpu_device.create_texture_from_hal::<wgpu::wgc::api::Metal>(
                    hal_texture,
                    &wgpu::TextureDescriptor {
                        label: Some("iosurface-metal-import"),
                        size: wgpu::Extent3d {
                            width: size.width,
                            height: size.height,
                            depth_or_array_layers: 1,
                        },
                        mip_level_count: 1,
                        sample_count: 1,
                        dimension: wgpu::TextureDimension::D2,
                        format: wgpu::TextureFormat::Bgra8Unorm,
                        usage: wgpu::TextureUsages::TEXTURE_BINDING
                            | wgpu::TextureUsages::RENDER_ATTACHMENT,
                        view_formats: &[],
                    },
                ),
            )
        }
    }
}