AnalogSegment: Calculate min/max also for small sample sizes

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

diff --git a/pv/data/analogsegment.cpp b/pv/data/analogsegment.cpp
index d40c40f205d5cac5440585a71834425b2c0d724b..38db0f123d3be31e95b98ee849fde237bf46819c 100644 (file)
--- a/pv/data/analogsegment.cpp
+++ b/pv/data/analogsegment.cpp
@@ -26,6 +26,7 @@
 
 #include <algorithm>
 
+#include "analog.hpp"
 #include "analogsegment.hpp"
 
 using std::lock_guard;
@@ -44,8 +45,11 @@ const float AnalogSegment::LogEnvelopeScaleFactor =
        logf(EnvelopeScaleFactor);
 const uint64_t AnalogSegment::EnvelopeDataUnit = 64*1024;      // bytes
 
-AnalogSegment::AnalogSegment(uint64_t samplerate) :
-       Segment(samplerate, sizeof(float))
+AnalogSegment::AnalogSegment(Analog& owner, uint64_t samplerate) :
+       Segment(samplerate, sizeof(float)),
+       owner_(owner),
+       min_value_(0),
+       max_value_(0)
 {
        lock_guard<recursive_mutex> lock(mutex_);
        memset(envelope_levels_, 0, sizeof(envelope_levels_));
@@ -65,6 +69,8 @@ void AnalogSegment::append_interleaved_samples(const float *data,
 
        lock_guard<recursive_mutex> lock(mutex_);
 
+       uint64_t prev_sample_count = sample_count_;
+
        for (uint32_t i=0; i < sample_count; i++) {
                append_single_sample((void*)data);
                data += stride;
@@ -72,6 +78,13 @@ void AnalogSegment::append_interleaved_samples(const float *data,
 
        // Generate the first mip-map from the data
        append_payload_to_envelope_levels();
+
+       if (sample_count > 1)
+               owner_.notify_samples_added(this, prev_sample_count + 1,
+                       prev_sample_count + 1 + sample_count);
+       else
+               owner_.notify_samples_added(this, prev_sample_count + 1,
+                       prev_sample_count + 1);
 }
 
 const float* AnalogSegment::get_samples(
@@ -88,6 +101,11 @@ const float* AnalogSegment::get_samples(
        return (float*)get_raw_samples(start_sample, (end_sample - start_sample));
 }
 
+const std::pair<float, float> AnalogSegment::get_min_max() const
+{
+       return std::make_pair(min_value_, max_value_);
+}
+
 SegmentAnalogDataIterator* AnalogSegment::begin_sample_iteration(uint64_t start) const
 {
        return (SegmentAnalogDataIterator*)begin_raw_sample_iteration(start);
@@ -149,6 +167,18 @@ void AnalogSegment::append_payload_to_envelope_levels()
        prev_length = e0.length;
        e0.length = sample_count_ / EnvelopeScaleFactor;
 
+       // Calculate min/max values in case we have too few samples for an envelope
+       if (sample_count_ < EnvelopeScaleFactor) {
+               it = begin_raw_sample_iteration(0);
+               for (uint64_t i = 0; i < sample_count_; i++) {
+                       const float sample = *((float*)it->value);
+                       if (sample < min_value_) min_value_ = sample;
+                       if (sample > max_value_) max_value_ = sample;
+                       continue_raw_sample_iteration(it, 1);
+               }
+               end_raw_sample_iteration(it);
+       }
+
        // Break off if there are no new samples to compute
        if (e0.length == prev_length)
                return;
@@ -170,6 +200,9 @@ void AnalogSegment::append_payload_to_envelope_levels()
                        *max_element(samples, samples + EnvelopeScaleFactor),
                };
 
+               if (sub_sample.min < min_value_) min_value_ = sub_sample.min;
+               if (sub_sample.max > max_value_) max_value_ = sub_sample.max;
+
                continue_raw_sample_iteration(it, EnvelopeScaleFactor);
                *dest_ptr++ = sub_sample;
        }
@@ -202,7 +235,7 @@ void AnalogSegment::append_payload_to_envelope_levels()
 
                        EnvelopeSample sub_sample = *src_ptr++;
                        while (src_ptr < end_src_ptr) {
-                               sub_sample.min = min(sub_sample.min, src_ptr->min);
+                               sub_sample.min = min(sub_sample.min, src_ptr->min);;
                                sub_sample.max = max(sub_sample.max, src_ptr->max);
                                src_ptr++;
                        }