@livekit/react-native 2.5.1 → 2.6.1

package/ios/LKAudioProcessingManager.m

@@ -0,0 +1,63 @@
+#import "LKAudioProcessingManager.h"
+#import "LKAudioProcessingAdapter.h"
+
+@implementation LKAudioProcessingManager
+
++ (instancetype)sharedInstance {
+    static dispatch_once_t onceToken;
+    static LKAudioProcessingManager* sharedInstance = nil;
+    dispatch_once(&onceToken, ^{
+        sharedInstance = [[self alloc] init];
+    });
+    return sharedInstance;
+}
+
+- (instancetype)init {
+    if (self = [super init]) {
+        _audioProcessingModule = [[RTCDefaultAudioProcessingModule alloc] init];
+        _capturePostProcessingAdapter = [[LKAudioProcessingAdapter alloc] init];
+        _renderPreProcessingAdapter = [[LKAudioProcessingAdapter alloc] init];
+        _audioProcessingModule.capturePostProcessingDelegate = _capturePostProcessingAdapter;
+        _audioProcessingModule.renderPreProcessingDelegate = _renderPreProcessingAdapter;
+    }
+    return self;
+}
+
+- (void)addLocalAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer {
+  [_capturePostProcessingAdapter addAudioRenderer:renderer];
+}
+
+- (void)removeLocalAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer {
+  [_capturePostProcessingAdapter removeAudioRenderer:renderer];
+}
+
+- (void)addRemoteAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer {
+  [_renderPreProcessingAdapter addAudioRenderer:renderer];
+}
+
+- (void)removeRemoteAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer {
+  [_renderPreProcessingAdapter removeAudioRenderer:renderer];
+}
+
+- (void)addCapturePostProcessor:(nonnull id<LKExternalAudioProcessingDelegate>)processor {
+    [_capturePostProcessingAdapter addProcessing:processor];
+}
+
+- (void)removeCapturePostProcessor:(nonnull id<LKExternalAudioProcessingDelegate>)processor {
+    [_capturePostProcessingAdapter removeProcessing:processor];
+}
+
+- (void)addRenderPreProcessor:(nonnull id<LKExternalAudioProcessingDelegate>)processor {
+    [_renderPreProcessingAdapter addProcessing:processor];
+}
+
+- (void)removeRenderPreProcessor:(nonnull id<LKExternalAudioProcessingDelegate>)processor {
+    [_renderPreProcessingAdapter removeProcessing:processor];
+}
+
+- (void)clearProcessors {
+    // TODO
+}
+
+
+@end

package/ios/LiveKitReactNativeModule.swift

