skyler
/
Lightningbeam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sound is playing!

This commit is contained in:
Skyler Lehmkuhl 2025-01-25 05:39:57 -05:00
parent 98d6e82397
commit cdd1ff2cbf
8 changed files with 952 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
lightningbeam-core/src/audio.rs
View File

@ -1,5 +1,5 @@
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use cpal::{Sample, SampleFormat, StreamConfig, SupportedBufferSize, SampleRate, BufferSize};
use cpal::{Sample};
use std::sync::{Arc, Mutex};
use crate::{TrackManager, Timestamp, Duration, SampleCount, AudioOutput, PlaybackState};
@ -44,15 +44,29 @@ where
self.sample_rate = supported_config.sample_rate.0;
let num_channels = supported_config.channels as usize; // Get channel count
let buffer_size_range = match config.buffer_size() {
cpal::SupportedBufferSize::Range { min, max } => (*min, *max),
cpal::SupportedBufferSize::Unknown => {
// Use a reasonable default range if the device doesn't specify
(256, 4096)
}
};
// Define the desired buffer size and clamp it to the supported range
let desired_buffer_size = 2048;
let clamped_buffer_size = desired_buffer_size.clamp(buffer_size_range.0, buffer_size_range.1);
let mut stream_config = supported_config.clone();
stream_config.buffer_size = cpal::BufferSize::Fixed(clamped_buffer_size);
let track_manager = self.track_manager.clone();
let playback_state = self.playback_state.clone();
let timestamp = self.timestamp.clone();
let sample_rate = self.sample_rate;
let err_fn = |err| eprintln!("Audio stream error: {:?}", err);
let stream = device.build_output_stream(
&supported_config,
&stream_config,
move |data: &mut [T], _: &cpal::OutputCallbackInfo| {
if let Some(track_manager) = &track_manager {
let num_frames = data.len() / num_channels; // Stereo: divide by 2
@ -60,14 +74,12 @@ where
let chunk_duration = Duration::new(num_frames as f64 / sample_rate as f64);
let mut track_manager = track_manager.lock().unwrap();
let playing = matches!(playback_state, PlaybackState::Playing);
let mut timestamp_guard = timestamp.lock().unwrap();
let timestamp = &mut *timestamp_guard;
let chunk = track_manager.update_audio(
timestamp.clone(),
playing,
sample_count,
sample_rate,
);

206
lightningbeam-core/src/lib.rs
View File

@ -5,112 +5,89 @@ use audio::{CpalAudioOutput};
use log::{Level, LevelFilter, Log, Metadata, Record, SetLoggerError};
use std::sync::{Arc, Mutex};
use std::fmt;
#[cfg(feature = "wasm")]
mod wasm_imports {
pub use wasm_bindgen::prelude::*;
pub use web_sys::console;
use wasm_logger;
}
#[cfg(feature = "wasm")]
use wasm_imports::*;
pub trait AudioTrack: Send {
/// Render a chunk of audio for the given timestamp and duration.
fn render_chunk(&mut self, timestamp: Timestamp, duration: SampleCount) -> Vec<f32>;
/// Get the sample rate of the audio track.
fn sample_rate(&self) -> u32;
pub trait Track: Send {
fn get_name(&self) -> &str {
"Unnamed Track"
}
pub trait VideoTrack: Send {
/// Render a frame for the given timestamp.
fn render_frame(&self, timestamp: Timestamp) -> Frame;
fn set_name(&mut self, _name: String) {
}
/// Render audio for the given timestamp and duration.
/// Returns `None` if this track doesn't produce audio.
fn render_audio(&mut self, _timestamp: Timestamp, _duration: SampleCount, _sample_rate: u32, _playing: bool) -> Option<Vec<f32>> {
None
}
/// Get the frame rate of the video track.
fn frame_rate(&self) -> f64;
/// Render a video frame for the given timestamp.
/// Returns `None` if this track doesn't produce video.
fn render_video(&self, _timestamp: Timestamp, _playing: bool) -> Option<Frame> {
None
}
}
pub struct TrackManager {
audio_tracks: Vec<Box<dyn AudioTrack>>,
video_tracks: Vec<Box<dyn VideoTrack>>,
// sample_rate: u32,
// frame_duration: Duration, // Duration of each frame in seconds (e.g., 1/60 for 60 FPS)
tracks: Vec<Box<dyn Track>>,
timestamp: Timestamp,
playback_state: PlaybackState,
}
impl TrackManager {
pub fn new(sample_rate: u32, frame_duration: f64) -> Self {
pub fn new() -> Self {
Self {
audio_tracks: Vec::new(),
video_tracks: Vec::new(),
// sample_rate,
// frame_duration: Duration::new(frame_duration),
playback_state: PlaybackState::Stopped,
tracks: Vec::new(),
timestamp: Timestamp::from_seconds(0.0),
playback_state: PlaybackState::Stopped,
}
}
pub fn add_audio_track(&mut self, track: Box<dyn AudioTrack>) {
self.audio_tracks.push(track);
pub fn add_track(&mut self, track: Box<dyn Track>) {
self.tracks.push(track);
}
pub fn add_video_track(&mut self, track: Box<dyn VideoTrack>) {
self.video_tracks.push(track);
pub fn update_audio(&mut self, timestamp: Timestamp, chunk_size: SampleCount, sample_rate: u32) -> Vec<f32> {
let mut mixed = vec![0.0; chunk_size.as_usize()];
let playing = matches!(self.playback_state, PlaybackState::Playing);
for track in &mut self.tracks {
if let Some(samples) = track.render_audio(timestamp, chunk_size, sample_rate, playing) {
for (i, sample) in samples.iter().enumerate() {
mixed[i] += *sample;
}
}
}
mixed
}
pub fn update_video(&self, timestamp: Timestamp) -> Vec<Frame> {
let playing = matches!(self.playback_state, PlaybackState::Playing);
self.tracks
.iter()
.filter_map(|track| track.render_video(timestamp, playing))
.collect()
}
pub fn play(&mut self, start_timestamp: Timestamp) {
self.timestamp = start_timestamp;
self.playback_state = PlaybackState::Playing;
}
pub fn stop(&mut self) {
self.playback_state = PlaybackState::Stopped;
}
// pub fn play(&mut self, timestamp: Timestamp, audio_output: &mut dyn AudioOutput, video_output: &mut dyn FrameTarget) {
// let mut timestamp = timestamp.clone();
// // Main playback loop
// loop {
// // Render and play audio chunks
// let mut audio_mix: Vec<f32> = vec![0.0; self.frame_duration.to_samples(self.sample_rate) as usize];
// for track in &mut self.audio_tracks {
// let chunk = track.render_chunk(timestamp, self.frame_duration);
// for (i, sample) in chunk.iter().enumerate() {
// audio_mix[i] += sample; // Simple mixing (sum of samples)
// }
// }
// audio_output.play_chunk(audio_mix);
// // Render video frames
// for track in &self.video_tracks {
// let track_frame = track.render_frame(timestamp);
// }
// // Update timestamp
// timestamp += self.frame_duration;
// // Break condition (e.g., end of tracks)
// if self.audio_tracks.iter().all(|t| t.render_chunk(timestamp, self.frame_duration).is_empty()) {
// break;
// }
// }
// }
pub fn update_audio(&mut self, timestamp: Timestamp, playing: bool, chunk_size: SampleCount, sample_rate: u32) -> Vec<f32> {
let mut mixed_audio = vec![0.0; chunk_size.as_usize()];
// TODO: render video
for track in &mut self.audio_tracks {
let track_audio = track.render_chunk(timestamp, chunk_size);
for (i, sample) in track_audio.iter().enumerate() {
mixed_audio[i] += *sample; // Simple mixing, add samples together
}
}
mixed_audio
pub fn get_tracks(&self) -> &Vec<Box<dyn Track>> {
&self.tracks
}
}
@ -136,39 +113,75 @@ enum PlaybackState {
pub struct SineWaveTrack {
frequency: f32,
phase: f32,
sample_rate: u32,
name: String,
}
impl SineWaveTrack {
pub fn new(frequency: f32, sample_rate: u32) -> Self {
pub fn new(frequency: f32) -> Self {
Self {
frequency,
phase: 0.0,
sample_rate,
name: "Sine Wave Track".to_string(),
}
}
}
impl AudioTrack for SineWaveTrack {
fn render_chunk(&mut self, timestamp: Timestamp, chunk_size: SampleCount) -> Vec<f32> {
impl Track for SineWaveTrack {
fn get_name(&self) -> &str {
&self.name
}
fn set_name(&mut self, name: String) {
self.name = name;
}
fn render_audio(&mut self, _timestamp: Timestamp, chunk_size: SampleCount, sample_rate: u32, playing: bool) -> Option<Vec<f32>> {
let mut chunk = Vec::with_capacity(chunk_size.as_usize());
let phase_increment = (2.0 * std::f32::consts::PI * self.frequency) / self.sample_rate as f32;
let phase_increment = (2.0 * std::f32::consts::PI * self.frequency) / sample_rate as f32;
for _ in 0..chunk_size.as_usize() {
chunk.push((self.phase).sin());
if playing {
chunk.push((self.phase).sin()*0.25);
} else {
chunk.push(0.0);
}
self.phase += phase_increment;
if self.phase > 2.0 * std::f32::consts::PI {
self.phase -= 2.0 * std::f32::consts::PI;
}
}
chunk
}
fn sample_rate(&self) -> u32 {
self.sample_rate
Some(chunk)
}
}
#[cfg(feature="wasm")]
#[wasm_bindgen]
pub struct JsTrack {
name: String,
}
#[cfg(feature="wasm")]
#[wasm_bindgen]
impl JsTrack {
#[wasm_bindgen(getter)]
pub fn name(&self) -> String {
self.name.clone()
}
}
#[cfg(feature="wasm")]
impl fmt::Display for JsTrack {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "JsTrack {{ name: {} }}", self.name)
}
}
#[cfg(feature="wasm")]
#[wasm_bindgen]
impl JsTrack {
#[wasm_bindgen(js_name = toString)]
pub fn to_string(&self) -> String {
format!("{}", self) // Calls the Display implementation
}
}
#[cfg(feature="wasm")]
#[wasm_bindgen]
@ -183,9 +196,9 @@ pub struct CoreInterface {
#[wasm_bindgen]
impl CoreInterface {
#[wasm_bindgen(constructor)]
pub fn new(sample_rate: u32, frame_duration: f64) -> Self {
pub fn new() -> Self {
Self {
track_manager: Arc::new(Mutex::new(TrackManager::new(sample_rate, frame_duration))),
track_manager: Arc::new(Mutex::new(TrackManager::new())),
cpal_audio_output: Box::new(CpalAudioOutput::new())
}
}
@ -193,16 +206,43 @@ impl CoreInterface {
println!("Init CoreInterface");
let track_manager_clone = self.track_manager.clone();
self.cpal_audio_output.register_track_manager(track_manager_clone);
self.cpal_audio_output.start();
let _ = self.cpal_audio_output.start();
}
pub fn play(&mut self, timestamp: f64) {
// Lock the Mutex to get access to TrackManager
let mut track_manager = self.track_manager.lock().unwrap();
track_manager.play(Timestamp::new(timestamp));
}
pub fn stop(&mut self) {
// Lock the Mutex to get access to TrackManager
let mut track_manager = self.track_manager.lock().unwrap();
track_manager.stop();
}
pub fn add_sine_track(&mut self, frequency: f32) -> Result<(), String> {
if frequency.is_nan() || frequency.is_infinite() || frequency <= 0.0 {
return Err(format!("Invalid frequency: {}", frequency));
}
log::info!("Freq: {}", frequency);
let mut track_manager = self.track_manager.lock().unwrap();
let sine_track = SineWaveTrack::new(frequency);
track_manager.add_track(Box::new(sine_track));
Ok(())
}
pub fn get_timestamp(&mut self) -> f64 {
self.cpal_audio_output.get_timestamp().as_seconds()
}
pub fn get_tracks(&mut self) -> Vec<JsTrack> {
let track_manager = self.track_manager.lock().unwrap();
let tracks = track_manager.get_tracks();
tracks
.iter()
.map(|track| JsTrack {
name: track.get_name().to_string(),
})
.collect()
}
}

13
src/main.js
View File

@ -78,6 +78,8 @@ const { Menu, MenuItem, PredefinedMenuItem, Submenu } = window.__TAURI__.menu;
const { getCurrentWindow } = window.__TAURI__.window;
const { getVersion } = window.__TAURI__.app;
import init, { CoreInterface } from './pkg/lightningbeam_core.js';
window.onerror = (message, source, lineno, colno, error) => {
invoke("error", { msg: `${message} at ${source}:${lineno}:${colno}\n${error?.stack || ''}` });
};
@ -8408,3 +8410,14 @@ if (window.openedFiles?.length>0) {
newWindow(window.openedFiles[i])
}
}
async function testAudio() {
console.log("Starting rust")
await init();
console.log("Rust started")
const coreInterface = new CoreInterface(100, 100)
coreInterface.init()
coreInterface.play(0.0)
console.log(coreInterface)
}
testAudio()

66
src/pkg/lightningbeam_core.d.ts vendored Normal file
View File

@ -0,0 +1,66 @@
/* tslint:disable */
/* eslint-disable */
export function main_js(): void;
export class CoreInterface {
free(): void;
constructor();
init(): void;
play(timestamp: number): void;
stop(): void;
add_sine_track(frequency: number): void;
get_timestamp(): number;
get_tracks(): JsTrack[];
}
export class JsTrack {
private constructor();
free(): void;
toString(): string;
readonly name: string;
}
export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
export interface InitOutput {
readonly memory: WebAssembly.Memory;
readonly __wbg_jstrack_free: (a: number, b: number) => void;
readonly jstrack_name: (a: number, b: number) => void;
readonly jstrack_toString: (a: number, b: number) => void;
readonly __wbg_coreinterface_free: (a: number, b: number) => void;
readonly coreinterface_new: () => number;
readonly coreinterface_init: (a: number) => void;
readonly coreinterface_play: (a: number, b: number) => void;
readonly coreinterface_stop: (a: number) => void;
readonly coreinterface_add_sine_track: (a: number, b: number, c: number) => void;
readonly coreinterface_get_timestamp: (a: number) => number;
readonly coreinterface_get_tracks: (a: number, b: number) => void;
readonly main_js: () => void;
readonly __wbindgen_exn_store: (a: number) => void;
readonly __wbindgen_export_1: WebAssembly.Table;
readonly __wbindgen_malloc: (a: number, b: number) => number;
readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
readonly __wbindgen_free: (a: number, b: number, c: number) => void;
readonly _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h03a328ab39659ec3: (a: number, b: number) => void;
readonly __wbindgen_start: () => void;
}
export type SyncInitInput = BufferSource | WebAssembly.Module;
/**
* Instantiates the given `module`, which can either be bytes or
* a precompiled `WebAssembly.Module`.
*
* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
*
* @returns {InitOutput}
*/
export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
/**
* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
* for everything else, calls `WebAssembly.instantiate` directly.
*
* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
*
* @returns {Promise<InitOutput>}
*/
export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

655
src/pkg/lightningbeam_core.js Normal file
View File

@ -0,0 +1,655 @@
const lAudioContext = (typeof AudioContext !== 'undefined' ? AudioContext : (typeof webkitAudioContext !== 'undefined' ? webkitAudioContext : undefined));
let wasm;
const heap = new Array(128).fill(undefined);
heap.push(undefined, null, true, false);
function getObject(idx) { return heap[idx]; }
let heap_next = heap.length;
function addHeapObject(obj) {
if (heap_next === heap.length) heap.push(heap.length + 1);
const idx = heap_next;
heap_next = heap[idx];
heap[idx] = obj;
return idx;
}
function handleError(f, args) {
try {
return f.apply(this, args);
} catch (e) {
wasm.__wbindgen_exn_store(addHeapObject(e));
}
}
let cachedFloat32ArrayMemory0 = null;
function getFloat32ArrayMemory0() {
if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
}
return cachedFloat32ArrayMemory0;
}
function getArrayF32FromWasm0(ptr, len) {
ptr = ptr >>> 0;
return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
}
const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
let cachedUint8ArrayMemory0 = null;
function getUint8ArrayMemory0() {
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
}
return cachedUint8ArrayMemory0;
}
function getStringFromWasm0(ptr, len) {
ptr = ptr >>> 0;
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}
function isLikeNone(x) {
return x === undefined || x === null;
}
function dropObject(idx) {
if (idx < 132) return;
heap[idx] = heap_next;
heap_next = idx;
}
function takeObject(idx) {
const ret = getObject(idx);
dropObject(idx);
return ret;
}
const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(state => {
wasm.__wbindgen_export_1.get(state.dtor)(state.a, state.b)
});
function makeMutClosure(arg0, arg1, dtor, f) {
const state = { a: arg0, b: arg1, cnt: 1, dtor };
const real = (...args) => {
// First up with a closure we increment the internal reference
// count. This ensures that the Rust closure environment won't
// be deallocated while we're invoking it.
state.cnt++;
const a = state.a;
state.a = 0;
try {
return f(a, state.b, ...args);
} finally {
if (--state.cnt === 0) {
wasm.__wbindgen_export_1.get(state.dtor)(a, state.b);
CLOSURE_DTORS.unregister(state);
} else {
state.a = a;
}
}
};
real.original = state;
CLOSURE_DTORS.register(real, state, state);
return real;
}
function debugString(val) {
// primitive types
const type = typeof val;
if (type == 'number' || type == 'boolean' || val == null) {
return `${val}`;
}
if (type == 'string') {
return `"${val}"`;
}
if (type == 'symbol') {
const description = val.description;
if (description == null) {
return 'Symbol';
} else {
return `Symbol(${description})`;
}
}
if (type == 'function') {
const name = val.name;
if (typeof name == 'string' && name.length > 0) {
return `Function(${name})`;
} else {
return 'Function';
}
}
// objects
if (Array.isArray(val)) {
const length = val.length;
let debug = '[';
if (length > 0) {
debug += debugString(val[0]);
}
for(let i = 1; i < length; i++) {
debug += ', ' + debugString(val[i]);
}
debug += ']';
return debug;
}
// Test for built-in
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
let className;
if (builtInMatches && builtInMatches.length > 1) {
className = builtInMatches[1];
} else {
// Failed to match the standard '[object ClassName]'
return toString.call(val);
}
if (className == 'Object') {
// we're a user defined class or Object
// JSON.stringify avoids problems with cycles, and is generally much
// easier than looping through ownProperties of `val`.
try {
return 'Object(' + JSON.stringify(val) + ')';
} catch (_) {
return 'Object';
}
}
// errors
if (val instanceof Error) {
return `${val.name}: ${val.message}\n${val.stack}`;
}
// TODO we could test for more things here, like `Set`s and `Map`s.
return className;
}
let WASM_VECTOR_LEN = 0;
const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
? function (arg, view) {
return cachedTextEncoder.encodeInto(arg, view);
}
: function (arg, view) {
const buf = cachedTextEncoder.encode(arg);
view.set(buf);
return {
read: arg.length,
written: buf.length
};
});
function passStringToWasm0(arg, malloc, realloc) {
if (realloc === undefined) {
const buf = cachedTextEncoder.encode(arg);
const ptr = malloc(buf.length, 1) >>> 0;
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
WASM_VECTOR_LEN = buf.length;
return ptr;
}
let len = arg.length;
let ptr = malloc(len, 1) >>> 0;
const mem = getUint8ArrayMemory0();
let offset = 0;
for (; offset < len; offset++) {
const code = arg.charCodeAt(offset);
if (code > 0x7F) break;
mem[ptr + offset] = code;
}
if (offset !== len) {
if (offset !== 0) {
arg = arg.slice(offset);
}
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
const ret = encodeString(arg, view);
offset += ret.written;
ptr = realloc(ptr, len, offset, 1) >>> 0;
}
WASM_VECTOR_LEN = offset;
return ptr;
}
let cachedDataViewMemory0 = null;
function getDataViewMemory0() {
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
}
return cachedDataViewMemory0;
}
function getArrayJsValueFromWasm0(ptr, len) {
ptr = ptr >>> 0;
const mem = getDataViewMemory0();
const result = [];
for (let i = ptr; i < ptr + 4 * len; i += 4) {
result.push(takeObject(mem.getUint32(i, true)));
}
return result;
}
export function main_js() {
wasm.main_js();
}
function __wbg_adapter_18(arg0, arg1) {
wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h03a328ab39659ec3(arg0, arg1);
}
const CoreInterfaceFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_coreinterface_free(ptr >>> 0, 1));
export class CoreInterface {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
CoreInterfaceFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_coreinterface_free(ptr, 0);
}
constructor() {
const ret = wasm.coreinterface_new();
this.__wbg_ptr = ret >>> 0;
CoreInterfaceFinalization.register(this, this.__wbg_ptr, this);
return this;
}
init() {
wasm.coreinterface_init(this.__wbg_ptr);
}
/**
* @param {number} timestamp
*/
play(timestamp) {
wasm.coreinterface_play(this.__wbg_ptr, timestamp);
}
stop() {
wasm.coreinterface_stop(this.__wbg_ptr);
}
/**
* @param {number} frequency
*/
add_sine_track(frequency) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.coreinterface_add_sine_track(retptr, this.__wbg_ptr, frequency);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
if (r1) {
throw takeObject(r0);
}
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* @returns {number}
*/
get_timestamp() {
const ret = wasm.coreinterface_get_timestamp(this.__wbg_ptr);
return ret;
}
/**
* @returns {JsTrack[]}
*/
get_tracks() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.coreinterface_get_tracks(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 4, 4);
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
const JsTrackFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_jstrack_free(ptr >>> 0, 1));
export class JsTrack {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(JsTrack.prototype);
obj.__wbg_ptr = ptr;
JsTrackFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
JsTrackFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_jstrack_free(ptr, 0);
}
/**
* @returns {string}
*/
get name() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.jstrack_name(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
toString() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.jstrack_toString(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
async function __wbg_load(module, imports) {
if (typeof Response === 'function' && module instanceof Response) {
if (typeof WebAssembly.instantiateStreaming === 'function') {
try {
return await WebAssembly.instantiateStreaming(module, imports);
} catch (e) {
if (module.headers.get('Content-Type') != 'application/wasm') {
console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
} else {
throw e;
}
}
}
const bytes = await module.arrayBuffer();
return await WebAssembly.instantiate(bytes, imports);
} else {
const instance = await WebAssembly.instantiate(module, imports);
if (instance instanceof WebAssembly.Instance) {
return { instance, module };
} else {
return instance;
}
}
}
function __wbg_get_imports() {
const imports = {};
imports.wbg = {};
imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
const ret = getObject(arg0).call(getObject(arg1));
return addHeapObject(ret);
}, arguments) };
imports.wbg.__wbg_close_5a97ef05b337f8ce = function() { return handleError(function (arg0) {
const ret = getObject(arg0).close();
return addHeapObject(ret);
}, arguments) };
imports.wbg.__wbg_connect_b22945d106632a36 = function() { return handleError(function (arg0, arg1) {
const ret = getObject(arg0).connect(getObject(arg1));
return addHeapObject(ret);
}, arguments) };
imports.wbg.__wbg_copyToChannel_b81ecf19fd54e146 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
getObject(arg0).copyToChannel(getArrayF32FromWasm0(arg1, arg2), arg3);
}, arguments) };
imports.wbg.__wbg_createBufferSource_f7860a96f709acbd = function() { return handleError(function (arg0) {
const ret = getObject(arg0).createBufferSource();
return addHeapObject(ret);
}, arguments) };
imports.wbg.__wbg_createBuffer_926beeec3ff39b5a = function() { return handleError(function (arg0, arg1, arg2, arg3) {
const ret = getObject(arg0).createBuffer(arg1 >>> 0, arg2 >>> 0, arg3);
return addHeapObject(ret);
}, arguments) };
imports.wbg.__wbg_currentTime_adef4d803f58eb66 = function(arg0) {
const ret = getObject(arg0).currentTime;
return ret;
};
imports.wbg.__wbg_destination_6400091abd6f01b3 = function(arg0) {
const ret = getObject(arg0).destination;
return addHeapObject(ret);
};
imports.wbg.__wbg_eval_e10dc02e9547f640 = function() { return handleError(function (arg0, arg1) {
const ret = eval(getStringFromWasm0(arg0, arg1));
return addHeapObject(ret);
}, arguments) };
imports.wbg.__wbg_instanceof_Window_def73ea0955fc569 = function(arg0) {
let result;
try {
result = getObject(arg0) instanceof Window;
} catch (_) {
result = false;
}
const ret = result;
return ret;
};
imports.wbg.__wbg_jstrack_new = function(arg0) {
const ret = JsTrack.__wrap(arg0);
return addHeapObject(ret);
};
imports.wbg.__wbg_log_c222819a41e063d3 = function(arg0) {
console.log(getObject(arg0));
};
imports.wbg.__wbg_maxChannelCount_a06f8ca4190698ed = function(arg0) {
const ret = getObject(arg0).maxChannelCount;
return ret;
};
imports.wbg.__wbg_new_405e22f390576ce2 = function() {
const ret = new Object();
return addHeapObject(ret);
};
imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
const ret = new Function(getStringFromWasm0(arg0, arg1));
return addHeapObject(ret);
};
imports.wbg.__wbg_newwithcontextoptions_b62c06fed7900366 = function() { return handleError(function (arg0) {
const ret = new lAudioContext(getObject(arg0));
return addHeapObject(ret);
}, arguments) };
imports.wbg.__wbg_resume_35efdc4ffe13bf18 = function() { return handleError(function (arg0) {
const ret = getObject(arg0).resume();
return addHeapObject(ret);
}, arguments) };
imports.wbg.__wbg_setTimeout_f2fe5af8e3debeb3 = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).setTimeout(getObject(arg1), arg2);
return ret;
}, arguments) };
imports.wbg.__wbg_setbuffer_10a9ee2a05c73896 = function(arg0, arg1) {
getObject(arg0).buffer = getObject(arg1);
};
imports.wbg.__wbg_setchannelCount_876fcf5798895180 = function(arg0, arg1) {
getObject(arg0).channelCount = arg1 >>> 0;
};
imports.wbg.__wbg_setonended_00ff85c70a4f819f = function(arg0, arg1) {
getObject(arg0).onended = getObject(arg1);
};
imports.wbg.__wbg_setsamplerate_8bc3fd769a6db02b = function(arg0, arg1) {
getObject(arg0).sampleRate = arg1;
};
imports.wbg.__wbg_start_e81f89e130c3c86e = function() { return handleError(function (arg0, arg1) {
getObject(arg0).start(arg1);
}, arguments) };
imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
const ret = typeof global === 'undefined' ? null : global;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
};
imports.wbg.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
const ret = typeof globalThis === 'undefined' ? null : globalThis;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
};
imports.wbg.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
const ret = typeof self === 'undefined' ? null : self;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
};
imports.wbg.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
const ret = typeof window === 'undefined' ? null : window;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
};
imports.wbg.__wbindgen_boolean_get = function(arg0) {
const v = getObject(arg0);
const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
return ret;
};
imports.wbg.__wbindgen_cb_drop = function(arg0) {
const obj = takeObject(arg0).original;
if (obj.cnt-- == 1) {
obj.a = 0;
return true;
}
const ret = false;
return ret;
};
imports.wbg.__wbindgen_closure_wrapper99 = function(arg0, arg1, arg2) {
const ret = makeMutClosure(arg0, arg1, 40, __wbg_adapter_18);
return addHeapObject(ret);
};
imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
const ret = debugString(getObject(arg1));
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
};
imports.wbg.__wbindgen_is_undefined = function(arg0) {
const ret = getObject(arg0) === undefined;
return ret;
};
imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
const ret = getObject(arg0);
return addHeapObject(ret);
};
imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
takeObject(arg0);
};
imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
const ret = getStringFromWasm0(arg0, arg1);
return addHeapObject(ret);
};
imports.wbg.__wbindgen_throw = function(arg0, arg1) {
throw new Error(getStringFromWasm0(arg0, arg1));
};
return imports;
}
function __wbg_init_memory(imports, memory) {
}
function __wbg_finalize_init(instance, module) {
wasm = instance.exports;
__wbg_init.__wbindgen_wasm_module = module;
cachedDataViewMemory0 = null;
cachedFloat32ArrayMemory0 = null;
cachedUint8ArrayMemory0 = null;
wasm.__wbindgen_start();
return wasm;
}
function initSync(module) {
if (wasm !== undefined) return wasm;
if (typeof module !== 'undefined') {
if (Object.getPrototypeOf(module) === Object.prototype) {
({module} = module)
} else {
console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
}
}
const imports = __wbg_get_imports();
__wbg_init_memory(imports);
if (!(module instanceof WebAssembly.Module)) {
module = new WebAssembly.Module(module);
}
const instance = new WebAssembly.Instance(module, imports);
return __wbg_finalize_init(instance, module);
}
async function __wbg_init(module_or_path) {
if (wasm !== undefined) return wasm;
if (typeof module_or_path !== 'undefined') {
if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
({module_or_path} = module_or_path)
} else {
console.warn('using deprecated parameters for the initialization function; pass a single object instead')
}
}
if (typeof module_or_path === 'undefined') {
module_or_path = new URL('lightningbeam_core_bg.wasm', import.meta.url);
}
const imports = __wbg_get_imports();
if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
module_or_path = fetch(module_or_path);
}
__wbg_init_memory(imports);
const { instance, module } = await __wbg_load(await module_or_path, imports);
return __wbg_finalize_init(instance, module);
}
export { initSync };
export default __wbg_init;

