DISTRHO
/
DPF-Max-Gen
mirror of https://github.com/DISTRHO/DPF-Max-Gen
1
0
Fork 0
Code Releases 0 Activity
DPF with Max Gen
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.
2 Commits
2 Branches
2.9MB
Tree: fc1fc07b17
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fc1fc07b17'
${ noResults }
DPF-Max-Gen/plugins/Freeverb/gen_exported.cpp

421 lines
13KB
Raw Blame History 

  1. #include "gen_exported.h"

  2. 

  3. namespace gen_exported {

  4. 

  5. 

  6. /*******************************************************************************************************************

  7. Copyright (c) 2012 Cycling '74

  8. 

  9. Permission is hereby granted, free of charge, to any person obtaining a copy of this software

  10. and associated documentation files (the "Software"), to deal in the Software without restriction,

  11. including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,

  12. and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,

  13. subject to the following conditions:

  14. 

  15. The above copyright notice and this permission notice shall be included in all copies

  16. or substantial portions of the Software.

  17. 

  18. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,

  19. INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

  20. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

  21. WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE

  22. OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  23. *******************************************************************************************************************/

  24. 

  25. 

  26. // global noise generator

  27. Noise noise;

  28. static const int GENLIB_LOOPCOUNT_BAIL = 100000;

  29. 

  30. 

  31. // The State struct contains all the state and procedures for the gendsp kernel

  32. typedef struct State { 

  33. 	CommonState __commonstate;

  34. 	Delay m_delay_24;

  35. 	Delay m_delay_15;

  36. 	Delay m_delay_13;

  37. 	Delay m_delay_23;

  38. 	Delay m_delay_9;

  39. 	Delay m_delay_17;

  40. 	Delay m_delay_21;

  41. 	Delay m_delay_19;

  42. 	Delay m_delay_22;

  43. 	Delay m_delay_7;

  44. 	Delay m_delay_11;

  45. 	Delay m_delay_5;

  46. 	double m_history_6;

  47. 	double m_history_18;

  48. 	double m_spread_1;

  49. 	double m_history_20;

  50. 	double samplerate;

  51. 	double m_fb_2;

  52. 	double m_history_8;

  53. 	double m_history_16;

  54. 	double m_history_14;

  55. 	double m_damp_3;

  56. 	double m_history_12;

  57. 	double m_history_10;

  58. 	double m_fb_4;

  59. 	int vectorsize;

  60. 	int __exception;

  61. 	// re-initialize all member variables;

  62. 	inline void reset(double __sr, int __vs) { 

  63. 		__exception = 0;

  64. 		vectorsize = __vs;

  65. 		samplerate = __sr;

  66. 		m_spread_1 = 0;

  67. 		m_fb_2 = 0.9;

  68. 		m_damp_3 = 0.5;

  69. 		m_fb_4 = 0.5;

  70. 		m_delay_5.reset("m_delay_5", 2000);

  71. 		m_history_6 = 0;

  72. 		m_delay_7.reset("m_delay_7", 2000);

  73. 		m_history_8 = 0;

  74. 		m_delay_9.reset("m_delay_9", 2000);

  75. 		m_history_10 = 0;

  76. 		m_delay_11.reset("m_delay_11", 2000);

  77. 		m_history_12 = 0;

  78. 		m_delay_13.reset("m_delay_13", 2000);

  79. 		m_history_14 = 0;

  80. 		m_delay_15.reset("m_delay_15", 2000);

  81. 		m_history_16 = 0;

  82. 		m_delay_17.reset("m_delay_17", 2000);

  83. 		m_history_18 = 0;

  84. 		m_delay_19.reset("m_delay_19", 2000);

  85. 		m_history_20 = 0;

  86. 		m_delay_21.reset("m_delay_21", 2000);

  87. 		m_delay_22.reset("m_delay_22", 2000);

  88. 		m_delay_23.reset("m_delay_23", 2000);

  89. 		m_delay_24.reset("m_delay_24", 2000);

  90. 		genlib_reset_complete(this);

  91. 		

  92. 	};

  93. 	// the signal processing routine;

  94. 	inline int perform(t_sample ** __ins, t_sample ** __outs, int __n) { 

  95. 		vectorsize = __n;

  96. 		const t_sample * __in1 = __ins[0];

  97. 		t_sample * __out1 = __outs[0];

  98. 		if (__exception) { 

  99. 			return __exception;

  100. 			

  101. 		} else if (( (__in1 == 0) || (__out1 == 0) )) { 

  102. 			__exception = GENLIB_ERR_NULL_BUFFER;

  103. 			return __exception;

  104. 			

  105. 		};

  106. 		double mul_498 = (m_fb_4 * 0.5);

  107. 		double add_474 = (225 + m_spread_1);

  108. 		double add_481 = (341 + m_spread_1);

  109. 		double add_496 = (441 + m_spread_1);

  110. 		double add_467 = (556 + m_spread_1);

  111. 		double damp_379 = m_damp_3;

  112. 		double damp_377 = damp_379;

  113. 		double damp_376 = damp_379;

  114. 		double damp_378 = damp_379;

  115. 		double damp_380 = damp_379;

  116. 		double damp_381 = damp_379;

  117. 		double damp_382 = damp_379;

  118. 		double damp_383 = damp_379;

  119. 		double add_489 = (1557 + m_spread_1);

  120. 		double rsub_72 = (1 - damp_377);

  121. 		double add_488 = (1617 + m_spread_1);

  122. 		double rsub_510 = (1 - damp_376);

  123. 		double add_490 = (1491 + m_spread_1);

  124. 		double rsub_522 = (1 - damp_378);

  125. 		double add_491 = (1422 + m_spread_1);

  126. 		double rsub_537 = (1 - damp_379);

  127. 		double add_492 = (1356 + m_spread_1);

  128. 		double rsub_548 = (1 - damp_380);

  129. 		double add_493 = (1277 + m_spread_1);

  130. 		double rsub_561 = (1 - damp_381);

  131. 		double add_494 = (1188 + m_spread_1);

  132. 		double rsub_576 = (1 - damp_382);

  133. 		double add_495 = (1116 + m_spread_1);

  134. 		double rsub_585 = (1 - damp_383);

  135. 		// the main sample loop;

  136. 		while ((__n--)) { 

  137. 			const double in1 = (*(__in1++));

  138. 			double mul_509 = (in1 * 0.015);

  139. 			double tap_79 = m_delay_5.read_linear(add_489);

  140. 			double gen_460 = tap_79;

  141. 			double mul_77 = (tap_79 * damp_377);

  142. 			double mul_75 = (m_history_6 * rsub_72);

  143. 			double add_76 = (mul_77 + mul_75);

  144. 			double mul_73 = (add_76 * m_fb_2);

  145. 			double add_80 = (mul_509 + mul_73);

  146. 			double history_74_next_81 = add_76;

  147. 			double tap_514 = m_delay_7.read_linear(add_488);

  148. 			double gen_508 = tap_514;

  149. 			double mul_518 = (tap_514 * damp_376);

  150. 			double mul_512 = (m_history_8 * rsub_510);

  151. 			double add_513 = (mul_518 + mul_512);

  152. 			double mul_515 = (add_513 * m_fb_2);

  153. 			double add_517 = (mul_509 + mul_515);

  154. 			double history_74_next_516 = add_513;

  155. 			double tap_526 = m_delay_9.read_linear(add_490);

  156. 			double gen_449 = tap_526;

  157. 			double mul_530 = (tap_526 * damp_378);

  158. 			double mul_524 = (m_history_10 * rsub_522);

  159. 			double add_525 = (mul_530 + mul_524);

  160. 			double mul_527 = (add_525 * m_fb_2);

  161. 			double add_529 = (mul_509 + mul_527);

  162. 			double history_74_next_528 = add_525;

  163. 			double tap_539 = m_delay_11.read_linear(add_491);

  164. 			double gen_438 = tap_539;

  165. 			double mul_536 = (tap_539 * damp_379);

  166. 			double mul_535 = (m_history_12 * rsub_537);

  167. 			double add_538 = (mul_536 + mul_535);

  168. 			double mul_540 = (add_538 * m_fb_2);

  169. 			double add_541 = (mul_509 + mul_540);

  170. 			double history_74_next_543 = add_538;

  171. 			double tap_550 = m_delay_13.read_linear(add_492);

  172. 			double gen_427 = tap_550;

  173. 			double mul_547 = (tap_550 * damp_380);

  174. 			double mul_546 = (m_history_14 * rsub_548);

  175. 			double add_549 = (mul_547 + mul_546);

  176. 			double mul_551 = (add_549 * m_fb_2);

  177. 			double add_553 = (mul_509 + mul_551);

  178. 			double history_74_next_555 = add_549;

  179. 			double tap_563 = m_delay_15.read_linear(add_493);

  180. 			double gen_416 = tap_563;

  181. 			double mul_560 = (tap_563 * damp_381);

  182. 			double mul_559 = (m_history_16 * rsub_561);

  183. 			double add_562 = (mul_560 + mul_559);

  184. 			double mul_564 = (add_562 * m_fb_2);

  185. 			double add_565 = (mul_509 + mul_564);

  186. 			double history_74_next_566 = add_562;

  187. 			double tap_574 = m_delay_17.read_linear(add_494);

  188. 			double gen_405 = tap_574;

  189. 			double mul_572 = (tap_574 * damp_382);

  190. 			double mul_571 = (m_history_18 * rsub_576);

  191. 			double add_573 = (mul_572 + mul_571);

  192. 			double mul_575 = (add_573 * m_fb_2);

  193. 			double add_577 = (mul_509 + mul_575);

  194. 			double history_74_next_579 = add_573;

  195. 			double tap_587 = m_delay_19.read_linear(add_495);

  196. 			double gen_394 = tap_587;

  197. 			double mul_584 = (tap_587 * damp_383);

  198. 			double mul_583 = (m_history_20 * rsub_585);

  199. 			double add_586 = (mul_584 + mul_583);

  200. 			double mul_588 = (add_586 * m_fb_2);

  201. 			double add_589 = (mul_509 + mul_588);

  202. 			double history_74_next_591 = add_586;

  203. 			double add_497 = ((((((((gen_394 + gen_405) + gen_416) + gen_427) + gen_438) + gen_449) + gen_508) + gen_460) + 0);

  204. 			double tap_60 = m_delay_21.read_linear(add_467);

  205. 			double sub_56 = (add_497 - tap_60);

  206. 			double mul_58 = (tap_60 * mul_498);

  207. 			double add_57 = (add_497 + mul_58);

  208. 			double tap_597 = m_delay_22.read_linear(add_496);

  209. 			double sub_594 = (sub_56 - tap_597);

  210. 			double mul_596 = (tap_597 * mul_498);

  211. 			double add_598 = (sub_56 + mul_596);

  212. 			double tap_603 = m_delay_23.read_linear(add_481);

  213. 			double sub_600 = (sub_594 - tap_603);

  214. 			double mul_602 = (tap_603 * mul_498);

  215. 			double add_604 = (sub_594 + mul_602);

  216. 			double tap_608 = m_delay_24.read_linear(add_474);

  217. 			double sub_606 = (sub_600 - tap_608);

  218. 			double mul_609 = (tap_608 * mul_498);

  219. 			double add_610 = (sub_600 + mul_609);

  220. 			double out1 = sub_606;

  221. 			m_delay_5.write(add_80);

  222. 			m_delay_24.write(add_610);

  223. 			m_delay_23.write(add_604);

  224. 			m_delay_22.write(add_598);

  225. 			m_delay_21.write(add_57);

  226. 			m_history_20 = history_74_next_591;

  227. 			m_delay_19.write(add_589);

  228. 			m_history_18 = history_74_next_579;

  229. 			m_delay_17.write(add_577);

  230. 			m_history_16 = history_74_next_566;

  231. 			m_delay_15.write(add_565);

  232. 			m_history_14 = history_74_next_555;

  233. 			m_delay_13.write(add_553);

  234. 			m_history_12 = history_74_next_543;

  235. 			m_delay_11.write(add_541);

  236. 			m_history_10 = history_74_next_528;

  237. 			m_delay_9.write(add_529);

  238. 			m_history_8 = history_74_next_516;

  239. 			m_delay_7.write(add_517);

  240. 			m_history_6 = history_74_next_81;

  241. 			m_delay_5.step();

  242. 			m_delay_7.step();

  243. 			m_delay_9.step();

  244. 			m_delay_11.step();

  245. 			m_delay_13.step();

  246. 			m_delay_15.step();

  247. 			m_delay_17.step();

  248. 			m_delay_19.step();

  249. 			m_delay_21.step();

  250. 			m_delay_22.step();

  251. 			m_delay_23.step();

  252. 			m_delay_24.step();

  253. 			// assign results to output buffer;

  254. 			(*(__out1++)) = out1;

  255. 			

  256. 		};

  257. 		return __exception;

  258. 		

  259. 	};

  260. 	inline void set_spread(double _value) {

  261. 		m_spread_1 = (_value < 0 ? 0 : (_value > 400 ? 400 : _value));

  262. 	};

  263. 	inline void set_fb1(double _value) {

  264. 		m_fb_2 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  265. 	};

  266. 	inline void set_damp(double _value) {

  267. 		m_damp_3 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  268. 	};

  269. 	inline void set_fb2(double _value) {

  270. 		m_fb_4 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  271. 	};

  272. 	

  273. } State;

  274. 

  275. 

  276. /// 

  277. ///	Configuration for the genlib API

  278. ///

  279. 

  280. /// Number of signal inputs and outputs 

  281. 

  282. int gen_kernel_numins = 1;

  283. int gen_kernel_numouts = 1;

  284. 

  285. int num_inputs() { return gen_kernel_numins; }

  286. int num_outputs() { return gen_kernel_numouts; }

  287. int num_params() { return 4; }

  288. 

  289. /// Assistive lables for the signal inputs and outputs 

  290. 

  291. const char * gen_kernel_innames[] = { "in1" };

  292. const char * gen_kernel_outnames[] = { "out1" };

  293. 

  294. /// Invoke the signal process of a State object

  295. 

  296. int perform(CommonState *cself, t_sample **ins, long numins, t_sample **outs, long numouts, long n) { 

  297. 	State * self = (State *)cself;

  298. 	return self->perform(ins, outs, n);

  299. }

  300. 

  301. /// Reset all parameters and stateful operators of a State object

  302. 

  303. void reset(CommonState *cself) { 

  304. 	State * self = (State *)cself;

  305. 	self->reset(cself->sr, cself->vs); 

  306. }

  307. 

  308. /// Set a parameter of a State object 

  309. 

  310. void setparameter(CommonState *cself, long index, double value, void *ref) {

  311. 	State * self = (State *)cself;

  312. 	switch (index) {

  313. 		case 0: self->set_spread(value); break;

  314. 		case 1: self->set_fb1(value); break;

  315. 		case 2: self->set_damp(value); break;

  316. 		case 3: self->set_fb2(value); break;

  317. 		

  318. 		default: break;

  319. 	}

  320. }

  321. 

  322. /// Get the value of a parameter of a State object 

  323. 

  324. void getparameter(CommonState *cself, long index, double *value) {

  325. 	State *self = (State *)cself;

  326. 	switch (index) {

  327. 		case 0: *value = self->m_spread_1; break;

  328. 		case 1: *value = self->m_fb_2; break;

  329. 		case 2: *value = self->m_damp_3; break;

  330. 		case 3: *value = self->m_fb_4; break;

  331. 		

  332. 		default: break;

  333. 	}

  334. }

  335. 

  336. /// Allocate and configure a new State object and it's internal CommonState:

  337. 

  338. void * create(double sr, long vs) {

  339. 	State *self = new State;

  340. 	self->reset(sr, vs);

  341. 	ParamInfo *pi;

  342. 	self->__commonstate.inputnames = gen_kernel_innames;

  343. 	self->__commonstate.outputnames = gen_kernel_outnames;

  344. 	self->__commonstate.numins = gen_kernel_numins;

  345. 	self->__commonstate.numouts = gen_kernel_numouts;

  346. 	self->__commonstate.sr = sr;

  347. 	self->__commonstate.vs = vs;

  348. 	self->__commonstate.params = (ParamInfo *)genlib_sysmem_newptr(4 * sizeof(ParamInfo));

  349. 	self->__commonstate.numparams = 4;

  350. 	// initialize parameter 0 ("m_spread_1")

  351. 	pi = self->__commonstate.params + 0;

  352. 	pi->name = "spread";

  353. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  354. 	pi->defaultvalue = self->m_spread_1;

  355. 	pi->defaultref = 0;

  356. 	pi->hasinputminmax = false;

  357. 	pi->inputmin = 0; 

  358. 	pi->inputmax = 1;

  359. 	pi->hasminmax = true;

  360. 	pi->outputmin = 0;

  361. 	pi->outputmax = 400;

  362. 	pi->exp = 0;

  363. 	pi->units = "";		// no units defined

  364. 	// initialize parameter 1 ("m_fb_2")

  365. 	pi = self->__commonstate.params + 1;

  366. 	pi->name = "fb1";

  367. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  368. 	pi->defaultvalue = self->m_fb_2;

  369. 	pi->defaultref = 0;

  370. 	pi->hasinputminmax = false;

  371. 	pi->inputmin = 0; 

  372. 	pi->inputmax = 1;

  373. 	pi->hasminmax = true;

  374. 	pi->outputmin = 0;

  375. 	pi->outputmax = 1;

  376. 	pi->exp = 0;

  377. 	pi->units = "";		// no units defined

  378. 	// initialize parameter 2 ("m_damp_3")

  379. 	pi = self->__commonstate.params + 2;

  380. 	pi->name = "damp";

  381. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  382. 	pi->defaultvalue = self->m_damp_3;

  383. 	pi->defaultref = 0;

  384. 	pi->hasinputminmax = false;

  385. 	pi->inputmin = 0; 

  386. 	pi->inputmax = 1;

  387. 	pi->hasminmax = true;

  388. 	pi->outputmin = 0;

  389. 	pi->outputmax = 1;

  390. 	pi->exp = 0;

  391. 	pi->units = "";		// no units defined

  392. 	// initialize parameter 3 ("m_fb_4")

  393. 	pi = self->__commonstate.params + 3;

  394. 	pi->name = "fb2";

  395. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  396. 	pi->defaultvalue = self->m_fb_4;

  397. 	pi->defaultref = 0;

  398. 	pi->hasinputminmax = false;

  399. 	pi->inputmin = 0; 

  400. 	pi->inputmax = 1;

  401. 	pi->hasminmax = true;

  402. 	pi->outputmin = 0;

  403. 	pi->outputmax = 1;

  404. 	pi->exp = 0;

  405. 	pi->units = "";		// no units defined

  406. 	

  407. 	return self;

  408. }

  409. 

  410. /// Release all resources and memory used by a State object:

  411. 

  412. void destroy(CommonState *cself) { 

  413. 	State * self = (State *)cself;

  414. 	genlib_sysmem_freeptr(cself->params);

  415. 		

  416. 	delete self; 

  417. }

  418. 

  419. 

  420. } // freeverb::