### Setup AVAudioEngine for Audio Capture

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/integration-guide.md

Set up the AVAudioEngine to capture audio input. This involves creating an audio format and installing a tap on the input node to receive audio buffers.

```swift
func setupAudioEngine() {
    audioEngine = AVAudioEngine()
    
    let audioSession = AVAudioSession.sharedInstance()
    let sampleRate = audioSession.sampleRate
    
    let format = AVAudioFormat(
        commonFormat: .pcmFormatFloat32,
        sampleRate: sampleRate,
        channels: 1,
        interleaved: true
    )
    
    guard let format = format else {
        print("Cannot create audio format")
        return
    }
    
    desiredFormat = format
    
    audioEngine?.inputNode.installTap(
        onBus: 0,
        bufferSize: 4800,
        format: format
    ) { [weak self] buffer, _ in
        self?.handleAudioBuffer(buffer)
    }
    
    audioEngine?.prepare()
    
    do {
        try audioEngine?.start()
        print("Audio engine started")
    } catch {
        print("Failed to start audio engine: \(error)")
    }
}
```

--------------------------------

### Minimal VADWrapper Setup

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/README.md

Initialize VADWrapper, set the delegate, and configure the Silero model and sample rate. This is the basic setup for most applications.

```swift
let vadManager = VADWrapper()
vadManager.delegate = self
vadManager.setSileroModel(.v5)
vadManager.setSamplerate(.SAMPLERATE_16)
```

--------------------------------

### Voice Memo Recorder Setup and VAD Integration

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/use-cases.md

This Swift code sets up the audio session, initializes the VADManager with a Silero model and appropriate sample rate, and starts audio capture. It handles audio session configuration and VAD manager setup based on the device's sample rate.

```swift
import UIKit
import AVFoundation
import RealTimeCutVADLibrary

class VoiceMemoViewController: UIViewController, VADDelegate {
    
    var vadManager: VADWrapper?
    var audioEngine: AVAudioEngine?
    
    @IBOutlet weak var recordButton: UIButton!
    @IBOutlet weak var statusLabel: UILabel!
    @IBOutlet weak var durationLabel: UILabel!
    @IBOutlet weak var memoListTableView: UITableView!
    
    private var recordingStartTime: Date?
    private var memos: [URL] = []
    private let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        setupAudioSession()
        setupVAD()
        loadMemos()
    }
    
    func setupAudioSession() {
        let audioSession = AVAudioSession.sharedInstance()
        do {
            try audioSession.setCategory(.playAndRecord, options: .defaultToSpeaker)
            try audioSession.setActive(true, options: .notifyOthersOnDeactivation)
        } catch {
            showError("Audio session setup failed: \(error)")
        }
    }
    
    func setupVAD() {
        vadManager = VADWrapper()
        vadManager?.delegate = self
        vadManager?.setSileroModel(.v5)
        
        let audioSession = AVAudioSession.sharedInstance()
        switch audioSession.sampleRate {
        case 48000:
            vadManager?.setSamplerate(.SAMPLERATE_48)
        case 24000:
            vadManager?.setSamplerate(.SAMPLERATE_24)
        case 16000:
            vadManager?.setSamplerate(.SAMPLERATE_16)
        default:
            vadManager?.setSamplerate(.SAMPLERATE_8)
        }
        
        startAudioCapture()
    }
    
    func startAudioCapture() {
        audioEngine = AVAudioEngine()
        
        let audioSession = AVAudioSession.sharedInstance()
        let format = AVAudioFormat(
            commonFormat: .pcmFormatFloat32,
            sampleRate: audioSession.sampleRate,
            channels: 1,
            interleaved: true
        )!
        
        audioEngine?.inputNode.installTap(onBus: 0, bufferSize: 4800, format: format) { [weak self] buffer, _ in
            guard let self = self, let channelData = buffer.floatChannelData else { return }
            self.vadManager?.processAudioDataWithBuffer(
                channelData[0],
                count: UInt(buffer.frameLength)
            )
        }
        
        do {
            try audioEngine?.start()
            updateUI(recording: false)
        } catch {
            showError("Audio engine start failed: \(error)")
        }
    }
    
    func voiceStarted() {
        DispatchQueue.main.async {
            self.recordingStartTime = Date()
            self.updateUI(recording: true)
        }
    }
    
    func voiceEndedWithWavData(_ wavData: NSData!) {
        guard let data = wavData else { return }
        
        DispatchQueue.main.async {
            let duration = Date().timeIntervalSince(self.recordingStartTime ?? Date())
            let formatter = ISO8601DateFormatter()
            let timestamp = formatter.string(from: Date())
            
            let fileURL = self.documentsURL.appendingPathComponent("\(timestamp).wav")
            
            do {
                try data.write(to: fileURL)
                self.memos.append(fileURL)
                self.memoListTableView.reloadData()
                self.showSuccess("Memo saved: \(duration.formatted())s")
            } catch {
                self.showError("Failed to save memo: \(error)")
            }
            
            self.updateUI(recording: false)
        }
    }
    
    func voiceDidContinueWithPCMFloatData(_ pcmFloatData: NSData!) {
        guard let recordingStart = recordingStartTime else { return }
        
        DispatchQueue.main.async {
            let elapsed = Date().timeIntervalSince(recordingStart)
            let minutes = Int(elapsed) / 60
            let seconds = Int(elapsed) % 60
            self.durationLabel.text = String(format: "%02d:%02d", minutes, seconds)
        }
    }
    
    func updateUI(recording: Bool) {
        recordButton.backgroundColor = recording ? .systemRed : .systemBlue
        statusLabel.text = recording ? "🎙️ Recording..." : "Ready"
        statusLabel.textColor = recording ? .systemRed : .systemGreen
    }
    
    func loadMemos() {
        do {
            let contents = try FileManager.default.contentsOfDirectory(at: documentsURL, includingPropertiesForKeys: nil)
            memos = contents.filter { $0.pathExtension == "wav" } \
                .sorted { $0.lastPathComponent > $1.lastPathComponent }
        } catch {
            print("Error loading memos: \(error)")
        }
    }
    
    func showError(_ message: String) {
        let alert = UIAlertController(title: "Error", message: message, preferredStyle: .alert)

```

