X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=3c5bcc426cd750fcca98ab1a56c9b97c70a86009;hp=9c3a2c259e2a635f2eed79f5a8a607a9c33d490c;hb=f4e57597347e47a4ea58fbdc7b0a22e07f1c0ede;hpb=bf0edd2b0cbb5f4bd5d69b0f00bcea7d037e2287 diff --git a/pv/session.cpp b/pv/session.cpp index 9c3a2c25..3c5bcc42 100644 --- a/pv/session.cpp +++ b/pv/session.cpp @@ -26,12 +26,15 @@ #include #include -#ifdef ENABLE_DECODE -#include -#endif +#include -#include "session.hpp" +#include +#include +#include + +#include +#include "session.hpp" #include "devicemanager.hpp" #include "data/analog.hpp" @@ -45,20 +48,20 @@ #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; @@ -94,8 +97,10 @@ using Glib::VariantBase; using Glib::Variant; namespace pv { -Session::Session(DeviceManager &device_manager) : +Session::Session(DeviceManager &device_manager, QString name) : device_manager_(device_manager), + default_name_(name), + name_(name), capture_state_(Stopped), cur_samplerate_(0) { @@ -129,6 +134,221 @@ 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(); +} + +const std::list< std::shared_ptr > Session::views() const +{ + return views_; +} + +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; + int stacks = 0, views = 0; + + if (device_) { + shared_ptr hw_device = + dynamic_pointer_cast< devices::HardwareDevice >(device_); + + if (hw_device) { + settings.setValue("device_type", "hardware"); + 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())); + } + + settings.endGroup(); + } + + shared_ptr sessionfile_device = + dynamic_pointer_cast< devices::SessionFile >(device_); + + if (sessionfile_device) { + settings.setValue("device_type", "sessionfile"); + settings.beginGroup("device"); + settings.setValue("filename", QString::fromStdString( + sessionfile_device->full_name())); + settings.endGroup(); + } + + // Save channels and decoders + for (shared_ptr base : signalbases_) { +#ifdef ENABLE_DECODE + if (base->is_decode_signal()) { + shared_ptr decoder_stack = + base->decoder_stack(); + std::shared_ptr top_decoder = + decoder_stack->stack().front(); + + settings.beginGroup("decoder_stack" + QString::number(stacks++)); + settings.setValue("id", top_decoder->decoder()->id); + settings.setValue("name", top_decoder->decoder()->name); + settings.endGroup(); + } else +#endif + { + settings.beginGroup(base->internal_name()); + base->save_settings(settings); + settings.endGroup(); + } + } + + settings.setValue("decoder_stacks", stacks); + + // Save view states and their signal settings + // Note: main_view must be saved as view0 + settings.beginGroup("view" + QString::number(views++)); + main_view_->save_settings(settings); + settings.endGroup(); + + for (shared_ptr view : views_) { + if (view != main_view_) { + settings.beginGroup("view" + QString::number(views++)); + view->save_settings(settings); + settings.endGroup(); + } + } + + settings.setValue("views", views); + } +} + +void Session::restore_settings(QSettings &settings) +{ + shared_ptr device; + + QString device_type = settings.value("device_type").toString(); + + if (device_type == "hardware") { + map dev_info; + list key_list; + + // 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); + + settings.endGroup(); + } + + if (device_type == "sessionfile") { + settings.beginGroup("device"); + QString filename = settings.value("filename").toString(); + settings.endGroup(); + + if (QFileInfo(filename).isReadable()) { + device = std::make_shared(device_manager_.context(), + filename.toStdString()); + set_device(device); + + // TODO Perform error handling + start_capture([](QString infoMessage) { (void)infoMessage; }); + + set_name(QFileInfo(filename).fileName()); + } + } + + if (device) { + // Restore channels + for (shared_ptr base : signalbases_) { + settings.beginGroup(base->internal_name()); + base->restore_settings(settings); + settings.endGroup(); + } + + // Restore decoders +#ifdef ENABLE_DECODE + int stacks = settings.value("decoder_stacks").toInt(); + + for (int i = 0; i < stacks; i++) { + settings.beginGroup("decoder_stack" + QString::number(i++)); + + QString id = settings.value("id").toString(); + add_decoder(srd_decoder_get_by_id(id.toStdString().c_str())); + + settings.endGroup(); + } +#endif + + // Restore views + int views = settings.value("views").toInt(); + + for (int i = 0; i < views; i++) { + settings.beginGroup("view" + QString::number(i)); + + if (i > 0) { + views::ViewType type = (views::ViewType)settings.value("type").toInt(); + add_view(name_, type, this); + views_.back()->restore_settings(settings); + } else + main_view_->restore_settings(settings); + + settings.endGroup(); + } + } +} + void Session::set_device(shared_ptr device) { assert(device); @@ -141,14 +361,21 @@ void Session::set_device(shared_ptr device) device_.reset(); + // Revert name back to default name (e.g. "Untitled-1") as the data is gone + name_ = default_name_; + name_changed(); + // Remove all stored data - signals_.clear(); - { - shared_lock lock(signals_mutex_); - for (const shared_ptr d : all_signal_data_) - d->clear(); + for (std::shared_ptr view : views_) { + view->clear_signals(); +#ifdef ENABLE_DECODE + view->clear_decode_signals(); +#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_) { @@ -157,7 +384,6 @@ void Session::set_device(shared_ptr device) } logic_data_.reset(); - decode_traces_.clear(); signals_changed(); @@ -167,7 +393,7 @@ void Session::set_device(shared_ptr device) device_->open(); } catch (const QString &e) { device_.reset(); - device_selected(); + device_changed(); throw; } @@ -177,7 +403,7 @@ void Session::set_device(shared_ptr device) }); update_signals(); - device_selected(); + device_changed(); } void Session::set_default_device() @@ -224,11 +450,12 @@ void Session::start_capture(function error_handler) } // Clear signal data - { - shared_lock lock(signals_mutex_); - for (const shared_ptr d : all_signal_data_) - d->clear(); - } + 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( @@ -245,19 +472,49 @@ void Session::stop_capture() sampling_thread_.join(); } +void Session::register_view(std::shared_ptr view) +{ + if (views_.empty()) { + main_view_ = view; + } + + views_.push_back(view); + + update_signals(); +} + +void Session::deregister_view(std::shared_ptr view) +{ + views_.remove_if([&](std::shared_ptr v) { + return v == view; }); + + if (views_.empty()) { + main_view_.reset(); + + // Without a view there can be no main bar + main_bar_.reset(); + } +} + +bool Session::has_view(std::shared_ptr view) +{ + for (std::shared_ptr v : views_) + if (v == view) + return true; + + return false; +} + double Session::get_samplerate() const { double samplerate = 0.0; - { - shared_lock lock(signals_mutex_); - 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()); - } + 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) @@ -266,21 +523,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)); @@ -294,13 +549,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( - s->channel()->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); @@ -312,10 +566,11 @@ bool Session::add_decoder(srd_decoder *const dec) shared_ptr signalbase = shared_ptr(new data::SignalBase(nullptr)); - shared_ptr d( - new view::DecodeTrace(*this, signalbase, decoder_stack, - decode_traces_.size())); - decode_traces_.push_back(d); + signalbase->set_decoder_stack(decoder_stack); + signalbases_.insert(signalbase); + + for (std::shared_ptr view : views_) + view->add_decode_signal(signalbase); } catch (std::runtime_error e) { return false; } @@ -328,20 +583,10 @@ bool Session::add_decoder(srd_decoder *const dec) return true; } -vector< shared_ptr > Session::get_decode_signals() const +void Session::remove_decode_signal(shared_ptr signalbase) { - shared_lock lock(signals_mutex_); - return decode_traces_; -} - -void Session::remove_decode_signal(view::DecodeTrace *signal) -{ - 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_signal(signalbase); } #endif @@ -362,8 +607,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_signals(); +#endif + } return; } @@ -371,8 +622,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_signals(); +#endif + } return; } @@ -397,72 +654,86 @@ void Session::update_signals() } } - // Make the Signals list - { - unique_lock lock(signals_mutex_); - - unordered_set< shared_ptr > prev_sigs(signals_); - signals_.clear(); - - 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() == 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 - signalbase = shared_ptr( - new data::SignalBase(channel)); - - switch(channel->type()->id()) { - case SR_CHANNEL_LOGIC: - signal = shared_ptr( - new view::LogicSignal(*this, - device_, signalbase, logic_data_)); - all_signal_data_.insert(logic_data_); - signalbases_.insert(signalbase); - break; - - case SR_CHANNEL_ANALOG: - { - shared_ptr data( - new data::Analog()); - signal = shared_ptr( - new view::AnalogSignal( - *this, signalbase, data)); - all_signal_data_.insert(data); - signalbases_.insert(signalbase); - break; - } - - default: - assert(0); - break; + // Make the signals list + for (std::shared_ptr viewbase : views_) { + views::TraceView::View *trace_view = + qobject_cast(viewbase.get()); + + if (trace_view) { + unordered_set< shared_ptr > + prev_sigs(trace_view->signals()); + trace_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->base()->channel() == channel; + }); + if (iter != prev_sigs.end()) { + // Copy the signal from the old set to the new + signal = *iter; + trace_view->add_signal(signal); + } else { + // 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 views::TraceView::LogicSignal(*this, + device_, signalbase)); + trace_view->add_signal(signal); + break; + + case SR_CHANNEL_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 views::TraceView::AnalogSignal( + *this, signalbase)); + trace_view->add_signal(signal); + break; + } + + default: + assert(0); + break; + } } } - - assert(signal); - signals_.insert(signal); } } signals_changed(); } -shared_ptr Session::signal_from_channel( +shared_ptr Session::signalbase_from_channel( shared_ptr channel) const { for (shared_ptr sig : signalbases_) { @@ -539,7 +810,6 @@ void Session::feed_in_trigger() uint64_t sample_count = 0; { - shared_lock lock(signals_mutex_); for (const shared_ptr d : all_signal_data_) { assert(d); uint64_t temp_count = 0; @@ -609,7 +879,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) { @@ -633,12 +903,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.