/*

------------------------------------------------------------------

Python Plugin

Copyright (C) 2016 FP Battaglia

based on

Open Ephys GUI

Copyright (C) 2013, 2015 Open Ephys

------------------------------------------------------------------

v

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

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

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

/*

==============================================================================

PythonPlugin.cpp

Created: 13 Jun 2014 5:56:17pm

Author: fpbatta

==============================================================================

*/

#include "PythonPlugin.h"

#include "PythonPlugin.h"

#include "PythonEditor.h"

#include <dlfcn.h>

#include <stdlib.h>

#include <string.h>

#ifdef DEBUG

#define PYTHON_DEBUG

#endif

#ifdef PYTHON_DEBUG

#if defined(__linux__)

#include <sys/syscall.h>

#include <unistd.h>

#else

#include <pthread.h>

#endif

#endif

PythonPlugin::PythonPlugin(const String &processorName)

: GenericProcessor(processorName) //, threshold(200.0), state(true)

{

//parameters.add(Parameter("thresh", 0.0, 500.0, 200.0, 0));

filePath = "";

plugin = 0;

#define QUOTE(name) #name

#define STR(macro) QUOTE(macro)

#define PYTHON_HOME_NAME STR(PYTHON_HOME)

char * old_python_home = getenv("PYTHONHOME");

if (old_python_home == NULL)

{

#ifdef PYTHON_DEBUG

std::cout << "setting PYTHONHOME" << std::endl;

#endif

setenv("PYTHONHOME", PYTHON_HOME_NAME, 1);

}

// setenv("PYTHONHOME", "/usr/local/anaconda", 1); // FIXME hardcoded PYTHONHOME!

#ifdef PYTHON_DEBUG

std::cout << "PYTHONHOME: " << getenv("PYTHONHOME") << std::endl;

#endif

#ifdef PYTHON_DEBUG

#if defined(__linux__)

pid_t tid;

tid = syscall(SYS_gettid);

#else

uint64_t tid;

pthread_threadid_np(NULL, &tid);

#endif

std::cout << "in constructor pthread_threadid_np()=" << tid << std::endl;

#endif

#if PY_MAJOR_VERSION==3

Py_SetProgramName ((wchar_t *)"PythonPlugin");

#else

Py_SetProgramName ((char *)"PythonPlugin");

#endif

Py_Initialize ();

PyEval_InitThreads();

PyRun_SimpleString("import sys");

PyRun_SimpleString("sys.setcheckinterval(10000)");

#ifdef PYTHON_DEBUG

std::cout << Py_GetPrefix() << std::endl;

std::cout << Py_GetVersion() << std::endl;

#endif

GUIThreadState = PyEval_SaveThread();

}

PythonPlugin::~PythonPlugin()

{

dlclose(plugin);

}

void PythonPlugin::createEventChannels()

{

EventChannel* ev = new EventChannel(EventChannel::TTL, 8, 1, CoreServices::getGlobalSampleRate(), this);

ev->setName("Python events");

ev->setDescription("Events generated by a Python plugin");

String identifier = "dataderived.python";

ev->setIdentifier(identifier);

MetaDataDescriptor md(MetaDataDescriptor::CHAR, 25, "Plugin type", "Description of the plugin", "channelInfo.extra");

MetaDataValue mv(md);

mv.setValue("Python plugin");

ev->addMetaData(md, mv);

eventChannelArray.add(ev);

ttlChannel = ev;

std::cout << "Python event channel created" << std::endl;

}

AudioProcessorEditor* PythonPlugin::createEditor()

{

// std::cout << "in PythonEditor::createEditor()" << std::endl;

editor = new PythonEditor(this, true);

return editor;

}

bool PythonPlugin::isReady()

{

#ifdef PYTHON_DEBUG

#if defined(__linux__)

pid_t tid;

tid = syscall(SYS_gettid);

#else

uint64_t tid;

pthread_threadid_np(NULL, &tid);

#endif

std::cout << "in isReady pthread_threadid_np()=" << tid << std::endl;

#endif

bool ret;

PyEval_RestoreThread(GUIThreadState);

if (plugin == 0 )

{

// sendActionMessage("No plugin selected in Python Plugin."); // FIXME how to send error message?

ret = false;

}

else if (pluginIsReady && !(*pluginIsReady)())

{

// sendActionMessage("Plugin is not ready"); // FIXME how to send error message?

ret = false;

}

else

{

ret = true;

}

GUIThreadState = PyEval_SaveThread();

return ret;

}

void PythonPlugin::setParameter(int parameterIndex, float newValue)

