X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=pv%2Fdata%2Fdecodesignal.cpp;h=593af02fdd796348aac72d3b621fa13239cffa3f;hb=cbb2e4da8042495531b406f745ee9d9e20448ef6;hp=4a7d6ed8c60a7593773d50bf17026176f018678b;hpb=ab185f78707eb2800c8b9ea577412ea5f6319f22;p=pulseview.git

diff --git a/pv/data/decodesignal.cpp b/pv/data/decodesignal.cpp
index 4a7d6ed8..593af02f 100644
--- a/pv/data/decodesignal.cpp
+++ b/pv/data/decodesignal.cpp
@@ -17,6 +17,7 @@
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <cstring>
 #include <forward_list>
 #include <limits>
 
@@ -27,7 +28,6 @@
 #include "decodesignal.hpp"
 #include "signaldata.hpp"
 
-#include <pv/binding/decoder.hpp>
 #include <pv/data/decode/decoder.hpp>
 #include <pv/data/decode/row.hpp>
 #include <pv/globalsettings.hpp>
@@ -42,6 +42,7 @@ using std::out_of_range;
 using std::shared_ptr;
 using std::unique_lock;
 using pv::data::decode::Annotation;
+using pv::data::decode::DecodeChannel;
 using pv::data::decode::Decoder;
 using pv::data::decode::Row;
 
@@ -75,7 +76,7 @@ const vector< shared_ptr<Decoder> >& DecodeSignal::decoder_stack() const
 	return stack_;
 }
 
-void DecodeSignal::stack_decoder(const srd_decoder *decoder)
+void DecodeSignal::stack_decoder(const srd_decoder *decoder, bool restart_decode)
 {
 	assert(decoder);
 
@@ -97,7 +98,11 @@ void DecodeSignal::stack_decoder(const srd_decoder *decoder)
 	stack_config_changed_ = true;
 	auto_assign_signals(dec);
 	commit_decoder_channels();
-	begin_decode();
+
+	decoder_stacked((void*)dec.get());
+
+	if (restart_decode)
+		begin_decode();
 }
 
 void DecodeSignal::remove_decoder(int index)
@@ -110,6 +115,8 @@ void DecodeSignal::remove_decoder(int index)
 	for (int i = 0; i < index; i++, iter++)
 		assert(iter != stack_.end());
 
+	decoder_removed(iter->get());
+
 	// Delete the element
 	stack_.erase(iter);
 
@@ -205,7 +212,7 @@ void DecodeSignal::begin_decode()
 	// Make sure that all assigned channels still provide logic data
 	// (can happen when a converted signal was assigned but the
 	// conversion removed in the meanwhile)
-	for (data::DecodeChannel& ch : channels_)
+	for (decode::DecodeChannel& ch : channels_)
 		if (ch.assigned_signal && !(ch.assigned_signal->logic_data() != nullptr))
 			ch.assigned_signal = nullptr;
 
@@ -229,12 +236,11 @@ void DecodeSignal::begin_decode()
 				(srd_decoder_annotation_row *)l->data;
 			assert(ann_row);
 
-			const Row row(row_index++, decc, ann_row);
+			const Row row(row_index++, dec.get(), ann_row);
 
 			for (const GSList *ll = ann_row->ann_classes;
 				ll; ll = ll->next)
-				class_rows_[make_pair(decc,
-					GPOINTER_TO_INT(ll->data))] = row;
+				class_rows_[make_pair(decc, GPOINTER_TO_INT(ll->data))] = row;
 		}
 	}
 
@@ -290,7 +296,7 @@ QString DecodeSignal::error_message() const
 	return error_message_;
 }
 
-const vector<data::DecodeChannel> DecodeSignal::get_channels() const
+const vector<decode::DecodeChannel> DecodeSignal::get_channels() const
 {
 	return channels_;
 }
