X-Git-Url: http://git.code-monkey.de/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Fsegment.cpp;h=2bac00621a0eb2de8dfd15c65f1cdfa5b9f22e4c;hp=9b18c6499a1b32cf03362dc67e835f410acb9159;hb=0df28cd5a727c5e4ff2c46e3258b76936bc0c33d;hpb=85a702806a15852f3684645dffdc38cb30274481

diff --git a/pv/data/segment.cpp b/pv/data/segment.cpp
index 9b18c64..2bac006 100644
--- a/pv/data/segment.cpp
+++ b/pv/data/segment.cpp
@@ -24,6 +24,9 @@
 #include <cstdlib>
 #include <cstring>
 
+#include <QDebug>
+
+using std::bad_alloc;
 using std::lock_guard;
 using std::min;
 using std::recursive_mutex;
@@ -51,7 +54,7 @@ Segment::Segment(uint32_t segment_id, uint64_t samplerate, unsigned int unit_siz
 	chunk_size_ = min(MaxChunkSize, (MaxChunkSize / unit_size_) * unit_size_);
 
 	// Create the initial chunk
-	current_chunk_ = new uint8_t[chunk_size_];
+	current_chunk_ = new uint8_t[chunk_size_ + 7];  /* FIXME +7 is workaround for #1284 */
 	data_chunks_.push_back(current_chunk_);
 	used_samples_ = 0;
 	unused_samples_ = chunk_size_ / unit_size_;
@@ -116,15 +119,17 @@ void Segment::free_unused_memory()
 		return;
 	}
 
-	// No more data will come in, so re-create the last chunk accordingly
-	uint8_t* resized_chunk = new uint8_t[used_samples_ * unit_size_];
-	memcpy(resized_chunk, current_chunk_, used_samples_ * unit_size_);
+	if (current_chunk_) {
+		// No more data will come in, so re-create the last chunk accordingly
+		uint8_t* resized_chunk = new uint8_t[used_samples_ * unit_size_ + 7];  /* FIXME +7 is workaround for #1284 */
+		memcpy(resized_chunk, current_chunk_, used_samples_ * unit_size_);
 
-	delete[] current_chunk_;
-	current_chunk_ = resized_chunk;
+		delete[] current_chunk_;
+		current_chunk_ = resized_chunk;
 
-	data_chunks_.pop_back();
-	data_chunks_.push_back(resized_chunk);
+		data_chunks_.pop_back();
+		data_chunks_.push_back(resized_chunk);
+	}
 }
 
 void Segment::append_single_sample(void *data)
@@ -139,7 +144,7 @@ void Segment::append_single_sample(void *data)
 	unused_samples_--;
 
 	if (unused_samples_ == 0) {
-		current_chunk_ = new uint8_t[chunk_size_];
+		current_chunk_ = new uint8_t[chunk_size_ + 7];  /* FIXME +7 is workaround for #1284 */
 		data_chunks_.push_back(current_chunk_);
 		used_samples_ = 0;
 		unused_samples_ = chunk_size_ / unit_size_;
@@ -177,8 +182,26 @@ void Segment::append_samples(void* data, uint64_t samples)
 		data_offset += (copy_count * unit_size_);
 
 		if (unused_samples_ == 0) {
-			// If we're out of memory, this will throw std::bad_alloc
-			current_chunk_ = new uint8_t[chunk_size_];
+			try {
+				// If we're out of memory, allocating a chunk will throw
+				// std::bad_alloc. To give the application some usable memory
+				// to work with in case chunk allocation fails, we allocate
+				// extra memory and throw it away if it all succeeded.
+				// This way, memory allocation will fail early enough to let
+				// PV remain alive. Otherwise, PV will crash in a random
+				// memory-allocating part of the application.
+				current_chunk_ = new uint8_t[chunk_size_ + 7];  /* FIXME +7 is workaround for #1284 */
+
+				const int dummy_size = 2 * chunk_size_;
+				auto dummy_chunk = new uint8_t[dummy_size];
+				memset(dummy_chunk, 0xFF, dummy_size);
+				delete[] dummy_chunk;
+			} catch (bad_alloc&) {
+				delete[] current_chunk_;  // The new may have succeeded
+				current_chunk_ = nullptr;
+				throw;
+			}
+
 			data_chunks_.push_back(current_chunk_);
 			used_samples_ = 0;
 			unused_samples_ = chunk_size_ / unit_size_;
@@ -219,9 +242,9 @@ void Segment::get_raw_samples(uint64_t start, uint64_t count,
 	}
 }
 
-SegmentRawDataIterator* Segment::begin_raw_sample_iteration(uint64_t start)
+SegmentDataIterator* Segment::begin_sample_iteration(uint64_t start)
 {
-	SegmentRawDataIterator* it = new SegmentRawDataIterator;
+	SegmentDataIterator* it = new SegmentDataIterator;
 
 	assert(start < sample_count_);
 
@@ -231,17 +254,12 @@ SegmentRawDataIterator* Segment::begin_raw_sample_iteration(uint64_t start)
 	it->chunk_num = (start * unit_size_) / chunk_size_;
 	it->chunk_offs = (start * unit_size_) % chunk_size_;
 	it->chunk = data_chunks_[it->chunk_num];
-	it->value = it->chunk + it->chunk_offs;
 
 	return it;
 }
 
-void Segment::continue_raw_sample_iteration(SegmentRawDataIterator* it, uint64_t increase)
+void Segment::continue_sample_iteration(SegmentDataIterator* it, uint64_t increase)
 {
-	// Fail gracefully if we are asked to deliver data we don't have
-	if (it->sample_index > sample_count_)
-		return;
-
 	it->sample_index += increase;
 	it->chunk_offs += (increase * unit_size_);
 
@@ -250,11 +268,9 @@ void Segment::continue_raw_sample_iteration(SegmentRawDataIterator* it, uint64_t
 		it->chunk_offs -= chunk_size_;
 		it->chunk = data_chunks_[it->chunk_num];
 	}
-
-	it->value = it->chunk + it->chunk_offs;
 }
 
-void Segment::end_raw_sample_iteration(SegmentRawDataIterator* it)
+void Segment::end_sample_iteration(SegmentDataIterator* it)
 {
 	delete it;
 
@@ -266,5 +282,19 @@ void Segment::end_raw_sample_iteration(SegmentRawDataIterator* it)
 	}
 }
 
+uint8_t* Segment::get_iterator_value(SegmentDataIterator* it)
+{
+	assert(it->sample_index <= (sample_count_ - 1));
+
+	return (it->chunk + it->chunk_offs);
+}
+
+uint64_t Segment::get_iterator_valid_length(SegmentDataIterator* it)
+{
+	assert(it->sample_index <= (sample_count_ - 1));
+
+	return ((chunk_size_ - it->chunk_offs) / unit_size_);
+}
+
 } // namespace data
 } // namespace pv