--------------------------------

### CocoaPods Installation

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/README.md

Add this to your Podfile to integrate the library using CocoaPods.

```ruby
pod 'RealTimeCutVADLibrary', '~> 1.0.14'
```

--------------------------------

### Meeting Recorder View Controller Setup

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/use-cases.md

Initializes the VAD manager, audio engine, and UI elements for the meeting recorder. Requires importing UIKit, AVFoundation, and the RealTimeCutVADLibrary.

```swift
import UIKit
import AVFoundation
import RealTimeCutVADLibrary

class MeetingRecorderViewController: UIViewController, VADDelegate {
    
    var vadManager: VADWrapper?
    var audioEngine: AVAudioEngine?
    
    @IBOutlet weak var recordButton: UIButton!
    @IBOutlet weak var statusLabel: UILabel!
    @IBOutlet weak var speakerCountLabel: UILabel!
    @IBOutlet weak var durationLabel: UILabel!
    
    private var isRecording = false
    private var recordingStartTime: Date?
    private var meetingSegments: [MeetingSegment] = []
    private let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
    private let segmentQueue = DispatchQueue(label: "com.example.meeting.segments")
    
    struct MeetingSegment {
        let startTime: Date
        let endTime: Date?
        let wavData: Data
        let speaker: Int  // Speaker ID (detected by voice characteristics)
    }
    
    override func viewDidLoad() {
        super.viewDidLoad() // Corrected from viewDidLoad() to viewDidLoad()
        
        setupAudioSession()
        setupVAD()
    }
    
    func setupAudioSession() {
        let audioSession = AVAudioSession.sharedInstance()
        do {
            try audioSession.setCategory(.playAndRecord, options: .defaultToSpeaker)
            try audioSession.setActive(true)
        } catch {
            print("Audio session error: \(error)")
        }
    }
    
    func setupVAD() {
        vadManager = VADWrapper()
        vadManager?.delegate = self
        vadManager?.setSileroModel(.v5)
        
        let audioSession = AVAudioSession.sharedInstance()
        switch audioSession.sampleRate {
        case 48000:
            vadManager?.setSamplerate(.SAMPLERATE_48)
        case 24000:
            vadManager?.setSamplerate(.SAMPLERATE_24)
        default:
            vadManager?.setSamplerate(.SAMPLERATE_16)
        }
        
        // Optimized for meeting environment with multiple speakers
        vadManager?.setThresholdWithVadStartDetectionProbability(
            0.75,
            vadEndDetectionProbability: 0.70,
            voiceStartVadTrueRatio: 0.6,
            voiceEndVadFalseRatio: 0.93,
            voiceStartFrameCount: 8,
            voiceEndFrameCount: 40
        )
        
        startAudioCapture()
    }
    
    func startAudioCapture() {
        audioEngine = AVAudioEngine()
        
        let format = AVAudioFormat(
            commonFormat: .pcmFormatFloat32,
            sampleRate: AVAudioSession.sharedInstance().sampleRate,
            channels: 1,
            interleaved: true
        )!
        
        audioEngine?.inputNode.installTap(onBus: 0, bufferSize: 4800, format: format) { [weak self] buffer, _ in
            guard let self = self, self.isRecording, let channelData = buffer.floatChannelData else { return }
            self.vadManager?.processAudioDataWithBuffer(
                channelData[0],
                count: UInt(buffer.frameLength)
            )
        }
        
        try? audioEngine?.start()
    }
    
    @IBAction func recordButtonTapped(_ sender: UIButton) {
        if isRecording {
            stopRecording()
        } else {
            startRecording()
        }
    }
    
    func startRecording() {
        isRecording = true
        recordingStartTime = Date()
        recordButton.setTitle("⏹️ Stop Recording", for: .normal)
        recordButton.backgroundColor = .systemRed
        statusLabel.text = "🔴 Recording..."
        updateDuration()
    }
    
    func stopRecording() {
        isRecording = false
        recordButton.setTitle("🔴 Start Recording", for: .normal)
        recordButton.backgroundColor = .systemGreen
        statusLabel.text = "Stopped"
        saveMeetingRecording()
    }
    
    func saveMeetingRecording() {
        let formatter = ISO8601DateFormatter()
        let timestamp = formatter.string(from: Date())
        
        let meetingURL = documentsURL.appendingPathComponent("meeting_\(timestamp).json")
        
        segmentQueue.async { [weak self] in
            guard let self = self else { return }
            
            // Encode meeting segments as JSON
            var meetingData = [String: Any]()
            meetingData["timestamp"] = timestamp
            meetingData["segmentCount"] = self.meetingSegments.count
            meetingData["uniqueSpeakers"] = Set(self.meetingSegments.map { $0.speaker }).count
            
            do {
                let jsonData = try JSONSerialization.data(withJSONObject: meetingData)
                try jsonData.write(to: meetingURL)
                
                DispatchQueue.main.async {
                    self.statusLabel.text = "✅ Meeting saved"
                }
            } catch {
                print("Failed to save meeting: \(error)")
            }
        }
    }
    
    func updateDuration() {
        // Implementation omitted for brevity
    }
    
    // VADDelegate method implementation would go here
    func vadDidDetectSpeaker(_ speaker: Int, vadProbability: Float, vadStart: Bool) {
        // Handle detected voice activity and speaker changes
    }
    
    func vadDidDetectVoiceActivity(_ vadProbability: Float, vadStart: Bool) {
        // Handle voice activity detection events
    }
}
```

