Revert of Replace interface VideoCapturerInput with VideoSinkInterface.

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  Copyright (c) 2014 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 1562 matching lines @@
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
       cpu_restricted_counter_(0),
       number_of_cpu_adapt_changes_(0),
       frame_count_(0),
       cpu_restricted_frame_count_(0),
       source_(nullptr),
       external_encoder_factory_(external_encoder_factory),
       stream_(nullptr),
-      encoder_sink_(nullptr),
       parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
       rtp_parameters_(CreateRtpParametersWithOneEncoding()),
       pending_encoder_reconfiguration_(false),
       allocated_encoder_(nullptr, webrtc::kVideoCodecUnknown, false),
       sending_(false),
       last_frame_timestamp_us_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
   parameters_.conference_mode = send_params.conference_mode;
 
   sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
@@ skipping 58 matching lines @@
     last_frame_info_.rotation = video_frame.rotation();
     last_frame_info_.is_texture = video_frame.is_texture();
     pending_encoder_reconfiguration_ = true;
 
     LOG(LS_INFO) << "Video frame parameters changed: dimensions="
                  << last_frame_info_.width << "x" << last_frame_info_.height
                  << ", rotation=" << last_frame_info_.rotation
                  << ", texture=" << last_frame_info_.is_texture;
   }
 
-  if (encoder_sink_ == NULL) {
+  if (stream_ == NULL) {
     // Frame input before send codecs are configured, dropping frame.
     return;
   }
 
   last_frame_timestamp_us_ = video_frame.timestamp_us();
 
   if (pending_encoder_reconfiguration_) {
     ReconfigureEncoder();
     pending_encoder_reconfiguration_ = false;
   }
 
   // Not sending, abort after reconfiguration. Reconfiguration should still
   // occur to permit sending this input as quickly as possible once we start
   // sending (without having to reconfigure then).
   if (!sending_) {
     return;
   }
 
   ++frame_count_;
   if (cpu_restricted_counter_ > 0)
     ++cpu_restricted_frame_count_;
 
-  encoder_sink_->OnFrame(video_frame);
+  stream_->Input()->IncomingCapturedFrame(video_frame);
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend(
     bool enable,
     const VideoOptions* options,
     rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   // Ignore |options| pointer if |enable| is false.
   bool options_present = enable && options;
   bool source_changing = source_ != source;
   if (source_changing) {
     DisconnectSource();
   }
 
   if (options_present || source_changing) {
     rtc::CritScope cs(&lock_);
 
     if (options_present) {
       VideoOptions old_options = parameters_.options;
       parameters_.options.SetAll(*options);
-      // Reconfigure encoder settings on the next frame or stream
+      // Reconfigure encoder settings on the naext frame or stream
       // recreation if the options changed.
       if (parameters_.options != old_options) {
         pending_encoder_reconfiguration_ = true;
       }
     }
 
     if (source_changing) {
-      if (source == nullptr && encoder_sink_ != nullptr) {
+      if (source == nullptr && stream_ != nullptr) {
         LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
         // Force this black frame not to be dropped due to timestamp order
         // check. As IncomingCapturedFrame will drop the frame if this frame's
         // timestamp is less than or equal to last frame's timestamp, it is
         // necessary to give this black frame a larger timestamp than the
         // previous one.
         last_frame_timestamp_us_ += rtc::kNumMicrosecsPerMillisec;
         rtc::scoped_refptr<webrtc::I420Buffer> black_buffer(
             webrtc::I420Buffer::Create(last_frame_info_.width,
                                        last_frame_info_.height));
         black_buffer->SetToBlack();
 
-        encoder_sink_->OnFrame(webrtc::VideoFrame(
-            black_buffer, last_frame_info_.rotation, last_frame_timestamp_us_));
+        stream_->Input()->IncomingCapturedFrame(webrtc::VideoFrame(
+            black_buffer, last_frame_info_.rotation,
+            last_frame_timestamp_us_));
       }
       source_ = source;
     }
   }
 
   // |source_->AddOrUpdateSink| may not be called while holding |lock_| since
   // that might cause a lock order inversion.
   if (source_changing && source_) {
     source_->AddOrUpdateSink(this, sink_wants_);
   }
   return true;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectSource() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (source_ == nullptr) {
+  if (source_ == NULL) {
     return;
   }
 
   // |source_->RemoveSink| may not be called while holding |lock_| since
   // that might cause a lock order inversion.
   source_->RemoveSink(this);
   source_ = nullptr;
   // Reset |cpu_restricted_counter_| if the source is changed. It is not
   // possible to know if the video resolution is restricted by CPU usage after
   // the source is changed since the next source might be screen capture
@@ skipping 285 matching lines @@
 
   parameters_.encoder_config = std::move(encoder_config);
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSend(bool send) {
   rtc::CritScope cs(&lock_);
   sending_ = send;
   UpdateSendState();
 }
 
-void WebRtcVideoChannel2::WebRtcVideoSendStream::AddOrUpdateSink(
-    VideoSinkInterface<webrtc::VideoFrame>* sink,
-    const rtc::VideoSinkWants& wants) {
-  // TODO(perkj): Actually consider the encoder |wants| and remove
-  // WebRtcVideoSendStream::OnLoadUpdate(Load load).
-  rtc::CritScope cs(&lock_);
-  RTC_DCHECK(!encoder_sink_ || encoder_sink_ == sink);
-  encoder_sink_ = sink;
-}
-
-void WebRtcVideoChannel2::WebRtcVideoSendStream::RemoveSink(
-    VideoSinkInterface<webrtc::VideoFrame>* sink) {
-  rtc::CritScope cs(&lock_);
-  RTC_DCHECK_EQ(encoder_sink_, sink);
-  encoder_sink_ = nullptr;
-}
-
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate(Load load) {
   if (worker_thread_ != rtc::Thread::Current()) {
     invoker_.AsyncInvoke<void>(
         RTC_FROM_HERE, worker_thread_,
         rtc::Bind(&WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate,
                   this, load));
     return;
   }
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!source_) {
@@ skipping 172 matching lines @@
       ConfigureVideoEncoderSettings(parameters_.codec_settings->codec);
 
   webrtc::VideoSendStream::Config config = parameters_.config.Copy();
   if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
     LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
                        "payload type the set codec. Ignoring RTX.";
     config.rtp.rtx.ssrcs.clear();
   }
   stream_ = call_->CreateVideoSendStream(std::move(config),
                                          parameters_.encoder_config.Copy());
-  stream_->SetSource(this);
 
   parameters_.encoder_config.encoder_specific_settings = NULL;
   pending_encoder_reconfiguration_ = false;
 
   // Call stream_->Start() if necessary conditions are met.
   UpdateSendState();
 }
 
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     webrtc::Call* call,
@@ skipping 438 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             fec_settings.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket