keyfork-qrcode: add bug messages

crates/qrcode/keyfork-qrcode/src/lib.rs

@@ -1,11 +1,15 @@
 //! Encoding and decoding QR codes.
 
+#![allow(clippy::expect_fun_call)]
+
 use keyfork_bug as bug;
 
+use bug::POISONED_MUTEX;
 use image::{ImageBuffer, ImageReader, Luma};
 use std::{
     io::{Cursor, Write},
     process::{Command, Stdio},
+    sync::{mpsc::channel, Arc, Condvar, Mutex},
     time::{Duration, Instant},
 };
 use v4l::{
@@ -15,6 +19,8 @@ use v4l::{
     Device, FourCC,
 };
 
+type Image = ImageBuffer<Luma<u8>, Vec<u8>>;
+
 /// A QR code could not be generated.
 #[derive(thiserror::Error, Debug)]
 pub enum QRGenerationError {
@@ -102,12 +108,12 @@ pub fn qrencode(
 const VIDEO_FORMAT_READ_ERROR: &str = "Failed to read video device format";
 
 trait Scanner {
-    fn scan_image(&mut self, image: ImageBuffer<Luma<u8>, Vec<u8>>) -> Option<String>;
+    fn scan_image(&mut self, image: Image) -> Option<String>;
 }
 
 #[cfg(feature = "decode-backend-zbar")]
 mod zbar {
-    use super::{ImageBuffer, Luma, Scanner};
+    use super::{Image, Scanner};
 
     pub struct Zbar {
         scanner: keyfork_zbar::image_scanner::ImageScanner,
@@ -129,29 +135,25 @@ mod zbar {
     }
 
     impl Scanner for Zbar {
-        fn scan_image(
-            &mut self,
-            image: ImageBuffer<Luma<u8>, Vec<u8>>,
-        ) -> Option<String> {
+        fn scan_image(&mut self, image: Image) -> Option<String> {
             let image = keyfork_zbar::image::Image::from(image);
-            self.scanner.scan_image(&image).into_iter().next().map(|symbol| {
-                String::from_utf8_lossy(symbol.data()).into()
-            })
+            self.scanner
+                .scan_image(&image)
+                .into_iter()
+                .next()
+                .map(|symbol| String::from_utf8_lossy(symbol.data()).into())
         }
     }
 }
 
 #[cfg(feature = "decode-backend-rqrr")]
 mod rqrr {
-    use super::{ImageBuffer, Luma, Scanner};
+    use super::{Image, Scanner};
 
     pub struct Rqrr;
 
     impl Scanner for Rqrr {
-        fn scan_image(
-            &mut self,
-            image: ImageBuffer<Luma<u8>, Vec<u8>>,
-        ) -> Option<String> {
+        fn scan_image(&mut self, image: Image) -> Option<String> {
             let mut image = rqrr::PreparedImage::prepare(image);
             for grid in image.detect_grids() {
                 if let Ok((_, content)) = grid.decode() {
@@ -170,12 +172,23 @@ fn dbg_elapsed(count: u64, instant: Instant) {
     eprintln!("framerate: {count}/{elapsed} = {framerate}");
 }
 
+#[derive(Debug)]
+struct ScanQueue {
+    shutdown: bool,
+    images: Vec<Image>,
+}
+
 /// Continuously scan the `index`-th camera for a QR code.
 ///
 /// # Errors
 ///
 /// The function may return an error if the hardware is unable to scan video or if an image could
 /// not be decoded.
+///
+/// # Panics
+///
+/// The function may panic if a mutex is poisoned by a thread panicking, which should
+/// only happen during a mutex, or if it can't send a message over the mpsc channel.
 pub fn scan_camera(timeout: Duration, index: usize) -> Result<Option<String>, QRCodeScanError> {
     let device = Device::new(index)?;
     let mut fmt = device
@@ -185,6 +198,26 @@ pub fn scan_camera(timeout: Duration, index: usize) -> Result<Option<String>, QR
     device.set_format(&fmt)?;
     let mut stream = Stream::with_buffers(&device, Type::VideoCapture, 4)?;
     let start = Instant::now();
+
+    #[allow(unused)]
+    let mut count = 0;
+
+    let thread_count = 4;
+
+    std::thread::scope(|scope| {
+        let scan_queue = ScanQueue {
+            shutdown: false,
+            images: vec![],
+        };
+
+        let arced = Arc::new((Mutex::new(scan_queue), Condvar::new()));
+        let (tx, rx) = channel();
+
+        for _ in 0..thread_count {
+            let tx = tx.clone();
+            let arced = arced.clone();
+
+            scope.spawn(move || {
                 cfg_if::cfg_if! {
                     if #[cfg(feature = "decode-backend-zbar")] {
                         let mut scanner = zbar::Zbar::default();
@@ -195,23 +228,63 @@ pub fn scan_camera(timeout: Duration, index: usize) -> Result<Option<String>, QR
                     }
                 };
 
-    #[allow(unused)]
-    let mut count = 0;
+                let (queue_mutex, condvar) = &*arced;
+                loop {
+                    // NOTE: Carrying the `queue` variable through the loop, so we can
+                    // pass it through without re-locking, means that we don't drop the
+                    // lock on the mutex. Therefore, we unlock, then immediately
+                    // re-lock when we pass the value to wait_while().
+                    //
+                    // By holding onto the queue until we pass it back to the Condvar,
+                    // and checking shutdown, we ensure that there's no way we miss the
+                    // shutdown being set before we release the guard on the queue.
+                    let queue = queue_mutex.lock().expect(bug::bug!(POISONED_MUTEX));
+                    if queue.shutdown {
+                        break;
+                    }
+                    let mut queue = condvar
+                        .wait_while(queue, |queue| {
+                            queue.images.is_empty() || !queue.shutdown
+                        })
+                        .expect(bug::bug!(POISONED_MUTEX));
+                    if let Some(image) = queue.images.pop() {
+                        // drop the queue here since this is what's going to take time
+                        drop(queue);
+                        if let Some(content) = scanner.scan_image(image) {
+                            tx.send(content).expect(
+                                bug::bug!("A scanned image could not be sent")
+                            );
+                        }
+                    }
+                }
+            });
+        }
 
         while Instant::now().duration_since(start) < timeout {
+            if let Ok(content) = rx.try_recv() {
+                arced.0.lock().expect(bug::bug!(POISONED_MUTEX)).shutdown = true;
+                arced.1.notify_all();
+                return Ok(Some(content));
+            }
+
             count += 1;
             let (buffer, _) = stream.next()?;
             let image = ImageReader::new(Cursor::new(buffer))
                 .with_guessed_format()?
                 .decode()?
                 .to_luma8();
-        if let Some(content) = scanner.scan_image(image) {
-            // dbg_elapsed(count, start);
-            return Ok(Some(content));
-        }
+
+            arced
+                .0
+                .lock()
+                .expect(bug::bug!(POISONED_MUTEX))
+                .images
+                .push(image);
+            arced.1.notify_one();
         }
 
         // dbg_elapsed(count, start);
 
         Ok(None)
+    })
 }