X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=b18d27ff9e8065f796b8434c21808a5568130737;hp=1f61c7db4bde41a690398e19347e65ca6c031b46;hb=1e4d7c4d21f72aa6b7078e92c0d159d2bd35eb4a;hpb=4b5537c576c37884c2a0254985893e20ea5338e6 diff --git a/pv/session.cpp b/pv/session.cpp index 1f61c7db..b18d27ff 100644 --- a/pv/session.cpp +++ b/pv/session.cpp @@ -18,12 +18,21 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifdef ENABLE_DECODE -#include +#ifdef _WIN32 +// Windows: Avoid boost/thread namespace pollution (which includes windows.h). +#define NOGDI +#define NORESOURCE #endif +#include +#include -#include "session.hpp" +#include +#include +#include +#include + +#include "session.hpp" #include "devicemanager.hpp" #include "data/analog.hpp" @@ -31,22 +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; @@ -57,9 +70,11 @@ using std::lock_guard; using std::list; using std::map; using std::mutex; +using std::recursive_mutex; using std::set; using std::shared_ptr; using std::string; +using std::unordered_set; using std::vector; using sigrok::Analog; @@ -67,9 +82,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; @@ -82,13 +95,12 @@ using Glib::VariantBase; using Glib::Variant; namespace pv { -Session::Session(DeviceManager &device_manager) : +Session::Session(DeviceManager &device_manager, QString name) : device_manager_(device_manager), - session_(device_manager.context()->create_session()), + name_(name), capture_state_(Stopped), cur_samplerate_(0) { - set_default_device(); } Session::~Session() @@ -107,98 +119,184 @@ 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) +QString Session::name() const { - // Ensure we are not capturing before setting the device - stop_capture(); + 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_; +} - // 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_); +void Session::save_settings(QSettings &settings) const +{ + map dev_info; + list key_list; if (device_) { - session_->remove_datafeed_callbacks(); - if (!prev_session_device) { - device_->close(); - session_->remove_devices(); + 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())); } - } - if (session_device) - session_ = session_device->parent(); + // TODO Save channel settings and decoders - decode_traces_.clear(); + settings.endGroup(); + } +} - if (device) { - if (!session_device) - { - session_ = device_manager_.context()->create_session(); +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)); + } - try { - device->open(); - } catch(const sigrok::Error &e) { - throw QString(e.what()); - } + if (dev_info.count("model") > 0) + device = device_manager_.find_device_from_info(dev_info); - session_->add_device(device); - } + if (device) { + set_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; + // TODO Restore channel settings and decoders + } - device_selected(); + settings.endGroup(); } -void Session::set_session_file(const string &name) +void Session::set_device(shared_ptr device) { - session_ = device_manager_.context()->load_session(name); - device_ = session_->devices()[0]; - decode_traces_.clear(); - session_->add_datafeed_callback([=] - (shared_ptr device, shared_ptr packet) { + assert(device); + + // Ensure we are not capturing before setting the device + stop_capture(); + + if (device_) + device_->close(); + + 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 + 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_) { + shared_ptr(entry.first).reset(); + shared_ptr(entry.second).reset(); + } + + logic_data_.reset(); + + signals_changed(); + + device_ = std::move(device); + + 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); }); - device_manager_.update_display_name(device_); - update_signals(device_); + + update_signals(); 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 @@ -209,93 +307,124 @@ Session::capture_state Session::get_capture_state() const void Session::start_capture(function error_handler) { - stop_capture(); - - // Check that a device instance has been selected. if (!device_) { - qDebug() << "No device selected"; + error_handler(tr("No active device set, can't start acquisition.")); return; } - // Check that at least one channel is enabled - auto channels = device_->channels(); - bool enabled = std::any_of(channels.begin(), channels.end(), - [](shared_ptr channel) { return channel->enabled(); }); + stop_capture(); - if (!enabled) { - error_handler(tr("No channels enabled.")); - return; + // Check that at least one channel is enabled + const shared_ptr sr_dev = device_->device(); + if (sr_dev) { + const auto channels = sr_dev->channels(); + if (!std::any_of(channels.begin(), channels.end(), + [](shared_ptr channel) { + return channel->enabled(); })) { + error_handler(tr("No channels enabled.")); + return; + } } + // Clear signal 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() { if (get_capture_state() != Stopped) - session_->stop(); + device_->stop(); // Check that sampling stopped if (sampling_thread_.joinable()) 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; } - return data; + views_.insert(view); } -boost::shared_mutex& Session::signals_mutex() const +void Session::deregister_view(std::shared_ptr view) { - return signals_mutex_; + views_.erase(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) +{ + return views_.find(view) != views_.end(); +} + +double Session::get_samplerate() const +{ + double samplerate = 0.0; + + 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; + + return samplerate; } -const vector< shared_ptr >& Session::signals() const +const std::unordered_set< std::shared_ptr > + Session::signalbases() const { - 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_); - + try { // Create the decoder decoder_stack = shared_ptr( new data::DecoderStack(*this, dec)); // Make a list of all the channels std::vector all_channels; - for(const GSList *i = dec->channels; i; i = i->next) + for (const GSList *i = dec->channels; i; i = i->next) all_channels.push_back((const srd_channel*)i->data); - for(const GSList *i = dec->opt_channels; i; i = i->next) + for (const GSList *i = dec->opt_channels; i; i = i->next) all_channels.push_back((const srd_channel*)i->data); // 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); @@ -304,13 +433,14 @@ 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); - } - catch(std::runtime_error e) - { + 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; } @@ -322,43 +452,58 @@ 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_trace(signalbase); } #endif void Session::set_capture_state(capture_state state) { - lock_guard lock(sampling_mutex_); - const bool changed = capture_state_ != state; - capture_state_ = state; - if(changed) + bool changed; + + { + lock_guard lock(sampling_mutex_); + changed = capture_state_ != state; + capture_state_ = state; + } + + if (changed) capture_state_changed(state); } -void Session::update_signals(shared_ptr device) +void Session::update_signals() { - assert(device); - assert(capture_state_ == Stopped); + if (!device_) { + signalbases_.clear(); + logic_data_.reset(); + for (std::shared_ptr view : views_) { + view->clear_signals(); +#ifdef ENABLE_DECODE + view->clear_decode_traces(); +#endif + } + return; + } - // Clear the decode traces - decode_traces_.clear(); + lock_guard lock(data_mutex_); + + const shared_ptr sr_dev = device_->device(); + if (!sr_dev) { + signalbases_.clear(); + logic_data_.reset(); + for (std::shared_ptr view : views_) { + view->clear_signals(); +#ifdef ENABLE_DECODE + view->clear_decode_traces(); +#endif + } + return; + } // Detect what data types we will receive - auto channels = device->channels(); + auto channels = sr_dev->channels(); unsigned int logic_channel_count = std::count_if( channels.begin(), channels.end(), [] (shared_ptr channel) { @@ -366,120 +511,150 @@ void Session::update_signals(shared_ptr device) // Create data containers for the logic data segments { - lock_guard data_lock(data_mutex_); + 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_); } } - // Make the Signals list - { - unique_lock lock(signals_mutex_); - - 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 : device->channels()) { + for (auto channel : sr_dev->channels()) { + shared_ptr signalbase; 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; + // 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; + } 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 view::LogicSignal(*this, + device_, signalbase)); + 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 view::AnalogSignal( + *this, signalbase)); + view->add_signal(signal); + break; + } + + default: + assert(0); + break; + } } - - default: - assert(0); - break; - } - - assert(signal); - signals_.push_back(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::read_sample_rate(shared_ptr device) +void Session::sample_thread_proc(function error_handler) { - const auto keys = device_->config_keys(ConfigKey::DEVICE_OPTIONS); - const auto iter = keys.find(ConfigKey::SAMPLERATE); - cur_samplerate_ = (iter != keys.end() && - (*iter).second.find(sigrok::GET) != (*iter).second.end()) ? - VariantBase::cast_dynamic>( - device->config_get(ConfigKey::SAMPLERATE)).get() : 0; -} - -void Session::sample_thread_proc(shared_ptr device, - function error_handler) -{ - assert(device); assert(error_handler); - read_sample_rate(device); + if (!device_) + return; + + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + + out_of_memory_ = false; try { - session_->start(); - } catch(Error e) { + device_->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_segment_) - { + if (cur_logic_segment_) { qDebug("SR_DF_END was not received."); assert(0); } + + if (out_of_memory_) + error_handler(tr("Out of memory, acquisition stopped.")); } -void Session::feed_in_header(shared_ptr device) +void Session::feed_in_header() { - read_sample_rate(device); + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); } -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: + // We can't rely on the header to always contain the sample rate, + // so in case it's supplied via a meta packet, we use it. + if (!cur_samplerate_) + cur_samplerate_ = g_variant_get_uint64(entry.second.gobj()); + /// @todo handle samplerate changes break; default: @@ -491,6 +666,29 @@ void Session::feed_in_meta(shared_ptr device, signals_changed(); } +void Session::feed_in_trigger() +{ + // The channel containing most samples should be most accurate + uint64_t sample_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(); + + if (temp_count > sample_count) + sample_count = temp_count; + } + } + + trigger_event(sample_count / get_samplerate()); +} + void Session::feed_in_frame_begin() { if (cur_logic_segment_ || !cur_analog_segments_.empty()) @@ -499,33 +697,25 @@ void Session::feed_in_frame_begin() void Session::feed_in_logic(shared_ptr logic) { - lock_guard lock(data_mutex_); + lock_guard lock(data_mutex_); - if (!logic_data_) - { - qDebug() << "Unexpected logic packet"; - return; + const size_t sample_count = logic->data_length() / logic->unit_size(); + + if (!logic_data_) { + // The only reason logic_data_ would not have been created is + // if it was not possible to determine the signals when the + // device was created. + update_signals(); } - if (!cur_logic_segment_) - { + 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( - 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; - // Create a new data segment cur_logic_segment_ = shared_ptr( new data::LogicSegment( - logic, cur_samplerate_, sample_limit)); + logic, cur_samplerate_, sample_count)); logic_data_->push_segment(cur_logic_segment_); // @todo Putting this here means that only listeners querying @@ -533,9 +723,7 @@ void Session::feed_in_logic(shared_ptr logic) // frame_began is DecoderStack, but in future we need to signal // this after both analog and logic sweeps have begun. frame_began(); - } - else - { + } else { // Append to the existing data segment cur_logic_segment_->append_payload(logic); } @@ -545,16 +733,18 @@ void Session::feed_in_logic(shared_ptr logic) void Session::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(); const size_t sample_count = analog->num_samples() / channel_count; - const float *data = analog->data_pointer(); + const float *data = static_cast(analog->data_pointer()); bool sweep_beginning = false; - for (auto channel : channels) - { + if (signalbases_.empty()) + update_signals(); + + for (auto channel : channels) { shared_ptr segment; // Try to get the segment of the channel @@ -562,35 +752,23 @@ void Session::feed_in_analog(shared_ptr analog) iterator iter = cur_analog_segments_.find(channel); if (iter != cur_analog_segments_.end()) segment = (*iter).second; - else - { - // If no segment was found, this means we havn't + else { + // If no segment was found, this means we haven't // created one yet. i.e. this is the first packet // in the sweep containing this segment. sweep_beginning = true; - // Get sample limit. - uint64_t sample_limit; - try { - sample_limit = VariantBase::cast_dynamic>( - device_->config_get(ConfigKey::LIMIT_SAMPLES)).get(); - } catch (Error) { - sample_limit = 0; - } - // Create a segment, keep it in the maps of channels segment = shared_ptr( new data::AnalogSegment( - cur_samplerate_, sample_limit)); + cur_samplerate_, sample_count)); cur_analog_segments_[channel] = segment; - // Find the annalog data associated with the channel - shared_ptr sig = - dynamic_pointer_cast( - signal_from_channel(channel)); - assert(sig); + // Find the analog data associated with the channel + 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. @@ -612,18 +790,26 @@ 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_TRIGGER: + feed_in_trigger(); break; case SR_DF_FRAME_BEGIN: @@ -631,17 +817,27 @@ void Session::data_feed_in(shared_ptr device, shared_ptr packet) break; case SR_DF_LOGIC: - feed_in_logic(dynamic_pointer_cast(packet->payload())); + try { + feed_in_logic(dynamic_pointer_cast(packet->payload())); + } catch (std::bad_alloc) { + out_of_memory_ = true; + device_->stop(); + } break; case SR_DF_ANALOG: - feed_in_analog(dynamic_pointer_cast(packet->payload())); + try { + feed_in_analog(dynamic_pointer_cast(packet->payload())); + } catch (std::bad_alloc) { + out_of_memory_ = true; + device_->stop(); + } break; case SR_DF_END: { { - lock_guard lock(data_mutex_); + lock_guard lock(data_mutex_); cur_logic_segment_.reset(); cur_analog_segments_.clear(); }