iOS Real-Time Noise Suppression SDK: Swift Tutorial

Key Takeaways

• SDK-Based Integration: Embeddable noise suppression library that runs inside your app's audio pipeline, not a system-level feature or end-user tool
• Built for Developers: Full programmatic control over when and how noise suppression is applied in real-time communication apps
• On-Device Processing: All noise suppression happens locally with zero network latency, ensuring user privacy
• Production-Ready Performance: Designed for real-time scenarios; minimal audio delay for smooth voice experiences

The Koala Noise Suppression iOS SDK is a real-time, on-device noise suppression library for Swift developers building real-time communication apps on iOS.

Koala Noise Suppression enables developers to remove background noise from live audio streams—such as voice calls, video conferences, and in-app chats—directly on the device with minimal latency. Running entirely within an iOS app's audio pipeline, Koala Noise Suppression gives developers full programmatic control while keeping user audio private and offline. This eliminates the need to rely on users to adopt end-user tools like Apple's Voice Isolation or other system-level noise cancellation.

This developer guide shows how to integrate the Koala Noise Suppression iOS SDK into your iOS app with Swift code examples.

Step-by-Step: Integrating Real-Time Noise Suppression in iOS Apps

Prerequisites

Supported Platforms

• iOS (16.0+)

Requirements

• Xcode
• Swift Package Manager or CocoaPods

Step 1: Install the Noise Suppression SDK

We'll install two libraries—Koala (noise suppression library) and ios-voice-processor (audio capture library).

Option A: Swift Package Manager (Recommended)

1. Open your Xcode project
2. Go to File → Add Package Dependencies
3. Enter the repository URL: https://github.com/Picovoice/koala.git
4. Click "Add Package"

Repeat the above steps for https://github.com/Picovoice/ios-voice-processor.git.

Option B: CocoaPods

Add to your Podfile:

pod 'Koala-iOS'
pod 'ios-voice-processor'

Then run:

pod install

Step 2: Get Your SDK Access Key

1. Sign up for a free account on Picovoice Console
2. Copy your AccessKey from the dashboard

Step 3: Configure Microphone Permissions

Add the microphone usage description to your Info.plist:

<key>NSMicrophoneUsageDescription</key>
<string>This app needs microphone access to enhance voice clarity during calls.</string>

This message appears when iOS requests microphone permission from the user.

Step 4: Initialize the Noise Suppression SDK

Import Koala and create an instance with your AccessKey:

import Koala

do {
    let koala = try Koala(accessKey: "${ACCESS_KEY}")
} catch {
    print("Failed to initialize Koala: \(error)")
}

Step 5: Set Up the Noise Suppression Pipeline

Using VoiceProcessor, create an audio callback that passes microphone input to the Koala SDK for noise suppression:

import ios_voice_processor

let audioCallback = VoiceProcessorFrameListener { frame in
    do {
        let cleanAudio = try koala.process(pcm: frame)
        // Use cleanAudio here
    } catch {
        print("Processing error: \(error)")
    }
}

VoiceProcessor.instance.addFrameListener(audioCallback)

Latency: The processing delay is available via the koala.delaySample property.

Step 6: Start Real-Time Noise Suppression

Request microphone permission and start the noise suppression pipeline:

guard VoiceProcessor.hasRecordAudioPermission else {
    VoiceProcessor.requestRecordAudioPermission { granted in
        guard granted else {
            print("Microphone permission denied")
            return
        }
        
        do {
            try VoiceProcessor.instance.start(
                frameLength: Koala.frameLength,
                sampleRate: Koala.sampleRate
            )
        } catch {
            print("Failed to start recording: \(error)")
        }
    }
    return
}

// Permission already granted
try VoiceProcessor.instance.start(
    frameLength: Koala.frameLength,
    sampleRate: Koala.sampleRate
)

Critical Audio Format Requirements:

The SDK expects audio in a specific format:

• Bit Depth: 16-bit PCM
• Channels: Mono (single-channel)
• Sample Rate: Accessed via Koala.sampleRate
• Frame Length: Fixed size matching Koala.frameLength

Step 7: Handle Audio Session Management

If an audio frame does not immediately follow the previous one—for example, when a new audio stream starts after the previous one ends—reset the Koala's internal state before beginning the new stream:

try koala.reset()

Step 8: Clean Up Noise Suppression Resources

Properly release resources when stopping noise suppression:

koala.delete()

Stop audio capture and clear listeners:

try VoiceProcessor.instance.stop()
VoiceProcessor.instance.clearFrameListeners()

Key Points to Remember

1. Audio Format: Koala requires 16-bit, single-channel (mono) PCM
2. Frame Size: Always use Koala.frameLength
3. Sample Rate: Always use Koala.sampleRate
4. Reset: Only call between separate audio streams, not during continuous audio
5. Cleanup: Always call delete() to free memory

For a complete example application, check out the Koala Noise Suppression iOS demo on GitHub.

SDK Dependencies

This tutorial uses the following packages:

• Koala-iOS - Noise suppression library
• ios-voice-processor - Audio capture library

Additional Resources

Comprehensive SDK documentation:

• Koala Noise Suppression Quick Start
• Koala Noise Suppression API Reference
• iOS Voice Processor Quick Start
• iOS Voice Processor API Reference

Troubleshooting Common SDK Integration Issues

SDK Initialization Failures

Problem: Koala fails to initialize with authentication errors.

Solutions:

• Verify your AccessKey is copied correctly from Picovoice Console (no extra spaces or characters)
• Ensure device has internet connectivity for initial license verification
• Confirm Koala SDK is properly installed and imported into your project
• Verify your app's deployment target meets iOS 16.0 minimum requirement

Audio Processing Errors

Problem: Runtime errors when calling process().

Solutions:

• Verify audio frames are exactly Koala.frameLength samples
• Confirm sample rate is Koala.sampleRate
• Ensure audio format is 16-bit PCM, mono channel

Poor Noise Suppression Quality

Problem: Noise suppression isn't working as expected.

Solutions:

• Verify the microphone is working properly and capturing audio
• Check that you're not calling reset() during continuous audio
• Ensure audio frames are provided in the correct chronological order
• Confirm audio isn't being pre-processed by other filters that might interfere
• Test with different noise environments to verify functionality

Conclusion

The Koala Noise Suppression SDK provides developers with a production-ready noise cancellation library for iOS apps. With this implementation guide, you can integrate real-time noise suppression into your iOS app and deliver clear, professional audio experiences to your users.

Frequently Asked Questions