X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=pv%2Fsession.cpp;h=7db96ff0abf568d0199d948afc7853bbbf499b9c;hb=970fca0d353f5c6d05c763bf7bdd12aac6f5ea0b;hp=a61224048b018701cad13b891db4baf00a50a8b7;hpb=0aa57689a8abc7eb313de50774b8d0cf271bc61f;p=pulseview.git
diff --git a/pv/session.cpp b/pv/session.cpp
index a612240..7db96ff 100644
--- a/pv/session.cpp
+++ b/pv/session.cpp
@@ -14,90 +14,94 @@
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ * along with this program; if not, see .
*/
-#ifdef _WIN32
-// Windows: Avoid boost/thread namespace pollution (which includes windows.h).
-#define NOGDI
-#define NORESOURCE
-#endif
-#include
-#include
+#include
+#include
-#ifdef ENABLE_DECODE
-#include
-#endif
+#include
+#include
+#include
+#include
-#include "session.hpp"
+#include
#include "devicemanager.hpp"
+#include "mainwindow.hpp"
+#include "session.hpp"
#include "data/analog.hpp"
#include "data/analogsegment.hpp"
-#include "data/decoderstack.hpp"
+#include "data/decode/decoder.hpp"
#include "data/logic.hpp"
#include "data/logicsegment.hpp"
#include "data/signalbase.hpp"
-#include "data/decode/decoder.hpp"
#include "devices/hardwaredevice.hpp"
+#include "devices/inputfile.hpp"
#include "devices/sessionfile.hpp"
-#include "view/analogsignal.hpp"
-#include "view/decodetrace.hpp"
-#include "view/logicsignal.hpp"
-
-#include
-#include
-#include
-
-#include
+#include "toolbars/mainbar.hpp"
-#include
+#include "views/trace/analogsignal.hpp"
+#include "views/trace/decodetrace.hpp"
+#include "views/trace/logicsignal.hpp"
+#include "views/trace/signal.hpp"
+#include "views/trace/view.hpp"
#include
-using boost::shared_lock;
-using boost::shared_mutex;
-using boost::unique_lock;
+#ifdef ENABLE_DECODE
+#include
+#include "data/decodesignal.hpp"
+#endif
+using std::bad_alloc;
using std::dynamic_pointer_cast;
+using std::find_if;
using std::function;
using std::lock_guard;
using std::list;
+using std::make_pair;
+using std::make_shared;
using std::map;
+using std::max;
+using std::move;
using std::mutex;
+using std::pair;
using std::recursive_mutex;
-using std::set;
+using std::runtime_error;
using std::shared_ptr;
using std::string;
+using std::unique_ptr;
using std::unordered_set;
using std::vector;
using sigrok::Analog;
using sigrok::Channel;
-using sigrok::ChannelType;
using sigrok::ConfigKey;
using sigrok::DatafeedCallbackFunction;
using sigrok::Error;
-using sigrok::Header;
+using sigrok::InputFormat;
using sigrok::Logic;
using sigrok::Meta;
using sigrok::Packet;
-using sigrok::PacketPayload;
using sigrok::Session;
-using sigrok::SessionDevice;
using Glib::VariantBase;
-using Glib::Variant;
namespace pv {
-Session::Session(DeviceManager &device_manager) :
+
+shared_ptr Session::sr_context;
+
+Session::Session(DeviceManager &device_manager, QString name) :
device_manager_(device_manager),
+ default_name_(name),
+ name_(name),
capture_state_(Stopped),
- cur_samplerate_(0)
+ cur_samplerate_(0),
+ data_saved_(true)
{
}
@@ -129,6 +133,254 @@ shared_ptr Session::device() const
return device_;
}
+QString Session::name() const
+{
+ return name_;
+}
+
+void Session::set_name(QString name)
+{
+ if (default_name_.isEmpty())
+ default_name_ = name;
+
+ name_ = name;
+
+ name_changed();
+}
+
+const list< shared_ptr > Session::views() const
+{
+ return views_;
+}
+
+shared_ptr Session::main_view() const
+{
+ return main_view_;
+}
+
+void Session::set_main_bar(shared_ptr main_bar)
+{
+ main_bar_ = main_bar;
+}
+
+shared_ptr Session::main_bar() const
+{
+ return main_bar_;
+}
+
+bool Session::data_saved() const
+{
+ return data_saved_;
+}
+
+void Session::save_settings(QSettings &settings) const
+{
+ map dev_info;
+ list key_list;
+ int decode_signals = 0, views = 0;
+
+ if (device_) {
+ shared_ptr hw_device =
+ dynamic_pointer_cast< devices::HardwareDevice >(device_);
+
+ if (hw_device) {
+ settings.setValue("device_type", "hardware");
+ settings.beginGroup("device");
+
+ key_list.emplace_back("vendor");
+ key_list.emplace_back("model");
+ key_list.emplace_back("version");
+ key_list.emplace_back("serial_num");
+ key_list.emplace_back("connection_id");
+
+ dev_info = device_manager_.get_device_info(device_);
+
+ for (string& key : key_list) {
+ if (dev_info.count(key))
+ settings.setValue(QString::fromUtf8(key.c_str()),
+ QString::fromUtf8(dev_info.at(key).c_str()));
+ else
+ settings.remove(QString::fromUtf8(key.c_str()));
+ }
+
+ settings.endGroup();
+ }
+
+ shared_ptr sessionfile_device =
+ dynamic_pointer_cast(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 inputfile_device =
+ dynamic_pointer_cast(device_);
+
+ if (inputfile_device) {
+ settings.setValue("device_type", "inputfile");
+ settings.beginGroup("device");
+ inputfile_device->save_meta_to_settings(settings);
+ settings.endGroup();
+ }
+
+ // Save channels and decoders
+ for (const shared_ptr& base : signalbases_) {
+#ifdef ENABLE_DECODE
+ if (base->is_decode_signal()) {
+ settings.beginGroup("decode_signal" + QString::number(decode_signals++));
+ base->save_settings(settings);
+ settings.endGroup();
+ } else
+#endif
+ {
+ settings.beginGroup(base->internal_name());
+ base->save_settings(settings);
+ settings.endGroup();
+ }
+ }
+
+ settings.setValue("decode_signals", decode_signals);
+
+ // Save view states and their signal settings
+ // Note: main_view must be saved as view0
+ settings.beginGroup("view" + QString::number(views++));
+ main_view_->save_settings(settings);
+ settings.endGroup();
+
+ for (const shared_ptr& view : views_) {
+ if (view != main_view_) {
+ settings.beginGroup("view" + QString::number(views++));
+ view->save_settings(settings);
+ settings.endGroup();
+ }
+ }
+
+ settings.setValue("views", views);
+ }
+}
+
+void Session::restore_settings(QSettings &settings)
+{
+ shared_ptr device;
+
+ QString device_type = settings.value("device_type").toString();
+
+ if (device_type == "hardware") {
+ map dev_info;
+ list key_list;
+
+ // Re-select last used device if possible but only if it's not demo
+ settings.beginGroup("device");
+ key_list.emplace_back("vendor");
+ key_list.emplace_back("model");
+ key_list.emplace_back("version");
+ key_list.emplace_back("serial_num");
+ key_list.emplace_back("connection_id");
+
+ for (string key : key_list) {
+ const QString k = QString::fromStdString(key);
+ if (!settings.contains(k))
+ continue;
+
+ const string value = settings.value(k).toString().toStdString();
+ if (!value.empty())
+ dev_info.insert(make_pair(key, value));
+ }
+
+ if (dev_info.count("model") > 0)
+ device = device_manager_.find_device_from_info(dev_info);
+
+ if (device)
+ set_device(device);
+
+ settings.endGroup();
+ }
+
+ if ((device_type == "sessionfile") || (device_type == "inputfile")) {
+ if (device_type == "sessionfile") {
+ settings.beginGroup("device");
+ QString filename = settings.value("filename").toString();
+ settings.endGroup();
+
+ if (QFileInfo(filename).isReadable()) {
+ device = make_shared(device_manager_.context(),
+ filename.toStdString());
+ }
+ }
+
+ if (device_type == "inputfile") {
+ settings.beginGroup("device");
+ device = make_shared(device_manager_.context(),
+ settings);
+ settings.endGroup();
+ }
+
+ if (device) {
+ set_device(device);
+
+ start_capture([](QString infoMessage) {
+ // TODO Emulate noquote()
+ qDebug() << "Session error:" << infoMessage; });
+
+ set_name(QString::fromStdString(
+ dynamic_pointer_cast(device)->display_name(device_manager_)));
+ }
+ }
+
+ if (device) {
+ // Restore channels
+ for (shared_ptr base : signalbases_) {
+ settings.beginGroup(base->internal_name());
+ base->restore_settings(settings);
+ settings.endGroup();
+ }
+
+ // Restore decoders
+#ifdef ENABLE_DECODE
+ int decode_signals = settings.value("decode_signals").toInt();
+
+ for (int i = 0; i < decode_signals; i++) {
+ settings.beginGroup("decode_signal" + QString::number(i));
+ shared_ptr signal = add_decode_signal();
+ signal->restore_settings(settings);
+ settings.endGroup();
+ }
+#endif
+
+ // Restore views
+ int views = settings.value("views").toInt();
+
+ for (int i = 0; i < views; i++) {
+ settings.beginGroup("view" + QString::number(i));
+
+ if (i > 0) {
+ views::ViewType type = (views::ViewType)settings.value("type").toInt();
+ add_view(name_, type, this);
+ views_.back()->restore_settings(settings);
+ } else
+ main_view_->restore_settings(settings);
+
+ settings.endGroup();
+ }
+ }
+}
+
+void Session::select_device(shared_ptr device)
+{
+ try {
+ if (device)
+ set_device(device);
+ else
+ set_default_device();
+ } catch (const QString &e) {
+ MainWindow::show_session_error(tr("Failed to select device"), e);
+ }
+}
+
void Session::set_device(shared_ptr device)
{
assert(device);
@@ -141,43 +393,52 @@ void Session::set_device(shared_ptr device)
device_.reset();
- // Remove all stored data
- signals_.clear();
- {
- shared_lock lock(signals_mutex_);
- for (const shared_ptr d : all_signal_data_)
- d->clear();
+ // Revert name back to default name (e.g. "Session 1") as the data is gone
+ name_ = default_name_;
+ name_changed();
+
+ // Remove all stored data and reset all views
+ for (shared_ptr view : views_) {
+ view->clear_signals();
+#ifdef ENABLE_DECODE
+ view->clear_decode_signals();
+#endif
+ view->reset_view_state();
}
+ for (const shared_ptr& d : all_signal_data_)
+ d->clear();
all_signal_data_.clear();
+ signalbases_.clear();
cur_logic_segment_.reset();
- for (auto entry : cur_analog_segments_) {
+ for (auto& entry : cur_analog_segments_) {
shared_ptr(entry.first).reset();
shared_ptr(entry.second).reset();
}
logic_data_.reset();
- decode_traces_.clear();
signals_changed();
- device_ = std::move(device);
+ device_ = move(device);
try {
device_->open();
} catch (const QString &e) {
device_.reset();
- device_selected();
- throw;
+ MainWindow::show_session_error(tr("Failed to open device"), e);
}
- device_->session()->add_datafeed_callback([=]
- (shared_ptr device, shared_ptr packet) {
- data_feed_in(device, packet);
- });
+ if (device_) {
+ device_->session()->add_datafeed_callback([=]
+ (shared_ptr device, shared_ptr packet) {
+ data_feed_in(device, packet);
+ });
- update_signals();
- device_selected();
+ update_signals();
+ }
+
+ device_changed();
}
void Session::set_default_device()
@@ -189,13 +450,122 @@ void Session::set_default_device()
return;
// Try and find the demo device and select that by default
- const auto iter = std::find_if(devices.begin(), devices.end(),
+ 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);
}
+/**
+ * Convert generic options to data types that are specific to InputFormat.
+ *
+ * @param[in] user_spec Vector of tokenized words, string format.
+ * @param[in] fmt_opts Input format's options, result of InputFormat::options().
+ *
+ * @return Map of options suitable for InputFormat::create_input().
+ */
+map
+Session::input_format_options(vector user_spec,
+ map> fmt_opts)
+{
+ map result;
+
+ for (auto& entry : user_spec) {
+ /*
+ * Split key=value specs. Accept entries without separator
+ * (for simplified boolean specifications).
+ */
+ string key, val;
+ size_t pos = entry.find("=");
+ if (pos == std::string::npos) {
+ key = entry;
+ val = "";
+ } else {
+ key = entry.substr(0, pos);
+ val = entry.substr(pos + 1);
+ }
+
+ /*
+ * Skip user specifications that are not a member of the
+ * format's set of supported options. Have the text input
+ * spec converted to the required input format specific
+ * data type.
+ */
+ auto found = fmt_opts.find(key);
+ if (found == fmt_opts.end())
+ continue;
+ shared_ptr