28 files changed, 2183 insertions, 60 deletions

diff --git a/epan/proto.c b/epan/proto.c
index 449e1c5995..447b8c2950 100644
--- a/epan/proto.c
+++ b/epan/proto.c
@@ -5417,7 +5417,8 @@ proto_get_protocol_filter_name(const int proto_id)
 void
 proto_get_frame_protocols(const wmem_list_t *layers, gboolean *is_ip,
 			  gboolean *is_tcp, gboolean *is_udp,
-			  gboolean *is_sctp, gboolean *is_ssl)
+			  gboolean *is_sctp, gboolean *is_ssl,
+			  gboolean *is_rtp)
 {
 	wmem_list_frame_t *protos = wmem_list_head(layers);
 	int	    proto_id;
@@ -5442,6 +5443,8 @@ proto_get_frame_protocols(const wmem_list_t *layers, gboolean *is_ip,
 			*is_sctp = TRUE;
 		} else if (is_ssl && !strcmp(proto_name, "ssl")) {
 			*is_ssl = TRUE;
+		} else if (is_rtp && !strcmp(proto_name, "rtp")) {
+			*is_rtp = TRUE;
 		}
 
 		protos = wmem_list_frame_next(protos);
diff --git a/epan/proto.h b/epan/proto.h
index fd9b295073..102ed0fdb8 100644
--- a/epan/proto.h
+++ b/epan/proto.h
@@ -2170,7 +2170,8 @@ WS_DLL_PUBLIC const char *proto_get_protocol_filter_name(const int proto_id);
  * unchanged. May be NULL.
  */
 WS_DLL_PUBLIC void proto_get_frame_protocols(const wmem_list_t *layers,
-      gboolean *is_ip, gboolean *is_tcp, gboolean *is_udp, gboolean *is_sctp, gboolean *is_ssl);
+      gboolean *is_ip, gboolean *is_tcp, gboolean *is_udp, gboolean *is_sctp,
+      gboolean *is_ssl, gboolean *is_rtp);
 
 /** Find a protocol by name in a layer list.
  * @param layers Protocol layer list
diff --git a/ui/gtk/main_menubar.c b/ui/gtk/main_menubar.c
index 81c3cfb59a..8b61697328 100644
--- a/ui/gtk/main_menubar.c
+++ b/ui/gtk/main_menubar.c
@@ -4573,7 +4573,7 @@ set_menus_for_selected_packet(capture_file *cf)
            than one time reference frame or the current frame isn't a
            time reference frame). (XXX - why check frame_selected?) */
     if (cf->edt)
