X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsigsession.cpp;h=b441dab8aaf429608dc6d848b47be4156902e57d;hp=2e7be37f9fb499e85156bd8480330d80059e7b89;hb=8bd26d8b9c831b509ee3241ea4dac6f50c023622;hpb=27e8df221014d1a8c7769866773e8dbb0486eea8 diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp index 2e7be37f..b441dab8 100644 --- a/pv/sigsession.cpp +++ b/pv/sigsession.cpp @@ -1,7 +1,7 @@ /* * This file is part of the PulseView project. * - * Copyright (C) 2012 Joel Holdsworth + * Copyright (C) 2012-14 Joel Holdsworth * * 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 @@ -18,11 +18,15 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#ifdef ENABLE_DECODE #include +#endif #include "sigsession.h" #include "devicemanager.h" +#include "device/device.h" +#include "device/file.h" #include "data/analog.h" #include "data/analogsnapshot.h" @@ -45,8 +49,16 @@ #include -using namespace boost; -using namespace std; +using boost::dynamic_pointer_cast; +using boost::function; +using boost::lock_guard; +using boost::mutex; +using boost::shared_ptr; +using std::list; +using std::map; +using std::set; +using std::string; +using std::vector; namespace pv { @@ -55,92 +67,94 @@ SigSession* SigSession::_session = NULL; SigSession::SigSession(DeviceManager &device_manager) : _device_manager(device_manager), - _sdi(NULL), _capture_state(Stopped) { // TODO: This should not be necessary _session = this; + + set_default_device(); } SigSession::~SigSession() { + using pv::device::Device; + stop_capture(); - _sampling_thread.join(); + if (_sampling_thread.joinable()) + _sampling_thread.join(); - if (_sdi) - _device_manager.release_device(_sdi); - _sdi = NULL; + _dev_inst->release(); // TODO: This should not be necessary _session = NULL; } -struct sr_dev_inst* SigSession::get_device() const -{ - return _sdi; -} - -void SigSession::set_device(struct sr_dev_inst *sdi) +shared_ptr SigSession::get_device() const { - if (_sdi) - _device_manager.release_device(_sdi); - if (sdi) - _device_manager.use_device(sdi, this); - _sdi = sdi; - update_signals(sdi); + return _dev_inst; } -void SigSession::release_device(struct sr_dev_inst *sdi) +void SigSession::set_device( + shared_ptr dev_inst) throw(QString) { - (void)sdi; + using pv::device::Device; - assert(_capture_state == Stopped); - _sdi = NULL; - update_signals(NULL); -} - -void SigSession::load_file(const string &name, - function error_handler) -{ + // 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); - - if (!devlist || !devlist->data || - sr_session_start() != SR_OK) { - error_handler(tr("Failed to start session.")); - return; - } + if (_dev_inst) { + sr_session_datafeed_callback_remove_all(); + _dev_inst->release(); + } - sr_dev_inst *const sdi = (sr_dev_inst*)devlist->data; - g_slist_free(devlist); + _dev_inst = dev_inst; + _decode_traces.clear(); - _decode_traces.clear(); - update_signals(sdi); - read_sample_rate(sdi); + if (dev_inst) { + dev_inst->use(this); + sr_session_datafeed_callback_add(data_feed_in_proc, NULL); + update_signals(dev_inst); + } +} - _sampling_thread = boost::thread( - &SigSession::load_session_thread_proc, this, - error_handler); +void SigSession::set_file(const string &name) throw(QString) +{ + // Deslect the old device, because file type detection in File::create + // destorys the old session inside libsigrok. + set_device(shared_ptr()); + set_device(shared_ptr(device::File::create(name))); +} - } else { - sr_input *in = NULL; +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 + BOOST_FOREACH (shared_ptr dev, devices) + if (strcmp(dev->dev_inst()->driver->name, + "demo") == 0) { + default_device = dev; + break; + } + } - if (!(in = load_input_file_format(name.c_str(), - error_handler))) - return; + set_device(default_device); +} - _decode_traces.clear(); - update_signals(in->sdi); - read_sample_rate(in->sdi); +void SigSession::release_device(device::DevInst *dev_inst) +{ + (void)dev_inst; + assert(_dev_inst.get() == dev_inst); - _sampling_thread = boost::thread( - &SigSession::load_input_thread_proc, this, - name, in, error_handler); - } + assert(_capture_state == Stopped); + _dev_inst = shared_ptr(); } SigSession::capture_state SigSession::get_capture_state() const @@ -149,35 +163,36 @@ SigSession::capture_state SigSession::get_capture_state() const return _capture_state; } -void SigSession::start_capture(uint64_t record_length, - function error_handler) +void SigSession::start_capture(function error_handler) { stop_capture(); // Check that a device instance has been selected. - if (!_sdi) { + if (!_dev_inst) { qDebug() << "No device selected"; return; } + assert(_dev_inst->dev_inst()); + // 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; + for (l = _dev_inst->dev_inst()->channels; l; l = l->next) { + sr_channel *const probe = (sr_channel*)l->data; assert(probe); if (probe->enabled) break; } if (!l) { - error_handler(tr("No probes enabled.")); + error_handler(tr("No channels enabled.")); return; } // Begin the session _sampling_thread = boost::thread( - &SigSession::sample_thread_proc, this, _sdi, - record_length, error_handler); + &SigSession::sample_thread_proc, this, _dev_inst, + error_handler); } void SigSession::stop_capture() @@ -188,23 +203,32 @@ void SigSession::stop_capture() sr_session_stop(); // Check that sampling stopped - _sampling_thread.join(); + if (_sampling_thread.joinable()) + _sampling_thread.join(); } -vector< shared_ptr > SigSession::get_signals() const +set< shared_ptr > SigSession::get_data() const { lock_guard lock(_signals_mutex); - return _signals; + set< shared_ptr > data; + BOOST_FOREACH(const shared_ptr sig, _signals) { + assert(sig); + data.insert(sig->data()); + } + + return data; } -boost::shared_ptr SigSession::get_data() +vector< shared_ptr > SigSession::get_signals() const { - return _logic_data; + lock_guard lock(_signals_mutex); + return _signals; } +#ifdef ENABLE_DECODE bool SigSession::add_decoder(srd_decoder *const dec) { - map > probes; + map > probes; shared_ptr decoder_stack; try @@ -213,22 +237,26 @@ bool SigSession::add_decoder(srd_decoder *const dec) // Create the decoder decoder_stack = shared_ptr( - new data::DecoderStack(dec)); + new data::DecoderStack(*this, dec)); + + // Make a list of all the probes + std::vector all_probes; + for(const GSList *i = dec->channels; i; i = i->next) + all_probes.push_back((const srd_channel*)i->data); + for(const GSList *i = dec->opt_channels; i; i = i->next) + all_probes.push_back((const srd_channel*)i->data); // Auto select the initial probes - for(const GSList *i = dec->probes; i; i = i->next) - { - const srd_probe *const probe = (const srd_probe*)i->data; + BOOST_FOREACH(const srd_channel *pdch, all_probes) BOOST_FOREACH(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; + probes[pdch] = l; } - } assert(decoder_stack); assert(!decoder_stack->stack().empty()); @@ -273,6 +301,7 @@ void SigSession::remove_decode_signal(view::DecodeTrace *signal) return; } } +#endif void SigSession::set_capture_state(capture_state state) { @@ -283,113 +312,34 @@ void SigSession::set_capture_state(capture_state state) 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 dev_inst) { + assert(dev_inst); assert(_capture_state == Stopped); - shared_ptr signal; unsigned int logic_probe_count = 0; - unsigned int analog_probe_count = 0; // Clear the decode traces _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(dev_inst) { + assert(dev_inst->dev_inst()); + for (const GSList *l = dev_inst->dev_inst()->channels; + l; l = l->next) { + const sr_channel *const probe = (const sr_channel *)l->data; if (!probe->enabled) continue; switch(probe->type) { - case SR_PROBE_LOGIC: + case SR_CHANNEL_LOGIC: logic_probe_count++; break; - - case SR_PROBE_ANALOG: - analog_probe_count++; - break; } } } - // Create data containers for the data snapshots + // Create data containers for the logic data snapshots { lock_guard data_lock(_data_mutex); @@ -399,58 +349,65 @@ void SigSession::update_signals(const sr_dev_inst *const sdi) logic_probe_count)); assert(_logic_data); } - - _analog_data.reset(); - if (analog_probe_count != 0) { - _analog_data.reset(new data::Analog()); - assert(_analog_data); - } } // Make the Signals list - { + do { lock_guard lock(_signals_mutex); _signals.clear(); - if(sdi) { - for (const GSList *l = sdi->probes; l; l = l->next) { - sr_probe *const probe = (sr_probe *)l->data; - assert(probe); - - switch(probe->type) { - case SR_PROBE_LOGIC: - signal = shared_ptr( - new view::LogicSignal(*this, probe, - _logic_data)); - break; - - case SR_PROBE_ANALOG: - signal = shared_ptr( - new view::AnalogSignal(*this, probe, - _analog_data)); - break; - } - - _signals.push_back(signal); + if(!dev_inst) + break; + + assert(dev_inst->dev_inst()); + for (const GSList *l = dev_inst->dev_inst()->channels; + l; l = l->next) { + shared_ptr signal; + sr_channel *const probe = (sr_channel *)l->data; + assert(probe); + + switch(probe->type) { + case SR_CHANNEL_LOGIC: + signal = shared_ptr( + new view::LogicSignal(dev_inst, + probe, _logic_data)); + break; + + case SR_CHANNEL_ANALOG: + { + shared_ptr data( + new data::Analog()); + signal = shared_ptr( + new view::AnalogSignal(dev_inst, + probe, data)); + break; } + + default: + assert(0); + break; + } + + assert(signal); + _signals.push_back(signal); } - } + + } while(0); signals_changed(); } -bool SigSession::is_trigger_enabled() const +shared_ptr SigSession::signal_from_probe( + const sr_channel *probe) 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; + lock_guard lock(_signals_mutex); + BOOST_FOREACH(shared_ptr sig, _signals) { + assert(sig); + if (sig->probe() == probe) + return sig; } - - return false; + return shared_ptr(); } void SigSession::read_sample_rate(const sr_dev_inst *const sdi) @@ -472,95 +429,42 @@ void SigSession::read_sample_rate(const sr_dev_inst *const sdi) g_variant_unref(gvar); } - if(_analog_data) - _analog_data->set_samplerate(sample_rate); - if(_logic_data) - _logic_data->set_samplerate(sample_rate); -} - -void SigSession::load_session_thread_proc( - 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_snapshot); -} - -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_snapshot); - - delete in; + // Set the sample rate of all data + const set< shared_ptr > data_set = get_data(); + BOOST_FOREACH(shared_ptr data, data_set) { + assert(data); + data->set_samplerate(sample_rate); + } } -void SigSession::sample_thread_proc(struct sr_dev_inst *sdi, - uint64_t record_length, +void SigSession::sample_thread_proc(shared_ptr dev_inst, function error_handler) { - assert(sdi); + assert(dev_inst); + assert(dev_inst->dev_inst()); 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; - } - - // Set the sample limit - if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_SAMPLES, - g_variant_new_uint64(record_length)) != SR_OK) { - error_handler(tr("Failed to configure " - "time-based sample limit.")); - sr_session_destroy(); - return; - } + read_sample_rate(dev_inst->dev_inst()); - if (sr_session_start() != SR_OK) { - error_handler(tr("Failed to start session.")); + try { + dev_inst->start(); + } catch(const QString e) { + error_handler(e); return; } - set_capture_state(is_trigger_enabled() ? AwaitingTrigger : Running); - - sr_session_run(); - sr_session_destroy(); + set_capture_state(dev_inst->is_trigger_enabled() ? + AwaitingTrigger : Running); + dev_inst->run(); set_capture_state(Stopped); // Confirm that SR_DF_END was received - assert(!_cur_logic_snapshot); - assert(!_cur_analog_snapshot); + if (_cur_logic_snapshot) + { + qDebug("SR_DF_END was not received."); + assert(0); + } } void SigSession::feed_in_header(const sr_dev_inst *sdi) @@ -589,6 +493,12 @@ void SigSession::feed_in_meta(const sr_dev_inst *sdi, signals_changed(); } +void SigSession::feed_in_frame_begin() +{ + if (_cur_logic_snapshot || !_cur_analog_snapshots.empty()) + frame_began(); +} + void SigSession::feed_in_logic(const sr_datafeed_logic &logic) { lock_guard lock(_data_mutex); @@ -601,12 +511,19 @@ void SigSession::feed_in_logic(const sr_datafeed_logic &logic) if (!_cur_logic_snapshot) { + // This could be the first packet after a trigger set_capture_state(Running); // Create a new data snapshot _cur_logic_snapshot = shared_ptr( - new data::LogicSnapshot(logic)); + new data::LogicSnapshot(logic, _dev_inst->get_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 { @@ -614,35 +531,68 @@ void SigSession::feed_in_logic(const sr_datafeed_logic &logic) _cur_logic_snapshot->append_payload(logic); } - data_updated(); + data_received(); } void SigSession::feed_in_analog(const sr_datafeed_analog &analog) { lock_guard lock(_data_mutex); - if(!_analog_data) - { - qDebug() << "Unexpected analog packet"; - return; // This analog packet was not expected. - } + const unsigned int probe_count = g_slist_length(analog.channels); + const size_t sample_count = analog.num_samples / probe_count; + const float *data = analog.data; + bool sweep_beginning = false; - if (!_cur_analog_snapshot) + for (GSList *p = analog.channels; p; p = p->next) { - set_capture_state(Running); + shared_ptr snapshot; - // Create a new data snapshot - _cur_analog_snapshot = shared_ptr( - new data::AnalogSnapshot(analog)); - _analog_data->push_snapshot(_cur_analog_snapshot); + sr_channel *const probe = (sr_channel*)p->data; + assert(probe); + + // Try to get the snapshot of the probe + const map< const sr_channel*, shared_ptr >:: + iterator iter = _cur_analog_snapshots.find(probe); + 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; + + // Create a snapshot, keep it in the maps of probes + snapshot = shared_ptr( + new data::AnalogSnapshot(_dev_inst->get_sample_limit())); + _cur_analog_snapshots[probe] = snapshot; + + // Find the annalog data associated with the probe + shared_ptr sig = + dynamic_pointer_cast( + signal_from_probe(probe)); + assert(sig); + + shared_ptr 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, + probe_count); } - else - { - // Append to the existing data snapshot - _cur_analog_snapshot->append_payload(analog); + + if (sweep_beginning) { + // This could be the first packet after a trigger + set_capture_state(Running); } - data_updated(); + data_received(); } void SigSession::data_feed_in(const struct sr_dev_inst *sdi, @@ -662,6 +612,10 @@ void SigSession::data_feed_in(const struct sr_dev_inst *sdi, *(const sr_datafeed_meta*)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); @@ -677,9 +631,9 @@ void SigSession::data_feed_in(const struct sr_dev_inst *sdi, { lock_guard lock(_data_mutex); _cur_logic_snapshot.reset(); - _cur_analog_snapshot.reset(); + _cur_analog_snapshots.clear(); } - data_updated(); + frame_ended(); break; } }