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

635 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. 			// Convert audio input -> engine output

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

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

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

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

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

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

  99. 				}

  100. 			}

  101. 			int audioInputFrames = frames;

  102. 			int outputFrames = engineOutputBuffer.capacity();

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

  104. 			engineOutputBuffer.endIncr(outputFrames);

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

  106. 			requestedEngineFrames = engineOutputBuffer.size();

  107. 		}

  108. 		else {

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

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

  111. 		}

  112. 	}

  113. 

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

  115. 		// Step engine

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

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

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

  119. 		}

  120. 	}

  121. 

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

  123. 		// bool isMasterCached = isMaster();

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

  125. 		float sampleRateRatio = engineSampleRate / deviceSampleRate;

  126. 

  127. 		if (deviceNumOutputs > 0) {

  128. 			// Set up sample rate converter

  129. 			inputSrc.setRates(engineSampleRate, deviceSampleRate);

  130. 			inputSrc.setChannels(deviceNumOutputs);

  131. 			// Convert engine input -> audio output

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

  133. 			int inputFrames = engineInputBuffer.size();

  134. 			int audioOutputFrames = frames;

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

  136. 			engineInputBuffer.startIncr(inputFrames);

  137. 			// Copy the audio output buffer

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

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

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

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

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

  143. 				}

  144. 			}

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

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

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

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

  149. 				}

  150. 			}

  151. 		}

  152. 

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

  154. 

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

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

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

  158. 			engineInputBuffer.clear();

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

  160. 		}

  161. 

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

  163. 	}

  164. 

  165. 	void onStartStream() override {

  166. 		engineInputBuffer.clear();

  167. 		engineOutputBuffer.clear();

  168. 		// DEBUG("onStartStream");

  169. 	}

  170. 

  171. 	void onStopStream() override {

  172. 		deviceNumInputs = 0;

  173. 		deviceNumOutputs = 0;

  174. 		deviceSampleRate = 0.f;

  175. 		engineInputBuffer.clear();

  176. 		engineOutputBuffer.clear();

  177. 		setMaster(false);

  178. 		// DEBUG("onStopStream");

  179. 	}

  180. };

  181. 

  182. 

  183. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  184. struct Audio : Module {

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

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

  187. 

  188. 	enum ParamIds {

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

  190. 		NUM_PARAMS

  191. 	};

  192. 	enum InputIds {

  193. 		ENUMS(AUDIO_INPUTS, NUM_AUDIO_INPUTS),

  194. 		NUM_INPUTS

  195. 	};

  196. 	enum OutputIds {

  197. 		ENUMS(AUDIO_OUTPUTS, NUM_AUDIO_OUTPUTS),

  198. 		NUM_OUTPUTS

  199. 	};

  200. 	enum LightIds {

  201. 		ENUMS(INPUT_LIGHTS, NUM_INPUT_LIGHTS * 2),

  202. 		ENUMS(OUTPUT_LIGHTS, NUM_OUTPUT_LIGHTS * 2),

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

  204. 		NUM_LIGHTS

  205. 	};

  206. 

  207. 	AudioPort<NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS> port;

  208. 

  209. 	dsp::RCFilter dcFilters[NUM_AUDIO_INPUTS];

  210. 	bool dcFilterEnabled = false;

  211. 

  212. 	dsp::ClockDivider lightDivider;

  213. 	// For each pair of inputs/outputs

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

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

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

  217. 

  218. 	Audio() : port(this) {

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

  220. 		if (NUM_AUDIO_INPUTS == 2)

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

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

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

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

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

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

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

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

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

  230. 

  231. 		lightDivider.setDivision(512);

  232. 

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

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

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

  236. 		}

  237. 

  238. 		onReset();

  239. 	}

  240. 

  241. 	~Audio() {

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

  243. 		port.setDriverId(-1);

  244. 	}

  245. 

  246. 	void onReset() override {

  247. 		port.setDriverId(-1);

  248. 

  249. 		if (NUM_AUDIO_INPUTS == 2)

  250. 			dcFilterEnabled = true;

  251. 		else

  252. 			dcFilterEnabled = false;

  253. 	}

  254. 

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

  256. 		port.engineInputBuffer.clear();

  257. 		port.engineOutputBuffer.clear();

  258. 

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

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

  261. 		}

  262. 	}

  263. 

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

  265. 		const float clipTime = 0.25f;

  266. 

  267. 		// Push inputs to buffer

  268. 		if (port.deviceNumOutputs > 0) {

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

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

  271. 				// Get input

  272. 				float v = 0.f;

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

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

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

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

  277. 					v = inputFrame.samples[0];

  278. 

  279. 				// Apply DC filter

  280. 				if (dcFilterEnabled) {

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

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

  283. 				}

  284. 

  285. 				// Detect clipping

  286. 				if (NUM_AUDIO_INPUTS > 2) {

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

  288. 						inputClipTimers[i / 2] = clipTime;

  289. 				}

  290. 				inputFrame.samples[i] = v;

  291. 			}

  292. 

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

  294. 			if (NUM_AUDIO_INPUTS == 2) {

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

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

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

  298. 				}

  299. 			}

  300. 

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

  302. 				port.engineInputBuffer.push(inputFrame);

  303. 			}

  304. 

  305. 			// Audio-2: VU meter process

  306. 			if (NUM_AUDIO_INPUTS == 2) {

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

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

  309. 				}

  310. 			}

  311. 		}

  312. 		else {

  313. 			// Audio-2: Clear VU meter

  314. 			if (NUM_AUDIO_INPUTS == 2) {

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

  316. 					vuMeter[i].reset();

  317. 				}

  318. 			}

  319. 		}

  320. 

  321. 		// Pull outputs from buffer

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

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

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

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

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

  327. 

  328. 				// Detect clipping

  329. 				if (NUM_AUDIO_OUTPUTS > 2) {

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

  331. 						outputClipTimers[i / 2] = clipTime;

  332. 				}

  333. 			}

  334. 		}

  335. 		else {

  336. 			// Zero outputs

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

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

  339. 			}

  340. 		}

  341. 

  342. 		// Lights

  343. 		if (lightDivider.process()) {

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

  345. 			// Audio-2: VU meter

  346. 			if (NUM_AUDIO_INPUTS == 2) {

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

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

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

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

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

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

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

  354. 				}

  355. 			}

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

  357. 			else {

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

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

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

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

  362. 					if (clip)

  363. 						inputClipTimers[i] -= lightTime;

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

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

  366. 				}

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

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

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

  370. 					if (clip)

  371. 						outputClipTimers[i] -= lightTime;

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

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

  374. 				}

  375. 			}

  376. 		}

  377. 	}

  378. 

  379. 	json_t* dataToJson() override {

  380. 		json_t* rootJ = json_object();

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

  382. 

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

  384. 

  385. 		return rootJ;

  386. 	}

  387. 

  388. 	void dataFromJson(json_t* rootJ) override {

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

  390. 		if (audioJ)

  391. 			port.fromJson(audioJ);

  392. 

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

  394. 		if (dcFilterJ)

  395. 			dcFilterEnabled = json_boolean_value(dcFilterJ);

  396. 	}

  397. };

  398. 

  399. 

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

  401. struct Audio2Display : LedDisplay {

  402. 	AudioDeviceMenuChoice* deviceChoice;

  403. 	LedDisplaySeparator* deviceSeparator;

  404. 

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

  406. 		math::Vec pos;

  407. 

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

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

  410. 		deviceChoice->port = port;

  411. 		addChild(deviceChoice);

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

  413. 

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

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

  416. 		addChild(deviceSeparator);

  417. 	}

  418. 

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

  420. 		if (layer == 1) {

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

  422. 				mm2px(28.899 - 13.039),

  423. 				mm2px(34.196 - 13.039),

  424. 				mm2px(39.494 - 13.039),

  425. 				mm2px(44.791 - 13.039),

  426. 				mm2px(50.089 - 13.039),

  427. 				mm2px(55.386 - 13.039),

  428. 			};

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

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

  431. 			};

  432. 

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

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

  435. 			if (!font)

  436. 				return;

  437. 

  438. 			nvgSave(args.vg);

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

  440. 			nvgFontSize(args.vg, 11);

  441. 			nvgTextLetterSpacing(args.vg, 0.0);

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

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

  444. 

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

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

  447. 			}

  448. 			nvgRestore(args.vg);

  449. 		}

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

  451. 	}

  452. };

  453. 

  454. 

  455. template <int NUM_AUDIO_INPUTS, int NUM_AUDIO_OUTPUTS>

  456. struct AudioWidget : ModuleWidget {

  457. 	typedef Audio<NUM_AUDIO_INPUTS, NUM_AUDIO_OUTPUTS> TAudio;

  458. 

  459. 	AudioWidget(TAudio* module) {

  460. 		setModule(module);

  461. 

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

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

  464. 

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

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

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

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

  469. 

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

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

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

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

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

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

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

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

  478. 

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

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

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

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

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

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

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

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

  487. 

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

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

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

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

  492. 

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

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

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

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

  497. 

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

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

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

  501. 			addChild(display);

  502. 		}

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

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

  505. 

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

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

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

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

  510. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  527. 

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

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

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

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

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

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

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

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

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

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

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

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

  540. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(65.565, 112.962)), module, TAudio::AUDIO_OUTPUTS + 12));

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

  542. 			addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(88.664, 112.962)), module, TAudio::AUDIO_OUTPUTS + 14));

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

  544. 

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

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

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

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

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

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

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

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

  553. 

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

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

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

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

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

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

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

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

  562. 

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

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

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

  566. 			addChild(display);

  567. 		}

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

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

  570. 

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

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

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

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

  575. 

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

  577. 

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

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

  580. 

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

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

  583. 

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

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

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

  587. 			addChild(display);

  588. 

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

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

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

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

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

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

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

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

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

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

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

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

  601. 

  602. 			// AudioButton example

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

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

  605. 			// addChild(audioButton_ADAT);

  606. 

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

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

  609. 			// addChild(audioButton_USB_B);

  610. 		}

  611. 	}

  612. 

  613. 	void appendContextMenu(Menu* menu) override {

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

  615. 

  616. 		menu->addChild(new MenuSeparator);

  617. 

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

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

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

  621. 		));

  622. 

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

  624. 	}

  625. };

  626. 

  627. 

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

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

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

  631. 

  632. 

  633. } // namespace core

  634. } // namespace rack