diff --git a/webrtc/modules/video_capture/android/device_info_android.cc b/webrtc/modules/video_capture/android/device_info_android.cc index ca16ebf08..e2e6f8a06 100644 --- a/webrtc/modules/video_capture/android/device_info_android.cc +++ b/webrtc/modules/video_capture/android/device_info_android.cc @@ -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; diff --git a/webrtc/modules/video_capture/android/device_info_android.h b/webrtc/modules/video_capture/android/device_info_android.h index 4db3445ac..bfebd9cba 100644 --- a/webrtc/modules/video_capture/android/device_info_android.h +++ b/webrtc/modules/video_capture/android/device_info_android.h @@ -30,28 +30,28 @@ 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, - VideoCaptureRotation& orientation); + 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); enum {_expectedCaptureDelay = 190}; diff --git a/webrtc/modules/video_capture/android/video_capture_android.cc b/webrtc/modules/video_capture/android/video_capture_android.cc index 7321495b2..b8ee51463 100644 --- a/webrtc/modules/video_capture/android/video_capture_android.cc +++ b/webrtc/modules/video_capture/android/video_capture_android.cc @@ -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* implementation = @@ -64,8 +64,8 @@ jobject VideoCaptureAndroid::g_javaContext = NULL; /* * Register references to Java Capture class. */ -WebRtc_Word32 VideoCaptureAndroid::SetAndroidObjects(void* javaVM, - void* javaContext) { +int32_t VideoCaptureAndroid::SetAndroidObjects(void* javaVM, + void* javaContext) { g_jvm = static_cast (javaVM); g_javaContext = static_cast (javaContext); @@ -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,8 +310,8 @@ 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, - const char* deviceUniqueIdUTF8) { +int32_t VideoCaptureAndroid::Init(const int32_t id, + const char* deviceUniqueIdUTF8) { const int nameLength = strlen(deviceUniqueIdUTF8); if (nameLength >= kVideoCaptureUniqueNameLength) { return -1; @@ -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) { diff --git a/webrtc/modules/video_capture/android/video_capture_android.h b/webrtc/modules/video_capture/android/video_capture_android.h index 3fd7e64b1..2a87eb25e 100644 --- a/webrtc/modules/video_capture/android/video_capture_android.h +++ b/webrtc/modules/video_capture/android/video_capture_android.h @@ -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(); diff --git a/webrtc/modules/video_capture/device_info_impl.cc b/webrtc/modules/video_capture/device_info_impl.cc index e0d5e7ea3..a17493463 100644 --- a/webrtc/modules/video_capture/device_info_impl.cc +++ b/webrtc/modules/video_capture/device_info_impl.cc @@ -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,13 +73,13 @@ 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, - VideoCaptureCapability& capability) +int32_t DeviceInfoImpl::GetCapability(const char* deviceUniqueIdUTF8, + const uint32_t deviceCapabilityNumber, + VideoCaptureCapability& capability) { if (!deviceUniqueIdUTF8) @@ -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 (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,8 +388,8 @@ WebRtc_Word32 DeviceInfoImpl::GetExpectedCaptureDelay( } //Default implementation. This should be overridden by Mobile implementations. -WebRtc_Word32 DeviceInfoImpl::GetOrientation(const char* deviceUniqueIdUTF8, - VideoCaptureRotation& orientation) +int32_t DeviceInfoImpl::GetOrientation(const char* deviceUniqueIdUTF8, + VideoCaptureRotation& orientation) { orientation = kCameraRotate0; return -1; diff --git a/webrtc/modules/video_capture/device_info_impl.h b/webrtc/modules/video_capture/device_info_impl.h index 0bc4711e1..1634c611d 100644 --- a/webrtc/modules/video_capture/device_info_impl.h +++ b/webrtc/modules/video_capture/device_info_impl.h @@ -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, - const char* productId, - const WebRtc_UWord32 width, - const WebRtc_UWord32 height); + int32_t GetExpectedCaptureDelay(const DelayValues delayValues[], + const uint32_t sizeOfDelayValues, + const char* productId, + 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 diff --git a/webrtc/modules/video_capture/external/device_info_external.cc b/webrtc/modules/video_capture/external/device_info_external.cc index ab70bdaa8..64dfa1607 100644 --- a/webrtc/modules/video_capture/external/device_info_external.cc +++ b/webrtc/modules/video_capture/external/device_info_external.cc @@ -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); } diff --git a/webrtc/modules/video_capture/external/video_capture_external.cc b/webrtc/modules/video_capture/external/video_capture_external.cc index dcc59aa80..5ec2b0419 100644 --- a/webrtc/modules/video_capture/external/video_capture_external.cc +++ b/webrtc/modules/video_capture/external/video_capture_external.cc @@ -16,7 +16,7 @@ namespace webrtc { namespace videocapturemodule { VideoCaptureModule* VideoCaptureImpl::Create( - const WebRtc_Word32 id, + const int32_t id, const char* deviceUniqueIdUTF8) { RefCountImpl* implementation = new RefCountImpl(id); diff --git a/webrtc/modules/video_capture/include/video_capture.h b/webrtc/modules/video_capture/include/video_capture.h index 736a539fc..ca04fb7ba 100644 --- a/webrtc/modules/video_capture/include/video_capture.h +++ b/webrtc/modules/video_capture/include/video_capture.h @@ -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() {}; diff --git a/webrtc/modules/video_capture/include/video_capture_defines.h b/webrtc/modules/video_capture/include/video_capture_defines.h index 990ab6371..bb20082e2 100644 --- a/webrtc/modules/video_capture/include/video_capture_defines.h +++ b/webrtc/modules/video_capture/include/video_capture_defines.h @@ -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, - const VideoCaptureCapability& frameInfo, - WebRtc_Word64 captureTime = 0) = 0; - virtual WebRtc_Word32 IncomingFrameI420(const VideoFrameI420& video_frame, - WebRtc_Word64 captureTime = 0) = 0; + virtual int32_t IncomingFrame(uint8_t* videoFrame, + int32_t videoFrameLength, + const VideoCaptureCapability& frameInfo, + 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(){} diff --git a/webrtc/modules/video_capture/include/video_capture_factory.h b/webrtc/modules/video_capture/include/video_capture_factory.h index 27c6ebaf2..06219e3aa 100644 --- a/webrtc/modules/video_capture/include/video_capture_factory.h +++ b/webrtc/modules/video_capture/include/video_capture_factory.h @@ -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: diff --git a/webrtc/modules/video_capture/linux/device_info_linux.cc b/webrtc/modules/video_capture/linux/device_info_linux.cc index 239a29267..186fdea37 100644 --- a/webrtc/modules/video_capture/linux/device_info_linux.cc +++ b/webrtc/modules/video_capture/linux/device_info_linux.cc @@ -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 diff --git a/webrtc/modules/video_capture/linux/device_info_linux.h b/webrtc/modules/video_capture/linux/device_info_linux.h index 2826fe86b..6aa53b8a3 100644 --- a/webrtc/modules/video_capture/linux/device_info_linux.h +++ b/webrtc/modules/video_capture/linux/device_info_linux.h @@ -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); diff --git a/webrtc/modules/video_capture/linux/video_capture_linux.cc b/webrtc/modules/video_capture/linux/video_capture_linux.cc index c2fdac0c6..0e7b597b8 100644 --- a/webrtc/modules/video_capture/linux/video_capture_linux.cc +++ b/webrtc/modules/video_capture/linux/video_capture_linux.cc @@ -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* 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; diff --git a/webrtc/modules/video_capture/linux/video_capture_linux.h b/webrtc/modules/video_capture/linux/video_capture_linux.h index e5f6ae7c6..e4b6dc6cc 100644 --- a/webrtc/modules/video_capture/linux/video_capture_linux.h +++ b/webrtc/modules/video_capture/linux/video_capture_linux.h @@ -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 diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h index 7b5710c3f..4273c6000 100644 --- a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h @@ -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 diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.mm b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.mm index 77284daa1..e68923219 100644 --- a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.mm +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.mm @@ -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; diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.h b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.h index 39847ea01..446254219 100644 --- a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.h +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.h @@ -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; diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.mm b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.mm index df61f0839..9a8db3c19 100644 --- a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.mm +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.mm @@ -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 diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h index a77a6daaf..a7fd58a0f 100644 --- a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h @@ -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_ diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.mm b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.mm index 6bd2cfc61..2a2a8ac87 100644 --- a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.mm +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.mm @@ -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]; } diff --git a/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.cc b/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.cc index 69fd67a30..2f93cda18 100644 --- a/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.cc +++ b/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.cc @@ -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); diff --git a/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.h b/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.h index 84e0667e1..cbd99edc0 100644 --- a/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.h +++ b/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time.h @@ -18,116 +18,114 @@ #include - #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); - virtual ~VideoCaptureMacQuickTime(); + public: + VideoCaptureMacQuickTime(const int32_t id); + virtual ~VideoCaptureMacQuickTime(); - static void Destroy(VideoCaptureModule* module); + 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(); - virtual bool CaptureStarted(); - virtual WebRtc_Word32 CaptureSettings(VideoCaptureCapability& settings); + 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 int32_t CaptureSettings(VideoCaptureCapability& settings); - // TODO: remove? - int VideoCaptureInitThreadContext(); - int VideoCaptureTerminate(); - int VideoCaptureSetCaptureDevice(const char* deviceName, int size); - int UpdateCaptureSettings(int channel, webrtc::VideoCodec& inst, bool def); - int VideoCaptureRun(); - int VideoCaptureStop(); + // TODO: remove? + int VideoCaptureInitThreadContext(); + int VideoCaptureTerminate(); + int VideoCaptureSetCaptureDevice(const char* deviceName, int size); + int UpdateCaptureSettings(int channel, webrtc::VideoCodec& inst, bool def); + int VideoCaptureRun(); + int VideoCaptureStop(); -protected: + protected: -private: // functions + private: // functions - struct VideoCaptureMacName - { - VideoCaptureMacName(); + struct VideoCaptureMacName { + VideoCaptureMacName(); - enum { kVideoCaptureMacNameMaxSize = 64}; - char _name[kVideoCaptureMacNameMaxSize]; - CFIndex _size; + 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}; - // Temporary constant allowing this size from builtin iSight webcams. - enum { kYuy2_1280_1024_length = 2621440}; + // Timeout value [ms] if we want to create a new device list or not + enum { + kVideoCaptureDeviceListTimeout = 5000 + }; + // Temporary constant allowing this size from builtin iSight webcams. + enum { + kYuy2_1280_1024_length = 2621440 + }; -private: + private: - // Capture device callback - static OSErr SendProcess(SGChannel sgChannel, Ptr p, long len, long *offset, - long chRefCon, TimeValue time, short writeType, - long refCon); - int SendFrame(SGChannel sgChannel, char* data, long length, TimeValue time); + // Capture device callback + static OSErr SendProcess(SGChannel sgChannel, Ptr p, long len, long* offset, + long chRefCon, TimeValue time, short writeType, + long refCon); + int SendFrame(SGChannel sgChannel, char* data, long length, TimeValue time); - // Capture device functions - int CreateLocalGWorld(int width, int height); - int RemoveLocalGWorld(); - int ConnectCaptureDevice(); - int DisconnectCaptureDevice(); - virtual bool IsCaptureDeviceSelected(); + // Capture device functions + int CreateLocalGWorld(int width, int height); + int RemoveLocalGWorld(); + int ConnectCaptureDevice(); + int DisconnectCaptureDevice(); + virtual bool IsCaptureDeviceSelected(); - // Process to make sure the capture device won't stop - static bool GrabberUpdateThread(void*); - bool GrabberUpdateProcess(); + // Process to make sure the capture device won't stop + static bool GrabberUpdateThread(void*); + bool GrabberUpdateProcess(); - // Starts and stops the capture - int StartQuickTimeCapture(); - int StopQuickTimeCapture(bool* wasCapturing = NULL); + // Starts and stops the capture + int StartQuickTimeCapture(); + int StopQuickTimeCapture(bool* wasCapturing = NULL); - static CFIndex PascalStringToCString(const unsigned char* pascalString, - char* cString, - CFIndex bufferSize); + static CFIndex PascalStringToCString(const unsigned char* pascalString, + char* cString, CFIndex bufferSize); -private: // variables - WebRtc_Word32 _id; - bool _isCapturing; - VideoCaptureCapability _captureCapability; - CriticalSectionWrapper* _grabberCritsect; - CriticalSectionWrapper* _videoMacCritsect; - bool _terminated; - webrtc::ThreadWrapper* _grabberUpdateThread; - webrtc::EventWrapper* _grabberUpdateEvent; - SeqGrabComponent _captureGrabber; - Component _captureDevice; - char _captureDeviceDisplayName[64]; - RawVideoType _captureVideoType; - bool _captureIsInitialized; - GWorldPtr _gWorld; - SGChannel _captureChannel; - ImageSequence _captureSequence; - bool _sgPrepared; - bool _sgStarted; - int _trueCaptureWidth; - int _trueCaptureHeight; - ListWrapper _captureDeviceList; - unsigned long _captureDeviceListTime; - ListWrapper _captureCapabilityList; + private : // variables + int32_t _id; + bool _isCapturing; + VideoCaptureCapability _captureCapability; + CriticalSectionWrapper* _grabberCritsect; + CriticalSectionWrapper* _videoMacCritsect; + bool _terminated; + webrtc::ThreadWrapper* _grabberUpdateThread; + webrtc::EventWrapper* _grabberUpdateEvent; + SeqGrabComponent _captureGrabber; + Component _captureDevice; + char _captureDeviceDisplayName[64]; + RawVideoType _captureVideoType; + bool _captureIsInitialized; + GWorldPtr _gWorld; + SGChannel _captureChannel; + ImageSequence _captureSequence; + bool _sgPrepared; + bool _sgStarted; + int _trueCaptureWidth; + int _trueCaptureHeight; + ListWrapper _captureDeviceList; + unsigned long _captureDeviceListTime; + ListWrapper _captureCapabilityList; }; } // namespace webrtc #endif // WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QUICKTIME_VIDEO_CAPTURE_QUICK_TIME_H_ diff --git a/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.cc b/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.cc index 152ab7036..15330ae61 100644 --- a/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.cc +++ b/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.cc @@ -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) { diff --git a/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.h b/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.h index 4cc84833d..bd92114b2 100644 --- a/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.h +++ b/webrtc/modules/video_capture/mac/quicktime/video_capture_quick_time_info.h @@ -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 diff --git a/webrtc/modules/video_capture/mac/video_capture_mac.mm b/webrtc/modules/video_capture/mac/video_capture_mac.mm index 6ed9ddbf8..2f9197e0a 100644 --- a/webrtc/modules/video_capture/mac/video_capture_mac.mm +++ b/webrtc/modules/video_capture/mac/video_capture_mac.mm @@ -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) { diff --git a/webrtc/modules/video_capture/test/video_capture_unittest.cc b/webrtc/modules/video_capture/test/video_capture_unittest.cc index cd4f147cf..4a069c119 100644 --- a/webrtc/modules/video_capture/test/video_capture_unittest.cc +++ b/webrtc/modules/video_capture/test/video_capture_unittest.cc @@ -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 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 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) { diff --git a/webrtc/modules/video_capture/video_capture_delay.h b/webrtc/modules/video_capture/video_capture_delay.h index 9f5b76ef3..4352644bb 100644 --- a/webrtc/modules/video_capture/video_capture_delay.h +++ b/webrtc/modules/video_capture/video_capture_delay.h @@ -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 }; diff --git a/webrtc/modules/video_capture/video_capture_factory.cc b/webrtc/modules/video_capture/video_capture_factory.cc index 6b792e14d..6a6b5981a 100644 --- a/webrtc/modules/video_capture/video_capture_factory.cc +++ b/webrtc/modules/video_capture/video_capture_factory.cc @@ -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); } diff --git a/webrtc/modules/video_capture/video_capture_impl.cc b/webrtc/modules/video_capture/video_capture_impl.cc index eb2b4aad2..9b6ae0eeb 100644 --- a/webrtc/modules/video_capture/video_capture_impl.cc +++ b/webrtc/modules/video_capture/video_capture_impl.cc @@ -26,7 +26,7 @@ namespace webrtc namespace videocapturemodule { VideoCaptureModule* VideoCaptureImpl::Create( - const WebRtc_Word32 id, + const int32_t id, VideoCaptureExternal*& externalCapture) { RefCountImpl* 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); } } diff --git a/webrtc/modules/video_capture/video_capture_impl.h b/webrtc/modules/video_capture/video_capture_impl.h index da5d60d71..905c37ea5 100644 --- a/webrtc/modules/video_capture/video_capture_impl.h +++ b/webrtc/modules/video_capture/video_capture_impl.h @@ -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, - const VideoCaptureCapability& frameInfo, - WebRtc_Word64 captureTime = 0); - virtual WebRtc_Word32 IncomingFrameI420( + virtual int32_t IncomingFrame(uint8_t* videoFrame, + int32_t videoFrameLength, + const VideoCaptureCapability& frameInfo, + 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, - VideoCodecType codec_type); + 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 diff --git a/webrtc/modules/video_capture/windows/device_info_ds.cc b/webrtc/modules/video_capture/windows/device_info_ds.cc index d7db9a34a..14606b7ba 100644 --- a/webrtc/modules/video_capture/windows/device_info_ds.cc +++ b/webrtc/modules/video_capture/windows/device_info_ds.cc @@ -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, - deviceNameLength, - deviceUniqueIdUTF8, - deviceUniqueIdUTF8Length, - productUniqueIdUTF8, - productUniqueIdUTF8Length); - return result > (WebRtc_Word32) deviceNumber ? 0 : -1; + const int32_t result = GetDeviceInfo(deviceNumber, deviceNameUTF8, + deviceNameLength, + deviceUniqueIdUTF8, + deviceUniqueIdUTF8Length, + productUniqueIdUTF8, + productUniqueIdUTF8Length); + 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 (&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 (&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; diff --git a/webrtc/modules/video_capture/windows/device_info_ds.h b/webrtc/modules/video_capture/windows/device_info_ds.h index 33ccdf5e5..7dc3e6c63 100644 --- a/webrtc/modules/video_capture/windows/device_info_ds.h +++ b/webrtc/modules/video_capture/windows/device_info_ds.h @@ -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, - char* deviceNameUTF8, - WebRtc_UWord32 deviceNameLength, - char* deviceUniqueIdUTF8, - WebRtc_UWord32 deviceUniqueIdUTF8Length, - char* productUniqueIdUTF8, - WebRtc_UWord32 productUniqueIdUTF8Length); + int32_t GetDeviceInfo(uint32_t deviceNumber, + char* deviceNameUTF8, + uint32_t deviceNameLength, + char* deviceUniqueIdUTF8, + uint32_t deviceUniqueIdUTF8Length, + char* productUniqueIdUTF8, + uint32_t productUniqueIdUTF8Length); - virtual WebRtc_Word32 + virtual int32_t CreateCapabilityMap(const char* deviceUniqueIdUTF8); private: diff --git a/webrtc/modules/video_capture/windows/device_info_mf.cc b/webrtc/modules/video_capture/windows/device_info_mf.cc index 61f4f46ec..aa747f1a3 100644 --- a/webrtc/modules/video_capture/windows/device_info_mf.cc +++ b/webrtc/modules/video_capture/windows/device_info_mf.cc @@ -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; } diff --git a/webrtc/modules/video_capture/windows/device_info_mf.h b/webrtc/modules/video_capture/windows/device_info_mf.h index cf1297f6d..cb5638af6 100644 --- a/webrtc/modules/video_capture/windows/device_info_mf.h +++ b/webrtc/modules/video_capture/windows/device_info_mf.h @@ -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 diff --git a/webrtc/modules/video_capture/windows/sink_filter_ds.cc b/webrtc/modules/video_capture/windows/sink_filter_ds.cc index db57eb263..b0f9b448d 100644 --- a/webrtc/modules/video_capture/windows/sink_filter_ds.cc +++ b/webrtc/modules/video_capture/windows/sink_filter_ds.cc @@ -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 diff --git a/webrtc/modules/video_capture/windows/sink_filter_ds.h b/webrtc/modules/video_capture/windows/sink_filter_ds.h index 78e34e3b2..010bc7e68 100644 --- a/webrtc/modules/video_capture/windows/sink_filter_ds.h +++ b/webrtc/modules/video_capture/windows/sink_filter_ds.h @@ -29,18 +29,18 @@ class CaptureSinkFilter; class CaptureInputPin: public CBaseInputPin { public: - WebRtc_Word32 _moduleId; + int32_t _moduleId; VideoCaptureCapability _requestedCapability; VideoCaptureCapability _resultingCapability; HANDLE _threadHandle; - CaptureInputPin ( WebRtc_Word32 moduleId, - IN TCHAR* szName, - IN CaptureSinkFilter* pFilter, - IN CCritSec * pLock, - OUT HRESULT * pHr, - IN LPCWSTR pszName); + CaptureInputPin(int32_t moduleId, + IN TCHAR* szName, + IN CaptureSinkFilter* pFilter, + IN CCritSec * pLock, + OUT HRESULT * pHr, + IN LPCWSTR pszName); virtual ~CaptureInputPin(); HRESULT GetMediaType (IN int iPos, OUT CMediaType * pmt); @@ -53,17 +53,17 @@ class CaptureSinkFilter: public CBaseFilter { public: - CaptureSinkFilter (IN TCHAR * tszName, - IN LPUNKNOWN punk, - OUT HRESULT * phr, - VideoCaptureExternal& captureObserver, - WebRtc_Word32 moduleId); + CaptureSinkFilter(IN TCHAR * tszName, + IN LPUNKNOWN punk, + OUT HRESULT * phr, + VideoCaptureExternal& captureObserver, + 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 diff --git a/webrtc/modules/video_capture/windows/video_capture_ds.cc b/webrtc/modules/video_capture/windows/video_capture_ds.cc index 275d987a7..9aa03a8d0 100644 --- a/webrtc/modules/video_capture/windows/video_capture_ds.cc +++ b/webrtc/modules/video_capture/windows/video_capture_ds.cc @@ -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); diff --git a/webrtc/modules/video_capture/windows/video_capture_ds.h b/webrtc/modules/video_capture/windows/video_capture_ds.h index 48c49909f..dd4afbc7e 100644 --- a/webrtc/modules/video_capture/windows/video_capture_ds.h +++ b/webrtc/modules/video_capture/windows/video_capture_ds.h @@ -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; diff --git a/webrtc/modules/video_capture/windows/video_capture_factory_windows.cc b/webrtc/modules/video_capture/windows/video_capture_factory_windows.cc index 815ff0251..8b6737ff1 100644 --- a/webrtc/modules/video_capture/windows/video_capture_factory_windows.cc +++ b/webrtc/modules/video_capture/windows/video_capture_factory_windows.cc @@ -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; diff --git a/webrtc/modules/video_capture/windows/video_capture_mf.cc b/webrtc/modules/video_capture/windows/video_capture_mf.cc index 873165d9e..34cdf3e8a 100644 --- a/webrtc/modules/video_capture/windows/video_capture_mf.cc +++ b/webrtc/modules/video_capture/windows/video_capture_mf.cc @@ -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; } diff --git a/webrtc/modules/video_capture/windows/video_capture_mf.h b/webrtc/modules/video_capture/windows/video_capture_mf.h index 5271eeb3d..5fba9c2de 100644 --- a/webrtc/modules/video_capture/windows/video_capture_mf.h +++ b/webrtc/modules/video_capture/windows/video_capture_mf.h @@ -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: