experiment: camera on thread

examples/iced.rs

@@ -1,25 +1,21 @@
 use std::iter::repeat;
-use std::sync::mpsc::{channel, Receiver, Sender, TryRecvError};
+use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Instant;
 
 use iced::widget::{column, container, image, text};
 use iced::{
     executor, window, Alignment, Application, Command, Element, Length, Settings, Subscription,
     Theme,
 };
-use kamera::{Camera, CameraInfo};
+use kamera::{Camera, CameraInfo, CameraOnThread};
 
 pub fn main() -> iced::Result {
     Example::run(Settings::default())
 }
 
 struct Example {
-    camera: Camera,
+    camera: CameraOnThread,
     cameras: Vec<CameraInfo>,
-    #[allow(unused)]
-    end_camera: Sender<()>,
-    send_frame: Sender<((u32, u32), Vec<u8>)>,
-    camera_frame: Receiver<((u32, u32), Vec<u8>)>,
     current_frame: image::Handle,
 }
 
@@ -36,25 +32,14 @@ impl Application for Example {
     type Flags = ();
 
     fn new(_flags: Self::Flags) -> (Self, Command<Message>) {
-        let (end_camera, end) = channel::<()>();
-        let (send_frame, camera_frame) = channel::<((u32, u32), Vec<u8>)>();
-        let (send_cameras, cameras) = channel::<Vec<CameraInfo>>();
-        // std::thread::spawn(move || {
-            let _ = send_cameras.send(Camera::enumerate_cameras());
-            let camera = Camera::new_default_device();
-            camera.start();
-
-        // });
-
-        let cameras = cameras.recv().expect("enumerate cameras");
+        let camera = CameraOnThread::new_default_device();
+        let cameras = CameraOnThread::enumerate_cameras();
+        camera.start();
 
         (
             Self {
                 camera,
                 cameras,
-                end_camera,
-                send_frame,
-                camera_frame,
                 current_frame: image::Handle::from_pixels(
                     16,
                     16,
@@ -76,15 +61,7 @@ impl Application for Example {
     fn update(&mut self, message: Message) -> Command<Message> {
         match message {
             Message::Tick(_instant) => {
-                if let Some(frame) = self.camera.wait_for_frame() {
-                    let size = frame.size_u32();
-                    let pixels = frame.data().data_u8().to_vec();
-                    if self.send_frame.send((size, pixels)).is_err() {
-
-                    }
-                }
-
-                while let Ok(((w, h), pixels)) = self.camera_frame.try_recv() {
+                if let Some(((w, h), pixels)) = self.camera.wait_for_frame() {
                     self.current_frame = image::Handle::from_pixels(w, h, pixels);
                 }
             }

src/camera_on_thread.rs

@@ -0,0 +1,100 @@
+use std::{
+    sync::mpsc::{channel, Receiver, Sender},
+    thread::JoinHandle,
+};
+
+use crate::{Camera, CameraInfo};
+
+enum Message {
+    NewDefaultDevice,
+    EnumerateCameras,
+    Start,
+    Stop,
+    WaitForFrame,
+    ChangeDevice,
+}
+
+enum Response {
+    EnumerateCameras(Vec<CameraInfo>),
+    WaitForFrame(((u32, u32), Vec<u8>)),
+}
+
+pub struct CameraOnThread {
+    messages: Sender<Message>,
+    responses: Receiver<Response>,
+    thread_join: JoinHandle<()>,
+}
+
+impl CameraOnThread {
+    pub fn new_default_device() -> Self {
+        let (messages, message_rx) = channel::<Message>();
+        let (response_tx, responses) = channel::<Response>();
+        let thread_join = std::thread::spawn(move || {
+            use Message::*;
+            let mut camera = None;
+            let mut send_result = Ok(());
+            while let (Ok(message), Ok(())) = (message_rx.recv(), &send_result) {
+                match message {
+                    NewDefaultDevice => {
+                        camera = Some(Camera::new_default_device());
+                    }
+                    EnumerateCameras => {
+                        send_result = response_tx
+                            .send(Response::EnumerateCameras(Camera::enumerate_cameras()));
+                    }
+                    Start => {
+                        camera.as_ref().map(|c| c.start());
+                    }
+                    Stop => {
+                        camera.as_ref().map(|c| c.stop());
+                    }
+                    WaitForFrame => {
+                        if let Some(ref camera) = camera {
+                            if let Some(frame) = camera.wait_for_frame() {
+                                let size = frame.size_u32();
+                                let pixels = frame.data().data_u8().to_vec();
+                                let response = Response::WaitForFrame((size, pixels));
+                                send_result = response_tx.send(response);
+                            }
+                        }
+                    }
+                    ChangeDevice => {
+                        camera.as_mut().map(|c| c.change_device());
+                    }
+                }
+            }
+            if let Some(camera) = camera {
+                camera.stop();
+            }
+        });
+
+        messages.send(Message::NewDefaultDevice).unwrap();
+
+        CameraOnThread { messages, responses, thread_join }
+    }
+
+    pub fn enumerate_cameras() -> Vec<CameraInfo> {
+        std::thread::spawn(|| Camera::enumerate_cameras()).join().unwrap()
+    }
+
+    pub fn start(&self) {
+        self.messages.send(Message::Start).unwrap();
+    }
+
+    pub fn stop(&self) {
+        self.messages.send(Message::Stop).unwrap();
+    }
+
+    pub fn change_device(&mut self) {
+        self.messages.send(Message::ChangeDevice).unwrap();
+    }
+
+    pub fn wait_for_frame(&self) -> Option<((u32, u32), Vec<u8>)> {
+        self.messages.send(Message::WaitForFrame).unwrap();
+        if let Response::WaitForFrame((size, pixels)) = self.responses.recv().unwrap() {
+            return Some((size, pixels));
+        } else {
+            todo!();
+        }
+    }
+}

src/lib.rs

@@ -1,6 +1,9 @@
 mod camera;
 pub use camera::*;
 
+mod camera_on_thread;
+pub use camera_on_thread::*;
+
 #[cfg(target_os = "macos")]
 pub(crate) mod mac_avf;