X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=instance.c;h=3327926d70e10db917174dda878ee0019789c19a;hp=79b72e18eb630ecb775892275cf554b78710d066;hb=eb88372396c2264948bc05586fb54dc318266973;hpb=3262ef0203e23399f3cab796391da06969c8306b

diff --git a/instance.c b/instance.c
index 79b72e1..3327926 100644
--- a/instance.c
+++ b/instance.c
@@ -30,8 +30,9 @@
 
 extern SRD_PRIV GSList *sessions;
 
-/* module_sigrokdecode.c */
-extern SRD_PRIV PyObject *srd_logic_type;
+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 */
 
@@ -349,6 +350,13 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
 		di->channel_samples = g_malloc(di->dec_num_channels);
 	}
 
+	/* 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);
+
 	/* Create a new instance of this decoder class. */
 	if (!(di->py_inst = PyObject_CallObject(dec->py_dec, NULL))) {
 		if (PyErr_Occurred())
@@ -367,15 +375,25 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
 
 	di->condition_list = NULL;
 	di->match_array = NULL;
-	di->start_samplenum = 0;
-	di->end_samplenum = 0;
+	di->abs_start_samplenum = 0;
+	di->abs_end_samplenum = 0;
 	di->inbuf = NULL;
 	di->inbuflen = 0;
-	di->cur_samplenum = 0;
-	di->old_pins_array = NULL;
+	di->abs_cur_samplenum = 0;
 	di->thread_handle = NULL;
 	di->got_new_samples = FALSE;
 	di->handled_all_samples = FALSE;
+	di->want_wait_terminate = FALSE;
+
+	/*
+	 * Strictly speaking initialization of statically allocated
+	 * condition and mutex variables (or variables allocated on the
+	 * stack) is not required, but won't harm either. Explicitly
+	 * running init() will better match subsequent clear() calls.
+	 */
+	g_cond_init(&di->got_new_samples_cond);
+	g_cond_init(&di->handled_all_samples_cond);
+	g_mutex_init(&di->data_mutex);
 
 	/* Instance takes input from a frontend by default. */
 	sess->di_list = g_slist_append(sess->di_list, di);
@@ -384,6 +402,66 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
 	return di;
 }
 
