1 /*
2 * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h"
12
13 #include <string.h>
14
15 #include <vector>
16
17 #include "absl/types/optional.h"
18 #include "api/array_view.h"
19 #include "api/network_state_predictor.h"
20 #include "api/rtp_headers.h"
21 #include "api/rtp_parameters.h"
22 #include "api/transport/network_types.h"
23 #include "logging/rtc_event_log/events/rtc_event_alr_state.h"
24 #include "logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h"
25 #include "logging/rtc_event_log/events/rtc_event_audio_playout.h"
26 #include "logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h"
27 #include "logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h"
28 #include "logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h"
29 #include "logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h"
30 #include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h"
31 #include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h"
32 #include "logging/rtc_event_log/events/rtc_event_probe_cluster_created.h"
33 #include "logging/rtc_event_log/events/rtc_event_probe_result_failure.h"
34 #include "logging/rtc_event_log/events/rtc_event_probe_result_success.h"
35 #include "logging/rtc_event_log/events/rtc_event_remote_estimate.h"
36 #include "logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h"
37 #include "logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h"
38 #include "logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h"
39 #include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
40 #include "logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h"
41 #include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
42 #include "logging/rtc_event_log/rtc_stream_config.h"
43 #include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
44 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
45 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
46 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
47 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
48 #include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
49 #include "modules/rtp_rtcp/source/rtcp_packet/psfb.h"
50 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
51 #include "modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
52 #include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
53 #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
54 #include "modules/rtp_rtcp/source/rtp_packet.h"
55 #include "rtc_base/checks.h"
56 #include "rtc_base/ignore_wundef.h"
57 #include "rtc_base/logging.h"
58
59 // *.pb.h files are generated at build-time by the protobuf compiler.
60 RTC_PUSH_IGNORING_WUNDEF()
61 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
62 #include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
63 #else
64 #include "logging/rtc_event_log/rtc_event_log.pb.h"
65 #endif
66 RTC_POP_IGNORING_WUNDEF()
67
68 namespace webrtc {
69
70 namespace {
ConvertDetectorState(BandwidthUsage state)71 rtclog::DelayBasedBweUpdate::DetectorState ConvertDetectorState(
72 BandwidthUsage state) {
73 switch (state) {
74 case BandwidthUsage::kBwNormal:
75 return rtclog::DelayBasedBweUpdate::BWE_NORMAL;
76 case BandwidthUsage::kBwUnderusing:
77 return rtclog::DelayBasedBweUpdate::BWE_UNDERUSING;
78 case BandwidthUsage::kBwOverusing:
79 return rtclog::DelayBasedBweUpdate::BWE_OVERUSING;
80 case BandwidthUsage::kLast:
81 RTC_DCHECK_NOTREACHED();
82 }
83 RTC_DCHECK_NOTREACHED();
84 return rtclog::DelayBasedBweUpdate::BWE_NORMAL;
85 }
86
ConvertProbeResultType(ProbeFailureReason failure_reason)87 rtclog::BweProbeResult::ResultType ConvertProbeResultType(
88 ProbeFailureReason failure_reason) {
89 switch (failure_reason) {
90 case ProbeFailureReason::kInvalidSendReceiveInterval:
91 return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL;
92 case ProbeFailureReason::kInvalidSendReceiveRatio:
93 return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO;
94 case ProbeFailureReason::kTimeout:
95 return rtclog::BweProbeResult::TIMEOUT;
96 case ProbeFailureReason::kLast:
97 RTC_DCHECK_NOTREACHED();
98 }
99 RTC_DCHECK_NOTREACHED();
100 return rtclog::BweProbeResult::SUCCESS;
101 }
102
ConvertRtcpMode(RtcpMode rtcp_mode)103 rtclog::VideoReceiveConfig_RtcpMode ConvertRtcpMode(RtcpMode rtcp_mode) {
104 switch (rtcp_mode) {
105 case RtcpMode::kCompound:
106 return rtclog::VideoReceiveConfig::RTCP_COMPOUND;
107 case RtcpMode::kReducedSize:
108 return rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE;
109 case RtcpMode::kOff:
110 RTC_DCHECK_NOTREACHED();
111 }
112 RTC_DCHECK_NOTREACHED();
113 return rtclog::VideoReceiveConfig::RTCP_COMPOUND;
114 }
115
116 rtclog::IceCandidatePairConfig::IceCandidatePairConfigType
ConvertIceCandidatePairConfigType(IceCandidatePairConfigType type)117 ConvertIceCandidatePairConfigType(IceCandidatePairConfigType type) {
118 switch (type) {
119 case IceCandidatePairConfigType::kAdded:
120 return rtclog::IceCandidatePairConfig::ADDED;
121 case IceCandidatePairConfigType::kUpdated:
122 return rtclog::IceCandidatePairConfig::UPDATED;
123 case IceCandidatePairConfigType::kDestroyed:
124 return rtclog::IceCandidatePairConfig::DESTROYED;
125 case IceCandidatePairConfigType::kSelected:
126 return rtclog::IceCandidatePairConfig::SELECTED;
127 case IceCandidatePairConfigType::kNumValues:
128 RTC_DCHECK_NOTREACHED();
129 }
130 RTC_DCHECK_NOTREACHED();
131 return rtclog::IceCandidatePairConfig::ADDED;
132 }
133
ConvertIceCandidateType(IceCandidateType type)134 rtclog::IceCandidatePairConfig::IceCandidateType ConvertIceCandidateType(
135 IceCandidateType type) {
136 switch (type) {
137 case IceCandidateType::kUnknown:
138 return rtclog::IceCandidatePairConfig::UNKNOWN_CANDIDATE_TYPE;
139 case IceCandidateType::kLocal:
140 return rtclog::IceCandidatePairConfig::LOCAL;
141 case IceCandidateType::kStun:
142 return rtclog::IceCandidatePairConfig::STUN;
143 case IceCandidateType::kPrflx:
144 return rtclog::IceCandidatePairConfig::PRFLX;
145 case IceCandidateType::kRelay:
146 return rtclog::IceCandidatePairConfig::RELAY;
147 case IceCandidateType::kNumValues:
148 RTC_DCHECK_NOTREACHED();
149 }
150 RTC_DCHECK_NOTREACHED();
151 return rtclog::IceCandidatePairConfig::UNKNOWN_CANDIDATE_TYPE;
152 }
153
ConvertIceCandidatePairProtocol(IceCandidatePairProtocol protocol)154 rtclog::IceCandidatePairConfig::Protocol ConvertIceCandidatePairProtocol(
155 IceCandidatePairProtocol protocol) {
156 switch (protocol) {
157 case IceCandidatePairProtocol::kUnknown:
158 return rtclog::IceCandidatePairConfig::UNKNOWN_PROTOCOL;
159 case IceCandidatePairProtocol::kUdp:
160 return rtclog::IceCandidatePairConfig::UDP;
161 case IceCandidatePairProtocol::kTcp:
162 return rtclog::IceCandidatePairConfig::TCP;
163 case IceCandidatePairProtocol::kSsltcp:
164 return rtclog::IceCandidatePairConfig::SSLTCP;
165 case IceCandidatePairProtocol::kTls:
166 return rtclog::IceCandidatePairConfig::TLS;
167 case IceCandidatePairProtocol::kNumValues:
168 RTC_DCHECK_NOTREACHED();
169 }
170 RTC_DCHECK_NOTREACHED();
171 return rtclog::IceCandidatePairConfig::UNKNOWN_PROTOCOL;
172 }
173
174 rtclog::IceCandidatePairConfig::AddressFamily
ConvertIceCandidatePairAddressFamily(IceCandidatePairAddressFamily address_family)175 ConvertIceCandidatePairAddressFamily(
176 IceCandidatePairAddressFamily address_family) {
177 switch (address_family) {
178 case IceCandidatePairAddressFamily::kUnknown:
179 return rtclog::IceCandidatePairConfig::UNKNOWN_ADDRESS_FAMILY;
180 case IceCandidatePairAddressFamily::kIpv4:
181 return rtclog::IceCandidatePairConfig::IPV4;
182 case IceCandidatePairAddressFamily::kIpv6:
183 return rtclog::IceCandidatePairConfig::IPV6;
184 case IceCandidatePairAddressFamily::kNumValues:
185 RTC_DCHECK_NOTREACHED();
186 }
187 RTC_DCHECK_NOTREACHED();
188 return rtclog::IceCandidatePairConfig::UNKNOWN_ADDRESS_FAMILY;
189 }
190
ConvertIceCandidateNetworkType(IceCandidateNetworkType network_type)191 rtclog::IceCandidatePairConfig::NetworkType ConvertIceCandidateNetworkType(
192 IceCandidateNetworkType network_type) {
193 switch (network_type) {
194 case IceCandidateNetworkType::kUnknown:
195 return rtclog::IceCandidatePairConfig::UNKNOWN_NETWORK_TYPE;
196 case IceCandidateNetworkType::kEthernet:
197 return rtclog::IceCandidatePairConfig::ETHERNET;
198 case IceCandidateNetworkType::kLoopback:
199 return rtclog::IceCandidatePairConfig::LOOPBACK;
200 case IceCandidateNetworkType::kWifi:
201 return rtclog::IceCandidatePairConfig::WIFI;
202 case IceCandidateNetworkType::kVpn:
203 return rtclog::IceCandidatePairConfig::VPN;
204 case IceCandidateNetworkType::kCellular:
205 return rtclog::IceCandidatePairConfig::CELLULAR;
206 case IceCandidateNetworkType::kNumValues:
207 RTC_DCHECK_NOTREACHED();
208 }
209 RTC_DCHECK_NOTREACHED();
210 return rtclog::IceCandidatePairConfig::UNKNOWN_NETWORK_TYPE;
211 }
212
213 rtclog::IceCandidatePairEvent::IceCandidatePairEventType
ConvertIceCandidatePairEventType(IceCandidatePairEventType type)214 ConvertIceCandidatePairEventType(IceCandidatePairEventType type) {
215 switch (type) {
216 case IceCandidatePairEventType::kCheckSent:
217 return rtclog::IceCandidatePairEvent::CHECK_SENT;
218 case IceCandidatePairEventType::kCheckReceived:
219 return rtclog::IceCandidatePairEvent::CHECK_RECEIVED;
220 case IceCandidatePairEventType::kCheckResponseSent:
221 return rtclog::IceCandidatePairEvent::CHECK_RESPONSE_SENT;
222 case IceCandidatePairEventType::kCheckResponseReceived:
223 return rtclog::IceCandidatePairEvent::CHECK_RESPONSE_RECEIVED;
224 case IceCandidatePairEventType::kNumValues:
225 RTC_DCHECK_NOTREACHED();
226 }
227 RTC_DCHECK_NOTREACHED();
228 return rtclog::IceCandidatePairEvent::CHECK_SENT;
229 }
230
231 } // namespace
232
EncodeLogStart(int64_t timestamp_us,int64_t utc_time_us)233 std::string RtcEventLogEncoderLegacy::EncodeLogStart(int64_t timestamp_us,
234 int64_t utc_time_us) {
235 rtclog::Event rtclog_event;
236 rtclog_event.set_timestamp_us(timestamp_us);
237 rtclog_event.set_type(rtclog::Event::LOG_START);
238 return Serialize(&rtclog_event);
239 }
240
EncodeLogEnd(int64_t timestamp_us)241 std::string RtcEventLogEncoderLegacy::EncodeLogEnd(int64_t timestamp_us) {
242 rtclog::Event rtclog_event;
243 rtclog_event.set_timestamp_us(timestamp_us);
244 rtclog_event.set_type(rtclog::Event::LOG_END);
245 return Serialize(&rtclog_event);
246 }
247
EncodeBatch(std::deque<std::unique_ptr<RtcEvent>>::const_iterator begin,std::deque<std::unique_ptr<RtcEvent>>::const_iterator end)248 std::string RtcEventLogEncoderLegacy::EncodeBatch(
249 std::deque<std::unique_ptr<RtcEvent>>::const_iterator begin,
250 std::deque<std::unique_ptr<RtcEvent>>::const_iterator end) {
251 std::string encoded_output;
252 for (auto it = begin; it != end; ++it) {
253 // TODO(terelius): Can we avoid the slight inefficiency of reallocating the
254 // string?
255 RTC_CHECK(it->get() != nullptr);
256 encoded_output += Encode(**it);
257 }
258 return encoded_output;
259 }
260
Encode(const RtcEvent & event)261 std::string RtcEventLogEncoderLegacy::Encode(const RtcEvent& event) {
262 switch (event.GetType()) {
263 case RtcEvent::Type::AudioNetworkAdaptation: {
264 auto& rtc_event =
265 static_cast<const RtcEventAudioNetworkAdaptation&>(event);
266 return EncodeAudioNetworkAdaptation(rtc_event);
267 }
268
269 case RtcEvent::Type::AlrStateEvent: {
270 auto& rtc_event = static_cast<const RtcEventAlrState&>(event);
271 return EncodeAlrState(rtc_event);
272 }
273
274 case RtcEvent::Type::AudioPlayout: {
275 auto& rtc_event = static_cast<const RtcEventAudioPlayout&>(event);
276 return EncodeAudioPlayout(rtc_event);
277 }
278
279 case RtcEvent::Type::AudioReceiveStreamConfig: {
280 auto& rtc_event =
281 static_cast<const RtcEventAudioReceiveStreamConfig&>(event);
282 return EncodeAudioReceiveStreamConfig(rtc_event);
283 }
284
285 case RtcEvent::Type::AudioSendStreamConfig: {
286 auto& rtc_event =
287 static_cast<const RtcEventAudioSendStreamConfig&>(event);
288 return EncodeAudioSendStreamConfig(rtc_event);
289 }
290
291 case RtcEvent::Type::BweUpdateDelayBased: {
292 auto& rtc_event = static_cast<const RtcEventBweUpdateDelayBased&>(event);
293 return EncodeBweUpdateDelayBased(rtc_event);
294 }
295
296 case RtcEvent::Type::BweUpdateLossBased: {
297 auto& rtc_event = static_cast<const RtcEventBweUpdateLossBased&>(event);
298 return EncodeBweUpdateLossBased(rtc_event);
299 }
300
301 case RtcEvent::Type::DtlsTransportState: {
302 return "";
303 }
304
305 case RtcEvent::Type::DtlsWritableState: {
306 return "";
307 }
308
309 case RtcEvent::Type::IceCandidatePairConfig: {
310 auto& rtc_event =
311 static_cast<const RtcEventIceCandidatePairConfig&>(event);
312 return EncodeIceCandidatePairConfig(rtc_event);
313 }
314
315 case RtcEvent::Type::IceCandidatePairEvent: {
316 auto& rtc_event = static_cast<const RtcEventIceCandidatePair&>(event);
317 return EncodeIceCandidatePairEvent(rtc_event);
318 }
319
320 case RtcEvent::Type::ProbeClusterCreated: {
321 auto& rtc_event = static_cast<const RtcEventProbeClusterCreated&>(event);
322 return EncodeProbeClusterCreated(rtc_event);
323 }
324
325 case RtcEvent::Type::ProbeResultFailure: {
326 auto& rtc_event = static_cast<const RtcEventProbeResultFailure&>(event);
327 return EncodeProbeResultFailure(rtc_event);
328 }
329
330 case RtcEvent::Type::ProbeResultSuccess: {
331 auto& rtc_event = static_cast<const RtcEventProbeResultSuccess&>(event);
332 return EncodeProbeResultSuccess(rtc_event);
333 }
334
335 case RtcEvent::Type::RemoteEstimateEvent: {
336 auto& rtc_event = static_cast<const RtcEventRemoteEstimate&>(event);
337 return EncodeRemoteEstimate(rtc_event);
338 }
339
340 case RtcEvent::Type::RtcpPacketIncoming: {
341 auto& rtc_event = static_cast<const RtcEventRtcpPacketIncoming&>(event);
342 return EncodeRtcpPacketIncoming(rtc_event);
343 }
344
345 case RtcEvent::Type::RtcpPacketOutgoing: {
346 auto& rtc_event = static_cast<const RtcEventRtcpPacketOutgoing&>(event);
347 return EncodeRtcpPacketOutgoing(rtc_event);
348 }
349
350 case RtcEvent::Type::RtpPacketIncoming: {
351 auto& rtc_event = static_cast<const RtcEventRtpPacketIncoming&>(event);
352 return EncodeRtpPacketIncoming(rtc_event);
353 }
354
355 case RtcEvent::Type::RtpPacketOutgoing: {
356 auto& rtc_event = static_cast<const RtcEventRtpPacketOutgoing&>(event);
357 return EncodeRtpPacketOutgoing(rtc_event);
358 }
359
360 case RtcEvent::Type::VideoReceiveStreamConfig: {
361 auto& rtc_event =
362 static_cast<const RtcEventVideoReceiveStreamConfig&>(event);
363 return EncodeVideoReceiveStreamConfig(rtc_event);
364 }
365
366 case RtcEvent::Type::VideoSendStreamConfig: {
367 auto& rtc_event =
368 static_cast<const RtcEventVideoSendStreamConfig&>(event);
369 return EncodeVideoSendStreamConfig(rtc_event);
370 }
371 case RtcEvent::Type::BeginV3Log:
372 case RtcEvent::Type::EndV3Log:
373 // These special events are written as part of starting
374 // and stopping the log, and only as part of version 3 of the format.
375 RTC_DCHECK_NOTREACHED();
376 break;
377 case RtcEvent::Type::RouteChangeEvent:
378 case RtcEvent::Type::GenericPacketReceived:
379 case RtcEvent::Type::GenericPacketSent:
380 case RtcEvent::Type::GenericAckReceived:
381 case RtcEvent::Type::FrameDecoded:
382 // These are unsupported in the old format, but shouldn't crash.
383 return "";
384 }
385
386 int event_type = static_cast<int>(event.GetType());
387 RTC_DCHECK_NOTREACHED() << "Unknown event type (" << event_type << ")";
388 return "";
389 }
390
EncodeAlrState(const RtcEventAlrState & event)391 std::string RtcEventLogEncoderLegacy::EncodeAlrState(
392 const RtcEventAlrState& event) {
393 rtclog::Event rtclog_event;
394 rtclog_event.set_timestamp_us(event.timestamp_us());
395 rtclog_event.set_type(rtclog::Event::ALR_STATE_EVENT);
396
397 auto* alr_state = rtclog_event.mutable_alr_state();
398 alr_state->set_in_alr(event.in_alr());
399 return Serialize(&rtclog_event);
400 }
401
EncodeAudioNetworkAdaptation(const RtcEventAudioNetworkAdaptation & event)402 std::string RtcEventLogEncoderLegacy::EncodeAudioNetworkAdaptation(
403 const RtcEventAudioNetworkAdaptation& event) {
404 rtclog::Event rtclog_event;
405 rtclog_event.set_timestamp_us(event.timestamp_us());
406 rtclog_event.set_type(rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);
407
408 auto* audio_network_adaptation =
409 rtclog_event.mutable_audio_network_adaptation();
410 if (event.config().bitrate_bps)
411 audio_network_adaptation->set_bitrate_bps(*event.config().bitrate_bps);
412 if (event.config().frame_length_ms)
413 audio_network_adaptation->set_frame_length_ms(
414 *event.config().frame_length_ms);
415 if (event.config().uplink_packet_loss_fraction) {
416 audio_network_adaptation->set_uplink_packet_loss_fraction(
417 *event.config().uplink_packet_loss_fraction);
418 }
419 if (event.config().enable_fec)
420 audio_network_adaptation->set_enable_fec(*event.config().enable_fec);
421 if (event.config().enable_dtx)
422 audio_network_adaptation->set_enable_dtx(*event.config().enable_dtx);
423 if (event.config().num_channels)
424 audio_network_adaptation->set_num_channels(*event.config().num_channels);
425
426 return Serialize(&rtclog_event);
427 }
428
EncodeAudioPlayout(const RtcEventAudioPlayout & event)429 std::string RtcEventLogEncoderLegacy::EncodeAudioPlayout(
430 const RtcEventAudioPlayout& event) {
431 rtclog::Event rtclog_event;
432 rtclog_event.set_timestamp_us(event.timestamp_us());
433 rtclog_event.set_type(rtclog::Event::AUDIO_PLAYOUT_EVENT);
434
435 auto* playout_event = rtclog_event.mutable_audio_playout_event();
436 playout_event->set_local_ssrc(event.ssrc());
437
438 return Serialize(&rtclog_event);
439 }
440
EncodeAudioReceiveStreamConfig(const RtcEventAudioReceiveStreamConfig & event)441 std::string RtcEventLogEncoderLegacy::EncodeAudioReceiveStreamConfig(
442 const RtcEventAudioReceiveStreamConfig& event) {
443 rtclog::Event rtclog_event;
444 rtclog_event.set_timestamp_us(event.timestamp_us());
445 rtclog_event.set_type(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT);
446
447 rtclog::AudioReceiveConfig* receiver_config =
448 rtclog_event.mutable_audio_receiver_config();
449 receiver_config->set_remote_ssrc(event.config().remote_ssrc);
450 receiver_config->set_local_ssrc(event.config().local_ssrc);
451
452 for (const auto& e : event.config().rtp_extensions) {
453 rtclog::RtpHeaderExtension* extension =
454 receiver_config->add_header_extensions();
455 extension->set_name(e.uri);
456 extension->set_id(e.id);
457 }
458
459 return Serialize(&rtclog_event);
460 }
461
EncodeAudioSendStreamConfig(const RtcEventAudioSendStreamConfig & event)462 std::string RtcEventLogEncoderLegacy::EncodeAudioSendStreamConfig(
463 const RtcEventAudioSendStreamConfig& event) {
464 rtclog::Event rtclog_event;
465 rtclog_event.set_timestamp_us(event.timestamp_us());
466 rtclog_event.set_type(rtclog::Event::AUDIO_SENDER_CONFIG_EVENT);
467
468 rtclog::AudioSendConfig* sender_config =
469 rtclog_event.mutable_audio_sender_config();
470
471 sender_config->set_ssrc(event.config().local_ssrc);
472
473 for (const auto& e : event.config().rtp_extensions) {
474 rtclog::RtpHeaderExtension* extension =
475 sender_config->add_header_extensions();
476 extension->set_name(e.uri);
477 extension->set_id(e.id);
478 }
479
480 return Serialize(&rtclog_event);
481 }
482
EncodeBweUpdateDelayBased(const RtcEventBweUpdateDelayBased & event)483 std::string RtcEventLogEncoderLegacy::EncodeBweUpdateDelayBased(
484 const RtcEventBweUpdateDelayBased& event) {
485 rtclog::Event rtclog_event;
486 rtclog_event.set_timestamp_us(event.timestamp_us());
487 rtclog_event.set_type(rtclog::Event::DELAY_BASED_BWE_UPDATE);
488
489 auto* bwe_event = rtclog_event.mutable_delay_based_bwe_update();
490 bwe_event->set_bitrate_bps(event.bitrate_bps());
491 bwe_event->set_detector_state(ConvertDetectorState(event.detector_state()));
492
493 return Serialize(&rtclog_event);
494 }
495
EncodeBweUpdateLossBased(const RtcEventBweUpdateLossBased & event)496 std::string RtcEventLogEncoderLegacy::EncodeBweUpdateLossBased(
497 const RtcEventBweUpdateLossBased& event) {
498 rtclog::Event rtclog_event;
499 rtclog_event.set_timestamp_us(event.timestamp_us());
500 rtclog_event.set_type(rtclog::Event::LOSS_BASED_BWE_UPDATE);
501
502 auto* bwe_event = rtclog_event.mutable_loss_based_bwe_update();
503 bwe_event->set_bitrate_bps(event.bitrate_bps());
504 bwe_event->set_fraction_loss(event.fraction_loss());
505 bwe_event->set_total_packets(event.total_packets());
506
507 return Serialize(&rtclog_event);
508 }
509
EncodeIceCandidatePairConfig(const RtcEventIceCandidatePairConfig & event)510 std::string RtcEventLogEncoderLegacy::EncodeIceCandidatePairConfig(
511 const RtcEventIceCandidatePairConfig& event) {
512 rtclog::Event encoded_rtc_event;
513 encoded_rtc_event.set_timestamp_us(event.timestamp_us());
514 encoded_rtc_event.set_type(rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG);
515
516 auto* encoded_ice_event =
517 encoded_rtc_event.mutable_ice_candidate_pair_config();
518 encoded_ice_event->set_config_type(
519 ConvertIceCandidatePairConfigType(event.type()));
520 encoded_ice_event->set_candidate_pair_id(event.candidate_pair_id());
521 const auto& desc = event.candidate_pair_desc();
522 encoded_ice_event->set_local_candidate_type(
523 ConvertIceCandidateType(desc.local_candidate_type));
524 encoded_ice_event->set_local_relay_protocol(
525 ConvertIceCandidatePairProtocol(desc.local_relay_protocol));
526 encoded_ice_event->set_local_network_type(
527 ConvertIceCandidateNetworkType(desc.local_network_type));
528 encoded_ice_event->set_local_address_family(
529 ConvertIceCandidatePairAddressFamily(desc.local_address_family));
530 encoded_ice_event->set_remote_candidate_type(
531 ConvertIceCandidateType(desc.remote_candidate_type));
532 encoded_ice_event->set_remote_address_family(
533 ConvertIceCandidatePairAddressFamily(desc.remote_address_family));
534 encoded_ice_event->set_candidate_pair_protocol(
535 ConvertIceCandidatePairProtocol(desc.candidate_pair_protocol));
536 return Serialize(&encoded_rtc_event);
537 }
538
EncodeIceCandidatePairEvent(const RtcEventIceCandidatePair & event)539 std::string RtcEventLogEncoderLegacy::EncodeIceCandidatePairEvent(
540 const RtcEventIceCandidatePair& event) {
541 rtclog::Event encoded_rtc_event;
542 encoded_rtc_event.set_timestamp_us(event.timestamp_us());
543 encoded_rtc_event.set_type(rtclog::Event::ICE_CANDIDATE_PAIR_EVENT);
544
545 auto* encoded_ice_event =
546 encoded_rtc_event.mutable_ice_candidate_pair_event();
547 encoded_ice_event->set_event_type(
548 ConvertIceCandidatePairEventType(event.type()));
549 encoded_ice_event->set_candidate_pair_id(event.candidate_pair_id());
550 return Serialize(&encoded_rtc_event);
551 }
552
EncodeProbeClusterCreated(const RtcEventProbeClusterCreated & event)553 std::string RtcEventLogEncoderLegacy::EncodeProbeClusterCreated(
554 const RtcEventProbeClusterCreated& event) {
555 rtclog::Event rtclog_event;
556 rtclog_event.set_timestamp_us(event.timestamp_us());
557 rtclog_event.set_type(rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT);
558
559 auto* probe_cluster = rtclog_event.mutable_probe_cluster();
560 probe_cluster->set_id(event.id());
561 probe_cluster->set_bitrate_bps(event.bitrate_bps());
562 probe_cluster->set_min_packets(event.min_probes());
563 probe_cluster->set_min_bytes(event.min_bytes());
564
565 return Serialize(&rtclog_event);
566 }
567
EncodeProbeResultFailure(const RtcEventProbeResultFailure & event)568 std::string RtcEventLogEncoderLegacy::EncodeProbeResultFailure(
569 const RtcEventProbeResultFailure& event) {
570 rtclog::Event rtclog_event;
571 rtclog_event.set_timestamp_us(event.timestamp_us());
572 rtclog_event.set_type(rtclog::Event::BWE_PROBE_RESULT_EVENT);
573
574 auto* probe_result = rtclog_event.mutable_probe_result();
575 probe_result->set_id(event.id());
576 probe_result->set_result(ConvertProbeResultType(event.failure_reason()));
577
578 return Serialize(&rtclog_event);
579 }
580
EncodeProbeResultSuccess(const RtcEventProbeResultSuccess & event)581 std::string RtcEventLogEncoderLegacy::EncodeProbeResultSuccess(
582 const RtcEventProbeResultSuccess& event) {
583 rtclog::Event rtclog_event;
584 rtclog_event.set_timestamp_us(event.timestamp_us());
585 rtclog_event.set_type(rtclog::Event::BWE_PROBE_RESULT_EVENT);
586
587 auto* probe_result = rtclog_event.mutable_probe_result();
588 probe_result->set_id(event.id());
589 probe_result->set_result(rtclog::BweProbeResult::SUCCESS);
590 probe_result->set_bitrate_bps(event.bitrate_bps());
591
592 return Serialize(&rtclog_event);
593 }
594
EncodeRemoteEstimate(const RtcEventRemoteEstimate & event)595 std::string RtcEventLogEncoderLegacy::EncodeRemoteEstimate(
596 const RtcEventRemoteEstimate& event) {
597 rtclog::Event rtclog_event;
598 rtclog_event.set_timestamp_us(event.timestamp_us());
599 rtclog_event.set_type(rtclog::Event::REMOTE_ESTIMATE);
600
601 auto* remote_estimate = rtclog_event.mutable_remote_estimate();
602 if (event.link_capacity_lower_.IsFinite())
603 remote_estimate->set_link_capacity_lower_kbps(
604 event.link_capacity_lower_.kbps<uint32_t>());
605 if (event.link_capacity_upper_.IsFinite())
606 remote_estimate->set_link_capacity_upper_kbps(
607 event.link_capacity_upper_.kbps<uint32_t>());
608
609 return Serialize(&rtclog_event);
610 }
611
EncodeRtcpPacketIncoming(const RtcEventRtcpPacketIncoming & event)612 std::string RtcEventLogEncoderLegacy::EncodeRtcpPacketIncoming(
613 const RtcEventRtcpPacketIncoming& event) {
614 return EncodeRtcpPacket(event.timestamp_us(), event.packet(), true);
615 }
616
EncodeRtcpPacketOutgoing(const RtcEventRtcpPacketOutgoing & event)617 std::string RtcEventLogEncoderLegacy::EncodeRtcpPacketOutgoing(
618 const RtcEventRtcpPacketOutgoing& event) {
619 return EncodeRtcpPacket(event.timestamp_us(), event.packet(), false);
620 }
621
EncodeRtpPacketIncoming(const RtcEventRtpPacketIncoming & event)622 std::string RtcEventLogEncoderLegacy::EncodeRtpPacketIncoming(
623 const RtcEventRtpPacketIncoming& event) {
624 return EncodeRtpPacket(event.timestamp_us(), event.RawHeader(),
625 event.packet_length(), PacedPacketInfo::kNotAProbe,
626 true);
627 }
628
EncodeRtpPacketOutgoing(const RtcEventRtpPacketOutgoing & event)629 std::string RtcEventLogEncoderLegacy::EncodeRtpPacketOutgoing(
630 const RtcEventRtpPacketOutgoing& event) {
631 return EncodeRtpPacket(event.timestamp_us(), event.RawHeader(),
632 event.packet_length(), event.probe_cluster_id(),
633 false);
634 }
635
EncodeVideoReceiveStreamConfig(const RtcEventVideoReceiveStreamConfig & event)636 std::string RtcEventLogEncoderLegacy::EncodeVideoReceiveStreamConfig(
637 const RtcEventVideoReceiveStreamConfig& event) {
638 rtclog::Event rtclog_event;
639 rtclog_event.set_timestamp_us(event.timestamp_us());
640 rtclog_event.set_type(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT);
641
642 rtclog::VideoReceiveConfig* receiver_config =
643 rtclog_event.mutable_video_receiver_config();
644 receiver_config->set_remote_ssrc(event.config().remote_ssrc);
645 receiver_config->set_local_ssrc(event.config().local_ssrc);
646
647 // TODO(perkj): Add field for rsid.
648 receiver_config->set_rtcp_mode(ConvertRtcpMode(event.config().rtcp_mode));
649 receiver_config->set_remb(event.config().remb);
650
651 for (const auto& e : event.config().rtp_extensions) {
652 rtclog::RtpHeaderExtension* extension =
653 receiver_config->add_header_extensions();
654 extension->set_name(e.uri);
655 extension->set_id(e.id);
656 }
657
658 for (const auto& d : event.config().codecs) {
659 rtclog::DecoderConfig* decoder = receiver_config->add_decoders();
660 decoder->set_name(d.payload_name);
661 decoder->set_payload_type(d.payload_type);
662 if (d.rtx_payload_type != 0) {
663 rtclog::RtxMap* rtx = receiver_config->add_rtx_map();
664 rtx->set_payload_type(d.payload_type);
665 rtx->mutable_config()->set_rtx_ssrc(event.config().rtx_ssrc);
666 rtx->mutable_config()->set_rtx_payload_type(d.rtx_payload_type);
667 }
668 }
669
670 return Serialize(&rtclog_event);
671 }
672
EncodeVideoSendStreamConfig(const RtcEventVideoSendStreamConfig & event)673 std::string RtcEventLogEncoderLegacy::EncodeVideoSendStreamConfig(
674 const RtcEventVideoSendStreamConfig& event) {
675 rtclog::Event rtclog_event;
676 rtclog_event.set_timestamp_us(event.timestamp_us());
677 rtclog_event.set_type(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT);
678
679 rtclog::VideoSendConfig* sender_config =
680 rtclog_event.mutable_video_sender_config();
681
682 // TODO(perkj): rtclog::VideoSendConfig should only contain one SSRC.
683 sender_config->add_ssrcs(event.config().local_ssrc);
684 if (event.config().rtx_ssrc != 0) {
685 sender_config->add_rtx_ssrcs(event.config().rtx_ssrc);
686 }
687
688 for (const auto& e : event.config().rtp_extensions) {
689 rtclog::RtpHeaderExtension* extension =
690 sender_config->add_header_extensions();
691 extension->set_name(e.uri);
692 extension->set_id(e.id);
693 }
694
695 // TODO(perkj): rtclog::VideoSendConfig should contain many possible codec
696 // configurations.
697 for (const auto& codec : event.config().codecs) {
698 sender_config->set_rtx_payload_type(codec.rtx_payload_type);
699 rtclog::EncoderConfig* encoder = sender_config->mutable_encoder();
700 encoder->set_name(codec.payload_name);
701 encoder->set_payload_type(codec.payload_type);
702
703 if (event.config().codecs.size() > 1) {
704 RTC_LOG(LS_WARNING)
705 << "LogVideoSendStreamConfig currently only supports one "
706 "codec. Logging codec :"
707 << codec.payload_name;
708 break;
709 }
710 }
711
712 return Serialize(&rtclog_event);
713 }
714
EncodeRtcpPacket(int64_t timestamp_us,const rtc::Buffer & packet,bool is_incoming)715 std::string RtcEventLogEncoderLegacy::EncodeRtcpPacket(
716 int64_t timestamp_us,
717 const rtc::Buffer& packet,
718 bool is_incoming) {
719 rtclog::Event rtclog_event;
720 rtclog_event.set_timestamp_us(timestamp_us);
721 rtclog_event.set_type(rtclog::Event::RTCP_EVENT);
722 rtclog_event.mutable_rtcp_packet()->set_incoming(is_incoming);
723
724 rtcp::CommonHeader header;
725 const uint8_t* block_begin = packet.data();
726 const uint8_t* packet_end = packet.data() + packet.size();
727 std::vector<uint8_t> buffer(packet.size());
728 uint32_t buffer_length = 0;
729 while (block_begin < packet_end) {
730 if (!header.Parse(block_begin, packet_end - block_begin)) {
731 break; // Incorrect message header.
732 }
733 const uint8_t* next_block = header.NextPacket();
734 uint32_t block_size = next_block - block_begin;
735 switch (header.type()) {
736 case rtcp::Bye::kPacketType:
737 case rtcp::ExtendedReports::kPacketType:
738 case rtcp::Psfb::kPacketType:
739 case rtcp::ReceiverReport::kPacketType:
740 case rtcp::Rtpfb::kPacketType:
741 case rtcp::SenderReport::kPacketType:
742 // We log sender reports, receiver reports, bye messages, third-party
743 // loss reports, payload-specific feedback and extended reports.
744 memcpy(buffer.data() + buffer_length, block_begin, block_size);
745 buffer_length += block_size;
746 break;
747 case rtcp::App::kPacketType:
748 case rtcp::Sdes::kPacketType:
749 default:
750 // We don't log sender descriptions, application defined messages
751 // or message blocks of unknown type.
752 break;
753 }
754
755 block_begin += block_size;
756 }
757 rtclog_event.mutable_rtcp_packet()->set_packet_data(buffer.data(),
758 buffer_length);
759
760 return Serialize(&rtclog_event);
761 }
762
EncodeRtpPacket(int64_t timestamp_us,rtc::ArrayView<const uint8_t> header,size_t packet_length,int probe_cluster_id,bool is_incoming)763 std::string RtcEventLogEncoderLegacy::EncodeRtpPacket(
764 int64_t timestamp_us,
765 rtc::ArrayView<const uint8_t> header,
766 size_t packet_length,
767 int probe_cluster_id,
768 bool is_incoming) {
769 rtclog::Event rtclog_event;
770 rtclog_event.set_timestamp_us(timestamp_us);
771 rtclog_event.set_type(rtclog::Event::RTP_EVENT);
772
773 rtclog_event.mutable_rtp_packet()->set_incoming(is_incoming);
774 rtclog_event.mutable_rtp_packet()->set_packet_length(packet_length);
775 rtclog_event.mutable_rtp_packet()->set_header(header.data(), header.size());
776 if (probe_cluster_id != PacedPacketInfo::kNotAProbe) {
777 RTC_DCHECK(!is_incoming);
778 rtclog_event.mutable_rtp_packet()->set_probe_cluster_id(probe_cluster_id);
779 }
780
781 return Serialize(&rtclog_event);
782 }
783
Serialize(rtclog::Event * event)784 std::string RtcEventLogEncoderLegacy::Serialize(rtclog::Event* event) {
785 // Even though we're only serializing a single event during this call, what
786 // we intend to get is a list of events, with a tag and length preceding
787 // each actual event. To produce that, we serialize a list of a single event.
788 // If we later concatenate several results from this function, the result will
789 // be a proper concatenation of all those events.
790
791 rtclog::EventStream event_stream;
792 event_stream.add_stream();
793
794 // As a tweak, we swap the new event into the event-stream, write that to
795 // file, then swap back. This saves on some copying, while making sure that
796 // the caller wouldn't be surprised by Serialize() modifying the object.
797 rtclog::Event* output_event = event_stream.mutable_stream(0);
798 output_event->Swap(event);
799
800 std::string output_string = event_stream.SerializeAsString();
801 RTC_DCHECK(!output_string.empty());
802
803 // When the function returns, the original Event will be unchanged.
804 output_event->Swap(event);
805
806 return output_string;
807 }
808
809 } // namespace webrtc
810