VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2151 Commits
4 Branches
723MB
Tree: f0753792b8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f0753792b8'
${ noResults }
Rack/src/core/AudioInterface.cpp

478 lines
24KB
Raw Blame History 

  1. #include <mutex>

  2. #include <chrono>

  3. #include <thread>

  4. #include <condition_variable>

  5. 

  6. #include "plugin.hpp"

  7. #include <audio.hpp>

  8. #include <context.hpp>

  9. 

  10. 

  11. namespace rack {

  12. namespace core {

  13. 

  14. 

  15. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  16. struct AudioInterface : Module, audio::Port {

  17. 	static constexpr int NUM_INPUT_LIGHTS = (NUM_AUDIO_INPUTS > 2) ? (NUM_AUDIO_INPUTS / 2) : 0;

  18. 	static constexpr int NUM_OUTPUT_LIGHTS = (NUM_AUDIO_OUTPUTS > 2) ? (NUM_AUDIO_OUTPUTS / 2) : 0;

  19. 

  20. 	enum ParamIds {

  21. 		ENUMS(GAIN_PARAM, NUM_AUDIO_INPUTS == 2),

  22. 		NUM_PARAMS

  23. 	};

  24. 	enum InputIds {

  25. 		ENUMS(AUDIO_INPUTS, NUM_AUDIO_INPUTS),

  26. 		NUM_INPUTS

  27. 	};

  28. 	enum OutputIds {

  29. 		ENUMS(AUDIO_OUTPUTS, NUM_AUDIO_OUTPUTS),

  30. 		NUM_OUTPUTS

  31. 	};

  32. 	enum LightIds {

  33. 		ENUMS(INPUT_LIGHTS, NUM_INPUT_LIGHTS * 2),

  34. 		ENUMS(OUTPUT_LIGHTS, NUM_OUTPUT_LIGHTS * 2),

  35. 		ENUMS(VU_LIGHTS, (NUM_AUDIO_INPUTS == 2) ? (2 * 6) : 0),

  36. 		NUM_LIGHTS

  37. 	};

  38. 

  39. 	dsp::DoubleRingBuffer<dsp::Frame<NUM_AUDIO_INPUTS>, 32768> inputBuffer;

  40. 	dsp::DoubleRingBuffer<dsp::Frame<NUM_AUDIO_OUTPUTS>, 32768> outputBuffer;

  41. 

  42. 	dsp::SampleRateConverter<NUM_AUDIO_INPUTS> inputSrc;

  43. 	dsp::SampleRateConverter<NUM_AUDIO_OUTPUTS> outputSrc;

  44. 

  45. 	dsp::ClockDivider lightDivider;

  46. 	// For each pair of inputs/outputs

  47. 	float inputClipTimers[(NUM_AUDIO_INPUTS > 0) ? NUM_INPUT_LIGHTS : 0] = {};

  48. 	float outputClipTimers[(NUM_AUDIO_INPUTS > 0) ? NUM_OUTPUT_LIGHTS : 0] = {};

  49. 	dsp::VuMeter2 vuMeter[(NUM_AUDIO_INPUTS == 2) ? 2 : 0];

  50. 

  51. 	// Port variables

  52. 	int requestedEngineFrames = 0;

  53. 	int maxEngineFrames = 0;

  54. 

  55. 	AudioInterface() {

  56. 		config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);

  57. 		if (NUM_AUDIO_INPUTS == 2)

  58. 			configParam(GAIN_PARAM, 0.f, 2.f, 1.f, "Level", " dB", -10, 40);

  59. 		for (int i = 0; i < NUM_AUDIO_INPUTS; i++)

  60. 			configInput(AUDIO_INPUTS + i, string::f("To \"device output %d\"", i + 1));

  61. 		for (int i = 0; i < NUM_AUDIO_OUTPUTS; i++)

  62. 			configOutput(AUDIO_OUTPUTS + i, string::f("From \"device input %d\"", i + 1));

  63. 		for (int i = 0; i < NUM_INPUT_LIGHTS; i++)

  64. 			configLight(INPUT_LIGHTS + 2 * i, string::f("Device output %d/%d status", 2 * i + 1, 2 * i + 2));

  65. 		for (int i = 0; i < NUM_OUTPUT_LIGHTS; i++)

  66. 			configLight(OUTPUT_LIGHTS + 2 * i, string::f("Device input %d/%d status", 2 * i + 1, 2 * i + 2));

  67. 

  68. 		lightDivider.setDivision(512);

  69. 		maxChannels = std::max(NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS);

  70. 		inputSrc.setQuality(6);

  71. 		outputSrc.setQuality(6);

  72. 	}

  73. 

  74. 	~AudioInterface() {

  75. 		// Close stream here before destructing AudioInterfacePort, so processBuffer() etc are not called on another thread while destructing.

  76. 		setDriverId(-1);

  77. 	}

  78. 

  79. 	void onReset() override {

  80. 		setDriverId(-1);

  81. 	}

  82. 

  83. 	void onSampleRateChange(const SampleRateChangeEvent& e) override {

  84. 		inputBuffer.clear();

  85. 		outputBuffer.clear();

  86. 	}

  87. 

  88. 	void process(const ProcessArgs& args) override {

  89. 		const float clipTime = 0.25f;

  90. 

  91. 		// Push inputs to buffer

  92. 		dsp::Frame<NUM_AUDIO_INPUTS> inputFrame;

  93. 		for (int i = 0; i < NUM_AUDIO_INPUTS; i++) {

  94. 			// Get input

  95. 			float v = 0.f;

  96. 			if (inputs[AUDIO_INPUTS + i].isConnected())

  97. 				v = inputs[AUDIO_INPUTS + i].getVoltageSum() / 10.f;

  98. 			// Normalize right input to left on Audio-2

  99. 			else if (i > 0 && NUM_AUDIO_INPUTS == 2)

  100. 				v = inputFrame.samples[i - 1];

  101. 

  102. 			// Detect clipping

  103. 			if (NUM_AUDIO_INPUTS > 2) {

  104. 				if (std::fabs(v) >= 1.f)

  105. 					inputClipTimers[i / 2] = clipTime;

  106. 			}

  107. 			inputFrame.samples[i] = v;

  108. 		}

  109. 

  110. 		// Apply gain from knob

  111. 		if (NUM_AUDIO_INPUTS == 2) {

  112. 			float gain = std::pow(params[GAIN_PARAM].getValue(), 2.f);

  113. 			for (int i = 0; i < NUM_AUDIO_INPUTS; i++) {

  114. 				inputFrame.samples[i] *= gain;

  115. 			}

  116. 		}

  117. 

  118. 		if (!inputBuffer.full()) {

  119. 			inputBuffer.push(inputFrame);

  120. 		}

  121. 

  122. 		// Pull outputs from buffer

  123. 		if (!outputBuffer.empty()) {

  124. 			dsp::Frame<NUM_AUDIO_OUTPUTS> outputFrame = outputBuffer.shift();

  125. 			for (int i = 0; i < NUM_AUDIO_OUTPUTS; i++) {

  126. 				float v = outputFrame.samples[i];

  127. 				outputs[AUDIO_OUTPUTS + i].setVoltage(10.f * v);

  128. 

  129. 				// Detect clipping

  130. 				if (NUM_AUDIO_OUTPUTS > 2) {

  131. 					if (std::fabs(v) >= 1.f)

  132. 						outputClipTimers[i / 2] = clipTime;

  133. 				}

  134. 			}

  135. 		}

  136. 		else {

  137. 			for (int i = 0; i < NUM_AUDIO_OUTPUTS; i++) {

  138. 				outputs[AUDIO_OUTPUTS + i].setVoltage(0.f);

  139. 			}

  140. 		}

  141. 

  142. 		// Lights

  143. 		if (NUM_AUDIO_INPUTS == 2) {

  144. 			for (int i = 0; i < 2; i++) {

  145. 				vuMeter[i].process(args.sampleTime, inputFrame.samples[i]);

  146. 			}

  147. 		}

  148. 		if (lightDivider.process()) {

  149. 			float lightTime = args.sampleTime * lightDivider.getDivision();

  150. 			if (NUM_AUDIO_INPUTS == 2) {

  151. 				for (int i = 0; i < 2; i++) {

  152. 					lights[VU_LIGHTS + i * 6 + 0].setBrightness(vuMeter[i].getBrightness(0, 0));

  153. 					lights[VU_LIGHTS + i * 6 + 1].setBrightness(vuMeter[i].getBrightness(-3, 0));

  154. 					lights[VU_LIGHTS + i * 6 + 2].setBrightness(vuMeter[i].getBrightness(-6, -3));

  155. 					lights[VU_LIGHTS + i * 6 + 3].setBrightness(vuMeter[i].getBrightness(-12, -6));

  156. 					lights[VU_LIGHTS + i * 6 + 4].setBrightness(vuMeter[i].getBrightness(-24, -12));

  157. 					lights[VU_LIGHTS + i * 6 + 5].setBrightness(vuMeter[i].getBrightness(-36, -24));

  158. 				}

  159. 			}

  160. 			else {

  161. 				int numDeviceInputs = getNumInputs();

  162. 				int numDeviceOutputs = getNumOutputs();

  163. 				// Turn on light if at least one port is enabled in the nearby pair.

  164. 				for (int i = 0; i < NUM_AUDIO_INPUTS / 2; i++) {

  165. 					bool active = numDeviceOutputs >= 2 * i + 1;

  166. 					bool clip = inputClipTimers[i] > 0.f;

  167. 					if (clip)

  168. 						inputClipTimers[i] -= lightTime;

  169. 					lights[INPUT_LIGHTS + i * 2 + 0].setBrightness(active && !clip);

  170. 					lights[INPUT_LIGHTS + i * 2 + 1].setBrightness(active && clip);

  171. 				}

  172. 				for (int i = 0; i < NUM_AUDIO_OUTPUTS / 2; i++) {

  173. 					bool active = numDeviceInputs >= 2 * i + 1;

  174. 					bool clip = outputClipTimers[i] > 0.f;

  175. 					if (clip)

  176. 						outputClipTimers[i] -= lightTime;

  177. 					lights[OUTPUT_LIGHTS + i * 2 + 0].setBrightness(active & !clip);

  178. 					lights[OUTPUT_LIGHTS + i * 2 + 1].setBrightness(active & clip);

  179. 				}

  180. 			}

  181. 		}

  182. 	}

  183. 

  184. 	json_t* dataToJson() override {

  185. 		json_t* rootJ = json_object();

  186. 		json_object_set_new(rootJ, "audio", audio::Port::toJson());

  187. 		return rootJ;

  188. 	}

  189. 

  190. 	void dataFromJson(json_t* rootJ) override {

  191. 		json_t* audioJ = json_object_get(rootJ, "audio");

  192. 		if (audioJ)

  193. 			audio::Port::fromJson(audioJ);

  194. 	}

  195. 

  196. 	// audio::Port

  197. 

  198. 	void processInput(const float* input, int inputStride, int frames) override {

  199. 		// Claim primary module if there is none

  200. 		if (!APP->engine->getPrimaryModule()) {

  201. 			APP->engine->setPrimaryModule(this);

  202. 		}

  203. 		bool isPrimary = (APP->engine->getPrimaryModule() == this);

  204. 

  205. 		// Initialize sample rate converters

  206. 		int numInputs = getNumInputs();

  207. 		int engineSampleRate = (int) APP->engine->getSampleRate();

  208. 		int sampleRate = getSampleRate();

  209. 		double sampleRateRatio = (double) engineSampleRate / sampleRate;

  210. 		outputSrc.setRates(sampleRate, engineSampleRate);

  211. 		outputSrc.setChannels(numInputs);

  212. 

  213. 		// Consider engine buffers "too full" if they contain a bit more than the audio device's number of frames, converted to engine sample rate.

  214. 		maxEngineFrames = (int) std::ceil(frames * sampleRateRatio * 1.5);

  215. 		// If this is a secondary audio module and the engine output buffer is too full, flush it.

  216. 		if (!isPrimary && (int) outputBuffer.size() > maxEngineFrames) {

  217. 			outputBuffer.clear();

  218. 			// DEBUG("%p: flushing engine output", this);

  219. 		}

  220. 

  221. 		if (numInputs > 0) {

  222. 			// audio input -> engine output

  223. 			dsp::Frame<NUM_AUDIO_OUTPUTS> inputAudioBuffer[frames];

  224. 			std::memset(inputAudioBuffer, 0, sizeof(inputAudioBuffer));

  225. 			for (int i = 0; i < frames; i++) {

  226. 				for (int j = 0; j < std::min(numInputs, NUM_AUDIO_OUTPUTS); j++) {

  227. 					float v = input[i * inputStride + j];

  228. 					inputAudioBuffer[i].samples[j] = v;

  229. 				}

  230. 			}

  231. 			int inputAudioFrames = frames;

  232. 			int outputFrames = outputBuffer.capacity();

  233. 			outputSrc.process(inputAudioBuffer, &inputAudioFrames, outputBuffer.endData(), &outputFrames);

  234. 			outputBuffer.endIncr(outputFrames);

  235. 			// Request exactly as many frames as we have.

  236. 			requestedEngineFrames = outputBuffer.size();

  237. 		}

  238. 		else {

  239. 			// Upper bound on number of frames so that `outputAudioFrames >= frames` at the end of this method.

  240. 			requestedEngineFrames = (int) std::ceil(frames * sampleRateRatio) - inputBuffer.size();

  241. 		}

  242. 	}

  243. 

  244. 	void processBuffer(const float* input, int inputStride, float* output, int outputStride, int frames) override {

  245. 		bool isPrimary = (APP->engine->getPrimaryModule() == this);

  246. 		// Step engine

  247. 		if (isPrimary && requestedEngineFrames > 0) {

  248. 			APP->engine->stepBlock(requestedEngineFrames);

  249. 		}

  250. 	}

  251. 

  252. 	void processOutput(float* output, int outputStride, int frames) override {

  253. 		bool isPrimary = (APP->engine->getPrimaryModule() == this);

  254. 		int numOutputs = getNumOutputs();

  255. 		int engineSampleRate = (int) APP->engine->getSampleRate();

  256. 		int sampleRate = getSampleRate();

  257. 		inputSrc.setRates(engineSampleRate, sampleRate);

  258. 		inputSrc.setChannels(numOutputs);

  259. 

  260. 		if (numOutputs > 0) {

  261. 			// engine input -> audio output

  262. 			dsp::Frame<NUM_AUDIO_OUTPUTS> outputAudioBuffer[frames];

  263. 			int inputFrames = inputBuffer.size();

  264. 			int outputAudioFrames = frames;

  265. 			inputSrc.process(inputBuffer.startData(), &inputFrames, outputAudioBuffer, &outputAudioFrames);

  266. 			inputBuffer.startIncr(inputFrames);

  267. 			for (int i = 0; i < outputAudioFrames; i++) {

  268. 				for (int j = 0; j < std::min(numOutputs, NUM_AUDIO_INPUTS); j++) {

  269. 					float v = outputAudioBuffer[i].samples[j];

  270. 					v = clamp(v, -1.f, 1.f);

  271. 					output[i * outputStride + j] = v;

  272. 				}

  273. 			}

  274. 		}

  275. 

  276. 		// If this is a secondary audio module and the engine input buffer is too full, flush it.

  277. 		if (!isPrimary && (int) inputBuffer.size() > maxEngineFrames) {

  278. 			inputBuffer.clear();

  279. 			// DEBUG("%p: flushing engine input", this);

  280. 		}

  281. 

  282. 		// DEBUG("%p %s:\tframes %d requestedEngineFrames %d\toutputBuffer %d inputBuffer %d\t", this, isPrimary ? "primary" : "secondary", frames, requestedEngineFrames, outputBuffer.size(), inputBuffer.size());

  283. 	}

  284. 

  285. 	void onOpenStream() override {

  286. 		inputBuffer.clear();

  287. 		outputBuffer.clear();

  288. 	}

  289. 

  290. 	void onCloseStream() override {

  291. 		inputBuffer.clear();

  292. 		outputBuffer.clear();

  293. 	}

  294. };

  295. 

  296. 

  297. template <typename TAudioInterface>

  298. struct PrimaryModuleItem : MenuItem {

  299. 	TAudioInterface* module;

  300. 

  301. 	void onAction(const event::Action& e) override {

  302. 		APP->engine->setPrimaryModule(module);

  303. 	}

  304. };

  305. 

  306. 

  307. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  308. struct AudioInterfaceWidget : ModuleWidget {

  309. 	typedef AudioInterface<NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS> TAudioInterface;

  310. 

  311. 	AudioInterfaceWidget(TAudioInterface* module) {

  312. 		setModule(module);

  313. 

  314. 		if (NUM_AUDIO_INPUTS == 8 && NUM_AUDIO_OUTPUTS == 8) {

  315. 			setPanel(APP->window->loadSvg(asset::system("res/Core/AudioInterface.svg")));

  316. 

  317. 			addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));

  318. 			addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  319. 			addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  320. 			addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  321. 

  322. 			addInput(createInput<PJ301MPort>(mm2px(Vec(3.7069211, 55.530807)), module, TAudioInterface::AUDIO_INPUTS + 0));

  323. 			addInput(createInput<PJ301MPort>(mm2px(Vec(15.307249, 55.530807)), module, TAudioInterface::AUDIO_INPUTS + 1));

  324. 			addInput(createInput<PJ301MPort>(mm2px(Vec(26.906193, 55.530807)), module, TAudioInterface::AUDIO_INPUTS + 2));

  325. 			addInput(createInput<PJ301MPort>(mm2px(Vec(38.506519, 55.530807)), module, TAudioInterface::AUDIO_INPUTS + 3));

  326. 			addInput(createInput<PJ301MPort>(mm2px(Vec(3.7069209, 70.144905)), module, TAudioInterface::AUDIO_INPUTS + 4));

  327. 			addInput(createInput<PJ301MPort>(mm2px(Vec(15.307249, 70.144905)), module, TAudioInterface::AUDIO_INPUTS + 5));

  328. 			addInput(createInput<PJ301MPort>(mm2px(Vec(26.906193, 70.144905)), module, TAudioInterface::AUDIO_INPUTS + 6));

  329. 			addInput(createInput<PJ301MPort>(mm2px(Vec(38.506519, 70.144905)), module, TAudioInterface::AUDIO_INPUTS + 7));

  330. 

  331. 			addOutput(createOutput<PJ301MPort>(mm2px(Vec(3.7069209, 92.143906)), module, TAudioInterface::AUDIO_OUTPUTS + 0));

  332. 			addOutput(createOutput<PJ301MPort>(mm2px(Vec(15.307249, 92.143906)), module, TAudioInterface::AUDIO_OUTPUTS + 1));

  333. 			addOutput(createOutput<PJ301MPort>(mm2px(Vec(26.906193, 92.143906)), module, TAudioInterface::AUDIO_OUTPUTS + 2));

  334. 			addOutput(createOutput<PJ301MPort>(mm2px(Vec(38.506519, 92.143906)), module, TAudioInterface::AUDIO_OUTPUTS + 3));

  335. 			addOutput(createOutput<PJ301MPort>(mm2px(Vec(3.7069209, 108.1443)), module, TAudioInterface::AUDIO_OUTPUTS + 4));

  336. 			addOutput(createOutput<PJ301MPort>(mm2px(Vec(15.307249, 108.1443)), module, TAudioInterface::AUDIO_OUTPUTS + 5));

  337. 			addOutput(createOutput<PJ301MPort>(mm2px(Vec(26.906193, 108.1443)), module, TAudioInterface::AUDIO_OUTPUTS + 6));

  338. 			addOutput(createOutput<PJ301MPort>(mm2px(Vec(38.506523, 108.1443)), module, TAudioInterface::AUDIO_OUTPUTS + 7));

  339. 

  340. 			addChild(createLight<SmallLight<GreenRedLight>>(mm2px(Vec(12.524985, 54.577202)), module, TAudioInterface::INPUT_LIGHTS + 0 * 2));

  341. 			addChild(createLight<SmallLight<GreenRedLight>>(mm2px(Vec(35.725647, 54.577202)), module, TAudioInterface::INPUT_LIGHTS + 1 * 2));

  342. 			addChild(createLight<SmallLight<GreenRedLight>>(mm2px(Vec(12.524985, 69.158226)), module, TAudioInterface::INPUT_LIGHTS + 2 * 2));

  343. 			addChild(createLight<SmallLight<GreenRedLight>>(mm2px(Vec(35.725647, 69.158226)), module, TAudioInterface::INPUT_LIGHTS + 3 * 2));

  344. 			addChild(createLight<SmallLight<GreenRedLight>>(mm2px(Vec(12.524985, 91.147583)), module, TAudioInterface::OUTPUT_LIGHTS + 0 * 2));

  345. 			addChild(createLight<SmallLight<GreenRedLight>>(mm2px(Vec(35.725647, 91.147583)), module, TAudioInterface::OUTPUT_LIGHTS + 1 * 2));

  346. 			addChild(createLight<SmallLight<GreenRedLight>>(mm2px(Vec(12.524985, 107.17003)), module, TAudioInterface::OUTPUT_LIGHTS + 2 * 2));

  347. 			addChild(createLight<SmallLight<GreenRedLight>>(mm2px(Vec(35.725647, 107.17003)), module, TAudioInterface::OUTPUT_LIGHTS + 3 * 2));

  348. 

  349. 			AudioWidget* audioWidget = createWidget<AudioWidget>(mm2px(Vec(3.2122073, 14.837339)));

  350. 			audioWidget->box.size = mm2px(Vec(44, 28));

  351. 			audioWidget->setAudioPort(module);

  352. 			addChild(audioWidget);

  353. 		}

  354. 		else if (NUM_AUDIO_INPUTS == 16 && NUM_AUDIO_OUTPUTS == 16) {

  355. 			setPanel(APP->window->loadSvg(asset::system("res/Core/AudioInterface16.svg")));

  356. 

  357. 			addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));

  358. 			addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  359. 			addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  360. 			addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  361. 

  362. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(7.661, 59.638)), module, TAudioInterface::AUDIO_INPUTS + 0));

  363. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(19.26, 59.638)), module, TAudioInterface::AUDIO_INPUTS + 1));

  364. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(30.86, 59.638)), module, TAudioInterface::AUDIO_INPUTS + 2));

  365. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(42.461, 59.638)), module, TAudioInterface::AUDIO_INPUTS + 3));

  366. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(54.06, 59.638)), module, TAudioInterface::AUDIO_INPUTS + 4));

  367. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(65.661, 59.638)), module, TAudioInterface::AUDIO_INPUTS + 5));

  368. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(77.26, 59.638)), module, TAudioInterface::AUDIO_INPUTS + 6));

  369. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(88.86, 59.638)), module, TAudioInterface::AUDIO_INPUTS + 7));

  370. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(7.661, 74.251)), module, TAudioInterface::AUDIO_INPUTS + 8));

  371. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(19.26, 74.251)), module, TAudioInterface::AUDIO_INPUTS + 9));

  372. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(30.86, 74.251)), module, TAudioInterface::AUDIO_INPUTS + 10));

  373. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(42.461, 74.251)), module, TAudioInterface::AUDIO_INPUTS + 11));

  374. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(54.06, 74.251)), module, TAudioInterface::AUDIO_INPUTS + 12));

  375. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(65.661, 74.251)), module, TAudioInterface::AUDIO_INPUTS + 13));

  376. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(77.26, 74.251)), module, TAudioInterface::AUDIO_INPUTS + 14));

  377. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(88.86, 74.251)), module, TAudioInterface::AUDIO_INPUTS + 15));

  378. 

  379. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.661, 96.251)), module, TAudioInterface::AUDIO_OUTPUTS + 0));

  380. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.26, 96.251)), module, TAudioInterface::AUDIO_OUTPUTS + 1));

  381. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(30.86, 96.251)), module, TAudioInterface::AUDIO_OUTPUTS + 2));

  382. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(42.461, 96.251)), module, TAudioInterface::AUDIO_OUTPUTS + 3));

  383. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(54.06, 96.251)), module, TAudioInterface::AUDIO_OUTPUTS + 4));

  384. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(65.661, 96.251)), module, TAudioInterface::AUDIO_OUTPUTS + 5));

  385. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(77.26, 96.251)), module, TAudioInterface::AUDIO_OUTPUTS + 6));

  386. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(88.86, 96.251)), module, TAudioInterface::AUDIO_OUTPUTS + 7));

  387. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.661, 112.252)), module, TAudioInterface::AUDIO_OUTPUTS + 8));

  388. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.26, 112.252)), module, TAudioInterface::AUDIO_OUTPUTS + 9));

  389. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(30.86, 112.252)), module, TAudioInterface::AUDIO_OUTPUTS + 10));

  390. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(42.461, 112.252)), module, TAudioInterface::AUDIO_OUTPUTS + 11));

  391. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(54.06, 112.252)), module, TAudioInterface::AUDIO_OUTPUTS + 12));

  392. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(65.661, 112.252)), module, TAudioInterface::AUDIO_OUTPUTS + 13));

  393. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(77.26, 112.252)), module, TAudioInterface::AUDIO_OUTPUTS + 14));

  394. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(88.86, 112.252)), module, TAudioInterface::AUDIO_OUTPUTS + 15));

  395. 

  396. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.46, 55.667)), module, TAudioInterface::INPUT_LIGHTS + 0 * 2));

  397. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.661, 55.667)), module, TAudioInterface::INPUT_LIGHTS + 1 * 2));

  398. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(59.861, 55.667)), module, TAudioInterface::INPUT_LIGHTS + 2 * 2));

  399. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(83.061, 55.667)), module, TAudioInterface::INPUT_LIGHTS + 3 * 2));

  400. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.46, 70.248)), module, TAudioInterface::INPUT_LIGHTS + 4 * 2));

  401. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.661, 70.248)), module, TAudioInterface::INPUT_LIGHTS + 5 * 2));

  402. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(59.861, 70.248)), module, TAudioInterface::INPUT_LIGHTS + 6 * 2));

  403. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(83.061, 70.248)), module, TAudioInterface::INPUT_LIGHTS + 7 * 2));

  404. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.46, 92.238)), module, TAudioInterface::OUTPUT_LIGHTS + 0 * 2));

  405. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.661, 92.238)), module, TAudioInterface::OUTPUT_LIGHTS + 1 * 2));

  406. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(59.861, 92.238)), module, TAudioInterface::OUTPUT_LIGHTS + 2 * 2));

  407. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(83.061, 92.238)), module, TAudioInterface::OUTPUT_LIGHTS + 3 * 2));

  408. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.46, 108.259)), module, TAudioInterface::OUTPUT_LIGHTS + 4 * 2));

  409. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.661, 108.259)), module, TAudioInterface::OUTPUT_LIGHTS + 5 * 2));

  410. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(59.861, 108.259)), module, TAudioInterface::OUTPUT_LIGHTS + 6 * 2));

  411. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(83.061, 108.259)), module, TAudioInterface::OUTPUT_LIGHTS + 7 * 2));

  412. 

  413. 			AudioWidget* audioWidget = createWidget<AudioWidget>(mm2px(Vec(2.57, 14.839)));

  414. 			audioWidget->box.size = mm2px(Vec(91.382, 28.0));

  415. 			audioWidget->setAudioPort(module);

  416. 			addChild(audioWidget);

  417. 		}

  418. 		else if (NUM_AUDIO_INPUTS == 2 && NUM_AUDIO_OUTPUTS == 2) {

  419. 			setPanel(APP->window->loadSvg(asset::system("res/Core/AudioInterface2.svg")));

  420. 

  421. 			addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));

  422. 			addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  423. 			addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  424. 			addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  425. 

  426. 			addParam(createParamCentered<RoundBigBlackKnob>(mm2px(Vec(12.7, 74.019)), module, TAudioInterface::GAIN_PARAM));

  427. 

  428. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.697, 94.253)), module, TAudioInterface::AUDIO_INPUTS + 0));

  429. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(18.703, 94.253)), module, TAudioInterface::AUDIO_INPUTS + 1));

  430. 

  431. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(6.699, 112.254)), module, TAudioInterface::AUDIO_OUTPUTS + 0));

  432. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(18.7, 112.254)), module, TAudioInterface::AUDIO_OUTPUTS + 1));

  433. 

  434. 			addChild(createLightCentered<MediumLight<RedLight>>(mm2px(Vec(6.7, 29.759)), module, TAudioInterface::VU_LIGHTS + 0 * 6 + 0));

  435. 			addChild(createLightCentered<MediumLight<RedLight>>(mm2px(Vec(18.7, 29.759)), module, TAudioInterface::VU_LIGHTS + 1 * 6 + 0));

  436. 			addChild(createLightCentered<MediumLight<YellowLight>>(mm2px(Vec(6.7, 34.753)), module, TAudioInterface::VU_LIGHTS + 0 * 6 + 1));

  437. 			addChild(createLightCentered<MediumLight<YellowLight>>(mm2px(Vec(18.7, 34.753)), module, TAudioInterface::VU_LIGHTS + 1 * 6 + 1));

  438. 			addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(6.7, 39.749)), module, TAudioInterface::VU_LIGHTS + 0 * 6 + 2));

  439. 			addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(18.7, 39.749)), module, TAudioInterface::VU_LIGHTS + 1 * 6 + 2));

  440. 			addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(6.7, 44.744)), module, TAudioInterface::VU_LIGHTS + 0 * 6 + 3));

  441. 			addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(18.7, 44.744)), module, TAudioInterface::VU_LIGHTS + 1 * 6 + 3));

  442. 			addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(6.7, 49.744)), module, TAudioInterface::VU_LIGHTS + 0 * 6 + 4));

  443. 			addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(18.7, 49.744)), module, TAudioInterface::VU_LIGHTS + 1 * 6 + 4));

  444. 			addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(6.7, 54.745)), module, TAudioInterface::VU_LIGHTS + 0 * 6 + 5));

  445. 			addChild(createLightCentered<MediumLight<GreenLight>>(mm2px(Vec(18.7, 54.745)), module, TAudioInterface::VU_LIGHTS + 1 * 6 + 5));

  446. 

  447. 			AudioDeviceWidget* audioWidget = createWidget<AudioDeviceWidget>(mm2px(Vec(2.135, 14.259)));

  448. 			audioWidget->box.size = mm2px(Vec(21.128, 6.725));

  449. 			audioWidget->setAudioPort(module);

  450. 			// Adjust deviceChoice position

  451. 			audioWidget->deviceChoice->textOffset = Vec(6, 14);

  452. 			addChild(audioWidget);

  453. 		}

  454. 	}

  455. 

  456. 	void appendContextMenu(Menu* menu) override {

  457. 		TAudioInterface* module = dynamic_cast<TAudioInterface*>(this->module);

  458. 

  459. 		menu->addChild(new MenuSeparator);

  460. 

  461. 		PrimaryModuleItem<TAudioInterface>* primaryModuleItem = new PrimaryModuleItem<TAudioInterface>;

  462. 		primaryModuleItem->text = "Primary audio module";

  463. 		primaryModuleItem->rightText = CHECKMARK(APP->engine->getPrimaryModule() == module);

  464. 		primaryModuleItem->module = module;

  465. 		menu->addChild(primaryModuleItem);

  466. 	}

  467. };

  468. 

  469. 

  470. Model* modelAudioInterface2 = createModel<AudioInterface<2, 2>, AudioInterfaceWidget<2, 2>>("AudioInterface2");

  471. // Legacy name for Audio-8

  472. Model* modelAudioInterface = createModel<AudioInterface<8, 8>, AudioInterfaceWidget<8, 8>>("AudioInterface");

  473. Model* modelAudioInterface16 = createModel<AudioInterface<16, 16>, AudioInterfaceWidget<16, 16>>("AudioInterface16");

  474. 

  475. 

  476. } // namespace core

  477. } // namespace rack