@@ -0,0 +1,234 @@
+import livekit_react_native_webrtc
+import AVFoundation
+import AVFAudio
+import React
+
+struct LKEvents {
+    static let kEventVolumeProcessed = "LK_VOLUME_PROCESSED";
+    static let kEventMultibandProcessed = "LK_MULTIBAND_PROCESSED";
+}
+
+@objc(LivekitReactNativeModule)
+public class LivekitReactNativeModule: RCTEventEmitter {
+    
+    // This cannot be initialized in init as self.bridge is given afterwards.
+    private var _audioRendererManager: AudioRendererManager? = nil
+    public var audioRendererManager: AudioRendererManager {
+        get {
+            if _audioRendererManager == nil {
+                _audioRendererManager = AudioRendererManager(bridge: self.bridge)
+            }
+            
+            return _audioRendererManager!
+        }
+    }
+    
+    @objc
+    public override init() {
+        super.init()
+        let config = RTCAudioSessionConfiguration()
+        config.category = AVAudioSession.Category.playAndRecord.rawValue
+        config.categoryOptions = [.allowAirPlay, .allowBluetooth, .allowBluetoothA2DP, .defaultToSpeaker]
+        config.mode = AVAudioSession.Mode.videoChat.rawValue
+        
+        RTCAudioSessionConfiguration.setWebRTC(config)
+    }
+    
+    @objc
+    override public static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    @objc
+    public static func setup() {
+        let videoEncoderFactory = RTCDefaultVideoEncoderFactory()
+        let simulcastVideoEncoderFactory = RTCVideoEncoderFactorySimulcast(primary: videoEncoderFactory, fallback: videoEncoderFactory)
+        let options = WebRTCModuleOptions.sharedInstance()
+        options.videoEncoderFactory = simulcastVideoEncoderFactory
+        options.audioProcessingModule = LKAudioProcessingManager.sharedInstance().audioProcessingModule
+    }
+    
+    @objc(configureAudio:)
+    public func configureAudio(_ config: NSDictionary) {
+        guard let iOSConfig = config["ios"] as? NSDictionary
+        else {
+            return
+        }
+        
+        let defaultOutput = iOSConfig["defaultOutput"] as? String ?? "speaker"
+        
+        let rtcConfig = RTCAudioSessionConfiguration()
+        rtcConfig.category = AVAudioSession.Category.playAndRecord.rawValue
+        
+        if (defaultOutput == "earpiece") {
+            rtcConfig.categoryOptions = [.allowAirPlay, .allowBluetooth, .allowBluetoothA2DP];
+            rtcConfig.mode = AVAudioSession.Mode.voiceChat.rawValue
+        } else {
+            rtcConfig.categoryOptions = [.allowAirPlay, .allowBluetooth, .allowBluetoothA2DP, .defaultToSpeaker]
+            rtcConfig.mode = AVAudioSession.Mode.videoChat.rawValue
+        }
+        RTCAudioSessionConfiguration.setWebRTC(rtcConfig)
+    }
+    
+    @objc(startAudioSession)
+    public func startAudioSession() {
+        // intentionally left empty
+    }
+    
+    @objc(stopAudioSession)
+    public func stopAudioSession() {
+        // intentionally left empty
+    }
+    
+    @objc(showAudioRoutePicker)
+    public func showAudioRoutePicker() {
+        if #available(iOS 11.0, *) {
+            let routePickerView = AVRoutePickerView()
+            let subviews = routePickerView.subviews
+            for subview in subviews {
+                if subview.isKind(of: UIButton.self) {
+                    let button = subview as! UIButton
+                    button.sendActions(for: .touchUpInside)
+                    break
+                }
+            }
+        }
+    }
+    
+    @objc(getAudioOutputsWithResolver:withRejecter:)
+    public func getAudioOutputs(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock){
+        resolve(["default", "force_speaker"])
+    }
+    
+    @objc(selectAudioOutput:withResolver:withRejecter:)
+    public func selectAudioOutput(_ deviceId: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        let session = AVAudioSession.sharedInstance()
+        do {
+            if (deviceId == "default") {
+                try session.overrideOutputAudioPort(.none)
+            } else if (deviceId == "force_speaker") {
+                try session.overrideOutputAudioPort(.speaker)
+            }
+        } catch {
+            reject("selectAudioOutput error", error.localizedDescription, error)
+            return
+        }
+        
+        resolve(nil)
+    }
+    
+    @objc(setAppleAudioConfiguration:)
+    public func setAppleAudioConfiguration(_ configuration: NSDictionary) {
+        let session = RTCAudioSession.sharedInstance()
+        let config = RTCAudioSessionConfiguration.webRTC()
+        
+        let appleAudioCategory = configuration["audioCategory"] as? String
+        let appleAudioCategoryOptions = configuration["audioCategoryOptions"] as? [String]
+        let appleAudioMode = configuration["audioMode"] as? String
+        
+        session.lockForConfiguration()
+        
+        var categoryChanged = false
+        
+        if let appleAudioCategoryOptions = appleAudioCategoryOptions {
+            categoryChanged = true
+            
+            var newOptions: AVAudioSession.CategoryOptions = []
+            for option in appleAudioCategoryOptions {
+                if option == "mixWithOthers" {
+                    newOptions.insert(.mixWithOthers)
+                } else if option == "duckOthers" {
+                    newOptions.insert(.duckOthers)
+                } else if option == "allowBluetooth" {
+                    newOptions.insert(.allowBluetooth)
+                } else if option == "allowBluetoothA2DP" {
+                    newOptions.insert(.allowBluetoothA2DP)
+                } else if option == "allowAirPlay" {
+                    newOptions.insert(.allowAirPlay)
+                } else if option == "defaultToSpeaker" {
+                    newOptions.insert(.defaultToSpeaker)
+                }
+            }
+            config.categoryOptions = newOptions
+        }
+        
+        if let appleAudioCategory = appleAudioCategory {
+            categoryChanged = true
+            config.category = AudioUtils.audioSessionCategoryFromString(appleAudioCategory).rawValue
+        }
+        
+        if categoryChanged {
+            do {
+                try session.setCategory(AVAudioSession.Category(rawValue: config.category), with: config.categoryOptions)
+            } catch {
+                NSLog("Error setting category: %@", error.localizedDescription)
+            }
+        }
+        
+        if let appleAudioMode = appleAudioMode {
+            let mode = AudioUtils.audioSessionModeFromString(appleAudioMode)
+            config.mode = mode.rawValue
+            do {
+                try session.setMode(mode)
+            } catch {
+                NSLog("Error setting mode: %@", error.localizedDescription)
+            }
+        }
+        
+        session.unlockForConfiguration()
+    }
+    
+    @objc(createVolumeProcessor:trackId:)
+    public func createVolumeProcessor(_ pcId: NSNumber, trackId: String) -> String {
+        let renderer = VolumeAudioRenderer(intervalMs: 40.0, eventEmitter: self)
+        let reactTag = self.audioRendererManager.registerRenderer(renderer)
+        renderer.reactTag = reactTag
+        self.audioRendererManager.attach(renderer: renderer, pcId: pcId, trackId: trackId)
+        
+        return reactTag
+    }
+
+    @objc(deleteVolumeProcessor:pcId:trackId:)
+    public func deleteVolumeProcessor(_ reactTag: String, pcId: NSNumber, trackId: String) -> Any? {
+        self.audioRendererManager.detach(rendererByTag: reactTag, pcId: pcId, trackId: trackId)
+        self.audioRendererManager.unregisterRenderer(forReactTag: reactTag)
+        
+        return nil
+    }
+    
+    @objc(createMultibandVolumeProcessor:pcId:trackId:)
+    public func createMultibandVolumeProcessor(_ options: NSDictionary, pcId: NSNumber, trackId: String) -> String {
+        let bands = (options["bands"] as? NSString)?.integerValue ?? 5
+        let minFrequency = (options["minFrequency"] as? NSString)?.floatValue ?? 1000
+        let maxFrequency = (options["maxFrequency"] as? NSString)?.floatValue ?? 8000
+        let intervalMs = (options["updateInterval"] as? NSString)?.floatValue ?? 40
+        
+        let renderer = MultibandVolumeAudioRenderer(
+            bands: bands,
+            minFrequency: minFrequency,
+            maxFrequency: maxFrequency,
+            intervalMs: intervalMs,
+            eventEmitter: self
+        )
+        let reactTag = self.audioRendererManager.registerRenderer(renderer)
+        renderer.reactTag = reactTag
+        self.audioRendererManager.attach(renderer: renderer, pcId: pcId, trackId: trackId)
+        
+        return reactTag
+    }
+    
+    @objc(deleteMultibandVolumeProcessor:pcId:trackId:)
+    public func deleteMultibandVolumeProcessor(_ reactTag: String, pcId: NSNumber, trackId: String) -> Any? {
+        self.audioRendererManager.detach(rendererByTag: reactTag, pcId: pcId, trackId: trackId)
+        self.audioRendererManager.unregisterRenderer(forReactTag: reactTag)
+        
+        return nil
+    }
+    
+    override public func supportedEvents() -> [String]! {
+        return [
+            LKEvents.kEventVolumeProcessed,
+            LKEvents.kEventMultibandProcessed,
+        ]
+    }
+}