--------------------------------

### Swift Package Manager Installation

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/README.md

Add this to your Package.swift file to integrate the library using Swift Package Manager.

```swift
.dependencies: [
    .package(url: "https://github.com/helloooideeeeea/RealTimeCutVADLibrary.git", from: "1.0.14")
]
```

--------------------------------

### Set Silero Model Version Example

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/api-reference/VADWrapper.md

Example of how to set the Silero model version using the VADManager. Use version 5 for recommended accuracy.

```Swift
// Use Silero model version 5 (recommended)
vadManager.setSileroModel(.v5)

// Or use version 4
// vadManager.setSileroModel(.v4)
```

--------------------------------

### Start Recording with AVAudioRecorder

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/integration-guide.md

Use this method for basic audio recording. Note that AVAudioRecorder does not provide real-time sample access, making it unsuitable for real-time VAD processing.

```swift
class RecorderDelegate: NSObject, AVAudioRecorderDelegate {
    var vadManager: VADWrapper?
    
    func startRecording() {
        let audioSession = AVAudioSession.sharedInstance()
        try? audioSession.setCategory(.playAndRecord)
        
        let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
        let tempURL = documentsURL.appendingPathComponent("temp_recording.wav")
        
        let settings: [String: Any] = [
            AVFormatIDKey: Int(kAudioFormatLinearPCM),
            AVSampleRateKey: 16000,
            AVNumberOfChannelsKey: 1,
            AVLinearPCMBitDepthKey: 16,
            AVLinearPCMIsNonInterleaved: false,
            AVLinearPCMIsFloatKey: false
        ]
        
        do {
            let recorder = try AVAudioRecorder(url: tempURL, settings: settings)
            recorder.delegate = self
            recorder.record()
            print("Recording started")
        } catch {
            print("Recording setup failed: \(error)")
        }
    }
    
    func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool) {
        if flag {
            print("Recording completed successfully")
        } else {
            print("Recording failed")
        }
    }
}
```

--------------------------------

### Implement VADDelegate Callbacks

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/INDEX.md

Provides example implementations for the required VADDelegate methods to handle voice events.

```swift
func voiceStarted() { /* Handle voice start */ }
func voiceEndedWithWavData(_ data: NSData) { /* Handle voice end */ }
func voiceDidContinueWithPCMFloatData(_ data: NSData) { /* Handle streaming */ }
```

--------------------------------

### Initialize and Use VADWrapper

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/api-reference/VADWrapper.md

This snippet demonstrates how to initialize VADWrapper, set the Silero model and sample rate, and set up an AVAudioEngine to process audio data for voice activity detection. It includes handling voice started, ended, and continued events.

```swift
import UIKit
import AVFoundation
import RealTimeCutVADLibrary

class ViewController: UIViewController, VADDelegate {
    var vadManager: VADWrapper?
    var audioEngine: AVAudioEngine?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Initialize VAD
        vadManager = VADWrapper()
        vadManager?.delegate = self
        vadManager?.setSileroModel(.v5)
        vadManager?.setSamplerate(.SAMPLERATE_48)
        
        // Setup audio capture
        let audioSession = AVAudioSession.sharedInstance()
        try? audioSession.setCategory(.playAndRecord)
        try? audioSession.setActive(true)
        
        audioEngine = AVAudioEngine()
        let format = AVAudioFormat(commonFormat: .pcmFormatFloat32, 
                                    sampleRate: 48000, 
                                    channels: 1, 
                                    interleaved: true)
        
        audioEngine?.inputNode.installTap(onBus: 0, bufferSize: 4800, format: format) { buffer, _ in
            guard let channelData = buffer.floatChannelData else { return }
            self.vadManager?.processAudioDataWithBuffer(channelData[0], count: UInt(buffer.frameLength))
        }
        
        try? audioEngine?.start()
    }
    
    func voiceStarted() {
        print("Voice detected!")
    }
    
    func voiceEndedWithWavData(_ wavData: NSData!) {
        print("Voice ended: \(wavData.count) bytes")
    }
    
    func voiceDidContinueWithPCMFloatData(_ pcmFloatData: NSData!) {
        print("Voice continues...")
    }
}
```

