moont-live 1.0.0

Real-time CM-32L MIDI sink using ALSA
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

// Copyright (C) 2021-2026 Geoff Hill <geoff@geoffhill.org>
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or (at
// your option) any later version. Read COPYING.LESSER.txt for details.

use alsa::pcm::{Access, Format, HwParams, PCM};
use alsa::{Direction, ValueOr};

pub struct AudioOut {
    pcm: PCM,
}

impl AudioOut {
    pub fn open(device: &str, period_frames: u64) -> AudioOut {
        let pcm = PCM::new(device, Direction::Playback, false)
            .expect("failed to open ALSA PCM device");

        {
            let hwp = HwParams::any(&pcm)
                .expect("failed to get ALSA hardware params");
            hwp.set_access(Access::RWInterleaved)
                .expect("failed to set access mode");
            hwp.set_format(Format::s16())
                .expect("failed to set format S16_LE");
            hwp.set_channels(2).expect("failed to set channels to 2");
            hwp.set_rate(moont::SAMPLE_RATE, ValueOr::Nearest)
                .expect("failed to set sample rate");
            hwp.set_period_size(period_frames as i64, ValueOr::Nearest)
                .expect("failed to set period size");
            hwp.set_periods(4, ValueOr::Nearest)
                .expect("failed to set period count");
            pcm.hw_params(&hwp)
                .expect("failed to apply hardware params");

            let rate = hwp.get_rate().unwrap();
            if rate != moont::SAMPLE_RATE {
                eprintln!(
                    "Warning: requested {}Hz, got {}Hz",
                    moont::SAMPLE_RATE,
                    rate
                );
            }
        }

        AudioOut { pcm }
    }

    pub fn writei(&self, buf: &[i16]) {
        let io = self.pcm.io_i16().expect("failed to get PCM I/O");
        match io.writei(buf) {
            Ok(_) => {}
            Err(e) => {
                self.pcm
                    .try_recover(e, true)
                    .expect("failed to recover from xrun");
                let _ = io.writei(buf);
            }
        }
    }
}