react-native-sherpa-onnx 0.3.5 → 0.3.7

package/ios/SherpaOnnxAudioConvert.mm

@@ -2,6 +2,7 @@
 #import <React/RCTLog.h>
 #include <string>
 #include <sys/stat.h>
+#include <vector>
 
 #ifdef HAVE_FFMPEG
 extern "C" {
@@ -12,11 +13,14 @@ extern "C" {
 #include <libswresample/swresample.h>
 }
 #include <cstdio>
-#include <vector>
 #endif
 
 // Forward declaration — convertToFormat handles all formats including WAV (16 kHz mono).
 static std::string convertToFormat(const char* inputPath, const char* outputPath, const char* formatHint, int outputSampleRateHz);
+static std::string decodeAudioFileToFloatMono(const char* inputPath,
+                                              int targetSampleRateHz,
+                                              std::vector<float>* outSamples,
+                                              int* outSampleRate);
 
 // Convenience: convert any audio to 16 kHz mono WAV via the main convertToFormat pipeline.
 static std::string convertToWav16kMono(const char* inputPath, const char* outputPath) {
@@ -659,6 +663,222 @@ static std::string convertToFormat(const char* inputPath, const char* outputPath
 #endif
 }
 
+static std::string decodeAudioFileToFloatMono(const char* inputPath,
+                                              int targetSampleRateHz,
+                                              std::vector<float>* outSamples,
+                                              int* outSampleRate) {
+    outSamples->clear();
+    *outSampleRate = 0;
+#ifndef HAVE_FFMPEG
+    (void)inputPath;
+    (void)targetSampleRateHz;
+    return std::string("FFmpeg not available. Build prebuilts with third_party/ffmpeg_prebuilt/build_ffmpeg_ios.sh.");
+#else
+    if (!inputPath) {
+        return std::string("inputPath is null");
+    }
+
+    AVFormatContext* inFmt = nullptr;
+    if (avformat_open_input(&inFmt, inputPath, nullptr, nullptr) < 0) {
+        return std::string("Failed to open input file");
+    }
+    if (avformat_find_stream_info(inFmt, nullptr) < 0) {
+        avformat_close_input(&inFmt);
+        return std::string("Failed to find stream info");
+    }
+
+    int audioStreamIndex = -1;
+    for (unsigned i = 0; i < inFmt->nb_streams; ++i) {
+        if (inFmt->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+            audioStreamIndex = (int)i;
+            break;
+        }
+    }
+    if (audioStreamIndex < 0) {
+        avformat_close_input(&inFmt);
+        return std::string("No audio stream found in input");
+    }
+
+    AVStream* inStream = inFmt->streams[audioStreamIndex];
+    const AVCodec* decoder = avcodec_find_decoder(inStream->codecpar->codec_id);
+    if (!decoder) {
+        avformat_close_input(&inFmt);
+        return std::string("Unsupported input codec");
+    }
+
+    AVCodecContext* decCtx = avcodec_alloc_context3(decoder);
+    if (!decCtx) {
+        avformat_close_input(&inFmt);
+        return std::string("Failed to allocate decoder context");
+    }
+    if (avcodec_parameters_to_context(decCtx, inStream->codecpar) < 0) {
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Failed to copy codec parameters");
+    }
+    if (avcodec_open2(decCtx, decoder, nullptr) < 0) {
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Failed to open decoder");
+    }
+
+    int in_sr = decCtx->sample_rate;
+    if (inStream->codecpar->sample_rate > 0) {
+        in_sr = inStream->codecpar->sample_rate;
+    }
+    if (in_sr <= 0) {
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Invalid input sample rate");
+    }
+
+    int out_sr = (targetSampleRateHz > 0) ? targetSampleRateHz : in_sr;
+    if (out_sr <= 0) {
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Invalid output sample rate");
+    }
+
+    AVChannelLayout in_layout{};
+    if (inStream->codecpar->ch_layout.nb_channels > 0) {
+        if (av_channel_layout_copy(&in_layout, &inStream->codecpar->ch_layout) < 0) {
+            avcodec_free_context(&decCtx);
+            avformat_close_input(&inFmt);
+            return std::string("Failed to copy input channel layout");
+        }
+    } else {
+        if (av_channel_layout_copy(&in_layout, &decCtx->ch_layout) < 0) {
+            avcodec_free_context(&decCtx);
+            avformat_close_input(&inFmt);
+            return std::string("Failed to get decoder channel layout");
+        }
+    }
+
+    AVChannelLayout out_layout = AV_CHANNEL_LAYOUT_MONO;
+    SwrContext* swr = nullptr;
+    if (swr_alloc_set_opts2(&swr,
+                           &out_layout,
+                           AV_SAMPLE_FMT_FLT,
+                           out_sr,
+                           &in_layout,
+                           decCtx->sample_fmt,
+                           in_sr,
+                           0,
+                           nullptr) < 0 ||
+        !swr) {
+        av_channel_layout_uninit(&in_layout);
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Failed to initialize resampler");
+    }
+    if (swr_init(swr) < 0) {
+        av_channel_layout_uninit(&in_layout);
+        swr_free(&swr);
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Failed to initialize resampler (swr_init)");
+    }
+    av_channel_layout_uninit(&in_layout);
+
+    AVPacket* pkt = av_packet_alloc();
+    AVFrame* frame = av_frame_alloc();
+    if (!pkt || !frame) {
+        if (pkt) av_packet_free(&pkt);
+        if (frame) av_frame_free(&frame);
+        swr_free(&swr);
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Out of memory");
+    }
+
+    auto appendConverted = [&](uint8_t* buf, int nbFloats) {
+        if (!buf || nbFloats <= 0) return;
+        const float* f = reinterpret_cast<const float*>(buf);
+        outSamples->insert(outSamples->end(), f, f + nbFloats);
+    };
+
+    auto convertOneFrame = [&](AVFrame* fr) {
+        // Copy plane pointers so we can pass const uint8_t** to swr_convert without
+        // reinterpret_cast(uint8_t** -> const uint8_t**), which triggers -Wcast-qual.
+        uint8_t** src = fr->extended_data ? fr->extended_data : fr->data;
+        int nplanes = fr->ch_layout.nb_channels;
+        if (nplanes <= 0) nplanes = AV_NUM_DATA_POINTERS;
+
+        const uint8_t* in_stack[AV_NUM_DATA_POINTERS] = {};
+        std::vector<const uint8_t*> in_heap;
+        const uint8_t** in_arg;
+        if (nplanes > AV_NUM_DATA_POINTERS) {
+            in_heap.resize(static_cast<size_t>(nplanes));
+            for (int i = 0; i < nplanes; ++i) {
+                in_heap[static_cast<size_t>(i)] = src[i];
+            }
+            in_arg = in_heap.data();
+        } else {
+            for (int i = 0; i < nplanes; ++i) {
+                in_stack[i] = src[i];
+            }
+            in_arg = in_stack;
+        }
+
+        int in_sr2 = inStream->codecpar->sample_rate ? inStream->codecpar->sample_rate : decCtx->sample_rate;
+        int64_t max_out =
+            av_rescale_rnd(swr_get_delay(swr, in_sr2) + (int64_t)fr->nb_samples, out_sr, in_sr2, AV_ROUND_UP);
+        if (max_out < 1) max_out = 1;
+        uint8_t* out_buf = nullptr;
+        if (av_samples_alloc(&out_buf, nullptr, 1, (int)max_out, AV_SAMPLE_FMT_FLT, 0) < 0) {
+            return;
+        }
+        int converted = swr_convert(swr, &out_buf, (int)max_out, in_arg, fr->nb_samples);
+        if (converted > 0) {
+            appendConverted(out_buf, converted);
+        }
+        av_freep(&out_buf);
+    };
+
+    while (av_read_frame(inFmt, pkt) >= 0) {
+        if (pkt->stream_index == audioStreamIndex) {
+            if (avcodec_send_packet(decCtx, pkt) == 0) {
+                while (avcodec_receive_frame(decCtx, frame) == 0) {
+                    convertOneFrame(frame);
+                    av_frame_unref(frame);
+                }
+            }
+        }
+        av_packet_unref(pkt);
+    }
+
+    if (avcodec_send_packet(decCtx, nullptr) == 0) {
+        while (avcodec_receive_frame(decCtx, frame) == 0) {
+            convertOneFrame(frame);
+            av_frame_unref(frame);
+        }
+    }
+
+    {
+        int in_sr2 = inStream->codecpar->sample_rate ? inStream->codecpar->sample_rate : decCtx->sample_rate;
+        int tailCap = (int)swr_get_delay(swr, in_sr2) + 4096;
+        if (tailCap < 16) tailCap = 16;
+        uint8_t* tailData = nullptr;
+        if (av_samples_alloc(&tailData, nullptr, 1, tailCap, AV_SAMPLE_FMT_FLT, 0) >= 0) {
+            int tailConverted = swr_convert(swr, &tailData, tailCap, nullptr, 0);
+            if (tailConverted > 0) {
+                appendConverted(tailData, tailConverted);
+            }
+            av_freep(&tailData);
+        }
+    }
+
+    av_packet_free(&pkt);
+    av_frame_free(&frame);
+    swr_free(&swr);
+    avcodec_free_context(&decCtx);
+    avformat_close_input(&inFmt);
+
+    *outSampleRate = out_sr;
+    return std::string("");
+#endif
+}
+
 @implementation SherpaOnnxAudioConvert
 
 + (BOOL)convertAudioToWav16k:(NSString *)inputPath
@@ -695,4 +915,40 @@ static std::string convertToFormat(const char* inputPath, const char* outputPath
     return YES;
 }
 
++ (BOOL)decodeAudioFileToFloatSamples:(NSString *)inputPath
+                   targetSampleRateHz:(int)targetSampleRateHz
+                           outSamples:(NSArray<NSNumber *> **)outSamples
+                        outSampleRate:(int *)outSampleRate
+                                error:(NSError **)error
+{
+    if (!outSamples || !outSampleRate) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"SherpaOnnxAudioConvert"
+                                         code:-2
+                                     userInfo:@{NSLocalizedDescriptionKey: @"outSamples/outSampleRate required"}];
+        }
+        return NO;
+    }
+    *outSamples = nil;
+    *outSampleRate = 0;
+    std::vector<float> v;
+    int sr = 0;
+    std::string err = decodeAudioFileToFloatMono(inputPath.UTF8String, targetSampleRateHz, &v, &sr);
+    if (!err.empty()) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"SherpaOnnxAudioConvert"
+                                         code:-1
+                                     userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithUTF8String:err.c_str()]}];
+        }
+        return NO;
+    }
+    NSMutableArray<NSNumber *> *arr = [NSMutableArray arrayWithCapacity:v.size()];
+    for (size_t i = 0; i < v.size(); ++i) {
+        [arr addObject:@(v[i])];
+    }
+    *outSamples = arr;
+    *outSampleRate = sr;
+    return YES;
+}
+
 @end

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

