X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=b18d27ff9e8065f796b8434c21808a5568130737;hp=4bc510e9fa538d5eb3a848fde39ea4604520512d;hb=1e4d7c4d21f72aa6b7078e92c0d159d2bd35eb4a;hpb=4b0d7046aded75445a836d0d8c0f687938398f81 diff --git a/pv/session.cpp b/pv/session.cpp index 4bc510e9..b18d27ff 100644 --- a/pv/session.cpp +++ b/pv/session.cpp @@ -26,12 +26,13 @@ #include #include -#ifdef ENABLE_DECODE -#include -#endif +#include +#include +#include -#include "session.hpp" +#include +#include "session.hpp" #include "devicemanager.hpp" #include "data/analog.hpp" @@ -39,25 +40,26 @@ #include "data/decoderstack.hpp" #include "data/logic.hpp" #include "data/logicsegment.hpp" +#include "data/signalbase.hpp" #include "data/decode/decoder.hpp" #include "devices/hardwaredevice.hpp" #include "devices/sessionfile.hpp" +#include "toolbars/mainbar.hpp" + #include "view/analogsignal.hpp" #include "view/decodetrace.hpp" #include "view/logicsignal.hpp" - -#include -#include -#include - -#include - -#include +#include "view/signal.hpp" +#include "view/view.hpp" #include +#ifdef ENABLE_DECODE +#include +#endif + using boost::shared_lock; using boost::shared_mutex; using boost::unique_lock; @@ -93,8 +95,9 @@ using Glib::VariantBase; using Glib::Variant; namespace pv { -Session::Session(DeviceManager &device_manager) : +Session::Session(DeviceManager &device_manager, QString name) : device_manager_(device_manager), + name_(name), capture_state_(Stopped), cur_samplerate_(0) { @@ -128,6 +131,101 @@ shared_ptr Session::device() const return device_; } +QString Session::name() const +{ + return name_; +} + +void Session::set_name(QString name) +{ + if (default_name_.isEmpty()) + default_name_ = name; + + name_ = name; + + name_changed(); +} + +std::shared_ptr Session::main_view() const +{ + return main_view_; +} + +void Session::set_main_bar(std::shared_ptr main_bar) +{ + main_bar_ = main_bar; +} + +shared_ptr Session::main_bar() const +{ + return main_bar_; +} + +void Session::save_settings(QSettings &settings) const +{ + map dev_info; + list key_list; + + if (device_) { + settings.beginGroup("Device"); + key_list.push_back("vendor"); + key_list.push_back("model"); + key_list.push_back("version"); + key_list.push_back("serial_num"); + key_list.push_back("connection_id"); + + dev_info = device_manager_.get_device_info(device_); + + for (string key : key_list) { + if (dev_info.count(key)) + settings.setValue(QString::fromUtf8(key.c_str()), + QString::fromUtf8(dev_info.at(key).c_str())); + else + settings.remove(QString::fromUtf8(key.c_str())); + } + + // TODO Save channel settings and decoders + + settings.endGroup(); + } +} + +void Session::restore_settings(QSettings &settings) +{ + map dev_info; + list key_list; + shared_ptr device; + + // Re-select last used device if possible but only if it's not demo + settings.beginGroup("Device"); + key_list.push_back("vendor"); + key_list.push_back("model"); + key_list.push_back("version"); + key_list.push_back("serial_num"); + key_list.push_back("connection_id"); + + for (string key : key_list) { + const QString k = QString::fromStdString(key); + if (!settings.contains(k)) + continue; + + const string value = settings.value(k).toString().toStdString(); + if (!value.empty()) + dev_info.insert(std::make_pair(key, value)); + } + + if (dev_info.count("model") > 0) + device = device_manager_.find_device_from_info(dev_info); + + if (device) { + set_device(device); + + // TODO Restore channel settings and decoders + } + + settings.endGroup(); +} + void Session::set_device(shared_ptr device) { assert(device); @@ -140,8 +238,21 @@ void Session::set_device(shared_ptr device) device_.reset(); - // Remove all traces - signals_.clear(); + // Revert name back to default name (e.g. "Untitled-1") as the data is gone + name_ = default_name_; + name_changed(); + + // Remove all stored data + for (std::shared_ptr view : views_) { + view->clear_signals(); +#ifdef ENABLE_DECODE + view->clear_decode_traces(); +#endif + } + for (const shared_ptr d : all_signal_data_) + d->clear(); + all_signal_data_.clear(); + signalbases_.clear(); cur_logic_segment_.reset(); for (auto entry : cur_analog_segments_) { @@ -150,12 +261,19 @@ void Session::set_device(shared_ptr device) } logic_data_.reset(); - decode_traces_.clear(); signals_changed(); device_ = std::move(device); - device_->open(); + + try { + device_->open(); + } catch (const QString &e) { + device_.reset(); + device_selected(); + throw; + } + device_->session()->add_datafeed_callback([=] (shared_ptr device, shared_ptr packet) { data_feed_in(device, packet); @@ -189,10 +307,14 @@ Session::capture_state Session::get_capture_state() const void Session::start_capture(function error_handler) { + if (!device_) { + error_handler(tr("No active device set, can't start acquisition.")); + return; + } + stop_capture(); // Check that at least one channel is enabled - assert(device_); const shared_ptr sr_dev = device_->device(); if (sr_dev) { const auto channels = sr_dev->channels(); @@ -205,13 +327,16 @@ void Session::start_capture(function error_handler) } // Clear signal data - for (const shared_ptr d : get_data()) + for (const shared_ptr d : all_signal_data_) d->clear(); + // Revert name back to default name (e.g. "Untitled-1") as the data is gone + name_ = default_name_; + name_changed(); + // Begin the session sampling_thread_ = std::thread( - &Session::sample_thread_proc, this, device_, - error_handler); + &Session::sample_thread_proc, this, error_handler); } void Session::stop_capture() @@ -224,30 +349,43 @@ void Session::stop_capture() sampling_thread_.join(); } -set< shared_ptr > Session::get_data() const +void Session::register_view(std::shared_ptr view) { - shared_lock lock(signals_mutex_); - set< shared_ptr > data; - for (const shared_ptr sig : signals_) { - assert(sig); - data.insert(sig->data()); + if (views_.empty()) { + main_view_ = view; + } + + views_.insert(view); +} + +void Session::deregister_view(std::shared_ptr view) +{ + views_.erase(view); + + if (views_.empty()) { + main_view_.reset(); + + // Without a view there can be no main bar + main_bar_.reset(); } +} - return data; +bool Session::has_view(std::shared_ptr view) +{ + return views_.find(view) != views_.end(); } double Session::get_samplerate() const { double samplerate = 0.0; - for (const shared_ptr d : get_data()) { + for (const shared_ptr d : all_signal_data_) { assert(d); const vector< shared_ptr > segments = d->segments(); for (const shared_ptr &s : segments) samplerate = std::max(samplerate, s->samplerate()); } - // If there is no sample rate given we use samples as unit if (samplerate == 0.0) samplerate = 1.0; @@ -255,21 +393,19 @@ double Session::get_samplerate() const return samplerate; } -const unordered_set< shared_ptr > Session::signals() const +const std::unordered_set< std::shared_ptr > + Session::signalbases() const { - shared_lock lock(signals_mutex_); - return signals_; + return signalbases_; } #ifdef ENABLE_DECODE bool Session::add_decoder(srd_decoder *const dec) { - map > channels; + map > channels; shared_ptr decoder_stack; try { - lock_guard lock(signals_mutex_); - // Create the decoder decoder_stack = shared_ptr( new data::DecoderStack(*this, dec)); @@ -283,13 +419,12 @@ bool Session::add_decoder(srd_decoder *const dec) // Auto select the initial channels for (const srd_channel *pdch : all_channels) - for (shared_ptr s : signals_) { - shared_ptr l = - dynamic_pointer_cast(s); - if (l && QString::fromUtf8(pdch->name). - toLower().contains( - l->name().toLower())) - channels[pdch] = l; + for (shared_ptr b : signalbases_) { + if (b->type() == ChannelType::LOGIC) { + if (QString::fromUtf8(pdch->name).toLower(). + contains(b->name().toLower())) + channels[pdch] = b; + } } assert(decoder_stack); @@ -298,10 +433,13 @@ bool Session::add_decoder(srd_decoder *const dec) decoder_stack->stack().front()->set_channels(channels); // Create the decode signal - shared_ptr d( - new view::DecodeTrace(*this, decoder_stack, - decode_traces_.size())); - decode_traces_.push_back(d); + shared_ptr signalbase = + shared_ptr(new data::SignalBase(nullptr)); + + signalbase->set_decoder_stack(decoder_stack); + + for (std::shared_ptr view : views_) + view->add_decode_trace(signalbase); } catch (std::runtime_error e) { return false; } @@ -314,20 +452,10 @@ bool Session::add_decoder(srd_decoder *const dec) return true; } -vector< shared_ptr > Session::get_decode_signals() const -{ - shared_lock lock(signals_mutex_); - return decode_traces_; -} - -void Session::remove_decode_signal(view::DecodeTrace *signal) +void Session::remove_decode_signal(shared_ptr signalbase) { - for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++) - if ((*i).get() == signal) { - decode_traces_.erase(i); - signals_changed(); - return; - } + for (std::shared_ptr view : views_) + view->remove_decode_trace(signalbase); } #endif @@ -348,8 +476,14 @@ void Session::set_capture_state(capture_state state) void Session::update_signals() { if (!device_) { - signals_.clear(); + signalbases_.clear(); logic_data_.reset(); + for (std::shared_ptr view : views_) { + view->clear_signals(); +#ifdef ENABLE_DECODE + view->clear_decode_traces(); +#endif + } return; } @@ -357,8 +491,14 @@ void Session::update_signals() const shared_ptr sr_dev = device_->device(); if (!sr_dev) { - signals_.clear(); + signalbases_.clear(); logic_data_.reset(); + for (std::shared_ptr view : views_) { + view->clear_signals(); +#ifdef ENABLE_DECODE + view->clear_decode_traces(); +#endif + } return; } @@ -383,47 +523,64 @@ void Session::update_signals() } } - // Make the Signals list - { - unique_lock lock(signals_mutex_); - - unordered_set< shared_ptr > prev_sigs(signals_); - signals_.clear(); + // Make the signals list + for (std::shared_ptr view : views_) { + unordered_set< shared_ptr > prev_sigs(view->signals()); + view->clear_signals(); for (auto channel : sr_dev->channels()) { + shared_ptr signalbase; shared_ptr signal; // Find the channel in the old signals const auto iter = std::find_if( prev_sigs.cbegin(), prev_sigs.cend(), [&](const shared_ptr &s) { - return s->channel() == channel; + return s->base()->channel() == channel; }); if (iter != prev_sigs.end()) { // Copy the signal from the old set to the new signal = *iter; - auto logic_signal = dynamic_pointer_cast< - view::LogicSignal>(signal); - if (logic_signal) - logic_signal->set_logic_data( - logic_data_); } else { - // Create a new signal + // Find the signalbase for this channel if possible + signalbase.reset(); + for (const shared_ptr b : signalbases_) + if (b->channel() == channel) + signalbase = b; + switch(channel->type()->id()) { case SR_CHANNEL_LOGIC: + if (!signalbase) { + signalbase = shared_ptr( + new data::SignalBase(channel)); + signalbases_.insert(signalbase); + + all_signal_data_.insert(logic_data_); + signalbase->set_data(logic_data_); + } + signal = shared_ptr( new view::LogicSignal(*this, - device_, channel, - logic_data_)); + device_, signalbase)); + view->add_signal(signal); break; case SR_CHANNEL_ANALOG: { - shared_ptr data( - new data::Analog()); + if (!signalbase) { + signalbase = shared_ptr( + new data::SignalBase(channel)); + signalbases_.insert(signalbase); + + shared_ptr data(new data::Analog()); + all_signal_data_.insert(data); + signalbase->set_data(data); + } + signal = shared_ptr( new view::AnalogSignal( - *this, channel, data)); + *this, signalbase)); + view->add_signal(signal); break; } @@ -432,34 +589,29 @@ void Session::update_signals() break; } } - - assert(signal); - signals_.insert(signal); } } signals_changed(); } -shared_ptr Session::signal_from_channel( - shared_ptr channel) const +shared_ptr Session::signalbase_from_channel( + shared_ptr channel) const { - lock_guard lock(signals_mutex_); - for (shared_ptr sig : signals_) { + for (shared_ptr sig : signalbases_) { assert(sig); if (sig->channel() == channel) return sig; } - return shared_ptr(); + return shared_ptr(); } -void Session::sample_thread_proc(shared_ptr device, - function error_handler) +void Session::sample_thread_proc(function error_handler) { - assert(device); assert(error_handler); - (void)device; + if (!device_) + return; cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); @@ -519,17 +671,19 @@ void Session::feed_in_trigger() // The channel containing most samples should be most accurate uint64_t sample_count = 0; - for (const shared_ptr d : get_data()) { - assert(d); - uint64_t temp_count = 0; + { + for (const shared_ptr d : all_signal_data_) { + assert(d); + uint64_t temp_count = 0; - const vector< shared_ptr > segments = - d->segments(); - for (const shared_ptr &s : segments) - temp_count += s->get_sample_count(); + const vector< shared_ptr > segments = + d->segments(); + for (const shared_ptr &s : segments) + temp_count += s->get_sample_count(); - if (temp_count > sample_count) - sample_count = temp_count; + if (temp_count > sample_count) + sample_count = temp_count; + } } trigger_event(sample_count / get_samplerate()); @@ -587,7 +741,7 @@ void Session::feed_in_analog(shared_ptr analog) const float *data = static_cast(analog->data_pointer()); bool sweep_beginning = false; - if (signals_.empty()) + if (signalbases_.empty()) update_signals(); for (auto channel : channels) { @@ -611,12 +765,10 @@ void Session::feed_in_analog(shared_ptr analog) cur_analog_segments_[channel] = segment; // Find the analog data associated with the channel - shared_ptr sig = - dynamic_pointer_cast( - signal_from_channel(channel)); - assert(sig); + shared_ptr base = signalbase_from_channel(channel); + assert(base); - shared_ptr data(sig->analog_data()); + shared_ptr data(base->analog_data()); assert(data); // Push the segment into the analog data.