318 lines
10 KiB
JavaScript
318 lines
10 KiB
JavaScript
import { synthesizeMicrophoneSignals } from "/packages/acoustics-core/propagation.js";
|
|
import { sampleQuasiStaticWindow } from "/packages/acoustics-core/trajectory.js";
|
|
import { createLocalizationAnalysisPlan } from "/packages/acoustics-core/localization.js";
|
|
import { localizationAlgorithmSupportsBackend } from "/packages/acoustics-core/localization-algorithms.js";
|
|
import { computeLocalizationWithBackend } from "/packages/webgpu-kernels/compute.js";
|
|
import { isMusicUnavailableError } from "/packages/acoustics-core/music.js";
|
|
import { getCompleteFrameCount } from "/packages/acoustics-core/stft.js";
|
|
|
|
function post(type, jobId, payload = {}, transfer = []) {
|
|
self.postMessage({ type, jobId, ...payload }, transfer);
|
|
}
|
|
|
|
function serializeError(error) {
|
|
return {
|
|
name: error?.name ?? "Error",
|
|
code: error?.code ?? "",
|
|
message: error instanceof Error ? error.message : String(error),
|
|
stack: error?.stack ?? "",
|
|
causes: error instanceof AggregateError
|
|
? error.errors.map((cause) => ({ name: cause?.name, code: cause?.code, message: cause?.message }))
|
|
: [],
|
|
};
|
|
}
|
|
|
|
function signalStats(synthesis) {
|
|
return {
|
|
preNormalizationPeak: synthesis.preNormalizationPeak,
|
|
appliedScale: synthesis.appliedScale,
|
|
clippedSampleCount: synthesis.clippedSampleCount,
|
|
peak: synthesis.peak,
|
|
acousticModel: synthesis.acousticModel,
|
|
acousticPathCount: synthesis.acousticPathCount,
|
|
acousticPathCounts: synthesis.acousticPathCounts,
|
|
workingSet: synthesis.workingSet,
|
|
windowing: synthesis.windowing,
|
|
sampling: synthesis.sampling,
|
|
};
|
|
}
|
|
|
|
function collectBandTransfers(run, transfer) {
|
|
const knownBuffers = new Set(transfer);
|
|
for (const band of run.bands ?? []) {
|
|
for (const map of [band.rawMap, band.displayMap]) {
|
|
const buffer = map?.buffer;
|
|
if (buffer instanceof ArrayBuffer && !knownBuffers.has(buffer)) {
|
|
knownBuffers.add(buffer);
|
|
transfer.push(buffer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async function computeLocalizationOrUnavailable(options) {
|
|
try {
|
|
return await computeLocalizationWithBackend(options);
|
|
} catch (error) {
|
|
if (!isMusicUnavailableError(error)) throw error;
|
|
return {
|
|
algorithm: "music",
|
|
backend: "cpu",
|
|
status: "unavailable",
|
|
unavailable: {
|
|
code: error.code,
|
|
reason: error.reason,
|
|
message: error.message,
|
|
details: { ...error.details },
|
|
},
|
|
frameCount: getCompleteFrameCount(
|
|
options.channels[0]?.length ?? 0,
|
|
options.experiment.stft.fftSize,
|
|
options.experiment.stft.hopSize,
|
|
),
|
|
microphoneCount:
|
|
options.arrayDefinition.microphones.length,
|
|
pointCount:
|
|
options.experiment.scan.rows *
|
|
options.experiment.scan.columns,
|
|
objectiveDirection: "minimum",
|
|
rawScale: "noise-projection",
|
|
bands: [],
|
|
};
|
|
}
|
|
}
|
|
|
|
async function runTimeline({ jobId, scene, arrayDefinition, experiment, assetBuffers, framePlan }) {
|
|
if (!Array.isArray(framePlan?.frames) || framePlan.frames.length === 0) {
|
|
throw new TypeError("framePlan.frames must be a non-empty array.");
|
|
}
|
|
|
|
const totalStartedAt = performance.now();
|
|
const totalFrames = framePlan.frames.length;
|
|
const frames = [];
|
|
const transfer = [];
|
|
let signalGeneration = 0;
|
|
let localizationTime = 0;
|
|
const localizationScene = { speedOfSound: scene.speedOfSound };
|
|
const algorithm = experiment.beamforming.algorithm ?? "das";
|
|
const requestedBackend = experiment.beamforming.backend ?? "auto";
|
|
const reuseCpuPlan =
|
|
!localizationAlgorithmSupportsBackend(algorithm, "webgpu") ||
|
|
requestedBackend === "cpu";
|
|
let localizationExperiment = experiment;
|
|
let analysisPlan = reuseCpuPlan
|
|
? createLocalizationAnalysisPlan({
|
|
sampleRate: scene.sampleRate,
|
|
arrayDefinition,
|
|
scene: localizationScene,
|
|
experiment: localizationExperiment,
|
|
})
|
|
: undefined;
|
|
|
|
post("progress", jobId, {
|
|
stage: "timeline-start",
|
|
message: `라이브 맵 ${totalFrames}개를 준비하고 있습니다…`,
|
|
completedFrames: 0,
|
|
totalFrames,
|
|
});
|
|
|
|
for (let frameIndex = 0; frameIndex < totalFrames; frameIndex += 1) {
|
|
const plannedFrame = framePlan.frames[frameIndex];
|
|
const synthesisWindow = sampleQuasiStaticWindow(
|
|
scene,
|
|
plannedFrame.startTime,
|
|
plannedFrame.endTime,
|
|
{
|
|
arrayDefinition,
|
|
assetBuffers,
|
|
minimumDistance: experiment.beamforming.minimumDistance,
|
|
},
|
|
);
|
|
post("progress", jobId, {
|
|
stage: "timeline-signal",
|
|
message: `라이브 신호 합성 중 · ${frameIndex + 1}/${totalFrames}`,
|
|
frameIndex,
|
|
completedFrames: frameIndex,
|
|
totalFrames,
|
|
});
|
|
|
|
const frameStartedAt = performance.now();
|
|
const signalStartedAt = performance.now();
|
|
const synthesis = synthesizeMicrophoneSignals({
|
|
scene: synthesisWindow.scene,
|
|
arrayDefinition,
|
|
assetBuffers,
|
|
minimumDistance: experiment.beamforming.minimumDistance,
|
|
signalOffsets: synthesisWindow.signalOffsets,
|
|
});
|
|
const frameSignalGeneration = performance.now() - signalStartedAt;
|
|
signalGeneration += frameSignalGeneration;
|
|
|
|
const localizationStartedAt = performance.now();
|
|
const localization = await computeLocalizationOrUnavailable({
|
|
channels: synthesis.channels,
|
|
sampleRate: synthesis.sampleRate,
|
|
arrayDefinition,
|
|
scene: localizationScene,
|
|
experiment: localizationExperiment,
|
|
...(analysisPlan ? { analysisPlan } : {}),
|
|
onFallback: ({ error }) =>
|
|
post("fallback", jobId, {
|
|
code: error.code,
|
|
message: error.message,
|
|
frameIndex,
|
|
totalFrames,
|
|
}),
|
|
onProgress: (progress) =>
|
|
post("progress", jobId, {
|
|
stage: `timeline-${progress.stage}`,
|
|
frameIndex,
|
|
completedFrames: frameIndex,
|
|
totalFrames,
|
|
progress,
|
|
}),
|
|
});
|
|
const frameLocalization = performance.now() - localizationStartedAt;
|
|
localizationTime += frameLocalization;
|
|
collectBandTransfers(localization, transfer);
|
|
|
|
if (
|
|
!analysisPlan &&
|
|
localization.backend === "cpu" &&
|
|
localization.fallback?.from === "webgpu"
|
|
) {
|
|
// Auto has established that WebGPU is unavailable for this worker. Keep
|
|
// the first frame's honest fallback metadata, then avoid retrying the GPU
|
|
// and rebuilding CPU geometry/workspaces on every remaining live frame.
|
|
localizationExperiment = {
|
|
...experiment,
|
|
beamforming: {
|
|
...experiment.beamforming,
|
|
backend: "cpu",
|
|
},
|
|
};
|
|
analysisPlan = createLocalizationAnalysisPlan({
|
|
sampleRate: scene.sampleRate,
|
|
arrayDefinition,
|
|
scene: localizationScene,
|
|
experiment: localizationExperiment,
|
|
});
|
|
}
|
|
|
|
frames.push({
|
|
index: plannedFrame.index ?? frameIndex,
|
|
startTime: synthesisWindow.startTime,
|
|
endTime: synthesisWindow.endTime,
|
|
sampleTime: synthesisWindow.sampleTime,
|
|
duration: synthesisWindow.duration,
|
|
run: {
|
|
...localization,
|
|
signalStats: signalStats(synthesis),
|
|
timingMs: {
|
|
total: performance.now() - frameStartedAt,
|
|
signalGeneration: frameSignalGeneration,
|
|
localization: frameLocalization,
|
|
beamforming: frameLocalization,
|
|
},
|
|
},
|
|
});
|
|
|
|
post("progress", jobId, {
|
|
stage: "timeline-frame-complete",
|
|
message: `라이브 맵 준비 · ${frameIndex + 1}/${totalFrames}`,
|
|
frameIndex,
|
|
completedFrames: frameIndex + 1,
|
|
totalFrames,
|
|
});
|
|
}
|
|
|
|
const backends = new Set(frames.map((frame) => frame.run.backend));
|
|
const fallbacks = frames
|
|
.filter((frame) => frame.run.fallback)
|
|
.map((frame) => ({ frameIndex: frame.index, ...frame.run.fallback }));
|
|
post(
|
|
"timeline-result",
|
|
jobId,
|
|
{
|
|
timeline: {
|
|
backend: backends.size === 1 ? frames[0].run.backend : "mixed",
|
|
algorithm: experiment.beamforming.algorithm ?? "das",
|
|
requestedBackend: experiment.beamforming.backend ?? "auto",
|
|
duration: scene.duration,
|
|
frameCount: frames.length,
|
|
frames,
|
|
...(fallbacks.length > 0 ? { fallbacks } : {}),
|
|
timingMs: {
|
|
total: performance.now() - totalStartedAt,
|
|
signalGeneration,
|
|
localization: localizationTime,
|
|
beamforming: localizationTime,
|
|
},
|
|
},
|
|
},
|
|
transfer,
|
|
);
|
|
}
|
|
|
|
self.addEventListener("message", async (event) => {
|
|
if (event.data?.type !== "run" && event.data?.type !== "run-timeline") return;
|
|
const { jobId, scene, arrayDefinition, experiment, assetBuffers } = event.data;
|
|
const totalStartedAt = performance.now();
|
|
try {
|
|
if (event.data.type === "run-timeline") {
|
|
await runTimeline(event.data);
|
|
return;
|
|
}
|
|
post("progress", jobId, { stage: "signal", message: "마이크 수신 신호를 합성하고 있습니다…" });
|
|
const signalStartedAt = performance.now();
|
|
const synthesis = synthesizeMicrophoneSignals({
|
|
scene,
|
|
arrayDefinition,
|
|
assetBuffers,
|
|
minimumDistance: experiment.beamforming.minimumDistance,
|
|
});
|
|
const signalGeneration = performance.now() - signalStartedAt;
|
|
post("progress", jobId, {
|
|
stage: "signal-complete",
|
|
message: `마이크 신호 합성 완료 · ${signalGeneration.toFixed(0)} ms`,
|
|
});
|
|
|
|
const localizationStartedAt = performance.now();
|
|
const localization = await computeLocalizationOrUnavailable({
|
|
channels: synthesis.channels,
|
|
sampleRate: synthesis.sampleRate,
|
|
arrayDefinition,
|
|
scene,
|
|
experiment,
|
|
onFallback: ({ error }) =>
|
|
post("fallback", jobId, {
|
|
code: error.code,
|
|
message: error.message,
|
|
}),
|
|
onProgress: (progress) => post("progress", jobId, { stage: progress.stage, progress }),
|
|
});
|
|
const localizationTime = performance.now() - localizationStartedAt;
|
|
const transfer = [];
|
|
collectBandTransfers(localization, transfer);
|
|
post(
|
|
"result",
|
|
jobId,
|
|
{
|
|
run: {
|
|
...localization,
|
|
signalStats: signalStats(synthesis),
|
|
timingMs: {
|
|
total: performance.now() - totalStartedAt,
|
|
signalGeneration,
|
|
localization: localizationTime,
|
|
beamforming: localizationTime,
|
|
},
|
|
},
|
|
},
|
|
transfer,
|
|
);
|
|
} catch (error) {
|
|
post("error", jobId, { error: serializeError(error) });
|
|
}
|
|
});
|