Add rtpdump and rtc log functionality to screenshare_loopback and video_loopback

webrtc/video/video_loopback.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 115 matching lines @@
   return static_cast<int>(FLAG_queue_size);
 }
 
 DEFINE_int(avg_propagation_delay_ms,
            0,
            "Average link propagation delay in ms.");
 int AvgPropagationDelayMs() {
   return static_cast<int>(FLAG_avg_propagation_delay_ms);
 }
 
+DEFINE_string(rtc_event_log_name, "", "Filename for rtc event log.");
+std::string RtcEventLogName() {
+  return static_cast<std::string>(FLAG_rtc_event_log_name);
+}
+
+DEFINE_string(rtp_dump_name, "", "Filename for dumped received RTP stream.");
+std::string RtpDumpName() {
+  return static_cast<std::string>(FLAG_rtp_dump_name);
+}
+
 DEFINE_int(std_propagation_delay_ms,
            0,
            "Link propagation delay standard deviation in ms.");
 int StdPropagationDelayMs() {
   return static_cast<int>(FLAG_std_propagation_delay_ms);
 }
 
 DEFINE_int(num_streams, 0, "Number of streams to show or analyze.");
 int NumStreams() {
   return static_cast<int>(FLAG_num_streams);
@@ skipping 103 matching lines @@
   pipe_config.queue_delay_ms = flags::AvgPropagationDelayMs();
   pipe_config.delay_standard_deviation_ms = flags::StdPropagationDelayMs();
   pipe_config.allow_reordering = flags::FLAG_allow_reordering;
 
   Call::Config::BitrateConfig call_bitrate_config;
   call_bitrate_config.min_bitrate_bps = flags::MinBitrateKbps() * 1000;
   call_bitrate_config.start_bitrate_bps = flags::StartBitrateKbps() * 1000;
   call_bitrate_config.max_bitrate_bps = flags::MaxBitrateKbps() * 1000;
 
   VideoQualityTest::Params params;
-  params.call = {flags::FLAG_send_side_bwe, call_bitrate_config};
+  params.call = {flags::FLAG_send_side_bwe, call_bitrate_config, 0};
   params.video = {flags::FLAG_video,
                   flags::Width(),
                   flags::Height(),
                   flags::Fps(),
                   flags::MinBitrateKbps() * 1000,
                   flags::TargetBitrateKbps() * 1000,
                   flags::MaxBitrateKbps() * 1000,
                   flags::FLAG_suspend_below_min_bitrate,
                   flags::Codec(),
                   flags::NumTemporalLayers(),
                   flags::SelectedTL(),
                   0,  // No min transmit bitrate.
                   flags::FLAG_use_ulpfec,
                   flags::FLAG_use_flexfec,
-                  flags::EncodedFramePath(),
                   flags::Clip(),
                   flags::GetCaptureDevice()};
   params.audio = {flags::FLAG_audio, flags::FLAG_audio_video_sync,
                   flags::FLAG_audio_dtx};
+  params.logging = {flags::FLAG_logs, flags::FLAG_rtc_event_log_name,
+                    flags::FLAG_rtp_dump_name, flags::FLAG_encoded_frame_path};
   params.screenshare.enabled = false;
   params.analyzer = {"video", 0.0, 0.0, flags::DurationSecs(),
       flags::OutputFilename(), flags::GraphTitle()};
   params.pipe = pipe_config;
-  params.logs = flags::FLAG_logs;
 
   if (flags::NumStreams() > 1 && flags::Stream0().empty() &&
       flags::Stream1().empty()) {
     params.ss.infer_streams = true;
   }
 
   std::vector<std::string> stream_descriptors;
   stream_descriptors.push_back(flags::Stream0());
   stream_descriptors.push_back(flags::Stream1());
   std::vector<std::string> SL_descriptors;
@@ skipping 21 matching lines @@
   }
 
   // InitFieldTrialsFromString needs a reference to an std::string instance,
   // with a scope that outlives the test.
   std::string field_trials = webrtc::flags::FLAG_force_fieldtrials;
   webrtc::test::InitFieldTrialsFromString(field_trials);
 
   webrtc::test::RunTest(webrtc::Loopback);
   return 0;
 }