Implement MathSignal

[pulseview.git] / pv / session.cpp

diff --git a/pv/session.cpp b/pv/session.cpp
index ec8082eb7cf0158ec0c85954a1bcc99e12227b86..a8047f7da7f51ad9417f7861e447e465a2a77f94 100644 (file)
--- a/pv/session.cpp
+++ b/pv/session.cpp
@@ -25,6 +25,7 @@
 #include <sys/stat.h>
 
 #include <QDebug>
+#include <QDir>
 #include <QFileInfo>
 
 #include "devicemanager.hpp"
@@ -322,25 +323,36 @@ void Session::save_settings(QSettings &settings) const
                        settings.endGroup();
                }
 
-               shared_ptr<devices::SessionFile> sessionfile_device =
-                       dynamic_pointer_cast<devices::SessionFile>(device_);
-
-               if (sessionfile_device) {
+               // Having saved the data to srzip overrides the current device. This is
+               // a crappy hack around the fact that saving e.g. an imported file to
+               // srzip would require changing the underlying libsigrok device
+               if (!save_path_.isEmpty()) {
+                       QFileInfo fi = QFileInfo(QDir(save_path_), name_);
                        settings.setValue("device_type", "sessionfile");
                        settings.beginGroup("device");
-                       settings.setValue("filename", QString::fromStdString(
-                               sessionfile_device->full_name()));
+                       settings.setValue("filename", fi.absoluteFilePath());
                        settings.endGroup();
-               }
+               } else {
+                       shared_ptr<devices::SessionFile> sessionfile_device =
+                               dynamic_pointer_cast<devices::SessionFile>(device_);
+
+                       if (sessionfile_device) {
+                               settings.setValue("device_type", "sessionfile");
+                               settings.beginGroup("device");
+                               settings.setValue("filename", QString::fromStdString(
+                                       sessionfile_device->full_name()));
+                               settings.endGroup();
+                       }
 
-               shared_ptr<devices::InputFile> inputfile_device =
-                       dynamic_pointer_cast<devices::InputFile>(device_);
+                       shared_ptr<devices::InputFile> inputfile_device =
+                               dynamic_pointer_cast<devices::InputFile>(device_);
 
-               if (inputfile_device) {
-                       settings.setValue("device_type", "inputfile");
-                       settings.beginGroup("device");
-                       inputfile_device->save_meta_to_settings(settings);
-                       settings.endGroup();
+                       if (inputfile_device) {
+                               settings.setValue("device_type", "inputfile");
+                               settings.beginGroup("device");
+                               inputfile_device->save_meta_to_settings(settings);
+                               settings.endGroup();
+                       }
                }
 
                save_setup(settings);
@@ -767,6 +779,7 @@ void Session::start_capture(function<void (const QString)> error_handler)
                d->clear();
 
        trigger_list_.clear();
+       segment_sample_count_.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.
@@ -873,16 +886,17 @@ double Session::get_samplerate() const
        return samplerate;
 }
 
-uint32_t Session::get_segment_count() const
+uint32_t Session::get_highest_segment_id() const
 {
-       uint32_t value = 0;
-
-       // Find the highest number of segments
-       for (const shared_ptr<data::SignalData>& data : all_signal_data_)
-               if (data->get_segment_count() > value)
-                       value = data->get_segment_count();
+       return highest_segment_id_;
+}
 
-       return value;
+uint64_t Session::get_segment_sample_count(uint32_t segment_id) const
+{
+       if (segment_id < segment_sample_count_.size())
+               return segment_sample_count_[segment_id];
+       else
+               return 0;
 }
 
 vector<util::Timestamp> Session::get_triggers(uint32_t segment_id) const
@@ -901,6 +915,18 @@ const vector< shared_ptr<data::SignalBase> > Session::signalbases() const
        return signalbases_;
 }
 
+uint32_t Session::get_signal_count(data::SignalBase::ChannelType type) const
+{
+       return count_if(signalbases_.begin(), signalbases_.end(),
+               [&] (shared_ptr<SignalBase> sb) { return sb->type() == type; });
+}
+
+uint32_t Session::get_next_signal_index(data::SignalBase::ChannelType type)
+{
+       next_index_list_[type]++;
+       return next_index_list_[type];
+}
+
 void Session::add_generated_signal(shared_ptr<data::SignalBase> signal)
 {
        signalbases_.push_back(signal);
@@ -1285,6 +1311,7 @@ void Session::signal_new_segment()
 
        if (new_segment_id > highest_segment_id_) {
                highest_segment_id_ = new_segment_id;
+               segment_sample_count_.emplace_back(0);
                new_segment(highest_segment_id_);
        }
 }
@@ -1485,6 +1512,9 @@ void Session::feed_in_logic(shared_ptr<sigrok::Logic> logic)
 
        cur_logic_segment_->append_payload(logic);
 
+       segment_sample_count_[highest_segment_id_] =
+               max(segment_sample_count_[highest_segment_id_], cur_logic_segment_->get_sample_count());
+
        data_received();
 }
 
@@ -1551,6 +1581,9 @@ void Session::feed_in_analog(shared_ptr<sigrok::Analog> analog)
                // Append the samples in the segment
                segment->append_interleaved_samples(channel_data++, analog->num_samples(),
                        channels.size());
+
+               segment_sample_count_[highest_segment_id_] =
+                       max(segment_sample_count_[highest_segment_id_], segment->get_sample_count());
        }
 
        if (sweep_beginning) {