Reland Replace interface VideoCapturerInput with VideoSinkInterface.

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"
+
 #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/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"
+#include "webrtc/test/vcm_capturer.h"
 #include "webrtc/test/video_renderer.h"
-#include "webrtc/video/video_quality_test.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 #include "webrtc/voice_engine/include/voe_codec.h"
 
 namespace {
 
 constexpr int kSendStatsPollingIntervalMs = 1000;
 constexpr int kPayloadTypeH264 = 122;
 constexpr int kPayloadTypeVP8 = 123;
 constexpr int kPayloadTypeVP9 = 124;
 constexpr size_t kMaxComparisons = 10;
@@ skipping 45 matching lines @@
   voe->voice_engine = nullptr;
 }
 
 }  // namespace
 
 namespace webrtc {
 
 class VideoAnalyzer : public PacketReceiver,
                       public Transport,
                       public rtc::VideoSinkInterface<VideoFrame>,
-                      public VideoCaptureInput,
                       public EncodedFrameObserver {
  public:
   VideoAnalyzer(test::LayerFilteringTransport* transport,
                 const std::string& test_label,
                 double avg_psnr_threshold,
                 double avg_ssim_threshold,
                 int duration_frames,
                 FILE* graph_data_output_file,
                 const std::string& graph_title,
                 uint32_t ssrc_to_analyze)
-      : input_(nullptr),
-        transport_(transport),
+      : transport_(transport),
         receiver_(nullptr),
         send_stream_(nullptr),
+        captured_frame_forwarder_(this),
         test_label_(test_label),
         graph_data_output_file_(graph_data_output_file),
         graph_title_(graph_title),
         ssrc_to_analyze_(ssrc_to_analyze),
         pre_encode_proxy_(this),
         encode_timing_proxy_(this),
         frames_to_process_(duration_frames),
         frames_recorded_(0),
         frames_processed_(0),
         dropped_frames_(0),
@@ skipping 35 matching lines @@
 
   ~VideoAnalyzer() {
     for (rtc::PlatformThread* thread : comparison_thread_pool_) {
       thread->Stop();
       delete thread;
     }
   }
 
   virtual void SetReceiver(PacketReceiver* receiver) { receiver_ = receiver; }
 
+  void SetSendStream(VideoSendStream* stream) {
+    rtc::CritScope lock(&crit_);
+    RTC_DCHECK(!send_stream_);
+    send_stream_ = stream;
+  }
+
+  rtc::VideoSinkInterface<VideoFrame>* InputInterface() {
+    return &captured_frame_forwarder_;
+  }
+  rtc::VideoSourceInterface<VideoFrame>* OutputInterface() {
+    return &captured_frame_forwarder_;
+  }
+
   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);
     }
 
     RtpUtility::RtpHeaderParser parser(packet, length);
     RTPHeader header;
     parser.Parse(&header);
     {
       rtc::CritScope lock(&crit_);
       int64_t timestamp =
           wrap_handler_.Unwrap(header.timestamp - rtp_timestamp_delta_);
       recv_times_[timestamp] =
           Clock::GetRealTimeClock()->CurrentNtpInMilliseconds();
     }
 
     return receiver_->DeliverPacket(media_type, packet, length, packet_time);
   }
 
   void MeasuredEncodeTiming(int64_t ntp_time_ms, int encode_time_ms) {
     rtc::CritScope crit(&comparison_lock_);
     samples_encode_time_ms_[ntp_time_ms] = encode_time_ms;
   }
 
-  void IncomingCapturedFrame(const VideoFrame& video_frame) override {
-    VideoFrame copy = video_frame;
-    copy.set_timestamp(copy.ntp_time_ms() * 90);
-    {
-      rtc::CritScope lock(&crit_);
-      frames_.push_back(copy);
-    }
-
-    input_->IncomingCapturedFrame(video_frame);
-  }
-
   void PreEncodeOnFrame(const VideoFrame& video_frame) {
     rtc::CritScope lock(&crit_);
     if (!first_send_timestamp_ && rtp_timestamp_delta_ == 0) {
       while (frames_.front().timestamp() != video_frame.timestamp()) {
         ++dropped_frames_before_first_encode_;
         frames_.pop_front();
         RTC_CHECK(!frames_.empty());
       }
       first_send_timestamp_ = rtc::Optional<uint32_t>(video_frame.timestamp());
     }
@@ skipping 117 matching lines @@
       printf("- Farewell, sweet Concorde!\n");
 
     stats_polling_thread_.Stop();
   }
 
   rtc::VideoSinkInterface<VideoFrame>* pre_encode_proxy() {
     return &pre_encode_proxy_;
   }
   EncodedFrameObserver* encode_timing_proxy() { return &encode_timing_proxy_; }
 
