can: decode CAN-FD DLC
[libsigrokdecode.git] / instance.c
index 81ce3fd33fbc8b23d6665b098a1b3963c732a65a..23732ddb3ad1645825aa389c61d2dfa413055206 100644 (file)
 
 extern SRD_PRIV GSList *sessions;
 
 
 extern SRD_PRIV GSList *sessions;
 
-static void srd_inst_join_decode_thread(struct srd_decoder_inst *di);
-static void srd_inst_reset_state(struct srd_decoder_inst *di);
-SRD_PRIV void oldpins_array_free(struct srd_decoder_inst *di);
-
 /** @endcond */
 
 /**
 /** @endcond */
 
 /**
@@ -50,6 +46,36 @@ SRD_PRIV void oldpins_array_free(struct srd_decoder_inst *di);
  * @{
  */
 
  * @{
  */
 
+static void oldpins_array_seed(struct srd_decoder_inst *di)
+{
+       size_t count;
+       GArray *arr;
+
+       if (!di)
+               return;
+       if (di->old_pins_array)
+               return;
+
+       count = di->dec_num_channels;
+       arr = g_array_sized_new(FALSE, TRUE, sizeof(uint8_t), count);
+       g_array_set_size(arr, count);
+       memset(arr->data, SRD_INITIAL_PIN_SAME_AS_SAMPLE0, count);
+       di->old_pins_array = arr;
+}
+
+static void oldpins_array_free(struct srd_decoder_inst *di)
+{
+       if (!di)
+               return;
+       if (!di->old_pins_array)
+               return;
+
+       srd_dbg("%s: Releasing initial pin state.", di->inst_id);
+
+       g_array_free(di->old_pins_array, TRUE);
+       di->old_pins_array = NULL;
+}
+
 /**
  * Set one or more options in a decoder instance.
  *
 /**
  * Set one or more options in a decoder instance.
  *
@@ -176,7 +202,7 @@ err_out:
        return ret;
 }
 
        return ret;
 }
 
-/* Helper GComparefunc for g_slist_find_custom() in srd_inst_channel_set_all() */
+/* Helper GComparefunc for g_slist_find_custom() in srd_inst_channel_set_all(). */
 static gint compare_channel_id(const struct srd_channel *pdch,
                        const char *channel_id)
 {
 static gint compare_channel_id(const struct srd_channel *pdch,
                        const char *channel_id)
 {
@@ -222,7 +248,7 @@ SRD_API int srd_inst_channel_set_all(struct srd_decoder_inst *di,
                return SRD_ERR_ARG;
        }
 
                return SRD_ERR_ARG;
        }
 
-       new_channelmap = g_malloc(sizeof(int) * di->dec_num_channels);
+       new_channelmap = g_malloc0(sizeof(int) * di->dec_num_channels);
 
        /*
         * For now, map all indexes to channel -1 (can be overridden later).
 
        /*
         * For now, map all indexes to channel -1 (can be overridden later).
@@ -262,11 +288,11 @@ SRD_API int srd_inst_channel_set_all(struct srd_decoder_inst *di,
        srd_dbg("Final channel map:");
        num_required_channels = g_slist_length(di->decoder->channels);
        for (i = 0; i < di->dec_num_channels; i++) {
        srd_dbg("Final channel map:");
        num_required_channels = g_slist_length(di->decoder->channels);
        for (i = 0; i < di->dec_num_channels; i++) {
-               GSList *l = g_slist_nth(di->decoder->channels, i);
-               if (!l)
-                       l = g_slist_nth(di->decoder->opt_channels,
+               GSList *ll = g_slist_nth(di->decoder->channels, i);
+               if (!ll)
+                       ll = g_slist_nth(di->decoder->opt_channels,
                                i - num_required_channels);
                                i - num_required_channels);
-               pdch = l->data;
+               pdch = ll->data;
                srd_dbg(" - PD ch idx %d (%s) = input data ch idx %d (%s)", i,
                        pdch->id, new_channelmap[i],
                        (i < num_required_channels) ? "required" : "optional");
                srd_dbg(" - PD ch idx %d (%s) = input data ch idx %d (%s)", i,
                        pdch->id, new_channelmap[i],
                        (i < num_required_channels) ? "required" : "optional");
@@ -279,6 +305,7 @@ SRD_API int srd_inst_channel_set_all(struct srd_decoder_inst *di,
                pdch = g_slist_nth(di->decoder->channels, i)->data;
                srd_err("Required channel '%s' (index %d) was not specified.",
                        pdch->id, i);
                pdch = g_slist_nth(di->decoder->channels, i)->data;
                srd_err("Required channel '%s' (index %d) was not specified.",
                        pdch->id, i);
+               g_free(new_channelmap);
                return SRD_ERR;
        }
 
                return SRD_ERR;
        }
 
@@ -292,6 +319,7 @@ SRD_API int srd_inst_channel_set_all(struct srd_decoder_inst *di,
  * Create a new protocol decoder instance.
  *
  * @param sess The session holding the protocol decoder instance.
  * Create a new protocol decoder instance.
  *
  * @param sess The session holding the protocol decoder instance.
+ *             Must not be NULL.
  * @param decoder_id Decoder 'id' field.
  * @param options GHashtable of options which override the defaults set in
  *                the decoder class. May be NULL.
  * @param decoder_id Decoder 'id' field.
  * @param options GHashtable of options which override the defaults set in
  *                the decoder class. May be NULL.
@@ -311,12 +339,9 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
        PyGILState_STATE gstate;
 
        i = 1;
        PyGILState_STATE gstate;
 
        i = 1;
-       srd_dbg("Creating new %s instance.", decoder_id);
 
 
-       if (session_is_valid(sess) != SRD_OK) {
-               srd_err("Invalid session.");
+       if (!sess)
                return NULL;
                return NULL;
-       }
 
        if (!(dec = srd_decoder_get_by_id(decoder_id))) {
                srd_err("Protocol decoder %s not found.", decoder_id);
 
        if (!(dec = srd_decoder_get_by_id(decoder_id))) {
                srd_err("Protocol decoder %s not found.", decoder_id);
@@ -363,11 +388,7 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
        }
 
        /* Default to the initial pins being the same as in sample 0. */
        }
 
        /* Default to the initial pins being the same as in sample 0. */
-       di->old_pins_array = g_array_sized_new(FALSE, TRUE, sizeof(uint8_t),
-                                               di->dec_num_channels);
-       g_array_set_size(di->old_pins_array, di->dec_num_channels);
-       memset(di->old_pins_array->data, SRD_INITIAL_PIN_SAME_AS_SAMPLE0,
-               di->dec_num_channels);
+       oldpins_array_seed(di);
 
        gstate = PyGILState_Ensure();
 
 
        gstate = PyGILState_Ensure();
 
@@ -401,6 +422,7 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
        di->got_new_samples = FALSE;
        di->handled_all_samples = FALSE;
        di->want_wait_terminate = FALSE;
        di->got_new_samples = FALSE;
        di->handled_all_samples = FALSE;
        di->want_wait_terminate = FALSE;
+       di->decoder_state = SRD_OK;
 
        /*
         * Strictly speaking initialization of statically allocated
 
        /*
         * Strictly speaking initialization of statically allocated
@@ -414,7 +436,7 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
 
        /* Instance takes input from a frontend by default. */
        sess->di_list = g_slist_append(sess->di_list, di);
 
        /* Instance takes input from a frontend by default. */
        sess->di_list = g_slist_append(sess->di_list, di);
-       srd_dbg("Created new %s instance with ID %s.", decoder_id, di->inst_id);
+       srd_dbg("Creating new %s instance %s.", decoder_id, di->inst_id);
 
        return di;
 }
 
        return di;
 }