@@ -300,7 +306,7 @@ void DecodeSignal::auto_assign_signals(const shared_ptr<Decoder> dec)
 	bool new_assignment = false;
 
 	// Try to auto-select channels that don't have signals assigned yet
-	for (data::DecodeChannel& ch : channels_) {
+	for (decode::DecodeChannel& ch : channels_) {
 		// If a decoder is given, auto-assign only its channels
 		if (dec && (ch.decoder_ != dec))
 			continue;
@@ -349,7 +355,7 @@ void DecodeSignal::auto_assign_signals(const shared_ptr<Decoder> dec)
 
 void DecodeSignal::assign_signal(const uint16_t channel_id, const SignalBase *signal)
 {
-	for (data::DecodeChannel& ch : channels_)
+	for (decode::DecodeChannel& ch : channels_)
 		if (ch.id == channel_id) {
 			ch.assigned_signal = signal;
 			logic_mux_data_invalid_ = true;
@@ -365,12 +371,12 @@ int DecodeSignal::get_assigned_signal_count() const
 {
 	// Count all channels that have a signal assigned to them
 	return count_if(channels_.begin(), channels_.end(),
-		[](data::DecodeChannel ch) { return ch.assigned_signal; });
+		[](decode::DecodeChannel ch) { return ch.assigned_signal; });
 }
 
 void DecodeSignal::set_initial_pin_state(const uint16_t channel_id, const int init_state)
 {
-	for (data::DecodeChannel& ch : channels_)
+	for (decode::DecodeChannel& ch : channels_)
 		if (ch.id == channel_id)
 			ch.initial_pin_state = init_state;
 
@@ -410,7 +416,7 @@ int64_t DecodeSignal::get_working_sample_count(uint32_t segment_id) const
 	int64_t count = std::numeric_limits<int64_t>::max();
 	bool no_signals_assigned = true;
 
-	for (const data::DecodeChannel& ch : channels_)
+	for (const decode::DecodeChannel& ch : channels_)
 		if (ch.assigned_signal) {
 			no_signals_assigned = false;
 
@@ -436,15 +442,13 @@ int64_t DecodeSignal::get_decoded_sample_count(uint32_t segment_id,
 
 	int64_t result = 0;
 
-	try {
-		const DecodeSegment *segment = &(segments_.at(segment_id));
-		if (include_processing)
-			result = segment->samples_decoded_incl;
-		else
-			result = segment->samples_decoded_excl;
-	} catch (out_of_range&) {
-		// Do nothing
-	}
+	if (segment_id >= segments_.size())
+		return result;
+
+	if (include_processing)
+		result = segments_[segment_id].samples_decoded_incl;
+	else
+		result = segments_[segment_id].samples_decoded_excl;
 
 	return result;
 }
@@ -466,20 +470,37 @@ vector<Row> DecodeSignal::get_rows(bool visible_only) const
 		int row_index = 0;
 		// Add a row for the decoder if it doesn't have a row list
 		if (!decc->annotation_rows)
-			rows.emplace_back(row_index++, decc);
+			rows.emplace_back(row_index++, dec.get());
 
 		// Add the decoder rows
 		for (const GSList *l = decc->annotation_rows; l; l = l->next) {
 			const srd_decoder_annotation_row *const ann_row =
 				(srd_decoder_annotation_row *)l->data;
 			assert(ann_row);
-			rows.emplace_back(row_index++, decc, ann_row);
+			rows.emplace_back(row_index++, dec.get(), ann_row);
 		}
 	}
 
 	return rows;
 }
 
+uint64_t DecodeSignal::get_annotation_count(const decode::Row &row,
+	uint32_t segment_id) const
+{
+	if (segment_id >= segments_.size())
+		return 0;
+
+	const DecodeSegment *segment = &(segments_.at(segment_id));
+	const map<const decode::Row, decode::RowData> *rows =
+		&(segment->annotation_rows);
+
+	const auto iter = rows->find(row);
+	if (iter != rows->end())
+		return (*iter).second.get_annotation_count();
+
+	return 0;
+}
+
 void DecodeSignal::get_annotation_subset(
 	vector<pv::data::decode::Annotation> &dest,
 	const decode::Row &row, uint32_t segment_id, uint64_t start_sample,
@@ -487,18 +508,15 @@ void DecodeSignal::get_annotation_subset(
 {
 	lock_guard<mutex> lock(output_mutex_);
 
-	try {
-		const DecodeSegment *segment = &(segments_.at(segment_id));
-		const map<const decode::Row, decode::RowData> *rows =
-			&(segment->annotation_rows);
+	if (segment_id >= segments_.size())
+		return;
 
-		const auto iter = rows->find(row);
-		if (iter != rows->end())
-			(*iter).second.get_annotation_subset(dest,
-				start_sample, end_sample);
-	} catch (out_of_range&) {
-		// Do nothing
-	}
+	const DecodeSegment *segment = &(segments_.at(segment_id));
+	const map<const decode::Row, decode::RowData> *rows = &(segment->annotation_rows);
+
+	const auto iter = rows->find(row);
+	if (iter != rows->end())
+		(*iter).second.get_annotation_subset(dest, start_sample, end_sample);
 }
 
 void DecodeSignal::get_annotation_subset(
@@ -507,7 +525,7 @@ void DecodeSignal::get_annotation_subset(
 {
 	// Note: We put all vectors and lists on the heap, not the stack
 
-	const vector<Row> rows = get_rows(true);
+	const vector<Row> rows = get_rows();
 
 	// Use forward_lists for faster merging
 	forward_list<Annotation> *all_ann_list = new forward_list<Annotation>();
@@ -528,6 +546,142 @@ void DecodeSignal::get_annotation_subset(
 	delete all_ann_list;
 }
 
+uint32_t DecodeSignal::get_binary_data_chunk_count(uint32_t segment_id,
+	const Decoder* dec, uint32_t bin_class_id) const
+{
+	if (segments_.size() == 0)
+		return 0;
+
+	try {
+		const DecodeSegment *segment = &(segments_.at(segment_id));
+
+		for (const DecodeBinaryClass& bc : segment->binary_classes)
+			if ((bc.decoder == dec) && (bc.info->bin_class_id == bin_class_id))
+				return bc.chunks.size();
+	} catch (out_of_range&) {
+		// Do nothing
+	}
+
+	return 0;
+}
+
+void DecodeSignal::get_binary_data_chunk(uint32_t segment_id,
+	const  Decoder* dec, uint32_t bin_class_id, uint32_t chunk_id,
+	const vector<uint8_t> **dest, uint64_t *size)
+{
+	try {
+		const DecodeSegment *segment = &(segments_.at(segment_id));
+
+		for (const DecodeBinaryClass& bc : segment->binary_classes)
+			if ((bc.decoder == dec) && (bc.info->bin_class_id == bin_class_id)) {
+				if (dest) *dest = &(bc.chunks.at(chunk_id).data);
+				if (size) *size = bc.chunks.at(chunk_id).data.size();
+				return;
+			}
+	} catch (out_of_range&) {
+		// Do nothing
+	}
+}
+
+void DecodeSignal::get_merged_binary_data_chunks_by_sample(uint32_t segment_id,
+	const Decoder* dec, uint32_t bin_class_id, uint64_t start_sample,
+	uint64_t end_sample, vector<uint8_t> *dest) const
+{
+	assert(dest != nullptr);
+
+	try {
+		const DecodeSegment *segment = &(segments_.at(segment_id));
+
+		const DecodeBinaryClass* bin_class = nullptr;
+		for (const DecodeBinaryClass& bc : segment->binary_classes)
+			if ((bc.decoder == dec) && (bc.info->bin_class_id == bin_class_id))
+				bin_class = &bc;
+
+		// Determine overall size before copying to resize dest vector only once
+		uint64_t size = 0;
+		uint64_t matches = 0;
+		for (const DecodeBinaryDataChunk& chunk : bin_class->chunks)
+			if ((chunk.sample >= start_sample) && (chunk.sample < end_sample)) {
+				size += chunk.data.size();
+				matches++;
+			}
+		dest->resize(size);
+
+		uint64_t offset = 0;
+		uint64_t matches2 = 0;
+		for (const DecodeBinaryDataChunk& chunk : bin_class->chunks)
+			if ((chunk.sample >= start_sample) && (chunk.sample < end_sample)) {
+				memcpy(dest->data() + offset, chunk.data.data(), chunk.data.size());
+				offset += chunk.data.size();
+				matches2++;
+
+				// Make sure we don't overwrite memory if the array grew in the meanwhile
+				if (matches2 == matches)
+					break;
+			}
+	} catch (out_of_range&) {
+		// Do nothing
+	}
+}
+
+void DecodeSignal::get_merged_binary_data_chunks_by_offset(uint32_t segment_id,
+	const data::decode::Decoder* dec, uint32_t bin_class_id, uint64_t start,
+	uint64_t end, vector<uint8_t> *dest) const
+{
+	assert(dest != nullptr);
+
+	try {
+		const DecodeSegment *segment = &(segments_.at(segment_id));
+
+		const DecodeBinaryClass* bin_class = nullptr;
+		for (const DecodeBinaryClass& bc : segment->binary_classes)
+			if ((bc.decoder == dec) && (bc.info->bin_class_id == bin_class_id))
+				bin_class = &bc;
+
+		// Determine overall size before copying to resize dest vector only once
+		uint64_t size = 0;
+		uint64_t offset = 0;
+		for (const DecodeBinaryDataChunk& chunk : bin_class->chunks) {
+			if (offset >= start)
+				size += chunk.data.size();
+			offset += chunk.data.size();
+			if (offset >= end)
+				break;
+		}
+		dest->resize(size);
+
+		offset = 0;
+		uint64_t dest_offset = 0;
+		for (const DecodeBinaryDataChunk& chunk : bin_class->chunks) {
+			if (offset >= start) {
+				memcpy(dest->data() + dest_offset, chunk.data.data(), chunk.data.size());
+				dest_offset += chunk.data.size();
+			}
+			offset += chunk.data.size();
+			if (offset >= end)
+				break;
+		}
+	} catch (out_of_range&) {
+		// Do nothing
+	}
+}
+
+const DecodeBinaryClass* DecodeSignal::get_binary_data_class(uint32_t segment_id,
+	const data::decode::Decoder* dec, uint32_t bin_class_id) const
+{
+	try {
+		const DecodeSegment *segment = &(segments_.at(segment_id));
+
+		for (const DecodeBinaryClass& bc : segment->binary_classes)
+			if ((bc.decoder == dec) && (bc.info->bin_class_id == bin_class_id))
+				return &bc;
+	} catch (out_of_range&) {
+		// Do nothing
+	}
+
+	return nullptr;
+}
+
 void DecodeSignal::save_settings(QSettings &settings) const
 {
 	SignalBase::save_settings(settings);
@@ -566,7 +720,7 @@ void DecodeSignal::save_settings(QSettings &settings) const
 
 	for (unsigned int channel_id = 0; channel_id < channels_.size(); channel_id++) {
 		auto channel = find_if(channels_.begin(), channels_.end(),
-			[&](data::DecodeChannel ch) { return ch.id == channel_id; });
+			[&](decode::DecodeChannel ch) { return ch.id == channel_id; });
 
 		if (channel == channels_.end()) {
 			qDebug() << "ERROR: Gap in channel index:" << channel_id;
@@ -640,7 +794,7 @@ void DecodeSignal::restore_settings(QSettings &settings)
 
 	for (unsigned int channel_id = 0; channel_id < channels; channel_id++) {
 		auto channel = find_if(channels_.begin(), channels_.end(),
-			[&](data::DecodeChannel ch) { return ch.id == channel_id; });
+			[&](decode::DecodeChannel ch) { return ch.id == channel_id; });
 
 		if (channel == channels_.end()) {
 			qDebug() << "ERROR: Non-existant channel index:" << channel_id;
@@ -680,7 +834,7 @@ uint32_t DecodeSignal::get_input_segment_count() const
 	uint64_t count = std::numeric_limits<uint64_t>::max();
 	bool no_signals_assigned = true;
 
-	for (const data::DecodeChannel& ch : channels_)
+	for (const decode::DecodeChannel& ch : channels_)
 		if (ch.assigned_signal) {
 			no_signals_assigned = false;
 
@@ -700,7 +854,7 @@ uint32_t DecodeSignal::get_input_samplerate(uint32_t segment_id) const
 {
 	double samplerate = 0;
 
-	for (const data::DecodeChannel& ch : channels_)
+	for (const decode::DecodeChannel& ch : channels_)
 		if (ch.assigned_signal) {
 			const shared_ptr<Logic> logic_data = ch.assigned_signal->logic_data();
 			if (!logic_data || logic_data->logic_segments().empty())
@@ -720,7 +874,7 @@ uint32_t DecodeSignal::get_input_samplerate(uint32_t segment_id) const
 
 void DecodeSignal::update_channel_list()
 {
-	vector<data::DecodeChannel> prev_channels = channels_;
+	vector<decode::DecodeChannel> prev_channels = channels_;
 	channels_.clear();
 
 	uint16_t id = 0;
@@ -736,7 +890,7 @@ void DecodeSignal::update_channel_list()
 			bool ch_added = false;
 
 			// Copy but update ID if this channel was in the list before
-			for (data::DecodeChannel& ch : prev_channels)
+			for (decode::DecodeChannel& ch : prev_channels)
 				if (ch.pdch_ == pdch) {
 					ch.id = id++;
 					channels_.push_back(ch);
@@ -746,7 +900,7 @@ void DecodeSignal::update_channel_list()
 
 			if (!ch_added) {
 				// Create new entry without a mapped signal
-				data::DecodeChannel ch = {id++, 0, false, nullptr,
+				decode::DecodeChannel ch = {id++, 0, false, nullptr,
 					QString::fromUtf8(pdch->name), QString::fromUtf8(pdch->desc),
 					SRD_INITIAL_PIN_SAME_AS_SAMPLE0, decoder, pdch};
 				channels_.push_back(ch);
@@ -759,7 +913,7 @@ void DecodeSignal::update_channel_list()
 			bool ch_added = false;
 
 			// Copy but update ID if this channel was in the list before
-			for (data::DecodeChannel& ch : prev_channels)
+			for (decode::DecodeChannel& ch : prev_channels)
 				if (ch.pdch_ == pdch) {
 					ch.id = id++;
 					channels_.push_back(ch);
@@ -769,7 +923,7 @@ void DecodeSignal::update_channel_list()
 
 			if (!ch_added) {
 				// Create new entry without a mapped signal
-				data::DecodeChannel ch = {id++, 0, true, nullptr,
+				decode::DecodeChannel ch = {id++, 0, true, nullptr,
 					QString::fromUtf8(pdch->name), QString::fromUtf8(pdch->desc),
 					SRD_INITIAL_PIN_SAME_AS_SAMPLE0, decoder, pdch};
 				channels_.push_back(ch);
@@ -784,8 +938,8 @@ void DecodeSignal::update_channel_list()
 	} else {
 		// Same number but assignment may still differ, so compare all channels
 		for (size_t i = 0; i < channels_.size(); i++) {
-			const data::DecodeChannel& p_ch = prev_channels[i];
-			const data::DecodeChannel& ch = channels_[i];
+			const decode::DecodeChannel& p_ch = prev_channels[i];
+			const decode::DecodeChannel& ch = channels_[i];
 
 			if ((p_ch.pdch_ != ch.pdch_) ||
 				(p_ch.assigned_signal != ch.assigned_signal)) {
@@ -803,9 +957,9 @@ void DecodeSignal::commit_decoder_channels()
 {
 	// Submit channel list to every decoder, containing only the relevant channels
 	for (shared_ptr<decode::Decoder> dec : stack_) {
-		vector<data::DecodeChannel*> channel_list;
+		vector<decode::DecodeChannel*> channel_list;
 
-		for (data::DecodeChannel& ch : channels_)
+		for (decode::DecodeChannel& ch : channels_)
 			if (ch.decoder_ == dec)
 				channel_list.push_back(&ch);
 
@@ -814,7 +968,7 @@ void DecodeSignal::commit_decoder_channels()
 
 	// Channel bit IDs must be in sync with the channel's apperance in channels_
 	int id = 0;
-	for (data::DecodeChannel& ch : channels_)
+	for (decode::DecodeChannel& ch : channels_)
 		if (ch.assigned_signal)
 			ch.bit_id = id++;
 }
@@ -831,7 +985,7 @@ void DecodeSignal::mux_logic_samples(uint32_t segment_id, const int64_t start, c
 	vector<uint8_t> signal_in_bytepos;
 	vector<uint8_t> signal_in_bitpos;
 
-	for (data::DecodeChannel& ch : channels_)
+	for (decode::DecodeChannel& ch : channels_)
 		if (ch.assigned_signal) {
 			const shared_ptr<Logic> logic_data = ch.assigned_signal->logic_data();
 
@@ -1154,6 +1308,9 @@ void DecodeSignal::start_srd_session()
 	srd_pd_output_callback_add(srd_session_, SRD_OUTPUT_ANN,
 		DecodeSignal::annotation_callback, this);
 
+	srd_pd_output_callback_add(srd_session_, SRD_OUTPUT_BINARY,
+		DecodeSignal::binary_callback, this);
+
 	srd_session_start(srd_session_);
 
 	// We just recreated the srd session, so all stack changes are applied now
@@ -1202,7 +1359,7 @@ void DecodeSignal::connect_input_notifiers()
 	disconnect(this, SLOT(on_data_received()));
 
 	// Connect the currently used signals to our slot
-	for (data::DecodeChannel& ch : channels_) {
+	for (decode::DecodeChannel& ch : channels_) {
 		if (!ch.assigned_signal)
 			continue;
 
@@ -1228,7 +1385,7 @@ void DecodeSignal::create_decode_segment()
 		int row_index = 0;
 		// Add a row for the decoder if it doesn't have a row list
 		if (!decc->annotation_rows)
-			(segments_.back().annotation_rows)[Row(row_index++, decc)] =
+			(segments_.back().annotation_rows)[Row(row_index++, dec.get())] =
 				decode::RowData();
 
 		// Add the decoder rows
@@ -1237,13 +1394,21 @@ void DecodeSignal::create_decode_segment()
 				(srd_decoder_annotation_row *)l->data;
 			assert(ann_row);
 
-			const Row row(row_index++, decc, ann_row);
+			const Row row(row_index++, dec.get(), ann_row);
 
 			// Add a new empty row data object
-			(segments_.back().annotation_rows)[row] =
-				decode::RowData();
+			(segments_.back().annotation_rows)[row] = decode::RowData();
 		}
 	}
+
+	// Prepare our binary output classes
+	for (const shared_ptr<decode::Decoder>& dec : stack_) {
+		uint32_t n = dec->get_binary_class_count();
+
+		for (uint32_t i = 0; i < n; i++)
+			segments_.back().binary_classes.push_back(
+				{dec.get(), dec->get_binary_class(i), deque<DecodeBinaryDataChunk>()});
+	}
 }
 
 void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signal)
@@ -1259,26 +1424,28 @@ void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signa
 
 	lock_guard<mutex> lock(ds->output_mutex_);
 
-	// Find the row
+	// Get the decoder and the annotation data
 	assert(pdata->pdo);
 	assert(pdata->pdo->di);
 	const srd_decoder *const decc = pdata->pdo->di->decoder;
 	assert(decc);
 
-	const srd_proto_data_annotation *const pda =
-		(const srd_proto_data_annotation*)pdata->data;
+	const srd_proto_data_annotation *const pda = (const srd_proto_data_annotation*)pdata->data;
 	assert(pda);
 
+	// Find the row
 	auto row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.end();
 
-	// Try looking up the sub-row of this class
+	// Try finding a better row match than the default by looking up the sub-row of this class
 	const auto format = pda->ann_class;
 	const auto r = ds->class_rows_.find(make_pair(decc, format));
 	if (r != ds->class_rows_.end())
 		row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find((*r).second);
 	else {
 		// Failing that, use the decoder as a key
-		row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find(Row(0, decc));
+		for (const shared_ptr<decode::Decoder>& dec : ds->decoder_stack())
+			if (dec->decoder() == decc)
+				row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find(Row(0, dec.get()));
 	}
 
 	if (row_iter == ds->segments_.at(ds->current_segment_id_).annotation_rows.end()) {
@@ -1292,6 +1459,60 @@ void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signa
 	(*row_iter).second.emplace_annotation(pdata, &((*row_iter).first));
 }
 
+void DecodeSignal::binary_callback(srd_proto_data *pdata, void *decode_signal)
+{
+	assert(pdata);
+	assert(decode_signal);
+
+	DecodeSignal *const ds = (DecodeSignal*)decode_signal;
+	assert(ds);
+
+	if (ds->decode_interrupt_)
+		return;
+
+	// Get the decoder and the binary data
+	assert(pdata->pdo);
+	assert(pdata->pdo->di);
+	const srd_decoder *const decc = pdata->pdo->di->decoder;
+	assert(decc);
+
+	const srd_proto_data_binary *const pdb = (const srd_proto_data_binary*)pdata->data;
+	assert(pdb);
+
+	// Find the matching DecodeBinaryClass
+	DecodeSegment* segment = &(ds->segments_.at(ds->current_segment_id_));
+
+	DecodeBinaryClass* bin_class = nullptr;
+	for (DecodeBinaryClass& bc : segment->binary_classes)
+		if ((bc.decoder->decoder() == decc) && (bc.info->bin_class_id == (uint32_t)pdb->bin_class))
+			bin_class = &bc;
+
+	if (!bin_class) {
+		qWarning() << "Could not find valid DecodeBinaryClass in segment" <<
+				ds->current_segment_id_ << "for binary class ID" << pdb->bin_class <<
+				", segment only knows" << segment->binary_classes.size() << "classes";
+		return;
+	}
+
+	// Add the data chunk
+	bin_class->chunks.emplace_back();
+	DecodeBinaryDataChunk* chunk = &(bin_class->chunks.back());
+
+	chunk->sample = pdata->start_sample;
+	chunk->data.resize(pdb->size);
+	memcpy(chunk->data.data(), pdb->data, pdb->size);
+
+	// Find decoder class instance
+	Decoder* dec = nullptr;
+	for (const shared_ptr<decode::Decoder>& d : ds->decoder_stack())
+		if (d->decoder() == decc) {
+			dec = d.get();
+			break;
+		}
+
+	ds->new_binary_data(ds->current_segment_id_, (void*)dec, pdb->bin_class);
+}
+
 void DecodeSignal::on_capture_state_changed(int state)
 {
 	// If a new acquisition was started, we need to start decoding from scratch