X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Flogicsegment.cpp;h=fcf572297e689f87762eabc81df96207df3000dc;hp=3e18b85ef4143bb399c5dd1dcff2fb7e6375d7ed;hb=9d22929c3588b994771e8db8f3be5b013fd35040;hpb=2ad82c2e40b6865481733913a2c32735602f63c4 diff --git a/pv/data/logicsegment.cpp b/pv/data/logicsegment.cpp index 3e18b85e..fcf57229 100644 --- a/pv/data/logicsegment.cpp +++ b/pv/data/logicsegment.cpp @@ -14,17 +14,17 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * along with this program; if not, see . */ #include -#include -#include -#include +#include +#include +#include #include +#include "logic.hpp" #include "logicsegment.hpp" #include @@ -35,6 +35,7 @@ using std::max; using std::min; using std::pair; using std::shared_ptr; +using std::vector; using sigrok::Logic; @@ -46,16 +47,24 @@ const int LogicSegment::MipMapScaleFactor = 1 << MipMapScalePower; const float LogicSegment::LogMipMapScaleFactor = logf(MipMapScaleFactor); const uint64_t LogicSegment::MipMapDataUnit = 64*1024; // bytes -LogicSegment::LogicSegment(shared_ptr logic, uint64_t samplerate, - const uint64_t expected_num_samples) : - Segment(samplerate, logic->unit_size()), +LogicSegment::LogicSegment(pv::data::Logic& owner, shared_ptr data, + uint64_t samplerate) : + Segment(samplerate, data->unit_size()), + owner_(owner), last_append_sample_(0) { - set_capacity(expected_num_samples); - lock_guard lock(mutex_); memset(mip_map_, 0, sizeof(mip_map_)); - append_payload(logic); + append_payload(data); +} + +LogicSegment::LogicSegment(pv::data::Logic& owner, unsigned int unit_size, + uint64_t samplerate) : + Segment(samplerate, unit_size), + owner_(owner), + last_append_sample_(0) +{ + memset(mip_map_, 0, sizeof(mip_map_)); } LogicSegment::~LogicSegment() @@ -139,24 +148,39 @@ void LogicSegment::pack_sample(uint8_t *ptr, uint64_t value) #endif } -void LogicSegment::append_payload(shared_ptr logic) +void LogicSegment::append_payload(shared_ptr logic) { assert(unit_size_ == logic->unit_size()); assert((logic->data_length() % unit_size_) == 0); + append_payload(logic->data_pointer(), logic->data_length()); +} + +void LogicSegment::append_payload(void *data, uint64_t data_size) +{ + assert((data_size % unit_size_) == 0); + lock_guard lock(mutex_); - append_data(logic->data_pointer(), - logic->data_length() / unit_size_); + uint64_t prev_sample_count = sample_count_; + uint64_t sample_count = data_size / unit_size_; + + append_samples(data, sample_count); // Generate the first mip-map from the data append_payload_to_mipmap(); + + 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); } -void LogicSegment::get_samples(uint8_t *const data, - int64_t start_sample, int64_t end_sample) const +const uint8_t* LogicSegment::get_samples(int64_t start_sample, + int64_t end_sample) const { - assert(data); assert(start_sample >= 0); assert(start_sample <= (int64_t)sample_count_); assert(end_sample >= 0); @@ -165,14 +189,31 @@ void LogicSegment::get_samples(uint8_t *const data, lock_guard lock(mutex_); - const size_t size = (end_sample - start_sample) * unit_size_; - memcpy(data, (const uint8_t*)data_.data() + start_sample * unit_size_, size); + return get_raw_samples(start_sample, (end_sample-start_sample)); +} + +SegmentLogicDataIterator* LogicSegment::begin_sample_iteration(uint64_t start) +{ + return (SegmentLogicDataIterator*)begin_raw_sample_iteration(start); +} + +void LogicSegment::continue_sample_iteration(SegmentLogicDataIterator* it, uint64_t increase) +{ + Segment::continue_raw_sample_iteration((SegmentRawDataIterator*)it, increase); +} + +void LogicSegment::end_sample_iteration(SegmentLogicDataIterator* it) +{ + Segment::end_raw_sample_iteration((SegmentRawDataIterator*)it); } void LogicSegment::reallocate_mipmap_level(MipMapLevel &m) { + lock_guard 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; @@ -186,8 +227,8 @@ void LogicSegment::append_payload_to_mipmap() { MipMapLevel &m0 = mip_map_[0]; uint64_t prev_length; - const uint8_t *src_ptr; uint8_t *dest_ptr; + SegmentRawDataIterator* it; uint64_t accumulator; unsigned int diff_counter; @@ -204,24 +245,26 @@ void LogicSegment::append_payload_to_mipmap() dest_ptr = (uint8_t*)m0.data + prev_length * unit_size_; // Iterate through the samples to populate the first level mipmap - const uint8_t *const end_src_ptr = (uint8_t*)data_.data() + - m0.length * unit_size_ * MipMapScaleFactor; - for (src_ptr = (uint8_t*)data_.data() + - prev_length * unit_size_ * MipMapScaleFactor; - src_ptr < end_src_ptr;) { + uint64_t start_sample = prev_length * MipMapScaleFactor; + 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(src_ptr); + const uint64_t sample = unpack_sample(it->value); accumulator |= last_append_sample_ ^ sample; last_append_sample_ = sample; - src_ptr += unit_size_; + 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++) { @@ -232,17 +275,18 @@ void LogicSegment::append_payload_to_mipmap() prev_length = m.length; m.length = ml.length / MipMapScaleFactor; - // Break off if there are no more samples to computed + // Break off if there are no more samples to be computed if (m.length == prev_length) break; reallocate_mipmap_level(m); - // Subsample the level lower level - src_ptr = (uint8_t*)ml.data + + // 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; @@ -259,15 +303,19 @@ void LogicSegment::append_payload_to_mipmap() } } -uint64_t LogicSegment::get_sample(uint64_t index) const +uint64_t LogicSegment::get_unpacked_sample(uint64_t index) const { assert(index < sample_count_); - return unpack_sample((uint8_t*)data_.data() + index * unit_size_); + const uint8_t* data = get_raw_samples(index, 1); + uint64_t sample = unpack_sample(data); + delete[] data; + + return sample; } void LogicSegment::get_subsampled_edges( - std::vector &edges, + vector &edges, uint64_t start, uint64_t end, float min_length, int sig_index) { @@ -290,8 +338,8 @@ void LogicSegment::get_subsampled_edges( const uint64_t sig_mask = 1ULL << sig_index; // Store the initial state - last_sample = (get_sample(start) & sig_mask) != 0; - edges.push_back(pair(index++, last_sample)); + last_sample = (get_unpacked_sample(start) & sig_mask) != 0; + edges.emplace_back(index++, last_sample); while (index + block_length <= end) { //----- Continue to search -----// @@ -308,10 +356,10 @@ void LogicSegment::get_subsampled_edges( pow2_ceil(index, MipMapScalePower)); for (; index < final_index && - (index & ~(~0 << MipMapScalePower)) != 0; + (index & ~((uint64_t)(~0) << MipMapScalePower)) != 0; index++) { const bool sample = - (get_sample(index) & sig_mask) != 0; + (get_unpacked_sample(index) & sig_mask) != 0; // If there was a change we cannot fast forward if (sample != last_sample) { @@ -331,7 +379,7 @@ void LogicSegment::get_subsampled_edges( // We can fast forward only if there was no change const bool sample = - (get_sample(index) & sig_mask) != 0; + (get_unpacked_sample(index) & sig_mask) != 0; if (last_sample != sample) fast_forward = false; } @@ -345,7 +393,7 @@ void LogicSegment::get_subsampled_edges( // Slide right and zoom out at the beginnings of mip-map // blocks until we encounter a change - while (1) { + while (true) { const int level_scale_power = (level + 1) * MipMapScalePower; const uint64_t offset = @@ -358,7 +406,7 @@ void LogicSegment::get_subsampled_edges( sig_mask)) break; - if ((offset & ~(~0 << MipMapScalePower)) == 0) { + if ((offset & ~((uint64_t)(~0) << MipMapScalePower)) == 0) { // If we are now at the beginning of a // higher level mip-map block ascend one // level @@ -377,7 +425,7 @@ void LogicSegment::get_subsampled_edges( // Zoom in, and slide right until we encounter a change, // and repeat until we reach min_level - while (1) { + while (true) { assert(mip_map_[level].data); const int level_scale_power = @@ -409,7 +457,7 @@ void LogicSegment::get_subsampled_edges( // block if (min_length < MipMapScaleFactor) { for (; index < end; index++) { - const bool sample = (get_sample(index) & + const bool sample = (get_unpacked_sample(index) & sig_mask) != 0; if (sample != last_sample) break; @@ -426,18 +474,18 @@ void LogicSegment::get_subsampled_edges( // Store the final state const bool final_sample = - (get_sample(final_index - 1) & sig_mask) != 0; - edges.push_back(pair(index, final_sample)); + (get_unpacked_sample(final_index - 1) & sig_mask) != 0; + edges.emplace_back(index, final_sample); index = final_index; last_sample = final_sample; } // Add the final state - const bool end_sample = get_sample(end) & sig_mask; + const bool end_sample = get_unpacked_sample(end) & sig_mask; if (last_sample != end_sample) - edges.push_back(pair(end, end_sample)); - edges.push_back(pair(end + 1, end_sample)); + edges.emplace_back(end, end_sample); + edges.emplace_back(end + 1, end_sample); } uint64_t LogicSegment::get_subsample(int level, uint64_t offset) const