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 2a3ad14b56743b5d7adb5b152aa76cfd03320807..d17c883c4b380eaac155ae1d04c88d7cfa16330b 100644 (file)
--- a/pv/data/decodesignal.cpp
+++ b/pv/data/decodesignal.cpp
@@ -56,6 +56,7 @@ 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),

+       stack_config_changed_(true),

        current_segment_id_(0)
 {
        connect(&session_, SIGNAL(capture_state_changed(int)),
        current_segment_id_(0)
 {
        connect(&session_, SIGNAL(capture_state_changed(int)),


@@ -64,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


@@ -86,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();


@@ -105,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();
 }


@@ -127,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();


@@ -141,8 +149,6 @@ void DecodeSignal::reset_decode()
                logic_mux_thread_.join();
        }
 
                logic_mux_thread_.join();
        }
 

-       stop_srd_session();
-

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


@@ -150,7 +156,11 @@ void DecodeSignal::reset_decode()
        logic_mux_data_.reset();
        logic_mux_data_invalid_ = true;
 
        logic_mux_data_.reset();
        logic_mux_data_invalid_ = true;
 

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

 
        decode_reset();
 }
 
        decode_reset();
 }


@@ -172,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;
        }
 


@@ -193,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;
                }
 


@@ -232,7 +242,7 @@ void DecodeSignal::begin_decode()
        connect_input_notifiers();
 
        if (get_input_segment_count() == 0) {
        connect_input_notifiers();
 
        if (get_input_segment_count() == 0) {

-               error_message_ = tr("No input data");
+               set_error_message(tr("No input data"));

                return;
        }
 
                return;
        }
 


@@ -283,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();
        }


@@ -296,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();


@@ -314,8 +326,8 @@ 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();
 }
 
        begin_decode();
 }
 


@@ -361,7 +373,7 @@ int64_t DecodeSignal::get_working_sample_count(uint32_t segment_id) const
                        try {
                                const shared_ptr<LogicSegment> segment = logic_data->logic_segments().at(segment_id);
                                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) {
+                       } catch (out_of_range&) {

                                return 0;
                        }
                }
                                return 0;
                        }
                }


@@ -378,7 +390,7 @@ int64_t DecodeSignal::get_decoded_sample_count(uint32_t segment_id) const
        try {
                const DecodeSegment *segment = &(segments_.at(segment_id));
                result = segment->samples_decoded;
        try {
                const DecodeSegment *segment = &(segments_.at(segment_id));
                result = segment->samples_decoded;

-       } catch (out_of_range) {
+       } catch (out_of_range&) {

                // Do nothing
        }
 
                // Do nothing
        }
 


@@ -431,7 +443,7 @@ void DecodeSignal::get_annotation_subset(
                if (iter != rows->end())
                        (*iter).second.get_annotation_subset(dest,
                                start_sample, end_sample);
                if (iter != rows->end())
                        (*iter).second.get_annotation_subset(dest,
                                start_sample, end_sample);

-       } catch (out_of_range) {
+       } catch (out_of_range&) {

                // Do nothing
        }
 }
                // Do nothing
        }
 }


@@ -567,12 +579,20 @@ void DecodeSignal::restore_settings(QSettings &settings)
        }
 
        // Update the internal structures
        }
 
        // Update the internal structures

