double QFUsesResultsEvaluation::getFitValue(const QFRawDataRecord *r, const QString &resultID, const QString ¶meterID) const {
//qDebug()<<"getFitValue("<<resultID<<", "<<parameterID<<")";
double res=0;
res=fitParamGlobalSettings->value(getParameterStoreIDInQSettings(parameterID), res).toDouble();
res=fitParamSettings->value(getParameterStoreIDInQSettings(parameterID), res).toDouble();
QFUsesResultsEvaluation::FitParameterDefault defVal;
if (getParameterDefault(r, resultID, parameterID, defVal)) {
res=defVal.value;
}
QString psID=getParameterStoreID(parameterID);
if (parameterStore.contains(psID)) {
if (parameterStore[psID].valueSet) {
res=parameterStore[psID].value;
}
}
double sval=res, serr=0;
if (hasSpecial(r, resultID, parameterID, sval, serr)) {
//qDebug()<<" - hasSpecial "<<sval;
res=sval;
}
if (r && hasResults(r, resultID)) {
QString tresultID=transformResultID(resultID);
QString pid=getFitParamID(parameterID);
//qDebug()<<" - hasResults "<<tresultID<<pid;
//qDebug()<<" "<<r->resultsCalcNames(tresultID);
if (r->resultsExists(tresultID, pid)) {
res=r->resultsGetAsDouble(tresultID, pid);
//qDebug()<<" - resultsExists "<<res;
}
}
//qDebug()<<" getFitValue("<<resultID<<", "<<parameterID<<") = "<<res;
return res;
}
// set default value for each scalar parameter. needed before loading
// patches, which are only required to store differences from these
// default values.
void MLPluginProcessor::setDefaultParameters()
{
if (mEngine.getCompileStatus() == MLProc::OK)
{
// set default for each parameter.
const unsigned numParams = getNumParameters();
for(unsigned i=0; i<numParams; ++i)
{
float defaultVal = getParameterDefault(i);
setPropertyImmediate(getParameterAlias(i), defaultVal);
}
}
}
QVector<double> QFUsesResultsEvaluation::getFitValueErrorArray(const QFRawDataRecord *r, const QString &resultID, const QString ¶meterID) const {
QVector<double> res;
if (r) {
QFUsesResultsEvaluation::FitParameterDefault defVal;
if (getParameterDefault(r, resultID, parameterID, defVal)) {
res=defVal.errorVector;
}
if (hasResults(r, resultID)) {
QString tresultID=transformResultID(resultID);
QString pid=getFitParamID(parameterID);
if (r->resultsExists(tresultID, pid)) res=r->resultsGetErrorAsDoubleList(tresultID, pid);
}
}
return res;
}
bool QFUsesResultsEvaluation::getFitFix(const QFRawDataRecord *r, const QString &resultID, const QString ¶meterID) const {
bool res=false;
res=fitParamGlobalSettings->value(getParameterStoreIDInQSettings(parameterID)+"_fix", res).toBool();
res=fitParamSettings->value(getParameterStoreIDInQSettings(parameterID)+"_fix", res).toBool();
QFUsesResultsEvaluation::FitParameterDefault defVal;
if (getParameterDefault(r, resultID, parameterID, defVal)) {
res=defVal.fix;
}
QString psID=getParameterStoreID(parameterID);
if (parameterStore.contains(psID)) {
if (parameterStore[psID].fixSet) {
res=parameterStore[psID].fix;
}
}
if (r && hasResults(r, resultID)) {
QString en=transformResultID(resultID);
QString pid=getFitParamFixID(parameterID);
if (r->resultsExists(en, pid)) res=r->resultsGetAsDouble(en, pid);
}
return res;
}
double QFUsesResultsEvaluation::getFitError(const QFRawDataRecord *r, const QString &resultID, const QString ¶meterID) const {
double sval=0, serr=0;
if (hasResults(r, resultID)) {
if (r!=NULL) {
return r->resultsGetErrorAsDouble(transformResultID(resultID), getFitParamID(parameterID));
}
}
if (hasSpecial(r, resultID, parameterID, sval, serr)) {
return serr;
}
QString psID=getParameterStoreID(parameterID);
if (parameterStore.contains(psID)) {
if (parameterStore[psID].errorSet) {
return parameterStore[psID].error;
}
}
QFUsesResultsEvaluation::FitParameterDefault defVal;
if (getParameterDefault(r, resultID, parameterID, defVal)) {
return defVal.error;
}
return 0.0;
}
plugMainUnion plugMain(DWORD functionCode, DWORD inputValue, DWORD instanceID)
#endif
{
plugMainUnion retval;
// declare pPlugObj - pointer to this instance
CFreeFrameGLPlugin* pPlugObj;
// typecast DWORD into pointer to a CFreeFrameGLPlugin
pPlugObj = (CFreeFrameGLPlugin*) instanceID;
switch (functionCode) {
case FF_GETINFO:
retval.PISvalue = (PluginInfoStruct*)getInfo();
break;
case FF_INITIALISE:
retval.ivalue = initialise();
break;
case FF_DEINITIALISE:
retval.ivalue = deInitialise();
break;
case FF_GETNUMPARAMETERS:
retval.ivalue = getNumParameters();
break;
case FF_GETPARAMETERNAME:
retval.svalue = getParameterName(inputValue);
break;
case FF_GETPARAMETERDEFAULT:
retval.ivalue = getParameterDefault(inputValue);
break;
case FF_GETPLUGINCAPS:
retval.ivalue = getPluginCaps(inputValue);
break;
case FF_GETEXTENDEDINFO:
retval.ivalue = (DWORD) getExtendedInfo();
break;
case FF_GETPARAMETERTYPE:
retval.ivalue = getParameterType(inputValue);
break;
case FF_GETPARAMETERDISPLAY:
if (pPlugObj != NULL)
retval.svalue = pPlugObj->GetParameterDisplay(inputValue);
else
retval.svalue = (char*)FF_FAIL;
break;
case FF_SETPARAMETER:
if (pPlugObj != NULL)
retval.ivalue = pPlugObj->SetParameter((const SetParameterStruct*) inputValue);
else
retval.ivalue = FF_FAIL;
break;
case FF_GETPARAMETER:
if (pPlugObj != NULL)
retval.ivalue = pPlugObj->GetParameter(inputValue);
else
retval.ivalue = FF_FAIL;
break;
case FF_INSTANTIATEGL:
retval.ivalue = (DWORD)instantiateGL((const FFGLViewportStruct *)inputValue);
break;
case FF_DEINSTANTIATEGL:
if (pPlugObj != NULL)
retval.ivalue = deInstantiateGL(pPlugObj);
else
retval.ivalue = FF_FAIL;
break;
case FF_GETIPUTSTATUS:
if (pPlugObj != NULL)
retval.ivalue = pPlugObj->GetInputStatus(inputValue);
else
retval.ivalue = FF_FAIL;
break;
case FF_PROCESSOPENGL:
if (pPlugObj != NULL)
{
ProcessOpenGLStruct *pogls = (ProcessOpenGLStruct *)inputValue;
if (pogls!=NULL)
retval.ivalue = pPlugObj->ProcessOpenGL(pogls);
else
retval.ivalue = FF_FAIL;
}
else
retval.ivalue = FF_FAIL;
break;
case FF_SETTIME:
if (pPlugObj != NULL)
{
double *inputTime = (double *)inputValue;
if (inputTime!=NULL)
retval.ivalue = pPlugObj->SetTime(*inputTime);
else
retval.ivalue = FF_FAIL;
}
else
retval.ivalue = FF_FAIL;
break;
//these old FF functions must always fail for FFGL plugins
case FF_INSTANTIATE:
case FF_DEINSTANTIATE:
case FF_PROCESSFRAME:
case FF_PROCESSFRAMECOPY:
default:
retval.ivalue = FF_FAIL;
break;
}
return retval;
}
plugMainUnion plugMain( DWORD functionCode, LPVOID pParam, LPVOID instanceID )
#endif
{
plugMainUnion retval;
// declare pPlugObj - pointer to this instance
WhorldPlug *pPlugObj;
// typecast LPVOID into pointer to a WhorldPlug
pPlugObj = (WhorldPlug*) instanceID;
switch(functionCode) {
case FF_GETINFO:
retval.PISvalue = getInfo();
break;
case FF_INITIALISE:
retval.ivalue = initialise();
break;
case FF_DEINITIALISE:
retval.ivalue = deInitialise(); // todo: pass on instance IDs etc
break;
case FF_GETNUMPARAMETERS:
retval.ivalue = getNumParameters();
break;
case FF_GETPARAMETERNAME:
retval.svalue = getParameterName( (DWORD) pParam );
break;
case FF_GETPARAMETERDEFAULT:
retval.fvalue = getParameterDefault( (DWORD) pParam );
break;
case FF_GETPARAMETERDISPLAY:
retval.svalue = pPlugObj->getParameterDisplay( (DWORD) pParam );
break;
// parameters are passed in here as a packed struct of two DWORDS:
// index and value
case FF_SETPARAMETER:
retval.ivalue= pPlugObj->setParameter( (SetParameterStruct*) pParam );
break;
case FF_PROCESSFRAME:
retval.ivalue = pPlugObj->processFrame(pParam);
break;
case FF_GETPARAMETER:
retval.fvalue = pPlugObj->getParameter((DWORD) pParam);
break;
case FF_GETPLUGINCAPS:
retval.ivalue = getPluginCaps( (DWORD) pParam);
break;
// Russell - FF 1.0 upgrade in progress ...
case FF_INSTANTIATE:
retval.ivalue = (DWORD) instantiate( (VideoInfoStruct*) pParam);
break;
case FF_DEINSTANTIATE:
retval.ivalue = deInstantiate(pPlugObj);
break;
case FF_GETEXTENDEDINFO:
retval.ivalue = (DWORD) getExtendedInfo();
break;
case FF_PROCESSFRAMECOPY:
retval.ivalue = pPlugObj->processFrameCopy((ProcessFrameCopyStruct*)pParam);
break;
case FF_GETPARAMETERTYPE:
// not implemented yet
retval.ivalue = FF_FAIL;
break;
// ....................................
default:
retval.ivalue = FF_FAIL;
break;
}
return retval;
}
void MLPluginProcessor::getStateAsXML (XmlElement& xml)
{
if( !(mEngine.getCompileStatus() == MLProc::OK)) return;
#if DEMO
xml.setAttribute ("pluginVersion", JucePlugin_VersionCode);
xml.setAttribute ("presetName", String("----"));
#else
const unsigned numParams = getNumParameters();
// TODO use string properties of model instead of these JUCE strings.
// also move to JSON.
xml.setAttribute ("pluginVersion", JucePlugin_VersionCode);
xml.setAttribute ("presetName", String(getStringProperty("preset").c_str()));
xml.setAttribute ("scaleName", String(getStringProperty("key_scale").c_str()));
// store parameter values to xml as a bunch of attributes.
// not XML best practice in general but takes fewer characters.
for(unsigned i=0; i<numParams; ++i)
{
const String paramName = symbolToXMLAttr(getParameterAlias(i));
const float defaultVal = getParameterDefault(i);
const float paramVal = getParameter(i);
if (paramVal != defaultVal)
{
xml.setAttribute(paramName, paramVal);
//debug() << "setting XML param " << paramName << " to " << paramVal << "\n";
}
}
// store patcher info to xml
{
MLProcList patchers = getPatcherList();
if (!patchers.empty())
{
MLProcPatcher& firstPatcher = static_cast<MLProcPatcher&>(**patchers.begin());
const int inputs = firstPatcher.getParam("inputs");
const int outputs = firstPatcher.getParam("outputs");
String outStr;
String patcherInput = "patcher_input_";
for(unsigned i=1; i<=inputs; ++i)
{
bool differentFromDefault = false;
outStr = "";
for(unsigned j=1; j<=outputs; ++j)
{
if (firstPatcher.getConnection(i, j))
{
outStr += "1";
differentFromDefault = true;
}
else
{
outStr += "0";
}
}
if(differentFromDefault)
{
String outNum (i);
xml.setAttribute(patcherInput + outNum, outStr);
}
}
}
}
// store editor state to XML if one exists
MLPluginEditor* pEditor = static_cast<MLPluginEditor*>(getActiveEditor());
if(pEditor)
{
MLRect r = pEditor->getWindowBounds();
xml.setAttribute("editor_x", r.x());
xml.setAttribute("editor_y", r.y());
xml.setAttribute("editor_width", r.getWidth());
xml.setAttribute("editor_height", r.getHeight());
xml.setAttribute("editor_num", getFloatProperty("patch_num"));
xml.setAttribute("editor_anim", getFloatProperty("patch_anim"));
}
// save blob as most recently saved state
mpLatestStateLoaded = XmlElementPtr(new XmlElement(xml));
#endif
}
void
RemotePluginServer::dispatchControlEvents()
{
RemotePluginOpcode opcode = RemotePluginNoOpcode;
static float *parameterBuffer = 0;
tryRead(m_controlRequestFd, &opcode, sizeof(RemotePluginOpcode));
switch (opcode) {
case RemotePluginGetVersion:
writeFloat(m_controlResponseFd, getVersion());
break;
case RemotePluginGetName:
writeString(m_controlResponseFd, getName());
break;
case RemotePluginGetMaker:
writeString(m_controlResponseFd, getMaker());
break;
case RemotePluginTerminate:
terminate();
break;
case RemotePluginGetInputCount:
m_numInputs = getInputCount();
writeInt(m_controlResponseFd, m_numInputs);
break;
case RemotePluginGetOutputCount:
m_numOutputs = getOutputCount();
writeInt(m_controlResponseFd, m_numOutputs);
break;
case RemotePluginGetParameterCount:
writeInt(m_controlResponseFd, getParameterCount());
break;
case RemotePluginGetParameterName:
writeString(m_controlResponseFd, getParameterName(readInt(m_controlRequestFd)));
break;
case RemotePluginGetParameter:
writeFloat(m_controlResponseFd, getParameter(readInt(m_controlRequestFd)));
break;
case RemotePluginGetParameterDefault:
writeFloat(m_controlResponseFd, getParameterDefault(readInt(m_controlRequestFd)));
break;
case RemotePluginGetParameters:
{
if (!parameterBuffer) {
parameterBuffer = new float[getParameterCount()];
}
int p0 = readInt(m_controlRequestFd);
int pn = readInt(m_controlRequestFd);
getParameters(p0, pn, parameterBuffer);
tryWrite(m_controlResponseFd, parameterBuffer, (pn - p0 + 1) * sizeof(float));
break;
}
case RemotePluginHasMIDIInput:
{
bool m = hasMIDIInput();
tryWrite(m_controlResponseFd, &m, sizeof(bool));
break;
}
case RemotePluginGetProgramCount:
writeInt(m_controlResponseFd, getProgramCount());
break;
case RemotePluginGetProgramName:
writeString(m_controlResponseFd, getProgramName(readInt(m_controlRequestFd)));
break;
case RemotePluginIsReady:
{
if (!m_shm) sizeShm();
bool b(isReady());
std::cerr << "isReady: returning " << b << std::endl;
tryWrite(m_controlResponseFd, &b, sizeof(bool));
}
case RemotePluginSetDebugLevel:
{
RemotePluginDebugLevel newLevel = m_debugLevel;
tryRead(m_controlRequestFd, &newLevel, sizeof(RemotePluginDebugLevel));
setDebugLevel(newLevel);
m_debugLevel = newLevel;
break;
}
case RemotePluginWarn:
{
bool b = warn(readString(m_controlRequestFd));
tryWrite(m_controlResponseFd, &b, sizeof(bool));
break;
}
case RemotePluginShowGUI:
{
showGUI(readString(m_controlRequestFd));
break;
}
case RemotePluginHideGUI:
{
hideGUI();
break;
}
//Deryabin Andrew: vst chunks support
case RemotePluginGetVSTChunk:
{
std::vector<char> chunk = getVSTChunk();
writeRaw(m_controlResponseFd, chunk);
break;
}
case RemotePluginSetVSTChunk:
{
std::vector<char> chunk = readRaw(m_controlRequestFd);
setVSTChunk(chunk);
break;
}
//Deryabin Andrew: vst chunks support: end code
case RemotePluginNoOpcode:
break;
case RemotePluginReset:
reset();
break;
default:
std::cerr << "WARNING: RemotePluginServer::dispatchControlEvents: unexpected opcode "
<< opcode << std::endl;
}
}