{

editor->updateParameterButtons(parameterIndex);

//Parameter& p = parameters.getReference(parameterIndex);

//p.setValue(newValue, 0);

//threshold = newValue;

//std::cout << float(p[0]) << std::endl;

editor->updateParameterButtons(parameterIndex);

}

void PythonPlugin::resetConnections()

{

#ifdef PYTHON_DEBUG

#if defined(__linux__)

pid_t tid;

tid = syscall(SYS_gettid);

#else

uint64_t tid;

pthread_threadid_np(NULL, &tid);

#endif

std::cout << "in resetConnection pthread_threadid_np()=" << tid << std::endl;

#endif

nextAvailableChannel = 0;

wasConnected = false;

#ifdef PYTHON_DEBUG

std::cout << "resetting ThreadState, which was " << processThreadState << std::endl;

#endif

processThreadState = 0;

}

void PythonPlugin::process(AudioSampleBuffer& buffer)

{

checkForEvents();

#ifdef PYTHON_DEBUG

#if defined(__linux__)

pid_t tid;

tid = syscall(SYS_gettid);

#else

uint64_t tid;

pthread_threadid_np(NULL, &tid);

#endif

// std::cout << "in process pthread_threadid_np()=" << tid << std::endl;

#endif

if(!processThreadState)

{

//DEBUG

PyThreadState *nowState;

nowState = PyGILState_GetThisThreadState();

#ifdef PYTHON_DEBUG

std::cout << "currentState: " << nowState << std::endl;

std::cout << "initialiting ThreadState" << std::endl;

#endif

if(nowState) //UGLY HACK!!!

{

processThreadState = nowState;

}

else

{

processThreadState = PyThreadState_New(GUIThreadState->interp);

}

if(!processThreadState)

std::cout << "ThreadState is Null!" << std::endl;

}

PyEval_RestoreThread(processThreadState);

PythonEvent *pyEvents = (PythonEvent *)calloc(1, sizeof(PythonEvent));

pyEvents->type = 0; // this marks an empty event

#ifdef PYTHON_DEBUG

// std::cout << "in process, trying to acquire lock" << std::endl;

#endif

// PyEval_InitThreads();

//

// std::cout << "in process, threadstate: " << PyGILState_GetThisThreadState() << std::endl;

// PyGILState_STATE gstate;

// gstate = PyGILState_Ensure();

// std::cout << "in process, lock acquired" << std::endl;

(*pluginFunction)(*(buffer.getArrayOfWritePointers()), buffer.getNumChannels(), buffer.getNumSamples(), getNumSamples(0), pyEvents);

// PyGILState_Release(gstate);

// std::cout << "in process, lock released" << std::endl;

if(wasTriggered)

{

uint8 ttlData = 0;

// std::cout << "in Python plugin resetting channel: " << lastChan << std::endl;

TTLEventPtr event = TTLEvent::createTTLEvent(ttlChannel, getTimestamp(0),

&ttlData, sizeof(uint8), lastChan);

addEvent(ttlChannel, event, 0);

wasTriggered = false;

}

if(pyEvents->type != 0)

{

#ifdef PYTHON_DEBUG

// std::cout << "Event emitted " << (int)pyEvents->type << std::endl;

#endif

// uint8 ttlData = 1 << module.outputChan;

// TTLEventPtr event = TTLEvent::createTTLEvent(moduleEventChannels[m], getTimestamp(module.inputChan) + i, &ttlData, sizeof(uint8), module.outputChan);

// addEvent(moduleEventChannels[m], event, i);

lastChan = (uint16)pyEvents->eventId;

uint8 ttlData = 1 << lastChan;

// std::cout << "in Python plugin ts is " << getTimestamp(0) + pyEvents->sampleNum << " and sampleNum is " <<

// pyEvents->sampleNum << " eventId: " << uint16(pyEvents->eventId) << " ttlData: " << int(ttlData) << std::endl;

// FIXME now we set the ts at the first samble in the block

TTLEventPtr event = TTLEvent::createTTLEvent(ttlChannel, getTimestamp(0) + pyEvents->sampleNum,

&ttlData, sizeof(uint8), lastChan);

addEvent(ttlChannel, event, pyEvents->sampleNum);

PythonEvent *lastEvent = pyEvents;

PythonEvent *nextEvent = lastEvent->nextEvent;

free((void *)lastEvent);

wasTriggered = true;

// std::cout << "lastChan is " << lastChan << std::endl;

while (nextEvent) {

lastChan = (uint16)nextEvent->eventId;

uint8 ttlData = 1 << lastChan;

// std::cout << "in Python plugin ts is " << getTimestamp(0) << " and sampleNum is " <<

// nextEvent->sampleNum << " ttlData: " << ttlData << std::endl;

TTLEventPtr event = TTLEvent::createTTLEvent(ttlChannel, getTimestamp(0) + nextEvent->sampleNum,

&ttlData, sizeof(uint8), lastChan);

addEvent(ttlChannel, event, nextEvent->sampleNum);

lastEvent = nextEvent;

nextEvent = nextEvent->nextEvent;

free((void *)lastEvent);

wasTriggered = true;

}

}

processThreadState = PyEval_SaveThread();

#ifdef PYTHON_DEBUG

// std::cout << "Thread saved" << std::endl;

#endif

}

