symphonium 0.9.2

An unofficial easy-to-use wrapper around Symphonia for loading audio files
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

# Symphonium

[![Documentation](https://docs.rs/symphonium/badge.svg)](https://docs.rs/symphonium)
[![Crates.io](https://img.shields.io/crates/v/symphonium.svg)](https://crates.io/crates/symphonium)
[![License](https://img.shields.io/crates/l/symphonium.svg)](https://codeberg.org/Meadowlark/symphonium/blob/main/LICENSE-MIT)

An unofficial easy-to-use wrapper around [Symphonia](https://github.com/pdeljanov/Symphonia) for loading audio files. It also handles resampling at load-time.

The resulting `DecodedAudio` resources are stored in their native sample format whenever possible to save on memory, and have convenience methods to fill a buffer with `f32` samples from any arbitrary position in the resource in realtime during playback. Alternatively you can use the `DecodedAudioF32` resource if you only need samples in the `f32` format.

## Example

```rust
let target_sample_rate = NonZeroU32::new(44100).unwrap();

// An optional cache to re-use decoders and resamplers.
let cache = SymphoniumCache::default();

// Probe the audio file.
let probed = symphonium::probe_from_file(
    &file_path,
    // A custom codec prober. Set to `None` to use the default one from symphonia.
    None,
)
.unwrap();

// Decode the probed data.
let audio_data = symphonium::decode(
    probed,
    &DecodeConfig::default(),
    // Set to `None` to keep the original sample rate of the file.
    Some(target_sample_rate),
    // Set to `None` if no cache is needed.
    Some(&cache),
    // A custom codec registry. Set to `None` to use the default one from symphonia.
    None,
)
.unwrap();

// Fill a stereo buffer with samples starting at frame 100.
let mut buf_l = vec![0.0f32; 512];
let mut buf_r = vec![0.0f32; 512];
audio_data.fill_stereo(100, &mut buf_l, &mut buf_r);

// Alternatively, if you don't need to save memory, you can
// decode directly to an `f32` format.
let probed = symphonium::probe_from_file(&file_path, None).unwrap();
let audio_data_f32 = symphonium::decode_f32(
        probed,
        &DecodeConfig::default(),
        Some(target_sample_rate),
        Some(&cache),
        None,
    )
    .unwrap();

// Print info about the data (`data` is a `Vec<Vec<f32>>`).
println!("num channels: {}", audio_data_f32.data.len());
println!("num frames: {}", audio_data_f32.data[0].len());
```
## Features

By default, only `wav` and `ogg` support is enabled. If you need more formats, enable them as features in your `Cargo.toml` file like this:

`symphonium = { version = "0.9", features = ["mp3", "flac"] }`

Available codecs:

* `aac`
* `adpcm`
* `alac`
* `flac`
* `mp1`
* `mp2`
* `mp3`
* `pcm`
* `vorbis`

Available container formats:

* `caf`
* `isomp4`
* `mkv`
* `ogg`
* `aiff`
* `wav`

Alternatively you can enable the `all` feature if you want everything, or the `open-standards` feature if you want all of the royalty-free open-source standards.