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

537 lines
17KB
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_10;

  35. 	Delay m_delay_11;

  36. 	Delta m_delta_29;

  37. 	Delta m_delta_26;

  38. 	Delta m_delta_23;

  39. 	Delta m_delta_33;

  40. 	Delta m_delta_36;

  41. 	Delta m_delta_20;

  42. 	Delta m_delta_39;

  43. 	Delta m_delta_42;

  44. 	Phasor m_phasor_32;

  45. 	Phasor m_phasor_19;

  46. 	Sah m_sah_25;

  47. 	Sah m_sah_35;

  48. 	Sah m_sah_24;

  49. 	Sah m_sah_27;

  50. 	Sah m_sah_28;

  51. 	Sah m_sah_41;

  52. 	Sah m_sah_30;

  53. 	Sah m_sah_34;

  54. 	Sah m_sah_37;

  55. 	Sah m_sah_38;

  56. 	Sah m_sah_31;

  57. 	Sah m_sah_40;

  58. 	Sah m_sah_22;

  59. 	Sah m_sah_44;

  60. 	Sah m_sah_43;

  61. 	Sah m_sah_21;

  62. 	double m_y_1;

  63. 	double m_history_5;

  64. 	double m_history_6;

  65. 	double samplerate;

  66. 	double m_history_4;

  67. 	double m_history_2;

  68. 	double m_history_7;

  69. 	double m_history_3;

  70. 	double m_history_8;

  71. 	double m_ratio_12;

  72. 	double m_history_9;

  73. 	double m_delay_18;

  74. 	double samples_to_seconds;

  75. 	double m_cutoff_16;

  76. 	double m_blur_17;

  77. 	double m_delay_14;

  78. 	double m_mix_13;

  79. 	double m_ratio_15;

  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_y_1 = 0;

  88. 		m_history_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_delay_10.reset("m_delay_10", 96000);

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

  98. 		m_ratio_12 = 2;

  99. 		m_mix_13 = 0.5;

  100. 		m_delay_14 = 100;

  101. 		m_ratio_15 = 0.5;

  102. 		m_cutoff_16 = 2250;

  103. 		m_blur_17 = 0.25;

  104. 		m_delay_18 = 100;

  105. 		samples_to_seconds = (1 / samplerate);

  106. 		m_phasor_19.reset(0);

  107. 		m_delta_20.reset(0);

  108. 		m_sah_21.reset(0);

  109. 		m_sah_22.reset(0);

  110. 		m_delta_23.reset(0);

  111. 		m_sah_24.reset(0);

  112. 		m_sah_25.reset(0);

  113. 		m_delta_26.reset(0);

  114. 		m_sah_27.reset(0);

  115. 		m_sah_28.reset(0);

  116. 		m_delta_29.reset(0);

  117. 		m_sah_30.reset(0);

  118. 		m_sah_31.reset(0);

  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. 		if (__exception) { 

  141. 			return __exception;

  142. 			

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

  144. 			__exception = GENLIB_ERR_NULL_BUFFER;

  145. 			return __exception;

  146. 			

  147. 		};

  148. 		double expr_5155 = safediv(((m_cutoff_16 * 2) * 3.1415926535898), 44100);

  149. 		double sin_5012 = sin(expr_5155);

  150. 		double clamp_5013 = ((sin_5012 <= 1e-05) ? 1e-05 : ((sin_5012 >= 0.99999) ? 0.99999 : sin_5012));

  151. 		double mstosamps_5148 = (m_delay_14 * (samplerate * 0.001));

  152. 		double mstosamps_5077 = (m_delay_18 * (samplerate * 0.001));

  153. 		double rsub_5064 = (1 - m_ratio_12);

  154. 		double mul_5063 = (rsub_5064 * 1000);

  155. 		double div_5062 = safediv(mul_5063, m_delay_18);

  156. 		samples_to_seconds = (1 / samplerate);

  157. 		double rsub_5135 = (1 - m_ratio_15);

  158. 		double mul_5134 = (rsub_5135 * 1000);

  159. 		double div_5133 = safediv(mul_5134, m_delay_14);

  160. 		// the main sample loop;

  161. 		while ((__n--)) { 

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

  163. 			double noise_5014 = noise();

  164. 			double abs_5031 = fabs(noise_5014);

  165. 			double mul_5035 = (abs_5031 * m_blur_17);

  166. 			double noise_5086 = noise();

  167. 			double abs_5104 = fabs(noise_5086);

  168. 			double mul_5112 = (abs_5104 * m_blur_17);

  169. 			double noise_5015 = noise();

  170. 			double abs_5032 = fabs(noise_5015);

  171. 			double mul_5038 = (abs_5032 * m_blur_17);

  172. 			double noise_5084 = noise();

  173. 			double abs_5102 = fabs(noise_5084);

  174. 			double mul_5106 = (abs_5102 * m_blur_17);

  175. 			double noise_5017 = noise();

  176. 			double abs_5034 = fabs(noise_5017);

  177. 			double mul_5044 = (abs_5034 * m_blur_17);

  178. 			double noise_5087 = noise();

  179. 			double abs_5105 = fabs(noise_5087);

  180. 			double mul_5115 = (abs_5105 * m_blur_17);

  181. 			double noise_5016 = noise();

  182. 			double abs_5033 = fabs(noise_5016);

  183. 			double mul_5041 = (abs_5033 * m_blur_17);

  184. 			double noise_5085 = noise();

  185. 			double abs_5103 = fabs(noise_5085);

  186. 			double mul_5109 = (abs_5103 * m_blur_17);

  187. 			double phasor_5083 = m_phasor_19(div_5062, samples_to_seconds);

  188. 			double add_5055 = ((phasor_5083 + m_history_9) + 0.75);

  189. 			double mod_5054 = safemod(add_5055, 1);

  190. 			double delta_5037 = m_delta_20(mod_5054);

  191. 			double sah_5018 = m_sah_21(mul_5035, delta_5037, 0);

  192. 			double sah_5036 = m_sah_22(mstosamps_5077, delta_5037, 0);

  193. 			double mul_5027 = (sah_5036 * mod_5054);

  194. 			double sub_5053 = (mod_5054 - 0.5);

  195. 			double mul_5052 = (sub_5053 * 3.1415926535898);

  196. 			double cos_5051 = cos(mul_5052);

  197. 			double mul_5046 = (cos_5051 * cos_5051);

  198. 			double add_5061 = ((phasor_5083 + m_history_8) + 0.5);

  199. 			double mod_5060 = safemod(add_5061, 1);

  200. 			double delta_5040 = m_delta_23(mod_5060);

  201. 			double sah_5020 = m_sah_24(mul_5038, delta_5040, 0);

  202. 			double sah_5039 = m_sah_25(mstosamps_5077, delta_5040, 0);

  203. 			double mul_5028 = (sah_5039 * mod_5060);

  204. 			double sub_5059 = (mod_5060 - 0.5);

  205. 			double mul_5058 = (sub_5059 * 3.1415926535898);

  206. 			double cos_5057 = cos(mul_5058);

  207. 			double mul_5047 = (cos_5057 * cos_5057);

  208. 			double add_5082 = ((phasor_5083 + m_history_7) + 0);

  209. 			double mod_5081 = safemod(add_5082, 1);

  210. 			double delta_5025 = m_delta_26(mod_5081);

  211. 			double sah_5024 = m_sah_27(mul_5044, delta_5025, 0);

  212. 			double sah_5045 = m_sah_28(mstosamps_5077, delta_5025, 0);

  213. 			double mul_5030 = (sah_5045 * mod_5081);

  214. 			double sub_5080 = (mod_5081 - 0.5);

  215. 			double mul_5079 = (sub_5080 * 3.1415926535898);

  216. 			double cos_5078 = cos(mul_5079);

  217. 			double mul_5049 = (cos_5078 * cos_5078);

  218. 			double add_5076 = ((phasor_5083 + m_history_6) + 0.25);

  219. 			double mod_5075 = safemod(add_5076, 1);

  220. 			double delta_5043 = m_delta_29(mod_5075);

  221. 			double sah_5022 = m_sah_30(mul_5041, delta_5043, 0);

  222. 			double sah_5042 = m_sah_31(mstosamps_5077, delta_5043, 0);

  223. 			double mul_5029 = (sah_5042 * mod_5075);

  224. 			double tap_5068 = m_delay_11.read_linear(mul_5030);

  225. 			double tap_5069 = m_delay_11.read_linear(mul_5029);

  226. 			double tap_5070 = m_delay_11.read_linear(mul_5028);

  227. 			double tap_5071 = m_delay_11.read_linear(mul_5027);

  228. 			double mul_5050 = (tap_5071 * mul_5046);

  229. 			double mul_5056 = (tap_5070 * mul_5047);

  230. 			double mul_5066 = (tap_5068 * mul_5049);

  231. 			double sub_5074 = (mod_5075 - 0.5);

  232. 			double mul_5073 = (sub_5074 * 3.1415926535898);

  233. 			double cos_5072 = cos(mul_5073);

  234. 			double mul_5048 = (cos_5072 * cos_5072);

  235. 			double mul_5065 = (tap_5069 * mul_5048);

  236. 			double phasor_5154 = m_phasor_32(div_5133, samples_to_seconds);

  237. 			double add_5147 = ((m_history_5 + phasor_5154) + 0.25);

  238. 			double mod_5146 = safemod(add_5147, 1);

  239. 			double delta_5114 = m_delta_33(mod_5146);

  240. 			double sah_5092 = m_sah_34(mul_5112, delta_5114, 0);

  241. 			double sah_5113 = m_sah_35(mstosamps_5148, delta_5114, 0);

  242. 			double mul_5100 = (sah_5113 * mod_5146);

  243. 			double sub_5145 = (mod_5146 - 0.5);

  244. 			double mul_5144 = (sub_5145 * 3.1415926535898);

  245. 			double cos_5143 = cos(mul_5144);

  246. 			double mul_5119 = (cos_5143 * cos_5143);

  247. 			double add_5126 = ((m_history_4 + phasor_5154) + 0.75);

  248. 			double mod_5125 = safemod(add_5126, 1);

  249. 			double delta_5108 = m_delta_36(mod_5125);

  250. 			double sah_5088 = m_sah_37(mul_5106, delta_5108, 0);

  251. 			double sah_5107 = m_sah_38(mstosamps_5148, delta_5108, 0);

  252. 			double mul_5098 = (sah_5107 * mod_5125);

  253. 			double sub_5124 = (mod_5125 - 0.5);

  254. 			double mul_5123 = (sub_5124 * 3.1415926535898);

  255. 			double cos_5122 = cos(mul_5123);

  256. 			double mul_5117 = (cos_5122 * cos_5122);

  257. 			double add_5153 = ((m_history_3 + phasor_5154) + 0);

  258. 			double mod_5152 = safemod(add_5153, 1);

  259. 			double delta_5095 = m_delta_39(mod_5152);

  260. 			double sah_5094 = m_sah_40(mul_5115, delta_5095, 0);

  261. 			double sah_5116 = m_sah_41(mstosamps_5148, delta_5095, 0);

  262. 			double mul_5101 = (sah_5116 * mod_5152);

  263. 			double sub_5151 = (mod_5152 - 0.5);

  264. 			double mul_5150 = (sub_5151 * 3.1415926535898);

  265. 			double cos_5149 = cos(mul_5150);

  266. 			double mul_5120 = (cos_5149 * cos_5149);

  267. 			double add_5132 = ((m_history_2 + phasor_5154) + 0.5);

  268. 			double mod_5131 = safemod(add_5132, 1);

  269. 			double delta_5111 = m_delta_42(mod_5131);

  270. 			double sah_5090 = m_sah_43(mul_5109, delta_5111, 0);

  271. 			double sah_5110 = m_sah_44(mstosamps_5148, delta_5111, 0);

  272. 			double mul_5099 = (sah_5110 * mod_5131);

  273. 			double tap_5139 = m_delay_10.read_linear(mul_5101);

  274. 			double tap_5140 = m_delay_10.read_linear(mul_5100);

  275. 			double tap_5141 = m_delay_10.read_linear(mul_5099);

  276. 			double tap_5142 = m_delay_10.read_linear(mul_5098);

  277. 			double mul_5137 = (tap_5139 * mul_5120);

  278. 			double mul_5136 = (tap_5140 * mul_5119);

  279. 			double mul_5121 = (tap_5142 * mul_5117);

  280. 			double sub_5130 = (mod_5131 - 0.5);

  281. 			double mul_5129 = (sub_5130 * 3.1415926535898);

  282. 			double cos_5128 = cos(mul_5129);

  283. 			double mul_5118 = (cos_5128 * cos_5128);

  284. 			double mul_5127 = (tap_5141 * mul_5118);

  285. 			double add_5174 = (((((((mul_5066 + mul_5065) + mul_5056) + mul_5050) + mul_5121) + mul_5127) + mul_5136) + mul_5137);

  286. 			double mix_5173 = (m_y_1 + (clamp_5013 * (add_5174 - m_y_1)));

  287. 			double mix_5010 = mix_5173;

  288. 			double mix_5175 = (in1 + (m_mix_13 * (mix_5010 - in1)));

  289. 			double out1 = mix_5175;

  290. 			double history_5019_next_5156 = sah_5018;

  291. 			double history_5021_next_5157 = sah_5020;

  292. 			double history_5026_next_5158 = sah_5024;

  293. 			double history_5023_next_5159 = sah_5022;

  294. 			double history_5093_next_5160 = sah_5092;

  295. 			double history_5089_next_5161 = sah_5088;

  296. 			double history_5096_next_5162 = sah_5094;

  297. 			double history_5091_next_5163 = sah_5090;

  298. 			double y0_next_5164 = mix_5010;

  299. 			m_delay_11.write(in1);

  300. 			m_delay_10.write(in1);

  301. 			m_history_9 = history_5019_next_5156;

  302. 			m_history_8 = history_5021_next_5157;

  303. 			m_history_7 = history_5026_next_5158;

  304. 			m_history_6 = history_5023_next_5159;

  305. 			m_history_5 = history_5093_next_5160;

  306. 			m_history_4 = history_5089_next_5161;

  307. 			m_history_3 = history_5096_next_5162;

  308. 			m_history_2 = history_5091_next_5163;

  309. 			m_y_1 = y0_next_5164;

  310. 			m_delay_10.step();

  311. 			m_delay_11.step();

  312. 			// assign results to output buffer;

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

  314. 			

  315. 		};

  316. 		return __exception;

  317. 		

  318. 	};

  319. 	inline void set_ratio2(double _value) {

  320. 		m_ratio_12 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  321. 	};

  322. 	inline void set_mix(double _value) {

  323. 		m_mix_13 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  324. 	};

  325. 	inline void set_delay1(double _value) {

  326. 		m_delay_14 = (_value < 0.1 ? 0.1 : (_value > 1000 ? 1000 : _value));

  327. 	};

  328. 	inline void set_ratio1(double _value) {

  329. 		m_ratio_15 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  330. 	};

  331. 	inline void set_cutoff(double _value) {

  332. 		m_cutoff_16 = (_value < 0 ? 0 : (_value > 3000 ? 3000 : _value));

  333. 	};

  334. 	inline void set_blur(double _value) {

  335. 		m_blur_17 = (_value < 0.01 ? 0.01 : (_value > 0.25 ? 0.25 : _value));

  336. 	};

  337. 	inline void set_delay2(double _value) {

  338. 		m_delay_18 = (_value < 0.1 ? 0.1 : (_value > 1000 ? 1000 : _value));

  339. 	};

  340. 	

  341. } State;

  342. 

  343. 

  344. /// 

  345. ///	Configuration for the genlib API

  346. ///

  347. 

  348. /// Number of signal inputs and outputs 

  349. 

  350. int gen_kernel_numins = 1;

  351. int gen_kernel_numouts = 1;

  352. 

  353. int num_inputs() { return gen_kernel_numins; }

  354. int num_outputs() { return gen_kernel_numouts; }

  355. int num_params() { return 7; }

  356. 

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

  358. 

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

  360. const char * gen_kernel_outnames[] = { "out1" };

  361. 

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

  363. 

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

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

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

  367. }

  368. 

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

  370. 

  371. void reset(CommonState *cself) { 

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

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

  374. }

  375. 

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

  377. 

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

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

  380. 	switch (index) {

  381. 		case 0: self->set_ratio2(value); break;

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

  383. 		case 2: self->set_delay1(value); break;

  384. 		case 3: self->set_ratio1(value); break;

  385. 		case 4: self->set_cutoff(value); break;

  386. 		case 5: self->set_blur(value); break;

  387. 		case 6: self->set_delay2(value); break;

  388. 		

  389. 		default: break;

  390. 	}

  391. }

  392. 

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

  394. 

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

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

  397. 	switch (index) {

  398. 		case 0: *value = self->m_ratio_12; break;

  399. 		case 1: *value = self->m_mix_13; break;

  400. 		case 2: *value = self->m_delay_14; break;

  401. 		case 3: *value = self->m_ratio_15; break;

  402. 		case 4: *value = self->m_cutoff_16; break;

  403. 		case 5: *value = self->m_blur_17; break;

  404. 		case 6: *value = self->m_delay_18; break;

  405. 		

  406. 		default: break;

  407. 	}

  408. }

  409. 

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

  411. 

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

  413. 	State *self = new State;

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

  415. 	ParamInfo *pi;

  416. 	self->__commonstate.inputnames = gen_kernel_innames;

  417. 	self->__commonstate.outputnames = gen_kernel_outnames;

  418. 	self->__commonstate.numins = gen_kernel_numins;

  419. 	self->__commonstate.numouts = gen_kernel_numouts;

  420. 	self->__commonstate.sr = sr;

  421. 	self->__commonstate.vs = vs;

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

  423. 	self->__commonstate.numparams = 7;

  424. 	// initialize parameter 0 ("m_ratio_12")

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

  426. 	pi->name = "ratio2";

  427. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  428. 	pi->defaultvalue = self->m_ratio_12;

  429. 	pi->defaultref = 0;

  430. 	pi->hasinputminmax = false;

  431. 	pi->inputmin = 0; 

  432. 	pi->inputmax = 1;

  433. 	pi->hasminmax = true;

  434. 	pi->outputmin = 0.5;

  435. 	pi->outputmax = 2;

  436. 	pi->exp = 0;

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

  438. 	// initialize parameter 1 ("m_mix_13")

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

  440. 	pi->name = "mix";

  441. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  442. 	pi->defaultvalue = self->m_mix_13;

  443. 	pi->defaultref = 0;

  444. 	pi->hasinputminmax = false;

  445. 	pi->inputmin = 0; 

  446. 	pi->inputmax = 1;

  447. 	pi->hasminmax = true;

  448. 	pi->outputmin = 0;

  449. 	pi->outputmax = 1;

  450. 	pi->exp = 0;

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

  452. 	// initialize parameter 2 ("m_delay_14")

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

  454. 	pi->name = "delay1";

  455. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  456. 	pi->defaultvalue = self->m_delay_14;

  457. 	pi->defaultref = 0;

  458. 	pi->hasinputminmax = false;

  459. 	pi->inputmin = 0; 

  460. 	pi->inputmax = 1;

  461. 	pi->hasminmax = true;

  462. 	pi->outputmin = 0.1;

  463. 	pi->outputmax = 1000;

  464. 	pi->exp = 0;

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

  466. 	// initialize parameter 3 ("m_ratio_15")

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

  468. 	pi->name = "ratio1";

  469. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  470. 	pi->defaultvalue = self->m_ratio_15;

  471. 	pi->defaultref = 0;

  472. 	pi->hasinputminmax = false;

  473. 	pi->inputmin = 0; 

  474. 	pi->inputmax = 1;

  475. 	pi->hasminmax = true;

  476. 	pi->outputmin = 0.5;

  477. 	pi->outputmax = 2;

  478. 	pi->exp = 0;

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

  480. 	// initialize parameter 4 ("m_cutoff_16")

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

  482. 	pi->name = "cutoff";

  483. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  484. 	pi->defaultvalue = self->m_cutoff_16;

  485. 	pi->defaultref = 0;

  486. 	pi->hasinputminmax = false;

  487. 	pi->inputmin = 0; 

  488. 	pi->inputmax = 1;

  489. 	pi->hasminmax = true;

  490. 	pi->outputmin = 0;

  491. 	pi->outputmax = 3000;

  492. 	pi->exp = 0;

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

  494. 	// initialize parameter 5 ("m_blur_17")

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

  496. 	pi->name = "blur";

  497. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  498. 	pi->defaultvalue = self->m_blur_17;

  499. 	pi->defaultref = 0;

  500. 	pi->hasinputminmax = false;

  501. 	pi->inputmin = 0; 

  502. 	pi->inputmax = 1;

  503. 	pi->hasminmax = true;

  504. 	pi->outputmin = 0.01;

  505. 	pi->outputmax = 0.25;

  506. 	pi->exp = 0;

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

  508. 	// initialize parameter 6 ("m_delay_18")

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

  510. 	pi->name = "delay2";

  511. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  512. 	pi->defaultvalue = self->m_delay_18;

  513. 	pi->defaultref = 0;

  514. 	pi->hasinputminmax = false;

  515. 	pi->inputmin = 0; 

  516. 	pi->inputmax = 1;

  517. 	pi->hasminmax = true;

  518. 	pi->outputmin = 0.1;

  519. 	pi->outputmax = 1000;

  520. 	pi->exp = 0;

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

  522. 	

  523. 	return self;

  524. }

  525. 

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

  527. 

  528. void destroy(CommonState *cself) { 

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

  530. 	genlib_sysmem_freeptr(cself->params);

  531. 		

  532. 	delete self; 

  533. }

  534. 

  535. 

  536. } // gen_exported::