using Glib::VariantBase;
namespace pv {
+
+shared_ptr<sigrok::Context> Session::sr_context;
+
Session::Session(DeviceManager &device_manager, QString name) :
device_manager_(device_manager),
default_name_(name),
int decode_signals = settings.value("decode_signals").toInt();
for (int i = 0; i < decode_signals; i++) {
- settings.beginGroup("decode_signal" + QString::number(i++));
- // TODO Split up add_decoder() into add_decode_signal() and add_decoder(),
- // then call add_decode_signal() and signal->restore_settings() here
+ settings.beginGroup("decode_signal" + QString::number(i));
+ shared_ptr<data::DecodeSignal> signal = add_decode_signal();
+ signal->restore_settings(settings);
settings.endGroup();
}
#endif
views_.push_back(view);
+ // Add all device signals
update_signals();
+
+ // Add all other signals
+ unordered_set< shared_ptr<data::SignalBase> > view_signalbases =
+ view->signalbases();
+
+ views::trace::View *trace_view =
+ qobject_cast<views::trace::View*>(view.get());
+
+ if (trace_view) {
+ for (shared_ptr<data::SignalBase> signalbase : signalbases_) {
+ const int sb_exists = count_if(
+ view_signalbases.cbegin(), view_signalbases.cend(),
+ [&](const shared_ptr<data::SignalBase> &sb) {
+ return sb == signalbase;
+ });
+ // Add the signal to the view as it doesn't have it yet
+ if (!sb_exists)
+ switch (signalbase->type()) {
+ case data::SignalBase::AnalogChannel:
+ case data::SignalBase::LogicChannel:
+ case data::SignalBase::DecodeChannel:
+#ifdef ENABLE_DECODE
+ trace_view->add_decode_signal(
+ dynamic_pointer_cast<data::DecodeSignal>(signalbase));
+#endif
+ break;
+ case data::SignalBase::MathChannel:
+ // TBD
+ break;
+ }
+ }
+ }
+
+ signals_changed();
}
void Session::deregister_view(shared_ptr<views::ViewBase> view)
return samplerate;
}
+int Session::get_segment_count() const
+{
+ int min_val = INT_MAX;
+
+ for (shared_ptr<data::SignalData> data : all_signal_data_)
+ if (data->get_segment_count() < min_val)
+ min_val = data->get_segment_count();
+
+ return min_val;
+}
+
const unordered_set< shared_ptr<data::SignalBase> > Session::signalbases() const
{
return signalbases_;
}
#ifdef ENABLE_DECODE
-bool Session::add_decoder(srd_decoder *const dec)
+shared_ptr<data::DecodeSignal> Session::add_decode_signal()
{
- if (!dec)
- return false;
+ shared_ptr<data::DecodeSignal> signal;
try {
// Create the decode signal
- shared_ptr<data::DecodeSignal> signal =
- make_shared<data::DecodeSignal>(*this);
+ signal = make_shared<data::DecodeSignal>(*this);
signalbases_.insert(signal);
// Add the decode signal to all views
for (shared_ptr<views::ViewBase> view : views_)
view->add_decode_signal(signal);
-
- // Add decoder
- signal->stack_decoder(dec);
} catch (runtime_error e) {
- return false;
+ remove_decode_signal(signal);
+ return nullptr;
}
signals_changed();
- return true;
+ return signal;
}
void Session::remove_decode_signal(shared_ptr<data::DecodeSignal> signal)
void Session::feed_in_frame_begin()
{
+ frame_began_ = true;
+
if (cur_logic_segment_ || !cur_analog_segments_.empty())
frame_began();
}
+void Session::feed_in_frame_end()
+{
+ {
+ lock_guard<recursive_mutex> lock(data_mutex_);
+ cur_logic_segment_.reset();
+ cur_analog_segments_.clear();
+ }
+
+ if (frame_began_) {
+ frame_began_ = false;
+ frame_ended();
+ }
+}
+
void Session::feed_in_logic(shared_ptr<Logic> logic)
{
lock_guard<recursive_mutex> lock(data_mutex_);
void Session::data_feed_in(shared_ptr<sigrok::Device> device,
shared_ptr<Packet> packet)
{
- static bool frame_began = false;
-
(void)device;
assert(device);
feed_in_trigger();
break;
- case SR_DF_FRAME_BEGIN:
- feed_in_frame_begin();
- frame_began = true;
- break;
-
case SR_DF_LOGIC:
try {
feed_in_logic(dynamic_pointer_cast<Logic>(packet->payload()));
}
break;
+ case SR_DF_FRAME_BEGIN:
+ feed_in_frame_begin();
+ break;
+
case SR_DF_FRAME_END:
+ feed_in_frame_end();
+ break;
+
case SR_DF_END:
- {
+ // Strictly speaking, this is performed when a frame end marker was
+ // received, so there's no point doing this again. However, not all
+ // devices use frames, and for those devices, we need to do it here.
{
lock_guard<recursive_mutex> lock(data_mutex_);
cur_logic_segment_.reset();
cur_analog_segments_.clear();
}
- if (frame_began) {
- frame_began = false;
- frame_ended();
- }
break;
- }
+
default:
break;
}