class GainAudioProcessor : AudioProcessorInterface {
    private var gain: Float = 1.0f

    override fun initializeAudioProcessing(sampleRateHz: Int, numChannels: Int) {
        // Initialize your processor with sample rate and channel info
    }

    override fun processAudio(numBands: Int, numFrames: Int, buffer: ByteBuffer) {
        // Apply gain control to the audio buffer
        // Convert buffer to audio samples, apply gain, and write back
    }

    override fun resetAudioProcessing(newRate: Int) {
        // Handle sample rate changes
    }

    fun setGain(newGain: Float) {
        gain = newGain
    }
}

val audioProcessorOptions = AudioProcessorOptions(
    capturePostProcessor = GainAudioProcessor()
)

val liveKitOverrides = LiveKitOverrides(
    audioOptions = AudioOptions(
        audioProcessorOptions = audioProcessorOptions
    )
)

class GainAudioProcessor: AudioCustomProcessingDelegate {
    var gain: Float = 1.0

    func audioProcessingInitialize(sampleRate sampleRateHz: Int, channels: Int) {
        // Initialize with sample rate and channel count
    }

    func audioProcessingProcess(audioBuffer: LKAudioBuffer) {
        // Apply gain control to the audio buffer
        // Modify audioBuffer.data in place
    }

    func audioProcessingRelease() {
        // Clean up resources
    }
}

AudioManager.shared.capturePostProcessingDelegate = GainAudioProcessor()

from livekit.rtc import AudioProcessingModule

# Enable auto gain control
apm = AudioProcessingModule(
    auto_gain_control=True,
    echo_cancellation=False,
    noise_suppression=False,
    high_pass_filter=False
)

# Process audio frames
apm.process_stream(audio_frame)

def _adjust_volume_in_frame(self, frame: rtc.AudioFrame, gain: float) -> rtc.AudioFrame:
    audio_data = np.frombuffer(frame.data, dtype=np.int16)
    audio_float = audio_data.astype(np.float32) / np.iinfo(np.int16).max
    audio_float = audio_float * gain  # Apply gain
    processed = (audio_float * np.iinfo(np.int16).max).astype(np.int16)

    return rtc.AudioFrame(
        data=processed.tobytes(),
        sample_rate=frame.sample_rate,
        num_channels=frame.num_channels,
        samples_per_channel=len(processed) // frame.num_channels,
    )

capturePostProcessor