Add VideoTrackSource implementation.

webrtc/api/videocapturertracksource.cc

 /*
  *  Copyright 2012 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 224 matching lines @@
       best_it = it;
     }
   }
   return *best_it;
 }
 
 // Set |option| to the highest-priority value of |key| in the constraints.
 // Return false if the key is mandatory, and the value is invalid.
 bool ExtractOption(const MediaConstraintsInterface* all_constraints,
                    const std::string& key,
-                   rtc::Optional<bool>* option) {
+                   bool* option) {
   size_t mandatory = 0;
-  bool value;
-  if (FindConstraint(all_constraints, key, &value, &mandatory)) {
-    *option = rtc::Optional<bool>(value);
+  *option = false;
+  if (FindConstraint(all_constraints, key, option, &mandatory)) {
     return true;
   }
 
   return mandatory == 0;
 }
 
-// Search |all_constraints| for known video options.  Apply all options that are
-// found with valid values, and return false if any mandatory video option was
-// found with an invalid value.
-bool ExtractVideoOptions(const MediaConstraintsInterface* all_constraints,
-                         cricket::VideoOptions* options) {
-  bool all_valid = true;
-
-  all_valid &=
-      ExtractOption(all_constraints, MediaConstraintsInterface::kNoiseReduction,
-                    &(options->video_noise_reduction));
-
-  return all_valid;
-}
-
 }  // anonymous namespace
 
 namespace webrtc {
 
 rtc::scoped_refptr<VideoTrackSourceInterface> VideoCapturerTrackSource::Create(
     rtc::Thread* worker_thread,
     cricket::VideoCapturer* capturer,
     const webrtc::MediaConstraintsInterface* constraints,
     bool remote) {
   RTC_DCHECK(worker_thread != NULL);
@@ skipping 15 matching lines @@
       new rtc::RefCountedObject<VideoCapturerTrackSource>(worker_thread,
                                                           capturer, remote));
   source->Initialize(nullptr);
   return source;
 }
 
 VideoCapturerTrackSource::VideoCapturerTrackSource(
     rtc::Thread* worker_thread,
     cricket::VideoCapturer* capturer,
     bool remote)
-    : signaling_thread_(rtc::Thread::Current()),
-      worker_thread_(worker_thread),
+    : VideoTrackSource(capturer, worker_thread, remote),
+      signaling_thread_(rtc::Thread::Current()),
       video_capturer_(capturer),
       started_(false),
-      state_(kInitializing),
-      remote_(remote) {
+      needs_denoising_(false) {
   video_capturer_->SignalStateChange.connect(
       this, &VideoCapturerTrackSource::OnStateChange);
 }
 
 VideoCapturerTrackSource::~VideoCapturerTrackSource() {
   video_capturer_->SignalStateChange.disconnect(this);
   Stop();
 }
 
 void VideoCapturerTrackSource::Initialize(
@@ skipping 30 matching lines @@
     formats =
         FilterFormats(mandatory_constraints, optional_constraints, formats);
   }
 
   if (formats.size() == 0) {
     LOG(LS_WARNING) << "Failed to find a suitable video format.";
     SetState(kEnded);
     return;
   }
 
-  cricket::VideoOptions options;
-  if (!ExtractVideoOptions(constraints, &options)) {
-    LOG(LS_WARNING) << "Could not satisfy mandatory options.";
+  if (!ExtractOption(constraints, MediaConstraintsInterface::kNoiseReduction,
+                     &needs_denoising_)) {
+    LOG(LS_WARNING) << "Invalid mandatory value for"
+                    << MediaConstraintsInterface::kNoiseReduction;
     SetState(kEnded);
     return;
   }
-  options_.SetAll(options);
-  options_.is_screencast = rtc::Optional<bool>(video_capturer_->IsScreencast());
 
   format_ = GetBestCaptureFormat(formats);
   // Start the camera with our best guess.
-  // TODO(perkj): Should we try again with another format it it turns out that
-  // the camera doesn't produce frames with the correct format? Or will
-  // cricket::VideCapturer be able to re-scale / crop to the requested
-  // resolution?
-  if (!worker_thread_->Invoke<bool>(
+  if (!worker_thread()->Invoke<bool>(
           rtc::Bind(&cricket::VideoCapturer::StartCapturing,
                     video_capturer_.get(), format_))) {
     SetState(kEnded);
     return;
   }
   started_ = true;
   // Initialize hasn't succeeded until a successful state change has occurred.
 }
 
 void VideoCapturerTrackSource::Stop() {
   if (!started_) {
     return;
   }
   started_ = false;
-  worker_thread_->Invoke<void>(
+  worker_thread()->Invoke<void>(
       rtc::Bind(&cricket::VideoCapturer::Stop, video_capturer_.get()));
 }
 
 void VideoCapturerTrackSource::Restart() {
   if (started_) {
     return;
   }
-  if (!worker_thread_->Invoke<bool>(
+  if (!worker_thread()->Invoke<bool>(
           rtc::Bind(&cricket::VideoCapturer::StartCapturing,
                     video_capturer_.get(), format_))) {
     SetState(kEnded);
     return;
   }
   started_ = true;
 }
 
-void VideoCapturerTrackSource::AddOrUpdateSink(
-    rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
-    const rtc::VideoSinkWants& wants) {
-  worker_thread_->Invoke<void>(
-      rtc::Bind(&cricket::VideoCapturer::AddOrUpdateSink, video_capturer_.get(),
-                sink, wants));
-}
-
-void VideoCapturerTrackSource::RemoveSink(
-    rtc::VideoSinkInterface<cricket::VideoFrame>* output) {
-  worker_thread_->Invoke<void>(rtc::Bind(&cricket::VideoCapturer::RemoveSink,
-                                         video_capturer_.get(), output));
-}
-
 // OnStateChange listens to the cricket::VideoCapturer::SignalStateChange.
 void VideoCapturerTrackSource::OnStateChange(
     cricket::VideoCapturer* capturer,
     cricket::CaptureState capture_state) {
   if (rtc::Thread::Current() != signaling_thread_) {
     invoker_.AsyncInvoke<void>(
         signaling_thread_, rtc::Bind(&VideoCapturerTrackSource::OnStateChange,
                                      this, capturer, capture_state));
     return;
   }
 
   if (capturer == video_capturer_.get()) {
     SetState(GetReadyState(capture_state));
   }
 }
 
-void VideoCapturerTrackSource::SetState(SourceState new_state) {
-  if (state_ != new_state) {
-    state_ = new_state;
-    FireOnChanged();
-  }
-}
-
 }  // namespace webrtc