X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Fdecoderstack.cpp;h=1c6b3c6b57c792e5c040e62593a0bd8161eef94e;hp=c2ae9116856161a94826db1adeadcfe9366d647b;hb=9242129958c996f9ff71da7c7b74d7983b5c59f6;hpb=06e810f29b6e9e3fe8ba8aba5d3823375da9bbb2 diff --git a/pv/data/decoderstack.cpp b/pv/data/decoderstack.cpp index c2ae9116..1c6b3c6b 100644 --- a/pv/data/decoderstack.cpp +++ b/pv/data/decoderstack.cpp @@ -20,6 +20,7 @@ #include +#include #include #include @@ -35,8 +36,13 @@ #include #include -using namespace boost; -using namespace std; +using boost::lock_guard; +using boost::mutex; +using boost::shared_ptr; +using std::deque; +using std::min; +using std::list; +using std::vector; namespace pv { namespace data { @@ -94,10 +100,27 @@ int64_t DecoderStack::samples_decoded() const return _samples_decoded; } -const vector DecoderStack::annotations() const +void DecoderStack::get_annotation_subset( + std::vector &dest, + uint64_t start_sample, uint64_t end_sample) const { lock_guard lock(_mutex); - return _annotations; + + const vector::const_iterator start_iter = + lower_bound(_ann_end_index.begin(), + _ann_end_index.end(), start_sample, + bind(&DecoderStack::index_entry_end_sample_lt, + this, _1, _2)); + + const vector::const_iterator end_iter = + upper_bound(_ann_start_index.begin(), + _ann_start_index.end(), end_sample, + bind(&DecoderStack::index_entry_start_sample_gt, + this, _1, _2)); + + for (vector::const_iterator i = start_iter; + i != _ann_end_index.end() && *i != *end_iter; i++) + dest.push_back(_annotations[*i]); } QString DecoderStack::error_message() @@ -116,7 +139,7 @@ void DecoderStack::begin_decode() _samples_decoded = 0; - _annotations.clear(); + clear(); // We get the logic data of the first probe in the list. // This works because we are currently assuming all @@ -143,6 +166,8 @@ void DecoderStack::begin_decode() void DecoderStack::clear() { _annotations.clear(); + _ann_start_index.clear(); + _ann_end_index.clear(); } uint64_t DecoderStack::get_max_sample_count() const @@ -167,13 +192,17 @@ void DecoderStack::decode_proc(shared_ptr data) const shared_ptr &snapshot = snapshots.front(); - const int64_t sample_count = snapshot->get_sample_count() - 1; + const int64_t sample_count = snapshot->get_sample_count(); + const unsigned int chunk_sample_count = + DecodeChunkLength / snapshot->unit_size(); + + // Clear error message upon every new session run + _error_message = QString(); // Create the session srd_session_new(&session); assert(session); - // Create the decoders BOOST_FOREACH(const shared_ptr &dec, _stack) { @@ -181,7 +210,7 @@ void DecoderStack::decode_proc(shared_ptr data) if (!di) { - _error_message = tr("Failed to initialise decoder"); + _error_message = tr("Failed to create decoder instance"); srd_session_destroy(session); return; } @@ -202,18 +231,19 @@ void DecoderStack::decode_proc(shared_ptr data) srd_session_start(session); for (int64_t i = 0; - !this_thread::interruption_requested() && i < sample_count; - i += DecodeChunkLength) + !boost::this_thread::interruption_requested() && + i < sample_count; + i += chunk_sample_count) { lock_guard decode_lock(_global_decode_mutex); const int64_t chunk_end = min( - i + DecodeChunkLength, sample_count); + i + chunk_sample_count, sample_count); snapshot->get_samples(chunk, i, chunk_end); if (srd_session_send(session, i, i + sample_count, chunk, chunk_end - i) != SRD_OK) { - _error_message = tr("Failed to initialise decoder"); + _error_message = tr("Decoder reported an error"); break; } @@ -227,17 +257,100 @@ void DecoderStack::decode_proc(shared_ptr data) srd_session_destroy(session); } +bool DecoderStack::index_entry_start_sample_gt( + const uint64_t sample, const size_t index) const +{ + assert(index < _annotations.size()); + return _annotations[index].start_sample() > sample; +} + +bool DecoderStack::index_entry_end_sample_lt( + const size_t index, const uint64_t sample) const +{ + assert(index < _annotations.size()); + return _annotations[index].end_sample() < sample; +} + +bool DecoderStack::index_entry_end_sample_gt( + const uint64_t sample, const size_t index) const +{ + assert(index < _annotations.size()); + return _annotations[index].end_sample() > sample; +} + +void DecoderStack::insert_annotation_into_start_index( + const pv::data::decode::Annotation &a, const size_t storage_offset) +{ + vector::iterator i = _ann_start_index.end(); + if (!_ann_start_index.empty() && + _annotations[_ann_start_index.back()].start_sample() > + a.start_sample()) + i = upper_bound(_ann_start_index.begin(), + _ann_start_index.end(), a.start_sample(), + bind(&DecoderStack::index_entry_start_sample_gt, + this, _1, _2)); + + _ann_start_index.insert(i, storage_offset); +} + +void DecoderStack::insert_annotation_into_end_index( + const pv::data::decode::Annotation &a, const size_t storage_offset) +{ + vector::iterator i = _ann_end_index.end(); + if (!_ann_end_index.empty() && + _annotations[_ann_end_index.back()].end_sample() < + a.end_sample()) + i = upper_bound(_ann_end_index.begin(), + _ann_end_index.end(), a.end_sample(), + bind(&DecoderStack::index_entry_end_sample_gt, + this, _1, _2)); + + _ann_end_index.insert(i, storage_offset); +} + void DecoderStack::annotation_callback(srd_proto_data *pdata, void *decoder) { using pv::data::decode::Annotation; + GSList *l, *ll; + int row, ann_class, idx = 0; + struct srd_decoder_annotation_row *ann_row; + struct srd_decoder *decc; + assert(pdata); assert(decoder); DecoderStack *const d = (DecoderStack*)decoder; lock_guard lock(d->_mutex); - d->_annotations.push_back(Annotation(pdata)); + + Annotation a = Annotation(pdata); + + decc = pdata->pdo->di->decoder; + BOOST_FOREACH(const shared_ptr &dec, d->stack()) { + if (dec->decoder() == decc) + break; + idx++; + } + a.set_pd_index(idx); + + for (l = decc->annotation_rows, row = 0; l; l = l->next, row++) + { + ann_row = (struct srd_decoder_annotation_row *)l->data; + + for (ll = ann_row->ann_classes, ann_class = 0; ll; + ll = ll->next, ann_class++) + { + if (GPOINTER_TO_INT(ll->data) == a.format()) + a.set_row(row); + } + } + + const size_t offset = d->_annotations.size(); + d->_annotations.push_back(a); + + d->insert_annotation_into_start_index(a, offset); + d->insert_annotation_into_end_index(a, offset); d->new_decode_data(); }