#include <boost/thread/thread.hpp>
+#include <stdexcept>
+
+#include <QDebug>
+
#include "decoder.h"
#include <pv/data/logic.h>
Decoder::Decoder(const srd_decoder *const dec,
std::map<const srd_probe*,
- boost::shared_ptr<pv::view::Signal> > probes,
+ boost::shared_ptr<pv::view::LogicSignal> > probes,
GHashTable *options) :
_decoder(dec),
_probes(probes),
_options(options),
+ _session(NULL),
_decoder_inst(NULL)
{
- init_decoder();
+ if (!init_decoder())
+ throw runtime_error("Failed to initialise decoder.");
+
begin_decode();
}
_decode_thread.join();
g_hash_table_destroy(_options);
+
+ if (_session)
+ srd_session_destroy(_session);
}
const srd_decoder* Decoder::get_decoder() const
// 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<pv::view::Signal> sig = (*_probes.begin()).second;
+ shared_ptr<pv::view::LogicSignal> sig = (*_probes.begin()).second;
assert(sig);
- const pv::view::LogicSignal *const l =
- dynamic_cast<pv::view::LogicSignal*>(sig.get());
- assert(l);
- shared_ptr<data::Logic> data = l->data();
+ shared_ptr<data::Logic> data = sig->data();
_decode_thread = boost::thread(&Decoder::decode_proc, this,
data);
{
}
-void Decoder::init_decoder()
+bool Decoder::init_decoder()
{
if (!_probes.empty())
{
}
}
- _decoder_inst = srd_inst_new(_decoder->id, _options);
- assert(_decoder_inst);
+ srd_session_new(&_session);
+ assert(_session);
+
+ _decoder_inst = srd_inst_new(_session, _decoder->id, _options);
+ if(!_decoder_inst) {
+ qDebug() << "Failed to initialise decoder";
+ return false;
+ }
_decoder_inst->data_samplerate = _samplerate;
GHashTable *probes = g_hash_table_new_full(g_str_hash,
g_str_equal, g_free, (GDestroyNotify)g_variant_unref);
- for(map<const srd_probe*, shared_ptr<view::Signal> >::
+ for(map<const srd_probe*, shared_ptr<view::LogicSignal> >::
const_iterator i = _probes.begin();
i != _probes.end(); i++)
{
}
srd_inst_probe_set_all(_decoder_inst, probes);
+
+ return true;
}
void Decoder::decode_proc(shared_ptr<data::Logic> data)
if (samplerate == 0.0)
samplerate = 1.0;
- srd_session_start(_probes.size(), snapshot->unit_size(), samplerate);
+ srd_session_config_set(_session, SRD_CONF_NUM_PROBES,
+ g_variant_new_uint64(_probes.size()));
+ srd_session_config_set(_session, SRD_CONF_UNITSIZE,
+ g_variant_new_uint64(snapshot->unit_size()));
+ srd_session_config_set(_session, SRD_CONF_SAMPLERATE,
+ g_variant_new_uint64((uint64_t)samplerate));
- srd_pd_output_callback_add(SRD_OUTPUT_ANN,
+ srd_session_start(_session);
+
+ srd_pd_output_callback_add(_session, SRD_OUTPUT_ANN,
Decoder::annotation_callback, this);
for (int64_t i = 0;
i + DecodeChunkLength, sample_count);
snapshot->get_samples(chunk, i, chunk_end);
- if (srd_session_send(i, chunk, chunk_end - i) != SRD_OK)
+ if (srd_session_send(_session, i, chunk, chunk_end - i) !=
+ SRD_OK)
break;
}
}
shared_ptr<Annotation> a(new Annotation(pdata));
lock_guard<mutex> lock(d->_annotations_mutex);
d->_annotations.push_back(a);
+
+ d->new_decode_data();
}
} // namespace data