react-native-suuqencode 0.1.5 → 0.1.7

package/Suuqencode.podspec

@@ -15,7 +15,7 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm,cpp}"
   s.private_header_files = "ios/**/*.h"
-  s.frameworks = "VideoToolbox", "CoreMedia", "CoreFoundation"
+  s.frameworks = "VideoToolbox", "CoreMedia", "CoreFoundation", "AudioToolbox", "AVFoundation"
   s.dependency "SuuqeDMABuf"
 
   install_modules_dependencies(s)

package/ios/Suuqencode.h

@@ -1,6 +1,7 @@
 #import <React/RCTEventEmitter.h>
 #import <AVFoundation/AVFoundation.h>
 #import <VideoToolbox/VideoToolbox.h>
+#import <AudioToolbox/AudioToolbox.h>
 
 @interface Suuqencode : RCTEventEmitter
 

package/ios/Suuqencode.mm

@@ -3,10 +3,21 @@
 
 @interface Suuqencode ()
 
+// Video encoding properties
 @property(nonatomic) VTCompressionSessionRef compressionSession;
 @property(nonatomic) dispatch_queue_t encodeQueue;
 @property(nonatomic) int frameCount;
 
+// Audio recording + FLAC encoding properties
+@property(nonatomic, strong) AVAudioEngine *audioEngine;
+@property(nonatomic, strong) AVAudioConverter *pcmConverter;
+@property(nonatomic, strong) AVAudioConverter *flacConverter;
+@property(nonatomic, strong) AVAudioFormat *targetPCMFormat;
+@property(nonatomic, strong) AVAudioFormat *flacFormat;
+@property(nonatomic) dispatch_queue_t audioEncodeQueue;
+@property(nonatomic) BOOL isRecordingAudio;
+@property(nonatomic) double audioSampleRate;
+
 - (void)sendEncodedData:(NSData *)data;
 
 @end
@@ -20,6 +31,8 @@ RCT_EXPORT_MODULE()
   if (self) {
     _encodeQueue = dispatch_queue_create("com.suuqencode.encodequeue",
                                          DISPATCH_QUEUE_SERIAL);
+    _audioEncodeQueue = dispatch_queue_create("com.suuqencode.audioencodequeue",
+                                              DISPATCH_QUEUE_SERIAL);
   }
   return self;
 }
@@ -108,6 +121,8 @@ void compressionOutputCallback(void *outputCallbackRefCon,
   }
 
   Suuqencode *encoder = (__bridge Suuqencode *)outputCallbackRefCon;
