Merge pull request 'Added the ability to switch soundfont after initialization' (#3) from wip into master

Reviewed-on: #3

.gitea/workflows/build.yaml

@@ -0,0 +1,25 @@
+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

@@ -1,24 +0,0 @@
-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 +1,4 @@
 /target
+.vscode
+.cargo
+Cargo.lock

Cargo.toml

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

README.md

@@ -2,29 +2,30 @@
 
 ![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.1           | 0.14         |
+| ------------- | ------------ |
+| 0.5           | 0.15         |
+| 0.2           | 0.14         |
 
 ## Installation
 
 ### crates.io
 ```toml
 [dependencies]
-bevy_rustysynth = "0.1"
+bevy_rustysynth = "0.5"
 ```
 
 ### Using git URL in Cargo.toml
 ```toml
 [dependencies.bevy_rustysynth]
-git = "https://github.com/exvacuum/bevy_rustysynth.git"
+git = "https://git.soaos.dev/soaos/bevy_rustysynth.git"
 ```
 
 ## Usage
@@ -46,8 +47,10 @@ 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::<MidiAudio>("example.mid");
+let midi_handle = asset_server.load::<MidiAudioSource>("example.mid");
 
 commands.spawn(AudioSourceBundle {
     source: midi_handle,
@@ -55,6 +58,13 @@ 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,18 +1,17 @@
+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 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};
+use crate::SOUNDFONT;
 
 /// Represents a single MIDI note in a sequence
 #[derive(Clone, Debug)]
@@ -44,159 +43,251 @@ 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,
-    stream: Receiver<f32>,
+    data: Vec<f32>,
+    #[cfg(feature = "bevy_audio")]
+    index: usize,
 }
 
 impl MidiFileDecoder {
-    /// Construct and begin a new MIDI sequencer with the given MIDI data and soundfont.
-    ///
-    /// 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 {
+    /// Construct and render a MIDI sequence with the given MIDI data and soundfont.
+    pub fn new(midi_data: Vec<u8>, soundfont: Arc<SoundFont>) -> Self {
         let sample_rate = 44100_usize;
-        let (tx, rx) = async_channel::bounded::<f32>(sample_rate * 2);
-        AsyncComputeTaskPool::get()
-            .spawn(async move {
-                let settings = SynthesizerSettings::new(sample_rate as i32);
-                let mut synthesizer =
-                    Synthesizer::new(&soundfont, &settings).expect("Failed to create synthesizer.");
+        let settings = SynthesizerSettings::new(sample_rate as i32);
+        let synthesizer =
+            Synthesizer::new(&soundfont, &settings).expect("Failed to create synthesizer.");
 
-                match midi {
-                    MidiAudio::File(midi_data) => {
-                        let mut sequencer = MidiFileSequencer::new(synthesizer);
-                        let mut midi_data = Cursor::new(midi_data);
-                        let midi = Arc::new(
-                            MidiFile::new(&mut midi_data).expect("Failed to read midi file."),
-                        );
-                        sequencer.play(&midi, false);
-                        let mut left: Vec<f32> = vec![0_f32; sample_rate];
-                        let mut right: Vec<f32> = vec![0_f32; sample_rate];
-                        while !sequencer.end_of_sequence() {
-                            sequencer.render(&mut left, &mut right);
-                            for value in left.iter().interleave(right.iter()) {
-                                if let Err(_) = tx.send(*value).await {
-                                    return;
-                                };
-                            }
-                        }
-                    }
-                    MidiAudio::Sequence(sequence) => {
-                        for MidiNote {
-                            channel,
-                            preset,
-                            bank,
-                            key,
-                            velocity,
-                            duration,
-                        } in sequence.iter()
-                        {
-                            synthesizer.process_midi_message(*channel, 0xB0, 0x00, *bank);
-                            synthesizer.process_midi_message(*channel, 0xC0, *preset, 0);
-                            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];
-                            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()) {
-                                    if let Err(_) = tx.send(*value).await {
-                                        return;
-                                    };
-                                }
-                            }
-                            synthesizer.note_off(*channel, *key);
-                        }
-                    }
-                }
-
-                tx.close();
-            })
-            .detach();
+        let mut data = Vec::new();
+        let mut sequencer = MidiFileSequencer::new(synthesizer);
+        let mut midi_data = Cursor::new(midi_data);
+        let midi = Arc::new(MidiFile::new(&mut midi_data).expect("Failed to read midi file."));
+        sequencer.play(&midi, false);
+        let mut left: Vec<f32> = vec![0_f32; sample_rate];
+        let mut right: Vec<f32> = vec![0_f32; sample_rate];
+        while !sequencer.end_of_sequence() {
+            sequencer.render(&mut left, &mut right);
+            for value in left.iter().interleave(right.iter()) {
+                data.push(*value);
+            }
+        }
         Self {
             sample_rate,
-            stream: rx,
+            data,
+            #[cfg(feature = "bevy_audio")]
+            index: 0,
+        }
+    }
+
+    /// Render a MIDI sequence with the given soundfont.
+    pub fn new_sequence(midi_sequence: Vec<MidiNote>, soundfont: Arc<SoundFont>) -> Self {
+        let sample_rate = 44100_usize;
+        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();
+
+        for MidiNote {
+            channel,
+            preset,
+            bank,
+            key,
+            velocity,
+            duration,
+        } in midi_sequence.iter()
+        {
+            synthesizer.process_midi_message(*channel, 0xB0, 0x00, *bank);
+            synthesizer.process_midi_message(*channel, 0xC0, *preset, 0);
+            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];
+            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);
+        }
+        Self {
+            sample_rate,
+            data,
+            #[cfg(feature = "bevy_audio")]
+            index: 0,
         }
     }
 }
 
