rtaudio 0.3.6

Safe Rust wrapper and bindings for RtAudio
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
106
107
108
109
110
111
112

# RtAudio-rs
[![Documentation](https://docs.rs/rtaudio/badge.svg)](https://docs.rs/rtaudio)
[![Crates.io](https://img.shields.io/crates/v/rtaudio.svg)](https://crates.io/crates/rtaudio)
[![License](https://img.shields.io/crates/l/rtaudio.svg)](https://codeberg.org/Meadowlark/rtaudio-rs/src/branch/main/LICENSE)

Safe Rust wrapper and bindings for [RtAudio](https://github.com/thestk/rtaudio) (version 6).

# Usage Example

```rust
use rtaudio::{Api, Buffers, DeviceParams, SampleFormat, StreamInfo, StreamOptions, StreamStatus};

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    let out_device = host.default_output_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            None,
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();

    let mut phasor = 0.0;
    let phasor_inc = 440.0 / stream_handle.info().sample_rate as f32;

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input: _ } = buffers {
                    // By default, buffers are interleaved.
                    for frame in output.chunks_mut(2) {
                        // Generate a sine wave at 440 Hz at 50% volume.
                        let val = (phasor * std::f32::consts::TAU).sin() * 0.5;
                        phasor = (phasor + phasor_inc).fract();

                        frame[0] = val;
                        frame[1] = val;
                    }
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}
```

# Prerequisites

`CMake` is required on all platforms.

## Linux

```
apt install cmake pkg-config libasound2-dev libpulse-dev
```

If the `jack_linux` feature is enabled, then also install the jack development headers:
```
apt install libjack-dev
```

## MacOS

### Install CMake: Option 1

Download at https://cmake.org/.

### Install CMake: Option 2

Install with [Homebrew](https://brew.sh/):

```
brew install cmake
```

## Windows

### Install CMake

Download at https://cmake.org/.

# Features

By default, Jack on Linux and ASIO on Windows is disabled. You can enable them with the `jack_linux` and `asio` features.

```
rtaudio = { version = "0.3.2", features = ["jack_linux", "asio"] }
```

# Notes

Bindings were made from the official [C header](https://github.com/thestk/rtaudio/blob/master/rtaudio_c.h). No bindings to the C++ interface are provided.

This will build RtAudio from source. Don't forget to initialize git submodules (git submodule update --init) or clone with --recursive.

This currently builds a static library from source on all platforms. Once RtAudio version 6 is commonly available in Linux package managers I might change it to link to the dynamic library on Linux.

I haven't figured out how to get Jack on MacOS to work yet. If you know how to install and link the Jack libraries on MacOS, please let me know.

I haven't thoroughly tested every API on every platform yet. If you run into any bugs or issues with building, please create an issue.