23 #include <forward_list> 27 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) 28 #include <QRegularExpression> 41 using std::dynamic_pointer_cast;
42 using std::lock_guard;
43 using std::make_shared;
45 using std::out_of_range;
46 using std::shared_ptr;
47 using std::unique_lock;
62 srd_session_(nullptr),
63 logic_mux_data_invalid_(false),
64 stack_config_changed_(true),
65 current_segment_id_(0)
67 connect(&
session_, SIGNAL(capture_state_changed(
int)),
100 const srd_decoder* prev_dec =
stack_.empty() ?
nullptr :
stack_.back()->get_srd_decoder();
101 const QString prev_dec_name = prev_dec ? QString::fromUtf8(prev_dec->name) : QString();
104 set_name(QString::fromUtf8(decoder->name));
106 const shared_ptr<Decoder> dec = make_shared<Decoder>(decoder,
stack_.size());
129 assert(index < (
int)
stack_.size());
133 assert(iter !=
stack_.end());
135 shared_ptr<Decoder> dec = *iter;
150 auto iter =
stack_.cbegin();
151 for (
int i = 0; i <
index; i++, iter++)
152 assert(iter !=
stack_.end());
154 shared_ptr<Decoder> dec = *iter;
159 state = !dec->visible();
160 dec->set_visible(state);
190 for (
const shared_ptr<decode::Decoder>& dec :
stack_)
191 if (dec->has_logic_output())
200 qDebug().nospace() <<
name() <<
": Error cleared";
238 if (ch.assigned_signal && !(ch.assigned_signal->logic_data() !=
nullptr))
239 ch.assigned_signal =
nullptr;
242 for (
const shared_ptr<Decoder>& dec :
stack_)
243 if (!dec->have_required_channels()) {
245 "have not been specified"));
297 bool new_assignment =
false;
305 if (dec && (ch.decoder_ != dec))
308 if (ch.assigned_signal)
311 QString ch_name = ch.name.toLower();
312 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) 313 ch_name = ch_name.replace(QRegularExpression(
"[-_.]"),
" ");
315 ch_name = ch_name.replace(QRegExp(
"[-_.]"),
" ");
318 shared_ptr<data::SignalBase> match;
323 QString s_name = s->name().toLower();
324 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) 325 s_name = s_name.replace(QRegularExpression(
"[-_.]"),
" ");
327 s_name = s_name.replace(QRegExp(
"[-_.]"),
" ");
330 if (s->logic_data() &&
331 ((ch_name.contains(s_name)) || (s_name.contains(ch_name)))) {
336 int old_unmatched = ch_name.length() - match->name().length();
337 int new_unmatched = ch_name.length() - s->name().length();
338 if (abs(new_unmatched) < abs(old_unmatched))
345 bool signal_not_already_used =
true;
347 if (ch.assigned_signal && (ch.assigned_signal == match))
348 signal_not_already_used =
false;
350 if (match && signal_not_already_used) {
351 ch.assigned_signal = match;
352 new_assignment =
true;
356 if (new_assignment) {
373 if (ch.id == channel_id) {
374 ch.assigned_signal = signal;
396 for (
const shared_ptr<decode::Decoder>& dec :
stack_) {
399 if (dec->has_logic_output()) {
400 const vector<decode::DecoderLogicOutputChannel> logic_channels =
401 dec->logic_output_channels();
407 bool ch_exists =
false;
409 if (signal->internal_name() == first_ch.
id)
413 shared_ptr<Logic>
logic_data = make_shared<Logic>(logic_channels.size());
418 shared_ptr<LogicSegment> logic_segment = make_shared<data::LogicSegment>(
420 logic_data->push_segment(logic_segment);
424 shared_ptr<data::SignalBase> signal =
426 signal->set_internal_name(logic_ch.id);
427 signal->set_index(index);
428 signal->set_data(logic_data);
429 output_signals_.push_back(signal);
436 for (shared_ptr<LogicSegment>& segment : logic_data->logic_segments())
443 s->set_name(s->internal_name() +
" (" +
name() +
")");
444 s->set_color(
color());
453 if (ch.id == channel_id)
454 ch.initial_pin_state = init_state;
490 bool no_signals_assigned =
true;
493 if (ch.assigned_signal) {
494 if (!ch.assigned_signal->logic_data())
497 no_signals_assigned =
false;
499 const shared_ptr<Logic>
logic_data = ch.assigned_signal->logic_data();
500 if (logic_data->logic_segments().empty())
503 if (segment_id >= logic_data->logic_segments().size())
506 const shared_ptr<const LogicSegment> segment = logic_data->logic_segments()[segment_id]->get_shared_ptr();
508 count =
min(count, (int64_t)segment->get_sample_count());
511 return (no_signals_assigned ? 0 : count);
515 bool include_processing)
const 524 if (include_processing)
525 result =
segments_[segment_id].samples_decoded_incl;
527 result =
segments_[segment_id].samples_decoded_excl;
536 for (
const shared_ptr<Decoder>& dec :
stack_) {
538 if (visible_only && !dec->visible())
541 for (
Row* row : dec->get_rows())
550 vector<const Row*> rows;
552 for (
const shared_ptr<Decoder>& dec :
stack_) {
554 if (visible_only && !dec->visible())
557 for (
const Row* row : dec->get_rows())
577 rd = &(row_it->second);
583 const Row* row, uint32_t segment_id, uint64_t start_sample,
584 uint64_t end_sample)
const 599 rd = &(row_it->second);
605 uint32_t segment_id, uint64_t start_sample, uint64_t end_sample)
const 612 const Decoder* dec, uint32_t bin_class_id)
const 627 const Decoder* dec, uint32_t bin_class_id, uint32_t chunk_id,
628 const vector<uint8_t> **dest, uint64_t *size)
637 if (dest) *dest = &(bc.
chunks.at(chunk_id).data);
638 if (size) *size = bc.
chunks.at(chunk_id).data.size();
644 const Decoder* dec, uint32_t bin_class_id, uint64_t start_sample,
645 uint64_t end_sample, vector<uint8_t> *dest)
const 647 assert(dest !=
nullptr);
661 uint64_t matches = 0;
663 if ((chunk.
sample >= start_sample) && (chunk.
sample < end_sample)) {
664 size += chunk.
data.size();
670 uint64_t matches2 = 0;
672 if ((chunk.
sample >= start_sample) && (chunk.
sample < end_sample)) {
673 memcpy(dest->data() + offset, chunk.
data.data(), chunk.
data.size());
674 offset += chunk.
data.size();
678 if (matches2 == matches)
684 const Decoder* dec, uint32_t bin_class_id, uint64_t start, uint64_t end,
685 vector<uint8_t> *dest)
const 687 assert(dest !=
nullptr);
704 size += chunk.
data.size();
705 offset += chunk.
data.size();
712 uint64_t dest_offset = 0;
714 if (offset >= start) {
715 memcpy(dest->data() + dest_offset, chunk.
data.data(), chunk.
data.size());
716 dest_offset += chunk.
data.size();
718 offset += chunk.
data.size();
725 const Decoder* dec, uint32_t bin_class_id)
const 740 uint32_t segment_id)
const 754 settings.setValue(
"decoders", (
int)(
stack_.size()));
758 for (
const shared_ptr<Decoder>& decoder :
stack_) {
759 settings.beginGroup(
"decoder" + QString::number(decoder_idx++));
761 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) 762 settings.setValue(
"id", (
const char *)decoder->get_srd_decoder()->id);
764 settings.setValue(
"id", decoder->get_srd_decoder()->id);
766 settings.setValue(
"visible", decoder->visible());
769 const map<string, GVariant*>&
options = decoder->options();
771 settings.setValue(
"options", (
int)options.size());
776 for (
auto&
option : options) {
777 settings.beginGroup(
"option" + QString::number(i));
778 settings.setValue(
"name", QString::fromStdString(
option.first));
786 for (
const Row* row : decoder->get_rows()) {
787 settings.beginGroup(
"row" + QString::number(i));
788 settings.setValue(
"visible", row->visible());
796 settings.beginGroup(
"ann_class" + QString::number(i));
797 settings.setValue(
"visible", ann_class->visible());
806 settings.setValue(
"channels", (
int)
channels_.size());
808 for (
unsigned int channel_id = 0; channel_id <
channels_.size(); channel_id++) {
813 qDebug() <<
"ERROR: Gap in channel index:" << channel_id;
817 settings.beginGroup(
"channel" + QString::number(channel_id));
819 settings.setValue(
"name",
channel->name);
820 settings.setValue(
"initial_pin_state",
channel->initial_pin_state);
823 settings.setValue(
"assigned_signal_name",
channel->assigned_signal->name());
836 GSList *dec_list = g_slist_copy((GSList*)srd_decoder_list());
838 int decoders = settings.value(
"decoders").toInt();
840 for (
int decoder_idx = 0; decoder_idx < decoders; decoder_idx++) {
841 settings.beginGroup(
"decoder" + QString::number(decoder_idx));
843 QString
id = settings.value(
"id").toString();
845 for (GSList *entry = dec_list; entry; entry = entry->next) {
846 const srd_decoder *dec = (srd_decoder*)entry->data;
850 if (QString::fromUtf8(dec->id) == id) {
851 shared_ptr<Decoder> decoder = make_shared<Decoder>(dec,
stack_.size());
856 stack_.push_back(decoder);
857 decoder->set_visible(settings.value(
"visible",
true).toBool());
860 int options = settings.value(
"options").toInt();
862 for (
int i = 0; i <
options; i++) {
863 settings.beginGroup(
"option" + QString::number(i));
864 QString
name = settings.value(
"name").toString();
866 decoder->set_option(name.toUtf8(),
value);
875 for (
Row* row : decoder->get_rows()) {
876 settings.beginGroup(
"row" + QString::number(i));
877 row->set_visible(settings.value(
"visible",
true).toBool());
885 settings.beginGroup(
"ann_class" + QString::number(i));
886 ann_class->set_visible(settings.value(
"visible",
true).toBool());
900 unsigned int channels = settings.value(
"channels").toInt();
902 const vector< shared_ptr<data::SignalBase> > signalbases =
905 for (
unsigned int channel_id = 0; channel_id < channels; channel_id++) {
910 qDebug() <<
"ERROR: Non-existant channel index:" << channel_id;
914 settings.beginGroup(
"channel" + QString::number(channel_id));
916 QString assigned_signal_name = settings.value(
"assigned_signal_name").toString();
918 for (
const shared_ptr<data::SignalBase>& signal : signalbases)
920 channel->assigned_signal = signal;
922 channel->initial_pin_state = settings.value(
"initial_pin_state").toInt();
942 bool all_complete =
true;
945 if (ch.assigned_signal) {
946 if (!ch.assigned_signal->logic_data())
949 const shared_ptr<Logic>
logic_data = ch.assigned_signal->logic_data();
950 if (logic_data->logic_segments().empty())
953 if (segment_id >= logic_data->logic_segments().size())
956 const shared_ptr<const LogicSegment> segment = logic_data->logic_segments()[segment_id]->get_shared_ptr();
957 if (segment && !segment->is_complete())
958 all_complete =
false;
967 bool no_signals_assigned =
true;
970 if (ch.assigned_signal) {
971 no_signals_assigned =
false;
973 const shared_ptr<Logic>
logic_data = ch.assigned_signal->logic_data();
974 if (!logic_data || logic_data->logic_segments().empty())
978 if ((uint64_t)(logic_data->logic_segments().size()) < count)
979 count = logic_data->logic_segments().size();
982 return (no_signals_assigned ? 0 : count);
987 double samplerate = 0;
990 if (ch.assigned_signal) {
991 const shared_ptr<Logic>
logic_data = ch.assigned_signal->logic_data();
992 if (!logic_data || logic_data->logic_segments().empty())
996 const shared_ptr<const LogicSegment> segment =
997 logic_data->logic_segments().at(segment_id)->get_shared_ptr();
999 samplerate = segment->samplerate();
1000 }
catch (out_of_range&) {
1011 for (shared_ptr<Decoder>& d :
stack_)
1012 if (d->get_srd_decoder() == srd_dec)
1020 vector<decode::DecodeChannel> prev_channels =
channels_;
1026 for (shared_ptr<Decoder>& decoder :
stack_) {
1027 const srd_decoder* srd_dec = decoder->get_srd_decoder();
1031 for (l = srd_dec->channels; l; l = l->next) {
1032 const struct srd_channel *
const pdch = (
struct srd_channel *)l->data;
1033 bool ch_added =
false;
1037 if (ch.pdch_ == pdch) {
1047 QString::fromUtf8(pdch->name), QString::fromUtf8(pdch->desc),
1048 SRD_INITIAL_PIN_SAME_AS_SAMPLE0, decoder, pdch};
1054 for (l = srd_dec->opt_channels; l; l = l->next) {
1055 const struct srd_channel *
const pdch = (
struct srd_channel *)l->data;
1056 bool ch_added =
false;
1060 if (ch.pdch_ == pdch) {
1070 QString::fromUtf8(pdch->name), QString::fromUtf8(pdch->desc),
1071 SRD_INITIAL_PIN_SAME_AS_SAMPLE0, decoder, pdch};
1078 if (prev_channels.size() !=
channels_.size()) {
1083 for (
size_t i = 0; i <
channels_.size(); i++) {
1102 for (shared_ptr<Decoder> dec :
stack_) {
1103 vector<decode::DecodeChannel*> channel_list;
1106 if (ch.decoder_ == dec)
1107 channel_list.push_back(&ch);
1109 dec->set_channels(channel_list);
1115 if (ch.assigned_signal)
1126 vector<shared_ptr<const LogicSegment> > segments;
1128 vector<uint8_t> signal_in_bytepos;
1129 vector<uint8_t> signal_in_bitpos;
1132 if (ch.assigned_signal) {
1133 const shared_ptr<Logic>
logic_data = ch.assigned_signal->logic_data();
1135 shared_ptr<const LogicSegment> segment;
1136 if (segment_id < logic_data->logic_segments().size()) {
1137 segment = logic_data->logic_segments().at(segment_id)->get_shared_ptr();
1139 qDebug() <<
"Muxer error for" <<
name() <<
":" << ch.assigned_signal->name() \
1140 <<
"has no logic segment" << segment_id;
1148 segments.push_back(segment);
1150 uint8_t*
data =
new uint8_t[(end - start) * segment->unit_size()];
1151 segment->get_samples(start, end, data);
1152 signal_data.push_back(data);
1154 const int bitpos = ch.assigned_signal->logic_bit_index();
1155 signal_in_bytepos.push_back(bitpos / 8);
1156 signal_in_bitpos.push_back(bitpos % 8);
1159 shared_ptr<LogicSegment> output_segment;
1162 }
catch (out_of_range&) {
1163 qDebug() <<
"Muxer error for" <<
name() <<
": no logic mux segment" \
1164 << segment_id <<
"in mux_logic_samples(), mux segments size is" \
1171 uint8_t* output =
new uint8_t[(end - start) * output_segment->unit_size()];
1172 unsigned int signal_count = signal_data.size();
1178 uint8_t bytepos = 0;
1180 const int out_sample_pos = sample_cnt * output_segment->unit_size();
1181 for (
unsigned int i = 0; i < output_segment->unit_size(); i++)
1182 output[out_sample_pos + i] = 0;
1184 for (
unsigned int i = 0; i < signal_count; i++) {
1185 const int in_sample_pos = sample_cnt * segments[i]->unit_size();
1186 const uint8_t in_sample = 1 &
1187 ((signal_data[i][in_sample_pos + signal_in_bytepos[i]]) >> (signal_in_bitpos[i]));
1189 const uint8_t out_sample = output[out_sample_pos + bytepos];
1191 output[out_sample_pos + bytepos] = out_sample | (in_sample << bitpos);
1201 output_segment->append_payload(output, (end - start) * output_segment->unit_size());
1204 for (
const uint8_t*
data : signal_data)
1210 uint32_t input_segment_count;
1213 if (input_segment_count == 0) {
1225 uint32_t segment_id = 0;
1228 shared_ptr<LogicSegment> output_segment =
1230 logic_mux_data_->push_segment(output_segment);
1237 uint64_t samples_to_process;
1241 const uint64_t output_sample_count = output_segment->get_sample_count();
1243 samples_to_process =
1244 (input_sample_count > output_sample_count) ?
1245 (input_sample_count - output_sample_count) : 0;
1247 if (samples_to_process > 0) {
1248 const uint64_t unit_size = output_segment->unit_size();
1251 uint64_t processed_samples = 0;
1253 const uint64_t start_sample = output_sample_count + processed_samples;
1254 const uint64_t sample_count =
1255 min(samples_to_process - processed_samples, chunk_sample_count);
1258 processed_samples += sample_count;
1271 if (!output_segment->is_complete())
1272 output_segment->set_complete();
1282 logic_mux_data_->push_segment(output_segment);
1300 const int64_t abs_start_samplenum,
const int64_t sample_count,
1301 const shared_ptr<const LogicSegment> input_segment)
1303 const int64_t unit_size = input_segment->unit_size();
1306 for (int64_t i = abs_start_samplenum;
1308 i += chunk_sample_count) {
1310 const int64_t chunk_end =
min(i + chunk_sample_count,
1311 abs_start_samplenum + sample_count);
1319 int64_t data_size = (chunk_end - i) * unit_size;
1320 uint8_t* chunk =
new uint8_t[data_size];
1321 input_segment->get_samples(i, chunk_end, chunk);
1323 if (srd_session_send(
srd_session_, i, chunk_end, chunk,
1324 data_size, unit_size) != SRD_OK) {
1364 shared_ptr<const LogicSegment> input_segment =
logic_mux_data_->logic_segments().front()->get_shared_ptr();
1375 uint64_t samples_to_process = 0;
1376 uint64_t abs_start_samplenum = 0;
1380 samples_to_process = input_segment->get_sample_count() - abs_start_samplenum;
1382 if (samples_to_process > 0) {
1383 decode_data(abs_start_samplenum, samples_to_process, input_segment);
1384 abs_start_samplenum += samples_to_process;
1392 if (input_segment->is_complete()) {
1393 #if defined HAVE_SRD_SESSION_SEND_EOF && HAVE_SRD_SESSION_SEND_EOF 1407 }
catch (out_of_range&) {
1408 qDebug() <<
"Decode error for" <<
name() <<
": no logic mux segment" \
1414 abs_start_samplenum = 0;
1458 uint64_t samplerate = 0;
1462 srd_session_metadata_set(
srd_session_, SRD_CONF_SAMPLERATE,
1463 g_variant_new_uint64(samplerate));
1464 for (
const shared_ptr<Decoder>& dec :
stack_)
1465 dec->apply_all_options();
1479 srd_decoder_inst *prev_di =
nullptr;
1480 for (
const shared_ptr<Decoder>& dec :
stack_) {
1481 srd_decoder_inst *
const di = dec->create_decoder_inst(
srd_session_);
1498 srd_session_metadata_set(
srd_session_, SRD_CONF_SAMPLERATE,
1501 srd_pd_output_callback_add(
srd_session_, SRD_OUTPUT_ANN,
1504 srd_pd_output_callback_add(
srd_session_, SRD_OUTPUT_BINARY,
1507 srd_pd_output_callback_add(
srd_session_, SRD_OUTPUT_LOGIC,
1524 #if defined HAVE_SRD_SESSION_SEND_EOF && HAVE_SRD_SESSION_SEND_EOF 1530 uint64_t samplerate = 0;
1534 srd_session_metadata_set(
srd_session_, SRD_CONF_SAMPLERATE,
1535 g_variant_new_uint64(samplerate));
1536 for (
const shared_ptr<Decoder>& dec :
stack_)
1537 dec->apply_all_options();
1549 for (
const shared_ptr<Decoder>& dec :
stack_)
1550 dec->invalidate_decoder_inst();
1558 if (!ch.assigned_signal)
1564 connect(signal, SIGNAL(
samples_added(uint64_t, uint64_t, uint64_t)),
1568 connect(signal->
logic_data().get(), SIGNAL(segment_completed()),
1577 if (!ch.assigned_signal)
1594 for (
const shared_ptr<Decoder>& dec :
stack_)
1595 for (
Row* row : dec->get_rows())
1599 for (
const shared_ptr<Decoder>& dec : stack_) {
1600 uint32_t n = dec->get_binary_class_count();
1602 for (uint32_t i = 0; i < n; i++)
1603 segments_.back().binary_classes.push_back(
1604 {dec.get(), dec->get_binary_class(i), deque<DecodeBinaryDataChunk>()});
1611 assert(decode_signal);
1626 assert(pdata->pdo->di);
1627 const srd_decoder *
const srd_dec = pdata->pdo->di->decoder;
1630 const srd_proto_data_annotation *
const pda = (
const srd_proto_data_annotation*)pdata->data;
1639 qWarning() <<
"Decoder" << ds->
display_name() <<
"wanted to add annotation" <<
1640 "with class ID" << pda->ann_class <<
"but there are only" <<
1645 const Row* row = ann_class->
row;
1658 deque<const Annotation*>& all_annotations =
1661 if (all_annotations.empty()) {
1662 all_annotations.emplace_back(ann);
1664 const uint64_t new_ann_len = (pdata->end_sample - pdata->start_sample);
1665 bool ann_has_earlier_start = (pdata->start_sample < all_annotations.back()->start_sample());
1666 bool ann_is_longer = (new_ann_len >
1667 (all_annotations.back()->end_sample() - all_annotations.back()->start_sample()));
1669 if (ann_has_earlier_start && ann_is_longer) {
1670 bool ann_has_same_start;
1671 auto it = all_annotations.end();
1675 ann_has_earlier_start = (pdata->start_sample < (*it)->start_sample());
1676 ann_has_same_start = (pdata->start_sample == (*it)->start_sample());
1677 ann_is_longer = (new_ann_len > (*it)->length());
1678 }
while ((ann_has_earlier_start || (ann_has_same_start && ann_is_longer)) && (it != all_annotations.begin()));
1681 if (it != all_annotations.begin())
1684 all_annotations.emplace(it, ann);
1686 all_annotations.emplace_back(ann);
1695 auto all_it = all_annotations.end();
1698 if ((*all_it)->row_data() == &row_data)
1700 }
while (&(*row_it) != ann);
1704 if ((*all_it)->row_data() == &row_data) {
1705 *all_it = &(*row_it);
1709 }
while (all_it != all_annotations.end());
1716 assert(decode_signal);
1726 assert(pdata->pdo->di);
1727 const srd_decoder *
const srd_dec = pdata->pdo->di->decoder;
1730 const srd_proto_data_binary *
const pdb = (
const srd_proto_data_binary*)pdata->data;
1743 qWarning() <<
"Could not find valid DecodeBinaryClass in segment" <<
1745 ", segment only knows" << segment->
binary_classes.size() <<
"classes";
1750 bin_class->
chunks.emplace_back();
1753 chunk->
sample = pdata->start_sample;
1754 chunk->
data.resize(pdb->size);
1755 memcpy(chunk->
data.data(), pdb->data, pdb->size);
1765 assert(decode_signal);
1776 assert(pdata->pdo->di);
1777 const srd_decoder *
const decc = pdata->pdo->di->decoder;
1780 const srd_proto_data_logic *
const pdl = (
const srd_proto_data_logic*)pdata->data;
1784 if (pdl->logic_group > 0) {
1785 qWarning() <<
"Received logic output state change for group" << pdl->logic_group <<
"from decoder" \
1786 << QString::fromUtf8(decc->name) <<
"but only group 0 is currently supported";
1790 shared_ptr<Logic> output_logic = ds->
output_logic_.at(decc);
1792 vector< shared_ptr<Segment> > segments = output_logic->segments();
1794 shared_ptr<LogicSegment> last_segment;
1796 if (!segments.empty())
1797 last_segment = dynamic_pointer_cast<LogicSegment>(segments.back());
1801 last_segment = make_shared<data::LogicSegment>(
1802 *output_logic, 0, (output_logic->num_channels() + 7) / 8, output_logic->get_samplerate());
1803 output_logic->push_segment(last_segment);
1806 if (pdata->start_sample < pdata->end_sample) {
1807 vector<uint8_t>
data;
1808 const unsigned int unit_size = last_segment->unit_size();
1809 data.resize(unit_size * (1 + pdl->repeat_count));
1812 for (
unsigned int i = 0; i <= pdl->repeat_count; i++)
1813 data.data()[i * unit_size] = *((uint8_t*)pdl->data);
1814 else if (unit_size == 2)
1815 for (
unsigned int i = 0; i <= pdl->repeat_count; i++)
1816 data.data()[i * unit_size] = *((uint16_t*)pdl->data);
1817 else if (unit_size <= 4)
1818 for (
unsigned int i = 0; i <= pdl->repeat_count; i++)
1819 data.data()[i * unit_size] = *((uint32_t*)pdl->data);
1820 else if (unit_size <= 8)
1821 for (
unsigned int i = 0; i <= pdl->repeat_count; i++)
1822 data.data()[i * unit_size] = *((uint64_t*)pdl->data);
1824 for (
unsigned int i = 0; i <= pdl->repeat_count; i++)
1825 memcpy((
void*)&data.data()[i * unit_size], (
void*)pdl->data, unit_size);
1827 last_segment->append_payload(data.data(), data.size());
1829 qWarning() <<
"Ignoring malformed logic output state change for group" << pdl->logic_group <<
"from decoder" \
1830 << QString::fromUtf8(decc->name) <<
"from" << pdata->start_sample <<
"to" << pdata->end_sample;
1858 qDebug().nospace() <<
name() <<
": Input data available, error cleared";
manual pdf if(NOT EXISTS"${CMAKE_CURRENT_BINARY_DIR}/images") message(STATUS"creating symlink for manual's images/ subdirectory") execute_process(COMMAND $
static void store_gvariant(QSettings &settings, GVariant *v)
atomic< bool > decode_interrupt_
map< const srd_decoder *, shared_ptr< Logic > > output_logic_
const vector< shared_ptr< Decoder > > & decoder_stack() const
void on_annotation_visibility_changed()
vector< decode::DecodeChannel > channels_
shared_ptr< pv::data::SignalData > data() const
deque< const Annotation * > all_annotations
const vector< shared_ptr< data::SignalBase > > signalbases() const
Decoder * get_decoder_by_instance(const srd_decoder *const srd_dec)
AnnotationClass * get_ann_class_by_id(size_t id)
int64_t get_working_sample_count(uint32_t segment_id) const
deque< DecodeSegment > segments_
int64_t get_decoded_sample_count(uint32_t segment_id, bool include_processing) const
vector< shared_ptr< Decoder > > stack_
const srd_decoder * get_srd_decoder() const
const srd_channel * pdch_
mutex decode_pause_mutex_
CMake option(DISABLE_WERROR"Build without -Werror"TRUE) option(ENABLE_SIGNALS"Build with UNIX signals"TRUE) option(ENABLE_STACKTRACE"Enable stack trace when crashing"FALSE) option(ENABLE_DECODE"Build with libsigrokdecode"TRUE) option(ENABLE_FLOW"Build with libsigrokflow"FALSE) option(ENABLE_TESTS"Enable unit tests"FALSE) option(STATIC_PKGDEPS_LIBS"Statically link to (pkg-config) libraries"FALSE) option(ENABLE_TS_UPDATE"Update .ts source files (Qt l10n)"FALSE) if(WIN32) set(STATIC_PKGDEPS_LIBS TRUE) set(ENABLE_SIGNALS FALSE) endif() if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING"Choose the type of build (None
void assign_signal(const uint16_t channel_id, shared_ptr< const SignalBase > signal)
void decoder_stacked(void *decoder)
decoder is of type decode::Decoder*
uint32_t logic_mux_unit_size_
virtual void set_name(QString name)
deque< DecodeBinaryDataChunk > chunks
T value(details::expression_node< T > *n)
vector< DecodeBinaryClass > binary_classes
static const double DecodeMargin
shared_ptr< sigrok::Channel > channel() const
void annotation_visibility_changed()
static void binary_callback(srd_proto_data *pdata, void *decode_signal)
condition_variable decode_pause_cond_
void get_merged_binary_data_chunks_by_sample(uint32_t segment_id, const Decoder *dec, uint32_t bin_class_id, uint64_t start_sample, uint64_t end_sample, vector< uint8_t > *dest) const
static const int64_t DecodeChunkLength
const DecodeBinaryClass * get_binary_data_class(uint32_t segment_id, const Decoder *dec, uint32_t bin_class_id) const
std::thread logic_mux_thread_
virtual void save_settings(QSettings &settings) const
void mux_logic_samples(uint32_t segment_id, const int64_t start, const int64_t end)
Mac OS X or Android For some we provide binary for others we provide installers and for others we provide AppImage containers that you can run without the need to install anything Check the the usual way to install PulseView is to install the packages provided by your distro s package manager sometimes only outdated packages are made available to you In that you have two options
const deque< const Annotation * > * get_all_annotations_by_segment(uint32_t segment_id) const
uint32_t current_segment_id_
void add_generated_signal(shared_ptr< data::SignalBase > signal)
map< const Row *, RowData > annotation_rows
virtual void save_settings(QSettings &settings) const
T max(const T v0, const T v1)
void stack_decoder(const srd_decoder *decoder, bool restart_decode=true)
virtual double get_samplerate() const
void on_input_segment_completed()
bool all_input_segments_complete(uint32_t segment_id) const
virtual void set_error_message(QString msg)
static const double DecodeThreshold
void disconnect_input_notifiers()
uint64_t get_annotation_count() const
virtual void set_name(QString name)
map< const srd_decoder *, vector< uint8_t > > output_logic_muxed_data_
void get_annotation_subset(deque< const pv::data::decode::Annotation * > &dest, uint64_t start_sample, uint64_t end_sample) const
const pv::util::Timestamp start_time() const
void auto_assign_signals(const shared_ptr< Decoder > dec)
QString display_name() const
void commit_decoder_channels()
vector< Row * > get_rows(bool visible_only=false)
void update_channel_list()
uint32_t get_input_segment_count() const
void set_initial_pin_state(const uint16_t channel_id, const int init_state)
T min(const T v0, const T v1)
virtual void restore_settings(QSettings &settings)
const vector< decode::DecodeChannel > get_channels() const
Row * get_row_by_id(size_t id)
const Annotation * emplace_annotation(srd_proto_data *pdata)
std::thread decode_thread_
int get_assigned_signal_count() const
uint64_t get_annotation_count(const Row *row, uint32_t segment_id) const
void terminate_srd_session()
bool logic_mux_data_invalid_
void decoder_removed(void *decoder)
decoder is of type decode::Decoder*
DecodeSignal(pv::Session &session)
void connect_input_notifiers()
void get_annotation_subset(deque< const Annotation * > &dest, const Row *row, uint32_t segment_id, uint64_t start_sample, uint64_t end_sample) const
virtual void set_color(QColor color)
double get_input_samplerate(uint32_t segment_id) const
virtual void restore_settings(QSettings &settings)
Protocol Decoder channel using libsigrokdecode.
static void logic_output_callback(srd_proto_data *pdata, void *decode_signal)
atomic< bool > logic_mux_interrupt_
bool toggle_decoder_visibility(int index)
shared_ptr< Logic > logic_mux_data_
static GVariant * restore_gvariant(QSettings &settings)
boost::multiprecision::number< boost::multiprecision::cpp_dec_float< 24 >, boost::multiprecision::et_off > Timestamp
Timestamp type providing yoctosecond resolution.
shared_ptr< pv::data::Logic > logic_data() const
condition_variable logic_mux_cond_
struct srd_session * srd_session_
virtual void set_color(QColor color)
void update_output_signals()
uint32_t get_binary_data_chunk_count(uint32_t segment_id, const Decoder *dec, uint32_t bin_class_id) const
static void annotation_callback(srd_proto_data *pdata, void *decode_signal)
void get_merged_binary_data_chunks_by_offset(uint32_t segment_id, const Decoder *dec, uint32_t bin_class_id, uint64_t start, uint64_t end, vector< uint8_t > *dest) const
void remove_decoder(int index)
condition_variable decode_input_cond_
const deque< Annotation > & annotations() const
void create_decode_segment()
shared_ptr< const pv::data::SignalBase > assigned_signal
const DecodeBinaryClassInfo * info
void reset_decode(bool shutting_down=false)
unsigned int index() const
uint64_t sample
Number of the sample where this data was provided by the PD.
void on_capture_state_changed(int state)
bool stack_config_changed_
vector< const AnnotationClass * > ann_classes() const
void decode_data(const int64_t abs_start_samplenum, const int64_t sample_count, const shared_ptr< const LogicSegment > input_segment)
void new_binary_data(unsigned int segment_id, void *decoder, unsigned int bin_class_id)
void samples_added(uint64_t segment_id, uint64_t start_sample, uint64_t end_sample)
void get_binary_data_chunk(uint32_t segment_id, const Decoder *dec, uint32_t bin_class_id, uint32_t chunk_id, const vector< uint8_t > **dest, uint64_t *size)
vector< shared_ptr< SignalBase > > output_signals_