DISTRHO
/
DPF-Plugins
mirror of https://github.com/DISTRHO/DPF-Plugins
1
0
Fork 0
Code Releases 8 Activity
Collection of DPF-based plugins for packaging
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.
36 Commits
1 Branch
86MB
Tree: b91b3dc60f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b91b3dc60f'
${ noResults }
DPF-Plugins/plugins/shiroverb/gen_exported.cpp

799 lines
26KB
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_14;

  35. 	Delay m_delay_18;

  36. 	Delay m_delay_19;

  37. 	Delay m_delay_15;

  38. 	Delay m_delay_12;

  39. 	Delay m_delay_17;

  40. 	Delay m_delay_13;

  41. 	Delay m_delay_21;

  42. 	Delay m_delay_20;

  43. 	Delay m_delay_22;

  44. 	Delay m_delay_24;

  45. 	Delay m_delay_23;

  46. 	Delay m_delay_16;

  47. 	Delta m_delta_43;

  48. 	Delta m_delta_49;

  49. 	Delta m_delta_46;

  50. 	Delta m_delta_40;

  51. 	Phasor m_phasor_39;

  52. 	Sah m_sah_50;

  53. 	Sah m_sah_51;

  54. 	Sah m_sah_47;

  55. 	Sah m_sah_48;

  56. 	Sah m_sah_45;

  57. 	Sah m_sah_42;

  58. 	Sah m_sah_44;

  59. 	Sah m_sah_41;

  60. 	double m_roomsize_34;

  61. 	double m_tail_35;

  62. 	double m_blur_36;

  63. 	double m_damping_38;

  64. 	double m_shimmer_33;

  65. 	double m_decay_37;

  66. 	double samples_to_seconds;

  67. 	double m_early_32;

  68. 	double m_ratio_25;

  69. 	double m_spread_30;

  70. 	double m_history_4;

  71. 	double m_history_5;

  72. 	double m_history_6;

  73. 	double m_history_3;

  74. 	double m_history_1;

  75. 	double m_y_2;

  76. 	double samplerate;

  77. 	double m_cutoff_31;

  78. 	double m_history_7;

  79. 	double m_history_9;

  80. 	double m_tone_28;

  81. 	double m_mix_29;

  82. 	double m_history_8;

  83. 	double m_resonance_27;

  84. 	double m_y_11;

  85. 	double m_history_10;

  86. 	double m_window_26;

  87. 	int vectorsize;

  88. 	int __exception;

  89. 	// re-initialize all member variables;

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

  91. 		__exception = 0;

  92. 		vectorsize = __vs;

  93. 		samplerate = __sr;

  94. 		m_history_1 = 0;

  95. 		m_y_2 = 0;

  96. 		m_history_3 = 0;

  97. 		m_history_4 = 0;

  98. 		m_history_5 = 0;

  99. 		m_history_6 = 0;

  100. 		m_history_7 = 0;

  101. 		m_history_8 = 0;

  102. 		m_history_9 = 0;

  103. 		m_history_10 = 0;

  104. 		m_y_11 = 0;

  105. 		m_delay_12.reset("m_delay_12", 5000);

  106. 		m_delay_13.reset("m_delay_13", 7000);

  107. 		m_delay_14.reset("m_delay_14", 15000);

  108. 		m_delay_15.reset("m_delay_15", 16000);

  109. 		m_delay_16.reset("m_delay_16", 6000);

  110. 		m_delay_17.reset("m_delay_17", 48000);

  111. 		m_delay_18.reset("m_delay_18", 96000);

  112. 		m_delay_19.reset("m_delay_19", 10000);

  113. 		m_delay_20.reset("m_delay_20", 12000);

  114. 		m_delay_21.reset("m_delay_21", 48000);

  115. 		m_delay_22.reset("m_delay_22", 48000);

  116. 		m_delay_23.reset("m_delay_23", 48000);

  117. 		m_delay_24.reset("m_delay_24", 48000);

  118. 		m_ratio_25 = 2;

  119. 		m_window_26 = 100;

  120. 		m_resonance_27 = 0;

  121. 		m_tone_28 = 0.5;

  122. 		m_mix_29 = 0.5;

  123. 		m_spread_30 = 25;

  124. 		m_cutoff_31 = 3000;

  125. 		m_early_32 = 0.25;

  126. 		m_shimmer_33 = 0.5;

  127. 		m_roomsize_34 = 150;

  128. 		m_tail_35 = 0.25;

  129. 		m_blur_36 = 0.25;

  130. 		m_decay_37 = 180;

  131. 		m_damping_38 = 0.75;

  132. 		samples_to_seconds = (1 / samplerate);

  133. 		m_phasor_39.reset(0);

  134. 		m_delta_40.reset(0);

  135. 		m_sah_41.reset(0);

  136. 		m_sah_42.reset(0);

  137. 		m_delta_43.reset(0);

  138. 		m_sah_44.reset(0);

  139. 		m_sah_45.reset(0);

  140. 		m_delta_46.reset(0);

  141. 		m_sah_47.reset(0);

  142. 		m_sah_48.reset(0);

  143. 		m_delta_49.reset(0);

  144. 		m_sah_50.reset(0);

  145. 		m_sah_51.reset(0);

  146. 		genlib_reset_complete(this);

  147. 		

  148. 	};

  149. 	// the signal processing routine;

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

  151. 		vectorsize = __n;

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

  153. 		t_sample * __out1 = __outs[0];

  154. 		t_sample * __out2 = __outs[1];

  155. 		if (__exception) { 

  156. 			return __exception;

  157. 			

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

  159. 			__exception = GENLIB_ERR_NULL_BUFFER;

  160. 			return __exception;

  161. 			

  162. 		};

  163. 		double rsub_552 = (1 - m_tone_28);

  164. 		double expr_1476 = safepow(0.001, safediv(1, (m_decay_37 * 44100)));

  165. 		double expr_1477 = safediv((m_roomsize_34 * 44100), 340);

  166. 		double mul_542 = (expr_1477 * 0.7071);

  167. 		double expr_1469 = (-safepow(expr_1476, mul_542));

  168. 		double mul_541 = (expr_1477 * 0.63245);

  169. 		double expr_1468 = (-safepow(expr_1476, mul_541));

  170. 		double mul_543 = (expr_1477 * 0.81649);

  171. 		double expr_1470 = (-safepow(expr_1476, mul_543));

  172. 		double mul_544 = (expr_1477 * 1);

  173. 		double expr_1475 = (-safepow(expr_1476, mul_544));

  174. 		double expr_1478 = safediv(((m_cutoff_31 * 2) * 3.1415926535898), 44100);

  175. 		double cos_1010 = cos(expr_1478);

  176. 		double mul_1012 = (m_resonance_27 * 0.125);

  177. 		double exp_1013 = exp(mul_1012);

  178. 		double mul_1011 = (exp_1013 * 0.882497);

  179. 		double mul_1007 = (mul_1011 * mul_1011);

  180. 		double mul_1009 = (cos_1010 * mul_1011);

  181. 		double mul_1008 = (mul_1009 * -2);

  182. 		double add_1006 = ((mul_1007 + mul_1008) + 1);

  183. 		double mul_538 = (expr_1477 * 0.000527);

  184. 		int int_537 = int(mul_538);

  185. 		double mstosamps_963 = (m_window_26 * (samplerate * 0.001));

  186. 		double add_467 = (expr_1477 + 5);

  187. 		double expr_1471 = safepow(expr_1476, add_467);

  188. 		double mul_478 = (m_spread_30 * -0.380445);

  189. 		double add_477 = (mul_478 + 931);

  190. 		double rsub_474 = (1341 - add_477);

  191. 		double mul_487 = (int_537 * rsub_474);

  192. 		double mul_506 = (m_spread_30 * 0.376623);

  193. 		double add_505 = (mul_506 + 931);

  194. 		double rsub_502 = (1341 - add_505);

  195. 		double mul_513 = (int_537 * rsub_502);

  196. 		double rsub_950 = (1 - m_ratio_25);

  197. 		double mul_949 = (rsub_950 * 1000);

  198. 		double div_948 = safediv(mul_949, m_window_26);

  199. 		samples_to_seconds = (1 / samplerate);

  200. 		double mul_473 = (expr_1477 * 0.41);

  201. 		double add_470 = (mul_473 + 5);

  202. 		double expr_1474 = safepow(expr_1476, add_470);

  203. 		double mul_472 = (expr_1477 * 0.3);

  204. 		double add_469 = (mul_472 + 5);

  205. 		double expr_1473 = safepow(expr_1476, add_469);

  206. 		double mul_471 = (expr_1477 * 0.155);

  207. 		double add_468 = (mul_471 + 5);

  208. 		double expr_1472 = safepow(expr_1476, add_468);

  209. 		double mul_536 = (expr_1477 * 0.110732);

  210. 		double mul_480 = (m_spread_30 * -0.568366);

  211. 		double add_476 = (mul_480 + 369);

  212. 		double rsub_475 = (add_477 - add_476);

  213. 		double mul_494 = (int_537 * rsub_475);

  214. 		double mul_522 = (m_spread_30 * 0.125541);

  215. 		double add_504 = (mul_522 + 369);

  216. 		double rsub_503 = (add_505 - add_504);

  217. 		double mul_520 = (int_537 * rsub_503);

  218. 		double add_479 = (mul_480 + 159);

  219. 		double mul_501 = (int_537 * add_479);

  220. 		double add_521 = (mul_522 + 159);

  221. 		double mul_529 = (int_537 * add_521);

  222. 		// the main sample loop;

  223. 		while ((__n--)) { 

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

  225. 			double noise_900 = noise();

  226. 			double abs_917 = fabs(noise_900);

  227. 			double mul_921 = (abs_917 * m_blur_36);

  228. 			double noise_902 = noise();

  229. 			double abs_919 = fabs(noise_902);

  230. 			double mul_927 = (abs_919 * m_blur_36);

  231. 			double noise_903 = noise();

  232. 			double abs_920 = fabs(noise_903);

  233. 			double mul_930 = (abs_920 * m_blur_36);

  234. 			double noise_901 = noise();

  235. 			double abs_918 = fabs(noise_901);

  236. 			double mul_924 = (abs_918 * m_blur_36);

  237. 			double tap_447 = m_delay_24.read_linear(mul_542);

  238. 			double mul_443 = (tap_447 * expr_1469);

  239. 			double mix_1521 = (mul_443 + (m_damping_38 * (m_history_10 - mul_443)));

  240. 			double mix_445 = mix_1521;

  241. 			double tap_441 = m_delay_23.read_linear(mul_541);

  242. 			double mul_437 = (tap_441 * expr_1468);

  243. 			double mix_1522 = (mul_437 + (m_damping_38 * (m_history_9 - mul_437)));

  244. 			double mix_439 = mix_1522;

  245. 			double tap_453 = m_delay_22.read_linear(mul_543);

  246. 			double mul_449 = (tap_453 * expr_1470);

  247. 			double mix_1523 = (mul_449 + (m_damping_38 * (m_history_8 - mul_449)));

  248. 			double mix_451 = mix_1523;

  249. 			double tap_549 = m_delay_21.read_linear(mul_544);

  250. 			double mul_540 = (tap_549 * expr_1475);

  251. 			double mix_1524 = (mul_540 + (m_damping_38 * (m_history_7 - mul_540)));

  252. 			double mix_547 = mix_1524;

  253. 			double mul_1003 = (mul_1007 * m_y_11);

  254. 			double mul_1004 = (mul_1008 * m_y_2);

  255. 			double add_431 = (mix_547 + mix_451);

  256. 			double add_429 = (mix_445 + mix_439);

  257. 			double add_424 = (add_431 + add_429);

  258. 			double mul_407 = (add_424 * 0.5);

  259. 			double sub_428 = (add_431 - add_429);

  260. 			double mul_410 = (sub_428 * 0.5);

  261. 			double sub_430 = (mix_547 - mix_451);

  262. 			double sub_427 = (mix_445 - mix_439);

  263. 			double sub_426 = (sub_430 - sub_427);

  264. 			double mul_409 = (sub_426 * 0.5);

  265. 			double add_425 = (sub_430 + sub_427);

  266. 			double rsub_423 = (0 - add_425);

  267. 			double mul_408 = (rsub_423 * 0.5);

  268. 			double tap_486 = m_delay_20.read_linear(mul_487);

  269. 			double mul_484 = (tap_486 * 0.625);

  270. 			double tap_512 = m_delay_19.read_linear(mul_513);

  271. 			double mul_510 = (tap_512 * 0.625);

  272. 			double phasor_969 = m_phasor_39(div_948, samples_to_seconds);

  273. 			double add_941 = ((phasor_969 + m_history_6) + 0.75);

  274. 			double mod_940 = safemod(add_941, 1);

  275. 			double delta_923 = m_delta_40(mod_940);

  276. 			double sah_904 = m_sah_41(mul_921, delta_923, 0);

  277. 			double sah_922 = m_sah_42(mstosamps_963, delta_923, 0);

  278. 			double mul_913 = (sah_922 * mod_940);

  279. 			double sub_939 = (mod_940 - 0.5);

  280. 			double mul_938 = (sub_939 * 3.1415926535898);

  281. 			double cos_937 = cos(mul_938);

  282. 			double mul_932 = (cos_937 * cos_937);

  283. 			double add_962 = ((phasor_969 + m_history_5) + 0.25);

  284. 			double mod_961 = safemod(add_962, 1);

  285. 			double delta_929 = m_delta_43(mod_961);

  286. 			double sah_908 = m_sah_44(mul_927, delta_929, 0);

  287. 			double sah_928 = m_sah_45(mstosamps_963, delta_929, 0);

  288. 			double mul_915 = (sah_928 * mod_961);

  289. 			double sub_960 = (mod_961 - 0.5);

  290. 			double mul_959 = (sub_960 * 3.1415926535898);

  291. 			double cos_958 = cos(mul_959);

  292. 			double mul_934 = (cos_958 * cos_958);

  293. 			double add_968 = ((phasor_969 + m_history_4) + 0);

  294. 			double mod_967 = safemod(add_968, 1);

  295. 			double delta_911 = m_delta_46(mod_967);

  296. 			double sah_910 = m_sah_47(mul_930, delta_911, 0);

  297. 			double sah_931 = m_sah_48(mstosamps_963, delta_911, 0);

  298. 			double mul_916 = (sah_931 * mod_967);

  299. 			double sub_966 = (mod_967 - 0.5);

  300. 			double mul_965 = (sub_966 * 3.1415926535898);

  301. 			double cos_964 = cos(mul_965);

  302. 			double mul_935 = (cos_964 * cos_964);

  303. 			double add_947 = ((phasor_969 + m_history_3) + 0.5);

  304. 			double mod_946 = safemod(add_947, 1);

  305. 			double delta_926 = m_delta_49(mod_946);

  306. 			double sah_906 = m_sah_50(mul_924, delta_926, 0);

  307. 			double sah_925 = m_sah_51(mstosamps_963, delta_926, 0);

  308. 			double mul_914 = (sah_925 * mod_946);

  309. 			double tap_954 = m_delay_18.read_linear(mul_916);

  310. 			double tap_955 = m_delay_18.read_linear(mul_915);

  311. 			double tap_956 = m_delay_18.read_linear(mul_914);

  312. 			double tap_957 = m_delay_18.read_linear(mul_913);

  313. 			double mul_952 = (tap_954 * mul_935);

  314. 			double mul_951 = (tap_955 * mul_934);

  315. 			double mul_936 = (tap_957 * mul_932);

  316. 			double sub_945 = (mod_946 - 0.5);

  317. 			double mul_944 = (sub_945 * 3.1415926535898);

  318. 			double cos_943 = cos(mul_944);

  319. 			double mul_933 = (cos_943 * cos_943);

  320. 			double mul_942 = (tap_956 * mul_933);

  321. 			double mul_1005 = ((((mul_936 + mul_942) + mul_951) + mul_952) * add_1006);

  322. 			double sub_1002 = (mul_1005 - (mul_1003 + mul_1004));

  323. 			double mix_1525 = (in1 + (m_shimmer_33 * (sub_1002 - in1)));

  324. 			double mix_341 = mix_1525;

  325. 			double mul_401 = (mix_341 * 0.707);

  326. 			double mix_1526 = (mul_401 + (rsub_552 * (m_history_1 - mul_401)));

  327. 			double mix_551 = mix_1526;

  328. 			double tap_455 = m_delay_17.read_linear(add_470);

  329. 			double tap_456 = m_delay_17.read_linear(add_469);

  330. 			double tap_457 = m_delay_17.read_linear(add_468);

  331. 			double tap_458 = m_delay_17.read_linear(add_467);

  332. 			double mul_459 = (tap_458 * expr_1471);

  333. 			double add_432 = (mul_407 + mul_459);

  334. 			double mul_463 = (tap_456 * expr_1473);

  335. 			double add_434 = (mul_409 + mul_463);

  336. 			double mul_465 = (tap_455 * expr_1474);

  337. 			double add_435 = (mul_410 + mul_465);

  338. 			double mul_461 = (tap_457 * expr_1472);

  339. 			double add_433 = (mul_408 + mul_461);

  340. 			double tap_535 = m_delay_16.read_linear(mul_536);

  341. 			double mul_533 = (tap_535 * 0.75);

  342. 			double sub_532 = (mix_551 - mul_533);

  343. 			double mul_531 = (sub_532 * 0.75);

  344. 			double add_530 = (mul_531 + tap_535);

  345. 			double tap_493 = m_delay_15.read_linear(mul_494);

  346. 			double mul_491 = (tap_493 * 0.625);

  347. 			double tap_519 = m_delay_14.read_linear(mul_520);

  348. 			double mul_517 = (tap_519 * 0.625);

  349. 			double tap_500 = m_delay_13.read_linear(mul_501);

  350. 			double mul_498 = (tap_500 * 0.75);

  351. 			double tap_528 = m_delay_12.read_linear(mul_529);

  352. 			double mul_526 = (tap_528 * 0.75);

  353. 			double mul_422 = (mul_410 * m_tail_35);

  354. 			double mul_420 = (mul_408 * m_tail_35);

  355. 			double add_406 = (mul_422 + mul_420);

  356. 			double mul_421 = (mul_409 * m_tail_35);

  357. 			double mul_419 = (mul_407 * m_tail_35);

  358. 			double add_405 = (mul_421 + mul_419);

  359. 			double sub_414 = (add_406 - add_405);

  360. 			double mul_418 = (mul_465 * m_early_32);

  361. 			double mul_416 = (mul_461 * m_early_32);

  362. 			double add_404 = (mul_418 + mul_416);

  363. 			double mul_417 = (mul_463 * m_early_32);

  364. 			double mul_415 = (mul_459 * m_early_32);

  365. 			double add_403 = (mul_417 + mul_415);

  366. 			double sub_413 = (add_404 - add_403);

  367. 			double add_400 = (sub_414 + sub_413);

  368. 			double add_402 = (add_400 + mix_341);

  369. 			double sub_497 = (add_402 - mul_498);

  370. 			double mul_496 = (sub_497 * 0.75);

  371. 			double add_495 = (mul_496 + tap_500);

  372. 			double sub_490 = (add_495 - mul_491);

  373. 			double mul_489 = (sub_490 * 0.625);

  374. 			double add_488 = (mul_489 + tap_493);

  375. 			double sub_483 = (add_488 - mul_484);

  376. 			double mul_482 = (sub_483 * 0.625);

  377. 			double add_481 = (mul_482 + tap_486);

  378. 			double mul_1327 = (add_481 * m_mix_29);

  379. 			double out2 = (mul_1327 + in1);

  380. 			double add_412 = (add_400 + mix_341);

  381. 			double sub_525 = (add_412 - mul_526);

  382. 			double mul_524 = (sub_525 * 0.75);

  383. 			double add_523 = (mul_524 + tap_528);

  384. 			double sub_516 = (add_523 - mul_517);

  385. 			double mul_515 = (sub_516 * 0.625);

  386. 			double add_514 = (mul_515 + tap_519);

  387. 			double sub_509 = (add_514 - mul_510);

  388. 			double mul_508 = (sub_509 * 0.625);

  389. 			double add_507 = (mul_508 + tap_512);

  390. 			double mul_411 = (add_507 * m_mix_29);

  391. 			double out1 = (in1 + mul_411);

  392. 			double y2_next_1492 = m_y_2;

  393. 			double history_444_next_1493 = mix_445;

  394. 			double history_438_next_1494 = mix_439;

  395. 			double history_450_next_1495 = mix_451;

  396. 			double history_546_next_1496 = mix_547;

  397. 			double history_905_next_1497 = sah_904;

  398. 			double history_909_next_1498 = sah_908;

  399. 			double history_912_next_1499 = sah_910;

  400. 			double history_907_next_1500 = sah_906;

  401. 			double y1_next_1501 = sub_1002;

  402. 			double history_550_next_1502 = mix_551;

  403. 			m_delay_24.write(add_433);

  404. 			m_delay_23.write(add_432);

  405. 			m_delay_22.write(add_434);

  406. 			m_delay_21.write(add_435);

  407. 			m_delay_20.write(sub_483);

  408. 			m_delay_19.write(sub_509);

  409. 			m_delay_18.write(in1);

  410. 			m_delay_17.write(add_530);

  411. 			m_delay_16.write(sub_532);

  412. 			m_delay_15.write(sub_490);

  413. 			m_delay_14.write(sub_516);

  414. 			m_delay_13.write(sub_497);

  415. 			m_delay_12.write(sub_525);

  416. 			m_y_11 = y2_next_1492;

  417. 			m_history_10 = history_444_next_1493;

  418. 			m_history_9 = history_438_next_1494;

  419. 			m_history_8 = history_450_next_1495;

  420. 			m_history_7 = history_546_next_1496;

  421. 			m_history_6 = history_905_next_1497;

  422. 			m_history_5 = history_909_next_1498;

  423. 			m_history_4 = history_912_next_1499;

  424. 			m_history_3 = history_907_next_1500;

  425. 			m_y_2 = y1_next_1501;

  426. 			m_history_1 = history_550_next_1502;

  427. 			m_delay_12.step();

  428. 			m_delay_13.step();

  429. 			m_delay_14.step();

  430. 			m_delay_15.step();

  431. 			m_delay_16.step();

  432. 			m_delay_17.step();

  433. 			m_delay_18.step();

  434. 			m_delay_19.step();

  435. 			m_delay_20.step();

  436. 			m_delay_21.step();

  437. 			m_delay_22.step();

  438. 			m_delay_23.step();

  439. 			m_delay_24.step();

  440. 			// assign results to output buffer;

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

  442. 			(*(__out2++)) = out2;

  443. 			

  444. 		};

  445. 		return __exception;

  446. 		

  447. 	};

  448. 	inline void set_ratio(double _value) {

  449. 		m_ratio_25 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  450. 	};

  451. 	inline void set_window(double _value) {

  452. 		m_window_26 = (_value < 0.1 ? 0.1 : (_value > 1000 ? 1000 : _value));

  453. 	};

  454. 	inline void set_resonance(double _value) {

  455. 		m_resonance_27 = (_value < 0 ? 0 : (_value > 0.25 ? 0.25 : _value));

  456. 	};

  457. 	inline void set_tone(double _value) {

  458. 		m_tone_28 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  459. 	};

  460. 	inline void set_mix(double _value) {

  461. 		m_mix_29 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  462. 	};

  463. 	inline void set_spread(double _value) {

  464. 		m_spread_30 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  465. 	};

  466. 	inline void set_cutoff(double _value) {

  467. 		m_cutoff_31 = (_value < 0 ? 0 : (_value > 6000 ? 6000 : _value));

  468. 	};

  469. 	inline void set_early(double _value) {

  470. 		m_early_32 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  471. 	};

  472. 	inline void set_shimmer(double _value) {

  473. 		m_shimmer_33 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  474. 	};

  475. 	inline void set_roomsize(double _value) {

  476. 		m_roomsize_34 = (_value < 0.1 ? 0.1 : (_value > 300 ? 300 : _value));

  477. 	};

  478. 	inline void set_tail(double _value) {

  479. 		m_tail_35 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  480. 	};

  481. 	inline void set_blur(double _value) {

  482. 		m_blur_36 = (_value < 0.01 ? 0.01 : (_value > 0.25 ? 0.25 : _value));

  483. 	};

  484. 	inline void set_decay(double _value) {

  485. 		m_decay_37 = (_value < 0.1 ? 0.1 : (_value > 360 ? 360 : _value));

  486. 	};

  487. 	inline void set_damping(double _value) {

  488. 		m_damping_38 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  489. 	};

  490. 	

  491. } State;

  492. 

  493. 

  494. /// 

  495. ///	Configuration for the genlib API

  496. ///

  497. 

  498. /// Number of signal inputs and outputs 

  499. 

  500. int gen_kernel_numins = 1;

  501. int gen_kernel_numouts = 2;

  502. 

  503. int num_inputs() { return gen_kernel_numins; }

  504. int num_outputs() { return gen_kernel_numouts; }

  505. int num_params() { return 14; }

  506. 

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

  508. 

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

  510. const char * gen_kernel_outnames[] = { "out1", "out2" };

  511. 

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

  513. 

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

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

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

  517. }

  518. 

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

  520. 

  521. void reset(CommonState *cself) { 

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

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

  524. }

  525. 

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

  527. 

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

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

  530. 	switch (index) {

  531. 		case 0: self->set_ratio(value); break;

  532. 		case 1: self->set_window(value); break;

  533. 		case 2: self->set_resonance(value); break;

  534. 		case 3: self->set_tone(value); break;

  535. 		case 4: self->set_mix(value); break;

  536. 		case 5: self->set_spread(value); break;

  537. 		case 6: self->set_cutoff(value); break;

  538. 		case 7: self->set_early(value); break;

  539. 		case 8: self->set_shimmer(value); break;

  540. 		case 9: self->set_roomsize(value); break;

  541. 		case 10: self->set_tail(value); break;

  542. 		case 11: self->set_blur(value); break;

  543. 		case 12: self->set_decay(value); break;

  544. 		case 13: self->set_damping(value); break;

  545. 		

  546. 		default: break;

  547. 	}

  548. }

  549. 

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

  551. 

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

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

  554. 	switch (index) {

  555. 		case 0: *value = self->m_ratio_25; break;

  556. 		case 1: *value = self->m_window_26; break;

  557. 		case 2: *value = self->m_resonance_27; break;

  558. 		case 3: *value = self->m_tone_28; break;

  559. 		case 4: *value = self->m_mix_29; break;

  560. 		case 5: *value = self->m_spread_30; break;

  561. 		case 6: *value = self->m_cutoff_31; break;

  562. 		case 7: *value = self->m_early_32; break;

  563. 		case 8: *value = self->m_shimmer_33; break;

  564. 		case 9: *value = self->m_roomsize_34; break;

  565. 		case 10: *value = self->m_tail_35; break;

  566. 		case 11: *value = self->m_blur_36; break;

  567. 		case 12: *value = self->m_decay_37; break;

  568. 		case 13: *value = self->m_damping_38; break;

  569. 		

  570. 		default: break;

  571. 	}

  572. }

  573. 

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

  575. 

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

  577. 	State *self = new State;

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

  579. 	ParamInfo *pi;

  580. 	self->__commonstate.inputnames = gen_kernel_innames;

  581. 	self->__commonstate.outputnames = gen_kernel_outnames;

  582. 	self->__commonstate.numins = gen_kernel_numins;

  583. 	self->__commonstate.numouts = gen_kernel_numouts;

  584. 	self->__commonstate.sr = sr;

  585. 	self->__commonstate.vs = vs;

  586. 	self->__commonstate.params = (ParamInfo *)genlib_sysmem_newptr(14 * sizeof(ParamInfo));

  587. 	self->__commonstate.numparams = 14;

  588. 	// initialize parameter 0 ("m_ratio_25")

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

  590. 	pi->name = "ratio";

  591. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  592. 	pi->defaultvalue = self->m_ratio_25;

  593. 	pi->defaultref = 0;

  594. 	pi->hasinputminmax = false;

  595. 	pi->inputmin = 0; 

  596. 	pi->inputmax = 1;

  597. 	pi->hasminmax = true;

  598. 	pi->outputmin = 0.5;

  599. 	pi->outputmax = 2;

  600. 	pi->exp = 0;

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

  602. 	// initialize parameter 1 ("m_window_26")

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

  604. 	pi->name = "window";

  605. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  606. 	pi->defaultvalue = self->m_window_26;

  607. 	pi->defaultref = 0;

  608. 	pi->hasinputminmax = false;

  609. 	pi->inputmin = 0; 

  610. 	pi->inputmax = 1;

  611. 	pi->hasminmax = true;

  612. 	pi->outputmin = 0.1;

  613. 	pi->outputmax = 1000;

  614. 	pi->exp = 0;

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

  616. 	// initialize parameter 2 ("m_resonance_27")

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

  618. 	pi->name = "resonance";

  619. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  620. 	pi->defaultvalue = self->m_resonance_27;

  621. 	pi->defaultref = 0;

  622. 	pi->hasinputminmax = false;

  623. 	pi->inputmin = 0; 

  624. 	pi->inputmax = 1;

  625. 	pi->hasminmax = true;

  626. 	pi->outputmin = 0;

  627. 	pi->outputmax = 0.25;

  628. 	pi->exp = 0;

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

  630. 	// initialize parameter 3 ("m_tone_28")

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

  632. 	pi->name = "tone";

  633. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  634. 	pi->defaultvalue = self->m_tone_28;

  635. 	pi->defaultref = 0;

  636. 	pi->hasinputminmax = false;

  637. 	pi->inputmin = 0; 

  638. 	pi->inputmax = 1;

  639. 	pi->hasminmax = true;

  640. 	pi->outputmin = 0;

  641. 	pi->outputmax = 1;

  642. 	pi->exp = 0;

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

  644. 	// initialize parameter 4 ("m_mix_29")

  645. 	pi = self->__commonstate.params + 4;

  646. 	pi->name = "mix";

  647. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  648. 	pi->defaultvalue = self->m_mix_29;

  649. 	pi->defaultref = 0;

  650. 	pi->hasinputminmax = false;

  651. 	pi->inputmin = 0; 

  652. 	pi->inputmax = 1;

  653. 	pi->hasminmax = true;

  654. 	pi->outputmin = 0;

  655. 	pi->outputmax = 1;

  656. 	pi->exp = 0;

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

  658. 	// initialize parameter 5 ("m_spread_30")

  659. 	pi = self->__commonstate.params + 5;

  660. 	pi->name = "spread";

  661. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  662. 	pi->defaultvalue = self->m_spread_30;

  663. 	pi->defaultref = 0;

  664. 	pi->hasinputminmax = false;

  665. 	pi->inputmin = 0; 

  666. 	pi->inputmax = 1;

  667. 	pi->hasminmax = true;

  668. 	pi->outputmin = 0;

  669. 	pi->outputmax = 100;

  670. 	pi->exp = 0;

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

  672. 	// initialize parameter 6 ("m_cutoff_31")

  673. 	pi = self->__commonstate.params + 6;

  674. 	pi->name = "cutoff";

  675. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  676. 	pi->defaultvalue = self->m_cutoff_31;

  677. 	pi->defaultref = 0;

  678. 	pi->hasinputminmax = false;

  679. 	pi->inputmin = 0; 

  680. 	pi->inputmax = 1;

  681. 	pi->hasminmax = true;

  682. 	pi->outputmin = 0;

  683. 	pi->outputmax = 6000;

  684. 	pi->exp = 0;

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

  686. 	// initialize parameter 7 ("m_early_32")

  687. 	pi = self->__commonstate.params + 7;

  688. 	pi->name = "early";

  689. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  690. 	pi->defaultvalue = self->m_early_32;

  691. 	pi->defaultref = 0;

  692. 	pi->hasinputminmax = false;

  693. 	pi->inputmin = 0; 

  694. 	pi->inputmax = 1;

  695. 	pi->hasminmax = true;

  696. 	pi->outputmin = 0;

  697. 	pi->outputmax = 1;

  698. 	pi->exp = 0;

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

  700. 	// initialize parameter 8 ("m_shimmer_33")

  701. 	pi = self->__commonstate.params + 8;

  702. 	pi->name = "shimmer";

  703. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  704. 	pi->defaultvalue = self->m_shimmer_33;

  705. 	pi->defaultref = 0;

  706. 	pi->hasinputminmax = false;

  707. 	pi->inputmin = 0; 

  708. 	pi->inputmax = 1;

  709. 	pi->hasminmax = true;

  710. 	pi->outputmin = 0;

  711. 	pi->outputmax = 1;

  712. 	pi->exp = 0;

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

  714. 	// initialize parameter 9 ("m_roomsize_34")

  715. 	pi = self->__commonstate.params + 9;

  716. 	pi->name = "roomsize";

  717. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  718. 	pi->defaultvalue = self->m_roomsize_34;

  719. 	pi->defaultref = 0;

  720. 	pi->hasinputminmax = false;

  721. 	pi->inputmin = 0; 

  722. 	pi->inputmax = 1;

  723. 	pi->hasminmax = true;

  724. 	pi->outputmin = 0.1;

  725. 	pi->outputmax = 300;

  726. 	pi->exp = 0;

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

  728. 	// initialize parameter 10 ("m_tail_35")

  729. 	pi = self->__commonstate.params + 10;

  730. 	pi->name = "tail";

  731. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  732. 	pi->defaultvalue = self->m_tail_35;

  733. 	pi->defaultref = 0;

  734. 	pi->hasinputminmax = false;

  735. 	pi->inputmin = 0; 

  736. 	pi->inputmax = 1;

  737. 	pi->hasminmax = true;

  738. 	pi->outputmin = 0;

  739. 	pi->outputmax = 1;

  740. 	pi->exp = 0;

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

  742. 	// initialize parameter 11 ("m_blur_36")

  743. 	pi = self->__commonstate.params + 11;

  744. 	pi->name = "blur";

  745. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  746. 	pi->defaultvalue = self->m_blur_36;

  747. 	pi->defaultref = 0;

  748. 	pi->hasinputminmax = false;

  749. 	pi->inputmin = 0; 

  750. 	pi->inputmax = 1;

  751. 	pi->hasminmax = true;

  752. 	pi->outputmin = 0.01;

  753. 	pi->outputmax = 0.25;

  754. 	pi->exp = 0;

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

  756. 	// initialize parameter 12 ("m_decay_37")

  757. 	pi = self->__commonstate.params + 12;

  758. 	pi->name = "decay";

  759. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  760. 	pi->defaultvalue = self->m_decay_37;

  761. 	pi->defaultref = 0;

  762. 	pi->hasinputminmax = false;

  763. 	pi->inputmin = 0; 

  764. 	pi->inputmax = 1;

  765. 	pi->hasminmax = true;

  766. 	pi->outputmin = 0.1;

  767. 	pi->outputmax = 360;

  768. 	pi->exp = 0;

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

  770. 	// initialize parameter 13 ("m_damping_38")

  771. 	pi = self->__commonstate.params + 13;

  772. 	pi->name = "damping";

  773. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  774. 	pi->defaultvalue = self->m_damping_38;

  775. 	pi->defaultref = 0;

  776. 	pi->hasinputminmax = false;

  777. 	pi->inputmin = 0; 

  778. 	pi->inputmax = 1;

  779. 	pi->hasminmax = true;

  780. 	pi->outputmin = 0;

  781. 	pi->outputmax = 1;

  782. 	pi->exp = 0;

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

  784. 	

  785. 	return self;

  786. }

  787. 

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

  789. 

  790. void destroy(CommonState *cself) { 

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

  792. 	genlib_sysmem_freeptr(cself->params);

  793. 		

  794. 	delete self; 

  795. }

  796. 

  797. 

  798. } // gen_exported::