Encode RTC event logs in new format.
This CL adds the encoder and wires it up to the event log. Parser and unit tests are uploaded in a separate CL. Bug: webrtc:8111 Change-Id: I6470003e55c2c4006cd8349a2c4bdc3f9491d869 Reviewed-on: https://webrtc-review.googlesource.com/c/106708 Commit-Queue: Björn Terelius <terelius@webrtc.org> Reviewed-by: Elad Alon <eladalon@webrtc.org> Cr-Commit-Position: refs/heads/master@{#25333}
This commit is contained in:
Bjorn Terelius
committed by
Commit Bot
Commit Bot
parent
fb5c1eca30
commit
ece3c228a2
@ -47,7 +47,6 @@
|
||||
#include "rtc_base/ignore_wundef.h"
|
||||
#include "rtc_base/logging.h"
|
||||
|
||||
#ifdef ENABLE_RTC_EVENT_LOG
|
||||
|
||||
// *.pb.h files are generated at build-time by the protobuf compiler.
|
||||
RTC_PUSH_IGNORING_WUNDEF()
|
||||
@ -756,5 +755,3 @@ std::string RtcEventLogEncoderLegacy::Serialize(rtclog::Event* event) {
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // ENABLE_RTC_EVENT_LOG
|
||||
|
||||
@ -18,8 +18,6 @@
|
||||
#include "logging/rtc_event_log/encoder/rtc_event_log_encoder.h"
|
||||
#include "rtc_base/buffer.h"
|
||||
|
||||
#if defined(ENABLE_RTC_EVENT_LOG)
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
namespace rtclog {
|
||||
@ -105,6 +103,4 @@ class RtcEventLogEncoderLegacy final : public RtcEventLogEncoder {
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // ENABLE_RTC_EVENT_LOG
|
||||
|
||||
#endif // LOGGING_RTC_EVENT_LOG_ENCODER_RTC_EVENT_LOG_ENCODER_LEGACY_H_
|
||||
|
||||
@ -0,0 +1,875 @@
|
||||
/*
|
||||
* Copyright (c) 2017 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.
|
||||
*/
|
||||
|
||||
#include "logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "api/array_view.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_alr_state.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_audio_playout.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_probe_cluster_created.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_probe_result_failure.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_probe_result_success.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h"
|
||||
#include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
|
||||
#include "logging/rtc_event_log/rtc_stream_config.h"
|
||||
#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
|
||||
#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
|
||||
#include "modules/rtp_rtcp/include/rtp_cvo.h"
|
||||
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/app.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/psfb.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
|
||||
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
|
||||
#include "modules/rtp_rtcp/source/rtp_packet.h"
|
||||
#include "rtc_base/checks.h"
|
||||
#include "rtc_base/ignore_wundef.h"
|
||||
#include "rtc_base/logging.h"
|
||||
|
||||
// *.pb.h files are 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_log2.pb.h"
|
||||
#else
|
||||
#include "logging/rtc_event_log/rtc_event_log2.pb.h"
|
||||
#endif
|
||||
RTC_POP_IGNORING_WUNDEF()
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
namespace {
|
||||
rtclog2::DelayBasedBweUpdates::DetectorState ConvertToProtoFormat(
|
||||
BandwidthUsage state) {
|
||||
switch (state) {
|
||||
case BandwidthUsage::kBwNormal:
|
||||
return rtclog2::DelayBasedBweUpdates::BWE_NORMAL;
|
||||
case BandwidthUsage::kBwUnderusing:
|
||||
return rtclog2::DelayBasedBweUpdates::BWE_UNDERUSING;
|
||||
case BandwidthUsage::kBwOverusing:
|
||||
return rtclog2::DelayBasedBweUpdates::BWE_OVERUSING;
|
||||
case BandwidthUsage::kLast:
|
||||
RTC_NOTREACHED();
|
||||
}
|
||||
RTC_NOTREACHED();
|
||||
return rtclog2::DelayBasedBweUpdates::BWE_UNKNOWN_STATE;
|
||||
}
|
||||
|
||||
rtclog2::BweProbeResultFailure::FailureReason ConvertToProtoFormat(
|
||||
ProbeFailureReason failure_reason) {
|
||||
switch (failure_reason) {
|
||||
case ProbeFailureReason::kInvalidSendReceiveInterval:
|
||||
return rtclog2::BweProbeResultFailure::INVALID_SEND_RECEIVE_INTERVAL;
|
||||
case ProbeFailureReason::kInvalidSendReceiveRatio:
|
||||
return rtclog2::BweProbeResultFailure::INVALID_SEND_RECEIVE_RATIO;
|
||||
case ProbeFailureReason::kTimeout:
|
||||
return rtclog2::BweProbeResultFailure::TIMEOUT;
|
||||
case ProbeFailureReason::kLast:
|
||||
RTC_NOTREACHED();
|
||||
}
|
||||
RTC_NOTREACHED();
|
||||
return rtclog2::BweProbeResultFailure::UNKNOWN;
|
||||
}
|
||||
|
||||
// Returns true if there are recognized extensions that we should log
|
||||
// and false if there are no extensions or all extensions are types we don't
|
||||
// log. The protobuf representation of the header configs is written to
|
||||
// |proto_config|.
|
||||
bool ConvertToProtoFormat(const std::vector<RtpExtension>& extensions,
|
||||
rtclog2::RtpHeaderExtensionConfig* proto_config) {
|
||||
size_t unknown_extensions = 0;
|
||||
for (auto& extension : extensions) {
|
||||
if (extension.uri == RtpExtension::kAudioLevelUri) {
|
||||
proto_config->set_audio_level_id(extension.id);
|
||||
} else if (extension.uri == RtpExtension::kTimestampOffsetUri) {
|
||||
proto_config->set_transmission_time_offset_id(extension.id);
|
||||
} else if (extension.uri == RtpExtension::kAbsSendTimeUri) {
|
||||
proto_config->set_absolute_send_time_id(extension.id);
|
||||
} else if (extension.uri == RtpExtension::kTransportSequenceNumberUri) {
|
||||
proto_config->set_transport_sequence_number_id(extension.id);
|
||||
} else if (extension.uri == RtpExtension::kVideoRotationUri) {
|
||||
proto_config->set_video_rotation_id(extension.id);
|
||||
} else {
|
||||
++unknown_extensions;
|
||||
}
|
||||
}
|
||||
return unknown_extensions < extensions.size();
|
||||
}
|
||||
|
||||
rtclog2::IceCandidatePairConfig::IceCandidatePairConfigType
|
||||
ConvertToProtoFormat(IceCandidatePairConfigType type) {
|
||||
switch (type) {
|
||||
case IceCandidatePairConfigType::kAdded:
|
||||
return rtclog2::IceCandidatePairConfig::ADDED;
|
||||
case IceCandidatePairConfigType::kUpdated:
|
||||
return rtclog2::IceCandidatePairConfig::UPDATED;
|
||||
case IceCandidatePairConfigType::kDestroyed:
|
||||
return rtclog2::IceCandidatePairConfig::DESTROYED;
|
||||
case IceCandidatePairConfigType::kSelected:
|
||||
return rtclog2::IceCandidatePairConfig::SELECTED;
|
||||
case IceCandidatePairConfigType::kNumValues:
|
||||
RTC_NOTREACHED();
|
||||
}
|
||||
RTC_NOTREACHED();
|
||||
return rtclog2::IceCandidatePairConfig::UNKNOWN_CONFIG_TYPE;
|
||||
}
|
||||
|
||||
rtclog2::IceCandidatePairConfig::IceCandidateType ConvertToProtoFormat(
|
||||
IceCandidateType type) {
|
||||
switch (type) {
|
||||
case IceCandidateType::kUnknown:
|
||||
return rtclog2::IceCandidatePairConfig::UNKNOWN_CANDIDATE_TYPE;
|
||||
case IceCandidateType::kLocal:
|
||||
return rtclog2::IceCandidatePairConfig::LOCAL;
|
||||
case IceCandidateType::kStun:
|
||||
return rtclog2::IceCandidatePairConfig::STUN;
|
||||
case IceCandidateType::kPrflx:
|
||||
return rtclog2::IceCandidatePairConfig::PRFLX;
|
||||
case IceCandidateType::kRelay:
|
||||
return rtclog2::IceCandidatePairConfig::RELAY;
|
||||
case IceCandidateType::kNumValues:
|
||||
RTC_NOTREACHED();
|
||||
}
|
||||
RTC_NOTREACHED();
|
||||
return rtclog2::IceCandidatePairConfig::UNKNOWN_CANDIDATE_TYPE;
|
||||
}
|
||||
|
||||
rtclog2::IceCandidatePairConfig::Protocol ConvertToProtoFormat(
|
||||
IceCandidatePairProtocol protocol) {
|
||||
switch (protocol) {
|
||||
case IceCandidatePairProtocol::kUnknown:
|
||||
return rtclog2::IceCandidatePairConfig::UNKNOWN_PROTOCOL;
|
||||
case IceCandidatePairProtocol::kUdp:
|
||||
return rtclog2::IceCandidatePairConfig::UDP;
|
||||
case IceCandidatePairProtocol::kTcp:
|
||||
return rtclog2::IceCandidatePairConfig::TCP;
|
||||
case IceCandidatePairProtocol::kSsltcp:
|
||||
return rtclog2::IceCandidatePairConfig::SSLTCP;
|
||||
case IceCandidatePairProtocol::kTls:
|
||||
return rtclog2::IceCandidatePairConfig::TLS;
|
||||
case IceCandidatePairProtocol::kNumValues:
|
||||
RTC_NOTREACHED();
|
||||
}
|
||||
RTC_NOTREACHED();
|
||||
return rtclog2::IceCandidatePairConfig::UNKNOWN_PROTOCOL;
|
||||
}
|
||||
|
||||
rtclog2::IceCandidatePairConfig::AddressFamily ConvertToProtoFormat(
|
||||
IceCandidatePairAddressFamily address_family) {
|
||||
switch (address_family) {
|
||||
case IceCandidatePairAddressFamily::kUnknown:
|
||||
return rtclog2::IceCandidatePairConfig::UNKNOWN_ADDRESS_FAMILY;
|
||||
case IceCandidatePairAddressFamily::kIpv4:
|
||||
return rtclog2::IceCandidatePairConfig::IPV4;
|
||||
case IceCandidatePairAddressFamily::kIpv6:
|
||||
return rtclog2::IceCandidatePairConfig::IPV6;
|
||||
case IceCandidatePairAddressFamily::kNumValues:
|
||||
RTC_NOTREACHED();
|
||||
}
|
||||
RTC_NOTREACHED();
|
||||
return rtclog2::IceCandidatePairConfig::UNKNOWN_ADDRESS_FAMILY;
|
||||
}
|
||||
|
||||
rtclog2::IceCandidatePairConfig::NetworkType ConvertToProtoFormat(
|
||||
IceCandidateNetworkType network_type) {
|
||||
switch (network_type) {
|
||||
case IceCandidateNetworkType::kUnknown:
|
||||
return rtclog2::IceCandidatePairConfig::UNKNOWN_NETWORK_TYPE;
|
||||
case IceCandidateNetworkType::kEthernet:
|
||||
return rtclog2::IceCandidatePairConfig::ETHERNET;
|
||||
case IceCandidateNetworkType::kLoopback:
|
||||
return rtclog2::IceCandidatePairConfig::LOOPBACK;
|
||||
case IceCandidateNetworkType::kWifi:
|
||||
return rtclog2::IceCandidatePairConfig::WIFI;
|
||||
case IceCandidateNetworkType::kVpn:
|
||||
return rtclog2::IceCandidatePairConfig::VPN;
|
||||
case IceCandidateNetworkType::kCellular:
|
||||
return rtclog2::IceCandidatePairConfig::CELLULAR;
|
||||
case IceCandidateNetworkType::kNumValues:
|
||||
RTC_NOTREACHED();
|
||||
}
|
||||
RTC_NOTREACHED();
|
||||
return rtclog2::IceCandidatePairConfig::UNKNOWN_NETWORK_TYPE;
|
||||
}
|
||||
|
||||
rtclog2::IceCandidatePairEvent::IceCandidatePairEventType ConvertToProtoFormat(
|
||||
IceCandidatePairEventType type) {
|
||||
switch (type) {
|
||||
case IceCandidatePairEventType::kCheckSent:
|
||||
return rtclog2::IceCandidatePairEvent::CHECK_SENT;
|
||||
case IceCandidatePairEventType::kCheckReceived:
|
||||
return rtclog2::IceCandidatePairEvent::CHECK_RECEIVED;
|
||||
case IceCandidatePairEventType::kCheckResponseSent:
|
||||
return rtclog2::IceCandidatePairEvent::CHECK_RESPONSE_SENT;
|
||||
case IceCandidatePairEventType::kCheckResponseReceived:
|
||||
return rtclog2::IceCandidatePairEvent::CHECK_RESPONSE_RECEIVED;
|
||||
case IceCandidatePairEventType::kNumValues:
|
||||
RTC_NOTREACHED();
|
||||
}
|
||||
RTC_NOTREACHED();
|
||||
return rtclog2::IceCandidatePairEvent::UNKNOWN_CHECK_TYPE;
|
||||
}
|
||||
|
||||
// Copies all RTCP blocks except APP, SDES and unknown from |packet| to
|
||||
// |buffer|. |buffer| must have space for |IP_PACKET_SIZE| bytes. |packet| must
|
||||
// be at most |IP_PACKET_SIZE| bytes long.
|
||||
size_t RemoveNonWhitelistedRtcpBlocks(const rtc::Buffer& packet,
|
||||
uint8_t* buffer) {
|
||||
RTC_DCHECK(packet.size() <= IP_PACKET_SIZE);
|
||||
RTC_DCHECK(buffer != nullptr);
|
||||
rtcp::CommonHeader header;
|
||||
const uint8_t* block_begin = packet.data();
|
||||
const uint8_t* packet_end = packet.data() + packet.size();
|
||||
size_t buffer_length = 0;
|
||||
while (block_begin < packet_end) {
|
||||
if (!header.Parse(block_begin, packet_end - block_begin)) {
|
||||
break; // Incorrect message header.
|
||||
}
|
||||
const uint8_t* next_block = header.NextPacket();
|
||||
RTC_DCHECK_GT(next_block, block_begin);
|
||||
RTC_DCHECK_LE(next_block, packet_end);
|
||||
size_t block_size = next_block - block_begin;
|
||||
switch (header.type()) {
|
||||
case rtcp::Bye::kPacketType:
|
||||
case rtcp::ExtendedJitterReport::kPacketType:
|
||||
case rtcp::ExtendedReports::kPacketType:
|
||||
case rtcp::Psfb::kPacketType:
|
||||
case rtcp::ReceiverReport::kPacketType:
|
||||
case rtcp::Rtpfb::kPacketType:
|
||||
case rtcp::SenderReport::kPacketType:
|
||||
// We log sender reports, receiver reports, bye messages
|
||||
// inter-arrival jitter, third-party loss reports, payload-specific
|
||||
// feedback and extended reports.
|
||||
// TODO(terelius): As an optimization, don't copy anything if all blocks
|
||||
// in the packet are whitelisted types.
|
||||
memcpy(buffer + buffer_length, block_begin, block_size);
|
||||
buffer_length += block_size;
|
||||
break;
|
||||
case rtcp::App::kPacketType:
|
||||
case rtcp::Sdes::kPacketType:
|
||||
default:
|
||||
// We don't log sender descriptions, application defined messages
|
||||
// or message blocks of unknown type.
|
||||
break;
|
||||
}
|
||||
|
||||
block_begin += block_size;
|
||||
}
|
||||
return buffer_length;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
std::string RtcEventLogEncoderNewFormat::EncodeLogStart(int64_t timestamp_us) {
|
||||
rtclog2::EventStream event_stream;
|
||||
rtclog2::BeginLogEvent* proto_batch = event_stream.add_begin_log_events();
|
||||
proto_batch->set_timestamp_ms(timestamp_us / 1000);
|
||||
return event_stream.SerializeAsString();
|
||||
}
|
||||
|
||||
std::string RtcEventLogEncoderNewFormat::EncodeLogEnd(int64_t timestamp_us) {
|
||||
rtclog2::EventStream event_stream;
|
||||
rtclog2::EndLogEvent* proto_batch = event_stream.add_end_log_events();
|
||||
proto_batch->set_timestamp_ms(timestamp_us / 1000);
|
||||
return event_stream.SerializeAsString();
|
||||
}
|
||||
|
||||
std::string RtcEventLogEncoderNewFormat::EncodeBatch(
|
||||
std::deque<std::unique_ptr<RtcEvent>>::const_iterator begin,
|
||||
std::deque<std::unique_ptr<RtcEvent>>::const_iterator end) {
|
||||
rtclog2::EventStream event_stream;
|
||||
std::string encoded_output;
|
||||
|
||||
{
|
||||
std::vector<const RtcEventAlrState*> alr_state_events;
|
||||
std::vector<const RtcEventAudioNetworkAdaptation*>
|
||||
audio_network_adaptation_events;
|
||||
std::vector<const RtcEventAudioPlayout*> audio_playout_events;
|
||||
std::vector<const RtcEventAudioReceiveStreamConfig*>
|
||||
audio_recv_stream_configs;
|
||||
std::vector<const RtcEventAudioSendStreamConfig*> audio_send_stream_configs;
|
||||
std::vector<const RtcEventBweUpdateDelayBased*> bwe_delay_based_updates;
|
||||
std::vector<const RtcEventBweUpdateLossBased*> bwe_loss_based_updates;
|
||||
std::vector<const RtcEventProbeClusterCreated*>
|
||||
probe_cluster_created_events;
|
||||
std::vector<const RtcEventProbeResultFailure*> probe_result_failure_events;
|
||||
std::vector<const RtcEventProbeResultSuccess*> probe_result_success_events;
|
||||
std::vector<const RtcEventRtcpPacketIncoming*> incoming_rtcp_packets;
|
||||
std::vector<const RtcEventRtcpPacketOutgoing*> outgoing_rtcp_packets;
|
||||
std::vector<const RtcEventRtpPacketIncoming*> incoming_rtp_packets;
|
||||
std::vector<const RtcEventRtpPacketOutgoing*> outgoing_rtp_packets;
|
||||
std::vector<const RtcEventVideoReceiveStreamConfig*>
|
||||
video_recv_stream_configs;
|
||||
std::vector<const RtcEventVideoSendStreamConfig*> video_send_stream_configs;
|
||||
std::vector<const RtcEventIceCandidatePairConfig*> ice_candidate_configs;
|
||||
std::vector<const RtcEventIceCandidatePair*> ice_candidate_events;
|
||||
|
||||
for (auto it = begin; it != end; ++it) {
|
||||
switch ((*it)->GetType()) {
|
||||
case RtcEvent::Type::AlrStateEvent: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventAlrState* const>(it->get());
|
||||
alr_state_events.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::AudioNetworkAdaptation: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventAudioNetworkAdaptation* const>(
|
||||
it->get());
|
||||
audio_network_adaptation_events.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::AudioPlayout: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventAudioPlayout* const>(it->get());
|
||||
audio_playout_events.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::AudioReceiveStreamConfig: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventAudioReceiveStreamConfig* const>(
|
||||
it->get());
|
||||
audio_recv_stream_configs.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::AudioSendStreamConfig: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventAudioSendStreamConfig* const>(
|
||||
it->get());
|
||||
audio_send_stream_configs.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::BweUpdateDelayBased: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventBweUpdateDelayBased* const>(it->get());
|
||||
bwe_delay_based_updates.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::BweUpdateLossBased: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventBweUpdateLossBased* const>(it->get());
|
||||
bwe_loss_based_updates.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::ProbeClusterCreated: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventProbeClusterCreated* const>(it->get());
|
||||
probe_cluster_created_events.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::ProbeResultFailure: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventProbeResultFailure* const>(it->get());
|
||||
probe_result_failure_events.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::ProbeResultSuccess: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventProbeResultSuccess* const>(it->get());
|
||||
probe_result_success_events.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::RtcpPacketIncoming: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventRtcpPacketIncoming* const>(it->get());
|
||||
incoming_rtcp_packets.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::RtcpPacketOutgoing: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventRtcpPacketOutgoing* const>(it->get());
|
||||
outgoing_rtcp_packets.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::RtpPacketIncoming: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventRtpPacketIncoming* const>(it->get());
|
||||
incoming_rtp_packets.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::RtpPacketOutgoing: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventRtpPacketOutgoing* const>(it->get());
|
||||
outgoing_rtp_packets.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::VideoReceiveStreamConfig: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventVideoReceiveStreamConfig* const>(
|
||||
it->get());
|
||||
video_recv_stream_configs.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::VideoSendStreamConfig: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventVideoSendStreamConfig* const>(
|
||||
it->get());
|
||||
video_send_stream_configs.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::IceCandidatePairConfig: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventIceCandidatePairConfig* const>(
|
||||
it->get());
|
||||
ice_candidate_configs.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
case RtcEvent::Type::IceCandidatePairEvent: {
|
||||
auto* rtc_event =
|
||||
static_cast<const RtcEventIceCandidatePair* const>(it->get());
|
||||
ice_candidate_events.push_back(rtc_event);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
EncodeAlrState(alr_state_events, &event_stream);
|
||||
EncodeAudioNetworkAdaptation(audio_network_adaptation_events,
|
||||
&event_stream);
|
||||
EncodeAudioPlayout(audio_playout_events, &event_stream);
|
||||
EncodeAudioRecvStreamConfig(audio_recv_stream_configs, &event_stream);
|
||||
EncodeAudioSendStreamConfig(audio_send_stream_configs, &event_stream);
|
||||
EncodeBweUpdateDelayBased(bwe_delay_based_updates, &event_stream);
|
||||
EncodeBweUpdateLossBased(bwe_loss_based_updates, &event_stream);
|
||||
EncodeProbeClusterCreated(probe_cluster_created_events, &event_stream);
|
||||
EncodeProbeResultFailure(probe_result_failure_events, &event_stream);
|
||||
EncodeProbeResultSuccess(probe_result_success_events, &event_stream);
|
||||
EncodeRtcpPacketIncoming(incoming_rtcp_packets, &event_stream);
|
||||
EncodeRtcpPacketOutgoing(outgoing_rtcp_packets, &event_stream);
|
||||
EncodeRtpPacketIncoming(incoming_rtp_packets, &event_stream);
|
||||
EncodeRtpPacketOutgoing(outgoing_rtp_packets, &event_stream);
|
||||
EncodeVideoRecvStreamConfig(video_recv_stream_configs, &event_stream);
|
||||
EncodeVideoSendStreamConfig(video_send_stream_configs, &event_stream);
|
||||
EncodeIceCandidatePairConfig(ice_candidate_configs, &event_stream);
|
||||
EncodeIceCandidatePairEvent(ice_candidate_events, &event_stream);
|
||||
} // Deallocate the temporary vectors.
|
||||
|
||||
return event_stream.SerializeAsString();
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeAlrState(
|
||||
rtc::ArrayView<const RtcEventAlrState*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventAlrState* base_event : batch) {
|
||||
rtclog2::AlrState* proto_batch = event_stream->add_alr_states();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_in_alr(base_event->in_alr_);
|
||||
}
|
||||
// TODO(terelius): Should we delta-compress this event type?
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
|
||||
rtc::ArrayView<const RtcEventAudioNetworkAdaptation*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
if (batch.size() == 0)
|
||||
return;
|
||||
for (const RtcEventAudioNetworkAdaptation* base_event : batch) {
|
||||
rtclog2::AudioNetworkAdaptations* proto_batch =
|
||||
event_stream->add_audio_network_adaptations();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
if (base_event->config_->bitrate_bps.has_value())
|
||||
proto_batch->set_bitrate_bps(base_event->config_->bitrate_bps.value());
|
||||
if (base_event->config_->frame_length_ms.has_value()) {
|
||||
proto_batch->set_frame_length_ms(
|
||||
base_event->config_->frame_length_ms.value());
|
||||
}
|
||||
if (base_event->config_->uplink_packet_loss_fraction.has_value()) {
|
||||
proto_batch->set_uplink_packet_loss_fraction(
|
||||
base_event->config_->uplink_packet_loss_fraction.value());
|
||||
}
|
||||
if (base_event->config_->enable_fec.has_value())
|
||||
proto_batch->set_enable_fec(base_event->config_->enable_fec.value());
|
||||
if (base_event->config_->enable_dtx.has_value())
|
||||
proto_batch->set_enable_dtx(base_event->config_->enable_dtx.value());
|
||||
if (base_event->config_->num_channels.has_value())
|
||||
proto_batch->set_num_channels(base_event->config_->num_channels.value());
|
||||
}
|
||||
// TODO(terelius): Delta-compress rest of batch.
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeAudioPlayout(
|
||||
rtc::ArrayView<const RtcEventAudioPlayout*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
if (batch.size() == 0)
|
||||
return;
|
||||
for (const RtcEventAudioPlayout* base_event : batch) {
|
||||
rtclog2::AudioPlayoutEvents* proto_batch =
|
||||
event_stream->add_audio_playout_events();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_local_ssrc(base_event->ssrc_);
|
||||
}
|
||||
// TODO(terelius): Delta-compress rest of batch.
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeAudioRecvStreamConfig(
|
||||
rtc::ArrayView<const RtcEventAudioReceiveStreamConfig*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventAudioReceiveStreamConfig* base_event : batch) {
|
||||
rtclog2::AudioRecvStreamConfig* proto_batch =
|
||||
event_stream->add_audio_recv_stream_configs();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_remote_ssrc(base_event->config_->remote_ssrc);
|
||||
proto_batch->set_local_ssrc(base_event->config_->local_ssrc);
|
||||
if (!base_event->config_->rsid.empty())
|
||||
proto_batch->set_rsid(base_event->config_->rsid);
|
||||
|
||||
rtclog2::RtpHeaderExtensionConfig* proto_config =
|
||||
proto_batch->mutable_header_extensions();
|
||||
bool has_recognized_extensions =
|
||||
ConvertToProtoFormat(base_event->config_->rtp_extensions, proto_config);
|
||||
if (!has_recognized_extensions)
|
||||
proto_batch->clear_header_extensions();
|
||||
}
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeAudioSendStreamConfig(
|
||||
rtc::ArrayView<const RtcEventAudioSendStreamConfig*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventAudioSendStreamConfig* base_event : batch) {
|
||||
rtclog2::AudioSendStreamConfig* proto_batch =
|
||||
event_stream->add_audio_send_stream_configs();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_ssrc(base_event->config_->local_ssrc);
|
||||
if (!base_event->config_->rsid.empty())
|
||||
proto_batch->set_rsid(base_event->config_->rsid);
|
||||
|
||||
rtclog2::RtpHeaderExtensionConfig* proto_config =
|
||||
proto_batch->mutable_header_extensions();
|
||||
bool has_recognized_extensions =
|
||||
ConvertToProtoFormat(base_event->config_->rtp_extensions, proto_config);
|
||||
if (!has_recognized_extensions)
|
||||
proto_batch->clear_header_extensions();
|
||||
}
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeBweUpdateDelayBased(
|
||||
rtc::ArrayView<const RtcEventBweUpdateDelayBased*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
if (batch.size() == 0)
|
||||
return;
|
||||
for (const RtcEventBweUpdateDelayBased* base_event : batch) {
|
||||
rtclog2::DelayBasedBweUpdates* proto_batch =
|
||||
event_stream->add_delay_based_bwe_updates();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_bitrate_bps(base_event->bitrate_bps_);
|
||||
proto_batch->set_detector_state(
|
||||
ConvertToProtoFormat(base_event->detector_state_));
|
||||
}
|
||||
// TODO(terelius): Delta-compress rest of batch.
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeBweUpdateLossBased(
|
||||
rtc::ArrayView<const RtcEventBweUpdateLossBased*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
if (batch.size() == 0)
|
||||
return;
|
||||
for (const RtcEventBweUpdateLossBased* base_event : batch) {
|
||||
rtclog2::LossBasedBweUpdates* proto_batch =
|
||||
event_stream->add_loss_based_bwe_updates();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_bitrate_bps(base_event->bitrate_bps_);
|
||||
proto_batch->set_fraction_loss(base_event->fraction_loss_);
|
||||
proto_batch->set_total_packets(base_event->total_packets_);
|
||||
}
|
||||
// TODO(terelius): Delta-compress rest of batch.
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeProbeClusterCreated(
|
||||
rtc::ArrayView<const RtcEventProbeClusterCreated*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventProbeClusterCreated* base_event : batch) {
|
||||
rtclog2::BweProbeCluster* proto_batch = event_stream->add_probe_clusters();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_id(base_event->id_);
|
||||
proto_batch->set_bitrate_bps(base_event->bitrate_bps_);
|
||||
proto_batch->set_min_packets(base_event->min_probes_);
|
||||
proto_batch->set_min_bytes(base_event->min_bytes_);
|
||||
}
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeProbeResultFailure(
|
||||
rtc::ArrayView<const RtcEventProbeResultFailure*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventProbeResultFailure* base_event : batch) {
|
||||
rtclog2::BweProbeResultFailure* proto_batch =
|
||||
event_stream->add_probe_failure();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_id(base_event->id_);
|
||||
proto_batch->set_failure(ConvertToProtoFormat(base_event->failure_reason_));
|
||||
}
|
||||
// TODO(terelius): Should we delta-compress this event type?
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeProbeResultSuccess(
|
||||
rtc::ArrayView<const RtcEventProbeResultSuccess*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventProbeResultSuccess* base_event : batch) {
|
||||
rtclog2::BweProbeResultSuccess* proto_batch =
|
||||
event_stream->add_probe_success();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_id(base_event->id_);
|
||||
proto_batch->set_bitrate_bps(base_event->bitrate_bps_);
|
||||
}
|
||||
// TODO(terelius): Should we delta-compress this event type?
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeRtcpPacketIncoming(
|
||||
rtc::ArrayView<const RtcEventRtcpPacketIncoming*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
if (batch.size() == 0)
|
||||
return;
|
||||
for (const RtcEventRtcpPacketIncoming* base_event : batch) {
|
||||
rtclog2::IncomingRtcpPackets* proto_batch =
|
||||
event_stream->add_incoming_rtcp_packets();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
|
||||
uint8_t buffer[IP_PACKET_SIZE];
|
||||
size_t buffer_length =
|
||||
RemoveNonWhitelistedRtcpBlocks(base_event->packet_, buffer);
|
||||
proto_batch->set_raw_packet(buffer, buffer_length);
|
||||
}
|
||||
// TODO(terelius): Delta-compress rest of batch.
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeRtcpPacketOutgoing(
|
||||
rtc::ArrayView<const RtcEventRtcpPacketOutgoing*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
if (batch.size() == 0)
|
||||
return;
|
||||
for (const RtcEventRtcpPacketOutgoing* base_event : batch) {
|
||||
rtclog2::OutgoingRtcpPackets* proto_batch =
|
||||
event_stream->add_outgoing_rtcp_packets();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
|
||||
uint8_t buffer[IP_PACKET_SIZE];
|
||||
size_t buffer_length =
|
||||
RemoveNonWhitelistedRtcpBlocks(base_event->packet_, buffer);
|
||||
proto_batch->set_raw_packet(buffer, buffer_length);
|
||||
}
|
||||
// TODO(terelius): Delta-compress rest of batch.
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeRtpPacketIncoming(
|
||||
rtc::ArrayView<const RtcEventRtpPacketIncoming*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
if (batch.size() == 0)
|
||||
return;
|
||||
for (const RtcEventRtpPacketIncoming* base_event : batch) {
|
||||
rtclog2::IncomingRtpPackets* proto_batch =
|
||||
event_stream->add_incoming_rtp_packets();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_marker(base_event->header_.Marker());
|
||||
// TODO(terelius): Is payload type needed?
|
||||
proto_batch->set_payload_type(base_event->header_.PayloadType());
|
||||
proto_batch->set_sequence_number(base_event->header_.SequenceNumber());
|
||||
proto_batch->set_rtp_timestamp(base_event->header_.Timestamp());
|
||||
proto_batch->set_ssrc(base_event->header_.Ssrc());
|
||||
proto_batch->set_payload_size(base_event->payload_length_);
|
||||
proto_batch->set_header_size(base_event->header_length_);
|
||||
proto_batch->set_padding_size(base_event->padding_length_);
|
||||
|
||||
// Add header extensions.
|
||||
if (base_event->header_.HasExtension<TransmissionOffset>()) {
|
||||
int32_t offset;
|
||||
base_event->header_.GetExtension<TransmissionOffset>(&offset);
|
||||
proto_batch->set_transmission_time_offset(offset);
|
||||
}
|
||||
if (base_event->header_.HasExtension<AbsoluteSendTime>()) {
|
||||
uint32_t sendtime;
|
||||
base_event->header_.GetExtension<AbsoluteSendTime>(&sendtime);
|
||||
proto_batch->set_absolute_send_time(sendtime);
|
||||
}
|
||||
if (base_event->header_.HasExtension<TransportSequenceNumber>()) {
|
||||
uint16_t seqnum;
|
||||
base_event->header_.GetExtension<TransportSequenceNumber>(&seqnum);
|
||||
proto_batch->set_transport_sequence_number(seqnum);
|
||||
}
|
||||
if (base_event->header_.HasExtension<AudioLevel>()) {
|
||||
bool voice_activity;
|
||||
uint8_t audio_level;
|
||||
base_event->header_.GetExtension<AudioLevel>(&voice_activity,
|
||||
&audio_level);
|
||||
RTC_DCHECK(audio_level < 128);
|
||||
if (voice_activity) {
|
||||
audio_level += 128; // Most significant bit indicates voice activity.
|
||||
}
|
||||
proto_batch->set_audio_level(audio_level);
|
||||
}
|
||||
if (base_event->header_.HasExtension<VideoOrientation>()) {
|
||||
VideoRotation video_rotation;
|
||||
base_event->header_.GetExtension<VideoOrientation>(&video_rotation);
|
||||
proto_batch->set_video_rotation(
|
||||
ConvertVideoRotationToCVOByte(video_rotation));
|
||||
}
|
||||
}
|
||||
// TODO(terelius): Delta-compress rest of batch.
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeRtpPacketOutgoing(
|
||||
rtc::ArrayView<const RtcEventRtpPacketOutgoing*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
if (batch.size() == 0)
|
||||
return;
|
||||
for (const RtcEventRtpPacketOutgoing* base_event : batch) {
|
||||
rtclog2::OutgoingRtpPackets* proto_batch =
|
||||
event_stream->add_outgoing_rtp_packets();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_marker(base_event->header_.Marker());
|
||||
// TODO(terelius): Is payload type needed?
|
||||
proto_batch->set_payload_type(base_event->header_.PayloadType());
|
||||
proto_batch->set_sequence_number(base_event->header_.SequenceNumber());
|
||||
proto_batch->set_rtp_timestamp(base_event->header_.Timestamp());
|
||||
proto_batch->set_ssrc(base_event->header_.Ssrc());
|
||||
proto_batch->set_payload_size(base_event->payload_length_);
|
||||
proto_batch->set_header_size(base_event->header_length_);
|
||||
proto_batch->set_padding_size(base_event->padding_length_);
|
||||
|
||||
// Add header extensions.
|
||||
if (base_event->header_.HasExtension<TransmissionOffset>()) {
|
||||
int32_t offset;
|
||||
base_event->header_.GetExtension<TransmissionOffset>(&offset);
|
||||
proto_batch->set_transmission_time_offset(offset);
|
||||
}
|
||||
if (base_event->header_.HasExtension<AbsoluteSendTime>()) {
|
||||
uint32_t sendtime;
|
||||
base_event->header_.GetExtension<AbsoluteSendTime>(&sendtime);
|
||||
proto_batch->set_absolute_send_time(sendtime);
|
||||
}
|
||||
if (base_event->header_.HasExtension<TransportSequenceNumber>()) {
|
||||
uint16_t seqnum;
|
||||
base_event->header_.GetExtension<TransportSequenceNumber>(&seqnum);
|
||||
proto_batch->set_transport_sequence_number(seqnum);
|
||||
}
|
||||
if (base_event->header_.HasExtension<AudioLevel>()) {
|
||||
bool voice_activity;
|
||||
uint8_t audio_level;
|
||||
base_event->header_.GetExtension<AudioLevel>(&voice_activity,
|
||||
&audio_level);
|
||||
RTC_DCHECK(audio_level < 128);
|
||||
if (voice_activity) {
|
||||
audio_level += 128; // Most significant bit indicates voice activity.
|
||||
}
|
||||
proto_batch->set_audio_level(audio_level);
|
||||
}
|
||||
if (base_event->header_.HasExtension<VideoOrientation>()) {
|
||||
VideoRotation video_rotation;
|
||||
base_event->header_.GetExtension<VideoOrientation>(&video_rotation);
|
||||
proto_batch->set_video_rotation(
|
||||
ConvertVideoRotationToCVOByte(video_rotation));
|
||||
}
|
||||
}
|
||||
// TODO(terelius): Delta-compress rest of batch.
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeVideoRecvStreamConfig(
|
||||
rtc::ArrayView<const RtcEventVideoReceiveStreamConfig*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventVideoReceiveStreamConfig* base_event : batch) {
|
||||
rtclog2::VideoRecvStreamConfig* proto_batch =
|
||||
event_stream->add_video_recv_stream_configs();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_remote_ssrc(base_event->config_->remote_ssrc);
|
||||
proto_batch->set_local_ssrc(base_event->config_->local_ssrc);
|
||||
proto_batch->set_rtx_ssrc(base_event->config_->rtx_ssrc);
|
||||
if (!base_event->config_->rsid.empty())
|
||||
proto_batch->set_rsid(base_event->config_->rsid);
|
||||
|
||||
rtclog2::RtpHeaderExtensionConfig* proto_config =
|
||||
proto_batch->mutable_header_extensions();
|
||||
bool has_recognized_extensions =
|
||||
ConvertToProtoFormat(base_event->config_->rtp_extensions, proto_config);
|
||||
if (!has_recognized_extensions)
|
||||
proto_batch->clear_header_extensions();
|
||||
}
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeVideoSendStreamConfig(
|
||||
rtc::ArrayView<const RtcEventVideoSendStreamConfig*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventVideoSendStreamConfig* base_event : batch) {
|
||||
rtclog2::VideoSendStreamConfig* proto_batch =
|
||||
event_stream->add_video_send_stream_configs();
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_ssrc(base_event->config_->local_ssrc);
|
||||
proto_batch->set_rtx_ssrc(base_event->config_->rtx_ssrc);
|
||||
if (!base_event->config_->rsid.empty())
|
||||
proto_batch->set_rsid(base_event->config_->rsid);
|
||||
|
||||
rtclog2::RtpHeaderExtensionConfig* proto_config =
|
||||
proto_batch->mutable_header_extensions();
|
||||
bool has_recognized_extensions =
|
||||
ConvertToProtoFormat(base_event->config_->rtp_extensions, proto_config);
|
||||
if (!has_recognized_extensions)
|
||||
proto_batch->clear_header_extensions();
|
||||
}
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeIceCandidatePairConfig(
|
||||
rtc::ArrayView<const RtcEventIceCandidatePairConfig*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventIceCandidatePairConfig* base_event : batch) {
|
||||
rtclog2::IceCandidatePairConfig* proto_batch =
|
||||
event_stream->add_ice_candidate_configs();
|
||||
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
proto_batch->set_config_type(ConvertToProtoFormat(base_event->type_));
|
||||
proto_batch->set_candidate_pair_id(base_event->candidate_pair_id_);
|
||||
const auto& desc = base_event->candidate_pair_desc_;
|
||||
proto_batch->set_local_candidate_type(
|
||||
ConvertToProtoFormat(desc.local_candidate_type));
|
||||
proto_batch->set_local_relay_protocol(
|
||||
ConvertToProtoFormat(desc.local_relay_protocol));
|
||||
proto_batch->set_local_network_type(
|
||||
ConvertToProtoFormat(desc.local_network_type));
|
||||
proto_batch->set_local_address_family(
|
||||
ConvertToProtoFormat(desc.local_address_family));
|
||||
proto_batch->set_remote_candidate_type(
|
||||
ConvertToProtoFormat(desc.remote_candidate_type));
|
||||
proto_batch->set_remote_address_family(
|
||||
ConvertToProtoFormat(desc.remote_address_family));
|
||||
proto_batch->set_candidate_pair_protocol(
|
||||
ConvertToProtoFormat(desc.candidate_pair_protocol));
|
||||
}
|
||||
// TODO(terelius): Should we delta-compress this event type?
|
||||
}
|
||||
|
||||
void RtcEventLogEncoderNewFormat::EncodeIceCandidatePairEvent(
|
||||
rtc::ArrayView<const RtcEventIceCandidatePair*> batch,
|
||||
rtclog2::EventStream* event_stream) {
|
||||
for (const RtcEventIceCandidatePair* base_event : batch) {
|
||||
rtclog2::IceCandidatePairEvent* proto_batch =
|
||||
event_stream->add_ice_candidate_events();
|
||||
|
||||
proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
|
||||
|
||||
proto_batch->set_event_type(ConvertToProtoFormat(base_event->type_));
|
||||
proto_batch->set_candidate_pair_id(base_event->candidate_pair_id_);
|
||||
}
|
||||
// TODO(terelius): Should we delta-compress this event type?
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
122
logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h
Normal file
122
logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h
Normal file
@ -0,0 +1,122 @@
|
||||
/*
|
||||
* Copyright (c) 2017 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_ENCODER_RTC_EVENT_LOG_ENCODER_NEW_FORMAT_H_
|
||||
#define LOGGING_RTC_EVENT_LOG_ENCODER_RTC_EVENT_LOG_ENCODER_NEW_FORMAT_H_
|
||||
|
||||
#include <deque>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "api/array_view.h"
|
||||
#include "logging/rtc_event_log/encoder/rtc_event_log_encoder.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
namespace rtclog2 {
|
||||
class EventStream; // Auto-generated from protobuf.
|
||||
} // namespace rtclog2
|
||||
|
||||
class RtcEventAlrState;
|
||||
class RtcEventAudioNetworkAdaptation;
|
||||
class RtcEventAudioPlayout;
|
||||
class RtcEventAudioReceiveStreamConfig;
|
||||
class RtcEventAudioSendStreamConfig;
|
||||
class RtcEventBweUpdateDelayBased;
|
||||
class RtcEventBweUpdateLossBased;
|
||||
class RtcEventLoggingStarted;
|
||||
class RtcEventLoggingStopped;
|
||||
class RtcEventProbeClusterCreated;
|
||||
class RtcEventProbeResultFailure;
|
||||
class RtcEventProbeResultSuccess;
|
||||
class RtcEventRtcpPacketIncoming;
|
||||
class RtcEventRtcpPacketOutgoing;
|
||||
class RtcEventRtpPacketIncoming;
|
||||
class RtcEventRtpPacketOutgoing;
|
||||
class RtcEventVideoReceiveStreamConfig;
|
||||
class RtcEventVideoSendStreamConfig;
|
||||
class RtcEventIceCandidatePairConfig;
|
||||
class RtcEventIceCandidatePair;
|
||||
class RtpPacket;
|
||||
|
||||
class RtcEventLogEncoderNewFormat final : public RtcEventLogEncoder {
|
||||
public:
|
||||
~RtcEventLogEncoderNewFormat() override = default;
|
||||
|
||||
std::string EncodeBatch(
|
||||
std::deque<std::unique_ptr<RtcEvent>>::const_iterator begin,
|
||||
std::deque<std::unique_ptr<RtcEvent>>::const_iterator end) override;
|
||||
|
||||
std::string EncodeLogStart(int64_t timestamp_us) override;
|
||||
std::string EncodeLogEnd(int64_t timestamp_us) override;
|
||||
|
||||
private:
|
||||
// Encoding entry-point for the various RtcEvent subclasses.
|
||||
void EncodeAlrState(rtc::ArrayView<const RtcEventAlrState*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeAudioNetworkAdaptation(
|
||||
rtc::ArrayView<const RtcEventAudioNetworkAdaptation*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeAudioPlayout(rtc::ArrayView<const RtcEventAudioPlayout*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeAudioRecvStreamConfig(
|
||||
rtc::ArrayView<const RtcEventAudioReceiveStreamConfig*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeAudioSendStreamConfig(
|
||||
rtc::ArrayView<const RtcEventAudioSendStreamConfig*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeBweUpdateDelayBased(
|
||||
rtc::ArrayView<const RtcEventBweUpdateDelayBased*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeBweUpdateLossBased(
|
||||
rtc::ArrayView<const RtcEventBweUpdateLossBased*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeLoggingStarted(rtc::ArrayView<const RtcEventLoggingStarted*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeLoggingStopped(rtc::ArrayView<const RtcEventLoggingStopped*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeProbeClusterCreated(
|
||||
rtc::ArrayView<const RtcEventProbeClusterCreated*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeProbeResultFailure(
|
||||
rtc::ArrayView<const RtcEventProbeResultFailure*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeProbeResultSuccess(
|
||||
rtc::ArrayView<const RtcEventProbeResultSuccess*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeRtcpPacketIncoming(
|
||||
rtc::ArrayView<const RtcEventRtcpPacketIncoming*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeRtcpPacketOutgoing(
|
||||
rtc::ArrayView<const RtcEventRtcpPacketOutgoing*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeRtpPacketIncoming(
|
||||
rtc::ArrayView<const RtcEventRtpPacketIncoming*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeRtpPacketOutgoing(
|
||||
rtc::ArrayView<const RtcEventRtpPacketOutgoing*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeVideoRecvStreamConfig(
|
||||
rtc::ArrayView<const RtcEventVideoReceiveStreamConfig*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeVideoSendStreamConfig(
|
||||
rtc::ArrayView<const RtcEventVideoSendStreamConfig*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeIceCandidatePairConfig(
|
||||
rtc::ArrayView<const RtcEventIceCandidatePairConfig*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
void EncodeIceCandidatePairEvent(
|
||||
rtc::ArrayView<const RtcEventIceCandidatePair*> batch,
|
||||
rtclog2::EventStream* event_stream);
|
||||
};
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // LOGGING_RTC_EVENT_LOG_ENCODER_RTC_EVENT_LOG_ENCODER_NEW_FORMAT_H_
|
||||
Reference in New Issue
Block a user