DecodeSignal: Allow muxed logic data to be cached

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

diff --git a/pv/data/decodesignal.cpp b/pv/data/decodesignal.cpp
index 03ecc2efcc3a0bbb7fd42b90133514969952f7b3..318a09535b5836beaa95ea4c848eab7b5bd90fc0 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::out_of_range;
 using std::shared_ptr;
 using std::unique_lock;
 using pv::data::decode::Annotation;
@@ -147,14 +148,17 @@ void DecodeSignal::reset_decode()
 
        frame_complete_ = false;
        samples_decoded_ = 0;
+       currently_processed_segment_ = 0;
        error_message_ = QString();
 
-       rows_.clear();
+       segmented_rows_.clear();
        current_rows_= nullptr;
        class_rows_.clear();
 
        logic_mux_data_.reset();
        logic_mux_data_invalid_ = true;
+
+       decode_reset();
 }
 
 void DecodeSignal::begin_decode()
@@ -220,7 +224,9 @@ void DecodeSignal::begin_decode()
                }
        }
 
-       prepare_annotation_segment();
+       create_new_annotation_segment();
+
+       // TODO Allow logic_mux_data and logic_mux_segment to work with multiple segments
 
        // Free the logic data and its segment(s) if it needs to be updated
        if (logic_mux_data_invalid_)
@@ -330,15 +336,13 @@ const pv::util::Timestamp& DecodeSignal::start_time() const
        return start_time_;
 }
 
-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
        // 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
-
        int64_t count = std::numeric_limits<int64_t>::max();
        bool no_signals_assigned = true;
 
@@ -350,17 +354,34 @@ int64_t DecodeSignal::get_working_sample_count() const
                        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);
 }
 
-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_);
-       return samples_decoded_;
+
+       int64_t result = 0;
+
+       if (segment_id == currently_processed_segment_)
+               result = samples_decoded_;
+       else
+               if (segment_id < currently_processed_segment_)
+                       // Segment was already decoded fully
+                       result = get_working_sample_count(segment_id);
+               else
+                       // Segment wasn't decoded at all yet
+                       result = 0;
+
+       return result;
 }
 
 vector<Row> DecodeSignal::visible_rows() const
@@ -403,7 +424,7 @@ void DecodeSignal::get_annotation_subset(
        if (!current_rows_)
                return;
 
-       // TODO Instead of current_rows_, use rows_ and the ID of the segment
+       // TODO Instead of current_rows_, use segmented_rows_ and the ID of the segment
 
        const auto iter = current_rows_->find(row);
        if (iter != current_rows_->end())
@@ -505,7 +526,6 @@ void DecodeSignal::restore_settings(QSettings &settings)
 
                                // Include the newly created decode channels in the channel lists
                                update_channel_list();
-                               commit_decoder_channels();
                                break;
                        }
                }
@@ -542,6 +562,10 @@ void DecodeSignal::restore_settings(QSettings &settings)
                settings.endGroup();
        }
 
+       // Update the internal structures
+       update_channel_list();
+       commit_decoder_channels();
+
        begin_decode();
 }
 
@@ -638,6 +662,12 @@ void DecodeSignal::commit_decoder_channels()
 
                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)
@@ -653,11 +683,8 @@ void DecodeSignal::mux_logic_samples(const int64_t start, const int64_t end)
        vector<uint8_t> signal_in_bytepos;
        vector<uint8_t> signal_in_bitpos;
 
-       int id = 0;
        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<LogicSegment> segment = logic_data->logic_segments().front();
                        segments.push_back(segment);
@@ -710,7 +737,7 @@ void DecodeSignal::mux_logic_samples(const int64_t start, const int64_t end)
 void DecodeSignal::logic_mux_proc()
 {
        do {
-               const uint64_t input_sample_count = get_working_sample_count();
+               const uint64_t input_sample_count = get_working_sample_count(currently_processed_segment_);
                const uint64_t output_sample_count = logic_mux_segment_->get_sample_count();
 
                const uint64_t samples_to_process =
@@ -737,16 +764,13 @@ void DecodeSignal::logic_mux_proc()
                }
 
                if (samples_to_process == 0) {
+                       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_);
-
-       // 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()
@@ -929,11 +953,10 @@ void DecodeSignal::connect_input_notifiers()
        }
 }
 
-void DecodeSignal::prepare_annotation_segment()
+void DecodeSignal::create_new_annotation_segment()
 {
-       // TODO Won't work for multiple segments
-       rows_.emplace_back(map<const decode::Row, decode::RowData>());
-       current_rows_ = &(rows_.back());
+       segmented_rows_.emplace_back(map<const decode::Row, decode::RowData>());
+       current_rows_ = &(segmented_rows_.back());
 
        // Add annotation classes
        for (const shared_ptr<decode::Decoder> &dec : stack_) {
@@ -1006,8 +1029,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
-       if (state == Session::Running)
+       if (state == Session::Running) {
+               logic_mux_data_invalid_ = true;
                begin_decode();
+       }
 }
 
 void DecodeSignal::on_data_cleared()