generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

WebRtc_Word32 -> int32_t in video_capture/

Browse Source 
BUG=314

Review URL: https://webrtc-codereview.appspot.com/1298005

git-svn-id: http://webrtc.googlecode.com/svn/trunk@3811 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
pbos@webrtc.org 2013-04-10 08:23:13 +00:00
parent ddf94e71e5
commit dfc5bb9c97
42 changed files with 642 additions and 650 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
webrtc/modules/video_capture/android/device_info_android.cc
View File

@ -30,7 +30,7 @@ void DeviceInfoAndroid::SetAndroidCaptureClasses(jclass capabilityClass) {
}
VideoCaptureModule::DeviceInfo*
VideoCaptureImpl::CreateDeviceInfo (const WebRtc_Word32 id) {
VideoCaptureImpl::CreateDeviceInfo (const int32_t id) {
videocapturemodule::DeviceInfoAndroid *deviceInfo =
new videocapturemodule::DeviceInfoAndroid(id);
if (deviceInfo && deviceInfo->Init() != 0) {
@ -40,18 +40,18 @@ VideoCaptureImpl::CreateDeviceInfo (const WebRtc_Word32 id) {
return deviceInfo;
}
DeviceInfoAndroid::DeviceInfoAndroid(const WebRtc_Word32 id) :
DeviceInfoAndroid::DeviceInfoAndroid(const int32_t id) :
DeviceInfoImpl(id) {
}
WebRtc_Word32 DeviceInfoAndroid::Init() {
int32_t DeviceInfoAndroid::Init() {
return 0;
}
DeviceInfoAndroid::~DeviceInfoAndroid() {
}
WebRtc_UWord32 DeviceInfoAndroid::NumberOfDevices() {
uint32_t DeviceInfoAndroid::NumberOfDevices() {
JNIEnv *env;
jclass javaCmDevInfoClass;
jobject javaCmDevInfoObject;
@ -83,19 +83,19 @@ WebRtc_UWord32 DeviceInfoAndroid::NumberOfDevices() {
return 0;
}
WebRtc_Word32 DeviceInfoAndroid::GetDeviceName(
WebRtc_UWord32 deviceNumber,
int32_t DeviceInfoAndroid::GetDeviceName(
uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* /*productUniqueIdUTF8*/,
WebRtc_UWord32 /*productUniqueIdUTF8Length*/) {
uint32_t /*productUniqueIdUTF8Length*/) {
JNIEnv *env;
jclass javaCmDevInfoClass;
jobject javaCmDevInfoObject;
WebRtc_Word32 result = 0;
int32_t result = 0;
bool attached = false;
if (VideoCaptureAndroid::AttachAndUseAndroidDeviceInfoObjects(
env,
@ -122,7 +122,7 @@ WebRtc_Word32 DeviceInfoAndroid::GetDeviceName(
,&isCopy);
const jsize javaDeviceNameCharLength =
env->GetStringUTFLength((jstring) javaDeviceNameObj);
if ((WebRtc_UWord32) javaDeviceNameCharLength <
if ((uint32_t) javaDeviceNameCharLength <
deviceUniqueIdUTF8Length) {
memcpy(deviceUniqueIdUTF8,
javaDeviceNameChar,
@ -134,7 +134,7 @@ WebRtc_Word32 DeviceInfoAndroid::GetDeviceName(
__FUNCTION__);
result = -1;
}
if ((WebRtc_UWord32) javaDeviceNameCharLength < deviceNameLength) {
if ((uint32_t) javaDeviceNameCharLength < deviceNameLength) {
memcpy(deviceNameUTF8,
javaDeviceNameChar,
javaDeviceNameCharLength + 1);
@ -159,7 +159,7 @@ WebRtc_Word32 DeviceInfoAndroid::GetDeviceName(
}
WebRtc_Word32 DeviceInfoAndroid::CreateCapabilityMap(
int32_t DeviceInfoAndroid::CreateCapabilityMap(
const char* deviceUniqueIdUTF8) {
MapItem* item = NULL;
while ((item = _captureCapabilities.Last())) {
@ -264,7 +264,7 @@ WebRtc_Word32 DeviceInfoAndroid::CreateCapabilityMap(
return _captureCapabilities.Size();
}
WebRtc_Word32 DeviceInfoAndroid::GetOrientation(
int32_t DeviceInfoAndroid::GetOrientation(
const char* deviceUniqueIdUTF8,
VideoCaptureRotation& orientation) {
JNIEnv *env;
@ -301,7 +301,7 @@ WebRtc_Word32 DeviceInfoAndroid::GetOrientation(
capureIdString);
VideoCaptureAndroid::ReleaseAndroidDeviceInfoObjects(attached);
WebRtc_Word32 retValue = 0;
int32_t retValue = 0;
switch (jorientation) {
case -1: // Error
orientation = kCameraRotate0;

26
webrtc/modules/video_capture/android/device_info_android.h
View File

@ -30,27 +30,27 @@ class DeviceInfoAndroid : public DeviceInfoImpl {
public:
static void SetAndroidCaptureClasses(jclass capabilityClass);
DeviceInfoAndroid(const WebRtc_Word32 id);
WebRtc_Word32 Init();
DeviceInfoAndroid(const int32_t id);
int32_t Init();
virtual ~DeviceInfoAndroid();
virtual WebRtc_UWord32 NumberOfDevices();
virtual WebRtc_Word32 GetDeviceName(
WebRtc_UWord32 deviceNumber,
virtual uint32_t NumberOfDevices();
virtual int32_t GetDeviceName(
uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8 = 0,
WebRtc_UWord32 productUniqueIdUTF8Length = 0);
virtual WebRtc_Word32 CreateCapabilityMap(const char* deviceUniqueIdUTF8);
uint32_t productUniqueIdUTF8Length = 0);
virtual int32_t CreateCapabilityMap(const char* deviceUniqueIdUTF8);
virtual WebRtc_Word32 DisplayCaptureSettingsDialogBox(
virtual int32_t DisplayCaptureSettingsDialogBox(
const char* /*deviceUniqueIdUTF8*/,
const char* /*dialogTitleUTF8*/,
void* /*parentWindow*/,
WebRtc_UWord32 /*positionX*/,
WebRtc_UWord32 /*positionY*/) { return -1; }
virtual WebRtc_Word32 GetOrientation(const char* deviceUniqueIdUTF8,
uint32_t /*positionX*/,
uint32_t /*positionY*/) { return -1; }
virtual int32_t GetOrientation(const char* deviceUniqueIdUTF8,
VideoCaptureRotation& orientation);
private:
bool IsDeviceNameMatches(const char* name, const char* deviceUniqueIdUTF8);

28
webrtc/modules/video_capture/android/video_capture_android.cc
View File

@ -21,7 +21,7 @@ namespace webrtc
#if defined(WEBRTC_ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
// TODO(leozwang) These SetAndroidVM apis will be refactored, thus we only
// keep and reference java vm.
WebRtc_Word32 SetCaptureAndroidVM(void* javaVM, void* javaContext) {
int32_t SetCaptureAndroidVM(void* javaVM, void* javaContext) {
return videocapturemodule::VideoCaptureAndroid::SetAndroidObjects(
javaVM,
javaContext);
@ -32,7 +32,7 @@ namespace videocapturemodule
{
VideoCaptureModule* VideoCaptureImpl::Create(
const WebRtc_Word32 id,
const int32_t id,
const char* deviceUniqueIdUTF8) {
RefCountImpl<videocapturemodule::VideoCaptureAndroid>* implementation =
@ -64,7 +64,7 @@ jobject VideoCaptureAndroid::g_javaContext = NULL;
/*
* Register references to Java Capture class.
*/
WebRtc_Word32 VideoCaptureAndroid::SetAndroidObjects(void* javaVM,
int32_t VideoCaptureAndroid::SetAndroidObjects(void* javaVM,
void* javaContext) {
g_jvm = static_cast<JavaVM*> (javaVM);
@ -232,7 +232,7 @@ WebRtc_Word32 VideoCaptureAndroid::SetAndroidObjects(void* javaVM,
return 0;
}
WebRtc_Word32 VideoCaptureAndroid::AttachAndUseAndroidDeviceInfoObjects(
int32_t VideoCaptureAndroid::AttachAndUseAndroidDeviceInfoObjects(
JNIEnv*& env,
jclass& javaCmDevInfoClass,
jobject& javaCmDevInfoObject,
@ -263,7 +263,7 @@ WebRtc_Word32 VideoCaptureAndroid::AttachAndUseAndroidDeviceInfoObjects(
}
WebRtc_Word32 VideoCaptureAndroid::ReleaseAndroidDeviceInfoObjects(
int32_t VideoCaptureAndroid::ReleaseAndroidDeviceInfoObjects(
bool attached) {
if (attached && g_jvm->DetachCurrentThread() < 0) {
WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, -1,
@ -290,14 +290,14 @@ void JNICALL VideoCaptureAndroid::ProvideCameraFrame(JNIEnv * env,
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture,
-1, "%s: IncomingFrame %d", __FUNCTION__,length);
jbyte* cameraFrame= env->GetByteArrayElements(javaCameraFrame,NULL);
captureModule->IncomingFrame((WebRtc_UWord8*) cameraFrame,
captureModule->IncomingFrame((uint8_t*) cameraFrame,
length,captureModule->_frameInfo,0);
env->ReleaseByteArrayElements(javaCameraFrame,cameraFrame,JNI_ABORT);
}
VideoCaptureAndroid::VideoCaptureAndroid(const WebRtc_Word32 id)
VideoCaptureAndroid::VideoCaptureAndroid(const int32_t id)
: VideoCaptureImpl(id), _capInfo(id), _javaCaptureObj(NULL),
_captureStarted(false) {
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, -1,
@ -310,7 +310,7 @@ VideoCaptureAndroid::VideoCaptureAndroid(const WebRtc_Word32 id)
// Initializes needed Java resources like the JNI interface to
// VideoCaptureAndroid.java
// ----------------------------------------------------------------------------
WebRtc_Word32 VideoCaptureAndroid::Init(const WebRtc_Word32 id,
int32_t VideoCaptureAndroid::Init(const int32_t id,
const char* deviceUniqueIdUTF8) {
const int nameLength = strlen(deviceUniqueIdUTF8);
if (nameLength >= kVideoCaptureUniqueNameLength) {
@ -468,14 +468,14 @@ VideoCaptureAndroid::~VideoCaptureAndroid() {
}
}
WebRtc_Word32 VideoCaptureAndroid::StartCapture(
int32_t VideoCaptureAndroid::StartCapture(
const VideoCaptureCapability& capability) {
CriticalSectionScoped cs(&_apiCs);
WEBRTC_TRACE(webrtc::kTraceStateInfo, webrtc::kTraceVideoCapture, -1,
"%s: ", __FUNCTION__);
bool isAttached = false;
WebRtc_Word32 result = 0;
int32_t result = 0;
// get the JNI env for this thread
JNIEnv *env;
if (g_jvm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
@ -538,13 +538,13 @@ WebRtc_Word32 VideoCaptureAndroid::StartCapture(
return result;
}
WebRtc_Word32 VideoCaptureAndroid::StopCapture() {
int32_t VideoCaptureAndroid::StopCapture() {
CriticalSectionScoped cs(&_apiCs);
WEBRTC_TRACE(webrtc::kTraceStateInfo, webrtc::kTraceVideoCapture, -1,
"%s: ", __FUNCTION__);
bool isAttached = false;
WebRtc_Word32 result = 0;
int32_t result = 0;
// get the JNI env for this thread
JNIEnv *env = NULL;
if (g_jvm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
@ -598,7 +598,7 @@ bool VideoCaptureAndroid::CaptureStarted() {
return _captureStarted;
}
WebRtc_Word32 VideoCaptureAndroid::CaptureSettings(
int32_t VideoCaptureAndroid::CaptureSettings(
VideoCaptureCapability& settings) {
CriticalSectionScoped cs(&_apiCs);
WEBRTC_TRACE(webrtc::kTraceStateInfo, webrtc::kTraceVideoCapture, -1,
@ -607,7 +607,7 @@ WebRtc_Word32 VideoCaptureAndroid::CaptureSettings(
return 0;
}
WebRtc_Word32 VideoCaptureAndroid::SetCaptureRotation(
int32_t VideoCaptureAndroid::SetCaptureRotation(
VideoCaptureRotation rotation) {
CriticalSectionScoped cs(&_apiCs);
if (VideoCaptureImpl::SetCaptureRotation(rotation) == 0) {

19
webrtc/modules/video_capture/android/video_capture_android.h
View File

@ -22,25 +22,24 @@ namespace videocapturemodule {
class VideoCaptureAndroid : public VideoCaptureImpl {
public:
static WebRtc_Word32 SetAndroidObjects(void* javaVM, void* javaContext);
static WebRtc_Word32 AttachAndUseAndroidDeviceInfoObjects(
static int32_t SetAndroidObjects(void* javaVM, void* javaContext);
static int32_t AttachAndUseAndroidDeviceInfoObjects(
JNIEnv*& env,
jclass& javaCmDevInfoClass,
jobject& javaCmDevInfoObject,
bool& attached);
static WebRtc_Word32 ReleaseAndroidDeviceInfoObjects(bool attached);
static int32_t ReleaseAndroidDeviceInfoObjects(bool attached);
VideoCaptureAndroid(const WebRtc_Word32 id);
virtual WebRtc_Word32 Init(const WebRtc_Word32 id,
const char* deviceUniqueIdUTF8);
VideoCaptureAndroid(const int32_t id);
virtual int32_t Init(const int32_t id, const char* deviceUniqueIdUTF8);
virtual WebRtc_Word32 StartCapture(
virtual int32_t StartCapture(
const VideoCaptureCapability& capability);
virtual WebRtc_Word32 StopCapture();
virtual int32_t StopCapture();
virtual bool CaptureStarted();
virtual WebRtc_Word32 CaptureSettings(VideoCaptureCapability& settings);
virtual WebRtc_Word32 SetCaptureRotation(VideoCaptureRotation rotation);
virtual int32_t CaptureSettings(VideoCaptureCapability& settings);
virtual int32_t SetCaptureRotation(VideoCaptureRotation rotation);
protected:
virtual ~VideoCaptureAndroid();

64
webrtc/modules/video_capture/device_info_impl.cc
View File

@ -21,7 +21,7 @@ namespace webrtc
{
namespace videocapturemodule
{
DeviceInfoImpl::DeviceInfoImpl(const WebRtc_Word32 id)
DeviceInfoImpl::DeviceInfoImpl(const int32_t id)
: _id(id), _apiLock(*RWLockWrapper::CreateRWLock()), _lastUsedDeviceName(NULL),
_lastUsedDeviceNameLength(0)
{
@ -42,7 +42,7 @@ DeviceInfoImpl::~DeviceInfoImpl(void)
delete &_apiLock;
}
WebRtc_Word32 DeviceInfoImpl::NumberOfCapabilities(
int32_t DeviceInfoImpl::NumberOfCapabilities(
const char* deviceUniqueIdUTF8)
{
@ -73,12 +73,12 @@ WebRtc_Word32 DeviceInfoImpl::NumberOfCapabilities(
_apiLock.ReleaseLockShared();
WriteLockScoped cs2(_apiLock);
WebRtc_Word32 ret = CreateCapabilityMap(deviceUniqueIdUTF8);
int32_t ret = CreateCapabilityMap(deviceUniqueIdUTF8);
return ret;
}
WebRtc_Word32 DeviceInfoImpl::GetCapability(const char* deviceUniqueIdUTF8,
const WebRtc_UWord32 deviceCapabilityNumber,
int32_t DeviceInfoImpl::GetCapability(const char* deviceUniqueIdUTF8,
const uint32_t deviceCapabilityNumber,
VideoCaptureCapability& capability)
{
@ -143,7 +143,7 @@ WebRtc_Word32 DeviceInfoImpl::GetCapability(const char* deviceUniqueIdUTF8,
return 0;
}
WebRtc_Word32 DeviceInfoImpl::GetBestMatchedCapability(
int32_t DeviceInfoImpl::GetBestMatchedCapability(
const char*deviceUniqueIdUTF8,
const VideoCaptureCapability& requested,
VideoCaptureCapability& resulting)
@ -175,16 +175,16 @@ WebRtc_Word32 DeviceInfoImpl::GetBestMatchedCapability(
_apiLock.AcquireLockShared();
}
WebRtc_Word32 bestformatIndex = -1;
WebRtc_Word32 bestWidth = 0;
WebRtc_Word32 bestHeight = 0;
WebRtc_Word32 bestFrameRate = 0;
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 WebRtc_Word32 numberOfCapabilies = _captureCapabilities.Size();
const int32_t numberOfCapabilies = _captureCapabilities.Size();
for (WebRtc_Word32 tmp = 0; tmp < numberOfCapabilies; ++tmp) // Loop through all capabilities
for (int32_t tmp = 0; tmp < numberOfCapabilies; ++tmp) // Loop through all capabilities
{
MapItem* item = _captureCapabilities.Find(tmp);
if (!item)
@ -193,13 +193,13 @@ WebRtc_Word32 DeviceInfoImpl::GetBestMatchedCapability(
VideoCaptureCapability& capability = *static_cast<VideoCaptureCapability*>
(item->GetItem());
const WebRtc_Word32 diffWidth = capability.width - requested.width;
const WebRtc_Word32 diffHeight = capability.height - requested.height;
const WebRtc_Word32 diffFrameRate = capability.maxFPS - requested.maxFPS;
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 WebRtc_Word32 currentbestDiffWith = bestWidth - requested.width;
const WebRtc_Word32 currentbestDiffHeight = bestHeight - requested.height;
const WebRtc_Word32 currentbestDiffFrameRate = bestFrameRate - 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))
@ -311,16 +311,16 @@ WebRtc_Word32 DeviceInfoImpl::GetBestMatchedCapability(
}
/* Returns the expected Capture delay*/
WebRtc_Word32 DeviceInfoImpl::GetExpectedCaptureDelay(
int32_t DeviceInfoImpl::GetExpectedCaptureDelay(
const DelayValues delayValues[],
const WebRtc_UWord32 sizeOfDelayValues,
const uint32_t sizeOfDelayValues,
const char* productId,
const WebRtc_UWord32 width,
const WebRtc_UWord32 height)
const uint32_t width,
const uint32_t height)
{
WebRtc_Word32 bestDelay = kDefaultCaptureDelay;
int32_t bestDelay = kDefaultCaptureDelay;
for (WebRtc_UWord32 device = 0; device < sizeOfDelayValues; ++device)
for (uint32_t device = 0; device < sizeOfDelayValues; ++device)
{
if (delayValues[device].productId && strncmp((char*) productId,
(char*) delayValues[device].productId,
@ -328,19 +328,19 @@ WebRtc_Word32 DeviceInfoImpl::GetExpectedCaptureDelay(
{
// We have found the camera
WebRtc_Word32 bestWidth = 0;
WebRtc_Word32 bestHeight = 0;
int32_t bestWidth = 0;
int32_t bestHeight = 0;
//Loop through all tested sizes and find one that seems fitting
for (WebRtc_UWord32 delayIndex = 0; delayIndex < NoOfDelayValues; ++delayIndex)
for (uint32_t delayIndex = 0; delayIndex < NoOfDelayValues; ++delayIndex)
{
const DelayValue& currentValue = delayValues[device].delayValues[delayIndex];
const WebRtc_Word32 diffWidth = currentValue.width - width;
const WebRtc_Word32 diffHeight = currentValue.height - height;
const int32_t diffWidth = currentValue.width - width;
const int32_t diffHeight = currentValue.height - height;
const WebRtc_Word32 currentbestDiffWith = bestWidth - width;
const WebRtc_Word32 currentbestDiffHeight = bestHeight - 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))
@ -388,7 +388,7 @@ WebRtc_Word32 DeviceInfoImpl::GetExpectedCaptureDelay(
}
//Default implementation. This should be overridden by Mobile implementations.
WebRtc_Word32 DeviceInfoImpl::GetOrientation(const char* deviceUniqueIdUTF8,
int32_t DeviceInfoImpl::GetOrientation(const char* deviceUniqueIdUTF8,
VideoCaptureRotation& orientation)
{
orientation = kCameraRotate0;

28
webrtc/modules/video_capture/device_info_impl.h
View File

@ -24,44 +24,44 @@ namespace videocapturemodule
class DeviceInfoImpl: public VideoCaptureModule::DeviceInfo
{
public:
DeviceInfoImpl(const WebRtc_Word32 id);
DeviceInfoImpl(const int32_t id);
virtual ~DeviceInfoImpl(void);
virtual WebRtc_Word32 NumberOfCapabilities(const char* deviceUniqueIdUTF8);
virtual WebRtc_Word32 GetCapability(
virtual int32_t NumberOfCapabilities(const char* deviceUniqueIdUTF8);
virtual int32_t GetCapability(
const char* deviceUniqueIdUTF8,
const WebRtc_UWord32 deviceCapabilityNumber,
const uint32_t deviceCapabilityNumber,
VideoCaptureCapability& capability);
virtual WebRtc_Word32 GetBestMatchedCapability(
virtual int32_t GetBestMatchedCapability(
const char* deviceUniqueIdUTF8,
const VideoCaptureCapability& requested,
VideoCaptureCapability& resulting);
virtual WebRtc_Word32 GetOrientation(
virtual int32_t GetOrientation(
const char* deviceUniqueIdUTF8,
VideoCaptureRotation& orientation);
protected:
/* Initialize this object*/
virtual WebRtc_Word32 Init()=0;
virtual int32_t Init()=0;
/*
* Fills the member variable _captureCapabilities with capabilities for the given device name.
*/
virtual WebRtc_Word32 CreateCapabilityMap(const char* deviceUniqueIdUTF8)=0;
virtual int32_t CreateCapabilityMap(const char* deviceUniqueIdUTF8)=0;
/* Returns the expected Capture delay*/
WebRtc_Word32 GetExpectedCaptureDelay(const DelayValues delayValues[],
const WebRtc_UWord32 sizeOfDelayValues,
int32_t GetExpectedCaptureDelay(const DelayValues delayValues[],
const uint32_t sizeOfDelayValues,
const char* productId,
const WebRtc_UWord32 width,
const WebRtc_UWord32 height);
const uint32_t width,
const uint32_t height);
protected:
// Data members
WebRtc_Word32 _id;
int32_t _id;
MapWrapper _captureCapabilities;
RWLockWrapper& _apiLock;
char* _lastUsedDeviceName;
WebRtc_UWord32 _lastUsedDeviceNameLength;
uint32_t _lastUsedDeviceNameLength;
};
} //namespace videocapturemodule
} // namespace webrtc

26
webrtc/modules/video_capture/external/device_info_external.cc vendored
View File

@ -17,34 +17,34 @@ namespace videocapturemodule {
class ExternalDeviceInfo : public DeviceInfoImpl {
public:
ExternalDeviceInfo(const WebRtc_Word32 id)
ExternalDeviceInfo(const int32_t id)
: DeviceInfoImpl(id) {
}
virtual ~ExternalDeviceInfo() {}
virtual WebRtc_UWord32 NumberOfDevices() { return 0; }
virtual WebRtc_Word32 DisplayCaptureSettingsDialogBox(
virtual uint32_t NumberOfDevices() { return 0; }
virtual int32_t DisplayCaptureSettingsDialogBox(
const char* /*deviceUniqueIdUTF8*/,
const char* /*dialogTitleUTF8*/,
void* /*parentWindow*/,
WebRtc_UWord32 /*positionX*/,
WebRtc_UWord32 /*positionY*/) { return -1; }
virtual WebRtc_Word32 GetDeviceName(
WebRtc_UWord32 deviceNumber,
uint32_t /*positionX*/,
uint32_t /*positionY*/) { return -1; }
virtual int32_t GetDeviceName(
uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8=0,
WebRtc_UWord32 productUniqueIdUTF8Length=0) {
uint32_t productUniqueIdUTF8Length=0) {
return -1;
}
virtual WebRtc_Word32 CreateCapabilityMap(
virtual int32_t CreateCapabilityMap(
const char* deviceUniqueIdUTF8) { return 0; }
virtual WebRtc_Word32 Init() { return 0; }
virtual int32_t Init() { return 0; }
};
VideoCaptureModule::DeviceInfo* VideoCaptureImpl::CreateDeviceInfo(
const WebRtc_Word32 id) {
const int32_t id) {
return new ExternalDeviceInfo(id);
}

2
webrtc/modules/video_capture/external/video_capture_external.cc vendored
View File

@ -16,7 +16,7 @@ namespace webrtc {
namespace videocapturemodule {
VideoCaptureModule* VideoCaptureImpl::Create(
const WebRtc_Word32 id,
const int32_t id,
const char* deviceUniqueIdUTF8) {
RefCountImpl<VideoCaptureImpl>* implementation =
new RefCountImpl<VideoCaptureImpl>(id);

66
webrtc/modules/video_capture/include/video_capture.h
View File

@ -17,7 +17,7 @@
namespace webrtc {
#if defined(WEBRTC_ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
WebRtc_Word32 SetCaptureAndroidVM(void* javaVM, void* javaContext);
int32_t SetCaptureAndroidVM(void* javaVM, void* javaContext);
#endif
class VideoCaptureModule: public RefCountedModule {
@ -25,7 +25,7 @@ class VideoCaptureModule: public RefCountedModule {
// Interface for receiving information about available camera devices.
class DeviceInfo {
public:
virtual WebRtc_UWord32 NumberOfDevices() = 0;
virtual uint32_t NumberOfDevices() = 0;
// Returns the available capture devices.
// deviceNumber - Index of capture device.
@ -34,93 +34,91 @@ class VideoCaptureModule: public RefCountedModule {
// Otherwise same as deviceNameUTF8.
// productUniqueIdUTF8 - Unique product id if it exist.
// Null terminated otherwise.
virtual WebRtc_Word32 GetDeviceName(
WebRtc_UWord32 deviceNumber,
virtual int32_t GetDeviceName(
uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8 = 0,
WebRtc_UWord32 productUniqueIdUTF8Length = 0) = 0;
uint32_t productUniqueIdUTF8Length = 0) = 0;
// Returns the number of capabilities this device.
virtual WebRtc_Word32 NumberOfCapabilities(
virtual int32_t NumberOfCapabilities(
const char* deviceUniqueIdUTF8) = 0;
// Gets the capabilities of the named device.
virtual WebRtc_Word32 GetCapability(
virtual int32_t GetCapability(
const char* deviceUniqueIdUTF8,
const WebRtc_UWord32 deviceCapabilityNumber,
const uint32_t deviceCapabilityNumber,
VideoCaptureCapability& capability) = 0;
// Gets clockwise angle the captured frames should be rotated in order
// to be displayed correctly on a normally rotated display.
virtual WebRtc_Word32 GetOrientation(
virtual int32_t GetOrientation(
const char* deviceUniqueIdUTF8,
VideoCaptureRotation& orientation) = 0;
// Gets the capability that best matches the requested width, height and
// frame rate.
// Returns the deviceCapabilityNumber on success.
virtual WebRtc_Word32 GetBestMatchedCapability(
virtual int32_t GetBestMatchedCapability(
const char* deviceUniqueIdUTF8,
const VideoCaptureCapability& requested,
VideoCaptureCapability& resulting) = 0;
// Display OS /capture device specific settings dialog
virtual WebRtc_Word32 DisplayCaptureSettingsDialogBox(
virtual int32_t DisplayCaptureSettingsDialogBox(
const char* deviceUniqueIdUTF8,
const char* dialogTitleUTF8,
void* parentWindow,
WebRtc_UWord32 positionX,
WebRtc_UWord32 positionY) = 0;
uint32_t positionX,
uint32_t positionY) = 0;
virtual ~DeviceInfo() {}
};
class VideoCaptureEncodeInterface {
public:
virtual WebRtc_Word32 ConfigureEncoder(const VideoCodec& codec,
WebRtc_UWord32 maxPayloadSize) = 0;
virtual int32_t ConfigureEncoder(const VideoCodec& codec,
uint32_t maxPayloadSize) = 0;
// Inform the encoder about the new target bit rate.
// - newBitRate : New target bit rate in Kbit/s.
// - frameRate : The target frame rate.
virtual WebRtc_Word32 SetRates(WebRtc_Word32 newBitRate,
WebRtc_Word32 frameRate) = 0;
virtual int32_t SetRates(int32_t newBitRate, int32_t frameRate) = 0;
// Inform the encoder about the packet loss and the round-trip time.
// - packetLoss : Fraction lost
// (loss rate in percent = 100 * packetLoss / 255).
// - rtt : Round-trip time in milliseconds.
virtual WebRtc_Word32 SetChannelParameters(WebRtc_UWord32 packetLoss,
int rtt) = 0;
virtual int32_t SetChannelParameters(uint32_t packetLoss, int rtt) = 0;
// Encode the next frame as key frame.
virtual WebRtc_Word32 EncodeFrameType(const FrameType type) = 0;
virtual int32_t EncodeFrameType(const FrameType type) = 0;
protected:
virtual ~VideoCaptureEncodeInterface() {
}
};
// Register capture data callback
virtual WebRtc_Word32 RegisterCaptureDataCallback(
virtual int32_t RegisterCaptureDataCallback(
VideoCaptureDataCallback& dataCallback) = 0;
// Remove capture data callback
virtual WebRtc_Word32 DeRegisterCaptureDataCallback() = 0;
virtual int32_t DeRegisterCaptureDataCallback() = 0;
// Register capture callback.
virtual WebRtc_Word32 RegisterCaptureCallback(
virtual int32_t RegisterCaptureCallback(
VideoCaptureFeedBack& callBack) = 0;
// Remove capture callback.
virtual WebRtc_Word32 DeRegisterCaptureCallback() = 0;
virtual int32_t DeRegisterCaptureCallback() = 0;
// Start capture device
virtual WebRtc_Word32 StartCapture(
virtual int32_t StartCapture(
const VideoCaptureCapability& capability) = 0;
virtual WebRtc_Word32 StopCapture() = 0;
virtual int32_t StopCapture() = 0;
// Returns the name of the device used by this module.
virtual const char* CurrentDeviceName() const = 0;
@ -129,26 +127,26 @@ class VideoCaptureModule: public RefCountedModule {
virtual bool CaptureStarted() = 0;
// Gets the current configuration.
virtual WebRtc_Word32 CaptureSettings(VideoCaptureCapability& settings) = 0;
virtual int32_t CaptureSettings(VideoCaptureCapability& settings) = 0;
virtual WebRtc_Word32 SetCaptureDelay(WebRtc_Word32 delayMS) = 0;
virtual int32_t SetCaptureDelay(int32_t delayMS) = 0;
// Returns the current CaptureDelay. Only valid when the camera is running.
virtual WebRtc_Word32 CaptureDelay() = 0;
virtual int32_t CaptureDelay() = 0;
// Set the rotation of the captured frames.
// If the rotation is set to the same as returned by
// DeviceInfo::GetOrientation the captured frames are
// displayed correctly if rendered.
virtual WebRtc_Word32 SetCaptureRotation(VideoCaptureRotation rotation) = 0;
virtual int32_t SetCaptureRotation(VideoCaptureRotation rotation) = 0;
// Gets a pointer to an encode interface if the capture device supports the
// requested type and size. NULL otherwise.
virtual VideoCaptureEncodeInterface* GetEncodeInterface(
const VideoCodec& codec) = 0;
virtual WebRtc_Word32 EnableFrameRateCallback(const bool enable) = 0;
virtual WebRtc_Word32 EnableNoPictureAlarm(const bool enable) = 0;
virtual int32_t EnableFrameRateCallback(const bool enable) = 0;
virtual int32_t EnableNoPictureAlarm(const bool enable) = 0;
protected:
virtual ~VideoCaptureModule() {};

32
webrtc/modules/video_capture/include/video_capture_defines.h
View File

@ -37,10 +37,10 @@ enum VideoCaptureRotation
struct VideoCaptureCapability
{
WebRtc_Word32 width;
WebRtc_Word32 height;
WebRtc_Word32 maxFPS;
WebRtc_Word32 expectedCaptureDelay;
int32_t width;
int32_t height;
int32_t maxFPS;
int32_t expectedCaptureDelay;
RawVideoType rawType;
VideoCodecType codecType;
bool interlaced;
@ -117,12 +117,12 @@ struct VideoFrameI420
class VideoCaptureExternal
{
public:
virtual WebRtc_Word32 IncomingFrame(WebRtc_UWord8* videoFrame,
WebRtc_Word32 videoFrameLength,
virtual int32_t IncomingFrame(uint8_t* videoFrame,
int32_t videoFrameLength,
const VideoCaptureCapability& frameInfo,
WebRtc_Word64 captureTime = 0) = 0;
virtual WebRtc_Word32 IncomingFrameI420(const VideoFrameI420& video_frame,
WebRtc_Word64 captureTime = 0) = 0;
int64_t captureTime = 0) = 0;
virtual int32_t IncomingFrameI420(const VideoFrameI420& video_frame,
int64_t captureTime = 0) = 0;
protected:
~VideoCaptureExternal() {}
};
@ -131,13 +131,13 @@ protected:
class VideoCaptureDataCallback
{
public:
virtual void OnIncomingCapturedFrame(const WebRtc_Word32 id,
virtual void OnIncomingCapturedFrame(const int32_t id,
I420VideoFrame& videoFrame) = 0;
virtual void OnIncomingCapturedEncodedFrame(const WebRtc_Word32 id,
virtual void OnIncomingCapturedEncodedFrame(const int32_t id,
VideoFrame& videoFrame,
VideoCodecType codecType) = 0;
virtual void OnCaptureDelayChanged(const WebRtc_Word32 id,
const WebRtc_Word32 delay) = 0;
virtual void OnCaptureDelayChanged(const int32_t id,
const int32_t delay) = 0;
protected:
virtual ~VideoCaptureDataCallback(){}
};
@ -145,9 +145,9 @@ protected:
class VideoCaptureFeedBack
{
public:
virtual void OnCaptureFrameRate(const WebRtc_Word32 id,
const WebRtc_UWord32 frameRate) = 0;
virtual void OnNoPictureAlarm(const WebRtc_Word32 id,
virtual void OnCaptureFrameRate(const int32_t id,
const uint32_t frameRate) = 0;
virtual void OnNoPictureAlarm(const int32_t id,
const VideoCaptureAlarm alarm) = 0;
protected:
virtual ~VideoCaptureFeedBack(){}

8
webrtc/modules/video_capture/include/video_capture_factory.h
View File

@ -24,20 +24,20 @@ class VideoCaptureFactory {
// id - unique identifier of this video capture module object.
// deviceUniqueIdUTF8 - name of the device.
// Available names can be found by using GetDeviceName
static VideoCaptureModule* Create(const WebRtc_Word32 id,
static VideoCaptureModule* Create(const int32_t id,
const char* deviceUniqueIdUTF8);
// Create a video capture module object used for external capture.
// id - unique identifier of this video capture module object
// externalCapture - [out] interface to call when a new frame is captured.
static VideoCaptureModule* Create(const WebRtc_Word32 id,
static VideoCaptureModule* Create(const int32_t id,
VideoCaptureExternal*& externalCapture);
static VideoCaptureModule::DeviceInfo* CreateDeviceInfo(
const WebRtc_Word32 id);
const int32_t id);
#ifdef WEBRTC_ANDROID
static WebRtc_Word32 SetAndroidObjects(void* javaVM, void* javaContext);
static int32_t SetAndroidObjects(void* javaVM, void* javaContext);
#endif
private:

30
webrtc/modules/video_capture/linux/device_info_linux.cc
View File

@ -30,7 +30,7 @@ namespace webrtc
namespace videocapturemodule
{
VideoCaptureModule::DeviceInfo*
VideoCaptureImpl::CreateDeviceInfo(const WebRtc_Word32 id)
VideoCaptureImpl::CreateDeviceInfo(const int32_t id)
{
videocapturemodule::DeviceInfoLinux *deviceInfo =
new videocapturemodule::DeviceInfoLinux(id);
@ -42,12 +42,12 @@ VideoCaptureImpl::CreateDeviceInfo(const WebRtc_Word32 id)
return deviceInfo;
}
DeviceInfoLinux::DeviceInfoLinux(const WebRtc_Word32 id)
DeviceInfoLinux::DeviceInfoLinux(const int32_t id)
: DeviceInfoImpl(id)
{
}
WebRtc_Word32 DeviceInfoLinux::Init()
int32_t DeviceInfoLinux::Init()
{
return 0;
}
@ -56,11 +56,11 @@ DeviceInfoLinux::~DeviceInfoLinux()
{
}
WebRtc_UWord32 DeviceInfoLinux::NumberOfDevices()
uint32_t DeviceInfoLinux::NumberOfDevices()
{
WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCapture, _id, "%s", __FUNCTION__);
WebRtc_UWord32 count = 0;
uint32_t count = 0;
char device[20];
int fd = -1;
@ -78,19 +78,19 @@ WebRtc_UWord32 DeviceInfoLinux::NumberOfDevices()
return count;
}
WebRtc_Word32 DeviceInfoLinux::GetDeviceName(
WebRtc_UWord32 deviceNumber,
int32_t DeviceInfoLinux::GetDeviceName(
uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* /*productUniqueIdUTF8*/,
WebRtc_UWord32 /*productUniqueIdUTF8Length*/)
uint32_t /*productUniqueIdUTF8Length*/)
{
WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCapture, _id, "%s", __FUNCTION__);
// Travel through /dev/video [0-63]
WebRtc_UWord32 count = 0;
uint32_t count = 0;
char device[20];
int fd = -1;
bool found = false;
@ -160,15 +160,15 @@ WebRtc_Word32 DeviceInfoLinux::GetDeviceName(
return 0;
}
WebRtc_Word32 DeviceInfoLinux::CreateCapabilityMap(
int32_t DeviceInfoLinux::CreateCapabilityMap(
const char* deviceUniqueIdUTF8)
{
int fd;
char device[32];
bool found = false;
const WebRtc_Word32 deviceUniqueIdUTF8Length =
(WebRtc_Word32) strlen((char*) deviceUniqueIdUTF8);
const int32_t deviceUniqueIdUTF8Length =
(int32_t) strlen((char*) deviceUniqueIdUTF8);
if (deviceUniqueIdUTF8Length > kVideoCaptureUniqueNameLength)
{
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id, "Device name too long");
@ -250,7 +250,7 @@ bool DeviceInfoLinux::IsDeviceNameMatches(const char* name,
return false;
}
WebRtc_Word32 DeviceInfoLinux::FillCapabilityMap(int fd)
int32_t DeviceInfoLinux::FillCapabilityMap(int fd)
{
// set image format

26
webrtc/modules/video_capture/linux/device_info_linux.h
View File

@ -21,29 +21,29 @@ namespace videocapturemodule
class DeviceInfoLinux: public DeviceInfoImpl
{
public:
DeviceInfoLinux(const WebRtc_Word32 id);
DeviceInfoLinux(const int32_t id);
virtual ~DeviceInfoLinux();
virtual WebRtc_UWord32 NumberOfDevices();
virtual WebRtc_Word32 GetDeviceName(
WebRtc_UWord32 deviceNumber,
virtual uint32_t NumberOfDevices();
virtual int32_t GetDeviceName(
uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8=0,
WebRtc_UWord32 productUniqueIdUTF8Length=0);
uint32_t productUniqueIdUTF8Length=0);
/*
* Fills the membervariable _captureCapabilities with capabilites for the given device name.
*/
virtual WebRtc_Word32 CreateCapabilityMap (const char* deviceUniqueIdUTF8);
virtual WebRtc_Word32 DisplayCaptureSettingsDialogBox(
virtual int32_t CreateCapabilityMap (const char* deviceUniqueIdUTF8);
virtual int32_t DisplayCaptureSettingsDialogBox(
const char* /*deviceUniqueIdUTF8*/,
const char* /*dialogTitleUTF8*/,
void* /*parentWindow*/,
WebRtc_UWord32 /*positionX*/,
WebRtc_UWord32 /*positionY*/) { return -1;}
WebRtc_Word32 FillCapabilityMap(int fd);
WebRtc_Word32 Init();
uint32_t /*positionX*/,
uint32_t /*positionY*/) { return -1;}
int32_t FillCapabilityMap(int fd);
int32_t Init();
private:
bool IsDeviceNameMatches(const char* name, const char* deviceUniqueIdUTF8);

12
webrtc/modules/video_capture/linux/video_capture_linux.cc
View File

@ -31,7 +31,7 @@ namespace webrtc
{
namespace videocapturemodule
{
VideoCaptureModule* VideoCaptureImpl::Create(const WebRtc_Word32 id,
VideoCaptureModule* VideoCaptureImpl::Create(const int32_t id,
const char* deviceUniqueId)
{
RefCountImpl<videocapturemodule::VideoCaptureModuleV4L2>* implementation =
@ -46,7 +46,7 @@ VideoCaptureModule* VideoCaptureImpl::Create(const WebRtc_Word32 id,
return implementation;
}
VideoCaptureModuleV4L2::VideoCaptureModuleV4L2(const WebRtc_Word32 id)
VideoCaptureModuleV4L2::VideoCaptureModuleV4L2(const int32_t id)
: VideoCaptureImpl(id),
_captureThread(NULL),
_captureCritSect(CriticalSectionWrapper::CreateCriticalSection()),
@ -62,7 +62,7 @@ VideoCaptureModuleV4L2::VideoCaptureModuleV4L2(const WebRtc_Word32 id)
{
}
WebRtc_Word32 VideoCaptureModuleV4L2::Init(const char* deviceUniqueIdUTF8)
int32_t VideoCaptureModuleV4L2::Init(const char* deviceUniqueIdUTF8)
{
int len = strlen((const char*) deviceUniqueIdUTF8);
_deviceUniqueId = new (std::nothrow) char[len + 1];
@ -121,7 +121,7 @@ VideoCaptureModuleV4L2::~VideoCaptureModuleV4L2()
close(_deviceFd);
}
WebRtc_Word32 VideoCaptureModuleV4L2::StartCapture(
int32_t VideoCaptureModuleV4L2::StartCapture(
const VideoCaptureCapability& capability)
{
if (_captureStarted)
@ -298,7 +298,7 @@ WebRtc_Word32 VideoCaptureModuleV4L2::StartCapture(
return 0;
}
WebRtc_Word32 VideoCaptureModuleV4L2::StopCapture()
int32_t VideoCaptureModuleV4L2::StopCapture()
{
if (_captureThread) {
// Make sure the capture thread stop stop using the critsect.
@ -487,7 +487,7 @@ bool VideoCaptureModuleV4L2::CaptureProcess()
return true;
}
WebRtc_Word32 VideoCaptureModuleV4L2::CaptureSettings(VideoCaptureCapability& settings)
int32_t VideoCaptureModuleV4L2::CaptureSettings(VideoCaptureCapability& settings)
{
settings.width = _currentWidth;
settings.height = _currentHeight;

22
webrtc/modules/video_capture/linux/video_capture_linux.h
View File

@ -23,13 +23,13 @@ namespace videocapturemodule
class VideoCaptureModuleV4L2: public VideoCaptureImpl
{
public:
VideoCaptureModuleV4L2(WebRtc_Word32 id);
VideoCaptureModuleV4L2(int32_t id);
virtual ~VideoCaptureModuleV4L2();
virtual WebRtc_Word32 Init(const char* deviceUniqueId);
virtual WebRtc_Word32 StartCapture(const VideoCaptureCapability& capability);
virtual WebRtc_Word32 StopCapture();
virtual int32_t Init(const char* deviceUniqueId);
virtual int32_t StartCapture(const VideoCaptureCapability& capability);
virtual int32_t StopCapture();
virtual bool CaptureStarted();
virtual WebRtc_Word32 CaptureSettings(VideoCaptureCapability& settings);
virtual int32_t CaptureSettings(VideoCaptureCapability& settings);
private:
enum {kNoOfV4L2Bufffers=4};
@ -42,13 +42,13 @@ private:
ThreadWrapper* _captureThread;
CriticalSectionWrapper* _captureCritSect;
WebRtc_Word32 _deviceId;
WebRtc_Word32 _deviceFd;
int32_t _deviceId;
int32_t _deviceFd;
WebRtc_Word32 _buffersAllocatedByDevice;
WebRtc_Word32 _currentWidth;
WebRtc_Word32 _currentHeight;
WebRtc_Word32 _currentFrameRate;
int32_t _buffersAllocatedByDevice;
int32_t _currentWidth;
int32_t _currentHeight;
int32_t _currentFrameRate;
bool _captureStarted;
RawVideoType _captureVideoType;
struct Buffer

23
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h
View File

@ -32,7 +32,7 @@ namespace videocapturemodule
class VideoCaptureMacQTKit : public VideoCaptureImpl
{
public:
VideoCaptureMacQTKit(const WebRtc_Word32 id);
VideoCaptureMacQTKit(const int32_t id);
virtual ~VideoCaptureMacQTKit();
/*
@ -45,37 +45,36 @@ public:
*/
static void Destroy(VideoCaptureModule* module);
WebRtc_Word32 Init(const WebRtc_Word32 id,
const char* deviceUniqueIdUTF8);
int32_t Init(const int32_t id, const char* deviceUniqueIdUTF8);
// Start/Stop
virtual WebRtc_Word32 StartCapture(
virtual int32_t StartCapture(
const VideoCaptureCapability& capability);
virtual WebRtc_Word32 StopCapture();
virtual int32_t StopCapture();
// Properties of the set device
virtual bool CaptureStarted();
WebRtc_Word32 CaptureSettings(VideoCaptureCapability& settings);
int32_t CaptureSettings(VideoCaptureCapability& settings);
protected:
// Help functions
WebRtc_Word32 SetCameraOutput();
int32_t SetCameraOutput();
private:
VideoCaptureMacQTKitObjC* _captureDevice;
VideoCaptureMacQTKitInfoObjC* _captureInfo;
bool _isCapturing;
WebRtc_Word32 _id;
WebRtc_Word32 _captureWidth;
WebRtc_Word32 _captureHeight;
WebRtc_Word32 _captureFrameRate;
int32_t _id;
int32_t _captureWidth;
int32_t _captureHeight;
int32_t _captureFrameRate;
char _currentDeviceNameUTF8[MAX_NAME_LENGTH];
char _currentDeviceUniqueIdUTF8[MAX_NAME_LENGTH];
char _currentDeviceProductUniqueIDUTF8[MAX_NAME_LENGTH];
WebRtc_Word32 _frameCount;
int32_t _frameCount;
};
} // namespace videocapturemodule
} // namespace webrtc

16
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.mm
View File

@ -21,7 +21,7 @@ namespace webrtc
namespace videocapturemodule
{
VideoCaptureMacQTKit::VideoCaptureMacQTKit(const WebRtc_Word32 id) :
VideoCaptureMacQTKit::VideoCaptureMacQTKit(const int32_t id) :
VideoCaptureImpl(id),
_captureDevice(NULL),
_captureInfo(NULL),
@ -55,14 +55,14 @@ VideoCaptureMacQTKit::~VideoCaptureMacQTKit()
}
}
WebRtc_Word32 VideoCaptureMacQTKit::Init(
const WebRtc_Word32 id, const char* iDeviceUniqueIdUTF8)
int32_t VideoCaptureMacQTKit::Init(
const int32_t id, const char* iDeviceUniqueIdUTF8)
{
CriticalSectionScoped cs(&_apiCs);
const WebRtc_Word32 nameLength =
(WebRtc_Word32) strlen((char*)iDeviceUniqueIdUTF8);
const int32_t nameLength =
(int32_t) strlen((char*)iDeviceUniqueIdUTF8);
if(nameLength>kVideoCaptureUniqueNameLength)
return -1;
@ -165,7 +165,7 @@ WebRtc_Word32 VideoCaptureMacQTKit::Init(
return 0;
}
WebRtc_Word32 VideoCaptureMacQTKit::StartCapture(
int32_t VideoCaptureMacQTKit::StartCapture(
const VideoCaptureCapability& capability)
{
@ -191,7 +191,7 @@ WebRtc_Word32 VideoCaptureMacQTKit::StartCapture(
return 0;
}
WebRtc_Word32 VideoCaptureMacQTKit::StopCapture()
int32_t VideoCaptureMacQTKit::StopCapture()
{
[_captureDevice stopCapture];
@ -204,7 +204,7 @@ bool VideoCaptureMacQTKit::CaptureStarted()
return _isCapturing;
}
WebRtc_Word32 VideoCaptureMacQTKit::CaptureSettings(VideoCaptureCapability& settings)
int32_t VideoCaptureMacQTKit::CaptureSettings(VideoCaptureCapability& settings)
{
settings.width = _captureWidth;
settings.height = _captureHeight;

30
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.h
View File

@ -29,12 +29,12 @@ class VideoCaptureMacQTKitInfo: public DeviceInfoImpl
{
public:
VideoCaptureMacQTKitInfo(const WebRtc_Word32 id);
VideoCaptureMacQTKitInfo(const int32_t id);
virtual ~VideoCaptureMacQTKitInfo();
WebRtc_Word32 Init();
int32_t Init();
virtual WebRtc_UWord32 NumberOfDevices();
virtual uint32_t NumberOfDevices();
/*
* Returns the available capture devices.
@ -45,32 +45,32 @@ public:
* productUniqueIdUTF8 - unique product id if it exist. Null terminated
* otherwise.
*/
virtual WebRtc_Word32 GetDeviceName(
WebRtc_UWord32 deviceNumber, char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength, char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
virtual int32_t GetDeviceName(
uint32_t deviceNumber, char* deviceNameUTF8,
uint32_t deviceNameLength, char* deviceUniqueIdUTF8,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8 = 0,
WebRtc_UWord32 productUniqueIdUTF8Length = 0);
uint32_t productUniqueIdUTF8Length = 0);
/*
* Returns the number of capabilities for this device
*/
virtual WebRtc_Word32 NumberOfCapabilities(
virtual int32_t NumberOfCapabilities(
const char* deviceUniqueIdUTF8);
/*
* Gets the capabilities of the named device
*/
virtual WebRtc_Word32 GetCapability(
virtual int32_t GetCapability(
const char* deviceUniqueIdUTF8,
const WebRtc_UWord32 deviceCapabilityNumber,
const uint32_t deviceCapabilityNumber,
VideoCaptureCapability& capability);
/*
* Gets the capability that best matches the requested width, height and frame rate.
* Returns the deviceCapabilityNumber on success.
*/
virtual WebRtc_Word32 GetBestMatchedCapability(
virtual int32_t GetBestMatchedCapability(
const char* deviceUniqueIdUTF8,
const VideoCaptureCapability& requested,
VideoCaptureCapability& resulting);
@ -78,13 +78,13 @@ public:
/*
* Display OS /capture device specific settings dialog
*/
virtual WebRtc_Word32 DisplayCaptureSettingsDialogBox(
virtual int32_t DisplayCaptureSettingsDialogBox(
const char* deviceUniqueIdUTF8,
const char* dialogTitleUTF8, void* parentWindow,
WebRtc_UWord32 positionX, WebRtc_UWord32 positionY);
uint32_t positionX, uint32_t positionY);
protected:
virtual WebRtc_Word32 CreateCapabilityMap(
virtual int32_t CreateCapabilityMap(
const char* deviceUniqueIdUTF8);
VideoCaptureMacQTKitInfoObjC* _captureInfo;

32
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.mm
View File

@ -19,7 +19,7 @@ namespace webrtc
namespace videocapturemodule
{
VideoCaptureMacQTKitInfo::VideoCaptureMacQTKitInfo(const WebRtc_Word32 id) :
VideoCaptureMacQTKitInfo::VideoCaptureMacQTKitInfo(const int32_t id) :
DeviceInfoImpl(id)
{
_captureInfo = [[VideoCaptureMacQTKitInfoObjC alloc] init];
@ -31,26 +31,26 @@ VideoCaptureMacQTKitInfo::~VideoCaptureMacQTKitInfo()
}
WebRtc_Word32 VideoCaptureMacQTKitInfo::Init()
int32_t VideoCaptureMacQTKitInfo::Init()
{
return 0;
}
WebRtc_UWord32 VideoCaptureMacQTKitInfo::NumberOfDevices()
uint32_t VideoCaptureMacQTKitInfo::NumberOfDevices()
{
WebRtc_UWord32 captureDeviceCount =
uint32_t captureDeviceCount =
[[_captureInfo getCaptureDeviceCount]intValue];
return captureDeviceCount;
}
WebRtc_Word32 VideoCaptureMacQTKitInfo::GetDeviceName(
WebRtc_UWord32 deviceNumber, char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength, char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length, char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length)
int32_t VideoCaptureMacQTKitInfo::GetDeviceName(
uint32_t deviceNumber, char* deviceNameUTF8,
uint32_t deviceNameLength, char* deviceUniqueIdUTF8,
uint32_t deviceUniqueIdUTF8Length, char* productUniqueIdUTF8,
uint32_t productUniqueIdUTF8Length)
{
int errNum = [[_captureInfo getDeviceNamesFromIndex:deviceNumber
DefaultName:deviceNameUTF8 WithLength:deviceNameLength
@ -61,7 +61,7 @@ WebRtc_Word32 VideoCaptureMacQTKitInfo::GetDeviceName(
return errNum;
}
WebRtc_Word32 VideoCaptureMacQTKitInfo::NumberOfCapabilities(
int32_t VideoCaptureMacQTKitInfo::NumberOfCapabilities(
const char* deviceUniqueIdUTF8)
{
// Not implemented. Mac doesn't use discrete steps in capabilities, rather
@ -73,9 +73,9 @@ WebRtc_Word32 VideoCaptureMacQTKitInfo::NumberOfCapabilities(
}
WebRtc_Word32 VideoCaptureMacQTKitInfo::GetCapability(
int32_t VideoCaptureMacQTKitInfo::GetCapability(
const char* deviceUniqueIdUTF8,
const WebRtc_UWord32 deviceCapabilityNumber,
const uint32_t deviceCapabilityNumber,
VideoCaptureCapability& capability)
{
// Not implemented. Mac doesn't use discrete steps in capabilities, rather
@ -87,7 +87,7 @@ WebRtc_Word32 VideoCaptureMacQTKitInfo::GetCapability(
}
WebRtc_Word32 VideoCaptureMacQTKitInfo::GetBestMatchedCapability(
int32_t VideoCaptureMacQTKitInfo::GetBestMatchedCapability(
const char*deviceUniqueIdUTF8,
const VideoCaptureCapability& requested, VideoCaptureCapability& resulting)
{
@ -99,10 +99,10 @@ WebRtc_Word32 VideoCaptureMacQTKitInfo::GetBestMatchedCapability(
return -1;
}
WebRtc_Word32 VideoCaptureMacQTKitInfo::DisplayCaptureSettingsDialogBox(
int32_t VideoCaptureMacQTKitInfo::DisplayCaptureSettingsDialogBox(
const char* deviceUniqueIdUTF8,
const char* dialogTitleUTF8, void* parentWindow,
WebRtc_UWord32 positionX, WebRtc_UWord32 positionY)
uint32_t positionX, uint32_t positionY)
{
return [[_captureInfo
@ -112,7 +112,7 @@ WebRtc_Word32 VideoCaptureMacQTKitInfo::DisplayCaptureSettingsDialogBox(
intValue];
}
WebRtc_Word32 VideoCaptureMacQTKitInfo::CreateCapabilityMap(
int32_t VideoCaptureMacQTKitInfo::CreateCapabilityMap(
const char* deviceUniqueIdUTF8)
{
// Not implemented. Mac doesn't use discrete steps in capabilities, rather

12
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h
View File

@ -48,19 +48,19 @@
- (NSNumber*)getCaptureDeviceCount;
- (NSNumber*)getDeviceNamesFromIndex:(WebRtc_UWord32)index
- (NSNumber*)getDeviceNamesFromIndex:(uint32_t)index
DefaultName:(char*)deviceName
WithLength:(WebRtc_UWord32)deviceNameLength
WithLength:(uint32_t)deviceNameLength
AndUniqueID:(char*)deviceUniqueID
WithLength:(WebRtc_UWord32)deviceUniqueIDLength
WithLength:(uint32_t)deviceUniqueIDLength
AndProductID:(char*)deviceProductID
WithLength:(WebRtc_UWord32)deviceProductIDLength;
WithLength:(uint32_t)deviceProductIDLength;
- (NSNumber*)displayCaptureSettingsDialogBoxWithDevice:
(const char*)deviceUniqueIdUTF8
AndTitle:(const char*)dialogTitleUTF8
AndParentWindow:(void*) parentWindow AtX:(WebRtc_UWord32)positionX
AndY:(WebRtc_UWord32) positionY;
AndParentWindow:(void*) parentWindow AtX:(uint32_t)positionX
AndY:(uint32_t) positionY;
@end
#endif // WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_INFO_OBJC_H_

14
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.mm
View File

@ -52,8 +52,8 @@ using namespace webrtc;
- (NSNumber*)displayCaptureSettingsDialogBoxWithDevice:(const char*)deviceUniqueIdUTF8
AndTitle:(const char*)dialogTitleUTF8
AndParentWindow:(void*) parentWindow
AtX:(WebRtc_UWord32)positionX
AndY:(WebRtc_UWord32) positionY
AtX:(uint32_t)positionX
AndY:(uint32_t) positionY
{
NSString* strTitle = [NSString stringWithFormat:@"%s", dialogTitleUTF8];
NSString* strButton = @"Alright";
@ -73,20 +73,20 @@ using namespace webrtc;
}
- (NSNumber*)getDeviceNamesFromIndex:(WebRtc_UWord32)index
- (NSNumber*)getDeviceNamesFromIndex:(uint32_t)index
DefaultName:(char*)deviceName
WithLength:(WebRtc_UWord32)deviceNameLength
WithLength:(uint32_t)deviceNameLength
AndUniqueID:(char*)deviceUniqueID
WithLength:(WebRtc_UWord32)deviceUniqueIDLength
WithLength:(uint32_t)deviceUniqueIDLength
AndProductID:(char*)deviceProductID
WithLength:(WebRtc_UWord32)deviceProductIDLength
WithLength:(uint32_t)deviceProductIDLength
{
if(NO == _OSSupportedInfo)
{
return [NSNumber numberWithInt:0];
}
if(index >= (WebRtc_UWord32)_captureDeviceCountInfo)
if(index >= (uint32_t)_captureDeviceCountInfo)
{
return [NSNumber numberWithInt:-1];
}

34
webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.cc
View File

@ -26,7 +26,7 @@
namespace webrtc
{
VideoCaptureMacQuickTime::VideoCaptureMacQuickTime(WebRtc_Word32 iID) :
VideoCaptureMacQuickTime::VideoCaptureMacQuickTime(int32_t iID) :
VideoCaptureImpl(iID), // super class constructor
_id(iID),
_isCapturing(false),
@ -64,12 +64,12 @@ VideoCaptureMacQuickTime::~VideoCaptureMacQuickTime()
}
WebRtc_Word32 VideoCaptureMacQuickTime::Init(
const WebRtc_Word32 id, const char* deviceUniqueIdUTF8)
int32_t VideoCaptureMacQuickTime::Init(
const int32_t id, const char* deviceUniqueIdUTF8)
{
const WebRtc_Word32 nameLength =
(WebRtc_Word32) strlen((char*) deviceUniqueIdUTF8);
const int32_t nameLength =
(int32_t) strlen((char*) deviceUniqueIdUTF8);
if (nameLength > kVideoCaptureUniqueNameLength)
return -1;
@ -153,7 +153,7 @@ WebRtc_Word32 VideoCaptureMacQuickTime::Init(
return 0;
}
WebRtc_Word32 VideoCaptureMacQuickTime::StartCapture(
int32_t VideoCaptureMacQuickTime::StartCapture(
const VideoCaptureCapability& capability)
{
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id, "%s:%d "
@ -175,7 +175,7 @@ WebRtc_Word32 VideoCaptureMacQuickTime::StartCapture(
return 0;
}
WebRtc_Word32 VideoCaptureMacQuickTime::StopCapture()
int32_t VideoCaptureMacQuickTime::StopCapture()
{
if (VideoCaptureStop() == -1)
@ -191,7 +191,7 @@ bool VideoCaptureMacQuickTime::CaptureStarted()
return _isCapturing;
}
WebRtc_Word32 VideoCaptureMacQuickTime::CaptureSettings(
int32_t VideoCaptureMacQuickTime::CaptureSettings(
VideoCaptureCapability& settings)
{
settings.width = _captureCapability.width;
@ -1003,9 +1003,9 @@ int VideoCaptureMacQuickTime::SendFrame(SGChannel /*sgChannel*/, char* data,
// Will be set to true if we don't recognize the size and/or video
// format.
bool convertFrame = false;
WebRtc_Word32 width = 352;
WebRtc_Word32 height = 288;
WebRtc_Word32 frameSize = 0;
int32_t width = 352;
int32_t height = 288;
int32_t frameSize = 0;
VideoCaptureCapability captureCapability;
captureCapability.width = width;
@ -1042,8 +1042,8 @@ int VideoCaptureMacQuickTime::SendFrame(SGChannel /*sgChannel*/, char* data,
== _captureCapability.height)
{
// Ok format and size, send the frame to super class
IncomingFrame((WebRtc_UWord8*) data,
(WebRtc_Word32) frameSize, captureCapability,
IncomingFrame((uint8_t*) data,
(int32_t) frameSize, captureCapability,
TickTime::MillisecondTimestamp());
}
@ -1078,8 +1078,8 @@ int VideoCaptureMacQuickTime::SendFrame(SGChannel /*sgChannel*/, char* data,
Ptr capturedFrame = GetPixBaseAddr(pixMap);
// Send the converted frame out to super class
IncomingFrame((WebRtc_UWord8*) data,
(WebRtc_Word32) frameSize, captureCapability,
IncomingFrame((uint8_t*) data,
(int32_t) frameSize, captureCapability,
TickTime::MillisecondTimestamp());
// Unlock the image data to get ready for the next frame.
@ -1133,10 +1133,10 @@ int VideoCaptureMacQuickTime::SendFrame(SGChannel /*sgChannel*/, char* data,
int height = (*rgbPixMap)->bounds.bottom;
// 16 is for YUY2 format.
WebRtc_Word32 frameSize = (width * height * 16) >> 3;
int32_t frameSize = (width * height * 16) >> 3;
// Ok format and size, send the frame to super class
IncomingFrame((WebRtc_UWord8*) data, (WebRtc_Word32) frameSize,
IncomingFrame((uint8_t*) data, (int32_t) frameSize,
captureCapability, TickTime::MillisecondTimestamp());
UnlockPixels(rgbPixMap);

40
webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.h
View File

@ -18,38 +18,32 @@
#include <QuickTime/QuickTime.h>
#include "../../device_info_impl.h"
#include "../../video_capture_impl.h"
#include "list_wrapper.h"
#define START_CODEC_WIDTH 352
#define START_CODEC_HEIGHT 288
#define SLEEP(x) usleep(x * 1000);
namespace webrtc
{
namespace webrtc {
class CriticalSectionWrapper;
class EventWrapper;
class ThreadWrapper;
class VideoCaptureMacQuickTime : public VideoCaptureImpl
{
class VideoCaptureMacQuickTime : public VideoCaptureImpl {
public:
VideoCaptureMacQuickTime(const WebRtc_Word32 id);
VideoCaptureMacQuickTime(const int32_t id);
virtual ~VideoCaptureMacQuickTime();
static void Destroy(VideoCaptureModule* module);
WebRtc_Word32 Init(const WebRtc_Word32 id,
const WebRtc_UWord8* deviceUniqueIdUTF8);
virtual WebRtc_Word32 StartCapture(
const VideoCaptureCapability& capability);
virtual WebRtc_Word32 StopCapture();
int32_t Init(const int32_t id, const uint8_t* deviceUniqueIdUTF8);
virtual int32_t StartCapture(const VideoCaptureCapability& capability);
virtual int32_t StopCapture();
virtual bool CaptureStarted();
virtual WebRtc_Word32 CaptureSettings(VideoCaptureCapability& settings);
virtual int32_t CaptureSettings(VideoCaptureCapability& settings);
// TODO: remove?
int VideoCaptureInitThreadContext();
@ -63,19 +57,24 @@ protected:
private: // functions
struct VideoCaptureMacName
{
struct VideoCaptureMacName {
VideoCaptureMacName();
enum { kVideoCaptureMacNameMaxSize = 64};
enum {
kVideoCaptureMacNameMaxSize = 64
};
char _name[kVideoCaptureMacNameMaxSize];
CFIndex _size;
};
// Timeout value [ms] if we want to create a new device list or not
enum { kVideoCaptureDeviceListTimeout = 5000};
enum {
kVideoCaptureDeviceListTimeout = 5000
};
// Temporary constant allowing this size from builtin iSight webcams.
enum { kYuy2_1280_1024_length = 2621440};
enum {
kYuy2_1280_1024_length = 2621440
};
private:
@ -101,11 +100,10 @@ private:
int StopQuickTimeCapture(bool* wasCapturing = NULL);
static CFIndex PascalStringToCString(const unsigned char* pascalString,
char* cString,
CFIndex bufferSize);
char* cString, CFIndex bufferSize);
private : // variables
WebRtc_Word32 _id;
int32_t _id;
bool _isCapturing;
VideoCaptureCapability _captureCapability;
CriticalSectionWrapper* _grabberCritsect;

38
webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.cc
View File

@ -26,7 +26,7 @@ namespace webrtc
{
VideoCaptureMacQuickTimeInfo::VideoCaptureMacQuickTimeInfo(
const WebRtc_Word32 iID) :
const int32_t iID) :
DeviceInfoImpl(iID), _id(iID),
_grabberCritsect(CriticalSectionWrapper::CreateCriticalSection())
{
@ -36,13 +36,13 @@ VideoCaptureMacQuickTimeInfo::~VideoCaptureMacQuickTimeInfo()
{
}
WebRtc_Word32 VideoCaptureMacQuickTimeInfo::Init()
int32_t VideoCaptureMacQuickTimeInfo::Init()
{
return 0;
}
WebRtc_UWord32 VideoCaptureMacQuickTimeInfo::NumberOfDevices()
uint32_t VideoCaptureMacQuickTimeInfo::NumberOfDevices()
{
int numOfDevices = 0;
@ -62,11 +62,11 @@ WebRtc_UWord32 VideoCaptureMacQuickTimeInfo::NumberOfDevices()
return numOfDevices;
}
WebRtc_Word32 VideoCaptureMacQuickTimeInfo::GetDeviceName(
WebRtc_UWord32 deviceNumber, char* deviceNameUTF8,
WebRtc_UWord32 deviceNameUTF8Length, char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length, char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length)
int32_t VideoCaptureMacQuickTimeInfo::GetDeviceName(
uint32_t deviceNumber, char* deviceNameUTF8,
uint32_t deviceNameUTF8Length, char* deviceUniqueIdUTF8,
uint32_t deviceUniqueIdUTF8Length, char* productUniqueIdUTF8,
uint32_t productUniqueIdUTF8Length)
{
int numOfDevices = 0; // not needed for this function
@ -76,7 +76,7 @@ WebRtc_Word32 VideoCaptureMacQuickTimeInfo::GetDeviceName(
productUniqueIdUTF8Length, numOfDevices);
}
WebRtc_Word32 VideoCaptureMacQuickTimeInfo::NumberOfCapabilities(
int32_t VideoCaptureMacQuickTimeInfo::NumberOfCapabilities(
const char* deviceUniqueIdUTF8)
{
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
@ -84,9 +84,9 @@ WebRtc_Word32 VideoCaptureMacQuickTimeInfo::NumberOfCapabilities(
return -1;
}
WebRtc_Word32 VideoCaptureMacQuickTimeInfo::GetCapability(
int32_t VideoCaptureMacQuickTimeInfo::GetCapability(
const char* deviceUniqueIdUTF8,
const WebRtc_UWord32 deviceCapabilityNumber,
const uint32_t deviceCapabilityNumber,
VideoCaptureCapability& capability)
{
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
@ -94,7 +94,7 @@ WebRtc_Word32 VideoCaptureMacQuickTimeInfo::GetCapability(
return -1;
}
WebRtc_Word32 VideoCaptureMacQuickTimeInfo::GetBestMatchedCapability(
int32_t VideoCaptureMacQuickTimeInfo::GetBestMatchedCapability(
const char*deviceUniqueIdUTF8,
const VideoCaptureCapability& requested, VideoCaptureCapability& resulting)
{
@ -103,15 +103,15 @@ WebRtc_Word32 VideoCaptureMacQuickTimeInfo::GetBestMatchedCapability(
return -1;
}
WebRtc_Word32 VideoCaptureMacQuickTimeInfo::DisplayCaptureSettingsDialogBox(
int32_t VideoCaptureMacQuickTimeInfo::DisplayCaptureSettingsDialogBox(
const char* deviceUniqueIdUTF8,
const char* dialogTitleUTF8, void* parentWindow,
WebRtc_UWord32 positionX, WebRtc_UWord32 positionY)
uint32_t positionX, uint32_t positionY)
{
return -1;
}
WebRtc_Word32 VideoCaptureMacQuickTimeInfo::CreateCapabilityMap(
int32_t VideoCaptureMacQuickTimeInfo::CreateCapabilityMap(
const char* deviceUniqueIdUTF8)
{
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id,
@ -120,10 +120,10 @@ WebRtc_Word32 VideoCaptureMacQuickTimeInfo::CreateCapabilityMap(
}
int VideoCaptureMacQuickTimeInfo::GetCaptureDevices(
WebRtc_UWord32 deviceNumber, char* deviceNameUTF8,
WebRtc_UWord32 deviceNameUTF8Length, char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length, char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length, int& numberOfDevices)
uint32_t deviceNumber, char* deviceNameUTF8,
uint32_t deviceNameUTF8Length, char* deviceUniqueIdUTF8,
uint32_t deviceUniqueIdUTF8Length, char* productUniqueIdUTF8,
uint32_t productUniqueIdUTF8Length, int& numberOfDevices)
{

44
webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.h
View File

@ -36,15 +36,15 @@ class VideoCaptureMacQuickTimeInfo: public DeviceInfoImpl
{
public:
static DeviceInfo* Create(const WebRtc_Word32 id);
static DeviceInfo* Create(const int32_t id);
static void Destroy(DeviceInfo* deviceInfo);
VideoCaptureMacQuickTimeInfo(const WebRtc_Word32 id);
VideoCaptureMacQuickTimeInfo(const int32_t id);
virtual ~VideoCaptureMacQuickTimeInfo();
WebRtc_Word32 Init();
int32_t Init();
virtual WebRtc_UWord32 NumberOfDevices();
virtual uint32_t NumberOfDevices();
/*
* Returns the available capture devices.
@ -55,12 +55,12 @@ public:
* productUniqueIdUTF8 - unique product id if it exist. Null terminated
* otherwise.
*/
virtual WebRtc_Word32 GetDeviceName(
WebRtc_UWord32 deviceNumber, char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength, char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
virtual int32_t GetDeviceName(
uint32_t deviceNumber, char* deviceNameUTF8,
uint32_t deviceNameLength, char* deviceUniqueIdUTF8,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8 = 0,
WebRtc_UWord32 productUniqueIdUTF8Length = 0);
uint32_t productUniqueIdUTF8Length = 0);
// ************** The remaining public functions are not supported on Mac
@ -68,21 +68,21 @@ public:
/*
* Returns the number of capabilities for this device
*/
virtual WebRtc_Word32 NumberOfCapabilities(const char* deviceUniqueIdUTF8);
virtual int32_t NumberOfCapabilities(const char* deviceUniqueIdUTF8);
/*
* Gets the capabilities of the named device
*/
virtual WebRtc_Word32 GetCapability(
virtual int32_t GetCapability(
const char* deviceUniqueIdUTF8,
const WebRtc_UWord32 deviceCapabilityNumber,
const uint32_t deviceCapabilityNumber,
VideoCaptureCapability& capability);
/*
* Gets the capability that best matches the requested width, height and frame rate.
* Returns the deviceCapabilityNumber on success.
*/
virtual WebRtc_Word32 GetBestMatchedCapability(
virtual int32_t GetBestMatchedCapability(
const char* deviceUniqueIdUTF8,
const VideoCaptureCapability& requested,
VideoCaptureCapability& resulting);
@ -90,13 +90,13 @@ public:
/*
* Display OS /capture device specific settings dialog
*/
virtual WebRtc_Word32 DisplayCaptureSettingsDialogBox(
virtual int32_t DisplayCaptureSettingsDialogBox(
const char* deviceUniqueIdUTF8,
const char* dialogTitleUTF8, void* parentWindow,
WebRtc_UWord32 positionX, WebRtc_UWord32 positionY);
uint32_t positionX, uint32_t positionY);
protected:
virtual WebRtc_Word32 CreateCapabilityMap(
virtual int32_t CreateCapabilityMap(
const char* deviceUniqueIdUTF8);
private:
@ -125,13 +125,13 @@ private:
private:
// private methods
int GetCaptureDevices(WebRtc_UWord32 deviceNumber,
int GetCaptureDevices(uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameUTF8Length,
uint32_t deviceNameUTF8Length,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length,
uint32_t productUniqueIdUTF8Length,
int& numberOfDevices);
static CFIndex PascalStringToCString(const unsigned char* pascalString,
@ -139,7 +139,7 @@ private:
private:
// member vars
WebRtc_Word32 _id;
int32_t _id;
bool _terminated;
CriticalSectionWrapper* _grabberCritsect;
webrtc::Trace* _trace;
@ -159,7 +159,7 @@ private:
int _trueCaptureWidth;
int _trueCaptureHeight;
ListWrapper _captureDeviceList;
WebRtc_Word64 _captureDeviceListTime;
int64_t _captureDeviceListTime;
ListWrapper _captureCapabilityList;
};
} // namespace webrtc

8
webrtc/modules/video_capture/mac/video_capture_mac.mm
View File

@ -106,14 +106,14 @@ bool CheckQTVersion()
* Returns version of the module and its components
*
* version - buffer to which the version will be written
* remainingBufferInBytes - remaining number of WebRtc_Word8 in the version
* remainingBufferInBytes - remaining number of int8_t in the version
* buffer
* position - position of the next empty WebRtc_Word8 in the
* position - position of the next empty int8_t in the
* version buffer
*/
VideoCaptureModule* VideoCaptureImpl::Create(
const WebRtc_Word32 id, const char* deviceUniqueIdUTF8)
const int32_t id, const char* deviceUniqueIdUTF8)
{
if (webrtc::videocapturemodule::CheckOSVersion() == false)
@ -206,7 +206,7 @@ VideoCaptureModule* VideoCaptureImpl::Create(
***************************************************************************/
VideoCaptureModule::DeviceInfo*
VideoCaptureImpl::CreateDeviceInfo(const WebRtc_Word32 id)
VideoCaptureImpl::CreateDeviceInfo(const int32_t id)
{

24
webrtc/modules/video_capture/test/video_capture_unittest.cc
View File

@ -38,7 +38,7 @@ using webrtc::VideoCaptureModule;
#define WAIT_(ex, timeout, res) \
do { \
res = (ex); \
WebRtc_Word64 start = TickTime::MillisecondTimestamp(); \
int64_t start = TickTime::MillisecondTimestamp(); \
while (!res && TickTime::MillisecondTimestamp() < start + timeout) { \
SleepMs(5); \
res = (ex); \
@ -154,7 +154,7 @@ class TestVideoCaptureCallback : public VideoCaptureDataCallback {
printf("No of timing warnings %d\n", timing_warnings_);
}
virtual void OnIncomingCapturedFrame(const WebRtc_Word32 id,
virtual void OnIncomingCapturedFrame(const int32_t id,
webrtc::I420VideoFrame& videoFrame) {
CriticalSectionScoped cs(capture_cs_.get());
@ -186,15 +186,15 @@ class TestVideoCaptureCallback : public VideoCaptureDataCallback {
last_render_time_ms_ = videoFrame.render_time_ms();
last_frame_.CopyFrame(videoFrame);
}
virtual void OnIncomingCapturedEncodedFrame(const WebRtc_Word32 id,
virtual void OnIncomingCapturedEncodedFrame(const int32_t id,
webrtc::VideoFrame& videoFrame,
webrtc::VideoCodecType codecType)
{
assert(!"NOTIMPLEMENTED");
}
virtual void OnCaptureDelayChanged(const WebRtc_Word32 id,
const WebRtc_Word32 delay) {
virtual void OnCaptureDelayChanged(const int32_t id,
const int32_t delay) {
CriticalSectionScoped cs(capture_cs_.get());
capture_delay_ = delay;
}
@ -243,7 +243,7 @@ class TestVideoCaptureCallback : public VideoCaptureDataCallback {
scoped_ptr<CriticalSectionWrapper> capture_cs_;
VideoCaptureCapability capability_;
int capture_delay_;
WebRtc_Word64 last_render_time_ms_;
int64_t last_render_time_ms_;
int incoming_frames_;
int timing_warnings_;
webrtc::I420VideoFrame last_frame_;
@ -258,13 +258,13 @@ class TestVideoCaptureFeedBack : public VideoCaptureFeedBack {
alarm_(webrtc::Cleared) {
}
virtual void OnCaptureFrameRate(const WebRtc_Word32 id,
const WebRtc_UWord32 frameRate) {
virtual void OnCaptureFrameRate(const int32_t id,
const uint32_t frameRate) {
CriticalSectionScoped cs(capture_cs_.get());
frame_rate_ = frameRate;
}
virtual void OnNoPictureAlarm(const WebRtc_Word32 id,
virtual void OnNoPictureAlarm(const int32_t id,
const VideoCaptureAlarm reported_alarm) {
CriticalSectionScoped cs(capture_cs_.get());
alarm_ = reported_alarm;
@ -332,7 +332,7 @@ class VideoCaptureTest : public testing::Test {
TEST_F(VideoCaptureTest, CreateDelete) {
for (int i = 0; i < 5; ++i) {
WebRtc_Word64 start_time = TickTime::MillisecondTimestamp();
int64_t start_time = TickTime::MillisecondTimestamp();
TestVideoCaptureCallback capture_observer;
webrtc::scoped_refptr<VideoCaptureModule> module(OpenVideoCaptureDevice(
0, &capture_observer));
@ -358,7 +358,7 @@ TEST_F(VideoCaptureTest, CreateDelete) {
EXPECT_GT(capture_observer.capture_delay(), 0);
WebRtc_Word64 stop_time = TickTime::MillisecondTimestamp();
int64_t stop_time = TickTime::MillisecondTimestamp();
EXPECT_EQ(0, module->StopCapture());
EXPECT_FALSE(module->CaptureStarted());
@ -581,7 +581,7 @@ TEST_F(VideoCaptureExternalTest, DISABLED_TestExternalCaptureI420) {
// Test frame rate and no picture alarm.
TEST_F(VideoCaptureExternalTest , FrameRate) {
WebRtc_Word64 testTime = 3;
int64_t testTime = 3;
TickTime startTime = TickTime::Now();
while ((TickTime::Now() - startTime).Milliseconds() < testTime * 1000) {

6
webrtc/modules/video_capture/video_capture_delay.h
View File

@ -18,9 +18,9 @@ namespace videocapturemodule
struct DelayValue
{
WebRtc_Word32 width;
WebRtc_Word32 height;
WebRtc_Word32 delay;
int32_t width;
int32_t height;
int32_t delay;
};
enum { NoOfDelayValues = 40 };

6
webrtc/modules/video_capture/video_capture_factory.cc
View File

@ -14,18 +14,18 @@
namespace webrtc
{
VideoCaptureModule* VideoCaptureFactory::Create(const WebRtc_Word32 id,
VideoCaptureModule* VideoCaptureFactory::Create(const int32_t id,
const char* deviceUniqueIdUTF8) {
return videocapturemodule::VideoCaptureImpl::Create(id, deviceUniqueIdUTF8);
}
VideoCaptureModule* VideoCaptureFactory::Create(const WebRtc_Word32 id,
VideoCaptureModule* VideoCaptureFactory::Create(const int32_t id,
VideoCaptureExternal*& externalCapture) {
return videocapturemodule::VideoCaptureImpl::Create(id, externalCapture);
}
VideoCaptureModule::DeviceInfo* VideoCaptureFactory::CreateDeviceInfo(
const WebRtc_Word32 id) {
const int32_t id) {
return videocapturemodule::VideoCaptureImpl::CreateDeviceInfo(id);
}

73
webrtc/modules/video_capture/video_capture_impl.cc
View File

@ -26,7 +26,7 @@ namespace webrtc
namespace videocapturemodule
{
VideoCaptureModule* VideoCaptureImpl::Create(
const WebRtc_Word32 id,
const int32_t id,
VideoCaptureExternal*& externalCapture)
{
RefCountImpl<VideoCaptureImpl>* implementation =
@ -40,25 +40,25 @@ const char* VideoCaptureImpl::CurrentDeviceName() const
return _deviceUniqueId;
}
WebRtc_Word32 VideoCaptureImpl::ChangeUniqueId(const WebRtc_Word32 id)
int32_t VideoCaptureImpl::ChangeUniqueId(const int32_t id)
{
_id = id;
return 0;
}
// returns the number of milliseconds until the module want a worker thread to call Process
WebRtc_Word32 VideoCaptureImpl::TimeUntilNextProcess()
int32_t VideoCaptureImpl::TimeUntilNextProcess()
{
CriticalSectionScoped cs(&_callBackCs);
WebRtc_Word32 timeToNormalProcess = kProcessInterval
- (WebRtc_Word32)((TickTime::Now() - _lastProcessTime).Milliseconds());
int32_t timeToNormalProcess = kProcessInterval
- (int32_t)((TickTime::Now() - _lastProcessTime).Milliseconds());
return timeToNormalProcess;
}
// Process any pending tasks such as timeouts
WebRtc_Word32 VideoCaptureImpl::Process()
int32_t VideoCaptureImpl::Process()
{
CriticalSectionScoped cs(&_callBackCs);
@ -93,7 +93,7 @@ WebRtc_Word32 VideoCaptureImpl::Process()
{
if (_frameRateCallBack && _captureCallBack)
{
const WebRtc_UWord32 frameRate = CalculateFrameRate(now);
const uint32_t frameRate = CalculateFrameRate(now);
_captureCallBack->OnCaptureFrameRate(_id, frameRate);
}
_lastFrameRateCallbackTime = now; // Can be set by EnableFrameRateCallback
@ -105,7 +105,7 @@ WebRtc_Word32 VideoCaptureImpl::Process()
return 0;
}
VideoCaptureImpl::VideoCaptureImpl(const WebRtc_Word32 id)
VideoCaptureImpl::VideoCaptureImpl(const int32_t id)
: _id(id), _deviceUniqueId(NULL), _apiCs(*CriticalSectionWrapper::CreateCriticalSection()),
_captureDelay(0), _requestedCapability(),
_callBackCs(*CriticalSectionWrapper::CreateCriticalSection()),
@ -136,7 +136,7 @@ VideoCaptureImpl::~VideoCaptureImpl()
delete[] _deviceUniqueId;
}
WebRtc_Word32 VideoCaptureImpl::RegisterCaptureDataCallback(
int32_t VideoCaptureImpl::RegisterCaptureDataCallback(
VideoCaptureDataCallback& dataCallBack)
{
CriticalSectionScoped cs(&_apiCs);
@ -146,14 +146,14 @@ WebRtc_Word32 VideoCaptureImpl::RegisterCaptureDataCallback(
return 0;
}
WebRtc_Word32 VideoCaptureImpl::DeRegisterCaptureDataCallback()
int32_t VideoCaptureImpl::DeRegisterCaptureDataCallback()
{
CriticalSectionScoped cs(&_apiCs);
CriticalSectionScoped cs2(&_callBackCs);
_dataCallBack = NULL;
return 0;
}
WebRtc_Word32 VideoCaptureImpl::RegisterCaptureCallback(VideoCaptureFeedBack& callBack)
int32_t VideoCaptureImpl::RegisterCaptureCallback(VideoCaptureFeedBack& callBack)
{
CriticalSectionScoped cs(&_apiCs);
@ -161,7 +161,7 @@ WebRtc_Word32 VideoCaptureImpl::RegisterCaptureCallback(VideoCaptureFeedBack& ca
_captureCallBack = &callBack;
return 0;
}
WebRtc_Word32 VideoCaptureImpl::DeRegisterCaptureCallback()
int32_t VideoCaptureImpl::DeRegisterCaptureCallback()
{
CriticalSectionScoped cs(&_apiCs);
@ -170,20 +170,20 @@ WebRtc_Word32 VideoCaptureImpl::DeRegisterCaptureCallback()
return 0;
}
WebRtc_Word32 VideoCaptureImpl::SetCaptureDelay(WebRtc_Word32 delayMS)
int32_t VideoCaptureImpl::SetCaptureDelay(int32_t delayMS)
{
CriticalSectionScoped cs(&_apiCs);
_captureDelay = delayMS;
return 0;
}
WebRtc_Word32 VideoCaptureImpl::CaptureDelay()
int32_t VideoCaptureImpl::CaptureDelay()
{
CriticalSectionScoped cs(&_apiCs);
return _setCaptureDelay;
}
WebRtc_Word32 VideoCaptureImpl::DeliverCapturedFrame(I420VideoFrame&
captureFrame, WebRtc_Word64 capture_time) {
int32_t VideoCaptureImpl::DeliverCapturedFrame(I420VideoFrame& captureFrame,
int64_t capture_time) {
UpdateFrameCount(); // frame count used for local frame rate callback.
const bool callOnCaptureDelayChanged = _setCaptureDelay != _captureDelay;
@ -219,8 +219,8 @@ WebRtc_Word32 VideoCaptureImpl::DeliverCapturedFrame(I420VideoFrame&
return 0;
}
WebRtc_Word32 VideoCaptureImpl::DeliverEncodedCapturedFrame(
VideoFrame& captureFrame, WebRtc_Word64 capture_time,
int32_t VideoCaptureImpl::DeliverEncodedCapturedFrame(
VideoFrame& captureFrame, int64_t capture_time,
VideoCodecType codecType) {
UpdateFrameCount(); // frame count used for local frame rate callback.
@ -254,11 +254,11 @@ WebRtc_Word32 VideoCaptureImpl::DeliverEncodedCapturedFrame(
return 0;
}
WebRtc_Word32 VideoCaptureImpl::IncomingFrame(
WebRtc_UWord8* videoFrame,
WebRtc_Word32 videoFrameLength,
int32_t VideoCaptureImpl::IncomingFrame(
uint8_t* videoFrame,
int32_t videoFrameLength,
const VideoCaptureCapability& frameInfo,
WebRtc_Word64 captureTime/*=0*/)
int64_t captureTime/*=0*/)
{
WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceVideoCapture, _id,
"IncomingFrame width %d, height %d", (int) frameInfo.width,
@ -268,8 +268,8 @@ WebRtc_Word32 VideoCaptureImpl::IncomingFrame(
CriticalSectionScoped cs(&_callBackCs);
const WebRtc_Word32 width = frameInfo.width;
const WebRtc_Word32 height = frameInfo.height;
const int32_t width = frameInfo.width;
const int32_t height = frameInfo.height;
TRACE_EVENT1("webrtc", "VC::IncomingFrame", "capture_time", captureTime);
@ -340,8 +340,8 @@ WebRtc_Word32 VideoCaptureImpl::IncomingFrame(
frameInfo.codecType);
}
const WebRtc_UWord32 processTime =
(WebRtc_UWord32)(TickTime::Now() - startProcessTime).Milliseconds();
const uint32_t processTime =
(uint32_t)(TickTime::Now() - startProcessTime).Milliseconds();
if (processTime > 10) // If the process time is too long MJPG will not work well.
{
WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, _id,
@ -352,8 +352,8 @@ WebRtc_Word32 VideoCaptureImpl::IncomingFrame(
return 0;
}
WebRtc_Word32 VideoCaptureImpl::IncomingFrameI420(
const VideoFrameI420& video_frame, WebRtc_Word64 captureTime) {
int32_t VideoCaptureImpl::IncomingFrameI420(
const VideoFrameI420& video_frame, int64_t captureTime) {
CriticalSectionScoped cs(&_callBackCs);
int size_y = video_frame.height * video_frame.y_pitch;
@ -377,8 +377,7 @@ WebRtc_Word32 VideoCaptureImpl::IncomingFrameI420(
return 0;
}
WebRtc_Word32 VideoCaptureImpl::SetCaptureRotation(VideoCaptureRotation
rotation) {
int32_t VideoCaptureImpl::SetCaptureRotation(VideoCaptureRotation rotation) {
CriticalSectionScoped cs(&_apiCs);
CriticalSectionScoped cs2(&_callBackCs);
switch (rotation){
@ -398,7 +397,7 @@ WebRtc_Word32 VideoCaptureImpl::SetCaptureRotation(VideoCaptureRotation
return 0;
}
WebRtc_Word32 VideoCaptureImpl::EnableFrameRateCallback(const bool enable)
int32_t VideoCaptureImpl::EnableFrameRateCallback(const bool enable)
{
CriticalSectionScoped cs(&_apiCs);
CriticalSectionScoped cs2(&_callBackCs);
@ -410,7 +409,7 @@ WebRtc_Word32 VideoCaptureImpl::EnableFrameRateCallback(const bool enable)
return 0;
}
WebRtc_Word32 VideoCaptureImpl::EnableNoPictureAlarm(const bool enable)
int32_t VideoCaptureImpl::EnableNoPictureAlarm(const bool enable)
{
CriticalSectionScoped cs(&_apiCs);
CriticalSectionScoped cs2(&_callBackCs);
@ -435,10 +434,10 @@ void VideoCaptureImpl::UpdateFrameCount()
_incomingFrameTimes[0] = TickTime::Now();
}
WebRtc_UWord32 VideoCaptureImpl::CalculateFrameRate(const TickTime& now)
uint32_t VideoCaptureImpl::CalculateFrameRate(const TickTime& now)
{
WebRtc_Word32 num = 0;
WebRtc_Word32 nrOfFrames = 0;
int32_t num = 0;
int32_t nrOfFrames = 0;
for (num = 1; num < (kFrameRateCountHistorySize - 1); num++)
{
if (_incomingFrameTimes[num].Ticks() <= 0
@ -453,10 +452,10 @@ WebRtc_UWord32 VideoCaptureImpl::CalculateFrameRate(const TickTime& now)
}
if (num > 1)
{
WebRtc_Word64 diff = (now - _incomingFrameTimes[num - 1]).Milliseconds();
int64_t diff = (now - _incomingFrameTimes[num - 1]).Milliseconds();
if (diff > 0)
{
return WebRtc_UWord32((nrOfFrames * 1000.0f / diff) + 0.5f);
return uint32_t((nrOfFrames * 1000.0f / diff) + 0.5f);
}
}

66
webrtc/modules/video_capture/video_capture_impl.h
View File

@ -37,7 +37,7 @@ public:
* id - unique identifier of this video capture module object
* deviceUniqueIdUTF8 - name of the device. Available names can be found by using GetDeviceName
*/
static VideoCaptureModule* Create(const WebRtc_Word32 id,
static VideoCaptureModule* Create(const int32_t id,
const char* deviceUniqueIdUTF8);
/*
@ -46,72 +46,72 @@ public:
* id - unique identifier of this video capture module object
* externalCapture - [out] interface to call when a new frame is captured.
*/
static VideoCaptureModule* Create(const WebRtc_Word32 id,
static VideoCaptureModule* Create(const int32_t id,
VideoCaptureExternal*& externalCapture);
static DeviceInfo* CreateDeviceInfo(const WebRtc_Word32 id);
static DeviceInfo* CreateDeviceInfo(const int32_t id);
// Implements Module declared functions.
virtual WebRtc_Word32 ChangeUniqueId(const WebRtc_Word32 id);
virtual int32_t ChangeUniqueId(const int32_t id);
//Call backs
virtual WebRtc_Word32 RegisterCaptureDataCallback(VideoCaptureDataCallback& dataCallback);
virtual WebRtc_Word32 DeRegisterCaptureDataCallback();
virtual WebRtc_Word32 RegisterCaptureCallback(VideoCaptureFeedBack& callBack);
virtual WebRtc_Word32 DeRegisterCaptureCallback();
virtual int32_t RegisterCaptureDataCallback(VideoCaptureDataCallback& dataCallback);
virtual int32_t DeRegisterCaptureDataCallback();
virtual int32_t RegisterCaptureCallback(VideoCaptureFeedBack& callBack);
virtual int32_t DeRegisterCaptureCallback();
virtual WebRtc_Word32 SetCaptureDelay(WebRtc_Word32 delayMS);
virtual WebRtc_Word32 CaptureDelay();
virtual WebRtc_Word32 SetCaptureRotation(VideoCaptureRotation rotation);
virtual int32_t SetCaptureDelay(int32_t delayMS);
virtual int32_t CaptureDelay();
virtual int32_t SetCaptureRotation(VideoCaptureRotation rotation);
virtual WebRtc_Word32 EnableFrameRateCallback(const bool enable);
virtual WebRtc_Word32 EnableNoPictureAlarm(const bool enable);
virtual int32_t EnableFrameRateCallback(const bool enable);
virtual int32_t EnableNoPictureAlarm(const bool enable);
virtual const char* CurrentDeviceName() const;
// Module handling
virtual WebRtc_Word32 TimeUntilNextProcess();
virtual WebRtc_Word32 Process();
virtual int32_t TimeUntilNextProcess();
virtual int32_t Process();
// Implement VideoCaptureExternal
virtual WebRtc_Word32 IncomingFrame(WebRtc_UWord8* videoFrame,
WebRtc_Word32 videoFrameLength,
virtual int32_t IncomingFrame(uint8_t* videoFrame,
int32_t videoFrameLength,
const VideoCaptureCapability& frameInfo,
WebRtc_Word64 captureTime = 0);
virtual WebRtc_Word32 IncomingFrameI420(
int64_t captureTime = 0);
virtual int32_t IncomingFrameI420(
const VideoFrameI420& video_frame,
WebRtc_Word64 captureTime = 0);
int64_t captureTime = 0);
// Platform dependent
virtual WebRtc_Word32 StartCapture(const VideoCaptureCapability& capability)
virtual int32_t StartCapture(const VideoCaptureCapability& capability)
{
_requestedCapability = capability;
return -1;
}
virtual WebRtc_Word32 StopCapture() { return -1; }
virtual int32_t StopCapture() { return -1; }
virtual bool CaptureStarted() {return false; }
virtual WebRtc_Word32 CaptureSettings(VideoCaptureCapability& /*settings*/)
virtual int32_t CaptureSettings(VideoCaptureCapability& /*settings*/)
{ return -1; }
VideoCaptureEncodeInterface* GetEncodeInterface(const VideoCodec& /*codec*/)
{ return NULL; }
protected:
VideoCaptureImpl(const WebRtc_Word32 id);
VideoCaptureImpl(const int32_t id);
virtual ~VideoCaptureImpl();
WebRtc_Word32 DeliverCapturedFrame(I420VideoFrame& captureFrame,
WebRtc_Word64 capture_time);
WebRtc_Word32 DeliverEncodedCapturedFrame(VideoFrame& captureFrame,
WebRtc_Word64 capture_time,
int32_t DeliverCapturedFrame(I420VideoFrame& captureFrame,
int64_t capture_time);
int32_t DeliverEncodedCapturedFrame(VideoFrame& captureFrame,
int64_t capture_time,
VideoCodecType codec_type);
WebRtc_Word32 _id; // Module ID
int32_t _id; // Module ID
char* _deviceUniqueId; // current Device unique name;
CriticalSectionWrapper& _apiCs;
WebRtc_Word32 _captureDelay; // Current capture delay. May be changed of platform dependent parts.
int32_t _captureDelay; // Current capture delay. May be changed of platform dependent parts.
VideoCaptureCapability _requestedCapability; // Should be set by platform dependent code in StartCapture.
private:
void UpdateFrameCount();
WebRtc_UWord32 CalculateFrameRate(const TickTime& now);
uint32_t CalculateFrameRate(const TickTime& now);
CriticalSectionWrapper& _callBackCs;
@ -121,7 +121,7 @@ private:
bool _noPictureAlarmCallBack; //true if EnableNoPictureAlarm
VideoCaptureAlarm _captureAlarm; // current value of the noPictureAlarm
WebRtc_Word32 _setCaptureDelay; // The currently used capture delay
int32_t _setCaptureDelay; // The currently used capture delay
VideoCaptureDataCallback* _dataCallBack;
VideoCaptureFeedBack* _captureCallBack;
@ -133,7 +133,7 @@ private:
VideoFrame _capture_encoded_frame;
// Used to make sure incoming timestamp is increasing for every frame.
WebRtc_Word64 last_capture_time_;
int64_t last_capture_time_;
};
} // namespace videocapturemodule
} //namespace webrtc

68
webrtc/modules/video_capture/windows/device_info_ds.cc
View File

@ -23,7 +23,7 @@ namespace webrtc
{
namespace videocapturemodule
{
const WebRtc_Word32 NoWindowsCaptureDelays = 1;
const int32_t NoWindowsCaptureDelays = 1;
const DelayValues WindowsCaptureDelays[NoWindowsCaptureDelays] = {
"Microsoft LifeCam Cinema",
"usb#vid_045e&pid_075d",
@ -43,7 +43,7 @@ const DelayValues WindowsCaptureDelays[NoWindowsCaptureDelays] = {
};
// static
DeviceInfoDS* DeviceInfoDS::Create(const WebRtc_Word32 id)
DeviceInfoDS* DeviceInfoDS::Create(const int32_t id)
{
DeviceInfoDS* dsInfo = new DeviceInfoDS(id);
if (!dsInfo || dsInfo->Init() != 0)
@ -54,7 +54,7 @@ DeviceInfoDS* DeviceInfoDS::Create(const WebRtc_Word32 id)
return dsInfo;
}
DeviceInfoDS::DeviceInfoDS(const WebRtc_Word32 id)
DeviceInfoDS::DeviceInfoDS(const int32_t id)
: DeviceInfoImpl(id), _dsDevEnum(NULL), _dsMonikerDevEnum(NULL),
_CoUninitializeIsRequired(true)
{
@ -108,7 +108,7 @@ DeviceInfoDS::~DeviceInfoDS()
}
}
WebRtc_Word32 DeviceInfoDS::Init()
int32_t DeviceInfoDS::Init()
{
HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
IID_ICreateDevEnum, (void **) &_dsDevEnum);
@ -120,39 +120,39 @@ WebRtc_Word32 DeviceInfoDS::Init()
}
return 0;
}
WebRtc_UWord32 DeviceInfoDS::NumberOfDevices()
uint32_t DeviceInfoDS::NumberOfDevices()
{
ReadLockScoped cs(_apiLock);
return GetDeviceInfo(0, 0, 0, 0, 0, 0, 0);
}
WebRtc_Word32 DeviceInfoDS::GetDeviceName(
WebRtc_UWord32 deviceNumber,
int32_t DeviceInfoDS::GetDeviceName(
uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length)
uint32_t productUniqueIdUTF8Length)
{
ReadLockScoped cs(_apiLock);
const WebRtc_Word32 result = GetDeviceInfo(deviceNumber, deviceNameUTF8,
const int32_t result = GetDeviceInfo(deviceNumber, deviceNameUTF8,
deviceNameLength,
deviceUniqueIdUTF8,
deviceUniqueIdUTF8Length,
productUniqueIdUTF8,
productUniqueIdUTF8Length);
return result > (WebRtc_Word32) deviceNumber ? 0 : -1;
return result > (int32_t) deviceNumber ? 0 : -1;
}
WebRtc_Word32 DeviceInfoDS::GetDeviceInfo(
WebRtc_UWord32 deviceNumber,
int32_t DeviceInfoDS::GetDeviceInfo(
uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length)
uint32_t productUniqueIdUTF8Length)
{
@ -275,11 +275,11 @@ WebRtc_Word32 DeviceInfoDS::GetDeviceInfo(
IBaseFilter * DeviceInfoDS::GetDeviceFilter(
const char* deviceUniqueIdUTF8,
char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length)
uint32_t productUniqueIdUTF8Length)
{
const WebRtc_Word32 deviceUniqueIdUTF8Length =
(WebRtc_Word32) strlen((char*) deviceUniqueIdUTF8); // UTF8 is also NULL terminated
const int32_t deviceUniqueIdUTF8Length =
(int32_t) strlen((char*) deviceUniqueIdUTF8); // UTF8 is also NULL terminated
if (deviceUniqueIdUTF8Length > kVideoCaptureUniqueNameLength)
{
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
@ -366,8 +366,8 @@ IBaseFilter * DeviceInfoDS::GetDeviceFilter(
return captureFilter;
}
WebRtc_Word32 DeviceInfoDS::GetWindowsCapability(
const WebRtc_Word32 capabilityIndex,
int32_t DeviceInfoDS::GetWindowsCapability(
const int32_t capabilityIndex,
VideoCaptureCapabilityWindows& windowsCapability)
{
@ -386,7 +386,7 @@ WebRtc_Word32 DeviceInfoDS::GetWindowsCapability(
return 0;
}
WebRtc_Word32 DeviceInfoDS::CreateCapabilityMap(
int32_t DeviceInfoDS::CreateCapabilityMap(
const char* deviceUniqueIdUTF8)
{
@ -400,8 +400,8 @@ WebRtc_Word32 DeviceInfoDS::CreateCapabilityMap(
_captureCapabilities.Erase(item);
}
const WebRtc_Word32 deviceUniqueIdUTF8Length =
(WebRtc_Word32) strlen((char*) deviceUniqueIdUTF8);
const int32_t deviceUniqueIdUTF8Length =
(int32_t) strlen((char*) deviceUniqueIdUTF8);
if (deviceUniqueIdUTF8Length > kVideoCaptureUniqueNameLength)
{
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
@ -473,7 +473,7 @@ WebRtc_Word32 DeviceInfoDS::CreateCapabilityMap(
return -1;
}
WebRtc_Word32 index = 0; // Index in created _capabilities map
int32_t index = 0; // Index in created _capabilities map
// Check if the device support formattype == FORMAT_VideoInfo2 and FORMAT_VideoInfo.
// Prefer FORMAT_VideoInfo since some cameras (ZureCam) has been seen having problem with MJPEG and FORMAT_VideoInfo2
// Interlace flag is only supported in FORMAT_VideoInfo2
@ -481,7 +481,7 @@ WebRtc_Word32 DeviceInfoDS::CreateCapabilityMap(
bool supportFORMAT_VideoInfo = false;
bool foundInterlacedFormat = false;
GUID preferedVideoFormat = FORMAT_VideoInfo;
for (WebRtc_Word32 tmp = 0; tmp < count; ++tmp)
for (int32_t tmp = 0; tmp < count; ++tmp)
{
hr = streamConfig->GetStreamCaps(tmp, &pmt,
reinterpret_cast<BYTE*> (&caps));
@ -521,7 +521,7 @@ WebRtc_Word32 DeviceInfoDS::CreateCapabilityMap(
}
}
for (WebRtc_Word32 tmp = 0; tmp < count; ++tmp)
for (int32_t tmp = 0; tmp < count; ++tmp)
{
hr = streamConfig->GetStreamCaps(tmp, &pmt,
reinterpret_cast<BYTE*> (&caps));
@ -542,7 +542,7 @@ WebRtc_Word32 DeviceInfoDS::CreateCapabilityMap(
VideoCaptureCapabilityWindows* capability =
new VideoCaptureCapabilityWindows();
WebRtc_Word64 avgTimePerFrame = 0;
int64_t avgTimePerFrame = 0;
if (pmt->formattype == FORMAT_VideoInfo)
{
@ -712,7 +712,7 @@ WebRtc_Word32 DeviceInfoDS::CreateCapabilityMap(
*/
void DeviceInfoDS::GetProductId(const char* devicePath,
char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length)
uint32_t productUniqueIdUTF8Length)
{
*productUniqueIdUTF8 = '\0';
char* startPos = strstr((char*) devicePath, "\\\\?\\");
@ -735,7 +735,7 @@ void DeviceInfoDS::GetProductId(const char* devicePath,
}
// Find the second occurrence.
pos = strchr(pos + 1, '&');
WebRtc_UWord32 bytesToCopy = (WebRtc_UWord32)(pos - startPos);
uint32_t bytesToCopy = (uint32_t)(pos - startPos);
if (pos && (bytesToCopy <= productUniqueIdUTF8Length) && bytesToCopy
<= kVideoCaptureProductIdLength)
{
@ -750,12 +750,12 @@ void DeviceInfoDS::GetProductId(const char* devicePath,
}
}
WebRtc_Word32 DeviceInfoDS::DisplayCaptureSettingsDialogBox(
int32_t DeviceInfoDS::DisplayCaptureSettingsDialogBox(
const char* deviceUniqueIdUTF8,
const char* dialogTitleUTF8,
void* parentWindow,
WebRtc_UWord32 positionX,
WebRtc_UWord32 positionY)
uint32_t positionX,
uint32_t positionY)
{
ReadLockScoped cs(_apiLock);
HWND window = (HWND) parentWindow;

44
webrtc/modules/video_capture/windows/device_info_ds.h
View File

@ -24,7 +24,7 @@ namespace videocapturemodule
{
struct VideoCaptureCapabilityWindows: public VideoCaptureCapability
{
WebRtc_UWord32 directShowCapabilityIndex;
uint32_t directShowCapabilityIndex;
bool supportFrameRateControl;
VideoCaptureCapabilityWindows()
{
@ -37,36 +37,36 @@ class DeviceInfoDS: public DeviceInfoImpl
{
public:
// Factory function.
static DeviceInfoDS* Create(const WebRtc_Word32 id);
static DeviceInfoDS* Create(const int32_t id);
DeviceInfoDS(const WebRtc_Word32 id);
DeviceInfoDS(const int32_t id);
virtual ~DeviceInfoDS();
WebRtc_Word32 Init();
virtual WebRtc_UWord32 NumberOfDevices();
int32_t Init();
virtual uint32_t NumberOfDevices();
/*
* Returns the available capture devices.
*/
virtual WebRtc_Word32
GetDeviceName(WebRtc_UWord32 deviceNumber,
virtual int32_t
GetDeviceName(uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length);
uint32_t productUniqueIdUTF8Length);
/*
* Display OS /capture device specific settings dialog
*/
virtual WebRtc_Word32
virtual int32_t
DisplayCaptureSettingsDialogBox(
const char* deviceUniqueIdUTF8,
const char* dialogTitleUTF8,
void* parentWindow,
WebRtc_UWord32 positionX,
WebRtc_UWord32 positionY);
uint32_t positionX,
uint32_t positionY);
// Windows specific
@ -75,26 +75,26 @@ public:
*/
IBaseFilter * GetDeviceFilter(const char* deviceUniqueIdUTF8,
char* productUniqueIdUTF8 = NULL,
WebRtc_UWord32 productUniqueIdUTF8Length = 0);
uint32_t productUniqueIdUTF8Length = 0);
WebRtc_Word32
GetWindowsCapability(const WebRtc_Word32 capabilityIndex,
int32_t
GetWindowsCapability(const int32_t capabilityIndex,
VideoCaptureCapabilityWindows& windowsCapability);
static void GetProductId(const char* devicePath,
char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length);
uint32_t productUniqueIdUTF8Length);
protected:
WebRtc_Word32 GetDeviceInfo(WebRtc_UWord32 deviceNumber,
int32_t GetDeviceInfo(uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length);
uint32_t productUniqueIdUTF8Length);
virtual WebRtc_Word32
virtual int32_t
CreateCapabilityMap(const char* deviceUniqueIdUTF8);
private:

22
webrtc/modules/video_capture/windows/device_info_mf.cc
View File

@ -13,37 +13,37 @@
namespace webrtc {
namespace videocapturemodule {
DeviceInfoMF::DeviceInfoMF(const WebRtc_Word32 id) : DeviceInfoImpl(id) {
DeviceInfoMF::DeviceInfoMF(const int32_t id) : DeviceInfoImpl(id) {
}
DeviceInfoMF::~DeviceInfoMF() {
}
WebRtc_Word32 DeviceInfoMF::Init() {
int32_t DeviceInfoMF::Init() {
return -1;
}
WebRtc_UWord32 DeviceInfoMF::NumberOfDevices() {
uint32_t DeviceInfoMF::NumberOfDevices() {
return 0;
}
WebRtc_Word32 DeviceInfoMF::GetDeviceName(
WebRtc_UWord32 deviceNumber,
int32_t DeviceInfoMF::GetDeviceName(
uint32_t deviceNumber,
char* deviceNameUTF8,
WebRtc_UWord32 deviceNameLength,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
WebRtc_UWord32 deviceUniqueIdUTF8Length,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8,
WebRtc_UWord32 productUniqueIdUTF8Length) {
uint32_t productUniqueIdUTF8Length) {
return -1;
}
WebRtc_Word32 DeviceInfoMF::DisplayCaptureSettingsDialogBox(
int32_t DeviceInfoMF::DisplayCaptureSettingsDialogBox(
const char* deviceUniqueIdUTF8,
const char* dialogTitleUTF8,
void* parentWindow,
WebRtc_UWord32 positionX,
WebRtc_UWord32 positionY) {
uint32_t positionX,
uint32_t positionY) {
return -1;
}

20
webrtc/modules/video_capture/windows/device_info_mf.h
View File

@ -19,20 +19,22 @@ namespace videocapturemodule {
// Provides video capture device information using the Media Foundation API.
class DeviceInfoMF : public DeviceInfoImpl {
public:
explicit DeviceInfoMF(const WebRtc_Word32 id);
explicit DeviceInfoMF(const int32_t id);
virtual ~DeviceInfoMF();
WebRtc_Word32 Init();
virtual WebRtc_UWord32 NumberOfDevices();
int32_t Init();
virtual uint32_t NumberOfDevices();
virtual WebRtc_Word32 GetDeviceName(WebRtc_UWord32 deviceNumber,
char* deviceNameUTF8, WebRtc_UWord32 deviceNameLength,
char* deviceUniqueIdUTF8, WebRtc_UWord32 deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8, WebRtc_UWord32 productUniqueIdUTF8Length);
virtual int32_t GetDeviceName(uint32_t deviceNumber, char* deviceNameUTF8,
uint32_t deviceNameLength,
char* deviceUniqueIdUTF8,
uint32_t deviceUniqueIdUTF8Length,
char* productUniqueIdUTF8,
uint32_t productUniqueIdUTF8Length);
virtual WebRtc_Word32 DisplayCaptureSettingsDialogBox(
virtual int32_t DisplayCaptureSettingsDialogBox(
const char* deviceUniqueIdUTF8, const char* dialogTitleUTF8,
void* parentWindow, WebRtc_UWord32 positionX, WebRtc_UWord32 positionY);
void* parentWindow, uint32_t positionX, uint32_t positionY);
};
} // namespace videocapturemodule

10
webrtc/modules/video_capture/windows/sink_filter_ds.cc
View File

@ -34,7 +34,7 @@ typedef struct tagTHREADNAME_INFO
DWORD dwFlags; // reserved for future use, must be zero
} THREADNAME_INFO;
CaptureInputPin::CaptureInputPin (WebRtc_Word32 moduleId,
CaptureInputPin::CaptureInputPin (int32_t moduleId,
IN TCHAR * szName,
IN CaptureSinkFilter* pFilter,
IN CCritSec * pLock,
@ -86,7 +86,7 @@ CaptureInputPin::GetMediaType (IN int iPosition, OUT CMediaType * pmt)
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(FALSE);
WebRtc_Word32 positionOffset=1;
int32_t positionOffset=1;
if(_requestedCapability.codecType!=kVideoCodecUnknown)
{
positionOffset=0;
@ -353,7 +353,7 @@ CaptureInputPin::Receive ( IN IMediaSample * pIMediaSample )
if (SUCCEEDED (hr))
{
const WebRtc_Word32 length = pIMediaSample->GetActualDataLength();
const int32_t length = pIMediaSample->GetActualDataLength();
unsigned char* pBuffer = NULL;
if(S_OK != pIMediaSample->GetPointer(&pBuffer))
@ -388,7 +388,7 @@ CaptureSinkFilter::CaptureSinkFilter (IN TCHAR * tszName,
IN LPUNKNOWN punk,
OUT HRESULT * phr,
VideoCaptureExternal& captureObserver,
WebRtc_Word32 moduleId)
int32_t moduleId)
: CBaseFilter(tszName,punk,& m_crtFilter,CLSID_SINKFILTER),
m_pInput(NULL),
_captureObserver(captureObserver),
@ -484,7 +484,7 @@ void CaptureSinkFilter::SetFilterGraph(IGraphBuilder* graph)
}
void CaptureSinkFilter::ProcessCapturedFrame(unsigned char* pBuffer,
WebRtc_Word32 length,
int32_t length,
const VideoCaptureCapability& frameInfo)
{
// we have the receiver lock

10
webrtc/modules/video_capture/windows/sink_filter_ds.h
View File

@ -29,13 +29,13 @@ class CaptureSinkFilter;
class CaptureInputPin: public CBaseInputPin
{
public:
WebRtc_Word32 _moduleId;
int32_t _moduleId;
VideoCaptureCapability _requestedCapability;
VideoCaptureCapability _resultingCapability;
HANDLE _threadHandle;
CaptureInputPin ( WebRtc_Word32 moduleId,
CaptureInputPin(int32_t moduleId,
IN TCHAR* szName,
IN CaptureSinkFilter* pFilter,
IN CCritSec * pLock,
@ -57,13 +57,13 @@ public:
IN LPUNKNOWN punk,
OUT HRESULT * phr,
VideoCaptureExternal& captureObserver,
WebRtc_Word32 moduleId);
int32_t moduleId);
virtual ~CaptureSinkFilter();
// --------------------------------------------------------------------
// class methods
void ProcessCapturedFrame(unsigned char* pBuffer, WebRtc_Word32 length,
void ProcessCapturedFrame(unsigned char* pBuffer, int32_t length,
const VideoCaptureCapability& frameInfo);
// explicit receiver lock aquisition and release
void LockReceive() { m_crtRecv.Lock();}
@ -93,7 +93,7 @@ private:
CCritSec m_crtRecv; // receiver lock; always acquire before filter lock
CaptureInputPin * m_pInput;
VideoCaptureExternal& _captureObserver;
WebRtc_Word32 _moduleId;
int32_t _moduleId;
};
} // namespace videocapturemodule
} // namespace webrtc

21
webrtc/modules/video_capture/windows/video_capture_ds.cc
View File

@ -22,7 +22,7 @@ namespace webrtc
{
namespace videocapturemodule
{
VideoCaptureDS::VideoCaptureDS(const WebRtc_Word32 id)
VideoCaptureDS::VideoCaptureDS(const int32_t id)
: VideoCaptureImpl(id), _dsInfo(id), _captureFilter(NULL),
_graphBuilder(NULL), _mediaControl(NULL), _sinkFilter(NULL),
_inputSendPin(NULL), _outputCapturePin(NULL), _dvFilter(NULL),
@ -59,11 +59,10 @@ VideoCaptureDS::~VideoCaptureDS()
RELEASE_AND_CLEAR(_graphBuilder);
}
WebRtc_Word32 VideoCaptureDS::Init(const WebRtc_Word32 id,
const char* deviceUniqueIdUTF8)
int32_t VideoCaptureDS::Init(const int32_t id, const char* deviceUniqueIdUTF8)
{
const WebRtc_Word32 nameLength =
(WebRtc_Word32) strlen((char*) deviceUniqueIdUTF8);
const int32_t nameLength =
(int32_t) strlen((char*) deviceUniqueIdUTF8);
if (nameLength > kVideoCaptureUniqueNameLength)
return -1;
@ -150,7 +149,7 @@ WebRtc_Word32 VideoCaptureDS::Init(const WebRtc_Word32 id,
return 0;
}
WebRtc_Word32 VideoCaptureDS::StartCapture(
int32_t VideoCaptureDS::StartCapture(
const VideoCaptureCapability& capability)
{
CriticalSectionScoped cs(&_apiCs);
@ -174,7 +173,7 @@ WebRtc_Word32 VideoCaptureDS::StartCapture(
return 0;
}
WebRtc_Word32 VideoCaptureDS::StopCapture()
int32_t VideoCaptureDS::StopCapture()
{
CriticalSectionScoped cs(&_apiCs);
@ -201,20 +200,20 @@ bool VideoCaptureDS::CaptureStarted()
return state == State_Running;
}
WebRtc_Word32 VideoCaptureDS::CaptureSettings(
int32_t VideoCaptureDS::CaptureSettings(
VideoCaptureCapability& settings)
{
settings = _requestedCapability;
return 0;
}
WebRtc_Word32 VideoCaptureDS::SetCameraOutput(
int32_t VideoCaptureDS::SetCameraOutput(
const VideoCaptureCapability& requestedCapability)
{
// Get the best matching capability
VideoCaptureCapability capability;
WebRtc_Word32 capabilityIndex;
int32_t capabilityIndex;
// Store the new requested size
_requestedCapability = requestedCapability;
@ -326,7 +325,7 @@ WebRtc_Word32 VideoCaptureDS::SetCameraOutput(
return 0;
}
WebRtc_Word32 VideoCaptureDS::DisconnectGraph()
int32_t VideoCaptureDS::DisconnectGraph()
{
HRESULT hr = _mediaControl->Stop();
hr += _graphBuilder->Disconnect(_outputCapturePin);

15
webrtc/modules/video_capture/windows/video_capture_ds.h
View File

@ -29,19 +29,18 @@ class CaptureSinkFilter;
class VideoCaptureDS: public VideoCaptureImpl
{
public:
VideoCaptureDS(const WebRtc_Word32 id);
VideoCaptureDS(const int32_t id);
virtual WebRtc_Word32 Init(const WebRtc_Word32 id,
const char* deviceUniqueIdUTF8);
virtual int32_t Init(const int32_t id, const char* deviceUniqueIdUTF8);
/*************************************************************************
*
* Start/Stop
*
*************************************************************************/
virtual WebRtc_Word32
virtual int32_t
StartCapture(const VideoCaptureCapability& capability);
virtual WebRtc_Word32 StopCapture();
virtual int32_t StopCapture();
/**************************************************************************
*
@ -50,16 +49,16 @@ public:
**************************************************************************/
virtual bool CaptureStarted();
virtual WebRtc_Word32 CaptureSettings(VideoCaptureCapability& settings);
virtual int32_t CaptureSettings(VideoCaptureCapability& settings);
protected:
virtual ~VideoCaptureDS();
// Help functions
WebRtc_Word32
int32_t
SetCameraOutput(const VideoCaptureCapability& requestedCapability);
WebRtc_Word32 DisconnectGraph();
int32_t DisconnectGraph();
HRESULT VideoCaptureDS::ConnectDVCamera();
DeviceInfoDS _dsInfo;

4
webrtc/modules/video_capture/windows/video_capture_factory_windows.cc
View File

@ -17,12 +17,12 @@ namespace videocapturemodule {
// static
VideoCaptureModule::DeviceInfo* VideoCaptureImpl::CreateDeviceInfo(
const WebRtc_Word32 id) {
const int32_t id) {
// TODO(tommi): Use the Media Foundation version on Vista and up.
return DeviceInfoDS::Create(id);
}
VideoCaptureModule* VideoCaptureImpl::Create(const WebRtc_Word32 id,
VideoCaptureModule* VideoCaptureImpl::Create(const int32_t id,
const char* device_id) {
if (device_id == NULL)
return NULL;

11
webrtc/modules/video_capture/windows/video_capture_mf.cc
View File

@ -13,20 +13,19 @@
namespace webrtc {
namespace videocapturemodule {
VideoCaptureMF::VideoCaptureMF(const WebRtc_Word32 id) : VideoCaptureImpl(id) {}
VideoCaptureMF::VideoCaptureMF(const int32_t id) : VideoCaptureImpl(id) {}
VideoCaptureMF::~VideoCaptureMF() {}
WebRtc_Word32 VideoCaptureMF::Init(const WebRtc_Word32 id,
const char* device_id) {
int32_t VideoCaptureMF::Init(const int32_t id, const char* device_id) {
return 0;
}
WebRtc_Word32 VideoCaptureMF::StartCapture(
int32_t VideoCaptureMF::StartCapture(
const VideoCaptureCapability& capability) {
return -1;
}
WebRtc_Word32 VideoCaptureMF::StopCapture() {
int32_t VideoCaptureMF::StopCapture() {
return -1;
}
@ -34,7 +33,7 @@ bool VideoCaptureMF::CaptureStarted() {
return false;
}
WebRtc_Word32 VideoCaptureMF::CaptureSettings(
int32_t VideoCaptureMF::CaptureSettings(
VideoCaptureCapability& settings) {
return -1;
}

10
webrtc/modules/video_capture/windows/video_capture_mf.h
View File

@ -22,15 +22,15 @@ namespace videocapturemodule {
// for supported platforms.
class VideoCaptureMF : public VideoCaptureImpl {
public:
explicit VideoCaptureMF(const WebRtc_Word32 id);
explicit VideoCaptureMF(const int32_t id);
WebRtc_Word32 Init(const WebRtc_Word32 id, const char* device_id);
int32_t Init(const int32_t id, const char* device_id);
// Overrides from VideoCaptureImpl.
virtual WebRtc_Word32 StartCapture(const VideoCaptureCapability& capability);
virtual WebRtc_Word32 StopCapture();
virtual int32_t StartCapture(const VideoCaptureCapability& capability);
virtual int32_t StopCapture();
virtual bool CaptureStarted();
virtual WebRtc_Word32 CaptureSettings(
virtual int32_t CaptureSettings(
VideoCaptureCapability& settings); // NOLINT
protected: