Added support for logging the SSRC corresponding to AudioPlayout events.

webrtc/video/rtc_event_log_unittest.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 247 matching lines @@
   EXPECT_EQ(incoming, rtcp_packet.incoming());
   ASSERT_TRUE(rtcp_packet.has_type());
   EXPECT_EQ(media_type, GetRuntimeMediaType(rtcp_packet.type()));
   ASSERT_TRUE(rtcp_packet.has_packet_data());
   ASSERT_EQ(total_size, rtcp_packet.packet_data().size());
   for (size_t i = 0; i < total_size; i++) {
     EXPECT_EQ(packet[i], static_cast<uint8_t>(rtcp_packet.packet_data()[i]));
   }
 }
 
-void VerifyPlayoutEvent(const rtclog::Event& event) {
+void VerifyPlayoutEvent(const rtclog::Event& event, uint32_t ssrc) {
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::DEBUG_EVENT, event.type());
   const rtclog::DebugEvent& debug_event = event.debug_event();
   ASSERT_TRUE(debug_event.has_type());
   EXPECT_EQ(rtclog::DebugEvent::AUDIO_PLAYOUT, debug_event.type());
+  ASSERT_TRUE(debug_event.has_local_ssrc());
+  EXPECT_EQ(ssrc, debug_event.local_ssrc());
 }
 
 void VerifyLogStartEvent(const rtclog::Event& event) {
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::DEBUG_EVENT, event.type());
   const rtclog::DebugEvent& debug_event = event.debug_event();
   ASSERT_TRUE(debug_event.has_type());
   EXPECT_EQ(rtclog::DebugEvent::LOG_START, debug_event.type());
 }
 
@@ skipping 116 matching lines @@
                            size_t rtcp_count,
                            size_t debug_count,
                            uint32_t extensions_bitvector,
                            uint32_t csrcs_count,
                            unsigned random_seed) {
   ASSERT_LE(rtcp_count, rtp_count);
   ASSERT_LE(debug_count, rtp_count);
   std::vector<rtc::Buffer> rtp_packets;
   std::vector<rtc::Buffer> rtcp_packets;
   std::vector<size_t> rtp_header_sizes;
+  std::vector<uint32_t> playout_ssrcs;
 
   VideoReceiveStream::Config receiver_config(nullptr);
   VideoSendStream::Config sender_config(nullptr);
 
   srand(random_seed);
 
   // Create rtp_count RTP packets containing random data.
   for (size_t i = 0; i < rtp_count; i++) {
     size_t packet_size = 1000 + rand() % 64;
     rtp_packets.push_back(rtc::Buffer(packet_size));
     size_t header_size = GenerateRtpPacket(extensions_bitvector, csrcs_count,
                                            rtp_packets[i].data(), packet_size);
     rtp_header_sizes.push_back(header_size);
   }
   // Create rtcp_count RTCP packets containing random data.
   for (size_t i = 0; i < rtcp_count; i++) {
     size_t packet_size = 1000 + rand() % 64;
     rtcp_packets.push_back(rtc::Buffer(packet_size));
     GenerateRtcpPacket(rtcp_packets[i].data(), packet_size);
   }
+  // Create debug_count random SSRCs to use when logging AudioPlayout events.
+  for (size_t i = 0; i < debug_count; i++) {
+    playout_ssrcs.push_back(static_cast<uint32_t>(rand()));
+  }
   // Create configurations for the video streams.
   GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config);
   GenerateVideoSendConfig(extensions_bitvector, &sender_config);
   const int config_count = 2;
 
   // Find the name of the current test, in order to use it as a temporary
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
@@ skipping 12 matching lines @@
           rtp_packets[i - 1].data(), rtp_packets[i - 1].size());
       if (i * rtcp_count >= rtcp_index * rtp_count) {
         log_dumper->LogRtcpPacket(
             rtcp_index % 2 == 0,  // Every second packet is incoming
             rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
             rtcp_packets[rtcp_index - 1].data(),
             rtcp_packets[rtcp_index - 1].size());
         rtcp_index++;
       }
       if (i * debug_count >= debug_index * rtp_count) {
-        log_dumper->LogDebugEvent(RtcEventLog::DebugEvent::kAudioPlayout);
+        log_dumper->LogAudioPlayout(playout_ssrcs[debug_index - 1]);
         debug_index++;
       }
       if (i == rtp_count / 2) {
         log_dumper->StartLogging(temp_filename, 10000000);
       }
     }
   }
 
   // Read the generated file from disk.
   rtclog::EventStream parsed_stream;
@@ skipping 17 matching lines @@
     if (i * rtcp_count >= rtcp_index * rtp_count) {
       VerifyRtcpEvent(parsed_stream.stream(event_index),
                       rtcp_index % 2 == 0,  // Every second packet is incoming.
                       rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
                       rtcp_packets[rtcp_index - 1].data(),
                       rtcp_packets[rtcp_index - 1].size());
       event_index++;
       rtcp_index++;
     }
     if (i * debug_count >= debug_index * rtp_count) {
-      VerifyPlayoutEvent(parsed_stream.stream(event_index));
+      VerifyPlayoutEvent(parsed_stream.stream(event_index),
+                         playout_ssrcs[debug_index - 1]);
       event_index++;
       debug_index++;
     }
     if (i == rtp_count / 2) {
       VerifyLogStartEvent(parsed_stream.stream(event_index));
       event_index++;
     }
   }
 
   // Clean up temporary file - can be pretty slow.
@@ skipping 27 matching lines @@
                             extensions,       // Bit vector choosing extensions
                             csrcs_count,      // Number of contributing sources
                             rand());
     }
   }
 }
 
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG