3dtours
cca970c348
Root cause: selectInstrument called before getAudioContext triggers init. _initialized=false → selectInstrument returns immediately → no sound bank. Fix: selectInstrument creates AudioContext + calls init() if not ready, waits for completion before proceeding with bank/program routing.
432 lines
23 KiB
JavaScript
432 lines
23 KiB
JavaScript
(function () {
|
|
'use strict';
|
|
|
|
const activeOscillators = {};
|
|
|
|
let __gainNode = null;
|
|
const getCtx = () => {
|
|
if (typeof getAudioContext === 'function') {
|
|
const ctx = getAudioContext();
|
|
if (!__gainNode) {
|
|
__gainNode = ctx.createGain();
|
|
__gainNode.gain.value = 0.3;
|
|
__gainNode.connect(ctx.destination);
|
|
}
|
|
return ctx;
|
|
}
|
|
if (!window.__sharedAudioCtx) {
|
|
window.__sharedAudioCtx = new (window.AudioContext || window.webkitAudioContext)();
|
|
}
|
|
if (window.__sharedAudioCtx.state === 'suspended') {
|
|
window.__sharedAudioCtx.resume();
|
|
}
|
|
if (!__gainNode) {
|
|
__gainNode = window.__sharedAudioCtx.createGain();
|
|
__gainNode.gain.value = 0.3;
|
|
__gainNode.connect(window.__sharedAudioCtx.destination);
|
|
}
|
|
return window.__sharedAudioCtx;
|
|
};
|
|
|
|
const _channels = Array.from({ length: 16 }, () => ({ bank: 0, program: 0, isPercussion: false }));
|
|
let _nextMelodicChannel = 0;
|
|
|
|
let _synthInstance = null;
|
|
let _initialized = false;
|
|
let _currentSfId = null;
|
|
|
|
// ── SpessaSynth addSoundBank wrapper with timeout ──
|
|
async function _addBankWithTimeout(synth, buffer, sfId, timeoutMs) {
|
|
console.log("[SonicSF][DEBUG] _addBankWithTimeout start sfId=" + sfId + " size=" + buffer.byteLength + " timeout=" + timeoutMs);
|
|
return new Promise((resolve) => {
|
|
const timer = setTimeout(() => {
|
|
console.warn("[SonicSF][DEBUG] _addBankWithTimeout TIMEOUT after " + timeoutMs + "ms for " + sfId);
|
|
resolve(false);
|
|
}, timeoutMs);
|
|
|
|
synth.soundBankManager.addSoundBank(buffer.slice(0), sfId).then(() => {
|
|
clearTimeout(timer);
|
|
const bl = synth.soundBankManager?.soundBankList?.length ?? 0;
|
|
console.log("[SonicSF][DEBUG] _addBankWithTimeout SUCCESS for " + sfId + " banks=" + bl);
|
|
resolve(true);
|
|
}).catch((err) => {
|
|
clearTimeout(timer);
|
|
console.error("[SonicSF][DEBUG] _addBankWithTimeout REJECTED for " + sfId + " error=" + err);
|
|
resolve(false);
|
|
});
|
|
});
|
|
}
|
|
|
|
const SonicSF = {
|
|
loadedFonts: {},
|
|
|
|
// ════════════════════════════════════════════════
|
|
// PHASE 1: Init SpessaSynth
|
|
// ════════════════════════════════════════════════
|
|
init: async function (audioContext) {
|
|
console.log("[SonicSF][DEBUG] PHASE1: init start");
|
|
if (!window.SpessaSynthClass || !window.__SpessaSynthCDN) {
|
|
console.warn("[SonicSF][DEBUG] PHASE1: SpessaSynth CDN not available");
|
|
return;
|
|
}
|
|
try {
|
|
console.log("[SonicSF][DEBUG] PHASE1: loading worklet from " + window.__SpessaSynthCDN + "spessasynth_processor.min.js");
|
|
const procUrl = window.__SpessaSynthCDN + "spessasynth_processor.min.js";
|
|
await audioContext.audioWorklet.addModule(procUrl);
|
|
console.log("[SonicSF][DEBUG] PHASE1: worklet loaded, creating WorkletSynthesizer");
|
|
_synthInstance = new window.SpessaSynthClass(audioContext);
|
|
console.log("[SonicSF][DEBUG] PHASE1: connecting to destination");
|
|
_synthInstance.connect(audioContext.destination);
|
|
console.log("[SonicSF][DEBUG] PHASE1: awaiting isReady");
|
|
await _synthInstance.isReady;
|
|
_initialized = true;
|
|
console.log("[SonicSF][DEBUG] PHASE1: SpessaSynth engine ready. isReady resolved.");
|
|
} catch (e) {
|
|
console.warn("[SonicSF][DEBUG] PHASE1: AudioWorklet failed:", e);
|
|
try {
|
|
console.log("[SonicSF][DEBUG] PHASE1: trying WorkerSynthesizer");
|
|
const mod = await import("https://cdn.jsdelivr.net/npm/spessasynth_lib@4.3.1/dist/index.js");
|
|
_synthInstance = new mod.WorkerSynthesizer(audioContext);
|
|
_synthInstance.connect(audioContext.destination);
|
|
await _synthInstance.isReady;
|
|
_initialized = true;
|
|
console.log("[SonicSF][DEBUG] PHASE1: WorkerSynthesizer ready.");
|
|
} catch (e2) {
|
|
console.error("[SonicSF][DEBUG] PHASE1: All paths failed:", e2);
|
|
}
|
|
}
|
|
},
|
|
|
|
// ════════════════════════════════════════════════
|
|
// PHASE 2: Load SF → IndexedDB → SpessaSynth
|
|
// ════════════════════════════════════════════════
|
|
loadSoundFont: async function (sfId) {
|
|
console.log("[SonicSF][DEBUG] PHASE2: loadSoundFont start sfId=" + sfId + " _initialized=" + _initialized + " _currentSfId=" + _currentSfId);
|
|
if (!_initialized || !_synthInstance) {
|
|
console.log("[SonicSF][DEBUG] PHASE2: engine not ready, returning false");
|
|
return false;
|
|
}
|
|
if (_currentSfId === sfId) {
|
|
console.log("[SonicSF][DEBUG] PHASE2: already loaded, returning true");
|
|
return true;
|
|
}
|
|
|
|
let buffer = null;
|
|
// Step 2a: Check IndexedDB cache
|
|
if (window.SonicSFStorage) {
|
|
console.log("[SonicSF][DEBUG] PHASE2a: checking IndexedDB for " + sfId);
|
|
buffer = await window.SonicSFStorage.getBuffer(sfId);
|
|
if (buffer) {
|
|
console.log("[SonicSF][DEBUG] PHASE2a: IndexedDB HIT size=" + buffer.byteLength);
|
|
} else {
|
|
console.log("[SonicSF][DEBUG] PHASE2a: IndexedDB MISS");
|
|
}
|
|
}
|
|
|
|
// Step 2b: Download from server
|
|
if (!buffer) {
|
|
try {
|
|
const url = "/api/v1/plugins/soundfonts/download/" + encodeURIComponent(sfId) + "?t=" + Date.now();
|
|
console.log("[SonicSF][DEBUG] PHASE2b: fetching from server url=" + url);
|
|
const resp = await fetch(url);
|
|
console.log("[SonicSF][DEBUG] PHASE2b: server response status=" + resp.status + " type=" + resp.headers.get("content-type") + " size=" + resp.headers.get("content-length"));
|
|
if (!resp.ok) throw new Error("HTTP " + resp.status);
|
|
buffer = await resp.arrayBuffer();
|
|
console.log("[SonicSF][DEBUG] PHASE2b: downloaded " + buffer.byteLength + " bytes for " + sfId);
|
|
|
|
// Step 2c: Save to IndexedDB
|
|
if (window.SonicSFStorage) {
|
|
console.log("[SonicSF][DEBUG] PHASE2c: saving to IndexedDB");
|
|
await window.SonicSFStorage.saveBuffer(sfId, buffer);
|
|
console.log("[SonicSF][DEBUG] PHASE2c: saved to IndexedDB OK");
|
|
}
|
|
} catch (e) {
|
|
console.error("[SonicSF][DEBUG] PHASE2b: download FAILED for " + sfId + ": " + e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Step 2d: Load ArrayBuffer into SpessaSynth Engine
|
|
console.log("[SonicSF][DEBUG] PHASE2d: calling addSoundBank for " + sfId + " size=" + buffer.byteLength);
|
|
const ok = await _addBankWithTimeout(_synthInstance, buffer, sfId, 15000);
|
|
if (ok) {
|
|
_currentSfId = sfId;
|
|
const bankCount = _synthInstance.soundBankManager?.soundBankList?.length ?? 0;
|
|
console.log("[SonicSF][DEBUG] PHASE2d: addSoundBank SUCCESS. _currentSfId=" + _currentSfId + " total banks=" + bankCount);
|
|
// Try to enumerate presets from loaded bank
|
|
try {
|
|
const presetList = _synthInstance.soundBankManager?.soundBankList?.[0]?.soundBank?.presets;
|
|
if (presetList) {
|
|
console.log("[SonicSF][DEBUG] PHASE2d: presets in loaded bank=" + presetList.length);
|
|
for (let i = 0; i < Math.min(presetList.length, 10); i++) {
|
|
const p = presetList[i];
|
|
console.log("[SonicSF][DEBUG] PHASE2d: preset[" + i + "] name=" + p.name + " bank=" + p.bankMSB + "/" + p.bankLSB + " prog=" + p.program + " drum=" + p.isGMGSDrum);
|
|
}
|
|
} else {
|
|
console.warn("[SonicSF][DEBUG] PHASE2d: soundBankList[0].soundBank.presets is UNDEFINED or EMPTY");
|
|
}
|
|
} catch (e) {
|
|
console.warn("[SonicSF][DEBUG] PHASE2d: preset enumeration failed:", e);
|
|
}
|
|
return true;
|
|
} else {
|
|
console.warn("[SonicSF][DEBUG] PHASE2d: addSoundBank FAILED for " + sfId + ". Clearing IndexedDB cache.");
|
|
if (window.SonicSFStorage) {
|
|
try {
|
|
const db = await window.SonicSFStorage.openDB();
|
|
const tx = db.transaction(window.SonicSFStorage.storeName, "readwrite");
|
|
tx.objectStore(window.SonicSFStorage.storeName).delete(sfId);
|
|
} catch (ce) {}
|
|
}
|
|
_currentSfId = null;
|
|
return false;
|
|
}
|
|
},
|
|
|
|
// ════════════════════════════════════════════════
|
|
// PHASE 3: Set up MIDI Channel (bank/program route)
|
|
// ════════════════════════════════════════════════
|
|
selectInstrument: async function (channel, bank, program, sfId) {
|
|
console.log("[SonicSF][DEBUG] PHASE3: selectInstrument ch=" + channel + " bank=" + bank + " prog=" + program + " sf=" + sfId + " _initialized=" + _initialized);
|
|
// Auto-init: create AudioContext + init SpessaSynth if not ready
|
|
if (!_initialized || !_synthInstance) {
|
|
console.log("[SonicSF][DEBUG] PHASE3: engine not ready, triggering init...");
|
|
try {
|
|
const ctx = new (window.AudioContext || window.webkitAudioContext)();
|
|
if (ctx.state === 'suspended') await ctx.resume();
|
|
await this.init(ctx);
|
|
} catch (e) {
|
|
console.error("[SonicSF][DEBUG] PHASE3: auto-init failed:", e);
|
|
return;
|
|
}
|
|
if (!_initialized || !_synthInstance) {
|
|
console.warn("[SonicSF][DEBUG] PHASE3: engine still not ready after auto-init");
|
|
return;
|
|
}
|
|
console.log("[SonicSF][DEBUG] PHASE3: auto-init complete");
|
|
}
|
|
// Phase 2 first: ensure SoundFont is loaded
|
|
if (sfId) {
|
|
const loaded = await this.loadSoundFont(sfId);
|
|
if (!loaded) {
|
|
console.warn("[SonicSF][DEBUG] PHASE3: loadSoundFont returned false, no bank to select");
|
|
return;
|
|
}
|
|
}
|
|
// Send CC0 + CC32 + Program Change
|
|
console.log("[SonicSF][DEBUG] PHASE3: sending controllerChange(ch=" + channel + ", cc=0, val=" + bank + ")");
|
|
try { _synthInstance.controllerChange(channel, 0, bank); } catch (e) { console.warn("[SonicSF][DEBUG] PHASE3: CC0 error:", e); }
|
|
console.log("[SonicSF][DEBUG] PHASE3: sending controllerChange(ch=" + channel + ", cc=32, val=0)");
|
|
try { _synthInstance.controllerChange(channel, 32, 0); } catch (e) { console.warn("[SonicSF][DEBUG] PHASE3: CC32 error:", e); }
|
|
console.log("[SonicSF][DEBUG] PHASE3: sending programChange(ch=" + channel + ", prog=" + program + ")");
|
|
try { _synthInstance.programChange(channel, program); } catch (e) { console.warn("[SonicSF][DEBUG] PHASE3: progChange error:", e); }
|
|
// Update internal SonicSF state
|
|
this.controllerChange(channel, 0, bank);
|
|
this.programChange(channel, program);
|
|
// Verify the sound bank list
|
|
const bl = _synthInstance.soundBankManager?.soundBankList?.length ?? 0;
|
|
console.log("[SonicSF][DEBUG] PHASE3: complete. total banks=" + bl + " _currentSfId=" + _currentSfId);
|
|
},
|
|
|
|
// ════════════════════════════════════════════════
|
|
// PHASE 4: Play Note
|
|
// ════════════════════════════════════════════════
|
|
controllerChange: function (channel, controller, value) {
|
|
if (channel < 0 || channel > 15) return;
|
|
if (_initialized && _synthInstance) {
|
|
try { _synthInstance.controllerChange(channel, controller, value); } catch (e) {}
|
|
}
|
|
if (controller === 0) {
|
|
_channels[channel].bank = value;
|
|
_channels[channel].isPercussion = (value === 128);
|
|
}
|
|
},
|
|
|
|
programChange: function (channel, program) {
|
|
if (channel < 0 || channel > 15) return;
|
|
if (_initialized && _synthInstance) {
|
|
try { _synthInstance.programChange(channel, program); } catch (e) {}
|
|
}
|
|
_channels[channel].program = program;
|
|
},
|
|
|
|
allocateChannel: function (bank) {
|
|
if (bank === 128) return 9;
|
|
const ch = _nextMelodicChannel % 9;
|
|
_nextMelodicChannel = (_nextMelodicChannel + 1) % 9;
|
|
return ch;
|
|
},
|
|
|
|
applyAITrackInstrument: function (bank, program, synthEngine) {
|
|
if (synthEngine) {
|
|
bank = bank !== undefined ? bank : (synthEngine.soundfont_bank || 0);
|
|
program = program !== undefined ? program : (synthEngine.soundfont_program || 0);
|
|
}
|
|
const channel = this.allocateChannel(bank);
|
|
this.selectInstrument(channel, bank, program, synthEngine?.soundfont_id);
|
|
return channel;
|
|
},
|
|
|
|
getChannelState: function (channel) {
|
|
if (channel < 0 || channel > 15) return null;
|
|
return { ..._channels[channel] };
|
|
},
|
|
|
|
playNote: function (note, velocity, durationMs, startTime, program, destinationNode, channel, synthEngine) {
|
|
if (_initialized && _synthInstance && _currentSfId) {
|
|
if (synthEngine) {
|
|
const ch = channel !== undefined ? channel : (synthEngine.soundfont_bank === 128 ? 9 : 0);
|
|
try { _synthInstance.controllerChange(ch, 0, synthEngine.soundfont_bank || 0); } catch (e) {}
|
|
try { _synthInstance.controllerChange(ch, 32, 0); } catch (e) {}
|
|
try { _synthInstance.programChange(ch, synthEngine.soundfont_program || 0); } catch (e) {}
|
|
if (channel === undefined) channel = ch;
|
|
}
|
|
if (channel === undefined) channel = 0;
|
|
console.log("[SonicSF][DEBUG] PHASE4: playNote via SpessaSynth ch=" + channel + " note=" + note + " vel=" + velocity + " _currentSfId=" + _currentSfId);
|
|
try {
|
|
this._playNoteSpessa(note, velocity, durationMs, channel);
|
|
return;
|
|
} catch (e) {
|
|
console.warn("[SonicSF][DEBUG] PHASE4: SpessaSynth play failed, oscillator fallback:", e);
|
|
}
|
|
} else {
|
|
console.log("[SonicSF][DEBUG] PHASE4: playNote via oscillator (init=" + _initialized + " sf=" + _currentSfId + ")");
|
|
}
|
|
this._playNoteOsc(note, velocity, durationMs, startTime, program, destinationNode, channel, synthEngine);
|
|
},
|
|
|
|
_playNoteSpessa: function (note, velocity, durationMs, channel) {
|
|
const ctx = getCtx();
|
|
const midiPitch = Math.min(127, Math.max(0, parseInt(note) || 60));
|
|
const midiVel = Math.min(127, Math.max(1, Math.floor(
|
|
typeof velocity === 'number' ? (velocity > 1 ? velocity : velocity * 127) : 100
|
|
)));
|
|
const durSec = durationMs / 1000;
|
|
console.log("[SonicSF][DEBUG] PHASE4: noteOn ch=" + channel + " pitch=" + midiPitch + " vel=" + midiVel + " banks=" + (_synthInstance.soundBankManager?.soundBankList?.length ?? 0));
|
|
const doNoteOn = () => {
|
|
try {
|
|
_synthInstance.noteOn(channel, midiPitch, midiVel);
|
|
setTimeout(() => { try { _synthInstance.noteOff(channel, midiPitch); } catch (e) {} }, durSec * 1000);
|
|
} catch (e) {
|
|
console.warn("[SonicSF][DEBUG] PHASE4: noteOn threw:", e);
|
|
}
|
|
};
|
|
doNoteOn();
|
|
},
|
|
|
|
_playNoteOsc: function (note, velocity, durationMs, startTime, program, destinationNode, channel, synthEngine) {
|
|
const ctx = getCtx();
|
|
const freq = 440 * Math.pow(2, (note - 69) / 12);
|
|
if (freq <= 0 || isNaN(freq)) return null;
|
|
|
|
if (synthEngine) {
|
|
const ch = channel !== undefined ? channel : (synthEngine.soundfont_bank === 128 ? 9 : 0);
|
|
this.controllerChange(ch, 0, synthEngine.soundfont_bank || 0);
|
|
this.programChange(ch, synthEngine.soundfont_program || 0);
|
|
if (channel === undefined) channel = ch;
|
|
if (program === undefined) program = synthEngine.soundfont_program;
|
|
}
|
|
|
|
const osc = ctx.createOscillator();
|
|
const noteGain = ctx.createGain();
|
|
let oscType = 'triangle';
|
|
let attackTime = 0.03, decayTime = 0.1, sustainLevel = 0.5, releaseTime = 0.2, volFactor = 0.25;
|
|
|
|
let prog = program !== undefined ? parseInt(program) : 0;
|
|
if (channel !== undefined && channel >= 0 && channel < 16) {
|
|
const chState = _channels[channel];
|
|
prog = chState.program || prog;
|
|
}
|
|
if (prog >= 0 && prog <= 7) {
|
|
oscType = 'sine';
|
|
decayTime = 0.3; sustainLevel = 0.1; releaseTime = 0.2;
|
|
} else if (prog >= 8 && prog <= 15) {
|
|
oscType = 'sine';
|
|
decayTime = 0.1; sustainLevel = 0.0; releaseTime = 0.1;
|
|
} else if (prog >= 16 && prog <= 23) {
|
|
oscType = 'sine';
|
|
attackTime = 0.05; sustainLevel = 0.8; releaseTime = 0.1;
|
|
} else if (prog >= 24 && prog <= 31) {
|
|
oscType = 'triangle';
|
|
decayTime = 0.4; sustainLevel = 0.2; releaseTime = 0.3;
|
|
} else if (prog >= 32 && prog <= 39) {
|
|
oscType = 'triangle';
|
|
attackTime = 0.02; decayTime = 0.2; sustainLevel = 0.6; releaseTime = 0.2;
|
|
} else if (prog >= 40 && prog <= 47) {
|
|
oscType = 'sawtooth';
|
|
attackTime = 0.15; sustainLevel = 0.8; releaseTime = 0.5; volFactor = 0.15;
|
|
} else if (prog >= 48 && prog <= 55) {
|
|
oscType = 'sawtooth';
|
|
attackTime = 0.2; sustainLevel = 0.8; releaseTime = 0.6; volFactor = 0.12;
|
|
} else if (prog >= 56 && prog <= 63) {
|
|
oscType = 'sawtooth';
|
|
attackTime = 0.08; sustainLevel = 0.7; releaseTime = 0.3; volFactor = 0.15;
|
|
} else if (prog >= 64 && prog <= 71) {
|
|
oscType = 'square';
|
|
attackTime = 0.05; sustainLevel = 0.6; releaseTime = 0.2; volFactor = 0.15;
|
|
} else if (prog >= 72 && prog <= 79) {
|
|
oscType = 'sine';
|
|
attackTime = 0.1; sustainLevel = 0.7; releaseTime = 0.3; volFactor = 0.2;
|
|
} else if (prog >= 80 && prog <= 119) {
|
|
oscType = 'sawtooth';
|
|
attackTime = 0.05; sustainLevel = 0.6; releaseTime = 0.4; volFactor = 0.15;
|
|
}
|
|
|
|
osc.type = oscType;
|
|
osc.frequency.setValueAtTime(freq, 0);
|
|
const startAt = startTime !== undefined ? startTime : ctx.currentTime;
|
|
const durSec = durationMs / 1000;
|
|
const vel = typeof velocity === 'number' ? (velocity > 1 ? velocity / 127 : velocity) : 0.8;
|
|
const targetGain = vel * volFactor;
|
|
|
|
noteGain.gain.setValueAtTime(0, startAt);
|
|
noteGain.gain.linearRampToValueAtTime(targetGain, startAt + attackTime);
|
|
noteGain.gain.linearRampToValueAtTime(targetGain * sustainLevel, startAt + attackTime + decayTime);
|
|
const releaseStart = startAt + Math.max(attackTime + decayTime, durSec);
|
|
noteGain.gain.linearRampToValueAtTime(targetGain * sustainLevel, releaseStart);
|
|
noteGain.gain.linearRampToValueAtTime(0, releaseStart + releaseTime);
|
|
|
|
osc.connect(noteGain);
|
|
noteGain.connect(destinationNode || __gainNode || ctx.destination);
|
|
osc.start(startAt);
|
|
const stopAt = releaseStart + releaseTime + 0.02;
|
|
osc.stop(stopAt);
|
|
|
|
const oscId = `${note}_${Date.now()}_${Math.random()}`;
|
|
activeOscillators[oscId] = { osc, gain: noteGain };
|
|
setTimeout(() => { delete activeOscillators[oscId]; }, (stopAt - ctx.currentTime) * 1000 + 100);
|
|
return osc;
|
|
},
|
|
|
|
stopAll: function () {
|
|
if (_initialized && _synthInstance) {
|
|
try { for (let ch = 0; ch < 16; ch++) _synthInstance.allNotesOff(ch); } catch (e) {}
|
|
}
|
|
const ctx = getCtx();
|
|
const now = ctx.currentTime;
|
|
Object.values(activeOscillators).forEach(entry => {
|
|
try {
|
|
if (entry.gain) { entry.gain.gain.cancelScheduledValues(now); entry.gain.gain.setValueAtTime(0, now); }
|
|
if (entry.osc) try { entry.osc.stop(now); } catch (e) { }
|
|
} catch (e) { }
|
|
});
|
|
Object.keys(activeOscillators).forEach(k => delete activeOscillators[k]);
|
|
},
|
|
|
|
saveToIndexedDB: async function (name, arrayBuffer) {
|
|
if (window.SonicStorage && window.SonicStorage.saveToIndexedDB) {
|
|
await window.SonicStorage.saveToIndexedDB('soundfont_' + name, arrayBuffer);
|
|
}
|
|
},
|
|
|
|
loadFromIndexedDB: async function (name) {
|
|
if (window.SonicStorage && window.SonicStorage.loadFromIndexedDB) {
|
|
return await window.SonicStorage.loadFromIndexedDB('soundfont_' + name);
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
|
|
window.SonicSF = SonicSF;
|
|
})();
|