use crate::camera::FrameData;
use crate::error::Error;
use crate::in_flight::InFlight;
use std::ops::ControlFlow;
use std::sync::{
Arc, Mutex,
atomic::{AtomicU64, Ordering},
};
pub static CAMERA_EPOCH: AtomicU64 = AtomicU64::new(0);
#[must_use]
pub fn camera_epoch() -> u64 {
CAMERA_EPOCH.load(Ordering::SeqCst)
}
pub type FrameHandler = Box<dyn FnMut(&egui::Context, &FrameData) -> ControlFlow<(), ()> + Send>;
#[derive(Debug, Default)]
pub struct FeedInner {
pub(crate) running: bool,
pub(crate) error: Option<Arc<Error>>,
pub(crate) latest_rgba: Option<(Vec<u8>, u32, u32)>,
pub(crate) epoch: u64,
pub(crate) interval_ms: u64,
}
pub struct CameraViewState {
inner: Arc<Mutex<FeedInner>>,
texture: Option<egui::TextureHandle>,
preview_dims: Option<(u32, u32)>,
in_flight: InFlight,
handler: Option<FrameHandler>,
}
impl Default for CameraViewState {
fn default() -> Self {
Self {
inner: Arc::new(Mutex::new(FeedInner {
interval_ms: 66,
..FeedInner::default()
})),
texture: None,
preview_dims: None,
in_flight: InFlight::default(),
handler: None,
}
}
}
impl CameraViewState {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn with_fps(self, fps: f32) -> Self {
let interval = crate::utils::fps_to_interval_ms(fps);
if let Ok(mut feed) = self.inner.lock() {
feed.interval_ms = interval;
}
self
}
pub fn ensure_default_handler(&mut self) {
if self.handler.is_none() {
self.handler = Some(Box::new(
|_ctx: &egui::Context, _frame: &crate::camera::FrameData| {
std::ops::ControlFlow::Continue(())
},
));
}
}
pub fn set_handler(&mut self, handler: Option<FrameHandler>) {
self.handler = handler;
}
pub fn set_fps(&self, fps: f32) {
let interval = crate::utils::fps_to_interval_ms(fps);
if let Ok(mut feed) = self.inner.lock() {
feed.interval_ms = interval;
}
}
#[must_use]
pub fn interval_ms(&self) -> u64 {
self.inner.lock().ok().map_or(66, |feed| feed.interval_ms)
}
pub fn start(&mut self, ctx: &egui::Context) -> bool {
if self.is_running() {
return true;
}
let Some(guard) = self.in_flight.claim() else {
return false;
};
let Some(handler) = self.handler.take() else {
drop(guard);
return false;
};
let epoch = CAMERA_EPOCH.fetch_add(1, Ordering::SeqCst) + 1;
let interval_ms = self.inner.lock().ok().map_or(66, |feed| feed.interval_ms);
if let Ok(mut feed) = self.inner.lock() {
feed.epoch = epoch;
feed.running = true;
feed.error = None;
}
super::pump::spawn_pump(ctx, &self.inner, epoch, interval_ms, handler, guard);
true
}
pub fn stop(&mut self) {
let epoch = CAMERA_EPOCH.fetch_add(1, Ordering::SeqCst) + 1;
if let Ok(mut feed) = self.inner.lock() {
feed.running = false;
feed.epoch = epoch;
}
crate::camera::stop_capture_worker();
#[cfg(target_os = "android")]
crate::platform::android::stop_camera_blocking();
}
#[must_use]
pub fn is_running(&self) -> bool {
self.inner.lock().is_ok_and(|feed| feed.running)
}
#[must_use]
pub fn error(&self) -> Option<Arc<Error>> {
self.inner.lock().ok().and_then(|feed| feed.error.clone())
}
pub fn clear_error(&mut self) {
if let Ok(mut feed) = self.inner.lock() {
feed.error = None;
}
}
pub(crate) fn drain_rgba(&self) -> Option<(Vec<u8>, u32, u32)> {
self.inner
.lock()
.ok()
.and_then(|mut feed| feed.latest_rgba.take())
}
pub(crate) fn take_texture(&mut self) -> &mut Option<egui::TextureHandle> {
&mut self.texture
}
#[must_use]
pub fn preview_size(&self) -> Option<(u32, u32)> {
self.preview_dims
}
pub(crate) fn store_texture(
&mut self,
ctx: &egui::Context,
rgba: &[u8],
width: u32,
height: u32,
) {
let expected = crate::utils::pixel_area_len(width, height).saturating_mul(4);
if width != 0 && height != 0 && expected != 0 && rgba.len() == expected {
let image =
egui::ColorImage::from_rgba_unmultiplied([width as usize, height as usize], rgba);
match &self.texture {
Some(tex) => {
let mut updated = egui::TextureHandle::clone(tex);
updated.set(image, egui::TextureOptions::LINEAR);
}
None => {
self.texture = Some(ctx.load_texture(
"functora-camera",
image,
egui::TextureOptions::LINEAR,
));
}
}
self.preview_dims = Some((width, height));
}
}
}