#include <pv/globalsettings.hpp>
#include <pv/session.hpp>
-using std::forward_list;
using std::lock_guard;
-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;
using pv::data::decode::AnnotationClass;
using pv::data::decode::DecodeChannel;
-using pv::data::decode::Decoder;
-using pv::data::decode::Row;
namespace pv {
namespace data {
if ((stack_.empty()) || ((stack_.size() > 0) && (name() == prev_dec_name)))
set_name(QString::fromUtf8(decoder->name));
- const shared_ptr<Decoder> dec = make_shared<Decoder>(decoder);
+ const shared_ptr<Decoder> dec = make_shared<Decoder>(decoder, stack_.size());
stack_.push_back(dec);
// Include the newly created decode channels in the channel lists
// Toggle decoder visibility
bool state = false;
if (dec) {
- state = !dec->shown();
- dec->show(state);
+ state = !dec->visible();
+ dec->set_visible(state);
}
return state;
void DecodeSignal::reset_decode(bool shutting_down)
{
+ resume_decode(); // Make sure the decode thread isn't blocked by pausing
+
if (stack_config_changed_ || shutting_down)
stop_srd_session();
else
logic_mux_thread_.join();
}
- resume_decode(); // Make sure the decode thread isn't blocked by pausing
-
current_segment_id_ = 0;
segments_.clear();
begin_decode();
}
-double DecodeSignal::samplerate() const
+double DecodeSignal::get_samplerate() const
{
double result = 0;
for (const shared_ptr<Decoder>& dec : stack_) {
assert(dec);
- if (visible_only && !dec->shown())
+ if (visible_only && !dec->visible())
continue;
for (Row* row : dec->get_rows())
for (const shared_ptr<Decoder>& dec : stack_) {
assert(dec);
- if (visible_only && !dec->shown())
+ if (visible_only && !dec->visible())
continue;
for (const Row* row : dec->get_rows())
auto row_it = segment->annotation_rows.find(row);
const RowData* rd;
- if (row_it == segment->annotation_rows.end()) {
- // FIXME Use the fallback row, but how?
- assert(false);
+ if (row_it == segment->annotation_rows.end())
return 0;
- } else
+ else
rd = &(row_it->second);
return rd->get_annotation_count();
}
-void DecodeSignal::get_annotation_subset(vector<Annotation> &dest,
+void DecodeSignal::get_annotation_subset(deque<const Annotation*> &dest,
const Row* row, uint32_t segment_id, uint64_t start_sample,
uint64_t end_sample) const
{
auto row_it = segment->annotation_rows.find(row);
const RowData* rd;
- if (row_it == segment->annotation_rows.end()) {
- // FIXME Use the fallback row, but how?
- assert(false);
+ if (row_it == segment->annotation_rows.end())
return;
- } else
+ else
rd = &(row_it->second);
rd->get_annotation_subset(dest, start_sample, end_sample);
}
-void DecodeSignal::get_annotation_subset(vector<Annotation> &dest,
+void DecodeSignal::get_annotation_subset(deque<const Annotation*> &dest,
uint32_t segment_id, uint64_t start_sample, uint64_t end_sample) const
{
- // Use forward_lists for faster merging
- forward_list<Annotation> *all_ann_list = new forward_list<Annotation>();
-
- vector<const Row*> rows = get_rows();
- for (const Row* row : rows) {
- vector<Annotation> *ann_vector = new vector<Annotation>();
- get_annotation_subset(*ann_vector, row, segment_id, start_sample, end_sample);
-
- forward_list<Annotation> *ann_list =
- new forward_list<Annotation>(ann_vector->begin(), ann_vector->end());
- delete ann_vector;
-
- all_ann_list->merge(*ann_list);
- delete ann_list;
- }
-
- move(all_ann_list->begin(), all_ann_list->end(), back_inserter(dest));
- delete all_ann_list;
+ for (const Row* row : get_rows())
+ get_annotation_subset(dest, row, segment_id, start_sample, end_sample);
}
uint32_t DecodeSignal::get_binary_data_chunk_count(uint32_t segment_id,
return nullptr;
}
+const deque<const Annotation*>* DecodeSignal::get_all_annotations_by_segment(
+ uint32_t segment_id) const
+{
+ try {
+ const DecodeSegment *segment = &(segments_.at(segment_id));
+ return &(segment->all_annotations);
+ } catch (out_of_range&) {
+ // Do nothing
+ }
+
+ return nullptr;
+}
+
void DecodeSignal::save_settings(QSettings &settings) const
{
SignalBase::save_settings(settings);
settings.beginGroup("decoder" + QString::number(decoder_idx++));
settings.setValue("id", decoder->get_srd_decoder()->id);
- settings.setValue("shown", decoder->shown());
+ settings.setValue("visible", decoder->visible());
// Save decoder options
const map<string, GVariant*>& options = decoder->options();
i++;
}
+ // Save row properties
+ i = 0;
+ for (const Row* row : decoder->get_rows()) {
+ settings.beginGroup("row" + QString::number(i));
+ settings.setValue("visible", row->visible());
+ settings.endGroup();
+ i++;
+ }
+
+ // Save class properties
+ i = 0;
+ for (const AnnotationClass* ann_class : decoder->ann_classes()) {
+ settings.beginGroup("ann_class" + QString::number(i));
+ settings.setValue("visible", ann_class->visible);
+ settings.endGroup();
+ i++;
+ }
+
settings.endGroup();
}
continue;
if (QString::fromUtf8(dec->id) == id) {
- shared_ptr<Decoder> decoder = make_shared<Decoder>(dec);
+ shared_ptr<Decoder> decoder = make_shared<Decoder>(dec, stack_.size());
stack_.push_back(decoder);
- decoder->show(settings.value("shown", true).toBool());
+ decoder->set_visible(settings.value("visible", true).toBool());
// Restore decoder options that differ from their default
int options = settings.value("options").toInt();
// Include the newly created decode channels in the channel lists
update_channel_list();
+
+ // Restore row properties
+ int i = 0;
+ for (Row* row : decoder->get_rows()) {
+ settings.beginGroup("row" + QString::number(i));
+ row->set_visible(settings.value("visible", true).toBool());
+ settings.endGroup();
+ i++;
+ }
+
+ // Restore class properties
+ i = 0;
+ for (AnnotationClass* ann_class : decoder->ann_classes()) {
+ settings.beginGroup("ann_class" + QString::number(i));
+ ann_class->visible = settings.value("visible", true).toBool();
+ settings.endGroup();
+ i++;
+ }
+
break;
}
}
// Restore channel mapping
unsigned int channels = settings.value("channels").toInt();
- const unordered_set< shared_ptr<data::SignalBase> > signalbases =
+ const vector< shared_ptr<data::SignalBase> > signalbases =
session_.signalbases();
for (unsigned int channel_id = 0; channel_id < channels; channel_id++) {
void DecodeSignal::create_decode_segment()
{
// Create annotation segment
- segments_.emplace_back(DecodeSegment());
+ segments_.emplace_back();
// Add annotation classes
- for (const shared_ptr<Decoder> dec : stack_)
+ for (const shared_ptr<Decoder>& dec : stack_)
for (Row* row : dec->get_rows())
segments_.back().annotation_rows.emplace(row, RowData(row));
if (ds->decode_interrupt_)
return;
+ if (ds->segments_.empty())
+ return;
+
lock_guard<mutex> lock(ds->output_mutex_);
// Get the decoder and the annotation data
assert(dec);
AnnotationClass* ann_class = dec->get_ann_class_by_id(pda->ann_class);
- assert(ann_class);
+ if (!ann_class) {
+ qWarning() << "Decoder" << ds->display_name() << "wanted to add annotation" <<
+ "with class ID" << pda->ann_class << "but there are only" <<
+ dec->ann_classes().size() << "known classes";
+ return;
+ }
const Row* row = ann_class->row;
if (!row)
row = dec->get_row_by_id(0);
- // Add the annotation
- ds->segments_[ds->current_segment_id_].annotation_rows.at(row).emplace_annotation(pdata);
+ RowData& row_data = ds->segments_[ds->current_segment_id_].annotation_rows.at(row);
+
+ // Add the annotation to the row
+ const Annotation* ann = row_data.emplace_annotation(pdata);
+
+ // We insert the annotation into the global annotation list in a way so that
+ // the annotation list is sorted by start sample and length. Otherwise, we'd
+ // have to sort the model, which is expensive
+ deque<const Annotation*>& all_annotations =
+ ds->segments_[ds->current_segment_id_].all_annotations;
+
+ if (all_annotations.empty()) {
+ all_annotations.emplace_back(ann);
+ } else {
+ const uint64_t new_ann_len = (pdata->end_sample - pdata->start_sample);
+ bool ann_has_earlier_start = (pdata->start_sample < all_annotations.back()->start_sample());
+ bool ann_is_longer = (new_ann_len >
+ (all_annotations.back()->end_sample() - all_annotations.back()->start_sample()));
+
+ if (ann_has_earlier_start && ann_is_longer) {
+ bool ann_has_same_start;
+ auto it = all_annotations.end();
+
+ do {
+ it--;
+ ann_has_earlier_start = (pdata->start_sample < (*it)->start_sample());
+ ann_has_same_start = (pdata->start_sample == (*it)->start_sample());
+ ann_is_longer = (new_ann_len > (*it)->length());
+ } while ((ann_has_earlier_start || (ann_has_same_start && ann_is_longer)) && (it != all_annotations.begin()));
+
+ // Allow inserting at the front
+ if (it != all_annotations.begin())
+ it++;
+
+ all_annotations.emplace(it, ann);
+ } else
+ all_annotations.emplace_back(ann);
+ }
+
+ // When emplace_annotation() inserts instead of appends an annotation,
+ // the pointers in all_annotations that follow the inserted annotation and
+ // point to annotations for this row are off by one and must be updated
+ if (&(row_data.annotations().back()) != ann) {
+ // Search backwards until we find the annotation we just added
+ auto row_it = row_data.annotations().end();
+ auto all_it = all_annotations.end();
+ do {
+ all_it--;
+ if ((*all_it)->row_data() == &row_data)
+ row_it--;
+ } while (&(*row_it) != ann);
+
+ // Update the annotation addresses for this row's annotations until the end
+ do {
+ if ((*all_it)->row_data() == &row_data) {
+ *all_it = &(*row_it);
+ row_it++;
+ }
+ all_it++;
+ } while (all_it != all_annotations.end());
+ }
}
void DecodeSignal::binary_callback(srd_proto_data *pdata, void *decode_signal)