Create RtcEventLogEncoderLegacy

webrtc/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc

+/*
+ *  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 "webrtc/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h"
+
+#include "webrtc/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_audio_playout.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_logging_started.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_logging_stopped.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_probe_cluster_created.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_probe_result_failure.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_probe_result_success.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
+#include "webrtc/logging/rtc_event_log/rtc_stream_config.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
+#include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet.h"
+#include "webrtc/rtc_base/checks.h"
+#include "webrtc/rtc_base/ignore_wundef.h"
+#include "webrtc/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()
+#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
+#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
+#else
+#include "webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
+#endif
+RTC_POP_IGNORING_WUNDEF()
+#endif
+
+namespace webrtc {
+
+namespace {
+rtclog::DelayBasedBweUpdate::DetectorState ConvertDetectorState(
+    BandwidthUsage state) {
+  switch (state) {
+    case BandwidthUsage::kBwNormal:
+      return rtclog::DelayBasedBweUpdate::BWE_NORMAL;
+    case BandwidthUsage::kBwUnderusing:
+      return rtclog::DelayBasedBweUpdate::BWE_UNDERUSING;
+    case BandwidthUsage::kBwOverusing:
+      return rtclog::DelayBasedBweUpdate::BWE_OVERUSING;
+  }
+  RTC_NOTREACHED();
+  return rtclog::DelayBasedBweUpdate::BWE_NORMAL;
+}
+
+rtclog::BweProbeResult::ResultType ConvertProbeResultType(
+    ProbeFailureReason failure_reason) {
+  switch (failure_reason) {
+    case kInvalidSendReceiveInterval:
+      return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL;
+    case kInvalidSendReceiveRatio:
+      return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO;
+    case kTimeout:
+      return rtclog::BweProbeResult::TIMEOUT;
+  }
+  RTC_NOTREACHED();
+  return rtclog::BweProbeResult::SUCCESS;
+}
+
+rtclog::VideoReceiveConfig_RtcpMode ConvertRtcpMode(RtcpMode rtcp_mode) {
+  switch (rtcp_mode) {
+    case RtcpMode::kCompound:
+      return rtclog::VideoReceiveConfig::RTCP_COMPOUND;
+    case RtcpMode::kReducedSize:
+      return rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE;
+    case RtcpMode::kOff:
+      RTC_NOTREACHED();
+      return rtclog::VideoReceiveConfig::RTCP_COMPOUND;
+  }
+  RTC_NOTREACHED();
+  return rtclog::VideoReceiveConfig::RTCP_COMPOUND;
+}
+}  // namespace
+
+std::string RtcEventLogEncoderLegacy::Encode(const RtcEvent& event) {
+  switch (event.GetType()) {
+    case RtcEvent::Type::AudioNetworkAdaptation: {
+      auto& rtc_event =
+          static_cast<const RtcEventAudioNetworkAdaptation&>(event);
+      return AudioNetworkAdaptation(rtc_event);
+    }
+
+    case RtcEvent::Type::AudioPlayout: {
+      auto& rtc_event = static_cast<const RtcEventAudioPlayout&>(event);
+      return AudioPlayout(rtc_event);
+    }
+
+    case RtcEvent::Type::AudioReceiveStreamConfig: {
+      auto& rtc_event =
+          static_cast<const RtcEventAudioReceiveStreamConfig&>(event);
+      return AudioReceiveStreamConfig(rtc_event);
+    }
+
+    case RtcEvent::Type::AudioSendStreamConfig: {
+      auto& rtc_event =
+          static_cast<const RtcEventAudioSendStreamConfig&>(event);
+      return AudioSendStreamConfig(rtc_event);
+    }
+
+    case RtcEvent::Type::BweUpdateDelayBased: {
+      auto& rtc_event = static_cast<const RtcEventBweUpdateDelayBased&>(event);
+      return BweUpdateDelayBased(rtc_event);
+    }
+
+    case RtcEvent::Type::BweUpdateLossBased: {
+      auto& rtc_event = static_cast<const RtcEventBweUpdateLossBased&>(event);
+      return BweUpdateLossBased(rtc_event);
+    }
+
+    case RtcEvent::Type::LoggingStarted: {
+      auto& rtc_event = static_cast<const RtcEventLoggingStarted&>(event);
+      return LoggingStarted(rtc_event);
+    }
+
+    case RtcEvent::Type::LoggingStopped: {
+      auto& rtc_event = static_cast<const RtcEventLoggingStopped&>(event);
+      return LoggingStopped(rtc_event);
+    }
+
+    case RtcEvent::Type::ProbeClusterCreated: {
+      auto& rtc_event = static_cast<const RtcEventProbeClusterCreated&>(event);
+      return ProbeClusterCreated(rtc_event);
+    }
+
+    case RtcEvent::Type::ProbeResultFailure: {
+      auto& rtc_event = static_cast<const RtcEventProbeResultFailure&>(event);
+      return ProbeResultFailure(rtc_event);
+    }
+
+    case RtcEvent::Type::ProbeResultSuccess: {
+      auto& rtc_event = static_cast<const RtcEventProbeResultSuccess&>(event);
+      return ProbeResultSuccess(rtc_event);
+    }
+
+    case RtcEvent::Type::RtcpPacketIncoming: {
+      auto& rtc_event = static_cast<const RtcEventRtcpPacketIncoming&>(event);
+      return RtcpPacketIncoming(rtc_event);
+    }
+
+    case RtcEvent::Type::RtcpPacketOutgoing: {
+      auto& rtc_event = static_cast<const RtcEventRtcpPacketOutgoing&>(event);
+      return RtcpPacketOutgoing(rtc_event);
+    }
+
+    case RtcEvent::Type::RtpPacketIncoming: {
+      auto& rtc_event = static_cast<const RtcEventRtpPacketIncoming&>(event);
+      return RtpPacketIncoming(rtc_event);
+    }
+
+    case RtcEvent::Type::RtpPacketOutgoing: {
+      auto& rtc_event = static_cast<const RtcEventRtpPacketOutgoing&>(event);
+      return RtpPacketOutgoing(rtc_event);
+    }
+
+    case RtcEvent::Type::VideoReceiveStreamConfig: {
+      auto& rtc_event =
+          static_cast<const RtcEventVideoReceiveStreamConfig&>(event);
+      return VideoReceiveStreamConfig(rtc_event);
+    }
+
+    case RtcEvent::Type::VideoSendStreamConfig: {
+      auto& rtc_event =
+          static_cast<const RtcEventVideoSendStreamConfig&>(event);
+      return VideoSendStreamConfig(rtc_event);
+    }
+  }
+
+  int event_type = static_cast<int>(event.GetType());
+  RTC_NOTREACHED() << "Unknown event type (" << event_type << ")";
+}
+
+std::string RtcEventLogEncoderLegacy::AudioNetworkAdaptation(
+    const RtcEventAudioNetworkAdaptation& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);
+
+  auto audio_network_adaptation =
+      rtclog_event.mutable_audio_network_adaptation();
+  if (event.config_->bitrate_bps)
+    audio_network_adaptation->set_bitrate_bps(*event.config_->bitrate_bps);
+  if (event.config_->frame_length_ms)
+    audio_network_adaptation->set_frame_length_ms(
+        *event.config_->frame_length_ms);
+  if (event.config_->uplink_packet_loss_fraction) {
+    audio_network_adaptation->set_uplink_packet_loss_fraction(
+        *event.config_->uplink_packet_loss_fraction);
+  }
+  if (event.config_->enable_fec)
+    audio_network_adaptation->set_enable_fec(*event.config_->enable_fec);
+  if (event.config_->enable_dtx)
+    audio_network_adaptation->set_enable_dtx(*event.config_->enable_dtx);
+  if (event.config_->num_channels)
+    audio_network_adaptation->set_num_channels(*event.config_->num_channels);
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::AudioPlayout(
+    const RtcEventAudioPlayout& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::AUDIO_PLAYOUT_EVENT);
+
+  auto playout_event = rtclog_event.mutable_audio_playout_event();
+  playout_event->set_local_ssrc(event.ssrc_);
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::AudioReceiveStreamConfig(
+    const RtcEventAudioReceiveStreamConfig& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT);
+
+  rtclog::AudioReceiveConfig* receiver_config =
+      rtclog_event.mutable_audio_receiver_config();
+  receiver_config->set_remote_ssrc(event.config_->remote_ssrc);
+  receiver_config->set_local_ssrc(event.config_->local_ssrc);
+
+  for (const auto& e : event.config_->rtp_extensions) {
+    rtclog::RtpHeaderExtension* extension =
+        receiver_config->add_header_extensions();
+    extension->set_name(e.uri);
+    extension->set_id(e.id);
+  }
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::AudioSendStreamConfig(
+    const RtcEventAudioSendStreamConfig& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::AUDIO_SENDER_CONFIG_EVENT);
+
+  rtclog::AudioSendConfig* sender_config =
+      rtclog_event.mutable_audio_sender_config();
+
+  sender_config->set_ssrc(event.config_->local_ssrc);
+
+  for (const auto& e : event.config_->rtp_extensions) {
+    rtclog::RtpHeaderExtension* extension =
+        sender_config->add_header_extensions();
+    extension->set_name(e.uri);
+    extension->set_id(e.id);
+  }
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::BweUpdateDelayBased(
+    const RtcEventBweUpdateDelayBased& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::DELAY_BASED_BWE_UPDATE);
+
+  auto bwe_event = rtclog_event.mutable_delay_based_bwe_update();
+  bwe_event->set_bitrate_bps(event.bitrate_bps_);
+  bwe_event->set_detector_state(ConvertDetectorState(event.detector_state_));
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::BweUpdateLossBased(
+    const RtcEventBweUpdateLossBased& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::LOSS_BASED_BWE_UPDATE);
+
+  auto bwe_event = rtclog_event.mutable_loss_based_bwe_update();
+  bwe_event->set_bitrate_bps(event.bitrate_bps_);
+  bwe_event->set_fraction_loss(event.fraction_loss_);
+  bwe_event->set_total_packets(event.total_packets_);
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::LoggingStarted(
+    const RtcEventLoggingStarted& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::LOG_START);
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::LoggingStopped(
+    const RtcEventLoggingStopped& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::LOG_END);
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::ProbeClusterCreated(
+    const RtcEventProbeClusterCreated& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT);
+
+  auto probe_cluster = rtclog_event.mutable_probe_cluster();
+  probe_cluster->set_id(event.id_);
+  probe_cluster->set_bitrate_bps(event.bitrate_bps_);
+  probe_cluster->set_min_packets(event.min_probes_);
+  probe_cluster->set_min_bytes(event.min_bytes_);
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::ProbeResultFailure(
+    const RtcEventProbeResultFailure& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::BWE_PROBE_RESULT_EVENT);
+
+  auto probe_result = rtclog_event.mutable_probe_result();
+  probe_result->set_id(event.id_);
+  probe_result->set_result(ConvertProbeResultType(event.failure_reason_));
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::ProbeResultSuccess(
+    const RtcEventProbeResultSuccess& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::BWE_PROBE_RESULT_EVENT);
+
+  auto probe_result = rtclog_event.mutable_probe_result();
+  probe_result->set_id(event.id_);
+  probe_result->set_result(rtclog::BweProbeResult::SUCCESS);
+  probe_result->set_bitrate_bps(event.bitrate_bps_);
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::RtcpPacketIncoming(
+    const RtcEventRtcpPacketIncoming& event) {
+  return RtcpPacket(event.timestamp_us_, event.packet_, true);
+}
+
+std::string RtcEventLogEncoderLegacy::RtcpPacketOutgoing(
+    const RtcEventRtcpPacketOutgoing& event) {
+  return RtcpPacket(event.timestamp_us_, event.packet_, false);
+}
+
+std::string RtcEventLogEncoderLegacy::RtpPacketIncoming(
+    const RtcEventRtpPacketIncoming& event) {
+  return RtpPacket(event.timestamp_us_, event.header_, event.packet_length_,
+                   true);
+}
+
+std::string RtcEventLogEncoderLegacy::RtpPacketOutgoing(
+    const RtcEventRtpPacketOutgoing& event) {
+  return RtpPacket(event.timestamp_us_, event.header_, event.packet_length_,
+                   false);
+}
+
+std::string RtcEventLogEncoderLegacy::VideoReceiveStreamConfig(
+    const RtcEventVideoReceiveStreamConfig& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT);
+
+  rtclog::VideoReceiveConfig* receiver_config =
+      rtclog_event.mutable_video_receiver_config();
+  receiver_config->set_remote_ssrc(event.config_->remote_ssrc);
+  receiver_config->set_local_ssrc(event.config_->local_ssrc);
+
+  // TODO(perkj): Add field for rsid.
+  receiver_config->set_rtcp_mode(ConvertRtcpMode(event.config_->rtcp_mode));
+  receiver_config->set_remb(event.config_->remb);
+
+  for (const auto& e : event.config_->rtp_extensions) {
+    rtclog::RtpHeaderExtension* extension =
+        receiver_config->add_header_extensions();
+    extension->set_name(e.uri);
+    extension->set_id(e.id);
+  }
+
+  for (const auto& d : event.config_->codecs) {
+    rtclog::DecoderConfig* decoder = receiver_config->add_decoders();
+    decoder->set_name(d.payload_name);
+    decoder->set_payload_type(d.payload_type);
+    if (d.rtx_payload_type != 0) {
+      rtclog::RtxMap* rtx = receiver_config->add_rtx_map();
+      rtx->set_payload_type(d.payload_type);
+      rtx->mutable_config()->set_rtx_ssrc(event.config_->rtx_ssrc);
+      rtx->mutable_config()->set_rtx_payload_type(d.rtx_payload_type);
+    }
+  }
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::VideoSendStreamConfig(
+    const RtcEventVideoSendStreamConfig& event) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(event.timestamp_us_);
+  rtclog_event.set_type(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT);
+
+  rtclog::VideoSendConfig* sender_config =
+      rtclog_event.mutable_video_sender_config();
+
+  // TODO(perkj): rtclog::VideoSendConfig should only contain one SSRC.
+  sender_config->add_ssrcs(event.config_->local_ssrc);
+  if (event.config_->rtx_ssrc != 0) {
+    sender_config->add_rtx_ssrcs(event.config_->rtx_ssrc);
+  }
+
+  for (const auto& e : event.config_->rtp_extensions) {
+    rtclog::RtpHeaderExtension* extension =
+        sender_config->add_header_extensions();
+    extension->set_name(e.uri);
+    extension->set_id(e.id);
+  }
+
+  // TODO(perkj): rtclog::VideoSendConfig should contain many possible codec
+  // configurations.
+  for (const auto& codec : event.config_->codecs) {
+    sender_config->set_rtx_payload_type(codec.rtx_payload_type);
+    rtclog::EncoderConfig* encoder = sender_config->mutable_encoder();
+    encoder->set_name(codec.payload_name);
+    encoder->set_payload_type(codec.payload_type);
+
+    if (event.config_->codecs.size() > 1) {
+      LOG(WARNING) << "LogVideoSendStreamConfig currently only supports one "
+                   << "codec. Logging codec :" << codec.payload_name;
+      break;
+    }
+  }
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::RtcpPacket(int64_t timestamp_us,
+                                                 const rtc::Buffer& packet,
+                                                 bool is_incoming) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(timestamp_us);
+  rtclog_event.set_type(rtclog::Event::RTCP_EVENT);
+  rtclog_event.mutable_rtcp_packet()->set_incoming(is_incoming);
+
+  rtcp::CommonHeader header;
+  const uint8_t* block_begin = packet.data();
+  const uint8_t* packet_end = packet.data() + packet.size();
+  RTC_DCHECK(packet.size() <= IP_PACKET_SIZE);
+  uint8_t buffer[IP_PACKET_SIZE];
+  uint32_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();
+    uint32_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.
+        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;
+  }
+  rtclog_event.mutable_rtcp_packet()->set_packet_data(buffer, buffer_length);
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::RtpPacket(int64_t timestamp_us,
+                                                const rtp::Packet& header,
+                                                size_t packet_length,
+                                                bool is_incoming) {
+  rtclog::Event rtclog_event;
+  rtclog_event.set_timestamp_us(timestamp_us);
+  rtclog_event.set_type(rtclog::Event::RTP_EVENT);
+
+  rtclog_event.mutable_rtp_packet()->set_incoming(is_incoming);
+  rtclog_event.mutable_rtp_packet()->set_packet_length(packet_length);
+  rtclog_event.mutable_rtp_packet()->set_header(header.data(), header.size());
+
+  return Serialize(&rtclog_event);
+}
+
+std::string RtcEventLogEncoderLegacy::Serialize(rtclog::Event* event) {
+  // Even though we're only serializing a single event during this call, what
+  // we intend to get is a list of events, with a tag and length preceding
+  // each actual event. To produce that, we serialize a list of a single event.
+  // If we later concatenate several results from this function, the result will
+  // be a proper concatenation of all those events.
+
+  rtclog::EventStream event_stream;
+  event_stream.add_stream();
+
+  // As a tweak, we swap the new event into the event-stream, write that to
+  // file, then swap back. This saves on some copying, while making sure that
+  // the caller wouldn't be surprised by Serialize() modifying the object.
+  rtclog::Event* output_event = event_stream.mutable_stream(0);
+  output_event->Swap(event);
+
+  std::string output_string;
+  event_stream.AppendToString(&output_string);
+
+  // When the function returns, the original Event will be unchanged.
+  output_event->Swap(event);
+
+  return output_string;
+}
+
+}  // namespace webrtc