X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Fdecodesignal.cpp;h=a6d4a9d603b23e0820a9a6a869658020e7787079;hp=4705b104542cef6c9875d8fa7e1922b6b6cae0c8;hb=ed75426f60765fe965d8bfdd21eb904cccc92804;hpb=556259d2d0a212c20db9b18311b9524b52401a56

diff --git a/pv/data/decodesignal.cpp b/pv/data/decodesignal.cpp
index 4705b104..a6d4a9d6 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,24 +76,33 @@ 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);
-	const shared_ptr<Decoder> dec = make_shared<decode::Decoder>(decoder);
 
-	stack_.push_back(dec);
+	// Set name if this decoder is the first in the list or the name is unchanged
+	const srd_decoder* prev_dec =
+		stack_.empty() ? nullptr : stack_.back()->decoder();
+	const QString prev_dec_name =
+		prev_dec ? QString::fromUtf8(prev_dec->name) : QString();
 
-	// Set name if this decoder is the first in the list
-	if (stack_.size() == 1)
+	if ((stack_.empty()) || ((stack_.size() > 0) && (name() == prev_dec_name)))
 		set_name(QString::fromUtf8(decoder->name));
 
+	const shared_ptr<Decoder> dec = make_shared<decode::Decoder>(decoder);
+	stack_.push_back(dec);
+
 	// Include the newly created decode channels in the channel lists
 	update_channel_list();
 
 	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)
@@ -105,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);
 
@@ -151,8 +163,7 @@ void DecodeSignal::reset_decode(bool shutting_down)
 		logic_mux_thread_.join();
 	}
 
-	decode_pause_mutex_.unlock();
-	decode_paused_ = false;
+	resume_decode();  // Make sure the decode thread isn't blocked by pausing
 
 	class_rows_.clear();
 	current_segment_id_ = 0;
@@ -201,12 +212,12 @@ 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;
 
 	// Check that all decoders have the required channels
