Rack/src/core/AudioInterface.cpp

#include <assert.h>
#include <mutex>
#include <chrono>
#include <thread>
#include <mutex>
#include <condition_variable>
#include "core.hpp"
#include "audio.hpp"
#include "dsp/samplerate.hpp"
#include "dsp/ringbuffer.hpp"

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsuggest-override"
#include <RtAudio.h>
#pragma GCC diagnostic pop


#define OUTPUTS 8
#define INPUTS 8

static const auto audioTimeout = std::chrono::milliseconds(100);


using namespace rack;


struct AudioInterfaceIO : AudioIO {
	std::mutex engineMutex;
	std::condition_variable engineCv;
	std::mutex audioMutex;
	std::condition_variable audioCv;
	// Audio thread produces, engine thread consumes
	DoubleRingBuffer<Frame<INPUTS>, (1<<15)> inputBuffer;
	// Audio thread consumes, engine thread produces
	DoubleRingBuffer<Frame<OUTPUTS>, (1<<15)> outputBuffer;

	AudioInterfaceIO() {
	}

	~AudioInterfaceIO() {
		// Close stream here before destructing AudioInterfaceIO, so the mutexes are still valid when waiting to close.
		closeStream();
	}

	void processStream(const float *input, float *output, int length) override {
		if (numInputs > 0) {
			// TODO Do we need to wait on the input to be consumed here? Experimentally, it works fine if we don't.
			for (int i = 0; i < length; i++) {
				if (inputBuffer.full())
					break;
				Frame<INPUTS> f;
				memset(&f, 0, sizeof(f));
				memcpy(&f, &input[numInputs * i], numInputs * sizeof(float));
				inputBuffer.push(f);
			}
		}

		if (numOutputs > 0) {
			std::unique_lock<std::mutex> lock(audioMutex);
			auto cond = [&] {
				return outputBuffer.size() >= length;
			};
			if (audioCv.wait_for(lock, audioTimeout, cond)) {
				// Consume audio block
				for (int i = 0; i < length; i++) {
					Frame<OUTPUTS> f = outputBuffer.shift();
					memcpy(&output[numOutputs * i], &f, numOutputs * sizeof(float));
				}
			}
			else {
				// Timed out, fill output with zeros
				memset(output, 0, length * numOutputs * sizeof(float));
			}
		}

		// Notify engine when finished processing
		engineCv.notify_all();
	}

	void onCloseStream() override {
		inputBuffer.clear();
		outputBuffer.clear();
	}
};


struct AudioInterface : Module {
	enum ParamIds {
		NUM_PARAMS
	};
	enum InputIds {
		ENUMS(AUDIO_INPUT, INPUTS),
		NUM_INPUTS
	};
	enum OutputIds {
		ENUMS(AUDIO_OUTPUT, OUTPUTS),
		NUM_OUTPUTS
	};
	enum LightIds {
		ENUMS(INPUT_LIGHT, INPUTS),
		ENUMS(OUTPUT_LIGHT, OUTPUTS),
		NUM_LIGHTS
	};

	AudioInterfaceIO audioIO;
	int lastSampleRate = 0;

	SampleRateConverter<INPUTS> inputSrc;
	SampleRateConverter<OUTPUTS> outputSrc;

	// in rack's sample rate
	DoubleRingBuffer<Frame<INPUTS>, 16> inputBuffer;
	DoubleRingBuffer<Frame<OUTPUTS>, 16> outputBuffer;

	AudioInterface() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {
		onSampleRateChange();
	}

	void step() override;

	json_t *toJson() override {
		json_t *rootJ = json_object();
		json_object_set_new(rootJ, "audio", audioIO.toJson());
		return rootJ;
	}

	void fromJson(json_t *rootJ) override {
		json_t *audioJ = json_object_get(rootJ, "audio");
		audioIO.fromJson(audioJ);
	}

	void onSampleRateChange() override {
		// for (int i = 0; i < INPUTS; i++) {
		// 	inputSrc[i].setRates(audioIO.sampleRate, engineGetSampleRate());
		// }
		// for (int i = 0; i < OUTPUTS; i++) {
		// 	outputSrc[i].setRates(engineGetSampleRate(), audioIO.sampleRate);
		// }
		inputSrc.setRates(audioIO.sampleRate, engineGetSampleRate());
		outputSrc.setRates(engineGetSampleRate(), audioIO.sampleRate);
	}

