]> sigrok.org Git - pulseview.git/commitdiff
Session: Renamed files to match class name
authorJoel Holdsworth <redacted>
Wed, 3 Dec 2014 22:23:36 +0000 (22:23 +0000)
committerJoel Holdsworth <redacted>
Wed, 3 Dec 2014 22:57:22 +0000 (22:57 +0000)
19 files changed:
CMakeLists.txt
pv/data/decoderstack.cpp
pv/devicemanager.cpp
pv/mainwindow.hpp
pv/popups/channels.cpp
pv/session.cpp [new file with mode: 0644]
pv/session.hpp [new file with mode: 0644]
pv/sigsession.cpp [deleted file]
pv/sigsession.hpp [deleted file]
pv/storesession.cpp
pv/toolbars/samplingbar.hpp
pv/view/decodetrace.cpp
pv/view/header.cpp
pv/view/logicsignal.cpp
pv/view/rowitemiterator.hpp
pv/view/view.cpp
pv/view/viewport.cpp
test/CMakeLists.txt
test/data/decoderstack.cpp

index f1e71061059e0eee2344fa51020d26b614ac20d2..93021a644da7a7e0420388251d59d2785bdc27f7 100644 (file)
@@ -149,7 +149,7 @@ set(pulseview_SOURCES
        pv/application.cpp
        pv/devicemanager.cpp
        pv/mainwindow.cpp
-       pv/sigsession.cpp
+       pv/session.cpp
        pv/storesession.cpp
        pv/util.cpp
        pv/data/analog.cpp
@@ -201,7 +201,7 @@ set(pulseview_SOURCES
 # This list includes only QObject derived class headers.
 set(pulseview_HEADERS
        pv/mainwindow.hpp
-       pv/sigsession.hpp
+       pv/session.hpp
        pv/storesession.hpp
        pv/dialogs/about.hpp
        pv/dialogs/connect.hpp
index 1c47016055fddae6dda477713487836b34b52793..c179b24a85701f548468ae244019444700af21e8 100644 (file)
@@ -30,7 +30,7 @@
 #include <pv/data/logicsnapshot.hpp>
 #include <pv/data/decode/decoder.hpp>
 #include <pv/data/decode/annotation.hpp>
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 #include <pv/view/logicsignal.hpp>
 
 using std::lock_guard;
index 7a016d1bd985090c9b89a2db880253e3cbce73f7..9976d3e6e5355c1dffcf84cc9ef53f304c04f113 100644 (file)
@@ -19,7 +19,7 @@
  */
 
 #include "devicemanager.hpp"
-#include "sigsession.hpp"
+#include "session.hpp"
 
 #include <cassert>
 #include <stdexcept>
index 8a67c615ca0718ec16e37f8cab203bc087edab5b..35cad3ab2890993f13c30afc95fa956ef7775548 100644 (file)
@@ -26,7 +26,7 @@
 
 #include <QMainWindow>
 
-#include "sigsession.hpp"
+#include "session.hpp"
 
 struct srd_decoder;
 
index f8061d9ac2c3514ba72cf2bea5cc06a316373238..f30ce627d72f3ae675571506f5eb58b878a57570 100644 (file)
@@ -28,7 +28,7 @@
 #include "channels.hpp"
 
 #include <pv/prop/binding/deviceoptions.hpp>
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 #include <pv/view/signal.hpp>
 
 #include <libsigrok/libsigrok.hpp>
diff --git a/pv/session.cpp b/pv/session.cpp
new file mode 100644 (file)
index 0000000..5e3b492
--- /dev/null
@@ -0,0 +1,660 @@
+/*
+ * This file is part of the PulseView project.
+ *
+ * Copyright (C) 2012-14 Joel Holdsworth <joel@airwebreathe.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * 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
+ */
+
+#ifdef ENABLE_DECODE
+#include <libsigrokdecode/libsigrokdecode.h>
+#endif
+
+#include "session.hpp"
+
+#include "devicemanager.hpp"
+
+#include "data/analog.hpp"
+#include "data/analogsnapshot.hpp"
+#include "data/decoderstack.hpp"
+#include "data/logic.hpp"
+#include "data/logicsnapshot.hpp"
+#include "data/decode/decoder.hpp"
+
+#include "view/analogsignal.hpp"
+#include "view/decodetrace.hpp"
+#include "view/logicsignal.hpp"
+
+#include <cassert>
+#include <mutex>
+#include <stdexcept>
+
+#include <sys/stat.h>
+
+#include <QDebug>
+
+#include <libsigrok/libsigrok.hpp>
+
+using boost::shared_lock;
+using boost::shared_mutex;
+using boost::unique_lock;
+
+using std::dynamic_pointer_cast;
+using std::function;
+using std::lock_guard;
+using std::list;
+using std::map;
+using std::mutex;
+using std::set;
+using std::shared_ptr;
+using std::string;
+using std::vector;
+
+using sigrok::Analog;
+using sigrok::Channel;
+using sigrok::ChannelType;
+using sigrok::ConfigKey;
+using sigrok::DatafeedCallbackFunction;
+using sigrok::Device;
+using sigrok::Error;
+using sigrok::HardwareDevice;
+using sigrok::Header;
+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) :
+       device_manager_(device_manager),
+       session_(device_manager.context()->create_session()),
+       capture_state_(Stopped)
+{
+       set_default_device();
+}
+
+Session::~Session()
+{
+       // Stop and join to the thread
+       stop_capture();
+}
+
+DeviceManager& Session::device_manager()
+{
+       return device_manager_;
+}
+
+const DeviceManager& Session::device_manager() const
+{
+       return device_manager_;
+}
+
+const shared_ptr<sigrok::Session>& Session::session() const
+{
+       return session_;
+}
+
+shared_ptr<Device> Session::device() const
+{
+       return device_;
+}
+
+void Session::set_device(shared_ptr<Device> device)
+{
+       // Ensure we are not capturing before setting the device
+       stop_capture();
+
+       // Are we setting a session device?
+       auto session_device = dynamic_pointer_cast<SessionDevice>(device);
+       // Did we have a session device selected previously?
+       auto prev_session_device = dynamic_pointer_cast<SessionDevice>(device_);
+
+       if (device_) {
+               session_->remove_datafeed_callbacks();
+               if (!prev_session_device) {
+                       device_->close();
+                       session_->remove_devices();
+               }
+       }
+
+       if (session_device)
+               session_ = session_device->parent();
+
+       decode_traces_.clear();
+
+       if (device) {
+               if (!session_device)
+               {
+                       session_ = device_manager_.context()->create_session();
+
+                       try {
+                               device->open();
+                       } catch(const sigrok::Error &e) {
+                               throw QString(e.what());
+                       }
+
+                       session_->add_device(device);
+               }
+
+               device_ = device;
+               session_->add_datafeed_callback([=]
+                       (shared_ptr<Device> device, shared_ptr<Packet> packet) {
+                               data_feed_in(device, packet);
+                       });
+               update_signals(device);
+       } else
+               device_ = nullptr;
+
+       device_selected();
+}
+
+void Session::set_file(const string &name)
+{
+       session_ = device_manager_.context()->load_session(name);
+       device_ = session_->devices()[0];
+       decode_traces_.clear();
+       session_->add_datafeed_callback([=]
+               (shared_ptr<Device> device, shared_ptr<Packet> packet) {
+                       data_feed_in(device, packet);
+               });
+       device_manager_.update_display_name(device_);
+       update_signals(device_);
+       device_selected();
+}
+
+void Session::set_default_device()
+{
+       shared_ptr<HardwareDevice> default_device;
+       const list< shared_ptr<HardwareDevice> > &devices =
+               device_manager_.devices();
+
+       if (!devices.empty()) {
+               // Fall back to the first device in the list.
+               default_device = devices.front();
+
+               // Try and find the demo device and select that by default
+               for (shared_ptr<HardwareDevice> dev : devices)
+                       if (dev->driver()->name().compare("demo") == 0) {
+                               default_device = dev;
+                               break;
+                       }
+
+               set_device(default_device);
+       }
+}
+
+Session::capture_state Session::get_capture_state() const
+{
+       lock_guard<mutex> lock(sampling_mutex_);
+       return capture_state_;
+}
+
+void Session::start_capture(function<void (const QString)> error_handler)
+{
+       stop_capture();
+
+       // Check that a device instance has been selected.
+       if (!device_) {
+               qDebug() << "No device selected";
+               return;
+       }
+
+       // Check that at least one channel is enabled
+       auto channels = device_->channels();
+       bool enabled = std::any_of(channels.begin(), channels.end(),
+               [](shared_ptr<Channel> channel) { return channel->enabled(); });
+
+       if (!enabled) {
+               error_handler(tr("No channels enabled."));
+               return;
+       }
+
+       // Begin the session
+       sampling_thread_ = std::thread(
+               &Session::sample_thread_proc, this, device_,
+                       error_handler);
+}
+
+void Session::stop_capture()
+{
+       if (get_capture_state() != Stopped)
+               session_->stop();
+
+       // Check that sampling stopped
+       if (sampling_thread_.joinable())
+               sampling_thread_.join();
+}
+
+set< shared_ptr<data::SignalData> > Session::get_data() const
+{
+       shared_lock<shared_mutex> lock(signals_mutex_);
+       set< shared_ptr<data::SignalData> > data;
+       for (const shared_ptr<view::Signal> sig : signals_) {
+               assert(sig);
+               data.insert(sig->data());
+       }
+
+       return data;
+}
+
+boost::shared_mutex& Session::signals_mutex() const
+{
+       return signals_mutex_;
+}
+
+const vector< shared_ptr<view::Signal> >& Session::signals() const
+{
+       return signals_;
+}
+
+#ifdef ENABLE_DECODE
+bool Session::add_decoder(srd_decoder *const dec)
+{
+       map<const srd_channel*, shared_ptr<view::LogicSignal> > channels;
+       shared_ptr<data::DecoderStack> decoder_stack;
+
+       try
+       {
+               lock_guard<boost::shared_mutex> lock(signals_mutex_);
+
+               // Create the decoder
+               decoder_stack = shared_ptr<data::DecoderStack>(
+                       new data::DecoderStack(*this, dec));
+
+               // Make a list of all the channels
+               std::vector<const srd_channel*> all_channels;
+               for(const GSList *i = dec->channels; i; i = i->next)
+                       all_channels.push_back((const srd_channel*)i->data);
+               for(const GSList *i = dec->opt_channels; i; i = i->next)
+                       all_channels.push_back((const srd_channel*)i->data);
+
+               // Auto select the initial channels
+               for (const srd_channel *pdch : all_channels)
+                       for (shared_ptr<view::Signal> s : signals_)
+                       {
+                               shared_ptr<view::LogicSignal> l =
+                                       dynamic_pointer_cast<view::LogicSignal>(s);
+                               if (l && QString::fromUtf8(pdch->name).
+                                       toLower().contains(
+                                       l->name().toLower()))
+                                       channels[pdch] = l;
+                       }
+
+               assert(decoder_stack);
+               assert(!decoder_stack->stack().empty());
+               assert(decoder_stack->stack().front());
+               decoder_stack->stack().front()->set_channels(channels);
+
+               // Create the decode signal
+               shared_ptr<view::DecodeTrace> d(
+                       new view::DecodeTrace(*this, decoder_stack,
+                               decode_traces_.size()));
+               decode_traces_.push_back(d);
+       }
+       catch(std::runtime_error e)
+       {
+               return false;
+       }
+
+       signals_changed();
+
+       // Do an initial decode
+       decoder_stack->begin_decode();
+
+       return true;
+}
+
+vector< shared_ptr<view::DecodeTrace> > Session::get_decode_signals() const
+{
+       shared_lock<shared_mutex> lock(signals_mutex_);
+       return decode_traces_;
+}
+
+void Session::remove_decode_signal(view::DecodeTrace *signal)
+{
+       for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++)
+               if ((*i).get() == signal)
+               {
+                       decode_traces_.erase(i);
+                       signals_changed();
+                       return;
+               }
+}
+#endif
+
+void Session::set_capture_state(capture_state state)
+{
+       lock_guard<mutex> lock(sampling_mutex_);
+       const bool changed = capture_state_ != state;
+       capture_state_ = state;
+       if(changed)
+               capture_state_changed(state);
+}
+
+void Session::update_signals(shared_ptr<Device> device)
+{
+       assert(device);
+       assert(capture_state_ == Stopped);
+
+       // Clear the decode traces
+       decode_traces_.clear();
+
+       // Detect what data types we will receive
+       auto channels = device->channels();
+       unsigned int logic_channel_count = std::count_if(
+               channels.begin(), channels.end(),
+               [] (shared_ptr<Channel> channel) {
+                       return channel->type() == ChannelType::LOGIC; });
+
+       // Create data containers for the logic data snapshots
+       {
+               lock_guard<mutex> data_lock(data_mutex_);
+
+               logic_data_.reset();
+               if (logic_channel_count != 0) {
+                       logic_data_.reset(new data::Logic(
+                               logic_channel_count));
+                       assert(logic_data_);
+               }
+       }
+
+       // Make the Signals list
+       {
+               unique_lock<shared_mutex> lock(signals_mutex_);
+
+               signals_.clear();
+
+               for (auto channel : device->channels()) {
+                       shared_ptr<view::Signal> signal;
+
+                       switch(channel->type()->id()) {
+                       case SR_CHANNEL_LOGIC:
+                               signal = shared_ptr<view::Signal>(
+                                       new view::LogicSignal(*this, device,
+                                               channel, logic_data_));
+                               break;
+
+                       case SR_CHANNEL_ANALOG:
+                       {
+                               shared_ptr<data::Analog> data(
+                                       new data::Analog());
+                               signal = shared_ptr<view::Signal>(
+                                       new view::AnalogSignal(
+                                               *this, channel, data));
+                               break;
+                       }
+
+                       default:
+                               assert(0);
+                               break;
+                       }
+
+                       assert(signal);
+                       signals_.push_back(signal);
+               }
+
+       }
+
+       signals_changed();
+}
+
+shared_ptr<view::Signal> Session::signal_from_channel(
+       shared_ptr<Channel> channel) const
+{
+       lock_guard<boost::shared_mutex> lock(signals_mutex_);
+       for (shared_ptr<view::Signal> sig : signals_) {
+               assert(sig);
+               if (sig->channel() == channel)
+                       return sig;
+       }
+       return shared_ptr<view::Signal>();
+}
+
+void Session::read_sample_rate(shared_ptr<Device> device)
+{
+       const auto keys = device_->config_keys(ConfigKey::DEVICE_OPTIONS);
+       const auto iter = keys.find(ConfigKey::SAMPLERATE);
+       const uint64_t sample_rate = (iter != keys.end() &&
+               (*iter).second.find(sigrok::GET) != (*iter).second.end()) ?
+               VariantBase::cast_dynamic<Variant<guint64>>(
+                       device->config_get(ConfigKey::SAMPLERATE)).get() : 0;
+
+       // Set the sample rate of all data
+       const set< shared_ptr<data::SignalData> > data_set = get_data();
+       for (shared_ptr<data::SignalData> data : data_set) {
+               assert(data);
+               data->set_samplerate(sample_rate);
+       }
+}
+
+void Session::sample_thread_proc(shared_ptr<Device> device,
+       function<void (const QString)> error_handler)
+{
+       assert(device);
+       assert(error_handler);
+
+       read_sample_rate(device);
+
+       try {
+               session_->start();
+       } catch(Error e) {
+               error_handler(e.what());
+               return;
+       }
+
+       set_capture_state(session_->trigger() ?
+               AwaitingTrigger : Running);
+
+       session_->run();
+       set_capture_state(Stopped);
+
+       // Confirm that SR_DF_END was received
+       if (cur_logic_snapshot_)
+       {
+               qDebug("SR_DF_END was not received.");
+               assert(0);
+       }
+}
+
+void Session::feed_in_header(shared_ptr<Device> device)
+{
+       read_sample_rate(device);
+}
+
+void Session::feed_in_meta(shared_ptr<Device> device,
+       shared_ptr<Meta> meta)
+{
+       (void)device;
+
+       for (auto entry : meta->config()) {
+               switch (entry.first->id()) {
+               case SR_CONF_SAMPLERATE:
+                       /// @todo handle samplerate changes
+                       break;
+               default:
+                       // Unknown metadata is not an error.
+                       break;
+               }
+       }
+
+       signals_changed();
+}
+
+void Session::feed_in_frame_begin()
+{
+       if (cur_logic_snapshot_ || !cur_analog_snapshots_.empty())
+               frame_began();
+}
+
+void Session::feed_in_logic(shared_ptr<Logic> logic)
+{
+       lock_guard<mutex> lock(data_mutex_);
+
+       if (!logic_data_)
+       {
+               qDebug() << "Unexpected logic packet";
+               return;
+       }
+
+       if (!cur_logic_snapshot_)
+       {
+               // This could be the first packet after a trigger
+               set_capture_state(Running);
+
+               // Get sample limit.
+               const auto keys = device_->config_keys(
+                       ConfigKey::DEVICE_OPTIONS);
+               const auto iter = keys.find(ConfigKey::LIMIT_SAMPLES);
+               const uint64_t sample_limit = (iter != keys.end() &&
+                       (*iter).second.find(sigrok::GET) !=
+                       (*iter).second.end()) ?
+                       VariantBase::cast_dynamic<Variant<guint64>>(
+                       device_->config_get(ConfigKey::LIMIT_SAMPLES)).get() : 0;
+
+               // Create a new data snapshot
+               cur_logic_snapshot_ = shared_ptr<data::LogicSnapshot>(
+                       new data::LogicSnapshot(logic, sample_limit));
+               logic_data_->push_snapshot(cur_logic_snapshot_);
+
+               // @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();
+       }
+       else
+       {
+               // Append to the existing data snapshot
+               cur_logic_snapshot_->append_payload(logic);
+       }
+
+       data_received();
+}
+
+void Session::feed_in_analog(shared_ptr<Analog> analog)
+{
+       lock_guard<mutex> lock(data_mutex_);
+
+       const vector<shared_ptr<Channel>> channels = analog->channels();
+       const unsigned int channel_count = channels.size();
+       const size_t sample_count = analog->num_samples() / channel_count;
+       const float *data = analog->data_pointer();
+       bool sweep_beginning = false;
+
+       for (auto channel : channels)
+       {
+               shared_ptr<data::AnalogSnapshot> snapshot;
+
+               // Try to get the snapshot of the channel
+               const map< shared_ptr<Channel>, shared_ptr<data::AnalogSnapshot> >::
+                       iterator iter = cur_analog_snapshots_.find(channel);
+               if (iter != cur_analog_snapshots_.end())
+                       snapshot = (*iter).second;
+               else
+               {
+                       // If no snapshot was found, this means we havn't
+                       // created one yet. i.e. this is the first packet
+                       // in the sweep containing this snapshot.
+                       sweep_beginning = true;
+
+                       // Get sample limit.
+                       uint64_t sample_limit;
+                       try {
+                               sample_limit = VariantBase::cast_dynamic<Variant<guint64>>(
+                                       device_->config_get(ConfigKey::LIMIT_SAMPLES)).get();
+                       } catch (Error) {
+                               sample_limit = 0;
+                       }
+
+                       // Create a snapshot, keep it in the maps of channels
+                       snapshot = shared_ptr<data::AnalogSnapshot>(
+                               new data::AnalogSnapshot(sample_limit));
+                       cur_analog_snapshots_[channel] = snapshot;
+
+                       // Find the annalog data associated with the channel
+                       shared_ptr<view::AnalogSignal> sig =
+                               dynamic_pointer_cast<view::AnalogSignal>(
+                                       signal_from_channel(channel));
+                       assert(sig);
+
+                       shared_ptr<data::Analog> data(sig->analog_data());
+                       assert(data);
+
+                       // Push the snapshot into the analog data.
+                       data->push_snapshot(snapshot);
+               }
+
+               assert(snapshot);
+
+               // Append the samples in the snapshot
+               snapshot->append_interleaved_samples(data++, sample_count,
+                       channel_count);
+       }
+
+       if (sweep_beginning) {
+               // This could be the first packet after a trigger
+               set_capture_state(Running);
+       }
+
+       data_received();
+}
+
+void Session::data_feed_in(shared_ptr<Device> device, shared_ptr<Packet> packet)
+{
+       assert(device);
+       assert(packet);
+
+       switch (packet->type()->id()) {
+       case SR_DF_HEADER:
+               feed_in_header(device);
+               break;
+
+       case SR_DF_META:
+               feed_in_meta(device, dynamic_pointer_cast<Meta>(packet->payload()));
+               break;
+
+       case SR_DF_FRAME_BEGIN:
+               feed_in_frame_begin();
+               break;
+
+       case SR_DF_LOGIC:
+               feed_in_logic(dynamic_pointer_cast<Logic>(packet->payload()));
+               break;
+
+       case SR_DF_ANALOG:
+               feed_in_analog(dynamic_pointer_cast<Analog>(packet->payload()));
+               break;
+
+       case SR_DF_END:
+       {
+               {
+                       lock_guard<mutex> lock(data_mutex_);
+                       cur_logic_snapshot_.reset();
+                       cur_analog_snapshots_.clear();
+               }
+               frame_ended();
+               break;
+       }
+       default:
+               break;
+       }
+}
+
+} // namespace pv
diff --git a/pv/session.hpp b/pv/session.hpp
new file mode 100644 (file)
index 0000000..c6a317d
--- /dev/null
@@ -0,0 +1,190 @@
+/*
+ * This file is part of the PulseView project.
+ *
+ * Copyright (C) 2012-14 Joel Holdsworth <joel@airwebreathe.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * 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
+ */
+
+#ifndef PULSEVIEW_PV_SIGSESSION_H
+#define PULSEVIEW_PV_SIGSESSION_H
+
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <boost/thread.hpp>
+
+#include <QObject>
+#include <QString>
+
+struct srd_decoder;
+struct srd_channel;
+
+namespace sigrok {
+       class Analog;
+       class Channel;
+       class Device;
+       class Logic;
+       class Meta;
+       class Packet;
+       class Session;
+}
+
+namespace pv {
+
+class DeviceManager;
+
+namespace data {
+class Analog;
+class AnalogSnapshot;
+class Logic;
+class LogicSnapshot;
+class SignalData;
+}
+
+namespace view {
+class DecodeTrace;
+class LogicSignal;
+class Signal;
+}
+
+class Session : public QObject
+{
+       Q_OBJECT
+
+public:
+       enum capture_state {
+               Stopped,
+               AwaitingTrigger,
+               Running
+       };
+
+public:
+       Session(DeviceManager &device_manager);
+
+       ~Session();
+
+       DeviceManager& device_manager();
+
+       const DeviceManager& device_manager() const;
+
+       const std::shared_ptr<sigrok::Session>& session() const;
+
+       std::shared_ptr<sigrok::Device> device() const;
+
+       /**
+        * Sets device instance that will be used in the next capture session.
+        */
+       void set_device(std::shared_ptr<sigrok::Device> device);
+
+       void set_file(const std::string &name);
+
+       void set_default_device();
+
+       capture_state get_capture_state() const;
+
+       void start_capture(std::function<void (const QString)> error_handler);
+
+       void stop_capture();
+
+       std::set< std::shared_ptr<data::SignalData> > get_data() const;
+
+       boost::shared_mutex& signals_mutex() const;
+
+       const std::vector< std::shared_ptr<view::Signal> >& signals() const;
+
+#ifdef ENABLE_DECODE
+       bool add_decoder(srd_decoder *const dec);
+
+       std::vector< std::shared_ptr<view::DecodeTrace> >
+               get_decode_signals() const;
+
+       void remove_decode_signal(view::DecodeTrace *signal);
+#endif
+
+private:
+       void set_capture_state(capture_state state);
+
+       void update_signals(std::shared_ptr<sigrok::Device> device);
+
+       std::shared_ptr<view::Signal> signal_from_channel(
+               std::shared_ptr<sigrok::Channel> channel) const;
+
+       void read_sample_rate(std::shared_ptr<sigrok::Device>);
+
+private:
+       void sample_thread_proc(std::shared_ptr<sigrok::Device> device,
+               std::function<void (const QString)> error_handler);
+
+       void feed_in_header(std::shared_ptr<sigrok::Device> device);
+
+       void feed_in_meta(std::shared_ptr<sigrok::Device> device,
+               std::shared_ptr<sigrok::Meta> meta);
+
+       void feed_in_frame_begin();
+
+       void feed_in_logic(std::shared_ptr<sigrok::Logic> logic);
+
+       void feed_in_analog(std::shared_ptr<sigrok::Analog> analog);
+
+       void data_feed_in(std::shared_ptr<sigrok::Device> device,
+               std::shared_ptr<sigrok::Packet> packet);
+
+private:
+       DeviceManager &device_manager_;
+       std::shared_ptr<sigrok::Session> session_;
+
+       /**
+        * The device instance that will be used in the next capture session.
+        */
+       std::shared_ptr<sigrok::Device> device_;
+
+       std::vector< std::shared_ptr<view::DecodeTrace> > decode_traces_;
+
+       mutable std::mutex sampling_mutex_;
+       capture_state capture_state_;
+
+       mutable boost::shared_mutex signals_mutex_;
+       std::vector< std::shared_ptr<view::Signal> > signals_;
+
+       mutable std::mutex data_mutex_;
+       std::shared_ptr<data::Logic> logic_data_;
+       std::shared_ptr<data::LogicSnapshot> cur_logic_snapshot_;
+       std::map< std::shared_ptr<sigrok::Channel>, std::shared_ptr<data::AnalogSnapshot> >
+               cur_analog_snapshots_;
+
+       std::thread sampling_thread_;
+
+Q_SIGNALS:
+       void capture_state_changed(int state);
+       void device_selected();
+
+       void signals_changed();
+
+       void frame_began();
+
+       void data_received();
+
+       void frame_ended();
+};
+
+} // namespace pv
+
+#endif // PULSEVIEW_PV_SIGSESSION_H
diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp
deleted file mode 100644 (file)
index 84c7589..0000000
+++ /dev/null
@@ -1,660 +0,0 @@
-/*
- * This file is part of the PulseView project.
- *
- * Copyright (C) 2012-14 Joel Holdsworth <joel@airwebreathe.org.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * 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
- */
-
-#ifdef ENABLE_DECODE
-#include <libsigrokdecode/libsigrokdecode.h>
-#endif
-
-#include "sigsession.hpp"
-
-#include "devicemanager.hpp"
-
-#include "data/analog.hpp"
-#include "data/analogsnapshot.hpp"
-#include "data/decoderstack.hpp"
-#include "data/logic.hpp"
-#include "data/logicsnapshot.hpp"
-#include "data/decode/decoder.hpp"
-
-#include "view/analogsignal.hpp"
-#include "view/decodetrace.hpp"
-#include "view/logicsignal.hpp"
-
-#include <cassert>
-#include <mutex>
-#include <stdexcept>
-
-#include <sys/stat.h>
-
-#include <QDebug>
-
-#include <libsigrok/libsigrok.hpp>
-
-using boost::shared_lock;
-using boost::shared_mutex;
-using boost::unique_lock;
-
-using std::dynamic_pointer_cast;
-using std::function;
-using std::lock_guard;
-using std::list;
-using std::map;
-using std::mutex;
-using std::set;
-using std::shared_ptr;
-using std::string;
-using std::vector;
-
-using sigrok::Analog;
-using sigrok::Channel;
-using sigrok::ChannelType;
-using sigrok::ConfigKey;
-using sigrok::DatafeedCallbackFunction;
-using sigrok::Device;
-using sigrok::Error;
-using sigrok::HardwareDevice;
-using sigrok::Header;
-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) :
-       device_manager_(device_manager),
-       session_(device_manager.context()->create_session()),
-       capture_state_(Stopped)
-{
-       set_default_device();
-}
-
-Session::~Session()
-{
-       // Stop and join to the thread
-       stop_capture();
-}
-
-DeviceManager& Session::device_manager()
-{
-       return device_manager_;
-}
-
-const DeviceManager& Session::device_manager() const
-{
-       return device_manager_;
-}
-
-const shared_ptr<sigrok::Session>& Session::session() const
-{
-       return session_;
-}
-
-shared_ptr<Device> Session::device() const
-{
-       return device_;
-}
-
-void Session::set_device(shared_ptr<Device> device)
-{
-       // Ensure we are not capturing before setting the device
-       stop_capture();
-
-       // Are we setting a session device?
-       auto session_device = dynamic_pointer_cast<SessionDevice>(device);
-       // Did we have a session device selected previously?
-       auto prev_session_device = dynamic_pointer_cast<SessionDevice>(device_);
-
-       if (device_) {
-               session_->remove_datafeed_callbacks();
-               if (!prev_session_device) {
-                       device_->close();
-                       session_->remove_devices();
-               }
-       }
-
-       if (session_device)
-               session_ = session_device->parent();
-
-       decode_traces_.clear();
-
-       if (device) {
-               if (!session_device)
-               {
-                       session_ = device_manager_.context()->create_session();
-
-                       try {
-                               device->open();
-                       } catch(const sigrok::Error &e) {
-                               throw QString(e.what());
-                       }
-
-                       session_->add_device(device);
-               }
-
-               device_ = device;
-               session_->add_datafeed_callback([=]
-                       (shared_ptr<Device> device, shared_ptr<Packet> packet) {
-                               data_feed_in(device, packet);
-                       });
-               update_signals(device);
-       } else
-               device_ = nullptr;
-
-       device_selected();
-}
-
-void Session::set_file(const string &name)
-{
-       session_ = device_manager_.context()->load_session(name);
-       device_ = session_->devices()[0];
-       decode_traces_.clear();
-       session_->add_datafeed_callback([=]
-               (shared_ptr<Device> device, shared_ptr<Packet> packet) {
-                       data_feed_in(device, packet);
-               });
-       device_manager_.update_display_name(device_);
-       update_signals(device_);
-       device_selected();
-}
-
-void Session::set_default_device()
-{
-       shared_ptr<HardwareDevice> default_device;
-       const list< shared_ptr<HardwareDevice> > &devices =
-               device_manager_.devices();
-
-       if (!devices.empty()) {
-               // Fall back to the first device in the list.
-               default_device = devices.front();
-
-               // Try and find the demo device and select that by default
-               for (shared_ptr<HardwareDevice> dev : devices)
-                       if (dev->driver()->name().compare("demo") == 0) {
-                               default_device = dev;
-                               break;
-                       }
-
-               set_device(default_device);
-       }
-}
-
-Session::capture_state Session::get_capture_state() const
-{
-       lock_guard<mutex> lock(sampling_mutex_);
-       return capture_state_;
-}
-
-void Session::start_capture(function<void (const QString)> error_handler)
-{
-       stop_capture();
-
-       // Check that a device instance has been selected.
-       if (!device_) {
-               qDebug() << "No device selected";
-               return;
-       }
-
-       // Check that at least one channel is enabled
-       auto channels = device_->channels();
-       bool enabled = std::any_of(channels.begin(), channels.end(),
-               [](shared_ptr<Channel> channel) { return channel->enabled(); });
-
-       if (!enabled) {
-               error_handler(tr("No channels enabled."));
-               return;
-       }
-
-       // Begin the session
-       sampling_thread_ = std::thread(
-               &Session::sample_thread_proc, this, device_,
-                       error_handler);
-}
-
-void Session::stop_capture()
-{
-       if (get_capture_state() != Stopped)
-               session_->stop();
-
-       // Check that sampling stopped
-       if (sampling_thread_.joinable())
-               sampling_thread_.join();
-}
-
-set< shared_ptr<data::SignalData> > Session::get_data() const
-{
-       shared_lock<shared_mutex> lock(signals_mutex_);
-       set< shared_ptr<data::SignalData> > data;
-       for (const shared_ptr<view::Signal> sig : signals_) {
-               assert(sig);
-               data.insert(sig->data());
-       }
-
-       return data;
-}
-
-boost::shared_mutex& Session::signals_mutex() const
-{
-       return signals_mutex_;
-}
-
-const vector< shared_ptr<view::Signal> >& Session::signals() const
-{
-       return signals_;
-}
-
-#ifdef ENABLE_DECODE
-bool Session::add_decoder(srd_decoder *const dec)
-{
-       map<const srd_channel*, shared_ptr<view::LogicSignal> > channels;
-       shared_ptr<data::DecoderStack> decoder_stack;
-
-       try
-       {
-               lock_guard<boost::shared_mutex> lock(signals_mutex_);
-
-               // Create the decoder
-               decoder_stack = shared_ptr<data::DecoderStack>(
-                       new data::DecoderStack(*this, dec));
-
-               // Make a list of all the channels
-               std::vector<const srd_channel*> all_channels;
-               for(const GSList *i = dec->channels; i; i = i->next)
-                       all_channels.push_back((const srd_channel*)i->data);
-               for(const GSList *i = dec->opt_channels; i; i = i->next)
-                       all_channels.push_back((const srd_channel*)i->data);
-
-               // Auto select the initial channels
-               for (const srd_channel *pdch : all_channels)
-                       for (shared_ptr<view::Signal> s : signals_)
-                       {
-                               shared_ptr<view::LogicSignal> l =
-                                       dynamic_pointer_cast<view::LogicSignal>(s);
-                               if (l && QString::fromUtf8(pdch->name).
-                                       toLower().contains(
-                                       l->name().toLower()))
-                                       channels[pdch] = l;
-                       }
-
-               assert(decoder_stack);
-               assert(!decoder_stack->stack().empty());
-               assert(decoder_stack->stack().front());
-               decoder_stack->stack().front()->set_channels(channels);
-
-               // Create the decode signal
-               shared_ptr<view::DecodeTrace> d(
-                       new view::DecodeTrace(*this, decoder_stack,
-                               decode_traces_.size()));
-               decode_traces_.push_back(d);
-       }
-       catch(std::runtime_error e)
-       {
-               return false;
-       }
-
-       signals_changed();
-
-       // Do an initial decode
-       decoder_stack->begin_decode();
-
-       return true;
-}
-
-vector< shared_ptr<view::DecodeTrace> > Session::get_decode_signals() const
-{
-       shared_lock<shared_mutex> lock(signals_mutex_);
-       return decode_traces_;
-}
-
-void Session::remove_decode_signal(view::DecodeTrace *signal)
-{
-       for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++)
-               if ((*i).get() == signal)
-               {
-                       decode_traces_.erase(i);
-                       signals_changed();
-                       return;
-               }
-}
-#endif
-
-void Session::set_capture_state(capture_state state)
-{
-       lock_guard<mutex> lock(sampling_mutex_);
-       const bool changed = capture_state_ != state;
-       capture_state_ = state;
-       if(changed)
-               capture_state_changed(state);
-}
-
-void Session::update_signals(shared_ptr<Device> device)
-{
-       assert(device);
-       assert(capture_state_ == Stopped);
-
-       // Clear the decode traces
-       decode_traces_.clear();
-
-       // Detect what data types we will receive
-       auto channels = device->channels();
-       unsigned int logic_channel_count = std::count_if(
-               channels.begin(), channels.end(),
-               [] (shared_ptr<Channel> channel) {
-                       return channel->type() == ChannelType::LOGIC; });
-
-       // Create data containers for the logic data snapshots
-       {
-               lock_guard<mutex> data_lock(data_mutex_);
-
-               logic_data_.reset();
-               if (logic_channel_count != 0) {
-                       logic_data_.reset(new data::Logic(
-                               logic_channel_count));
-                       assert(logic_data_);
-               }
-       }
-
-       // Make the Signals list
-       {
-               unique_lock<shared_mutex> lock(signals_mutex_);
-
-               signals_.clear();
-
-               for (auto channel : device->channels()) {
-                       shared_ptr<view::Signal> signal;
-
-                       switch(channel->type()->id()) {
-                       case SR_CHANNEL_LOGIC:
-                               signal = shared_ptr<view::Signal>(
-                                       new view::LogicSignal(*this, device,
-                                               channel, logic_data_));
-                               break;
-
-                       case SR_CHANNEL_ANALOG:
-                       {
-                               shared_ptr<data::Analog> data(
-                                       new data::Analog());
-                               signal = shared_ptr<view::Signal>(
-                                       new view::AnalogSignal(
-                                               *this, channel, data));
-                               break;
-                       }
-
-                       default:
-                               assert(0);
-                               break;
-                       }
-
-                       assert(signal);
-                       signals_.push_back(signal);
-               }
-
-       }
-
-       signals_changed();
-}
-
-shared_ptr<view::Signal> Session::signal_from_channel(
-       shared_ptr<Channel> channel) const
-{
-       lock_guard<boost::shared_mutex> lock(signals_mutex_);
-       for (shared_ptr<view::Signal> sig : signals_) {
-               assert(sig);
-               if (sig->channel() == channel)
-                       return sig;
-       }
-       return shared_ptr<view::Signal>();
-}
-
-void Session::read_sample_rate(shared_ptr<Device> device)
-{
-       const auto keys = device_->config_keys(ConfigKey::DEVICE_OPTIONS);
-       const auto iter = keys.find(ConfigKey::SAMPLERATE);
-       const uint64_t sample_rate = (iter != keys.end() &&
-               (*iter).second.find(sigrok::GET) != (*iter).second.end()) ?
-               VariantBase::cast_dynamic<Variant<guint64>>(
-                       device->config_get(ConfigKey::SAMPLERATE)).get() : 0;
-
-       // Set the sample rate of all data
-       const set< shared_ptr<data::SignalData> > data_set = get_data();
-       for (shared_ptr<data::SignalData> data : data_set) {
-               assert(data);
-               data->set_samplerate(sample_rate);
-       }
-}
-
-void Session::sample_thread_proc(shared_ptr<Device> device,
-       function<void (const QString)> error_handler)
-{
-       assert(device);
-       assert(error_handler);
-
-       read_sample_rate(device);
-
-       try {
-               session_->start();
-       } catch(Error e) {
-               error_handler(e.what());
-               return;
-       }
-
-       set_capture_state(session_->trigger() ?
-               AwaitingTrigger : Running);
-
-       session_->run();
-       set_capture_state(Stopped);
-
-       // Confirm that SR_DF_END was received
-       if (cur_logic_snapshot_)
-       {
-               qDebug("SR_DF_END was not received.");
-               assert(0);
-       }
-}
-
-void Session::feed_in_header(shared_ptr<Device> device)
-{
-       read_sample_rate(device);
-}
-
-void Session::feed_in_meta(shared_ptr<Device> device,
-       shared_ptr<Meta> meta)
-{
-       (void)device;
-
-       for (auto entry : meta->config()) {
-               switch (entry.first->id()) {
-               case SR_CONF_SAMPLERATE:
-                       /// @todo handle samplerate changes
-                       break;
-               default:
-                       // Unknown metadata is not an error.
-                       break;
-               }
-       }
-
-       signals_changed();
-}
-
-void Session::feed_in_frame_begin()
-{
-       if (cur_logic_snapshot_ || !cur_analog_snapshots_.empty())
-               frame_began();
-}
-
-void Session::feed_in_logic(shared_ptr<Logic> logic)
-{
-       lock_guard<mutex> lock(data_mutex_);
-
-       if (!logic_data_)
-       {
-               qDebug() << "Unexpected logic packet";
-               return;
-       }
-
-       if (!cur_logic_snapshot_)
-       {
-               // This could be the first packet after a trigger
-               set_capture_state(Running);
-
-               // Get sample limit.
-               const auto keys = device_->config_keys(
-                       ConfigKey::DEVICE_OPTIONS);
-               const auto iter = keys.find(ConfigKey::LIMIT_SAMPLES);
-               const uint64_t sample_limit = (iter != keys.end() &&
-                       (*iter).second.find(sigrok::GET) !=
-                       (*iter).second.end()) ?
-                       VariantBase::cast_dynamic<Variant<guint64>>(
-                       device_->config_get(ConfigKey::LIMIT_SAMPLES)).get() : 0;
-
-               // Create a new data snapshot
-               cur_logic_snapshot_ = shared_ptr<data::LogicSnapshot>(
-                       new data::LogicSnapshot(logic, sample_limit));
-               logic_data_->push_snapshot(cur_logic_snapshot_);
-
-               // @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();
-       }
-       else
-       {
-               // Append to the existing data snapshot
-               cur_logic_snapshot_->append_payload(logic);
-       }
-
-       data_received();
-}
-
-void Session::feed_in_analog(shared_ptr<Analog> analog)
-{
-       lock_guard<mutex> lock(data_mutex_);
-
-       const vector<shared_ptr<Channel>> channels = analog->channels();
-       const unsigned int channel_count = channels.size();
-       const size_t sample_count = analog->num_samples() / channel_count;
-       const float *data = analog->data_pointer();
-       bool sweep_beginning = false;
-
-       for (auto channel : channels)
-       {
-               shared_ptr<data::AnalogSnapshot> snapshot;
-
-               // Try to get the snapshot of the channel
-               const map< shared_ptr<Channel>, shared_ptr<data::AnalogSnapshot> >::
-                       iterator iter = cur_analog_snapshots_.find(channel);
-               if (iter != cur_analog_snapshots_.end())
-                       snapshot = (*iter).second;
-               else
-               {
-                       // If no snapshot was found, this means we havn't
-                       // created one yet. i.e. this is the first packet
-                       // in the sweep containing this snapshot.
-                       sweep_beginning = true;
-
-                       // Get sample limit.
-                       uint64_t sample_limit;
-                       try {
-                               sample_limit = VariantBase::cast_dynamic<Variant<guint64>>(
-                                       device_->config_get(ConfigKey::LIMIT_SAMPLES)).get();
-                       } catch (Error) {
-                               sample_limit = 0;
-                       }
-
-                       // Create a snapshot, keep it in the maps of channels
-                       snapshot = shared_ptr<data::AnalogSnapshot>(
-                               new data::AnalogSnapshot(sample_limit));
-                       cur_analog_snapshots_[channel] = snapshot;
-
-                       // Find the annalog data associated with the channel
-                       shared_ptr<view::AnalogSignal> sig =
-                               dynamic_pointer_cast<view::AnalogSignal>(
-                                       signal_from_channel(channel));
-                       assert(sig);
-
-                       shared_ptr<data::Analog> data(sig->analog_data());
-                       assert(data);
-
-                       // Push the snapshot into the analog data.
-                       data->push_snapshot(snapshot);
-               }
-
-               assert(snapshot);
-
-               // Append the samples in the snapshot
-               snapshot->append_interleaved_samples(data++, sample_count,
-                       channel_count);
-       }
-
-       if (sweep_beginning) {
-               // This could be the first packet after a trigger
-               set_capture_state(Running);
-       }
-
-       data_received();
-}
-
-void Session::data_feed_in(shared_ptr<Device> device, shared_ptr<Packet> packet)
-{
-       assert(device);
-       assert(packet);
-
-       switch (packet->type()->id()) {
-       case SR_DF_HEADER:
-               feed_in_header(device);
-               break;
-
-       case SR_DF_META:
-               feed_in_meta(device, dynamic_pointer_cast<Meta>(packet->payload()));
-               break;
-
-       case SR_DF_FRAME_BEGIN:
-               feed_in_frame_begin();
-               break;
-
-       case SR_DF_LOGIC:
-               feed_in_logic(dynamic_pointer_cast<Logic>(packet->payload()));
-               break;
-
-       case SR_DF_ANALOG:
-               feed_in_analog(dynamic_pointer_cast<Analog>(packet->payload()));
-               break;
-
-       case SR_DF_END:
-       {
-               {
-                       lock_guard<mutex> lock(data_mutex_);
-                       cur_logic_snapshot_.reset();
-                       cur_analog_snapshots_.clear();
-               }
-               frame_ended();
-               break;
-       }
-       default:
-               break;
-       }
-}
-
-} // namespace pv
diff --git a/pv/sigsession.hpp b/pv/sigsession.hpp
deleted file mode 100644 (file)
index c6a317d..0000000
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * This file is part of the PulseView project.
- *
- * Copyright (C) 2012-14 Joel Holdsworth <joel@airwebreathe.org.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * 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
- */
-
-#ifndef PULSEVIEW_PV_SIGSESSION_H
-#define PULSEVIEW_PV_SIGSESSION_H
-
-#include <map>
-#include <memory>
-#include <mutex>
-#include <set>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include <boost/thread.hpp>
-
-#include <QObject>
-#include <QString>
-
-struct srd_decoder;
-struct srd_channel;
-
-namespace sigrok {
-       class Analog;
-       class Channel;
-       class Device;
-       class Logic;
-       class Meta;
-       class Packet;
-       class Session;
-}
-
-namespace pv {
-
-class DeviceManager;
-
-namespace data {
-class Analog;
-class AnalogSnapshot;
-class Logic;
-class LogicSnapshot;
-class SignalData;
-}
-
-namespace view {
-class DecodeTrace;
-class LogicSignal;
-class Signal;
-}
-
-class Session : public QObject
-{
-       Q_OBJECT
-
-public:
-       enum capture_state {
-               Stopped,
-               AwaitingTrigger,
-               Running
-       };
-
-public:
-       Session(DeviceManager &device_manager);
-
-       ~Session();
-
-       DeviceManager& device_manager();
-
-       const DeviceManager& device_manager() const;
-
-       const std::shared_ptr<sigrok::Session>& session() const;
-
-       std::shared_ptr<sigrok::Device> device() const;
-
-       /**
-        * Sets device instance that will be used in the next capture session.
-        */
-       void set_device(std::shared_ptr<sigrok::Device> device);
-
-       void set_file(const std::string &name);
-
-       void set_default_device();
-
-       capture_state get_capture_state() const;
-
-       void start_capture(std::function<void (const QString)> error_handler);
-
-       void stop_capture();
-
-       std::set< std::shared_ptr<data::SignalData> > get_data() const;
-
-       boost::shared_mutex& signals_mutex() const;
-
-       const std::vector< std::shared_ptr<view::Signal> >& signals() const;
-
-#ifdef ENABLE_DECODE
-       bool add_decoder(srd_decoder *const dec);
-
-       std::vector< std::shared_ptr<view::DecodeTrace> >
-               get_decode_signals() const;
-
-       void remove_decode_signal(view::DecodeTrace *signal);
-#endif
-
-private:
-       void set_capture_state(capture_state state);
-
-       void update_signals(std::shared_ptr<sigrok::Device> device);
-
-       std::shared_ptr<view::Signal> signal_from_channel(
-               std::shared_ptr<sigrok::Channel> channel) const;
-
-       void read_sample_rate(std::shared_ptr<sigrok::Device>);
-
-private:
-       void sample_thread_proc(std::shared_ptr<sigrok::Device> device,
-               std::function<void (const QString)> error_handler);
-
-       void feed_in_header(std::shared_ptr<sigrok::Device> device);
-
-       void feed_in_meta(std::shared_ptr<sigrok::Device> device,
-               std::shared_ptr<sigrok::Meta> meta);
-
-       void feed_in_frame_begin();
-
-       void feed_in_logic(std::shared_ptr<sigrok::Logic> logic);
-
-       void feed_in_analog(std::shared_ptr<sigrok::Analog> analog);
-
-       void data_feed_in(std::shared_ptr<sigrok::Device> device,
-               std::shared_ptr<sigrok::Packet> packet);
-
-private:
-       DeviceManager &device_manager_;
-       std::shared_ptr<sigrok::Session> session_;
-
-       /**
-        * The device instance that will be used in the next capture session.
-        */
-       std::shared_ptr<sigrok::Device> device_;
-
-       std::vector< std::shared_ptr<view::DecodeTrace> > decode_traces_;
-
-       mutable std::mutex sampling_mutex_;
-       capture_state capture_state_;
-
-       mutable boost::shared_mutex signals_mutex_;
-       std::vector< std::shared_ptr<view::Signal> > signals_;
-
-       mutable std::mutex data_mutex_;
-       std::shared_ptr<data::Logic> logic_data_;
-       std::shared_ptr<data::LogicSnapshot> cur_logic_snapshot_;
-       std::map< std::shared_ptr<sigrok::Channel>, std::shared_ptr<data::AnalogSnapshot> >
-               cur_analog_snapshots_;
-
-       std::thread sampling_thread_;
-
-Q_SIGNALS:
-       void capture_state_changed(int state);
-       void device_selected();
-
-       void signals_changed();
-
-       void frame_began();
-
-       void data_received();
-
-       void frame_ended();
-};
-
-} // namespace pv
-
-#endif // PULSEVIEW_PV_SIGSESSION_H
index 221804c40baaf07721f7c229704f5cae072f1ca4..2e90871cbcd3a6bda936e6efb863df1a21135c20 100644 (file)
@@ -22,7 +22,7 @@
 
 #include "storesession.hpp"
 
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 #include <pv/data/logic.hpp>
 #include <pv/data/logicsnapshot.hpp>
 #include <pv/view/signal.hpp>
