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 int kPayloadTypeH264 = 122;
 constexpr int kPayloadTypeVP8 = 123;
 constexpr int kPayloadTypeVP9 = 124;
 
 constexpr size_t kMaxComparisons = 10;
 constexpr char kSyncGroup[] = "av_sync";
 constexpr int kOpusMinBitrateBps = 6000;
@@ skipping 83 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.length() > 0) {

[sprang_webrtc, 2017/07/12 13:27:05]

nit: if (!rtp_dump_name.empty()) ...

[ilnik, 2017/07/12 13:58:53]

Done.

+      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_) {
+      std::unique_ptr<test::RtpPacket> p(new test::RtpPacket());

[sprang_webrtc, 2017/07/12 13:27:05]

Just stack allocate it instead.

[ilnik, 2017/07/12 13:58:52]

Done.

+      memcpy(p->data, packet, length);
+      p->length = length;
+      p->original_length = length;
+      p->time_ms = clock_->TimeInMilliseconds() - start_ms_;
+      rtp_file_writer_->WritePacket(p.get());
+    }
+
     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* clock_;

[sprang_webrtc, 2017/07/12 13:27:05]

Clock* const clock_;

[ilnik, 2017/07/12 13:58:52]

Done.

+  const int64_t start_ms_;
 };
 
 class Vp8EncoderFactory : public VideoEncoderFactory {
  public:
   Vp8EncoderFactory() = default;
   ~Vp8EncoderFactory() override { RTC_CHECK(live_encoders_.empty()); }
 
   VideoEncoder* Create() override {
     VideoEncoder* encoder = VP8Encoder::Create();
     live_encoders_.insert(encoder);
@@ skipping 635 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
         << "!";
   }
 
+  bool event_log_started =  false;

[sprang_webrtc, 2017/07/12 13:27:05]

nit: git cl format?

[ilnik, 2017/07/12 13:58:52]

Done.

+  if (params.rtc_event_log_name.length() > 0) {

[sprang_webrtc, 2017/07/12 13:27:05]

.empty()

[ilnik, 2017/07/12 13:58:52]

Done.

+    event_log_ = RtcEventLog::Create(clock_);
+    event_log_started = event_log_->StartLogging(params.rtc_event_log_name, -1);

[sprang_webrtc, 2017/07/12 13:27:05]

Why would StartLogging() fail?
Can you just DCHECK instead?

Also, I don't think you need event_log_started, just call StopLogging() in any
case below. The member will by default be populated by a null-impl that does
nothing in that case.

[ilnik, 2017/07/12 13:58:52]

Done.

+  }
+
   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_.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);
@@ skipping 14 matching lines @@
   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();
 
+  if (event_log_started) {
+    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 198 matching lines @@
   if (!params_.video.encoded_frame_base_path.empty()) {
     std::ostringstream str;
     str << send_logs_++;
     std::string prefix =
         params_.video.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()) {
     std::ostringstream str;
     str << receive_logs_++;
     std::string path =
         params_.video.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
     stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path),
-                                        10000000);
+                                        100000000);
   }
 }
 }  // namespace webrtc