scripting.c

   1 /*
   2 Calf Box, an open source musical instrument.
   3 Copyright (C) 2010-2011 Krzysztof Foltman
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include "config.h"
  20
  21 #if USE_PYTHON
  22
  23 #include "app.h"
  24 #include "blob.h"
  25 #include "engine.h"
  26 #include "errors.h"
  27 #include "scripting.h"
  28 #include <assert.h>
  29 #include <glib.h>
  30
  31 // This is a workaround for what I consider a defect in pyconfig.h
  32 #undef _XOPEN_SOURCE
  33 #undef _POSIX_C_SOURCE
  34
  35 #include <Python.h>
  36
  37 static gboolean engine_initialised = FALSE;
  38
  39 struct PyCboxCallback
  40 {
  41     PyObject_HEAD
  42     struct cbox_command_target *target;
  43 };
  44
  45 static PyObject *
  46 PyCboxCallback_New(PyTypeObject *type, PyObject *args, PyObject *kwds)
  47 {
  48     struct PyCboxCallback *self;
  49
  50     self = (struct PyCboxCallback *)type->tp_alloc(type, 0);
  51     if (self != NULL) {
  52         self->target = NULL;
  53     }
  54
  55     return (PyObject *)self;
  56 }
  57
  58 static int
  59 PyCboxCallback_Init(struct PyCboxCallback *self, PyObject *args, PyObject *kwds)
  60 {
  61     PyObject *cobj = NULL;
  62     if (!PyArg_ParseTuple(args, "O!:init", &PyCapsule_Type, &cobj))
  63         return -1;
  64
  65     self->target = PyCapsule_GetPointer(cobj, NULL);
  66     return 0;
  67 }
  68
  69 static PyObject *cbox_python_do_cmd_on(struct cbox_command_target *ct, PyObject *self, PyObject *args);
  70
  71 static PyObject *
  72 PyCboxCallback_Call(PyObject *_self, PyObject *args, PyObject *kwds)
  73 {
  74     struct PyCboxCallback *self = (struct PyCboxCallback *)_self;
  75
  76     return cbox_python_do_cmd_on(self->target, _self, args);
  77 }
  78
  79 PyTypeObject CboxCallbackType = {
  80     PyVarObject_HEAD_INIT(NULL, 0)
  81     .tp_name = "_cbox.Callback",
  82     .tp_basicsize = sizeof(struct PyCboxCallback),
  83     .tp_flags = Py_TPFLAGS_DEFAULT,
  84     .tp_doc = "Callback for feedback channel to Cbox C code",
  85     .tp_init = (initproc)PyCboxCallback_Init,
  86     .tp_new = PyCboxCallback_New,
  87     .tp_call = PyCboxCallback_Call
  88 };
  89
  90 static gboolean set_error_from_python(GError **error)
  91 {
  92     PyObject *ptype = NULL, *pvalue = NULL, *ptraceback = NULL;
  93     PyErr_Fetch(&ptype, &pvalue, &ptraceback);
  94     PyObject *ptypestr = PyObject_Str(ptype);
  95     PyObject *pvaluestr = PyObject_Str(pvalue);
  96     PyObject *ptypestr_unicode = PyUnicode_AsUTF8String(ptypestr);
  97     PyObject *pvaluestr_unicode = PyUnicode_AsUTF8String(pvaluestr);
  98     g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "%s: %s", PyBytes_AsString(ptypestr_unicode), PyBytes_AsString(pvaluestr_unicode));
  99     Py_DECREF(pvaluestr_unicode);
 100     Py_DECREF(ptypestr_unicode);
 101     //g_error("%s:%s", PyString_AsString(ptypestr), PyString_AsString(pvaluestr));
 102     Py_DECREF(ptypestr);
 103     Py_DECREF(pvaluestr);
 104     Py_DECREF(ptype);
 105     Py_XDECREF(pvalue);
 106     Py_XDECREF(ptraceback);
 107     return FALSE;
 108 }
 109
 110 static gboolean bridge_to_python_callback(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
 111 {
 112     PyObject *callback = ct->user_data;
 113
 114     int argc = strlen(cmd->arg_types);
 115     PyObject *arg_values = PyList_New(argc);
 116     for (int i = 0; i < argc; i++)
 117     {
 118         if (cmd->arg_types[i] == 's')
 119         {
 120             PyList_SetItem(arg_values, i, PyUnicode_FromString(cmd->arg_values[i]));
 121         }
 122         else
 123         if (cmd->arg_types[i] == 'o')
 124         {
 125             struct cbox_objhdr *oh = cmd->arg_values[i];
 126             char buf[40];
 127             cbox_uuid_tostring(&oh->instance_uuid, buf);
 128             PyList_SetItem(arg_values, i, PyUnicode_FromString(buf));
 129         }
 130         else
 131         if (cmd->arg_types[i] == 'u')
 132         {
 133             struct cbox_uuid *uuid = cmd->arg_values[i];
 134             char buf[40];
 135             cbox_uuid_tostring(uuid, buf);
 136             PyList_SetItem(arg_values, i, PyUnicode_FromString(buf));
 137         }
 138         else
 139         if (cmd->arg_types[i] == 'i')
 140         {
 141             PyList_SetItem(arg_values, i, PyLong_FromLong(*(int *)cmd->arg_values[i]));
 142         }
 143         else
 144         if (cmd->arg_types[i] == 'f')
 145         {
 146             PyList_SetItem(arg_values, i, PyFloat_FromDouble(*(double *)cmd->arg_values[i]));
 147         }
 148         else
 149         if (cmd->arg_types[i] == 'b')
 150         {
 151             struct cbox_blob *blob = cmd->arg_values[i];
 152             PyList_SetItem(arg_values, i, PyByteArray_FromStringAndSize(blob->data, blob->size));
 153         }
 154         else
 155         {
 156             PyList_SetItem(arg_values, i, Py_None);
 157             Py_INCREF(Py_None);
 158         }
 159     }
 160     struct PyCboxCallback *fbcb = NULL;
 161
 162     PyObject *args = PyTuple_New(3);
 163     PyTuple_SetItem(args, 0, PyUnicode_FromString(cmd->command));
 164     PyObject *pyfb = NULL;
 165     if (fb)
 166     {
 167         struct PyCboxCallback *fbcb = PyObject_New(struct PyCboxCallback, &CboxCallbackType);
 168         fbcb->target = fb;
 169         pyfb = (PyObject *)fbcb;
 170     }
 171     else
 172     {
 173         pyfb = Py_None;
 174         Py_INCREF(Py_None);
 175     }
 176     PyTuple_SetItem(args, 1, pyfb);
 177     PyTuple_SetItem(args, 2, arg_values);
 178
 179     PyObject *result = PyObject_Call(callback, args, NULL);
 180     Py_DECREF(args);
 181
 182     if (fbcb)
 183         fbcb->target = NULL;
 184
 185     if (result)
 186     {
 187         Py_DECREF(result);
 188         return TRUE;
 189     }
 190
 191     return set_error_from_python(error);
 192 }
 193
 194 static PyObject *cbox_python_do_cmd_on(struct cbox_command_target *ct, PyObject *self, PyObject *args)
 195 {
 196     const char *command = NULL;
 197     PyObject *callback = NULL;
 198     PyObject *list = NULL;
 199     if (!PyArg_ParseTuple(args, "sOO!:do_cmd", &command, &callback, &PyList_Type, &list))
 200         return NULL;
 201
 202     int len = PyList_Size(list);
 203     void *extra = malloc(len * sizeof(double));
 204     struct cbox_osc_command cmd;
 205     GError *error = NULL;
 206     char *arg_types = malloc(len + 1);
 207     void **arg_values = malloc(2 * len * sizeof(void *));
 208     void **arg_extra = &arg_values[len];
 209     cmd.command = command;
 210     cmd.arg_types = arg_types;
 211     cmd.arg_values = arg_values;
 212     double *arg_space = extra;
 213     gboolean free_blobs = FALSE;
 214     for (int i = 0; i < len; i++)
 215     {
 216         cmd.arg_values[i] = &arg_space[i];
 217         PyObject *value = PyList_GetItem(list, i);
 218
 219         if (PyLong_Check(value))
 220         {
 221             arg_types[i] = 'i';
 222             *(int *)arg_values[i] = PyLong_AsLong(value);
 223         }
 224         else
 225         if (PyFloat_Check(value))
 226         {
 227             arg_types[i] = 'f';
 228             *(double *)arg_values[i] = PyFloat_AsDouble(value);
 229         }
 230         else
 231         if (PyUnicode_Check(value))
 232         {
 233             PyObject *utf8str = PyUnicode_AsUTF8String(value);
 234             arg_types[i] = 's';
 235             arg_extra[i] = utf8str;
 236             arg_values[i] = PyBytes_AsString(utf8str);
 237         }
 238         else
 239         if (PyByteArray_Check(value))
 240         {
 241             const void *buf = PyByteArray_AsString(value);
 242             ssize_t len = PyByteArray_Size(value);
 243
 244             if (buf)
 245             {
 246                 // note: this is not really acquired, the blob is freed using free and not cbox_blob_destroy
 247                 struct cbox_blob *blob = cbox_blob_new_acquire_data((void *)buf, len);
 248                 arg_types[i] = 'b';
 249                 arg_values[i] = blob;
 250                 free_blobs = TRUE;
 251             }
 252             else
 253                 arg_types[i] = 'N';
 254         }
 255         else
 256         {
 257             PyObject *ob_type = (PyObject *)value->ob_type;
 258             PyObject *typename_unicode = PyObject_Str(ob_type);
 259             PyObject *typename_bytes = PyUnicode_AsUTF8String(typename_unicode);
 260             PyObject *exc = PyErr_Format(PyExc_ValueError, "Cannot decode Python type '%s' to execute '%s'", PyBytes_AsString(typename_bytes), command);
 261             Py_DECREF(typename_bytes);
 262             Py_DECREF(typename_unicode);
 263
 264             return exc;
 265         }
 266     }
 267     arg_types[len] = '\0';
 268
 269     struct cbox_command_target target;
 270     cbox_command_target_init(&target, bridge_to_python_callback, callback);
 271
 272     // cbox_osc_command_dump(&cmd);
 273     Py_INCREF(callback);
 274     gboolean result = ct->process_cmd(ct, callback != Py_None ? &target : NULL, &cmd, &error);
 275     Py_DECREF(callback);
 276
 277     if (free_blobs)
 278     {
 279         for (int i = 0; i < len; i++)
 280         {
 281             if (arg_types[i] == 'b')
 282                 free(arg_values[i]);
 283             if (arg_types[i] == 's')
 284                 Py_DECREF((PyObject *)arg_extra[i]);
 285         }
 286     }
 287     free(arg_space);
 288     free(arg_values);
 289     free(arg_types);
 290
 291     if (!result)
 292         return PyErr_Format(PyExc_Exception, "%s", error ? error->message : "Unknown error");
 293
 294     Py_RETURN_NONE;
 295 }
 296
 297 static PyObject *cbox_python_do_cmd(PyObject *self, PyObject *args)
 298 {
 299     if (!engine_initialised)
 300         return PyErr_Format(PyExc_Exception, "Engine not initialised");
 301     return cbox_python_do_cmd_on(&app.cmd_target, self, args);
 302 }
 303
 304 #if CALFBOX_AS_MODULE
 305
 306 #include "config-api.h"
 307 #include "wavebank.h"
 308 #include "scene.h"
 309
 310 static gboolean audio_running = FALSE;
 311
 312 static PyObject *cbox_python_init_engine(PyObject *self, PyObject *args)
 313 {
 314     const char *config_file = NULL;
 315     if (!PyArg_ParseTuple(args, "|z:init_engine", &config_file))
 316         return NULL;
 317     if (engine_initialised)
 318         return PyErr_Format(PyExc_Exception, "Engine already initialised");
 319
 320     cbox_dom_init();
 321     app.tarpool = cbox_tarpool_new();
 322     app.document = cbox_document_new();
 323     app.rt = cbox_rt_new(app.document);
 324     app.engine = cbox_engine_new(app.document, app.rt);
 325     app.rt->engine = app.engine;
 326     cbox_config_init(config_file);
 327     cbox_wavebank_init();
 328     engine_initialised = 1;
 329
 330     Py_INCREF(Py_None);
 331     return Py_None;
 332 }
 333
 334 static PyObject *cbox_python_shutdown_engine(PyObject *self, PyObject *args)
 335 {
 336     if (!PyArg_ParseTuple(args, ":shutdown_engine"))
 337         return NULL;
 338     if (!engine_initialised)
 339         return PyErr_Format(PyExc_Exception, "Engine not initialised");
 340
 341     CBOX_DELETE(app.engine);
 342     CBOX_DELETE(app.rt);
 343     cbox_tarpool_destroy(app.tarpool);
 344     cbox_document_destroy(app.document);
 345     cbox_wavebank_close();
 346     cbox_config_close();
 347     cbox_dom_close();
 348     engine_initialised = FALSE;
 349
 350     Py_INCREF(Py_None);
 351     return Py_None;
 352 }
 353
 354 static PyObject *cbox_python_start_audio(PyObject *self, PyObject *args)
 355 {
 356     PyObject *callback = NULL;
 357     if (!PyArg_ParseTuple(args, "|O:start_audio", &callback))
 358         return NULL;
 359     if (!engine_initialised)
 360         return PyErr_Format(PyExc_Exception, "Engine not initialised");
 361     if (audio_running)
 362         return PyErr_Format(PyExc_Exception, "Audio already started");
 363
 364     struct cbox_open_params params;
 365     GError *error = NULL;
 366
 367     struct cbox_command_target target;
 368     if (callback && callback != Py_None)
 369         cbox_command_target_init(&target, bridge_to_python_callback, callback);
 370
 371     if (!cbox_io_init(&app.io, &params, (callback && callback != Py_None) ? &target : NULL, &error))
 372         return PyErr_Format(PyExc_IOError, "Cannot initialise sound I/O: %s", (error && error->message) ? error->message : "Unknown error");
 373
 374     cbox_rt_set_io(app.rt, &app.io);
 375     cbox_scene_new(app.document, app.engine);
 376     cbox_rt_start(app.rt, (callback && callback != Py_None) ? &target : NULL);
 377     audio_running = TRUE;
 378
 379     Py_INCREF(Py_None);
 380     return Py_None;
 381 }
 382
 383 static PyObject *cbox_python_start_noaudio(PyObject *self, PyObject *args)
 384 {
 385     PyObject *callback = NULL;
 386     int sample_rate = 0;
 387     if (!PyArg_ParseTuple(args, "i|O:start_noaudio", &sample_rate, &callback))
 388         return NULL;
 389     if (!engine_initialised)
 390         return PyErr_Format(PyExc_Exception, "Engine not initialised");
 391     if (audio_running)
 392         return PyErr_Format(PyExc_Exception, "Audio already started");
 393
 394     struct cbox_command_target target;
 395     if (callback && callback != Py_None)
 396         cbox_command_target_init(&target, bridge_to_python_callback, callback);
 397
 398     cbox_rt_set_offline(app.rt, sample_rate, 1024);
 399     cbox_scene_new(app.document, app.engine);
 400     cbox_rt_start(app.rt, (callback && callback != Py_None) ? &target : NULL);
 401     audio_running = TRUE;
 402
 403     Py_INCREF(Py_None);
 404     return Py_None;
 405 }
 406
 407 static PyObject *cbox_python_stop_audio(PyObject *self, PyObject *args)
 408 {
 409     if (!PyArg_ParseTuple(args, ":stop_audio"))
 410         return NULL;
 411     if (!engine_initialised)
 412         return PyErr_Format(PyExc_Exception, "Engine not initialised");
 413     if (!audio_running)
 414         return PyErr_Format(PyExc_Exception, "Audio not running");
 415
 416     while(app.engine->scene_count > 0)
 417         CBOX_DELETE(app.engine->scenes[0]);
 418     cbox_rt_stop(app.rt);
 419     cbox_io_close(&app.io);
 420     audio_running = FALSE;
 421     Py_INCREF(Py_None);
 422     return Py_None;
 423 }
 424
 425 #endif
 426
 427 static PyMethodDef CboxMethods[] = {
 428     {"do_cmd", cbox_python_do_cmd, METH_VARARGS, "Execute a CalfBox command using a global path."},
 429 #if CALFBOX_AS_MODULE
 430     {"init_engine", cbox_python_init_engine, METH_VARARGS, "Initialise the CalfBox engine using optional config file."},
 431     {"shutdown_engine", cbox_python_shutdown_engine, METH_VARARGS, "Shutdown the CalfBox engine."},
 432     {"start_audio", cbox_python_start_audio, METH_VARARGS, "Start real-time audio processing using I/O settings from the current config."},
 433     {"start_noaudio", cbox_python_start_noaudio, METH_VARARGS, "Start dummy audio processing using sample rate specified as argument."},
 434     {"stop_audio", cbox_python_stop_audio, METH_VARARGS, "Stop real-time audio processing."},
 435 #endif
 436     {NULL, NULL, 0, NULL}
 437 };
 438
 439 static PyModuleDef CboxModule = {
 440     PyModuleDef_HEAD_INIT, "_cbox", NULL, -1, CboxMethods,
 441     NULL, NULL, NULL, NULL
 442 };
 443
 444 #if CALFBOX_AS_MODULE
 445
 446 PyMODINIT_FUNC
 447 PyInit__cbox(void)
 448 {
 449     PyObject *m = PyModule_Create(&CboxModule);
 450     if (!m)
 451         return NULL;
 452     Py_INCREF(&CboxCallbackType);
 453     if (PyType_Ready(&CboxCallbackType) < 0)
 454         return NULL;
 455     PyModule_AddObject(m, "Callback", (PyObject *)&CboxCallbackType);
 456
 457     return m;
 458 }
 459
 460 #else
 461
 462 PyObject*
 463 PyInit_cbox(void)
 464 {
 465     PyObject *m = PyModule_Create(&CboxModule);
 466     PyModule_AddObject(m, "Callback", (PyObject *)&CboxCallbackType);
 467     return m;
 468 }
 469
 470 void cbox_script_run(const char *name)
 471 {
 472     FILE *fp = fopen(name, "rb");
 473     if (!fp)
 474     {
 475         g_warning("Cannot open script file '%s': %s", name, strerror(errno));
 476         return;
 477     }
 478     PyImport_AppendInittab("_cbox", &PyInit_cbox);
 479     Py_Initialize();
 480     if (PyType_Ready(&CboxCallbackType) < 0)
 481     {
 482         g_warning("Cannot install the C callback type");
 483         return;
 484     }
 485     Py_INCREF(&CboxCallbackType);
 486     engine_initialised = TRUE;
 487
 488     if (PyRun_SimpleFile(fp, name) == 1)
 489     {
 490         GError *error = NULL;
 491         set_error_from_python(&error);
 492         cbox_print_error(error);
 493     }
 494     Py_Finalize();
 495 }
 496
 497 #endif
 498 #endif