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

538 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_11;

  35. 	Delay m_delay_9;

  36. 	Delay m_delay_8;

  37. 	Delay m_delay_7;

  38. 	Delay m_delay_10;

  39. 	Delay m_delay_12;

  40. 	Delay m_delay_16;

  41. 	Delay m_delay_13;

  42. 	Delay m_delay_14;

  43. 	Delay m_delay_6;

  44. 	Delay m_delay_15;

  45. 	Delay m_delay_17;

  46. 	double m_bandwidth_22;

  47. 	double m_tail_23;

  48. 	double m_spread_21;

  49. 	double m_revtime_19;

  50. 	double m_roomsize_20;

  51. 	double m_damping_18;

  52. 	double m_early_25;

  53. 	double m_history_5;

  54. 	double m_dry_24;

  55. 	double samplerate;

  56. 	double m_history_2;

  57. 	double m_history_1;

  58. 	double m_history_4;

  59. 	double m_history_3;

  60. 	int vectorsize;

  61. 	int __exception;

  62. 	// re-initialize all member variables;

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

  64. 		__exception = 0;

  65. 		vectorsize = __vs;

  66. 		samplerate = __sr;

  67. 		m_history_1 = 0;

  68. 		m_history_2 = 0;

  69. 		m_history_3 = 0;

  70. 		m_history_4 = 0;

  71. 		m_history_5 = 0;

  72. 		m_delay_6.reset("m_delay_6", 5000);

  73. 		m_delay_7.reset("m_delay_7", 7000);

  74. 		m_delay_8.reset("m_delay_8", 15000);

  75. 		m_delay_9.reset("m_delay_9", 6000);

  76. 		m_delay_10.reset("m_delay_10", 16000);

  77. 		m_delay_11.reset("m_delay_11", 48000);

  78. 		m_delay_12.reset("m_delay_12", 10000);

  79. 		m_delay_13.reset("m_delay_13", 12000);

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

  81. 		m_delay_15.reset("m_delay_15", 48000);

  82. 		m_delay_16.reset("m_delay_16", 48000);

  83. 		m_delay_17.reset("m_delay_17", 48000);

  84. 		m_damping_18 = 0.7;

  85. 		m_revtime_19 = 11;

  86. 		m_roomsize_20 = 75;

  87. 		m_spread_21 = 23;

  88. 		m_bandwidth_22 = 0.5;

  89. 		m_tail_23 = 0.25;

  90. 		m_dry_24 = 1;

  91. 		m_early_25 = 0.25;

  92. 		genlib_reset_complete(this);

  93. 		

  94. 	};

  95. 	// the signal processing routine;

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

  97. 		vectorsize = __n;

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

  99. 		const t_sample * __in2 = __ins[1];

  100. 		t_sample * __out1 = __outs[0];

  101. 		t_sample * __out2 = __outs[1];

  102. 		if (__exception) { 

  103. 			return __exception;

  104. 			

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

  106. 			__exception = GENLIB_ERR_NULL_BUFFER;

  107. 			return __exception;

  108. 			

  109. 		};

  110. 		double rsub_999 = (1 - m_bandwidth_22);

  111. 		double expr_1051 = safepow(0.001, safediv(1, (m_revtime_19 * 44100)));

  112. 		double expr_1052 = safediv((m_roomsize_20 * 44100), 340);

  113. 		double mul_988 = (expr_1052 * 0.63245);

  114. 		double expr_1043 = (-safepow(expr_1051, mul_988));

  115. 		double mul_990 = (expr_1052 * 0.81649);

  116. 		double expr_1045 = (-safepow(expr_1051, mul_990));

  117. 		double mul_989 = (expr_1052 * 0.7071);

  118. 		double expr_1044 = (-safepow(expr_1051, mul_989));

  119. 		double mul_991 = (expr_1052 * 1);

  120. 		double expr_1050 = (-safepow(expr_1051, mul_991));

  121. 		double mul_985 = (expr_1052 * 0.000527);

  122. 		int int_984 = int(mul_985);

  123. 		double mul_925 = (m_spread_21 * -0.380445);

  124. 		double add_924 = (mul_925 + 931);

  125. 		double rsub_921 = (1341 - add_924);

  126. 		double mul_934 = (int_984 * rsub_921);

  127. 		double mul_953 = (m_spread_21 * 0.376623);

  128. 		double add_952 = (mul_953 + 931);

  129. 		double rsub_949 = (1341 - add_952);

  130. 		double mul_960 = (int_984 * rsub_949);

  131. 		double add_914 = (expr_1052 + 5);

  132. 		double expr_1046 = safepow(expr_1051, add_914);

  133. 		double mul_920 = (expr_1052 * 0.41);

  134. 		double add_917 = (mul_920 + 5);

  135. 		double expr_1049 = safepow(expr_1051, add_917);

  136. 		double mul_919 = (expr_1052 * 0.3);

  137. 		double add_916 = (mul_919 + 5);

  138. 		double expr_1048 = safepow(expr_1051, add_916);

  139. 		double mul_918 = (expr_1052 * 0.155);

  140. 		double add_915 = (mul_918 + 5);

  141. 		double expr_1047 = safepow(expr_1051, add_915);

  142. 		double mul_927 = (m_spread_21 * -0.568366);

  143. 		double add_923 = (mul_927 + 369);

  144. 		double rsub_922 = (add_924 - add_923);

  145. 		double mul_941 = (int_984 * rsub_922);

  146. 		double mul_983 = (expr_1052 * 0.110732);

  147. 		double mul_969 = (m_spread_21 * 0.125541);

  148. 		double add_951 = (mul_969 + 369);

  149. 		double rsub_950 = (add_952 - add_951);

  150. 		double mul_967 = (int_984 * rsub_950);

  151. 		double add_926 = (mul_927 + 159);

  152. 		double mul_948 = (int_984 * add_926);

  153. 		double add_968 = (mul_969 + 159);

  154. 		double mul_976 = (int_984 * add_968);

  155. 		// the main sample loop;

  156. 		while ((__n--)) { 

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

  158. 			const double in2 = (*(__in2++));

  159. 			double mul_846 = (in2 * m_dry_24);

  160. 			double mul_858 = (in1 * m_dry_24);

  161. 			double mul_848 = ((in1 + in2) * 0.707);

  162. 			double mix_1070 = (mul_848 + (rsub_999 * (m_history_5 - mul_848)));

  163. 			double mix_998 = mix_1070;

  164. 			double tap_888 = m_delay_17.read_linear(mul_988);

  165. 			double mul_884 = (tap_888 * expr_1043);

  166. 			double mix_1071 = (mul_884 + (m_damping_18 * (m_history_4 - mul_884)));

  167. 			double mix_886 = mix_1071;

  168. 			double tap_900 = m_delay_16.read_linear(mul_990);

  169. 			double mul_896 = (tap_900 * expr_1045);

  170. 			double mix_1072 = (mul_896 + (m_damping_18 * (m_history_3 - mul_896)));

  171. 			double mix_898 = mix_1072;

  172. 			double tap_894 = m_delay_15.read_linear(mul_989);

  173. 			double mul_890 = (tap_894 * expr_1044);

  174. 			double mix_1073 = (mul_890 + (m_damping_18 * (m_history_2 - mul_890)));

  175. 			double mix_892 = mix_1073;

  176. 			double tap_996 = m_delay_14.read_linear(mul_991);

  177. 			double mul_987 = (tap_996 * expr_1050);

  178. 			double mix_1074 = (mul_987 + (m_damping_18 * (m_history_1 - mul_987)));

  179. 			double mix_994 = mix_1074;

  180. 			double tap_933 = m_delay_13.read_linear(mul_934);

  181. 			double mul_931 = (tap_933 * 0.625);

  182. 			double tap_959 = m_delay_12.read_linear(mul_960);

  183. 			double mul_957 = (tap_959 * 0.625);

  184. 			double add_878 = (mix_994 + mix_898);

  185. 			double add_876 = (mix_892 + mix_886);

  186. 			double add_871 = (add_878 + add_876);

  187. 			double mul_854 = (add_871 * 0.5);

  188. 			double sub_875 = (add_878 - add_876);

  189. 			double mul_857 = (sub_875 * 0.5);

  190. 			double sub_877 = (mix_994 - mix_898);

  191. 			double sub_874 = (mix_892 - mix_886);

  192. 			double sub_873 = (sub_877 - sub_874);

  193. 			double mul_856 = (sub_873 * 0.5);

  194. 			double add_872 = (sub_877 + sub_874);

  195. 			double rsub_870 = (0 - add_872);

  196. 			double mul_855 = (rsub_870 * 0.5);

  197. 			double tap_902 = m_delay_11.read_linear(add_917);

  198. 			double tap_903 = m_delay_11.read_linear(add_916);

  199. 			double tap_904 = m_delay_11.read_linear(add_915);

  200. 			double tap_905 = m_delay_11.read_linear(add_914);

  201. 			double mul_906 = (tap_905 * expr_1046);

  202. 			double add_879 = (mul_854 + mul_906);

  203. 			double mul_910 = (tap_903 * expr_1048);

  204. 			double add_881 = (mul_856 + mul_910);

  205. 			double mul_912 = (tap_902 * expr_1049);

  206. 			double add_882 = (mul_857 + mul_912);

  207. 			double mul_908 = (tap_904 * expr_1047);

  208. 			double add_880 = (mul_855 + mul_908);

  209. 			double tap_940 = m_delay_10.read_linear(mul_941);

  210. 			double mul_938 = (tap_940 * 0.625);

  211. 			double tap_982 = m_delay_9.read_linear(mul_983);

  212. 			double tap_966 = m_delay_8.read_linear(mul_967);

  213. 			double mul_964 = (tap_966 * 0.625);

  214. 			double tap_947 = m_delay_7.read_linear(mul_948);

  215. 			double mul_945 = (tap_947 * 0.75);

  216. 			double mul_980 = (tap_982 * 0.75);

  217. 			double sub_979 = (mix_998 - mul_980);

  218. 			double mul_978 = (sub_979 * 0.75);

  219. 			double add_977 = (mul_978 + tap_982);

  220. 			double tap_975 = m_delay_6.read_linear(mul_976);

  221. 			double mul_973 = (tap_975 * 0.75);

  222. 			double mul_869 = (mul_857 * m_tail_23);

  223. 			double mul_867 = (mul_855 * m_tail_23);

  224. 			double add_853 = (mul_869 + mul_867);

  225. 			double mul_868 = (mul_856 * m_tail_23);

  226. 			double mul_866 = (mul_854 * m_tail_23);

  227. 			double add_852 = (mul_868 + mul_866);

  228. 			double sub_861 = (add_853 - add_852);

  229. 			double mul_865 = (mul_912 * m_early_25);

  230. 			double mul_863 = (mul_908 * m_early_25);

  231. 			double add_851 = (mul_865 + mul_863);

  232. 			double mul_864 = (mul_910 * m_early_25);

  233. 			double mul_862 = (mul_906 * m_early_25);

  234. 			double add_850 = (mul_864 + mul_862);

  235. 			double sub_860 = (add_851 - add_850);

  236. 			double add_847 = (sub_861 + sub_860);

  237. 			double add_849 = (add_847 + in2);

  238. 			double sub_944 = (add_849 - mul_945);

  239. 			double mul_943 = (sub_944 * 0.75);

  240. 			double add_942 = (mul_943 + tap_947);

  241. 			double sub_937 = (add_942 - mul_938);

  242. 			double mul_936 = (sub_937 * 0.625);

  243. 			double add_935 = (mul_936 + tap_940);

  244. 			double sub_930 = (add_935 - mul_931);

  245. 			double mul_929 = (sub_930 * 0.625);

  246. 			double add_928 = (mul_929 + tap_933);

  247. 			double out2 = (mul_846 + add_928);

  248. 			double add_859 = (add_847 + in1);

  249. 			double sub_972 = (add_859 - mul_973);

  250. 			double mul_971 = (sub_972 * 0.75);

  251. 			double add_970 = (mul_971 + tap_975);

  252. 			double sub_963 = (add_970 - mul_964);

  253. 			double mul_962 = (sub_963 * 0.625);

  254. 			double add_961 = (mul_962 + tap_966);

  255. 			double sub_956 = (add_961 - mul_957);

  256. 			double mul_955 = (sub_956 * 0.625);

  257. 			double add_954 = (mul_955 + tap_959);

  258. 			double out1 = (mul_858 + add_954);

  259. 			double history_997_next_1065 = mix_998;

  260. 			double history_885_next_1066 = mix_886;

  261. 			double history_897_next_1067 = mix_898;

  262. 			double history_891_next_1068 = mix_892;

  263. 			double history_993_next_1069 = mix_994;

  264. 			m_delay_17.write(add_879);

  265. 			m_delay_16.write(add_881);

  266. 			m_delay_15.write(add_880);

  267. 			m_delay_14.write(add_882);

  268. 			m_delay_13.write(sub_930);

  269. 			m_delay_12.write(sub_956);

  270. 			m_delay_11.write(add_977);

  271. 			m_delay_10.write(sub_937);

  272. 			m_delay_9.write(sub_979);

  273. 			m_delay_8.write(sub_963);

  274. 			m_delay_7.write(sub_944);

  275. 			m_delay_6.write(sub_972);

  276. 			m_history_5 = history_997_next_1065;

  277. 			m_history_4 = history_885_next_1066;

  278. 			m_history_3 = history_897_next_1067;

  279. 			m_history_2 = history_891_next_1068;

  280. 			m_history_1 = history_993_next_1069;

  281. 			m_delay_6.step();

  282. 			m_delay_7.step();

  283. 			m_delay_8.step();

  284. 			m_delay_9.step();

  285. 			m_delay_10.step();

  286. 			m_delay_11.step();

  287. 			m_delay_12.step();

  288. 			m_delay_13.step();

  289. 			m_delay_14.step();

  290. 			m_delay_15.step();

  291. 			m_delay_16.step();

  292. 			m_delay_17.step();

  293. 			// assign results to output buffer;

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

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

  296. 			

  297. 		};

  298. 		return __exception;

  299. 		

  300. 	};

  301. 	inline void set_damping(double _value) {

  302. 		m_damping_18 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  303. 	};

  304. 	inline void set_revtime(double _value) {

  305. 		m_revtime_19 = (_value < 0.1 ? 0.1 : (_value > 360 ? 360 : _value));

  306. 	};

  307. 	inline void set_roomsize(double _value) {

  308. 		m_roomsize_20 = (_value < 0.1 ? 0.1 : (_value > 300 ? 300 : _value));

  309. 	};

  310. 	inline void set_spread(double _value) {

  311. 		m_spread_21 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  312. 	};

  313. 	inline void set_bandwidth(double _value) {

  314. 		m_bandwidth_22 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  315. 	};

  316. 	inline void set_tail(double _value) {

  317. 		m_tail_23 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  318. 	};

  319. 	inline void set_dry(double _value) {

  320. 		m_dry_24 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  321. 	};

  322. 	inline void set_early(double _value) {

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

  324. 	};

  325. 	

  326. } State;

  327. 

  328. 

  329. /// 

  330. ///	Configuration for the genlib API

  331. ///

  332. 

  333. /// Number of signal inputs and outputs 

  334. 

  335. const int gen_kernel_numins = 2;

  336. const int gen_kernel_numouts = 2;

  337. 

  338. int num_inputs() { return gen_kernel_numins; }

  339. int num_outputs() { return gen_kernel_numouts; }

  340. int num_params() { return 8; }

  341. 

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

  343. 

  344. const char * gen_kernel_innames[] = { "in1", "in2" };

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

  346. 

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

  348. 

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

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

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

  352. }

  353. 

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

  355. 

  356. void reset(CommonState *cself) { 

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

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

  359. }

  360. 

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

  362. 

  363. void setparameter(CommonState *cself, long index, t_param value, void *ref) {

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

  365. 	switch (index) {

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

  367. 		case 1: self->set_revtime(value); break;

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

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

  370. 		case 4: self->set_bandwidth(value); break;

  371. 		case 5: self->set_tail(value); break;

  372. 		case 6: self->set_dry(value); break;

  373. 		case 7: self->set_early(value); break;

  374. 		

  375. 		default: break;

  376. 	}

  377. }

  378. 

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

  380. 

  381. void getparameter(CommonState *cself, long index, t_param *value) {

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

  383. 	switch (index) {

  384. 		case 0: *value = self->m_damping_18; break;

  385. 		case 1: *value = self->m_revtime_19; break;

  386. 		case 2: *value = self->m_roomsize_20; break;

  387. 		case 3: *value = self->m_spread_21; break;

  388. 		case 4: *value = self->m_bandwidth_22; break;

  389. 		case 5: *value = self->m_tail_23; break;

  390. 		case 6: *value = self->m_dry_24; break;

  391. 		case 7: *value = self->m_early_25; break;

  392. 		

  393. 		default: break;

  394. 	}

  395. }

  396. 

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

  398. 

  399. void * create(t_param sr, long vs) {

  400. 	State *self = new State;

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

  402. 	ParamInfo *pi;

  403. 	self->__commonstate.inputnames = gen_kernel_innames;

  404. 	self->__commonstate.outputnames = gen_kernel_outnames;

  405. 	self->__commonstate.numins = gen_kernel_numins;

  406. 	self->__commonstate.numouts = gen_kernel_numouts;

  407. 	self->__commonstate.sr = sr;

  408. 	self->__commonstate.vs = vs;

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

  410. 	self->__commonstate.numparams = 8;

  411. 	// initialize parameter 0 ("m_damping_18")

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

  413. 	pi->name = "damping";

  414. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  415. 	pi->defaultvalue = self->m_damping_18;

  416. 	pi->defaultref = 0;

  417. 	pi->hasinputminmax = false;

  418. 	pi->inputmin = 0; 

  419. 	pi->inputmax = 1;

  420. 	pi->hasminmax = true;

  421. 	pi->outputmin = 0;

  422. 	pi->outputmax = 1;

  423. 	pi->exp = 0;

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

  425. 	// initialize parameter 1 ("m_revtime_19")

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

  427. 	pi->name = "revtime";

  428. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  429. 	pi->defaultvalue = self->m_revtime_19;

  430. 	pi->defaultref = 0;

  431. 	pi->hasinputminmax = false;

  432. 	pi->inputmin = 0; 

  433. 	pi->inputmax = 1;

  434. 	pi->hasminmax = true;

  435. 	pi->outputmin = 0.1;

  436. 	pi->outputmax = 360;

  437. 	pi->exp = 0;

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

  439. 	// initialize parameter 2 ("m_roomsize_20")

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

  441. 	pi->name = "roomsize";

  442. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  443. 	pi->defaultvalue = self->m_roomsize_20;

  444. 	pi->defaultref = 0;

  445. 	pi->hasinputminmax = false;

  446. 	pi->inputmin = 0; 

  447. 	pi->inputmax = 1;

  448. 	pi->hasminmax = true;

  449. 	pi->outputmin = 0.1;

  450. 	pi->outputmax = 300;

  451. 	pi->exp = 0;

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

  453. 	// initialize parameter 3 ("m_spread_21")

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

  455. 	pi->name = "spread";

  456. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  457. 	pi->defaultvalue = self->m_spread_21;

  458. 	pi->defaultref = 0;

  459. 	pi->hasinputminmax = false;

  460. 	pi->inputmin = 0; 

  461. 	pi->inputmax = 1;

  462. 	pi->hasminmax = true;

  463. 	pi->outputmin = 0;

  464. 	pi->outputmax = 100;

  465. 	pi->exp = 0;

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

  467. 	// initialize parameter 4 ("m_bandwidth_22")

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

  469. 	pi->name = "bandwidth";

  470. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  471. 	pi->defaultvalue = self->m_bandwidth_22;

  472. 	pi->defaultref = 0;

  473. 	pi->hasinputminmax = false;

  474. 	pi->inputmin = 0; 

  475. 	pi->inputmax = 1;

  476. 	pi->hasminmax = true;

  477. 	pi->outputmin = 0;

  478. 	pi->outputmax = 1;

  479. 	pi->exp = 0;

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

  481. 	// initialize parameter 5 ("m_tail_23")

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

  483. 	pi->name = "tail";

  484. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  485. 	pi->defaultvalue = self->m_tail_23;

  486. 	pi->defaultref = 0;

  487. 	pi->hasinputminmax = false;

  488. 	pi->inputmin = 0; 

  489. 	pi->inputmax = 1;

  490. 	pi->hasminmax = true;

  491. 	pi->outputmin = 0;

  492. 	pi->outputmax = 1;

  493. 	pi->exp = 0;

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

  495. 	// initialize parameter 6 ("m_dry_24")

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

  497. 	pi->name = "dry";

  498. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  499. 	pi->defaultvalue = self->m_dry_24;

  500. 	pi->defaultref = 0;

  501. 	pi->hasinputminmax = false;

  502. 	pi->inputmin = 0; 

  503. 	pi->inputmax = 1;

  504. 	pi->hasminmax = true;

  505. 	pi->outputmin = 0;

  506. 	pi->outputmax = 1;

  507. 	pi->exp = 0;

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

  509. 	// initialize parameter 7 ("m_early_25")

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

  511. 	pi->name = "early";

  512. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  513. 	pi->defaultvalue = self->m_early_25;

  514. 	pi->defaultref = 0;

  515. 	pi->hasinputminmax = false;

  516. 	pi->inputmin = 0; 

  517. 	pi->inputmax = 1;

  518. 	pi->hasminmax = true;

  519. 	pi->outputmin = 0;

  520. 	pi->outputmax = 1;

  521. 	pi->exp = 0;

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

  523. 	

  524. 	return self;

  525. }

  526. 

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

  528. 

  529. void destroy(CommonState *cself) { 

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

  531. 	genlib_sysmem_freeptr(cself->params);

  532. 		

  533. 	delete self; 

  534. }

  535. 

  536. 

  537. } // gen_exported::