DecodeSignal::DecodeSignal(pv::Session &session) :
SignalBase(nullptr, SignalBase::DecodeChannel),
session_(session),
+ srd_session_(nullptr),
logic_mux_data_invalid_(false),
start_time_(0),
samplerate_(0),
{
connect(&session_, SIGNAL(capture_state_changed(int)),
this, SLOT(on_capture_state_changed(int)));
- connect(&session_, SIGNAL(data_received()),
- this, SLOT(on_data_received()));
- connect(&session_, SIGNAL(frame_ended()),
- this, SLOT(on_frame_ended()));
set_name(tr("Empty decoder signal"));
}
logic_mux_cond_.notify_one();
logic_mux_thread_.join();
}
+
+ stop_srd_session();
}
const vector< shared_ptr<Decoder> >& DecodeSignal::decoder_stack() const
void DecodeSignal::reset_decode()
{
+ stop_srd_session();
+
annotation_count_ = 0;
frame_complete_ = false;
samples_decoded_ = 0;
// Decode the muxed logic data
decode_interrupt_ = false;
decode_thread_ = std::thread(&DecodeSignal::decode_proc, this);
+
+ // Receive notifications when new sample data is available
+ connect_input_notifiers();
}
QString DecodeSignal::error_message() const
void DecodeSignal::logic_mux_proc()
{
do {
-
const uint64_t input_sample_count = get_working_sample_count();
const uint64_t output_sample_count = segment_->get_sample_count();
}
void DecodeSignal::decode_data(
- const int64_t abs_start_samplenum, const int64_t sample_count,
- srd_session *const session)
+ const int64_t abs_start_samplenum, const int64_t sample_count)
{
const int64_t unit_size = segment_->unit_size();
const int64_t chunk_sample_count = DecodeChunkLength / unit_size;
const uint8_t* chunk = segment_->get_samples(i, chunk_end);
- if (srd_session_send(session, i, chunk_end, chunk,
+ if (srd_session_send(srd_session_, i, chunk_end, chunk,
(chunk_end - i) * unit_size, unit_size) != SRD_OK) {
error_message_ = tr("Decoder reported an error");
delete[] chunk;
void DecodeSignal::decode_proc()
{
- srd_session *session;
- srd_decoder_inst *prev_di = nullptr;
-
- // Prevent any other decode threads from accessing libsigrokdecode
- lock_guard<mutex> srd_lock(global_srd_mutex_);
-
- // Create the session
- srd_session_new(&session);
- assert(session);
-
- // Create the decoders
- for (const shared_ptr<decode::Decoder> &dec : stack_) {
- srd_decoder_inst *const di = dec->create_decoder_inst(session);
-
- if (!di) {
- error_message_ = tr("Failed to create decoder instance");
- srd_session_destroy(session);
- return;
- }
-
- if (prev_di)
- srd_inst_stack(session, prev_di, di);
-
- prev_di = di;
- }
-
- // Start the session
- srd_session_metadata_set(session, SRD_CONF_SAMPLERATE,
- g_variant_new_uint64(samplerate_));
-
- srd_pd_output_callback_add(session, SRD_OUTPUT_ANN,
- DecodeSignal::annotation_callback, this);
-
- srd_session_start(session);
+ start_srd_session();
uint64_t sample_count;
uint64_t abs_start_samplenum = 0;
do {
// Keep processing new samples until we exhaust the input data
do {
+ // Prevent any other decode threads from accessing libsigrokdecode
+ lock_guard<mutex> srd_lock(global_srd_mutex_);
+
{
lock_guard<mutex> input_lock(input_mutex_);
sample_count = segment_->get_sample_count() - abs_start_samplenum;
}
if (sample_count > 0) {
- decode_data(abs_start_samplenum, sample_count, session);
+ decode_data(abs_start_samplenum, sample_count);
abs_start_samplenum += sample_count;
}
} while (error_message_.isEmpty() && (sample_count > 0));
- // Terminate if we exhausted the input data
- if ((int64_t)segment_->get_sample_count() == get_working_sample_count())
- break;
-
if (error_message_.isEmpty()) {
+ // Make sure all annotations are known to the frontend
+ new_annotations();
+
// Wait for new input data or an interrupt request
unique_lock<mutex> input_wait_lock(input_mutex_);
decode_input_cond_.wait(input_wait_lock);
}
} while (error_message_.isEmpty() && !decode_interrupt_);
+}
+
+void DecodeSignal::start_srd_session()
+{
+ if (!srd_session_) {
+ // Create the session
+ srd_session_new(&srd_session_);
+ assert(srd_session_);
- // Make sure all annotations are known to the frontend
- new_annotations();
+ // Create the decoders
+ srd_decoder_inst *prev_di = nullptr;
+ for (const shared_ptr<decode::Decoder> &dec : stack_) {
+ srd_decoder_inst *const di = dec->create_decoder_inst(srd_session_);
- // Destroy the session
- srd_session_destroy(session);
+ if (!di) {
+ error_message_ = tr("Failed to create decoder instance");
+ srd_session_destroy(srd_session_);
+ return;
+ }
+
+ if (prev_di)
+ srd_inst_stack(srd_session_, prev_di, di);
+
+ prev_di = di;
+ }
+
+ // Start the session
+ srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
+ g_variant_new_uint64(samplerate_));
+
+ srd_pd_output_callback_add(srd_session_, SRD_OUTPUT_ANN,
+ DecodeSignal::annotation_callback, this);
+
+ srd_session_start(srd_session_);
+ }
+}
+
+void DecodeSignal::stop_srd_session()
+{
+ if (srd_session_) {
+ // Destroy the session
+ srd_session_destroy(srd_session_);
+ srd_session_ = nullptr;
+ }
+}
+
+void DecodeSignal::connect_input_notifiers()
+{
+ // Disconnect the notification slot from the previous set of signals
+ disconnect(this, SLOT(on_data_received()));
+
+ // Connect the currently used signals to our slot
+ for (data::DecodeChannel &ch : channels_) {
+ if (!ch.assigned_signal)
+ continue;
+
+ shared_ptr<Logic> logic_data = ch.assigned_signal->logic_data();
+ connect(logic_data.get(), SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
+ this, SLOT(on_data_received()));
+ }
}
void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signal)
logic_mux_cond_.notify_one();
}
-void DecodeSignal::on_frame_ended()
-{
- logic_mux_cond_.notify_one();
-}
-
} // namespace data
} // namespace pv