@livekit/react-native 2.5.0 → 2.6.0

package/android/src/main/java/com/livekit/reactnative/audio/processing/MultibandVolumeProcessor.kt

@@ -0,0 +1,181 @@
+package com.livekit.reactnative.audio.processing
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.livekit.reactnative.audio.events.Events
+import com.livekit.reactnative.audio.processing.fft.FFTAudioAnalyzer
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.flow.transform
+import kotlinx.coroutines.launch
+import org.webrtc.AudioTrackSink
+import java.nio.ByteBuffer
+import kotlin.math.pow
+import kotlin.math.round
+import kotlin.math.roundToInt
+import kotlin.math.sqrt
+import kotlin.time.Duration
+
+class MultibandVolumeProcessor(
+    minFrequency: Float = 1000f,
+    maxFrequency: Float = 8000f,
+    barCount: Int,
+    interval: Duration,
+    private val reactContext: ReactContext,
+) : BaseMultibandVolumeProcessor(minFrequency, maxFrequency, barCount, interval) {
+
+    var reactTag: String? = null
+    override fun onMagnitudesCollected(magnitudes: FloatArray) {
+        val reactTag = this.reactTag ?: return
+        val event = Arguments.createMap().apply {
+            putArray("magnitudes", Arguments.fromArray(magnitudes))
+            putString("id", reactTag)
+        }
+        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(Events.LK_MULTIBAND_PROCESSED.name, event)
+    }
+}
+
+abstract class BaseMultibandVolumeProcessor(
+    val minFrequency: Float = 1000f,
+    val maxFrequency: Float = 8000f,
+    val barCount: Int,
+    val interval: Duration,
+) : AudioTrackSink {
+
+    private val audioProcessor = FFTAudioAnalyzer()
+    private var coroutineScope: CoroutineScope? = null
+
+    abstract fun onMagnitudesCollected(magnitudes: FloatArray)
+
+    fun start() {
+        coroutineScope?.cancel()
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+        coroutineScope = scope
+        scope.launch {
+            val averages = FloatArray(barCount)
+            audioProcessor.fftFlow.throttleLatest(interval).collect { fft ->
+                val loPass: Int
+                val hiPass: Int
+                val audioFormat = audioProcessor.configuredInputFormat
+
+                if (audioFormat != null) {
+                    loPass = (minFrequency * fft.size / (audioFormat.sampleRate / 2)).roundToInt().coerceIn(fft.indices)
+                    hiPass = (maxFrequency * fft.size / (audioFormat.sampleRate / 2)).roundToInt().coerceIn(fft.indices)
+                } else {
+                    loPass = 0
+                    hiPass = fft.size
+                }
+
+                val sliced = fft.slice(loPass until hiPass)
+                val magnitudes = calculateAmplitudeBarsFromFFT(sliced, averages, barCount)
+
+                onMagnitudesCollected(magnitudes)
+            }
+        }
+    }
+
+    fun stop() {
+        coroutineScope?.cancel()
+        coroutineScope = null
+    }
+
+    fun release() {
+        stop()
+        audioProcessor.release()
+    }
+
+    override fun onData(
+        audioData: ByteBuffer,
+        bitsPerSample: Int,
+        sampleRate: Int,
+        numberOfChannels: Int,
+        numberOfFrames: Int,
+        absoluteCaptureTimestampMs: Long
+    ) {
+        val curAudioFormat = audioProcessor.configuredInputFormat
+        if (curAudioFormat == null ||
+            curAudioFormat.bitsPerSample != bitsPerSample ||
+            curAudioFormat.sampleRate != sampleRate ||
+            curAudioFormat.numberOfChannels != numberOfChannels
+        ) {
+            audioProcessor.configure(AudioFormat(bitsPerSample, sampleRate, numberOfChannels))
+        }
+
+        audioProcessor.queueInput(audioData)
+    }
+}
+
+fun <T> Flow<T>.throttleLatest(interval: Duration): Flow<T> = this
+    .conflate()
+    .transform {
+        emit(it)
+        delay(interval)
+    }
+
+
+private const val MIN_CONST = 2f
+private const val MAX_CONST = 25f
+
+private fun calculateAmplitudeBarsFromFFT(
+    fft: List<Float>,
+    averages: FloatArray,
+    barCount: Int,
+): FloatArray {
+    val amplitudes = FloatArray(barCount)
+    if (fft.isEmpty()) {
+        return amplitudes
+    }
+
+    // We average out the values over 3 occurrences (plus the current one), so big jumps are smoothed out
+    // Iterate over the entire FFT result array.
+    for (barIndex in 0 until barCount) {
+        // Note: each FFT is a real and imaginary pair.
+        // Scale down by 2 and scale back up to ensure we get an even number.
+        val prevLimit = (round(fft.size.toFloat() / 2 * barIndex / barCount).toInt() * 2)
+            .coerceIn(0, fft.size - 1)
+        val nextLimit = (round(fft.size.toFloat() / 2 * (barIndex + 1) / barCount).toInt() * 2)
+            .coerceIn(0, fft.size - 1)
+
+        var accum = 0f
+        // Here we iterate within this single band
+        for (i in prevLimit until nextLimit step 2) {
+            // Convert real and imaginary part to get energy
+
+            val realSq = fft[i]
+                .toDouble()
+                .pow(2.0)
+            val imaginarySq = fft[i + 1]
+                .toDouble()
+                .pow(2.0)
+            val raw = sqrt(realSq + imaginarySq).toFloat()
+
+            accum += raw
+        }
+
+        // A window might be empty which would result in a 0 division
+        if ((nextLimit - prevLimit) != 0) {
+            accum /= (nextLimit - prevLimit)
+        } else {
+            accum = 0.0f
+        }
+
+        val smoothingFactor = 5
+        var avg = averages[barIndex]
+        avg += (accum - avg / smoothingFactor)
+        averages[barIndex] = avg
+
+        var amplitude = avg.coerceIn(MIN_CONST, MAX_CONST)
+        amplitude -= MIN_CONST
+        amplitude /= (MAX_CONST - MIN_CONST)
+        amplitudes[barIndex] = amplitude
+    }
+
+    return amplitudes
+}