-	for (const shared_ptr<decode::Decoder> &dec : stack_)
+	for (const shared_ptr<decode::Decoder>& dec : stack_)
 		if (!dec->have_required_channels()) {
 			set_error_message(tr("One or more required channels "
 				"have not been specified"));
@@ -215,7 +226,7 @@ void DecodeSignal::begin_decode()
 
 	// Map out all the annotation classes
 	int row_index = 0;
-	for (const shared_ptr<decode::Decoder> &dec : stack_) {
+	for (const shared_ptr<decode::Decoder>& dec : stack_) {
 		assert(dec);
 		const srd_decoder *const decc = dec->decoder();
 		assert(dec->decoder());
@@ -286,7 +297,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_;
 }
@@ -296,7 +307,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;
@@ -304,14 +315,16 @@ void DecodeSignal::auto_assign_signals(const shared_ptr<Decoder> dec)
 		if (ch.assigned_signal)
 			continue;
 
-		const QString ch_name = ch.name.toLower();
+		QString ch_name = ch.name.toLower();
+		ch_name = ch_name.replace(QRegExp("[-_.]"), " ");
 
 		shared_ptr<data::SignalBase> match;
-		for (shared_ptr<data::SignalBase> s : session_.signalbases()) {
+		for (const shared_ptr<data::SignalBase>& s : session_.signalbases()) {
 			if (!s->enabled())
 				continue;
 
-			const QString s_name = s->name().toLower();
+			QString s_name = s->name().toLower();
+			s_name = s_name.replace(QRegExp("[-_.]"), " ");
 
 			if (s->logic_data() &&
 				((ch_name.contains(s_name)) || (s_name.contains(ch_name)))) {
@@ -343,7 +356,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;
@@ -359,12 +372,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;
 
@@ -404,7 +417,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;
 
@@ -430,28 +443,26 @@ 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;
 }
 
-vector<Row> DecodeSignal::visible_rows() const
+vector<Row> DecodeSignal::get_rows(bool visible_only) const
 {
 	lock_guard<mutex> lock(output_mutex_);
 
 	vector<Row> rows;
 
-	for (const shared_ptr<decode::Decoder> &dec : stack_) {
+	for (const shared_ptr<decode::Decoder>& dec : stack_) {
 		assert(dec);
-		if (!dec->shown())
+		if (visible_only && !dec->shown())
 			continue;
 
 		const srd_decoder *const decc = dec->decoder();
@@ -481,18 +492,16 @@ 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(
@@ -501,7 +510,7 @@ void DecodeSignal::get_annotation_subset(
 {
 	// Note: We put all vectors and lists on the heap, not the stack
 
-	const vector<Row> rows = visible_rows();
+	const vector<Row> rows = get_rows(true);
 
 	// Use forward_lists for faster merging
 	forward_list<Annotation> *all_ann_list = new forward_list<Annotation>();
@@ -522,6 +531,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);
@@ -530,10 +675,11 @@ void DecodeSignal::save_settings(QSettings &settings) const
 
 	// Save decoder stack
 	int decoder_idx = 0;
-	for (shared_ptr<decode::Decoder> decoder : stack_) {
+	for (const shared_ptr<decode::Decoder>& decoder : stack_) {
 		settings.beginGroup("decoder" + QString::number(decoder_idx++));
 
 		settings.setValue("id", decoder->decoder()->id);
+		settings.setValue("shown", decoder->shown());
 
 		// Save decoder options
 		const map<string, GVariant*>& options = decoder->options();
@@ -543,7 +689,7 @@ void DecodeSignal::save_settings(QSettings &settings) const
 		// Note: decode::Decoder::options() returns only the options
 		// that differ from the default. See binding::Decoder::getter()
 		int i = 0;
-		for (auto option : options) {
+		for (auto& option : options) {
 			settings.beginGroup("option" + QString::number(i));
 			settings.setValue("name", QString::fromStdString(option.first));
 			GlobalSettings::store_gvariant(settings, option.second);
@@ -559,7 +705,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;
@@ -602,6 +748,7 @@ void DecodeSignal::restore_settings(QSettings &settings)
 					make_shared<decode::Decoder>(dec);
 
 				stack_.push_back(decoder);
+				decoder->show(settings.value("shown", true).toBool());
 
 				// Restore decoder options that differ from their default
 				int options = settings.value("options").toInt();
@@ -632,7 +779,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;
@@ -643,7 +790,7 @@ void DecodeSignal::restore_settings(QSettings &settings)
 
 		QString assigned_signal_name = settings.value("assigned_signal_name").toString();
 
-		for (shared_ptr<data::SignalBase> signal : signalbases)
+		for (const shared_ptr<data::SignalBase>& signal : signalbases)
 			if (signal->name() == assigned_signal_name)
 				channel->assigned_signal = signal.get();
 
@@ -672,7 +819,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;
 
@@ -692,7 +839,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())
@@ -712,13 +859,13 @@ 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;
 
 	// Copy existing entries, create new as needed
-	for (shared_ptr<Decoder> decoder : stack_) {
+	for (shared_ptr<Decoder>& decoder : stack_) {
 		const srd_decoder* srd_d = decoder->decoder();
 		const GSList *l;
 
@@ -728,7 +875,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);
@@ -738,7 +885,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);
@@ -751,7 +898,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);
@@ -761,7 +908,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);
@@ -776,8 +923,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)) {
@@ -795,9 +942,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);
 
@@ -806,7 +953,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++;
 }
@@ -823,7 +970,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();
 
@@ -1109,7 +1256,7 @@ void DecodeSignal::start_srd_session()
 		if (samplerate)
 			srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
 				g_variant_new_uint64(samplerate));
-		for (const shared_ptr<decode::Decoder> &dec : stack_)
+		for (const shared_ptr<decode::Decoder>& dec : stack_)
 			dec->apply_all_options();
 		srd_session_start(srd_session_);
 
@@ -1122,7 +1269,7 @@ void DecodeSignal::start_srd_session()
 
 	// Create the decoders
 	srd_decoder_inst *prev_di = nullptr;
-	for (const shared_ptr<decode::Decoder> &dec : stack_) {
+	for (const shared_ptr<decode::Decoder>& dec : stack_) {
 		srd_decoder_inst *const di = dec->create_decoder_inst(srd_session_);
 
 		if (!di) {
@@ -1146,6 +1293,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
@@ -1169,7 +1319,7 @@ void DecodeSignal::terminate_srd_session()
 		if (samplerate)
 			srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
 				g_variant_new_uint64(samplerate));
-		for (const shared_ptr<decode::Decoder> &dec : stack_)
+		for (const shared_ptr<decode::Decoder>& dec : stack_)
 			dec->apply_all_options();
 	}
 }
@@ -1182,7 +1332,7 @@ void DecodeSignal::stop_srd_session()
 		srd_session_ = nullptr;
 
 		// Mark the decoder instances as non-existant since they were deleted
-		for (const shared_ptr<decode::Decoder> &dec : stack_)
+		for (const shared_ptr<decode::Decoder>& dec : stack_)
 			dec->invalidate_decoder_inst();
 	}
 }
@@ -1194,7 +1344,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;
 
@@ -1212,7 +1362,7 @@ void DecodeSignal::create_decode_segment()
 	segments_.emplace_back(DecodeSegment());
 
 	// Add annotation classes
-	for (const shared_ptr<decode::Decoder> &dec : stack_) {
+	for (const shared_ptr<decode::Decoder>& dec : stack_) {
 		assert(dec);
 		const srd_decoder *const decc = dec->decoder();
 		assert(dec->decoder());
@@ -1236,6 +1386,15 @@ void DecodeSignal::create_decode_segment()
 				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)
@@ -1251,19 +1410,19 @@ 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())
@@ -1284,6 +1443,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