| /* |
| * 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 <assert.h> |
| #include <stdlib.h> |
| |
| #include "webrtc/modules/video_capture/device_info_impl.h" |
| #include "webrtc/modules/video_capture/video_capture_config.h" |
| #include "webrtc/system_wrappers/include/logging.h" |
| |
| #ifndef abs |
| #define abs(a) (a>=0?a:-a) |
| #endif |
| |
| namespace webrtc |
| { |
| namespace videocapturemodule |
| { |
| DeviceInfoImpl::DeviceInfoImpl(const int32_t id) |
| : _id(id), _apiLock(*RWLockWrapper::CreateRWLock()), _lastUsedDeviceName(NULL), |
| _lastUsedDeviceNameLength(0) |
| { |
| } |
| |
| DeviceInfoImpl::~DeviceInfoImpl(void) |
| { |
| _apiLock.AcquireLockExclusive(); |
| free(_lastUsedDeviceName); |
| _apiLock.ReleaseLockExclusive(); |
| |
| delete &_apiLock; |
| } |
| int32_t DeviceInfoImpl::NumberOfCapabilities( |
| const char* deviceUniqueIdUTF8) |
| { |
| |
| if (!deviceUniqueIdUTF8) |
| return -1; |
| |
| _apiLock.AcquireLockShared(); |
| |
| if (_lastUsedDeviceNameLength == strlen((char*) deviceUniqueIdUTF8)) |
| { |
| // Is it the same device that is asked for again. |
| #if defined(WEBRTC_MAC) || defined(WEBRTC_LINUX) |
| if(strncasecmp((char*)_lastUsedDeviceName, |
| (char*) deviceUniqueIdUTF8, |
| _lastUsedDeviceNameLength)==0) |
| #else |
| if (_strnicmp((char*) _lastUsedDeviceName, |
| (char*) deviceUniqueIdUTF8, |
| _lastUsedDeviceNameLength) == 0) |
| #endif |
| { |
| //yes |
| _apiLock.ReleaseLockShared(); |
| return static_cast<int32_t>(_captureCapabilities.size()); |
| } |
| } |
| // Need to get exclusive rights to create the new capability map. |
| _apiLock.ReleaseLockShared(); |
| WriteLockScoped cs2(_apiLock); |
| |
| int32_t ret = CreateCapabilityMap(deviceUniqueIdUTF8); |
| return ret; |
| } |
| |
| int32_t DeviceInfoImpl::GetCapability(const char* deviceUniqueIdUTF8, |
| const uint32_t deviceCapabilityNumber, |
| VideoCaptureCapability& capability) |
| { |
| assert(deviceUniqueIdUTF8 != NULL); |
| |
| ReadLockScoped cs(_apiLock); |
| |
| if ((_lastUsedDeviceNameLength != strlen((char*) deviceUniqueIdUTF8)) |
| #if defined(WEBRTC_MAC) || defined(WEBRTC_LINUX) |
| || (strncasecmp((char*)_lastUsedDeviceName, |
| (char*) deviceUniqueIdUTF8, |
| _lastUsedDeviceNameLength)!=0)) |
| #else |
| || (_strnicmp((char*) _lastUsedDeviceName, |
| (char*) deviceUniqueIdUTF8, |
| _lastUsedDeviceNameLength) != 0)) |
| #endif |
| |
| { |
| _apiLock.ReleaseLockShared(); |
| _apiLock.AcquireLockExclusive(); |
| if (-1 == CreateCapabilityMap(deviceUniqueIdUTF8)) |
| { |
| _apiLock.ReleaseLockExclusive(); |
| _apiLock.AcquireLockShared(); |
| return -1; |
| } |
| _apiLock.ReleaseLockExclusive(); |
| _apiLock.AcquireLockShared(); |
| } |
| |
| // Make sure the number is valid |
| if (deviceCapabilityNumber >= (unsigned int) _captureCapabilities.size()) |
| { |
| LOG(LS_ERROR) << "Invalid deviceCapabilityNumber " |
| << deviceCapabilityNumber << ">= number of capabilities (" |
| << _captureCapabilities.size() << ")."; |
| return -1; |
| } |
| |
| capability = _captureCapabilities[deviceCapabilityNumber]; |
| return 0; |
| } |
| |
| int32_t DeviceInfoImpl::GetBestMatchedCapability( |
| const char*deviceUniqueIdUTF8, |
| const VideoCaptureCapability& requested, |
| VideoCaptureCapability& resulting) |
| { |
| |
| |
| if (!deviceUniqueIdUTF8) |
| return -1; |
| |
| ReadLockScoped cs(_apiLock); |
| if ((_lastUsedDeviceNameLength != strlen((char*) deviceUniqueIdUTF8)) |
| #if defined(WEBRTC_MAC) || defined(WEBRTC_LINUX) |
| || (strncasecmp((char*)_lastUsedDeviceName, |
| (char*) deviceUniqueIdUTF8, |
| _lastUsedDeviceNameLength)!=0)) |
| #else |
| || (_strnicmp((char*) _lastUsedDeviceName, |
| (char*) deviceUniqueIdUTF8, |
| _lastUsedDeviceNameLength) != 0)) |
| #endif |
| { |
| _apiLock.ReleaseLockShared(); |
| _apiLock.AcquireLockExclusive(); |
| if (-1 == CreateCapabilityMap(deviceUniqueIdUTF8)) |
| { |
| return -1; |
| } |
| _apiLock.ReleaseLockExclusive(); |
| _apiLock.AcquireLockShared(); |
| } |
| |
| int32_t bestformatIndex = -1; |
| int32_t bestWidth = 0; |
| int32_t bestHeight = 0; |
| int32_t bestFrameRate = 0; |
| RawVideoType bestRawType = kVideoUnknown; |
| webrtc::VideoCodecType bestCodecType = webrtc::kVideoCodecUnknown; |
| |
| const int32_t numberOfCapabilies = |
| static_cast<int32_t>(_captureCapabilities.size()); |
| |
| for (int32_t tmp = 0; tmp < numberOfCapabilies; ++tmp) // Loop through all capabilities |
| { |
| VideoCaptureCapability& capability = _captureCapabilities[tmp]; |
| |
| const int32_t diffWidth = capability.width - requested.width; |
| const int32_t diffHeight = capability.height - requested.height; |
| const int32_t diffFrameRate = capability.maxFPS - requested.maxFPS; |
| |
| const int32_t currentbestDiffWith = bestWidth - requested.width; |
| const int32_t currentbestDiffHeight = bestHeight - requested.height; |
| const int32_t currentbestDiffFrameRate = bestFrameRate - requested.maxFPS; |
| |
| if ((diffHeight >= 0 && diffHeight <= abs(currentbestDiffHeight)) // Height better or equalt that previouse. |
| || (currentbestDiffHeight < 0 && diffHeight >= currentbestDiffHeight)) |
| { |
| |
| if (diffHeight == currentbestDiffHeight) // Found best height. Care about the width) |
| { |
| if ((diffWidth >= 0 && diffWidth <= abs(currentbestDiffWith)) // Width better or equal |
| || (currentbestDiffWith < 0 && diffWidth >= currentbestDiffWith)) |
| { |
| if (diffWidth == currentbestDiffWith && diffHeight |
| == currentbestDiffHeight) // Same size as previously |
| { |
| //Also check the best frame rate if the diff is the same as previouse |
| if (((diffFrameRate >= 0 && |
| diffFrameRate <= currentbestDiffFrameRate) // Frame rate to high but better match than previouse and we have not selected IUV |
| || |
| (currentbestDiffFrameRate < 0 && |
| diffFrameRate >= currentbestDiffFrameRate)) // Current frame rate is lower than requested. This is better. |
| ) |
| { |
| if ((currentbestDiffFrameRate == diffFrameRate) // Same frame rate as previous or frame rate allready good enough |
| || (currentbestDiffFrameRate >= 0)) |
| { |
| if (bestRawType != requested.rawType |
| && requested.rawType != kVideoUnknown |
| && (capability.rawType == requested.rawType |
| || capability.rawType == kVideoI420 |
| || capability.rawType == kVideoYUY2 |
| || capability.rawType == kVideoYV12)) |
| { |
| bestCodecType = capability.codecType; |
| bestRawType = capability.rawType; |
| bestformatIndex = tmp; |
| } |
| // If width height and frame rate is full filled we can use the camera for encoding if it is supported. |
| if (capability.height == requested.height |
| && capability.width == requested.width |
| && capability.maxFPS >= requested.maxFPS) |
| { |
| if (capability.codecType == requested.codecType |
| && bestCodecType != requested.codecType) |
| { |
| bestCodecType = capability.codecType; |
| bestformatIndex = tmp; |
| } |
| } |
| } |
| else // Better frame rate |
| { |
| if (requested.codecType == capability.codecType) |
| { |
| |
| bestWidth = capability.width; |
| bestHeight = capability.height; |
| bestFrameRate = capability.maxFPS; |
| bestCodecType = capability.codecType; |
| bestRawType = capability.rawType; |
| bestformatIndex = tmp; |
| } |
| } |
| } |
| } |
| else // Better width than previously |
| { |
| if (requested.codecType == capability.codecType) |
| { |
| bestWidth = capability.width; |
| bestHeight = capability.height; |
| bestFrameRate = capability.maxFPS; |
| bestCodecType = capability.codecType; |
| bestRawType = capability.rawType; |
| bestformatIndex = tmp; |
| } |
| } |
| }// else width no good |
| } |
| else // Better height |
| { |
| if (requested.codecType == capability.codecType) |
| { |
| bestWidth = capability.width; |
| bestHeight = capability.height; |
| bestFrameRate = capability.maxFPS; |
| bestCodecType = capability.codecType; |
| bestRawType = capability.rawType; |
| bestformatIndex = tmp; |
| } |
| } |
| }// else height not good |
| }//end for |
| |
| LOG(LS_VERBOSE) << "Best camera format: " << bestWidth << "x" << bestHeight |
| << "@" << bestFrameRate |
| << "fps, color format: " << bestRawType; |
| |
| // Copy the capability |
| if (bestformatIndex < 0) |
| return -1; |
| resulting = _captureCapabilities[bestformatIndex]; |
| return bestformatIndex; |
| } |
| |
| /* Returns the expected Capture delay*/ |
| int32_t DeviceInfoImpl::GetExpectedCaptureDelay( |
| const DelayValues delayValues[], |
| const uint32_t sizeOfDelayValues, |
| const char* productId, |
| const uint32_t width, |
| const uint32_t height) |
| { |
| int32_t bestDelay = kDefaultCaptureDelay; |
| |
| for (uint32_t device = 0; device < sizeOfDelayValues; ++device) |
| { |
| if (delayValues[device].productId && strncmp((char*) productId, |
| (char*) delayValues[device].productId, |
| kVideoCaptureProductIdLength) == 0) |
| { |
| // We have found the camera |
| |
| int32_t bestWidth = 0; |
| int32_t bestHeight = 0; |
| |
| //Loop through all tested sizes and find one that seems fitting |
| for (uint32_t delayIndex = 0; delayIndex < NoOfDelayValues; ++delayIndex) |
| { |
| const DelayValue& currentValue = delayValues[device].delayValues[delayIndex]; |
| |
| const int32_t diffWidth = currentValue.width - width; |
| const int32_t diffHeight = currentValue.height - height; |
| |
| const int32_t currentbestDiffWith = bestWidth - width; |
| const int32_t currentbestDiffHeight = bestHeight - height; |
| |
| if ((diffHeight >= 0 && diffHeight <= abs(currentbestDiffHeight)) // Height better or equal than previous. |
| || (currentbestDiffHeight < 0 && diffHeight >= currentbestDiffHeight)) |
| { |
| |
| if (diffHeight == currentbestDiffHeight) // Found best height. Care about the width) |
| { |
| if ((diffWidth >= 0 && diffWidth <= abs(currentbestDiffWith)) // Width better or equal |
| || (currentbestDiffWith < 0 && diffWidth >= currentbestDiffWith)) |
| { |
| if (diffWidth == currentbestDiffWith && diffHeight |
| == currentbestDiffHeight) // Same size as previous |
| { |
| } |
| else // Better width than previously |
| { |
| bestWidth = currentValue.width; |
| bestHeight = currentValue.height; |
| bestDelay = currentValue.delay; |
| } |
| }// else width no good |
| } |
| else // Better height |
| { |
| bestWidth = currentValue.width; |
| bestHeight = currentValue.height; |
| bestDelay = currentValue.delay; |
| } |
| }// else height not good |
| }//end for |
| break; |
| } |
| } |
| if (bestDelay > kMaxCaptureDelay) |
| { |
| LOG(LS_WARNING) << "Expected capture delay (" << bestDelay |
| << " ms) too high, using " << kMaxCaptureDelay |
| << " ms."; |
| bestDelay = kMaxCaptureDelay; |
| } |
| |
| return bestDelay; |
| |
| } |
| |
| //Default implementation. This should be overridden by Mobile implementations. |
| int32_t DeviceInfoImpl::GetOrientation(const char* deviceUniqueIdUTF8, |
| VideoRotation& orientation) { |
| orientation = kVideoRotation_0; |
| return -1; |
| } |
| } // namespace videocapturemodule |
| } // namespace webrtc |
