// TODO: This should not be necessary
SigSession* SigSession::_session = NULL;
-SigSession::SigSession()
+SigSession::SigSession() :
+ _capture_state(Stopped)
{
// TODO: This should not be necessary
_session = this;
SigSession::~SigSession()
{
+ stop_capture();
+
if(_sampling_thread.get())
_sampling_thread->join();
_sampling_thread.reset();
}
}
+SigSession::capture_state SigSession::get_capture_state() const
+{
+ lock_guard<mutex> lock(_state_mutex);
+ return _capture_state;
+}
+
void SigSession::start_capture(struct sr_dev_inst *sdi,
uint64_t record_length, uint64_t sample_rate)
{
- // Check sampling isn't already active
- if(_sampling_thread.get())
- _sampling_thread->join();
+ stop_capture();
+
_sampling_thread.reset(new boost::thread(
&SigSession::sample_thread_proc, this, sdi,
record_length, sample_rate));
}
-vector< shared_ptr<view::Signal> >& SigSession::get_signals()
+void SigSession::stop_capture()
{
+ if(get_capture_state() == Stopped)
+ return;
+
+ sr_session_stop();
+
+ // Check that sampling stopped
+ if(_sampling_thread.get())
+ _sampling_thread->join();
+ _sampling_thread.reset();
+}
+
+vector< shared_ptr<view::Signal> > SigSession::get_signals()
+{
+ lock_guard<mutex> lock(_signals_mutex);
return _signals;
}
return _logic_data;
}
+void SigSession::set_capture_state(capture_state state)
+{
+ lock_guard<mutex> lock(_state_mutex);
+ _capture_state = state;
+ capture_state_changed(state);
+}
+
void SigSession::sample_thread_proc(struct sr_dev_inst *sdi,
uint64_t record_length, uint64_t sample_rate)
{
return;
}
+ set_capture_state(Running);
+
sr_session_run();
sr_session_destroy();
+
+ set_capture_state(Stopped);
}
void SigSession::data_feed_in(const struct sr_dev_inst *sdi,
switch (packet->type) {
case SR_DF_HEADER:
{
- lock_guard<mutex> lock(_data_mutex);
+ lock_guard<mutex> lock(_signals_mutex);
_signals.clear();
break;
}
case SR_DF_META_LOGIC:
{
assert(packet->payload);
-
- lock_guard<mutex> lock(_data_mutex);
-
const sr_datafeed_meta_logic &meta_logic =
*(sr_datafeed_meta_logic*)packet->payload;
+ {
+ lock_guard<mutex> lock(_data_mutex);
+
// Create an empty LogiData for coming data snapshots
_logic_data.reset(new LogicData(meta_logic));
assert(_logic_data);
if(!_logic_data)
break;
+ }
+
+ {
+ lock_guard<mutex> lock(_signals_mutex);
// Add the signals
for (int i = 0; i < meta_logic.num_probes; i++)
}
}
+ signals_changed();
break;
}
+ }
case SR_DF_LOGIC:
{
*(sr_datafeed_logic*)packet->payload);
}
+ data_updated();
break;
}