@@ -462,9 +484,7 @@ static void srd_inst_reset_state(struct srd_decoder_inst *di)
 
        srd_dbg("%s: Resetting decoder state.", di->inst_id);
 
 
        srd_dbg("%s: Resetting decoder state.", di->inst_id);
 
-       /*
-        * Reset internal state of the decoder.
-        */
+       /* Reset internal state of the decoder. */
        condition_list_free(di);
        match_array_free(di);
        di->abs_start_samplenum = 0;
        condition_list_free(di);
        match_array_free(di);
        di->abs_start_samplenum = 0;
@@ -476,6 +496,7 @@ static void srd_inst_reset_state(struct srd_decoder_inst *di)
        di->got_new_samples = FALSE;
        di->handled_all_samples = FALSE;
        di->want_wait_terminate = FALSE;
        di->got_new_samples = FALSE;
        di->handled_all_samples = FALSE;
        di->want_wait_terminate = FALSE;
+       di->decoder_state = SRD_OK;
        /* Conditions and mutex got reset after joining the thread. */
 }
 
        /* Conditions and mutex got reset after joining the thread. */
 }
 
@@ -483,6 +504,7 @@ static void srd_inst_reset_state(struct srd_decoder_inst *di)
  * Stack a decoder instance on top of another.
  *
  * @param sess The session holding the protocol decoder instances.
  * Stack a decoder instance on top of another.
  *
  * @param sess The session holding the protocol decoder instances.
