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

657 lines
23KB
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_21;

  35. 	Delay m_delay_13;

  36. 	Delay m_delay_14;

  37. 	Delay m_delay_12;

  38. 	Delay m_delay_11;

  39. 	Delay m_delay_23;

  40. 	Delay m_delay_15;

  41. 	Delay m_delay_17;

  42. 	Delay m_delay_16;

  43. 	Delay m_delay_19;

  44. 	Delay m_delay_18;

  45. 	Delay m_delay_20;

  46. 	Delay m_delay_22;

  47. 	Delta m_delta_39;

  48. 	Delta m_delta_36;

  49. 	Delta m_delta_42;

  50. 	Delta m_delta_33;

  51. 	Phasor m_phasor_32;

  52. 	Sah m_sah_37;

  53. 	Sah m_sah_35;

  54. 	Sah m_sah_38;

  55. 	Sah m_sah_41;

  56. 	Sah m_sah_40;

  57. 	Sah m_sah_34;

  58. 	Sah m_sah_44;

  59. 	Sah m_sah_43;

  60. 	double m_history_5;

  61. 	double m_history_6;

  62. 	double m_history_7;

  63. 	double m_history_10;

  64. 	double m_history_4;

  65. 	double m_y_2;

  66. 	double m_history_3;

  67. 	double samplerate;

  68. 	double m_history_1;

  69. 	double m_history_9;

  70. 	double m_history_8;

  71. 	double m_ratio_31;

  72. 	double samples_to_seconds;

  73. 	double m_mix_25;

  74. 	double m_bandwidth_24;

  75. 	double m_roomsize_27;

  76. 	double m_shimmer_26;

  77. 	double m_damping_29;

  78. 	double m_tone_30;

  79. 	double m_decay_28;

  80. 	int vectorsize;

  81. 	int __exception;

  82. 	// re-initialize all member variables;

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

  84. 		__exception = 0;

  85. 		vectorsize = __vs;

  86. 		samplerate = __sr;

  87. 		m_history_1 = 0;

  88. 		m_y_2 = 0;

  89. 		m_history_3 = 0;

  90. 		m_history_4 = 0;

  91. 		m_history_5 = 0;

  92. 		m_history_6 = 0;

  93. 		m_history_7 = 0;

  94. 		m_history_8 = 0;

  95. 		m_history_9 = 0;

  96. 		m_history_10 = 0;

  97. 		m_delay_11.reset("m_delay_11", 7000);

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

  99. 		m_delay_13.reset("m_delay_13", 6000);

  100. 		m_delay_14.reset("m_delay_14", 48000);

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

  102. 		m_delay_16.reset("m_delay_16", 15000);

  103. 		m_delay_17.reset("m_delay_17", 96000);

  104. 		m_delay_18.reset("m_delay_18", 12000);

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

  106. 		m_delay_20.reset("m_delay_20", 48000);

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

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

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

  110. 		m_bandwidth_24 = 75;

  111. 		m_mix_25 = 75;

  112. 		m_shimmer_26 = 30;

  113. 		m_roomsize_27 = 200;

  114. 		m_decay_28 = 50;

  115. 		m_damping_29 = 50;

  116. 		m_tone_30 = 1500;

  117. 		m_ratio_31 = 2;

  118. 		samples_to_seconds = (1 / samplerate);

  119. 		m_phasor_32.reset(0);

  120. 		m_delta_33.reset(0);

  121. 		m_sah_34.reset(0);

  122. 		m_sah_35.reset(0);

  123. 		m_delta_36.reset(0);

  124. 		m_sah_37.reset(0);

  125. 		m_sah_38.reset(0);

  126. 		m_delta_39.reset(0);

  127. 		m_sah_40.reset(0);

  128. 		m_sah_41.reset(0);

  129. 		m_delta_42.reset(0);

  130. 		m_sah_43.reset(0);

  131. 		m_sah_44.reset(0);

  132. 		genlib_reset_complete(this);

  133. 		

  134. 	};

  135. 	// the signal processing routine;

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

  137. 		vectorsize = __n;

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

  139. 		t_sample * __out1 = __outs[0];

  140. 		t_sample * __out2 = __outs[1];

  141. 		if (__exception) { 

  142. 			return __exception;

  143. 			

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

  145. 			__exception = GENLIB_ERR_NULL_BUFFER;

  146. 			return __exception;

  147. 			

  148. 		};

  149. 		double mul_13301 = (m_damping_29 * 0.01);

  150. 		double mul_13302 = (m_mix_25 * 0.01);

  151. 		double mul_13300 = (m_bandwidth_24 * 0.01);

  152. 		double rsub_13299 = (1 - mul_13300);

  153. 		double mul_13303 = (m_shimmer_26 * 0.01);

  154. 		double expr_13519 = safediv(((m_tone_30 * 2) * 3.1415926535898), 48000);

  155. 		double sin_13307 = sin(expr_13519);

  156. 		double clamp_13308 = ((sin_13307 <= 1e-05) ? 1e-05 : ((sin_13307 >= 0.99999) ? 0.99999 : sin_13307));

  157. 		double expr_13529 = safediv((m_roomsize_27 * 48000), 340);

  158. 		double mul_13509 = (expr_13529 * 1);

  159. 		double mul_13508 = (expr_13529 * 0.81649);

  160. 		double mul_13507 = (expr_13529 * 0.7071);

  161. 		double mul_13506 = (expr_13529 * 0.63245);

  162. 		double expr_13518 = safepow(1.0418, m_decay_28);

  163. 		double expr_13528 = safepow(0.001, safediv(1, (expr_13518 * 48000)));

  164. 		double expr_13527 = (-safepow(expr_13528, mul_13509));

  165. 		double expr_13522 = (-safepow(expr_13528, mul_13508));

  166. 		double expr_13521 = (-safepow(expr_13528, mul_13507));

  167. 		double expr_13520 = (-safepow(expr_13528, mul_13506));

  168. 		double mul_13503 = (expr_13529 * 0.000527);

  169. 		int int_13502 = int(mul_13503);

  170. 		double mul_13480 = (int_13502 * 400.600006);

  171. 		double mul_13459 = (int_13502 * 419.5);

  172. 		double rsub_13358 = (1 - m_ratio_31);

  173. 		double mul_13357 = (rsub_13358 * 10);

  174. 		samples_to_seconds = (1 / samplerate);

  175. 		double add_13446 = (expr_13529 + 5);

  176. 		double expr_13523 = safepow(expr_13528, add_13446);

  177. 		double mul_13487 = (int_13502 * 568.299988);

  178. 		double mul_13466 = (int_13502 * 566.700012);

  179. 		double mul_13452 = (expr_13529 * 0.41);

  180. 		double add_13449 = (mul_13452 + 5);

  181. 		double expr_13526 = safepow(expr_13528, add_13449);

  182. 		double mul_13451 = (expr_13529 * 0.3);

  183. 		double add_13448 = (mul_13451 + 5);

  184. 		double expr_13525 = safepow(expr_13528, add_13448);

  185. 		double mul_13450 = (expr_13529 * 0.155);

  186. 		double add_13447 = (mul_13450 + 5);

  187. 		double expr_13524 = safepow(expr_13528, add_13447);

  188. 		double mul_13501 = (expr_13529 * 0.110732);

  189. 		double mul_13494 = (int_13502 * 162.100006);

  190. 		double mul_13473 = (int_13502 * 144.800003);

  191. 		double mul_13297 = (m_decay_28 * 2);

  192. 		double clamp_13292 = ((mul_13297 <= 0) ? 0 : ((mul_13297 >= 100) ? 100 : mul_13297));

  193. 		double mul_13296 = (clamp_13292 * 0.01);

  194. 		double atodb_13295 = atodb(mul_13296);

  195. 		double sub_13294 = (atodb_13295 - 9);

  196. 		double dbtoa_13293 = dbtoa(sub_13294);

  197. 		// the main sample loop;

  198. 		while ((__n--)) { 

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

  200. 			double noise_13309 = noise();

  201. 			double abs_13326 = fabs(noise_13309);

  202. 			double mul_13330 = (abs_13326 * 0.25);

  203. 			double noise_13310 = noise();

  204. 			double abs_13327 = fabs(noise_13310);

  205. 			double mul_13333 = (abs_13327 * 0.25);

  206. 			double noise_13311 = noise();

  207. 			double abs_13328 = fabs(noise_13311);

  208. 			double mul_13336 = (abs_13328 * 0.25);

  209. 			double noise_13312 = noise();

  210. 			double abs_13329 = fabs(noise_13312);

  211. 			double mul_13339 = (abs_13329 * 0.25);

  212. 			double tap_13514 = m_delay_23.read_cubic(mul_13509);

  213. 			double tap_13432 = m_delay_22.read_cubic(mul_13508);

  214. 			double tap_13426 = m_delay_21.read_cubic(mul_13507);

  215. 			double tap_13420 = m_delay_20.read_cubic(mul_13506);

  216. 			double mul_13505 = (tap_13514 * expr_13527);

  217. 			double mix_13540 = (mul_13505 + (mul_13301 * (m_history_10 - mul_13505)));

  218. 			double mix_13512 = mix_13540;

  219. 			double mul_13428 = (tap_13432 * expr_13522);

  220. 			double mix_13541 = (mul_13428 + (mul_13301 * (m_history_9 - mul_13428)));

  221. 			double mix_13430 = mix_13541;

  222. 			double mul_13422 = (tap_13426 * expr_13521);

  223. 			double mix_13542 = (mul_13422 + (mul_13301 * (m_history_8 - mul_13422)));

  224. 			double mix_13424 = mix_13542;

  225. 			double mul_13416 = (tap_13420 * expr_13520);

  226. 			double mix_13543 = (mul_13416 + (mul_13301 * (m_history_7 - mul_13416)));

  227. 			double mix_13418 = mix_13543;

  228. 			double tap_13479 = m_delay_19.read_linear(mul_13480);

  229. 			double mul_13477 = (tap_13479 * 0.625);

  230. 			double tap_13458 = m_delay_18.read_linear(mul_13459);

  231. 			double mul_13456 = (tap_13458 * 0.625);

  232. 			double phasor_13376 = m_phasor_32(mul_13357, samples_to_seconds);

  233. 			double add_13350 = ((m_history_6 + phasor_13376) + 0.75);

  234. 			double mod_13349 = safemod(add_13350, 1);

  235. 			double delta_13332 = m_delta_33(mod_13349);

  236. 			double sah_13313 = m_sah_34(mul_13330, delta_13332, 0);

  237. 			int sah_13331 = m_sah_35(4800, delta_13332, 0);

  238. 			double mul_13322 = (sah_13331 * mod_13349);

  239. 			double sub_13348 = (mod_13349 - 0.5);

  240. 			double mul_13347 = (sub_13348 * 3.1415926535898);

  241. 			double cos_13346 = cos(mul_13347);

  242. 			double mul_13341 = (cos_13346 * cos_13346);

  243. 			double add_13356 = ((m_history_5 + phasor_13376) + 0.5);

  244. 			double mod_13355 = safemod(add_13356, 1);

  245. 			double delta_13335 = m_delta_36(mod_13355);

  246. 			double sah_13315 = m_sah_37(mul_13333, delta_13335, 0);

  247. 			int sah_13334 = m_sah_38(4800, delta_13335, 0);

  248. 			double mul_13323 = (sah_13334 * mod_13355);

  249. 			double sub_13354 = (mod_13355 - 0.5);

  250. 			double mul_13353 = (sub_13354 * 3.1415926535898);

  251. 			double cos_13352 = cos(mul_13353);

  252. 			double mul_13342 = (cos_13352 * cos_13352);

  253. 			double add_13370 = ((m_history_4 + phasor_13376) + 0.25);

  254. 			double mod_13369 = safemod(add_13370, 1);

  255. 			double delta_13338 = m_delta_39(mod_13369);

  256. 			double sah_13317 = m_sah_40(mul_13336, delta_13338, 0);

  257. 			int sah_13337 = m_sah_41(4800, delta_13338, 0);

  258. 			double mul_13324 = (sah_13337 * mod_13369);

  259. 			double sub_13368 = (mod_13369 - 0.5);

  260. 			double mul_13367 = (sub_13368 * 3.1415926535898);

  261. 			double cos_13366 = cos(mul_13367);

  262. 			double mul_13343 = (cos_13366 * cos_13366);

  263. 			double add_13375 = ((m_history_3 + phasor_13376) + 0);

  264. 			double mod_13374 = safemod(add_13375, 1);

  265. 			double delta_13320 = m_delta_42(mod_13374);

  266. 			double sah_13319 = m_sah_43(mul_13339, delta_13320, 0);

  267. 			int sah_13340 = m_sah_44(4800, delta_13320, 0);

  268. 			double mul_13325 = (sah_13340 * mod_13374);

  269. 			double tap_13362 = m_delay_17.read_linear(mul_13325);

  270. 			double tap_13363 = m_delay_17.read_linear(mul_13324);

  271. 			double tap_13364 = m_delay_17.read_linear(mul_13323);

  272. 			double tap_13365 = m_delay_17.read_linear(mul_13322);

  273. 			double mul_13345 = (tap_13365 * mul_13341);

  274. 			double mul_13351 = (tap_13364 * mul_13342);

  275. 			double mul_13359 = (tap_13363 * mul_13343);

  276. 			double sub_13373 = (mod_13374 - 0.5);

  277. 			double mul_13372 = (sub_13373 * 3.1415926535898);

  278. 			double cos_13371 = cos(mul_13372);

  279. 			double mul_13344 = (cos_13371 * cos_13371);

  280. 			double mul_13360 = (tap_13362 * mul_13344);

  281. 			double add_13545 = (((mul_13360 + mul_13359) + mul_13351) + mul_13345);

  282. 			double mix_13544 = (m_y_2 + (clamp_13308 * (add_13545 - m_y_2)));

  283. 			double mix_13305 = mix_13544;

  284. 			double mix_13546 = (in1 + (mul_13303 * (mix_13305 - in1)));

  285. 			double mix_13377 = mix_13546;

  286. 			double mul_13380 = (mix_13377 * 0.707);

  287. 			double mix_13547 = (mul_13380 + (rsub_13299 * (m_history_1 - mul_13380)));

  288. 			double mix_13516 = mix_13547;

  289. 			double add_13410 = (mix_13512 + mix_13430);

  290. 			double add_13408 = (mix_13424 + mix_13418);

  291. 			double sub_13407 = (add_13410 - add_13408);

  292. 			double mul_13389 = (sub_13407 * 0.5);

  293. 			double add_13403 = (add_13410 + add_13408);

  294. 			double mul_13386 = (add_13403 * 0.5);

  295. 			double tap_13486 = m_delay_16.read_linear(mul_13487);

  296. 			double tap_13465 = m_delay_15.read_linear(mul_13466);

  297. 			double sub_13409 = (mix_13512 - mix_13430);

  298. 			double sub_13406 = (mix_13424 - mix_13418);

  299. 			double sub_13405 = (sub_13409 - sub_13406);

  300. 			double mul_13388 = (sub_13405 * 0.5);

  301. 			double add_13404 = (sub_13409 + sub_13406);

  302. 			double rsub_13402 = (0 - add_13404);

  303. 			double mul_13387 = (rsub_13402 * 0.5);

  304. 			double tap_13434 = m_delay_14.read_cubic(add_13449);

  305. 			double tap_13435 = m_delay_14.read_cubic(add_13448);

  306. 			double tap_13436 = m_delay_14.read_cubic(add_13447);

  307. 			double tap_13437 = m_delay_14.read_cubic(add_13446);

  308. 			double mul_13444 = (tap_13434 * expr_13526);

  309. 			double add_13414 = (mul_13389 + mul_13444);

  310. 			double mul_13442 = (tap_13435 * expr_13525);

  311. 			double add_13413 = (mul_13388 + mul_13442);

  312. 			double mul_13438 = (tap_13437 * expr_13523);

  313. 			double add_13411 = (mul_13386 + mul_13438);

  314. 			double mul_13440 = (tap_13436 * expr_13524);

  315. 			double add_13412 = (mul_13387 + mul_13440);

  316. 			double mul_13484 = (tap_13486 * 0.625);

  317. 			double mul_13463 = (tap_13465 * 0.625);

  318. 			double tap_13500 = m_delay_13.read_cubic(mul_13501);

  319. 			double mul_13498 = (tap_13500 * 0.75);

  320. 			double sub_13497 = (mix_13516 - mul_13498);

  321. 			double mul_13496 = (sub_13497 * 0.75);

  322. 			double add_13495 = (mul_13496 + tap_13500);

  323. 			double tap_13493 = m_delay_12.read_linear(mul_13494);

  324. 			double tap_13472 = m_delay_11.read_linear(mul_13473);

  325. 			double mul_13491 = (tap_13493 * 0.75);

  326. 			double mul_13470 = (tap_13472 * 0.75);

  327. 			double mul_13397 = (mul_13444 * mul_13296);

  328. 			double mul_13395 = (mul_13440 * mul_13296);

  329. 			double add_13383 = (mul_13397 + mul_13395);

  330. 			double mul_13396 = (mul_13442 * mul_13296);

  331. 			double mul_13394 = (mul_13438 * mul_13296);

  332. 			double add_13382 = (mul_13396 + mul_13394);

  333. 			double sub_13392 = (add_13383 - add_13382);

  334. 			double mul_13401 = (mul_13389 * dbtoa_13293);

  335. 			double mul_13399 = (mul_13387 * dbtoa_13293);

  336. 			double add_13385 = (mul_13401 + mul_13399);

  337. 			double mul_13400 = (mul_13388 * dbtoa_13293);

  338. 			double mul_13398 = (mul_13386 * dbtoa_13293);

  339. 			double add_13384 = (mul_13400 + mul_13398);

  340. 			double sub_13393 = (add_13385 - add_13384);

  341. 			double add_13379 = (sub_13393 + sub_13392);

  342. 			double add_13391 = (add_13379 + mix_13377);

  343. 			double sub_13490 = (add_13391 - mul_13491);

  344. 			double mul_13489 = (sub_13490 * 0.75);

  345. 			double add_13488 = (mul_13489 + tap_13493);

  346. 			double sub_13483 = (add_13488 - mul_13484);

  347. 			double mul_13482 = (sub_13483 * 0.625);

  348. 			double add_13481 = (mul_13482 + tap_13486);

  349. 			double sub_13476 = (add_13481 - mul_13477);

  350. 			double mul_13475 = (sub_13476 * 0.625);

  351. 			double add_13474 = (mul_13475 + tap_13479);

  352. 			double mul_13390 = (add_13474 * mul_13302);

  353. 			double out1 = (in1 + mul_13390);

  354. 			double add_13381 = (add_13379 + mix_13377);

  355. 			double sub_13469 = (add_13381 - mul_13470);

  356. 			double mul_13468 = (sub_13469 * 0.75);

  357. 			double add_13467 = (mul_13468 + tap_13472);

  358. 			double sub_13462 = (add_13467 - mul_13463);

  359. 			double mul_13461 = (sub_13462 * 0.625);

  360. 			double add_13460 = (mul_13461 + tap_13465);

  361. 			double sub_13455 = (add_13460 - mul_13456);

  362. 			double mul_13454 = (sub_13455 * 0.625);

  363. 			double add_13453 = (mul_13454 + tap_13458);

  364. 			double mul_13378 = (add_13453 * mul_13302);

  365. 			double out2 = (in1 + mul_13378);

  366. 			double history_13511_next_13530 = mix_13512;

  367. 			double history_13429_next_13531 = mix_13430;

  368. 			double history_13423_next_13532 = mix_13424;

  369. 			double history_13417_next_13533 = mix_13418;

  370. 			double history_13314_next_13534 = sah_13313;

  371. 			double history_13316_next_13535 = sah_13315;

  372. 			double history_13318_next_13536 = sah_13317;

  373. 			double history_13321_next_13537 = sah_13319;

  374. 			double y0_next_13538 = mix_13305;

  375. 			double history_13515_next_13539 = mix_13516;

  376. 			m_delay_23.write(add_13414);

  377. 			m_delay_22.write(add_13413);

  378. 			m_delay_21.write(add_13412);

  379. 			m_delay_20.write(add_13411);

  380. 			m_delay_19.write(sub_13476);

  381. 			m_delay_18.write(sub_13455);

  382. 			m_delay_17.write(in1);

  383. 			m_delay_16.write(sub_13483);

  384. 			m_delay_15.write(sub_13462);

  385. 			m_delay_14.write(add_13495);

  386. 			m_delay_13.write(sub_13497);

  387. 			m_delay_12.write(sub_13490);

  388. 			m_delay_11.write(sub_13469);

  389. 			m_history_10 = history_13511_next_13530;

  390. 			m_history_9 = history_13429_next_13531;

  391. 			m_history_8 = history_13423_next_13532;

  392. 			m_history_7 = history_13417_next_13533;

  393. 			m_history_6 = history_13314_next_13534;

  394. 			m_history_5 = history_13316_next_13535;

  395. 			m_history_4 = history_13318_next_13536;

  396. 			m_history_3 = history_13321_next_13537;

  397. 			m_y_2 = y0_next_13538;

  398. 			m_history_1 = history_13515_next_13539;

  399. 			m_delay_11.step();

  400. 			m_delay_12.step();

  401. 			m_delay_13.step();

  402. 			m_delay_14.step();

  403. 			m_delay_15.step();

  404. 			m_delay_16.step();

  405. 			m_delay_17.step();

  406. 			m_delay_18.step();

  407. 			m_delay_19.step();

  408. 			m_delay_20.step();

  409. 			m_delay_21.step();

  410. 			m_delay_22.step();

  411. 			m_delay_23.step();

  412. 			// assign results to output buffer;

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

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

  415. 			

  416. 		};

  417. 		return __exception;

  418. 		

  419. 	};

  420. 	inline void set_bandwidth(double _value) {

  421. 		m_bandwidth_24 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  422. 	};

  423. 	inline void set_mix(double _value) {

  424. 		m_mix_25 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  425. 	};

  426. 	inline void set_shimmer(double _value) {

  427. 		m_shimmer_26 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  428. 	};

  429. 	inline void set_roomsize(double _value) {

  430. 		m_roomsize_27 = (_value < 1 ? 1 : (_value > 300 ? 300 : _value));

  431. 	};

  432. 	inline void set_decay(double _value) {

  433. 		m_decay_28 = (_value < 1 ? 1 : (_value > 100 ? 100 : _value));

  434. 	};

  435. 	inline void set_damping(double _value) {

  436. 		m_damping_29 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  437. 	};

  438. 	inline void set_tone(double _value) {

  439. 		m_tone_30 = (_value < 500 ? 500 : (_value > 6000 ? 6000 : _value));

  440. 	};

  441. 	inline void set_ratio(double _value) {

  442. 		m_ratio_31 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  443. 	};

  444. 	

  445. } State;

  446. 

  447. 

  448. /// 

  449. ///	Configuration for the genlib API

  450. ///

  451. 

  452. /// Number of signal inputs and outputs 

  453. 

  454. int gen_kernel_numins = 1;

  455. int gen_kernel_numouts = 2;

  456. 

  457. int num_inputs() { return gen_kernel_numins; }

  458. int num_outputs() { return gen_kernel_numouts; }

  459. int num_params() { return 8; }

  460. 

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

  462. 

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

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

  465. 

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

  467. 

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

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

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

  471. }

  472. 

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

  474. 

  475. void reset(CommonState *cself) { 

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

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

  478. }

  479. 

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

  481. 

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

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

  484. 	switch (index) {

  485. 		case 0: self->set_bandwidth(value); break;

  486. 		case 1: self->set_mix(value); break;

  487. 		case 2: self->set_shimmer(value); break;

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

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

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

  491. 		case 6: self->set_tone(value); break;

  492. 		case 7: self->set_ratio(value); break;

  493. 		

  494. 		default: break;

  495. 	}

  496. }

  497. 

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

  499. 

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

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

  502. 	switch (index) {

  503. 		case 0: *value = self->m_bandwidth_24; break;

  504. 		case 1: *value = self->m_mix_25; break;

  505. 		case 2: *value = self->m_shimmer_26; break;

  506. 		case 3: *value = self->m_roomsize_27; break;

  507. 		case 4: *value = self->m_decay_28; break;

  508. 		case 5: *value = self->m_damping_29; break;

  509. 		case 6: *value = self->m_tone_30; break;

  510. 		case 7: *value = self->m_ratio_31; break;

  511. 		

  512. 		default: break;

  513. 	}

  514. }

  515. 

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

  517. 

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

  519. 	State *self = new State;

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

  521. 	ParamInfo *pi;

  522. 	self->__commonstate.inputnames = gen_kernel_innames;

  523. 	self->__commonstate.outputnames = gen_kernel_outnames;

  524. 	self->__commonstate.numins = gen_kernel_numins;

  525. 	self->__commonstate.numouts = gen_kernel_numouts;

  526. 	self->__commonstate.sr = sr;

  527. 	self->__commonstate.vs = vs;

  528. 	self->__commonstate.params = (ParamInfo *)genlib_sysmem_newptr(8 * sizeof(ParamInfo));

  529. 	self->__commonstate.numparams = 8;

  530. 	// initialize parameter 0 ("m_bandwidth_24")

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

  532. 	pi->name = "bandwidth";

  533. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  534. 	pi->defaultvalue = self->m_bandwidth_24;

  535. 	pi->defaultref = 0;

  536. 	pi->hasinputminmax = false;

  537. 	pi->inputmin = 0; 

  538. 	pi->inputmax = 1;

  539. 	pi->hasminmax = true;

  540. 	pi->outputmin = 0;

  541. 	pi->outputmax = 100;

  542. 	pi->exp = 0;

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

  544. 	// initialize parameter 1 ("m_mix_25")

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

  546. 	pi->name = "mix";

  547. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  548. 	pi->defaultvalue = self->m_mix_25;

  549. 	pi->defaultref = 0;

  550. 	pi->hasinputminmax = false;

  551. 	pi->inputmin = 0; 

  552. 	pi->inputmax = 1;

  553. 	pi->hasminmax = true;

  554. 	pi->outputmin = 0;

  555. 	pi->outputmax = 100;

  556. 	pi->exp = 0;

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

  558. 	// initialize parameter 2 ("m_shimmer_26")

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

  560. 	pi->name = "shimmer";

  561. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  562. 	pi->defaultvalue = self->m_shimmer_26;

  563. 	pi->defaultref = 0;

  564. 	pi->hasinputminmax = false;

  565. 	pi->inputmin = 0; 

  566. 	pi->inputmax = 1;

  567. 	pi->hasminmax = true;

  568. 	pi->outputmin = 0;

  569. 	pi->outputmax = 100;

  570. 	pi->exp = 0;

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

  572. 	// initialize parameter 3 ("m_roomsize_27")

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

  574. 	pi->name = "roomsize";

  575. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  576. 	pi->defaultvalue = self->m_roomsize_27;

  577. 	pi->defaultref = 0;

  578. 	pi->hasinputminmax = false;

  579. 	pi->inputmin = 0; 

  580. 	pi->inputmax = 1;

  581. 	pi->hasminmax = true;

  582. 	pi->outputmin = 1;

  583. 	pi->outputmax = 300;

  584. 	pi->exp = 0;

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

  586. 	// initialize parameter 4 ("m_decay_28")

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

  588. 	pi->name = "decay";

  589. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  590. 	pi->defaultvalue = self->m_decay_28;

  591. 	pi->defaultref = 0;

  592. 	pi->hasinputminmax = false;

  593. 	pi->inputmin = 0; 

  594. 	pi->inputmax = 1;

  595. 	pi->hasminmax = true;

  596. 	pi->outputmin = 1;

  597. 	pi->outputmax = 100;

  598. 	pi->exp = 0;

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

  600. 	// initialize parameter 5 ("m_damping_29")

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

  602. 	pi->name = "damping";

  603. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  604. 	pi->defaultvalue = self->m_damping_29;

  605. 	pi->defaultref = 0;

  606. 	pi->hasinputminmax = false;

  607. 	pi->inputmin = 0; 

  608. 	pi->inputmax = 1;

  609. 	pi->hasminmax = true;

  610. 	pi->outputmin = 0;

  611. 	pi->outputmax = 100;

  612. 	pi->exp = 0;

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

  614. 	// initialize parameter 6 ("m_tone_30")

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

  616. 	pi->name = "tone";

  617. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  618. 	pi->defaultvalue = self->m_tone_30;

  619. 	pi->defaultref = 0;

  620. 	pi->hasinputminmax = false;

  621. 	pi->inputmin = 0; 

  622. 	pi->inputmax = 1;

  623. 	pi->hasminmax = true;

  624. 	pi->outputmin = 500;

  625. 	pi->outputmax = 6000;

  626. 	pi->exp = 0;

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

  628. 	// initialize parameter 7 ("m_ratio_31")

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

  630. 	pi->name = "ratio";

  631. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  632. 	pi->defaultvalue = self->m_ratio_31;

  633. 	pi->defaultref = 0;

  634. 	pi->hasinputminmax = false;

  635. 	pi->inputmin = 0; 

  636. 	pi->inputmax = 1;

  637. 	pi->hasminmax = true;

  638. 	pi->outputmin = 0.5;

  639. 	pi->outputmax = 2;

  640. 	pi->exp = 0;

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

  642. 	

  643. 	return self;

  644. }

  645. 

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

  647. 

  648. void destroy(CommonState *cself) { 

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

  650. 	genlib_sysmem_freeptr(cself->params);

  651. 		

  652. 	delete self; 

  653. }

  654. 

  655. 

  656. } // gen_exported::