Replace SetCapturer and SetCaptureDevice by SetSource.

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.
  */
 
 #include "webrtc/media/engine/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"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call.h"
-#include "webrtc/media/base/videocapturer.h"
-#include "webrtc/media/base/videorenderer.h"
 #include "webrtc/media/engine/constants.h"
 #include "webrtc/media/engine/simulcast.h"
 #include "webrtc/media/engine/webrtcmediaengine.h"
 #include "webrtc/media/engine/webrtcvideoencoderfactory.h"
 #include "webrtc/media/engine/webrtcvideoframe.h"
 #include "webrtc/media/engine/webrtcvoiceengine.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/video_decoder.h"
@@ skipping 1225 matching lines @@
   // Get send stream bitrate stats.
   rtc::CritScope stream_lock(&stream_crit_);
   for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream =
            send_streams_.begin();
        stream != send_streams_.end(); ++stream) {
     stream->second->FillBandwidthEstimationInfo(&bwe_info);
   }
   video_media_info->bw_estimations.push_back(bwe_info);
 }
 
-bool WebRtcVideoChannel2::SetCapturer(uint32_t ssrc, VideoCapturer* capturer) {
-  LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
-               << (capturer != NULL ? "(capturer)" : "NULL");
-  RTC_DCHECK(ssrc != 0);
-  {
-    rtc::CritScope stream_lock(&stream_crit_);
-    const auto& kv = send_streams_.find(ssrc);
-    if (kv == send_streams_.end()) {
-      LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
-      return false;
-    }
-    if (!kv->second->SetCapturer(capturer)) {
-      return false;
-    }
+void WebRtcVideoChannel2::SetSource(
+    uint32_t ssrc,
+    rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
+  LOG(LS_INFO) << "SetSource: " << ssrc << " -> "
+               << (source ? "(source)" : "NULL");
+  RTC_CHECK(ssrc != 0);
+
+  rtc::CritScope stream_lock(&stream_crit_);
+  const auto& kv = send_streams_.find(ssrc);
+  if (kv == send_streams_.end()) {
+    // Allow unknown ssrc only if source is null.
+    RTC_CHECK(source == nullptr);
   }
-  return true;
+  else {
+    send_streams_.find(ssrc)->second->SetSource(source);

[pthatcher1, 2016/03/05 01:45:41]

Why not kv->second->SetSource(source)?

[nisse-webrtc, 2016/03/15 16:28:00]

Done.

+  }
 }
 
 void WebRtcVideoChannel2::OnPacketReceived(
     rtc::Buffer* packet,
     const rtc::PacketTime& packet_time) {
   const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
                                               packet_time.not_before);
   const webrtc::PacketReceiver::DeliveryStatus delivery_result =
       call_->Receiver()->DeliverPacket(
           webrtc::MediaType::VIDEO,
@@ skipping 180 matching lines @@
     const std::vector<webrtc::RtpExtension>& rtp_extensions,
     // TODO(deadbeef): Don't duplicate information between send_params,
     // rtp_extensions, options, etc.
     const VideoSendParameters& send_params)
     : worker_thread_(rtc::Thread::Current()),
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
       cpu_restricted_counter_(0),
       number_of_cpu_adapt_changes_(0),
-      capturer_(nullptr),
+      source_(nullptr),
       external_encoder_factory_(external_encoder_factory),
       stream_(nullptr),
       parameters_(config, send_params.options, max_bitrate_bps, codec_settings),
       pending_encoder_reconfiguration_(false),
       allocated_encoder_(nullptr, webrtc::kVideoCodecUnknown, false),
       sending_(false),
       muted_(false),
       first_frame_timestamp_ms_(0),
       last_frame_timestamp_ms_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
@@ skipping 12 matching lines @@
 
   sink_wants_.rotation_applied = !ContainsHeaderExtension(
       rtp_extensions, kRtpVideoRotationHeaderExtension);
 
   if (codec_settings) {
     SetCodec(*codec_settings);
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
-  DisconnectCapturer();
+  DisconnectSource();
   if (stream_ != NULL) {
     call_->DestroyVideoSendStream(stream_);
   }
   DestroyVideoEncoder(&allocated_encoder_);
 }
 
 static void CreateBlackFrame(webrtc::VideoFrame* video_frame,
                              int width,
                              int height,
                              webrtc::VideoRotation rotation) {
@@ skipping 17 matching lines @@
   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;
 
+  // TODO(nisse): Keep?

[pthatcher1, 2016/03/05 01:45:41]

Yes, we need to keep this.  It's part of the standard to black-out frames for a
disabled VideoTrack.

[nisse-webrtc, 2016/03/15 16:28:00]

A while ago, I added similar logic in the VideoTrack class, so that it could be
removed here. My gut feeling is that the enabled_ flag makes sense in a
VideoTrack, but that the muted_ state doesn't really belong here. I'd like to
delete it, together with the |enable| argument for SetVideoSend.

And more recently, we've been discussing pushing black frames back to the source
with another VideoSinkWants flag (one potential advantage is that a source
producing textures might be able to produce black textures, and not switch
between textures and ordinary frames in main memory).

So we have to keep the logic here for now, but I really don't think this is the
right place to produce black frames.

[pthatcher1, 2016/03/15 16:56:45]

Yes, I saw that CL while Per was here.  If the VideoTrack does it via
wants.black_frames, then we don't need it here.  We can remove this once that CL
has landed.



On 2016/03/15 16:28:00, nisse-webrtc wrote:

   if (muted_) {
     // Create a black frame to transmit instead.
     CreateBlackFrame(&video_frame,
                      static_cast<int>(frame.GetWidth()),
                      static_cast<int>(frame.GetHeight()),
                      video_frame.rotation());
   }
 
   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());
   last_rotation_ = video_frame.rotation();
 
   stream_->Input()->IncomingCapturedFrame(video_frame);
 }
 
-bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
-    VideoCapturer* capturer) {
-  TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetCapturer");
+void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSource(
+    rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
+  TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetSource");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!DisconnectCapturer() && capturer == NULL) {
-    return false;
-  }
+
+  if (!source && !source_)
+    return;
+  DisconnectSource();
 
   {
     rtc::CritScope cs(&lock_);
 
     // Reset timestamps to realign new incoming frames to a webrtc timestamp. A
     // new capturer may have a different timestamp delta than the previous one.
     first_frame_timestamp_ms_ = 0;
 
-    if (capturer == NULL) {
+    if (source == NULL) {
       if (stream_ != NULL) {
         LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
         webrtc::VideoFrame black_frame;
 
         CreateBlackFrame(&black_frame, last_dimensions_.width,
                          last_dimensions_.height, last_rotation_);
 
         // 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_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_);
-  return true;
+  source_ = source;
+  if (source_)
+    source_->AddOrUpdateSink(this, sink_wants_);

[pthatcher1, 2016/03/05 01:45:41]

{} please

[nisse-webrtc, 2016/03/15 16:28:00]

Done.

 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
   rtc::CritScope cs(&lock_);
   muted_ = mute;
 }
 
-bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
+void WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectSource() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (capturer_ == NULL) {
-    return false;
+  if (source_ == NULL) {
+    return;
   }
 
-  capturer_->RemoveSink(this);
-  capturer_ = NULL;
+  source_->RemoveSink(this);
+  source_ = NULL;
   // Reset |cpu_restricted_counter_| if the capturer is changed. It is not
   // possible to know if the video resolution is restricted by CPU usage after
   // the capturer is changed since the next capturer might be screen capture
   // with another resolution and frame rate.
   cpu_restricted_counter_ = 0;
-  return true;
 }
 
 const std::vector<uint32_t>&
 WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
   return ssrcs_;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
     const VideoOptions& options) {
   rtc::CritScope cs(&lock_);
@@ skipping 108 matching lines @@
   // 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_);
+    if (source_) {
+      source_->AddOrUpdateSink(this, sink_wants_);
     }
     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;
   }
   if (params.conference_mode) {
@@ skipping 125 matching lines @@
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate(Load load) {
   if (worker_thread_ != rtc::Thread::Current()) {
     invoker_.AsyncInvoke<void>(
         worker_thread_,
         rtc::Bind(&WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate,
                   this, load));
     return;
   }
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!capturer_) {
+  if (!source_) {
     return;
   }
   {
     rtc::CritScope cs(&lock_);
     LOG(LS_INFO) << "OnLoadUpdate " << load << ", is_screencast: "
                  << (parameters_.options.is_screencast
                          ? (*parameters_.options.is_screencast ? "true"
                                                                : "false")
                          : "unset");
     // Do not adapt resolution for screen content as this will likely result in
@@ skipping 26 matching lines @@
       if (sink_wants_.max_pixel_count ||
           (sink_wants_.max_pixel_count_step_up &&
            *sink_wants_.max_pixel_count_step_up < *max_pixel_count_step_up)) {
         ++number_of_cpu_adapt_changes_;
         --cpu_restricted_counter_;
       }
     }
     sink_wants_.max_pixel_count = max_pixel_count;
     sink_wants_.max_pixel_count_step_up = max_pixel_count_step_up;
   }
-  capturer_->AddOrUpdateSink(this, sink_wants_);
+  source_->AddOrUpdateSink(this, sink_wants_);
 }
 
 VideoSenderInfo
 WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() {
   VideoSenderInfo info;
   webrtc::VideoSendStream::Stats stats;
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   {
     rtc::CritScope cs(&lock_);
     for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
@@ skipping 14 matching lines @@
     if (stream_ == NULL)
       return info;
 
     stats = stream_->GetStats();
   }
   info.adapt_changes = number_of_cpu_adapt_changes_;
   info.adapt_reason = cpu_restricted_counter_ <= 0
                           ? CoordinatedVideoAdapter::ADAPTREASON_NONE
                           : CoordinatedVideoAdapter::ADAPTREASON_CPU;
 
-  if (capturer_) {
+  if (source_) {
       VideoFormat last_captured_frame_format;
+      // TODO(nisse): Move stats logic elsewhere?
+#if 0
       capturer_->GetStats(&info.adapt_frame_drops, &info.effects_frame_drops,
                           &info.capturer_frame_time,
                           &last_captured_frame_format);
+#endif

[pthatcher1, 2016/03/05 01:45:41]

What?

[nisse-webrtc, 2016/03/15 16:28:00]

To get the cl in a landable state, we have to figure out how to get the stats;
this class shouldn't know about the capturer. I don't know yet what's the right
way to do that.

[pthatcher1, 2016/03/15 16:56:45]

adapt_frame_drops, effects_frame_drops, and capturer_frame_time are never used
by anything, as far as I can tell.

The input_frame sizes is used.  I guess it's the non-adapted frame size.  We
could get that by having the unscaled resolution on the VideoFrame, which is
something I talked to Per about while he was here.

       info.input_frame_width = last_captured_frame_format.width;
       info.input_frame_height = last_captured_frame_format.height;
   }
 
   // Get bandwidth limitation info from stream_->GetStats().
   // Input resolution (output from video_adapter) can be further scaled down or
   // higher video layer(s) can be dropped due to bitrate constraints.
   // Note, adapt_changes only include changes from the video_adapter.
   if (stats.bw_limited_resolution)
     info.adapt_reason |= CoordinatedVideoAdapter::ADAPTREASON_BANDWIDTH;
@@ skipping 501 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