react-native-sherpa-onnx 0.3.2 → 0.3.4

package/ios/archive/sherpa-onnx-archive-helper.mm

@@ -6,8 +6,10 @@
  */
 
 #import "sherpa-onnx-archive-helper.h"
+#ifdef HAVE_LIBARCHIVE
 #import <archive.h>
 #import <archive_entry.h>
+#endif
 #import <CommonCrypto/CommonCrypto.h>
 #include <array>
 #include <atomic>
@@ -17,6 +19,7 @@
 static std::atomic_bool g_cancelExtract(false);
 
 namespace {
+#ifdef HAVE_LIBARCHIVE
 struct ArchiveReadContext {
   FILE* file = nullptr;
   std::array<unsigned char, 64 * 1024> buffer{};
@@ -66,6 +69,7 @@ static void DrainRemainingAndClose(ArchiveReadContext* ctx) {
   fclose(ctx->file);
   ctx->file = nullptr;
 }
+#endif
 
 static NSString* HexStringFromDigest(const unsigned char* digest, size_t size) {
   static const char* kHex = "0123456789abcdef";
@@ -122,7 +126,11 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
 
 + (void)cancelExtractTarBz2
 {
+#ifdef HAVE_LIBARCHIVE
   g_cancelExtract.store(true);
+#else
+  // feature disabled
+#endif
 }
 
 - (NSDictionary *)extractTarBz2:(NSString *)sourcePath
@@ -130,6 +138,9 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
            force:(BOOL)force
            progress:(SherpaOnnxArchiveProgressBlock)progress
 {
+#ifndef HAVE_LIBARCHIVE
+  return @{ @"success": @NO, @"reason": @"libarchive is disabled in this build. Rebuild without SHERPA_ONNX_DISABLE_LIBARCHIVE=1." };
+#else
   g_cancelExtract.store(false);
   NSFileManager *fileManager = [NSFileManager defaultManager];
 
@@ -285,6 +296,7 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
   NSString *sha256Hex = HexStringFromDigest(digest, CC_SHA256_DIGEST_LENGTH);
 
   return @{ @"success": @YES, @"path": targetPath, @"sha256": sha256Hex ?: @"" };
+#endif
 }
 
 - (NSString *)computeFileSha256:(NSString *)filePath

package/ios/model_detect/sherpa-onnx-model-detect-helper.h

@@ -21,12 +21,11 @@ std::vector<std::string> ListDirectories(const std::string& path);
 std::vector<FileEntry> ListFiles(const std::string& path);
 std::vector<FileEntry> ListFilesRecursive(const std::string& path, int maxDepth);
 std::string ToLower(std::string value);
-std::string ResolveTokenizerDir(const std::string& modelDir);
 
-std::string FindFileByName(const std::string& baseDir, const std::string& fileName, int maxDepth);
+/** Find file in \p files whose name equals \p fileName (case-insensitive). Uses file tree only, no filesystem. */
+std::string FindFileByName(const std::vector<FileEntry>& files, const std::string& fileName);
 /** Find file whose name equals or ends with suffix (e.g. tokens.txt, tiny-tokens.txt) in a pre-built file list. */
 std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::string& suffix);
-std::string FindDirectoryByName(const std::string& baseDir, const std::string& dirName, int maxDepth);
 
 std::string FindOnnxByToken(
     const std::vector<FileEntry>& files,
@@ -38,6 +37,13 @@ std::string FindOnnxByAnyToken(
     const std::vector<std::string>& tokens,
     const std::optional<bool>& preferInt8
 );
+/** Like FindOnnxByAnyToken but skips any file whose nameLower contains any of \p excludeInName. */
+std::string FindOnnxByAnyTokenExcluding(
+    const std::vector<FileEntry>& files,
+    const std::vector<std::string>& tokens,
+    const std::vector<std::string>& excludeInName,
+    const std::optional<bool>& preferInt8
+);
 std::string FindLargestOnnxExcludingTokens(
     const std::vector<FileEntry>& files,
     const std::vector<std::string>& excludeTokens
@@ -46,6 +52,34 @@ std::string FindLargestOnnxExcludingTokens(
 /** Returns true if \p word appears in \p haystack as a standalone token (surrounded by separators: / - _ . space). */
 bool ContainsWord(const std::string& haystack, const std::string& word);
 
+/**
+ * Find a directory with the given name anywhere under \p rootDir in the file tree.
+ * Searches \p files for any path that starts with \p rootDir and contains "/dirName/".
+ * Returns the full path to that directory (e.g. rootDir/inner/dirName) or empty if not found.
+ * Used e.g. to find espeak-ng-data in modelDir or in modelDir/inner-model-dir/.
+ */
+std::string FindDirectoryUnderRoot(
+    const std::vector<FileEntry>& files,
+    const std::string& rootDir,
+    const std::string& dirName
+);
+
+/** Lexicon file with optional language id for multi-lang TTS (e.g. Kokoro). */
+struct LexiconCandidate {
+    std::string path;       /**< Full path to the lexicon file */
+    std::string languageId; /**< From filename: "default" for lexicon.txt, else e.g. "us-en", "zh" from lexicon-us-en.txt, lexicon-zh.txt */
+};
+
+/**
+ * Find all lexicon files under \p rootDir: exact "lexicon.txt" and any "lexicon-*.txt".
+ * Returns a list of LexiconCandidate (path + languageId), ordered: lexicon.txt first (as "default"),
+ * then lexicon-*.txt alphabetically by language id. Used for multi-language Kokoro/Kitten TTS.
+ */
+std::vector<LexiconCandidate> FindLexiconCandidates(
+    const std::vector<FileEntry>& files,
+    const std::string& rootDir
+);
+
 } // namespace model_detect
 } // namespace sherpaonnx
 

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

@@ -30,12 +30,16 @@ bool ContainsToken(const std::string& value, const std::string& token) {
     return value.find(token) != std::string::npos;
 }
 
+static bool IsOnnxOrOrtFile(const FileEntry& entry) {
+    return EndsWith(entry.nameLower, ".onnx") || EndsWith(entry.nameLower, ".ort");
+}
+
 std::string ChooseLargest(const std::vector<FileEntry>& files,
     const std::vector<std::string>& excludeTokens, bool onlyInt8, bool onlyNonInt8) {
     std::string chosen;
     std::uint64_t bestSize = 0;
     for (const auto& entry : files) {
-        if (!EndsWith(entry.nameLower, ".onnx")) continue;
+        if (!IsOnnxOrOrtFile(entry)) continue;
         bool hasExcluded = false;
         for (const auto& token : excludeTokens) {
             if (ContainsToken(entry.nameLower, token)) { hasExcluded = true; break; }
@@ -115,7 +119,7 @@ std::string FindOnnxByToken(const std::vector<FileEntry>& files,
     std::string tokenLower = ToLower(token);
     std::vector<FileEntry> matches;
     for (const auto& entry : files) {
-        if (!EndsWith(entry.nameLower, ".onnx")) continue;
+        if (!IsOnnxOrOrtFile(entry)) continue;
         if (ContainsToken(entry.nameLower, tokenLower)) matches.push_back(entry);
     }
     if (matches.empty()) return "";
@@ -136,6 +140,37 @@ std::string FindOnnxByAnyToken(const std::vector<FileEntry>& files,
     return "";
 }
 
+std::string FindOnnxByAnyTokenExcluding(const std::vector<FileEntry>& files,
+    const std::vector<std::string>& tokens, const std::vector<std::string>& excludeInName,
+    const std::optional<bool>& preferInt8) {
+    for (const auto& token : tokens) {
+        std::string tokenLower = ToLower(token);
+        std::vector<FileEntry> matches;
+        for (const auto& entry : files) {
+            if (!IsOnnxOrOrtFile(entry)) continue;
+            if (!ContainsToken(entry.nameLower, tokenLower)) continue;
+            bool excluded = false;
+            for (const auto& ex : excludeInName) {
+                std::string exLower = ToLower(ex);
+                if (ContainsToken(entry.nameLower, exLower)) {
+                    excluded = true;
+                    break;
+                }
+            }
+            if (!excluded) matches.push_back(entry);
+        }
+        if (matches.empty()) continue;
+        std::vector<std::string> emptyTokens;
+        bool wantInt8 = preferInt8.has_value() && preferInt8.value();
+        bool wantNonInt8 = preferInt8.has_value() && !preferInt8.value();
+        std::string chosen = ChooseLargest(matches, emptyTokens, wantInt8, wantNonInt8);
+        if (!chosen.empty()) return chosen;
+        chosen = ChooseLargest(matches, emptyTokens, false, false);
+        if (!chosen.empty()) return chosen;
+    }
+    return "";
+}
+
 std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::string& suffix) {
     std::string targetSuffix = ToLower(suffix);
     for (const auto& entry : files) {
@@ -147,9 +182,8 @@ std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::s
     return "";
 }
 
-std::string FindFileByName(const std::string& baseDir, const std::string& fileName, int maxDepth) {
+std::string FindFileByName(const std::vector<FileEntry>& files, const std::string& fileName) {
     std::string target = ToLower(fileName);
-    auto files = ListFilesRecursive(baseDir, maxDepth);
     for (const auto& entry : files) {
         if (entry.nameLower == target) return entry.path;
     }
@@ -172,54 +206,55 @@ bool ContainsWord(const std::string& haystack, const std::string& word) {
     return false;
 }
 
-std::string FindDirectoryByName(const std::string& baseDir, const std::string& dirName, int maxDepth) {
-    std::string target = ToLower(dirName);
-    std::vector<std::string> toVisit = ListDirectories(baseDir);
-    int depth = 0;
-    while (!toVisit.empty() && depth <= maxDepth) {
-        std::vector<std::string> next;
-        for (const auto& dir : toVisit) {
-            std::string name = fs::path(dir).filename().string();
-            if (ToLower(name) == target) return dir;
-            if (depth < maxDepth) {
-                auto nested = ListDirectories(dir);
-                next.insert(next.end(), nested.begin(), nested.end());
-            }
+std::string FindDirectoryUnderRoot(
+    const std::vector<FileEntry>& files,
+    const std::string& rootDir,
+    const std::string& dirName
+) {
+    if (dirName.empty()) return "";
+    const std::string needle = "/" + dirName + "/";
+    const size_t dirPathLen = 1 + dirName.size();
+    for (const auto& entry : files) {
+        if (entry.path.size() < rootDir.size() + needle.size()) continue;
+        if (entry.path.compare(0, rootDir.size(), rootDir) != 0) continue;
+        size_t pos = entry.path.find(needle, rootDir.size());
+        if (pos != std::string::npos) {
+            return entry.path.substr(0, pos + dirPathLen);
         }
-        toVisit.swap(next);
-        depth += 1;
     }
     return "";
 }
 
-std::string ResolveTokenizerDir(const std::string& modelDir) {
-    std::string vocabInMain = modelDir + "/vocab.json";
-    if (FileExists(vocabInMain)) {
-        return modelDir;
-    }
-
-    try {
-        for (const auto& entry : fs::directory_iterator(modelDir)) {
-            if (entry.is_directory()) {
-                std::string dirName = entry.path().filename().string();
-                std::string dirNameLower = ToLower(dirName);
-                if (dirNameLower.find("qwen3") != std::string::npos) {
-                    std::string vocabPath = entry.path().string() + "/vocab.json";
-                    if (FileExists(vocabPath)) {
-                        return entry.path().string();
-                    }
-                }
-            }
+std::vector<LexiconCandidate> FindLexiconCandidates(
+    const std::vector<FileEntry>& files,
+    const std::string& rootDir
+) {
+    std::vector<LexiconCandidate> candidates;
+    const size_t rootLen = rootDir.size();
+    for (const auto& entry : files) {
+        if (entry.path.size() <= rootLen) continue;
+        if (rootLen > 0) {
+            if (entry.path.compare(0, rootLen, rootDir) != 0) continue;
+            // Enforce path boundary: if rootDir doesn't end with '/', require '/' after it
+            if (rootDir.back() != '/' && entry.path[rootLen] != '/') continue;
+        }
+        const std::string& baseLower = entry.nameLower;
+        if (baseLower == "lexicon.txt") {
+            candidates.push_back({entry.path, "default"});
+        } else if (baseLower.size() > 12 &&
+                   baseLower.compare(0, 8, "lexicon-") == 0 &&
+                   baseLower.compare(baseLower.size() - 4, 4, ".txt") == 0) {
+            std::string languageId = baseLower.substr(8, baseLower.size() - 12);
+            candidates.push_back({entry.path, languageId});
         }
-    } catch (const std::exception&) {
-    }
-
-    std::string commonPath = modelDir + "/Qwen3-0.6B";
-    if (FileExists(commonPath + "/vocab.json")) {
-        return commonPath;
     }
-
-    return "";
+    std::sort(candidates.begin(), candidates.end(), [](const LexiconCandidate& a, const LexiconCandidate& b) {
+        if (a.languageId == b.languageId) return a.path < b.path;
+        if (a.languageId == "default") return true;
+        if (b.languageId == "default") return false;
+        return a.languageId < b.languageId;
+    });
+    return candidates;
 }
 
 } // namespace model_detect