DecodeSignal: Re-set decoder metadata after stack termination

[pulseview.git] / pv / data / decodesignal.cpp

diff --git a/pv/data/decodesignal.cpp b/pv/data/decodesignal.cpp
index 03ecc2efcc3a0bbb7fd42b90133514969952f7b3..d17c883c4b380eaac155ae1d04c88d7cfa16330b 100644 (file)
--- a/pv/data/decodesignal.cpp
+++ b/pv/data/decodesignal.cpp
@@ -36,6 +36,7 @@ using std::lock_guard;
 using std::make_pair;
 using std::make_shared;
 using std::min;
 using std::make_pair;
 using std::make_shared;
 using std::min;

+using std::out_of_range;

 using std::shared_ptr;
 using std::unique_lock;
 using pv::data::decode::Annotation;
 using std::shared_ptr;
 using std::unique_lock;
 using pv::data::decode::Annotation;


@@ -55,10 +56,8 @@ DecodeSignal::DecodeSignal(pv::Session &session) :
        session_(session),
        srd_session_(nullptr),
        logic_mux_data_invalid_(false),
        session_(session),
        srd_session_(nullptr),
        logic_mux_data_invalid_(false),

-       start_time_(0),
-       samplerate_(0),
-       samples_decoded_(0),
-       frame_complete_(false)
+       stack_config_changed_(true),
+       current_segment_id_(0)

 {
        connect(&session_, SIGNAL(capture_state_changed(int)),
                this, SLOT(on_capture_state_changed(int)));
 {
        connect(&session_, SIGNAL(capture_state_changed(int)),
                this, SLOT(on_capture_state_changed(int)));


@@ -66,7 +65,7 @@ DecodeSignal::DecodeSignal(pv::Session &session) :
 
 DecodeSignal::~DecodeSignal()
 {
 
 DecodeSignal::~DecodeSignal()
 {

-       reset_decode();
+       reset_decode(true);

 }
 
 const vector< shared_ptr<Decoder> >& DecodeSignal::decoder_stack() const
 }
 
 const vector< shared_ptr<Decoder> >& DecodeSignal::decoder_stack() const


@@ -88,6 +87,7 @@ void DecodeSignal::stack_decoder(const srd_decoder *decoder)
        // Include the newly created decode channels in the channel lists
        update_channel_list();
 
        // 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();
        auto_assign_signals(dec);
        commit_decoder_channels();
        begin_decode();


@@ -107,6 +107,7 @@ void DecodeSignal::remove_decoder(int index)
        stack_.erase(iter);
 
        // Update channels and decoded data
        stack_.erase(iter);
 
        // Update channels and decoded data

+       stack_config_changed_ = true;

        update_channel_list();
        begin_decode();
 }
        update_channel_list();
        begin_decode();
 }


@@ -129,8 +130,13 @@ bool DecodeSignal::toggle_decoder_visibility(int index)
        return state;
 }
 
        return state;
 }
 

-void DecodeSignal::reset_decode()
+void DecodeSignal::reset_decode(bool shutting_down)

 {
 {

+       if (stack_config_changed_ || shutting_down)
+               stop_srd_session();
+       else
+               terminate_srd_session();
+

        if (decode_thread_.joinable()) {
                decode_interrupt_ = true;
                decode_input_cond_.notify_one();
        if (decode_thread_.joinable()) {
                decode_interrupt_ = true;
                decode_input_cond_.notify_one();


@@ -143,18 +149,20 @@ void DecodeSignal::reset_decode()
                logic_mux_thread_.join();
        }
 
                logic_mux_thread_.join();
        }
 

-       stop_srd_session();
-
-       frame_complete_ = false;
-       samples_decoded_ = 0;
-       error_message_ = QString();
-
-       rows_.clear();
-       current_rows_= nullptr;

        class_rows_.clear();
        class_rows_.clear();

+       current_segment_id_ = 0;
+       segments_.clear();

 
        logic_mux_data_.reset();
        logic_mux_data_invalid_ = true;
 
        logic_mux_data_.reset();
        logic_mux_data_invalid_ = true;

+
+       if (!error_message_.isEmpty()) {
+               error_message_ = QString();
+               // TODO Emulate noquote()
+               qDebug().nospace() << name() << ": Error cleared";
+       }
+
+       decode_reset();

 }
 
 void DecodeSignal::begin_decode()
 }
 
 void DecodeSignal::begin_decode()


@@ -174,14 +182,14 @@ void DecodeSignal::begin_decode()
        reset_decode();
 
        if (stack_.size() == 0) {
        reset_decode();
 
        if (stack_.size() == 0) {

-               error_message_ = tr("No decoders");
+               set_error_message(tr("No decoders"));

                return;
        }
 
        assert(channels_.size() > 0);
 
        if (get_assigned_signal_count() == 0) {
                return;
        }
 
        assert(channels_.size() > 0);
 
        if (get_assigned_signal_count() == 0) {

-               error_message_ = tr("There are no channels assigned to this decoder");
+               set_error_message(tr("There are no channels assigned to this decoder"));

                return;
        }
 
                return;
        }
 


