const double DecoderStack::DecodeMargin = 1.0;
const double DecoderStack::DecodeThreshold = 0.2;
const int64_t DecoderStack::DecodeChunkLength = 4096;
+const unsigned int DecoderStack::DecodeNotifyPeriod = 65536;
mutex DecoderStack::_global_decode_mutex;
assert(index < (int)_stack.size());
// Find the decoder in the stack
- list< shared_ptr<Decoder> >::iterator iter = _stack.begin();
+ auto iter = _stack.begin();
for(int i = 0; i < index; i++, iter++)
assert(iter != _stack.end());
{
lock_guard<mutex> lock(_output_mutex);
- std::map<const Row, decode::RowData>::const_iterator iter =
- _rows.find(row);
+ const auto iter = _rows.find(row);
if (iter != _rows.end())
(*iter).second.get_annotation_subset(dest,
start_sample, end_sample);
clear();
+ // Check that all decoders have the required channels
+ BOOST_FOREACH(const shared_ptr<decode::Decoder> &dec, _stack)
+ if (!dec->have_required_probes()) {
+ _error_message = tr("One or more required channels "
+ "have not been specified");
+ return;
+ }
+
// Add classes
BOOST_FOREACH (const shared_ptr<decode::Decoder> &dec, _stack)
{
}
}
- // We get the logic data of the first probe in the list.
+ // We get the logic data of the first channel in the list.
// This works because we are currently assuming all
// LogicSignals have the same data/snapshot
BOOST_FOREACH (const shared_ptr<decode::Decoder> &dec, _stack)
- if (dec && !dec->probes().empty() &&
- ((logic_signal = (*dec->probes().begin()).second)) &&
+ if (dec && !dec->channels().empty() &&
+ ((logic_signal = (*dec->channels().begin()).second)) &&
((data = logic_signal->logic_data())))
break;
if (_samplerate == 0.0)
_samplerate = 1.0;
- _decode_thread = boost::thread(&DecoderStack::decode_proc, this,
- data);
+ _decode_thread = boost::thread(&DecoderStack::decode_proc, this);
}
uint64_t DecoderStack::get_max_sample_count() const
{
uint64_t max_sample_count = 0;
- for (map<const Row, RowData>::const_iterator i = _rows.begin();
- i != _rows.end(); i++)
+ for (auto i = _rows.cbegin(); i != _rows.end(); i++)
max_sample_count = max(max_sample_count,
(*i).second.get_max_sample());
lock_guard<mutex> lock(_output_mutex);
_samples_decoded = chunk_end;
}
+
+ if (i % DecodeNotifyPeriod == 0)
+ new_decode_data();
}
new_decode_data();
}
-void DecoderStack::decode_proc(shared_ptr<data::Logic> data)
+void DecoderStack::decode_proc()
{
optional<int64_t> sample_count;
srd_session *session;
srd_decoder_inst *prev_di = NULL;
- assert(data);
assert(_snapshot);
- // Check that all decoders have the required probes
- BOOST_FOREACH(const shared_ptr<decode::Decoder> &dec, _stack)
- if (!dec->have_required_probes())
- return;
-
// Create the session
srd_session_new(&session);
assert(session);
const srd_decoder *const decc = pdata->pdo->di->decoder;
assert(decc);
- map<const Row, decode::RowData>::iterator row_iter = d->_rows.end();
+ auto row_iter = d->_rows.end();
// Try looking up the sub-row of this class
- const map<pair<const srd_decoder*, int>, Row>::const_iterator r =
- d->_class_rows.find(make_pair(decc, a.format()));
+ const auto r = d->_class_rows.find(make_pair(decc, a.format()));
if (r != d->_class_rows.end())
row_iter = d->_rows.find((*r).second);
else
{
{
unique_lock<mutex> lock(_input_mutex);
- _sample_count = _snapshot->get_sample_count();
+ if (_snapshot)
+ _sample_count = _snapshot->get_sample_count();
}
_input_cond.notify_one();
}
{
{
unique_lock<mutex> lock(_input_mutex);
- _frame_complete = true;
+ if (_snapshot)
+ _frame_complete = true;
}
_input_cond.notify_one();
}