react-native-sherpa-onnx 0.2.0 → 0.3.0

package/ios/model_detect/sherpa-onnx-model-detect-tts.mm

@@ -0,0 +1,201 @@
+/**
+ * sherpa-onnx-model-detect-tts.mm
+ *
+ * Purpose: Detects TTS (text-to-speech) model type and fills TtsModelPaths from a model directory.
+ * Supports Vits, Piper, Kokoro, Zipvoice, Pocket, etc. Used by the TTS wrapper on iOS.
+ */
+
+#include "sherpa-onnx-model-detect.h"
+#include "sherpa-onnx-model-detect-helper.h"
+
+#include <string>
+
+namespace sherpaonnx {
+namespace {
+
+using namespace model_detect;
+
+TtsModelKind ParseTtsModelType(const std::string& modelType) {
+    if (modelType == "vits") return TtsModelKind::kVits;
+    if (modelType == "matcha") return TtsModelKind::kMatcha;
+    if (modelType == "kokoro") return TtsModelKind::kKokoro;
+    if (modelType == "kitten") return TtsModelKind::kKitten;
+    if (modelType == "pocket") return TtsModelKind::kPocket;
+    if (modelType == "zipvoice") return TtsModelKind::kZipvoice;
+    return TtsModelKind::kUnknown;
+}
+
+} // namespace
+
+TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& modelType) {
+    using namespace model_detect;
+
+    TtsDetectResult result;
+
+    if (modelDir.empty()) {
+        result.error = "TTS: Model directory is empty";
+        return result;
+    }
+
+    if (!FileExists(modelDir) || !IsDirectory(modelDir)) {
+        result.error = "TTS: Model directory does not exist or is not a directory: " + modelDir;
+        return result;
+    }
+
+    const int kMaxSearchDepth = 4;
+    const std::vector<FileEntry> files = ListFilesRecursive(modelDir, kMaxSearchDepth);
+
+    std::string tokensFile = FindFileByName(modelDir, "tokens.txt", kMaxSearchDepth);
+    std::string lexiconFile = FindFileByName(modelDir, "lexicon.txt", kMaxSearchDepth);
+    std::string dataDirPath = FindDirectoryByName(modelDir, "espeak-ng-data", kMaxSearchDepth);
+    std::string voicesFile = FindFileByName(modelDir, "voices.bin", kMaxSearchDepth);
+
+    std::string acousticModel = FindOnnxByAnyToken(files, {"acoustic_model", "acoustic-model"}, std::nullopt);
+    std::string vocoder = FindOnnxByAnyToken(files, {"vocoder", "vocos"}, std::nullopt);
+    std::string encoder = FindOnnxByAnyToken(files, {"encoder"}, std::nullopt);
+    std::string decoder = FindOnnxByAnyToken(files, {"decoder"}, std::nullopt);
+    std::string lmFlow = FindOnnxByAnyToken(files, {"lm_flow", "lm-flow"}, std::nullopt);
+    std::string lmMain = FindOnnxByAnyToken(files, {"lm_main", "lm-main"}, std::nullopt);
+    std::string textConditioner = FindOnnxByAnyToken(files, {"text_conditioner", "text-conditioner"}, std::nullopt);
+    std::string vocabJsonFile = FindFileByName(modelDir, "vocab.json", kMaxSearchDepth);
+    std::string tokenScoresJsonFile = FindFileByName(modelDir, "token_scores.json", kMaxSearchDepth);
+
+    std::vector<std::string> modelExcludes = {"acoustic", "vocoder", "encoder", "decoder", "joiner"};
+    std::string ttsModel = FindOnnxByAnyToken(files, {"model"}, std::nullopt);
+    if (ttsModel.empty()) {
+        ttsModel = FindLargestOnnxExcludingTokens(files, modelExcludes);
+    }
+
+    bool hasVits = !ttsModel.empty();
+    bool hasMatcha = !acousticModel.empty() && !vocoder.empty();
+    bool hasVoicesFile = !voicesFile.empty() && FileExists(voicesFile);
+    bool hasZipvoice = !encoder.empty() && !decoder.empty() && !vocoder.empty();
+    bool hasPocket = !lmFlow.empty() && !lmMain.empty() && !encoder.empty() && !decoder.empty() &&
+                     !textConditioner.empty() && !vocabJsonFile.empty() && FileExists(vocabJsonFile) &&
+                     !tokenScoresJsonFile.empty() && FileExists(tokenScoresJsonFile);
+    bool hasDataDir = !dataDirPath.empty() && IsDirectory(dataDirPath);
+
+    std::string modelDirLower = ToLower(modelDir);
+    bool isLikelyKitten = modelDirLower.find("kitten") != std::string::npos;
+    bool isLikelyKokoro = modelDirLower.find("kokoro") != std::string::npos;
+
+    if (hasMatcha) {
+        result.detectedModels.push_back({"matcha", modelDir});
+    }
+    if (hasPocket) {
+        result.detectedModels.push_back({"pocket", modelDir});
+    }
+    if (hasZipvoice && !hasMatcha) {
+        result.detectedModels.push_back({"zipvoice", modelDir});
+    }
+    if (hasVoicesFile) {
+        if (isLikelyKitten && !isLikelyKokoro) {
+            result.detectedModels.push_back({"kitten", modelDir});
+        } else if (isLikelyKokoro && !isLikelyKitten) {
+            result.detectedModels.push_back({"kokoro", modelDir});
+        } else {
+            result.detectedModels.push_back({"kokoro", modelDir});
+            result.detectedModels.push_back({"kitten", modelDir});
+        }
+    }
+    if (hasVits) {
+        bool isLikelyVits = modelDirLower.find("vits") != std::string::npos;
+        bool voicesAmbiguous = !isLikelyKitten && !isLikelyKokoro;
+        bool addVits = false;
+        if (!hasVoicesFile) {
+            addVits = true;
+        } else {
+            if (isLikelyVits || voicesAmbiguous) addVits = true;
+        }
+        if (addVits) {
+            result.detectedModels.push_back({"vits", modelDir});
+        }
+    }
+
+    TtsModelKind selected = TtsModelKind::kUnknown;
+    if (modelType != "auto") {
+        selected = ParseTtsModelType(modelType);
+        if (selected == TtsModelKind::kUnknown) {
+            result.error = "TTS: Unknown model type: " + modelType;
+            return result;
+        }
+    } else {
+        if (hasMatcha) {
+            selected = TtsModelKind::kMatcha;
+        } else if (hasPocket) {
+            selected = TtsModelKind::kPocket;
+        } else if (hasZipvoice) {
+            selected = TtsModelKind::kZipvoice;
+        } else if (hasVoicesFile) {
+            if (isLikelyKitten && !isLikelyKokoro) {
+                selected = TtsModelKind::kKitten;
+            } else if (isLikelyKokoro && !isLikelyKitten) {
+                selected = TtsModelKind::kKokoro;
+            } else {
+                selected = TtsModelKind::kKokoro;
+            }
+        } else if (hasVits) {
+            selected = TtsModelKind::kVits;
+        }
+    }
+
+    if (selected == TtsModelKind::kUnknown) {
+        result.error = "TTS: No compatible model type detected in " + modelDir;
+        return result;
+    }
+
+    if (selected == TtsModelKind::kVits && !hasVits) {
+        result.error = "TTS: VITS model requested but model file not found in " + modelDir;
+        return result;
+    }
+    if (selected == TtsModelKind::kMatcha && !hasMatcha) {
+        result.error = "TTS: Matcha model requested but required files not found in " + modelDir;
+        return result;
+    }
+    if ((selected == TtsModelKind::kKokoro || selected == TtsModelKind::kKitten) && (!hasVits || !hasVoicesFile)) {
+        result.error = "TTS: Kokoro/Kitten model requested but required files not found in " + modelDir;
+        return result;
+    }
+    if (selected == TtsModelKind::kPocket && !hasPocket) {
+        result.error = "TTS: Pocket model requested but required files not found in " + modelDir;
+        return result;
+    }
+    if (selected == TtsModelKind::kZipvoice && !hasZipvoice) {
+        result.error = "TTS: Zipvoice model requested but required files not found in " + modelDir;
+        return result;
+    }
+    if ((selected == TtsModelKind::kVits || selected == TtsModelKind::kMatcha ||
+         selected == TtsModelKind::kKokoro || selected == TtsModelKind::kKitten ||
+         selected == TtsModelKind::kZipvoice) &&
+        !hasDataDir) {
+        result.error = "TTS: espeak-ng-data not found in " + modelDir +
+                       ". Copy espeak-ng-data into the model directory.";
+        return result;
+    }
+
+    result.selectedKind = selected;
+    result.paths.ttsModel = ttsModel;
+    result.paths.tokens = tokensFile;
+    result.paths.lexicon = (!lexiconFile.empty() && FileExists(lexiconFile)) ? lexiconFile : "";
+    result.paths.dataDir = dataDirPath;
+    result.paths.voices = voicesFile;
+    result.paths.acousticModel = acousticModel;
+    result.paths.vocoder = vocoder;
+    result.paths.encoder = encoder;
+    result.paths.decoder = decoder;
+    result.paths.lmFlow = lmFlow;
+    result.paths.lmMain = lmMain;
+    result.paths.textConditioner = textConditioner;
+    result.paths.vocabJson = vocabJsonFile;
+    result.paths.tokenScoresJson = tokenScoresJsonFile;
+
+    if (selected != TtsModelKind::kPocket && (tokensFile.empty() || !FileExists(tokensFile))) {
+        result.error = "TTS: tokens.txt not found in " + modelDir;
+        return result;
+    }
+
+    result.ok = true;
+    return result;
+}
+
+} // namespace sherpaonnx

