Rust bindings for the soloud audio engine library

Overview

soloud-rs

Documentation Crates.io License Build

A crossplatform Rust bindings for the soloud audio engine library.

Supported formats: wav, mp3, ogg, flac. The library also comes with a speech synthesizer.

Usage

[dependencies]
soloud = "0.3"

Or to use the git repo:

[dependencies]
soloud = { git = "https://github.com/moalyousef/soloud-rs" }

To play audio:

use soloud::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut sl = Soloud::default()?;

    let mut wav = audio::Wav::default();

    wav.load(&std::path::Path::new("sample.wav"))?;

    sl.play(&wav); // calls to play are non-blocking, so we put the thread to sleep
    while sl.voice_count() > 0 {
        std::thread::sleep(std::time::Duration::from_millis(100));
    }

    wav.load(&std::path::Path::new("Recording.mp3"))?;
    
    sl.play(&wav);
    while sl.voice_count() > 0 {
        std::thread::sleep(std::time::Duration::from_millis(100));
    }

    Ok(())
}

To play speech:

use soloud::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut sl = Soloud::default()?;

    let mut speech = audio::Speech::default();

    speech.set_text("Hello World")?;

    sl.play(&speech);
    while sl.active_voice_count() > 0 {
        std::thread::sleep(std::time::Duration::from_millis(100));
    }

    speech.set_text("1 2 3")?;

    sl.play(&speech);
    while sl.active_voice_count() > 0 {
        std::thread::sleep(std::time::Duration::from_millis(100));
    }

    speech.set_text("Can you hear me?")?;

    sl.play(&speech);
    while sl.active_voice_count() > 0 {
        std::thread::sleep(std::time::Duration::from_millis(100));
    }
    
    Ok(())
}

To add a filter:

use soloud::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut sl = Soloud::default()?;

    let mut wav = audio::Wav::default();
    let mut filt = filter::EchoFilter::default();
    filt.set_params(0.2)?; // sets the delay

    wav.load(&std::path::Path::new("sample.wav"))?;
    wav.set_filter(0, Some(&filt));

    sl.play(&wav);
    while sl.voice_count() > 0 {
        std::thread::sleep(std::time::Duration::from_millis(100));
    }

    Ok(())
}

The examples can be found in the soloud/examples directory. They can be run using:

$ cargo run --example simple
$ cargo run --example speech
$ cargo run --example filter
$ cargo run --example load_mem

You will need to have valid "sample.wav" and "Recording.mp3" audio files in the project root. Or you can change the paths to point to any supported audio file.

There is also a demo gui application (using fltk) here.

Dependencies

A Rust compiler, C++ compiler, Cargo, CMake and git (all these need to be in your PATH). This crate uses the miniaudio backend by default which assumes default sound drivers are functional.

Backends

The default backend is miniaudio, however Soloud supports several backends to varying degrees. To enable support of a certain backend, alsa for example:

[dependencies]
soloud = { version = "0.3", default-features = false, features = ["alsa"] }

This also assumes that those libraries headers are in your include path where CMake can find them, otherwise you can set it via the command line (posix):

$ export CXXFLAGS="-I /path/to/include"

or for Windows:

$ set CXXFLAGS="-I C:\\path\\to\\include"

The same can be done for CFLAGS if needed.

Supported backends:

  • miniaudio
  • oss
  • alsa
  • sdl2
  • sdl2-static
  • portaudio
  • openal
  • xaudio2
  • winmm
  • wasapi
  • opensles
  • coreaudio
  • jack
