2166 lines
100 KiB
Objective-C
2166 lines
100 KiB
Objective-C
//
|
|
// SCManagedCapturer.m
|
|
// Snapchat
|
|
//
|
|
// Created by Liu Liu on 4/20/15.
|
|
// Copyright (c) 2015 Liu Liu. All rights reserved.
|
|
//
|
|
|
|
#import "SCManagedCapturerV1.h"
|
|
#import "SCManagedCapturerV1_Private.h"
|
|
|
|
#import "ARConfiguration+SCConfiguration.h"
|
|
#import "NSURL+Asset.h"
|
|
#import "SCBlackCameraDetector.h"
|
|
#import "SCBlackCameraNoOutputDetector.h"
|
|
#import "SCCameraTweaks.h"
|
|
#import "SCCaptureResource.h"
|
|
#import "SCCaptureSessionFixer.h"
|
|
#import "SCCaptureUninitializedState.h"
|
|
#import "SCCaptureWorker.h"
|
|
#import "SCCapturerToken.h"
|
|
#import "SCManagedAudioStreamer.h"
|
|
#import "SCManagedCaptureDevice+SCManagedCapturer.h"
|
|
#import "SCManagedCaptureDeviceDefaultZoomHandler.h"
|
|
#import "SCManagedCaptureDeviceHandler.h"
|
|
#import "SCManagedCaptureDeviceSubjectAreaHandler.h"
|
|
#import "SCManagedCapturePreviewLayerController.h"
|
|
#import "SCManagedCaptureSession.h"
|
|
#import "SCManagedCapturerARImageCaptureProvider.h"
|
|
#import "SCManagedCapturerGLViewManagerAPI.h"
|
|
#import "SCManagedCapturerLSAComponentTrackerAPI.h"
|
|
#import "SCManagedCapturerLensAPI.h"
|
|
#import "SCManagedCapturerListenerAnnouncer.h"
|
|
#import "SCManagedCapturerLogging.h"
|
|
#import "SCManagedCapturerSampleMetadata.h"
|
|
#import "SCManagedCapturerState.h"
|
|
#import "SCManagedCapturerStateBuilder.h"
|
|
#import "SCManagedDeviceCapacityAnalyzer.h"
|
|
#import "SCManagedDroppedFramesReporter.h"
|
|
#import "SCManagedFrameHealthChecker.h"
|
|
#import "SCManagedFrontFlashController.h"
|
|
#import "SCManagedStillImageCapturer.h"
|
|
#import "SCManagedStillImageCapturerHandler.h"
|
|
#import "SCManagedVideoARDataSource.h"
|
|
#import "SCManagedVideoCapturer.h"
|
|
#import "SCManagedVideoFileStreamer.h"
|
|
#import "SCManagedVideoFrameSampler.h"
|
|
#import "SCManagedVideoScanner.h"
|
|
#import "SCManagedVideoStreamReporter.h"
|
|
#import "SCManagedVideoStreamer.h"
|
|
#import "SCMetalUtils.h"
|
|
#import "SCProcessingPipeline.h"
|
|
#import "SCProcessingPipelineBuilder.h"
|
|
#import "SCScanConfiguration.h"
|
|
#import "SCSingleFrameStreamCapturer.h"
|
|
#import "SCSnapCreationTriggers.h"
|
|
#import "SCTimedTask.h"
|
|
|
|
#import <SCBase/SCAssignment.h>
|
|
#import <SCBase/SCLazyLoadingProxy.h>
|
|
#import <SCBatteryLogger/SCBatteryLogger.h>
|
|
#import <SCFoundation/NSData+Random.h>
|
|
#import <SCFoundation/NSError+Helpers.h>
|
|
#import <SCFoundation/NSString+SCFormat.h>
|
|
#import <SCFoundation/SCAppEnvironment.h>
|
|
#import <SCFoundation/SCDeviceName.h>
|
|
#import <SCFoundation/SCQueuePerformer.h>
|
|
#import <SCFoundation/SCThreadHelpers.h>
|
|
#import <SCFoundation/SCTrace.h>
|
|
#import <SCFoundation/SCTraceODPCompatible.h>
|
|
#import <SCFoundation/SCZeroDependencyExperiments.h>
|
|
#import <SCGhostToSnappable/SCGhostToSnappableSignal.h>
|
|
#import <SCImageProcess/SCImageProcessVideoPlaybackSession.h>
|
|
#import <SCLenses/SCLens.h>
|
|
#import <SCLogger/SCCameraMetrics.h>
|
|
#import <SCLogger/SCLogger+Performance.h>
|
|
#import <SCUserTraceLogger/SCUserTraceLogger.h>
|
|
|
|
#import <Looksery/Looksery.h>
|
|
|
|
@import ARKit;
|
|
|
|
static NSUInteger const kSCManagedCapturerFixInconsistencyMaxRetriesWithCurrentSession = 22;
|
|
static CGFloat const kSCManagedCapturerFixInconsistencyARSessionDelayThreshold = 2;
|
|
static CGFloat const kSCManagedCapturerFixInconsistencyARSessionHungInitThreshold = 5;
|
|
|
|
static NSTimeInterval const kMinFixAVSessionRunningInterval = 1; // Interval to run _fixAVSessionIfNecessary
|
|
static NSTimeInterval const kMinFixSessionRuntimeErrorInterval =
|
|
1; // Min interval that RuntimeError calls _startNewSession
|
|
|
|
static NSString *const kSCManagedCapturerErrorDomain = @"kSCManagedCapturerErrorDomain";
|
|
|
|
NSString *const kSCLensesTweaksDidChangeFileInput = @"kSCLensesTweaksDidChangeFileInput";
|
|
|
|
@implementation SCManagedCapturerV1 {
|
|
// No ivars for CapturerV1 please, they should be in resource.
|
|
SCCaptureResource *_captureResource;
|
|
}
|
|
|
|
+ (SCManagedCapturerV1 *)sharedInstance
|
|
{
|
|
static dispatch_once_t onceToken;
|
|
static SCManagedCapturerV1 *managedCapturerV1;
|
|
dispatch_once(&onceToken, ^{
|
|
managedCapturerV1 = [[SCManagedCapturerV1 alloc] init];
|
|
});
|
|
return managedCapturerV1;
|
|
}
|
|
|
|
- (instancetype)init
|
|
{
|
|
SCTraceStart();
|
|
SCAssertMainThread();
|
|
SCCaptureResource *resource = [SCCaptureWorker generateCaptureResource];
|
|
return [self initWithResource:resource];
|
|
}
|
|
|
|
- (instancetype)initWithResource:(SCCaptureResource *)resource
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssertMainThread();
|
|
self = [super init];
|
|
if (self) {
|
|
// Assuming I am not in background. I can be more defensive here and fetch the app state.
|
|
// But to avoid potential problems, won't do that until later.
|
|
SCLogCapturerInfo(@"======================= cool startup =======================");
|
|
// Initialization of capture resource should be done in worker to be shared between V1 and V2.
|
|
_captureResource = resource;
|
|
_captureResource.handleAVSessionStatusChange = @selector(_handleAVSessionStatusChange:);
|
|
_captureResource.sessionRuntimeError = @selector(_sessionRuntimeError:);
|
|
_captureResource.livenessConsistency = @selector(_livenessConsistency:);
|
|
_captureResource.deviceSubjectAreaHandler =
|
|
[[SCManagedCaptureDeviceSubjectAreaHandler alloc] initWithCaptureResource:_captureResource];
|
|
_captureResource.snapCreationTriggers = [SCSnapCreationTriggers new];
|
|
if (SCIsMasterBuild()) {
|
|
// We call _sessionRuntimeError to reset _captureResource.videoDataSource if input changes
|
|
[[NSNotificationCenter defaultCenter] addObserver:self
|
|
selector:@selector(_sessionRuntimeError:)
|
|
name:kSCLensesTweaksDidChangeFileInput
|
|
object:nil];
|
|
}
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (SCBlackCameraDetector *)blackCameraDetector
|
|
{
|
|
return _captureResource.blackCameraDetector;
|
|
}
|
|
|
|
- (void)recreateAVCaptureSession
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[self _startRunningWithNewCaptureSessionIfNecessary];
|
|
}
|
|
|
|
- (void)_handleAVSessionStatusChange:(NSDictionary *)change
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SC_GUARD_ELSE_RETURN(!_captureResource.state.arSessionActive);
|
|
SC_GUARD_ELSE_RETURN(!_captureResource.appInBackground);
|
|
BOOL wasRunning = [change[NSKeyValueChangeOldKey] boolValue];
|
|
BOOL isRunning = [change[NSKeyValueChangeNewKey] boolValue];
|
|
SCLogCapturerInfo(@"avSession running status changed: %@ -> %@", wasRunning ? @"running" : @"stopped",
|
|
isRunning ? @"running" : @"stopped");
|
|
|
|
[_captureResource.blackCameraDetector sessionDidChangeIsRunning:isRunning];
|
|
|
|
if (_captureResource.isRecreateSessionFixScheduled) {
|
|
SCLogCapturerInfo(@"Scheduled AVCaptureSession recreation, return");
|
|
return;
|
|
}
|
|
|
|
if (wasRunning != isRunning) {
|
|
runOnMainThreadAsynchronously(^{
|
|
if (isRunning) {
|
|
[_captureResource.announcer managedCapturer:self didStartRunning:_captureResource.state];
|
|
} else {
|
|
[_captureResource.announcer managedCapturer:self didStopRunning:_captureResource.state];
|
|
}
|
|
});
|
|
}
|
|
|
|
if (!isRunning) {
|
|
[_captureResource.queuePerformer perform:^{
|
|
[self _fixAVSessionIfNecessary];
|
|
}];
|
|
} else {
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[self _fixNonMetalSessionPreviewInconsistency];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)_fixAVSessionIfNecessary
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssert([_captureResource.queuePerformer isCurrentPerformer], @"");
|
|
SC_GUARD_ELSE_RETURN(!_captureResource.appInBackground);
|
|
SC_GUARD_ELSE_RETURN(_captureResource.status == SCManagedCapturerStatusRunning);
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraFixAVCaptureSession
|
|
uniqueId:@""
|
|
stepName:@"startConsistencyCheckAndFix"];
|
|
|
|
NSTimeInterval timeNow = [NSDate timeIntervalSinceReferenceDate];
|
|
if (timeNow - _captureResource.lastFixSessionTimestamp < kMinFixAVSessionRunningInterval) {
|
|
SCLogCoreCameraInfo(@"Fixing session in less than %f, skip", kMinFixAVSessionRunningInterval);
|
|
return;
|
|
}
|
|
_captureResource.lastFixSessionTimestamp = timeNow;
|
|
|
|
if (!_captureResource.managedSession.isRunning) {
|
|
SCTraceStartSection("Fix AVSession")
|
|
{
|
|
_captureResource.numRetriesFixAVCaptureSessionWithCurrentSession++;
|
|
SCGhostToSnappableSignalCameraFixInconsistency();
|
|
if (_captureResource.numRetriesFixAVCaptureSessionWithCurrentSession <=
|
|
kSCManagedCapturerFixInconsistencyARSessionDelayThreshold) {
|
|
SCLogCapturerInfo(@"Fixing AVSession");
|
|
[_captureResource.managedSession startRunning];
|
|
SCLogCapturerInfo(@"Fixed AVSession, success : %@", @(_captureResource.managedSession.isRunning));
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraFixAVCaptureSession
|
|
uniqueId:@""
|
|
stepName:@"finishCaptureSessionFix"];
|
|
} else {
|
|
// start running with new capture session if the inconsistency fixing not succeeds
|
|
SCLogCapturerInfo(@"*** Recreate and run new capture session to fix the inconsistency ***");
|
|
[self _startRunningWithNewCaptureSessionIfNecessary];
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraFixAVCaptureSession
|
|
uniqueId:@""
|
|
stepName:@"finishNewCaptureSessionCreation"];
|
|
}
|
|
}
|
|
SCTraceEndSection();
|
|
[[SCLogger sharedInstance]
|
|
logTimedEventEnd:kSCCameraFixAVCaptureSession
|
|
uniqueId:@""
|
|
parameters:@{
|
|
@"success" : @(_captureResource.managedSession.isRunning),
|
|
@"count" : @(_captureResource.numRetriesFixAVCaptureSessionWithCurrentSession)
|
|
}];
|
|
} else {
|
|
_captureResource.numRetriesFixAVCaptureSessionWithCurrentSession = 0;
|
|
[[SCLogger sharedInstance] cancelLogTimedEvent:kSCCameraFixAVCaptureSession uniqueId:@""];
|
|
}
|
|
if (_captureResource.managedSession.isRunning) {
|
|
// If it is fixed, we signal received the first frame.
|
|
SCGhostToSnappableSignalDidReceiveFirstPreviewFrame();
|
|
|
|
// For non-metal preview render, we need to make sure preview is not hidden
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[self _fixNonMetalSessionPreviewInconsistency];
|
|
}
|
|
runOnMainThreadAsynchronously(^{
|
|
[_captureResource.announcer managedCapturer:self didStartRunning:_captureResource.state];
|
|
// To approximate this did render timer, it is not accurate.
|
|
SCGhostToSnappableSignalDidRenderFirstPreviewFrame(CACurrentMediaTime());
|
|
});
|
|
} else {
|
|
[_captureResource.queuePerformer perform:^{
|
|
[self _fixAVSessionIfNecessary];
|
|
}
|
|
after:1];
|
|
}
|
|
|
|
[_captureResource.blackCameraDetector sessionDidChangeIsRunning:_captureResource.managedSession.isRunning];
|
|
}
|
|
|
|
- (void)_fixNonMetalSessionPreviewInconsistency
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SC_GUARD_ELSE_RETURN(_captureResource.status == SCManagedCapturerStatusRunning);
|
|
if ((!_captureResource.videoPreviewLayer.hidden) != _captureResource.managedSession.isRunning) {
|
|
SCTraceStartSection("Fix non-Metal VideoPreviewLayer");
|
|
{
|
|
[CATransaction begin];
|
|
[CATransaction setDisableActions:YES];
|
|
[SCCaptureWorker setupVideoPreviewLayer:_captureResource];
|
|
[CATransaction commit];
|
|
}
|
|
SCTraceEndSection();
|
|
}
|
|
}
|
|
|
|
- (SCCaptureResource *)captureResource
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
return _captureResource;
|
|
}
|
|
|
|
- (id<SCManagedCapturerLensAPI>)lensProcessingCore
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
@weakify(self);
|
|
return (id<SCManagedCapturerLensAPI>)[[SCLazyLoadingProxy alloc] initWithInitializationBlock:^id {
|
|
@strongify(self);
|
|
SCReportErrorIf(self.captureResource.state.lensProcessorReady, @"[Lenses] Lens processing core is not ready");
|
|
return self.captureResource.lensProcessingCore;
|
|
}];
|
|
}
|
|
|
|
- (SCVideoCaptureSessionInfo)activeSession
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
return [SCCaptureWorker activeSession:_captureResource];
|
|
}
|
|
|
|
- (BOOL)isLensApplied
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
return [SCCaptureWorker isLensApplied:_captureResource];
|
|
}
|
|
|
|
- (BOOL)isVideoMirrored
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
return [SCCaptureWorker isVideoMirrored:_captureResource];
|
|
}
|
|
|
|
#pragma mark - Setup, Start & Stop
|
|
|
|
- (void)_updateHRSIEnabled
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
// Since night mode is low-res, we set high resolution still image output when night mode is enabled
|
|
// SoftwareZoom requires higher resolution image to get better zooming result too.
|
|
// We also want a higher resolution on newer devices
|
|
BOOL is1080pSupported = [SCManagedCaptureDevice is1080pSupported];
|
|
BOOL shouldHRSIEnabled =
|
|
(_captureResource.device.isNightModeActive || _captureResource.device.softwareZoom || is1080pSupported);
|
|
SCLogCapturerInfo(@"Setting HRSIEnabled to: %d. isNightModeActive:%d softwareZoom:%d is1080pSupported:%d",
|
|
shouldHRSIEnabled, _captureResource.device.isNightModeActive,
|
|
_captureResource.device.softwareZoom, is1080pSupported);
|
|
[_captureResource.stillImageCapturer setHighResolutionStillImageOutputEnabled:shouldHRSIEnabled];
|
|
}
|
|
|
|
- (void)_updateStillImageStabilizationEnabled
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Enabling still image stabilization");
|
|
[_captureResource.stillImageCapturer enableStillImageStabilization];
|
|
}
|
|
|
|
- (void)setupWithDevicePositionAsynchronously:(SCManagedCaptureDevicePosition)devicePosition
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Setting up with devicePosition:%lu", (unsigned long)devicePosition);
|
|
SCTraceResumeToken token = SCTraceCapture();
|
|
[[SCManagedCapturePreviewLayerController sharedInstance] setupPreviewLayer];
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceResume(token);
|
|
[self setupWithDevicePosition:devicePosition completionHandler:completionHandler];
|
|
}];
|
|
}
|
|
|
|
- (void)setupWithDevicePosition:(SCManagedCaptureDevicePosition)devicePosition
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssertPerformer(_captureResource.queuePerformer);
|
|
[SCCaptureWorker setupWithCaptureResource:_captureResource devicePosition:devicePosition];
|
|
|
|
[self addListener:_captureResource.stillImageCapturer];
|
|
[self addListener:_captureResource.blackCameraDetector.blackCameraNoOutputDetector];
|
|
[self addListener:_captureResource.lensProcessingCore];
|
|
|
|
[self _updateHRSIEnabled];
|
|
[self _updateStillImageStabilizationEnabled];
|
|
|
|
[SCCaptureWorker updateLensesFieldOfViewTracking:_captureResource];
|
|
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[SCCaptureWorker makeVideoPreviewLayer:_captureResource];
|
|
}
|
|
|
|
// I need to do this setup now. Thus, it is off the main thread. This also means my preview layer controller is
|
|
// entangled with the capturer.
|
|
[[SCManagedCapturePreviewLayerController sharedInstance] setupRenderPipeline];
|
|
[[SCManagedCapturePreviewLayerController sharedInstance] setManagedCapturer:self];
|
|
_captureResource.status = SCManagedCapturerStatusReady;
|
|
|
|
SCManagedCapturerState *state = [_captureResource.state copy];
|
|
AVCaptureVideoPreviewLayer *videoPreviewLayer = _captureResource.videoPreviewLayer;
|
|
runOnMainThreadAsynchronously(^{
|
|
SCLogCapturerInfo(@"Did setup with devicePosition:%lu", (unsigned long)devicePosition);
|
|
[_captureResource.announcer managedCapturer:self didChangeState:state];
|
|
[_captureResource.announcer managedCapturer:self didChangeCaptureDevicePosition:state];
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[_captureResource.announcer managedCapturer:self didChangeVideoPreviewLayer:videoPreviewLayer];
|
|
}
|
|
if (completionHandler) {
|
|
completionHandler();
|
|
}
|
|
});
|
|
}
|
|
|
|
- (void)addSampleBufferDisplayController:(id<SCManagedSampleBufferDisplayController>)sampleBufferDisplayController
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
_captureResource.sampleBufferDisplayController = sampleBufferDisplayController;
|
|
[_captureResource.videoDataSource addSampleBufferDisplayController:sampleBufferDisplayController];
|
|
}];
|
|
}
|
|
|
|
- (SCCapturerToken *)startRunningAsynchronouslyWithCompletionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCTraceResumeToken resumeToken = SCTraceCapture();
|
|
[[SCLogger sharedInstance] updateLogTimedEventStart:kSCCameraMetricsOpen uniqueId:@""];
|
|
SCCapturerToken *token = [[SCCapturerToken alloc] initWithIdentifier:context];
|
|
SCLogCapturerInfo(@"startRunningAsynchronouslyWithCompletionHandler called. token: %@", token);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceResume(resumeToken);
|
|
[SCCaptureWorker startRunningWithCaptureResource:_captureResource
|
|
token:token
|
|
completionHandler:completionHandler];
|
|
// After startRunning, we need to make sure _fixAVSessionIfNecessary start running.
|
|
// The problem: with the new KVO fix strategy, it may happen that AVCaptureSession is in stopped state, thus no
|
|
// KVO callback is triggered.
|
|
// And calling startRunningAsynchronouslyWithCompletionHandler has no effect because SCManagedCapturerStatus is
|
|
// in SCManagedCapturerStatusRunning state
|
|
[self _fixAVSessionIfNecessary];
|
|
}];
|
|
return token;
|
|
}
|
|
|
|
- (BOOL)stopRunningWithCaptureToken:(SCCapturerToken *)token
|
|
completionHandler:(sc_managed_capturer_stop_running_completion_handler_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssertPerformer(_captureResource.queuePerformer);
|
|
SCLogCapturerInfo(@"Stop running. token:%@ context:%@", token, context);
|
|
return [SCCaptureWorker stopRunningWithCaptureResource:_captureResource
|
|
token:token
|
|
completionHandler:completionHandler];
|
|
}
|
|
|
|
- (void)stopRunningAsynchronously:(SCCapturerToken *)token
|
|
completionHandler:(sc_managed_capturer_stop_running_completion_handler_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Stop running asynchronously. token:%@ context:%@", token, context);
|
|
SCTraceResumeToken resumeToken = SCTraceCapture();
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceResume(resumeToken);
|
|
[SCCaptureWorker stopRunningWithCaptureResource:_captureResource
|
|
token:token
|
|
completionHandler:completionHandler];
|
|
}];
|
|
}
|
|
|
|
- (void)stopRunningAsynchronously:(SCCapturerToken *)token
|
|
completionHandler:(sc_managed_capturer_stop_running_completion_handler_t)completionHandler
|
|
after:(NSTimeInterval)delay
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Stop running asynchronously. token:%@ delay:%f", token, delay);
|
|
NSTimeInterval startTime = CACurrentMediaTime();
|
|
[_captureResource.queuePerformer perform:^{
|
|
NSTimeInterval elapsedTime = CACurrentMediaTime() - startTime;
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
// If we haven't started a new running sequence yet, stop running now
|
|
[SCCaptureWorker stopRunningWithCaptureResource:_captureResource
|
|
token:token
|
|
completionHandler:completionHandler];
|
|
}
|
|
after:MAX(delay - elapsedTime, 0)];
|
|
}];
|
|
}
|
|
|
|
- (void)startStreamingAsynchronouslyWithCompletionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Start streaming asynchronously");
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
[SCCaptureWorker startStreaming:_captureResource];
|
|
if (completionHandler) {
|
|
runOnMainThreadAsynchronously(completionHandler);
|
|
}
|
|
}];
|
|
}
|
|
|
|
#pragma mark - Recording / Capture
|
|
|
|
- (void)captureStillImageAsynchronouslyWithAspectRatio:(CGFloat)aspectRatio
|
|
captureSessionID:(NSString *)captureSessionID
|
|
completionHandler:
|
|
(sc_managed_capturer_capture_still_image_completion_handler_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
[SCCaptureWorker captureStillImageWithCaptureResource:_captureResource
|
|
aspectRatio:aspectRatio
|
|
captureSessionID:captureSessionID
|
|
shouldCaptureFromVideo:[self _shouldCaptureImageFromVideo]
|
|
completionHandler:completionHandler
|
|
context:context];
|
|
}];
|
|
}
|
|
|
|
- (void)captureSingleVideoFrameAsynchronouslyWithCompletionHandler:
|
|
(sc_managed_capturer_capture_video_frame_completion_handler_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
SCLogCapturerInfo(@"Start capturing single video frame");
|
|
_captureResource.frameCap = [[SCSingleFrameStreamCapturer alloc] initWithCompletion:^void(UIImage *image) {
|
|
[_captureResource.queuePerformer perform:^{
|
|
[_captureResource.videoDataSource removeListener:_captureResource.frameCap];
|
|
_captureResource.frameCap = nil;
|
|
}];
|
|
runOnMainThreadAsynchronously(^{
|
|
[_captureResource.device setTorchActive:NO];
|
|
SCLogCapturerInfo(@"End capturing single video frame");
|
|
completionHandler(image);
|
|
});
|
|
}];
|
|
|
|
BOOL waitForTorch = NO;
|
|
if (!_captureResource.state.torchActive) {
|
|
if (_captureResource.state.flashActive) {
|
|
waitForTorch = YES;
|
|
[_captureResource.device setTorchActive:YES];
|
|
}
|
|
}
|
|
[_captureResource.queuePerformer perform:^{
|
|
[_captureResource.videoDataSource addListener:_captureResource.frameCap];
|
|
[SCCaptureWorker startStreaming:_captureResource];
|
|
}
|
|
after:(waitForTorch ? 0.5 : 0)];
|
|
|
|
}];
|
|
}
|
|
|
|
- (void)prepareForRecordingAsynchronouslyWithContext:(NSString *)context
|
|
audioConfiguration:(SCAudioConfiguration *)configuration
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCLogCapturerInfo(@"prepare for recording");
|
|
[_captureResource.videoCapturer prepareForRecordingWithAudioConfiguration:configuration];
|
|
}];
|
|
}
|
|
|
|
- (void)startRecordingAsynchronouslyWithOutputSettings:(SCManagedVideoCapturerOutputSettings *)outputSettings
|
|
audioConfiguration:(SCAudioConfiguration *)configuration
|
|
maxDuration:(NSTimeInterval)maxDuration
|
|
fileURL:(NSURL *)fileURL
|
|
captureSessionID:(NSString *)captureSessionID
|
|
completionHandler:
|
|
(sc_managed_capturer_start_recording_completion_handler_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
[SCCaptureWorker startRecordingWithCaptureResource:_captureResource
|
|
outputSettings:outputSettings
|
|
audioConfiguration:configuration
|
|
maxDuration:maxDuration
|
|
fileURL:fileURL
|
|
captureSessionID:captureSessionID
|
|
completionHandler:completionHandler];
|
|
}];
|
|
}
|
|
|
|
- (void)stopRecordingAsynchronouslyWithContext:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
[SCCaptureWorker stopRecordingWithCaptureResource:_captureResource];
|
|
}];
|
|
}
|
|
|
|
- (void)cancelRecordingAsynchronouslyWithContext:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
[SCCaptureWorker cancelRecordingWithCaptureResource:_captureResource];
|
|
}];
|
|
}
|
|
|
|
- (void)startScanAsynchronouslyWithScanConfiguration:(SCScanConfiguration *)configuration context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
[SCCaptureWorker startScanWithScanConfiguration:configuration resource:_captureResource];
|
|
}];
|
|
}
|
|
|
|
- (void)stopScanAsynchronouslyWithCompletionHandler:(dispatch_block_t)completionHandler context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
[SCCaptureWorker stopScanWithCompletionHandler:completionHandler resource:_captureResource];
|
|
}];
|
|
}
|
|
|
|
- (void)sampleFrameWithCompletionHandler:(void (^)(UIImage *frame, CMTime presentationTime))completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
// Previously _captureResource.videoFrameSampler was conditionally created when setting up, but if this method is
|
|
// called it is a
|
|
// safe assumption the client wants it to run instead of failing silently, so always create
|
|
// _captureResource.videoFrameSampler
|
|
if (!_captureResource.videoFrameSampler) {
|
|
_captureResource.videoFrameSampler = [SCManagedVideoFrameSampler new];
|
|
[_captureResource.announcer addListener:_captureResource.videoFrameSampler];
|
|
}
|
|
SCLogCapturerInfo(@"Sampling next frame");
|
|
[_captureResource.videoFrameSampler sampleNextFrame:completionHandler];
|
|
}
|
|
|
|
- (void)addTimedTask:(SCTimedTask *)task context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Adding timed task:%@", task);
|
|
[_captureResource.queuePerformer perform:^{
|
|
[_captureResource.videoCapturer addTimedTask:task];
|
|
}];
|
|
}
|
|
|
|
- (void)clearTimedTasksWithContext:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
[_captureResource.videoCapturer clearTimedTasks];
|
|
}];
|
|
}
|
|
|
|
#pragma mark - Utilities
|
|
|
|
- (void)convertViewCoordinates:(CGPoint)viewCoordinates
|
|
completionHandler:(sc_managed_capturer_convert_view_coordniates_completion_handler_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssert(completionHandler, @"completionHandler shouldn't be nil");
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
if (SCDeviceSupportsMetal()) {
|
|
CGSize viewSize = [UIScreen mainScreen].fixedCoordinateSpace.bounds.size;
|
|
CGPoint pointOfInterest =
|
|
[_captureResource.device convertViewCoordinates:viewCoordinates
|
|
viewSize:viewSize
|
|
videoGravity:AVLayerVideoGravityResizeAspectFill];
|
|
runOnMainThreadAsynchronously(^{
|
|
completionHandler(pointOfInterest);
|
|
});
|
|
} else {
|
|
CGSize viewSize = _captureResource.videoPreviewLayer.bounds.size;
|
|
CGPoint pointOfInterest =
|
|
[_captureResource.device convertViewCoordinates:viewCoordinates
|
|
viewSize:viewSize
|
|
videoGravity:_captureResource.videoPreviewLayer.videoGravity];
|
|
runOnMainThreadAsynchronously(^{
|
|
completionHandler(pointOfInterest);
|
|
});
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)detectLensCategoryOnNextFrame:(CGPoint)point
|
|
lenses:(NSArray<SCLens *> *)lenses
|
|
completion:(sc_managed_lenses_processor_category_point_completion_handler_t)completion
|
|
context:(NSString *)context
|
|
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssert(completion, @"completionHandler shouldn't be nil");
|
|
SCAssertMainThread();
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
SCLogCapturerInfo(@"Detecting lens category on next frame. point:%@, lenses:%@", NSStringFromCGPoint(point),
|
|
[lenses valueForKey:NSStringFromSelector(@selector(lensId))]);
|
|
[_captureResource.lensProcessingCore
|
|
detectLensCategoryOnNextFrame:point
|
|
videoOrientation:_captureResource.videoDataSource.videoOrientation
|
|
lenses:lenses
|
|
completion:^(SCLensCategory *_Nullable category, NSInteger categoriesCount) {
|
|
runOnMainThreadAsynchronously(^{
|
|
if (completion) {
|
|
completion(category, categoriesCount);
|
|
}
|
|
});
|
|
}];
|
|
}];
|
|
}
|
|
|
|
#pragma mark - Configurations
|
|
|
|
- (void)setDevicePositionAsynchronously:(SCManagedCaptureDevicePosition)devicePosition
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Setting device position asynchronously to: %lu", (unsigned long)devicePosition);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
BOOL devicePositionChanged = NO;
|
|
BOOL nightModeChanged = NO;
|
|
BOOL portraitModeChanged = NO;
|
|
BOOL zoomFactorChanged = NO;
|
|
BOOL flashSupportedOrTorchSupportedChanged = NO;
|
|
SCManagedCapturerState *state = [_captureResource.state copy];
|
|
if (_captureResource.state.devicePosition != devicePosition) {
|
|
SCManagedCaptureDevice *device = [SCManagedCaptureDevice deviceWithPosition:devicePosition];
|
|
if (device) {
|
|
if (!device.delegate) {
|
|
device.delegate = _captureResource.captureDeviceHandler;
|
|
}
|
|
|
|
SCManagedCaptureDevice *prevDevice = _captureResource.device;
|
|
[SCCaptureWorker turnARSessionOff:_captureResource];
|
|
BOOL isStreaming = _captureResource.videoDataSource.isStreaming;
|
|
if (!SCDeviceSupportsMetal()) {
|
|
if (isStreaming) {
|
|
[_captureResource.videoDataSource stopStreaming];
|
|
}
|
|
}
|
|
SCLogCapturerInfo(@"Set device position beginConfiguration");
|
|
[_captureResource.videoDataSource beginConfiguration];
|
|
[_captureResource.managedSession beginConfiguration];
|
|
// Turn off flash for the current device in case it is active
|
|
[_captureResource.device setTorchActive:NO];
|
|
if (_captureResource.state.devicePosition == SCManagedCaptureDevicePositionFront) {
|
|
_captureResource.frontFlashController.torchActive = NO;
|
|
}
|
|
[_captureResource.deviceCapacityAnalyzer removeFocusListener];
|
|
[_captureResource.device removeDeviceAsInput:_captureResource.managedSession.avSession];
|
|
_captureResource.device = device;
|
|
BOOL deviceSet = [_captureResource.device setDeviceAsInput:_captureResource.managedSession.avSession];
|
|
// If we are toggling while recording, set the night mode back to not
|
|
// active
|
|
if (_captureResource.videoRecording) {
|
|
[self _setNightModeActive:NO];
|
|
}
|
|
// Sync night mode, torch and flash state with the current device
|
|
devicePositionChanged = (_captureResource.state.devicePosition != devicePosition);
|
|
nightModeChanged =
|
|
(_captureResource.state.isNightModeActive != _captureResource.device.isNightModeActive);
|
|
portraitModeChanged =
|
|
devicePositionChanged &&
|
|
(devicePosition == SCManagedCaptureDevicePositionBackDualCamera ||
|
|
_captureResource.state.devicePosition == SCManagedCaptureDevicePositionBackDualCamera);
|
|
zoomFactorChanged = (_captureResource.state.zoomFactor != _captureResource.device.zoomFactor);
|
|
if (zoomFactorChanged && _captureResource.device.softwareZoom) {
|
|
[SCCaptureWorker softwareZoomWithDevice:_captureResource.device resource:_captureResource];
|
|
}
|
|
if (_captureResource.state.flashActive != _captureResource.device.flashActive) {
|
|
// preserve flashActive across devices
|
|
_captureResource.device.flashActive = _captureResource.state.flashActive;
|
|
}
|
|
if (_captureResource.state.liveVideoStreaming != device.liveVideoStreamingActive) {
|
|
// preserve liveVideoStreaming state across devices
|
|
[_captureResource.device setLiveVideoStreaming:_captureResource.state.liveVideoStreaming
|
|
session:_captureResource.managedSession.avSession];
|
|
}
|
|
if (devicePosition == SCManagedCaptureDevicePositionBackDualCamera &&
|
|
_captureResource.state.isNightModeActive != _captureResource.device.isNightModeActive) {
|
|
// preserve nightMode when switching from back camera to back dual camera
|
|
[self _setNightModeActive:_captureResource.state.isNightModeActive];
|
|
}
|
|
|
|
flashSupportedOrTorchSupportedChanged =
|
|
(_captureResource.state.flashSupported != _captureResource.device.isFlashSupported ||
|
|
_captureResource.state.torchSupported != _captureResource.device.isTorchSupported);
|
|
SCLogCapturerInfo(@"Set device position: %lu -> %lu, night mode: %d -> %d, zoom "
|
|
@"factor: %f -> %f, flash supported: %d -> %d, torch supported: %d -> %d",
|
|
(unsigned long)_captureResource.state.devicePosition, (unsigned long)devicePosition,
|
|
_captureResource.state.isNightModeActive, _captureResource.device.isNightModeActive,
|
|
_captureResource.state.zoomFactor, _captureResource.device.zoomFactor,
|
|
_captureResource.state.flashSupported, _captureResource.device.isFlashSupported,
|
|
_captureResource.state.torchSupported, _captureResource.device.isTorchSupported);
|
|
_captureResource.state = [[[[[[[[SCManagedCapturerStateBuilder
|
|
withManagedCapturerState:_captureResource.state] setDevicePosition:devicePosition]
|
|
setIsNightModeActive:_captureResource.device.isNightModeActive]
|
|
setZoomFactor:_captureResource.device.zoomFactor]
|
|
setFlashSupported:_captureResource.device.isFlashSupported]
|
|
setTorchSupported:_captureResource.device.isTorchSupported]
|
|
setIsPortraitModeActive:devicePosition == SCManagedCaptureDevicePositionBackDualCamera] build];
|
|
[self _updateHRSIEnabled];
|
|
[self _updateStillImageStabilizationEnabled];
|
|
// This needs to be done after we have finished configure everything
|
|
// for session otherwise we
|
|
// may set it up without hooking up the video input yet, and will set
|
|
// wrong parameter for the
|
|
// output.
|
|
[_captureResource.videoDataSource setDevicePosition:devicePosition];
|
|
if (@available(ios 11.0, *)) {
|
|
if (portraitModeChanged) {
|
|
[_captureResource.videoDataSource
|
|
setDepthCaptureEnabled:_captureResource.state.isPortraitModeActive];
|
|
[_captureResource.device setCaptureDepthData:_captureResource.state.isPortraitModeActive
|
|
session:_captureResource.managedSession.avSession];
|
|
[_captureResource.stillImageCapturer
|
|
setPortraitModeCaptureEnabled:_captureResource.state.isPortraitModeActive];
|
|
if (_captureResource.state.isPortraitModeActive) {
|
|
SCProcessingPipelineBuilder *processingPipelineBuilder =
|
|
[[SCProcessingPipelineBuilder alloc] init];
|
|
processingPipelineBuilder.portraitModeEnabled = YES;
|
|
SCProcessingPipeline *pipeline = [processingPipelineBuilder build];
|
|
SCLogCapturerInfo(@"Adding processing pipeline:%@", pipeline);
|
|
[_captureResource.videoDataSource addProcessingPipeline:pipeline];
|
|
} else {
|
|
[_captureResource.videoDataSource removeProcessingPipeline];
|
|
}
|
|
}
|
|
}
|
|
[_captureResource.deviceCapacityAnalyzer setAsFocusListenerForDevice:_captureResource.device];
|
|
|
|
[SCCaptureWorker updateLensesFieldOfViewTracking:_captureResource];
|
|
[_captureResource.managedSession commitConfiguration];
|
|
[_captureResource.videoDataSource commitConfiguration];
|
|
|
|
// Checks if the flash is activated and if so switches the flash along
|
|
// with the camera view. Setting device's torch mode has to be called after -[AVCaptureSession
|
|
// commitConfiguration], otherwise flash may be not working, especially for iPhone 8/8 Plus.
|
|
if (_captureResource.state.torchActive ||
|
|
(_captureResource.state.flashActive && _captureResource.videoRecording)) {
|
|
[_captureResource.device setTorchActive:YES];
|
|
if (devicePosition == SCManagedCaptureDevicePositionFront) {
|
|
_captureResource.frontFlashController.torchActive = YES;
|
|
}
|
|
}
|
|
|
|
SCLogCapturerInfo(@"Set device position commitConfiguration");
|
|
[_captureResource.droppedFramesReporter didChangeCaptureDevicePosition];
|
|
if (!SCDeviceSupportsMetal()) {
|
|
if (isStreaming) {
|
|
[SCCaptureWorker startStreaming:_captureResource];
|
|
}
|
|
}
|
|
NSArray *inputs = _captureResource.managedSession.avSession.inputs;
|
|
if (!deviceSet) {
|
|
[self _logFailureSetDevicePositionFrom:_captureResource.state.devicePosition
|
|
to:devicePosition
|
|
reason:@"setDeviceForInput failed"];
|
|
} else if (inputs.count == 0) {
|
|
[self _logFailureSetDevicePositionFrom:_captureResource.state.devicePosition
|
|
to:devicePosition
|
|
reason:@"no input"];
|
|
} else if (inputs.count > 1) {
|
|
[self
|
|
_logFailureSetDevicePositionFrom:_captureResource.state.devicePosition
|
|
to:devicePosition
|
|
reason:[NSString sc_stringWithFormat:@"multiple inputs: %@", inputs]];
|
|
} else {
|
|
AVCaptureDeviceInput *input = [inputs firstObject];
|
|
AVCaptureDevice *resultDevice = input.device;
|
|
if (resultDevice == prevDevice.device) {
|
|
[self _logFailureSetDevicePositionFrom:_captureResource.state.devicePosition
|
|
to:devicePosition
|
|
reason:@"stayed on previous device"];
|
|
} else if (resultDevice != _captureResource.device.device) {
|
|
[self
|
|
_logFailureSetDevicePositionFrom:_captureResource.state.devicePosition
|
|
to:devicePosition
|
|
reason:[NSString sc_stringWithFormat:@"unknown input device: %@",
|
|
resultDevice]];
|
|
}
|
|
}
|
|
} else {
|
|
[self _logFailureSetDevicePositionFrom:_captureResource.state.devicePosition
|
|
to:devicePosition
|
|
reason:@"no device"];
|
|
}
|
|
} else {
|
|
SCLogCapturerInfo(@"Device position did not change");
|
|
if (_captureResource.device.position != _captureResource.state.devicePosition) {
|
|
[self _logFailureSetDevicePositionFrom:state.devicePosition
|
|
to:devicePosition
|
|
reason:@"state position set incorrectly"];
|
|
}
|
|
}
|
|
BOOL stateChanged = ![_captureResource.state isEqual:state];
|
|
state = [_captureResource.state copy];
|
|
runOnMainThreadAsynchronously(^{
|
|
if (stateChanged) {
|
|
[_captureResource.announcer managedCapturer:self didChangeState:state];
|
|
}
|
|
if (devicePositionChanged) {
|
|
[_captureResource.announcer managedCapturer:self didChangeCaptureDevicePosition:state];
|
|
}
|
|
if (nightModeChanged) {
|
|
[_captureResource.announcer managedCapturer:self didChangeNightModeActive:state];
|
|
}
|
|
if (portraitModeChanged) {
|
|
[_captureResource.announcer managedCapturer:self didChangePortraitModeActive:state];
|
|
}
|
|
if (zoomFactorChanged) {
|
|
[_captureResource.announcer managedCapturer:self didChangeZoomFactor:state];
|
|
}
|
|
if (flashSupportedOrTorchSupportedChanged) {
|
|
[_captureResource.announcer managedCapturer:self didChangeFlashSupportedAndTorchSupported:state];
|
|
}
|
|
if (completionHandler) {
|
|
completionHandler();
|
|
}
|
|
});
|
|
}];
|
|
}
|
|
|
|
- (void)_logFailureSetDevicePositionFrom:(SCManagedCaptureDevicePosition)start
|
|
to:(SCManagedCaptureDevicePosition)end
|
|
reason:(NSString *)reason
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Device position change failed: %@", reason);
|
|
[[SCLogger sharedInstance] logEvent:kSCCameraMetricsCameraFlipFailure
|
|
parameters:@{
|
|
@"start" : @(start),
|
|
@"end" : @(end),
|
|
@"reason" : reason,
|
|
}];
|
|
}
|
|
|
|
- (void)setFlashActive:(BOOL)flashActive
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
BOOL flashActiveOrFrontFlashEnabledChanged = NO;
|
|
if (_captureResource.state.flashActive != flashActive) {
|
|
[_captureResource.device setFlashActive:flashActive];
|
|
SCLogCapturerInfo(@"Set flash active: %d -> %d", _captureResource.state.flashActive, flashActive);
|
|
_captureResource.state = [[[SCManagedCapturerStateBuilder withManagedCapturerState:_captureResource.state]
|
|
setFlashActive:flashActive] build];
|
|
flashActiveOrFrontFlashEnabledChanged = YES;
|
|
}
|
|
SCManagedCapturerState *state = [_captureResource.state copy];
|
|
runOnMainThreadAsynchronously(^{
|
|
if (flashActiveOrFrontFlashEnabledChanged) {
|
|
[_captureResource.announcer managedCapturer:self didChangeState:state];
|
|
[_captureResource.announcer managedCapturer:self didChangeFlashActive:state];
|
|
}
|
|
if (completionHandler) {
|
|
completionHandler();
|
|
}
|
|
});
|
|
}];
|
|
}
|
|
|
|
- (void)setLensesActive:(BOOL)lensesActive
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[self _setLensesActive:lensesActive
|
|
liveVideoStreaming:NO
|
|
filterFactory:nil
|
|
completionHandler:completionHandler
|
|
context:context];
|
|
}
|
|
|
|
- (void)setLensesActive:(BOOL)lensesActive
|
|
filterFactory:(SCLookseryFilterFactory *)filterFactory
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
[self _setLensesActive:lensesActive
|
|
liveVideoStreaming:NO
|
|
filterFactory:filterFactory
|
|
completionHandler:completionHandler
|
|
context:context];
|
|
}
|
|
|
|
- (void)setLensesInTalkActive:(BOOL)lensesActive
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
// Talk requires liveVideoStreaming to be turned on
|
|
BOOL liveVideoStreaming = lensesActive;
|
|
|
|
dispatch_block_t activationBlock = ^{
|
|
[self _setLensesActive:lensesActive
|
|
liveVideoStreaming:liveVideoStreaming
|
|
filterFactory:nil
|
|
completionHandler:completionHandler
|
|
context:context];
|
|
};
|
|
|
|
@weakify(self);
|
|
[_captureResource.queuePerformer perform:^{
|
|
@strongify(self);
|
|
SC_GUARD_ELSE_RETURN(self);
|
|
// If lenses are enabled in TV3 and it was enabled not from TV3. We have to turn off lenses off at first.
|
|
BOOL shouldTurnOffBeforeActivation = liveVideoStreaming && !self->_captureResource.state.liveVideoStreaming &&
|
|
self->_captureResource.state.lensesActive;
|
|
if (shouldTurnOffBeforeActivation) {
|
|
[self _setLensesActive:NO
|
|
liveVideoStreaming:NO
|
|
filterFactory:nil
|
|
completionHandler:activationBlock
|
|
context:context];
|
|
} else {
|
|
activationBlock();
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)_setLensesActive:(BOOL)lensesActive
|
|
liveVideoStreaming:(BOOL)liveVideoStreaming
|
|
filterFactory:(SCLookseryFilterFactory *)filterFactory
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Setting lenses active to: %d", lensesActive);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
BOOL lensesActiveChanged = NO;
|
|
if (_captureResource.state.lensesActive != lensesActive) {
|
|
SCLogCapturerInfo(@"Set lenses active: %d -> %d", _captureResource.state.lensesActive, lensesActive);
|
|
_captureResource.state = [[[SCManagedCapturerStateBuilder withManagedCapturerState:_captureResource.state]
|
|
setLensesActive:lensesActive] build];
|
|
|
|
// Update capturer settings(orientation and resolution) after changing state, because
|
|
// _setLiveVideoStreaming logic is depends on it
|
|
[self _setLiveVideoStreaming:liveVideoStreaming];
|
|
|
|
[SCCaptureWorker turnARSessionOff:_captureResource];
|
|
|
|
// Only enable sample buffer display when lenses is not active.
|
|
[_captureResource.videoDataSource setSampleBufferDisplayEnabled:!lensesActive];
|
|
[_captureResource.debugInfoDict setObject:!lensesActive ? @"True" : @"False"
|
|
forKey:@"sampleBufferDisplayEnabled"];
|
|
|
|
lensesActiveChanged = YES;
|
|
[_captureResource.lensProcessingCore setAspectRatio:_captureResource.state.liveVideoStreaming];
|
|
[_captureResource.lensProcessingCore setLensesActive:_captureResource.state.lensesActive
|
|
videoOrientation:_captureResource.videoDataSource.videoOrientation
|
|
filterFactory:filterFactory];
|
|
BOOL modifySource = _captureResource.state.liveVideoStreaming || _captureResource.videoRecording;
|
|
[_captureResource.lensProcessingCore setModifySource:modifySource];
|
|
[_captureResource.lensProcessingCore setShouldMuteAllSounds:_captureResource.state.liveVideoStreaming];
|
|
if (_captureResource.fileInputDecider.shouldProcessFileInput) {
|
|
[_captureResource.lensProcessingCore setLensesActive:YES
|
|
videoOrientation:_captureResource.videoDataSource.videoOrientation
|
|
filterFactory:filterFactory];
|
|
}
|
|
[_captureResource.videoDataSource
|
|
setVideoStabilizationEnabledIfSupported:!_captureResource.state.lensesActive];
|
|
|
|
if (SCIsMasterBuild()) {
|
|
// Check that connection configuration is correct
|
|
if (_captureResource.state.lensesActive &&
|
|
_captureResource.state.devicePosition == SCManagedCaptureDevicePositionFront) {
|
|
for (AVCaptureOutput *output in _captureResource.managedSession.avSession.outputs) {
|
|
if ([output isKindOfClass:[AVCaptureVideoDataOutput class]]) {
|
|
AVCaptureConnection *connection = [output connectionWithMediaType:AVMediaTypeVideo];
|
|
SCAssert(connection.videoMirrored &&
|
|
connection.videoOrientation == !_captureResource.state.liveVideoStreaming
|
|
? AVCaptureVideoOrientationLandscapeRight
|
|
: AVCaptureVideoOrientationPortrait,
|
|
@"Connection configuration is not correct");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
dispatch_block_t viewChangeHandler = ^{
|
|
SCManagedCapturerState *state = [_captureResource.state copy]; // update to latest state always
|
|
runOnMainThreadAsynchronously(^{
|
|
[_captureResource.announcer managedCapturer:self didChangeState:state];
|
|
[_captureResource.announcer managedCapturer:self didChangeLensesActive:state];
|
|
[_captureResource.videoPreviewGLViewManager setLensesActive:state.lensesActive];
|
|
if (completionHandler) {
|
|
completionHandler();
|
|
}
|
|
});
|
|
};
|
|
if (lensesActiveChanged && !lensesActive && SCDeviceSupportsMetal()) {
|
|
// If we are turning off lenses and have sample buffer display on.
|
|
// We need to wait until new frame presented in sample buffer before
|
|
// dismiss the Lenses' OpenGL view.
|
|
[_captureResource.videoDataSource waitUntilSampleBufferDisplayed:_captureResource.queuePerformer.queue
|
|
completionHandler:viewChangeHandler];
|
|
} else {
|
|
viewChangeHandler();
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)_setLiveVideoStreaming:(BOOL)liveVideoStreaming
|
|
{
|
|
SCAssertPerformer(_captureResource.queuePerformer);
|
|
BOOL enableLiveVideoStreaming = liveVideoStreaming;
|
|
if (!_captureResource.state.lensesActive && liveVideoStreaming) {
|
|
SCLogLensesError(@"LiveVideoStreaming is not allowed when lenses are turned off");
|
|
enableLiveVideoStreaming = NO;
|
|
}
|
|
SC_GUARD_ELSE_RETURN(enableLiveVideoStreaming != _captureResource.state.liveVideoStreaming);
|
|
|
|
// We will disable blackCameraNoOutputDetector if in live video streaming
|
|
// In case there is some black camera when doing video call, will consider re-enable it
|
|
[self _setBlackCameraNoOutputDetectorEnabled:!liveVideoStreaming];
|
|
|
|
if (!_captureResource.device.isConnected) {
|
|
SCLogCapturerError(@"Can't perform configuration for live video streaming");
|
|
}
|
|
SCLogCapturerInfo(@"Set live video streaming: %d -> %d", _captureResource.state.liveVideoStreaming,
|
|
enableLiveVideoStreaming);
|
|
_captureResource.state = [[[SCManagedCapturerStateBuilder withManagedCapturerState:_captureResource.state]
|
|
setLiveVideoStreaming:enableLiveVideoStreaming] build];
|
|
|
|
BOOL isStreaming = _captureResource.videoDataSource.isStreaming;
|
|
if (isStreaming) {
|
|
[_captureResource.videoDataSource stopStreaming];
|
|
}
|
|
|
|
SCLogCapturerInfo(@"Set live video streaming beginConfiguration");
|
|
[_captureResource.managedSession performConfiguration:^{
|
|
[_captureResource.videoDataSource beginConfiguration];
|
|
|
|
// If video chat is active we should use portrait orientation, otherwise landscape right
|
|
[_captureResource.videoDataSource setVideoOrientation:_captureResource.state.liveVideoStreaming
|
|
? AVCaptureVideoOrientationPortrait
|
|
: AVCaptureVideoOrientationLandscapeRight];
|
|
|
|
[_captureResource.device setLiveVideoStreaming:_captureResource.state.liveVideoStreaming
|
|
session:_captureResource.managedSession.avSession];
|
|
|
|
[_captureResource.videoDataSource commitConfiguration];
|
|
}];
|
|
|
|
SCLogCapturerInfo(@"Set live video streaming commitConfiguration");
|
|
|
|
if (isStreaming) {
|
|
[_captureResource.videoDataSource startStreaming];
|
|
}
|
|
}
|
|
|
|
- (void)_setBlackCameraNoOutputDetectorEnabled:(BOOL)enabled
|
|
{
|
|
if (enabled) {
|
|
[self addListener:_captureResource.blackCameraDetector.blackCameraNoOutputDetector];
|
|
[_captureResource.videoDataSource addListener:_captureResource.blackCameraDetector.blackCameraNoOutputDetector];
|
|
} else {
|
|
[self removeListener:_captureResource.blackCameraDetector.blackCameraNoOutputDetector];
|
|
[_captureResource.videoDataSource
|
|
removeListener:_captureResource.blackCameraDetector.blackCameraNoOutputDetector];
|
|
}
|
|
}
|
|
|
|
- (void)setTorchActiveAsynchronously:(BOOL)torchActive
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCLogCapturerInfo(@"Setting torch active asynchronously to: %d", torchActive);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
BOOL torchActiveChanged = NO;
|
|
if (_captureResource.state.torchActive != torchActive) {
|
|
[_captureResource.device setTorchActive:torchActive];
|
|
if (_captureResource.state.devicePosition == SCManagedCaptureDevicePositionFront) {
|
|
_captureResource.frontFlashController.torchActive = torchActive;
|
|
}
|
|
SCLogCapturerInfo(@"Set torch active: %d -> %d", _captureResource.state.torchActive, torchActive);
|
|
_captureResource.state = [[[SCManagedCapturerStateBuilder withManagedCapturerState:_captureResource.state]
|
|
setTorchActive:torchActive] build];
|
|
torchActiveChanged = YES;
|
|
}
|
|
SCManagedCapturerState *state = [_captureResource.state copy];
|
|
runOnMainThreadAsynchronously(^{
|
|
if (torchActiveChanged) {
|
|
[_captureResource.announcer managedCapturer:self didChangeState:state];
|
|
}
|
|
if (completionHandler) {
|
|
completionHandler();
|
|
}
|
|
});
|
|
}];
|
|
}
|
|
|
|
- (void)setNightModeActiveAsynchronously:(BOOL)active
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
// Only do the configuration if current device is connected
|
|
if (_captureResource.device.isConnected) {
|
|
SCLogCapturerInfo(@"Set night mode beginConfiguration");
|
|
[_captureResource.managedSession performConfiguration:^{
|
|
[self _setNightModeActive:active];
|
|
[self _updateHRSIEnabled];
|
|
[self _updateStillImageStabilizationEnabled];
|
|
}];
|
|
SCLogCapturerInfo(@"Set night mode commitConfiguration");
|
|
}
|
|
BOOL nightModeChanged = (_captureResource.state.isNightModeActive != active);
|
|
if (nightModeChanged) {
|
|
SCLogCapturerInfo(@"Set night mode active: %d -> %d", _captureResource.state.isNightModeActive, active);
|
|
_captureResource.state = [[[SCManagedCapturerStateBuilder withManagedCapturerState:_captureResource.state]
|
|
setIsNightModeActive:active] build];
|
|
}
|
|
SCManagedCapturerState *state = [_captureResource.state copy];
|
|
runOnMainThreadAsynchronously(^{
|
|
if (nightModeChanged) {
|
|
[_captureResource.announcer managedCapturer:self didChangeState:state];
|
|
[_captureResource.announcer managedCapturer:self didChangeNightModeActive:state];
|
|
}
|
|
if (completionHandler) {
|
|
completionHandler();
|
|
}
|
|
});
|
|
}];
|
|
}
|
|
|
|
- (void)_setNightModeActive:(BOOL)active
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.device setNightModeActive:active session:_captureResource.managedSession.avSession];
|
|
if ([SCManagedCaptureDevice isEnhancedNightModeSupported]) {
|
|
[self _toggleSoftwareNightmode:active];
|
|
}
|
|
}
|
|
|
|
- (void)_toggleSoftwareNightmode:(BOOL)active
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
if (active) {
|
|
SCLogCapturerInfo(@"Set enhanced night mode active");
|
|
SCProcessingPipelineBuilder *processingPipelineBuilder = [[SCProcessingPipelineBuilder alloc] init];
|
|
processingPipelineBuilder.enhancedNightMode = YES;
|
|
SCProcessingPipeline *pipeline = [processingPipelineBuilder build];
|
|
SCLogCapturerInfo(@"Adding processing pipeline:%@", pipeline);
|
|
[_captureResource.videoDataSource addProcessingPipeline:pipeline];
|
|
} else {
|
|
SCLogCapturerInfo(@"Removing processing pipeline");
|
|
[_captureResource.videoDataSource removeProcessingPipeline];
|
|
}
|
|
}
|
|
|
|
- (BOOL)_shouldCaptureImageFromVideo
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
BOOL isIphone5Series = [SCDeviceName isSimilarToIphone5orNewer] && ![SCDeviceName isSimilarToIphone6orNewer];
|
|
return isIphone5Series && !_captureResource.state.flashActive && ![self isLensApplied];
|
|
}
|
|
|
|
- (void)lockZoomWithContext:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssertMainThread();
|
|
SCLogCapturerInfo(@"Lock zoom");
|
|
_captureResource.allowsZoom = NO;
|
|
}
|
|
|
|
- (void)unlockZoomWithContext:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssertMainThread();
|
|
SCLogCapturerInfo(@"Unlock zoom");
|
|
// Don't let anyone unlock the zoom while ARKit is active. When ARKit shuts down, it'll unlock it.
|
|
SC_GUARD_ELSE_RETURN(!_captureResource.state.arSessionActive);
|
|
_captureResource.allowsZoom = YES;
|
|
}
|
|
|
|
- (void)setZoomFactorAsynchronously:(CGFloat)zoomFactor context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssertMainThread();
|
|
SC_GUARD_ELSE_RETURN(_captureResource.allowsZoom);
|
|
SCLogCapturerInfo(@"Setting zoom factor to: %f", zoomFactor);
|
|
[_captureResource.deviceZoomHandler setZoomFactor:zoomFactor forDevice:_captureResource.device immediately:NO];
|
|
}
|
|
|
|
- (void)resetZoomFactorAsynchronously:(CGFloat)zoomFactor
|
|
devicePosition:(SCManagedCaptureDevicePosition)devicePosition
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssertMainThread();
|
|
SC_GUARD_ELSE_RETURN(_captureResource.allowsZoom);
|
|
SCLogCapturerInfo(@"Setting zoom factor to: %f devicePosition:%lu", zoomFactor, (unsigned long)devicePosition);
|
|
SCManagedCaptureDevice *device = [SCManagedCaptureDevice deviceWithPosition:devicePosition];
|
|
[_captureResource.deviceZoomHandler setZoomFactor:zoomFactor forDevice:device immediately:YES];
|
|
}
|
|
|
|
- (void)setExposurePointOfInterestAsynchronously:(CGPoint)pointOfInterest
|
|
fromUser:(BOOL)fromUser
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
if (_captureResource.device.isConnected) {
|
|
CGPoint exposurePoint;
|
|
if ([self isVideoMirrored]) {
|
|
exposurePoint = CGPointMake(pointOfInterest.x, 1 - pointOfInterest.y);
|
|
} else {
|
|
exposurePoint = pointOfInterest;
|
|
}
|
|
if (_captureResource.device.softwareZoom) {
|
|
// Fix for the zooming factor
|
|
[_captureResource.device
|
|
setExposurePointOfInterest:CGPointMake(
|
|
(exposurePoint.x - 0.5) / _captureResource.device.softwareZoom + 0.5,
|
|
(exposurePoint.y - 0.5) / _captureResource.device.softwareZoom + 0.5)
|
|
fromUser:fromUser];
|
|
} else {
|
|
[_captureResource.device setExposurePointOfInterest:exposurePoint fromUser:fromUser];
|
|
}
|
|
}
|
|
if (completionHandler) {
|
|
runOnMainThreadAsynchronously(completionHandler);
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)setAutofocusPointOfInterestAsynchronously:(CGPoint)pointOfInterest
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
if (_captureResource.device.isConnected) {
|
|
CGPoint focusPoint;
|
|
if ([self isVideoMirrored]) {
|
|
focusPoint = CGPointMake(pointOfInterest.x, 1 - pointOfInterest.y);
|
|
} else {
|
|
focusPoint = pointOfInterest;
|
|
}
|
|
if (_captureResource.device.softwareZoom) {
|
|
// Fix for the zooming factor
|
|
[_captureResource.device
|
|
setAutofocusPointOfInterest:CGPointMake(
|
|
(focusPoint.x - 0.5) / _captureResource.device.softwareZoom + 0.5,
|
|
(focusPoint.y - 0.5) / _captureResource.device.softwareZoom + 0.5)];
|
|
} else {
|
|
[_captureResource.device setAutofocusPointOfInterest:focusPoint];
|
|
}
|
|
}
|
|
if (completionHandler) {
|
|
runOnMainThreadAsynchronously(completionHandler);
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)setPortraitModePointOfInterestAsynchronously:(CGPoint)pointOfInterest
|
|
completionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[SCCaptureWorker setPortraitModePointOfInterestAsynchronously:pointOfInterest
|
|
completionHandler:completionHandler
|
|
resource:_captureResource];
|
|
}
|
|
|
|
- (void)continuousAutofocusAndExposureAsynchronouslyWithCompletionHandler:(dispatch_block_t)completionHandler
|
|
context:(NSString *)context
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
if (_captureResource.device.isConnected) {
|
|
[_captureResource.device continuousAutofocus];
|
|
[_captureResource.device setExposurePointOfInterest:CGPointMake(0.5, 0.5) fromUser:NO];
|
|
if (SCCameraTweaksEnablePortraitModeAutofocus()) {
|
|
[self setPortraitModePointOfInterestAsynchronously:CGPointMake(0.5, 0.5)
|
|
completionHandler:nil
|
|
context:context];
|
|
}
|
|
}
|
|
if (completionHandler) {
|
|
runOnMainThreadAsynchronously(completionHandler);
|
|
}
|
|
}];
|
|
}
|
|
|
|
#pragma mark - Add / Remove Listener
|
|
|
|
- (void)addListener:(id<SCManagedCapturerListener>)listener
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
// Only do the make sure thing if I added it to announcer fresh.
|
|
SC_GUARD_ELSE_RETURN([_captureResource.announcer addListener:listener]);
|
|
// After added the listener, make sure we called all these methods with its
|
|
// initial values
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCManagedCapturerState *state = [_captureResource.state copy];
|
|
AVCaptureVideoPreviewLayer *videoPreviewLayer = _captureResource.videoPreviewLayer;
|
|
LSAGLView *videoPreviewGLView = _captureResource.videoPreviewGLViewManager.view;
|
|
runOnMainThreadAsynchronously(^{
|
|
SCTraceStart();
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeState:)]) {
|
|
[listener managedCapturer:self didChangeState:state];
|
|
}
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeCaptureDevicePosition:)]) {
|
|
[listener managedCapturer:self didChangeCaptureDevicePosition:state];
|
|
}
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeNightModeActive:)]) {
|
|
[listener managedCapturer:self didChangeNightModeActive:state];
|
|
}
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeFlashActive:)]) {
|
|
[listener managedCapturer:self didChangeFlashActive:state];
|
|
}
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeFlashSupportedAndTorchSupported:)]) {
|
|
[listener managedCapturer:self didChangeFlashSupportedAndTorchSupported:state];
|
|
}
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeZoomFactor:)]) {
|
|
[listener managedCapturer:self didChangeZoomFactor:state];
|
|
}
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeLowLightCondition:)]) {
|
|
[listener managedCapturer:self didChangeLowLightCondition:state];
|
|
}
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeAdjustingExposure:)]) {
|
|
[listener managedCapturer:self didChangeAdjustingExposure:state];
|
|
}
|
|
if (!SCDeviceSupportsMetal()) {
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeVideoPreviewLayer:)]) {
|
|
[listener managedCapturer:self didChangeVideoPreviewLayer:videoPreviewLayer];
|
|
}
|
|
}
|
|
if (videoPreviewGLView &&
|
|
[listener respondsToSelector:@selector(managedCapturer:didChangeVideoPreviewGLView:)]) {
|
|
[listener managedCapturer:self didChangeVideoPreviewGLView:videoPreviewGLView];
|
|
}
|
|
if ([listener respondsToSelector:@selector(managedCapturer:didChangeLensesActive:)]) {
|
|
[listener managedCapturer:self didChangeLensesActive:state];
|
|
}
|
|
});
|
|
}];
|
|
}
|
|
|
|
- (void)removeListener:(id<SCManagedCapturerListener>)listener
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.announcer removeListener:listener];
|
|
}
|
|
|
|
- (void)addVideoDataSourceListener:(id<SCManagedVideoDataSourceListener>)listener
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.videoDataSource addListener:listener];
|
|
}
|
|
|
|
- (void)removeVideoDataSourceListener:(id<SCManagedVideoDataSourceListener>)listener
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.videoDataSource removeListener:listener];
|
|
}
|
|
|
|
- (void)addDeviceCapacityAnalyzerListener:(id<SCManagedDeviceCapacityAnalyzerListener>)listener
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.deviceCapacityAnalyzer addListener:listener];
|
|
}
|
|
|
|
- (void)removeDeviceCapacityAnalyzerListener:(id<SCManagedDeviceCapacityAnalyzerListener>)listener
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.deviceCapacityAnalyzer removeListener:listener];
|
|
}
|
|
|
|
#pragma mark - Debug
|
|
|
|
- (NSString *)debugInfo
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
NSMutableString *info = [NSMutableString new];
|
|
[info appendString:@"==== SCManagedCapturer tokens ====\n"];
|
|
[_captureResource.tokenSet enumerateObjectsUsingBlock:^(SCCapturerToken *_Nonnull token, BOOL *_Nonnull stop) {
|
|
[info appendFormat:@"%@\n", token.debugDescription];
|
|
}];
|
|
return info.copy;
|
|
}
|
|
|
|
- (NSString *)description
|
|
{
|
|
return [self debugDescription];
|
|
}
|
|
|
|
- (NSString *)debugDescription
|
|
{
|
|
return [NSString sc_stringWithFormat:@"SCManagedCapturer state:\n%@\nVideo streamer info:\n%@",
|
|
_captureResource.state.debugDescription,
|
|
_captureResource.videoDataSource.description];
|
|
}
|
|
|
|
- (CMTime)firstWrittenAudioBufferDelay
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
return [SCCaptureWorker firstWrittenAudioBufferDelay:_captureResource];
|
|
}
|
|
|
|
- (BOOL)audioQueueStarted
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
return [SCCaptureWorker audioQueueStarted:_captureResource];
|
|
}
|
|
|
|
#pragma mark - SCTimeProfilable
|
|
|
|
+ (SCTimeProfilerContext)context
|
|
{
|
|
return SCTimeProfilerContextCamera;
|
|
}
|
|
|
|
// We disable and re-enable liveness timer when enter background and foreground
|
|
|
|
- (void)applicationDidEnterBackground
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[SCCaptureWorker destroyLivenessConsistencyTimer:_captureResource];
|
|
// Hide the view when in background.
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[_captureResource.queuePerformer perform:^{
|
|
_captureResource.appInBackground = YES;
|
|
[CATransaction begin];
|
|
[CATransaction setDisableActions:YES];
|
|
_captureResource.videoPreviewLayer.hidden = YES;
|
|
[CATransaction commit];
|
|
}];
|
|
} else {
|
|
[_captureResource.queuePerformer perform:^{
|
|
_captureResource.appInBackground = YES;
|
|
// If it is running, stop the streaming.
|
|
if (_captureResource.status == SCManagedCapturerStatusRunning) {
|
|
[_captureResource.videoDataSource stopStreaming];
|
|
}
|
|
}];
|
|
}
|
|
[[SCManagedCapturePreviewLayerController sharedInstance] applicationDidEnterBackground];
|
|
}
|
|
|
|
- (void)applicationWillEnterForeground
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
_captureResource.appInBackground = NO;
|
|
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[self _fixNonMetalSessionPreviewInconsistency];
|
|
}
|
|
|
|
// Doing this right now on iOS 10. It will probably work on iOS 9 as well, but need to verify.
|
|
if (SC_AT_LEAST_IOS_10) {
|
|
[self _runningConsistencyCheckAndFix];
|
|
// For OS version >= iOS 10, try to fix AVCaptureSession when app is entering foreground.
|
|
_captureResource.numRetriesFixAVCaptureSessionWithCurrentSession = 0;
|
|
[self _fixAVSessionIfNecessary];
|
|
}
|
|
}];
|
|
} else {
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
_captureResource.appInBackground = NO;
|
|
if (_captureResource.status == SCManagedCapturerStatusRunning) {
|
|
[_captureResource.videoDataSource startStreaming];
|
|
}
|
|
// Doing this right now on iOS 10. It will probably work on iOS 9 as well, but need to verify.
|
|
if (SC_AT_LEAST_IOS_10) {
|
|
[self _runningConsistencyCheckAndFix];
|
|
// For OS version >= iOS 10, try to fix AVCaptureSession when app is entering foreground.
|
|
_captureResource.numRetriesFixAVCaptureSessionWithCurrentSession = 0;
|
|
[self _fixAVSessionIfNecessary];
|
|
}
|
|
}];
|
|
}
|
|
[[SCManagedCapturePreviewLayerController sharedInstance] applicationWillEnterForeground];
|
|
}
|
|
|
|
- (void)applicationWillResignActive
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[[SCManagedCapturePreviewLayerController sharedInstance] applicationWillResignActive];
|
|
[_captureResource.queuePerformer perform:^{
|
|
[self _pauseCaptureSessionKVOCheck];
|
|
}];
|
|
}
|
|
|
|
- (void)applicationDidBecomeActive
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[[SCManagedCapturePreviewLayerController sharedInstance] applicationDidBecomeActive];
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
// Since we foreground it, do the running consistency check immediately.
|
|
// Reset number of retries for fixing status inconsistency
|
|
_captureResource.numRetriesFixInconsistencyWithCurrentSession = 0;
|
|
[self _runningConsistencyCheckAndFix];
|
|
if (!SC_AT_LEAST_IOS_10) {
|
|
// For OS version < iOS 10, try to fix AVCaptureSession after app becomes active.
|
|
_captureResource.numRetriesFixAVCaptureSessionWithCurrentSession = 0;
|
|
[self _fixAVSessionIfNecessary];
|
|
}
|
|
[self _resumeCaptureSessionKVOCheck];
|
|
if (_captureResource.status == SCManagedCapturerStatusRunning) {
|
|
// Reschedule the timer if we don't have it already
|
|
runOnMainThreadAsynchronously(^{
|
|
SCTraceStart();
|
|
[SCCaptureWorker setupLivenessConsistencyTimerIfForeground:_captureResource];
|
|
});
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)_runningConsistencyCheckAndFix
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
// Don't enforce consistency on simulator, as it'll constantly false-positive and restart session.
|
|
SC_GUARD_ELSE_RETURN(![SCDeviceName isSimulator]);
|
|
if (_captureResource.state.arSessionActive) {
|
|
[self _runningARSessionConsistencyCheckAndFix];
|
|
} else {
|
|
[self _runningAVCaptureSessionConsistencyCheckAndFix];
|
|
}
|
|
}
|
|
|
|
- (void)_runningARSessionConsistencyCheckAndFix
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssert([_captureResource.queuePerformer isCurrentPerformer], @"");
|
|
SCAssert(_captureResource.state.arSessionActive, @"");
|
|
if (@available(iOS 11.0, *)) {
|
|
// Occassionally the capture session will get into a weird "stuck" state.
|
|
// If this happens, we'll see that the timestamp for the most recent frame is behind the current time.
|
|
// Pausinging the session for a moment and restarting to attempt to jog it loose.
|
|
NSTimeInterval timeSinceLastFrame = CACurrentMediaTime() - _captureResource.arSession.currentFrame.timestamp;
|
|
BOOL reset = NO;
|
|
if (_captureResource.arSession.currentFrame.camera.trackingStateReason == ARTrackingStateReasonInitializing) {
|
|
if (timeSinceLastFrame > kSCManagedCapturerFixInconsistencyARSessionHungInitThreshold) {
|
|
SCLogCapturerInfo(@"*** Found inconsistency for ARSession timestamp (possible hung init), fix now ***");
|
|
reset = YES;
|
|
}
|
|
} else if (timeSinceLastFrame > kSCManagedCapturerFixInconsistencyARSessionDelayThreshold) {
|
|
SCLogCapturerInfo(@"*** Found inconsistency for ARSession timestamp (init complete), fix now ***");
|
|
reset = YES;
|
|
}
|
|
if (reset) {
|
|
[SCCaptureWorker turnARSessionOff:_captureResource];
|
|
[SCCaptureWorker turnARSessionOn:_captureResource];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)_runningAVCaptureSessionConsistencyCheckAndFix
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssert([_captureResource.queuePerformer isCurrentPerformer], @"");
|
|
SCAssert(!_captureResource.state.arSessionActive, @"");
|
|
[[SCLogger sharedInstance] logStepToEvent:@"CAMERA_OPEN_WITH_FIX_INCONSISTENCY"
|
|
uniqueId:@""
|
|
stepName:@"startConsistencyCheckAndFix"];
|
|
// If the video preview layer's hidden status is out of sync with the
|
|
// session's running status,
|
|
// fix that now. Also, we don't care that much if the status is not running.
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[self _fixNonMetalSessionPreviewInconsistency];
|
|
}
|
|
// Skip the liveness consistency check if we are in background
|
|
if (_captureResource.appInBackground) {
|
|
SCLogCapturerInfo(@"*** Skipped liveness consistency check, as we are in the background ***");
|
|
return;
|
|
}
|
|
if (_captureResource.status == SCManagedCapturerStatusRunning && !_captureResource.managedSession.isRunning) {
|
|
SCGhostToSnappableSignalCameraFixInconsistency();
|
|
SCLogCapturerInfo(@"*** Found status inconsistency for running, fix now ***");
|
|
_captureResource.numRetriesFixInconsistencyWithCurrentSession++;
|
|
if (_captureResource.numRetriesFixInconsistencyWithCurrentSession <=
|
|
kSCManagedCapturerFixInconsistencyMaxRetriesWithCurrentSession) {
|
|
SCTraceStartSection("Fix non-running session")
|
|
{
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[CATransaction begin];
|
|
[CATransaction setDisableActions:YES];
|
|
[_captureResource.managedSession startRunning];
|
|
[SCCaptureWorker setupVideoPreviewLayer:_captureResource];
|
|
[CATransaction commit];
|
|
} else {
|
|
[_captureResource.managedSession startRunning];
|
|
}
|
|
}
|
|
SCTraceEndSection();
|
|
} else {
|
|
SCTraceStartSection("Create new capturer session")
|
|
{
|
|
// start running with new capture session if the inconsistency fixing not succeeds
|
|
// after kSCManagedCapturerFixInconsistencyMaxRetriesWithCurrentSession retries
|
|
SCLogCapturerInfo(@"*** Recreate and run new capture session to fix the inconsistency ***");
|
|
[self _startRunningWithNewCaptureSession];
|
|
}
|
|
SCTraceEndSection();
|
|
}
|
|
BOOL sessionIsRunning = _captureResource.managedSession.isRunning;
|
|
if (sessionIsRunning && !SCDeviceSupportsMetal()) {
|
|
// If it is fixed, we signal received the first frame.
|
|
SCGhostToSnappableSignalDidReceiveFirstPreviewFrame();
|
|
runOnMainThreadAsynchronously(^{
|
|
// To approximate this did render timer, it is not accurate.
|
|
SCGhostToSnappableSignalDidRenderFirstPreviewFrame(CACurrentMediaTime());
|
|
});
|
|
}
|
|
SCLogCapturerInfo(@"*** Applied inconsistency fix, running state : %@ ***", sessionIsRunning ? @"YES" : @"NO");
|
|
if (_captureResource.managedSession.isRunning) {
|
|
[[SCLogger sharedInstance] logStepToEvent:@"CAMERA_OPEN_WITH_FIX_INCONSISTENCY"
|
|
uniqueId:@""
|
|
stepName:@"finishConsistencyCheckAndFix"];
|
|
[[SCLogger sharedInstance]
|
|
logTimedEventEnd:@"CAMERA_OPEN_WITH_FIX_INCONSISTENCY"
|
|
uniqueId:@""
|
|
parameters:@{
|
|
@"count" : @(_captureResource.numRetriesFixInconsistencyWithCurrentSession)
|
|
}];
|
|
}
|
|
} else {
|
|
[[SCLogger sharedInstance] cancelLogTimedEvent:@"CAMERA_OPEN_WITH_FIX_INCONSISTENCY" uniqueId:@""];
|
|
// Reset number of retries for fixing status inconsistency
|
|
_captureResource.numRetriesFixInconsistencyWithCurrentSession = 0;
|
|
}
|
|
|
|
[_captureResource.blackCameraDetector sessionDidChangeIsRunning:_captureResource.managedSession.isRunning];
|
|
}
|
|
|
|
- (void)mediaServicesWereReset
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[self mediaServicesWereLost];
|
|
[_captureResource.queuePerformer perform:^{
|
|
/* If the current state requires the ARSession, restart it.
|
|
Explicitly flip the arSessionActive flag so that `turnSessionOn` thinks it can reset itself.
|
|
*/
|
|
if (_captureResource.state.arSessionActive) {
|
|
_captureResource.state = [[[SCManagedCapturerStateBuilder withManagedCapturerState:_captureResource.state]
|
|
setArSessionActive:NO] build];
|
|
[SCCaptureWorker turnARSessionOn:_captureResource];
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)mediaServicesWereLost
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
if (!_captureResource.state.arSessionActive && !_captureResource.managedSession.isRunning) {
|
|
/*
|
|
If the session is running we will trigger
|
|
_sessionRuntimeError: so nothing else is
|
|
needed here.
|
|
*/
|
|
[_captureResource.videoCapturer.outputURL reloadAssetKeys];
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)_livenessConsistency:(NSTimer *)timer
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssertMainThread();
|
|
// We can directly check the application state because this timer is scheduled
|
|
// on the main thread.
|
|
if ([UIApplication sharedApplication].applicationState == UIApplicationStateActive) {
|
|
[_captureResource.queuePerformer perform:^{
|
|
[self _runningConsistencyCheckAndFix];
|
|
}];
|
|
}
|
|
}
|
|
|
|
- (void)_sessionRuntimeError:(NSNotification *)notification
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
NSError *sessionError = notification.userInfo[AVCaptureSessionErrorKey];
|
|
SCLogCapturerError(@"Encountered runtime error for capture session %@", sessionError);
|
|
|
|
NSString *errorString =
|
|
[sessionError.description stringByReplacingOccurrencesOfString:@" " withString:@"_"].uppercaseString
|
|
?: @"UNKNOWN_ERROR";
|
|
[[SCUserTraceLogger shared]
|
|
logUserTraceEvent:[NSString sc_stringWithFormat:@"AVCAPTURESESSION_RUNTIME_ERROR_%@", errorString]];
|
|
|
|
if (sessionError.code == AVErrorMediaServicesWereReset) {
|
|
// If it is a AVErrorMediaServicesWereReset error, we can just call startRunning, it is much light weighted
|
|
[_captureResource.queuePerformer perform:^{
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[CATransaction begin];
|
|
[CATransaction setDisableActions:YES];
|
|
[_captureResource.managedSession startRunning];
|
|
[SCCaptureWorker setupVideoPreviewLayer:_captureResource];
|
|
[CATransaction commit];
|
|
} else {
|
|
[_captureResource.managedSession startRunning];
|
|
}
|
|
}];
|
|
} else {
|
|
if (_captureResource.isRecreateSessionFixScheduled) {
|
|
SCLogCoreCameraInfo(@"Fixing session runtime error is scheduled, skip");
|
|
return;
|
|
}
|
|
|
|
_captureResource.isRecreateSessionFixScheduled = YES;
|
|
NSTimeInterval delay = 0;
|
|
NSTimeInterval timeNow = [NSDate timeIntervalSinceReferenceDate];
|
|
if (timeNow - _captureResource.lastSessionRuntimeErrorTime < kMinFixSessionRuntimeErrorInterval) {
|
|
SCLogCoreCameraInfo(@"Fixing runtime error session in less than %f, delay",
|
|
kMinFixSessionRuntimeErrorInterval);
|
|
delay = kMinFixSessionRuntimeErrorInterval;
|
|
}
|
|
_captureResource.lastSessionRuntimeErrorTime = timeNow;
|
|
[_captureResource.queuePerformer perform:^{
|
|
SCTraceStart();
|
|
// Occasionaly _captureResource.avSession will throw out an error when shutting down. If this happens while
|
|
// ARKit is starting up,
|
|
// _startRunningWithNewCaptureSession will throw a wrench in ARSession startup and freeze the image.
|
|
SC_GUARD_ELSE_RETURN(!_captureResource.state.arSessionActive);
|
|
// Need to reset the flag before _startRunningWithNewCaptureSession
|
|
_captureResource.isRecreateSessionFixScheduled = NO;
|
|
[self _startRunningWithNewCaptureSession];
|
|
[self _fixAVSessionIfNecessary];
|
|
}
|
|
after:delay];
|
|
}
|
|
|
|
[[SCLogger sharedInstance] logUnsampledEvent:kSCCameraMetricsRuntimeError
|
|
parameters:@{
|
|
@"error" : sessionError == nil ? @"Unknown error" : sessionError.description,
|
|
}
|
|
secretParameters:nil
|
|
metrics:nil];
|
|
}
|
|
|
|
- (void)_startRunningWithNewCaptureSessionIfNecessary
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
if (_captureResource.isRecreateSessionFixScheduled) {
|
|
SCLogCapturerInfo(@"Session recreation is scheduled, return");
|
|
return;
|
|
}
|
|
_captureResource.isRecreateSessionFixScheduled = YES;
|
|
[_captureResource.queuePerformer perform:^{
|
|
// Need to reset the flag before _startRunningWithNewCaptureSession
|
|
_captureResource.isRecreateSessionFixScheduled = NO;
|
|
[self _startRunningWithNewCaptureSession];
|
|
}];
|
|
}
|
|
|
|
- (void)_startRunningWithNewCaptureSession
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssert([_captureResource.queuePerformer isCurrentPerformer], @"");
|
|
SCLogCapturerInfo(@"Start running with new capture session. isRecording:%d isStreaming:%d status:%lu",
|
|
_captureResource.videoRecording, _captureResource.videoDataSource.isStreaming,
|
|
(unsigned long)_captureResource.status);
|
|
|
|
// Mark the start of recreating session
|
|
[_captureResource.blackCameraDetector sessionWillRecreate];
|
|
|
|
// Light weight fix gating
|
|
BOOL lightWeightFix = SCCameraTweaksSessionLightWeightFixEnabled() || SCCameraTweaksBlackCameraRecoveryEnabled();
|
|
|
|
if (!lightWeightFix) {
|
|
[_captureResource.deviceCapacityAnalyzer removeListener:_captureResource.stillImageCapturer];
|
|
[self removeListener:_captureResource.stillImageCapturer];
|
|
[_captureResource.videoDataSource removeListener:_captureResource.lensProcessingCore.capturerListener];
|
|
|
|
[_captureResource.videoDataSource removeListener:_captureResource.deviceCapacityAnalyzer];
|
|
[_captureResource.videoDataSource removeListener:_captureResource.stillImageCapturer];
|
|
|
|
if (SCIsMasterBuild()) {
|
|
[_captureResource.videoDataSource removeListener:_captureResource.videoStreamReporter];
|
|
}
|
|
[_captureResource.videoDataSource removeListener:_captureResource.videoScanner];
|
|
[_captureResource.videoDataSource removeListener:_captureResource.videoCapturer];
|
|
[_captureResource.videoDataSource
|
|
removeListener:_captureResource.blackCameraDetector.blackCameraNoOutputDetector];
|
|
}
|
|
|
|
[_captureResource.videoCapturer.outputURL reloadAssetKeys];
|
|
|
|
BOOL isStreaming = _captureResource.videoDataSource.isStreaming;
|
|
if (_captureResource.videoRecording) {
|
|
// Stop video recording prematurely
|
|
[self stopRecordingAsynchronouslyWithContext:SCCapturerContext];
|
|
NSError *error = [NSError
|
|
errorWithDomain:kSCManagedCapturerErrorDomain
|
|
description:
|
|
[NSString
|
|
sc_stringWithFormat:@"Interrupt video recording to start new session. %@",
|
|
@{
|
|
@"isAVSessionRunning" : @(_captureResource.managedSession.isRunning),
|
|
@"numRetriesFixInconsistency" :
|
|
@(_captureResource.numRetriesFixInconsistencyWithCurrentSession),
|
|
@"numRetriesFixAVCaptureSession" :
|
|
@(_captureResource.numRetriesFixAVCaptureSessionWithCurrentSession),
|
|
@"lastSessionRuntimeErrorTime" :
|
|
@(_captureResource.lastSessionRuntimeErrorTime),
|
|
}]
|
|
code:-1];
|
|
[[SCLogger sharedInstance] logUnsampledEvent:kSCCameraMetricsVideoRecordingInterrupted
|
|
parameters:@{
|
|
@"error" : error.description
|
|
}
|
|
secretParameters:nil
|
|
metrics:nil];
|
|
}
|
|
@try {
|
|
if (@available(iOS 11.0, *)) {
|
|
[_captureResource.arSession pause];
|
|
if (!lightWeightFix) {
|
|
[_captureResource.videoDataSource removeListener:_captureResource.arImageCapturer];
|
|
}
|
|
}
|
|
[_captureResource.managedSession stopRunning];
|
|
[_captureResource.device removeDeviceAsInput:_captureResource.managedSession.avSession];
|
|
} @catch (NSException *exception) {
|
|
SCLogCapturerError(@"Encountered Exception %@", exception);
|
|
} @finally {
|
|
// Nil out device inputs from both devices
|
|
[[SCManagedCaptureDevice front] resetDeviceAsInput];
|
|
[[SCManagedCaptureDevice back] resetDeviceAsInput];
|
|
}
|
|
|
|
if (!SCDeviceSupportsMetal()) {
|
|
// Redo the video preview to mitigate https://ph.sc-corp.net/T42584
|
|
[SCCaptureWorker redoVideoPreviewLayer:_captureResource];
|
|
}
|
|
|
|
#if !TARGET_IPHONE_SIMULATOR
|
|
if (@available(iOS 11.0, *)) {
|
|
_captureResource.arSession = [[ARSession alloc] init];
|
|
_captureResource.arImageCapturer =
|
|
[_captureResource.arImageCaptureProvider arImageCapturerWith:_captureResource.queuePerformer
|
|
lensProcessingCore:_captureResource.lensProcessingCore];
|
|
}
|
|
[self _resetAVCaptureSession];
|
|
#endif
|
|
[_captureResource.managedSession.avSession setAutomaticallyConfiguresApplicationAudioSession:NO];
|
|
[_captureResource.device setDeviceAsInput:_captureResource.managedSession.avSession];
|
|
|
|
if (_captureResource.fileInputDecider.shouldProcessFileInput) {
|
|
// Keep the same logic, always create new VideoDataSource
|
|
[self _setupNewVideoFileDataSource];
|
|
} else {
|
|
if (!lightWeightFix) {
|
|
[self _setupNewVideoDataSource];
|
|
} else {
|
|
[self _setupVideoDataSourceWithNewSession];
|
|
}
|
|
}
|
|
|
|
if (_captureResource.status == SCManagedCapturerStatusRunning) {
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[CATransaction begin];
|
|
[CATransaction setDisableActions:YES];
|
|
// Set the session to be the new session before start running.
|
|
_captureResource.videoPreviewLayer.session = _captureResource.managedSession.avSession;
|
|
if (!_captureResource.appInBackground) {
|
|
[_captureResource.managedSession startRunning];
|
|
}
|
|
[SCCaptureWorker setupVideoPreviewLayer:_captureResource];
|
|
[CATransaction commit];
|
|
} else {
|
|
if (!_captureResource.appInBackground) {
|
|
[_captureResource.managedSession startRunning];
|
|
}
|
|
}
|
|
}
|
|
// Since this start and stop happens in one block, we don't have to worry
|
|
// about streamingSequence issues
|
|
if (isStreaming) {
|
|
[_captureResource.videoDataSource startStreaming];
|
|
}
|
|
SCManagedCapturerState *state = [_captureResource.state copy];
|
|
AVCaptureVideoPreviewLayer *videoPreviewLayer = _captureResource.videoPreviewLayer;
|
|
runOnMainThreadAsynchronously(^{
|
|
[_captureResource.announcer managedCapturer:self didResetFromRuntimeError:state];
|
|
if (!SCDeviceSupportsMetal()) {
|
|
[_captureResource.announcer managedCapturer:self didChangeVideoPreviewLayer:videoPreviewLayer];
|
|
}
|
|
});
|
|
|
|
// Mark the end of recreating session
|
|
[_captureResource.blackCameraDetector sessionDidRecreate];
|
|
}
|
|
|
|
/**
|
|
* Heavy-weight session fixing approach: recreating everything
|
|
*/
|
|
- (void)_setupNewVideoDataSource
|
|
{
|
|
if (@available(iOS 11.0, *)) {
|
|
_captureResource.videoDataSource =
|
|
[[SCManagedVideoStreamer alloc] initWithSession:_captureResource.managedSession.avSession
|
|
arSession:_captureResource.arSession
|
|
devicePosition:_captureResource.state.devicePosition];
|
|
[_captureResource.videoDataSource addListener:_captureResource.arImageCapturer];
|
|
if (_captureResource.state.isPortraitModeActive) {
|
|
[_captureResource.videoDataSource setDepthCaptureEnabled:YES];
|
|
|
|
SCProcessingPipelineBuilder *processingPipelineBuilder = [[SCProcessingPipelineBuilder alloc] init];
|
|
processingPipelineBuilder.portraitModeEnabled = YES;
|
|
SCProcessingPipeline *pipeline = [processingPipelineBuilder build];
|
|
[_captureResource.videoDataSource addProcessingPipeline:pipeline];
|
|
}
|
|
} else {
|
|
_captureResource.videoDataSource =
|
|
[[SCManagedVideoStreamer alloc] initWithSession:_captureResource.managedSession.avSession
|
|
devicePosition:_captureResource.state.devicePosition];
|
|
}
|
|
|
|
[self _setupVideoDataSourceListeners];
|
|
}
|
|
|
|
- (void)_setupNewVideoFileDataSource
|
|
{
|
|
_captureResource.videoDataSource =
|
|
[[SCManagedVideoFileStreamer alloc] initWithPlaybackForURL:_captureResource.fileInputDecider.fileURL];
|
|
[_captureResource.lensProcessingCore setLensesActive:YES
|
|
videoOrientation:_captureResource.videoDataSource.videoOrientation
|
|
filterFactory:nil];
|
|
runOnMainThreadAsynchronously(^{
|
|
[_captureResource.videoPreviewGLViewManager prepareViewIfNecessary];
|
|
});
|
|
[self _setupVideoDataSourceListeners];
|
|
}
|
|
|
|
/**
|
|
* Light-weight session fixing approach: recreating AVCaptureSession / AVCaptureOutput, and bind it to the new session
|
|
*/
|
|
- (void)_setupVideoDataSourceWithNewSession
|
|
{
|
|
if (@available(iOS 11.0, *)) {
|
|
SCManagedVideoStreamer *streamer = (SCManagedVideoStreamer *)_captureResource.videoDataSource;
|
|
[streamer setupWithSession:_captureResource.managedSession.avSession
|
|
devicePosition:_captureResource.state.devicePosition];
|
|
[streamer setupWithARSession:_captureResource.arSession];
|
|
} else {
|
|
SCManagedVideoStreamer *streamer = (SCManagedVideoStreamer *)_captureResource.videoDataSource;
|
|
[streamer setupWithSession:_captureResource.managedSession.avSession
|
|
devicePosition:_captureResource.state.devicePosition];
|
|
}
|
|
[_captureResource.stillImageCapturer setupWithSession:_captureResource.managedSession.avSession];
|
|
}
|
|
|
|
- (void)_setupVideoDataSourceListeners
|
|
{
|
|
if (_captureResource.videoFrameSampler) {
|
|
[_captureResource.announcer addListener:_captureResource.videoFrameSampler];
|
|
}
|
|
|
|
[_captureResource.videoDataSource addSampleBufferDisplayController:_captureResource.sampleBufferDisplayController];
|
|
[_captureResource.videoDataSource addListener:_captureResource.lensProcessingCore.capturerListener];
|
|
[_captureResource.videoDataSource addListener:_captureResource.deviceCapacityAnalyzer];
|
|
if (SCIsMasterBuild()) {
|
|
[_captureResource.videoDataSource addListener:_captureResource.videoStreamReporter];
|
|
}
|
|
[_captureResource.videoDataSource addListener:_captureResource.videoScanner];
|
|
[_captureResource.videoDataSource addListener:_captureResource.blackCameraDetector.blackCameraNoOutputDetector];
|
|
_captureResource.stillImageCapturer = [SCManagedStillImageCapturer capturerWithCaptureResource:_captureResource];
|
|
[_captureResource.deviceCapacityAnalyzer addListener:_captureResource.stillImageCapturer];
|
|
[_captureResource.videoDataSource addListener:_captureResource.stillImageCapturer];
|
|
|
|
[self addListener:_captureResource.stillImageCapturer];
|
|
}
|
|
|
|
- (void)_resetAVCaptureSession
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssert([_captureResource.queuePerformer isCurrentPerformer], @"");
|
|
_captureResource.numRetriesFixAVCaptureSessionWithCurrentSession = 0;
|
|
// lazily initialize _captureResource.kvoController on background thread
|
|
if (!_captureResource.kvoController) {
|
|
_captureResource.kvoController = [[FBKVOController alloc] initWithObserver:self];
|
|
}
|
|
[_captureResource.kvoController unobserve:_captureResource.managedSession.avSession];
|
|
_captureResource.managedSession =
|
|
[[SCManagedCaptureSession alloc] initWithBlackCameraDetector:_captureResource.blackCameraDetector];
|
|
[_captureResource.kvoController observe:_captureResource.managedSession.avSession
|
|
keyPath:@keypath(_captureResource.managedSession.avSession, running)
|
|
options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
|
|
action:_captureResource.handleAVSessionStatusChange];
|
|
}
|
|
|
|
- (void)_pauseCaptureSessionKVOCheck
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssert([_captureResource.queuePerformer isCurrentPerformer], @"");
|
|
[_captureResource.kvoController unobserve:_captureResource.managedSession.avSession];
|
|
}
|
|
|
|
- (void)_resumeCaptureSessionKVOCheck
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
SCAssert([_captureResource.queuePerformer isCurrentPerformer], @"");
|
|
[_captureResource.kvoController observe:_captureResource.managedSession.avSession
|
|
keyPath:@keypath(_captureResource.managedSession.avSession, running)
|
|
options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
|
|
action:_captureResource.handleAVSessionStatusChange];
|
|
}
|
|
|
|
- (id<SCManagedVideoDataSource>)currentVideoDataSource
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
return _captureResource.videoDataSource;
|
|
}
|
|
|
|
- (void)checkRestrictedCamera:(void (^)(BOOL, BOOL, AVAuthorizationStatus))callback
|
|
{
|
|
SCTraceODPCompatibleStart(2);
|
|
[_captureResource.queuePerformer perform:^{
|
|
// Front and back should be available if user has no restriction on camera.
|
|
BOOL front = [[SCManagedCaptureDevice front] isAvailable];
|
|
BOOL back = [[SCManagedCaptureDevice back] isAvailable];
|
|
AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo];
|
|
runOnMainThreadAsynchronously(^{
|
|
callback(front, back, status);
|
|
});
|
|
}];
|
|
}
|
|
|
|
- (SCSnapCreationTriggers *)snapCreationTriggers
|
|
{
|
|
return _captureResource.snapCreationTriggers;
|
|
}
|
|
|
|
- (void)setBlackCameraDetector:(SCBlackCameraDetector *)blackCameraDetector
|
|
deviceMotionProvider:(id<SCDeviceMotionProvider>)deviceMotionProvider
|
|
fileInputDecider:(id<SCFileInputDecider>)fileInputDecider
|
|
arImageCaptureProvider:(id<SCManagedCapturerARImageCaptureProvider>)arImageCaptureProvider
|
|
glviewManager:(id<SCManagedCapturerGLViewManagerAPI>)glViewManager
|
|
lensAPIProvider:(id<SCManagedCapturerLensAPIProvider>)lensAPIProvider
|
|
lsaComponentTracker:(id<SCManagedCapturerLSAComponentTrackerAPI>)lsaComponentTracker
|
|
managedCapturerPreviewLayerControllerDelegate:
|
|
(id<SCManagedCapturePreviewLayerControllerDelegate>)previewLayerControllerDelegate
|
|
{
|
|
_captureResource.blackCameraDetector = blackCameraDetector;
|
|
_captureResource.deviceMotionProvider = deviceMotionProvider;
|
|
_captureResource.fileInputDecider = fileInputDecider;
|
|
_captureResource.arImageCaptureProvider = arImageCaptureProvider;
|
|
_captureResource.videoPreviewGLViewManager = glViewManager;
|
|
[_captureResource.videoPreviewGLViewManager configureWithCaptureResource:_captureResource];
|
|
_captureResource.lensAPIProvider = lensAPIProvider;
|
|
_captureResource.lsaTrackingComponentHandler = lsaComponentTracker;
|
|
[_captureResource.lsaTrackingComponentHandler configureWithCaptureResource:_captureResource];
|
|
_captureResource.previewLayerControllerDelegate = previewLayerControllerDelegate;
|
|
[SCManagedCapturePreviewLayerController sharedInstance].delegate = previewLayerControllerDelegate;
|
|
}
|
|
|
|
@end
|