Added support for logging the SSRC corresponding to AudioPlayout events.

webrtc/video/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 32 matching lines @@
   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 LogDebugEvent(DebugEvent event_type) override {}
+  void LogAudioPlayout(uint32_t ssrc) override {}
 };
 
 #else  // ENABLE_RTC_EVENT_LOG is defined
 
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   RtcEventLogImpl();
 
   void StartLogging(const std::string& file_name, int duration_ms) 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 LogDebugEvent(DebugEvent event_type) override;
+  void LogAudioPlayout(uint32_t ssrc) override;
 
  private:
   // 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_);
   // Writes the event to the file. Note that this will destroy the state of the
   // input argument.
   void StoreToFile(rtclog::Event* event) EXCLUSIVE_LOCKS_REQUIRED(crit_);
@@ skipping 18 matching lines @@
 
 namespace {
 // The functions in this namespace convert enums from the runtime format
 // that the rest of the WebRtc project can use, to the corresponding
 // serialized enum which is defined by the protobuf.
 
 // Do not add default return values to the conversion functions in this
 // unnamed namespace. The intention is to make the compiler warn if anyone
 // adds unhandled new events/modes/etc.
 
-rtclog::DebugEvent_EventType ConvertDebugEvent(
-    RtcEventLog::DebugEvent event_type) {
-  switch (event_type) {
-    case RtcEventLog::DebugEvent::kLogStart:
-      return rtclog::DebugEvent::LOG_START;
-    case RtcEventLog::DebugEvent::kLogEnd:
-      return rtclog::DebugEvent::LOG_END;
-    case RtcEventLog::DebugEvent::kAudioPlayout:
-      return rtclog::DebugEvent::AUDIO_PLAYOUT;
-  }
-  RTC_NOTREACHED();
-  return rtclog::DebugEvent::UNKNOWN_EVENT;
-}
-
 rtclog::VideoReceiveConfig_RtcpMode ConvertRtcpMode(
     newapi::RtcpMode rtcp_mode) {
   switch (rtcp_mode) {
     case newapi::kRtcpCompound:
       return rtclog::VideoReceiveConfig::RTCP_COMPOUND;
     case newapi::kRtcpReducedSize:
       return rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE;
   }
   RTC_NOTREACHED();
   return rtclog::VideoReceiveConfig::RTCP_COMPOUND;
@@ skipping 43 matching lines @@
     if (event.timestamp_us() >= start_time_us_ - recent_log_duration_us) {
       StoreToFile(&event);
     }
   }
   recent_log_events_.clear();
   // Write a LOG_START event to the file.
   rtclog::Event start_event;
   start_event.set_timestamp_us(start_time_us_);
   start_event.set_type(rtclog::Event::DEBUG_EVENT);
   auto debug_event = start_event.mutable_debug_event();
-  debug_event->set_type(ConvertDebugEvent(DebugEvent::kLogStart));
+  debug_event->set_type(rtclog::DebugEvent_EventType_LOG_START);
   StoreToFile(&start_event);
 }
 
 void RtcEventLogImpl::StopLogging() {
   rtc::CritScope lock(&crit_);
   StopLoggingLocked();
 }
 
 void RtcEventLogImpl::LogVideoReceiveStreamConfig(
     const VideoReceiveStream::Config& config) {
@@ skipping 121 matching lines @@
   rtclog::Event rtcp_event;
   const int64_t timestamp = clock_->TimeInMicroseconds();
   rtcp_event.set_timestamp_us(timestamp);
   rtcp_event.set_type(rtclog::Event::RTCP_EVENT);
   rtcp_event.mutable_rtcp_packet()->set_incoming(incoming);
   rtcp_event.mutable_rtcp_packet()->set_type(ConvertMediaType(media_type));
   rtcp_event.mutable_rtcp_packet()->set_packet_data(packet, length);
   HandleEvent(&rtcp_event);
 }
 
-void RtcEventLogImpl::LogDebugEvent(DebugEvent event_type) {
+void RtcEventLogImpl::LogAudioPlayout(uint32_t ssrc) {
   rtc::CritScope lock(&crit_);
   rtclog::Event event;
   const int64_t timestamp = clock_->TimeInMicroseconds();
   event.set_timestamp_us(timestamp);
   event.set_type(rtclog::Event::DEBUG_EVENT);
   auto debug_event = event.mutable_debug_event();
-  debug_event->set_type(ConvertDebugEvent(event_type));
+  debug_event->set_type(rtclog::DebugEvent_EventType_AUDIO_PLAYOUT);
+  debug_event->set_local_ssrc(ssrc);
   HandleEvent(&event);
 }
 
 void RtcEventLogImpl::StopLoggingLocked() {
   if (currently_logging_) {
     currently_logging_ = false;
     // Create a LogEnd debug event
     rtclog::Event event;
     int64_t timestamp = clock_->TimeInMicroseconds();
     event.set_timestamp_us(timestamp);
     event.set_type(rtclog::Event::DEBUG_EVENT);
     auto debug_event = event.mutable_debug_event();
-    debug_event->set_type(ConvertDebugEvent(DebugEvent::kLogEnd));
+    debug_event->set_type(rtclog::DebugEvent_EventType_LOG_END);
     // Store the event and close the file
     RTC_DCHECK(file_->Open());
     StoreToFile(&event);
     file_->CloseFile();
   }
   RTC_DCHECK(!file_->Open());
   stream_.Clear();
 }
 
 void RtcEventLogImpl::HandleEvent(rtclog::Event* event) {
@@ skipping 45 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