static PyObject *Decoder_add(PyObject *self, PyObject *args)
{
PyObject *ret;
struct srd_decoder_inst *di;
char *proto_id;
int output_type, pdo_id;
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)) {
/* Let Python raise this exception. */
return NULL;
}
pdo_id = srd_inst_pd_output_add(di, output_type, proto_id);
if (pdo_id < 0)
Py_RETURN_NONE;
else
ret = Py_BuildValue("i", pdo_id);
return ret;
}
/**
* Find a decoder instance by its Python object.
*
* I.e. find that instance's instantiation of the sigrokdecode.Decoder class.
* This will recurse to find the instance anywhere in the stack tree.
*
* @param stack Pointer to a GSList of struct srd_decoder_inst, indicating the
* stack to search. To start searching at the bottom level of
* decoder instances, pass NULL.
* @param obj The Python class instantiation.
*
* @return Pointer to struct srd_decoder_inst, or NULL if not found.
*/
SRD_PRIV struct srd_decoder_inst *srd_inst_find_by_obj(const GSList *stack,
const PyObject *obj)
{
// TODO?
const GSList *l;
struct srd_decoder_inst *tmp, *di;
di = NULL;
for (l = stack ? stack : di_list; di == NULL && l != NULL; l = l->next) {
tmp = l->data;
if (tmp->py_inst == obj)
di = tmp;
else if (tmp->next_di)
di = srd_inst_find_by_obj(tmp->next_di, obj);
}
return di;
}
/**
* Return whether the specified channel was supplied to the decoder.
*
* @param self TODO. Must not be NULL.
* @param args TODO. Must not be NULL.
*
* @retval Py_True The channel has been supplied by the frontend.
* @retval Py_False The channel has been supplied by the frontend.
* @retval NULL An error occurred.
*/
static PyObject *Decoder_has_channel(PyObject *self, PyObject *args)
{
int idx, max_idx;
struct srd_decoder_inst *di;
PyObject *py_channel;
if (!self || !args)
return NULL;
if (!(di = srd_inst_find_by_obj(NULL, self))) {
PyErr_SetString(PyExc_Exception, "decoder instance not found");
return NULL;
}
/* Parse the argument of self.has_channel() into 'py_channel'. */
if (!PyArg_ParseTuple(args, "O", &py_channel)) {
/* Let Python raise this exception. */
return NULL;
}
if (!PyLong_Check(py_channel)) {
PyErr_SetString(PyExc_Exception, "channel index not a number");
return NULL;
}
idx = PyLong_AsLong(py_channel);
max_idx = g_slist_length(di->decoder->channels)
+ g_slist_length(di->decoder->opt_channels) - 1;
if (idx < 0 || idx > max_idx) {
srd_err("Invalid channel index %d/%d.", idx, max_idx);
PyErr_SetString(PyExc_Exception, "invalid channel");
return NULL;
}
return (di->dec_channelmap[idx] == -1) ? Py_False : Py_True;
}
static PyObject *Decoder_register(PyObject *self, PyObject *args,
PyObject *kwargs)
{
struct srd_decoder_inst *di;
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;
}
/* 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;
}
/* 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;
}
static PyObject *Decoder_put(PyObject *self, PyObject *args)
{
GSList *l;
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;
struct srd_pd_callback *cb;
if (!(di = srd_inst_find_by_obj(NULL, self))) {
/* Shouldn't happen. */
srd_dbg("put(): self instance not found.");
return NULL;
}
if (!PyArg_ParseTuple(args, "KKiO", &start_sample, &end_sample,
&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
* controller.c on the decode() method call.
*/
return NULL;
}
if (!(l = g_slist_nth(di->pd_output, output_id))) {
srd_err("Protocol decoder %s submitted invalid output ID %d.",
di->decoder->name, output_id);
return NULL;
}
pdo = l->data;
srd_spew("Instance %s put %" PRIu64 "-%" PRIu64 " %s on oid %d.",
di->inst_id, start_sample, end_sample,
OUTPUT_TYPES[pdo->output_type], output_id);
if (!(pdata = g_try_malloc0(sizeof(struct srd_proto_data)))) {
srd_err("Failed to g_malloc() 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_pd_output_callback_find(di->sess, pdo->output_type))) {
/* Convert from PyDict to srd_proto_data_annotation. */
if (convert_annotation(di, py_data, pdata) != SRD_OK) {
/* An error was already logged. */
break;
}
cb->cb(pdata, cb->cb_data);
}
break;
case SRD_OUTPUT_PYTHON:
for (l = di->next_di; l; l = l->next) {
next_di = l->data;
srd_spew("Sending %d-%d to instance %s",
start_sample, end_sample, next_di->inst_id);
if (!(py_res = PyObject_CallMethod(
next_di->py_inst, "decode", "KKO", start_sample,
end_sample, py_data))) {
srd_exception_catch("Calling %s decode(): ",
next_di->inst_id);
}
Py_XDECREF(py_res);
}
if ((cb = srd_pd_output_callback_find(di->sess, pdo->output_type))) {
/* Frontends aren't really supposed to get Python
* callbacks, but it's useful for testing. */
pdata->data = py_data;
cb->cb(pdata, cb->cb_data);
}
break;
case SRD_OUTPUT_BINARY:
if ((cb = srd_pd_output_callback_find(di->sess, pdo->output_type))) {
/* Convert from PyDict to srd_proto_data_binary. */
if (convert_binary(di, py_data, pdata) != SRD_OK) {
/* An error was already logged. */
break;
}
cb->cb(pdata, cb->cb_data);
}
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);
break;
}
g_free(pdata);
Py_RETURN_NONE;
}
static PyObject *Decoder_put(PyObject *self, PyObject *args)
{
GSList *l;
PyObject *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)();
if (!(di = srd_inst_find_by_obj(NULL, self))) {
/* Shouldn't happen. */
srd_dbg("put(): self instance not found.");
return NULL;
}
if (!PyArg_ParseTuple(args, "KKiO", &start_sample, &end_sample,
&output_id, &data)) {
/*
* This throws an exception, but by returning NULL here we let
* Python raise it. This results in a much better trace in
* controller.c on the decode() method call.
*/
return NULL;
}
if (!(l = g_slist_nth(di->pd_output, output_id))) {
srd_err("Protocol decoder %s submitted invalid output ID %d.",
di->decoder->name, output_id);
return NULL;
}
pdo = l->data;
srd_spew("Instance %s put %" PRIu64 "-%" PRIu64 " %s on oid %d.",
di->inst_id, start_sample, end_sample,
OUTPUT_TYPES[pdo->output_type], output_id);
if (!(pdata = g_try_malloc0(sizeof(struct srd_proto_data)))) {
srd_err("Failed to g_malloc() 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_pd_output_callback_find(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_inst);
srd_spew("Sending %d-%d to instance %s",
start_sample, end_sample,
next_di->inst_id);
if (!(py_res = PyObject_CallMethod(
next_di->py_inst, "decode", "KKO", start_sample,
end_sample, data))) {
srd_exception_catch("Calling %s decode(): ",
next_di->inst_id);
}
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_wait(PyObject *self, PyObject *args)
{
int ret;
unsigned int i;
gboolean found_match;
struct srd_decoder_inst *di;
PyObject *py_pinvalues, *py_matched;
if (!self || !args)
return NULL;
if (!(di = srd_inst_find_by_obj(NULL, self))) {
PyErr_SetString(PyExc_Exception, "decoder instance not found");
Py_RETURN_NONE;
}
ret = set_new_condition_list(self, args);
if (ret < 0) {
srd_dbg("%s: %s: Aborting wait().", di->inst_id, __func__);
return NULL;
}
if (ret == 9999) {
/* Empty condition list, automatic match. */
PyObject_SetAttrString(di->py_inst, "matched", Py_None);
/* Leave self.samplenum unchanged (== di->abs_cur_samplenum). */
return get_current_pinvalues(di);
}
while (1) {
/* Wait for new samples to process, or termination request. */
g_mutex_lock(&di->data_mutex);
while (!di->got_new_samples && !di->want_wait_terminate)
g_cond_wait(&di->got_new_samples_cond, &di->data_mutex);
/*
* Check whether any of the current condition(s) match.
* Arrange for termination requests to take a code path which
* won't find new samples to process, pretends to have processed
* previously stored samples, and returns to the main thread,
* while the termination request still gets signalled.
*/
found_match = FALSE;
ret = process_samples_until_condition_match(di, &found_match);
/* If there's a match, set self.samplenum etc. and return. */
if (found_match) {
/* Set self.samplenum to the (absolute) sample number that matched. */
PyObject_SetAttrString(di->py_inst, "samplenum",
PyLong_FromLong(di->abs_cur_samplenum));
if (di->match_array && di->match_array->len > 0) {
py_matched = PyTuple_New(di->match_array->len);
for (i = 0; i < di->match_array->len; i++)
PyTuple_SetItem(py_matched, i, PyBool_FromLong(di->match_array->data[i]));
PyObject_SetAttrString(di->py_inst, "matched", py_matched);
match_array_free(di);
} else {
PyObject_SetAttrString(di->py_inst, "matched", Py_None);
}
py_pinvalues = get_current_pinvalues(di);
g_mutex_unlock(&di->data_mutex);
return py_pinvalues;
}
/* No match, reset state for the next chunk. */
di->got_new_samples = FALSE;
di->handled_all_samples = TRUE;
di->abs_start_samplenum = 0;
di->abs_end_samplenum = 0;
di->inbuf = NULL;
di->inbuflen = 0;
/* Signal the main thread that we handled all samples. */
g_cond_signal(&di->handled_all_samples_cond);
/*
* When termination of wait() and decode() was requested,
* then exit the loop after releasing the mutex.
*/
if (di->want_wait_terminate) {
srd_dbg("%s: %s: Will return from wait().",
di->inst_id, __func__);
g_mutex_unlock(&di->data_mutex);
return NULL;
}
g_mutex_unlock(&di->data_mutex);
}
Py_RETURN_NONE;
}
/**
* Replace the current condition list with the new one.
*
* @param self TODO. Must not be NULL.
* @param args TODO. Must not be NULL.
*
* @retval SRD_OK The new condition list was set successfully.
* @retval SRD_ERR There was an error setting the new condition list.
* The contents of di->condition_list are undefined.
* @retval 9999 TODO.
*/
static int set_new_condition_list(PyObject *self, PyObject *args)
{
struct srd_decoder_inst *di;
GSList *term_list;
PyObject *py_conditionlist, *py_conds, *py_dict;
int i, num_conditions, ret;
if (!self || !args)
return SRD_ERR_ARG;
/* Get the decoder instance. */
if (!(di = srd_inst_find_by_obj(NULL, self))) {
PyErr_SetString(PyExc_Exception, "decoder instance not found");
return SRD_ERR;
}
/*
* Return an error condition from .wait() when termination is
* requested, such that decode() will terminate.
*/
if (di->want_wait_terminate) {
srd_dbg("%s: %s: Skip (want_term).", di->inst_id, __func__);
return SRD_ERR;
}
/* Parse the argument of self.wait() into 'py_conds'. */
if (!PyArg_ParseTuple(args, "O", &py_conds)) {
/* Let Python raise this exception. */
return SRD_ERR;
}
/* Check whether 'py_conds' is a dict or a list. */
if (PyList_Check(py_conds)) {
/* 'py_conds' is a list. */
py_conditionlist = py_conds;
num_conditions = PyList_Size(py_conditionlist);
if (num_conditions == 0)
return 9999; /* The PD invoked self.wait([]). */
Py_IncRef(py_conditionlist);
} else if (PyDict_Check(py_conds)) {
/* 'py_conds' is a dict. */
if (PyDict_Size(py_conds) == 0)
return 9999; /* The PD invoked self.wait({}). */
/* Make a list and put the dict in there for convenience. */
py_conditionlist = PyList_New(1);
Py_IncRef(py_conds);
PyList_SetItem(py_conditionlist, 0, py_conds);
num_conditions = 1;
} else {
srd_err("Condition list is neither a list nor a dict.");
return SRD_ERR;
}
/* Free the old condition list. */
condition_list_free(di);
ret = SRD_OK;
/* Iterate over the conditions, set di->condition_list accordingly. */
for (i = 0; i < num_conditions; i++) {
/* Get a condition (dict) from the condition list. */
py_dict = PyList_GetItem(py_conditionlist, i);
if (!PyDict_Check(py_dict)) {
srd_err("Condition is not a dict.");
ret = SRD_ERR;
break;
}
/* Create the list of terms in this condition. */
if ((ret = create_term_list(py_dict, &term_list)) < 0)
break;
/* Add the new condition to the PD instance's condition list. */
di->condition_list = g_slist_append(di->condition_list, term_list);
}
Py_DecRef(py_conditionlist);
return ret;
}