+ *             Must not be NULL.
  * @param di_bottom The instance on top of which di_top will be stacked.
  * @param di_top The instance to go on top.
  *
  * @param di_bottom The instance on top of which di_top will be stacked.
  * @param di_top The instance to go on top.
  *
@@ -494,10 +516,8 @@ SRD_API int srd_inst_stack(struct srd_session *sess,
                struct srd_decoder_inst *di_bottom,
                struct srd_decoder_inst *di_top)
 {
                struct srd_decoder_inst *di_bottom,
                struct srd_decoder_inst *di_top)
 {
-       if (session_is_valid(sess) != SRD_OK) {
-               srd_err("Invalid session.");
+       if (!sess)
                return SRD_ERR_ARG;
                return SRD_ERR_ARG;
-       }
 
        if (!di_bottom || !di_top) {
                srd_err("Invalid from/to instance pair.");
 
        if (!di_bottom || !di_top) {
                srd_err("Invalid from/to instance pair.");
@@ -509,10 +529,31 @@ SRD_API int srd_inst_stack(struct srd_session *sess,
                sess->di_list = g_slist_remove(sess->di_list, di_top);
        }
 
                sess->di_list = g_slist_remove(sess->di_list, di_top);
        }
 
+       /*
+        * Check if there's at least one matching input/output pair
+        * for the stacked PDs. We warn if that's not the case, but it's
+        * not a hard error for the time being.
+        */
+       gboolean at_least_one_match = FALSE;
+       for (GSList *out = di_bottom->decoder->outputs; out; out = out->next) {
+               const char *o = out->data;
+               for (GSList *in = di_top->decoder->inputs; in; in = in->next) {
+                       const char *i = in->data;
+                       if (!strcmp(o, i)) {
+                               at_least_one_match = TRUE;
+                               break;
+                       }
+               }
+       }
+
+       if (!at_least_one_match)
+               srd_warn("No matching in-/output when stacking %s onto %s.",
+                       di_top->inst_id, di_bottom->inst_id);
+
        /* Stack on top of source di. */
        di_bottom->next_di = g_slist_append(di_bottom->next_di, di_top);
 
        /* Stack on top of source di. */
        di_bottom->next_di = g_slist_append(di_bottom->next_di, di_top);
 
-       srd_dbg("Stacked %s onto %s.", di_top->inst_id, di_bottom->inst_id);
+       srd_dbg("Stacking %s onto %s.", di_top->inst_id, di_bottom->inst_id);
 
        return SRD_OK;
 }
 
        return SRD_OK;
 }