package/ios/LivekitReactNative-Bridging-Header.h

@@ -1,2 +1,5 @@
-#import <React/RCTBridgeModule.h>
-#import <React/RCTViewManager.h>
+#import "RCTBridgeModule.h"
+#import "RCTEventEmitter.h"
+#import "RCTViewManager.h"
+#import "WebRTCModule.h"
+#import "WebRTCModule+RTCMediaStream.h"

package/ios/LivekitReactNative.h

@@ -2,13 +2,9 @@
 //  LivekitReactNative.h
 //  LivekitReactNative
 //
-//  Created by David Liu on 9/4/22.
-//  Copyright © 2022 LiveKit. All rights reserved.
+//  Copyright © 2022-2025 LiveKit. All rights reserved.
 //
-#import <React/RCTBridgeModule.h>
-
-@interface LivekitReactNative : NSObject <RCTBridgeModule>
 
+@interface LivekitReactNative : NSObject
 +(void)setup;
-
 @end

package/ios/LivekitReactNative.m

@@ -1,179 +1,16 @@
-#import "AudioUtils.h"
-#import "LivekitReactNative.h"
 #import "WebRTCModule.h"
 #import "WebRTCModuleOptions.h"
-#import <WebRTC/RTCAudioSession.h>
-#import <WebRTC/RTCAudioSessionConfiguration.h>
-#import <AVFAudio/AVFAudio.h>
-#import <AVKit/AVKit.h>
+#import "LivekitReactNative.h"
+#import "LKAudioProcessingManager.h"
 
 @implementation LivekitReactNative
