Introduce views::trace::RowData and everything that comes with it

[pulseview.git] / pv / data / decodesignal.cpp

diff --git a/pv/data/decodesignal.cpp b/pv/data/decodesignal.cpp
index ad5a27a9f254f6c041dcd2d75e8eda252382dbf3..2e9e38b842718f5d5c43e56df8d88525b1cf8461 100644 (file)
--- a/pv/data/decodesignal.cpp
+++ b/pv/data/decodesignal.cpp
@@ -76,7 +76,7 @@ const vector< shared_ptr<Decoder> >& DecodeSignal::decoder_stack() const
        return stack_;
 }
 
-void DecodeSignal::stack_decoder(const srd_decoder *decoder)
+void DecodeSignal::stack_decoder(const srd_decoder *decoder, bool restart_decode)
 {
        assert(decoder);
 
@@ -101,7 +101,8 @@ void DecodeSignal::stack_decoder(const srd_decoder *decoder)
 
        decoder_stacked((void*)dec.get());
 
-       begin_decode();
+       if (restart_decode)
+               begin_decode();
 }
 
 void DecodeSignal::remove_decoder(int index)
@@ -442,20 +443,18 @@ int64_t DecodeSignal::get_decoded_sample_count(uint32_t segment_id,
 
        int64_t result = 0;
 
-       try {
-               const DecodeSegment *segment = &(segments_.at(segment_id));
-               if (include_processing)
-                       result = segment->samples_decoded_incl;
-               else
-                       result = segment->samples_decoded_excl;
-       } catch (out_of_range&) {
-               // Do nothing
-       }
+       if (segment_id >= segments_.size())
+               return result;
+
+       if (include_processing)
+               result = segments_[segment_id].samples_decoded_incl;
+       else
+               result = segments_[segment_id].samples_decoded_excl;
 
        return result;
 }
 
