Added protobuf message for loss-based BWE events, and wired it up to the send side bandwidth estima…

webrtc/call/rtc_event_log.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
@@ skipping 34 matching lines @@
       const VideoSendStream::Config& config) override {}
   void LogRtpHeader(bool incoming,
                     MediaType media_type,
                     const uint8_t* header,
                     size_t packet_length) override {}
   void LogRtcpPacket(bool incoming,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override {}
   void LogAudioPlayout(uint32_t ssrc) override {}
+  void LogBwePacketLossEvent(int32_t bitrate,
+                             uint8_t fraction_loss,
+                             int32_t total_packets) override {}
 };
 
 #else  // ENABLE_RTC_EVENT_LOG is defined
 
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   void StartLogging(const std::string& file_name, int duration_ms) override;
   bool StartLogging(rtc::PlatformFile log_file) override;
   void StopLogging() override;
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override;
   void LogVideoSendStreamConfig(const VideoSendStream::Config& config) override;
   void LogRtpHeader(bool incoming,
                     MediaType media_type,
                     const uint8_t* header,
                     size_t packet_length) override;
   void LogRtcpPacket(bool incoming,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override;
   void LogAudioPlayout(uint32_t ssrc) override;
+  void LogBwePacketLossEvent(int32_t bitrate,
+                             uint8_t fraction_loss,
+                             int32_t total_packets) override;
 
  private:
   // Starts logging. This function assumes the file_ has been opened succesfully
   // and that the start_time_us_ and _duration_us_ have been set.
   void StartLoggingLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_);
   // Stops logging and clears the stored data and buffers.
   void StopLoggingLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_);
   // Adds a new event to the logfile if logging is active, or adds it to the
   // list of recent log events otherwise.
   void HandleEvent(rtclog::Event* event) EXCLUSIVE_LOCKS_REQUIRED(crit_);
@@ skipping 262 matching lines @@
   rtc::CritScope lock(&crit_);
   rtclog::Event event;
   const int64_t timestamp = clock_->TimeInMicroseconds();
   event.set_timestamp_us(timestamp);
   event.set_type(rtclog::Event::AUDIO_PLAYOUT_EVENT);
   auto playout_event = event.mutable_audio_playout_event();
   playout_event->set_local_ssrc(ssrc);
   HandleEvent(&event);
 }
 
+void RtcEventLogImpl::LogBwePacketLossEvent(int32_t bitrate,
+                                            uint8_t fraction_loss,
+                                            int32_t total_packets) {
+  rtc::CritScope lock(&crit_);
+  rtclog::Event event;
+  const int64_t timestamp = clock_->TimeInMicroseconds();
+  event.set_timestamp_us(timestamp);

[stefan-webrtc, 2015/10/19 08:43:21]

Pass in clock_->TimeInMicroseconds() directly.

[terelius, 2015/10/26 17:40:18]

I agree with this idea for Rtcp and Rtp packets since they are logged far from
the socket, but wouldn't it just be an inconvenience for the caller in the case
of BWE events? I mean, the function which updates the birate estimate calls this
function directly and this function immediately reads the clock.

[stefan-webrtc, 2015/10/28 16:03:18]

Oh, I meant that instead of doing event.set_timestamp_us(timestamp) you could
do:

event.set_timestamp_us(clock_->TimeInMicroseconds());

and save one line. I do see that a temporary variable is used in other places
here though, so if you prefer that way, go for it.

[terelius, 2015/10/30 10:51:40]

Done. Sorry, I misunderstood what you wanted.

+  event.set_type(rtclog::Event::BWE_PACKET_LOSS_EVENT);
+  auto bwe_event = event.mutable_bwe_packet_loss_event();
+  bwe_event->set_bitrate(bitrate);
+  bwe_event->set_fraction_loss(fraction_loss);
+  bwe_event->set_total_packets(total_packets);
+  HandleEvent(&event);
+}
+
 void RtcEventLogImpl::StopLoggingLocked() {
   if (currently_logging_) {
     currently_logging_ = false;
     // Create a LogEnd event
     rtclog::Event event;
     int64_t timestamp = clock_->TimeInMicroseconds();
     event.set_timestamp_us(timestamp);
     event.set_type(rtclog::Event::LOG_END);
     // Store the event and close the file
     RTC_DCHECK(file_->Open());
@@ skipping 57 matching lines @@
   return result->ParseFromString(dump_buffer);
 }
 
 #endif  // ENABLE_RTC_EVENT_LOG
 
 // RtcEventLog member functions.
 rtc::scoped_ptr<RtcEventLog> RtcEventLog::Create() {
   return rtc::scoped_ptr<RtcEventLog>(new RtcEventLogImpl());
 }
 }  // namespace webrtc