Comments
  • Support for other audio backends

    Support for other audio backends

    I'm currently trying to use soloud-rs for my game engine, but it doesn't seem to work very well performance-wise (audio crackles a lot even with very big buffer sizes). IMO there should be support for a few other backends (not necessarily all of them) to see where this issue is coming from, and personally I think it will help with debugging future problems as well.

    opened by ghost 33
  • Cannot load files containing unicode.

    Cannot load files containing unicode.

    When trying to load a file containing unicode characters I get the error Internal(FileNotFound).

    let mut wav = audio::Wav::default();
    
    wav.load(Path::new("覆.flac"))?;
    //Crashes here ^     
    

    I'm pretty sure this has something to do with const char * not supporting unicode, so I'm not sure if this is a problem with the bindings.

    I've been able to alleviate the problem on Windows by getting the short path and using that instead.

    let p = "覆.flac";
    //convert path to null terminated string
    let long_path: Vec<u16> = p.encode_utf16().chain(Some(0)).collect();
    //get length of short path
    let len = GetShortPathNameW(long_path.as_ptr(), null_mut(), 0);
    
    let mut short_path = vec![0; len as usize];
    
    //get short path
    GetShortPathNameW(long_path.as_ptr(), short_path.as_mut_ptr(), len);
    
    //convert short path to string
    let mut path = String::from_utf16(&short_path).unwrap();
    //remove null terminator
    path.pop();
    
    assert_eq!(path, "3342~1.FLA");
    

    Edit: Short paths only seem to work on certain files, It might have something to do with file permissions. All I can say is that it's super broken.

    opened by zX3no 11
  • Questions on trying to create a simple audio player

    Questions on trying to create a simple audio player

    Once I've loaded a track using wav.load(), the user can then play it or pause it (in theory) as follows:

        fn on_play_or_pause(&mut self) {
            if self.playing { // self.player: soloud::Soloud
                self.player.pause(self.handle); // self.handle: soloud::Handle
            } else {
                self.handle = self.player.play(&self.wav);
                let sender = self.sender.clone();
                fltk::app::add_timeout(0.2, move || {
                    sender.send(Action::Tick);
                });
            }
            self.playing = !self.playing;
    }
    

    But what happens is that pause is ignored.

    What I want to be able to do is:

    1. Play from the start
    2. Pause
    3. Resume from where paused
    4. Extract meta-data (e.g., title, album, track number)

    Thanks.

    opened by mark-summerfield 8
  • Weird behaviour when seeking

    Weird behaviour when seeking

    Seeking does not seem to work correctly. After moving the stream foward 32 seconds I would expect the position to be 32 but instead I get 8?

    let handle = sl.play(&wav);
    dbg!(sl.stream_position(handle)); //"0.0"
    
    //works fine
    sl.seek(handle, 12.0)?;
    dbg!(sl.stream_position(handle)); //"12.0"
    
    //expected 32
    sl.seek(handle, 20.0)?;
    dbg!(sl.stream_position(handle)); //"8.0"
    
    
    opened by zX3no 8
  • Garbled sound

    Garbled sound

    Describe the bug All examples result in just noise coming out of speakers when using the miniaudio backend.

    To Reproduce Steps to reproduce the behavior:

    1. Clone repo
    2. cargo run --example=speech or cargo run --example=simple
    3. Garbled sound vaguely resembling speech/sample.wav plays out of speakers.

    Expected behavior Speech or sample plays.

    Desktop (please complete the following information):

    • OS: Arch Linux
    • Output of cargo build -vv
          Fresh cc v1.0.71
          Fresh paste v1.0.5
          Fresh bitflags v1.3.2
          Fresh cmake v0.1.46
          Fresh soloud-sys v1.0.0 (/home/t/Personal/chime/soloud-rs/soloud-sys)
          Fresh soloud v1.0.0 (/home/t/Personal/chime/soloud-rs/soloud)
       Finished dev [unoptimized + debuginfo] target(s) in 0.00s
    

    Additional context The problem remains even when I compiled using cross - i.e., even while my toolchain was (presumably?) completely bypassed, and on a completely different machine (Raspberry Pi w/ Raspbian) than my development machine. Sound obviously otherwise works on both systems, and I was even able to use the 'miniaudio' Python library with no issues. Additionally, trying to use the alsa backend fails with "UnknownError" on my machine, and results in a slightly different, but still unintelligible output on the Raspberry Pi. I have also tried adjusting the sample rate, buffer size and channel number on the Soloud object, with seemingly no effects.

    opened by tmladek 5
  • Way to create new audio sources

    Way to create new audio sources

    I can't seem to find a way to create new audio sources in the documentation or in the source code. It is possible to do so from the Rust side, like a trait to implement of some sort?

    I think this chapter from the SoLoud article is relevant: https://sol.gfxile.net/soloud/newsoundsources.html

    opened by ghost 5
  • Playing sound freezes/slows down my game

    Playing sound freezes/slows down my game

    This is probably not a bug with soloud-rs but with my lack of understanding of how sound works and muilthreading. Does anyone have guidance on what I need to learn to fix this?

    opened by jestarray 5
  • Sound is not playing while waiting for mpsc receiver

    Sound is not playing while waiting for mpsc receiver

    I'm tryint to use soloud-rs in a tokio application. I did put soloud into its own thread with an mpsc channel to control playback, but it never plays any sound:

    thread::spawn(move || {
        let mut soloud = Soloud::default().unwrap();
    
        while let Some(command) = soloud_rx.blocking_recv() {
            match command {
                SoloudCommand::PlayFile { path, get_length } => {
                    let mut wav = audio::Wav::default();
                    wav.load(path).unwrap();
                    soloud.play(&wav);
    
                    if let Some(get_length) = get_length {
                        let _ = get_length.send(Duration::from_secs_f64(wav.length()));
                    }
                },
            }
        }
    });
    

    But when I do introduce a sleep after the soloud.play() call, it will start playing sounds. This is not ideal of course, since that would make it impossible to play multiple sounds in parallel.

    I'm not sure if I'm missing something, but AFAIK soloud plays sounds in a different thread, so waiting for more commands on the controller thread should not prevent soloud from playing, correct?

    opened by DASPRiD 4
  • Is this supposed to work on Ubuntu 18.04

    Is this supposed to work on Ubuntu 18.04

    because compilation fails:

        Blocking waiting for file lock on build directory
       Compiling soloud-sys v1.0.2
    error: failed to run custom build command for `soloud-sys v1.0.2`
    
    Caused by:
      process didn't exit successfully: `/home/decades/calibration/target/debug/build/soloud-sys-52d783e35b4127a6/build-script-main` (exit status: 101)
      --- stdout
      cargo:rerun-if-changed=build/android.rs
      cargo:rerun-if-changed=build/link.rs
      cargo:rerun-if-changed=build/main.rs
      cargo:rerun-if-changed=build/source.rs
      cargo:rerun-if-env-changed=CC
      cargo:rerun-if-env-changed=CXX
      cargo:rerun-if-env-changed=CFLAGS
      cargo:rerun-if-env-changed=CXXFLAGS
      cargo:rerun-if-changed=sys/CMakeLists.txt
      cargo:rerun-if-changed=sys/soloud_new.cpp
      cargo:rerun-if-changed=sys/soloud_derives.h
      cargo:rerun-if-changed=sys/soloud_derives.cpp
      CMAKE_TOOLCHAIN_FILE_x86_64-unknown-linux-gnu = None
      CMAKE_TOOLCHAIN_FILE_x86_64_unknown_linux_gnu = None
      HOST_CMAKE_TOOLCHAIN_FILE = None
      CMAKE_TOOLCHAIN_FILE = None
      CMAKE_PREFIX_PATH_x86_64-unknown-linux-gnu = None
      CMAKE_PREFIX_PATH_x86_64_unknown_linux_gnu = None
      HOST_CMAKE_PREFIX_PATH = None
      CMAKE_PREFIX_PATH = None
      CMAKE_x86_64-unknown-linux-gnu = None
      CMAKE_x86_64_unknown_linux_gnu = None
      HOST_CMAKE = None
      CMAKE = None
      running: "cmake" "/home/decades/.cargo/registry/src/github.com-1ecc6299db9ec823/soloud-sys-1.0.2/sys" "-G" "Ninja" "-DWITH_MINIAUDIO=ON" "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON" "-DCMAKE_INSTALL_PREFIX=/home/decades/calibration/target/debug/build/soloud-sys-f91a35d357ff0bab/out" "-DCMAKE_C_FLAGS= -ffunction-sections -fdata-sections -fPIC -m64" "-DCMAKE_C_COMPILER=/usr/bin/cc" "-DCMAKE_CXX_FLAGS= -ffunction-sections -fdata-sections -fPIC -m64" "-DCMAKE_CXX_COMPILER=/usr/bin/c++" "-DCMAKE_ASM_FLAGS= -ffunction-sections -fdata-sections -fPIC -m64" "-DCMAKE_ASM_COMPILER=/usr/bin/cc" "-DCMAKE_BUILD_TYPE=Release"
      -- Configuring incomplete, errors occurred!
      See also "/home/decades/calibration/target/debug/build/soloud-sys-f91a35d357ff0bab/out/build/CMakeFiles/CMakeOutput.log".
    
      --- stderr
      fatal: Kein Git-Repository (oder irgendeines der Elternverzeichnisse): .git
      CMake Error at CMakeLists.txt:45 (add_compile_definitions):
        Unknown CMake command "add_compile_definitions".
    
    
      thread 'main' panicked at '
      command did not execute successfully, got: exit status: 1
    
      build script failed, must exit now', /home/decades/.cargo/registry/src/github.com-1ecc6299db9ec823/cmake-0.1.48/src/lib.rs:975:5
      note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
    
    
    opened by neilyoung 3
  • seg fault -> cannot call set global volume more than once in the same program

    seg fault -> cannot call set global volume more than once in the same program

    Describe the bug im trying to create 2 Soloud instances in the name scope and set the global volume to some value also 2 times.

    after running the code i get segfault core dumped.

    To Reproduce Steps to reproduce the behavior:

    1. get this code
        let mut sl = Soloud::default()?;
        sl.set_global_volume(3.0);
    
        let mut wav = audio::Wav::default();
    
        wav.load("noice.mp3")?;
    
    
        let mut sl2 = Soloud::default()?;
        sl2.set_global_volume(3.0);
    
        let mut wav2 = audio::Wav::default();
        wav2.load("bizwarn_minus_15.wav")?;
    
    1. cargo run
    2. the error is
    Assertion 'm->state == STATE_PASSIVE' failed at ../pulseaudio/src/pulse/mainloop.c:808, function pa_mainloop_prepare(). Aborting.
    [1]    723251 IOT instruction (core dumped)  cargo run -q --example simple
    

    and also i get this error:

    Assertion 's' failed at ../pulseaudio/src/pulse/stream.c:1708, function pa_stream_drain(). Aborting.
    [1]    723328 IOT instruction (core dumped)  
    

    the error from the same code its kinda random.

    Expected behavior instantiate 2 Soloud objects and set the global volume.

    Desktop (please complete the following information):

    • OS: Manjaro Linux
    • Version [after Pahvo]
    • Output of cargo build -vv
    ❱  cargo build -vv
           Fresh autocfg v1.1.0
           Fresh unicode-xid v0.2.2
           Fresh cfg-if v1.0.0
           Fresh cc v1.0.73
           Fresh version_check v0.9.4
           Fresh pin-project-lite v0.2.8
           Fresh gimli v0.26.1
           Fresh cache-padded v1.2.0
           Fresh bitflags v1.3.2
           Fresh adler v1.0.2
           Fresh event-listener v2.5.2
           Fresh waker-fn v1.1.0
           Fresh futures-io v0.3.21
           Fresh slab v0.4.6
           Fresh fastrand v1.7.0
           Fresh rustc-demangle v0.1.21
           Fresh parking v2.0.0
           Fresh once_cell v1.10.0
           Fresh byteorder v1.4.3
           Fresh regex-syntax v0.6.25
           Fresh ppv-lite86 v0.2.16
           Fresh static_assertions v1.1.0
           Fresh siphasher v0.3.10
           Fresh lazy_static v1.4.0
           Fresh async-task v4.2.0
           Fresh sha1_smol v1.0.0
           Fresh easy-parallel v3.2.0
           Fresh pin-utils v0.1.0
           Fresh futures-sink v0.3.21
           Fresh hex v0.4.3
           Fresh paste v1.0.7
           Fresh termcolor v1.1.3
           Fresh byte-slice-cast v1.2.1
           Fresh hashbrown v0.11.2
           Fresh pathdiff v0.2.1
           Fresh heck v0.4.0
           Fresh iana-time-zone v0.1.31
           Fresh itoa v1.0.1
           Fresh num_threads v0.1.5
           Fresh strsim v0.10.0
           Fresh ryu v1.0.9
           Fresh textwrap v0.15.0
           Fresh xdg-utils v0.4.0
           Fresh cmake v0.1.48
           Fresh addr2line v0.17.0
           Fresh concurrent-queue v1.2.2
           Fresh async-lock v2.5.0
           Fresh sha1 v0.6.1
           Fresh phf_shared v0.10.0
           Fresh open v2.1.1
           Fresh proc-macro2 v1.0.36
           Fresh memchr v2.4.1
           Fresh futures-core v0.3.21
           Fresh log v0.4.16
           Fresh libc v0.2.121
           Fresh futures-task v0.3.21
           Fresh const_fn v0.4.9
           Fresh phf v0.10.1
           Fresh quote v1.0.17
           Fresh miniz_oxide v0.4.4
           Fresh getrandom v0.2.6
           Fresh object v0.27.1
           Fresh aho-corasick v0.7.18
           Fresh futures-lite v1.12.0
           Fresh socket2 v0.4.4
           Fresh polling v2.2.0
           Fresh ordered-stream v0.0.1
           Fresh async-broadcast v0.3.4
           Fresh async-channel v1.6.1
           Fresh atty v0.2.14
           Fresh time v0.1.44
           Fresh os_str_bytes v6.0.0
           Fresh time v0.3.9
           Fresh toml v0.5.8
           Fresh memoffset v0.6.5
           Fresh num-traits v0.2.14
           Fresh futures-util v0.3.21
           Fresh indexmap v1.8.1
           Fresh syn v1.0.90
           Fresh backtrace v0.3.64
           Fresh rand_core v0.6.3
           Fresh proc-macro-error-attr v1.0.4
           Fresh tz-rs v0.6.7
           Fresh regex v1.5.5
           Fresh async-executor v1.4.1
           Fresh async-io v1.6.0
           Fresh nix v0.23.1
           Fresh num-integer v0.1.44
           Fresh thiserror-impl v1.0.30
           Fresh serde_derive v1.0.136
           Fresh enumflags2_derive v0.7.4
           Fresh rand_chacha v0.3.1
           Fresh async-trait v0.1.53
           Fresh derivative v2.2.0
           Fresh failure v0.1.8
           Fresh async-recursion v0.3.2
           Fresh serde_repr v0.1.7
           Fresh proc-macro-error v1.0.4
           Fresh soloud-sys v1.0.2
           Fresh tzdb v0.2.1
           Fresh color-backtrace v0.5.1
           Fresh serde v1.0.136
           Fresh thiserror v1.0.30
           Fresh xcb v0.8.2
           Fresh chrono v0.4.19
           Fresh ctrlc v3.2.1
           Fresh rand v0.8.5
           Fresh which v3.1.1
           Fresh clap_derive v3.1.7
           Fresh soloud v1.0.2
           Fresh proc-macro-crate v1.1.3
           Fresh enumflags2 v0.7.4
           Fresh x11-clipboard v0.3.3
           Fresh serde_json v1.0.79
           Fresh ansi_term v0.12.1
           Fresh zvariant_derive v3.1.2
           Fresh zbus_macros v2.1.1
           Fresh clipboard v0.5.0
           Fresh clap v3.1.8
           Fresh zvariant v3.1.2
           Fresh clipboard-ext v0.2.0
           Fresh zbus_names v2.1.0
           Fresh zbus v2.1.1
           Fresh notify-rust v4.5.8
           Fresh core-dev v0.0.1 (...)
           Fresh rule_202020 v0.1.0 (...)
        Finished dev [unoptimized + debuginfo] target(s) in 0.07s
    

    Additional context if i comment this line

        let mut sl = Soloud::default()?;
        sl.set_global_volume(3.0);
    
        let mut wav = audio::Wav::default();
    
        wav.load("noice.mp3")?;
    
    
        let mut sl2 = Soloud::default()?;
        // sl2.set_global_volume(3.0);              <--- this line
    
        let mut wav2 = audio::Wav::default();
        wav2.load("bizwarn_minus_15.wav")?;
    

    the error is gone. meaning that i cannot set the global volume 2 times in the same program/application. this is what i noticed. is this right ?

    if so, then why i cant ?

    why

    Q: why im making 2 instances of Soloud and set global volume everything ?

    A: because im making a struct which looks like this

        #[derive(Debug)]
        pub struct MusicPlayer {
            player:  Soloud,
            wav:     Wav,
            playing: bool,
            handle:  Option<Handle>,
        }
    

    and has this implementation

        impl MusicPlayer {
            pub fn new() -> Result<Self, SoloudError> {
                let mut sl = Soloud::default()?;
                sl.set_global_volume(2.0);
    
                let mut wav = Wav::default();
                Ok(Self {
                    player: sl,
                    wav,
                    playing: false,
                    handle: None,
                })
            }
    
            pub fn load_file<P: AsRef<std::path::Path>>(
                &mut self,
                path: P,
            ) -> Result<(), SoloudError> {
                self.wav.load(path)?;
                Ok(())
            }
    
            pub fn pause_playing(&mut self) {
                if let Some(handle) = self.handle {
                    self.playing = false;
    
                    self.player.set_pause(handle, true);
                }
            }
    
            pub fn continue_playing(&mut self) {
                if let Some(handle) = self.handle {
                    self.playing = true;
                    self.player.set_pause(handle, false);
                }
            }
    
            pub fn is_done_playing(&self) -> bool {
                self.player.voice_count() == 0
            }
    
            pub fn is_playing(&self) -> bool {
                self.player.voice_count() > 0
            }
    
            pub fn play_music(&mut self, wait: bool, timeout: Option<u64>) {
                self.playing = true;
                let handle = self.player.play(&self.wav);
                self.handle = Some(handle);
                if wait {
                    // calls to play are non-blocking, so we put the thread to sleep
                    while self.is_playing() {
                        if let Some(timeout) = timeout {
                            std::thread::sleep(std::time::Duration::from_millis(
                                timeout,
                            ));
                        }
                    }
                }
            }
        }
    

    and im creating 1 instance of Soloud and set the global volume everytime i call new because the programmer user can make only 1 instance of MusicPlayer in their program. and im making sure the volume its set at least once.

    opened by alexzanderr 3
  • Make Soloud::mix() public

    Make Soloud::mix() public

    Is there any particular reason to make mix() and mix_signed_16 private? Those are rather useful for a variety of reasons (writing to file, custom backends etc.)

    opened by OlegOAndreev 2
