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.
1441 Commits
4 Branches
546MB
Tree: 3b5380d28c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3b5380d28c'
${ noResults }
Rack/src/Core/AudioInterface.cpp

353 lines
17KB
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. using namespace rack;

  12. 

  13. 

  14. template <int AUDIO_OUTPUTS, int AUDIO_INPUTS>

  15. struct AudioInterfacePort : audio::Port {

  16. 	std::mutex engineMutex;

  17. 	std::condition_variable engineCv;

  18. 	std::mutex audioMutex;

  19. 	std::condition_variable audioCv;

  20. 	// Audio thread produces, engine thread consumes

  21. 	dsp::DoubleRingBuffer<dsp::Frame<AUDIO_INPUTS>, (1<<15)> inputBuffer;

  22. 	// Audio thread consumes, engine thread produces

  23. 	dsp::DoubleRingBuffer<dsp::Frame<AUDIO_OUTPUTS>, (1<<15)> outputBuffer;

  24. 	bool active = false;

  25. 

  26. 	~AudioInterfacePort() {

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

  28. 		setDeviceId(-1, 0);

  29. 	}

  30. 

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

  32. 		// Reactivate idle stream

  33. 		if (!active) {

  34. 			active = true;

  35. 			inputBuffer.clear();

  36. 			outputBuffer.clear();

  37. 		}

  38. 

  39. 		if (numInputs > 0) {

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

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

  42. 				if (inputBuffer.full())

  43. 					break;

  44. 				dsp::Frame<AUDIO_INPUTS> inputFrame;

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

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

  47. 				inputBuffer.push(inputFrame);

  48. 			}

  49. 		}

  50. 

  51. 		if (numOutputs > 0) {

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

  53. 			auto cond = [&] {

  54. 				return (outputBuffer.size() >= (size_t) frames);

  55. 			};

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

  57. 			if (audioCv.wait_for(lock, timeout, cond)) {

  58. 				// Consume audio block

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

  60. 					dsp::Frame<AUDIO_OUTPUTS> f = outputBuffer.shift();

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

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

  63. 					}

  64. 				}

  65. 			}

  66. 			else {

  67. 				// Timed out, fill output with zeros

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

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

  70. 			}

  71. 		}

  72. 

  73. 		// Notify engine when finished processing

  74. 		engineCv.notify_one();

  75. 	}

  76. 

  77. 	void onCloseStream() override {

  78. 		inputBuffer.clear();

  79. 		outputBuffer.clear();

  80. 	}

  81. 

  82. 	void onChannelsChange() override {

  83. 	}

  84. };

  85. 

  86. 

  87. template <int AUDIO_OUTPUTS, int AUDIO_INPUTS>

  88. struct AudioInterface : Module {

  89. 	enum ParamIds {

  90. 		NUM_PARAMS

  91. 	};

  92. 	enum InputIds {

  93. 		ENUMS(AUDIO_INPUT, AUDIO_INPUTS),

  94. 		NUM_INPUTS

  95. 	};

  96. 	enum OutputIds {

  97. 		ENUMS(AUDIO_OUTPUT, AUDIO_OUTPUTS),

  98. 		NUM_OUTPUTS

  99. 	};

  100. 	enum LightIds {

  101. 		ENUMS(INPUT_LIGHT, AUDIO_INPUTS / 2),

  102. 		ENUMS(OUTPUT_LIGHT, AUDIO_OUTPUTS / 2),

  103. 		NUM_LIGHTS

  104. 	};

  105. 

  106. 	AudioInterfacePort<AUDIO_OUTPUTS, AUDIO_INPUTS> port;

  107. 	int lastSampleRate = 0;

  108. 	int lastNumOutputs = -1;

  109. 	int lastNumInputs = -1;

  110. 

  111. 	dsp::SampleRateConverter<AUDIO_INPUTS> inputSrc;

  112. 	dsp::SampleRateConverter<AUDIO_OUTPUTS> outputSrc;

  113. 

  114. 	// in rack's sample rate

  115. 	dsp::DoubleRingBuffer<dsp::Frame<AUDIO_INPUTS>, 16> inputBuffer;

  116. 	dsp::DoubleRingBuffer<dsp::Frame<AUDIO_OUTPUTS>, 16> outputBuffer;

  117. 

  118. 	AudioInterface() {

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

  120. 		onSampleRateChange();

  121. 	}

  122. 

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

  124. 		// Update SRC states

  125. 		inputSrc.setRates(port.sampleRate, args.sampleRate);

  126. 		outputSrc.setRates(args.sampleRate, port.sampleRate);

  127. 

  128. 		inputSrc.setChannels(port.numInputs);

  129. 		outputSrc.setChannels(port.numOutputs);

  130. 

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

  132. 		if (port.active && port.numInputs > 0) {

  133. 			// Wait until inputs are present

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

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

  136. 			auto cond = [&] {

  137. 				return (!port.inputBuffer.empty());

  138. 			};

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

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

  141. 				// Convert inputs

  142. 				int inLen = port.inputBuffer.size();

  143. 				int outLen = inputBuffer.capacity();

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

  145. 				port.inputBuffer.startIncr(inLen);

  146. 				inputBuffer.endIncr(outLen);

  147. 			}

  148. 			else {

  149. 				// Give up on pulling input

  150. 				port.active = false;

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

  152. 			}

  153. 		}

  154. 

  155. 		// Take input from buffer

  156. 		dsp::Frame<AUDIO_INPUTS> inputFrame;

  157. 		if (!inputBuffer.empty()) {

  158. 			inputFrame = inputBuffer.shift();

  159. 		}

  160. 		else {

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

  162. 		}

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

  164. 			outputs[AUDIO_OUTPUT + i].setVoltage(10.f * inputFrame.samples[i]);

  165. 		}

  166. 		for (int i = port.numInputs; i < AUDIO_INPUTS; i++) {

  167. 			outputs[AUDIO_OUTPUT + i].setVoltage(0.f);

  168. 		}

  169. 

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

  171. 		if (port.active && port.numOutputs > 0) {

  172. 			// Get and push output SRC frame

  173. 			if (!outputBuffer.full()) {

  174. 				dsp::Frame<AUDIO_OUTPUTS> outputFrame;

  175. 				for (int i = 0; i < AUDIO_OUTPUTS; i++) {

  176. 					outputFrame.samples[i] = inputs[AUDIO_INPUT + i].getVoltage() / 10.f;

  177. 				}

  178. 				outputBuffer.push(outputFrame);

  179. 			}

  180. 

  181. 			if (outputBuffer.full()) {

  182. 				// Wait until enough outputs are consumed

  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.outputBuffer.size() < (size_t) port.blockSize);

  187. 				};

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

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

  190. 					// Push converted output

  191. 					int inLen = outputBuffer.size();

  192. 					int outLen = port.outputBuffer.capacity();

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

  194. 					outputBuffer.startIncr(inLen);

  195. 					port.outputBuffer.endIncr(outLen);

  196. 				}

  197. 				else {

  198. 					// Give up on pushing output

  199. 					port.active = false;

  200. 					outputBuffer.clear();

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

  202. 				}

  203. 			}

  204. 

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

  206. 			port.audioCv.notify_one();

  207. 		}

  208. 

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

  210. 		for (int i = 0; i < AUDIO_INPUTS / 2; i++)

  211. 			lights[INPUT_LIGHT + i].setBrightness(port.active && port.numOutputs >= 2*i+1);

  212. 		for (int i = 0; i < AUDIO_OUTPUTS / 2; i++)

  213. 			lights[OUTPUT_LIGHT + i].setBrightness(port.active && port.numInputs >= 2*i+1);

  214. 	}

  215. 

  216. 	json_t *dataToJson() override {

  217. 		json_t *rootJ = json_object();

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

  219. 		return rootJ;

  220. 	}

  221. 

  222. 	void dataFromJson(json_t *rootJ) override {

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

  224. 		port.fromJson(audioJ);

  225. 	}

  226. 

  227. 	void onReset() override {

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

  229. 	}

  230. };

  231. 

  232. 

  233. struct AudioInterface8Widget : ModuleWidget {

  234. 	typedef AudioInterface<8, 8> TAudioInterface;

  235. 

  236. 	AudioInterface8Widget(TAudioInterface *module) {

  237. 		setModule(module);

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

  239. 

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

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

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

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

  244. 

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

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

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

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

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

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

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

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

  253. 

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

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

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

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

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

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

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

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

  262. 

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

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

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

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

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

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

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

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

  271. 

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

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

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

  275. 		addChild(audioWidget);

  276. 	}

  277. };

  278. 

  279. 

  280. struct AudioInterface16Widget : ModuleWidget {

  281. 	typedef AudioInterface<16, 16> TAudioInterface;

  282. 

  283. 	AudioInterface16Widget(TAudioInterface *module) {

  284. 		setModule(module);

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

  286. 

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

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

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

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

  291. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  308. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  325. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  342. 

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

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

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

  346. 		addChild(audioWidget);

  347. 	}

  348. };

  349. 

  350. 

  351. Model *modelAudioInterface = createModel<AudioInterface<8, 8>, AudioInterface8Widget>("AudioInterface");

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