Replace VideoCaptureDataCallback by VideoSinkInterface.

webrtc/modules/video_capture/video_capture_impl.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/modules/video_capture/video_capture_impl.h"
 
 #include <stdlib.h>
 
 #include "webrtc/base/refcount.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/video_capture/video_capture_config.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/logging.h"
 
 namespace webrtc {
 namespace videocapturemodule {
 rtc::scoped_refptr<VideoCaptureModule> VideoCaptureImpl::Create(
-    const int32_t id,
     VideoCaptureExternal*& externalCapture) {
   rtc::scoped_refptr<VideoCaptureImpl> implementation(
-      new rtc::RefCountedObject<VideoCaptureImpl>(id));
+      new rtc::RefCountedObject<VideoCaptureImpl>());
   externalCapture = implementation.get();
   return implementation;
 }
 
 const char* VideoCaptureImpl::CurrentDeviceName() const
 {
     return _deviceUniqueId;
 }
 
 // static
@@ skipping 41 matching lines @@
 int64_t VideoCaptureImpl::TimeUntilNextProcess()
 {
     CriticalSectionScoped cs(&_callBackCs);
     const int64_t kProcessIntervalMs = 300;
     return kProcessIntervalMs -
            (rtc::TimeNanos() - _lastProcessTimeNanos) /
            rtc::kNumNanosecsPerMillisec;
 }
 
 // Process any pending tasks such as timeouts
 void VideoCaptureImpl::Process()

[perkj_webrtc, 2016/11/29 12:55:56]

VideoCaptureImpl no longer need ::Process and VideoCaptureModule no longer need
to inherit from public RefCountedModule.

[nisse-webrtc, 2016/11/29 13:58:17]

Nice!

And TimeUntilNextProcess should also be deleted. But it still has to inherit
rtc::RefCountInterface, right?

[perkj_webrtc, 2016/11/30 06:28:48]

I don't think so. It does not have to be ref counted.

[nisse-webrtc, 2016/11/30 07:54:01]

There's a method, WebRtcVcmFactory::Create, which returns a
scoped_refptr<VideoCaptureModule>. Should we keep ref counting in for this cl,
or can we change that Create method (and whatever calls it) to use a unique_ptr
instead?

 {
     CriticalSectionScoped cs(&_callBackCs);

[nisse-webrtc, 2016/11/29 13:58:17]

And it seems _callBackCs can also be deleted? In all remaining uses it is locked
together with _apiCs.

[perkj_webrtc, 2016/11/30 06:28:48]

You can use GUARDED_BY().. But yes, there is no reason to have two locks.

 
-    const int64_t now_ns = rtc::TimeNanos();
     _lastProcessTimeNanos = rtc::TimeNanos();
 
-    // Handle No picture alarm
-
-    if (_lastProcessFrameTimeNanos == _incomingFrameTimesNanos[0] &&
-        _captureAlarm != Raised)
-    {
-        if (_noPictureAlarmCallBack && _captureCallBack)
-        {
-            _captureAlarm = Raised;
-            _captureCallBack->OnNoPictureAlarm(_id, _captureAlarm);
-        }
-    }
-    else if (_lastProcessFrameTimeNanos != _incomingFrameTimesNanos[0] &&
-             _captureAlarm != Cleared)
-    {
-        if (_noPictureAlarmCallBack && _captureCallBack)
-        {
-            _captureAlarm = Cleared;
-            _captureCallBack->OnNoPictureAlarm(_id, _captureAlarm);
-
-        }
-    }
-
-    // Handle frame rate callback
-    if ((now_ns - _lastFrameRateCallbackTimeNanos) /
-        rtc::kNumNanosecsPerMillisec
-        > kFrameRateCallbackInterval)
-    {
-        if (_frameRateCallBack && _captureCallBack)
-        {
-            const uint32_t frameRate = CalculateFrameRate(now_ns);
-            _captureCallBack->OnCaptureFrameRate(_id, frameRate);
-        }
-        // Can be set by EnableFrameRateCallback
-        _lastFrameRateCallbackTimeNanos = now_ns;
-
-    }
-
     _lastProcessFrameTimeNanos = _incomingFrameTimesNanos[0];
 }
 
-VideoCaptureImpl::VideoCaptureImpl(const int32_t id)
-    : _id(id),
-      _deviceUniqueId(NULL),
+VideoCaptureImpl::VideoCaptureImpl()
+    : _deviceUniqueId(NULL),
       _apiCs(*CriticalSectionWrapper::CreateCriticalSection()),
       _captureDelay(0),
       _requestedCapability(),
       _callBackCs(*CriticalSectionWrapper::CreateCriticalSection()),
       _lastProcessTimeNanos(rtc::TimeNanos()),
       _lastFrameRateCallbackTimeNanos(rtc::TimeNanos()),
-      _frameRateCallBack(false),
-      _noPictureAlarmCallBack(false),
-      _captureAlarm(Cleared),
-      _setCaptureDelay(0),
       _dataCallBack(NULL),
-      _captureCallBack(NULL),
       _lastProcessFrameTimeNanos(rtc::TimeNanos()),
       _rotateFrame(kVideoRotation_0),
       apply_rotation_(false) {
     _requestedCapability.width = kDefaultWidth;
     _requestedCapability.height = kDefaultHeight;
     _requestedCapability.maxFPS = 30;
     _requestedCapability.rawType = kVideoI420;
     _requestedCapability.codecType = kVideoCodecUnknown;
     memset(_incomingFrameTimesNanos, 0, sizeof(_incomingFrameTimesNanos));
 }
 
 VideoCaptureImpl::~VideoCaptureImpl()
 {
     DeRegisterCaptureDataCallback();
-    DeRegisterCaptureCallback();
     delete &_callBackCs;
     delete &_apiCs;
 
     if (_deviceUniqueId)
         delete[] _deviceUniqueId;
 }
 
 void VideoCaptureImpl::RegisterCaptureDataCallback(
-    VideoCaptureDataCallback& dataCallBack) {
+    rtc::VideoSinkInterface<VideoFrame>* dataCallBack) {
     CriticalSectionScoped cs(&_apiCs);
     CriticalSectionScoped cs2(&_callBackCs);
-    _dataCallBack = &dataCallBack;
+    _dataCallBack = dataCallBack;
 }
 
 void VideoCaptureImpl::DeRegisterCaptureDataCallback() {
     CriticalSectionScoped cs(&_apiCs);
     CriticalSectionScoped cs2(&_callBackCs);
     _dataCallBack = NULL;
 }
-void VideoCaptureImpl::RegisterCaptureCallback(VideoCaptureFeedBack& callBack) {
-
-    CriticalSectionScoped cs(&_apiCs);
-    CriticalSectionScoped cs2(&_callBackCs);
-    _captureCallBack = &callBack;
-}
-void VideoCaptureImpl::DeRegisterCaptureCallback() {
-
-    CriticalSectionScoped cs(&_apiCs);
-    CriticalSectionScoped cs2(&_callBackCs);
-    _captureCallBack = NULL;
-}
-void VideoCaptureImpl::SetCaptureDelay(int32_t delayMS) {
-    CriticalSectionScoped cs(&_apiCs);
-    _captureDelay = delayMS;
-}
-int32_t VideoCaptureImpl::CaptureDelay()
-{
-    CriticalSectionScoped cs(&_apiCs);
-    return _setCaptureDelay;
-}
-
 int32_t VideoCaptureImpl::DeliverCapturedFrame(VideoFrame& captureFrame) {
   UpdateFrameCount();  // frame count used for local frame rate callback.
 
-  const bool callOnCaptureDelayChanged = _setCaptureDelay != _captureDelay;
-  // Capture delay changed
-  if (_setCaptureDelay != _captureDelay) {
-      _setCaptureDelay = _captureDelay;
-  }
-
   if (_dataCallBack) {
-    if (callOnCaptureDelayChanged) {
-      _dataCallBack->OnCaptureDelayChanged(_id, _captureDelay);
-    }
-    _dataCallBack->OnIncomingCapturedFrame(_id, captureFrame);
+    _dataCallBack->OnFrame(captureFrame);
   }
 
   return 0;
 }
 
 int32_t VideoCaptureImpl::IncomingFrame(
     uint8_t* videoFrame,
     size_t videoFrameLength,
     const VideoCaptureCapability& frameInfo,
     int64_t captureTime/*=0*/)
@@ skipping 71 matching lines @@
     return 0;
 }
 
 int32_t VideoCaptureImpl::SetCaptureRotation(VideoRotation rotation) {
   CriticalSectionScoped cs(&_apiCs);
   CriticalSectionScoped cs2(&_callBackCs);
   _rotateFrame = rotation;
   return 0;
 }
 