+static void srd_inst_join_decode_thread(struct srd_decoder_inst *di)
+{
+	if (!di)
+		return;
+	if (!di->thread_handle)
+		return;
+
+	srd_dbg("%s: Joining decoder thread.", di->inst_id);
+
+	/*
+	 * Terminate potentially running threads which still
+	 * execute the decoder instance's decode() method.
+	 */
+	srd_dbg("%s: Raising want_term, sending got_new.", di->inst_id);
+	g_mutex_lock(&di->data_mutex);
+	di->want_wait_terminate = TRUE;
+	g_cond_signal(&di->got_new_samples_cond);
+	g_mutex_unlock(&di->data_mutex);
+
+	srd_dbg("%s: Running join().", di->inst_id);
+	(void)g_thread_join(di->thread_handle);
+	srd_dbg("%s: Call to join() done.", di->inst_id);
+	di->thread_handle = NULL;
+
+	/*
+	 * Reset condition and mutex variables, such that next
+	 * operations on them will find them in a clean state.
+	 */
+	g_cond_clear(&di->got_new_samples_cond);
+	g_cond_init(&di->got_new_samples_cond);
+	g_cond_clear(&di->handled_all_samples_cond);
+	g_cond_init(&di->handled_all_samples_cond);
+	g_mutex_clear(&di->data_mutex);
+	g_mutex_init(&di->data_mutex);
+}
+
+static void srd_inst_reset_state(struct srd_decoder_inst *di)
+{
+	if (!di)
+		return;
+
+	srd_dbg("%s: Resetting decoder state.", di->inst_id);
+
+	/*
+	 * Reset internal state of the decoder.
+	 */
+	condition_list_free(di);
+	match_array_free(di);
+	di->abs_start_samplenum = 0;
+	di->abs_end_samplenum = 0;
+	di->inbuf = NULL;
+	di->inbuflen = 0;
+	di->abs_cur_samplenum = 0;
+	oldpins_array_free(di);
+	di->got_new_samples = FALSE;
+	di->handled_all_samples = FALSE;
+	di->want_wait_terminate = FALSE;
+	/* Conditions and mutex got reset after joining the thread. */
+}
+
 /**
  * Stack a decoder instance on top of another.
  *
@@ -423,11 +501,43 @@ SRD_API int srd_inst_stack(struct srd_session *sess,
 	return SRD_OK;
 }
 
+/**
+ * Search a decoder instance and its stack for instance ID.
+ *
+ * @param[in] inst_id ID to search for.
+ * @param[in] stack A decoder instance, potentially with stacked instances.
+ *
+ * @return The matching instance, or NULL.
+ */
+static struct srd_decoder_inst *srd_inst_find_by_id_stack(const char *inst_id,
+		struct srd_decoder_inst *stack)
+{
+	const GSList *l;
+	struct srd_decoder_inst *tmp, *di;
+
+	if (!strcmp(stack->inst_id, inst_id))
+		return stack;
+
+	/* Otherwise, look recursively in our stack. */
+	di = NULL;
+	if (stack->next_di) {
+		for (l = stack->next_di; l; l = l->next) {
+			tmp = l->data;
+			if (!strcmp(tmp->inst_id, inst_id)) {
+				di = tmp;
+				break;
+			}
+		}
+	}
+
+	return di;
+}
+
 /**
  * Find a decoder instance by its instance ID.
  *
- * Only the bottom level of instances are searched -- instances already stacked
- * on top of another one will not be found.
+ * This will recurse to find the instance anywhere in the stack tree of the
+ * given session.
  *
  * @param sess The session holding the protocol decoder instance.
  * @param inst_id The instance ID to be found.
@@ -450,10 +560,8 @@ SRD_API struct srd_decoder_inst *srd_inst_find_by_id(struct srd_session *sess,
 	di = NULL;
 	for (l = sess->di_list; l; l = l->next) {
 		tmp = l->data;
-		if (!strcmp(tmp->inst_id, inst_id)) {
-			di = tmp;
+		if ((di = srd_inst_find_by_id_stack(inst_id, tmp)) != NULL)
 			break;
-		}
 	}
 
 	return di;
@@ -520,51 +628,63 @@ SRD_PRIV struct srd_decoder_inst *srd_inst_find_by_obj(const GSList *stack,
 /**
  * Set the list of initial (assumed) pin values.
  *
- * If the list already exists, do nothing.
- *
  * @param di Decoder instance to use. Must not be NULL.
+ * @param initial_pins A GArray of uint8_t values. Must not be NULL.
  *
- * @private
+ * @since 0.5.0
  */
