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

629 lines
22KB
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_shimmer_25;

  73. 	double m_damping_24;

  74. 	double m_ratio_27;

  75. 	double m_roomsize_26;

  76. 	double m_tone_29;

  77. 	double m_mix_30;

  78. 	double m_decay_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", 96000);

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

  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_damping_24 = 75;

  110. 		m_shimmer_25 = 50;

  111. 		m_roomsize_26 = 100;

  112. 		m_ratio_27 = 2;

  113. 		m_decay_28 = 50;

  114. 		m_tone_29 = 3000;

  115. 		m_mix_30 = 75;

  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_46984 = (m_mix_30 * 0.01);

  148. 		double mul_46983 = (m_damping_24 * 0.01);

  149. 		double mul_46982 = (m_shimmer_25 * 0.01);

  150. 		double expr_46980 = safediv(((m_tone_29 * 2) * 3.1415926535898), 48000);

  151. 		double sin_46767 = sin(expr_46980);

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

  153. 		double expr_46979 = safediv((m_roomsize_26 * 48000), 340);

  154. 		double mul_46949 = (expr_46979 * 0.81649);

  155. 		double mul_46950 = (expr_46979 * 1);

  156. 		double mul_46948 = (expr_46979 * 0.7071);

  157. 		double mul_46947 = (expr_46979 * 0.63245);

  158. 		double mul_46959 = (m_decay_28 * 3.6);

  159. 		double expr_46978 = safepow(0.001, safediv(1, (mul_46959 * 48000)));

  160. 		double expr_46875 = (-safepow(expr_46978, mul_46949));

  161. 		double expr_46945 = (-safepow(expr_46978, mul_46950));

  162. 		double expr_46870 = (-safepow(expr_46978, mul_46948));

  163. 		double expr_46865 = (-safepow(expr_46978, mul_46947));

  164. 		double mul_46944 = (expr_46979 * 0.000527);

  165. 		int int_46943 = int(mul_46944);

  166. 		double mul_46968 = (int_46943 * 400.600006);

  167. 		double mul_46971 = (int_46943 * 419.5);

  168. 		double mul_46967 = (int_46943 * 568.299988);

  169. 		double add_46893 = (expr_46979 + 5);

  170. 		double expr_46886 = safepow(expr_46978, add_46893);

  171. 		double rsub_46809 = (1 - m_ratio_27);

  172. 		double mul_46981 = (rsub_46809 * 10);

  173. 		samples_to_seconds = (1 / samplerate);

  174. 		double mul_46970 = (int_46943 * 566.700012);

  175. 		double mul_46899 = (expr_46979 * 0.41);

  176. 		double add_46896 = (mul_46899 + 5);

  177. 		double expr_46892 = safepow(expr_46978, add_46896);

  178. 		double mul_46898 = (expr_46979 * 0.3);

  179. 		double add_46895 = (mul_46898 + 5);

  180. 		double expr_46890 = safepow(expr_46978, add_46895);

  181. 		double mul_46897 = (expr_46979 * 0.155);

  182. 		double add_46894 = (mul_46897 + 5);

  183. 		double expr_46888 = safepow(expr_46978, add_46894);

  184. 		double mul_46942 = (expr_46979 * 0.110732);

  185. 		double mul_46966 = (int_46943 * 162.100006);

  186. 		double mul_46969 = (int_46943 * 144.800003);

  187. 		double mul_46960 = (m_decay_28 * 0.01);

  188. 		// the main sample loop;

  189. 		while ((__n--)) { 

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

  191. 			double noise_46770 = noise();

  192. 			double abs_46787 = fabs(noise_46770);

  193. 			double mul_46957 = (abs_46787 * 0.25);

  194. 			double noise_46772 = noise();

  195. 			double abs_46789 = fabs(noise_46772);

  196. 			double mul_46955 = (abs_46789 * 0.25);

  197. 			double noise_46771 = noise();

  198. 			double abs_46788 = fabs(noise_46771);

  199. 			double mul_46956 = (abs_46788 * 0.25);

  200. 			double noise_46769 = noise();

  201. 			double abs_46786 = fabs(noise_46769);

  202. 			double mul_46958 = (abs_46786 * 0.25);

  203. 			double tap_46879 = m_delay_23.read_linear(mul_46949);

  204. 			double tap_46953 = m_delay_22.read_linear(mul_46950);

  205. 			double tap_46874 = m_delay_21.read_linear(mul_46948);

  206. 			double tap_46869 = m_delay_20.read_linear(mul_46947);

  207. 			double mul_46876 = (tap_46879 * expr_46875);

  208. 			double mix_47035 = (mul_46876 + (mul_46983 * (m_history_10 - mul_46876)));

  209. 			double mix_46976 = mix_47035;

  210. 			double mul_46946 = (tap_46953 * expr_46945);

  211. 			double mix_47036 = (mul_46946 + (mul_46983 * (m_history_9 - mul_46946)));

  212. 			double mix_46977 = mix_47036;

  213. 			double mul_46871 = (tap_46874 * expr_46870);

  214. 			double mix_47037 = (mul_46871 + (mul_46983 * (m_history_8 - mul_46871)));

  215. 			double mix_46975 = mix_47037;

  216. 			double mul_46866 = (tap_46869 * expr_46865);

  217. 			double mix_47038 = (mul_46866 + (mul_46983 * (m_history_7 - mul_46866)));

  218. 			double mix_46974 = mix_47038;

  219. 			double tap_46923 = m_delay_19.read_linear(mul_46968);

  220. 			double mul_46921 = (tap_46923 * 0.625);

  221. 			double tap_46905 = m_delay_18.read_linear(mul_46971);

  222. 			double mul_46903 = (tap_46905 * 0.625);

  223. 			double tap_46929 = m_delay_17.read_linear(mul_46967);

  224. 			double sub_46859 = (mix_46977 - mix_46976);

  225. 			double sub_46856 = (mix_46975 - mix_46974);

  226. 			double sub_46855 = (sub_46859 - sub_46856);

  227. 			double mul_46838 = (sub_46855 * 0.5);

  228. 			double phasor_46827 = m_phasor_31(mul_46981, samples_to_seconds);

  229. 			double add_46808 = ((m_history_6 + phasor_46827) + 0.5);

  230. 			double mod_46807 = safemod(add_46808, 1);

  231. 			double delta_46791 = m_delta_32(mod_46807);

  232. 			double sah_46775 = m_sah_33(mul_46957, delta_46791, 0);

  233. 			int sah_46963 = m_sah_34(4800, delta_46791, 0);

  234. 			double mul_46783 = (sah_46963 * mod_46807);

  235. 			double sub_46806 = (mod_46807 - 0.5);

  236. 			double mul_46805 = (sub_46806 * 3.1415926535898);

  237. 			double cos_46804 = cos(mul_46805);

  238. 			double mul_46794 = (cos_46804 * cos_46804);

  239. 			double add_46826 = ((m_history_5 + phasor_46827) + 0);

  240. 			double mod_46825 = safemod(add_46826, 1);

  241. 			double delta_46780 = m_delta_35(mod_46825);

  242. 			double sah_46779 = m_sah_36(mul_46955, delta_46780, 0);

  243. 			int sah_46961 = m_sah_37(4800, delta_46780, 0);

  244. 			double mul_46785 = (sah_46961 * mod_46825);

  245. 			double sub_46824 = (mod_46825 - 0.5);

  246. 			double mul_46823 = (sub_46824 * 3.1415926535898);

  247. 			double cos_46822 = cos(mul_46823);

  248. 			double mul_46796 = (cos_46822 * cos_46822);

  249. 			double add_46821 = ((m_history_4 + phasor_46827) + 0.25);

  250. 			double mod_46820 = safemod(add_46821, 1);

  251. 			double delta_46792 = m_delta_38(mod_46820);

  252. 			double sah_46777 = m_sah_39(mul_46956, delta_46792, 0);

  253. 			int sah_46962 = m_sah_40(4800, delta_46792, 0);

  254. 			double mul_46784 = (sah_46962 * mod_46820);

  255. 			double sub_46819 = (mod_46820 - 0.5);

  256. 			double mul_46818 = (sub_46819 * 3.1415926535898);

  257. 			double cos_46817 = cos(mul_46818);

  258. 			double mul_46795 = (cos_46817 * cos_46817);

  259. 			double add_46802 = ((m_history_3 + phasor_46827) + 0.75);

  260. 			double mod_46801 = safemod(add_46802, 1);

  261. 			double delta_46790 = m_delta_41(mod_46801);

  262. 			double sah_46773 = m_sah_42(mul_46958, delta_46790, 0);

  263. 			int sah_46964 = m_sah_43(4800, delta_46790, 0);

  264. 			double mul_46782 = (sah_46964 * mod_46801);

  265. 			double tap_46813 = m_delay_16.read_linear(mul_46785);

  266. 			double tap_46814 = m_delay_16.read_linear(mul_46784);

  267. 			double tap_46815 = m_delay_16.read_linear(mul_46783);

  268. 			double tap_46816 = m_delay_16.read_linear(mul_46782);

  269. 			double mul_46803 = (tap_46815 * mul_46794);

  270. 			double mul_46810 = (tap_46814 * mul_46795);

  271. 			double mul_46811 = (tap_46813 * mul_46796);

  272. 			double sub_46800 = (mod_46801 - 0.5);

  273. 			double mul_46799 = (sub_46800 * 3.1415926535898);

  274. 			double cos_46798 = cos(mul_46799);

  275. 			double mul_46793 = (cos_46798 * cos_46798);

  276. 			double mul_46797 = (tap_46816 * mul_46793);

  277. 			double add_47040 = (((mul_46811 + mul_46810) + mul_46803) + mul_46797);

  278. 			double mix_47039 = (m_y_2 + (clamp_46768 * (add_47040 - m_y_2)));

  279. 			double mix_46766 = mix_47039;

  280. 			double mix_47041 = (in1 + (mul_46982 * (mix_46766 - in1)));

  281. 			double mix_46973 = mix_47041;

  282. 			double mul_46830 = (mix_46973 * 0.707);

  283. 			double mix_47042 = (mul_46830 + (0.5 * (m_history_1 - mul_46830)));

  284. 			double mix_46965 = mix_47042;

  285. 			double tap_46911 = m_delay_15.read_linear(mul_46970);

  286. 			double add_46860 = (mix_46977 + mix_46976);

  287. 			double add_46858 = (mix_46975 + mix_46974);

  288. 			double sub_46857 = (add_46860 - add_46858);

  289. 			double mul_46839 = (sub_46857 * 0.5);

  290. 			double add_46853 = (add_46860 + add_46858);

  291. 			double mul_46836 = (add_46853 * 0.5);

  292. 			double add_46854 = (sub_46859 + sub_46856);

  293. 			double rsub_46852 = (0 - add_46854);

  294. 			double mul_46837 = (rsub_46852 * 0.5);

  295. 			double mul_46927 = (tap_46929 * 0.625);

  296. 			double tap_46881 = m_delay_14.read_linear(add_46896);

  297. 			double tap_46882 = m_delay_14.read_linear(add_46895);

  298. 			double tap_46883 = m_delay_14.read_linear(add_46894);

  299. 			double tap_46884 = m_delay_14.read_linear(add_46893);

  300. 			double mul_46889 = (tap_46882 * expr_46890);

  301. 			double add_46863 = (mul_46838 + mul_46889);

  302. 			double mul_46891 = (tap_46881 * expr_46892);

  303. 			double add_46864 = (mul_46839 + mul_46891);

  304. 			double mul_46885 = (tap_46884 * expr_46886);

  305. 			double add_46861 = (mul_46836 + mul_46885);

  306. 			double mul_46887 = (tap_46883 * expr_46888);

  307. 			double add_46862 = (mul_46837 + mul_46887);

  308. 			double mul_46909 = (tap_46911 * 0.625);

  309. 			double tap_46941 = m_delay_13.read_linear(mul_46942);

  310. 			double tap_46935 = m_delay_12.read_linear(mul_46966);

  311. 			double mul_46939 = (tap_46941 * 0.75);

  312. 			double sub_46938 = (mix_46965 - mul_46939);

  313. 			double mul_46937 = (sub_46938 * 0.75);

  314. 			double add_46936 = (mul_46937 + tap_46941);

  315. 			double tap_46917 = m_delay_11.read_linear(mul_46969);

  316. 			double mul_46933 = (tap_46935 * 0.75);

  317. 			double mul_46915 = (tap_46917 * 0.75);

  318. 			double mul_46851 = (mul_46839 * mul_46960);

  319. 			double mul_46849 = (mul_46837 * mul_46960);

  320. 			double add_46835 = (mul_46851 + mul_46849);

  321. 			double mul_46850 = (mul_46838 * mul_46960);

  322. 			double mul_46848 = (mul_46836 * mul_46960);

  323. 			double add_46834 = (mul_46850 + mul_46848);

  324. 			double sub_46843 = (add_46835 - add_46834);

  325. 			double mul_46847 = (mul_46891 * mul_46960);

  326. 			double mul_46845 = (mul_46887 * mul_46960);

  327. 			double add_46833 = (mul_46847 + mul_46845);

  328. 			double mul_46846 = (mul_46889 * mul_46960);

  329. 			double mul_46844 = (mul_46885 * mul_46960);

  330. 			double add_46832 = (mul_46846 + mul_46844);

  331. 			double sub_46842 = (add_46833 - add_46832);

  332. 			double add_46829 = (sub_46843 + sub_46842);

  333. 			double add_46841 = (add_46829 + mix_46973);

  334. 			double sub_46932 = (add_46841 - mul_46933);

  335. 			double mul_46931 = (sub_46932 * 0.75);

  336. 			double add_46930 = (mul_46931 + tap_46935);

  337. 			double sub_46926 = (add_46930 - mul_46927);

  338. 			double mul_46925 = (sub_46926 * 0.625);

  339. 			double add_46924 = (mul_46925 + tap_46929);

  340. 			double sub_46920 = (add_46924 - mul_46921);

  341. 			double mul_46919 = (sub_46920 * 0.625);

  342. 			double add_46918 = (mul_46919 + tap_46923);

  343. 			double mul_46840 = (add_46918 * mul_46984);

  344. 			double out1 = (in1 + mul_46840);

  345. 			double add_46831 = (add_46829 + mix_46973);

  346. 			double sub_46914 = (add_46831 - mul_46915);

  347. 			double mul_46913 = (sub_46914 * 0.75);

  348. 			double add_46912 = (mul_46913 + tap_46917);

  349. 			double sub_46908 = (add_46912 - mul_46909);

  350. 			double mul_46907 = (sub_46908 * 0.625);

  351. 			double add_46906 = (mul_46907 + tap_46911);

  352. 			double sub_46902 = (add_46906 - mul_46903);

  353. 			double mul_46901 = (sub_46902 * 0.625);

  354. 			double add_46900 = (mul_46901 + tap_46905);

  355. 			double mul_46828 = (add_46900 * mul_46984);

  356. 			double out2 = (in1 + mul_46828);

  357. 			double history_46877_next_46985 = mix_46976;

  358. 			double history_46951_next_46986 = mix_46977;

  359. 			double history_46872_next_46987 = mix_46975;

  360. 			double history_46867_next_46988 = mix_46974;

  361. 			double history_46776_next_46989 = sah_46775;

  362. 			double history_46781_next_46990 = sah_46779;

  363. 			double history_46778_next_46991 = sah_46777;

  364. 			double history_46774_next_46992 = sah_46773;

  365. 			double y0_next_46993 = mix_46766;

  366. 			double history_46954_next_46994 = mix_46965;

  367. 			m_delay_23.write(add_46863);

  368. 			m_delay_22.write(add_46864);

  369. 			m_delay_21.write(add_46862);

  370. 			m_delay_20.write(add_46861);

  371. 			m_delay_19.write(sub_46920);

  372. 			m_delay_18.write(sub_46902);

  373. 			m_delay_17.write(sub_46926);

  374. 			m_delay_16.write(in1);

  375. 			m_delay_15.write(sub_46908);

  376. 			m_delay_14.write(add_46936);

  377. 			m_delay_13.write(sub_46938);

  378. 			m_delay_12.write(sub_46932);

  379. 			m_delay_11.write(sub_46914);

  380. 			m_history_10 = history_46877_next_46985;

  381. 			m_history_9 = history_46951_next_46986;

  382. 			m_history_8 = history_46872_next_46987;

  383. 			m_history_7 = history_46867_next_46988;

  384. 			m_history_6 = history_46776_next_46989;

  385. 			m_history_5 = history_46781_next_46990;

  386. 			m_history_4 = history_46778_next_46991;

  387. 			m_history_3 = history_46774_next_46992;

  388. 			m_y_2 = y0_next_46993;

  389. 			m_history_1 = history_46954_next_46994;

  390. 			m_delay_11.step();

  391. 			m_delay_12.step();

  392. 			m_delay_13.step();

  393. 			m_delay_14.step();

  394. 			m_delay_15.step();

  395. 			m_delay_16.step();

  396. 			m_delay_17.step();

  397. 			m_delay_18.step();

  398. 			m_delay_19.step();

  399. 			m_delay_20.step();

  400. 			m_delay_21.step();

  401. 			m_delay_22.step();

  402. 			m_delay_23.step();

  403. 			// assign results to output buffer;

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

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

  406. 			

  407. 		};

  408. 		return __exception;

  409. 		

  410. 	};

  411. 	inline void set_damping(double _value) {

  412. 		m_damping_24 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  413. 	};

  414. 	inline void set_shimmer(double _value) {

  415. 		m_shimmer_25 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  416. 	};

  417. 	inline void set_roomsize(double _value) {

  418. 		m_roomsize_26 = (_value < 0.1 ? 0.1 : (_value > 300 ? 300 : _value));

  419. 	};

  420. 	inline void set_ratio(double _value) {

  421. 		m_ratio_27 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  422. 	};

  423. 	inline void set_decay(double _value) {

  424. 		m_decay_28 = (_value < 0.1 ? 0.1 : (_value > 100 ? 100 : _value));

  425. 	};

  426. 	inline void set_tone(double _value) {

  427. 		m_tone_29 = (_value < 500 ? 500 : (_value > 6000 ? 6000 : _value));

  428. 	};

  429. 	inline void set_mix(double _value) {

  430. 		m_mix_30 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  431. 	};

  432. 	

  433. } State;

  434. 

  435. 

  436. /// 

  437. ///	Configuration for the genlib API

  438. ///

  439. 

  440. /// Number of signal inputs and outputs 

  441. 

  442. int gen_kernel_numins = 1;

  443. int gen_kernel_numouts = 2;

  444. 

  445. int num_inputs() { return gen_kernel_numins; }

  446. int num_outputs() { return gen_kernel_numouts; }

  447. int num_params() { return 7; }

  448. 

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

  450. 

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

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

  453. 

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

  455. 

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

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

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

  459. }

  460. 

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

  462. 

  463. void reset(CommonState *cself) { 

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

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

  466. }

  467. 

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

  469. 

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

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

  472. 	switch (index) {

  473. 		case 0: self->set_damping(value); break;

  474. 		case 1: self->set_shimmer(value); break;

  475. 		case 2: self->set_roomsize(value); break;

  476. 		case 3: self->set_ratio(value); break;

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

  478. 		case 5: self->set_tone(value); break;

  479. 		case 6: self->set_mix(value); break;

  480. 		

  481. 		default: break;

  482. 	}

  483. }

  484. 

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

  486. 

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

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

  489. 	switch (index) {

  490. 		case 0: *value = self->m_damping_24; break;

  491. 		case 1: *value = self->m_shimmer_25; break;

  492. 		case 2: *value = self->m_roomsize_26; break;

  493. 		case 3: *value = self->m_ratio_27; break;

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

  495. 		case 5: *value = self->m_tone_29; break;

  496. 		case 6: *value = self->m_mix_30; break;

  497. 		

  498. 		default: break;

  499. 	}

  500. }

  501. 

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

  503. 

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

  505. 	State *self = new State;

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

  507. 	ParamInfo *pi;

  508. 	self->__commonstate.inputnames = gen_kernel_innames;

  509. 	self->__commonstate.outputnames = gen_kernel_outnames;

  510. 	self->__commonstate.numins = gen_kernel_numins;

  511. 	self->__commonstate.numouts = gen_kernel_numouts;

  512. 	self->__commonstate.sr = sr;

  513. 	self->__commonstate.vs = vs;

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

  515. 	self->__commonstate.numparams = 7;

  516. 	// initialize parameter 0 ("m_damping_24")

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

  518. 	pi->name = "damping";

  519. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  520. 	pi->defaultvalue = self->m_damping_24;

  521. 	pi->defaultref = 0;

  522. 	pi->hasinputminmax = false;

  523. 	pi->inputmin = 0; 

  524. 	pi->inputmax = 1;

  525. 	pi->hasminmax = true;

  526. 	pi->outputmin = 0;

  527. 	pi->outputmax = 100;

  528. 	pi->exp = 0;

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

  530. 	// initialize parameter 1 ("m_shimmer_25")

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

  532. 	pi->name = "shimmer";

  533. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  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 2 ("m_roomsize_26")

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

  546. 	pi->name = "roomsize";

  547. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  549. 	pi->defaultref = 0;

  550. 	pi->hasinputminmax = false;

  551. 	pi->inputmin = 0; 

  552. 	pi->inputmax = 1;

  553. 	pi->hasminmax = true;

  554. 	pi->outputmin = 0.1;

  555. 	pi->outputmax = 300;

  556. 	pi->exp = 0;

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

  558. 	// initialize parameter 3 ("m_ratio_27")

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

  560. 	pi->name = "ratio";

  561. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  563. 	pi->defaultref = 0;

  564. 	pi->hasinputminmax = false;

  565. 	pi->inputmin = 0; 

  566. 	pi->inputmax = 1;

  567. 	pi->hasminmax = true;

  568. 	pi->outputmin = 0.5;

  569. 	pi->outputmax = 2;

  570. 	pi->exp = 0;

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

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

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

  574. 	pi->name = "decay";

  575. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  577. 	pi->defaultref = 0;

  578. 	pi->hasinputminmax = false;

  579. 	pi->inputmin = 0; 

  580. 	pi->inputmax = 1;

  581. 	pi->hasminmax = true;

  582. 	pi->outputmin = 0.1;

  583. 	pi->outputmax = 100;

  584. 	pi->exp = 0;

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

  586. 	// initialize parameter 5 ("m_tone_29")

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

  588. 	pi->name = "tone";

  589. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  591. 	pi->defaultref = 0;

  592. 	pi->hasinputminmax = false;

  593. 	pi->inputmin = 0; 

  594. 	pi->inputmax = 1;

  595. 	pi->hasminmax = true;

  596. 	pi->outputmin = 500;

  597. 	pi->outputmax = 6000;

  598. 	pi->exp = 0;

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

  600. 	// initialize parameter 6 ("m_mix_30")

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

  602. 	pi->name = "mix";

  603. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  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. 	

  615. 	return self;

  616. }

  617. 

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

  619. 

  620. void destroy(CommonState *cself) { 

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

  622. 	genlib_sysmem_freeptr(cself->params);

  623. 		

  624. 	delete self; 

  625. }

  626. 

  627. 

  628. } // gen_exported::