-RCT_EXPORT_MODULE();
-
--(instancetype)init {
-    if(self = [super init]) {
-        
-        RTCAudioSessionConfiguration* config = [[RTCAudioSessionConfiguration alloc] init];
-        [config setCategory:AVAudioSessionCategoryPlayAndRecord];
-        [config setCategoryOptions:
-             AVAudioSessionCategoryOptionAllowAirPlay|
-             AVAudioSessionCategoryOptionAllowBluetooth|
-             AVAudioSessionCategoryOptionAllowBluetoothA2DP|
-             AVAudioSessionCategoryOptionDefaultToSpeaker
-        ];
-        [config setMode:AVAudioSessionModeVideoChat];
-        [RTCAudioSessionConfiguration setWebRTCConfiguration: config];
-        return self;
-    } else {
-        return nil;
-    }
-}
-
-+(BOOL)requiresMainQueueSetup {
-    return NO;
-}
 
 +(void)setup {
     RTCDefaultVideoEncoderFactory *videoEncoderFactory = [[RTCDefaultVideoEncoderFactory alloc] init];
     RTCVideoEncoderFactorySimulcast *simulcastVideoEncoderFactory = [[RTCVideoEncoderFactorySimulcast alloc] initWithPrimary:videoEncoderFactory fallback:videoEncoderFactory];
     WebRTCModuleOptions *options = [WebRTCModuleOptions sharedInstance];
     options.videoEncoderFactory = simulcastVideoEncoderFactory;
+    options.audioProcessingModule = LKAudioProcessingManager.sharedInstance.audioProcessingModule;
 }
 