@@ -556,6 +597,7 @@ static struct srd_decoder_inst *srd_inst_find_by_id_stack(const char *inst_id,
  * given session.
  *
  * @param sess The session holding the protocol decoder instance.
  * given session.
  *
  * @param sess The session holding the protocol decoder instance.
+ *             Must not be NULL.
  * @param inst_id The instance ID to be found.
  *
  * @return Pointer to struct srd_decoder_inst, or NULL if not found.
  * @param inst_id The instance ID to be found.
  *
  * @return Pointer to struct srd_decoder_inst, or NULL if not found.
@@ -568,10 +610,8 @@ SRD_API struct srd_decoder_inst *srd_inst_find_by_id(struct srd_session *sess,
        GSList *l;
        struct srd_decoder_inst *tmp, *di;
 
        GSList *l;
        struct srd_decoder_inst *tmp, *di;
 
-       if (session_is_valid(sess) != SRD_OK) {
-               srd_err("Invalid session.");
+       if (!sess)
                return NULL;
                return NULL;
-       }
 
        di = NULL;
        for (l = sess->di_list; l; l = l->next) {
 
        di = NULL;
        for (l = sess->di_list; l; l = l->next) {
@@ -583,64 +623,6 @@ SRD_API struct srd_decoder_inst *srd_inst_find_by_id(struct srd_session *sess,
        return di;
 }
 
        return di;
 }
 
-static 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 (session_is_valid(sess) != SRD_OK) {
-               srd_err("Invalid session.");
-               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.
- *
- * @private
- *
- * @since 0.1.0
- */
-SRD_PRIV 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;
-
-       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;
-}
-
 /**
  * Set the list of initial (assumed) pin values.
  *
 /**
  * Set the list of initial (assumed) pin values.
  *
@@ -678,6 +660,7 @@ SRD_API int srd_inst_initial_pins_set_all(struct srd_decoder_inst *di, GArray *i
        }
 
        s = g_string_sized_new(100);
        }
 
        s = g_string_sized_new(100);
+       oldpins_array_seed(di);
        for (i = 0; i < di->dec_num_channels; i++) {
                di->old_pins_array->data[i] = initial_pins->data[i];
                g_string_append_printf(s, "%d, ", di->old_pins_array->data[i]);
        for (i = 0; i < di->dec_num_channels; i++) {
                di->old_pins_array->data[i] = initial_pins->data[i];
                g_string_append_printf(s, "%d, ", di->old_pins_array->data[i]);
@@ -689,20 +672,6 @@ SRD_API int srd_inst_initial_pins_set_all(struct srd_decoder_inst *di, GArray *i
        return SRD_OK;
 }
 
        return SRD_OK;
 }
 
-/** @private */
-SRD_PRIV void oldpins_array_free(struct srd_decoder_inst *di)
-{
-       if (!di)
-               return;
-       if (!di->old_pins_array)
-               return;
-
-       srd_dbg("%s: Releasing initial pin state.", di->inst_id);
-
-       g_array_free(di->old_pins_array, TRUE);
-       di->old_pins_array = NULL;
-}
-
 /** @private */
 SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di)
 {
 /** @private */
 SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di)
 {
@@ -712,8 +681,7 @@ SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di)
        int ret;
        PyGILState_STATE gstate;
 
        int ret;
        PyGILState_STATE gstate;
 
-       srd_dbg("Calling start() method on protocol decoder instance %s.",
-                       di->inst_id);
+       srd_dbg("Calling start() of instance %s.", di->inst_id);
 
        gstate = PyGILState_Ensure();
 
 
        gstate = PyGILState_Ensure();
 
@@ -760,7 +728,8 @@ SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di)
  *
  * @private
  */
  *
  * @private
  */
-static gboolean sample_matches(uint8_t old_sample, uint8_t sample, struct srd_term *term)
+__attribute__((always_inline))
+static inline gboolean sample_matches(uint8_t old_sample, uint8_t sample, struct srd_term *term)
 {
        /* Caller ensures term != NULL. */
 
 {
        /* Caller ensures term != NULL. */
 
@@ -854,6 +823,7 @@ static void update_old_pins_array(struct srd_decoder_inst *di,
        if (!di || !di->dec_channelmap || !sample_pos)
                return;
 
        if (!di || !di->dec_channelmap || !sample_pos)
                return;
 
+       oldpins_array_seed(di);
        for (i = 0; i < di->dec_num_channels; i++) {
                byte_offset = di->dec_channelmap[i] / 8;
                bit_offset = di->dec_channelmap[i] % 8;
        for (i = 0; i < di->dec_num_channels; i++) {
                byte_offset = di->dec_channelmap[i] / 8;
                bit_offset = di->dec_channelmap[i] % 8;
@@ -873,6 +843,7 @@ static void update_old_pins_array_initial_pins(struct srd_decoder_inst *di)
 
        sample_pos = di->inbuf + ((di->abs_cur_samplenum - di->abs_start_samplenum) * di->data_unitsize);
 
 
        sample_pos = di->inbuf + ((di->abs_cur_samplenum - di->abs_start_samplenum) * di->data_unitsize);
 
+       oldpins_array_seed(di);
        for (i = 0; i < di->dec_num_channels; i++) {
                if (di->old_pins_array->data[i] != SRD_INITIAL_PIN_SAME_AS_SAMPLE0)
                        continue;
        for (i = 0; i < di->dec_num_channels; i++) {
                if (di->old_pins_array->data[i] != SRD_INITIAL_PIN_SAME_AS_SAMPLE0)
                        continue;
@@ -1070,9 +1041,12 @@ static gpointer di_thread(gpointer data)
         * "Regular" termination of the decode() method is not expected.
         */
        Py_IncRef(di->py_inst);
         * "Regular" termination of the decode() method is not expected.
         */
        Py_IncRef(di->py_inst);
-       srd_dbg("%s: Calling decode() method.", di->inst_id);
+       srd_dbg("%s: Calling decode().", di->inst_id);
        py_res = PyObject_CallMethod(di->py_inst, "decode", NULL);
        py_res = PyObject_CallMethod(di->py_inst, "decode", NULL);
-       srd_dbg("%s: decode() method terminated.", di->inst_id);
+       srd_dbg("%s: decode() terminated.", di->inst_id);
+
+       if (!py_res)
+               di->decoder_state = SRD_ERR;
 
        /*
         * Make sure to unblock potentially pending srd_inst_decode()
 
        /*
         * Make sure to unblock potentially pending srd_inst_decode()
@@ -1236,7 +1210,6 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di,
        di->inbuflen = inbuflen;
        di->got_new_samples = TRUE;
        di->handled_all_samples = FALSE;
        di->inbuflen = inbuflen;
        di->got_new_samples = TRUE;
        di->handled_all_samples = FALSE;
-       di->want_wait_terminate = FALSE;
 
        /* Signal the thread that we have new data. */
        g_cond_signal(&di->got_new_samples_cond);
 
        /* Signal the thread that we have new data. */
        g_cond_signal(&di->got_new_samples_cond);
@@ -1248,9 +1221,76 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di,
                g_cond_wait(&di->handled_all_samples_cond, &di->data_mutex);
        g_mutex_unlock(&di->data_mutex);
 
                g_cond_wait(&di->handled_all_samples_cond, &di->data_mutex);
        g_mutex_unlock(&di->data_mutex);
 
+       if (di->want_wait_terminate)
+               return SRD_ERR_TERM_REQ;
+
        return SRD_OK;
 }
 
        return SRD_OK;
 }
 
+/**
+ * Terminate current decoder work, prepare for re-use on new input data.
+ *
+ * Terminates all decoder operations in the specified decoder instance
+ * and the instances stacked on top of it. Resets internal state such
+ * that the previously constructed stack can process new input data that
+ * is not related to previously processed input data. This avoids the
+ * expensive and complex re-construction of decoder stacks.
+ *
+ * Callers are expected to follow up with start, metadata, and decode
+ * calls like they would for newly constructed decoder stacks.
+ *
+ * @param di The decoder instance to call. Must not be NULL.
+ *
+ * @return SRD_OK upon success, a (negative) error code otherwise.
+ *
+ * @private
+ */
+SRD_PRIV int srd_inst_terminate_reset(struct srd_decoder_inst *di)
+{
+       PyGILState_STATE gstate;
+       PyObject *py_ret;
+       GSList *l;
+       int ret;
+
+       if (!di)
+               return SRD_ERR_ARG;
+
+       /*
+        * Request termination and wait for previously initiated
+        * background operation to finish. Reset internal state, but
+        * do not start releasing resources yet. This shall result in
+        * decoders' state just like after creation. This block handles
+        * the C language library side.
+        */
+       srd_dbg("Terminating instance %s", di->inst_id);
+       srd_inst_join_decode_thread(di);
+       srd_inst_reset_state(di);
+
+       /*
+        * Have the Python side's .reset() method executed (if the PD
+        * implements it). It's assumed that .reset() assigns variables
+        * very much like __init__() used to do in the past. Thus memory
+        * that was allocated in previous calls gets released by Python
+        * as it's not referenced any longer.
+        */
+       gstate = PyGILState_Ensure();
+       if (PyObject_HasAttrString(di->py_inst, "reset")) {
+               srd_dbg("Calling reset() of instance %s", di->inst_id);
+               py_ret = PyObject_CallMethod(di->py_inst, "reset", NULL);
+               Py_XDECREF(py_ret);
+       }
+       PyGILState_Release(gstate);
+
+       /* Pass the "restart" request to all stacked decoders. */
+       for (l = di->next_di; l; l = l->next) {
+               ret = srd_inst_terminate_reset(l->data);
+               if (ret != SRD_OK)
+                       return ret;
+       }
+
+       return di->decoder_state;
+}
+
 /** @private */
 SRD_PRIV void srd_inst_free(struct srd_decoder_inst *di)
 {
 /** @private */
 SRD_PRIV void srd_inst_free(struct srd_decoder_inst *di)
 {
@@ -1258,7 +1298,7 @@ SRD_PRIV void srd_inst_free(struct srd_decoder_inst *di)
        struct srd_pd_output *pdo;
        PyGILState_STATE gstate;
 
        struct srd_pd_output *pdo;
        PyGILState_STATE gstate;
 
-       srd_dbg("Freeing instance %s", di->inst_id);
+       srd_dbg("Freeing instance %s.", di->inst_id);
 
        srd_inst_join_decode_thread(di);
 
 
        srd_inst_join_decode_thread(di);
 
@@ -1284,10 +1324,8 @@ SRD_PRIV void srd_inst_free(struct srd_decoder_inst *di)
 /** @private */
 SRD_PRIV void srd_inst_free_all(struct srd_session *sess)
 {
 /** @private */
 SRD_PRIV void srd_inst_free_all(struct srd_session *sess)
 {
-       if (session_is_valid(sess) != SRD_OK) {
-               srd_err("Invalid session.");
+       if (!sess)
                return;
                return;
-       }
 
        g_slist_free_full(sess->di_list, (GDestroyNotify)srd_inst_free);
 }
 
        g_slist_free_full(sess->di_list, (GDestroyNotify)srd_inst_free);
 }