X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Flogicsnapshot.cpp;h=a1beafb9c4e4e3e3c50a111077e62fd3c2d261d5;hp=e6fd26e33b68f742a8547894487ddf7f719a5bd3;hb=8cb717055ce13a6d6568ff384b3cd3932c41d1b0;hpb=023887ca1d8a104b4bef287b7cea8d403044a41b

diff --git a/pv/data/logicsnapshot.cpp b/pv/data/logicsnapshot.cpp
index e6fd26e3..a1beafb9 100644
--- a/pv/data/logicsnapshot.cpp
+++ b/pv/data/logicsnapshot.cpp
@@ -29,8 +29,11 @@
 
 #include "logicsnapshot.h"
 
-using namespace boost;
-using namespace std;
+using boost::lock_guard;
+using boost::recursive_mutex;
+using std::max;
+using std::min;
+using std::pair;
 
 namespace pv {
 namespace data {
@@ -40,10 +43,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) :
+LogicSnapshot::LogicSnapshot(const sr_datafeed_logic &logic,
+                             const uint64_t expected_num_samples) :
 	Snapshot(logic.unitsize),
 	_last_append_sample(0)
 {
+	set_capacity(expected_num_samples);
+
 	lock_guard<recursive_mutex> lock(_mutex);
 	memset(_mip_map, 0, sizeof(_mip_map));
 	append_payload(logic);
@@ -56,6 +62,72 @@ LogicSnapshot::~LogicSnapshot()
 		free(l.data);
 }
 
+uint64_t LogicSnapshot::unpack_sample(const uint8_t *ptr) const
+{
+	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;
+}
+
+void LogicSnapshot::pack_sample(uint8_t *ptr, uint64_t value)
+{
+	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;
+	}
+}
+
 void LogicSnapshot::append_payload(
 	const sr_datafeed_logic &logic)
 {
@@ -70,6 +142,22 @@ void LogicSnapshot::append_payload(
 	append_payload_to_mipmap();
 }
 
+void LogicSnapshot::get_samples(uint8_t *const data,
+	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);
+	assert(end_sample <= (int64_t)_sample_count);
+	assert(start_sample <= end_sample);
+
+	lock_guard<recursive_mutex> lock(_mutex);
+
+	const size_t size = (end_sample - start_sample) * _unit_size;
+	memcpy(data, (const uint8_t*)_data + start_sample, size);
+}
+
 void LogicSnapshot::reallocate_mipmap_level(MipMapLevel &m)
 {
 	const uint64_t new_data_length = ((m.length + MipMapDataUnit - 1) /
@@ -117,13 +205,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;
 	}
 
@@ -157,11 +245,11 @@ 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);
 		}
 	}
 }
@@ -171,7 +259,7 @@ 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 + index * _unit_size);
 }
 
 void LogicSnapshot::get_subsampled_edges(
@@ -188,7 +276,7 @@ void LogicSnapshot::get_subsampled_edges(
 	assert(start <= end);
 	assert(min_length > 0);
 	assert(sig_index >= 0);
-	assert(sig_index < SR_MAX_NUM_PROBES);
+	assert(sig_index < 64);
 
 	lock_guard<recursive_mutex> lock(_mutex);
 
@@ -347,15 +435,17 @@ void LogicSnapshot::get_subsampled_edges(
 	}
 
 	// Add the final state
-	edges.push_back(pair<int64_t, bool>(end,
-		get_sample(end) & sig_mask));
+	const bool end_sample = get_sample(end) & sig_mask;
+	if (last_sample != end_sample)
+		edges.push_back(pair<int64_t, bool>(end, end_sample));
+	edges.push_back(pair<int64_t, bool>(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);
 }