X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=type_decoder.c;h=52f7ca0640b31a3f53f7403ee39c4dd935415ab7;hp=19fd3508bd723a3ed965f9c8a8b25ae165a23578;hb=0169f19c53e195df2f96c4df731ad3214c59e20a;hpb=b33b8aa56ec27edf57cd7dc3d735370f60bfe13d diff --git a/type_decoder.c b/type_decoder.c index 19fd350..52f7ca0 100644 --- a/type_decoder.c +++ b/type_decoder.c @@ -1,5 +1,5 @@ /* - * This file is part of the sigrok project. + * This file is part of the libsigrokdecode project. * * Copyright (C) 2012 Bert Vermeulen * @@ -17,24 +17,27 @@ * along with this program. If not, see . */ -#include "sigrokdecode.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */ -#include "sigrokdecode-internal.h" +#include "libsigrokdecode.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */ +#include "libsigrokdecode-internal.h" #include "config.h" #include /* This is only used for nicer srd_dbg() output. */ static const char *OUTPUT_TYPES[] = { "OUTPUT_ANN", - "OUTPUT_PROTO", + "OUTPUT_PYTHON", "OUTPUT_BINARY", + "OUTPUT_META", }; -static int convert_pyobj(struct srd_decoder_inst *di, PyObject *obj, - int *ann_format, char ***ann) +static int convert_annotation(struct srd_decoder_inst *di, PyObject *obj, + struct srd_proto_data *pdata) { PyObject *py_tmp; struct srd_pd_output *pdo; - int ann_id; + struct srd_proto_data_annotation *pda; + int ann_format; + char **ann_text; /* Should be a list of [annotation format, [string, ...]]. */ if (!PyList_Check(obj) && !PyTuple_Check(obj)) { @@ -61,14 +64,12 @@ static int convert_pyobj(struct srd_decoder_inst *di, PyObject *obj, "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))) { + ann_format = PyLong_AsLong(py_tmp); + if (!(pdo = g_slist_nth_data(di->decoder->annotations, ann_format))) { srd_err("Protocol decoder %s submitted data to unregistered " - "annotation format %d.", di->decoder->name, ann_id); + "annotation format %d.", di->decoder->name, ann_format); return SRD_ERR_PYTHON; } - *ann_format = ann_id; /* Second element must be a list. */ py_tmp = PyList_GetItem(obj, 1); @@ -77,25 +78,61 @@ static int convert_pyobj(struct srd_decoder_inst *di, PyObject *obj, "second element was not a list.", di->decoder->name); return SRD_ERR_PYTHON; } - if (py_strlist_to_char(py_tmp, ann) != SRD_OK) { + if (py_strlist_to_char(py_tmp, &ann_text) != SRD_OK) { srd_err("Protocol decoder %s submitted annotation list, but " "second element was malformed.", di->decoder->name); return SRD_ERR_PYTHON; } + if (!(pda = g_try_malloc(sizeof(struct srd_proto_data_annotation)))) + return SRD_ERR_MALLOC; + pda->ann_format = ann_format; + pda->ann_text = ann_text; + pdata->data = pda; + + return SRD_OK; +} + +static int convert_meta(struct srd_proto_data *pdata, PyObject *obj) +{ + long long intvalue; + double dvalue; + + if (pdata->pdo->meta_type == G_VARIANT_TYPE_INT64) { + if (!PyLong_Check(obj)) { + PyErr_Format(PyExc_TypeError, "This output was registered " + "as 'int', but '%s' was passed.", obj->ob_type->tp_name); + return SRD_ERR_PYTHON; + } + intvalue = PyLong_AsLongLong(obj); + if (PyErr_Occurred()) + return SRD_ERR_PYTHON; + pdata->data = g_variant_new_int64(intvalue); + } else if (pdata->pdo->meta_type == G_VARIANT_TYPE_DOUBLE) { + if (!PyFloat_Check(obj)) { + PyErr_Format(PyExc_TypeError, "This output was registered " + "as 'float', but '%s' was passed.", obj->ob_type->tp_name); + return SRD_ERR_PYTHON; + } + dvalue = PyFloat_AsDouble(obj); + if (PyErr_Occurred()) + return SRD_ERR_PYTHON; + pdata->data = g_variant_new_double(dvalue); + } + return SRD_OK; } static PyObject *Decoder_put(PyObject *self, PyObject *args) { GSList *l; - PyObject *data, *py_res; + PyObject *py_data, *py_res; struct srd_decoder_inst *di, *next_di; struct srd_pd_output *pdo; struct srd_proto_data *pdata; uint64_t start_sample, end_sample; int output_id; - void (*cb)(); + struct srd_pd_callback *cb; if (!(di = srd_inst_find_by_obj(NULL, self))) { /* Shouldn't happen. */ @@ -104,7 +141,7 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) } if (!PyArg_ParseTuple(args, "KKiO", &start_sample, &end_sample, - &output_id, &data)) { + &output_id, &py_data)) { /* * This throws an exception, but by returning NULL here we let * Python raise it. This results in a much better trace in @@ -135,17 +172,16 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) switch (pdo->output_type) { case SRD_OUTPUT_ANN: /* Annotations are only fed to callbacks. */ - if ((cb = srd_pd_output_callback_find(pdo->output_type))) { + if ((cb = srd_pd_output_callback_find(di->sess, pdo->output_type))) { /* Annotations need converting from PyObject. */ - if (convert_pyobj(di, data, &pdata->ann_format, - (char ***)&pdata->data) != SRD_OK) { + if (convert_annotation(di, py_data, pdata) != SRD_OK) { /* An error was already logged. */ break; } - cb(pdata); + cb->cb(pdata, cb->cb_data); } break; - case SRD_OUTPUT_PROTO: + case SRD_OUTPUT_PYTHON: for (l = di->next_di; l; l = l->next) { next_di = l->data; /* TODO: Is this needed? */ @@ -155,9 +191,9 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) next_di->inst_id); if (!(py_res = PyObject_CallMethod( next_di->py_inst, "decode", "KKO", start_sample, - end_sample, data))) { - catch_exception("Calling %s decode(): ", - next_di->inst_id); + end_sample, py_data))) { + srd_exception_catch("Calling %s decode(): ", + next_di->inst_id); } Py_XDECREF(py_res); } @@ -165,6 +201,16 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) case SRD_OUTPUT_BINARY: srd_err("SRD_OUTPUT_BINARY not yet supported."); break; + case SRD_OUTPUT_META: + if ((cb = srd_pd_output_callback_find(di->sess, pdo->output_type))) { + /* Annotations need converting from PyObject. */ + if (convert_meta(pdata, py_data) != SRD_OK) { + /* An exception was already set up. */ + break; + } + cb->cb(pdata, cb->cb_data); + } + break; default: srd_err("Protocol decoder %s submitted invalid output type %d.", di->decoder->name, pdo->output_type); @@ -176,39 +222,98 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) Py_RETURN_NONE; } -static PyObject *Decoder_add(PyObject *self, PyObject *args) +static PyObject *Decoder_register(PyObject *self, PyObject *args, + PyObject *kwargs) { - PyObject *ret; struct srd_decoder_inst *di; - char *proto_id; - int output_type, pdo_id; + struct srd_pd_output *pdo; + PyObject *py_new_output_id; + PyTypeObject *meta_type_py; + const GVariantType *meta_type_gv; + int output_type; + char *proto_id, *meta_name, *meta_descr; + char *keywords[] = {"output_type", "proto_id", "meta", NULL}; + + meta_type_py = NULL; + meta_type_gv = NULL; + meta_name = meta_descr = NULL; if (!(di = srd_inst_find_by_obj(NULL, self))) { PyErr_SetString(PyExc_Exception, "decoder instance not found"); return NULL; } - if (!PyArg_ParseTuple(args, "is", &output_type, &proto_id)) { + /* Default to instance id, which defaults to class id. */ + proto_id = di->inst_id; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|s(Oss)", keywords, + &output_type, &proto_id, + &meta_type_py, &meta_name, &meta_descr)) { /* Let Python raise this exception. */ return NULL; } - pdo_id = pd_add(di, output_type, proto_id); - if (pdo_id < 0) - Py_RETURN_NONE; - else - ret = Py_BuildValue("i", pdo_id); + /* Check if the meta value's type is supported. */ + if (output_type == SRD_OUTPUT_META) { + if (meta_type_py == &PyLong_Type) + meta_type_gv = G_VARIANT_TYPE_INT64; + else if (meta_type_py == &PyFloat_Type) + meta_type_gv = G_VARIANT_TYPE_DOUBLE; + else { + PyErr_Format(PyExc_TypeError, "Unsupported type '%s'.", + meta_type_py->tp_name); + return NULL; + } + } + + srd_dbg("Instance %s creating new output type %d for %s.", + di->inst_id, output_type, proto_id); + + if (!(pdo = g_try_malloc(sizeof(struct srd_pd_output)))) { + PyErr_SetString(PyExc_MemoryError, "struct srd_pd_output"); + return NULL; + } + + /* pdo_id is just a simple index, nothing is deleted from this list anyway. */ + pdo->pdo_id = g_slist_length(di->pd_output); + pdo->output_type = output_type; + pdo->di = di; + pdo->proto_id = g_strdup(proto_id); + + if (output_type == SRD_OUTPUT_META) { + pdo->meta_type = meta_type_gv; + pdo->meta_name = g_strdup(meta_name); + pdo->meta_descr = g_strdup(meta_descr); + } + + di->pd_output = g_slist_append(di->pd_output, pdo); + py_new_output_id = Py_BuildValue("i", pdo->pdo_id); + + return py_new_output_id; +} + +/* TODO: this is just a stub that calls _register() until all PDs + * are changed to use the new register API. */ +static PyObject *Decoder_add(PyObject *self, PyObject *args) +{ + PyObject *py_keywords, *py_new_output_id; + + py_keywords = PyDict_New(); + py_new_output_id = Decoder_register(self, args, py_keywords); + Py_DecRef(py_keywords); - return ret; + return py_new_output_id; } static PyMethodDef Decoder_methods[] = { {"put", Decoder_put, METH_VARARGS, "Accepts a dictionary with the following keys: startsample, endsample, data"}, {"add", Decoder_add, METH_VARARGS, "Create a new output stream"}, + {"register", (PyCFunction)Decoder_register, METH_VARARGS|METH_KEYWORDS, + "Register a new output stream"}, {NULL, NULL, 0, NULL} }; +/** @cond PRIVATE */ SRD_PRIV PyTypeObject srd_Decoder_type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "sigrokdecode.Decoder", @@ -217,3 +322,4 @@ SRD_PRIV PyTypeObject srd_Decoder_type = { .tp_doc = "sigrok Decoder base class", .tp_methods = Decoder_methods, }; +/** @endcond */