BIN
src/pkg/lightningbeam_core_bg.wasm Normal file
View File

Binary file not shown.

23
src/pkg/lightningbeam_core_bg.wasm.d.ts vendored Normal file
View File

@ -0,0 +1,23 @@
/* tslint:disable */
/* eslint-disable */
export const memory: WebAssembly.Memory;
export const __wbg_jstrack_free: (a: number, b: number) => void;
export const jstrack_name: (a: number, b: number) => void;
export const jstrack_toString: (a: number, b: number) => void;
export const __wbg_coreinterface_free: (a: number, b: number) => void;
export const coreinterface_new: () => number;
export const coreinterface_init: (a: number) => void;
export const coreinterface_play: (a: number, b: number) => void;
export const coreinterface_stop: (a: number) => void;
export const coreinterface_add_sine_track: (a: number, b: number, c: number) => void;
export const coreinterface_get_timestamp: (a: number) => number;
export const coreinterface_get_tracks: (a: number, b: number) => void;
export const main_js: () => void;
export const __wbindgen_exn_store: (a: number) => void;
export const __wbindgen_export_1: WebAssembly.Table;
export const __wbindgen_malloc: (a: number, b: number) => number;
export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
export const __wbindgen_add_to_stack_pointer: (a: number) => number;
export const __wbindgen_free: (a: number, b: number, c: number) => void;
export const _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h03a328ab39659ec3: (a: number, b: number) => void;
export const __wbindgen_start: () => void;

14
src/pkg/package.json Normal file
View File

@ -0,0 +1,14 @@
{
"name": "lightningbeam-core",
"version": "0.1.0",
"files": [
"lightningbeam_core_bg.wasm",
"lightningbeam_core.js",
"lightningbeam_core.d.ts"
],
"module": "lightningbeam_core.js",
"types": "lightningbeam_core.d.ts",
"sideEffects": [
"./snippets/*"
]
}