using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Xiaomi Corporation")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright 2019-2023 Xiaomi Corporation")]
[assembly: AssemblyDescription("sherpa-onnx is an open-source real-time speech recognition toolkit developed\n by the Next-gen Kaldi team. It supports streaming recognition on a variety of\n platforms such as Android, iOS, Raspberry, Linux, Windows, macOS, etc.\n\n It does not require Internet connection during recognition.\n\n See the documentation https://k2-fsa.github.io/sherpa/onnx/index.html\n for details.\n ")]
[assembly: AssemblyFileVersion("1.12.23.0")]
[assembly: AssemblyInformationalVersion("1.12.23+7e227a529be6c383134a358c5744d0eb1cb5ae1f")]
[assembly: AssemblyProduct("sherpa-onnx")]
[assembly: AssemblyTitle("sherpa-onnx")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/k2-fsa/sherpa-onnx")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.12.23.0")]
[module: UnverifiableCode]
namespace SherpaOnnx;
public class AudioEvent
{
private struct Impl
{
public IntPtr Name;
public int Index;
public float Prob;
}
private string _name;
private int _index;
private float _prob;
public string Name => _name;
public int Index => _index;
public float Prob => _prob;
public unsafe AudioEvent(IntPtr handle)
{
Impl impl = (Impl)Marshal.PtrToStructure(handle, typeof(Impl));
int num = 0;
byte* ptr = (byte*)(void*)impl.Name;
while (*ptr != 0)
{
ptr++;
num++;
}
byte[] array = new byte[num];
Marshal.Copy(impl.Name, array, 0, num);
_name = Encoding.UTF8.GetString(array);
_index = impl.Index;
_prob = impl.Prob;
}
}
public class AudioTagging : IDisposable
{
private HandleRef _handle;
public AudioTagging(AudioTaggingConfig config)
{
IntPtr handle = SherpaOnnxCreateAudioTagging(ref config);
_handle = new HandleRef(this, handle);
}
public OfflineStream CreateStream()
{
return new OfflineStream(SherpaOnnxAudioTaggingCreateOfflineStream(_handle.Handle));
}
public AudioEvent[] Compute(OfflineStream stream, int topK = -1)
{
IntPtr intPtr = SherpaOnnxAudioTaggingCompute(_handle.Handle, stream.Handle, topK);
List<AudioEvent> list = new List<AudioEvent>();
if (intPtr == IntPtr.Zero)
{
return list.ToArray();
}
int num = 0;
while (true)
{
IntPtr intPtr2 = Marshal.ReadIntPtr(intPtr, num * IntPtr.Size);
if (intPtr2 == IntPtr.Zero)
{
break;
}
AudioEvent item = new AudioEvent(intPtr2);
list.Add(item);
num++;
}
SherpaOnnxAudioTaggingFreeResults(intPtr);
return list.ToArray();
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~AudioTagging()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyAudioTagging(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateAudioTagging(ref AudioTaggingConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyAudioTagging(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxAudioTaggingCreateOfflineStream(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxAudioTaggingCompute(IntPtr handle, IntPtr stream, int topK);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxAudioTaggingFreeResults(IntPtr p);
}
public struct AudioTaggingConfig
{
public AudioTaggingModelConfig Model;
[MarshalAs(UnmanagedType.LPStr)]
public string Labels;
public int TopK;
public AudioTaggingConfig()
{
Model = new AudioTaggingModelConfig();
Labels = "";
TopK = 5;
}
}
public struct AudioTaggingModelConfig
{
public OfflineZipformerAudioTaggingModelConfig Zipformer;
[MarshalAs(UnmanagedType.LPStr)]
public string CED;
public int NumThreads;
public int Debug;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
public AudioTaggingModelConfig()
{
Zipformer = new OfflineZipformerAudioTaggingModelConfig();
CED = "";
NumThreads = 1;
Debug = 0;
Provider = "cpu";
}
}
public class CircularBuffer : IDisposable
{
private HandleRef _handle;
public int Size => SherpaOnnxCircularBufferSize(_handle.Handle);
public int Head => SherpaOnnxCircularBufferHead(_handle.Handle);
public CircularBuffer(int capacity)
{
IntPtr handle = SherpaOnnxCreateCircularBuffer(capacity);
_handle = new HandleRef(this, handle);
}
public void Push(float[] data)
{
SherpaOnnxCircularBufferPush(_handle.Handle, data, data.Length);
}
public float[] Get(int startIndex, int n)
{
IntPtr intPtr = SherpaOnnxCircularBufferGet(_handle.Handle, startIndex, n);
float[] array = new float[n];
Marshal.Copy(intPtr, array, 0, n);
SherpaOnnxCircularBufferFree(intPtr);
return array;
}
public void Pop(int n)
{
SherpaOnnxCircularBufferPop(_handle.Handle, n);
}
public void Reset()
{
SherpaOnnxCircularBufferReset(_handle.Handle);
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~CircularBuffer()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyCircularBuffer(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateCircularBuffer(int capacity);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyCircularBuffer(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxCircularBufferPush(IntPtr handle, float[] p, int n);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCircularBufferGet(IntPtr handle, int startIndex, int n);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxCircularBufferFree(IntPtr p);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxCircularBufferPop(IntPtr handle, int n);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxCircularBufferSize(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxCircularBufferHead(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxCircularBufferReset(IntPtr handle);
}
public class DenoisedAudio
{
private struct Impl
{
public IntPtr Samples;
public int NumSamples;
public int SampleRate;
}
private HandleRef _handle;
public IntPtr Handle => _handle.Handle;
public int NumSamples => ((Impl)Marshal.PtrToStructure(Handle, typeof(Impl))).NumSamples;
public int SampleRate => ((Impl)Marshal.PtrToStructure(Handle, typeof(Impl))).SampleRate;
public float[] Samples
{
get
{
Impl impl = (Impl)Marshal.PtrToStructure(Handle, typeof(Impl));
float[] array = new float[impl.NumSamples];
Marshal.Copy(impl.Samples, array, 0, impl.NumSamples);
return array;
}
}
public DenoisedAudio(IntPtr p)
{
_handle = new HandleRef(this, p);
}
public bool SaveToWaveFile(string filename)
{
Impl impl = (Impl)Marshal.PtrToStructure(Handle, typeof(Impl));
byte[] bytes = Encoding.UTF8.GetBytes(filename);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return SherpaOnnxWriteWave(impl.Samples, impl.NumSamples, impl.SampleRate, array) == 1;
}
~DenoisedAudio()
{
Cleanup();
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
private void Cleanup()
{
SherpaOnnxDestroyDenoisedAudio(Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyDenoisedAudio(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxWriteWave(IntPtr samples, int n, int sample_rate, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Filename);
}
internal static class Dll
{
public const string Filename = "sherpa-onnx-c-api";
}
public struct FastClusteringConfig
{
public int NumClusters;
public float Threshold;
public FastClusteringConfig()
{
NumClusters = -1;
Threshold = 0.5f;
}
}
public struct FeatureConfig
{
public int SampleRate;
public int FeatureDim;
public FeatureConfig()
{
SampleRate = 16000;
FeatureDim = 80;
}
}
public struct HomophoneReplacerConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string DictDir;
[MarshalAs(UnmanagedType.LPStr)]
public string Lexicon;
[MarshalAs(UnmanagedType.LPStr)]
public string RuleFsts;
public HomophoneReplacerConfig()
{
DictDir = "";
Lexicon = "";
RuleFsts = "";
}
}
public class KeywordResult
{
private struct Impl
{
public IntPtr Keyword;
}
private string _keyword;
public string Keyword => _keyword;
public unsafe KeywordResult(IntPtr handle)
{
Impl impl = (Impl)Marshal.PtrToStructure(handle, typeof(Impl));
int num = 0;
byte* ptr = (byte*)(void*)impl.Keyword;
while (*ptr != 0)
{
ptr++;
num++;
}
byte[] array = new byte[num];
Marshal.Copy(impl.Keyword, array, 0, num);
_keyword = Encoding.UTF8.GetString(array);
}
}
public class KeywordSpotter : IDisposable
{
private HandleRef _handle;
public KeywordSpotter(KeywordSpotterConfig config)
{
IntPtr handle = SherpaOnnxCreateKeywordSpotter(ref config);
_handle = new HandleRef(this, handle);
}
public OnlineStream CreateStream()
{
return new OnlineStream(SherpaOnnxCreateKeywordStream(_handle.Handle));
}
public OnlineStream CreateStream(string keywords)
{
byte[] bytes = Encoding.UTF8.GetBytes(keywords);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return new OnlineStream(SherpaOnnxCreateKeywordStreamWithKeywords(_handle.Handle, array));
}
public bool IsReady(OnlineStream stream)
{
return IsReady(_handle.Handle, stream.Handle) != 0;
}
public void Decode(OnlineStream stream)
{
Decode(_handle.Handle, stream.Handle);
}
public void Reset(OnlineStream stream)
{
Reset(_handle.Handle, stream.Handle);
}
public void Decode(IEnumerable<OnlineStream> streams)
{
List<IntPtr> list = new List<IntPtr>();
foreach (OnlineStream stream in streams)
{
list.Add(stream.Handle);
}
IntPtr[] array = list.ToArray();
Decode(_handle.Handle, array, array.Length);
}
public KeywordResult GetResult(OnlineStream stream)
{
IntPtr result = GetResult(_handle.Handle, stream.Handle);
KeywordResult result2 = new KeywordResult(result);
DestroyResult(result);
return result2;
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~KeywordSpotter()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyKeywordSpotter(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateKeywordSpotter(ref KeywordSpotterConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyKeywordSpotter(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateKeywordStream(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateKeywordStreamWithKeywords(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Keywords);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxIsKeywordStreamReady")]
private static extern int IsReady(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxDecodeKeywordStream")]
private static extern void Decode(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxResetKeywordStream")]
private static extern void Reset(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxDecodeMultipleKeywordStreams")]
private static extern void Decode(IntPtr handle, IntPtr[] streams, int n);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxGetKeywordResult")]
private static extern IntPtr GetResult(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxDestroyKeywordResult")]
private static extern void DestroyResult(IntPtr result);
}
public struct KeywordSpotterConfig
{
public FeatureConfig FeatConfig;
public OnlineModelConfig ModelConfig;
public int MaxActivePaths;
public int NumTrailingBlanks;
public float KeywordsScore;
public float KeywordsThreshold;
[MarshalAs(UnmanagedType.LPStr)]
public string KeywordsFile;
[MarshalAs(UnmanagedType.LPStr)]
public string KeywordsBuf;
public int KeywordsBufSize;
public KeywordSpotterConfig()
{
FeatConfig = new FeatureConfig();
ModelConfig = new OnlineModelConfig();
MaxActivePaths = 4;
NumTrailingBlanks = 1;
KeywordsScore = 1f;
KeywordsThreshold = 0.25f;
KeywordsFile = "";
KeywordsBuf = "";
KeywordsBufSize = 0;
}
}
public struct OfflineCanaryModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Encoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Decoder;
[MarshalAs(UnmanagedType.LPStr)]
public string SrcLang;
[MarshalAs(UnmanagedType.LPStr)]
public string TgtLang;
public int UsePnc;
public OfflineCanaryModelConfig()
{
Encoder = "";
Decoder = "";
SrcLang = "en";
TgtLang = "en";
UsePnc = 1;
}
}
public struct OfflineDolphinModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineDolphinModelConfig()
{
Model = "";
}
}
public struct OfflineFireRedAsrModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Encoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Decoder;
public OfflineFireRedAsrModelConfig()
{
Encoder = "";
Decoder = "";
}
}
public struct OfflineFunAsrNanoModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string EncoderAdaptor;
[MarshalAs(UnmanagedType.LPStr)]
public string LLM;
[MarshalAs(UnmanagedType.LPStr)]
public string Embedding;
[MarshalAs(UnmanagedType.LPStr)]
public string Tokenizer;
[MarshalAs(UnmanagedType.LPStr)]
public string SystemPrompt;
[MarshalAs(UnmanagedType.LPStr)]
public string UserPrompt;
public int MaxNewTokens;
public float Temperature;
public float TopP;
public int Seed;
public OfflineFunAsrNanoModelConfig()
{
EncoderAdaptor = "";
LLM = "";
Embedding = "";
Tokenizer = "";
SystemPrompt = "You are a helpful assistant.";
UserPrompt = "语音转写：";
MaxNewTokens = 512;
Temperature = 1E-06f;
TopP = 0.8f;
Seed = 42;
}
}
public struct OfflineLMConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public float Scale;
public OfflineLMConfig()
{
Model = "";
Scale = 0.5f;
}
}
public struct OfflineMedAsrCtcModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineMedAsrCtcModelConfig()
{
Model = "";
}
}
public struct OfflineModelConfig
{
public OfflineTransducerModelConfig Transducer;
public OfflineParaformerModelConfig Paraformer;
public OfflineNemoEncDecCtcModelConfig NeMoCtc;
public OfflineWhisperModelConfig Whisper;
public OfflineTdnnModelConfig Tdnn;
[MarshalAs(UnmanagedType.LPStr)]
public string Tokens;
public int NumThreads;
public int Debug;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
[MarshalAs(UnmanagedType.LPStr)]
public string ModelType;
[MarshalAs(UnmanagedType.LPStr)]
public string ModelingUnit;
[MarshalAs(UnmanagedType.LPStr)]
public string BpeVocab;
[MarshalAs(UnmanagedType.LPStr)]
public string TeleSpeechCtc;
public OfflineSenseVoiceModelConfig SenseVoice;
public OfflineMoonshineModelConfig Moonshine;
public OfflineFireRedAsrModelConfig FireRedAsr;
public OfflineDolphinModelConfig Dolphin;
public OfflineZipformerCtcModelConfig ZipformerCtc;
public OfflineCanaryModelConfig Canary;
public OfflineWenetCtcModelConfig WenetCtc;
public OfflineOmnilingualAsrCtcModelConfig Omnilingual;
public OfflineMedAsrCtcModelConfig MedAsr;
public OfflineFunAsrNanoModelConfig FunAsrNano;
public OfflineModelConfig()
{
Transducer = new OfflineTransducerModelConfig();
Paraformer = new OfflineParaformerModelConfig();
NeMoCtc = new OfflineNemoEncDecCtcModelConfig();
Whisper = new OfflineWhisperModelConfig();
Tdnn = new OfflineTdnnModelConfig();
Tokens = "";
NumThreads = 1;
Debug = 0;
Provider = "cpu";
ModelType = "";
ModelingUnit = "cjkchar";
BpeVocab = "";
TeleSpeechCtc = "";
SenseVoice = new OfflineSenseVoiceModelConfig();
Moonshine = new OfflineMoonshineModelConfig();
FireRedAsr = new OfflineFireRedAsrModelConfig();
Dolphin = new OfflineDolphinModelConfig();
ZipformerCtc = new OfflineZipformerCtcModelConfig();
Canary = new OfflineCanaryModelConfig();
WenetCtc = new OfflineWenetCtcModelConfig();
Omnilingual = new OfflineOmnilingualAsrCtcModelConfig();
MedAsr = new OfflineMedAsrCtcModelConfig();
FunAsrNano = new OfflineFunAsrNanoModelConfig();
}
}
public struct OfflineMoonshineModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Preprocessor;
[MarshalAs(UnmanagedType.LPStr)]
public string Encoder;
[MarshalAs(UnmanagedType.LPStr)]
public string UncachedDecoder;
[MarshalAs(UnmanagedType.LPStr)]
public string CachedDecoder;
public OfflineMoonshineModelConfig()
{
Preprocessor = "";
Encoder = "";
UncachedDecoder = "";
CachedDecoder = "";
}
}
public struct OfflineNemoEncDecCtcModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineNemoEncDecCtcModelConfig()
{
Model = "";
}
}
public struct OfflineOmnilingualAsrCtcModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineOmnilingualAsrCtcModelConfig()
{
Model = "";
}
}
public struct OfflineParaformerModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineParaformerModelConfig()
{
Model = "";
}
}
public class OfflinePunctuation : IDisposable
{
private HandleRef _handle;
public OfflinePunctuation(OfflinePunctuationConfig config)
{
IntPtr handle = SherpaOnnxCreateOfflinePunctuation(ref config);
_handle = new HandleRef(this, handle);
}
public unsafe string AddPunct(string text)
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
IntPtr intPtr = SherpaOfflinePunctuationAddPunct(_handle.Handle, array);
string result = "";
int num = 0;
byte* ptr = (byte*)(void*)intPtr;
if (ptr != null)
{
while (*ptr != 0)
{
ptr++;
num++;
}
}
if (num > 0)
{
byte[] array2 = new byte[num];
Marshal.Copy(intPtr, array2, 0, num);
result = Encoding.UTF8.GetString(array2);
}
SherpaOfflinePunctuationFreeText(intPtr);
return result;
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~OfflinePunctuation()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyOfflinePunctuation(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateOfflinePunctuation(ref OfflinePunctuationConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyOfflinePunctuation(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOfflinePunctuationAddPunct(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Text);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOfflinePunctuationFreeText(IntPtr p);
}
public struct OfflinePunctuationConfig
{
public OfflinePunctuationModelConfig Model;
public OfflinePunctuationConfig()
{
Model = new OfflinePunctuationModelConfig();
}
}
public struct OfflinePunctuationModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string CtTransformer;
public int NumThreads;
public int Debug;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
public OfflinePunctuationModelConfig()
{
CtTransformer = "";
NumThreads = 1;
Debug = 0;
Provider = "cpu";
}
}
public class OfflineRecognizer : IDisposable
{
private HandleRef _handle;
public OfflineRecognizer(OfflineRecognizerConfig config)
{
IntPtr handle = SherpaOnnxCreateOfflineRecognizer(ref config);
_handle = new HandleRef(this, handle);
}
public void SetConfig(OfflineRecognizerConfig config)
{
SherpaOnnxOfflineRecognizerSetConfig(_handle.Handle, ref config);
}
public OfflineStream CreateStream()
{
return new OfflineStream(SherpaOnnxCreateOfflineStream(_handle.Handle));
}
public void Decode(OfflineStream stream)
{
Decode(_handle.Handle, stream.Handle);
}
public void Decode(IEnumerable<OfflineStream> streams)
{
List<IntPtr> list = new List<IntPtr>();
foreach (OfflineStream stream in streams)
{
list.Add(stream.Handle);
}
IntPtr[] array = list.ToArray();
Decode(_handle.Handle, array, array.Length);
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~OfflineRecognizer()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyOfflineRecognizer(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateOfflineRecognizer(ref OfflineRecognizerConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxOfflineRecognizerSetConfig(IntPtr handle, ref OfflineRecognizerConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyOfflineRecognizer(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateOfflineStream(IntPtr handle);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxDecodeOfflineStream")]
private static extern void Decode(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxDecodeMultipleOfflineStreams")]
private static extern void Decode(IntPtr handle, IntPtr[] streams, int n);
}
public struct OfflineRecognizerConfig
{
public FeatureConfig FeatConfig;
public OfflineModelConfig ModelConfig;
public OfflineLMConfig LmConfig;
[MarshalAs(UnmanagedType.LPStr)]
public string DecodingMethod;
public int MaxActivePaths;
[MarshalAs(UnmanagedType.LPStr)]
public string HotwordsFile;
public float HotwordsScore;
[MarshalAs(UnmanagedType.LPStr)]
public string RuleFsts;
[MarshalAs(UnmanagedType.LPStr)]
public string RuleFars;
public float BlankPenalty;
public HomophoneReplacerConfig Hr;
public OfflineRecognizerConfig()
{
FeatConfig = new FeatureConfig();
ModelConfig = new OfflineModelConfig();
LmConfig = new OfflineLMConfig();
DecodingMethod = "greedy_search";
MaxActivePaths = 4;
HotwordsFile = "";
HotwordsScore = 1.5f;
RuleFsts = "";
RuleFars = "";
BlankPenalty = 0f;
Hr = new HomophoneReplacerConfig();
}
}
public class OfflineRecognizerResult
{
private struct Impl
{
public IntPtr Text;
public IntPtr Timestamps;
public int Count;
public IntPtr Tokens;
public IntPtr Durations;
}
private string _text;
private string[] _tokens;
private float[] _timestamps;
private float[] _durations;
public string Text => _text;
public string[] Tokens => _tokens;
public float[] Timestamps => _timestamps;
public float[] Durations => _durations;
public unsafe OfflineRecognizerResult(IntPtr handle)
{
Impl impl = (Impl)Marshal.PtrToStructure(handle, typeof(Impl));
int num = 0;
byte* ptr = (byte*)(void*)impl.Text;
while (*ptr != 0)
{
ptr++;
num++;
}
byte[] array = new byte[num];
Marshal.Copy(impl.Text, array, 0, num);
_text = Encoding.UTF8.GetString(array);
_tokens = new string[impl.Count];
byte* ptr2 = (byte*)(void*)impl.Tokens;
for (int i = 0; i < impl.Count; i++)
{
num = 0;
byte* ptr3 = ptr2;
while (*ptr2 != 0)
{
ptr2++;
num++;
}
ptr2++;
array = new byte[num];
fixed (byte* ptr4 = array)
{
for (int j = 0; j < num; j++)
{
ptr4[j] = ptr3[j];
}
}
_tokens[i] = Encoding.UTF8.GetString(array);
}
if (impl.Timestamps != IntPtr.Zero)
{
float* ptr5 = (float*)(void*)impl.Timestamps;
_timestamps = new float[impl.Count];
fixed (float* ptr6 = _timestamps)
{
for (int k = 0; k < impl.Count; k++)
{
ptr6[k] = ptr5[k];
}
}
}
if (!(impl.Durations != IntPtr.Zero))
{
return;
}
float* ptr7 = (float*)(void*)impl.Durations;
_durations = new float[impl.Count];
fixed (float* ptr8 = _durations)
{
for (int l = 0; l < impl.Count; l++)
{
ptr8[l] = ptr7[l];
}
}
}
}
public struct OfflineSenseVoiceModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
[MarshalAs(UnmanagedType.LPStr)]
public string Language;
public int UseInverseTextNormalization;
public OfflineSenseVoiceModelConfig()
{
Model = "";
Language = "";
UseInverseTextNormalization = 0;
}
}
public delegate int OfflineSpeakerDiarizationProgressCallback(int numProcessedChunks, int numTotalChunks, IntPtr arg);
public class OfflineSpeakerDiarization : IDisposable
{
private HandleRef _handle;
public int SampleRate => SherpaOnnxOfflineSpeakerDiarizationGetSampleRate(_handle.Handle);
public OfflineSpeakerDiarization(OfflineSpeakerDiarizationConfig config)
{
IntPtr handle = SherpaOnnxCreateOfflineSpeakerDiarization(ref config);
_handle = new HandleRef(this, handle);
}
public void SetConfig(OfflineSpeakerDiarizationConfig config)
{
SherpaOnnxOfflineSpeakerDiarizationSetConfig(_handle.Handle, ref config);
}
public OfflineSpeakerDiarizationSegment[] Process(float[] samples)
{
IntPtr result = SherpaOnnxOfflineSpeakerDiarizationProcess(_handle.Handle, samples, samples.Length);
return ProcessImpl(result);
}
public OfflineSpeakerDiarizationSegment[] ProcessWithCallback(float[] samples, OfflineSpeakerDiarizationProgressCallback callback, IntPtr arg)
{
IntPtr result = SherpaOnnxOfflineSpeakerDiarizationProcessWithCallback(_handle.Handle, samples, samples.Length, callback, arg);
return ProcessImpl(result);
}
private unsafe OfflineSpeakerDiarizationSegment[] ProcessImpl(IntPtr result)
{
if (result == IntPtr.Zero)
{
return new OfflineSpeakerDiarizationSegment[0];
}
int num = SherpaOnnxOfflineSpeakerDiarizationResultGetNumSegments(result);
IntPtr intPtr = SherpaOnnxOfflineSpeakerDiarizationResultSortByStartTime(result);
OfflineSpeakerDiarizationSegment[] array = new OfflineSpeakerDiarizationSegment[num];
int num2 = 12;
for (int i = 0; i != num; i++)
{
IntPtr handle = new IntPtr((byte*)(void*)intPtr + i * num2);
array[i] = new OfflineSpeakerDiarizationSegment(handle);
}
SherpaOnnxOfflineSpeakerDiarizationDestroySegment(intPtr);
SherpaOnnxOfflineSpeakerDiarizationDestroyResult(result);
return array;
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~OfflineSpeakerDiarization()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyOfflineSpeakerDiarization(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateOfflineSpeakerDiarization(ref OfflineSpeakerDiarizationConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyOfflineSpeakerDiarization(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxOfflineSpeakerDiarizationGetSampleRate(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxOfflineSpeakerDiarizationResultGetNumSegments(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxOfflineSpeakerDiarizationProcess(IntPtr handle, float[] samples, int n);
[DllImport("sherpa-onnx-c-api", CallingConvention = CallingConvention.Cdecl)]
private static extern IntPtr SherpaOnnxOfflineSpeakerDiarizationProcessWithCallback(IntPtr handle, float[] samples, int n, OfflineSpeakerDiarizationProgressCallback callback, IntPtr arg);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxOfflineSpeakerDiarizationDestroyResult(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxOfflineSpeakerDiarizationResultSortByStartTime(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxOfflineSpeakerDiarizationDestroySegment(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxOfflineSpeakerDiarizationSetConfig(IntPtr handle, ref OfflineSpeakerDiarizationConfig config);
}
public struct OfflineSpeakerDiarizationConfig
{
public OfflineSpeakerSegmentationModelConfig Segmentation;
public SpeakerEmbeddingExtractorConfig Embedding;
public FastClusteringConfig Clustering;
public float MinDurationOn;
public float MinDurationOff;
public OfflineSpeakerDiarizationConfig()
{
Segmentation = new OfflineSpeakerSegmentationModelConfig();
Embedding = new SpeakerEmbeddingExtractorConfig();
Clustering = new FastClusteringConfig();
MinDurationOn = 0.3f;
MinDurationOff = 0.5f;
}
}
public class OfflineSpeakerDiarizationSegment
{
private struct Impl
{
public float Start;
public float End;
public int Speaker;
}
public float Start;
public float End;
public int Speaker;
public OfflineSpeakerDiarizationSegment(IntPtr handle)
{
Impl impl = (Impl)Marshal.PtrToStructure(handle, typeof(Impl));
Start = impl.Start;
End = impl.End;
Speaker = impl.Speaker;
}
}
public struct OfflineSpeakerSegmentationModelConfig
{
public OfflineSpeakerSegmentationPyannoteModelConfig Pyannote;
public int NumThreads;
public int Debug;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
public OfflineSpeakerSegmentationModelConfig()
{
Pyannote = new OfflineSpeakerSegmentationPyannoteModelConfig();
NumThreads = 1;
Debug = 0;
Provider = "cpu";
}
}
public struct OfflineSpeakerSegmentationPyannoteModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineSpeakerSegmentationPyannoteModelConfig()
{
Model = "";
}
}
public class OfflineSpeechDenoiser : IDisposable
{
private HandleRef _handle;
public int SampleRate => SherpaOnnxOfflineSpeechDenoiserGetSampleRate(_handle.Handle);
public OfflineSpeechDenoiser(OfflineSpeechDenoiserConfig config)
{
IntPtr handle = SherpaOnnxCreateOfflineSpeechDenoiser(ref config);
_handle = new HandleRef(this, handle);
}
public DenoisedAudio Run(float[] samples, int sampleRate)
{
return new DenoisedAudio(SherpaOnnxOfflineSpeechDenoiserRun(_handle.Handle, samples, samples.Length, sampleRate));
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~OfflineSpeechDenoiser()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyOfflineSpeechDenoiser(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateOfflineSpeechDenoiser(ref OfflineSpeechDenoiserConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyOfflineSpeechDenoiser(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxOfflineSpeechDenoiserGetSampleRate(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxOfflineSpeechDenoiserRun(IntPtr handle, float[] samples, int n, int sampleRate);
}
public struct OfflineSpeechDenoiserConfig
{
public OfflineSpeechDenoiserModelConfig Model;
public OfflineSpeechDenoiserConfig()
{
Model = new OfflineSpeechDenoiserModelConfig();
}
}
public struct OfflineSpeechDenoiserGtcrnModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineSpeechDenoiserGtcrnModelConfig()
{
Model = "";
}
}
public struct OfflineSpeechDenoiserModelConfig
{
public OfflineSpeechDenoiserGtcrnModelConfig Gtcrn;
public int NumThreads;
public int Debug;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
public OfflineSpeechDenoiserModelConfig()
{
Gtcrn = new OfflineSpeechDenoiserGtcrnModelConfig();
NumThreads = 1;
Debug = 0;
Provider = "cpu";
}
}
public class OfflineStream : IDisposable
{
private HandleRef _handle;
public OfflineRecognizerResult Result
{
get
{
IntPtr result = GetResult(_handle.Handle);
OfflineRecognizerResult result2 = new OfflineRecognizerResult(result);
DestroyResult(result);
return result2;
}
}
public IntPtr Handle => _handle.Handle;
public OfflineStream(IntPtr p)
{
_handle = new HandleRef(this, p);
}
public void AcceptWaveform(int sampleRate, float[] samples)
{
AcceptWaveform(Handle, sampleRate, samples, samples.Length);
}
~OfflineStream()
{
Cleanup();
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
private void Cleanup()
{
SherpaOnnxDestroyOfflineStream(Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyOfflineStream(IntPtr handle);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxAcceptWaveformOffline")]
private static extern void AcceptWaveform(IntPtr handle, int sampleRate, float[] samples, int n);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxGetOfflineStreamResult")]
private static extern IntPtr GetResult(IntPtr handle);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxDestroyOfflineRecognizerResult")]
private static extern void DestroyResult(IntPtr handle);
}
public struct OfflineTdnnModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineTdnnModelConfig()
{
Model = "";
}
}
public struct OfflineTransducerModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Encoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Decoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Joiner;
public OfflineTransducerModelConfig()
{
Encoder = "";
Decoder = "";
Joiner = "";
}
}
public delegate int OfflineTtsCallback(IntPtr samples, int n);
public delegate int OfflineTtsCallbackProgress(IntPtr samples, int n, float progress);
public class OfflineTts : IDisposable
{
private HandleRef _handle;
public int SampleRate => SherpaOnnxOfflineTtsSampleRate(_handle.Handle);
public int NumSpeakers => SherpaOnnxOfflineTtsNumSpeakers(_handle.Handle);
public OfflineTts(OfflineTtsConfig config)
{
IntPtr handle = SherpaOnnxCreateOfflineTts(ref config);
_handle = new HandleRef(this, handle);
}
public OfflineTtsGeneratedAudio Generate(string text, float speed, int speakerId)
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return new OfflineTtsGeneratedAudio(SherpaOnnxOfflineTtsGenerate(_handle.Handle, array, speakerId, speed));
}
public OfflineTtsGeneratedAudio GenerateWithCallback(string text, float speed, int speakerId, OfflineTtsCallback callback)
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return new OfflineTtsGeneratedAudio(SherpaOnnxOfflineTtsGenerateWithCallback(_handle.Handle, array, speakerId, speed, callback));
}
public OfflineTtsGeneratedAudio GenerateWithCallbackProgress(string text, float speed, int speakerId, OfflineTtsCallbackProgress callback)
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return new OfflineTtsGeneratedAudio(SherpaOnnxOfflineTtsGenerateWithProgressCallback(_handle.Handle, array, speakerId, speed, callback));
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~OfflineTts()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyOfflineTts(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateOfflineTts(ref OfflineTtsConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyOfflineTts(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxOfflineTtsSampleRate(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxOfflineTtsNumSpeakers(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxOfflineTtsGenerate(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Text, int sid, float speed);
[DllImport("sherpa-onnx-c-api", CallingConvention = CallingConvention.Cdecl)]
private static extern IntPtr SherpaOnnxOfflineTtsGenerateWithCallback(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Text, int sid, float speed, OfflineTtsCallback callback);
[DllImport("sherpa-onnx-c-api", CallingConvention = CallingConvention.Cdecl)]
private static extern IntPtr SherpaOnnxOfflineTtsGenerateWithProgressCallback(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Text, int sid, float speed, OfflineTtsCallbackProgress callback);
}
public struct OfflineTtsConfig
{
public OfflineTtsModelConfig Model;
[MarshalAs(UnmanagedType.LPStr)]
public string RuleFsts;
public int MaxNumSentences;
[MarshalAs(UnmanagedType.LPStr)]
public string RuleFars;
public float SilenceScale;
public OfflineTtsConfig()
{
Model = new OfflineTtsModelConfig();
RuleFsts = "";
MaxNumSentences = 1;
RuleFars = "";
SilenceScale = 0.2f;
}
}
public class OfflineTtsGeneratedAudio
{
private struct Impl
{
public IntPtr Samples;
public int NumSamples;
public int SampleRate;
}
private HandleRef _handle;
public IntPtr Handle => _handle.Handle;
public int NumSamples => ((Impl)Marshal.PtrToStructure(Handle, typeof(Impl))).NumSamples;
public int SampleRate => ((Impl)Marshal.PtrToStructure(Handle, typeof(Impl))).SampleRate;
public float[] Samples
{
get
{
Impl impl = (Impl)Marshal.PtrToStructure(Handle, typeof(Impl));
float[] array = new float[impl.NumSamples];
Marshal.Copy(impl.Samples, array, 0, impl.NumSamples);
return array;
}
}
public OfflineTtsGeneratedAudio(IntPtr p)
{
_handle = new HandleRef(this, p);
}
public bool SaveToWaveFile(string filename)
{
Impl impl = (Impl)Marshal.PtrToStructure(Handle, typeof(Impl));
byte[] bytes = Encoding.UTF8.GetBytes(filename);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return SherpaOnnxWriteWave(impl.Samples, impl.NumSamples, impl.SampleRate, array) == 1;
}
~OfflineTtsGeneratedAudio()
{
Cleanup();
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
private void Cleanup()
{
SherpaOnnxDestroyOfflineTtsGeneratedAudio(Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyOfflineTtsGeneratedAudio(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxWriteWave(IntPtr samples, int n, int sample_rate, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Filename);
}
public struct OfflineTtsKittenModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
[MarshalAs(UnmanagedType.LPStr)]
public string Voices;
[MarshalAs(UnmanagedType.LPStr)]
public string Tokens;
[MarshalAs(UnmanagedType.LPStr)]
public string DataDir;
public float LengthScale;
public OfflineTtsKittenModelConfig()
{
Model = "";
Voices = "";
Tokens = "";
DataDir = "";
LengthScale = 1f;
}
}
public struct OfflineTtsKokoroModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
[MarshalAs(UnmanagedType.LPStr)]
public string Voices;
[MarshalAs(UnmanagedType.LPStr)]
public string Tokens;
[MarshalAs(UnmanagedType.LPStr)]
public string DataDir;
public float LengthScale;
[MarshalAs(UnmanagedType.LPStr)]
public string DictDir;
[MarshalAs(UnmanagedType.LPStr)]
public string Lexicon;
[MarshalAs(UnmanagedType.LPStr)]
public string Lang;
public OfflineTtsKokoroModelConfig()
{
Model = "";
Voices = "";
Tokens = "";
DataDir = "";
LengthScale = 1f;
DictDir = "";
Lexicon = "";
Lang = "";
}
}
public struct OfflineTtsMatchaModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string AcousticModel;
[MarshalAs(UnmanagedType.LPStr)]
public string Vocoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Lexicon;
[MarshalAs(UnmanagedType.LPStr)]
public string Tokens;
[MarshalAs(UnmanagedType.LPStr)]
public string DataDir;
public float NoiseScale;
public float LengthScale;
[MarshalAs(UnmanagedType.LPStr)]
public string DictDir;
public OfflineTtsMatchaModelConfig()
{
AcousticModel = "";
Vocoder = "";
Lexicon = "";
Tokens = "";
DataDir = "";
NoiseScale = 0.667f;
LengthScale = 1f;
DictDir = "";
}
}
public struct OfflineTtsModelConfig
{
public OfflineTtsVitsModelConfig Vits;
public int NumThreads;
public int Debug;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
public OfflineTtsMatchaModelConfig Matcha;
public OfflineTtsKokoroModelConfig Kokoro;
public OfflineTtsKittenModelConfig Kitten;
public OfflineTtsZipVoiceModelConfig ZipVoice;
public OfflineTtsModelConfig()
{
Vits = new OfflineTtsVitsModelConfig();
Matcha = new OfflineTtsMatchaModelConfig();
Kokoro = new OfflineTtsKokoroModelConfig();
Kitten = new OfflineTtsKittenModelConfig();
ZipVoice = new OfflineTtsZipVoiceModelConfig();
NumThreads = 1;
Debug = 0;
Provider = "cpu";
}
}
public struct OfflineTtsVitsModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
[MarshalAs(UnmanagedType.LPStr)]
public string Lexicon;
[MarshalAs(UnmanagedType.LPStr)]
public string Tokens;
[MarshalAs(UnmanagedType.LPStr)]
public string DataDir;
public float NoiseScale;
public float NoiseScaleW;
public float LengthScale;
[MarshalAs(UnmanagedType.LPStr)]
public string DictDir;
public OfflineTtsVitsModelConfig()
{
Model = "";
Lexicon = "";
Tokens = "";
DataDir = "";
NoiseScale = 0.667f;
NoiseScaleW = 0.8f;
LengthScale = 1f;
DictDir = "";
}
}
public struct OfflineTtsZipVoiceModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Tokens;
[MarshalAs(UnmanagedType.LPStr)]
public string Encoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Decoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Vocoder;
[MarshalAs(UnmanagedType.LPStr)]
public string DataDir;
[MarshalAs(UnmanagedType.LPStr)]
public string Lexicon;
public float FeatScale;
public float Tshift;
public float TargetRms;
public float GuidanceScale;
public OfflineTtsZipVoiceModelConfig()
{
Tokens = "";
Encoder = "";
Decoder = "";
Vocoder = "";
DataDir = "";
Lexicon = "";
FeatScale = 0.1f;
Tshift = 0.5f;
TargetRms = 0.1f;
GuidanceScale = 1f;
}
}
public struct OfflineWenetCtcModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineWenetCtcModelConfig()
{
Model = "";
}
}
public struct OfflineWhisperModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Encoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Decoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Language;
[MarshalAs(UnmanagedType.LPStr)]
public string Task;
public int TailPaddings;
public OfflineWhisperModelConfig()
{
Encoder = "";
Decoder = "";
Language = "";
Task = "transcribe";
TailPaddings = -1;
}
}
public struct OfflineZipformerAudioTaggingModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineZipformerAudioTaggingModelConfig()
{
Model = "";
}
}
public struct OfflineZipformerCtcModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OfflineZipformerCtcModelConfig()
{
Model = "";
}
}
public struct OnlineCtcFstDecoderConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Graph;
public int MaxActive;
public OnlineCtcFstDecoderConfig()
{
Graph = "";
MaxActive = 3000;
}
}
public struct OnlineModelConfig
{
public OnlineTransducerModelConfig Transducer;
public OnlineParaformerModelConfig Paraformer;
public OnlineZipformer2CtcModelConfig Zipformer2Ctc;
[MarshalAs(UnmanagedType.LPStr)]
public string Tokens;
public int NumThreads;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
public int Debug;
[MarshalAs(UnmanagedType.LPStr)]
public string ModelType;
[MarshalAs(UnmanagedType.LPStr)]
public string ModelingUnit;
[MarshalAs(UnmanagedType.LPStr)]
public string BpeVocab;
[MarshalAs(UnmanagedType.LPStr)]
public string TokensBuf;
public int TokensBufSize;
public OnlineNemoCtcModelConfig NemoCtc;
public OnlineToneCtcModelConfig ToneCtc;
public OnlineModelConfig()
{
Transducer = new OnlineTransducerModelConfig();
Paraformer = new OnlineParaformerModelConfig();
Zipformer2Ctc = new OnlineZipformer2CtcModelConfig();
Tokens = "";
NumThreads = 1;
Provider = "cpu";
Debug = 0;
ModelType = "";
ModelingUnit = "cjkchar";
BpeVocab = "";
TokensBuf = "";
TokensBufSize = 0;
NemoCtc = new OnlineNemoCtcModelConfig();
ToneCtc = new OnlineToneCtcModelConfig();
}
}
public struct OnlineNemoCtcModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OnlineNemoCtcModelConfig()
{
Model = "";
}
}
public struct OnlineParaformerModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Encoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Decoder;
public OnlineParaformerModelConfig()
{
Encoder = "";
Decoder = "";
}
}
public class OnlineRecognizer : IDisposable
{
private HandleRef _handle;
public OnlineRecognizer(OnlineRecognizerConfig config)
{
IntPtr handle = SherpaOnnxCreateOnlineRecognizer(ref config);
_handle = new HandleRef(this, handle);
}
public OnlineStream CreateStream()
{
return new OnlineStream(SherpaOnnxCreateOnlineStream(_handle.Handle));
}
public bool IsReady(OnlineStream stream)
{
return IsReady(_handle.Handle, stream.Handle) != 0;
}
public bool IsEndpoint(OnlineStream stream)
{
return SherpaOnnxOnlineStreamIsEndpoint(_handle.Handle, stream.Handle) != 0;
}
public void Decode(OnlineStream stream)
{
Decode(_handle.Handle, stream.Handle);
}
public void Decode(IEnumerable<OnlineStream> streams)
{
List<IntPtr> list = new List<IntPtr>();
foreach (OnlineStream stream in streams)
{
list.Add(stream.Handle);
}
IntPtr[] array = list.ToArray();
Decode(_handle.Handle, array, array.Length);
}
public OnlineRecognizerResult GetResult(OnlineStream stream)
{
IntPtr result = GetResult(_handle.Handle, stream.Handle);
OnlineRecognizerResult result2 = new OnlineRecognizerResult(result);
DestroyResult(result);
return result2;
}
public void Reset(OnlineStream stream)
{
SherpaOnnxOnlineStreamReset(_handle.Handle, stream.Handle);
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~OnlineRecognizer()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyOnlineRecognizer(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateOnlineRecognizer(ref OnlineRecognizerConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyOnlineRecognizer(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateOnlineStream(IntPtr handle);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxIsOnlineStreamReady")]
private static extern int IsReady(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxDecodeOnlineStream")]
private static extern void Decode(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxDecodeMultipleOnlineStreams")]
private static extern void Decode(IntPtr handle, IntPtr[] streams, int n);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxGetOnlineStreamResult")]
private static extern IntPtr GetResult(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api", EntryPoint = "SherpaOnnxDestroyOnlineRecognizerResult")]
private static extern void DestroyResult(IntPtr result);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxOnlineStreamReset(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxOnlineStreamIsEndpoint(IntPtr handle, IntPtr stream);
}
public struct OnlineRecognizerConfig
{
public FeatureConfig FeatConfig;
public OnlineModelConfig ModelConfig;
[MarshalAs(UnmanagedType.LPStr)]
public string DecodingMethod;
public int MaxActivePaths;
public int EnableEndpoint;
public float Rule1MinTrailingSilence;
public float Rule2MinTrailingSilence;
public float Rule3MinUtteranceLength;
[MarshalAs(UnmanagedType.LPStr)]
public string HotwordsFile;
public float HotwordsScore;
public OnlineCtcFstDecoderConfig CtcFstDecoderConfig;
[MarshalAs(UnmanagedType.LPStr)]
public string RuleFsts;
[MarshalAs(UnmanagedType.LPStr)]
public string RuleFars;
public float BlankPenalty;
[MarshalAs(UnmanagedType.LPStr)]
public string HotwordsBuf;
public int HotwordsBufSize;
public HomophoneReplacerConfig Hr;
public OnlineRecognizerConfig()
{
FeatConfig = new FeatureConfig();
ModelConfig = new OnlineModelConfig();
DecodingMethod = "greedy_search";
MaxActivePaths = 4;
EnableEndpoint = 0;
Rule1MinTrailingSilence = 1.2f;
Rule2MinTrailingSilence = 2.4f;
Rule3MinUtteranceLength = 20f;
HotwordsFile = "";
HotwordsScore = 1.5f;
CtcFstDecoderConfig = new OnlineCtcFstDecoderConfig();
RuleFsts = "";
RuleFars = "";
BlankPenalty = 0f;
HotwordsBuf = "";
HotwordsBufSize = 0;
Hr = new HomophoneReplacerConfig();
}
}
public class OnlineRecognizerResult
{
private struct Impl
{
public IntPtr Text;
public IntPtr Tokens;
public IntPtr TokensArr;
public IntPtr Timestamps;
public int Count;
}
private string _text;
private string[] _tokens;
private float[] _timestamps;
public string Text => _text;
public string[] Tokens => _tokens;
public float[] Timestamps => _timestamps;
public unsafe OnlineRecognizerResult(IntPtr handle)
{
Impl impl = (Impl)Marshal.PtrToStructure(handle, typeof(Impl));
int num = 0;
byte* ptr = (byte*)(void*)impl.Text;
while (*ptr != 0)
{
ptr++;
num++;
}
byte[] array = new byte[num];
Marshal.Copy(impl.Text, array, 0, num);
_text = Encoding.UTF8.GetString(array);
_tokens = new string[impl.Count];
byte* ptr2 = (byte*)(void*)impl.Tokens;
for (int i = 0; i < impl.Count; i++)
{
num = 0;
byte* ptr3 = ptr2;
while (*ptr2 != 0)
{
ptr2++;
num++;
}
ptr2++;
array = new byte[num];
fixed (byte* ptr4 = array)
{
for (int j = 0; j < num; j++)
{
ptr4[j] = ptr3[j];
}
}
_tokens[i] = Encoding.UTF8.GetString(array);
}
float* ptr5 = (float*)(void*)impl.Timestamps;
if (ptr5 != null)
{
_timestamps = new float[impl.Count];
fixed (float* ptr6 = _timestamps)
{
for (int k = 0; k < impl.Count; k++)
{
ptr6[k] = ptr5[k];
}
}
}
else
{
_timestamps = new float[0];
}
}
}
public class OnlineStream : IDisposable
{
private HandleRef _handle;
public IntPtr Handle => _handle.Handle;
public OnlineStream(IntPtr p)
{
_handle = new HandleRef(this, p);
}
public void AcceptWaveform(int sampleRate, float[] samples)
{
SherpaOnnxOnlineStreamAcceptWaveform(Handle, sampleRate, samples, samples.Length);
}
public void InputFinished()
{
SherpaOnnxOnlineStreamInputFinished(Handle);
}
~OnlineStream()
{
Cleanup();
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
private void Cleanup()
{
SherpaOnnxDestroyOnlineStream(Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyOnlineStream(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxOnlineStreamAcceptWaveform(IntPtr handle, int sampleRate, float[] samples, int n);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxOnlineStreamInputFinished(IntPtr handle);
}
public struct OnlineToneCtcModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OnlineToneCtcModelConfig()
{
Model = "";
}
}
public struct OnlineTransducerModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Encoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Decoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Joiner;
public OnlineTransducerModelConfig()
{
Encoder = "";
Decoder = "";
Joiner = "";
}
}
public struct OnlineZipformer2CtcModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public OnlineZipformer2CtcModelConfig()
{
Model = "";
}
}
public struct SileroVadModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public float Threshold;
public float MinSilenceDuration;
public float MinSpeechDuration;
public int WindowSize;
public float MaxSpeechDuration;
public SileroVadModelConfig()
{
Model = "";
Threshold = 0.5f;
MinSilenceDuration = 0.5f;
MinSpeechDuration = 0.25f;
WindowSize = 512;
MaxSpeechDuration = 5f;
}
}
public class SpeakerEmbeddingExtractor : IDisposable
{
private HandleRef _handle;
public int Dim => SherpaOnnxSpeakerEmbeddingExtractorDim(_handle.Handle);
public SpeakerEmbeddingExtractor(SpeakerEmbeddingExtractorConfig config)
{
IntPtr handle = SherpaOnnxCreateSpeakerEmbeddingExtractor(ref config);
_handle = new HandleRef(this, handle);
}
public OnlineStream CreateStream()
{
return new OnlineStream(SherpaOnnxSpeakerEmbeddingExtractorCreateStream(_handle.Handle));
}
public bool IsReady(OnlineStream stream)
{
return SherpaOnnxSpeakerEmbeddingExtractorIsReady(_handle.Handle, stream.Handle) != 0;
}
public float[] Compute(OnlineStream stream)
{
IntPtr intPtr = SherpaOnnxSpeakerEmbeddingExtractorComputeEmbedding(_handle.Handle, stream.Handle);
int dim = Dim;
float[] array = new float[dim];
Marshal.Copy(intPtr, array, 0, dim);
SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(intPtr);
return array;
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~SpeakerEmbeddingExtractor()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroySpeakerEmbeddingExtractor(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateSpeakerEmbeddingExtractor(ref SpeakerEmbeddingExtractorConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroySpeakerEmbeddingExtractor(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxSpeakerEmbeddingExtractorDim(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxSpeakerEmbeddingExtractorCreateStream(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxSpeakerEmbeddingExtractorIsReady(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxSpeakerEmbeddingExtractorComputeEmbedding(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(IntPtr p);
}
public struct SpeakerEmbeddingExtractorConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public int NumThreads;
public int Debug;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
public SpeakerEmbeddingExtractorConfig()
{
Model = "";
NumThreads = 1;
Debug = 0;
Provider = "cpu";
}
}
public class SpeakerEmbeddingManager : IDisposable
{
private HandleRef _handle;
private int _dim;
public int NumSpeakers => SherpaOnnxSpeakerEmbeddingManagerNumSpeakers(_handle.Handle);
public SpeakerEmbeddingManager(int dim)
{
IntPtr handle = SherpaOnnxCreateSpeakerEmbeddingManager(dim);
_handle = new HandleRef(this, handle);
_dim = dim;
}
public bool Add(string name, float[] v)
{
byte[] bytes = Encoding.UTF8.GetBytes(name);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return SherpaOnnxSpeakerEmbeddingManagerAdd(_handle.Handle, array, v) == 1;
}
public bool Add(string name, ICollection<float[]> v_list)
{
int count = v_list.Count;
float[] array = new float[count * _dim];
int num = 0;
foreach (float[] item in v_list)
{
item.CopyTo(array, num);
num += _dim;
}
byte[] bytes = Encoding.UTF8.GetBytes(name);
byte[] array2 = new byte[bytes.Length + 1];
Array.Copy(bytes, array2, bytes.Length);
array2[bytes.Length] = 0;
return SherpaOnnxSpeakerEmbeddingManagerAddListFlattened(_handle.Handle, array2, array, count) == 1;
}
public bool Remove(string name)
{
byte[] bytes = Encoding.UTF8.GetBytes(name);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return SherpaOnnxSpeakerEmbeddingManagerRemove(_handle.Handle, array) == 1;
}
public unsafe string Search(float[] v, float threshold)
{
IntPtr intPtr = SherpaOnnxSpeakerEmbeddingManagerSearch(_handle.Handle, v, threshold);
string result = "";
int num = 0;
byte* ptr = (byte*)(void*)intPtr;
if (ptr != null)
{
while (*ptr != 0)
{
ptr++;
num++;
}
}
if (num > 0)
{
byte[] array = new byte[num];
Marshal.Copy(intPtr, array, 0, num);
result = Encoding.UTF8.GetString(array);
}
SherpaOnnxSpeakerEmbeddingManagerFreeSearch(intPtr);
return result;
}
public bool Verify(string name, float[] v, float threshold)
{
byte[] bytes = Encoding.UTF8.GetBytes(name);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return SherpaOnnxSpeakerEmbeddingManagerVerify(_handle.Handle, array, v, threshold) == 1;
}
public bool Contains(string name)
{
byte[] bytes = Encoding.UTF8.GetBytes(name);
byte[] array = new byte[bytes.Length + 1];
Array.Copy(bytes, array, bytes.Length);
array[bytes.Length] = 0;
return SherpaOnnxSpeakerEmbeddingManagerContains(_handle.Handle, array) == 1;
}
public unsafe string[] GetAllSpeakers()
{
if (NumSpeakers == 0)
{
return new string[0];
}
IntPtr intPtr = SherpaOnnxSpeakerEmbeddingManagerGetAllSpeakers(_handle.Handle);
string[] array = new string[NumSpeakers];
byte** ptr = (byte**)(void*)intPtr;
for (int i = 0; i != NumSpeakers; i++)
{
int num = 0;
byte* ptr2 = ptr[i];
while (*ptr2 != 0)
{
ptr2++;
num++;
}
byte[] array2 = new byte[num];
Marshal.Copy((IntPtr)ptr[i], array2, 0, num);
array[i] = Encoding.UTF8.GetString(array2);
}
SherpaOnnxSpeakerEmbeddingManagerFreeAllSpeakers(intPtr);
return array;
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~SpeakerEmbeddingManager()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroySpeakerEmbeddingManager(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateSpeakerEmbeddingManager(int dim);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroySpeakerEmbeddingManager(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxSpeakerEmbeddingManagerAdd(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Name, float[] v);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxSpeakerEmbeddingManagerAddListFlattened(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Name, float[] v, int n);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxSpeakerEmbeddingManagerRemove(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Name);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxSpeakerEmbeddingManagerSearch(IntPtr handle, float[] v, float threshold);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxSpeakerEmbeddingManagerFreeSearch(IntPtr p);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxSpeakerEmbeddingManagerVerify(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Name, float[] v, float threshold);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxSpeakerEmbeddingManagerContains(IntPtr handle, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] byte[] utf8Name);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxSpeakerEmbeddingManagerNumSpeakers(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxSpeakerEmbeddingManagerGetAllSpeakers(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxSpeakerEmbeddingManagerFreeAllSpeakers(IntPtr names);
}
public class SpeechSegment
{
private struct Impl
{
public int Start;
public IntPtr Samples;
public int Count;
}
public int _start;
private float[] _samples;
public int Start => _start;
public float[] Samples => _samples;
public unsafe SpeechSegment(IntPtr handle)
{
Impl impl = (Impl)Marshal.PtrToStructure(handle, typeof(Impl));
_start = impl.Start;
float* ptr = (float*)(void*)impl.Samples;
_samples = new float[impl.Count];
fixed (float* ptr2 = _samples)
{
for (int i = 0; i < impl.Count; i++)
{
ptr2[i] = ptr[i];
}
}
}
}
public class SpokenLanguageIdentification : IDisposable
{
private HandleRef _handle;
public SpokenLanguageIdentification(SpokenLanguageIdentificationConfig config)
{
IntPtr handle = SherpaOnnxCreateSpokenLanguageIdentification(ref config);
_handle = new HandleRef(this, handle);
}
public OfflineStream CreateStream()
{
return new OfflineStream(SherpaOnnxSpokenLanguageIdentificationCreateOfflineStream(_handle.Handle));
}
public SpokenLanguageIdentificationResult Compute(OfflineStream stream)
{
IntPtr handle = SherpaOnnxSpokenLanguageIdentificationCompute(_handle.Handle, stream.Handle);
SpokenLanguageIdentificationResult result = new SpokenLanguageIdentificationResult(handle);
SherpaOnnxDestroySpokenLanguageIdentificationResult(handle);
return result;
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~SpokenLanguageIdentification()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroySpokenLanguageIdentification(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateSpokenLanguageIdentification(ref SpokenLanguageIdentificationConfig config);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroySpokenLanguageIdentification(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxSpokenLanguageIdentificationCreateOfflineStream(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxSpokenLanguageIdentificationCompute(IntPtr handle, IntPtr stream);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroySpokenLanguageIdentificationResult(IntPtr handle);
}
public struct SpokenLanguageIdentificationConfig
{
public SpokenLanguageIdentificationWhisperConfig Whisper;
public int NumThreads;
public int Debug;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
public SpokenLanguageIdentificationConfig()
{
Whisper = new SpokenLanguageIdentificationWhisperConfig();
NumThreads = 1;
Debug = 0;
Provider = "cpu";
}
}
public class SpokenLanguageIdentificationResult
{
private struct Impl
{
public IntPtr Lang;
}
private string _lang;
public string Lang => _lang;
public unsafe SpokenLanguageIdentificationResult(IntPtr handle)
{
Impl impl = (Impl)Marshal.PtrToStructure(handle, typeof(Impl));
int num = 0;
byte* ptr = (byte*)(void*)impl.Lang;
while (*ptr != 0)
{
ptr++;
num++;
}
byte[] array = new byte[num];
Marshal.Copy(impl.Lang, array, 0, num);
_lang = Encoding.UTF8.GetString(array);
}
}
public struct SpokenLanguageIdentificationWhisperConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Encoder;
[MarshalAs(UnmanagedType.LPStr)]
public string Decoder;
public int TailPaddings;
public SpokenLanguageIdentificationWhisperConfig()
{
Encoder = "";
Decoder = "";
TailPaddings = -1;
}
}
public struct TenVadModelConfig
{
[MarshalAs(UnmanagedType.LPStr)]
public string Model;
public float Threshold;
public float MinSilenceDuration;
public float MinSpeechDuration;
public int WindowSize;
public float MaxSpeechDuration;
public TenVadModelConfig()
{
Model = "";
Threshold = 0.5f;
MinSilenceDuration = 0.5f;
MinSpeechDuration = 0.25f;
WindowSize = 256;
MaxSpeechDuration = 5f;
}
}
public struct VadModelConfig
{
public SileroVadModelConfig SileroVad;
public int SampleRate;
public int NumThreads;
[MarshalAs(UnmanagedType.LPStr)]
public string Provider;
public int Debug;
public TenVadModelConfig TenVad;
public VadModelConfig()
{
SileroVad = new SileroVadModelConfig();
SampleRate = 16000;
NumThreads = 1;
Provider = "cpu";
Debug = 0;
TenVad = new TenVadModelConfig();
}
}
public class VersionInfo
{
public unsafe static string Version
{
get
{
IntPtr intPtr = SherpaOnnxGetVersionStr();
string result = "";
int num = 0;
byte* ptr = (byte*)(void*)intPtr;
if (ptr != null)
{
while (*ptr != 0)
{
ptr++;
num++;
}
}
if (num > 0)
{
byte[] array = new byte[num];
Marshal.Copy(intPtr, array, 0, num);
result = Encoding.UTF8.GetString(array);
}
return result;
}
}
public unsafe static string GitSha1
{
get
{
IntPtr intPtr = SherpaOnnxGetGitSha1();
string result = "";
int num = 0;
byte* ptr = (byte*)(void*)intPtr;
if (ptr != null)
{
while (*ptr != 0)
{
ptr++;
num++;
}
}
if (num > 0)
{
byte[] array = new byte[num];
Marshal.Copy(intPtr, array, 0, num);
result = Encoding.UTF8.GetString(array);
}
return result;
}
}
public unsafe static string GitDate
{
get
{
IntPtr intPtr = SherpaOnnxGetGitDate();
string result = "";
int num = 0;
byte* ptr = (byte*)(void*)intPtr;
if (ptr != null)
{
while (*ptr != 0)
{
ptr++;
num++;
}
}
if (num > 0)
{
byte[] array = new byte[num];
Marshal.Copy(intPtr, array, 0, num);
result = Encoding.UTF8.GetString(array);
}
return result;
}
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxGetVersionStr();
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxGetGitSha1();
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxGetGitDate();
}
public class VoiceActivityDetector : IDisposable
{
private HandleRef _handle;
public VoiceActivityDetector(VadModelConfig config, float bufferSizeInSeconds)
{
IntPtr handle = SherpaOnnxCreateVoiceActivityDetector(ref config, bufferSizeInSeconds);
_handle = new HandleRef(this, handle);
}
public void AcceptWaveform(float[] samples)
{
SherpaOnnxVoiceActivityDetectorAcceptWaveform(_handle.Handle, samples, samples.Length);
}
public bool IsEmpty()
{
return SherpaOnnxVoiceActivityDetectorEmpty(_handle.Handle) == 1;
}
public bool IsSpeechDetected()
{
return SherpaOnnxVoiceActivityDetectorDetected(_handle.Handle) == 1;
}
public void Pop()
{
SherpaOnnxVoiceActivityDetectorPop(_handle.Handle);
}
public SpeechSegment Front()
{
IntPtr intPtr = SherpaOnnxVoiceActivityDetectorFront(_handle.Handle);
SpeechSegment result = new SpeechSegment(intPtr);
SherpaOnnxDestroySpeechSegment(intPtr);
return result;
}
public void Clear()
{
SherpaOnnxVoiceActivityDetectorClear(_handle.Handle);
}
public void Reset()
{
SherpaOnnxVoiceActivityDetectorReset(_handle.Handle);
}
public void Flush()
{
SherpaOnnxVoiceActivityDetectorFlush(_handle.Handle);
}
public void Dispose()
{
Cleanup();
GC.SuppressFinalize(this);
}
~VoiceActivityDetector()
{
Cleanup();
}
private void Cleanup()
{
SherpaOnnxDestroyVoiceActivityDetector(_handle.Handle);
_handle = new HandleRef(this, IntPtr.Zero);
}
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxCreateVoiceActivityDetector(ref VadModelConfig config, float bufferSizeInSeconds);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroyVoiceActivityDetector(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxVoiceActivityDetectorAcceptWaveform(IntPtr handle, float[] samples, int n);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxVoiceActivityDetectorEmpty(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern int SherpaOnnxVoiceActivityDetectorDetected(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxVoiceActivityDetectorPop(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxVoiceActivityDetectorClear(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern IntPtr SherpaOnnxVoiceActivityDetectorFront(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxDestroySpeechSegment(IntPtr segment);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxVoiceActivityDetectorReset(IntPtr handle);
[DllImport("sherpa-onnx-c-api")]
private static extern void SherpaOnnxVoiceActivityDetectorFlush(IntPtr handle);
}
