kithara-audio 0.0.1-alpha2

Audio pipeline: worker thread, effects chain, resampling.
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

use kithara_platform::{
    sync::Mutex,
    thread::{self, Thread},
};

#[derive(Default)]
pub(crate) struct ThreadWake {
    waiter: Mutex<Option<Thread>>,
}

impl ThreadWake {
    pub(crate) fn register_current(&self) {
        *self.waiter.lock_sync() = Some(thread::current());
    }
}

impl crate::runtime::WakeSignal for ThreadWake {
    fn wake(&self) {
        let waiter = self.waiter.lock_sync().as_ref().cloned();
        if let Some(waiter) = waiter {
            waiter.unpark();
        }
    }
}

#[cfg(test)]
mod tests {
    use std::{
        sync::{
            Arc,
            atomic::{AtomicBool, Ordering},
        },
        time::Duration,
    };

    use kithara_platform::thread::{park_timeout, sleep, spawn};
    use kithara_test_utils::kithara;

    use super::ThreadWake;
    use crate::runtime::WakeSignal;

    #[kithara::test]
    fn wake_unparks_registered_thread() {
        #[cfg(not(target_arch = "wasm32"))]
        {
            let wake = Arc::new(ThreadWake::default());
            let done = Arc::new(AtomicBool::new(false));
            let worker_wake = Arc::clone(&wake);
            let worker_done = Arc::clone(&done);

            let join = spawn(move || {
                worker_wake.register_current();
                park_timeout(Duration::from_secs(1));
                worker_done.store(true, Ordering::Release);
            });

            sleep(Duration::from_millis(10));
            wake.wake();
            join.join().expect("wake test thread");
            assert!(done.load(Ordering::Acquire));
        }
    }
}