VCVRack
/
Befaco
mirror of https://github.com/VCVRack/Befaco.git
1
0
Fork 0
Code Issues 0 Releases 17 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.
205 Commits
7 Branches
9.8MB
Tree: 700a5cce98
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '700a5cce98'
${ noResults }
Befaco/src/Octaves.cpp

344 lines
13KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. 

  3. 

  4. float aliasSuppressedSaw(const float* phases, float pw) {

  5. 	float sawBuffer[3];

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

  7. 		float p = 2 * phases[i] - 1.0; 		// range -1 to +1

  8. 		float pwp = p + 2 * pw;				// phase after pw (pw in [0, 1])

  9. 		pwp += simd::ifelse(pwp > 1, -2, simd::ifelse(pwp < -1, +2, 0));     			// modulo on [-1, +1]

  10. 		sawBuffer[i] = (pwp * pwp * pwp - pwp) / 6.0;	// eq 11

  11. 	}

  12. 

  13. 	return (sawBuffer[0] - 2.0 * sawBuffer[1] + sawBuffer[2]);

  14. }

  15. 

  16. float aliasSuppressedOffsetSaw(const float* phases, float pw) {

  17. 	float sawOffsetBuff[3];

  18. 

  19. 	for (int i = 0; i < 3; ++i) {

  20. 		float pwp = 2 * phases[i] - 2 * pw; 		// range -1 to +1

  21. 		

  22. 		pwp += simd::ifelse(pwp > 1, -2, 0);     			// modulo on [-1, +1]

  23. 		sawOffsetBuff[i] = (pwp * pwp * pwp - pwp) / 6.0;	// eq 11

  24. 	}

  25. 	return (sawOffsetBuff[0] - 2.0 * sawOffsetBuff[1] + sawOffsetBuff[2]);

  26. }

  27. 

  28. 

  29. struct Octaves : Module {

  30. 	enum ParamId {

  31. 		PWM_CV_PARAM,

  32. 		OCTAVE_PARAM,

  33. 		TUNE_PARAM,

  34. 		PWM_PARAM,

  35. 		RANGE_PARAM,

  36. 		GAIN_01F_PARAM,

  37. 		GAIN_02F_PARAM,

  38. 		GAIN_04F_PARAM,

  39. 		GAIN_08F_PARAM,

  40. 		GAIN_16F_PARAM,

  41. 		GAIN_32F_PARAM,

  42. 		PARAMS_LEN

  43. 	};

  44. 	enum InputId {

  45. 		VOCT1_INPUT,

  46. 		VOCT2_INPUT,

  47. 		SYNC_INPUT,

  48. 		PWM_INPUT,

  49. 		GAIN_01F_INPUT,

  50. 		GAIN_02F_INPUT,

  51. 		GAIN_04F_INPUT,

  52. 		GAIN_08F_INPUT,

  53. 		GAIN_16F_INPUT,

  54. 		GAIN_32F_INPUT,

  55. 		INPUTS_LEN

  56. 	};

  57. 	enum OutputId {

  58. 		OUT_01F_OUTPUT,

  59. 		OUT_02F_OUTPUT,

  60. 		OUT_04F_OUTPUT,

  61. 		OUT_08F_OUTPUT,

  62. 		OUT_16F_OUTPUT,

  63. 		OUT_32F_OUTPUT,

  64. 		OUT_OUTPUT,

  65. 		OUT2_OUTPUT,

  66. 		OUT_01F_OUTPUT_ALT,

  67. 		OUT_02F_OUTPUT_ALT,

  68. 		OUT_04F_OUTPUT_ALT,

  69. 		OUT_08F_OUTPUT_ALT,

  70. 		OUT_16F_OUTPUT_ALT,

  71. 		OUT_32F_OUTPUT_ALT,

  72. 		OUTPUTS_LEN

  73. 	};

  74. 	enum LightId {

  75. 		LIGHTS_LEN

  76. 	};

  77. 

  78. 	bool limitPW = true;

  79. 	bool removePulseDC = false;

  80. 	int oversamplingIndex = 0;

  81. 

  82. 	Octaves() {

  83. 		config(PARAMS_LEN, INPUTS_LEN, OUTPUTS_LEN, LIGHTS_LEN);

  84. 		configParam(PWM_CV_PARAM, 0.f, 1.f, 1.f, "PWM CV attenuater");

  85. 

  86. 		auto octParam = configSwitch(OCTAVE_PARAM, 0.f, 6.f, 4.f, "Octave", {"C1", "C2", "C3", "C4", "C5", "C6", "C7"});

  87. 		octParam->snapEnabled = true;

  88. 

  89. 		configParam(TUNE_PARAM, -1.f, 1.f, 0.f, "Tune");

  90. 		configParam(PWM_PARAM, 0.5f, 0.f, 0.5f, "PWM");

  91. 		auto rangeParam = configSwitch(RANGE_PARAM, 0.f, 2.f, 0.f, "Range", {"VCO: Full", "VCO: Octave", "VCO: Semitone"});

  92. 		rangeParam->snapEnabled = true;

  93. 

  94. 		configParam(GAIN_01F_PARAM, 0.f, 1.f, 0.f, "Gain Fundamental");

  95. 		configParam(GAIN_02F_PARAM, 0.f, 1.f, 0.f, "Gain x2 Fundamental");

  96. 		configParam(GAIN_04F_PARAM, 0.f, 1.f, 0.f, "Gain x4 Fundamental");

  97. 		configParam(GAIN_08F_PARAM, 0.f, 1.f, 0.f, "Gain x8 Fundamental");

  98. 		configParam(GAIN_16F_PARAM, 0.f, 1.f, 0.f, "Gain x16 Fundamental");

  99. 		configParam(GAIN_32F_PARAM, 0.f, 1.f, 0.f, "Gain x32 Fundamental");

  100. 

  101. 		configInput(VOCT1_INPUT, "V/Octave 1");

  102. 		configInput(VOCT2_INPUT, "V/Octave 2");

  103. 		configInput(SYNC_INPUT, "Sync");

  104. 		configInput(PWM_INPUT, "PWM");

  105. 		configInput(GAIN_01F_INPUT, "Gain x1F CV");

  106. 		configInput(GAIN_02F_INPUT, "Gain x1F CV");

  107. 		configInput(GAIN_04F_INPUT, "Gain x1F CV");

  108. 		configInput(GAIN_08F_INPUT, "Gain x1F CV");

  109. 		configInput(GAIN_16F_INPUT, "Gain x1F CV");

  110. 		configInput(GAIN_32F_INPUT, "Gain x1F CV");

  111. 

  112. 		configOutput(OUT_01F_OUTPUT, "x1F");

  113. 		configOutput(OUT_02F_OUTPUT, "x2F");

  114. 		configOutput(OUT_04F_OUTPUT, "x4F");

  115. 		configOutput(OUT_08F_OUTPUT, "x8F");

  116. 		configOutput(OUT_16F_OUTPUT, "x16F");

  117. 		configOutput(OUT_32F_OUTPUT, "x32F");

  118. 		configOutput(OUT_OUTPUT, "debug");

  119. 	}

  120. 

  121. 	float phase = 0.f;

  122. 	float phases[3];

  123. 	bool forceNaive = false;

  124. 

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

  126. 

  127. 		float pitch = params[TUNE_PARAM].getValue() + inputs[VOCT1_INPUT].getVoltage() + inputs[VOCT2_INPUT].getVoltage();

  128. 		pitch += params[OCTAVE_PARAM].getValue() - 3;

  129. 		float freq = dsp::FREQ_C4 * dsp::exp2_taylor5(pitch);

  130. 		// -1 to +1

  131. 		float pwmCV = params[PWM_CV_PARAM].getValue() * clamp(inputs[PWM_INPUT].getVoltage() / 10.f, -1.f, 1.f);

  132. 		const float pulseWidthLimit = limitPW ? 0.05f : 0.0f;

  133. 		

  134. 		// pwm in [-0.25 : +0.25]

  135. 		float pwm = clamp(0.5 - params[PWM_PARAM].getValue() + 0.5 * pwmCV, -0.5f + pulseWidthLimit, 0.5f - pulseWidthLimit);

  136. 		pwm /= 2.0;

  137. 

  138. 

  139. 		float deltaPhase = freq * args.sampleTime;

  140. 		phase += deltaPhase;

  141. 		phase -= std::floor(phase);

  142. 

  143. 		float sum = 0.f;

  144. 		float sumNaive = 0.f;

  145. 		for (int c = 0; c < 6; c++) {

  146. 			// derive phases for higher octaves from base phase (this keeps things in sync!)

  147. 			const float n = (float)(1 << c);

  148. 			// this is on [0, 1]

  149. 			const float effectivePhaseRaw = n * std::fmod(phase, 1 / n);			

  150. 			// this is on [0, 1], and offset in time by 0.25

  151. 			const float effectivePhase = std::fmod(effectivePhaseRaw + 0.25, 1);

  152. 

  153. 			const float effectiveDeltaPhase = deltaPhase * n;

  154. 			const float gainCV = clamp(inputs[GAIN_01F_INPUT + c].getNormalVoltage(10.f) / 10.f, 0.f, 1.0f);

  155. 			const float gain = params[GAIN_01F_PARAM + c].getValue() * gainCV;

  156. 

  157. 			// floating point arithmetic doesn't work well at low frequencies, specifically because the finite difference denominator

  158. 			// becomes tiny - we check for that scenario and use naive / 1st order waveforms in that frequency regime (as aliasing isn't

  159. 			// a problem there). With no oversampling, at 44100Hz, the threshold frequency is 44.1Hz.

  160. 			const bool lowFreqRegime = forceNaive; //effectiveDeltaPhase < 1e-3 || forceNaive;

  161. 

  162. 

  163. 			//float waveTri = 1.0 - 2.0 * std::abs(2.f * effectivePhase - 1.0);

  164. 			// float dpwOrder1 = (waveTri > 2 * pwm - 1) ? 1.0 : -1.0;

  165. 

  166. 			float dpwOrder1 = gain * (effectivePhaseRaw > pwm + 0.25 && effectivePhaseRaw < 0.75 - pwm ? -1.0 : +1.0);

  167. 			dpwOrder1 -= removePulseDC ? 2.f * (0.5f - pwm) : 0.f;

  168. 

  169. 			// dpwOrder1 = waveTri * gain;

  170. 

  171. 			sumNaive += dpwOrder1;

  172. 

  173. 			outputs[OUT_01F_OUTPUT_ALT + c].setVoltage(dpwOrder1);

  174. 

  175. 			float outForOctave = dpwOrder1;

  176. 

  177. 			if (!lowFreqRegime) {

  178. 				phases[0] = effectivePhase - 2 * effectiveDeltaPhase + (effectivePhase < 2 * effectiveDeltaPhase ? 1.f : 0.f);

  179. 				phases[1] = effectivePhase - 1 * effectiveDeltaPhase + (effectivePhase < 1 * effectiveDeltaPhase ? 1.f : 0.f);

  180. 				phases[2] = effectivePhase;

  181. 

  182. 

  183. 				float saw = aliasSuppressedSaw(phases, pwm);

  184. 				float sawOffset = aliasSuppressedOffsetSaw(phases, pwm);

  185. 				float denominatorInv = 0.25 / (effectiveDeltaPhase * effectiveDeltaPhase);

  186. 				float dpwOrder3 = gain * (sawOffset - saw) * denominatorInv;

  187. 

  188. 				const float pulseDCOffset = (!removePulseDC) * 4.f * pwm * gain;

  189. 				dpwOrder3 += pulseDCOffset;

  190. 

  191. 

  192. 				outForOctave = dpwOrder3;

  193. 			}

  194. 

  195. 

  196. 			sum += outForOctave;

  197. 			sum = clamp(sum, -1.f, 1.f);

  198. 

  199. 			if (outputs[OUT_01F_OUTPUT + c].isConnected()) {

  200. 				outputs[OUT_01F_OUTPUT + c].setVoltage(5 * sum);

  201. 				sum = 0.f;

  202. 			}

  203. 

  204. 			if (c == 0) {

  205. 				outputs[OUT_OUTPUT].setVoltage(effectivePhase);

  206. 				

  207. 				float saw = aliasSuppressedSaw(phases, 2*pwm);

  208. 				float sawOffset = aliasSuppressedOffsetSaw(phases, 2*pwm);

  209. 				float denominatorInv = 0.25 / (effectiveDeltaPhase * effectiveDeltaPhase);

  210. 				float dpwOrder3_ = gain * (-saw) * denominatorInv;

  211. 

  212. 				outputs[OUT2_OUTPUT].setVoltage(dpwOrder3_);

  213. 			}

  214. 

  215. 

  216. 		}

  217. 

  218. 		//outputs[OUT_OUTPUT].setVoltage(sum);

  219. 		//outputs[OUT2_OUTPUT].setVoltage(phase > 0.5 ? +5 : -5);

  220. 

  221. 	}

  222. 

  223. 

  224. 	json_t* dataToJson() override {

  225. 		json_t* rootJ = json_object();

  226. 		json_object_set_new(rootJ, "removePulseDC", json_boolean(removePulseDC));

  227. 		json_object_set_new(rootJ, "limitPW", json_boolean(limitPW));

  228. 		json_object_set_new(rootJ, "forceNaive", json_boolean(forceNaive));

  229. 		// TODO:

  230. 		// json_object_set_new(rootJ, "oversamplingIndex", json_integer(oversampler[0].getOversamplingIndex()));

  231. 		return rootJ;

  232. 	}

  233. 

  234. 	void dataFromJson(json_t* rootJ) override {

  235. 

  236. 		json_t* removePulseDCJ = json_object_get(rootJ, "removePulseDC");

  237. 		if (removePulseDCJ) {

  238. 			removePulseDC = json_boolean_value(removePulseDCJ);

  239. 		}

  240. 

  241. 		json_t* limitPWJ = json_object_get(rootJ, "limitPW");

  242. 		if (limitPWJ) {

  243. 			limitPW = json_boolean_value(limitPWJ);

  244. 		}

  245. 

  246. 		json_t* forceNaiveJ = json_object_get(rootJ, "forceNaive");

  247. 		if (forceNaiveJ) {

  248. 			forceNaive = json_boolean_value(forceNaiveJ);

  249. 		}

  250. 

  251. 		json_t* oversamplingIndexJ = json_object_get(rootJ, "oversamplingIndex");

  252. 		if (oversamplingIndexJ) {

  253. 			oversamplingIndex = json_integer_value(oversamplingIndexJ);

  254. 			onSampleRateChange();

  255. 		}

  256. 	}

  257. };

  258. 

  259. 

  260. 

  261. 

  262. struct OctavesWidget : ModuleWidget {

  263. 	OctavesWidget(Octaves* module) {

  264. 		setModule(module);

  265. 		setPanel(createPanel(asset::plugin(pluginInstance, "res/panels/Octaves.svg")));

  266. 

  267. 		addChild(createWidget<Knurlie>(Vec(RACK_GRID_WIDTH, 0)));

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

  269. 		addChild(createWidget<Knurlie>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

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

  271. 

  272. 		addParam(createParamCentered<BefacoTinyKnobLightGrey>(mm2px(Vec(52.138, 15.037)), module, Octaves::PWM_CV_PARAM));

  273. 		addParam(createParam<CKSSVert7>(mm2px(Vec(22.171, 30.214)), module, Octaves::OCTAVE_PARAM));

  274. 		addParam(createParamCentered<BefacoTinyKnobLightGrey>(mm2px(Vec(10.264, 33.007)), module, Octaves::TUNE_PARAM));

  275. 		addParam(createParamCentered<Davies1900hLargeRedKnob>(mm2px(Vec(45.384, 40.528)), module, Octaves::PWM_PARAM));

  276. 		addParam(createParam<CKSSThreeHorizontal>(mm2px(Vec(6.023, 48.937)), module, Octaves::RANGE_PARAM));

  277. 		addParam(createParam<BefacoSlidePotSmall>(mm2px(Vec(2.9830, 60.342)), module, Octaves::GAIN_01F_PARAM));

  278. 		addParam(createParam<BefacoSlidePotSmall>(mm2px(Vec(12.967, 60.342)), module, Octaves::GAIN_02F_PARAM));

  279. 		addParam(createParam<BefacoSlidePotSmall>(mm2px(Vec(22.951, 60.342)), module, Octaves::GAIN_04F_PARAM));

  280. 		addParam(createParam<BefacoSlidePotSmall>(mm2px(Vec(32.936, 60.342)), module, Octaves::GAIN_08F_PARAM));

  281. 		addParam(createParam<BefacoSlidePotSmall>(mm2px(Vec(42.920, 60.342)), module, Octaves::GAIN_16F_PARAM));

  282. 		addParam(createParam<BefacoSlidePotSmall>(mm2px(Vec(52.905, 60.342)), module, Octaves::GAIN_32F_PARAM));

  283. 

  284. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(5.247, 15.181)), module, Octaves::VOCT1_INPUT));

  285. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(15.282, 15.181)), module, Octaves::VOCT2_INPUT));

  286. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(25.316, 15.181)), module, Octaves::SYNC_INPUT));

  287. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(37.092, 15.135)), module, Octaves::PWM_INPUT));

  288. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(5.247, 100.492)), module, Octaves::GAIN_01F_INPUT));

  289. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(15.282, 100.492)), module, Octaves::GAIN_02F_INPUT));

  290. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(25.316, 100.492)), module, Octaves::GAIN_04F_INPUT));

  291. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(35.35, 100.492)), module, Octaves::GAIN_08F_INPUT));

  292. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(45.384, 100.492)), module, Octaves::GAIN_16F_INPUT));

  293. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(55.418, 100.492)), module, Octaves::GAIN_32F_INPUT));

  294. 

  295. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(5.247, 113.508)), module, Octaves::OUT_01F_OUTPUT));

  296. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(15.282, 113.508)), module, Octaves::OUT_02F_OUTPUT));

  297. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(25.316, 113.508)), module, Octaves::OUT_04F_OUTPUT));

  298. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(35.35, 113.508)), module, Octaves::OUT_08F_OUTPUT));

  299. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(45.384, 113.508)), module, Octaves::OUT_16F_OUTPUT));

  300. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(55.418, 113.508)), module, Octaves::OUT_32F_OUTPUT));

  301. 

  302. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(25.316, 106.508)), module, Octaves::OUT_OUTPUT));

  303. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(35.316, 106.508)), module, Octaves::OUT2_OUTPUT));

  304. 

  305. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(5.247,  120.508)), module, Octaves::OUT_01F_OUTPUT_ALT));

  306. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(15.282, 120.508)), module, Octaves::OUT_02F_OUTPUT_ALT));

  307. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(25.316, 120.508)), module, Octaves::OUT_04F_OUTPUT_ALT));

  308. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(35.35,  120.508)), module, Octaves::OUT_08F_OUTPUT_ALT));

  309. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(45.384, 120.508)), module, Octaves::OUT_16F_OUTPUT_ALT));

  310. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(55.418, 120.508)), module, Octaves::OUT_32F_OUTPUT_ALT));

  311. 

  312. 	}

  313. 

  314. 	void appendContextMenu(Menu* menu) override {

  315. 		Octaves* module = dynamic_cast<Octaves*>(this->module);

  316. 		assert(module);

  317. 

  318. 		menu->addChild(new MenuSeparator());

  319. 		menu->addChild(createSubmenuItem("Hardware compatibility", "",

  320. 		[ = ](Menu * menu) {

  321. 			menu->addChild(createBoolPtrMenuItem("Limit pulsewidth (5\%-95\%)", "", &module->limitPW));

  322. 			menu->addChild(createBoolPtrMenuItem("Remove pulse DC", "", &module->removePulseDC));

  323. 		}

  324. 		                                ));

  325. 

  326. 		menu->addChild(createIndexSubmenuItem("Oversampling",

  327. 		{"Off", "x2", "x4", "x8"},

  328. 		[ = ]() {

  329. 			return module->oversamplingIndex;

  330. 		},

  331. 		[ = ](int mode) {

  332. 			module->oversamplingIndex = mode;

  333. 			module->onSampleRateChange();

  334. 		}

  335. 		                                     ));

  336. 

  337. 		menu->addChild(createBoolPtrMenuItem("Force naive waveforms", "", &module->forceNaive));

  338. 

  339. 

  340. 	}

  341. };

  342. 

  343. 

  344. Model* modelOctaves = createModel<Octaves, OctavesWidget>("Octaves");