Refactor C# code and support building nuget packages for cross-platforms (#144)

sherpa-onnx/c-api/c-api.cc

@@ -10,10 +10,11 @@
 #include <vector>
 
 #include "sherpa-onnx/csrc/display.h"
+#include "sherpa-onnx/csrc/offline-recognizer.h"
 #include "sherpa-onnx/csrc/online-recognizer.h"
 
 struct SherpaOnnxOnlineRecognizer {
-  sherpa_onnx::OnlineRecognizer *impl;
+  std::unique_ptr<sherpa_onnx::OnlineRecognizer> impl;
 };
 
 struct SherpaOnnxOnlineStream {
@@ -56,14 +57,19 @@ SherpaOnnxOnlineRecognizer *CreateOnlineRecognizer(
   recognizer_config.endpoint_config.rule3.min_utterance_length =
       config->rule3_min_utterance_length;
 
+  if (config->model_config.debug) {
+    fprintf(stderr, "%s\n", recognizer_config.ToString().c_str());
+  }
+
   SherpaOnnxOnlineRecognizer *recognizer = new SherpaOnnxOnlineRecognizer;
-  recognizer->impl = new sherpa_onnx::OnlineRecognizer(recognizer_config);
+
+  recognizer->impl =
+      std::make_unique<sherpa_onnx::OnlineRecognizer>(recognizer_config);
 
   return recognizer;
 }
 
 void DestroyOnlineRecognizer(SherpaOnnxOnlineRecognizer *recognizer) {
-  delete recognizer->impl;
   delete recognizer;
 }
 
@@ -144,3 +150,116 @@ void DestroyDisplay(SherpaOnnxDisplay *display) { delete display; }
 void SherpaOnnxPrint(SherpaOnnxDisplay *display, int32_t idx, const char *s) {
   display->impl->Print(idx, s);
 }
+
+// ============================================================
+// For offline ASR (i.e., non-streaming ASR)
+// ============================================================
+//
+struct SherpaOnnxOfflineRecognizer {
+  std::unique_ptr<sherpa_onnx::OfflineRecognizer> impl;
+};
+
+struct SherpaOnnxOfflineStream {
+  std::unique_ptr<sherpa_onnx::OfflineStream> impl;
+  explicit SherpaOnnxOfflineStream(
+      std::unique_ptr<sherpa_onnx::OfflineStream> p)
+      : impl(std::move(p)) {}
+};
+
+SherpaOnnxOfflineRecognizer *CreateOfflineRecognizer(
+    const SherpaOnnxOfflineRecognizerConfig *config) {
+  sherpa_onnx::OfflineRecognizerConfig recognizer_config;
+
+  recognizer_config.feat_config.sampling_rate = config->feat_config.sample_rate;
+
+  recognizer_config.feat_config.feature_dim = config->feat_config.feature_dim;
+
+  recognizer_config.model_config.transducer.encoder_filename =
+      config->model_config.transducer.encoder;
+
+  recognizer_config.model_config.transducer.decoder_filename =
+      config->model_config.transducer.decoder;
+
+  recognizer_config.model_config.transducer.joiner_filename =
+      config->model_config.transducer.joiner;
+
+  recognizer_config.model_config.paraformer.model =
+      config->model_config.paraformer.model;
+
+  recognizer_config.model_config.nemo_ctc.model =
+      config->model_config.nemo_ctc.model;
+
+  recognizer_config.model_config.tokens = config->model_config.tokens;
+  recognizer_config.model_config.num_threads = config->model_config.num_threads;
+  recognizer_config.model_config.debug = config->model_config.debug;
+
+  recognizer_config.lm_config.model = config->lm_config.model;
+  recognizer_config.lm_config.scale = config->lm_config.scale;
+
+  recognizer_config.decoding_method = config->decoding_method;
+  recognizer_config.max_active_paths = config->max_active_paths;
+
+  if (config->model_config.debug) {
+    fprintf(stderr, "%s\n", recognizer_config.ToString().c_str());
+  }
+
+  SherpaOnnxOfflineRecognizer *recognizer = new SherpaOnnxOfflineRecognizer;
+
+  recognizer->impl =
+      std::make_unique<sherpa_onnx::OfflineRecognizer>(recognizer_config);
+
+  return recognizer;
+}
+
+void DestroyOfflineRecognizer(SherpaOnnxOfflineRecognizer *recognizer) {
+  delete recognizer;
+}
+
+SherpaOnnxOfflineStream *CreateOfflineStream(
+    const SherpaOnnxOfflineRecognizer *recognizer) {
+  SherpaOnnxOfflineStream *stream =
+      new SherpaOnnxOfflineStream(recognizer->impl->CreateStream());
+  return stream;
+}
+
+void DestoryOfflineStream(SherpaOnnxOfflineStream *stream) { delete stream; }
+
+void AcceptWaveformOffline(SherpaOnnxOfflineStream *stream, int32_t sample_rate,
+                           const float *samples, int32_t n) {
+  stream->impl->AcceptWaveform(sample_rate, samples, n);
+}
+
+void DecodeOfflineStream(SherpaOnnxOfflineRecognizer *recognizer,
+                         SherpaOnnxOfflineStream *stream) {
+  recognizer->impl->DecodeStream(stream->impl.get());
+}
+
+void DecodeMultipleOfflineStreams(SherpaOnnxOfflineRecognizer *recognizer,
+                                  SherpaOnnxOfflineStream **streams,
+                                  int32_t n) {
+  std::vector<sherpa_onnx::OfflineStream *> ss(n);
+  for (int32_t i = 0; i != n; ++i) {
+    ss[i] = streams[i]->impl.get();
+  }
+  recognizer->impl->DecodeStreams(ss.data(), n);
+}
+
+SherpaOnnxOfflineRecognizerResult *GetOfflineStreamResult(
+    SherpaOnnxOfflineStream *stream) {
+  const sherpa_onnx::OfflineRecognitionResult &result =
+      stream->impl->GetResult();
+  const auto &text = result.text;
+
+  auto r = new SherpaOnnxOfflineRecognizerResult;
+  r->text = new char[text.size() + 1];
+  std::copy(text.begin(), text.end(), const_cast<char *>(r->text));
+  const_cast<char *>(r->text)[text.size()] = 0;
+
+  return r;
+}
+
+void DestroyOfflineRecognizerResult(
+    const SherpaOnnxOfflineRecognizerResult *r) {
+  delete[] r->text;
+  delete r;
+}