How to generate a beep with Swift

 1import AVFAudio
 2
 3final class BeepPlayer {
 4    // Initialized during configuration
 5    private var engine: AVAudioEngine!
 6    private var source: AVAudioSourceNode!
 7
 8    // Control properties
 9    private var phase = Float.zero
10    private var amplitude = Float.zero
11
12    // The frequency at which the oscillator
13    // generates soundwaves.
14    var frequency: Float
15
16    init(frequency: Float = 440) {
17        self.frequency = frequency
18    }
19}

private func configureEngine() {
    engine = AVAudioEngine()
    let mixer = engine.mainMixerNode
    mixer.outputVolume = 0.5
    let output = engine.outputNode

    let outputFormat = output.inputFormat(forBus: 0)
    let inputFormat = AVAudioFormat(commonFormat: outputFormat.commonFormat,
                                    sampleRate: outputFormat.sampleRate,
                                    channels: 1,
                                    interleaved: outputFormat.isInterleaved)

    // TODO: Create and attach audio source node

    engine.prepare()
}

init(frequency: Float = 440) {
    self.frequency = frequency
    configureEngine()
}

private func renderBlock(
    isSlience: UnsafeMutablePointer<ObjCBool>,
    timestamp: UnsafePointer<AudioTimeStamp>,
    frameCount: AVAudioFrameCount,
    outputData: UnsafeMutablePointer<AudioBufferList>
) -> OSStatus {
    // Capture self as a local variable
    // to avoid multiple Objective-C
    // symbol lookups
    let player = self

    let sampleRate = Float(player.engine.outputNode.outputFormat(forBus: 0).sampleRate)

    // A wrapper for an unsafe mutable pointer to
    // an AudioBufferList instance.
    let ablPtr = UnsafeMutableAudioBufferListPointer(outputData)

    // Phase delta between each sound frame
    let phaseDelta = 2 * Float.pi * player.frequency / sampleRate

    for frame in 0..<Int(frameCount) {
        // Calculate sample for frame based on
        // current phase, frame index, and amplitude.
        let sample = sin(player.phase) * player.amplitude
        // Increment the phase by fixed delta.
        player.phase += phaseDelta

        // Fract the phase between 0...2*pi
        if player.phase > .pi * 2 {
            player.phase -= .pi * 2
        }

        for buffer in ablPtr {
            let ptr = buffer.mData!.assumingMemoryBound(to: Float.self)
            ptr[frame] = sample
        }
    }

    return noErr
}

private func configureEngine() {
    // ...

    // Create source node
    source = AVAudioSourceNode(renderBlock: renderBlock)

    // Attach source node
    engine.attach(source)
    engine.connect(source, to: mixer, format: inputFormat)

    engine.prepare()
}

func startEngine() {
    guard !engine.isRunning else { return }
    do {
        try engine.start()
    } catch {
        // Catch the error
        print(error.localizedDescription)
    }
}

func beep(withFrequency frequency: Float? = nil) {
    if let frequency {
        self.frequency = frequency
    }
    amplitude = 0.2
}

func stopBeep() {
    amplitude = .zero
}

 1// BeepPlayer.swift
 2
 3import AVFAudio
 4
 5final class BeepPlayer {
 6    private var engine: AVAudioEngine!
 7    private var source: AVAudioSourceNode!
 8
 9    private var phase = Float.zero
10    private var amplitude = Float.zero
11
12    var frequency: Float
13
14    init(frequency: Float = 440) {
15        self.frequency = frequency
16        configureEngine()
17    }
18
19    private func configureEngine() {
20        engine = AVAudioEngine()
21        let mixer = engine.mainMixerNode
22        mixer.outputVolume = 0.5
23        let output = engine.outputNode
24
25        let outputFormat = output.inputFormat(forBus: 0)
26        let inputFormat = AVAudioFormat(commonFormat: outputFormat.commonFormat, sampleRate: outputFormat.sampleRate, channels: 1, interleaved: outputFormat.isInterleaved)
27
28        source = AVAudioSourceNode(renderBlock: renderBlock)
29
30        engine.attach(source)
31        engine.connect(source, to: mixer, format: inputFormat)
32
33        engine.prepare()
34    }
35
36    private func renderBlock(
37        isSlience: UnsafeMutablePointer<ObjCBool>,
38        timestamp: UnsafePointer<AudioTimeStamp>,
39        frameCount: AVAudioFrameCount,
40        outputData: UnsafeMutablePointer<AudioBufferList>
41    ) -> OSStatus {
42        let player = self
43
44        let sampleRate = Float(player.engine.outputNode.outputFormat(forBus: 0).sampleRate)
45
46        let ablPtr = UnsafeMutableAudioBufferListPointer(outputData)
47
48        let phaseDelta = 2 * Float.pi * player.frequency / sampleRate
49
50        for frame in 0..<Int(frameCount) {
51            let sample = sin(player.phase) * player.amplitude
52            player.phase += phaseDelta
53
54            if player.phase > .pi * 2 {
55                player.phase -= .pi * 2
56            }
57
58            for buffer in ablPtr {
59                let ptr = buffer.mData!.assumingMemoryBound(to: Float.self)
60                ptr[frame] = sample
61            }
62        }
63
64        return noErr
65    }
66
67    func startEngine() {
68        guard !engine.isRunning else { return }
69        do {
70            try engine.start()
71        } catch {
72            print(error.localizedDescription)
73        }
74    }
75
76    func beep(withFrequency frequency: Float? = nil) {
77        if let frequency {
78            self.frequency = frequency
79        }
80        amplitude = 0.2
81    }
82
83    func stopBeep() {
84        amplitude = .zero
85    }
86}