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

#[macro_use]
extern crate bitflags;

mod channel;
mod coefficient;

// Export Channel outside.
pub use channel::Channel;
use coefficient::{Coefficient, MixingCoefficient};

use std::default::Default;
use std::fmt::Debug;
use std::ops::{AddAssign, Mul};

// A mixer mixing M-channel input data to N-channel output data.
// T::Coef is an associated type defined in MixingCoefficient, which indicates the type of the
// mixing coefficient that would be used for type T. When T is f32, the T::Coef is f32. When T
// is i16, the T::Coef is i32. When mixing data, a temporary variable with type T::Coef would be
// created to hold the mixing result. Since the type of input and output audio data is T,
// the methods provided from MixingCoefficient trait would be used to convert the value between
// type T and T::Coef.
#[derive(Debug)]
pub struct Mixer<T>
where
    T: Copy + Debug + MixingCoefficient,
    T::Coef: AddAssign + Copy + Debug + Default + Mul<T::Coef, Output = T::Coef>,
{
    coefficient: Coefficient<T>,
}

impl<T> Mixer<T>
where
    T: Copy + Debug + MixingCoefficient,
    T::Coef: AddAssign + Copy + Debug + Default + Mul<T::Coef, Output = T::Coef>,
{
    pub fn new(input_channels: &[Channel], output_channels: &[Channel]) -> Self {
        Self {
            coefficient: Coefficient::create(input_channels, output_channels),
        }
    }

    // To mix M-channel audio input data to N-channel output data, the data in output-channel i
    // is the sum of product of data in input-channel j and the coefficient for mixing from
    // input-channel j to output-channel i, for all j in M channels. That is,
    // output_data(i) = Σ coefficient(j, i) * input_data(j), for all j in [0, M),
    // where i is in [0, N) and coefficient is a function returning mixing coefficient from
    // input channel j to output channel i.
    pub fn mix(&self, input_buffer: &[T], output_buffer: &mut [T]) {
        assert_eq!(
            input_buffer.len(),
            self.input_channels().len(),
            "input slice must have the same size as the input channel's one."
        );
        assert_eq!(
            output_buffer.len(),
            self.output_channels().len(),
            "output slice must have the same size as the output channel's one."
        );
        for (i, output) in output_buffer.iter_mut().enumerate() {
            // T must implement Default that returns a zero value from default().
            let mut value = T::Coef::default(); // Create a zero value.
            for (j, input) in input_buffer.iter().enumerate() {
                // T::Coef needs to implement `AddAssign` and `Mul` to make `+=` and `*` work.
                // T needs to implement `Copy` so `*input` can be copied.
                value += self.coefficient.get(j, i) * T::to_coefficient_value(*input);
            }
            *output = T::from_coefficient_value(
                value,
                self.coefficient.would_overflow_from_coefficient_value(),
            );
        }
    }

    pub fn input_channels(&self) -> &[Channel] {
        &self.coefficient.input_channels()
    }

    pub fn output_channels(&self) -> &[Channel] {
        &self.coefficient.output_channels()
    }
}