--------------------------------

### Configure VAD Sensitivity Thresholds

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/INDEX.md

Illustrates setting custom thresholds for VAD start and end detection probabilities, and ratios.

```swift
vad.setThresholdWithVadStartDetectionProbability(
    0.7, vadEndDetectionProbability: 0.7,
    voiceStartVadTrueRatio: 0.5,
    voiceEndVadFalseRatio: 0.95,
    voiceStartFrameCount: 10,
    voiceEndFrameCount: 57
)
```

--------------------------------

### Deprecated Audio Processing Example

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/api-reference/VADWrapper.md

Example demonstrating the deprecated usage of processing audio data with an array of NSNumber objects. Avoid using this method in new development.

```Swift
// ❌ Do NOT use this method
var audioDataArray: [NSNumber] = []
for i in 0..<frameLength {
    audioDataArray.append(NSNumber(value: monoAudio[i]))
}
vadManager.processAudioData(audioDataArray)
```

--------------------------------

### Real-time Audio Processing with AVAudioEngine

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/api-reference/VADWrapper.md

Example of processing audio data in real-time using AVAudioEngine. This demonstrates the recommended usage of `processAudioDataWithBuffer:count:` for efficient VAD analysis.

```Swift
// ✅ Recommended usage with AVAudioEngine
audioEngine.inputNode.installTap(onBus: 0, bufferSize: 4800, format: desiredFormat) { buffer, time in
    guard let channelData = buffer.floatChannelData else { return }
    let frameLength = UInt(buffer.frameLength)
    let monoAudio = channelData[0]
    
    // Process audio directly
    vadManager.processAudioDataWithBuffer(monoAudio, count: frameLength)
}
```

--------------------------------

### Configure Sample Rate with SL Enum

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/types.md

Example demonstrating how to set the sample rate for the VADWrapper using the SL enumeration based on the device's audio session sample rate.

```Swift
import RealTimeCutVADLibrary

let vadManager = VADWrapper()

// Set sample rate based on device audio session
let audioSession = AVAudioSession.sharedInstance()
let sampleRate = audioSession.sampleRate

switch sampleRate {
case 48000:
    vadManager.setSamplerate(.SAMPLERATE_48)
case 24000:
    vadManager.setSamplerate(.SAMPLERATE_24)
case 16000:
    vadManager.setSamplerate(.SAMPLERATE_16)
case 8000:
    vadManager.setSamplerate(.SAMPLERATE_8)
default:
    break
}
```

--------------------------------

### Voice Started Callback

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/api-reference/VADWrapper.md

Called when the VAD model detects the start of voice activity. Use this to prepare resources or notify the user.

```Swift
func voiceStarted() {
    print("Voice detected!")
    recordingStatus = .TALKING
    self.collectedPCMData = Data()
}
```

--------------------------------

### Customize VAD Thresholds in Swift

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/api-reference/VADWrapper.md

Example of customizing VAD thresholds for stricter detection using Swift. This involves setting higher start thresholds and more frames to confirm start and end.

```Swift
// Customize VAD thresholds for stricter detection
vadManager.setThresholdWithVadStartDetectionProbability(
    0.75,  // Higher start threshold
    vadEndDetectionProbability: 0.75,
    voiceStartVadTrueRatio: 0.6,
    voiceEndVadFalseRatio: 0.95,
    voiceStartFrameCount: 12,    // More frames to confirm start
    voiceEndFrameCount: 60        // More frames to confirm end
)
```

--------------------------------

### Implement VADDelegate Protocol

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/types.md

Example of a ViewController implementing the VADDelegate protocol to receive and handle voice activity events from the VADWrapper.

```Swift
class ViewController: UIViewController, VADDelegate {
    var vadManager: VADWrapper?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        vadManager = VADWrapper()
        vadManager?.delegate = self  // Set delegate
    }
    
    func voiceStarted() {
        print("Voice detected!")
    }
    
    func voiceEndedWithWavData(_ wavData: NSData!) {
        print("Recording complete: \(wavData.count) bytes")
    }
    
    func voiceDidContinueWithPCMFloatData(_ pcmFloatData: NSData!) {
        print("Voice continues...")
    }
}
```

--------------------------------

### Initialize VAD Manager and Configure Sample Rate

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/integration-guide.md

Initialize the VAD manager, set its delegate, configure the Silero model, and set the sample rate to match the audio input. This setup should be done in your view controller's initialization method.

```swift
override func viewDidLoad() {
    super.viewDidLoad()
    
    // Create VAD instance
    vadManager = VADWrapper()
    
    // Set delegate
    vadManager?.delegate = self
    
    // Configure model
    vadManager?.setSileroModel(.v5)
    
    // Configure sample rate (must match audio input)
    let audioSession = AVAudioSession.sharedInstance()
    configureVADSampleRate(audioSession.sampleRate)
    
    // Optional: customize thresholds
    // vadManager?.setThresholdWithVadStartDetectionProbability(...)
}

func configureVADSampleRate(_ sampleRate: Double) {
    switch sampleRate {
    case 48000:
        vadManager?.setSamplerate(.SAMPLERATE_48)
    case 24000:
        vadManager?.setSamplerate(.SAMPLERATE_24)
    case 16000:
        vadManager?.setSamplerate(.SAMPLERATE_16)
    case 8000:
        vadManager?.setSamplerate(.SAMPLERATE_8)
    default:
        print("Unsupported sample rate: \(sampleRate)")
    }
}
```

