X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsigsession.cpp;h=f3eb19460593141de7b33740bb94eb2d0e69f4a3;hp=2e49422fb9a60746246c1d858e66234940674426;hb=2acdb232d6bb452cfdfaea3ef5218fb4da592329;hpb=e8d009288de28cb194bc7964f96677c2baf900c9 diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp index 2e49422f..f3eb1946 100644 --- a/pv/sigsession.cpp +++ b/pv/sigsession.cpp @@ -22,20 +22,20 @@ #include #endif -#include "sigsession.h" +#include "sigsession.hpp" -#include "devicemanager.h" +#include "devicemanager.hpp" -#include "data/analog.h" -#include "data/analogsnapshot.h" -#include "data/decoderstack.h" -#include "data/logic.h" -#include "data/logicsnapshot.h" -#include "data/decode/decoder.h" +#include "data/analog.hpp" +#include "data/analogsnapshot.hpp" +#include "data/decoderstack.hpp" +#include "data/logic.hpp" +#include "data/logicsnapshot.hpp" +#include "data/decode/decoder.hpp" -#include "view/analogsignal.h" -#include "view/decodetrace.h" -#include "view/logicsignal.h" +#include "view/analogsignal.hpp" +#include "view/decodetrace.hpp" +#include "view/logicsignal.hpp" #include #include @@ -47,12 +47,16 @@ #include +using boost::shared_lock; +using boost::shared_mutex; +using boost::unique_lock; + using std::dynamic_pointer_cast; using std::function; using std::lock_guard; -using std::mutex; using std::list; using std::map; +using std::mutex; using std::set; using std::shared_ptr; using std::string; @@ -78,17 +82,11 @@ using Glib::VariantBase; using Glib::Variant; namespace pv { - -// TODO: This should not be necessary -shared_ptr SigSession::_sr_session = nullptr; - SigSession::SigSession(DeviceManager &device_manager) : - _device_manager(device_manager), - _capture_state(Stopped) + device_manager_(device_manager), + session_(device_manager.context()->create_session()), + capture_state_(Stopped) { - // TODO: This should not be necessary - _sr_session = device_manager.context()->create_session(); - set_default_device(); } @@ -98,9 +96,24 @@ SigSession::~SigSession() stop_capture(); } -shared_ptr SigSession::get_device() const +DeviceManager& SigSession::device_manager() +{ + return device_manager_; +} + +const DeviceManager& SigSession::device_manager() const +{ + return device_manager_; +} + +const shared_ptr& SigSession::session() const +{ + return session_; +} + +shared_ptr SigSession::device() const { - return _device; + return device_; } void SigSession::set_device(shared_ptr device) @@ -111,30 +124,30 @@ void SigSession::set_device(shared_ptr device) // Are we setting a session device? auto session_device = dynamic_pointer_cast(device); // Did we have a session device selected previously? - auto prev_session_device = dynamic_pointer_cast(_device); + auto prev_session_device = dynamic_pointer_cast(device_); - if (_device) { - _sr_session->remove_datafeed_callbacks(); + if (device_) { + session_->remove_datafeed_callbacks(); if (!prev_session_device) { - _device->close(); - _sr_session->remove_devices(); + device_->close(); + session_->remove_devices(); } } if (session_device) - _sr_session = session_device->parent(); + session_ = session_device->parent(); - _device = device; - _decode_traces.clear(); + device_ = device; + decode_traces_.clear(); if (device) { if (!session_device) { - _sr_session = _device_manager.context()->create_session(); + session_ = device_manager_.context()->create_session(); device->open(); - _sr_session->add_device(device); + session_->add_device(device); } - _sr_session->add_datafeed_callback([=] + session_->add_datafeed_callback([=] (shared_ptr device, shared_ptr packet) { data_feed_in(device, packet); }); @@ -144,21 +157,22 @@ void SigSession::set_device(shared_ptr device) void SigSession::set_file(const string &name) { - _sr_session = _device_manager.context()->load_session(name); - _device = _sr_session->devices()[0]; - _decode_traces.clear(); - _sr_session->add_datafeed_callback([=] + session_ = device_manager_.context()->load_session(name); + device_ = session_->devices()[0]; + decode_traces_.clear(); + session_->add_datafeed_callback([=] (shared_ptr device, shared_ptr packet) { data_feed_in(device, packet); }); - update_signals(_device); + device_manager_.update_display_name(device_); + update_signals(device_); } void SigSession::set_default_device() { shared_ptr default_device; const list< shared_ptr > &devices = - _device_manager.devices(); + device_manager_.devices(); if (!devices.empty()) { // Fall back to the first device in the list. @@ -177,8 +191,8 @@ void SigSession::set_default_device() SigSession::capture_state SigSession::get_capture_state() const { - lock_guard lock(_sampling_mutex); - return _capture_state; + lock_guard lock(sampling_mutex_); + return capture_state_; } void SigSession::start_capture(function error_handler) @@ -186,13 +200,13 @@ void SigSession::start_capture(function error_handler) stop_capture(); // Check that a device instance has been selected. - if (!_device) { + if (!device_) { qDebug() << "No device selected"; return; } // Check that at least one channel is enabled - auto channels = _device->channels(); + auto channels = device_->channels(); bool enabled = std::any_of(channels.begin(), channels.end(), [](shared_ptr channel) { return channel->enabled(); }); @@ -202,26 +216,26 @@ void SigSession::start_capture(function error_handler) } // Begin the session - _sampling_thread = std::thread( - &SigSession::sample_thread_proc, this, _device, + sampling_thread_ = std::thread( + &SigSession::sample_thread_proc, this, device_, error_handler); } void SigSession::stop_capture() { if (get_capture_state() != Stopped) - _sr_session->stop(); + session_->stop(); // Check that sampling stopped - if (_sampling_thread.joinable()) - _sampling_thread.join(); + if (sampling_thread_.joinable()) + sampling_thread_.join(); } set< shared_ptr > SigSession::get_data() const { - lock_guard lock(_signals_mutex); + shared_lock lock(signals_mutex_); set< shared_ptr > data; - for (const shared_ptr sig : _signals) { + for (const shared_ptr sig : signals_) { assert(sig); data.insert(sig->data()); } @@ -229,10 +243,14 @@ set< shared_ptr > SigSession::get_data() const return data; } -vector< shared_ptr > SigSession::get_signals() const +boost::shared_mutex& SigSession::signals_mutex() const { - lock_guard lock(_signals_mutex); - return _signals; + return signals_mutex_; +} + +const vector< shared_ptr >& SigSession::signals() const +{ + return signals_; } #ifdef ENABLE_DECODE @@ -243,7 +261,7 @@ bool SigSession::add_decoder(srd_decoder *const dec) try { - lock_guard lock(_signals_mutex); + lock_guard lock(signals_mutex_); // Create the decoder decoder_stack = shared_ptr( @@ -258,13 +276,13 @@ bool SigSession::add_decoder(srd_decoder *const dec) // Auto select the initial channels for (const srd_channel *pdch : all_channels) - for (shared_ptr s : _signals) + for (shared_ptr s : signals_) { shared_ptr l = dynamic_pointer_cast(s); if (l && QString::fromUtf8(pdch->name). toLower().contains( - l->get_name().toLower())) + l->name().toLower())) channels[pdch] = l; } @@ -276,8 +294,8 @@ bool SigSession::add_decoder(srd_decoder *const dec) // Create the decode signal shared_ptr d( new view::DecodeTrace(*this, decoder_stack, - _decode_traces.size())); - _decode_traces.push_back(d); + decode_traces_.size())); + decode_traces_.push_back(d); } catch(std::runtime_error e) { @@ -294,16 +312,16 @@ bool SigSession::add_decoder(srd_decoder *const dec) vector< shared_ptr > SigSession::get_decode_signals() const { - lock_guard lock(_signals_mutex); - return _decode_traces; + shared_lock lock(signals_mutex_); + return decode_traces_; } void SigSession::remove_decode_signal(view::DecodeTrace *signal) { - for (auto i = _decode_traces.begin(); i != _decode_traces.end(); i++) + for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++) if ((*i).get() == signal) { - _decode_traces.erase(i); + decode_traces_.erase(i); signals_changed(); return; } @@ -312,9 +330,9 @@ void SigSession::remove_decode_signal(view::DecodeTrace *signal) void SigSession::set_capture_state(capture_state state) { - lock_guard lock(_sampling_mutex); - const bool changed = _capture_state != state; - _capture_state = state; + lock_guard lock(sampling_mutex_); + const bool changed = capture_state_ != state; + capture_state_ = state; if(changed) capture_state_changed(state); } @@ -322,10 +340,10 @@ void SigSession::set_capture_state(capture_state state) void SigSession::update_signals(shared_ptr device) { assert(device); - assert(_capture_state == Stopped); + assert(capture_state_ == Stopped); // Clear the decode traces - _decode_traces.clear(); + decode_traces_.clear(); // Detect what data types we will receive auto channels = device->channels(); @@ -336,21 +354,21 @@ void SigSession::update_signals(shared_ptr device) // Create data containers for the logic data snapshots { - lock_guard data_lock(_data_mutex); + lock_guard data_lock(data_mutex_); - _logic_data.reset(); + logic_data_.reset(); if (logic_channel_count != 0) { - _logic_data.reset(new data::Logic( + logic_data_.reset(new data::Logic( logic_channel_count)); - assert(_logic_data); + assert(logic_data_); } } // Make the Signals list - do { - lock_guard lock(_signals_mutex); + { + unique_lock lock(signals_mutex_); - _signals.clear(); + signals_.clear(); for (auto channel : device->channels()) { shared_ptr signal; @@ -358,7 +376,8 @@ void SigSession::update_signals(shared_ptr device) switch(channel->type()->id()) { case SR_CHANNEL_LOGIC: signal = shared_ptr( - new view::LogicSignal(device, channel, _logic_data)); + new view::LogicSignal(*this, device, + channel, logic_data_)); break; case SR_CHANNEL_ANALOG: @@ -366,7 +385,8 @@ void SigSession::update_signals(shared_ptr device) shared_ptr data( new data::Analog()); signal = shared_ptr( - new view::AnalogSignal(channel, data)); + new view::AnalogSignal( + *this, channel, data)); break; } @@ -376,10 +396,10 @@ void SigSession::update_signals(shared_ptr device) } assert(signal); - _signals.push_back(signal); + signals_.push_back(signal); } - } while(0); + } signals_changed(); } @@ -387,8 +407,8 @@ void SigSession::update_signals(shared_ptr device) shared_ptr SigSession::signal_from_channel( shared_ptr channel) const { - lock_guard lock(_signals_mutex); - for (shared_ptr sig : _signals) { + lock_guard lock(signals_mutex_); + for (shared_ptr sig : signals_) { assert(sig); if (sig->channel() == channel) return sig; @@ -418,20 +438,20 @@ void SigSession::sample_thread_proc(shared_ptr device, read_sample_rate(device); try { - _sr_session->start(); + session_->start(); } catch(Error e) { error_handler(e.what()); return; } - set_capture_state(_sr_session->trigger() ? + set_capture_state(session_->trigger() ? AwaitingTrigger : Running); - _sr_session->run(); + session_->run(); set_capture_state(Stopped); // Confirm that SR_DF_END was received - if (_cur_logic_snapshot) + if (cur_logic_snapshot_) { qDebug("SR_DF_END was not received."); assert(0); @@ -464,21 +484,21 @@ void SigSession::feed_in_meta(shared_ptr device, void SigSession::feed_in_frame_begin() { - if (_cur_logic_snapshot || !_cur_analog_snapshots.empty()) + if (cur_logic_snapshot_ || !cur_analog_snapshots_.empty()) frame_began(); } void SigSession::feed_in_logic(shared_ptr logic) { - lock_guard lock(_data_mutex); + lock_guard lock(data_mutex_); - if (!_logic_data) + if (!logic_data_) { qDebug() << "Unexpected logic packet"; return; } - if (!_cur_logic_snapshot) + if (!cur_logic_snapshot_) { // This could be the first packet after a trigger set_capture_state(Running); @@ -487,15 +507,15 @@ void SigSession::feed_in_logic(shared_ptr logic) uint64_t sample_limit; try { sample_limit = VariantBase::cast_dynamic>( - _device->config_get(ConfigKey::LIMIT_SAMPLES)).get(); + device_->config_get(ConfigKey::LIMIT_SAMPLES)).get(); } catch (Error) { sample_limit = 0; } // Create a new data snapshot - _cur_logic_snapshot = shared_ptr( + cur_logic_snapshot_ = shared_ptr( new data::LogicSnapshot(logic, sample_limit)); - _logic_data->push_snapshot(_cur_logic_snapshot); + logic_data_->push_snapshot(cur_logic_snapshot_); // @todo Putting this here means that only listeners querying // for logic will be notified. Currently the only user of @@ -506,7 +526,7 @@ void SigSession::feed_in_logic(shared_ptr logic) else { // Append to the existing data snapshot - _cur_logic_snapshot->append_payload(logic); + cur_logic_snapshot_->append_payload(logic); } data_received(); @@ -514,7 +534,7 @@ void SigSession::feed_in_logic(shared_ptr logic) void SigSession::feed_in_analog(shared_ptr analog) { - lock_guard lock(_data_mutex); + lock_guard lock(data_mutex_); const vector> channels = analog->channels(); const unsigned int channel_count = channels.size(); @@ -528,8 +548,8 @@ void SigSession::feed_in_analog(shared_ptr analog) // Try to get the snapshot of the channel const map< shared_ptr, shared_ptr >:: - iterator iter = _cur_analog_snapshots.find(channel); - if (iter != _cur_analog_snapshots.end()) + iterator iter = cur_analog_snapshots_.find(channel); + if (iter != cur_analog_snapshots_.end()) snapshot = (*iter).second; else { @@ -542,7 +562,7 @@ void SigSession::feed_in_analog(shared_ptr analog) uint64_t sample_limit; try { sample_limit = VariantBase::cast_dynamic>( - _device->config_get(ConfigKey::LIMIT_SAMPLES)).get(); + device_->config_get(ConfigKey::LIMIT_SAMPLES)).get(); } catch (Error) { sample_limit = 0; } @@ -550,7 +570,7 @@ void SigSession::feed_in_analog(shared_ptr analog) // Create a snapshot, keep it in the maps of channels snapshot = shared_ptr( new data::AnalogSnapshot(sample_limit)); - _cur_analog_snapshots[channel] = snapshot; + cur_analog_snapshots_[channel] = snapshot; // Find the annalog data associated with the channel shared_ptr sig = @@ -609,9 +629,9 @@ void SigSession::data_feed_in(shared_ptr device, shared_ptr pack case SR_DF_END: { { - lock_guard lock(_data_mutex); - _cur_logic_snapshot.reset(); - _cur_analog_snapshots.clear(); + lock_guard lock(data_mutex_); + cur_logic_snapshot_.reset(); + cur_analog_snapshots_.clear(); } frame_ended(); break;