]> sigrok.org Git - pulseview.git/commitdiff
Implement LogicSegment::get_surrounding_edges() and use it
authorSoeren Apel <redacted>
Mon, 2 Jul 2018 17:57:10 +0000 (19:57 +0200)
committerSoeren Apel <redacted>
Wed, 26 Sep 2018 21:00:50 +0000 (23:00 +0200)
pv/data/logicsegment.cpp
pv/data/logicsegment.hpp
pv/views/trace/logicsignal.cpp
pv/views/trace/logicsignal.hpp

index 1bbd8d7cf0e7c40255ce13ae21d7211cafc550d6..32a7adb240fc5535a895c00f5d87abfb97d712b3 100644 (file)
@@ -199,118 +199,10 @@ void LogicSegment::end_sample_iteration(SegmentLogicDataIterator* it)
        Segment::end_raw_sample_iteration((SegmentRawDataIterator*)it);
 }
 
-void LogicSegment::reallocate_mipmap_level(MipMapLevel &m)
-{
-       lock_guard<recursive_mutex> lock(mutex_);
-
-       const uint64_t new_data_length = ((m.length + MipMapDataUnit - 1) /
-               MipMapDataUnit) * MipMapDataUnit;
-
-       if (new_data_length > m.data_length) {
-               m.data_length = new_data_length;
-
-               // Padding is added to allow for the uint64_t write word
-               m.data = realloc(m.data, new_data_length * unit_size_ +
-                       sizeof(uint64_t));
-       }
-}
-
-void LogicSegment::append_payload_to_mipmap()
-{
-       MipMapLevel &m0 = mip_map_[0];
-       uint64_t prev_length;
-       uint8_t *dest_ptr;
-       SegmentRawDataIterator* it;
-       uint64_t accumulator;
-       unsigned int diff_counter;
-
-       // Expand the data buffer to fit the new samples
-       prev_length = m0.length;
-       m0.length = sample_count_ / MipMapScaleFactor;
-
-       // Break off if there are no new samples to compute
-       if (m0.length == prev_length)
-               return;
-
-       reallocate_mipmap_level(m0);
-
-       dest_ptr = (uint8_t*)m0.data + prev_length * unit_size_;
-
-       // Iterate through the samples to populate the first level mipmap
-       const uint64_t start_sample = prev_length * MipMapScaleFactor;
-       const uint64_t end_sample = m0.length * MipMapScaleFactor;
-
-       it = begin_raw_sample_iteration(start_sample);
-       for (uint64_t i = start_sample; i < end_sample;) {
-               // Accumulate transitions which have occurred in this sample
-               accumulator = 0;
-               diff_counter = MipMapScaleFactor;
-               while (diff_counter-- > 0) {
-                       const uint64_t sample = unpack_sample(it->value);
-                       accumulator |= last_append_sample_ ^ sample;
-                       last_append_sample_ = sample;
-                       continue_raw_sample_iteration(it, 1);
-                       i++;
-               }
-
-               pack_sample(dest_ptr, accumulator);
-               dest_ptr += unit_size_;
-       }
-       end_raw_sample_iteration(it);
-
-       // Compute higher level mipmaps
-       for (unsigned int level = 1; level < ScaleStepCount; level++) {
-               MipMapLevel &m = mip_map_[level];
-               const MipMapLevel &ml = mip_map_[level - 1];
-
-               // Expand the data buffer to fit the new samples
-               prev_length = m.length;
-               m.length = ml.length / MipMapScaleFactor;
-
-               // Break off if there are no more samples to be computed
-               if (m.length == prev_length)
-                       break;
-
-               reallocate_mipmap_level(m);
-
-               // Subsample the lower level
-               const uint8_t* src_ptr = (uint8_t*)ml.data +
-                       unit_size_ * prev_length * MipMapScaleFactor;
-               const uint8_t *const end_dest_ptr =
-                       (uint8_t*)m.data + unit_size_ * m.length;
-
-               for (dest_ptr = (uint8_t*)m.data +
-                               unit_size_ * prev_length;
-                               dest_ptr < end_dest_ptr;
-                               dest_ptr += unit_size_) {
-                       accumulator = 0;
-                       diff_counter = MipMapScaleFactor;
-                       while (diff_counter-- > 0) {
-                               accumulator |= unpack_sample(src_ptr);
-                               src_ptr += unit_size_;
-                       }
-
-                       pack_sample(dest_ptr, accumulator);
-               }
-       }
-}
-
-uint64_t LogicSegment::get_unpacked_sample(uint64_t index) const
-{
-       assert(index < sample_count_);
-
-       assert(unit_size_ <= 8);  // 8 * 8 = 64 channels
-       uint8_t data[8];
-
-       get_raw_samples(index, 1, data);
-
-       return unpack_sample(data);
-}
-
 void LogicSegment::get_subsampled_edges(
        vector<EdgePair> &edges,
        uint64_t start, uint64_t end,
-       float min_length, int sig_index)
+       float min_length, int sig_index, bool first_change_only)
 {
        uint64_t index = start;
        unsigned int level;
@@ -335,7 +227,8 @@ void LogicSegment::get_subsampled_edges(
 
        // Store the initial state
        last_sample = (get_unpacked_sample(start) & sig_mask) != 0;
-       edges.emplace_back(index++, last_sample);
+       if (!first_change_only)
+               edges.emplace_back(index++, last_sample);
 
        while (index + block_length <= end) {
                //----- Continue to search -----//
@@ -461,13 +354,161 @@ void LogicSegment::get_subsampled_edges(
 
                index = final_index;
                last_sample = final_sample;
+
+               if (first_change_only)
+                       break;
        }
 
        // Add the final state
-       const bool end_sample = get_unpacked_sample(end) & sig_mask;
-       if (last_sample != end_sample)
-               edges.emplace_back(end, end_sample);
-       edges.emplace_back(end + 1, end_sample);
+       if (!first_change_only) {
+               const bool end_sample = get_unpacked_sample(end) & sig_mask;
+               if (last_sample != end_sample)
+                       edges.emplace_back(end, end_sample);
+               edges.emplace_back(end + 1, end_sample);
+       }
+}
+
+void LogicSegment::get_surrounding_edges(vector<EdgePair> &dest,
+       uint64_t origin_sample, float min_length, int sig_index)
+{
+       // Put the edges vector on the heap, it can become quite big until we can
+       // use a get_subsampled_edges() implementation that searches backwards
+       vector<EdgePair>* edges = new vector<EdgePair>;
+
+       get_subsampled_edges(*edges, 0, origin_sample, min_length, sig_index, false);
+
+       // If we don't specify "first only", the first and last edge are the states
+       // at samples 0 and origin_sample. If only those exist, there are no edges
+       if (edges->size() == 2) {
+               delete edges;
+               return;
+       }
+
+       // Dismiss the entry for origin_sample so that back() gives us the
+       // real last entry
+       edges->pop_back();
+       dest.push_back(edges->back());
+       edges->clear();
+
+       get_subsampled_edges(*edges, origin_sample, sample_count_, min_length, sig_index, true);
+
+       // "first only" is specified, so nothing needs to be dismissed
+       if (edges->size() == 0) {
+               delete edges;
+               return;
+       }
+
+       dest.push_back(edges->front());
+
+       delete edges;
+}
+
+void LogicSegment::reallocate_mipmap_level(MipMapLevel &m)
+{
+       lock_guard<recursive_mutex> lock(mutex_);
+
+       const uint64_t new_data_length = ((m.length + MipMapDataUnit - 1) /
+               MipMapDataUnit) * MipMapDataUnit;
+
+       if (new_data_length > m.data_length) {
+               m.data_length = new_data_length;
+
+               // Padding is added to allow for the uint64_t write word
+               m.data = realloc(m.data, new_data_length * unit_size_ +
+                       sizeof(uint64_t));
+       }
+}
+
+void LogicSegment::append_payload_to_mipmap()
+{
+       MipMapLevel &m0 = mip_map_[0];
+       uint64_t prev_length;
+       uint8_t *dest_ptr;
+       SegmentRawDataIterator* it;
+       uint64_t accumulator;
+       unsigned int diff_counter;
+
+       // Expand the data buffer to fit the new samples
+       prev_length = m0.length;
+       m0.length = sample_count_ / MipMapScaleFactor;
+
+       // Break off if there are no new samples to compute
+       if (m0.length == prev_length)
+               return;
+
+       reallocate_mipmap_level(m0);
+
+       dest_ptr = (uint8_t*)m0.data + prev_length * unit_size_;
+
+       // Iterate through the samples to populate the first level mipmap
+       const uint64_t start_sample = prev_length * MipMapScaleFactor;
+       const uint64_t end_sample = m0.length * MipMapScaleFactor;
+
+       it = begin_raw_sample_iteration(start_sample);
+       for (uint64_t i = start_sample; i < end_sample;) {
+               // Accumulate transitions which have occurred in this sample
+               accumulator = 0;
+               diff_counter = MipMapScaleFactor;
+               while (diff_counter-- > 0) {
+                       const uint64_t sample = unpack_sample(it->value);
+                       accumulator |= last_append_sample_ ^ sample;
+                       last_append_sample_ = sample;
+                       continue_raw_sample_iteration(it, 1);
+                       i++;
+               }
+
+               pack_sample(dest_ptr, accumulator);
+               dest_ptr += unit_size_;
+       }
+       end_raw_sample_iteration(it);
+
+       // Compute higher level mipmaps
+       for (unsigned int level = 1; level < ScaleStepCount; level++) {
+               MipMapLevel &m = mip_map_[level];
+               const MipMapLevel &ml = mip_map_[level - 1];
+
+               // Expand the data buffer to fit the new samples
+               prev_length = m.length;
+               m.length = ml.length / MipMapScaleFactor;
+
+               // Break off if there are no more samples to be computed
+               if (m.length == prev_length)
+                       break;
+
+               reallocate_mipmap_level(m);
+
+               // Subsample the lower level
+               const uint8_t* src_ptr = (uint8_t*)ml.data +
+                       unit_size_ * prev_length * MipMapScaleFactor;
+               const uint8_t *const end_dest_ptr =
+                       (uint8_t*)m.data + unit_size_ * m.length;
+
+               for (dest_ptr = (uint8_t*)m.data +
+                               unit_size_ * prev_length;
+                               dest_ptr < end_dest_ptr;
+                               dest_ptr += unit_size_) {
+                       accumulator = 0;
+                       diff_counter = MipMapScaleFactor;
+                       while (diff_counter-- > 0) {
+                               accumulator |= unpack_sample(src_ptr);
+                               src_ptr += unit_size_;
+                       }
+
+                       pack_sample(dest_ptr, accumulator);
+               }
+       }
+}
+
+uint64_t LogicSegment::get_unpacked_sample(uint64_t index) const
+{
+       assert(index < sample_count_);
+
+       assert(unit_size_ <= 8);  // 8 * 8 = 64 channels
+       uint8_t data[8];
+
+       get_raw_samples(index, 1, data);
+
+       return unpack_sample(data);
 }
 
 uint64_t LogicSegment::get_subsample(int level, uint64_t offset) const
index 88576118d06eb180b281d0d8ee9a9b2f1def1e2c..a18a59f2e154130de84f5b7c009c2f9f50199fff 100644 (file)
@@ -90,17 +90,6 @@ public:
        void continue_sample_iteration(SegmentLogicDataIterator* it, uint64_t increase);
        void end_sample_iteration(SegmentLogicDataIterator* it);
 
-private:
-       uint64_t unpack_sample(const uint8_t *ptr) const;
-       void pack_sample(uint8_t *ptr, uint64_t value);
-
-       void reallocate_mipmap_level(MipMapLevel &m);
-
-       void append_payload_to_mipmap();
-
-       uint64_t get_unpacked_sample(uint64_t index) const;
-
-public:
        /**
         * Parses a logic data segment to generate a list of transitions
         * in a time interval to a given level of detail.
@@ -113,7 +102,20 @@ public:
         */
        void get_subsampled_edges(vector<EdgePair> &edges,
                uint64_t start, uint64_t end,
-               float min_length, int sig_index);
+               float min_length, int sig_index, bool first_change_only = false);
+
+       void get_surrounding_edges(vector<EdgePair> &dest,
+               uint64_t origin_sample, float min_length, int sig_index);
+
+private:
+       uint64_t unpack_sample(const uint8_t *ptr) const;
+       void pack_sample(uint8_t *ptr, uint64_t value);
+
+       void reallocate_mipmap_level(MipMapLevel &m);
+
+       void append_payload_to_mipmap();
+
+       uint64_t get_unpacked_sample(uint64_t index) const;
 
 private:
        uint64_t get_subsample(int level, uint64_t offset) const;
index 8396323f4ee05623c3e49d747ef9b44caf47cc15..438e4e21c1f6a6c639543897cb65f35362e9a746 100644 (file)
@@ -320,6 +320,51 @@ void LogicSignal::paint_fore(QPainter &p, ViewItemPaintParams &pp)
        }
 }
 
