Segment: Do not alter chunks when there are active iterators

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

diff --git a/pv/data/analogsegment.cpp b/pv/data/analogsegment.cpp
index d40c40f205d5cac5440585a71834425b2c0d724b..b3f310a144c5cd7ce2e18fb83ed242bd10526b6c 100644 (file)
--- a/pv/data/analogsegment.cpp
+++ b/pv/data/analogsegment.cpp
@@ -26,6 +26,7 @@
 
 #include <algorithm>
 
 
 #include <algorithm>
 

+#include "analog.hpp"

 #include "analogsegment.hpp"
 
 using std::lock_guard;
 #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
 
        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_));
 {
        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_);
 
 
        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;
        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();
 
        // 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(
 }
 
 const float* AnalogSegment::get_samples(


@@ -88,17 +101,22 @@ const float* AnalogSegment::get_samples(
        return (float*)get_raw_samples(start_sample, (end_sample - start_sample));
 }
 
        return (float*)get_raw_samples(start_sample, (end_sample - start_sample));
 }
 

-SegmentAnalogDataIterator* AnalogSegment::begin_sample_iteration(uint64_t start) const
+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)

 {
        return (SegmentAnalogDataIterator*)begin_raw_sample_iteration(start);
 }
 
 {
        return (SegmentAnalogDataIterator*)begin_raw_sample_iteration(start);
 }
 

-void AnalogSegment::continue_sample_iteration(SegmentAnalogDataIterator* it, uint64_t increase) const
+void AnalogSegment::continue_sample_iteration(SegmentAnalogDataIterator* it, uint64_t increase)

 {
        Segment::continue_raw_sample_iteration((SegmentRawDataIterator*)it, increase);
 }
 
 {
        Segment::continue_raw_sample_iteration((SegmentRawDataIterator*)it, increase);
 }
 

-void AnalogSegment::end_sample_iteration(SegmentAnalogDataIterator* it) const
+void AnalogSegment::end_sample_iteration(SegmentAnalogDataIterator* it)

 {
        Segment::end_raw_sample_iteration((SegmentRawDataIterator*)it);
 }
 {
        Segment::end_raw_sample_iteration((SegmentRawDataIterator*)it);
 }


@@ -149,6 +167,18 @@ void AnalogSegment::append_payload_to_envelope_levels()
        prev_length = e0.length;
        e0.length = sample_count_ / EnvelopeScaleFactor;
 
        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;
        // 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),
                };
 
                        *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;
        }
                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) {
 
                        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++;
                        }
                                sub_sample.max = max(sub_sample.max, src_ptr->max);
                                src_ptr++;
                        }