--------------------------------

### Process Audio Data

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/README.md

Install an audio input node tap to capture audio buffers and process them using the VADWrapper. Ensure the buffer size and format are correctly set.

```swift
audioEngine.inputNode.installTap(onBus: 0, bufferSize: 4800, format: format) { buffer, _ in
    guard let channelData = buffer.floatChannelData else { return }
    vadManager.processAudioDataWithBuffer(channelData[0], count: UInt(buffer.frameLength))
}
```

--------------------------------

### Select Silero Model Version with SMVER Enum

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/types.md

Example showing how to set the Silero VAD model version using the SMVER enumeration. Version 5 is recommended.

```Swift
import RealTimeCutVADLibrary

let vadManager = VADWrapper()

// Use version 5 (recommended)
vadManager.setSileroModel(.v5)

// Or use version 4
// vadManager.setSileroModel(.v4)
```

--------------------------------

### Handle Voice Started Event

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/integration-guide.md

This function is called when voice activity is detected. It resets collected data, updates the UI to indicate recording, and logs the start time.

```swift
func voiceStarted() {
    // Clear any previously collected data
    collectedPCMData.removeAll()
    collectedWAVData = nil
    
    // Update UI
    DispatchQueue.main.async {
        self.statusLabel.text = "🎙️ Recording..."
        self.statusLabel.textColor = .systemRed
    }
    
    // Start internal recording or logging
    recordingStartTime = Date()
    print("Voice activity detected at \(recordingStartTime)")
}
```

--------------------------------

### Speech-to-Text Integration with VAD

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/use-cases.md

This Swift code demonstrates how to set up and use Apple's Speech framework in conjunction with the RealTimeCutVADLibrary for real-time audio transcription. It handles audio session setup, VAD initialization, and speech recognition task management.

```swift
import UIKit
import AVFoundation
import Speech
import RealTimeCutVADLibrary

class SpeechToTextViewController: UIViewController, VADDelegate, SFSpeechRecognitionTaskDelegate {
    
    var vadManager: VADWrapper?
    var audioEngine: AVAudioEngine?
    var speechRecognizer: SFSpeechRecognizer?
    var recognitionRequest: SFAudioBufferRecognitionRequest?
    var recognitionTask: SFSpeechRecognitionTask?
    
    @IBOutlet weak var transcriptLabel: UILabel!
    @IBOutlet weak var confidenceLabel: UILabel!
    @IBOutlet weak var statusLabel: UILabel!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        requestSpeechRecognitionAuthorization()
        setupAudioAndVAD()
    }
    
    func requestSpeechRecognitionAuthorization() {
        SFSpeechRecognizer.requestAuthorization { authStatus in
            switch authStatus {
            case .authorized:
                print("Speech recognition authorized")
            case .denied, .restricted, .notDetermined:
                print("Speech recognition not authorized")
            @unknown default:
                break
            }
        }
    }
    
    func setupAudioAndVAD() {
        let audioSession = AVAudioSession.sharedInstance()
        do {
            try audioSession.setCategory(.playAndRecord, options: .deferredDeactivationEnabled)
            try audioSession.setActive(true, options: .notifyOthersOnDeactivation)
        } catch {
            print("Audio session error: \(error)")
            return
        }
        
        speechRecognizer = SFSpeechRecognizer()
        
        vadManager = VADWrapper()
        vadManager?.delegate = self
        vadManager?.setSileroModel(.v5)
        
        switch audioSession.sampleRate {
        case 48000:
            vadManager?.setSamplerate(.SAMPLERATE_48)
        default:
            vadManager?.setSamplerate(.SAMPLERATE_16)
        }
        
        startAudioCapture()
    }
    
    func startAudioCapture() {
        recognitionRequest = SFAudioBufferRecognitionRequest()
        recognitionRequest?.shouldReportPartialResults = true
        
        audioEngine = AVAudioEngine()
        let inputNode = audioEngine!.inputNode
        
        let recordingFormat = inputNode.outputFormat(forBus: 0)!
        
        inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { [weak self] buffer, _ in
            self?.recognitionRequest?.append(buffer)
            
            // Also send to VAD
            if let channelData = buffer.floatChannelData {
                self?.vadManager?.processAudioDataWithBuffer(
                    channelData[0],
                    count: UInt(buffer.frameLength)
                )
            }
        }
        
        audioEngine?.prepare()
        
        do {
            try audioEngine?.start()
            
            recognitionTask = speechRecognizer?.recognitionTask(
                with: recognitionRequest!
            ) { [weak self] result, error in
                if let result = result {
                    let isFinal = result.isFinal
                    let transcript = result.bestTranscription.formattedString
                    let confidence = result.bestTranscription.segments.last.map { Double($0.confidence) } ?? 0.0
                    
                    DispatchQueue.main.async {
                        self?.transcriptLabel.text = transcript
                        self?.confidenceLabel.text = String(format: "Confidence: %.0f%%", confidence * 100)
                    }
                    
                    if isFinal {
                        // Voice ended, restart recognition for next segment
                        self?.restartRecognition()
                    }
                }
                
                if let error = error {
                    print("Recognition error: \(error)")
                }
            }
        } catch {
            print("Audio engine start error: \(error)")
        }
    }
    
    func restartRecognition() {
        recognitionTask?.cancel()
        recognitionRequest = nil
        startAudioCapture()
    }
    
    func voiceStarted() {
        DispatchQueue.main.async {
            self.statusLabel.text = "🎙️ Listening..."
            self.statusLabel.textColor = .systemRed
        }
    }
    
    func voiceEndedWithWavData(_ wavData: NSData!) {
        DispatchQueue.main.async {
            self.statusLabel.text = "✅ Ready"
            self.statusLabel.textColor = .systemGreen
        }
    }
    
    func voiceDidContinueWithPCMFloatData(_ pcmFloatData: NSData!) {
        // Can use for real-time audio visualization
    }
    
    deinit {
        audioEngine?.stop()
        recognitionTask?.cancel()
    }
}
```

