X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsigsession.cpp;h=e81d36051fa068e361eafb01c18ef3aeee02caaa;hp=80802e5c7123d395edd16fcf46d8515e27c05b2c;hb=e92cd4e4cddac2639c1a5e278124b5bb22ace10f;hpb=0f7849397159791fa0ac35c6065aab99756f7901 diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp index 80802e5c..e81d3605 100644 --- a/pv/sigsession.cpp +++ b/pv/sigsession.cpp @@ -21,15 +21,21 @@ #include "sigsession.h" #include "devicemanager.h" + #include "data/analog.h" #include "data/analogsnapshot.h" +#include "data/decoder.h" #include "data/logic.h" #include "data/logicsnapshot.h" + #include "view/analogsignal.h" +#include "view/decodesignal.h" #include "view/logicsignal.h" #include +#include + #include #include @@ -55,9 +61,7 @@ SigSession::~SigSession() { stop_capture(); - if (_sampling_thread.get()) - _sampling_thread->join(); - _sampling_thread.reset(); + _sampling_thread.join(); if (_sdi) _device_manager.release_device(_sdi); @@ -79,6 +83,7 @@ void SigSession::set_device(struct sr_dev_inst *sdi) if (sdi) _device_manager.use_device(sdi, this); _sdi = sdi; + update_signals(sdi); } void SigSession::release_device(struct sr_dev_inst *sdi) @@ -87,15 +92,48 @@ void SigSession::release_device(struct sr_dev_inst *sdi) assert(_capture_state == Stopped); _sdi = NULL; + update_signals(NULL); } void SigSession::load_file(const string &name, function error_handler) { stop_capture(); - _sampling_thread.reset(new boost::thread( - &SigSession::load_thread_proc, this, name, - error_handler)); + + if (sr_session_load(name.c_str()) == SR_OK) { + GSList *devlist = NULL; + sr_session_dev_list(&devlist); + + if (!devlist || !devlist->data || + sr_session_start() != SR_OK) { + error_handler(tr("Failed to start session.")); + return; + } + + sr_dev_inst *const sdi = (sr_dev_inst*)devlist->data; + g_slist_free(devlist); + + update_signals(sdi); + read_sample_rate(sdi); + + _sampling_thread = boost::thread( + &SigSession::load_session_thread_proc, this, + error_handler); + + } else { + sr_input *in = NULL; + + if (!(in = load_input_file_format(name.c_str(), + error_handler))) + return; + + update_signals(in->sdi); + read_sample_rate(in->sdi); + + _sampling_thread = boost::thread( + &SigSession::load_input_thread_proc, this, + name, in, error_handler); + } } SigSession::capture_state SigSession::get_capture_state() const @@ -130,9 +168,9 @@ void SigSession::start_capture(uint64_t record_length, } // Begin the session - _sampling_thread.reset(new boost::thread( + _sampling_thread = boost::thread( &SigSession::sample_thread_proc, this, _sdi, - record_length, error_handler)); + record_length, error_handler); } void SigSession::stop_capture() @@ -143,12 +181,10 @@ void SigSession::stop_capture() sr_session_stop(); // Check that sampling stopped - if (_sampling_thread.get()) - _sampling_thread->join(); - _sampling_thread.reset(); + _sampling_thread.join(); } -vector< shared_ptr > SigSession::get_signals() +vector< shared_ptr > SigSession::get_signals() const { lock_guard lock(_signals_mutex); return _signals; @@ -159,11 +195,59 @@ boost::shared_ptr SigSession::get_data() return _logic_data; } +bool SigSession::add_decoder(srd_decoder *const dec, + std::map > probes, + GHashTable *options) +{ + try + { + lock_guard lock(_signals_mutex); + + shared_ptr decoder( + new data::Decoder(dec, probes, options)); + shared_ptr d( + new view::DecodeSignal(*this, decoder, + _decode_traces.size())); + _decode_traces.push_back(d); + } + catch(std::runtime_error e) + { + return false; + } + + signals_changed(); + + return true; +} + +vector< shared_ptr > SigSession::get_decode_signals() const +{ + lock_guard lock(_signals_mutex); + return _decode_traces; +} + +void SigSession::remove_decode_signal(view::DecodeSignal *signal) +{ + for (vector< shared_ptr >::iterator i = + _decode_traces.begin(); + i != _decode_traces.end(); + i++) + if ((*i).get() == signal) + { + _decode_traces.erase(i); + signals_changed(); + return; + } +} + void SigSession::set_capture_state(capture_state state) { lock_guard lock(_sampling_mutex); + const bool changed = _capture_state != state; _capture_state = state; - capture_state_changed(state); + if(changed) + capture_state_changed(state); } /** @@ -242,29 +326,157 @@ sr_input* SigSession::load_input_file_format(const string &filename, return in; } -void SigSession::load_thread_proc(const string name, - function error_handler) +void SigSession::update_signals(const sr_dev_inst *const sdi) { - sr_input *in = NULL; + assert(_capture_state == Stopped); - if (sr_session_load(name.c_str()) == SR_OK) { - if (sr_session_start() != SR_OK) { - error_handler(tr("Failed to start session.")); + shared_ptr signal; + unsigned int logic_probe_count = 0; + unsigned int analog_probe_count = 0; + + // Clear the decode traces + _decode_traces.clear(); + + // 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 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 lock(_signals_mutex); + + _signals.clear(); + + if(sdi) { + for (const GSList *l = sdi->probes; l; l = l->next) { + sr_probe *const probe = (sr_probe *)l->data; + assert(probe); + + switch(probe->type) { + case SR_PROBE_LOGIC: + signal = shared_ptr( + new view::LogicSignal(*this, probe, + _logic_data)); + break; + + case SR_PROBE_ANALOG: + signal = shared_ptr( + 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::read_sample_rate(const sr_dev_inst *const sdi) +{ + GVariant *gvar; + uint64_t sample_rate = 0; + + // Read out the sample rate + if(sdi->driver) + { + const int ret = sr_config_get(sdi->driver, + SR_CONF_SAMPLERATE, &gvar, sdi); + if (ret != SR_OK) { + qDebug("Failed to get samplerate\n"); return; } + + sample_rate = g_variant_get_uint64(gvar); + g_variant_unref(gvar); } - else if(!(in = load_input_file_format(name.c_str(), error_handler))) - return; + + if(_analog_data) + _analog_data->set_samplerate(sample_rate); + if(_logic_data) + _logic_data->set_samplerate(sample_rate); +} + +void SigSession::load_session_thread_proc( + function error_handler) +{ + (void)error_handler; + + sr_session_datafeed_callback_add(data_feed_in_proc, NULL); + + set_capture_state(Running); + + sr_session_run(); + + sr_session_destroy(); + set_capture_state(Stopped); + + // Confirm that SR_DF_END was received + assert(!_cur_logic_snapshot); + assert(!_cur_analog_snapshot); +} + +void SigSession::load_input_thread_proc(const string name, + sr_input *in, function error_handler) +{ + (void)error_handler; + + assert(in); + assert(in->format); sr_session_datafeed_callback_add(data_feed_in_proc, NULL); set_capture_state(Running); - if(in) { - assert(in->format); - in->format->loadfile(in, name.c_str()); - } else - sr_session_run(); + in->format->loadfile(in, name.c_str()); sr_session_destroy(); set_capture_state(Stopped); @@ -306,7 +518,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,91 +532,7 @@ void SigSession::sample_thread_proc(struct sr_dev_inst *sdi, void SigSession::feed_in_header(const sr_dev_inst *sdi) { - shared_ptr 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) - { - const int ret = sr_config_get(sdi->driver, - SR_CONF_SAMPLERATE, &gvar, sdi); - if (ret != SR_OK) { - qDebug("Failed to get samplerate\n"); - return; - } - - sample_rate = g_variant_get_uint64(gvar); - g_variant_unref(gvar); - } - - // Create data containers for the coming data snapshots - { - lock_guard 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 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( - new view::LogicSignal(probe->name, - _logic_data, probe->index)); - break; - - case SR_PROBE_ANALOG: - signal = shared_ptr( - new view::AnalogSignal(probe->name, - _analog_data, probe->index)); - break; - } - - _signals.push_back(signal); - } - - signals_changed(); - } + read_sample_rate(sdi); } void SigSession::feed_in_meta(const sr_dev_inst *sdi, @@ -424,6 +552,8 @@ void SigSession::feed_in_meta(const sr_dev_inst *sdi, break; } } + + signals_changed(); } void SigSession::feed_in_logic(const sr_datafeed_logic &logic) @@ -438,6 +568,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( new data::LogicSnapshot(logic)); @@ -464,6 +596,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( new data::AnalogSnapshot(analog));