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.
1830 Commits
4 Branches
710MB
Tree: e9dd0d1676
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e9dd0d1676'
${ noResults }
Rack/src/core/AudioInterface.cpp

430 lines
20KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. #include <audio.hpp>

  3. #include <app.hpp>

  4. #include <mutex>

  5. #include <chrono>

  6. #include <thread>

  7. #include <mutex>

  8. #include <condition_variable>

  9. 

  10. 

  11. namespace rack {

  12. namespace core {

  13. 

  14. 

  15. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  16. struct AudioInterfacePort : audio::Port {

  17. 	// std::mutex engineMutex;

  18. 	// std::condition_variable engineCv;

  19. 	// std::mutex audioMutex;

  20. 	// std::condition_variable audioCv;

  21. 	// // Audio thread produces, engine thread consumes

  22. 	// dsp::DoubleRingBuffer < dsp::Frame<NUM_AUDIO_INPUTS>, (1 << 15) > inputBuffer;

  23. 	// // Audio thread consumes, engine thread produces

  24. 	// dsp::DoubleRingBuffer < dsp::Frame<NUM_AUDIO_OUTPUTS>, (1 << 15) > outputBuffer;

  25. 	// bool active = false;

  26. 

  27. 	// For checking getPrimaryModule()

  28. 	Module* module = NULL;

  29. 	const float* input = NULL;

  30. 	float* output = NULL;

  31. 	int frame = 0;

  32. 	int numFrames = 0;

  33. 

  34. 	~AudioInterfacePort() {

  35. 		// Close stream here before destructing AudioInterfacePort, so the mutexes are still valid when waiting to close.

  36. 		setDeviceId(-1, 0);

  37. 	}

  38. 

  39. 	void processStream(const float* input, float* output, int frames) override {

  40. 		if (APP->engine->getPrimaryModule() != module) {

  41. 			// TEMP

  42. 			std::memset(output, 0, sizeof(float) * frames * numOutputs);

  43. 			return;

  44. 		}

  45. 

  46. 		frame = 0;

  47. 		numFrames = frames;

  48. 		this->input = input;

  49. 		this->output = output;

  50. 

  51. 		APP->engine->step(frames);

  52. 

  53. 		// // Reactivate idle stream

  54. 		// if (!active) {

  55. 		// 	active = true;

  56. 		// 	inputBuffer.clear();

  57. 		// 	outputBuffer.clear();

  58. 		// }

  59. 

  60. 		// if (numInputs > 0) {

  61. 		// 	// TODO Do we need to wait on the input to be consumed here? Experimentally, it works fine if we don't.

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

  63. 		// 		if (inputBuffer.full())

  64. 		// 			break;

  65. 		// 		dsp::Frame<NUM_AUDIO_INPUTS> inputFrame;

  66. 		// 		std::memset(&inputFrame, 0, sizeof(inputFrame));

  67. 		// 		std::memcpy(&inputFrame, &input[numInputs * i], numInputs * sizeof(float));

  68. 		// 		inputBuffer.push(inputFrame);

  69. 		// 	}

  70. 		// }

  71. 

  72. 		// if (numOutputs > 0) {

  73. 		// 	std::unique_lock<std::mutex> lock(audioMutex);

  74. 		// 	auto cond = [&] {

  75. 		// 		return (outputBuffer.size() >= (size_t) frames);

  76. 		// 	};

  77. 		// 	auto timeout = std::chrono::milliseconds(100);

  78. 		// 	if (audioCv.wait_for(lock, timeout, cond)) {

  79. 		// 		// Consume audio block

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

  81. 		// 			dsp::Frame<NUM_AUDIO_OUTPUTS> f = outputBuffer.shift();

  82. 		// 			for (int j = 0; j < numOutputs; j++) {

  83. 		// 				output[numOutputs * i + j] = clamp(f.samples[j], -1.f, 1.f);

  84. 		// 			}

  85. 		// 		}

  86. 		// 	}

  87. 		// 	else {

  88. 		// 		// Timed out, fill output with zeros

  89. 		// 		std::memset(output, 0, frames * numOutputs * sizeof(float));

  90. 		// 		// DEBUG("Audio Interface Port underflow");

  91. 		// 	}

  92. 		// }

  93. 

  94. 		// // Notify engine when finished processing

  95. 		// engineCv.notify_one();

  96. 	}

  97. 

  98. 	void onCloseStream() override {

  99. 		// inputBuffer.clear();

  100. 		// outputBuffer.clear();

  101. 	}

  102. 

  103. 	void onChannelsChange() override {

  104. 	}

  105. };

  106. 

  107. 

  108. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  109. struct AudioInterface : Module {

  110. 	enum ParamIds {

  111. 		NUM_PARAMS

  112. 	};

  113. 	enum InputIds {

  114. 		ENUMS(AUDIO_INPUTS, NUM_AUDIO_INPUTS),

  115. 		NUM_INPUTS

  116. 	};

  117. 	enum OutputIds {

  118. 		ENUMS(AUDIO_OUTPUTS, NUM_AUDIO_OUTPUTS),

  119. 		NUM_OUTPUTS

  120. 	};

  121. 	enum LightIds {

  122. 		ENUMS(INPUT_LIGHTS, NUM_AUDIO_INPUTS / 2),

  123. 		ENUMS(OUTPUT_LIGHTS, NUM_AUDIO_OUTPUTS / 2),

  124. 		NUM_LIGHTS

  125. 	};

  126. 

  127. 	AudioInterfacePort<NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS> port;

  128. 	// int lastSampleRate = 0;

  129. 	// int lastNumOutputs = -1;

  130. 	// int lastNumInputs = -1;

  131. 

  132. 	// dsp::SampleRateConverter<NUM_AUDIO_INPUTS> inputSrc;

  133. 	// dsp::SampleRateConverter<NUM_AUDIO_OUTPUTS> outputSrc;

  134. 

  135. 	// // in rack's sample rate

  136. 	// dsp::DoubleRingBuffer<dsp::Frame<NUM_AUDIO_INPUTS>, 16> inputBuffer;

  137. 	// dsp::DoubleRingBuffer<dsp::Frame<NUM_AUDIO_OUTPUTS>, 16> outputBuffer;

  138. 

  139. 	AudioInterface() {

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

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

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

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

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

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

  146. 		port.module = this;

  147. 		onSampleRateChange();

  148. 	}

  149. 

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

  151. 		// Claim primary module if there is none

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

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

  154. 		}

  155. 

  156. 		// Get inputs

  157. 		for (int i = 0; i < port.numOutputs; i++) {

  158. 			float v = inputs[AUDIO_INPUTS + i].getVoltage() / 10.f;

  159. 			port.output[port.frame * port.numOutputs + i] = v;

  160. 		}

  161. 

  162. 		// Set outputs

  163. 		for (int i = 0; i < port.numInputs; i++) {

  164. 			float v = port.input[port.frame * port.numInputs + i];

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

  166. 		}

  167. 		for (int i = port.numInputs; i < NUM_AUDIO_INPUTS; i++) {

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

  169. 		}

  170. 

  171. 		port.frame++;

  172. 

  173. 		// // Update SRC states

  174. 		// inputSrc.setRates(port.sampleRate, args.sampleRate);

  175. 		// outputSrc.setRates(args.sampleRate, port.sampleRate);

  176. 

  177. 		// inputSrc.setChannels(port.numInputs);

  178. 		// outputSrc.setChannels(port.numOutputs);

  179. 

  180. 		// // Inputs: audio engine -> rack engine

  181. 		// if (port.active && port.numInputs > 0) {

  182. 		// 	// Wait until inputs are present

  183. 		// 	// Give up after a timeout in case the audio device is being unresponsive.

  184. 		// 	std::unique_lock<std::mutex> lock(port.engineMutex);

  185. 		// 	auto cond = [&] {

  186. 		// 		return (!port.inputBuffer.empty());

  187. 		// 	};

  188. 		// 	auto timeout = std::chrono::milliseconds(200);

  189. 		// 	if (port.engineCv.wait_for(lock, timeout, cond)) {

  190. 		// 		// Convert inputs

  191. 		// 		int inLen = port.inputBuffer.size();

  192. 		// 		int outLen = inputBuffer.capacity();

  193. 		// 		inputSrc.process(port.inputBuffer.startData(), &inLen, inputBuffer.endData(), &outLen);

  194. 		// 		port.inputBuffer.startIncr(inLen);

  195. 		// 		inputBuffer.endIncr(outLen);

  196. 		// 	}

  197. 		// 	else {

  198. 		// 		// Give up on pulling input

  199. 		// 		port.active = false;

  200. 		// 		// DEBUG("Audio Interface underflow");

  201. 		// 	}

  202. 		// }

  203. 

  204. 		// // Take input from buffer

  205. 		// dsp::Frame<NUM_AUDIO_INPUTS> inputFrame;

  206. 		// if (!inputBuffer.empty()) {

  207. 		// 	inputFrame = inputBuffer.shift();

  208. 		// }

  209. 		// else {

  210. 		// 	std::memset(&inputFrame, 0, sizeof(inputFrame));

  211. 		// }

  212. 		// for (int i = 0; i < port.numInputs; i++) {

  213. 		// 	outputs[AUDIO_OUTPUTS + i].setVoltage(10.f * inputFrame.samples[i]);

  214. 		// }

  215. 		// for (int i = port.numInputs; i < NUM_AUDIO_INPUTS; i++) {

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

  217. 		// }

  218. 

  219. 		// // Outputs: rack engine -> audio engine

  220. 		// if (port.active && port.numOutputs > 0) {

  221. 		// 	// Get and push output SRC frame

  222. 		// 	if (!outputBuffer.full()) {

  223. 		// 		dsp::Frame<NUM_AUDIO_OUTPUTS> outputFrame;

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

  225. 		// 			outputFrame.samples[i] = inputs[AUDIO_INPUTS + i].getVoltageSum() / 10.f;

  226. 		// 		}

  227. 		// 		outputBuffer.push(outputFrame);

  228. 		// 	}

  229. 

  230. 		// 	if (outputBuffer.full()) {

  231. 		// 		// Wait until enough outputs are consumed

  232. 		// 		// Give up after a timeout in case the audio device is being unresponsive.

  233. 		// 		auto cond = [&] {

  234. 		// 			return (port.outputBuffer.size() < (size_t) port.blockSize);

  235. 		// 		};

  236. 		// 		if (!cond())

  237. 		// 			APP->engine->yieldWorkers();

  238. 		// 		std::unique_lock<std::mutex> lock(port.engineMutex);

  239. 		// 		auto timeout = std::chrono::milliseconds(200);

  240. 		// 		if (port.engineCv.wait_for(lock, timeout, cond)) {

  241. 		// 			// Push converted output

  242. 		// 			int inLen = outputBuffer.size();

  243. 		// 			int outLen = port.outputBuffer.capacity();

  244. 		// 			outputSrc.process(outputBuffer.startData(), &inLen, port.outputBuffer.endData(), &outLen);

  245. 		// 			outputBuffer.startIncr(inLen);

  246. 		// 			port.outputBuffer.endIncr(outLen);

  247. 		// 		}

  248. 		// 		else {

  249. 		// 			// Give up on pushing output

  250. 		// 			port.active = false;

  251. 		// 			outputBuffer.clear();

  252. 		// 			// DEBUG("Audio Interface underflow");

  253. 		// 		}

  254. 		// 	}

  255. 

  256. 		// 	// Notify audio thread that an output is potentially ready

  257. 		// 	port.audioCv.notify_one();

  258. 		// }

  259. 

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

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

  262. 			lights[INPUT_LIGHTS + i].setBrightness(port.numOutputs >= 2 * i + 1);

  263. 		}

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

  265. 			lights[OUTPUT_LIGHTS + i].setBrightness(port.numInputs >= 2 * i + 1);

  266. 		}

  267. 	}

  268. 

  269. 	json_t* dataToJson() override {

  270. 		json_t* rootJ = json_object();

  271. 		json_object_set_new(rootJ, "audio", port.toJson());

  272. 		return rootJ;

  273. 	}

  274. 

  275. 	void dataFromJson(json_t* rootJ) override {

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

  277. 		if (audioJ)

  278. 			port.fromJson(audioJ);

  279. 	}

  280. 

  281. 	void onReset() override {

  282. 		port.setDeviceId(-1, 0);

  283. 	}

  284. };

  285. 

  286. 

  287. template <typename TAudioInterface>

  288. struct PrimaryModuleItem : MenuItem {

  289. 	TAudioInterface* module;

  290. 

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

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

  293. 	}

  294. };

  295. 

  296. 

  297. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  298. struct AudioInterfaceWidget : ModuleWidget {

  299. 	typedef AudioInterface<NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS> TAudioInterface;

  300. 

  301. 	AudioInterfaceWidget(TAudioInterface* module) {

  302. 		setModule(module);

  303. 

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

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

  306. 

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

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

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

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

  311. 

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

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

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

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

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

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

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

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

  320. 

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

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

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

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

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

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

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

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

  329. 

  330. 			addChild(createLight<SmallLight<GreenLight>>(mm2px(Vec(12.524985, 54.577202)), module, TAudioInterface::INPUT_LIGHTS + 0));

  331. 			addChild(createLight<SmallLight<GreenLight>>(mm2px(Vec(35.725647, 54.577202)), module, TAudioInterface::INPUT_LIGHTS + 1));

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

  333. 			addChild(createLight<SmallLight<GreenLight>>(mm2px(Vec(35.725647, 69.158226)), module, TAudioInterface::INPUT_LIGHTS + 3));

  334. 			addChild(createLight<SmallLight<GreenLight>>(mm2px(Vec(12.524985, 91.147583)), module, TAudioInterface::OUTPUT_LIGHTS + 0));

  335. 			addChild(createLight<SmallLight<GreenLight>>(mm2px(Vec(35.725647, 91.147583)), module, TAudioInterface::OUTPUT_LIGHTS + 1));

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

  337. 			addChild(createLight<SmallLight<GreenLight>>(mm2px(Vec(35.725647, 107.17003)), module, TAudioInterface::OUTPUT_LIGHTS + 3));

  338. 

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

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

  341. 			audioWidget->setAudioPort(module ? &module->port : NULL);

  342. 			addChild(audioWidget);

  343. 		}

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

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

  346. 

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

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

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

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

  351. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  368. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  385. 

  386. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(13.46, 55.667)), module, TAudioInterface::INPUT_LIGHTS + 0));

  387. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(36.661, 55.667)), module, TAudioInterface::INPUT_LIGHTS + 1));

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

  389. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(83.061, 55.667)), module, TAudioInterface::INPUT_LIGHTS + 3));

  390. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(13.46, 70.248)), module, TAudioInterface::INPUT_LIGHTS + 4));

  391. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(36.661, 70.248)), module, TAudioInterface::INPUT_LIGHTS + 5));

  392. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(59.861, 70.248)), module, TAudioInterface::INPUT_LIGHTS + 6));

  393. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(83.061, 70.248)), module, TAudioInterface::INPUT_LIGHTS + 7));

  394. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(13.46, 92.238)), module, TAudioInterface::OUTPUT_LIGHTS + 0));

  395. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(36.661, 92.238)), module, TAudioInterface::OUTPUT_LIGHTS + 1));

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

  397. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(83.061, 92.238)), module, TAudioInterface::OUTPUT_LIGHTS + 3));

  398. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(13.46, 108.259)), module, TAudioInterface::OUTPUT_LIGHTS + 4));

  399. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(36.661, 108.259)), module, TAudioInterface::OUTPUT_LIGHTS + 5));

  400. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(59.861, 108.259)), module, TAudioInterface::OUTPUT_LIGHTS + 6));

  401. 			addChild(createLightCentered<SmallLight<GreenLight>>(mm2px(Vec(83.061, 108.259)), module, TAudioInterface::OUTPUT_LIGHTS + 7));

  402. 

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

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

  405. 			audioWidget->setAudioPort(module ? &module->port : NULL);

  406. 			addChild(audioWidget);

  407. 		}

  408. 	}

  409. 

  410. 	void appendContextMenu(Menu* menu) override {

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

  412. 

  413. 		menu->addChild(new MenuEntry);

  414. 

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

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

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

  418. 		primaryModuleItem->module = module;

  419. 		menu->addChild(primaryModuleItem);

  420. 	}

  421. };

  422. 

  423. 

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

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

  426. 

  427. 

  428. } // namespace core

  429. } // namespace rack