Make cricket::VideoCapturer implement VideoSourceInterface

webrtc/media/base/capturemanager.cc

 /*
  *  Copyright (c) 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.
  */
 
 #include "webrtc/media/base/capturemanager.h"
 
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/media/base/videocapturer.h"
 
 namespace cricket {
 
 // CaptureManager helper class.
 class VideoCapturerState {
  public:
   static const VideoFormatPod kDefaultCaptureFormat;
 
-  static VideoCapturerState* Create(VideoCapturer* video_capturer);
+  explicit VideoCapturerState(VideoCapturer* capturer);
   ~VideoCapturerState() {}
 
   void AddCaptureResolution(const VideoFormat& desired_format);
   bool RemoveCaptureResolution(const VideoFormat& format);
   VideoFormat GetHighestFormat(VideoCapturer* video_capturer) const;
 
   int IncCaptureStartRef();
   int DecCaptureStartRef();
-  CaptureRenderAdapter* adapter() {
-    RTC_DCHECK(thread_checker_.CalledOnValidThread());
-    return adapter_.get();
-  }
   VideoCapturer* GetVideoCapturer() {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
-    return adapter()->video_capturer();
+    return video_capturer_;
   }
 
   int start_count() const {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return start_count_;
   }
 
  private:
   struct CaptureResolutionInfo {
     VideoFormat video_format;
     int format_ref_count;
   };
   typedef std::vector<CaptureResolutionInfo> CaptureFormats;
 
-  explicit VideoCapturerState(CaptureRenderAdapter* adapter);
+  rtc::ThreadChecker thread_checker_;
 
-  rtc::ThreadChecker thread_checker_;
-  rtc::scoped_ptr<CaptureRenderAdapter> adapter_;
-
+  VideoCapturer* video_capturer_;
   int start_count_;
   CaptureFormats capture_formats_;
 };
 
 const VideoFormatPod VideoCapturerState::kDefaultCaptureFormat = {
   640, 360, FPS_TO_INTERVAL(30), FOURCC_ANY
 };
 
-VideoCapturerState::VideoCapturerState(CaptureRenderAdapter* adapter)
-    : adapter_(adapter), start_count_(1) {}
-
-// static
-VideoCapturerState* VideoCapturerState::Create(VideoCapturer* video_capturer) {
-  CaptureRenderAdapter* adapter = CaptureRenderAdapter::Create(video_capturer);
-  if (!adapter) {
-    return NULL;
-  }
-  return new VideoCapturerState(adapter);
-}
+VideoCapturerState::VideoCapturerState(VideoCapturer* capturer)
+    : video_capturer_(capturer), start_count_(1) {}
 
 void VideoCapturerState::AddCaptureResolution(
     const VideoFormat& desired_format) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   for (CaptureFormats::iterator iter = capture_formats_.begin();
        iter != capture_formats_.end(); ++iter) {
     if (desired_format == iter->video_format) {
       ++(iter->format_ref_count);
       return;
     }
@@ skipping 179 matching lines @@
   return true;
 }
 
 void CaptureManager::AddVideoSink(VideoCapturer* video_capturer,
                                   rtc::VideoSinkInterface<VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(nisse): Do we really need to tolerate NULL inputs?
   if (!video_capturer || !sink) {
     return;
   }
-  CaptureRenderAdapter* adapter = GetAdapter(video_capturer);
-  if (!adapter) {
-    return;
-  }
-  adapter->AddSink(sink);
+  rtc::VideoWants wants;
+  // Renderers must be able to apply rotation.
+  wants.rotation_applied = true;
+  video_capturer->AddOrUpdateSink(sink, wants);
 }
 
 void CaptureManager::RemoveVideoSink(
     VideoCapturer* video_capturer,
     rtc::VideoSinkInterface<VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!video_capturer || !sink) {
     return;
   }
-  CaptureRenderAdapter* adapter = GetAdapter(video_capturer);
-  if (!adapter) {
-    return;
-  }
-  adapter->RemoveSink(sink);
+  video_capturer->RemoveSink(sink);
 }
 
 bool CaptureManager::IsCapturerRegistered(VideoCapturer* video_capturer) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return GetCaptureState(video_capturer) != NULL;
 }
 
 bool CaptureManager::RegisterVideoCapturer(VideoCapturer* video_capturer) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  VideoCapturerState* capture_state =
-      VideoCapturerState::Create(video_capturer);
-  if (!capture_state) {
-    return false;
-  }
+  VideoCapturerState* capture_state = new VideoCapturerState(video_capturer);
   capture_states_[video_capturer] = capture_state;
   SignalCapturerStateChange.repeat(video_capturer->SignalStateChange);
   return true;
 }
 
 void CaptureManager::UnregisterVideoCapturer(
     VideoCapturerState* capture_state) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   VideoCapturer* video_capturer = capture_state->GetVideoCapturer();
   capture_states_.erase(video_capturer);
@@ skipping 47 matching lines @@
 VideoCapturerState* CaptureManager::GetCaptureState(
     VideoCapturer* video_capturer) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   CaptureStates::const_iterator iter = capture_states_.find(video_capturer);
   if (iter == capture_states_.end()) {
     return NULL;
   }
   return iter->second;
 }
 
-CaptureRenderAdapter* CaptureManager::GetAdapter(
-    VideoCapturer* video_capturer) const {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  VideoCapturerState* capture_state = GetCaptureState(video_capturer);
-  if (!capture_state) {
-    return NULL;
-  }
-  return capture_state->adapter();
-}
-
 }  // namespace cricket