#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::mutex;
using std::list;
using std::map;
+using std::mutex;
using std::set;
using std::shared_ptr;
using std::string;
using Glib::Variant;
namespace pv {
-
-// TODO: This should not be necessary
-shared_ptr<Session> SigSession::_sr_session = nullptr;
-
SigSession::SigSession(DeviceManager &device_manager) :
_device_manager(device_manager),
+ _session(device_manager.context()->create_session()),
_capture_state(Stopped)
{
- // TODO: This should not be necessary
- _sr_session = device_manager.context()->create_session();
-
set_default_device();
}
stop_capture();
}
-shared_ptr<Device> SigSession::get_device() const
+DeviceManager& SigSession::device_manager()
+{
+ return _device_manager;
+}
+
+const DeviceManager& SigSession::device_manager() const
+{
+ return _device_manager;
+}
+
+const shared_ptr<sigrok::Session>& SigSession::session() const
+{
+ return _session;
+}
+
+shared_ptr<Device> SigSession::device() const
{
return _device;
}
auto prev_session_device = dynamic_pointer_cast<SessionDevice>(_device);
if (_device) {
- _sr_session->remove_datafeed_callbacks();
+ _session->remove_datafeed_callbacks();
if (!prev_session_device) {
_device->close();
- _sr_session->remove_devices();
+ _session->remove_devices();
}
}
if (session_device)
- _sr_session = session_device->parent();
+ _session = session_device->parent();
_device = device;
_decode_traces.clear();
if (device) {
if (!session_device)
{
- _sr_session = _device_manager.context()->create_session();
+ _session = _device_manager.context()->create_session();
device->open();
- _sr_session->add_device(device);
+ _session->add_device(device);
}
- _sr_session->add_datafeed_callback([=]
+ _session->add_datafeed_callback([=]
(shared_ptr<Device> device, shared_ptr<Packet> packet) {
data_feed_in(device, packet);
});
void SigSession::set_file(const string &name)
{
- _sr_session = _device_manager.context()->load_session(name);
- _device = _sr_session->devices()[0];
+ _session = _device_manager.context()->load_session(name);
+ _device = _session->devices()[0];
_decode_traces.clear();
- _sr_session->add_datafeed_callback([=]
+ _session->add_datafeed_callback([=]
(shared_ptr<Device> device, shared_ptr<Packet> packet) {
data_feed_in(device, packet);
});
void SigSession::stop_capture()
{
if (get_capture_state() != Stopped)
- _sr_session->stop();
+ _session->stop();
// Check that sampling stopped
if (_sampling_thread.joinable())
set< shared_ptr<data::SignalData> > SigSession::get_data() const
{
- lock_guard<mutex> lock(_signals_mutex);
+ shared_lock<shared_mutex> lock(_signals_mutex);
set< shared_ptr<data::SignalData> > data;
for (const shared_ptr<view::Signal> sig : _signals) {
assert(sig);
return data;
}
-vector< shared_ptr<view::Signal> > SigSession::get_signals() const
+boost::shared_mutex& SigSession::signals_mutex() const
+{
+ return _signals_mutex;
+}
+
+const vector< shared_ptr<view::Signal> >& SigSession::signals() const
{
- lock_guard<mutex> lock(_signals_mutex);
return _signals;
}
try
{
- lock_guard<mutex> lock(_signals_mutex);
+ lock_guard<boost::shared_mutex> lock(_signals_mutex);
// Create the decoder
decoder_stack = shared_ptr<data::DecoderStack>(
dynamic_pointer_cast<view::LogicSignal>(s);
if (l && QString::fromUtf8(pdch->name).
toLower().contains(
- l->get_name().toLower()))
+ l->name().toLower()))
channels[pdch] = l;
}
vector< shared_ptr<view::DecodeTrace> > SigSession::get_decode_signals() const
{
- lock_guard<mutex> lock(_signals_mutex);
+ shared_lock<shared_mutex> lock(_signals_mutex);
return _decode_traces;
}
}
// Make the Signals list
- do {
- lock_guard<mutex> lock(_signals_mutex);
+ {
+ unique_lock<shared_mutex> lock(_signals_mutex);
_signals.clear();
switch(channel->type()->id()) {
case SR_CHANNEL_LOGIC:
signal = shared_ptr<view::Signal>(
- new view::LogicSignal(device, channel, _logic_data));
+ 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(channel, data));
+ new view::AnalogSignal(
+ *this, channel, data));
break;
}
_signals.push_back(signal);
}
- } while(0);
+ }
signals_changed();
}
shared_ptr<view::Signal> SigSession::signal_from_channel(
shared_ptr<Channel> channel) const
{
- lock_guard<mutex> lock(_signals_mutex);
+ lock_guard<boost::shared_mutex> lock(_signals_mutex);
for (shared_ptr<view::Signal> sig : _signals) {
assert(sig);
if (sig->channel() == channel)
read_sample_rate(device);
try {
- _sr_session->start();
+ _session->start();
} catch(Error e) {
error_handler(e.what());
return;
}
- set_capture_state(_sr_session->trigger() ?
+ set_capture_state(_session->trigger() ?
AwaitingTrigger : Running);
- _sr_session->run();
+ _session->run();
set_capture_state(Stopped);
// Confirm that SR_DF_END was received