X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=module_sigrokdecode.c;h=a18583bb5ea9b6ae33ebd1e17804f1f046540a15;hp=b547e9d697019d0f7459ba8423d4b244f37f10ff;hb=f8e458577f72a5b13fa83b6cd3675a7eefc83072;hpb=bc5f5a434e148db1843be7b02b95a35d21237702;ds=inline diff --git a/module_sigrokdecode.c b/module_sigrokdecode.c index b547e9d..a18583b 100644 --- a/module_sigrokdecode.c +++ b/module_sigrokdecode.c @@ -18,73 +18,158 @@ */ #include "sigrokdecode.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */ +#include "sigrokdecode-internal.h" #include "config.h" /* lives in type_logic.c */ extern PyTypeObject srd_logic_type; -/* TODO: not used, doesn't work actually */ -static PyObject *Decoder_init(PyObject *self, PyObject *args) +static int convert_pyobj(struct srd_decoder_instance *di, PyObject *obj, + int *ann_format, char ***ann) { - (void)self; - (void)args; - printf("init Decoder object %p\n", self); + PyObject *py_tmp; + struct srd_pd_output *pdo; + int ann_id; - Py_RETURN_NONE; + /* Should be a list of [annotation format, [string, ...]] */ + if (!PyList_Check(obj) && !PyTuple_Check(obj)) { + srd_err("Protocol decoder %s submitted %s instead of list", + di->decoder->name, obj->ob_type->tp_name); + return SRD_ERR_PYTHON; + } + + /* Should have 2 elements... */ + if (PyList_Size(obj) != 2) { + srd_err("Protocol decoder %s submitted annotation list with %d elements instead of 2", + di->decoder->name, PyList_Size(obj)); + return SRD_ERR_PYTHON; + } + + /* First element should be an integer matching a previously + * registered annotation format. */ + py_tmp = PyList_GetItem(obj, 0); + if (!PyLong_Check(py_tmp)) { + srd_err("Protocol decoder %s submitted annotation list, but first element was not an integer", + di->decoder->name); + return SRD_ERR_PYTHON; + } + + ann_id = PyLong_AsLong(py_tmp); + if (!(pdo = g_slist_nth_data(di->decoder->annotations, ann_id))) { + srd_err("Protocol decoder %s submitted data to non-existent annotation format %d", + di->decoder->name, ann_id); + return SRD_ERR_PYTHON; + } + *ann_format = ann_id; + + /* Second element must be a list */ + py_tmp = PyList_GetItem(obj, 1); + if (!PyList_Check(py_tmp)) { + srd_err("Protocol decoder %s submitted annotation list, but second element was not a list", + di->decoder->name); + return SRD_ERR_PYTHON; + } + if (py_strlist_to_char(py_tmp, ann) != SRD_OK) { + srd_err("Protocol decoder %s submitted annotation list, but second element was malformed", + di->decoder->name); + return SRD_ERR_PYTHON; + } + + return SRD_OK; } static PyObject *Decoder_put(PyObject *self, PyObject *args) { GSList *l; - PyObject *data; - struct srd_decoder_instance *di; + PyObject *data, *py_res; + struct srd_decoder_instance *di, *next_di; struct srd_pd_output *pdo; - uint64_t timeoffset, duration; + struct srd_proto_data *pdata; + uint64_t start_sample, end_sample; int output_id; + void (*cb)(); if (!(di = get_di_by_decobject(self))) return NULL; - if (!PyArg_ParseTuple(args, "KKiO", &timeoffset, &duration, &output_id, &data)) + if (!PyArg_ParseTuple(args, "KKiO", &start_sample, &end_sample, &output_id, &data)) return NULL; if (!(l = g_slist_nth(di->pd_output, output_id))) { - /* PD supplied invalid output id */ - /* TODO: better error message */ + srd_err("Protocol decoder %s submitted invalid output ID %d", + di->decoder->name, output_id); return NULL; } pdo = l->data; - /* TODO: SRD_OUTPUT_ANNOTATION should go back up to the caller, - * and SRD_OUTPUT_PROTOCOL should go up the PD stack. - */ - printf("stream %d: ", pdo->output_type); - PyObject_Print(data, stdout, Py_PRINT_RAW); - puts(""); + if (!(pdata = g_try_malloc0(sizeof(struct srd_proto_data)))) + return NULL; + pdata->start_sample = start_sample; + pdata->end_sample = end_sample; + pdata->pdo = pdo; + + switch (pdo->output_type) { + case SRD_OUTPUT_ANN: + /* Annotations are only fed to callbacks. */ + if ((cb = srd_find_callback(pdo->output_type))) { + /* Annotations need converting from PyObject. */ + if (convert_pyobj(di, data, &pdata->ann_format, + (char ***)&pdata->data) != SRD_OK) { + /* An error was already logged. */ + break; + } + cb(pdata); + } + break; + case SRD_OUTPUT_PROTO: + for (l = di->next_di; l; l = l->next) { + next_di = l->data; + /* TODO: is this needed? */ + Py_XINCREF(next_di->py_instance); + if (!(py_res = PyObject_CallMethod(next_di->py_instance, "decode", + "KKO", start_sample, end_sample, data))) { + if (PyErr_Occurred()) + PyErr_Print(); + } + Py_XDECREF(py_res); + } + break; + case SRD_OUTPUT_BINARY: + srd_err("SRD_OUTPUT_BINARY not yet supported"); + break; + default: + srd_err("Protocol decoder %s submitted invalid output type %d", + di->decoder->name, pdo->output_type); + break; + } + + g_free(pdata); Py_RETURN_NONE; } -static PyObject *Decoder_output_new(PyObject *self, PyObject *py_output_type) +static PyObject *Decoder_add(PyObject *self, PyObject *args) { PyObject *ret; struct srd_decoder_instance *di; - char *protocol_id, *description; + char *proto_id; int output_type, pdo_id; - if (!(di = get_di_by_decobject(self))) + if (!(di = get_di_by_decobject(self))) { + srd_err("%s():%d decoder instance not found", __func__, __LINE__); + PyErr_SetString(PyExc_Exception, "decoder instance not found"); return NULL; + } - printf("output_new di %s\n", di->decoder->name); - - if (!PyArg_ParseTuple(py_output_type, "i:output_type", &output_type)) + if (!PyArg_ParseTuple(args, "is", &output_type, &proto_id)) { + if (PyErr_Occurred()) + PyErr_Print(); return NULL; + } - protocol_id = "i2c"; - description = "blah"; - pdo_id = pd_output_new(di, output_type, protocol_id, description); + pdo_id = pd_add(di, output_type, proto_id); if (pdo_id < 0) Py_RETURN_NONE; else @@ -97,30 +182,24 @@ static PyMethodDef no_methods[] = { {NULL, NULL, 0, NULL} }; static PyMethodDef Decoder_methods[] = { {"put", Decoder_put, METH_VARARGS, "Accepts a dictionary with the following keys: time, duration, data"}, - {"output_new", Decoder_output_new, METH_VARARGS, - "Create a new output stream"}, + {"add", Decoder_add, METH_VARARGS, "Create a new output stream"}, {NULL, NULL, 0, NULL} }; -typedef struct { - PyObject_HEAD -} sigrok_Decoder_object; - -static PyTypeObject srd_Decoder_type = { +PyTypeObject srd_Decoder_type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "sigrokdecode.Decoder", - .tp_basicsize = sizeof(sigrok_Decoder_object), + .tp_basicsize = sizeof(srd_Decoder), .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, - .tp_doc = "Sigrok Decoder object", + .tp_doc = "Sigrok Decoder base class", .tp_methods = Decoder_methods, - .tp_init = (initproc) Decoder_init, }; static struct PyModuleDef sigrokdecode_module = { PyModuleDef_HEAD_INIT, .m_name = "sigrokdecode", - .m_doc = "sigrokdecode base class", + .m_doc = "sigrokdecode module", .m_size = -1, .m_methods = no_methods, }; @@ -146,6 +225,17 @@ PyMODINIT_FUNC PyInit_sigrokdecode(void) if (PyModule_AddObject(mod, "srd_logic", (PyObject *)&srd_logic_type) == -1) return NULL; + /* expose output types as symbols in the sigrokdecode module */ + if(PyModule_AddObject(mod, "OUTPUT_ANN", + PyLong_FromLong(SRD_OUTPUT_ANN)) == -1) + return NULL; + if(PyModule_AddObject(mod, "OUTPUT_PROTO", + PyLong_FromLong(SRD_OUTPUT_PROTO)) == -1) + return NULL; + if(PyModule_AddObject(mod, "OUTPUT_BINARY", + PyLong_FromLong(SRD_OUTPUT_BINARY)) == -1) + return NULL; + return mod; }