}
// Map out all the annotation classes
+ int row_index = 0;
for (const shared_ptr<decode::Decoder> &dec : stack_) {
assert(dec);
const srd_decoder *const decc = dec->decoder();
(srd_decoder_annotation_row *)l->data;
assert(ann_row);
- const Row row(decc, ann_row);
+ const Row row(row_index++, decc, ann_row);
for (const GSList *ll = ann_row->ann_classes;
ll; ll = ll->next)
if (ch.assigned_signal)
continue;
+ const QString ch_name = ch.name.toLower();
+
+ shared_ptr<data::SignalBase> match;
for (shared_ptr<data::SignalBase> s : session_.signalbases()) {
- const QString ch_name = ch.name.toLower();
+ if (!s->enabled())
+ continue;
+
const QString s_name = s->name().toLower();
if (s->logic_data() &&
((ch_name.contains(s_name)) || (s_name.contains(ch_name)))) {
- ch.assigned_signal = s.get();
- new_assignment = true;
+ if (!match)
+ match = s;
+ else {
+ // Only replace an existing match if it matches more characters
+ int old_unmatched = ch_name.length() - match->name().length();
+ int new_unmatched = ch_name.length() - s->name().length();
+ if (abs(new_unmatched) < abs(old_unmatched))
+ match = s;
+ }
}
}
+
+ if (match) {
+ ch.assigned_signal = match.get();
+ new_assignment = true;
+ }
}
if (new_assignment) {
return (no_signals_assigned ? 0 : count);
}
-int64_t DecodeSignal::get_decoded_sample_count(uint32_t segment_id) const
+int64_t DecodeSignal::get_decoded_sample_count(uint32_t segment_id,
+ bool include_processing) const
{
lock_guard<mutex> decode_lock(output_mutex_);
try {
const DecodeSegment *segment = &(segments_.at(segment_id));
- result = segment->samples_decoded;
+ if (include_processing)
+ result = segment->samples_decoded_incl;
+ else
+ result = segment->samples_decoded_excl;
} catch (out_of_range&) {
// Do nothing
}
const srd_decoder *const decc = dec->decoder();
assert(dec->decoder());
+ int row_index = 0;
// Add a row for the decoder if it doesn't have a row list
if (!decc->annotation_rows)
- rows.emplace_back(decc);
+ rows.emplace_back(row_index++, 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.emplace_back(decc, ann_row);
+ rows.emplace_back(row_index++, decc, ann_row);
}
}
logic_mux_cond_.wait(logic_mux_lock);
}
}
+
} while (!logic_mux_interrupt_);
}
const int64_t chunk_sample_count = DecodeChunkLength / unit_size;
for (int64_t i = abs_start_samplenum;
- !decode_interrupt_ && (i < (abs_start_samplenum + sample_count));
+ error_message_.isEmpty() && !decode_interrupt_ &&
+ (i < (abs_start_samplenum + sample_count));
i += chunk_sample_count) {
const int64_t chunk_end = min(i + chunk_sample_count,
abs_start_samplenum + sample_count);
+ {
+ lock_guard<mutex> lock(output_mutex_);
+ // Update the sample count showing the samples including currently processed ones
+ segments_.at(current_segment_id_).samples_decoded_incl = chunk_end;
+ }
+
int64_t data_size = (chunk_end - i) * unit_size;
uint8_t* chunk = new uint8_t[data_size];
input_segment->get_samples(i, chunk_end, chunk);
if (srd_session_send(srd_session_, i, chunk_end, chunk,
- data_size, unit_size) != SRD_OK) {
+ data_size, unit_size) != SRD_OK)
set_error_message(tr("Decoder reported an error"));
- delete[] chunk;
- break;
- }
delete[] chunk;
{
lock_guard<mutex> lock(output_mutex_);
- segments_.at(current_segment_id_).samples_decoded = chunk_end;
+ // Now that all samples are processed, the exclusive sample count catches up
+ segments_.at(current_segment_id_).samples_decoded_excl = chunk_end;
}
// Notify the frontend that we processed some data and
void DecodeSignal::start_srd_session()
{
- uint64_t samplerate;
-
// If there were stack changes, the session has been destroyed by now, so if
// it hasn't been destroyed, we can just reset and re-use it
if (srd_session_) {
// and) construction of another decoder stack.
// TODO Reduce redundancy, use a common code path for
- // the meta/cb/start sequence?
+ // the meta/start sequence?
terminate_srd_session();
- srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
- g_variant_new_uint64(segments_.at(current_segment_id_).samplerate));
- srd_pd_output_callback_add(srd_session_, SRD_OUTPUT_ANN,
- DecodeSignal::annotation_callback, this);
+
+ // Metadata is cleared also, so re-set it
+ uint64_t samplerate = 0;
+ if (segments_.size() > 0)
+ samplerate = segments_.at(current_segment_id_).samplerate;
+ if (samplerate)
+ srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
+ g_variant_new_uint64(samplerate));
+ for (const shared_ptr<decode::Decoder> &dec : stack_)
+ dec->apply_all_options();
srd_session_start(srd_session_);
+
return;
}
}
// Start the session
- samplerate = segments_.at(current_segment_id_).samplerate;
- if (samplerate)
+ if (segments_.size() > 0)
srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
- g_variant_new_uint64(samplerate));
+ g_variant_new_uint64(segments_.at(current_segment_id_).samplerate));
srd_pd_output_callback_add(srd_session_, SRD_OUTPUT_ANN,
DecodeSignal::annotation_callback, this);
// have completed their operation, and reduces response time for
// those stacks which still are processing data while the
// application no longer wants them to.
- if (srd_session_)
+ if (srd_session_) {
srd_session_terminate_reset(srd_session_);
+
+ // Metadata is cleared also, so re-set it
+ uint64_t samplerate = 0;
+ if (segments_.size() > 0)
+ samplerate = segments_.at(current_segment_id_).samplerate;
+ if (samplerate)
+ srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
+ g_variant_new_uint64(samplerate));
+ for (const shared_ptr<decode::Decoder> &dec : stack_)
+ dec->apply_all_options();
+ }
}
void DecodeSignal::stop_srd_session()
const srd_decoder *const decc = dec->decoder();
assert(dec->decoder());
+ int row_index = 0;
// Add a row for the decoder if it doesn't have a row list
if (!decc->annotation_rows)
- (segments_.back().annotation_rows)[Row(decc)] =
+ (segments_.back().annotation_rows)[Row(row_index++, decc)] =
decode::RowData();
// Add the decoder rows
(srd_decoder_annotation_row *)l->data;
assert(ann_row);
- const Row row(decc, ann_row);
+ const Row row(row_index++, decc, ann_row);
// Add a new empty row data object
(segments_.back().annotation_rows)[row] =
row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find((*r).second);
else {
// Failing that, use the decoder as a key
- row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find(Row(decc));
+ row_iter = ds->segments_.at(ds->current_segment_id_).annotation_rows.find(Row(0, decc));
}
if (row_iter == ds->segments_.at(ds->current_segment_id_).annotation_rows.end()) {