Reland of Unify the macOS and iOS capturer implementations

webrtc/modules/video_capture/objc/rtc_video_capture_objc.mm

 /*
  *  Copyright (c) 2013 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.
  */
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
+#import <AVFoundation/AVFoundation.h>
+#ifdef WEBRTC_IOS
 #import <UIKit/UIKit.h>
+#endif
 
-#import "webrtc/modules/video_capture/ios/device_info_ios_objc.h"
-#import "webrtc/modules/video_capture/ios/rtc_video_capture_ios_objc.h"
+#import "webrtc/modules/video_capture/objc/device_info_objc.h"
+#import "webrtc/modules/video_capture/objc/rtc_video_capture_objc.h"
 
 #include "webrtc/system_wrappers/include/trace.h"
 
 using namespace webrtc;
 using namespace webrtc::videocapturemodule;
 
 @interface RTCVideoCaptureIosObjC (hidden)
 - (int)changeCaptureInputWithName:(NSString*)captureDeviceName;
 @end
 
@@ skipping 36 matching lines @@
     NSNumber* val = [NSNumber
         numberWithUnsignedInt:kCVPixelFormatType_420YpCbCr8BiPlanarFullRange];
     NSDictionary* videoSettings =
         [NSDictionary dictionaryWithObject:val forKey:key];
     captureOutput.videoSettings = videoSettings;
 
     // add new output
     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];
     [notify addObserver:self
                selector:@selector(onVideoError:)
                    name:AVCaptureSessionRuntimeErrorNotification
                  object:_captureSession];
     [notify addObserver:self
                selector:@selector(deviceOrientationDidChange:)
                    name:UIDeviceOrientationDidChangeNotification
                  object:nil];
+#endif
   }
 
   return self;
 }
 
 - (void)directOutputToSelf {
   [[self currentOutput]
       setSampleBufferDelegate:self
                         queue:dispatch_get_global_queue(
                                   DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)];
@@ skipping 32 matching lines @@
   [self waitForCaptureChangeToFinish];
   if (!_captureSession) {
     return NO;
   }
 
   // check limits of the resolution
   if (capability.maxFPS < 0 || capability.maxFPS > 60) {
     return NO;
   }
 
-  if ([_captureSession canSetSessionPreset:AVCaptureSessionPreset1920x1080]) {
-    if (capability.width > 1920 || capability.height > 1080) {
-      return NO;
-    }
-  } else if ([_captureSession
-                 canSetSessionPreset:AVCaptureSessionPreset1280x720]) {
+  if ([_captureSession canSetSessionPreset:AVCaptureSessionPreset1280x720]) {
     if (capability.width > 1280 || capability.height > 720) {
       return NO;
     }
   } else if ([_captureSession
                  canSetSessionPreset:AVCaptureSessionPreset640x480]) {
     if (capability.width > 640 || capability.height > 480) {
       return NO;
     }
   } else if ([_captureSession
                  canSetSessionPreset:AVCaptureSessionPreset352x288]) {
     if (capability.width > 352 || capability.height > 288) {
       return NO;
     }
   } else if (capability.width < 0 || capability.height < 0) {
     return NO;
   }
 
   _capability = capability;
 
   AVCaptureVideoDataOutput* currentOutput = [self currentOutput];
   if (!currentOutput)
     return NO;
 
   [self directOutputToSelf];
 
   _orientationHasChanged = NO;
   _captureChanging = YES;
-  dispatch_async(
-      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
-      ^(void) { [self startCaptureInBackgroundWithOutput:currentOutput]; });
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
+                 ^{
+                   [self startCaptureInBackgroundWithOutput:currentOutput];
+                 });
   return YES;
 }
 
 - (AVCaptureVideoDataOutput*)currentOutput {
   return [[_captureSession outputs] firstObject];
 }
 
 - (void)startCaptureInBackgroundWithOutput:
-            (AVCaptureVideoDataOutput*)currentOutput {
+    (AVCaptureVideoDataOutput*)currentOutput {
   NSString* captureQuality =
       [NSString stringWithString:AVCaptureSessionPresetLow];
-  if (_capability.width >= 1920 || _capability.height >= 1080) {
-    captureQuality =
-        [NSString stringWithString:AVCaptureSessionPreset1920x1080];
-  } else if (_capability.width >= 1280 || _capability.height >= 720) {
+  if (_capability.width >= 1280 || _capability.height >= 720) {
     captureQuality = [NSString stringWithString:AVCaptureSessionPreset1280x720];
   } else if (_capability.width >= 640 || _capability.height >= 480) {
     captureQuality = [NSString stringWithString:AVCaptureSessionPreset640x480];
   } else if (_capability.width >= 352 || _capability.height >= 288) {
     captureQuality = [NSString stringWithString:AVCaptureSessionPreset352x288];
   }
 
   // begin configuration for the AVCaptureSession
   [_captureSession beginConfiguration];
 
   // 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];
 
   // finished configuring, commit settings to AVCaptureSession.
   [_captureSession commitConfiguration];
 
   [_captureSession startRunning];
   [self signalCaptureChangeEnd];
 }
 
 - (void)setRelativeVideoOrientation {
   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];
 
   if (!_captureSession) {
     return NO;
   }
 
   _captureChanging = YES;
   dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
-                 ^(void) { [self stopCaptureInBackground]; });
+                 ^(void) {
+                   [self stopCaptureInBackground];
+                 });
   return YES;
 }
 
 - (void)stopCaptureInBackground {
   [_captureSession stopRunning];
   [self signalCaptureChangeEnd];
 }
 
 - (BOOL)changeCaptureInputByUniqueId:(NSString*)uniqueId {
   [self waitForCaptureChangeToFinish];
@@ skipping 22 matching lines @@
 
   // now create capture session input out of AVCaptureDevice
   NSError* deviceError = nil;
   AVCaptureDeviceInput* newCaptureInput =
       [AVCaptureDeviceInput deviceInputWithDevice:captureDevice
                                             error:&deviceError];
 
   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;
   }
 
   // try to add our new capture device to the capture session
   [_captureSession beginConfiguration];
 
   BOOL addedCaptureInput = NO;
   if ([_captureSession canAddInput:newCaptureInput]) {
     [_captureSession addInput:newCaptureInput];
@@ skipping 51 matching lines @@
 }
 
 - (void)waitForCaptureChangeToFinish {
   [_captureChangingCondition lock];
   while (_captureChanging) {
     [_captureChangingCondition wait];
   }
   [_captureChangingCondition unlock];
 }
 @end