Add AVFoundation video capture support to Mac objc SDK (based on iOS)

webrtc/sdk/objc/Framework/Classes/avfoundationvideocapturer.mm

 /*
  *  Copyright 2015 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 "avfoundationvideocapturer.h"
 
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
+#if TARGET_OS_IPHONE
 #import <UIKit/UIKit.h>
+#endif
 
 #import "RTCDispatcher+Private.h"
 #import "WebRTC/RTCLogging.h"
 
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/thread.h"
 
 // TODO(tkchin): support other formats.
 static NSString *const kDefaultPreset = AVCaptureSessionPreset640x480;
@@ skipping 55 matching lines @@
   if (self = [super init]) {
     _capturer = capturer;
     // Create the capture session and all relevant inputs and outputs. We need
     // to do this in init because the application may want the capture session
     // before we start the capturer for e.g. AVCapturePreviewLayer. All objects
     // created here are retained until dealloc and never recreated.
     if (![self setupCaptureSession]) {
       return nil;
     }
     NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+#if TARGET_OS_IPHONE
     [center addObserver:self
                selector:@selector(deviceOrientationDidChange:)
                    name:UIDeviceOrientationDidChangeNotification
                  object:nil];
     [center addObserver:self
                selector:@selector(handleCaptureSessionInterruption:)
                    name:AVCaptureSessionWasInterruptedNotification
                  object:_captureSession];
     [center addObserver:self
                selector:@selector(handleCaptureSessionInterruptionEnded:)
                    name:AVCaptureSessionInterruptionEndedNotification
                  object:_captureSession];
+#endif
     [center addObserver:self
                selector:@selector(handleCaptureSessionRuntimeError:)
                    name:AVCaptureSessionRuntimeErrorNotification
                  object:_captureSession];
     [center addObserver:self
                selector:@selector(handleCaptureSessionDidStartRunning:)
                    name:AVCaptureSessionDidStartRunningNotification
                  object:_captureSession];
     [center addObserver:self
                selector:@selector(handleCaptureSessionDidStopRunning:)
@@ skipping 68 matching lines @@
 // Called from WebRTC thread.
 - (void)start {
   if (self.hasStarted) {
     return;
   }
   self.hasStarted = YES;
   [RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
                                block:^{
     _orientationHasChanged = NO;
     [self updateOrientation];
+#if TARGET_OS_IPHONE
     [[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications];
+#endif
     AVCaptureSession *captureSession = self.captureSession;
     [captureSession startRunning];
   }];
 }
 
 // Called from same thread as start.
 - (void)stop {
   if (!self.hasStarted) {
     return;
   }
   self.hasStarted = NO;
   // Due to this async block, it's possible that the ObjC object outlives the
   // C++ one. In order to not invoke functions on the C++ object, we set
   // hasStarted immediately instead of dispatching it async.
   [RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
                                block:^{
     [_videoDataOutput setSampleBufferDelegate:nil queue:nullptr];
     [_captureSession stopRunning];
+#if TARGET_OS_IPHONE
     [[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications];
+#endif
   }];
 }
 
 #pragma mark iOS notifications
 
+#if TARGET_OS_IPHONE
 - (void)deviceOrientationDidChange:(NSNotification *)notification {
   [RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
                                block:^{
     _orientationHasChanged = YES;
     [self updateOrientation];
   }];
 }
+#endif
 
 #pragma mark AVCaptureVideoDataOutputSampleBufferDelegate
 
 - (void)captureOutput:(AVCaptureOutput *)captureOutput
     didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
            fromConnection:(AVCaptureConnection *)connection {
   NSParameterAssert(captureOutput == _videoDataOutput);
   if (!self.hasStarted) {
     return;
   }
@@ skipping 33 matching lines @@
   RTCLog(@"Capture session interrupted: %@", reasonString);
   // TODO(tkchin): Handle this case.
 }
 
 - (void)handleCaptureSessionInterruptionEnded:(NSNotification *)notification {
   RTCLog(@"Capture session interruption ended.");
   // TODO(tkchin): Handle this case.
 }
 
 - (void)handleCaptureSessionRuntimeError:(NSNotification *)notification {
-  NSError *error = notification.userInfo[AVCaptureSessionErrorKey];
+  NSError *error =
+      [notification.userInfo objectForKey:AVCaptureSessionErrorKey];
   RTCLogError(@"Capture session runtime error: %@", error.localizedDescription);
 
   [RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
                                block:^{
+#if TARGET_OS_IPHONE
     if (error.code == AVErrorMediaServicesWereReset) {
       [self handleNonFatalError];
     } else {
       [self handleFatalError];
     }
+#else
+    [self handleFatalError];
+#endif
   }];
 }
 
 - (void)handleCaptureSessionDidStartRunning:(NSNotification *)notification {
   RTCLog(@"Capture session started.");
   self.isRunning = YES;
   [RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
                                block:^{
     // If we successfully restarted after an unknown error, allow future
     // retries on fatal errors.
@@ skipping 99 matching lines @@
        [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo]) {
     if (captureDevice.position == position) {
       return captureDevice;
     }
   }
   return nil;
 }
 
 - (AVCaptureDeviceInput *)frontCameraInput {
   if (!_frontCameraInput) {
+#if TARGET_OS_IPHONE
     AVCaptureDevice *frontCameraDevice =
         [self videoCaptureDeviceForPosition:AVCaptureDevicePositionFront];
+#else
+    AVCaptureDevice *frontCameraDevice =
+        [AVCaptureDevice defaultDeviceWithMediaType: AVMediaTypeVideo];;

[tkchin_webrtc, 2016/06/08 22:17:24]

last one I promise :)
no space after :

+#endif
     if (!frontCameraDevice) {
       RTCLogWarning(@"Failed to find front capture device.");
       return nil;
     }
     NSError *error = nil;
     AVCaptureDeviceInput *frontCameraInput =
         [AVCaptureDeviceInput deviceInputWithDevice:frontCameraDevice
                                               error:&error];
     if (!frontCameraInput) {
       RTCLogError(@"Failed to create front camera input: %@",
@@ skipping 28 matching lines @@
 }
 
 // Called from capture session queue.
 - (void)updateOrientation {
   AVCaptureConnection *connection =
       [_videoDataOutput connectionWithMediaType:AVMediaTypeVideo];
   if (!connection.supportsVideoOrientation) {
     // TODO(tkchin): set rotation bit on frames.
     return;
   }
+#if TARGET_OS_IPHONE
   AVCaptureVideoOrientation orientation = AVCaptureVideoOrientationPortrait;
   switch ([UIDevice currentDevice].orientation) {
     case UIDeviceOrientationPortrait:
       orientation = AVCaptureVideoOrientationPortrait;
       break;
     case UIDeviceOrientationPortraitUpsideDown:
       orientation = AVCaptureVideoOrientationPortraitUpsideDown;
       break;
     case UIDeviceOrientationLandscapeLeft:
       orientation = AVCaptureVideoOrientationLandscapeRight;
       break;
     case UIDeviceOrientationLandscapeRight:
       orientation = AVCaptureVideoOrientationLandscapeLeft;
       break;
     case UIDeviceOrientationFaceUp:
     case UIDeviceOrientationFaceDown:
     case UIDeviceOrientationUnknown:
       if (!_orientationHasChanged) {
         connection.videoOrientation = orientation;
       }
       return;
   }
   connection.videoOrientation = orientation;
+#endif
 }
 
 // Update the current session input to match what's stored in _useBackCamera.
 - (void)updateSessionInputForUseBackCamera:(BOOL)useBackCamera {
   [RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
                                block:^{
     [_captureSession beginConfiguration];
     AVCaptureDeviceInput *oldInput = _backCameraInput;
     AVCaptureDeviceInput *newInput = _frontCameraInput;
     if (useBackCamera) {
@@ skipping 180 matching lines @@
 
   // This will call a superclass method that will perform the frame conversion
   // to I420.
   SignalFrameCaptured(this, &frame);
 
   CVPixelBufferUnlockBaseAddress(image_buffer, lock_flags);
   CVBufferRelease(image_buffer);
 }
 
 }  // namespace webrtc