--------------------------------

### Implement VADDelegate Callbacks

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/README.md

Implement the VADDelegate protocol methods to handle voice detection events. This includes notifications for when voice starts, continues, and ends, with options to receive WAV or PCM data.

```swift
extension ViewController: VADDelegate {
    func voiceStarted() {
        print("Voice detected!")
    }
    
    func voiceEndedWithWavData(_ wavData: NSData!) {
        print("Recording complete: \(wavData.count) bytes")
        // Save or process WAV data
    }
    
    func voiceDidContinueWithPCMFloatData(_ pcmFloatData: NSData!) {
        // Handle real-time PCM stream
    }
}
```

--------------------------------

### Configure Audio Session for VAD

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/integration-guide.md

Configure the audio session with appropriate categories and options before starting Voice Activity Detection (VAD). This ensures proper audio routing and playback capabilities.

```swift
import AVFoundation
import RealTimeCutVADLibrary

let audioSession = AVAudioSession.sharedInstance()

do {
    try audioSession.setCategory(
        .playAndRecord,
        options: [.defaultToSpeaker, .allowBluetooth, .allowBluetoothA2DP]
    )
    try audioSession.setActive(true, options: .notifyOthersOnDeactivation)
} catch {
    print("Audio session setup failed: \(error)")
}
```

--------------------------------

### Real-Time Voice Chat Implementation

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/use-cases.md

This Swift code implements a real-time voice chat feature. It requires importing UIKit, AVFoundation, and RealTimeCutVADLibrary. The `VoiceChatViewController` class handles audio session setup, VAD initialization, and audio capture.

```swift
import UIKit
import AVFoundation
import RealTimeCutVADLibrary

class VoiceChatViewController: UIViewController, VADDelegate {
    
    var vadManager: VADWrapper? 
    var audioEngine: AVAudioEngine? 
    var callSession: CallSession? 
    
    private var collectedPCMData = Data()
    private let pcmQueue = DispatchQueue(label: "com.example.voice.chat.pcm")
    
    @IBOutlet weak var callStatusLabel: UILabel!
    @IBOutlet weak var callDurationLabel: UILabel!
    @IBOutlet weak var muteButton: UIButton!
    
    private var isMuted = false
    private var callStartTime: Date?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        setupAudioSession()
        setupVAD()
    }
    
    func setupAudioSession() {
        let audioSession = AVAudioSession.sharedInstance()
        do {
            try audioSession.setCategory(.playAndRecord, options: [.allowBluetooth, .defaultToSpeaker])
            try audioSession.setActive(true, options: .notifyOthersOnDeactivation)
        } catch {
            print("Audio session error: (error)")
        }
    }
    
    func setupVAD() {
        vadManager = VADWrapper()
        vadManager?.delegate = self
        vadManager?.setSileroModel(.v5)
        
        let audioSession = AVAudioSession.sharedInstance()
        switch audioSession.sampleRate {
        case 48000:
            vadManager?.setSamplerate(.SAMPLERATE_48)
        case 24000:
            vadManager?.setSamplerate(.SAMPLERATE_24)
        default:
            vadManager?.setSamplerate(.SAMPLERATE_16)
        }
        
        // Adjust thresholds for real-time chat (faster response)
        vadManager?.setThresholdWithVadStartDetectionProbability(
            0.6,
            vadEndDetectionProbability: 0.6,
            voiceStartVadTrueRatio: 0.4,
            voiceEndVadFalseRatio: 0.90,
            voiceStartFrameCount: 5,
            voiceEndFrameCount: 20
        )
        
        startAudioCapture()
    }
    
    func startAudioCapture() {
        audioEngine = AVAudioEngine()
        
        let audioSession = AVAudioSession.sharedInstance()
        let format = AVAudioFormat(
            commonFormat: .pcmFormatFloat32,
            sampleRate: audioSession.sampleRate,
            channels: 1,
            interleaved: true
        )!
        
        audioEngine?.inputNode.installTap(onBus: 0, bufferSize: 2400, format: format) { [weak self] buffer, _ in
            guard let self = self, !self.isMuted, let channelData = buffer.floatChannelData else { return }
            
            self.vadManager?.processAudioDataWithBuffer(
                channelData[0],
                count: UInt(buffer.frameLength)
            )
        }
        
        try? audioEngine?.start()
    }
    
    @IBAction func muteButtonTapped(_ sender: UIButton) {
        isMuted.toggle()
        muteButton.setTitle(isMuted ? "🔇 Unmute" : "🎤 Mute", for: .normal)
        muteButton.backgroundColor = isMuted ? .systemRed : .systemGreen
    }
    
    func voiceStarted() {
        guard !isMuted else { return }
        
        DispatchQueue.main.async {
            self.callStatusLabel.text = "🎙️ You are speaking"
            self.callStatusLabel.textColor = .systemRed
        }
        
        // Notify remote party that we're speaking
        self.callSession?.notifySpeakingStarted()
    }
    
    func voiceEndedWithWavData(_ wavData: NSData!) {
        DispatchQueue.main.async {
            self.callStatusLabel.text = "Listening..."
            self.callStatusLabel.textColor = .systemBlue
        }
        
        // Notify remote party that we stopped speaking
        self.callSession?.notifySpeakingStopped()
    }
    
    func voiceDidContinueWithPCMFloatData(_ pcmFloatData: NSData!) {
        guard !isMuted else { return }
        
        pcmQueue.async { [weak self] in
            guard let self = self else { return }
            
            self.collectedPCMData.append(pcmFloatData as Data)
            
            // Send chunks to remote party for streaming
            if self.collectedPCMData.count > 8192 {  // ~256ms at 16kHz
                self.callSession?.sendAudioData(self.collectedPCMData)
                self.collectedPCMData.removeAll(keepingCapacity: true)
            }
        }
    }
    
    func startCall() {
        callSession = CallSession()
        callStartTime = Date()
        updateCallDuration()
    }
    
    func updateCallDuration() {
        guard let startTime = callStartTime else { return }
        
        let elapsed = Date().timeIntervalSince(startTime)
        let hours = Int(elapsed) / 3600
        let minutes = Int(elapsed) / 60 % 60
        let seconds = Int(elapsed) % 60
        
        DispatchQueue.main.async {
            self.callDurationLabel.text = String(format: "%02d:%02d:%02d", hours, minutes, seconds)
        }
    }
}
```