package/android/src/main/java/com/livekit/reactnative/audio/processing/VolumeProcessor.kt

@@ -0,0 +1,67 @@
+package com.livekit.reactnative.audio.processing
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.livekit.reactnative.audio.events.Events
+import org.webrtc.AudioTrackSink
+import java.nio.ByteBuffer
+import kotlin.math.round
+import kotlin.math.sqrt
+
+class VolumeProcessor(private val reactContext: ReactContext) : BaseVolumeProcessor() {
+    var reactTag: String? = null
+
+    override fun onVolumeCalculated(volume: Double) {
+        val reactTag = this.reactTag ?: return
+        val event = Arguments.createMap().apply {
+            putDouble("volume", volume)
+            putString("id", reactTag)
+        }
+        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(Events.LK_VOLUME_PROCESSED.name, event)
+    }
+}
+
+abstract class BaseVolumeProcessor : AudioTrackSink {
+    abstract fun onVolumeCalculated(volume: Double)
+
+    override fun onData(
+        audioData: ByteBuffer,
+        bitsPerSample: Int,
+        sampleRate: Int,
+        numberOfChannels: Int,
+        numberOfFrames: Int,
+        absoluteCaptureTimestampMs: Long
+    ) {
+        audioData.mark()
+        audioData.position(0)
+        var average = 0L
+        val bytesPerSample = bitsPerSample / 8
+
+        // RMS average calculation
+        for (i in 0 until numberOfFrames) {
+            val value = when (bytesPerSample) {
+                1 -> audioData.get().toLong()
+                2 -> audioData.getShort().toLong()
+                4 -> audioData.getInt().toLong()
+                else -> throw IllegalArgumentException()
+            }
+
+            average += value * value
+        }
+
+        average /= numberOfFrames
+
+        val volume = round(sqrt(average.toDouble()))
+        val volumeNormalized = when (bytesPerSample) {
+            1 -> volume / Byte.MAX_VALUE
+            2 -> volume / Short.MAX_VALUE
+            4 -> volume / Int.MAX_VALUE
+            else -> throw IllegalArgumentException()
+        }
+        audioData.reset()
+
+        onVolumeCalculated(volumeNormalized)
+    }
+}

