Adding upstream version 4.2.2.upstream/4.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 953 insertions, 0 deletions

diff --git a/ui/qt/rtp_audio_stream.cpp b/ui/qt/rtp_audio_stream.cpp
new file mode 100644
index 0000000..5ceb809
--- /dev/null
+++ b/ui/qt/rtp_audio_stream.cpp
@@ -0,0 +1,953 @@
+/* rtp_audio_frame.cpp
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "rtp_audio_stream.h"
+
+#ifdef QT_MULTIMEDIA_LIB
+
+#include <speex/speex_resampler.h>
+
+#include <epan/rtp_pt.h>
+#include <epan/to_str.h>
+
+#include <epan/dissectors/packet-rtp.h>
+
+#include <ui/rtp_media.h>
+#include <ui/rtp_stream.h>
+#include <ui/tap-rtp-common.h>
+
+#include <wsutil/nstime.h>
+
+#include <ui/qt/utils/rtp_audio_routing_filter.h>
+#include <ui/qt/utils/rtp_audio_file.h>
+
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+#include <QAudioDevice>
+#include <QAudioSink>
+#endif
+#include <QAudioFormat>
+#include <QAudioOutput>
+#include <QVariant>
+#include <QTimer>
+
+// To do:
+// - Only allow one rtpstream_info_t per RtpAudioStream?
+
+static const spx_int16_t visual_sample_rate_ = 1000;
+
+RtpAudioStream::RtpAudioStream(QObject *parent, rtpstream_id_t *id, bool stereo_required) :
+    QObject(parent)
+    , first_packet_(true)
+    , decoders_hash_(rtp_decoder_hash_table_new())
+    , global_start_rel_time_(0.0)
+    , start_abs_offset_(0.0)
+    , start_rel_time_(0.0)
+    , stop_rel_time_(0.0)
+    , stereo_required_(stereo_required)
+    , first_sample_rate_(0)
+    , audio_out_rate_(0)
+    , audio_requested_out_rate_(0)
+    , max_sample_val_(1)
+    , max_sample_val_used_(1)
+    , color_(0)
+    , jitter_buffer_size_(50)
+    , timing_mode_(RtpAudioStream::JitterBuffer)
+    , start_play_time_(0)
+    , audio_output_(NULL)
+{
+    rtpstream_id_copy(id, &id_);
+    memset(&rtpstream_, 0, sizeof(rtpstream_));
+    rtpstream_id_copy(&id_, &rtpstream_.id);
+
+    // Rates will be set later, we just init visual resampler
+    visual_resampler_ = speex_resampler_init(1, visual_sample_rate_,
+                                                visual_sample_rate_, SPEEX_RESAMPLER_QUALITY_MIN, NULL);
+
+    try {
+        // RtpAudioFile is ready for writing Frames
+        audio_file_ = new RtpAudioFile(prefs.gui_rtp_player_use_disk1, prefs.gui_rtp_player_use_disk2);
+    } catch (...) {
+        speex_resampler_destroy(visual_resampler_);
+        rtpstream_info_free_data(&rtpstream_);
+        rtpstream_id_free(&id_);
+        throw -1;
+    }
+
+    // RTP_STREAM_DEBUG("Writing to %s", tempname.toUtf8().constData());
+}
+
+RtpAudioStream::~RtpAudioStream()
+{
+    for (int i = 0; i < rtp_packets_.size(); i++) {
+        rtp_packet_t *rtp_packet = rtp_packets_[i];
+        g_free(rtp_packet->info);
+        g_free(rtp_packet->payload_data);
+        g_free(rtp_packet);
+    }
+    g_hash_table_destroy(decoders_hash_);
+    speex_resampler_destroy(visual_resampler_);
+    rtpstream_info_free_data(&rtpstream_);
+    rtpstream_id_free(&id_);
+    if (audio_file_) delete audio_file_;
+    // temp_file_ is released by audio_output_
+    if (audio_output_) delete audio_output_;
+}
+
+bool RtpAudioStream::isMatch(const rtpstream_id_t *id) const
+{
+    if (id
+        && rtpstream_id_equal(&id_, id, RTPSTREAM_ID_EQUAL_SSRC))
+        return true;
+    return false;
+}
+
+bool RtpAudioStream::isMatch(const _packet_info *pinfo, const _rtp_info *rtp_info) const
+{
+    if (pinfo && rtp_info
+        && rtpstream_id_equal_pinfo_rtp_info(&id_, pinfo, rtp_info))
+        return true;
+    return false;
+}
+
+void RtpAudioStream::addRtpPacket(const struct _packet_info *pinfo, const struct _rtp_info *rtp_info)
+{
+    if (!rtp_info) return;
+
+    if (first_packet_) {
+        rtpstream_info_analyse_init(&rtpstream_, pinfo, rtp_info);
+        first_packet_ = false;
+    }
+    rtpstream_info_analyse_process(&rtpstream_, pinfo, rtp_info);
+
+    rtp_packet_t *rtp_packet = g_new0(rtp_packet_t, 1);
+    rtp_packet->info = (struct _rtp_info *) g_memdup2(rtp_info, sizeof(struct _rtp_info));
+    if (rtp_info->info_all_data_present && (rtp_info->info_payload_len != 0)) {
+        rtp_packet->payload_data = (guint8 *) g_memdup2(&(rtp_info->info_data[rtp_info->info_payload_offset]),
+          rtp_info->info_payload_len);
+    }
+
+    if (rtp_packets_.size() < 1) { // First packet
+        start_abs_offset_ = nstime_to_sec(&pinfo->abs_ts) - start_rel_time_;
+        start_rel_time_ = stop_rel_time_ = nstime_to_sec(&pinfo->rel_ts);
+    }
+    rtp_packet->frame_num = pinfo->num;
+    rtp_packet->arrive_offset = nstime_to_sec(&pinfo->rel_ts) - start_rel_time_;
+
+    rtp_packets_ << rtp_packet;
+}
+
+void RtpAudioStream::clearPackets()
+{
+    for (int i = 0; i < rtp_packets_.size(); i++) {
+        rtp_packet_t *rtp_packet = rtp_packets_[i];
+        g_free(rtp_packet->info);
+        g_free(rtp_packet->payload_data);
+        g_free(rtp_packet);
+    }
+    rtp_packets_.clear();
+    rtpstream_info_free_data(&rtpstream_);
+    memset(&rtpstream_, 0, sizeof(rtpstream_));
+    rtpstream_id_copy(&id_, &rtpstream_.id);
+    first_packet_ = true;
+}
+
+void RtpAudioStream::reset(double global_start_time)
+{
+    global_start_rel_time_ = global_start_time;
+    stop_rel_time_ = start_rel_time_;
+    audio_out_rate_ = 0;
+    max_sample_val_ = 1;
+    packet_timestamps_.clear();
+    visual_samples_.clear();
+    out_of_seq_timestamps_.clear();
+    jitter_drop_timestamps_.clear();
+}
+
+AudioRouting RtpAudioStream::getAudioRouting()
+{
+    return audio_routing_;
+}
+
+void RtpAudioStream::setAudioRouting(AudioRouting audio_routing)
+{
+    audio_routing_ = audio_routing;
+}
+
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+void RtpAudioStream::decode(QAudioDevice out_device)
+#else
+void RtpAudioStream::decode(QAudioDeviceInfo out_device)
+#endif
+{
+    if (rtp_packets_.size() < 1) return;
+
+    audio_file_->setFrameWriteStage();
+    decodeAudio(out_device);
+
+    // Skip silence at begin of the stream
+    audio_file_->setFrameReadStage(prepend_samples_);
+
+    speex_resampler_reset_mem(visual_resampler_);
+    decodeVisual();
+    audio_file_->setDataReadStage();
+}
+
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+quint32 RtpAudioStream::calculateAudioOutRate(QAudioDevice out_device, unsigned int sample_rate, unsigned int requested_out_rate)
+#else
+quint32 RtpAudioStream::calculateAudioOutRate(QAudioDeviceInfo out_device, unsigned int sample_rate, unsigned int requested_out_rate)
+#endif
+{
+    quint32 out_rate;
+
+    // Use the first non-zero rate we find. Ajust it to match
+    // our audio hardware.
+    QAudioFormat format;
+    format.setSampleRate(sample_rate);
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+    // Must match rtp_media.h.
+    format.setSampleFormat(QAudioFormat::Int16);
+#else
+    format.setSampleSize(SAMPLE_BYTES * 8); // bits
+    format.setSampleType(QAudioFormat::SignedInt);
+#endif
+    if (stereo_required_) {
+        format.setChannelCount(2);
+    } else {
+        format.setChannelCount(1);
+    }
+#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
+    format.setCodec("audio/pcm");
+#endif
+
+    if (!out_device.isNull() &&
+        !out_device.isFormatSupported(format) &&
+        (requested_out_rate == 0)
+       ) {
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+        out_rate = out_device.preferredFormat().sampleRate();
+#else
+        out_rate = out_device.nearestFormat(format).sampleRate();
+#endif
+    } else {
+        if ((requested_out_rate != 0) &&
+            (requested_out_rate != sample_rate)
+           ) {
+            out_rate = requested_out_rate;
+        } else {
+            out_rate = sample_rate;
+        }
+    }
+
+    RTP_STREAM_DEBUG("Audio sample rate is %u", out_rate);
+
+    return out_rate;
+}
+
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+void RtpAudioStream::decodeAudio(QAudioDevice out_device)
+#else
+void RtpAudioStream::decodeAudio(QAudioDeviceInfo out_device)
+#endif
+{
+    // XXX This is more messy than it should be.
+
+    gint32 resample_buff_bytes = 0x1000;
+    SAMPLE *resample_buff = (SAMPLE *) g_malloc(resample_buff_bytes);
+    char *write_buff = NULL;
+    qint64 write_bytes = 0;
+    unsigned int channels = 0;
+    unsigned int sample_rate = 0;
+    guint32 last_sequence = 0;
+    guint32 last_sequence_w = 0;  // Last sequence number we wrote data
+
+    double rtp_time_prev = 0.0;
+    double arrive_time_prev = 0.0;
+    double pack_period = 0.0;
+    double start_time = 0.0;
+    double start_rtp_time = 0.0;
+    guint64 start_timestamp = 0;
+
+    size_t decoded_bytes_prev = 0;
+    unsigned int audio_resampler_input_rate = 0;
+    struct SpeexResamplerState_ *audio_resampler = NULL;
+
+    for (int cur_packet = 0; cur_packet < rtp_packets_.size(); cur_packet++) {
+        SAMPLE *decode_buff = NULL;
+        // TODO: Update a progress bar here.
+        rtp_packet_t *rtp_packet = rtp_packets_[cur_packet];
+
+        stop_rel_time_ = start_rel_time_ + rtp_packet->arrive_offset;
+
+        QString payload_name;
+        if (rtp_packet->info->info_payload_type_str) {
+            payload_name = rtp_packet->info->info_payload_type_str;
+        } else {
+            payload_name = try_val_to_str_ext(rtp_packet->info->info_payload_type, &rtp_payload_type_short_vals_ext);
+        }
+        if (!payload_name.isEmpty()) {
+            payload_names_ << payload_name;
+        }
+
+        if (cur_packet < 1) { // First packet
+            start_timestamp = rtp_packet->info->info_extended_timestamp;
+            start_rtp_time = 0;
+            rtp_time_prev = 0;
+            last_sequence = rtp_packet->info->info_extended_seq_num - 1;
+        }
+
+        size_t decoded_bytes = decode_rtp_packet(rtp_packet, &decode_buff, decoders_hash_, &channels, &sample_rate);
+        // XXX: We don't actually *do* anything with channels, and just treat
+        // everything as if it were mono
+
+        unsigned rtp_clock_rate = sample_rate;
+        if (rtp_packet->info->info_payload_type == PT_G722) {
+            // G.722 sample rate is 16kHz, but RTP clock rate is 8kHz
+            // for historic reasons.
+            rtp_clock_rate = 8000;
+        }
+
+        // Length 2 for PT_PCM mean silence packet probably, ignore
+        if (decoded_bytes == 0 || sample_rate == 0 ||
+            ((rtp_packet->info->info_payload_type == PT_PCMU ||
+              rtp_packet->info->info_payload_type == PT_PCMA
+             ) && (decoded_bytes == 2)
+            )
+           ) {
+            // We didn't decode anything. Clean up and prep for
+            // the next packet.
+            last_sequence = rtp_packet->info->info_extended_seq_num;
+            g_free(decode_buff);
+            continue;
+        }
+
+        if (audio_out_rate_ == 0) {
+            first_sample_rate_ = sample_rate;
+
+            // We calculate audio_out_rate just for first sample_rate.
+            // All later are just resampled to it.
+            // Side effect: it creates and initiates resampler if needed
+            audio_out_rate_ = calculateAudioOutRate(out_device, sample_rate, audio_requested_out_rate_);
+
+            // Calculate count of prepend samples for the stream
+            // The earliest stream starts at 0.
+            // Note: Order of operations and separation to two formulas is
+            // important.
+            // When joined, calculated incorrectly - probably caused by
+            // conversions between int/double
+            prepend_samples_ = (start_rel_time_ - global_start_rel_time_) * sample_rate;
+            prepend_samples_ = prepend_samples_ * audio_out_rate_ / sample_rate;
+
+            // Prepend silence to match our sibling streams.
+            if ((prepend_samples_ > 0) && (audio_out_rate_ != 0)) {
+                audio_file_->frameWriteSilence(rtp_packet->frame_num, prepend_samples_);
+            }
+        }
+
+        if (rtp_packet->info->info_extended_seq_num != last_sequence+1) {
+            out_of_seq_timestamps_.append(stop_rel_time_);
+        }
+        last_sequence = rtp_packet->info->info_extended_seq_num;
+
+        double rtp_time = (double)(rtp_packet->info->info_extended_timestamp-start_timestamp)/rtp_clock_rate - start_rtp_time;
+        double arrive_time;
+        if (timing_mode_ == RtpTimestamp) {
+            arrive_time = rtp_time;
+        } else {
+            arrive_time = rtp_packet->arrive_offset - start_time;
+        }
+
+        double diff = qAbs(arrive_time - rtp_time);
+        if (diff*1000 > jitter_buffer_size_ && timing_mode_ != Uninterrupted) {
+            // rtp_player.c:628
+
+            jitter_drop_timestamps_.append(stop_rel_time_);
+            RTP_STREAM_DEBUG("Packet drop by jitter buffer exceeded %f > %d", diff*1000, jitter_buffer_size_);
+
+            /* if there was a silence period (more than two packetization
+             * period) resync the source */
+            if ((rtp_time - rtp_time_prev) > pack_period*2) {
+                qint64 silence_samples;
+                RTP_STREAM_DEBUG("Resync...");
+
+                silence_samples = (qint64)((arrive_time - arrive_time_prev)*sample_rate - decoded_bytes_prev / SAMPLE_BYTES);
+                silence_samples = silence_samples * audio_out_rate_ / sample_rate;
+                silence_timestamps_.append(stop_rel_time_);
+                // Timestamp shift can make silence calculation negative
+                if ((silence_samples > 0) && (audio_out_rate_ != 0)) {
+                    audio_file_->frameWriteSilence(rtp_packet->frame_num, silence_samples);
+                }
+
+                decoded_bytes_prev = 0;
+                start_timestamp = rtp_packet->info->info_extended_timestamp;
+                start_rtp_time = 0;
+                start_time = rtp_packet->arrive_offset;
+                rtp_time_prev = 0;
+            }
+
+        } else {
+            // rtp_player.c:664
+            /* Add silence if it is necessary */
+            qint64 silence_samples;
+
+            if (timing_mode_ == Uninterrupted) {
+                silence_samples = 0;
+            } else {
+                silence_samples = (int)((rtp_time - rtp_time_prev)*sample_rate - decoded_bytes_prev / SAMPLE_BYTES);
+                silence_samples = silence_samples * audio_out_rate_ / sample_rate;
+            }
+
+            if (silence_samples != 0) {
+                wrong_timestamp_timestamps_.append(stop_rel_time_);
+            }
+
+            if (silence_samples > 0) {
+                silence_timestamps_.append(stop_rel_time_);
+                if ((silence_samples > 0) && (audio_out_rate_ != 0)) {
+                    audio_file_->frameWriteSilence(rtp_packet->frame_num, silence_samples);
+                }
+            }
+
+            // XXX rtp_player.c:696 adds audio here.
+            rtp_time_prev = rtp_time;
+            pack_period = (double) decoded_bytes / SAMPLE_BYTES / sample_rate;
+            decoded_bytes_prev = decoded_bytes;
+            arrive_time_prev = arrive_time;
+        }
+
+        // Prepare samples to write
+        write_buff = (char *) decode_buff;
+        write_bytes = decoded_bytes;
+
+        if (audio_out_rate_ != sample_rate) {
+            // Resample the audio to match output rate.
+            // Buffer is in SAMPLEs
+            spx_uint32_t in_len = (spx_uint32_t) (write_bytes / SAMPLE_BYTES);
+            // Output is audio_out_rate_/sample_rate bigger than input
+            spx_uint32_t out_len = (spx_uint32_t) ((guint64)in_len * audio_out_rate_ / sample_rate);
+            resample_buff = resizeBufferIfNeeded(resample_buff, &resample_buff_bytes, out_len * SAMPLE_BYTES);
+
+            if (audio_resampler &&
+                sample_rate != audio_resampler_input_rate
+               ) {
+              // Clear old resampler because input rate changed
+              speex_resampler_destroy(audio_resampler);
+              audio_resampler_input_rate = 0;
+              audio_resampler = NULL;
+            }
+            if (!audio_resampler) {
+                audio_resampler_input_rate = sample_rate;
+                audio_resampler = speex_resampler_init(1, sample_rate, audio_out_rate_, 10, NULL);
+                RTP_STREAM_DEBUG("Started resampling from %u to (out) %u Hz.", sample_rate, audio_out_rate_);
+            }
+            speex_resampler_process_int(audio_resampler, 0, decode_buff, &in_len, resample_buff, &out_len);
+
+            write_buff = (char *) resample_buff;
+            write_bytes = out_len * SAMPLE_BYTES;
+        }
+
+        // We should write only newer data to avoid duplicates in replay
+        if (last_sequence_w < last_sequence) {
+            // Write the decoded, possibly-resampled audio to our temp file.
+            audio_file_->frameWriteSamples(rtp_packet->frame_num, write_buff, write_bytes);
+            last_sequence_w = last_sequence;
+        }
+
+        g_free(decode_buff);
+    }
+    g_free(resample_buff);
+
+    if (audio_resampler) speex_resampler_destroy(audio_resampler);
+}
+
+// We preallocate buffer, 320 samples is enough for most scenarios
+#define VISUAL_BUFF_LEN (320)
+#define VISUAL_BUFF_BYTES (SAMPLE_BYTES * VISUAL_BUFF_LEN)
+void RtpAudioStream::decodeVisual()
+{
+    spx_uint32_t read_len = 0;
+    gint32 read_buff_bytes = VISUAL_BUFF_BYTES;
+    SAMPLE *read_buff = (SAMPLE *) g_malloc(read_buff_bytes);
+    gint32 resample_buff_bytes = VISUAL_BUFF_BYTES;
+    SAMPLE *resample_buff = (SAMPLE *) g_malloc(resample_buff_bytes);
+    unsigned int sample_no = 0;
+    spx_uint32_t out_len;
+    guint32 frame_num;
+    rtp_frame_type type;
+
+    speex_resampler_set_rate(visual_resampler_, audio_out_rate_, visual_sample_rate_);
+
+    // Loop over every frame record
+    // readFrameSamples() maintains size of buffer for us
+    while (audio_file_->readFrameSamples(&read_buff_bytes, &read_buff, &read_len, &frame_num, &type)) {
+        out_len = (spx_uint32_t)(((guint64)read_len * visual_sample_rate_ ) / audio_out_rate_);
+
+        if (type == RTP_FRAME_AUDIO) {
+            // We resample only audio samples
+            resample_buff = resizeBufferIfNeeded(resample_buff, &resample_buff_bytes, out_len * SAMPLE_BYTES);
+
+            // Resample
+            speex_resampler_process_int(visual_resampler_, 0, read_buff, &read_len, resample_buff, &out_len);
+
+            // Create timestamp and visual sample
+            for (unsigned i = 0; i < out_len; i++) {
+                double time = start_rel_time_ + (double) sample_no / visual_sample_rate_;
+                packet_timestamps_[time] = frame_num;
+                if (qAbs(resample_buff[i]) > max_sample_val_) max_sample_val_ = qAbs(resample_buff[i]);
+                visual_samples_.append(resample_buff[i]);
+                sample_no++;
+            }
+        } else {
+            // Insert end of line mark
+            double time = start_rel_time_ + (double) sample_no / visual_sample_rate_;
+            packet_timestamps_[time] = frame_num;
+            visual_samples_.append(SAMPLE_NaN);
+            sample_no += out_len;
+        }
+    }
+
+    max_sample_val_used_ = max_sample_val_;
+    g_free(resample_buff);
+    g_free(read_buff);
+}
+
+const QStringList RtpAudioStream::payloadNames() const
+{
+    QStringList payload_names = payload_names_.values();
+    payload_names.sort();
+    return payload_names;
+}
+
+const QVector<double> RtpAudioStream::visualTimestamps(bool relative)
+{
+    QVector<double> ts_keys = packet_timestamps_.keys().toVector();
+    if (relative) return ts_keys;
+
+    QVector<double> adj_timestamps;
+    for (int i = 0; i < ts_keys.size(); i++) {
+        adj_timestamps.append(ts_keys[i] + start_abs_offset_ - start_rel_time_);
+    }
+    return adj_timestamps;
+}
+
+// Scale the height of the waveform to global scale (max_sample_val_used_)
+// and adjust its Y offset so that they overlap slightly (stack_offset_).
+static const double stack_offset_ = G_MAXINT16 / 3;
+const QVector<double> RtpAudioStream::visualSamples(int y_offset)
+{
+    QVector<double> adj_samples;
+    double scaled_offset = y_offset * stack_offset_;
+    for (int i = 0; i < visual_samples_.size(); i++) {
+        if (SAMPLE_NaN != visual_samples_[i]) {
+            adj_samples.append(((double)visual_samples_[i] * G_MAXINT16 / max_sample_val_used_) + scaled_offset);
+        } else {
+            // Convert to break in graph line
+            adj_samples.append(qQNaN());
+        }
+    }
+    return adj_samples;
+}
+
+const QVector<double> RtpAudioStream::outOfSequenceTimestamps(bool relative)
+{
+    if (relative) return out_of_seq_timestamps_;
+
+    QVector<double> adj_timestamps;
+    for (int i = 0; i < out_of_seq_timestamps_.size(); i++) {
+        adj_timestamps.append(out_of_seq_timestamps_[i] + start_abs_offset_ - start_rel_time_);
+    }
+    return adj_timestamps;
+}
+
+const QVector<double> RtpAudioStream::outOfSequenceSamples(int y_offset)
+{
+    QVector<double> adj_samples;
+    double scaled_offset = y_offset * stack_offset_;  // XXX Should be different for seq, jitter, wrong & silence
+    for (int i = 0; i < out_of_seq_timestamps_.size(); i++) {
+        adj_samples.append(scaled_offset);
+    }
+    return adj_samples;
+}
+
+const QVector<double> RtpAudioStream::jitterDroppedTimestamps(bool relative)
+{
+    if (relative) return jitter_drop_timestamps_;
+
+    QVector<double> adj_timestamps;
+    for (int i = 0; i < jitter_drop_timestamps_.size(); i++) {
+        adj_timestamps.append(jitter_drop_timestamps_[i] + start_abs_offset_ - start_rel_time_);
+    }
+    return adj_timestamps;
+}
+
+const QVector<double> RtpAudioStream::jitterDroppedSamples(int y_offset)
+{
+    QVector<double> adj_samples;
+    double scaled_offset = y_offset * stack_offset_; // XXX Should be different for seq, jitter, wrong & silence
+    for (int i = 0; i < jitter_drop_timestamps_.size(); i++) {
+        adj_samples.append(scaled_offset);
+    }
+    return adj_samples;
+}
+
+const QVector<double> RtpAudioStream::wrongTimestampTimestamps(bool relative)
+{
+    if (relative) return wrong_timestamp_timestamps_;
+
+    QVector<double> adj_timestamps;
+    for (int i = 0; i < wrong_timestamp_timestamps_.size(); i++) {
+        adj_timestamps.append(wrong_timestamp_timestamps_[i] + start_abs_offset_ - start_rel_time_);
+    }
+    return adj_timestamps;
+}
+
+const QVector<double> RtpAudioStream::wrongTimestampSamples(int y_offset)
+{
+    QVector<double> adj_samples;
+    double scaled_offset = y_offset * stack_offset_; // XXX Should be different for seq, jitter, wrong & silence
+    for (int i = 0; i < wrong_timestamp_timestamps_.size(); i++) {
+        adj_samples.append(scaled_offset);
+    }
+    return adj_samples;
+}
+
+const QVector<double> RtpAudioStream::insertedSilenceTimestamps(bool relative)
+{
+    if (relative) return silence_timestamps_;
+
+    QVector<double> adj_timestamps;
+    for (int i = 0; i < silence_timestamps_.size(); i++) {
+        adj_timestamps.append(silence_timestamps_[i] + start_abs_offset_ - start_rel_time_);
+    }
+    return adj_timestamps;
+}
+
+const QVector<double> RtpAudioStream::insertedSilenceSamples(int y_offset)
+{
+    QVector<double> adj_samples;
+    double scaled_offset = y_offset * stack_offset_;  // XXX Should be different for seq, jitter, wrong & silence
+    for (int i = 0; i < silence_timestamps_.size(); i++) {
+        adj_samples.append(scaled_offset);
+    }
+    return adj_samples;
+}
+
+quint32 RtpAudioStream::nearestPacket(double timestamp, bool is_relative)
+{
+    if (packet_timestamps_.size() < 1) return 0;
+
+    if (!is_relative) timestamp -= start_abs_offset_;
+    QMap<double, quint32>::iterator it = packet_timestamps_.lowerBound(timestamp);
+    if (it == packet_timestamps_.end()) return 0;
+    return it.value();
+}
+
+QAudio::State RtpAudioStream::outputState() const
+{
+    if (!audio_output_) return QAudio::IdleState;
+    return audio_output_->state();
+}
+
+const QString RtpAudioStream::formatDescription(const QAudioFormat &format)
+{
+    QString fmt_descr = QString("%1 Hz, ").arg(format.sampleRate());
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+    switch (format.sampleFormat()) {
+    case QAudioFormat::UInt8:
+        fmt_descr += "UInt8";
+        break;
+    case QAudioFormat::Int16:
+        fmt_descr += "Int16";
+        break;
+    case QAudioFormat::Int32:
+        fmt_descr += "Int32";
+        break;
+    case QAudioFormat::Float:
+        fmt_descr += "Float";
+        break;
+    default:
+        fmt_descr += "Unknown";
+        break;
+    }
+#else
+    switch (format.sampleType()) {
+    case QAudioFormat::SignedInt:
+        fmt_descr += "Int";
+        fmt_descr += QString::number(format.sampleSize());
+        fmt_descr += format.byteOrder() == QAudioFormat::BigEndian ? "BE" : "LE";
+        break;
+    case QAudioFormat::UnSignedInt:
+        fmt_descr += "UInt";
+        fmt_descr += QString::number(format.sampleSize());
+        fmt_descr += format.byteOrder() == QAudioFormat::BigEndian ? "BE" : "LE";
+        break;
+    case QAudioFormat::Float:
+        fmt_descr += "Float";
+        break;
+    default:
+        fmt_descr += "Unknown";
+        break;
+    }
+#endif
+
+    return fmt_descr;
+}
+
+QString RtpAudioStream::getIDAsQString()
+{
+    gchar *src_addr_str = address_to_display(NULL, &id_.src_addr);
+    gchar *dst_addr_str = address_to_display(NULL, &id_.dst_addr);
+    QString str = QString("%1:%2 - %3:%4 %5")
+        .arg(src_addr_str)
+        .arg(id_.src_port)
+        .arg(dst_addr_str)
+        .arg(id_.dst_port)
+        .arg(QString("0x%1").arg(id_.ssrc, 0, 16));
+    wmem_free(NULL, src_addr_str);
+    wmem_free(NULL, dst_addr_str);
+
+    return str;
+}
+
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+bool RtpAudioStream::prepareForPlay(QAudioDevice out_device)
+#else
+bool RtpAudioStream::prepareForPlay(QAudioDeviceInfo out_device)
+#endif
+{
+    qint64 start_pos;
+    qint64 size;
+
+    if (audio_routing_.isMuted())
+        return false;
+
+    if (audio_output_)
+        return false;
+
+    if (audio_out_rate_ == 0) {
+        /* It is observed, but is not an error
+        QString error = tr("RTP stream (%1) is empty or codec is unsupported.")
+            .arg(getIDAsQString());
+
+        emit playbackError(error);
+        */
+        return false;
+    }
+
+    QAudioFormat format;
+    format.setSampleRate(audio_out_rate_);
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+    // Must match rtp_media.h.
+    format.setSampleFormat(QAudioFormat::Int16);
+#else
+    format.setSampleSize(SAMPLE_BYTES * 8); // bits
+    format.setSampleType(QAudioFormat::SignedInt);
+#endif
+    if (stereo_required_) {
+        format.setChannelCount(2);
+    } else {
+        format.setChannelCount(1);
+    }
+#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
+    format.setCodec("audio/pcm");
+#endif
+
+    // RTP_STREAM_DEBUG("playing %s %d samples @ %u Hz",
+    //                 sample_file_->fileName().toUtf8().constData(),
+    //                 (int) sample_file_->size(), audio_out_rate_);
+
+    if (!out_device.isFormatSupported(format)) {
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+        QString playback_error = tr("%1 does not support PCM at %2. Preferred format is %3")
+                .arg(out_device.description(), formatDescription(format), formatDescription(out_device.preferredFormat()));
+#else
+        QString playback_error = tr("%1 does not support PCM at %2. Preferred format is %3")
+                .arg(out_device.deviceName())
+                .arg(formatDescription(format))
+                .arg(formatDescription(out_device.nearestFormat(format)));
+#endif
+        emit playbackError(playback_error);
+    }
+
+    start_pos = (qint64)(start_play_time_ * SAMPLE_BYTES * audio_out_rate_);
+    // Round to SAMPLE_BYTES boundary
+    start_pos = (start_pos / SAMPLE_BYTES) * SAMPLE_BYTES;
+    size = audio_file_->sampleFileSize();
+    if (stereo_required_) {
+        // There is 2x more samples for stereo
+        start_pos *= 2;
+        size *= 2;
+    }
+    if (start_pos < size) {
+        audio_file_->setDataReadStage();
+        temp_file_ = new AudioRoutingFilter(audio_file_, stereo_required_, audio_routing_);
+        temp_file_->seek(start_pos);
+        if (audio_output_) delete audio_output_;
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+        audio_output_ = new QAudioSink(out_device, format, this);
+        connect(audio_output_, &QAudioSink::stateChanged, this, &RtpAudioStream::outputStateChanged);
+#else
+        audio_output_ = new QAudioOutput(out_device, format, this);
+        connect(audio_output_, &QAudioOutput::stateChanged, this, &RtpAudioStream::outputStateChanged);
+#endif
+        return true;
+    } else {
+        // Report stopped audio if start position is later than stream ends
+        outputStateChanged(QAudio::StoppedState);
+        return false;
+    }
+
+    return false;
+}
+
+void RtpAudioStream::startPlaying()
+{
+   // On Win32/Qt 6.x start() returns, but state() is QAudio::StoppedState even
+   // everything is OK
+   audio_output_->start(temp_file_);
+#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
+   // Bug is related to Qt 4.x and probably for 5.x, but not for 6.x
+   // QTBUG-6548 StoppedState is not always emitted on error, force a cleanup
+   // in case playback fails immediately.
+   if (audio_output_ && audio_output_->state() == QAudio::StoppedState) {
+       outputStateChanged(QAudio::StoppedState);
+   }
+#endif
+}
+
+void RtpAudioStream::pausePlaying()
+{
+    if (audio_routing_.isMuted())
+        return;
+
+    if (audio_output_) {
+        if (QAudio::ActiveState == audio_output_->state()) {
+            audio_output_->suspend();
+        } else if (QAudio::SuspendedState == audio_output_->state()) {
+            audio_output_->resume();
+        }
+    }
+}
+
+void RtpAudioStream::stopPlaying()
+{
+    if (audio_routing_.isMuted())
+        return;
+
+    if (audio_output_) {
+        if (audio_output_->state() == QAudio::StoppedState) {
+            // Looks like "delayed" QTBUG-6548
+            // It may happen that stream is stopped, but no signal emited
+            // Probably triggered by some issue in sound system which is not
+            // handled by Qt correctly
+            outputStateChanged(QAudio::StoppedState);
+        } else {
+            audio_output_->stop();
+        }
+    }
+}
+
+void RtpAudioStream::seekPlaying(qint64 samples _U_)
+{
+    if (audio_routing_.isMuted())
+        return;
+
+    if (audio_output_) {
+        audio_output_->suspend();
+        audio_file_->seekSample(samples);
+        audio_output_->resume();
+    }
+}
+
+void RtpAudioStream::outputStateChanged(QAudio::State new_state)
+{
+    if (!audio_output_) return;
+
+    // On some platforms including macOS and Windows, the stateChanged signal
+    // is emitted while a QMutexLocker is active. As a result we shouldn't
+    // delete audio_output_ here.
+    switch (new_state) {
+    case QAudio::StoppedState:
+        {
+            // RTP_STREAM_DEBUG("stopped %f", audio_output_->processedUSecs() / 100000.0);
+            // Detach from parent (RtpAudioStream) to prevent deleteLater
+            // from being run during destruction of this class.
+            QAudio::Error error = audio_output_->error();
+
+            audio_output_->setParent(0);
+            audio_output_->disconnect();
+            audio_output_->deleteLater();
+            audio_output_ = NULL;
+            emit finishedPlaying(this, error);
+            break;
+        }
+    case QAudio::IdleState:
+        // Workaround for Qt behaving on some platforms with some soundcards:
+        // When ->stop() is called from outputStateChanged(),
+        // internalQMutexLock is locked and application hangs.
+        // We can stop the stream later.
+        QTimer::singleShot(0, this, SLOT(delayedStopStream()));
+
+        break;
+    default:
+        break;
+    }
+}
+
+void RtpAudioStream::delayedStopStream()
+{
+    audio_output_->stop();
+}
+
+SAMPLE *RtpAudioStream::resizeBufferIfNeeded(SAMPLE *buff, gint32 *buff_bytes, qint64 requested_size)
+{
+    if (requested_size > *buff_bytes) {
+        while ((requested_size > *buff_bytes))
+            *buff_bytes *= 2;
+        buff = (SAMPLE *) g_realloc(buff, *buff_bytes);
+    }
+
+    return buff;
+}
+
+void RtpAudioStream::seekSample(qint64 samples)
+{
+    audio_file_->seekSample(samples);
+}
+
+qint64 RtpAudioStream::readSample(SAMPLE *sample)
+{
+    return audio_file_->readSample(sample);
+}
+
+bool RtpAudioStream::savePayload(QIODevice *file)
+{
+    for (int cur_packet = 0; cur_packet < rtp_packets_.size(); cur_packet++) {
+        // TODO: Update a progress bar here.
+        rtp_packet_t *rtp_packet = rtp_packets_[cur_packet];
+
+        if ((rtp_packet->info->info_payload_type != PT_CN) &&
+            (rtp_packet->info->info_payload_type != PT_CN_OLD)) {
+            // All other payloads
+            int64_t nchars;
+
+            if (rtp_packet->payload_data && (rtp_packet->info->info_payload_len > 0)) {
+                nchars = file->write((char *)rtp_packet->payload_data, rtp_packet->info->info_payload_len);
+                if (nchars != rtp_packet->info->info_payload_len) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+
+#endif // QT_MULTIMEDIA_LIB