Add rtpdump and rtc log functionality to screenshare_loopback and video_loopback

webrtc/video/video_quality_test.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.
  */
 #include "webrtc/video/video_quality_test.h"
@@ skipping 31 matching lines @@
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/layer_filtering_transport.h"
 #include "webrtc/test/run_loop.h"
 #include "webrtc/test/statistics.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/vcm_capturer.h"
 #include "webrtc/test/video_renderer.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 
+#include "webrtc/test/rtp_file_writer.h"
+
 namespace {
 
 constexpr int kSendStatsPollingIntervalMs = 1000;
 
 constexpr size_t kMaxComparisons = 10;
 constexpr char kSyncGroup[] = "av_sync";
 constexpr int kOpusMinBitrateBps = 6000;
 constexpr int kOpusBitrateFbBps = 32000;
 constexpr int kFramesSentInQuickTest = 1;
 constexpr uint32_t kThumbnailSendSsrcStart = 0xE0000;
@@ skipping 80 matching lines @@
                 double avg_ssim_threshold,
                 int duration_frames,
                 FILE* graph_data_output_file,
                 const std::string& graph_title,
                 uint32_t ssrc_to_analyze,
                 uint32_t rtx_ssrc_to_analyze,
                 size_t selected_stream,
                 int selected_sl,
                 int selected_tl,
                 bool is_quick_test_enabled,
-                Clock* clock)
+                Clock* clock,
+                std::string rtp_dump_name)
       : transport_(transport),
         receiver_(nullptr),
         call_(nullptr),
         send_stream_(nullptr),
         receive_stream_(nullptr),
         captured_frame_forwarder_(this, clock),
         test_label_(test_label),
         graph_data_output_file_(graph_data_output_file),
         graph_title_(graph_title),
         ssrc_to_analyze_(ssrc_to_analyze),
@@ skipping 15 matching lines @@
         total_media_bytes_(0),
         first_sending_time_(0),
         last_sending_time_(0),
         cpu_time_(0),
         wallclock_time_(0),
         avg_psnr_threshold_(avg_psnr_threshold),
         avg_ssim_threshold_(avg_ssim_threshold),
         is_quick_test_enabled_(is_quick_test_enabled),
         stats_polling_thread_(&PollStatsThread, this, "StatsPoller"),
         comparison_available_event_(false, false),
