Making Some Noise

Let's explore how the Switchboard SDK can be used by building a simple audio app.

To get started, create an iOS, Android project and integrate the Switchboard SDK. Please follow the integration steps on these pages. Once you have an app that you can build and run, add the following class to your project.

You can also create a C++ app and use the different nodes in C++, where you have to take care of getting the audio in and out of the audio graph in the process method.

JSON

{
  "nodes": {
    { "id": "noiseGeneratorNode", "type": "WhiteNoiseGeneratorNode" },
    { "id": "gainNode", "type": "GainNode" }
  },
  "connections": {
    { "sourceNode": "noiseGeneratorNode", "destinationNode": "gainNode" },
    { "sourceNode": "gainNode", "destinationNode": "outputNode" }
  },
}

Swift

import SwitchboardSDK

class MyAudioEngine {

    let audioEngine = SBAudioEngine()
    let audioGraph = SBAudioGraph()
    let noiseGeneratorNode = SBWhiteNoiseGeneratorNode()
    let gainNode = SBGainNode()

    init() {
        audioGraph.addNode(noiseGeneratorNode)
        audioGraph.addNode(gainNode)
        audioGraph.connect(noiseGeneratorNode, to: gainNode)
        audioGraph.connect(gainNode, to: audioGraph.outputNode)

        gainNode.gain = 0.5

        audioEngine.start(audioGraph)
    }
}

Kotlin

import com.synervoz.switchboard.sdk.AudioEngine
import com.synervoz.switchboard.sdk.audiograph.AudioGraph
import com.synervoz.switchboard.sdk.audiographnodes.WhiteNoiseGeneratorNode
import com.synervoz.switchboard.sdk.audiographnodes.GainNode

class MyAudioEngine(context: Context) {

    val audioEngine = AudioEngine(context)
    val audioGraph = AudioGraph()
    val noiseGeneratorNode = WhiteNoiseGeneratorNode()
    val gainNode = GainNode()

    init {
        audioGraph.addNode(noiseGeneratorNode)
        audioGraph.addNode(gainNode)
        audioGraph.connect(noiseGeneratorNode, gainNode)
        audioGraph.connect(gainNode, audioGraph.outputNode)

        gainNode.gain = 0.5

        audioEngine.start(audioGraph)
    }
}

C++

#include "AudioGraph.hpp"
#include "WhiteNoiseGeneratorNode.hpp"
#include "GainNode.hpp"
#include "AudioBuffer.hpp"
#include "AudioBusList.hpp"

using namespace switchboard;

class MyAudioEngine {
public:
    MyAudioEngine() {
        audioGraph.addNode(noiseGeneratorNode);
        audioGraph.addNode(gainNode);
        audioGraph.connect(noiseGeneratorNode, gainNode);
        audioGraph.connect(gainNode, audioGraph.getOutputNode());

        gainNode.setGain(0.5f);
    }

    void process(float** buffers, const uint numberOfFrames, const uint numberOfChannels, const uint sampleRate) {
        AudioBuffer<float> inBuffer(numberOfChannels, numberOfFrames, false, sampleRate, buffers);
        AudioBusList audioBusList(inBuffer);
        audioGraph.process(audioBusList, audioBusList);
    }

private:
    AudioGraph audioGraph;
    WhiteNoiseGeneratorNode noiseGeneratorNode;
    GainNode gainNode;
};

JavaScript

// Change the import to reflect the location of library
// relative to this publically accessible AudioWorklet
import {SwitchboardSDK} from "/libs/switchboard-sdk/index.js";

class SwitchboardWhiteNoiseGeneratorProcessor extends AudioWorkletProcessor {
    constructor(options) {
        super();
        this.sampleRate = options.processorOptions.sampleRate;
        this.port.onmessage = (event) => this.onMessage(event.data);
    }

    onMessage(message) {
        if (message.wasmArrayBuffer) {
            const switchboardSdkConfigObject = {
                extensions: [],
                wasmBytes: message.wasmArrayBuffer
            }
            this.configure(switchboardSdkConfigObject);
        }
    }

    configure(sdkConfig) {
        this.switchboard = new SwitchboardSDK();
        this.switchboard.configure(sdkConfig)
            .then(response => {
                this.constructAudioGraph();
            })
    }

    constructAudioGraph() {
        const inputChannelLayout = [];
        const outputChannelLayout = [1];
        const maxNumFrames = 128;

        let noiseNode = new this.switchboard.classes.WhiteNoiseGeneratorNode();
        let gainNode = new this.switchboard.classes.GainNode();

        gainNode.setGain(1);

        let audioGraph = this.switchboard.createAudioGraph(inputChannelLayout, outputChannelLayout, maxNumFrames, this.sampleRate);
        let audioGraphOutputNode = audioGraph.getOutputNode();
        audioGraph.addNode(noiseNode);
        audioGraph.addNode(gainNode);
        audioGraph.connect(noiseNode, gainNode);
        audioGraph.connect(gainNode, audioGraphOutputNode);
        audioGraph.start();

        this.noiseNode = noiseNode;
        this.gainNode = gainNode;
        this.audioGraph = audioGraph;
    }

    destruct() {
        this.audioGraph.destruct();
        this.gainNode.destruct();
        this.noiseNode.destruct();
    }

    process(inputs, outputs, parameters) {
        if (this.audioGraph) return this.audioGraph.processGraph(inputs, outputs);
        return true;
    }
}

registerProcessor("SwitchboardWhiteNoiseGeneratorProcessor", SwitchboardWhiteNoiseGeneratorProcessor);

After the above code is added, initialize the MyAudioEngine class in a place where it would get called (e.g. the main view controller or activity or main function). After this change, you should hear some generated white noise when you run the app.

The implemented audio engine class can be depicted by the following diagram:

This is what happens in this example:

• An AudioGraph is created that comes with a built-in output node.
• Two other nodes are created (noise generator and gain nodes) that are added to the audio graph.
• The noise generator's output is connected to the gain node's input. The gain node's output is connected to the output node's input.
• The gain value of the gain node is set to 0.5, which is going to reduce the volume of the generated noise.
• An AudioEngine is created which starts running the constructed AudioGraph instance.

Generating noise is this simple. For some more real-world examples check out our other examples here.