osmocom
/
wireshark
11
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
wireshark/ui/qt/rtp_analysis_dialog.cpp

1189 lines
41 KiB
C++
Raw Blame History

/* rtp_analysis_dialog.cpp
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "rtp_analysis_dialog.h"
#include <ui_rtp_analysis_dialog.h>
#include "file.h"
#include "frame_tvbuff.h"
#include "epan/epan_dissect.h"
#include <epan/addr_resolv.h>
#include "epan/rtp_pt.h"
#include "epan/dfilter/dfilter.h"
#include "epan/dissectors/packet-rtp.h"
#include <ui/rtp_media.h>
#include "ui/help_url.h"
#include "ui/simple_dialog.h"
#include <wsutil/utf8_entities.h>
#include <wsutil/g711.h>
#include <wsutil/pint.h>
#include <QMessageBox>
#include <QPushButton>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QLabel>
#include <QToolButton>
#include <QWidget>
#include <QCheckBox>
#include <ui/qt/utils/color_utils.h>
#include <ui/qt/utils/qt_ui_utils.h>
#include "rtp_player_dialog.h"
#include <ui/qt/utils/stock_icon.h>
#include "main_application.h"
#include "ui/qt/widgets/wireshark_file_dialog.h"
/*
* @file RTP stream analysis dialog
*
* Displays forward and reverse RTP streams and graphs each stream
*/
// To do:
// - Progress bar for tapping and saving.
// - Add a refresh button and/or action.
// - Fixup output file names.
// - Add a graph title and legend when saving?
enum {
packet_col_,
sequence_col_,
delta_col_,
jitter_col_,
skew_col_,
bandwidth_col_,
marker_col_,
status_col_
};
static const QRgb color_cn_ = 0xbfbfff;
static const QRgb color_rtp_warn_ = 0xffdbbf;
static const QRgb color_pt_event_ = 0xefffff;
enum { rtp_analysis_type_ = 1000 };
class RtpAnalysisTreeWidgetItem : public QTreeWidgetItem
{
public:
RtpAnalysisTreeWidgetItem(QTreeWidget *tree, tap_rtp_stat_t *statinfo, packet_info *pinfo, const struct _rtp_info *rtpinfo) :
QTreeWidgetItem(tree, rtp_analysis_type_)
{
frame_num_ = pinfo->num;
sequence_num_ = rtpinfo->info_seq_num;
pkt_len_ = pinfo->fd->pkt_len;
flags_ = statinfo->flags;
if (flags_ & STAT_FLAG_FIRST) {
delta_ = 0.0;
jitter_ = 0.0;
skew_ = 0.0;
} else {
delta_ = statinfo->delta;
jitter_ = statinfo->jitter;
skew_ = statinfo->skew;
}
bandwidth_ = statinfo->bandwidth;
marker_ = rtpinfo->info_marker_set ? true : false;
ok_ = false;
QColor bg_color = QColor();
QString status;
if (statinfo->pt == PT_CN) {
status = "Comfort noise (PT=13, RFC 3389)";
bg_color = color_cn_;
} else if (statinfo->pt == PT_CN_OLD) {
status = "Comfort noise (PT=19, reserved)";
bg_color = color_cn_;
} else if (statinfo->flags & STAT_FLAG_WRONG_SEQ) {
status = "Wrong sequence number";
bg_color = ColorUtils::expert_color_error;
} else if (statinfo->flags & STAT_FLAG_DUP_PKT) {
status = "Suspected duplicate (MAC address) only delta time calculated";
bg_color = color_rtp_warn_;
} else if (statinfo->flags & STAT_FLAG_REG_PT_CHANGE) {
status = QString("Payload changed to PT=%1").arg(statinfo->pt);
if (statinfo->flags & STAT_FLAG_PT_T_EVENT) {
status.append(" telephone/event");
}
bg_color = color_rtp_warn_;
} else if (statinfo->flags & STAT_FLAG_WRONG_TIMESTAMP) {
status = "Incorrect timestamp";
/* color = COLOR_WARNING; */
bg_color = color_rtp_warn_;
} else if ((statinfo->flags & STAT_FLAG_PT_CHANGE)
&& !(statinfo->flags & STAT_FLAG_FIRST)
&& !(statinfo->flags & STAT_FLAG_PT_CN)
&& (statinfo->flags & STAT_FLAG_FOLLOW_PT_CN)
&& !(statinfo->flags & STAT_FLAG_MARKER)) {
status = "Marker missing?";
bg_color = color_rtp_warn_;
} else if (statinfo->flags & STAT_FLAG_PT_T_EVENT) {
status = QString("PT=%1 telephone/event").arg(statinfo->pt);
/* XXX add color? */
bg_color = color_pt_event_;
} else {
if (statinfo->flags & STAT_FLAG_MARKER) {
bg_color = color_rtp_warn_;
}
}
if (status.isEmpty()) {
ok_ = true;
status = UTF8_CHECK_MARK;
}
setText(packet_col_, QString::number(frame_num_));
setText(sequence_col_, QString::number(sequence_num_));
setText(delta_col_, QString::number(delta_, 'f', prefs.gui_decimal_places3));
setText(jitter_col_, QString::number(jitter_, 'f', prefs.gui_decimal_places3));
setText(skew_col_, QString::number(skew_, 'f', prefs.gui_decimal_places3));
setText(bandwidth_col_, QString::number(bandwidth_, 'f', prefs.gui_decimal_places1));
if (marker_) {
setText(marker_col_, UTF8_BULLET);
}
setText(status_col_, status);
setTextAlignment(packet_col_, Qt::AlignRight);
setTextAlignment(sequence_col_, Qt::AlignRight);
setTextAlignment(delta_col_, Qt::AlignRight);
setTextAlignment(jitter_col_, Qt::AlignRight);
setTextAlignment(skew_col_, Qt::AlignRight);
setTextAlignment(bandwidth_col_, Qt::AlignRight);
setTextAlignment(marker_col_, Qt::AlignCenter);
if (bg_color.isValid()) {
for (int col = 0; col < columnCount(); col++) {
setBackground(col, bg_color);
setForeground(col, ColorUtils::expert_color_foreground);
}
}
}
uint32_t frameNum() { return frame_num_; }
bool frameStatus() { return ok_; }
QList<QVariant> rowData() {
QString marker_str;
QString status_str = ok_ ? "OK" : text(status_col_);
if (marker_) marker_str = "SET";
return QList<QVariant>()
<< frame_num_ << sequence_num_ << delta_ << jitter_ << skew_ << bandwidth_
<< marker_str << status_str;
}
bool operator< (const QTreeWidgetItem &other) const
{
if (other.type() != rtp_analysis_type_) return QTreeWidgetItem::operator< (other);
const RtpAnalysisTreeWidgetItem *other_row = static_cast<const RtpAnalysisTreeWidgetItem *>(&other);
switch (treeWidget()->sortColumn()) {
case (packet_col_):
return frame_num_ < other_row->frame_num_;
break;
case (sequence_col_):
return sequence_num_ < other_row->sequence_num_;
break;
case (delta_col_):
return delta_ < other_row->delta_;
break;
case (jitter_col_):
return jitter_ < other_row->jitter_;
break;
case (skew_col_):
return skew_ < other_row->skew_;
break;
case (bandwidth_col_):
return bandwidth_ < other_row->bandwidth_;
break;
default:
break;
}
// Fall back to string comparison
return QTreeWidgetItem::operator <(other);
}
private:
uint32_t frame_num_;
uint32_t sequence_num_;
uint32_t pkt_len_;
uint32_t flags_;
double delta_;
double jitter_;
double skew_;
double bandwidth_;
bool marker_;
bool ok_;
};
enum {
fwd_jitter_graph_,
fwd_diff_graph_,
fwd_delta_graph_,
rev_jitter_graph_,
rev_diff_graph_,
rev_delta_graph_,
num_graphs_
};
RtpAnalysisDialog *RtpAnalysisDialog::pinstance_{nullptr};
std::mutex RtpAnalysisDialog::init_mutex_;
std::mutex RtpAnalysisDialog::run_mutex_;
RtpAnalysisDialog *RtpAnalysisDialog::openRtpAnalysisDialog(QWidget &parent, CaptureFile &cf, QObject *packet_list)
{
std::lock_guard<std::mutex> lock(init_mutex_);
if (pinstance_ == nullptr)
{
pinstance_ = new RtpAnalysisDialog(parent, cf);
connect(pinstance_, SIGNAL(goToPacket(int)),
packet_list, SLOT(goToPacket(int)));
}
return pinstance_;
}
RtpAnalysisDialog::RtpAnalysisDialog(QWidget &parent, CaptureFile &cf) :
WiresharkDialog(parent, cf),
ui(new Ui::RtpAnalysisDialog),
tab_seq(0)
{
ui->setupUi(this);
loadGeometry(parent.width() * 4 / 5, parent.height() * 4 / 5);
setWindowSubtitle(tr("RTP Stream Analysis"));
// Used when tab contains IPs
//ui->tabWidget->setStyleSheet("QTabBar::tab { height: 7ex; }");
ui->tabWidget->tabBar()->setTabsClosable(true);
ui->progressFrame->hide();
stream_ctx_menu_.addAction(ui->actionGoToPacket);
stream_ctx_menu_.addAction(ui->actionNextProblem);
set_action_shortcuts_visible_in_context_menu(stream_ctx_menu_.actions());
connect(ui->streamGraph, SIGNAL(mousePress(QMouseEvent*)),
this, SLOT(graphClicked(QMouseEvent*)));
graph_ctx_menu_.addAction(ui->actionSaveGraph);
ui->streamGraph->xAxis->setLabel("Arrival Time");
ui->streamGraph->yAxis->setLabel("Value (ms)");
QPushButton *prepare_button = ui->buttonBox->addButton(ui->actionPrepareButton->text(), QDialogButtonBox::ActionRole);
prepare_button->setToolTip(ui->actionPrepareButton->toolTip());
prepare_button->setMenu(ui->menuPrepareFilter);
player_button_ = RtpPlayerDialog::addPlayerButton(ui->buttonBox, this);
QPushButton *export_btn = ui->buttonBox->addButton(ui->actionExportButton->text(), QDialogButtonBox::ActionRole);
export_btn->setToolTip(ui->actionExportButton->toolTip());
QMenu *save_menu = new QMenu(export_btn);
save_menu->addAction(ui->actionSaveOneCsv);
save_menu->addAction(ui->actionSaveAllCsv);
save_menu->addSeparator();
save_menu->addAction(ui->actionSaveGraph);
export_btn->setMenu(save_menu);
connect(ui->tabWidget, SIGNAL(currentChanged(int)),
this, SLOT(updateWidgets()));
connect(ui->tabWidget->tabBar(), SIGNAL(tabCloseRequested(int)),
this, SLOT(closeTab(int)));
connect(this, SIGNAL(updateFilter(QString, bool)),
&parent, SLOT(filterPackets(QString, bool)));
connect(this, SIGNAL(rtpPlayerDialogReplaceRtpStreams(QVector<rtpstream_id_t *>)),
&parent, SLOT(rtpPlayerDialogReplaceRtpStreams(QVector<rtpstream_id_t *>)));
connect(this, SIGNAL(rtpPlayerDialogAddRtpStreams(QVector<rtpstream_id_t *>)),
&parent, SLOT(rtpPlayerDialogAddRtpStreams(QVector<rtpstream_id_t *>)));
connect(this, SIGNAL(rtpPlayerDialogRemoveRtpStreams(QVector<rtpstream_id_t *>)),
&parent, SLOT(rtpPlayerDialogRemoveRtpStreams(QVector<rtpstream_id_t *>)));
updateWidgets();
updateStatistics();
}
RtpAnalysisDialog::~RtpAnalysisDialog()
{
std::lock_guard<std::mutex> lock(init_mutex_);
if (pinstance_ != nullptr) {
delete ui;
for(int i=0; i<tabs_.count(); i++) {
deleteTabInfo(tabs_[i]);
g_free(tabs_[i]);
}
pinstance_ = nullptr;
}
}
void RtpAnalysisDialog::deleteTabInfo(tab_info_t *tab_info)
{
delete tab_info->time_vals;
delete tab_info->jitter_vals;
delete tab_info->diff_vals;
delete tab_info->delta_vals;
// tab_info->tree_widget was deleted by ui
// tab_info->statistics_label was deleted by ui
rtpstream_info_free_data(&tab_info->stream);
}
int RtpAnalysisDialog::addTabUI(tab_info_t *new_tab)
{
int new_tab_no;
rtpstream_info_calc_t s_calc;
rtpstream_info_calculate(&new_tab->stream, &s_calc);
new_tab->tab_name = new QString(QString("%1:%2 " UTF8_RIGHTWARDS_ARROW "\n%3:%4\n(%5)")
.arg(s_calc.src_addr_str)
.arg(s_calc.src_port)
.arg(s_calc.dst_addr_str)
.arg(s_calc.dst_port)
.arg(int_to_qstring(s_calc.ssrc, 8, 16)));
QWidget *tab = new QWidget();
tab->setProperty("tab_data", QVariant::fromValue((void *)new_tab));
QHBoxLayout *horizontalLayout = new QHBoxLayout(tab);
QVBoxLayout *verticalLayout = new QVBoxLayout();
new_tab->statistics_label = new QLabel();
//new_tab->statistics_label->setStyleSheet("QLabel { color : blue; }");
new_tab->statistics_label->setTextFormat(Qt::RichText);
new_tab->statistics_label->setTextInteractionFlags(Qt::LinksAccessibleByMouse|Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse);
verticalLayout->addWidget(new_tab->statistics_label);
QSpacerItem *verticalSpacer = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding);
verticalLayout->addItem(verticalSpacer);
horizontalLayout->addLayout(verticalLayout);
new_tab->tree_widget = new QTreeWidget();
new_tab->tree_widget->setRootIsDecorated(false);
new_tab->tree_widget->setUniformRowHeights(true);
new_tab->tree_widget->setItemsExpandable(false);
new_tab->tree_widget->setSortingEnabled(true);
new_tab->tree_widget->setExpandsOnDoubleClick(false);
new_tab->tree_widget->installEventFilter(this);
new_tab->tree_widget->setContextMenuPolicy(Qt::CustomContextMenu);
new_tab->tree_widget->header()->setSortIndicator(0, Qt::AscendingOrder);
connect(new_tab->tree_widget, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(showStreamMenu(QPoint)));
connect(new_tab->tree_widget, SIGNAL(itemSelectionChanged()),
this, SLOT(updateWidgets()));
QTreeWidgetItem *ti = new_tab->tree_widget->headerItem();
ti->setText(packet_col_, tr("Packet"));
ti->setText(sequence_col_, tr("Sequence"));
ti->setText(delta_col_, tr("Delta (ms)"));
ti->setText(jitter_col_, tr("Jitter (ms)"));
ti->setText(skew_col_, tr("Skew"));
ti->setText(bandwidth_col_, tr("Bandwidth"));
ti->setText(marker_col_, tr("Marker"));
ti->setText(status_col_, tr("Status"));
QColor color = ColorUtils::graphColor(tab_seq++);
ui->tabWidget->setUpdatesEnabled(false);
horizontalLayout->addWidget(new_tab->tree_widget);
new_tab_no = ui->tabWidget->count() - 1;
// Used when tab contains IPs
//ui->tabWidget->insertTab(new_tab_no, tab, *new_tab->tab_name);
ui->tabWidget->insertTab(new_tab_no, tab, QString(tr("Stream %1")).arg(tab_seq - 1));
ui->tabWidget->tabBar()->setTabTextColor(new_tab_no, color);
ui->tabWidget->tabBar()->setTabToolTip(new_tab_no, *new_tab->tab_name);
ui->tabWidget->setUpdatesEnabled(true);
QPen pen = QPen(color);
QCPScatterStyle jitter_shape;
QCPScatterStyle diff_shape;
QCPScatterStyle delta_shape;
jitter_shape.setShape(QCPScatterStyle::ssCircle);
//jitter_shape.setSize(5);
diff_shape.setShape(QCPScatterStyle::ssCross);
//diff_shape.setSize(5);
delta_shape.setShape(QCPScatterStyle::ssTriangle);
//delta_shape.setSize(5);
new_tab->jitter_graph = ui->streamGraph->addGraph();
new_tab->diff_graph = ui->streamGraph->addGraph();
new_tab->delta_graph = ui->streamGraph->addGraph();
new_tab->jitter_graph->setPen(pen);
new_tab->diff_graph->setPen(pen);
new_tab->delta_graph->setPen(pen);
new_tab->jitter_graph->setScatterStyle(jitter_shape);
new_tab->diff_graph->setScatterStyle(diff_shape);
new_tab->delta_graph->setScatterStyle(delta_shape);
new_tab->graphHorizontalLayout = new QHBoxLayout();
new_tab->stream_checkbox = new QCheckBox(tr("Stream %1").arg(tab_seq - 1), ui->graphTab);
new_tab->stream_checkbox->setChecked(true);
new_tab->stream_checkbox->setIcon(StockIcon::colorIcon(color.rgb(), QPalette::Text));
new_tab->graphHorizontalLayout->addWidget(new_tab->stream_checkbox);
new_tab->graphHorizontalLayout->addItem(new QSpacerItem(10, 5, QSizePolicy::Expanding, QSizePolicy::Minimum));
connect(new_tab->stream_checkbox, SIGNAL(stateChanged(int)),
this, SLOT(rowCheckboxChanged(int)));
new_tab->jitter_checkbox = new QCheckBox(tr("Stream %1 Jitter").arg(tab_seq - 1), ui->graphTab);
new_tab->jitter_checkbox->setChecked(true);
new_tab->jitter_checkbox->setIcon(StockIcon::colorIconCircle(color.rgb(), QPalette::Text));
new_tab->graphHorizontalLayout->addWidget(new_tab->jitter_checkbox);
new_tab->graphHorizontalLayout->addItem(new QSpacerItem(10, 5, QSizePolicy::Expanding, QSizePolicy::Minimum));
connect(new_tab->jitter_checkbox, SIGNAL(stateChanged(int)),
this, SLOT(singleCheckboxChanged(int)));
new_tab->diff_checkbox = new QCheckBox(tr("Stream %1 Difference").arg(tab_seq - 1), ui->graphTab);
new_tab->diff_checkbox->setChecked(true);
new_tab->diff_checkbox->setIcon(StockIcon::colorIconCross(color.rgb(), QPalette::Text));
new_tab->graphHorizontalLayout->addWidget(new_tab->diff_checkbox);
new_tab->graphHorizontalLayout->addItem(new QSpacerItem(10, 5, QSizePolicy::Expanding, QSizePolicy::Minimum));
connect(new_tab->diff_checkbox, SIGNAL(stateChanged(int)),
this, SLOT(singleCheckboxChanged(int)));
new_tab->delta_checkbox = new QCheckBox(tr("Stream %1 Delta").arg(tab_seq - 1), ui->graphTab);
new_tab->delta_checkbox->setChecked(true);
new_tab->delta_checkbox->setIcon(StockIcon::colorIconTriangle(color.rgb(), QPalette::Text));
new_tab->graphHorizontalLayout->addWidget(new_tab->delta_checkbox);
new_tab->graphHorizontalLayout->addItem(new QSpacerItem(10, 5, QSizePolicy::Expanding, QSizePolicy::Minimum));
connect(new_tab->delta_checkbox, SIGNAL(stateChanged(int)),
this, SLOT(singleCheckboxChanged(int)));
new_tab->graphHorizontalLayout->setStretch(6, 1);
ui->layout->addLayout(new_tab->graphHorizontalLayout);
return new_tab_no;
}
// Handles all row checkBoxes
void RtpAnalysisDialog::rowCheckboxChanged(int checked)
{
QObject *obj = sender();
// Find correct tab data
for(int i=0; i<tabs_.count(); i++) {
tab_info_t *tab = tabs_[i];
if (obj == tab->stream_checkbox) {
// Set new state for all checkboxes on row
Qt::CheckState new_state;
if (checked) {
new_state = Qt::Checked;
} else {
new_state = Qt::Unchecked;
}
tab->jitter_checkbox->setCheckState(new_state);
tab->diff_checkbox->setCheckState(new_state);
tab->delta_checkbox->setCheckState(new_state);
break;
}
}
}
// Handles all single CheckBoxes
void RtpAnalysisDialog::singleCheckboxChanged(int checked)
{
QObject *obj = sender();
// Find correct tab data
for(int i=0; i<tabs_.count(); i++) {
tab_info_t *tab = tabs_[i];
if (obj == tab->jitter_checkbox) {
tab->jitter_graph->setVisible(checked);
updateGraph();
break;
} else if (obj == tab->diff_checkbox) {
tab->diff_graph->setVisible(checked);
updateGraph();
break;
} else if (obj == tab->delta_checkbox) {
tab->delta_graph->setVisible(checked);
updateGraph();
break;
}
}
}
void RtpAnalysisDialog::updateWidgets()
{
bool enable_tab = false;
bool enable_nav = false;
QString hint = err_str_;
if ((!file_closed_) &&
(tabs_.count() > 0)) {
enable_tab = true;
}
if ((!file_closed_) &&
(tabs_.count() > 0) &&
(ui->tabWidget->currentIndex() < (ui->tabWidget->count()-1))) {
enable_nav = true;
}
ui->actionGoToPacket->setEnabled(enable_nav);
ui->actionNextProblem->setEnabled(enable_nav);
if (enable_nav) {
hint.append(tr(" %1 streams, ").arg(tabs_.count() - 1));
hint.append(tr(" G: Go to packet, N: Next problem packet"));
}
ui->actionExportButton->setEnabled(enable_tab);
ui->actionSaveOneCsv->setEnabled(enable_nav);
ui->actionSaveAllCsv->setEnabled(enable_tab);
ui->actionSaveGraph->setEnabled(enable_tab);
ui->actionPrepareFilterOne->setEnabled(enable_nav);
ui->actionPrepareFilterAll->setEnabled(enable_tab);
#if defined(QT_MULTIMEDIA_LIB)
player_button_->setEnabled(enable_tab);
#endif
ui->tabWidget->setEnabled(enable_tab);
hint.prepend("<small><i>");
hint.append("</i></small>");
ui->hintLabel->setText(hint);
WiresharkDialog::updateWidgets();
}
void RtpAnalysisDialog::on_actionGoToPacket_triggered()
{
tab_info_t *tab_data = getTabInfoForCurrentTab();
if (!tab_data) return;
QTreeWidget *cur_tree = tab_data->tree_widget;
if (!cur_tree || cur_tree->selectedItems().length() < 1) return;
QTreeWidgetItem *ti = cur_tree->selectedItems()[0];
if (ti->type() != rtp_analysis_type_) return;
RtpAnalysisTreeWidgetItem *ra_ti = dynamic_cast<RtpAnalysisTreeWidgetItem *>((RtpAnalysisTreeWidgetItem *)ti);
emit goToPacket(ra_ti->frameNum());
}
void RtpAnalysisDialog::on_actionNextProblem_triggered()
{
tab_info_t *tab_data = getTabInfoForCurrentTab();
if (!tab_data) return;
QTreeWidget *cur_tree = tab_data->tree_widget;
if (!cur_tree || cur_tree->topLevelItemCount() < 2) return;
// Choose convenience over correctness.
if (cur_tree->selectedItems().length() < 1) {
cur_tree->setCurrentItem(cur_tree->topLevelItem(0));
}
QTreeWidgetItem *sel_ti = cur_tree->selectedItems()[0];
if (sel_ti->type() != rtp_analysis_type_) return;
QTreeWidgetItem *test_ti = cur_tree->itemBelow(sel_ti);
if (!test_ti) test_ti = cur_tree->topLevelItem(0);
while (test_ti != sel_ti) {
RtpAnalysisTreeWidgetItem *ra_ti = dynamic_cast<RtpAnalysisTreeWidgetItem *>((RtpAnalysisTreeWidgetItem *)test_ti);
if (!ra_ti->frameStatus()) {
cur_tree->setCurrentItem(ra_ti);
break;
}
test_ti = cur_tree->itemBelow(test_ti);
if (!test_ti) test_ti = cur_tree->topLevelItem(0);
}
}
void RtpAnalysisDialog::on_actionSaveOneCsv_triggered()
{
saveCsv(dir_one_);
}
void RtpAnalysisDialog::on_actionSaveAllCsv_triggered()
{
saveCsv(dir_all_);
}
void RtpAnalysisDialog::on_actionSaveGraph_triggered()
{
ui->tabWidget->setCurrentWidget(ui->graphTab);
QString file_name, extension;
QDir path(mainApp->lastOpenDir());
QString pdf_filter = tr("Portable Document Format (*.pdf)");
QString png_filter = tr("Portable Network Graphics (*.png)");
QString bmp_filter = tr("Windows Bitmap (*.bmp)");
// Gaze upon my beautiful graph with lossy artifacts!
QString jpeg_filter = tr("JPEG File Interchange Format (*.jpeg *.jpg)");
QString filter = QString("%1;;%2;;%3;;%4")
.arg(pdf_filter)
.arg(png_filter)
.arg(bmp_filter)
.arg(jpeg_filter);
QString save_file = path.canonicalPath();
if (!file_closed_) {
save_file += QString("/%1").arg(cap_file_.fileBaseName());
}
file_name = WiresharkFileDialog::getSaveFileName(this, mainApp->windowTitleString(tr("Save Graph As…")),
save_file, filter, &extension);
if (!file_name.isEmpty()) {
bool save_ok = false;
// https://www.qcustomplot.com/index.php/support/forum/63
// ui->streamGraph->legend->setVisible(true);
if (extension.compare(pdf_filter) == 0) {
save_ok = ui->streamGraph->savePdf(file_name);
} else if (extension.compare(png_filter) == 0) {
save_ok = ui->streamGraph->savePng(file_name);
} else if (extension.compare(bmp_filter) == 0) {
save_ok = ui->streamGraph->saveBmp(file_name);
} else if (extension.compare(jpeg_filter) == 0) {
save_ok = ui->streamGraph->saveJpg(file_name);
}
// ui->streamGraph->legend->setVisible(false);
// else error dialog?
if (save_ok) {
mainApp->setLastOpenDirFromFilename(file_name);
}
}
}
void RtpAnalysisDialog::on_buttonBox_helpRequested()
{
mainApp->helpTopicAction(HELP_TELEPHONY_RTP_ANALYSIS_DIALOG);
}
void RtpAnalysisDialog::tapReset(void *tapinfo_ptr)
{
RtpAnalysisDialog *rtp_analysis_dialog = dynamic_cast<RtpAnalysisDialog *>((RtpAnalysisDialog*)tapinfo_ptr);
if (!rtp_analysis_dialog) return;
rtp_analysis_dialog->resetStatistics();
}
tap_packet_status RtpAnalysisDialog::tapPacket(void *tapinfo_ptr, packet_info *pinfo, epan_dissect_t *, const void *rtpinfo_ptr, tap_flags_t)
{
RtpAnalysisDialog *rtp_analysis_dialog = dynamic_cast<RtpAnalysisDialog *>((RtpAnalysisDialog*)tapinfo_ptr);
if (!rtp_analysis_dialog) return TAP_PACKET_DONT_REDRAW;
const struct _rtp_info *rtpinfo = (const struct _rtp_info *)rtpinfo_ptr;
if (!rtpinfo) return TAP_PACKET_DONT_REDRAW;
/* we ignore packets that are not displayed */
if (pinfo->fd->passed_dfilter == 0)
return TAP_PACKET_DONT_REDRAW;
/* also ignore RTP Version != 2 */
else if (rtpinfo->info_version != 2)
return TAP_PACKET_DONT_REDRAW;
/* is it the forward direction? */
else {
// Search tab in hash key, if there are multiple tabs with same hash
QList<tab_info_t *> tabs = rtp_analysis_dialog->tab_hash_.values(pinfo_rtp_info_to_hash(pinfo, rtpinfo));
for (int i = 0; i < tabs.size(); i++) {
tab_info_t *tab = tabs.at(i);
if (rtpstream_id_equal_pinfo_rtp_info(&tab->stream.id, pinfo, rtpinfo)) {
rtp_analysis_dialog->addPacket(tab, pinfo, rtpinfo);
break;
}
}
}
return TAP_PACKET_DONT_REDRAW;
}
void RtpAnalysisDialog::tapDraw(void *tapinfo_ptr)
{
RtpAnalysisDialog *rtp_analysis_dialog = dynamic_cast<RtpAnalysisDialog *>((RtpAnalysisDialog*)tapinfo_ptr);
if (!rtp_analysis_dialog) return;
rtp_analysis_dialog->updateStatistics();
}
void RtpAnalysisDialog::resetStatistics()
{
for(int i=0; i<tabs_.count(); i++) {
tab_info_t *tab = tabs_[i];
memset(&tab->stream.rtp_stats, 0, sizeof(tab->stream.rtp_stats));
tab->stream.rtp_stats.first_packet = true;
tab->stream.rtp_stats.reg_pt = PT_UNDEFINED;
tab->time_vals->clear();
tab->jitter_vals->clear();
tab->diff_vals->clear();
tab->delta_vals->clear();
tab->tree_widget->clear();
}
for (int i = 0; i < ui->streamGraph->graphCount(); i++) {
ui->streamGraph->graph(i)->data()->clear();
}
}
void RtpAnalysisDialog::addPacket(tab_info_t *tab, packet_info *pinfo, const _rtp_info *rtpinfo)
{
rtpstream_info_analyse_process(&tab->stream, pinfo, rtpinfo);
new RtpAnalysisTreeWidgetItem(tab->tree_widget, &tab->stream.rtp_stats, pinfo, rtpinfo);
tab->time_vals->append(tab->stream.rtp_stats.time / 1000);
tab->jitter_vals->append(tab->stream.rtp_stats.jitter);
tab->diff_vals->append(tab->stream.rtp_stats.diff);
tab->delta_vals->append(tab->stream.rtp_stats.delta);
}
void RtpAnalysisDialog::updateStatistics()
{
for(int i=0; i<tabs_.count(); i++) {
rtpstream_info_t *stream = &tabs_[i]->stream;
rtpstream_info_calc_t s_calc;
rtpstream_info_calculate(stream, &s_calc);
QString stats_tables = "<html><head><style>td{vertical-align:bottom;}</style></head><body>\n";
stats_tables += "<h4>Stream</h4>\n";
stats_tables += QString("<p>%1:%2 " UTF8_RIGHTWARDS_ARROW)
.arg(s_calc.src_addr_str)
.arg(s_calc.src_port);
stats_tables += QString("<br>%1:%2</p>\n")
.arg(s_calc.dst_addr_str)
.arg(s_calc.dst_port);
stats_tables += "<p><table>\n";
stats_tables += QString("<tr><th align=\"left\">SSRC</th><td>%1</td></tr>")
.arg(int_to_qstring(s_calc.ssrc, 8, 16));
stats_tables += QString("<tr><th align=\"left\">Max Delta</th><td>%1 ms @ %2</td></tr>")
.arg(s_calc.max_delta, 0, 'f', prefs.gui_decimal_places3)
.arg(s_calc.last_packet_num);
stats_tables += QString("<tr><th align=\"left\">Max Jitter</th><td>%1 ms</td></tr>")
.arg(s_calc.max_jitter, 0, 'f', prefs.gui_decimal_places3);
stats_tables += QString("<tr><th align=\"left\">Mean Jitter</th><td>%1 ms</td></tr>")
.arg(s_calc.mean_jitter, 0, 'f', prefs.gui_decimal_places3);
stats_tables += QString("<tr><th align=\"left\">Max Skew</th><td>%1 ms</td></tr>")
.arg(s_calc.max_skew, 0, 'f', prefs.gui_decimal_places3);
stats_tables += QString("<tr><th align=\"left\">RTP Packets</th><td>%1</td></tr>")
.arg(s_calc.total_nr);
stats_tables += QString("<tr><th align=\"left\">Expected</th><td>%1</td></tr>")
.arg(s_calc.packet_expected);
stats_tables += QString("<tr><th align=\"left\">Lost</th><td>%1 (%2 %)</td></tr>")
.arg(s_calc.lost_num).arg(s_calc.lost_perc, 0, 'f', prefs.gui_decimal_places1);
stats_tables += QString("<tr><th align=\"left\">Seq Errs</th><td>%1</td></tr>")
.arg(s_calc.sequence_err);
stats_tables += QString("<tr><th align=\"left\">Start at</th><td>%1 s @ %2</td></tr>")
.arg(s_calc.start_time_ms, 0, 'f', 6)
.arg(s_calc.first_packet_num);
stats_tables += QString("<tr><th align=\"left\">Duration</th><td>%1 s</td></tr>")
.arg(s_calc.duration_ms, 0, 'f', prefs.gui_decimal_places1);
stats_tables += QString("<tr><th align=\"left\">Clock Drift</th><td>%1 ms</td></tr>")
.arg(s_calc.clock_drift_ms, 0, 'f', 0);
stats_tables += QString("<tr><th align=\"left\">Freq Drift</th><td>%1 Hz (%2 %)</td></tr>") // XXX Terminology?
.arg(s_calc.freq_drift_hz, 0, 'f', 0).arg(s_calc.freq_drift_perc, 0, 'f', 2);
stats_tables += "</table></p>\n";
tabs_[i]->statistics_label->setText(stats_tables);
for (int col = 0; col < tabs_[i]->tree_widget->columnCount() - 1; col++) {
tabs_[i]->tree_widget->resizeColumnToContents(col);
}
tabs_[i]->jitter_graph->setData(*tabs_[i]->time_vals, *tabs_[i]->jitter_vals);
tabs_[i]->diff_graph->setData(*tabs_[i]->time_vals, *tabs_[i]->diff_vals);
tabs_[i]->delta_graph->setData(*tabs_[i]->time_vals, *tabs_[i]->delta_vals);
}
updateGraph();
updateWidgets();
}
void RtpAnalysisDialog::updateGraph()
{
for (int i = 0; i < ui->streamGraph->graphCount(); i++) {
if (ui->streamGraph->graph(i)->visible()) {
ui->streamGraph->graph(i)->rescaleAxes(i > 0);
}
}
ui->streamGraph->replot();
}
QVector<rtpstream_id_t *>RtpAnalysisDialog::getSelectedRtpIds()
{
QVector<rtpstream_id_t *> stream_ids;
for(int i=0; i < tabs_.count(); i++) {
stream_ids << &(tabs_[i]->stream.id);
}
return stream_ids;
}
void RtpAnalysisDialog::rtpPlayerReplace()
{
if (tabs_.count() < 1) return;
emit rtpPlayerDialogReplaceRtpStreams(getSelectedRtpIds());
}
void RtpAnalysisDialog::rtpPlayerAdd()
{
if (tabs_.count() < 1) return;
emit rtpPlayerDialogAddRtpStreams(getSelectedRtpIds());
}
void RtpAnalysisDialog::rtpPlayerRemove()
{
if (tabs_.count() < 1) return;
emit rtpPlayerDialogRemoveRtpStreams(getSelectedRtpIds());
}
void RtpAnalysisDialog::saveCsvHeader(QFile *save_file, QTreeWidget *tree)
{
QList<QVariant> row_data;
QStringList values;
for (int col = 0; col < tree->columnCount(); col++) {
row_data << tree->headerItem()->text(col);
}
foreach (QVariant v, row_data) {
if (!v.isValid()) {
values << "\"\"";
} else if (v.userType() == QMetaType::QString) {
values << QString("\"%1\"").arg(v.toString());
} else {
values << v.toString();
}
}
save_file->write(values.join(",").toUtf8());
save_file->write("\n");
}
void RtpAnalysisDialog::saveCsvData(QFile *save_file, QTreeWidget *tree)
{
for (int row = 0; row < tree->topLevelItemCount(); row++) {
QTreeWidgetItem *ti = tree->topLevelItem(row);
if (ti->type() != rtp_analysis_type_) continue;
RtpAnalysisTreeWidgetItem *ra_ti = dynamic_cast<RtpAnalysisTreeWidgetItem *>((RtpAnalysisTreeWidgetItem *)ti);
QStringList values;
foreach (QVariant v, ra_ti->rowData()) {
if (!v.isValid()) {
values << "\"\"";
} else if (v.userType() == QMetaType::QString) {
values << QString("\"%1\"").arg(v.toString());
} else {
values << v.toString();
}
}
save_file->write(values.join(",").toUtf8());
save_file->write("\n");
}
}
// XXX The GTK+ UI saves the length and timestamp.
void RtpAnalysisDialog::saveCsv(RtpAnalysisDialog::StreamDirection direction)
{
QString caption;
switch (direction) {
case dir_one_:
caption = tr("Save one stream CSV");
break;
case dir_all_:
default:
caption = tr("Save all stream's CSV");
break;
}
QString file_path = WiresharkFileDialog::getSaveFileName(
this, caption, mainApp->lastOpenDir().absoluteFilePath("RTP Packet Data.csv"),
tr("Comma-separated values (*.csv)"));
if (file_path.isEmpty()) return;
QFile save_file(file_path);
save_file.open(QFile::WriteOnly);
switch (direction) {
case dir_one_:
{
tab_info_t *tab_data = getTabInfoForCurrentTab();
if (tab_data) {
saveCsvHeader(&save_file, tab_data->tree_widget);
QString n = QString(*tab_data->tab_name);
n.replace("\n"," ");
save_file.write("\"");
save_file.write(n.toUtf8());
save_file.write("\"\n");
saveCsvData(&save_file, tab_data->tree_widget);
}
}
break;
case dir_all_:
default:
if (tabs_.count() > 0) {
saveCsvHeader(&save_file, tabs_[0]->tree_widget);
}
for(int i=0; i<tabs_.count(); i++) {
QString n = QString(*tabs_[i]->tab_name);
n.replace("\n"," ");
save_file.write("\"");
save_file.write(n.toUtf8());
save_file.write("\"\n");
saveCsvData(&save_file, tabs_[i]->tree_widget);
save_file.write("\n");
}
break;
}
}
bool RtpAnalysisDialog::eventFilter(QObject *, QEvent *event)
{
if (event->type() != QEvent::KeyPress) return false;
QKeyEvent *kevt = static_cast<QKeyEvent *>(event);
switch(kevt->key()) {
case Qt::Key_G:
on_actionGoToPacket_triggered();
return true;
case Qt::Key_N:
on_actionNextProblem_triggered();
return true;
default:
break;
}
return false;
}
void RtpAnalysisDialog::graphClicked(QMouseEvent *event)
{
updateWidgets();
if (event->button() == Qt::RightButton) {
#if QT_VERSION >= QT_VERSION_CHECK(6, 0 ,0)
graph_ctx_menu_.popup(event->globalPosition().toPoint());
#else
graph_ctx_menu_.popup(event->globalPos());
#endif
}
}
void RtpAnalysisDialog::clearLayout(QLayout *layout)
{
if (layout) {
QLayoutItem *item;
//the key point here is that the layout items are stored inside the layout in a stack
while((item = layout->takeAt(0)) != 0) {
if (item->widget()) {
layout->removeWidget(item->widget());
delete item->widget();
}
delete item;
}
}
}
void RtpAnalysisDialog::closeTab(int index)
{
// Do not close last tab with graph
if (index != tabs_.count()) {
QWidget *remove_tab = qobject_cast<QWidget *>(ui->tabWidget->widget(index));
tab_info_t *tab = tabs_[index];
tab_hash_.remove(rtpstream_to_hash(&tab->stream), tab);
tabs_.remove(index);
ui->tabWidget->removeTab(index);
ui->streamGraph->removeGraph(tab->jitter_graph);
ui->streamGraph->removeGraph(tab->diff_graph);
ui->streamGraph->removeGraph(tab->delta_graph);
clearLayout(tab->graphHorizontalLayout);
delete remove_tab;
deleteTabInfo(tab);
g_free(tab);
updateGraph();
}
}
void RtpAnalysisDialog::showStreamMenu(QPoint pos)
{
tab_info_t *tab_data = getTabInfoForCurrentTab();
if (!tab_data) return;
QTreeWidget *cur_tree = tab_data->tree_widget;
if (!cur_tree) return;
updateWidgets();
stream_ctx_menu_.popup(cur_tree->viewport()->mapToGlobal(pos));
}
void RtpAnalysisDialog::replaceRtpStreams(QVector<rtpstream_id_t *> stream_ids)
{
std::unique_lock<std::mutex> lock(run_mutex_, std::try_to_lock);
if (lock.owns_lock()) {
// Delete existing tabs (from last to first)
if (tabs_.count() > 0) {
for(int i = static_cast<int>(tabs_.count()); i>0; i--) {
closeTab(i-1);
}
}
addRtpStreamsPrivate(stream_ids);
} else {
ws_warning("replaceRtpStreams was called while other thread locked it. Current call is ignored, try it later.");
}
}
void RtpAnalysisDialog::addRtpStreams(QVector<rtpstream_id_t *> stream_ids)
{
std::unique_lock<std::mutex> lock(run_mutex_, std::try_to_lock);
if (lock.owns_lock()) {
addRtpStreamsPrivate(stream_ids);
} else {
ws_warning("addRtpStreams was called while other thread locked it. Current call is ignored, try it later.");
}
}
void RtpAnalysisDialog::addRtpStreamsPrivate(QVector<rtpstream_id_t *> stream_ids)
{
int first_tab_no = -1;
setUpdatesEnabled(false);
foreach(rtpstream_id_t *id, stream_ids) {
bool found = false;
QList<tab_info_t *> tabs = tab_hash_.values(rtpstream_id_to_hash(id));
for (int i = 0; i < tabs.size(); i++) {
tab_info_t *tab = tabs.at(i);
if (rtpstream_id_equal(&tab->stream.id, id, RTPSTREAM_ID_EQUAL_SSRC)) {
found = true;
break;
}
}
if (!found) {
int cur_tab_no;
tab_info_t *new_tab = g_new0(tab_info_t, 1);
rtpstream_id_copy(id, &(new_tab->stream.id));
new_tab->time_vals = new QVector<double>();
new_tab->jitter_vals = new QVector<double>();
new_tab->diff_vals = new QVector<double>();
new_tab->delta_vals = new QVector<double>();
tabs_ << new_tab;
cur_tab_no = addTabUI(new_tab);
tab_hash_.insert(rtpstream_id_to_hash(id), new_tab);
if (first_tab_no == -1) {
first_tab_no = cur_tab_no;
}
}
}
if (first_tab_no != -1) {
ui->tabWidget->setCurrentIndex(first_tab_no);
}
setUpdatesEnabled(true);
registerTapListener("rtp", this, NULL, 0, tapReset, tapPacket, tapDraw);
cap_file_.retapPackets();
updateStatistics();
removeTapListeners();
updateGraph();
}
void RtpAnalysisDialog::removeRtpStreams(QVector<rtpstream_id_t *> stream_ids)
{
std::unique_lock<std::mutex> lock(run_mutex_, std::try_to_lock);
if (lock.owns_lock()) {
setUpdatesEnabled(false);
foreach(rtpstream_id_t *id, stream_ids) {
QList<tab_info_t *> tabs = tab_hash_.values(rtpstream_id_to_hash(id));
for (int i = 0; i < tabs.size(); i++) {
tab_info_t *tab = tabs.at(i);
if (rtpstream_id_equal(&tab->stream.id, id, RTPSTREAM_ID_EQUAL_SSRC)) {
closeTab(static_cast<int>(tabs_.indexOf(tab)));
}
}
}
setUpdatesEnabled(true);
updateGraph();
} else {
ws_warning("removeRtpStreams was called while other thread locked it. Current call is ignored, try it later.");
}
}
tab_info_t *RtpAnalysisDialog::getTabInfoForCurrentTab()
{
tab_info_t *tab_data;
if (file_closed_) return NULL;
QWidget *cur_tab = qobject_cast<QWidget *>(ui->tabWidget->currentWidget());
if (!cur_tab) return NULL;
tab_data = static_cast<tab_info_t *>(cur_tab->property("tab_data").value<void*>());
return tab_data;
}
QToolButton *RtpAnalysisDialog::addAnalyzeButton(QDialogButtonBox *button_box, QDialog *dialog)
{
if (!button_box) return NULL;
QAction *ca;
QToolButton *analysis_button = new QToolButton();
button_box->addButton(analysis_button, QDialogButtonBox::ActionRole);
analysis_button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
analysis_button->setPopupMode(QToolButton::MenuButtonPopup);
ca = new QAction(tr("&Analyze"));
ca->setToolTip(tr("Open the analysis window for the selected stream(s)"));
connect(ca, SIGNAL(triggered()), dialog, SLOT(rtpAnalysisReplace()));
analysis_button->setDefaultAction(ca);
// Overrides text striping of shortcut undercode in QAction
analysis_button->setText(ca->text());
QMenu *button_menu = new QMenu(analysis_button);
button_menu->setToolTipsVisible(true);
ca = button_menu->addAction(tr("&Set List"));
ca->setToolTip(tr("Replace existing list in RTP Analysis Dialog with new one"));
connect(ca, SIGNAL(triggered()), dialog, SLOT(rtpAnalysisReplace()));
ca = button_menu->addAction(tr("&Add to List"));
ca->setToolTip(tr("Add new set to existing list in RTP Analysis Dialog"));
connect(ca, SIGNAL(triggered()), dialog, SLOT(rtpAnalysisAdd()));
ca = button_menu->addAction(tr("&Remove from List"));
ca->setToolTip(tr("Remove selected streams from list in RTP Analysis Dialog"));
connect(ca, SIGNAL(triggered()), dialog, SLOT(rtpAnalysisRemove()));
analysis_button->setMenu(button_menu);
return analysis_button;
}
void RtpAnalysisDialog::on_actionPrepareFilterOne_triggered()
{
if ((ui->tabWidget->currentIndex() < (ui->tabWidget->count()-1))) {
QVector<rtpstream_id_t *> ids;
ids << &(tabs_[ui->tabWidget->currentIndex()]->stream.id);
QString filter = make_filter_based_on_rtpstream_id(ids);
if (filter.length() > 0) {
emit updateFilter(filter);
}
}
}
void RtpAnalysisDialog::on_actionPrepareFilterAll_triggered()
{
QVector<rtpstream_id_t *>ids = getSelectedRtpIds();
QString filter = make_filter_based_on_rtpstream_id(ids);
if (filter.length() > 0) {
emit updateFilter(filter);
}
}
Reference in New Issue View Git Blame Copy Permalink