DISTRHO
/
DPF-Plugins
mirror of https://github.com/DISTRHO/DPF-Plugins
1
0
Fork 0
Code Releases 8 Activity
Collection of DPF-based plugins for packaging
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.
36 Commits
1 Branch
86MB
Tree: b91b3dc60f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b91b3dc60f'
${ noResults }
DPF-Plugins/plugins/pitchotto/gen_exported.cpp

569 lines
18KB
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_12;

  35. 	Delay m_delay_11;

  36. 	Delta m_delta_22;

  37. 	Delta m_delta_38;

  38. 	Delta m_delta_41;

  39. 	Delta m_delta_31;

  40. 	Delta m_delta_28;

  41. 	Delta m_delta_25;

  42. 	Delta m_delta_44;

  43. 	Delta m_delta_35;

  44. 	Phasor m_phasor_34;

  45. 	Phasor m_phasor_21;

  46. 	Sah m_sah_23;

  47. 	Sah m_sah_27;

  48. 	Sah m_sah_42;

  49. 	Sah m_sah_26;

  50. 	Sah m_sah_24;

  51. 	Sah m_sah_43;

  52. 	Sah m_sah_36;

  53. 	Sah m_sah_29;

  54. 	Sah m_sah_40;

  55. 	Sah m_sah_37;

  56. 	Sah m_sah_30;

  57. 	Sah m_sah_39;

  58. 	Sah m_sah_32;

  59. 	Sah m_sah_33;

  60. 	Sah m_sah_46;

  61. 	Sah m_sah_45;

  62. 	double m_history_5;

  63. 	double m_history_6;

  64. 	double m_history_7;

  65. 	double samples_to_seconds;

  66. 	double m_history_4;

  67. 	double m_history_2;

  68. 	double m_history_3;

  69. 	double samplerate;

  70. 	double m_y_1;

  71. 	double m_history_9;

  72. 	double m_history_8;

  73. 	double m_resonance_13;

  74. 	double m_y_10;

  75. 	double m_window_19;

  76. 	double m_ratio_20;

  77. 	double m_blur_17;

  78. 	double m_ratio_18;

  79. 	double m_window_15;

  80. 	double m_cutoff_14;

  81. 	double m_mix_16;

  82. 	int vectorsize;

  83. 	int __exception;

  84. 	// re-initialize all member variables;

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

  86. 		__exception = 0;

  87. 		vectorsize = __vs;

  88. 		samplerate = __sr;

  89. 		m_y_1 = 0;

  90. 		m_history_2 = 0;

  91. 		m_history_3 = 0;

  92. 		m_history_4 = 0;

  93. 		m_history_5 = 0;

  94. 		m_history_6 = 0;

  95. 		m_history_7 = 0;

  96. 		m_history_8 = 0;

  97. 		m_history_9 = 0;

  98. 		m_y_10 = 0;

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

  100. 		m_delay_12.reset("m_delay_12", 96000);

  101. 		m_resonance_13 = 0;

  102. 		m_cutoff_14 = 2250;

  103. 		m_window_15 = 100;

  104. 		m_mix_16 = 0.5;

  105. 		m_blur_17 = 0.25;

  106. 		m_ratio_18 = 0.5;

  107. 		m_window_19 = 100;

  108. 		m_ratio_20 = 2;

  109. 		samples_to_seconds = (1 / samplerate);

  110. 		m_phasor_21.reset(0);

  111. 		m_delta_22.reset(0);

  112. 		m_sah_23.reset(0);

  113. 		m_sah_24.reset(0);

  114. 		m_delta_25.reset(0);

  115. 		m_sah_26.reset(0);

  116. 		m_sah_27.reset(0);

  117. 		m_delta_28.reset(0);

  118. 		m_sah_29.reset(0);

  119. 		m_sah_30.reset(0);

  120. 		m_delta_31.reset(0);

  121. 		m_sah_32.reset(0);

  122. 		m_sah_33.reset(0);

  123. 		m_phasor_34.reset(0);

  124. 		m_delta_35.reset(0);

  125. 		m_sah_36.reset(0);

  126. 		m_sah_37.reset(0);

  127. 		m_delta_38.reset(0);

  128. 		m_sah_39.reset(0);

  129. 		m_sah_40.reset(0);

  130. 		m_delta_41.reset(0);

  131. 		m_sah_42.reset(0);

  132. 		m_sah_43.reset(0);

  133. 		m_delta_44.reset(0);

  134. 		m_sah_45.reset(0);

  135. 		m_sah_46.reset(0);

  136. 		genlib_reset_complete(this);

  137. 		

  138. 	};

  139. 	// the signal processing routine;

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

  141. 		vectorsize = __n;

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

  143. 		t_sample * __out1 = __outs[0];

  144. 		if (__exception) { 

  145. 			return __exception;

  146. 			

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

  148. 			__exception = GENLIB_ERR_NULL_BUFFER;

  149. 			return __exception;

  150. 			

  151. 		};

  152. 		double mul_2327 = (m_resonance_13 * 0.125);

  153. 		double exp_2328 = exp(mul_2327);

  154. 		double mul_2326 = (exp_2328 * 0.882497);

  155. 		double mul_2322 = (mul_2326 * mul_2326);

  156. 		double expr_2437 = safediv(((m_cutoff_14 * 2) * 3.1415926535898), 44100);

  157. 		double cos_2325 = cos(expr_2437);

  158. 		double mul_2324 = (cos_2325 * mul_2326);

  159. 		double mul_2323 = (mul_2324 * -2);

  160. 		double add_2321 = ((mul_2323 + mul_2322) + 1);

  161. 		double mstosamps_2393 = (m_window_15 * (samplerate * 0.001));

  162. 		double mstosamps_2309 = (m_window_19 * (samplerate * 0.001));

  163. 		double rsub_2296 = (1 - m_ratio_20);

  164. 		double mul_2295 = (rsub_2296 * 1000);

  165. 		double div_2294 = safediv(mul_2295, m_window_19);

  166. 		samples_to_seconds = (1 / samplerate);

  167. 		double rsub_2380 = (1 - m_ratio_18);

  168. 		double mul_2379 = (rsub_2380 * 1000);

  169. 		double div_2378 = safediv(mul_2379, m_window_15);

  170. 		// the main sample loop;

  171. 		while ((__n--)) { 

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

  173. 			double noise_2247 = noise();

  174. 			double abs_2264 = fabs(noise_2247);

  175. 			double mul_2270 = (abs_2264 * m_blur_17);

  176. 			double noise_2246 = noise();

  177. 			double abs_2263 = fabs(noise_2246);

  178. 			double mul_2267 = (abs_2263 * m_blur_17);

  179. 			double noise_2330 = noise();

  180. 			double abs_2348 = fabs(noise_2330);

  181. 			double mul_2354 = (abs_2348 * m_blur_17);

  182. 			double noise_2332 = noise();

  183. 			double abs_2350 = fabs(noise_2332);

  184. 			double mul_2360 = (abs_2350 * m_blur_17);

  185. 			double noise_2249 = noise();

  186. 			double abs_2266 = fabs(noise_2249);

  187. 			double mul_2276 = (abs_2266 * m_blur_17);

  188. 			double noise_2248 = noise();

  189. 			double abs_2265 = fabs(noise_2248);

  190. 			double mul_2273 = (abs_2265 * m_blur_17);

  191. 			double noise_2331 = noise();

  192. 			double abs_2349 = fabs(noise_2331);

  193. 			double mul_2357 = (abs_2349 * m_blur_17);

  194. 			double noise_2329 = noise();

  195. 			double abs_2347 = fabs(noise_2329);

  196. 			double mul_2351 = (abs_2347 * m_blur_17);

  197. 			double mul_2318 = (mul_2322 * m_y_10);

  198. 			double mul_2319 = (mul_2323 * m_y_1);

  199. 			double phasor_2315 = m_phasor_21(div_2294, samples_to_seconds);

  200. 			double add_2293 = ((phasor_2315 + m_history_9) + 0.5);

  201. 			double mod_2292 = safemod(add_2293, 1);

  202. 			double delta_2272 = m_delta_22(mod_2292);

  203. 			double sah_2252 = m_sah_23(mul_2270, delta_2272, 0);

  204. 			double sah_2271 = m_sah_24(mstosamps_2309, delta_2272, 0);

  205. 			double mul_2260 = (sah_2271 * mod_2292);

  206. 			double sub_2291 = (mod_2292 - 0.5);

  207. 			double mul_2290 = (sub_2291 * 3.1415926535898);

  208. 			double cos_2289 = cos(mul_2290);

  209. 			double mul_2279 = (cos_2289 * cos_2289);

  210. 			double add_2287 = ((phasor_2315 + m_history_8) + 0.75);

  211. 			double mod_2286 = safemod(add_2287, 1);

  212. 			double delta_2269 = m_delta_25(mod_2286);

  213. 			double sah_2250 = m_sah_26(mul_2267, delta_2269, 0);

  214. 			double sah_2268 = m_sah_27(mstosamps_2309, delta_2269, 0);

  215. 			double mul_2259 = (sah_2268 * mod_2286);

  216. 			double sub_2285 = (mod_2286 - 0.5);

  217. 			double mul_2284 = (sub_2285 * 3.1415926535898);

  218. 			double cos_2283 = cos(mul_2284);

  219. 			double mul_2278 = (cos_2283 * cos_2283);

  220. 			double add_2314 = ((phasor_2315 + m_history_7) + 0);

  221. 			double mod_2313 = safemod(add_2314, 1);

  222. 			double delta_2257 = m_delta_28(mod_2313);

  223. 			double sah_2256 = m_sah_29(mul_2276, delta_2257, 0);

  224. 			double sah_2277 = m_sah_30(mstosamps_2309, delta_2257, 0);

  225. 			double mul_2262 = (sah_2277 * mod_2313);

  226. 			double sub_2312 = (mod_2313 - 0.5);

  227. 			double mul_2311 = (sub_2312 * 3.1415926535898);

  228. 			double cos_2310 = cos(mul_2311);

  229. 			double mul_2281 = (cos_2310 * cos_2310);

  230. 			double add_2308 = ((phasor_2315 + m_history_6) + 0.25);

  231. 			double mod_2307 = safemod(add_2308, 1);

  232. 			double delta_2275 = m_delta_31(mod_2307);

  233. 			double sah_2254 = m_sah_32(mul_2273, delta_2275, 0);

  234. 			double sah_2274 = m_sah_33(mstosamps_2309, delta_2275, 0);

  235. 			double mul_2261 = (sah_2274 * mod_2307);

  236. 			double tap_2300 = m_delay_12.read_linear(mul_2262);

  237. 			double tap_2301 = m_delay_12.read_linear(mul_2261);

  238. 			double tap_2302 = m_delay_12.read_linear(mul_2260);

  239. 			double tap_2303 = m_delay_12.read_linear(mul_2259);

  240. 			double mul_2282 = (tap_2303 * mul_2278);

  241. 			double mul_2288 = (tap_2302 * mul_2279);

  242. 			double mul_2298 = (tap_2300 * mul_2281);

  243. 			double sub_2306 = (mod_2307 - 0.5);

  244. 			double mul_2305 = (sub_2306 * 3.1415926535898);

  245. 			double cos_2304 = cos(mul_2305);

  246. 			double mul_2280 = (cos_2304 * cos_2304);

  247. 			double mul_2297 = (tap_2301 * mul_2280);

  248. 			double phasor_2399 = m_phasor_34(div_2378, samples_to_seconds);

  249. 			double add_2377 = ((m_history_5 + phasor_2399) + 0.5);

  250. 			double mod_2376 = safemod(add_2377, 1);

  251. 			double delta_2356 = m_delta_35(mod_2376);

  252. 			double sah_2335 = m_sah_36(mul_2354, delta_2356, 0);

  253. 			double sah_2355 = m_sah_37(mstosamps_2393, delta_2356, 0);

  254. 			double mul_2344 = (sah_2355 * mod_2376);

  255. 			double sub_2375 = (mod_2376 - 0.5);

  256. 			double mul_2374 = (sub_2375 * 3.1415926535898);

  257. 			double cos_2373 = cos(mul_2374);

  258. 			double mul_2363 = (cos_2373 * cos_2373);

  259. 			double add_2398 = ((m_history_4 + phasor_2399) + 0);

  260. 			double mod_2397 = safemod(add_2398, 1);

  261. 			double delta_2340 = m_delta_38(mod_2397);

  262. 			double sah_2339 = m_sah_39(mul_2360, delta_2340, 0);

  263. 			double sah_2361 = m_sah_40(mstosamps_2393, delta_2340, 0);

  264. 			double mul_2346 = (sah_2361 * mod_2397);

  265. 			double sub_2396 = (mod_2397 - 0.5);

  266. 			double mul_2395 = (sub_2396 * 3.1415926535898);

  267. 			double cos_2394 = cos(mul_2395);

  268. 			double mul_2365 = (cos_2394 * cos_2394);

  269. 			double add_2392 = ((m_history_3 + phasor_2399) + 0.25);

  270. 			double mod_2391 = safemod(add_2392, 1);

  271. 			double delta_2359 = m_delta_41(mod_2391);

  272. 			double sah_2337 = m_sah_42(mul_2357, delta_2359, 0);

  273. 			double sah_2358 = m_sah_43(mstosamps_2393, delta_2359, 0);

  274. 			double mul_2345 = (sah_2358 * mod_2391);

  275. 			double sub_2390 = (mod_2391 - 0.5);

  276. 			double mul_2389 = (sub_2390 * 3.1415926535898);

  277. 			double cos_2388 = cos(mul_2389);

  278. 			double mul_2364 = (cos_2388 * cos_2388);

  279. 			double add_2371 = ((m_history_2 + phasor_2399) + 0.75);

  280. 			double mod_2370 = safemod(add_2371, 1);

  281. 			double delta_2353 = m_delta_44(mod_2370);

  282. 			double sah_2333 = m_sah_45(mul_2351, delta_2353, 0);

  283. 			double sah_2352 = m_sah_46(mstosamps_2393, delta_2353, 0);

  284. 			double mul_2343 = (sah_2352 * mod_2370);

  285. 			double tap_2384 = m_delay_11.read_linear(mul_2346);

  286. 			double tap_2385 = m_delay_11.read_linear(mul_2345);

  287. 			double tap_2386 = m_delay_11.read_linear(mul_2344);

  288. 			double tap_2387 = m_delay_11.read_linear(mul_2343);

  289. 			double mul_2382 = (tap_2384 * mul_2365);

  290. 			double mul_2381 = (tap_2385 * mul_2364);

  291. 			double mul_2372 = (tap_2386 * mul_2363);

  292. 			double sub_2369 = (mod_2370 - 0.5);

  293. 			double mul_2368 = (sub_2369 * 3.1415926535898);

  294. 			double cos_2367 = cos(mul_2368);

  295. 			double mul_2362 = (cos_2367 * cos_2367);

  296. 			double mul_2366 = (tap_2387 * mul_2362);

  297. 			double mul_2320 = ((((((((mul_2298 + mul_2297) + mul_2288) + mul_2282) + mul_2366) + mul_2372) + mul_2381) + mul_2382) * add_2321);

  298. 			double sub_2317 = (mul_2320 - (mul_2319 + mul_2318));

  299. 			double mix_2450 = (in1 + (m_mix_16 * (sub_2317 - in1)));

  300. 			double out1 = mix_2450;

  301. 			double y2_next_2440 = m_y_1;

  302. 			double history_2253_next_2441 = sah_2252;

  303. 			double history_2251_next_2442 = sah_2250;

  304. 			double history_2258_next_2443 = sah_2256;

  305. 			double history_2255_next_2444 = sah_2254;

  306. 			double history_2336_next_2445 = sah_2335;

  307. 			double history_2341_next_2446 = sah_2339;

  308. 			double history_2338_next_2447 = sah_2337;

  309. 			double history_2334_next_2448 = sah_2333;

  310. 			double y1_next_2449 = sub_2317;

  311. 			m_delay_12.write(in1);

  312. 			m_delay_11.write(in1);

  313. 			m_y_10 = y2_next_2440;

  314. 			m_history_9 = history_2253_next_2441;

  315. 			m_history_8 = history_2251_next_2442;

  316. 			m_history_7 = history_2258_next_2443;

  317. 			m_history_6 = history_2255_next_2444;

  318. 			m_history_5 = history_2336_next_2445;

  319. 			m_history_4 = history_2341_next_2446;

  320. 			m_history_3 = history_2338_next_2447;

  321. 			m_history_2 = history_2334_next_2448;

  322. 			m_y_1 = y1_next_2449;

  323. 			m_delay_11.step();

  324. 			m_delay_12.step();

  325. 			// assign results to output buffer;

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

  327. 			

  328. 		};

  329. 		return __exception;

  330. 		

  331. 	};

  332. 	inline void set_resonance(double _value) {

  333. 		m_resonance_13 = (_value < 0 ? 0 : (_value > 0.25 ? 0.25 : _value));

  334. 	};

  335. 	inline void set_cutoff(double _value) {

  336. 		m_cutoff_14 = (_value < 0 ? 0 : (_value > 3000 ? 3000 : _value));

  337. 	};

  338. 	inline void set_window1(double _value) {

  339. 		m_window_15 = (_value < 0.1 ? 0.1 : (_value > 1000 ? 1000 : _value));

  340. 	};

  341. 	inline void set_mix(double _value) {

  342. 		m_mix_16 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  343. 	};

  344. 	inline void set_blur(double _value) {

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

  346. 	};

  347. 	inline void set_ratio1(double _value) {

  348. 		m_ratio_18 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  349. 	};

  350. 	inline void set_window2(double _value) {

  351. 		m_window_19 = (_value < 0.1 ? 0.1 : (_value > 1000 ? 1000 : _value));

  352. 	};

  353. 	inline void set_ratio2(double _value) {

  354. 		m_ratio_20 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  355. 	};

  356. 	

  357. } State;

  358. 

  359. 

  360. /// 

  361. ///	Configuration for the genlib API

  362. ///

  363. 

  364. /// Number of signal inputs and outputs 

  365. 

  366. int gen_kernel_numins = 1;

  367. int gen_kernel_numouts = 1;

  368. 

  369. int num_inputs() { return gen_kernel_numins; }

  370. int num_outputs() { return gen_kernel_numouts; }

  371. int num_params() { return 8; }

  372. 

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

  374. 

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

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

  377. 

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

  379. 

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

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

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

  383. }

  384. 

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

  386. 

  387. void reset(CommonState *cself) { 

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

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

  390. }

  391. 

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

  393. 

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

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

  396. 	switch (index) {

  397. 		case 0: self->set_resonance(value); break;

  398. 		case 1: self->set_cutoff(value); break;

  399. 		case 2: self->set_window1(value); break;

  400. 		case 3: self->set_mix(value); break;

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

  402. 		case 5: self->set_ratio1(value); break;

  403. 		case 6: self->set_window2(value); break;

  404. 		case 7: self->set_ratio2(value); break;

  405. 		

  406. 		default: break;

  407. 	}

  408. }

  409. 

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

  411. 

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

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

  414. 	switch (index) {

  415. 		case 0: *value = self->m_resonance_13; break;

  416. 		case 1: *value = self->m_cutoff_14; break;

  417. 		case 2: *value = self->m_window_15; break;

  418. 		case 3: *value = self->m_mix_16; break;

  419. 		case 4: *value = self->m_blur_17; break;

  420. 		case 5: *value = self->m_ratio_18; break;

  421. 		case 6: *value = self->m_window_19; break;

  422. 		case 7: *value = self->m_ratio_20; break;

  423. 		

  424. 		default: break;

  425. 	}

  426. }

  427. 

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

  429. 

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

  431. 	State *self = new State;

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

  433. 	ParamInfo *pi;

  434. 	self->__commonstate.inputnames = gen_kernel_innames;

  435. 	self->__commonstate.outputnames = gen_kernel_outnames;

  436. 	self->__commonstate.numins = gen_kernel_numins;

  437. 	self->__commonstate.numouts = gen_kernel_numouts;

  438. 	self->__commonstate.sr = sr;

  439. 	self->__commonstate.vs = vs;

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

  441. 	self->__commonstate.numparams = 8;

  442. 	// initialize parameter 0 ("m_resonance_13")

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

  444. 	pi->name = "resonance";

  445. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  446. 	pi->defaultvalue = self->m_resonance_13;

  447. 	pi->defaultref = 0;

  448. 	pi->hasinputminmax = false;

  449. 	pi->inputmin = 0; 

  450. 	pi->inputmax = 1;

  451. 	pi->hasminmax = true;

  452. 	pi->outputmin = 0;

  453. 	pi->outputmax = 0.25;

  454. 	pi->exp = 0;

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

  456. 	// initialize parameter 1 ("m_cutoff_14")

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

  458. 	pi->name = "cutoff";

  459. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  460. 	pi->defaultvalue = self->m_cutoff_14;

  461. 	pi->defaultref = 0;

  462. 	pi->hasinputminmax = false;

  463. 	pi->inputmin = 0; 

  464. 	pi->inputmax = 1;

  465. 	pi->hasminmax = true;

  466. 	pi->outputmin = 0;

  467. 	pi->outputmax = 3000;

  468. 	pi->exp = 0;

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

  470. 	// initialize parameter 2 ("m_window_15")

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

  472. 	pi->name = "window1";

  473. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  474. 	pi->defaultvalue = self->m_window_15;

  475. 	pi->defaultref = 0;

  476. 	pi->hasinputminmax = false;

  477. 	pi->inputmin = 0; 

  478. 	pi->inputmax = 1;

  479. 	pi->hasminmax = true;

  480. 	pi->outputmin = 0.1;

  481. 	pi->outputmax = 1000;

  482. 	pi->exp = 0;

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

  484. 	// initialize parameter 3 ("m_mix_16")

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

  486. 	pi->name = "mix";

  487. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  488. 	pi->defaultvalue = self->m_mix_16;

  489. 	pi->defaultref = 0;

  490. 	pi->hasinputminmax = false;

  491. 	pi->inputmin = 0; 

  492. 	pi->inputmax = 1;

  493. 	pi->hasminmax = true;

  494. 	pi->outputmin = 0;

  495. 	pi->outputmax = 1;

  496. 	pi->exp = 0;

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

  498. 	// initialize parameter 4 ("m_blur_17")

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

  500. 	pi->name = "blur";

  501. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  503. 	pi->defaultref = 0;

  504. 	pi->hasinputminmax = false;

  505. 	pi->inputmin = 0; 

  506. 	pi->inputmax = 1;

  507. 	pi->hasminmax = true;

  508. 	pi->outputmin = 0.01;

  509. 	pi->outputmax = 0.25;

  510. 	pi->exp = 0;

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

  512. 	// initialize parameter 5 ("m_ratio_18")

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

  514. 	pi->name = "ratio1";

  515. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  516. 	pi->defaultvalue = self->m_ratio_18;

  517. 	pi->defaultref = 0;

  518. 	pi->hasinputminmax = false;

  519. 	pi->inputmin = 0; 

  520. 	pi->inputmax = 1;

  521. 	pi->hasminmax = true;

  522. 	pi->outputmin = 0.5;

  523. 	pi->outputmax = 2;

  524. 	pi->exp = 0;

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

  526. 	// initialize parameter 6 ("m_window_19")

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

  528. 	pi->name = "window2";

  529. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  530. 	pi->defaultvalue = self->m_window_19;

  531. 	pi->defaultref = 0;

  532. 	pi->hasinputminmax = false;

  533. 	pi->inputmin = 0; 

  534. 	pi->inputmax = 1;

  535. 	pi->hasminmax = true;

  536. 	pi->outputmin = 0.1;

  537. 	pi->outputmax = 1000;

  538. 	pi->exp = 0;

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

  540. 	// initialize parameter 7 ("m_ratio_20")

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

  542. 	pi->name = "ratio2";

  543. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  544. 	pi->defaultvalue = self->m_ratio_20;

  545. 	pi->defaultref = 0;

  546. 	pi->hasinputminmax = false;

  547. 	pi->inputmin = 0; 

  548. 	pi->inputmax = 1;

  549. 	pi->hasminmax = true;

  550. 	pi->outputmin = 0.5;

  551. 	pi->outputmax = 2;

  552. 	pi->exp = 0;

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

  554. 	

  555. 	return self;

  556. }

  557. 

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

  559. 

  560. void destroy(CommonState *cself) { 

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

  562. 	genlib_sysmem_freeptr(cself->params);

  563. 		

  564. 	delete self; 

  565. }

  566. 

  567. 

  568. } // gen_exported::