X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=pv%2Fdata%2Fdecoderstack.cpp;h=1c6b3c6b57c792e5c040e62593a0bd8161eef94e;hb=d2899ad580eea569f3b167e8c9ebcb913194c6b6;hp=bc26f9fccf1a93a2acaa38bea1a86621bca53687;hpb=613d097c5af2d12ffd68e2dfab309b518edca1a6;p=pulseview.git diff --git a/pv/data/decoderstack.cpp b/pv/data/decoderstack.cpp index bc26f9f..1c6b3c6 100644 --- a/pv/data/decoderstack.cpp +++ b/pv/data/decoderstack.cpp @@ -20,6 +20,7 @@ #include +#include #include #include @@ -32,11 +33,16 @@ #include #include #include +#include #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 { @@ -47,7 +53,8 @@ const int64_t DecoderStack::DecodeChunkLength = 4096; mutex DecoderStack::_global_decode_mutex; -DecoderStack::DecoderStack(const srd_decoder *const dec) +DecoderStack::DecoderStack(const srd_decoder *const dec) : + _samples_decoded(0) { _stack.push_back(shared_ptr( new decode::Decoder(dec))); @@ -87,11 +94,33 @@ void DecoderStack::remove(int index) _stack.erase(iter); } -const vector< shared_ptr > - DecoderStack::annotations() const +int64_t DecoderStack::samples_decoded() const +{ + lock_guard decode_lock(_mutex); + return _samples_decoded; +} + +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() @@ -108,7 +137,9 @@ void DecoderStack::begin_decode() _decode_thread.interrupt(); _decode_thread.join(); - _annotations.clear(); + _samples_decoded = 0; + + clear(); // We get the logic data of the first probe in the list. // This works because we are currently assuming all @@ -116,7 +147,7 @@ void DecoderStack::begin_decode() BOOST_FOREACH (const shared_ptr &dec, _stack) if (dec && !dec->probes().empty() && ((logic_signal = (*dec->probes().begin()).second)) && - ((data = logic_signal->data()))) + ((data = logic_signal->logic_data()))) break; if (!data) @@ -124,7 +155,7 @@ void DecoderStack::begin_decode() // Get the samplerate and start time _start_time = data->get_start_time(); - _samplerate = data->get_samplerate(); + _samplerate = data->samplerate(); if (_samplerate == 0.0) _samplerate = 1.0; @@ -132,8 +163,18 @@ void DecoderStack::begin_decode() data); } -void DecoderStack::clear_snapshots() +void DecoderStack::clear() { + _annotations.clear(); + _ann_start_index.clear(); + _ann_end_index.clear(); +} + +uint64_t DecoderStack::get_max_sample_count() const +{ + if (_annotations.empty()) + return 0; + return _annotations.back().end_sample(); } void DecoderStack::decode_proc(shared_ptr data) @@ -151,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) { @@ -165,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; } @@ -186,39 +231,127 @@ 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; } + + { + lock_guard lock(_mutex); + _samples_decoded = chunk_end; + } } // Destroy the session 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 namespace pv::view::decode; + 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; - shared_ptr a(new Annotation(pdata)); lock_guard lock(d->_mutex); + + 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(); }