+ "second element was malformed.", di->decoder->name);
+ goto err;
+ }
+
+ pda = pdata->data;
+ pda->ann_class = ann_class;
+ pda->ann_text = ann_text;
+
+ PyGILState_Release(gstate);
+
+ return SRD_OK;
+
+err:
+ PyGILState_Release(gstate);
+
+ return SRD_ERR_PYTHON;
+}
+
+static void release_binary(struct srd_proto_data_binary *pdb)
+{
+ if (!pdb)
+ return;
+ g_free((void *)pdb->data);
+}
+
+static int convert_binary(struct srd_decoder_inst *di, PyObject *obj,
+ struct srd_proto_data *pdata)
+{
+ struct srd_proto_data_binary *pdb;
+ PyObject *py_tmp;
+ Py_ssize_t size;
+ int bin_class;
+ char *class_name, *buf;
+ PyGILState_STATE gstate;
+
+ gstate = PyGILState_Ensure();
+
+ /* Should be a list of [binary class, bytes]. */
+ if (!PyList_Check(obj)) {
+ srd_err("Protocol decoder %s submitted non-list for SRD_OUTPUT_BINARY.",
+ di->decoder->name);
+ goto err;
+ }
+
+ /* Should have 2 elements. */
+ if (PyList_Size(obj) != 2) {
+ srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY list "
+ "with %zd elements instead of 2", di->decoder->name,
+ PyList_Size(obj));
+ goto err;
+ }
+
+ /* The first element should be an integer. */
+ py_tmp = PyList_GetItem(obj, 0);
+ if (!PyLong_Check(py_tmp)) {
+ srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY list, "
+ "but first element was not an integer.", di->decoder->name);
+ goto err;
+ }
+ bin_class = PyLong_AsLong(py_tmp);
+ if (!(class_name = g_slist_nth_data(di->decoder->binary, bin_class))) {
+ srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY with "
+ "unregistered binary class %d.", di->decoder->name, bin_class);
+ goto err;
+ }
+
+ /* Second element should be bytes. */
+ py_tmp = PyList_GetItem(obj, 1);
+ if (!PyBytes_Check(py_tmp)) {
+ srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY list, "
+ "but second element was not bytes.", di->decoder->name);
+ goto err;
+ }
+
+ /* Consider an empty set of bytes a bug. */
+ if (PyBytes_Size(py_tmp) == 0) {
+ srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY "
+ "with empty data set.", di->decoder->name);
+ goto err;
+ }
+
+ if (PyBytes_AsStringAndSize(py_tmp, &buf, &size) == -1)
+ goto err;
+
+ PyGILState_Release(gstate);
+
+ pdb = pdata->data;
+ pdb->bin_class = bin_class;
+ pdb->size = size;
+ if (!(pdb->data = g_try_malloc(pdb->size)))
+ return SRD_ERR_MALLOC;
+ memcpy((void *)pdb->data, (const void *)buf, pdb->size);
+
+ return SRD_OK;
+
+err:
+ PyGILState_Release(gstate);
+
+ return SRD_ERR_PYTHON;
+}
+
+static inline struct srd_decoder_inst *srd_sess_inst_find_by_obj(
+ struct srd_session *sess, const GSList *stack, const PyObject *obj)
+{
+ const GSList *l;
+ struct srd_decoder_inst *tmp, *di;
+
+ if (!sess)
+ return NULL;
+
+ di = NULL;
+ for (l = stack ? stack : sess->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_sess_inst_find_by_obj(sess, tmp->next_di, obj);
+ }
+
+ return di;
+}
+
+/**
+ * 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 of all
+ * sessions.
+ *
+ * @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.
+ *
+ * @since 0.1.0
+ */
+static inline struct srd_decoder_inst *srd_inst_find_by_obj(
+ const GSList *stack, const PyObject *obj)
+{
+ struct srd_decoder_inst *di;
+ struct srd_session *sess;
+ GSList *l;
+
+ /* Performance shortcut: Handle the most common case first. */
+ sess = sessions->data;
+ di = sess->di_list->data;
+ if (di->py_inst == obj)
+ return di;
+
+ di = NULL;
+ for (l = sessions; di == NULL && l != NULL; l = l->next) {
+ sess = l->data;
+ di = srd_sess_inst_find_by_obj(sess, stack, obj);
+ }
+
+ return di;
+}
+
+static int convert_meta(struct srd_proto_data *pdata, PyObject *obj)
+{
+ long long intvalue;
+ double dvalue;
+ PyGILState_STATE gstate;
+
+ gstate = PyGILState_Ensure();
+
+ if (g_variant_type_equal(pdata->pdo->meta_type, G_VARIANT_TYPE_INT64)) {
+ if (!PyLong_Check(obj)) {
+ PyErr_Format(PyExc_TypeError, "This output was registered "
+ "as 'int', but something else was passed.");
+ goto err;
+ }
+ intvalue = PyLong_AsLongLong(obj);
+ if (PyErr_Occurred())
+ goto err;
+ pdata->data = g_variant_new_int64(intvalue);
+ } else if (g_variant_type_equal(pdata->pdo->meta_type, G_VARIANT_TYPE_DOUBLE)) {
+ if (!PyFloat_Check(obj)) {
+ PyErr_Format(PyExc_TypeError, "This output was registered "
+ "as 'float', but something else was passed.");
+ goto err;
+ }
+ dvalue = PyFloat_AsDouble(obj);
+ if (PyErr_Occurred())
+ goto err;
+ pdata->data = g_variant_new_double(dvalue);