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.
10 Commits
2 Branches
5.0MB
Tree: fd7bf0fa54
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fd7bf0fa54'
${ noResults }
DPF-Max-Gen/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_early_34;

  61. 	double m_ratio_35;

  62. 	double m_cutoff_36;

  63. 	double m_blur_38;

  64. 	double m_roomsize_33;

  65. 	double m_spread_37;

  66. 	double samples_to_seconds;

  67. 	double m_tail_32;

  68. 	double m_shimmer_25;

  69. 	double m_window_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_damping_31;

  78. 	double m_history_7;

  79. 	double m_history_9;

  80. 	double m_resonance_28;

  81. 	double m_mix_29;

  82. 	double m_history_8;

  83. 	double m_tone_27;

  84. 	double m_y_11;

  85. 	double m_history_10;

  86. 	double m_decay_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", 7000);

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

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

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

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

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

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

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

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

  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_shimmer_25 = 0.5;

  119. 		m_decay_26 = 60;

  120. 		m_tone_27 = 0.5;

  121. 		m_resonance_28 = 0;

  122. 		m_mix_29 = 0.5;

  123. 		m_window_30 = 100;

  124. 		m_damping_31 = 0.75;

  125. 		m_tail_32 = 0.25;

  126. 		m_roomsize_33 = 75;

  127. 		m_early_34 = 0.25;

  128. 		m_ratio_35 = 2;

  129. 		m_cutoff_36 = 3000;

  130. 		m_spread_37 = 25;

  131. 		m_blur_38 = 0.25;

  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_3603 = (1 - m_tone_27);

  164. 		double expr_4406 = safepow(0.001, safediv(1, (m_decay_26 * 44100)));

  165. 		double expr_4407 = safediv((m_roomsize_33 * 44100), 340);

  166. 		double mul_3592 = (expr_4407 * 0.63245);

  167. 		double expr_4398 = (-safepow(expr_4406, mul_3592));

  168. 		double mul_3595 = (expr_4407 * 1);

  169. 		double expr_4405 = (-safepow(expr_4406, mul_3595));

  170. 		double mul_3593 = (expr_4407 * 0.7071);

  171. 		double expr_4399 = (-safepow(expr_4406, mul_3593));

  172. 		double mul_3594 = (expr_4407 * 0.81649);

  173. 		double expr_4400 = (-safepow(expr_4406, mul_3594));

  174. 		double mul_3589 = (expr_4407 * 0.000527);

  175. 		int int_3588 = int(mul_3589);

  176. 		double mul_3377 = (m_resonance_28 * 0.125);

  177. 		double exp_3378 = exp(mul_3377);

  178. 		double mul_3376 = (exp_3378 * 0.882497);

  179. 		double mul_3372 = (mul_3376 * mul_3376);

  180. 		double expr_4397 = safediv(((m_cutoff_36 * 2) * 3.1415926535898), 44100);

  181. 		double cos_3375 = cos(expr_4397);

  182. 		double mul_3374 = (cos_3375 * mul_3376);

  183. 		double mul_3373 = (mul_3374 * -2);

  184. 		double add_3371 = ((mul_3373 + mul_3372) + 1);

  185. 		double mul_3557 = (m_spread_37 * 0.376623);

  186. 		double add_3556 = (mul_3557 + 931);

  187. 		double rsub_3553 = (1341 - add_3556);

  188. 		double mul_3564 = (int_3588 * rsub_3553);

  189. 		double add_3518 = (expr_4407 + 5);

  190. 		double expr_4401 = safepow(expr_4406, add_3518);

  191. 		double mstosamps_3443 = (m_window_30 * (samplerate * 0.001));

  192. 		double mul_3529 = (m_spread_37 * -0.380445);

  193. 		double add_3528 = (mul_3529 + 931);

  194. 		double rsub_3525 = (1341 - add_3528);

  195. 		double mul_3538 = (int_3588 * rsub_3525);

  196. 		double mul_3524 = (expr_4407 * 0.41);

  197. 		double add_3521 = (mul_3524 + 5);

  198. 		double expr_4404 = safepow(expr_4406, add_3521);

  199. 		double mul_3523 = (expr_4407 * 0.3);

  200. 		double add_3520 = (mul_3523 + 5);

  201. 		double expr_4403 = safepow(expr_4406, add_3520);

  202. 		double mul_3522 = (expr_4407 * 0.155);

  203. 		double add_3519 = (mul_3522 + 5);

  204. 		double expr_4402 = safepow(expr_4406, add_3519);

  205. 		double rsub_3430 = (1 - m_ratio_35);

  206. 		double mul_3429 = (rsub_3430 * 1000);

  207. 		double div_3428 = safediv(mul_3429, m_window_30);

  208. 		samples_to_seconds = (1 / samplerate);

  209. 		double mul_3587 = (expr_4407 * 0.110732);

  210. 		double mul_3573 = (m_spread_37 * 0.125541);

  211. 		double add_3555 = (mul_3573 + 369);

  212. 		double rsub_3554 = (add_3556 - add_3555);

  213. 		double mul_3571 = (int_3588 * rsub_3554);

  214. 		double mul_3531 = (m_spread_37 * -0.568366);

  215. 		double add_3527 = (mul_3531 + 369);

  216. 		double rsub_3526 = (add_3528 - add_3527);

  217. 		double mul_3545 = (int_3588 * rsub_3526);

  218. 		double add_3572 = (mul_3573 + 159);

  219. 		double mul_3580 = (int_3588 * add_3572);

  220. 		double add_3530 = (mul_3531 + 159);

  221. 		double mul_3552 = (int_3588 * add_3530);

  222. 		// the main sample loop;

  223. 		while ((__n--)) { 

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

  225. 			double noise_3382 = noise();

  226. 			double abs_3400 = fabs(noise_3382);

  227. 			double mul_3410 = (abs_3400 * m_blur_38);

  228. 			double noise_3381 = noise();

  229. 			double abs_3399 = fabs(noise_3381);

  230. 			double mul_3407 = (abs_3399 * m_blur_38);

  231. 			double noise_3379 = noise();

  232. 			double abs_3397 = fabs(noise_3379);

  233. 			double mul_3401 = (abs_3397 * m_blur_38);

  234. 			double noise_3380 = noise();

  235. 			double abs_3398 = fabs(noise_3380);

  236. 			double mul_3404 = (abs_3398 * m_blur_38);

  237. 			double tap_3492 = m_delay_24.read_linear(mul_3592);

  238. 			double mul_3488 = (tap_3492 * expr_4398);

  239. 			double mix_4450 = (mul_3488 + (m_damping_31 * (m_history_10 - mul_3488)));

  240. 			double mix_3490 = mix_4450;

  241. 			double tap_3600 = m_delay_23.read_linear(mul_3595);

  242. 			double mul_3591 = (tap_3600 * expr_4405);

  243. 			double mix_4451 = (mul_3591 + (m_damping_31 * (m_history_9 - mul_3591)));

  244. 			double mix_3598 = mix_4451;

  245. 			double tap_3498 = m_delay_22.read_linear(mul_3593);

  246. 			double mul_3494 = (tap_3498 * expr_4399);

  247. 			double mix_4452 = (mul_3494 + (m_damping_31 * (m_history_8 - mul_3494)));

  248. 			double mix_3496 = mix_4452;

  249. 			double tap_3504 = m_delay_21.read_linear(mul_3594);

  250. 			double mul_3500 = (tap_3504 * expr_4400);

  251. 			double mix_4453 = (mul_3500 + (m_damping_31 * (m_history_7 - mul_3500)));

  252. 			double mix_3502 = mix_4453;

  253. 			double mul_3368 = (mul_3372 * m_y_11);

  254. 			double mul_3369 = (mul_3373 * m_y_2);

  255. 			double tap_3563 = m_delay_20.read_linear(mul_3564);

  256. 			double mul_3561 = (tap_3563 * 0.625);

  257. 			double add_3482 = (mix_3598 + mix_3502);

  258. 			double add_3480 = (mix_3496 + mix_3490);

  259. 			double add_3475 = (add_3482 + add_3480);

  260. 			double mul_3458 = (add_3475 * 0.5);

  261. 			double sub_3479 = (add_3482 - add_3480);

  262. 			double mul_3461 = (sub_3479 * 0.5);

  263. 			double sub_3481 = (mix_3598 - mix_3502);

  264. 			double sub_3478 = (mix_3496 - mix_3490);

  265. 			double sub_3477 = (sub_3481 - sub_3478);

  266. 			double mul_3460 = (sub_3477 * 0.5);

  267. 			double add_3476 = (sub_3481 + sub_3478);

  268. 			double rsub_3474 = (0 - add_3476);

  269. 			double mul_3459 = (rsub_3474 * 0.5);

  270. 			double tap_3537 = m_delay_19.read_linear(mul_3538);

  271. 			double mul_3535 = (tap_3537 * 0.625);

  272. 			double tap_3506 = m_delay_18.read_linear(add_3521);

  273. 			double tap_3507 = m_delay_18.read_linear(add_3520);

  274. 			double tap_3508 = m_delay_18.read_linear(add_3519);

  275. 			double tap_3509 = m_delay_18.read_linear(add_3518);

  276. 			double mul_3510 = (tap_3509 * expr_4401);

  277. 			double add_3483 = (mul_3458 + mul_3510);

  278. 			double mul_3516 = (tap_3506 * expr_4404);

  279. 			double add_3486 = (mul_3461 + mul_3516);

  280. 			double mul_3514 = (tap_3507 * expr_4403);

  281. 			double add_3485 = (mul_3460 + mul_3514);

  282. 			double mul_3512 = (tap_3508 * expr_4402);

  283. 			double add_3484 = (mul_3459 + mul_3512);

  284. 			double phasor_3449 = m_phasor_39(div_3428, samples_to_seconds);

  285. 			double add_3448 = ((m_history_6 + phasor_3449) + 0);

  286. 			double mod_3447 = safemod(add_3448, 1);

  287. 			double delta_3390 = m_delta_40(mod_3447);

  288. 			double sah_3389 = m_sah_41(mul_3410, delta_3390, 0);

  289. 			double sah_3411 = m_sah_42(mstosamps_3443, delta_3390, 0);

  290. 			double mul_3396 = (sah_3411 * mod_3447);

  291. 			double sub_3446 = (mod_3447 - 0.5);

  292. 			double mul_3445 = (sub_3446 * 3.1415926535898);

  293. 			double cos_3444 = cos(mul_3445);

  294. 			double mul_3415 = (cos_3444 * cos_3444);

  295. 			double add_3442 = ((m_history_5 + phasor_3449) + 0.25);

  296. 			double mod_3441 = safemod(add_3442, 1);

  297. 			double delta_3409 = m_delta_43(mod_3441);

  298. 			double sah_3387 = m_sah_44(mul_3407, delta_3409, 0);

  299. 			double sah_3408 = m_sah_45(mstosamps_3443, delta_3409, 0);

  300. 			double mul_3395 = (sah_3408 * mod_3441);

  301. 			double sub_3440 = (mod_3441 - 0.5);

  302. 			double mul_3439 = (sub_3440 * 3.1415926535898);

  303. 			double cos_3438 = cos(mul_3439);

  304. 			double mul_3414 = (cos_3438 * cos_3438);

  305. 			double add_3421 = ((m_history_4 + phasor_3449) + 0.75);

  306. 			double mod_3420 = safemod(add_3421, 1);

  307. 			double delta_3403 = m_delta_46(mod_3420);

  308. 			double sah_3383 = m_sah_47(mul_3401, delta_3403, 0);

  309. 			double sah_3402 = m_sah_48(mstosamps_3443, delta_3403, 0);

  310. 			double mul_3393 = (sah_3402 * mod_3420);

  311. 			double sub_3419 = (mod_3420 - 0.5);

  312. 			double mul_3418 = (sub_3419 * 3.1415926535898);

  313. 			double cos_3417 = cos(mul_3418);

  314. 			double mul_3412 = (cos_3417 * cos_3417);

  315. 			double add_3427 = ((m_history_3 + phasor_3449) + 0.5);

  316. 			double mod_3426 = safemod(add_3427, 1);

  317. 			double delta_3406 = m_delta_49(mod_3426);

  318. 			double sah_3385 = m_sah_50(mul_3404, delta_3406, 0);

  319. 			double sah_3405 = m_sah_51(mstosamps_3443, delta_3406, 0);

  320. 			double mul_3394 = (sah_3405 * mod_3426);

  321. 			double tap_3434 = m_delay_17.read_linear(mul_3396);

  322. 			double tap_3435 = m_delay_17.read_linear(mul_3395);

  323. 			double tap_3436 = m_delay_17.read_linear(mul_3394);

  324. 			double tap_3437 = m_delay_17.read_linear(mul_3393);

  325. 			double mul_3416 = (tap_3437 * mul_3412);

  326. 			double mul_3431 = (tap_3435 * mul_3414);

  327. 			double mul_3432 = (tap_3434 * mul_3415);

  328. 			double sub_3425 = (mod_3426 - 0.5);

  329. 			double mul_3424 = (sub_3425 * 3.1415926535898);

  330. 			double cos_3423 = cos(mul_3424);

  331. 			double mul_3413 = (cos_3423 * cos_3423);

  332. 			double mul_3422 = (tap_3436 * mul_3413);

  333. 			double mul_3370 = ((((mul_3432 + mul_3431) + mul_3422) + mul_3416) * add_3371);

  334. 			double sub_3367 = (mul_3370 - (mul_3369 + mul_3368));

  335. 			double mix_4454 = (in1 + (m_shimmer_25 * (sub_3367 - in1)));

  336. 			double mix_3392 = mix_4454;

  337. 			double mul_3452 = (mix_3392 * 0.707);

  338. 			double mix_4455 = (mul_3452 + (rsub_3603 * (m_history_1 - mul_3452)));

  339. 			double mix_3602 = mix_4455;

  340. 			double tap_3586 = m_delay_16.read_linear(mul_3587);

  341. 			double tap_3570 = m_delay_15.read_linear(mul_3571);

  342. 			double mul_3568 = (tap_3570 * 0.625);

  343. 			double mul_3584 = (tap_3586 * 0.75);

  344. 			double sub_3583 = (mix_3602 - mul_3584);

  345. 			double mul_3582 = (sub_3583 * 0.75);

  346. 			double add_3581 = (mul_3582 + tap_3586);

  347. 			double tap_3544 = m_delay_14.read_linear(mul_3545);

  348. 			double mul_3542 = (tap_3544 * 0.625);

  349. 			double tap_3579 = m_delay_13.read_linear(mul_3580);

  350. 			double mul_3577 = (tap_3579 * 0.75);

  351. 			double tap_3551 = m_delay_12.read_linear(mul_3552);

  352. 			double mul_3549 = (tap_3551 * 0.75);

  353. 			double mul_3473 = (mul_3461 * m_tail_32);

  354. 			double mul_3471 = (mul_3459 * m_tail_32);

  355. 			double add_3457 = (mul_3473 + mul_3471);

  356. 			double mul_3472 = (mul_3460 * m_tail_32);

  357. 			double mul_3470 = (mul_3458 * m_tail_32);

  358. 			double add_3456 = (mul_3472 + mul_3470);

  359. 			double sub_3465 = (add_3457 - add_3456);

  360. 			double mul_3469 = (mul_3516 * m_early_34);

  361. 			double mul_3467 = (mul_3512 * m_early_34);

  362. 			double add_3455 = (mul_3469 + mul_3467);

  363. 			double mul_3468 = (mul_3514 * m_early_34);

  364. 			double mul_3466 = (mul_3510 * m_early_34);

  365. 			double add_3454 = (mul_3468 + mul_3466);

  366. 			double sub_3464 = (add_3455 - add_3454);

  367. 			double add_3451 = (sub_3465 + sub_3464);

  368. 			double add_3463 = (add_3451 + mix_3392);

  369. 			double sub_3576 = (add_3463 - mul_3577);

  370. 			double mul_3575 = (sub_3576 * 0.75);

  371. 			double add_3574 = (mul_3575 + tap_3579);

  372. 			double sub_3567 = (add_3574 - mul_3568);

  373. 			double mul_3566 = (sub_3567 * 0.625);

  374. 			double add_3565 = (mul_3566 + tap_3570);

  375. 			double sub_3560 = (add_3565 - mul_3561);

  376. 			double mul_3559 = (sub_3560 * 0.625);

  377. 			double add_3558 = (mul_3559 + tap_3563);

  378. 			double mul_3462 = (add_3558 * m_mix_29);

  379. 			double out1 = (mul_3462 + in1);

  380. 			double add_3453 = (add_3451 + mix_3392);

  381. 			double sub_3548 = (add_3453 - mul_3549);

  382. 			double mul_3547 = (sub_3548 * 0.75);

  383. 			double add_3546 = (mul_3547 + tap_3551);

  384. 			double sub_3541 = (add_3546 - mul_3542);

  385. 			double mul_3540 = (sub_3541 * 0.625);

  386. 			double add_3539 = (mul_3540 + tap_3544);

  387. 			double sub_3534 = (add_3539 - mul_3535);

  388. 			double mul_3533 = (sub_3534 * 0.625);

  389. 			double add_3532 = (mul_3533 + tap_3537);

  390. 			double mul_3450 = (add_3532 * m_mix_29);

  391. 			double out2 = (mul_3450 + in1);

  392. 			double y2_next_4421 = m_y_2;

  393. 			double history_3489_next_4422 = mix_3490;

  394. 			double history_3597_next_4423 = mix_3598;

  395. 			double history_3495_next_4424 = mix_3496;

  396. 			double history_3501_next_4425 = mix_3502;

  397. 			double history_3391_next_4426 = sah_3389;

  398. 			double history_3388_next_4427 = sah_3387;

  399. 			double history_3384_next_4428 = sah_3383;

  400. 			double history_3386_next_4429 = sah_3385;

  401. 			double y1_next_4430 = sub_3367;

  402. 			double history_3601_next_4431 = mix_3602;

  403. 			m_delay_24.write(add_3483);

  404. 			m_delay_23.write(add_3486);

  405. 			m_delay_22.write(add_3484);

  406. 			m_delay_21.write(add_3485);

  407. 			m_delay_20.write(sub_3560);

  408. 			m_delay_19.write(sub_3534);

  409. 			m_delay_18.write(add_3581);

  410. 			m_delay_17.write(in1);

  411. 			m_delay_16.write(sub_3583);

  412. 			m_delay_15.write(sub_3567);

  413. 			m_delay_14.write(sub_3541);

  414. 			m_delay_13.write(sub_3576);

  415. 			m_delay_12.write(sub_3548);

  416. 			m_y_11 = y2_next_4421;

  417. 			m_history_10 = history_3489_next_4422;

  418. 			m_history_9 = history_3597_next_4423;

  419. 			m_history_8 = history_3495_next_4424;

  420. 			m_history_7 = history_3501_next_4425;

  421. 			m_history_6 = history_3391_next_4426;

  422. 			m_history_5 = history_3388_next_4427;

  423. 			m_history_4 = history_3384_next_4428;

  424. 			m_history_3 = history_3386_next_4429;

  425. 			m_y_2 = y1_next_4430;

  426. 			m_history_1 = history_3601_next_4431;

  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_shimmer(double _value) {

  449. 		m_shimmer_25 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  450. 	};

  451. 	inline void set_decay(double _value) {

  452. 		m_decay_26 = (_value < 0.1 ? 0.1 : (_value > 360 ? 360 : _value));

  453. 	};

  454. 	inline void set_tone(double _value) {

  455. 		m_tone_27 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  456. 	};

  457. 	inline void set_resonance(double _value) {

  458. 		m_resonance_28 = (_value < 0 ? 0 : (_value > 0.25 ? 0.25 : _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_window(double _value) {

  464. 		m_window_30 = (_value < 0.1 ? 0.1 : (_value > 1000 ? 1000 : _value));

  465. 	};

  466. 	inline void set_damping(double _value) {

  467. 		m_damping_31 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  468. 	};

  469. 	inline void set_tail(double _value) {

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

  471. 	};

  472. 	inline void set_roomsize(double _value) {

  473. 		m_roomsize_33 = (_value < 0.1 ? 0.1 : (_value > 300 ? 300 : _value));

  474. 	};

  475. 	inline void set_early(double _value) {

  476. 		m_early_34 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  477. 	};

  478. 	inline void set_ratio(double _value) {

  479. 		m_ratio_35 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  480. 	};

  481. 	inline void set_cutoff(double _value) {

  482. 		m_cutoff_36 = (_value < 0 ? 0 : (_value > 6000 ? 6000 : _value));

  483. 	};

  484. 	inline void set_spread(double _value) {

  485. 		m_spread_37 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  486. 	};

  487. 	inline void set_blur(double _value) {

  488. 		m_blur_38 = (_value < 0.01 ? 0.01 : (_value > 0.25 ? 0.25 : _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_shimmer(value); break;

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

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

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

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

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

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

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

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

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

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

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

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

  544. 		case 13: self->set_blur(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_shimmer_25; break;

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

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

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

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

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

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

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

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

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

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

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

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

  568. 		case 13: *value = self->m_blur_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_shimmer_25")

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

  590. 	pi->name = "shimmer";

  591. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  592. 	pi->defaultvalue = self->m_shimmer_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;

  599. 	pi->outputmax = 1;

  600. 	pi->exp = 0;

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

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

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

  604. 	pi->name = "decay";

  605. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  606. 	pi->defaultvalue = self->m_decay_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 = 360;

  614. 	pi->exp = 0;

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

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

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

  618. 	pi->name = "tone";

  619. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  620. 	pi->defaultvalue = self->m_tone_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 = 1;

  628. 	pi->exp = 0;

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

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

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

  632. 	pi->name = "resonance";

  633. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  634. 	pi->defaultvalue = self->m_resonance_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 = 0.25;

  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_window_30")

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

  660. 	pi->name = "window";

  661. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  662. 	pi->defaultvalue = self->m_window_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.1;

  669. 	pi->outputmax = 1000;

  670. 	pi->exp = 0;

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

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

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

  674. 	pi->name = "damping";

  675. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  676. 	pi->defaultvalue = self->m_damping_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 = 1;

  684. 	pi->exp = 0;

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

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

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

  688. 	pi->name = "tail";

  689. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  690. 	pi->defaultvalue = self->m_tail_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_roomsize_33")

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

  702. 	pi->name = "roomsize";

  703. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  704. 	pi->defaultvalue = self->m_roomsize_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.1;

  711. 	pi->outputmax = 300;

  712. 	pi->exp = 0;

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

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

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

  716. 	pi->name = "early";

  717. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  718. 	pi->defaultvalue = self->m_early_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;

  725. 	pi->outputmax = 1;

  726. 	pi->exp = 0;

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

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

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

  730. 	pi->name = "ratio";

  731. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  732. 	pi->defaultvalue = self->m_ratio_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.5;

  739. 	pi->outputmax = 2;

  740. 	pi->exp = 0;

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

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

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

  744. 	pi->name = "cutoff";

  745. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  746. 	pi->defaultvalue = self->m_cutoff_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;

  753. 	pi->outputmax = 6000;

  754. 	pi->exp = 0;

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

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

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

  758. 	pi->name = "spread";

  759. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  760. 	pi->defaultvalue = self->m_spread_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;

  767. 	pi->outputmax = 100;

  768. 	pi->exp = 0;

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

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

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

  772. 	pi->name = "blur";

  773. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  774. 	pi->defaultvalue = self->m_blur_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.01;

  781. 	pi->outputmax = 0.25;

  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::