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

628 lines
28KB
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 AudioPort : 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. 	AudioPort(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 setMaster(bool master = true) {

  40. 		if (master) {

  41. 			APP->engine->setMasterModule(module);

  42. 		}

  43. 		else {

  44. 			// Unset master only if module is currently master

  45. 			if (isMaster())

  46. 				APP->engine->setMasterModule(NULL);

  47. 		}

  48. 	}

  49. 

  50. 	bool isMaster() {

  51. 		return APP->engine->getMasterModule() == module;

  52. 	}

  53. 

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

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

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

  57. 		deviceSampleRate = getSampleRate();

  58. 

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

  60. 		// Claim master module if there is none

  61. 		if (!APP->engine->getMasterModule()) {

  62. 			setMaster();

  63. 		}

  64. 		bool isMasterCached = isMaster();

  65. 

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

  67. 		if (isMasterCached) {

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

  69. 		}

  70. 

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

  72. 		float sampleRateRatio = engineSampleRate / deviceSampleRate;

  73. 

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

  75. 

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

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

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

  79. 		if (!isMasterCached && (int) engineOutputBuffer.size() > maxEngineFrames) {

  80. 			engineOutputBuffer.clear();

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

  82. 		}

  83. 

  84. 		if (deviceNumInputs > 0) {

  85. 			// Always clear engine output if master

  86. 			if (isMasterCached) {

  87. 				engineOutputBuffer.clear();

  88. 			}

  89. 			// Set up sample rate converter

  90. 			outputSrc.setRates(deviceSampleRate, engineSampleRate);

  91. 			outputSrc.setChannels(deviceNumInputs);

  92. 			int inputFrames = frames;

  93. 			int outputFrames = engineOutputBuffer.capacity();

  94. 			outputSrc.process(input, inputStride, &inputFrames, (float*) engineOutputBuffer.endData(), NUM_AUDIO_OUTPUTS, &outputFrames);

  95. 			engineOutputBuffer.endIncr(outputFrames);

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

  97. 			requestedEngineFrames = engineOutputBuffer.size();

  98. 		}

  99. 		else {

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

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

  102. 		}

  103. 	}

  104. 

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

  106. 		// Step engine

  107. 		if (isMaster() && requestedEngineFrames > 0) {

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

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

  110. 		}

  111. 	}

  112. 

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

  114. 		// bool isMasterCached = isMaster();

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

  116. 		float sampleRateRatio = engineSampleRate / deviceSampleRate;

  117. 

  118. 		if (deviceNumOutputs > 0) {

  119. 			// Set up sample rate converter

  120. 			inputSrc.setRates(engineSampleRate, deviceSampleRate);

  121. 			inputSrc.setChannels(deviceNumOutputs);

  122. 			// Convert engine input -> audio output

  123. 			int inputFrames = engineInputBuffer.size();

  124. 			int outputFrames = frames;

  125. 			inputSrc.process((const float*) engineInputBuffer.startData(), NUM_AUDIO_INPUTS, &inputFrames, output, outputStride, &outputFrames);

  126. 			engineInputBuffer.startIncr(inputFrames);

  127. 			// Clamp output samples

  128. 			for (int i = 0; i < outputFrames; i++) {

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

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

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

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

  133. 				}

  134. 			}

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

  136. 			for (int i = outputFrames; i < frames; i++) {

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

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

  139. 				}

  140. 			}

  141. 		}

  142. 

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

  144. 

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

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

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

  148. 			engineInputBuffer.clear();

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

  150. 		}

  151. 

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

  153. 	}

  154. 

  155. 	void onStartStream() override {

  156. 		engineInputBuffer.clear();

  157. 		engineOutputBuffer.clear();

  158. 		// DEBUG("onStartStream");

  159. 	}

  160. 

  161. 	void onStopStream() override {

  162. 		deviceNumInputs = 0;

  163. 		deviceNumOutputs = 0;

  164. 		deviceSampleRate = 0.f;

  165. 		engineInputBuffer.clear();

  166. 		engineOutputBuffer.clear();

  167. 		// We can be in an Engine write-lock here (e.g. onReset() calls this indirectly), so use non-locking master module API.

  168. 		// setMaster(false);

  169. 		if (APP->engine->getMasterModule() == module)

  170. 			APP->engine->setMasterModule_NoLock(NULL);

  171. 		// DEBUG("onStopStream");

  172. 	}

  173. };

  174. 

  175. 

  176. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  177. struct Audio : Module {

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

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

  180. 

  181. 	enum ParamIds {

  182. 		ENUMS(LEVEL_PARAM, NUM_AUDIO_INPUTS == 2),

  183. 		NUM_PARAMS

  184. 	};

  185. 	enum InputIds {

  186. 		ENUMS(AUDIO_INPUTS, NUM_AUDIO_INPUTS),

  187. 		NUM_INPUTS

  188. 	};

  189. 	enum OutputIds {

  190. 		ENUMS(AUDIO_OUTPUTS, NUM_AUDIO_OUTPUTS),

  191. 		NUM_OUTPUTS

  192. 	};

  193. 	enum LightIds {

  194. 		ENUMS(INPUT_LIGHTS, NUM_INPUT_LIGHTS * 2),

  195. 		ENUMS(OUTPUT_LIGHTS, NUM_OUTPUT_LIGHTS * 2),

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

  197. 		NUM_LIGHTS

  198. 	};

  199. 

  200. 	AudioPort<NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS> port;

  201. 

  202. 	dsp::RCFilter dcFilters[NUM_AUDIO_INPUTS];

  203. 	bool dcFilterEnabled = false;

  204. 

  205. 	dsp::ClockDivider lightDivider;

  206. 	// For each pair of inputs/outputs

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

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

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

  210. 

  211. 	Audio() : port(this) {

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

  213. 		if (NUM_AUDIO_INPUTS == 2)

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

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

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

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

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

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

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

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

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

  223. 

  224. 		lightDivider.setDivision(512);

  225. 

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

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

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

  229. 		}

  230. 

  231. 		onReset();

  232. 	}

  233. 

  234. 	~Audio() {

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

  236. 		port.setDriverId(-1);

  237. 	}

  238. 

  239. 	void onReset() override {

  240. 		port.setDriverId(-1);

  241. 

  242. 		if (NUM_AUDIO_INPUTS == 2)

  243. 			dcFilterEnabled = true;

  244. 		else

  245. 			dcFilterEnabled = false;

  246. 	}

  247. 

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

  249. 		port.engineInputBuffer.clear();

  250. 		port.engineOutputBuffer.clear();

  251. 

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

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

  254. 		}

  255. 	}

  256. 

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

  258. 		const float clipTime = 0.25f;

  259. 

  260. 		// Push inputs to buffer

  261. 		if (port.deviceNumOutputs > 0) {

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

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

  264. 				// Get input

  265. 				float v = 0.f;

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

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

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

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

  270. 					v = inputFrame.samples[0];

  271. 

  272. 				// Apply DC filter

  273. 				if (dcFilterEnabled) {

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

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

  276. 				}

  277. 

  278. 				// Detect clipping

  279. 				if (NUM_AUDIO_INPUTS > 2) {

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

  281. 						inputClipTimers[i / 2] = clipTime;

  282. 				}

  283. 				inputFrame.samples[i] = v;

  284. 			}

  285. 

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

  287. 			if (NUM_AUDIO_INPUTS == 2) {

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

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

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

  291. 				}

  292. 			}

  293. 

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

  295. 				port.engineInputBuffer.push(inputFrame);

  296. 			}

  297. 

  298. 			// Audio-2: VU meter process

  299. 			if (NUM_AUDIO_INPUTS == 2) {

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

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

  302. 				}

  303. 			}

  304. 		}

  305. 		else {

  306. 			// Audio-2: Clear VU meter

  307. 			if (NUM_AUDIO_INPUTS == 2) {

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

  309. 					vuMeter[i].reset();

  310. 				}

  311. 			}

  312. 		}

  313. 

  314. 		// Pull outputs from buffer

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

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

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

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

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

  320. 

  321. 				// Detect clipping

  322. 				if (NUM_AUDIO_OUTPUTS > 2) {

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

  324. 						outputClipTimers[i / 2] = clipTime;

  325. 				}

  326. 			}

  327. 		}

  328. 		else {

  329. 			// Zero outputs

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

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

  332. 			}

  333. 		}

  334. 

  335. 		// Lights

  336. 		if (lightDivider.process()) {

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

  338. 			// Audio-2: VU meter

  339. 			if (NUM_AUDIO_INPUTS == 2) {

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

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

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

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

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

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

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

  347. 				}

  348. 			}

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

  350. 			else {

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

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

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

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

  355. 					if (clip)

  356. 						inputClipTimers[i] -= lightTime;

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

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

  359. 				}

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

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

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

  363. 					if (clip)

  364. 						outputClipTimers[i] -= lightTime;

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

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

  367. 				}

  368. 			}

  369. 		}

  370. 	}

  371. 

  372. 	json_t* dataToJson() override {

  373. 		json_t* rootJ = json_object();

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

  375. 

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

  377. 

  378. 		return rootJ;

  379. 	}

  380. 

  381. 	void dataFromJson(json_t* rootJ) override {

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

  383. 		if (audioJ)

  384. 			port.fromJson(audioJ);

  385. 

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

  387. 		if (dcFilterJ)

  388. 			dcFilterEnabled = json_boolean_value(dcFilterJ);

  389. 	}

  390. };

  391. 

  392. 

  393. /** For Audio-2 module. */

  394. struct Audio2Display : LedDisplay {

  395. 	AudioDeviceMenuChoice* deviceChoice;

  396. 	LedDisplaySeparator* deviceSeparator;

  397. 

  398. 	void setAudioPort(audio::Port* port) {

  399. 		math::Vec pos;

  400. 

  401. 		deviceChoice = createWidget<AudioDeviceMenuChoice>(math::Vec());

  402. 		deviceChoice->box.size.x = box.size.x;

  403. 		deviceChoice->port = port;

  404. 		addChild(deviceChoice);

  405. 		pos = deviceChoice->box.getBottomLeft();

  406. 

  407. 		deviceSeparator = createWidget<LedDisplaySeparator>(pos);

  408. 		deviceSeparator->box.size.x = box.size.x;

  409. 		addChild(deviceSeparator);

  410. 	}

  411. 

  412. 	void drawLayer(const DrawArgs& args, int layer) override {

  413. 		if (layer == 1) {

  414. 			static const std::vector<float> posY = {

  415. 				mm2px(28.899 - 13.039),

  416. 				mm2px(34.196 - 13.039),

  417. 				mm2px(39.494 - 13.039),

  418. 				mm2px(44.791 - 13.039),

  419. 				mm2px(50.089 - 13.039),

  420. 				mm2px(55.386 - 13.039),

  421. 			};

  422. 			static const std::vector<std::string> texts = {

  423. 				" 0", "-3", "-6", "-12", "-24", "-36",

  424. 			};

  425. 

  426. 			std::string fontPath = asset::system("res/fonts/Nunito-Bold.ttf");

  427. 			std::shared_ptr<Font> font = APP->window->loadFont(fontPath);

  428. 			if (!font)

  429. 				return;

  430. 

  431. 			nvgSave(args.vg);

  432. 			nvgFontFaceId(args.vg, font->handle);

  433. 			nvgFontSize(args.vg, 11);

  434. 			nvgTextLetterSpacing(args.vg, 0.0);

  435. 			nvgTextAlign(args.vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);

  436. 			nvgFillColor(args.vg, nvgRGB(99, 99, 99));

  437. 

  438. 			for (int i = 0; i < 6; i++) {

  439. 				nvgText(args.vg, 36.0, posY[i], texts[i].c_str(), NULL);

  440. 			}

  441. 			nvgRestore(args.vg);

  442. 		}

  443. 		LedDisplay::drawLayer(args, layer);

  444. 	}

  445. };

  446. 

  447. 

  448. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  449. struct AudioWidget : ModuleWidget {

  450. 	typedef Audio<NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS> TAudio;

  451. 

  452. 	AudioWidget(TAudio* module) {

  453. 		setModule(module);

  454. 

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

  456. 			setPanel(Svg::load(asset::system("res/Core/Audio8.svg")));

  457. 

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

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

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

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

  462. 

  463. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(7.81, 57.929)), module, TAudio::AUDIO_INPUTS + 0));

  464. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(19.359, 57.929)), module, TAudio::AUDIO_INPUTS + 1));

  465. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(30.909, 57.929)), module, TAudio::AUDIO_INPUTS + 2));

  466. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(42.459, 57.929)), module, TAudio::AUDIO_INPUTS + 3));

  467. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(7.81, 74.286)), module, TAudio::AUDIO_INPUTS + 4));

  468. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(19.359, 74.286)), module, TAudio::AUDIO_INPUTS + 5));

  469. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(30.909, 74.286)), module, TAudio::AUDIO_INPUTS + 6));

  470. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(42.459, 74.286)), module, TAudio::AUDIO_INPUTS + 7));

  471. 

  472. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.81, 96.859)), module, TAudio::AUDIO_OUTPUTS + 0));

  473. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.359, 96.859)), module, TAudio::AUDIO_OUTPUTS + 1));

  474. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(30.909, 96.859)), module, TAudio::AUDIO_OUTPUTS + 2));

  475. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(42.459, 96.859)), module, TAudio::AUDIO_OUTPUTS + 3));

  476. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.81, 113.115)), module, TAudio::AUDIO_OUTPUTS + 4));

  477. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.359, 113.115)), module, TAudio::AUDIO_OUTPUTS + 5));

  478. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(30.909, 113.115)), module, TAudio::AUDIO_OUTPUTS + 6));

  479. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(42.459, 113.115)), module, TAudio::AUDIO_OUTPUTS + 7));

  480. 

  481. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.54, 52.168)), module, TAudio::INPUT_LIGHTS + 2 * 0));

  482. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.774, 52.168)), module, TAudio::INPUT_LIGHTS + 2 * 1));

  483. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.54, 68.53)), module, TAudio::INPUT_LIGHTS + 2 * 2));

  484. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.774, 68.53)), module, TAudio::INPUT_LIGHTS + 2 * 3));

  485. 

  486. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.54, 90.791)), module, TAudio::OUTPUT_LIGHTS + 2 * 0));

  487. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.638, 90.791)), module, TAudio::OUTPUT_LIGHTS + 2 * 1));

  488. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.54, 107.097)), module, TAudio::OUTPUT_LIGHTS + 2 * 2));

  489. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.638, 107.097)), module, TAudio::OUTPUT_LIGHTS + 2 * 3));

  490. 

  491. 			AudioDisplay* display = createWidget<AudioDisplay>(mm2px(Vec(0.0, 13.039)));

  492. 			display->box.size = mm2px(Vec(50.8, 29.021));

  493. 			display->setAudioPort(module ? &module->port : NULL);

  494. 			addChild(display);

  495. 		}

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

  497. 			setPanel(Svg::load(asset::system("res/Core/Audio16.svg")));

  498. 

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

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

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

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

  503. 

  504. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(7.815, 57.929)), module, TAudio::AUDIO_INPUTS + 0));

  505. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(19.364, 57.929)), module, TAudio::AUDIO_INPUTS + 1));

  506. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(30.914, 57.929)), module, TAudio::AUDIO_INPUTS + 2));

  507. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(42.464, 57.929)), module, TAudio::AUDIO_INPUTS + 3));

  508. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(54.015, 57.929)), module, TAudio::AUDIO_INPUTS + 4));

  509. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(65.565, 57.914)), module, TAudio::AUDIO_INPUTS + 5));

  510. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(77.114, 57.914)), module, TAudio::AUDIO_INPUTS + 6));

  511. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(88.664, 57.914)), module, TAudio::AUDIO_INPUTS + 7));

  512. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(7.815, 74.276)), module, TAudio::AUDIO_INPUTS + 8));

  513. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(19.364, 74.276)), module, TAudio::AUDIO_INPUTS + 9));

  514. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(30.914, 74.276)), module, TAudio::AUDIO_INPUTS + 10));

  515. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(42.464, 74.276)), module, TAudio::AUDIO_INPUTS + 11));

  516. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(54.015, 74.291)), module, TAudio::AUDIO_INPUTS + 12));

  517. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(65.565, 74.276)), module, TAudio::AUDIO_INPUTS + 13));

  518. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(77.114, 74.276)), module, TAudio::AUDIO_INPUTS + 14));

  519. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(88.664, 74.276)), module, TAudio::AUDIO_INPUTS + 15));

  520. 

  521. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.815, 96.859)), module, TAudio::AUDIO_OUTPUTS + 0));

  522. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.364, 96.859)), module, TAudio::AUDIO_OUTPUTS + 1));

  523. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(30.914, 96.859)), module, TAudio::AUDIO_OUTPUTS + 2));

  524. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(42.464, 96.859)), module, TAudio::AUDIO_OUTPUTS + 3));

  525. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(54.015, 96.859)), module, TAudio::AUDIO_OUTPUTS + 4));

  526. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(65.565, 96.859)), module, TAudio::AUDIO_OUTPUTS + 5));

  527. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(77.114, 96.859)), module, TAudio::AUDIO_OUTPUTS + 6));

  528. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(88.664, 96.859)), module, TAudio::AUDIO_OUTPUTS + 7));

  529. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.815, 113.115)), module, TAudio::AUDIO_OUTPUTS + 8));

  530. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.364, 113.115)), module, TAudio::AUDIO_OUTPUTS + 9));

  531. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(30.914, 113.115)), module, TAudio::AUDIO_OUTPUTS + 10));

  532. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(42.464, 113.115)), module, TAudio::AUDIO_OUTPUTS + 11));

  533. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(54.015, 113.115)), module, TAudio::AUDIO_OUTPUTS + 12));

  534. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(65.565, 113.115)), module, TAudio::AUDIO_OUTPUTS + 13));

  535. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(77.114, 113.115)), module, TAudio::AUDIO_OUTPUTS + 14));

  536. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(88.664, 113.115)), module, TAudio::AUDIO_OUTPUTS + 15));

  537. 

  538. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.545, 52.168)), module, TAudio::INPUT_LIGHTS + 2 * 0));

  539. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.779, 52.168)), module, TAudio::INPUT_LIGHTS + 2 * 1));

  540. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(59.745, 52.168)), module, TAudio::INPUT_LIGHTS + 2 * 2));

  541. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(82.98, 52.168)), module, TAudio::INPUT_LIGHTS + 2 * 3));

  542. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.545, 68.53)), module, TAudio::INPUT_LIGHTS + 2 * 4));

  543. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.779, 68.53)), module, TAudio::INPUT_LIGHTS + 2 * 5));

  544. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(59.745, 68.53)), module, TAudio::INPUT_LIGHTS + 2 * 6));

  545. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(82.98, 68.53)), module, TAudio::INPUT_LIGHTS + 2 * 7));

  546. 

  547. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.545, 90.791)), module, TAudio::OUTPUT_LIGHTS + 2 * 0));

  548. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.644, 90.791)), module, TAudio::OUTPUT_LIGHTS + 2 * 1));

  549. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(59.745, 90.791)), module, TAudio::OUTPUT_LIGHTS + 2 * 2));

  550. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(82.844, 90.791)), module, TAudio::OUTPUT_LIGHTS + 2 * 3));

  551. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(13.545, 107.097)), module, TAudio::OUTPUT_LIGHTS + 2 * 4));

  552. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(36.644, 107.097)), module, TAudio::OUTPUT_LIGHTS + 2 * 5));

  553. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(59.745, 107.097)), module, TAudio::OUTPUT_LIGHTS + 2 * 6));

  554. 			addChild(createLightCentered<SmallLight<GreenRedLight>>(mm2px(Vec(82.844, 107.097)), module, TAudio::OUTPUT_LIGHTS + 2 * 7));

  555. 

  556. 			AudioDisplay* display = createWidget<AudioDisplay>(mm2px(Vec(0.0, 13.039)));

  557. 			display->box.size = mm2px(Vec(96.52, 29.021));

  558. 			display->setAudioPort(module ? &module->port : NULL);

  559. 			addChild(display);

  560. 		}

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

  562. 			setPanel(Svg::load(asset::system("res/Core/Audio2.svg")));

  563. 

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

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

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

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

  568. 

  569. 			addParam(createParamCentered<RoundLargeBlackKnob>(mm2px(Vec(12.869, 77.362)), module, TAudio::LEVEL_PARAM));

  570. 

  571. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(7.285, 96.859)), module, TAudio::AUDIO_INPUTS + 0));

  572. 			addInput(createInputCentered<PJ301MPort>(mm2px(Vec(18.122, 96.859)), module, TAudio::AUDIO_INPUTS + 1));

  573. 

  574. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(7.285, 113.115)), module, TAudio::AUDIO_OUTPUTS + 0));

  575. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(18.122, 113.115)), module, TAudio::AUDIO_OUTPUTS + 1));

  576. 

  577. 			Audio2Display* display = createWidget<Audio2Display>(mm2px(Vec(0.0, 13.039)));

  578. 			display->box.size = mm2px(Vec(25.4, 47.726));

  579. 			display->setAudioPort(module ? &module->port : NULL);

  580. 			addChild(display);

  581. 

  582. 			addChild(createLightCentered<SmallSimpleLight<RedLight>>(mm2px(Vec(6.691, 28.899)), module, TAudio::VU_LIGHTS + 6 * 0 + 0));

  583. 			addChild(createLightCentered<SmallSimpleLight<RedLight>>(mm2px(Vec(18.709, 28.899)), module, TAudio::VU_LIGHTS + 6 * 1 + 0));

  584. 			addChild(createLightCentered<SmallSimpleLight<YellowLight>>(mm2px(Vec(6.691, 34.196)), module, TAudio::VU_LIGHTS + 6 * 0 + 1));

  585. 			addChild(createLightCentered<SmallSimpleLight<YellowLight>>(mm2px(Vec(18.709, 34.196)), module, TAudio::VU_LIGHTS + 6 * 1 + 1));

  586. 			addChild(createLightCentered<SmallSimpleLight<GreenLight>>(mm2px(Vec(6.691, 39.494)), module, TAudio::VU_LIGHTS + 6 * 0 + 2));

  587. 			addChild(createLightCentered<SmallSimpleLight<GreenLight>>(mm2px(Vec(18.709, 39.494)), module, TAudio::VU_LIGHTS + 6 * 1 + 2));

  588. 			addChild(createLightCentered<SmallSimpleLight<GreenLight>>(mm2px(Vec(6.691, 44.791)), module, TAudio::VU_LIGHTS + 6 * 0 + 3));

  589. 			addChild(createLightCentered<SmallSimpleLight<GreenLight>>(mm2px(Vec(18.709, 44.791)), module, TAudio::VU_LIGHTS + 6 * 1 + 3));

  590. 			addChild(createLightCentered<SmallSimpleLight<GreenLight>>(mm2px(Vec(6.691, 50.089)), module, TAudio::VU_LIGHTS + 6 * 0 + 4));

  591. 			addChild(createLightCentered<SmallSimpleLight<GreenLight>>(mm2px(Vec(18.709, 50.089)), module, TAudio::VU_LIGHTS + 6 * 1 + 4));

  592. 			addChild(createLightCentered<SmallSimpleLight<GreenLight>>(mm2px(Vec(6.691, 55.386)), module, TAudio::VU_LIGHTS + 6 * 0 + 5));

  593. 			addChild(createLightCentered<SmallSimpleLight<GreenLight>>(mm2px(Vec(18.709, 55.386)), module, TAudio::VU_LIGHTS + 6 * 1 + 5));

  594. 

  595. 			// AudioButton example

  596. 			// AudioButton* audioButton_ADAT = createWidget<AudioButton_ADAT>(Vec(0, 0));

  597. 			// audioButton_ADAT->setAudioPort(module ? &module->port : NULL);

  598. 			// addChild(audioButton_ADAT);

  599. 

  600. 			// AudioButton* audioButton_USB_B = createWidget<AudioButton_USB_B>(Vec(0, 40));

  601. 			// audioButton_USB_B->setAudioPort(module ? &module->port : NULL);

  602. 			// addChild(audioButton_USB_B);

  603. 		}

  604. 	}

  605. 

  606. 	void appendContextMenu(Menu* menu) override {

  607. 		TAudio* module = dynamic_cast<TAudio*>(this->module);

  608. 

  609. 		menu->addChild(new MenuSeparator);

  610. 

  611. 		menu->addChild(createBoolMenuItem("Master audio module", "",

  612. 			[=]() {return module->port.isMaster();},

  613. 			[=](bool master) {module->port.setMaster(master);}

  614. 		));

  615. 

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

  617. 	}

  618. };

  619. 

  620. 

  621. Model* modelAudio2 = createModel<Audio<2, 2>, AudioWidget<2, 2>>("AudioInterface2");

  622. Model* modelAudio8 = createModel<Audio<8, 8>, AudioWidget<8, 8>>("AudioInterface");

  623. Model* modelAudio16 = createModel<Audio<16, 16>, AudioWidget<16, 16>>("AudioInterface16");

  624. 

  625. 

  626. } // namespace core

  627. } // namespace rack