+  const uint8_t startCode[] = {0x00, 0x00, 0x00, 0x01};
+  size_t startCodeSize = sizeof(startCode);
 
   bool isKeyFrame = !CFDictionaryContainsKey(
       (CFDictionaryRef)CFArrayGetValueAtIndex(
@@ -127,11 +142,15 @@ void compressionOutputCallback(void *outputCallbackRefCon,
     CMVideoFormatDescriptionGetH264ParameterSetAtIndex(
         format, 1, &pparameterSet, &pparameterSetSize, &pparameterSetCount, 0);
 
-    NSData *sps = [NSData dataWithBytes:sparameterSet length:sparameterSetSize];
-    NSData *pps = [NSData dataWithBytes:pparameterSet length:pparameterSetSize];
+    NSMutableData *spsData = [NSMutableData dataWithBytes:startCode
+                                                   length:startCodeSize];
+    [spsData appendBytes:sparameterSet length:sparameterSetSize];
+    [encoder sendEncodedData:spsData];
 
-    [encoder sendEncodedData:sps];
-    [encoder sendEncodedData:pps];
+    NSMutableData *ppsData = [NSMutableData dataWithBytes:startCode
+                                                   length:startCodeSize];
+    [ppsData appendBytes:pparameterSet length:pparameterSetSize];
+    [encoder sendEncodedData:ppsData];
   }
 
   CMBlockBufferRef dataBuffer = CMSampleBufferGetDataBuffer(sampleBuffer);
@@ -140,8 +159,26 @@ void compressionOutputCallback(void *outputCallbackRefCon,
   CMBlockBufferGetDataPointer(dataBuffer, 0, &length, &totalLength,
                               &dataPointer);
 
-  NSData *naluData = [NSData dataWithBytes:dataPointer length:length];
-  [encoder sendEncodedData:naluData];
+  // Parse AVCC NAL units and convert to Annex B
+  size_t bufferOffset = 0;
+  static const int AVCCHeaderLength = 4;
+
+  while (bufferOffset < totalLength - AVCCHeaderLength) {
+    uint32_t NALUnitLength = 0;
+    memcpy(&NALUnitLength, dataPointer + bufferOffset, AVCCHeaderLength);
+
+    // Convert big-endian length to host endianness
+    NALUnitLength = CFSwapInt32BigToHost(NALUnitLength);
+
+    NSMutableData *naluData = [NSMutableData dataWithBytes:startCode
+                                                    length:startCodeSize];
+    [naluData appendBytes:(dataPointer + bufferOffset + AVCCHeaderLength)
+                   length:NALUnitLength];
+
+    [encoder sendEncodedData:naluData];
+
+    bufferOffset += AVCCHeaderLength + NALUnitLength;
+  }
 }
 
 - (void)sendEncodedData:(NSData *)data {
@@ -149,8 +186,297 @@ void compressionOutputCallback(void *outputCallbackRefCon,
   [self sendEventWithName:@"onEncodedData" body:base64Encoded];
 }
 
+#pragma mark - Audio Recording & FLAC Encoding
+
+RCT_EXPORT_METHOD(startAudioEncode:(double)sampleRate
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  if (self.isRecordingAudio) {
+    reject(@"ALREADY_RECORDING", @"Audio recording is already in progress", nil);
+    return;
+  }
+
+  self.audioSampleRate = sampleRate > 0 ? sampleRate : 16000.0;
+
+  AVAudioSession *session = [AVAudioSession sharedInstance];
+  [session requestRecordPermission:^(BOOL granted) {
+    if (!granted) {
+      reject(@"PERMISSION_DENIED", @"Microphone permission was denied", nil);
+      return;
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      NSError *setupError = nil;
+      BOOL success = [self setupAudioCaptureWithError:&setupError];
+      if (!success) {
+        reject(@"SETUP_FAILED",
+               setupError ? setupError.localizedDescription : @"Failed to set up audio capture",
+               setupError);
+        return;
+      }
+
+      // Emit format info so the receiver knows the audio parameters
+      NSDictionary *formatInfo = @{
+        @"sampleRate": @(self.audioSampleRate),
+        @"channels": @(1),
+        @"bitsPerSample": @(16),
+        @"codec": @"flac"
+      };
+      [self sendEventWithName:@"onAudioFormatInfo" body:formatInfo];
+      resolve(@(YES));
+    });
+  }];
+}
+
+RCT_EXPORT_METHOD(stopAudioEncode) {
+  if (!self.isRecordingAudio) {
+    return;
+  }
+
+  self.isRecordingAudio = NO;
+
+  if (self.audioEngine) {
+    [self.audioEngine.inputNode removeTapOnBus:0];
+    [self.audioEngine stop];
+    self.audioEngine = nil;
+  }
+
+  self.pcmConverter = nil;
+  self.flacConverter = nil;
+  self.targetPCMFormat = nil;
+  self.flacFormat = nil;
+}
+
+- (BOOL)setupAudioCaptureWithError:(NSError **)outError {
+  AVAudioSession *session = [AVAudioSession sharedInstance];
+  NSError *error = nil;
+
+  [session setCategory:AVAudioSessionCategoryPlayAndRecord
+           withOptions:(AVAudioSessionCategoryOptionDefaultToSpeaker |
+                        AVAudioSessionCategoryOptionAllowBluetooth)
+                 error:&error];
+  if (error) {
+    if (outError) *outError = error;
+    return NO;
+  }
+
+  [session setActive:YES error:&error];
+  if (error) {
+    if (outError) *outError = error;
+    return NO;
+  }
+
+  // Initialize audio engine
+  self.audioEngine = [[AVAudioEngine alloc] init];
+  AVAudioInputNode *inputNode = self.audioEngine.inputNode;
+  AVAudioFormat *hardwareFormat = [inputNode outputFormatForBus:0];
+
+  if (!hardwareFormat || hardwareFormat.sampleRate == 0) {
+    if (outError) {
+      *outError = [NSError errorWithDomain:@"SuuqencodeAudio"
+                                      code:-1
+                                  userInfo:@{NSLocalizedDescriptionKey: @"Could not get hardware audio format"}];
+    }
+    return NO;
+  }
+
+  // Target PCM format: 16-bit signed integer, mono, at requested sample rate
+  AudioStreamBasicDescription pcmASBD = {};
+  pcmASBD.mFormatID = kAudioFormatLinearPCM;
+  pcmASBD.mSampleRate = self.audioSampleRate;
+  pcmASBD.mChannelsPerFrame = 1;
+  pcmASBD.mBitsPerChannel = 16;
+  pcmASBD.mBytesPerFrame = 2;
+  pcmASBD.mBytesPerPacket = 2;
+  pcmASBD.mFramesPerPacket = 1;
+  pcmASBD.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
+
+  self.targetPCMFormat = [[AVAudioFormat alloc] initWithStreamDescription:&pcmASBD];
+  if (!self.targetPCMFormat) {
+    if (outError) {
+      *outError = [NSError errorWithDomain:@"SuuqencodeAudio"
+                                      code:-2
+                                  userInfo:@{NSLocalizedDescriptionKey: @"Could not create target PCM format"}];
+    }
+    return NO;
+  }
+
+  // FLAC output format
+  AudioStreamBasicDescription flacASBD = {};
+  flacASBD.mFormatID = kAudioFormatFLAC;
+  flacASBD.mSampleRate = self.audioSampleRate;
+  flacASBD.mChannelsPerFrame = 1;
+  flacASBD.mBitsPerChannel = 16;
+  flacASBD.mFramesPerPacket = 0;
+  flacASBD.mBytesPerPacket = 0;
+  flacASBD.mBytesPerFrame = 0;
+  flacASBD.mFormatFlags = 0;
+
+  self.flacFormat = [[AVAudioFormat alloc] initWithStreamDescription:&flacASBD];
+  if (!self.flacFormat) {
+    if (outError) {
+      *outError = [NSError errorWithDomain:@"SuuqencodeAudio"
+                                      code:-3
+                                  userInfo:@{NSLocalizedDescriptionKey: @"FLAC audio format not available on this device"}];
+    }
+    return NO;
+  }
+
+  // PCM resampler: hardware format → target PCM
+  self.pcmConverter = [[AVAudioConverter alloc] initFromFormat:hardwareFormat
+                                                     toFormat:self.targetPCMFormat];
+  if (!self.pcmConverter) {
+    if (outError) {
+      *outError = [NSError errorWithDomain:@"SuuqencodeAudio"
+                                      code:-4
+                                  userInfo:@{NSLocalizedDescriptionKey: @"Could not create PCM resampler"}];
+    }
+    return NO;
+  }
+
+  // FLAC encoder: target PCM → FLAC
+  self.flacConverter = [[AVAudioConverter alloc] initFromFormat:self.targetPCMFormat
+                                                      toFormat:self.flacFormat];
+  if (!self.flacConverter) {
+    if (outError) {
+      *outError = [NSError errorWithDomain:@"SuuqencodeAudio"
+                                      code:-5
+                                  userInfo:@{NSLocalizedDescriptionKey: @"Could not create FLAC encoder — FLAC encoding may not be supported on this OS version"}];
+    }
+    return NO;
+  }
+
+  // Install tap on the input node using the hardware's native format
+  __weak Suuqencode *weakSelf = self;
+  [inputNode installTapOnBus:0
+                  bufferSize:4096
+                      format:hardwareFormat
+                       block:^(AVAudioPCMBuffer * _Nonnull buffer, AVAudioTime * _Nonnull when) {
+    __strong Suuqencode *strongSelf = weakSelf;
+    if (!strongSelf || !strongSelf.isRecordingAudio) return;
+
+    // Copy the buffer so we can safely dispatch off the realtime audio thread
+    AVAudioPCMBuffer *bufferCopy = [[AVAudioPCMBuffer alloc] initWithPCMFormat:buffer.format
+                                                                 frameCapacity:buffer.frameLength];
+    bufferCopy.frameLength = buffer.frameLength;
+
+    if (hardwareFormat.commonFormat == AVAudioPCMFormatFloat32) {
+      for (AVAudioChannelCount ch = 0; ch < hardwareFormat.channelCount; ch++) {
+        memcpy(bufferCopy.floatChannelData[ch],
+               buffer.floatChannelData[ch],
+               buffer.frameLength * sizeof(float));
+      }
+    } else if (hardwareFormat.commonFormat == AVAudioPCMFormatInt16) {
+      for (AVAudioChannelCount ch = 0; ch < hardwareFormat.channelCount; ch++) {
+        memcpy(bufferCopy.int16ChannelData[ch],
+               buffer.int16ChannelData[ch],
+               buffer.frameLength * sizeof(int16_t));
+      }
+    } else if (hardwareFormat.commonFormat == AVAudioPCMFormatInt32) {
+      for (AVAudioChannelCount ch = 0; ch < hardwareFormat.channelCount; ch++) {
+        memcpy(bufferCopy.int32ChannelData[ch],
+               buffer.int32ChannelData[ch],
+               buffer.frameLength * sizeof(int32_t));
+      }
+    } else {
+      // Float64 or other — fallback to raw bytes
+      size_t byteCount = buffer.frameLength * hardwareFormat.streamDescription->mBytesPerFrame;
+      for (AVAudioChannelCount ch = 0; ch < hardwareFormat.channelCount; ch++) {
+        memcpy(bufferCopy.floatChannelData[ch],
+               buffer.floatChannelData[ch],
+               byteCount);
+      }
+    }
+
+    dispatch_async(strongSelf.audioEncodeQueue, ^{
+      [strongSelf processAudioBuffer:bufferCopy];
+    });
+  }];
+
+  // Start the engine
+  [self.audioEngine startAndReturnError:&error];
+  if (error) {
+    if (outError) *outError = error;
+    [inputNode removeTapOnBus:0];
+    self.audioEngine = nil;
+    return NO;
+  }
+
+  self.isRecordingAudio = YES;
+  return YES;
+}
+
+- (void)processAudioBuffer:(AVAudioPCMBuffer *)inputBuffer {
+  if (!self.isRecordingAudio) return;
+
+  // Step 1: Resample hardware PCM → target PCM (16kHz mono int16)
+  double sampleRateRatio = self.targetPCMFormat.sampleRate / inputBuffer.format.sampleRate;
+  AVAudioFrameCount outputFrameCapacity = (AVAudioFrameCount)ceil(inputBuffer.frameLength * sampleRateRatio) + 16;
+
+  AVAudioPCMBuffer *pcmBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.targetPCMFormat
+                                                              frameCapacity:outputFrameCapacity];
+  NSError *error = nil;
+  __block BOOL pcmInputProvided = NO;
+
+  AVAudioConverterOutputStatus pcmStatus = [self.pcmConverter
+      convertToBuffer:pcmBuffer
+                error:&error
+    withInputFromBlock:^AVAudioBuffer * _Nullable(AVAudioPacketCount inNumberOfPackets,
+                                                   AVAudioConverterInputStatus *outStatus) {
+      if (pcmInputProvided) {
+        *outStatus = AVAudioConverterInputStatus_NoDataNow;
+        return nil;
+      }
+      pcmInputProvided = YES;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return inputBuffer;
+    }];
+
+  if (error) {
+    NSLog(@"[Suuqencode] PCM resampling error: %@", error);
+    return;
+  }
+  if (pcmBuffer.frameLength == 0) {
+    return;
+  }
+
+  // Step 2: Encode PCM → FLAC
+  AVAudioCompressedBuffer *flacBuffer =
+      [[AVAudioCompressedBuffer alloc] initWithFormat:self.flacFormat
+                                       packetCapacity:8
+                                    maximumPacketSize:65536];
+
+  __block BOOL flacInputProvided = NO;
+  AVAudioConverterOutputStatus flacStatus = [self.flacConverter
+      convertToBuffer:flacBuffer
+                error:&error
+    withInputFromBlock:^AVAudioBuffer * _Nullable(AVAudioPacketCount inNumberOfPackets,
+                                                   AVAudioConverterInputStatus *outStatus) {
+      if (flacInputProvided) {
+        *outStatus = AVAudioConverterInputStatus_NoDataNow;
+        return nil;
+      }
+      flacInputProvided = YES;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return pcmBuffer;
+    }];
+
+  if (error) {
+    NSLog(@"[Suuqencode] FLAC encoding error: %@", error);
+    return;
+  }
+
+  if ((flacStatus == AVAudioConverterOutputStatus_HaveData ||
+       flacStatus == AVAudioConverterOutputStatus_InputRanDry) &&
+      flacBuffer.byteLength > 0) {
+    NSData *flacData = [NSData dataWithBytes:flacBuffer.data length:flacBuffer.byteLength];
+    NSString *base64 = [flacData base64EncodedStringWithOptions:0];
+    [self sendEventWithName:@"onAudioEncodedData" body:base64];
+  }
+}
+
 - (NSArray<NSString *> *)supportedEvents {
-  return @[ @"onEncodedData" ];
+  return @[ @"onEncodedData", @"onAudioEncodedData", @"onAudioFormatInfo" ];
 }
 
 + (BOOL)requiresMainQueueSetup {

package/lib/module/NativeSuuqencode.js.map

@@ -1 +1 @@
-{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeSuuqencode.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAQpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,YAAY,CAAC","ignoreList":[]}
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeSuuqencode.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAUpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,YAAY,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -16,4 +16,44 @@ export function addEncodedDataListener(callback) {
     subscription.remove();
   };
 }
+/**
+ * Start recording from the microphone and encoding audio to FLAC in real time.
+ * Each encoded FLAC packet is base64-encoded and emitted via the onAudioEncodedData event.
+ * @param sampleRate Target sample rate in Hz (default: 16000)
+ * @returns Promise that resolves when recording has started successfully
+ */
+export function startAudioEncode(sampleRate = 16000) {
+  return Suuqencode.startAudioEncode(sampleRate);
+}
+
+/**
+ * Stop audio recording and FLAC encoding.
+ */
+export function stopAudioEncode() {
+  Suuqencode.stopAudioEncode();
+}
+
+/**
+ * Listen for base64-encoded FLAC audio packets.
+ */
+export function addAudioDataListener(callback) {
+  const subscription = eventEmitter.addListener('onAudioEncodedData', data => {
+    callback(data);
+  });
+  return () => {
+    subscription.remove();
+  };
+}
+
+/**
+ * Listen for audio format info emitted once at the start of recording.
+ */
+export function addAudioFormatInfoListener(callback) {
+  const subscription = eventEmitter.addListener('onAudioFormatInfo', info => {
+    callback(info);
+  });
+  return () => {
+    subscription.remove();
+  };
+}
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NativeModules","NativeEventEmitter","Suuqencode","eventEmitter","startEncode","addEncodedDataListener","callback","subscription","addListener","data","remove"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,aAAa,EAAEC,kBAAkB,QAAQ,cAAc;AAEhE,MAAM;EAAEC;AAAW,CAAC,GAAGF,aAAa;AAEpC,MAAMG,YAAY,GAAG,IAAIF,kBAAkB,CAACC,UAAU,CAAC;AAEvD,OAAO,SAASE,WAAWA,CAAA,EAAS;EAClCF,UAAU,CAACE,WAAW,CAAC,CAAC;AAC1B;AAEA,OAAO,SAASC,sBAAsBA,CACpCC,QAAgC,EACpB;EACZ,MAAMC,YAAY,GAAGJ,YAAY,CAACK,WAAW,CAC3C,eAAe,EACdC,IAAS,IAAK;IACbH,QAAQ,CAACG,IAAc,CAAC;EAC1B,CACF,CAAC;EACD,OAAO,MAAM;IACXF,YAAY,CAACG,MAAM,CAAC,CAAC;EACvB,CAAC;AACH","ignoreList":[]}
+{"version":3,"names":["NativeModules","NativeEventEmitter","Suuqencode","eventEmitter","startEncode","addEncodedDataListener","callback","subscription","addListener","data","remove","startAudioEncode","sampleRate","stopAudioEncode","addAudioDataListener","addAudioFormatInfoListener","info"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,aAAa,EAAEC,kBAAkB,QAAQ,cAAc;AAEhE,MAAM;EAAEC;AAAW,CAAC,GAAGF,aAAa;AAEpC,MAAMG,YAAY,GAAG,IAAIF,kBAAkB,CAACC,UAAU,CAAC;AAEvD,OAAO,SAASE,WAAWA,CAAA,EAAS;EAClCF,UAAU,CAACE,WAAW,CAAC,CAAC;AAC1B;AAEA,OAAO,SAASC,sBAAsBA,CACpCC,QAAgC,EACpB;EACZ,MAAMC,YAAY,GAAGJ,YAAY,CAACK,WAAW,CAC3C,eAAe,EACdC,IAAS,IAAK;IACbH,QAAQ,CAACG,IAAc,CAAC;EAC1B,CACF,CAAC;EACD,OAAO,MAAM;IACXF,YAAY,CAACG,MAAM,CAAC,CAAC;EACvB,CAAC;AACH;AASA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,gBAAgBA,CAACC,UAAkB,GAAG,KAAK,EAAoB;EAC7E,OAAOV,UAAU,CAACS,gBAAgB,CAACC,UAAU,CAAC;AAChD;;AAEA;AACA;AACA;AACA,OAAO,SAASC,eAAeA,CAAA,EAAS;EACtCX,UAAU,CAACW,eAAe,CAAC,CAAC;AAC9B;;AAEA;AACA;AACA;AACA,OAAO,SAASC,oBAAoBA,CAClCR,QAAgC,EACpB;EACZ,MAAMC,YAAY,GAAGJ,YAAY,CAACK,WAAW,CAC3C,oBAAoB,EACnBC,IAAS,IAAK;IACbH,QAAQ,CAACG,IAAc,CAAC;EAC1B,CACF,CAAC;EACD,OAAO,MAAM;IACXF,YAAY,CAACG,MAAM,CAAC,CAAC;EACvB,CAAC;AACH;;AAEA;AACA;AACA;AACA,OAAO,SAASK,0BAA0BA,CACxCT,QAAyC,EAC7B;EACZ,MAAMC,YAAY,GAAGJ,YAAY,CAACK,WAAW,CAC3C,mBAAmB,EAClBQ,IAAS,IAAK;IACbV,QAAQ,CAACU,IAAuB,CAAC;EACnC,CACF,CAAC;EACD,OAAO,MAAM;IACXT,YAAY,CAACG,MAAM,CAAC,CAAC;EACvB,CAAC;AACH","ignoreList":[]}

package/lib/typescript/src/NativeSuuqencode.d.ts

@@ -1,6 +1,8 @@
 import { type TurboModule } from 'react-native';
 export interface Spec extends TurboModule {
     startEncode(): void;
+    startAudioEncode(sampleRate: number): Promise<boolean>;
+    stopAudioEncode(): void;
     addListener(eventName: string): void;
     removeListeners(count: number): void;
 }

package/lib/typescript/src/NativeSuuqencode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeSuuqencode.d.ts","sourceRoot":"","sources":["../../../src/NativeSuuqencode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,WAAW,IAAI,IAAI,CAAC;IACpB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;;AAED,wBAAoE"}
+{"version":3,"file":"NativeSuuqencode.d.ts","sourceRoot":"","sources":["../../../src/NativeSuuqencode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,WAAW,IAAI,IAAI,CAAC;IACpB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,eAAe,IAAI,IAAI,CAAC;IACxB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;;AAED,wBAAoE"}

package/lib/typescript/src/index.d.ts

@@ -1,3 +1,28 @@
 export declare function startEncode(): void;
 export declare function addEncodedDataListener(callback: (data: string) => void): () => void;
+export interface AudioFormatInfo {
+    sampleRate: number;
+    channels: number;
+    bitsPerSample: number;
+    codec: string;
+}
+/**
+ * Start recording from the microphone and encoding audio to FLAC in real time.
+ * Each encoded FLAC packet is base64-encoded and emitted via the onAudioEncodedData event.
+ * @param sampleRate Target sample rate in Hz (default: 16000)
+ * @returns Promise that resolves when recording has started successfully
+ */
+export declare function startAudioEncode(sampleRate?: number): Promise<boolean>;
+/**
+ * Stop audio recording and FLAC encoding.
+ */
+export declare function stopAudioEncode(): void;
+/**
+ * Listen for base64-encoded FLAC audio packets.
+ */
+export declare function addAudioDataListener(callback: (data: string) => void): () => void;
+/**
+ * Listen for audio format info emitted once at the start of recording.
+ */
+export declare function addAudioFormatInfoListener(callback: (info: AudioFormatInfo) => void): () => void;
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAMA,wBAAgB,WAAW,IAAI,IAAI,CAElC;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC/B,MAAM,IAAI,CAUZ"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAMA,wBAAgB,WAAW,IAAI,IAAI,CAElC;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC/B,MAAM,IAAI,CAUZ;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,GAAE,MAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAE7E;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC/B,MAAM,IAAI,CAUZ;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,GACxC,MAAM,IAAI,CAUZ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-suuqencode",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "h264 hardware encode support for iOS, developed by Suuqe Llc.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/NativeSuuqencode.ts

@@ -2,6 +2,8 @@ import { TurboModuleRegistry, type TurboModule } from 'react-native';
 
 export interface Spec extends TurboModule {
   startEncode(): void;
+  startAudioEncode(sampleRate: number): Promise<boolean>;
+  stopAudioEncode(): void;
   addListener(eventName: string): void;
   removeListeners(count: number): void;
 }

package/src/index.tsx

@@ -21,3 +21,61 @@ export function addEncodedDataListener(
     subscription.remove();
   };
 }
+
+export interface AudioFormatInfo {
+  sampleRate: number;
+  channels: number;
+  bitsPerSample: number;
+  codec: string;
+}
+
+/**
+ * Start recording from the microphone and encoding audio to FLAC in real time.
+ * Each encoded FLAC packet is base64-encoded and emitted via the onAudioEncodedData event.
+ * @param sampleRate Target sample rate in Hz (default: 16000)
+ * @returns Promise that resolves when recording has started successfully
+ */
+export function startAudioEncode(sampleRate: number = 16000): Promise<boolean> {
+  return Suuqencode.startAudioEncode(sampleRate);
+}
+
+/**
+ * Stop audio recording and FLAC encoding.
+ */
+export function stopAudioEncode(): void {
+  Suuqencode.stopAudioEncode();
+}
+
+/**
+ * Listen for base64-encoded FLAC audio packets.
+ */
+export function addAudioDataListener(
+  callback: (data: string) => void
+): () => void {
+  const subscription = eventEmitter.addListener(
+    'onAudioEncodedData',
+    (data: any) => {
+      callback(data as string);
+    }
+  );
+  return () => {
+    subscription.remove();
+  };
+}
+
+/**
+ * Listen for audio format info emitted once at the start of recording.
+ */
+export function addAudioFormatInfoListener(
+  callback: (info: AudioFormatInfo) => void
+): () => void {
+  const subscription = eventEmitter.addListener(
+    'onAudioFormatInfo',
+    (info: any) => {
+      callback(info as AudioFormatInfo);
+    }
+  );
+  return () => {
+    subscription.remove();
+  };
+}