Implement MathSignal

[pulseview.git] / pv / session.cpp

diff --git a/pv/session.cpp b/pv/session.cpp
index ea3fe07b4e312c8bece64035967edf4e6e5c692f..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"
@@ -176,6 +177,16 @@ void Session::set_name(QString name)
        name_changed();
 }
 
+QString Session::save_path() const
+{
+       return save_path_;
+}
+
+void Session::set_save_path(QString path)
+{
+       save_path_ = path;
+}
+
 const vector< shared_ptr<views::ViewBase> > Session::views() const
 {
        return views_;
@@ -312,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);
@@ -444,16 +466,17 @@ void Session::restore_settings(QSettings &settings)
                settings.endGroup();
        }
 
+
+       QString filename;
        if ((device_type == "sessionfile") || (device_type == "inputfile")) {
                if (device_type == "sessionfile") {
                        settings.beginGroup("device");
-                       const QString filename = settings.value("filename").toString();
+                       filename = settings.value("filename").toString();
                        settings.endGroup();
 
-                       if (QFileInfo(filename).isReadable()) {
+                       if (QFileInfo(filename).isReadable())
                                device = make_shared<devices::SessionFile>(device_manager_.context(),
                                        filename.toStdString());
-                       }
                }
 
                if (device_type == "inputfile") {
@@ -472,6 +495,14 @@ void Session::restore_settings(QSettings &settings)
 
                        set_name(QString::fromStdString(
                                dynamic_pointer_cast<devices::File>(device)->display_name(device_manager_)));
+
+                       if (!filename.isEmpty()) {
+                               // Only set the save path if we load an srzip file
+                               if (device_type == "sessionfile")
+                                       set_save_path(QFileInfo(filename).absolutePath());
+
+                               set_name(QFileInfo(filename).fileName());
+                       }
                }
        }
 
@@ -709,6 +740,10 @@ void Session::load_file(QString file_name, QString setup_file_name,
        start_capture([&, errorMessage](QString infoMessage) {
                MainWindow::show_session_error(errorMessage, infoMessage); });
 
+       // Only set save path if we loaded an srzip file
+       if (dynamic_pointer_cast<devices::SessionFile>(device_))
+               set_save_path(QFileInfo(file_name).absolutePath());
+
        set_name(QFileInfo(file_name).fileName());
 }
 
@@ -744,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.
@@ -850,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
@@ -878,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);
@@ -1262,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_);
        }
 }
@@ -1462,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();
 }
 
@@ -1528,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) {