X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsigsession.cpp;h=82fa877065254cd05c38f82aa64c19c54063732e;hp=41e31a2802a0af68c2d0505e2f3e3384ca96a010;hb=02412f0b16cb5ad92654c92b472a84268e79bb54;hpb=e8c9f8a5a3186f9c3e4f23ba4e35de7c59410bd3 diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp index 41e31a28..82fa8770 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,24 +18,44 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#ifdef ENABLE_DECODE +#include +#endif + #include "sigsession.h" #include "devicemanager.h" + #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 "view/analogsignal.h" +#include "view/decodetrace.h" #include "view/logicsignal.h" #include +#include + +#include + #include #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::map; +using std::set; +using std::string; +using std::vector; namespace pv { @@ -55,9 +75,7 @@ SigSession::~SigSession() { stop_capture(); - if (_sampling_thread.get()) - _sampling_thread->join(); - _sampling_thread.reset(); + _sampling_thread.join(); if (_sdi) _device_manager.release_device(_sdi); @@ -74,6 +92,9 @@ struct sr_dev_inst* SigSession::get_device() const void SigSession::set_device(struct sr_dev_inst *sdi) { + // Ensure we are not capturing before setting the device + stop_capture(); + if (_sdi) _device_manager.release_device(_sdi); if (sdi) @@ -106,12 +127,16 @@ void SigSession::load_file(const string &name, return; } - update_signals((sr_dev_inst*)devlist->data); + sr_dev_inst *const sdi = (sr_dev_inst*)devlist->data; g_slist_free(devlist); - _sampling_thread.reset(new boost::thread( + _decode_traces.clear(); + update_signals(sdi); + read_sample_rate(sdi); + + _sampling_thread = boost::thread( &SigSession::load_session_thread_proc, this, - error_handler)); + error_handler); } else { sr_input *in = NULL; @@ -120,13 +145,14 @@ void SigSession::load_file(const string &name, error_handler))) return; + _decode_traces.clear(); update_signals(in->sdi); + read_sample_rate(in->sdi); - _sampling_thread.reset(new boost::thread( + _sampling_thread = boost::thread( &SigSession::load_input_thread_proc, this, - name, in, error_handler)); + name, in, error_handler); } - } SigSession::capture_state SigSession::get_capture_state() const @@ -161,9 +187,9 @@ void SigSession::start_capture(uint64_t record_length, } // Begin the session - _sampling_thread.reset(new boost::thread( + _sampling_thread = boost::thread( &SigSession::sample_thread_proc, this, _sdi, - record_length, error_handler)); + record_length, error_handler); } void SigSession::stop_capture() @@ -174,22 +200,101 @@ void SigSession::stop_capture() sr_session_stop(); // Check that sampling stopped - if (_sampling_thread.get()) - _sampling_thread->join(); - _sampling_thread.reset(); + _sampling_thread.join(); +} + +set< shared_ptr > SigSession::get_data() const +{ + lock_guard lock(_signals_mutex); + set< shared_ptr > data; + BOOST_FOREACH(const shared_ptr sig, _signals) { + assert(sig); + data.insert(sig->data()); + } + + return data; } -vector< shared_ptr > SigSession::get_signals() +vector< shared_ptr > SigSession::get_signals() const { lock_guard lock(_signals_mutex); return _signals; } -boost::shared_ptr SigSession::get_data() +#ifdef ENABLE_DECODE +bool SigSession::add_decoder(srd_decoder *const dec) { - return _logic_data; + map > probes; + shared_ptr decoder_stack; + + try + { + lock_guard lock(_signals_mutex); + + // Create the decoder + decoder_stack = shared_ptr( + new data::DecoderStack(dec)); + + // 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(shared_ptr s, _signals) + { + shared_ptr l = + dynamic_pointer_cast(s); + if (l && QString::fromUtf8(probe->name). + toLower().contains( + l->get_name().toLower())) + probes[probe] = l; + } + } + + assert(decoder_stack); + assert(!decoder_stack->stack().empty()); + assert(decoder_stack->stack().front()); + decoder_stack->stack().front()->set_probes(probes); + + // Create the decode signal + shared_ptr d( + new view::DecodeTrace(*this, decoder_stack, + _decode_traces.size())); + _decode_traces.push_back(d); + } + catch(std::runtime_error e) + { + return false; + } + + signals_changed(); + + // Do an initial decode + decoder_stack->begin_decode(); + + return true; } +vector< shared_ptr > SigSession::get_decode_signals() const +{ + lock_guard 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++) + if ((*i).get() == signal) + { + _decode_traces.erase(i); + signals_changed(); + return; + } +} +#endif + void SigSession::set_capture_state(capture_state state) { lock_guard lock(_sampling_mutex); @@ -283,6 +388,9 @@ void SigSession::update_signals(const sr_dev_inst *const sdi) 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) { @@ -328,8 +436,7 @@ void SigSession::update_signals(const sr_dev_inst *const sdi) if(sdi) { for (const GSList *l = sdi->probes; l; l = l->next) { - const sr_probe *const probe = - (const sr_probe *)l->data; + sr_probe *const probe = (sr_probe *)l->data; assert(probe); switch(probe->type) { @@ -367,6 +474,31 @@ bool SigSession::is_trigger_enabled() const return false; } +void SigSession::read_sample_rate(const sr_dev_inst *const sdi) +{ + 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); + } + + 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) { @@ -427,7 +559,7 @@ void SigSession::sample_thread_proc(struct sr_dev_inst *sdi, } // Set the sample limit - if (sr_config_set(sdi, SR_CONF_LIMIT_SAMPLES, + 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.")); @@ -454,27 +586,7 @@ void SigSession::sample_thread_proc(struct sr_dev_inst *sdi, void SigSession::feed_in_header(const sr_dev_inst *sdi) { - GVariant *gvar; - uint64_t sample_rate = 0; - - // Read out the sample rate - if(sdi->driver) - { - const int ret = sr_config_get(sdi->driver, - SR_CONF_SAMPLERATE, &gvar, sdi); - if (ret != SR_OK) { - qDebug("Failed to get samplerate\n"); - return; - } - - sample_rate = g_variant_get_uint64(gvar); - g_variant_unref(gvar); - } - - if(_analog_data) - _analog_data->set_samplerate(sample_rate); - if(_logic_data) - _logic_data->set_samplerate(sample_rate); + read_sample_rate(sdi); } void SigSession::feed_in_meta(const sr_dev_inst *sdi, @@ -494,6 +606,8 @@ void SigSession::feed_in_meta(const sr_dev_inst *sdi, break; } } + + signals_changed(); } void SigSession::feed_in_logic(const sr_datafeed_logic &logic)