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.
208 Commits
4 Branches
8.5MB
Tree: 5ef75736f8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5ef75736f8'
${ noResults }
AudibleInstruments/src/Clouds.cpp

399 lines
13KB
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. 		configParam(FREEZE_PARAM, 0.0, 1.0, 0.0, "Freeze");

  81. 		configParam(MODE_PARAM, 0.0, 1.0, 0.0, "Mode");

  82. 		configParam(LOAD_PARAM, 0.0, 1.0, 0.0, "Load/save");

  83. 

  84. 		const int memLen = 118784;

  85. 		const int ccmLen = 65536 - 128;

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

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

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

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

  90. 

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

  92. 		onReset();

  93. 	}

  94. 

  95. 	~Clouds() {

  96. 		delete processor;

  97. 		delete[] block_mem;

  98. 		delete[] block_ccm;

  99. 	}

  100. 

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

  102. 		// Get input

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

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

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

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

  107. 			inputBuffer.push(inputFrame);

  108. 		}

  109. 

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

  111. 			freeze ^= true;

  112. 		}

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

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

  115. 		}

  116. 

  117. 		// Trigger

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

  119. 			triggered = true;

  120. 		}

  121. 

  122. 		// Render frames

  123. 		if (outputBuffer.empty()) {

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

  125. 			// Convert input buffer

  126. 			{

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

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

  129. 				int inLen = inputBuffer.size();

  130. 				int outLen = 32;

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

  132. 				inputBuffer.startIncr(inLen);

  133. 

  134. 				// 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.

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

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

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

  138. 				}

  139. 			}

  140. 

  141. 			// Set up processor

  142. 			processor->set_playback_mode(playback);

  143. 			processor->set_quality(quality);

  144. 			processor->Prepare();

  145. 

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

  147. 			p->trigger = triggered;

  148. 			p->gate = triggered;

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

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

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

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

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

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

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

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

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

  158. 			// TODO

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

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

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

  162. 			switch (blendMode) {

  163. 				case 0:

  164. 					p->dry_wet += blend;

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

  166. 					break;

  167. 				case 1:

  168. 					p->stereo_spread += blend;

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

  170. 					break;

  171. 				case 2:

  172. 					p->feedback += blend;

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

  174. 					break;

  175. 				case 3:

  176. 					p->reverb += blend;

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

  178. 					break;

  179. 			}

  180. 

  181. 			clouds::ShortFrame output[32];

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

  183. 

  184. 			// Convert output buffer

  185. 			{

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

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

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

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

  190. 				}

  191. 

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

  193. 				int inLen = 32;

  194. 				int outLen = outputBuffer.capacity();

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

  196. 				outputBuffer.endIncr(outLen);

  197. 			}

  198. 

  199. 			triggered = false;

  200. 		}

  201. 

  202. 		// Set output

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

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

  205. 			outputFrame = outputBuffer.shift();

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

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

  208. 		}

  209. 

  210. 		// Lights

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

  212. 		dsp::VuMeter vuMeter;

  213. 		vuMeter.dBInterval = 6.0;

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

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

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

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

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

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

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

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

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

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

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

  225. 	}

  226. 

  227. 	void onReset() override {

  228. 		freeze = false;

  229. 		blendMode = 0;

  230. 		playback = clouds::PLAYBACK_MODE_GRANULAR;

  231. 		quality = 0;

  232. 	}

  233. 

  234. 	json_t* dataToJson() override {

  235. 		json_t* rootJ = json_object();

  236. 

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

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

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

  240. 

  241. 		return rootJ;

  242. 	}

  243. 

  244. 	void dataFromJson(json_t* rootJ) override {

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

  246. 		if (playbackJ) {

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

  248. 		}

  249. 

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

  251. 		if (qualityJ) {

  252. 			quality = json_integer_value(qualityJ);

  253. 		}

  254. 

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

  256. 		if (blendModeJ) {

  257. 			blendMode = json_integer_value(blendModeJ);

  258. 		}

  259. 	}

  260. };

  261. 

  262. 

  263. struct FreezeLight : YellowLight {

  264. 	FreezeLight() {

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

  266. 		bgColor = color::BLACK_TRANSPARENT;

  267. 	}

  268. };

  269. 

  270. 

  271. struct CloudsWidget : ModuleWidget {

  272. 	ParamWidget* blendParam;

  273. 	ParamWidget* spreadParam;

  274. 	ParamWidget* feedbackParam;

  275. 	ParamWidget* reverbParam;

  276. 

  277. 	CloudsWidget(Clouds* module) {

  278. 		setModule(module);

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

  280. 

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

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

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

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

  285. 

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

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

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

  289. 

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

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

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

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

  294. 		addParam(blendParam);

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

  296. 		spreadParam->hide();

  297. 		addParam(spreadParam);

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

  299. 		feedbackParam->hide();

  300. 		addParam(feedbackParam);

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

  302. 		reverbParam->hide();

  303. 		addParam(reverbParam);

  304. 

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

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

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

  308. 

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

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

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

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

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

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

  315. 

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

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

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

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

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

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

  322. 

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

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

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

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

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

  328. 	}

  329. 

  330. 	void step() override {

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

  332. 

  333. 		if (module) {

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

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

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

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

  338. 		}

  339. 

  340. 		ModuleWidget::step();

  341. 	}

  342. 

  343. 	void appendContextMenu(Menu* menu) override {

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

  345. 		assert(module);

  346. 

  347. 		menu->addChild(new MenuSeparator);

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

  349. 

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

  351. 			"Wet/dry",

  352. 			"Spread",

  353. 			"Feedback",

  354. 			"Reverb",

  355. 		};

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

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

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

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

  360. 			));

  361. 		}

  362. 

  363. 		menu->addChild(new MenuSeparator);

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

  365. 

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

  367. 			"Granular",

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

  369. 			"Looping delay",

  370. 			"Spectral madness",

  371. 		};

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

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

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

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

  376. 			));

  377. 		}

  378. 

  379. 		menu->addChild(new MenuSeparator);

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

  381. 

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

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

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

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

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

  387. 		};

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

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

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

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

  392. 			));

  393. 		}

  394. 	}

  395. };

  396. 

  397. 

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