rust-video-display/src/main.rs

extern crate rscam;
use std::{env, time::Instant};

use fltk::{
    app::App,
    enums::ColorDepth,
    frame::Frame,
    image::RgbImage,
    prelude::{GroupExt, WidgetBase, WidgetExt},
    window::Window,
};
use image::Rgb;
use rscam::{Camera, Config};

fn main() {
    let args: Vec<String> = env::args().collect();
    println!("{:?}", args);
    let camera_device = &args[1];
    let w = args[2].clone();
    let h = args[3].clone();
    let fps = args[4].clone();
    let mut camera_open = false;
    let app = App::default();
    let mut camera_window = Window::new(100, 100, 400, 300, "Camera Video Output Window");
    let mut camera_frame = Frame::default_fill();
    camera_window.end();
    camera_window.show();
    let mut color_window = Window::new(100, 600, 400, 300, "Video Output Window");
    let mut color_frame = Frame::default_fill();
    color_window.end();
    color_window.show();
    // app.run().unwrap();
    // 打开摄像头设备
    let mut camera = Camera::new(camera_device).unwrap();

    // 配置摄像头参数
    match camera.start(&Config {
        // use command 'v4l2-ctl --list-formats-ext' see more...
        interval: (1, parse(fps)),        // 设置帧率为 30fps
        resolution: (parse(w), parse(h)), // 设置分辨率为 640x480
        format: b"MJPG",                  // 设置图像格式为 MJPG
        ..Default::default()
    }) {
        Ok(_) => camera_open = true,
        Err(e) => {
            eprint!("Open Camera Error:{}", e)
        }
    }
    let mut w = 0;
    let mut h = 0;
    if camera_open {
        loop {
            // 捕获一帧图像
            match camera.capture() {
                Ok(data) => {
                    let start = Instant::now();
                    let img = image::load_from_memory(&data).unwrap();
                    let l_data = img.to_luma8();
                    let mut rgb_data = img.to_rgb8();
                    if w == 0 {
                        w = l_data.width() as i32;
                        h = l_data.height() as i32;
                    }
                    crossbeam::scope(|_| {
                        for tmp_x in 0..30 {
                            for tmp_y in 0..60 {
                                rgb_data.put_pixel(tmp_x, tmp_y, Rgb([102, 204, 255]));
                            }
                        }
                        let fltk_rgb_image =
                            RgbImage::new(rgb_data.as_raw(), w, h, ColorDepth::Rgb8).unwrap();
                        color_frame.set_image(Some(fltk_rgb_image));
                        color_frame.set_size(w, h);
                        color_frame.redraw();
                        let duration = start.elapsed();
                        println!("L8 Frame Draw use time: {:?}", duration);
                    })
                    .unwrap();
                    crossbeam::scope(|_| {
                        let fltk_l_image =
                            RgbImage::new(l_data.as_raw(), w, h, ColorDepth::L8).unwrap();
                        camera_frame.set_image(Some(fltk_l_image));
                        // 通过重新调整尺寸从而刷新图像
                        camera_frame.redraw();
                        let duration = start.elapsed();
                        println!("RGB8 Frame Draw use time: {:?}", duration);
                    })
                    .unwrap();
                }
                Err(e) => {
                    eprintln!("捕获错误: {}", e);
                    continue;
                }
            }
            app.wait();
        }
    }
}

/// 从 args 传入的数字转换为 u32
fn parse(str: String) -> u32 {
    match str.parse::<u32>() {
        Ok(data) => return data,
        Err(e) => {
            eprintln!("Error:${}", e);
            println!("Note: rust-v4l2 <video_device> <width> <height> <interval>");
            return 0;
        }
    }
}