Symphonia is a pure Rust audio decoding and media demuxing library supporting AAC, FLAC, MP3, MP4, OGG, Vorbis, and WAV.

Overview

Symphonia

Docs Build Status dependency status

Symphonia is a pure Rust audio decoding and media demuxing library supporting AAC, FLAC, MP3, MP4, OGG, Vorbis, and WAV.

Features

Symphonia's planned features are:

  • Decode support for the most popular audio codecs
  • Reading the most common media container formats
  • Probing and guessing the correct format and decoder combination(s) for playback or inspection
  • Reading metadata
  • Providing a set of audio primitives for manipulating audio data efficiently
  • Providing a C API for integration into other languages
  • Providing a WASM API for web usage

Format and Codec Support Roadmap

Support for individual audio codecs and media formats is provided by separate crates. By default, Symphonia selects support for FOSS codecs and formats, but others may be included via the features option.

The follow status classifications are used to determine the state of development for each format or codec.

Status Meaning
- No work started or planned yet.
Next Is the next major work item.
Good Many media streams play. Some streams may panic, error, or produce audible glitches. Some features may not be supported.
Great Most media streams play. Inaudible glitches may be present. Most common features are supported.
Perfect All media streams play. No audible or inaudible glitches. All required features are supported.

A classification of Great indicates the end of major development. Though bugs and smaller issues can occur, it would generally be safe to use in an application. Compliance testing according to standards will be delayed until most codecs and demuxers are implemented so it's expected that many will stay in the category for a while.

Formats (Demux)

Format Status Feature Flag Default Crate
ISO/MP4 Great isomp4 No symphonia-format-isomp4
MKV/WebM - mkv Yes symphonia-format-mkv
OGG Great ogg Yes symphonia-format-ogg
Wave Perfect wav Yes symphonia-format-wav

Codecs (Decode)

Codec Status Feature Flag Default Crate
AAC-LC Good aac No symphonia-codec-aac
ALAC - alac No symphonia-codec-alac
HE-AAC (AAC+, aacPlus) - aac No symphonia-codec-aac
HE-AACv2 (eAAC+, aacPlus v2) - aac No symphonia-codec-aac
FLAC Perfect flac Yes symphonia-bundle-flac
MP1 - mp3 No symphonia-bundle-mp3
MP2 - mp3 No symphonia-bundle-mp3
MP3 Great mp3 No symphonia-bundle-mp3
Opus Next opus Yes symphonia-codec-opus
PCM Perfect pcm Yes symphonia-codec-pcm
Vorbis Great vorbis Yes symphonia-codec-vorbis
WavPack - wavpack Yes symphonia-codec-wavpack

A symphonia-bundle-* package is a combination of a decoder and a native bitstream demuxer.

Tags (Read)

All metadata readers are provided by the symphonia-metadata crate.

Format Status
ID3v1 Great
ID3v2 Great
ISO/MP4 Great
RIFF Great
Vorbis comment (FLAC) Perfect
Vorbis comment (OGG) Perfect

Quality

In addition to the safety guarantees provided by Rust, Symphonia aims to:

  • Decode files as well as the leading free-and-open-source software decoders
  • Provide a powerful, consistent, and easy to use API
  • Be 100% safe code
  • Have very minimal dependencies
  • Prevent denial-of-service attacks
  • Be fuzz-tested

Performance

Symphonia aims to be equivalent in speed to popular open-source C-based implementations.

Symphonia does not include explicit SIMD optimizations, however the auto-vectorizer is leveraged as much as possible and the results have been excellent. As Rust support for packed SIMD grows, Symphonia will include explicit SIMD optimizations where necessary.

Benchmarks (as of September 2019)

These benchmarks compare the single-threaded decoding performance of both Symphonia and FFmpeg with various audio files.

The benchmarks were executed on an Arch Linux system with a Core i7 4790k and 32GB of RAM, for a minimum of 20 runs each. Hyperfine was used to execute the test. The full benchmark script is as follows:

#!/bin/bash
IN="${1@Q}"
hyperfine -m 20 "ffmpeg -threads 1 -benchmark -v 0 -i ${IN} -f null -" "symphonia-play --decode-only ${IN}"

MP3, 192kbps @ 44.1kHz

Command Mean [ms] Min [ms] Max [ms] Relative
Symphonia 306.2 ± 3.0 301.8 312.5 1.1
FFmpeg 272.7 ± 4.3 267.6 285.3 1.0

MP3, 320kbps @ 44.1kHz

