OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 */ | |
10 | |
11 #if !defined(__has_feature) || !__has_feature(objc_arc) | |
12 #error "This file requires ARC support." | |
13 #endif | |
14 | |
15 #import <UIKit/UIKit.h> | |
16 | |
17 #import "webrtc/modules/video_capture/ios/device_info_ios_objc.h" | |
18 #import "webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.h" | |
19 | |
20 #include "webrtc/system_wrappers/include/trace.h" | |
21 | |
22 using namespace webrtc; | |
23 using namespace webrtc::videocapturemodule; | |
24 | |
25 @interface RTCVideoCaptureIosObjC (hidden) | |
26 - (int)changeCaptureInputWithName:(NSString*)captureDeviceName; | |
27 @end | |
28 | |
29 @implementation RTCVideoCaptureIosObjC { | |
30 webrtc::videocapturemodule::VideoCaptureIos* _owner; | |
31 webrtc::VideoCaptureCapability _capability; | |
32 AVCaptureSession* _captureSession; | |
33 int _captureId; | |
34 BOOL _orientationHasChanged; | |
35 AVCaptureConnection* _connection; | |
36 BOOL _captureChanging; // Guarded by _captureChangingCondition. | |
37 NSCondition* _captureChangingCondition; | |
38 } | |
39 | |
40 @synthesize frameRotation = _framRotation; | |
41 | |
42 - (id)initWithOwner:(VideoCaptureIos*)owner captureId:(int)captureId { | |
43 if (self == [super init]) { | |
44 _owner = owner; | |
45 _captureId = captureId; | |
46 _captureSession = [[AVCaptureSession alloc] init]; | |
47 #if defined(__IPHONE_7_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_7_0 | |
48 NSString* version = [[UIDevice currentDevice] systemVersion]; | |
49 if ([version integerValue] >= 7) { | |
50 _captureSession.usesApplicationAudioSession = NO; | |
51 } | |
52 #endif | |
53 _captureChanging = NO; | |
54 _captureChangingCondition = [[NSCondition alloc] init]; | |
55 | |
56 if (!_captureSession || !_captureChangingCondition) { | |
57 return nil; | |
58 } | |
59 | |
60 // create and configure a new output (using callbacks) | |
61 AVCaptureVideoDataOutput* captureOutput = | |
62 [[AVCaptureVideoDataOutput alloc] init]; | |
63 NSString* key = (NSString*)kCVPixelBufferPixelFormatTypeKey; | |
64 | |
65 NSNumber* val = [NSNumber | |
66 numberWithUnsignedInt:kCVPixelFormatType_420YpCbCr8BiPlanarFullRange]; | |
67 NSDictionary* videoSettings = | |
68 [NSDictionary dictionaryWithObject:val forKey:key]; | |
69 captureOutput.videoSettings = videoSettings; | |
70 | |
71 // add new output | |
72 if ([_captureSession canAddOutput:captureOutput]) { | |
73 [_captureSession addOutput:captureOutput]; | |
74 } else { | |
75 WEBRTC_TRACE(kTraceError, | |
76 kTraceVideoCapture, | |
77 _captureId, | |
78 "%s:%s:%d Could not add output to AVCaptureSession ", | |
79 __FILE__, | |
80 __FUNCTION__, | |
81 __LINE__); | |
82 } | |
83 | |
84 [[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications]; | |
85 | |
86 NSNotificationCenter* notify = [NSNotificationCenter defaultCenter]; | |
87 [notify addObserver:self | |
88 selector:@selector(onVideoError:) | |
89 name:AVCaptureSessionRuntimeErrorNotification | |
90 object:_captureSession]; | |
91 [notify addObserver:self | |
92 selector:@selector(deviceOrientationDidChange:) | |
93 name:UIDeviceOrientationDidChangeNotification | |
94 object:nil]; | |
95 } | |
96 | |
97 return self; | |
98 } | |
99 | |
100 - (void)directOutputToSelf { | |
101 [[self currentOutput] | |
102 setSampleBufferDelegate:self | |
103 queue:dispatch_get_global_queue( | |
104 DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)]; | |
105 } | |
106 | |
107 - (void)directOutputToNil { | |
108 [[self currentOutput] setSampleBufferDelegate:nil queue:NULL]; | |
109 } | |
110 | |
111 - (void)deviceOrientationDidChange:(NSNotification*)notification { | |
112 _orientationHasChanged = YES; | |
113 [self setRelativeVideoOrientation]; | |
114 } | |
115 | |
116 - (void)dealloc { | |
117 [[NSNotificationCenter defaultCenter] removeObserver:self]; | |
118 } | |
119 | |
120 - (BOOL)setCaptureDeviceByUniqueId:(NSString*)uniqueId { | |
121 [self waitForCaptureChangeToFinish]; | |
122 // check to see if the camera is already set | |
123 if (_captureSession) { | |
124 NSArray* currentInputs = [NSArray arrayWithArray:[_captureSession inputs]]; | |
125 if ([currentInputs count] > 0) { | |
126 AVCaptureDeviceInput* currentInput = [currentInputs objectAtIndex:0]; | |
127 if ([uniqueId isEqualToString:[currentInput.device localizedName]]) { | |
128 return YES; | |
129 } | |
130 } | |
131 } | |
132 | |
133 return [self changeCaptureInputByUniqueId:uniqueId]; | |
134 } | |
135 | |
136 - (BOOL)startCaptureWithCapability:(const VideoCaptureCapability&)capability { | |
137 [self waitForCaptureChangeToFinish]; | |
138 if (!_captureSession) { | |
139 return NO; | |
140 } | |
141 | |
142 // check limits of the resolution | |
143 if (capability.maxFPS < 0 || capability.maxFPS > 60) { | |
144 return NO; | |
145 } | |
146 | |
147 if ([_captureSession canSetSessionPreset:AVCaptureSessionPreset1920x1080]) { | |
148 if (capability.width > 1920 || capability.height > 1080) { | |
149 return NO; | |
150 } | |
151 } else if ([_captureSession | |
152 canSetSessionPreset:AVCaptureSessionPreset1280x720]) { | |
153 if (capability.width > 1280 || capability.height > 720) { | |
154 return NO; | |
155 } | |
156 } else if ([_captureSession | |
157 canSetSessionPreset:AVCaptureSessionPreset640x480]) { | |
158 if (capability.width > 640 || capability.height > 480) { | |
159 return NO; | |
160 } | |
161 } else if ([_captureSession | |
162 canSetSessionPreset:AVCaptureSessionPreset352x288]) { | |
163 if (capability.width > 352 || capability.height > 288) { | |
164 return NO; | |
165 } | |
166 } else if (capability.width < 0 || capability.height < 0) { | |
167 return NO; | |
168 } | |
169 | |
170 _capability = capability; | |
171 | |
172 AVCaptureVideoDataOutput* currentOutput = [self currentOutput]; | |
173 if (!currentOutput) | |
174 return NO; | |
175 | |
176 [self directOutputToSelf]; | |
177 | |
178 _orientationHasChanged = NO; | |
179 _captureChanging = YES; | |
180 dispatch_async( | |
181 dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), | |
182 ^(void) { [self startCaptureInBackgroundWithOutput:currentOutput]; }); | |
183 return YES; | |
184 } | |
185 | |
186 - (AVCaptureVideoDataOutput*)currentOutput { | |
187 return [[_captureSession outputs] firstObject]; | |
188 } | |
189 | |
190 - (void)startCaptureInBackgroundWithOutput: | |
191 (AVCaptureVideoDataOutput*)currentOutput { | |
192 NSString* captureQuality = | |
193 [NSString stringWithString:AVCaptureSessionPresetLow]; | |
194 if (_capability.width >= 1920 || _capability.height >= 1080) { | |
195 captureQuality = | |
196 [NSString stringWithString:AVCaptureSessionPreset1920x1080]; | |
197 } else if (_capability.width >= 1280 || _capability.height >= 720) { | |
198 captureQuality = [NSString stringWithString:AVCaptureSessionPreset1280x720]; | |
199 } else if (_capability.width >= 640 || _capability.height >= 480) { | |
200 captureQuality = [NSString stringWithString:AVCaptureSessionPreset640x480]; | |
201 } else if (_capability.width >= 352 || _capability.height >= 288) { | |
202 captureQuality = [NSString stringWithString:AVCaptureSessionPreset352x288]; | |
203 } | |
204 | |
205 // begin configuration for the AVCaptureSession | |
206 [_captureSession beginConfiguration]; | |
207 | |
208 // picture resolution | |
209 [_captureSession setSessionPreset:captureQuality]; | |
210 | |
211 // take care of capture framerate now | |
212 NSArray* sessionInputs = _captureSession.inputs; | |
213 AVCaptureDeviceInput* deviceInput = [sessionInputs count] > 0 ? | |
214 sessionInputs[0] : nil; | |
215 AVCaptureDevice* inputDevice = deviceInput.device; | |
216 if (inputDevice) { | |
217 AVCaptureDeviceFormat* activeFormat = inputDevice.activeFormat; | |
218 NSArray* supportedRanges = activeFormat.videoSupportedFrameRateRanges; | |
219 AVFrameRateRange* targetRange = [supportedRanges count] > 0 ? | |
220 supportedRanges[0] : nil; | |
221 // Find the largest supported framerate less than capability maxFPS. | |
222 for (AVFrameRateRange* range in supportedRanges) { | |
223 if (range.maxFrameRate <= _capability.maxFPS && | |
224 targetRange.maxFrameRate <= range.maxFrameRate) { | |
225 targetRange = range; | |
226 } | |
227 } | |
228 if (targetRange && [inputDevice lockForConfiguration:NULL]) { | |
229 inputDevice.activeVideoMinFrameDuration = targetRange.minFrameDuration; | |
230 inputDevice.activeVideoMaxFrameDuration = targetRange.minFrameDuration; | |
231 [inputDevice unlockForConfiguration]; | |
232 } | |
233 } | |
234 | |
235 _connection = [currentOutput connectionWithMediaType:AVMediaTypeVideo]; | |
236 [self setRelativeVideoOrientation]; | |
237 | |
238 // finished configuring, commit settings to AVCaptureSession. | |
239 [_captureSession commitConfiguration]; | |
240 | |
241 [_captureSession startRunning]; | |
242 [self signalCaptureChangeEnd]; | |
243 } | |
244 | |
245 - (void)setRelativeVideoOrientation { | |
246 if (!_connection.supportsVideoOrientation) { | |
247 return; | |
248 } | |
249 | |
250 switch ([UIDevice currentDevice].orientation) { | |
251 case UIDeviceOrientationPortrait: | |
252 _connection.videoOrientation = | |
253 AVCaptureVideoOrientationPortrait; | |
254 break; | |
255 case UIDeviceOrientationPortraitUpsideDown: | |
256 _connection.videoOrientation = | |
257 AVCaptureVideoOrientationPortraitUpsideDown; | |
258 break; | |
259 case UIDeviceOrientationLandscapeLeft: | |
260 _connection.videoOrientation = | |
261 AVCaptureVideoOrientationLandscapeRight; | |
262 break; | |
263 case UIDeviceOrientationLandscapeRight: | |
264 _connection.videoOrientation = | |
265 AVCaptureVideoOrientationLandscapeLeft; | |
266 break; | |
267 case UIDeviceOrientationFaceUp: | |
268 case UIDeviceOrientationFaceDown: | |
269 case UIDeviceOrientationUnknown: | |
270 if (!_orientationHasChanged) { | |
271 _connection.videoOrientation = | |
272 AVCaptureVideoOrientationPortrait; | |
273 } | |
274 break; | |
275 } | |
276 } | |
277 | |
278 - (void)onVideoError:(NSNotification*)notification { | |
279 NSLog(@"onVideoError: %@", notification); | |
280 // TODO(sjlee): make the specific error handling with this notification. | |
281 WEBRTC_TRACE(kTraceError, | |
282 kTraceVideoCapture, | |
283 _captureId, | |
284 "%s:%s:%d [AVCaptureSession startRunning] error.", | |
285 __FILE__, | |
286 __FUNCTION__, | |
287 __LINE__); | |
288 } | |
289 | |
290 - (BOOL)stopCapture { | |
291 [[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications]; | |
292 _orientationHasChanged = NO; | |
293 [self waitForCaptureChangeToFinish]; | |
294 [self directOutputToNil]; | |
295 | |
296 if (!_captureSession) { | |
297 return NO; | |
298 } | |
299 | |
300 _captureChanging = YES; | |
301 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), | |
302 ^(void) { [self stopCaptureInBackground]; }); | |
303 return YES; | |
304 } | |
305 | |
306 - (void)stopCaptureInBackground { | |
307 [_captureSession stopRunning]; | |
308 [self signalCaptureChangeEnd]; | |
309 } | |
310 | |
311 - (BOOL)changeCaptureInputByUniqueId:(NSString*)uniqueId { | |
312 [self waitForCaptureChangeToFinish]; | |
313 NSArray* currentInputs = [_captureSession inputs]; | |
314 // remove current input | |
315 if ([currentInputs count] > 0) { | |
316 AVCaptureInput* currentInput = | |
317 (AVCaptureInput*)[currentInputs objectAtIndex:0]; | |
318 | |
319 [_captureSession removeInput:currentInput]; | |
320 } | |
321 | |
322 // Look for input device with the name requested (as our input param) | |
323 // get list of available capture devices | |
324 int captureDeviceCount = [DeviceInfoIosObjC captureDeviceCount]; | |
325 if (captureDeviceCount <= 0) { | |
326 return NO; | |
327 } | |
328 | |
329 AVCaptureDevice* captureDevice = | |
330 [DeviceInfoIosObjC captureDeviceForUniqueId:uniqueId]; | |
331 | |
332 if (!captureDevice) { | |
333 return NO; | |
334 } | |
335 | |
336 // now create capture session input out of AVCaptureDevice | |
337 NSError* deviceError = nil; | |
338 AVCaptureDeviceInput* newCaptureInput = | |
339 [AVCaptureDeviceInput deviceInputWithDevice:captureDevice | |
340 error:&deviceError]; | |
341 | |
342 if (!newCaptureInput) { | |
343 const char* errorMessage = [[deviceError localizedDescription] UTF8String]; | |
344 | |
345 WEBRTC_TRACE(kTraceError, | |
346 kTraceVideoCapture, | |
347 _captureId, | |
348 "%s:%s:%d deviceInputWithDevice error:%s", | |
349 __FILE__, | |
350 __FUNCTION__, | |
351 __LINE__, | |
352 errorMessage); | |
353 | |
354 return NO; | |
355 } | |
356 | |
357 // try to add our new capture device to the capture session | |
358 [_captureSession beginConfiguration]; | |
359 | |
360 BOOL addedCaptureInput = NO; | |
361 if ([_captureSession canAddInput:newCaptureInput]) { | |
362 [_captureSession addInput:newCaptureInput]; | |
363 addedCaptureInput = YES; | |
364 } else { | |
365 addedCaptureInput = NO; | |
366 } | |
367 | |
368 [_captureSession commitConfiguration]; | |
369 | |
370 return addedCaptureInput; | |
371 } | |
372 | |
373 - (void)captureOutput:(AVCaptureOutput*)captureOutput | |
374 didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer | |
375 fromConnection:(AVCaptureConnection*)connection { | |
376 const int kFlags = 0; | |
377 CVImageBufferRef videoFrame = CMSampleBufferGetImageBuffer(sampleBuffer); | |
378 | |
379 if (CVPixelBufferLockBaseAddress(videoFrame, kFlags) != kCVReturnSuccess) { | |
380 return; | |
381 } | |
382 | |
383 const int kYPlaneIndex = 0; | |
384 const int kUVPlaneIndex = 1; | |
385 | |
386 uint8_t* baseAddress = | |
387 (uint8_t*)CVPixelBufferGetBaseAddressOfPlane(videoFrame, kYPlaneIndex); | |
388 size_t yPlaneBytesPerRow = | |
389 CVPixelBufferGetBytesPerRowOfPlane(videoFrame, kYPlaneIndex); | |
390 size_t yPlaneHeight = CVPixelBufferGetHeightOfPlane(videoFrame, kYPlaneIndex); | |
391 size_t uvPlaneBytesPerRow = | |
392 CVPixelBufferGetBytesPerRowOfPlane(videoFrame, kUVPlaneIndex); | |
393 size_t uvPlaneHeight = | |
394 CVPixelBufferGetHeightOfPlane(videoFrame, kUVPlaneIndex); | |
395 size_t frameSize = | |
396 yPlaneBytesPerRow * yPlaneHeight + uvPlaneBytesPerRow * uvPlaneHeight; | |
397 | |
398 VideoCaptureCapability tempCaptureCapability; | |
399 tempCaptureCapability.width = CVPixelBufferGetWidth(videoFrame); | |
400 tempCaptureCapability.height = CVPixelBufferGetHeight(videoFrame); | |
401 tempCaptureCapability.maxFPS = _capability.maxFPS; | |
402 tempCaptureCapability.rawType = kVideoNV12; | |
403 | |
404 _owner->IncomingFrame(baseAddress, frameSize, tempCaptureCapability, 0); | |
405 | |
406 CVPixelBufferUnlockBaseAddress(videoFrame, kFlags); | |
407 } | |
408 | |
409 - (void)signalCaptureChangeEnd { | |
410 [_captureChangingCondition lock]; | |
411 _captureChanging = NO; | |
412 [_captureChangingCondition signal]; | |
413 [_captureChangingCondition unlock]; | |
414 } | |
415 | |
416 - (void)waitForCaptureChangeToFinish { | |
417 [_captureChangingCondition lock]; | |
418 while (_captureChanging) { | |
419 [_captureChangingCondition wait]; | |
420 } | |
421 [_captureChangingCondition unlock]; | |
422 } | |
423 @end | |
OLD | NEW |