package/android/src/main/java/com/livekit/reactnative/audio/processing/fft/FFTAudioAnalyzer.kt

@@ -0,0 +1,224 @@
+/*
+ * Copyright 2024 LiveKit, Inc.
+ *
+ * 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.
+ *
+ * Originally adapted from: https://github.com/dzolnai/ExoVisualizer
+ *
+ * MIT License
+ *
+ * Copyright (c) 2019 Dániel Zolnai
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.livekit.reactnative.audio.processing.fft;
+
+import android.media.AudioTrack
+import com.livekit.reactnative.audio.processing.AudioFormat
+import com.paramsen.noise.Noise
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.util.concurrent.TimeUnit
+import kotlin.math.max
+
+/**
+ * A Fast Fourier Transform analyzer for audio bytes.
+ *
+ * Use [queueInput] to add audio bytes, and collect on [fftFlow]
+ * to receive the analyzed frequencies.
+ */
+class FFTAudioAnalyzer {
+
+    companion object {
+        const val SAMPLE_SIZE = 1024
+        private val EMPTY_BUFFER = ByteBuffer.allocateDirect(0).order(ByteOrder.nativeOrder())
+
+        // Extra size next in addition to the AudioTrack buffer size
+        private const val BUFFER_EXTRA_SIZE = SAMPLE_SIZE * 8
+
+        // Size of short in bytes.
+        private const val SHORT_SIZE = 2
+    }
+
+    val isActive: Boolean
+        get() = noise != null
+
+    private var noise: Noise? = null
+    private lateinit var inputAudioFormat: AudioFormat
+    val configuredInputFormat: AudioFormat?
+        get() {
+            if (::inputAudioFormat.isInitialized) {
+                return inputAudioFormat
+            } else {
+                return null
+            }
+        }
+
+    private var audioTrackBufferSize = 0
+
+    private var fftBuffer: ByteBuffer = EMPTY_BUFFER
+    private lateinit var srcBuffer: ByteBuffer
+    private var srcBufferPosition = 0
+    private val tempShortArray = ShortArray(SAMPLE_SIZE)
+    private val src = FloatArray(SAMPLE_SIZE)
+
+    private val mutableFftFlow = MutableSharedFlow<FloatArray>(replay = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
+
+    /**
+     * A flow of frequencies for the audio bytes given through [queueInput].
+     */
+    val fftFlow: Flow<FloatArray> = mutableFftFlow
+
+    fun configure(inputAudioFormat: AudioFormat) {
+        this.inputAudioFormat = inputAudioFormat
+
+        noise = Noise.real(SAMPLE_SIZE)
+
+        audioTrackBufferSize = getDefaultBufferSizeInBytes(inputAudioFormat)
+
+        srcBuffer = ByteBuffer.allocate(audioTrackBufferSize + BUFFER_EXTRA_SIZE)
+    }
+
+    fun release() {
+        noise?.close()
+        noise = null
+    }
+
+    /**
+     * Add audio bytes to be processed.
+     */
+    fun queueInput(inputBuffer: ByteBuffer) {
+        if (!isActive) {
+            return
+        }
+        var position = inputBuffer.position()
+        val limit = inputBuffer.limit()
+        val frameCount = (limit - position) / (SHORT_SIZE * inputAudioFormat.numberOfChannels)
+        val singleChannelOutputSize = frameCount * SHORT_SIZE
+
+        // Setup buffer
+        if (fftBuffer.capacity() < singleChannelOutputSize) {
+            fftBuffer =
+                ByteBuffer.allocateDirect(singleChannelOutputSize).order(ByteOrder.nativeOrder())
+        } else {
+            fftBuffer.clear()
+        }
+
+        // Process inputBuffer
+        while (position < limit) {
+            var summedUp = 0
+            for (channelIndex in 0 until inputAudioFormat.numberOfChannels) {
+                val current = inputBuffer.getShort(position + 2 * channelIndex)
+                summedUp += current
+            }
+            // For the FFT, we use an average of all the channels and put into a single short.
+            fftBuffer.putShort((summedUp / inputAudioFormat.numberOfChannels).toShort())
+            position += inputAudioFormat.numberOfChannels * 2
+        }
+
+        // Reset input buffer to original position.
+        inputBuffer.position(position)
+
+        processFFT(this.fftBuffer)
+    }
+
+    private fun processFFT(buffer: ByteBuffer) {
+        if (noise == null) {
+            return
+        }
+        srcBuffer.put(buffer.array())
+        srcBufferPosition += buffer.array().size
+        // Since this is PCM 16 bit, each sample will be 2 bytes.
+        // So to get the sample size in the end, we need to take twice as many bytes off the buffer
+        val bytesToProcess = SAMPLE_SIZE * 2
+        while (srcBufferPosition > bytesToProcess) {
+            // Move to start of
+            srcBuffer.position(0)
+
+            srcBuffer.asShortBuffer().get(tempShortArray, 0, SAMPLE_SIZE)
+            tempShortArray.forEachIndexed { index, sample ->
+                // Normalize to value between -1.0 and 1.0
+                src[index] = sample.toFloat() / Short.MAX_VALUE
+            }
+
+            srcBuffer.position(bytesToProcess)
+            srcBuffer.compact()
+            srcBufferPosition -= bytesToProcess
+            srcBuffer.position(srcBufferPosition)
+            val dst = FloatArray(SAMPLE_SIZE + 2)
+            val fft = noise?.fft(src, dst)!!
+
+            mutableFftFlow.tryEmit(fft)
+        }
+    }
+
+    private fun durationUsToFrames(sampleRate: Int, durationUs: Long): Long {
+        return durationUs * sampleRate / TimeUnit.MICROSECONDS.convert(1, TimeUnit.SECONDS)
+    }
+
+    private fun getPcmFrameSize(channelCount: Int): Int {
+        // assumes PCM_16BIT
+        return channelCount * 2
+    }
+
+    private fun getAudioTrackChannelConfig(channelCount: Int): Int {
+        return when (channelCount) {
+            1 -> android.media.AudioFormat.CHANNEL_OUT_MONO
+            2 -> android.media.AudioFormat.CHANNEL_OUT_STEREO
+            // ignore other channel counts that aren't used in LiveKit
+            else -> android.media.AudioFormat.CHANNEL_INVALID
+        }
+    }
+
+    private fun getDefaultBufferSizeInBytes(audioFormat: AudioFormat): Int {
+        val outputPcmFrameSize = getPcmFrameSize(audioFormat.numberOfChannels)
+        val minBufferSize =
+            AudioTrack.getMinBufferSize(
+                audioFormat.sampleRate,
+                getAudioTrackChannelConfig(audioFormat.numberOfChannels),
+                android.media.AudioFormat.ENCODING_PCM_16BIT
+            )
+
+        check(minBufferSize != AudioTrack.ERROR_BAD_VALUE)
+        val multipliedBufferSize = minBufferSize * 4
+        val minAppBufferSize =
+            durationUsToFrames(audioFormat.sampleRate, 30 * 1000).toInt() * outputPcmFrameSize
+        val maxAppBufferSize = max(
+            minBufferSize.toLong(),
+            durationUsToFrames(audioFormat.sampleRate, 500 * 1000) * outputPcmFrameSize
+        ).toInt()
+        val bufferSizeInFrames =
+            multipliedBufferSize.coerceIn(minAppBufferSize, maxAppBufferSize) / outputPcmFrameSize
+        return bufferSizeInFrames * outputPcmFrameSize
+    }
+}

package/ios/LKAudioProcessingAdapter.h

@@ -0,0 +1,26 @@
+#import <Foundation/Foundation.h>
+#import <WebRTC/WebRTC.h>
+
+@protocol LKExternalAudioProcessingDelegate
+
+- (void)audioProcessingInitializeWithSampleRate:(size_t)sampleRateHz channels:(size_t)channels;
+
+- (void)audioProcessingProcess:(RTC_OBJC_TYPE(RTCAudioBuffer) * _Nonnull)audioBuffer;
+
+- (void)audioProcessingRelease;
+
+@end
+
+@interface LKAudioProcessingAdapter : NSObject <RTCAudioCustomProcessingDelegate>
+
+- (nonnull instancetype)init;
+
+- (void)addProcessing:(id<LKExternalAudioProcessingDelegate> _Nonnull)processor;
+
+- (void)removeProcessing:(id<LKExternalAudioProcessingDelegate> _Nonnull)processor;
+
+- (void)addAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer;
+
+- (void)removeAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer;
+
+@end

package/ios/LKAudioProcessingAdapter.m

@@ -0,0 +1,117 @@
+#import "LKAudioProcessingAdapter.h"
+#import <WebRTC/RTCAudioRenderer.h>
+#import <os/lock.h>
+
+@implementation LKAudioProcessingAdapter {
+  NSMutableArray<id<RTCAudioRenderer>>* _renderers;
+  NSMutableArray<id<LKExternalAudioProcessingDelegate>>* _processors;
+  os_unfair_lock _lock;
+  BOOL _isAudioProcessingInitialized;
+  size_t _sampleRateHz;
+  size_t _channels;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _isAudioProcessingInitialized = NO;
+    _lock = OS_UNFAIR_LOCK_INIT;
+    _renderers = [[NSMutableArray<id<RTCAudioRenderer>> alloc] init];
+    _processors = [[NSMutableArray<id<LKExternalAudioProcessingDelegate>> alloc] init];
+  }
+  return self;
+}
+
+- (void)addProcessing:(id<LKExternalAudioProcessingDelegate> _Nonnull)processor {
+  os_unfair_lock_lock(&_lock);
+  [_processors addObject:processor];
+  if (_isAudioProcessingInitialized) {
+    [processor audioProcessingInitializeWithSampleRate:_sampleRateHz channels:_channels];
+  }
+  os_unfair_lock_unlock(&_lock);
+}
+
+- (void)removeProcessing:(id<LKExternalAudioProcessingDelegate> _Nonnull)processor {
+  os_unfair_lock_lock(&_lock);
+  _processors = [[_processors
+      filteredArrayUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(id evaluatedObject,
+                                                                        NSDictionary* bindings) {
+        return evaluatedObject != processor;
+      }]] mutableCopy];
+  os_unfair_lock_unlock(&_lock);
+}
+
+- (void)addAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer {
+  os_unfair_lock_lock(&_lock);
+  [_renderers addObject:renderer];
+  os_unfair_lock_unlock(&_lock);
+}
+
+- (void)removeAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer {
+  os_unfair_lock_lock(&_lock);
+  _renderers = [[_renderers
+      filteredArrayUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(id evaluatedObject,
+                                                                        NSDictionary* bindings) {
+        return evaluatedObject != renderer;
+      }]] mutableCopy];
+  os_unfair_lock_unlock(&_lock);
+}
+
+- (void)audioProcessingInitializeWithSampleRate:(size_t)sampleRateHz channels:(size_t)channels {
+  os_unfair_lock_lock(&_lock);
+  _isAudioProcessingInitialized = YES;
+  _sampleRateHz = sampleRateHz;
+  _channels = channels;
+
+  for (id<LKExternalAudioProcessingDelegate> processor in _processors) {
+    [processor audioProcessingInitializeWithSampleRate:sampleRateHz channels:channels];
+  }
+  os_unfair_lock_unlock(&_lock);
+}
+
+- (AVAudioPCMBuffer*)toPCMBuffer:(RTC_OBJC_TYPE(RTCAudioBuffer) *)audioBuffer {
+  AVAudioFormat* format =
+      [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatInt16
+                                       sampleRate:audioBuffer.frames * 100.0
+                                         channels:(AVAudioChannelCount)audioBuffer.channels
+                                      interleaved:NO];
+  AVAudioPCMBuffer* pcmBuffer =
+      [[AVAudioPCMBuffer alloc] initWithPCMFormat:format
+                                    frameCapacity:(AVAudioFrameCount)audioBuffer.frames];
+  if (!pcmBuffer) {
+    NSLog(@"Failed to create AVAudioPCMBuffer");
+    return nil;
+  }
+  pcmBuffer.frameLength = (AVAudioFrameCount)audioBuffer.frames;
+  for (int i = 0; i < audioBuffer.channels; i++) {
+    float* sourceBuffer = [audioBuffer rawBufferForChannel:i];
+    int16_t* targetBuffer = (int16_t*)pcmBuffer.int16ChannelData[i];
+    for (int frame = 0; frame < audioBuffer.frames; frame++) {
+      targetBuffer[frame] = sourceBuffer[frame];
+    }
+  }
+  return pcmBuffer;
+}
+
+- (void)audioProcessingProcess:(RTC_OBJC_TYPE(RTCAudioBuffer) *)audioBuffer {
+  os_unfair_lock_lock(&_lock);
+  for (id<LKExternalAudioProcessingDelegate> processor in _processors) {
+    [processor audioProcessingProcess:audioBuffer];
+  }
+
+  for (id<RTCAudioRenderer> renderer in _renderers) {
+    [renderer renderPCMBuffer:[self toPCMBuffer:audioBuffer]];
+  }
+  os_unfair_lock_unlock(&_lock);
+}
+
+- (void)audioProcessingRelease {
+  os_unfair_lock_lock(&_lock);
+  for (id<LKExternalAudioProcessingDelegate> processor in _processors) {
+    [processor audioProcessingRelease];
+  }
+  _isAudioProcessingInitialized = NO;
+  os_unfair_lock_unlock(&_lock);
+}
+
+@end

