X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Fdecoderstack.cpp;h=716d778b390c1c344e2a829c53498b4d4e5894f8;hp=d6fa17cafe8b6780239be558eeec88486923c1be;hb=f67d9e9b4b37e62c1ac2edae18c048f3bff5c075;hpb=5dfeb70fc60f1c4752697d8ad6f80e1415213197 diff --git a/pv/data/decoderstack.cpp b/pv/data/decoderstack.cpp index d6fa17ca..716d778b 100644 --- a/pv/data/decoderstack.cpp +++ b/pv/data/decoderstack.cpp @@ -32,11 +32,23 @@ #include #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::make_pair; +using std::max; +using std::min; +using std::list; +using std::map; +using std::pair; +using std::vector; + +using namespace pv::data::decode; namespace pv { namespace data { @@ -47,17 +59,23 @@ const int64_t DecoderStack::DecodeChunkLength = 4096; mutex DecoderStack::_global_decode_mutex; -DecoderStack::DecoderStack(const srd_decoder *const dec) : +DecoderStack::DecoderStack(pv::SigSession &session, + const srd_decoder *const dec) : + _session(session), _samples_decoded(0) { + connect(&_session, SIGNAL(frame_began()), this, SLOT(on_new_frame())); + _stack.push_back(shared_ptr( new decode::Decoder(dec))); } DecoderStack::~DecoderStack() { - _decode_thread.interrupt(); - _decode_thread.join(); + if (_decode_thread.joinable()) { + _decode_thread.interrupt(); + _decode_thread.join(); + } } const std::list< boost::shared_ptr >& @@ -74,8 +92,6 @@ void DecoderStack::push(boost::shared_ptr decoder) void DecoderStack::remove(int index) { - using pv::data::decode::Decoder; - assert(index >= 0); assert(index < (int)_stack.size()); @@ -94,11 +110,50 @@ int64_t DecoderStack::samples_decoded() const return _samples_decoded; } -const vector< shared_ptr > - DecoderStack::annotations() const +std::vector DecoderStack::get_visible_rows() const { lock_guard lock(_mutex); - return _annotations; + + vector rows; + + BOOST_FOREACH (const shared_ptr &dec, _stack) + { + assert(dec); + if (!dec->shown()) + continue; + + const srd_decoder *const decc = dec->decoder(); + assert(dec->decoder()); + + // Add a row for the decoder if it doesn't have a row list + if (!decc->annotation_rows) + rows.push_back(Row(decc)); + + // Add the decoder rows + for (const GSList *l = decc->annotation_rows; l; l = l->next) + { + const srd_decoder_annotation_row *const ann_row = + (srd_decoder_annotation_row *)l->data; + assert(ann_row); + rows.push_back(Row(decc, ann_row)); + } + } + + return rows; +} + +void DecoderStack::get_annotation_subset( + std::vector &dest, + const Row &row, uint64_t start_sample, + uint64_t end_sample) const +{ + lock_guard lock(_mutex); + + std::map::const_iterator iter = + _rows.find(row); + if (iter != _rows.end()) + (*iter).second.get_annotation_subset(dest, + start_sample, end_sample); } QString DecoderStack::error_message() @@ -107,17 +162,56 @@ QString DecoderStack::error_message() return _error_message; } +void DecoderStack::clear() +{ + _samples_decoded = 0; + _error_message = QString(); + _rows.clear(); + _class_rows.clear(); +} + void DecoderStack::begin_decode() { shared_ptr logic_signal; shared_ptr data; - _decode_thread.interrupt(); - _decode_thread.join(); + if (_decode_thread.joinable()) { + _decode_thread.interrupt(); + _decode_thread.join(); + } - _samples_decoded = 0; + clear(); + + // Add classes + BOOST_FOREACH (const shared_ptr &dec, _stack) + { + assert(dec); + const srd_decoder *const decc = dec->decoder(); + assert(dec->decoder()); - _annotations.clear(); + // Add a row for the decoder if it doesn't have a row list + if (!decc->annotation_rows) + _rows[Row(decc)] = decode::RowData(); + + // Add the decoder rows + for (const GSList *l = decc->annotation_rows; l; l = l->next) + { + const srd_decoder_annotation_row *const ann_row = + (srd_decoder_annotation_row *)l->data; + assert(ann_row); + + const Row row(decc, ann_row); + + // Add a new empty row data object + _rows[row] = decode::RowData(); + + // Map out all the classes + for (const GSList *ll = ann_row->ann_classes; + ll; ll = ll->next) + _class_rows[make_pair(decc, + GPOINTER_TO_INT(ll->data))] = row; + } + } // We get the logic data of the first probe in the list. // This works because we are currently assuming all @@ -125,7 +219,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) @@ -133,7 +227,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; @@ -141,40 +235,87 @@ void DecoderStack::begin_decode() data); } -void DecoderStack::clear_snapshots() +uint64_t DecoderStack::get_max_sample_count() const { + uint64_t max_sample_count = 0; + + for (map::const_iterator i = _rows.begin(); + i != _rows.end(); i++) + max_sample_count = max(max_sample_count, + (*i).second.get_max_sample()); + + return max_sample_count; +} + +void DecoderStack::decode_data( + const shared_ptr &snapshot, + srd_session *const session) +{ + uint8_t chunk[DecodeChunkLength]; + + const int64_t sample_count = snapshot->get_sample_count(); + const unsigned int unit_size = snapshot->unit_size(); + const unsigned int chunk_sample_count = + DecodeChunkLength / snapshot->unit_size(); + + for (int64_t i = 0; + !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 + 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) * unit_size) != SRD_OK) { + _error_message = tr("Decoder reported an error"); + break; + } + + { + lock_guard lock(_mutex); + _samples_decoded = chunk_end; + } + } + } void DecoderStack::decode_proc(shared_ptr data) { srd_session *session; - uint8_t chunk[DecodeChunkLength]; srd_decoder_inst *prev_di = NULL; assert(data); + // Check we have a snapshot of data const deque< shared_ptr > &snapshots = data->get_snapshots(); if (snapshots.empty()) return; - const shared_ptr &snapshot = - snapshots.front(); - const int64_t sample_count = snapshot->get_sample_count() - 1; + // Check that all decoders have the required probes + BOOST_FOREACH(const shared_ptr &dec, _stack) + if (!dec->have_required_probes()) + return; // Create the session srd_session_new(&session); assert(session); - // Create the decoders + const shared_ptr &snapshot = snapshots.front(); + const unsigned int unit_size = snapshot->unit_size(); + BOOST_FOREACH(const shared_ptr &dec, _stack) { - srd_decoder_inst *const di = dec->create_decoder_inst(session); + srd_decoder_inst *const di = dec->create_decoder_inst(session, unit_size); if (!di) { - _error_message = tr("Failed to initialise decoder"); + _error_message = tr("Failed to create decoder instance"); srd_session_destroy(session); return; } @@ -194,27 +335,7 @@ 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) - { - lock_guard decode_lock(_global_decode_mutex); - - const int64_t chunk_end = min( - i + DecodeChunkLength, 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"); - break; - } - - { - lock_guard lock(_mutex); - _samples_decoded = chunk_end; - } - } + decode_data(snapshot, session); // Destroy the session srd_session_destroy(session); @@ -222,19 +343,53 @@ void DecoderStack::decode_proc(shared_ptr data) void DecoderStack::annotation_callback(srd_proto_data *pdata, void *decoder) { - using namespace pv::view::decode; - assert(pdata); assert(decoder); DecoderStack *const d = (DecoderStack*)decoder; + assert(d); - shared_ptr a(new Annotation(pdata)); lock_guard lock(d->_mutex); - d->_annotations.push_back(a); + + const Annotation a(pdata); + + // Find the row + assert(pdata->pdo); + assert(pdata->pdo->di); + const srd_decoder *const decc = pdata->pdo->di->decoder; + assert(decc); + + map::iterator row_iter = d->_rows.end(); + + // Try looking up the sub-row of this class + const map, Row>::const_iterator r = + d->_class_rows.find(make_pair(decc, a.format())); + if (r != d->_class_rows.end()) + row_iter = d->_rows.find((*r).second); + else + { + // Failing that, use the decoder as a key + row_iter = d->_rows.find(Row(decc)); + } + + assert(row_iter != d->_rows.end()); + if (row_iter == d->_rows.end()) { + qDebug() << "Unexpected annotation: decoder = " << decc << + ", format = " << a.format(); + assert(0); + return; + } + + // Add the annotation + (*row_iter).second.push_annotation(a); d->new_decode_data(); } +void DecoderStack::on_new_frame() +{ + begin_decode(); +} + } // namespace data } // namespace pv