@@ -195,8 +203,8 @@ void DecodeSignal::begin_decode()
        // Check that all decoders have the required channels
        for (const shared_ptr<decode::Decoder> &dec : stack_)
                if (!dec->have_required_channels()) {
        // Check that all decoders have the required channels
        for (const shared_ptr<decode::Decoder> &dec : stack_)
                if (!dec->have_required_channels()) {

-                       error_message_ = tr("One or more required channels "
-                               "have not been specified");
+                       set_error_message(tr("One or more required channels "
+                               "have not been specified"));

                        return;
                }
 
                        return;
                }
 


@@ -220,18 +228,22 @@ void DecodeSignal::begin_decode()
                }
        }
 
                }
        }
 

-       prepare_annotation_segment();
-

        // Free the logic data and its segment(s) if it needs to be updated
        if (logic_mux_data_invalid_)
                logic_mux_data_.reset();
 
        if (!logic_mux_data_) {
        // Free the logic data and its segment(s) if it needs to be updated
        if (logic_mux_data_invalid_)
                logic_mux_data_.reset();
 
        if (!logic_mux_data_) {

-               const int64_t ch_count = get_assigned_signal_count();
-               const int64_t unit_size = (ch_count + 7) / 8;
+               const uint32_t ch_count = get_assigned_signal_count();
+               logic_mux_unit_size_ = (ch_count + 7) / 8;

                logic_mux_data_ = make_shared<Logic>(ch_count);
                logic_mux_data_ = make_shared<Logic>(ch_count);

-               logic_mux_segment_ = make_shared<LogicSegment>(*logic_mux_data_, unit_size, samplerate_);
-               logic_mux_data_->push_segment(logic_mux_segment_);
+       }
+
+       // Receive notifications when new sample data is available
+       connect_input_notifiers();
+
+       if (get_input_segment_count() == 0) {
+               set_error_message(tr("No input data"));
+               return;

        }
 
        // Make sure the logic output data is complete and up-to-date
        }
 
        // Make sure the logic output data is complete and up-to-date


@@ -241,9 +253,6 @@ void DecodeSignal::begin_decode()
        // Decode the muxed logic data
        decode_interrupt_ = false;
        decode_thread_ = std::thread(&DecodeSignal::decode_proc, this);
        // Decode the muxed logic data
        decode_interrupt_ = false;
        decode_thread_ = std::thread(&DecodeSignal::decode_proc, this);

-
-       // Receive notifications when new sample data is available
-       connect_input_notifiers();

 }
 
 QString DecodeSignal::error_message() const
 }
 
 QString DecodeSignal::error_message() const


@@ -284,6 +293,7 @@ void DecodeSignal::auto_assign_signals(const shared_ptr<Decoder> dec)
 
        if (new_assignment) {
                logic_mux_data_invalid_ = true;
 
        if (new_assignment) {
                logic_mux_data_invalid_ = true;

+               stack_config_changed_ = true;

                commit_decoder_channels();
                channels_updated();
        }
                commit_decoder_channels();
                channels_updated();
        }


@@ -297,6 +307,7 @@ void DecodeSignal::assign_signal(const uint16_t channel_id, const SignalBase *si
                        logic_mux_data_invalid_ = true;
                }
 
                        logic_mux_data_invalid_ = true;
                }
 

+       stack_config_changed_ = true;

        commit_decoder_channels();
        channels_updated();
        begin_decode();
        commit_decoder_channels();
        channels_updated();
        begin_decode();


@@ -315,29 +326,38 @@ void DecodeSignal::set_initial_pin_state(const uint16_t channel_id, const int in
                if (ch.id == channel_id)
                        ch.initial_pin_state = init_state;
 
                if (ch.id == channel_id)
                        ch.initial_pin_state = init_state;
 

+       stack_config_changed_ = true;

        channels_updated();
        channels_updated();

-

        begin_decode();
 }
 
 double DecodeSignal::samplerate() const
 {
        begin_decode();
 }
 
 double DecodeSignal::samplerate() const
 {

-       return samplerate_;
+       double result = 0;
+
+       // TODO For now, we simply return the first samplerate that we have
+       if (segments_.size() > 0)
+               result = segments_.front().samplerate;
+
+       return result;

 }
 
 }
 

-const pv::util::Timestamp& DecodeSignal::start_time() const
+const pv::util::Timestamp DecodeSignal::start_time() const

 {
 {

-       return start_time_;
+       pv::util::Timestamp result;
+
+       // TODO For now, we simply return the first start time that we have
+       if (segments_.size() > 0)
+               result = segments_.front().start_time;
+
+       return result;

 }
 
 }
 

