X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Flogicsnapshot.cpp;h=a00a22ede0cd33ee5aa3b43042f51b59c37d8376;hp=d32274b3322cb4b02808343dad61f92afee57774;hb=e8d009288de28cb194bc7964f96677c2baf900c9;hpb=ed990f118d154cd487261d23986b7ad0ba4e24fe diff --git a/pv/data/logicsnapshot.cpp b/pv/data/logicsnapshot.cpp index d32274b3..a00a22ed 100644 --- a/pv/data/logicsnapshot.cpp +++ b/pv/data/logicsnapshot.cpp @@ -25,12 +25,19 @@ #include #include -#include - +#include "config.h" #include "logicsnapshot.h" -using namespace boost; -using namespace std; +#include + +using std::lock_guard; +using std::recursive_mutex; +using std::max; +using std::min; +using std::pair; +using std::shared_ptr; + +using sigrok::Logic; namespace pv { namespace data { @@ -40,10 +47,13 @@ const int LogicSnapshot::MipMapScaleFactor = 1 << MipMapScalePower; const float LogicSnapshot::LogMipMapScaleFactor = logf(MipMapScaleFactor); const uint64_t LogicSnapshot::MipMapDataUnit = 64*1024; // bytes -LogicSnapshot::LogicSnapshot(const sr_datafeed_logic &logic) : - Snapshot(logic.unitsize), +LogicSnapshot::LogicSnapshot(shared_ptr logic, + const uint64_t expected_num_samples) : + Snapshot(logic->unit_size()), _last_append_sample(0) { + set_capacity(expected_num_samples); + lock_guard lock(_mutex); memset(_mip_map, 0, sizeof(_mip_map)); append_payload(logic); @@ -52,19 +62,93 @@ LogicSnapshot::LogicSnapshot(const sr_datafeed_logic &logic) : LogicSnapshot::~LogicSnapshot() { lock_guard lock(_mutex); - BOOST_FOREACH(MipMapLevel &l, _mip_map) + for (MipMapLevel &l : _mip_map) free(l.data); } -void LogicSnapshot::append_payload( - const sr_datafeed_logic &logic) +uint64_t LogicSnapshot::unpack_sample(const uint8_t *ptr) const +{ +#ifdef HAVE_UNALIGNED_LITTLE_ENDIAN_ACCESS + return *(uint64_t*)ptr; +#else + uint64_t value = 0; + switch(_unit_size) { + default: + value |= ((uint64_t)ptr[7]) << 56; + /* FALLTHRU */ + case 7: + value |= ((uint64_t)ptr[6]) << 48; + /* FALLTHRU */ + case 6: + value |= ((uint64_t)ptr[5]) << 40; + /* FALLTHRU */ + case 5: + value |= ((uint64_t)ptr[4]) << 32; + /* FALLTHRU */ + case 4: + value |= ((uint32_t)ptr[3]) << 24; + /* FALLTHRU */ + case 3: + value |= ((uint32_t)ptr[2]) << 16; + /* FALLTHRU */ + case 2: + value |= ptr[1] << 8; + /* FALLTHRU */ + case 1: + value |= ptr[0]; + /* FALLTHRU */ + case 0: + break; + } + return value; +#endif +} + +void LogicSnapshot::pack_sample(uint8_t *ptr, uint64_t value) +{ +#ifdef HAVE_UNALIGNED_LITTLE_ENDIAN_ACCESS + *(uint64_t*)ptr = value; +#else + switch(_unit_size) { + default: + ptr[7] = value >> 56; + /* FALLTHRU */ + case 7: + ptr[6] = value >> 48; + /* FALLTHRU */ + case 6: + ptr[5] = value >> 40; + /* FALLTHRU */ + case 5: + ptr[4] = value >> 32; + /* FALLTHRU */ + case 4: + ptr[3] = value >> 24; + /* FALLTHRU */ + case 3: + ptr[2] = value >> 16; + /* FALLTHRU */ + case 2: + ptr[1] = value >> 8; + /* FALLTHRU */ + case 1: + ptr[0] = value; + /* FALLTHRU */ + case 0: + break; + } +#endif +} + +void LogicSnapshot::append_payload(shared_ptr logic) { - assert(_unit_size == logic.unitsize); - assert((logic.length % _unit_size) == 0); + assert(_unit_size == logic->unit_size()); + assert((logic->data_length() % _unit_size) == 0); lock_guard lock(_mutex); - append_data(logic.data, logic.length / _unit_size); + append_data(logic->data_pointer(), + logic->data_length() / _unit_size); // Generate the first mip-map from the data append_payload_to_mipmap(); @@ -75,15 +159,15 @@ void LogicSnapshot::get_samples(uint8_t *const data, { assert(data); 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 lock(_mutex); const size_t size = (end_sample - start_sample) * _unit_size; - memcpy(data, (const uint8_t*)_data + start_sample, size); + memcpy(data, (const uint8_t*)_data.data() + start_sample * _unit_size, size); } void LogicSnapshot::reallocate_mipmap_level(MipMapLevel &m) @@ -122,9 +206,9 @@ void LogicSnapshot::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 + + const uint8_t *const end_src_ptr = (uint8_t*)_data.data() + m0.length * _unit_size * MipMapScaleFactor; - for (src_ptr = (uint8_t*)_data + + for (src_ptr = (uint8_t*)_data.data() + prev_length * _unit_size * MipMapScaleFactor; src_ptr < end_src_ptr;) { @@ -133,13 +217,13 @@ void LogicSnapshot::append_payload_to_mipmap() diff_counter = MipMapScaleFactor; while (diff_counter-- > 0) { - const uint64_t sample = *(uint64_t*)src_ptr; + const uint64_t sample = unpack_sample(src_ptr); accumulator |= _last_append_sample ^ sample; _last_append_sample = sample; src_ptr += _unit_size; } - *(uint64_t*)dest_ptr = accumulator; + pack_sample(dest_ptr, accumulator); dest_ptr += _unit_size; } @@ -173,21 +257,20 @@ void LogicSnapshot::append_payload_to_mipmap() diff_counter = MipMapScaleFactor; while (diff_counter-- > 0) { - accumulator |= *(uint64_t*)src_ptr; + accumulator |= unpack_sample(src_ptr); src_ptr += _unit_size; } - *(uint64_t*)dest_ptr = accumulator; + pack_sample(dest_ptr, accumulator); } } } uint64_t LogicSnapshot::get_sample(uint64_t index) const { - assert(_data); assert(index < _sample_count); - return *(uint64_t*)((uint8_t*)_data + index * _unit_size); + return unpack_sample((uint8_t*)_data.data() + index * _unit_size); } void LogicSnapshot::get_subsampled_edges( @@ -363,15 +446,17 @@ void LogicSnapshot::get_subsampled_edges( } // Add the final state - edges.push_back(pair(end, - get_sample(end) & sig_mask)); + const bool end_sample = get_sample(end) & sig_mask; + if (last_sample != end_sample) + edges.push_back(pair(end, end_sample)); + edges.push_back(pair(end + 1, end_sample)); } uint64_t LogicSnapshot::get_subsample(int level, uint64_t offset) const { assert(level >= 0); assert(_mip_map[level].data); - return *(uint64_t*)((uint8_t*)_mip_map[level].data + + return unpack_sample((uint8_t*)_mip_map[level].data + _unit_size * offset); }