#include <algorithm>
-#include <boost/foreach.hpp>
+#include "analogsnapshot.hpp"
-#include "analogsnapshot.h"
-
-using boost::lock_guard;
-using boost::recursive_mutex;
+using std::lock_guard;
+using std::recursive_mutex;
using std::max;
using std::max_element;
using std::min;
logf(EnvelopeScaleFactor);
const uint64_t AnalogSnapshot::EnvelopeDataUnit = 64*1024; // bytes
-AnalogSnapshot::AnalogSnapshot(const sr_datafeed_analog &analog) :
+AnalogSnapshot::AnalogSnapshot(const uint64_t expected_num_samples) :
Snapshot(sizeof(float))
{
- lock_guard<recursive_mutex> lock(_mutex);
- memset(_envelope_levels, 0, sizeof(_envelope_levels));
- append_payload(analog);
+ set_capacity(expected_num_samples);
+
+ lock_guard<recursive_mutex> lock(mutex_);
+ memset(envelope_levels_, 0, sizeof(envelope_levels_));
}
AnalogSnapshot::~AnalogSnapshot()
{
- lock_guard<recursive_mutex> lock(_mutex);
- BOOST_FOREACH(Envelope &e, _envelope_levels)
+ lock_guard<recursive_mutex> lock(mutex_);
+ for (Envelope &e : envelope_levels_)
free(e.samples);
}
-void AnalogSnapshot::append_payload(
- const sr_datafeed_analog &analog)
+void AnalogSnapshot::append_interleaved_samples(const float *data,
+ size_t sample_count, size_t stride)
{
- lock_guard<recursive_mutex> lock(_mutex);
- append_data(analog.data, analog.num_samples);
+ assert(unit_size_ == sizeof(float));
+
+ lock_guard<recursive_mutex> lock(mutex_);
+
+ data_.resize((sample_count_ + sample_count) * sizeof(float));
+
+ float *dst = (float*)data_.data() + sample_count_;
+ const float *dst_end = dst + sample_count;
+ while (dst != dst_end)
+ {
+ *dst++ = *data;
+ data += stride;
+ }
+
+ sample_count_ += sample_count;
// Generate the first mip-map from the data
append_payload_to_envelope_levels();
int64_t start_sample, int64_t end_sample) const
{
assert(start_sample >= 0);
- assert(start_sample < (int64_t)_sample_count);
+ assert(start_sample < (int64_t)sample_count_);
assert(end_sample >= 0);
- assert(end_sample < (int64_t)_sample_count);
+ assert(end_sample < (int64_t)sample_count_);
assert(start_sample <= end_sample);
- lock_guard<recursive_mutex> lock(_mutex);
+ lock_guard<recursive_mutex> lock(mutex_);
float *const data = new float[end_sample - start_sample];
- memcpy(data, (float*)_data + start_sample, sizeof(float) *
+ memcpy(data, (float*)data_.data() + start_sample, sizeof(float) *
(end_sample - start_sample));
return data;
}
assert(start <= end);
assert(min_length > 0);
- lock_guard<recursive_mutex> lock(_mutex);
+ lock_guard<recursive_mutex> lock(mutex_);
const unsigned int min_level = max((int)floorf(logf(min_length) /
LogEnvelopeScaleFactor) - 1, 0);
s.scale = 1 << scale_power;
s.length = end - start;
s.samples = new EnvelopeSample[s.length];
- memcpy(s.samples, _envelope_levels[min_level].samples + start,
+ memcpy(s.samples, envelope_levels_[min_level].samples + start,
s.length * sizeof(EnvelopeSample));
}
void AnalogSnapshot::append_payload_to_envelope_levels()
{
- Envelope &e0 = _envelope_levels[0];
+ Envelope &e0 = envelope_levels_[0];
uint64_t prev_length;
EnvelopeSample *dest_ptr;
// Expand the data buffer to fit the new samples
prev_length = e0.length;
- e0.length = _sample_count / EnvelopeScaleFactor;
+ e0.length = sample_count_ / EnvelopeScaleFactor;
// Break off if there are no new samples to compute
if (e0.length == prev_length)
dest_ptr = e0.samples + prev_length;
// Iterate through the samples to populate the first level mipmap
- const float *const end_src_ptr = (float*)_data +
+ const float *const end_src_ptr = (float*)data_.data() +
e0.length * EnvelopeScaleFactor;
- for (const float *src_ptr = (float*)_data +
+ for (const float *src_ptr = (float*)data_.data() +
prev_length * EnvelopeScaleFactor;
src_ptr < end_src_ptr; src_ptr += EnvelopeScaleFactor)
{
// Compute higher level mipmaps
for (unsigned int level = 1; level < ScaleStepCount; level++)
{
- Envelope &e = _envelope_levels[level];
- const Envelope &el = _envelope_levels[level-1];
+ Envelope &e = envelope_levels_[level];
+ const Envelope &el = envelope_levels_[level-1];
// Expand the data buffer to fit the new samples
prev_length = e.length;