OB-Xd/Source/PluginProcessor.cpp

/*
==============================================================================

This file was auto-generated!

It contains the basic startup code for a Juce application.

==============================================================================
*/
#include "PluginProcessor.h"
#include "PluginEditor.h"
#include "Engine/Params.h"

// Compare JUCE_VERSION against this to check for JUCE 5.4.3 and earlier
#define JUCE_543 328707

//only sse2 version on windows
#ifdef _WINDOWS
#define __SSE2__
#define __SSE__
#endif

#ifdef __SSE2__
#include <xmmintrin.h>
#endif

//==============================================================================
#define S(T) (juce::String(T))

//==============================================================================
ObxdAudioProcessor::ObxdAudioProcessor()
	: bindings()
	, programs()
	, configLock("__" JucePlugin_Name "ConfigLock__")
{
	isHostAutomatedChange = true;
	midiControlledParamSet = false;
	lastMovedController = 0;
	lastUsedParameter = 0;

	synth.setSampleRate(44100);

	PropertiesFile::Options options;
	options.applicationName = JucePlugin_Name;
	options.storageFormat = PropertiesFile::storeAsXML;
	options.millisecondsBeforeSaving = 2500;
	options.processLock = &configLock;
	config = new PropertiesFile(getDocumentFolder().getChildFile("Settings.xml"), options);

	currentSkin = config->containsKey("skin") ? config->getValue("skin") : "discoDSP Blue";
	currentBank = "Init";

	scanAndUpdateBanks();
	initAllParams();

	if (bankFiles.size() > 0)
	{
		loadFromFXBFile(bankFiles[0]);
	}
}

ObxdAudioProcessor::~ObxdAudioProcessor()
{
	config->saveIfNeeded();
	config = nullptr;
}

//==============================================================================
void ObxdAudioProcessor::initAllParams()
{
	for (int i = 0 ; i < PARAM_COUNT; i++)
	{
		setParameter(i, programs.currentProgramPtr->values[i]);
	}
}

//==============================================================================
int ObxdAudioProcessor::getNumParameters()
{
	return PARAM_COUNT;
}

float ObxdAudioProcessor::getParameter (int index)
{
	return programs.currentProgramPtr->values[index];
}