-int64_t DecodeSignal::get_working_sample_count() const
+int64_t DecodeSignal::get_working_sample_count(uint32_t segment_id) const

 {
        // The working sample count is the highest sample number for
 {
        // The working sample count is the highest sample number for

-       // which all used signals have data available, so go through
-       // all channels and use the lowest overall sample count of the
-       // current segment
-
-       // TODO Currently, we assume only a single segment exists
+       // which all used signals have data available, so go through all
+       // channels and use the lowest overall sample count of the segment

 
        int64_t count = std::numeric_limits<int64_t>::max();
        bool no_signals_assigned = true;
 
        int64_t count = std::numeric_limits<int64_t>::max();
        bool no_signals_assigned = true;


@@ -350,17 +370,31 @@ int64_t DecodeSignal::get_working_sample_count() const
                        if (!logic_data || logic_data->logic_segments().empty())
                                return 0;
 
                        if (!logic_data || logic_data->logic_segments().empty())
                                return 0;
 

-                       const shared_ptr<LogicSegment> segment = logic_data->logic_segments().front();
-                       count = min(count, (int64_t)segment->get_sample_count());
+                       try {
+                               const shared_ptr<LogicSegment> segment = logic_data->logic_segments().at(segment_id);
+                               count = min(count, (int64_t)segment->get_sample_count());
+                       } catch (out_of_range&) {
+                               return 0;
+                       }

                }
 
        return (no_signals_assigned ? 0 : count);
 }
 
                }
 
        return (no_signals_assigned ? 0 : count);
 }
 

-int64_t DecodeSignal::get_decoded_sample_count() const
+int64_t DecodeSignal::get_decoded_sample_count(uint32_t segment_id) const

 {
        lock_guard<mutex> decode_lock(output_mutex_);
 {
        lock_guard<mutex> decode_lock(output_mutex_);

-       return samples_decoded_;
+
+       int64_t result = 0;
+
+       try {
+               const DecodeSegment *segment = &(segments_.at(segment_id));
+               result = segment->samples_decoded;
+       } catch (out_of_range&) {
+               // Do nothing
+       }
+
+       return result;

 }
 
 vector<Row> DecodeSignal::visible_rows() const
 }
 
 vector<Row> DecodeSignal::visible_rows() const


@@ -395,20 +429,23 @@ vector<Row> DecodeSignal::visible_rows() const
 
 void DecodeSignal::get_annotation_subset(
        vector<pv::data::decode::Annotation> &dest,
 
 void DecodeSignal::get_annotation_subset(
        vector<pv::data::decode::Annotation> &dest,

-       const decode::Row &row, uint64_t start_sample,
+       const decode::Row &row, uint32_t segment_id, uint64_t start_sample,

        uint64_t end_sample) const
 {
        lock_guard<mutex> lock(output_mutex_);
 
        uint64_t end_sample) const
 {
        lock_guard<mutex> lock(output_mutex_);
 

-       if (!current_rows_)
-               return;
-
-       // TODO Instead of current_rows_, use rows_ and the ID of the segment
-
-       const auto iter = current_rows_->find(row);
-       if (iter != current_rows_->end())
-               (*iter).second.get_annotation_subset(dest,
-                       start_sample, end_sample);
+       try {
+               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);
+       } catch (out_of_range&) {
+               // Do nothing
+       }

 }
 
 void DecodeSignal::save_settings(QSettings &settings) const
 }
 
 void DecodeSignal::save_settings(QSettings &settings) const


@@ -505,7 +542,6 @@ void DecodeSignal::restore_settings(QSettings &settings)
 
                                // Include the newly created decode channels in the channel lists
                                update_channel_list();
 
                                // Include the newly created decode channels in the channel lists
                                update_channel_list();

-                               commit_decoder_channels();

                                break;
                        }
                }
                                break;
                        }
                }


@@ -542,9 +578,64 @@ void DecodeSignal::restore_settings(QSettings &settings)
                settings.endGroup();
        }
 
                settings.endGroup();
        }
 

+       // Update the internal structures
+       stack_config_changed_ = true;
+       update_channel_list();
+       commit_decoder_channels();
+

        begin_decode();
 }
 
        begin_decode();
 }
 

+void DecodeSignal::set_error_message(QString msg)
+{
+       error_message_ = msg;
+       // TODO Emulate noquote()
+       qDebug().nospace() << name() << ": " << msg;
+}
+
+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_)
+               if (ch.assigned_signal) {
+                       no_signals_assigned = false;
+
+                       const shared_ptr<Logic> logic_data = ch.assigned_signal->logic_data();
+                       if (!logic_data || logic_data->logic_segments().empty())
+                               return 0;
+
+                       // Find the min value of all segment counts
+                       if ((uint64_t)(logic_data->logic_segments().size()) < count)
+                               count = logic_data->logic_segments().size();
+               }
+
+       return (no_signals_assigned ? 0 : count);
+}
+
+uint32_t DecodeSignal::get_input_samplerate(uint32_t segment_id) const
+{
+       double samplerate = 0;
+
+       for (const data::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())
+                               continue;
+
+                       try {
+                               const shared_ptr<LogicSegment> segment = logic_data->logic_segments().at(segment_id);
+                               samplerate = segment->samplerate();
+                       } catch (out_of_range&) {
+                               // Do nothing
+                       }
+                       break;
+               }
+
+       return samplerate;
+}
+

 void DecodeSignal::update_channel_list()
 {
        vector<data::DecodeChannel> prev_channels = channels_;
 void DecodeSignal::update_channel_list()
 {
        vector<data::DecodeChannel> prev_channels = channels_;


@@ -638,28 +729,38 @@ void DecodeSignal::commit_decoder_channels()
 
                dec->set_channels(channel_list);
        }
 
                dec->set_channels(channel_list);
        }

+
+       // Channel bit IDs must be in sync with the channel's apperance in channels_
+       int id = 0;
+       for (data::DecodeChannel &ch : channels_)
+               if (ch.assigned_signal)
+                       ch.bit_id = id++;

 }
 
 }
 