Command Mean [ms] Min [ms] Max [ms] Relative
Symphonia 355.1 ± 8.4 348.2 376.2 1.1
FFmpeg 316.0 ± 3.5 308.8 322.8 1.0

FLAC, 24-bit @ 96kHz

Decoder Mean [ms] Min [ms] Max [ms] Relative
Symphonia 453.6 ± 2.9 449.3 462.4 1.0
FFmpeg 501.9 ± 4.3 496.4 512.7 1.1

FLAC, 24-bit @ 48kHz

Command Mean [ms] Min [ms] Max [ms] Relative
Symphonia 324.0 ± 8.9 315.4 346.3 1.0
FFmpeg 331.0 ± 7.4 323.6 354.5 1.0

WAVE, S32LE @ 44.1kHz

Command Mean [ms] Min [ms] Max [ms] Relative
Symphonia 84.5 ± 1.8 81.8 89.1 1.0
FFmpeg 129.8 ± 3.4 123.4 136.1 1.5

Example Usage

Basic usage examples may be found in symphonia/examples.

For a more complete application, see symphonia-play, a simple music player.

Tools

Symphonia provides the following tools for debugging purposes:

  • symphonia-play for probing, decoding, validating, and playing back media streams.
  • symphonia-check for validating Symphonia's decoded output against ffmpeg.

Authors

The primary author is Philip Deljanov.

Special Thanks

  • Kostya Shishkov (AAC-LC decoder contribution, see symphonia-codec-aac)

License

Symphonia is provided under the MPL v2.0 license. Please refer to the LICENSE file for more details.

Contributing

Symphonia is an open-source project and contributions are very welcome! If you would like to make a large contribution, please raise an issue ahead of time to make sure your efforts fit into the project goals, and that there's no duplication of effort. Please be aware that all contributions must also be licensed under the MPL v2.0 license to be accepted.

When submitting a pull request, be sure you have included yourself in the CONTRIBUTORS file!

