X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=80dad66ee929ef36974da0573cb982f3843b4e06;hp=f96fc869ecad613816196072409c4d1458e198ad;hb=dbed5609ae31cdfc3e9db10f3ab91b7607c08372;hpb=477472187338948c83bea5d790ead66034008296 diff --git a/pv/session.cpp b/pv/session.cpp index f96fc869..80dad66e 100644 --- a/pv/session.cpp +++ b/pv/session.cpp @@ -28,6 +28,7 @@ #include #include "devicemanager.hpp" +#include "mainwindow.hpp" #include "session.hpp" #include "data/analog.hpp" @@ -91,6 +92,9 @@ using sigrok::Session; using Glib::VariantBase; namespace pv { + +shared_ptr Session::sr_context; + Session::Session(DeviceManager &device_manager, QString name) : device_manager_(device_manager), default_name_(name), @@ -296,8 +300,9 @@ void Session::restore_settings(QSettings &settings) filename.toStdString()); set_device(device); - // TODO Perform error handling - start_capture([](QString infoMessage) { (void)infoMessage; }); + start_capture([](QString infoMessage) { + // TODO Emulate noquote() + qDebug() << "Session error:" << infoMessage; }); set_name(QFileInfo(filename).fileName()); } @@ -316,9 +321,9 @@ void Session::restore_settings(QSettings &settings) int decode_signals = settings.value("decode_signals").toInt(); for (int i = 0; i < decode_signals; i++) { - settings.beginGroup("decode_signal" + QString::number(i++)); - // TODO Split up add_decoder() into add_decode_signal() and add_decoder(), - // then call add_decode_signal() and signal->restore_settings() here + settings.beginGroup("decode_signal" + QString::number(i)); + shared_ptr signal = add_decode_signal(); + signal->restore_settings(settings); settings.endGroup(); } #endif @@ -349,8 +354,7 @@ void Session::select_device(shared_ptr device) else set_default_device(); } catch (const QString &e) { - main_bar_->session_error(tr("Failed to Select Device"), - tr("Failed to Select Device")); + MainWindow::show_session_error(tr("Failed to select device"), e); } } @@ -398,6 +402,7 @@ void Session::set_device(shared_ptr device) device_->open(); } catch (const QString &e) { device_.reset(); + MainWindow::show_session_error(tr("Failed to open device"), e); } if (device_) { @@ -423,7 +428,7 @@ void Session::set_default_device() // Try and find the demo device and select that by default const auto iter = find_if(devices.begin(), devices.end(), [] (const shared_ptr &d) { - return d->hardware_device()->driver()->name() == "demo"; }); + return d->hardware_device()->driver()->name() == "demo"; }); set_device((iter == devices.end()) ? devices.front() : *iter); } @@ -487,7 +492,7 @@ void Session::load_init_file(const string &file_name, const string &format) [&](const pair > f) { return f.first == user_name; }); if (iter == formats.end()) { - main_bar_->session_error(tr("Error"), + MainWindow::show_session_error(tr("Error"), tr("Unexpected input format: %s").arg(QString::fromStdString(format))); return; } @@ -518,8 +523,8 @@ void Session::load_file(QString file_name, new devices::SessionFile( device_manager_.context(), file_name.toStdString()))); - } catch (Error e) { - main_bar_->session_error(tr("Failed to load ") + file_name, e.what()); + } catch (Error& e) { + MainWindow::show_session_error(tr("Failed to load ") + file_name, e.what()); set_default_device(); main_bar_->update_device_list(); return; @@ -528,7 +533,7 @@ void Session::load_file(QString file_name, main_bar_->update_device_list(); start_capture([&, errorMessage](QString infoMessage) { - main_bar_->session_error(errorMessage, infoMessage); }); + MainWindow::show_session_error(errorMessage, infoMessage); }); set_name(QFileInfo(file_name).fileName()); } @@ -564,6 +569,8 @@ void Session::start_capture(function error_handler) for (const shared_ptr d : all_signal_data_) d->clear(); + trigger_list_.clear(); + // Revert name back to default name (e.g. "Session 1") for real devices // as the (possibly saved) data is gone. File devices keep their name. shared_ptr hw_device = @@ -597,7 +604,42 @@ void Session::register_view(shared_ptr view) views_.push_back(view); + // Add all device signals update_signals(); + + // Add all other signals + unordered_set< shared_ptr > view_signalbases = + view->signalbases(); + + views::trace::View *trace_view = + qobject_cast(view.get()); + + if (trace_view) { + for (shared_ptr signalbase : signalbases_) { + const int sb_exists = count_if( + view_signalbases.cbegin(), view_signalbases.cend(), + [&](const shared_ptr &sb) { + return sb == signalbase; + }); + // Add the signal to the view as it doesn't have it yet + if (!sb_exists) + switch (signalbase->type()) { + case data::SignalBase::AnalogChannel: + case data::SignalBase::LogicChannel: + case data::SignalBase::DecodeChannel: +#ifdef ENABLE_DECODE + trace_view->add_decode_signal( + dynamic_pointer_cast(signalbase)); +#endif + break; + case data::SignalBase::MathChannel: + // TBD + break; + } + } + } + + signals_changed(); } void Session::deregister_view(shared_ptr view) @@ -639,37 +681,67 @@ double Session::get_samplerate() const return samplerate; } +uint32_t Session::get_segment_count() const +{ + uint32_t value = 0; + + // Find the highest number of segments + for (shared_ptr data : all_signal_data_) + if (data->get_segment_count() > value) + value = data->get_segment_count(); + + return value; +} + +vector Session::get_triggers(uint32_t segment_id) const +{ + vector result; + + for (pair entry : trigger_list_) + if (entry.first == segment_id) + result.push_back(entry.second); + + return result; +} + const unordered_set< shared_ptr > Session::signalbases() const { return signalbases_; } +bool Session::all_segments_complete(uint32_t segment_id) const +{ + bool all_complete = true; + + for (shared_ptr base : signalbases_) + if (!base->segment_is_complete(segment_id)) + all_complete = false; + + return all_complete; +} + #ifdef ENABLE_DECODE -bool Session::add_decoder(srd_decoder *const dec) +shared_ptr Session::add_decode_signal() { - if (!dec) - return false; + shared_ptr signal; try { // Create the decode signal - shared_ptr signal = - make_shared(*this); + signal = make_shared(*this); signalbases_.insert(signal); // Add the decode signal to all views for (shared_ptr view : views_) view->add_decode_signal(signal); - - // Add decoder - signal->stack_decoder(dec); - } catch (runtime_error e) { - return false; + } catch (runtime_error& e) { + remove_decode_signal(signal); + return nullptr; } signals_changed(); - return true; + return signal; } void Session::remove_decode_signal(shared_ptr signal) @@ -854,9 +926,17 @@ void Session::sample_thread_proc(function error_handler) out_of_memory_ = false; + { + lock_guard lock(data_mutex_); + cur_logic_segment_.reset(); + cur_analog_segments_.clear(); + } + highest_segment_id_ = -1; + frame_began_ = false; + try { device_->start(); - } catch (Error e) { + } catch (Error& e) { error_handler(e.what()); return; } @@ -866,7 +946,7 @@ void Session::sample_thread_proc(function error_handler) try { device_->run(); - } catch (Error e) { + } catch (Error& e) { error_handler(e.what()); set_capture_state(Stopped); return; @@ -875,10 +955,8 @@ void Session::sample_thread_proc(function error_handler) set_capture_state(Stopped); // Confirm that SR_DF_END was received - if (cur_logic_segment_) { - qDebug("SR_DF_END was not received."); - assert(false); - } + if (cur_logic_segment_) + qDebug() << "WARNING: SR_DF_END was not received."; // Optimize memory usage free_unused_memory(); @@ -905,9 +983,60 @@ void Session::free_unused_memory() } } +void Session::signal_new_segment() +{ + int new_segment_id = 0; + + if ((cur_logic_segment_ != nullptr) || !cur_analog_segments_.empty()) { + + // Determine new frame/segment number, assuming that all + // signals have the same number of frames/segments + if (cur_logic_segment_) { + new_segment_id = logic_data_->get_segment_count() - 1; + } else { + shared_ptr any_channel = + (*cur_analog_segments_.begin()).first; + + shared_ptr base = signalbase_from_channel(any_channel); + assert(base); + + shared_ptr data(base->analog_data()); + assert(data); + + new_segment_id = data->get_segment_count() - 1; + } + } + + if (new_segment_id > highest_segment_id_) { + highest_segment_id_ = new_segment_id; + new_segment(highest_segment_id_); + } +} + +void Session::signal_segment_completed() +{ + int segment_id = 0; + + for (shared_ptr signalbase : signalbases_) { + // We only care about analog and logic channels, not derived ones + if (signalbase->type() == data::SignalBase::AnalogChannel) { + segment_id = signalbase->analog_data()->get_segment_count() - 1; + break; + } + + if (signalbase->type() == data::SignalBase::LogicChannel) { + segment_id = signalbase->logic_data()->get_segment_count() - 1; + break; + } + } + + if (segment_id >= 0) + segment_completed(segment_id); +} + void Session::feed_in_header() { - cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + // Nothing to do here for now } void Session::feed_in_meta(shared_ptr meta) @@ -951,17 +1080,66 @@ void Session::feed_in_trigger() } } - trigger_event(sample_count / get_samplerate()); + uint32_t segment_id = 0; // Default segment when no frames are used + + // If a frame began, we'd ideally be able to use the highest segment ID for + // the trigger. However, as new segments are only created when logic or + // analog data comes in, this doesn't work if the trigger appears right + // after the beginning of the frame, before any sample data. + // For this reason, we use highest segment ID + 1 if no sample data came in + // yet and the highest segment ID otherwise. + if (frame_began_) { + segment_id = highest_segment_id_; + if (!cur_logic_segment_ && (cur_analog_segments_.size() == 0)) + segment_id++; + } + + // TODO Create timestamp from segment start time + segment's current sample count + util::Timestamp timestamp = sample_count / get_samplerate(); + trigger_list_.emplace_back(segment_id, timestamp); + trigger_event(segment_id, timestamp); } void Session::feed_in_frame_begin() { - if (cur_logic_segment_ || !cur_analog_segments_.empty()) - frame_began(); + frame_began_ = true; +} + +void Session::feed_in_frame_end() +{ + if (!frame_began_) + return; + + { + lock_guard lock(data_mutex_); + + if (cur_logic_segment_) + cur_logic_segment_->set_complete(); + + for (auto entry : cur_analog_segments_) { + shared_ptr segment = entry.second; + segment->set_complete(); + } + + cur_logic_segment_.reset(); + cur_analog_segments_.clear(); + } + + frame_began_ = false; + + signal_segment_completed(); } void Session::feed_in_logic(shared_ptr logic) { + if (logic->data_length() == 0) { + qDebug() << "WARNING: Received logic packet with 0 samples."; + return; + } + + if (!cur_samplerate_) + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + lock_guard lock(data_mutex_); if (!logic_data_) { @@ -977,14 +1155,11 @@ void Session::feed_in_logic(shared_ptr logic) // Create a new data segment cur_logic_segment_ = make_shared( - *logic_data_, logic->unit_size(), cur_samplerate_); + *logic_data_, logic_data_->get_segment_count(), + logic->unit_size(), cur_samplerate_); 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 - // frame_began is DecoderStack, but in future we need to signal - // this after both analog and logic sweeps have begun. - frame_began(); + signal_new_segment(); } cur_logic_segment_->append_payload(logic); @@ -994,6 +1169,14 @@ void Session::feed_in_logic(shared_ptr logic) void Session::feed_in_analog(shared_ptr analog) { + if (analog->num_samples() == 0) { + qDebug() << "WARNING: Received analog packet with 0 samples."; + return; + } + + if (!cur_samplerate_) + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + lock_guard lock(data_mutex_); const vector> channels = analog->channels(); @@ -1001,7 +1184,7 @@ void Session::feed_in_analog(shared_ptr analog) const size_t sample_count = analog->num_samples() / channel_count; bool sweep_beginning = false; - unique_ptr data(new float[analog->num_samples()]); + unique_ptr data(new float[analog->num_samples()]); analog->get_data_as_float(data.get()); if (signalbases_.empty()) @@ -1031,11 +1214,13 @@ void Session::feed_in_analog(shared_ptr analog) // Create a segment, keep it in the maps of channels segment = make_shared( - *data, cur_samplerate_); + *data, data->get_segment_count(), cur_samplerate_); cur_analog_segments_[channel] = segment; // Push the segment into the analog data. data->push_segment(segment); + + signal_new_segment(); } assert(segment); @@ -1056,8 +1241,6 @@ void Session::feed_in_analog(shared_ptr analog) void Session::data_feed_in(shared_ptr device, shared_ptr packet) { - static bool frame_began = false; - (void)device; assert(device); @@ -1077,15 +1260,10 @@ void Session::data_feed_in(shared_ptr device, feed_in_trigger(); break; - case SR_DF_FRAME_BEGIN: - feed_in_frame_begin(); - frame_began = true; - break; - case SR_DF_LOGIC: try { feed_in_logic(dynamic_pointer_cast(packet->payload())); - } catch (bad_alloc) { + } catch (bad_alloc&) { out_of_memory_ = true; device_->stop(); } @@ -1094,26 +1272,40 @@ void Session::data_feed_in(shared_ptr device, case SR_DF_ANALOG: try { feed_in_analog(dynamic_pointer_cast(packet->payload())); - } catch (bad_alloc) { + } catch (bad_alloc&) { out_of_memory_ = true; device_->stop(); } break; + case SR_DF_FRAME_BEGIN: + feed_in_frame_begin(); + break; + case SR_DF_FRAME_END: + feed_in_frame_end(); + break; + case SR_DF_END: - { + // Strictly speaking, this is performed when a frame end marker was + // received, so there's no point doing this again. However, not all + // devices use frames, and for those devices, we need to do it here. { lock_guard lock(data_mutex_); + + if (cur_logic_segment_) + cur_logic_segment_->set_complete(); + + for (auto entry : cur_analog_segments_) { + shared_ptr segment = entry.second; + segment->set_complete(); + } + cur_logic_segment_.reset(); cur_analog_segments_.clear(); } - if (frame_began) { - frame_began = false; - frame_ended(); - } break; - } + default: break; }