using std::make_pair;
using std::make_shared;
using std::min;
+using std::out_of_range;
using std::shared_ptr;
using std::unique_lock;
using pv::data::decode::Annotation;
frame_complete_ = false;
samples_decoded_ = 0;
+ currently_processed_segment_ = 0;
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();
return start_time_;
}
-int64_t DecodeSignal::get_working_sample_count() const
+int64_t DecodeSignal::get_working_sample_count(uint32_t segment_id) const
{
// The working sample count is the highest sample number for
// which all used signals have data available, so go through
// all channels and use the lowest overall sample count of the
// current segment
- // TODO Currently, we assume only a single segment exists
-
int64_t count = std::numeric_limits<int64_t>::max();
bool no_signals_assigned = true;
if (!logic_data || logic_data->logic_segments().empty())
return 0;
- const shared_ptr<LogicSegment> segment = logic_data->logic_segments().front();
- count = min(count, (int64_t)segment->get_sample_count());
+ try {
+ const shared_ptr<LogicSegment> segment = logic_data->logic_segments().at(segment_id);
+ count = min(count, (int64_t)segment->get_sample_count());
+ } catch (out_of_range) {
+ return 0;
+ }
}
return (no_signals_assigned ? 0 : count);
}
-int64_t DecodeSignal::get_decoded_sample_count() const
+int64_t DecodeSignal::get_decoded_sample_count(uint32_t segment_id) const
{
lock_guard<mutex> decode_lock(output_mutex_);
- return samples_decoded_;
+
+ int64_t result = 0;
+
+ if (segment_id == currently_processed_segment_)
+ result = samples_decoded_;
+ else
+ if (segment_id < currently_processed_segment_)
+ // Segment was already decoded fully
+ result = get_working_sample_count(segment_id);
+ else
+ // Segment wasn't decoded at all yet
+ result = 0;
+
+ return result;
}
vector<Row> DecodeSignal::visible_rows() const
{
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);
}
// Include the newly created decode channels in the channel lists
update_channel_list();
- commit_decoder_channels();
break;
}
}
settings.endGroup();
}
+ // Update the internal structures
+ update_channel_list();
+ commit_decoder_channels();
+
begin_decode();
}
dec->set_channels(channel_list);
}
+
+ // Channel bit IDs must be in sync with the channel's apperance in channels_
+ int id = 0;
+ for (data::DecodeChannel &ch : channels_)
+ if (ch.assigned_signal)
+ ch.bit_id = id++;
}
void DecodeSignal::mux_logic_samples(const int64_t start, const int64_t end)
vector<uint8_t> signal_in_bytepos;
vector<uint8_t> signal_in_bitpos;
- int id = 0;
for (data::DecodeChannel &ch : channels_)
if (ch.assigned_signal) {
- ch.bit_id = id++;
-
const shared_ptr<Logic> logic_data = ch.assigned_signal->logic_data();
const shared_ptr<LogicSegment> segment = logic_data->logic_segments().front();
segments.push_back(segment);
void DecodeSignal::logic_mux_proc()
{
do {
- const uint64_t input_sample_count = get_working_sample_count();
+ const uint64_t input_sample_count = get_working_sample_count(currently_processed_segment_);
const uint64_t output_sample_count = logic_mux_segment_->get_sample_count();
const uint64_t samples_to_process =
logic_mux_cond_.wait(logic_mux_lock);
}
} while (!logic_mux_interrupt_);
-
- // No more input data and session is stopped, let the decode thread
- // process any pending data, terminate and release the global SRD mutex
- // in order to let other decoders run
- decode_input_cond_.notify_one();
}
void DecodeSignal::query_input_metadata()
}
}
+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);
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 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 = " << format;
assert(false);
projects / pulseview.git / blobdiff