ferroui_media_camera_browser/
lib.rs1#![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 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}