-static void set_initial_pin_values(struct srd_decoder_inst *di)
+SRD_API int srd_inst_initial_pins_set_all(struct srd_decoder_inst *di, GArray *initial_pins)
 {
 	int i;
 	GString *s;
-	PyObject *py_initial_pins;
 
-	if (!di || !di->py_inst) {
+	if (!di) {
 		srd_err("Invalid decoder instance.");
-		return;
-	}
-
-	/* Nothing to do if di->old_pins_array is already != NULL. */
-	if (di->old_pins_array) {
-		srd_dbg("Initial pins already set, nothing to do.");
-		return;
+		return SRD_ERR_ARG;
 	}
 
-	/* Create an array of old (previous sample) pins, init to 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);
+	if (!initial_pins)
+		return SRD_ERR_ARG;
 
-	/* Check if the decoder has set self.initial_pins. */
-	if (!PyObject_HasAttrString(di->py_inst, "initial_pins")) {
-		srd_dbg("Initial pins: all 0 (self.initial_pins not set).");
-		return;
+	if (initial_pins->len != (guint)di->dec_num_channels) {
+		srd_err("Incorrect number of channels (need %d, got %d).",
+			di->dec_num_channels, initial_pins->len);
+		return SRD_ERR_ARG;
 	}
 
-	/* Get self.initial_pins. */
-	py_initial_pins = PyObject_GetAttrString(di->py_inst, "initial_pins");
+	/* Sanity-check initial pin state values. */
+	for (i = 0; i < di->dec_num_channels; i++) {
+		if (initial_pins->data[i] <= 2)
+			continue;
+		srd_err("Invalid initial channel %d pin state: %d.",
+			i, initial_pins->data[i]);
+		return SRD_ERR_ARG;
+	}
 
-	/* Fill di->old_pins_array based on self.initial_pins. */
 	s = g_string_sized_new(100);
 	for (i = 0; i < di->dec_num_channels; i++) {
-		di->old_pins_array->data[i] = PyLong_AsLong(PyList_GetItem(py_initial_pins, i));
+		di->old_pins_array->data[i] = initial_pins->data[i];
 		g_string_append_printf(s, "%d, ", di->old_pins_array->data[i]);
 	}
 	s = g_string_truncate(s, s->len - 2);
 	srd_dbg("Initial pins: %s.", s->str);
 	g_string_free(s, TRUE);
+
+	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 */
@@ -586,14 +706,11 @@ SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di)
 	}
 	Py_DecRef(py_res);
 
-	/* Set the initial pins based on self.initial_pins. */
-	set_initial_pin_values(di);
-
 	/* Set self.samplenum to 0. */
 	PyObject_SetAttrString(di->py_inst, "samplenum", PyLong_FromLong(0));
 
-	/* Set self.matches to None. */
-	PyObject_SetAttrString(di->py_inst, "matches", Py_None);
+	/* Set self.matched to None. */
+	PyObject_SetAttrString(di->py_inst, "matched", Py_None);
 
 	/* Start all the PDs stacked on top of this one. */
 	for (l = di->next_di; l; l = l->next) {
@@ -623,8 +740,7 @@ SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di)
  */
 static gboolean sample_matches(uint8_t old_sample, uint8_t sample, struct srd_term *term)
 {
-	if (!term)
-		return FALSE;
+	/* Caller ensures term != NULL. */
 
 	switch (term->type) {
 	case SRD_TERM_HIGH:
@@ -664,6 +780,7 @@ static gboolean sample_matches(uint8_t old_sample, uint8_t sample, struct srd_te
 	return FALSE;
 }
 
+/** @private */
 SRD_PRIV void match_array_free(struct srd_decoder_inst *di)
 {
 	if (!di || !di->match_array)
@@ -673,6 +790,7 @@ SRD_PRIV void match_array_free(struct srd_decoder_inst *di)
 	di->match_array = NULL;
 }
 
+/** @private */
 SRD_PRIV void condition_list_free(struct srd_decoder_inst *di)
 {
 	GSList *l, *ll;
@@ -722,25 +840,43 @@ static void update_old_pins_array(struct srd_decoder_inst *di,
 	}
 }
 
+static void update_old_pins_array_initial_pins(struct srd_decoder_inst *di)
+{
+	uint8_t sample;
+	int i, byte_offset, bit_offset;
+	const uint8_t *sample_pos;
+
+	if (!di || !di->dec_channelmap)
+		return;
+
+	sample_pos = di->inbuf + ((di->abs_cur_samplenum - di->abs_start_samplenum) * di->data_unitsize);
+
+	for (i = 0; i < di->dec_num_channels; i++) {
+		if (di->old_pins_array->data[i] != SRD_INITIAL_PIN_SAME_AS_SAMPLE0)
+			continue;
+		byte_offset = di->dec_channelmap[i] / 8;
+		bit_offset = di->dec_channelmap[i] % 8;
+		sample = *(sample_pos + byte_offset) & (1 << bit_offset) ? 1 : 0;
+		di->old_pins_array->data[i] = sample;
+	}
+}
+
 static gboolean term_matches(const struct srd_decoder_inst *di,
 		struct srd_term *term, const uint8_t *sample_pos)
 {
 	uint8_t old_sample, sample;
 	int byte_offset, bit_offset, ch;
 
-	if (!di || !di->dec_channelmap || !term || !sample_pos)
-		return FALSE;
+	/* Caller ensures di, di->dec_channelmap, term, sample_pos != NULL. */
 
-	/* Overwritten below (or ignored for SRD_TERM_SKIP). */
-	old_sample = sample = 0;
+	if (term->type == SRD_TERM_SKIP)
+		return sample_matches(0, 0, term);
 
-	if (term->type != SRD_TERM_SKIP) {
-		ch = term->channel;
-		byte_offset = di->dec_channelmap[ch] / 8;
-		bit_offset = di->dec_channelmap[ch] % 8;
-		sample = *(sample_pos + byte_offset) & (1 << bit_offset) ? 1 : 0;
-		old_sample = di->old_pins_array->data[ch];
-	}
+	ch = term->channel;
+	byte_offset = di->dec_channelmap[ch] / 8;
+	bit_offset = di->dec_channelmap[ch] % 8;
+	sample = *(sample_pos + byte_offset) & (1 << bit_offset) ? 1 : 0;
+	old_sample = di->old_pins_array->data[ch];
 
 	return sample_matches(old_sample, sample, term);
 }
@@ -751,8 +887,7 @@ static gboolean all_terms_match(const struct srd_decoder_inst *di,
 	const GSList *l;
 	struct srd_term *term;
 
-	if (!di || !cond || !sample_pos)
-		return FALSE;
+	/* Caller ensures di, cond, sample_pos != NULL. */
 
 	for (l = cond; l; l = l->next) {
 		term = l->data;
@@ -768,8 +903,7 @@ static gboolean at_least_one_condition_matched(
 {
 	unsigned int i;
 
-	if (!di)
-		return FALSE;
+	/* Caller ensures di != NULL. */
 
 	for (i = 0; i < num_conditions; i++) {
 		if (di->match_array->data[i])
@@ -787,6 +921,8 @@ static gboolean find_match(struct srd_decoder_inst *di)
 	const uint8_t *sample_pos;
 	unsigned int num_conditions;
 
+	/* Caller ensures di != NULL. */
+
 	/* Check whether the condition list is NULL/empty. */
 	if (!di->condition_list) {
 		srd_dbg("NULL/empty condition list, automatic match.");
@@ -799,16 +935,20 @@ static gboolean find_match(struct srd_decoder_inst *di)
 		return TRUE;
 	}
 
-	num_samples_to_process = di->end_samplenum - di->cur_samplenum;
+	num_samples_to_process = di->abs_end_samplenum - di->abs_cur_samplenum;
 	num_conditions = g_slist_length(di->condition_list);
 
 	/* di->match_array is NULL here. Create a new GArray. */
 	di->match_array = g_array_sized_new(FALSE, TRUE, sizeof(gboolean), num_conditions);
 	g_array_set_size(di->match_array, num_conditions);
 
-	for (i = 0, s = 0; i < num_samples_to_process; i++, s++, (di->cur_samplenum)++) {
+	/* Sample 0: Set di->old_pins_array for SRD_INITIAL_PIN_SAME_AS_SAMPLE0 pins. */
+	if (di->abs_cur_samplenum == 0)
+		update_old_pins_array_initial_pins(di);
+
+	for (i = 0, s = 0; i < num_samples_to_process; i++, s++, (di->abs_cur_samplenum)++) {
 
-		sample_pos = di->inbuf + ((di->cur_samplenum - di->start_samplenum) * di->data_unitsize);
+		sample_pos = di->inbuf + ((di->abs_cur_samplenum - di->abs_start_samplenum) * di->data_unitsize);
 
 		/* Check whether the current sample matches at least one of the conditions (logical OR). */
 		/* IMPORTANT: We need to check all conditions, even if there was a match already! */
@@ -835,6 +975,8 @@ static gboolean find_match(struct srd_decoder_inst *di)
  *
  * This function returns if there is an error, or when a match is found, or
  * when all samples have been processed (whether a match was found or not).
+ * This function immediately terminates when the decoder's wait() method
+ * invocation shall get terminated.
  *
  * @param di The decoder instance to use. Must not be NULL.
  * @param found_match Will be set to TRUE if at least one condition matched,
@@ -850,15 +992,20 @@ SRD_PRIV int process_samples_until_condition_match(struct srd_decoder_inst *di,
 	if (!di || !found_match)
 		return SRD_ERR_ARG;
 
+	*found_match = FALSE;
+	if (di->want_wait_terminate)
+		return SRD_OK;
+
 	/* Check if any of the current condition(s) match. */
 	while (TRUE) {
 		/* Feed the (next chunk of the) buffer to find_match(). */
 		*found_match = find_match(di);
 
 		/* Did we handle all samples yet? */
-		if (di->cur_samplenum >= di->end_samplenum) {
-			srd_dbg("Done, handled all samples (%" PRIu64 "/%" PRIu64 ").",
-				di->cur_samplenum, di->end_samplenum);
+		if (di->abs_cur_samplenum >= di->abs_end_samplenum) {
+			srd_dbg("Done, handled all samples (abs cur %" PRIu64
+				" / abs end %" PRIu64 ").",
+				di->abs_cur_samplenum, di->abs_end_samplenum);
 			return SRD_OK;
 		}
 
@@ -885,20 +1032,74 @@ static gpointer di_thread(gpointer data)
 {
 	PyObject *py_res;
 	struct srd_decoder_inst *di;
+	int wanted_term;
 
 	if (!data)
 		return NULL;
 
 	di = data;
 
-	/* Call self.decode(). Only returns if the PD throws an exception. */
+	srd_dbg("%s: Starting thread routine for decoder.", di->inst_id);
+
+	/*
+	 * Call self.decode(). Only returns if the PD throws an exception.
+	 * "Regular" termination of the decode() method is not expected.
+	 */
 	Py_IncRef(di->py_inst);
-	if (!(py_res = PyObject_CallMethod(di->py_inst, "decode", NULL))) {
+	srd_dbg("%s: Calling decode() method.", di->inst_id);
+	py_res = PyObject_CallMethod(di->py_inst, "decode", NULL);
+	srd_dbg("%s: decode() method terminated.", di->inst_id);
+
+	/*
+	 * Make sure to unblock potentially pending srd_inst_decode()
+	 * calls in application threads after the decode() method might
+	 * have terminated, while it neither has processed sample data
+	 * nor has terminated upon request. This happens e.g. when "need
+	 * a samplerate to decode" exception is thrown.
+	 */
+	g_mutex_lock(&di->data_mutex);
+	wanted_term = di->want_wait_terminate;
+	di->want_wait_terminate = TRUE;
+	di->handled_all_samples = TRUE;
+	g_cond_signal(&di->handled_all_samples_cond);
+	g_mutex_unlock(&di->data_mutex);
+
+	/*
+	 * Check for the termination cause of the decode() method.
+	 * Though this is mostly for information.
+	 */
+	if (!py_res && wanted_term) {
+		/*
+		 * Silently ignore errors upon return from decode() calls
+		 * when termination was requested. Terminate the thread
+		 * which executed this instance's decode() logic.
+		 */
+		srd_dbg("%s: Thread done (!res, want_term).", di->inst_id);
+		PyErr_Clear();
+		return NULL;
+	}
+	if (!py_res) {
+		/*
+		 * The decode() invocation terminated unexpectedly. Have
+		 * the back trace printed, and terminate the thread which
+		 * executed the decode() method.
+		 */
+		srd_dbg("%s: decode() terminated unrequested.", di->inst_id);
 		srd_exception_catch("Protocol decoder instance %s: ", di->inst_id);
-		exit(1); /* TODO: Proper shutdown. This is a hack. */
+		srd_dbg("%s: Thread done (!res, !want_term).", di->inst_id);
 		return NULL;
 	}
+
+	/*
+	 * TODO: By design the decode() method is not supposed to terminate.
+	 * Nevertheless we have the thread joined, and srd backend calls to
+	 * decode() will re-start another thread transparently.
+	 */
+	srd_dbg("%s: decode() terminated (req %d).", di->inst_id, wanted_term);
 	Py_DecRef(py_res);
+	PyErr_Clear();
+
+	srd_dbg("%s: Thread done (with res).", di->inst_id);
 
 	return NULL;
 }
@@ -906,11 +1107,45 @@ static gpointer di_thread(gpointer data)
 /**
  * Decode a chunk of samples.
  *
+ * The calls to this function must provide the samples that shall be
+ * used by the protocol decoder
+ *  - in the correct order ([...]5, 6, 4, 7, 8[...] is a bug),
+ *  - starting from sample zero (2, 3, 4, 5, 6[...] is a bug),
+ *  - consecutively, with no gaps (0, 1, 2, 4, 5[...] is a bug).
+ *
+ * The start- and end-sample numbers are absolute sample numbers (relative
+ * to the start of the whole capture/file/stream), i.e. they are not relative
+ * sample numbers within the chunk specified by 'inbuf' and 'inbuflen'.
+ *
+ * Correct example (4096 samples total, 4 chunks @ 1024 samples each):
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 1024, 2048, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 2048, 3072, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 3072, 4096, inbuf, 1024, 1);
+ *
+ * The chunk size ('inbuflen') can be arbitrary and can differ between calls.
+ *
+ * Correct example (4096 samples total, 7 chunks @ various samples each):
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 1024, 1124, inbuf,  100, 1);
+ *   srd_inst_decode(di, 1124, 1424, inbuf,  300, 1);
+ *   srd_inst_decode(di, 1424, 1643, inbuf,  219, 1);
+ *   srd_inst_decode(di, 1643, 2048, inbuf,  405, 1);
+ *   srd_inst_decode(di, 2048, 3072, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 3072, 4096, inbuf, 1024, 1);
+ *
+ * INCORRECT example (4096 samples total, 4 chunks @ 1024 samples each, but
+ * the start- and end-samplenumbers are not absolute):
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *
  * @param di The decoder instance to call. Must not be NULL.
- * @param start_samplenum The starting sample number for the buffer's sample
- * 			  set, relative to the start of capture.
- * @param end_samplenum The ending sample number for the buffer's sample
- * 			  set, relative to the start of capture.
+ * @param abs_start_samplenum The absolute starting sample number for the
+ * 		buffer's sample set, relative to the start of capture.
+ * @param abs_end_samplenum The absolute ending sample number for the
+ * 		buffer's sample set, relative to the start of capture.
  * @param inbuf The buffer to decode. Must not be NULL.
  * @param inbuflen Length of the buffer. Must be > 0.
  * @param unitsize The number of bytes per sample. Must be > 0.
@@ -920,13 +1155,9 @@ static gpointer di_thread(gpointer data)
  * @private
  */
 SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di,
-		uint64_t start_samplenum, uint64_t end_samplenum,
+		uint64_t abs_start_samplenum, uint64_t abs_end_samplenum,
 		const uint8_t *inbuf, uint64_t inbuflen, uint64_t unitsize)
 {
-	PyObject *py_res;
-	srd_logic *logic;
-	long apiver;
-
 	/* Return an error upon unusable input. */
 	if (!di) {
 		srd_dbg("empty decoder instance");
@@ -945,65 +1176,50 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di,
 		return SRD_ERR_ARG;
 	}
 
+	if (abs_start_samplenum != di->abs_cur_samplenum ||
+	    abs_end_samplenum < abs_start_samplenum) {
+		srd_dbg("Incorrect sample numbers: start=%" PRIu64 ", cur=%"
+			PRIu64 ", end=%" PRIu64 ".", abs_start_samplenum,
+			di->abs_cur_samplenum, abs_end_samplenum);
+		return SRD_ERR_ARG;
+	}
+
 	di->data_unitsize = unitsize;
 
-	srd_dbg("Decoding: start sample %" PRIu64 ", end sample %"
+	srd_dbg("Decoding: abs start sample %" PRIu64 ", abs end sample %"
 		PRIu64 " (%" PRIu64 " samples, %" PRIu64 " bytes, unitsize = "
-		"%d), instance %s.", start_samplenum, end_samplenum,
-		end_samplenum - start_samplenum, inbuflen, di->data_unitsize,
+		"%d), instance %s.", abs_start_samplenum, abs_end_samplenum,
+		abs_end_samplenum - abs_start_samplenum, inbuflen, di->data_unitsize,
 		di->inst_id);
 
-	apiver = srd_decoder_apiver(di->decoder);
-
-	if (apiver == 2) {
-		/*
-		 * Create new srd_logic object. Each iteration around the PD's
-		 * loop will fill one sample into this object.
-		 */
-		logic = PyObject_New(srd_logic, (PyTypeObject *)srd_logic_type);
-		Py_INCREF(logic);
-		logic->di = (struct srd_decoder_inst *)di;
-		logic->start_samplenum = start_samplenum;
-		logic->itercnt = 0;
-		logic->inbuf = (uint8_t *)inbuf;
-		logic->inbuflen = inbuflen;
-		logic->sample = PyList_New(2);
-		Py_INCREF(logic->sample);
-
-		Py_IncRef(di->py_inst);
-		if (!(py_res = PyObject_CallMethod(di->py_inst, "decode",
-			"KKO", start_samplenum, end_samplenum, logic))) {
-			srd_exception_catch("Protocol decoder instance %s",
-					di->inst_id);
-			return SRD_ERR_PYTHON;
-		}
-		Py_DecRef(py_res);
-	} else {
-		/* If this is the first call, start the worker thread. */
-		if (!di->thread_handle)
-			di->thread_handle = g_thread_new("di_thread",
-							 di_thread, di);
-
-		/* Push the new sample chunk to the worker thread. */
-		g_mutex_lock(&di->data_mutex);
-		di->start_samplenum = start_samplenum;
-		di->end_samplenum = end_samplenum;
-		di->inbuf = inbuf;
-		di->inbuflen = inbuflen;
-		di->got_new_samples = TRUE;
-		di->handled_all_samples = FALSE;
-
-		/* Signal the thread that we have new data. */
-		g_cond_signal(&di->got_new_samples_cond);
-		g_mutex_unlock(&di->data_mutex);
-
-		/* When all samples in this chunk were handled, return. */
-		g_mutex_lock(&di->data_mutex);
-		while (!di->handled_all_samples)
-			g_cond_wait(&di->handled_all_samples_cond, &di->data_mutex);
-		g_mutex_unlock(&di->data_mutex);
+	/* If this is the first call, start the worker thread. */
+	if (!di->thread_handle) {
+		srd_dbg("No worker thread for this decoder stack "
+			"exists yet, creating one: %s.", di->inst_id);
+		di->thread_handle = g_thread_new(di->inst_id,
+						 di_thread, di);
 	}
 
+	/* Push the new sample chunk to the worker thread. */
+	g_mutex_lock(&di->data_mutex);
+	di->abs_start_samplenum = abs_start_samplenum;
+	di->abs_end_samplenum = abs_end_samplenum;
+	di->inbuf = inbuf;
+	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);
+	g_mutex_unlock(&di->data_mutex);
+
+	/* When all samples in this chunk were handled, return. */
+	g_mutex_lock(&di->data_mutex);
+	while (!di->handled_all_samples && !di->want_wait_terminate)
+		g_cond_wait(&di->handled_all_samples_cond, &di->data_mutex);
+	g_mutex_unlock(&di->data_mutex);
+
 	return SRD_OK;
 }
 
@@ -1015,6 +1231,9 @@ SRD_PRIV void srd_inst_free(struct srd_decoder_inst *di)
 
 	srd_dbg("Freeing instance %s", di->inst_id);
 
+	srd_inst_join_decode_thread(di);
+	srd_inst_reset_state(di);
+
 	Py_DecRef(di->py_inst);
 	g_free(di->inst_id);
 	g_free(di->dec_channelmap);