X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Fdecoderstack.cpp;h=073dcd523ec44146fb067cadd9957d5c523f2d76;hp=645b92f32474d44aafcde927023bc5c4f36fd60b;hb=dd048a7ec035447c051c7937ce04aca5be065b4e;hpb=bc870bcf81b99afcaf4c358f4e68643d1bf4efaf diff --git a/pv/data/decoderstack.cpp b/pv/data/decoderstack.cpp index 645b92f3..073dcd52 100644 --- a/pv/data/decoderstack.cpp +++ b/pv/data/decoderstack.cpp @@ -39,10 +39,16 @@ 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 { @@ -79,8 +85,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()); @@ -99,10 +103,50 @@ int64_t DecoderStack::samples_decoded() const return _samples_decoded; } -const vector 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() @@ -111,6 +155,14 @@ 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; @@ -119,9 +171,38 @@ void DecoderStack::begin_decode() _decode_thread.interrupt(); _decode_thread.join(); - _samples_decoded = 0; + clear(); - _annotations.clear(); + // Add classes + BOOST_FOREACH (const shared_ptr &dec, _stack) + { + assert(dec); + 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[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 @@ -145,16 +226,16 @@ void DecoderStack::begin_decode() data); } -void DecoderStack::clear() -{ - _annotations.clear(); -} - uint64_t DecoderStack::get_max_sample_count() const { - if (_annotations.empty()) - return 0; - return _annotations.back().end_sample(); + 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_proc(shared_ptr data) @@ -176,9 +257,6 @@ void DecoderStack::decode_proc(shared_ptr data) 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); @@ -239,43 +317,45 @@ void DecoderStack::decode_proc(shared_ptr data) 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; + assert(d); 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++) + 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 { - ann_row = (struct srd_decoder_annotation_row *)l->data; + // Failing that, use the decoder as a key + row_iter = d->_rows.find(Row(decc)); + } - 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); - } + assert(row_iter != d->_rows.end()); + if (row_iter == d->_rows.end()) { + qDebug() << "Unexpected annotation: decoder = " << decc << + ", format = " << a.format(); + assert(0); + return; } - d->_annotations.push_back(a); + // Add the annotation + (*row_iter).second.push_annotation(a); d->new_decode_data(); }