Move rtp dump writer from quality test to test transport

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 33 matching lines @@
 #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/testsupport/frame_writer.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"

[ilnik, 2017/08/23 08:24:25]

This include should go after line 45.

[sprang_webrtc, 2017/08/23 10:32:05]

Done.

 
 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;
@@ skipping 81 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,
-                std::string rtp_dump_name)
+                Clock* clock)
       : 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),
-        clock_(clock),
-        start_ms_(clock->TimeInMilliseconds()) {
+        done_(true, false) {
     // 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 33 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 814 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 664 matching lines @@
     RTC_DCHECK(event_log_started);
   }
 
   Call::Config call_config(event_log_.get());
   call_config.bitrate_config = params.call.call_bitrate_config;
 
   task_queue_.SendTask([this, &call_config, &send_transport,
                         &recv_transport]() {
     CreateCalls(call_config, call_config);
 
+    std::unique_ptr<test::RtpFileWriter> rtp_file_writer;
+    if (!params_.logging.rtp_dump_name.empty()) {
+      LOG(LS_INFO) << "Writing rtp dump to " << params_.logging.rtp_dump_name;
+      rtp_file_writer.reset(test::RtpFileWriter::Create(
+          test::RtpFileWriter::kRtpDump, params_.logging.rtp_dump_name));
+    }
+
     send_transport = rtc::MakeUnique<test::LayerFilteringTransport>(
         &task_queue_, params_.pipe, sender_call_.get(), kPayloadTypeVP8,
         kPayloadTypeVP9, params_.video.selected_tl, params_.ss.selected_sl,
-        payload_type_map_);
+        payload_type_map_, std::move(rtp_file_writer));
 
     recv_transport = rtc::MakeUnique<test::DirectTransport>(
         &task_queue_, 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");
   analyzer = rtc::MakeUnique<VideoAnalyzer>(
       send_transport.get(), 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_.logging.rtp_dump_name);
+      params_.video.selected_tl, is_quick_test_enabled, clock_);
 
   task_queue_.SendTask([&]() {
     analyzer->SetCall(sender_call_.get());
     analyzer->SetReceiver(receiver_call_->Receiver());
     send_transport->SetReceiver(analyzer.get());
     recv_transport->SetReceiver(sender_call_->Receiver());
 
     SetupVideo(analyzer.get(), recv_transport.get());
     SetupThumbnails(analyzer.get(), recv_transport.get());
     video_receive_configs_[params_.ss.selected_stream].renderer =
@@ skipping 141 matching lines @@
       CreateVoiceEngine(&voe, audio_processing.get(), decoder_factory_);
       AudioState::Config audio_state_config;
       audio_state_config.voice_engine = voe.voice_engine;
       audio_state_config.audio_mixer = AudioMixerImpl::Create();
       audio_state_config.audio_processing = audio_processing;
       call_config.audio_state = AudioState::Create(audio_state_config);
     }
 
     CreateCalls(call_config, call_config);
 
+    std::unique_ptr<test::RtpFileWriter> rtp_file_writer;
+    if (!params_.logging.rtp_dump_name.empty()) {
+      LOG(LS_INFO) << "Writing rtp dump to " << params_.logging.rtp_dump_name;
+      rtp_file_writer.reset(test::RtpFileWriter::Create(
+          test::RtpFileWriter::kRtpDump, params_.logging.rtp_dump_name));
+    }
+
     // TODO(minyue): consider if this is a good transport even for audio only
     // calls.
     send_transport = rtc::MakeUnique<test::LayerFilteringTransport>(
         &task_queue_, params.pipe, sender_call_.get(), kPayloadTypeVP8,
         kPayloadTypeVP9, params.video.selected_tl, params_.ss.selected_sl,
-        payload_type_map_);
+        payload_type_map_, std::move(rtp_file_writer));
 
     recv_transport = rtc::MakeUnique<test::DirectTransport>(
         &task_queue_, params_.pipe, receiver_call_.get(), payload_type_map_);
 
     // TODO(ivica): Use two calls to be able to merge with RunWithAnalyzer or at
     // least share as much code as possible. That way this test would also match
     // the full stack tests better.
     send_transport->SetReceiver(receiver_call_->Receiver());
     recv_transport->SetReceiver(sender_call_->Receiver());
 
@@ skipping 143 matching lines @@
   if (!params_.logging.encoded_frame_base_path.empty()) {
     std::ostringstream str;
     str << receive_logs_++;
     std::string path =
         params_.logging.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
     stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path),
                                         100000000);
   }
 }
 }  // namespace webrtc