Renamed pv::SigSession::_state_mutex to pv::SigSession::_sampling_mutex

[pulseview.git] / pv / sigsession.cpp

diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp
index 580b6796c680f8a76c679dfad20d7ea11640aaa4..adad2c5ee0cc51304f928e92445471d7ef88c2d8 100644 (file)
--- a/pv/sigsession.cpp
+++ b/pv/sigsession.cpp
@@ -47,7 +47,7 @@ SigSession::~SigSession()
 {
        stop_capture();
 
-       if(_sampling_thread.get())
+       if (_sampling_thread.get())
                _sampling_thread->join();
        _sampling_thread.reset();
 
@@ -55,20 +55,16 @@ SigSession::~SigSession()
        _session = NULL;
 }
 
-void SigSession::load_file(const std::string &name)
+void SigSession::load_file(const string &name)
 {
-       if (sr_session_load(name.c_str()) == SR_OK) {
-               /* sigrok session file */
-               sr_session_datafeed_callback_add(data_feed_in_proc);
-               sr_session_start();
-               sr_session_run();
-               sr_session_stop();
-       }
+       stop_capture();
+       _sampling_thread.reset(new boost::thread(
+               &SigSession::load_thread_proc, this, name));
 }
 
 SigSession::capture_state SigSession::get_capture_state() const
 {
-       lock_guard<mutex> lock(_state_mutex);
+       lock_guard<mutex> lock(_sampling_mutex);
        return _capture_state;
 }
 
@@ -85,17 +81,15 @@ void SigSession::start_capture(struct sr_dev_inst *sdi,
 
 void SigSession::stop_capture()
 {
-       if(get_capture_state() == Stopped)
+       if (get_capture_state() == Stopped)
                return;
 
        sr_session_stop();
 
        // Check that sampling stopped
-       if(_sampling_thread.get())
+       if (_sampling_thread.get())
                _sampling_thread->join();
        _sampling_thread.reset();
-
-       _capture_state = Stopped;
 }
 
 vector< shared_ptr<view::Signal> > SigSession::get_signals()
@@ -109,6 +103,35 @@ boost::shared_ptr<LogicData> SigSession::get_data()
        return _logic_data;
 }
 
+void SigSession::set_capture_state(capture_state state)
+{
+       lock_guard<mutex> lock(_sampling_mutex);
+       _capture_state = state;
+       capture_state_changed(state);
+}
+
+void SigSession::load_thread_proc(const string name)
+{
+       if (sr_session_load(name.c_str()) != SR_OK) {
+               qDebug() << "Failed to load file.";
+               return;
+       }
+
+       sr_session_datafeed_callback_add(data_feed_in_proc);
+
+       if (sr_session_start() != SR_OK) {
+               qDebug() << "Failed to start session.";
+               return;
+       }
+
+       set_capture_state(Running);
+
+       sr_session_run();
+       sr_session_stop();
+
+       set_capture_state(Stopped);
+}
+
 void SigSession::sample_thread_proc(struct sr_dev_inst *sdi,
        uint64_t record_length, uint64_t sample_rate)
 {
@@ -140,93 +163,93 @@ void SigSession::sample_thread_proc(struct sr_dev_inst *sdi,
                return;
        }
 
-       {
-               lock_guard<mutex> lock(_state_mutex);
-               _capture_state = Running;
-       }
+       set_capture_state(Running);
 
        sr_session_run();
        sr_session_destroy();
+
+       set_capture_state(Stopped);
 }
 