index 25ce23ae9ccffb9463966652e988eb3d8092e9f4..436304bc4ca915c88ee5a0f266a55ed66dcd2765 100644 (file)
@@ -31,7 +31,7 @@
 #include <QToolBar>
 #include <QToolButton>
 
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 #include <pv/widgets/popuptoolbutton.hpp>
 #include <pv/widgets/sweeptimingwidget.hpp>
 
index 790589568582003b70f2ceb948a7803b4ae07fc1..0fbd16fd22b5e636a6b71d1ef3c27cea3d01fe40 100644 (file)
@@ -41,7 +41,7 @@ extern "C" {
 
 #include "decodetrace.hpp"
 
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 #include <pv/data/decoderstack.hpp>
 #include <pv/data/decode/decoder.hpp>
 #include <pv/data/logic.hpp>
index 08b3fdd2e07fa48ecfcc9a6fa9bb986bfffbcc9f..2269849c24da9886fd3ff132dfffb7e27bf017a4 100644 (file)
@@ -35,7 +35,7 @@
 #include <QPainter>
 #include <QRect>
 
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 #include <pv/widgets/popup.hpp>
 
 using boost::make_filter_iterator;
index 22b39bbbcfaa49f907696c005fb991508e3cb3eb..fc81a4a92668663b26a9cf2ad7fa0113f72258f4 100644 (file)
@@ -31,7 +31,7 @@
 #include "logicsignal.hpp"
 #include "view.hpp"
 
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 #include <pv/devicemanager.hpp>
 #include <pv/data/logic.hpp>
 #include <pv/data/logicsnapshot.hpp>
index 110dc57418f0a280d8e050941993971b6138c1a8..577b471318bd8255cf4361fd90d5b6c84cb46f2a 100644 (file)
@@ -31,7 +31,7 @@
 
 #include <boost/thread.hpp>
 
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 
 namespace pv {
 namespace view {
index c96063536c0e917bc86336bbf2d7cb071a63b3c6..a5114027713c0ffa63aab9f754d4855cc9815230 100644 (file)
@@ -44,7 +44,7 @@
 #include "view.hpp"
 #include "viewport.hpp"
 
-#include "pv/sigsession.hpp"
+#include "pv/session.hpp"
 #include "pv/data/logic.hpp"
 #include "pv/data/logicsnapshot.hpp"
 
index fbbb52bf950876f56be947c16ed918b50bd88e66..a94ada93faac055aae26761941e515b3318288a7 100644 (file)
@@ -26,7 +26,7 @@
 #include "view.hpp"
 #include "viewport.hpp"
 
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 
 #include <QMouseEvent>
 
index c4d4e718482e879bd87b3a8904263765e3c60620..10f26ddc678e6d7bc5b40b77e63f803666f1168b 100644 (file)
@@ -20,7 +20,7 @@
 
 set(pulseview_TEST_SOURCES
        ${PROJECT_SOURCE_DIR}/pv/devicemanager.cpp
-       ${PROJECT_SOURCE_DIR}/pv/sigsession.cpp
+       ${PROJECT_SOURCE_DIR}/pv/session.cpp
        ${PROJECT_SOURCE_DIR}/pv/storesession.cpp
        ${PROJECT_SOURCE_DIR}/pv/util.cpp
        ${PROJECT_SOURCE_DIR}/pv/data/analog.cpp
@@ -69,7 +69,7 @@ set(pulseview_TEST_SOURCES
 
 # This list includes only QObject derived class headers.
 set(pulseview_TEST_HEADERS
-       ${PROJECT_SOURCE_DIR}/pv/sigsession.hpp
+       ${PROJECT_SOURCE_DIR}/pv/session.hpp
        ${PROJECT_SOURCE_DIR}/pv/storesession.hpp
        ${PROJECT_SOURCE_DIR}/pv/popups/channels.hpp
        ${PROJECT_SOURCE_DIR}/pv/popups/deviceoptions.hpp
index ceb5147f66faefe844af40ed1ac993283d3f8495..c169e1ff2271f1d779665486ab23cdc43b94089f 100644 (file)
@@ -25,7 +25,7 @@
 
 #include "../../pv/data/decoderstack.hpp"
 #include "../../pv/devicemanager.hpp"
-#include "../../pv/sigsession.hpp"
+#include "../../pv/session.hpp"
 #include "../../pv/view/decodetrace.hpp"
 
 using pv::data::DecoderStack;