dynwave 0.2.0

Dynamic audio player based on fixed samples stream
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

use cpal::{Data, FromSample, Sample, SampleFormat, SizedSample};
use ringbuf::{traits::Consumer, HeapCons};

// Type alias for the processing function - matches the required callback signature
type ProcessingFn = Box<dyn FnMut(&mut Data, &cpal::OutputCallbackInfo) + Send + 'static>;

// Function to create the appropriate processing function based on format
pub fn create_output_processor<T>(
    format: SampleFormat,
    mut buffer_consumer: HeapCons<T>,
) -> ProcessingFn
where
    T: Sample + SizedSample + Send + 'static,

    // sadly, cpal uses macro to generate those, and there is no auto way
    // to use the type system to, even though it seems that it makes sense
    // to have `T : FromSample<W> where W: SizedSample`?
    i8: FromSample<T>,
    i16: FromSample<T>,
    i32: FromSample<T>,
    i64: FromSample<T>,
    u8: FromSample<T>,
    u16: FromSample<T>,
    u32: FromSample<T>,
    u64: FromSample<T>,
    f32: FromSample<T>,
    f64: FromSample<T>,
{
    match format {
        SampleFormat::I8 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<i8>().expect("Valid format") {
                *sample = i8::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        SampleFormat::I16 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<i16>().expect("Valid format") {
                *sample = i16::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        SampleFormat::I32 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<i32>().expect("Valid format") {
                *sample = i32::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        SampleFormat::I64 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<i64>().expect("Valid format") {
                *sample = i64::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        SampleFormat::U8 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<u8>().expect("Valid format") {
                *sample = u8::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        SampleFormat::U16 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<u16>().expect("Valid format") {
                *sample = u16::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        SampleFormat::U32 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<u32>().expect("Valid format") {
                *sample = u32::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        SampleFormat::U64 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<u64>().expect("Valid format") {
                *sample = u64::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        SampleFormat::F32 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<f32>().expect("Valid format") {
                *sample = f32::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        SampleFormat::F64 => Box::new(move |data, _| {
            for sample in data.as_slice_mut::<f64>().expect("Valid format") {
                *sample = f64::from_sample(buffer_consumer.try_pop().unwrap_or(T::EQUILIBRIUM));
            }
        }),
        e => panic!("Format {e:?} isn't supported"),
    }
}