X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=controller.c;h=3292603b1df909f0fb250f5ddf7e927cd45206fb;hb=4244f8252706c5715a5598c51914f4f8d20c5e84;hp=963345c637c1b09ce550ecf623f1778ed48faf3c;hpb=451680f192b97d652fb02186f5201efa0d668a2a;p=libsigrokdecode.git diff --git a/controller.c b/controller.c index 963345c..3292603 100644 --- a/controller.c +++ b/controller.c @@ -23,6 +23,7 @@ #include "config.h" #include #include +#include static GSList *di_list = NULL; @@ -113,74 +114,292 @@ int srd_exit(void) * Add search directories for the protocol decoders. * * TODO: add path from env var SIGROKDECODE_PATH, config etc + * TODO: Should take directoryname/path as input. */ int set_modulepath(void) { int ret; + gchar *path, *s; - PyRun_SimpleString("import sys"); - ret = PyRun_SimpleString("sys.path.append(r'" DECODERS_DIR "');"); +#ifdef _WIN32 + gchar **splitted; + + /* + * On Windows/MinGW, Python's sys.path needs entries of the form + * 'C:\\foo\\bar' instead of '/foo/bar'. + */ + + splitted = g_strsplit(DECODERS_DIR, "/", 0); + path = g_build_pathv("\\\\", splitted); + g_strfreev(splitted); +#else + path = g_strdup(DECODERS_DIR); +#endif + + /* TODO: Prepend instead of appending. */ + /* TODO: Sanity check on 'path' (length, escape special chars, ...). */ + s = g_strdup_printf("import sys; sys.path.append(r'%s')", path); + + ret = PyRun_SimpleString(s); + + g_free(path); + g_free(s); return ret; } /** - * Create a new protocol decoder instance. + * Set options in a decoder instance. + * + * @param di Decoder instance. + * @param options A GHashTable of options to set. + * + * Handled options are removed from the hash. + * + * @return SRD_OK upon success, a (negative) error code otherwise. + */ +int srd_instance_set_options(struct srd_decoder_instance *di, + GHashTable *options) +{ + PyObject *py_dec_options, *py_dec_optkeys, *py_di_options, *py_optval; + PyObject *py_optlist, *py_classval; + Py_UNICODE *py_ustr; + unsigned long long int val_ull; + int num_optkeys, ret, size, i; + char *key, *value; + + if(!PyObject_HasAttrString(di->decoder->py_dec, "options")) { + /* Decoder has no options. */ + if (g_hash_table_size(options) == 0) { + /* No options provided. */ + return SRD_OK; + } else { + srd_err("Protocol decoder has no options."); + return SRD_ERR_ARG; + } + return SRD_OK; + } + + ret = SRD_ERR_PYTHON; + key = NULL; + py_dec_options = py_dec_optkeys = py_di_options = py_optval = NULL; + py_optlist = py_classval = NULL; + py_dec_options = PyObject_GetAttrString(di->decoder->py_dec, "options"); + + /* All of these are synthesized objects, so they're good. */ + py_dec_optkeys = PyDict_Keys(py_dec_options); + num_optkeys = PyList_Size(py_dec_optkeys); + if (!(py_di_options = PyObject_GetAttrString(di->py_instance, "options"))) + goto err_out; + for (i = 0; i < num_optkeys; i++) { + /* Get the default class value for this option. */ + py_str_as_str(PyList_GetItem(py_dec_optkeys, i), &key); + if (!(py_optlist = PyDict_GetItemString(py_dec_options, key))) + goto err_out; + if (!(py_classval = PyList_GetItem(py_optlist, 1))) + goto err_out; + if (!PyUnicode_Check(py_classval) && !PyLong_Check(py_classval)) { + srd_err("Options of type %s are not yet supported.", Py_TYPE(py_classval)->tp_name); + goto err_out; + } + + if ((value = g_hash_table_lookup(options, key))) { + /* An override for this option was provided. */ + if (PyUnicode_Check(py_classval)) { + if (!(py_optval = PyUnicode_FromString(value))) { + /* Some UTF-8 encoding error. */ + PyErr_Clear(); + goto err_out; + } + } else if (PyLong_Check(py_classval)) { + if (!(py_optval = PyLong_FromString(value, NULL, 0))) { + /* ValueError Exception */ + PyErr_Clear(); + srd_err("Option %s has invalid value %s: expected integer", + key, value); + goto err_out; + } + } + g_hash_table_remove(options, key); + } else { + /* Use the class default for this option. */ + if (PyUnicode_Check(py_classval)) { + /* Make a brand new copy of the string. */ + py_ustr = PyUnicode_AS_UNICODE(py_classval); + size = PyUnicode_GET_SIZE(py_classval); + py_optval = PyUnicode_FromUnicode(py_ustr, size); + } else if (PyLong_Check(py_classval)) { + /* Make a brand new copy of the integer. */ + val_ull = PyLong_AsUnsignedLongLong(py_classval); + if (val_ull == (unsigned long long)-1) { + /* OverFlowError exception */ + PyErr_Clear(); + srd_err("Invalid integer value for %s: expected integer", key); + goto err_out; + } + if (!(py_optval = PyLong_FromUnsignedLongLong(val_ull))) + goto err_out; + } + } + + /* If we got here, py_optval holds a known good new reference + * to the instance option to set. + */ + if (PyDict_SetItemString(py_di_options, key, py_optval) == -1) + goto err_out; + } + + ret = SRD_OK; + +err_out: + Py_XDECREF(py_optlist); + Py_XDECREF(py_di_options); + Py_XDECREF(py_dec_optkeys); + Py_XDECREF(py_dec_options); + if (key) + g_free(key); + if (PyErr_Occurred()) { + srd_dbg("stray exception!"); + PyErr_Print(); + PyErr_Clear(); + } + + return ret; +} + +static gint compare_probe_id(struct srd_probe *a, char *probe_id) +{ + + return strcmp(a->id, probe_id); +} + +/** + * Set probes in a decoder instance. + * + * @param di Decoder instance. + * @param probes A GHashTable of probes to set. Key is probe name, value is + * the probe number. Samples passed to this instance will be arranged in this + * order. * - * TODO: this should be a decoder name, as decoder ids will disappear. + * @return SRD_OK upon success, a (negative) error code otherwise. + */ +int srd_instance_set_probes(struct srd_decoder_instance *di, + GHashTable *new_probes) +{ + GList *l; + GSList *sl; + struct srd_probe *p; + int *new_probemap, new_probenum; + char *probe_id; + + if (g_hash_table_size(new_probes) == 0) + /* No probes provided. */ + return SRD_OK; + + if(!PyObject_HasAttrString(di->decoder->py_dec, "probes") + && !PyObject_HasAttrString(di->decoder->py_dec, "extra_probes")) { + /* Decoder has no probes. */ + srd_err("Protocol decoder %s has no probes to define.", + di->decoder->name); + return SRD_ERR_ARG; + } + + new_probemap = NULL; + + if (!(new_probemap = g_try_malloc(sizeof(int) * di->dec_num_probes))) { + srd_err("Failed to malloc new probe map."); + return SRD_ERR_MALLOC; + } + + for (l = g_hash_table_get_keys(new_probes); l; l = l->next) { + probe_id = l->data; + new_probenum = strtol(g_hash_table_lookup(new_probes, probe_id), NULL, 10); + if (!(sl = g_slist_find_custom(di->decoder->probes, probe_id, + (GCompareFunc)compare_probe_id))) { + /* Fall back on optional probes. */ + if (!(sl = g_slist_find_custom(di->decoder->extra_probes, + probe_id, (GCompareFunc)compare_probe_id))) { + srd_err("Protocol decoder %s has no probe '%s'", + di->decoder->name, probe_id); + g_free(new_probemap); + return SRD_ERR_ARG; + } + } + p = sl->data; + new_probemap[p->order] = new_probenum; + } + g_free(di->dec_probemap); + di->dec_probemap = new_probemap; + + return SRD_OK; +} + +/** + * Create a new protocol decoder instance. * * @param id Decoder 'id' field. - * @param instance_id Optional unique identifier for this instance. If NULL, - * the 'id' parameter is used. + * @param options GHashtable of options which override the defaults set in + * the decoder class. * @return Pointer to a newly allocated struct srd_decoder_instance, or - * NULL in case of failure. + * NULL in case of failure. */ -struct srd_decoder_instance *srd_instance_new(const char *id, - const char *instance_id) +struct srd_decoder_instance *srd_instance_new(const char *decoder_id, + GHashTable *options) { struct srd_decoder *dec; struct srd_decoder_instance *di; - PyObject *py_args; + int i; + char *instance_id; - srd_dbg("%s: creating new %s instance", __func__, id); + srd_dbg("%s: creating new %s instance", __func__, decoder_id); - if (!(dec = srd_get_decoder_by_id(id))) + if (!(dec = srd_get_decoder_by_id(decoder_id))) { + srd_err("Protocol decoder %s not found.", decoder_id); return NULL; + } - if (!(di = g_try_malloc(sizeof(*di)))) { - srd_err("failed to malloc instance"); + if (!(di = g_try_malloc0(sizeof(*di)))) { + srd_err("Failed to malloc instance."); return NULL; } + + instance_id = g_hash_table_lookup(options, "id"); di->decoder = dec; - di->instance_id = g_strdup(instance_id ? instance_id : id); - di->pd_output = NULL; - di->num_probes = 0; - di->unitsize = 0; - di->samplerate = 0; - di->next_di = NULL; - - /* Create an empty Python tuple. */ - if (!(py_args = PyTuple_New(0))) { /* NEWREF */ - if (PyErr_Occurred()) - PyErr_Print(); + di->instance_id = g_strdup(instance_id ? instance_id : decoder_id); + g_hash_table_remove(options, "id"); + + /* Prepare a default probe map, where samples come in the + * order in which the decoder class defined them. + */ + di->dec_num_probes = g_slist_length(di->decoder->probes) + + g_slist_length(di->decoder->extra_probes); + if (!(di->dec_probemap = g_try_malloc(sizeof(int) * di->dec_num_probes))) { + srd_err("Failed to malloc probe map."); + g_free(di); return NULL; } + for (i = 0; i < di->dec_num_probes; i++) + di->dec_probemap[i] = i; - /* Create an instance of the 'Decoder' class. */ - di->py_instance = PyObject_Call(dec->py_dec, py_args, NULL); - if (!di->py_instance) { + /* Create a new instance of this decoder class. */ + if (!(di->py_instance = PyObject_CallObject(dec->py_dec, NULL))) { if (PyErr_Occurred()) PyErr_Print(); - Py_XDECREF(py_args); + g_free(di->dec_probemap); + g_free(di); + return NULL; + } + + if (srd_instance_set_options(di, options) != SRD_OK) { + g_free(di->dec_probemap); + g_free(di); return NULL; } /* Instance takes input from a frontend by default. */ di_list = g_slist_append(di_list, di); - Py_XDECREF(py_args); - return di; } @@ -208,28 +427,6 @@ int srd_instance_stack(struct srd_decoder_instance *di_from, } -int srd_instance_set_probe(struct srd_decoder_instance *di, - const char *probename, int num) -{ - PyObject *probedict, *probenum; - - probedict = PyObject_GetAttrString(di->py_instance, "probes"); /* NEWREF */ - if (!probedict) { - if (PyErr_Occurred()) - PyErr_Print(); /* Returns void. */ - - return SRD_ERR_PYTHON; /* TODO: More specific error? */ - } - - probenum = PyLong_FromLong(num); - PyMapping_SetItemString(probedict, (char *)probename, probenum); - - Py_XDECREF(probenum); - Py_XDECREF(probedict); - - return SRD_OK; -} - /* TODO: this should go into the PD stack */ struct srd_decoder_instance *srd_instance_find(char *instance_id) { @@ -268,8 +465,8 @@ int srd_instance_start(struct srd_decoder_instance *di, PyObject *args) return SRD_ERR_PYTHON; } - Py_XDECREF(py_res); - Py_DECREF(py_name); + Py_DecRef(py_res); + Py_DecRef(py_name); return SRD_OK; } @@ -283,11 +480,12 @@ int srd_instance_start(struct srd_decoder_instance *di, PyObject *args) * * @return SRD_OK upon success, a (negative) error code otherwise. */ -int srd_instance_decode(uint64_t timeoffset, uint64_t duration, +int srd_instance_decode(uint64_t start_samplenum, struct srd_decoder_instance *di, uint8_t *inbuf, uint64_t inbuflen) { PyObject *py_instance, *py_res; srd_logic *logic; + uint64_t end_samplenum; /* Return an error upon unusable input. */ if (di == NULL) @@ -304,14 +502,16 @@ int srd_instance_decode(uint64_t timeoffset, uint64_t duration, logic = PyObject_New(srd_logic, &srd_logic_type); Py_INCREF(logic); logic->di = di; + logic->start_samplenum = start_samplenum; logic->itercnt = 0; logic->inbuf = inbuf; logic->inbuflen = inbuflen; logic->sample = PyList_New(2); Py_INCREF(logic->sample); + end_samplenum = start_samplenum + inbuflen / di->data_unitsize; if (!(py_res = PyObject_CallMethod(py_instance, "decode", - "KKO", timeoffset, duration, logic))) { + "KKO", logic->start_samplenum, end_samplenum, logic))) { if (PyErr_Occurred()) PyErr_Print(); /* Returns void. */ @@ -339,9 +539,9 @@ int srd_session_start(int num_probes, int unitsize, uint64_t samplerate) /* Run the start() method on all decoders receiving frontend data. */ for (d = di_list; d; d = d->next) { di = d->data; - di->num_probes = num_probes; - di->unitsize = unitsize; - di->samplerate = samplerate; + di->data_num_probes = num_probes; + di->data_unitsize = unitsize; + di->data_samplerate = samplerate; if ((ret = srd_instance_start(di, args) != SRD_OK)) return ret; @@ -360,14 +560,13 @@ int srd_session_start(int num_probes, int unitsize, uint64_t samplerate) } /* Feed logic samples to decoder session. */ -int srd_session_feed(uint64_t timeoffset, uint64_t duration, uint8_t *inbuf, - uint64_t inbuflen) +int srd_session_feed(uint64_t start_samplenum, uint8_t *inbuf, uint64_t inbuflen) { GSList *d; int ret; for (d = di_list; d; d = d->next) { - if ((ret = srd_instance_decode(timeoffset, duration, d->data, inbuf, + if ((ret = srd_instance_decode(start_samplenum, d->data, inbuf, inbuflen)) != SRD_OK) return ret; }