	void onReset() override {
		audioIO.closeStream();
	}
};


void AudioInterface::step() {
	Frame<INPUTS> inputFrame;
	memset(&inputFrame, 0, sizeof(inputFrame));

	// Update sample rate if changed by audio driver
	if (audioIO.sampleRate != lastSampleRate) {
		onSampleRateChange();
		lastSampleRate = audioIO.sampleRate;
	}

	if (audioIO.numInputs > 0) {
		if (inputBuffer.empty()) {
			int inLen = audioIO.inputBuffer.size();
			int outLen = inputBuffer.capacity();
			inputSrc.process(audioIO.inputBuffer.startData(), &inLen, inputBuffer.endData(), &outLen);
			audioIO.inputBuffer.startIncr(inLen);
			inputBuffer.endIncr(outLen);
		}
	}

	if (!inputBuffer.empty()) {
		inputFrame = inputBuffer.shift();
	}
	for (int i = 0; i < INPUTS; i++) {
		outputs[AUDIO_OUTPUT + i].value = 10.0 * inputFrame.samples[i];
	}

	if (audioIO.numOutputs > 0) {
		// Get and push output SRC frame
		if (!outputBuffer.full()) {
			Frame<OUTPUTS> f;
			for (int i = 0; i < audioIO.numOutputs; i++) {
				f.samples[i] = inputs[AUDIO_INPUT + i].value / 10.0;
			}
			outputBuffer.push(f);
		}

		if (outputBuffer.full()) {
			// Wait until outputs are needed
			std::unique_lock<std::mutex> lock(audioIO.engineMutex);
			auto cond = [&] {
				return audioIO.outputBuffer.size() < audioIO.blockSize;
			};
			if (audioIO.engineCv.wait_for(lock, audioTimeout, cond)) {
				// Push converted output
				int inLen = outputBuffer.size();
				int outLen = audioIO.outputBuffer.capacity();
				outputSrc.process(outputBuffer.startData(), &inLen, audioIO.outputBuffer.endData(), &outLen);
				outputBuffer.startIncr(inLen);
				audioIO.outputBuffer.endIncr(outLen);
			}
			else {
				// Give up on pushing output
			}
		}
	}

	for (int i = 0; i < INPUTS; i++)
		lights[INPUT_LIGHT + i].value = (audioIO.numInputs > i);
	for (int i = 0; i < OUTPUTS; i++)
		lights[OUTPUT_LIGHT + i].value = (audioIO.numOutputs > i);

	audioIO.audioCv.notify_all();
}


struct AudioInterfaceWidget : ModuleWidget {
	AudioInterfaceWidget(AudioInterface *module);
};