-void DecodeSignal::mux_logic_samples(const int64_t start, const int64_t end)
+void DecodeSignal::mux_logic_samples(uint32_t segment_id, const int64_t start, const int64_t end)

 {
        // Enforce end to be greater than start
        if (end <= start)
                return;
 
 {
        // Enforce end to be greater than start
        if (end <= start)
                return;
 

-       // Fetch all segments and their data
-       // TODO Currently, we assume only a single segment exists
+       // Fetch the channel segments and their data

        vector<shared_ptr<LogicSegment> > segments;
        vector<const uint8_t*> signal_data;
        vector<uint8_t> signal_in_bytepos;
        vector<uint8_t> signal_in_bitpos;
 
        vector<shared_ptr<LogicSegment> > segments;
        vector<const uint8_t*> signal_data;
        vector<uint8_t> signal_in_bytepos;
        vector<uint8_t> signal_in_bitpos;
 

-       int id = 0;

        for (data::DecodeChannel &ch : channels_)
                if (ch.assigned_signal) {
        for (data::DecodeChannel &ch : channels_)
                if (ch.assigned_signal) {

-                       ch.bit_id = id++;
-

                        const shared_ptr<Logic> logic_data = ch.assigned_signal->logic_data();
                        const shared_ptr<Logic> logic_data = ch.assigned_signal->logic_data();

-                       const shared_ptr<LogicSegment> segment = logic_data->logic_segments().front();
+
+                       shared_ptr<LogicSegment> segment;
+                       try {
+                               segment = logic_data->logic_segments().at(segment_id);
+                       } catch (out_of_range&) {
+                               qDebug() << "Muxer error for" << name() << ":" << ch.assigned_signal->name() \
+                                       << "has no logic segment" << segment_id;
+                               return;
+                       }

                        segments.push_back(segment);
 
                        uint8_t* data = new uint8_t[(end - start) * segment->unit_size()];
                        segments.push_back(segment);
 
                        uint8_t* data = new uint8_t[(end - start) * segment->unit_size()];


@@ -671,16 +772,29 @@ void DecodeSignal::mux_logic_samples(const int64_t start, const int64_t end)
                        signal_in_bitpos.push_back(bitpos % 8);
                }
 
                        signal_in_bitpos.push_back(bitpos % 8);
                }
 

+
+       shared_ptr<LogicSegment> output_segment;
+       try {
+               output_segment = logic_mux_data_->logic_segments().at(segment_id);
+       } catch (out_of_range&) {
+               qDebug() << "Muxer error for" << name() << ": no logic mux segment" \
+                       << segment_id << "in mux_logic_samples(), mux segments size is" \
+                       << logic_mux_data_->logic_segments().size();
+               return;
+       }
+

        // Perform the muxing of signal data into the output data
        // Perform the muxing of signal data into the output data

-       uint8_t* output = new uint8_t[(end - start) * logic_mux_segment_->unit_size()];
+       uint8_t* output = new uint8_t[(end - start) * output_segment->unit_size()];

        unsigned int signal_count = signal_data.size();
 
        unsigned int signal_count = signal_data.size();
 

-       for (int64_t sample_cnt = 0; sample_cnt < (end - start); sample_cnt++) {
+       for (int64_t sample_cnt = 0; !logic_mux_interrupt_ && (sample_cnt < (end - start));
+               sample_cnt++) {
+

                int bitpos = 0;
                uint8_t bytepos = 0;
 
                int bitpos = 0;
                uint8_t bytepos = 0;
 

-               const int out_sample_pos = sample_cnt * logic_mux_segment_->unit_size();
-               for (unsigned int i = 0; i < logic_mux_segment_->unit_size(); i++)
+               const int out_sample_pos = sample_cnt * output_segment->unit_size();
+               for (unsigned int i = 0; i < output_segment->unit_size(); i++)

                        output[out_sample_pos + i] = 0;
 
                for (unsigned int i = 0; i < signal_count; i++) {
                        output[out_sample_pos + i] = 0;
 
                for (unsigned int i = 0; i < signal_count; i++) {


@@ -700,7 +814,7 @@ void DecodeSignal::mux_logic_samples(const int64_t start, const int64_t end)
                }
        }
 
                }
        }
 

-       logic_mux_segment_->append_payload(output, (end - start) * logic_mux_segment_->unit_size());
+       output_segment->append_payload(output, (end - start) * output_segment->unit_size());

        delete[] output;
 
        for (const uint8_t* data : signal_data)
        delete[] output;
 
        for (const uint8_t* data : signal_data)


@@ -709,9 +823,21 @@ void DecodeSignal::mux_logic_samples(const int64_t start, const int64_t end)
 
 void DecodeSignal::logic_mux_proc()
 {
 
 void DecodeSignal::logic_mux_proc()
 {

+       uint32_t segment_id = 0;
+
+       assert(logic_mux_data_);
+
+       // Create initial logic mux segment
+       shared_ptr<LogicSegment> output_segment =
+               make_shared<LogicSegment>(*logic_mux_data_, segment_id,
+                       logic_mux_unit_size_, 0);
+       logic_mux_data_->push_segment(output_segment);
+
+       output_segment->set_samplerate(get_input_samplerate(0));
+

        do {
        do {

-               const uint64_t input_sample_count = get_working_sample_count();
-               const uint64_t output_sample_count = logic_mux_segment_->get_sample_count();
+               const uint64_t input_sample_count = get_working_sample_count(segment_id);
+               const uint64_t output_sample_count = output_segment->get_sample_count();

 
                const uint64_t samples_to_process =
                        (input_sample_count > output_sample_count) ?
 
                const uint64_t samples_to_process =
                        (input_sample_count > output_sample_count) ?


@@ -719,7 +845,7 @@ void DecodeSignal::logic_mux_proc()
 
                // Process the samples if necessary...
                if (samples_to_process > 0) {
 
                // Process the samples if necessary...
                if (samples_to_process > 0) {

-                       const uint64_t unit_size = logic_mux_segment_->unit_size();
+                       const uint64_t unit_size = output_segment->unit_size();

                        const uint64_t chunk_sample_count = DecodeChunkLength / unit_size;
 
                        uint64_t processed_samples = 0;
                        const uint64_t chunk_sample_count = DecodeChunkLength / unit_size;
 
                        uint64_t processed_samples = 0;


@@ -728,76 +854,45 @@ void DecodeSignal::logic_mux_proc()
                                const uint64_t sample_count =
                                        min(samples_to_process - processed_samples,     chunk_sample_count);
 
                                const uint64_t sample_count =
                                        min(samples_to_process - processed_samples,     chunk_sample_count);
 

-                               mux_logic_samples(start_sample, start_sample + sample_count);
+                               mux_logic_samples(segment_id, start_sample, start_sample + sample_count);

                                processed_samples += sample_count;
 
                                // ...and process the newly muxed logic data
                                decode_input_cond_.notify_one();
                                processed_samples += sample_count;
 
                                // ...and process the newly muxed logic data
                                decode_input_cond_.notify_one();

-                       } while (processed_samples < samples_to_process);
+                       } while (!logic_mux_interrupt_ && (processed_samples < samples_to_process));

                }
 
                if (samples_to_process == 0) {
                }
 
                if (samples_to_process == 0) {

-                       // Wait for more input
-                       unique_lock<mutex> logic_mux_lock(logic_mux_mutex_);
-                       logic_mux_cond_.wait(logic_mux_lock);
+                       // TODO Optimize this by caching the input segment count and only
+                       // querying it when the cached value was reached
+                       if (segment_id < get_input_segment_count() - 1) {
+                               // Process next segment
+                               segment_id++;
+
+                               output_segment =
+                                       make_shared<LogicSegment>(*logic_mux_data_, segment_id,
+                                               logic_mux_unit_size_, 0);
+                               logic_mux_data_->push_segment(output_segment);
+
+                               output_segment->set_samplerate(get_input_samplerate(segment_id));
+
+                       } else {
+                               // All segments have been processed
+                               logic_mux_data_invalid_ = false;
+
+                               // Wait for more input
+                               unique_lock<mutex> logic_mux_lock(logic_mux_mutex_);
+                               logic_mux_cond_.wait(logic_mux_lock);
+                       }

                }
        } while (!logic_mux_interrupt_);
                }
        } while (!logic_mux_interrupt_);

-
-       // No more input data and session is stopped, let the decode thread
-       // process any pending data, terminate and release the global SRD mutex
-       // in order to let other decoders run
-       decode_input_cond_.notify_one();
-}
-
-void DecodeSignal::query_input_metadata()
-{
-       // Update the samplerate and start time because we cannot start
-       // the libsrd session without the current samplerate
-
-       // TODO Currently we assume all channels have the same sample rate
-       // and start time
-       bool samplerate_valid = false;
-       data::DecodeChannel *any_channel;
-       shared_ptr<Logic> logic_data;
-
-       do {
-               any_channel = &(*find_if(channels_.begin(), channels_.end(),
-                       [](data::DecodeChannel ch) { return ch.assigned_signal; }));
-
-               logic_data = any_channel->assigned_signal->logic_data();
-
-               if (!logic_data) {
-                       // Wait until input data is available or an interrupt was requested
-                       unique_lock<mutex> input_wait_lock(input_mutex_);
-                       decode_input_cond_.wait(input_wait_lock);
-               }
-       } while (!logic_data && !decode_interrupt_);
-
-       if (decode_interrupt_)
-               return;
-
-       do {
-               if (!logic_data->logic_segments().empty()) {
-                       shared_ptr<LogicSegment> first_segment =
-                               any_channel->assigned_signal->logic_data()->logic_segments().front();
-                       start_time_ = first_segment->start_time();
-                       samplerate_ = first_segment->samplerate();
-                       if (samplerate_ > 0)
-                               samplerate_valid = true;
-               }
-
-               if (!samplerate_valid) {
-                       // Wait until input data is available or an interrupt was requested
-                       unique_lock<mutex> input_wait_lock(input_mutex_);
-                       decode_input_cond_.wait(input_wait_lock);
-               }
-       } while (!samplerate_valid && !decode_interrupt_);

 }
 
 void DecodeSignal::decode_data(
 }
 
 void DecodeSignal::decode_data(

-       const int64_t abs_start_samplenum, const int64_t sample_count)
+       const int64_t abs_start_samplenum, const int64_t sample_count,
+       const shared_ptr<LogicSegment> input_segment)

 {
 {

-       const int64_t unit_size = logic_mux_segment_->unit_size();
+       const int64_t unit_size = input_segment->unit_size();

        const int64_t chunk_sample_count = DecodeChunkLength / unit_size;
 
        for (int64_t i = abs_start_samplenum;
        const int64_t chunk_sample_count = DecodeChunkLength / unit_size;
 
        for (int64_t i = abs_start_samplenum;


@@ -807,24 +902,26 @@ void DecodeSignal::decode_data(
                const int64_t chunk_end = min(i + chunk_sample_count,
                        abs_start_samplenum + sample_count);
 
                const int64_t chunk_end = min(i + chunk_sample_count,
                        abs_start_samplenum + sample_count);
 

+               // Report this chunk as already decoded so that annotations don't
+               // appear in an area that we claim to not having been been decoded yet
+               {
+                       lock_guard<mutex> lock(output_mutex_);
+                       segments_.at(current_segment_id_).samples_decoded = chunk_end;
+               }
+

                int64_t data_size = (chunk_end - i) * unit_size;
                uint8_t* chunk = new uint8_t[data_size];
                int64_t data_size = (chunk_end - i) * unit_size;
                uint8_t* chunk = new uint8_t[data_size];

-               logic_mux_segment_->get_samples(i, chunk_end, chunk);
+               input_segment->get_samples(i, chunk_end, chunk);

 
                if (srd_session_send(srd_session_, i, chunk_end, chunk,
                                data_size, unit_size) != SRD_OK) {
 
                if (srd_session_send(srd_session_, i, chunk_end, chunk,
                                data_size, unit_size) != SRD_OK) {

-                       error_message_ = tr("Decoder reported an error");
+                       set_error_message(tr("Decoder reported an error"));

                        delete[] chunk;
                        break;
                }
 
                delete[] chunk;
 
                        delete[] chunk;
                        break;
                }
 
                delete[] chunk;
 

-               {
-                       lock_guard<mutex> lock(output_mutex_);
-                       samples_decoded_ = chunk_end;
-               }
-

                // Notify the frontend that we processed some data and
                // possibly have new annotations as well
                new_annotations();
                // Notify the frontend that we processed some data and
                // possibly have new annotations as well
                new_annotations();


@@ -833,42 +930,104 @@ void DecodeSignal::decode_data(
 
 void DecodeSignal::decode_proc()
 {
 
 void DecodeSignal::decode_proc()
 {

-       query_input_metadata();
+       current_segment_id_ = 0;
+
+       // If there is no input data available yet, wait until it is or we're interrupted
+       if (logic_mux_data_->logic_segments().size() == 0) {
+               unique_lock<mutex> input_wait_lock(input_mutex_);
+               decode_input_cond_.wait(input_wait_lock);
+       }

 
        if (decode_interrupt_)
                return;
 
 
        if (decode_interrupt_)
                return;
 

+       shared_ptr<LogicSegment> input_segment = logic_mux_data_->logic_segments().front();
+       assert(input_segment);
+
+       // Create the initial segment and set its sample rate so that we can pass it to SRD
+       create_decode_segment();
+       segments_.at(current_segment_id_).samplerate = input_segment->samplerate();
+       segments_.at(current_segment_id_).start_time = input_segment->start_time();
+

        start_srd_session();
 
        start_srd_session();
 

-       uint64_t sample_count;
+       uint64_t sample_count = 0;

        uint64_t abs_start_samplenum = 0;
        do {
                // Keep processing new samples until we exhaust the input data
                do {
                        lock_guard<mutex> input_lock(input_mutex_);
        uint64_t abs_start_samplenum = 0;
        do {
                // Keep processing new samples until we exhaust the input data
                do {
                        lock_guard<mutex> input_lock(input_mutex_);

-                       sample_count = logic_mux_segment_->get_sample_count() - abs_start_samplenum;
+                       sample_count = input_segment->get_sample_count() - abs_start_samplenum;

 
                        if (sample_count > 0) {
 
                        if (sample_count > 0) {

-                               decode_data(abs_start_samplenum, sample_count);
+                               decode_data(abs_start_samplenum, sample_count, input_segment);

                                abs_start_samplenum += sample_count;
                        }
                } while (error_message_.isEmpty() && (sample_count > 0) && !decode_interrupt_);
 
                                abs_start_samplenum += sample_count;
                        }
                } while (error_message_.isEmpty() && (sample_count > 0) && !decode_interrupt_);
 

-               if (error_message_.isEmpty() && !decode_interrupt_) {
-                       if (sample_count == 0)
+               if (error_message_.isEmpty() && !decode_interrupt_ && sample_count == 0) {
+                       if (current_segment_id_ < logic_mux_data_->logic_segments().size() - 1) {
+                               // Process next segment
+                               current_segment_id_++;
+
+                               try {
+                                       input_segment = logic_mux_data_->logic_segments().at(current_segment_id_);
+                               } catch (out_of_range&) {
+                                       qDebug() << "Decode error for" << name() << ": no logic mux segment" \
+                                               << current_segment_id_ << "in decode_proc(), mux segments size is" \
+                                               << logic_mux_data_->logic_segments().size();
+                                       return;
+                               }
+                               abs_start_samplenum = 0;
+
+                               // Create the next segment and set its metadata
+                               create_decode_segment();
+                               segments_.at(current_segment_id_).samplerate = input_segment->samplerate();
+                               segments_.at(current_segment_id_).start_time = input_segment->start_time();
+
+                               // Reset decoder state but keep the decoder stack intact
+                               terminate_srd_session();
+                       } else {
+                               // All segments have been processed

                                decode_finished();
 
                                decode_finished();
 

-                       // Wait for new input data or an interrupt was requested
-                       unique_lock<mutex> input_wait_lock(input_mutex_);
-                       decode_input_cond_.wait(input_wait_lock);
+                               // Wait for new input data or an interrupt was requested
+                               unique_lock<mutex> input_wait_lock(input_mutex_);
+                               decode_input_cond_.wait(input_wait_lock);
+                       }

                }
        } while (error_message_.isEmpty() && !decode_interrupt_);
                }
        } while (error_message_.isEmpty() && !decode_interrupt_);

+
+       // Potentially reap decoders when the application no longer is
+       // interested in their (pending) results.
+       if (decode_interrupt_)
+               terminate_srd_session();

 }
 
 void DecodeSignal::start_srd_session()
 {
 }
 
 void DecodeSignal::start_srd_session()
 {

-       if (srd_session_)
-               stop_srd_session();
+       // If there were stack changes, the session has been destroyed by now, so if
+       // it hasn't been destroyed, we can just reset and re-use it
+       if (srd_session_) {
+               // When a decoder stack was created before, re-use it
+               // for the next stream of input data, after terminating
+               // potentially still executing operations, and resetting
+               // internal state. Skip the rather expensive (teardown
+               // and) construction of another decoder stack.
+
+               // TODO Reduce redundancy, use a common code path for
+               // the meta/start sequence?
+               terminate_srd_session();
+
+               // Metadata is cleared also, so re-set it
+               srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
+                       g_variant_new_uint64(segments_.at(current_segment_id_).samplerate));
+               for (const shared_ptr<decode::Decoder> &dec : stack_)
+                       dec->apply_all_options();
+               srd_session_start(srd_session_);
+
+               return;
+       }

 
        // Create the session
        srd_session_new(&srd_session_);
 
        // Create the session
        srd_session_new(&srd_session_);


@@ -880,8 +1039,9 @@ void DecodeSignal::start_srd_session()
                srd_decoder_inst *const di = dec->create_decoder_inst(srd_session_);
 
                if (!di) {
                srd_decoder_inst *const di = dec->create_decoder_inst(srd_session_);
 
                if (!di) {

-                       error_message_ = tr("Failed to create decoder instance");
+                       set_error_message(tr("Failed to create decoder instance"));

                        srd_session_destroy(srd_session_);
                        srd_session_destroy(srd_session_);

+                       srd_session_ = nullptr;

                        return;
                }
 
                        return;
                }
 


@@ -893,12 +1053,33 @@ void DecodeSignal::start_srd_session()
 
        // Start the session
        srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
 
        // Start the session
        srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,

-               g_variant_new_uint64(samplerate_));
+               g_variant_new_uint64(segments_.at(current_segment_id_).samplerate));

 
        srd_pd_output_callback_add(srd_session_, SRD_OUTPUT_ANN,
                DecodeSignal::annotation_callback, this);
 
        srd_session_start(srd_session_);
 
        srd_pd_output_callback_add(srd_session_, SRD_OUTPUT_ANN,
                DecodeSignal::annotation_callback, this);
 
        srd_session_start(srd_session_);

+
+       // We just recreated the srd session, so all stack changes are applied now
+       stack_config_changed_ = false;
+}
+
+void DecodeSignal::terminate_srd_session()
+{
+       // Call the "terminate and reset" routine for the decoder stack
+       // (if available). This does not harm those stacks which already
+       // have completed their operation, and reduces response time for
+       // those stacks which still are processing data while the
+       // application no longer wants them to.
+       if (srd_session_) {
+               srd_session_terminate_reset(srd_session_);
+
+               // Metadata is cleared also, so re-set it
+               srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
+                       g_variant_new_uint64(segments_.at(current_segment_id_).samplerate));
+               for (const shared_ptr<decode::Decoder> &dec : stack_)
+                       dec->apply_all_options();
+       }

 }
 
 void DecodeSignal::stop_srd_session()
 }
 
 void DecodeSignal::stop_srd_session()


@@ -907,6 +1088,10 @@ void DecodeSignal::stop_srd_session()
                // Destroy the session
                srd_session_destroy(srd_session_);
                srd_session_ = nullptr;
                // Destroy the session
                srd_session_destroy(srd_session_);
                srd_session_ = nullptr;

+
+               // Mark the decoder instances as non-existant since they were deleted
+               for (const shared_ptr<decode::Decoder> &dec : stack_)
+                       dec->invalidate_decoder_inst();

        }
 }
 
        }
 }
 


