react-native-davoice-tts 1.0.218 → 1.0.220

package/TTSRNBridge.podspec

@@ -2,7 +2,7 @@ require 'json'
 
 Pod::Spec.new do |s|
     s.name         = "TTSRNBridge"
-    s.version      = "1.0.91" # Update to your package version
+    s.version      = "1.0.93" # Update to your package version
     s.summary      = "TTS for React Native."
     s.description  = <<-DESC
                      A React Native module for tts .

package/ios/SpeechBridge/SpeechBridge.m

@@ -2,10 +2,102 @@
 #import "SpeechBridge.h"
 #import <React/RCTLog.h>
 #import <React/RCTConvert.h>
+#import <AudioToolbox/AudioToolbox.h>
 
 // Import your Swift classes (names as in your project)
 #import <DaVoiceTTS/DaVoiceTTS-Swift.h>   // DaVoiceTTS + STT live here in your setup
 
+
+static NSData *SB_Base64Decode(NSString *b64) {
+  if (!b64 || (id)b64 == [NSNull null]) return nil;
+  return [[NSData alloc] initWithBase64EncodedString:b64 options:0];
+}
+
+// Make a mono Float32 AVAudioPCMBuffer from raw PCM payload (i16 or f32).
+// We accept either interleaved or non-interleaved input and mixdown to mono
+// (DaVoiceTTS.playBuffer will resample / normalize as needed).
+static AVAudioPCMBuffer *SB_MakeMonoF32Buffer(NSData *raw,
+                                              double sampleRate,
+                                              NSString *fmt,      // "i16" | "f32"
+                                              NSInteger channels, // >= 1
+                                              BOOL interleaved)
+{
+  if (!raw || raw.length == 0 || channels < 1) return nil;
+
+  // Target: mono float32, non-interleaved
+  AVAudioFormat *dstFmt = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:sampleRate channels:1];
+  NSUInteger frameCount = 0;
+
+  if ([fmt.lowercaseString isEqualToString:@"i16"]) {
+    // Each sample is 2 bytes
+    const NSUInteger bytesPerSample = 2;
+    if (raw.length % (bytesPerSample * channels) != 0) return nil;
+    frameCount = raw.length / (bytesPerSample * channels);
+
+    AVAudioPCMBuffer *buf = [[AVAudioPCMBuffer alloc] initWithPCMFormat:dstFmt frameCapacity:(AVAudioFrameCount)frameCount];
+    buf.frameLength = (AVAudioFrameCount)frameCount;
+
+    const int16_t *in = (const int16_t *)raw.bytes;
+    float *out = buf.floatChannelData[0];
+    const float scale = 1.0f / 32768.0f;
+
+    if (interleaved || channels == 1) {
+      // Interleaved: [c0,c1,.., c0,c1,..]
+      for (NSUInteger f = 0; f < frameCount; ++f) {
+        int64_t acc = 0;
+        for (NSInteger ch = 0; ch < channels; ++ch) {
+          acc += in[f*channels + ch];
+        }
+        out[f] = (float)(acc / (double)channels) * scale;
+      }
+    } else {
+      // Non-interleaved planar i16 (rare): [all c0][all c1]…
+      const NSUInteger planeLen = frameCount;
+      for (NSUInteger f = 0; f < frameCount; ++f) {
+        int64_t acc = 0;
+        for (NSInteger ch = 0; ch < channels; ++ch) {
+          acc += in[ch*planeLen + f];
+        }
+        out[f] = (float)(acc / (double)channels) * scale;
+      }
+    }
+    return buf;
+  }
+
+  // f32 path
+  if (![fmt.lowercaseString isEqualToString:@"f32"]) return nil;
+  const NSUInteger bytesPerSample = 4;
+  if (raw.length % (bytesPerSample * channels) != 0) return nil;
+  frameCount = raw.length / (bytesPerSample * channels);
+
+  AVAudioPCMBuffer *buf = [[AVAudioPCMBuffer alloc] initWithPCMFormat:dstFmt frameCapacity:(AVAudioFrameCount)frameCount];
+  buf.frameLength = (AVAudioFrameCount)frameCount;
+
+  const float *in = (const float *)raw.bytes;
+  float *out = buf.floatChannelData[0];
+
+  if (interleaved || channels == 1) {
+    for (NSUInteger f = 0; f < frameCount; ++f) {
+      double acc = 0.0;
+      for (NSInteger ch = 0; ch < channels; ++ch) {
+        acc += in[f*channels + ch];
+      }
+      out[f] = (float)(acc / (double)channels);
+    }
+  } else {
+    // Planar f32: [all c0][all c1]…
+    const NSUInteger planeLen = frameCount;
+    for (NSUInteger f = 0; f < frameCount; ++f) {
+      double acc = 0.0;
+      for (NSInteger ch = 0; ch < channels; ++ch) {
+        acc += in[ch*planeLen + f];
+      }
+      out[f] = (float)(acc / (double)channels);
+    }
+  }
+  return buf;
+}
+
 @interface SpeechBridge () <STTDelegate>
 @property (nonatomic, strong, nullable) STT *stt;
 @property (nonatomic, strong, nullable) DaVoiceTTS *tts;
