micarrsim/packages/acoustics-core/propagation.js

import { dbToLinear, distance3 } from "./math.js";
import {
  addFrequencyDomainDelay,
  addFrequencyDomainPaths,
  createDelayWorkspace,
  nextPowerOfTwo,
  prepareDelaySpectrum,
} from "./fractional-delay.js";
import { buildAcousticPaths, maximumAcousticDelaySeconds } from "./environment.js";
import { renderSignal } from "./signal.js";

export function propagationDelaySeconds(sourcePosition, receiverPosition, speedOfSound) {
  return distance3(sourcePosition, receiverPosition) / speedOfSound;
}

export function sphericalAttenuation(distance, referenceDistance = 1, minimumDistance = 0.01) {
  return referenceDistance / Math.max(distance, minimumDistance);
}

export function synthesizeMicrophoneSignals(options) {
  const {
    scene,
    arrayDefinition,
    assetBuffers = new Map(),
    referenceDistance = 1,
    minimumDistance = 0.01,
    maximumBufferBytes = 512 * 1024 * 1024,
    signalOffsets,
  } = options;
  const sampleCount = Math.ceil(scene.duration * scene.sampleRate);
  const retainedBufferCount = arrayDefinition.microphones.length + scene.sources.length + 1;
  const maximumDelaySamples =
    maximumAcousticDelaySeconds({
      scene,
      arrayDefinition,
      referenceDistance,
      minimumDistance,
    }) * scene.sampleRate;
  const delayFftSize = nextPowerOfTwo(sampleCount + Math.ceil(maximumDelaySamples) + 2);
  const delayWorkingBytes = delayFftSize * Float64Array.BYTES_PER_ELEMENT * 4;
  const estimatedBufferBytes =
    retainedBufferCount * sampleCount * Float32Array.BYTES_PER_ELEMENT + delayWorkingBytes;
  if (estimatedBufferBytes > maximumBufferBytes) {
    throw new Error(
      `예상 signal buffer ${(estimatedBufferBytes / 1024 ** 2).toFixed(1)} MiB가 ` +
        `현재 한도 ${(maximumBufferBytes / 1024 ** 2).toFixed(1)} MiB를 넘습니다. duration 또는 sample rate를 줄이세요.`,
    );
  }
  const channels = arrayDefinition.microphones.map(() => new Float32Array(sampleCount));
  const sceneSampleOffset = signalOffsets?.sceneSampleOffset ?? 0;
  const renderedSources = scene.sources.map((source, sourceIndex) => ({
    definition: source,
    samples: renderSignal(source, scene, assetBuffers, 0, {
      sceneSampleOffset,
      ...(signalOffsets?.sources?.[sourceIndex] ?? {}),
    }),
  }));

  const acousticPathCounts = {};
  let acousticPathCount = 0;
  renderedSources.forEach(({ definition, samples }) => {
    const microphonePaths = arrayDefinition.microphones.map((microphone) =>
      buildAcousticPaths({
        scene,
        sourcePosition: definition.position,
        receiverPosition: microphone.position,
        sourceId: definition.id,
        receiverId: microphone.id,
        referenceDistance,
        minimumDistance,
      }),
    );
    let sourceMaximumDelaySamples = 0;
    for (const paths of microphonePaths) {
      for (const path of paths) {
        sourceMaximumDelaySamples = Math.max(
          sourceMaximumDelaySamples,
          path.delaySeconds * scene.sampleRate,
        );
      }
    }
    const spectrum = prepareDelaySpectrum(samples, sourceMaximumDelaySamples);
    const workspace = createDelayWorkspace(spectrum.fftSize);
    arrayDefinition.microphones.forEach((microphone, microphoneIndex) => {
      const paths = microphonePaths[microphoneIndex];
      for (const path of paths) {
        acousticPathCount += 1;
        acousticPathCounts[path.kind] = (acousticPathCounts[path.kind] ?? 0) + 1;
      }
      const sensitivity = dbToLinear(microphone.sensitivityDb ?? 0);
      addFrequencyDomainPaths({
        output: channels[microphoneIndex],
        spectrum,
        paths: paths.map((path) => ({
          delaySamples: path.delaySeconds * scene.sampleRate,
          gain: path.gain,
        })),
        gain: sensitivity,
        phaseOffsetDeg: microphone.phaseOffsetDeg ?? 0,
        frequencyResponse: microphone.frequencyResponse,
        sampleRate: scene.sampleRate,
        workspace,
      });
    });
  });

  if (Array.isArray(scene.ambient)) {
    scene.ambient.forEach((ambient, ambientIndex) => {
      channels.forEach((channel, microphoneIndex) => {
        const microphone = arrayDefinition.microphones[microphoneIndex];
        const seedSalt = Math.imul(ambientIndex + 1, 0x45d9f3b) ^ Math.imul(microphoneIndex + 1, 0x27d4eb2d);
        const ambientSamples = renderSignal(ambient, scene, assetBuffers, seedSalt, {
          sceneSampleOffset,
          ...(signalOffsets?.ambient?.[ambientIndex] ?? {}),
        });
        const spectrum = prepareDelaySpectrum(ambientSamples, 0);
        addFrequencyDomainDelay({
          output: channel,
          spectrum,
          delaySamples: 0,
          gain: dbToLinear(microphone.sensitivityDb ?? 0),
          phaseOffsetDeg: microphone.phaseOffsetDeg ?? 0,
          frequencyResponse: microphone.frequencyResponse,
          sampleRate: scene.sampleRate,
          workspace: createDelayWorkspace(spectrum.fftSize),
        });
      });
    });
  }

  let preNormalizationPeak = 0;
  for (const channel of channels) {
    for (const value of channel) {
      preNormalizationPeak = Math.max(preNormalizationPeak, Math.abs(value));
    }
  }
  const appliedScale =
    scene.mix?.normalization === "peak" && preNormalizationPeak > 0
      ? scene.mix.targetPeak / preNormalizationPeak
      : 1;
  let peak = 0;
  let clippedSampleCount = 0;
  for (const channel of channels) {
    for (let sampleIndex = 0; sampleIndex < channel.length; sampleIndex += 1) {
      channel[sampleIndex] *= appliedScale;
      const magnitude = Math.abs(channel[sampleIndex]);
      peak = Math.max(peak, magnitude);
      if (magnitude > 1) clippedSampleCount += 1;
    }
  }
  return {
    channels,
    sampleRate: scene.sampleRate,
    peak,
    preNormalizationPeak,
    appliedScale,
    clippedSampleCount,
    estimatedBufferBytes,
    acousticModel: scene.acoustics?.model ?? "free-field",
    acousticPathCount,
    acousticPathCounts,
  };
}