void OnlineUnlockStatus::load()
{
MemoryBlock mb;
mb.fromBase64Encoding (getState());
if (mb.getSize() > 0)
status = ValueTree::readFromGZIPData (mb.getData(), mb.getSize());
else
status = ValueTree (stateTagName);
StringArray localMachineNums (getLocalMachineIDs());
if (machineNumberAllowed (StringArray ("1234"), localMachineNums))
status.removeProperty (unlockedProp, nullptr);
KeyFileUtils::KeyFileData data;
data = KeyFileUtils::getDataFromKeyFile (KeyFileUtils::getXmlFromKeyFile (status[keyfileDataProp], getPublicKey()));
if (data.keyFileExpires)
{
if (! doesProductIDMatch (data.appID))
status.removeProperty (expiryTimeProp, nullptr);
if (! machineNumberAllowed (data.machineNumbers, localMachineNums))
status.removeProperty (expiryTimeProp, nullptr);
}
else
{
if (! doesProductIDMatch (data.appID))
status.removeProperty (unlockedProp, nullptr);
if (! machineNumberAllowed (data.machineNumbers, localMachineNums))
status.removeProperty (unlockedProp, nullptr);
}
}
void NamedValueSet::setFromXmlAttributes (const XmlElement& xml)
{
clear();
LinkedListPointer<NamedValue>::Appender appender (values);
const int numAtts = xml.getNumAttributes(); // xxx inefficient - should write an att iterator..
for (int i = 0; i < numAtts; ++i)
{
const String& name = xml.getAttributeName (i);
const String& value = xml.getAttributeValue (i);
if (name.startsWith ("base64:"))
{
MemoryBlock mb;
if (mb.fromBase64Encoding (value))
{
appender.append (new NamedValue (name.substring (7), var (mb)));
continue;
}
}
appender.append (new NamedValue (name, var (value)));
}
}
void WrappedJucePlugin::loadPresetFromXml(XmlElement* element)
{
if (instance)
{
XmlElement* chunk = element->getChildByName (T("juceVSTPluginData"));
if (chunk)
{
MemoryBlock mb;
mb.fromBase64Encoding (chunk->getAllSubText ());
instance->setStateInformation (mb.getData(), mb.getSize ());
}
}
}
static void recreate_from_state(struct SoundPlugin *plugin, hash_t *state){
#if JUCE_LINUX
const MessageManagerLock mmLock;
#endif
Data *data = (Data*)plugin->data;
AudioPluginInstance *audio_instance = data->audio_instance;
if (HASH_has_key(state, "audio_instance_state")) {
const char *stateAsString = HASH_get_chars(state, "audio_instance_state");
MemoryBlock sourceData;
sourceData.fromBase64Encoding(stateAsString);
audio_instance->setStateInformation(sourceData.getData(), sourceData.getSize());
}
if (HASH_has_key(state, "audio_instance_current_program")) {
int current_program = HASH_get_int(state, "audio_instance_current_program");
audio_instance->setCurrentProgram(current_program);
}
if (HASH_has_key(state, "audio_instance_program_state")){
const char *programStateAsString = HASH_get_chars(state, "audio_instance_program_state");
MemoryBlock sourceData;
sourceData.fromBase64Encoding(programStateAsString);
audio_instance->setCurrentProgramStateInformation(sourceData.getData(), sourceData.getSize());
}
if (HASH_has_key(state, "x_pos"))
data->x = HASH_get_int(state, "x_pos");
if (HASH_has_key(state, "y_pos"))
data->y = HASH_get_int(state, "y_pos");
}
void initialise(const String& commandLineParameters)
{
Logger::writeToLog("CTRLR:initialise params \""+commandLineParameters+"\"");
SystemStats::setApplicationCrashHandler (&CtrlrApplication::crashHandler);
if (!commandLineParameters.isEmpty())
{
String stackTrace = "?";
StringArray parameters = getParameters(commandLineParameters);
StringArray parameterValues = getParameterValues(commandLineParameters);
if (parameters.contains("crashReport"))
{
File crashReportForExec(parameterValues[parameters.indexOf("crashReport")]);
File crashReportFile(crashReportForExec.withFileExtension(crashReportForExec.getFileExtension()+".crash"));
AlertWindow crashReport("Ctrlr has crashed", "This is a crash indicator, it means that Ctrlr has crashed for some reason. Some crash information will be written to: "+crashReportFile.getFullPathName(), AlertWindow::WarningIcon);
if (parameters.contains("stackTrace"))
{
if (!parameterValues[parameters.indexOf("stackTrace")].isEmpty())
{
MemoryBlock mb;
mb.fromBase64Encoding(parameterValues[parameters.indexOf("stackTrace")]);
stackTrace = mb.toString();
crashReport.addTextBlock (stackTrace);
}
}
crashReport.addButton ("OK", 1, KeyPress (KeyPress::returnKey));
crashReport.runModalLoop();
crashReportFile.replaceWithText ("Ctrlr crash at: "+Time::getCurrentTime().toString(true, true, true, true) + "\nStack trace:\n"+stackTrace);
JUCEApplication::quit();
}
}
filterWindow = new CtrlrStandaloneWindow (ProjectInfo::projectName + String("/") + ProjectInfo::versionString, Colours::lightgrey);
if (File::isAbsolutePath(commandLineParameters.unquoted()))
filterWindow->openFileFromCli (File(commandLineParameters.unquoted()));
}
void NamedValueSet::setFromXmlAttributes (const XmlElement& xml)
{
values.clearQuick();
for (auto* att = xml.attributes.get(); att != nullptr; att = att->nextListItem)
{
if (att->name.toString().startsWith ("base64:"))
{
MemoryBlock mb;
if (mb.fromBase64Encoding (att->value))
{
values.add ({ att->name.toString().substring (7), var (mb) });
continue;
}
}
values.add ({ att->name, var (att->value) });
}
}
String EncryptedString::decrypt (const String& encryptedString, const String& privateKey, bool inputIsHex)
{
RSAKey rsaKey (privateKey);
MemoryBlock encryptedMemoryBlock;
if (inputIsHex)
{
encryptedMemoryBlock.loadFromHexString (encryptedString);
}
else
{
encryptedMemoryBlock.fromBase64Encoding (encryptedString);
}
BigInteger stringAsData;
stringAsData.loadFromMemoryBlock (encryptedMemoryBlock);
rsaKey.applyToValue (stringAsData);
return stringAsData.toMemoryBlock().toString();
}
void PMixDocument::createNodeFromXml (XmlElement& xml, const String& newSourceCode)
{
PluginDescription pd;
forEachXmlChildElement (xml, e)
{
if (pd.loadFromXml (*e))
break;
}
String errorMessage;
AudioPluginInstance* instance = audioEngine.createPluginInstance(pd, errorMessage);
jassert(instance != nullptr);
if (pd.pluginFormatName == "FAUST")
{
FaustAudioPluginInstance* faustProc = dynamic_cast<FaustAudioPluginInstance*>(instance);
faustProc->initialize(getLibraryPath(), drawPath);
if (newSourceCode.length())
faustProc->setSourceCode(newSourceCode, true);
// TODO: this is a bit wrong!
faustProc->prepareToPlay(44100., 8192);
// xml.setAttribute("numInputs", faustProc->getNumInputChannels());
// xml.setAttribute("numOutputs", faustProc->getNumOutputChannels()); ???
}
AudioProcessorGraph::Node::Ptr node (audioEngine.getGraph().addNode (instance, xml.getIntAttribute ("uid")));
if (!newSourceCode.length())
{
if (const XmlElement* const state = xml.getChildByName ("STATE"))
{
MemoryBlock m;
m.fromBase64Encoding (state->getAllSubText());
node->getProcessor()->setStateInformation (m.getData(), (int) m.getSize());
}
}
node->properties.set ("x", xml.getDoubleAttribute ("x"));
node->properties.set ("y", xml.getDoubleAttribute ("y"));
node->properties.set ("uiLastX", xml.getIntAttribute ("uiLastX"));
node->properties.set ("uiLastY", xml.getIntAttribute ("uiLastY"));
node->properties.set ("uiStatus", xml.getIntAttribute ("uiStatus"));
// presets etc for faust & plugin nodes
if(!InternalPluginFormat::isInternalFormat(pd.name))
{
node->properties.set ("colour", xml.getStringAttribute ("colour"));
node->properties.set ("iposx", xml.getDoubleAttribute ("iposx"));
node->properties.set ("iposy", xml.getDoubleAttribute ("iposy"));
if (const XmlElement* const params = xml.getChildByName ("PARAMS"))
{
var vparams = JSON::parse(params->getAllSubText());
node->properties.set ("params", vparams);
}
Array<var> presetsArr;
forEachXmlChildElement (xml, e)
{
if (e->hasTagName ("PRESET"))
{
DynamicObject* obj = new DynamicObject();
obj->setProperty("name", e->getStringAttribute("name"));
obj->setProperty("x", e->getDoubleAttribute("x"));
obj->setProperty("y", e->getDoubleAttribute("y"));
obj->setProperty("radius", e->getDoubleAttribute("radius"));
obj->setProperty("hidden", e->getBoolAttribute("hidden"));
// obj->setProperty("distance", e->getDoubleAttribute("distance"));
obj->setProperty("coeff", e->getDoubleAttribute("coeff"));
var vparams = JSON::parse(e->getAllSubText());
obj->setProperty("state", vparams);
obj->setProperty("uid", e->getIntAttribute("uid"));
var preset = var(obj);
presetsArr.add(preset);
}
}
node->properties.set("presets", presetsArr);
}
//==============================================================================
StandaloneFilterWindow::StandaloneFilterWindow (const String& title,
const Colour& backgroundColour,
const int requiredButtons,
const bool optionsButtonVisible,
const String& commandLine)
: DocumentWindow (title, backgroundColour, requiredButtons),
filter (0),
deviceManager (0),
optionsButton (0)
{
setTitleBarButtonsRequired (requiredButtons, false);
PropertySet* const globalSettings = getGlobalSettings();
if (optionsButtonVisible)
{
optionsButton = new TextButton (T("options"));
Component::addAndMakeVisible (optionsButton);
optionsButton->addButtonListener (this);
optionsButton->setTriggeredOnMouseDown (true);
}
JUCE_TRY
{
filter = createPluginFilter(commandLine);
if (filter != 0)
{
deviceManager = new AudioFilterStreamingDeviceManager();
deviceManager->setFilter (filter);
XmlElement* savedState = 0;
if (globalSettings != 0)
savedState = globalSettings->getXmlValue (T("audioSetup"));
deviceManager->initialise (filter->getNumInputChannels(),
filter->getNumOutputChannels(),
savedState,
true);
// reset filter so all midi inputs are available...
deviceManager->setFilter (filter);
delete savedState;
if (globalSettings != 0)
{
MemoryBlock data;
if (data.fromBase64Encoding (globalSettings->getValue (T("filterState")))
&& data.getSize() > 0)
{
filter->setStateInformation (data.getData(), data.getSize());
}
}
setContentComponent (filter->createEditorIfNeeded(), true, true);
int x = -100, y = -100;
if (globalSettings != 0)
{
x = globalSettings->getIntValue (T("windowX"), -100);
y = globalSettings->getIntValue (T("windowY"), -100);
}
if (x != -100 && y != -100)
setBoundsConstrained (x, y, getWidth(), getHeight());
else
centreWithSize (getWidth(), getHeight());
}
}
JUCE_CATCH_ALL
if (deviceManager == 0)
{
jassertfalse // Your filter didn't create correctly! In a standalone app that's not too great.
JUCEApplication::quit();
}
}