Renames RtcEventLogParseNew to RtcEventLogParser
Bug: webrtc:10170 Change-Id: I9232c276229a64fa4d8321b6c996387fe130f68b Reviewed-on: https://webrtc-review.googlesource.com/c/116064 Commit-Queue: Sebastian Jansson <srte@webrtc.org> Reviewed-by: Björn Terelius <terelius@webrtc.org> Reviewed-by: Minyue Li <minyue@webrtc.org> Cr-Commit-Position: refs/heads/master@{#26128}
This commit is contained in:
Sebastian Jansson
committed by
Commit Bot
Commit Bot
parent
a29b3a6f34
commit
b290a6d767
686
logging/rtc_event_log/rtc_event_log_parser.h
Normal file
686
logging/rtc_event_log/rtc_event_log_parser.h
Normal file
@ -0,0 +1,686 @@
|
||||
/*
|
||||
* Copyright 2019 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
#ifndef LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_
|
||||
#define LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_
|
||||
|
||||
#include <iterator>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <sstream> // no-presubmit-check TODO(webrtc:8982)
|
||||
#include <string>
|
||||
#include <utility> // pair
|
||||
#include <vector>
|
||||
|
||||
#include "call/video_receive_stream.h"
|
||||
#include "call/video_send_stream.h"
|
||||
#include "logging/rtc_event_log/logged_events.h"
|
||||
#include "logging/rtc_event_log/rtc_event_log.h"
|
||||
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
|
||||
#include "rtc_base/ignore_wundef.h"
|
||||
|
||||
// Files generated at build-time by the protobuf compiler.
|
||||
RTC_PUSH_IGNORING_WUNDEF()
|
||||
#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
|
||||
#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
|
||||
#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log2.pb.h"
|
||||
#else
|
||||
#include "logging/rtc_event_log/rtc_event_log.pb.h"
|
||||
#include "logging/rtc_event_log/rtc_event_log2.pb.h"
|
||||
#endif
|
||||
RTC_POP_IGNORING_WUNDEF()
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
template <typename T>
|
||||
class PacketView;
|
||||
|
||||
template <typename T>
|
||||
class PacketIterator {
|
||||
friend class PacketView<T>;
|
||||
|
||||
public:
|
||||
// Standard iterator traits.
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using value_type = T;
|
||||
using pointer = T*;
|
||||
using reference = T&;
|
||||
using iterator_category = std::bidirectional_iterator_tag;
|
||||
|
||||
// The default-contructed iterator is meaningless, but is required by the
|
||||
// ForwardIterator concept.
|
||||
PacketIterator() : ptr_(nullptr), element_size_(0) {}
|
||||
PacketIterator(const PacketIterator& other)
|
||||
: ptr_(other.ptr_), element_size_(other.element_size_) {}
|
||||
PacketIterator(const PacketIterator&& other)
|
||||
: ptr_(other.ptr_), element_size_(other.element_size_) {}
|
||||
~PacketIterator() = default;
|
||||
|
||||
PacketIterator& operator=(const PacketIterator& other) {
|
||||
ptr_ = other.ptr_;
|
||||
element_size_ = other.element_size_;
|
||||
return *this;
|
||||
}
|
||||
PacketIterator& operator=(const PacketIterator&& other) {
|
||||
ptr_ = other.ptr_;
|
||||
element_size_ = other.element_size_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const PacketIterator<T>& other) const {
|
||||
RTC_DCHECK_EQ(element_size_, other.element_size_);
|
||||
return ptr_ == other.ptr_;
|
||||
}
|
||||
bool operator!=(const PacketIterator<T>& other) const {
|
||||
RTC_DCHECK_EQ(element_size_, other.element_size_);
|
||||
return ptr_ != other.ptr_;
|
||||
}
|
||||
|
||||
PacketIterator& operator++() {
|
||||
ptr_ += element_size_;
|
||||
return *this;
|
||||
}
|
||||
PacketIterator& operator--() {
|
||||
ptr_ -= element_size_;
|
||||
return *this;
|
||||
}
|
||||
PacketIterator operator++(int) {
|
||||
PacketIterator iter_copy(ptr_, element_size_);
|
||||
ptr_ += element_size_;
|
||||
return iter_copy;
|
||||
}
|
||||
PacketIterator operator--(int) {
|
||||
PacketIterator iter_copy(ptr_, element_size_);
|
||||
ptr_ -= element_size_;
|
||||
return iter_copy;
|
||||
}
|
||||
|
||||
T& operator*() { return *reinterpret_cast<T*>(ptr_); }
|
||||
const T& operator*() const { return *reinterpret_cast<const T*>(ptr_); }
|
||||
|
||||
private:
|
||||
PacketIterator(typename std::conditional<std::is_const<T>::value,
|
||||
const void*,
|
||||
void*>::type p,
|
||||
size_t s)
|
||||
: ptr_(reinterpret_cast<decltype(ptr_)>(p)), element_size_(s) {}
|
||||
|
||||
typename std::conditional<std::is_const<T>::value, const char*, char*>::type
|
||||
ptr_;
|
||||
size_t element_size_;
|
||||
};
|
||||
|
||||
// Suppose that we have a struct S where we are only interested in a specific
|
||||
// member M. Given an array of S, PacketView can be used to treat the array
|
||||
// as an array of M, without exposing the type S to surrounding code and without
|
||||
// accessing the member through a virtual function. In this case, we want to
|
||||
// have a common view for incoming and outgoing RtpPackets, hence the PacketView
|
||||
// name.
|
||||
// Note that constructing a PacketView bypasses the typesystem, so the caller
|
||||
// has to take extra care when constructing these objects. The implementation
|
||||
// also requires that the containing struct is standard-layout (e.g. POD).
|
||||
//
|
||||
// Usage example:
|
||||
// struct A {...};
|
||||
// struct B { A a; ...};
|
||||
// struct C { A a; ...};
|
||||
// size_t len = 10;
|
||||
// B* array1 = new B[len];
|
||||
// C* array2 = new C[len];
|
||||
//
|
||||
// PacketView<A> view1 = PacketView<A>::Create<B>(array1, len, offsetof(B, a));
|
||||
// PacketView<A> view2 = PacketView<A>::Create<C>(array2, len, offsetof(C, a));
|
||||
//
|
||||
// The following code works with either view1 or view2.
|
||||
// void f(PacketView<A> view)
|
||||
// for (A& a : view) {
|
||||
// DoSomething(a);
|
||||
// }
|
||||
template <typename T>
|
||||
class PacketView {
|
||||
public:
|
||||
template <typename U>
|
||||
static PacketView Create(U* ptr, size_t num_elements, size_t offset) {
|
||||
static_assert(std::is_standard_layout<U>::value,
|
||||
"PacketView can only be created for standard layout types.");
|
||||
static_assert(std::is_standard_layout<T>::value,
|
||||
"PacketView can only be created for standard layout types.");
|
||||
return PacketView(ptr, num_elements, offset, sizeof(U));
|
||||
}
|
||||
|
||||
using iterator = PacketIterator<T>;
|
||||
using const_iterator = PacketIterator<const T>;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
|
||||
iterator begin() { return iterator(data_, element_size_); }
|
||||
iterator end() {
|
||||
auto end_ptr = data_ + num_elements_ * element_size_;
|
||||
return iterator(end_ptr, element_size_);
|
||||
}
|
||||
|
||||
const_iterator begin() const { return const_iterator(data_, element_size_); }
|
||||
const_iterator end() const {
|
||||
auto end_ptr = data_ + num_elements_ * element_size_;
|
||||
return const_iterator(end_ptr, element_size_);
|
||||
}
|
||||
|
||||
reverse_iterator rbegin() { return reverse_iterator(end()); }
|
||||
reverse_iterator rend() { return reverse_iterator(begin()); }
|
||||
|
||||
const_reverse_iterator rbegin() const {
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
const_reverse_iterator rend() const {
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
|
||||
size_t size() const { return num_elements_; }
|
||||
|
||||
T& operator[](size_t i) {
|
||||
auto elem_ptr = data_ + i * element_size_;
|
||||
return *reinterpret_cast<T*>(elem_ptr);
|
||||
}
|
||||
|
||||
const T& operator[](size_t i) const {
|
||||
auto elem_ptr = data_ + i * element_size_;
|
||||
return *reinterpret_cast<const T*>(elem_ptr);
|
||||
}
|
||||
|
||||
private:
|
||||
PacketView(typename std::conditional<std::is_const<T>::value,
|
||||
const void*,
|
||||
void*>::type data,
|
||||
size_t num_elements,
|
||||
size_t offset,
|
||||
size_t element_size)
|
||||
: data_(reinterpret_cast<decltype(data_)>(data) + offset),
|
||||
num_elements_(num_elements),
|
||||
element_size_(element_size) {}
|
||||
|
||||
typename std::conditional<std::is_const<T>::value, const char*, char*>::type
|
||||
data_;
|
||||
size_t num_elements_;
|
||||
size_t element_size_;
|
||||
};
|
||||
|
||||
class ParsedRtcEventLog {
|
||||
friend class RtcEventLogTestHelper;
|
||||
|
||||
public:
|
||||
enum class MediaType { ANY, AUDIO, VIDEO, DATA };
|
||||
enum class UnconfiguredHeaderExtensions {
|
||||
kDontParse,
|
||||
kAttemptWebrtcDefaultConfig
|
||||
};
|
||||
|
||||
struct LoggedRtpStreamIncoming {
|
||||
LoggedRtpStreamIncoming();
|
||||
LoggedRtpStreamIncoming(const LoggedRtpStreamIncoming&);
|
||||
~LoggedRtpStreamIncoming();
|
||||
uint32_t ssrc;
|
||||
std::vector<LoggedRtpPacketIncoming> incoming_packets;
|
||||
};
|
||||
|
||||
struct LoggedRtpStreamOutgoing {
|
||||
LoggedRtpStreamOutgoing();
|
||||
LoggedRtpStreamOutgoing(const LoggedRtpStreamOutgoing&);
|
||||
~LoggedRtpStreamOutgoing();
|
||||
uint32_t ssrc;
|
||||
std::vector<LoggedRtpPacketOutgoing> outgoing_packets;
|
||||
};
|
||||
|
||||
struct LoggedRtpStreamView {
|
||||
LoggedRtpStreamView(uint32_t ssrc,
|
||||
const LoggedRtpPacketIncoming* ptr,
|
||||
size_t num_elements);
|
||||
LoggedRtpStreamView(uint32_t ssrc,
|
||||
const LoggedRtpPacketOutgoing* ptr,
|
||||
size_t num_elements);
|
||||
LoggedRtpStreamView(const LoggedRtpStreamView&);
|
||||
uint32_t ssrc;
|
||||
PacketView<const LoggedRtpPacket> packet_view;
|
||||
};
|
||||
|
||||
static webrtc::RtpHeaderExtensionMap GetDefaultHeaderExtensionMap();
|
||||
|
||||
explicit ParsedRtcEventLog(
|
||||
UnconfiguredHeaderExtensions parse_unconfigured_header_extensions =
|
||||
UnconfiguredHeaderExtensions::kDontParse);
|
||||
|
||||
~ParsedRtcEventLog();
|
||||
|
||||
// Clears previously parsed events and resets the ParsedRtcEventLogNew to an
|
||||
// empty state.
|
||||
void Clear();
|
||||
|
||||
// Reads an RtcEventLog file and returns true if parsing was successful.
|
||||
bool ParseFile(const std::string& file_name);
|
||||
|
||||
// Reads an RtcEventLog from a string and returns true if successful.
|
||||
bool ParseString(const std::string& s);
|
||||
|
||||
// Reads an RtcEventLog from an istream and returns true if successful.
|
||||
bool ParseStream(
|
||||
std::istream& stream); // no-presubmit-check TODO(webrtc:8982)
|
||||
|
||||
MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) const;
|
||||
|
||||
// Configured SSRCs.
|
||||
const std::set<uint32_t>& incoming_rtx_ssrcs() const {
|
||||
return incoming_rtx_ssrcs_;
|
||||
}
|
||||
|
||||
const std::set<uint32_t>& incoming_video_ssrcs() const {
|
||||
return incoming_video_ssrcs_;
|
||||
}
|
||||
|
||||
const std::set<uint32_t>& incoming_audio_ssrcs() const {
|
||||
return incoming_audio_ssrcs_;
|
||||
}
|
||||
|
||||
const std::set<uint32_t>& outgoing_rtx_ssrcs() const {
|
||||
return outgoing_rtx_ssrcs_;
|
||||
}
|
||||
|
||||
const std::set<uint32_t>& outgoing_video_ssrcs() const {
|
||||
return outgoing_video_ssrcs_;
|
||||
}
|
||||
|
||||
const std::set<uint32_t>& outgoing_audio_ssrcs() const {
|
||||
return outgoing_audio_ssrcs_;
|
||||
}
|
||||
|
||||
// Stream configurations.
|
||||
const std::vector<LoggedAudioRecvConfig>& audio_recv_configs() const {
|
||||
return audio_recv_configs_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedAudioSendConfig>& audio_send_configs() const {
|
||||
return audio_send_configs_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedVideoRecvConfig>& video_recv_configs() const {
|
||||
return video_recv_configs_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedVideoSendConfig>& video_send_configs() const {
|
||||
return video_send_configs_;
|
||||
}
|
||||
|
||||
// Beginning and end of log segments.
|
||||
const std::vector<LoggedStartEvent>& start_log_events() const {
|
||||
return start_log_events_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedStopEvent>& stop_log_events() const {
|
||||
return stop_log_events_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedAlrStateEvent>& alr_state_events() const {
|
||||
return alr_state_events_;
|
||||
}
|
||||
|
||||
// Audio
|
||||
const std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>&
|
||||
audio_playout_events() const {
|
||||
return audio_playout_events_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedAudioNetworkAdaptationEvent>&
|
||||
audio_network_adaptation_events() const {
|
||||
return audio_network_adaptation_events_;
|
||||
}
|
||||
|
||||
// Bandwidth estimation
|
||||
const std::vector<LoggedBweProbeClusterCreatedEvent>&
|
||||
bwe_probe_cluster_created_events() const {
|
||||
return bwe_probe_cluster_created_events_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedBweProbeFailureEvent>& bwe_probe_failure_events()
|
||||
const {
|
||||
return bwe_probe_failure_events_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedBweProbeSuccessEvent>& bwe_probe_success_events()
|
||||
const {
|
||||
return bwe_probe_success_events_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedBweDelayBasedUpdate>& bwe_delay_updates() const {
|
||||
return bwe_delay_updates_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedBweLossBasedUpdate>& bwe_loss_updates() const {
|
||||
return bwe_loss_updates_;
|
||||
}
|
||||
|
||||
// DTLS
|
||||
const std::vector<LoggedDtlsTransportState>& dtls_transport_states() const {
|
||||
return dtls_transport_states_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedDtlsWritableState>& dtls_writable_states() const {
|
||||
return dtls_writable_states_;
|
||||
}
|
||||
|
||||
// ICE events
|
||||
const std::vector<LoggedIceCandidatePairConfig>& ice_candidate_pair_configs()
|
||||
const {
|
||||
return ice_candidate_pair_configs_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedIceCandidatePairEvent>& ice_candidate_pair_events()
|
||||
const {
|
||||
return ice_candidate_pair_events_;
|
||||
}
|
||||
|
||||
// RTP
|
||||
const std::vector<LoggedRtpStreamIncoming>& incoming_rtp_packets_by_ssrc()
|
||||
const {
|
||||
return incoming_rtp_packets_by_ssrc_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedRtpStreamOutgoing>& outgoing_rtp_packets_by_ssrc()
|
||||
const {
|
||||
return outgoing_rtp_packets_by_ssrc_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedRtpStreamView>& rtp_packets_by_ssrc(
|
||||
PacketDirection direction) const {
|
||||
if (direction == kIncomingPacket)
|
||||
return incoming_rtp_packet_views_by_ssrc_;
|
||||
else
|
||||
return outgoing_rtp_packet_views_by_ssrc_;
|
||||
}
|
||||
|
||||
// RTCP
|
||||
const std::vector<LoggedRtcpPacketIncoming>& incoming_rtcp_packets() const {
|
||||
return incoming_rtcp_packets_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedRtcpPacketOutgoing>& outgoing_rtcp_packets() const {
|
||||
return outgoing_rtcp_packets_;
|
||||
}
|
||||
|
||||
const std::vector<LoggedRtcpPacketReceiverReport>& receiver_reports(
|
||||
PacketDirection direction) const {
|
||||
if (direction == kIncomingPacket) {
|
||||
return incoming_rr_;
|
||||
} else {
|
||||
return outgoing_rr_;
|
||||
}
|
||||
}
|
||||
|
||||
const std::vector<LoggedRtcpPacketSenderReport>& sender_reports(
|
||||
PacketDirection direction) const {
|
||||
if (direction == kIncomingPacket) {
|
||||
return incoming_sr_;
|
||||
} else {
|
||||
return outgoing_sr_;
|
||||
}
|
||||
}
|
||||
|
||||
const std::vector<LoggedRtcpPacketNack>& nacks(
|
||||
PacketDirection direction) const {
|
||||
if (direction == kIncomingPacket) {
|
||||
return incoming_nack_;
|
||||
} else {
|
||||
return outgoing_nack_;
|
||||
}
|
||||
}
|
||||
|
||||
const std::vector<LoggedRtcpPacketRemb>& rembs(
|
||||
PacketDirection direction) const {
|
||||
if (direction == kIncomingPacket) {
|
||||
return incoming_remb_;
|
||||
} else {
|
||||
return outgoing_remb_;
|
||||
}
|
||||
}
|
||||
|
||||
const std::vector<LoggedRtcpPacketTransportFeedback>& transport_feedbacks(
|
||||
PacketDirection direction) const {
|
||||
if (direction == kIncomingPacket) {
|
||||
return incoming_transport_feedback_;
|
||||
} else {
|
||||
return outgoing_transport_feedback_;
|
||||
}
|
||||
}
|
||||
|
||||
int64_t first_timestamp() const { return first_timestamp_; }
|
||||
int64_t last_timestamp() const { return last_timestamp_; }
|
||||
|
||||
private:
|
||||
bool ParseStreamInternal(
|
||||
std::istream& stream); // no-presubmit-check TODO(webrtc:8982)
|
||||
|
||||
void StoreParsedLegacyEvent(const rtclog::Event& event);
|
||||
|
||||
template <typename T>
|
||||
void StoreFirstAndLastTimestamp(const std::vector<T>& v);
|
||||
|
||||
// Reads the arrival timestamp (in microseconds) from a rtclog::Event.
|
||||
int64_t GetTimestamp(const rtclog::Event& event) const;
|
||||
|
||||
// Reads the header, direction, header length and packet length from the RTP
|
||||
// event at |index|, and stores the values in the corresponding output
|
||||
// parameters. Each output parameter can be set to nullptr if that value
|
||||
// isn't needed.
|
||||
// NB: The header must have space for at least IP_PACKET_SIZE bytes.
|
||||
// Returns: a pointer to a header extensions map acquired from parsing
|
||||
// corresponding Audio/Video Sender/Receiver config events.
|
||||
// Warning: if the same SSRC is reused by both video and audio streams during
|
||||
// call, extensions maps may be incorrect (the last one would be returned).
|
||||
const webrtc::RtpHeaderExtensionMap* GetRtpHeader(
|
||||
const rtclog::Event& event,
|
||||
PacketDirection* incoming,
|
||||
uint8_t* header,
|
||||
size_t* header_length,
|
||||
size_t* total_length,
|
||||
int* probe_cluster_id) const;
|
||||
|
||||
// Reads packet, direction and packet length from the RTCP event at |index|,
|
||||
// and stores the values in the corresponding output parameters.
|
||||
// Each output parameter can be set to nullptr if that value isn't needed.
|
||||
// NB: The packet must have space for at least IP_PACKET_SIZE bytes.
|
||||
void GetRtcpPacket(const rtclog::Event& event,
|
||||
PacketDirection* incoming,
|
||||
uint8_t* packet,
|
||||
size_t* length) const;
|
||||
|
||||
rtclog::StreamConfig GetVideoReceiveConfig(const rtclog::Event& event) const;
|
||||
rtclog::StreamConfig GetVideoSendConfig(const rtclog::Event& event) const;
|
||||
rtclog::StreamConfig GetAudioReceiveConfig(const rtclog::Event& event) const;
|
||||
rtclog::StreamConfig GetAudioSendConfig(const rtclog::Event& event) const;
|
||||
|
||||
LoggedAudioPlayoutEvent GetAudioPlayout(const rtclog::Event& event) const;
|
||||
|
||||
LoggedBweLossBasedUpdate GetLossBasedBweUpdate(
|
||||
const rtclog::Event& event) const;
|
||||
LoggedBweDelayBasedUpdate GetDelayBasedBweUpdate(
|
||||
const rtclog::Event& event) const;
|
||||
|
||||
LoggedAudioNetworkAdaptationEvent GetAudioNetworkAdaptation(
|
||||
const rtclog::Event& event) const;
|
||||
|
||||
LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated(
|
||||
const rtclog::Event& event) const;
|
||||
LoggedBweProbeFailureEvent GetBweProbeFailure(
|
||||
const rtclog::Event& event) const;
|
||||
LoggedBweProbeSuccessEvent GetBweProbeSuccess(
|
||||
const rtclog::Event& event) const;
|
||||
|
||||
LoggedAlrStateEvent GetAlrState(const rtclog::Event& event) const;
|
||||
|
||||
LoggedIceCandidatePairConfig GetIceCandidatePairConfig(
|
||||
const rtclog::Event& event) const;
|
||||
LoggedIceCandidatePairEvent GetIceCandidatePairEvent(
|
||||
const rtclog::Event& event) const;
|
||||
|
||||
// Parsing functions for new format.
|
||||
void StoreParsedNewFormatEvent(const rtclog2::EventStream& event);
|
||||
void StoreIncomingRtpPackets(const rtclog2::IncomingRtpPackets& proto);
|
||||
void StoreOutgoingRtpPackets(const rtclog2::OutgoingRtpPackets& proto);
|
||||
void StoreIncomingRtcpPackets(const rtclog2::IncomingRtcpPackets& proto);
|
||||
void StoreOutgoingRtcpPackets(const rtclog2::OutgoingRtcpPackets& proto);
|
||||
void StoreStartEvent(const rtclog2::BeginLogEvent& proto);
|
||||
void StoreStopEvent(const rtclog2::EndLogEvent& proto);
|
||||
void StoreAlrStateEvent(const rtclog2::AlrState& proto);
|
||||
void StoreAudioNetworkAdaptationEvent(
|
||||
const rtclog2::AudioNetworkAdaptations& proto);
|
||||
void StoreAudioPlayoutEvent(const rtclog2::AudioPlayoutEvents& proto);
|
||||
void StoreBweLossBasedUpdate(const rtclog2::LossBasedBweUpdates& proto);
|
||||
void StoreBweDelayBasedUpdate(const rtclog2::DelayBasedBweUpdates& proto);
|
||||
void StoreBweProbeClusterCreated(const rtclog2::BweProbeCluster& proto);
|
||||
void StoreBweProbeSuccessEvent(const rtclog2::BweProbeResultSuccess& proto);
|
||||
void StoreBweProbeFailureEvent(const rtclog2::BweProbeResultFailure& proto);
|
||||
void StoreDtlsTransportState(const rtclog2::DtlsTransportStateEvent& proto);
|
||||
void StoreDtlsWritableState(const rtclog2::DtlsWritableState& proto);
|
||||
void StoreIceCandidatePairConfig(
|
||||
const rtclog2::IceCandidatePairConfig& proto);
|
||||
void StoreIceCandidateEvent(const rtclog2::IceCandidatePairEvent& proto);
|
||||
void StoreAudioRecvConfig(const rtclog2::AudioRecvStreamConfig& proto);
|
||||
void StoreAudioSendConfig(const rtclog2::AudioSendStreamConfig& proto);
|
||||
void StoreVideoRecvConfig(const rtclog2::VideoRecvStreamConfig& proto);
|
||||
void StoreVideoSendConfig(const rtclog2::VideoSendStreamConfig& proto);
|
||||
// End of new parsing functions.
|
||||
|
||||
struct Stream {
|
||||
Stream(uint32_t ssrc,
|
||||
MediaType media_type,
|
||||
PacketDirection direction,
|
||||
webrtc::RtpHeaderExtensionMap map)
|
||||
: ssrc(ssrc),
|
||||
media_type(media_type),
|
||||
direction(direction),
|
||||
rtp_extensions_map(map) {}
|
||||
uint32_t ssrc;
|
||||
MediaType media_type;
|
||||
PacketDirection direction;
|
||||
webrtc::RtpHeaderExtensionMap rtp_extensions_map;
|
||||
};
|
||||
|
||||
const UnconfiguredHeaderExtensions parse_unconfigured_header_extensions_;
|
||||
|
||||
// Make a default extension map for streams without configuration information.
|
||||
// TODO(ivoc): Once configuration of audio streams is stored in the event log,
|
||||
// this can be removed. Tracking bug: webrtc:6399
|
||||
RtpHeaderExtensionMap default_extension_map_;
|
||||
|
||||
// Tracks what each stream is configured for. Note that a single SSRC can be
|
||||
// in several sets. For example, the SSRC used for sending video over RTX
|
||||
// will appear in both video_ssrcs_ and rtx_ssrcs_. In the unlikely case that
|
||||
// an SSRC is reconfigured to a different media type mid-call, it will also
|
||||
// appear in multiple sets.
|
||||
std::set<uint32_t> incoming_rtx_ssrcs_;
|
||||
std::set<uint32_t> incoming_video_ssrcs_;
|
||||
std::set<uint32_t> incoming_audio_ssrcs_;
|
||||
std::set<uint32_t> outgoing_rtx_ssrcs_;
|
||||
std::set<uint32_t> outgoing_video_ssrcs_;
|
||||
std::set<uint32_t> outgoing_audio_ssrcs_;
|
||||
|
||||
// Maps an SSRC to the parsed RTP headers in that stream. Header extensions
|
||||
// are parsed if the stream has been configured. This is only used for
|
||||
// grouping the events by SSRC during parsing; the events are moved to
|
||||
// incoming_rtp_packets_by_ssrc_ once the parsing is done.
|
||||
std::map<uint32_t, std::vector<LoggedRtpPacketIncoming>>
|
||||
incoming_rtp_packets_map_;
|
||||
std::map<uint32_t, std::vector<LoggedRtpPacketOutgoing>>
|
||||
outgoing_rtp_packets_map_;
|
||||
|
||||
// RTP headers.
|
||||
std::vector<LoggedRtpStreamIncoming> incoming_rtp_packets_by_ssrc_;
|
||||
std::vector<LoggedRtpStreamOutgoing> outgoing_rtp_packets_by_ssrc_;
|
||||
std::vector<LoggedRtpStreamView> incoming_rtp_packet_views_by_ssrc_;
|
||||
std::vector<LoggedRtpStreamView> outgoing_rtp_packet_views_by_ssrc_;
|
||||
|
||||
// Raw RTCP packets.
|
||||
std::vector<LoggedRtcpPacketIncoming> incoming_rtcp_packets_;
|
||||
std::vector<LoggedRtcpPacketOutgoing> outgoing_rtcp_packets_;
|
||||
|
||||
// Parsed RTCP messages. Currently not separated based on SSRC.
|
||||
std::vector<LoggedRtcpPacketReceiverReport> incoming_rr_;
|
||||
std::vector<LoggedRtcpPacketReceiverReport> outgoing_rr_;
|
||||
std::vector<LoggedRtcpPacketSenderReport> incoming_sr_;
|
||||
std::vector<LoggedRtcpPacketSenderReport> outgoing_sr_;
|
||||
std::vector<LoggedRtcpPacketNack> incoming_nack_;
|
||||
std::vector<LoggedRtcpPacketNack> outgoing_nack_;
|
||||
std::vector<LoggedRtcpPacketRemb> incoming_remb_;
|
||||
std::vector<LoggedRtcpPacketRemb> outgoing_remb_;
|
||||
std::vector<LoggedRtcpPacketTransportFeedback> incoming_transport_feedback_;
|
||||
std::vector<LoggedRtcpPacketTransportFeedback> outgoing_transport_feedback_;
|
||||
|
||||
std::vector<LoggedStartEvent> start_log_events_;
|
||||
std::vector<LoggedStopEvent> stop_log_events_;
|
||||
|
||||
std::vector<LoggedAlrStateEvent> alr_state_events_;
|
||||
|
||||
std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>
|
||||
audio_playout_events_;
|
||||
|
||||
std::vector<LoggedAudioNetworkAdaptationEvent>
|
||||
audio_network_adaptation_events_;
|
||||
|
||||
std::vector<LoggedBweProbeClusterCreatedEvent>
|
||||
bwe_probe_cluster_created_events_;
|
||||
|
||||
std::vector<LoggedBweProbeFailureEvent> bwe_probe_failure_events_;
|
||||
std::vector<LoggedBweProbeSuccessEvent> bwe_probe_success_events_;
|
||||
|
||||
std::vector<LoggedBweDelayBasedUpdate> bwe_delay_updates_;
|
||||
std::vector<LoggedBweLossBasedUpdate> bwe_loss_updates_;
|
||||
|
||||
std::vector<LoggedDtlsTransportState> dtls_transport_states_;
|
||||
std::vector<LoggedDtlsWritableState> dtls_writable_states_;
|
||||
|
||||
std::vector<LoggedIceCandidatePairConfig> ice_candidate_pair_configs_;
|
||||
std::vector<LoggedIceCandidatePairEvent> ice_candidate_pair_events_;
|
||||
|
||||
std::vector<LoggedAudioRecvConfig> audio_recv_configs_;
|
||||
std::vector<LoggedAudioSendConfig> audio_send_configs_;
|
||||
std::vector<LoggedVideoRecvConfig> video_recv_configs_;
|
||||
std::vector<LoggedVideoSendConfig> video_send_configs_;
|
||||
|
||||
uint8_t last_incoming_rtcp_packet_[IP_PACKET_SIZE];
|
||||
uint8_t last_incoming_rtcp_packet_length_;
|
||||
|
||||
int64_t first_timestamp_;
|
||||
int64_t last_timestamp_;
|
||||
|
||||
// The extension maps are mutable to allow us to insert the default
|
||||
// configuration when parsing an RTP header for an unconfigured stream.
|
||||
// TODO(terelius): This is only used for the legacy format. Remove once we've
|
||||
// fully transitioned to the new format.
|
||||
mutable std::map<uint32_t, webrtc::RtpHeaderExtensionMap>
|
||||
incoming_rtp_extensions_maps_;
|
||||
mutable std::map<uint32_t, webrtc::RtpHeaderExtensionMap>
|
||||
outgoing_rtp_extensions_maps_;
|
||||
};
|
||||
|
||||
struct MatchedSendArrivalTimes {
|
||||
MatchedSendArrivalTimes(int64_t fb, int64_t tx, int64_t rx, int64_t ps)
|
||||
: feedback_arrival_time_ms(fb),
|
||||
send_time_ms(tx),
|
||||
arrival_time_ms(rx),
|
||||
payload_size(ps) {}
|
||||
|
||||
int64_t feedback_arrival_time_ms;
|
||||
int64_t send_time_ms; // PacketFeedback::kNoSendTime for late feedback.
|
||||
int64_t arrival_time_ms; // PacketFeedback::kNotReceived for lost packets.
|
||||
int64_t payload_size;
|
||||
};
|
||||
const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
|
||||
const ParsedRtcEventLog& parsed_log);
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_
|
||||
Reference in New Issue
Block a user