.gitea/workflows/build.yaml

@@ -1,25 +0,0 @@
-name: Build
-on: [push]
-
-jobs:
-  Build:
-    env:
-      RUNNER_TOOL_CACHE: /toolcache
-    container: rust:alpine
-    steps:
-      - name: Install node
-        run: apk add nodejs gcc libc-dev pkgconf libx11-dev alsa-lib-dev eudev-dev tar
-      - name: Check out repository code
-        uses: actions/checkout@v4
-      - name: Restore cache
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-      - name: Build
-        run: cargo build --release

.github/workflows/rust.yml

@@ -0,0 +1,24 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install Dependencies
+      run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose

.gitignore

@@ -1,4 +1 @@
 /target
-.vscode
-.cargo
-Cargo.lock

Cargo.toml

@@ -1,29 +1,21 @@
 [package]
 name = "bevy_rustysynth"
 description = "A plugin which adds MIDI file and soundfont audio support to the bevy engine via rustysynth."
-version = "0.5.0"
+version = "0.2.1"
 edition = "2021"
 license = "0BSD OR MIT OR Apache-2.0"
-repository = "https://git.soaos.dev/soaos/bevy_rustysynth"
 
 [dependencies]
 rustysynth = "1.3"
-itertools = "0.14"
+itertools = "0.13"
 async-channel = "2.3"
-rodio = "0.20"
+rodio = "0.19"
-lazy_static = "1.5"
 
 [dependencies.bevy]
-version = "0.15"
+version = "0.14"
 default-features = false
-features = ["bevy_asset"]
+features = ["bevy_audio", "bevy_asset"]
-
-[dependencies.bevy_kira_audio]
-version = "0.22"
-optional = true
 
 [features]
-default = ["hl4mgm", "bevy_audio"]
+default = ["hl4mgm"]
-kira = ["dep:bevy_kira_audio"]
-bevy_audio = ["bevy/bevy_audio"]
 hl4mgm = []

README.md