/* The complete API that the Cython plugin has to expose is

void pluginStartup(void): a function to initialize the plugin data structures prior to start ACQ

int isReady(void): a boolean function telling the processor whether the plugin is ready to receive data

int getParamNum(void) get the number of parameters that the plugin takes

ParamConfig *getParamConfig(void) this will allow generating the editor GUI TODO

void setIntParameter(char *name, int value) set integer parameter

void set FloatParameter(char *name, float value) set float parameter

*/

void PythonPlugin::setFile(String fullpath)

{

#ifdef PYTHON_DEBUG

#if defined(__linux__)

pid_t tid;

tid = syscall(SYS_gettid);

#else

uint64_t tid;

pthread_threadid_np(NULL, &tid);

#endif

std::cout << "in setFile pthread_threadid_np()=" << tid << std::endl;

#endif

filePath = fullpath;

const char* path = filePath.getCharPointer();

plugin = dlopen(path, RTLD_LAZY);

if (!plugin)

{

std::cout << "Can't open plugin "

<< '"' << path << "\""

<< dlerror()

<< std::endl;

return;

}

String initPlugin = filePath.fromLastOccurrenceOf(String("/"), false, true);

initPlugin = initPlugin.upToFirstOccurrenceOf(String("."), false, true);

#if PY_MAJOR_VERSION>=3

String initPluginName = String("PyInit_");

#else

String initPluginName = String("init");

#endif

initPluginName.append(initPlugin, 200);

std::cout << "init function is: " << initPluginName << std::endl;

void *initializer = dlsym(plugin,initPluginName.getCharPointer());

#ifdef PYTHON_DEBUG

std::cout << "initializer: " << initializer << std::endl;

#endif

if (!initializer)

{

std::cout << "Can't find init function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

plugin = 0;

return;

}

initfunc_t initF = (initfunc_t) initializer;

void *cfunc = dlsym(plugin,"pluginisready");

if (!cfunc)

{

std::cout << "Can't find ready function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

plugin = 0;

return;

}

pluginIsReady = (isreadyfunc_t)cfunc;

cfunc = dlsym(plugin,"pluginStartup");

if (!cfunc)

{

std::cout << "Can't find startup function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

plugin = 0;

return;

}

pluginStartupFunction = (startupfunc_t)cfunc;

cfunc = dlsym(plugin,"getParamNum");

if (!cfunc)

{

std::cout << "Can't find getParamNum function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

plugin = 0;

return;

}

getParamNumFunction = (getparamnumfunc_t)cfunc;

cfunc = dlsym(plugin,"getParamConfig");

if (!cfunc)

{

std::cout << "Can't find getParamNum function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

// plugin = 0;

// return;

}

getParamConfigFunction = (getparamconfigfunc_t)cfunc;

cfunc = dlsym(plugin,"pluginFunction");

// std::cout << "plugin: " << cfunc << std::endl;

if (!cfunc)

{

std::cout << "Can't find plugin function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

plugin = 0;

return;

}

pluginFunction = (pluginfunc_t)cfunc;

cfunc = dlsym(plugin,"setIntParam");

// std::cout << "plugin: " << cfunc << std::endl;

if (!cfunc)

{

std::cout << "Can't find setIntParam function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

plugin = 0;

return;

}

setIntParamFunction = (setintparamfunc_t)cfunc;

cfunc = dlsym(plugin,"setFloatParam");

// std::cout << "plugin: " << cfunc << std::endl;

if (!cfunc)

{

std::cout << "Can't find setFloatParam function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

plugin = 0;

return;

}

setFloatParamFunction = (setfloatparamfunc_t)cfunc;

cfunc = dlsym(plugin, "getIntParam");

// std::cout << "plugin: " << cfunc << std::endl;

if (!cfunc)

{

std::cout << "Can't find getIntParam function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

plugin = 0;

return;

}

getIntParamFunction = (getintparamfunc_t)cfunc;

cfunc = dlsym(plugin, "getFloatParam");

// std::cout << "plugin: " << cfunc << std::endl;

if (!cfunc)

{

std::cout << "Can't find getFloatParam function in plugin "

<< '"' << path << "\"" << std::endl

<< dlerror()

<< std::endl;

plugin = 0;

return;

}

getFloatParamFunction = (getfloatparamfunc_t)cfunc;

// now the API should be fully loaded

PyEval_RestoreThread(GUIThreadState);

// initialize the plugin

#ifdef PYTHON_DEBUG

std::cout << "before initplugin" << std::endl; // DEBUG

#endif

(*initF)();

#ifdef PYTHON_DEBUG

std::cout << "after initplugin" << std::endl; // DEBUG

#endif

(*pluginStartupFunction)(getSampleRate());

// load the parameter configuration

numPythonParams = (*getParamNumFunction)();

#ifdef PYTHON_DEBUG

std::cout << "the plugin wants " << numPythonParams

<< " parameters" << std::endl;

#endif

params = (ParamConfig *)calloc(numPythonParams, sizeof(ParamConfig));

paramsControl = (Component **)calloc(numPythonParams, sizeof(Component *));

(*getParamConfigFunction)(params);

#ifdef PYTHON_DEBUG

std::cout << "release paramconfig" << std::endl;

#endif

for(int i = 0; i < numPythonParams; i++)

{

#ifdef PYTHON_DEBUG

std::cout << "param " << i << " is a " << params[i].type << std::endl;

std::cout << "it is named: " << params[i].name << std::endl << std::endl;

#endif

switch (params[i].type) {

case TOGGLE:

paramsControl[i] = dynamic_cast<PythonEditor *>(getEditor())->addToggleButton(String(params[i].name), params[i].isEnabled);

break;

case INT_SET:

paramsControl[i] = dynamic_cast<PythonEditor *>(getEditor())->addComboBox(String(params[i].name), params[i].nEntries, params[i].entries);

break;

case FLOAT_RANGE:

paramsControl[i] = dynamic_cast<PythonEditor *>(getEditor())->addSlider(String(params[i].name), params[i].rangeMin, params[i].rangeMax, params[i].startValue);

break;

default:

break;

}

}

GUIThreadState = PyEval_SaveThread();

}

