using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Vosk;
public class Model : IDisposable
{
private HandleRef handle;
internal Model(IntPtr cPtr)
{
handle = new HandleRef(this, cPtr);
}
public Model(string model_path)
: this(VoskPINVOKE.new_Model(model_path))
{
}
internal static HandleRef getCPtr(Model obj)
{
return obj?.handle ?? new HandleRef(null, IntPtr.Zero);
}
~Model()
{
Dispose(disposing: false);
}
public void Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
lock (this)
{
if (handle.Handle != IntPtr.Zero)
{
VoskPINVOKE.delete_Model(handle);
handle = new HandleRef(null, IntPtr.Zero);
}
}
}
public int vosk_model_find_word(string word)
{
return VoskPINVOKE.Model_vosk_model_find_word(handle, word);
}
}
public class SpkModel : IDisposable
{
private HandleRef handle;
internal SpkModel(IntPtr cPtr)
{
handle = new HandleRef(this, cPtr);
}
public SpkModel(string model_path)
: this(VoskPINVOKE.new_SpkModel(model_path))
{
}
internal static HandleRef getCPtr(SpkModel obj)
{
return obj?.handle ?? new HandleRef(null, IntPtr.Zero);
}
~SpkModel()
{
Dispose(disposing: false);
}
public void Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
lock (this)
{
if (handle.Handle != IntPtr.Zero)
{
VoskPINVOKE.delete_SpkModel(handle);
handle = new HandleRef(null, IntPtr.Zero);
}
}
}
}
public class Vosk
{
public static void SetLogLevel(int level)
{
VoskPINVOKE.SetLogLevel(level);
}
public static void GpuInit()
{
VoskPINVOKE.GpuInit();
}
public static void GpuThreadInit()
{
VoskPINVOKE.GpuThreadInit();
}
}
internal class VoskPINVOKE
{
static VoskPINVOKE()
{
}
[DllImport("libvosk", EntryPoint = "vosk_model_new")]
public static extern IntPtr new_Model(string jarg1);
[DllImport("libvosk", EntryPoint = "vosk_model_free")]
public static extern void delete_Model(HandleRef jarg1);
[DllImport("libvosk", EntryPoint = "vosk_model_find_word")]
public static extern int Model_vosk_model_find_word(HandleRef jarg1, string jarg2);
[DllImport("libvosk", EntryPoint = "vosk_spk_model_new")]
public static extern IntPtr new_SpkModel(string jarg1);
[DllImport("libvosk", EntryPoint = "vosk_spk_model_free")]
public static extern void delete_SpkModel(HandleRef jarg1);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_new")]
public static extern IntPtr new_VoskRecognizer(HandleRef jarg1, float jarg2);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_new_spk")]
public static extern IntPtr new_VoskRecognizerSpk(HandleRef jarg1, float jarg2, HandleRef jarg3);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_new_grm")]
public static extern IntPtr new_VoskRecognizerGrm(HandleRef jarg1, float jarg2, string jarg3);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_free")]
public static extern void delete_VoskRecognizer(HandleRef jarg1);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_set_max_alternatives")]
public static extern void VoskRecognizer_SetMaxAlternatives(HandleRef jarg1, int jarg2);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_set_words")]
public static extern void VoskRecognizer_SetWords(HandleRef jarg1, int jarg2);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_set_spk_model")]
public static extern void VoskRecognizer_SetSpkModel(HandleRef jarg1, HandleRef jarg2);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_accept_waveform")]
public static extern bool VoskRecognizer_AcceptWaveform(HandleRef jarg1, [In][MarshalAs(UnmanagedType.LPArray)] byte[] jarg2, int jarg3);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_accept_waveform_s")]
public static extern bool VoskRecognizer_AcceptWaveformShort(HandleRef jarg1, [In][MarshalAs(UnmanagedType.LPArray)] short[] jarg2, int jarg3);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_accept_waveform_f")]
public static extern bool VoskRecognizer_AcceptWaveformFloat(HandleRef jarg1, [In][MarshalAs(UnmanagedType.LPArray)] float[] jarg2, int jarg3);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_result")]
public static extern IntPtr VoskRecognizer_Result(HandleRef jarg1);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_partial_result")]
public static extern IntPtr VoskRecognizer_PartialResult(HandleRef jarg1);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_final_result")]
public static extern IntPtr VoskRecognizer_FinalResult(HandleRef jarg1);
[DllImport("libvosk", EntryPoint = "vosk_recognizer_reset")]
public static extern void VoskRecognizer_Reset(HandleRef jarg1);
[DllImport("libvosk", EntryPoint = "vosk_set_log_level")]
public static extern void SetLogLevel(int jarg1);
[DllImport("libvosk", EntryPoint = "vosk_gpu_init")]
public static extern void GpuInit();
[DllImport("libvosk", EntryPoint = "vosk_gpu_thread_init")]
public static extern void GpuThreadInit();
}
public class VoskRecognizer : IDisposable
{
private HandleRef handle;
internal VoskRecognizer(IntPtr cPtr)
{
handle = new HandleRef(this, cPtr);
}
public VoskRecognizer(Model model, float sample_rate)
: this(VoskPINVOKE.new_VoskRecognizer(Model.getCPtr(model), sample_rate))
{
}
public VoskRecognizer(Model model, float sample_rate, SpkModel spk_model)
: this(VoskPINVOKE.new_VoskRecognizerSpk(Model.getCPtr(model), sample_rate, SpkModel.getCPtr(spk_model)))
{
}
public VoskRecognizer(Model model, float sample_rate, string grammar)
: this(VoskPINVOKE.new_VoskRecognizerGrm(Model.getCPtr(model), sample_rate, grammar))
{
}
internal static HandleRef getCPtr(VoskRecognizer obj)
{
return obj?.handle ?? new HandleRef(null, IntPtr.Zero);
}
~VoskRecognizer()
{
Dispose(disposing: false);
}
public void Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
lock (this)
{
if (handle.Handle != IntPtr.Zero)
{
VoskPINVOKE.delete_VoskRecognizer(handle);
handle = new HandleRef(null, IntPtr.Zero);
}
}
}
public void SetMaxAlternatives(int max_alternatives)
{
VoskPINVOKE.VoskRecognizer_SetMaxAlternatives(handle, max_alternatives);
}
public void SetWords(bool words)
{
VoskPINVOKE.VoskRecognizer_SetWords(handle, words ? 1 : 0);
}
public void SetSpkModel(SpkModel spk_model)
{
VoskPINVOKE.VoskRecognizer_SetSpkModel(handle, SpkModel.getCPtr(spk_model));
}
public bool AcceptWaveform(byte[] data, int len)
{
return VoskPINVOKE.VoskRecognizer_AcceptWaveform(handle, data, len);
}
public bool AcceptWaveform(short[] sdata, int len)
{
return VoskPINVOKE.VoskRecognizer_AcceptWaveformShort(handle, sdata, len);
}
public bool AcceptWaveform(float[] fdata, int len)
{
return VoskPINVOKE.VoskRecognizer_AcceptWaveformFloat(handle, fdata, len);
}
private static string PtrToStringUTF8(IntPtr ptr)
{
int i;
for (i = 0; Marshal.ReadByte(ptr, i) != 0; i++)
{
}
byte[] array = new byte[i];
Marshal.Copy(ptr, array, 0, i);
return Encoding.UTF8.GetString(array);
}
public string Result()
{
return PtrToStringUTF8(VoskPINVOKE.VoskRecognizer_Result(handle));
}
public string PartialResult()
{
return PtrToStringUTF8(VoskPINVOKE.VoskRecognizer_PartialResult(handle));
}
public string FinalResult()
{
return PtrToStringUTF8(VoskPINVOKE.VoskRecognizer_FinalResult(handle));
}
public void Reset()
{
VoskPINVOKE.VoskRecognizer_Reset(handle);
}
}using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dissonance;
using Dissonance.Audio.Capture;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using NAudio.Wave;
using Newtonsoft.Json;
using SpeechRecognitionAPI.Patches;
using UnityEngine;
using Vosk;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("JS03")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+9248eb8c7794f7211b32ff17374b70fbdc2ac5fe")]
[assembly: AssemblyProduct("WhisperLC")]
[assembly: AssemblyTitle("SpeechRecognitionAPI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace SpeechRecognitionAPI
{
public class Engine : MonoBehaviour
{
[CompilerGenerated]
private sealed class <WaitForDissonance>d__10 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Engine <>4__this;
private DissonanceComms <dissonance>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForDissonance>d__10(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<dissonance>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<dissonance>5__1 = Object.FindObjectOfType<DissonanceComms>();
break;
case 1:
<>1__state = -1;
break;
}
if (!Object.op_Implicit((Object)(object)<dissonance>5__1) || <dissonance>5__1.MicrophoneCapture == null)
{
<dissonance>5__1 = Object.FindObjectOfType<DissonanceComms>();
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
}
<>4__this._micCapture = new MicrophoneCapture();
<dissonance>5__1.MicrophoneCapture.Subscribe((IMicrophoneSubscriber)(object)<>4__this._micCapture);
Plugin.mls.LogInfo((object)"Subscribed to Dissonance microphone stream");
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private string[] models = new string[2] { "vosk-model-small-en-us-0.15", "vosk-model-small-es-0.42" };
private VoskRecognizer _recognizer;
private Model _model;
private MicrophoneCapture _micCapture;
private int _micSampleRate;
public static event EventHandler<SpeechEventArgs> SpeechRecognized;
public void StartEngine()
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
Object.DontDestroyOnLoad((Object)(object)this);
string text = Path.Combine(Plugin.pluginDir, "models", models[(int)Plugin.language.Value]);
_model = new Model(text);
_recognizer = new VoskRecognizer(_model, 16000f);
Plugin.mls.LogInfo((object)"Vosk ASR ready.");
}
public void StartMicCapture()
{
((MonoBehaviour)this).StartCoroutine(WaitForDissonance());
}
[IteratorStateMachine(typeof(<WaitForDissonance>d__10))]
private IEnumerator WaitForDissonance()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForDissonance>d__10(0)
{
<>4__this = this
};
}
public void StopMicCapture()
{
DissonanceComms val = Object.FindObjectOfType<DissonanceComms>();
if ((Object)(object)val == (Object)null)
{
Plugin.mls.LogError((object)"DissonanceComms not found");
}
else
{
val.MicrophoneCapture.Unsubscribe((IMicrophoneSubscriber)(object)_micCapture);
}
}
private float[] Resample(float[] input, int inputRate, int outputRate)
{
if (inputRate == outputRate)
{
return input;
}
int num = (int)((long)input.Length * (long)outputRate / inputRate);
float[] array = new float[num];
float num2 = (float)input.Length / (float)num;
for (int i = 0; i < num; i++)
{
float num3 = (float)i * num2;
int num4 = (int)num3;
float num5 = num3 - (float)num4;
float num6 = input[num4];
float num7 = ((num4 + 1 < input.Length) ? input[num4 + 1] : num6);
array[i] = num6 + (num7 - num6) * num5;
}
return array;
}
public void ReceiveAudio(ArraySegment<float> buffer, int sampleRate)
{
float[] array = new float[buffer.Count];
if (buffer.Array == null)
{
return;
}
Array.Copy(buffer.Array, buffer.Offset, array, 0, buffer.Count);
float[] array2 = Resample(array, sampleRate, 16000);
byte[] array3 = new byte[array2.Length * 2];
for (int i = 0; i < array2.Length; i++)
{
short num = (short)(array2[i] * 32767f);
array3[i * 2] = (byte)((uint)num & 0xFFu);
array3[i * 2 + 1] = (byte)(num >> 8);
}
if (!_recognizer.AcceptWaveform(array3, array3.Length))
{
return;
}
string text = _recognizer.Result();
string text2 = JsonConvert.DeserializeObject<VoskResult>(text)?.text;
if (!string.IsNullOrEmpty(text2))
{
if (Plugin.logging.Value)
{
Plugin.mls.LogInfo((object)("Recognized: " + text2));
}
if (Speech.phrases.Count > 0)
{
Speech.GetBestMatch(text2);
}
Engine.SpeechRecognized?.Invoke(this, new SpeechEventArgs(text2));
}
}
}
public enum Languages
{
English,
Spanish
}
public class MicrophoneCapture : IMicrophoneSubscriber
{
public void ReceiveMicrophoneData(ArraySegment<float> buffer, WaveFormat format)
{
Plugin.SpeechEngine.ReceiveAudio(buffer, format.SampleRate);
}
public void Reset()
{
}
}
[BepInPlugin("JS03.SpeechRecognitionAPI", "SpeechRecognitionAPI", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
private const string modGUID = "JS03.SpeechRecognitionAPI";
private const string modName = "SpeechRecognitionAPI";
private const string modVersion = "1.0.0";
public static Engine SpeechEngine;
private static readonly string[] _libraries = new string[5] { "libgcc_s_seh-1", "libstdc++-6", "libvosk", "libwinpthread-1", "Vosk" };
internal static string? pluginDir;
private readonly Harmony harmony = new Harmony("JS03.SpeechRecognitionAPI");
public static Plugin Instance;
internal static ManualLogSource mls;
public static ConfigEntry<bool> logging;
public static ConfigEntry<Languages> language;
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr LoadLibrary(string lpFileName);
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("JS03.SpeechRecognitionAPI");
mls.LogInfo((object)"Starting SpeechRecognitionAPI");
language = ((BaseUnityPlugin)this).Config.Bind<Languages>("General", "Language", Languages.English, "Language to be used for speech recognition");
logging = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Log recognized speech", true, "Shows the speech recognition output");
Speech.phrases = new List<string>();
pluginDir = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
Environment.SetEnvironmentVariable("PATH", pluginDir + ";" + Environment.GetEnvironmentVariable("PATH"));
string[] libraries = _libraries;
foreach (string text in libraries)
{
string text2 = Path.Combine(pluginDir, text + ".dll");
if (File.Exists(text2))
{
LoadLibrary(text2);
}
else
{
mls.LogError((object)(text + ".dll not found at: " + text2));
}
}
harmony.PatchAll(typeof(GameNetworkManagerPatch));
harmony.PatchAll(typeof(StartOfRoundPatch));
}
}
public class Speech
{
internal static List<string> phrases;
public static string bestMatch;
private static double bestScore;
internal static float GetSimilarity(string phrase, string recognized)
{
if (string.IsNullOrEmpty(phrase) || string.IsNullOrEmpty(recognized))
{
return 0f;
}
int num = Math.Max(phrase.Length, recognized.Length);
if (num == 0)
{
return 1f;
}
int num2 = LevenshteinDistance(phrase, recognized);
return (float)Math.Round(1.0 - (double)num2 / (double)num, 2);
}
internal static void GetBestMatch(string recognized)
{
float num = float.MinValue;
foreach (string phrase in phrases)
{
float similarity = GetSimilarity(phrase, recognized);
if (similarity > num)
{
num = similarity;
bestMatch = phrase;
}
}
bestScore = num;
if (Plugin.logging.Value)
{
Plugin.mls.LogDebug((object)("Best match: " + bestMatch));
Plugin.mls.LogDebug((object)$"Best similarity score: {bestScore}");
}
}
public static bool IsAboveThreshold(string[] phrases, double similarityThreshold)
{
return phrases.Contains(bestMatch) && bestScore >= similarityThreshold;
}
public static void RegisterPhrases(string[] phrases)
{
Speech.phrases.AddRange(phrases);
}
public static EventHandler<SpeechEventArgs> RegisterCustomHandler(EventHandler<SpeechEventArgs> callback)
{
Engine.SpeechRecognized += callback;
return callback;
}
private static int LevenshteinDistance(string s1, string s2)
{
s1 = s1.ToLower();
s2 = s2.ToLower();
int[] array = new int[s2.Length + 1];
int[] array2 = new int[s2.Length + 1];
for (int i = 0; i <= s2.Length; i++)
{
array[i] = i;
}
for (int j = 1; j <= s1.Length; j++)
{
array2[0] = j;
for (int k = 1; k <= s2.Length; k++)
{
int num = ((s1[j - 1] != s2[k - 1]) ? 1 : 0);
array2[k] = Math.Min(Math.Min(array[k] + 1, array2[k - 1] + 1), array[k - 1] + num);
}
int[] array3 = array2;
array2 = array;
array = array3;
}
return array[s2.Length];
}
}
public class SpeechEventArgs : EventArgs
{
public string Text { get; }
public SpeechEventArgs(string text)
{
Text = text;
}
}
internal class VoskResult
{
public string text;
}
}
namespace SpeechRecognitionAPI.Patches
{
[HarmonyPatch(typeof(GameNetworkManager))]
internal class GameNetworkManagerPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void StartModel()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
if (Plugin.pluginDir == null)
{
Debug.LogError((object)"[SpeechRecognitionAPI] Plugin did not initialize correctly, skipping engine start.");
return;
}
GameObject val = new GameObject("SpeechRecognitionAPIEngine");
Plugin.SpeechEngine = val.AddComponent<Engine>();
Plugin.SpeechEngine.StartEngine();
}
[HarmonyPatch("Disconnect")]
[HarmonyPostfix]
private static void StopMicCapture()
{
Plugin.SpeechEngine.StopMicCapture();
}
}
[HarmonyPatch(typeof(StartOfRound))]
public class StartOfRoundPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void StartMicCapture()
{
Plugin.SpeechEngine.StartMicCapture();
}
}
}