-vector<Row> DecodeSignal::get_rows(bool visible_only) const
+vector<Row> DecodeSignal::get_rows() const
 {
        lock_guard<mutex> lock(output_mutex_);
 
@@ -463,9 +462,6 @@ vector<Row> DecodeSignal::get_rows(bool visible_only) const
 
        for (const shared_ptr<decode::Decoder>& dec : stack_) {
                assert(dec);
-               if (visible_only && !dec->shown())
-                       continue;
-
                const srd_decoder *const decc = dec->decoder();
                assert(dec->decoder());
 
@@ -486,6 +482,23 @@ vector<Row> DecodeSignal::get_rows(bool visible_only) const
        return rows;
 }
 
+uint64_t DecodeSignal::get_annotation_count(const decode::Row &row,
+       uint32_t segment_id) const
+{
+       if (segment_id >= segments_.size())
+               return 0;
+
+       const DecodeSegment *segment = &(segments_.at(segment_id));
+       const map<const decode::Row, decode::RowData> *rows =
+               &(segment->annotation_rows);
+
+       const auto iter = rows->find(row);
+       if (iter != rows->end())
+               return (*iter).second.get_annotation_count();
+
+       return 0;
+}
+
 void DecodeSignal::get_annotation_subset(
        vector<pv::data::decode::Annotation> &dest,
        const decode::Row &row, uint32_t segment_id, uint64_t start_sample,
@@ -493,18 +506,15 @@ void DecodeSignal::get_annotation_subset(
 {
        lock_guard<mutex> lock(output_mutex_);
 
-       try {
-               const DecodeSegment *segment = &(segments_.at(segment_id));
-               const map<const decode::Row, decode::RowData> *rows =
-                       &(segment->annotation_rows);
+       if (segment_id >= segments_.size())
+               return;
 
-               const auto iter = rows->find(row);
-               if (iter != rows->end())
-                       (*iter).second.get_annotation_subset(dest,
-                               start_sample, end_sample);
-       } catch (out_of_range&) {
-               // Do nothing
-       }
+       const DecodeSegment *segment = &(segments_.at(segment_id));
+       const map<const decode::Row, decode::RowData> *rows = &(segment->annotation_rows);
+
+       const auto iter = rows->find(row);
+       if (iter != rows->end())
+               (*iter).second.get_annotation_subset(dest, start_sample, end_sample);
 }
 
 void DecodeSignal::get_annotation_subset(
@@ -513,7 +523,7 @@ void DecodeSignal::get_annotation_subset(
 {
        // Note: We put all vectors and lists on the heap, not the stack
 
-       const vector<Row> rows = get_rows(true);
+       const vector<Row> rows = get_rows();
 
        // Use forward_lists for faster merging
        forward_list<Annotation> *all_ann_list = new forward_list<Annotation>();
@@ -537,6 +547,9 @@ void DecodeSignal::get_annotation_subset(
 uint32_t DecodeSignal::get_binary_data_chunk_count(uint32_t segment_id,
        const Decoder* dec, uint32_t bin_class_id) const
 {
+       if (segments_.size() == 0)
+               return 0;
+
        try {
                const DecodeSegment *segment = &(segments_.at(segment_id));
 
@@ -568,7 +581,7 @@ void DecodeSignal::get_binary_data_chunk(uint32_t segment_id,
        }
 }
 
-void DecodeSignal::get_binary_data_chunks_merged(uint32_t segment_id,
+void DecodeSignal::get_merged_binary_data_chunks_by_sample(uint32_t segment_id,
        const Decoder* dec, uint32_t bin_class_id, uint64_t start_sample,
        uint64_t end_sample, vector<uint8_t> *dest) const
 {
@@ -609,6 +622,48 @@ void DecodeSignal::get_binary_data_chunks_merged(uint32_t segment_id,
        }
 }
 
+void DecodeSignal::get_merged_binary_data_chunks_by_offset(uint32_t segment_id,
+       const data::decode::Decoder* dec, uint32_t bin_class_id, uint64_t start,
+       uint64_t end, vector<uint8_t> *dest) const
+{
+       assert(dest != nullptr);
+
+       try {
+               const DecodeSegment *segment = &(segments_.at(segment_id));
+
+               const DecodeBinaryClass* bin_class = nullptr;
+               for (const DecodeBinaryClass& bc : segment->binary_classes)
+                       if ((bc.decoder == dec) && (bc.info->bin_class_id == bin_class_id))
+                               bin_class = &bc;
+
+               // Determine overall size before copying to resize dest vector only once
+               uint64_t size = 0;
+               uint64_t offset = 0;
+               for (const DecodeBinaryDataChunk& chunk : bin_class->chunks) {
+                       if (offset >= start)
+                               size += chunk.data.size();
+                       offset += chunk.data.size();
+                       if (offset >= end)
+                               break;
+               }
+               dest->resize(size);
+
+               offset = 0;
+               uint64_t dest_offset = 0;
+               for (const DecodeBinaryDataChunk& chunk : bin_class->chunks) {
+                       if (offset >= start) {
+                               memcpy(dest->data() + dest_offset, chunk.data.data(), chunk.data.size());
+                               dest_offset += chunk.data.size();
+                       }
+                       offset += chunk.data.size();
+                       if (offset >= end)
+                               break;
+               }
+       } catch (out_of_range&) {
+               // Do nothing
+       }
+}
+
 const DecodeBinaryClass* DecodeSignal::get_binary_data_class(uint32_t segment_id,
        const data::decode::Decoder* dec, uint32_t bin_class_id) const
 {
@@ -1351,7 +1406,7 @@ void DecodeSignal::create_decode_segment()
 
                for (uint32_t i = 0; i < n; i++)
                        segments_.back().binary_classes.push_back(
-                               {dec.get(), dec->get_binary_class(i), vector<DecodeBinaryDataChunk>()});
+                               {dec.get(), dec->get_binary_class(i), deque<DecodeBinaryDataChunk>()});
        }
 }
 
@@ -1426,7 +1481,7 @@ void DecodeSignal::binary_callback(srd_proto_data *pdata, void *decode_signal)
 
        DecodeBinaryClass* bin_class = nullptr;
        for (DecodeBinaryClass& bc : segment->binary_classes)
-               if ((bc.decoder->decoder() == decc) && (bc.info->bin_class_id == pdb->bin_class))
+               if ((bc.decoder->decoder() == decc) && (bc.info->bin_class_id == (uint32_t)pdb->bin_class))
                        bin_class = &bc;
 
        if (!bin_class) {