String PythonPlugin::getFile()

{

return filePath;

}

void PythonPlugin::updateSettings()

{

}

void PythonPlugin::setIntPythonParameter(String name, int value)

{

#ifdef PYTHON_DEBUG

#if defined(__linux__)

pid_t tid;

tid = syscall(SYS_gettid);

#else

uint64_t tid;

pthread_threadid_np(NULL, &tid);

#endif

std::cout << "in setintparam pthread_threadid_np()=" << tid << std::endl;

#endif

PyEval_RestoreThread(GUIThreadState);

(*setIntParamFunction)(name.getCharPointer().getAddress(), value);

GUIThreadState = PyEval_SaveThread();

}

void PythonPlugin::setFloatPythonParameter(String name, float value)

{

#ifdef PYTHON_DEBUG

#if defined(__linux__)

pid_t tid;

tid = syscall(SYS_gettid);

#else

uint64_t tid;

pthread_threadid_np(NULL, &tid);

#endif

std::cout << "in setfloatparam pthread_threadid_np()=" << tid << std::endl;

#endif

PyEval_RestoreThread(GUIThreadState);

(*setFloatParamFunction)(name.getCharPointer().getAddress(), value);

GUIThreadState = PyEval_SaveThread();

}

int PythonPlugin::getIntPythonParameter(String name)

{

#ifdef PYTHON_DEBUG

#if defined(__linux__)

pid_t tid;

tid = syscall(SYS_gettid);

#else

uint64_t tid;

pthread_threadid_np(NULL, &tid);

#endif

std::cout << "in getintparam pthread_threadid_np()=" << tid << std::endl;

#endif

int value;

PyEval_RestoreThread(GUIThreadState);

value = (*getIntParamFunction)(name.getCharPointer().getAddress());

GUIThreadState = PyEval_SaveThread();

return value;

}

float PythonPlugin::getFloatPythonParameter(String name)

{

#ifdef PYTHON_DEBUG

#if defined(__linux__)

pid_t tid;

tid = syscall(SYS_gettid);

#else

uint64_t tid;

pthread_threadid_np(NULL, &tid);

#endif

std::cout << "in getfloatparam pthread_threadid_np()=" << tid << std::endl;

#endif

PyEval_RestoreThread(GUIThreadState);

float value;

value = (*getFloatParamFunction)(name.getCharPointer().getAddress());

GUIThreadState = PyEval_SaveThread();

return value;

}