Comments
  • FLAC: Mismatch with max delta from 0.085 to 1.998

    FLAC: Mismatch with max delta from 0.085 to 1.998

    These files exhibit mismatches compared to ffmpeg:

    1.25170898 01 - Give It Away (In Progress).flac 1.93112183 05 - Киберпанк.flac 1.59304810 06. The Sunshine.flac 1.98730469 03 Roll Us A Giant.flac 1.72723389 10. The Parts.flac 1.08828735 07. The Grocery.flac 0.08523428 04- The Hours - Arr. Michael Riesman - Morning Passages.flac 1.66995239 16. Olivia's Doom (Chad Mossholder Remix).flac 1.92807007 09 - Путь прост.flac 1.92960131 40. Stumpy.flac 1.99769855 3-Blue Jeans.flac 1.92474365 Robert Rich - Echo of Small Things.flac

    More over, one of the files triggers an error:

    ERROR symphonia_core::probe > reached probe limit of 1048576 bytes.Test interrupted by error: unsupported feature: core (probe): no suitable reader found 01. You Are Light (feat. Felicia Farerre).flac

    opened by totikom 40
  • Add initial support for matroska / webm

    Add initial support for matroska / webm

    Hi! This PR adds an initial support for matroska and webm containers that is intended to close #63. It is far from complete, but I decided to share what I have so far to get some feedback.

    opened by darksv 24
  • Remove unsafe from SampleWriter

    Remove unsafe from SampleWriter

    Removes the last use of unsafe from symphonia.

    Obligatory disclaimer that while this compiles fine and cargo test passes, I'm not sure how to actually test these changes on actual audio since symphonia-play doesn't like my computer's audio devices for some reason, so im blind to if this actually broke something.

    Closes https://github.com/pdeljanov/Symphonia/issues/38

    opened by BlackHoleFox 23
  • Vorbis: Mismatch with max delta from 0.001 to 1.25

    Vorbis: Mismatch with max delta from 0.001 to 1.25

    Data link

    The high-delta mismatches are likely simply misaligned, although I haven't been able to confirm that.

    I have excluded files with max delta below 0.001.

    Tested on commit 16497ee5fb0d2f00287ba3444c52b22bc4debdae

    opened by Shnatsel 17
  • Decoded frame count doesn't match the file's frame count

    Decoded frame count doesn't match the file's frame count

    First of all, thanks for making and sharing this library, I'm very happy to have discovered it, kudos!

    I've noticed some behaviour that I don't understand while decoding some .wav files (I haven't checked all of their formats, but typically they're stereo 16bit, 44.1k, PCM).

    Is it expected that the sum of all decoded AudioBufferRef frame counts should match the n_frames value defined in the track's codec params? I'm finding that in the last decoded packet, there are sometimes extra frames in the buffer, which then contain data that isn't in the file (e.g. Each buffer's frame count is 1158 through the file, then the final buffer contains 541 frames, when there are only 118 frames remaining according to the count).

    I can share an example if you like but I figured I'd better check first if I'm just misunderstanding something in the API.

    opened by irh 16
  • Add `latest` function to Metadata

    Add `latest` function to Metadata

    • Gets an immutable reference to the latest, and therefore newest, revision of the metadata.

    Removes the need to pop though the revisions via a loop when all you want is the latest.

    As mentioned in https://github.com/librespot-org/librespot/pull/967

    opened by JasonLG1979 14
  • mp3 playing twice

    mp3 playing twice

    I have a few mp3 files like this, where it plays the file and then plays it again. The file is 2:17, but it's played for about 4:34: Kill Paris feat. Big Gigantic & Jimi Tents - Fizzy Lifting Drink.mp3.zip

    I'm guessing there's something about how it's encoded that causes Symphonia to trip up, but no idea what that could be.

    Cargo.toml

    [package]
    name = "mp3test"
    version = "0.1.0"
    edition = "2018"
    
    [dependencies]
    rodio = { git = "https://github.com/RustAudio/rodio", rev = "d40551d", features = ["symphonia-mp3"] }
    

    main.rs

    use rodio::{Decoder, OutputStream, Sink};
    use std::fs::File;
    use std::io::BufReader;
    use std::sync::mpsc::channel;
    use std::sync::mpsc::TryRecvError;
    use std::thread;
    use std::time::{Duration, Instant};
    
    fn main() {
        let path = "Kill Paris feat. Big Gigantic & Jimi Tents - Fizzy Lifting Drink.mp3";
        let file = File::open(path).unwrap();
        let buf = BufReader::new(file);
    
        let decoder = Decoder::new(buf).unwrap();
    
        let output_stream = OutputStream::try_default();
        let (_stream, handle) = output_stream.unwrap();
        let sink = Sink::try_new(&handle).unwrap();
    
        sink.append(decoder);
        let (send, recv) = channel();
        thread::spawn(move || {
            sink.set_volume(0.25);
            let start = Instant::now();
            sink.play();
            sink.sleep_until_end();
            let dur = start.elapsed().as_secs_f64();
            println!("Ended, took {:.3}s", dur);
            send.send("End").unwrap();
        });
    
        let start = Instant::now();
        loop {
            match recv.try_recv() {
                Ok("End") => break,
                Err(TryRecvError::Empty) => {}
                _ => panic!(),
            };
            let dur = start.elapsed().as_secs_f64();
            println!("\u{23f1}  {:.3}s", dur);
            thread::sleep(Duration::from_millis(1000));
        }
    }
    
    opened by probablykasper 11
  • MP3: move bounds checks out of the hot loop

    MP3: move bounds checks out of the hot loop

    Move bounds checks out of the hot loop to be performed only once outside it. This should provide a modest performance boost, especially on CPUs with less powerful speculative execution.

    Reduces the output of cargo asm for this function from 488 to 412 lines, when annotated with #[inline(never)] to make it easy to inspect.

    Instruction counts before 125 movss 92 mov 85 lea 25 cmp 18 call 16 mulss 14 xor 14 jmp 13 addss 11 jne 6 ud2 6 push 6 pop 6 jae 5 jb 5 add 3 je 1 subss 1 sub 1 ret
    Instruction counts after 125 movss 74 lea 68 mov 16 mulss 14 xor 14 jmp 14 cmp 13 addss 12 call 11 jne 6 push 6 pop 5 add 3 je 1 subss 1 sub 1 ret

    This doesn't introduce any new panics - the code would have panicked anyway, now the check is simply performed once per function call outside the hot loop.

    There might be a more elegant iterator-based way than .try_into().unwrap(); I haven't really looked into it.

    Many other functions in this file can be given a similar treatment; this should provide a total boost of a few % in terms of performance for end-to-end decoding. This PR is meant to demonstrate the approach. I could proceed with converting the rest to this idiom, if you wish.

    opened by Shnatsel 10
  • Add initial fuzzing harness

    Add initial fuzzing harness

    This, as-is, will try and fuzz all the default-enabled targets using the format guessing. This is probably good enough to not need one fuzzer target per format?

    opened by 5225225 9
  • MP3: Mismatch with max delta up to 2.0

    MP3: Mismatch with max delta up to 2.0

    These files show max delta up to 2.0 when compared against ffmpeg with symphonia-check.

    I meant to test against mpg123 as well, but on my system --ref mpg123 always results in 0 samples compared, even though mpg123 itself seems to work. I suggest you run the check against mpg123 as well and only investigate files that diverge with both decoders, because this time it's a lot of files!

    Tested on commit 898ee01ff9785eff54782da85124c32d9cdadfc9 (latest as of this writing).

    The files are from the Pony Music Archive corpus and should be free to redistribute. I like this corpus because it contains files produced by a wide variety of encoders. I have previously run the test on a subset of this corpus; I've pruned the files I've already reported from the archive. I have run the check on the entire corpus this time; this amounts to roughly 200Gb of MP3 (27552 individual files).

    opened by Shnatsel 8
  • MP3 frame synchronization is not adequate in some pathological cases

    MP3 frame synchronization is not adequate in some pathological cases

    symphonia-play detects this corrupted mp3 file as stereo 22050 Hz, so it plays it back at ~4x speed. It's actually a mono 11025 Hz one, and plays correctly in VLC for example. This data was extracted from https://z0r.de/L/z0r-de_6315.swf.

    There seems to be an unusually high amount of 0xFF bytes before the first actual frame, which most likely throws off sync_frame(), even though check_header() does a decent amount of sanity checking. Perhaps it should also be extended with parsing the header at any potential frame sync point, then checking whether right after the potential frame there's either the end of the data stream, or another sync sequence (frame header). This would necessitate adding a seekback buffer of (in some cases) as long as ~2.9 KiB, which should not be an issue with local file sources, but for network streams, it might add a noticeable amount of latency. It might also prevent syncing to perfectly valid frames that happen to not be directly followed by another frame... So maybe it should be a decoder option? There might be other ways to fix the synchronization of this file, but this is what's described here: https://hydrogenaud.io/index.php?topic=85125.msg747716#msg747716 If the frame (supposedly) has CRC, that could also be used instead to rule out red herring frames.

    The "correct" way might be to change the sample rate and channel setup at each decoded frame as necessary, but I'm not sure if the playback machinery (of either symphonia-play, or of any embedding application) is set up for that.

    For reference: https://github.com/ruffle-rs/ruffle/pull/4273, https://github.com/ruffle-rs/ruffle/pull/5231 (EDIT: The reason I'm reporting is that at the moment, https://z0r.de/6315 only has sound in Chrome, but not in Firefox, as Ruffle currently uses decodeAudioData to decode MP3 sounds, and the mandated-by-spec format sniffing in FF can't figure out that it is in fact supposed to be MP3 content, most likely due to the amount of garbage before the first frame. If only https://github.com/WebAudio/web-audio-api/issues/7 ended up being resolved...)

    opened by torokati44 8
  • meta: use unsyncedlyrics vorbis tag for lyrics

    meta: use unsyncedlyrics vorbis tag for lyrics

    Some .flac files downloaded from Bandcamp have the UNSYNCEDLYRICS tag set if the artist added lyrics to a track. This PR enables Symphonia to also read this tag for lyrics metadata.

    opened by nilsding 0
  • Is it possible to replace `MediaSourceStream` with generic `M: MediaSource`?

    Is it possible to replace `MediaSourceStream` with generic `M: MediaSource`?

    Instead of taking in MediaSourceStream, is it possible to have decoders generically take in a M: MediaSource trait instead? (Or possibly Box<dyn MediaSource>, although I prefer the generic version because of fewer pointer indirections). The reason being, the underlying MediaSource implementation may already be buffered or is entirely in-memory, causing unnecessary copy into the buffer within MediaSourceStream.

    The existing MediaSourceStream can be repurposed as MediaSourceStream<M>, a buffered wrapper type over MediaSource types, so that the user can decide for themselves whether they require buffering (pay only when needed).

    opened by compilerintrinsics 2
  • FL Studio .wav's cannot be read

    FL Studio .wav's cannot be read

    Trying to read music production software FL Studio's built-in sample file "FPC 1 Kick.wav" throws an Unsupported("wav: unsupported wave format") error

    Sample file (rename .png to .wav): FPC 1 Kick

    Audacity can read this file already

    opened by kangalioo 2
  • play: Add resampling for Windows.

    play: Add resampling for Windows.

    Fixes: https://github.com/pdeljanov/Symphonia/issues/43

    The symphonia-play example will now use libsamplerate to resample according to the default output config from Windows.

    opened by erikas-taroza 21
  • Is possible that decoder support PacketRef?

    Is possible that decoder support PacketRef?

    Suppose application has a fixed buffer to store every packet data, but before invoking Decoder::decode() it must invoke Packet::new() to alloc data first. That make poor performance. Is possible that add a new type PacketRef and change decode function signature to Decoder::decode(&PacketRef) ? The PacketRef look like: pub PacketRef<'a> { .. the same as Packet, data: &'a [u8], }

    enhancement 
    opened by simon-fu 4
  • Metadata tag reading fails for non-utf8 mp3 tags

    Metadata tag reading fails for non-utf8 mp3 tags

    I tried the following added to the getting-started.rs example after probing the media source:

         if let Some(mut meta) = probed.metadata.get() {
             if let Some(latest) = meta.skip_to_latest() {
                 for tag in latest.tags().iter() {
                     println!("{:?}", tag);
                 }
             }
         }
    

    It works for mp3 files with utf8 tags, but it doesn't find anything for the ones in latin-2. Adding at least a fallback encoding would be great.

    opened by jbalintbiro 1
