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

573 lines
27KB
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 AudioInterfacePort : audio::Port {

  17. 	Module* module;

  18. 

  19. 	dsp::DoubleRingBuffer<dsp::Frame<NUM_AUDIO_INPUTS>, 32768> engineInputBuffer;

  20. 	dsp::DoubleRingBuffer<dsp::Frame<NUM_AUDIO_OUTPUTS>, 32768> engineOutputBuffer;

  21. 

  22. 	dsp::SampleRateConverter<NUM_AUDIO_INPUTS> inputSrc;

  23. 	dsp::SampleRateConverter<NUM_AUDIO_OUTPUTS> outputSrc;

  24. 

  25. 	// Port variable caches

  26. 	int deviceNumInputs = 0;

  27. 	int deviceNumOutputs = 0;

  28. 	float deviceSampleRate = 0.f;

  29. 	int requestedEngineFrames = 0;

  30. 

  31. 	AudioInterfacePort(Module* module) {

  32. 		this->module = module;

  33. 		maxOutputs = NUM_AUDIO_INPUTS;

  34. 		maxInputs = NUM_AUDIO_OUTPUTS;

  35. 		inputSrc.setQuality(6);

  36. 		outputSrc.setQuality(6);

  37. 	}

  38. 

  39. 	void setPrimary() {

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

  41. 	}

  42. 

  43. 	bool isPrimary() {

  44. 		return APP->engine->getPrimaryModule() == module;

  45. 	}

  46. 

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

  48. 		// DEBUG("%p: new device block ____________________________", this);

  49. 		// Claim primary module if there is none

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

  51. 			setPrimary();

  52. 		}

  53. 		bool isPrimaryCached = isPrimary();

  54. 

  55. 		// Set sample rate of engine if engine sample rate is "auto".

  56. 		if (isPrimaryCached) {

  57. 			APP->engine->setSuggestedSampleRate(deviceSampleRate);

  58. 		}

  59. 

  60. 		float engineSampleRate = APP->engine->getSampleRate();

  61. 		float sampleRateRatio = engineSampleRate / deviceSampleRate;

  62. 

  63. 		// DEBUG("%p: %d block, engineOutputBuffer still has %d", this, frames, (int) engineOutputBuffer.size());

  64. 

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

  66. 		int maxEngineFrames = (int) std::ceil(frames * sampleRateRatio * 2.0) - 1;

  67. 		// If the engine output buffer is too full, clear it to keep latency low. No need to clear if primary because it's always cleared below.

  68. 		if (!isPrimaryCached && (int) engineOutputBuffer.size() > maxEngineFrames) {

  69. 			engineOutputBuffer.clear();

  70. 			// DEBUG("%p: clearing engine output", this);

  71. 		}

  72. 

  73. 		if (deviceNumInputs > 0) {

  74. 			// Always clear engine output if primary

  75. 			if (isPrimaryCached) {

  76. 				engineOutputBuffer.clear();

  77. 			}

  78. 			// Set up sample rate converter

  79. 			outputSrc.setRates(deviceSampleRate, engineSampleRate);

  80. 			outputSrc.setChannels(deviceNumInputs);

  81. 			// Convert audio input -> engine output

  82. 			dsp::Frame<NUM_AUDIO_OUTPUTS> audioInputBuffer[frames];

  83. 			std::memset(audioInputBuffer, 0, sizeof(audioInputBuffer));

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

  85. 				for (int j = 0; j < deviceNumInputs; j++) {

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

  87. 					audioInputBuffer[i].samples[j] = v;

  88. 				}

  89. 			}

  90. 			int audioInputFrames = frames;

  91. 			int outputFrames = engineOutputBuffer.capacity();

  92. 			outputSrc.process(audioInputBuffer, &audioInputFrames, engineOutputBuffer.endData(), &outputFrames);

  93. 			engineOutputBuffer.endIncr(outputFrames);

  94. 			// Request exactly as many frames as we have in the engine output buffer.

  95. 			requestedEngineFrames = engineOutputBuffer.size();

  96. 		}

  97. 		else {

  98. 			// Upper bound on number of frames so that `audioOutputFrames >= frames` when processOutput() is called.

  99. 			requestedEngineFrames = std::max((int) std::ceil(frames * sampleRateRatio) - (int) engineInputBuffer.size(), 0);

  100. 		}

  101. 	}

  102. 

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

  104. 		// Step engine

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

  106. 			// DEBUG("%p: %d block, stepping %d", this, frames, requestedEngineFrames);

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

  108. 		}

  109. 	}

  110. 

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

  112. 		// bool isPrimaryCached = isPrimary();

  113. 		float engineSampleRate = APP->engine->getSampleRate();

  114. 		float sampleRateRatio = engineSampleRate / deviceSampleRate;

  115. 

  116. 		if (deviceNumOutputs > 0) {

  117. 			// Set up sample rate converter

  118. 			inputSrc.setRates(engineSampleRate, deviceSampleRate);

  119. 			inputSrc.setChannels(deviceNumOutputs);

  120. 			// Convert engine input -> audio output

  121. 			dsp::Frame<NUM_AUDIO_OUTPUTS> audioOutputBuffer[frames];

  122. 			int inputFrames = engineInputBuffer.size();

  123. 			int audioOutputFrames = frames;

  124. 			inputSrc.process(engineInputBuffer.startData(), &inputFrames, audioOutputBuffer, &audioOutputFrames);

  125. 			engineInputBuffer.startIncr(inputFrames);

  126. 			// Copy the audio output buffer

  127. 			for (int i = 0; i < audioOutputFrames; i++) {

  128. 				for (int j = 0; j < deviceNumOutputs; j++) {

  129. 					float v = audioOutputBuffer[i].samples[j];

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

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

  132. 				}

  133. 			}

  134. 			// Fill the rest of the audio output buffer with zeros

  135. 			for (int i = audioOutputFrames; i < frames; i++) {

  136. 				for (int j = 0; j < deviceNumOutputs; j++) {

  137. 					output[i * outputStride + j] = 0.f;

  138. 				}

  139. 			}

  140. 		}

  141. 

  142. 		// DEBUG("%p: %d block, engineInputBuffer left %d", this, frames, (int) engineInputBuffer.size());

  143. 

  144. 		// If the engine input buffer is too full, clear it to keep latency low.

  145. 		int maxEngineFrames = (int) std::ceil(frames * sampleRateRatio * 2.0) - 1;

  146. 		if ((int) engineInputBuffer.size() > maxEngineFrames) {

  147. 			engineInputBuffer.clear();

  148. 			// DEBUG("%p: clearing engine input", this);

  149. 		}

  150. 

  151. 		// DEBUG("%p %s:\tframes %d requestedEngineFrames %d\toutputBuffer %d engineInputBuffer %d\t", this, isPrimaryCached ? "primary" : "secondary", frames, requestedEngineFrames, engineOutputBuffer.size(), engineInputBuffer.size());

  152. 	}

  153. 

  154. 	void onStartStream() override {

  155. 		deviceNumInputs = std::min(getNumInputs(), NUM_AUDIO_OUTPUTS);

  156. 		deviceNumOutputs = std::min(getNumOutputs(), NUM_AUDIO_INPUTS);

  157. 		deviceSampleRate = getSampleRate();

  158. 		engineInputBuffer.clear();

  159. 		engineOutputBuffer.clear();

  160. 		// DEBUG("onStartStream %d %d %f", deviceNumInputs, deviceNumOutputs, deviceSampleRate);

  161. 	}

  162. 

  163. 	void onStopStream() override {

  164. 		deviceNumInputs = 0;

  165. 		deviceNumOutputs = 0;

  166. 		deviceSampleRate = 0.f;

  167. 		engineInputBuffer.clear();

  168. 		engineOutputBuffer.clear();

  169. 		// DEBUG("onStopStream");

  170. 	}

  171. };

  172. 

  173. 

  174. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  175. struct AudioInterface : Module {

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

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

  178. 

  179. 	enum ParamIds {

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

  181. 		NUM_PARAMS

  182. 	};

  183. 	enum InputIds {

  184. 		ENUMS(AUDIO_INPUTS, NUM_AUDIO_INPUTS),

  185. 		NUM_INPUTS

  186. 	};

  187. 	enum OutputIds {

  188. 		ENUMS(AUDIO_OUTPUTS, NUM_AUDIO_OUTPUTS),

  189. 		NUM_OUTPUTS

  190. 	};

  191. 	enum LightIds {

  192. 		ENUMS(INPUT_LIGHTS, NUM_INPUT_LIGHTS * 2),

  193. 		ENUMS(OUTPUT_LIGHTS, NUM_OUTPUT_LIGHTS * 2),

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

  195. 		NUM_LIGHTS

  196. 	};

  197. 

  198. 	AudioInterfacePort<NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS> port;

  199. 

  200. 	dsp::RCFilter dcFilters[NUM_AUDIO_INPUTS];

  201. 	bool dcFilterEnabled = false;

  202. 

  203. 	dsp::ClockDivider lightDivider;

  204. 	// For each pair of inputs/outputs

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

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

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

  208. 

  209. 	AudioInterface() : port(this) {

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

  211. 		if (NUM_AUDIO_INPUTS == 2)

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

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

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

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

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

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

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

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

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

  221. 

  222. 		lightDivider.setDivision(512);

  223. 

  224. 		float sampleTime = APP->engine->getSampleTime();

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

  226. 			dcFilters[i].setCutoffFreq(10.f * sampleTime);

  227. 		}

  228. 

  229. 		onReset();

  230. 	}

  231. 

  232. 	~AudioInterface() {

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

  234. 		port.setDriverId(-1);

  235. 	}

  236. 

  237. 	void onReset() override {

  238. 		port.setDriverId(-1);

  239. 

  240. 		if (NUM_AUDIO_INPUTS == 2)

  241. 			dcFilterEnabled = true;

  242. 		else

  243. 			dcFilterEnabled = false;

  244. 	}

  245. 

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

  247. 		port.engineInputBuffer.clear();

  248. 		port.engineOutputBuffer.clear();

  249. 

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

  251. 			dcFilters[i].setCutoffFreq(10.f * e.sampleTime);

  252. 		}

  253. 	}

  254. 

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

  256. 		const float clipTime = 0.25f;

  257. 

  258. 		// Push inputs to buffer

  259. 		if (port.deviceNumOutputs > 0) {

  260. 			dsp::Frame<NUM_AUDIO_INPUTS> inputFrame = {};

  261. 			for (int i = 0; i < port.deviceNumOutputs; i++) {

  262. 				// Get input

  263. 				float v = 0.f;

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

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

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

  267. 				else if (i == 1 && NUM_AUDIO_INPUTS == 2)

  268. 					v = inputFrame.samples[0];

  269. 

  270. 				// Apply DC filter

  271. 				if (dcFilterEnabled) {

  272. 					dcFilters[i].process(v);

  273. 					v = dcFilters[i].highpass();

  274. 				}

  275. 

  276. 				// Detect clipping

  277. 				if (NUM_AUDIO_INPUTS > 2) {

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

  279. 						inputClipTimers[i / 2] = clipTime;

  280. 				}

  281. 				inputFrame.samples[i] = v;

  282. 			}

  283. 

  284. 			// Audio-2: Apply gain from knob

  285. 			if (NUM_AUDIO_INPUTS == 2) {

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

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

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

  289. 				}

  290. 			}

  291. 

  292. 			if (!port.engineInputBuffer.full()) {

  293. 				port.engineInputBuffer.push(inputFrame);

  294. 			}

  295. 

  296. 			// Audio-2: VU meter process

  297. 			if (NUM_AUDIO_INPUTS == 2) {

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

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

  300. 				}

  301. 			}

  302. 		}

  303. 		else {

  304. 			// Audio-2: Clear VU meter

  305. 			if (NUM_AUDIO_INPUTS == 2) {

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

  307. 					vuMeter[i].reset();

  308. 				}

  309. 			}

  310. 		}

  311. 

  312. 		// Pull outputs from buffer

  313. 		if (!port.engineOutputBuffer.empty()) {

  314. 			dsp::Frame<NUM_AUDIO_OUTPUTS> outputFrame = port.engineOutputBuffer.shift();

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

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

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

  318. 

  319. 				// Detect clipping

  320. 				if (NUM_AUDIO_OUTPUTS > 2) {

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

  322. 						outputClipTimers[i / 2] = clipTime;

  323. 				}

  324. 			}

  325. 		}

  326. 		else {

  327. 			// Zero outputs

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

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

  330. 			}

  331. 		}

  332. 

  333. 		// Lights

  334. 		if (lightDivider.process()) {

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

  336. 			// Audio-2: VU meter

  337. 			if (NUM_AUDIO_INPUTS == 2) {

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

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

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

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

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

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

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

  345. 				}

  346. 			}

  347. 			// Audio-8 and Audio-16: pair state lights

  348. 			else {

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

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

  351. 					bool active = port.deviceNumOutputs >= 2 * i + 1;

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

  353. 					if (clip)

  354. 						inputClipTimers[i] -= lightTime;

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

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

  357. 				}

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

  359. 					bool active = port.deviceNumInputs >= 2 * i + 1;

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

  361. 					if (clip)

  362. 						outputClipTimers[i] -= lightTime;

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

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

  365. 				}

  366. 			}

  367. 		}

  368. 	}

  369. 

  370. 	json_t* dataToJson() override {

  371. 		json_t* rootJ = json_object();

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

  373. 

  374. 		json_object_set_new(rootJ, "dcFilter", json_boolean(dcFilterEnabled));

  375. 

  376. 		return rootJ;

  377. 	}

  378. 

  379. 	void dataFromJson(json_t* rootJ) override {

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

  381. 		if (audioJ)

  382. 			port.fromJson(audioJ);

  383. 

  384. 		json_t* dcFilterJ = json_object_get(rootJ, "dcFilter");

  385. 		if (dcFilterJ)

  386. 			dcFilterEnabled = json_boolean_value(dcFilterJ);

  387. 	}

  388. 

  389. 	/** Must be called when the Engine mutex is unlocked.

  390. 	*/

  391. 	void setPrimary() {

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

  393. 	}

  394. 

  395. 	bool isPrimary() {

  396. 		return APP->engine->getPrimaryModule() == this;

  397. 	}

  398. };

  399. 

  400. 

  401. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  402. struct AudioInterfaceWidget : ModuleWidget {

  403. 	typedef AudioInterface<NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS> TAudioInterface;

  404. 

  405. 	AudioInterfaceWidget(TAudioInterface* module) {

  406. 		setModule(module);

  407. 

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

  409. 			setPanel(Svg::load(asset::system("res/Core/AudioInterface.svg")));

  410. 

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

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

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

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

  415. 

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

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

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

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

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

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

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

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

  424. 

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

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

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

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

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

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

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

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

  433. 

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

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

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

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

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

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

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

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

  442. 

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

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

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

  446. 			addChild(audioWidget);

  447. 		}

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

  449. 			setPanel(Svg::load(asset::system("res/Core/AudioInterface16.svg")));

  450. 

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

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

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

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

  455. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  472. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  489. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  506. 

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

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

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

  510. 			addChild(audioWidget);

  511. 		}

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

  513. 			setPanel(Svg::load(asset::system("res/Core/AudioInterface2.svg")));

  514. 

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

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

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

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

  519. 

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

  521. 

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

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

  524. 

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

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

  527. 

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

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

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

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

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

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

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

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

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

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

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

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

  540. 

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

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

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

  544. 			// Adjust deviceChoice position

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

  546. 			addChild(audioWidget);

  547. 		}

  548. 	}

  549. 

  550. 	void appendContextMenu(Menu* menu) override {

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

  552. 

  553. 		menu->addChild(new MenuSeparator);

  554. 

  555. 		menu->addChild(createCheckMenuItem("Primary audio module",

  556. 			[=]() {return module->isPrimary();},

  557. 			[=]() {module->setPrimary();}

  558. 		));

  559. 

  560. 		menu->addChild(createBoolPtrMenuItem("DC blocker", &module->dcFilterEnabled));

  561. 	}

  562. };

  563. 

  564. 

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

  566. // Legacy name for Audio-8

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

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

  569. 

  570. 

  571. } // namespace core

  572. } // namespace rack