AudioInterfaceWidget::AudioInterfaceWidget(AudioInterface *module) : ModuleWidget(module) {
	setPanel(SVG::load(assetGlobal("res/Core/AudioInterface.svg")));

	addChild(Widget::create<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));
	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));
	addChild(Widget::create<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));
	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

	addInput(Port::create<PJ301MPort>(mm2px(Vec(3.89433, 55.5308)), Port::INPUT, module, AudioInterface::AUDIO_INPUT + 0));
	addInput(Port::create<PJ301MPort>(mm2px(Vec(15.4947, 55.5308)), Port::INPUT, module, AudioInterface::AUDIO_INPUT + 1));
	addInput(Port::create<PJ301MPort>(mm2px(Vec(27.095, 55.5308)), Port::INPUT, module, AudioInterface::AUDIO_INPUT + 2));
	addInput(Port::create<PJ301MPort>(mm2px(Vec(38.6953, 55.5308)), Port::INPUT, module, AudioInterface::AUDIO_INPUT + 3));
	addInput(Port::create<PJ301MPort>(mm2px(Vec(3.89433, 70.1449)), Port::INPUT, module, AudioInterface::AUDIO_INPUT + 4));
	addInput(Port::create<PJ301MPort>(mm2px(Vec(15.4947, 70.1449)), Port::INPUT, module, AudioInterface::AUDIO_INPUT + 5));
	addInput(Port::create<PJ301MPort>(mm2px(Vec(27.095, 70.1449)), Port::INPUT, module, AudioInterface::AUDIO_INPUT + 6));
	addInput(Port::create<PJ301MPort>(mm2px(Vec(38.6953, 70.1449)), Port::INPUT, module, AudioInterface::AUDIO_INPUT + 7));

	addOutput(Port::create<PJ301MPort>(mm2px(Vec(3.89295, 92.1439)), Port::OUTPUT, module, AudioInterface::AUDIO_OUTPUT + 0));
	addOutput(Port::create<PJ301MPort>(mm2px(Vec(15.4933, 92.1439)), Port::OUTPUT, module, AudioInterface::AUDIO_OUTPUT + 1));
	addOutput(Port::create<PJ301MPort>(mm2px(Vec(27.0936, 92.1439)), Port::OUTPUT, module, AudioInterface::AUDIO_OUTPUT + 2));
	addOutput(Port::create<PJ301MPort>(mm2px(Vec(38.6939, 92.1439)), Port::OUTPUT, module, AudioInterface::AUDIO_OUTPUT + 3));
	addOutput(Port::create<PJ301MPort>(mm2px(Vec(3.89433, 108.144)), Port::OUTPUT, module, AudioInterface::AUDIO_OUTPUT + 4));
	addOutput(Port::create<PJ301MPort>(mm2px(Vec(15.4947, 108.144)), Port::OUTPUT, module, AudioInterface::AUDIO_OUTPUT + 5));
	addOutput(Port::create<PJ301MPort>(mm2px(Vec(27.095, 108.144)), Port::OUTPUT, module, AudioInterface::AUDIO_OUTPUT + 6));
	addOutput(Port::create<PJ301MPort>(mm2px(Vec(38.6953, 108.144)), Port::OUTPUT, module, AudioInterface::AUDIO_OUTPUT + 7));

	Vec lightOffset = mm2px(Vec(7.21812, -0.1833));

	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(3.89433, 55.5308)).plus(lightOffset), module, AudioInterface::INPUT_LIGHT + 0));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(15.4947, 55.5308)).plus(lightOffset), module, AudioInterface::INPUT_LIGHT + 1));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(27.095, 55.5308)).plus(lightOffset), module, AudioInterface::INPUT_LIGHT + 2));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(38.6953, 55.5308)).plus(lightOffset), module, AudioInterface::INPUT_LIGHT + 3));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(3.89433, 70.1449)).plus(lightOffset), module, AudioInterface::INPUT_LIGHT + 4));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(15.4947, 70.1449)).plus(lightOffset), module, AudioInterface::INPUT_LIGHT + 5));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(27.095, 70.1449)).plus(lightOffset), module, AudioInterface::INPUT_LIGHT + 6));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(38.6953, 70.1449)).plus(lightOffset), module, AudioInterface::INPUT_LIGHT + 7));

	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(3.89295, 92.1439)).plus(lightOffset), module, AudioInterface::OUTPUT_LIGHT + 0));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(15.4933, 92.1439)).plus(lightOffset), module, AudioInterface::OUTPUT_LIGHT + 1));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(27.0936, 92.1439)).plus(lightOffset), module, AudioInterface::OUTPUT_LIGHT + 2));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(38.6939, 92.1439)).plus(lightOffset), module, AudioInterface::OUTPUT_LIGHT + 3));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(3.89433, 108.144)).plus(lightOffset), module, AudioInterface::OUTPUT_LIGHT + 4));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(15.4947, 108.144)).plus(lightOffset), module, AudioInterface::OUTPUT_LIGHT + 5));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(27.095, 108.144)).plus(lightOffset), module, AudioInterface::OUTPUT_LIGHT + 6));
	addChild(ModuleLightWidget::create<TinyLight<YellowLight>>(mm2px(Vec(38.6953, 108.144)).plus(lightOffset), module, AudioInterface::OUTPUT_LIGHT + 7));


	AudioWidget *audioWidget = Widget::create<AudioWidget>(mm2px(Vec(3.401, 14.8373)));
	audioWidget->box.size = mm2px(Vec(44, 28));
	audioWidget->audioIO = &module->audioIO;
	addChild(audioWidget);
}


Model *modelAudioInterface = Model::create<AudioInterface, AudioInterfaceWidget>("Core", "AudioInterface", "Audio", EXTERNAL_TAG);