Replace VideoCaptureDataCallback by VideoSinkInterface.

webrtc/media/engine/webrtcvideocapturer.cc

 /*
  *  Copyright (c) 2011 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 29 matching lines @@
   { FOURCC_NV12, webrtc::kVideoNV12 },   // 12 bpp, fast conversion.
   { FOURCC_NV21, webrtc::kVideoNV21 },   // 12 bpp, fast conversion.
   { FOURCC_MJPG, webrtc::kVideoMJPEG },  // compressed, slow conversion.
   { FOURCC_ARGB, webrtc::kVideoARGB },   // 32 bpp, slow conversion.
   { FOURCC_24BG, webrtc::kVideoRGB24 },  // 24 bpp, slow conversion.
 };
 
 class WebRtcVcmFactory : public WebRtcVcmFactoryInterface {
  public:
   virtual rtc::scoped_refptr<webrtc::VideoCaptureModule> Create(
-      int id,
       const char* device) {
-    return webrtc::VideoCaptureFactory::Create(id, device);
+    return webrtc::VideoCaptureFactory::Create(device);
   }
-  virtual webrtc::VideoCaptureModule::DeviceInfo* CreateDeviceInfo(int id) {
-    return webrtc::VideoCaptureFactory::CreateDeviceInfo(id);
+  virtual webrtc::VideoCaptureModule::DeviceInfo* CreateDeviceInfo() {
+    return webrtc::VideoCaptureFactory::CreateDeviceInfo();
   }
   virtual void DestroyDeviceInfo(webrtc::VideoCaptureModule::DeviceInfo* info) {
     delete info;
   }
 };
 
 static bool CapabilityToFormat(const webrtc::VideoCaptureCapability& cap,
                                VideoFormat* format) {
   uint32_t fourcc = 0;
   for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
@@ skipping 56 matching lines @@
 
 WebRtcVideoCapturer::~WebRtcVideoCapturer() {}
 
 bool WebRtcVideoCapturer::Init(const Device& device) {
   RTC_DCHECK(!start_thread_);
   if (module_) {
     LOG(LS_ERROR) << "The capturer is already initialized";
     return false;
   }
 
-  webrtc::VideoCaptureModule::DeviceInfo* info = factory_->CreateDeviceInfo(0);
+  webrtc::VideoCaptureModule::DeviceInfo* info = factory_->CreateDeviceInfo();
   if (!info) {
     return false;
   }
 
   // Find the desired camera, by name.
   // In the future, comparing IDs will be more robust.
   // TODO(juberti): Figure what's needed to allow this.
   int num_cams = info->NumberOfDevices();
   char vcm_id[256] = "";
   bool found = false;
@@ skipping 29 matching lines @@
       }
     }
   }
   factory_->DestroyDeviceInfo(info);
 
   if (supported.empty()) {
     LOG(LS_ERROR) << "Failed to find usable formats for id: " << device.id;
     return false;
   }
 
-  module_ = factory_->Create(0, vcm_id);
+  module_ = factory_->Create(vcm_id);
   if (!module_) {
     LOG(LS_ERROR) << "Failed to create capturer for id: " << device.id;
     return false;
   }
 
   // It is safe to change member attributes now.
   SetId(device.id);
   SetSupportedFormats(supported);
 
   return true;
@@ skipping 73 matching lines @@
 
   SetCaptureFormat(&capture_format);
 
   webrtc::VideoCaptureCapability cap;
   if (!FormatToCapability(capture_format, &cap)) {
     LOG(LS_ERROR) << "Invalid capture format specified";
     return CS_FAILED;
   }
 
   int64_t start = rtc::TimeMillis();
-  module_->RegisterCaptureDataCallback(*this);
+  module_->RegisterCaptureDataCallback(this);
   if (module_->StartCapture(cap) != 0) {
     LOG(LS_ERROR) << "Camera '" << GetId() << "' failed to start";
     module_->DeRegisterCaptureDataCallback();
     async_invoker_.reset();
     SetCaptureFormat(nullptr);
     start_thread_ = nullptr;
     return CS_FAILED;
   }
 
   LOG(LS_INFO) << "Camera '" << GetId() << "' started with format "
@@ skipping 43 matching lines @@
     return false;
   }
 
   fourccs->clear();
   for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
     fourccs->push_back(kSupportedFourCCs[i].fourcc);
   }
   return true;
 }
 
-void WebRtcVideoCapturer::OnIncomingCapturedFrame(
-    const int32_t id,
+void WebRtcVideoCapturer::OnFrame(
     const webrtc::VideoFrame& sample) {
   // This can only happen between Start() and Stop().
   RTC_DCHECK(start_thread_);
   RTC_DCHECK(async_invoker_);
 
   ++captured_frames_;
   // Log the size and pixel aspect ratio of the first captured frame.
   if (1 == captured_frames_) {
     LOG(LS_INFO) << "Captured frame size "
                  << sample.width() << "x" << sample.height()
                  << ". Expected format " << GetCaptureFormat()->ToString();
   }
 
-  OnFrame(sample, sample.width(), sample.height());
-}
-
-void WebRtcVideoCapturer::OnCaptureDelayChanged(const int32_t id,
-                                                const int32_t delay) {
-  LOG(LS_INFO) << "Capture delay changed to " << delay << " ms";
+  VideoCapturer::OnFrame(sample, sample.width(), sample.height());
 }
 
 }  // namespace cricket