void ObxdAudioProcessor::setParameter (int index, float newValue)
{
	if(!midiControlledParamSet || index==MIDILEARN || index==UNLEARN)
		lastUsedParameter = index;
	programs.currentProgramPtr->values[index] = newValue;
	switch(index)
	{
	case SELF_OSC_PUSH:
		synth.processSelfOscPush(newValue);
		break;
	case PW_ENV_BOTH:
		synth.processPwEnvBoth(newValue);
		break;
	case PW_OSC2_OFS:
		synth.processPwOfs(newValue);
		break;
	case ENV_PITCH_BOTH:
		synth.processPitchModBoth(newValue);
		break;
	case FENV_INVERT:
		synth.processInvertFenv(newValue);
		break;
	case LEVEL_DIF:
		synth.processLoudnessDetune(newValue);
		break;
	case PW_ENV:
		synth.processPwEnv(newValue);
		break;
	case LFO_SYNC:
		synth.procLfoSync(newValue);
		break;
	case ECONOMY_MODE:
		synth.procEconomyMode(newValue);
		break;
	case VAMPENV:
		synth.procAmpVelocityAmount(newValue);
		break;
	case VFLTENV:
		synth.procFltVelocityAmount(newValue);
		break;
	case ASPLAYEDALLOCATION:
		synth.procAsPlayedAlloc(newValue);
		break;
	case BENDLFORATE:
		synth.procModWheelFrequency(newValue);
		break;
	case FOURPOLE:
		synth.processFourPole(newValue);
		break;
	case LEGATOMODE:
		synth.processLegatoMode(newValue);
		break;
	case ENVPITCH:
		synth.processEnvelopeToPitch(newValue);
		break;
	case OSCQuantize:
		synth.processPitchQuantization(newValue);
		break;
	case VOICE_COUNT:
		synth.setVoiceCount(newValue);
		break;
	case BANDPASS:
		synth.processBandpassSw(newValue);
		break;
	case FILTER_WARM:
		synth.processOversampling(newValue);
		break;
	case BENDOSC2:
		synth.procPitchWheelOsc2Only(newValue);
		break;
	case BENDRANGE:
		synth.procPitchWheelAmount(newValue);
		break;
	case NOISEMIX:
		synth.processNoiseMix(newValue);
		break;
	case OCTAVE:
		synth.processOctave(newValue);
		break;
	case TUNE:
		synth.processTune(newValue);
		break;
	case BRIGHTNESS:
		synth.processBrightness(newValue);
		break;
	case MULTIMODE:
		synth.processMultimode(newValue);
		break;
	case LFOFREQ:
		synth.processLfoFrequency(newValue);
		break;
	case LFO1AMT:
		synth.processLfoAmt1(newValue);
		break;
	case LFO2AMT:
		synth.processLfoAmt2(newValue);
		break;
	case LFOSINWAVE:
		synth.processLfoSine(newValue);
		break;
	case LFOSQUAREWAVE:
		synth.processLfoSquare(newValue);
		break;
	case LFOSHWAVE:
		synth.processLfoSH(newValue);
		break;
	case LFOFILTER:
		synth.processLfoFilter(newValue);
		break;
	case LFOOSC1:
		synth.processLfoOsc1(newValue);
		break;
	case LFOOSC2:
		synth.processLfoOsc2(newValue);
		break;
	case LFOPW1:
		synth.processLfoPw1(newValue);
		break;
	case LFOPW2:
		synth.processLfoPw2(newValue);
		break;
	case PORTADER:
		synth.processPortamentoDetune(newValue);
		break;
	case FILTERDER:
		synth.processFilterDetune(newValue);
		break;
	case ENVDER:
		synth.processEnvelopeDetune(newValue);
		break;
	case XMOD:
		synth.processOsc2Xmod(newValue);
		break;
	case OSC2HS:
		synth.processOsc2HardSync(newValue);
		break;
	case OSC2P:
		synth.processOsc2Pitch(newValue);
		break;
	case OSC1P:
		synth.processOsc1Pitch(newValue);
		break;
	case PORTAMENTO:
		synth.processPortamento(newValue);
		break;
	case UNISON:
		synth.processUnison(newValue);
		break;
	case FLT_KF:
		synth.processFilterKeyFollow(newValue);
		break;
	case OSC1MIX:
		synth.processOsc1Mix(newValue);
		break;
	case OSC2MIX:
		synth.processOsc2Mix(newValue);
		break;
	case PW:
		synth.processPulseWidth(newValue);
		break;
	case OSC1Saw:
		synth.processOsc1Saw(newValue);
		break;
	case OSC2Saw:
		synth.processOsc2Saw(newValue);
		break;
	case OSC1Pul:
		synth.processOsc1Pulse(newValue);
		break;
	case OSC2Pul:
		synth.processOsc2Pulse(newValue);
		break;
	case VOLUME:
		synth.processVolume(newValue);
		break;
	case UDET:
		synth.processDetune(newValue);
		break;
	case OSC2_DET:
		synth.processOsc2Det(newValue);
		break;
	case CUTOFF:
		synth.processCutoff(newValue);
		break;
	case RESONANCE:
		synth.processResonance(newValue);
		break;
	case ENVELOPE_AMT:
		synth.processFilterEnvelopeAmt(newValue);
		break;
	case LATK:
		synth.processLoudnessEnvelopeAttack(newValue);
		break;
	case LDEC:
		synth.processLoudnessEnvelopeDecay(newValue);
		break;
	case LSUS:
		synth.processLoudnessEnvelopeSustain(newValue);
		break;
	case LREL:
		synth.processLoudnessEnvelopeRelease(newValue);
		break;
	case FATK:
		synth.processFilterEnvelopeAttack(newValue);
		break;
	case FDEC:
		synth.processFilterEnvelopeDecay(newValue);
		break;
	case FSUS:
		synth.processFilterEnvelopeSustain(newValue);
		break;
	case FREL:
		synth.processFilterEnvelopeRelease(newValue);
		break;
	case PAN1:
		synth.processPan(newValue,1);
		break;
	case PAN2:
		synth.processPan(newValue,2);
		break;
	case PAN3:
		synth.processPan(newValue,3);
		break;
	case PAN4:
		synth.processPan(newValue,4);
		break;
	case PAN5:
		synth.processPan(newValue,5);
		break;
	case PAN6:
		synth.processPan(newValue,6);
		break;
	case PAN7:
		synth.processPan(newValue,7);
		break;
	case PAN8:
		synth.processPan(newValue,8);
		break;
	}
	//DIRTY HACK
	//This should be checked to avoid stalling on gui update
	//It is needed because some hosts do  wierd stuff
	if(isHostAutomatedChange)
		sendChangeMessage();
}