-  VideoCaptureInput* input_;
   test::LayerFilteringTransport* const transport_;
   PacketReceiver* receiver_;
-  VideoSendStream* send_stream_;
 
  private:
   struct FrameComparison {
     FrameComparison()
         : dropped(false),
           send_time_ms(0),
           recv_time_ms(0),
           render_time_ms(0),
           encoded_frame_size(0) {}
 
@@ skipping 327 matching lines @@
               sample.encoded_frame_size, sample.psnr, sample.ssim,
               encode_time_ms);
     }
     if (missing_encode_time_samples) {
       fprintf(stderr,
               "Warning: Missing encode_time_ms samples for %d frame(s).\n",
               missing_encode_time_samples);
     }
   }
 
+  // Implements VideoSinkInterface to receive captured frames from a
+  // FrameGeneratorCapturer. Implements VideoSourceInterface to be able to act
+  // as a source to VideoSendStream.
+  // It forwards all input frames to the VideoAnalyzer for later comparison and
+  // forwards the captured frames to the VideoSendStream.
+  class CapturedFrameForwarder : public rtc::VideoSinkInterface<VideoFrame>,
+                                 public rtc::VideoSourceInterface<VideoFrame> {
+   public:
+    explicit CapturedFrameForwarder(VideoAnalyzer* analyzer)
+        : analyzer_(analyzer), send_stream_input_(nullptr) {}
+
+   private:
+    void OnFrame(const VideoFrame& video_frame) override {
+      VideoFrame copy = video_frame;
+      copy.set_timestamp(copy.ntp_time_ms() * 90);
+
+      analyzer_->AddCapturedFrameForComparison(video_frame);
+      rtc::CritScope lock(&crit_);
+      if (send_stream_input_)
+        send_stream_input_->OnFrame(video_frame);
+    }
+
+    // Called when |send_stream_.SetSource()| is called.
+    void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
+                         const rtc::VideoSinkWants& wants) override {
+      rtc::CritScope lock(&crit_);
+      RTC_DCHECK(!send_stream_input_ || send_stream_input_ == sink);
+      send_stream_input_ = sink;
+    }
+
+    // Called by |send_stream_| when |send_stream_.SetSource()| is called.
+    void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {
+      rtc::CritScope lock(&crit_);
+      RTC_DCHECK(sink == send_stream_input_);
+      send_stream_input_ = nullptr;
+    }
+
+    VideoAnalyzer* const analyzer_;
+    rtc::CriticalSection crit_;
+    rtc::VideoSinkInterface<VideoFrame>* send_stream_input_ GUARDED_BY(crit_);
+  };
+
+  void AddCapturedFrameForComparison(const VideoFrame& video_frame) {
+    rtc::CritScope lock(&crit_);
+    RTC_DCHECK_EQ(0u, video_frame.timestamp());
+    // Frames from the capturer does not have a rtp timestamp. Create one so it
+    // can be used for comparison.
+    VideoFrame copy = video_frame;
+    copy.set_timestamp(copy.ntp_time_ms() * 90);
+    frames_.push_back(copy);
+  }
+
+  VideoSendStream* send_stream_;
+  CapturedFrameForwarder captured_frame_forwarder_;
   const std::string test_label_;
   FILE* const graph_data_output_file_;
   const std::string graph_title_;
   const uint32_t ssrc_to_analyze_;
   PreEncodeProxy pre_encode_proxy_;
   OnEncodeTimingProxy encode_timing_proxy_;
   std::vector<Sample> samples_ GUARDED_BY(comparison_lock_);
   std::map<int64_t, int> samples_encode_time_ms_ GUARDED_BY(comparison_lock_);
   test::Statistics sender_time_ GUARDED_BY(comparison_lock_);
   test::Statistics receiver_time_ GUARDED_BY(comparison_lock_);
