kamera 0.0.2

Camera API with a reduced feature set for basic use cases and learning
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use super::mf::*;

use std::{sync::mpsc::*, time::Duration};

use windows::Win32::Media::MediaFoundation::*;

#[allow(unused)]
#[derive(Debug)]
pub struct Camera {
    engine: IMFCaptureEngine,
    device: Device,
    event_rx: Receiver<CaptureEngineEvent>,
    sample_rx: Receiver<Option<IMFSample>>,
    event_cb: IMFCaptureEngineOnEventCallback,
    sample_cb: IMFCaptureEngineOnSampleCallback,
}

#[derive(Debug)]
pub struct Frame {
    buffer: LockedBuffer,
}

pub struct FrameData<'a> {
    data: &'a [u8],
}

impl Camera {
    pub fn new_default_device() -> Self {
        co_initialize_multithreaded();
        media_foundation_startup().expect("media_foundation_startup");

        let engine = new_capture_engine().unwrap();
        let (event_tx, event_rx) = channel::<CaptureEngineEvent>();
        let (sample_tx, sample_rx) = channel::<Option<IMFSample>>();
        let event_cb = CaptureEventCallback { event_tx }.into();
        let sample_cb = CaptureSampleCallback { sample_tx }.into();

        let devices = Device::enum_devices();
        let Some(device) = devices.first().cloned() else { todo!() };

        init_capture_engine(&engine, Some(&device.source), &event_cb).unwrap();

        let camera = Camera { engine, device, event_rx, sample_rx, event_cb, sample_cb };
        camera.wait_for_event(CaptureEngineEvent::Initialized);
        camera.prepare_source_sink();
        camera
    }

    pub fn start(&self) {
        unsafe { self.engine.StartPreview().unwrap() }
    }

    pub fn stop(&self) {
        capture_engine_stop_preview(&self.engine).unwrap();
    }

    pub fn wait_for_frame(&self) -> Option<Frame> {
        self.sample_rx
            // TODO sometimes running two engines on the same camera breaks frame delivery, so wait not too long
            .recv_timeout(Duration::from_secs(3))
            .ok()
            .flatten()
            .and_then(|sample| {
                let Some(mt) = capture_engine_sink_get_media_type(&self.engine).ok() else {
                    return None;
                };
                let width = mt.frame_width();
                let height = mt.frame_height();
                sample_to_locked_buffer(&sample, width, height).ok()
            })
            .map(|buffer: LockedBuffer| Frame { buffer })
    }

    pub fn change_device(&mut self) {
        let devices: Vec<Device> = enum_device_sources().into_iter().map(Device::new).collect();
        let Some(index) = devices.iter().position(|d| d.id() == self.device.id()) else { return };
        let new_index = (index + 1) % devices.len();

        if new_index == index {
            return;
        }
        let new_device = devices[new_index].clone();

        let engine = new_capture_engine().unwrap();
        let (event_tx, event_rx) = channel::<CaptureEngineEvent>();
        let (sample_tx, sample_rx) = channel::<Option<IMFSample>>();
        let event_cb = CaptureEventCallback { event_tx }.into();
        let sample_cb = CaptureSampleCallback { sample_tx }.into();

        init_capture_engine(&engine, Some(&new_device.source), &event_cb).unwrap();

        *self = Camera { engine, device: new_device, event_rx, sample_rx, event_cb, sample_cb };
        self.wait_for_event(CaptureEngineEvent::Initialized);
        self.prepare_source_sink();
        self.start(); // TODO watch out about playing state
    }
}

impl Camera {
    fn prepare_source_sink(&self) {
        capture_engine_prepare_sample_callback(&self.engine, &self.sample_cb).unwrap();
    }

    fn wait_for_event(&self, event: CaptureEngineEvent) {
        self.event_rx.iter().find(|e| e == &event);
    }
}

impl Frame {
    pub fn data(&self) -> FrameData {
        FrameData { data: self.buffer.data() }
    }

    pub fn size_u32(&self) -> (u32, u32) {
        (self.buffer.width, self.buffer.height)
    }
}

impl<'a> FrameData<'a> {
    pub fn data_u8(&self) -> &[u8] {
        self.data
    }

    pub fn data_u32(&self) -> &[u32] {
        let (a, data, b) = unsafe { self.data.align_to() };
        debug_assert!(a.is_empty());
        debug_assert!(b.is_empty());
        data
    }
}