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.
38 Commits
1 Branch
97MB
Tree: 0d94e8c3bc
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0d94e8c3bc'
${ noResults }
DPF-Plugins/plugins/shiroverb/gen_exported.cpp

767 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_14;

  35. 	Delay m_delay_11;

  36. 	Delay m_delay_18;

  37. 	Delay m_delay_15;

  38. 	Delay m_delay_12;

  39. 	Delay m_delay_17;

  40. 	Delay m_delay_13;

  41. 	Delay m_delay_20;

  42. 	Delay m_delay_19;

  43. 	Delay m_delay_21;

  44. 	Delay m_delay_23;

  45. 	Delay m_delay_22;

  46. 	Delay m_delay_16;

  47. 	Delta m_delta_41;

  48. 	Delta m_delta_47;

  49. 	Delta m_delta_44;

  50. 	Delta m_delta_38;

  51. 	Phasor m_phasor_37;

  52. 	Sah m_sah_48;

  53. 	Sah m_sah_49;

  54. 	Sah m_sah_46;

  55. 	Sah m_sah_45;

  56. 	Sah m_sah_42;

  57. 	Sah m_sah_43;

  58. 	Sah m_sah_40;

  59. 	Sah m_sah_39;

  60. 	double m_cutoff_34;

  61. 	double m_tail_33;

  62. 	double m_early_35;

  63. 	double samples_to_seconds;

  64. 	double m_tone_32;

  65. 	double m_mix_36;

  66. 	double m_spread_31;

  67. 	double m_ratio_24;

  68. 	double m_roomsize_29;

  69. 	double m_history_4;

  70. 	double m_history_5;

  71. 	double m_damping_30;

  72. 	double m_history_3;

  73. 	double m_history_1;

  74. 	double m_y_2;

  75. 	double samplerate;

  76. 	double m_history_7;

  77. 	double m_history_6;

  78. 	double m_history_9;

  79. 	double m_history_8;

  80. 	double m_blur_28;

  81. 	double m_decay_26;

  82. 	double m_shimmer_27;

  83. 	double m_history_10;

  84. 	double m_window_25;

  85. 	int vectorsize;

  86. 	int __exception;

  87. 	// re-initialize all member variables;

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

  89. 		__exception = 0;

  90. 		vectorsize = __vs;

  91. 		samplerate = __sr;

  92. 		m_history_1 = 0;

  93. 		m_y_2 = 0;

  94. 		m_history_3 = 0;

  95. 		m_history_4 = 0;

  96. 		m_history_5 = 0;

  97. 		m_history_6 = 0;

  98. 		m_history_7 = 0;

  99. 		m_history_8 = 0;

  100. 		m_history_9 = 0;

  101. 		m_history_10 = 0;

  102. 		m_delay_11.reset("m_delay_11", 5000);

  103. 		m_delay_12.reset("m_delay_12", 7000);

  104. 		m_delay_13.reset("m_delay_13", 15000);

  105. 		m_delay_14.reset("m_delay_14", 16000);

  106. 		m_delay_15.reset("m_delay_15", 6000);

  107. 		m_delay_16.reset("m_delay_16", 96000);

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

  109. 		m_delay_18.reset("m_delay_18", 10000);

  110. 		m_delay_19.reset("m_delay_19", 12000);

  111. 		m_delay_20.reset("m_delay_20", 48000);

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

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

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

  115. 		m_ratio_24 = 2;

  116. 		m_window_25 = 100;

  117. 		m_decay_26 = 180;

  118. 		m_shimmer_27 = 0.5;

  119. 		m_blur_28 = 0.25;

  120. 		m_roomsize_29 = 150;

  121. 		m_damping_30 = 0.75;

  122. 		m_spread_31 = 25;

  123. 		m_tone_32 = 0.5;

  124. 		m_tail_33 = 0.25;

  125. 		m_cutoff_34 = 3000;

  126. 		m_early_35 = 0.25;

  127. 		m_mix_36 = 0.5;

  128. 		samples_to_seconds = (1 / samplerate);

  129. 		m_phasor_37.reset(0);

  130. 		m_delta_38.reset(0);

  131. 		m_sah_39.reset(0);

  132. 		m_sah_40.reset(0);

  133. 		m_delta_41.reset(0);

  134. 		m_sah_42.reset(0);

  135. 		m_sah_43.reset(0);

  136. 		m_delta_44.reset(0);

  137. 		m_sah_45.reset(0);

  138. 		m_sah_46.reset(0);

  139. 		m_delta_47.reset(0);

  140. 		m_sah_48.reset(0);

  141. 		m_sah_49.reset(0);

  142. 		genlib_reset_complete(this);

  143. 		

  144. 	};

  145. 	// the signal processing routine;

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

  147. 		vectorsize = __n;

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

  149. 		t_sample * __out1 = __outs[0];

  150. 		t_sample * __out2 = __outs[1];

  151. 		if (__exception) { 

  152. 			return __exception;

  153. 			

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

  155. 			__exception = GENLIB_ERR_NULL_BUFFER;

  156. 			return __exception;

  157. 			

  158. 		};

  159. 		double rsub_5405 = (1 - m_tone_32);

  160. 		double expr_5416 = safepow(0.001, safediv(1, (m_decay_26 * 44100)));

  161. 		double expr_5407 = safediv(((m_cutoff_34 * 2) * 3.1415926535898), 44100);

  162. 		double sin_5179 = sin(expr_5407);

  163. 		double clamp_5180 = ((sin_5179 <= 1e-05) ? 1e-05 : ((sin_5179 >= 0.99999) ? 0.99999 : sin_5179));

  164. 		double expr_5417 = safediv((m_roomsize_29 * 44100), 340);

  165. 		double mul_5394 = (expr_5417 * 0.63245);

  166. 		double expr_5408 = (-safepow(expr_5416, mul_5394));

  167. 		double mul_5397 = (expr_5417 * 1);

  168. 		double expr_5415 = (-safepow(expr_5416, mul_5397));

  169. 		double mul_5395 = (expr_5417 * 0.7071);

  170. 		double expr_5409 = (-safepow(expr_5416, mul_5395));

  171. 		double mul_5396 = (expr_5417 * 0.81649);

  172. 		double expr_5410 = (-safepow(expr_5416, mul_5396));

  173. 		double mul_5391 = (expr_5417 * 0.000527);

  174. 		int int_5390 = int(mul_5391);

  175. 		double mstosamps_5244 = (m_window_25 * (samplerate * 0.001));

  176. 		double add_5320 = (expr_5417 + 5);

  177. 		double expr_5411 = safepow(expr_5416, add_5320);

  178. 		double mul_5331 = (m_spread_31 * -0.380445);

  179. 		double add_5330 = (mul_5331 + 931);

  180. 		double rsub_5327 = (1341 - add_5330);

  181. 		double mul_5340 = (int_5390 * rsub_5327);

  182. 		double mul_5359 = (m_spread_31 * 0.376623);

  183. 		double add_5358 = (mul_5359 + 931);

  184. 		double rsub_5355 = (1341 - add_5358);

  185. 		double mul_5366 = (int_5390 * rsub_5355);

  186. 		double mul_5326 = (expr_5417 * 0.41);

  187. 		double add_5323 = (mul_5326 + 5);

  188. 		double expr_5414 = safepow(expr_5416, add_5323);

  189. 		double mul_5325 = (expr_5417 * 0.3);

  190. 		double add_5322 = (mul_5325 + 5);

  191. 		double expr_5413 = safepow(expr_5416, add_5322);

  192. 		double mul_5324 = (expr_5417 * 0.155);

  193. 		double add_5321 = (mul_5324 + 5);

  194. 		double expr_5412 = safepow(expr_5416, add_5321);

  195. 		double rsub_5231 = (1 - m_ratio_24);

  196. 		double mul_5230 = (rsub_5231 * 1000);

  197. 		double div_5229 = safediv(mul_5230, m_window_25);

  198. 		samples_to_seconds = (1 / samplerate);

  199. 		double mul_5389 = (expr_5417 * 0.110732);

  200. 		double mul_5333 = (m_spread_31 * -0.568366);

  201. 		double add_5329 = (mul_5333 + 369);

  202. 		double rsub_5328 = (add_5330 - add_5329);

  203. 		double mul_5347 = (int_5390 * rsub_5328);

  204. 		double mul_5375 = (m_spread_31 * 0.125541);

  205. 		double add_5357 = (mul_5375 + 369);

  206. 		double rsub_5356 = (add_5358 - add_5357);

  207. 		double mul_5373 = (int_5390 * rsub_5356);

  208. 		double add_5332 = (mul_5333 + 159);

  209. 		double mul_5354 = (int_5390 * add_5332);

  210. 		double add_5374 = (mul_5375 + 159);

  211. 		double mul_5382 = (int_5390 * add_5374);

  212. 		// the main sample loop;

  213. 		while ((__n--)) { 

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

  215. 			double noise_5183 = noise();

  216. 			double abs_5200 = fabs(noise_5183);

  217. 			double mul_5208 = (abs_5200 * m_blur_28);

  218. 			double noise_5182 = noise();

  219. 			double abs_5199 = fabs(noise_5182);

  220. 			double mul_5205 = (abs_5199 * m_blur_28);

  221. 			double noise_5181 = noise();

  222. 			double abs_5198 = fabs(noise_5181);

  223. 			double mul_5202 = (abs_5198 * m_blur_28);

  224. 			double noise_5184 = noise();

  225. 			double abs_5201 = fabs(noise_5184);

  226. 			double mul_5211 = (abs_5201 * m_blur_28);

  227. 			double tap_5294 = m_delay_23.read_linear(mul_5394);

  228. 			double mul_5290 = (tap_5294 * expr_5408);

  229. 			double mix_5468 = (mul_5290 + (m_damping_30 * (m_history_10 - mul_5290)));

  230. 			double mix_5292 = mix_5468;

  231. 			double tap_5402 = m_delay_22.read_linear(mul_5397);

  232. 			double mul_5393 = (tap_5402 * expr_5415);

  233. 			double mix_5469 = (mul_5393 + (m_damping_30 * (m_history_9 - mul_5393)));

  234. 			double mix_5400 = mix_5469;

  235. 			double tap_5300 = m_delay_21.read_linear(mul_5395);

  236. 			double mul_5296 = (tap_5300 * expr_5409);

  237. 			double mix_5470 = (mul_5296 + (m_damping_30 * (m_history_8 - mul_5296)));

  238. 			double mix_5298 = mix_5470;

  239. 			double tap_5306 = m_delay_20.read_linear(mul_5396);

  240. 			double mul_5302 = (tap_5306 * expr_5410);

  241. 			double mix_5471 = (mul_5302 + (m_damping_30 * (m_history_7 - mul_5302)));

  242. 			double mix_5304 = mix_5471;

  243. 			double add_5284 = (mix_5400 + mix_5304);

  244. 			double add_5282 = (mix_5298 + mix_5292);

  245. 			double add_5277 = (add_5284 + add_5282);

  246. 			double mul_5260 = (add_5277 * 0.5);

  247. 			double sub_5281 = (add_5284 - add_5282);

  248. 			double mul_5263 = (sub_5281 * 0.5);

  249. 			double tap_5339 = m_delay_19.read_linear(mul_5340);

  250. 			double mul_5337 = (tap_5339 * 0.625);

  251. 			double tap_5365 = m_delay_18.read_linear(mul_5366);

  252. 			double mul_5363 = (tap_5365 * 0.625);

  253. 			double sub_5283 = (mix_5400 - mix_5304);

  254. 			double sub_5280 = (mix_5298 - mix_5292);

  255. 			double sub_5279 = (sub_5283 - sub_5280);

  256. 			double mul_5262 = (sub_5279 * 0.5);

  257. 			double add_5278 = (sub_5283 + sub_5280);

  258. 			double rsub_5276 = (0 - add_5278);

  259. 			double mul_5261 = (rsub_5276 * 0.5);

  260. 			double tap_5308 = m_delay_17.read_linear(add_5323);

  261. 			double tap_5309 = m_delay_17.read_linear(add_5322);

  262. 			double tap_5310 = m_delay_17.read_linear(add_5321);

  263. 			double tap_5311 = m_delay_17.read_linear(add_5320);

  264. 			double mul_5312 = (tap_5311 * expr_5411);

  265. 			double add_5285 = (mul_5260 + mul_5312);

  266. 			double mul_5318 = (tap_5308 * expr_5414);

  267. 			double add_5288 = (mul_5263 + mul_5318);

  268. 			double mul_5316 = (tap_5309 * expr_5413);

  269. 			double add_5287 = (mul_5262 + mul_5316);

  270. 			double mul_5314 = (tap_5310 * expr_5412);

  271. 			double add_5286 = (mul_5261 + mul_5314);

  272. 			double phasor_5250 = m_phasor_37(div_5229, samples_to_seconds);

  273. 			double add_5243 = ((m_history_6 + phasor_5250) + 0.25);

  274. 			double mod_5242 = safemod(add_5243, 1);

  275. 			double delta_5210 = m_delta_38(mod_5242);

  276. 			double sah_5189 = m_sah_39(mul_5208, delta_5210, 0);

  277. 			double sah_5209 = m_sah_40(mstosamps_5244, delta_5210, 0);

  278. 			double mul_5196 = (sah_5209 * mod_5242);

  279. 			double sub_5241 = (mod_5242 - 0.5);

  280. 			double mul_5240 = (sub_5241 * 3.1415926535898);

  281. 			double cos_5239 = cos(mul_5240);

  282. 			double mul_5215 = (cos_5239 * cos_5239);

  283. 			double add_5228 = ((m_history_5 + phasor_5250) + 0.5);

  284. 			double mod_5227 = safemod(add_5228, 1);

  285. 			double delta_5207 = m_delta_41(mod_5227);

  286. 			double sah_5187 = m_sah_42(mul_5205, delta_5207, 0);

  287. 			double sah_5206 = m_sah_43(mstosamps_5244, delta_5207, 0);

  288. 			double mul_5195 = (sah_5206 * mod_5227);

  289. 			double sub_5226 = (mod_5227 - 0.5);

  290. 			double mul_5225 = (sub_5226 * 3.1415926535898);

  291. 			double cos_5224 = cos(mul_5225);

  292. 			double mul_5214 = (cos_5224 * cos_5224);

  293. 			double add_5222 = ((m_history_4 + phasor_5250) + 0.75);

  294. 			double mod_5221 = safemod(add_5222, 1);

  295. 			double delta_5204 = m_delta_44(mod_5221);

  296. 			double sah_5185 = m_sah_45(mul_5202, delta_5204, 0);

  297. 			double sah_5203 = m_sah_46(mstosamps_5244, delta_5204, 0);

  298. 			double mul_5194 = (sah_5203 * mod_5221);

  299. 			double sub_5220 = (mod_5221 - 0.5);

  300. 			double mul_5219 = (sub_5220 * 3.1415926535898);

  301. 			double cos_5218 = cos(mul_5219);

  302. 			double mul_5213 = (cos_5218 * cos_5218);

  303. 			double add_5249 = ((m_history_3 + phasor_5250) + 0);

  304. 			double mod_5248 = safemod(add_5249, 1);

  305. 			double delta_5192 = m_delta_47(mod_5248);

  306. 			double sah_5191 = m_sah_48(mul_5211, delta_5192, 0);

  307. 			double sah_5212 = m_sah_49(mstosamps_5244, delta_5192, 0);

  308. 			double mul_5197 = (sah_5212 * mod_5248);

  309. 			double tap_5235 = m_delay_16.read_linear(mul_5197);

  310. 			double tap_5236 = m_delay_16.read_linear(mul_5196);

  311. 			double tap_5237 = m_delay_16.read_linear(mul_5195);

  312. 			double tap_5238 = m_delay_16.read_linear(mul_5194);

  313. 			double mul_5217 = (tap_5238 * mul_5213);

  314. 			double mul_5223 = (tap_5237 * mul_5214);

  315. 			double mul_5232 = (tap_5236 * mul_5215);

  316. 			double sub_5247 = (mod_5248 - 0.5);

  317. 			double mul_5246 = (sub_5247 * 3.1415926535898);

  318. 			double cos_5245 = cos(mul_5246);

  319. 			double mul_5216 = (cos_5245 * cos_5245);

  320. 			double mul_5233 = (tap_5235 * mul_5216);

  321. 			double add_5473 = (((mul_5233 + mul_5232) + mul_5223) + mul_5217);

  322. 			double mix_5472 = (m_y_2 + (clamp_5180 * (add_5473 - m_y_2)));

  323. 			double mix_5177 = mix_5472;

  324. 			double mix_5474 = (in1 + (m_shimmer_27 * (mix_5177 - in1)));

  325. 			double mix_5251 = mix_5474;

  326. 			double mul_5254 = (mix_5251 * 0.707);

  327. 			double mix_5475 = (mul_5254 + (rsub_5405 * (m_history_1 - mul_5254)));

  328. 			double mix_5404 = mix_5475;

  329. 			double tap_5388 = m_delay_15.read_linear(mul_5389);

  330. 			double mul_5386 = (tap_5388 * 0.75);

  331. 			double sub_5385 = (mix_5404 - mul_5386);

  332. 			double mul_5384 = (sub_5385 * 0.75);

  333. 			double add_5383 = (mul_5384 + tap_5388);

  334. 			double tap_5346 = m_delay_14.read_linear(mul_5347);

  335. 			double mul_5344 = (tap_5346 * 0.625);

  336. 			double tap_5372 = m_delay_13.read_linear(mul_5373);

  337. 			double mul_5370 = (tap_5372 * 0.625);

  338. 			double tap_5353 = m_delay_12.read_linear(mul_5354);

  339. 			double mul_5351 = (tap_5353 * 0.75);

  340. 			double tap_5381 = m_delay_11.read_linear(mul_5382);

  341. 			double mul_5379 = (tap_5381 * 0.75);

  342. 			double mul_5275 = (mul_5263 * m_tail_33);

  343. 			double mul_5273 = (mul_5261 * m_tail_33);

  344. 			double add_5259 = (mul_5275 + mul_5273);

  345. 			double mul_5274 = (mul_5262 * m_tail_33);

  346. 			double mul_5272 = (mul_5260 * m_tail_33);

  347. 			double add_5258 = (mul_5274 + mul_5272);

  348. 			double sub_5267 = (add_5259 - add_5258);

  349. 			double mul_5271 = (mul_5318 * m_early_35);

  350. 			double mul_5269 = (mul_5314 * m_early_35);

  351. 			double add_5257 = (mul_5271 + mul_5269);

  352. 			double mul_5270 = (mul_5316 * m_early_35);

  353. 			double mul_5268 = (mul_5312 * m_early_35);

  354. 			double add_5256 = (mul_5270 + mul_5268);

  355. 			double sub_5266 = (add_5257 - add_5256);

  356. 			double add_5253 = (sub_5267 + sub_5266);

  357. 			double add_5255 = (add_5253 + mix_5251);

  358. 			double sub_5350 = (add_5255 - mul_5351);

  359. 			double mul_5349 = (sub_5350 * 0.75);

  360. 			double add_5348 = (mul_5349 + tap_5353);

  361. 			double sub_5343 = (add_5348 - mul_5344);

  362. 			double mul_5342 = (sub_5343 * 0.625);

  363. 			double add_5341 = (mul_5342 + tap_5346);

  364. 			double sub_5336 = (add_5341 - mul_5337);

  365. 			double mul_5335 = (sub_5336 * 0.625);

  366. 			double add_5334 = (mul_5335 + tap_5339);

  367. 			double mul_5252 = (add_5334 * m_mix_36);

  368. 			double out2 = (in1 + mul_5252);

  369. 			double add_5265 = (add_5253 + mix_5251);

  370. 			double sub_5378 = (add_5265 - mul_5379);

  371. 			double mul_5377 = (sub_5378 * 0.75);

  372. 			double add_5376 = (mul_5377 + tap_5381);

  373. 			double sub_5369 = (add_5376 - mul_5370);

  374. 			double mul_5368 = (sub_5369 * 0.625);

  375. 			double add_5367 = (mul_5368 + tap_5372);

  376. 			double sub_5362 = (add_5367 - mul_5363);

  377. 			double mul_5361 = (sub_5362 * 0.625);

  378. 			double add_5360 = (mul_5361 + tap_5365);

  379. 			double mul_5264 = (add_5360 * m_mix_36);

  380. 			double out1 = (in1 + mul_5264);

  381. 			double history_5291_next_5418 = mix_5292;

  382. 			double history_5399_next_5419 = mix_5400;

  383. 			double history_5297_next_5420 = mix_5298;

  384. 			double history_5303_next_5421 = mix_5304;

  385. 			double history_5190_next_5422 = sah_5189;

  386. 			double history_5188_next_5423 = sah_5187;

  387. 			double history_5186_next_5424 = sah_5185;

  388. 			double history_5193_next_5425 = sah_5191;

  389. 			double y0_next_5426 = mix_5177;

  390. 			double history_5403_next_5427 = mix_5404;

  391. 			m_delay_23.write(add_5285);

  392. 			m_delay_22.write(add_5288);

  393. 			m_delay_21.write(add_5286);

  394. 			m_delay_20.write(add_5287);

  395. 			m_delay_19.write(sub_5336);

  396. 			m_delay_18.write(sub_5362);

  397. 			m_delay_17.write(add_5383);

  398. 			m_delay_16.write(in1);

  399. 			m_delay_15.write(sub_5385);

  400. 			m_delay_14.write(sub_5343);

  401. 			m_delay_13.write(sub_5369);

  402. 			m_delay_12.write(sub_5350);

  403. 			m_delay_11.write(sub_5378);

  404. 			m_history_10 = history_5291_next_5418;

  405. 			m_history_9 = history_5399_next_5419;

  406. 			m_history_8 = history_5297_next_5420;

  407. 			m_history_7 = history_5303_next_5421;

  408. 			m_history_6 = history_5190_next_5422;

  409. 			m_history_5 = history_5188_next_5423;

  410. 			m_history_4 = history_5186_next_5424;

  411. 			m_history_3 = history_5193_next_5425;

  412. 			m_y_2 = y0_next_5426;

  413. 			m_history_1 = history_5403_next_5427;

  414. 			m_delay_11.step();

  415. 			m_delay_12.step();

  416. 			m_delay_13.step();

  417. 			m_delay_14.step();

  418. 			m_delay_15.step();

  419. 			m_delay_16.step();

  420. 			m_delay_17.step();

  421. 			m_delay_18.step();

  422. 			m_delay_19.step();

  423. 			m_delay_20.step();

  424. 			m_delay_21.step();

  425. 			m_delay_22.step();

  426. 			m_delay_23.step();

  427. 			// assign results to output buffer;

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

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

  430. 			

  431. 		};

  432. 		return __exception;

  433. 		

  434. 	};

  435. 	inline void set_ratio(double _value) {

  436. 		m_ratio_24 = (_value < 0.5 ? 0.5 : (_value > 2 ? 2 : _value));

  437. 	};

  438. 	inline void set_window(double _value) {

  439. 		m_window_25 = (_value < 0.1 ? 0.1 : (_value > 1000 ? 1000 : _value));

  440. 	};

  441. 	inline void set_decay(double _value) {

  442. 		m_decay_26 = (_value < 0.1 ? 0.1 : (_value > 360 ? 360 : _value));

  443. 	};

  444. 	inline void set_shimmer(double _value) {

  445. 		m_shimmer_27 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  446. 	};

  447. 	inline void set_blur(double _value) {

  448. 		m_blur_28 = (_value < 0.01 ? 0.01 : (_value > 0.25 ? 0.25 : _value));

  449. 	};

  450. 	inline void set_roomsize(double _value) {

  451. 		m_roomsize_29 = (_value < 0.1 ? 0.1 : (_value > 300 ? 300 : _value));

  452. 	};

  453. 	inline void set_damping(double _value) {

  454. 		m_damping_30 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  455. 	};

  456. 	inline void set_spread(double _value) {

  457. 		m_spread_31 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));

  458. 	};

  459. 	inline void set_tone(double _value) {

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

  461. 	};

  462. 	inline void set_tail(double _value) {

  463. 		m_tail_33 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));

  464. 	};

  465. 	inline void set_cutoff(double _value) {

  466. 		m_cutoff_34 = (_value < 0 ? 0 : (_value > 6000 ? 6000 : _value));

  467. 	};

  468. 	inline void set_early(double _value) {

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

  470. 	};

  471. 	inline void set_mix(double _value) {

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

  473. 	};

  474. 	

  475. } State;

  476. 

  477. 

  478. /// 

  479. ///	Configuration for the genlib API

  480. ///

  481. 

  482. /// Number of signal inputs and outputs 

  483. 

  484. int gen_kernel_numins = 1;

  485. int gen_kernel_numouts = 2;

  486. 

  487. int num_inputs() { return gen_kernel_numins; }

  488. int num_outputs() { return gen_kernel_numouts; }

  489. int num_params() { return 13; }

  490. 

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

  492. 

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

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

  495. 

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

  497. 

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

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

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

  501. }

  502. 

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

  504. 

  505. void reset(CommonState *cself) { 

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

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

  508. }

  509. 

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

  511. 

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

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

  514. 	switch (index) {

  515. 		case 0: self->set_ratio(value); break;

  516. 		case 1: self->set_window(value); break;

  517. 		case 2: self->set_decay(value); break;

  518. 		case 3: self->set_shimmer(value); break;

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

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

  521. 		case 6: self->set_damping(value); break;

  522. 		case 7: self->set_spread(value); break;

  523. 		case 8: self->set_tone(value); break;

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

  525. 		case 10: self->set_cutoff(value); break;

  526. 		case 11: self->set_early(value); break;

  527. 		case 12: self->set_mix(value); break;

  528. 		

  529. 		default: break;

  530. 	}

  531. }

  532. 

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

  534. 

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

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

  537. 	switch (index) {

  538. 		case 0: *value = self->m_ratio_24; break;

  539. 		case 1: *value = self->m_window_25; break;

  540. 		case 2: *value = self->m_decay_26; break;

  541. 		case 3: *value = self->m_shimmer_27; break;

  542. 		case 4: *value = self->m_blur_28; break;

  543. 		case 5: *value = self->m_roomsize_29; break;

  544. 		case 6: *value = self->m_damping_30; break;

  545. 		case 7: *value = self->m_spread_31; break;

  546. 		case 8: *value = self->m_tone_32; break;

  547. 		case 9: *value = self->m_tail_33; break;

  548. 		case 10: *value = self->m_cutoff_34; break;

  549. 		case 11: *value = self->m_early_35; break;

  550. 		case 12: *value = self->m_mix_36; break;

  551. 		

  552. 		default: break;

  553. 	}

  554. }

  555. 

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

  557. 

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

  559. 	State *self = new State;

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

  561. 	ParamInfo *pi;

  562. 	self->__commonstate.inputnames = gen_kernel_innames;

  563. 	self->__commonstate.outputnames = gen_kernel_outnames;

  564. 	self->__commonstate.numins = gen_kernel_numins;

  565. 	self->__commonstate.numouts = gen_kernel_numouts;

  566. 	self->__commonstate.sr = sr;

  567. 	self->__commonstate.vs = vs;

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

  569. 	self->__commonstate.numparams = 13;

  570. 	// initialize parameter 0 ("m_ratio_24")

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

  572. 	pi->name = "ratio";

  573. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  574. 	pi->defaultvalue = self->m_ratio_24;

  575. 	pi->defaultref = 0;

  576. 	pi->hasinputminmax = false;

  577. 	pi->inputmin = 0; 

  578. 	pi->inputmax = 1;

  579. 	pi->hasminmax = true;

  580. 	pi->outputmin = 0.5;

  581. 	pi->outputmax = 2;

  582. 	pi->exp = 0;

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

  584. 	// initialize parameter 1 ("m_window_25")

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

  586. 	pi->name = "window";

  587. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  588. 	pi->defaultvalue = self->m_window_25;

  589. 	pi->defaultref = 0;

  590. 	pi->hasinputminmax = false;

  591. 	pi->inputmin = 0; 

  592. 	pi->inputmax = 1;

  593. 	pi->hasminmax = true;

  594. 	pi->outputmin = 0.1;

  595. 	pi->outputmax = 1000;

  596. 	pi->exp = 0;

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

  598. 	// initialize parameter 2 ("m_decay_26")

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

  600. 	pi->name = "decay";

  601. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  602. 	pi->defaultvalue = self->m_decay_26;

  603. 	pi->defaultref = 0;

  604. 	pi->hasinputminmax = false;

  605. 	pi->inputmin = 0; 

  606. 	pi->inputmax = 1;

  607. 	pi->hasminmax = true;

  608. 	pi->outputmin = 0.1;

  609. 	pi->outputmax = 360;

  610. 	pi->exp = 0;

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

  612. 	// initialize parameter 3 ("m_shimmer_27")

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

  614. 	pi->name = "shimmer";

  615. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  616. 	pi->defaultvalue = self->m_shimmer_27;

  617. 	pi->defaultref = 0;

  618. 	pi->hasinputminmax = false;

  619. 	pi->inputmin = 0; 

  620. 	pi->inputmax = 1;

  621. 	pi->hasminmax = true;

  622. 	pi->outputmin = 0;

  623. 	pi->outputmax = 1;

  624. 	pi->exp = 0;

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

  626. 	// initialize parameter 4 ("m_blur_28")

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

  628. 	pi->name = "blur";

  629. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  630. 	pi->defaultvalue = self->m_blur_28;

  631. 	pi->defaultref = 0;

  632. 	pi->hasinputminmax = false;

  633. 	pi->inputmin = 0; 

  634. 	pi->inputmax = 1;

  635. 	pi->hasminmax = true;

  636. 	pi->outputmin = 0.01;

  637. 	pi->outputmax = 0.25;

  638. 	pi->exp = 0;

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

  640. 	// initialize parameter 5 ("m_roomsize_29")

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

  642. 	pi->name = "roomsize";

  643. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  644. 	pi->defaultvalue = self->m_roomsize_29;

  645. 	pi->defaultref = 0;

  646. 	pi->hasinputminmax = false;

  647. 	pi->inputmin = 0; 

  648. 	pi->inputmax = 1;

  649. 	pi->hasminmax = true;

  650. 	pi->outputmin = 0.1;

  651. 	pi->outputmax = 300;

  652. 	pi->exp = 0;

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

  654. 	// initialize parameter 6 ("m_damping_30")

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

  656. 	pi->name = "damping";

  657. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  658. 	pi->defaultvalue = self->m_damping_30;

  659. 	pi->defaultref = 0;

  660. 	pi->hasinputminmax = false;

  661. 	pi->inputmin = 0; 

  662. 	pi->inputmax = 1;

  663. 	pi->hasminmax = true;

  664. 	pi->outputmin = 0;

  665. 	pi->outputmax = 1;

  666. 	pi->exp = 0;

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

  668. 	// initialize parameter 7 ("m_spread_31")

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

  670. 	pi->name = "spread";

  671. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  672. 	pi->defaultvalue = self->m_spread_31;

  673. 	pi->defaultref = 0;

  674. 	pi->hasinputminmax = false;

  675. 	pi->inputmin = 0; 

  676. 	pi->inputmax = 1;

  677. 	pi->hasminmax = true;

  678. 	pi->outputmin = 0;

  679. 	pi->outputmax = 100;

  680. 	pi->exp = 0;

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

  682. 	// initialize parameter 8 ("m_tone_32")

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

  684. 	pi->name = "tone";

  685. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  687. 	pi->defaultref = 0;

  688. 	pi->hasinputminmax = false;

  689. 	pi->inputmin = 0; 

  690. 	pi->inputmax = 1;

  691. 	pi->hasminmax = true;

  692. 	pi->outputmin = 0;

  693. 	pi->outputmax = 1;

  694. 	pi->exp = 0;

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

  696. 	// initialize parameter 9 ("m_tail_33")

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

  698. 	pi->name = "tail";

  699. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  700. 	pi->defaultvalue = self->m_tail_33;

  701. 	pi->defaultref = 0;

  702. 	pi->hasinputminmax = false;

  703. 	pi->inputmin = 0; 

  704. 	pi->inputmax = 1;

  705. 	pi->hasminmax = true;

  706. 	pi->outputmin = 0;

  707. 	pi->outputmax = 1;

  708. 	pi->exp = 0;

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

  710. 	// initialize parameter 10 ("m_cutoff_34")

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

  712. 	pi->name = "cutoff";

  713. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

  714. 	pi->defaultvalue = self->m_cutoff_34;

  715. 	pi->defaultref = 0;

  716. 	pi->hasinputminmax = false;

  717. 	pi->inputmin = 0; 

  718. 	pi->inputmax = 1;

  719. 	pi->hasminmax = true;

  720. 	pi->outputmin = 0;

  721. 	pi->outputmax = 6000;

  722. 	pi->exp = 0;

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

  724. 	// initialize parameter 11 ("m_early_35")

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

  726. 	pi->name = "early";

  727. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  729. 	pi->defaultref = 0;

  730. 	pi->hasinputminmax = false;

  731. 	pi->inputmin = 0; 

  732. 	pi->inputmax = 1;

  733. 	pi->hasminmax = true;

  734. 	pi->outputmin = 0;

  735. 	pi->outputmax = 1;

  736. 	pi->exp = 0;

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

  738. 	// initialize parameter 12 ("m_mix_36")

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

  740. 	pi->name = "mix";

  741. 	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;

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

  743. 	pi->defaultref = 0;

  744. 	pi->hasinputminmax = false;

  745. 	pi->inputmin = 0; 

  746. 	pi->inputmax = 1;

  747. 	pi->hasminmax = true;

  748. 	pi->outputmin = 0;

  749. 	pi->outputmax = 1;

  750. 	pi->exp = 0;

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

  752. 	

  753. 	return self;

  754. }

  755. 

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

  757. 

  758. void destroy(CommonState *cself) { 

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

  760. 	genlib_sysmem_freeptr(cself->params);

  761. 		

  762. 	delete self; 

  763. }

  764. 

  765. 

  766. } // gen_exported::