-        done_(true, false) {
+        done_(true, false),
+        clock_(clock),
+        start_ms_(clock->TimeInMilliseconds()) {
     // Create thread pool for CPU-expensive PSNR/SSIM calculations.
 
     // Try to use about as many threads as cores, but leave kMinCoresLeft alone,
     // so that we don't accidentally starve "real" worker threads (codec etc).
     // Also, don't allocate more than kMaxComparisonThreads, even if there are
     // spare cores.
 
     uint32_t num_cores = CpuInfo::DetectNumberOfCores();
     RTC_DCHECK_GE(num_cores, 1);
     static const uint32_t kMinCoresLeft = 4;
     static const uint32_t kMaxComparisonThreads = 8;
 
     if (num_cores <= kMinCoresLeft) {
       num_cores = 1;
     } else {
       num_cores -= kMinCoresLeft;
       num_cores = std::min(num_cores, kMaxComparisonThreads);
     }
 
     for (uint32_t i = 0; i < num_cores; ++i) {
       rtc::PlatformThread* thread =
           new rtc::PlatformThread(&FrameComparisonThread, this, "Analyzer");
       thread->Start();
       comparison_thread_pool_.push_back(thread);
     }
+
+    if (!rtp_dump_name.empty()) {
+      fprintf(stdout, "Writing rtp dump to %s\n", rtp_dump_name.c_str());
+      rtp_file_writer_.reset(test::RtpFileWriter::Create(
+          test::RtpFileWriter::kRtpDump, rtp_dump_name));
+    }
   }
 
   ~VideoAnalyzer() {
     for (rtc::PlatformThread* thread : comparison_thread_pool_) {
       thread->Stop();
       delete thread;
     }
   }
 
   virtual void SetReceiver(PacketReceiver* receiver) { receiver_ = receiver; }
@@ skipping 32 matching lines @@
 
   DeliveryStatus DeliverPacket(MediaType media_type,
                                const uint8_t* packet,
                                size_t length,
                                const PacketTime& packet_time) override {
     // Ignore timestamps of RTCP packets. They're not synchronized with
     // RTP packet timestamps and so they would confuse wrap_handler_.
     if (RtpHeaderParser::IsRtcp(packet, length)) {
       return receiver_->DeliverPacket(media_type, packet, length, packet_time);
     }
+
+    if (rtp_file_writer_) {
+      test::RtpPacket p;
+      memcpy(p.data, packet, length);
+      p.length = length;
+      p.original_length = length;
+      p.time_ms = clock_->TimeInMilliseconds() - start_ms_;
+      rtp_file_writer_->WritePacket(&p);
+    }
+
     RtpUtility::RtpHeaderParser parser(packet, length);
     RTPHeader header;
     parser.Parse(&header);
     if (!IsFlexfec(header.payloadType) &&
         (header.ssrc == ssrc_to_analyze_ ||
          header.ssrc == rtx_ssrc_to_analyze_)) {
       // Ignore FlexFEC timestamps, to avoid collisions with media timestamps.
       // (FlexFEC and media are sent on different SSRCs, which have different
       // timestamps spaces.)
       // Also ignore packets from wrong SSRC, but include retransmits.
@@ skipping 773 matching lines @@
   const double avg_psnr_threshold_;
   const double avg_ssim_threshold_;
   bool is_quick_test_enabled_;
 
   rtc::CriticalSection comparison_lock_;
   std::vector<rtc::PlatformThread*> comparison_thread_pool_;
   rtc::PlatformThread stats_polling_thread_;
   rtc::Event comparison_available_event_;
   std::deque<FrameComparison> comparisons_ GUARDED_BY(comparison_lock_);
   rtc::Event done_;
+
+  std::unique_ptr<test::RtpFileWriter> rtp_file_writer_;
+  Clock* const clock_;
+  const int64_t start_ms_;
 };
 
 class Vp8EncoderFactory : public cricket::WebRtcVideoEncoderFactory {
  public:
   Vp8EncoderFactory() {
     supported_codecs_.push_back(cricket::VideoCodec("VP8"));
   }
   ~Vp8EncoderFactory() override { RTC_CHECK(live_encoders_.empty()); }
 
   const std::vector<cricket::VideoCodec>& supported_codecs() const override {
@@ skipping 26 matching lines @@
   RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP8) ==
              payload_type_map_.end());
   RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP9) ==
              payload_type_map_.end());
   payload_type_map_[kPayloadTypeH264] = webrtc::MediaType::VIDEO;
   payload_type_map_[kPayloadTypeVP8] = webrtc::MediaType::VIDEO;
   payload_type_map_[kPayloadTypeVP9] = webrtc::MediaType::VIDEO;
 }
 
 VideoQualityTest::Params::Params()
-    : call({false, Call::Config::BitrateConfig()}),
+    : call({false, Call::Config::BitrateConfig(), 0}),
       video({false, 640, 480, 30, 50, 800, 800, false, "VP8", 1, -1, 0, false,
-             false, "", ""}),
+             false, ""}),
       audio({false, false, false}),
       screenshare({false, 10, 0}),
       analyzer({"", 0.0, 0.0, 0, "", ""}),
       pipe(),
-      logs(false),
       ss({std::vector<VideoStream>(), 0, 0, -1, std::vector<SpatialLayer>()}),
