Fix utf8 encoding error by changing the Python parameter to a bytes() object (python3...

[libsigrokdecode.git] / controller.c

diff --git a/controller.c b/controller.c
index efeef2808e70c56fe074f9309a8f389acf160d20..db85c2338a7832e1730da35c5471a56166bf498a 100644 (file)
--- a/controller.c
+++ b/controller.c
@@ -21,14 +21,7 @@
 #include "config.h"
 #include <sigrokdecode.h> /* First, so we avoid a _POSIX_C_SOURCE warning. */
 #include <glib.h>
-
-/* TODO: this should probably be in sigrokdecode.h */
-/* Re-define some string functions for Python >= 3.0. */
-#if PY_VERSION_HEX >= 0x03000000
-#define PyString_AsString PyBytes_AsString
-#define PyString_FromString PyBytes_FromString
-#define PyString_Check PyBytes_Check
-#endif
+#include <inttypes.h>
 
 
 /* TODO
@@ -63,23 +56,25 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args)
        PyObject *data;
        struct srd_decoder_instance *di;
        struct srd_pd_output *pdo;
+       uint64_t timeoffset, duration;
        int output_id;
 
        if (!(di = get_di_by_decobject(self)))
                return NULL;
 
-       printf("put: %s instance %x: ", di->decoder->name, (unsigned int) di);
-
-       if (!PyArg_ParseTuple(args, "iO", &output_id, &data))
+       if (!PyArg_ParseTuple(args, "KKiO", &timeoffset, &duration, &output_id, &data))
                return NULL;
 
+       printf("put: %s instance %p time %" PRIu64 " duration %" PRIu64 " ",
+                       di->decoder->name, di, timeoffset, duration);
+
        if (!(l = g_slist_nth(di->pd_output, output_id)))
                /* PD supplied invalid output id */
                /* TODO: better error message */
                return NULL;
        pdo = l->data;
 
-       printf("output type %d: ", pdo->output_type);
+       printf("stream %d: ", pdo->output_type);
        PyObject_Print(data, stdout, Py_PRINT_RAW);
        puts("");
 
@@ -131,7 +126,7 @@ typedef struct {
 } sigrok_Decoder_object;
 
 static PyTypeObject sigrok_Decoder_type = {
-       PyObject_HEAD_INIT(NULL)
+       PyVarObject_HEAD_INIT(NULL, 0)
        .tp_name = "sigrok.Decoder",
        .tp_basicsize = sizeof(sigrok_Decoder_object),
        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
@@ -139,19 +134,30 @@ static PyTypeObject sigrok_Decoder_type = {
        .tp_methods = Decoder_methods,
 };
 
-PyMODINIT_FUNC init_sigrok_Decoder(void)
+static struct PyModuleDef sigrok_Decoder_module = {
+       PyModuleDef_HEAD_INIT,
+       .m_name = "sigrok",
+       .m_doc = "sigrok base classes",
+       .m_size = -1,
+       .m_methods = no_methods,
+};
+
+PyMODINIT_FUNC PyInit_sigrok(void)
 {
        PyObject *mod;
 
        /* assign this here, for compiler portability */
        sigrok_Decoder_type.tp_new = PyType_GenericNew;
        if (PyType_Ready(&sigrok_Decoder_type) < 0)
-               return;
+               return NULL;
 
-       mod = Py_InitModule3("sigrok", no_methods, "sigrok base classes");
+//     mod = Py_InitModule3("sigrok", no_methods, "sigrok base classes");
+       mod = PyModule_Create(&sigrok_Decoder_module);
        Py_INCREF(&sigrok_Decoder_type);
-       PyModule_AddObject(mod, "Decoder", (PyObject *)&sigrok_Decoder_type);
+       if (PyModule_AddObject(mod, "Decoder", (PyObject *)&sigrok_Decoder_type) == -1)
+               return NULL;
 
+       return mod;
 }
 
 
@@ -195,10 +201,12 @@ int srd_init(void)
 {
        int ret;
 
+       PyImport_AppendInittab("sigrok", PyInit_sigrok);
+
        /* Py_Initialize() returns void and usually cannot fail. */
        Py_Initialize();
 
-       init_sigrok_Decoder();
+       PyInit_sigrok();
 
        PyRun_SimpleString("import sys;");
        if ((ret = set_modulepath()) != SRD_OK) {
@@ -309,7 +317,7 @@ int srd_instance_set_probe(struct srd_decoder_instance *di,
                return SRD_ERR_PYTHON; /* TODO: More specific error? */
        }
 
-       probenum = PyInt_FromLong(num);
+       probenum = PyLong_FromLong(num);
        PyMapping_SetItemString(probedict, (char *)probename, probenum);
 
        Py_XDECREF(probenum);
@@ -357,16 +365,13 @@ int srd_session_start(const char *driver, int unitsize, uint64_t starttime,
  *
  * @return SRD_OK upon success, a (negative) error code otherwise.
  */
-int srd_run_decoder(struct srd_decoder_instance *dec,
-                   uint8_t *inbuf, uint64_t inbuflen)
+int srd_run_decoder(uint64_t timeoffset, uint64_t duration,
+               struct srd_decoder_instance *dec, uint8_t *inbuf, uint64_t inbuflen)
 {
        PyObject *py_instance, *py_res;
-       /* FIXME: Don't have a timebase available here. Make one up. */
-       static int _timehack = 0;
-
-       _timehack += inbuflen;
 
 //     fprintf(stdout, "%s: %s\n", __func__, dec->decoder->name);
+//     printf("to %u du %u len %d\n", timeoffset, duration, inbuflen);
 
        /* Return an error upon unusable input. */
        if (dec == NULL)
@@ -381,10 +386,7 @@ int srd_run_decoder(struct srd_decoder_instance *dec,
        Py_XINCREF(py_instance);
 
        if (!(py_res = PyObject_CallMethod(py_instance, "decode",
-                                          "{s:i,s:i,s:s#}",
-                                          "time", _timehack,
-                                          "duration", 10,
-                                          "data", inbuf, inbuflen))) { /* NEWREF */
+                       "KKy#", timeoffset, duration, inbuf, inbuflen))) {
                if (PyErr_Occurred())
                        PyErr_Print(); /* Returns void. */
 
@@ -397,7 +399,8 @@ int srd_run_decoder(struct srd_decoder_instance *dec,
 
 
 /* Feed logic samples to decoder session. */
-int srd_session_feed(uint8_t *inbuf, uint64_t inbuflen)
+int srd_session_feed(uint64_t timeoffset, uint64_t duration, uint8_t *inbuf,
+               uint64_t inbuflen)
 {
        GSList *d;
        int ret;
@@ -405,7 +408,8 @@ int srd_session_feed(uint8_t *inbuf, uint64_t inbuflen)
 //     fprintf(stdout, "%s: %d bytes\n", __func__, inbuflen);
 
        for (d = di_list; d; d = d->next) {
-               if ((ret = srd_run_decoder(d->data, inbuf, inbuflen)) != SRD_OK)
+               if ((ret = srd_run_decoder(timeoffset, duration, d->data, inbuf,
+                               inbuflen)) != SRD_OK)
                        return ret;
        }