moont_web/

lib.rs

// Copyright (C) 2021-2026 Geoff Hill <geoff@geoffhill.org>
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or (at
// your option) any later version. Read COPYING.LESSER.txt for details.

//! WebAssembly wrapper for the moont CM-32L synthesizer.
//!
//! Provides a [`CM32LWeb`] struct that hooks into the Web Audio API
//! via `ScriptProcessorNode` for real-time audio output at 32 kHz.

use std::cell::RefCell;
use std::rc::Rc;

use moont::{CM32L, Frame, Synth, smf};
use wasm_bindgen::prelude::*;
use web_sys::{
    AudioContext, AudioContextOptions, AudioProcessingEvent,
    ScriptProcessorNode,
};

const BUFFER_SIZE: u32 = 1024;
const SAMPLE_RATE: f32 = 32000.0;

struct Inner {
    synth: CM32L,
    smf_events: Vec<smf::Event>,
    smf_index: usize,
}

impl Inner {
    fn feed_smf(&mut self, deadline: u32) {
        while self.smf_index < self.smf_events.len()
            && self.smf_events[self.smf_index].time() <= deadline
        {
            match &self.smf_events[self.smf_index] {
                smf::Event::Msg { time, msg } => {
                    self.synth.play_msg_at(*msg, *time);
                }
                smf::Event::Sysex { time, data } => {
                    self.synth.play_sysex_at(data, *time);
                }
            }
            self.smf_index += 1;
        }
    }
}

/// CM-32L synthesizer with Web Audio output.
#[wasm_bindgen]
pub struct CM32LWeb {
    inner: Rc<RefCell<Inner>>,
    _ctx: AudioContext,
    _processor: ScriptProcessorNode,
    _closure: Closure<dyn FnMut(AudioProcessingEvent)>,
}

fn setup(synth: CM32L) -> Result<CM32LWeb, JsValue> {
    let inner = Rc::new(RefCell::new(Inner {
        synth,
        smf_events: Vec::new(),
        smf_index: 0,
    }));

    let opts = AudioContextOptions::new();
    opts.set_sample_rate(SAMPLE_RATE);
    let ctx = AudioContext::new_with_context_options(&opts)?;

    let processor = ctx.create_script_processor_with_buffer_size_and_number_of_input_channels_and_number_of_output_channels(
        BUFFER_SIZE, 0, 2,
    )?;

    let inner_ref = inner.clone();
    let closure = Closure::wrap(Box::new(move |event: AudioProcessingEvent| {
        let buf = event.output_buffer().unwrap();
        let len = buf.length() as usize;
        let mut inner = inner_ref.borrow_mut();
        let current = inner.synth.current_time();
        inner.feed_smf(current + len as u32);
        let mut frames = vec![Frame(0, 0); len];
        inner.synth.render(&mut frames);
        drop(inner);

        let mut left = vec![0.0f32; len];
        let mut right = vec![0.0f32; len];
        for (i, f) in frames.iter().enumerate() {
            left[i] = f.0 as f32 / 32768.0;
            right[i] = f.1 as f32 / 32768.0;
        }
        buf.copy_to_channel(&left, 0).unwrap();
        buf.copy_to_channel(&right, 1).unwrap();
    }) as Box<dyn FnMut(AudioProcessingEvent)>);

    processor.set_onaudioprocess(Some(closure.as_ref().unchecked_ref()));
    processor.connect_with_audio_node(&ctx.destination())?;

    Ok(CM32LWeb {
        inner,
        _ctx: ctx,
        _processor: processor,
        _closure: closure,
    })
}

#[wasm_bindgen]
impl CM32LWeb {
    /// Creates a new CM-32L synthesizer using the bundled ROM.
    ///
    /// Requires the `bundle-rom` feature to be enabled.
    #[cfg(feature = "bundle-rom")]
    #[wasm_bindgen(constructor)]
    pub fn new() -> Result<CM32LWeb, JsValue> {
        let synth = CM32L::new(moont::Rom::bundled());
        setup(synth)
    }

    /// Creates a new CM-32L synthesizer from dynamically loaded ROM data.
    pub fn from_rom(
        control_rom: &[u8],
        pcm_rom: &[u8],
    ) -> Result<CM32LWeb, JsValue> {
        let rom = moont::Rom::new(control_rom, pcm_rom)
            .map_err(|e| JsValue::from_str(&format!("{e:?}")))?;
        let synth = CM32L::new(rom);
        setup(synth)
    }

    /// Plays a MIDI channel message from raw bytes (1-3 bytes).
    ///
    /// Returns `true` if the message was successfully enqueued.
    pub fn play_midi(&self, data: &[u8]) -> bool {
        if data.is_empty() || data.len() > 3 {
            return false;
        }
        let mut msg: u32 = 0;
        for (i, &b) in data.iter().enumerate() {
            msg |= (b as u32) << (i * 8);
        }
        self.inner.borrow_mut().synth.play_msg(msg)
    }

    /// Plays a SysEx message from raw bytes.
    ///
    /// Returns `true` if the message was successfully enqueued.
    pub fn play_sysex(&self, data: &[u8]) -> bool {
        self.inner.borrow_mut().synth.play_sysex(data)
    }

    /// Loads an SMF (Standard MIDI File) for incremental playback.
    ///
    /// Events are fed to the synthesizer incrementally during audio
    /// rendering. Returns the total duration in seconds, or throws
    /// on parse error.
    pub fn load_smf(&self, data: &[u8]) -> Result<f64, JsValue> {
        let events =
            smf::parse(data).map_err(|e| JsValue::from_str(&format!("{e}")))?;
        let last = events.last().map(|e| e.time()).unwrap_or(0);
        let total = last + 2 * SAMPLE_RATE as u32;
        let mut inner = self.inner.borrow_mut();
        inner.smf_events = events;
        inner.smf_index = 0;
        Ok(total as f64 / SAMPLE_RATE as f64)
    }

    /// Returns the current playback position in seconds.
    pub fn current_time(&self) -> f64 {
        self.inner.borrow().synth.current_time() as f64 / SAMPLE_RATE as f64
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_midi_packing() {
        let data: &[u8] = &[0x90, 0x3C, 0x7F];
        let mut msg: u32 = 0;
        for (i, &b) in data.iter().enumerate() {
            msg |= (b as u32) << (i * 8);
        }
        assert_eq!(msg, 0x007F3C90);
    }
}