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.
1264 Commits
4 Branches
540MB
Tree: 2d3d5b7e6c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2d3d5b7e6c'
${ noResults }
Rack/plugins/community/repos/AudibleInstruments/src/Clouds.cpp

404 lines
14KB
Raw Blame History 

  1. #include <string.h>

  2. #include "AudibleInstruments.hpp"

  3. #include "dsp/samplerate.hpp"

  4. #include "dsp/ringbuffer.hpp"

  5. #include "dsp/digital.hpp"

  6. #include "dsp/vumeter.hpp"

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

  8. 

  9. 

  10. struct Clouds : Module {

  11. 	enum ParamIds {

  12. 		FREEZE_PARAM,

  13. 		MODE_PARAM,

  14. 		LOAD_PARAM,

  15. 		POSITION_PARAM,

  16. 		SIZE_PARAM,

  17. 		PITCH_PARAM,

  18. 		IN_GAIN_PARAM,

  19. 		DENSITY_PARAM,

  20. 		TEXTURE_PARAM,

  21. 		BLEND_PARAM,

  22. 		SPREAD_PARAM,

  23. 		FEEDBACK_PARAM,

  24. 		REVERB_PARAM,

  25. 		NUM_PARAMS

  26. 	};

  27. 	enum InputIds {

  28. 		FREEZE_INPUT,

  29. 		TRIG_INPUT,

  30. 		POSITION_INPUT,

  31. 		SIZE_INPUT,

  32. 		PITCH_INPUT,

  33. 		BLEND_INPUT,

  34. 		IN_L_INPUT,

  35. 		IN_R_INPUT,

  36. 		DENSITY_INPUT,

  37. 		TEXTURE_INPUT,

  38. 		NUM_INPUTS

  39. 	};

  40. 	enum OutputIds {

  41. 		OUT_L_OUTPUT,

  42. 		OUT_R_OUTPUT,

  43. 		NUM_OUTPUTS

  44. 	};

  45. 	enum LightIds {

  46. 		FREEZE_LIGHT,

  47. 		MIX_GREEN_LIGHT, MIX_RED_LIGHT,

  48. 		PAN_GREEN_LIGHT, PAN_RED_LIGHT,

  49. 		FEEDBACK_GREEN_LIGHT, FEEDBACK_RED_LIGHT,

  50. 		REVERB_GREEN_LIGHT, REVERB_RED_LIGHT,

  51. 		NUM_LIGHTS

  52. 	};

  53. 

  54. 	SampleRateConverter<2> inputSrc;

  55. 	SampleRateConverter<2> outputSrc;

  56. 	DoubleRingBuffer<Frame<2>, 256> inputBuffer;

  57. 	DoubleRingBuffer<Frame<2>, 256> outputBuffer;

  58. 

  59. 	uint8_t *block_mem;

  60. 	uint8_t *block_ccm;

  61. 	clouds::GranularProcessor *processor;

  62. 

  63. 	bool triggered = false;

  64. 

  65. 	SchmittTrigger freezeTrigger;

  66. 	bool freeze = false;

  67. 	SchmittTrigger blendTrigger;

  68. 	int blendMode = 0;

  69. 

  70. 	clouds::PlaybackMode playback;

  71. 	int quality = 0;

  72. 

  73. 	Clouds();

  74. 	~Clouds();

  75. 	void step() override;

  76. 

  77. 	void onReset() override {

  78. 		freeze = false;

  79. 		blendMode = 0;

  80. 		playback = clouds::PLAYBACK_MODE_GRANULAR;

  81. 		quality = 0;

  82. 	}

  83. 

  84. 	json_t *toJson() override {

  85. 		json_t *rootJ = json_object();

  86. 

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

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

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

  90. 

  91. 		return rootJ;

  92. 	}

  93. 

  94. 	void fromJson(json_t *rootJ) override {

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

  96. 		if (playbackJ) {

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

  98. 		}

  99. 

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

  101. 		if (qualityJ) {

  102. 			quality = json_integer_value(qualityJ);

  103. 		}

  104. 

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

  106. 		if (blendModeJ) {

  107. 			blendMode = json_integer_value(blendModeJ);

  108. 		}

  109. 	}

  110. };

  111. 

  112. 

  113. Clouds::Clouds() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  114. 	const int memLen = 118784;

  115. 	const int ccmLen = 65536 - 128;

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

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

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

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

  120. 

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

  122. 	onReset();

  123. }

  124. 

  125. Clouds::~Clouds() {

  126. 	delete processor;

  127. 	delete[] block_mem;

  128. 	delete[] block_ccm;

  129. }

  130. 

  131. void Clouds::step() {

  132. 	// Get input

  133. 	Frame<2> inputFrame = {};

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

  135. 		inputFrame.samples[0] = inputs[IN_L_INPUT].value * params[IN_GAIN_PARAM].value / 5.0;

  136. 		inputFrame.samples[1] = inputs[IN_R_INPUT].active ? inputs[IN_R_INPUT].value * params[IN_GAIN_PARAM].value / 5.0 : inputFrame.samples[0];

  137. 		inputBuffer.push(inputFrame);

  138. 	}

  139. 

  140. 	if (freezeTrigger.process(params[FREEZE_PARAM].value)) {

  141. 		freeze ^= true;

  142. 	}

  143. 	if (blendTrigger.process(params[MODE_PARAM].value)) {

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

  145. 	}

  146. 

  147. 	// Trigger

  148. 	if (inputs[TRIG_INPUT].value >= 1.0) {

  149. 		triggered = true;

  150. 	}

  151. 

  152. 	// Render frames

  153. 	if (outputBuffer.empty()) {

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

  155. 		// Convert input buffer

  156. 		{

  157. 			inputSrc.setRates(engineGetSampleRate(), 32000);

  158. 			Frame<2> inputFrames[32];

  159. 			int inLen = inputBuffer.size();

  160. 			int outLen = 32;

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

  162. 			inputBuffer.startIncr(inLen);

  163. 

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

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

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

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

  168. 			}

  169. 		}

  170. 

  171. 		// Set up processor

  172. 		processor->set_playback_mode(playback);

  173. 		processor->set_quality(quality);

  174. 		processor->Prepare();

  175. 

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

  177. 		p->trigger = triggered;

  178. 		p->gate = triggered;

  179. 		p->freeze = freeze || (inputs[FREEZE_INPUT].value >= 1.0);

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

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

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

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

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

  185. 		p->dry_wet = params[BLEND_PARAM].value;

  186. 		p->stereo_spread = params[SPREAD_PARAM].value;

  187. 		p->feedback = params[FEEDBACK_PARAM].value;

  188. 		// TODO

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

  190. 		p->reverb = params[REVERB_PARAM].value;

  191. 		float blend = inputs[BLEND_INPUT].value / 5.0f;

  192. 		switch (blendMode) {

  193. 			case 0:

  194. 				p->dry_wet += blend;

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

  196. 				break;

  197. 			case 1:

  198. 				p->stereo_spread += blend;

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

  200. 				break;

  201. 			case 2:

  202. 				p->feedback += blend;

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

  204. 				break;

  205. 			case 3:

  206. 				p->reverb += blend;

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

  208. 				break;

  209. 		}

  210. 

  211. 		clouds::ShortFrame output[32];

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

  213. 

  214. 		// Convert output buffer

  215. 		{

  216. 			Frame<2> outputFrames[32];

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

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

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

  220. 			}

  221. 

  222. 			outputSrc.setRates(32000, engineGetSampleRate());

  223. 			int inLen = 32;

  224. 			int outLen = outputBuffer.capacity();

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

  226. 			outputBuffer.endIncr(outLen);

  227. 		}

  228. 

  229. 		triggered = false;

  230. 	}

  231. 

  232. 	// Set output

  233. 	Frame<2> outputFrame = {};

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

  235. 		outputFrame = outputBuffer.shift();

  236. 		outputs[OUT_L_OUTPUT].value = 5.0 * outputFrame.samples[0];

  237. 		outputs[OUT_R_OUTPUT].value = 5.0 * outputFrame.samples[1];

  238. 	}

  239. 

  240. 	// Lights

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

  242. 	VUMeter vuMeter;

  243. 	vuMeter.dBInterval = 6.0;

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

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

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

  247. 	lights[MIX_GREEN_LIGHT].setBrightnessSmooth(vuMeter.getBrightness(3));

  248. 	lights[PAN_GREEN_LIGHT].setBrightnessSmooth(vuMeter.getBrightness(2));

  249. 	lights[FEEDBACK_GREEN_LIGHT].setBrightnessSmooth(vuMeter.getBrightness(1));

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

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

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

  253. 	lights[FEEDBACK_RED_LIGHT].setBrightnessSmooth(vuMeter.getBrightness(1));

  254. 	lights[REVERB_RED_LIGHT].setBrightnessSmooth(vuMeter.getBrightness(0));

  255. }

  256. 

  257. 

  258. 

  259. struct FreezeLight : YellowLight {

  260. 	FreezeLight() {

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

  262. 		bgColor = COLOR_BLACK_TRANSPARENT;

  263. 	}

  264. };

  265. 

  266. 

  267. struct CloudsBlendItem : MenuItem {

  268. 	Clouds *module;

  269. 	int blendMode;

  270. 	void onAction(EventAction &e) override {

  271. 		module->blendMode = blendMode;

  272. 	}

  273. 	void step() override {

  274. 		rightText = (module->blendMode == blendMode) ? "✔" : "";

  275. 		MenuItem::step();

  276. 	}

  277. };

  278. 

  279. 

  280. struct CloudsPlaybackItem : MenuItem {

  281. 	Clouds *module;

  282. 	clouds::PlaybackMode playback;

  283. 	void onAction(EventAction &e) override {

  284. 		module->playback = playback;

  285. 	}

  286. 	void step() override {

  287. 		rightText = (module->playback == playback) ? "✔" : "";

  288. 		MenuItem::step();

  289. 	}

  290. };

  291. 

  292. 

  293. struct CloudsQualityItem : MenuItem {

  294. 	Clouds *module;

  295. 	int quality;

  296. 	void onAction(EventAction &e) override {

  297. 		module->quality = quality;

  298. 	}

  299. 	void step() override {

  300. 		rightText = (module->quality == quality) ? "✔" : "";

  301. 		MenuItem::step();

  302. 	}

  303. };

  304. 

  305. 

  306. struct CloudsWidget : ModuleWidget {

  307. 	ParamWidget *blendParam;

  308. 	ParamWidget *spreadParam;

  309. 	ParamWidget *feedbackParam;

  310. 	ParamWidget *reverbParam;

  311. 

  312. 	CloudsWidget(Clouds *module) : ModuleWidget(module) {

  313. 		setPanel(SVG::load(assetPlugin(plugin, "res/Clouds.svg")));

  314. 

  315. 		addChild(Widget::create<ScrewSilver>(Vec(15, 0)));

  316. 		addChild(Widget::create<ScrewSilver>(Vec(240, 0)));

  317. 		addChild(Widget::create<ScrewSilver>(Vec(15, 365)));

  318. 		addChild(Widget::create<ScrewSilver>(Vec(240, 365)));

  319. 

  320. 		addParam(ParamWidget::create<Rogan3PSRed>(Vec(27, 93), module, Clouds::POSITION_PARAM, 0.0, 1.0, 0.5));

  321. 		addParam(ParamWidget::create<Rogan3PSGreen>(Vec(108, 93), module, Clouds::SIZE_PARAM, 0.0, 1.0, 0.5));

  322. 		addParam(ParamWidget::create<Rogan3PSWhite>(Vec(190, 93), module, Clouds::PITCH_PARAM, -2.0, 2.0, 0.0));

  323. 

  324. 		addParam(ParamWidget::create<Rogan1PSRed>(Vec(14, 180), module, Clouds::IN_GAIN_PARAM, 0.0, 1.0, 0.5));

  325. 		addParam(ParamWidget::create<Rogan1PSRed>(Vec(81, 180), module, Clouds::DENSITY_PARAM, 0.0, 1.0, 0.5));

  326. 		addParam(ParamWidget::create<Rogan1PSGreen>(Vec(146, 180), module, Clouds::TEXTURE_PARAM, 0.0, 1.0, 0.5));

  327. 		blendParam = ParamWidget::create<Rogan1PSWhite>(Vec(213, 180), module, Clouds::BLEND_PARAM, 0.0, 1.0, 0.5);

  328. 		addParam(blendParam);

  329. 		spreadParam = ParamWidget::create<Rogan1PSRed>(Vec(213, 180), module, Clouds::SPREAD_PARAM, 0.0, 1.0, 0.0);

  330. 		addParam(spreadParam);

  331. 		feedbackParam = ParamWidget::create<Rogan1PSGreen>(Vec(213, 180), module, Clouds::FEEDBACK_PARAM, 0.0, 1.0, 0.0);

  332. 		addParam(feedbackParam);

  333. 		reverbParam = ParamWidget::create<Rogan1PSBlue>(Vec(213, 180), module, Clouds::REVERB_PARAM, 0.0, 1.0, 0.0);

  334. 		addParam(reverbParam);

  335. 

  336. 		addParam(ParamWidget::create<CKD6>(Vec(12, 43), module, Clouds::FREEZE_PARAM, 0.0, 1.0, 0.0));

  337. 		addParam(ParamWidget::create<TL1105>(Vec(211, 50), module, Clouds::MODE_PARAM, 0.0, 1.0, 0.0));

  338. 		addParam(ParamWidget::create<TL1105>(Vec(239, 50), module, Clouds::LOAD_PARAM, 0.0, 1.0, 0.0));

  339. 

  340. 		addInput(Port::create<PJ301MPort>(Vec(15, 274), Port::INPUT, module, Clouds::FREEZE_INPUT));

  341. 		addInput(Port::create<PJ301MPort>(Vec(58, 274), Port::INPUT, module, Clouds::TRIG_INPUT));

  342. 		addInput(Port::create<PJ301MPort>(Vec(101, 274), Port::INPUT, module, Clouds::POSITION_INPUT));

  343. 		addInput(Port::create<PJ301MPort>(Vec(144, 274), Port::INPUT, module, Clouds::SIZE_INPUT));

  344. 		addInput(Port::create<PJ301MPort>(Vec(188, 274), Port::INPUT, module, Clouds::PITCH_INPUT));

  345. 		addInput(Port::create<PJ301MPort>(Vec(230, 274), Port::INPUT, module, Clouds::BLEND_INPUT));

  346. 

  347. 		addInput(Port::create<PJ301MPort>(Vec(15, 317), Port::INPUT, module, Clouds::IN_L_INPUT));

  348. 		addInput(Port::create<PJ301MPort>(Vec(58, 317), Port::INPUT, module, Clouds::IN_R_INPUT));

  349. 		addInput(Port::create<PJ301MPort>(Vec(101, 317), Port::INPUT, module, Clouds::DENSITY_INPUT));

  350. 		addInput(Port::create<PJ301MPort>(Vec(144, 317), Port::INPUT, module, Clouds::TEXTURE_INPUT));

  351. 		addOutput(Port::create<PJ301MPort>(Vec(188, 317), Port::OUTPUT, module, Clouds::OUT_L_OUTPUT));

  352. 		addOutput(Port::create<PJ301MPort>(Vec(230, 317), Port::OUTPUT, module, Clouds::OUT_R_OUTPUT));

  353. 

  354. 		addChild(ModuleLightWidget::create<FreezeLight>(Vec(12+3, 43+3), module, Clouds::FREEZE_LIGHT));

  355. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(82.5, 53), module, Clouds::MIX_GREEN_LIGHT));

  356. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(114.5, 53), module, Clouds::PAN_GREEN_LIGHT));

  357. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(145.5, 53), module, Clouds::FEEDBACK_GREEN_LIGHT));

  358. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(177.5, 53), module, Clouds::REVERB_GREEN_LIGHT));

  359. 	}

  360. 

  361. 	void step() override {

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

  363. 

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

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

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

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

  368. 

  369. 		ModuleWidget::step();

  370. 	}

  371. 

  372. 	void appendContextMenu(Menu *menu) override {

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

  374. 		assert(module);

  375. 

  376. 		menu->addChild(construct<MenuLabel>());

  377. 		menu->addChild(construct<MenuLabel>(&MenuLabel::text, "Blend knob"));

  378. 		menu->addChild(construct<CloudsBlendItem>(&MenuItem::text, "Wet/dry", &CloudsBlendItem::module, module, &CloudsBlendItem::blendMode, 0));

  379. 		menu->addChild(construct<CloudsBlendItem>(&MenuItem::text, "Spread", &CloudsBlendItem::module, module, &CloudsBlendItem::blendMode, 1));

  380. 		menu->addChild(construct<CloudsBlendItem>(&MenuItem::text, "Feedback", &CloudsBlendItem::module, module, &CloudsBlendItem::blendMode, 2));

  381. 		menu->addChild(construct<CloudsBlendItem>(&MenuItem::text, "Reverb", &CloudsBlendItem::module, module, &CloudsBlendItem::blendMode, 3));

  382. 

  383. 		menu->addChild(construct<MenuLabel>());

  384. 		menu->addChild(construct<MenuLabel>(&MenuLabel::text, "Alternative mode"));

  385. 		menu->addChild(construct<CloudsPlaybackItem>(&MenuItem::text, "Granular", &CloudsPlaybackItem::module, module, &CloudsPlaybackItem::playback, clouds::PLAYBACK_MODE_GRANULAR));

  386. 		menu->addChild(construct<CloudsPlaybackItem>(&MenuItem::text, "Pitch-shifter/time-stretcher", &CloudsPlaybackItem::module, module, &CloudsPlaybackItem::playback, clouds::PLAYBACK_MODE_STRETCH));

  387. 		menu->addChild(construct<CloudsPlaybackItem>(&MenuItem::text, "Looping delay", &CloudsPlaybackItem::module, module, &CloudsPlaybackItem::playback, clouds::PLAYBACK_MODE_LOOPING_DELAY));

  388. 		menu->addChild(construct<CloudsPlaybackItem>(&MenuItem::text, "Spectral madness", &CloudsPlaybackItem::module, module, &CloudsPlaybackItem::playback, clouds::PLAYBACK_MODE_SPECTRAL));

  389. 

  390. 		menu->addChild(construct<MenuLabel>());

  391. 		menu->addChild(construct<MenuLabel>(&MenuLabel::text, "Quality"));

  392. 		menu->addChild(construct<CloudsQualityItem>(&MenuItem::text, "1s 32kHz 16-bit stereo", &CloudsQualityItem::module, module, &CloudsQualityItem::quality, 0));

  393. 		menu->addChild(construct<CloudsQualityItem>(&MenuItem::text, "2s 32kHz 16-bit mono", &CloudsQualityItem::module, module, &CloudsQualityItem::quality, 1));

  394. 		menu->addChild(construct<CloudsQualityItem>(&MenuItem::text, "4s 16kHz 8-bit µ-law stereo", &CloudsQualityItem::module, module, &CloudsQualityItem::quality, 2));

  395. 		menu->addChild(construct<CloudsQualityItem>(&MenuItem::text, "8s 16kHz 8-bit µ-law mono", &CloudsQualityItem::module, module, &CloudsQualityItem::quality, 3));

  396. 	}

  397. };

  398. 

  399. 

  400. RACK_PLUGIN_MODEL_INIT(AudibleInstruments, Clouds) {

  401.    Model *modelClouds = Model::create<Clouds, CloudsWidget>("Audible Instruments", "Clouds", "Texture Synthesizer", GRANULAR_TAG, REVERB_TAG);

  402.    return modelClouds;

  403. }