Fix #1270 by replacing insignificant characters before comparing

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

diff --git a/pv/data/decodesignal.cpp b/pv/data/decodesignal.cpp
index 65436002c760681a8b1b8117f15c74932479f4a2..9b40540c7032b058f988f8cb8d903d6763b3d97f 100644 (file)
--- 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 <forward_list>
 #include <limits>
 
 #include <QDebug>
@@ -32,6 +33,7 @@
 #include <pv/globalsettings.hpp>
 #include <pv/session.hpp>
 
+using std::forward_list;
 using std::lock_guard;
 using std::make_pair;
 using std::make_shared;
@@ -149,6 +151,8 @@ void DecodeSignal::reset_decode(bool shutting_down)
                logic_mux_thread_.join();
        }
 
+       resume_decode();  // Make sure the decode thread isn't blocked by pausing
+
        class_rows_.clear();
        current_segment_id_ = 0;
        segments_.clear();
@@ -209,6 +213,7 @@ void DecodeSignal::begin_decode()
                }
 
        // Map out all the annotation classes
+       int row_index = 0;
        for (const shared_ptr<decode::Decoder> &dec : stack_) {
                assert(dec);
                const srd_decoder *const decc = dec->decoder();
@@ -219,7 +224,7 @@ void DecodeSignal::begin_decode()
                                (srd_decoder_annotation_row *)l->data;
                        assert(ann_row);
 
-                       const Row row(decc, ann_row);
+                       const Row row(row_index++, decc, ann_row);
 
                        for (const GSList *ll = ann_row->ann_classes;
                                ll; ll = ll->next)
@@ -255,6 +260,25 @@ void DecodeSignal::begin_decode()
        decode_thread_ = std::thread(&DecodeSignal::decode_proc, this);
 }
 
+void DecodeSignal::pause_decode()
+{
+       decode_paused_ = true;
+}
+
+void DecodeSignal::resume_decode()
+{
+       // Manual unlocking is done before notifying, to avoid waking up the
+       // waiting thread only to block again (see notify_one for details)
+       decode_pause_mutex_.unlock();
+       decode_pause_cond_.notify_one();
+       decode_paused_ = false;
+}
+
+bool DecodeSignal::is_paused() const
+{
+       return decode_paused_;
+}
+
 QString DecodeSignal::error_message() const
 {
        lock_guard<mutex> lock(output_mutex_);
@@ -279,14 +303,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()) {
                        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)))) {
@@ -432,16 +458,17 @@ vector<Row> DecodeSignal::visible_rows() const
                const srd_decoder *const decc = dec->decoder();
                assert(dec->decoder());
 
+               int row_index = 0;
                // Add a row for the decoder if it doesn't have a row list
                if (!decc->annotation_rows)
-                       rows.emplace_back(decc);
+                       rows.emplace_back(row_index++, decc);
 
                // Add the decoder rows
                for (const GSList *l = decc->annotation_rows; l; l = l->next) {
                        const srd_decoder_annotation_row *const ann_row =
                                (srd_decoder_annotation_row *)l->data;
                        assert(ann_row);
-                       rows.emplace_back(decc, ann_row);
+                       rows.emplace_back(row_index++, decc, ann_row);
                }
        }
 
@@ -469,6 +496,33 @@ void DecodeSignal::get_annotation_subset(
        }
 }
 
+void DecodeSignal::get_annotation_subset(
+       vector<pv::data::decode::Annotation> &dest,
+       uint32_t segment_id, uint64_t start_sample, uint64_t end_sample) const
+{
+       // Note: We put all vectors and lists on the heap, not the stack
+
+       const vector<Row> rows = visible_rows();
+
+       // Use forward_lists for faster merging
+       forward_list<Annotation> *all_ann_list = new forward_list<Annotation>();
+
+       for (const Row& row : rows) {
+               vector<Annotation> *ann_vector = new vector<Annotation>();
+               get_annotation_subset(*ann_vector, row, segment_id, start_sample, end_sample);
+
+               forward_list<Annotation> *ann_list =
+                       new forward_list<Annotation>(ann_vector->begin(), ann_vector->end());
+               delete ann_vector;
+
+               all_ann_list->merge(*ann_list);
+               delete ann_list;
+       }
+
+       move(all_ann_list->begin(), all_ann_list->end(), back_inserter(dest));
+       delete all_ann_list;
+}
+
 void DecodeSignal::save_settings(QSettings &settings) const
 {
        SignalBase::save_settings(settings);
@@ -950,6 +1004,11 @@ void DecodeSignal::decode_data(
                // Notify the frontend that we processed some data and
                // possibly have new annotations as well
                new_annotations();
+
+               if (decode_paused_) {
+                       unique_lock<mutex> pause_wait_lock(decode_pause_mutex_);
+                       decode_pause_cond_.wait(pause_wait_lock);
+               }
        }
 }
 
@@ -1159,9 +1218,10 @@ void DecodeSignal::create_decode_segment()
                const srd_decoder *const decc = dec->decoder();
                assert(dec->decoder());
 
+               int row_index = 0;
                // Add a row for the decoder if it doesn't have a row list
                if (!decc->annotation_rows)
-                       (segments_.back().annotation_rows)[Row(decc)] =
+                       (segments_.back().annotation_rows)[Row(row_index++, decc)] =
                                decode::RowData();
 
                // Add the decoder rows
@@ -1170,7 +1230,7 @@ void DecodeSignal::create_decode_segment()
                                (srd_decoder_annotation_row *)l->data;
                        assert(ann_row);
 
-                       const Row row(decc, ann_row);
+                       const Row row(row_index++, decc, ann_row);
 
                        // Add a new empty row data object
                        (segments_.back().annotation_rows)[row] =
@@ -1211,7 +1271,7 @@ void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signa
                row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find((*r).second);
        else {
                // Failing that, use the decoder as a key
-               row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find(Row(decc));
+               row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find(Row(0, decc));
        }
 
        if (row_iter == ds->segments_.at(ds->current_segment_id_).annotation_rows.end()) {
@@ -1222,7 +1282,7 @@ void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signa
        }
 
        // Add the annotation
-       (*row_iter).second.emplace_annotation(pdata);
+       (*row_iter).second.emplace_annotation(pdata, &((*row_iter).first));
 }
 
 void DecodeSignal::on_capture_state_changed(int state)