@@ -924,16 +1109,15 @@ void DecodeSignal::connect_input_notifiers()
                const data::SignalBase *signal = ch.assigned_signal;
                connect(signal, SIGNAL(samples_cleared()),
                        this, SLOT(on_data_cleared()));
                const data::SignalBase *signal = ch.assigned_signal;
                connect(signal, SIGNAL(samples_cleared()),
                        this, SLOT(on_data_cleared()));

-               connect(signal, SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
+               connect(signal, SIGNAL(samples_added(uint64_t, uint64_t, uint64_t)),

                        this, SLOT(on_data_received()));
        }
 }
 
                        this, SLOT(on_data_received()));
        }
 }
 

-void DecodeSignal::prepare_annotation_segment()
+void DecodeSignal::create_decode_segment()

 {
 {

-       // TODO Won't work for multiple segments
-       rows_.emplace_back(map<const decode::Row, decode::RowData>());
-       current_rows_ = &(rows_.back());
+       // Create annotation segment
+       segments_.emplace_back(DecodeSegment());

 
        // Add annotation classes
        for (const shared_ptr<decode::Decoder> &dec : stack_) {
 
        // Add annotation classes
        for (const shared_ptr<decode::Decoder> &dec : stack_) {


@@ -943,7 +1127,8 @@ void DecodeSignal::prepare_annotation_segment()
 
                // Add a row for the decoder if it doesn't have a row list
                if (!decc->annotation_rows)
 
                // Add a row for the decoder if it doesn't have a row list
                if (!decc->annotation_rows)

-                       (*current_rows_)[Row(decc)] = decode::RowData();
+                       (segments_.back().annotation_rows)[Row(decc)] =
+                               decode::RowData();

 
                // Add the decoder rows
                for (const GSList *l = decc->annotation_rows; l; l = l->next) {
 
                // Add the decoder rows
                for (const GSList *l = decc->annotation_rows; l; l = l->next) {


@@ -954,7 +1139,8 @@ void DecodeSignal::prepare_annotation_segment()
                        const Row row(decc, ann_row);
 
                        // Add a new empty row data object
                        const Row row(decc, ann_row);
 
                        // Add a new empty row data object

-                       (*current_rows_)[row] = decode::RowData();
+                       (segments_.back().annotation_rows)[row] =
+                               decode::RowData();

                }
        }
 }
                }
        }
 }


