camera: update nokhwa, eye for macos, ability to switch camera when another camera not loaded

src/gui/platform/desktop/mod.rs

@@ -15,7 +15,7 @@
 use std::fs::File;
 use std::io::Write;
 use std::thread;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use parking_lot::RwLock;
 use lazy_static::lazy_static;
@@ -30,6 +30,10 @@ pub struct Desktop {
     /// Context to repaint content and handle viewport commands.
     ctx: Arc<RwLock<Option<egui::Context>>>,
 
+    /// Cameras amount.
+    cameras_amount: Arc<AtomicUsize>,
+    /// Camera index.
+    camera_index: Arc<AtomicUsize>,
     /// Flag to check if camera stop is needed.
     stop_camera: Arc<AtomicBool>,
 
@@ -37,6 +41,127 @@ pub struct Desktop {
     attention_required: Arc<AtomicBool>,
 }
 
+impl Desktop {
+    pub fn new() -> Self {
+        Self {
+            ctx: Arc::new(RwLock::new(None)),
+            cameras_amount: Arc::new(AtomicUsize::new(0)),
+            camera_index: Arc::new(AtomicUsize::new(0)),
+            stop_camera: Arc::new(AtomicBool::new(false)),
+            attention_required: Arc::new(AtomicBool::new(false)),
+        }
+    }
+
+    #[allow(dead_code)]
+    #[cfg(not(target_os = "macos"))]
+    fn start_camera_capture(cameras_amount: Arc<AtomicUsize>,
+                            camera_index: Arc<AtomicUsize>,
+                            stop_camera: Arc<AtomicBool>) {
+        use nokhwa::Camera;
+        use nokhwa::pixel_format::RgbFormat;
+        use nokhwa::utils::{CameraIndex, RequestedFormat, RequestedFormatType};
+        use nokhwa::utils::ApiBackend;
+
+        let devices = nokhwa::query(ApiBackend::Auto).unwrap();
+        cameras_amount.store(devices.len(), Ordering::Relaxed);
+        let index = camera_index.load(Ordering::Relaxed);
+        if devices.is_empty() || index >= devices.len() {
+            return;
+        }
+
+        thread::spawn(move || {
+            let index = CameraIndex::Index(camera_index.load(Ordering::Relaxed) as u32);
+            let requested = RequestedFormat::new::<RgbFormat>(
+                RequestedFormatType::AbsoluteHighestFrameRate
+            );
+            // Create and open camera.
+            if let Ok(mut camera) = Camera::new(index, requested) {
+                if let Ok(_) = camera.open_stream() {
+                    loop {
+                        // Stop if camera was stopped.
+                        if stop_camera.load(Ordering::Relaxed) {
+                            stop_camera.store(false, Ordering::Relaxed);
+                            // Clear image.
+                            let mut w_image = LAST_CAMERA_IMAGE.write();
+                            *w_image = None;
+                            break;
+                        }
+                        // Get a frame.
+                        if let Ok(frame) = camera.frame() {
+                            // Save image.
+                            let mut w_image = LAST_CAMERA_IMAGE.write();
+                            *w_image = Some((frame.buffer().to_vec(), 0));
+                        } else {
+                            // Clear image.
+                            let mut w_image = LAST_CAMERA_IMAGE.write();
+                            *w_image = None;
+                            break;
+                        }
+                    }
+                    camera.stop_stream().unwrap();
+                };
+            }
+        });
+    }
+
+    #[allow(dead_code)]
+    #[cfg(target_os = "macos")]
+    fn start_camera_capture(cameras_amount: Arc<AtomicUsize>,
+                            camera_index: Arc<AtomicUsize>,
+                            stop_camera: Arc<AtomicBool>) {
+        use image::{ExtendedColorType, ImageBuffer, ImageEncoder, Rgb};
+        use eye::hal::{traits::{Context, Device, Stream}, PlatformContext};
+        use image::codecs::jpeg::JpegEncoder;
+
+        let index = camera_index.load(Ordering::Relaxed);
+        let devices = PlatformContext::default().devices().unwrap_or(vec![]);
+        cameras_amount.store(devices.len(), Ordering::Relaxed);
+        if devices.is_empty() || index >= devices.len() {
+            return;
+        }
+
+        // Capture images at separate thread.
+        let uri = devices[camera_index.load(Ordering::Relaxed)].uri.clone();
+        thread::spawn(move || {
+            if let Ok(dev) = PlatformContext::default().open_device(&uri) {
+                let streams = dev.streams().unwrap_or(vec![]);
+                if streams.is_empty() {
+                    return;
+                }
+                let stream_desc = streams[0].clone();
+                let w = stream_desc.width;
+                let h = stream_desc.height;
+                if let Ok(mut stream) = dev.start_stream(&stream_desc) {
+                    loop {
+                        // Stop if camera was stopped.
+                        if stop_camera.load(Ordering::Relaxed) {
+                            stop_camera.store(false, Ordering::Relaxed);
+                            let mut w_image = LAST_CAMERA_IMAGE.write();
+                            *w_image = None;
+                            break;
+                        }
+                        // Get a frame.
+                        let frame = stream.next()
+                            .expect("Stream is dead")
+                            .expect("Failed to capture a frame");
+                        let mut out = vec![];
+                        if let Some(buf) = ImageBuffer::<Rgb<u8>, &[u8]>::from_raw(w, h, &frame) {
+                            JpegEncoder::new(&mut out)
+                                .write_image(buf.as_raw(), w, h, ExtendedColorType::Rgb8)
+                                .unwrap_or_default();
+                        } else {
+                            out = frame.to_vec();
+                        }
+                        // Save image.
+                        let mut w_image = LAST_CAMERA_IMAGE.write();
+                        *w_image = Some((out, 0));
+                    }
+                }
+            }
+        });
+    }
+}
+
 impl PlatformCallbacks for Desktop {
     fn set_context(&mut self, ctx: &egui::Context) {
         let mut w_ctx = self.ctx.write();
@@ -47,7 +172,7 @@ impl PlatformCallbacks for Desktop {
         let r_ctx = self.ctx.read();
         if r_ctx.is_some() {
             let ctx = r_ctx.as_ref().unwrap();
-            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+            ctx.send_viewport_cmd(ViewportCommand::Close);
         }
     }
 
@@ -71,15 +196,13 @@ impl PlatformCallbacks for Desktop {
             let mut w_image = LAST_CAMERA_IMAGE.write();
             *w_image = None;
         }
-
         // Setup stop camera flag.
         let stop_camera = self.stop_camera.clone();
         stop_camera.store(false, Ordering::Relaxed);
 
-        // Capture images at separate thread.
-        thread::spawn(move || {
-            Self::start_camera_capture(stop_camera);
-        });
+        Self::start_camera_capture(self.cameras_amount.clone(),
+                                   self.camera_index.clone(),
+                                   stop_camera);
     }
 
     fn stop_camera(&self) {
@@ -96,11 +219,20 @@ impl PlatformCallbacks for Desktop {
     }
 
     fn can_switch_camera(&self) -> bool {
-        false
+        let amount = self.cameras_amount.load(Ordering::Relaxed);
+        amount > 1
     }
 
     fn switch_camera(&self) {
-        return;
+        self.stop_camera();
+        let index = self.camera_index.load(Ordering::Relaxed);
+        let amount = self.cameras_amount.load(Ordering::Relaxed);
+        if index == amount - 1 {
+            self.camera_index.store(0, Ordering::Relaxed);
+        } else {
+            self.camera_index.store(index + 1, Ordering::Relaxed);
+        }
+        self.start_camera();
     }
 
     fn share_data(&self, name: String, data: Vec<u8>) -> Result<(), std::io::Error> {
@@ -171,53 +303,6 @@ impl PlatformCallbacks for Desktop {
     }
 }
 
-impl Desktop {
-    pub fn new() -> Self {
-        Self {
-            stop_camera: Arc::new(AtomicBool::new(false)),
-            ctx: Arc::new(RwLock::new(None)),
-            attention_required: Arc::new(AtomicBool::new(false)),
-        }
-    }
-
-    fn start_camera_capture(stop_camera: Arc<AtomicBool>) {
-        use nokhwa::Camera;
-        use nokhwa::pixel_format::RgbFormat;
-        use nokhwa::utils::{CameraIndex, RequestedFormat, RequestedFormatType};
-        let index = CameraIndex::Index(0);
-        let requested = RequestedFormat::new::<RgbFormat>(
-            RequestedFormatType::AbsoluteHighestFrameRate
-        );
-        // Create and open camera.
-        if let Ok(mut camera) = Camera::new(index, requested) {
-            if let Ok(_) = camera.open_stream() {
-                loop {
-                    // Stop if camera was stopped.
-                    if stop_camera.load(Ordering::Relaxed) {
-                        stop_camera.store(false, Ordering::Relaxed);
-                        // Clear image.
-                        let mut w_image = LAST_CAMERA_IMAGE.write();
-                        *w_image = None;
-                        break;
-                    }
-                    // Get a frame.
-                    if let Ok(frame) = camera.frame() {
-                        // Save image.
-                        let mut w_image = LAST_CAMERA_IMAGE.write();
-                        *w_image = Some((frame.buffer().to_vec(), 0));
-                    } else {
-                        // Clear image.
-                        let mut w_image = LAST_CAMERA_IMAGE.write();
-                        *w_image = None;
-                        break;
-                    }
-                }
-                let _ = camera.stop_stream();
-            };
-        }
-    }
-}
-
 lazy_static! {
     /// Last captured image from started camera.
     static ref LAST_CAMERA_IMAGE: Arc<RwLock<Option<(Vec<u8>, u32)>>> = Arc::new(RwLock::new(None));

src/gui/views/camera.rs

@@ -51,7 +51,7 @@ impl CameraContent {
     /// Draw camera content.
     pub fn ui(&mut self, ui: &mut egui::Ui, cb: &dyn PlatformCallbacks) {
         ui.ctx().request_repaint();
-        if let Some(img_data) = cb.camera_image() {
+        let rect = if let Some(img_data) = cb.camera_image() {
             if let Ok(img) =
                 image::load_from_memory(&*img_data.0) {
                 // Process image to find QR code.
@@ -62,27 +62,28 @@ impl CameraContent {
 
                 // Show UR scan progress.
                 self.ur_progress_ui(ui);
-
-                // Show button to switch cameras.
-                if cb.can_switch_camera() {
-                    let r = {
-                        let mut r = img_rect.clone();
-                        r.min.y = r.max.y - 52.0;
-                        r.min.x = r.max.x - 52.0;
-                        r
-                    };
-                    ui.allocate_new_ui(UiBuilder::new().max_rect(r), |ui| {
-                        let rotate_img = CAMERA_ROTATE.to_string();
-                        View::button(ui, rotate_img, Colors::white_or_black(false), || {
-                            cb.switch_camera();
-                        });
-                    });
-                }
+                img_rect
             } else {
-                self.loading_ui(ui);
+                self.loading_ui(ui)
             }
         } else {
-            self.loading_ui(ui);
+            self.loading_ui(ui)
+        };
+
+        // Show button to switch cameras.
+        if cb.can_switch_camera() {
+            let r = {
+                let mut r = rect.clone();
+                r.min.y = r.max.y - 52.0;
+                r.min.x = r.max.x - 52.0;
+                r
+            };
+            ui.allocate_new_ui(UiBuilder::new().max_rect(r), |ui| {
+                let rotate_img = CAMERA_ROTATE.to_string();
+                View::button(ui, rotate_img, Colors::white_or_black(false), || {
+                    cb.switch_camera();
+                });
+            });
         }
     }
 
@@ -148,13 +149,13 @@ impl CameraContent {
     }
 
     /// Draw camera loading progress content.
-    fn loading_ui(&self, ui: &mut egui::Ui) {
+    fn loading_ui(&self, ui: &mut egui::Ui) -> Rect {
         let space = (ui.available_width() - View::BIG_SPINNER_SIZE) / 2.0;
         ui.vertical_centered(|ui| {
             ui.add_space(space);
             View::big_loading_spinner(ui);
             ui.add_space(space);
-        });
+        }).response.rect
     }
 
     /// Check if image is processing to find QR code.