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.
1507 Commits
4 Branches
665MB
Tree: f678e52df1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f678e52df1'
${ 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. template <int AUDIO_OUTPUTS, int AUDIO_INPUTS>

  12. struct AudioInterfacePort : audio::Port {

  13. 	std::mutex engineMutex;

  14. 	std::condition_variable engineCv;

  15. 	std::mutex audioMutex;

  16. 	std::condition_variable audioCv;

  17. 	// Audio thread produces, engine thread consumes

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

  19. 	// Audio thread consumes, engine thread produces

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

  21. 	bool active = false;

  22. 

  23. 	~AudioInterfacePort() {

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

  25. 		setDeviceId(-1, 0);

  26. 	}

  27. 

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

  29. 		// Reactivate idle stream

  30. 		if (!active) {

  31. 			active = true;

  32. 			inputBuffer.clear();

  33. 			outputBuffer.clear();

  34. 		}

  35. 

  36. 		if (numInputs > 0) {

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

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

  39. 				if (inputBuffer.full())

  40. 					break;

  41. 				dsp::Frame<AUDIO_INPUTS> inputFrame;

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

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

  44. 				inputBuffer.push(inputFrame);

  45. 			}

  46. 		}

  47. 

  48. 		if (numOutputs > 0) {

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

  50. 			auto cond = [&] {

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

  52. 			};

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

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

  55. 				// Consume audio block

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

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

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

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

  60. 					}

  61. 				}

  62. 			}

  63. 			else {

  64. 				// Timed out, fill output with zeros

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

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

  67. 			}

  68. 		}

  69. 

  70. 		// Notify engine when finished processing

  71. 		engineCv.notify_one();

  72. 	}

  73. 

  74. 	void onCloseStream() override {

  75. 		inputBuffer.clear();

  76. 		outputBuffer.clear();

  77. 	}

  78. 

  79. 	void onChannelsChange() override {

  80. 	}

  81. };

  82. 

  83. 

  84. template <int AUDIO_OUTPUTS, int AUDIO_INPUTS>

  85. struct AudioInterface : Module {

  86. 	enum ParamIds {

  87. 		NUM_PARAMS

  88. 	};

  89. 	enum InputIds {

  90. 		ENUMS(AUDIO_INPUT, AUDIO_INPUTS),

  91. 		NUM_INPUTS

  92. 	};

  93. 	enum OutputIds {

  94. 		ENUMS(AUDIO_OUTPUT, AUDIO_OUTPUTS),

  95. 		NUM_OUTPUTS

  96. 	};

  97. 	enum LightIds {

  98. 		ENUMS(INPUT_LIGHT, AUDIO_INPUTS / 2),

  99. 		ENUMS(OUTPUT_LIGHT, AUDIO_OUTPUTS / 2),

  100. 		NUM_LIGHTS

  101. 	};

  102. 

  103. 	AudioInterfacePort<AUDIO_OUTPUTS, AUDIO_INPUTS> port;

  104. 	int lastSampleRate = 0;

  105. 	int lastNumOutputs = -1;

  106. 	int lastNumInputs = -1;

  107. 

  108. 	dsp::SampleRateConverter<AUDIO_INPUTS> inputSrc;

  109. 	dsp::SampleRateConverter<AUDIO_OUTPUTS> outputSrc;

  110. 

  111. 	// in rack's sample rate

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

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

  114. 

  115. 	AudioInterface() {

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

  117. 		port.maxChannels = std::max(AUDIO_OUTPUTS, AUDIO_INPUTS);

  118. 		onSampleRateChange();

  119. 	}

  120. 

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

  122. 		// Update SRC states

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

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

  125. 

  126. 		inputSrc.setChannels(port.numInputs);

  127. 		outputSrc.setChannels(port.numOutputs);

  128. 

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

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

  131. 			// Wait until inputs are present

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

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

  134. 			auto cond = [&] {

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

  136. 			};

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

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

  139. 				// Convert inputs

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

  141. 				int outLen = inputBuffer.capacity();

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

  143. 				port.inputBuffer.startIncr(inLen);

  144. 				inputBuffer.endIncr(outLen);

  145. 			}

  146. 			else {

  147. 				// Give up on pulling input

  148. 				port.active = false;

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

  150. 			}

  151. 		}

  152. 

  153. 		// Take input from buffer

  154. 		dsp::Frame<AUDIO_INPUTS> inputFrame;

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

  156. 			inputFrame = inputBuffer.shift();

  157. 		}

  158. 		else {

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

  160. 		}

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

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

  163. 		}

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

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

  166. 		}

  167. 

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

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

  170. 			// Get and push output SRC frame

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

  172. 				dsp::Frame<AUDIO_OUTPUTS> outputFrame;

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

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

  175. 				}

  176. 				outputBuffer.push(outputFrame);

  177. 			}

  178. 

  179. 			if (outputBuffer.full()) {

  180. 				// Wait until enough outputs are consumed

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

  182. 				auto cond = [&] {

  183. 					return (port.outputBuffer.size() < (size_t) port.blockSize);

  184. 				};

  185. 				if (!cond())

  186. 					APP->engine->yieldWorkers();

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

  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");