falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
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.
1858 Commits
17 Branches
341MB
Tree: 0937586360
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0937586360'
${ noResults }
Carla/source/modules/native-plugins/groovejuice/GrooveJuicePlugin.cpp

622 lines
17KB
Raw Blame History 

  1. /*

  2.  * Vector Juice Plugin

  3.  * Copyright (C) 2014 Andre Sklenar <andre.sklenar@gmail.com>, www.juicelab.cz

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "GrooveJuicePlugin.hpp"

  19. 

  20. 

  21. 

  22. 

  23. START_NAMESPACE_DISTRHO

  24. 

  25. // -----------------------------------------------------------------------

  26. 

  27. GrooveJuicePlugin::GrooveJuicePlugin()

  28.     : Plugin(paramCount, 1, 0) // 1 program, 0 states

  29. {

  30.     // set default values

  31.     d_setProgram(0);

  32. 

  33.     // reset

  34.     d_deactivate();

  35. }

  36. 

  37. // -----------------------------------------------------------------------

  38. // Init

  39. 

  40. void GrooveJuicePlugin::d_initParameter(uint32_t index, Parameter& parameter)

  41. {

  42. 	switch (index)

  43. 	{

  44. 	    case paramX:

  45. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  46. 		   parameter.name       = "X";

  47. 		   parameter.symbol     = "x";

  48. 		   parameter.unit       = "";

  49. 		   parameter.ranges.def = 0.5f;

  50. 		   parameter.ranges.min = 0.0f;

  51. 		   parameter.ranges.max = 1.0f;

  52. 		   break;

  53. 

  54. 	    case paramY:

  55. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  56. 		   parameter.name       = "Y";

  57. 		   parameter.symbol     = "y";

  58. 		   parameter.unit       = "";

  59. 		   parameter.ranges.def = 0.5f;

  60. 		   parameter.ranges.min = 0.0f;

  61. 		   parameter.ranges.max = 1.0f;

  62. 		   break;

  63. 

  64. 	    case paramOrbitSpeedX:

  65. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  66. 		   parameter.name       = "Orbit Speed X";

  67. 		   parameter.symbol     = "";

  68. 		   parameter.unit       = "";

  69. 		   parameter.ranges.def = 4.0f;

  70. 		   parameter.ranges.min = 1.0f;

  71. 		   parameter.ranges.max = 128.0f;

  72. 		   break;

  73. 

  74. 	    case paramOrbitSpeedY:

  75. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  76. 		   parameter.name       = "Orbit Speed Y";

  77. 		   parameter.symbol     = "";

  78. 		   parameter.unit       = "";

  79. 		   parameter.ranges.def = 4.0f;

  80. 		   parameter.ranges.min = 1.0f;

  81. 		   parameter.ranges.max = 128.0f;

  82. 		   break;

  83. 

  84. 	    case paramOrbitSizeX:

  85. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  86. 		   parameter.name       = "Orbit Size X";

  87. 		   parameter.symbol     = "osl";

  88. 		   parameter.unit       = "";

  89. 		   parameter.ranges.def = 0.5f;

  90. 		   parameter.ranges.min = 0.0f;

  91. 		   parameter.ranges.max = 1.0f;

  92. 		   break;

  93. 

  94. 	    case paramOrbitSizeY:

  95. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  96. 		   parameter.name       = "Orbit Size Y";

  97. 		   parameter.symbol     = "osr";

  98. 		   parameter.unit       = "";

  99. 		   parameter.ranges.def = 0.5f;

  100. 		   parameter.ranges.min = 0.0f;

  101. 		   parameter.ranges.max = 1.0f;

  102. 		   break;

  103. 

  104. 	    case paramSubOrbitSpeed:

  105. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  106. 		   parameter.name       = "SubOrbit Speed";

  107. 		   parameter.symbol     = "";

  108. 		   parameter.unit       = "";

  109. 		   parameter.ranges.def = 32.0f;

  110. 		   parameter.ranges.min = 1.0f;

  111. 		   parameter.ranges.max = 128.0f;

  112. 		   break;

  113. 

  114. 	    case paramSubOrbitSize:

  115. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  116. 		   parameter.name       = "SubOrbit Size";

  117. 		   parameter.symbol     = "";

  118. 		   parameter.unit       = "";

  119. 		   parameter.ranges.def = 0.5f;

  120. 		   parameter.ranges.min = 0.0f;

  121. 		   parameter.ranges.max = 1.0f;

  122. 		   break;

  123. 

  124. 	    case paramSubOrbitSmooth:

  125. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  126. 		   parameter.name       = "SubOrbit Wave";

  127. 		   parameter.symbol     = "";

  128. 		   parameter.unit       = "";

  129. 		   parameter.ranges.def = 0.5f;

  130. 		   parameter.ranges.min = 0.0f;

  131. 		   parameter.ranges.max = 1.0f;

  132. 		   break;

  133. 

  134. 	    case paramOrbitWaveX:

  135. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  136. 		   parameter.name       = "Orbit Wave X";

  137. 		   parameter.symbol     = "";

  138. 		   parameter.unit       = "";

  139. 		   parameter.ranges.def = 3.0f;

  140. 		   parameter.ranges.min = 1.0f;

  141. 		   parameter.ranges.max = 4.0f;

  142. 		   break;

  143. 

  144. 	    case paramOrbitPhaseX:

  145. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  146. 		   parameter.name       = "Orbit Phase X";

  147. 		   parameter.symbol     = "";

  148. 		   parameter.unit       = "";

  149. 		   parameter.ranges.def = 0.0f;

  150. 		   parameter.ranges.min = 0.0f;

  151. 		   parameter.ranges.max = 1.0f;

  152. 		   break;

  153. 

  154. 	    case paramOrbitPhaseY:

  155. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  156. 		   parameter.name       = "Orbit Phase Y";

  157. 		   parameter.symbol     = "";

  158. 		   parameter.unit       = "";

  159. 		   parameter.ranges.def = 0.0f;

  160. 		   parameter.ranges.min = 0.0f;

  161. 		   parameter.ranges.max = 1.0f;

  162. 		   break;

  163. 

  164. 	    case paramOrbitWaveY:

  165. 		   parameter.hints      = PARAMETER_IS_AUTOMABLE;

  166. 		   parameter.name       = "Orbit Wave Y";

  167. 		   parameter.symbol     = "";

  168. 		   parameter.unit       = "";

  169. 		   parameter.ranges.def = 3.0f;

  170. 		   parameter.ranges.min = 1.0f;

  171. 		   parameter.ranges.max = 4.0f;

  172. 		   break;

  173. 

  174. 	    case paramOrbitOutX:

  175. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  176. 		   parameter.name       = "Orbit X";

  177. 		   parameter.symbol     = "orx";

  178. 		   parameter.unit       = "";

  179. 		   parameter.ranges.def = 0.5f;

  180. 		   parameter.ranges.min = 0.0f;

  181. 		   parameter.ranges.max = 1.0f;

  182. 		   break;

  183. 

  184. 	    case paramOrbitOutY:

  185. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  186. 		   parameter.name       = "Orbit Y";

  187. 		   parameter.symbol     = "ory";

  188. 		   parameter.unit       = "";

  189. 		   parameter.ranges.def = 0.5f;

  190. 		   parameter.ranges.min = 0.0f;

  191. 		   parameter.ranges.max = 1.0f;

  192. 		   break;

  193. 

  194. 	    case paramSubOrbitOutX:

  195. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  196. 		   parameter.name       = "SubOrbit X";

  197. 		   parameter.symbol     = "sorx";

  198. 		   parameter.unit       = "";

  199. 		   parameter.ranges.def = 0.5f;

  200. 		   parameter.ranges.min = 0.0f;

  201. 		   parameter.ranges.max = 1.0f;

  202. 		   break;

  203. 

  204. 	    case paramSubOrbitOutY:

  205. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  206. 		   parameter.name       = "SubOrbit Y";

  207. 		   parameter.symbol     = "sory";

  208. 		   parameter.unit       = "";

  209. 		   parameter.ranges.def = 0.5f;

  210. 		   parameter.ranges.min = 0.0f;

  211. 		   parameter.ranges.max = 1.0f;

  212. 		   break;

  213.    

  214. 		case paramW1Out:

  215. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  216. 		   parameter.name       = "";

  217. 		   parameter.symbol     = "";

  218. 		   parameter.unit       = "";

  219. 		   parameter.ranges.def = 0.5f;

  220. 		   parameter.ranges.min = 0.0f;

  221. 		   parameter.ranges.max = 1.0f;

  222. 		   break;

  223.   

  224. 		case paramW2Out:

  225. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  226. 		   parameter.name       = "";

  227. 		   parameter.symbol     = "";

  228. 		   parameter.unit       = "";

  229. 		   parameter.ranges.def = 0.5f;

  230. 		   parameter.ranges.min = 0.0f;

  231. 		   parameter.ranges.max = 1.0f;

  232. 		   break;

  233. 		

  234. 		case paramMOut:

  235. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  236. 		   parameter.name       = "";

  237. 		   parameter.symbol     = "";

  238. 		   parameter.unit       = "";

  239. 		   parameter.ranges.def = 0.5f;

  240. 		   parameter.ranges.min = 0.0f;

  241. 		   parameter.ranges.max = 1.0f;

  242. 		   break;

  243. 		  

  244. 		case paramCOut:

  245. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  246. 		   parameter.name       = "";

  247. 		   parameter.symbol     = "";

  248. 		   parameter.unit       = "";

  249. 		   parameter.ranges.def = 0.5f;

  250. 		   parameter.ranges.min = 0.0f;

  251. 		   parameter.ranges.max = 1.0f;

  252. 		   break;

  253. 		 

  254. 		case paramROut:

  255. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  256. 		   parameter.name       = "";

  257. 		   parameter.symbol     = "";

  258. 		   parameter.unit       = "";

  259. 		   parameter.ranges.def = 0.5f;

  260. 		   parameter.ranges.min = 0.0f;

  261. 		   parameter.ranges.max = 1.0f;

  262. 		   break;

  263. 		   

  264. 		case paramSOut:

  265. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  266. 		   parameter.name       = "";

  267. 		   parameter.symbol     = "";

  268. 		   parameter.unit       = "";

  269. 		   parameter.ranges.def = 0.5f;

  270. 		   parameter.ranges.min = 0.0f;

  271. 		   parameter.ranges.max = 1.0f;

  272. 		   break;

  273. 		   

  274. 		case paramReOut:

  275. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  276. 		   parameter.name       = "";

  277. 		   parameter.symbol     = "";

  278. 		   parameter.unit       = "";

  279. 		   parameter.ranges.def = 0.5f;

  280. 		   parameter.ranges.min = 0.0f;

  281. 		   parameter.ranges.max = 1.0f;

  282. 		   break;

  283. 		   

  284. 		case paramShOut:

  285. 		   parameter.hints      = PARAMETER_IS_OUTPUT;

  286. 		   parameter.name       = "";

  287. 		   parameter.symbol     = "";

  288. 		   parameter.unit       = "";

  289. 		   parameter.ranges.def = 0.5f;

  290. 		   parameter.ranges.min = 0.0f;

  291. 		   parameter.ranges.max = 1.0f;

  292. 		   break;

  293.     }

  294.     

  295.     if (index>=17 && index<17+64) {

  296. 		//int x = (index-17)%8;

  297. 		//int y = (x+1)/(index-17)

  298. 		

  299. 		parameter.hints      = PARAMETER_IS_AUTOMABLE;

  300. 		parameter.name       = "synth";

  301. 		parameter.symbol     = "";

  302. 		parameter.unit       = "";

  303. 		parameter.ranges.def = 0.5f;

  304. 		parameter.ranges.min = 0.0f;

  305. 		parameter.ranges.max = 1.0f;

  306.     }

  307. }

  308. 

  309. void GrooveJuicePlugin::d_initProgramName(uint32_t index, d_string& programName)

  310. {

  311.     if (index != 0)

  312.         return;

  313. 

  314.     programName = "Default";

  315. }

  316. 

  317. // -----------------------------------------------------------------------

  318. // Internal data

  319. 

  320. 

  321. float GrooveJuicePlugin::d_getParameterValue(uint32_t index) const

  322. {

  323. 	if (index<17 || index>=17+64) {

  324. 	    switch (index)

  325. 	    {

  326. 			case paramX:

  327. 				return x;

  328. 			case paramY:

  329. 				return y;

  330. 			case paramOrbitSizeX:

  331. 				return orbitSizeX;

  332. 			case paramOrbitSizeY:

  333. 				return orbitSizeY;

  334. 			case paramOrbitSpeedX:

  335. 				return orbitSpeedX;

  336. 			case paramOrbitSpeedY:

  337. 				return orbitSpeedY;

  338. 			case paramSubOrbitSpeed:

  339. 				return subOrbitSpeed;

  340. 			case paramSubOrbitSize:

  341. 				return subOrbitSize;

  342. 			case paramOrbitOutX:

  343. 				return orbitX;

  344. 			case paramOrbitOutY:

  345. 				return orbitY;

  346. 			case paramSubOrbitOutX:

  347. 				return subOrbitX;

  348. 			case paramSubOrbitOutY:

  349. 				return subOrbitY;

  350. 			case paramSubOrbitSmooth:

  351. 				return subOrbitSmooth;

  352. 			case paramOrbitWaveX:

  353. 				return orbitWaveX;

  354. 			case paramOrbitWaveY:

  355. 				return orbitWaveY;

  356. 			case paramOrbitPhaseX:

  357. 				return orbitPhaseY;

  358. 			case paramOrbitPhaseY:

  359. 				return orbitPhaseY;

  360. 			case paramW1Out:

  361. 				return synthSound[0];

  362. 			case paramW2Out:

  363. 				return synthSound[1];

  364. 			case paramMOut:

  365. 				return synthSound[2];

  366. 			case paramCOut:

  367. 				return synthSound[3];

  368. 			case paramROut:

  369. 				return synthSound[4];

  370. 			case paramSOut:

  371. 				return synthSound[5];

  372. 			case paramReOut:

  373. 				return synthSound[6];

  374. 			case paramShOut:

  375. 				return synthSound[7];

  376. 	    default:

  377. 		   return 0.0f;

  378. 	    }

  379.     

  380.     } else {

  381. 		int num = (index-17); //synth params begin on #17

  382. 		int x = num%8; //synth param

  383. 		//synth page

  384. 		int y = (num-(num%8))/8;

  385. 		return synthData[x][y];

  386.     }

  387. }

  388. 

  389. void GrooveJuicePlugin::d_setParameterValue(uint32_t index, float value)

  390. {

  391. 

  392. 	if (index<17) {

  393. 	    switch (index)

  394. 	    {

  395. 	    case paramX:

  396. 		   x = value;

  397. 		   break;

  398. 	    case paramY:

  399. 		   y = value;

  400. 		   break;

  401. 	    case paramOrbitSpeedX:

  402. 		   orbitSpeedX = value;

  403. 		   resetPhase();

  404. 		   break;

  405. 	    case paramOrbitSpeedY:

  406. 		   orbitSpeedY = value;

  407. 		   resetPhase();

  408. 		   break;

  409. 	    case paramOrbitSizeX:

  410. 		   orbitSizeX = value;

  411. 		   break;

  412. 	    case paramOrbitSizeY:

  413. 		   orbitSizeY = value;

  414. 		   break;

  415. 	    case paramSubOrbitSpeed:

  416. 		   subOrbitSpeed = value;

  417. 		   resetPhase();

  418. 		   break;

  419. 	    case paramSubOrbitSize:

  420. 		   subOrbitSize = value;

  421. 		   break;

  422. 	    case paramSubOrbitSmooth:

  423. 		   subOrbitSmooth = value;

  424. 		   break;

  425. 	    case paramOrbitWaveX:

  426. 		   orbitWaveX = value;

  427. 		   break;

  428. 	    case paramOrbitWaveY:

  429. 		   orbitWaveY = value;

  430. 		   break;

  431. 	    case paramOrbitPhaseX:

  432. 		   orbitPhaseX = value;

  433. 		   resetPhase();

  434. 		   break;

  435. 	    case paramOrbitPhaseY:

  436. 		   orbitPhaseY = value;

  437. 		   resetPhase();

  438. 		   break;

  439. 	    }

  440.     

  441.     } else  {

  442. 		

  443. 		int num = (index-17); //synth params begin on #17

  444. 		int x = num%8; //synth param

  445. 		//synth page

  446. 		int y = (num-(num%8))/8;

  447. 		synthData[x][y] = value;

  448.     }

  449.     

  450. }

  451. 

  452. void GrooveJuicePlugin::d_setProgram(uint32_t index)

  453. {

  454.     if (index != 0)

  455.         return;

  456. 

  457.     /* Default parameter values */

  458.     x = 0.5f;

  459.     y = 0.5f;

  460.     orbitSpeedX = 4.0f;

  461.     orbitSpeedY = 4.0f;

  462.     orbitSizeX = 0.5f;

  463.     orbitSizeY = 0.5f;

  464.     subOrbitSize = 0.5f;

  465.     subOrbitSpeed = 32.0f;

  466.     orbitWaveX = 3.0f;

  467.     orbitWaveY = 3.0f;

  468.     subOrbitSmooth = 0.5f;

  469.     orbitPhaseX = 0.0f;

  470.     orbitPhaseY = 0.0f;

  471. 

  472.     /* Default variable values */

  473.     orbitX=orbitY=orbitTX=orbitTY=0.5;

  474.     subOrbitX=subOrbitY=subOrbitTX=subOrbitTY=0;

  475.     interpolationDivider=200;

  476.     bar=tickX=tickY=percentageX=percentageY=tickOffsetX=0;

  477.     tickOffsetY=sinePosX=sinePosY=tick=percentage=tickOffset=sinePos=0;

  478.     waveBlend=0;

  479. 

  480. 	synthL.setSampleRate(d_getSampleRate());

  481. 	synthR.setSampleRate(d_getSampleRate());

  482. 

  483.     //parameter smoothing

  484.     for (int i=0; i<2; i++) {

  485.         sA[i] = 0.99f;

  486.         sB[i] = 1.f - sA[i];

  487.         sZ[i] = 0;

  488.     }

  489.     

  490. 	for (int x=0; x<8; x++)

  491. 		for (int y=0; y<8; y++)

  492. 			synthData[x][y] = 0.5;

  493. 

  494.     /* reset filter values */

  495.     d_activate();

  496. }

  497. 

  498. // -----------------------------------------------------------------------

  499. // Process

  500. 

  501. void GrooveJuicePlugin::d_activate()

  502. {

  503.     //sinePos = 0;

  504. }

  505. 

  506. void GrooveJuicePlugin::d_deactivate()

  507. {

  508.     // all values to zero

  509. }

  510. 

  511. void GrooveJuicePlugin::d_run(const float**, float** outputs, uint32_t frames, const MidiEvent* midiEvents, uint32_t midiEventCount)

  512. {

  513.     float out1, out2, tX, tY;

  514.         

  515. 		/*

  516.         out1 = inputs[0][i]*tN(1-std::sqrt((tX*tX)+(tY*tY)));

  517.         out2 = inputs[1][i]*tN(1-std::sqrt((tX*tX)+(tY*tY)));

  518. 

  519.         out1 += inputs[2][i]*tN(1-std::sqrt(((1-tX)*(1-tX))+(tY*tY)));

  520.         out2 += inputs[3][i]*tN(1-std::sqrt(((1-tX)*(1-tX))+(tY*tY)));

  521. 

  522.         out1 += inputs[4][i]*tN(1-std::sqrt(((1-tX)*(1-tX))+((1-tY)*(1-tY))));

  523.         out2 += inputs[5][i]*tN(1-std::sqrt(((1-tX)*(1-tX))+((1-tY)*(1-tY))));

  524. 

  525.         out1 += inputs[6][i]*tN(1-std::sqrt((tX*tX)+((1-tY)*(1-tY))));

  526.         out2 += inputs[7][i]*tN(1-std::sqrt((tX*tX)+((1-tY)*(1-tY))));

  527. 	   */

  528.    

  529.    for (uint32_t i = 0; i<frames; i++) {

  530. 	animate();	

  531. 	tX = subOrbitX;

  532. 	tY = subOrbitY;

  533. 	//sum values

  534. 	float c = 0.41421f; //mid segment

  535. 	float d = c/1.41f; //side segments

  536. 	float distances[8];

  537. 	distances[0] = distance(d, 0, tX, tY);

  538. 	distances[1] = distance(c+d, 0, tX, tY);

  539. 	distances[2] = distance(1, d, tX, tY);

  540. 	distances[3] = distance(1, c+d, tX, tY);

  541. 	distances[4] = distance(d, 1, tX, tY);

  542. 	distances[5] = distance(c+d, 1, tX, tY);

  543. 	distances[6] = distance(0, d, tX, tY);

  544. 	distances[7] = distance(0, c+d, tX, tY);

  545. 	

  546. 	//std::cout << distances[0] << " ";

  547. 	//std::cout << tX << std::endl;

  548. 	

  549. 	for (int x=0; x<8; x++) {

  550. 		float targetValue = 0;

  551. 		for (int y=0; y<8; y++) {

  552. 			targetValue += synthData[x][y]*(distances[y]);

  553. 		}

  554. 		synthSound[x] = tN(targetValue);

  555. 	}

  556. 	

  557. 	//printf("wave1: %f\n", synthSound[0]);

  558. 	

  559. 	//std::cout << synthSound[0] << std::endl;

  560. 	

  561. 	synthL.setWave(0, synthSound[0]);

  562. 	synthR.setWave(0, synthSound[0]);

  563. 	synthL.setWave(1, synthSound[1]);

  564. 	synthR.setWave(1, synthSound[1]);

  565. 	synthL.setMix(synthSound[2]);

  566. 	synthR.setMix(synthSound[2]);

  567. 	//synthL.setCut(synthSound[3]);

  568. 	//synthR.setCut(synthSound[3]);

  569. 	//synthL.setReso(synthSound[4]);

  570. 	//synthR.setReso(synthSound[4]);

  571. 	//synthL.setDecay(synthSound[5]);

  572. 	//synthR.setDecay(synthSound[5]);

  573. 	synthL.setSustain(synthSound[5]);

  574. 	synthR.setSustain(synthSound[5]);

  575. 	synthL.setRelease(synthSound[6]);

  576. 	synthR.setRelease(synthSound[6]);

  577. 	synthL.setStereo(-0.5);

  578. 	synthR.setStereo(0.5);

  579. 	synthL.setShape(synthSound[7]);

  580. 	synthR.setShape(synthSound[7]);

  581. 	

  582. 	float cutoff = std::exp((std::log(16000)-std::log(500))*synthSound[3]+std::log(500));

  583. 	

  584. 	filterL.recalc(cutoff, synthSound[4]*0.8, d_getSampleRate(), synthSound[7]);

  585. 	filterR.recalc(cutoff, synthSound[4]*0.8, d_getSampleRate(), synthSound[7]);

  586. 	

  587. 	outputs[0][i] = filterL.process(synthL.run());

  588. 	outputs[1][i] = filterR.process(synthL.run());

  589. 

  590.    }

  591.    

  592.    

  593.    //outputs = buffer;

  594.    

  595.    for (uint32_t i = 0; i<midiEventCount; i++) {

  596.         int mType = midiEvents[i].buf[0] & 0xF0;

  597.         //int mChan = midiEvents[i].buf[0] & 0x0F;

  598.         int mNum = midiEvents[i].buf[1];

  599.         if (mType == 0x90) {

  600.             //note on

  601.             synthL.play(mNum);

  602.             synthR.play(mNum);

  603.         } else if (mType == 0x80) {

  604.             //note off

  605.             synthL.stop(mNum);

  606.             synthR.stop(mNum);

  607.         }

  608.     }

  609.    

  610. }

  611. 

  612. // -----------------------------------------------------------------------

  613. 

  614. Plugin* createPlugin()

  615. {

  616.     return new GrooveJuicePlugin();

  617. }

  618. 

  619. // -----------------------------------------------------------------------

  620. 

  621. END_NAMESPACE_DISTRHO