VCVRack
/
AudibleInstruments
mirror of https://github.com/VCVRack/AudibleInstruments.git
1
0
Fork 0
Code Issues 0 Releases 8 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.
224 Commits
4 Branches
59MB
Tree: 41c7e2a563
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '41c7e2a563'
${ noResults }
AudibleInstruments/src/Clouds.cpp

414 lines
14KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. #include "clouds/dsp/granular_processor.h"

  3. 

  4. 

  5. struct Clouds : Module {

  6. 	enum ParamIds {

  7. 		FREEZE_PARAM,

  8. 		MODE_PARAM,

  9. 		LOAD_PARAM,

  10. 		POSITION_PARAM,

  11. 		SIZE_PARAM,

  12. 		PITCH_PARAM,

  13. 		IN_GAIN_PARAM,

  14. 		DENSITY_PARAM,

  15. 		TEXTURE_PARAM,

  16. 		BLEND_PARAM,

  17. 		SPREAD_PARAM,

  18. 		FEEDBACK_PARAM,

  19. 		REVERB_PARAM,

  20. 		NUM_PARAMS

  21. 	};

  22. 	enum InputIds {

  23. 		FREEZE_INPUT,

  24. 		TRIG_INPUT,

  25. 		POSITION_INPUT,

  26. 		SIZE_INPUT,

  27. 		PITCH_INPUT,

  28. 		BLEND_INPUT,

  29. 		IN_L_INPUT,

  30. 		IN_R_INPUT,

  31. 		DENSITY_INPUT,

  32. 		TEXTURE_INPUT,

  33. 		NUM_INPUTS

  34. 	};

  35. 	enum OutputIds {

  36. 		OUT_L_OUTPUT,

  37. 		OUT_R_OUTPUT,

  38. 		NUM_OUTPUTS

  39. 	};

  40. 	enum LightIds {

  41. 		FREEZE_LIGHT,

  42. 		MIX_GREEN_LIGHT, MIX_RED_LIGHT,

  43. 		PAN_GREEN_LIGHT, PAN_RED_LIGHT,

  44. 		FEEDBACK_GREEN_LIGHT, FEEDBACK_RED_LIGHT,

  45. 		REVERB_GREEN_LIGHT, REVERB_RED_LIGHT,

  46. 		NUM_LIGHTS

  47. 	};

  48. 

  49. 	dsp::SampleRateConverter<2> inputSrc;

  50. 	dsp::SampleRateConverter<2> outputSrc;

  51. 	dsp::DoubleRingBuffer<dsp::Frame<2>, 256> inputBuffer;

  52. 	dsp::DoubleRingBuffer<dsp::Frame<2>, 256> outputBuffer;

  53. 

  54. 	uint8_t* block_mem;

  55. 	uint8_t* block_ccm;

  56. 	clouds::GranularProcessor* processor;

  57. 

  58. 	bool triggered = false;

  59. 

  60. 	dsp::SchmittTrigger freezeTrigger;

  61. 	bool freeze = false;

  62. 	dsp::SchmittTrigger blendTrigger;

  63. 	int blendMode = 0;

  64. 

  65. 	clouds::PlaybackMode playback;

  66. 	int quality = 0;

  67. 

  68. 	Clouds() {

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

  70. 		configParam(POSITION_PARAM, 0.0, 1.0, 0.5, "Grain position");

  71. 		configParam(SIZE_PARAM, 0.0, 1.0, 0.5, "Grain size");

  72. 		configParam(PITCH_PARAM, -2.0, 2.0, 0.0, "Grain pitch");

  73. 		configParam(IN_GAIN_PARAM, 0.0, 1.0, 0.5, "Audio input gain");

  74. 		configParam(DENSITY_PARAM, 0.0, 1.0, 0.5, "Grain density");

  75. 		configParam(TEXTURE_PARAM, 0.0, 1.0, 0.5, "Grain texture");

  76. 		configParam(BLEND_PARAM, 0.0, 1.0, 0.5, "Dry/wet");

  77. 		configParam(SPREAD_PARAM, 0.0, 1.0, 0.0, "Stereo spread");

  78. 		configParam(FEEDBACK_PARAM, 0.0, 1.0, 0.0, "Feedback amount");

  79. 		configParam(REVERB_PARAM, 0.0, 1.0, 0.0, "Reverb amount");

  80. 		configButton(FREEZE_PARAM, "Freeze");

  81. 		configButton(MODE_PARAM, "Mode");

  82. 		configButton(LOAD_PARAM, "Load/save");

  83. 		configInput(FREEZE_INPUT, "Freeze");

  84. 		configInput(TRIG_INPUT, "Trigger");

  85. 		configInput(POSITION_INPUT, "Position");

  86. 		configInput(SIZE_INPUT, "Size");

  87. 		configInput(PITCH_INPUT, "Pitch (1V/oct)");

  88. 		configInput(BLEND_INPUT, "Blend");

  89. 		configInput(IN_L_INPUT, "Left");

  90. 		configInput(IN_R_INPUT, "Right");

  91. 		configInput(DENSITY_INPUT, "Density");

  92. 		configInput(TEXTURE_INPUT, "Texture");

  93. 		configOutput(OUT_L_OUTPUT, "Left");

  94. 		configOutput(OUT_R_OUTPUT, "Right");

  95. 

  96. 		configBypass(IN_L_INPUT, OUT_L_OUTPUT);

  97. 		configBypass(IN_R_INPUT, OUT_R_OUTPUT);

  98. 

  99. 		const int memLen = 118784;

  100. 		const int ccmLen = 65536 - 128;

  101. 		block_mem = new uint8_t[memLen]();

  102. 		block_ccm = new uint8_t[ccmLen]();

  103. 		processor = new clouds::GranularProcessor();

  104. 		memset(processor, 0, sizeof(*processor));

  105. 

  106. 		processor->Init(block_mem, memLen, block_ccm, ccmLen);

  107. 		onReset();

  108. 	}

  109. 

  110. 	~Clouds() {

  111. 		delete processor;

  112. 		delete[] block_mem;

  113. 		delete[] block_ccm;

  114. 	}

  115. 

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

  117. 		// Get input

  118. 		dsp::Frame<2> inputFrame = {};

  119. 		if (!inputBuffer.full()) {

  120. 			inputFrame.samples[0] = inputs[IN_L_INPUT].getVoltage() * params[IN_GAIN_PARAM].getValue() / 5.0;

  121. 			inputFrame.samples[1] = inputs[IN_R_INPUT].isConnected() ? inputs[IN_R_INPUT].getVoltage() * params[IN_GAIN_PARAM].getValue() / 5.0 : inputFrame.samples[0];

  122. 			inputBuffer.push(inputFrame);

  123. 		}

  124. 

  125. 		if (freezeTrigger.process(params[FREEZE_PARAM].getValue())) {

  126. 			freeze ^= true;

  127. 		}

  128. 		if (blendTrigger.process(params[MODE_PARAM].getValue())) {

  129. 			blendMode = (blendMode + 1) % 4;

  130. 		}

  131. 

  132. 		// Trigger

  133. 		if (inputs[TRIG_INPUT].getVoltage() >= 1.0) {

  134. 			triggered = true;

  135. 		}

  136. 

  137. 		// Render frames

  138. 		if (outputBuffer.empty()) {

  139. 			clouds::ShortFrame input[32] = {};

  140. 			// Convert input buffer

  141. 			{

  142. 				inputSrc.setRates(args.sampleRate, 32000);

  143. 				dsp::Frame<2> inputFrames[32];

  144. 				int inLen = inputBuffer.size();

  145. 				int outLen = 32;

  146. 				inputSrc.process(inputBuffer.startData(), &inLen, inputFrames, &outLen);

  147. 				inputBuffer.startIncr(inLen);

  148. 

  149. 				// We might not fill all of the input buffer if there is a deficiency, but this cannot be avoided due to imprecisions between the input and output SRC.

  150. 				for (int i = 0; i < outLen; i++) {

  151. 					input[i].l = clamp(inputFrames[i].samples[0] * 32767.0f, -32768.0f, 32767.0f);

  152. 					input[i].r = clamp(inputFrames[i].samples[1] * 32767.0f, -32768.0f, 32767.0f);

  153. 				}

  154. 			}

  155. 

  156. 			// Set up processor

  157. 			processor->set_playback_mode(playback);

  158. 			processor->set_quality(quality);

  159. 			processor->Prepare();

  160. 

  161. 			clouds::Parameters* p = processor->mutable_parameters();

  162. 			p->trigger = triggered;

  163. 			p->gate = triggered;

  164. 			p->freeze = freeze || (inputs[FREEZE_INPUT].getVoltage() >= 1.0);

  165. 			p->position = clamp(params[POSITION_PARAM].getValue() + inputs[POSITION_INPUT].getVoltage() / 5.0f, 0.0f, 1.0f);

  166. 			p->size = clamp(params[SIZE_PARAM].getValue() + inputs[SIZE_INPUT].getVoltage() / 5.0f, 0.0f, 1.0f);

  167. 			p->pitch = clamp((params[PITCH_PARAM].getValue() + inputs[PITCH_INPUT].getVoltage()) * 12.0f, -48.0f, 48.0f);

  168. 			p->density = clamp(params[DENSITY_PARAM].getValue() + inputs[DENSITY_INPUT].getVoltage() / 5.0f, 0.0f, 1.0f);

  169. 			p->texture = clamp(params[TEXTURE_PARAM].getValue() + inputs[TEXTURE_INPUT].getVoltage() / 5.0f, 0.0f, 1.0f);

  170. 			p->dry_wet = params[BLEND_PARAM].getValue();

  171. 			p->stereo_spread = params[SPREAD_PARAM].getValue();

  172. 			p->feedback = params[FEEDBACK_PARAM].getValue();

  173. 			// TODO

  174. 			// Why doesn't dry audio get reverbed?

  175. 			p->reverb = params[REVERB_PARAM].getValue();

  176. 			float blend = inputs[BLEND_INPUT].getVoltage() / 5.0f;

  177. 			switch (blendMode) {

  178. 				case 0:

  179. 					p->dry_wet += blend;

  180. 					p->dry_wet = clamp(p->dry_wet, 0.0f, 1.0f);

  181. 					break;

  182. 				case 1:

  183. 					p->stereo_spread += blend;

  184. 					p->stereo_spread = clamp(p->stereo_spread, 0.0f, 1.0f);

  185. 					break;

  186. 				case 2:

  187. 					p->feedback += blend;

  188. 					p->feedback = clamp(p->feedback, 0.0f, 1.0f);

  189. 					break;

  190. 				case 3:

  191. 					p->reverb += blend;

  192. 					p->reverb = clamp(p->reverb, 0.0f, 1.0f);

  193. 					break;

  194. 			}

  195. 

  196. 			clouds::ShortFrame output[32];

  197. 			processor->Process(input, output, 32);

  198. 

  199. 			// Convert output buffer

  200. 			{

  201. 				dsp::Frame<2> outputFrames[32];

  202. 				for (int i = 0; i < 32; i++) {

  203. 					outputFrames[i].samples[0] = output[i].l / 32768.0;

  204. 					outputFrames[i].samples[1] = output[i].r / 32768.0;

  205. 				}

  206. 

  207. 				outputSrc.setRates(32000, args.sampleRate);

  208. 				int inLen = 32;

  209. 				int outLen = outputBuffer.capacity();

  210. 				outputSrc.process(outputFrames, &inLen, outputBuffer.endData(), &outLen);

  211. 				outputBuffer.endIncr(outLen);

  212. 			}

  213. 

  214. 			triggered = false;

  215. 		}

  216. 

  217. 		// Set output

  218. 		dsp::Frame<2> outputFrame = {};

  219. 		if (!outputBuffer.empty()) {

  220. 			outputFrame = outputBuffer.shift();

  221. 			outputs[OUT_L_OUTPUT].setVoltage(5.0 * outputFrame.samples[0]);

  222. 			outputs[OUT_R_OUTPUT].setVoltage(5.0 * outputFrame.samples[1]);

  223. 		}

  224. 

  225. 		// Lights

  226. 		clouds::Parameters* p = processor->mutable_parameters();

  227. 		dsp::VuMeter vuMeter;

  228. 		vuMeter.dBInterval = 6.0;

  229. 		dsp::Frame<2> lightFrame = p->freeze ? outputFrame : inputFrame;

  230. 		vuMeter.setValue(fmaxf(fabsf(lightFrame.samples[0]), fabsf(lightFrame.samples[1])));

  231. 		lights[FREEZE_LIGHT].setBrightness(p->freeze ? 0.75 : 0.0);

  232. 		lights[MIX_GREEN_LIGHT].setSmoothBrightness(vuMeter.getBrightness(3), args.sampleTime);

  233. 		lights[PAN_GREEN_LIGHT].setSmoothBrightness(vuMeter.getBrightness(2), args.sampleTime);

  234. 		lights[FEEDBACK_GREEN_LIGHT].setSmoothBrightness(vuMeter.getBrightness(1), args.sampleTime);

  235. 		lights[REVERB_GREEN_LIGHT].setBrightness(0.0);

  236. 		lights[MIX_RED_LIGHT].setBrightness(0.0);

  237. 		lights[PAN_RED_LIGHT].setBrightness(0.0);

  238. 		lights[FEEDBACK_RED_LIGHT].setSmoothBrightness(vuMeter.getBrightness(1), args.sampleTime);

  239. 		lights[REVERB_RED_LIGHT].setSmoothBrightness(vuMeter.getBrightness(0), args.sampleTime);

  240. 	}

  241. 

  242. 	void onReset() override {

  243. 		freeze = false;

  244. 		blendMode = 0;

  245. 		playback = clouds::PLAYBACK_MODE_GRANULAR;

  246. 		quality = 0;

  247. 	}

  248. 

  249. 	json_t* dataToJson() override {

  250. 		json_t* rootJ = json_object();

  251. 

  252. 		json_object_set_new(rootJ, "playback", json_integer((int) playback));

  253. 		json_object_set_new(rootJ, "quality", json_integer(quality));

  254. 		json_object_set_new(rootJ, "blendMode", json_integer(blendMode));

  255. 

  256. 		return rootJ;

  257. 	}

  258. 

  259. 	void dataFromJson(json_t* rootJ) override {

  260. 		json_t* playbackJ = json_object_get(rootJ, "playback");

  261. 		if (playbackJ) {

  262. 			playback = (clouds::PlaybackMode) json_integer_value(playbackJ);

  263. 		}

  264. 

  265. 		json_t* qualityJ = json_object_get(rootJ, "quality");

  266. 		if (qualityJ) {

  267. 			quality = json_integer_value(qualityJ);

  268. 		}

  269. 

  270. 		json_t* blendModeJ = json_object_get(rootJ, "blendMode");

  271. 		if (blendModeJ) {

  272. 			blendMode = json_integer_value(blendModeJ);

  273. 		}

  274. 	}

  275. };

  276. 

  277. 

  278. struct FreezeLight : YellowLight {

  279. 	FreezeLight() {

  280. 		box.size = Vec(28 - 6, 28 - 6);

  281. 		bgColor = color::BLACK_TRANSPARENT;

  282. 	}

  283. };

  284. 

  285. 

  286. struct CloudsWidget : ModuleWidget {

  287. 	ParamWidget* blendParam;

  288. 	ParamWidget* spreadParam;

  289. 	ParamWidget* feedbackParam;

  290. 	ParamWidget* reverbParam;

  291. 

  292. 	CloudsWidget(Clouds* module) {

  293. 		setModule(module);

  294. 		setPanel(Svg::load(asset::plugin(pluginInstance, "res/Clouds.svg")));

  295. 

  296. 		addChild(createWidget<ScrewSilver>(Vec(15, 0)));

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

  298. 		addChild(createWidget<ScrewSilver>(Vec(15, 365)));

  299. 		addChild(createWidget<ScrewSilver>(Vec(240, 365)));

  300. 

  301. 		addParam(createParam<Rogan3PSRed>(Vec(27, 93), module, Clouds::POSITION_PARAM));

  302. 		addParam(createParam<Rogan3PSGreen>(Vec(108, 93), module, Clouds::SIZE_PARAM));

  303. 		addParam(createParam<Rogan3PSWhite>(Vec(190, 93), module, Clouds::PITCH_PARAM));

  304. 

  305. 		addParam(createParam<Rogan1PSRed>(Vec(14, 180), module, Clouds::IN_GAIN_PARAM));

  306. 		addParam(createParam<Rogan1PSRed>(Vec(81, 180), module, Clouds::DENSITY_PARAM));

  307. 		addParam(createParam<Rogan1PSGreen>(Vec(146, 180), module, Clouds::TEXTURE_PARAM));

  308. 		blendParam = createParam<Rogan1PSWhite>(Vec(213, 180), module, Clouds::BLEND_PARAM);

  309. 		addParam(blendParam);

  310. 		spreadParam = createParam<Rogan1PSRed>(Vec(213, 180), module, Clouds::SPREAD_PARAM);

  311. 		spreadParam->hide();

  312. 		addParam(spreadParam);

  313. 		feedbackParam = createParam<Rogan1PSGreen>(Vec(213, 180), module, Clouds::FEEDBACK_PARAM);

  314. 		feedbackParam->hide();

  315. 		addParam(feedbackParam);

  316. 		reverbParam = createParam<Rogan1PSBlue>(Vec(213, 180), module, Clouds::REVERB_PARAM);

  317. 		reverbParam->hide();

  318. 		addParam(reverbParam);

  319. 

  320. 		addParam(createParam<CKD6>(Vec(12, 43), module, Clouds::FREEZE_PARAM));

  321. 		addParam(createParam<TL1105>(Vec(211, 50), module, Clouds::MODE_PARAM));

  322. 		addParam(createParam<TL1105>(Vec(239, 50), module, Clouds::LOAD_PARAM));

  323. 

  324. 		addInput(createInput<PJ301MPort>(Vec(15, 274), module, Clouds::FREEZE_INPUT));

  325. 		addInput(createInput<PJ301MPort>(Vec(58, 274), module, Clouds::TRIG_INPUT));

  326. 		addInput(createInput<PJ301MPort>(Vec(101, 274), module, Clouds::POSITION_INPUT));

  327. 		addInput(createInput<PJ301MPort>(Vec(144, 274), module, Clouds::SIZE_INPUT));

  328. 		addInput(createInput<PJ301MPort>(Vec(188, 274), module, Clouds::PITCH_INPUT));

  329. 		addInput(createInput<PJ301MPort>(Vec(230, 274), module, Clouds::BLEND_INPUT));

  330. 

  331. 		addInput(createInput<PJ301MPort>(Vec(15, 317), module, Clouds::IN_L_INPUT));

  332. 		addInput(createInput<PJ301MPort>(Vec(58, 317), module, Clouds::IN_R_INPUT));

  333. 		addInput(createInput<PJ301MPort>(Vec(101, 317), module, Clouds::DENSITY_INPUT));

  334. 		addInput(createInput<PJ301MPort>(Vec(144, 317), module, Clouds::TEXTURE_INPUT));

  335. 		addOutput(createOutput<PJ301MPort>(Vec(188, 317), module, Clouds::OUT_L_OUTPUT));

  336. 		addOutput(createOutput<PJ301MPort>(Vec(230, 317), module, Clouds::OUT_R_OUTPUT));

  337. 

  338. 		addChild(createLight<FreezeLight>(Vec(12 + 3, 43 + 3), module, Clouds::FREEZE_LIGHT));

  339. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(82.5, 53), module, Clouds::MIX_GREEN_LIGHT));

  340. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(114.5, 53), module, Clouds::PAN_GREEN_LIGHT));

  341. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(145.5, 53), module, Clouds::FEEDBACK_GREEN_LIGHT));

  342. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(177.5, 53), module, Clouds::REVERB_GREEN_LIGHT));

  343. 	}

  344. 

  345. 	void step() override {

  346. 		Clouds* module = dynamic_cast<Clouds*>(this->module);

  347. 

  348. 		if (module) {

  349. 			blendParam->visible = (module->blendMode == 0);

  350. 			spreadParam->visible = (module->blendMode == 1);

  351. 			feedbackParam->visible = (module->blendMode == 2);

  352. 			reverbParam->visible = (module->blendMode == 3);

  353. 		}

  354. 

  355. 		ModuleWidget::step();

  356. 	}

  357. 

  358. 	void appendContextMenu(Menu* menu) override {

  359. 		Clouds* module = dynamic_cast<Clouds*>(this->module);

  360. 		assert(module);

  361. 

  362. 		menu->addChild(new MenuSeparator);

  363. 		menu->addChild(createMenuLabel("Blend knob"));

  364. 

  365. 		static const std::vector<std::string> blendLabels = {

  366. 			"Wet/dry",

  367. 			"Spread",

  368. 			"Feedback",

  369. 			"Reverb",

  370. 		};

  371. 		for (int i = 0; i < (int) blendLabels.size(); i++) {

  372. 			menu->addChild(createCheckMenuItem(blendLabels[i], "",

  373. 				[=]() {return module->blendMode == i;},

  374. 				[=]() {module->blendMode = i;}

  375. 			));

  376. 		}

  377. 

  378. 		menu->addChild(new MenuSeparator);

  379. 		menu->addChild(createMenuLabel("Alternate mode"));

  380. 

  381. 		static const std::vector<std::string> playbackLabels = {

  382. 			"Granular",

  383. 			"Pitch-shifter/time-stretcher",

  384. 			"Looping delay",

  385. 			"Spectral madness",

  386. 		};

  387. 		for (int i = 0; i < (int) playbackLabels.size(); i++) {

  388. 			menu->addChild(createCheckMenuItem(playbackLabels[i], "",

  389. 				[=]() {return module->playback == i;},

  390. 				[=]() {module->playback = (clouds::PlaybackMode) i;}

  391. 			));

  392. 		}

  393. 

  394. 		menu->addChild(new MenuSeparator);

  395. 		menu->addChild(createMenuLabel("Quality"));

  396. 

  397. 		static const std::vector<std::string> qualityLabels = {

  398. 			"1s 32kHz 16-bit stereo",

  399. 			"2s 32kHz 16-bit mono",

  400. 			"4s 16kHz 8-bit µ-law stereo",

  401. 			"8s 16kHz 8-bit µ-law mono",

  402. 		};

  403. 		for (int i = 0; i < (int) qualityLabels.size(); i++) {

  404. 			menu->addChild(createCheckMenuItem(qualityLabels[i], "",

  405. 				[=]() {return module->quality == i;},

  406. 				[=]() {module->quality = i;}

  407. 			));

  408. 		}

  409. 	}

  410. };

  411. 

  412. 

  413. Model* modelClouds = createModel<Clouds, CloudsWidget>("Clouds");