-/// Configure default audio config for WebRTC
-RCT_EXPORT_METHOD(configureAudio:(NSDictionary *) config){
-    NSDictionary *iOSConfig = [config objectForKey:@"ios"];
-    if(iOSConfig == nil) {
-        return;
-    }
-    
-    NSString * defaultOutput = [iOSConfig objectForKey:@"defaultOutput"];
-    if (defaultOutput == nil) {
-        defaultOutput = @"speaker";
-    }
-    
-    RTCAudioSessionConfiguration* rtcConfig = [[RTCAudioSessionConfiguration alloc] init];
-    [rtcConfig setCategory:AVAudioSessionCategoryPlayAndRecord];
-    
-    if([defaultOutput isEqualToString:@"earpiece"]){
-        [rtcConfig setCategoryOptions:
-         AVAudioSessionCategoryOptionAllowAirPlay|
-         AVAudioSessionCategoryOptionAllowBluetooth|
-         AVAudioSessionCategoryOptionAllowBluetoothA2DP];
-        [rtcConfig setMode:AVAudioSessionModeVoiceChat];
-    } else {
-        [rtcConfig setCategoryOptions:
-         AVAudioSessionCategoryOptionAllowAirPlay|
-         AVAudioSessionCategoryOptionAllowBluetooth|
-         AVAudioSessionCategoryOptionAllowBluetoothA2DP|
-         AVAudioSessionCategoryOptionDefaultToSpeaker];
-        [rtcConfig setMode:AVAudioSessionModeVideoChat];
-    }
-    [RTCAudioSessionConfiguration setWebRTCConfiguration: rtcConfig];
-}
-
-RCT_EXPORT_METHOD(startAudioSession){
-}
-
-RCT_EXPORT_METHOD(stopAudioSession){
-    
-}
-
-RCT_EXPORT_METHOD(showAudioRoutePicker){
-    if (@available(iOS 11.0, *)) {
-        AVRoutePickerView *routePickerView = [[AVRoutePickerView alloc] init];
-        NSArray<UIView *> *subviews = routePickerView.subviews;
-        for (int i = 0; i < subviews.count; i++) {
-            UIView *subview = [subviews objectAtIndex:i];
-            if([subview isKindOfClass:[UIButton class]]) {
-                UIButton *button = (UIButton *) subview;
-                [button sendActionsForControlEvents:UIControlEventTouchUpInside];
-                break;
-            }
-        }
-    }
-}
-
-RCT_EXPORT_METHOD(getAudioOutputsWithResolver:(RCTPromiseResolveBlock)resolve
-                  withRejecter:(RCTPromiseRejectBlock)reject){
-    resolve(@[@"default", @"force_speaker"]);
-}
-RCT_EXPORT_METHOD(selectAudioOutput:(NSString *)deviceId
-                  withResolver:(RCTPromiseResolveBlock)resolve
-                  withRejecter:(RCTPromiseRejectBlock)reject){
-    
-    AVAudioSession *session = [AVAudioSession sharedInstance];
-    NSError *error = nil;
-    
-    if ([deviceId isEqualToString:@"default"]) {
-        [session overrideOutputAudioPort:AVAudioSessionPortOverrideNone error:&error];
-    } else if ([deviceId isEqualToString:@"force_speaker"]) {
-        [session overrideOutputAudioPort:AVAudioSessionPortOverrideSpeaker error:&error];
-    }
-    
-    if (error != nil) {
-        reject(@"selectAudioOutput error", error.localizedDescription, error);
-    } else {
-        resolve(nil);
-    }
-}
-
-
-/// Configure audio config for WebRTC
-RCT_EXPORT_METHOD(setAppleAudioConfiguration:(NSDictionary *) configuration){
-    RTCAudioSession* session = [RTCAudioSession sharedInstance];
-    RTCAudioSessionConfiguration* config = [RTCAudioSessionConfiguration webRTCConfiguration];
-
-    NSString* appleAudioCategory = configuration[@"audioCategory"];
-    NSArray* appleAudioCategoryOptions = configuration[@"audioCategoryOptions"];
-    NSString* appleAudioMode = configuration[@"audioMode"];
-    
-    [session lockForConfiguration];
-
-    NSError* error = nil;
-    BOOL categoryChanged = NO;
-    if(appleAudioCategoryOptions != nil) {
-        categoryChanged = YES;
-        config.categoryOptions = 0;
-        for(NSString* option in appleAudioCategoryOptions) {
-            if([@"mixWithOthers" isEqualToString:option]) {
-                config.categoryOptions |= AVAudioSessionCategoryOptionMixWithOthers;
-            } else if([@"duckOthers" isEqualToString:option]) {
-                config.categoryOptions |= AVAudioSessionCategoryOptionDuckOthers;
-            } else if([@"allowBluetooth" isEqualToString:option]) {
-                config.categoryOptions |= AVAudioSessionCategoryOptionAllowBluetooth;
-            } else if([@"allowBluetoothA2DP" isEqualToString:option]) {
-                config.categoryOptions |= AVAudioSessionCategoryOptionAllowBluetoothA2DP;
-            } else if([@"allowAirPlay" isEqualToString:option]) {
-                config.categoryOptions |= AVAudioSessionCategoryOptionAllowAirPlay;
-            } else if([@"defaultToSpeaker" isEqualToString:option]) {
-                config.categoryOptions |= AVAudioSessionCategoryOptionDefaultToSpeaker;
-            }
-        }
-    }
-
-    if(appleAudioCategory != nil) {
-        categoryChanged = YES;
-        config.category = [AudioUtils audioSessionCategoryFromString:appleAudioCategory];
-    }
-    
-    if(categoryChanged) {
-        [session setCategory:config.category withOptions:config.categoryOptions error:&error];
-        if(error != nil) {
-            NSLog(@"Error setting category: %@", [error localizedDescription]);
-            error = nil;
-        }
-    }
-
-    if(appleAudioMode != nil) {
-        config.mode = [AudioUtils audioSessionModeFromString:appleAudioMode];
-        [session setMode:config.mode error:&error];
-        if(error != nil) {
-            NSLog(@"Error setting category: %@", [error localizedDescription]);
-            error = nil;
-        }
-    }
-
-    [session unlockForConfiguration];
-}
 @end

package/ios/LivekitReactNativeModule.m

@@ -0,0 +1,42 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import "WebRTCModule.h"
+
+@interface RCT_EXTERN_MODULE(LivekitReactNativeModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(configureAudio:(NSDictionary *) config)
+RCT_EXTERN_METHOD(startAudioSession)
+RCT_EXTERN_METHOD(stopAudioSession)
+
+RCT_EXTERN_METHOD(showAudioRoutePicker)
+RCT_EXTERN_METHOD(getAudioOutputsWithResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(selectAudioOutput:(NSString *)deviceId
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+
+/// Configure audio config for WebRTC
+RCT_EXTERN_METHOD(setAppleAudioConfiguration:(NSDictionary *) configuration)
+
+
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(createVolumeProcessor:(nonnull NSNumber *)pcId
+                                        trackId:(nonnull NSString *)trackId)
+
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(deleteVolumeProcessor:(nonnull NSString *)reactTag
+                                        pcId:(nonnull NSNumber *)pcId
+                                        trackId:(nonnull NSString *)trackId)
+
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(createMultibandVolumeProcessor:(NSDictionary *)options
+                                        pcId:(nonnull NSNumber *)pcId
+                                        trackId:(nonnull NSString *)trackId)
+
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(deleteMultibandVolumeProcessor:(nonnull NSString *)reactTag
+                                        pcId:(nonnull NSNumber *)pcId
+                                        trackId:(nonnull NSString *)trackId)
+
++(BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+@end

package/ios/Logging.swift

@@ -0,0 +1,4 @@
+public func lklog(_ object: Any, functionName: String = #function, fileName: String = #file, lineNumber: Int = #line) {
+  let className = (fileName as NSString).lastPathComponent
+  print("\(className).\(functionName):\(lineNumber) : \(object)\n")
+}

package/ios/audio/AVAudioPCMBuffer.swift

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2025 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Accelerate
+import AVFoundation
+
+public extension AVAudioPCMBuffer {
+    func resample(toSampleRate targetSampleRate: Double) -> AVAudioPCMBuffer? {
+        let sourceFormat = format
+
+        if sourceFormat.sampleRate == targetSampleRate {
+            // Already targetSampleRate.
+            return self
+        }
+
+        // Define the source format (from the input buffer) and the target format.
+        guard let targetFormat = AVAudioFormat(commonFormat: sourceFormat.commonFormat,
+                                               sampleRate: targetSampleRate,
+                                               channels: sourceFormat.channelCount,
+                                               interleaved: sourceFormat.isInterleaved)
+        else {
+            print("Failed to create target format.")
+            return nil
+        }
+
+        guard let converter = AVAudioConverter(from: sourceFormat, to: targetFormat) else {
+            print("Failed to create audio converter.")
+            return nil
+        }
+
+        let capacity = targetFormat.sampleRate * Double(frameLength) / sourceFormat.sampleRate
+
+        guard let convertedBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: AVAudioFrameCount(capacity)) else {
+            print("Failed to create converted buffer.")
+            return nil
+        }
+
+        var isDone = false
+        let inputBlock: AVAudioConverterInputBlock = { _, outStatus in
+            if isDone {
+                outStatus.pointee = .noDataNow
+                return nil
+            }
+            outStatus.pointee = .haveData
+            isDone = true
+            return self
+        }
+
+        var error: NSError?
+        let status = converter.convert(to: convertedBuffer, error: &error, withInputFrom: inputBlock)
+
+        if status == .error {
+            print("Conversion failed: \(error?.localizedDescription ?? "Unknown error")")
+            return nil
+        }
+
+        // Adjust frame length to the actual amount of data written
+        convertedBuffer.frameLength = convertedBuffer.frameCapacity
+
+        return convertedBuffer
+    }
+
+    /// Convert PCM buffer to specified common format.
+    /// Currently supports conversion from Int16 to Float32.
+    func convert(toCommonFormat commonFormat: AVAudioCommonFormat) -> AVAudioPCMBuffer? {
+        // Check if conversion is needed
+        guard format.commonFormat != commonFormat else {
+            return self
+        }
+
+        // Check if the conversion is supported
+        guard format.commonFormat == .pcmFormatInt16, commonFormat == .pcmFormatFloat32 else {
+            print("Unsupported conversion: only Int16 to Float32 is supported")
+            return nil
+        }
+
+        // Create output format
+        guard let outputFormat = AVAudioFormat(commonFormat: commonFormat,
+                                               sampleRate: format.sampleRate,
+                                               channels: format.channelCount,
+                                               interleaved: false)
+        else {
+            print("Failed to create output audio format")
+            return nil
+        }
+
+        // Create output buffer
+        guard let outputBuffer = AVAudioPCMBuffer(pcmFormat: outputFormat,
+                                                  frameCapacity: frameCapacity)
+        else {
+            print("Failed to create output PCM buffer")
+            return nil
+        }
+
+        outputBuffer.frameLength = frameLength
+
+        let channelCount = Int(format.channelCount)
+        let frameCount = Int(frameLength)
+
+        // Ensure the source buffer has Int16 data
+        guard let int16Data = int16ChannelData else {
+            print("Source buffer doesn't contain Int16 data")
+            return nil
+        }
+
+        // Ensure the output buffer has Float32 data
+        guard let floatData = outputBuffer.floatChannelData else {
+            print("Failed to get float channel data from output buffer")
+            return nil
+        }
+
+        // Convert Int16 to Float32 and normalize to [-1.0, 1.0]
+        let scale = Float(Int16.max)
+        var scalar = 1.0 / scale
+
+        for channel in 0 ..< channelCount {
+            vDSP_vflt16(int16Data[channel], 1, floatData[channel], 1, vDSP_Length(frameCount))
+            vDSP_vsmul(floatData[channel], 1, &scalar, floatData[channel], 1, vDSP_Length(frameCount))
+        }
+
+        return outputBuffer
+    }
+}