+void LogicSignal::hover_point_changed(const QPoint &hp)
+{
+       Signal::hover_point_changed(hp);
+
+       assert(base_);
+       assert(owner_);
+
+       if ((!base_->enabled()) || (hp.x() == 0))
+               return;
+
+       // Ignore if mouse cursor is not hovering over this trace
+       const int y = get_visual_y();
+       const pair<int, int> extents = v_extents();
+       if ((hp.y() < (y + extents.first)) || ((hp.y() > (y + extents.second))))
+               return;
+
+       shared_ptr<pv::data::LogicSegment> segment = get_logic_segment_to_paint();
+       if (!segment || (segment->get_sample_count() == 0))
+               return;
+
+       double samplerate = segment->samplerate();
+
+       // Show sample rate as 1Hz when it is unknown
+       if (samplerate == 0.0)
+               samplerate = 1.0;
+
+       const View *view = owner_->view();
+       assert(view);
+       const double scale = view->scale();
+       const double pixels_offset =
+               ((view->offset() - segment->start_time()) / scale).convert_to<double>();
+       const double samples_per_pixel = samplerate * scale;
+
+       const uint64_t sample_pos = (uint64_t)max(
+               (hp.x() + pixels_offset) * samples_per_pixel, 0.0);
+
+       vector<data::LogicSegment::EdgePair> edges;
+
+       segment->get_surrounding_edges(edges, sample_pos,
+               samples_per_pixel / Oversampling, base_->index());
+
+       if (edges.empty())
+               return;
+}
+
 void LogicSignal::paint_caps(QPainter &p, QLineF *const lines,
        vector< pair<int64_t, bool> > &edges, bool level,
        double samples_per_pixel, double pixels_offset, float x_offset,
index 04ba1305fc455a8addd8f75236e529ebd04dc5d1..ca5ce3d4d2f38ba922971c4c67dc5f6248e6ab4f 100644 (file)
@@ -103,6 +103,8 @@ public:
         */
        virtual void paint_fore(QPainter &p, ViewItemPaintParams &pp);
 
+       virtual void hover_point_changed(const QPoint &hp);
+
 private:
        void paint_caps(QPainter &p, QLineF *const lines,
                vector< pair<int64_t, bool> > &edges,