X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=ca72e9b0d670fed6a14da47d4c7c2ce79946c078;hp=a44ceb99b669aec396c97d92c19c733a6f489698;hb=7ea2a4ff0765fdad34b84e4b4631d6f3f5588714;hpb=7f9654641c096b303fc30b710335e235b9738ce9 diff --git a/pv/session.cpp b/pv/session.cpp index a44ceb99..ca72e9b0 100644 --- a/pv/session.cpp +++ b/pv/session.cpp @@ -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 = @@ -677,15 +679,27 @@ double Session::get_samplerate() const return samplerate; } -int Session::get_segment_count() const +uint32_t Session::get_segment_count() const { - int min_val = INT_MAX; + uint32_t value = 0; + // Find the highest number of segments for (shared_ptr data : all_signal_data_) - if (data->get_segment_count() < min_val) - min_val = data->get_segment_count(); + 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 min_val; + return result; } const unordered_set< shared_ptr > Session::signalbases() const @@ -693,6 +707,17 @@ 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() { @@ -899,6 +924,14 @@ 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) { @@ -950,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) @@ -996,33 +1080,50 @@ void Session::feed_in_trigger() } } - trigger_event(sample_count / get_samplerate()); + // If no frame began then this is a trigger for a new segment + const uint32_t segment_id = + (frame_began_) ? highest_segment_id_ : (highest_segment_id_ + 1); + + 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() { frame_began_ = true; - - if (cur_logic_segment_ || !cur_analog_segments_.empty()) - frame_began(); } 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(); } - if (frame_began_) { - frame_began_ = false; - frame_ended(); - } + 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_) { @@ -1038,14 +1139,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); @@ -1055,6 +1153,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(); @@ -1062,7 +1163,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()) @@ -1092,11 +1193,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);