const String ObxdAudioProcessor::getParameterName (int index)
{
	switch(index)
	{
	case SELF_OSC_PUSH:
		return S("SelfOscPush");
	case ENV_PITCH_BOTH:
		return S("EnvPitchBoth");
	case FENV_INVERT:
		return S("FenvInvert");
	case PW_OSC2_OFS:
		return S("PwOfs");
	case LEVEL_DIF:
		return S("LevelDif");
	case PW_ENV_BOTH:
		return S("PwEnvBoth");
	case PW_ENV:
		return S("PwEnv");
	case LFO_SYNC:
		return S("LfoSync");
	case ECONOMY_MODE:
		return S("EconomyMode");
	case UNLEARN:
		return S("MidiUnlearn");
	case MIDILEARN:
		return S("MidiLearn");
	case VAMPENV:
		return S("VAmpFactor");
	case VFLTENV:
		return S("VFltFactor");
	case ASPLAYEDALLOCATION:
		return S("AsPlayedAllocation");
	case BENDLFORATE:
		return S("VibratoRate");
	case FOURPOLE:
		return S("FourPole");
	case LEGATOMODE:
		return S("LegatoMode");
	case ENVPITCH:
		return S("EnvelopeToPitch");
	case OSCQuantize:
		return S("PitchQuant");
	case VOICE_COUNT:
		return S("VoiceCount");
	case BANDPASS:
		return S("BandpassBlend");
	case FILTER_WARM:
		return S("Filter_Warm");
	case BENDRANGE:
		return S("BendRange");
	case BENDOSC2:
		return S("BendOsc2Only");
	case OCTAVE:
		return S("Octave");
	case TUNE:
		return S("Tune");
	case BRIGHTNESS:
		return S("Brightness");
	case NOISEMIX:
		return S("NoiseMix");
	case OSC1MIX:
		return S("Osc1Mix");
	case OSC2MIX:
		return S("Osc2Mix");
	case MULTIMODE:
		return S("Multimode");
	case LFOSHWAVE:
		return S("LfoSampleHoldWave");
	case LFOSINWAVE:
		return S("LfoSineWave");
	case LFOSQUAREWAVE:
		return S("LfoSquareWave");
	case LFO1AMT:
		return S("LfoAmount1");
	case LFO2AMT:
		return S("LfoAmount2");
	case LFOFILTER:
		return S("LfoFilter");
	case LFOOSC1:
		return S("LfoOsc1");
	case LFOOSC2:
		return S("LfoOsc2");
	case LFOFREQ:
		return S("LfoFrequency");
	case LFOPW1:
		return S("LfoPw1");
	case LFOPW2:
		return S("LfoPw2");
	case PORTADER:
		return S("PortamentoDetune");
	case FILTERDER:
		return S("FilterDetune");
	case ENVDER:
		return S("EnvelopeDetune");
	case PAN1:
		return S("Pan1");
	case PAN2:
		return S("Pan2");
	case PAN3:
		return S("Pan3");
	case PAN4:
		return S("Pan4");
	case PAN5:
		return S("Pan5");
	case PAN6:
		return S("Pan6");
	case PAN7:
		return S("Pan7");
	case PAN8:
		return S("Pan8");
	case XMOD:
		return S("Xmod");
	case OSC2HS:
		return S("Osc2HardSync");
	case OSC1P:
		return S("Osc1Pitch");
	case OSC2P:
		return S("Osc2Pitch");
	case PORTAMENTO:
		return S("Portamento");
	case UNISON:
		return S("Unison");
	case FLT_KF:
		return S("FilterKeyFollow");
	case PW:
		return S("PulseWidth");
	case OSC2Saw:
		return S("Osc2Saw");
	case OSC1Saw:
		return S("Osc1Saw");
	case OSC1Pul:
		return S("Osc1Pulse");
	case OSC2Pul:
		return S("Osc2Pulse");
	case VOLUME:
		return S("Volume");
	case UDET:
		return S("VoiceDetune");
	case OSC2_DET:
		return S("Oscillator2detune");
	case CUTOFF:
		return S("Cutoff");
	case RESONANCE:
		return S("Resonance");
	case ENVELOPE_AMT:
		return S("FilterEnvAmount");
	case LATK:
		return S("Attack");
	case LDEC:
		return S("Decay");
	case LSUS:
		return S("Sustain");
	case LREL:
		return S("Release");
	case FATK:
		return S("FilterAttack");
	case FDEC:
		return S("FilterDecay");
	case FSUS:
		return S("FilterSustain");
	case FREL:
		return S("FilterRelease");
	}
    return {};
}

