Multitrack Recorder App

Multitrack recording is a technique used in audio production that allows for the separate recording and mixing of individual audio tracks. In multitrack recording, each instrument or vocal track is recorded onto a separate track, which can then be mixed together with other tracks to create a final mix.

Using the components of the SwitchboardSDK we can simply create an app like this. We need to create an AudioGraph with multiple recorders, and mix the recordings together. We can even apply various effects on the different tracks. To check the list of available effects please visit our extensions page. Let's say we want to have three different tracks:

• our voice with applied compressor effect on it
• a guitar track with reverb effect
• a piano track with flanger effect

The sketch of the audio graph will help us understand how the nodes will be connected:

Now let's take a look at code:

Swift

import SwitchboardSDK

class MultitrackRecorderExample {

    let audioEngine = SBAudioEngine()
    let audioGraph = SBAudioGraph()

    let voiceRecorderNode: SBRecorderNode
    let guitarRecorderNode: SBRecorderNode
    let pianoRecorderNode: SBRecorderNode

    let voicePlayerNode = SBAudioPlayerNode()
    let guitarPlayerNode = SBAudioPlayerNode()
    let pianoPlayerNode = SBAudioPlayerNode()

    let compressorNode = SBCompressorNode()
    let reverbNode = SBReverbNode()
    let flangerNode = SBFlangerNode()

    let mixerNode = SBMixerNode()

    let currentFormat: SBCodec = .wav

    init() {

        voiceRecorderNode = SBRecorderNode(
            name: "UniqueID1",
            recordingSampleRate: 48000,
            numberOfRecordedChannels: 2
        )

        guitarRecorderNode = SBRecorderNode(
            name: "UniqueID2",
            recordingSampleRate: 48000,
            numberOfRecordedChannels: 2
        )

        pianoRecorderNode = SBRecorderNode(
            name: "UniqueID3",
            recordingSampleRate: 48000,
            numberOfRecordedChannels: 2
        )

        audioGraph.add(voiceRecorderNode)
        audioGraph.add(voiceRecorderNode)
        audioGraph.add(voiceRecorderNode)

        audioGraph.add(voicePlayerNode)
        audioGraph.add(guitarPlayerNode)
        audioGraph.add(pianoPlayerNode)

        audioGraph.add(compressorNode)
        audioGraph.add(reverbNode)
        audioGraph.add(flangerNode)

        audioGraph.add(mixerNode)

        audioGraph.connect(audioGraph.inputNode, to: voiceRecorderNode)
        audioGraph.connect(audioGraph.inputNode, to: guitarRecorderNode)
        audioGraph.connect(audioGraph.inputNode, to: pianoRecorderNode)

        audioGraph.connect(voicePlayerNode, to: compressorNode)
        audioGraph.connect(guitarPlayerNode, to: reverbNode)
        audioGraph.connect(pianoPlayerNode, to: flangerNode)

        audioGraph.connect(compressorNode, to: mixerNode)
        audioGraph.connect(reverbNode, to: mixerNode)
        audioGraph.connect(flangerNode, to: mixerNode)

        audioGraph.connect(mixerNode, to: audioGraph.outputNode)

        compressorNode.isEnabled = true
        reverbNode.isEnabled = true
        flangerNode.isEnabled = true

        audioEngine.microphoneEnabled = true
        audioEngine.start(audioGraph)
    }

    func startRecording(typeId: String) {
        switch typeId {
            case "voice": voiceRecorderNode.start()
            case "guitar": guitarRecorderNode.start()
            case "piano": pianoRecorderNode.start()
        }
    }

    func stopRecording(typeId: String, fileName: String) {
        switch typeId {
            case "voice": voiceRecorderNode.stop(fileName, withFormat: currentFormat)
            case "guitar": guitarRecorderNode.stop(fileName, withFormat: currentFormat)
            case "piano": pianoRecorderNode.stop(fileName, withFormat: currentFormat)
        }
    }

    func loadRecordingIntoAudioPlayer(path: String, typeId: String) {
        switch typeId {
            case "voice": voicePlayerNode.load(path, withFormat: currentFormat)
            case "guitar": guitarPlayerNode.load(path, withFormat: currentFormat)
            case "piano": pianoPlayerNode.load(path, withFormat: currentFormat)
        }
    }

    func startAudioPlayer(typeId: String) {
        switch typeId {
            case "voice": voicePlayerNode.play()
            case "guitar": guitarPlayerNode.play()
            case "piano": pianoPlayerNode.play()
        }
    }

