Revert of Make cricket::VideoCapturer implement VideoSourceInterface

webrtc/media/webrtc/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.
  */
 
+#ifdef HAVE_WEBRTC_VIDEO
 #include "webrtc/media/webrtc/webrtcvideoengine2.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/timeutils.h"
@@ skipping 941 matching lines @@
   if (enable && options) {
     VideoSendParameters new_params = send_params_;
     new_params.options.SetAll(*options);
     SetSendParameters(send_params_);
   }
   return true;
 }
 
 bool WebRtcVideoChannel2::ValidateSendSsrcAvailability(
     const StreamParams& sp) const {
-  for (uint32_t ssrc : sp.ssrcs) {
+  for (uint32_t ssrc: sp.ssrcs) {
     if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
       LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists.";
       return false;
     }
   }
   return true;
 }
 
 bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability(
     const StreamParams& sp) const {
-  for (uint32_t ssrc : sp.ssrcs) {
+  for (uint32_t ssrc: sp.ssrcs) {
     if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) {
       LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc
                     << "' already exists.";
       return false;
     }
   }
   return true;
 }
 
 bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
@@ skipping 285 matching lines @@
   {
     rtc::CritScope stream_lock(&stream_crit_);
     if (send_streams_.find(ssrc) == send_streams_.end()) {
       LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
       return false;
     }
     if (!send_streams_[ssrc]->SetCapturer(capturer)) {
       return false;
     }
   }
+
+  if (capturer) {
+    capturer->SetApplyRotation(!ContainsHeaderExtension(
+        send_rtp_extensions_, kRtpVideoRotationHeaderExtension));
+  }
   {
     rtc::CritScope lock(&capturer_crit_);
     capturers_[ssrc] = capturer;
   }
   return true;
 }
 
 void WebRtcVideoChannel2::OnPacketReceived(
     rtc::Buffer* packet,
     const rtc::PacketTime& packet_time) {
@@ skipping 243 matching lines @@
   video_frame->CreateEmptyFrame(width, height, width, (width + 1) / 2,
                                 (width + 1) / 2);
   memset(video_frame->buffer(webrtc::kYPlane), 16,
          video_frame->allocated_size(webrtc::kYPlane));
   memset(video_frame->buffer(webrtc::kUPlane), 128,
          video_frame->allocated_size(webrtc::kUPlane));
   memset(video_frame->buffer(webrtc::kVPlane), 128,
          video_frame->allocated_size(webrtc::kVPlane));
 }
 
-void WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame(
-    const VideoFrame& frame) {
-  TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::OnFrame");
-  webrtc::VideoFrame video_frame(frame.GetVideoFrameBuffer(), 0, 0,
-                                 frame.GetVideoRotation());
+void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
+    VideoCapturer* capturer,
+    const VideoFrame* frame) {
+  TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::InputFrame");
+  webrtc::VideoFrame video_frame(frame->GetVideoFrameBuffer(), 0, 0,
+                                 frame->GetVideoRotation());
   rtc::CritScope cs(&lock_);
   if (stream_ == NULL) {
     // Frame input before send codecs are configured, dropping frame.
     return;
   }
 
   // Not sending, abort early to prevent expensive reconfigurations while
   // setting up codecs etc.
   if (!sending_)
     return;
 
   if (muted_) {
     // Create a black frame to transmit instead.
-    CreateBlackFrame(&video_frame, static_cast<int>(frame.GetWidth()),
-                     static_cast<int>(frame.GetHeight()));
+    CreateBlackFrame(&video_frame,
+                     static_cast<int>(frame->GetWidth()),
+                     static_cast<int>(frame->GetHeight()));
   }
 
-  int64_t frame_delta_ms = frame.GetTimeStamp() / rtc::kNumNanosecsPerMillisec;
+  int64_t frame_delta_ms = frame->GetTimeStamp() / rtc::kNumNanosecsPerMillisec;
   // frame->GetTimeStamp() is essentially a delta, align to webrtc time
   if (first_frame_timestamp_ms_ == 0) {
     first_frame_timestamp_ms_ = rtc::Time() - frame_delta_ms;
   }
 
   last_frame_timestamp_ms_ = first_frame_timestamp_ms_ + frame_delta_ms;
   video_frame.set_render_time_ms(last_frame_timestamp_ms_);
   // Reconfigure codec if necessary.
-  SetDimensions(video_frame.width(), video_frame.height(),
-                capturer_->IsScreencast());
+  SetDimensions(
+      video_frame.width(), video_frame.height(), capturer->IsScreencast());
 
   stream_->Input()->IncomingCapturedFrame(video_frame);
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
     VideoCapturer* capturer) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetCapturer");
   if (!DisconnectCapturer() && capturer == NULL) {
     return false;
   }
@@ skipping 21 matching lines @@
         last_frame_timestamp_ms_ += 1;
         black_frame.set_render_time_ms(last_frame_timestamp_ms_);
         stream_->Input()->IncomingCapturedFrame(black_frame);
       }
 
       capturer_ = NULL;
       return true;
     }
 
     capturer_ = capturer;
-    capturer_->AddOrUpdateSink(this, sink_wants_);
   }
+  // Lock cannot be held while connecting the capturer to prevent lock-order
+  // violations.
+  capturer->SignalVideoFrame.connect(this, &WebRtcVideoSendStream::InputFrame);
   return true;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
   rtc::CritScope cs(&lock_);
   muted_ = mute;
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
   cricket::VideoCapturer* capturer;
   {
     rtc::CritScope cs(&lock_);
     if (capturer_ == NULL)
       return false;
 
     if (capturer_->video_adapter() != nullptr)
       old_adapt_changes_ += capturer_->video_adapter()->adaptation_changes();
 
     capturer = capturer_;
     capturer_ = NULL;
   }
-  capturer->RemoveSink(this);
-
+  capturer->SignalVideoFrame.disconnect(this);
   return true;
 }
 
 const std::vector<uint32_t>&
 WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
   return ssrcs_;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
     const VideoOptions& options) {
@@ skipping 117 matching lines @@
   rtc::CritScope cs(&lock_);
   // |recreate_stream| means construction-time parameters have changed and the
   // sending stream needs to be reset with the new config.
   bool recreate_stream = false;
   if (params.rtcp_mode) {
     parameters_.config.rtp.rtcp_mode = *params.rtcp_mode;
     recreate_stream = true;
   }
   if (params.rtp_header_extensions) {
     parameters_.config.rtp.extensions = *params.rtp_header_extensions;
-    sink_wants_.rotation_applied = !ContainsHeaderExtension(
-        *params.rtp_header_extensions, kRtpVideoRotationHeaderExtension);
     if (capturer_) {
-      capturer_->AddOrUpdateSink(this, sink_wants_);
+      capturer_->SetApplyRotation(!ContainsHeaderExtension(
+          *params.rtp_header_extensions, kRtpVideoRotationHeaderExtension));
     }
     recreate_stream = true;
   }
   if (params.max_bandwidth_bps) {
     // Max bitrate has changed, reconfigure encoder settings on the next frame
     // or stream recreation.
     parameters_.max_bitrate_bps = *params.max_bandwidth_bps;
     pending_encoder_reconfiguration_ = true;
   }
   // Set codecs and options.
@@ skipping 688 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
+
+#endif  // HAVE_WEBRTC_VIDEO