@@ skipping 311 matching lines @@
                  params_.screenshare.slide_change_interval);
 
     frame_generator_.reset(
         test::FrameGenerator::CreateScrollingInputFromYuvFiles(
             clock_, slides, kWidth, kHeight, params_.common.width,
             params_.common.height, params_.screenshare.scroll_duration * 1000,
             kPauseDurationMs));
   }
 }
 
-void VideoQualityTest::CreateCapturer(VideoCaptureInput* input) {
+void VideoQualityTest::CreateCapturer() {
   if (params_.screenshare.enabled) {
     test::FrameGeneratorCapturer* frame_generator_capturer =
-        new test::FrameGeneratorCapturer(
-            clock_, input, frame_generator_.release(), params_.common.fps);
+        new test::FrameGeneratorCapturer(clock_, frame_generator_.release(),
+                                         params_.common.fps);
     EXPECT_TRUE(frame_generator_capturer->Init());
     capturer_.reset(frame_generator_capturer);
   } else {
     if (params_.video.clip_name.empty()) {
-      capturer_.reset(test::VideoCapturer::Create(input, params_.common.width,
-                                                  params_.common.height,
-                                                  params_.common.fps, clock_));
+      capturer_.reset(test::VcmCapturer::Create(
+          params_.common.width, params_.common.height, params_.common.fps));
     } else {
       capturer_.reset(test::FrameGeneratorCapturer::CreateFromYuvFile(
-          input, test::ResourcePath(params_.video.clip_name, "yuv"),
+          test::ResourcePath(params_.video.clip_name, "yuv"),
           params_.common.width, params_.common.height, params_.common.fps,
           clock_));
       ASSERT_TRUE(capturer_) << "Could not create capturer for "
                              << params_.video.clip_name
                              << ".yuv. Is this resource file present?";
     }
   }
 }
 
 void VideoQualityTest::RunWithAnalyzer(const Params& params) {
@@ skipping 64 matching lines @@
   video_send_config_.pre_encode_callback = analyzer.pre_encode_proxy();
   for (auto& config : video_receive_configs_)
     config.pre_decode_callback = &analyzer;
   RTC_DCHECK(!video_send_config_.post_encode_callback);
   video_send_config_.post_encode_callback = analyzer.encode_timing_proxy();
 
   if (params_.screenshare.enabled)
     SetupScreenshare();
 
   CreateVideoStreams();
-  analyzer.input_ = video_send_stream_->Input();
-  analyzer.send_stream_ = video_send_stream_;
+  analyzer.SetSendStream(video_send_stream_);
+  video_send_stream_->SetSource(analyzer.OutputInterface());
 
-  CreateCapturer(&analyzer);
+  CreateCapturer();
+  rtc::VideoSinkWants wants;
+  capturer_->AddOrUpdateSink(analyzer.InputInterface(), wants);
 
   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 71 matching lines @@
       kUlpfecPayloadType;
   }
 
   if (params_.screenshare.enabled)
     SetupScreenshare();
 
   video_send_stream_ = call->CreateVideoSendStream(
       video_send_config_.Copy(), video_encoder_config_.Copy());
   VideoReceiveStream* video_receive_stream =
       call->CreateVideoReceiveStream(video_receive_configs_[stream_id].Copy());
-  CreateCapturer(video_send_stream_->Input());
+  CreateCapturer();
+  video_send_stream_->SetSource(capturer_.get());
 
   AudioReceiveStream* audio_receive_stream = nullptr;
   if (params_.audio) {
     audio_send_config_ = AudioSendStream::Config(&transport);
     audio_send_config_.voe_channel_id = voe.send_channel_id;
     audio_send_config_.rtp.ssrc = kAudioSendSsrc;
 
     // Add extension to enable audio send side BWE, and allow audio bit rate
     // adaptation.
     audio_send_config_.rtp.extensions.clear();
@@ skipping 65 matching lines @@
      call->DestroyAudioSendStream(audio_send_stream_);
      call->DestroyAudioReceiveStream(audio_receive_stream);
   }
 
   transport.StopSending();
   if (params_.audio)
     DestroyVoiceEngine(&voe);
 }
 
 }  // namespace webrtc