package/{android/src/main/cpp/jni → ios/model_detect}/sherpa-onnx-model-detect.h

@@ -1,89 +1,117 @@
-#ifndef SHERPA_ONNX_MODEL_DETECT_H
-#define SHERPA_ONNX_MODEL_DETECT_H
-
-#include "sherpa-onnx-common.h"
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace sherpaonnx {
-
-enum class SttModelKind {
-    kUnknown,
-    kTransducer,
-    kParaformer,
-    kNemoCtc,
-    kWenetCtc,
-    kSenseVoice,
-    kZipformerCtc,
-    kWhisper,
-    kFunAsrNano
-};
-
-enum class TtsModelKind {
-    kUnknown,
-    kVits,
-    kMatcha,
-    kKokoro,
-    kKitten,
-    kZipvoice
-};
-
-struct SttModelPaths {
-    std::string encoder;
-    std::string decoder;
-    std::string joiner;
-    std::string paraformerModel;
-    std::string ctcModel;
-    std::string whisperEncoder;
-    std::string whisperDecoder;
-    std::string tokens;
-    std::string funasrEncoderAdaptor;
-    std::string funasrLLM;
-    std::string funasrEmbedding;
-    std::string funasrTokenizer;
-};
-
-struct TtsModelPaths {
-    std::string ttsModel;
-    std::string tokens;
-    std::string lexicon;
-    std::string dataDir;
-    std::string voices;
-    std::string acousticModel;
-    std::string vocoder;
-    std::string encoder;
-    std::string decoder;
-};
-
-struct SttDetectResult {
-    bool ok = false;
-    std::string error;
-    std::vector<DetectedModel> detectedModels;
-    SttModelKind selectedKind = SttModelKind::kUnknown;
-    bool tokensRequired = true;
-    SttModelPaths paths;
-};
-
-struct TtsDetectResult {
-    bool ok = false;
-    std::string error;
-    std::vector<DetectedModel> detectedModels;
-    TtsModelKind selectedKind = TtsModelKind::kUnknown;
-    TtsModelPaths paths;
-};
-
-SttDetectResult DetectSttModel(
-    const std::string& modelDir,
-    const std::optional<bool>& preferInt8,
-    const std::optional<std::string>& modelType
-);
-
-TtsDetectResult DetectTtsModel(
-    const std::string& modelDir,
-    const std::string& modelType
-);
-
-} // namespace sherpaonnx
-
-#endif // SHERPA_ONNX_MODEL_DETECT_H
+#ifndef SHERPA_ONNX_MODEL_DETECT_H
+#define SHERPA_ONNX_MODEL_DETECT_H
+
+#include "sherpa-onnx-common.h"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace sherpaonnx {
+
+enum class SttModelKind {
+    kUnknown,
+    kTransducer,
+    kNemoTransducer,
+    kParaformer,
+    kNemoCtc,
+    kWenetCtc,
+    kSenseVoice,
+    kZipformerCtc,
+    kWhisper,
+    kFunAsrNano,
+    kFireRedAsr,
+    kMoonshine,
+    kDolphin,
+    kCanary,
+    kOmnilingual,
+    kMedAsr,
+    kTeleSpeechCtc
+};
+
+enum class TtsModelKind {
+    kUnknown,
+    kVits,
+    kMatcha,
+    kKokoro,
+    kKitten,
+    kPocket,
+    kZipvoice
+};
+
+struct SttModelPaths {
+    std::string encoder;
+    std::string decoder;
+    std::string joiner;
+    std::string paraformerModel;
+    std::string ctcModel;
+    std::string whisperEncoder;
+    std::string whisperDecoder;
+    std::string tokens;
+    std::string funasrEncoderAdaptor;
+    std::string funasrLLM;
+    std::string funasrEmbedding;
+    std::string funasrTokenizer;
+    std::string moonshinePreprocessor;
+    std::string moonshineEncoder;
+    std::string moonshineUncachedDecoder;
+    std::string moonshineCachedDecoder;
+    std::string dolphinModel;
+    std::string omnilingualModel;
+    std::string medasrModel;
+    std::string telespeechCtcModel;
+    std::string fireRedEncoder;
+    std::string fireRedDecoder;
+    std::string canaryEncoder;
+    std::string canaryDecoder;
+};
+
+struct TtsModelPaths {
+    std::string ttsModel;
+    std::string tokens;
+    std::string lexicon;
+    std::string dataDir;
+    std::string voices;
+    std::string acousticModel;
+    std::string vocoder;
+    std::string encoder;
+    std::string decoder;
+    // Pocket TTS
+    std::string lmFlow;
+    std::string lmMain;
+    std::string textConditioner;
+    std::string vocabJson;
+    std::string tokenScoresJson;
+};
+
+struct SttDetectResult {
+    bool ok = false;
+    std::string error;
+    std::vector<DetectedModel> detectedModels;
+    SttModelKind selectedKind = SttModelKind::kUnknown;
+    bool tokensRequired = true;
+    SttModelPaths paths;
+};
+
+struct TtsDetectResult {
+    bool ok = false;
+    std::string error;
+    std::vector<DetectedModel> detectedModels;
+    TtsModelKind selectedKind = TtsModelKind::kUnknown;
+    TtsModelPaths paths;
+};
+
+SttDetectResult DetectSttModel(
+    const std::string& modelDir,
+    const std::optional<bool>& preferInt8,
+    const std::optional<std::string>& modelType,
+    bool debug = false
+);
+
+TtsDetectResult DetectTtsModel(
+    const std::string& modelDir,
+    const std::string& modelType
+);
+
+} // namespace sherpaonnx
+
+#endif // SHERPA_ONNX_MODEL_DETECT_H

