bool pybase::gencall(PyObject *pmeth,PyObject *pargs)
{
bool ret = false;
// Now call method
switch(detach) {
case 0:
ret = docall(pmeth,pargs);
Py_DECREF(pargs);
Py_DECREF(pmeth);
break;
#ifdef FLEXT_THREADS
case 1:
// put call into queue
ret = qucall(pmeth,pargs);
break;
case 2:
// each call a new thread
if(!shouldexit) {
thr_params *p = new thr_params;
p->cl = (flext_base *)this;
p->var->_ext = new work_data(pmeth,pargs);
ret = LaunchThread(thrworker,p);
if(!ret) post("py/pyext - Failed to launch thread!");
}
break;
#endif
default:
post("py/pyext - Unknown detach mode");
}
return ret;
}
void CTClean::RunTestCaseL(TInt aCurTestCase)
{
((CTCleanStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
switch(aCurTestCase)
{
case 1:
((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0593"));
INFO_PRINTF1(_L("Thread Cleanup\r\n"));
DeadThread();
break;
case 2:
#if defined(_DEBUG)
INFO_PRINTF1(_L("Font\r\n"));
((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0594"));
LaunchThread(EFont1);
((CTCleanStep*)iStep)->RecordTestResultL();
((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0595"));
LaunchThread(EFont2);
#else
((CTCleanStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
#endif
break;
case 3:
((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0596"));
INFO_PRINTF1(_L("Bitmap\r\n"));
LaunchThread(EBitmap1);
break;
case 4:
((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0597"));
INFO_PRINTF1(_L("Pile\r\n"));
LaunchThread(EPile1);
break;
case 5:
INFO_PRINTF1(_L("Session\r\n"));
((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0598"));
LaunchThread(ESession1);
((CTCleanStep*)iStep)->RecordTestResultL();
((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0599"));
LaunchThread(ESession2);
break;
case 6:
((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0600"));
INFO_PRINTF1(_L("TypefaceStore\r\n"));
LaunchThread(ETypefaceStore1);
break;
case 7:
((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0601"));
INFO_PRINTF1(_L("Bad Message\r\n"));
LaunchThread(EBadMessage);
case 8:
((CTCleanStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
((CTCleanStep*)iStep)->CloseTMSGraphicsStep();
TestComplete();
break;
}
((CTCleanStep*)iStep)->RecordTestResultL();
}
void proxy_start(int listenport, char *extproxyaddr, int extproxyport, int (*callback_fn)(), int comeback, int singlethread)
{
//printf("proxy_start: listenport = %d\n", listenport);
proxy_listenport = listenport;
proxy_extproxyaddr = extproxyaddr != NULL ? strdup(extproxyaddr) : NULL;
proxy_extproxyport = extproxyport;
proxy_callback_fn = callback_fn;
//proxy_singlethread = 1;
proxy_singlethread = singlethread;
if (comeback)
LaunchThread(proxy_server, NULL);
else
proxy_server(NULL);
}
void flext_base::StartQueue()
{
if(qustarted) return;
#if FLEXT_QMODE == 1
# ifdef PERMANENTIDLE
sys_callback(QTick,NULL,0);
qustarted = true;
# endif
#elif FLEXT_QMODE == 2
LaunchThread(QWorker,NULL);
// very unelegant... but waiting should be ok, since happens only on loading
while(!qustarted) Sleep(0.001);
#elif FLEXT_QMODE == 0 && (FLEXT_SYS == FLEXT_SYS_PD || FLEXT_SYS == FLEXT_SYS_MAX)
// qclk = (t_qelem *)(qelem_new(NULL,(t_method)QTick));
qclk = (t_clock *)(clock_new(NULL,(t_method)QTick));
qustarted = true;
#else
# error Not implemented!
#endif
}
void VSTPlugin::Setup()
{
LaunchThread(worker);
sym_param = flext::MakeSymbol("param");
sym_event = flext::MakeSymbol("event");
sym_evmidi = flext::MakeSymbol("midi");
sym_evaudio = flext::MakeSymbol("audio");
sym_evvideo = flext::MakeSymbol("video");
sym_evparam = flext::MakeSymbol("param");
sym_evtrigger = flext::MakeSymbol("trigger");
sym_evsysex = flext::MakeSymbol("sysex");
sym_ev_ = flext::MakeSymbol("???");
sym_midi[0] = flext::MakeSymbol("noteoff");
sym_midi[1] = flext::MakeSymbol("note");
sym_midi[2] = flext::MakeSymbol("atouch");
sym_midi[3] = flext::MakeSymbol("ctlchg");
sym_midi[4] = flext::MakeSymbol("progchg");
sym_midi[5] = flext::MakeSymbol("atouch");
sym_midi[6] = flext::MakeSymbol("pbend");
sym_midi[7] = flext::MakeSymbol("sysex");
}
//
// main thread which listens for incoming http connections, and launches a thread pair
// when a connection comes in
//
static int proxy_server(void *dummy)
{
int Status;
SOCKET sock_listen, sock_client;
int oldListenPort;
char *oldextproxyaddr;
int lastError;
unsigned long nbParm = 1000;
int one = 1;
SockAddrType sockAddr;
// loop around waiting for client connection or change of listen port
while (1)
{
// create the socket
oldListenPort = proxy_listenport;
oldextproxyaddr = proxy_extproxyaddr;
if (proxy_getaddr("127.0.0.1", proxy_listenport, &sockAddr) == 0)
{
SockError("proxy_server(): failed to get socket address");
return 1;
}
// bind the socket
sock_listen = socket(AF_INET, SOCK_STREAM, 0);
//Status = setsockopt (sock_listen, IPPROTO_TCP, TCP_NODELAY, (char * ) &one, sizeof (int));
Status = bind(sock_listen, &sockAddr, sizeof(sockAddr));
if(Status < 0)
{
SockError("proxy_server(): Failed to connect socket for receiving connections");
return 1;
}
// set socket to non-blocking mode
if ((Status = SockBlock(sock_listen, 1)) < 0)
{
SockError("proxy_server(): Failed to set non-block mode on socket");
return 1;
}
// set socket to listen
if (listen(sock_listen, SOMAXCONN) != 0)
{
SockError("proxy_server(): Failed to listening mode on socket");
return 1;
}
//printf("about to start awaiting connections\n");
// loop accepting connections with timeout
while (1)
{
// if external proxy addr has changed, ditch the strdup()'ed string
if (oldextproxyaddr != proxy_extproxyaddr)
{
if (oldextproxyaddr != NULL)
free(oldextproxyaddr);
oldextproxyaddr = proxy_extproxyaddr;
}
// has someone changed the listening port?
if (oldListenPort != proxy_listenport)
{
SockClose(sock_listen);
break; // fall out to top of outer loop, set up another socket on new port
}
// check for incoming connections
if ((sock_client = accept(sock_listen, NULL, NULL)) == INVALID_SOCKET)
{
if (SockLastError() != SockErrWouldBlock)
{
SockError("proxy_server(): accept() call failed");
return 1;
}
else
{
// no connections
SockSleep();
continue;
}
}
// there's a new connection
//printf("got connection\n");
if (proxy_singlethread)
proxy_handlereq(sock_client); // single-thread mode
else
{
// spawn a thread to handle request
// p_thrdsecattr initstacksize threadfn threadarg creationflags p_retthreadid
LaunchThread(proxy_handlereq, sock_client);
}
//MessageBox(0, "Got incoming connection", "FreeWeb Proxy", MB_SYSTEMMODAL);
}
// don't add any statements after this inner loop!
} // 'while (1)'
return 0; // how on earth did we get here???
} // 'proxyServer()'
void manta::StartThread()
{
shouldStop = false;
/* start the polling thread if this is the first connected Manta */
LaunchThread(PollConnectedMantas, NULL);
}
void FileDaemon::MessageReceived(BMessage *msg) {
switch (msg->what) {
case kCheckPool: {
// A new thread will be launched if...
// - There's a request and no threads
// - The thread pool isn't full and the pool is working at 100% efficiency
if (fThreads.empty() == true) {
LaunchThread();
return;
};
uint32 threads = fThreads.size();
if ((threads < fMaxThreads) && (fRequests.size() >= threads)) {
LaunchThread();
return;
};
} break;
case kGetRequest: {
thread_id thread = B_ERROR;
if (msg->FindInt32("threadid", &thread) != B_OK) return;
thread_t::iterator tIt = fThreads.find(thread);
if (tIt == fThreads.end()) return;
if (fRequests.empty() == true) {
BMessage reply(B_REPLY);
reply.AddBool("continue", fThreads.size() == 1);
msg->SendReply(&reply);
return;
};
RequestInfo *request = fRequests[0];
fRequests.erase(fRequests.begin());
BMessage reply(B_REPLY);
reply.AddBool("continue", true);
reply.AddPointer("requestinfo", request);
msg->SendReply(&reply);
tIt->second = request;
} break;
case kRequestComplete: {
thread_id thread = B_ERROR;
RequestInfo *info = NULL;
if (msg->FindInt32("threadid", &thread) != B_OK) return;
if (msg->FindPointer("requestinfo", reinterpret_cast<void **>(&info)) != B_OK) return;
thread_t::iterator tIt = fThreads.find(thread);
if (tIt != fThreads.end()) tIt->second = NULL;
info_t::iterator iIt;
for (iIt = fRequests.begin(); iIt != fRequests.end(); iIt++) {
if ((*iIt) == info) {
delete info;
fRequests.erase(iIt);
};
}
} break;
case kThreadComplete: {
thread_id thread = B_ERROR;
if (msg->FindInt32("threadid", &thread) != B_OK) return;
thread_t::iterator tIt = fThreads.find(thread);
if (tIt != fThreads.end()) {
delete tIt->second;
fThreads.erase(tIt);
};
} break;
default: {
BLooper::MessageReceived(msg);
};
};
};
void pybase::lib_setup()
{
post("");
post("------------------------------------------------");
post("py/pyext %s - python script objects",PY__VERSION);
post("(C)2002-2015 Thomas Grill - http://grrrr.org/ext");
post("");
post("using Python %s",Py_GetVersion());
#ifdef FLEXT_DEBUG
post("");
post("DEBUG version compiled on %s %s",__DATE__,__TIME__);
#endif
// -------------------------------------------------------------
sym_response = flext::MakeSymbol("response");
#if FLEXT_SYS == FLEXT_SYS_PD
sym_fint = sym_float;
#else
sym_fint = sym_int;
#endif
// -------------------------------------------------------------
Py_Initialize();
#ifdef FLEXT_DEBUG
// Py_DebugFlag = 1;
// Py_VerboseFlag = 1;
#else
Py_OptimizeFlag = 1;
#endif
#ifdef FLEXT_THREADS
// enable thread support and acquire the global thread lock
PyEval_InitThreads();
#ifndef PY_USE_GIL
// get thread state
pythrsys = PyThreadState_Get();
// get main interpreter state
pymain = pythrsys->interp;
// add thread state of main thread to map
pythrmap[GetThreadId()] = pythrsys;
#endif // PY_USE_GIL
#endif
// sys.argv must be set to empty tuple
const char *nothing = "";
PySys_SetArgv(0,const_cast<char **>(¬hing));
// register/initialize pyext module only once!
module_obj = Py_InitModule(const_cast<char *>(PYEXT_MODULE), func_tbl);
module_dict = PyModule_GetDict(module_obj); // borrowed reference
PyModule_AddStringConstant(module_obj,"__doc__",(char *)py_doc);
// redirect stdout
PyObject* py_out;
py_out = Py_InitModule(const_cast<char *>("stdout"), StdOut_Methods);
PySys_SetObject(const_cast<char *>("stdout"), py_out);
py_out = Py_InitModule(const_cast<char *>("stderr"), StdOut_Methods);
PySys_SetObject(const_cast<char *>("stderr"), py_out);
// get garbage collector function
PyObject *gcobj = PyImport_ImportModule("gc");
if(gcobj) {
gcollect = PyObject_GetAttrString(gcobj,"collect");
Py_DECREF(gcobj);
}
builtins_obj = PyImport_ImportModule("__builtin__");
builtins_dict = PyModule_GetDict(builtins_obj); // borrowed reference
// add symbol type
initsymbol();
PyModule_AddObject(module_obj,"Symbol",(PyObject *)&pySymbol_Type);
// pre-defined symbols
PyModule_AddObject(module_obj,"_s_",(PyObject *)pySymbol__);
PyModule_AddObject(module_obj,"_s_bang",(PyObject *)pySymbol_bang);
PyModule_AddObject(module_obj,"_s_list",(PyObject *)pySymbol_list);
PyModule_AddObject(module_obj,"_s_symbol",(PyObject *)pySymbol_symbol);
PyModule_AddObject(module_obj,"_s_float",(PyObject *)pySymbol_float);
PyModule_AddObject(module_obj,"_s_int",(PyObject *)pySymbol_int);
// add samplebuffer type
initsamplebuffer();
PyModule_AddObject(module_obj,"Buffer",(PyObject *)&pySamplebuffer_Type);
// add message bundle type
initbundle();
PyModule_AddObject(module_obj,"Bundle",(PyObject *)&pyBundle_Type);
// -------------------------------------------------------------
#if FLEXT_SYS == FLEXT_SYS_PD && defined(PD_DEVEL_VERSION) && defined(PY_USE_INOFFICIAL)
// add PD paths
char *dir;
for(int i = 0; (dir = namelist_get(sys_searchpath,i)) != NULL; ++i) {
AddToPath(dir);
}
#endif
// -------------------------------------------------------------
FLEXT_SETUP(pyobj);
FLEXT_SETUP(pymeth);
FLEXT_SETUP(pyext);
#ifndef PY_NODSP
FLEXT_DSP_SETUP(pydsp);
#endif
#ifdef FLEXT_THREADS
// release global lock
PyEval_ReleaseLock();
// launch thread worker
LaunchThread(quworker,NULL);
// launch python worker
LaunchThread(pyworker,NULL);
#endif
post("------------------------------------------------");
post("");
}