@@ -11,11 +11,21 @@ typedef void (^SherpaOnnxArchiveProgressBlock)(long long bytes, long long totalB
                           force:(BOOL)force
                        progress:(nullable SherpaOnnxArchiveProgressBlock)progress;
 
+- (NSDictionary *)extractTarZst:(NSString *)sourcePath
+                     targetPath:(NSString *)targetPath
+                          force:(BOOL)force
+                       progress:(nullable SherpaOnnxArchiveProgressBlock)progress;
+
 - (nullable NSString *)computeFileSha256:(NSString *)filePath
                                    error:(NSError * _Nullable * _Nullable)error;
 
 + (void)cancelExtractTarBz2;
 
++ (void)cancelExtractTarZst;
+
+/** Cancel extraction for a specific source archive path (per-operation cancel for parallel extractions). */
++ (void)cancelExtractForPath:(NSString *)sourcePath;
+
 @end
 
 NS_ASSUME_NONNULL_END

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

@@ -14,9 +14,24 @@
 #include <array>
 #include <atomic>
 #include <cstdio>
+#include <mutex>
+#include <set>
 #include <string>
 
-static std::atomic_bool g_cancelExtract(false);
+static std::mutex g_cancelMutex;
+static std::set<std::string> g_cancelledPaths;
+
+static bool isPathCancelled(const std::string& path) {
+  std::lock_guard<std::mutex> lock(g_cancelMutex);
+  // If the set contains an empty string, ALL extractions are cancelled (legacy global cancel).
+  return g_cancelledPaths.count("") > 0 || g_cancelledPaths.count(path) > 0;
+}
+
+static void clearCancelForPath(const std::string& path) {
+  std::lock_guard<std::mutex> lock(g_cancelMutex);
+  g_cancelledPaths.erase(path);
+  g_cancelledPaths.erase(""); // Clear the global cancel flag too
+}
 
 namespace {
 #ifdef HAVE_LIBARCHIVE
@@ -127,7 +142,31 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
 + (void)cancelExtractTarBz2
 {
 #ifdef HAVE_LIBARCHIVE
-  g_cancelExtract.store(true);
+  std::lock_guard<std::mutex> lock(g_cancelMutex);
+  g_cancelledPaths.insert(""); // Empty string = cancel ALL
+#else
+  // feature disabled
+#endif
+}
+
++ (void)cancelExtractTarZst
+{
+#ifdef HAVE_LIBARCHIVE
+  std::lock_guard<std::mutex> lock(g_cancelMutex);
+  g_cancelledPaths.insert(""); // Empty string = cancel ALL
+#else
+  // feature disabled
+#endif
+}
+
++ (void)cancelExtractForPath:(NSString *)sourcePath
+{
+#ifdef HAVE_LIBARCHIVE
+  std::string path = [sourcePath UTF8String] ?: "";
+  if (!path.empty()) {
+    std::lock_guard<std::mutex> lock(g_cancelMutex);
+    g_cancelledPaths.insert(path);
+  }
 #else
   // feature disabled
 #endif
@@ -141,7 +180,8 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
 #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);
+  std::string sourcePathStr = [sourcePath UTF8String] ?: "";
+  clearCancelForPath(sourcePathStr);
   NSFileManager *fileManager = [NSFileManager defaultManager];
 
   if (![fileManager fileExistsAtPath:sourcePath]) {
@@ -174,6 +214,7 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
   struct archive *archive = archive_read_new();
   archive_read_support_format_tar(archive);
   archive_read_support_filter_bzip2(archive);
+  archive_read_support_filter_zstd(archive);
 
   ArchiveReadContext read_ctx;
   read_ctx.file = fopen([sourcePath UTF8String], "rb");
@@ -203,10 +244,11 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
   int lastPercent = -1;
   long long lastEmitBytes = 0;
   while ((result = archive_read_next_header(archive, &entry)) == ARCHIVE_OK) {
-    if (g_cancelExtract.load()) {
+    if (isPathCancelled(sourcePathStr)) {
       archive_read_free(archive);
       archive_write_free(disk);
       close_reader();
+      clearCancelForPath(sourcePathStr);
       return @{ @"success": @NO, @"reason": @"Extraction cancelled" };
     }
     const char *currentPath = archive_entry_pathname(entry);
@@ -235,10 +277,11 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
     size_t size = 0;
     la_int64_t offset = 0;
     while ((result = archive_read_data_block(archive, &buff, &size, &offset)) == ARCHIVE_OK) {
-      if (g_cancelExtract.load()) {
+      if (isPathCancelled(sourcePathStr)) {
         archive_read_free(archive);
         archive_write_free(disk);
         close_reader();
+        clearCancelForPath(sourcePathStr);
         return @{ @"success": @NO, @"reason": @"Extraction cancelled" };
       }
       la_ssize_t writeResult = archive_write_data_block(disk, buff, size, offset);
@@ -299,6 +342,14 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
 #endif
 }
 
+- (NSDictionary *)extractTarZst:(NSString *)sourcePath
+                     targetPath:(NSString *)targetPath
+                          force:(BOOL)force
+                       progress:(SherpaOnnxArchiveProgressBlock)progress
+{
+  return [self extractTarBz2:sourcePath targetPath:targetPath force:force progress:progress];
+}
+
 - (NSString *)computeFileSha256:(NSString *)filePath
                            error:(NSError * _Nullable * _Nullable)error
 {

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

@@ -39,6 +39,13 @@
 #include <string>
 #include <vector>
 
+#if defined(__APPLE__)
+#include <Foundation/Foundation.h>
+#define TTS_DETECT_LOGI(fmt, ...) NSLog(@"[TtsModelDetect] " fmt, ##__VA_ARGS__)
+#else
+#define TTS_DETECT_LOGI(fmt, ...) ((void)0)
+#endif
+
 namespace sherpaonnx {
 namespace {
 
@@ -55,8 +62,8 @@ TtsModelKind ParseTtsModelType(const std::string& modelType) {
 }
 
 /** Returns true if the given kind is supported by the current paths and hints (required files present).
- *  data_dir (espeak-ng-data) is required only for Kitten and Kokoro (sherpa-onnx config Validate());
- *  VITS, Matcha, Zipvoice use it optionally; Pocket does not use it. */
+ *  data_dir (espeak-ng-data) is required for Kitten, Kokoro, and Zipvoice (Zipvoice uses MatchaTtsLexicon + espeak).
+ *  VITS and Matcha use dataDir optionally in this detector; Pocket does not use it. */
 static bool CapabilitySupportsTtsKind(
     TtsModelKind kind,
     bool hasVits,
@@ -132,6 +139,10 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     std::string tokensFile = FindFileByName(files, "tokens.txt");
     std::vector<LexiconCandidate> lexiconCandidates = FindLexiconCandidates(files, modelDir);
     std::string dataDirPath = FindDirectoryUnderRoot(files, modelDir, "espeak-ng-data");
+    TTS_DETECT_LOGI("DetectTtsModel: modelDir=%s espeak-ng dataDir=%s (empty=%d)",
+                    modelDir.c_str(),
+                    dataDirPath.empty() ? "(empty)" : dataDirPath.c_str(),
+                    (int)dataDirPath.empty());
     std::string voicesFile = FindFileByName(files, "voices.bin");
 
     std::string acousticModel = FindOnnxByAnyToken(files, {"acoustic_model", "acoustic-model"}, std::nullopt);

package/ios/model_detect/sherpa-onnx-validate-tts.mm

@@ -55,8 +55,8 @@ static const TtsFieldRequirement kZipvoiceReqs[] = {
     {"decoder",  &TtsModelPaths::decoder,  true},
     {"vocoder",  &TtsModelPaths::vocoder,  true},
     {"tokens",   &TtsModelPaths::tokens,   true},
-    {"dataDir",  &TtsModelPaths::dataDir,  false},
-    {"lexicon",  &TtsModelPaths::lexicon,  false},
+    {"dataDir",  &TtsModelPaths::dataDir,  true},
+    {"lexicon",  &TtsModelPaths::lexicon,  true},
 };
 
 // ============================================================
@@ -102,6 +102,8 @@ static const char* GetFieldHint(const char* fieldName) {
         return "Copy espeak-ng-data into the model directory.";
     if (std::strcmp(fieldName, "tokens") == 0)
         return "Ensure tokens.txt is present in the model directory.";
+    if (std::strcmp(fieldName, "lexicon") == 0)
+        return "Add lexicon.txt (or lexicon-<lang>.txt) from the official sherpa-onnx Zipvoice/Matcha release; without it the native engine aborts.";
     return nullptr;
 }
 

package/ios/online_stt/sherpa-onnx-online-stt-wrapper.h

@@ -49,6 +49,7 @@ public:
         const std::string& provider,
         const std::string& ruleFsts,
         const std::string& ruleFars,
+        float dither,
         float blankPenalty,
         bool debug,
         bool rule1MustContainNonSilence,

package/ios/online_stt/sherpa-onnx-online-stt-wrapper.mm

@@ -103,6 +103,7 @@ OnlineSttInitResult OnlineSttWrapper::initialize(
     const std::string& provider,
     const std::string& ruleFsts,
     const std::string& ruleFars,
+    float dither,
     float blankPenalty,
     bool debug,
     // NOTE: rule*MustContainNonSilence, rule1/2MinUtteranceLength, and
@@ -138,6 +139,9 @@ OnlineSttInitResult OnlineSttWrapper::initialize(
     sherpa_onnx::cxx::OnlineRecognizerConfig config;
     config.feat_config.sample_rate = 16000;
     config.feat_config.feature_dim = 80;
+    // Dither is not exposed on cxx::FeatureConfig in the bundled sherpa-onnx headers;
+    // Android applies it via JNI. iOS uses the library default (no dither from JS).
+    (void)dither;
     config.decoding_method = decodingMethod.empty() ? "greedy_search" : decodingMethod;
     config.max_active_paths = maxActivePaths;
     config.enable_endpoint = enableEndpoint;

package/ios/tts/sherpa-onnx-tts-wrapper.h

@@ -2,21 +2,35 @@
 #define SHERPA_ONNX_TTS_WRAPPER_H
 
 #include "sherpa-onnx-common.h"
+#include "sherpa-onnx-model-detect.h"
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <optional>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 namespace sherpaonnx {
 
+/** Voice cloning / zero-shot options for Zipvoice and Pocket (matches JS referenceAudio + referenceSampleRate + optional fields). */
+struct VoiceCloneOptions {
+    std::vector<float> reference_audio;
+    int32_t reference_sample_rate = 0;
+    std::string reference_text;
+    int32_t num_steps = 5;
+    float silence_scale = 0.2f;
+    std::unordered_map<std::string, std::string> extra;
+};
+
 /**
  * Result of TTS initialization.
  */
 struct TtsInitializeResult {
     bool success;
     std::vector<DetectedModel> detectedModels;  // List of detected models with type and path
+    /** When success is false, optional error message (e.g. from DetectTtsModel or OfflineTts::Create). */
+    std::string error;
 };
 
 /**
@@ -59,6 +73,17 @@ public:
         float speed = 1.0f
     );
 
+    /**
+     * When cloning is set (non-empty reference_audio and reference_sample_rate > 0), calls
+     * OfflineTts::Generate(text, GenerationConfig). Otherwise same as generate(text, sid, speed).
+     */
+    AudioResult generate(
+        const std::string& text,
+        int32_t sid,
+        float speed,
+        const std::optional<VoiceCloneOptions>& cloning
+    );
+
     bool generateStream(
         const std::string& text,
         int32_t sid,
@@ -66,6 +91,15 @@ public:
         const TtsStreamCallback& callback
     );
 
+    /** Pocket: streaming with reference audio. Zipvoice + cloning is not supported (match Android). */
+    bool generateStream(
+        const std::string& text,
+        int32_t sid,
+        float speed,
+        const TtsStreamCallback& callback,
+        const std::optional<VoiceCloneOptions>& cloning
+    );
+
     static bool saveToWavFile(
         const std::vector<float>& samples,
         int32_t sampleRate,
@@ -78,6 +112,9 @@ public:
 
     bool isInitialized() const;
 
+    /** Model kind from last successful initialize() (for voice-cloning validation). */
+    TtsModelKind getModelKind() const;
+
     void release();
 
 private: