Revert "Remove deprecated functions from RtcEventLog"
This reverts commit 5fd6e5ec1feed9e937efbe27ba9924cee3be2b81.
Reason for revert: breaks downstream project
please still keep default arguments for CreateEventLog
Original change's description:
> Remove deprecated functions from RtcEventLog
>
> The unified Log() interface replaces the many old LogX() functions. This helps hide dependencies between the modules which log different events.
>
> TBR=stefan@webrtc.org
>
> Bug: webrtc:8111
> Change-Id: I5ea9fd50ba6da87d5867513c81c5e3bdb0524a32
> Reviewed-on: https://webrtc-review.googlesource.com/2689
> Commit-Queue: Elad Alon <eladalon@webrtc.org>
> Reviewed-by: Björn Terelius <terelius@webrtc.org>
> Reviewed-by: Elad Alon <eladalon@webrtc.org>
> Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#20159}
TBR=danilchap@webrtc.org,eladalon@webrtc.org,terelius@webrtc.org,stefan@webrtc.org
Change-Id: Iefc195f5804dabc0f76b87f889ff55481f4d285b
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:8111
Reviewed-on: https://webrtc-review.googlesource.com/6842
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20164}diff --git a/logging/rtc_event_log/mock/mock_rtc_event_log.h b/logging/rtc_event_log/mock/mock_rtc_event_log.h
index 6a4cdbd..1f44c0b 100644
--- a/logging/rtc_event_log/mock/mock_rtc_event_log.h
+++ b/logging/rtc_event_log/mock/mock_rtc_event_log.h
@@ -12,8 +12,13 @@
#define LOGGING_RTC_EVENT_LOG_MOCK_MOCK_RTC_EVENT_LOG_H_
#include <memory>
+#include <string>
#include "logging/rtc_event_log/rtc_event_log.h"
+#include "logging/rtc_event_log/rtc_stream_config.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
#include "test/gmock.h"
namespace webrtc {
@@ -25,12 +30,76 @@
}
MOCK_METHOD1(StartLoggingProxy, bool(RtcEventLogOutput*));
+ MOCK_METHOD2(StartLogging,
+ bool(const std::string& file_name, int64_t max_size_bytes));
+
+ MOCK_METHOD2(StartLogging,
+ bool(rtc::PlatformFile log_file, int64_t max_size_bytes));
+
MOCK_METHOD0(StopLogging, void());
virtual void Log(std::unique_ptr<RtcEvent> event) {
return LogProxy(event.get());
}
MOCK_METHOD1(LogProxy, void(RtcEvent*));
+
+ MOCK_METHOD1(LogVideoReceiveStreamConfig,
+ void(const rtclog::StreamConfig& config));
+
+ MOCK_METHOD1(LogVideoSendStreamConfig,
+ void(const rtclog::StreamConfig& config));
+
+ MOCK_METHOD1(LogAudioReceiveStreamConfig,
+ void(const rtclog::StreamConfig& config));
+
+ MOCK_METHOD1(LogAudioSendStreamConfig,
+ void(const rtclog::StreamConfig& config));
+ MOCK_METHOD3(LogRtpHeader,
+ void(PacketDirection direction,
+ const uint8_t* header,
+ size_t packet_length));
+
+ MOCK_METHOD4(LogRtpHeader,
+ void(PacketDirection direction,
+ const uint8_t* header,
+ size_t packet_length,
+ int probe_cluster_id));
+
+ MOCK_METHOD3(LogRtcpPacket,
+ void(PacketDirection direction,
+ const uint8_t* packet,
+ size_t length));
+
+ MOCK_METHOD1(LogIncomingRtpHeader, void(const RtpPacketReceived& packet));
+
+ MOCK_METHOD2(LogOutgoingRtpHeader,
+ void(const RtpPacketToSend& packet, int probe_cluster_id));
+
+ MOCK_METHOD1(LogIncomingRtcpPacket,
+ void(rtc::ArrayView<const uint8_t> packet));
+
+ MOCK_METHOD1(LogOutgoingRtcpPacket,
+ void(rtc::ArrayView<const uint8_t> packet));
+
+ MOCK_METHOD1(LogAudioPlayout, void(uint32_t ssrc));
+
+ MOCK_METHOD3(LogLossBasedBweUpdate,
+ void(int32_t bitrate_bps,
+ uint8_t fraction_loss,
+ int32_t total_packets));
+
+ MOCK_METHOD2(LogDelayBasedBweUpdate,
+ void(int32_t bitrate_bps, BandwidthUsage detector_state));
+
+ MOCK_METHOD1(LogAudioNetworkAdaptation,
+ void(const AudioEncoderRuntimeConfig& config));
+
+ MOCK_METHOD4(LogProbeClusterCreated,
+ void(int id, int bitrate_bps, int min_probes, int min_bytes));
+
+ MOCK_METHOD2(LogProbeResultSuccess, void(int id, int bitrate_bps));
+ MOCK_METHOD2(LogProbeResultFailure,
+ void(int id, ProbeFailureReason failure_reason));
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/rtc_event_log.cc b/logging/rtc_event_log/rtc_event_log.cc
index 22dd287..83ba029 100644
--- a/logging/rtc_event_log/rtc_event_log.cc
+++ b/logging/rtc_event_log/rtc_event_log.cc
@@ -19,9 +19,44 @@
#include <vector>
#include "logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h"
+// TODO(eladalon): Remove events/* when the deprecated functions are removed.
+#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_logging_started.h"
#include "logging/rtc_event_log/events/rtc_event_logging_stopped.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/output/rtc_event_log_output.h"
#include "logging/rtc_event_log/output/rtc_event_log_output_file.h"
+#include "logging/rtc_event_log/rtc_stream_config.h"
+// TODO(eladalon): Remove these when deprecated functions are removed.
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
+#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
+#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "modules/rtp_rtcp/source/byte_io.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_packet_received.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
#include "rtc_base/checks.h"
#include "rtc_base/constructormagic.h"
#include "rtc_base/event.h"
@@ -31,6 +66,7 @@
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/thread_annotations.h"
+#include "typedefs.h" // NOLINT(build/include)
namespace webrtc {
@@ -81,6 +117,11 @@
explicit RtcEventLogImpl(std::unique_ptr<RtcEventLogEncoder> event_encoder);
~RtcEventLogImpl() override;
+ bool StartLogging(const std::string& file_name,
+ int64_t max_size_bytes) override;
+ bool StartLogging(rtc::PlatformFile platform_file,
+ int64_t max_size_bytes) override;
+
// TODO(eladalon): We should change these name to reflect that what we're
// actually starting/stopping is the output of the log, not the log itself.
bool StartLogging(std::unique_ptr<RtcEventLogOutput> output) override;
@@ -88,6 +129,47 @@
void Log(std::unique_ptr<RtcEvent> event) override;
+ void LogVideoReceiveStreamConfig(const rtclog::StreamConfig& config) override;
+ void LogVideoSendStreamConfig(const rtclog::StreamConfig& config) override;
+ void LogAudioReceiveStreamConfig(const rtclog::StreamConfig& config) override;
+ void LogAudioSendStreamConfig(const rtclog::StreamConfig& config) override;
+ // TODO(terelius): This can be removed as soon as the interface has been
+ // updated.
+ void LogRtpHeader(PacketDirection direction,
+ const uint8_t* header,
+ size_t packet_length) override;
+ // TODO(terelius): This can be made private, non-virtual as soon as the
+ // interface has been updated.
+ void LogRtpHeader(PacketDirection direction,
+ const uint8_t* header,
+ size_t packet_length,
+ int probe_cluster_id) override;
+ void LogIncomingRtpHeader(const RtpPacketReceived& packet) override;
+ void LogOutgoingRtpHeader(const RtpPacketToSend& packet,
+ int probe_cluster_id) override;
+ // TODO(terelius): This can be made private, non-virtual as soon as the
+ // interface has been updated.
+ void LogRtcpPacket(PacketDirection direction,
+ const uint8_t* packet,
+ size_t length) override;
+ void LogIncomingRtcpPacket(rtc::ArrayView<const uint8_t> packet) override;
+ void LogOutgoingRtcpPacket(rtc::ArrayView<const uint8_t> packet) override;
+ void LogAudioPlayout(uint32_t ssrc) override;
+ void LogLossBasedBweUpdate(int32_t bitrate_bps,
+ uint8_t fraction_loss,
+ int32_t total_packets) override;
+ void LogDelayBasedBweUpdate(int32_t bitrate_bps,
+ BandwidthUsage detector_state) override;
+ void LogAudioNetworkAdaptation(
+ const AudioEncoderRuntimeConfig& config) override;
+ void LogProbeClusterCreated(int id,
+ int bitrate_bps,
+ int min_probes,
+ int min_bytes) override;
+ void LogProbeResultSuccess(int id, int bitrate_bps) override;
+ void LogProbeResultFailure(int id,
+ ProbeFailureReason failure_reason) override;
+
private:
// Appends an event to the output protobuf string, returning true on success.
// Fails and returns false in case the limit on output size prevents the
@@ -150,6 +232,20 @@
RTC_DCHECK_GE(count, 0);
}
+bool RtcEventLogImpl::StartLogging(const std::string& file_name,
+ int64_t max_size_bytes) {
+ RTC_CHECK(max_size_bytes > 0 || max_size_bytes == kUnlimitedOutput);
+ return StartLogging(rtc::MakeUnique<RtcEventLogOutputFile>(
+ file_name, rtc::saturated_cast<size_t>(max_size_bytes)));
+}
+
+bool RtcEventLogImpl::StartLogging(rtc::PlatformFile platform_file,
+ int64_t max_size_bytes) {
+ RTC_CHECK(max_size_bytes > 0 || max_size_bytes == kUnlimitedOutput);
+ return StartLogging(rtc::MakeUnique<RtcEventLogOutputFile>(
+ platform_file, rtc::saturated_cast<size_t>(max_size_bytes)));
+}
+
bool RtcEventLogImpl::StartLogging(std::unique_ptr<RtcEventLogOutput> output) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
@@ -214,6 +310,124 @@
std::move(event), event_handler));
}
+void RtcEventLogImpl::LogVideoReceiveStreamConfig(
+ const rtclog::StreamConfig& config) {
+ Log(rtc::MakeUnique<RtcEventVideoReceiveStreamConfig>(
+ rtc::MakeUnique<rtclog::StreamConfig>(config)));
+}
+
+void RtcEventLogImpl::LogVideoSendStreamConfig(
+ const rtclog::StreamConfig& config) {
+ Log(rtc::MakeUnique<RtcEventVideoSendStreamConfig>(
+ rtc::MakeUnique<rtclog::StreamConfig>(config)));
+}
+
+void RtcEventLogImpl::LogAudioReceiveStreamConfig(
+ const rtclog::StreamConfig& config) {
+ Log(rtc::MakeUnique<RtcEventAudioReceiveStreamConfig>(
+ rtc::MakeUnique<rtclog::StreamConfig>(config)));
+}
+
+void RtcEventLogImpl::LogAudioSendStreamConfig(
+ const rtclog::StreamConfig& config) {
+ Log(rtc::MakeUnique<RtcEventAudioSendStreamConfig>(
+ rtc::MakeUnique<rtclog::StreamConfig>(config)));
+}
+
+void RtcEventLogImpl::LogIncomingRtpHeader(const RtpPacketReceived& packet) {
+ Log(rtc::MakeUnique<RtcEventRtpPacketIncoming>(packet));
+}
+
+void RtcEventLogImpl::LogOutgoingRtpHeader(const RtpPacketToSend& packet,
+ int probe_cluster_id) {
+ Log(rtc::MakeUnique<RtcEventRtpPacketOutgoing>(packet, probe_cluster_id));
+}
+
+void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
+ const uint8_t* header,
+ size_t packet_length) {
+ LogRtpHeader(direction, header, packet_length, PacedPacketInfo::kNotAProbe);
+}
+
+void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
+ const uint8_t* header,
+ size_t packet_length,
+ int probe_cluster_id) {
+ // TODO(eladalon): This is highly inefficient. We're only doing this for
+ // the deprecated interface. We should remove this soon.
+ if (direction == PacketDirection::kIncomingPacket) {
+ RtpPacketReceived packet;
+ packet.Parse(header, packet_length);
+ Log(rtc::MakeUnique<RtcEventRtpPacketIncoming>(packet));
+ } else {
+ RTC_CHECK_EQ(direction, PacketDirection::kOutgoingPacket);
+ RtpPacketToSend packet(nullptr);
+ packet.Parse(header, packet_length);
+ Log(rtc::MakeUnique<RtcEventRtpPacketOutgoing>(packet, probe_cluster_id));
+ }
+}
+
+void RtcEventLogImpl::LogIncomingRtcpPacket(
+ rtc::ArrayView<const uint8_t> packet) {
+ Log(rtc::MakeUnique<RtcEventRtcpPacketIncoming>(packet));
+}
+
+void RtcEventLogImpl::LogOutgoingRtcpPacket(
+ rtc::ArrayView<const uint8_t> packet) {
+ Log(rtc::MakeUnique<RtcEventRtcpPacketOutgoing>(packet));
+}
+
+void RtcEventLogImpl::LogRtcpPacket(PacketDirection direction,
+ const uint8_t* packet,
+ size_t length) {
+ if (direction == PacketDirection::kIncomingPacket) {
+ LogIncomingRtcpPacket(rtc::ArrayView<const uint8_t>(packet, length));
+ } else {
+ RTC_CHECK_EQ(direction, PacketDirection::kOutgoingPacket);
+ LogOutgoingRtcpPacket(rtc::ArrayView<const uint8_t>(packet, length));
+ }
+}
+
+void RtcEventLogImpl::LogAudioPlayout(uint32_t ssrc) {
+ Log(rtc::MakeUnique<RtcEventAudioPlayout>(ssrc));
+}
+
+void RtcEventLogImpl::LogLossBasedBweUpdate(int32_t bitrate_bps,
+ uint8_t fraction_loss,
+ int32_t total_packets) {
+ Log(rtc::MakeUnique<RtcEventBweUpdateLossBased>(bitrate_bps, fraction_loss,
+ total_packets));
+}
+
+void RtcEventLogImpl::LogDelayBasedBweUpdate(int32_t bitrate_bps,
+ BandwidthUsage detector_state) {
+ Log(rtc::MakeUnique<RtcEventBweUpdateDelayBased>(bitrate_bps,
+ detector_state));
+}
+
+void RtcEventLogImpl::LogAudioNetworkAdaptation(
+ const AudioEncoderRuntimeConfig& config) {
+ Log(rtc::MakeUnique<RtcEventAudioNetworkAdaptation>(
+ rtc::MakeUnique<AudioEncoderRuntimeConfig>(config)));
+}
+
+void RtcEventLogImpl::LogProbeClusterCreated(int id,
+ int bitrate_bps,
+ int min_probes,
+ int min_bytes) {
+ Log(rtc::MakeUnique<RtcEventProbeClusterCreated>(id, bitrate_bps, min_probes,
+ min_bytes));
+}
+
+void RtcEventLogImpl::LogProbeResultSuccess(int id, int bitrate_bps) {
+ Log(rtc::MakeUnique<RtcEventProbeResultSuccess>(id, bitrate_bps));
+}
+
+void RtcEventLogImpl::LogProbeResultFailure(int id,
+ ProbeFailureReason failure_reason) {
+ Log(rtc::MakeUnique<RtcEventProbeResultFailure>(id, failure_reason));
+}
+
bool RtcEventLogImpl::AppendEventToString(const RtcEvent& event,
std::string* output_string) {
RTC_DCHECK_RUN_ON(&task_queue_);
diff --git a/logging/rtc_event_log/rtc_event_log.h b/logging/rtc_event_log/rtc_event_log.h
index f798045..cb9d097 100644
--- a/logging/rtc_event_log/rtc_event_log.h
+++ b/logging/rtc_event_log/rtc_event_log.h
@@ -14,13 +14,33 @@
#include <memory>
#include <string>
-#include "logging/rtc_event_log/events/rtc_event.h"
+// TODO(eladalon): Remove this include once LogIncomingRtcpPacket(), etc., have
+// been removed (they are currently deprecated).
+#include "api/array_view.h"
+#include "common_types.h" // NOLINT(build/include)
#include "logging/rtc_event_log/output/rtc_event_log_output.h"
+// TODO(eladalon): This is here because of ProbeFailureReason; remove this
+// dependency along with the deprecated LogProbeResultFailure().
+#include "logging/rtc_event_log/events/rtc_event_probe_result_failure.h"
+// TODO(eladalon): Remove this #include once the deprecated versions of
+// StartLogging() have been removed.
+#include "rtc_base/platform_file.h"
namespace webrtc {
-class Clock;
+namespace rtclog {
+class EventStream; // Storage class automatically generated from protobuf.
+// TODO(eladalon): Get rid of this when deprecated methods are removed.
+struct StreamConfig;
+} // namespace rtclog
+class Clock;
+// TODO(eladalon): The following may be removed when the deprecated methods
+// are removed.
+struct AudioEncoderRuntimeConfig;
+class RtpPacketReceived;
+class RtpPacketToSend;
+enum class BandwidthUsage;
enum PacketDirection { kIncomingPacket = 0, kOutgoingPacket };
class RtcEventLog {
@@ -35,12 +55,16 @@
virtual ~RtcEventLog() {}
// Factory method to create an RtcEventLog object.
- static std::unique_ptr<RtcEventLog> Create(EncodingType encoding_type);
+ // TODO(eladalon): Get rid of the default value after internal projects fixed.
+ static std::unique_ptr<RtcEventLog> Create(
+ EncodingType encoding_type = EncodingType::Legacy);
// TODO(nisse): webrtc::Clock is deprecated. Delete this method and
// above forward declaration of Clock when
// webrtc/system_wrappers/include/clock.h is deleted.
- static std::unique_ptr<RtcEventLog> Create(const Clock* clock,
- EncodingType encoding_type) {
+ // TODO(eladalon): Get rid of the default value after internal projects fixed.
+ static std::unique_ptr<RtcEventLog> Create(
+ const Clock* clock,
+ EncodingType encoding_type = EncodingType::Legacy) {
return Create(encoding_type);
}
@@ -51,12 +75,115 @@
// and may close itself once it has reached the maximum size.
virtual bool StartLogging(std::unique_ptr<RtcEventLogOutput> output) = 0;
+ // Starts logging a maximum of max_size_bytes bytes to the specified file.
+ // If the file already exists it will be overwritten.
+ // If max_size_bytes <= 0, logging will be active until StopLogging is called.
+ // The function has no effect and returns false if we can't start a new log
+ // e.g. because we are already logging or the file cannot be opened.
+ RTC_DEPRECATED virtual bool StartLogging(const std::string& file_name,
+ int64_t max_size_bytes) = 0;
+
+ // Same as above. The RtcEventLog takes ownership of the file if the call
+ // is successful, i.e. if it returns true.
+ RTC_DEPRECATED virtual bool StartLogging(rtc::PlatformFile platform_file,
+ int64_t max_size_bytes) = 0;
+
+ // Deprecated. Pass an explicit file size limit.
+ RTC_DEPRECATED bool StartLogging(const std::string& file_name) {
+ return StartLogging(file_name, 10000000);
+ }
+
+ // Deprecated. Pass an explicit file size limit.
+ RTC_DEPRECATED bool StartLogging(rtc::PlatformFile platform_file) {
+ return StartLogging(platform_file, 10000000);
+ }
+
// Stops logging to file and waits until the file has been closed, after
// which it would be permissible to read and/or modify it.
virtual void StopLogging() = 0;
// Log an RTC event (the type of event is determined by the subclass).
virtual void Log(std::unique_ptr<RtcEvent> event) = 0;
+
+ // Logs configuration information for a video receive stream.
+ RTC_DEPRECATED virtual void LogVideoReceiveStreamConfig(
+ const rtclog::StreamConfig& config) = 0;
+
+ // Logs configuration information for a video send stream.
+ RTC_DEPRECATED virtual void LogVideoSendStreamConfig(
+ const rtclog::StreamConfig& config) = 0;
+
+ // Logs configuration information for an audio receive stream.
+ RTC_DEPRECATED virtual void LogAudioReceiveStreamConfig(
+ const rtclog::StreamConfig& config) = 0;
+
+ // Logs configuration information for an audio send stream.
+ RTC_DEPRECATED virtual void LogAudioSendStreamConfig(
+ const rtclog::StreamConfig& config) = 0;
+
+ RTC_DEPRECATED virtual void LogRtpHeader(PacketDirection direction,
+ const uint8_t* header,
+ size_t packet_length) {}
+
+ RTC_DEPRECATED virtual void LogRtpHeader(PacketDirection direction,
+ const uint8_t* header,
+ size_t packet_length,
+ int probe_cluster_id) {}
+
+ // Logs the header of an incoming RTP packet. |packet_length|
+ // is the total length of the packet, including both header and payload.
+ RTC_DEPRECATED virtual void LogIncomingRtpHeader(
+ const RtpPacketReceived& packet) = 0;
+
+ // Logs the header of an incoming RTP packet. |packet_length|
+ // is the total length of the packet, including both header and payload.
+ RTC_DEPRECATED virtual void LogOutgoingRtpHeader(
+ const RtpPacketToSend& packet,
+ int probe_cluster_id) = 0;
+
+ RTC_DEPRECATED virtual void LogRtcpPacket(PacketDirection direction,
+ const uint8_t* header,
+ size_t packet_length) {}
+
+ // Logs an incoming RTCP packet.
+ RTC_DEPRECATED virtual void LogIncomingRtcpPacket(
+ rtc::ArrayView<const uint8_t> packet) = 0;
+
+ // Logs an outgoing RTCP packet.
+ RTC_DEPRECATED virtual void LogOutgoingRtcpPacket(
+ rtc::ArrayView<const uint8_t> packet) = 0;
+
+ // Logs an audio playout event.
+ RTC_DEPRECATED virtual void LogAudioPlayout(uint32_t ssrc) = 0;
+
+ // Logs a bitrate update from the bandwidth estimator based on packet loss.
+ RTC_DEPRECATED virtual void LogLossBasedBweUpdate(int32_t bitrate_bps,
+ uint8_t fraction_loss,
+ int32_t total_packets) = 0;
+
+ // Logs a bitrate update from the bandwidth estimator based on delay changes.
+ RTC_DEPRECATED virtual void LogDelayBasedBweUpdate(
+ int32_t bitrate_bps,
+ BandwidthUsage detector_state) = 0;
+
+ // Logs audio encoder re-configuration driven by audio network adaptor.
+ RTC_DEPRECATED virtual void LogAudioNetworkAdaptation(
+ const AudioEncoderRuntimeConfig& config) = 0;
+
+ // Logs when a probe cluster is created.
+ RTC_DEPRECATED virtual void LogProbeClusterCreated(int id,
+ int bitrate_bps,
+ int min_probes,
+ int min_bytes) = 0;
+
+ // Logs the result of a successful probing attempt.
+ RTC_DEPRECATED virtual void LogProbeResultSuccess(int id,
+ int bitrate_bps) = 0;
+
+ // Logs the result of an unsuccessful probing attempt.
+ RTC_DEPRECATED virtual void LogProbeResultFailure(
+ int id,
+ ProbeFailureReason failure_reason) = 0;
};
// No-op implementation is used if flag is not set, or in tests.
@@ -65,8 +192,42 @@
bool StartLogging(std::unique_ptr<RtcEventLogOutput> output) override {
return false;
}
+ bool StartLogging(const std::string& file_name,
+ int64_t max_size_bytes) override {
+ return false;
+ }
+ bool StartLogging(rtc::PlatformFile platform_file,
+ int64_t max_size_bytes) override {
+ return false;
+ }
void StopLogging() override {}
void Log(std::unique_ptr<RtcEvent> event) override {}
+ void LogVideoReceiveStreamConfig(
+ const rtclog::StreamConfig& config) override {}
+ void LogVideoSendStreamConfig(const rtclog::StreamConfig& config) override {}
+ void LogAudioReceiveStreamConfig(
+ const rtclog::StreamConfig& config) override {}
+ void LogAudioSendStreamConfig(const rtclog::StreamConfig& config) override {}
+ void LogIncomingRtpHeader(const RtpPacketReceived& packet) override {}
+ void LogOutgoingRtpHeader(const RtpPacketToSend& packet,
+ int probe_cluster_id) override {}
+ void LogIncomingRtcpPacket(rtc::ArrayView<const uint8_t> packet) override {}
+ void LogOutgoingRtcpPacket(rtc::ArrayView<const uint8_t> packet) override {}
+ void LogAudioPlayout(uint32_t ssrc) override {}
+ void LogLossBasedBweUpdate(int32_t bitrate_bps,
+ uint8_t fraction_loss,
+ int32_t total_packets) override {}
+ void LogDelayBasedBweUpdate(int32_t bitrate_bps,
+ BandwidthUsage detector_state) override {}
+ void LogAudioNetworkAdaptation(
+ const AudioEncoderRuntimeConfig& config) override {}
+ void LogProbeClusterCreated(int id,
+ int bitrate_bps,
+ int min_probes,
+ int min_bytes) override{};
+ void LogProbeResultSuccess(int id, int bitrate_bps) override{};
+ void LogProbeResultFailure(int id,
+ ProbeFailureReason failure_reason) override{};
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/rtc_event_log_parser.h b/logging/rtc_event_log/rtc_event_log_parser.h
index 8192c30..4980959 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.h
+++ b/logging/rtc_event_log/rtc_event_log_parser.h
@@ -17,7 +17,6 @@
#include "call/video_receive_stream.h"
#include "call/video_send_stream.h"
-#include "logging/rtc_event_log/events/rtc_event_probe_result_failure.h"
#include "logging/rtc_event_log/rtc_event_log.h"
#include "logging/rtc_event_log/rtc_stream_config.h"
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
@@ -35,11 +34,8 @@
namespace webrtc {
-enum class BandwidthUsage;
enum class MediaType;
-struct AudioEncoderRuntimeConfig;
-
class ParsedRtcEventLog {
friend class RtcEventLogTestHelper;
diff --git a/voice_engine/channel.cc b/voice_engine/channel.cc
index 542ea2d..19873f1 100644
--- a/voice_engine/channel.cc
+++ b/voice_engine/channel.cc
@@ -12,7 +12,6 @@
#include <algorithm>
#include <map>
-#include <memory>
#include <string>
#include <utility>
#include <vector>
@@ -21,7 +20,24 @@
#include "audio/utility/audio_frame_operations.h"
#include "call/rtp_transport_controller_send_interface.h"
#include "logging/rtc_event_log/rtc_event_log.h"
+// TODO(eladalon): Remove events/* after removing the deprecated functions.
+#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_logging_started.h"
+#include "logging/rtc_event_log/events/rtc_event_logging_stopped.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 "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
#include "modules/audio_coding/codecs/audio_format_conversion.h"
#include "modules/audio_device/include/audio_device.h"
@@ -70,6 +86,18 @@
return false;
}
+ bool StartLogging(const std::string& file_name,
+ int64_t max_size_bytes) override {
+ RTC_NOTREACHED();
+ return false;
+ }
+
+ bool StartLogging(rtc::PlatformFile log_file,
+ int64_t max_size_bytes) override {
+ RTC_NOTREACHED();
+ return false;
+ }
+
void StopLogging() override { RTC_NOTREACHED(); }
void Log(std::unique_ptr<RtcEvent> event) override {
@@ -79,6 +107,126 @@
}
}
+ void LogVideoReceiveStreamConfig(
+ const webrtc::rtclog::StreamConfig&) override {
+ RTC_NOTREACHED();
+ }
+
+ void LogVideoSendStreamConfig(const webrtc::rtclog::StreamConfig&) override {
+ RTC_NOTREACHED();
+ }
+
+ void LogAudioReceiveStreamConfig(
+ const webrtc::rtclog::StreamConfig& config) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventAudioReceiveStreamConfig>(
+ rtc::MakeUnique<webrtc::rtclog::StreamConfig>(config)));
+ }
+ }
+
+ void LogAudioSendStreamConfig(
+ const webrtc::rtclog::StreamConfig& config) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventAudioSendStreamConfig>(
+ rtc::MakeUnique<webrtc::rtclog::StreamConfig>(config)));
+ }
+ }
+
+ void LogIncomingRtpHeader(const RtpPacketReceived& packet) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventRtpPacketIncoming>(packet));
+ }
+ }
+
+ void LogOutgoingRtpHeader(const RtpPacketToSend& packet,
+ int probe_cluster_id) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(
+ rtc::MakeUnique<RtcEventRtpPacketOutgoing>(packet, probe_cluster_id));
+ }
+ }
+
+ void LogIncomingRtcpPacket(rtc::ArrayView<const uint8_t> packet) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventRtcpPacketIncoming>(packet));
+ }
+ }
+
+ void LogOutgoingRtcpPacket(rtc::ArrayView<const uint8_t> packet) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventRtcpPacketOutgoing>(packet));
+ }
+ }
+
+ void LogAudioPlayout(uint32_t ssrc) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventAudioPlayout>(ssrc));
+ }
+ }
+
+ void LogLossBasedBweUpdate(int32_t bitrate_bps,
+ uint8_t fraction_loss,
+ int32_t total_packets) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventBweUpdateLossBased>(
+ bitrate_bps, fraction_loss, total_packets));
+ }
+ }
+
+ void LogDelayBasedBweUpdate(int32_t bitrate_bps,
+ BandwidthUsage detector_state) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventBweUpdateDelayBased>(
+ bitrate_bps, detector_state));
+ }
+ }
+
+ void LogAudioNetworkAdaptation(
+ const AudioEncoderRuntimeConfig& config) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventAudioNetworkAdaptation>(
+ rtc::MakeUnique<AudioEncoderRuntimeConfig>(config)));
+ }
+ }
+
+ void LogProbeClusterCreated(int id,
+ int bitrate_bps,
+ int min_probes,
+ int min_bytes) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(rtc::MakeUnique<RtcEventProbeClusterCreated>(
+ id, bitrate_bps, min_probes, min_bytes));
+ }
+ };
+
+ void LogProbeResultSuccess(int id, int bitrate_bps) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(
+ rtc::MakeUnique<RtcEventProbeResultSuccess>(id, bitrate_bps));
+ }
+ };
+
+ void LogProbeResultFailure(int id,
+ ProbeFailureReason failure_reason) override {
+ rtc::CritScope lock(&crit_);
+ if (event_log_) {
+ event_log_->Log(
+ rtc::MakeUnique<RtcEventProbeResultFailure>(id, failure_reason));
+ }
+ };
+
void SetEventLog(RtcEventLog* event_log) {
rtc::CritScope lock(&crit_);
event_log_ = event_log;
