Add setMaxAlternatives

lib/src/interfaces.ts

@@ -7,20 +7,27 @@ export interface ClientMessageTerminate {
   action: "terminate";
 }
 
-export interface ClientMessageRecognizerSet {
+export interface ClientMessageRecognizerSetWords {
   action: "set";
   recognizerId: string;
   key: "words";
   value: boolean;
 }
 
+export interface ClientMessageRecognizerSetMaxAlternatives {
+  action: "set";
+  recognizerId: string;
+  key: "maxAlternatives";
+  value: number;
+}
+
 export interface ClientMessageGenericSet {
   action: "set";
   key: "logLevel";
   value: number;
 }
 
-export type ClientMessageSet = ClientMessageRecognizerSet | ClientMessageGenericSet;
+export type ClientMessageSet = ClientMessageRecognizerSetWords | ClientMessageRecognizerSetMaxAlternatives | ClientMessageGenericSet;
 
 export interface ClientMessageAudioChunk {
   action: "audioChunk";

lib/src/model.ts

@@ -178,6 +178,17 @@ export class Model extends EventTarget {
         );
       }
 
+      public setMaxAlternatives(max_alternatives: number): void {
+        model.postMessage<ClientMessageSet>(
+          {
+            action: "set",
+            recognizerId: this.id,
+            key: "maxAlternatives",
+            value: max_alternatives
+          }
+        );
+      }
+
       public acceptWaveform(buffer: AudioBuffer): void {
         if (buffer.numberOfChannels < 1) {
           throw new Error(`AudioBuffer should contain at least one channel`);

lib/src/vosk-wasm.d.ts

@@ -7,6 +7,7 @@ export declare class Recognizer {
   constructor(model: Model, sampleRate: number);
   constructor(model: Model, sampleRate: number, grammar: string);
   public SetWords(words: boolean): void;
+  public SetMaxAlternatives(max_alternatives: number): void;
   public AcceptWaveform(address: number, length: number): boolean;
   public Result(): string;
   public PartialResult(): string;

lib/src/worker.ts

@@ -17,6 +17,7 @@ export interface Recognizer {
   recognizer: VoskWasm.Recognizer;
   sampleRate: number;
   words?: boolean;
+  maxAlternatives?: number;
   grammar?: string;
 }
 export class RecognizerWorker {
@@ -215,7 +216,7 @@ export class RecognizerWorker {
     const { key } = message;
 
     switch (key) {
-      case "words":
+      case "words": {
         const { recognizerId, value } = message;
         this.logger.verbose(`Recognizer (id: ${recognizerId}): set ${key} to ${value}`);
 
@@ -227,15 +228,28 @@ export class RecognizerWorker {
         const recognizer = this.recognizers.get(recognizerId)!;
         recognizer.words = value;
         recognizer.recognizer.SetWords(value);
-        break;
-      case "logLevel":
+      } break;
+
+      case "maxAlternatives": {
+        const { recognizerId, value } = message;
+        this.logger.verbose(`Recognizer (id: ${recognizerId}): set ${key} to ${value}`);
+        if (!this.recognizers.has(recognizerId)) {
+          this.logger.warn(`Recognizer not ready, ignoring`);
+          return;
+        }
+        const recognizer = this.recognizers.get(recognizerId)!;
+        recognizer.maxAlternatives = value;
+        recognizer.recognizer.SetMaxAlternatives(value);
+      } break;
+
+      case "logLevel":{
         const level = message.value;
         this.logger.verbose(`Set ${key} to ${level}`);
         if (this.Vosk) {
           this.Vosk.SetLogLevel(level);
         }
         this.logger.setLogLevel(level);
-        break;
+      } break;
       default:
         this.logger.warn(`Unrecognized key ${key}`);
     }
@@ -256,12 +270,12 @@ export class RecognizerWorker {
     }
 
     let recognizer = this.recognizers.get(recognizerId)!;
-
+    
     if (recognizer.sampleRate !== sampleRate) {
       this.logger.warn(
         `Recognizer (id: ${recognizerId}) was created with sampleRate ${recognizer.sampleRate} but audio chunk with sampleRate ${sampleRate} was received! Recreating recognizer...`
       );
-
+      
       await this.createRecognizer({
         action: "create",
         recognizerId,
@@ -270,9 +284,14 @@ export class RecognizerWorker {
       });
 
       const newRecognizer = this.recognizers.get(recognizerId)!;
-      if (recognizer.words) {
-        newRecognizer.words = true;
-        newRecognizer.recognizer.SetWords(true);
+
+      if ('words' in recognizer) {
+        newRecognizer.words = recognizer.words;
+        newRecognizer.recognizer.SetWords(recognizer.words!);
+      }
+      if('maxAlternatives' in recognizer){
+        newRecognizer.maxAlternatives = recognizer.maxAlternatives;
+        newRecognizer.recognizer.SetMaxAlternatives(recognizer.maxAlternatives!);
       }
       recognizer = newRecognizer;
     }
@@ -294,7 +313,7 @@ export class RecognizerWorker {
       )
     ) {
       json = recognizer.recognizer.Result();
-
+      
       return {
         event: "result",
         recognizerId: recognizer.id,

src/bindings.cc

@@ -50,6 +50,11 @@ static void Recognizer_SetWords(Recognizer &self, int words) {
     self.SetWords(words);
 }
 
+static void Recognizer_SetMaxAlternatives(Recognizer &self, int max_alternatives) {
+    KALDI_VLOG(2) << "Setting max alternatives to " << max_alternatives;
+    self.SetMaxAlternatives(max_alternatives);
+}
+
 static bool Recognizer_AcceptWaveform(Recognizer &self, long jsHeapAddr, int len) {
     const float *fdata = (const float*) jsHeapAddr;
     KALDI_VLOG(3) << "AcceptWaveform received len=" << len << " 0=" << fdata[0] << " " << len-1 << "=" << fdata[len-1];
@@ -102,6 +107,7 @@ EMSCRIPTEN_BINDINGS(vosk) {
         .constructor(&makeRecognizerWithGrammar, allow_raw_pointers())
         .constructor<Model *, float>(allow_raw_pointers())
         .function("SetWords", &Recognizer_SetWords)
+        .function("SetMaxAlternatives", &Recognizer_SetMaxAlternatives)
         .function("AcceptWaveform", &Recognizer_AcceptWaveform)
         .function("Result", &Recognizer_Result)
         .function("FinalResult", &Recognizer_FinalResult)