const String ObxdAudioProcessor::getParameterText (int index)
{
	return String(programs.currentProgramPtr->values[index],2);
}

//==============================================================================
const String ObxdAudioProcessor::getName() const
{
	return JucePlugin_Name;
}

const String ObxdAudioProcessor::getInputChannelName (int channelIndex) const
{
	return String (channelIndex + 1);
}

const String ObxdAudioProcessor::getOutputChannelName (int channelIndex) const
{
	return String (channelIndex + 1);
}

bool ObxdAudioProcessor::isInputChannelStereoPair (int index) const
{
	return true;
}

bool ObxdAudioProcessor::isOutputChannelStereoPair (int index) const
{
	return true;
}

bool ObxdAudioProcessor::acceptsMidi() const
{
#if JucePlugin_WantsMidiInput
	return true;
#else
	return false;
#endif
}

bool ObxdAudioProcessor::producesMidi() const
{
#if JucePlugin_ProducesMidiOutput
	return true;
#else
	return false;
#endif
}

bool ObxdAudioProcessor::silenceInProducesSilenceOut() const
{
	return false;
}

double ObxdAudioProcessor::getTailLengthSeconds() const
{
	return 0.0;
}

//==============================================================================
int ObxdAudioProcessor::getNumPrograms()
{
	return PROGRAMCOUNT;
}

int ObxdAudioProcessor::getCurrentProgram()
{
	return programs.currentProgram;
}

void ObxdAudioProcessor::setCurrentProgram (int index)
{
	programs.currentProgram = index;
	programs.currentProgramPtr = programs.programs + programs.currentProgram;
	isHostAutomatedChange = false;
	for(int i = 0 ; i < PARAM_COUNT;i++)
		setParameter(i,programs.currentProgramPtr->values[i]);
	isHostAutomatedChange = true;
	sendChangeMessage();
	updateHostDisplay();
}

const String ObxdAudioProcessor::getProgramName (int index)
{
	return programs.programs[index].name;
}

void ObxdAudioProcessor::changeProgramName (int index, const String& newName)
{
	 programs.programs[index].name = newName;
}

//==============================================================================
void ObxdAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
{
	// Use this method as the place to do any pre-playback
	// initialisation that you need..
	nextMidi= new MidiMessage(0xF0);
	midiMsg = new MidiMessage(0xF0);
	synth.setSampleRate(sampleRate);
}

void ObxdAudioProcessor::releaseResources()
{

}

inline void ObxdAudioProcessor::processMidiPerSample(MidiBuffer::Iterator* iter,const int samplePos)
{
	while (getNextEvent(iter, samplePos))
	{
		if(midiMsg->isNoteOn())
		{
			synth.procNoteOn(midiMsg->getNoteNumber(),midiMsg->getFloatVelocity());
		}
		if (midiMsg->isNoteOff())
		{
			synth.procNoteOff(midiMsg->getNoteNumber());
		}
		if(midiMsg->isPitchWheel())
		{
			// [0..16383] center = 8192;
			synth.procPitchWheel((midiMsg->getPitchWheelValue()-8192) / 8192.0);
		}
		if(midiMsg->isController() && midiMsg->getControllerNumber()==1)
			synth.procModWheel(midiMsg->getControllerValue() / 127.0);
		if(midiMsg->isController())
		{
			lastMovedController = midiMsg->getControllerNumber();
			if(programs.currentProgramPtr->values[MIDILEARN]  > 0.5)
				bindings.controllers[lastMovedController] = lastUsedParameter;
			if(programs.currentProgramPtr->values[UNLEARN] >0.5)
			{
				midiControlledParamSet = true;
				bindings.controllers[lastMovedController] = 0;
				setParameter(UNLEARN,0);
				lastMovedController = 0;
				lastUsedParameter = 0;
				midiControlledParamSet = false;
			}

			if(bindings.controllers[lastMovedController] > 0)
			{
				midiControlledParamSet = true;
				setParameter(bindings.controllers[lastMovedController],midiMsg->getControllerValue() / 127.0);
				setParameter(MIDILEARN,0);
				lastMovedController = 0;
				lastUsedParameter = 0;

				midiControlledParamSet = false;
			}

		}
		if(midiMsg->isSustainPedalOn())
		{
			synth.sustainOn();
		}
		if(midiMsg->isSustainPedalOff() || midiMsg->isAllNotesOff()||midiMsg->isAllSoundOff())
		{
			synth.sustainOff();
		}
		if(midiMsg->isAllNotesOff())
		{
			synth.allNotesOff();
		}
		if(midiMsg->isAllSoundOff())
		{
			synth.allSoundOff();
		}

	}
}

bool ObxdAudioProcessor::getNextEvent(MidiBuffer::Iterator* iter,const int samplePos)
{
	if (hasMidiMessage && midiEventPos <= samplePos)
	{
		*midiMsg = *nextMidi;
		hasMidiMessage = iter->getNextEvent(*nextMidi, midiEventPos);
		return true;
	} 
	return false;
}

void ObxdAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
	//SSE flags set
#ifdef __SSE__
	_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
#endif
#ifdef __SSE2__
	// _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
#endif

	MidiBuffer::Iterator ppp(midiMessages);
	hasMidiMessage = ppp.getNextEvent(*nextMidi,midiEventPos);

	int samplePos = 0;
	int numSamples = buffer.getNumSamples();
	float* channelData1 = buffer.getWritePointer(0);
	float* channelData2 = buffer.getWritePointer(1);

	AudioPlayHead::CurrentPositionInfo pos;
    if (getPlayHead() != 0 && getPlayHead()->getCurrentPosition (pos))
    {
		synth.setPlayHead(pos.bpm,pos.ppqPosition);
    }

	while (samplePos < numSamples)
	{
		processMidiPerSample(&ppp,samplePos);

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

		samplePos++;
	}
}

//==============================================================================
bool ObxdAudioProcessor::hasEditor() const
{
	return true;
}

AudioProcessorEditor* ObxdAudioProcessor::createEditor()
{
	return new ObxdAudioProcessorEditor (this);
}

//==============================================================================
void ObxdAudioProcessor::getStateInformation(MemoryBlock& destData)
{
	XmlElement xmlState = XmlElement("Datsounds");
	xmlState.setAttribute(S("currentProgram"), programs.currentProgram);

	XmlElement* xprogs = new XmlElement("programs");
	for (int i = 0; i < PROGRAMCOUNT; ++i)
	{
		XmlElement* xpr = new XmlElement("program");
		xpr->setAttribute(S("programName"), programs.programs[i].name);
		xpr->setAttribute(S("voiceCount"), Motherboard::MAX_VOICES);

		for (int k = 0; k < PARAM_COUNT; ++k)
		{
			xpr->setAttribute(String(k), programs.programs[i].values[k]);
		}

		xprogs->addChildElement(xpr);
	}

	xmlState.addChildElement(xprogs);

	for (int i = 0; i < 255; ++i)
	{
		xmlState.setAttribute(String(i), bindings.controllers[i]);
	}

	copyXmlToBinary(xmlState, destData);
}

