X-Git-Url: http://git.code-monkey.de/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=9c3a2c259e2a635f2eed79f5a8a607a9c33d490c;hp=08bec08e4a5f664b87c0c30f2333c603861ce9fd;hb=bf0edd2b0cbb5f4bd5d69b0f00bcea7d037e2287;hpb=5237f0c50352b523c6a0c3d7f931081ecdbdecaa diff --git a/pv/session.cpp b/pv/session.cpp index 08bec08..9c3a2c2 100644 --- a/pv/session.cpp +++ b/pv/session.cpp @@ -18,6 +18,14 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#ifdef _WIN32 +// Windows: Avoid boost/thread namespace pollution (which includes windows.h). +#define NOGDI +#define NORESOURCE +#endif +#include +#include + #ifdef ENABLE_DECODE #include #endif @@ -31,6 +39,7 @@ #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" @@ -90,7 +99,6 @@ Session::Session(DeviceManager &device_manager) : capture_state_(Stopped), cur_samplerate_(0) { - set_default_device(); } Session::~Session() @@ -128,16 +136,47 @@ void Session::set_device(shared_ptr device) // Ensure we are not capturing before setting the device stop_capture(); + if (device_) + device_->close(); + + device_.reset(); + + // Remove all stored data + signals_.clear(); + { + shared_lock lock(signals_mutex_); + for (const shared_ptr d : all_signal_data_) + d->clear(); + } + all_signal_data_.clear(); + cur_logic_segment_.reset(); + + for (auto entry : cur_analog_segments_) { + shared_ptr(entry.first).reset(); + shared_ptr(entry.second).reset(); + } + + logic_data_.reset(); + decode_traces_.clear(); + + signals_changed(); + device_ = std::move(device); - device_->create(); + + 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); }); - update_signals(); - - decode_traces_.clear(); + update_signals(); device_selected(); } @@ -165,10 +204,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(); @@ -180,10 +223,16 @@ 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(); + } + // 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() @@ -196,25 +245,30 @@ void Session::stop_capture() sampling_thread_.join(); } -set< shared_ptr > Session::get_data() const +double Session::get_samplerate() const { - shared_lock lock(signals_mutex_); - set< shared_ptr > data; - for (const shared_ptr sig : signals_) { - assert(sig); - data.insert(sig->data()); - } + double samplerate = 0.0; - return data; -} + { + 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()); + } + } + // If there is no sample rate given we use samples as unit + if (samplerate == 0.0) + samplerate = 1.0; -boost::shared_mutex& Session::signals_mutex() const -{ - return signals_mutex_; + return samplerate; } -const unordered_set< shared_ptr >& Session::signals() const +const unordered_set< shared_ptr > Session::signals() const { + shared_lock lock(signals_mutex_); return signals_; } @@ -224,8 +278,7 @@ bool Session::add_decoder(srd_decoder *const dec) map > channels; shared_ptr decoder_stack; - try - { + try { lock_guard lock(signals_mutex_); // Create the decoder @@ -234,20 +287,19 @@ bool Session::add_decoder(srd_decoder *const 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_) - { + for (shared_ptr s : signals_) { shared_ptr l = dynamic_pointer_cast(s); if (l && QString::fromUtf8(pdch->name). toLower().contains( - l->name().toLower())) + s->channel()->name().toLower())) channels[pdch] = l; } @@ -257,13 +309,14 @@ bool Session::add_decoder(srd_decoder *const dec) decoder_stack->stack().front()->set_channels(channels); // Create the decode signal + shared_ptr signalbase = + shared_ptr(new data::SignalBase(nullptr)); + shared_ptr d( - new view::DecodeTrace(*this, decoder_stack, + new view::DecodeTrace(*this, signalbase, decoder_stack, decode_traces_.size())); decode_traces_.push_back(d); - } - catch(std::runtime_error e) - { + } catch (std::runtime_error e) { return false; } @@ -284,8 +337,7 @@ vector< shared_ptr > Session::get_decode_signals() const void Session::remove_decode_signal(view::DecodeTrace *signal) { for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++) - if ((*i).get() == signal) - { + if ((*i).get() == signal) { decode_traces_.erase(i); signals_changed(); return; @@ -295,16 +347,25 @@ void Session::remove_decode_signal(view::DecodeTrace *signal) 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() { - assert(device_); + if (!device_) { + signals_.clear(); + logic_data_.reset(); + return; + } lock_guard lock(data_mutex_); @@ -344,13 +405,14 @@ void Session::update_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; + return s->channel()->channel() == channel; }); if (iter != prev_sigs.end()) { // Copy the signal from the old set to the new @@ -362,12 +424,16 @@ void Session::update_signals() 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_, channel, - logic_data_)); + device_, signalbase, logic_data_)); + all_signal_data_.insert(logic_data_); + signalbases_.insert(signalbase); break; case SR_CHANNEL_ANALOG: @@ -376,7 +442,9 @@ void Session::update_signals() new data::Analog()); signal = shared_ptr( new view::AnalogSignal( - *this, channel, data)); + *this, signalbase, data)); + all_signal_data_.insert(data); + signalbases_.insert(signalbase); break; } @@ -394,29 +462,31 @@ void Session::update_signals() signals_changed(); } -shared_ptr Session::signal_from_channel( - shared_ptr channel) const +shared_ptr Session::signal_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); + if (!device_) + return; + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + out_of_memory_ = false; + try { device_->start(); - } catch(Error e) { + } catch (Error e) { error_handler(e.what()); return; } @@ -428,11 +498,13 @@ void Session::sample_thread_proc(shared_ptr device, 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() @@ -445,6 +517,11 @@ void Session::feed_in_meta(shared_ptr meta) 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: @@ -456,6 +533,30 @@ void Session::feed_in_meta(shared_ptr meta) signals_changed(); } +void Session::feed_in_trigger() +{ + // The channel containing most samples should be most accurate + 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; + + 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()) @@ -466,27 +567,23 @@ void Session::feed_in_logic(shared_ptr logic) { lock_guard lock(data_mutex_); - if (!logic_data_) - { + 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 uint64_t sample_limit = device_->read_config( - ConfigKey::LIMIT_SAMPLES); - // 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 @@ -494,9 +591,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); } @@ -511,11 +606,13 @@ void Session::feed_in_analog(shared_ptr analog) 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 (signals_.empty()) + update_signals(); + + for (auto channel : channels) { shared_ptr segment; // Try to get the segment of the channel @@ -523,33 +620,19 @@ 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 { - assert(device_); - const std::shared_ptr device = - device_->device(); - assert(device); - 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 + // Find the analog data associated with the channel shared_ptr sig = dynamic_pointer_cast( signal_from_channel(channel)); @@ -595,16 +678,30 @@ void Session::data_feed_in(shared_ptr device, feed_in_meta(dynamic_pointer_cast(packet->payload())); break; + case SR_DF_TRIGGER: + feed_in_trigger(); + break; + case SR_DF_FRAME_BEGIN: feed_in_frame_begin(); 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: