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.
3 Commits
2 Branches
18MB
Tree: 6eab61a6fb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6eab61a6fb'
${ noResults }
DPF-Max-Gen/plugins/shiroverb/gen_exported.cpp

799 lines
27KB
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_mix_34;

  61. 	double m_resonance_35;

  62. 	double m_cutoff_36;

  63. 	double m_window_38;

  64. 	double m_blur_33;

  65. 	double m_shift_37;

  66. 	double samples_to_seconds;

  67. 	double m_tail_32;

  68. 	double m_ratio_25;

  69. 	double m_damping_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_spread_31;

  78. 	double m_history_7;

  79. 	double m_history_9;

  80. 	double m_roomsize_28;

  81. 	double m_decay_29;

  82. 	double m_history_8;

  83. 	double m_early_27;

  84. 	double m_y_11;

  85. 	double m_history_10;

  86. 	double m_tone_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_ratio_25 = 2;

  119. 		m_tone_26 = 0.5;

  120. 		m_early_27 = 0.25;

  121. 		m_roomsize_28 = 75;

  122. 		m_decay_29 = 11;

  123. 		m_damping_30 = 0.7;

  124. 		m_spread_31 = 23;

  125. 		m_tail_32 = 0.25;

  126. 		m_blur_33 = 0;

  127. 		m_mix_34 = 1;

  128. 		m_resonance_35 = 0;

  129. 		m_cutoff_36 = 8000;

  130. 		m_shift_37 = 1;

  131. 		m_window_38 = 100;

  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_11547 = (1 - m_tone_26);

  164. 		double expr_11686 = safepow(0.001, safediv(1, (m_decay_29 * 44100)));

  165. 		double expr_11687 = safediv((m_roomsize_28 * 44100), 340);

  166. 		double mul_11539 = (expr_11687 * 1);

  167. 		double expr_11685 = (-safepow(expr_11686, mul_11539));

  168. 		double mul_11537 = (expr_11687 * 0.7071);

  169. 		double expr_11679 = (-safepow(expr_11686, mul_11537));

  170. 		double mul_11538 = (expr_11687 * 0.81649);

  171. 		double expr_11680 = (-safepow(expr_11686, mul_11538));

  172. 		double mul_11536 = (expr_11687 * 0.63245);

  173. 		double expr_11678 = (-safepow(expr_11686, mul_11536));

  174. 		double expr_11677 = safediv(((m_cutoff_36 * 2) * 3.1415926535898), 44100);

  175. 		double cos_11390 = cos(expr_11677);

  176. 		double mul_11392 = (m_resonance_35 * 0.125);

  177. 		double exp_11393 = exp(mul_11392);

  178. 		double mul_11391 = (exp_11393 * 0.882497);

  179. 		double mul_11387 = (mul_11391 * mul_11391);

  180. 		double mul_11389 = (cos_11390 * mul_11391);

  181. 		double mul_11388 = (mul_11389 * -2);

  182. 		double add_11386 = ((mul_11387 + mul_11388) + 1);

  183. 		double mul_11533 = (expr_11687 * 0.000527);

  184. 		int int_11532 = int(mul_11533);

  185. 		double mstosamps_11374 = (m_window_38 * (samplerate * 0.001));

  186. 		double add_11462 = (expr_11687 + 5);

  187. 		double expr_11681 = safepow(expr_11686, add_11462);

  188. 		double mul_11501 = (m_spread_31 * 0.376623);

  189. 		double add_11500 = (mul_11501 + 931);

  190. 		double rsub_11497 = (1341 - add_11500);

  191. 		double mul_11508 = (int_11532 * rsub_11497);

  192. 		double mul_11473 = (m_spread_31 * -0.380445);

  193. 		double add_11472 = (mul_11473 + 931);

  194. 		double rsub_11469 = (1341 - add_11472);

  195. 		double mul_11482 = (int_11532 * rsub_11469);

  196. 		double mul_11468 = (expr_11687 * 0.41);

  197. 		double add_11465 = (mul_11468 + 5);

  198. 		double expr_11684 = safepow(expr_11686, add_11465);

  199. 		double mul_11467 = (expr_11687 * 0.3);

  200. 		double add_11464 = (mul_11467 + 5);

  201. 		double expr_11683 = safepow(expr_11686, add_11464);

  202. 		double mul_11466 = (expr_11687 * 0.155);

  203. 		double add_11463 = (mul_11466 + 5);

  204. 		double expr_11682 = safepow(expr_11686, add_11463);

  205. 		double rsub_11361 = (1 - m_ratio_25);

  206. 		double mul_11360 = (rsub_11361 * 1000);

  207. 		double div_11359 = safediv(mul_11360, m_window_38);

  208. 		samples_to_seconds = (1 / samplerate);

  209. 		double mul_11531 = (expr_11687 * 0.110732);

  210. 		double mul_11517 = (m_spread_31 * 0.125541);

  211. 		double add_11499 = (mul_11517 + 369);

  212. 		double rsub_11498 = (add_11500 - add_11499);

  213. 		double mul_11515 = (int_11532 * rsub_11498);

  214. 		double mul_11475 = (m_spread_31 * -0.568366);

  215. 		double add_11471 = (mul_11475 + 369);

  216. 		double rsub_11470 = (add_11472 - add_11471);

  217. 		double mul_11489 = (int_11532 * rsub_11470);

  218. 		double add_11516 = (mul_11517 + 159);

  219. 		double mul_11524 = (int_11532 * add_11516);

  220. 		double add_11474 = (mul_11475 + 159);

  221. 		double mul_11496 = (int_11532 * add_11474);

  222. 		// the main sample loop;

  223. 		while ((__n--)) { 

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

  225. 			double noise_11310 = noise();

  226. 			double abs_11328 = fabs(noise_11310);

  227. 			double mul_11332 = (abs_11328 * m_blur_33);

  228. 			double noise_11311 = noise();

  229. 			double abs_11329 = fabs(noise_11311);

  230. 			double mul_11335 = (abs_11329 * m_blur_33);

  231. 			double noise_11313 = noise();

  232. 			double abs_11331 = fabs(noise_11313);

  233. 			double mul_11341 = (abs_11331 * m_blur_33);

  234. 			double noise_11312 = noise();

  235. 			double abs_11330 = fabs(noise_11312);

  236. 			double mul_11338 = (abs_11330 * m_blur_33);

  237. 			double tap_11544 = m_delay_24.read_linear(mul_11539);

  238. 			double mul_11535 = (tap_11544 * expr_11685);

  239. 			double mix_11730 = (mul_11535 + (m_damping_30 * (m_history_10 - mul_11535)));

  240. 			double mix_11542 = mix_11730;

  241. 			double tap_11442 = m_delay_23.read_linear(mul_11537);

  242. 			double mul_11438 = (tap_11442 * expr_11679);

  243. 			double mix_11731 = (mul_11438 + (m_damping_30 * (m_history_9 - mul_11438)));

  244. 			double mix_11440 = mix_11731;

  245. 			double tap_11448 = m_delay_22.read_linear(mul_11538);

  246. 			double mul_11444 = (tap_11448 * expr_11680);

  247. 			double mix_11732 = (mul_11444 + (m_damping_30 * (m_history_8 - mul_11444)));

  248. 			double mix_11446 = mix_11732;

  249. 			double tap_11436 = m_delay_21.read_linear(mul_11536);

  250. 			double mul_11432 = (tap_11436 * expr_11678);

  251. 			double mix_11733 = (mul_11432 + (m_damping_30 * (m_history_7 - mul_11432)));

  252. 			double mix_11434 = mix_11733;

  253. 			double mul_11383 = (mul_11387 * m_y_11);

  254. 			double mul_11384 = (mul_11388 * m_y_2);

  255. 			double add_11426 = (mix_11542 + mix_11446);

  256. 			double add_11424 = (mix_11440 + mix_11434);

  257. 			double sub_11423 = (add_11426 - add_11424);

  258. 			double mul_11405 = (sub_11423 * 0.5);

  259. 			double add_11419 = (add_11426 + add_11424);

  260. 			double mul_11402 = (add_11419 * 0.5);

  261. 			double tap_11507 = m_delay_20.read_linear(mul_11508);

  262. 			double mul_11505 = (tap_11507 * 0.625);

  263. 			double tap_11481 = m_delay_19.read_linear(mul_11482);

  264. 			double mul_11479 = (tap_11481 * 0.625);

  265. 			double sub_11425 = (mix_11542 - mix_11446);

  266. 			double sub_11422 = (mix_11440 - mix_11434);

  267. 			double sub_11421 = (sub_11425 - sub_11422);

  268. 			double mul_11404 = (sub_11421 * 0.5);

  269. 			double add_11420 = (sub_11425 + sub_11422);

  270. 			double rsub_11418 = (0 - add_11420);

  271. 			double mul_11403 = (rsub_11418 * 0.5);

  272. 			double tap_11450 = m_delay_18.read_linear(add_11465);

  273. 			double tap_11451 = m_delay_18.read_linear(add_11464);

  274. 			double tap_11452 = m_delay_18.read_linear(add_11463);

  275. 			double tap_11453 = m_delay_18.read_linear(add_11462);

  276. 			double mul_11460 = (tap_11450 * expr_11684);

  277. 			double add_11430 = (mul_11405 + mul_11460);

  278. 			double mul_11458 = (tap_11451 * expr_11683);

  279. 			double add_11429 = (mul_11404 + mul_11458);

  280. 			double mul_11454 = (tap_11453 * expr_11681);

  281. 			double add_11427 = (mul_11402 + mul_11454);

  282. 			double mul_11456 = (tap_11452 * expr_11682);

  283. 			double add_11428 = (mul_11403 + mul_11456);

  284. 			double phasor_11380 = m_phasor_39(div_11359, samples_to_seconds);

  285. 			double add_11352 = ((m_history_6 + phasor_11380) + 0.75);

  286. 			double mod_11351 = safemod(add_11352, 1);

  287. 			double delta_11334 = m_delta_40(mod_11351);

  288. 			double sah_11314 = m_sah_41(mul_11332, delta_11334, 0);

  289. 			double sah_11333 = m_sah_42(mstosamps_11374, delta_11334, 0);

  290. 			double mul_11324 = (sah_11333 * mod_11351);

  291. 			double sub_11350 = (mod_11351 - 0.5);

  292. 			double mul_11349 = (sub_11350 * 3.1415926535898);

  293. 			double cos_11348 = cos(mul_11349);

  294. 			double mul_11343 = (cos_11348 * cos_11348);

  295. 			double add_11358 = ((m_history_5 + phasor_11380) + 0.5);

  296. 			double mod_11357 = safemod(add_11358, 1);

  297. 			double delta_11337 = m_delta_43(mod_11357);

  298. 			double sah_11316 = m_sah_44(mul_11335, delta_11337, 0);

  299. 			double sah_11336 = m_sah_45(mstosamps_11374, delta_11337, 0);

  300. 			double mul_11325 = (sah_11336 * mod_11357);

  301. 			double sub_11356 = (mod_11357 - 0.5);

  302. 			double mul_11355 = (sub_11356 * 3.1415926535898);

  303. 			double cos_11354 = cos(mul_11355);

  304. 			double mul_11344 = (cos_11354 * cos_11354);

  305. 			double add_11379 = ((m_history_4 + phasor_11380) + 0);

  306. 			double mod_11378 = safemod(add_11379, 1);

  307. 			double delta_11321 = m_delta_46(mod_11378);

  308. 			double sah_11320 = m_sah_47(mul_11341, delta_11321, 0);

  309. 			double sah_11342 = m_sah_48(mstosamps_11374, delta_11321, 0);

  310. 			double mul_11327 = (sah_11342 * mod_11378);

  311. 			double sub_11377 = (mod_11378 - 0.5);

  312. 			double mul_11376 = (sub_11377 * 3.1415926535898);

  313. 			double cos_11375 = cos(mul_11376);

  314. 			double mul_11346 = (cos_11375 * cos_11375);

  315. 			double add_11373 = ((m_history_3 + phasor_11380) + 0.25);

  316. 			double mod_11372 = safemod(add_11373, 1);

  317. 			double delta_11340 = m_delta_49(mod_11372);

  318. 			double sah_11318 = m_sah_50(mul_11338, delta_11340, 0);

  319. 			double sah_11339 = m_sah_51(mstosamps_11374, delta_11340, 0);

  320. 			double mul_11326 = (sah_11339 * mod_11372);

  321. 			double tap_11365 = m_delay_17.read_linear(mul_11327);

  322. 			double tap_11366 = m_delay_17.read_linear(mul_11326);

  323. 			double tap_11367 = m_delay_17.read_linear(mul_11325);

  324. 			double tap_11368 = m_delay_17.read_linear(mul_11324);

  325. 			double mul_11347 = (tap_11368 * mul_11343);

  326. 			double mul_11353 = (tap_11367 * mul_11344);

  327. 			double mul_11363 = (tap_11365 * mul_11346);

  328. 			double sub_11371 = (mod_11372 - 0.5);

  329. 			double mul_11370 = (sub_11371 * 3.1415926535898);

  330. 			double cos_11369 = cos(mul_11370);

  331. 			double mul_11345 = (cos_11369 * cos_11369);

  332. 			double mul_11362 = (tap_11366 * mul_11345);

  333. 			double mul_11385 = ((((mul_11363 + mul_11362) + mul_11353) + mul_11347) * add_11386);

  334. 			double sub_11382 = (mul_11385 - (mul_11383 + mul_11384));

  335. 			double mix_11734 = (in1 + (m_shift_37 * (sub_11382 - in1)));

  336. 			double mix_11323 = mix_11734;

  337. 			double mul_11396 = (mix_11323 * 0.707);

  338. 			double mix_11735 = (mul_11396 + (rsub_11547 * (m_history_1 - mul_11396)));

  339. 			double mix_11546 = mix_11735;

  340. 			double tap_11530 = m_delay_16.read_linear(mul_11531);

  341. 			double mul_11528 = (tap_11530 * 0.75);

  342. 			double sub_11527 = (mix_11546 - mul_11528);

  343. 			double mul_11526 = (sub_11527 * 0.75);

  344. 			double add_11525 = (mul_11526 + tap_11530);

  345. 			double tap_11514 = m_delay_15.read_linear(mul_11515);

  346. 			double mul_11512 = (tap_11514 * 0.625);

  347. 			double tap_11488 = m_delay_14.read_linear(mul_11489);

  348. 			double mul_11486 = (tap_11488 * 0.625);

  349. 			double tap_11523 = m_delay_13.read_linear(mul_11524);

  350. 			double mul_11521 = (tap_11523 * 0.75);

  351. 			double tap_11495 = m_delay_12.read_linear(mul_11496);

  352. 			double mul_11493 = (tap_11495 * 0.75);

  353. 			double mul_11417 = (mul_11405 * m_tail_32);

  354. 			double mul_11415 = (mul_11403 * m_tail_32);

  355. 			double add_11401 = (mul_11417 + mul_11415);

  356. 			double mul_11416 = (mul_11404 * m_tail_32);

  357. 			double mul_11414 = (mul_11402 * m_tail_32);

  358. 			double add_11400 = (mul_11416 + mul_11414);

  359. 			double sub_11409 = (add_11401 - add_11400);

  360. 			double mul_11413 = (mul_11460 * m_early_27);

  361. 			double mul_11411 = (mul_11456 * m_early_27);

  362. 			double add_11399 = (mul_11413 + mul_11411);

  363. 			double mul_11412 = (mul_11458 * m_early_27);

  364. 			double mul_11410 = (mul_11454 * m_early_27);

  365. 			double add_11398 = (mul_11412 + mul_11410);

  366. 			double sub_11408 = (add_11399 - add_11398);

  367. 			double add_11395 = (sub_11409 + sub_11408);

  368. 			double add_11407 = (add_11395 + mix_11323);

  369. 			double sub_11520 = (add_11407 - mul_11521);

  370. 			double mul_11519 = (sub_11520 * 0.75);

  371. 			double add_11518 = (mul_11519 + tap_11523);

  372. 			double sub_11511 = (add_11518 - mul_11512);

  373. 			double mul_11510 = (sub_11511 * 0.625);

  374. 			double add_11509 = (mul_11510 + tap_11514);

  375. 			double sub_11504 = (add_11509 - mul_11505);

  376. 			double mul_11503 = (sub_11504 * 0.625);

  377. 			double add_11502 = (mul_11503 + tap_11507);

  378. 			double mul_11406 = (add_11502 * m_mix_34);

  379. 			double out1 = (mul_11406 + in1);

  380. 			double add_11397 = (add_11395 + mix_11323);

  381. 			double sub_11492 = (add_11397 - mul_11493);

  382. 			double mul_11491 = (sub_11492 * 0.75);

  383. 			double add_11490 = (mul_11491 + tap_11495);

  384. 			double sub_11485 = (add_11490 - mul_11486);

  385. 			double mul_11484 = (sub_11485 * 0.625);

  386. 			double add_11483 = (mul_11484 + tap_11488);

  387. 			double sub_11478 = (add_11483 - mul_11479);

  388. 			double mul_11477 = (sub_11478 * 0.625);

  389. 			double add_11476 = (mul_11477 + tap_11481);

  390. 			double mul_11394 = (add_11476 * m_mix_34);

  391. 			double out2 = (mul_11394 + in1);

  392. 			double y2_next_11701 = m_y_2;

  393. 			double history_11541_next_11702 = mix_11542;

  394. 			double history_11439_next_11703 = mix_11440;

  395. 			double history_11445_next_11704 = mix_11446;

  396. 			double history_11433_next_11705 = mix_11434;

  397. 			double history_11315_next_11706 = sah_11314;

  398. 			double history_11317_next_11707 = sah_11316;

  399. 			double history_11322_next_11708 = sah_11320;

  400. 			double history_11319_next_11709 = sah_11318;

  401. 			double y1_next_11710 = sub_11382;

  402. 			double history_11545_next_11711 = mix_11546;

  403. 			m_delay_24.write(add_11430);

  404. 			m_delay_23.write(add_11428);

  405. 			m_delay_22.write(add_11429);

  406. 			m_delay_21.write(add_11427);

  407. 			m_delay_20.write(sub_11504);

  408. 			m_delay_19.write(sub_11478);

  409. 			m_delay_18.write(add_11525);

  410. 			m_delay_17.write(in1);

  411. 			m_delay_16.write(sub_11527);

  412. 			m_delay_15.write(sub_11511);

  413. 			m_delay_14.write(sub_11485);

  414. 			m_delay_13.write(sub_11520);

  415. 			m_delay_12.write(sub_11492);

  416. 			m_y_11 = y2_next_11701;

  417. 			m_history_10 = history_11541_next_11702;

  418. 			m_history_9 = history_11439_next_11703;

  419. 			m_history_8 = history_11445_next_11704;

  420. 			m_history_7 = history_11433_next_11705;

  421. 			m_history_6 = history_11315_next_11706;

  422. 			m_history_5 = history_11317_next_11707;

  423. 			m_history_4 = history_11322_next_11708;

  424. 			m_history_3 = history_11319_next_11709;

  425. 			m_y_2 = y1_next_11710;

  426. 			m_history_1 = history_11545_next_11711;

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

  452. 		m_tone_26 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  453. 	};

  454. 	inline void set_early(double _value) {

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

  456. 	};

  457. 	inline void set_roomsize(double _value) {

  458. 		m_roomsize_28 = (_value < 0.1 ? 0.1 : (_value > 300 ? 300 : _value));

  459. 	};

  460. 	inline void set_decay(double _value) {

  461. 		m_decay_29 = (_value < 0.1 ? 0.1 : (_value > 360 ? 360 : _value));

  462. 	};

  463. 	inline void set_damping(double _value) {

  464. 		m_damping_30 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  465. 	};

  466. 	inline void set_spread(double _value) {

  467. 		m_spread_31 = (_value < 0 ? 0 : (_value > 100 ? 100 : _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_blur(double _value) {

  473. 		m_blur_33 = (_value < 0 ? 0 : (_value > 0.25 ? 0.25 : _value));

  474. 	};

  475. 	inline void set_mix(double _value) {

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

  477. 	};

  478. 	inline void set_resonance(double _value) {

  479. 		m_resonance_35 = (_value < 0 ? 0 : (_value > 0.5 ? 0.5 : _value));

  480. 	};

  481. 	inline void set_cutoff(double _value) {

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

  483. 	};

  484. 	inline void set_shift(double _value) {

  485. 		m_shift_37 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  486. 	};

  487. 	inline void set_window(double _value) {

  488. 		m_window_38 = (_value < 0.1 ? 0.1 : (_value > 1000 ? 1000 : _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_tone(value); break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  604. 	pi->name = "tone";

  605. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  613. 	pi->outputmax = 1;

  614. 	pi->exp = 0;

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

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

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

  618. 	pi->name = "early";

  619. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  620. 	pi->defaultvalue = self->m_early_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_roomsize_28")

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

  632. 	pi->name = "roomsize";

  633. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  641. 	pi->outputmax = 300;

  642. 	pi->exp = 0;

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

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

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

  646. 	pi->name = "decay";

  647. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  648. 	pi->defaultvalue = self->m_decay_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.1;

  655. 	pi->outputmax = 360;

  656. 	pi->exp = 0;

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

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

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

  660. 	pi->name = "damping";

  661. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  670. 	pi->exp = 0;

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

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

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

  674. 	pi->name = "spread";

  675. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

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

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

  702. 	pi->name = "blur";

  703. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  704. 	pi->defaultvalue = self->m_blur_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 = 0.25;

  712. 	pi->exp = 0;

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

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

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

  716. 	pi->name = "mix";

  717. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  718. 	pi->defaultvalue = self->m_mix_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_resonance_35")

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

  730. 	pi->name = "resonance";

  731. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  732. 	pi->defaultvalue = self->m_resonance_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 = 0.5;

  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 = 8000;

  754. 	pi->exp = 0;

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

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

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

  758. 	pi->name = "shift";

  759. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  768. 	pi->exp = 0;

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

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

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

  772. 	pi->name = "window";

  773. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  781. 	pi->outputmax = 1000;

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