Skip to main content

ferroui_media_camera_browser/
lib.rs

1//! Explicit video-only getUserMedia acquisition and bounded shared GPU preview.
2#![forbid(unsafe_code)]
3use ferroui_browser::interop::completion_helper::{await_promise, PromiseError};
4use ferroui_media::{frames::*, MediaError};
5#[cfg(feature = "controls")]
6pub use ferroui_media_browser::BrowserTextureImporter;
7use ferroui_media_browser::{BrowserFrameStream, BrowserImageFrame, WebGlFrameProducer};
8use ferroui_media_camera::*;
9use std::{cell::Cell, rc::Rc, time::Duration};
10use wasm_bindgen::prelude::*;
11#[wasm_bindgen(module = "/camera.js")]
12extern "C" {
13    #[wasm_bindgen(js_name=devices)]
14    fn discover() -> JsValue;
15    #[wasm_bindgen(js_name=permission)]
16    fn consent() -> i32;
17    #[wasm_bindgen(catch,js_name=start)]
18    fn start_native(options: &str) -> Result<CameraRequest, JsValue>;
19    type CameraRequest;
20    #[wasm_bindgen(method, getter)]
21    fn promise(this: &CameraRequest) -> JsValue;
22    #[wasm_bindgen(method)]
23    fn commit(this: &CameraRequest);
24    #[wasm_bindgen(method)]
25    fn close(this: &CameraRequest);
26    type BrowserCamera;
27    #[wasm_bindgen(method, getter)]
28    fn active(this: &BrowserCamera) -> bool;
29    #[wasm_bindgen(method, catch)]
30    fn settings(this: &BrowserCamera) -> Result<String, JsValue>;
31    #[wasm_bindgen(method, catch)]
32    fn sample(this: &BrowserCamera) -> Result<Option<NativeImage>, JsValue>;
33    #[wasm_bindgen(method)]
34    fn photo(this: &BrowserCamera) -> JsValue;
35    #[wasm_bindgen(method,js_name=close)]
36    fn stop_camera(this: &BrowserCamera);
37    type NativeImage;
38    #[wasm_bindgen(method, getter)]
39    fn image(this: &NativeImage) -> JsValue;
40    #[wasm_bindgen(method, getter)]
41    fn sequence(this: &NativeImage) -> f64;
42    #[wasm_bindgen(method, getter)]
43    fn timestamp(this: &NativeImage) -> f64;
44    #[wasm_bindgen(method, getter)]
45    fn width(this: &NativeImage) -> u32;
46    #[wasm_bindgen(method, getter)]
47    fn height(this: &NativeImage) -> u32;
48    type NativePhoto;
49    #[wasm_bindgen(method, getter)]
50    fn bytes(this: &NativePhoto) -> Vec<u8>;
51    #[wasm_bindgen(method,getter,js_name=length)]
52    fn encoded_length(this: &NativePhoto) -> u32;
53    #[wasm_bindgen(method,getter,js_name=width)]
54    fn photo_width(this: &NativePhoto) -> u32;
55    #[wasm_bindgen(method,getter,js_name=height)]
56    fn photo_height(this: &NativePhoto) -> u32;
57    #[wasm_bindgen(method,getter,js_name=timestamp)]
58    fn photo_timestamp(this: &NativePhoto) -> f64;
59    #[wasm_bindgen(method, getter)]
60    fn origin(this: &NativePhoto) -> String;
61}
62struct Request(CameraRequest);
63impl Drop for Request {
64    fn drop(&mut self) {
65        self.0.close();
66    }
67}
68struct Camera(BrowserCamera);
69impl Drop for Camera {
70    fn drop(&mut self) {
71        self.0.stop_camera();
72    }
73}
74#[derive(Default)]
75pub struct BrowserCameraProvider {
76    frames: Option<WebGlFrameProducer>,
77}
78impl BrowserCameraProvider {
79    /// Discovery does not require a compositor, hardware acquisition or consent.
80    pub fn discovery() -> Self {
81        Self::default()
82    }
83    pub fn new(frames: WebGlFrameProducer) -> Self {
84        Self {
85            frames: Some(frames),
86        }
87    }
88}
89impl CameraProvider for BrowserCameraProvider {
90    fn devices(&self) -> CameraFuture<Vec<CameraDevice>> {
91        let pending = await_promise(&discover());
92        Box::pin(async move {
93            let value = pending
94                .await
95                .map_err(promise_error)?
96                .as_string()
97                .ok_or_else(|| error(CameraErrorKind::NativeFailure, "Invalid discovery result"))?;
98            let values: serde_json::Value = serde_json::from_str(&value)
99                .map_err(|e| error(CameraErrorKind::NativeFailure, e.to_string()))?;
100            values
101                .as_array()
102                .ok_or_else(|| error(CameraErrorKind::NativeFailure, "Invalid discovery result"))?
103                .iter()
104                .map(|d| {
105                    Ok(CameraDevice {
106                        id: d["id"]
107                            .as_str()
108                            .ok_or_else(|| {
109                                error(CameraErrorKind::NativeFailure, "Missing camera identity")
110                            })?
111                            .into(),
112                        label: d["label"].as_str().map(str::to_owned),
113                        facing: CameraFacing::Unknown,
114                        formats: Vec::new(),
115                    })
116                })
117                .collect()
118        })
119    }
120    fn permission(&self) -> CameraPermission {
121        match consent() {
122            1 => CameraPermission::Granted,
123            2 => CameraPermission::Denied,
124            _ => CameraPermission::NotDetermined,
125        }
126    }
127    fn start(
128        &self,
129        options: CameraStartOptions,
130        source: u64,
131        generation: u64,
132        budget: FrameBudget,
133    ) -> CameraFuture<Rc<dyn NativeCameraSession>> {
134        let Some(producer) = self.frames.clone() else {
135            return Box::pin(async {
136                Err(error(
137                    CameraErrorKind::Unsupported,
138                    "Camera preview requires an admitted WebGL frame producer",
139                ))
140            });
141        };
142        let selection = options.selection;
143        let facing = match selection.preferred_facing {
144            Some(CameraFacing::Front) => Some("user"),
145            Some(CameraFacing::Rear) => Some("environment"),
146            _ => None,
147        };
148        let json=serde_json::json!({"device":selection.device_id,"facing":facing,"exact":selection.exact,"width":selection.format.map(|f|f.width),"height":selection.format.map(|f|f.height),"fps":selection.format.map(|f|f.frames_per_second)}).to_string();
149        let request = start_native(&json).map(Request).map_err(js_error);
150        let frames = producer
151            .with_budget(budget.clone())
152            .with_analysis(options.enable_analysis)
153            .stream(source, generation);
154        Box::pin(async move {
155            let request = request?;
156            let value = await_promise(&request.0.promise())
157                .await
158                .map_err(promise_error)?;
159            let camera = Camera(value.unchecked_into());
160            let settings = parse_settings(&camera.0.settings().map_err(js_error)?)?;
161            request.0.commit();
162            Ok(Rc::new(Session {
163                camera,
164                settings,
165                frames,
166                budget,
167                stopped: Cell::new(false),
168            }) as Rc<dyn NativeCameraSession>)
169        })
170    }
171}
172struct Session {
173    camera: Camera,
174    settings: CameraSettings,
175    frames: BrowserFrameStream,
176    budget: FrameBudget,
177    stopped: Cell<bool>,
178}
179impl NativeCameraSession for Session {
180    fn settings(&self) -> CameraSettings {
181        self.settings.clone()
182    }
183    fn take_frame(&self) -> Result<Option<FrameLease>, CameraError> {
184        if self.stopped.get() || !self.camera.0.active() {
185            return Err(error(
186                CameraErrorKind::Disconnected,
187                "The camera track ended",
188            ));
189        }
190        self.frames
191            .poll(|| {
192                self.camera
193                    .0
194                    .sample()
195                    .map_err(|e| media_error(js_error(e)))?
196                    .map(|sample| {
197                        Ok(BrowserImageFrame {
198                            image: sample.image(),
199                            sequence: sample.sequence() as u64,
200                            width: sample.width(),
201                            height: sample.height(),
202                            timestamp: Duration::try_from_secs_f64(sample.timestamp()).map_err(
203                                |_| {
204                                    media_error(error(
205                                        CameraErrorKind::NativeFailure,
206                                        "Invalid camera timestamp",
207                                    ))
208                                },
209                            )?,
210                        })
211                    })
212                    .transpose()
213            })
214            .map_err(|e| error(CameraErrorKind::NativeFailure, e.to_string()))
215    }
216    fn photo(&self) -> CameraFuture<CameraPhoto> {
217        let pending = await_promise(&self.camera.0.photo());
218        let counters = self.budget.counters();
219        Box::pin(async move {
220            let photo: NativePhoto = pending.await.map_err(promise_error)?.unchecked_into();
221            let length = photo.encoded_length();
222            if length > 64 * 1024 * 1024 {
223                return Err(error(
224                    CameraErrorKind::NativeFailure,
225                    "Native photo exceeds the encoded-output bound",
226                ));
227            }
228            counters
229                .cpu_transfer(
230                    PixelTransferPurpose::Photo,
231                    u64::from(length),
232                    PresentationRoute::SharedTexture,
233                )
234                .map_err(|e| error(CameraErrorKind::NativeFailure, e.to_string()))?;
235            let encoded = photo.bytes();
236            if encoded.len() != length as usize {
237                return Err(error(
238                    CameraErrorKind::NativeFailure,
239                    "Native photo length changed",
240                ));
241            }
242            Ok(CameraPhoto {
243                encoded: encoded.into(),
244                content_type: "image/jpeg".into(),
245                width: photo.photo_width(),
246                height: photo.photo_height(),
247                timestamp: Duration::try_from_secs_f64(photo.photo_timestamp()).unwrap_or_default(),
248                rotation_degrees: 0,
249                mirrored: false,
250                origin: if photo.origin() == "native" {
251                    PhotoOrigin::NativeStill
252                } else {
253                    PhotoOrigin::PreviewSnapshot
254                },
255            })
256        })
257    }
258    fn set_control(&self, _: CameraControl) -> Result<(), CameraError> {
259        Err(error(
260            CameraErrorKind::Unsupported,
261            "This browser profile does not expose synchronous camera controls",
262        ))
263    }
264    fn stop(&self) {
265        if !self.stopped.replace(true) {
266            self.frames.clear();
267            self.camera.0.stop_camera();
268        }
269    }
270}
271fn parse_settings(text: &str) -> Result<CameraSettings, CameraError> {
272    let s: serde_json::Value = serde_json::from_str(text)
273        .map_err(|e| error(CameraErrorKind::NativeFailure, e.to_string()))?;
274    let width = s["width"]
275        .as_u64()
276        .and_then(|v| u32::try_from(v).ok())
277        .unwrap_or_default();
278    let height = s["height"]
279        .as_u64()
280        .and_then(|v| u32::try_from(v).ok())
281        .unwrap_or_default();
282    let fps = s["fps"].as_f64().unwrap_or_default();
283    if width == 0 || height == 0 || !fps.is_finite() || fps <= 0. {
284        return Err(error(
285            CameraErrorKind::Unsupported,
286            "The browser did not report negotiated dimensions and frame rate",
287        ));
288    }
289    Ok(CameraSettings {
290        device: CameraDevice {
291            id: s["device"].as_str().unwrap_or_default().into(),
292            label: s["label"].as_str().map(str::to_owned),
293            facing: match s["facing"].as_str() {
294                Some("user") => CameraFacing::Front,
295                Some("environment") => CameraFacing::Rear,
296                _ => CameraFacing::Unknown,
297            },
298            formats: Vec::new(),
299        },
300        format: CameraFormat {
301            width,
302            height,
303            frames_per_second: fps,
304        },
305        native_still: s["nativeStill"].as_bool().unwrap_or(false),
306        torch: false,
307        zoom: None,
308    })
309}
310fn error(kind: CameraErrorKind, message: impl Into<String>) -> CameraError {
311    CameraError::new(kind, message)
312}
313fn media_error(error: CameraError) -> MediaError {
314    MediaError::new(
315        ferroui_media::MediaErrorKind::NativeFailure,
316        error.to_string(),
317    )
318}
319fn js_error(value: JsValue) -> CameraError {
320    error(
321        CameraErrorKind::NativeFailure,
322        format!("Browser camera: {value:?}"),
323    )
324}
325fn promise_error(value: PromiseError) -> CameraError {
326    error(
327        match value.name() {
328            "NotAllowedError" => CameraErrorKind::Denied,
329            "SecurityError" => CameraErrorKind::Restricted,
330            "NotFoundError" => CameraErrorKind::NoDevice,
331            "NotReadableError" => CameraErrorKind::Disconnected,
332            "InvalidStateError" => CameraErrorKind::Busy,
333            "OverconstrainedError" => CameraErrorKind::InvalidRequest,
334            "NotSupportedError" => CameraErrorKind::Unsupported,
335            "AbortError" => CameraErrorKind::Cancelled,
336            _ => CameraErrorKind::NativeFailure,
337        },
338        value.to_string(),
339    )
340}