@@ -2,30 +2,29 @@
 
 ![Crates](https://img.shields.io/crates/v/bevy_rustysynth)
 ![License](https://img.shields.io/badge/license-0BSD%2FMIT%2FApache-blue.svg)
+![Tag](https://img.shields.io/github/v/tag/exvacuum/bevy_rustysynth)
+![Build](https://img.shields.io/github/actions/workflow/status/exvacuum/bevy_rustysynth/rust.yml)
 
 A plugin which adds MIDI file and soundfont audio support to the bevy engine via rustysynth.
 
-From version 0.4, the crate has undergone significant rewrites, and now works with the default `bevy_audio` backend (`bevy_audio` feature) OR [`bevy_kira_audio`](https://github.com/NiklasEi/bevy_kira_audio) (`kira` feature)
-
 ## Compatibility
 
 | Crate Version | Bevy Version |
-| ------------- | ------------ |
+|---            |---           |
-| 0.5           | 0.15         |
+| 0.1           | 0.14         |
-| 0.2           | 0.14         |
 
 ## Installation
 
 ### crates.io
 ```toml
 [dependencies]
-bevy_rustysynth = "0.5"
+bevy_rustysynth = "0.1"
 ```
 
 ### Using git URL in Cargo.toml
 ```toml
 [dependencies.bevy_rustysynth]
-git = "https://git.soaos.dev/soaos/bevy_rustysynth.git"
+git = "https://github.com/exvacuum/bevy_rustysynth.git"
 ```
 
 ## Usage
@@ -47,10 +46,8 @@ fn main() {
 }
 ```
 Then you can load and play a MIDI like any other audio file:
-
-### `bevy_audio` Example
 ```rs
-let midi_handle = asset_server.load::<MidiAudioSource>("example.mid");
+let midi_handle = asset_server.load::<MidiAudio>("example.mid");
 
 commands.spawn(AudioSourceBundle {
     source: midi_handle,
@@ -58,13 +55,6 @@ commands.spawn(AudioSourceBundle {
 });
 ```
 
-### `bevy_kira_audio` Example
-```rs
-let midi_handle = asset_server.load::<AudioSource>("example.mid");
-
-audio.play(midi_handle);
-```
-
 ## License
 
 This crate is licensed under your choice of 0BSD, Apache-2.0, or MIT license.

src/assets.rs

@@ -1,17 +1,18 @@
-use bevy::asset::{io::Reader, AssetLoader, LoadContext};
-#[cfg(feature = "bevy_audio")]
-use bevy::prelude::*;
-use itertools::Itertools;
-use rustysynth::{MidiFile, MidiFileSequencer, SoundFont, Synthesizer, SynthesizerSettings};
-#[cfg(feature = "kira")]
-use std::future::Future;
 use std::{
     io::{self, Cursor},
     sync::Arc,
     time::Duration,
 };
 
-use crate::SOUNDFONT;
+use async_channel::{Receiver, TryRecvError};
+use bevy::{
+    asset::{io::Reader, AssetLoader, AsyncReadExt, LoadContext},
+    audio::Source,
+    prelude::*,
+    tasks::AsyncComputeTaskPool,
+};
+use itertools::Itertools;
+use rustysynth::{MidiFile, MidiFileSequencer, SoundFont, Synthesizer, SynthesizerSettings};
 
 /// Represents a single MIDI note in a sequence
 #[derive(Clone, Debug)]
@@ -43,251 +44,159 @@ impl Default for MidiNote {
     }
 }
 
+/// MIDI audio asset
+#[derive(Asset, TypePath, Clone, Debug)]
+pub enum MidiAudio {
+    /// Plays audio from a MIDI file
+    File(Vec<u8>),
+    /// Plays a simple sequence of notes
+    Sequence(Vec<MidiNote>),
+}
+
 /// AssetLoader for MIDI files (.mid/.midi)
 #[derive(Default, Debug)]
 pub struct MidiAssetLoader;
 
+impl AssetLoader for MidiAssetLoader {
+    type Asset = MidiAudio;
+
+    type Settings = ();
+
+    type Error = io::Error;
+
+    async fn load<'a>(
+        &'a self,
+        reader: &'a mut Reader<'_>,
+        _settings: &'a Self::Settings,
+        _load_context: &'a mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let mut bytes = vec![];
+        reader.read_to_end(&mut bytes).await?;
+        Ok(MidiAudio::File(bytes))
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["mid", "midi"]
+    }
+}
+
 /// Decoder for MIDI file playback
 pub struct MidiFileDecoder {
     sample_rate: usize,
-    data: Vec<f32>,
+    stream: Receiver<f32>,
-    #[cfg(feature = "bevy_audio")]
-    index: usize,
 }
 
 impl MidiFileDecoder {
-    /// Construct and render a MIDI sequence with the given MIDI data and soundfont.
+    /// Construct and begin a new MIDI sequencer with the given MIDI data and soundfont.
-    pub fn new(midi_data: Vec<u8>, soundfont: Arc<SoundFont>) -> Self {
+    ///
+    /// The sequencer will push at most 1 second's worth of audio ahead, allowing the decoder to
+    /// be paused without endlessly backing up data forever.
+    pub fn new(midi: MidiAudio, soundfont: Arc<SoundFont>) -> Self {
         let sample_rate = 44100_usize;
-        let settings = SynthesizerSettings::new(sample_rate as i32);
+        let (tx, rx) = async_channel::bounded::<f32>(sample_rate * 2);
-        let synthesizer =
+        AsyncComputeTaskPool::get()
-            Synthesizer::new(&soundfont, &settings).expect("Failed to create synthesizer.");
+            .spawn(async move {
+                let settings = SynthesizerSettings::new(sample_rate as i32);
+                let mut synthesizer =
+                    Synthesizer::new(&soundfont, &settings).expect("Failed to create synthesizer.");
 
-        let mut data = Vec::new();
+                match midi {
-        let mut sequencer = MidiFileSequencer::new(synthesizer);
+                    MidiAudio::File(midi_data) => {
-        let mut midi_data = Cursor::new(midi_data);
+                        let mut sequencer = MidiFileSequencer::new(synthesizer);
-        let midi = Arc::new(MidiFile::new(&mut midi_data).expect("Failed to read midi file."));
+                        let mut midi_data = Cursor::new(midi_data);
-        sequencer.play(&midi, false);
+                        let midi = Arc::new(
-        let mut left: Vec<f32> = vec![0_f32; sample_rate];
+                            MidiFile::new(&mut midi_data).expect("Failed to read midi file."),
-        let mut right: Vec<f32> = vec![0_f32; sample_rate];
+                        );
-        while !sequencer.end_of_sequence() {
+                        sequencer.play(&midi, false);
-            sequencer.render(&mut left, &mut right);
+                        let mut left: Vec<f32> = vec![0_f32; sample_rate];
-            for value in left.iter().interleave(right.iter()) {
+                        let mut right: Vec<f32> = vec![0_f32; sample_rate];
-                data.push(*value);
+                        while !sequencer.end_of_sequence() {
-            }
+                            sequencer.render(&mut left, &mut right);
-        }
+                            for value in left.iter().interleave(right.iter()) {
-        Self {
+                                if let Err(_) = tx.send(*value).await {
-            sample_rate,
+                                    return;
-            data,
+                                };
-            #[cfg(feature = "bevy_audio")]
+                            }
-            index: 0,
+                        }
-        }
+                    }
-    }
+                    MidiAudio::Sequence(sequence) => {
-
+                        for MidiNote {
-    /// Render a MIDI sequence with the given soundfont.
+                            channel,
-    pub fn new_sequence(midi_sequence: Vec<MidiNote>, soundfont: Arc<SoundFont>) -> Self {
+                            preset,
-        let sample_rate = 44100_usize;
+                            bank,
-        let settings = SynthesizerSettings::new(sample_rate as i32);
+                            key,
-        let mut synthesizer =
+                            velocity,
-            Synthesizer::new(&soundfont, &settings).expect("Failed to create synthesizer.");
+                            duration,
-
+                        } in sequence.iter()
-        let mut data = Vec::new();
+                        {
-
+                            synthesizer.process_midi_message(*channel, 0xB0, 0x00, *bank);
-        for MidiNote {
+                            synthesizer.process_midi_message(*channel, 0xC0, *preset, 0);
-            channel,
+                            synthesizer.note_on(*channel, *key, *velocity);
-            preset,
+                            let note_length =
-            bank,
+                                (sample_rate as f32 * duration.as_secs_f32()) as usize;
-            key,
+                            let mut left: Vec<f32> = vec![0_f32; note_length];
-            velocity,
+                            let mut right: Vec<f32> = vec![0_f32; note_length];
-            duration,
+                            for (left, right) in left.chunks_mut(sample_rate).zip(right.chunks_mut(sample_rate)) {
-        } in midi_sequence.iter()
+                                synthesizer.render(left, right);
-        {
+                                for value in left.iter().interleave(right.iter()) {
-            synthesizer.process_midi_message(*channel, 0xB0, 0x00, *bank);
+                                    if let Err(_) = tx.send(*value).await {
-            synthesizer.process_midi_message(*channel, 0xC0, *preset, 0);
+                                        return;
-            synthesizer.note_on(*channel, *key, *velocity);
+                                    };
-            let note_length = (sample_rate as f32 * duration.as_secs_f32()) as usize;
+                                }
-            let mut left: Vec<f32> = vec![0_f32; note_length];
+                            }
-            let mut right: Vec<f32> = vec![0_f32; note_length];
+                            synthesizer.note_off(*channel, *key);
-            for (left, right) in left
+                        }
-                .chunks_mut(sample_rate)
+                    }
-                .zip(right.chunks_mut(sample_rate))
-            {
-                synthesizer.render(left, right);
-                for value in left.iter().interleave(right.iter()) {
-                    data.push(*value);
                 }
-            }
+
-            synthesizer.note_off(*channel, *key);
+                tx.close();
-        }
+            })
+            .detach();
         Self {
             sample_rate,
-            data,
+            stream: rx,
-            #[cfg(feature = "bevy_audio")]
-            index: 0,
         }
     }
 }
 
-#[cfg(all(feature = "bevy_audio", not(feature = "kira")))]
+impl Iterator for MidiFileDecoder {
-/// Asset containing MIDI file data to be used as a `Decodable` audio source
+    type Item = f32;
-#[derive(Asset, TypePath, Debug)]
-pub struct MidiAudio(Vec<u8>);
 
-#[cfg(all(feature = "bevy_audio", not(feature = "kira")))]
+    fn next(&mut self) -> Option<Self::Item> {
-mod bevy_audio {
+        match self.stream.try_recv() {
-    use super::*;
+            Ok(value) => Some(value),
-    use bevy::audio::{Decodable, Source};
+            Err(e) => match e {
-
+                TryRecvError::Empty => Some(0.0),
-    impl Source for MidiFileDecoder {
+                TryRecvError::Closed => None,
-        fn current_frame_len(&self) -> Option<usize> {
+            },
-            None
-        }
-
-        fn channels(&self) -> u16 {
-            2
-        }
-
-        fn sample_rate(&self) -> u32 {
-            self.sample_rate as u32
-        }
-
-        fn total_duration(&self) -> Option<std::time::Duration> {
-            None
-        }
-    }
-
-    impl Decodable for MidiAudio {
-        type Decoder = MidiFileDecoder;
-
-        type DecoderItem = <MidiFileDecoder as Iterator>::Item;
-
-        fn decoder(&self) -> Self::Decoder {
-            MidiFileDecoder::new(
-                self.0.clone(),
-                SOUNDFONT.lock().unwrap().as_ref().unwrap().clone(),
-            )
-        }
-    }
-
-    impl AssetLoader for MidiAssetLoader {
-        type Asset = MidiAudio;
-
-        type Settings = ();
-
-        type Error = io::Error;
-
-        async fn load(
-            &self,
-            reader: &mut dyn Reader,
-            _settings: &Self::Settings,
-            _load_context: &mut LoadContext<'_>,
-        ) -> Result<Self::Asset, Self::Error> {
-            let mut bytes = vec![];
-            reader.read_to_end(&mut bytes).await?;
-            Ok(MidiAudio(bytes))
-        }
-
-        fn extensions(&self) -> &[&str] {
-            &["mid", "midi"]
-        }
-    }
-
-    impl Iterator for MidiFileDecoder {
-        type Item = f32;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            let result = self.data.get(self.index).copied();
-            self.index += 1;
-            result
         }
     }
 }
 
-#[cfg(all(feature = "kira", not(feature = "bevy_audio")))]
+impl Source for MidiFileDecoder {
-/// Extensions For Rendering MIDI Audio
+    fn current_frame_len(&self) -> Option<usize> {
-pub trait MidiAudioExtensions {
+        None
-    /// Renders MIDI audio from orovided data
-    fn from_midi_file(data: Vec<u8>) -> impl Future<Output = Self> + Send;
-    /// Renders MIDI audio from provided note sequence
-    fn from_midi_sequence(sequence: Vec<MidiNote>) -> impl Future<Output = Self> + Send;
-}
-
-#[cfg(all(feature = "kira", not(feature = "bevy_audio")))]
-mod kira {
-    use super::*;
-    use bevy_kira_audio::{
-        prelude::{Frame, StaticSoundData, StaticSoundSettings},
-        AudioSource,
-    };
-
-    impl AssetLoader for MidiAssetLoader {
-        type Asset = AudioSource;
-
-        type Settings = ();
-
-        type Error = io::Error;
-
-        async fn load(
-            &self,
-            reader: &mut dyn Reader,
-            _settings: &Self::Settings,
-            _load_context: &mut LoadContext<'_>,
-        ) -> Result<Self::Asset, Self::Error> {
-            let mut bytes = vec![];
-            reader.read_to_end(&mut bytes).await?;
-            Ok(AudioSource::from_midi_file(bytes).await)
-        }
-
-        fn extensions(&self) -> &[&str] {
-            &["mid", "midi"]
-        }
     }
 
-    impl MidiAudioExtensions for AudioSource {
+    fn channels(&self) -> u16 {
-        async fn from_midi_file(data: Vec<u8>) -> Self {
+        2
-            let decoder =
+    }
-                MidiFileDecoder::new(data, SOUNDFONT.lock().unwrap().as_ref().unwrap().clone());
-            let frames = decoder
-                .data
-                .chunks(2)
-                .map(|sample| Frame::new(sample[0], sample[1]))
-                .collect::<Arc<[_]>>();
-            let sample_rate = decoder.sample_rate as u32;
-            let settings = StaticSoundSettings {
-                ..Default::default()
-            };
-            AudioSource {
-                sound: StaticSoundData {
-                    sample_rate,
-                    frames,
-                    settings,
-                    slice: None,
-                },
-            }
-        }
 
-        async fn from_midi_sequence(sequence: Vec<MidiNote>) -> Self {
+    fn sample_rate(&self) -> u32 {
-            let decoder = MidiFileDecoder::new_sequence(
+        self.sample_rate as u32
-                sequence,
+    }
-                SOUNDFONT.lock().unwrap().as_ref().unwrap().clone(),
+
-            );
+    fn total_duration(&self) -> Option<std::time::Duration> {
-            let frames = decoder
+        None
-                .data
+    }
-                .chunks(2)
+}
-                .map(|sample| Frame::new(sample[0], sample[1]))
+
-                .collect::<Arc<[_]>>();
+impl Decodable for MidiAudio {
-            let sample_rate = decoder.sample_rate as u32;
+    type Decoder = MidiFileDecoder;
-            let settings = StaticSoundSettings {
+
-                ..Default::default()
+    type DecoderItem = <MidiFileDecoder as Iterator>::Item;
-            };
+
-            AudioSource {
+    fn decoder(&self) -> Self::Decoder {
-                sound: StaticSoundData {
+        MidiFileDecoder::new(self.clone(), crate::SOUNDFONT.get().unwrap().clone())
-                    sample_rate,
-                    frames,
-                    settings,
-                    slice: None,
-                },
-            }
-        }
     }
 }

src/lib.rs

@@ -1,21 +1,12 @@
 #![warn(missing_docs)]
+
 //! A plugin which adds MIDI file and soundfont audio support to the [bevy](https://crates.io/crates/bevy) engine via [rustysynth](https://crates.io/crates/rustysynth).
 
-#[cfg(all(feature = "bevy_audio", feature = "kira"))]
+use bevy::{audio::AddAudioSource, prelude::*};
-compile_error!("Cannot compile with both bevy_audio and kira features enabled simultaneously. Please disable one of these features");
-
-#[cfg(feature = "bevy_audio")]
-use bevy::audio::AddAudioSource;
-use bevy::prelude::*;
-use lazy_static::lazy_static;
 use rustysynth::SoundFont;
-#[cfg(feature = "hl4mgm")]
-use std::io::Cursor;
 use std::{
-    fs::{self, File},
+    io::{Cursor, Read},
-    io::Read,
+    sync::{Arc, OnceLock},
-    path::PathBuf,
-    sync::{Arc, Mutex},
 };
 
 mod assets;
@@ -24,22 +15,11 @@ pub use assets::*;
 #[cfg(feature = "hl4mgm")]
 pub(crate) static HL4MGM: &[u8] = include_bytes!("./embedded_assets/hl4mgm.sf2");
 
-lazy_static! {
+pub(crate) static SOUNDFONT: OnceLock<Arc<SoundFont>> = OnceLock::new();
-    pub(crate) static ref DEFAULT_SOUNDFONT: Arc<Mutex<Option<Arc<SoundFont>>>> =
-        Arc::new(Mutex::new(None));
-    pub(crate) static ref SOUNDFONT: Arc<Mutex<Option<Arc<SoundFont>>>> =
-        Arc::new(Mutex::new(None));
-}
-
-#[derive(SystemSet, Hash, Clone, PartialEq, Eq, Debug)]
-pub enum RustySynthSet {
-    Setup,
-    Update,
-}
 
 /// This plugin configures the soundfont used for playback and registers MIDI assets.
 #[derive(Debug)]
-pub struct RustySynthPlugin<R: Read + Clone + 'static> {
+pub struct RustySynthPlugin<R: Read + Send + Sync + Clone + 'static> {
     /// Reader for soundfont data.
     pub soundfont: R,
 }
@@ -55,50 +35,11 @@ impl Default for RustySynthPlugin<Cursor<&[u8]>> {
 
 impl<R: Read + Send + Sync + Clone + 'static> Plugin for RustySynthPlugin<R> {
     fn build(&self, app: &mut App) {
-        *DEFAULT_SOUNDFONT.lock().unwrap() = Some(Arc::new(
+        let _ = SOUNDFONT.set(Arc::new(
             SoundFont::new(&mut self.soundfont.clone()).unwrap(),
         ));
-        info!("Setting Soundfont Initially");
+        app.add_audio_source::<MidiAudio>()
-        *SOUNDFONT.lock().unwrap() = DEFAULT_SOUNDFONT.lock().unwrap().clone();
+            .init_asset::<MidiAudio>()
-        app.init_asset_loader::<MidiAssetLoader>()
+            .init_asset_loader::<MidiAssetLoader>();
-            .add_event::<SetSoundfontEvent>()
-            .add_systems(Startup, handle_set_soundfont.in_set(RustySynthSet::Setup))
-            .add_systems(Update, handle_set_soundfont.in_set(RustySynthSet::Update));
-        #[cfg(feature = "bevy_audio")]
-        app.init_asset::<MidiAudio>()
-            .add_audio_source::<MidiAudio>();
-    }
-}
-
-pub(crate) fn set_soundfont<R: Read + 'static>(mut reader: R) {
-    info!("Setting Soundfont");
-    *SOUNDFONT.lock().unwrap() = Some(Arc::new(SoundFont::new(&mut reader).unwrap()));
-}
-
-/// Event for setting the soundfont after initialization
-/// This will not affect sounds which have already been rendered
-#[derive(Event)]
-pub enum SetSoundfontEvent {
-    /// Load soundfont from bytes
-    Bytes(Vec<u8>),
-    /// Load soundfont at path
-    Path(PathBuf),
-    /// Load default soundfont
-    Default,
-}
-
-fn handle_set_soundfont(mut event_reader: EventReader<SetSoundfontEvent>) {
-    for event in event_reader.read() {
-        match event {
-            SetSoundfontEvent::Bytes(items) => {
-                set_soundfont(Cursor::new(items.clone()));
-            }
-            SetSoundfontEvent::Path(path_buf) => {
-                set_soundfont(File::open(path_buf).unwrap());
-            }
-            SetSoundfontEvent::Default => {
-                *SOUNDFONT.lock().unwrap() = DEFAULT_SOUNDFONT.lock().unwrap().clone();
-            }
-        }
     }
 }