Expose Ivf logging through the native API

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 <stdio.h>
 
 #include <algorithm>
 #include <deque>
 #include <map>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/optional.h"
+#include "webrtc/base/platform_file.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/call.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/system_wrappers/include/cpu_info.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"
@@ skipping 703 matching lines @@
   const double avg_ssim_threshold_;
 
   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_;
 };
 
-VideoQualityTest::VideoQualityTest() : clock_(Clock::GetRealTimeClock()) {}
+VideoQualityTest::VideoQualityTest()
+    : clock_(Clock::GetRealTimeClock()), receive_logs_(0), send_logs_(0) {}
 
 void VideoQualityTest::TestBody() {}
 
 std::string VideoQualityTest::GenerateGraphTitle() const {
   std::stringstream ss;
   ss << params_.common.codec;
   ss << " (" << params_.common.target_bitrate_bps / 1000 << "kbps";
   ss << ", " << params_.common.fps << " FPS";
   if (params_.screenshare.scroll_duration)
     ss << ", " << params_.screenshare.scroll_duration << "s scroll";
@@ skipping 366 matching lines @@
 
   if (params_.screenshare.enabled)
     SetupScreenshare();
 
   CreateVideoStreams();
   analyzer.input_ = video_send_stream_->Input();
   analyzer.send_stream_ = video_send_stream_;
 
   CreateCapturer(&analyzer);
 
+  StartEncodedFrameLogs(video_send_stream_);
+  StartEncodedFrameLogs(video_receive_streams_[0]);
   video_send_stream_->Start();
   for (VideoReceiveStream* receive_stream : video_receive_streams_)
     receive_stream->Start();
   capturer_->Start();
 
   analyzer.Wait();
 
   send_transport.StopSending();
   recv_transport.StopSending();
 
@@ skipping 102 matching lines @@
     audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
     audio_config.rtcp_send_transport = &transport;
     audio_config.voe_channel_id = voe.receive_channel_id;
     audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
     audio_config.rtp.transport_cc = params_.common.send_side_bwe;
     audio_config.rtp.extensions = audio_send_config_.rtp.extensions;
     audio_config.decoder_factory = decoder_factory_;
     if (params_.audio_video_sync)
       audio_config.sync_group = kSyncGroup;
 
-    audio_receive_stream =call->CreateAudioReceiveStream(audio_config);
+    audio_receive_stream = call->CreateAudioReceiveStream(audio_config);
 
     const CodecInst kOpusInst = {120, "OPUS", 48000, 960, 2, 64000};
     EXPECT_EQ(0, voe.codec->SetSendCodec(voe.send_channel_id, kOpusInst));
   }
 
+  StartEncodedFrameLogs(video_receive_stream);
+  StartEncodedFrameLogs(video_send_stream_);
+
   // Start sending and receiving video.
   video_receive_stream->Start();
   video_send_stream_->Start();
   capturer_->Start();
 
   if (params_.audio) {
     // Start receiving audio.
     audio_receive_stream->Start();
     EXPECT_EQ(0, voe.base->StartPlayout(voe.receive_channel_id));
     EXPECT_EQ(0, voe.base->StartReceive(voe.receive_channel_id));
@@ skipping 27 matching lines @@
   if (params_.audio) {
      call->DestroyAudioSendStream(audio_send_stream_);
      call->DestroyAudioReceiveStream(audio_receive_stream);
   }
 
   transport.StopSending();
   if (params_.audio)
     DestroyVoiceEngine(&voe);
 }
 
+void VideoQualityTest::StartEncodedFrameLogs(VideoSendStream* stream) {
+  if (!params_.common.encoded_frame_base_path.empty()) {
+    std::ostringstream str;
+    str << send_logs_++;
+    std::string prefix =
+        params_.common.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);
+  }
+}
+void VideoQualityTest::StartEncodedFrameLogs(VideoReceiveStream* stream) {
+  if (!params_.common.encoded_frame_base_path.empty()) {
+    std::ostringstream str;
+    str << receive_logs_++;
+    std::string path =
+        params_.common.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
+    stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path),
+                                        10000000);
+  }
+}
+
 }  // namespace webrtc