Speaker Recognition for Web Applications using JavaScript

npm install @picovoice/eagle-web

cp ${EAGLE_PARAMS_PATH} ${PUBLIC_DIRECTORY}/${EAGLE_PARAMS}

npx pvbase64 -i ${EAGLE_PARAMS_PATH} -o ${OUTPUT_DIRECTORY}/${MODEL_NAME}.js

import base64model from '${OUTPUT_DIRECTORY}/${MODEL_NAME}.js'

const eagleModel = {
  publicPath: '${PUBLIC_DIRECTORY}/${EAGLE_PARAMS}',
  // or
  base64: base64model,
}

import { EagleProfilerWorker } from "@picovoice/eagle-web";

const eagleProfiler = await EagleProfilerWorker.create(
    "${ACCESS_KEY}",
    eagleModel
);

import {
  EagleProfilerEnrollResult,
  EagleProfilerEnrollFeedback,
} from "@picovoice/eagle-web";

function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
}

let percentage = 0;
while (percentage < 100) {
  const audioData = getAudioData(eagleProfiler.minEnrollSamples);
  const result: EagleProfilerEnrollResult = await eagleProfiler.enroll(audioData);  
  switch (result.feedback) {
    case EagleProfilerEnrollFeedback.AUDIO_OK:
    case EagleProfilerEnrollFeedback.AUDIO_TOO_SHORT:
    case EagleProfilerEnrollFeedback.UNKNOWN_SPEAKER:
    case EagleProfilerEnrollFeedback.NO_VOICE_FOUND:
    case EagleProfilerEnrollFeedback.QUALITY_ISSUE:
  }
  
  percentage = result.percentage;
}

const speakerProfile = eagleProfiler.export()

eagleProfiler.release();

import { EagleWorker } from "@picovoice/eagle-web";

const eagle = await EagleWorker.create(
    "${ACCESS_KEY}",
    eagleModel,
    speakerProfile
);

while (true) {
  const audioData = getAudioData(eagle.frameLength);
  const scores: number[] = await eagle.process(audioData);
}

eagle.release();

npm install @picovoice/web-voice-processor

import { EagleProfilerWorker, EagleWorker } from "@picovoice/eagle-web";
import { WebVoiceProcessor } from "@picovoice/web-voice-processor";

const eagleModel = { publicPath: '${PUBLIC_DIRECTORY}/${EAGLE_PARAMS}' }
const speakerProfiles = [];

// Step 1: Enrollment
let eagleProfiler = null;
const startProfiler = async () => {
  eagleProfiler = await EagleProfilerWorker.create(
    "${ACCESS_KEY}",
    eagleModel);
}

const startEnrollment = async () => {
  if (eagleProfiler === null) return;

  let audioData = [];
  const micEnrollEngine = {
    onmessage: async (event) => {
      switch (event.data.command) {
        case "process":
          audioData.push(event.data.inputFrame);
          if (audioData.length * 512 >= eagleProfiler.minEnrollSamples) {
            let result;
            const frames = new Int16Array(audioData.length * 512);
            for (let i = 0; i < audioData.length; i++) {
              frames.set(audioData[i], i * 512);
            }
            audioData = [];
            result = await eagleProfiler.enroll(frames);
            console.log(`Progress: ${result.percentage}`)
            if (result.percentage === 100) {
              await WebVoiceProcessor.unsubscribe(micEnrollEngine);
              const profile = await eagleProfiler.export();
              speakerProfiles.push(profile);
              console.log("Enrollment complete!");
            }
          }
          break;
      }
    }
  }

  await WebVoiceProcessor.subscribe(micEnrollEngine);
}

const cleanupProfiler = () => eagleProfiler.release();

// Step 2: Recognition
let eagle;
const startEagle = async () => {
  eagle = await EagleWorker.create(
    "${ACCESS_KEY}",
    eagleModel,
    speakerProfiles
  );
}

const micTestEngine = {
  onmessage: async (event: MessageEvent) => {
    switch (event.data.command) {
      case "process":
        const scores = await eagle.process(event.data.inputFrame)
        console.log(scores)
        break
    }
  }
}

const startTesting = async () => {
  await WebVoiceProcessor.subscribe(micTestEngine);
}

const stopTesting = async () => {
  await WebVoiceProcessor.unsubscribe(micTestEngine); 
}

const cleanup = () => eagle.release();