diff --git a/webrtc/modules/video_capture/BUILD.gn b/webrtc/modules/video_capture/BUILD.gn index cd4d3c91b8..60573ba4b1 100644 --- a/webrtc/modules/video_capture/BUILD.gn +++ b/webrtc/modules/video_capture/BUILD.gn @@ -60,7 +60,7 @@ rtc_static_library("video_capture") { if (!build_with_chromium) { config("video_capture_internal_impl_config") { - if (is_ios || is_mac) { + if (is_ios) { libs = [ "AVFoundation.framework", "CoreMedia.framework", @@ -104,6 +104,30 @@ if (!build_with_chromium) { ] deps += [ "../..:webrtc_common" ] } + if (is_mac) { + sources = [ + "mac/qtkit/video_capture_qtkit.h", + "mac/qtkit/video_capture_qtkit.mm", + "mac/qtkit/video_capture_qtkit_info.h", + "mac/qtkit/video_capture_qtkit_info.mm", + "mac/qtkit/video_capture_qtkit_info_objc.h", + "mac/qtkit/video_capture_qtkit_info_objc.mm", + "mac/qtkit/video_capture_qtkit_objc.h", + "mac/qtkit/video_capture_qtkit_objc.mm", + "mac/qtkit/video_capture_qtkit_utility.h", + "mac/video_capture_mac.mm", + ] + + libs = [ + # For NSAlert in video_capture_qtkit_info_objc.mm. + "Cocoa.framework", + + # For GetGestalt in video_capture_mac.mm. + "CoreServices.framework", + "CoreVideo.framework", + "QTKit.framework", + ] + } if (is_win) { sources = [ "windows/device_info_ds.cc", @@ -125,16 +149,16 @@ if (!build_with_chromium) { deps += [ "//third_party/winsdk_samples" ] } - if (is_ios || is_mac) { + if (is_ios) { sources = [ - "objc/device_info.h", - "objc/device_info.mm", - "objc/device_info_objc.h", - "objc/device_info_objc.mm", - "objc/rtc_video_capture_objc.h", - "objc/rtc_video_capture_objc.mm", - "objc/video_capture.h", - "objc/video_capture.mm", + "ios/device_info_ios.h", + "ios/device_info_ios.mm", + "ios/device_info_ios_objc.h", + "ios/device_info_ios_objc.mm", + "ios/rtc_video_capture_ios_objc.h", + "ios/rtc_video_capture_ios_objc.mm", + "ios/video_capture_ios.h", + "ios/video_capture_ios.mm", ] cflags = [ @@ -159,6 +183,7 @@ if (!build_with_chromium) { if (!is_android && rtc_include_tests) { rtc_test("video_capture_tests") { sources = [ + "test/video_capture_main_mac.mm", "test/video_capture_unittest.cc", ] @@ -190,7 +215,11 @@ if (!build_with_chromium) { "../utility", "//testing/gtest", ] - deps += [ "//webrtc/test:test_support_main" ] + if (is_mac) { + deps += [ "//webrtc/test:test_support_main_threaded_mac" ] + } else { + deps += [ "//webrtc/test:test_support_main" ] + } if (is_clang) { # Suppress warnings from Chrome's Clang plugins. diff --git a/webrtc/modules/video_capture/objc/device_info.h b/webrtc/modules/video_capture/ios/device_info_ios.h similarity index 91% rename from webrtc/modules/video_capture/objc/device_info.h rename to webrtc/modules/video_capture/ios/device_info_ios.h index bec5c694ba..6af7c33899 100644 --- a/webrtc/modules/video_capture/objc/device_info.h +++ b/webrtc/modules/video_capture/ios/device_info_ios.h @@ -8,13 +8,12 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_DEVICE_INFO_H_ -#define WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_DEVICE_INFO_H_ +#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_IOS_DEVICE_INFO_IOS_H_ +#define WEBRTC_MODULES_VIDEO_CAPTURE_IOS_DEVICE_INFO_IOS_H_ #include "webrtc/modules/video_capture/device_info_impl.h" #include -#include namespace webrtc { namespace videocapturemodule { @@ -58,4 +57,4 @@ class DeviceInfoIos : public DeviceInfoImpl { } // namespace videocapturemodule } // namespace webrtc -#endif // WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_DEVICE_INFO_H_ +#endif // WEBRTC_MODULES_VIDEO_CAPTURE_IOS_DEVICE_INFO_IOS_H_ diff --git a/webrtc/modules/video_capture/objc/device_info.mm b/webrtc/modules/video_capture/ios/device_info_ios.mm similarity index 81% rename from webrtc/modules/video_capture/objc/device_info.mm rename to webrtc/modules/video_capture/ios/device_info_ios.mm index 2535f1c69e..307e5d3605 100644 --- a/webrtc/modules/video_capture/objc/device_info.mm +++ b/webrtc/modules/video_capture/ios/device_info_ios.mm @@ -16,22 +16,26 @@ #include -#include "webrtc/modules/video_capture/objc/device_info.h" -#include "webrtc/modules/video_capture/objc/device_info_objc.h" +#include "webrtc/modules/video_capture/ios/device_info_ios.h" +#include "webrtc/modules/video_capture/ios/device_info_ios_objc.h" #include "webrtc/modules/video_capture/video_capture_impl.h" #include "webrtc/system_wrappers/include/trace.h" using namespace webrtc; using namespace videocapturemodule; -static NSArray* camera_presets = @[ - AVCaptureSessionPreset352x288, AVCaptureSessionPreset640x480, - AVCaptureSessionPreset1280x720 -]; +static NSArray *camera_presets = @[AVCaptureSessionPreset352x288, + AVCaptureSessionPreset640x480, + AVCaptureSessionPreset1280x720, + AVCaptureSessionPreset1920x1080]; -#define IOS_UNSUPPORTED() \ - WEBRTC_TRACE(kTraceError, kTraceVideoCapture, _id, \ - "%s is not supported on the iOS platform.", __FUNCTION__); \ + +#define IOS_UNSUPPORTED() \ + WEBRTC_TRACE(kTraceError, \ + kTraceVideoCapture, \ + _id, \ + "%s is not supported on the iOS platform.", \ + __FUNCTION__); \ return -1; VideoCaptureModule::DeviceInfo* VideoCaptureImpl::CreateDeviceInfo( @@ -52,10 +56,10 @@ int32_t DeviceInfoIos::Init() { int deviceCount = [DeviceInfoIosObjC captureDeviceCount]; for (int i = 0; i < deviceCount; i++) { - AVCaptureDevice* avDevice = [DeviceInfoIosObjC captureDeviceForIndex:i]; + AVCaptureDevice *avDevice = [DeviceInfoIosObjC captureDeviceForIndex:i]; VideoCaptureCapabilities capabilityVector; - for (NSString* preset in camera_presets) { + for (NSString *preset in camera_presets) { BOOL support = [avDevice supportsAVCaptureSessionPreset:preset]; if (support) { VideoCaptureCapability capability = @@ -69,8 +73,8 @@ int32_t DeviceInfoIos::Init() { this->GetDeviceName(i, deviceNameUTF8, 256, deviceId, 256); std::string deviceIdCopy(deviceId); std::pair mapPair = - std::pair(deviceIdCopy, - capabilityVector); + std::pair + (deviceIdCopy, capabilityVector); _capabilitiesMap.insert(mapPair); } @@ -96,7 +100,9 @@ int32_t DeviceInfoIos::GetDeviceName(uint32_t deviceNumber, strncpy(deviceNameUTF8, [deviceName UTF8String], deviceNameUTF8Length); deviceNameUTF8[deviceNameUTF8Length - 1] = '\0'; - strncpy(deviceUniqueIdUTF8, deviceUniqueId.UTF8String, deviceUniqueIdUTF8Length); + strncpy(deviceUniqueIdUTF8, + [deviceUniqueId UTF8String], + deviceUniqueIdUTF8Length); deviceUniqueIdUTF8[deviceUniqueIdUTF8Length - 1] = '\0'; if (productUniqueIdUTF8) { diff --git a/webrtc/modules/video_capture/objc/device_info_objc.h b/webrtc/modules/video_capture/ios/device_info_ios_objc.h similarity index 82% rename from webrtc/modules/video_capture/objc/device_info_objc.h rename to webrtc/modules/video_capture/ios/device_info_ios_objc.h index b5db689e30..d67b559972 100644 --- a/webrtc/modules/video_capture/objc/device_info_objc.h +++ b/webrtc/modules/video_capture/ios/device_info_ios_objc.h @@ -8,8 +8,8 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_DEVICE_INFO_OBJC_H_ -#define WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_DEVICE_INFO_OBJC_H_ +#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_IOS_DEVICE_INFO_IOS_OBJC_H_ +#define WEBRTC_MODULES_VIDEO_CAPTURE_IOS_DEVICE_INFO_IOS_OBJC_H_ #import @@ -26,4 +26,4 @@ @end -#endif // WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_DEVICE_INFO_OBJC_H_ +#endif // WEBRTC_MODULES_VIDEO_CAPTURE_IOS_DEVICE_INFO_IOS_OBJC_H_ diff --git a/webrtc/modules/video_capture/objc/device_info_objc.mm b/webrtc/modules/video_capture/ios/device_info_ios_objc.mm similarity index 86% rename from webrtc/modules/video_capture/objc/device_info_objc.mm rename to webrtc/modules/video_capture/ios/device_info_ios_objc.mm index d46fa5c346..818f8624c7 100644 --- a/webrtc/modules/video_capture/objc/device_info_objc.mm +++ b/webrtc/modules/video_capture/ios/device_info_ios_objc.mm @@ -14,7 +14,7 @@ #import -#import "webrtc/modules/video_capture/objc/device_info_objc.h" +#import "webrtc/modules/video_capture/ios/device_info_ios_objc.h" #include "webrtc/modules/video_capture/video_capture_config.h" @implementation DeviceInfoIosObjC @@ -83,6 +83,15 @@ capability.rawType = webrtc::kVideoNV12; capability.codecType = webrtc::kVideoCodecUnknown; capability.interlaced = false; + } else if ([preset isEqualToString:AVCaptureSessionPreset1920x1080]) { + capability.width = 1920; + capability.height = 1080; + capability.maxFPS = 30; + capability.expectedCaptureDelay = + webrtc::videocapturemodule::kDefaultCaptureDelay; + capability.rawType = webrtc::kVideoNV12; + capability.codecType = webrtc::kVideoCodecUnknown; + capability.interlaced = false; } return capability; diff --git a/webrtc/modules/video_capture/objc/rtc_video_capture_objc.h b/webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.h similarity index 77% rename from webrtc/modules/video_capture/objc/rtc_video_capture_objc.h rename to webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.h index e108ee1bb3..2653958130 100644 --- a/webrtc/modules/video_capture/objc/rtc_video_capture_objc.h +++ b/webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.h @@ -8,15 +8,13 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_RTC_VIDEO_CAPTURE_OBJC_H_ -#define WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_RTC_VIDEO_CAPTURE_OBJC_H_ +#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_IOS_VIDEO_CAPTURE_IOS_OBJC_H_ +#define WEBRTC_MODULES_VIDEO_CAPTURE_IOS_VIDEO_CAPTURE_IOS_OBJC_H_ #import -#ifdef WEBRTC_IOS #import -#endif -#include "webrtc/modules/video_capture/objc/video_capture.h" +#include "webrtc/modules/video_capture/ios/video_capture_ios.h" // The following class listens to a notification with name: // 'StatusBarOrientationDidChange'. @@ -34,8 +32,8 @@ captureId:(int)captureId; - (BOOL)setCaptureDeviceByUniqueId:(NSString*)uniqueId; - (BOOL)startCaptureWithCapability: - (const webrtc::VideoCaptureCapability&)capability; + (const webrtc::VideoCaptureCapability&)capability; - (BOOL)stopCapture; @end -#endif // WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_RTC_VIDEO_CAPTURE_OBJC_H_ +#endif // WEBRTC_MODULES_VIDEO_CAPTURE_IOS_VIDEO_CAPTURE_IOS_OBJC_H_ diff --git a/webrtc/modules/video_capture/objc/rtc_video_capture_objc.mm b/webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.mm similarity index 78% rename from webrtc/modules/video_capture/objc/rtc_video_capture_objc.mm rename to webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.mm index 10671eb2ae..e36c83bad9 100644 --- a/webrtc/modules/video_capture/objc/rtc_video_capture_objc.mm +++ b/webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.mm @@ -12,13 +12,10 @@ #error "This file requires ARC support." #endif -#import -#ifdef WEBRTC_IOS #import -#endif -#import "webrtc/modules/video_capture/objc/device_info_objc.h" -#import "webrtc/modules/video_capture/objc/rtc_video_capture_objc.h" +#import "webrtc/modules/video_capture/ios/device_info_ios_objc.h" +#import "webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.h" #include "webrtc/system_wrappers/include/trace.h" @@ -47,8 +44,7 @@ using namespace webrtc::videocapturemodule; _owner = owner; _captureId = captureId; _captureSession = [[AVCaptureSession alloc] init]; -#if defined(__IPHONE_7_0) && defined(__IPHONE_OS_VERSION_MAX_ALLOWED) \ - && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_7_0 +#if defined(__IPHONE_7_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_7_0 NSString* version = [[UIDevice currentDevice] systemVersion]; if ([version integerValue] >= 7) { _captureSession.usesApplicationAudioSession = NO; @@ -76,12 +72,15 @@ using namespace webrtc::videocapturemodule; if ([_captureSession canAddOutput:captureOutput]) { [_captureSession addOutput:captureOutput]; } else { - WEBRTC_TRACE(kTraceError, kTraceVideoCapture, _captureId, + WEBRTC_TRACE(kTraceError, + kTraceVideoCapture, + _captureId, "%s:%s:%d Could not add output to AVCaptureSession ", - __FILE__, __FUNCTION__, __LINE__); + __FILE__, + __FUNCTION__, + __LINE__); } -#ifdef WEBRTC_IOS [[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications]; NSNotificationCenter* notify = [NSNotificationCenter defaultCenter]; @@ -93,7 +92,6 @@ using namespace webrtc::videocapturemodule; selector:@selector(deviceOrientationDidChange:) name:UIDeviceOrientationDidChangeNotification object:nil]; -#endif } return self; @@ -146,7 +144,12 @@ using namespace webrtc::videocapturemodule; return NO; } - if ([_captureSession canSetSessionPreset:AVCaptureSessionPreset1280x720]) { + if ([_captureSession canSetSessionPreset:AVCaptureSessionPreset1920x1080]) { + if (capability.width > 1920 || capability.height > 1080) { + return NO; + } + } else if ([_captureSession + canSetSessionPreset:AVCaptureSessionPreset1280x720]) { if (capability.width > 1280 || capability.height > 720) { return NO; } @@ -174,10 +177,9 @@ using namespace webrtc::videocapturemodule; _orientationHasChanged = NO; _captureChanging = YES; - dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), - ^{ - [self startCaptureInBackgroundWithOutput:currentOutput]; - }); + dispatch_async( + dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), + ^(void) { [self startCaptureInBackgroundWithOutput:currentOutput]; }); return YES; } @@ -186,10 +188,13 @@ using namespace webrtc::videocapturemodule; } - (void)startCaptureInBackgroundWithOutput: - (AVCaptureVideoDataOutput*)currentOutput { + (AVCaptureVideoDataOutput*)currentOutput { NSString* captureQuality = [NSString stringWithString:AVCaptureSessionPresetLow]; - if (_capability.width >= 1280 || _capability.height >= 720) { + if (_capability.width >= 1920 || _capability.height >= 1080) { + captureQuality = + [NSString stringWithString:AVCaptureSessionPreset1920x1080]; + } else if (_capability.width >= 1280 || _capability.height >= 720) { captureQuality = [NSString stringWithString:AVCaptureSessionPreset1280x720]; } else if (_capability.width >= 640 || _capability.height >= 480) { captureQuality = [NSString stringWithString:AVCaptureSessionPreset640x480]; @@ -203,6 +208,30 @@ using namespace webrtc::videocapturemodule; // picture resolution [_captureSession setSessionPreset:captureQuality]; + // take care of capture framerate now + NSArray* sessionInputs = _captureSession.inputs; + AVCaptureDeviceInput* deviceInput = [sessionInputs count] > 0 ? + sessionInputs[0] : nil; + AVCaptureDevice* inputDevice = deviceInput.device; + if (inputDevice) { + AVCaptureDeviceFormat* activeFormat = inputDevice.activeFormat; + NSArray* supportedRanges = activeFormat.videoSupportedFrameRateRanges; + AVFrameRateRange* targetRange = [supportedRanges count] > 0 ? + supportedRanges[0] : nil; + // Find the largest supported framerate less than capability maxFPS. + for (AVFrameRateRange* range in supportedRanges) { + if (range.maxFrameRate <= _capability.maxFPS && + targetRange.maxFrameRate <= range.maxFrameRate) { + targetRange = range; + } + } + if (targetRange && [inputDevice lockForConfiguration:NULL]) { + inputDevice.activeVideoMinFrameDuration = targetRange.minFrameDuration; + inputDevice.activeVideoMaxFrameDuration = targetRange.minFrameDuration; + [inputDevice unlockForConfiguration]; + } + } + _connection = [currentOutput connectionWithMediaType:AVMediaTypeVideo]; [self setRelativeVideoOrientation]; @@ -217,47 +246,49 @@ using namespace webrtc::videocapturemodule; if (!_connection.supportsVideoOrientation) { return; } -#ifndef WEBRTC_IOS - _connection.videoOrientation = AVCaptureVideoOrientationLandscapeRight; - return; -#else + switch ([UIDevice currentDevice].orientation) { case UIDeviceOrientationPortrait: - _connection.videoOrientation = AVCaptureVideoOrientationPortrait; + _connection.videoOrientation = + AVCaptureVideoOrientationPortrait; break; case UIDeviceOrientationPortraitUpsideDown: _connection.videoOrientation = AVCaptureVideoOrientationPortraitUpsideDown; break; case UIDeviceOrientationLandscapeLeft: - _connection.videoOrientation = AVCaptureVideoOrientationLandscapeRight; + _connection.videoOrientation = + AVCaptureVideoOrientationLandscapeRight; break; case UIDeviceOrientationLandscapeRight: - _connection.videoOrientation = AVCaptureVideoOrientationLandscapeLeft; + _connection.videoOrientation = + AVCaptureVideoOrientationLandscapeLeft; break; case UIDeviceOrientationFaceUp: case UIDeviceOrientationFaceDown: case UIDeviceOrientationUnknown: if (!_orientationHasChanged) { - _connection.videoOrientation = AVCaptureVideoOrientationPortrait; + _connection.videoOrientation = + AVCaptureVideoOrientationPortrait; } break; } -#endif } - (void)onVideoError:(NSNotification*)notification { NSLog(@"onVideoError: %@", notification); // TODO(sjlee): make the specific error handling with this notification. - WEBRTC_TRACE(kTraceError, kTraceVideoCapture, _captureId, - "%s:%s:%d [AVCaptureSession startRunning] error.", __FILE__, - __FUNCTION__, __LINE__); + WEBRTC_TRACE(kTraceError, + kTraceVideoCapture, + _captureId, + "%s:%s:%d [AVCaptureSession startRunning] error.", + __FILE__, + __FUNCTION__, + __LINE__); } - (BOOL)stopCapture { -#ifdef WEBRTC_IOS [[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications]; -#endif _orientationHasChanged = NO; [self waitForCaptureChangeToFinish]; [self directOutputToNil]; @@ -268,9 +299,7 @@ using namespace webrtc::videocapturemodule; _captureChanging = YES; dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), - ^(void) { - [self stopCaptureInBackground]; - }); + ^(void) { [self stopCaptureInBackground]; }); return YES; } @@ -313,9 +342,14 @@ using namespace webrtc::videocapturemodule; if (!newCaptureInput) { const char* errorMessage = [[deviceError localizedDescription] UTF8String]; - WEBRTC_TRACE(kTraceError, kTraceVideoCapture, _captureId, - "%s:%s:%d deviceInputWithDevice error:%s", __FILE__, - __FUNCTION__, __LINE__, errorMessage); + WEBRTC_TRACE(kTraceError, + kTraceVideoCapture, + _captureId, + "%s:%s:%d deviceInputWithDevice error:%s", + __FILE__, + __FUNCTION__, + __LINE__, + errorMessage); return NO; } diff --git a/webrtc/modules/video_capture/objc/video_capture.h b/webrtc/modules/video_capture/ios/video_capture_ios.h similarity index 87% rename from webrtc/modules/video_capture/objc/video_capture.h rename to webrtc/modules/video_capture/ios/video_capture_ios.h index 1f9f420945..5172855161 100644 --- a/webrtc/modules/video_capture/objc/video_capture.h +++ b/webrtc/modules/video_capture/ios/video_capture_ios.h @@ -8,8 +8,8 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_VIDEO_CAPTURE_H_ -#define WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_VIDEO_CAPTURE_H_ +#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_IOS_VIDEO_CAPTURE_IOS_H_ +#define WEBRTC_MODULES_VIDEO_CAPTURE_IOS_VIDEO_CAPTURE_IOS_H_ #include "webrtc/base/scoped_ref_ptr.h" #include "webrtc/modules/video_capture/video_capture_impl.h" @@ -43,4 +43,4 @@ class VideoCaptureIos : public VideoCaptureImpl { } // namespace videocapturemodule } // namespace webrtc -#endif // WEBRTC_MODULES_VIDEO_CAPTURE_OBJC_VIDEO_CAPTURE_H_ +#endif // WEBRTC_MODULES_VIDEO_CAPTURE_IOS_VIDEO_CAPTURE_IOS_H_ diff --git a/webrtc/modules/video_capture/objc/video_capture.mm b/webrtc/modules/video_capture/ios/video_capture_ios.mm similarity index 86% rename from webrtc/modules/video_capture/objc/video_capture.mm rename to webrtc/modules/video_capture/ios/video_capture_ios.mm index e73b47ae0e..7a1f17bd13 100644 --- a/webrtc/modules/video_capture/objc/video_capture.mm +++ b/webrtc/modules/video_capture/ios/video_capture_ios.mm @@ -14,8 +14,8 @@ #include "webrtc/base/refcount.h" #include "webrtc/base/scoped_ref_ptr.h" -#include "webrtc/modules/video_capture/objc/device_info_objc.h" -#include "webrtc/modules/video_capture/objc/rtc_video_capture_objc.h" +#include "webrtc/modules/video_capture/ios/device_info_ios_objc.h" +#include "webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.h" #include "webrtc/system_wrappers/include/trace.h" using namespace webrtc; @@ -67,10 +67,9 @@ rtc::scoped_refptr VideoCaptureIos::Create( return nullptr; } - if (![capture_module->capture_device_ - setCaptureDeviceByUniqueId: - [[NSString alloc] initWithCString:deviceUniqueIdUTF8 - encoding:NSUTF8StringEncoding]]) { + if (![capture_module->capture_device_ setCaptureDeviceByUniqueId:[ + [NSString alloc] initWithCString:deviceUniqueIdUTF8 + encoding:NSUTF8StringEncoding]]) { return nullptr; } return capture_module; @@ -98,9 +97,7 @@ int32_t VideoCaptureIos::StopCapture() { return 0; } -bool VideoCaptureIos::CaptureStarted() { - return is_capturing_; -} +bool VideoCaptureIos::CaptureStarted() { return is_capturing_; } int32_t VideoCaptureIos::CaptureSettings(VideoCaptureCapability& settings) { settings = capability_; diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h new file mode 100644 index 0000000000..e3ddd9fe10 --- /dev/null +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_H_ +#define WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_H_ + +#import +#include + +#include "webrtc/modules/video_capture/device_info_impl.h" +#include "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_utility.h" +#include "webrtc/modules/video_capture/video_capture_impl.h" + +@class VideoCaptureMacQTKitObjC; +@class VideoCaptureMacQTKitInfoObjC; + +namespace webrtc +{ +namespace videocapturemodule +{ + +class VideoCaptureMacQTKit : public VideoCaptureImpl +{ +public: + VideoCaptureMacQTKit(const int32_t id); + virtual ~VideoCaptureMacQTKit(); + + /* + * Create a video capture module object + * + * id - unique identifier of this video capture module object + * deviceUniqueIdUTF8 - name of the device. Available names can be found + * by using GetDeviceName + * deviceUniqueIdUTF8Length - length of deviceUniqueIdUTF8 + */ + static void Destroy(VideoCaptureModule* module); + + int32_t Init(const int32_t id, const char* deviceUniqueIdUTF8); + + + // Start/Stop + virtual int32_t StartCapture( + const VideoCaptureCapability& capability); + virtual int32_t StopCapture(); + + // Properties of the set device + + virtual bool CaptureStarted(); + + int32_t CaptureSettings(VideoCaptureCapability& settings); + +protected: + // Help functions + int32_t SetCameraOutput(); + +private: + VideoCaptureMacQTKitObjC* _captureDevice; + VideoCaptureMacQTKitInfoObjC* _captureInfo; + bool _isCapturing; + 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]; + int32_t _frameCount; +}; +} // namespace videocapturemodule +} // namespace webrtc + +#endif // WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_H_ diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.mm b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.mm new file mode 100644 index 0000000000..ad057b49db --- /dev/null +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.mm @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h" +#import "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h" +#import "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.h" +#include "webrtc/modules/video_capture/video_capture_config.h" +#include "webrtc/system_wrappers/include/critical_section_wrapper.h" +#include "webrtc/system_wrappers/include/trace.h" + +namespace webrtc +{ + +namespace videocapturemodule +{ + +VideoCaptureMacQTKit::VideoCaptureMacQTKit(const int32_t id) : + VideoCaptureImpl(id), + _captureDevice(NULL), + _captureInfo(NULL), + _isCapturing(false), + _id(id), + _captureWidth(QTKIT_DEFAULT_WIDTH), + _captureHeight(QTKIT_DEFAULT_HEIGHT), + _captureFrameRate(QTKIT_DEFAULT_FRAME_RATE), + _frameCount(0) +{ + + memset(_currentDeviceNameUTF8, 0, MAX_NAME_LENGTH); + memset(_currentDeviceUniqueIdUTF8, 0, MAX_NAME_LENGTH); + memset(_currentDeviceProductUniqueIDUTF8, 0, MAX_NAME_LENGTH); +} + +VideoCaptureMacQTKit::~VideoCaptureMacQTKit() +{ + + WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, _id, + "~VideoCaptureMacQTKit() called"); + if(_captureDevice) + { + [_captureDevice registerOwner:nil]; + [_captureDevice stopCapture]; + [_captureDevice release]; + } + + if(_captureInfo) + { + [_captureInfo release]; + } +} + +int32_t VideoCaptureMacQTKit::Init( + const int32_t id, const char* iDeviceUniqueIdUTF8) +{ + CriticalSectionScoped cs(&_apiCs); + + + const int32_t nameLength = + (int32_t) strlen((char*)iDeviceUniqueIdUTF8); + if(nameLength>kVideoCaptureUniqueNameLength) + return -1; + + // Store the device name + _deviceUniqueId = new char[nameLength+1]; + memcpy(_deviceUniqueId, iDeviceUniqueIdUTF8,nameLength+1); + + _captureDevice = [[VideoCaptureMacQTKitObjC alloc] init]; + if(NULL == _captureDevice) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, id, + "Failed to create an instance of " + "VideoCaptureMacQTKitObjC"); + return -1; + } + + [_captureDevice registerOwner:this]; + + if(0 == strcmp((char*)iDeviceUniqueIdUTF8, "")) + { + // the user doesn't want to set a capture device at this time + return 0; + } + + _captureInfo = [[VideoCaptureMacQTKitInfoObjC alloc]init]; + if(nil == _captureInfo) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, id, + "Failed to create an instance of VideoCaptureMacQTKitInfoObjC"); + return -1; + } + + int captureDeviceCount = [[_captureInfo getCaptureDeviceCount]intValue]; + if(captureDeviceCount < 0) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, id, + "No Capture Devices Present"); + return -1; + } + + const int NAME_LENGTH = 1024; + char deviceNameUTF8[1024] = ""; + char deviceUniqueIdUTF8[1024] = ""; + char deviceProductUniqueIDUTF8[1024] = ""; + + bool captureDeviceFound = false; + for(int index = 0; index < captureDeviceCount; index++){ + + memset(deviceNameUTF8, 0, NAME_LENGTH); + memset(deviceUniqueIdUTF8, 0, NAME_LENGTH); + memset(deviceProductUniqueIDUTF8, 0, NAME_LENGTH); + if(-1 == [[_captureInfo getDeviceNamesFromIndex:index + DefaultName:deviceNameUTF8 WithLength:NAME_LENGTH + AndUniqueID:deviceUniqueIdUTF8 WithLength:NAME_LENGTH + AndProductID:deviceProductUniqueIDUTF8 + WithLength:NAME_LENGTH]intValue]) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id, + "GetDeviceName returned -1 for index %d", index); + return -1; + } + if(0 == strcmp((const char*)iDeviceUniqueIdUTF8, + (char*)deviceUniqueIdUTF8)) + { + // we have a match + captureDeviceFound = true; + break; + } + } + + if(false == captureDeviceFound) + { + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id, + "Failed to find capture device unique ID %s", + iDeviceUniqueIdUTF8); + return -1; + } + + // at this point we know that the user has passed in a valid camera. Let's + // set it as the current. + if(![_captureDevice setCaptureDeviceById:(char*)deviceUniqueIdUTF8]) + { + strcpy((char*)_deviceUniqueId, (char*)deviceUniqueIdUTF8); + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id, + "Failed to set capture device %s (unique ID %s) even " + "though it was a valid return from " + "VideoCaptureMacQTKitInfo", deviceNameUTF8, + iDeviceUniqueIdUTF8); + return -1; + } + + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id, + "successfully Init VideoCaptureMacQTKit" ); + return 0; +} + +int32_t VideoCaptureMacQTKit::StartCapture( + const VideoCaptureCapability& capability) +{ + + _captureWidth = capability.width; + _captureHeight = capability.height; + _captureFrameRate = capability.maxFPS; + _captureDelay = 120; + + [_captureDevice setCaptureHeight:_captureHeight + width:_captureWidth + frameRate:_captureFrameRate]; + + [_captureDevice startCapture]; + _isCapturing = true; + return 0; +} + +int32_t VideoCaptureMacQTKit::StopCapture() +{ + [_captureDevice stopCapture]; + _isCapturing = false; + return 0; +} + +bool VideoCaptureMacQTKit::CaptureStarted() +{ + return _isCapturing; +} + +int32_t VideoCaptureMacQTKit::CaptureSettings(VideoCaptureCapability& settings) +{ + settings.width = _captureWidth; + settings.height = _captureHeight; + settings.maxFPS = _captureFrameRate; + return 0; +} + + +// ********** begin functions inherited from DeviceInfoImpl ********** + +struct VideoCaptureCapabilityMacQTKit:public VideoCaptureCapability +{ + VideoCaptureCapabilityMacQTKit() + { + } +}; +} // namespace videocapturemodule +} // namespace webrtc 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 new file mode 100644 index 0000000000..fd994ad676 --- /dev/null +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.h @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_INFO_H_ +#define WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_INFO_H_ + +#include "webrtc/modules/video_capture/device_info_impl.h" +#include "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_utility.h" +#include "webrtc/modules/video_capture/video_capture_impl.h" + + +@class VideoCaptureMacQTKitInfoObjC; + +namespace webrtc +{ +namespace videocapturemodule +{ + +class VideoCaptureMacQTKitInfo: public DeviceInfoImpl +{ +public: + + VideoCaptureMacQTKitInfo(const int32_t id); + virtual ~VideoCaptureMacQTKitInfo(); + + int32_t Init(); + + virtual uint32_t NumberOfDevices(); + + /* + * Returns the available capture devices. + * deviceNumber -[in] index of capture device + * deviceNameUTF8 - friendly name of the capture device + * deviceUniqueIdUTF8 - unique name of the capture device if it exist. + * Otherwise same as deviceNameUTF8 + * productUniqueIdUTF8 - unique product id if it exist. Null terminated + * otherwise. + */ + virtual int32_t GetDeviceName( + uint32_t deviceNumber, char* deviceNameUTF8, + uint32_t deviceNameLength, char* deviceUniqueIdUTF8, + uint32_t deviceUniqueIdUTF8Length, + char* productUniqueIdUTF8 = 0, + uint32_t productUniqueIdUTF8Length = 0); + + /* + * Returns the number of capabilities for this device + */ + virtual int32_t NumberOfCapabilities( + const char* deviceUniqueIdUTF8); + + /* + * Gets the capabilities of the named device + */ + virtual int32_t GetCapability( + const char* deviceUniqueIdUTF8, + 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 int32_t GetBestMatchedCapability( + const char* deviceUniqueIdUTF8, + const VideoCaptureCapability& requested, + VideoCaptureCapability& resulting); + + /* + * Display OS /capture device specific settings dialog + */ + virtual int32_t DisplayCaptureSettingsDialogBox( + const char* deviceUniqueIdUTF8, + const char* dialogTitleUTF8, void* parentWindow, + uint32_t positionX, uint32_t positionY); + +protected: + virtual int32_t CreateCapabilityMap( + const char* deviceUniqueIdUTF8); + + VideoCaptureMacQTKitInfoObjC* _captureInfo; +}; +} // namespace videocapturemodule +} // namespace webrtc + +#endif // WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_INFO_H_ 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 new file mode 100644 index 0000000000..0c0c6a1261 --- /dev/null +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.mm @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#import "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h" +#include "webrtc/modules/video_capture/video_capture.h" +#include "webrtc/modules/video_capture/video_capture_config.h" +#include "webrtc/system_wrappers/include/trace.h" + +namespace webrtc +{ +namespace videocapturemodule +{ + +VideoCaptureMacQTKitInfo::VideoCaptureMacQTKitInfo(const int32_t id) : + DeviceInfoImpl(id) +{ + _captureInfo = [[VideoCaptureMacQTKitInfoObjC alloc] init]; +} + +VideoCaptureMacQTKitInfo::~VideoCaptureMacQTKitInfo() +{ + [_captureInfo release]; + +} + +int32_t VideoCaptureMacQTKitInfo::Init() +{ + + return 0; +} + +uint32_t VideoCaptureMacQTKitInfo::NumberOfDevices() +{ + + uint32_t captureDeviceCount = + [[_captureInfo getCaptureDeviceCount]intValue]; + return captureDeviceCount; + +} + +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 + AndUniqueID:deviceUniqueIdUTF8 + WithLength:deviceUniqueIdUTF8Length + AndProductID:productUniqueIdUTF8 + WithLength:productUniqueIdUTF8Length]intValue]; + return errNum; +} + +int32_t VideoCaptureMacQTKitInfo::NumberOfCapabilities( + const char* deviceUniqueIdUTF8) +{ + // Not implemented. Mac doesn't use discrete steps in capabilities, rather + // "analog". QTKit will do it's best to convert frames to what ever format + // you ask for. + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id, + "NumberOfCapabilities is not supported on the Mac platform."); + return -1; +} + + +int32_t VideoCaptureMacQTKitInfo::GetCapability( + const char* deviceUniqueIdUTF8, + const uint32_t deviceCapabilityNumber, + VideoCaptureCapability& capability) +{ + // Not implemented. Mac doesn't use discrete steps in capabilities, rather + // "analog". QTKit will do it's best to convert frames to what ever format + // you ask for. + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id, + "NumberOfCapabilities is not supported on the Mac platform."); + return -1; +} + + +int32_t VideoCaptureMacQTKitInfo::GetBestMatchedCapability( + const char*deviceUniqueIdUTF8, + const VideoCaptureCapability& requested, VideoCaptureCapability& resulting) +{ + // Not implemented. Mac doesn't use discrete steps in capabilities, rather + // "analog". QTKit will do it's best to convert frames to what ever format + // you ask for. + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id, + "NumberOfCapabilities is not supported on the Mac platform."); + return -1; +} + +int32_t VideoCaptureMacQTKitInfo::DisplayCaptureSettingsDialogBox( + const char* deviceUniqueIdUTF8, + const char* dialogTitleUTF8, void* parentWindow, + uint32_t positionX, uint32_t positionY) +{ + + return [[_captureInfo + displayCaptureSettingsDialogBoxWithDevice:deviceUniqueIdUTF8 + AndTitle:dialogTitleUTF8 + AndParentWindow:parentWindow AtX:positionX AndY:positionY] + intValue]; +} + +int32_t VideoCaptureMacQTKitInfo::CreateCapabilityMap( + const char* deviceUniqueIdUTF8) +{ + // Not implemented. Mac doesn't use discrete steps in capabilities, rather + // "analog". QTKit will do it's best to convert frames to what ever format + // you ask for. + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id, + "NumberOfCapabilities is not supported on the Mac platform."); + return -1; +} +} // namespace videocapturemodule +} // namespace webrtc 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 new file mode 100644 index 0000000000..c03aa935f5 --- /dev/null +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +// +// video_capture_qtkit_info_objc.h +// +// + +#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_INFO_OBJC_H_ +#define WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_INFO_OBJC_H_ + +#import +#import + +#include "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.h" +#include "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_utility.h" + +@interface VideoCaptureMacQTKitInfoObjC : NSObject{ + bool _OSSupportedInfo; + NSArray* _captureDevicesInfo; + NSAutoreleasePool* _poolInfo; + int _captureDeviceCountInfo; + +} + +/************************************************************************** + * + * The following functions are considered to be private + * + ***************************************************************************/ + +- (NSNumber*)getCaptureDevices; +- (NSNumber*)initializeVariables; +- (void)checkOSSupported; + + +/************************************************************************** + * + * The following functions are considered to be public and called by VideoCaptureMacQTKitInfo class + * + ***************************************************************************/ + +- (NSNumber*)getCaptureDeviceCount; + +- (NSNumber*)getDeviceNamesFromIndex:(uint32_t)index + DefaultName:(char*)deviceName + WithLength:(uint32_t)deviceNameLength + AndUniqueID:(char*)deviceUniqueID + WithLength:(uint32_t)deviceUniqueIDLength + AndProductID:(char*)deviceProductID + WithLength:(uint32_t)deviceProductIDLength; + +- (NSNumber*)displayCaptureSettingsDialogBoxWithDevice: + (const char*)deviceUniqueIdUTF8 + AndTitle:(const char*)dialogTitleUTF8 + 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 new file mode 100644 index 0000000000..d3f2188bae --- /dev/null +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.mm @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#pragma mark **** imports/includes + +#import "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h" + +#include "webrtc/system_wrappers/include/trace.h" + +using namespace webrtc; + +#pragma mark **** hidden class interface + +@implementation VideoCaptureMacQTKitInfoObjC + +// ****************** over-written OS methods *********************** +#pragma mark **** over-written OS methods + +/// ***** Objective-C. Similar to C++ constructor, although invoked manually +/// ***** Potentially returns an instance of self +-(id)init{ + self = [super init]; + if(nil != self){ + [self checkOSSupported]; + [self initializeVariables]; + } + else + { + return nil; + } + return self; +} + +/// ***** Objective-C. Similar to C++ destructor +/// ***** Returns nothing +- (void)dealloc { + + [_captureDevicesInfo release]; + + [super dealloc]; +} + +// ****************** public methods ****************** +#pragma mark **** public method implementations + +/// ***** Creates a message box with Cocoa framework +/// ***** Returns 0 on success, -1 otherwise. +- (NSNumber*)displayCaptureSettingsDialogBoxWithDevice:(const char*)deviceUniqueIdUTF8 + AndTitle:(const char*)dialogTitleUTF8 + AndParentWindow:(void*) parentWindow + AtX:(uint32_t)positionX + AndY:(uint32_t) positionY +{ + NSString* strTitle = [NSString stringWithFormat:@"%s", dialogTitleUTF8]; + NSString* strButton = @"Alright"; + NSAlert* alert = [NSAlert alertWithMessageText:strTitle + defaultButton:strButton + alternateButton:nil otherButton:nil + informativeTextWithFormat:@"Device %s is capturing", deviceUniqueIdUTF8]; + [alert setAlertStyle:NSInformationalAlertStyle]; + [alert runModal]; + return [NSNumber numberWithInt:0]; +} + +- (NSNumber*)getCaptureDeviceCount{ + [self getCaptureDevices]; + return [NSNumber numberWithInt:_captureDeviceCountInfo]; +} + + +- (NSNumber*)getDeviceNamesFromIndex:(uint32_t)index + DefaultName:(char*)deviceName + WithLength:(uint32_t)deviceNameLength + AndUniqueID:(char*)deviceUniqueID + WithLength:(uint32_t)deviceUniqueIDLength + AndProductID:(char*)deviceProductID + WithLength:(uint32_t)deviceProductIDLength +{ + if(NO == _OSSupportedInfo) + { + return [NSNumber numberWithInt:0]; + } + + if(index >= (uint32_t)_captureDeviceCountInfo) + { + return [NSNumber numberWithInt:-1]; + } + + QTCaptureDevice* tempCaptureDevice = + (QTCaptureDevice*)[_captureDevicesInfo objectAtIndex:index]; + if(!tempCaptureDevice) + { + return [NSNumber numberWithInt:-1]; + } + + memset(deviceName, 0, deviceNameLength); + memset(deviceUniqueID, 0, deviceUniqueIDLength); + + bool successful = NO; + + NSString* tempString = [tempCaptureDevice localizedDisplayName]; + successful = [tempString getCString:(char*)deviceName + maxLength:deviceNameLength encoding:NSUTF8StringEncoding]; + if(NO == successful) + { + memset(deviceName, 0, deviceNameLength); + return [NSNumber numberWithInt:-1]; + } + + tempString = [tempCaptureDevice uniqueID]; + successful = [tempString getCString:(char*)deviceUniqueID + maxLength:deviceUniqueIDLength encoding:NSUTF8StringEncoding]; + if(NO == successful) + { + memset(deviceUniqueID, 0, deviceNameLength); + return [NSNumber numberWithInt:-1]; + } + + return [NSNumber numberWithInt:0]; + +} + +// ****************** "private" category functions below here ****************** +#pragma mark **** "private" method implementations + +- (NSNumber*)initializeVariables +{ + if(NO == _OSSupportedInfo) + { + return [NSNumber numberWithInt:0]; + } + + _poolInfo = [[NSAutoreleasePool alloc]init]; + _captureDeviceCountInfo = 0; + [self getCaptureDevices]; + + return [NSNumber numberWithInt:0]; +} + +// ***** Checks to see if the QTCaptureSession framework is available in the OS +// ***** If it is not, isOSSupprted = NO +// ***** Throughout the rest of the class isOSSupprted is checked and functions +// ***** are/aren't called depending +// ***** The user can use weak linking to the QTKit framework and run on older +// ***** versions of the OS +// ***** I.E. Backwards compaitibility +// ***** Returns nothing. Sets member variable +- (void)checkOSSupported +{ + Class osSupportedTest = NSClassFromString(@"QTCaptureSession"); + if(nil == osSupportedTest) + { + _OSSupportedInfo = NO; + } + else + { + _OSSupportedInfo = YES; + } +} + +/// ***** Retrieves the number of capture devices currently available +/// ***** Stores them in an NSArray instance +/// ***** Returns 0 on success, -1 otherwise. +- (NSNumber*)getCaptureDevices +{ + if(NO == _OSSupportedInfo) + { + return [NSNumber numberWithInt:0]; + } + + if(_captureDevicesInfo) + { + [_captureDevicesInfo release]; + } + _captureDevicesInfo = [[NSArray alloc] + initWithArray:[QTCaptureDevice + inputDevicesWithMediaType:QTMediaTypeVideo]]; + + _captureDeviceCountInfo = _captureDevicesInfo.count; + + return [NSNumber numberWithInt:0]; +} + +@end diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.h b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.h new file mode 100644 index 0000000000..50076003cb --- /dev/null +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +// +// video_capture_qtkit_objc.h +// +// + +#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_OBJC_H_ +#define WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_OBJC_H_ + +#import +#import +#import +#import +#import +#import + +#include "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h" + +@interface VideoCaptureMacQTKitObjC : NSObject { + bool _capturing; + int _frameRate; + int _frameWidth; + int _frameHeight; + int _framesDelivered; + int _framesRendered; + bool _captureInitialized; + + webrtc::videocapturemodule::VideoCaptureMacQTKit* _owner; + NSLock* _lock; + + QTCaptureSession* _captureSession; + QTCaptureDeviceInput* _captureVideoDeviceInput; + QTCaptureDecompressedVideoOutput* _captureDecompressedVideoOutput; + NSArray* _captureDevices; + int _captureDeviceCount; + char _captureDeviceNameUTF8[1024]; + char _captureDeviceNameUniqueID[1024]; +} + +- (void)getCaptureDevices; +- (BOOL)initializeVideoCapture; +- (BOOL)initializeVariables; + +- (void)registerOwner:(webrtc::videocapturemodule::VideoCaptureMacQTKit*)owner; +- (BOOL)setCaptureDeviceById:(char*)uniqueId; +- (void)setCaptureHeight:(int)height width:(int)width frameRate:(int)frameRate; +- (void)startCapture; +- (void)stopCapture; + +@end + +#endif // WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_OBJC_H_ diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.mm b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.mm new file mode 100644 index 0000000000..53e9db7770 --- /dev/null +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.mm @@ -0,0 +1,259 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#define DEFAULT_CAPTURE_DEVICE_INDEX 1 +#define DEFAULT_FRAME_RATE 30 +#define DEFAULT_FRAME_WIDTH 352 +#define DEFAULT_FRAME_HEIGHT 288 +#define ROTATE_CAPTURED_FRAME 1 +#define LOW_QUALITY 1 + +#import "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.h" + +#include "webrtc/system_wrappers/include/trace.h" + +using namespace webrtc; +using namespace videocapturemodule; + +@implementation VideoCaptureMacQTKitObjC + +-(id)init { + self = [super init]; + if (self) { + [self initializeVariables]; + } + return self; +} + +- (void)dealloc { + if (_captureSession) + [_captureSession stopRunning]; + + if (_captureVideoDeviceInput) { + if ([[_captureVideoDeviceInput device] isOpen]) + [[_captureVideoDeviceInput device] close]; + + [_captureVideoDeviceInput release]; + } + + [_captureDecompressedVideoOutput release]; + [_captureSession release]; + [_captureDevices release]; + [_lock release]; + + [super dealloc]; +} + +#pragma mark Public methods + +- (void)registerOwner:(VideoCaptureMacQTKit*)owner { + [_lock lock]; + _owner = owner; + [_lock unlock]; +} + +- (BOOL)setCaptureDeviceById:(char*)uniqueId { + if (uniqueId == nil || !strcmp("", uniqueId)) { + WEBRTC_TRACE(kTraceInfo, kTraceVideoCapture, 0, + "Incorrect capture id argument"); + return NO; + } + + if (!strcmp(uniqueId, _captureDeviceNameUniqueID)) + return YES; + + QTCaptureDevice* captureDevice; + for(int index = 0; index < _captureDeviceCount; index++) { + captureDevice = (QTCaptureDevice*)[_captureDevices objectAtIndex:index]; + char captureDeviceId[1024] = ""; + [[captureDevice uniqueID] getCString:captureDeviceId + maxLength:1024 + encoding:NSUTF8StringEncoding]; + if (strcmp(uniqueId, captureDeviceId) == 0) { + WEBRTC_TRACE(kTraceInfo, kTraceVideoCapture, 0, + "%s:%d Found capture device id %s as index %d", + __FUNCTION__, __LINE__, captureDeviceId, index); + [[captureDevice localizedDisplayName] getCString:_captureDeviceNameUTF8 + maxLength:1024 + encoding:NSUTF8StringEncoding]; + [[captureDevice uniqueID] getCString:_captureDeviceNameUniqueID + maxLength:1024 + encoding:NSUTF8StringEncoding]; + break; + } + captureDevice = nil; + } + + if (!captureDevice) + return NO; + + NSError* error; + if (![captureDevice open:&error]) { + WEBRTC_TRACE(kTraceError, kTraceVideoCapture, 0, + "Failed to open capture device: %s", _captureDeviceNameUTF8); + return NO; + } + + if (_captureVideoDeviceInput) { + [_captureVideoDeviceInput release]; + } + _captureVideoDeviceInput = + [[QTCaptureDeviceInput alloc] initWithDevice:captureDevice]; + + if (![_captureSession addInput:_captureVideoDeviceInput error:&error]) { + WEBRTC_TRACE(kTraceError, kTraceVideoCapture, 0, + "Failed to add input from %s to the capture session", + _captureDeviceNameUTF8); + return NO; + } + + WEBRTC_TRACE(kTraceInfo, kTraceVideoCapture, 0, + "%s:%d successfully added capture device: %s", __FUNCTION__, + __LINE__, _captureDeviceNameUTF8); + return YES; +} + +- (void)setCaptureHeight:(int)height width:(int)width frameRate:(int)frameRate { + _frameWidth = width; + _frameHeight = height; + _frameRate = frameRate; + + NSDictionary* captureDictionary = + [NSDictionary dictionaryWithObjectsAndKeys: + [NSNumber numberWithDouble:_frameWidth], + (id)kCVPixelBufferWidthKey, + [NSNumber numberWithDouble:_frameHeight], + (id)kCVPixelBufferHeightKey, + [NSNumber numberWithUnsignedInt:kCVPixelFormatType_32ARGB], + (id)kCVPixelBufferPixelFormatTypeKey, + nil]; + [_captureDecompressedVideoOutput + performSelectorOnMainThread:@selector(setPixelBufferAttributes:) + withObject:captureDictionary + waitUntilDone:YES]; +} + +- (void)startCapture { + if (_capturing) + return; + + [_captureSession startRunning]; + _capturing = YES; +} + +- (void)stopCapture { + if (!_capturing) + return; + + [_captureSession stopRunning]; + _capturing = NO; +} + +#pragma mark Private methods + +- (BOOL)initializeVariables { + if (NSClassFromString(@"QTCaptureSession") == nil) + return NO; + + memset(_captureDeviceNameUTF8, 0, 1024); + _framesDelivered = 0; + _framesRendered = 0; + _captureDeviceCount = 0; + _capturing = NO; + _captureInitialized = NO; + _frameRate = DEFAULT_FRAME_RATE; + _frameWidth = DEFAULT_FRAME_WIDTH; + _frameHeight = DEFAULT_FRAME_HEIGHT; + _lock = [[NSLock alloc] init]; + _captureSession = [[QTCaptureSession alloc] init]; + _captureDecompressedVideoOutput = + [[QTCaptureDecompressedVideoOutput alloc] init]; + [_captureDecompressedVideoOutput setDelegate:self]; + + [self getCaptureDevices]; + if (![self initializeVideoCapture]) + return NO; + + return NO; +} + +- (void)getCaptureDevices { + if (_captureDevices) + [_captureDevices release]; + + _captureDevices = [[NSArray alloc] initWithArray: + [QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeVideo]]; + + _captureDeviceCount = _captureDevices.count; +} + +- (BOOL)initializeVideoCapture{ + NSDictionary *captureDictionary = + [NSDictionary dictionaryWithObjectsAndKeys: + [NSNumber numberWithDouble:_frameWidth], + (id)kCVPixelBufferWidthKey, + [NSNumber numberWithDouble:_frameHeight], + (id)kCVPixelBufferHeightKey, + [NSNumber numberWithUnsignedInt:kCVPixelFormatType_32ARGB], + (id)kCVPixelBufferPixelFormatTypeKey, + nil]; + + [_captureDecompressedVideoOutput setPixelBufferAttributes:captureDictionary]; + [_captureDecompressedVideoOutput setAutomaticallyDropsLateVideoFrames:YES]; + [_captureDecompressedVideoOutput + setMinimumVideoFrameInterval:(NSTimeInterval)1/(float)_frameRate]; + + NSError *error; + if (![_captureSession addOutput:_captureDecompressedVideoOutput error:&error]) + return NO; + + return YES; +} + +- (void)captureOutput:(QTCaptureOutput *)captureOutput + didDropVideoFrameWithSampleBuffer:(QTSampleBuffer *)sampleBuffer + fromConnection:(QTCaptureConnection *)connection { +} + +- (void)captureOutput:(QTCaptureOutput *)captureOutput + didOutputVideoFrame:(CVImageBufferRef)videoFrame + withSampleBuffer:(QTSampleBuffer *)sampleBuffer + fromConnection:(QTCaptureConnection *)connection { + + [_lock lock]; + if (!_owner) { + [_lock unlock]; + return; + } + + const int kFlags = 0; + if (CVPixelBufferLockBaseAddress(videoFrame, kFlags) == kCVReturnSuccess) { + void *baseAddress = CVPixelBufferGetBaseAddress(videoFrame); + size_t bytesPerRow = CVPixelBufferGetBytesPerRow(videoFrame); + size_t frameHeight = CVPixelBufferGetHeight(videoFrame); + size_t frameSize = bytesPerRow * frameHeight; + + VideoCaptureCapability tempCaptureCapability; + tempCaptureCapability.width = _frameWidth; + tempCaptureCapability.height = _frameHeight; + tempCaptureCapability.maxFPS = _frameRate; + // TODO(wu) : Update actual type and not hard-coded value. + tempCaptureCapability.rawType = kVideoBGRA; + + _owner->IncomingFrame((unsigned char*)baseAddress, frameSize, + tempCaptureCapability, 0); + CVPixelBufferUnlockBaseAddress(videoFrame, kFlags); + } + [_lock unlock]; + _framesDelivered++; + _framesRendered++; +} + +@end diff --git a/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_utility.h b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_utility.h new file mode 100644 index 0000000000..5ef0b96b6b --- /dev/null +++ b/webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_utility.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +/* + * video_capture_qtkit_utility.h + * + */ + + +#ifndef WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_UTILITY_H_ +#define WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_UTILITY_H_ + +#define MAX_NAME_LENGTH 1024 + +#define QTKIT_MIN_WIDTH 0 +#define QTKIT_MAX_WIDTH 2560 +#define QTKIT_DEFAULT_WIDTH 352 + +#define QTKIT_MIN_HEIGHT 0 +#define QTKIT_MAX_HEIGHT 1440 +#define QTKIT_DEFAULT_HEIGHT 288 + +#define QTKIT_MIN_FRAME_RATE 1 +#define QTKIT_MAX_FRAME_RATE 60 +#define QTKIT_DEFAULT_FRAME_RATE 30 + +#define RELEASE_AND_CLEAR(p) if (p) { (p) -> Release () ; (p) = NULL ; } + +#endif // WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_MAC_QTKIT_VIDEO_CAPTURE_QTKIT_UTILITY_H_ diff --git a/webrtc/modules/video_capture/mac/video_capture_mac.mm b/webrtc/modules/video_capture/mac/video_capture_mac.mm new file mode 100644 index 0000000000..08b2aeb39a --- /dev/null +++ b/webrtc/modules/video_capture/mac/video_capture_mac.mm @@ -0,0 +1,252 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +/* + * video_capture_mac.cc + * + */ + +#include + +#include "webrtc/base/refcount.h" +#include "webrtc/base/scoped_ref_ptr.h" +#include "webrtc/modules/video_capture/device_info_impl.h" +#include "webrtc/modules/video_capture/video_capture_config.h" +#include "webrtc/modules/video_capture/video_capture_impl.h" +#include "webrtc/system_wrappers/include/trace.h" + +// 10.4 support must be decided runtime. We will just decide which framework to +// use at compile time "work" classes. One for QTKit, one for QuickTime +#if __MAC_OS_X_VERSION_MIN_REQUIRED == __MAC_10_4 // QuickTime version +#include +#include +#else +#include "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h" +#include "webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.h" +#endif + +namespace webrtc +{ +namespace videocapturemodule +{ + +// static +bool CheckOSVersion() +{ + // Check OSX version + OSErr err = noErr; + + SInt32 version; + + err = Gestalt(gestaltSystemVersion, &version); + if (err != noErr) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0, + "Could not get OS version"); + return false; + } + + if (version < 0x00001040) // Older version than Mac OSX 10.4 + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0, + "OS version too old: 0x%x", version); + return false; + } + + WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, 0, + "OS version compatible: 0x%x", version); + + return true; +} + +// static +bool CheckQTVersion() +{ + // Check OSX version + OSErr err = noErr; + + SInt32 version; + + err = Gestalt(gestaltQuickTime, &version); + if (err != noErr) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0, + "Could not get QuickTime version"); + return false; + } + + if (version < 0x07000000) // QT v. 7.x or newer (QT 5.0.2 0x05020000) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0, + "QuickTime version too old: 0x%x", version); + return false; + } + + WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, 0, + "QuickTime version compatible: 0x%x", version); + return true; +} + +/************************************************************************** + * + * Create/Destroy a VideoCaptureModule + * + ***************************************************************************/ + +/* + * Returns version of the module and its components + * + * version - buffer to which the version will be written + * remainingBufferInBytes - remaining number of int8_t in the version + * buffer + * position - position of the next empty int8_t in the + * version buffer + */ + +rtc::scoped_refptr VideoCaptureImpl::Create( + const int32_t id, + const char* deviceUniqueIdUTF8) { + if (!CheckOSVersion()) { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, id, + "OS version is too old. Could not create video capture " + "module. Returning NULL"); + return nullptr; + } + +#if __MAC_OS_X_VERSION_MIN_REQUIRED == __MAC_10_4 // QuickTime version + if (!CheckQTVersion()) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, id, + "QuickTime version is too old. Could not create video " + "capture module. Returning NULL"); + return nullptr; + } + + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, id, + "%s line %d. QTKit is not supported on this machine. Using " + "QuickTime framework to capture video", + __FILE__, __LINE__); + + rtc::scoped_refptr newCaptureModule( + new rtc::RefCountedObject(id)); + + if (newCaptureModule->Init(id, deviceUniqueIdUTF8) != 0) + { + WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, id, + "could not Create for unique device %s, " + "newCaptureModule->Init()!=0", + deviceUniqueIdUTF8); + return nullptr; + } + + // Successfully created VideoCaptureMacQuicktime. Return it + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, id, + "Module created for unique device %s. Will use QuickTime " + "framework to capture", + deviceUniqueIdUTF8); + return newCaptureModule; + +#else // QTKit version + + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, id, + "Using QTKit framework to capture video", id); + + rtc::scoped_refptr newCaptureModule( + new rtc::RefCountedObject(id)); + + if(newCaptureModule->Init(id, deviceUniqueIdUTF8) != 0) + { + WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, id, + "could not Create for unique device %s, " + "newCaptureModule->Init()!=0", deviceUniqueIdUTF8); + return nullptr; + } + + // Successfully created VideoCaptureMacQuicktime. Return it + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, id, + "Module created for unique device %s, will use QTKit " + "framework",deviceUniqueIdUTF8); + return newCaptureModule; +#endif +} + +/************************************************************************** + * + * Create/Destroy a DeviceInfo + * + ***************************************************************************/ + +VideoCaptureModule::DeviceInfo* +VideoCaptureImpl::CreateDeviceInfo(const int32_t id) +{ + + + if (webrtc::videocapturemodule::CheckOSVersion() == false) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, id, + "OS version is too old. Could not create video capture " + "module. Returning NULL"); + return NULL; + } + +#if __MAC_OS_X_VERSION_MIN_REQUIRED == __MAC_10_4 // QuickTime version + if (webrtc::videocapturemodule::CheckQTVersion() == false) + { + WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, id, + "QuickTime version is too old. Could not create video " + "capture module. Returning NULL"); + return NULL; + } + + webrtc::videocapturemodule::VideoCaptureMacQuickTimeInfo* newCaptureInfoModule = + new webrtc::videocapturemodule::VideoCaptureMacQuickTimeInfo(id); + + if (!newCaptureInfoModule || newCaptureInfoModule->Init() != 0) + { + Destroy(newCaptureInfoModule); + newCaptureInfoModule = NULL; + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, id, + "Failed to Init newCaptureInfoModule created with id %d " + "and device \"\" ", id); + return NULL; + } + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, id, + "VideoCaptureModule created for id", id); + return newCaptureInfoModule; + +#else // QTKit version + webrtc::videocapturemodule::VideoCaptureMacQTKitInfo* newCaptureInfoModule = + new webrtc::videocapturemodule::VideoCaptureMacQTKitInfo(id); + + if(!newCaptureInfoModule || newCaptureInfoModule->Init() != 0) + { + //Destroy(newCaptureInfoModule); + delete newCaptureInfoModule; + newCaptureInfoModule = NULL; + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, id, + "Failed to Init newCaptureInfoModule created with id %d " + "and device \"\" ", id); + return NULL; + } + WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, id, + "VideoCaptureModule created for id", id); + return newCaptureInfoModule; + +#endif + +} + +/************************************************************************** + * + * End Create/Destroy VideoCaptureModule + * + ***************************************************************************/ +} // namespace videocapturemodule +} // namespace webrtc diff --git a/webrtc/modules/video_capture/video_capture.gypi b/webrtc/modules/video_capture/video_capture.gypi index 0f4820ced7..eb101478fe 100644 --- a/webrtc/modules/video_capture/video_capture.gypi +++ b/webrtc/modules/video_capture/video_capture.gypi @@ -68,6 +68,29 @@ 'linux/video_capture_linux.h', ], }], # linux + ['OS=="mac"', { + 'sources': [ + 'mac/qtkit/video_capture_qtkit.h', + 'mac/qtkit/video_capture_qtkit.mm', + 'mac/qtkit/video_capture_qtkit_info.h', + 'mac/qtkit/video_capture_qtkit_info.mm', + 'mac/qtkit/video_capture_qtkit_info_objc.h', + 'mac/qtkit/video_capture_qtkit_info_objc.mm', + 'mac/qtkit/video_capture_qtkit_objc.h', + 'mac/qtkit/video_capture_qtkit_objc.mm', + 'mac/qtkit/video_capture_qtkit_utility.h', + 'mac/video_capture_mac.mm', + ], + 'link_settings': { + 'xcode_settings': { + 'OTHER_LDFLAGS': [ + '-framework Cocoa', + '-framework CoreVideo', + '-framework QTKit', + ], + }, + }, + }], # mac ['OS=="win"', { 'dependencies': [ '<(DEPTH)/third_party/winsdk_samples/winsdk_samples.gyp:directshow_baseclasses', @@ -110,16 +133,16 @@ }, }, }], - ['OS=="ios" or OS=="mac"', { + ['OS=="ios"', { 'sources': [ - 'apple/device_info.h', - 'apple/device_info.mm', - 'apple/device_info_objc.h', - 'apple/device_info_objc.mm', - 'apple/rtc_video_capture_objc.h', - 'apple/rtc_video_capture_objc.mm', - 'apple/video_capture.h', - 'apple/video_capture.mm', + 'ios/device_info_ios.h', + 'ios/device_info_ios.mm', + 'ios/device_info_ios_objc.h', + 'ios/device_info_ios_objc.mm', + 'ios/rtc_video_capture_ios_objc.h', + 'ios/rtc_video_capture_ios_objc.mm', + 'ios/video_capture_ios.h', + 'ios/video_capture_ios.mm', ], 'xcode_settings': { 'CLANG_ENABLE_OBJC_ARC': 'YES', @@ -130,14 +153,6 @@ '-framework AVFoundation', '-framework CoreMedia', '-framework CoreVideo', - ], - }, - }, - }], # ios - ['OS=="ios"', { - 'all_dependent_settings': { - 'xcode_settings': { - 'OTHER_LDFLAGS': [ '-framework UIKit', ], },