@sbhjt-gr/react-native-webrtc 124.0.0 → 124.0.2

package/ios/RCTWebRTC/WebRTCModule+RTCMediaStream.m

@@ -1,533 +1,728 @@
-#import <objc/runtime.h>
-
-#import <WebRTC/RTCCameraVideoCapturer.h>
-#import <WebRTC/RTCMediaConstraints.h>
-#import <WebRTC/RTCMediaStreamTrack.h>
-#import <WebRTC/RTCVideoTrack.h>
-
-#import "RTCMediaStreamTrack+React.h"
-#import "WebRTCModule+RTCMediaStream.h"
-#import "WebRTCModule+RTCPeerConnection.h"
-#import "WebRTCModuleOptions.h"
-
-#import "ProcessorProvider.h"
-#import "ScreenCaptureController.h"
-#import "ScreenCapturer.h"
-#import "TrackCapturerEventsEmitter.h"
-#import "VideoCaptureController.h"
-
-@implementation WebRTCModule (RTCMediaStream)
-
-- (VideoEffectProcessor *)videoEffectProcessor {
-    return objc_getAssociatedObject(self, _cmd);
-}
-
-- (void)setVideoEffectProcessor:(VideoEffectProcessor *)videoEffectProcessor {
-    objc_setAssociatedObject(
-        self, @selector(videoEffectProcessor), videoEffectProcessor, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-}
-
-#pragma mark - getUserMedia
-
-- (NSString *)convertBoolToString:(id)value {
-    return value ? @"true" : @"false";
-}
-
-/**
- * Initializes a new {@link RTCAudioTrack} which satisfies the given constraints.
- *
- * @param constraints The {@code MediaStreamConstraints} which the new
- * {@code RTCAudioTrack} instance is to satisfy.
- */
-- (RTCAudioTrack *)createAudioTrack:(NSDictionary *)constraints {
-    NSString *trackId = [[NSUUID UUID] UUIDString];
-    NSDictionary *audioConstraints = constraints[@"audio"];
-    NSMutableDictionary *optionalConstraints = [NSMutableDictionary dictionary];
-    optionalConstraints[@"googAutoGainControl"] = audioConstraints[@"autoGainControl"] != nil
-                                                      ? [self convertBoolToString:audioConstraints[@"autoGainControl"]]
-                                                      : @"true";
-    optionalConstraints[@"googNoiseSuppression"] =
-        audioConstraints[@"noiseSuppression"] != nil ? [self convertBoolToString:audioConstraints[@"noiseSuppression"]]
-                                                     : @"true";
-    optionalConstraints[@"googEchoCancellation"] =
-        audioConstraints[@"echoCancellation"] != nil ? [self convertBoolToString:audioConstraints[@"echoCancellation"]]
-                                                     : @"true";
-    optionalConstraints[@"googHighpassFilter"] = audioConstraints[@"highpassFilter"] != nil
-                                                     ? [self convertBoolToString:audioConstraints[@"highpassFilter"]]
-                                                     : @"true";
-
-    RTCMediaConstraints *mediaConstraints =
-        [[RTCMediaConstraints alloc] initWithMandatoryConstraints:nil optionalConstraints:optionalConstraints];
-
-    RTCAudioSource *audioSource = [self.peerConnectionFactory audioSourceWithConstraints:mediaConstraints];
-    RTCAudioTrack *audioTrack = [self.peerConnectionFactory audioTrackWithSource:audioSource trackId:trackId];
-    return audioTrack;
-}
-/**
- * Initializes a new {@link RTCVideoTrack} with the given capture controller
- */
-- (RTCVideoTrack *)createVideoTrackWithCaptureController:
-    (CaptureController * (^)(RTCVideoSource *))captureControllerCreator {
-#if TARGET_OS_TV
-    return nil;
-#else
-
-    RTCVideoSource *videoSource = [self.peerConnectionFactory videoSource];
-
-    NSString *trackUUID = [[NSUUID UUID] UUIDString];
-    RTCVideoTrack *videoTrack = [self.peerConnectionFactory videoTrackWithSource:videoSource trackId:trackUUID];
-
-    CaptureController *captureController = captureControllerCreator(videoSource);
-    videoTrack.captureController = captureController;
-    [captureController startCapture];
-
-    return videoTrack;
-#endif
-}
-/**
- * Initializes a new {@link RTCMediaTrack} with the given tracks.
- *
- * @return An array with the mediaStreamId in index 0, and track infos in index 1.
- */
-- (NSArray *)createMediaStream:(NSArray<RTCMediaStreamTrack *> *)tracks {
-#if TARGET_OS_TV
-    return nil;
-#else
-    NSString *mediaStreamId = [[NSUUID UUID] UUIDString];
-    RTCMediaStream *mediaStream = [self.peerConnectionFactory mediaStreamWithStreamId:mediaStreamId];
-    NSMutableArray<NSDictionary *> *trackInfos = [NSMutableArray array];
-
-    for (RTCMediaStreamTrack *track in tracks) {
-        if ([track.kind isEqualToString:@"audio"]) {
-            [mediaStream addAudioTrack:(RTCAudioTrack *)track];
-        } else if ([track.kind isEqualToString:@"video"]) {
-            [mediaStream addVideoTrack:(RTCVideoTrack *)track];
-        }
-
-        NSString *trackId = track.trackId;
-
-        self.localTracks[trackId] = track;
-
-        NSDictionary *settings = @{};
-        if ([track.kind isEqualToString:@"video"]) {
-            RTCVideoTrack *videoTrack = (RTCVideoTrack *)track;
-            if ([videoTrack.captureController isKindOfClass:[CaptureController class]]) {
-                settings = [videoTrack.captureController getSettings];
-            }
-        } else if ([track.kind isEqualToString:@"audio"]) {
-            settings = @{
-                @"deviceId" : @"audio",
-                @"groupId" : @"",
-            };
-        }
-
-        [trackInfos addObject:@{
-            @"enabled" : @(track.isEnabled),
-            @"id" : trackId,
-            @"kind" : track.kind,
-            @"readyState" : @"live",
-            @"remote" : @(NO),
-            @"settings" : settings
-        }];
-    }
-
-    self.localStreams[mediaStreamId] = mediaStream;
-    return @[ mediaStreamId, trackInfos ];
-#endif
-}
-
-/**
- * Initializes a new {@link RTCVideoTrack} which satisfies the given constraints.
- */
-- (RTCVideoTrack *)createVideoTrack:(NSDictionary *)constraints {
-#if TARGET_OS_TV
-    return nil;
-#else
-    RTCVideoSource *videoSource = [self.peerConnectionFactory videoSource];
-
-    NSString *trackUUID = [[NSUUID UUID] UUIDString];
-    RTCVideoTrack *videoTrack = [self.peerConnectionFactory videoTrackWithSource:videoSource trackId:trackUUID];
-
-#if !TARGET_IPHONE_SIMULATOR
-    RTCCameraVideoCapturer *videoCapturer = [[RTCCameraVideoCapturer alloc] initWithDelegate:videoSource];
-    VideoCaptureController *videoCaptureController =
-        [[VideoCaptureController alloc] initWithCapturer:videoCapturer andConstraints:constraints[@"video"]];
-    videoCaptureController.enableMultitaskingCameraAccess =
-        [WebRTCModuleOptions sharedInstance].enableMultitaskingCameraAccess;
-    videoTrack.captureController = videoCaptureController;
-    [videoCaptureController startCapture];
-#endif
-
-    return videoTrack;
-#endif
-}
-
-- (RTCVideoTrack *)createScreenCaptureVideoTrack {
-#if TARGET_IPHONE_SIMULATOR || TARGET_OS_OSX || TARGET_OS_TV
-    return nil;
-#endif
-
-    RTCVideoSource *videoSource = [self.peerConnectionFactory videoSourceForScreenCast:YES];
-
-    NSString *trackUUID = [[NSUUID UUID] UUIDString];
-    RTCVideoTrack *videoTrack = [self.peerConnectionFactory videoTrackWithSource:videoSource trackId:trackUUID];
-
-    ScreenCapturer *screenCapturer = [[ScreenCapturer alloc] initWithDelegate:videoSource];
-    ScreenCaptureController *screenCaptureController =
-        [[ScreenCaptureController alloc] initWithCapturer:screenCapturer];
-
-    TrackCapturerEventsEmitter *emitter = [[TrackCapturerEventsEmitter alloc] initWith:trackUUID webRTCModule:self];
-    screenCaptureController.eventsDelegate = emitter;
-    videoTrack.captureController = screenCaptureController;
-    [screenCaptureController startCapture];
-
-    return videoTrack;
-}
-
-RCT_EXPORT_METHOD(getDisplayMedia : (RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
-#if TARGET_OS_TV
-    reject(@"unsupported_platform", @"tvOS is not supported", nil);
-    return;
-#else
-
-    RTCVideoTrack *videoTrack = [self createScreenCaptureVideoTrack];
-
-    if (videoTrack == nil) {
-        reject(@"DOMException", @"AbortError", nil);
-        return;
-    }
-
-    NSString *mediaStreamId = [[NSUUID UUID] UUIDString];
-    RTCMediaStream *mediaStream = [self.peerConnectionFactory mediaStreamWithStreamId:mediaStreamId];
-    [mediaStream addVideoTrack:videoTrack];
-
-    NSString *trackId = videoTrack.trackId;
-    self.localTracks[trackId] = videoTrack;
-
-    NSDictionary *trackInfo = @{
-        @"enabled" : @(videoTrack.isEnabled),
-        @"id" : videoTrack.trackId,
-        @"kind" : videoTrack.kind,
-        @"readyState" : @"live",
-        @"remote" : @(NO)
-    };
-
-    self.localStreams[mediaStreamId] = mediaStream;
-    resolve(@{@"streamId" : mediaStreamId, @"track" : trackInfo});
-#endif
-}
-
-/**
- * Implements {@code getUserMedia}. Note that at this point constraints have
- * been normalized and permissions have been granted. The constraints only
- * contain keys for which permissions have already been granted, that is,
- * if audio permission was not granted, there will be no "audio" key in
- * the constraints dictionary.
- */
-RCT_EXPORT_METHOD(getUserMedia
-                  : (NSDictionary *)constraints successCallback
-                  : (RCTResponseSenderBlock)successCallback errorCallback
-                  : (RCTResponseSenderBlock)errorCallback) {
-#if TARGET_OS_TV
-    errorCallback(@[ @"PlatformNotSupported", @"getUserMedia is not supported on tvOS." ]);
-    return;
-#else
-    RTCAudioTrack *audioTrack = nil;
-    RTCVideoTrack *videoTrack = nil;
-
-    if (constraints[@"audio"]) {
-        audioTrack = [self createAudioTrack:constraints];
-    }
-    if (constraints[@"video"]) {
-        videoTrack = [self createVideoTrack:constraints];
-    }
-
-    if (audioTrack == nil && videoTrack == nil) {
-        // Fail with DOMException with name AbortError as per:
-        // https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia
-        errorCallback(@[ @"DOMException", @"AbortError" ]);
-        return;
-    }
-
-    NSString *mediaStreamId = [[NSUUID UUID] UUIDString];
-    RTCMediaStream *mediaStream = [self.peerConnectionFactory mediaStreamWithStreamId:mediaStreamId];
-    NSMutableArray *tracks = [NSMutableArray array];
-    NSMutableArray *tmp = [NSMutableArray array];
-    if (audioTrack)
-        [tmp addObject:audioTrack];
-    if (videoTrack)
-        [tmp addObject:videoTrack];
-
-    for (RTCMediaStreamTrack *track in tmp) {
-        if ([track.kind isEqualToString:@"audio"]) {
-            [mediaStream addAudioTrack:(RTCAudioTrack *)track];
-        } else if ([track.kind isEqualToString:@"video"]) {
-            [mediaStream addVideoTrack:(RTCVideoTrack *)track];
-        }
-
-        NSString *trackId = track.trackId;
-
-        self.localTracks[trackId] = track;
-
-        NSDictionary *settings = @{};
-        if ([track.kind isEqualToString:@"video"]) {
-            RTCVideoTrack *videoTrack = (RTCVideoTrack *)track;
-            if ([videoTrack.captureController isKindOfClass:[CaptureController class]]) {
-                settings = [videoTrack.captureController getSettings];
-            }
-        } else if ([track.kind isEqualToString:@"audio"]) {
-            settings = @{
-                @"deviceId" : @"audio",
-                @"groupId" : @"",
-            };
-        }
-
-        [tracks addObject:@{
-            @"enabled" : @(track.isEnabled),
-            @"id" : trackId,
-            @"kind" : track.kind,
-            @"readyState" : @"live",
-            @"remote" : @(NO),
-            @"settings" : settings
-        }];
-    }
-
-    self.localStreams[mediaStreamId] = mediaStream;
-    successCallback(@[ mediaStreamId, tracks ]);
-#endif
-}
-
-#pragma mark - Other stream related APIs
-
-RCT_EXPORT_METHOD(enumerateDevices : (RCTResponseSenderBlock)callback) {
-#if TARGET_OS_TV
-    callback(@[]);
-#else
-    NSMutableArray *devices = [NSMutableArray array];
-    NSMutableArray *deviceTypes = [NSMutableArray array];
-    [deviceTypes addObjectsFromArray:@[
-        AVCaptureDeviceTypeBuiltInWideAngleCamera,
-        AVCaptureDeviceTypeBuiltInUltraWideCamera,
-        AVCaptureDeviceTypeBuiltInTelephotoCamera,
-        AVCaptureDeviceTypeBuiltInDualCamera,
-        AVCaptureDeviceTypeBuiltInDualWideCamera,
-        AVCaptureDeviceTypeBuiltInTripleCamera
-    ]];
-    if (@available(macos 14.0, ios 17.0, tvos 17.0, *)) {
-        [deviceTypes addObject:AVCaptureDeviceTypeExternal];
-    }
-    AVCaptureDeviceDiscoverySession *videoDevicesSession =
-        [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:deviceTypes
-                                                               mediaType:AVMediaTypeVideo
-                                                                position:AVCaptureDevicePositionUnspecified];
-    for (AVCaptureDevice *device in videoDevicesSession.devices) {
-        NSString *position = @"unknown";
-        if (device.position == AVCaptureDevicePositionBack) {
-            position = @"environment";
-        } else if (device.position == AVCaptureDevicePositionFront) {
-            position = @"front";
-        }
-        NSString *label = @"Unknown video device";
-        if (device.localizedName != nil) {
-            label = device.localizedName;
-        }
-
-        [devices addObject:@{
-            @"facing" : position,
-            @"deviceId" : device.uniqueID,
-            @"groupId" : @"",
-            @"label" : label,
-            @"kind" : @"videoinput",
-        }];
-    }
-    AVCaptureDeviceDiscoverySession *audioDevicesSession =
-        [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:@[ AVCaptureDeviceTypeBuiltInMicrophone ]
-                                                               mediaType:AVMediaTypeAudio
-                                                                position:AVCaptureDevicePositionUnspecified];
-    for (AVCaptureDevice *device in audioDevicesSession.devices) {
-        NSString *label = @"Unknown audio device";
-        if (device.localizedName != nil) {
-            label = device.localizedName;
-        }
-        [devices addObject:@{
-            @"deviceId" : device.uniqueID,
-            @"groupId" : @"",
-            @"label" : label,
-            @"kind" : @"audioinput",
-        }];
-    }
-    callback(@[ devices ]);
-#endif
-}
-
-RCT_EXPORT_METHOD(mediaStreamCreate : (nonnull NSString *)streamID) {
-    RTCMediaStream *mediaStream = [self.peerConnectionFactory mediaStreamWithStreamId:streamID];
-    self.localStreams[streamID] = mediaStream;
-}
-
-RCT_EXPORT_METHOD(mediaStreamAddTrack
-                  : (nonnull NSString *)streamID
-                  : (nonnull NSNumber *)pcId
-                  : (nonnull NSString *)trackID) {
-    RTCMediaStream *mediaStream = self.localStreams[streamID];
-    if (mediaStream == nil) {
-        return;
-    }
-
-    RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
-    if (track == nil) {
-        return;
-    }
-
-    if ([track.kind isEqualToString:@"audio"]) {
-        [mediaStream addAudioTrack:(RTCAudioTrack *)track];
-    } else if ([track.kind isEqualToString:@"video"]) {
-        [mediaStream addVideoTrack:(RTCVideoTrack *)track];
-    }
-}
-
-RCT_EXPORT_METHOD(mediaStreamRemoveTrack
-                  : (nonnull NSString *)streamID
-                  : (nonnull NSNumber *)pcId
-                  : (nonnull NSString *)trackID) {
-    RTCMediaStream *mediaStream = self.localStreams[streamID];
-    if (mediaStream == nil) {
-        return;
-    }
-
-    RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
-    if (track == nil) {
-        return;
-    }
-
-    if ([track.kind isEqualToString:@"audio"]) {
-        [mediaStream removeAudioTrack:(RTCAudioTrack *)track];
-    } else if ([track.kind isEqualToString:@"video"]) {
-        [mediaStream removeVideoTrack:(RTCVideoTrack *)track];
-    }
-}
-
-RCT_EXPORT_METHOD(mediaStreamRelease : (nonnull NSString *)streamID) {
-    RTCMediaStream *stream = self.localStreams[streamID];
-    if (stream) {
-        [self.localStreams removeObjectForKey:streamID];
-    }
-}
-
-RCT_EXPORT_METHOD(mediaStreamTrackRelease : (nonnull NSString *)trackID) {
-#if TARGET_OS_TV
-    return;
-#else
-
-    RTCMediaStreamTrack *track = self.localTracks[trackID];
-    if (track) {
-        track.isEnabled = NO;
-        [track.captureController stopCapture];
-        [self.localTracks removeObjectForKey:trackID];
-    }
-#endif
-}
-
-RCT_EXPORT_METHOD(mediaStreamTrackSetEnabled : (nonnull NSNumber *)pcId : (nonnull NSString *)trackID : (BOOL)enabled) {
-    RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
-    if (track == nil) {
-        return;
-    }
-
-    track.isEnabled = enabled;
-#if !TARGET_OS_TV
-    if (track.captureController) {  // It could be a remote track!
-        if (enabled) {
-            [track.captureController startCapture];
-        } else {
-            [track.captureController stopCapture];
-        }
-    }
-#endif
-}
-
-RCT_EXPORT_METHOD(mediaStreamTrackApplyConstraints
-                  : (nonnull NSString *)trackID
-                  : (NSDictionary *)constraints
-                  : (RCTPromiseResolveBlock)resolve
-                  : (RCTPromiseRejectBlock)reject) {
-#if TARGET_OS_TV
-    reject(@"unsupported_platform", @"tvOS is not supported", nil);
-    return;
-#else
-    RTCMediaStreamTrack *track = self.localTracks[trackID];
-    if (track) {
-        if ([track.kind isEqualToString:@"video"]) {
-            RTCVideoTrack *videoTrack = (RTCVideoTrack *)track;
-            if ([videoTrack.captureController isKindOfClass:[CaptureController class]]) {
-                CaptureController *vcc = (CaptureController *)videoTrack.captureController;
-                NSError *error = nil;
-                [vcc applyConstraints:constraints error:&error];
-                if (error) {
-                    reject(@"E_INVALID", error.localizedDescription, error);
-                } else {
-                    resolve([vcc getSettings]);
-                }
-            }
-        } else {
-            RCTLogWarn(@"mediaStreamTrackApplyConstraints() track is not video");
-            reject(@"E_INVALID", @"Can't apply constraints on audio tracks", nil);
-        }
-    } else {
-        RCTLogWarn(@"mediaStreamTrackApplyConstraints() track is null");
-        reject(@"E_INVALID", @"Could not get track", nil);
-    }
-#endif
-}
-
-RCT_EXPORT_METHOD(mediaStreamTrackSetVolume : (nonnull NSNumber *)pcId : (nonnull NSString *)trackID : (double)volume) {
-    RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
-    if (track && [track.kind isEqualToString:@"audio"]) {
-        RTCAudioTrack *audioTrack = (RTCAudioTrack *)track;
-        audioTrack.source.volume = volume;
-    }
-}
-
-RCT_EXPORT_METHOD(mediaStreamTrackSetVideoEffects
-                  : (nonnull NSString *)trackID names
-                  : (nonnull NSArray<NSString *> *)names) {
-    RTCMediaStreamTrack *track = self.localTracks[trackID];
-    if (track == nil) {
-        return;
-    }
-
-    RTCVideoTrack *videoTrack = (RTCVideoTrack *)track;
-    RTCVideoSource *videoSource = videoTrack.source;
-
-    NSMutableArray *processors = [[NSMutableArray alloc] init];
-    for (NSString *name in names) {
-        NSObject<VideoFrameProcessorDelegate> *processor = [ProcessorProvider getProcessor:name];
-        if (processor != nil) {
-            [processors addObject:processor];
-        }
-    }
-
-    self.videoEffectProcessor = [[VideoEffectProcessor alloc] initWithProcessors:processors videoSource:videoSource];
-
-    VideoCaptureController *vcc = (VideoCaptureController *)videoTrack.captureController;
-    RTCVideoCapturer *capturer = vcc.capturer;
-
-    capturer.delegate = self.videoEffectProcessor;
-}
-
-#pragma mark - Helpers
-
-- (RTCMediaStreamTrack *)trackForId:(nonnull NSString *)trackId pcId:(nonnull NSNumber *)pcId {
-    if ([pcId isEqualToNumber:[NSNumber numberWithInt:-1]]) {
-        return self.localTracks[trackId];
-    }
-
-    RTCPeerConnection *peerConnection = self.peerConnections[pcId];
-    if (peerConnection == nil) {
-        return nil;
-    }
-
-    return peerConnection.remoteTracks[trackId];
-}
-
-@end
+#import <objc/runtime.h>
+
+#import <AVFoundation/AVFoundation.h>
+#import <math.h>
+#import <limits.h>
+#import <stdint.h>
+
+#import <WebRTC/RTCCameraVideoCapturer.h>
+#import <WebRTC/RTCMediaConstraints.h>
+#import <WebRTC/RTCMediaStreamTrack.h>
+#import <WebRTC/RTCVideoTrack.h>
+
+#import "RTCMediaStreamTrack+React.h"
+#import "WebRTCModule+RTCMediaStream.h"
+#import "WebRTCModule+RTCPeerConnection.h"
+#import "WebRTCModuleOptions.h"
+#import "WLVAudioDevice.h"
+
+#import "ProcessorProvider.h"
+#import "ScreenCaptureController.h"
+#import "ScreenCapturer.h"
+#import "TrackCapturerEventsEmitter.h"
+#import "VideoCaptureController.h"
+
+@interface AudioSamplesRenderer : NSObject<RTCAudioRenderer>
+
+- (instancetype)initWithModule:(WebRTCModule *)module trackId:(NSString *)trackId;
+
+@end
+
+@implementation AudioSamplesRenderer {
+    __weak WebRTCModule *_module;
+    NSString *_trackId;
+}
+
+- (instancetype)initWithModule:(WebRTCModule *)module trackId:(NSString *)trackId {
+    self = [super init];
+    if (self) {
+        _module = module;
+        _trackId = [trackId copy];
+    }
+    return self;
+}
+
+- (void)render:(AVAudioPCMBuffer *)pcmBuffer {
+    WebRTCModule *module = _module;
+    if (!module) {
+        return;
+    }
+
+    AVAudioFrameCount frameLength = pcmBuffer.frameLength;
+    if (frameLength == 0) {
+        return;
+    }
+
+    UInt32 channelCount = pcmBuffer.format.channelCount;
+    if (channelCount == 0) {
+        return;
+    }
+
+    AVAudioCommonFormat format = pcmBuffer.format.commonFormat;
+    NSUInteger totalSamples = (NSUInteger)frameLength * (NSUInteger)channelCount;
+    NSMutableArray<NSNumber *> *samples = [NSMutableArray arrayWithCapacity:totalSamples];
+    int bitsPerSample = (int)pcmBuffer.format.streamDescription->mBitsPerChannel;
+
+    if (format == AVAudioPCMFormatInt16) {
+        int16_t **channelData = pcmBuffer.int16ChannelData;
+        if (!channelData) {
+            return;
+        }
+        for (AVAudioFrameCount frame = 0; frame < frameLength; frame++) {
+            for (UInt32 channel = 0; channel < channelCount; channel++) {
+                [samples addObject:@(channelData[channel][frame])];
+            }
+        }
+    } else if (format == AVAudioPCMFormatFloat32) {
+        float **channelData = pcmBuffer.floatChannelData;
+        if (!channelData) {
+            return;
+        }
+        bitsPerSample = 16;
+        for (AVAudioFrameCount frame = 0; frame < frameLength; frame++) {
+            for (UInt32 channel = 0; channel < channelCount; channel++) {
+                float value = channelData[channel][frame];
+                float clipped = fminf(fmaxf(value, -1.0f), 1.0f);
+                int16_t sample = (int16_t)lrintf(clipped * (float)INT16_MAX);
+                [samples addObject:@(sample)];
+            }
+        }
+    } else if (format == AVAudioPCMFormatInt32) {
+        int32_t **channelData = pcmBuffer.int32ChannelData;
+        if (!channelData) {
+            return;
+        }
+        bitsPerSample = 32;
+        for (AVAudioFrameCount frame = 0; frame < frameLength; frame++) {
+            for (UInt32 channel = 0; channel < channelCount; channel++) {
+                int32_t value = channelData[channel][frame];
+                [samples addObject:@(value)];
+            }
+        }
+    } else {
+        return;
+    }
+
+    NSTimeInterval timestampMs = [[NSDate date] timeIntervalSince1970] * 1000.0;
+
+    [module sendEventWithName:kEventAudioSamples
+                         body:@{
+                             @"trackId" : _trackId,
+                             @"samples" : samples,
+                             @"sampleRate" : @(pcmBuffer.format.sampleRate),
+                             @"channels" : @(channelCount),
+                             @"bitsPerSample" : @(bitsPerSample),
+                             @"framesPerBuffer" : @(frameLength),
+                             @"timestamp" : @(timestampMs)
+                         }];
+}
+
+@end
+
+@implementation WebRTCModule (RTCMediaStream)
+
+- (NSString *)audioSinkKeyForPcId:(NSNumber *)pcId trackId:(NSString *)trackId {
+    return [NSString stringWithFormat:@"%@:%@", pcId, trackId];
+}
+
+- (VideoEffectProcessor *)videoEffectProcessor {
+    return objc_getAssociatedObject(self, _cmd);
+}
+
+- (void)setVideoEffectProcessor:(VideoEffectProcessor *)videoEffectProcessor {
+    objc_setAssociatedObject(
+        self, @selector(videoEffectProcessor), videoEffectProcessor, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+#pragma mark - getUserMedia
+
+- (NSString *)convertBoolToString:(id)value {
+    return value ? @"true" : @"false";
+}
+
+/**
+ * Initializes a new {@link RTCAudioTrack} which satisfies the given constraints.
+ *
+ * @param constraints The {@code MediaStreamConstraints} which the new
+ * {@code RTCAudioTrack} instance is to satisfy.
+ */
+- (RTCAudioTrack *)createAudioTrack:(NSDictionary *)constraints {
+    NSString *trackId = [[NSUUID UUID] UUIDString];
+    NSDictionary *audioConstraints = constraints[@"audio"];
+    NSMutableDictionary *optionalConstraints = [NSMutableDictionary dictionary];
+    optionalConstraints[@"googAutoGainControl"] = audioConstraints[@"autoGainControl"] != nil
+                                                      ? [self convertBoolToString:audioConstraints[@"autoGainControl"]]
+                                                      : @"true";
+    optionalConstraints[@"googNoiseSuppression"] =
+        audioConstraints[@"noiseSuppression"] != nil ? [self convertBoolToString:audioConstraints[@"noiseSuppression"]]
+                                                     : @"true";
+    optionalConstraints[@"googEchoCancellation"] =
+        audioConstraints[@"echoCancellation"] != nil ? [self convertBoolToString:audioConstraints[@"echoCancellation"]]
+                                                     : @"true";
+    optionalConstraints[@"googHighpassFilter"] = audioConstraints[@"highpassFilter"] != nil
+                                                     ? [self convertBoolToString:audioConstraints[@"highpassFilter"]]
+                                                     : @"true";
+
+    RTCMediaConstraints *mediaConstraints =
+        [[RTCMediaConstraints alloc] initWithMandatoryConstraints:nil optionalConstraints:optionalConstraints];
+
+    RTCAudioSource *audioSource = [self.peerConnectionFactory audioSourceWithConstraints:mediaConstraints];
+    RTCAudioTrack *audioTrack = [self.peerConnectionFactory audioTrackWithSource:audioSource trackId:trackId];
+    return audioTrack;
+}
+/**
+ * Initializes a new {@link RTCVideoTrack} with the given capture controller
+ */
+- (RTCVideoTrack *)createVideoTrackWithCaptureController:
+    (CaptureController * (^)(RTCVideoSource *))captureControllerCreator {
+#if TARGET_OS_TV
+    return nil;
+#else
+
+    RTCVideoSource *videoSource = [self.peerConnectionFactory videoSource];
+
+    NSString *trackUUID = [[NSUUID UUID] UUIDString];
+    RTCVideoTrack *videoTrack = [self.peerConnectionFactory videoTrackWithSource:videoSource trackId:trackUUID];
+
+    CaptureController *captureController = captureControllerCreator(videoSource);
+    videoTrack.captureController = captureController;
+    [captureController startCapture];
+
+    return videoTrack;
+#endif
+}
+/**
+ * Initializes a new {@link RTCMediaTrack} with the given tracks.
+ *
+ * @return An array with the mediaStreamId in index 0, and track infos in index 1.
+ */
+- (NSArray *)createMediaStream:(NSArray<RTCMediaStreamTrack *> *)tracks {
+#if TARGET_OS_TV
+    return nil;
+#else
+    NSString *mediaStreamId = [[NSUUID UUID] UUIDString];
+    RTCMediaStream *mediaStream = [self.peerConnectionFactory mediaStreamWithStreamId:mediaStreamId];
+    NSMutableArray<NSDictionary *> *trackInfos = [NSMutableArray array];
+
+    for (RTCMediaStreamTrack *track in tracks) {
+        if ([track.kind isEqualToString:@"audio"]) {
+            [mediaStream addAudioTrack:(RTCAudioTrack *)track];
+        } else if ([track.kind isEqualToString:@"video"]) {
+            [mediaStream addVideoTrack:(RTCVideoTrack *)track];
+        }
+
+        NSString *trackId = track.trackId;
+
+        self.localTracks[trackId] = track;
+
+        NSDictionary *settings = @{};
+        if ([track.kind isEqualToString:@"video"]) {
+            RTCVideoTrack *videoTrack = (RTCVideoTrack *)track;
+            if ([videoTrack.captureController isKindOfClass:[CaptureController class]]) {
+                settings = [videoTrack.captureController getSettings];
+            }
+        } else if ([track.kind isEqualToString:@"audio"]) {
+            settings = @{
+                @"deviceId" : @"audio",
+                @"groupId" : @"",
+            };
+        }
+
+        [trackInfos addObject:@{
+            @"enabled" : @(track.isEnabled),
+            @"id" : trackId,
+            @"kind" : track.kind,
+            @"readyState" : @"live",
+            @"remote" : @(NO),
+            @"settings" : settings
+        }];
+    }
+
+    self.localStreams[mediaStreamId] = mediaStream;
+    return @[ mediaStreamId, trackInfos ];
+#endif
+}
+
+/**
+ * Initializes a new {@link RTCVideoTrack} which satisfies the given constraints.
+ */
+- (RTCVideoTrack *)createVideoTrack:(NSDictionary *)constraints {
+#if TARGET_OS_TV
+    return nil;
+#else
+    RTCVideoSource *videoSource = [self.peerConnectionFactory videoSource];
+
+    NSString *trackUUID = [[NSUUID UUID] UUIDString];
+    RTCVideoTrack *videoTrack = [self.peerConnectionFactory videoTrackWithSource:videoSource trackId:trackUUID];
+
+#if !TARGET_IPHONE_SIMULATOR
+    RTCCameraVideoCapturer *videoCapturer = [[RTCCameraVideoCapturer alloc] initWithDelegate:videoSource];
+    VideoCaptureController *videoCaptureController =
+        [[VideoCaptureController alloc] initWithCapturer:videoCapturer andConstraints:constraints[@"video"]];
+    videoCaptureController.enableMultitaskingCameraAccess =
+        [WebRTCModuleOptions sharedInstance].enableMultitaskingCameraAccess;
+    videoTrack.captureController = videoCaptureController;
+    [videoCaptureController startCapture];
+#endif
+
+    return videoTrack;
+#endif
+}
+
+- (RTCVideoTrack *)createScreenCaptureVideoTrack {
+#if TARGET_IPHONE_SIMULATOR || TARGET_OS_OSX || TARGET_OS_TV
+    return nil;
+#endif
+
+    RTCVideoSource *videoSource = [self.peerConnectionFactory videoSourceForScreenCast:YES];
+
+    NSString *trackUUID = [[NSUUID UUID] UUIDString];
+    RTCVideoTrack *videoTrack = [self.peerConnectionFactory videoTrackWithSource:videoSource trackId:trackUUID];
+
+    ScreenCapturer *screenCapturer = [[ScreenCapturer alloc] initWithDelegate:videoSource];
+    ScreenCaptureController *screenCaptureController =
+        [[ScreenCaptureController alloc] initWithCapturer:screenCapturer];
+
+    TrackCapturerEventsEmitter *emitter = [[TrackCapturerEventsEmitter alloc] initWith:trackUUID webRTCModule:self];
+    screenCaptureController.eventsDelegate = emitter;
+    videoTrack.captureController = screenCaptureController;
+    [screenCaptureController startCapture];
+
+    return videoTrack;
+}
+
+RCT_EXPORT_METHOD(createVirtualAudioTrack : (RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+#if TARGET_OS_TV
+    reject(@"unsupported_platform", @"tvOS is not supported", nil);
+    return;
+#else
+    RTCPeerConnectionFactory *factory = [self virtualFactory];
+    if (!factory) {
+        reject(@"virtual_factory_error", @"Factory unavailable", nil);
+        return;
+    }
+    NSString *trackId = [[NSUUID UUID] UUIDString];
+    RTCAudioSource *source = [factory audioSourceWithConstraints:nil];
+    RTCAudioTrack *track = [factory audioTrackWithSource:source trackId:trackId];
+    NSArray *components = [self createMediaStream:@[ track ]];
+    resolve(@{ @"streamId" : components[0], @"tracks" : components[1] });
+#endif
+}
+
+RCT_EXPORT_METHOD(pushVirtualAudioSamples
+                  : (nonnull NSArray<NSNumber *> *)samples
+                  sampleRate
+                  : (nonnull NSNumber *)sampleRate
+                  channels
+                  : (nonnull NSNumber *)channels) {
+#if TARGET_OS_TV
+    return;
+#else
+    if (samples.count == 0) {
+        return;
+    }
+    if (!self.virtualAudioDevice) {
+        [self virtualFactory];
+    }
+    if (!self.virtualAudioDevice) {
+        return;
+    }
+    NSUInteger length = samples.count * sizeof(int16_t);
+    NSMutableData *data = [NSMutableData dataWithLength:length];
+    int16_t *buffer = data.mutableBytes;
+    NSUInteger idx = 0;
+    for (NSNumber *value in samples) {
+        buffer[idx++] = (int16_t)value.shortValue;
+    }
+    [self.virtualAudioDevice pushAudioData:data sampleRate:sampleRate.doubleValue channels:channels.integerValue];
+#endif
+}
+
+RCT_EXPORT_METHOD(getDisplayMedia : (RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+#if TARGET_OS_TV
+    reject(@"unsupported_platform", @"tvOS is not supported", nil);
+    return;
+#else
+
+    RTCVideoTrack *videoTrack = [self createScreenCaptureVideoTrack];
+
+    if (videoTrack == nil) {
+        reject(@"DOMException", @"AbortError", nil);
+        return;
+    }
+
+    NSString *mediaStreamId = [[NSUUID UUID] UUIDString];
+    RTCMediaStream *mediaStream = [self.peerConnectionFactory mediaStreamWithStreamId:mediaStreamId];
+    [mediaStream addVideoTrack:videoTrack];
+
+    NSString *trackId = videoTrack.trackId;
+    self.localTracks[trackId] = videoTrack;
+
+    NSDictionary *trackInfo = @{
+        @"enabled" : @(videoTrack.isEnabled),
+        @"id" : videoTrack.trackId,
+        @"kind" : videoTrack.kind,
+        @"readyState" : @"live",
+        @"remote" : @(NO)
+    };
+
+    self.localStreams[mediaStreamId] = mediaStream;
+    resolve(@{@"streamId" : mediaStreamId, @"track" : trackInfo});
+#endif
+}
+
+/**
+ * Implements {@code getUserMedia}. Note that at this point constraints have
+ * been normalized and permissions have been granted. The constraints only
+ * contain keys for which permissions have already been granted, that is,
+ * if audio permission was not granted, there will be no "audio" key in
+ * the constraints dictionary.
+ */
+RCT_EXPORT_METHOD(getUserMedia
+                  : (NSDictionary *)constraints successCallback
+                  : (RCTResponseSenderBlock)successCallback errorCallback
+                  : (RCTResponseSenderBlock)errorCallback) {
+#if TARGET_OS_TV
+    errorCallback(@[ @"PlatformNotSupported", @"getUserMedia is not supported on tvOS." ]);
+    return;
+#else
+    RTCAudioTrack *audioTrack = nil;
+    RTCVideoTrack *videoTrack = nil;
+
+    if (constraints[@"audio"]) {
+        audioTrack = [self createAudioTrack:constraints];
+    }
+    if (constraints[@"video"]) {
+        videoTrack = [self createVideoTrack:constraints];
+    }
+
+    if (audioTrack == nil && videoTrack == nil) {
+        // Fail with DOMException with name AbortError as per:
+        // https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia
+        errorCallback(@[ @"DOMException", @"AbortError" ]);
+        return;
+    }
+
+    NSString *mediaStreamId = [[NSUUID UUID] UUIDString];
+    RTCMediaStream *mediaStream = [self.peerConnectionFactory mediaStreamWithStreamId:mediaStreamId];
+    NSMutableArray *tracks = [NSMutableArray array];
+    NSMutableArray *tmp = [NSMutableArray array];
+    if (audioTrack)
+        [tmp addObject:audioTrack];
+    if (videoTrack)
+        [tmp addObject:videoTrack];
+
+    for (RTCMediaStreamTrack *track in tmp) {
+        if ([track.kind isEqualToString:@"audio"]) {
+            [mediaStream addAudioTrack:(RTCAudioTrack *)track];
+        } else if ([track.kind isEqualToString:@"video"]) {
+            [mediaStream addVideoTrack:(RTCVideoTrack *)track];
+        }
+
+        NSString *trackId = track.trackId;
+
+        self.localTracks[trackId] = track;
+
+        NSDictionary *settings = @{};
+        if ([track.kind isEqualToString:@"video"]) {
+            RTCVideoTrack *videoTrack = (RTCVideoTrack *)track;
+            if ([videoTrack.captureController isKindOfClass:[CaptureController class]]) {
+                settings = [videoTrack.captureController getSettings];
+            }
+        } else if ([track.kind isEqualToString:@"audio"]) {
+            settings = @{
+                @"deviceId" : @"audio",
+                @"groupId" : @"",
+            };
+        }
+
+        [tracks addObject:@{
+            @"enabled" : @(track.isEnabled),
+            @"id" : trackId,
+            @"kind" : track.kind,
+            @"readyState" : @"live",
+            @"remote" : @(NO),
+            @"settings" : settings
+        }];
+    }
+
+    self.localStreams[mediaStreamId] = mediaStream;
+    successCallback(@[ mediaStreamId, tracks ]);
+#endif
+}
+
+#pragma mark - Other stream related APIs
+
+RCT_EXPORT_METHOD(enumerateDevices : (RCTResponseSenderBlock)callback) {
+#if TARGET_OS_TV
+    callback(@[]);
+#else
+    NSMutableArray *devices = [NSMutableArray array];
+    NSMutableArray *deviceTypes = [NSMutableArray array];
+    [deviceTypes addObjectsFromArray:@[
+        AVCaptureDeviceTypeBuiltInWideAngleCamera,
+        AVCaptureDeviceTypeBuiltInUltraWideCamera,
+        AVCaptureDeviceTypeBuiltInTelephotoCamera,
+        AVCaptureDeviceTypeBuiltInDualCamera,
+        AVCaptureDeviceTypeBuiltInDualWideCamera,
+        AVCaptureDeviceTypeBuiltInTripleCamera
+    ]];
+    if (@available(macos 14.0, ios 17.0, tvos 17.0, *)) {
+        [deviceTypes addObject:AVCaptureDeviceTypeExternal];
+    }
+    AVCaptureDeviceDiscoverySession *videoDevicesSession =
+        [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:deviceTypes
+                                                               mediaType:AVMediaTypeVideo
+                                                                position:AVCaptureDevicePositionUnspecified];
+    for (AVCaptureDevice *device in videoDevicesSession.devices) {
+        NSString *position = @"unknown";
+        if (device.position == AVCaptureDevicePositionBack) {
+            position = @"environment";
+        } else if (device.position == AVCaptureDevicePositionFront) {
+            position = @"front";
+        }
+        NSString *label = @"Unknown video device";
+        if (device.localizedName != nil) {
+            label = device.localizedName;
+        }
+
+        [devices addObject:@{
+            @"facing" : position,
+            @"deviceId" : device.uniqueID,
+            @"groupId" : @"",
+            @"label" : label,
+            @"kind" : @"videoinput",
+        }];
+    }
+    AVCaptureDeviceDiscoverySession *audioDevicesSession =
+        [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:@[ AVCaptureDeviceTypeBuiltInMicrophone ]
+                                                               mediaType:AVMediaTypeAudio
+                                                                position:AVCaptureDevicePositionUnspecified];
+    for (AVCaptureDevice *device in audioDevicesSession.devices) {
+        NSString *label = @"Unknown audio device";
+        if (device.localizedName != nil) {
+            label = device.localizedName;
+        }
+        [devices addObject:@{
+            @"deviceId" : device.uniqueID,
+            @"groupId" : @"",
+            @"label" : label,
+            @"kind" : @"audioinput",
+        }];
+    }
+    callback(@[ devices ]);
+#endif
+}
+
+RCT_EXPORT_METHOD(mediaStreamCreate : (nonnull NSString *)streamID) {
+    RTCMediaStream *mediaStream = [self.peerConnectionFactory mediaStreamWithStreamId:streamID];
+    self.localStreams[streamID] = mediaStream;
+}
+
+RCT_EXPORT_METHOD(mediaStreamAddTrack
+                  : (nonnull NSString *)streamID
+                  : (nonnull NSNumber *)pcId
+                  : (nonnull NSString *)trackID) {
+    RTCMediaStream *mediaStream = self.localStreams[streamID];
+    if (mediaStream == nil) {
+        return;
+    }
+
+    RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
+    if (track == nil) {
+        return;
+    }
+
+    if ([track.kind isEqualToString:@"audio"]) {
+        [mediaStream addAudioTrack:(RTCAudioTrack *)track];
+    } else if ([track.kind isEqualToString:@"video"]) {
+        [mediaStream addVideoTrack:(RTCVideoTrack *)track];
+    }
+}
+
+RCT_EXPORT_METHOD(mediaStreamRemoveTrack
+                  : (nonnull NSString *)streamID
+                  : (nonnull NSNumber *)pcId
+                  : (nonnull NSString *)trackID) {
+    RTCMediaStream *mediaStream = self.localStreams[streamID];
+    if (mediaStream == nil) {
+        return;
+    }
+
+    RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
+    if (track == nil) {
+        return;
+    }
+
+    if ([track.kind isEqualToString:@"audio"]) {
+        [mediaStream removeAudioTrack:(RTCAudioTrack *)track];
+    } else if ([track.kind isEqualToString:@"video"]) {
+        [mediaStream removeVideoTrack:(RTCVideoTrack *)track];
+    }
+}
+
+RCT_EXPORT_METHOD(mediaStreamRelease : (nonnull NSString *)streamID) {
+    RTCMediaStream *stream = self.localStreams[streamID];
+    if (stream) {
+        [self.localStreams removeObjectForKey:streamID];
+    }
+}
+
+RCT_EXPORT_METHOD(mediaStreamTrackRelease : (nonnull NSString *)trackID) {
+#if TARGET_OS_TV
+    return;
+#else
+
+    RTCMediaStreamTrack *track = self.localTracks[trackID];
+    if (track) {
+        track.isEnabled = NO;
+        [track.captureController stopCapture];
+        [self.localTracks removeObjectForKey:trackID];
+    }
+#endif
+}
+
+RCT_EXPORT_METHOD(mediaStreamTrackSetEnabled : (nonnull NSNumber *)pcId : (nonnull NSString *)trackID : (BOOL)enabled) {
+    RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
+    if (track == nil) {
+        return;
+    }
+
+    track.isEnabled = enabled;
+#if !TARGET_OS_TV
+    if (track.captureController) {  // It could be a remote track!
+        if (enabled) {
+            [track.captureController startCapture];
+        } else {
+            [track.captureController stopCapture];
+        }
+    }
+#endif
+}
+
+RCT_EXPORT_METHOD(mediaStreamTrackApplyConstraints
+                  : (nonnull NSString *)trackID
+                  : (NSDictionary *)constraints
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+#if TARGET_OS_TV
+    reject(@"unsupported_platform", @"tvOS is not supported", nil);
+    return;
+#else
+    RTCMediaStreamTrack *track = self.localTracks[trackID];
+    if (track) {
+        if ([track.kind isEqualToString:@"video"]) {
+            RTCVideoTrack *videoTrack = (RTCVideoTrack *)track;
+            if ([videoTrack.captureController isKindOfClass:[CaptureController class]]) {
+                CaptureController *vcc = (CaptureController *)videoTrack.captureController;
+                NSError *error = nil;
+                [vcc applyConstraints:constraints error:&error];
+                if (error) {
+                    reject(@"E_INVALID", error.localizedDescription, error);
+                } else {
+                    resolve([vcc getSettings]);
+                }
+            }
+        } else {
+            RCTLogWarn(@"mediaStreamTrackApplyConstraints() track is not video");
+            reject(@"E_INVALID", @"Can't apply constraints on audio tracks", nil);
+        }
+    } else {
+        RCTLogWarn(@"mediaStreamTrackApplyConstraints() track is null");
+        reject(@"E_INVALID", @"Could not get track", nil);
+    }
+#endif
+}
+
+RCT_EXPORT_METHOD(mediaStreamTrackSetVolume : (nonnull NSNumber *)pcId : (nonnull NSString *)trackID : (double)volume) {
+    RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
+    if (track && [track.kind isEqualToString:@"audio"]) {
+        RTCAudioTrack *audioTrack = (RTCAudioTrack *)track;
+        audioTrack.source.volume = volume;
+    }
+}
+
+RCT_EXPORT_METHOD(mediaStreamTrackSetPlaybackEnabled : (nonnull NSNumber *)pcId : (nonnull NSString *)trackID : (BOOL)enabled) {
+    RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
+    if (track && [track.kind isEqualToString:@"audio"]) {
+        RTCAudioTrack *audioTrack = (RTCAudioTrack *)track;
+        audioTrack.source.volume = enabled ? 1.0 : 0.0;
+    }
+}
+
+RCT_EXPORT_METHOD(mediaStreamTrackEnableAudioSink : (nonnull NSNumber *)pcId : (nonnull NSString *)trackID : (BOOL)enabled) {
+    NSString *key = [self audioSinkKeyForPcId:pcId trackId:trackID];
+
+    if (enabled) {
+        if (self.audioRenderers[key]) {
+            return;
+        }
+
+        RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
+        if (track == nil || ![track.kind isEqualToString:@"audio"]) {
+            return;
+        }
+
+        RTCAudioTrack *audioTrack = (RTCAudioTrack *)track;
+        AudioSamplesRenderer *renderer = [[AudioSamplesRenderer alloc] initWithModule:self trackId:trackID];
+        self.audioRenderers[key] = renderer;
+        [audioTrack addRenderer:renderer];
+    } else {
+        id<RTCAudioRenderer> renderer = self.audioRenderers[key];
+        if (!renderer) {
+            return;
+        }
+
+        RTCMediaStreamTrack *track = [self trackForId:trackID pcId:pcId];
+        if ([track isKindOfClass:[RTCAudioTrack class]]) {
+            RTCAudioTrack *audioTrack = (RTCAudioTrack *)track;
+            [audioTrack removeRenderer:renderer];
+        }
+
+        [self.audioRenderers removeObjectForKey:key];
+    }
+}
+
+RCT_EXPORT_METHOD(mediaStreamTrackSetVideoEffects
+                  : (nonnull NSString *)trackID names
+                  : (nonnull NSArray<NSString *> *)names) {
+    RTCMediaStreamTrack *track = self.localTracks[trackID];
+    if (track == nil) {
+        return;
+    }
+
+    RTCVideoTrack *videoTrack = (RTCVideoTrack *)track;
+    RTCVideoSource *videoSource = videoTrack.source;
+
+    NSMutableArray *processors = [[NSMutableArray alloc] init];
+    for (NSString *name in names) {
+        NSObject<VideoFrameProcessorDelegate> *processor = [ProcessorProvider getProcessor:name];
+        if (processor != nil) {
+            [processors addObject:processor];
+        }
+    }
+
+    self.videoEffectProcessor = [[VideoEffectProcessor alloc] initWithProcessors:processors videoSource:videoSource];
+
+    VideoCaptureController *vcc = (VideoCaptureController *)videoTrack.captureController;
+    RTCVideoCapturer *capturer = vcc.capturer;
+
+    capturer.delegate = self.videoEffectProcessor;
+}
+
+#pragma mark - Helpers
+
+- (RTCMediaStreamTrack *)trackForId:(nonnull NSString *)trackId pcId:(nonnull NSNumber *)pcId {
+    if ([pcId isEqualToNumber:[NSNumber numberWithInt:-1]]) {
+        return self.localTracks[trackId];
+    }
+
+    RTCPeerConnection *peerConnection = self.peerConnections[pcId];
+    if (peerConnection == nil) {
+        return nil;
+    }
+
+    return peerConnection.remoteTracks[trackId];
+}
+
+@end