package/ios/LKAudioProcessingManager.h

@@ -0,0 +1,34 @@
+#import <Foundation/Foundation.h>
+#import <WebRTC/WebRTC.h>
+#import "LKAudioProcessingAdapter.h"
+
+@interface LKAudioProcessingManager : NSObject
+
+@property(nonatomic, strong) RTCDefaultAudioProcessingModule* _Nonnull audioProcessingModule;
+
+@property(nonatomic, strong) LKAudioProcessingAdapter* _Nonnull capturePostProcessingAdapter;
+
+@property(nonatomic, strong) LKAudioProcessingAdapter* _Nonnull renderPreProcessingAdapter;
+
++ (_Nonnull instancetype)sharedInstance;
+
+
+- (void)addLocalAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer;
+
+- (void)removeLocalAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer;
+
+- (void)addRemoteAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer;
+
+- (void)removeRemoteAudioRenderer:(nonnull id<RTCAudioRenderer>)renderer;
+
+- (void)addCapturePostProcessor:(nonnull id<LKExternalAudioProcessingDelegate>)processor;
+
+- (void)removeCapturePostProcessor:(nonnull id<LKExternalAudioProcessingDelegate>)processor;
+
+- (void)addRenderPreProcessor:(nonnull id<LKExternalAudioProcessingDelegate>)renderer;
+
+- (void)removeRenderPreProcessor:(nonnull id<LKExternalAudioProcessingDelegate>)renderer;
+
+- (void)clearProcessors;
+
+@end