void ObxdAudioProcessor::getCurrentProgramStateInformation(MemoryBlock& destData)
{
	XmlElement xmlState = XmlElement("Datsounds");

	for (int k = 0; k < PARAM_COUNT; ++k)
	{
		xmlState.setAttribute(String(k), programs.currentProgramPtr->values[k]);
	}

	xmlState.setAttribute(S("voiceCount"), Motherboard::MAX_VOICES);
	xmlState.setAttribute(S("programName"), programs.currentProgramPtr->name);

	copyXmlToBinary(xmlState, destData);
}

void ObxdAudioProcessor::setStateInformation(const void* data, int sizeInBytes)
{
#if JUCE_VERSION <= JUCE_543
	XmlElement * const xmlState = getXmlFromBinary(data, sizeInBytes);
#else
	std::unique_ptr<XmlElement> xmlState = getXmlFromBinary(data, sizeInBytes);
#endif
	if (xmlState)
	{
		XmlElement* xprogs = xmlState->getFirstChildElement();
		if (xprogs->hasTagName(S("programs")))
		{
			int i = 0;
			forEachXmlChildElement(*xprogs, e)
			{
				bool newFormat = e->hasAttribute("voiceCount");
				programs.programs[i].setDefaultValues();

				for (int k = 0; k < PARAM_COUNT; ++k)
				{
					float value = float(e->getDoubleAttribute(String(k), programs.programs[i].values[k]));
					if (!newFormat && k == VOICE_COUNT) value *= 0.25f;
					programs.programs[i].values[k] = value;
				}

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

				++i;
				}
			}

		for (int i = 0; i < 255; ++i)
		{
			bindings.controllers[i] = xmlState->getIntAttribute(String(i), 0);
		}

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

#if JUCE_VERSION <= JUCE_543
		delete xmlState;
#endif
		}
	}

void  ObxdAudioProcessor::setCurrentProgramStateInformation(const void* data, int sizeInBytes)
{
#if JUCE_VERSION <= JUCE_543
	XmlElement * const e = getXmlFromBinary(data, sizeInBytes);
#else
	std::unique_ptr<XmlElement> e = getXmlFromBinary(data, sizeInBytes);
#endif
	if (e)
	{
		programs.currentProgramPtr->setDefaultValues();

		bool newFormat = e->hasAttribute("voiceCount");
		for (int k = 0; k < PARAM_COUNT; ++k)
		{
			float value = float(e->getDoubleAttribute(String(k), programs.currentProgramPtr->values[k]));
			if (!newFormat && k == VOICE_COUNT) value *= 0.25f;
			programs.currentProgramPtr->values[k] = value;
		}

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

		setCurrentProgram(programs.currentProgram);

#if JUCE_VERSION <= JUCE_543
		delete e;
#endif
	}
}