-void SigSession::data_feed_in(const struct sr_dev_inst *sdi,
-       struct sr_datafeed_packet *packet)
+void SigSession::feed_in_meta_logic(const struct sr_dev_inst *sdi,
+       const sr_datafeed_meta_logic &meta_logic)
 {
        using view::LogicSignal;
 
-       assert(sdi);
-       assert(packet);
-
-       switch (packet->type) {
-       case SR_DF_HEADER:
-       {
-               lock_guard<mutex> lock(_signals_mutex);
-               _signals.clear();
-               break;
-       }
-
-       case SR_DF_META_LOGIC:
-       {
-               assert(packet->payload);
-               const sr_datafeed_meta_logic &meta_logic =
-                       *(sr_datafeed_meta_logic*)packet->payload;
-
        {
                lock_guard<mutex> lock(_data_mutex);
 
-               // Create an empty LogiData for coming data snapshots
+               // Create an empty LogicData for coming data snapshots
                _logic_data.reset(new LogicData(meta_logic));
                assert(_logic_data);
-               if(!_logic_data)
-                       break;
+               if (!_logic_data)
+                       return;
        }
 
        {
                lock_guard<mutex> lock(_signals_mutex);
 
                // Add the signals
-               for (int i = 0; i < meta_logic.num_probes; i++)
-               {
+               for (int i = 0; i < meta_logic.num_probes; i++) {
                        const sr_probe *const probe =
                                (const sr_probe*)g_slist_nth_data(
                                        sdi->probes, i);
-                       if(probe->enabled)
-                       {
+                       if (probe->enabled) {
                                shared_ptr<LogicSignal> signal(
                                        new LogicSignal(probe->name,
-                                               _logic_data,
-                                               probe->index));
+                                               _logic_data, probe->index));
                                _signals.push_back(signal);
                        }
                }
 
                signals_changed();
-               break;
        }
+}
+
+void SigSession::feed_in_logic(const sr_datafeed_logic &logic)
+{
+       lock_guard<mutex> lock(_data_mutex);
+       if (!_cur_logic_snapshot)
+       {
+               // Create a new data snapshot
+               _cur_logic_snapshot = shared_ptr<LogicDataSnapshot>(
+                       new LogicDataSnapshot(logic));
+               _logic_data->push_snapshot(_cur_logic_snapshot);
+       }
+       else
+       {
+               // Append to the existing data snapshot
+               _cur_logic_snapshot->append_payload(logic);
        }
 
-       case SR_DF_LOGIC:
+       data_updated();
+}
+
+
+void SigSession::data_feed_in(const struct sr_dev_inst *sdi,
+       const struct sr_datafeed_packet *packet)
+{
+       assert(sdi);
+       assert(packet);
+
+       switch (packet->type) {
+       case SR_DF_HEADER:
        {
-               lock_guard<mutex> lock(_data_mutex);
+               lock_guard<mutex> lock(_signals_mutex);
+               _signals.clear();
+               break;
+       }
+
+       case SR_DF_META_LOGIC:
                assert(packet->payload);
-               if(!_cur_logic_snapshot)
-               {
-                       // Create a new data snapshot
-                       _cur_logic_snapshot = shared_ptr<LogicDataSnapshot>(
-                               new LogicDataSnapshot(
-                               *(sr_datafeed_logic*)packet->payload));
-                       _logic_data->push_snapshot(_cur_logic_snapshot);
-               }
-               else
-               {
-                       // Append to the existing data snapshot
-                       _cur_logic_snapshot->append_payload(
-                               *(sr_datafeed_logic*)packet->payload);
-               }
+               feed_in_meta_logic(sdi,
+                       *(const sr_datafeed_meta_logic*)packet->payload);
+               break;
 
-               data_updated();
+       case SR_DF_LOGIC:
+               assert(packet->payload);
+               feed_in_logic(*(const sr_datafeed_logic*)packet->payload);
                break;
-       }
 
        case SR_DF_END:
        {
@@ -241,7 +264,7 @@ void SigSession::data_feed_in(const struct sr_dev_inst *sdi,
 }
 
 void SigSession::data_feed_in_proc(const struct sr_dev_inst *sdi,
-       struct sr_datafeed_packet *packet)
+       const struct sr_datafeed_packet *packet)
 {
        assert(_session);
        _session->data_feed_in(sdi, packet);