    func stopAudioPlayer(typeId: String) {
        switch typeId {
            case "voice": voicePlayerNode.stop()
            case "guitar": guitarPlayerNode.stop()
            case "piano": pianoPlayerNode.stop()
        }
    }
}

Kotlin

import com.synervoz.switchboard.sdk.Codec
import com.synervoz.switchboard.sdk.audioengine.AudioEngine
import com.synervoz.switchboard.sdk.audiograph.AudioGraph
import com.synervoz.switchboard.sdk.audiographnodes.AudioPlayerNode
import com.synervoz.switchboard.sdk.audiographnodes.MixerNode
import com.synervoz.switchboard.sdk.audiographnodes.RecorderNode

class MultitrackRecorderExample {

    val audioEngine = AudioEngine()
    val audioGraph = AudioGraph()

    val voiceRecorderNode: RecorderNode
    val guitarRecorderNode: RecorderNode
    val pianoRecorderNode: RecorderNode

    val voicePlayerNode = AudioPlayerNode()
    val guitarPlayerNode = AudioPlayerNode()
    val pianoPlayerNode = AudioPlayerNode()

    val compressorNode = CompressorNode()
    val reverbNode = ReverbNode()
    val flangerNode = FlangerNode()

    val mixerNode = MixerNode()

    val currentFormat: Codec = Codec.wav

    init() {
        voiceRecorderNode = RecorderNode(
            name: "UniqueID1",
            recordingSampleRate: 48000,
            numberOfRecordedChannels: 2
        )

        guitarRecorderNode = RecorderNode(
            name: "UniqueID2",
            recordingSampleRate: 48000,
            numberOfRecordedChannels: 2
        )

        pianoRecorderNode = RecorderNode(
            name: "UniqueID3",
            recordingSampleRate: 48000,
            numberOfRecordedChannels: 2
        )

        audioGraph.add(voiceRecorderNode)
        audioGraph.add(voiceRecorderNode)
        audioGraph.add(voiceRecorderNode)

        audioGraph.add(voicePlayerNode)
        audioGraph.add(guitarPlayerNode)
        audioGraph.add(pianoPlayerNode)

        audioGraph.add(compressorNode)
        audioGraph.add(reverbNode)
        audioGraph.add(flangerNode)

        audioGraph.add(mixerNode)

        audioGraph.connect(audioGraph.inputNode, voiceRecorderNode)
        audioGraph.connect(audioGraph.inputNode, guitarRecorderNode)
        audioGraph.connect(audioGraph.inputNode, pianoRecorderNode)

        audioGraph.connect(voicePlayerNode, compressorNode)
        audioGraph.connect(guitarPlayerNode, reverbNode)
        audioGraph.connect(pianoPlayerNode, flangerNode)

        audioGraph.connect(compressorNode, mixerNode)
        audioGraph.connect(reverbNode, mixerNode)
        audioGraph.connect(flangerNode, mixerNode)

        audioGraph.connect(mixerNode, audioGraph.outputNode)

        compressorNode.isEnabled = true
        reverbNode.isEnabled = true
        flangerNode.isEnabled = true

        audioEngine.enableMicrophone(true)
        audioEngine.start(audioGraph)
    }

    fun startRecording(typeId: String) {
        switch typeId {
            case "voice": voiceRecorderNode.start()
            case "guitar": guitarRecorderNode.start()
            case "piano": pianoRecorderNode.start()
        }
    }

    fun stopRecording(typeId: String, fileName: String) {
        switch typeId {
            case "voice": voiceRecorderNode.stop(fileName, currentFormat)
            case "guitar": guitarRecorderNode.stop(fileName, currentFormat)
            case "piano": pianoRecorderNode.stop(fileName, currentFormat)
        }
    }

    fun loadRecordingIntoAudioPlayer(path: String, typeId: String) {
        switch typeId {
            case "voice": voicePlayerNode.load(path, currentFormat)
            case "guitar": guitarPlayerNode.load(path, currentFormat)
            case "piano": pianoPlayerNode.load(path, currentFormat)
        }
    }

    fun startAudioPlayer(typeId: String) {
        switch typeId {
            case "voice": voicePlayerNode.play()
            case "guitar": guitarPlayerNode.play()
            case "piano": pianoPlayerNode.play()
        }
    }

    fun stopAudioPlayer(typeId: String) {
        switch typeId {
            case "voice": voicePlayerNode.stop()
            case "guitar": guitarPlayerNode.stop()
            case "piano": pianoPlayerNode.stop()
        }
    }
}