Rename 'probe' to 'channel' everywhere.

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

diff --git a/pv/data/decoderstack.cpp b/pv/data/decoderstack.cpp
index f642b11eaf92db972f4c0c01745db0b42ace3b87..5c26371b891f2d856fc04342a435ba3fdd413257 100644 (file)
--- a/pv/data/decoderstack.cpp
+++ b/pv/data/decoderstack.cpp
@@ -20,9 +20,6 @@
 
 #include <libsigrokdecode/libsigrokdecode.h>
 
-#include <boost/foreach.hpp>
-#include <boost/thread/thread.hpp>
-
 #include <stdexcept>
 
 #include <QDebug>
@@ -36,11 +33,10 @@
 #include <pv/sigsession.h>
 #include <pv/view/logicsignal.h>
 
-using boost::lock_guard;
-using boost::mutex;
+using std::lock_guard;
+using std::mutex;
 using boost::optional;
-using boost::shared_ptr;
-using boost::unique_lock;
+using std::unique_lock;
 using std::deque;
 using std::make_pair;
 using std::max;
@@ -48,6 +44,7 @@ using std::min;
 using std::list;
 using std::map;
 using std::pair;
+using std::shared_ptr;
 using std::vector;
 
 using namespace pv::data::decode;
@@ -58,6 +55,7 @@ namespace data {
 const double DecoderStack::DecodeMargin = 1.0;
 const double DecoderStack::DecodeThreshold = 0.2;
 const int64_t DecoderStack::DecodeChunkLength = 4096;
+const unsigned int DecoderStack::DecodeNotifyPeriod = 65536;
 
 mutex DecoderStack::_global_decode_mutex;
 
@@ -82,18 +80,19 @@ DecoderStack::DecoderStack(pv::SigSession &session,
 DecoderStack::~DecoderStack()
 {
        if (_decode_thread.joinable()) {
-               _decode_thread.interrupt();
+               _interrupt = true;
+               _input_cond.notify_one();
                _decode_thread.join();
        }
 }
 
-const std::list< boost::shared_ptr<decode::Decoder> >&
+const std::list< std::shared_ptr<decode::Decoder> >&
 DecoderStack::stack() const
 {
        return _stack;
 }
 
-void DecoderStack::push(boost::shared_ptr<decode::Decoder> decoder)
+void DecoderStack::push(std::shared_ptr<decode::Decoder> decoder)
 {
        assert(decoder);
        _stack.push_back(decoder);
@@ -105,7 +104,7 @@ void DecoderStack::remove(int index)
        assert(index < (int)_stack.size());
 
        // Find the decoder in the stack
-       list< shared_ptr<Decoder> >::iterator iter = _stack.begin();
+       auto iter = _stack.begin();
        for(int i = 0; i < index; i++, iter++)
                assert(iter != _stack.end());
 
@@ -125,7 +124,7 @@ std::vector<Row> DecoderStack::get_visible_rows() const
 
        vector<Row> rows;
 
-       BOOST_FOREACH (const shared_ptr<decode::Decoder> &dec, _stack)
+       for (const shared_ptr<decode::Decoder> &dec : _stack)
        {
                assert(dec);
                if (!dec->shown())
@@ -158,8 +157,7 @@ void DecoderStack::get_annotation_subset(
 {
        lock_guard<mutex> lock(_output_mutex);
 
-       std::map<const Row, decode::RowData>::const_iterator iter =
-               _rows.find(row);
+       const auto iter = _rows.find(row);
        if (iter != _rows.end())
                (*iter).second.get_annotation_subset(dest,
                        start_sample, end_sample);
@@ -187,14 +185,23 @@ void DecoderStack::begin_decode()
        shared_ptr<pv::data::Logic> data;
 
        if (_decode_thread.joinable()) {
-               _decode_thread.interrupt();
+               _interrupt = true;
+               _input_cond.notify_one();
                _decode_thread.join();
        }
 
        clear();
 
+       // Check that all decoders have the required channels
+       for (const shared_ptr<decode::Decoder> &dec : _stack)
+               if (!dec->have_required_channels()) {
+                       _error_message = tr("One or more required channels "
+                               "have not been specified");
+                       return;
+               }
+
        // Add classes
-       BOOST_FOREACH (const shared_ptr<decode::Decoder> &dec, _stack)
+       for (const shared_ptr<decode::Decoder> &dec : _stack)
        {
                assert(dec);
                const srd_decoder *const decc = dec->decoder();
@@ -224,12 +231,12 @@ void DecoderStack::begin_decode()
                }
        }
 
-       // We get the logic data of the first probe in the list.
+       // We get the logic data of the first channel in the list.
        // This works because we are currently assuming all
        // LogicSignals have the same data/snapshot
-       BOOST_FOREACH (const shared_ptr<decode::Decoder> &dec, _stack)
-               if (dec && !dec->probes().empty() &&
-                       ((logic_signal = (*dec->probes().begin()).second)) &&
+       for (const shared_ptr<decode::Decoder> &dec : _stack)
+               if (dec && !dec->channels().empty() &&
+                       ((logic_signal = (*dec->channels().begin()).second)) &&
                        ((data = logic_signal->logic_data())))
                        break;
 
@@ -249,15 +256,15 @@ void DecoderStack::begin_decode()
        if (_samplerate == 0.0)
                _samplerate = 1.0;
 
-       _decode_thread = boost::thread(&DecoderStack::decode_proc, this);
+       _interrupt = false;
+       _decode_thread = std::thread(&DecoderStack::decode_proc, this);
 }
 
 uint64_t DecoderStack::get_max_sample_count() const
 {
        uint64_t max_sample_count = 0;
 
-       for (map<const Row, RowData>::const_iterator i = _rows.begin();
-               i != _rows.end(); i++)
+       for (auto i = _rows.cbegin(); i != _rows.end(); i++)
                max_sample_count = max(max_sample_count,
                        (*i).second.get_max_sample());
 
@@ -267,11 +274,10 @@ uint64_t DecoderStack::get_max_sample_count() const
 optional<int64_t> DecoderStack::wait_for_data() const
 {
        unique_lock<mutex> input_lock(_input_mutex);
-       while(!boost::this_thread::interruption_requested() &&
-               !_frame_complete && _samples_decoded >= _sample_count)
+       while(!_interrupt && !_frame_complete &&
+               _samples_decoded >= _sample_count)
                _input_cond.wait(input_lock);
-       return boost::make_optional(
-               !boost::this_thread::interruption_requested() &&
+       return boost::make_optional(!_interrupt &&
                (_samples_decoded < _sample_count || !_frame_complete),
                _sample_count);
 }
@@ -285,9 +291,7 @@ void DecoderStack::decode_data(
        const unsigned int chunk_sample_count =
                DecodeChunkLength / _snapshot->unit_size();
 
-       for (int64_t i = 0;
-               !boost::this_thread::interruption_requested() &&
-                       i < sample_count;
+       for (int64_t i = 0; !_interrupt && i < sample_count;
                i += chunk_sample_count)
        {
                lock_guard<mutex> decode_lock(_global_decode_mutex);
@@ -306,6 +310,9 @@ void DecoderStack::decode_data(
                        lock_guard<mutex> lock(_output_mutex);
                        _samples_decoded = chunk_end;
                }
+
+               if (i % DecodeNotifyPeriod == 0)
+                       new_decode_data();
        }
 
        new_decode_data();
@@ -317,17 +324,8 @@ void DecoderStack::decode_proc()
        srd_session *session;
        srd_decoder_inst *prev_di = NULL;
 
-       assert(data);
        assert(_snapshot);
 
-       // Check that all decoders have the required probes
-       BOOST_FOREACH(const shared_ptr<decode::Decoder> &dec, _stack)
-               if (!dec->have_required_probes()) {
-                       _error_message = tr("One or more required probes "
-                               "have not been specified");
-                       return;
-               }
-
        // Create the session
        srd_session_new(&session);
        assert(session);
@@ -335,7 +333,7 @@ void DecoderStack::decode_proc()
        // Create the decoders
        const unsigned int unit_size = _snapshot->unit_size();
 
-       BOOST_FOREACH(const shared_ptr<decode::Decoder> &dec, _stack)
+       for (const shared_ptr<decode::Decoder> &dec : _stack)
        {
                srd_decoder_inst *const di = dec->create_decoder_inst(session, unit_size);
 
@@ -393,11 +391,10 @@ void DecoderStack::annotation_callback(srd_proto_data *pdata, void *decoder)
        const srd_decoder *const decc = pdata->pdo->di->decoder;
        assert(decc);
 
-       map<const Row, decode::RowData>::iterator row_iter = d->_rows.end();
+       auto row_iter = d->_rows.end();
        
        // Try looking up the sub-row of this class
-       const map<pair<const srd_decoder*, int>, Row>::const_iterator r =
-               d->_class_rows.find(make_pair(decc, a.format()));
+       const auto r = d->_class_rows.find(make_pair(decc, a.format()));
        if (r != d->_class_rows.end())
                row_iter = d->_rows.find((*r).second);
        else
@@ -427,7 +424,8 @@ void DecoderStack::on_data_received()
 {
        {
                unique_lock<mutex> lock(_input_mutex);
-               _sample_count = _snapshot->get_sample_count();
+               if (_snapshot)
+                       _sample_count = _snapshot->get_sample_count();
        }
        _input_cond.notify_one();
 }
@@ -436,7 +434,8 @@ void DecoderStack::on_frame_ended()
 {
        {
                unique_lock<mutex> lock(_input_mutex);
-               _frame_complete = true;
+               if (_snapshot)
+                       _frame_complete = true;
        }
        _input_cond.notify_one();
 }