X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=e8174915e4043c37d508c3371b0c8007d168bd06;hp=e258f6db8e189fb410bcd696d123f31fb295f40e;hb=7c61104601b14e1b22d1a35151e5bd92ca3e11de;hpb=419ec4e11ee29e27566d1c0c17741fcad85dbdf6 diff --git a/pv/session.cpp b/pv/session.cpp index e258f6db..e8174915 100644 --- a/pv/session.cpp +++ b/pv/session.cpp @@ -352,8 +352,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")); + main_bar_->session_error(tr("Failed to select device"), e); } } @@ -401,6 +400,7 @@ void Session::set_device(shared_ptr device) device_->open(); } catch (const QString &e) { device_.reset(); + main_bar_->session_error(tr("Failed to open device"), e); } if (device_) { @@ -426,7 +426,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); } @@ -521,7 +521,7 @@ void Session::load_file(QString file_name, new devices::SessionFile( device_manager_.context(), file_name.toStdString()))); - } catch (Error e) { + } catch (Error& e) { main_bar_->session_error(tr("Failed to load ") + file_name, e.what()); set_default_device(); main_bar_->update_device_list(); @@ -567,6 +567,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 = @@ -622,8 +624,6 @@ void Session::register_view(shared_ptr view) switch (signalbase->type()) { case data::SignalBase::AnalogChannel: case data::SignalBase::LogicChannel: - case data::SignalBase::A2LChannel: - break; case data::SignalBase::DecodeChannel: #ifdef ENABLE_DECODE trace_view->add_decode_signal( @@ -679,11 +679,45 @@ 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 shared_ptr Session::add_decode_signal() { @@ -698,7 +732,7 @@ shared_ptr Session::add_decode_signal() // Add the decode signal to all views for (shared_ptr view : views_) view->add_decode_signal(signal); - } catch (runtime_error e) { + } catch (runtime_error& e) { remove_decode_signal(signal); return nullptr; } @@ -890,9 +924,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; } @@ -902,7 +944,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; @@ -941,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) @@ -987,17 +1080,61 @@ 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 (!cur_samplerate_) + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + lock_guard lock(data_mutex_); if (!logic_data_) { @@ -1013,14 +1150,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); @@ -1030,6 +1164,9 @@ void Session::feed_in_logic(shared_ptr logic) void Session::feed_in_analog(shared_ptr analog) { + if (!cur_samplerate_) + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + lock_guard lock(data_mutex_); const vector> channels = analog->channels(); @@ -1037,7 +1174,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()) @@ -1067,11 +1204,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); @@ -1092,8 +1231,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); @@ -1113,15 +1250,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(); } @@ -1130,26 +1262,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; }