phonic 0.16.0

Audio playback library
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

use std::sync::Arc;

use crossbeam_queue::ArrayQueue;

use crate::utils::smoothing::{apply_smoothed_panning, ExponentialSmoothedValue, SmoothedValue};

use super::{Source, SourceTime};

// -------------------------------------------------------------------------------------------------

/// Messages to control the panned source
pub enum PannedSourceMessage {
    SetPanning(f32), // new panning value
}

// -------------------------------------------------------------------------------------------------

/// A source which applies a pan factor to some other source's output
pub struct PannedSource<InputSource: Source + 'static> {
    source: InputSource,
    panning: ExponentialSmoothedValue,
    message_queue: Arc<ArrayQueue<PannedSourceMessage>>,
}

impl<InputSource: Source + 'static> PannedSource<InputSource> {
    pub fn new(source: InputSource, panning: f32) -> Self
    where
        InputSource: Source,
    {
        debug_assert!((-1.0..=1.0).contains(&panning), "Invalid panning factor");
        let panning = ExponentialSmoothedValue::new(panning, source.sample_rate());

        // we're expecting a single message only, as events are already scheduled by the mixer
        const MESSAGE_QUEUE_SIZE: usize = 1;
        let message_queue = Arc::new(ArrayQueue::new(MESSAGE_QUEUE_SIZE));

        Self {
            source,
            panning,
            message_queue,
        }
    }

    /// Returns the message queue for this source.
    pub fn message_queue(&self) -> Arc<ArrayQueue<PannedSourceMessage>> {
        self.message_queue.clone()
    }

    /// Access to the wrapped source.
    #[allow(unused)]
    pub fn input_source(&self) -> &InputSource {
        &self.source
    }
    /// Mut access to the wrapped source.
    pub fn input_source_mut(&mut self) -> &mut InputSource {
        &mut self.source
    }

    /// Set a new target panning level.
    pub fn set_panning(&mut self, panning: f32) {
        self.panning.set_target(panning);
    }

    /// Internal event handling
    fn process_messages(&mut self) {
        while let Some(msg) = self.message_queue.pop() {
            match msg {
                PannedSourceMessage::SetPanning(panning) => {
                    self.panning.set_target(panning);
                }
            }
        }
    }
}

impl<InputSource: Source + 'static> Source for PannedSource<InputSource> {
    fn channel_count(&self) -> usize {
        self.source.channel_count()
    }

    fn sample_rate(&self) -> u32 {
        self.source.sample_rate()
    }

    fn is_exhausted(&self) -> bool {
        self.source.is_exhausted()
    }

    fn weight(&self) -> usize {
        self.source.weight()
    }

    fn write(&mut self, output: &mut [f32], time: &SourceTime) -> usize {
        // process pending messages
        self.process_messages();

        // write input source
        let written = self.source.write(output, time);

        // apply panning
        let channel_count = self.source.channel_count();
        apply_smoothed_panning(&mut output[..written], channel_count, &mut self.panning);
        written
    }
}