canbana: complete basic functions (#25965)

* add chart header

* get all signal val from logs

* loop in selected range

* clear list before append

* automatically zoom on yaxis

* cleanup

* sync charts

* fix event_begin_sec

* set the color of rubber

* add TODO

* sync slider with charts

* keep video aspect ratio

* sync plot buttons

* reduce flickers

* cleanup

* refactor detail view

* clear counters

* more

use qcamera
old-commit-hash: a6ba073231
taco
Dean Lee 3 years ago committed by GitHub
parent 73f0c74b9b
commit f93f4e9f9b
  1. 3
      tools/cabana/SConscript
  2. 6
      tools/cabana/cabana.cc
  3. 206
      tools/cabana/chartswidget.cc
  4. 52
      tools/cabana/chartswidget.h
  5. 421
      tools/cabana/detailwidget.cc
  6. 86
      tools/cabana/detailwidget.h
  7. 9
      tools/cabana/mainwin.cc
  8. 4
      tools/cabana/mainwin.h
  9. 35
      tools/cabana/messageswidget.cc
  10. 2
      tools/cabana/messageswidget.h
  11. 114
      tools/cabana/parser.cc
  12. 58
      tools/cabana/parser.h
  13. 203
      tools/cabana/signaledit.cc
  14. 50
      tools/cabana/signaledit.h
  15. 49
      tools/cabana/videowidget.cc
  16. 5
      tools/cabana/videowidget.h
  17. 18
      tools/replay/logreader.cc
  18. 7
      tools/replay/logreader.h
  19. 21
      tools/replay/replay.cc
  20. 9
      tools/replay/replay.h
  21. 6
      tools/replay/route.cc
  22. 3
      tools/replay/route.h

@ -16,6 +16,5 @@ if arch in ['x86_64', 'Darwin'] and GetOption('extras'):
qt_env['CXXFLAGS'] += ["-Wno-deprecated-declarations"]
Import('replay_lib')
# qt_env["LD_LIBRARY_PATH"] = [Dir(f"#opendbc/can").abspath]
cabana_libs = [widgets, cereal, messaging, visionipc, replay_lib, opendbc,'avutil', 'avcodec', 'avformat', 'bz2', 'curl', 'yuv'] + qt_libs
qt_env.Program('_cabana', ['cabana.cc', 'mainwin.cc', 'chartswidget.cc', 'videowidget.cc', 'parser.cc', 'messageswidget.cc', 'detailwidget.cc'], LIBS=cabana_libs, FRAMEWORKS=base_frameworks)
qt_env.Program('_cabana', ['cabana.cc', 'mainwin.cc', 'chartswidget.cc', 'videowidget.cc', 'signaledit.cc', 'parser.cc', 'messageswidget.cc', 'detailwidget.cc'], LIBS=cabana_libs, FRAMEWORKS=base_frameworks)

@ -5,7 +5,6 @@
#include "tools/cabana/mainwin.h"
const QString DEMO_ROUTE = "4cf7a6ad03080c90|2021-09-29--13-46-36";
Parser *parser = nullptr;
int main(int argc, char *argv[]) {
initApp(argc, argv);
@ -16,7 +15,6 @@ int main(int argc, char *argv[]) {
cmd_parser.addPositionalArgument("route", "the drive to replay. find your drives at connect.comma.ai");
cmd_parser.addOption({"demo", "use a demo route instead of providing your own"});
cmd_parser.addOption({"data_dir", "local directory with routes", "data_dir"});
cmd_parser.addOption({"qcam", "use qcamera"});
cmd_parser.process(app);
const QStringList args = cmd_parser.positionalArguments();
if (args.empty() && !cmd_parser.isSet("demo")) {
@ -24,8 +22,8 @@ int main(int argc, char *argv[]) {
}
const QString route = args.empty() ? DEMO_ROUTE : args.first();
parser = new Parser(&app);
if (!parser->loadRoute(route, cmd_parser.value("data_dir"), cmd_parser.isSet("qcam"))) {
Parser p(&app);
if (!p.loadRoute(route, cmd_parser.value("data_dir"), true)) {
return 0;
}
MainWindow w;

@ -1,20 +1,24 @@
#include "tools/cabana/chartswidget.h"
#include <QGraphicsLayout>
#include <QLabel>
#include <QPushButton>
#include <QRubberBand>
#include <QStackedLayout>
#include <QtCharts/QLineSeries>
#include <QtCharts/QValueAxis>
using namespace QtCharts;
int64_t get_raw_value(const QByteArray &msg, const Signal &sig) {
int64_t get_raw_value(uint8_t *data, size_t data_size, const Signal &sig) {
int64_t ret = 0;
int i = sig.msb / 8;
int bits = sig.size;
while (i >= 0 && i < msg.size() && bits > 0) {
while (i >= 0 && i < data_size && bits > 0) {
int lsb = (int)(sig.lsb / 8) == i ? sig.lsb : i * 8;
int msb = (int)(sig.msb / 8) == i ? sig.msb : (i + 1) * 8 - 1;
int size = msb - lsb + 1;
uint64_t d = (msg[i] >> (lsb - (i * 8))) & ((1ULL << size) - 1);
uint64_t d = (data[i] >> (lsb - (i * 8))) & ((1ULL << size) - 1);
ret |= d << (bits - size);
bits -= size;
@ -26,77 +30,163 @@ int64_t get_raw_value(const QByteArray &msg, const Signal &sig) {
ChartsWidget::ChartsWidget(QWidget *parent) : QWidget(parent) {
main_layout = new QVBoxLayout(this);
main_layout->setContentsMargins(0, 0, 0, 0);
connect(parser, &Parser::updated, this, &ChartsWidget::updateState);
connect(parser, &Parser::showPlot, this, &ChartsWidget::addChart);
connect(parser, &Parser::hidePlot, this, &ChartsWidget::removeChart);
connect(parser, &Parser::signalRemoved, this, &ChartsWidget::removeChart);
}
void ChartsWidget::addChart(const QString &id, const QString &sig_name) {
const QString char_name = id + sig_name;
if (charts.find(char_name) == charts.end()) {
QLineSeries *series = new QLineSeries();
series->setUseOpenGL(true);
auto chart = new QChart();
chart->setTitle(id + ": " + sig_name);
chart->addSeries(series);
chart->createDefaultAxes();
chart->legend()->hide();
auto chart_view = new QChartView(chart);
chart_view->setMinimumSize({width(), 300});
chart_view->setMaximumSize({width(), 300});
chart_view->setRenderHint(QPainter::Antialiasing);
main_layout->addWidget(chart_view);
charts[char_name] = {.id = id, .sig_name = sig_name, .chart_view = chart_view};
auto chart = new ChartWidget(id, sig_name, this);
main_layout->addWidget(chart);
charts[char_name] = chart;
}
}
void ChartsWidget::removeChart(const QString &id, const QString &sig_name) {
auto it = charts.find(id + sig_name);
if (it == charts.end()) return;
delete it->second.chart_view;
charts.erase(it);
if (auto it = charts.find(id + sig_name); it != charts.end()) {
it->second->deleteLater();
charts.erase(it);
}
}
void ChartsWidget::updateState() {
static double last_update = millis_since_boot();
double current_ts = millis_since_boot();
bool update = (current_ts - last_update) > 500;
if (update) {
last_update = current_ts;
ChartWidget::ChartWidget(const QString &id, const QString &sig_name, QWidget *parent) : id(id), sig_name(sig_name), QWidget(parent) {
QStackedLayout *stacked = new QStackedLayout(this);
stacked->setStackingMode(QStackedLayout::StackAll);
QWidget *chart_widget = new QWidget(this);
QVBoxLayout *chart_layout = new QVBoxLayout(chart_widget);
chart_layout->setSpacing(0);
chart_layout->setContentsMargins(0, 0, 0, 0);
QWidget *header = new QWidget(this);
header->setStyleSheet("background-color:white");
QHBoxLayout *header_layout = new QHBoxLayout(header);
header_layout->setContentsMargins(11, 11, 11, 0);
auto title = new QLabel(tr("%1 %2").arg(parser->getMsg(id)->name.c_str()).arg(id));
header_layout->addWidget(title);
header_layout->addStretch();
zoom_label = new QLabel("", this);
header_layout->addWidget(zoom_label);
QPushButton *zoom_in = new QPushButton("", this);
zoom_in->setToolTip(tr("reset zoom"));
QObject::connect(zoom_in, &QPushButton::clicked, []() { parser->resetRange(); });
header_layout->addWidget(zoom_in);
QPushButton *remove_btn = new QPushButton("", this);
QObject::connect(remove_btn, &QPushButton::clicked, [=]() {
emit parser->hidePlot(id, sig_name);
});
header_layout->addWidget(remove_btn);
chart_layout->addWidget(header);
QLineSeries *series = new QLineSeries();
series->setUseOpenGL(true);
auto chart = new QChart();
chart->setTitle(sig_name);
chart->addSeries(series);
chart->createDefaultAxes();
chart->legend()->hide();
QFont font;
font.setBold(true);
chart->setTitleFont(font);
chart->setMargins({0, 0, 0, 0});
chart->layout()->setContentsMargins(0, 0, 0, 0);
QObject::connect(dynamic_cast<QValueAxis *>(chart->axisX()), &QValueAxis::rangeChanged, parser, &Parser::setRange);
chart_view = new QChartView(chart);
chart_view->setFixedHeight(300);
chart_view->setRenderHint(QPainter::Antialiasing);
chart_view->setRubberBand(QChartView::HorizontalRubberBand);
if (auto rubber = chart_view->findChild<QRubberBand *>()) {
QPalette pal;
pal.setBrush(QPalette::Base, QColor(0, 0, 0, 80));
rubber->setPalette(pal);
}
chart_layout->addWidget(chart_view);
chart_layout->addStretch();
auto getSig = [=](const QString &id, const QString &name) -> const Signal * {
for (auto &sig : parser->getMsg(id)->sigs) {
if (name == sig.name.c_str()) return &sig;
}
return nullptr;
};
for (auto &[_, c] : charts) {
if (auto sig = getSig(c.id, c.sig_name)) {
const auto &can_data = parser->can_msgs[c.id].back();
int64_t val = get_raw_value(can_data.dat, *sig);
if (sig->is_signed) {
val -= ((val >> (sig->size - 1)) & 0x1) ? (1ULL << sig->size) : 0;
}
double value = val * sig->factor + sig->offset;
stacked->addWidget(chart_widget);
line_marker = new LineMarker(chart, this);
stacked->addWidget(line_marker);
line_marker->setAttribute(Qt::WA_TransparentForMouseEvents, true);
line_marker->raise();
if (value > c.max_y) c.max_y = value;
if (value < c.min_y) c.min_y = value;
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
QObject::connect(parser, &Parser::updated, this, &ChartWidget::updateState);
QObject::connect(parser, &Parser::rangeChanged, this, &ChartWidget::rangeChanged);
QObject::connect(parser, &Parser::eventsMerged, this, &ChartWidget::updateSeries);
while (c.data.size() > DATA_LIST_SIZE) {
c.data.pop_front();
}
c.data.push_back({can_data.ts / 1000., value});
if (update) {
QChart *chart = c.chart_view->chart();
QLineSeries *series = (QLineSeries *)chart->series()[0];
series->replace(c.data);
chart->axisX()->setRange(c.data.front().x(), c.data.back().x());
chart->axisY()->setRange(c.min_y, c.max_y);
updateSeries();
}
void ChartWidget::updateState() {
line_marker->update();
}
void ChartWidget::updateSeries() {
const Signal *sig = parser->getSig(id, sig_name);
auto events = parser->replay->events();
if (!sig || !events) return;
auto l = id.split(':');
int bus = l[0].toInt();
uint32_t address = l[1].toUInt(nullptr, 16);
vals.clear();
vals.reserve(3 * 60 * 100);
uint64_t route_start_time = parser->replay->routeStartTime();
for (auto &evt : *events) {
if (evt->which == cereal::Event::Which::CAN) {
for (auto c : evt->event.getCan()) {
if (bus == c.getSrc() && address == c.getAddress()) {
auto dat = c.getDat();
int64_t val = get_raw_value((uint8_t *)dat.begin(), dat.size(), *sig);
if (sig->is_signed) {
val -= ((val >> (sig->size - 1)) & 0x1) ? (1ULL << sig->size) : 0;
}
double value = val * sig->factor + sig->offset;
double ts = (evt->mono_time - route_start_time) / (double)1e9; // seconds
vals.push_back({ts, value});
}
}
}
}
QLineSeries *series = (QLineSeries *)chart_view->chart()->series()[0];
series->replace(vals);
auto [begin, end] = parser->range();
chart_view->chart()->axisX()->setRange(begin, end);
}
void ChartWidget::rangeChanged(qreal min, qreal max) {
auto axis_x = dynamic_cast<QValueAxis *>(chart_view->chart()->axisX());
if (axis_x->min() != min || axis_x->max() != max) {
axis_x->setRange(min, max);
}
// auto zoom on yaxis
double min_y = 0, max_y = 0;
for (auto &p : vals) {
if (p.x() > max) break;
if (p.x() >= min) {
if (p.y() < min_y) min_y = p.y();
if (p.y() > max_y) max_y = p.y();
}
}
chart_view->chart()->axisY()->setRange(min_y * 0.95, max_y * 1.05);
}
LineMarker::LineMarker(QChart *chart, QWidget *parent) : chart(chart), QWidget(parent) {}
void LineMarker::paintEvent(QPaintEvent *event) {
auto axis_x = dynamic_cast<QValueAxis *>(chart->axisX());
if (axis_x->max() <= axis_x->min()) return;
double x = chart->plotArea().left() + chart->plotArea().width() * (parser->currentSec() - axis_x->min()) / (axis_x->max() - axis_x->min());
QPainter p(this);
QPen pen = QPen(Qt::black);
pen.setWidth(2);
p.setPen(pen);
p.drawLine(QPointF{x, 50.}, QPointF{x, (qreal)height() - 11});
}

@ -1,17 +1,53 @@
#pragma once
#include <map>
#include <QLabel>
#include <QVBoxLayout>
#include <QWidget>
#include <QtCharts/QChartView>
#include <QtCharts/QLineSeries>
#include <map>
#include "tools/cabana/parser.h"
using namespace QtCharts;
class LineMarker : public QWidget {
Q_OBJECT
public:
LineMarker(QChart *chart, QWidget *parent);
void paintEvent(QPaintEvent *event) override;
private:
QChart *chart;
};
class ChartWidget : public QWidget {
Q_OBJECT
public:
ChartWidget(const QString &id, const QString &sig_name, QWidget *parent);
inline QChart *chart() const { return chart_view->chart(); }
protected:
void updateState();
void addData(const CanData &can_data, const Signal &sig);
void updateSeries();
void rangeChanged(qreal min, qreal max);
QString id;
QString sig_name;
QLabel *zoom_label;
QChartView *chart_view = nullptr;
LineMarker *line_marker = nullptr;
QList<QPointF> vals;
};
class ChartsWidget : public QWidget {
Q_OBJECT
public:
public:
ChartsWidget(QWidget *parent = nullptr);
inline bool hasChart(const QString &id, const QString &sig_name) {
return charts.find(id+sig_name) != charts.end();
@ -20,15 +56,7 @@ class ChartsWidget : public QWidget {
void removeChart(const QString &id, const QString &sig_name);
void updateState();
protected:
protected:
QVBoxLayout *main_layout;
struct SignalChart {
QString id;
QString sig_name;
int max_y = 0;
int min_y = 0;
QList<QPointF> data;
QtCharts::QChartView *chart_view = nullptr;
};
std::map<QString, SignalChart> charts;
std::map<QString, ChartWidget *> charts;
};

@ -1,68 +1,53 @@
#include "tools/cabana/detailwidget.h"
#include <QDebug>
#include <QDialogButtonBox>
#include <QHeaderView>
#include <QMessageBox>
#include <QTimer>
#include <QVBoxLayout>
#include <bitset>
#include "selfdrive/ui/qt/util.h"
#include "selfdrive/ui/qt/widgets/scrollview.h"
const QString SIGNAL_COLORS[] = {"#9FE2BF", "#40E0D0", "#6495ED", "#CCCCFF", "#FF7F50", "#FFBF00"};
static QVector<int> BIG_ENDIAN_START_BITS = []() {
QVector<int> ret;
for (int i = 0; i < 64; i++) {
for (int j = 7; j >= 0; j--) {
ret.push_back(j + i * 8);
}
}
return ret;
}();
static int bigEndianBitIndex(int index) {
// TODO: Add a helper function in dbc.h
return BIG_ENDIAN_START_BITS.indexOf(index);
inline const QString &getColor(int i) {
static const QString SIGNAL_COLORS[] = {"#9FE2BF", "#40E0D0", "#6495ED", "#CCCCFF", "#FF7F50", "#FFBF00"};
return SIGNAL_COLORS[i % std::size(SIGNAL_COLORS)];
}
// DetailWidget
DetailWidget::DetailWidget(QWidget *parent) : QWidget(parent) {
QVBoxLayout *main_layout = new QVBoxLayout(this);
QLabel *title = new QLabel(tr("SELECTED MESSAGE:"), this);
main_layout->addWidget(title);
QHBoxLayout *name_layout = new QHBoxLayout();
name_label = new QLabel(this);
name_label->setStyleSheet("font-weight:bold;");
name_layout->addWidget(name_label);
name_layout->addStretch();
name_label->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
name_label->setAlignment(Qt::AlignCenter);
main_layout->addWidget(name_label);
// title
QHBoxLayout *title_layout = new QHBoxLayout();
time_label = new QLabel(this);
title_layout->addWidget(time_label);
title_layout->addStretch();
edit_btn = new QPushButton(tr("Edit"), this);
edit_btn->setVisible(false);
QObject::connect(edit_btn, &QPushButton::clicked, [=]() {
EditMessageDialog dlg(msg_id, this);
int ret = dlg.exec();
if (ret) {
setMsg(msg_id);
}
});
name_layout->addWidget(edit_btn);
main_layout->addLayout(name_layout);
title_layout->addWidget(edit_btn);
main_layout->addLayout(title_layout);
// binary view
binary_view = new BinaryView(this);
main_layout->addWidget(binary_view);
// scroll area
QHBoxLayout *signals_layout = new QHBoxLayout();
signals_layout->addWidget(new QLabel(tr("Signals")));
signals_layout->addStretch();
add_sig_btn = new QPushButton(tr("Add signal"), this);
add_sig_btn->setVisible(false);
QObject::connect(add_sig_btn, &QPushButton::clicked, [=]() {
AddSignalDialog dlg(msg_id, this);
int ret = dlg.exec();
if (ret) {
setMsg(msg_id);
}
});
signals_layout->addWidget(add_sig_btn);
main_layout->addLayout(signals_layout);
@ -72,238 +57,67 @@ DetailWidget::DetailWidget(QWidget *parent) : QWidget(parent) {
signal_edit_layout->setSpacing(2);
container_layout->addLayout(signal_edit_layout);
messages_view = new MessagesView(this);
container_layout->addWidget(messages_view);
history_log = new HistoryLog(this);
container_layout->addWidget(history_log);
QScrollArea *scroll = new QScrollArea(this);
scroll->setWidget(container);
scroll->setWidgetResizable(true);
scroll->setFrameShape(QFrame::NoFrame);
scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
scroll->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
main_layout->addWidget(scroll);
setFixedWidth(600);
connect(parser, &Parser::updated, this, &DetailWidget::updateState);
QObject::connect(add_sig_btn, &QPushButton::clicked, this, &DetailWidget::addSignal);
QObject::connect(edit_btn, &QPushButton::clicked, this, &DetailWidget::editMsg);
QObject::connect(parser, &Parser::updated, this, &DetailWidget::updateState);
}
void DetailWidget::updateState() {
if (msg_id.isEmpty()) return;
auto &list = parser->can_msgs[msg_id];
if (!list.empty()) {
binary_view->setData(list.back().dat);
messages_view->setMessages(list);
}
}
SignalForm::SignalForm(const Signal &sig, QWidget *parent) : QWidget(parent) {
QVBoxLayout *v_layout = new QVBoxLayout(this);
QHBoxLayout *h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Name")));
name = new QLineEdit(sig.name.c_str());
h->addWidget(name);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Size")));
size = new QSpinBox();
size->setValue(sig.size);
h->addWidget(size);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Most significant bit")));
msb = new QSpinBox();
msb->setValue(sig.msb);
h->addWidget(msb);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Endianness")));
endianness = new QComboBox();
endianness->addItems({"Little", "Big"});
endianness->setCurrentIndex(sig.is_little_endian ? 0 : 1);
h->addWidget(endianness);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("sign")));
sign = new QComboBox();
sign->addItems({"Signed", "Unsigned"});
sign->setCurrentIndex(sig.is_signed ? 0 : 1);
h->addWidget(sign);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Factor")));
factor = new QSpinBox();
factor->setValue(sig.factor);
h->addWidget(factor);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Offset")));
offset = new QSpinBox();
offset->setValue(sig.offset);
h->addWidget(offset);
v_layout->addLayout(h);
// TODO: parse the following parameters in opendbc
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Unit")));
unit = new QLineEdit();
h->addWidget(unit);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Comment")));
comment = new QLineEdit();
h->addWidget(comment);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Minimum value")));
min_val = new QSpinBox();
h->addWidget(min_val);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Maximum value")));
max_val = new QSpinBox();
h->addWidget(max_val);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Value descriptions")));
val_desc = new QLineEdit();
h->addWidget(val_desc);
v_layout->addLayout(h);
}
std::optional<Signal> SignalForm::getSignal() {
Signal sig = {};
sig.name = name->text().toStdString();
sig.size = size->text().toInt();
sig.offset = offset->text().toDouble();
sig.factor = factor->text().toDouble();
sig.msb = msb->text().toInt();
sig.is_signed = sign->currentIndex() == 0;
sig.is_little_endian = endianness->currentIndex() == 0;
if (sig.is_little_endian) {
sig.lsb = sig.start_bit;
sig.msb = sig.start_bit + sig.size - 1;
} else {
sig.lsb = BIG_ENDIAN_START_BITS[bigEndianBitIndex(sig.start_bit) + sig.size - 1];
sig.msb = sig.start_bit;
}
return (sig.name.empty() || sig.size <= 0) ? std::nullopt : std::optional(sig);
}
void DetailWidget::setMsg(const QString &id) {
msg_id = id;
QString name = tr("untitled");
void DetailWidget::setMsg(const CanData *c) {
can_data = c;
clearLayout(signal_edit_layout);
edit_btn->setVisible(true);
for (auto edit : signal_edit) {
delete edit;
}
signal_edit.clear();
int i = 0;
auto msg = parser->getMsg(id);
if (msg) {
for (auto &s : msg->sigs) {
SignalEdit *edit = new SignalEdit(id, s, i++, this);
connect(edit, &SignalEdit::removed, [=]() {
QTimer::singleShot(0, [=]() { setMsg(id); });
});
signal_edit_layout->addWidget(edit);
signal_edit.push_back(edit);
if (auto msg = parser->getMsg(can_data->address)) {
name_label->setText(msg->name.c_str());
add_sig_btn->setVisible(true);
for (int i = 0; i < msg->sigs.size(); ++i) {
signal_edit_layout->addWidget(new SignalEdit(can_data->id, msg->sigs[i], getColor(i)));
}
name = msg->name.c_str();
} else {
name_label->setText(tr("untitled"));
add_sig_btn->setVisible(false);
}
name_label->setText(name);
binary_view->setMsg(msg_id);
edit_btn->setVisible(true);
add_sig_btn->setVisible(msg != nullptr);
binary_view->setMsg(can_data);
history_log->clear();
}
SignalEdit::SignalEdit(const QString &id, const Signal &sig, int idx, QWidget *parent) : id(id), name_(sig.name.c_str()), QWidget(parent) {
QVBoxLayout *main_layout = new QVBoxLayout(this);
main_layout->setContentsMargins(0, 0, 0, 0);
// title
QHBoxLayout *title_layout = new QHBoxLayout();
QLabel *icon = new QLabel(">");
icon->setStyleSheet("font-weight:bold");
title_layout->addWidget(icon);
title = new ElidedLabel(this);
title->setText(sig.name.c_str());
title->setStyleSheet(QString("font-weight:bold; color:%1").arg(SIGNAL_COLORS[idx % std::size(SIGNAL_COLORS)]));
connect(title, &ElidedLabel::clicked, [=]() {
edit_container->isVisible() ? edit_container->hide() : edit_container->show();
icon->setText(edit_container->isVisible() ? "" : ">");
});
title_layout->addWidget(title);
title_layout->addStretch();
QPushButton *show_plot = new QPushButton(tr("Show Plot"));
QObject::connect(show_plot, &QPushButton::clicked, [=]() {
if (show_plot->text() == tr("Show Plot")) {
emit parser->showPlot(id, name_);
show_plot->setText(tr("Hide Plot"));
} else {
emit parser->hidePlot(id, name_);
show_plot->setText(tr("Show Plot"));
}
});
title_layout->addWidget(show_plot);
main_layout->addLayout(title_layout);
void DetailWidget::updateState() {
if (!can_data) return;
edit_container = new QWidget(this);
QVBoxLayout *v_layout = new QVBoxLayout(edit_container);
form = new SignalForm(sig, this);
v_layout->addWidget(form);
QHBoxLayout *h = new QHBoxLayout();
remove_btn = new QPushButton(tr("Remove Signal"));
QObject::connect(remove_btn, &QPushButton::clicked, this, &SignalEdit::remove);
h->addWidget(remove_btn);
h->addStretch();
QPushButton *save_btn = new QPushButton(tr("Save"));
QObject::connect(save_btn, &QPushButton::clicked, this, &SignalEdit::save);
h->addWidget(save_btn);
v_layout->addLayout(h);
edit_container->setVisible(false);
main_layout->addWidget(edit_container);
time_label->setText(QString("time: %1").arg(can_data->ts, 0, 'f', 3));
binary_view->setData(can_data->dat);
history_log->updateState();
}
void SignalEdit::save() {
Msg *msg = const_cast<Msg *>(parser->getMsg(id));
if (!msg) return;
for (auto &sig : msg->sigs) {
if (name_ == sig.name.c_str()) {
if (auto s = form->getSignal()) {
sig = *s;
}
break;
}
void DetailWidget::editMsg() {
EditMessageDialog dlg(can_data->id, this);
if (dlg.exec()) {
setMsg(can_data);
}
}
void SignalEdit::remove() {
QMessageBox msgbox;
msgbox.setText(tr("Remove signal"));
msgbox.setInformativeText(tr("Are you sure you want to remove signal '%1'").arg(name_));
msgbox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
msgbox.setDefaultButton(QMessageBox::Cancel);
if (msgbox.exec()) {
parser->removeSignal(id, name_);
emit removed();
void DetailWidget::addSignal() {
AddSignalDialog dlg(can_data->id, this);
if (dlg.exec()) {
setMsg(can_data);
}
}
// BinaryView
BinaryView::BinaryView(QWidget *parent) {
QVBoxLayout *main_layout = new QVBoxLayout(this);
table = new QTableWidget(this);
@ -316,15 +130,16 @@ BinaryView::BinaryView(QWidget *parent) {
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
}
void BinaryView::setMsg(const QString &id) {
auto msg = parser->getMsg(Parser::addressFromId(id));
int row_count = msg ? msg->size : parser->can_msgs[id].back().dat.size();
void BinaryView::setMsg(const CanData *can_data) {
const Msg *msg = parser->getMsg(can_data->address);
int row_count = msg ? msg->size : can_data->dat.size();
table->setRowCount(row_count);
table->setColumnCount(9);
for (int i = 0; i < table->rowCount(); ++i) {
for (int j = 0; j < table->columnCount(); ++j) {
auto item = new QTableWidgetItem();
item->setFlags(item->flags() ^ Qt::ItemIsEditable);
item->setTextAlignment(Qt::AlignCenter);
if (j == 8) {
QFont font;
@ -336,19 +151,17 @@ void BinaryView::setMsg(const QString &id) {
}
if (msg) {
// set background color
for (int i = 0; i < msg->sigs.size(); ++i) {
const auto &sig = msg->sigs[i];
int start = sig.is_little_endian ? sig.start_bit : bigEndianBitIndex(sig.start_bit);
for (int j = start; j <= start + sig.size - 1; ++j) {
table->item(j / 8, j % 8)->setBackground(QColor(SIGNAL_COLORS[i % std::size(SIGNAL_COLORS)]));
table->item(j / 8, j % 8)->setBackground(QColor(getColor(i)));
}
}
}
setFixedHeight(table->rowHeight(0) * table->rowCount() + 25);
if (!parser->can_msgs.empty()) {
setData(parser->can_msgs[id].back().dat);
}
}
void BinaryView::setData(const QByteArray &binary) {
@ -357,6 +170,7 @@ void BinaryView::setData(const QByteArray &binary) {
s += std::bitset<8>(binary[j]).to_string();
}
setUpdatesEnabled(false);
char hex[3] = {'\0'};
for (int i = 0; i < binary.size(); ++i) {
for (int j = 0; j < 8; ++j) {
@ -365,46 +179,58 @@ void BinaryView::setData(const QByteArray &binary) {
sprintf(&hex[0], "%02X", (unsigned char)binary[i]);
table->item(i, 8)->setText(hex);
}
setUpdatesEnabled(true);
}
MessagesView::MessagesView(QWidget *parent) : QWidget(parent) {
// HistoryLog
HistoryLog::HistoryLog(QWidget *parent) : QWidget(parent) {
QVBoxLayout *main_layout = new QVBoxLayout(this);
QLabel *title = new QLabel("MESSAGE TIME BYTES");
QLabel *title = new QLabel("TIME BYTES");
main_layout->addWidget(title);
message_layout = new QVBoxLayout();
QVBoxLayout *message_layout = new QVBoxLayout();
for (int i = 0; i < std::size(labels); ++i) {
labels[i] = new QLabel();
labels[i]->setVisible(false);
message_layout->addWidget(labels[i]);
}
main_layout->addLayout(message_layout);
main_layout->addStretch();
}
void MessagesView::setMessages(const std::list<CanData> &list) {
auto begin = list.begin();
std::advance(begin, std::max(0, (int)(list.size() - 100)));
int j = 0;
for (auto it = begin; it != list.end(); ++it) {
QLabel *label;
if (j >= messages.size()) {
label = new QLabel();
message_layout->addWidget(label);
messages.push_back(label);
} else {
label = messages[j];
}
label->setText(it->hex_dat);
++j;
void HistoryLog::updateState() {
int i = 0;
for (; i < parser->history_log.size(); ++i) {
const auto &c = parser->history_log[i];
auto label = labels[i];
label->setVisible(true);
label->setText(QString("%1 %2").arg(c.ts, 0, 'f', 3).arg(c.hex_dat));
}
for (; i < std::size(labels); ++i) {
labels[i]->setVisible(false);
}
}
EditMessageDialog::EditMessageDialog(const QString &id, QWidget *parent) : QDialog(parent) {
void HistoryLog::clear() {
setUpdatesEnabled(false);
for (auto l : labels) l->setVisible(false);
setUpdatesEnabled(true);
}
// EditMessageDialog
EditMessageDialog::EditMessageDialog(const QString &id, QWidget *parent) : id(id), QDialog(parent) {
setWindowTitle(tr("Edit message"));
QVBoxLayout *main_layout = new QVBoxLayout(this);
main_layout->addWidget(new QLabel(tr("ID: (%1)").arg(id)));
auto msg = const_cast<Msg *>(parser->getMsg(Parser::addressFromId(id)));
auto msg = const_cast<Msg *>(parser->getMsg(id));
QHBoxLayout *h_layout = new QHBoxLayout();
h_layout->addWidget(new QLabel(tr("Name")));
h_layout->addStretch();
QLineEdit *name_edit = new QLineEdit(this);
name_edit = new QLineEdit(this);
name_edit->setText(msg ? msg->name.c_str() : "untitled");
h_layout->addWidget(name_edit);
main_layout->addLayout(h_layout);
@ -412,47 +238,30 @@ EditMessageDialog::EditMessageDialog(const QString &id, QWidget *parent) : QDial
h_layout = new QHBoxLayout();
h_layout->addWidget(new QLabel(tr("Size")));
h_layout->addStretch();
QSpinBox *size_spin = new QSpinBox(this);
size_spin->setValue(msg ? msg->size : parser->can_msgs[id].back().dat.size());
size_spin = new QSpinBox(this);
size_spin->setValue(msg ? msg->size : parser->can_msgs[id].dat.size());
h_layout->addWidget(size_spin);
main_layout->addLayout(h_layout);
auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
main_layout->addWidget(buttonBox);
connect(buttonBox, &QDialogButtonBox::accepted, [=]() {
if (size_spin->value() <= 0 || name_edit->text().isEmpty()) return;
if (msg) {
msg->name = name_edit->text().toStdString();
msg->size = size_spin->value();
} else {
Msg m = {};
m.address = Parser::addressFromId(id);
m.name = name_edit->text().toStdString();
m.size = size_spin->value();
parser->addNewMsg(m);
}
QDialog::accept();
});
connect(buttonBox, &QDialogButtonBox::accepted, this, &EditMessageDialog::save);
connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
}
AddSignalDialog::AddSignalDialog(const QString &id, QWidget *parent) : QDialog(parent) {
setWindowTitle(tr("Add signal to %1").arg(parser->getMsg(id)->name.c_str()));
QVBoxLayout *main_layout = new QVBoxLayout(this);
Signal sig = {.name = "untitled"};
auto form = new SignalForm(sig, this);
main_layout->addWidget(form);
auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
main_layout->addWidget(buttonBox);
connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
connect(buttonBox, &QDialogButtonBox::accepted, [=]() {
if (auto msg = const_cast<Msg *>(parser->getMsg(id))) {
if (auto signal = form->getSignal()) {
msg->sigs.push_back(*signal);
}
}
QDialog::accept();
});
void EditMessageDialog::save() {
if (size_spin->value() <= 0 || name_edit->text().isEmpty()) return;
if (auto msg = const_cast<Msg *>(parser->getMsg(id))) {
msg->name = name_edit->text().toStdString();
msg->size = size_spin->value();
} else {
Msg m = {};
m.address = Parser::addressFromId(id);
m.name = name_edit->text().toStdString();
m.size = size_spin->value();
parser->addNewMsg(m);
}
QDialog::accept();
}

@ -1,102 +1,70 @@
#pragma once
#include <QComboBox>
#include <QDialog>
#include <QDialogButtonBox>
#include <QLabel>
#include <QLineEdit>
#include <QPushButton>
#include <QSpinBox>
#include <QTableWidget>
#include <QVBoxLayout>
#include <QWidget>
#include <optional>
#include "opendbc/can/common.h"
#include "opendbc/can/common_dbc.h"
#include "selfdrive/ui/qt/widgets/controls.h"
#include "tools/cabana/parser.h"
#include "tools/cabana/signaledit.h"
class SignalForm : public QWidget {
class HistoryLog : public QWidget {
Q_OBJECT
public:
SignalForm(const Signal &sig, QWidget *parent);
std::optional<Signal> getSignal();
QLineEdit *name, *unit, *comment, *val_desc;
QSpinBox *size, *msb, *lsb, *factor, *offset, *min_val, *max_val;
QComboBox *sign, *endianness;
};
class MessagesView : public QWidget {
Q_OBJECT
public:
HistoryLog(QWidget *parent);
void clear();
void updateState();
public:
MessagesView(QWidget *parent);
void setMessages(const std::list<CanData> &data);
std::vector<QLabel *> messages;
QVBoxLayout *message_layout;
private:
QLabel *labels[LOG_SIZE] = {};
};
class BinaryView : public QWidget {
Q_OBJECT
public:
public:
BinaryView(QWidget *parent);
void setMsg(const QString &id);
void setMsg(const CanData *can_data);
void setData(const QByteArray &binary);
QTableWidget *table;
};
class SignalEdit : public QWidget {
class EditMessageDialog : public QDialog {
Q_OBJECT
public:
SignalEdit(const QString &id, const Signal &sig, int idx, QWidget *parent);
public:
EditMessageDialog(const QString &id, QWidget *parent);
protected:
void save();
signals:
void removed();
protected:
void remove();
QLineEdit *name_edit;
QSpinBox *size_spin;
QString id;
QString name_;
ElidedLabel *title;
SignalForm *form;
QWidget *edit_container;
QPushButton *remove_btn;
};
class DetailWidget : public QWidget {
Q_OBJECT
public:
public:
DetailWidget(QWidget *parent);
void setMsg(const QString &id);
void setMsg(const CanData *c);
public slots:
private:
void updateState();
void addSignal();
void editMsg();
protected:
QLabel *name_label = nullptr;
const CanData *can_data = nullptr;
QLabel *name_label, *time_label;
QPushButton *edit_btn, *add_sig_btn;
QVBoxLayout *signal_edit_layout;
Signal *sig = nullptr;
MessagesView *messages_view;
QString msg_id;
HistoryLog *history_log;
BinaryView *binary_view;
std::vector<SignalEdit *> signal_edit;
};
class EditMessageDialog : public QDialog {
Q_OBJECT
public:
EditMessageDialog(const QString &id, QWidget *parent);
};
class AddSignalDialog : public QDialog {
Q_OBJECT
public:
AddSignalDialog(const QString &id, QWidget *parent);
};

@ -4,19 +4,15 @@
#include <QVBoxLayout>
MainWindow::MainWindow() : QWidget() {
assert(parser != nullptr);
QVBoxLayout *main_layout = new QVBoxLayout(this);
QHBoxLayout *h_layout = new QHBoxLayout();
main_layout->addLayout(h_layout);
messages_widget = new MessagesWidget(this);
QObject::connect(messages_widget, &MessagesWidget::msgChanged, [=](const QString &id) {
detail_widget->setMsg(id);
});
h_layout->addWidget(messages_widget);
detail_widget = new DetailWidget(this);
detail_widget->setFixedWidth(600);
h_layout->addWidget(detail_widget);
// right widget
@ -30,9 +26,12 @@ MainWindow::MainWindow() : QWidget() {
QScrollArea *scroll = new QScrollArea(this);
scroll->setWidget(charts_widget);
scroll->setWidgetResizable(true);
scroll->setFrameShape(QFrame::NoFrame);
scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
scroll->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
r_layout->addWidget(scroll);
h_layout->addWidget(right_container);
QObject::connect(messages_widget, &MessagesWidget::msgChanged, detail_widget, &DetailWidget::setMsg);
}

@ -11,10 +11,10 @@
class MainWindow : public QWidget {
Q_OBJECT
public:
public:
MainWindow();
protected:
protected:
VideoWidget *video_widget;
MessagesWidget *messages_widget;
DetailWidget *detail_widget;

@ -1,11 +1,9 @@
#include "tools/cabana/messageswidget.h"
#include <QComboBox>
#include <QDebug>
#include <QHeaderView>
#include <QPushButton>
#include <QVBoxLayout>
#include <bitset>
MessagesWidget::MessagesWidget(QWidget *parent) : QWidget(parent) {
QVBoxLayout *main_layout = new QVBoxLayout(this);
@ -47,8 +45,9 @@ MessagesWidget::MessagesWidget(QWidget *parent) : QWidget(parent) {
table_widget->setHorizontalHeaderLabels({tr("Name"), tr("ID"), tr("Count"), tr("Bytes")});
table_widget->horizontalHeader()->setStretchLastSection(true);
QObject::connect(table_widget, &QTableWidget::itemSelectionChanged, [=]() {
auto id = table_widget->selectedItems()[0]->data(Qt::UserRole);
emit msgChanged(id.toString());
const CanData *c = &(parser->can_msgs[table_widget->selectedItems()[1]->text()]);
parser->setCurrentMsg(c->id);
emit msgChanged(c);
});
main_layout->addWidget(table_widget);
@ -60,6 +59,7 @@ void MessagesWidget::updateState() {
auto item = table_widget->item(row, col);
if (!item) {
item = new QTableWidgetItem();
item->setFlags(item->flags() ^ Qt::ItemIsEditable);
table_widget->setItem(row, col, item);
}
return item;
@ -67,28 +67,27 @@ void MessagesWidget::updateState() {
table_widget->setRowCount(parser->can_msgs.size());
int i = 0;
const QString filter_str = filter->text().toLower();
for (const auto &[id, list] : parser->can_msgs) {
assert(!list.empty());
QString name;
if (auto msg = parser->getMsg(list.back().address)) {
QString name, untitled = tr("untitled");
const QString filter_str = filter->text();
for (const auto &[_, c] : parser->can_msgs) {
if (auto msg = parser->getMsg(c.address)) {
name = msg->name.c_str();
} else {
name = tr("untitled");
name = untitled;
}
if (!filter_str.isEmpty() && !name.toLower().contains(filter_str)) {
if (!filter_str.isEmpty() && !name.contains(filter_str, Qt::CaseInsensitive)) {
table_widget->hideRow(i++);
continue;
}
auto item = getTableItem(i, 0);
item->setText(name);
item->setData(Qt::UserRole, id);
getTableItem(i, 1)->setText(id);
getTableItem(i, 2)->setText(QString("%1").arg(parser->counters[id]));
getTableItem(i, 3)->setText(list.back().hex_dat);
getTableItem(i, 0)->setText(name);
getTableItem(i, 1)->setText(c.id);
getTableItem(i, 2)->setText(QString::number(parser->counters[c.id]));
getTableItem(i, 3)->setText(c.hex_dat);
table_widget->showRow(i);
i++;
}
if (table_widget->currentRow() == -1) {
table_widget->selectRow(0);
}
}

@ -16,7 +16,7 @@ class MessagesWidget : public QWidget {
void updateState();
signals:
void msgChanged(const QString &id);
void msgChanged(const CanData *id);
protected:
QLineEdit *filter;

@ -4,7 +4,11 @@
#include "cereal/messaging/messaging.h"
Parser *parser = nullptr;
Parser::Parser(QObject *parent) : QObject(parent) {
parser = this;
qRegisterMetaType<std::vector<CanData>>();
QObject::connect(this, &Parser::received, this, &Parser::process, Qt::QueuedConnection);
@ -23,32 +27,48 @@ Parser::~Parser() {
bool Parser::loadRoute(const QString &route, const QString &data_dir, bool use_qcam) {
replay = new Replay(route, {"can", "roadEncodeIdx"}, {}, nullptr, use_qcam ? REPLAY_FLAG_QCAMERA : 0, data_dir, this);
if (!replay->load()) {
return false;
QObject::connect(replay, &Replay::segmentsMerged, this, &Parser::segmentsMerged);
if (replay->load()) {
replay->start();
return true;
}
replay->start();
return true;
return false;
}
void Parser::openDBC(const QString &name) {
dbc_name = name;
dbc = const_cast<DBC *>(dbc_lookup(name.toStdString()));
counters.clear();
msg_map.clear();
for (auto &msg : dbc->msgs) {
msg_map[msg.address] = &msg;
}
}
void Parser::process(std::vector<CanData> can) {
for (auto &data : can) {
++counters[data.id];
auto &list = can_msgs[data.id];
while (list.size() > DATA_LIST_SIZE) {
list.pop_front();
void Parser::process(std::vector<CanData> msgs) {
static double prev_update_ts = 0;
for (const auto &can_data : msgs) {
can_msgs[can_data.id] = can_data;
current_sec = can_data.ts;
++counters[can_data.id];
if (can_data.id == current_msg_id) {
while (history_log.size() >= LOG_SIZE) {
history_log.pop_back();
}
history_log.push_front(can_data);
}
list.push_back(data);
}
emit updated();
double current_ts = millis_since_boot();
if ((current_ts - prev_update_ts) > 1000.0 / FPS) {
prev_update_ts = current_ts;
emit updated();
}
if (current_sec < begin_sec || current_sec > end_sec) {
// loop replay in selected range.
replay->seekTo(begin_sec, false);
}
}
void Parser::recvThread() {
@ -56,13 +76,16 @@ void Parser::recvThread() {
std::unique_ptr<Context> context(Context::create());
std::unique_ptr<SubSocket> subscriber(SubSocket::create(context.get(), "can"));
subscriber->setTimeout(100);
std::vector<CanData> can;
while (!exit) {
std::unique_ptr<Message> msg(subscriber->receive());
if (!msg) continue;
capnp::FlatArrayMessageReader cmsg(aligned_buf.align(msg.get()));
cereal::Event::Reader event = cmsg.getRoot<cereal::Event>();
std::vector<CanData> can;
can.clear();
can.reserve(event.getCan().size());
for (const auto &c : event.getCan()) {
CanData &data = can.emplace_back();
@ -72,7 +95,7 @@ void Parser::recvThread() {
data.dat.append((char *)c.getDat().begin(), c.getDat().size());
data.hex_dat = data.dat.toHex(' ').toUpper();
data.id = QString("%1:%2").arg(data.source).arg(data.address, 1, 16);
data.ts = (event.getLogMonoTime() - replay->routeStartTime()) / (double)1e6;
data.ts = (event.getLogMonoTime() - replay->routeStartTime()) / (double)1e9; // seconds
}
emit received(can);
}
@ -90,9 +113,72 @@ void Parser::removeSignal(const QString &id, const QString &sig_name) {
auto it = std::find_if(msg->sigs.begin(), msg->sigs.end(), [=](auto &sig) { return sig_name == sig.name.c_str(); });
if (it != msg->sigs.end()) {
msg->sigs.erase(it);
emit signalRemoved(id, sig_name);
}
}
uint32_t Parser::addressFromId(const QString &id) {
return id.mid(id.indexOf(':') + 1).toUInt(nullptr, 16);
}
const Signal *Parser::getSig(const QString &id, const QString &sig_name) {
if (auto msg = getMsg(id)) {
auto it = std::find_if(msg->sigs.begin(), msg->sigs.end(), [&](auto &s) { return sig_name == s.name.c_str(); });
if (it != msg->sigs.end()) {
return &(*it);
}
}
return nullptr;
}
void Parser::setRange(double min, double max) {
if (begin_sec != min || end_sec != max) {
begin_sec = min;
end_sec = max;
is_zoomed = begin_sec != event_begin_sec || end_sec != event_end_sec;
emit rangeChanged(min, max);
}
}
void Parser::segmentsMerged() {
auto events = replay->events();
if (!events || events->empty()) return;
auto it = std::find_if(events->begin(), events->end(), [=](const Event *e) { return e->which == cereal::Event::Which::CAN; });
event_begin_sec = it == events->end() ? 0 : ((*it)->mono_time - replay->routeStartTime()) / (double)1e9;
event_end_sec = double(events->back()->mono_time - replay->routeStartTime()) / 1e9;
if (!is_zoomed) {
begin_sec = event_begin_sec;
end_sec = event_end_sec;
}
emit eventsMerged();
}
void Parser::resetRange() {
setRange(event_begin_sec, event_end_sec);
}
void Parser::setCurrentMsg(const QString &id) {
current_msg_id = id;
history_log.clear();
}
// helper functions
static QVector<int> BIG_ENDIAN_START_BITS = []() {
QVector<int> ret;
for (int i = 0; i < 64; i++) {
for (int j = 7; j >= 0; j--) {
ret.push_back(j + i * 8);
}
}
return ret;
}();
int bigEndianStartBitsIndex(int start_bit) {
return BIG_ENDIAN_START_BITS[start_bit];
}
int bigEndianBitIndex(int index) {
return BIG_ENDIAN_START_BITS.indexOf(index);
}

@ -1,17 +1,20 @@
#pragma once
#include <atomic>
#include <map>
#include <QApplication>
#include <QHash>
#include <QObject>
#include <QThread>
#include <atomic>
#include <map>
#include "opendbc/can/common.h"
#include "opendbc/can/common_dbc.h"
#include "tools/replay/replay.h"
const int DATA_LIST_SIZE = 500;
// const int FPS = 20;
const int DATA_LIST_SIZE = 50;
const int FPS = 20;
const static int LOG_SIZE = 25;
struct CanData {
QString id;
@ -26,7 +29,7 @@ struct CanData {
class Parser : public QObject {
Q_OBJECT
public:
public:
Parser(QObject *parent);
~Parser();
static uint32_t addressFromId(const QString &id);
@ -35,32 +38,57 @@ class Parser : public QObject {
void saveDBC(const QString &name) {}
void addNewMsg(const Msg &msg);
void removeSignal(const QString &id, const QString &sig_name);
const Msg *getMsg(const QString &id) {
return getMsg(addressFromId(id));
}
const Msg *getMsg(uint32_t address) {
const Signal *getSig(const QString &id, const QString &sig_name);
void setRange(double min, double max);
void resetRange();
void setCurrentMsg(const QString &id);
inline std::pair<double, double> range() const { return {begin_sec, end_sec}; }
inline double currentSec() const { return current_sec; }
inline bool isZoomed() const { return is_zoomed; }
inline const Msg *getMsg(const QString &id) { return getMsg(addressFromId(id)); }
inline const Msg *getMsg(uint32_t address) {
auto it = msg_map.find(address);
return it != msg_map.end() ? it->second : nullptr;
}
signals:
signals:
void showPlot(const QString &id, const QString &name);
void hidePlot(const QString &id, const QString &name);
void signalRemoved(const QString &id, const QString &sig_name);
void eventsMerged();
void rangeChanged(double min, double max);
void received(std::vector<CanData> can);
void updated();
public:
public:
Replay *replay = nullptr;
QHash<QString, uint64_t> counters;
std::map<QString, CanData> can_msgs;
QList<CanData> history_log;
protected:
void recvThread();
void process(std::vector<CanData> can);
void segmentsMerged();
double current_sec = 0.;
std::atomic<bool> exit = false;
QThread *thread;
QString dbc_name;
std::atomic<bool> exit = false;
std::map<QString, std::list<CanData>> can_msgs;
std::map<QString, uint64_t> counters;
Replay *replay = nullptr;
double begin_sec = 0;
double end_sec = 0;
double event_begin_sec = 0;
double event_end_sec = 0;
bool is_zoomed = false;
DBC *dbc = nullptr;
std::map<uint32_t, const Msg *> msg_map;
QString current_msg_id;
};
Q_DECLARE_METATYPE(std::vector<CanData>);
// TODO: Add helper function in dbc.h
int bigEndianStartBitsIndex(int start_bit);
int bigEndianBitIndex(int index);
extern Parser *parser;

@ -0,0 +1,203 @@
#include "tools/cabana/signaledit.h"
#include <QDialogButtonBox>
#include <QHBoxLayout>
#include <QLabel>
#include <QMessageBox>
#include <QVBoxLayout>
// SignalForm
SignalForm::SignalForm(const Signal &sig, QWidget *parent) : QWidget(parent) {
QVBoxLayout *v_layout = new QVBoxLayout(this);
QHBoxLayout *h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Name")));
name = new QLineEdit(sig.name.c_str());
h->addWidget(name);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Size")));
size = new QSpinBox();
size->setValue(sig.size);
h->addWidget(size);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Most significant bit")));
msb = new QSpinBox();
msb->setValue(sig.msb);
h->addWidget(msb);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Endianness")));
endianness = new QComboBox();
endianness->addItems({"Little", "Big"});
endianness->setCurrentIndex(sig.is_little_endian ? 0 : 1);
h->addWidget(endianness);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("sign")));
sign = new QComboBox();
sign->addItems({"Signed", "Unsigned"});
sign->setCurrentIndex(sig.is_signed ? 0 : 1);
h->addWidget(sign);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Factor")));
factor = new QSpinBox();
factor->setValue(sig.factor);
h->addWidget(factor);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Offset")));
offset = new QSpinBox();
offset->setValue(sig.offset);
h->addWidget(offset);
v_layout->addLayout(h);
// TODO: parse the following parameters in opendbc
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Unit")));
unit = new QLineEdit();
h->addWidget(unit);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Comment")));
comment = new QLineEdit();
h->addWidget(comment);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Minimum value")));
min_val = new QSpinBox();
h->addWidget(min_val);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Maximum value")));
max_val = new QSpinBox();
h->addWidget(max_val);
v_layout->addLayout(h);
h = new QHBoxLayout();
h->addWidget(new QLabel(tr("Value descriptions")));
val_desc = new QLineEdit();
h->addWidget(val_desc);
v_layout->addLayout(h);
}
std::optional<Signal> SignalForm::getSignal() {
Signal sig = {};
sig.name = name->text().toStdString();
sig.size = size->text().toInt();
sig.offset = offset->text().toDouble();
sig.factor = factor->text().toDouble();
sig.msb = msb->text().toInt();
sig.is_signed = sign->currentIndex() == 0;
sig.is_little_endian = endianness->currentIndex() == 0;
if (sig.is_little_endian) {
sig.lsb = sig.start_bit;
sig.msb = sig.start_bit + sig.size - 1;
} else {
sig.lsb = bigEndianStartBitsIndex(bigEndianBitIndex(sig.start_bit) + sig.size - 1);
sig.msb = sig.start_bit;
}
return (sig.name.empty() || sig.size <= 0) ? std::nullopt : std::optional(sig);
}
// SignalEdit
SignalEdit::SignalEdit(const QString &id, const Signal &sig, const QString &color, QWidget *parent) : id(id), name_(sig.name.c_str()), QWidget(parent) {
QVBoxLayout *main_layout = new QVBoxLayout(this);
main_layout->setContentsMargins(0, 0, 0, 0);
// title
QHBoxLayout *title_layout = new QHBoxLayout();
QLabel *icon = new QLabel(">");
icon->setStyleSheet("font-weight:bold");
title_layout->addWidget(icon);
title = new ElidedLabel(this);
title->setText(sig.name.c_str());
title->setStyleSheet(QString("font-weight:bold; color:%1").arg(color));
connect(title, &ElidedLabel::clicked, [=]() {
edit_container->isVisible() ? edit_container->hide() : edit_container->show();
icon->setText(edit_container->isVisible() ? "" : ">");
});
title_layout->addWidget(title);
title_layout->addStretch();
plot_btn = new QPushButton("📈");
plot_btn->setStyleSheet("font-size:16px");
plot_btn->setToolTip(tr("Show Plot"));
plot_btn->setContentsMargins(5, 5, 5, 5);
plot_btn->setFixedSize(30, 30);
QObject::connect(plot_btn, &QPushButton::clicked, [=]() { emit parser->showPlot(id, name_); });
title_layout->addWidget(plot_btn);
main_layout->addLayout(title_layout);
edit_container = new QWidget(this);
QVBoxLayout *v_layout = new QVBoxLayout(edit_container);
form = new SignalForm(sig, this);
v_layout->addWidget(form);
QHBoxLayout *h = new QHBoxLayout();
remove_btn = new QPushButton(tr("Remove Signal"));
QObject::connect(remove_btn, &QPushButton::clicked, this, &SignalEdit::remove);
h->addWidget(remove_btn);
h->addStretch();
QPushButton *save_btn = new QPushButton(tr("Save"));
QObject::connect(save_btn, &QPushButton::clicked, this, &SignalEdit::save);
h->addWidget(save_btn);
v_layout->addLayout(h);
edit_container->setVisible(false);
main_layout->addWidget(edit_container);
}
void SignalEdit::save() {
if (auto sig = const_cast<Signal *>(parser->getSig(id, name_))) {
if (auto s = form->getSignal()) {
*sig = *s;
// TODO: reset the chart for sig
}
}
}
void SignalEdit::remove() {
QMessageBox msgbox;
msgbox.setText(tr("Remove signal"));
msgbox.setInformativeText(tr("Are you sure you want to remove signal '%1'").arg(name_));
msgbox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
msgbox.setDefaultButton(QMessageBox::Cancel);
if (msgbox.exec()) {
parser->removeSignal(id, name_);
deleteLater();
}
}
// AddSignalDialog
AddSignalDialog::AddSignalDialog(const QString &id, QWidget *parent) : QDialog(parent) {
setWindowTitle(tr("Add signal to %1").arg(parser->getMsg(id)->name.c_str()));
QVBoxLayout *main_layout = new QVBoxLayout(this);
Signal sig = {.name = "untitled"};
auto form = new SignalForm(sig, this);
main_layout->addWidget(form);
auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
main_layout->addWidget(buttonBox);
connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
connect(buttonBox, &QDialogButtonBox::accepted, [=]() {
if (auto msg = const_cast<Msg *>(parser->getMsg(id))) {
if (auto signal = form->getSignal()) {
msg->sigs.push_back(*signal);
}
}
QDialog::accept();
});
}

@ -0,0 +1,50 @@
#pragma once
#include <optional>
#include <QComboBox>
#include <QDialog>
#include <QLineEdit>
#include <QPushButton>
#include <QSpinBox>
#include "selfdrive/ui/qt/widgets/controls.h"
#include "tools/cabana/parser.h"
class SignalForm : public QWidget {
Q_OBJECT
public:
SignalForm(const Signal &sig, QWidget *parent);
std::optional<Signal> getSignal();
QLineEdit *name, *unit, *comment, *val_desc;
QSpinBox *size, *msb, *lsb, *factor, *offset, *min_val, *max_val;
QComboBox *sign, *endianness;
};
class SignalEdit : public QWidget {
Q_OBJECT
public:
SignalEdit(const QString &id, const Signal &sig, const QString &color, QWidget *parent = nullptr);
void save();
protected:
void remove();
QString id;
QString name_;
QPushButton *plot_btn;
ElidedLabel *title;
SignalForm *form;
QWidget *edit_container;
QPushButton *remove_btn;
};
class AddSignalDialog : public QDialog {
Q_OBJECT
public:
AddSignalDialog(const QString &id, QWidget *parent);
};

@ -3,9 +3,7 @@
#include <QButtonGroup>
#include <QDateTime>
#include <QHBoxLayout>
#include <QLabel>
#include <QPushButton>
#include <QTimer>
#include <QVBoxLayout>
#include "tools/cabana/parser.h"
@ -17,17 +15,19 @@ inline QString formatTime(int seconds) {
VideoWidget::VideoWidget(QWidget *parent) : QWidget(parent) {
QVBoxLayout *main_layout = new QVBoxLayout(this);
cam_widget = new CameraViewWidget("camerad", VISION_STREAM_ROAD, true, this);
cam_widget->setFixedSize(640, 480);
cam_widget = new CameraViewWidget("camerad", VISION_STREAM_ROAD, false, this);
cam_widget->setFixedSize(parent->width(), parent->width() / 1.596);
main_layout->addWidget(cam_widget);
// slider controls
QHBoxLayout *slider_layout = new QHBoxLayout();
QLabel *time_label = new QLabel("00:00");
time_label = new QLabel("00:00");
slider_layout->addWidget(time_label);
slider = new QSlider(Qt::Horizontal, this);
// slider->setFixedWidth(640);
QObject::connect(slider, &QSlider::sliderMoved, [=]() {
time_label->setText(formatTime(slider->value()));
});
slider->setSingleStep(1);
slider->setMaximum(parser->replay->totalSeconds());
QObject::connect(slider, &QSlider::sliderReleased, [=]() {
@ -36,7 +36,7 @@ VideoWidget::VideoWidget(QWidget *parent) : QWidget(parent) {
});
slider_layout->addWidget(slider);
QLabel *total_time_label = new QLabel(formatTime(parser->replay->totalSeconds()));
total_time_label = new QLabel(formatTime(parser->replay->totalSeconds()));
slider_layout->addWidget(total_time_label);
main_layout->addLayout(slider_layout);
@ -57,9 +57,7 @@ VideoWidget::VideoWidget(QWidget *parent) : QWidget(parent) {
for (float speed : {0.1, 0.5, 1., 2.}) {
QPushButton *btn = new QPushButton(QString("%1x").arg(speed), this);
btn->setCheckable(true);
QObject::connect(btn, &QPushButton::clicked, [=]() {
parser->replay->setSpeed(speed);
});
QObject::connect(btn, &QPushButton::clicked, [=]() { parser->replay->setSpeed(speed); });
control_layout->addWidget(btn);
group->addButton(btn);
if (speed == 1.0) btn->setChecked(true);
@ -67,14 +65,25 @@ VideoWidget::VideoWidget(QWidget *parent) : QWidget(parent) {
main_layout->addLayout(control_layout);
QTimer *timer = new QTimer(this);
timer->setInterval(1000);
timer->callOnTimeout([=]() {
int current_seconds = parser->replay->currentSeconds();
time_label->setText(formatTime(current_seconds));
if (!slider->isSliderDown()) {
slider->setValue(current_seconds);
}
});
timer->start();
QObject::connect(parser, &Parser::rangeChanged, this, &VideoWidget::rangeChanged);
QObject::connect(parser, &Parser::updated, this, &VideoWidget::updateState);
}
void VideoWidget::rangeChanged(double min, double max) {
if (!parser->isZoomed()) {
min = 0;
max = parser->replay->totalSeconds();
}
time_label->setText(formatTime(min));
total_time_label->setText(formatTime(max));
slider->setMaximum(max);
slider->setValue(parser->currentSec());
}
void VideoWidget::updateState() {
if (!slider->isSliderDown()) {
int current_sec = parser->currentSec();
time_label->setText(formatTime(current_sec));
slider->setValue(current_sec);
}
}

@ -1,5 +1,6 @@
#pragma once
#include <QLabel>
#include <QSlider>
#include <QWidget>
@ -12,6 +13,10 @@ public:
VideoWidget(QWidget *parnet = nullptr);
protected:
void rangeChanged(double min, double max);
void updateState();
CameraViewWidget *cam_widget;
QLabel *time_label, *total_time_label;
QSlider *slider;
};

@ -46,7 +46,9 @@ LogReader::~LogReader() {
#endif
}
bool LogReader::load(const std::string &url, std::atomic<bool> *abort, bool local_cache, int chunk_size, int retries) {
bool LogReader::load(const std::string &url, std::atomic<bool> *abort,
const std::set<cereal::Event::Which> &allow,
bool local_cache, int chunk_size, int retries) {
raw_ = FileReader(local_cache, chunk_size, retries).read(url, abort);
if (raw_.empty()) return false;
@ -54,18 +56,26 @@ bool LogReader::load(const std::string &url, std::atomic<bool> *abort, bool loca
raw_ = decompressBZ2(raw_, abort);
if (raw_.empty()) return false;
}
return parse(abort);
return parse(allow, abort);
}
bool LogReader::load(const std::byte *data, size_t size, std::atomic<bool> *abort) {
raw_.assign((const char *)data, size);
return parse(abort);
return parse({}, abort);
}
bool LogReader::parse(std::atomic<bool> *abort) {
bool LogReader::parse(const std::set<cereal::Event::Which> &allow, std::atomic<bool> *abort) {
try {
kj::ArrayPtr<const capnp::word> words((const capnp::word *)raw_.data(), raw_.size() / sizeof(capnp::word));
while (words.size() > 0 && !(abort && *abort)) {
if (!allow.empty()) {
capnp::FlatArrayMessageReader reader(words);
auto which = reader.getRoot<cereal::Event>().which();
if (allow.find(which) == allow.end()) {
words = kj::arrayPtr(reader.getEnd(), words.end());
continue;
}
}
#ifdef HAS_MEMORY_RESOURCE
Event *evt = new (mbr_) Event(words);

@ -5,6 +5,8 @@
#include <memory_resource>
#endif
#include <set>
#include "cereal/gen/cpp/log.capnp.h"
#include "system/camerad/cameras/camera_common.h"
#include "tools/replay/filereader.h"
@ -50,12 +52,13 @@ class LogReader {
public:
LogReader(size_t memory_pool_block_size = DEFAULT_EVENT_MEMORY_POOL_BLOCK_SIZE);
~LogReader();
bool load(const std::string &url, std::atomic<bool> *abort = nullptr, bool local_cache = false, int chunk_size = -1, int retries = 0);
bool load(const std::string &url, std::atomic<bool> *abort = nullptr, const std::set<cereal::Event::Which> &allow = {},
bool local_cache = false, int chunk_size = -1, int retries = 0);
bool load(const std::byte *data, size_t size, std::atomic<bool> *abort = nullptr);
std::vector<Event*> events;
private:
bool parse(std::atomic<bool> *abort);
bool parse(const std::set<cereal::Event::Which> &allow, std::atomic<bool> *abort);
std::string raw_;
#ifdef HAS_MEMORY_RESOURCE
std::pmr::monotonic_buffer_resource *mbr_ = nullptr;

@ -19,6 +19,9 @@ Replay::Replay(QString route, QStringList allow, QStringList block, SubMaster *s
if ((allow.empty() || allow.contains(it.name)) && !block.contains(it.name)) {
uint16_t which = event_struct.getFieldByName(it.name).getProto().getDiscriminantValue();
sockets_[which] = it.name;
if (!allow.empty() || !block.empty()) {
allow_list.insert((cereal::Event::Which)which);
}
s.push_back(it.name);
}
}
@ -91,17 +94,17 @@ void Replay::updateEvents(const std::function<bool()> &lambda) {
stream_cv_.notify_one();
}
void Replay::seekTo(int seconds, bool relative) {
void Replay::seekTo(double seconds, bool relative) {
seconds = relative ? seconds + currentSeconds() : seconds;
updateEvents([&]() {
seconds = std::max(0, seconds);
int seg = seconds / 60;
seconds = std::max(double(0.0), seconds);
int seg = (int)seconds / 60;
if (segments_.find(seg) == segments_.end()) {
rWarning("can't seek to %d s segment %d is invalid", seconds, seg);
return true;
}
rInfo("seeking to %d s, segment %d", seconds, seg);
rInfo("seeking to %d s, segment %d", (int)seconds, seg);
current_segment_ = seg;
cur_mono_time_ = route_start_ts_ + seconds * 1e9;
return isSegmentMerged(seg);
@ -122,7 +125,9 @@ void Replay::buildTimeline() {
for (int i = 0; i < segments_.size() && !exit_; ++i) {
LogReader log;
if (!log.load(route_->at(i).qlog.toStdString(), &exit_, !hasFlag(REPLAY_FLAG_NO_FILE_CACHE), 0, 3)) continue;
if (!log.load(route_->at(i).qlog.toStdString(), &exit_,
{cereal::Event::Which::CONTROLS_STATE, cereal::Event::Which::USER_FLAG},
!hasFlag(REPLAY_FLAG_NO_FILE_CACHE), 0, 3)) continue;
for (const Event *e : log.events) {
if (e->which == cereal::Event::Which::CONTROLS_STATE) {
@ -215,7 +220,7 @@ void Replay::queueSegment() {
if ((seg && !seg->isLoaded()) || !seg) {
if (!seg) {
rDebug("loading segment %d...", n);
seg = std::make_unique<Segment>(n, route_->at(n), flags_);
seg = std::make_unique<Segment>(n, route_->at(n), flags_, allow_list);
QObject::connect(seg.get(), &Segment::loadFinished, this, &Replay::segmentLoadFinished);
}
break;
@ -270,6 +275,9 @@ void Replay::mergeSegments(const SegmentMap::iterator &begin, const SegmentMap::
segments_merged_ = segments_need_merge;
return true;
});
if (stream_thread_) {
emit segmentsMerged();
}
}
}
@ -306,6 +314,7 @@ void Replay::startStream(const Segment *cur_segment) {
camera_server_ = std::make_unique<CameraServer>(camera_size);
}
emit segmentsMerged();
// start stream thread
stream_thread_ = new QThread();
QObject::connect(stream_thread_, &QThread::started, [=]() { stream(); });

@ -45,18 +45,19 @@ public:
void stop();
void pause(bool pause);
void seekToFlag(FindFlag flag);
void seekTo(int seconds, bool relative);
void seekTo(double seconds, bool relative);
inline bool isPaused() const { return paused_; }
inline bool hasFlag(REPLAY_FLAGS flag) const { return flags_ & flag; }
inline void addFlag(REPLAY_FLAGS flag) { flags_ |= flag; }
inline void removeFlag(REPLAY_FLAGS flag) { flags_ &= ~flag; }
inline const Route* route() const { return route_.get(); }
inline int currentSeconds() const { return (cur_mono_time_ - route_start_ts_) / 1e9; }
inline double currentSeconds() const { return double(cur_mono_time_ - route_start_ts_) / 1e9; }
inline uint64_t routeStartTime() const { return route_start_ts_; }
inline int toSeconds(uint64_t mono_time) const { return (mono_time - route_start_ts_) / 1e9; }
inline int totalSeconds() const { return segments_.size() * 60; }
inline void setSpeed(float speed) { speed_ = speed; }
inline float getSpeed() const { return speed_; }
inline const std::vector<Event *> *events() const { return events_.get(); }
inline const std::string &carFingerprint() const { return car_fingerprint_; }
inline const std::vector<std::tuple<int, int, TimelineType>> getTimeline() {
std::lock_guard lk(timeline_lock);
@ -65,6 +66,7 @@ public:
signals:
void streamStarted();
void segmentsMerged();
protected slots:
void segmentLoadFinished(bool success);
@ -98,7 +100,7 @@ protected:
bool paused_ = false;
bool events_updated_ = false;
uint64_t route_start_ts_ = 0;
uint64_t cur_mono_time_ = 0;
std::atomic<uint64_t> cur_mono_time_ = 0;
std::unique_ptr<std::vector<Event *>> events_;
std::unique_ptr<std::vector<Event *>> new_events_;
std::vector<int> segments_merged_;
@ -114,6 +116,7 @@ protected:
std::mutex timeline_lock;
QFuture<void> timeline_future;
std::vector<std::tuple<int, int, TimelineType>> timeline;
std::set<cereal::Event::Which> allow_list;
std::string car_fingerprint_;
float speed_ = 1.0;
};

@ -99,7 +99,9 @@ void Route::addFileToSegment(int n, const QString &file) {
// class Segment
Segment::Segment(int n, const SegmentFile &files, uint32_t flags) : seg_num(n), flags(flags) {
Segment::Segment(int n, const SegmentFile &files, uint32_t flags,
const std::set<cereal::Event::Which> &allow)
: seg_num(n), flags(flags), allow(allow) {
// [RoadCam, DriverCam, WideRoadCam, log]. fallback to qcamera/qlog
const std::array file_list = {
(flags & REPLAY_FLAG_QCAMERA) || files.road_cam.isEmpty() ? files.qcamera : files.road_cam,
@ -130,7 +132,7 @@ void Segment::loadFile(int id, const std::string file) {
success = frames[id]->load(file, flags & REPLAY_FLAG_NO_HW_DECODER, &abort_, local_cache, 20 * 1024 * 1024, 3);
} else {
log = std::make_unique<LogReader>();
success = log->load(file, &abort_, local_cache, 0, 3);
success = log->load(file, &abort_, allow, local_cache, 0, 3);
}
if (!success) {

@ -47,7 +47,7 @@ class Segment : public QObject {
Q_OBJECT
public:
Segment(int n, const SegmentFile &files, uint32_t flags);
Segment(int n, const SegmentFile &files, uint32_t flags, const std::set<cereal::Event::Which> &allow = {});
~Segment();
inline bool isLoaded() const { return !loading_ && !abort_; }
@ -65,4 +65,5 @@ protected:
std::atomic<int> loading_ = 0;
QFutureSynchronizer<void> synchronizer_;
uint32_t flags;
std::set<cereal::Event::Which> allow;
};

Loading…
Cancel
Save