X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=2cdc25f83ed0ee3c718896da9d8df98d13f34876;hp=5e3b492c1ae018c1fe390d7f1f010eb104209203;hb=30d6f09f5eec0fb18d5c87347b5de6124a56a63c;hpb=f65cd27bdbf70644052dd43dac4bbe9403f4dfee diff --git a/pv/session.cpp b/pv/session.cpp index 5e3b492c..2cdc25f8 100644 --- a/pv/session.cpp +++ b/pv/session.cpp @@ -27,12 +27,15 @@ #include "devicemanager.hpp" #include "data/analog.hpp" -#include "data/analogsnapshot.hpp" +#include "data/analogsegment.hpp" #include "data/decoderstack.hpp" #include "data/logic.hpp" -#include "data/logicsnapshot.hpp" +#include "data/logicsegment.hpp" #include "data/decode/decoder.hpp" +#include "devices/hardwaredevice.hpp" +#include "devices/sessionfile.hpp" + #include "view/analogsignal.hpp" #include "view/decodetrace.hpp" #include "view/logicsignal.hpp" @@ -45,7 +48,7 @@ #include -#include +#include using boost::shared_lock; using boost::shared_mutex; @@ -60,6 +63,7 @@ using std::mutex; using std::set; using std::shared_ptr; using std::string; +using std::unordered_set; using std::vector; using sigrok::Analog; @@ -67,9 +71,7 @@ using sigrok::Channel; using sigrok::ChannelType; using sigrok::ConfigKey; using sigrok::DatafeedCallbackFunction; -using sigrok::Device; using sigrok::Error; -using sigrok::HardwareDevice; using sigrok::Header; using sigrok::Logic; using sigrok::Meta; @@ -84,8 +86,8 @@ using Glib::Variant; namespace pv { Session::Session(DeviceManager &device_manager) : device_manager_(device_manager), - session_(device_manager.context()->create_session()), - capture_state_(Stopped) + capture_state_(Stopped), + cur_samplerate_(0) { set_default_device(); } @@ -106,98 +108,52 @@ const DeviceManager& Session::device_manager() const return device_manager_; } -const shared_ptr& Session::session() const +shared_ptr Session::session() const { - return session_; + if (!device_) + return shared_ptr(); + return device_->session(); } -shared_ptr Session::device() const +shared_ptr Session::device() const { return device_; } -void Session::set_device(shared_ptr device) +void Session::set_device(shared_ptr device) { + assert(device); + // Ensure we are not capturing before setting the device stop_capture(); - // 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_); - - if (device_) { - session_->remove_datafeed_callbacks(); - if (!prev_session_device) { - device_->close(); - session_->remove_devices(); - } - } - - if (session_device) - session_ = session_device->parent(); - - decode_traces_.clear(); - - if (device) { - if (!session_device) - { - session_ = device_manager_.context()->create_session(); - - try { - device->open(); - } catch(const sigrok::Error &e) { - throw QString(e.what()); - } - - session_->add_device(device); - } - - device_ = device; - session_->add_datafeed_callback([=] - (shared_ptr device, shared_ptr packet) { - data_feed_in(device, packet); - }); - update_signals(device); - } else - device_ = nullptr; - - device_selected(); -} - -void Session::set_file(const string &name) -{ - session_ = device_manager_.context()->load_session(name); - device_ = session_->devices()[0]; - decode_traces_.clear(); - session_->add_datafeed_callback([=] - (shared_ptr device, shared_ptr packet) { + device_ = std::move(device); + device_->create(); + device_->session()->add_datafeed_callback([=] + (shared_ptr device, shared_ptr packet) { data_feed_in(device, packet); }); - device_manager_.update_display_name(device_); update_signals(device_); + + decode_traces_.clear(); + device_selected(); } void Session::set_default_device() { - shared_ptr default_device; - const list< shared_ptr > &devices = + const list< shared_ptr > &devices = device_manager_.devices(); - if (!devices.empty()) { - // Fall back to the first device in the list. - default_device = devices.front(); - - // Try and find the demo device and select that by default - for (shared_ptr dev : devices) - if (dev->driver()->name().compare("demo") == 0) { - default_device = dev; - break; - } + if (devices.empty()) + return; - set_device(default_device); - } + // Try and find the demo device and select that by default + const auto iter = std::find_if(devices.begin(), devices.end(), + [] (const shared_ptr &d) { + return d->hardware_device()->driver()->name() == + "demo"; }); + set_device((iter == devices.end()) ? devices.front() : *iter); } Session::capture_state Session::get_capture_state() const @@ -210,14 +166,11 @@ void Session::start_capture(function error_handler) { stop_capture(); - // Check that a device instance has been selected. - if (!device_) { - qDebug() << "No device selected"; - return; - } - // Check that at least one channel is enabled - auto channels = device_->channels(); + assert(device_); + const std::shared_ptr device = device_->device(); + assert(device); + auto channels = device->channels(); bool enabled = std::any_of(channels.begin(), channels.end(), [](shared_ptr channel) { return channel->enabled(); }); @@ -235,7 +188,7 @@ void Session::start_capture(function error_handler) void Session::stop_capture() { if (get_capture_state() != Stopped) - session_->stop(); + device_->stop(); // Check that sampling stopped if (sampling_thread_.joinable()) @@ -259,7 +212,7 @@ boost::shared_mutex& Session::signals_mutex() const return signals_mutex_; } -const vector< shared_ptr >& Session::signals() const +const unordered_set< shared_ptr >& Session::signals() const { return signals_; } @@ -348,27 +301,26 @@ void Session::set_capture_state(capture_state state) capture_state_changed(state); } -void Session::update_signals(shared_ptr device) +void Session::update_signals(shared_ptr device) { assert(device); assert(capture_state_ == Stopped); - // Clear the decode traces - decode_traces_.clear(); - // Detect what data types we will receive - auto channels = device->channels(); + auto channels = device->device()->channels(); unsigned int logic_channel_count = std::count_if( channels.begin(), channels.end(), [] (shared_ptr channel) { return channel->type() == ChannelType::LOGIC; }); - // Create data containers for the logic data snapshots + // Create data containers for the logic data segments { lock_guard data_lock(data_mutex_); - logic_data_.reset(); - if (logic_channel_count != 0) { + if (logic_channel_count == 0) { + logic_data_.reset(); + } else if (!logic_data_ || + logic_data_->num_channels() != logic_channel_count) { logic_data_.reset(new data::Logic( logic_channel_count)); assert(logic_data_); @@ -379,37 +331,55 @@ void Session::update_signals(shared_ptr device) { unique_lock lock(signals_mutex_); + unordered_set< shared_ptr > prev_sigs(signals_); signals_.clear(); - for (auto channel : device->channels()) { + for (auto channel : device->device()->channels()) { shared_ptr signal; - switch(channel->type()->id()) { - case SR_CHANNEL_LOGIC: - signal = shared_ptr( - new view::LogicSignal(*this, device, - channel, logic_data_)); - break; - - case SR_CHANNEL_ANALOG: - { - shared_ptr data( - new data::Analog()); - signal = shared_ptr( - new view::AnalogSignal( - *this, channel, data)); - break; - } - - default: - assert(0); - break; + // 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; + }); + 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 + switch(channel->type()->id()) { + case SR_CHANNEL_LOGIC: + signal = shared_ptr( + new view::LogicSignal(*this, + device, channel, + logic_data_)); + break; + + case SR_CHANNEL_ANALOG: + { + shared_ptr data( + new data::Analog()); + signal = shared_ptr( + new view::AnalogSignal( + *this, channel, data)); + break; + } + + default: + assert(0); + break; + } } assert(signal); - signals_.push_back(signal); + signals_.insert(signal); } - } signals_changed(); @@ -427,62 +397,60 @@ shared_ptr Session::signal_from_channel( return shared_ptr(); } -void Session::read_sample_rate(shared_ptr device) +void Session::read_sample_rate(shared_ptr device) { - const auto keys = device_->config_keys(ConfigKey::DEVICE_OPTIONS); + assert(device); + map< const ConfigKey*, set > keys; + + try { + keys = device->config_keys(ConfigKey::DEVICE_OPTIONS); + } catch (const Error) {} + const auto iter = keys.find(ConfigKey::SAMPLERATE); - const uint64_t sample_rate = (iter != keys.end() && + cur_samplerate_ = (iter != keys.end() && (*iter).second.find(sigrok::GET) != (*iter).second.end()) ? VariantBase::cast_dynamic>( device->config_get(ConfigKey::SAMPLERATE)).get() : 0; - - // Set the sample rate of all data - const set< shared_ptr > data_set = get_data(); - for (shared_ptr data : data_set) { - assert(data); - data->set_samplerate(sample_rate); - } } -void Session::sample_thread_proc(shared_ptr device, +void Session::sample_thread_proc(shared_ptr device, function error_handler) { assert(device); assert(error_handler); - read_sample_rate(device); + const std::shared_ptr sr_dev = device->device(); + assert(sr_dev); + read_sample_rate(sr_dev); try { - session_->start(); + device_->session()->start(); } catch(Error e) { error_handler(e.what()); return; } - set_capture_state(session_->trigger() ? + set_capture_state(device_->session()->trigger() ? AwaitingTrigger : Running); - session_->run(); + device_->run(); set_capture_state(Stopped); // Confirm that SR_DF_END was received - if (cur_logic_snapshot_) + if (cur_logic_segment_) { qDebug("SR_DF_END was not received."); assert(0); } } -void Session::feed_in_header(shared_ptr device) +void Session::feed_in_header() { - read_sample_rate(device); + read_sample_rate(device_->device()); } -void Session::feed_in_meta(shared_ptr device, - shared_ptr meta) +void Session::feed_in_meta(shared_ptr meta) { - (void)device; - for (auto entry : meta->config()) { switch (entry.first->id()) { case SR_CONF_SAMPLERATE: @@ -499,7 +467,7 @@ void Session::feed_in_meta(shared_ptr device, void Session::feed_in_frame_begin() { - if (cur_logic_snapshot_ || !cur_analog_snapshots_.empty()) + if (cur_logic_segment_ || !cur_analog_segments_.empty()) frame_began(); } @@ -513,25 +481,30 @@ void Session::feed_in_logic(shared_ptr logic) return; } - if (!cur_logic_snapshot_) + if (!cur_logic_segment_) { // This could be the first packet after a trigger set_capture_state(Running); // Get sample limit. - const auto keys = device_->config_keys( + assert(device_); + const std::shared_ptr device = + device_->device(); + assert(device); + const auto keys = device->config_keys( ConfigKey::DEVICE_OPTIONS); const auto iter = keys.find(ConfigKey::LIMIT_SAMPLES); const uint64_t sample_limit = (iter != keys.end() && (*iter).second.find(sigrok::GET) != (*iter).second.end()) ? VariantBase::cast_dynamic>( - device_->config_get(ConfigKey::LIMIT_SAMPLES)).get() : 0; + device->config_get(ConfigKey::LIMIT_SAMPLES)).get() : 0; - // Create a new data snapshot - cur_logic_snapshot_ = shared_ptr( - new data::LogicSnapshot(logic, sample_limit)); - logic_data_->push_snapshot(cur_logic_snapshot_); + // Create a new data segment + cur_logic_segment_ = shared_ptr( + new data::LogicSegment( + logic, cur_samplerate_, sample_limit)); + logic_data_->push_segment(cur_logic_segment_); // @todo Putting this here means that only listeners querying // for logic will be notified. Currently the only user of @@ -541,8 +514,8 @@ void Session::feed_in_logic(shared_ptr logic) } else { - // Append to the existing data snapshot - cur_logic_snapshot_->append_payload(logic); + // Append to the existing data segment + cur_logic_segment_->append_payload(logic); } data_received(); @@ -560,33 +533,38 @@ void Session::feed_in_analog(shared_ptr analog) for (auto channel : channels) { - shared_ptr snapshot; + shared_ptr segment; - // 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()) - snapshot = (*iter).second; + // Try to get the segment of the channel + const map< shared_ptr, shared_ptr >:: + iterator iter = cur_analog_segments_.find(channel); + if (iter != cur_analog_segments_.end()) + segment = (*iter).second; else { - // If no snapshot was found, this means we havn't + // If no segment was found, this means we havn't // created one yet. i.e. this is the first packet - // in the sweep containing this snapshot. + // in the sweep containing this segment. sweep_beginning = true; // Get sample limit. uint64_t sample_limit; try { + assert(device_); + const std::shared_ptr device = + device_->device(); + assert(device); 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 snapshot, keep it in the maps of channels - snapshot = shared_ptr( - new data::AnalogSnapshot(sample_limit)); - cur_analog_snapshots_[channel] = snapshot; + // Create a segment, keep it in the maps of channels + segment = shared_ptr( + new data::AnalogSegment( + cur_samplerate_, sample_limit)); + cur_analog_segments_[channel] = segment; // Find the annalog data associated with the channel shared_ptr sig = @@ -597,14 +575,14 @@ void Session::feed_in_analog(shared_ptr analog) shared_ptr data(sig->analog_data()); assert(data); - // Push the snapshot into the analog data. - data->push_snapshot(snapshot); + // Push the segment into the analog data. + data->push_segment(segment); } - assert(snapshot); + assert(segment); - // Append the samples in the snapshot - snapshot->append_interleaved_samples(data++, sample_count, + // Append the samples in the segment + segment->append_interleaved_samples(data++, sample_count, channel_count); } @@ -616,18 +594,22 @@ void Session::feed_in_analog(shared_ptr analog) data_received(); } -void Session::data_feed_in(shared_ptr device, shared_ptr packet) +void Session::data_feed_in(shared_ptr device, + shared_ptr packet) { + (void)device; + assert(device); + assert(device == device_->device()); assert(packet); switch (packet->type()->id()) { case SR_DF_HEADER: - feed_in_header(device); + feed_in_header(); break; case SR_DF_META: - feed_in_meta(device, dynamic_pointer_cast(packet->payload())); + feed_in_meta(dynamic_pointer_cast(packet->payload())); break; case SR_DF_FRAME_BEGIN: @@ -646,8 +628,8 @@ void Session::data_feed_in(shared_ptr device, shared_ptr packet) { { lock_guard lock(data_mutex_); - cur_logic_snapshot_.reset(); - cur_analog_snapshots_.clear(); + cur_logic_segment_.reset(); + cur_analog_segments_.clear(); } frame_ended(); break;