Releases(v0.5.1)
  • v0.5.1(Jul 17, 2022)

    New Features

    • Add skip_to_latest function to Metadata by @JasonLG1979 in https://github.com/pdeljanov/Symphonia/pull/110
    • Add clear functions to (Raw)SampleBuffer by @torokati44 in https://github.com/pdeljanov/Symphonia/issues/126

    Bug Fixes & Improvements

    • Improved symphonia-play on MacOS and Windows
    • Better ISO/MP4 fragmented stream support
    • Fixed many bugs after a preliminary fuzzing of Mp3Reader and Mp3Decoder
    • Handle malformed ID3v2 tags better instead of giving up entirely
    • Many others!

    New Contributors

    • @JasonLG1979 made their first contribution in https://github.com/pdeljanov/Symphonia/pull/110

    Full Changelog: https://github.com/pdeljanov/Symphonia/compare/v0.5.0...v0.5.1

    Source code(tar.gz)
    Source code(zip)
  • v0.5.0(Jan 31, 2022)

    New Features

    • Apple Lossless Audio Codec (ALAC) decoder
    • Matroska (MKV) & WebM demuxer
    • Gapless playback for ALAC, FLAC, MP3, PCM, and Vorbis
    • ISO/MP4/BMFF containers can now contain ALAC, FLAC, Opus, MP3, or PCM codecs
    • A getting started guide

    Bug Fixes & Improvements

    • MP3 and Vorbis decoders are now classified as Excellent
    • Improved the resilience and diagnostic messages of the MP3 demuxer when dealing with pathological inputs
    • Performance and accuracy gains across the board
    • Many other bug fixes and improvements

    New Contributors

    • @antifuchs made their first contribution in https://github.com/pdeljanov/Symphonia/pull/90
    • @Beinsezii made their first contribution in https://github.com/pdeljanov/Symphonia/pull/61
    • @Be-ing made their first contribution in https://github.com/pdeljanov/Symphonia/pull/83
    • @FelixMcFelix made their first contribution in https://github.com/pdeljanov/Symphonia/pull/53
    • @darksv made their first contribution in https://github.com/pdeljanov/Symphonia/pull/66
    • @sagudev made their first contribution in https://github.com/pdeljanov/Symphonia/pull/98
    • @Shnatsel made their first code contribution in https://github.com/pdeljanov/Symphonia/pull/101
    • @Techno-coder made their first contribution in https://github.com/pdeljanov/Symphonia/pull/93

    Full Changelog: https://github.com/pdeljanov/Symphonia/compare/v0.4.0...v0.5.0

    Source code(tar.gz)
    Source code(zip)
Owner
Philip Deljanov
Code artisan and electronics designer
Philip Deljanov
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
Program to check if stereo wav files have identical channels (faux-stereo) and convert them to mono.

zrtstr Command line application for checking WAV-files for identical channels, detecting faux-stereo files generated by some audio-editing software an

Kirill 22 Nov 6, 2022
Cross-platform audio I/O library in pure Rust

CPAL - Cross-Platform Audio Library Low-level library for audio input and output in pure Rust. This library currently supports the following: Enumerat

null 1.8k Jan 8, 2023
VR media player for linux

VR media player for linux Very early development access version. I'll drop more notes here once it's ready for more publicity. Some details: Uses wgpu

null 4 Oct 7, 2022
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
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
Rust bindings for the soloud audio engine library

soloud-rs A crossplatform Rust bindings for the soloud audio engine library. Supported formats: wav, mp3, ogg, flac. The library also comes with a spe

Mohammed Alyousef 38 Dec 8, 2022
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
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
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
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
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
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