@@ -967,6 +1153,9 @@ void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signa
        DecodeSignal *const ds = (DecodeSignal*)decode_signal;
        assert(ds);
 
        DecodeSignal *const ds = (DecodeSignal*)decode_signal;
        assert(ds);
 

+       if (ds->decode_interrupt_)
+               return;
+

        lock_guard<mutex> lock(ds->output_mutex_);
 
        // Find the row
        lock_guard<mutex> lock(ds->output_mutex_);
 
        // Find the row


@@ -974,25 +1163,24 @@ void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signa
        assert(pdata->pdo->di);
        const srd_decoder *const decc = pdata->pdo->di->decoder;
        assert(decc);
        assert(pdata->pdo->di);
        const srd_decoder *const decc = pdata->pdo->di->decoder;
        assert(decc);

-       assert(ds->current_rows_);

 
        const srd_proto_data_annotation *const pda =
                (const srd_proto_data_annotation*)pdata->data;
        assert(pda);
 
 
        const srd_proto_data_annotation *const pda =
                (const srd_proto_data_annotation*)pdata->data;
        assert(pda);
 

-       auto row_iter = ds->current_rows_->end();
+       auto row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.end();

 
        // Try 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())
 
        // Try 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->current_rows_->find((*r).second);
+               row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find((*r).second);

        else {
                // Failing that, use the decoder as a key
        else {
                // Failing that, use the decoder as a key

-               row_iter = ds->current_rows_->find(Row(decc));
+               row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find(Row(decc));

        }
 
        }
 

-       if (row_iter == ds->current_rows_->end()) {
+       if (row_iter == ds->segments_.at(ds->current_segment_id_).annotation_rows.end()) {

                qDebug() << "Unexpected annotation: decoder = " << decc <<
                        ", format = " << format;
                assert(false);
                qDebug() << "Unexpected annotation: decoder = " << decc <<
                        ", format = " << format;
                assert(false);


@@ -1006,8 +1194,10 @@ void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signa
 void DecodeSignal::on_capture_state_changed(int state)
 {
        // If a new acquisition was started, we need to start decoding from scratch
 void DecodeSignal::on_capture_state_changed(int state)
 {
        // If a new acquisition was started, we need to start decoding from scratch

-       if (state == Session::Running)
+       if (state == Session::Running) {
+               logic_mux_data_invalid_ = true;

                begin_decode();
                begin_decode();

+       }

 }
 
 void DecodeSignal::on_data_cleared()
 }
 
 void DecodeSignal::on_data_cleared()


@@ -1017,6 +1207,12 @@ void DecodeSignal::on_data_cleared()
 
 void DecodeSignal::on_data_received()
 {
 
 void DecodeSignal::on_data_received()
 {

+       // If we detected a lack of input data when trying to start decoding,
+       // we have set an error message. Only try again if we now have data
+       // to work with
+       if ((!error_message_.isEmpty()) && (get_input_segment_count() == 0))
+               return;
+

        if (!logic_mux_thread_.joinable())
                begin_decode();
        else
        if (!logic_mux_thread_.joinable())
                begin_decode();
        else