X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Fdecoderstack.cpp;h=b8eff67ffd02d0dc5ab018806b056b0c9849cf67;hp=d56422a9a4f38090069c469d2e2006b13bf29643;hb=064a7f42c7a107eae88c946718fe4141b52f8e0c;hpb=6e89374a6796f8d5d9cc61b0a2f7e98562a034ae diff --git a/pv/data/decoderstack.cpp b/pv/data/decoderstack.cpp index d56422a9..b8eff67f 100644 --- a/pv/data/decoderstack.cpp +++ b/pv/data/decoderstack.cpp @@ -20,6 +20,7 @@ #include +#include #include #include @@ -30,11 +31,17 @@ #include #include +#include +#include #include -#include -using namespace boost; -using namespace std; +using boost::lock_guard; +using boost::mutex; +using boost::shared_ptr; +using std::deque; +using std::min; +using std::list; +using std::vector; namespace pv { namespace data { @@ -46,52 +53,53 @@ const int64_t DecoderStack::DecodeChunkLength = 4096; mutex DecoderStack::_global_decode_mutex; DecoderStack::DecoderStack(const srd_decoder *const dec) : - _decoder(dec), - _options(g_hash_table_new_full(g_str_hash, - g_str_equal, g_free, (GDestroyNotify)g_variant_unref)) + _samples_decoded(0) { + _stack.push_back(shared_ptr( + new decode::Decoder(dec))); } DecoderStack::~DecoderStack() { _decode_thread.interrupt(); _decode_thread.join(); - - g_hash_table_destroy(_options); } -const srd_decoder* DecoderStack::decoder() const +const std::list< boost::shared_ptr >& +DecoderStack::stack() const { - return _decoder; + return _stack; } -const map >& -DecoderStack::probes() const +void DecoderStack::push(boost::shared_ptr decoder) { - return _probes; + assert(decoder); + _stack.push_back(decoder); } -void DecoderStack::set_probes(std::map > probes) +void DecoderStack::remove(int index) { - _probes = probes; - begin_decode(); -} + using pv::data::decode::Decoder; -const GHashTable* DecoderStack::options() const -{ - return _options; + assert(index >= 0); + assert(index < (int)_stack.size()); + + // Find the decoder in the stack + list< shared_ptr >::iterator iter = _stack.begin(); + for(int i = 0; i < index; i++, iter++) + assert(iter != _stack.end()); + + // Delete the element + _stack.erase(iter); } -void DecoderStack::set_option(const char *id, GVariant *value) +int64_t DecoderStack::samples_decoded() const { - g_variant_ref(value); - g_hash_table_replace(_options, (void*)g_strdup(id), value); - begin_decode(); + lock_guard decode_lock(_mutex); + return _samples_decoded; } -const vector< shared_ptr > - DecoderStack::annotations() const +const vector DecoderStack::annotations() const { lock_guard lock(_mutex); return _annotations; @@ -105,48 +113,55 @@ QString DecoderStack::error_message() void DecoderStack::begin_decode() { + shared_ptr logic_signal; + shared_ptr data; + _decode_thread.interrupt(); _decode_thread.join(); - _annotations.clear(); + _samples_decoded = 0; - if (_probes.empty()) - return; - - // Get the samplerate and start time - shared_ptr logic_signal = - dynamic_pointer_cast( - (*_probes.begin()).second); - if (logic_signal) { - shared_ptr data( - logic_signal->data()); - if (data) { - _start_time = data->get_start_time(); - _samplerate = data->get_samplerate(); - if (_samplerate == 0.0) - _samplerate = 1.0; - } - } + _annotations.clear(); // We get the logic data of the first probe in the list. // This works because we are currently assuming all // LogicSignals have the same data/snapshot - shared_ptr sig = (*_probes.begin()).second; - assert(sig); - shared_ptr data = sig->data(); + BOOST_FOREACH (const shared_ptr &dec, _stack) + if (dec && !dec->probes().empty() && + ((logic_signal = (*dec->probes().begin()).second)) && + ((data = logic_signal->logic_data()))) + break; + + if (!data) + return; + + // Get the samplerate and start time + _start_time = data->get_start_time(); + _samplerate = data->samplerate(); + if (_samplerate == 0.0) + _samplerate = 1.0; _decode_thread = boost::thread(&DecoderStack::decode_proc, this, data); } -void DecoderStack::clear_snapshots() +void DecoderStack::clear() { + _annotations.clear(); +} + +uint64_t DecoderStack::get_max_sample_count() const +{ + if (_annotations.empty()) + return 0; + return _annotations.back().end_sample(); } void DecoderStack::decode_proc(shared_ptr data) { srd_session *session; uint8_t chunk[DecodeChunkLength]; + srd_decoder_inst *prev_di = NULL; assert(data); @@ -158,53 +173,49 @@ void DecoderStack::decode_proc(shared_ptr data) const shared_ptr &snapshot = snapshots.front(); const int64_t sample_count = snapshot->get_sample_count() - 1; + const unsigned int chunk_sample_count = + DecodeChunkLength / snapshot->unit_size(); // Create the session srd_session_new(&session); assert(session); - srd_session_metadata_set(session, SRD_CONF_SAMPLERATE, - g_variant_new_uint64((uint64_t)_samplerate)); - - srd_pd_output_callback_add(session, SRD_OUTPUT_ANN, - DecoderStack::annotation_callback, this); + // Create the decoders + BOOST_FOREACH(const shared_ptr &dec, _stack) + { + srd_decoder_inst *const di = dec->create_decoder_inst(session); - // Create the decoder instance - srd_decoder_inst *const decoder_inst = srd_inst_new( - session, _decoder->id, _options); - if(!decoder_inst) { - _error_message = tr("Failed to initialise decoder"); - return; - } + if (!di) + { + _error_message = tr("Failed to initialise decoder"); + srd_session_destroy(session); + return; + } - // Setup the probes - GHashTable *const probes = g_hash_table_new_full(g_str_hash, - g_str_equal, g_free, (GDestroyNotify)g_variant_unref); + if (prev_di) + srd_inst_stack (session, prev_di, di); - for(map >:: - const_iterator i = _probes.begin(); - i != _probes.end(); i++) - { - shared_ptr signal((*i).second); - GVariant *const gvar = g_variant_new_int32( - signal->probe()->index); - g_variant_ref_sink(gvar); - g_hash_table_insert(probes, (*i).first->id, gvar); + prev_di = di; } - srd_inst_probe_set_all(decoder_inst, probes); - // Start the session + srd_session_metadata_set(session, SRD_CONF_SAMPLERATE, + g_variant_new_uint64((uint64_t)_samplerate)); + + srd_pd_output_callback_add(session, SRD_OUTPUT_ANN, + DecoderStack::annotation_callback, this); + srd_session_start(session); for (int64_t i = 0; - !this_thread::interruption_requested() && i < sample_count; - i += DecodeChunkLength) + !boost::this_thread::interruption_requested() && + i < sample_count; + i += chunk_sample_count) { lock_guard decode_lock(_global_decode_mutex); const int64_t chunk_end = min( - i + DecodeChunkLength, sample_count); + i + chunk_sample_count, sample_count); snapshot->get_samples(chunk, i, chunk_end); if (srd_session_send(session, i, i + sample_count, @@ -212,6 +223,11 @@ void DecoderStack::decode_proc(shared_ptr data) _error_message = tr("Failed to initialise decoder"); break; } + + { + lock_guard lock(_mutex); + _samples_decoded = chunk_end; + } } // Destroy the session @@ -220,16 +236,15 @@ void DecoderStack::decode_proc(shared_ptr data) void DecoderStack::annotation_callback(srd_proto_data *pdata, void *decoder) { - using namespace pv::view::decode; + using pv::data::decode::Annotation; assert(pdata); assert(decoder); DecoderStack *const d = (DecoderStack*)decoder; - shared_ptr a(new Annotation(pdata)); lock_guard lock(d->_mutex); - d->_annotations.push_back(a); + d->_annotations.push_back(Annotation(pdata)); d->new_decode_data(); }