WebAssembly analysis API

export class Analyzer

free(): void;

[Symbol.dispose](): void;

analyze(): AnalysisResult;

buffer(audio: Float32Array): void;

initialize(sample_rate: number, block_size: number, variable_block_size: boolean): void;

constructor(model: Model, license_key: string);

reset(): void;

terminateSession(): void;

updateBearerToken(token: string): void;

export class AnalysisResult

free(): void;

[Symbol.dispose](): void;

readonly codecDegradation: number;

readonly interferingSpeech: number;

readonly noise: number;

readonly packetLoss: number;

readonly riskScore: number;

readonly speakerLoudness: number;

readonly speakerReverb: number;

import { Analyzer } from "@ai-coustics/aic-sdk-wasm";

/**
 * @param {import("@ai-coustics/aic-sdk-wasm").Model} model
 * @param {string} token
 * @param {Float32Array} audio
 */
export function analyzeWindow(model, token, audio) {
  const sampleRate = model.getOptimalSampleRate();
  const blockSize = model.getOptimalBlockSize(sampleRate);
  if (audio.length % blockSize !== 0) throw new Error("Expected complete blocks");
  const analyzer = new Analyzer(model, token);
  try {
    analyzer.initialize(sampleRate, blockSize, false);
    for (let offset = 0; offset < audio.length; offset += blockSize) {
      analyzer.buffer(audio.subarray(offset, offset + blockSize));
    }
    const result = analyzer.analyze();
    try {
      return {
        riskScore: result.riskScore,
        speakerReverb: result.speakerReverb,
        speakerLoudness: result.speakerLoudness,
        interferingSpeech: result.interferingSpeech,
        noise: result.noise,
        codecDegradation: result.codecDegradation,
        packetLoss: result.packetLoss,
      };
    } finally {
      result.free();
    }
  } finally {
    try {
      analyzer.terminateSession();
    } finally {
      analyzer.free();
    }
  }
}