mtrack 0.12.0

A multitrack audio and MIDI player for live performances.
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

// Copyright (C) 2026 Michael Wilson <mike@mdwn.dev>
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, version 3.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <https://www.gnu.org/licenses/>.
//
// Shared context for audio playback (song and sample sources). Carries
// format, buffer sizes, and shared pools so call sites don't thread many
// separate arguments.
//

use std::sync::Arc;

use crate::audio::format::TargetFormat;
use crate::audio::sample_source::BufferFillPool;
use crate::config::ResamplerType;

/// Context passed into playback and source-creation paths so they can
/// obtain target format, buffer size, and shared resources (e.g. buffer
/// fill pool) without many separate parameters.
#[derive(Clone)]
pub struct PlaybackContext {
    /// Target sample rate, format, and bit depth for output.
    pub target_format: TargetFormat,
    /// Device buffer size in frames (used for BufferedSampleSource capacity
    /// and for file decode buffer size).
    pub buffer_size: usize,
    /// Shared pool for prefilling BufferedSampleSource. If None, sources
    /// are not wrapped in BufferedSampleSource.
    pub buffer_fill_pool: Option<Arc<BufferFillPool>>,
    /// Which resampling algorithm to use when sample rates differ.
    pub resampler_type: ResamplerType,
}

impl PlaybackContext {
    /// Builds a context from the given format, buffer size, and optional pool.
    pub fn new(
        target_format: TargetFormat,
        buffer_size: usize,
        buffer_fill_pool: Option<Arc<BufferFillPool>>,
        resampler_type: ResamplerType,
    ) -> Self {
        Self {
            target_format,
            buffer_size,
            buffer_fill_pool,
            resampler_type,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn new_without_pool() {
        let fmt = TargetFormat::default();
        let ctx = PlaybackContext::new(fmt.clone(), 1024, None, ResamplerType::Sinc);
        assert_eq!(ctx.target_format, fmt);
        assert_eq!(ctx.buffer_size, 1024);
        assert!(ctx.buffer_fill_pool.is_none());
    }

    #[test]
    fn new_with_pool() {
        let fmt = TargetFormat::default();
        let pool = Arc::new(BufferFillPool::new(1).unwrap());
        let ctx = PlaybackContext::new(fmt, 512, Some(pool.clone()), ResamplerType::Fft);
        assert!(ctx.buffer_fill_pool.is_some());
        assert_eq!(ctx.buffer_size, 512);
    }

    #[test]
    fn clone() {
        let fmt = TargetFormat::default();
        let ctx = PlaybackContext::new(fmt, 256, None, ResamplerType::Sinc);
        let ctx2 = ctx.clone();
        assert_eq!(ctx2.buffer_size, 256);
    }
}