--------------------------------

### Get Audio Session Properties

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/integration-guide.md

Retrieve and print the current audio session's sample rate and number of output channels. This information is useful for configuring the VAD library to match the audio input.

```swift
let sampleRate = audioSession.sampleRate
let channels = audioSession.outputNumberOfChannels
print("Sample Rate: \(sampleRate) Hz")
print("Channels: \(channels)")
```

--------------------------------

### Initialize VADWrapper and Set Parameters

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/INDEX.md

Demonstrates the initialization of VADWrapper, setting the delegate, model, and sample rate.

```swift
let vad = VADWrapper()
vad.delegate = self
vad.setSileroModel(.v5)
vad.setSamplerate(.SAMPLERATE_48)
```

--------------------------------

### Initialize VADWrapper and Configure Settings

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/configuration.md

This snippet demonstrates the complete initialization process for VADWrapper, including setting the delegate, Silero model version, sample rate, and optional threshold customization.

```swift
import RealTimeCutVADLibrary

let vadManager = VADWrapper()

// 1. Set delegate (required to receive callbacks)
vadManager.delegate = self

// 2. Set Silero model version (required)
vadManager.setSileroModel(.v5)

// 3. Set sample rate (required)
vadManager.setSamplerate(.SAMPLERATE_48)

// 4. (Optional) Customize thresholds if defaults don't suit your needs
// vadManager.setThresholdWithVadStartDetectionProbability(...)

// 5. Start processing audio
// vadManager.processAudioDataWithBuffer(audioBuffer, count: bufferSize)
```

--------------------------------

### Import RealTimeCutVADLibrary in Objective-C

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/INDEX.md

Demonstrates how to import and initialize VADWrapper in Objective-C projects.

```objc
#import <RealTimeCutVADLibrary/VADWrapper.h>

VADWrapper *vad = [[VADWrapper alloc] init];
```

--------------------------------

### Clear Collected PCM Data on Voice Start

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/integration-guide.md

Reset collected PCM data when voice starts to manage memory usage. This is crucial for applications that continuously process audio.

```swift
func voiceStarted() {
    collectedPCMData = Data()
}
```

--------------------------------

### Initialize and Configure VAD Manager

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/README.md

Initialize the VADManager, set its delegate, choose the Silero model version, and set the audio sample rate. Optional threshold configuration is also shown.