//==============================================================================
bool ObxdAudioProcessor::loadFromFXBFile(const File& fxbFile)
{
	MemoryBlock mb;
	if (! fxbFile.loadFileAsData(mb))
		return false;

	const void* const data = mb.getData();
	const size_t dataSize = mb.getSize();

	if (dataSize < 28)
		return false;

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

	if ((! compareMagic (set->chunkMagic, "CcnK")) || fxbSwap (set->version) > fxbVersionNum)
		return false;

	if (compareMagic (set->fxMagic, "FxBk"))
	{
		// bank of programs
		if (fxbSwap (set->numPrograms) >= 0)
		{
			const int oldProg = getCurrentProgram();
			const int numParams = fxbSwap (((const fxProgram*) (set->programs))->numParams);
			const int progLen = (int) sizeof (fxProgram) + (numParams - 1) * (int) sizeof (float);

			for (int i = 0; i < fxbSwap (set->numPrograms); ++i)
			{
				if (i != oldProg)
				{
					const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + i * progLen);
					if (((const char*) prog) - ((const char*) set) >= (ssize_t) dataSize)
						return false;

					if (fxbSwap (set->numPrograms) > 0)
						setCurrentProgram (i);

					if (! restoreProgramSettings (prog))
						return false;
				}
			}

			if (fxbSwap (set->numPrograms) > 0)
				setCurrentProgram (oldProg);

			const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + oldProg * progLen);
			if (((const char*) prog) - ((const char*) set) >= (ssize_t) dataSize)
				return false;

			if (! restoreProgramSettings (prog))
				return false;
		}
	}
	else if (compareMagic (set->fxMagic, "FxCk"))
	{
		// single program
		const fxProgram* const prog = (const fxProgram*) data;

		if (! compareMagic (prog->chunkMagic, "CcnK"))
			return false;

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

		for (int i = 0; i < fxbSwap (prog->numParams); ++i)
			setParameter (i, fxbSwapFloat (prog->params[i]));
	}
	else if (compareMagic (set->fxMagic, "FBCh"))
	{
		// non-preset chunk
		const fxChunkSet* const cset = (const fxChunkSet*) data;

		if ((size_t) fxbSwap (cset->chunkSize) + sizeof (fxChunkSet) - 8 > (size_t) dataSize)
			return false;

		setStateInformation(cset->chunk, fxbSwap (cset->chunkSize));
	}
	else if (compareMagic (set->fxMagic, "FPCh"))
	{
		// preset chunk
		const fxProgramSet* const cset = (const fxProgramSet*) data;

		if ((size_t) fxbSwap (cset->chunkSize) + sizeof (fxProgramSet) - 8 > (size_t) dataSize)
			return false;

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

		changeProgramName (getCurrentProgram(), cset->name);
	}
	else
	{
		return false;
	}

	currentBank = fxbFile.getFileName();

	updateHostDisplay();

	return true;
}

bool ObxdAudioProcessor::restoreProgramSettings(const fxProgram* const prog)
{
	if (compareMagic (prog->chunkMagic, "CcnK")
		&& compareMagic (prog->fxMagic, "FxCk"))
	{
		changeProgramName (getCurrentProgram(), prog->prgName);

		for (int i = 0; i < fxbSwap (prog->numParams); ++i)
			setParameter (i, fxbSwapFloat (prog->params[i]));

		return true;
	}

	return false;
}

//==============================================================================
void ObxdAudioProcessor::scanAndUpdateBanks()
{
	bankFiles.clearQuick();

	DirectoryIterator it(getBanksFolder(), false, "*.fxb", File::findFiles);
	while (it.next())
	{
		bankFiles.addUsingDefaultSort(it.getFile());
	}
}

const Array<File>& ObxdAudioProcessor::getBankFiles() const
{
	return bankFiles;
}

File ObxdAudioProcessor::getCurrentBankFile() const
{
	return getBanksFolder().getChildFile(currentBank);
}

//==============================================================================
File ObxdAudioProcessor::getDocumentFolder() const
{
	File folder = File::getSpecialLocation(File::userDocumentsDirectory).getChildFile("discoDSP").getChildFile("OB-Xd");
	if (folder.isSymbolicLink())
		folder = folder.getLinkedTarget();
	return folder;
}

File ObxdAudioProcessor::getSkinFolder() const
{
	return getDocumentFolder().getChildFile("Skins");
}

File ObxdAudioProcessor::getBanksFolder() const
{
	return getDocumentFolder().getChildFile("Banks");
}

File ObxdAudioProcessor::getCurrentSkinFolder() const
{
	return getSkinFolder().getChildFile(currentSkin);
}

void ObxdAudioProcessor::setCurrentSkinFolder(const String& folderName)
{
	currentSkin = folderName;

	config->setValue("skin", folderName);
	config->setNeedsToBeSaved(true);
}

//==============================================================================
// This creates new instances of the plugin..
AudioProcessor* JUCE_CALLTYPE createPluginFilter()
{
	return new ObxdAudioProcessor();
}