Refactored Signal into Trace

[pulseview.git] / pv / sigsession.cpp

diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp
index 80802e5c7123d395edd16fcf46d8515e27c05b2c..cbdbac07c2031d6232af8089bbf51b7f25d403ac 100644 (file)
--- a/pv/sigsession.cpp
+++ b/pv/sigsession.cpp
@@ -79,6 +79,7 @@ void SigSession::set_device(struct sr_dev_inst *sdi)
        if (sdi)
                _device_manager.use_device(sdi, this);
        _sdi = sdi;
+       update_signals();
 }
 
 void SigSession::release_device(struct sr_dev_inst *sdi)
@@ -87,6 +88,7 @@ void SigSession::release_device(struct sr_dev_inst *sdi)
 
        assert(_capture_state == Stopped);
        _sdi = NULL;
+       update_signals();
 }
 
 void SigSession::load_file(const string &name,
@@ -162,8 +164,10 @@ boost::shared_ptr<data::Logic> SigSession::get_data()
 void SigSession::set_capture_state(capture_state state)
 {
        lock_guard<mutex> lock(_sampling_mutex);
+       const bool changed = _capture_state != state;
        _capture_state = state;
-       capture_state_changed(state);
+       if(changed)
+               capture_state_changed(state);
 }
 
 /**
@@ -242,6 +246,98 @@ sr_input* SigSession::load_input_file_format(const string &filename,
        return in;
 }
 
+void SigSession::update_signals()
+{
+       assert(_capture_state == Stopped);
+
+       shared_ptr<view::Signal> signal;
+       unsigned int logic_probe_count = 0;
+       unsigned int analog_probe_count = 0;
+
+       // Detect what data types we will receive
+       if(_sdi) {
+               for (const GSList *l = _sdi->probes; l; l = l->next) {
+                       const sr_probe *const probe = (const sr_probe *)l->data;
+                       if (!probe->enabled)
+                               continue;
+
+                       switch(probe->type) {
+                       case SR_PROBE_LOGIC:
+                               logic_probe_count++;
+                               break;
+
+                       case SR_PROBE_ANALOG:
+                               analog_probe_count++;
+                               break;
+                       }
+               }
+       }
+
+       // Create data containers for the data snapshots
+       {
+               lock_guard<mutex> data_lock(_data_mutex);
+
+               _logic_data.reset();
+               if (logic_probe_count != 0) {
+                       _logic_data.reset(new data::Logic(
+                               logic_probe_count));
+                       assert(_logic_data);
+               }
+
+               _analog_data.reset();
+               if (analog_probe_count != 0) {
+                       _analog_data.reset(new data::Analog());
+                       assert(_analog_data);
+               }
+       }
+
+       // Make the Signals list
+       {
+               lock_guard<mutex> lock(_signals_mutex);
+
+               _signals.clear();
+
+               if(_sdi) {
+                       for (const GSList *l = _sdi->probes; l; l = l->next) {
+                               const sr_probe *const probe =
+                                       (const sr_probe *)l->data;
+                               assert(probe);
+
+                               switch(probe->type) {
+                               case SR_PROBE_LOGIC:
+                                       signal = shared_ptr<view::Signal>(
+                                               new view::LogicSignal(*this, probe,
+                                                       _logic_data));
+                                       break;
+
+                               case SR_PROBE_ANALOG:
+                                       signal = shared_ptr<view::Signal>(
+                                               new view::AnalogSignal(*this, probe,
+                                                       _analog_data));
+                                       break;
+                               }
+
+                               _signals.push_back(signal);
+                       }
+               }
+       }
+
+       signals_changed();
+}
+
+bool SigSession::is_trigger_enabled() const
+{
+       assert(_sdi);
+       for (const GSList *l = _sdi->probes; l; l = l->next) {
+               const sr_probe *const p = (const sr_probe *)l->data;
+               assert(p);
+               if (p->trigger && p->trigger[0] != '\0')
+                       return true;
+       }
+
+       return false;
+}
+
 void SigSession::load_thread_proc(const string name,
        function<void (const QString)> error_handler)
 {
@@ -306,7 +402,7 @@ void SigSession::sample_thread_proc(struct sr_dev_inst *sdi,
                return;
        }
 
-       set_capture_state(Running);
+       set_capture_state(is_trigger_enabled() ? AwaitingTrigger : Running);
 
        sr_session_run();
        sr_session_destroy();
@@ -320,28 +416,8 @@ void SigSession::sample_thread_proc(struct sr_dev_inst *sdi,
 
 void SigSession::feed_in_header(const sr_dev_inst *sdi)
 {
-       shared_ptr<view::Signal> signal;
        GVariant *gvar;
        uint64_t sample_rate = 0;
-       unsigned int logic_probe_count = 0;
-       unsigned int analog_probe_count = 0;
-
-       // Detect what data types we will receive
-       for (const GSList *l = sdi->probes; l; l = l->next) {
-               const sr_probe *const probe = (const sr_probe *)l->data;
-               if (!probe->enabled)
-                       continue;
-
-               switch(probe->type) {
-               case SR_PROBE_LOGIC:
-                       logic_probe_count++;
-                       break;
-
-               case SR_PROBE_ANALOG:
-                       analog_probe_count++;
-                       break;
-               }
-       }
 
        // Read out the sample rate
        if(sdi->driver)
@@ -357,54 +433,10 @@ void SigSession::feed_in_header(const sr_dev_inst *sdi)
                g_variant_unref(gvar);
        }
 
-       // Create data containers for the coming data snapshots
-       {
-               lock_guard<mutex> data_lock(_data_mutex);
-
-               if (logic_probe_count != 0) {
-                       _logic_data.reset(new data::Logic(
-                               logic_probe_count, sample_rate));
-                       assert(_logic_data);
-               }
-
-               if (analog_probe_count != 0) {
-                       _analog_data.reset(new data::Analog(sample_rate));
-                       assert(_analog_data);
-               }
-       }
-
-       // Make the logic probe list
-       {
-               lock_guard<mutex> lock(_signals_mutex);
-
-               _signals.clear();
-
-               for (const GSList *l = sdi->probes; l; l = l->next) {
-                       const sr_probe *const probe =
-                               (const sr_probe *)l->data;
-                       assert(probe);
-                       if (!probe->enabled)
-                               continue;
-
-                       switch(probe->type) {
-                       case SR_PROBE_LOGIC:
-                               signal = shared_ptr<view::Signal>(
-                                       new view::LogicSignal(probe->name,
-                                               _logic_data, probe->index));
-                               break;
-
-                       case SR_PROBE_ANALOG:
-                               signal = shared_ptr<view::Signal>(
-                                       new view::AnalogSignal(probe->name,
-                                               _analog_data, probe->index));
-                               break;
-                       }
-
-                       _signals.push_back(signal);
-               }
-
-               signals_changed();
-       }
+       if(_analog_data)
+               _analog_data->set_samplerate(sample_rate);
+       if(_logic_data)
+               _logic_data->set_samplerate(sample_rate);
 }
 
 void SigSession::feed_in_meta(const sr_dev_inst *sdi,
@@ -438,6 +470,8 @@ void SigSession::feed_in_logic(const sr_datafeed_logic &logic)
 
        if (!_cur_logic_snapshot)
        {
+               set_capture_state(Running);
+
                // Create a new data snapshot
                _cur_logic_snapshot = shared_ptr<data::LogicSnapshot>(
                        new data::LogicSnapshot(logic));
@@ -464,6 +498,8 @@ void SigSession::feed_in_analog(const sr_datafeed_analog &analog)
 
        if (!_cur_analog_snapshot)
        {
+               set_capture_state(Running);
+
                // Create a new data snapshot
                _cur_analog_snapshot = shared_ptr<data::AnalogSnapshot>(
                        new data::AnalogSnapshot(analog));