| /* | |
| * 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)); | |
| externalCapture = implementation.get(); | |
| return implementation; | |
| } | |
| const char* VideoCaptureImpl::CurrentDeviceName() const | |
| { | |
| return _deviceUniqueId; | |
| } | |
| // static | |
| int32_t VideoCaptureImpl::RotationFromDegrees(int degrees, | |
| VideoRotation* rotation) { | |
| switch (degrees) { | |
| case 0: | |
| *rotation = kVideoRotation_0; | |
| return 0; | |
| case 90: | |
| *rotation = kVideoRotation_90; | |
| return 0; | |
| case 180: | |
| *rotation = kVideoRotation_180; | |
| return 0; | |
| case 270: | |
| *rotation = kVideoRotation_270; | |
| return 0; | |
| default: | |
| return -1;; | |
| } | |
| } | |
| // static | |
| int32_t VideoCaptureImpl::RotationInDegrees(VideoRotation rotation, | |
| int* degrees) { | |
| switch (rotation) { | |
| case kVideoRotation_0: | |
| *degrees = 0; | |
| return 0; | |
| case kVideoRotation_90: | |
| *degrees = 90; | |
| return 0; | |
| case kVideoRotation_180: | |
| *degrees = 180; | |
| return 0; | |
| case kVideoRotation_270: | |
| *degrees = 270; | |
| return 0; | |
| } | |
| return -1; | |
| } | |
| // returns the number of milliseconds until the module want a worker thread to call Process | |
| 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() | |
| { | |
| CriticalSectionScoped cs(&_callBackCs); | |
| 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), | |
| _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) { | |
| CriticalSectionScoped cs(&_apiCs); | |
| CriticalSectionScoped cs2(&_callBackCs); | |
| _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); | |
| } | |
| return 0; | |
| } | |
| int32_t VideoCaptureImpl::IncomingFrame( | |
| uint8_t* videoFrame, | |
| size_t videoFrameLength, | |
| const VideoCaptureCapability& frameInfo, | |
| int64_t captureTime/*=0*/) | |
| { | |
| CriticalSectionScoped cs(&_apiCs); | |
| CriticalSectionScoped cs2(&_callBackCs); | |
| const int32_t width = frameInfo.width; | |
| const int32_t height = frameInfo.height; | |
| TRACE_EVENT1("webrtc", "VC::IncomingFrame", "capture_time", captureTime); | |
| if (frameInfo.codecType == kVideoCodecUnknown) | |
| { | |
| // Not encoded, convert to I420. | |
| const VideoType commonVideoType = | |
| RawVideoTypeToCommonVideoVideoType(frameInfo.rawType); | |
| if (frameInfo.rawType != kVideoMJPEG && | |
| CalcBufferSize(commonVideoType, width, | |
| abs(height)) != videoFrameLength) | |
| { | |
| LOG(LS_ERROR) << "Wrong incoming frame length."; | |
| return -1; | |
| } | |
| int stride_y = width; | |
| int stride_uv = (width + 1) / 2; | |
| int target_width = width; | |
| int target_height = height; | |
| // SetApplyRotation doesn't take any lock. Make a local copy here. | |
| bool apply_rotation = apply_rotation_; | |
| if (apply_rotation) { | |
| // Rotating resolution when for 90/270 degree rotations. | |
| if (_rotateFrame == kVideoRotation_90 || | |
| _rotateFrame == kVideoRotation_270) { | |
| target_width = abs(height); | |
| target_height = width; | |
| } | |
| } | |
| // Setting absolute height (in case it was negative). | |
| // In Windows, the image starts bottom left, instead of top left. | |
| // Setting a negative source height, inverts the image (within LibYuv). | |
| // TODO(nisse): Use a pool? | |
| rtc::scoped_refptr<I420Buffer> buffer = I420Buffer::Create( | |
| target_width, abs(target_height), stride_y, stride_uv, stride_uv); | |
| const int conversionResult = ConvertToI420( | |
| commonVideoType, videoFrame, 0, 0, // No cropping | |
| width, height, videoFrameLength, | |
| apply_rotation ? _rotateFrame : kVideoRotation_0, buffer.get()); | |
| if (conversionResult < 0) | |
| { | |
| LOG(LS_ERROR) << "Failed to convert capture frame from type " | |
| << frameInfo.rawType << "to I420."; | |
| return -1; | |
| } | |
| VideoFrame captureFrame( | |
| buffer, 0, rtc::TimeMillis(), | |
| !apply_rotation ? _rotateFrame : kVideoRotation_0); | |
| captureFrame.set_ntp_time_ms(captureTime); | |
| DeliverCapturedFrame(captureFrame); | |
| } | |
| else // Encoded format | |
| { | |
| assert(false); | |
| return -1; | |
| } | |
| 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--) | |
| { | |
| _incomingFrameTimesNanos[i + 1] = _incomingFrameTimesNanos[i]; | |
| } | |
| } | |
| _incomingFrameTimesNanos[0] = rtc::TimeNanos(); | |
| } | |
| uint32_t VideoCaptureImpl::CalculateFrameRate(int64_t now_ns) | |
| { | |
| int32_t num = 0; | |
| int32_t nrOfFrames = 0; | |
| for (num = 1; num < (kFrameRateCountHistorySize - 1); num++) | |
| { | |
| if (_incomingFrameTimesNanos[num] <= 0 || | |
| (now_ns - _incomingFrameTimesNanos[num]) / | |
| rtc::kNumNanosecsPerMillisec > | |
| kFrameRateHistoryWindowMs) // don't use data older than 2sec | |
| { | |
| break; | |
| } | |
| else | |
| { | |
| nrOfFrames++; | |
| } | |
| } | |
| if (num > 1) | |
| { | |
| int64_t diff = (now_ns - _incomingFrameTimesNanos[num - 1]) / | |
| rtc::kNumNanosecsPerMillisec; | |
| if (diff > 0) | |
| { | |
| return uint32_t((nrOfFrames * 1000.0f / diff) + 0.5f); | |
| } | |
| } | |
| return nrOfFrames; | |
| } | |
| } // namespace videocapturemodule | |
| } // namespace webrtc |