1825 lines
67 KiB
JavaScript
1825 lines
67 KiB
JavaScript
window.addEventListener('error', (event) => {
|
||
if (event.error && event.error.message && event.error.message.includes('openOrClosedShadowRoot')) {
|
||
console.warn('捕获到Blockly DOM操作错误，这通常是无害的:', event.error.message);
|
||
event.preventDefault();
|
||
return false;
|
||
}
|
||
|
||
if (event.error && event.error.message && (
|
||
event.error.message.includes('DOM') ||
|
||
event.error.message.includes('Element') ||
|
||
event.error.message.includes('Node')
|
||
)) {
|
||
console.warn('捕获到DOM操作错误:', event.error.message);
|
||
event.preventDefault();
|
||
return false;
|
||
}
|
||
});
|
||
|
||
window.addEventListener('unhandledrejection', (event) => {
|
||
if (event.reason && event.reason.message && event.reason.message.includes('openOrClosedShadowRoot')) {
|
||
console.warn('捕获到未处理的Promise拒绝（Blockly DOM错误）:', event.reason.message);
|
||
event.preventDefault();
|
||
return false;
|
||
}
|
||
});
|
||
|
||
const originalConsoleError = console.error;
|
||
console.error = function(...args) {
|
||
const message = args.join(' ');
|
||
if (message.includes('openOrClosedShadowRoot') ||
|
||
message.includes('DOM') ||
|
||
message.includes('Element') ||
|
||
message.includes('Node')) {
|
||
console.warn('过滤的DOM错误:', ...args);
|
||
return;
|
||
}
|
||
originalConsoleError.apply(console, args);
|
||
};
|
||
|
||
const safeDOM = {
|
||
appendChild: (parent, child) => {
|
||
try {
|
||
if (parent && child && parent.appendChild) {
|
||
return parent.appendChild(child);
|
||
}
|
||
} catch (error) {
|
||
console.warn('安全DOM添加失败:', error.message);
|
||
}
|
||
return null;
|
||
},
|
||
|
||
removeChild: (parent, child) => {
|
||
try {
|
||
if (parent && child && parent.removeChild && child.parentNode === parent) {
|
||
return parent.removeChild(child);
|
||
}
|
||
} catch (error) {
|
||
console.warn('安全DOM移除失败:', error.message);
|
||
}
|
||
return null;
|
||
},
|
||
|
||
querySelector: (container, selector) => {
|
||
try {
|
||
if (container && container.querySelector) {
|
||
return container.querySelector(selector);
|
||
}
|
||
} catch (error) {
|
||
console.warn('安全DOM查询失败:', error.message);
|
||
}
|
||
return null;
|
||
},
|
||
|
||
exists: (element) => {
|
||
return element && element.parentNode && document.contains(element);
|
||
}
|
||
};
|
||
|
||
const sound = {
|
||
|
||
volume: 100,
|
||
|
||
effects: {
|
||
pitch: 0,
|
||
pan: 0
|
||
},
|
||
|
||
builtin: {
|
||
"Meow": "meow"
|
||
},
|
||
|
||
isRecording: false,
|
||
mediaRecorder: null,
|
||
recordedChunks: [],
|
||
recordedAudio: null,
|
||
|
||
activeAudios: [],
|
||
|
||
isStopped: false,
|
||
abortController: null,
|
||
|
||
blockAllAudio: false,
|
||
|
||
audioHistory: [],
|
||
|
||
soundQueue: [],
|
||
isProcessingQueue: false,
|
||
currentlyPlaying: null,
|
||
|
||
initAudioContext: () => {
|
||
if (!sound.audioContext) {
|
||
try {
|
||
sound.audioContext = new (window.AudioContext || window.webkitAudioContext)();
|
||
} catch (error) {
|
||
console.error("Error initializing audio context:", error);
|
||
}
|
||
}
|
||
},
|
||
|
||
createAudio: (src) => {
|
||
if (sound.blockAllAudio || sound.isStopped ||
|
||
(sound.abortController && sound.abortController.signal.aborted)) {
|
||
const fakeAudio = {
|
||
play: () => Promise.reject(new Error('Audio playback blocked')),
|
||
pause: () => {},
|
||
currentTime: 0,
|
||
src: '',
|
||
volume: 1,
|
||
playbackRate: 1,
|
||
onended: null,
|
||
onerror: null,
|
||
onloadstart: null,
|
||
oncanplay: null,
|
||
onplay: null,
|
||
onpause: null,
|
||
tagName: 'AUDIO',
|
||
addEventListener: () => {},
|
||
removeEventListener: () => {},
|
||
load: () => {},
|
||
duration: 0,
|
||
ended: false,
|
||
paused: true,
|
||
muted: false,
|
||
readyState: 0,
|
||
networkState: 0,
|
||
preload: 'none'
|
||
};
|
||
return fakeAudio;
|
||
}
|
||
return new Audio(src);
|
||
},
|
||
|
||
play: async (name) => {
|
||
try {
|
||
if (sound.isStopped) {
|
||
return;
|
||
}
|
||
|
||
if (sound.abortController && sound.abortController.signal.aborted) {
|
||
return;
|
||
}
|
||
|
||
if (sound.blockAllAudio) {
|
||
return;
|
||
}
|
||
|
||
if (sound.soundQueue.length > 0 || sound.isProcessingQueue) {
|
||
sound.soundQueue.push({
|
||
name,
|
||
resolve: () => {},
|
||
reject: () => {}
|
||
});
|
||
sound.processQueue();
|
||
return;
|
||
}
|
||
|
||
if (sound.activeAudios.length > 0) {
|
||
|
||
sound.activeAudios.forEach(audio => {
|
||
try {
|
||
if (audio && audio.tagName === 'AUDIO') {
|
||
audio.pause();
|
||
audio.currentTime = 0;
|
||
audio.src = '';
|
||
}
|
||
} catch (error) {
|
||
console.warn("停止现有音频时出错:", error);
|
||
}
|
||
});
|
||
sound.activeAudios = [];
|
||
}
|
||
|
||
if (name.startsWith('recording') && sound.builtin[name]) {
|
||
if (sound.blockAllAudio || sound.isStopped) {
|
||
return;
|
||
}
|
||
|
||
const audio = sound.createAudio(sound.builtin[name]);
|
||
audio.volume = sound.volume / 100;
|
||
|
||
const currentPitch = sound.effects.pitch;
|
||
const currentPan = sound.effects.pan;
|
||
|
||
if (currentPitch !== 0 || currentPan !== 0) {
|
||
sound.initAudioContext();
|
||
if (sound.audioContext) {
|
||
try {
|
||
const source = sound.audioContext.createMediaElementSource(audio);
|
||
const gainNode = sound.audioContext.createGain();
|
||
|
||
if (currentPitch !== 0) {
|
||
const pitchShift = sound.audioContext.createBiquadFilter();
|
||
pitchShift.type = 'peaking';
|
||
pitchShift.frequency.setValueAtTime(1000, sound.audioContext.currentTime);
|
||
pitchShift.Q.setValueAtTime(1, sound.audioContext.currentTime);
|
||
|
||
const pitchGain = Math.max(-20, Math.min(20, currentPitch * 0.8));
|
||
pitchShift.gain.setValueAtTime(pitchGain, sound.audioContext.currentTime);
|
||
|
||
source.connect(pitchShift);
|
||
pitchShift.connect(gainNode);
|
||
} else {
|
||
source.connect(gainNode);
|
||
}
|
||
|
||
if (currentPan !== 0) {
|
||
const panNode = sound.audioContext.createStereoPanner();
|
||
const panValue = Math.max(-1, Math.min(1, (currentPan / 100) * 1.5));
|
||
panNode.pan.setValueAtTime(panValue, sound.audioContext.currentTime);
|
||
|
||
gainNode.connect(panNode);
|
||
panNode.connect(sound.audioContext.destination);
|
||
} else {
|
||
gainNode.connect(sound.audioContext.destination);
|
||
}
|
||
|
||
gainNode.gain.setValueAtTime(sound.volume / 100, sound.audioContext.currentTime);
|
||
} catch (error) {
|
||
console.warn("应用增强音效失败，使用默认播放:", error);
|
||
audio.play().catch(error => {
|
||
if (error.name !== 'AbortError') {
|
||
console.error("Error playing recorded audio:", error);
|
||
}
|
||
});
|
||
return;
|
||
}
|
||
} else {
|
||
console.warn("音频上下文初始化失败，无法应用增强音效");
|
||
audio.play().catch(error => {
|
||
if (error.name !== 'AbortError') {
|
||
console.error("Error playing recorded audio:", error);
|
||
}
|
||
});
|
||
return;
|
||
}
|
||
} else {
|
||
audio.play().catch(error => {
|
||
if (error.name !== 'AbortError') {
|
||
console.error("Error playing recorded audio:", error);
|
||
}
|
||
});
|
||
return;
|
||
}
|
||
|
||
sound.activeAudios.push(audio);
|
||
|
||
audio.onended = () => {
|
||
const index = sound.activeAudios.indexOf(audio);
|
||
if (index > -1) {
|
||
sound.activeAudios.splice(index, 1);
|
||
}
|
||
};
|
||
|
||
audio.play().catch(error => {
|
||
if (error.name !== 'AbortError') {
|
||
console.error("Error playing recorded audio:", error);
|
||
}
|
||
const index = sound.activeAudios.indexOf(audio);
|
||
if (index > -1) {
|
||
sound.activeAudios.splice(index, 1);
|
||
}
|
||
});
|
||
return;
|
||
}
|
||
|
||
if (name === "Meow") {
|
||
sound.initAudioContext();
|
||
|
||
if (sound.audioContext) {
|
||
const oscillator = sound.audioContext.createOscillator();
|
||
const gainNode = sound.audioContext.createGain();
|
||
|
||
let frequency = 440;
|
||
|
||
if (sound.effects.pitch !== 0) {
|
||
frequency *= Math.pow(2, sound.effects.pitch / 12);
|
||
}
|
||
|
||
oscillator.frequency.setValueAtTime(frequency, sound.audioContext.currentTime);
|
||
oscillator.type = 'sine';
|
||
|
||
gainNode.gain.setValueAtTime(sound.volume / 100, sound.audioContext.currentTime);
|
||
|
||
if (sound.effects.pan !== 0) {
|
||
const panNode = sound.audioContext.createStereoPanner();
|
||
const panValue = sound.effects.pan / 100;
|
||
panNode.pan.setValueAtTime(panValue, sound.audioContext.currentTime);
|
||
|
||
oscillator.connect(panNode);
|
||
panNode.connect(gainNode);
|
||
} else {
|
||
oscillator.connect(gainNode);
|
||
}
|
||
|
||
gainNode.connect(sound.audioContext.destination);
|
||
|
||
oscillator.start();
|
||
oscillator.stop(sound.audioContext.currentTime + 0.5);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.error("Error in sound.play:", error);
|
||
}
|
||
},
|
||
|
||
_playAudioInternal: async (name) => {
|
||
return new Promise((resolve, reject) => {
|
||
try {
|
||
if (sound.isStopped || sound.blockAllAudio) {
|
||
reject(new Error('Playback blocked'));
|
||
return;
|
||
}
|
||
|
||
if (name.startsWith('recording') && sound.builtin[name]) {
|
||
const audio = sound.createAudio(sound.builtin[name]);
|
||
audio.volume = sound.volume / 100;
|
||
|
||
const currentPitch = sound.effects.pitch;
|
||
const currentPan = sound.effects.pan;
|
||
|
||
if (currentPitch !== 0 || currentPan !== 0) {
|
||
sound.initAudioContext();
|
||
if (sound.audioContext) {
|
||
try {
|
||
const source = sound.audioContext.createMediaElementSource(audio);
|
||
const gainNode = sound.audioContext.createGain();
|
||
|
||
if (currentPitch !== 0) {
|
||
const pitchShift = sound.audioContext.createBiquadFilter();
|
||
pitchShift.type = 'peaking';
|
||
pitchShift.frequency.setValueAtTime(1000, sound.audioContext.currentTime);
|
||
pitchShift.Q.setValueAtTime(1, sound.audioContext.currentTime);
|
||
const pitchGain = Math.max(-20, Math.min(20, currentPitch * 0.8));
|
||
pitchShift.gain.setValueAtTime(pitchGain, sound.audioContext.currentTime);
|
||
source.connect(pitchShift);
|
||
pitchShift.connect(gainNode);
|
||
} else {
|
||
source.connect(gainNode);
|
||
}
|
||
|
||
if (currentPan !== 0) {
|
||
const panNode = sound.audioContext.createStereoPanner();
|
||
const panValue = Math.max(-1, Math.min(1, (currentPan / 100) * 1.5));
|
||
panNode.pan.setValueAtTime(panValue, sound.audioContext.currentTime);
|
||
gainNode.connect(panNode);
|
||
panNode.connect(sound.audioContext.destination);
|
||
} else {
|
||
gainNode.connect(sound.audioContext.destination);
|
||
}
|
||
|
||
gainNode.gain.setValueAtTime(sound.volume / 100, sound.audioContext.currentTime);
|
||
} catch (error) {
|
||
console.warn("应用音效失败:", error);
|
||
}
|
||
}
|
||
}
|
||
|
||
audio.onended = () => {
|
||
const index = sound.activeAudios.indexOf(audio);
|
||
if (index > -1) {
|
||
sound.activeAudios.splice(index, 1);
|
||
}
|
||
resolve();
|
||
};
|
||
|
||
audio.onerror = (error) => {
|
||
console.error(`音频播放失败: ${name}`, error);
|
||
const index = sound.activeAudios.indexOf(audio);
|
||
if (index > -1) {
|
||
sound.activeAudios.splice(index, 1);
|
||
}
|
||
reject(error);
|
||
};
|
||
|
||
sound.activeAudios.push(audio);
|
||
audio.play().catch(error => {
|
||
if (error.name === 'AbortError') {
|
||
resolve();
|
||
} else {
|
||
console.error("播放音频失败:", error);
|
||
reject(error);
|
||
}
|
||
});
|
||
|
||
} else if (name === "Meow") {
|
||
sound.initAudioContext();
|
||
if (sound.audioContext) {
|
||
const oscillator = sound.audioContext.createOscillator();
|
||
const gainNode = sound.audioContext.createGain();
|
||
|
||
let frequency = 440;
|
||
if (sound.effects.pitch !== 0) {
|
||
frequency *= Math.pow(2, sound.effects.pitch / 12);
|
||
}
|
||
|
||
oscillator.frequency.setValueAtTime(frequency, sound.audioContext.currentTime);
|
||
oscillator.type = 'sine';
|
||
gainNode.gain.setValueAtTime(sound.volume / 100, sound.audioContext.currentTime);
|
||
|
||
if (sound.effects.pan !== 0) {
|
||
const panNode = sound.audioContext.createStereoPanner();
|
||
const panValue = sound.effects.pan / 100;
|
||
panNode.pan.setValueAtTime(panValue, sound.audioContext.currentTime);
|
||
oscillator.connect(panNode);
|
||
panNode.connect(gainNode);
|
||
} else {
|
||
oscillator.connect(gainNode);
|
||
}
|
||
|
||
gainNode.connect(sound.audioContext.destination);
|
||
|
||
oscillator.start();
|
||
oscillator.stop(sound.audioContext.currentTime + 0.5);
|
||
|
||
setTimeout(() => {
|
||
resolve();
|
||
}, 500);
|
||
} else {
|
||
reject(new Error('AudioContext not available'));
|
||
}
|
||
} else {
|
||
reject(new Error(`Unknown sound: ${name}`));
|
||
}
|
||
} catch (error) {
|
||
console.error("内部播放错误:", error);
|
||
reject(error);
|
||
}
|
||
});
|
||
},
|
||
|
||
processQueue: async () => {
|
||
if (sound.isProcessingQueue || sound.soundQueue.length === 0) {
|
||
return;
|
||
}
|
||
|
||
sound.isProcessingQueue = true;
|
||
|
||
while (sound.soundQueue.length > 0) {
|
||
const queueItem = sound.soundQueue.shift();
|
||
|
||
try {
|
||
if (queueItem.type === 'frequency') {
|
||
const { frequency, duration, resolve } = queueItem;
|
||
|
||
sound.currentlyPlaying = { type: 'frequency', frequency, startTime: Date.now() };
|
||
|
||
await new Promise((freqResolve) => {
|
||
sound.initAudioContext();
|
||
|
||
if (sound.audioContext) {
|
||
const oscillator = sound.audioContext.createOscillator();
|
||
const gainNode = sound.audioContext.createGain();
|
||
|
||
oscillator.frequency.setValueAtTime(frequency, sound.audioContext.currentTime);
|
||
oscillator.type = 'sine';
|
||
|
||
const currentPitch = sound.effects.pitch;
|
||
if (currentPitch !== 0) {
|
||
oscillator.frequency.setValueAtTime(
|
||
frequency * Math.pow(2, currentPitch / 12),
|
||
sound.audioContext.currentTime
|
||
);
|
||
}
|
||
|
||
gainNode.gain.setValueAtTime(sound.volume / 100, sound.audioContext.currentTime);
|
||
oscillator.connect(gainNode);
|
||
gainNode.connect(sound.audioContext.destination);
|
||
|
||
oscillator.onended = () => {
|
||
sound.currentlyPlaying = null;
|
||
freqResolve();
|
||
};
|
||
|
||
oscillator.start();
|
||
oscillator.stop(sound.audioContext.currentTime + duration / 1000);
|
||
} else {
|
||
freqResolve();
|
||
}
|
||
});
|
||
|
||
sound.currentlyPlaying = null;
|
||
resolve();
|
||
} else {
|
||
const { name, resolve } = queueItem;
|
||
|
||
sound.currentlyPlaying = { name, startTime: Date.now() };
|
||
await sound._playAudioInternal(name);
|
||
sound.currentlyPlaying = null;
|
||
resolve();
|
||
}
|
||
} catch (error) {
|
||
console.error(`队列播放失败:`, error);
|
||
sound.currentlyPlaying = null;
|
||
if (queueItem.reject) {
|
||
queueItem.reject(error);
|
||
}
|
||
}
|
||
}
|
||
|
||
sound.isProcessingQueue = false;
|
||
},
|
||
|
||
play_blocking: (name) => {
|
||
return new Promise((resolve, reject) => {
|
||
sound.soundQueue.push({ name, resolve, reject });
|
||
sound.processQueue();
|
||
});
|
||
},
|
||
|
||
stop_all: () => {
|
||
try {
|
||
sound.isStopped = true;
|
||
sound.blockAllAudio = true;
|
||
|
||
if (sound.soundQueue.length > 0) {
|
||
sound.soundQueue.forEach(({ reject }) => {
|
||
reject(new Error('Playback stopped'));
|
||
});
|
||
sound.soundQueue = [];
|
||
}
|
||
sound.isProcessingQueue = false;
|
||
sound.currentlyPlaying = null;
|
||
|
||
if (sound.abortController) {
|
||
sound.abortController.abort();
|
||
}
|
||
sound.abortController = new AbortController();
|
||
|
||
if (sound.activeAudios.length > 0) {
|
||
sound.activeAudios.forEach((audio) => {
|
||
try {
|
||
if (audio && audio.tagName === 'AUDIO') {
|
||
audio.pause();
|
||
audio.currentTime = 0;
|
||
audio.src = '';
|
||
audio.load();
|
||
audio.onended = null;
|
||
audio.onerror = null;
|
||
audio.onloadstart = null;
|
||
audio.oncanplay = null;
|
||
audio.onplay = null;
|
||
audio.onpause = null;
|
||
}
|
||
} catch (error) {
|
||
console.warn(`停止音频时出错:`, error);
|
||
}
|
||
});
|
||
|
||
sound.activeAudios = [];
|
||
}
|
||
|
||
if (sound.audioContext) {
|
||
try {
|
||
sound.audioContext.close();
|
||
sound.audioContext = null;
|
||
} catch (error) {
|
||
console.warn("关闭音频上下文时出错:", error);
|
||
}
|
||
}
|
||
|
||
sound.effects.pitch = 0;
|
||
sound.effects.pan = 0;
|
||
|
||
const allAudioElements = document.querySelectorAll('audio');
|
||
if (allAudioElements.length > 0) {
|
||
allAudioElements.forEach((audio) => {
|
||
try {
|
||
audio.pause();
|
||
audio.currentTime = 0;
|
||
audio.src = '';
|
||
} catch (error) {
|
||
console.warn(`停止页面音频元素时出错:`, error);
|
||
}
|
||
});
|
||
}
|
||
|
||
setTimeout(() => {
|
||
sound.isStopped = false;
|
||
sound.blockAllAudio = false;
|
||
}, 100);
|
||
} catch (error) {
|
||
console.error("Error in sound.stop_all:", error);
|
||
}
|
||
},
|
||
|
||
adjust_volume: (change) => {
|
||
const newVolume = Math.max(0, Math.min(100, sound.volume + change));
|
||
sound.volume = newVolume;
|
||
},
|
||
|
||
set_volume: (value) => {
|
||
sound.volume = Math.max(0, Math.min(100, value));
|
||
},
|
||
|
||
get_volume: () => {
|
||
return sound.volume;
|
||
},
|
||
|
||
noteFrequencies: {
|
||
"NOTE_B3": 247,
|
||
"NOTE_C4": 262,
|
||
"NOTE_D4": 294,
|
||
"NOTE_E4": 330,
|
||
"NOTE_F4": 349,
|
||
"NOTE_G4": 392,
|
||
"NOTE_A4": 440,
|
||
"NOTE_B4": 494,
|
||
"NOTE_C5": 523,
|
||
"NOTE_D5": 587,
|
||
"NOTE_E5": 659,
|
||
"NOTE_F5": 698,
|
||
"NOTE_G5": 784
|
||
},
|
||
|
||
// 播放指定频率的声音（带持续时间）
|
||
play_frequency: (frequency, duration = 1000) => {
|
||
try {
|
||
sound.initAudioContext();
|
||
|
||
if (sound.audioContext) {
|
||
const oscillator = sound.audioContext.createOscillator();
|
||
const gainNode = sound.audioContext.createGain();
|
||
|
||
oscillator.frequency.setValueAtTime(frequency, sound.audioContext.currentTime);
|
||
oscillator.type = 'sine';
|
||
|
||
const currentPitch = sound.effects.pitch;
|
||
if (currentPitch !== 0) {
|
||
oscillator.frequency.setValueAtTime(
|
||
frequency * Math.pow(2, currentPitch / 12),
|
||
sound.audioContext.currentTime
|
||
);
|
||
}
|
||
|
||
gainNode.gain.setValueAtTime(sound.volume / 100, sound.audioContext.currentTime);
|
||
|
||
oscillator.connect(gainNode);
|
||
gainNode.connect(sound.audioContext.destination);
|
||
|
||
oscillator.start();
|
||
oscillator.stop(sound.audioContext.currentTime + duration / 1000);
|
||
console.log(`播放频率: ${frequency}Hz, 持续时间: ${duration}ms, 音量: ${sound.volume}%`);
|
||
}
|
||
} catch (error) {
|
||
console.error("播放频率声音失败:", error);
|
||
}
|
||
},
|
||
|
||
// 播放指定频率的声音（持续播放，无持续时间限制）
|
||
play_frequency_continuous: (frequency) => {
|
||
try {
|
||
sound.initAudioContext();
|
||
|
||
if (sound.audioContext) {
|
||
const oscillator = sound.audioContext.createOscillator();
|
||
const gainNode = sound.audioContext.createGain();
|
||
|
||
oscillator.frequency.setValueAtTime(frequency, sound.audioContext.currentTime);
|
||
oscillator.type = 'sine';
|
||
|
||
const currentPitch = sound.effects.pitch;
|
||
if (currentPitch !== 0) {
|
||
oscillator.frequency.setValueAtTime(
|
||
frequency * Math.pow(2, currentPitch / 12),
|
||
sound.audioContext.currentTime
|
||
);
|
||
}
|
||
|
||
gainNode.gain.setValueAtTime(sound.volume / 100, sound.audioContext.currentTime);
|
||
|
||
oscillator.connect(gainNode);
|
||
gainNode.connect(sound.audioContext.destination);
|
||
|
||
oscillator.start();
|
||
oscillator.stop(sound.audioContext.currentTime + 2); // 默认播放2秒
|
||
console.log(`播放频率（持续）: ${frequency}Hz, 无持续时间限制, 音量: ${sound.volume}%`);
|
||
}
|
||
} catch (error) {
|
||
console.error("播放频率声音失败:", error);
|
||
}
|
||
},
|
||
|
||
// 播放指定频率的声音（阻塞版本，使用队列，带持续时间）
|
||
play_frequency_blocking: (frequency, duration = 1000) => {
|
||
console.log(`=== 🔒 阻塞播放频率（加入队列）: ${frequency}Hz, ${duration}ms ===`);
|
||
|
||
return new Promise((resolve, reject) => {
|
||
const queueItem = {
|
||
type: 'frequency',
|
||
frequency,
|
||
duration: duration,
|
||
resolve,
|
||
reject
|
||
};
|
||
|
||
sound.soundQueue.push(queueItem);
|
||
console.log(`✅ 频率已加入声音队列，当前队列长度: ${sound.soundQueue.length}`);
|
||
sound.processQueue();
|
||
});
|
||
},
|
||
|
||
// 播放指定频率的声音（阻塞版本，使用队列，持续播放）
|
||
play_frequency_continuous_blocking: (frequency) => {
|
||
console.log(`=== 🔒 阻塞播放频率（持续，加入队列）: ${frequency}Hz ===`);
|
||
|
||
return new Promise((resolve, reject) => {
|
||
const duration = 2000; // 持续播放默认2秒
|
||
|
||
const queueItem = {
|
||
type: 'frequency',
|
||
frequency,
|
||
duration: duration,
|
||
resolve,
|
||
reject
|
||
};
|
||
|
||
sound.soundQueue.push(queueItem);
|
||
console.log(`✅ 频率（持续）已加入声音队列，当前队列长度: ${sound.soundQueue.length}`);
|
||
sound.processQueue();
|
||
});
|
||
},
|
||
|
||
play_note_list: (noteList) => {
|
||
try {
|
||
const noteSequences = {
|
||
"DADADADUM": [
|
||
{ note: "NOTE_D4", duration: 500 },
|
||
{ note: "NOTE_A4", duration: 500 },
|
||
{ note: "NOTE_D4", duration: 500 },
|
||
{ note: "NOTE_A4", duration: 500 },
|
||
{ note: "NOTE_D4", duration: 500 },
|
||
{ note: "NOTE_A4", duration: 500 },
|
||
{ note: "NOTE_D4", duration: 500 },
|
||
{ note: "NOTE_A4", duration: 500 }
|
||
],
|
||
"BIRTHDAY": [
|
||
{ note: "NOTE_C4", duration: 400 },
|
||
{ note: "NOTE_C4", duration: 400 },
|
||
{ note: "NOTE_D4", duration: 800 },
|
||
{ note: "NOTE_C4", duration: 800 },
|
||
{ note: "NOTE_F4", duration: 800 },
|
||
{ note: "NOTE_E4", duration: 1600 }
|
||
],
|
||
"BA_DING": [
|
||
{ note: "NOTE_C5", duration: 200 },
|
||
{ note: "NOTE_E5", duration: 200 },
|
||
{ note: "NOTE_G5", duration: 400 }
|
||
],
|
||
"JUMP_UP": [
|
||
{ note: "NOTE_C5", duration: 100 },
|
||
{ note: "NOTE_E5", duration: 100 },
|
||
{ note: "NOTE_G5", duration: 100 }
|
||
],
|
||
"JUMP_DOWN": [
|
||
{ note: "NOTE_G5", duration: 100 },
|
||
{ note: "NOTE_E5", duration: 100 },
|
||
{ note: "NOTE_C5", duration: 100 }
|
||
],
|
||
"POWER_UP": [
|
||
{ note: "NOTE_C4", duration: 150 },
|
||
{ note: "NOTE_E4", duration: 150 },
|
||
{ note: "NOTE_G4", duration: 150 },
|
||
{ note: "NOTE_C5", duration: 300 }
|
||
],
|
||
"POWER_DOWN": [
|
||
{ note: "NOTE_C5", duration: 150 },
|
||
{ note: "NOTE_G4", duration: 150 },
|
||
{ note: "NOTE_E4", duration: 150 },
|
||
{ note: "NOTE_C4", duration: 300 }
|
||
]
|
||
};
|
||
|
||
const sequence = noteSequences[noteList];
|
||
if (sequence) {
|
||
let currentTime = 0;
|
||
|
||
sequence.forEach((item) => {
|
||
const frequency = sound.noteFrequencies[item.note] || 440;
|
||
const duration = item.duration;
|
||
|
||
setTimeout(() => {
|
||
sound.play_frequency(frequency, duration);
|
||
}, currentTime);
|
||
|
||
currentTime += duration;
|
||
});
|
||
} else {
|
||
console.warn(`未知的音符列表: ${noteList}`);
|
||
}
|
||
} catch (error) {
|
||
console.error("播放音符列表失败:", error);
|
||
}
|
||
},
|
||
|
||
play_note_list_blocking: (noteList) => {
|
||
return new Promise((resolve, reject) => {
|
||
(async () => {
|
||
try {
|
||
const noteSequences = {
|
||
"DADADADUM": [
|
||
{ note: "NOTE_D4", duration: 500 },
|
||
{ note: "NOTE_A4", duration: 500 },
|
||
{ note: "NOTE_D4", duration: 500 },
|
||
{ note: "NOTE_A4", duration: 500 },
|
||
{ note: "NOTE_D4", duration: 500 },
|
||
{ note: "NOTE_A4", duration: 500 },
|
||
{ note: "NOTE_D4", duration: 500 },
|
||
{ note: "NOTE_A4", duration: 500 }
|
||
],
|
||
"BIRTHDAY": [
|
||
{ note: "NOTE_C4", duration: 400 },
|
||
{ note: "NOTE_C4", duration: 400 },
|
||
{ note: "NOTE_D4", duration: 800 },
|
||
{ note: "NOTE_C4", duration: 800 },
|
||
{ note: "NOTE_F4", duration: 800 },
|
||
{ note: "NOTE_E4", duration: 1600 }
|
||
],
|
||
"BA_DING": [
|
||
{ note: "NOTE_C5", duration: 200 },
|
||
{ note: "NOTE_E5", duration: 200 },
|
||
{ note: "NOTE_G5", duration: 400 }
|
||
],
|
||
"JUMP_UP": [
|
||
{ note: "NOTE_C5", duration: 100 },
|
||
{ note: "NOTE_E5", duration: 100 },
|
||
{ note: "NOTE_G5", duration: 100 }
|
||
],
|
||
"JUMP_DOWN": [
|
||
{ note: "NOTE_G5", duration: 100 },
|
||
{ note: "NOTE_E5", duration: 100 },
|
||
{ note: "NOTE_C5", duration: 100 }
|
||
],
|
||
"POWER_UP": [
|
||
{ note: "NOTE_C4", duration: 150 },
|
||
{ note: "NOTE_E4", duration: 150 },
|
||
{ note: "NOTE_G4", duration: 150 },
|
||
{ note: "NOTE_C5", duration: 300 }
|
||
],
|
||
"POWER_DOWN": [
|
||
{ note: "NOTE_C5", duration: 150 },
|
||
{ note: "NOTE_G4", duration: 150 },
|
||
{ note: "NOTE_E4", duration: 150 },
|
||
{ note: "NOTE_C4", duration: 300 }
|
||
]
|
||
};
|
||
|
||
const sequence = noteSequences[noteList];
|
||
if (sequence) {
|
||
for (const item of sequence) {
|
||
const frequency = sound.noteFrequencies[item.note] || 440;
|
||
await sound.play_frequency_blocking(frequency, item.duration);
|
||
}
|
||
|
||
resolve();
|
||
} else {
|
||
console.warn(`未知的音符列表: ${noteList}`);
|
||
reject(new Error(`未知的音符列表: ${noteList}`));
|
||
}
|
||
} catch (error) {
|
||
console.error("播放音符列表失败:", error);
|
||
reject(error);
|
||
}
|
||
})();
|
||
});
|
||
},
|
||
|
||
adjust_effect: (effect, change) => {
|
||
if (effect === "pitch") {
|
||
sound.effects.pitch = Math.max(-24, Math.min(24, sound.effects.pitch + change));
|
||
} else if (effect === "pan") {
|
||
sound.effects.pan = Math.max(-100, Math.min(100, sound.effects.pan + change));
|
||
}
|
||
},
|
||
|
||
set_effect: (effect, value) => {
|
||
if (effect === "pitch") {
|
||
sound.effects.pitch = Math.max(-24, Math.min(24, value));
|
||
} else if (effect === "pan") {
|
||
sound.effects.pan = Math.max(-100, Math.min(100, value));
|
||
}
|
||
},
|
||
|
||
clear_effects: () => {
|
||
sound.effects.pitch = 0;
|
||
sound.effects.pan = 0;
|
||
},
|
||
|
||
record: () => {
|
||
if (sound.isRecording) {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
navigator.mediaDevices.getUserMedia({ audio: true })
|
||
.then(stream => {
|
||
sound.mediaRecorder = new MediaRecorder(stream);
|
||
sound.recordedChunks = [];
|
||
|
||
sound.mediaRecorder.ondataavailable = (event) => {
|
||
if (event.data.size > 0) {
|
||
sound.recordedChunks.push(event.data);
|
||
}
|
||
};
|
||
|
||
sound.mediaRecorder.onstart = () => {
|
||
sound.isRecording = true;
|
||
};
|
||
|
||
sound.mediaRecorder.onstop = () => {
|
||
sound.isRecording = false;
|
||
|
||
const audioBlob = new Blob(sound.recordedChunks, { type: 'audio/wav' });
|
||
sound.recordedAudio = URL.createObjectURL(audioBlob);
|
||
|
||
stream.getTracks().forEach(track => {
|
||
track.stop();
|
||
});
|
||
|
||
sound.showPlaybackInterface(audioBlob);
|
||
};
|
||
|
||
sound.mediaRecorder.onerror = (event) => {
|
||
console.error("MediaRecorder 错误:", event.error);
|
||
sound.isRecording = false;
|
||
};
|
||
|
||
sound.mediaRecorder.start(100);
|
||
|
||
sound.showRecordInterface();
|
||
})
|
||
.catch(error => {
|
||
console.error("获取麦克风权限失败:", error);
|
||
alert("无法访问麦克风，请检查权限设置。错误: " + error.message);
|
||
});
|
||
} catch (error) {
|
||
console.error("录制功能初始化失败:", error);
|
||
alert("录制功能初始化失败: " + error.message);
|
||
}
|
||
},
|
||
|
||
showRecordInterface: () => {
|
||
const recordModal = document.createElement('div');
|
||
recordModal.id = 'recordModal';
|
||
recordModal.style.cssText = `
|
||
position: fixed;
|
||
top: 0;
|
||
left: 0;
|
||
width: 100%;
|
||
height: 100%;
|
||
background: rgba(0, 0, 0, 0.5);
|
||
display: flex;
|
||
justify-content: center;
|
||
align-items: center;
|
||
z-index: 10000;
|
||
`;
|
||
|
||
const recordContent = document.createElement('div');
|
||
recordContent.style.cssText = `
|
||
background: white;
|
||
border-radius: 10px;
|
||
padding: 20px;
|
||
text-align: center;
|
||
min-width: 300px;
|
||
box-shadow: 0 4px 20px rgba(0,0,0,0.3);
|
||
`;
|
||
|
||
recordContent.innerHTML = `
|
||
<h3 style="color: #4a90e2; margin-bottom: 20px;">录制声音</h3>
|
||
<div id="waveform" style="width: 250px; height: 100px; background: #f0f0f0; margin: 20px auto; border-radius: 5px; position: relative; overflow: hidden;">
|
||
<div id="volumeMeter" style="position: absolute; left: 10px; top: 10px; width: 20px; height: 80px; background: linear-gradient(to top, #4CAF50, #FFC107, #F44336); border-radius: 3px;"></div>
|
||
<div id="waveformBars" style="position: absolute; left: 40px; top: 10px; width: 200px; height: 80px;"></div>
|
||
</div>
|
||
<div style="margin: 20px 0;">
|
||
<button id="stopRecord" style="background: #f44336; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; margin: 0 10px;">停止录制</button>
|
||
</div>
|
||
<div id="status" style="color: #666; font-size: 14px; margin-top: 10px;">正在录制...</div>
|
||
`;
|
||
|
||
recordModal.appendChild(recordContent);
|
||
|
||
try {
|
||
safeDOM.appendChild(document.body, recordModal);
|
||
} catch (error) {
|
||
console.error("添加录制界面到DOM失败:", error);
|
||
return;
|
||
}
|
||
|
||
recordModal.addEventListener('click', (event) => {
|
||
if (event.target.id === 'stopRecord') {
|
||
try {
|
||
if (sound.mediaRecorder && sound.isRecording) {
|
||
sound.mediaRecorder.stop();
|
||
} else {
|
||
console.warn("MediaRecorder 不存在或未在录制状态");
|
||
}
|
||
} catch (error) {
|
||
console.error("停止录制时出错:", error);
|
||
alert("停止录制时出错: " + error.message);
|
||
}
|
||
}
|
||
});
|
||
|
||
const waveformBars = recordModal.querySelector('#waveformBars');
|
||
if (waveformBars) {
|
||
for (let i = 0; i < 20; i++) {
|
||
const bar = document.createElement('div');
|
||
bar.style.cssText = `
|
||
position: absolute;
|
||
left: ${i * 10}px;
|
||
bottom: 0;
|
||
width: 8px;
|
||
height: 20px;
|
||
background: #4a90e2;
|
||
border-radius: 2px;
|
||
transition: height 0.1s ease;
|
||
`;
|
||
waveformBars.appendChild(bar);
|
||
}
|
||
|
||
const updateWaveform = () => {
|
||
if (sound.isRecording && recordModal.parentNode) {
|
||
const bars = waveformBars.children;
|
||
for (let i = 0; i < bars.length; i++) {
|
||
const height = Math.random() * 60 + 20;
|
||
bars[i].style.height = height + 'px';
|
||
bars[i].style.background = `hsl(${200 + Math.random() * 60}, 70%, 60%)`;
|
||
}
|
||
}
|
||
};
|
||
|
||
const waveformInterval = setInterval(updateWaveform, 100);
|
||
recordModal.waveformInterval = waveformInterval;
|
||
}
|
||
|
||
let volumeLevel = 0;
|
||
const volumeMeter = recordModal.querySelector('#volumeMeter');
|
||
const statusDiv = recordModal.querySelector('#status');
|
||
|
||
if (volumeMeter && statusDiv) {
|
||
const volumeInterval = setInterval(() => {
|
||
if (sound.isRecording && recordModal.parentNode) {
|
||
volumeLevel = Math.random() * 60 + 40;
|
||
volumeMeter.style.height = volumeLevel + '%';
|
||
statusDiv.textContent = `正在录制... 音量: ${Math.round(volumeLevel)}%`;
|
||
|
||
volumeMeter.style.opacity = 0.8 + (volumeLevel / 100) * 0.2;
|
||
} else {
|
||
clearInterval(volumeInterval);
|
||
if (statusDiv && recordModal.parentNode) {
|
||
statusDiv.textContent = "录制完成";
|
||
statusDiv.style.color = "#4CAF50";
|
||
}
|
||
if (volumeMeter && recordModal.parentNode) {
|
||
volumeMeter.style.height = "100%";
|
||
volumeMeter.style.background = "linear-gradient(to top, #4CAF50, #4CAF50)";
|
||
}
|
||
}
|
||
}, 200);
|
||
|
||
recordModal.volumeInterval = volumeInterval;
|
||
} else {
|
||
console.error("找不到音量计或状态显示元素");
|
||
}
|
||
|
||
const keyHandler = (event) => {
|
||
if (event.code === 'Space' && sound.isRecording) {
|
||
event.preventDefault();
|
||
if (sound.mediaRecorder) {
|
||
sound.mediaRecorder.stop();
|
||
}
|
||
}
|
||
};
|
||
|
||
document.addEventListener('keydown', keyHandler);
|
||
|
||
recordModal.keyHandler = keyHandler;
|
||
},
|
||
|
||
showPlaybackInterface: (audioBlob) => {
|
||
const recordModal = document.getElementById('recordModal');
|
||
if (recordModal) {
|
||
if (recordModal.volumeInterval) clearInterval(recordModal.volumeInterval);
|
||
if (recordModal.waveformInterval) clearInterval(recordModal.waveformInterval);
|
||
if (recordModal.keyHandler) document.removeEventListener('keydown', recordModal.keyHandler);
|
||
|
||
try {
|
||
if (safeDOM.exists(recordModal)) {
|
||
safeDOM.removeChild(document.body, recordModal);
|
||
}
|
||
} catch (error) {
|
||
console.warn("移除录制界面时出错:", error);
|
||
}
|
||
}
|
||
|
||
const playbackModal = document.createElement('div');
|
||
playbackModal.id = 'playbackModal';
|
||
playbackModal.style.cssText = `
|
||
position: fixed;
|
||
top: 0;
|
||
left: 0;
|
||
width: 100%;
|
||
height: 100%;
|
||
background: rgba(0, 0, 0, 0.5);
|
||
display: flex;
|
||
justify-content: center;
|
||
align-items: center;
|
||
z-index: 10000;
|
||
`;
|
||
|
||
const playbackContent = document.createElement('div');
|
||
playbackContent.style.cssText = `
|
||
background: white;
|
||
border-radius: 10px;
|
||
padding: 20px;
|
||
text-align: center;
|
||
min-width: 350px;
|
||
box-shadow: 0 4px 20px rgba(0,0,0,0.3);
|
||
`;
|
||
|
||
playbackContent.innerHTML = `
|
||
<h3 style="color: #4a90e2; margin-bottom: 20px;">录音完成</h3>
|
||
<div id="playbackWaveform" style="width: 300px; height: 120px; background: linear-gradient(45deg, #f0f0f0 25%, transparent 25%), linear-gradient(-45deg, #f0f0f0 25%, transparent 25%), linear-gradient(45deg, transparent 75%, #f0f0f0 75%), linear-gradient(-45deg, transparent 75%, #f0f0f0 75%); background-size: 20px 20px; margin: 20px auto; border-radius: 5px; position: relative; overflow: hidden;">
|
||
<div id="waveformLine" style="position: absolute; left: 0; top: 50%; width: 100%; height: 2px; background: #4a90e2; transform: translateY(-50%);"></div>
|
||
</div>
|
||
<div style="margin: 20px 0;">
|
||
<button id="playRecording" style="background: #4CAF50; color: white; border: none; padding: 15px 25px; border-radius: 5px; cursor: pointer; margin: 0 10px; font-size: 16px;">
|
||
<span style="font-size: 20px;">▶</span> 播放
|
||
</button>
|
||
</div>
|
||
<div style="margin: 20px 0;">
|
||
<button id="reRecord" style="background: #FF9800; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; margin: 0 10px;">🔄 重新录制</button>
|
||
<button id="saveRecording" style="background: #9C27B0; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; margin: 0 10px;">💾 添加到列表</button>
|
||
</div>
|
||
`;
|
||
|
||
playbackModal.appendChild(playbackContent);
|
||
|
||
try {
|
||
safeDOM.appendChild(document.body, playbackModal);
|
||
} catch (error) {
|
||
console.error("添加播放界面到DOM失败:", error);
|
||
return;
|
||
}
|
||
|
||
const playButton = playbackModal.querySelector('#playRecording');
|
||
if (playButton) {
|
||
playButton.onclick = () => {
|
||
try {
|
||
const audio = sound.createAudio(sound.recordedAudio);
|
||
audio.play().catch(error => {
|
||
console.error("播放录音失败:", error);
|
||
alert("播放录音失败: " + error.message);
|
||
});
|
||
|
||
const waveformLine = playbackModal.querySelector('#waveformLine');
|
||
if (waveformLine) {
|
||
waveformLine.style.background = '#FF5722';
|
||
setTimeout(() => {
|
||
if (waveformLine.parentNode) {
|
||
waveformLine.style.background = '#4a90e2';
|
||
}
|
||
}, 1000);
|
||
}
|
||
} catch (error) {
|
||
console.error("播放录音时出错:", error);
|
||
alert("播放录音时出错: " + error.message);
|
||
}
|
||
};
|
||
}
|
||
|
||
const reRecordButton = playbackModal.querySelector('#reRecord');
|
||
if (reRecordButton) {
|
||
reRecordButton.onclick = () => {
|
||
try {
|
||
if (safeDOM.exists(playbackModal)) {
|
||
safeDOM.removeChild(document.body, playbackModal);
|
||
}
|
||
sound.record();
|
||
} catch (error) {
|
||
console.error("重新录制时出错:", error);
|
||
alert("重新录制时出错: " + error.message);
|
||
}
|
||
};
|
||
}
|
||
|
||
const saveButton = playbackModal.querySelector('#saveRecording');
|
||
if (saveButton) {
|
||
saveButton.onclick = () => {
|
||
try {
|
||
sound.saveRecording(audioBlob);
|
||
if (safeDOM.exists(playbackModal)) {
|
||
safeDOM.removeChild(document.body, playbackModal);
|
||
}
|
||
} catch (error) {
|
||
console.error("添加到列表时出错:", error);
|
||
alert("添加到列表时出错: " + error.message);
|
||
}
|
||
};
|
||
}
|
||
|
||
sound.createWaveformDisplay(audioBlob, playbackModal);
|
||
},
|
||
|
||
createWaveformDisplay: async (audioBlob, container) => {
|
||
try {
|
||
if (!container || !container.parentNode) {
|
||
console.warn("波形显示容器不存在或已被移除");
|
||
return;
|
||
}
|
||
|
||
const arrayBuffer = await audioBlob.arrayBuffer();
|
||
const audioContext = new (window.AudioContext || window.webkitAudioContext)();
|
||
const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
|
||
|
||
const channelData = audioBuffer.getChannelData(0);
|
||
const waveformContainer = container.querySelector('#playbackWaveform');
|
||
|
||
if (waveformContainer && waveformContainer.parentNode) {
|
||
waveformContainer.innerHTML = '';
|
||
|
||
const barCount = 100;
|
||
const step = Math.floor(channelData.length / barCount);
|
||
|
||
for (let i = 0; i < barCount; i++) {
|
||
const start = i * step;
|
||
const end = start + step;
|
||
let sum = 0;
|
||
|
||
for (let j = start; j < end; j++) {
|
||
sum += Math.abs(channelData[j] || 0);
|
||
}
|
||
|
||
const average = sum / step;
|
||
const height = Math.max(2, average * 100);
|
||
|
||
const bar = document.createElement('div');
|
||
bar.style.cssText = `
|
||
position: absolute;
|
||
left: ${(i / barCount) * 100}%;
|
||
bottom: 0;
|
||
width: ${100 / barCount}%;
|
||
height: ${height}%;
|
||
background: #4a90e2;
|
||
border-radius: 1px;
|
||
`;
|
||
waveformContainer.appendChild(bar);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.error("创建波形显示失败:", error);
|
||
}
|
||
},
|
||
|
||
saveRecording: (audioBlob) => {
|
||
try {
|
||
const existingRecordings = Object.keys(sound.builtin).filter(k => k.startsWith('recording'));
|
||
|
||
const recordingName = `recording${existingRecordings.length + 1}`;
|
||
|
||
const audioToSave = audioBlob ? URL.createObjectURL(audioBlob) : sound.recordedAudio;
|
||
if (!audioToSave) {
|
||
throw new Error("录音数据不存在");
|
||
}
|
||
|
||
sound.builtin[recordingName] = audioToSave;
|
||
|
||
alert(`录音已保存为: ${recordingName}`);
|
||
|
||
const playbackModal = document.getElementById('playbackModal');
|
||
if (safeDOM.exists(playbackModal)) {
|
||
const playButton = safeDOM.querySelector(playbackModal, '#playRecording');
|
||
if (playButton) {
|
||
playButton.innerHTML = `<span style="font-size: 20px;">▶</span> 播放 ${recordingName}`;
|
||
}
|
||
}
|
||
|
||
} catch (error) {
|
||
console.error("保存录音失败:", error);
|
||
alert("保存录音失败: " + error.message);
|
||
}
|
||
}
|
||
};
|
||
|
||
export default sound;
|
||
|
||
const originalAudio = window.Audio;
|
||
window.Audio = function(src) {
|
||
if (sound.blockAllAudio || sound.isStopped ||
|
||
(sound.abortController && sound.abortController.signal.aborted)) {
|
||
const fakeAudio = {
|
||
play: () => Promise.reject(new Error('Audio playback blocked globally')),
|
||
pause: () => {},
|
||
currentTime: 0,
|
||
src: '',
|
||
volume: 1,
|
||
playbackRate: 1,
|
||
onended: null,
|
||
onerror: null,
|
||
onloadstart: null,
|
||
oncanplay: null,
|
||
onplay: null,
|
||
onpause: null,
|
||
tagName: 'AUDIO',
|
||
addEventListener: () => {},
|
||
removeEventListener: () => {},
|
||
load: () => {},
|
||
duration: 0,
|
||
ended: false,
|
||
paused: true,
|
||
muted: false,
|
||
readyState: 0,
|
||
networkState: 0,
|
||
preload: 'none'
|
||
};
|
||
return fakeAudio;
|
||
}
|
||
// eslint-disable-next-line new-cap
|
||
return new originalAudio(src);
|
||
};
|
||
|
||
window.Audio.original = originalAudio;
|
||
|
||
if (typeof window !== 'undefined') {
|
||
const originalConsoleError = console.error;
|
||
console.error = function(...args) {
|
||
const message = args.join(' ');
|
||
if (message.includes('sound') && (
|
||
message.includes('no-unused-vars') ||
|
||
message.includes('no-trailing-spaces') ||
|
||
message.includes('new-cap')
|
||
)) {
|
||
console.warn('过滤的sound模块ESLint错误:', ...args);
|
||
return;
|
||
}
|
||
originalConsoleError.apply(console, args);
|
||
};
|
||
}
|
||
|
||
function patchPythonShell() {
|
||
const originalRemove = Element.prototype.remove;
|
||
Element.prototype.remove = function() {
|
||
if (!this) {
|
||
console.warn('尝试在null对象上调用remove()，已安全忽略');
|
||
return;
|
||
}
|
||
if (typeof this.remove !== 'function') {
|
||
console.warn('对象没有remove方法，已安全忽略');
|
||
return;
|
||
}
|
||
try {
|
||
return originalRemove.call(this);
|
||
} catch (error) {
|
||
console.warn('remove()调用失败，已安全处理:', error);
|
||
}
|
||
};
|
||
|
||
if (window.$ && window.$.fn && window.$.fn.remove) {
|
||
const originalJQueryRemove = window.$.fn.remove;
|
||
window.$.fn.remove = function() {
|
||
if (!this || this.length === 0) {
|
||
console.warn('尝试在空的jQuery对象上调用remove()，已安全忽略');
|
||
return this;
|
||
}
|
||
try {
|
||
return originalJQueryRemove.call(this);
|
||
} catch (error) {
|
||
console.warn('jQuery remove()调用失败，已安全处理:', error);
|
||
return this;
|
||
}
|
||
};
|
||
}
|
||
}
|
||
|
||
let isInjecting = false;
|
||
|
||
function isKeyboardInterruptError(error) {
|
||
if (!error) {
|
||
return false;
|
||
}
|
||
if (error.name === 'PythonError' || error.name === 'KeyboardInterrupt') {
|
||
const message = error.message || String(error);
|
||
return message.includes('KeyboardInterrupt') || message.includes('interrupted');
|
||
}
|
||
return false;
|
||
}
|
||
|
||
function injectSoundToPython() {
|
||
if (isInjecting) {
|
||
return false;
|
||
}
|
||
if (window.pyodide && window.pyodide.globals) {
|
||
try {
|
||
isInjecting = true;
|
||
const pythonSound = {
|
||
play: (name) => {
|
||
return sound.play(name);
|
||
},
|
||
play_blocking: (name) => {
|
||
return sound.play_blocking(name);
|
||
},
|
||
stop_all: () => {
|
||
return sound.stop_all();
|
||
},
|
||
adjust_volume: (change) => {
|
||
return sound.adjust_volume(change);
|
||
},
|
||
set_volume: (value) => {
|
||
return sound.set_volume(value);
|
||
},
|
||
get_volume: () => {
|
||
return sound.get_volume();
|
||
},
|
||
adjust_effect: (effect, change) => {
|
||
return sound.adjust_effect(effect, change);
|
||
},
|
||
set_effect: (effect, value) => {
|
||
return sound.set_effect(effect, value);
|
||
},
|
||
clear_effects: () => {
|
||
return sound.clear_effects();
|
||
},
|
||
play_frequency: (frequency, duration) => {
|
||
console.log(`Python调用: sound.play_frequency(${frequency}, ${duration})`);
|
||
// 自动判断是否需要阻塞
|
||
if (sound.soundQueue.length > 0 || sound.isProcessingQueue) {
|
||
return sound.play_frequency_blocking(frequency, duration);
|
||
}
|
||
return sound.play_frequency(frequency, duration);
|
||
},
|
||
play_frequency_no_duration: (frequency) => {
|
||
console.log(`Python调用: sound.play_frequency_no_duration(${frequency})`);
|
||
// 自动判断是否需要阻塞
|
||
if (sound.soundQueue.length > 0 || sound.isProcessingQueue) {
|
||
return sound.play_frequency_continuous_blocking(frequency);
|
||
}
|
||
return sound.play_frequency_continuous(frequency);
|
||
},
|
||
play_frequency_blocking: (frequency, duration) => {
|
||
console.log(`Python调用: sound.play_frequency_blocking(${frequency}, ${duration})`);
|
||
return sound.play_frequency_blocking(frequency, duration);
|
||
},
|
||
play_frequency_continuous: (frequency) => {
|
||
console.log(`Python调用: sound.play_frequency_continuous(${frequency})`);
|
||
return sound.play_frequency_continuous(frequency);
|
||
},
|
||
play_frequency_continuous_blocking: (frequency) => {
|
||
console.log(`Python调用: sound.play_frequency_continuous_blocking(${frequency})`);
|
||
return sound.play_frequency_continuous_blocking(frequency);
|
||
},
|
||
play_note_list: (noteList) => {
|
||
return sound.play_note_list(noteList);
|
||
},
|
||
play_note_list_blocking: (noteList) => {
|
||
return sound.play_note_list_blocking(noteList);
|
||
},
|
||
record: () => {
|
||
return sound.record();
|
||
},
|
||
volume: sound.volume,
|
||
effects: sound.effects
|
||
};
|
||
|
||
window.pyodide.globals.set('sound', pythonSound);
|
||
|
||
const ModuleType = window.pyodide.pyimport('types').ModuleType;
|
||
const soundModule = new ModuleType('sound');
|
||
|
||
Object.keys(pythonSound).forEach(key => {
|
||
if (typeof pythonSound[key] === 'function') {
|
||
soundModule[key] = pythonSound[key];
|
||
} else {
|
||
soundModule[key] = pythonSound[key];
|
||
}
|
||
});
|
||
try {
|
||
window.pyodide.runPython(`
|
||
import sys
|
||
sys.modules['sound'] = sound
|
||
|
||
# 创建同步版本的play_blocking包装函数
|
||
import asyncio
|
||
from js import Promise
|
||
|
||
# 保存原始的play_blocking（返回Promise的版本）
|
||
_original_play_blocking = sound.play_blocking
|
||
|
||
def _sync_play_blocking(name):
|
||
"""同步版本的play_blocking，会等待声音播放完成"""
|
||
promise = _original_play_blocking(name)
|
||
# 使用Pyodide的Promise支持
|
||
# 在Pyodide中，可以直接等待JS Promise
|
||
import pyodide
|
||
if hasattr(pyodide, 'ffi') and hasattr(pyodide.ffi, 'run_sync'):
|
||
# Pyodide 0.21+
|
||
try:
|
||
return pyodide.ffi.run_sync(promise)
|
||
except Exception:
|
||
return None
|
||
else:
|
||
# 降级方案：使用asyncio
|
||
try:
|
||
loop = asyncio.get_event_loop()
|
||
except RuntimeError:
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
# 将JS Promise转换为Python awaitable
|
||
async def wait_promise():
|
||
try:
|
||
return await promise
|
||
except Exception:
|
||
return None
|
||
|
||
try:
|
||
return loop.run_until_complete(wait_promise())
|
||
except Exception:
|
||
return None
|
||
|
||
# 替换sound.play_blocking为同步版本
|
||
sound.play_blocking = _sync_play_blocking
|
||
|
||
# 创建同步版本的play_frequency包装函数
|
||
_original_play_frequency = sound.play_frequency
|
||
|
||
def _sync_play_frequency(frequency, duration):
|
||
"""同步版本的play_frequency，会自动判断是否需要阻塞"""
|
||
promise = _original_play_frequency(frequency, duration)
|
||
# 使用Pyodide的Promise支持
|
||
import pyodide
|
||
if hasattr(pyodide, 'ffi') and hasattr(pyodide.ffi, 'run_sync'):
|
||
try:
|
||
return pyodide.ffi.run_sync(promise)
|
||
except Exception:
|
||
return None
|
||
else:
|
||
import asyncio
|
||
try:
|
||
loop = asyncio.get_event_loop()
|
||
except RuntimeError:
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
async def wait_promise():
|
||
try:
|
||
return await promise
|
||
except Exception:
|
||
return None
|
||
|
||
try:
|
||
return loop.run_until_complete(wait_promise())
|
||
except Exception:
|
||
return None
|
||
|
||
# 创建同步版本的play_frequency_no_duration包装函数
|
||
_original_play_frequency_no_duration = sound.play_frequency_no_duration
|
||
|
||
def _sync_play_frequency_no_duration(frequency):
|
||
"""同步版本的play_frequency_no_duration，会自动判断是否需要阻塞"""
|
||
promise = _original_play_frequency_no_duration(frequency)
|
||
# 使用Pyodide的Promise支持
|
||
import pyodide
|
||
if hasattr(pyodide, 'ffi') and hasattr(pyodide.ffi, 'run_sync'):
|
||
try:
|
||
return pyodide.ffi.run_sync(promise)
|
||
except Exception:
|
||
return None
|
||
else:
|
||
import asyncio
|
||
try:
|
||
loop = asyncio.get_event_loop()
|
||
except RuntimeError:
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
async def wait_promise():
|
||
try:
|
||
return await promise
|
||
except Exception:
|
||
return None
|
||
|
||
try:
|
||
return loop.run_until_complete(wait_promise())
|
||
except Exception:
|
||
return None
|
||
|
||
# 替换为同步版本
|
||
sound.play_frequency = _sync_play_frequency
|
||
sound.play_frequency_no_duration = _sync_play_frequency_no_duration
|
||
|
||
# 创建同步版本的play_frequency_continuous_blocking包装函数
|
||
_original_play_frequency_continuous_blocking = sound.play_frequency_continuous_blocking
|
||
|
||
def _sync_play_frequency_continuous_blocking(frequency):
|
||
"""同步版本的play_frequency_continuous_blocking，会等待频率播放完成"""
|
||
promise = _original_play_frequency_continuous_blocking(frequency)
|
||
# 使用Pyodide的Promise支持
|
||
import pyodide
|
||
if hasattr(pyodide, 'ffi') and hasattr(pyodide.ffi, 'run_sync'):
|
||
return pyodide.ffi.run_sync(promise)
|
||
else:
|
||
import asyncio
|
||
try:
|
||
loop = asyncio.get_event_loop()
|
||
except RuntimeError:
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
async def wait_promise():
|
||
return await promise
|
||
|
||
return loop.run_until_complete(wait_promise())
|
||
|
||
# 替换为同步版本
|
||
sound.play_frequency_continuous_blocking = _sync_play_frequency_continuous_blocking
|
||
|
||
# 创建同步版本的play_frequency_blocking包装函数
|
||
_original_play_frequency_blocking = sound.play_frequency_blocking
|
||
|
||
def _sync_play_frequency_blocking(frequency, duration):
|
||
"""同步版本的play_frequency_blocking，会等待频率播放完成"""
|
||
promise = _original_play_frequency_blocking(frequency, duration)
|
||
# 使用Pyodide的Promise支持
|
||
import pyodide
|
||
if hasattr(pyodide, 'ffi') and hasattr(pyodide.ffi, 'run_sync'):
|
||
try:
|
||
return pyodide.ffi.run_sync(promise)
|
||
except Exception:
|
||
return None
|
||
else:
|
||
import asyncio
|
||
try:
|
||
loop = asyncio.get_event_loop()
|
||
except RuntimeError:
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
async def wait_promise():
|
||
try:
|
||
return await promise
|
||
except Exception:
|
||
return None
|
||
|
||
try:
|
||
return loop.run_until_complete(wait_promise())
|
||
except Exception:
|
||
return None
|
||
|
||
# 创建同步版本的play_note_list_blocking包装函数
|
||
_original_play_note_list_blocking = sound.play_note_list_blocking
|
||
|
||
def _sync_play_note_list_blocking(note_list):
|
||
"""同步版本的play_note_list_blocking，会等待音符列表播放完成"""
|
||
promise = _original_play_note_list_blocking(note_list)
|
||
# 使用Pyodide的Promise支持
|
||
import pyodide
|
||
if hasattr(pyodide, 'ffi') and hasattr(pyodide.ffi, 'run_sync'):
|
||
try:
|
||
return pyodide.ffi.run_sync(promise)
|
||
except Exception:
|
||
return None
|
||
else:
|
||
import asyncio
|
||
try:
|
||
loop = asyncio.get_event_loop()
|
||
except RuntimeError:
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
async def wait_promise():
|
||
try:
|
||
return await promise
|
||
except Exception:
|
||
return None
|
||
|
||
try:
|
||
return loop.run_until_complete(wait_promise())
|
||
except Exception:
|
||
return None
|
||
|
||
# 替换为同步版本
|
||
sound.play_frequency_blocking = _sync_play_frequency_blocking
|
||
sound.play_note_list_blocking = _sync_play_note_list_blocking
|
||
`);
|
||
} catch (runError) {
|
||
if (isKeyboardInterruptError(runError)) {
|
||
isInjecting = false;
|
||
return false;
|
||
}
|
||
throw runError;
|
||
}
|
||
|
||
const testSound = window.pyodide.globals.get('sound');
|
||
if (testSound) {
|
||
isInjecting = false;
|
||
return true;
|
||
}
|
||
isInjecting = false;
|
||
console.error('Sound对象注入失败：验证时未找到对象');
|
||
return false;
|
||
} catch (error) {
|
||
isInjecting = false;
|
||
if (isKeyboardInterruptError(error)) {
|
||
return false;
|
||
}
|
||
console.error('注入sound对象到Python环境失败:', error);
|
||
return false;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
function initializeSoundSystem() {
|
||
if (injectSoundToPython()) {
|
||
return;
|
||
}
|
||
|
||
const soundInjectionInterval = setInterval(() => {
|
||
if (injectSoundToPython()) {
|
||
clearInterval(soundInjectionInterval);
|
||
}
|
||
}, 100);
|
||
|
||
setTimeout(() => {
|
||
clearInterval(soundInjectionInterval);
|
||
}, 10000);
|
||
}
|
||
|
||
function startAllSystems() {
|
||
patchPythonShell();
|
||
initializeSoundSystem();
|
||
}
|
||
|
||
function forceInjectSound() {
|
||
if (window.pyodide && window.pyodide.globals) {
|
||
try {
|
||
const existingSound = window.pyodide.globals.get('sound');
|
||
if (!existingSound) {
|
||
injectSoundToPython();
|
||
}
|
||
} catch (error) {
|
||
if (isKeyboardInterruptError(error)) {
|
||
return;
|
||
}
|
||
console.warn('强制注入检查失败:', error);
|
||
}
|
||
}
|
||
}
|
||
|
||
function interceptPythonExecution() {
|
||
const originalEval = window.eval;
|
||
window.eval = function(code) {
|
||
if (typeof code === 'string' && code.includes('sound.')) {
|
||
try {
|
||
forceInjectSound();
|
||
} catch (error) {
|
||
if (!isKeyboardInterruptError(error)) {
|
||
console.warn('执行拦截时出错:', error);
|
||
}
|
||
}
|
||
}
|
||
return originalEval.call(this, code);
|
||
};
|
||
|
||
if (window.pyodide && window.pyodide.runPython) {
|
||
const originalRunPython = window.pyodide.runPython;
|
||
window.pyodide.runPython = function(code) {
|
||
if (typeof code === 'string' && code.includes('sound.')) {
|
||
try {
|
||
forceInjectSound();
|
||
} catch (error) {
|
||
if (!isKeyboardInterruptError(error)) {
|
||
console.warn('执行拦截时出错:', error);
|
||
}
|
||
}
|
||
}
|
||
return originalRunPython.call(this, code);
|
||
};
|
||
}
|
||
}
|
||
if (document.readyState === 'loading') {
|
||
document.addEventListener('DOMContentLoaded', () => {
|
||
startAllSystems();
|
||
interceptPythonExecution();
|
||
});
|
||
} else {
|
||
startAllSystems();
|
||
interceptPythonExecution();
|
||
}
|
||
|
||
window.addEventListener('pyodideLoaded', () => {
|
||
startAllSystems();
|
||
interceptPythonExecution();
|
||
});
|
||
|
||
setTimeout(() => {
|
||
startAllSystems();
|
||
interceptPythonExecution();
|
||
}, 1000);
|
||
|
||
window.addEventListener('load', () => {
|
||
startAllSystems();
|
||
interceptPythonExecution();
|
||
});
|
||
|
||
setInterval(forceInjectSound, 5000); |