2 * This file is part of the PulseView project.
4 * Copyright (C) 2020 Soeren Apel <soeren@apelpie.net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
24 #include "mathsignal.hpp"
27 #include <pv/globalsettings.hpp>
28 #include <pv/session.hpp>
29 #include <pv/data/analogsegment.hpp>
30 #include <pv/data/signalbase.hpp>
32 using std::dynamic_pointer_cast;
33 using std::make_shared;
35 using std::unique_lock;
40 const int64_t MathSignal::ChunkLength = 256 * 1024;
44 struct sig_sample : public exprtk::igeneric_function<T>
46 typedef typename exprtk::igeneric_function<T>::parameter_list_t parameter_list_t;
47 typedef typename exprtk::igeneric_function<T>::generic_type generic_type;
48 typedef typename generic_type::scalar_view scalar_t;
49 typedef typename generic_type::string_view string_t;
51 sig_sample(MathSignal& owner) :
52 exprtk::igeneric_function<T>("ST"), // Require channel name and sample number
58 T operator()(parameter_list_t parameters)
60 const string_t exprtk_sig_name = string_t(parameters[0]);
61 const scalar_t exprtk_sample_num = scalar_t(parameters[1]);
63 const std::string str_sig_name = to_str(exprtk_sig_name);
64 const double sample_num = exprtk_sample_num();
67 sig_data = owner_.signal_from_name(str_sig_name);
70 owner_.update_signal_sample(sig_data, current_segment, sample_num);
72 return T(sig_data->sample_value);
76 uint32_t current_segment;
77 signal_data* sig_data;
81 MathSignal::MathSignal(pv::Session &session) :
82 SignalBase(nullptr, SignalBase::MathChannel),
84 use_custom_sample_rate_(false),
85 use_custom_sample_count_(false),
87 exprtk_unknown_symbol_table_(nullptr),
88 exprtk_symbol_table_(nullptr),
89 exprtk_expression_(nullptr),
90 exprtk_parser_(nullptr),
91 fnc_sig_sample_(nullptr)
93 uint32_t sig_idx = session_.get_next_signal_index(MathChannel);
94 set_name(QString(tr("Math%1")).arg(sig_idx));
95 set_color(AnalogSignalColors[(sig_idx - 1) % countof(AnalogSignalColors)]);
97 set_data(std::make_shared<data::Analog>());
99 connect(&session_, SIGNAL(capture_state_changed(int)),
100 this, SLOT(on_capture_state_changed(int)));
103 MathSignal::~MathSignal()
108 delete fnc_sig_sample_;
111 void MathSignal::save_settings(QSettings &settings) const
113 SignalBase::save_settings(settings);
115 settings.setValue("expression", expression_);
117 settings.setValue("custom_sample_rate", (qulonglong)custom_sample_rate_);
118 settings.setValue("custom_sample_count", (qulonglong)custom_sample_count_);
119 settings.setValue("use_custom_sample_rate", use_custom_sample_rate_);
120 settings.setValue("use_custom_sample_count", use_custom_sample_count_);
123 void MathSignal::restore_settings(QSettings &settings)
125 SignalBase::restore_settings(settings);
127 if (settings.contains("expression"))
128 expression_ = settings.value("expression").toString();
130 if (settings.contains("custom_sample_rate"))
131 custom_sample_rate_ = settings.value("custom_sample_rate").toULongLong();
133 if (settings.contains("custom_sample_count"))
134 custom_sample_count_ = settings.value("custom_sample_count").toULongLong();
136 if (settings.contains("use_custom_sample_rate"))
137 use_custom_sample_rate_ = settings.value("use_custom_sample_rate").toBool();
139 if (settings.contains("use_custom_sample_count"))
140 use_custom_sample_count_ = settings.value("use_custom_sample_count").toBool();
143 QString MathSignal::get_expression() const
148 void MathSignal::set_expression(QString expression)
150 expression_ = expression;
155 void MathSignal::set_error_message(QString msg)
157 error_message_ = msg;
158 // TODO Emulate noquote()
159 qDebug().nospace() << name() << ": " << msg << "(Expression: '" << expression_ << "')";
161 error_message_changed(msg);
164 uint64_t MathSignal::get_working_sample_count(uint32_t segment_id) const
166 // The working sample count is the highest sample number for
167 // which all used signals have data available, so go through all
168 // channels and use the lowest overall sample count of the segment
170 int64_t result = std::numeric_limits<int64_t>::max();
172 if (use_custom_sample_count_)
173 // A custom sample count implies that only one segment will be created
174 result = (segment_id == 0) ? custom_sample_count_ : 0;
176 if (input_signals_.size() > 0) {
177 for (auto input_signal : input_signals_) {
178 const shared_ptr<SignalBase>& sb = input_signal.second.sb;
180 shared_ptr<Analog> a = sb->analog_data();
181 auto analog_segments = a->analog_segments();
183 if (analog_segments.size() == 0) {
188 const uint32_t highest_segment_id = (analog_segments.size() - 1);
189 if (segment_id > highest_segment_id)
192 const shared_ptr<AnalogSegment> segment = analog_segments.at(segment_id);
193 result = min(result, (int64_t)segment->get_sample_count());
196 result = session_.get_segment_sample_count(segment_id);
202 void MathSignal::update_completeness(uint32_t segment_id, uint64_t output_sample_count)
204 bool output_complete = true;
206 if (input_signals_.size() > 0) {
207 for (auto input_signal : input_signals_) {
208 const shared_ptr<SignalBase>& sb = input_signal.second.sb;
210 shared_ptr<Analog> a = sb->analog_data();
211 auto analog_segments = a->analog_segments();
213 if (analog_segments.size() == 0) {
214 output_complete = false;
218 const uint32_t highest_segment_id = (analog_segments.size() - 1);
219 if (segment_id > highest_segment_id) {
220 output_complete = false;
224 const shared_ptr<AnalogSegment> segment = analog_segments.at(segment_id);
225 if (!segment->is_complete()) {
226 output_complete = false;
230 if (output_sample_count < segment->get_sample_count())
231 output_complete = false;
234 // We're done when we generated as many samples as the stopped session is long
235 if ((session_.get_capture_state() != Session::Stopped) ||
236 (output_sample_count < session_.get_segment_sample_count(segment_id)))
237 output_complete = false;
241 analog_data()->analog_segments().at(segment_id)->set_complete();
244 void MathSignal::reset_generation()
246 if (gen_thread_.joinable()) {
247 gen_interrupt_ = true;
248 gen_input_cond_.notify_one();
253 input_signals_.clear();
255 if (exprtk_parser_) {
256 delete exprtk_parser_;
257 exprtk_parser_ = nullptr;
260 if (exprtk_expression_) {
261 delete exprtk_expression_;
262 exprtk_expression_ = nullptr;
265 if (exprtk_symbol_table_) {
266 delete exprtk_symbol_table_;
267 exprtk_symbol_table_ = nullptr;
270 if (exprtk_unknown_symbol_table_) {
271 delete exprtk_unknown_symbol_table_;
272 exprtk_unknown_symbol_table_ = nullptr;
275 if (fnc_sig_sample_) {
276 delete fnc_sig_sample_;
277 fnc_sig_sample_ = nullptr;
280 if (!error_message_.isEmpty()) {
281 error_message_ = QString();
282 // TODO Emulate noquote()
283 qDebug().nospace() << name() << ": Error cleared";
287 void MathSignal::begin_generation()
291 if (expression_.isEmpty()) {
292 set_error_message(tr("No expression defined, nothing to do"));
296 disconnect(this, SLOT(on_data_received()));
298 fnc_sig_sample_ = new sig_sample<double>(*this);
300 exprtk_unknown_symbol_table_ = new exprtk::symbol_table<double>();
302 exprtk_symbol_table_ = new exprtk::symbol_table<double>();
303 exprtk_symbol_table_->add_function("sig_sample", *fnc_sig_sample_);
304 exprtk_symbol_table_->add_variable("t", exprtk_current_time_);
305 exprtk_symbol_table_->add_variable("s", exprtk_current_sample_);
306 exprtk_symbol_table_->add_constants();
308 exprtk_expression_ = new exprtk::expression<double>();
309 exprtk_expression_->register_symbol_table(*exprtk_unknown_symbol_table_);
310 exprtk_expression_->register_symbol_table(*exprtk_symbol_table_);
312 exprtk_parser_ = new exprtk::parser<double>();
313 exprtk_parser_->enable_unknown_symbol_resolver();
315 if (!exprtk_parser_->compile(expression_.toStdString(), *exprtk_expression_)) {
316 QString error_details;
317 size_t error_count = exprtk_parser_->error_count();
319 for (size_t i = 0; i < error_count; i++) {
320 typedef exprtk::parser_error::type error_t;
321 error_t error = exprtk_parser_->get_error(i);
322 exprtk::parser_error::update_error(error, expression_.toStdString());
324 QString error_detail = tr("%1 at line %2, column %3: %4");
325 if ((error_count > 1) && (i < (error_count - 1)))
326 error_detail += "\n";
328 error_details += error_detail \
329 .arg(exprtk::parser_error::to_str(error.mode).c_str()) \
330 .arg(error.line_no) \
331 .arg(error.column_no) \
332 .arg(error.diagnostic.c_str());
334 set_error_message(error_details);
336 // Resolve unknown scalars to signals and add them to the input signal list
337 vector<string> unknowns;
338 exprtk_unknown_symbol_table_->get_variable_list(unknowns);
339 for (string& unknown : unknowns) {
340 signal_data* sig_data = signal_from_name(unknown);
341 const shared_ptr<SignalBase> signal = (sig_data) ? (sig_data->sb) : nullptr;
342 if (!signal || (!signal->analog_data())) {
343 set_error_message(QString(tr("%1 isn't a valid analog signal")).arg(
344 QString::fromStdString(unknown)));
346 sig_data->ref = &(exprtk_unknown_symbol_table_->variable_ref(unknown));
350 if (error_message_.isEmpty()) {
351 // Connect to the session data notification if we have no input signals
352 if (input_signals_.empty())
353 connect(&session_, SIGNAL(data_received()),
354 this, SLOT(on_data_received()));
356 gen_interrupt_ = false;
357 gen_thread_ = std::thread(&MathSignal::generation_proc, this);
361 void MathSignal::generate_samples(uint32_t segment_id, const uint64_t start_sample,
362 const int64_t sample_count)
364 shared_ptr<Analog> analog = dynamic_pointer_cast<Analog>(data_);
365 shared_ptr<AnalogSegment> segment = analog->analog_segments().at(segment_id);
367 // Keep the math functions segment IDs in sync
368 fnc_sig_sample_->current_segment = segment_id;
370 const double sample_rate = data_->get_samplerate();
372 exprtk_current_sample_ = start_sample;
374 float *sample_data = new float[sample_count];
376 for (int64_t i = 0; i < sample_count; i++) {
377 exprtk_current_time_ = exprtk_current_sample_ / sample_rate;
379 for (auto& entry : input_signals_) {
380 signal_data* sig_data = &(entry.second);
381 update_signal_sample(sig_data, segment_id, exprtk_current_sample_);
384 double value = exprtk_expression_->value();
385 sample_data[i] = value;
386 exprtk_current_sample_ += 1;
389 segment->append_interleaved_samples(sample_data, sample_count, 1);
391 delete[] sample_data;
394 void MathSignal::generation_proc()
396 // Don't do anything until we have a valid sample rate
398 if (use_custom_sample_rate_)
399 data_->set_samplerate(custom_sample_rate_);
401 data_->set_samplerate(session_.get_samplerate());
403 if (data_->get_samplerate() == 1) {
404 unique_lock<mutex> gen_input_lock(input_mutex_);
405 gen_input_cond_.wait(gen_input_lock);
407 } while ((!gen_interrupt_) && (data_->get_samplerate() == 1));
412 uint32_t segment_id = 0;
413 shared_ptr<Analog> analog = analog_data();
415 // Create initial analog segment
416 shared_ptr<AnalogSegment> output_segment =
417 make_shared<AnalogSegment>(*analog.get(), segment_id, analog->get_samplerate());
418 analog->push_segment(output_segment);
420 // Create analog samples
422 const uint64_t input_sample_count = get_working_sample_count(segment_id);
423 const uint64_t output_sample_count = output_segment->get_sample_count();
425 const uint64_t samples_to_process =
426 (input_sample_count > output_sample_count) ?
427 (input_sample_count - output_sample_count) : 0;
429 // Process the samples if necessary...
430 if (samples_to_process > 0) {
431 const uint64_t chunk_sample_count = ChunkLength;
433 uint64_t processed_samples = 0;
435 const uint64_t start_sample = output_sample_count + processed_samples;
436 const uint64_t sample_count =
437 min(samples_to_process - processed_samples, chunk_sample_count);
439 generate_samples(segment_id, start_sample, sample_count);
440 processed_samples += sample_count;
442 // Notify consumers of this signal's data
443 samples_added(segment_id, start_sample, start_sample + processed_samples);
444 } while (!gen_interrupt_ && (processed_samples < samples_to_process));
447 update_completeness(segment_id, output_sample_count);
449 if (output_segment->is_complete() && (segment_id < session_.get_highest_segment_id())) {
450 // Process next segment
454 make_shared<AnalogSegment>(*analog.get(), segment_id, analog->get_samplerate());
455 analog->push_segment(output_segment);
458 if (!gen_interrupt_ && (samples_to_process == 0)) {
459 // Wait for more input
460 unique_lock<mutex> gen_input_lock(input_mutex_);
461 gen_input_cond_.wait(gen_input_lock);
463 } while (!gen_interrupt_);
466 signal_data* MathSignal::signal_from_name(const std::string& name)
468 // Look up signal in the map and if it doesn't exist yet, add it for future use
470 auto element = input_signals_.find(name);
472 if (element != input_signals_.end()) {
473 return &(element->second);
475 const vector< shared_ptr<SignalBase> > signalbases = session_.signalbases();
476 const QString sig_name = QString::fromStdString(name);
478 for (const shared_ptr<SignalBase>& sb : signalbases)
479 if (sb->name() == sig_name) {
480 if (!sb->analog_data())
483 connect(sb->analog_data().get(), SIGNAL(samples_added(SharedPtrToSegment, uint64_t, uint64_t)),
484 this, SLOT(on_data_received()));
485 connect(sb->analog_data().get(), SIGNAL(segment_completed()),
486 this, SLOT(on_data_received()));
488 return &(input_signals_.insert({name, signal_data(sb)}).first->second);
495 void MathSignal::update_signal_sample(signal_data* sig_data, uint32_t segment_id, uint64_t sample_num)
499 // Update the value only if a different sample is requested
500 if (sig_data->sample_num == sample_num)
503 assert(sig_data->sb);
504 const shared_ptr<pv::data::Analog> analog = sig_data->sb->analog_data();
507 assert(segment_id < analog->analog_segments().size());
509 const shared_ptr<AnalogSegment> segment = analog->analog_segments().at(segment_id);
511 sig_data->sample_num = sample_num;
512 sig_data->sample_value = segment->get_sample(sample_num);
514 // We only have a reference if this signal is used as a scalar;
515 // if it's used by a function, it's null
517 *(sig_data->ref) = sig_data->sample_value;
520 void MathSignal::on_capture_state_changed(int state)
522 if (state == Session::Running)
525 // Make sure we don't miss any input samples, just in case
526 if (state == Session::Stopped)
527 gen_input_cond_.notify_one();
530 void MathSignal::on_data_received()
532 gen_input_cond_.notify_one();