-impl Iterator for MidiFileDecoder {
-    type Item = f32;
+#[cfg(all(feature = "bevy_audio", not(feature = "kira")))]
+/// Asset containing MIDI file data to be used as a `Decodable` audio source
+#[derive(Asset, TypePath, Debug)]
+pub struct MidiAudio(Vec<u8>);
 
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.stream.try_recv() {
-            Ok(value) => Some(value),
-            Err(e) => match e {
-                TryRecvError::Empty => Some(0.0),
-                TryRecvError::Closed => None,
-            },
+#[cfg(all(feature = "bevy_audio", not(feature = "kira")))]
+mod bevy_audio {
+    use super::*;
+    use bevy::audio::{Decodable, Source};
+
+    impl Source for MidiFileDecoder {
+        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
         }
     }
 }
 
-impl Source for MidiFileDecoder {
-    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
-    }
+#[cfg(all(feature = "kira", not(feature = "bevy_audio")))]
+/// Extensions For Rendering MIDI Audio
+pub trait MidiAudioExtensions {
+    /// 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;
 }
 
-impl Decodable for MidiAudio {
-    type Decoder = MidiFileDecoder;
+#[cfg(all(feature = "kira", not(feature = "bevy_audio")))]
+mod kira {
+    use super::*;
+    use bevy_kira_audio::{
+        prelude::{Frame, StaticSoundData, StaticSoundSettings},
+        AudioSource,
+    };
 
-    type DecoderItem = <MidiFileDecoder as Iterator>::Item;
+    impl AssetLoader for MidiAssetLoader {
+        type Asset = AudioSource;
 
-    fn decoder(&self) -> Self::Decoder {
-        MidiFileDecoder::new(self.clone(), crate::SOUNDFONT.get().unwrap().clone())
+        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 {
+        async fn from_midi_file(data: Vec<u8>) -> Self {
+            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 {
+            let decoder = MidiFileDecoder::new_sequence(
+                sequence,
+                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,
+                },
+            }
+        }
     }
 }

src/lib.rs

@@ -1,12 +1,21 @@
 #![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).
 
-use bevy::{audio::AddAudioSource, prelude::*};
+#[cfg(all(feature = "bevy_audio", feature = "kira"))]
+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::{
-    io::{Cursor, Read},
-    sync::{Arc, OnceLock},
+    fs::{self, File},
+    io::Read,
+    path::PathBuf,
+    sync::{Arc, Mutex},
 };
 
 mod assets;
@@ -15,11 +24,22 @@ pub use assets::*;
 #[cfg(feature = "hl4mgm")]
 pub(crate) static HL4MGM: &[u8] = include_bytes!("./embedded_assets/hl4mgm.sf2");
 
-pub(crate) static SOUNDFONT: OnceLock<Arc<SoundFont>> = OnceLock::new();
+lazy_static! {
+    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 + Send + Sync + Clone + 'static> {
+pub struct RustySynthPlugin<R: Read + Clone + 'static> {
     /// Reader for soundfont data.
     pub soundfont: R,
 }
@@ -35,11 +55,50 @@ impl Default for RustySynthPlugin<Cursor<&[u8]>> {
 
 impl<R: Read + Send + Sync + Clone + 'static> Plugin for RustySynthPlugin<R> {
     fn build(&self, app: &mut App) {
-        let _ = SOUNDFONT.set(Arc::new(
+        *DEFAULT_SOUNDFONT.lock().unwrap() = Some(Arc::new(
             SoundFont::new(&mut self.soundfont.clone()).unwrap(),
         ));
-        app.add_audio_source::<MidiAudio>()
-            .init_asset::<MidiAudio>()
-            .init_asset_loader::<MidiAssetLoader>();
+        info!("Setting Soundfont Initially");
+        *SOUNDFONT.lock().unwrap() = DEFAULT_SOUNDFONT.lock().unwrap().clone();
+        app.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();
+            }
+        }
     }
 }