@@ -233,4 +325,65 @@ RCT_EXPORT_METHOD(stopSpeaking:(RCTPromiseResolveBlock)resolve
   resolve(@"Stopped");
 }
 
+/// playWav(pathOrURL: string, markAsLast?: boolean)
+RCT_EXPORT_METHOD(playWav:(NSString *)pathOrURL
+                  markAsLast:(nonnull NSNumber *)markAsLast
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  if (!self.tts) { reject(@"no_tts", @"Call initAll first", nil); return; }
+
+  NSURL *url = nil;
+  if ([pathOrURL hasPrefix:@"http://"] || [pathOrURL hasPrefix:@"https://"] || [pathOrURL hasPrefix:@"file://"]) {
+    url = [NSURL URLWithString:pathOrURL];
+    if (url.isFileURL == NO) {
+      // For remote URLs: you’d normally download first. Keep it simple: reject.
+      reject(@"unsupported_url", @"Remote URLs not supported. Download to a file path first.", nil);
+      return;
+    }
+  } else {
+    url = [NSURL fileURLWithPath:pathOrURL];
+  }
+
+  if (![[NSFileManager defaultManager] fileExistsAtPath:url.path]) {
+    reject(@"file_missing", @"WAV file does not exist at path", nil);
+    return;
+  }
+
+  // Pass through to DaVoiceTTS (which routes via AEC graph/queue)
+  [self.tts playWav:url markAsLastUtterance:markAsLast.boolValue];
+  resolve(@"queued");
+}
+
+/// playBuffer(desc: { base64, sampleRate, channels?, interleaved?, format: "i16" | "f32", markAsLast? })
+RCT_EXPORT_METHOD(playBuffer:(NSDictionary *)desc
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  if (!self.tts) { reject(@"no_tts", @"Call initAll first", nil); return; }
+
+  // Validate inputs
+  NSString *b64 = [RCTConvert NSString:desc[@"base64"]];
+  NSNumber *srN = [RCTConvert NSNumber:desc[@"sampleRate"]];
+  NSString *fmt = [RCTConvert NSString:desc[@"format"]];
+  NSNumber *chN = desc[@"channels"] ? [RCTConvert NSNumber:desc[@"channels"]] : @(1);
+  NSNumber *ilN = desc[@"interleaved"] ? [RCTConvert NSNumber:desc[@"interleaved"]] : @(YES);
+  NSNumber *markLastN = desc[@"markAsLast"] ? [RCTConvert NSNumber:desc[@"markAsLast"]] : @(YES);
+
+  if (!b64 || !srN || !fmt) {
+    reject(@"invalid_args", @"Missing one of base64/sampleRate/format", nil);
+    return;
+  }
+
+  NSData *raw = SB_Base64Decode(b64);
+  if (!raw) { reject(@"bad_base64", @"Could not decode base64 payload", nil); return; }
+
+  AVAudioPCMBuffer *buf = SB_MakeMonoF32Buffer(raw, srN.doubleValue, fmt, chN.integerValue, ilN.boolValue);
+  if (!buf) { reject(@"bad_buffer", @"Unsupported PCM layout or empty data", nil); return; }
+
+  // Hand over to DaVoiceTTS (it will resample/normalize and enqueue via AEC graph)
+  [self.tts playBuffer:buf markAsLastUtterance:markLastN.boolValue];
+  resolve(@"queued");
+}
+
 @end

package/ios/TTSRNBridge/DavoiceTTS.xcframework/ios-arm64/DavoiceTTS.framework/Headers/DavoiceTTS-Swift.h

@@ -322,6 +322,13 @@ SWIFT_CLASS("_TtC10DavoiceTTS10DaVoiceTTS")
 - (void)destroy;
 - (void)speak:(NSString * _Nonnull)txt sid:(int32_t)sid;
 - (AVAudioPCMBuffer * _Nullable)synthesize_top:(NSString * _Nonnull)_text speakerId:(int32_t)speakerId token:(NSUUID * _Nonnull)token error:(NSError * _Nullable * _Nullable)error SWIFT_WARN_UNUSED_RESULT;
+/// Queue an external WAV file for playback via the same AEC path/queue used by speak().
+/// If called repeatedly, items are queued in order. <code>onLastUtteranceFinished</code> fires
+/// after THIS file finishes (unless you enqueue more later and mark those as last).
+- (void)playWav:(NSURL * _Nonnull)url markAsLastUtterance:(BOOL)markAsLastUtterance;
+/// Queue an in-memory PCM buffer (any format) for playback via the same AEC path/queue.
+/// We resample/normalize, write a temp WAV, then enqueue it (so it uses the engine hook).
+- (void)playBuffer:(AVAudioPCMBuffer * _Nonnull)buffer markAsLastUtterance:(BOOL)markAsLastUtterance;
 - (nonnull instancetype)init SWIFT_UNAVAILABLE;
 + (nonnull instancetype)new SWIFT_UNAVAILABLE_MSG("-init is unavailable");
 @end