-void VideoCaptureImpl::EnableFrameRateCallback(const bool enable) {
-    CriticalSectionScoped cs(&_apiCs);
-    CriticalSectionScoped cs2(&_callBackCs);
-    _frameRateCallBack = enable;
-    if (enable)
-    {
-      _lastFrameRateCallbackTimeNanos = rtc::TimeNanos();
-    }
-}
-
 bool VideoCaptureImpl::SetApplyRotation(bool enable) {
   // We can't take any lock here as it'll cause deadlock with IncomingFrame.
 
   // The effect of this is the last caller wins.
   apply_rotation_ = enable;
   return true;
 }
 
-void VideoCaptureImpl::EnableNoPictureAlarm(const bool enable) {
-    CriticalSectionScoped cs(&_apiCs);
-    CriticalSectionScoped cs2(&_callBackCs);
-    _noPictureAlarmCallBack = enable;
-}
-
 void VideoCaptureImpl::UpdateFrameCount()
 {
   if (_incomingFrameTimesNanos[0] / rtc::kNumNanosecsPerMicrosec == 0)
     {
         // first no shift
     }
     else
     {
         // shift
         for (int i = (kFrameRateCountHistorySize - 2); i >= 0; i--)
@@ skipping 29 matching lines @@
         if (diff > 0)
         {
             return uint32_t((nrOfFrames * 1000.0f / diff) + 0.5f);
         }
     }
 
     return nrOfFrames;
 }
 }  // namespace videocapturemodule
 }  // namespace webrtc