-        proto_get_frame_protocols(cf->edt->pi.layers, &is_ip, &is_tcp, &is_udp, &is_sctp, &is_ssl);
+        proto_get_frame_protocols(cf->edt->pi.layers, &is_ip, &is_tcp, &is_udp, &is_sctp, &is_ssl, NULL);
 
     if (cf->edt && cf->edt->tree) {
         GPtrArray          *ga;
diff --git a/ui/gtk/rtp_analysis.c b/ui/gtk/rtp_analysis.c
index 02d3014029..e33e25932f 100644
--- a/ui/gtk/rtp_analysis.c
+++ b/ui/gtk/rtp_analysis.c
@@ -484,7 +484,7 @@ static int rtp_packet_save_payload(tap_rtp_save_info_t *saveinfo,
 
 /****************************************************************************/
 /* whenever a RTP packet is seen by the tap listener */
-static int
+static gboolean
 rtp_packet(void *user_data_arg, packet_info *pinfo, epan_dissect_t *edt _U_, const void *rtpinfo_arg)
 {
 	user_data_t	       *user_data    = (user_data_t *)user_data_arg;
@@ -493,10 +493,10 @@ rtp_packet(void *user_data_arg, packet_info *pinfo, epan_dissect_t *edt _U_, con
 
 	/* we ignore packets that are not displayed */
 	if (pinfo->fd->flags.passed_dfilter == 0)
-		return 0;
+		return FALSE;
 	/* also ignore RTP Version != 2 */
 	else if (rtpinfo->info_version != 2)
-		return 0;
+		return FALSE;
 	/* is it the forward direction?  */
 	else if (user_data->ssrc_fwd == rtpinfo->info_sync_src
 		 && (CMP_ADDRESS(&(user_data->src_fwd), &(pinfo->src)) == 0)
@@ -548,7 +548,7 @@ rtp_packet(void *user_data_arg, packet_info *pinfo, epan_dissect_t *edt _U_, con
 #endif
 	}
 
-	return 0;
+	return FALSE;
 }
 
 /*
@@ -606,7 +606,7 @@ rtp_packet_add_info(GtkWidget *list, user_data_t * user_data,
 		g_snprintf(color_str, sizeof(color_str), "#ffffbfffbfff");
 	}
 	else if (statinfo->flags & STAT_FLAG_DUP_PKT) {
-		g_snprintf(status, sizeof(status), "Suspected duplicate(MAC address) only delta time calculated");
+		g_snprintf(status, sizeof(status), "Suspected duplicate (MAC address) only delta time calculated");
 		/* color = Yellow; */
 		g_snprintf(color_str, sizeof(color_str), "#ffffffff0000");
 	}
@@ -3212,7 +3212,7 @@ draw_stat(user_data_t *user_data)
 		user_data->forward.statinfo.max_delta, user_data->forward.statinfo.max_nr,
 		user_data->forward.statinfo.max_jitter, user_data->forward.statinfo.mean_jitter,
 		user_data->forward.statinfo.max_skew,
-		f_expected, f_expected, f_lost, f_perc,
+		f_total_nr, f_expected, f_lost, f_perc,
 		user_data->forward.statinfo.sequence,
 		f_duration / 1000,
 		f_duration * (f_clock_drift - 1.0),
@@ -3231,7 +3231,7 @@ draw_stat(user_data_t *user_data)
 		user_data->reversed.statinfo.max_delta, user_data->reversed.statinfo.max_nr,
 		user_data->reversed.statinfo.max_jitter, user_data->reversed.statinfo.mean_jitter,
 		user_data->reversed.statinfo.max_skew,
-		r_expected, r_expected, r_lost, r_perc,
+		r_total_nr, r_expected, r_lost, r_perc,
 		user_data->reversed.statinfo.sequence,
 		r_duration / 1000,
 		r_duration * (r_clock_drift - 1.0),
@@ -3543,9 +3543,9 @@ create_rtp_dialog(user_data_t* user_data)
 	GtkWidget *player_bt;
 #endif /* HAVE_LIBPORTAUDIO */
 	GtkWidget *graph_bt;
-	gchar	   label_forward[150];
-	gchar	   label_forward_tree[150];
-	gchar	   label_reverse[150];
+	gchar	   label_forward[200];
+	gchar	   label_forward_tree[200];
+	gchar	   label_reverse[200];
 	char *src_addr, *dst_addr;
 
 	window = dlg_window_new("Wireshark: RTP Stream Analysis");  /* transient_for top_level */
@@ -3566,7 +3566,7 @@ create_rtp_dialog(user_data_t* user_data)
 
 	g_snprintf(label_forward_tree, sizeof(label_forward_tree),
 		"Analysing stream from  %s port %u  to  %s port %u   SSRC = 0x%X \n"
-		"Note many things affects the accurasy of the analysis, use with caution",
+		"Note many things affects the accuracy of the analysis, use with caution",
 		src_addr, user_data->port_src_fwd, dst_addr, user_data->port_dst_fwd, user_data->ssrc_fwd);
 	wmem_free(NULL, src_addr);
 	wmem_free(NULL, dst_addr);
@@ -3575,7 +3575,7 @@ create_rtp_dialog(user_data_t* user_data)
 	dst_addr = (char*)address_to_display(NULL, &(user_data->dst_rev));
 	g_snprintf(label_reverse, sizeof(label_reverse),
 		"Analysing stream from  %s port %u  to  %s port %u   SSRC = 0x%X \n"
-		"Note many things affects the accurasy of the analysis, use with caution",
+		"Note many things affects the accuracy of the analysis, use with caution",
 		src_addr, user_data->port_src_rev, dst_addr, user_data->port_dst_rev, user_data->ssrc_rev);
 	wmem_free(NULL, src_addr);
 	wmem_free(NULL, dst_addr);
@@ -3931,7 +3931,7 @@ rtp_analysis_cb(GtkAction *action _U_, gpointer user_data _U_)
 	guint32	      ssrc_rev	    = 0;
 	unsigned int  version_fwd;
 
-	gchar	      filter_text[256];
+	const gchar  *filter_text = "rtp && rtp.version && rtp.ssrc && (ip || ipv6)";
 	dfilter_t    *sfcode;
 	gchar        *err_msg;
 	capture_file *cf;
@@ -3943,7 +3943,6 @@ rtp_analysis_cb(GtkAction *action _U_, gpointer user_data _U_)
 	rtp_stream_info_t *strinfo;
 
 	/* Try to compile the filter. */
-	g_strlcpy(filter_text, "rtp && rtp.version && rtp.ssrc && (ip || ipv6)", sizeof(filter_text));
 	if (!dfilter_compile(filter_text, &sfcode, &err_msg)) {
 		simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_msg);
 		g_free(err_msg);
diff --git a/ui/qt/CMakeLists.txt b/ui/qt/CMakeLists.txt
index 9ef86b7ba1..35b2d2e2f4 100644
--- a/ui/qt/CMakeLists.txt
+++ b/ui/qt/CMakeLists.txt
@@ -99,6 +99,7 @@ set(WIRESHARK_QT_HEADERS
 	related_packet_delegate.h
 	resolved_addresses_dialog.h
 	response_time_delay_dialog.h
+	rtp_analysis_dialog.h
 	rtp_stream_dialog.h
 	sctp_all_assocs_dialog.h
 	sctp_assoc_analyse_dialog.h
@@ -225,6 +226,7 @@ set(WIRESHARK_QT_SRC
 	related_packet_delegate.cpp
 	resolved_addresses_dialog.cpp
 	response_time_delay_dialog.cpp
+	rtp_analysis_dialog.cpp
 	rtp_stream_dialog.cpp
 	sctp_all_assocs_dialog.cpp
 	sctp_assoc_analyse_dialog.cpp
@@ -329,6 +331,7 @@ set(WIRESHARK_QT_UI
 	profile_dialog.ui
 	protocol_hierarchy_dialog.ui
 	resolved_addresses_dialog.ui
+	rtp_analysis_dialog.ui
 	rtp_stream_dialog.ui
 	sctp_all_assocs_dialog.ui
 	sctp_assoc_analyse_dialog.ui
diff --git a/ui/qt/Makefile.am b/ui/qt/Makefile.am
index befd4669ba..0f045e182d 100644
--- a/ui/qt/Makefile.am
+++ b/ui/qt/Makefile.am
@@ -216,6 +216,10 @@ preferences_dialog.$(OBJEXT): ui_preferences_dialog.h
 
 print_dialog.$(OBJEXT): ui_print_dialog.h
 
+rtp_analysis_dialog.$(OBJEXT): ui_rtp_analysis_dialog.h
+
+rtp_stream_dialog.$(OBJEXT): ui_rtp_stream_dialog.h
+
 profile_dialog.$(OBJEXT): ui_profile_dialog.h
 
 protocol_hierarchy_dialog.$(OBJEXT): ui_protocol_hierarchy_dialog.h
diff --git a/ui/qt/Makefile.common b/ui/qt/Makefile.common
index 6116ad444e..c1a7479e54 100644
--- a/ui/qt/Makefile.common
+++ b/ui/qt/Makefile.common
@@ -77,6 +77,7 @@ NODIST_GENERATED_HEADER_FILES =	\
 	ui_remote_capture_dialog.h	\
 	ui_remote_settings_dialog.h	\
 	ui_resolved_addresses_dialog.h	\
+	ui_rtp_analysis_dialog.h	\
 	ui_rtp_stream_dialog.h	\
 	ui_sctp_all_assocs_dialog.h	\
 	ui_sctp_assoc_analyse_dialog.h	\
@@ -210,6 +211,7 @@ MOC_HDRS =	\
 	resolved_addresses_dialog.h	\
 	response_time_delay_dialog.h	\
 	search_frame.h	\
+	rtp_analysis_dialog.h	\
 	rtp_stream_dialog.h	\
 	sctp_all_assocs_dialog.h	\
 	sctp_assoc_analyse_dialog.h	\
@@ -289,6 +291,7 @@ UI_FILES =	\
 	remote_capture_dialog.ui	\
 	remote_settings_dialog.ui	\
 	resolved_addresses_dialog.ui	\
+	rtp_analysis_dialog.ui	\
 	rtp_stream_dialog.ui	\
 	sctp_all_assocs_dialog.ui	\
 	sctp_assoc_analyse_dialog.ui	\
@@ -440,6 +443,7 @@ WIRESHARK_QT_SRC =	\
 	remote_settings_dialog.cpp	\
 	resolved_addresses_dialog.cpp	\
 	response_time_delay_dialog.cpp	\
+	rtp_analysis_dialog.cpp	\
 	rtp_stream_dialog.cpp	\
 	sctp_all_assocs_dialog.cpp	\
 	sctp_assoc_analyse_dialog.cpp	\
diff --git a/ui/qt/Wireshark.pro b/ui/qt/Wireshark.pro
index 3d6c373eaa..3aadf34e63 100644
--- a/ui/qt/Wireshark.pro
+++ b/ui/qt/Wireshark.pro
@@ -253,6 +253,7 @@ FORMS += \
     remote_capture_dialog.ui  \
     remote_settings_dialog.ui  \
     resolved_addresses_dialog.ui \
+    rtp_analysis_dialog.ui   \
     rtp_stream_dialog.ui   \
     sctp_all_assocs_dialog.ui   \
     sctp_assoc_analyse_dialog.ui \
@@ -325,6 +326,7 @@ HEADERS += $$HEADERS_WS_C \
     remote_capture_dialog.h  \
     remote_settings_dialog.h    \
     resolved_addresses_dialog.h \
+    rtp_analysis_dialog.h  \
     rtp_stream_dialog.h  \
     sctp_all_assocs_dialog.h  \
     sctp_assoc_analyse_dialog.h \
@@ -712,6 +714,7 @@ SOURCES += \
     remote_settings_dialog.cpp \
     response_time_delay_dialog.cpp \
     resolved_addresses_dialog.cpp \
+    rtp_analysis_dialog.cpp  \
     rtp_stream_dialog.cpp  \
     sctp_all_assocs_dialog.cpp  \
     sctp_assoc_analyse_dialog.cpp \
diff --git a/ui/qt/color_utils.cpp b/ui/qt/color_utils.cpp
index 70babce6e8..f63b2a0378 100644
--- a/ui/qt/color_utils.cpp
+++ b/ui/qt/color_utils.cpp
@@ -19,9 +19,9 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-
 #include "color_utils.h"
 
+#include "tango_colors.h"
 
 /*
  * Initialize a color with R, G, and B values, including any toolkit-dependent
@@ -53,6 +53,24 @@ const QColor ColorUtils::expert_color_error      = QColor ( 0xff, 0x5c, 0x5c );
 const QColor ColorUtils::expert_color_foreground = QColor ( 0x00, 0x00, 0x00 );        /* Black */
 const QColor ColorUtils::hidden_proto_item       = QColor ( 0x44, 0x44, 0x44 );        /* Gray */
 
+// Available colors
+// XXX - Add custom
+const QList<QRgb> ColorUtils::graph_colors_ = QList<QRgb>()
+        << tango_aluminium_6 // Bar outline (use black instead)?
+        << tango_sky_blue_5
+        << tango_butter_6
+        << tango_chameleon_5
+        << tango_scarlet_red_5
+        << tango_plum_5
+        << tango_orange_6
+        << tango_aluminium_3
+        << tango_sky_blue_3
+        << tango_butter_3
+        << tango_chameleon_3
+        << tango_scarlet_red_3
+        << tango_plum_3
+        << tango_orange_3;
+
 ColorUtils::ColorUtils(QObject *parent) :
     QObject(parent)
 {
diff --git a/ui/qt/color_utils.h b/ui/qt/color_utils.h
index 5626f1c5a5..a263f76d23 100644
--- a/ui/qt/color_utils.h
+++ b/ui/qt/color_utils.h
@@ -53,6 +53,7 @@ public:
     static const QColor expert_color_foreground; /* black */
     static const QColor hidden_proto_item;       /* gray */
 
+    static const QList<QRgb> graph_colors_;
 signals:
 
 public slots:
diff --git a/ui/qt/follow_stream_dialog.cpp b/ui/qt/follow_stream_dialog.cpp
index 84a8e1983a..d75a0b2f91 100644
--- a/ui/qt/follow_stream_dialog.cpp
+++ b/ui/qt/follow_stream_dialog.cpp
@@ -855,7 +855,7 @@ bool FollowStreamDialog::follow(QString previous_filter, bool use_stream_index)
         return false;
     }
 
-    proto_get_frame_protocols(cap_file_.capFile()->edt->pi.layers, NULL, &is_tcp, &is_udp, NULL, NULL);
+    proto_get_frame_protocols(cap_file_.capFile()->edt->pi.layers, NULL, &is_tcp, &is_udp, NULL, NULL, NULL);
 
     switch (follow_type_)
     {
diff --git a/ui/qt/io_graph_dialog.cpp b/ui/qt/io_graph_dialog.cpp
index 222163fd88..e5da5255e4 100644
--- a/ui/qt/io_graph_dialog.cpp
+++ b/ui/qt/io_graph_dialog.cpp
@@ -31,8 +31,8 @@
 #include "ui/utf8_entities.h"
 
 #include "qt_ui_utils.h"
-#include "tango_colors.h"
 
+#include "color_utils.h"
 #include "qcustomplot.h"
 #include "stock_icon.h"
 #include "syntax_line_edit.h"
@@ -78,21 +78,7 @@ const int num_cols_ = 7;
 
 // Available colors
 // XXX - Add custom
-QList<QRgb> colors_ = QList<QRgb>()
-        << tango_aluminium_6 // Bar outline (use black instead)?
-        << tango_sky_blue_5
-        << tango_butter_6
-        << tango_chameleon_5
-        << tango_scarlet_red_5
-        << tango_plum_5
-        << tango_orange_6
-        << tango_aluminium_3
-        << tango_sky_blue_3
-        << tango_butter_3
-        << tango_chameleon_3
-        << tango_scarlet_red_3
-        << tango_plum_3
-        << tango_orange_3;
+QList<QRgb> colors_ = ColorUtils::graph_colors_;
 
 const qreal graph_line_width_ = 1.0;
 
diff --git a/ui/qt/main_window.cpp b/ui/qt/main_window.cpp
index bd60aef7d7..7042e93d85 100644
--- a/ui/qt/main_window.cpp
+++ b/ui/qt/main_window.cpp
@@ -1798,7 +1798,7 @@ void MainWindow::setMenusForFollowStream()
     main_ui_->actionAnalyzeFollowUDPStream->setEnabled(false);
     main_ui_->actionAnalyzeFollowSSLStream->setEnabled(false);
 
-    proto_get_frame_protocols(capture_file_.capFile()->edt->pi.layers, NULL, &is_tcp, &is_udp, NULL, NULL);
+    proto_get_frame_protocols(capture_file_.capFile()->edt->pi.layers, NULL, &is_tcp, &is_udp, NULL, NULL, NULL);
 
     if (is_tcp)
     {
diff --git a/ui/qt/main_window.h b/ui/qt/main_window.h
index 9cd6dd5a63..6f74cda8f6 100644
--- a/ui/qt/main_window.h
+++ b/ui/qt/main_window.h
@@ -511,6 +511,7 @@ private slots:
     void on_actionTelephonyVoipCalls_triggered();
     void on_actionTelephonyISUPMessages_triggered();
     void on_actionTelephonyRTPStreams_triggered();
+    void on_actionTelephonyRTPStreamAnalysis_triggered();
     void on_actionTelephonyRTSPPacketCounter_triggered();
     void on_actionTelephonySMPPOperations_triggered();
     void on_actionTelephonyUCPMessages_triggered();
diff --git a/ui/qt/main_window.ui b/ui/qt/main_window.ui
index 292df80960..6a334ef049 100644
--- a/ui/qt/main_window.ui
+++ b/ui/qt/main_window.ui
@@ -500,6 +500,7 @@
       <string>RTP</string>
      </property>
      <addaction name="actionTelephonyRTPStreams"/>
+     <addaction name="actionTelephonyRTPStreamAnalysis"/>
     </widget>
     <widget class="QMenu" name="menuANSI">
      <property name="title">
@@ -2535,6 +2536,14 @@
     <string>Ctrl+Space</string>
    </property>
   </action>
+  <action name="actionTelephonyRTPStreamAnalysis">
+   <property name="text">
+    <string>Analyze RTP Stream</string>
+   </property>
+   <property name="toolTip">
+    <string>RTP Stream Analysis</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
diff --git a/ui/qt/main_window_slots.cpp b/ui/qt/main_window_slots.cpp
index c4b73e77bf..d62d91ccad 100644
--- a/ui/qt/main_window_slots.cpp
+++ b/ui/qt/main_window_slots.cpp
@@ -107,6 +107,7 @@
 #include "qt_ui_utils.h"
 #include "resolved_addresses_dialog.h"
 #include "rtp_stream_dialog.h"
+#include "rtp_analysis_dialog.h"
 #include "sctp_all_assocs_dialog.h"
 #include "sctp_assoc_analyse_dialog.h"
 #include "sctp_graph_dialog.h"
@@ -956,7 +957,7 @@ void MainWindow::recentActionTriggered() {
 void MainWindow::setMenusForSelectedPacket()
 {
 //    gboolean is_ip = FALSE, is_tcp = FALSE, is_udp = FALSE, is_sctp = FALSE, is_ssl = FALSE;
-    gboolean is_tcp = FALSE, is_sctp = FALSE;
+    gboolean is_tcp = FALSE, is_sctp = FALSE, is_rtp = FALSE;
 
 //    /* Making the menu context-sensitive allows for easier selection of the
 //       desired item and has the added benefit, with large captures, of
@@ -999,7 +1000,7 @@ void MainWindow::setMenusForSelectedPacket()
 
         if (capture_file_.capFile()->edt)
         {
-            proto_get_frame_protocols(capture_file_.capFile()->edt->pi.layers, NULL, &is_tcp, NULL, &is_sctp, NULL);
+            proto_get_frame_protocols(capture_file_.capFile()->edt->pi.layers, NULL, &is_tcp, NULL, &is_sctp, NULL, &is_rtp);
         }
     }
 //    if (cfile.edt && cfile.edt->tree) {
@@ -1160,6 +1161,7 @@ void MainWindow::setMenusForSelectedPacket()
     main_ui_->actionSCTPAnalyseThisAssociation->setEnabled(is_sctp);
     main_ui_->actionSCTPShowAllAssociations->setEnabled(is_sctp);
     main_ui_->actionSCTPFilterThisAssociation->setEnabled(is_sctp);
+    main_ui_->actionTelephonyRTPStreamAnalysis->setEnabled(is_rtp);
 
 //    while (list_entry != NULL) {
 //        dissector_filter_t *filter_entry;
@@ -2907,6 +2909,14 @@ void MainWindow::on_actionTelephonyRTPStreams_triggered()
     rtp_stream_dialog->show();
 }
 
+void MainWindow::on_actionTelephonyRTPStreamAnalysis_triggered()
+{
+    RtpAnalysisDialog *rtp_analysis_dialog = new  RtpAnalysisDialog(*this, capture_file_);
+    connect(rtp_analysis_dialog, SIGNAL(goToPacket(int)),
+            packet_list_, SLOT(goToPacket(int)));
+    rtp_analysis_dialog->show();
+}
+
 void MainWindow::on_actionTelephonyRTSPPacketCounter_triggered()
 {
     openStatisticsTreeDialog("rtsp");
diff --git a/ui/qt/packet_list.cpp b/ui/qt/packet_list.cpp
index 0a368a1b3e..14452438c7 100644
--- a/ui/qt/packet_list.cpp
+++ b/ui/qt/packet_list.cpp
@@ -506,7 +506,7 @@ void PacketList::contextMenuEvent(QContextMenuEvent *event)
 
     /* walk the list of a available protocols in the packet to see what we have */
     if (cap_file_ != NULL && cap_file_->edt != NULL)
-        proto_get_frame_protocols(cap_file_->edt->pi.layers, NULL, &is_tcp, &is_udp, &is_sctp, NULL);
+        proto_get_frame_protocols(cap_file_->edt->pi.layers, NULL, &is_tcp, &is_udp, &is_sctp, NULL, NULL);
 
     QMenu *main_conv_menu = window()->findChild<QMenu *>("menuConversationFilter");
     conv_menu_.clear();
diff --git a/ui/qt/qt_ui_utils.cpp b/ui/qt/qt_ui_utils.cpp
index c1841c9f80..4d131d302e 100644
--- a/ui/qt/qt_ui_utils.cpp
+++ b/ui/qt/qt_ui_utils.cpp
@@ -66,13 +66,15 @@ QByteArray gstring_free_to_qbytearray(GString *glib_gstring)
     return qt_ba;
 }
 
-const QString address_to_qstring(const _address *address)
+const QString address_to_qstring(const _address *address, bool enclose)
 {
     QString address_qstr = QString();
     if (address) {
+        if (enclose && address->type == AT_IPv6) address_qstr += "[";
         gchar *address_gchar_p = address_to_str(NULL, address);
-        address_qstr = address_gchar_p;
+        address_qstr += address_gchar_p;
         wmem_free(NULL, address_gchar_p);
+        if (enclose && address->type == AT_IPv6) address_qstr += "]";
     }
     return address_qstr;
 }
diff --git a/ui/qt/qt_ui_utils.h b/ui/qt/qt_ui_utils.h
index 88057922f8..a46f2d1c84 100644
--- a/ui/qt/qt_ui_utils.h
+++ b/ui/qt/qt_ui_utils.h
@@ -82,10 +82,11 @@ QByteArray gstring_free_to_qbytearray(GString *glib_gstring);
 /** Convert an address to a QString using address_to_str().
  *
  * @param address A pointer to an address.
+ * @param enclose Enclose IPv6 addresses in square brackets.
  *
  * @return A QString representation of the address. May be the null string (QString())
  */
-const QString address_to_qstring(const struct _address *address);
+const QString address_to_qstring(const struct _address *address, bool enclose = false);
 
 /** Convert an address to a QString using address_to_display().
  *
diff --git a/ui/qt/rtp_analysis_dialog.cpp b/ui/qt/rtp_analysis_dialog.cpp
new file mode 100644
index 0000000000..e1246cd97e
--- /dev/null
+++ b/ui/qt/rtp_analysis_dialog.cpp
@@ -0,0 +1,1538 @@
+/* rtp_analysis_dialog.cpp
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#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/rtp_pt.h"
+
+#include "epan/dfilter/dfilter.h"
+
+#include "epan/dissectors/packet-rtp.h"
+
+#include "ui/help_url.h"
+#include "ui/utf8_entities.h"
+
+#include <wsutil/g711.h>
+#include <wsutil/pint.h>
+
+#include <QFileDialog>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QTemporaryFile>
+
+#include "color_utils.h"
+#include "qt_ui_utils.h"
+#include "stock_icon.h"
+#include "wireshark_application.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_
+};
+
+const QRgb color_cn_ = 0xbfbfff;
+const QRgb color_rtp_warn_ = 0xffdbbf;
+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->fd->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=%u").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=%u 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', 2));
+        setText(jitter_col_, QString::number(jitter_, 'f', 2));
+        setText(skew_col_, QString::number(skew_, 'f', 2));
+        setText(bandwidth_col_, QString::number(bandwidth_, 'f', 2));
+        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);
+            }
+        }
+    }
+
+    guint32 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:
+    guint32 frame_num_;
+    guint32 sequence_num_;
+    guint32 pkt_len_;
+    guint32 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(QWidget &parent, CaptureFile &cf) :
+    WiresharkDialog(parent, cf),
+    ui(new Ui::RtpAnalysisDialog),
+    port_src_fwd_(0),
+    port_dst_fwd_(0),
+    ssrc_fwd_(0),
+    port_src_rev_(0),
+    port_dst_rev_(0),
+    ssrc_rev_(0)
+{
+    ui->setupUi(this);
+    setWindowSubtitle(tr("RTP Stream Analysis"));
+
+    // XXX Use recent settings instead
+    resize(parent.width() * 4 / 5, parent.height() * 4 / 5);
+
+    stream_ctx_menu_.addAction(ui->actionGoToPacket);
+    stream_ctx_menu_.addAction(ui->actionNextProblem);
+    stream_ctx_menu_.addSeparator();
+    stream_ctx_menu_.addAction(ui->actionSaveAudio);
+    stream_ctx_menu_.addAction(ui->actionSaveForwardAudio);
+    stream_ctx_menu_.addAction(ui->actionSaveReverseAudio);
+    stream_ctx_menu_.addSeparator();
+    stream_ctx_menu_.addAction(ui->actionSaveCsv);
+    stream_ctx_menu_.addAction(ui->actionSaveForwardCsv);
+    stream_ctx_menu_.addAction(ui->actionSaveReverseCsv);
+    stream_ctx_menu_.addSeparator();
+    stream_ctx_menu_.addAction(ui->actionSaveGraph);
+    ui->forwardTreeWidget->installEventFilter(this);
+    ui->forwardTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(ui->forwardTreeWidget, SIGNAL(customContextMenuRequested(QPoint)),
+                SLOT(showStreamMenu(QPoint)));
+    ui->reverseTreeWidget->installEventFilter(this);
+    ui->reverseTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(ui->reverseTreeWidget, SIGNAL(customContextMenuRequested(QPoint)),
+                SLOT(showStreamMenu(QPoint)));
+    connect(ui->streamGraph, SIGNAL(mousePress(QMouseEvent*)),
+            this, SLOT(graphClicked(QMouseEvent*)));
+
+    graph_ctx_menu_.addAction(ui->actionSaveGraph);
+
+    QStringList header_labels;
+    for (int i = 0; i < ui->forwardTreeWidget->columnCount(); i++) {
+        header_labels << ui->forwardTreeWidget->headerItem()->text(i);
+    }
+    ui->reverseTreeWidget->setHeaderLabels(header_labels);
+
+    memset(&src_fwd_, 0, sizeof(address));
+    memset(&dst_fwd_, 0, sizeof(address));
+    memset(&src_rev_, 0, sizeof(address));
+    memset(&dst_rev_, 0, sizeof(address));
+
+    QList<QCheckBox *> graph_cbs = QList<QCheckBox *>()
+            << ui->fJitterCheckBox << ui->fDiffCheckBox << ui->fDeltaCheckBox
+            << ui->rJitterCheckBox << ui->rDiffCheckBox << ui->rDeltaCheckBox;
+
+    for (int i = 0; i < num_graphs_; i++) {
+        QCPGraph *graph = ui->streamGraph->addGraph();
+        graph->setPen(QPen(ColorUtils::graph_colors_[i]));
+        graph->setName(graph_cbs[i]->text());
+        graphs_ << graph;
+        graph_cbs[i]->setChecked(true);
+        graph_cbs[i]->setIcon(StockIcon::colorIcon(ColorUtils::graph_colors_[i], QPalette::Text));
+    }
+    ui->streamGraph->xAxis->setLabel("Arrival Time");
+    ui->streamGraph->yAxis->setLabel("Value (ms)");
+
+    // We keep our temp files open for the lifetime of the dialog. The GTK+
+    // UI opens and closes at various points.
+    QString tempname = QString("%1/wireshark_rtp_f").arg(QDir::tempPath());
+    fwd_tempfile_ = new QTemporaryFile(tempname, this);
+    fwd_tempfile_->open();
+    tempname = QString("%1/wireshark_rtp_r").arg(QDir::tempPath());
+    rev_tempfile_ = new QTemporaryFile(tempname, this);
+    rev_tempfile_->open();
+
+    if (fwd_tempfile_->error() != QFile::NoError || rev_tempfile_->error() != QFile::NoError) {
+        err_str_ = tr("Unable to save RTP data.");
+        ui->actionSaveAudio->setEnabled(false);
+        ui->actionSaveForwardAudio->setEnabled(false);
+        ui->actionSaveReverseAudio->setEnabled(false);
+    }
+
+    QMenu *save_menu = new QMenu();
+    save_menu->addAction(ui->actionSaveAudio);
+    save_menu->addAction(ui->actionSaveForwardAudio);
+    save_menu->addAction(ui->actionSaveReverseAudio);
+    save_menu->addSeparator();
+    save_menu->addAction(ui->actionSaveCsv);
+    save_menu->addAction(ui->actionSaveForwardCsv);
+    save_menu->addAction(ui->actionSaveReverseCsv);
+    save_menu->addSeparator();
+    save_menu->addAction(ui->actionSaveGraph);
+    ui->buttonBox->button(QDialogButtonBox::Save)->setMenu(save_menu);
+
+    const gchar *filter_text = "rtp && rtp.version && rtp.ssrc && (ip || ipv6)";
+    dfilter_t *sfcode;
+    gchar *err_msg;
+
+    if (!dfilter_compile(filter_text, &sfcode, &err_msg)) {
+        QMessageBox::warning(this, tr("No RTP packets found"), QString("%1").arg(err_msg));
+        g_free(err_msg);
+        close();
+    }
+
+    if (!cap_file_.capFile() || !cap_file_.capFile()->current_frame) close();
+
+    frame_data *fdata = cap_file_.capFile()->current_frame;
+
+    if (!cf_read_record(cap_file_.capFile(), fdata)) close();
+
+    epan_dissect_t edt;
+
+    epan_dissect_init(&edt, cap_file_.capFile()->epan, TRUE, FALSE);
+    epan_dissect_prime_dfilter(&edt, sfcode);
+    epan_dissect_run(&edt, cap_file_.capFile()->cd_t, &cap_file_.capFile()->phdr,
+                     frame_tvbuff_new_buffer(fdata, &cap_file_.capFile()->buf), fdata, NULL);
+
+    // This shouldn't happen (the menu item should be disabled) but check anyway
+    if (!dfilter_apply_edt(sfcode, &edt)) {
+        epan_dissect_cleanup(&edt);
+        dfilter_free(sfcode);
+        err_str_ = tr("Please select an RTP packet");
+        updateWidgets();
+        return;
+    }
+
+    dfilter_free(sfcode);
+
+    /* OK, it is an RTP frame. Let's get the IP and port values */
+    COPY_ADDRESS(&(src_fwd_), &(edt.pi.src));
+    COPY_ADDRESS(&(dst_fwd_), &(edt.pi.dst));
+    port_src_fwd_ = edt.pi.srcport;
+    port_dst_fwd_ = edt.pi.destport;
+
+    /* assume the inverse ip/port combination for the reverse direction */
+    COPY_ADDRESS(&(src_rev_), &(edt.pi.dst));
+    COPY_ADDRESS(&(dst_rev_), &(edt.pi.src));
+    port_src_rev_ = edt.pi.destport;
+    port_dst_rev_ = edt.pi.srcport;
+
+    /* Check if it is RTP Version 2 */
+    unsigned int  version_fwd;
+    bool ok;
+    version_fwd = getIntFromProtoTree(edt.tree, "rtp", "rtp.version", &ok);
+    if (!ok || version_fwd != 2) {
+        err_str_ = tr("RTP version %1 found. Only version 2 is supported.").arg(version_fwd);
+        updateWidgets();
+        return;
+    }
+
+    /* now we need the SSRC value of the current frame */
+    ssrc_fwd_ = getIntFromProtoTree(edt.tree, "rtp", "rtp.ssrc", &ok);
+    if (!ok) {
+        err_str_ = tr("SSRC value not found.");
+        updateWidgets();
+        return;
+    }
+
+    /* Register the tap listener */
+    memset(&tapinfo_, 0, sizeof(rtpstream_tapinfo_t));
+    tapinfo_.tap_data = this;
+    tapinfo_.mode = TAP_ANALYSE;
+
+//    register_tap_listener_rtp_stream(&tapinfo_, NULL);
+    /* Scan for RTP streams (redissect all packets) */
+    rtpstream_scan(&tapinfo_, cap_file_.capFile(), NULL);
+
+    num_streams_ = 0;
+    GList *filtered_list = NULL;
+    for (GList *strinfo_list = g_list_first(tapinfo_.strinfo_list); strinfo_list; strinfo_list = g_list_next(strinfo_list)) {
+        rtp_stream_info_t * strinfo = (rtp_stream_info_t*)(strinfo_list->data);
+        if (ADDRESSES_EQUAL(&(strinfo->src_addr), &(src_fwd_))
+            && (strinfo->src_port == port_src_fwd_)
+            && (ADDRESSES_EQUAL(&(strinfo->dest_addr), &(dst_fwd_)))
+            && (strinfo->dest_port == port_dst_fwd_))
+        {
+            ++num_streams_;
+            filtered_list = g_list_prepend(filtered_list, strinfo);
+        }
+
+        if (ADDRESSES_EQUAL(&(strinfo->src_addr), &(src_rev_))
+            && (strinfo->src_port == port_src_rev_)
+            && (ADDRESSES_EQUAL(&(strinfo->dest_addr), &(dst_rev_)))
+            && (strinfo->dest_port == port_dst_rev_))
+        {
+            ++num_streams_;
+            filtered_list = g_list_append(filtered_list, strinfo);
+            if (ssrc_rev_ == 0)
+                ssrc_rev_ = strinfo->ssrc;
+        }
+    }
+
+    if (num_streams_ < 1) {
+        err_str_ = tr("No streams found.");
+    }
+
+    connect(ui->tabWidget, SIGNAL(currentChanged(int)),
+            this, SLOT(updateWidgets()));
+    connect(ui->forwardTreeWidget, SIGNAL(itemSelectionChanged()),
+            this, SLOT(updateWidgets()));
+    connect(ui->reverseTreeWidget, SIGNAL(itemSelectionChanged()),
+            this, SLOT(updateWidgets()));
+    connect(&cap_file_, SIGNAL(captureFileClosing()),
+            this, SLOT(updateWidgets()));
+    updateWidgets();
+
+    register_tap_listener("rtp", this, NULL, 0, tapReset, tapPacket, tapDraw);
+
+    cap_file_.retapPackets();
+    remove_tap_listener(this);
+
+    updateStatistics();
+}
+
+RtpAnalysisDialog::~RtpAnalysisDialog()
+{
+    delete ui;
+//    remove_tap_listener_rtp_stream(&tapinfo_);
+    delete fwd_tempfile_;
+    delete rev_tempfile_;
+}
+
+// XXX Should we do this in WiresharkDialog?
+void RtpAnalysisDialog::reject()
+{
+    // We need to make sure our temporary files are closed.
+    deleteLater();
+    WiresharkDialog::reject();
+}
+
+void RtpAnalysisDialog::updateWidgets()
+{
+    bool enable_tab = false;
+    QString hint = err_str_;
+
+    if (hint.isEmpty()) {
+        enable_tab = true;
+        hint = tr("%1 streams found.").arg(num_streams_);
+    }
+
+    bool enable_nav = false;
+    if (!file_closed_
+            && ((ui->tabWidget->currentWidget() == ui->forwardTreeWidget
+                 && ui->forwardTreeWidget->selectedItems().length() > 0)
+                || (ui->tabWidget->currentWidget() == ui->reverseTreeWidget
+                    && ui->reverseTreeWidget->selectedItems().length() > 0))) {
+        enable_nav = true;
+    }
+    ui->actionGoToPacket->setEnabled(enable_nav);
+    ui->actionNextProblem->setEnabled(enable_nav);
+
+    if (enable_nav) {
+        hint.append(tr(" G: Go to packet, N: Next problem packet"));
+    }
+
+    bool enable_save_fwd_audio = fwd_tempfile_->isOpen();
+    bool enable_save_rev_audio = rev_tempfile_->isOpen();
+    ui->actionSaveAudio->setEnabled(enable_save_fwd_audio && enable_save_rev_audio);
+    ui->actionSaveForwardAudio->setEnabled(enable_save_fwd_audio);
+    ui->actionSaveReverseAudio->setEnabled(enable_save_rev_audio);
+
+    bool enable_save_fwd_csv = ui->forwardTreeWidget->topLevelItemCount() > 0;
+    bool enable_save_rev_csv = ui->reverseTreeWidget->topLevelItemCount() > 0;
+    ui->actionSaveCsv->setEnabled(enable_save_fwd_csv && enable_save_rev_csv);
+    ui->actionSaveForwardCsv->setEnabled(enable_save_fwd_csv);
+    ui->actionSaveReverseCsv->setEnabled(enable_save_rev_csv);
+
+    ui->tabWidget->setEnabled(enable_tab);
+    hint.prepend("<small><i>");
+    hint.append("</i></small>");
+    ui->hintLabel->setText(hint);
+}
+
+void RtpAnalysisDialog::on_actionGoToPacket_triggered()
+{
+    if (file_closed_) return;
+    QTreeWidget *cur_tree = qobject_cast<QTreeWidget *>(ui->tabWidget->currentWidget());
+    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()
+{
+    QTreeWidget *cur_tree = qobject_cast<QTreeWidget *>(ui->tabWidget->currentWidget());
+    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);
+    while (test_ti != sel_ti) {
+        if (!test_ti) test_ti = cur_tree->topLevelItem(0);
+        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);
+    }
+}
+
+void RtpAnalysisDialog::on_fJitterCheckBox_toggled(bool checked)
+{
+    ui->streamGraph->graph(fwd_jitter_graph_)->setVisible(checked);
+    updateGraph();
+}
+
+void RtpAnalysisDialog::on_fDiffCheckBox_toggled(bool checked)
+{
+    ui->streamGraph->graph(fwd_diff_graph_)->setVisible(checked);
+    updateGraph();
+}
+
+void RtpAnalysisDialog::on_fDeltaCheckBox_toggled(bool checked)
+{
+    ui->streamGraph->graph(fwd_delta_graph_)->setVisible(checked);
+    updateGraph();
+}
+
+void RtpAnalysisDialog::on_rJitterCheckBox_toggled(bool checked)
+{
+    ui->streamGraph->graph(rev_jitter_graph_)->setVisible(checked);
+    updateGraph();
+}
+
+void RtpAnalysisDialog::on_rDiffCheckBox_toggled(bool checked)
+{
+    ui->streamGraph->graph(rev_diff_graph_)->setVisible(checked);
+    updateGraph();
+}
+
+void RtpAnalysisDialog::on_rDeltaCheckBox_toggled(bool checked)
+{
+    ui->streamGraph->graph(rev_delta_graph_)->setVisible(checked);
+    updateGraph();
+}
+
+void RtpAnalysisDialog::on_actionSaveAudio_triggered()
+{
+    saveAudio(dir_both_);
+}
+
+void RtpAnalysisDialog::on_actionSaveForwardAudio_triggered()
+{
+    saveAudio(dir_forward_);
+}
+
+void RtpAnalysisDialog::on_actionSaveReverseAudio_triggered()
+{
+    saveAudio(dir_reverse_);
+}
+
+void RtpAnalysisDialog::on_actionSaveCsv_triggered()
+{
+    saveCsv(dir_both_);
+}
+
+void RtpAnalysisDialog::on_actionSaveForwardCsv_triggered()
+{
+    saveCsv(dir_forward_);
+}
+
+void RtpAnalysisDialog::on_actionSaveReverseCsv_triggered()
+{
+    saveCsv(dir_reverse_);
+}
+
+void RtpAnalysisDialog::on_actionSaveGraph_triggered()
+{
+    ui->tabWidget->setCurrentWidget(ui->graphTab);
+
+    QString file_name, extension;
+    QDir path(wsApp->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_.fileTitle());
+    }
+    file_name = QFileDialog::getSaveFileName(this, wsApp->windowTitleString(tr("Save Graph As" UTF8_HORIZONTAL_ELLIPSIS)),
+                                             save_file, filter, &extension);
+
+    if (!file_name.isEmpty()) {
+        bool save_ok = false;
+        // http://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) {
+            path = QDir(file_name);
+            wsApp->setLastOpenDir(path.canonicalPath().toUtf8().constData());
+        }
+    }
+}
+
+void RtpAnalysisDialog::on_buttonBox_helpRequested()
+{
+    wsApp->helpTopicAction(HELP_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();
+}
+
+gboolean RtpAnalysisDialog::tapPacket(void *tapinfo_ptr, packet_info *pinfo, epan_dissect_t *, const void *rtpinfo_ptr)
+{
+    RtpAnalysisDialog *rtp_analysis_dialog = dynamic_cast<RtpAnalysisDialog *>((RtpAnalysisDialog*)tapinfo_ptr);
+    if (!rtp_analysis_dialog) return FALSE;
+
+    const struct _rtp_info *rtpinfo = (const struct _rtp_info *)rtpinfo_ptr;
+    if (!rtpinfo) return FALSE;
+
+    /* we ignore packets that are not displayed */
+    if (pinfo->fd->flags.passed_dfilter == 0)
+        return FALSE;
+    /* also ignore RTP Version != 2 */
+    else if (rtpinfo->info_version != 2)
+        return FALSE;
+    /* is it the forward direction?  */
+    else if (rtp_analysis_dialog->ssrc_fwd_ == rtpinfo->info_sync_src
+         && (CMP_ADDRESS(&(rtp_analysis_dialog->src_fwd_), &(pinfo->src)) == 0)
+         && (rtp_analysis_dialog->port_src_fwd_ == pinfo->srcport)
+         && (CMP_ADDRESS(&(rtp_analysis_dialog->dst_fwd_), &(pinfo->dst)) == 0)
+         && (rtp_analysis_dialog->port_dst_fwd_ == pinfo->destport))  {
+
+        rtp_analysis_dialog->addPacket(true, pinfo, rtpinfo);
+    }
+    /* is it the reversed direction? */
+    else if (rtp_analysis_dialog->ssrc_rev_ == rtpinfo->info_sync_src
+         && (CMP_ADDRESS(&(rtp_analysis_dialog->src_rev_), &(pinfo->src)) == 0)
+         && (rtp_analysis_dialog->port_src_rev_ == pinfo->srcport)
+         && (CMP_ADDRESS(&(rtp_analysis_dialog->dst_rev_), &(pinfo->dst)) == 0)
+         && (rtp_analysis_dialog->port_dst_rev_ == pinfo->destport))  {
+
+        rtp_analysis_dialog->addPacket(false, pinfo, rtpinfo);
+    }
+    return FALSE;
+}
+
+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()
+{
+    memset(&fwd_statinfo_, 0, sizeof(tap_rtp_stat_t));
+    memset(&rev_statinfo_, 0, sizeof(tap_rtp_stat_t));
+
+    fwd_statinfo_.first_packet = TRUE;
+    rev_statinfo_.first_packet = TRUE;
+    fwd_statinfo_.reg_pt = PT_UNDEFINED;
+    rev_statinfo_.reg_pt = PT_UNDEFINED;
+
+    ui->forwardTreeWidget->clear();
+    ui->reverseTreeWidget->clear();
+
+    for (int i = 0; i < ui->streamGraph->graphCount(); i++) {
+        ui->streamGraph->graph(i)->clearData();
+    }
+
+    fwd_time_vals_.clear();
+    fwd_jitter_vals_.clear();
+    fwd_diff_vals_.clear();
+    fwd_delta_vals_.clear();
+    rev_time_vals_.clear();
+    rev_jitter_vals_.clear();
+    rev_diff_vals_.clear();
+    rev_delta_vals_.clear();
+
+    fwd_tempfile_->resize(0);
+    rev_tempfile_->resize(0);
+}
+
+void RtpAnalysisDialog::addPacket(bool forward, packet_info *pinfo, const _rtp_info *rtpinfo)
+{
+    /* add this RTP for future listening using the RTP Player*/
+//    add_rtp_packet(rtpinfo, pinfo);
+
+    if (forward) {
+        rtp_packet_analyse(&fwd_statinfo_, pinfo, rtpinfo);
+        new RtpAnalysisTreeWidgetItem(ui->forwardTreeWidget, &fwd_statinfo_, pinfo, rtpinfo);
+
+        fwd_time_vals_.append((fwd_statinfo_.time - fwd_statinfo_.start_time) / 1000);
+        fwd_jitter_vals_.append(fwd_statinfo_.jitter * 1000);
+        fwd_diff_vals_.append(fwd_statinfo_.diff * 1000);
+        fwd_delta_vals_.append(fwd_statinfo_.delta * 1000);
+
+        savePayload(fwd_tempfile_, &fwd_statinfo_, pinfo, rtpinfo);
+    } else {
+        rtp_packet_analyse(&rev_statinfo_, pinfo, rtpinfo);
+        new RtpAnalysisTreeWidgetItem(ui->reverseTreeWidget, &rev_statinfo_, pinfo, rtpinfo);
+
+        rev_time_vals_.append((rev_statinfo_.time - rev_statinfo_.start_time) / 1000);
+        rev_jitter_vals_.append(rev_statinfo_.jitter * 1000);
+        rev_diff_vals_.append(rev_statinfo_.diff * 1000);
+        rev_delta_vals_.append(rev_statinfo_.delta * 1000);
+
+        savePayload(rev_tempfile_, &rev_statinfo_, pinfo, rtpinfo);
+    }
+
+}
+
+// rtp_analysis.c:rtp_packet_save_payload
+const unsigned int max_silence_ticks_ = 1000000;
+const guint8 silence_pcmu_ = 0xff;
+const guint8 silence_pcma_ = 0x55;
+void RtpAnalysisDialog::savePayload(QTemporaryFile *tmpfile, tap_rtp_stat_t *statinfo, packet_info *pinfo, const _rtp_info *rtpinfo)
+{
+    /* Is this the first packet we got in this direction? */
+//    if (statinfo->flags & STAT_FLAG_FIRST) {
+//        if (saveinfo->fp == NULL) {
+//            saveinfo->saved = FALSE;
+//            saveinfo->error_type = TAP_RTP_FILE_OPEN_ERROR;
+//        } else {
+//            saveinfo->saved = TRUE;
+//        }
+//    }
+
+    /* Save the voice information */
+
+    /* If there was already an error, we quit */
+    if (!tmpfile->isOpen() || tmpfile->error() != QFile::NoError) return;
+
+    /* Quit if the captured length and packet length aren't equal or
+     * if the RTP dissector thinks there is some information missing
+     */
+    if ((pinfo->fd->pkt_len != pinfo->fd->cap_len)
+        && (!rtpinfo->info_all_data_present)) {
+        tmpfile->close();
+        err_str_ = tr("Can't save in a file: Wrong length of captured packets.");
+        return;
+    }
+
+    /* If padding bit is set but the padding count is bigger
+     * then the whole RTP data - error with padding count
+     */
+    if ( (rtpinfo->info_padding_set != FALSE)
+         && (rtpinfo->info_padding_count > rtpinfo->info_payload_len) ) {
+        tmpfile->close();
+        err_str_ = tr("Can't save in a file: RTP data with padding.");
+        return;
+    }
+
+    /* Do we need to insert some silence? */
+    if ((rtpinfo->info_marker_set)
+        && ! (statinfo->flags & STAT_FLAG_FIRST)
+        && ! (statinfo->flags & STAT_FLAG_WRONG_TIMESTAMP)
+        && (statinfo->delta_timestamp > (rtpinfo->info_payload_len - rtpinfo->info_padding_count)) )  {
+        /* the amount of silence should be the difference between
+        * the last timestamp and the current one minus x
+        * x should equal the amount of information in the last frame
+        * XXX not done yet */
+        for (unsigned int i = 0;
+             (i < (statinfo->delta_timestamp - rtpinfo->info_payload_len - rtpinfo->info_padding_count))
+                 && (i < max_silence_ticks_);
+             i++) {
+            guint8 tmp;
+            size_t nchars;
+
+            switch (statinfo->reg_pt) {
+            case PT_PCMU:
+                tmp = silence_pcmu_;
+                break;
+            case PT_PCMA:
+                tmp = silence_pcma_;
+                break;
+            default:
+                tmp = 0;
+                break;
+            }
+            nchars = tmpfile->write((char *)&tmp, 1);
+            if (nchars != 1) {
+                /* Write error or short write */
+                tmpfile->close();
+                err_str_ = tr("Can't save in a file: File I/O problem.");
+                return;
+            }
+        }
+    }
+
+
+    if ((rtpinfo->info_payload_type == PT_CN)
+        || (rtpinfo->info_payload_type == PT_CN_OLD)) {
+    } else { /* All other payloads */
+        const char *data;
+        size_t nchars;
+
+        if (!rtpinfo->info_all_data_present) {
+            /* Not all the data was captured. */
+            tmpfile->close();
+            err_str_ = tr("Can't save in a file: Not all data in all packets was captured.");
+            return;
+        }
+
+        /* We put the pointer at the beginning of the RTP
+         * payload, that is, at the beginning of the RTP data
+         * plus the offset of the payload from the beginning
+         * of the RTP data */
+        data   = (const char *) rtpinfo->info_data + rtpinfo->info_payload_offset;
+        nchars = tmpfile->write(data, rtpinfo->info_payload_len - rtpinfo->info_padding_count);
+        if (nchars != (rtpinfo->info_payload_len - rtpinfo->info_padding_count)) {
+            /* Write error or short write */
+            err_str_ = tr("Can't save in a file: File I/O problem.");
+            tmpfile->close();
+            return;
+        }
+        return;
+    }
+    return;
+}
+
+void RtpAnalysisDialog::updateStatistics()
+{
+    unsigned int f_clock_rate = fwd_statinfo_.clock_rate;
+    unsigned int r_clock_rate = rev_statinfo_.clock_rate;
+    unsigned int f_expected = (fwd_statinfo_.stop_seq_nr + fwd_statinfo_.cycles*65536)
+            - fwd_statinfo_.start_seq_nr + 1;
+    unsigned int r_expected = (rev_statinfo_.stop_seq_nr + rev_statinfo_.cycles*65536)
+            - rev_statinfo_.start_seq_nr + 1;
+    unsigned int f_total_nr = fwd_statinfo_.total_nr;
+    unsigned int r_total_nr = rev_statinfo_.total_nr;
+    int f_lost = f_expected - f_total_nr;
+    int r_lost = r_expected - r_total_nr;
+    double f_sumt = fwd_statinfo_.sumt;
+    double f_sumTS = fwd_statinfo_.sumTS;
+    double f_sumt2 = fwd_statinfo_.sumt2;
+    double f_sumtTS = fwd_statinfo_.sumtTS;
+    double r_sumt = rev_statinfo_.sumt;
+    double r_sumTS = rev_statinfo_.sumTS;
+    double r_sumt2 = rev_statinfo_.sumt2;
+    double r_sumtTS = rev_statinfo_.sumtTS;
+    double f_perc, r_perc;
+    double f_clock_drift = 1.0;
+    double r_clock_drift = 1.0;
+    double f_duration = fwd_statinfo_.time - fwd_statinfo_.start_time;
+    double r_duration = rev_statinfo_.time - rev_statinfo_.start_time;
+
+    if (f_clock_rate == 0) {
+        f_clock_rate = 1;
+    }
+
+    if (r_clock_rate == 0) {
+        r_clock_rate = 1;
+    }
+
+    if (f_expected) {
+        f_perc = (double)(f_lost*100)/(double)f_expected;
+    } else {
+        f_perc = 0;
+    }
+    if (r_expected) {
+        r_perc = (double)(r_lost*100)/(double)r_expected;
+    } else {
+        r_perc = 0;
+    }
+
+    if ((f_total_nr >0) && (f_sumt2 > 0)) {
+        f_clock_drift = (f_total_nr * f_sumtTS - f_sumt * f_sumTS) / (f_total_nr * f_sumt2 - f_sumt * f_sumt);
+    }
+    if ((r_total_nr >0) && (r_sumt2 > 0)) {
+        r_clock_drift = (r_total_nr * r_sumtTS - r_sumt * r_sumTS) / (r_total_nr * r_sumt2 - r_sumt * r_sumt);
+    }
+
+    QString stats_tables = "<html><head></head><body>\n";
+    stats_tables += QString("<p>%1:%2 " UTF8_LEFT_RIGHT_ARROW)
+            .arg(address_to_qstring(&src_fwd_, true))
+            .arg(port_src_fwd_);
+    stats_tables += QString("<br>%1:%2</p>\n")
+            .arg(address_to_qstring(&dst_fwd_, true))
+            .arg(port_dst_fwd_);
+    stats_tables += "<h4>Forward</h4>\n";
+    stats_tables += "<p><table>\n";
+    stats_tables += QString("<tr><th align=\"left\">SSRC</th><td>0x%1</tr>")
+            .arg(ssrc_fwd_, 8, 16, QChar('0'));
+    stats_tables += QString("<tr><th align=\"left\">Max Delta</th><td>%1 ms @ %2</td></tr>")
+            .arg(fwd_statinfo_.max_delta, 0, 'f', 2)
+            .arg(fwd_statinfo_.max_nr);
+    stats_tables += QString("<tr><th align=\"left\">Max Jitter</th><td>%1 ms</tr>")
+            .arg(fwd_statinfo_.max_jitter, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">Mean Jitter</th><td>%1 ms</tr>")
+            .arg(fwd_statinfo_.mean_jitter, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">Max Skew</th><td>%1 ms</tr>")
+            .arg(fwd_statinfo_.max_skew, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">RTP Packets</th><td>%1</tr>")
+            .arg(f_total_nr);
+    stats_tables += QString("<tr><th align=\"left\">Expected</th><td>%1</tr>")
+            .arg(f_expected);
+    stats_tables += QString("<tr><th align=\"left\">Lost</th><td>%1 (%2 %)</tr>")
+            .arg(f_lost).arg(f_perc, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">Seq Errs</th><td>%1</tr>")
+            .arg(fwd_statinfo_.sequence);
+    stats_tables += QString("<tr><th align=\"left\">Duration</th><td>%1 s</tr>")
+            .arg(f_duration / 1000.0, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">Clock Drift</th><td>%1 ms</tr>")
+            .arg(f_duration * (f_clock_drift - 1.0), 0, 'f', 0);
+    stats_tables += QString("<tr><th align=\"left\">Freq Drift</th><td>%1 Hz (%2 %)</tr>") // XXX Terminology?
+            .arg(f_clock_drift * f_clock_rate, 0, 'f', 0).arg(100.0 * (f_clock_drift - 1.0), 0, 'f', 2);
+    stats_tables += "</table></p>\n";
+
+    stats_tables += "<h4>Reverse</h4>\n";
+    stats_tables += "<p><table>\n";
+    stats_tables += QString("<tr><th align=\"left\">SSRC</th><td>0x%1</tr>")
+            .arg(ssrc_fwd_, 8, 16, QChar('0'));
+    stats_tables += QString("<tr><th align=\"left\">Max Delta</th><td>%1 ms @ %2</td></tr>")
+            .arg(rev_statinfo_.max_delta, 0, 'f', 2)
+            .arg(rev_statinfo_.max_nr);
+    stats_tables += QString("<tr><th align=\"left\">Max Jitter</th><td>%1 ms</tr>")
+            .arg(rev_statinfo_.max_jitter, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">Mean Jitter</th><td>%1 ms</tr>")
+            .arg(rev_statinfo_.mean_jitter, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">Max Skew</th><td>%1 ms</tr>")
+            .arg(rev_statinfo_.max_skew, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">RTP Packets</th><td>%1</tr>")
+            .arg(r_total_nr);
+    stats_tables += QString("<tr><th align=\"left\">Expected</th><td>%1</tr>")
+            .arg(r_expected);
+    stats_tables += QString("<tr><th align=\"left\">Lost</th><td>%1 (%2 %)</tr>")
+            .arg(r_lost).arg(r_perc, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">Seq Errs</th><td>%1</tr>")
+            .arg(rev_statinfo_.sequence);
+    stats_tables += QString("<tr><th align=\"left\">Duration</th><td>%1 s</tr>")
+            .arg(r_duration / 1000.0, 0, 'f', 2);
+    stats_tables += QString("<tr><th align=\"left\">Clock Drift</th><td>%1 ms</tr>")
+            .arg(r_duration * (r_clock_drift - 1.0), 0, 'f', 0);
+    stats_tables += QString("<tr><th align=\"left\">Freq Drift</th><td>%1 Hz (%2 %)</tr>") // XXX Terminology?
+            .arg(r_clock_drift * r_clock_rate, 0, 'f', 0).arg(100.0 * (r_clock_drift - 1.0), 0, 'f', 2);
+    stats_tables += "</table></p></body>\n";
+
+    ui->statisticsLabel->setText(stats_tables);
+
+    for (int col = 0; col < ui->forwardTreeWidget->columnCount() - 1; col++) {
+        ui->forwardTreeWidget->resizeColumnToContents(col);
+        ui->reverseTreeWidget->resizeColumnToContents(col);
+    }
+
+    graphs_[fwd_jitter_graph_]->setData(fwd_time_vals_, fwd_jitter_vals_);
+    graphs_[fwd_diff_graph_]->setData(fwd_time_vals_, fwd_diff_vals_);
+    graphs_[fwd_delta_graph_]->setData(fwd_time_vals_, fwd_delta_vals_);
+    graphs_[rev_jitter_graph_]->setData(rev_time_vals_, rev_jitter_vals_);
+    graphs_[rev_diff_graph_]->setData(rev_time_vals_, rev_diff_vals_);
+    graphs_[rev_delta_graph_]->setData(rev_time_vals_, rev_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();
+}
+
+// rtp_analysis.c:copy_file
+enum { save_audio_none_, save_audio_au_, save_audio_raw_ };
+void RtpAnalysisDialog::saveAudio(RtpAnalysisDialog::StreamDirection direction)
+{
+    if (!fwd_tempfile_->isOpen() || !rev_tempfile_->isOpen()) return;
+
+    QString caption;
+
+    switch (direction) {
+    case dir_forward_:
+        caption = tr("Save forward stream audio");
+        break;
+    case dir_reverse_:
+        caption = tr("Save reverse stream audio");
+        break;
+    case dir_both_:
+    default:
+        caption = tr("Save audio");
+        break;
+    }
+
+    QString ext_filter = tr("Sun Audio (*.au)");
+    if (direction != dir_both_) {
+        ext_filter.append(tr(";;Raw (*.raw)"));
+    }
+    QString sel_filter;
+    QString file_path = QFileDialog::getSaveFileName(
+                this, caption, wsApp->lastOpenDir().absoluteFilePath("Saved RTP Audio.au"),
+                ext_filter, &sel_filter);
+
+    if (file_path.isEmpty()) return;
+
+    int save_format = save_audio_none_;
+    if (file_path.endsWith(".au")) {
+        save_format = save_audio_au_;
+    } else if (file_path.endsWith(".raw")) {
+        save_format = save_audio_raw_;
+    }
+
+    if (save_format == save_audio_none_) {
+        QMessageBox::warning(this, tr("Warning"), tr("Unable to save in that format"));
+        return;
+    }
+
+    QFile      save_file(file_path);
+    gint16     sample;
+    gchar      pd[4];
+//    progdlg_t *progbar;
+//    guint32	   progbar_count, progbar_quantum;
+//    guint32    progbar_nextstep = 0;
+    guint32    count = 0;
+    gboolean   stop_flag = FALSE;
+    size_t     nchars;
+
+    save_file.open(QIODevice::WriteOnly);
+    fwd_tempfile_->seek(0);
+    rev_tempfile_->seek(0);
+
+    if (save_file.error() != QFile::NoError) {
+        QMessageBox::warning(this, tr("Warning"), tr("Unable to save %1").arg(save_file.fileName()));
+        return;
+    }
+
+//    progbar = create_progress_dlg(top_level, "Saving voice in a file", dest, TRUE, &stop_flag);
+
+    if	(save_format == save_audio_au_) { /* au format */
+        /* First we write the .au header. XXX Hope this is endian independent */
+        /* the magic word 0x2e736e64 == .snd */
+        phton32(pd, 0x2e736e64);
+        nchars = save_file.write((const char *)pd, 4);
+        if (nchars != 4)
+            goto copy_file_err;
+        /* header offset == 24 bytes */
+        phton32(pd, 24);
+        nchars = save_file.write((const char *)pd, 4);
+        if (nchars != 4)
+            goto copy_file_err;
+        /* total length; it is permitted to set this to 0xffffffff */
+        phton32(pd, 0xffffffff);
+        nchars = save_file.write((const char *)pd, 4);
+        if (nchars != 4)
+            goto copy_file_err;
+        /* encoding format == 16-bit linear PCM */
+        phton32(pd, 3);
+        nchars = save_file.write((const char *)pd, 4);
+        if (nchars != 4)
+            goto copy_file_err;
+        /* sample rate == 8000 Hz */
+        phton32(pd, 8000);
+        nchars = save_file.write((const char *)pd, 4);
+        if (nchars != 4)
+            goto copy_file_err;
+        /* channels == 1 */
+        phton32(pd, 1);
+        nchars = save_file.write((const char *)pd, 4);
+        if (nchars != 4)
+            goto copy_file_err;
+
+        switch (direction) {
+        /* Only forward direction */
+        case dir_forward_:
+        {
+            char f_rawvalue;
+//                progbar_count = user_data->forward.saveinfo.count;
+//                progbar_quantum = user_data->forward.saveinfo.count/100;
+            while (fwd_tempfile_->getChar(&f_rawvalue)) {
+                if (stop_flag)
+                    break;
+//                    if ((count > progbar_nextstep) && (count <= progbar_count)) {
+//                        update_progress_dlg(progbar,
+//                            (gfloat) count/progbar_count, "Saving");
+//                        progbar_nextstep = progbar_nextstep + progbar_quantum;
+//                    }
+                count++;
+
+                if (fwd_statinfo_.pt == PT_PCMU) {
+                    sample = ulaw2linear((unsigned char)f_rawvalue);
+                    phton16(pd, sample);
+                } else if (fwd_statinfo_.pt == PT_PCMA) {
+                    sample = alaw2linear((unsigned char)f_rawvalue);
+                    phton16(pd, sample);
+                } else {
+                    goto copy_file_err;
+                }
+
+                nchars = save_file.write((const char *)pd, 2);
+                if (nchars < 2) {
+                    goto copy_file_err;
+                }
+            }
+            break;
+        }
+            /* Only reverse direction */
+        case dir_reverse_:
+        {
+            char r_rawvalue;
+//                progbar_count = user_data->reversed.saveinfo.count;
+//                progbar_quantum = user_data->reversed.saveinfo.count/100;
+            while (rev_tempfile_->getChar(&r_rawvalue)) {
+                if (stop_flag)
+                    break;
+//                if ((count > progbar_nextstep) && (count <= progbar_count)) {
+//                    update_progress_dlg(progbar,
+//                                        (gfloat) count/progbar_count, "Saving");
+//                    progbar_nextstep = progbar_nextstep + progbar_quantum;
+//                }
+                count++;
+
+                if (rev_statinfo_.pt == PT_PCMU) {
+                    sample = ulaw2linear((unsigned char)r_rawvalue);
+                    phton16(pd, sample);
+                } else if (rev_statinfo_.pt == PT_PCMA) {
+                    sample = alaw2linear((unsigned char)r_rawvalue);
+                    phton16(pd, sample);
+                } else {
+                    goto copy_file_err;
+                }
+
+                nchars = save_file.write((const char *)pd, 2);
+                if (nchars < 2) {
+                    goto copy_file_err;
+                }
+            }
+            break;
+        }
+            /* Both directions */
+        case dir_both_:
+        {
+            char f_rawvalue, r_rawvalue;
+            guint32 f_write_silence = 0;
+            guint32 r_write_silence = 0;
+//            if (user_data->forward.saveinfo.count > user_data->reversed.saveinfo.count) {
+//                progbar_count = user_data->forward.saveinfo.count;
+//            } else {
+//                progbar_count = user_data->reversed.saveinfo.count;
+//            }
+//            progbar_quantum = progbar_count/100;
+            /* since conversation in one way can start later than in the other one,
+                 * we have to write some silence information for one channel */
+            if (fwd_statinfo_.start_time > rev_statinfo_.start_time) {
+                f_write_silence = (guint32)
+                        ((fwd_statinfo_.start_time - rev_statinfo_.start_time)
+                         * (8000/1000));
+            } else if (fwd_statinfo_.start_time < rev_statinfo_.start_time) {
+                r_write_silence = (guint32)
+                        ((rev_statinfo_.start_time - fwd_statinfo_.start_time)
+                         * (8000/1000));
+            }
+            for (;;) {
+                if (stop_flag)
+                    break;
+//                if ((count > progbar_nextstep) && (count <= progbar_count)) {
+//                    update_progress_dlg(progbar,
+//                                        (gfloat) count/progbar_count, "Saving");
+//                    progbar_nextstep = progbar_nextstep + progbar_quantum;
+//                }
+                count++;
+                if (f_write_silence > 0) {
+                    rev_tempfile_->getChar(&r_rawvalue);
+                    switch (fwd_statinfo_.reg_pt) {
+                    case PT_PCMU:
+                        f_rawvalue = silence_pcmu_;
+                        break;
+                    case PT_PCMA:
+                        f_rawvalue = silence_pcma_;
+                        break;
+                    default:
+                        f_rawvalue = 0;
+                        break;
+                    }
+                    f_write_silence--;
+                } else if (r_write_silence > 0) {
+                    fwd_tempfile_->getChar(&f_rawvalue);
+                    switch (rev_statinfo_.reg_pt) {
+                    case PT_PCMU:
+                        r_rawvalue = silence_pcmu_;
+                        break;
+                    case PT_PCMA:
+                        r_rawvalue = silence_pcma_;
+                        break;
+                    default:
+                        r_rawvalue = 0;
+                        break;
+                    }
+                    r_write_silence--;
+                } else {
+                    fwd_tempfile_->getChar(&f_rawvalue);
+                    rev_tempfile_->getChar(&r_rawvalue);
+                }
+                if (fwd_tempfile_->atEnd() && rev_tempfile_->atEnd())
+                    break;
+                if ((fwd_statinfo_.pt == PT_PCMU)
+                        && (rev_statinfo_.pt == PT_PCMU)) {
+                    sample = (ulaw2linear((unsigned char)r_rawvalue)
+                              + ulaw2linear((unsigned char)f_rawvalue)) / 2;
+                    phton16(pd, sample);
+                }
+                else if ((fwd_statinfo_.pt == PT_PCMA)
+                         && (rev_statinfo_.pt == PT_PCMA)) {
+                    sample = (alaw2linear((unsigned char)r_rawvalue)
+                              + alaw2linear((unsigned char)f_rawvalue)) / 2;
+                    phton16(pd, sample);
+                } else {
+                    goto copy_file_err;
+                }
+
+                nchars = save_file.write((const char *)pd, 2);
+                if (nchars < 2) {
+                    goto copy_file_err;
+                }
+            }
+        }
+        }
+    } else if (save_format == save_audio_raw_) { /* raw format */
+        QFile *tempfile;
+        switch (direction) {
+        /* Only forward direction */
+        case dir_forward_: {
+//            progbar_count = user_data->forward.saveinfo.count;
+//            progbar_quantum = user_data->forward.saveinfo.count/100;
+            tempfile = fwd_tempfile_;
+            break;
+        }
+            /* only reversed direction */
+        case dir_reverse_: {
+//            progbar_count = user_data->reversed.saveinfo.count;
+//            progbar_quantum = user_data->reversed.saveinfo.count/100;
+            tempfile = rev_tempfile_;
+            break;
+        }
+        default: {
+            goto copy_file_err;
+        }
+        }
+
+        int chunk_size = 65536;
+        /* XXX how do you just copy the file? */
+        while (chunk_size > 0) {
+            if (stop_flag)
+                break;
+            QByteArray bytes = tempfile->read(chunk_size);
+//            if ((count > progbar_nextstep) && (count <= progbar_count)) {
+//                update_progress_dlg(progbar,
+//                                    (gfloat) count/progbar_count, "Saving");
+//                progbar_nextstep = progbar_nextstep + progbar_quantum;
+//            }
+//            count++;
+
+            if (!save_file.write(bytes)) {
+                goto copy_file_err;
+            }
+            chunk_size = bytes.length();
+        }
+    }
+
+//	ret_val = TRUE;
+//	goto copy_file_xit;
+
+copy_file_err:
+    return;
+//    ret_val = FALSE;
+//    goto copy_file_xit;
+
+//copy_file_xit:
+//	destroy_progress_dlg(progbar);
+//	fclose(forw_stream);
+//	fclose(rev_stream);
+//	fclose(to_stream);
+    //	return ret_val;
+}
+
+// XXX The GTK+ UI saves the length and timestamp.
+void RtpAnalysisDialog::saveCsv(RtpAnalysisDialog::StreamDirection direction)
+{
+    QString caption;
+
+    switch (direction) {
+    case dir_forward_:
+        caption = tr("Save forward stream CSV");
+        break;
+    case dir_reverse_:
+        caption = tr("Save reverse stream CSV");
+        break;
+    case dir_both_:
+    default:
+        caption = tr("Save CSV");
+        break;
+    }
+
+    QString file_path = QFileDialog::getSaveFileName(
+                this, caption, wsApp->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);
+
+    if (direction == dir_forward_ || direction == dir_both_) {
+        save_file.write("Forward\n");
+
+        for (int row = 0; row < ui->forwardTreeWidget->topLevelItemCount(); row++) {
+            QTreeWidgetItem *ti = ui->forwardTreeWidget->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 ((int) v.type() == (int) QMetaType::QString) {
+                    values << QString("\"%1\"").arg(v.toString());
+                } else {
+                    values << v.toString();
+                }
+            }
+            save_file.write(values.join(",").toUtf8());
+            save_file.write("\n");
+        }
+    }
+    if (direction == dir_both_) {
+        save_file.write("\n");
+    }
+    if (direction == dir_reverse_ || direction == dir_both_) {
+        save_file.write("Reverse\n");
+
+        for (int row = 0; row < ui->forwardTreeWidget->topLevelItemCount(); row++) {
+            QTreeWidgetItem *ti = ui->forwardTreeWidget->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 ((int) v.type() == (int) QMetaType::QString) {
+                    values << QString("\"%1\"").arg(v.toString());
+                } else {
+                    values << v.toString();
+                }
+            }
+            save_file.write(values.join(",").toUtf8());
+            save_file.write("\n");
+        }
+    }
+}
+
+// Adapted from rtp_analysis.c:process_node
+guint32 RtpAnalysisDialog::processNode(proto_node *ptree_node, header_field_info *hfinformation, const gchar *proto_field, bool *ok)
+{
+    field_info        *finfo;
+    proto_node        *proto_sibling_node;
+    header_field_info *hfssrc;
+    ipv4_addr         *ipv4;
+
+    finfo = PNODE_FINFO(ptree_node);
+
+    /* Caller passed top of the protocol tree. Expected child node */
+    g_assert(finfo);
+
+    if (hfinformation == (finfo->hfinfo)) {
+        hfssrc = proto_registrar_get_byname(proto_field);
+        if (hfssrc == NULL) {
+            return 0;
+        }
+        for (ptree_node = ptree_node->first_child;
+             ptree_node != NULL;
+             ptree_node = ptree_node->next) {
+            finfo = PNODE_FINFO(ptree_node);
+            if (hfssrc == finfo->hfinfo) {
+                guint32 result;
+                if (hfinformation->type == FT_IPv4) {
+                    ipv4 = (ipv4_addr *)fvalue_get(&finfo->value);
+                    result = ipv4_get_net_order_addr(ipv4);
+                } else {
+                    result = fvalue_get_uinteger(&finfo->value);
+                }
+                if (ok) *ok = true;
+                return result;
+            }
+        }
+        if (!ptree_node) {
+            return 0;
+        }
+    }
+
+    proto_sibling_node = ptree_node->next;
+
+    if (proto_sibling_node) {
+        return processNode(proto_sibling_node, hfinformation, proto_field, ok);
+    } else {
+        return 0;
+    }
+}
+
+// Adapted from rtp_analysis.c:get_int_value_from_proto_tree
+guint32 RtpAnalysisDialog::getIntFromProtoTree(proto_tree *protocol_tree, const gchar *proto_name, const gchar *proto_field, bool *ok)
+{
+    proto_node *ptree_node;
+    header_field_info *hfinformation;
+
+    if (ok) *ok = false;
+
+    hfinformation = proto_registrar_get_byname(proto_name);
+    if (hfinformation == NULL) {
+        return 0;
+    }
+
+    ptree_node = ((proto_node *)protocol_tree)->first_child;
+    if (!ptree_node) {
+        return 0;
+    }
+
+    return processNode(ptree_node, hfinformation, proto_field, ok);
+}
+
+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) {
+        graph_ctx_menu_.exec(event->globalPos());
+    }
+}
+
+void RtpAnalysisDialog::showStreamMenu(QPoint pos)
+{
+    QTreeWidget *cur_tree = qobject_cast<QTreeWidget *>(ui->tabWidget->currentWidget());
+    if (!cur_tree) return;
+
+    updateWidgets();
+    stream_ctx_menu_.popup(cur_tree->viewport()->mapToGlobal(pos));
+}
+
+/*
+ * Editor modelines
+ *
+ * Local Variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * ex: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */
diff --git a/ui/qt/rtp_analysis_dialog.h b/ui/qt/rtp_analysis_dialog.h
new file mode 100644
index 0000000000..99f9bd2f64
--- /dev/null
+++ b/ui/qt/rtp_analysis_dialog.h
@@ -0,0 +1,156 @@
+/* rtp_analysis_dialog.h
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef RTP_ANALYSIS_DIALOG_H
+#define RTP_ANALYSIS_DIALOG_H
+
+#include <config.h>
+
+#include <glib.h>
+
+#include "epan/address.h"
+
+#include "ui/rtp_analysis.h"
+#include "ui/rtp_stream.h"
+
+#include <QAbstractButton>
+#include <QMenu>
+
+#include "wireshark_dialog.h"
+
+namespace Ui {
+class RtpAnalysisDialog;
+}
+
+class QCPGraph;
+class QTemporaryFile;
+
+class RtpAnalysisDialog : public WiresharkDialog
+{
+    Q_OBJECT
+
+public:
+    explicit RtpAnalysisDialog(QWidget &parent, CaptureFile &cf);
+    ~RtpAnalysisDialog();
+
+signals:
+    void goToPacket(int packet_num);
+
+protected:
+    virtual void reject();
+
+protected slots:
+    virtual void updateWidgets();
+
+private slots:
+    void on_actionGoToPacket_triggered();
+    void on_actionNextProblem_triggered();
+    void on_fJitterCheckBox_toggled(bool checked);
+    void on_fDiffCheckBox_toggled(bool checked);
+    void on_fDeltaCheckBox_toggled(bool checked);
+    void on_rJitterCheckBox_toggled(bool checked);
+    void on_rDiffCheckBox_toggled(bool checked);
+    void on_rDeltaCheckBox_toggled(bool checked);
+    void on_actionSaveAudio_triggered();
+    void on_actionSaveForwardAudio_triggered();
+    void on_actionSaveReverseAudio_triggered();
+    void on_actionSaveCsv_triggered();
+    void on_actionSaveForwardCsv_triggered();
+    void on_actionSaveReverseCsv_triggered();
+    void on_actionSaveGraph_triggered();
+    void on_buttonBox_helpRequested();
+    void showStreamMenu(QPoint pos);
+    void graphClicked(QMouseEvent *event);
+
+private:
+    Ui::RtpAnalysisDialog *ui;
+    enum StreamDirection { dir_both_, dir_forward_, dir_reverse_ };
+
+    address src_fwd_;
+    guint32 port_src_fwd_;
+    address dst_fwd_;
+    guint32 port_dst_fwd_;
+    guint32 ssrc_fwd_;
+    address src_rev_;
+    guint32 port_src_rev_;
+    address dst_rev_;
+    guint32 port_dst_rev_;
+    guint32 ssrc_rev_;
+    int num_streams_;
+
+    tap_rtp_stat_t fwd_statinfo_;
+    tap_rtp_stat_t rev_statinfo_;
+
+    QTemporaryFile *fwd_tempfile_;
+    QTemporaryFile *rev_tempfile_;
+
+    // Graph data for QCustomPlot
+    QList<QCPGraph *>graphs_;
+    QVector<double> fwd_time_vals_;
+    QVector<double> fwd_jitter_vals_;
+    QVector<double> fwd_diff_vals_;
+    QVector<double> fwd_delta_vals_;
+
+    QVector<double> rev_time_vals_;
+    QVector<double> rev_jitter_vals_;
+    QVector<double> rev_diff_vals_;
+    QVector<double> rev_delta_vals_;
+
+    rtpstream_tapinfo_t tapinfo_;
+    QString err_str_;
+
+    QMenu stream_ctx_menu_;
+    QMenu graph_ctx_menu_;
+
+    // Tap callbacks
+    static void tapReset(void *tapinfo_ptr);
+    static gboolean tapPacket(void *tapinfo_ptr, packet_info *pinfo, epan_dissect_t *, const void *rtpinfo_ptr);
+    static void tapDraw(void *tapinfo_ptr);
+
+    void resetStatistics();
+    void addPacket(bool forward, packet_info *pinfo, const struct _rtp_info *rtpinfo);
+    void savePayload(QTemporaryFile *tmpfile, tap_rtp_stat_t *statinfo, packet_info *pinfo, const struct _rtp_info *rtpinfo);
+    void updateStatistics();
+    void updateGraph();
+
+    void saveAudio(StreamDirection direction);
+    void saveCsv(StreamDirection direction);
+
+    guint32 processNode(proto_node *ptree_node, header_field_info *hfinformation, const gchar* proto_field, bool *ok);
+    guint32 getIntFromProtoTree(proto_tree *protocol_tree, const gchar *proto_name, const gchar *proto_field, bool *ok);
+
+    bool eventFilter(QObject*, QEvent* event);
+};
+
+#endif // RTP_ANALYSIS_DIALOG_H
+
+/*
+ * Editor modelines
+ *
+ * Local Variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * ex: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */
diff --git a/ui/qt/rtp_analysis_dialog.ui b/ui/qt/rtp_analysis_dialog.ui
new file mode 100644
index 0000000000..a593e37693
--- /dev/null
+++ b/ui/qt/rtp_analysis_dialog.ui
@@ -0,0 +1,346 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RtpAnalysisDialog</class>
+ <widget class="QDialog" name="RtpAnalysisDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>650</width>
+    <height>475</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_3">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <layout class="QVBoxLayout" name="verticalLayout">
+       <item>
+        <widget class="QLabel" name="statisticsLabel">
+         <property name="text">
+          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;Forward&lt;/span&gt;&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-size:medium; font-weight:600;&quot;&gt;Reverse&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+         </property>
+         <property name="textFormat">
+          <enum>Qt::RichText</enum>
+         </property>
+         <property name="textInteractionFlags">
+          <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse</set>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <spacer name="verticalSpacer">
+         <property name="orientation">
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>40</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <widget class="QTabWidget" name="tabWidget">
+       <property name="currentIndex">
+        <number>0</number>
+       </property>
+       <widget class="QTreeWidget" name="forwardTreeWidget">
+        <property name="rootIsDecorated">
+         <bool>false</bool>
+        </property>
+        <property name="itemsExpandable">
+         <bool>false</bool>
+        </property>
+        <property name="expandsOnDoubleClick">
+         <bool>false</bool>
+        </property>
+        <attribute name="title">
+         <string>Forward</string>
+        </attribute>
+        <column>
+         <property name="text">
+          <string>Packet</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Sequence</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Delta (ms)</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Jitter</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Skew</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Bandwidth</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Marker</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Status</string>
+         </property>
+        </column>
+       </widget>
+       <widget class="QTreeWidget" name="reverseTreeWidget">
+        <property name="rootIsDecorated">
+         <bool>false</bool>
+        </property>
+        <property name="itemsExpandable">
+         <bool>false</bool>
+        </property>
+        <attribute name="title">
+         <string>Reverse</string>
+        </attribute>
+        <column>
+         <property name="text">
+          <string notr="true">1</string>
+         </property>
+        </column>
+       </widget>
+       <widget class="QWidget" name="graphTab">
+        <attribute name="title">
+         <string>Graph</string>
+        </attribute>
+        <layout class="QVBoxLayout" name="verticalLayout_2" stretch="1,0,0">
+         <item>
+          <widget class="QCustomPlot" name="streamGraph" native="true"/>
+         </item>
+         <item>
+          <layout class="QHBoxLayout" name="forwardHorizontalLayout">
+           <item>
+            <widget class="QCheckBox" name="fJitterCheckBox">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Show or hide forward jitter values.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>Forward Jitter</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QCheckBox" name="fDiffCheckBox">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Show or hide forward difference values.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>Forward Difference</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QCheckBox" name="fDeltaCheckBox">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Show or hide forward delta values.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>Forward Delta</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QHBoxLayout" name="reverseHorizontalLayout">
+           <item>
+            <widget class="QCheckBox" name="rJitterCheckBox">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Show or hide reverse jitter values.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>Reverse Jitter</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QCheckBox" name="rDiffCheckBox">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Show or hide reverse difference values.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>Reverse Difference</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QCheckBox" name="rDeltaCheckBox">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Show or hide reverse delta values.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>Reverse Delta</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+        </layout>
+       </widget>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QLabel" name="hintLabel">
+     <property name="text">
+      <string>&lt;small&gt;&lt;i&gt;A hint.&lt;/i&gt;&lt;/small&gt;</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Close|QDialogButtonBox::Help|QDialogButtonBox::Save</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+  <action name="actionSaveAudio">
+   <property name="text">
+    <string>Audio</string>
+   </property>
+   <property name="toolTip">
+    <string>Save the audio data for both channels.</string>
+   </property>
+  </action>
+  <action name="actionSaveForwardAudio">
+   <property name="text">
+    <string>Forward Stream Audio</string>
+   </property>
+   <property name="toolTip">
+    <string>Save the forward stream audio data.</string>
+   </property>
+  </action>
+  <action name="actionSaveReverseAudio">
+   <property name="text">
+    <string>Reverse Stream Audio</string>
+   </property>
+   <property name="toolTip">
+    <string>Save the reverse stream audio data.</string>
+   </property>
+  </action>
+  <action name="actionSaveCsv">
+   <property name="text">
+    <string>CSV</string>
+   </property>
+   <property name="toolTip">
+    <string>Save both tables as CSV.</string>
+   </property>
+  </action>
+  <action name="actionSaveForwardCsv">
+   <property name="text">
+    <string>Forward Stream CSV</string>
+   </property>
+   <property name="toolTip">
+    <string>Save the forward table as CSV.</string>
+   </property>
+  </action>
+  <action name="actionSaveReverseCsv">
+   <property name="text">
+    <string>Reverse Stream CSV</string>
+   </property>
+   <property name="toolTip">
+    <string>Save the reverse table as CSV.</string>
+   </property>
+  </action>
+  <action name="actionSaveGraph">
+   <property name="text">
+    <string>Save Graph</string>
+   </property>
+   <property name="toolTip">
+    <string>Save the graph image.</string>
+   </property>
+  </action>
+  <action name="actionGoToPacket">
+   <property name="text">
+    <string>Go to Packet</string>
+   </property>
+   <property name="toolTip">
+    <string>Select the corresponding packet in the packet list.</string>
+   </property>
+   <property name="shortcut">
+    <string>G</string>
+   </property>
+  </action>
+  <action name="actionNextProblem">
+   <property name="text">
+    <string>Next Problem Packet</string>
+   </property>
+   <property name="toolTip">
+    <string>Go to the next problem packet</string>
+   </property>
+   <property name="shortcut">
+    <string>N</string>
+   </property>
+  </action>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QCustomPlot</class>
+   <extends>QWidget</extends>
+   <header>qcustomplot.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>RtpAnalysisDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>RtpAnalysisDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/ui/qt/rtp_stream_dialog.cpp b/ui/qt/rtp_stream_dialog.cpp
index 0685bcaf8e..9cbe8c86b7 100644
--- a/ui/qt/rtp_stream_dialog.cpp
+++ b/ui/qt/rtp_stream_dialog.cpp
@@ -316,7 +316,7 @@ bool RtpStreamDialog::eventFilter(QObject *, QEvent *event)
 
 void RtpStreamDialog::tapDraw(rtpstream_tapinfo_t *tapinfo)
 {
-    RtpStreamDialog *rtp_stream_dialog = static_cast<RtpStreamDialog *>(tapinfo->tap_data);
+    RtpStreamDialog *rtp_stream_dialog = dynamic_cast<RtpStreamDialog *>((RtpStreamDialog *)tapinfo->tap_data);
     if (rtp_stream_dialog) {
         rtp_stream_dialog->updateStreams();
     }
@@ -326,9 +326,8 @@ void RtpStreamDialog::tapMarkPacket(rtpstream_tapinfo_t *tapinfo, frame_data *fd
 {
     if (!tapinfo) return;
 
-    RtpStreamDialog *rtp_stream_dialog = static_cast<RtpStreamDialog *>(tapinfo->tap_data);
+    RtpStreamDialog *rtp_stream_dialog = dynamic_cast<RtpStreamDialog *>((RtpStreamDialog *)tapinfo->tap_data);
     if (rtp_stream_dialog) {
-        rtp_stream_dialog->need_redraw_ = true;
         cf_mark_frame(rtp_stream_dialog->cap_file_.capFile(), fd);
         rtp_stream_dialog->need_redraw_ = true;
     }
diff --git a/ui/qt/syntax_line_edit.cpp b/ui/qt/syntax_line_edit.cpp
index 282d969edd..08cb23327d 100644
--- a/ui/qt/syntax_line_edit.cpp
+++ b/ui/qt/syntax_line_edit.cpp
@@ -92,7 +92,7 @@ void SyntaxLineEdit::setSyntaxState(SyntaxState state) {
             .arg("palette(text)")   // Foreground
             .arg(ColorUtils::fromColorT(&prefs.gui_text_valid).name())        // Valid
             .arg(ColorUtils::fromColorT(&prefs.gui_text_invalid).name())      // Invalid
-            .arg(ColorUtils::fromColorT(&prefs.gui_text_deprecated).name())   // VDeprecated
+            .arg(ColorUtils::fromColorT(&prefs.gui_text_deprecated).name())   // Deprecated
             ;
     setStyleSheet(style_sheet_);
 }
diff --git a/ui/rtp_analysis.h b/ui/rtp_analysis.h
index a10d628c95..65dae42699 100644
--- a/ui/rtp_analysis.h
+++ b/ui/rtp_analysis.h
@@ -39,6 +39,10 @@
  *  @todo what's this?
  */
 
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
 void rtp_analysis(
     address *ip_src_fwd,
     guint32  port_src_fwd,
@@ -88,7 +92,7 @@ typedef struct _tap_rtp_stat_t {
     double          sumt2;
     double          sumtTS;
     double          time;       /**< Unit is ms */
-    double          start_time;
+    double          start_time; /**< Unit is ms */
     double          lastnominaltime;
     double          max_delta;
     double          max_jitter;
@@ -127,6 +131,10 @@ extern int rtp_packet_analyse(tap_rtp_stat_t *statinfo,
                               packet_info *pinfo,
                               const struct _rtp_info *rtpinfo);
 
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
 #endif /* __RTP_ANALYSIS_H__ */
 
 /*
diff --git a/ui/tap-rtp-common.c b/ui/tap-rtp-common.c
index d260a0f1a4..a95e261b50 100644
--- a/ui/tap-rtp-common.c
+++ b/ui/tap-rtp-common.c
@@ -4,7 +4,7 @@
  * Copyright 2008, Ericsson AB
  * By Balint Reczey <balint.reczey@ericsson.com>
  *
- * most functions are copied from ui/gtk/rtp_stream.c and ui/gtk/rtp_analisys.c
+ * most functions are copied from ui/gtk/rtp_stream.c and ui/gtk/rtp_analysis.c
  * Copyright 2003, Alcatel Business Systems
  * By Lars Ruoff <lars.ruoff@gmx.net>
  *
diff --git a/ui/tap-rtp-common.h b/ui/tap-rtp-common.h
index a4242c794e..239180383c 100644
--- a/ui/tap-rtp-common.h
+++ b/ui/tap-rtp-common.h
@@ -27,14 +27,42 @@
  * Foundation,  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#ifndef TAP_RTP_COMMON_H_INCLUDED
-#define TAP_RTP_COMMON_H_INCLUDED
+#ifndef __TAP_RTP_COMMON_H__
+#define __TAP_RTP_COMMON_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* type of error when saving voice in a file didn't succeed */
+typedef enum {
+    TAP_RTP_WRONG_CODEC,
+    TAP_RTP_WRONG_LENGTH,
+    TAP_RTP_PADDING_ERROR,
+    TAP_RTP_SHORT_FRAME,
+    TAP_RTP_FILE_OPEN_ERROR,
+    TAP_RTP_FILE_WRITE_ERROR,
+    TAP_RTP_NO_DATA
+} error_type_t;
+
+typedef struct _tap_rtp_save_info_t {
+    FILE *fp;
+    guint32 count;
+    error_type_t error_type;
+    gboolean saved;
+} tap_rtp_save_info_t;
+
+struct _rtp_stream_info;
 
 void rtpstream_reset_cb(void*);
-void rtp_write_header(rtp_stream_info_t*, FILE*);
+void rtp_write_header(struct _rtp_stream_info*, FILE*);
 int rtpstream_packet(void*, packet_info*, epan_dissect_t *, const void *);
 
-#endif /*TAP_RTP_COMMON_H_INCLUDED*/
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __TAP_RTP_COMMON_H__ */
 
 /*
  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
diff --git a/ui/utf8_entities.h b/ui/utf8_entities.h
index 84d8bfd76e..05285d5517 100644
--- a/ui/utf8_entities.h
+++ b/ui/utf8_entities.h
@@ -31,16 +31,19 @@
  * and other places
  */
 
-#define UTF8_MIDDLE_DOT                     "\xc2\xb7"      /*  183 /   0xb7 */
+#define UTF8_MIDDLE_DOT                     "\xc2\xb7"      /*   183 /   0xb7 */
 
-#define UTF8_BULLET                     "\xe2\x80\xa2"      /* 8226 / 0x2024 */
-#define UTF8_EM_DASH                    "\xe2\x80\x94"      /* 8212 / 0x2014 */
-#define UTF8_HORIZONTAL_ELLIPSIS        "\xe2\x80\xa6"      /* 8230 / 0x2026 */
-#define UTF8_LEFTWARDS_ARROW            "\xe2\x86\x90"      /* 8592 / 0x2190 */
-#define UTF8_RIGHTWARDS_ARROW           "\xe2\x86\x92"      /* 8594 / 0x2192 */
-#define UTF8_LEFT_RIGHT_ARROW           "\xe2\x86\x94"      /* 8596 / 0x2194 */
+#define UTF8_BULLET                     "\xe2\x80\xa2"      /*  8226 / 0x2024 */
+#define UTF8_EM_DASH                    "\xe2\x80\x94"      /*  8212 / 0x2014 */
+#define UTF8_HORIZONTAL_ELLIPSIS        "\xe2\x80\xa6"      /*  8230 / 0x2026 */
+#define UTF8_LEFTWARDS_ARROW            "\xe2\x86\x90"      /*  8592 / 0x2190 */
+#define UTF8_RIGHTWARDS_ARROW           "\xe2\x86\x92"      /*  8594 / 0x2192 */
+#define UTF8_LEFT_RIGHT_ARROW           "\xe2\x86\x94"      /*  8596 / 0x2194 */
 
-#define UTF8_PLACE_OF_INTEREST_SIGN     "\xe2\x8c\x98"      /* 8984 / 0x2318 */
+#define UTF8_PLACE_OF_INTEREST_SIGN     "\xe2\x8c\x98"      /*  8984 / 0x2318 */
+
+#define UTF8_CHECK_MARK                 "\xe2\x9c\x93"      /* 10003 / 0x2713 */
+#define UTF8_BALLOT_X                   "\xe2\x9c\x97"      /* 10007 / 0x2717 */
 #endif /* __UTF8_ENTITIES_H__ */
 
 /*