Owner
Mohammed Alyousef
MD.
Mohammed Alyousef
Rust audio playback library

Audio playback library Rust playback library. Playback is handled by cpal. MP3 decoding is handled by minimp3. WAV decoding is handled by hound. Vorbi

null 1.2k Jan 1, 2023
Symphonia is a pure Rust audio decoding and media demuxing library supporting AAC, FLAC, MP3, MP4, OGG, Vorbis, and WAV.

Pure Rust multimedia format demuxing, tag reading, and audio decoding library

Philip Deljanov 1k Jan 2, 2023
A low-overhead and adaptable audio playback library for Rust

Awedio   A low-overhead and adaptable audio playback library for Rust. Examples Play a single sound file: let (mut manager, backend) = awedio::start()

10 Buttons 20 May 25, 2023
Flutter crossplatform audio playback library powered by golang beep & oto

Rowdy Pure Rust based Dart/Flutter audio playback library Installation $ flutter pub add rowdy Configuration You'll need the Rust toolchain installed

Kingkor Roy Tirtho 3 Aug 31, 2022
A library and application for lossless, format-preserving, two-pass optimization and repair of Vorbis data, reducing its size without altering any audio information.

OptiVorbis A library and application for lossless, format-preserving, two-pass optimization and repair of Vorbis data, reducing its size without alter

