DISTRHO
/
DISTRHO-Ports
mirror of https://github.com/DISTRHO/DISTRHO-Ports
1
0
Fork 0
Code Releases 5 Activity
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.
398 Commits
6 Branches
885MB
Tree: e11e2b204c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e11e2b204c'
${ noResults }
DISTRHO-Ports/ports/obxd/source/PluginProcessor.cpp

939 lines
21KB
Raw Blame History 

  1. /*

  2. ==============================================================================

  3. 

  4. This file was auto-generated!

  5. 

  6. It contains the basic startup code for a Juce application.

  7. 

  8. ==============================================================================

  9. */

  10. #include "PluginProcessor.h"

  11. #include "PluginEditor.h"

  12. #include "Engine/Params.h"

  13. 

  14. //==============================================================================

  15. #define S(T) (juce::String(T))

  16. 

  17. //==============================================================================

  18. ObxdAudioProcessor::ObxdAudioProcessor()

  19. 	: programs()

  20. 	, configLock("__" JucePlugin_Name "ConfigLock__")

  21. {

  22. 	isHostAutomatedChange = true;

  23. 

  24. 	synth.setSampleRate(44100);

  25. 

  26. 	PropertiesFile::Options options;

  27. 	options.applicationName = JucePlugin_Name;

  28. 	options.storageFormat = PropertiesFile::storeAsXML;

  29. 	options.millisecondsBeforeSaving = 2500;

  30. 	options.processLock = &configLock;

  31. 	config = new PropertiesFile(getDocumentFolder().getChildFile("Settings.xml"), options);

  32. 

  33. 	currentSkin = config->containsKey("skin") ? config->getValue("skin") : "discoDSP Grey";

  34. 	currentBank = "Init";

  35. 

  36. 	scanAndUpdateBanks();

  37. 	initAllParams();

  38. 

  39. 	if (bankFiles.size() > 0)

  40. 	{

  41. 		loadFromFXBFile(bankFiles[0]);

  42. 	}

  43. }

  44. 

  45. ObxdAudioProcessor::~ObxdAudioProcessor()

  46. {

  47. 	config->saveIfNeeded();

  48. 	config = nullptr;

  49. }

  50. 

  51. //==============================================================================

  52. void ObxdAudioProcessor::initAllParams()

  53. {

  54. 	for (int i = 0 ; i < PARAM_COUNT; i++)

  55. 	{

  56. 		setParameter(i, programs.currentProgramPtr->values[i]);

  57. 	}

  58. }

  59. 

  60. //==============================================================================

  61. int ObxdAudioProcessor::getNumParameters()

  62. {

  63. 	return PARAM_COUNT;

  64. }

  65. 

  66. float ObxdAudioProcessor::getParameter (int index)

  67. {

  68. 	return programs.currentProgramPtr->values[index];

  69. }

  70. 

  71. void ObxdAudioProcessor::setParameter (int index, float newValue)

  72. {

  73. 	programs.currentProgramPtr->values[index] = newValue;

  74. 	switch(index)

  75. 	{

  76. 	case SELF_OSC_PUSH:

  77. 		synth.processSelfOscPush(newValue);

  78. 		break;

  79. 	case PW_ENV_BOTH:

  80. 		synth.processPwEnvBoth(newValue);

  81. 		break;

  82. 	case PW_OSC2_OFS:

  83. 		synth.processPwOfs(newValue);

  84. 		break;

  85. 	case ENV_PITCH_BOTH:

  86. 		synth.processPitchModBoth(newValue);

  87. 		break;

  88. 	case FENV_INVERT:

  89. 		synth.processInvertFenv(newValue);

  90. 		break;

  91. 	case LEVEL_DIF:

  92. 		synth.processLoudnessDetune(newValue);

  93. 		break;

  94. 	case PW_ENV:

  95. 		synth.processPwEnv(newValue);

  96. 		break;

  97. 	case LFO_SYNC:

  98. 		synth.procLfoSync(newValue);

  99. 		break;

  100. 	case ECONOMY_MODE:

  101. 		synth.procEconomyMode(newValue);

  102. 		break;

  103. 	case VAMPENV:

  104. 		synth.procAmpVelocityAmount(newValue);

  105. 		break;

  106. 	case VFLTENV:

  107. 		synth.procFltVelocityAmount(newValue);

  108. 		break;

  109. 	case ASPLAYEDALLOCATION:

  110. 		synth.procAsPlayedAlloc(newValue);

  111. 		break;

  112. 	case BENDLFORATE:

  113. 		synth.procModWheelFrequency(newValue);

  114. 		break;

  115. 	case FOURPOLE:

  116. 		synth.processFourPole(newValue);

  117. 		break;

  118. 	case LEGATOMODE:

  119. 		synth.processLegatoMode(newValue);

  120. 		break;

  121. 	case ENVPITCH:

  122. 		synth.processEnvelopeToPitch(newValue);

  123. 		break;

  124. 	case OSCQuantize:

  125. 		synth.processPitchQuantization(newValue);

  126. 		break;

  127. 	case VOICE_COUNT:

  128. 		synth.setVoiceCount(newValue);

  129. 		break;

  130. 	case BANDPASS:

  131. 		synth.processBandpassSw(newValue);

  132. 		break;

  133. 	case FILTER_WARM:

  134. 		synth.processOversampling(newValue);

  135. 		break;

  136. 	case BENDOSC2:

  137. 		synth.procPitchWheelOsc2Only(newValue);

  138. 		break;

  139. 	case BENDRANGE:

  140. 		synth.procPitchWheelAmount(newValue);

  141. 		break;

  142. 	case NOISEMIX:

  143. 		synth.processNoiseMix(newValue);

  144. 		break;

  145. 	case OCTAVE:

  146. 		synth.processOctave(newValue);

  147. 		break;

  148. 	case TUNE:

  149. 		synth.processTune(newValue);

  150. 		break;

  151. 	case BRIGHTNESS:

  152. 		synth.processBrightness(newValue);

  153. 		break;

  154. 	case MULTIMODE:

  155. 		synth.processMultimode(newValue);

  156. 		break;

  157. 	case LFOFREQ:

  158. 		synth.processLfoFrequency(newValue);

  159. 		break;

  160. 	case LFO1AMT:

  161. 		synth.processLfoAmt1(newValue);

  162. 		break;

  163. 	case LFO2AMT:

  164. 		synth.processLfoAmt2(newValue);

  165. 		break;

  166. 	case LFOSINWAVE:

  167. 		synth.processLfoSine(newValue);

  168. 		break;

  169. 	case LFOSQUAREWAVE:

  170. 		synth.processLfoSquare(newValue);

  171. 		break;

  172. 	case LFOSHWAVE:

  173. 		synth.processLfoSH(newValue);

  174. 		break;

  175. 	case LFOFILTER:

  176. 		synth.processLfoFilter(newValue);

  177. 		break;

  178. 	case LFOOSC1:

  179. 		synth.processLfoOsc1(newValue);

  180. 		break;

  181. 	case LFOOSC2:

  182. 		synth.processLfoOsc2(newValue);

  183. 		break;

  184. 	case LFOPW1:

  185. 		synth.processLfoPw1(newValue);

  186. 		break;

  187. 	case LFOPW2:

  188. 		synth.processLfoPw2(newValue);

  189. 		break;

  190. 	case PORTADER:

  191. 		synth.processPortamentoDetune(newValue);

  192. 		break;

  193. 	case FILTERDER:

  194. 		synth.processFilterDetune(newValue);

  195. 		break;

  196. 	case ENVDER:

  197. 		synth.processEnvelopeDetune(newValue);

  198. 		break;

  199. 	case XMOD:

  200. 		synth.processOsc2Xmod(newValue);

  201. 		break;

  202. 	case OSC2HS:

  203. 		synth.processOsc2HardSync(newValue);

  204. 		break;

  205. 	case OSC2P:

  206. 		synth.processOsc2Pitch(newValue);

  207. 		break;

  208. 	case OSC1P:

  209. 		synth.processOsc1Pitch(newValue);

  210. 		break;

  211. 	case PORTAMENTO:

  212. 		synth.processPortamento(newValue);

  213. 		break;

  214. 	case UNISON:

  215. 		synth.processUnison(newValue);

  216. 		break;

  217. 	case FLT_KF:

  218. 		synth.processFilterKeyFollow(newValue);

  219. 		break;

  220. 	case OSC1MIX:

  221. 		synth.processOsc1Mix(newValue);

  222. 		break;

  223. 	case OSC2MIX:

  224. 		synth.processOsc2Mix(newValue);

  225. 		break;

  226. 	case PW:

  227. 		synth.processPulseWidth(newValue);

  228. 		break;

  229. 	case OSC1Saw:

  230. 		synth.processOsc1Saw(newValue);

  231. 		break;

  232. 	case OSC2Saw:

  233. 		synth.processOsc2Saw(newValue);

  234. 		break;

  235. 	case OSC1Pul:

  236. 		synth.processOsc1Pulse(newValue);

  237. 		break;

  238. 	case OSC2Pul:

  239. 		synth.processOsc2Pulse(newValue);

  240. 		break;

  241. 	case VOLUME:

  242. 		synth.processVolume(newValue);

  243. 		break;

  244. 	case UDET:

  245. 		synth.processDetune(newValue);

  246. 		break;

  247. 	case OSC2_DET:

  248. 		synth.processOsc2Det(newValue);

  249. 		break;

  250. 	case CUTOFF:

  251. 		synth.processCutoff(newValue);

  252. 		break;

  253. 	case RESONANCE:

  254. 		synth.processResonance(newValue);

  255. 		break;

  256. 	case ENVELOPE_AMT:

  257. 		synth.processFilterEnvelopeAmt(newValue);

  258. 		break;

  259. 	case LATK:

  260. 		synth.processLoudnessEnvelopeAttack(newValue);

  261. 		break;

  262. 	case LDEC:

  263. 		synth.processLoudnessEnvelopeDecay(newValue);

  264. 		break;

  265. 	case LSUS:

  266. 		synth.processLoudnessEnvelopeSustain(newValue);

  267. 		break;

  268. 	case LREL:

  269. 		synth.processLoudnessEnvelopeRelease(newValue);

  270. 		break;

  271. 	case FATK:

  272. 		synth.processFilterEnvelopeAttack(newValue);

  273. 		break;

  274. 	case FDEC:

  275. 		synth.processFilterEnvelopeDecay(newValue);

  276. 		break;

  277. 	case FSUS:

  278. 		synth.processFilterEnvelopeSustain(newValue);

  279. 		break;

  280. 	case FREL:

  281. 		synth.processFilterEnvelopeRelease(newValue);

  282. 		break;

  283. 	case PAN1:

  284. 		synth.processPan(newValue,1);

  285. 		break;

  286. 	case PAN2:

  287. 		synth.processPan(newValue,2);

  288. 		break;

  289. 	case PAN3:

  290. 		synth.processPan(newValue,3);

  291. 		break;

  292. 	case PAN4:

  293. 		synth.processPan(newValue,4);

  294. 		break;

  295. 	case PAN5:

  296. 		synth.processPan(newValue,5);

  297. 		break;

  298. 	case PAN6:

  299. 		synth.processPan(newValue,6);

  300. 		break;

  301. 	case PAN7:

  302. 		synth.processPan(newValue,7);

  303. 		break;

  304. 	case PAN8:

  305. 		synth.processPan(newValue,8);

  306. 		break;

  307. 	}

  308. 	//DIRTY HACK

  309. 	//This should be checked to avoid stalling on gui update

  310. 	//It is needed because some hosts do  wierd stuff

  311. 	if(isHostAutomatedChange)

  312. 		sendChangeMessage();

  313. }

  314. 

  315. const String ObxdAudioProcessor::getParameterName (int index)

  316. {

  317. 	switch(index)

  318. 	{

  319. 	case SELF_OSC_PUSH:

  320. 		return S("SelfOscPush");

  321. 	case ENV_PITCH_BOTH:

  322. 		return S("EnvPitchBoth");

  323. 	case FENV_INVERT:

  324. 		return S("FenvInvert");

  325. 	case PW_OSC2_OFS:

  326. 		return S("PwOfs");

  327. 	case LEVEL_DIF:

  328. 		return S("LevelDif");

  329. 	case PW_ENV_BOTH:

  330. 		return S("PwEnvBoth");

  331. 	case PW_ENV:

  332. 		return S("PwEnv");

  333. 	case LFO_SYNC:

  334. 		return S("LfoSync");

  335. 	case ECONOMY_MODE:

  336. 		return S("EconomyMode");

  337. 	case UNUSED_1:

  338. 		return S("Unused 1");

  339. 	case UNUSED_2:

  340. 		return S("Unused 2");

  341. 	case VAMPENV:

  342. 		return S("VAmpFactor");

  343. 	case VFLTENV:

  344. 		return S("VFltFactor");

  345. 	case ASPLAYEDALLOCATION:

  346. 		return S("AsPlayedAllocation");

  347. 	case BENDLFORATE:

  348. 		return S("VibratoRate");

  349. 	case FOURPOLE:

  350. 		return S("FourPole");

  351. 	case LEGATOMODE:

  352. 		return S("LegatoMode");

  353. 	case ENVPITCH:

  354. 		return S("EnvelopeToPitch");

  355. 	case OSCQuantize:

  356. 		return S("PitchQuant");

  357. 	case VOICE_COUNT:

  358. 		return S("VoiceCount");

  359. 	case BANDPASS:

  360. 		return S("BandpassBlend");

  361. 	case FILTER_WARM:

  362. 		return S("Filter_Warm");

  363. 	case BENDRANGE:

  364. 		return S("BendRange");

  365. 	case BENDOSC2:

  366. 		return S("BendOsc2Only");

  367. 	case OCTAVE:

  368. 		return S("Octave");

  369. 	case TUNE:

  370. 		return S("Tune");

  371. 	case BRIGHTNESS:

  372. 		return S("Brightness");

  373. 	case NOISEMIX:

  374. 		return S("NoiseMix");

  375. 	case OSC1MIX:

  376. 		return S("Osc1Mix");

  377. 	case OSC2MIX:

  378. 		return S("Osc2Mix");

  379. 	case MULTIMODE:

  380. 		return S("Multimode");

  381. 	case LFOSHWAVE:

  382. 		return S("LfoSampleHoldWave");

  383. 	case LFOSINWAVE:

  384. 		return S("LfoSineWave");

  385. 	case LFOSQUAREWAVE:

  386. 		return S("LfoSquareWave");

  387. 	case LFO1AMT:

  388. 		return S("LfoAmount1");

  389. 	case LFO2AMT:

  390. 		return S("LfoAmount2");

  391. 	case LFOFILTER:

  392. 		return S("LfoFilter");

  393. 	case LFOOSC1:

  394. 		return S("LfoOsc1");

  395. 	case LFOOSC2:

  396. 		return S("LfoOsc2");

  397. 	case LFOFREQ:

  398. 		return S("LfoFrequency");

  399. 	case LFOPW1:

  400. 		return S("LfoPw1");

  401. 	case LFOPW2:

  402. 		return S("LfoPw2");

  403. 	case PORTADER:

  404. 		return S("PortamentoDetune");

  405. 	case FILTERDER:

  406. 		return S("FilterDetune");

  407. 	case ENVDER:

  408. 		return S("EnvelopeDetune");

  409. 	case PAN1:

  410. 		return S("Pan1");

  411. 	case PAN2:

  412. 		return S("Pan2");

  413. 	case PAN3:

  414. 		return S("Pan3");

  415. 	case PAN4:

  416. 		return S("Pan4");

  417. 	case PAN5:

  418. 		return S("Pan5");

  419. 	case PAN6:

  420. 		return S("Pan6");

  421. 	case PAN7:

  422. 		return S("Pan7");

  423. 	case PAN8:

  424. 		return S("Pan8");

  425. 	case XMOD:

  426. 		return S("Xmod");

  427. 	case OSC2HS:

  428. 		return S("Osc2HardSync");

  429. 	case OSC1P:

  430. 		return S("Osc1Pitch");

  431. 	case OSC2P:

  432. 		return S("Osc2Pitch");

  433. 	case PORTAMENTO:

  434. 		return S("Portamento");

  435. 	case UNISON:

  436. 		return S("Unison");

  437. 	case FLT_KF:

  438. 		return S("FilterKeyFollow");

  439. 	case PW:

  440. 		return S("PulseWidth");

  441. 	case OSC2Saw:

  442. 		return S("Osc2Saw");

  443. 	case OSC1Saw:

  444. 		return S("Osc1Saw");

  445. 	case OSC1Pul:

  446. 		return S("Osc1Pulse");

  447. 	case OSC2Pul:

  448. 		return S("Osc2Pulse");

  449. 	case VOLUME:

  450. 		return S("Volume");

  451. 	case UDET:

  452. 		return S("VoiceDetune");

  453. 	case OSC2_DET:

  454. 		return S("Oscillator2detune");

  455. 	case CUTOFF:

  456. 		return S("Cutoff");

  457. 	case RESONANCE:

  458. 		return S("Resonance");

  459. 	case ENVELOPE_AMT:

  460. 		return S("FilterEnvAmount");

  461. 	case LATK:

  462. 		return S("Attack");

  463. 	case LDEC:

  464. 		return S("Decay");

  465. 	case LSUS:

  466. 		return S("Sustain");

  467. 	case LREL:

  468. 		return S("Release");

  469. 	case FATK:

  470. 		return S("FilterAttack");

  471. 	case FDEC:

  472. 		return S("FilterDecay");

  473. 	case FSUS:

  474. 		return S("FilterSustain");

  475. 	case FREL:

  476. 		return S("FilterRelease");

  477. 	}

  478. 	return String();

  479. }

  480. 

  481. const String ObxdAudioProcessor::getParameterText (int index)

  482. {

  483. 	return String(programs.currentProgramPtr->values[index],2);

  484. }

  485. 

  486. //==============================================================================

  487. const String ObxdAudioProcessor::getName() const

  488. {

  489. 	return JucePlugin_Name;

  490. }

  491. 

  492. const String ObxdAudioProcessor::getInputChannelName (int channelIndex) const

  493. {

  494. 	return String (channelIndex + 1);

  495. }

  496. 

  497. const String ObxdAudioProcessor::getOutputChannelName (int channelIndex) const

  498. {

  499. 	return String (channelIndex + 1);

  500. }

  501. 

  502. bool ObxdAudioProcessor::isInputChannelStereoPair (int index) const

  503. {

  504. 	return true;

  505. }

  506. 

  507. bool ObxdAudioProcessor::isOutputChannelStereoPair (int index) const

  508. {

  509. 	return true;

  510. }

  511. 

  512. bool ObxdAudioProcessor::acceptsMidi() const

  513. {

  514. #if JucePlugin_WantsMidiInput

  515. 	return true;

  516. #else

  517. 	return false;

  518. #endif

  519. }

  520. 

  521. bool ObxdAudioProcessor::producesMidi() const

  522. {

  523. #if JucePlugin_ProducesMidiOutput

  524. 	return true;

  525. #else

  526. 	return false;

  527. #endif

  528. }

  529. 

  530. bool ObxdAudioProcessor::silenceInProducesSilenceOut() const

  531. {

  532. 	return false;

  533. }

  534. 

  535. double ObxdAudioProcessor::getTailLengthSeconds() const

  536. {

  537. 	return 0.0;

  538. }

  539. 

  540. //==============================================================================

  541. int ObxdAudioProcessor::getNumPrograms()

  542. {

  543. 	return PROGRAMCOUNT;

  544. }

  545. 

  546. int ObxdAudioProcessor::getCurrentProgram()

  547. {

  548. 	return programs.currentProgram;

  549. }

  550. 

  551. void ObxdAudioProcessor::setCurrentProgram (int index)

  552. {

  553. 	programs.currentProgram = index;

  554. 	programs.currentProgramPtr = programs.programs + programs.currentProgram;

  555. 	isHostAutomatedChange = false;

  556. 	for(int i = 0 ; i < PARAM_COUNT;i++)

  557. 		setParameter(i,programs.currentProgramPtr->values[i]);

  558. 	isHostAutomatedChange = true;

  559. 	sendChangeMessage();

  560. 	updateHostDisplay();

  561. }

  562. 

  563. const String ObxdAudioProcessor::getProgramName (int index)

  564. {

  565. 	return programs.programs[index].name;

  566. }

  567. 

  568. void ObxdAudioProcessor::changeProgramName (int index, const String& newName)

  569. {

  570. 	 programs.programs[index].name = newName;

  571. }

  572. 

  573. //==============================================================================

  574. void ObxdAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)

  575. {

  576. 	// Use this method as the place to do any pre-playback

  577. 	// initialisation that you need..

  578. 	nextMidi = MidiMessage(0xF0);

  579. 	midiMsg  = MidiMessage(0xF0);

  580. 	synth.setSampleRate(sampleRate);

  581. }

  582. 

  583. void ObxdAudioProcessor::releaseResources()

  584. {

  585. 

  586. }

  587. 

  588. inline void ObxdAudioProcessor::processMidiPerSample(MidiBuffer::Iterator* iter,const int samplePos)

  589. {

  590. 	while (getNextEvent(iter, samplePos))

  591. 	{

  592. 		if(midiMsg.isNoteOn())

  593. 		{

  594. 			synth.procNoteOn(midiMsg.getNoteNumber(),midiMsg.getFloatVelocity());

  595. 		}

  596. 		if (midiMsg.isNoteOff())

  597. 		{

  598. 			synth.procNoteOff(midiMsg.getNoteNumber());

  599. 		}

  600. 		if(midiMsg.isPitchWheel())

  601. 		{

  602. 			// [0..16383] center = 8192;

  603. 			synth.procPitchWheel((midiMsg.getPitchWheelValue()-8192) / 8192.0);

  604. 		}

  605. 		if(midiMsg.isController() && midiMsg.getControllerNumber()==1)

  606. 			synth.procModWheel(midiMsg.getControllerValue() / 127.0);

  607. 		if(midiMsg.isSustainPedalOn())

  608. 		{

  609. 			synth.sustainOn();

  610. 		}

  611. 		if(midiMsg.isSustainPedalOff() || midiMsg.isAllNotesOff()||midiMsg.isAllSoundOff())

  612. 		{

  613. 			synth.sustainOff();

  614. 		}

  615. 		if(midiMsg.isAllNotesOff())

  616. 		{

  617. 			synth.allNotesOff();

  618. 		}

  619. 		if(midiMsg.isAllSoundOff())

  620. 		{

  621. 			synth.allSoundOff();

  622. 		}

  623. 

  624. 	}

  625. }

  626. 

  627. bool ObxdAudioProcessor::getNextEvent(MidiBuffer::Iterator* iter,const int samplePos)

  628. {

  629. 	if (hasMidiMessage && midiEventPos <= samplePos)

  630. 	{

  631. 		midiMsg = nextMidi;

  632. 		hasMidiMessage = iter->getNextEvent(nextMidi, midiEventPos);

  633. 		return true;

  634. 	} 

  635. 	return false;

  636. }

  637. 

  638. void ObxdAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)

  639. {

  640. 	MidiBuffer::Iterator ppp(midiMessages);

  641. 	hasMidiMessage = ppp.getNextEvent(nextMidi,midiEventPos);

  642. 

  643. 	int samplePos = 0;

  644. 	int numSamples = buffer.getNumSamples();

  645. 	float* channelData1 = buffer.getWritePointer(0);

  646. 	float* channelData2 = buffer.getWritePointer(1);

  647. 

  648. 	AudioPlayHead::CurrentPositionInfo pos;

  649.     if (getPlayHead() != 0 && getPlayHead()->getCurrentPosition (pos))

  650.     {

  651. 		synth.setPlayHead(pos.bpm,pos.ppqPosition);

  652.     }

  653. 

  654. 	while (samplePos < numSamples)

  655. 	{

  656. 		processMidiPerSample(&ppp,samplePos);

  657. 

  658. 		synth.processSample(channelData1+samplePos,channelData2+samplePos);

  659. 

  660. 		samplePos++;

  661. 	}

  662. }

  663. 

  664. //==============================================================================

  665. bool ObxdAudioProcessor::hasEditor() const

  666. {

  667. 	return true;

  668. }

  669. 

  670. AudioProcessorEditor* ObxdAudioProcessor::createEditor()

  671. {

  672. 	return new ObxdAudioProcessorEditor (this);

  673. }

  674. 

  675. //==============================================================================

  676. void ObxdAudioProcessor::getStateInformation (MemoryBlock& destData)

  677. {

  678. 	XmlElement xmlState = XmlElement("Datsounds");

  679. 	xmlState.setAttribute(S("currentProgram"), programs.currentProgram);

  680. 

  681. 	XmlElement* xprogs = new XmlElement("programs");

  682. 	for (int i = 0; i < PROGRAMCOUNT; ++i)

  683. 	{

  684. 		XmlElement* xpr = new XmlElement("program");

  685. 		xpr->setAttribute(S("programName"), programs.programs[i].name);

  686. 

  687. 		for (int k = 0; k < PARAM_COUNT; ++k)

  688. 		{

  689. 			xpr->setAttribute(String(k), programs.programs[i].values[k]);

  690. 		}

  691. 

  692. 		xprogs->addChildElement(xpr);

  693. 	}

  694. 

  695. 	xmlState.addChildElement(xprogs);

  696. 

  697. 	copyXmlToBinary(xmlState,destData);

  698. }

  699. 

  700. void ObxdAudioProcessor::setStateInformation (const void* data, int sizeInBytes)

  701. {

  702. 	if (XmlElement* const xmlState = getXmlFromBinary(data,sizeInBytes))

  703. 	{

  704. 		XmlElement* xprogs = xmlState->getFirstChildElement();

  705. 		if (xprogs->hasTagName(S("programs")))

  706. 		{

  707. 			int i = 0;

  708. 			forEachXmlChildElement(*xprogs, e)

  709. 			{

  710. 				programs.programs[i].setDefaultValues();

  711. 

  712. 				for (int k = 0; k < PARAM_COUNT; ++k)

  713. 				{

  714. 					programs.programs[i].values[k] = e->getDoubleAttribute(String(k), programs.programs[i].values[k]);

  715. 				}

  716. 

  717. 				programs.programs[i].name = e->getStringAttribute(S("programName"), S("Default"));

  718. 

  719. 				++i;

  720. 			}

  721. 		}

  722. 

  723. 		setCurrentProgram(xmlState->getIntAttribute(S("currentProgram"), 0));

  724. 

  725. 		delete xmlState;

  726. 	}

  727. }

  728. 

  729. void  ObxdAudioProcessor::setCurrentProgramStateInformation(const void* data,int sizeInBytes)

  730. {

  731. 	if (XmlElement* const e = getXmlFromBinary(data, sizeInBytes))

  732. 	{

  733. 		programs.currentProgramPtr->setDefaultValues();

  734. 

  735. 		for (int k = 0; k < PARAM_COUNT; ++k)

  736. 		{

  737. 			programs.currentProgramPtr->values[k] = e->getDoubleAttribute(String(k), programs.currentProgramPtr->values[k]);

  738. 		}

  739. 

  740. 		programs.currentProgramPtr->name =  e->getStringAttribute(S("programName"), S("Default"));

  741. 

  742. 		setCurrentProgram(programs.currentProgram);

  743. 

  744. 		delete e;

  745. 	}

  746. }

  747. 

  748. void ObxdAudioProcessor::getCurrentProgramStateInformation(MemoryBlock& destData)

  749. {

  750. 	XmlElement xmlState = XmlElement("Datsounds");

  751. 

  752. 	for (int k = 0; k < PARAM_COUNT; ++k)

  753. 	{

  754. 		xmlState.setAttribute(String(k), programs.currentProgramPtr->values[k]);

  755. 	}

  756. 

  757. 	xmlState.setAttribute(S("programName"), programs.currentProgramPtr->name);

  758. 

  759. 	copyXmlToBinary(xmlState, destData);

  760. }

  761. 

  762. //==============================================================================

  763. bool ObxdAudioProcessor::loadFromFXBFile(const File& fxbFile)

  764. {

  765. 	MemoryBlock mb;

  766. 	if (! fxbFile.loadFileAsData(mb))

  767. 		return false;

  768. 

  769. 	const void* const data = mb.getData();

  770. 	const size_t dataSize = mb.getSize();

  771. 

  772. 	if (dataSize < 28)

  773. 		return false;

  774. 

  775. 	const fxSet* const set = (const fxSet*) data;

  776. 

  777. 	if ((! compareMagic (set->chunkMagic, "CcnK")) || fxbSwap (set->version) > fxbVersionNum)

  778. 		return false;

  779. 

  780. 	if (compareMagic (set->fxMagic, "FxBk"))

  781. 	{

  782. 		// bank of programs

  783. 		if (fxbSwap (set->numPrograms) >= 0)

  784. 		{

  785. 			const int oldProg = getCurrentProgram();

  786. 			const int numParams = fxbSwap (((const fxProgram*) (set->programs))->numParams);

  787. 			const int progLen = (int) sizeof (fxProgram) + (numParams - 1) * (int) sizeof (float);

  788. 

  789. 			for (int i = 0; i < fxbSwap (set->numPrograms); ++i)

  790. 			{

  791. 				if (i != oldProg)

  792. 				{

  793. 					const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + i * progLen);

  794. 					if (((const char*) prog) - ((const char*) set) >= (ssize_t) dataSize)

  795. 						return false;

  796. 

  797. 					if (fxbSwap (set->numPrograms) > 0)

  798. 						setCurrentProgram (i);

  799. 

  800. 					if (! restoreProgramSettings (prog))

  801. 						return false;

  802. 				}

  803. 			}

  804. 

  805. 			if (fxbSwap (set->numPrograms) > 0)

  806. 				setCurrentProgram (oldProg);

  807. 

  808. 			const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + oldProg * progLen);

  809. 			if (((const char*) prog) - ((const char*) set) >= (ssize_t) dataSize)

  810. 				return false;

  811. 

  812. 			if (! restoreProgramSettings (prog))

  813. 				return false;

  814. 		}

  815. 	}

  816. 	else if (compareMagic (set->fxMagic, "FxCk"))

  817. 	{

  818. 		// single program

  819. 		const fxProgram* const prog = (const fxProgram*) data;

  820. 

  821. 		if (! compareMagic (prog->chunkMagic, "CcnK"))

  822. 			return false;

  823. 

  824. 		changeProgramName (getCurrentProgram(), prog->prgName);

  825. 

  826. 		for (int i = 0; i < fxbSwap (prog->numParams); ++i)

  827. 			setParameter (i, fxbSwapFloat (prog->params[i]));

  828. 	}

  829. 	else if (compareMagic (set->fxMagic, "FBCh"))

  830. 	{

  831. 		// non-preset chunk

  832. 		const fxChunkSet* const cset = (const fxChunkSet*) data;

  833. 

  834. 		if ((size_t) fxbSwap (cset->chunkSize) + sizeof (fxChunkSet) - 8 > (size_t) dataSize)

  835. 			return false;

  836. 

  837. 		setStateInformation(cset->chunk, fxbSwap (cset->chunkSize));

  838. 	}

  839. 	else if (compareMagic (set->fxMagic, "FPCh"))

  840. 	{

  841. 		// preset chunk

  842. 		const fxProgramSet* const cset = (const fxProgramSet*) data;

  843. 

  844. 		if ((size_t) fxbSwap (cset->chunkSize) + sizeof (fxProgramSet) - 8 > (size_t) dataSize)

  845. 			return false;

  846. 

  847. 		setCurrentProgramStateInformation(cset->chunk, fxbSwap (cset->chunkSize));

  848. 

  849. 		changeProgramName (getCurrentProgram(), cset->name);

  850. 	}

  851. 	else

  852. 	{

  853. 		return false;

  854. 	}

  855. 

  856. 	currentBank = fxbFile.getFileName();

  857. 

  858. 	updateHostDisplay();

  859. 

  860. 	return true;

  861. }

  862. 

  863. bool ObxdAudioProcessor::restoreProgramSettings(const fxProgram* const prog)

  864. {

  865. 	if (compareMagic (prog->chunkMagic, "CcnK")

  866. 		&& compareMagic (prog->fxMagic, "FxCk"))

  867. 	{

  868. 		changeProgramName (getCurrentProgram(), prog->prgName);

  869. 

  870. 		for (int i = 0; i < fxbSwap (prog->numParams); ++i)

  871. 			setParameter (i, fxbSwapFloat (prog->params[i]));

  872. 

  873. 		return true;

  874. 	}

  875. 

  876. 	return false;

  877. }

  878. 

  879. //==============================================================================

  880. void ObxdAudioProcessor::scanAndUpdateBanks()

  881. {

  882. 	bankFiles.clearQuick();

  883. 

  884. 	DirectoryIterator it(getBanksFolder(), false, "*.fxb", File::findFiles);

  885. 	while (it.next())

  886. 	{

  887. 		bankFiles.add(it.getFile());

  888. 	}

  889. }

  890. 

  891. const Array<File>& ObxdAudioProcessor::getBankFiles() const

  892. {

  893. 	return bankFiles;

  894. }

  895. 

  896. File ObxdAudioProcessor::getCurrentBankFile() const

  897. {

  898. 	return getBanksFolder().getChildFile(currentBank);

  899. }

  900. 

  901. //==============================================================================

  902. File ObxdAudioProcessor::getDocumentFolder() const

  903. {

  904. 	File folder = File::getSpecialLocation(File::userDocumentsDirectory).getChildFile("discoDSP").getChildFile("OB-Xd");

  905. 	if (folder.isSymbolicLink())

  906. 		folder = folder.getLinkedTarget();

  907. 	return folder;

  908. }

  909. 

  910. File ObxdAudioProcessor::getSkinFolder() const

  911. {

  912. 	return getDocumentFolder().getChildFile("Skins");

  913. }

  914. 

  915. File ObxdAudioProcessor::getBanksFolder() const

  916. {

  917. 	return getDocumentFolder().getChildFile("Banks");

  918. }

  919. 

  920. File ObxdAudioProcessor::getCurrentSkinFolder() const

  921. {

  922. 	return getSkinFolder().getChildFile(currentSkin);

  923. }

  924. 

  925. void ObxdAudioProcessor::setCurrentSkinFolder(const String& folderName)

  926. {

  927. 	currentSkin = folderName;

  928. 

  929. 	config->setValue("skin", folderName);

  930. 	config->setNeedsToBeSaved(true);

  931. }

  932. 

  933. //==============================================================================

  934. // This creates new instances of the plugin..

  935. AudioProcessor* JUCE_CALLTYPE createPluginFilter()

  936. {

  937. 	return new ObxdAudioProcessor();

  938. }