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

634 lines
21KB
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_38;

  48. 	Delta m_delta_35;

  49. 	Delta m_delta_41;

  50. 	Delta m_delta_32;

  51. 	Phasor m_phasor_31;

  52. 	Sah m_sah_36;

  53. 	Sah m_sah_34;

  54. 	Sah m_sah_37;

  55. 	Sah m_sah_40;

  56. 	Sah m_sah_39;

  57. 	Sah m_sah_33;

  58. 	Sah m_sah_43;

  59. 	Sah m_sah_42;

  60. 	double m_history_4;

  61. 	double m_history_5;

  62. 	double m_history_6;

  63. 	double m_history_7;

  64. 	double m_history_3;

  65. 	double m_history_1;

  66. 	double m_y_2;

  67. 	double samplerate;

  68. 	double m_history_10;

  69. 	double m_history_8;

  70. 	double samples_to_seconds;

  71. 	double m_history_9;

  72. 	double m_ratio_25;

  73. 	double m_roomsize_24;

  74. 	double m_decay_27;

  75. 	double m_damping_26;

  76. 	double m_mix_29;

  77. 	double m_shimmer_30;

  78. 	double m_tone_28;

  79. 	int vectorsize;

  80. 	int __exception;

  81. 	// re-initialize all member variables;

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

  83. 		__exception = 0;

  84. 		vectorsize = __vs;

  85. 		samplerate = __sr;

  86. 		m_history_1 = 0;

  87. 		m_y_2 = 0;

  88. 		m_history_3 = 0;

  89. 		m_history_4 = 0;

  90. 		m_history_5 = 0;

  91. 		m_history_6 = 0;

  92. 		m_history_7 = 0;

  93. 		m_history_8 = 0;

  94. 		m_history_9 = 0;

  95. 		m_history_10 = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

  109. 		m_roomsize_24 = 100;

  110. 		m_ratio_25 = 2;

  111. 		m_damping_26 = 75;

  112. 		m_decay_27 = 50;

  113. 		m_tone_28 = 3000;

  114. 		m_mix_29 = 75;

  115. 		m_shimmer_30 = 50;

  116. 		samples_to_seconds = (1 / samplerate);

  117. 		m_phasor_31.reset(0);

  118. 		m_delta_32.reset(0);

  119. 		m_sah_33.reset(0);

  120. 		m_sah_34.reset(0);

  121. 		m_delta_35.reset(0);

  122. 		m_sah_36.reset(0);

  123. 		m_sah_37.reset(0);

  124. 		m_delta_38.reset(0);

  125. 		m_sah_39.reset(0);

  126. 		m_sah_40.reset(0);

  127. 		m_delta_41.reset(0);

  128. 		m_sah_42.reset(0);

  129. 		m_sah_43.reset(0);

  130. 		genlib_reset_complete(this);

  131. 		

  132. 	};

  133. 	// the signal processing routine;

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

  135. 		vectorsize = __n;

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

  137. 		t_sample * __out1 = __outs[0];

  138. 		t_sample * __out2 = __outs[1];

  139. 		if (__exception) { 

  140. 			return __exception;

  141. 			

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

  143. 			__exception = GENLIB_ERR_NULL_BUFFER;

  144. 			return __exception;

  145. 			

  146. 		};

  147. 		double mul_6640 = (m_damping_26 * 0.01);

  148. 		double mul_6639 = (m_mix_29 * 0.01);

  149. 		double mul_6641 = (m_shimmer_30 * 0.01);

  150. 		double expr_6646 = safediv(((m_tone_28 * 2) * 3.1415926535898), 48000);

  151. 		double sin_6647 = sin(expr_6646);

  152. 		double clamp_6648 = ((sin_6647 <= 1e-05) ? 1e-05 : ((sin_6647 >= 0.99999) ? 0.99999 : sin_6647));

  153. 		double expr_6857 = safediv((m_roomsize_24 * 48000), 340);

  154. 		double mul_6849 = (expr_6857 * 1);

  155. 		double mul_6846 = (expr_6857 * 0.63245);

  156. 		double mul_6847 = (expr_6857 * 0.7071);

  157. 		double mul_6848 = (expr_6857 * 0.81649);

  158. 		double mul_6644 = (m_decay_27 * 3.6);

  159. 		double expr_6850 = safepow(0.001, safediv(1, (mul_6644 * 48000)));

  160. 		double expr_6844 = (-safepow(expr_6850, mul_6849));

  161. 		double expr_6755 = (-safepow(expr_6850, mul_6846));

  162. 		double expr_6761 = (-safepow(expr_6850, mul_6847));

  163. 		double expr_6767 = (-safepow(expr_6850, mul_6848));

  164. 		double mul_6843 = (expr_6857 * 0.000527);

  165. 		int int_6842 = int(mul_6843);

  166. 		double mul_6820 = (int_6842 * 400.600006);

  167. 		double mul_6799 = (int_6842 * 419.5);

  168. 		double rsub_6698 = (1 - m_ratio_25);

  169. 		double mul_6697 = (rsub_6698 * 10);

  170. 		samples_to_seconds = (1 / samplerate);

  171. 		double add_6786 = (expr_6857 + 5);

  172. 		double expr_6779 = safepow(expr_6850, add_6786);

  173. 		double mul_6827 = (int_6842 * 568.299988);

  174. 		double mul_6806 = (int_6842 * 566.700012);

  175. 		double mul_6792 = (expr_6857 * 0.41);

  176. 		double add_6789 = (mul_6792 + 5);

  177. 		double expr_6785 = safepow(expr_6850, add_6789);

  178. 		double mul_6791 = (expr_6857 * 0.3);

  179. 		double add_6788 = (mul_6791 + 5);

  180. 		double expr_6783 = safepow(expr_6850, add_6788);

  181. 		double mul_6790 = (expr_6857 * 0.155);

  182. 		double add_6787 = (mul_6790 + 5);

  183. 		double expr_6781 = safepow(expr_6850, add_6787);

  184. 		double mul_6841 = (expr_6857 * 0.110732);

  185. 		double mul_6834 = (int_6842 * 162.100006);

  186. 		double mul_6813 = (int_6842 * 144.800003);

  187. 		double expr_6861 = safepow(1.0472, m_decay_27);

  188. 		double sub_6862 = (expr_6861 - 1);

  189. 		double mul_6643 = (sub_6862 * 0.01);

  190. 		double mul_6859 = (m_decay_27 * 0.75);

  191. 		double add_6858 = (mul_6859 + 25);

  192. 		double mul_6860 = (add_6858 * 0.01);

  193. 		// the main sample loop;

  194. 		while ((__n--)) { 

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

  196. 			double noise_6650 = noise();

  197. 			double abs_6667 = fabs(noise_6650);

  198. 			double mul_6673 = (abs_6667 * 0.25);

  199. 			double noise_6649 = noise();

  200. 			double abs_6666 = fabs(noise_6649);

  201. 			double mul_6670 = (abs_6666 * 0.25);

  202. 			double noise_6651 = noise();

  203. 			double abs_6668 = fabs(noise_6651);

  204. 			double mul_6676 = (abs_6668 * 0.25);

  205. 			double noise_6652 = noise();

  206. 			double abs_6669 = fabs(noise_6652);

  207. 			double mul_6679 = (abs_6669 * 0.25);

  208. 			double tap_6854 = m_delay_23.read_linear(mul_6849);

  209. 			double tap_6760 = m_delay_22.read_linear(mul_6846);

  210. 			double tap_6766 = m_delay_21.read_linear(mul_6847);

  211. 			double tap_6772 = m_delay_20.read_linear(mul_6848);

  212. 			double mul_6845 = (tap_6854 * expr_6844);

  213. 			double mix_6913 = (mul_6845 + (mul_6640 * (m_history_10 - mul_6845)));

  214. 			double mix_6852 = mix_6913;

  215. 			double mul_6756 = (tap_6760 * expr_6755);

  216. 			double mix_6914 = (mul_6756 + (mul_6640 * (m_history_9 - mul_6756)));

  217. 			double mix_6758 = mix_6914;

  218. 			double mul_6762 = (tap_6766 * expr_6761);

  219. 			double mix_6915 = (mul_6762 + (mul_6640 * (m_history_8 - mul_6762)));

  220. 			double mix_6764 = mix_6915;

  221. 			double mul_6768 = (tap_6772 * expr_6767);

  222. 			double mix_6916 = (mul_6768 + (mul_6640 * (m_history_7 - mul_6768)));

  223. 			double mix_6770 = mix_6916;

  224. 			double tap_6819 = m_delay_19.read_linear(mul_6820);

  225. 			double mul_6817 = (tap_6819 * 0.625);

  226. 			double tap_6798 = m_delay_18.read_linear(mul_6799);

  227. 			double mul_6796 = (tap_6798 * 0.625);

  228. 			double phasor_6716 = m_phasor_31(mul_6697, samples_to_seconds);

  229. 			double add_6696 = ((m_history_6 + phasor_6716) + 0.5);

  230. 			double mod_6695 = safemod(add_6696, 1);

  231. 			double delta_6675 = m_delta_32(mod_6695);

  232. 			double sah_6655 = m_sah_33(mul_6673, delta_6675, 0);

  233. 			int sah_6674 = m_sah_34(4800, delta_6675, 0);

  234. 			double mul_6663 = (sah_6674 * mod_6695);

  235. 			double sub_6694 = (mod_6695 - 0.5);

  236. 			double mul_6693 = (sub_6694 * 3.1415926535898);

  237. 			double cos_6692 = cos(mul_6693);

  238. 			double mul_6682 = (cos_6692 * cos_6692);

  239. 			double add_6690 = ((m_history_5 + phasor_6716) + 0.75);

  240. 			double mod_6689 = safemod(add_6690, 1);

  241. 			double delta_6672 = m_delta_35(mod_6689);

  242. 			double sah_6653 = m_sah_36(mul_6670, delta_6672, 0);

  243. 			int sah_6671 = m_sah_37(4800, delta_6672, 0);

  244. 			double mul_6662 = (sah_6671 * mod_6689);

  245. 			double sub_6688 = (mod_6689 - 0.5);

  246. 			double mul_6687 = (sub_6688 * 3.1415926535898);

  247. 			double cos_6686 = cos(mul_6687);

  248. 			double mul_6681 = (cos_6686 * cos_6686);

  249. 			double add_6710 = ((m_history_4 + phasor_6716) + 0.25);

  250. 			double mod_6709 = safemod(add_6710, 1);

  251. 			double delta_6678 = m_delta_38(mod_6709);

  252. 			double sah_6657 = m_sah_39(mul_6676, delta_6678, 0);

  253. 			int sah_6677 = m_sah_40(4800, delta_6678, 0);

  254. 			double mul_6664 = (sah_6677 * mod_6709);

  255. 			double sub_6708 = (mod_6709 - 0.5);

  256. 			double mul_6707 = (sub_6708 * 3.1415926535898);

  257. 			double cos_6706 = cos(mul_6707);

  258. 			double mul_6683 = (cos_6706 * cos_6706);

  259. 			double add_6715 = ((m_history_3 + phasor_6716) + 0);

  260. 			double mod_6714 = safemod(add_6715, 1);

  261. 			double delta_6660 = m_delta_41(mod_6714);

  262. 			double sah_6659 = m_sah_42(mul_6679, delta_6660, 0);

  263. 			int sah_6680 = m_sah_43(4800, delta_6660, 0);

  264. 			double mul_6665 = (sah_6680 * mod_6714);

  265. 			double tap_6702 = m_delay_17.read_linear(mul_6665);

  266. 			double tap_6703 = m_delay_17.read_linear(mul_6664);

  267. 			double tap_6704 = m_delay_17.read_linear(mul_6663);

  268. 			double tap_6705 = m_delay_17.read_linear(mul_6662);

  269. 			double mul_6685 = (tap_6705 * mul_6681);

  270. 			double mul_6691 = (tap_6704 * mul_6682);

  271. 			double mul_6699 = (tap_6703 * mul_6683);

  272. 			double sub_6713 = (mod_6714 - 0.5);

  273. 			double mul_6712 = (sub_6713 * 3.1415926535898);

  274. 			double cos_6711 = cos(mul_6712);

  275. 			double mul_6684 = (cos_6711 * cos_6711);

  276. 			double mul_6700 = (tap_6702 * mul_6684);

  277. 			double add_6918 = (((mul_6700 + mul_6699) + mul_6691) + mul_6685);

  278. 			double mix_6917 = (m_y_2 + (clamp_6648 * (add_6918 - m_y_2)));

  279. 			double mix_6645 = mix_6917;

  280. 			double mix_6919 = (in1 + (mul_6641 * (mix_6645 - in1)));

  281. 			double mix_6717 = mix_6919;

  282. 			double mul_6720 = (mix_6717 * 0.707);

  283. 			double mix_6920 = (mul_6720 + (0.5 * (m_history_1 - mul_6720)));

  284. 			double mix_6856 = mix_6920;

  285. 			double add_6750 = (mix_6852 + mix_6770);

  286. 			double add_6748 = (mix_6764 + mix_6758);

  287. 			double sub_6747 = (add_6750 - add_6748);

  288. 			double mul_6729 = (sub_6747 * 0.5);

  289. 			double add_6743 = (add_6750 + add_6748);

  290. 			double mul_6726 = (add_6743 * 0.5);

  291. 			double tap_6826 = m_delay_16.read_linear(mul_6827);

  292. 			double tap_6805 = m_delay_15.read_linear(mul_6806);

  293. 			double sub_6749 = (mix_6852 - mix_6770);

  294. 			double sub_6746 = (mix_6764 - mix_6758);

  295. 			double sub_6745 = (sub_6749 - sub_6746);

  296. 			double mul_6728 = (sub_6745 * 0.5);

  297. 			double add_6744 = (sub_6749 + sub_6746);

  298. 			double rsub_6742 = (0 - add_6744);

  299. 			double mul_6727 = (rsub_6742 * 0.5);

  300. 			double tap_6774 = m_delay_14.read_linear(add_6789);

  301. 			double tap_6775 = m_delay_14.read_linear(add_6788);

  302. 			double tap_6776 = m_delay_14.read_linear(add_6787);

  303. 			double tap_6777 = m_delay_14.read_linear(add_6786);

  304. 			double mul_6784 = (tap_6774 * expr_6785);

  305. 			double add_6754 = (mul_6729 + mul_6784);

  306. 			double mul_6778 = (tap_6777 * expr_6779);

  307. 			double add_6751 = (mul_6726 + mul_6778);

  308. 			double mul_6782 = (tap_6775 * expr_6783);

  309. 			double add_6753 = (mul_6728 + mul_6782);

  310. 			double mul_6780 = (tap_6776 * expr_6781);

  311. 			double add_6752 = (mul_6727 + mul_6780);

  312. 			double mul_6824 = (tap_6826 * 0.625);

  313. 			double mul_6803 = (tap_6805 * 0.625);

  314. 			double tap_6840 = m_delay_13.read_linear(mul_6841);

  315. 			double mul_6838 = (tap_6840 * 0.75);

  316. 			double sub_6837 = (mix_6856 - mul_6838);

  317. 			double mul_6836 = (sub_6837 * 0.75);

  318. 			double add_6835 = (mul_6836 + tap_6840);

  319. 			double tap_6833 = m_delay_12.read_linear(mul_6834);

  320. 			double tap_6812 = m_delay_11.read_linear(mul_6813);

  321. 			double mul_6831 = (tap_6833 * 0.75);

  322. 			double mul_6810 = (tap_6812 * 0.75);

  323. 			double mul_6741 = (mul_6729 * mul_6643);

  324. 			double mul_6739 = (mul_6727 * mul_6643);

  325. 			double add_6725 = (mul_6741 + mul_6739);

  326. 			double mul_6740 = (mul_6728 * mul_6643);

  327. 			double mul_6738 = (mul_6726 * mul_6643);

  328. 			double add_6724 = (mul_6740 + mul_6738);

  329. 			double sub_6733 = (add_6725 - add_6724);

  330. 			double mul_6737 = (mul_6784 * mul_6860);

  331. 			double mul_6735 = (mul_6780 * mul_6860);

  332. 			double add_6723 = (mul_6737 + mul_6735);

  333. 			double mul_6736 = (mul_6782 * mul_6860);

  334. 			double mul_6734 = (mul_6778 * mul_6860);

  335. 			double add_6722 = (mul_6736 + mul_6734);

  336. 			double sub_6732 = (add_6723 - add_6722);

  337. 			double add_6719 = (sub_6733 + sub_6732);

  338. 			double add_6731 = (add_6719 + mix_6717);

  339. 			double sub_6830 = (add_6731 - mul_6831);

  340. 			double mul_6829 = (sub_6830 * 0.75);

  341. 			double add_6828 = (mul_6829 + tap_6833);

  342. 			double sub_6823 = (add_6828 - mul_6824);

  343. 			double mul_6822 = (sub_6823 * 0.625);

  344. 			double add_6821 = (mul_6822 + tap_6826);

  345. 			double sub_6816 = (add_6821 - mul_6817);

  346. 			double mul_6815 = (sub_6816 * 0.625);

  347. 			double add_6814 = (mul_6815 + tap_6819);

  348. 			double mul_6730 = (add_6814 * mul_6639);

  349. 			double out1 = (in1 + mul_6730);

  350. 			double add_6721 = (add_6719 + mix_6717);

  351. 			double sub_6809 = (add_6721 - mul_6810);

  352. 			double mul_6808 = (sub_6809 * 0.75);

  353. 			double add_6807 = (mul_6808 + tap_6812);

  354. 			double sub_6802 = (add_6807 - mul_6803);

  355. 			double mul_6801 = (sub_6802 * 0.625);

  356. 			double add_6800 = (mul_6801 + tap_6805);

  357. 			double sub_6795 = (add_6800 - mul_6796);

  358. 			double mul_6794 = (sub_6795 * 0.625);

  359. 			double add_6793 = (mul_6794 + tap_6798);

  360. 			double mul_6718 = (add_6793 * mul_6639);

  361. 			double out2 = (in1 + mul_6718);

  362. 			double history_6851_next_6863 = mix_6852;

  363. 			double history_6757_next_6864 = mix_6758;

  364. 			double history_6763_next_6865 = mix_6764;

  365. 			double history_6769_next_6866 = mix_6770;

  366. 			double history_6656_next_6867 = sah_6655;

  367. 			double history_6654_next_6868 = sah_6653;

  368. 			double history_6658_next_6869 = sah_6657;

  369. 			double history_6661_next_6870 = sah_6659;

  370. 			double y0_next_6871 = mix_6645;

  371. 			double history_6855_next_6872 = mix_6856;

  372. 			m_delay_23.write(add_6754);

  373. 			m_delay_22.write(add_6751);

  374. 			m_delay_21.write(add_6752);

  375. 			m_delay_20.write(add_6753);

  376. 			m_delay_19.write(sub_6816);

  377. 			m_delay_18.write(sub_6795);

  378. 			m_delay_17.write(in1);

  379. 			m_delay_16.write(sub_6823);

  380. 			m_delay_15.write(sub_6802);

  381. 			m_delay_14.write(add_6835);

  382. 			m_delay_13.write(sub_6837);

  383. 			m_delay_12.write(sub_6830);

  384. 			m_delay_11.write(sub_6809);

  385. 			m_history_10 = history_6851_next_6863;

  386. 			m_history_9 = history_6757_next_6864;

  387. 			m_history_8 = history_6763_next_6865;

  388. 			m_history_7 = history_6769_next_6866;

  389. 			m_history_6 = history_6656_next_6867;

  390. 			m_history_5 = history_6654_next_6868;

  391. 			m_history_4 = history_6658_next_6869;

  392. 			m_history_3 = history_6661_next_6870;

  393. 			m_y_2 = y0_next_6871;

  394. 			m_history_1 = history_6855_next_6872;

  395. 			m_delay_11.step();

  396. 			m_delay_12.step();

  397. 			m_delay_13.step();

  398. 			m_delay_14.step();

  399. 			m_delay_15.step();

  400. 			m_delay_16.step();

  401. 			m_delay_17.step();

  402. 			m_delay_18.step();

  403. 			m_delay_19.step();

  404. 			m_delay_20.step();

  405. 			m_delay_21.step();

  406. 			m_delay_22.step();

  407. 			m_delay_23.step();

  408. 			// assign results to output buffer;

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

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

  411. 			

  412. 		};

  413. 		return __exception;

  414. 		

  415. 	};

  416. 	inline void set_roomsize(double _value) {

  417. 		m_roomsize_24 = (_value < 0.1 ? 0.1 : (_value > 300 ? 300 : _value));

  418. 	};

  419. 	inline void set_ratio(double _value) {

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

  421. 	};

  422. 	inline void set_damping(double _value) {

  423. 		m_damping_26 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  424. 	};

  425. 	inline void set_decay(double _value) {

  426. 		m_decay_27 = (_value < 0.1 ? 0.1 : (_value > 100 ? 100 : _value));

  427. 	};

  428. 	inline void set_tone(double _value) {

  429. 		m_tone_28 = (_value < 500 ? 500 : (_value > 6000 ? 6000 : _value));

  430. 	};

  431. 	inline void set_mix(double _value) {

  432. 		m_mix_29 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  433. 	};

  434. 	inline void set_shimmer(double _value) {

  435. 		m_shimmer_30 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  436. 	};

  437. 	

  438. } State;

  439. 

  440. 

  441. /// 

  442. ///	Configuration for the genlib API

  443. ///

  444. 

  445. /// Number of signal inputs and outputs 

  446. 

  447. int gen_kernel_numins = 1;

  448. int gen_kernel_numouts = 2;

  449. 

  450. int num_inputs() { return gen_kernel_numins; }

  451. int num_outputs() { return gen_kernel_numouts; }

  452. int num_params() { return 7; }

  453. 

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

  455. 

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

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

  458. 

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

  460. 

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

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

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

  464. }

  465. 

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

  467. 

  468. void reset(CommonState *cself) { 

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

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

  471. }

  472. 

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

  474. 

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

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

  477. 	switch (index) {

  478. 		case 0: self->set_roomsize(value); break;

  479. 		case 1: self->set_ratio(value); break;

  480. 		case 2: self->set_damping(value); break;

  481. 		case 3: self->set_decay(value); break;

  482. 		case 4: self->set_tone(value); break;

  483. 		case 5: self->set_mix(value); break;

  484. 		case 6: self->set_shimmer(value); break;

  485. 		

  486. 		default: break;

  487. 	}

  488. }

  489. 

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

  491. 

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

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

  494. 	switch (index) {

  495. 		case 0: *value = self->m_roomsize_24; break;

  496. 		case 1: *value = self->m_ratio_25; break;

  497. 		case 2: *value = self->m_damping_26; break;

  498. 		case 3: *value = self->m_decay_27; break;

  499. 		case 4: *value = self->m_tone_28; break;

  500. 		case 5: *value = self->m_mix_29; break;

  501. 		case 6: *value = self->m_shimmer_30; break;

  502. 		

  503. 		default: break;

  504. 	}

  505. }

  506. 

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

  508. 

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

  510. 	State *self = new State;

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

  512. 	ParamInfo *pi;

  513. 	self->__commonstate.inputnames = gen_kernel_innames;

  514. 	self->__commonstate.outputnames = gen_kernel_outnames;

  515. 	self->__commonstate.numins = gen_kernel_numins;

  516. 	self->__commonstate.numouts = gen_kernel_numouts;

  517. 	self->__commonstate.sr = sr;

  518. 	self->__commonstate.vs = vs;

  519. 	self->__commonstate.params = (ParamInfo *)genlib_sysmem_newptr(7 * sizeof(ParamInfo));

  520. 	self->__commonstate.numparams = 7;

  521. 	// initialize parameter 0 ("m_roomsize_24")

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

  523. 	pi->name = "roomsize";

  524. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  525. 	pi->defaultvalue = self->m_roomsize_24;

  526. 	pi->defaultref = 0;

  527. 	pi->hasinputminmax = false;

  528. 	pi->inputmin = 0; 

  529. 	pi->inputmax = 1;

  530. 	pi->hasminmax = true;

  531. 	pi->outputmin = 0.1;

  532. 	pi->outputmax = 300;

  533. 	pi->exp = 0;

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

  535. 	// initialize parameter 1 ("m_ratio_25")

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

  537. 	pi->name = "ratio";

  538. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  540. 	pi->defaultref = 0;

  541. 	pi->hasinputminmax = false;

  542. 	pi->inputmin = 0; 

  543. 	pi->inputmax = 1;

  544. 	pi->hasminmax = true;

  545. 	pi->outputmin = 0.5;

  546. 	pi->outputmax = 2;

  547. 	pi->exp = 0;

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

  549. 	// initialize parameter 2 ("m_damping_26")

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

  551. 	pi->name = "damping";

  552. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  553. 	pi->defaultvalue = self->m_damping_26;

  554. 	pi->defaultref = 0;

  555. 	pi->hasinputminmax = false;

  556. 	pi->inputmin = 0; 

  557. 	pi->inputmax = 1;

  558. 	pi->hasminmax = true;

  559. 	pi->outputmin = 0;

  560. 	pi->outputmax = 100;

  561. 	pi->exp = 0;

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

  563. 	// initialize parameter 3 ("m_decay_27")

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

  565. 	pi->name = "decay";

  566. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  567. 	pi->defaultvalue = self->m_decay_27;

  568. 	pi->defaultref = 0;

  569. 	pi->hasinputminmax = false;

  570. 	pi->inputmin = 0; 

  571. 	pi->inputmax = 1;

  572. 	pi->hasminmax = true;

  573. 	pi->outputmin = 0.1;

  574. 	pi->outputmax = 100;

  575. 	pi->exp = 0;

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

  577. 	// initialize parameter 4 ("m_tone_28")

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

  579. 	pi->name = "tone";

  580. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  582. 	pi->defaultref = 0;

  583. 	pi->hasinputminmax = false;

  584. 	pi->inputmin = 0; 

  585. 	pi->inputmax = 1;

  586. 	pi->hasminmax = true;

  587. 	pi->outputmin = 500;

  588. 	pi->outputmax = 6000;

  589. 	pi->exp = 0;

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

  591. 	// initialize parameter 5 ("m_mix_29")

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

  593. 	pi->name = "mix";

  594. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  596. 	pi->defaultref = 0;

  597. 	pi->hasinputminmax = false;

  598. 	pi->inputmin = 0; 

  599. 	pi->inputmax = 1;

  600. 	pi->hasminmax = true;

  601. 	pi->outputmin = 0;

  602. 	pi->outputmax = 100;

  603. 	pi->exp = 0;

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

  605. 	// initialize parameter 6 ("m_shimmer_30")

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

  607. 	pi->name = "shimmer";

  608. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  609. 	pi->defaultvalue = self->m_shimmer_30;

  610. 	pi->defaultref = 0;

  611. 	pi->hasinputminmax = false;

  612. 	pi->inputmin = 0; 

  613. 	pi->inputmax = 1;

  614. 	pi->hasminmax = true;

  615. 	pi->outputmin = 0;

  616. 	pi->outputmax = 100;

  617. 	pi->exp = 0;

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

  619. 	

  620. 	return self;

  621. }

  622. 

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

  624. 

  625. void destroy(CommonState *cself) { 

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

  627. 	genlib_sysmem_freeptr(cself->params);

  628. 		

  629. 	delete self; 

  630. }

  631. 

  632. 

  633. } // gen_exported::