error_message_ = QString();
rows_.clear();
+ current_rows_= nullptr;
class_rows_.clear();
logic_mux_data_.reset();
logic_mux_data_invalid_ = true;
+
+ decode_reset();
}
void DecodeSignal::begin_decode()
return;
}
- // Add annotation classes
+ // Map out all the annotation classes
for (const shared_ptr<decode::Decoder> &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;
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,
}
}
+ prepare_annotation_segment();
+
// Free the logic data and its segment(s) if it needs to be updated
if (logic_mux_data_invalid_)
logic_mux_data_.reset();
const int64_t ch_count = get_assigned_signal_count();
const int64_t unit_size = (ch_count + 7) / 8;
logic_mux_data_ = make_shared<Logic>(ch_count);
- segment_ = make_shared<LogicSegment>(*logic_mux_data_, unit_size, samplerate_);
- logic_mux_data_->push_segment(segment_);
+ logic_mux_segment_ = make_shared<LogicSegment>(*logic_mux_data_, unit_size, samplerate_);
+ logic_mux_data_->push_segment(logic_mux_segment_);
}
// Make sure the logic output data is complete and up-to-date
{
lock_guard<mutex> lock(output_mutex_);
- const auto iter = rows_.find(row);
- if (iter != rows_.end())
+ if (!current_rows_)
+ return;
+
+ // TODO Instead of current_rows_, use rows_ and the ID of the segment
+
+ const auto iter = current_rows_->find(row);
+ if (iter != current_rows_->end())
(*iter).second.get_annotation_subset(dest,
start_sample, end_sample);
}
}
// Perform the muxing of signal data into the output data
- uint8_t* output = new uint8_t[(end - start) * segment_->unit_size()];
+ uint8_t* output = new uint8_t[(end - start) * logic_mux_segment_->unit_size()];
unsigned int signal_count = signal_data.size();
for (int64_t sample_cnt = 0; sample_cnt < (end - start); sample_cnt++) {
int bitpos = 0;
uint8_t bytepos = 0;
- const int out_sample_pos = sample_cnt * segment_->unit_size();
- for (unsigned int i = 0; i < segment_->unit_size(); i++)
+ const int out_sample_pos = sample_cnt * logic_mux_segment_->unit_size();
+ for (unsigned int i = 0; i < logic_mux_segment_->unit_size(); i++)
output[out_sample_pos + i] = 0;
for (unsigned int i = 0; i < signal_count; i++) {
}
}
- segment_->append_payload(output, (end - start) * segment_->unit_size());
+ logic_mux_segment_->append_payload(output, (end - start) * logic_mux_segment_->unit_size());
delete[] output;
for (const uint8_t* data : signal_data)
{
do {
const uint64_t input_sample_count = get_working_sample_count();
- const uint64_t output_sample_count = segment_->get_sample_count();
+ const uint64_t output_sample_count = logic_mux_segment_->get_sample_count();
const uint64_t samples_to_process =
(input_sample_count > output_sample_count) ?
// Process the samples if necessary...
if (samples_to_process > 0) {
- const uint64_t unit_size = segment_->unit_size();
+ const uint64_t unit_size = logic_mux_segment_->unit_size();
const uint64_t chunk_sample_count = DecodeChunkLength / unit_size;
uint64_t processed_samples = 0;
void DecodeSignal::decode_data(
const int64_t abs_start_samplenum, const int64_t sample_count)
{
- const int64_t unit_size = segment_->unit_size();
+ const int64_t unit_size = logic_mux_segment_->unit_size();
const int64_t chunk_sample_count = DecodeChunkLength / unit_size;
for (int64_t i = abs_start_samplenum;
int64_t data_size = (chunk_end - i) * unit_size;
uint8_t* chunk = new uint8_t[data_size];
- segment_->get_samples(i, chunk_end, chunk);
+ logic_mux_segment_->get_samples(i, chunk_end, chunk);
if (srd_session_send(srd_session_, i, chunk_end, chunk,
data_size, unit_size) != SRD_OK) {
// Keep processing new samples until we exhaust the input data
do {
lock_guard<mutex> input_lock(input_mutex_);
- sample_count = segment_->get_sample_count() - abs_start_samplenum;
+ sample_count = logic_mux_segment_->get_sample_count() - abs_start_samplenum;
if (sample_count > 0) {
decode_data(abs_start_samplenum, sample_count);
}
}
+void DecodeSignal::prepare_annotation_segment()
+{
+ // TODO Won't work for multiple segments
+ rows_.emplace_back(map<const decode::Row, decode::RowData>());
+ current_rows_ = &(rows_.back());
+
+ // Add annotation classes
+ for (const shared_ptr<decode::Decoder> &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)
+ (*current_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
+ (*current_rows_)[row] = decode::RowData();
+ }
+ }
+}
+
void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signal)
{
assert(pdata);
lock_guard<mutex> lock(ds->output_mutex_);
- const decode::Annotation a(pdata);
-
// Find the row
assert(pdata->pdo);
assert(pdata->pdo->di);
const srd_decoder *const decc = pdata->pdo->di->decoder;
assert(decc);
+ assert(ds->current_rows_);
+
+ const srd_proto_data_annotation *const pda =
+ (const srd_proto_data_annotation*)pdata->data;
+ assert(pda);
- auto row_iter = ds->rows_.end();
+ auto row_iter = ds->current_rows_->end();
// Try looking up the sub-row of this class
- const auto r = ds->class_rows_.find(make_pair(decc, a.format()));
+ const auto format = pda->ann_class;
+ const auto r = ds->class_rows_.find(make_pair(decc, format));
if (r != ds->class_rows_.end())
- row_iter = ds->rows_.find((*r).second);
+ row_iter = ds->current_rows_->find((*r).second);
else {
// Failing that, use the decoder as a key
- row_iter = ds->rows_.find(Row(decc));
+ row_iter = ds->current_rows_->find(Row(decc));
}
- assert(row_iter != ds->rows_.end());
- if (row_iter == ds->rows_.end()) {
+ if (row_iter == ds->current_rows_->end()) {
qDebug() << "Unexpected annotation: decoder = " << decc <<
- ", format = " << a.format();
+ ", format = " << format;
assert(false);
return;
}
// Add the annotation
- (*row_iter).second.push_annotation(a);
+ (*row_iter).second.emplace_annotation(pdata);
}
void DecodeSignal::on_capture_state_changed(int state)
projects / pulseview.git / blobdiff