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

772 lines
25KB
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_24;

  35. 	Delay m_delay_14;

  36. 	Delay m_delay_15;

  37. 	Delay m_delay_13;

  38. 	Delay m_delay_12;

  39. 	Delay m_delay_23;

  40. 	Delay m_delay_16;

  41. 	Delay m_delay_18;

  42. 	Delay m_delay_17;

  43. 	Delay m_delay_20;

  44. 	Delay m_delay_19;

  45. 	Delay m_delay_21;

  46. 	Delay m_delay_22;

  47. 	Delta m_delta_39;

  48. 	Delta m_delta_48;

  49. 	Delta m_delta_42;

  50. 	Delta m_delta_45;

  51. 	Phasor m_phasor_38;

  52. 	Sah m_sah_47;

  53. 	Sah m_sah_46;

  54. 	Sah m_sah_44;

  55. 	Sah m_sah_41;

  56. 	Sah m_sah_43;

  57. 	Sah m_sah_40;

  58. 	Sah m_sah_49;

  59. 	Sah m_sah_50;

  60. 	double m_history_10;

  61. 	double m_history_7;

  62. 	double m_history_6;

  63. 	double m_history_8;

  64. 	double m_history_9;

  65. 	double samples_to_seconds;

  66. 	double m_history_5;

  67. 	double m_history_3;

  68. 	double samplerate;

  69. 	double m_history_4;

  70. 	double m_history_1;

  71. 	double m_y_2;

  72. 	double m_y_11;

  73. 	double m_window_37;

  74. 	double m_early_35;

  75. 	double m_damping_27;

  76. 	double m_spread_28;

  77. 	double m_ratio_26;

  78. 	double m_shift_25;

  79. 	double m_mix_36;

  80. 	double m_blur_29;

  81. 	double m_decay_31;

  82. 	double m_roomsize_30;

  83. 	double m_cutoff_33;

  84. 	double m_tail_34;

  85. 	double m_tone_32;

  86. 	int vectorsize;

  87. 	int __exception;

  88. 	// re-initialize all member variables;

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

  90. 		__exception = 0;

  91. 		vectorsize = __vs;

  92. 		samplerate = __sr;

  93. 		m_history_1 = 0;

  94. 		m_y_2 = 0;

  95. 		m_history_3 = 0;

  96. 		m_history_4 = 0;

  97. 		m_history_5 = 0;

  98. 		m_history_6 = 0;

  99. 		m_history_7 = 0;

  100. 		m_history_8 = 0;

  101. 		m_history_9 = 0;

  102. 		m_history_10 = 0;

  103. 		m_y_11 = 0;

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

  105. 		m_delay_13.reset("m_delay_13", 7000);

  106. 		m_delay_14.reset("m_delay_14", 15000);

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

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

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

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

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

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

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

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

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

  116. 		m_delay_24.reset("m_delay_24", 48000);

  117. 		m_shift_25 = 0.5;

  118. 		m_ratio_26 = 2;

  119. 		m_damping_27 = 0.75;

  120. 		m_spread_28 = 25;

  121. 		m_blur_29 = 0.25;

  122. 		m_roomsize_30 = 75;

  123. 		m_decay_31 = 11;

  124. 		m_tone_32 = 0.5;

  125. 		m_cutoff_33 = 3000;

  126. 		m_tail_34 = 0.25;

  127. 		m_early_35 = 0.25;

  128. 		m_mix_36 = 0.75;

  129. 		m_window_37 = 100;

  130. 		samples_to_seconds = (1 / samplerate);

  131. 		m_phasor_38.reset(0);

  132. 		m_delta_39.reset(0);

  133. 		m_sah_40.reset(0);

  134. 		m_sah_41.reset(0);

  135. 		m_delta_42.reset(0);

  136. 		m_sah_43.reset(0);

  137. 		m_sah_44.reset(0);

  138. 		m_delta_45.reset(0);

  139. 		m_sah_46.reset(0);

  140. 		m_sah_47.reset(0);

  141. 		m_delta_48.reset(0);

  142. 		m_sah_49.reset(0);

  143. 		m_sah_50.reset(0);

  144. 		genlib_reset_complete(this);

  145. 		

  146. 	};

  147. 	// the signal processing routine;

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

  149. 		vectorsize = __n;

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

  151. 		t_sample * __out1 = __outs[0];

  152. 		t_sample * __out2 = __outs[1];

  153. 		if (__exception) { 

  154. 			return __exception;

  155. 			

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

  157. 			__exception = GENLIB_ERR_NULL_BUFFER;

  158. 			return __exception;

  159. 			

  160. 		};

  161. 		double rsub_1933 = (1 - m_tone_32);

  162. 		double expr_2527 = safepow(0.001, safediv(1, (m_decay_31 * 44100)));

  163. 		double expr_2518 = safediv(((m_cutoff_33 * 2) * 3.1415926535898), 44100);

  164. 		double cos_1776 = cos(expr_2518);

  165. 		double mul_1774 = (cos_1776 * -2);

  166. 		double add_1772 = (mul_1774 + 1);

  167. 		double expr_2528 = safediv((m_roomsize_30 * 44100), 340);

  168. 		double mul_1922 = (expr_2528 * 0.63245);

  169. 		double expr_2519 = (-safepow(expr_2527, mul_1922));

  170. 		double mul_1923 = (expr_2528 * 0.7071);

  171. 		double expr_2520 = (-safepow(expr_2527, mul_1923));

  172. 		double mul_1925 = (expr_2528 * 1);

  173. 		double expr_2526 = (-safepow(expr_2527, mul_1925));

  174. 		double mul_1924 = (expr_2528 * 0.81649);

  175. 		double expr_2521 = (-safepow(expr_2527, mul_1924));

  176. 		double mul_1919 = (expr_2528 * 0.000527);

  177. 		int int_1918 = int(mul_1919);

  178. 		double mstosamps_1760 = (m_window_37 * (samplerate * 0.001));

  179. 		double mul_1859 = (m_spread_28 * -0.380445);

  180. 		double add_1858 = (mul_1859 + 931);

  181. 		double rsub_1855 = (1341 - add_1858);

  182. 		double mul_1868 = (int_1918 * rsub_1855);

  183. 		double add_1848 = (expr_2528 + 5);

  184. 		double expr_2522 = safepow(expr_2527, add_1848);

  185. 		double mul_1887 = (m_spread_28 * 0.376623);

  186. 		double add_1886 = (mul_1887 + 931);

  187. 		double rsub_1883 = (1341 - add_1886);

  188. 		double mul_1894 = (int_1918 * rsub_1883);

  189. 		double mul_1854 = (expr_2528 * 0.41);

  190. 		double add_1851 = (mul_1854 + 5);

  191. 		double expr_2525 = safepow(expr_2527, add_1851);

  192. 		double mul_1853 = (expr_2528 * 0.3);

  193. 		double add_1850 = (mul_1853 + 5);

  194. 		double expr_2524 = safepow(expr_2527, add_1850);

  195. 		double mul_1852 = (expr_2528 * 0.155);

  196. 		double add_1849 = (mul_1852 + 5);

  197. 		double expr_2523 = safepow(expr_2527, add_1849);

  198. 		double rsub_1747 = (1 - m_ratio_26);

  199. 		double mul_1746 = (rsub_1747 * 1000);

  200. 		double div_1745 = safediv(mul_1746, m_window_37);

  201. 		samples_to_seconds = (1 / samplerate);

  202. 		double mul_1917 = (expr_2528 * 0.110732);

  203. 		double mul_1861 = (m_spread_28 * -0.568366);

  204. 		double add_1857 = (mul_1861 + 369);

  205. 		double rsub_1856 = (add_1858 - add_1857);

  206. 		double mul_1875 = (int_1918 * rsub_1856);

  207. 		double mul_1903 = (m_spread_28 * 0.125541);

  208. 		double add_1885 = (mul_1903 + 369);

  209. 		double rsub_1884 = (add_1886 - add_1885);

  210. 		double mul_1901 = (int_1918 * rsub_1884);

  211. 		double add_1860 = (mul_1861 + 159);

  212. 		double mul_1882 = (int_1918 * add_1860);

  213. 		double add_1902 = (mul_1903 + 159);

  214. 		double mul_1910 = (int_1918 * add_1902);

  215. 		// the main sample loop;

  216. 		while ((__n--)) { 

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

  218. 			double noise_1697 = noise();

  219. 			double abs_1715 = fabs(noise_1697);

  220. 			double mul_1721 = (abs_1715 * m_blur_29);

  221. 			double noise_1698 = noise();

  222. 			double abs_1716 = fabs(noise_1698);

  223. 			double mul_1724 = (abs_1716 * m_blur_29);

  224. 			double noise_1699 = noise();

  225. 			double abs_1717 = fabs(noise_1699);

  226. 			double mul_1727 = (abs_1717 * m_blur_29);

  227. 			double noise_1696 = noise();

  228. 			double abs_1714 = fabs(noise_1696);

  229. 			double mul_1718 = (abs_1714 * m_blur_29);

  230. 			double mul_1770 = (mul_1774 * m_y_2);

  231. 			double tap_1822 = m_delay_24.read_linear(mul_1922);

  232. 			double mul_1818 = (tap_1822 * expr_2519);

  233. 			double mix_2553 = (mul_1818 + (m_damping_27 * (m_history_10 - mul_1818)));

  234. 			double mix_1820 = mix_2553;

  235. 			double tap_1828 = m_delay_23.read_linear(mul_1923);

  236. 			double mul_1824 = (tap_1828 * expr_2520);

  237. 			double mix_2554 = (mul_1824 + (m_damping_27 * (m_history_9 - mul_1824)));

  238. 			double mix_1826 = mix_2554;

  239. 			double tap_1930 = m_delay_22.read_linear(mul_1925);

  240. 			double mul_1921 = (tap_1930 * expr_2526);

  241. 			double mix_2555 = (mul_1921 + (m_damping_27 * (m_history_8 - mul_1921)));

  242. 			double mix_1928 = mix_2555;

  243. 			double tap_1834 = m_delay_21.read_linear(mul_1924);

  244. 			double mul_1830 = (tap_1834 * expr_2521);

  245. 			double mix_2556 = (mul_1830 + (m_damping_27 * (m_history_7 - mul_1830)));

  246. 			double mix_1832 = mix_2556;

  247. 			double tap_1867 = m_delay_20.read_linear(mul_1868);

  248. 			double mul_1865 = (tap_1867 * 0.625);

  249. 			double add_1812 = (mix_1928 + mix_1832);

  250. 			double add_1810 = (mix_1826 + mix_1820);

  251. 			double add_1805 = (add_1812 + add_1810);

  252. 			double mul_1788 = (add_1805 * 0.5);

  253. 			double sub_1809 = (add_1812 - add_1810);

  254. 			double mul_1791 = (sub_1809 * 0.5);

  255. 			double tap_1893 = m_delay_19.read_linear(mul_1894);

  256. 			double mul_1891 = (tap_1893 * 0.625);

  257. 			double sub_1811 = (mix_1928 - mix_1832);

  258. 			double sub_1808 = (mix_1826 - mix_1820);

  259. 			double sub_1807 = (sub_1811 - sub_1808);

  260. 			double mul_1790 = (sub_1807 * 0.5);

  261. 			double add_1806 = (sub_1811 + sub_1808);

  262. 			double rsub_1804 = (0 - add_1806);

  263. 			double mul_1789 = (rsub_1804 * 0.5);

  264. 			double tap_1836 = m_delay_18.read_linear(add_1851);

  265. 			double tap_1837 = m_delay_18.read_linear(add_1850);

  266. 			double tap_1838 = m_delay_18.read_linear(add_1849);

  267. 			double tap_1839 = m_delay_18.read_linear(add_1848);

  268. 			double mul_1840 = (tap_1839 * expr_2522);

  269. 			double add_1813 = (mul_1788 + mul_1840);

  270. 			double mul_1846 = (tap_1836 * expr_2525);

  271. 			double add_1816 = (mul_1791 + mul_1846);

  272. 			double mul_1844 = (tap_1837 * expr_2524);

  273. 			double add_1815 = (mul_1790 + mul_1844);

  274. 			double mul_1842 = (tap_1838 * expr_2523);

  275. 			double add_1814 = (mul_1789 + mul_1842);

  276. 			double phasor_1766 = m_phasor_38(div_1745, samples_to_seconds);

  277. 			double add_1744 = ((m_history_6 + phasor_1766) + 0.5);

  278. 			double mod_1743 = safemod(add_1744, 1);

  279. 			double delta_1723 = m_delta_39(mod_1743);

  280. 			double sah_1702 = m_sah_40(mul_1721, delta_1723, 0);

  281. 			double sah_1722 = m_sah_41(mstosamps_1760, delta_1723, 0);

  282. 			double mul_1711 = (sah_1722 * mod_1743);

  283. 			double sub_1742 = (mod_1743 - 0.5);

  284. 			double mul_1741 = (sub_1742 * 3.1415926535898);

  285. 			double cos_1740 = cos(mul_1741);

  286. 			double mul_1730 = (cos_1740 * cos_1740);

  287. 			double add_1759 = ((m_history_5 + phasor_1766) + 0.25);

  288. 			double mod_1758 = safemod(add_1759, 1);

  289. 			double delta_1726 = m_delta_42(mod_1758);

  290. 			double sah_1704 = m_sah_43(mul_1724, delta_1726, 0);

  291. 			double sah_1725 = m_sah_44(mstosamps_1760, delta_1726, 0);

  292. 			double mul_1712 = (sah_1725 * mod_1758);

  293. 			double sub_1757 = (mod_1758 - 0.5);

  294. 			double mul_1756 = (sub_1757 * 3.1415926535898);

  295. 			double cos_1755 = cos(mul_1756);

  296. 			double mul_1731 = (cos_1755 * cos_1755);

  297. 			double add_1765 = ((m_history_4 + phasor_1766) + 0);

  298. 			double mod_1764 = safemod(add_1765, 1);

  299. 			double delta_1707 = m_delta_45(mod_1764);

  300. 			double sah_1706 = m_sah_46(mul_1727, delta_1707, 0);

  301. 			double sah_1728 = m_sah_47(mstosamps_1760, delta_1707, 0);

  302. 			double mul_1713 = (sah_1728 * mod_1764);

  303. 			double sub_1763 = (mod_1764 - 0.5);

  304. 			double mul_1762 = (sub_1763 * 3.1415926535898);

  305. 			double cos_1761 = cos(mul_1762);

  306. 			double mul_1732 = (cos_1761 * cos_1761);

  307. 			double add_1738 = ((m_history_3 + phasor_1766) + 0.75);

  308. 			double mod_1737 = safemod(add_1738, 1);

  309. 			double delta_1720 = m_delta_48(mod_1737);

  310. 			double sah_1700 = m_sah_49(mul_1718, delta_1720, 0);

  311. 			double sah_1719 = m_sah_50(mstosamps_1760, delta_1720, 0);

  312. 			double mul_1710 = (sah_1719 * mod_1737);

  313. 			double tap_1751 = m_delay_17.read_linear(mul_1713);

  314. 			double tap_1752 = m_delay_17.read_linear(mul_1712);

  315. 			double tap_1753 = m_delay_17.read_linear(mul_1711);

  316. 			double tap_1754 = m_delay_17.read_linear(mul_1710);

  317. 			double mul_1739 = (tap_1753 * mul_1730);

  318. 			double mul_1748 = (tap_1752 * mul_1731);

  319. 			double mul_1749 = (tap_1751 * mul_1732);

  320. 			double sub_1736 = (mod_1737 - 0.5);

  321. 			double mul_1735 = (sub_1736 * 3.1415926535898);

  322. 			double cos_1734 = cos(mul_1735);

  323. 			double mul_1729 = (cos_1734 * cos_1734);

  324. 			double mul_1733 = (tap_1754 * mul_1729);

  325. 			double mul_1771 = ((((mul_1749 + mul_1748) + mul_1739) + mul_1733) * add_1772);

  326. 			double sub_1768 = (mul_1771 - (m_y_11 + mul_1770));

  327. 			double mix_2557 = (in1 + (m_shift_25 * (sub_1768 - in1)));

  328. 			double mix_1709 = mix_2557;

  329. 			double mul_1782 = (mix_1709 * 0.707);

  330. 			double mix_2558 = (mul_1782 + (rsub_1933 * (m_history_1 - mul_1782)));

  331. 			double mix_1932 = mix_2558;

  332. 			double tap_1916 = m_delay_16.read_linear(mul_1917);

  333. 			double tap_1874 = m_delay_15.read_linear(mul_1875);

  334. 			double mul_1872 = (tap_1874 * 0.625);

  335. 			double mul_1914 = (tap_1916 * 0.75);

  336. 			double sub_1913 = (mix_1932 - mul_1914);

  337. 			double mul_1912 = (sub_1913 * 0.75);

  338. 			double add_1911 = (mul_1912 + tap_1916);

  339. 			double tap_1900 = m_delay_14.read_linear(mul_1901);

  340. 			double mul_1898 = (tap_1900 * 0.625);

  341. 			double tap_1881 = m_delay_13.read_linear(mul_1882);

  342. 			double mul_1879 = (tap_1881 * 0.75);

  343. 			double tap_1909 = m_delay_12.read_linear(mul_1910);

  344. 			double mul_1907 = (tap_1909 * 0.75);

  345. 			double mul_1803 = (mul_1791 * m_tail_34);

  346. 			double mul_1801 = (mul_1789 * m_tail_34);

  347. 			double add_1787 = (mul_1803 + mul_1801);

  348. 			double mul_1802 = (mul_1790 * m_tail_34);

  349. 			double mul_1800 = (mul_1788 * m_tail_34);

  350. 			double add_1786 = (mul_1802 + mul_1800);

  351. 			double sub_1795 = (add_1787 - add_1786);

  352. 			double mul_1799 = (mul_1846 * m_early_35);

  353. 			double mul_1797 = (mul_1842 * m_early_35);

  354. 			double add_1785 = (mul_1799 + mul_1797);

  355. 			double mul_1798 = (mul_1844 * m_early_35);

  356. 			double mul_1796 = (mul_1840 * m_early_35);

  357. 			double add_1784 = (mul_1798 + mul_1796);

  358. 			double sub_1794 = (add_1785 - add_1784);

  359. 			double add_1781 = (sub_1795 + sub_1794);

  360. 			double add_1783 = (add_1781 + mix_1709);

  361. 			double sub_1878 = (add_1783 - mul_1879);

  362. 			double mul_1877 = (sub_1878 * 0.75);

  363. 			double add_1876 = (mul_1877 + tap_1881);

  364. 			double sub_1871 = (add_1876 - mul_1872);

  365. 			double mul_1870 = (sub_1871 * 0.625);

  366. 			double add_1869 = (mul_1870 + tap_1874);

  367. 			double sub_1864 = (add_1869 - mul_1865);

  368. 			double mul_1863 = (sub_1864 * 0.625);

  369. 			double add_1862 = (mul_1863 + tap_1867);

  370. 			double mul_1780 = (add_1862 * m_mix_36);

  371. 			double out2 = (mul_1780 + in1);

  372. 			double add_1793 = (add_1781 + mix_1709);

  373. 			double sub_1906 = (add_1793 - mul_1907);

  374. 			double mul_1905 = (sub_1906 * 0.75);

  375. 			double add_1904 = (mul_1905 + tap_1909);

  376. 			double sub_1897 = (add_1904 - mul_1898);

  377. 			double mul_1896 = (sub_1897 * 0.625);

  378. 			double add_1895 = (mul_1896 + tap_1900);

  379. 			double sub_1890 = (add_1895 - mul_1891);

  380. 			double mul_1889 = (sub_1890 * 0.625);

  381. 			double add_1888 = (mul_1889 + tap_1893);

  382. 			double mul_1792 = (add_1888 * m_mix_36);

  383. 			double out1 = (mul_1792 + in1);

  384. 			double y2_next_2542 = m_y_2;

  385. 			double history_1819_next_2543 = mix_1820;

  386. 			double history_1825_next_2544 = mix_1826;

  387. 			double history_1927_next_2545 = mix_1928;

  388. 			double history_1831_next_2546 = mix_1832;

  389. 			double history_1703_next_2547 = sah_1702;

  390. 			double history_1705_next_2548 = sah_1704;

  391. 			double history_1708_next_2549 = sah_1706;

  392. 			double history_1701_next_2550 = sah_1700;

  393. 			double y1_next_2551 = sub_1768;

  394. 			double history_1931_next_2552 = mix_1932;

  395. 			m_delay_24.write(add_1813);

  396. 			m_delay_23.write(add_1814);

  397. 			m_delay_22.write(add_1816);

  398. 			m_delay_21.write(add_1815);

  399. 			m_delay_20.write(sub_1864);

  400. 			m_delay_19.write(sub_1890);

  401. 			m_delay_18.write(add_1911);

  402. 			m_delay_17.write(in1);

  403. 			m_delay_16.write(sub_1913);

  404. 			m_delay_15.write(sub_1871);

  405. 			m_delay_14.write(sub_1897);

  406. 			m_delay_13.write(sub_1878);

  407. 			m_delay_12.write(sub_1906);

  408. 			m_y_11 = y2_next_2542;

  409. 			m_history_10 = history_1819_next_2543;

  410. 			m_history_9 = history_1825_next_2544;

  411. 			m_history_8 = history_1927_next_2545;

  412. 			m_history_7 = history_1831_next_2546;

  413. 			m_history_6 = history_1703_next_2547;

  414. 			m_history_5 = history_1705_next_2548;

  415. 			m_history_4 = history_1708_next_2549;

  416. 			m_history_3 = history_1701_next_2550;

  417. 			m_y_2 = y1_next_2551;

  418. 			m_history_1 = history_1931_next_2552;

  419. 			m_delay_12.step();

  420. 			m_delay_13.step();

  421. 			m_delay_14.step();

  422. 			m_delay_15.step();

  423. 			m_delay_16.step();

  424. 			m_delay_17.step();

  425. 			m_delay_18.step();

  426. 			m_delay_19.step();

  427. 			m_delay_20.step();

  428. 			m_delay_21.step();

  429. 			m_delay_22.step();

  430. 			m_delay_23.step();

  431. 			m_delay_24.step();

  432. 			// assign results to output buffer;

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

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

  435. 			

  436. 		};

  437. 		return __exception;

  438. 		

  439. 	};

  440. 	inline void set_shift(double _value) {

  441. 		m_shift_25 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  442. 	};

  443. 	inline void set_ratio(double _value) {

  444. 		m_ratio_26 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  445. 	};

  446. 	inline void set_damping(double _value) {

  447. 		m_damping_27 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  448. 	};

  449. 	inline void set_spread(double _value) {

  450. 		m_spread_28 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  451. 	};

  452. 	inline void set_blur(double _value) {

  453. 		m_blur_29 = (_value < 0.01 ? 0.01 : (_value > 0.25 ? 0.25 : _value));

  454. 	};

  455. 	inline void set_roomsize(double _value) {

  456. 		m_roomsize_30 = (_value < 0.1 ? 0.1 : (_value > 300 ? 300 : _value));

  457. 	};

  458. 	inline void set_decay(double _value) {

  459. 		m_decay_31 = (_value < 0.1 ? 0.1 : (_value > 360 ? 360 : _value));

  460. 	};

  461. 	inline void set_tone(double _value) {

  462. 		m_tone_32 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  463. 	};

  464. 	inline void set_cutoff(double _value) {

  465. 		m_cutoff_33 = (_value < 0 ? 0 : (_value > 6000 ? 6000 : _value));

  466. 	};

  467. 	inline void set_tail(double _value) {

  468. 		m_tail_34 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  469. 	};

  470. 	inline void set_early(double _value) {

  471. 		m_early_35 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  472. 	};

  473. 	inline void set_mix(double _value) {

  474. 		m_mix_36 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  475. 	};

  476. 	inline void set_window(double _value) {

  477. 		m_window_37 = (_value < 0.1 ? 0.1 : (_value > 1000 ? 1000 : _value));

  478. 	};

  479. 	

  480. } State;

  481. 

  482. 

  483. /// 

  484. ///	Configuration for the genlib API

  485. ///

  486. 

  487. /// Number of signal inputs and outputs 

  488. 

  489. int gen_kernel_numins = 1;

  490. int gen_kernel_numouts = 2;

  491. 

  492. int num_inputs() { return gen_kernel_numins; }

  493. int num_outputs() { return gen_kernel_numouts; }

  494. int num_params() { return 13; }

  495. 

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

  497. 

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

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

  500. 

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

  502. 

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

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

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

  506. }

  507. 

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

  509. 

  510. void reset(CommonState *cself) { 

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

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

  513. }

  514. 

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

  516. 

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

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

  519. 	switch (index) {

  520. 		case 0: self->set_shift(value); break;

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

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

  523. 		case 3: self->set_spread(value); break;

  524. 		case 4: self->set_blur(value); break;

  525. 		case 5: self->set_roomsize(value); break;

  526. 		case 6: self->set_decay(value); break;

  527. 		case 7: self->set_tone(value); break;

  528. 		case 8: self->set_cutoff(value); break;

  529. 		case 9: self->set_tail(value); break;

  530. 		case 10: self->set_early(value); break;

  531. 		case 11: self->set_mix(value); break;

  532. 		case 12: self->set_window(value); break;

  533. 		

  534. 		default: break;

  535. 	}

  536. }

  537. 

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

  539. 

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

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

  542. 	switch (index) {

  543. 		case 0: *value = self->m_shift_25; break;

  544. 		case 1: *value = self->m_ratio_26; break;

  545. 		case 2: *value = self->m_damping_27; break;

  546. 		case 3: *value = self->m_spread_28; break;

  547. 		case 4: *value = self->m_blur_29; break;

  548. 		case 5: *value = self->m_roomsize_30; break;

  549. 		case 6: *value = self->m_decay_31; break;

  550. 		case 7: *value = self->m_tone_32; break;

  551. 		case 8: *value = self->m_cutoff_33; break;

  552. 		case 9: *value = self->m_tail_34; break;

  553. 		case 10: *value = self->m_early_35; break;

  554. 		case 11: *value = self->m_mix_36; break;

  555. 		case 12: *value = self->m_window_37; break;

  556. 		

  557. 		default: break;

  558. 	}

  559. }

  560. 

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

  562. 

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

  564. 	State *self = new State;

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

  566. 	ParamInfo *pi;

  567. 	self->__commonstate.inputnames = gen_kernel_innames;

  568. 	self->__commonstate.outputnames = gen_kernel_outnames;

  569. 	self->__commonstate.numins = gen_kernel_numins;

  570. 	self->__commonstate.numouts = gen_kernel_numouts;

  571. 	self->__commonstate.sr = sr;

  572. 	self->__commonstate.vs = vs;

  573. 	self->__commonstate.params = (ParamInfo *)genlib_sysmem_newptr(13 * sizeof(ParamInfo));

  574. 	self->__commonstate.numparams = 13;

  575. 	// initialize parameter 0 ("m_shift_25")

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

  577. 	pi->name = "shift";

  578. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  579. 	pi->defaultvalue = self->m_shift_25;

  580. 	pi->defaultref = 0;

  581. 	pi->hasinputminmax = false;

  582. 	pi->inputmin = 0; 

  583. 	pi->inputmax = 1;

  584. 	pi->hasminmax = true;

  585. 	pi->outputmin = 0;

  586. 	pi->outputmax = 1;

  587. 	pi->exp = 0;

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

  589. 	// initialize parameter 1 ("m_ratio_26")

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

  591. 	pi->name = "ratio";

  592. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  593. 	pi->defaultvalue = self->m_ratio_26;

  594. 	pi->defaultref = 0;

  595. 	pi->hasinputminmax = false;

  596. 	pi->inputmin = 0; 

  597. 	pi->inputmax = 1;

  598. 	pi->hasminmax = true;

  599. 	pi->outputmin = 0.5;

  600. 	pi->outputmax = 2;

  601. 	pi->exp = 0;

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

  603. 	// initialize parameter 2 ("m_damping_27")

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

  605. 	pi->name = "damping";

  606. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  607. 	pi->defaultvalue = self->m_damping_27;

  608. 	pi->defaultref = 0;

  609. 	pi->hasinputminmax = false;

  610. 	pi->inputmin = 0; 

  611. 	pi->inputmax = 1;

  612. 	pi->hasminmax = true;

  613. 	pi->outputmin = 0;

  614. 	pi->outputmax = 1;

  615. 	pi->exp = 0;

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

  617. 	// initialize parameter 3 ("m_spread_28")

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

  619. 	pi->name = "spread";

  620. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  621. 	pi->defaultvalue = self->m_spread_28;

  622. 	pi->defaultref = 0;

  623. 	pi->hasinputminmax = false;

  624. 	pi->inputmin = 0; 

  625. 	pi->inputmax = 1;

  626. 	pi->hasminmax = true;

  627. 	pi->outputmin = 0;

  628. 	pi->outputmax = 100;

  629. 	pi->exp = 0;

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

  631. 	// initialize parameter 4 ("m_blur_29")

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

  633. 	pi->name = "blur";

  634. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  635. 	pi->defaultvalue = self->m_blur_29;

  636. 	pi->defaultref = 0;

  637. 	pi->hasinputminmax = false;

  638. 	pi->inputmin = 0; 

  639. 	pi->inputmax = 1;

  640. 	pi->hasminmax = true;

  641. 	pi->outputmin = 0.01;

  642. 	pi->outputmax = 0.25;

  643. 	pi->exp = 0;

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

  645. 	// initialize parameter 5 ("m_roomsize_30")

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

  647. 	pi->name = "roomsize";

  648. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  649. 	pi->defaultvalue = self->m_roomsize_30;

  650. 	pi->defaultref = 0;

  651. 	pi->hasinputminmax = false;

  652. 	pi->inputmin = 0; 

  653. 	pi->inputmax = 1;

  654. 	pi->hasminmax = true;

  655. 	pi->outputmin = 0.1;

  656. 	pi->outputmax = 300;

  657. 	pi->exp = 0;

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

  659. 	// initialize parameter 6 ("m_decay_31")

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

  661. 	pi->name = "decay";

  662. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  663. 	pi->defaultvalue = self->m_decay_31;

  664. 	pi->defaultref = 0;

  665. 	pi->hasinputminmax = false;

  666. 	pi->inputmin = 0; 

  667. 	pi->inputmax = 1;

  668. 	pi->hasminmax = true;

  669. 	pi->outputmin = 0.1;

  670. 	pi->outputmax = 360;

  671. 	pi->exp = 0;

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

  673. 	// initialize parameter 7 ("m_tone_32")

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

  675. 	pi->name = "tone";

  676. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  677. 	pi->defaultvalue = self->m_tone_32;

  678. 	pi->defaultref = 0;

  679. 	pi->hasinputminmax = false;

  680. 	pi->inputmin = 0; 

  681. 	pi->inputmax = 1;

  682. 	pi->hasminmax = true;

  683. 	pi->outputmin = 0;

  684. 	pi->outputmax = 1;

  685. 	pi->exp = 0;

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

  687. 	// initialize parameter 8 ("m_cutoff_33")

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

  689. 	pi->name = "cutoff";

  690. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  691. 	pi->defaultvalue = self->m_cutoff_33;

  692. 	pi->defaultref = 0;

  693. 	pi->hasinputminmax = false;

  694. 	pi->inputmin = 0; 

  695. 	pi->inputmax = 1;

  696. 	pi->hasminmax = true;

  697. 	pi->outputmin = 0;

  698. 	pi->outputmax = 6000;

  699. 	pi->exp = 0;

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

  701. 	// initialize parameter 9 ("m_tail_34")

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

  703. 	pi->name = "tail";

  704. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  705. 	pi->defaultvalue = self->m_tail_34;

  706. 	pi->defaultref = 0;

  707. 	pi->hasinputminmax = false;

  708. 	pi->inputmin = 0; 

  709. 	pi->inputmax = 1;

  710. 	pi->hasminmax = true;

  711. 	pi->outputmin = 0;

  712. 	pi->outputmax = 1;

  713. 	pi->exp = 0;

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

  715. 	// initialize parameter 10 ("m_early_35")

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

  717. 	pi->name = "early";

  718. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  719. 	pi->defaultvalue = self->m_early_35;

  720. 	pi->defaultref = 0;

  721. 	pi->hasinputminmax = false;

  722. 	pi->inputmin = 0; 

  723. 	pi->inputmax = 1;

  724. 	pi->hasminmax = true;

  725. 	pi->outputmin = 0;

  726. 	pi->outputmax = 1;

  727. 	pi->exp = 0;

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

  729. 	// initialize parameter 11 ("m_mix_36")

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

  731. 	pi->name = "mix";

  732. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  733. 	pi->defaultvalue = self->m_mix_36;

  734. 	pi->defaultref = 0;

  735. 	pi->hasinputminmax = false;

  736. 	pi->inputmin = 0; 

  737. 	pi->inputmax = 1;

  738. 	pi->hasminmax = true;

  739. 	pi->outputmin = 0;

  740. 	pi->outputmax = 1;

  741. 	pi->exp = 0;

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

  743. 	// initialize parameter 12 ("m_window_37")

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

  745. 	pi->name = "window";

  746. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  747. 	pi->defaultvalue = self->m_window_37;

  748. 	pi->defaultref = 0;

  749. 	pi->hasinputminmax = false;

  750. 	pi->inputmin = 0; 

  751. 	pi->inputmax = 1;

  752. 	pi->hasminmax = true;

  753. 	pi->outputmin = 0.1;

  754. 	pi->outputmax = 1000;

  755. 	pi->exp = 0;

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

  757. 	

  758. 	return self;

  759. }

  760. 

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

  762. 

  763. void destroy(CommonState *cself) { 

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

  765. 	genlib_sysmem_freeptr(cself->params);

  766. 		

  767. 	delete self; 

  768. }

  769. 

  770. 

  771. } // gen_exported::