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

396 lines
14KB
Raw Blame History 

  1. #include "AudibleInstruments.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. 	SampleRateConverter<2> inputSrc;

  50. 	SampleRateConverter<2> outputSrc;

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

  52. 	DoubleRingBuffer<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. 	SchmittTrigger freezeTrigger;

  61. 	bool freeze = false;

  62. 	SchmittTrigger blendTrigger;

  63. 	int blendMode = 0;

  64. 

  65. 	clouds::PlaybackMode playback;

  66. 	int quality = 0;

  67. 

  68. 	Clouds();

  69. 	~Clouds();

  70. 	void step() override;

  71. 

  72. 	void onReset() override {

  73. 		freeze = false;

  74. 		blendMode = 0;

  75. 		playback = clouds::PLAYBACK_MODE_GRANULAR;

  76. 		quality = 0;

  77. 	}

  78. 

  79. 	json_t *dataToJson() override {

  80. 		json_t *rootJ = json_object();

  81. 

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

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

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

  85. 

  86. 		return rootJ;

  87. 	}

  88. 

  89. 	void dataFromJson(json_t *rootJ) override {

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

  91. 		if (playbackJ) {

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

  93. 		}

  94. 

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

  96. 		if (qualityJ) {

  97. 			quality = json_integer_value(qualityJ);

  98. 		}

  99. 

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

  101. 		if (blendModeJ) {

  102. 			blendMode = json_integer_value(blendModeJ);

  103. 		}

  104. 	}

  105. };

  106. 

  107. 

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

  109. 	const int memLen = 118784;

  110. 	const int ccmLen = 65536 - 128;

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

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

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

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

  115. 

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

  117. 	onReset();

  118. }

  119. 

  120. Clouds::~Clouds() {

  121. 	delete processor;

  122. 	delete[] block_mem;

  123. 	delete[] block_ccm;

  124. }

  125. 

  126. void Clouds::step() {

  127. 	// Get input

  128. 	Frame<2> inputFrame = {};

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

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

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

  132. 		inputBuffer.push(inputFrame);

  133. 	}

  134. 

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

  136. 		freeze ^= true;

  137. 	}

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

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

  140. 	}

  141. 

  142. 	// Trigger

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

  144. 		triggered = true;

  145. 	}

  146. 

  147. 	// Render frames

  148. 	if (outputBuffer.empty()) {

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

  150. 		// Convert input buffer

  151. 		{

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

  153. 			Frame<2> inputFrames[32];

  154. 			int inLen = inputBuffer.size();

  155. 			int outLen = 32;

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

  157. 			inputBuffer.startIncr(inLen);

  158. 

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

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

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

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

  163. 			}

  164. 		}

  165. 

  166. 		// Set up processor

  167. 		processor->set_playback_mode(playback);

  168. 		processor->set_quality(quality);

  169. 		processor->Prepare();

  170. 

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

  172. 		p->trigger = triggered;

  173. 		p->gate = triggered;

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

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

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

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

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

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

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

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

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

  183. 		// TODO

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

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

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

  187. 		switch (blendMode) {

  188. 			case 0:

  189. 				p->dry_wet += blend;

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

  191. 				break;

  192. 			case 1:

  193. 				p->stereo_spread += blend;

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

  195. 				break;

  196. 			case 2:

  197. 				p->feedback += blend;

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

  199. 				break;

  200. 			case 3:

  201. 				p->reverb += blend;

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

  203. 				break;

  204. 		}

  205. 

  206. 		clouds::ShortFrame output[32];

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

  208. 

  209. 		// Convert output buffer

  210. 		{

  211. 			Frame<2> outputFrames[32];

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

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

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

  215. 			}

  216. 

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

  218. 			int inLen = 32;

  219. 			int outLen = outputBuffer.capacity();

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

  221. 			outputBuffer.endIncr(outLen);

  222. 		}

  223. 

  224. 		triggered = false;

  225. 	}

  226. 

  227. 	// Set output

  228. 	Frame<2> outputFrame = {};

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

  230. 		outputFrame = outputBuffer.shift();

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

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

  233. 	}

  234. 

  235. 	// Lights

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

  237. 	VUMeter vuMeter;

  238. 	vuMeter.dBInterval = 6.0;

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

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

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

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

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

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

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

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

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

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

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

  250. }

  251. 

  252. 

  253. 

  254. struct FreezeLight : YellowLight {

  255. 	FreezeLight() {

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

  257. 		bgColor = COLOR_BLACK_TRANSPARENT;

  258. 	}

  259. };

  260. 

  261. 

  262. struct CloudsBlendItem : MenuItem {

  263. 	Clouds *module;

  264. 	int blendMode;

  265. 	void onAction(const event::Action &e) override {

  266. 		module->blendMode = blendMode;

  267. 	}

  268. 	void step() override {

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

  270. 		MenuItem::step();

  271. 	}

  272. };

  273. 

  274. 

  275. struct CloudsPlaybackItem : MenuItem {

  276. 	Clouds *module;

  277. 	clouds::PlaybackMode playback;

  278. 	void onAction(const event::Action &e) override {

  279. 		module->playback = playback;

  280. 	}

  281. 	void step() override {

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

  283. 		MenuItem::step();

  284. 	}

  285. };

  286. 

  287. 

  288. struct CloudsQualityItem : MenuItem {

  289. 	Clouds *module;

  290. 	int quality;

  291. 	void onAction(const event::Action &e) override {

  292. 		module->quality = quality;

  293. 	}

  294. 	void step() override {

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

  296. 		MenuItem::step();

  297. 	}

  298. };

  299. 

  300. 

  301. struct CloudsWidget : ModuleWidget {

  302. 	ParamWidget *blendParam;

  303. 	ParamWidget *spreadParam;

  304. 	ParamWidget *feedbackParam;

  305. 	ParamWidget *reverbParam;

  306. 

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

  308. 		setPanel(SVG::load(assetPlugin(pluginInstance, "res/Clouds.svg")));

  309. 

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

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

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

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

  314. 

  315. 		addParam(createParam<Rogan3PSRed>(Vec(27, 93), module, Clouds::POSITION_PARAM, 0.0, 1.0, 0.5));

  316. 		addParam(createParam<Rogan3PSGreen>(Vec(108, 93), module, Clouds::SIZE_PARAM, 0.0, 1.0, 0.5));

  317. 		addParam(createParam<Rogan3PSWhite>(Vec(190, 93), module, Clouds::PITCH_PARAM, -2.0, 2.0, 0.0));

  318. 

  319. 		addParam(createParam<Rogan1PSRed>(Vec(14, 180), module, Clouds::IN_GAIN_PARAM, 0.0, 1.0, 0.5));

  320. 		addParam(createParam<Rogan1PSRed>(Vec(81, 180), module, Clouds::DENSITY_PARAM, 0.0, 1.0, 0.5));

  321. 		addParam(createParam<Rogan1PSGreen>(Vec(146, 180), module, Clouds::TEXTURE_PARAM, 0.0, 1.0, 0.5));

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

  323. 		addParam(blendParam);

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

  325. 		addParam(spreadParam);

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

  327. 		addParam(feedbackParam);

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

  329. 		addParam(reverbParam);

  330. 

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

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

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

  334. 

  335. 		addInput(createPort<PJ301MPort>(Vec(15, 274), PortWidget::INPUT, module, Clouds::FREEZE_INPUT));

  336. 		addInput(createPort<PJ301MPort>(Vec(58, 274), PortWidget::INPUT, module, Clouds::TRIG_INPUT));

  337. 		addInput(createPort<PJ301MPort>(Vec(101, 274), PortWidget::INPUT, module, Clouds::POSITION_INPUT));

  338. 		addInput(createPort<PJ301MPort>(Vec(144, 274), PortWidget::INPUT, module, Clouds::SIZE_INPUT));

  339. 		addInput(createPort<PJ301MPort>(Vec(188, 274), PortWidget::INPUT, module, Clouds::PITCH_INPUT));

  340. 		addInput(createPort<PJ301MPort>(Vec(230, 274), PortWidget::INPUT, module, Clouds::BLEND_INPUT));

  341. 

  342. 		addInput(createPort<PJ301MPort>(Vec(15, 317), PortWidget::INPUT, module, Clouds::IN_L_INPUT));

  343. 		addInput(createPort<PJ301MPort>(Vec(58, 317), PortWidget::INPUT, module, Clouds::IN_R_INPUT));

  344. 		addInput(createPort<PJ301MPort>(Vec(101, 317), PortWidget::INPUT, module, Clouds::DENSITY_INPUT));

  345. 		addInput(createPort<PJ301MPort>(Vec(144, 317), PortWidget::INPUT, module, Clouds::TEXTURE_INPUT));

  346. 		addOutput(createPort<PJ301MPort>(Vec(188, 317), PortWidget::OUTPUT, module, Clouds::OUT_L_OUTPUT));

  347. 		addOutput(createPort<PJ301MPort>(Vec(230, 317), PortWidget::OUTPUT, module, Clouds::OUT_R_OUTPUT));

  348. 

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

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

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

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

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

  354. 	}

  355. 

  356. 	void step() override {

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

  358. 

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

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

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

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

  363. 

  364. 		ModuleWidget::step();

  365. 	}

  366. 

  367. 	void appendContextMenu(Menu *menu) override {

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

  369. 		assert(module);

  370. 

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

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

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

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

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

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

  377. 

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

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

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

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

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

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

  384. 

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

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

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

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

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

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

  391. 	}

  392. };

  393. 

  394. 

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