package/ios/scripts/patch-libarchive-includes.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# Copy libarchive .c files to ios/patched_libarchive and insert <stdio.h> and <unistd.h>
+# after #include "archive_platform.h" so they compile without modifying the submodule.
+# Called from SherpaOnnx.podspec during evaluation.
+# Requires: libarchive source dir (same as used for HEADER_SEARCH_PATHS: third_party or ios/Downloads/libarchive).
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SDK_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+LIBARCHIVE_SRC="${1:-}"
+PATCHED_DIR="$SDK_ROOT/ios/patched_libarchive"
+
+if [ -z "$LIBARCHIVE_SRC" ]; then
+  echo "Error: libarchive source dir not set. Usage: $0 <libarchive_source_dir>" >&2
+  echo "Use the same path as libarchive_dir in the pod (e.g. third_party/libarchive_prebuilt/libarchive-ios-layout or ios/Downloads/libarchive)." >&2
+  exit 1
+fi
+
+if [ ! -d "$LIBARCHIVE_SRC" ]; then
+  echo "Error: libarchive source dir not found: $LIBARCHIVE_SRC" >&2
+  echo "Run third_party/libarchive_prebuilt/build_libarchive_ios.sh (repo) or ios/scripts/setup-ios-libarchive.sh (npm)." >&2
+  exit 1
+fi
+
+if [ ! -f "$LIBARCHIVE_SRC/archive_platform.h" ]; then
+  echo "Error: $LIBARCHIVE_SRC does not look like libarchive (archive_platform.h missing)." >&2
+  exit 1
+fi
+
+mkdir -p "$PATCHED_DIR"
+count=0
+
+# Same exclude as podspec: no test, windows, linux, sunos, freebsd
+for f in "$LIBARCHIVE_SRC"/*.c; do
+  [ -f "$f" ] || continue
+  base=$(basename "$f" .c)
+  [[ "$(basename "$f")" =~ ^test\. ]] && continue
+  [[ "$base" == *windows* ]] && continue
+  [[ "$base" == *linux* ]] && continue
+  [[ "$base" == *sunos* ]] && continue
+  [[ "$base" == *freebsd* ]] && continue
+
+  dest="$PATCHED_DIR/$(basename "$f")"
+  # Insert #include <stdio.h> and #include <unistd.h> after first #include "archive_platform.h"
+  inserted=0
+  while IFS= read -r line; do
+    echo "$line"
+    if [ "$inserted" -eq 0 ] && echo "$line" | grep -q '^#include "archive_platform.h"'; then
+      echo '#include <stdio.h>'
+      echo '#include <unistd.h>'
+      inserted=1
+    fi
+  done < "$f" > "$dest"
+  count=$((count + 1))
+done
+
+if [ "$count" -eq 0 ]; then
+  echo "Error: No libarchive .c files were copied to $PATCHED_DIR. Check excludes and source dir." >&2
+  exit 1
+fi

package/ios/scripts/setup-ios-libarchive.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# Download libarchive iOS sources from GitHub Releases and extract to ios/Downloads/libarchive.
+# Always downloads (no skip when prebuilts exist). Call from Podfile pre_install so that
+# ios/Downloads/libarchive exists before the podspec is evaluated (required when using the SDK from npm).
+#
+# Usage: run from repo root or from Podfile pre_install, e.g.:
+#   system("bash", "#{sdk_path}/ios/scripts/setup-ios-libarchive.sh")
+# Or: ./ios/scripts/setup-ios-libarchive.sh
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# SDK root = parent of ios/
+SDK_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+DOWNLOADS_DIR="$SDK_ROOT/ios/Downloads"
+LIBARCHIVE_DIR="$DOWNLOADS_DIR/libarchive"
+TAG_FILE="$SDK_ROOT/third_party/libarchive_prebuilt/IOS_RELEASE_TAG"
+
+# Resolve release tag: env LIBARCHIVE_IOS_RELEASE_TAG, or IOS_RELEASE_TAG file (single source of truth; committed and included in npm package).
+RELEASE_TAG="${LIBARCHIVE_IOS_RELEASE_TAG:-}"
+if [ -z "$RELEASE_TAG" ] && [ -f "$TAG_FILE" ]; then
+  RELEASE_TAG=$(grep -v '^#' "$TAG_FILE" | grep -v '^[[:space:]]*$' | head -1 | tr -d '\r\n')
+fi
+if [ -z "$RELEASE_TAG" ]; then
+  echo "Error: IOS_RELEASE_TAG not found at $TAG_FILE. Reinstall the package or run from repo." >&2
+  exit 1
+fi
+
+# Skip download if already present (podspec can be evaluated multiple times during pod install).
+if [ -d "$LIBARCHIVE_DIR" ] && [ -f "$LIBARCHIVE_DIR/archive.h" ] && [ -n "$(find "$LIBARCHIVE_DIR" -maxdepth 1 -name '*.c' -print -quit 2>/dev/null)" ]; then
+  exit 0
+fi
+
+AUTH_ARGS=()
+if [ -n "$GITHUB_TOKEN" ]; then
+  AUTH_ARGS+=(-H "Authorization: Bearer $GITHUB_TOKEN")
+fi
+
+echo "Downloading libarchive iOS sources from release $RELEASE_TAG..."
+
+release_json=$(curl -s "${AUTH_ARGS[@]}" -H "Accept: application/vnd.github+json" \
+  "https://api.github.com/repos/XDcobra/react-native-sherpa-onnx/releases/tags/$RELEASE_TAG" 2>/dev/null || true)
+if [ -z "$release_json" ] || ! echo "$release_json" | grep -q '"assets"'; then
+  echo "Error: Could not fetch release $RELEASE_TAG or no assets (rate limit?)." >&2
+  exit 1
+fi
+
+download_url=""
+if command -v jq &>/dev/null; then
+  download_url=$(echo "$release_json" | jq -r '.assets[] | select(.name == "libarchive-ios-sources.zip") | .browser_download_url' | head -1)
+else
+  download_url=$(echo "$release_json" | grep -o '"browser_download_url": "[^"]*libarchive-ios-sources.zip[^"]*"' | head -1 | sed 's/.*: "//;s/"$//')
+fi
+if [ -z "$download_url" ]; then
+  echo "Error: Asset libarchive-ios-sources.zip not found in release $RELEASE_TAG" >&2
+  exit 1
+fi
+
+mkdir -p "$DOWNLOADS_DIR"
+zip_path="$DOWNLOADS_DIR/libarchive-ios-sources.zip"
+if ! curl -L -f "${AUTH_ARGS[@]}" -o "$zip_path" "$download_url"; then
+  rm -f "$zip_path"
+  exit 1
+fi
+if ! file "$zip_path" 2>/dev/null | grep -q "Zip archive"; then
+  echo "Error: Downloaded file is not a valid zip" >&2
+  rm -f "$zip_path"
+  exit 1
+fi
+
+rm -rf "$LIBARCHIVE_DIR"
+mkdir -p "$LIBARCHIVE_DIR"
+unzip -q -o "$zip_path" -d "$LIBARCHIVE_DIR"
+rm -f "$zip_path"
+
+# If the zip had a single top-level dir (e.g. libarchive-ios-sources), flatten so
+# archive.h and archive_xxhash.h are directly in LIBARCHIVE_DIR (podspec HEADER_SEARCH_PATHS expects that).
+subdirs=("$LIBARCHIVE_DIR"/*/)
+if [ -d "${subdirs[0]}" ] && [ "${#subdirs[@]}" -eq 1 ] && [ ! -f "$LIBARCHIVE_DIR/archive.h" ]; then
+  subdir="${subdirs[0]}"
+  echo "Flattening single top-level directory: $(basename "$subdir")"
+  shopt -s dotglob
+  mv "$subdir"* "$LIBARCHIVE_DIR/"
+  shopt -u dotglob
+  rmdir "$subdir" 2>/dev/null || true
+fi
+
+# Ensure required headers exist (e.g. archive_xxhash.h for LZ4 support)
+if [ ! -f "$LIBARCHIVE_DIR/archive.h" ]; then
+  echo "Error: $LIBARCHIVE_DIR/archive.h missing after extract. Zip layout may be unexpected." >&2
+  exit 1
+fi
+if [ ! -f "$LIBARCHIVE_DIR/archive_xxhash.h" ]; then
+  echo "Error: $LIBARCHIVE_DIR/archive_xxhash.h missing. Re-publish libarchive iOS release (build_libarchive_ios.sh copies all *.h)." >&2
+  exit 1
+fi
+
+echo "Libarchive iOS sources extracted to $LIBARCHIVE_DIR"