```swift
import RealTimeCutVADLibrary

class ViewController: UIViewController {
    var vadManager: VADWrapper?

    override func viewDidLoad() {
        super.viewDidLoad()

        // Initialize VAD Manager
        vadManager = VADWrapper()

        // Set VAD delegate to receive callbacks
        vadManager?.delegate = self

        // Set Silero model version (v4 or v5). Version v5 is recommended.
        vadManager?.setSileroModel(.v5)

        // Calling setVADThreshold is optional. If not called, the recommended default values will be used.
        // vadManager?.setThresholdWithVadStartDetectionProbability(0.7,0.7,0.5,0.95,10,57)

        // Set audio sample rate (8, 16, 24, or 48 kHz)
        vadManager?.setSamplerate(.SAMPLERATE_48)

        // Retrieve audio channel data from Microphone
        guard let channelData = buffer.floatChannelData else {
            return
        }

        // Extract frame length from the audio buffer
        let frameLength = UInt(buffer.frameLength)

        // Select the first channel as mono audio data
        let monoralData = channelData[0] // This is UnsafeMutablePointer<Float>

        // Send the audio data directly to VAD processing
        vadManager?.processAudioData(withBuffer: monoralData, count: frameLength)

        // ❌ Deprecated Usage. Do NOT use this method: Slow due to NSNumber conversion
        var monoralDataArray: [NSNumber] = []
        for i in 0..<frameLength {
            monoralDataArray.append(NSNumber(value: monoralData[i]))
        }
        // ⚠️ Deprecated method call
        vadManager?.processAudioData(monoralDataArray)
    }
}

extension ViewController: VADDelegate {
    // Called when voice activity starts
    func voiceStarted() {
        print("Voice detected!")
    }

    // Called when voice activity ends, providing WAV data at 16 kHz
    // The Data object includes the WAV file header metadata, making it ready for playback or saving directly.
    func voiceEnded(withWavData wavData: Data!) {
        print("Voice ended. WAV data length: \(wavData.count) bytes")
    }

    // 🆕 Called in real-time with each chunk of PCM float audio data during voice activity
    // This data is 32-bit float, mono, 16 kHz, and can be concatenated for file output or streamed live.
    // ⚠️ Make sure to handle this on a background thread, as processing in real-time on the main thread may lead to dropped audio or UI freeze.
    // For testing, save the concatenated PCM data and convert to WAV using sox:
    // $ sox -t raw -r 16000 -c 1 -e float -b 32 test_16khz_32bit.pcm test_16khz_32bit.wav
    func voiceDidContinue(withPCMFloat pcmFloatData: Data!) {
        print("voiceDidContinue")
        // ex. private let pcmDataQueue = DispatchQueue(label: "com.example.pcmDataQueue")
        pcmDataQueue.async { [weak self] in
            guard let self = self, let data = pcmFloatData else { return }
            self.collectedPCMData.append(data)
        }
    }
}
```

--------------------------------

### voiceStarted

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/api-reference/VADWrapper.md

Called when voice activity is detected. This callback is invoked when the VAD model detects the start of voice activity according to the configured thresholds.

```APIDOC
## voiceStarted (Objective-C)

### Description
Called when voice activity is detected. Use this callback to prepare resources or notify the user that voice recording has begun.

### Method
- (void)voiceStarted;

### Example
```swift
func voiceStarted() {
    print("Voice detected!")
    recordingStatus = .TALKING
    self.collectedPCMData = Data()
}
```
```

--------------------------------

### Import Necessary Frameworks

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/integration-guide.md

Import the AVFoundation and RealTimeCutVADLibrary frameworks at the beginning of your Swift file to use their functionalities.

```swift
import AVFoundation
import RealTimeCutVADLibrary
```

--------------------------------

### Update Recording Duration

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/use-cases.md

Updates the displayed duration of the recording every second. It calculates minutes and seconds from the elapsed time since recording started.

```swift
guard let startTime = recordingStartTime, isRecording else { return }
        
        let elapsed = Date().timeIntervalSince(startTime)
        let minutes = Int(elapsed) / 60
        let seconds = Int(elapsed) % 60
        
        durationLabel.text = String(format: "%02d:%02d", minutes, seconds)
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            self.updateDuration()
        }
```

--------------------------------

### Process Audio Data with Buffer

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/INDEX.md

Shows how to process audio data using a buffer in the audio tap callback.

```swift
// In audio tap callback
vad.processAudioDataWithBuffer(audioBuffer, count: bufferSize)
```

--------------------------------

### VADDelegate Protocol Definition

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/INDEX.md

Defines the VADDelegate protocol for handling voice activity events, including start, continuation, and end with associated audio data.

```swift
protocol VADDelegate
  - voiceStarted()
  - voiceEndedWithWavData(_:)
  - voiceDidContinueWithPCMFloatData(_:)
```

--------------------------------

### Unit Test VAD Initialization and Configuration

Source: https://github.com/helloooideeeeea/realtimecutvadlibrary/blob/main/_autodocs/integration-guide.md

Write unit tests to verify VAD initialization and threshold configuration. This ensures the VAD manager is set up correctly before use.

```swift
import XCTest

class VADTests: XCTestCase {
    var vadManager: VADWrapper? 
    
    override func setUp() {
        super.setUp() 
        vadManager = VADWrapper()
        vadManager?.setSileroModel(.v5)
        vadManager?.setSamplerate(.SAMPLERATE_16)
    }
    
    func testVADInitialization() {
        XCTAssertNotNil(vadManager)
    }
    
    func testThresholdConfiguration() {
        vadManager?.setThresholdWithVadStartDetectionProbability(
            0.7, vadEndDetectionProbability: 0.7,
            voiceStartVadTrueRatio: 0.5,
            voiceEndVadFalseRatio: 0.95,
            voiceStartFrameCount: 10,
            voiceEndFrameCount: 57
        )
        // Verify configuration applied
    }
}
```