pv/data/decodesignal.cpp

   1 /*
   2  * This file is part of the PulseView project.
   3  *
   4  * Copyright (C) 2017 Soeren Apel <soeren@apelpie.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <limits>
  21
  22 #include <QDebug>
  23
  24 #include "logic.hpp"
  25 #include "logicsegment.hpp"
  26 #include "decodesignal.hpp"
  27 #include "signaldata.hpp"
  28
  29 #include <pv/binding/decoder.hpp>
  30 #include <pv/data/decode/decoder.hpp>
  31 #include <pv/data/decode/row.hpp>
  32 #include <pv/globalsettings.hpp>
  33 #include <pv/session.hpp>
  34
  35 using std::lock_guard;
  36 using std::make_pair;
  37 using std::make_shared;
  38 using std::min;
  39 using std::shared_ptr;
  40 using std::unique_lock;
  41 using pv::data::decode::Annotation;
  42 using pv::data::decode::Decoder;
  43 using pv::data::decode::Row;
  44
  45 namespace pv {
  46 namespace data {
  47
  48 const double DecodeSignal::DecodeMargin = 1.0;
  49 const double DecodeSignal::DecodeThreshold = 0.2;
  50 const int64_t DecodeSignal::DecodeChunkLength = 256 * 1024;
  51
  52
  53 DecodeSignal::DecodeSignal(pv::Session &session) :
  54         SignalBase(nullptr, SignalBase::DecodeChannel),
  55         session_(session),
  56         srd_session_(nullptr),
  57         logic_mux_data_invalid_(false),
  58         start_time_(0),
  59         samplerate_(0),
  60         samples_decoded_(0),
  61         frame_complete_(false)
  62 {
  63         connect(&session_, SIGNAL(capture_state_changed(int)),
  64                 this, SLOT(on_capture_state_changed(int)));
  65
  66         set_name(tr("Empty decoder signal"));
  67 }
  68
  69 DecodeSignal::~DecodeSignal()
  70 {
  71         reset_decode();
  72 }
  73
  74 const vector< shared_ptr<Decoder> >& DecodeSignal::decoder_stack() const
  75 {
  76         return stack_;
  77 }
  78
  79 void DecodeSignal::stack_decoder(const srd_decoder *decoder)
  80 {
  81         assert(decoder);
  82         stack_.push_back(make_shared<decode::Decoder>(decoder));
  83
  84         // Set name if this decoder is the first in the list
  85         if (stack_.size() == 1)
  86                 set_name(QString::fromUtf8(decoder->name));
  87
  88         // Include the newly created decode channels in the channel lists
  89         update_channel_list();
  90
  91         auto_assign_signals();
  92         commit_decoder_channels();
  93         begin_decode();
  94 }
  95
  96 void DecodeSignal::remove_decoder(int index)
  97 {
  98         assert(index >= 0);
  99         assert(index < (int)stack_.size());
 100
 101         // Find the decoder in the stack
 102         auto iter = stack_.begin();
 103         for (int i = 0; i < index; i++, iter++)
 104                 assert(iter != stack_.end());
 105
 106         // Delete the element
 107         stack_.erase(iter);
 108
 109         // Update channels and decoded data
 110         update_channel_list();
 111         begin_decode();
 112 }
 113
 114 bool DecodeSignal::toggle_decoder_visibility(int index)
 115 {
 116         auto iter = stack_.cbegin();
 117         for (int i = 0; i < index; i++, iter++)
 118                 assert(iter != stack_.end());
 119
 120         shared_ptr<Decoder> dec = *iter;
 121
 122         // Toggle decoder visibility
 123         bool state = false;
 124         if (dec) {
 125                 state = !dec->shown();
 126                 dec->show(state);
 127         }
 128
 129         return state;
 130 }
 131
 132 void DecodeSignal::reset_decode()
 133 {
 134         if (decode_thread_.joinable()) {
 135                 decode_interrupt_ = true;
 136                 decode_input_cond_.notify_one();
 137                 decode_thread_.join();
 138         }
 139
 140         if (logic_mux_thread_.joinable()) {
 141                 logic_mux_interrupt_ = true;
 142                 logic_mux_cond_.notify_one();
 143                 logic_mux_thread_.join();
 144         }
 145
 146         stop_srd_session();
 147
 148         frame_complete_ = false;
 149         samples_decoded_ = 0;
 150         error_message_ = QString();
 151
 152         rows_.clear();
 153         class_rows_.clear();
 154
 155         logic_mux_data_.reset();
 156         logic_mux_data_invalid_ = true;
 157 }
 158
 159 void DecodeSignal::begin_decode()
 160 {
 161         if (decode_thread_.joinable()) {
 162                 decode_interrupt_ = true;
 163                 decode_input_cond_.notify_one();
 164                 decode_thread_.join();
 165         }
 166
 167         if (logic_mux_thread_.joinable()) {
 168                 logic_mux_interrupt_ = true;
 169                 logic_mux_cond_.notify_one();
 170                 logic_mux_thread_.join();
 171         }
 172
 173         reset_decode();
 174
 175         if (stack_.size() == 0) {
 176                 error_message_ = tr("No decoders");
 177                 return;
 178         }
 179
 180         assert(channels_.size() > 0);
 181
 182         if (get_assigned_signal_count() == 0) {
 183                 error_message_ = tr("There are no channels assigned to this decoder");
 184                 return;
 185         }
 186
 187         // Make sure that all assigned channels still provide logic data
 188         // (can happen when a converted signal was assigned but the
 189         // conversion removed in the meanwhile)
 190         for (data::DecodeChannel &ch : channels_)
 191                 if (ch.assigned_signal && !(ch.assigned_signal->logic_data() != nullptr))
 192                         ch.assigned_signal = nullptr;
 193
 194         // Check that all decoders have the required channels
 195         for (const shared_ptr<decode::Decoder> &dec : stack_)
 196                 if (!dec->have_required_channels()) {
 197                         error_message_ = tr("One or more required channels "
 198                                 "have not been specified");
 199                         return;
 200                 }
 201
 202         // Add annotation classes
 203         for (const shared_ptr<decode::Decoder> &dec : stack_) {
 204                 assert(dec);
 205                 const srd_decoder *const decc = dec->decoder();
 206                 assert(dec->decoder());
 207
 208                 // Add a row for the decoder if it doesn't have a row list
 209                 if (!decc->annotation_rows)
 210                         rows_[Row(decc)] = decode::RowData();
 211
 212                 // Add the decoder rows
 213                 for (const GSList *l = decc->annotation_rows; l; l = l->next) {
 214                         const srd_decoder_annotation_row *const ann_row =
 215                                 (srd_decoder_annotation_row *)l->data;
 216                         assert(ann_row);
 217
 218                         const Row row(decc, ann_row);
 219
 220                         // Add a new empty row data object
 221                         rows_[row] = decode::RowData();
 222
 223                         // Map out all the classes
 224                         for (const GSList *ll = ann_row->ann_classes;
 225                                 ll; ll = ll->next)
 226                                 class_rows_[make_pair(decc,
 227                                         GPOINTER_TO_INT(ll->data))] = row;
 228                 }
 229         }
 230
 231         // Free the logic data and its segment(s) if it needs to be updated
 232         if (logic_mux_data_invalid_)
 233                 logic_mux_data_.reset();
 234
 235         if (!logic_mux_data_) {
 236                 const int64_t ch_count = get_assigned_signal_count();
 237                 const int64_t unit_size = (ch_count + 7) / 8;
 238                 logic_mux_data_ = make_shared<Logic>(ch_count);
 239                 segment_ = make_shared<LogicSegment>(*logic_mux_data_, unit_size, samplerate_);
 240                 logic_mux_data_->push_segment(segment_);
 241         }
 242
 243         // Make sure the logic output data is complete and up-to-date
 244         logic_mux_interrupt_ = false;
 245         logic_mux_thread_ = std::thread(&DecodeSignal::logic_mux_proc, this);
 246
 247         // Decode the muxed logic data
 248         decode_interrupt_ = false;
 249         decode_thread_ = std::thread(&DecodeSignal::decode_proc, this);
 250
 251         // Receive notifications when new sample data is available
 252         connect_input_notifiers();
 253 }
 254
 255 QString DecodeSignal::error_message() const
 256 {
 257         lock_guard<mutex> lock(output_mutex_);
 258         return error_message_;
 259 }
 260
 261 const vector<data::DecodeChannel> DecodeSignal::get_channels() const
 262 {
 263         return channels_;
 264 }
 265
 266 void DecodeSignal::auto_assign_signals()
 267 {
 268         bool new_assignment = false;
 269
 270         // Try to auto-select channels that don't have signals assigned yet
 271         for (data::DecodeChannel &ch : channels_) {
 272                 if (ch.assigned_signal)
 273                         continue;
 274
 275                 for (shared_ptr<data::SignalBase> s : session_.signalbases()) {
 276                         const QString ch_name = ch.name.toLower();
 277                         const QString s_name = s->name().toLower();
 278
 279                         if (s->logic_data() &&
 280                                 ((ch_name.contains(s_name)) || (s_name.contains(ch_name)))) {
 281                                 ch.assigned_signal = s.get();
 282                                 new_assignment = true;
 283                         }
 284                 }
 285         }
 286
 287         if (new_assignment) {
 288                 logic_mux_data_invalid_ = true;
 289                 commit_decoder_channels();
 290                 channels_updated();
 291         }
 292 }
 293
 294 void DecodeSignal::assign_signal(const uint16_t channel_id, const SignalBase *signal)
 295 {
 296         for (data::DecodeChannel &ch : channels_)
 297                 if (ch.id == channel_id) {
 298                         ch.assigned_signal = signal;
 299                         logic_mux_data_invalid_ = true;
 300                 }
 301
 302         commit_decoder_channels();
 303         channels_updated();
 304         begin_decode();
 305 }
 306
 307 int DecodeSignal::get_assigned_signal_count() const
 308 {
 309         // Count all channels that have a signal assigned to them
 310         return count_if(channels_.begin(), channels_.end(),
 311                 [](data::DecodeChannel ch) { return ch.assigned_signal; });
 312 }
 313
 314 void DecodeSignal::set_initial_pin_state(const uint16_t channel_id, const int init_state)
 315 {
 316         for (data::DecodeChannel &ch : channels_)
 317                 if (ch.id == channel_id)
 318                         ch.initial_pin_state = init_state;
 319
 320         channels_updated();
 321
 322         begin_decode();
 323 }
 324
 325 double DecodeSignal::samplerate() const
 326 {
 327         return samplerate_;
 328 }
 329
 330 const pv::util::Timestamp& DecodeSignal::start_time() const
 331 {
 332         return start_time_;
 333 }
 334
 335 int64_t DecodeSignal::get_working_sample_count() const
 336 {
 337         // The working sample count is the highest sample number for
 338         // which all used signals have data available, so go through
 339         // all channels and use the lowest overall sample count of the
 340         // current segment
 341
 342         // TODO Currently, we assume only a single segment exists
 343
 344         int64_t count = std::numeric_limits<int64_t>::max();
 345         bool no_signals_assigned = true;
 346
 347         for (const data::DecodeChannel &ch : channels_)
 348                 if (ch.assigned_signal) {
 349                         no_signals_assigned = false;
 350
 351                         const shared_ptr<Logic> logic_data = ch.assigned_signal->logic_data();
 352                         if (!logic_data || logic_data->logic_segments().empty())
 353                                 return 0;
 354
 355                         const shared_ptr<LogicSegment> segment = logic_data->logic_segments().front();
 356                         count = min(count, (int64_t)segment->get_sample_count());
 357                 }
 358
 359         return (no_signals_assigned ? 0 : count);
 360 }
 361
 362 int64_t DecodeSignal::get_decoded_sample_count() const
 363 {
 364         lock_guard<mutex> decode_lock(output_mutex_);
 365         return samples_decoded_;
 366 }
 367
 368 vector<Row> DecodeSignal::visible_rows() const
 369 {
 370         lock_guard<mutex> lock(output_mutex_);
 371
 372         vector<Row> rows;
 373
 374         for (const shared_ptr<decode::Decoder> &dec : stack_) {
 375                 assert(dec);
 376                 if (!dec->shown())
 377                         continue;
 378
 379                 const srd_decoder *const decc = dec->decoder();
 380                 assert(dec->decoder());
 381
 382                 // Add a row for the decoder if it doesn't have a row list
 383                 if (!decc->annotation_rows)
 384                         rows.emplace_back(decc);
 385
 386                 // Add the decoder rows
 387                 for (const GSList *l = decc->annotation_rows; l; l = l->next) {
 388                         const srd_decoder_annotation_row *const ann_row =
 389                                 (srd_decoder_annotation_row *)l->data;
 390                         assert(ann_row);
 391                         rows.emplace_back(decc, ann_row);
 392                 }
 393         }
 394
 395         return rows;
 396 }
 397
 398 void DecodeSignal::get_annotation_subset(
 399         vector<pv::data::decode::Annotation> &dest,
 400         const decode::Row &row, uint64_t start_sample,
 401         uint64_t end_sample) const
 402 {
 403         lock_guard<mutex> lock(output_mutex_);
 404
 405         const auto iter = rows_.find(row);
 406         if (iter != rows_.end())
 407                 (*iter).second.get_annotation_subset(dest,
 408                         start_sample, end_sample);
 409 }
 410
 411 void DecodeSignal::save_settings(QSettings &settings) const
 412 {
 413         SignalBase::save_settings(settings);
 414
 415         settings.setValue("decoders", (int)(stack_.size()));
 416
 417         // Save decoder stack
 418         int decoder_idx = 0;
 419         for (shared_ptr<decode::Decoder> decoder : stack_) {
 420                 settings.beginGroup("decoder" + QString::number(decoder_idx++));
 421
 422                 settings.setValue("id", decoder->decoder()->id);
 423
 424                 // Save decoder options
 425                 const map<string, GVariant*>& options = decoder->options();
 426
 427                 settings.setValue("options", (int)options.size());
 428
 429                 // Note: decode::Decoder::options() returns only the options
 430                 // that differ from the default. See binding::Decoder::getter()
 431                 int i = 0;
 432                 for (auto option : options) {
 433                         settings.beginGroup("option" + QString::number(i));
 434                         settings.setValue("name", QString::fromStdString(option.first));
 435                         GlobalSettings::store_gvariant(settings, option.second);
 436                         settings.endGroup();
 437                         i++;
 438                 }
 439
 440                 settings.endGroup();
 441         }
 442
 443         // Save channel mapping
 444         settings.setValue("channels", (int)channels_.size());
 445
 446         for (unsigned int channel_id = 0; channel_id < channels_.size(); channel_id++) {
 447                 auto channel = find_if(channels_.begin(), channels_.end(),
 448                         [&](data::DecodeChannel ch) { return ch.id == channel_id; });
 449
 450                 if (channel == channels_.end()) {
 451                         qDebug() << "ERROR: Gap in channel index:" << channel_id;
 452                         continue;
 453                 }
 454
 455                 settings.beginGroup("channel" + QString::number(channel_id));
 456
 457                 settings.setValue("name", channel->name);  // Useful for debugging
 458                 settings.setValue("initial_pin_state", channel->initial_pin_state);
 459
 460                 if (channel->assigned_signal)
 461                         settings.setValue("assigned_signal_name", channel->assigned_signal->name());
 462
 463                 settings.endGroup();
 464         }
 465 }
 466
 467 void DecodeSignal::restore_settings(QSettings &settings)
 468 {
 469         SignalBase::restore_settings(settings);
 470
 471         // Restore decoder stack
 472         GSList *dec_list = g_slist_copy((GSList*)srd_decoder_list());
 473
 474         int decoders = settings.value("decoders").toInt();
 475
 476         for (int decoder_idx = 0; decoder_idx < decoders; decoder_idx++) {
 477                 settings.beginGroup("decoder" + QString::number(decoder_idx));
 478
 479                 QString id = settings.value("id").toString();
 480
 481                 for (GSList *entry = dec_list; entry; entry = entry->next) {
 482                         const srd_decoder *dec = (srd_decoder*)entry->data;
 483                         if (!dec)
 484                                 continue;
 485
 486                         if (QString::fromUtf8(dec->id) == id) {
 487                                 shared_ptr<decode::Decoder> decoder =
 488                                         make_shared<decode::Decoder>(dec);
 489
 490                                 stack_.push_back(decoder);
 491
 492                                 // Restore decoder options that differ from their default
 493                                 int options = settings.value("options").toInt();
 494
 495                                 for (int i = 0; i < options; i++) {
 496                                         settings.beginGroup("option" + QString::number(i));
 497                                         QString name = settings.value("name").toString();
 498                                         GVariant *value = GlobalSettings::restore_gvariant(settings);
 499                                         decoder->set_option(name.toUtf8(), value);
 500                                         settings.endGroup();
 501                                 }
 502
 503                                 // Include the newly created decode channels in the channel lists
 504                                 update_channel_list();
 505                                 break;
 506                         }
 507                 }
 508
 509                 settings.endGroup();
 510         }
 511
 512         // Restore channel mapping
 513         unsigned int channels = settings.value("channels").toInt();
 514
 515         const unordered_set< shared_ptr<data::SignalBase> > signalbases =
 516                 session_.signalbases();
 517
 518         for (unsigned int channel_id = 0; channel_id < channels; channel_id++) {
 519                 auto channel = find_if(channels_.begin(), channels_.end(),
 520                         [&](data::DecodeChannel ch) { return ch.id == channel_id; });
 521
 522                 if (channel == channels_.end()) {
 523                         qDebug() << "ERROR: Non-existant channel index:" << channel_id;
 524                         continue;
 525                 }
 526
 527                 settings.beginGroup("channel" + QString::number(channel_id));
 528
 529                 QString assigned_signal_name = settings.value("assigned_signal_name").toString();
 530
 531                 for (shared_ptr<data::SignalBase> signal : signalbases)
 532                         if (signal->name() == assigned_signal_name)
 533                                 channel->assigned_signal = signal.get();
 534
 535                 channel->initial_pin_state = settings.value("initial_pin_state").toInt();
 536
 537                 settings.endGroup();
 538         }
 539
 540         begin_decode();
 541 }
 542
 543 void DecodeSignal::update_channel_list()
 544 {
 545         vector<data::DecodeChannel> prev_channels = channels_;
 546         channels_.clear();
 547
 548         uint16_t id = 0;
 549
 550         // Copy existing entries, create new as needed
 551         for (shared_ptr<Decoder> decoder : stack_) {
 552                 const srd_decoder* srd_d = decoder->decoder();
 553                 const GSList *l;
 554
 555                 // Mandatory channels
 556                 for (l = srd_d->channels; l; l = l->next) {
 557                         const struct srd_channel *const pdch = (struct srd_channel *)l->data;
 558                         bool ch_added = false;
 559
 560                         // Copy but update ID if this channel was in the list before
 561                         for (data::DecodeChannel &ch : prev_channels)
 562                                 if (ch.pdch_ == pdch) {
 563                                         ch.id = id++;
 564                                         channels_.push_back(ch);
 565                                         ch_added = true;
 566                                         break;
 567                                 }
 568
 569                         if (!ch_added) {
 570                                 // Create new entry without a mapped signal
 571                                 data::DecodeChannel ch = {id++, false, nullptr,
 572                                         QString::fromUtf8(pdch->name), QString::fromUtf8(pdch->desc),
 573                                         SRD_INITIAL_PIN_SAME_AS_SAMPLE0, decoder, pdch};
 574                                 channels_.push_back(ch);
 575                         }
 576                 }
 577
 578                 // Optional channels
 579                 for (l = srd_d->opt_channels; l; l = l->next) {
 580                         const struct srd_channel *const pdch = (struct srd_channel *)l->data;
 581                         bool ch_added = false;
 582
 583                         // Copy but update ID if this channel was in the list before
 584                         for (data::DecodeChannel &ch : prev_channels)
 585                                 if (ch.pdch_ == pdch) {
 586                                         ch.id = id++;
 587                                         channels_.push_back(ch);
 588                                         ch_added = true;
 589                                         break;
 590                                 }
 591
 592                         if (!ch_added) {
 593                                 // Create new entry without a mapped signal
 594                                 data::DecodeChannel ch = {id++, true, nullptr,
 595                                         QString::fromUtf8(pdch->name), QString::fromUtf8(pdch->desc),
 596                                         SRD_INITIAL_PIN_SAME_AS_SAMPLE0, decoder, pdch};
 597                                 channels_.push_back(ch);
 598                         }
 599                 }
 600         }
 601
 602         // Invalidate the logic output data if the channel assignment changed
 603         if (prev_channels.size() != channels_.size()) {
 604                 // The number of channels changed, there's definitely a difference
 605                 logic_mux_data_invalid_ = true;
 606         } else {
 607                 // Same number but assignment may still differ, so compare all channels
 608                 for (size_t i = 0; i < channels_.size(); i++) {
 609                         const data::DecodeChannel &p_ch = prev_channels[i];
 610                         const data::DecodeChannel &ch = channels_[i];
 611
 612                         if ((p_ch.pdch_ != ch.pdch_) ||
 613                                 (p_ch.assigned_signal != ch.assigned_signal)) {
 614                                 logic_mux_data_invalid_ = true;
 615                                 break;
 616                         }
 617                 }
 618
 619         }
 620
 621         channels_updated();
 622 }
 623
 624 void DecodeSignal::commit_decoder_channels()
 625 {
 626         // Submit channel list to every decoder, containing only the relevant channels
 627         for (shared_ptr<decode::Decoder> dec : stack_) {
 628                 vector<data::DecodeChannel*> channel_list;
 629
 630                 for (data::DecodeChannel &ch : channels_)
 631                         if (ch.decoder_ == dec)
 632                                 channel_list.push_back(&ch);
 633
 634                 dec->set_channels(channel_list);
 635         }
 636 }
 637
 638 void DecodeSignal::mux_logic_samples(const int64_t start, const int64_t end)
 639 {
 640         // Enforce end to be greater than start
 641         if (end <= start)
 642                 return;
 643
 644         // Fetch all segments and their data
 645         // TODO Currently, we assume only a single segment exists
 646         vector<shared_ptr<LogicSegment> > segments;
 647         vector<const uint8_t*> signal_data;
 648         vector<uint8_t> signal_in_bytepos;
 649         vector<uint8_t> signal_in_bitpos;
 650
 651         for (data::DecodeChannel &ch : channels_)
 652                 if (ch.assigned_signal) {
 653                         const shared_ptr<Logic> logic_data = ch.assigned_signal->logic_data();
 654                         const shared_ptr<LogicSegment> segment = logic_data->logic_segments().front();
 655                         segments.push_back(segment);
 656
 657                         uint8_t* data = new uint8_t[(end - start) * segment->unit_size()];
 658                         segment->get_samples(start, end, data);
 659                         signal_data.push_back(data);
 660
 661                         const int bitpos = ch.assigned_signal->logic_bit_index();
 662                         signal_in_bytepos.push_back(bitpos / 8);
 663                         signal_in_bitpos.push_back(bitpos % 8);
 664                 }
 665
 666         // Perform the muxing of signal data into the output data
 667         uint8_t* output = new uint8_t[(end - start) * segment_->unit_size()];
 668         unsigned int signal_count = signal_data.size();
 669
 670         for (int64_t sample_cnt = 0; sample_cnt < (end - start); sample_cnt++) {
 671                 int bitpos = 0;
 672                 uint8_t bytepos = 0;
 673
 674                 const int out_sample_pos = sample_cnt * segment_->unit_size();
 675                 for (unsigned int i = 0; i < segment_->unit_size(); i++)
 676                         output[out_sample_pos + i] = 0;
 677
 678                 for (unsigned int i = 0; i < signal_count; i++) {
 679                         const int in_sample_pos = sample_cnt * segments[i]->unit_size();
 680                         const uint8_t in_sample = 1 &
 681                                 ((signal_data[i][in_sample_pos + signal_in_bytepos[i]]) >> (signal_in_bitpos[i]));
 682
 683                         const uint8_t out_sample = output[out_sample_pos + bytepos];
 684
 685                         output[out_sample_pos + bytepos] = out_sample | (in_sample << bitpos);
 686
 687                         bitpos++;
 688                         if (bitpos > 7) {
 689                                 bitpos = 0;
 690                                 bytepos++;
 691                         }
 692                 }
 693         }
 694
 695         segment_->append_payload(output, (end - start) * segment_->unit_size());
 696         delete[] output;
 697
 698         for (const uint8_t* data : signal_data)
 699                 delete[] data;
 700 }
 701
 702 void DecodeSignal::logic_mux_proc()
 703 {
 704         do {
 705                 const uint64_t input_sample_count = get_working_sample_count();
 706                 const uint64_t output_sample_count = segment_->get_sample_count();
 707
 708                 const uint64_t samples_to_process =
 709                         (input_sample_count > output_sample_count) ?
 710                         (input_sample_count - output_sample_count) : 0;
 711
 712                 // Process the samples if necessary...
 713                 if (samples_to_process > 0) {
 714                         const uint64_t unit_size = segment_->unit_size();
 715                         const uint64_t chunk_sample_count = DecodeChunkLength / unit_size;
 716
 717                         uint64_t processed_samples = 0;
 718                         do {
 719                                 const uint64_t start_sample = output_sample_count + processed_samples;
 720                                 const uint64_t sample_count =
 721                                         min(samples_to_process - processed_samples,     chunk_sample_count);
 722
 723                                 mux_logic_samples(start_sample, start_sample + sample_count);
 724                                 processed_samples += sample_count;
 725
 726                                 // ...and process the newly muxed logic data
 727                                 decode_input_cond_.notify_one();
 728                         } while (processed_samples < samples_to_process);
 729                 }
 730
 731                 if (samples_to_process == 0) {
 732                         // Wait for more input
 733                         unique_lock<mutex> logic_mux_lock(logic_mux_mutex_);
 734                         logic_mux_cond_.wait(logic_mux_lock);
 735                 }
 736         } while (!logic_mux_interrupt_);
 737
 738         // No more input data and session is stopped, let the decode thread
 739         // process any pending data, terminate and release the global SRD mutex
 740         // in order to let other decoders run
 741         decode_input_cond_.notify_one();
 742 }
 743
 744 void DecodeSignal::query_input_metadata()
 745 {
 746         // Update the samplerate and start time because we cannot start
 747         // the libsrd session without the current samplerate
 748
 749         // TODO Currently we assume all channels have the same sample rate
 750         // and start time
 751         bool samplerate_valid = false;
 752
 753         auto any_channel = find_if(channels_.begin(), channels_.end(),
 754                 [](data::DecodeChannel ch) { return ch.assigned_signal; });
 755
 756         shared_ptr<Logic> logic_data =
 757                 any_channel->assigned_signal->logic_data();
 758
 759         do {
 760                 if (!logic_data->logic_segments().empty()) {
 761                         shared_ptr<LogicSegment> first_segment =
 762                                 any_channel->assigned_signal->logic_data()->logic_segments().front();
 763                         start_time_ = first_segment->start_time();
 764                         samplerate_ = first_segment->samplerate();
 765                         if (samplerate_ > 0)
 766                                 samplerate_valid = true;
 767                 }
 768
 769                 if (!samplerate_valid) {
 770                         // Wait until input data is available or an interrupt was requested
 771                         unique_lock<mutex> input_wait_lock(input_mutex_);
 772                         decode_input_cond_.wait(input_wait_lock);
 773                 }
 774         } while (!samplerate_valid && !decode_interrupt_);
 775 }
 776
 777 void DecodeSignal::decode_data(
 778         const int64_t abs_start_samplenum, const int64_t sample_count)
 779 {
 780         const int64_t unit_size = segment_->unit_size();
 781         const int64_t chunk_sample_count = DecodeChunkLength / unit_size;
 782
 783         for (int64_t i = abs_start_samplenum;
 784                 !decode_interrupt_ && (i < (abs_start_samplenum + sample_count));
 785                 i += chunk_sample_count) {
 786
 787                 const int64_t chunk_end = min(i + chunk_sample_count,
 788                         abs_start_samplenum + sample_count);
 789
 790                 int64_t data_size = (chunk_end - i) * unit_size;
 791                 uint8_t* chunk = new uint8_t[data_size];
 792                 segment_->get_samples(i, chunk_end, chunk);
 793
 794                 if (srd_session_send(srd_session_, i, chunk_end, chunk,
 795                                 data_size, unit_size) != SRD_OK) {
 796                         error_message_ = tr("Decoder reported an error");
 797                         delete[] chunk;
 798                         break;
 799                 }
 800
 801                 delete[] chunk;
 802
 803                 {
 804                         lock_guard<mutex> lock(output_mutex_);
 805                         samples_decoded_ = chunk_end;
 806                 }
 807
 808                 // Notify the frontend that we processed some data and
 809                 // possibly have new annotations as well
 810                 new_annotations();
 811         }
 812 }
 813
 814 void DecodeSignal::decode_proc()
 815 {
 816         query_input_metadata();
 817
 818         if (decode_interrupt_)
 819                 return;
 820
 821         start_srd_session();
 822
 823         uint64_t sample_count;
 824         uint64_t abs_start_samplenum = 0;
 825         do {
 826                 // Keep processing new samples until we exhaust the input data
 827                 do {
 828                         lock_guard<mutex> input_lock(input_mutex_);
 829                         sample_count = segment_->get_sample_count() - abs_start_samplenum;
 830
 831                         if (sample_count > 0) {
 832                                 decode_data(abs_start_samplenum, sample_count);
 833                                 abs_start_samplenum += sample_count;
 834                         }
 835                 } while (error_message_.isEmpty() && (sample_count > 0) && !decode_interrupt_);
 836
 837                 if (error_message_.isEmpty() && !decode_interrupt_) {
 838                         if (sample_count == 0)
 839                                 decode_finished();
 840
 841                         // Wait for new input data or an interrupt was requested
 842                         unique_lock<mutex> input_wait_lock(input_mutex_);
 843                         decode_input_cond_.wait(input_wait_lock);
 844                 }
 845         } while (error_message_.isEmpty() && !decode_interrupt_);
 846 }
 847
 848 void DecodeSignal::start_srd_session()
 849 {
 850         if (srd_session_)
 851                 stop_srd_session();
 852
 853         // Create the session
 854         srd_session_new(&srd_session_);
 855         assert(srd_session_);
 856
 857         // Create the decoders
 858         srd_decoder_inst *prev_di = nullptr;
 859         for (const shared_ptr<decode::Decoder> &dec : stack_) {
 860                 srd_decoder_inst *const di = dec->create_decoder_inst(srd_session_);
 861
 862                 if (!di) {
 863                         error_message_ = tr("Failed to create decoder instance");
 864                         srd_session_destroy(srd_session_);
 865                         return;
 866                 }
 867
 868                 if (prev_di)
 869                         srd_inst_stack(srd_session_, prev_di, di);
 870
 871                 prev_di = di;
 872         }
 873
 874         // Start the session
 875         srd_session_metadata_set(srd_session_, SRD_CONF_SAMPLERATE,
 876                 g_variant_new_uint64(samplerate_));
 877
 878         srd_pd_output_callback_add(srd_session_, SRD_OUTPUT_ANN,
 879                 DecodeSignal::annotation_callback, this);
 880
 881         srd_session_start(srd_session_);
 882 }
 883
 884 void DecodeSignal::stop_srd_session()
 885 {
 886         if (srd_session_) {
 887                 // Destroy the session
 888                 srd_session_destroy(srd_session_);
 889                 srd_session_ = nullptr;
 890         }
 891 }
 892
 893 void DecodeSignal::connect_input_notifiers()
 894 {
 895         // Disconnect the notification slot from the previous set of signals
 896         disconnect(this, SLOT(on_data_cleared()));
 897         disconnect(this, SLOT(on_data_received()));
 898
 899         // Connect the currently used signals to our slot
 900         for (data::DecodeChannel &ch : channels_) {
 901                 if (!ch.assigned_signal)
 902                         continue;
 903
 904                 const data::SignalBase *signal = ch.assigned_signal;
 905                 connect(signal, SIGNAL(samples_cleared()),
 906                         this, SLOT(on_data_cleared()));
 907                 connect(signal, SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
 908                         this, SLOT(on_data_received()));
 909         }
 910 }
 911
 912 void DecodeSignal::annotation_callback(srd_proto_data *pdata, void *decode_signal)
 913 {
 914         assert(pdata);
 915         assert(decoder);
 916
 917         DecodeSignal *const ds = (DecodeSignal*)decode_signal;
 918         assert(ds);
 919
 920         lock_guard<mutex> lock(ds->output_mutex_);
 921
 922         const decode::Annotation a(pdata);
 923
 924         // Find the row
 925         assert(pdata->pdo);
 926         assert(pdata->pdo->di);
 927         const srd_decoder *const decc = pdata->pdo->di->decoder;
 928         assert(decc);
 929
 930         auto row_iter = ds->rows_.end();
 931
 932         // Try looking up the sub-row of this class
 933         const auto r = ds->class_rows_.find(make_pair(decc, a.format()));
 934         if (r != ds->class_rows_.end())
 935                 row_iter = ds->rows_.find((*r).second);
 936         else {
 937                 // Failing that, use the decoder as a key
 938                 row_iter = ds->rows_.find(Row(decc));
 939         }
 940
 941         assert(row_iter != ds->rows_.end());
 942         if (row_iter == ds->rows_.end()) {
 943                 qDebug() << "Unexpected annotation: decoder = " << decc <<
 944                         ", format = " << a.format();
 945                 assert(false);
 946                 return;
 947         }
 948
 949         // Add the annotation
 950         (*row_iter).second.push_annotation(a);
 951 }
 952
 953 void DecodeSignal::on_capture_state_changed(int state)
 954 {
 955         // If a new acquisition was started, we need to start decoding from scratch
 956         if (state == Session::Running)
 957                 begin_decode();
 958 }
 959
 960 void DecodeSignal::on_data_cleared()
 961 {
 962         reset_decode();
 963 }
 964
 965 void DecodeSignal::on_data_received()
 966 {
 967         if (!logic_mux_thread_.joinable())
 968                 begin_decode();
 969         else
 970                 logic_mux_cond_.notify_one();
 971 }
 972
 973 } // namespace data
 974 } // namespace pv