OptiVorbis 27 Jan 3, 2023
TinyAudio is a cross-platform audio output library

TinyAudio TinyAudio is a cross-platform audio output library. Its main goal to provide unified access to a default sound output device of your operati

Dmitry Stepanov 39 Apr 4, 2023
Implements the free and open audio codec Opus in Rust.

opus-native Overview Implements the free and open audio codec Opus in Rust. Status This crate is under heavy development. Most functionality is not wo

Nils Hasenbanck 9 Nov 28, 2022
Rust - Augmented Audio Libraries

Augmented Audio Libraries In this repository I'll push some experiments trying to use Rust for audio programming. Goals Goal 1: Learn & have fun This

Pedro Tacla Yamada 116 Dec 18, 2022
CLI Rust Audio Visualizer

crav Console-based Rust Audio Visualizer It can run in the terminal but also has a 3D accelerated backend implemented in wgpu. demo compatibility The

null 20 Oct 16, 2022
Simple examples to demonstrate full-stack Rust audio plugin dev with baseplug and iced_audio

iced baseplug examples Simple examples to demonstrate full-stack Rust audio plugin dev with baseplug and iced_audio WIP (The GUI knobs do nothing curr

Billy Messenger 10 Sep 12, 2022
MVC audio plugin framework for rust

__ __ | |--.---.-.-----.-----.-----.| |.--.--.-----. | _ | _ |__ --| -__| _ || || | | _ | |

william light 93 Dec 23, 2022
simple-eq is a crate that implements a simple audio equalizer in Rust.

simple-eq A Simple Audio Equalizer simple-eq is a crate that implements a simple audio equalizer in Rust. It supports a maximum of 32 filter bands. Us

Mike Hilgendorf 11 Sep 17, 2022
A simple GUI audio player written in Rust with egui. Inspired by foobar2000.

Music Player A simple GUI music player inspired by foobar2000 written in Rust using egui. The goal of this project is to learn about making gui/ nativ

Ryan Blecher 5 Sep 16, 2022
Rust Audio Player Daemon

Rust Audio Player Daemon Cause mpd was annoying What rapd trys to do Rapd is not a spotify client, or an advanced music player. Its an audio/music dae

ash 3 Nov 1, 2022
API-agnostic audio plugin framework written in Rust

Because everything is better when you do it yourself - Rust VST3 and CLAP framework and plugins

Robbert van der Helm 415 Dec 27, 2022
Cross-platform audio for Rust

quad-snd High-level, light-weight, and opinionated audio library. Web: WebAudio Android: OpenSLES Linux: Alsa macOS: CoreAudio Windows: Wasapi iOS: Co

Fedor Logachev 86 Nov 7, 2022
DSP real time audio synthesis, effect algorithms and utilities for Rust

synfx-dsp synfx-dsp DSP real time audio synthesis, effect algorithms and utilities for Rust Most of the algorithms and implementations in this library

Weird Constructor 8 Nov 23, 2022
Quite OK Audio format in Rust.

QOA - The Quite Ok Audio Format This is a pure Rust (zero dependency) implementation of the QOA audio format. This code is based off the reference C i

Rafael Carício 10 Apr 16, 2023
Capture system output audio in rust.

RUHear A simple crate that allows you to capture system output audio (what aRe yoU HEARing). Dependencies On windows and linux: cpal On macos: screenc

Charles 3 Feb 7, 2024