admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert of Unify the macOS and iOS capturer implementations (patchset #4 id:60001 of https://codereview.webrtc.org/2309253005/ )

Browse Source 
Reason for revert:
Breaks internal project

Original issue's description:
> Unify the macOS and iOS capturer implementations
>
> This removes the QTKit based capturer for mac, and removes the need
> to link against deprecated system libraries on macOS.
>
> BUG=webrtc:3968,webrtc:6275,webrtc:6333
>
> Committed: https://crrev.com/242d8bdddd77109781cbb70c59d161be7566ac98
> Cr-Commit-Position: refs/heads/master@{#14418}

TBR=magjed@webrtc.org,tkchin@webrtc.org,perkj@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=webrtc:3968,webrtc:6275,webrtc:6333

Review-Url: https://codereview.webrtc.org/2381853002
Cr-Commit-Position: refs/heads/master@{#14429}
This commit is contained in:
kthelgason 2016-09-29 02:43:23 -07:00 committed by Commit bot
parent ff9793c600
commit eddb7571d8
20 changed files with 1568 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
webrtc/modules/video_capture/BUILD.gn
View File

@ -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",
]
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.

7
webrtc/modules/video_capture/objc/device_info.h → webrtc/modules/video_capture/ios/device_info_ios.h
View File

@ -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 <map>
#include <string>
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_

32
webrtc/modules/video_capture/objc/device_info.mm → webrtc/modules/video_capture/ios/device_info_ios.mm
View File

@ -16,22 +16,26 @@
#include <string>
#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__); \
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<std::string, VideoCaptureCapabilities> mapPair =
std::pair<std::string, VideoCaptureCapabilities>(deviceIdCopy,
capabilityVector);
std::pair<std::string, VideoCaptureCapabilities>
(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) {

6
webrtc/modules/video_capture/objc/device_info_objc.h → webrtc/modules/video_capture/ios/device_info_ios_objc.h
View File

@ -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 <AVFoundation/AVFoundation.h>
@ -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_

11
webrtc/modules/video_capture/objc/device_info_objc.mm → webrtc/modules/video_capture/ios/device_info_ios_objc.mm
View File

@ -14,7 +14,7 @@
#import <AVFoundation/AVFoundation.h>
#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;

10
webrtc/modules/video_capture/objc/rtc_video_capture_objc.h → webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.h
View File

@ -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 <Foundation/Foundation.h>
#ifdef WEBRTC_IOS
#import <UIKit/UIKit.h>
#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'.
@ -38,4 +36,4 @@
- (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_

108
webrtc/modules/video_capture/objc/rtc_video_capture_objc.mm → webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.mm
View File

@ -12,13 +12,10 @@
#error "This file requires ARC support."
#endif
#import <AVFoundation/AVFoundation.h>
#ifdef WEBRTC_IOS
#import <UIKit/UIKit.h>
#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;
}
@ -189,7 +191,10 @@ using namespace webrtc::videocapturemodule;
(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;
}

6
webrtc/modules/video_capture/objc/video_capture.h → webrtc/modules/video_capture/ios/video_capture_ios.h
View File

@ -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_

13
webrtc/modules/video_capture/objc/video_capture.mm → webrtc/modules/video_capture/ios/video_capture_ios.mm
View File

@ -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,9 +67,8 @@ rtc::scoped_refptr<VideoCaptureModule> VideoCaptureIos::Create(
return nullptr;
}
if (![capture_module->capture_device_
setCaptureDeviceByUniqueId:
[[NSString alloc] initWithCString:deviceUniqueIdUTF8
if (![capture_module->capture_device_ setCaptureDeviceByUniqueId:[
[NSString alloc] initWithCString:deviceUniqueIdUTF8
encoding:NSUTF8StringEncoding]]) {
return nullptr;
}
@ -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_;

79
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.h Normal file
View File

@ -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 <QTKit/QTKit.h>
#include <stdio.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 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_

211
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit.mm Normal file
View File

@ -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

93
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.h Normal file
View File

@ -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_

125
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info.mm Normal file
View File

@ -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

67
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.h Normal file
View File

@ -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 <Foundation/Foundation.h>
#import <QTKit/QTKit.h>
#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_

191
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_info_objc.mm Normal file
View File

@ -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

61
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.h Normal file
View File

@ -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 <AppKit/AppKit.h>
#import <CoreData/CoreData.h>
#import <CoreFoundation/CoreFoundation.h>
#import <CoreVideo/CoreVideo.h>
#import <Foundation/Foundation.h>
#import <QTKit/QTKit.h>
#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_

259
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_objc.mm Normal file
View File

@ -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

36
webrtc/modules/video_capture/mac/qtkit/video_capture_qtkit_utility.h Normal file
View File

@ -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_

252
webrtc/modules/video_capture/mac/video_capture_mac.mm Normal file
View File

@ -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 <QuickTime/QuickTime.h>
#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 <QuickTime/video_capture_quick_time.h>
#include <QuickTime/video_capture_quick_time_info.h>
#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<VideoCaptureModule> 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<VideoCaptureMacQuickTime> newCaptureModule(
new rtc::RefCountedObject<VideoCaptureMacQuickTime>(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<VideoCaptureMacQTKit> newCaptureModule(
new rtc::RefCountedObject<VideoCaptureMacQTKit>(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

49
webrtc/modules/video_capture/video_capture.gypi
View File

@ -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',
],
},