X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsigsession.cpp;h=80830214877148f38a6100c06dc43bbc56c0a134;hp=e507a09946801fa0c081d8ecfecb18ba6806c946;hb=ed1d9d81f46c6595bea7278aa5dc9c1213c81609;hpb=d2f46d2719dae993818784ffffc8697d7e827258 diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp index e507a099..80830214 100644 --- a/pv/sigsession.cpp +++ b/pv/sigsession.cpp @@ -22,143 +22,180 @@ #include #endif -#include "sigsession.h" +#include "sigsession.hpp" -#include "devicemanager.h" +#include "devicemanager.hpp" -#include "data/analog.h" -#include "data/analogsnapshot.h" -#include "data/decoderstack.h" -#include "data/logic.h" -#include "data/logicsnapshot.h" -#include "data/decode/decoder.h" +#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.h" -#include "view/decodetrace.h" -#include "view/logicsignal.h" - -#include +#include "view/analogsignal.hpp" +#include "view/decodetrace.hpp" +#include "view/logicsignal.hpp" +#include +#include #include -#include - #include #include -using boost::dynamic_pointer_cast; -using boost::function; -using boost::lock_guard; -using boost::mutex; -using boost::shared_ptr; +#include + +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; -namespace pv { - -// TODO: This should not be necessary -SigSession* SigSession::_session = NULL; +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 { SigSession::SigSession(DeviceManager &device_manager) : - _device_manager(device_manager), - _sdi(NULL), - _capture_state(Stopped) + device_manager_(device_manager), + session_(device_manager.context()->create_session()), + capture_state_(Stopped) { - // TODO: This should not be necessary - _session = this; + set_default_device(); } SigSession::~SigSession() { + // Stop and join to the thread stop_capture(); - - _sampling_thread.join(); - - if (_sdi) - _device_manager.release_device(_sdi); - _sdi = NULL; - - // TODO: This should not be necessary - _session = NULL; } -struct sr_dev_inst* SigSession::get_device() const +DeviceManager& SigSession::device_manager() { - return _sdi; + return device_manager_; } -void SigSession::set_device(struct sr_dev_inst *sdi) +const DeviceManager& SigSession::device_manager() const { - // Ensure we are not capturing before setting the device - stop_capture(); - - if (_sdi) - _device_manager.release_device(_sdi); - if (sdi) - _device_manager.use_device(sdi, this); - _sdi = sdi; - update_signals(sdi); + return device_manager_; } -void SigSession::release_device(struct sr_dev_inst *sdi) +const shared_ptr& SigSession::session() const { - (void)sdi; + return session_; +} - assert(_capture_state == Stopped); - _sdi = NULL; - update_signals(NULL); +shared_ptr SigSession::device() const +{ + return device_; } -void SigSession::load_file(const string &name, - function error_handler) +void SigSession::set_device(shared_ptr device) { + // Ensure we are not capturing before setting the device stop_capture(); - if (sr_session_load(name.c_str()) == SR_OK) { - GSList *devlist = NULL; - sr_session_dev_list(&devlist); + // Are we setting a session device? + auto session_device = dynamic_pointer_cast(device); + // Did we have a session device selected previously? + auto prev_session_device = dynamic_pointer_cast(device_); - if (!devlist || !devlist->data || - sr_session_start() != SR_OK) { - error_handler(tr("Failed to start session.")); - return; + if (device_) { + session_->remove_datafeed_callbacks(); + if (!prev_session_device) { + device_->close(); + session_->remove_devices(); } + } - sr_dev_inst *const sdi = (sr_dev_inst*)devlist->data; - g_slist_free(devlist); + if (session_device) + session_ = session_device->parent(); - _decode_traces.clear(); - update_signals(sdi); - read_sample_rate(sdi); + device_ = device; + decode_traces_.clear(); - _sampling_thread = boost::thread( - &SigSession::load_session_thread_proc, this, - error_handler); + if (device) { + if (!session_device) + { + session_ = device_manager_.context()->create_session(); + device->open(); + session_->add_device(device); + } + session_->add_datafeed_callback([=] + (shared_ptr device, shared_ptr packet) { + data_feed_in(device, packet); + }); + update_signals(device); + } - } else { - sr_input *in = NULL; + device_selected(); +} - if (!(in = load_input_file_format(name.c_str(), - error_handler))) - return; +void SigSession::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, shared_ptr packet) { + data_feed_in(device, packet); + }); + device_manager_.update_display_name(device_); + update_signals(device_); + device_selected(); +} - _decode_traces.clear(); - update_signals(in->sdi); - read_sample_rate(in->sdi); +void SigSession::set_default_device() +{ + shared_ptr default_device; + const list< shared_ptr > &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 dev : devices) + if (dev->driver()->name().compare("demo") == 0) { + default_device = dev; + break; + } - _sampling_thread = boost::thread( - &SigSession::load_input_thread_proc, this, - name, in, error_handler); + set_device(default_device); } } SigSession::capture_state SigSession::get_capture_state() const { - lock_guard lock(_sampling_mutex); - return _capture_state; + lock_guard lock(sampling_mutex_); + return capture_state_; } void SigSession::start_capture(function error_handler) @@ -166,46 +203,42 @@ void SigSession::start_capture(function error_handler) stop_capture(); // Check that a device instance has been selected. - if (!_sdi) { + if (!device_) { qDebug() << "No device selected"; return; } - // Check that at least one probe is enabled - const GSList *l; - for (l = _sdi->probes; l; l = l->next) { - sr_probe *const probe = (sr_probe*)l->data; - assert(probe); - if (probe->enabled) - break; - } + // Check that at least one channel is enabled + auto channels = device_->channels(); + bool enabled = std::any_of(channels.begin(), channels.end(), + [](shared_ptr channel) { return channel->enabled(); }); - if (!l) { - error_handler(tr("No probes enabled.")); + if (!enabled) { + error_handler(tr("No channels enabled.")); return; } // Begin the session - _sampling_thread = boost::thread( - &SigSession::sample_thread_proc, this, _sdi, error_handler); + sampling_thread_ = std::thread( + &SigSession::sample_thread_proc, this, device_, + error_handler); } void SigSession::stop_capture() { - if (get_capture_state() == Stopped) - return; - - sr_session_stop(); + if (get_capture_state() != Stopped) + session_->stop(); // Check that sampling stopped - _sampling_thread.join(); + if (sampling_thread_.joinable()) + sampling_thread_.join(); } set< shared_ptr > SigSession::get_data() const { - lock_guard lock(_signals_mutex); + shared_lock lock(signals_mutex_); set< shared_ptr > data; - BOOST_FOREACH(const shared_ptr sig, _signals) { + for (const shared_ptr sig : signals_) { assert(sig); data.insert(sig->data()); } @@ -213,55 +246,59 @@ set< shared_ptr > SigSession::get_data() const return data; } -vector< shared_ptr > SigSession::get_signals() const +boost::shared_mutex& SigSession::signals_mutex() const +{ + return signals_mutex_; +} + +const vector< shared_ptr >& SigSession::signals() const { - lock_guard lock(_signals_mutex); - return _signals; + return signals_; } #ifdef ENABLE_DECODE bool SigSession::add_decoder(srd_decoder *const dec) { - map > probes; + map > channels; shared_ptr decoder_stack; try { - lock_guard lock(_signals_mutex); + lock_guard lock(signals_mutex_); // Create the decoder decoder_stack = shared_ptr( - new data::DecoderStack(dec)); - - // Make a list of all the probes - std::vector all_probes; - for(const GSList *i = dec->probes; i; i = i->next) - all_probes.push_back((const srd_probe*)i->data); - for(const GSList *i = dec->opt_probes; i; i = i->next) - all_probes.push_back((const srd_probe*)i->data); - - // Auto select the initial probes - BOOST_FOREACH(const srd_probe *probe, all_probes) - BOOST_FOREACH(shared_ptr s, _signals) + new data::DecoderStack(*this, dec)); + + // Make a list of all the channels + std::vector 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 s : signals_) { shared_ptr l = dynamic_pointer_cast(s); - if (l && QString::fromUtf8(probe->name). + if (l && QString::fromUtf8(pdch->name). toLower().contains( - l->get_name().toLower())) - probes[probe] = l; + l->name().toLower())) + channels[pdch] = l; } assert(decoder_stack); assert(!decoder_stack->stack().empty()); assert(decoder_stack->stack().front()); - decoder_stack->stack().front()->set_probes(probes); + decoder_stack->stack().front()->set_channels(channels); // Create the decode signal shared_ptr d( new view::DecodeTrace(*this, decoder_stack, - _decode_traces.size())); - _decode_traces.push_back(d); + decode_traces_.size())); + decode_traces_.push_back(d); } catch(std::runtime_error e) { @@ -278,19 +315,16 @@ bool SigSession::add_decoder(srd_decoder *const dec) vector< shared_ptr > SigSession::get_decode_signals() const { - lock_guard lock(_signals_mutex); - return _decode_traces; + shared_lock lock(signals_mutex_); + return decode_traces_; } void SigSession::remove_decode_signal(view::DecodeTrace *signal) { - for (vector< shared_ptr >::iterator i = - _decode_traces.begin(); - i != _decode_traces.end(); - i++) + for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++) if ((*i).get() == signal) { - _decode_traces.erase(i); + decode_traces_.erase(i); signals_changed(); return; } @@ -299,153 +333,63 @@ void SigSession::remove_decode_signal(view::DecodeTrace *signal) void SigSession::set_capture_state(capture_state state) { - lock_guard lock(_sampling_mutex); - const bool changed = _capture_state != state; - _capture_state = state; + lock_guard lock(sampling_mutex_); + const bool changed = capture_state_ != state; + capture_state_ = state; if(changed) capture_state_changed(state); } -/** - * Attempts to autodetect the format. Failing that - * @param filename The filename of the input file. - * @return A pointer to the 'struct sr_input_format' that should be used, - * or NULL if no input format was selected or auto-detected. - */ -sr_input_format* SigSession::determine_input_file_format( - const string &filename) -{ - int i; - - /* If there are no input formats, return NULL right away. */ - sr_input_format *const *const inputs = sr_input_list(); - if (!inputs) { - g_critical("No supported input formats available."); - return NULL; - } - - /* Otherwise, try to find an input module that can handle this file. */ - for (i = 0; inputs[i]; i++) { - if (inputs[i]->format_match(filename.c_str())) - break; - } - - /* Return NULL if no input module wanted to touch this. */ - if (!inputs[i]) { - g_critical("Error: no matching input module found."); - return NULL; - } - - return inputs[i]; -} - -sr_input* SigSession::load_input_file_format(const string &filename, - function error_handler, - sr_input_format *format) -{ - struct stat st; - sr_input *in; - - if (!format && !(format = - determine_input_file_format(filename.c_str()))) { - /* The exact cause was already logged. */ - return NULL; - } - - if (stat(filename.c_str(), &st) == -1) { - error_handler(tr("Failed to load file")); - return NULL; - } - - /* Initialize the input module. */ - if (!(in = new sr_input)) { - qDebug("Failed to allocate input module.\n"); - return NULL; - } - - in->format = format; - in->param = NULL; - if (in->format->init && - in->format->init(in, filename.c_str()) != SR_OK) { - qDebug("Input format init failed.\n"); - return NULL; - } - - sr_session_new(); - - if (sr_session_dev_add(in->sdi) != SR_OK) { - qDebug("Failed to use device.\n"); - sr_session_destroy(); - return NULL; - } - - return in; -} - -void SigSession::update_signals(const sr_dev_inst *const sdi) +void SigSession::update_signals(shared_ptr device) { - assert(_capture_state == Stopped); - - unsigned int logic_probe_count = 0; + assert(device); + assert(capture_state_ == Stopped); // Clear the decode traces - _decode_traces.clear(); + decode_traces_.clear(); // Detect what data types we will receive - if(sdi) { - for (const GSList *l = sdi->probes; l; l = l->next) { - const sr_probe *const probe = (const sr_probe *)l->data; - if (!probe->enabled) - continue; - - switch(probe->type) { - case SR_PROBE_LOGIC: - logic_probe_count++; - break; - } - } - } + auto channels = device->channels(); + unsigned int logic_channel_count = std::count_if( + channels.begin(), channels.end(), + [] (shared_ptr channel) { + return channel->type() == ChannelType::LOGIC; }); // Create data containers for the logic data snapshots { - lock_guard data_lock(_data_mutex); + lock_guard data_lock(data_mutex_); - _logic_data.reset(); - if (logic_probe_count != 0) { - _logic_data.reset(new data::Logic( - logic_probe_count)); - assert(_logic_data); + logic_data_.reset(); + if (logic_channel_count != 0) { + logic_data_.reset(new data::Logic( + logic_channel_count)); + assert(logic_data_); } } // Make the Signals list - do { - lock_guard lock(_signals_mutex); - - _signals.clear(); + { + unique_lock lock(signals_mutex_); - if(!sdi) - break; + signals_.clear(); - for (const GSList *l = sdi->probes; l; l = l->next) { + for (auto channel : device->channels()) { shared_ptr signal; - sr_probe *const probe = (sr_probe *)l->data; - assert(probe); - switch(probe->type) { - case SR_PROBE_LOGIC: + switch(channel->type()->id()) { + case SR_CHANNEL_LOGIC: signal = shared_ptr( - new view::LogicSignal(*this, probe, - _logic_data)); + new view::LogicSignal(*this, device, + channel, logic_data_)); break; - case SR_PROBE_ANALOG: + case SR_CHANNEL_ANALOG: { shared_ptr data( new data::Analog()); signal = shared_ptr( - new view::AnalogSignal(*this, probe, - data)); + new view::AnalogSignal( + *this, channel, data)); break; } @@ -455,160 +399,86 @@ void SigSession::update_signals(const sr_dev_inst *const sdi) } assert(signal); - _signals.push_back(signal); + signals_.push_back(signal); } - } while(0); - - signals_changed(); -} - -bool SigSession::is_trigger_enabled() const -{ - assert(_sdi); - for (const GSList *l = _sdi->probes; l; l = l->next) { - const sr_probe *const p = (const sr_probe *)l->data; - assert(p); - if (p->trigger && p->trigger[0] != '\0') - return true; } - return false; + signals_changed(); } -shared_ptr SigSession::signal_from_probe( - const sr_probe *probe) const +shared_ptr SigSession::signal_from_channel( + shared_ptr channel) const { - lock_guard lock(_signals_mutex); - BOOST_FOREACH(shared_ptr sig, _signals) { + lock_guard lock(signals_mutex_); + for (shared_ptr sig : signals_) { assert(sig); - if (sig->probe() == probe) + if (sig->channel() == channel) return sig; } return shared_ptr(); } -void SigSession::read_sample_rate(const sr_dev_inst *const sdi) +void SigSession::read_sample_rate(shared_ptr device) { - GVariant *gvar; - uint64_t sample_rate = 0; - - // Read out the sample rate - if(sdi->driver) - { - const int ret = sr_config_get(sdi->driver, sdi, NULL, - SR_CONF_SAMPLERATE, &gvar); - if (ret != SR_OK) { - qDebug("Failed to get samplerate\n"); - return; - } - - sample_rate = g_variant_get_uint64(gvar); - g_variant_unref(gvar); - } + 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>( + device->config_get(ConfigKey::SAMPLERATE)).get() : 0; // Set the sample rate of all data const set< shared_ptr > data_set = get_data(); - BOOST_FOREACH(shared_ptr data, data_set) { + for (shared_ptr data : data_set) { assert(data); data->set_samplerate(sample_rate); } } -void SigSession::load_session_thread_proc( +void SigSession::sample_thread_proc(shared_ptr device, function error_handler) { - (void)error_handler; - - sr_session_datafeed_callback_add(data_feed_in_proc, NULL); - - set_capture_state(Running); - - sr_session_run(); - - sr_session_destroy(); - set_capture_state(Stopped); - - // Confirm that SR_DF_END was received - assert(!_cur_logic_snapshot); - assert(_cur_analog_snapshots.empty()); -} - -void SigSession::load_input_thread_proc(const string name, - sr_input *in, function error_handler) -{ - (void)error_handler; - - assert(in); - assert(in->format); - - sr_session_datafeed_callback_add(data_feed_in_proc, NULL); - - set_capture_state(Running); - - in->format->loadfile(in, name.c_str()); - - sr_session_destroy(); - set_capture_state(Stopped); - - // Confirm that SR_DF_END was received - assert(!_cur_logic_snapshot); - assert(_cur_analog_snapshots.empty()); - - delete in; -} - -void SigSession::sample_thread_proc(struct sr_dev_inst *sdi, - function error_handler) -{ - assert(sdi); + assert(device); assert(error_handler); - sr_session_new(); - sr_session_datafeed_callback_add(data_feed_in_proc, NULL); - - if (sr_session_dev_add(sdi) != SR_OK) { - error_handler(tr("Failed to use device.")); - sr_session_destroy(); - return; - } + read_sample_rate(device); - if (sr_session_start() != SR_OK) { - error_handler(tr("Failed to start session.")); + try { + session_->start(); + } catch(Error e) { + error_handler(e.what()); return; } - set_capture_state(is_trigger_enabled() ? AwaitingTrigger : Running); - - sr_session_run(); - sr_session_destroy(); + set_capture_state(session_->trigger() ? + AwaitingTrigger : Running); + session_->run(); set_capture_state(Stopped); // Confirm that SR_DF_END was received - if (_cur_logic_snapshot) + if (cur_logic_snapshot_) { qDebug("SR_DF_END was not received."); assert(0); } } -void SigSession::feed_in_header(const sr_dev_inst *sdi) +void SigSession::feed_in_header(shared_ptr device) { - read_sample_rate(sdi); + read_sample_rate(device); } -void SigSession::feed_in_meta(const sr_dev_inst *sdi, - const sr_datafeed_meta &meta) +void SigSession::feed_in_meta(shared_ptr device, + shared_ptr meta) { - (void)sdi; + (void)device; - for (const GSList *l = meta.config; l; l = l->next) { - const sr_config *const src = (const sr_config*)l->data; - switch (src->key) { + for (auto entry : meta->config()) { + switch (entry.first->id()) { case SR_CONF_SAMPLERATE: /// @todo handle samplerate changes - /// samplerate = (uint64_t *)src->value; break; default: // Unknown metadata is not an error. @@ -619,55 +489,75 @@ void SigSession::feed_in_meta(const sr_dev_inst *sdi, signals_changed(); } -void SigSession::feed_in_logic(const sr_datafeed_logic &logic) +void SigSession::feed_in_frame_begin() +{ + if (cur_logic_snapshot_ || !cur_analog_snapshots_.empty()) + frame_began(); +} + +void SigSession::feed_in_logic(shared_ptr logic) { - lock_guard lock(_data_mutex); + lock_guard lock(data_mutex_); - if (!_logic_data) + if (!logic_data_) { qDebug() << "Unexpected logic packet"; return; } - if (!_cur_logic_snapshot) + 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>( + device_->config_get(ConfigKey::LIMIT_SAMPLES)).get() : 0; + // Create a new data snapshot - _cur_logic_snapshot = shared_ptr( - new data::LogicSnapshot(logic)); - _logic_data->push_snapshot(_cur_logic_snapshot); + cur_logic_snapshot_ = shared_ptr( + 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); + cur_logic_snapshot_->append_payload(logic); } - data_updated(); + data_received(); } -void SigSession::feed_in_analog(const sr_datafeed_analog &analog) +void SigSession::feed_in_analog(shared_ptr analog) { - lock_guard lock(_data_mutex); + lock_guard lock(data_mutex_); - const unsigned int probe_count = g_slist_length(analog.probes); - const size_t sample_count = analog.num_samples / probe_count; - const float *data = analog.data; + const vector> 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 (GSList *p = analog.probes; p; p = p->next) + for (auto channel : channels) { shared_ptr snapshot; - sr_probe *const probe = (sr_probe*)p->data; - assert(probe); - - // Try to get the snapshot of the probe - const map< const sr_probe*, shared_ptr >:: - iterator iter = _cur_analog_snapshots.find(probe); - if (iter != _cur_analog_snapshots.end()) + // Try to get the snapshot of the channel + const map< shared_ptr, shared_ptr >:: + iterator iter = cur_analog_snapshots_.find(channel); + if (iter != cur_analog_snapshots_.end()) snapshot = (*iter).second; else { @@ -676,15 +566,24 @@ void SigSession::feed_in_analog(const sr_datafeed_analog &analog) // in the sweep containing this snapshot. sweep_beginning = true; - // Create a snapshot, keep it in the maps of probes + // Get sample limit. + uint64_t sample_limit; + try { + sample_limit = VariantBase::cast_dynamic>( + 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( - new data::AnalogSnapshot()); - _cur_analog_snapshots[probe] = snapshot; + new data::AnalogSnapshot(sample_limit)); + cur_analog_snapshots_[channel] = snapshot; - // Find the annalog data associated with the probe + // Find the annalog data associated with the channel shared_ptr sig = dynamic_pointer_cast( - signal_from_probe(probe)); + signal_from_channel(channel)); assert(sig); shared_ptr data(sig->analog_data()); @@ -698,7 +597,7 @@ void SigSession::feed_in_analog(const sr_datafeed_analog &analog) // Append the samples in the snapshot snapshot->append_interleaved_samples(data++, sample_count, - probe_count); + channel_count); } if (sweep_beginning) { @@ -706,55 +605,48 @@ void SigSession::feed_in_analog(const sr_datafeed_analog &analog) set_capture_state(Running); } - data_updated(); + data_received(); } -void SigSession::data_feed_in(const struct sr_dev_inst *sdi, - const struct sr_datafeed_packet *packet) +void SigSession::data_feed_in(shared_ptr device, shared_ptr packet) { - assert(sdi); + assert(device); assert(packet); - switch (packet->type) { + switch (packet->type()->id()) { case SR_DF_HEADER: - feed_in_header(sdi); + feed_in_header(device); break; case SR_DF_META: - assert(packet->payload); - feed_in_meta(sdi, - *(const sr_datafeed_meta*)packet->payload); + feed_in_meta(device, dynamic_pointer_cast(packet->payload())); + break; + + case SR_DF_FRAME_BEGIN: + feed_in_frame_begin(); break; case SR_DF_LOGIC: - assert(packet->payload); - feed_in_logic(*(const sr_datafeed_logic*)packet->payload); + feed_in_logic(dynamic_pointer_cast(packet->payload())); break; case SR_DF_ANALOG: - assert(packet->payload); - feed_in_analog(*(const sr_datafeed_analog*)packet->payload); + feed_in_analog(dynamic_pointer_cast(packet->payload())); break; case SR_DF_END: { { - lock_guard lock(_data_mutex); - _cur_logic_snapshot.reset(); - _cur_analog_snapshots.clear(); + lock_guard lock(data_mutex_); + cur_logic_snapshot_.reset(); + cur_analog_snapshots_.clear(); } - data_updated(); + frame_ended(); break; } + default: + break; } } -void SigSession::data_feed_in_proc(const struct sr_dev_inst *sdi, - const struct sr_datafeed_packet *packet, void *cb_data) -{ - (void) cb_data; - assert(_session); - _session->data_feed_in(sdi, packet); -} - } // namespace pv