-      num_thumbnails(0) {}
+      logging({false, "", "", ""}) {}
 
 VideoQualityTest::Params::~Params() = default;
 
 void VideoQualityTest::TestBody() {}
 
 std::string VideoQualityTest::GenerateGraphTitle() const {
   std::stringstream ss;
   ss << params_.video.codec;
   ss << " (" << params_.video.target_bitrate_bps / 1000 << "kbps";
   ss << ", " << params_.video.fps << " FPS";
@@ skipping 45 matching lines @@
   RTC_CHECK_GE(params_.ss.num_spatial_layers, 1);
   RTC_CHECK_LE(params_.ss.selected_sl, params_.ss.num_spatial_layers);
   RTC_CHECK(params_.ss.spatial_layers.empty() ||
             params_.ss.spatial_layers.size() ==
                 static_cast<size_t>(params_.ss.num_spatial_layers));
   if (params_.video.codec == "VP8") {
     RTC_CHECK_EQ(params_.ss.num_spatial_layers, 1);
   } else if (params_.video.codec == "VP9") {
     RTC_CHECK_EQ(params_.ss.streams.size(), 1);
   }
-  RTC_CHECK_GE(params_.num_thumbnails, 0);
-  if (params_.num_thumbnails > 0) {
+  RTC_CHECK_GE(params_.call.num_thumbnails, 0);
+  if (params_.call.num_thumbnails > 0) {
     RTC_CHECK_EQ(params_.ss.num_spatial_layers, 1);
     RTC_CHECK_EQ(params_.ss.streams.size(), 3);
     RTC_CHECK_EQ(params_.video.num_temporal_layers, 3);
     RTC_CHECK_EQ(params_.video.codec, "VP8");
   }
 }
 
 // Static.
 std::vector<int> VideoQualityTest::ParseCSV(const std::string& str) {
   // Parse comma separated nonnegative integers, where some elements may be
@@ skipping 132 matching lines @@
     SpatialLayer layer;
     layer.scaling_factor_num = v[0] == -1 ? 1 : v[0];
     layer.scaling_factor_den = v[1] == -1 ? 1 : v[1];
     layer.target_bitrate_bps = v[2];
     params->ss.spatial_layers.push_back(layer);
   }
 }
 
 void VideoQualityTest::SetupVideo(Transport* send_transport,
                                   Transport* recv_transport) {
-  if (params_.logs)
+  if (params_.logging.logs)
     trace_to_stderr_.reset(new test::TraceToStderr);
 
   size_t num_video_streams = params_.ss.streams.size();
   size_t num_flexfec_streams = params_.video.flexfec ? 1 : 0;
   CreateSendConfig(num_video_streams, 0, num_flexfec_streams, send_transport);
 
   int payload_type;
   if (params_.video.codec == "H264") {
     video_encoder_.reset(H264Encoder::Create(cricket::VideoCodec("H264")));
     payload_type = kPayloadTypeH264;
@@ skipping 145 matching lines @@
           video_send_config_.rtp.ulpfec.ulpfec_payload_type;
       video_receive_configs_[params_.ss.selected_stream]
           .rtp.ulpfec.red_rtx_payload_type =
           video_send_config_.rtp.ulpfec.red_rtx_payload_type;
     }
   }
 }
 
 void VideoQualityTest::SetupThumbnails(Transport* send_transport,
                                        Transport* recv_transport) {
-  for (int i = 0; i < params_.num_thumbnails; ++i) {
+  for (int i = 0; i < params_.call.num_thumbnails; ++i) {
     thumbnail_encoders_.emplace_back(VP8Encoder::Create());
 
     // Thumbnails will be send in the other way: from receiver_call to
     // sender_call.
     VideoSendStream::Config thumbnail_send_config(recv_transport);
     thumbnail_send_config.rtp.ssrcs.push_back(kThumbnailSendSsrcStart + i);
     thumbnail_send_config.encoder_settings.encoder =
         thumbnail_encoders_.back().get();
     thumbnail_send_config.encoder_settings.payload_name = params_.video.codec;
     thumbnail_send_config.encoder_settings.payload_type = kPayloadTypeVP8;
@@ skipping 49 matching lines @@
     thumbnail_receive_config.rtp.rtx_payload_types[kPayloadTypeVP8] =
         kSendRtxPayloadType;
     thumbnail_receive_config.rtp.transport_cc = params_.call.send_side_bwe;
     thumbnail_receive_config.rtp.remb = !params_.call.send_side_bwe;
 
     thumbnail_encoder_configs_.push_back(thumbnail_encoder_config.Copy());
     thumbnail_send_configs_.push_back(thumbnail_send_config.Copy());
     thumbnail_receive_configs_.push_back(thumbnail_receive_config.Copy());
   }
 
-  for (int i = 0; i < params_.num_thumbnails; ++i) {
+  for (int i = 0; i < params_.call.num_thumbnails; ++i) {
     thumbnail_send_streams_.push_back(receiver_call_->CreateVideoSendStream(
         thumbnail_send_configs_[i].Copy(),
         thumbnail_encoder_configs_[i].Copy()));
     thumbnail_receive_streams_.push_back(sender_call_->CreateVideoReceiveStream(
         thumbnail_receive_configs_[i].Copy()));
   }
 }
 
 void VideoQualityTest::DestroyThumbnailStreams() {
   for (VideoSendStream* thumbnail_send_stream : thumbnail_send_streams_)
@@ skipping 131 matching lines @@
 
   FILE* graph_data_output_file = nullptr;
   if (!params_.analyzer.graph_data_output_filename.empty()) {
     graph_data_output_file =
         fopen(params_.analyzer.graph_data_output_filename.c_str(), "w");
     RTC_CHECK(graph_data_output_file)
         << "Can't open the file " << params_.analyzer.graph_data_output_filename
         << "!";
   }
 
+  if (!params.logging.rtc_event_log_name.empty()) {
+    event_log_ = RtcEventLog::Create(clock_);
+    bool event_log_started =
+        event_log_->StartLogging(params.logging.rtc_event_log_name, -1);
+    RTC_DCHECK(event_log_started);
+  }
+
   Call::Config call_config(event_log_.get());
   call_config.bitrate_config = params.call.call_bitrate_config;
   CreateCalls(call_config, call_config);
 
   test::LayerFilteringTransport send_transport(
       params_.pipe, sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
       params_.video.selected_tl, params_.ss.selected_sl, payload_type_map_);
 
   test::DirectTransport recv_transport(params_.pipe, receiver_call_.get(),
                                        payload_type_map_);
 
   std::string graph_title = params_.analyzer.graph_title;
   if (graph_title.empty())
     graph_title = VideoQualityTest::GenerateGraphTitle();
 
   bool is_quick_test_enabled = field_trial::IsEnabled("WebRTC-QuickPerfTest");
   VideoAnalyzer analyzer(
       &send_transport, params_.analyzer.test_label,
       params_.analyzer.avg_psnr_threshold, params_.analyzer.avg_ssim_threshold,
       is_quick_test_enabled
           ? kFramesSentInQuickTest
           : params_.analyzer.test_durations_secs * params_.video.fps,
       graph_data_output_file, graph_title,
       kVideoSendSsrcs[params_.ss.selected_stream],
       kSendRtxSsrcs[params_.ss.selected_stream],
       static_cast<size_t>(params_.ss.selected_stream), params.ss.selected_sl,
-      params_.video.selected_tl, is_quick_test_enabled, clock_);
+      params_.video.selected_tl, is_quick_test_enabled, clock_,
+      params_.logging.rtp_dump_name);
   analyzer.SetCall(sender_call_.get());
   analyzer.SetReceiver(receiver_call_->Receiver());
   send_transport.SetReceiver(&analyzer);
   recv_transport.SetReceiver(sender_call_->Receiver());
 
   SetupVideo(&analyzer, &recv_transport);
   SetupThumbnails(&analyzer, &recv_transport);
   video_receive_configs_[params_.ss.selected_stream].renderer = &analyzer;
   video_send_config_.pre_encode_callback = analyzer.pre_encode_proxy();
   RTC_DCHECK(!video_send_config_.post_encode_callback);
   video_send_config_.post_encode_callback = analyzer.encode_timing_proxy();
 
   SetupScreenshareOrSVC();
 
   CreateFlexfecStreams();
   CreateVideoStreams();
   analyzer.SetSendStream(video_send_stream_);
   if (video_receive_streams_.size() == 1)
     analyzer.SetReceiveStream(video_receive_streams_[0]);
 
   video_send_stream_->SetSource(analyzer.OutputInterface(),
                                 degradation_preference_);
 
-  SetupThumbnailCapturers(params_.num_thumbnails);
+  SetupThumbnailCapturers(params_.call.num_thumbnails);
   for (size_t i = 0; i < thumbnail_send_streams_.size(); ++i) {
     thumbnail_send_streams_[i]->SetSource(thumbnail_capturers_[i].get(),
                                           degradation_preference_);
   }
 
   CreateCapturer();
 
   analyzer.SetSource(video_capturer_.get(), params_.ss.infer_streams);
 
   StartEncodedFrameLogs(video_send_stream_);
-  StartEncodedFrameLogs(video_receive_streams_[0]);
+  StartEncodedFrameLogs(video_receive_streams_[params_.ss.selected_stream]);
   video_send_stream_->Start();
   for (VideoSendStream* thumbnail_send_stream : thumbnail_send_streams_)
     thumbnail_send_stream->Start();
   for (VideoReceiveStream* receive_stream : video_receive_streams_)
     receive_stream->Start();
   for (FlexfecReceiveStream* receive_stream : flexfec_receive_streams_)
     receive_stream->Start();
   for (VideoReceiveStream* thumbnail_receive_stream :
        thumbnail_receive_streams_)
     thumbnail_receive_stream->Start();
@@ skipping 22 matching lines @@
     receive_stream->Stop();
   for (VideoReceiveStream* receive_stream : video_receive_streams_)
     receive_stream->Stop();
   for (VideoSendStream* thumbnail_send_stream : thumbnail_send_streams_)
     thumbnail_send_stream->Stop();
   video_send_stream_->Stop();
 
   DestroyStreams();
   DestroyThumbnailStreams();
 
+  event_log_->StopLogging();
   if (graph_data_output_file)
     fclose(graph_data_output_file);
 }
 
 void VideoQualityTest::SetupAudio(int send_channel_id,
                                   int receive_channel_id,
                                   Transport* transport,
                                   AudioReceiveStream** audio_receive_stream) {
   audio_send_config_ = AudioSendStream::Config(transport);
   audio_send_config_.voe_channel_id = send_channel_id;
@@ skipping 188 matching lines @@
   }
 
   send_transport.StopSending();
   recv_transport.StopSending();
 
   if (params_.audio.enabled)
     DestroyVoiceEngine(&voe);
 }
 
 void VideoQualityTest::StartEncodedFrameLogs(VideoSendStream* stream) {
-  if (!params_.video.encoded_frame_base_path.empty()) {
+  if (!params_.logging.encoded_frame_base_path.empty()) {
     std::ostringstream str;
     str << send_logs_++;
     std::string prefix =
-        params_.video.encoded_frame_base_path + "." + str.str() + ".send.";
+        params_.logging.encoded_frame_base_path + "." + str.str() + ".send.";
     stream->EnableEncodedFrameRecording(
         std::vector<rtc::PlatformFile>(
             {rtc::CreatePlatformFile(prefix + "1.ivf"),
              rtc::CreatePlatformFile(prefix + "2.ivf"),
              rtc::CreatePlatformFile(prefix + "3.ivf")}),
-        10000000);
+        100000000);
   }
 }
 
 void VideoQualityTest::StartEncodedFrameLogs(VideoReceiveStream* stream) {
-  if (!params_.video.encoded_frame_base_path.empty()) {
+  if (!params_.logging.encoded_frame_base_path.empty()) {
     std::ostringstream str;
     str << receive_logs_++;
     std::string path =
-        params_.video.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
+        params_.logging.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
     stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path),
-                                        10000000);
+                                        100000000);
   }
 }
 }  // namespace webrtc