+       stack_config_changed_ = true;

        update_channel_list();
        commit_decoder_channels();
 
        begin_decode();
 }
 
        update_channel_list();
        commit_decoder_channels();
 
        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();
 uint32_t DecodeSignal::get_input_segment_count() const
 {
        uint64_t count = std::numeric_limits<uint64_t>::max();


@@ -607,7 +627,7 @@ uint32_t DecodeSignal::get_input_samplerate(uint32_t segment_id) const
                        try {
                                const shared_ptr<LogicSegment> segment = logic_data->logic_segments().at(segment_id);
                                samplerate = segment->samplerate();
                        try {
                                const shared_ptr<LogicSegment> segment = logic_data->logic_segments().at(segment_id);
                                samplerate = segment->samplerate();

-                       } catch (out_of_range) {
+                       } catch (out_of_range&) {

                                // Do nothing
                        }
                        break;
                                // Do nothing
                        }
                        break;


@@ -736,7 +756,7 @@ void DecodeSignal::mux_logic_samples(uint32_t segment_id, const int64_t start, c
                        shared_ptr<LogicSegment> segment;
                        try {
                                segment = logic_data->logic_segments().at(segment_id);
                        shared_ptr<LogicSegment> segment;
                        try {
                                segment = logic_data->logic_segments().at(segment_id);

-                       } catch (out_of_range) {
+                       } catch (out_of_range&) {

                                qDebug() << "Muxer error for" << name() << ":" << ch.assigned_signal->name() \
                                        << "has no logic segment" << segment_id;
                                return;
                                qDebug() << "Muxer error for" << name() << ":" << ch.assigned_signal->name() \
                                        << "has no logic segment" << segment_id;
                                return;


@@ -756,7 +776,7 @@ void DecodeSignal::mux_logic_samples(uint32_t segment_id, const int64_t start, c
        shared_ptr<LogicSegment> output_segment;
        try {
                output_segment = logic_mux_data_->logic_segments().at(segment_id);
        shared_ptr<LogicSegment> output_segment;
        try {
                output_segment = logic_mux_data_->logic_segments().at(segment_id);

-       } catch (out_of_range) {
+       } 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();
                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();


@@ -767,7 +787,9 @@ void DecodeSignal::mux_logic_samples(uint32_t segment_id, const int64_t start, c
        uint8_t* output = new uint8_t[(end - start) * output_segment->unit_size()];
        unsigned int signal_count = signal_data.size();
 
        uint8_t* output = new uint8_t[(end - start) * output_segment->unit_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;
 


@@ -837,7 +859,7 @@ void DecodeSignal::logic_mux_proc()
 
                                // ...and process the newly muxed logic data
                                decode_input_cond_.notify_one();
 
                                // ...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) {


@@ -880,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];
                input_segment->get_samples(i, chunk_end, chunk);
 
                if (srd_session_send(srd_session_, i, chunk_end, chunk,
                                data_size, unit_size) != SRD_OK) {
                int64_t data_size = (chunk_end - i) * unit_size;
                uint8_t* chunk = new uint8_t[data_size];
                input_segment->get_samples(i, chunk_end, chunk);
 
                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_);
-                       segments_.at(current_segment_id_).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();


@@ -948,7 +972,7 @@ void DecodeSignal::decode_proc()
 
                                try {
                                        input_segment = logic_mux_data_->logic_segments().at(current_segment_id_);
 
                                try {
                                        input_segment = logic_mux_data_->logic_segments().at(current_segment_id_);

-                               } catch (out_of_range) {
+                               } 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();
                                        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();


@@ -961,9 +985,8 @@ void DecodeSignal::decode_proc()
                                segments_.at(current_segment_id_).samplerate = input_segment->samplerate();
                                segments_.at(current_segment_id_).start_time = input_segment->start_time();
 
                                segments_.at(current_segment_id_).samplerate = input_segment->samplerate();
                                segments_.at(current_segment_id_).start_time = input_segment->start_time();
 

-                               // Reset decoder state
-                               stop_srd_session();
-                               start_srd_session();
+                               // Reset decoder state but keep the decoder stack intact
+                               terminate_srd_session();

                        } else {
                                // All segments have been processed
                                decode_finished();
                        } else {
                                // All segments have been processed
                                decode_finished();


@@ -974,12 +997,37 @@ void DecodeSignal::decode_proc()
                        }
                }
        } 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_);


@@ -991,7 +1039,7 @@ 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_ = nullptr;
                        return;
                        srd_session_destroy(srd_session_);
                        srd_session_ = nullptr;
                        return;


@@ -1011,6 +1059,27 @@ void DecodeSignal::start_srd_session()
                DecodeSignal::annotation_callback, this);
 
        srd_session_start(srd_session_);
                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()


@@ -1019,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();

        }
 }
 
        }
 }
 


@@ -1036,7 +1109,7 @@ 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()));
        }
 }


@@ -1080,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


@@ -1131,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