1108 lines
53 KiB
Objective-C
1108 lines
53 KiB
Objective-C
//
|
|
// SCManagedVideoCapturer.m
|
|
// Snapchat
|
|
//
|
|
// Created by Liu Liu on 5/1/15.
|
|
// Copyright (c) 2015 Liu Liu. All rights reserved.
|
|
//
|
|
|
|
#import "SCManagedVideoCapturer.h"
|
|
|
|
#import "NSURL+Asset.h"
|
|
#import "SCAudioCaptureSession.h"
|
|
#import "SCCameraTweaks.h"
|
|
#import "SCCapturerBufferedVideoWriter.h"
|
|
#import "SCCoreCameraLogger.h"
|
|
#import "SCLogger+Camera.h"
|
|
#import "SCManagedCapturer.h"
|
|
#import "SCManagedFrameHealthChecker.h"
|
|
#import "SCManagedVideoCapturerLogger.h"
|
|
#import "SCManagedVideoCapturerTimeObserver.h"
|
|
|
|
#import <SCAudio/SCAudioSession.h>
|
|
#import <SCAudio/SCMutableAudioSession.h>
|
|
#import <SCBase/SCMacros.h>
|
|
#import <SCCameraFoundation/SCManagedAudioDataSourceListenerAnnouncer.h>
|
|
#import <SCFoundation/SCAssertWrapper.h>
|
|
#import <SCFoundation/SCCoreGraphicsUtils.h>
|
|
#import <SCFoundation/SCDeviceName.h>
|
|
#import <SCFoundation/SCFuture.h>
|
|
#import <SCFoundation/SCLog.h>
|
|
#import <SCFoundation/SCQueuePerformer.h>
|
|
#import <SCFoundation/SCTrace.h>
|
|
#import <SCFoundation/UIImage+CVPixelBufferRef.h>
|
|
#import <SCImageProcess/SCSnapVideoFrameRawData.h>
|
|
#import <SCImageProcess/SCVideoFrameRawDataCollector.h>
|
|
#import <SCImageProcess/SnapVideoMetadata.h>
|
|
#import <SCLogger/SCCameraMetrics.h>
|
|
#import <SCLogger/SCLogger+Performance.h>
|
|
#import <SCLogger/SCLogger.h>
|
|
|
|
#import <SCAudioScope/SCAudioSessionExperimentAdapter.h>
|
|
|
|
@import CoreMedia;
|
|
@import ImageIO;
|
|
|
|
static NSString *const kSCAudioCaptureAudioSessionLabel = @"CAMERA";
|
|
|
|
// wild card audio queue error code
|
|
static NSInteger const kSCAudioQueueErrorWildCard = -50;
|
|
// kAudioHardwareIllegalOperationError, it means hardware failure
|
|
static NSInteger const kSCAudioQueueErrorHardware = 1852797029;
|
|
|
|
typedef NS_ENUM(NSUInteger, SCManagedVideoCapturerStatus) {
|
|
SCManagedVideoCapturerStatusUnknown,
|
|
SCManagedVideoCapturerStatusIdle,
|
|
SCManagedVideoCapturerStatusPrepareToRecord,
|
|
SCManagedVideoCapturerStatusReadyForRecording,
|
|
SCManagedVideoCapturerStatusRecording,
|
|
SCManagedVideoCapturerStatusError,
|
|
};
|
|
|
|
#define SCLogVideoCapturerInfo(fmt, ...) SCLogCoreCameraInfo(@"[SCManagedVideoCapturer] " fmt, ##__VA_ARGS__)
|
|
#define SCLogVideoCapturerWarning(fmt, ...) SCLogCoreCameraWarning(@"[SCManagedVideoCapturer] " fmt, ##__VA_ARGS__)
|
|
#define SCLogVideoCapturerError(fmt, ...) SCLogCoreCameraError(@"[SCManagedVideoCapturer] " fmt, ##__VA_ARGS__)
|
|
|
|
@interface SCManagedVideoCapturer () <SCAudioCaptureSessionDelegate>
|
|
// This value has to be atomic because it is read on a different thread (write
|
|
// on output queue, as always)
|
|
@property (atomic, assign, readwrite) SCManagedVideoCapturerStatus status;
|
|
|
|
@property (nonatomic, assign) CMTime firstWrittenAudioBufferDelay;
|
|
|
|
@end
|
|
|
|
static char *const kSCManagedVideoCapturerQueueLabel = "com.snapchat.managed-video-capturer-queue";
|
|
static char *const kSCManagedVideoCapturerPromiseQueueLabel = "com.snapchat.video-capture-promise";
|
|
|
|
static NSString *const kSCManagedVideoCapturerErrorDomain = @"kSCManagedVideoCapturerErrorDomain";
|
|
|
|
static NSInteger const kSCManagedVideoCapturerCannotAddAudioVideoInput = 1001;
|
|
static NSInteger const kSCManagedVideoCapturerEmptyFrame = 1002;
|
|
static NSInteger const kSCManagedVideoCapturerStopBeforeStart = 1003;
|
|
static NSInteger const kSCManagedVideoCapturerStopWithoutStart = 1004;
|
|
static NSInteger const kSCManagedVideoCapturerZeroVideoSize = -111;
|
|
|
|
static NSUInteger const kSCVideoContentComplexitySamplingRate = 90;
|
|
|
|
// This is the maximum time we will wait for the Recording Capturer pipeline to drain
|
|
// When video stabilization is turned on the extra frame delay is around 20 frames.
|
|
// @30 fps this is 0.66 seconds
|
|
static NSTimeInterval const kSCManagedVideoCapturerStopRecordingDeadline = 1.0;
|
|
|
|
static const char *SCPlaceholderImageGenerationQueueLabel = "com.snapchat.video-capturer-placeholder-queue";
|
|
|
|
static const char *SCVideoRecordingPreparationQueueLabel = "com.snapchat.video-recording-preparation-queue";
|
|
|
|
static dispatch_queue_t SCPlaceholderImageGenerationQueue(void)
|
|
{
|
|
static dispatch_queue_t queue;
|
|
static dispatch_once_t onceToken;
|
|
dispatch_once(&onceToken, ^{
|
|
queue = dispatch_queue_create(SCPlaceholderImageGenerationQueueLabel, DISPATCH_QUEUE_SERIAL);
|
|
});
|
|
return queue;
|
|
}
|
|
|
|
@interface SCManagedVideoCapturer () <SCCapturerBufferedVideoWriterDelegate>
|
|
|
|
@end
|
|
|
|
@implementation SCManagedVideoCapturer {
|
|
NSTimeInterval _maxDuration;
|
|
NSTimeInterval _recordStartTime;
|
|
|
|
SCCapturerBufferedVideoWriter *_videoWriter;
|
|
|
|
BOOL _hasWritten;
|
|
SCQueuePerformer *_performer;
|
|
SCQueuePerformer *_videoPreparationPerformer;
|
|
SCAudioCaptureSession *_audioCaptureSession;
|
|
NSError *_lastError;
|
|
UIImage *_placeholderImage;
|
|
|
|
// For logging purpose
|
|
BOOL _isVideoSnap;
|
|
NSDictionary *_videoOutputSettings;
|
|
|
|
// The following value is used to control the encoder shutdown following a stop recording message.
|
|
// When a shutdown is requested this value will be the timestamp of the last captured frame.
|
|
CFTimeInterval _stopTime;
|
|
NSInteger _stopSession;
|
|
SCAudioConfigurationToken *_preparedAudioConfiguration;
|
|
SCAudioConfigurationToken *_audioConfiguration;
|
|
|
|
dispatch_semaphore_t _startRecordingSemaphore;
|
|
|
|
// For store the raw frame datas
|
|
NSInteger _rawDataFrameNum;
|
|
NSURL *_rawDataURL;
|
|
SCVideoFrameRawDataCollector *_videoFrameRawDataCollector;
|
|
|
|
CMTime _startSessionTime;
|
|
// Indicates how actual processing time of first frame. Also used for camera timer animation start offset.
|
|
NSTimeInterval _startSessionRealTime;
|
|
CMTime _endSessionTime;
|
|
sc_managed_capturer_recording_session_t _sessionId;
|
|
|
|
SCManagedVideoCapturerTimeObserver *_timeObserver;
|
|
SCManagedVideoCapturerLogger *_capturerLogger;
|
|
|
|
CGSize _outputSize;
|
|
BOOL _isFrontFacingCamera;
|
|
SCPromise<id<SCManagedRecordedVideo>> *_recordedVideoPromise;
|
|
SCManagedAudioDataSourceListenerAnnouncer *_announcer;
|
|
|
|
NSString *_captureSessionID;
|
|
CIContext *_ciContext;
|
|
}
|
|
|
|
@synthesize performer = _performer;
|
|
|
|
- (instancetype)init
|
|
{
|
|
SCTraceStart();
|
|
return [self initWithQueuePerformer:[[SCQueuePerformer alloc] initWithLabel:kSCManagedVideoCapturerQueueLabel
|
|
qualityOfService:QOS_CLASS_USER_INTERACTIVE
|
|
queueType:DISPATCH_QUEUE_SERIAL
|
|
context:SCQueuePerformerContextCamera]];
|
|
}
|
|
|
|
- (instancetype)initWithQueuePerformer:(SCQueuePerformer *)queuePerformer
|
|
{
|
|
SCTraceStart();
|
|
self = [super init];
|
|
if (self) {
|
|
_performer = queuePerformer;
|
|
_audioCaptureSession = [[SCAudioCaptureSession alloc] init];
|
|
_audioCaptureSession.delegate = self;
|
|
_announcer = [SCManagedAudioDataSourceListenerAnnouncer new];
|
|
self.status = SCManagedVideoCapturerStatusIdle;
|
|
_capturerLogger = [[SCManagedVideoCapturerLogger alloc] init];
|
|
_startRecordingSemaphore = dispatch_semaphore_create(0);
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc
|
|
{
|
|
SCLogVideoCapturerInfo(@"SCVideoCaptureSessionInfo before dealloc: %@",
|
|
SCVideoCaptureSessionInfoGetDebugDescription(self.activeSession));
|
|
}
|
|
|
|
- (SCVideoCaptureSessionInfo)activeSession
|
|
{
|
|
return SCVideoCaptureSessionInfoMake(_startSessionTime, _endSessionTime, _sessionId);
|
|
}
|
|
|
|
- (CGSize)defaultSizeForDeviceFormat:(AVCaptureDeviceFormat *)format
|
|
{
|
|
SCTraceStart();
|
|
// if there is no device, and no format
|
|
if (format == nil) {
|
|
// hard code 720p
|
|
return CGSizeMake(kSCManagedCapturerDefaultVideoActiveFormatWidth,
|
|
kSCManagedCapturerDefaultVideoActiveFormatHeight);
|
|
}
|
|
CMVideoDimensions videoDimensions = CMVideoFormatDescriptionGetDimensions(format.formatDescription);
|
|
CGSize size = CGSizeMake(videoDimensions.width, videoDimensions.height);
|
|
if (videoDimensions.width > kSCManagedCapturerDefaultVideoActiveFormatWidth &&
|
|
videoDimensions.height > kSCManagedCapturerDefaultVideoActiveFormatHeight) {
|
|
CGFloat scaleFactor = MAX((kSCManagedCapturerDefaultVideoActiveFormatWidth / videoDimensions.width),
|
|
(kSCManagedCapturerDefaultVideoActiveFormatHeight / videoDimensions.height));
|
|
size = SCSizeMakeAlignTo(SCSizeApplyScale(size, scaleFactor), 2);
|
|
}
|
|
if ([SCDeviceName isIphoneX]) {
|
|
size = SCSizeApplyScale(size, kSCIPhoneXCapturedImageVideoCropRatio);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
- (CGSize)cropSize:(CGSize)size toAspectRatio:(CGFloat)aspectRatio
|
|
{
|
|
if (aspectRatio == kSCManagedCapturerAspectRatioUnspecified) {
|
|
return size;
|
|
}
|
|
// video input is always in landscape mode
|
|
aspectRatio = 1.0 / aspectRatio;
|
|
if (size.width > size.height * aspectRatio) {
|
|
size.width = size.height * aspectRatio;
|
|
} else {
|
|
size.height = size.width / aspectRatio;
|
|
}
|
|
return CGSizeMake(roundf(size.width / 2) * 2, roundf(size.height / 2) * 2);
|
|
}
|
|
|
|
- (SCManagedVideoCapturerOutputSettings *)defaultRecordingOutputSettingsWithDeviceFormat:
|
|
(AVCaptureDeviceFormat *)deviceFormat
|
|
{
|
|
SCTraceStart();
|
|
CGFloat aspectRatio = SCManagedCapturedImageAndVideoAspectRatio();
|
|
CGSize outputSize = [self defaultSizeForDeviceFormat:deviceFormat];
|
|
outputSize = [self cropSize:outputSize toAspectRatio:aspectRatio];
|
|
|
|
// [TODO](Chao): remove the dependency of SCManagedVideoCapturer on SnapVideoMetaData
|
|
NSInteger videoBitRate = [SnapVideoMetadata averageTranscodingBitRate:outputSize
|
|
isRecording:YES
|
|
highQuality:YES
|
|
duration:0
|
|
iFrameOnly:NO
|
|
originalVideoBitRate:0
|
|
overlayImageFileSizeBits:0
|
|
videoPlaybackRate:1
|
|
isLagunaVideo:NO
|
|
hasOverlayToBlend:NO
|
|
sourceType:SCSnapVideoFilterSourceTypeUndefined];
|
|
SCTraceSignal(@"Setup transcoding video bitrate");
|
|
[_capturerLogger logStartingStep:kSCCapturerStartingStepTranscodeingVideoBitrate];
|
|
|
|
SCManagedVideoCapturerOutputSettings *outputSettings =
|
|
[[SCManagedVideoCapturerOutputSettings alloc] initWithWidth:outputSize.width
|
|
height:outputSize.height
|
|
videoBitRate:videoBitRate
|
|
audioBitRate:64000.0
|
|
keyFrameInterval:15
|
|
outputType:SCManagedVideoCapturerOutputTypeVideoSnap];
|
|
|
|
return outputSettings;
|
|
}
|
|
|
|
- (SCQueuePerformer *)_getVideoPreparationPerformer
|
|
{
|
|
SCAssert([_performer isCurrentPerformer], @"must run on _performer");
|
|
if (!_videoPreparationPerformer) {
|
|
_videoPreparationPerformer = [[SCQueuePerformer alloc] initWithLabel:SCVideoRecordingPreparationQueueLabel
|
|
qualityOfService:QOS_CLASS_USER_INTERACTIVE
|
|
queueType:DISPATCH_QUEUE_SERIAL
|
|
context:SCQueuePerformerContextCamera];
|
|
}
|
|
return _videoPreparationPerformer;
|
|
}
|
|
|
|
- (void)prepareForRecordingWithAudioConfiguration:(SCAudioConfiguration *)configuration
|
|
{
|
|
SCTraceStart();
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
SCTraceStart();
|
|
self.status = SCManagedVideoCapturerStatusPrepareToRecord;
|
|
if (_audioConfiguration) {
|
|
[SCAudioSessionExperimentAdapter relinquishConfiguration:_audioConfiguration performer:nil completion:nil];
|
|
}
|
|
__block NSError *audioSessionError = nil;
|
|
_preparedAudioConfiguration = _audioConfiguration =
|
|
[SCAudioSessionExperimentAdapter configureWith:configuration
|
|
performer:[self _getVideoPreparationPerformer]
|
|
completion:^(NSError *error) {
|
|
audioSessionError = error;
|
|
if (self.status == SCManagedVideoCapturerStatusPrepareToRecord) {
|
|
dispatch_semaphore_signal(_startRecordingSemaphore);
|
|
}
|
|
}];
|
|
|
|
// Wait until preparation for recording is done
|
|
dispatch_semaphore_wait(_startRecordingSemaphore, DISPATCH_TIME_FOREVER);
|
|
[_delegate managedVideoCapturer:self
|
|
didGetError:audioSessionError
|
|
forType:SCManagedVideoCapturerInfoAudioSessionError
|
|
session:self.activeSession];
|
|
}];
|
|
}
|
|
|
|
- (SCVideoCaptureSessionInfo)startRecordingAsynchronouslyWithOutputSettings:
|
|
(SCManagedVideoCapturerOutputSettings *)outputSettings
|
|
audioConfiguration:(SCAudioConfiguration *)audioConfiguration
|
|
maxDuration:(NSTimeInterval)maxDuration
|
|
toURL:(NSURL *)URL
|
|
deviceFormat:(AVCaptureDeviceFormat *)deviceFormat
|
|
orientation:(AVCaptureVideoOrientation)videoOrientation
|
|
captureSessionID:(NSString *)captureSessionID
|
|
{
|
|
SCTraceStart();
|
|
_captureSessionID = [captureSessionID copy];
|
|
[_capturerLogger prepareForStartingLog];
|
|
|
|
[[SCLogger sharedInstance] logTimedEventStart:kSCCameraMetricsAudioDelay
|
|
uniqueId:_captureSessionID
|
|
isUniqueEvent:NO];
|
|
|
|
NSTimeInterval startTime = CACurrentMediaTime();
|
|
[[SCLogger sharedInstance] logPreCaptureOperationRequestedAt:startTime];
|
|
[[SCCoreCameraLogger sharedInstance] logCameraCreationDelaySplitPointPreCaptureOperationRequested];
|
|
_sessionId = arc4random();
|
|
|
|
// Set a invalid time so that we don't process videos when no frame available
|
|
_startSessionTime = kCMTimeInvalid;
|
|
_endSessionTime = kCMTimeInvalid;
|
|
_firstWrittenAudioBufferDelay = kCMTimeInvalid;
|
|
_audioQueueStarted = NO;
|
|
|
|
SCLogVideoCapturerInfo(@"SCVideoCaptureSessionInfo at start of recording: %@",
|
|
SCVideoCaptureSessionInfoGetDebugDescription(self.activeSession));
|
|
|
|
SCVideoCaptureSessionInfo sessionInfo = self.activeSession;
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
_maxDuration = maxDuration;
|
|
dispatch_block_t startRecordingBlock = ^{
|
|
_rawDataFrameNum = 0;
|
|
// Begin audio recording asynchronously, first, need to have correct audio session.
|
|
SCTraceStart();
|
|
SCLogVideoCapturerInfo(@"Dequeue begin recording with audio session change delay: %lf seconds",
|
|
CACurrentMediaTime() - startTime);
|
|
if (self.status != SCManagedVideoCapturerStatusReadyForRecording) {
|
|
SCLogVideoCapturerInfo(@"SCManagedVideoCapturer status: %lu", (unsigned long)self.status);
|
|
// We may already released, but this should be OK.
|
|
[SCAudioSessionExperimentAdapter relinquishConfiguration:_preparedAudioConfiguration
|
|
performer:nil
|
|
completion:nil];
|
|
return;
|
|
}
|
|
if (_preparedAudioConfiguration != _audioConfiguration) {
|
|
SCLogVideoCapturerInfo(
|
|
@"SCManagedVideoCapturer has mismatched audio session token, prepared: %@, have: %@",
|
|
_preparedAudioConfiguration.token, _audioConfiguration.token);
|
|
// We are on a different audio session token already.
|
|
[SCAudioSessionExperimentAdapter relinquishConfiguration:_preparedAudioConfiguration
|
|
performer:nil
|
|
completion:nil];
|
|
return;
|
|
}
|
|
|
|
// Divide start recording workflow into different steps to log delay time.
|
|
// And checkpoint is the end of a step
|
|
[_capturerLogger logStartingStep:kSCCapturerStartingStepAudioSession];
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraMetricsAudioDelay
|
|
uniqueId:_captureSessionID
|
|
stepName:@"audio_session_start_end"];
|
|
|
|
SCLogVideoCapturerInfo(@"Prepare to begin recording");
|
|
_lastError = nil;
|
|
|
|
// initialize stopTime to a number much larger than the CACurrentMediaTime() which is the time from Jan 1,
|
|
// 2001
|
|
_stopTime = kCFAbsoluteTimeIntervalSince1970;
|
|
|
|
// Restart everything
|
|
_hasWritten = NO;
|
|
|
|
SCManagedVideoCapturerOutputSettings *finalOutputSettings =
|
|
outputSettings ? outputSettings : [self defaultRecordingOutputSettingsWithDeviceFormat:deviceFormat];
|
|
_isVideoSnap = finalOutputSettings.outputType == SCManagedVideoCapturerOutputTypeVideoSnap;
|
|
_outputSize = CGSizeMake(finalOutputSettings.height, finalOutputSettings.width);
|
|
[[SCLogger sharedInstance] logEvent:kSCCameraMetricsVideoRecordingStart
|
|
parameters:@{
|
|
@"video_width" : @(finalOutputSettings.width),
|
|
@"video_height" : @(finalOutputSettings.height),
|
|
@"bit_rate" : @(finalOutputSettings.videoBitRate),
|
|
@"is_video_snap" : @(_isVideoSnap),
|
|
}];
|
|
|
|
_outputURL = [URL copy];
|
|
_rawDataURL = [_outputURL URLByAppendingPathExtension:@"dat"];
|
|
[_capturerLogger logStartingStep:kSCCapturerStartingStepOutputSettings];
|
|
|
|
// Make sure the raw frame data file is gone
|
|
SCTraceSignal(@"Setup video frame raw data");
|
|
[[NSFileManager defaultManager] removeItemAtURL:_rawDataURL error:NULL];
|
|
if ([SnapVideoMetadata deviceMeetsRequirementsForContentAdaptiveVideoEncoding]) {
|
|
if (!_videoFrameRawDataCollector) {
|
|
_videoFrameRawDataCollector = [[SCVideoFrameRawDataCollector alloc] initWithPerformer:_performer];
|
|
}
|
|
[_videoFrameRawDataCollector prepareForCollectingVideoFrameRawDataWithRawDataURL:_rawDataURL];
|
|
}
|
|
[_capturerLogger logStartingStep:kSCCapturerStartingStepVideoFrameRawData];
|
|
|
|
SCLogVideoCapturerInfo(@"Prepare to begin audio recording");
|
|
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraMetricsAudioDelay
|
|
uniqueId:_captureSessionID
|
|
stepName:@"audio_queue_start_begin"];
|
|
[self _beginAudioQueueRecordingWithCompleteHandler:^(NSError *error) {
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraMetricsAudioDelay
|
|
uniqueId:_captureSessionID
|
|
stepName:@"audio_queue_start_end"];
|
|
if (error) {
|
|
[_delegate managedVideoCapturer:self
|
|
didGetError:error
|
|
forType:SCManagedVideoCapturerInfoAudioQueueError
|
|
session:sessionInfo];
|
|
} else {
|
|
_audioQueueStarted = YES;
|
|
}
|
|
if (self.status == SCManagedVideoCapturerStatusRecording) {
|
|
[_delegate managedVideoCapturer:self didBeginAudioRecording:sessionInfo];
|
|
}
|
|
}];
|
|
|
|
// Call this delegate first so that we have proper state transition from begin recording to finish / error
|
|
[_delegate managedVideoCapturer:self didBeginVideoRecording:sessionInfo];
|
|
|
|
// We need to start with a fresh recording file, make sure it's gone
|
|
[[NSFileManager defaultManager] removeItemAtURL:_outputURL error:NULL];
|
|
[_capturerLogger logStartingStep:kSCCapturerStartingStepAudioRecording];
|
|
|
|
SCTraceSignal(@"Setup asset writer");
|
|
|
|
NSError *error = nil;
|
|
_videoWriter = [[SCCapturerBufferedVideoWriter alloc] initWithPerformer:_performer
|
|
outputURL:self.outputURL
|
|
delegate:self
|
|
error:&error];
|
|
if (error) {
|
|
self.status = SCManagedVideoCapturerStatusError;
|
|
_lastError = error;
|
|
_placeholderImage = nil;
|
|
[_delegate managedVideoCapturer:self
|
|
didGetError:error
|
|
forType:SCManagedVideoCapturerInfoAssetWriterError
|
|
session:sessionInfo];
|
|
[_delegate managedVideoCapturer:self didFailWithError:_lastError session:sessionInfo];
|
|
return;
|
|
}
|
|
|
|
[_capturerLogger logStartingStep:kSCCapturerStartingStepAssetWriterConfiguration];
|
|
if (![_videoWriter prepareWritingWithOutputSettings:finalOutputSettings]) {
|
|
_lastError = [NSError errorWithDomain:kSCManagedVideoCapturerErrorDomain
|
|
code:kSCManagedVideoCapturerCannotAddAudioVideoInput
|
|
userInfo:nil];
|
|
_placeholderImage = nil;
|
|
[_delegate managedVideoCapturer:self didFailWithError:_lastError session:sessionInfo];
|
|
return;
|
|
}
|
|
SCTraceSignal(@"Observe asset writer status change");
|
|
SCCAssert(_placeholderImage == nil, @"placeholderImage should be nil");
|
|
self.status = SCManagedVideoCapturerStatusRecording;
|
|
// Only log the recording delay event from camera view (excluding video note recording)
|
|
if (_isVideoSnap) {
|
|
[[SCLogger sharedInstance] logTimedEventEnd:kSCCameraMetricsRecordingDelay
|
|
uniqueId:@"VIDEO"
|
|
parameters:@{
|
|
@"type" : @"video"
|
|
}];
|
|
}
|
|
_recordStartTime = CACurrentMediaTime();
|
|
};
|
|
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraMetricsAudioDelay
|
|
uniqueId:_captureSessionID
|
|
stepName:@"audio_session_start_begin"];
|
|
|
|
if (self.status == SCManagedVideoCapturerStatusPrepareToRecord) {
|
|
self.status = SCManagedVideoCapturerStatusReadyForRecording;
|
|
startRecordingBlock();
|
|
} else {
|
|
self.status = SCManagedVideoCapturerStatusReadyForRecording;
|
|
if (_audioConfiguration) {
|
|
[SCAudioSessionExperimentAdapter relinquishConfiguration:_audioConfiguration
|
|
performer:nil
|
|
completion:nil];
|
|
}
|
|
_preparedAudioConfiguration = _audioConfiguration = [SCAudioSessionExperimentAdapter
|
|
configureWith:audioConfiguration
|
|
performer:_performer
|
|
completion:^(NSError *error) {
|
|
if (error) {
|
|
[_delegate managedVideoCapturer:self
|
|
didGetError:error
|
|
forType:SCManagedVideoCapturerInfoAudioSessionError
|
|
session:sessionInfo];
|
|
}
|
|
startRecordingBlock();
|
|
}];
|
|
}
|
|
}];
|
|
return sessionInfo;
|
|
}
|
|
|
|
- (NSError *)_handleRetryBeginAudioRecordingErrorCode:(NSInteger)errorCode
|
|
error:(NSError *)error
|
|
micResult:(NSDictionary *)resultInfo
|
|
{
|
|
SCTraceStart();
|
|
NSString *resultStr = SC_CAST_TO_CLASS_OR_NIL(resultInfo[SCAudioSessionRetryDataSourceInfoKey], NSString);
|
|
BOOL changeMicSuccess = [resultInfo[SCAudioSessionRetryDataSourceResultKey] boolValue];
|
|
if (!error) {
|
|
SCManagedVideoCapturerInfoType type = SCManagedVideoCapturerInfoAudioQueueRetrySuccess;
|
|
if (changeMicSuccess) {
|
|
if (errorCode == kSCAudioQueueErrorWildCard) {
|
|
type = SCManagedVideoCapturerInfoAudioQueueRetryDataSourceSuccess_audioQueue;
|
|
} else if (errorCode == kSCAudioQueueErrorHardware) {
|
|
type = SCManagedVideoCapturerInfoAudioQueueRetryDataSourceSuccess_hardware;
|
|
}
|
|
}
|
|
[_delegate managedVideoCapturer:self didGetError:nil forType:type session:self.activeSession];
|
|
} else {
|
|
error = [self _appendInfo:resultStr forInfoKey:@"retry_datasource_result" toError:error];
|
|
SCLogVideoCapturerError(@"Retry setting audio session failed with error:%@", error);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
- (BOOL)_isBottomMicBrokenCode:(NSInteger)errorCode
|
|
{
|
|
// we consider both -50 and 1852797029 as a broken microphone case
|
|
return (errorCode == kSCAudioQueueErrorWildCard || errorCode == kSCAudioQueueErrorHardware);
|
|
}
|
|
|
|
- (void)_beginAudioQueueRecordingWithCompleteHandler:(audio_capture_session_block)block
|
|
{
|
|
SCTraceStart();
|
|
SCAssert(block, @"block can not be nil");
|
|
@weakify(self);
|
|
void (^beginAudioBlock)(NSError *error) = ^(NSError *error) {
|
|
@strongify(self);
|
|
SC_GUARD_ELSE_RETURN(self);
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
|
|
SCTraceStart();
|
|
NSInteger errorCode = error.code;
|
|
if ([self _isBottomMicBrokenCode:errorCode] &&
|
|
(self.status == SCManagedVideoCapturerStatusReadyForRecording ||
|
|
self.status == SCManagedVideoCapturerStatusRecording)) {
|
|
|
|
SCLogVideoCapturerError(@"Start to retry begin audio queue (error code: %@)", @(errorCode));
|
|
|
|
// use front microphone to retry
|
|
NSDictionary *resultInfo = [[SCAudioSession sharedInstance] tryUseFrontMicWithErrorCode:errorCode];
|
|
[self _retryRequestRecordingWithCompleteHandler:^(NSError *error) {
|
|
// then retry audio queue again
|
|
[_audioCaptureSession
|
|
beginAudioRecordingAsynchronouslyWithSampleRate:kSCAudioCaptureSessionDefaultSampleRate
|
|
completionHandler:^(NSError *innerError) {
|
|
NSError *modifyError = [self
|
|
_handleRetryBeginAudioRecordingErrorCode:errorCode
|
|
error:innerError
|
|
micResult:resultInfo];
|
|
block(modifyError);
|
|
}];
|
|
}];
|
|
|
|
} else {
|
|
block(error);
|
|
}
|
|
}];
|
|
};
|
|
[_audioCaptureSession beginAudioRecordingAsynchronouslyWithSampleRate:kSCAudioCaptureSessionDefaultSampleRate
|
|
completionHandler:^(NSError *error) {
|
|
beginAudioBlock(error);
|
|
}];
|
|
}
|
|
|
|
// This method must not change nullability of error, it should only either append info into userInfo,
|
|
// or return the NSError as it is.
|
|
- (NSError *)_appendInfo:(NSString *)infoStr forInfoKey:(NSString *)infoKey toError:(NSError *)error
|
|
{
|
|
if (!error || infoStr.length == 0 || infoKey.length == 0 || error.domain.length == 0) {
|
|
return error;
|
|
}
|
|
NSMutableDictionary *errorInfo = [[error userInfo] mutableCopy];
|
|
errorInfo[infoKey] = infoStr.length > 0 ? infoStr : @"(null)";
|
|
|
|
return [NSError errorWithDomain:error.domain code:error.code userInfo:errorInfo];
|
|
}
|
|
|
|
- (void)_retryRequestRecordingWithCompleteHandler:(audio_capture_session_block)block
|
|
{
|
|
SCTraceStart();
|
|
if (_audioConfiguration) {
|
|
[SCAudioSessionExperimentAdapter relinquishConfiguration:_audioConfiguration performer:nil completion:nil];
|
|
}
|
|
SCVideoCaptureSessionInfo sessionInfo = self.activeSession;
|
|
_preparedAudioConfiguration = _audioConfiguration = [SCAudioSessionExperimentAdapter
|
|
configureWith:_audioConfiguration.configuration
|
|
performer:_performer
|
|
completion:^(NSError *error) {
|
|
if (error) {
|
|
[_delegate managedVideoCapturer:self
|
|
didGetError:error
|
|
forType:SCManagedVideoCapturerInfoAudioSessionError
|
|
session:sessionInfo];
|
|
}
|
|
if (block) {
|
|
block(error);
|
|
}
|
|
}];
|
|
}
|
|
|
|
#pragma SCCapturerBufferedVideoWriterDelegate
|
|
|
|
- (void)videoWriterDidFailWritingWithError:(NSError *)error
|
|
{
|
|
// If it failed, we call the delegate method, release everything else we
|
|
// have, well, on the output queue obviously
|
|
SCTraceStart();
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
SCTraceStart();
|
|
SCVideoCaptureSessionInfo sessionInfo = self.activeSession;
|
|
[_outputURL reloadAssetKeys];
|
|
[self _cleanup];
|
|
[self _disposeAudioRecording];
|
|
self.status = SCManagedVideoCapturerStatusError;
|
|
_lastError = error;
|
|
_placeholderImage = nil;
|
|
[_delegate managedVideoCapturer:self
|
|
didGetError:error
|
|
forType:SCManagedVideoCapturerInfoAssetWriterError
|
|
session:sessionInfo];
|
|
[_delegate managedVideoCapturer:self didFailWithError:_lastError session:sessionInfo];
|
|
}];
|
|
}
|
|
|
|
- (void)_willStopRecording
|
|
{
|
|
if (self.status == SCManagedVideoCapturerStatusRecording) {
|
|
// To notify UI continue the preview processing
|
|
SCQueuePerformer *promisePerformer =
|
|
[[SCQueuePerformer alloc] initWithLabel:kSCManagedVideoCapturerPromiseQueueLabel
|
|
qualityOfService:QOS_CLASS_USER_INTERACTIVE
|
|
queueType:DISPATCH_QUEUE_SERIAL
|
|
context:SCQueuePerformerContextCamera];
|
|
_recordedVideoPromise = [[SCPromise alloc] initWithPerformer:promisePerformer];
|
|
[_delegate managedVideoCapturer:self
|
|
willStopWithRecordedVideoFuture:_recordedVideoPromise.future
|
|
videoSize:_outputSize
|
|
placeholderImage:_placeholderImage
|
|
session:self.activeSession];
|
|
}
|
|
}
|
|
|
|
- (void)_stopRecording
|
|
{
|
|
SCTraceStart();
|
|
SCAssert([_performer isCurrentPerformer], @"Needs to be on the performing queue");
|
|
// Reset stop session as well as stop time.
|
|
++_stopSession;
|
|
_stopTime = kCFAbsoluteTimeIntervalSince1970;
|
|
SCPromise<id<SCManagedRecordedVideo>> *recordedVideoPromise = _recordedVideoPromise;
|
|
_recordedVideoPromise = nil;
|
|
sc_managed_capturer_recording_session_t sessionId = _sessionId;
|
|
if (self.status == SCManagedVideoCapturerStatusRecording) {
|
|
self.status = SCManagedVideoCapturerStatusIdle;
|
|
if (CMTIME_IS_VALID(_endSessionTime)) {
|
|
[_videoWriter
|
|
finishWritingAtSourceTime:_endSessionTime
|
|
withCompletionHanlder:^{
|
|
// actually, make sure everything happens on outputQueue
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
if (sessionId != _sessionId) {
|
|
SCLogVideoCapturerError(@"SessionId mismatch: before: %@, after: %@", @(sessionId),
|
|
@(_sessionId));
|
|
return;
|
|
}
|
|
[self _disposeAudioRecording];
|
|
// Log the video snap recording success event w/ parameters, not including video
|
|
// note
|
|
if (_isVideoSnap) {
|
|
[SnapVideoMetadata logVideoEvent:kSCCameraMetricsVideoRecordingSuccess
|
|
videoSettings:_videoOutputSettings
|
|
isSave:NO];
|
|
}
|
|
void (^stopRecordingCompletionBlock)(NSURL *) = ^(NSURL *rawDataURL) {
|
|
SCAssert([_performer isCurrentPerformer], @"Needs to be on the performing queue");
|
|
SCVideoCaptureSessionInfo sessionInfo = self.activeSession;
|
|
|
|
[self _cleanup];
|
|
|
|
[[SCLogger sharedInstance] logTimedEventStart:@"SNAP_VIDEO_SIZE_LOADING"
|
|
uniqueId:@""
|
|
isUniqueEvent:NO];
|
|
CGSize videoSize =
|
|
[SnapVideoMetadata videoSizeForURL:_outputURL waitWhileLoadingTracksIfNeeded:YES];
|
|
[[SCLogger sharedInstance] logTimedEventEnd:@"SNAP_VIDEO_SIZE_LOADING"
|
|
uniqueId:@""
|
|
parameters:nil];
|
|
// Log error if video file is not really ready
|
|
if (videoSize.width == 0.0 || videoSize.height == 0.0) {
|
|
_lastError = [NSError errorWithDomain:kSCManagedVideoCapturerErrorDomain
|
|
code:kSCManagedVideoCapturerZeroVideoSize
|
|
userInfo:nil];
|
|
[recordedVideoPromise completeWithError:_lastError];
|
|
[_delegate managedVideoCapturer:self
|
|
didFailWithError:_lastError
|
|
session:sessionInfo];
|
|
_placeholderImage = nil;
|
|
return;
|
|
}
|
|
// If the video duration is too short, the future object will complete
|
|
// with error as well
|
|
SCManagedRecordedVideo *recordedVideo =
|
|
[[SCManagedRecordedVideo alloc] initWithVideoURL:_outputURL
|
|
rawVideoDataFileURL:_rawDataURL
|
|
placeholderImage:_placeholderImage
|
|
isFrontFacingCamera:_isFrontFacingCamera];
|
|
[recordedVideoPromise completeWithValue:recordedVideo];
|
|
[_delegate managedVideoCapturer:self
|
|
didSucceedWithRecordedVideo:recordedVideo
|
|
session:sessionInfo];
|
|
_placeholderImage = nil;
|
|
};
|
|
|
|
if (_videoFrameRawDataCollector) {
|
|
[_videoFrameRawDataCollector
|
|
drainFrameDataCollectionWithCompletionHandler:^(NSURL *rawDataURL) {
|
|
stopRecordingCompletionBlock(rawDataURL);
|
|
}];
|
|
} else {
|
|
stopRecordingCompletionBlock(nil);
|
|
}
|
|
}];
|
|
}];
|
|
|
|
} else {
|
|
[self _disposeAudioRecording];
|
|
SCVideoCaptureSessionInfo sessionInfo = self.activeSession;
|
|
[self _cleanup];
|
|
self.status = SCManagedVideoCapturerStatusError;
|
|
_lastError = [NSError errorWithDomain:kSCManagedVideoCapturerErrorDomain
|
|
code:kSCManagedVideoCapturerEmptyFrame
|
|
userInfo:nil];
|
|
_placeholderImage = nil;
|
|
[recordedVideoPromise completeWithError:_lastError];
|
|
[_delegate managedVideoCapturer:self didFailWithError:_lastError session:sessionInfo];
|
|
}
|
|
} else {
|
|
if (self.status == SCManagedVideoCapturerStatusPrepareToRecord ||
|
|
self.status == SCManagedVideoCapturerStatusReadyForRecording) {
|
|
_lastError = [NSError errorWithDomain:kSCManagedVideoCapturerErrorDomain
|
|
code:kSCManagedVideoCapturerStopBeforeStart
|
|
userInfo:nil];
|
|
} else {
|
|
_lastError = [NSError errorWithDomain:kSCManagedVideoCapturerErrorDomain
|
|
code:kSCManagedVideoCapturerStopWithoutStart
|
|
userInfo:nil];
|
|
}
|
|
SCVideoCaptureSessionInfo sessionInfo = self.activeSession;
|
|
[self _cleanup];
|
|
_placeholderImage = nil;
|
|
if (_audioConfiguration) {
|
|
[SCAudioSessionExperimentAdapter relinquishConfiguration:_audioConfiguration performer:nil completion:nil];
|
|
_audioConfiguration = nil;
|
|
}
|
|
[recordedVideoPromise completeWithError:_lastError];
|
|
[_delegate managedVideoCapturer:self didFailWithError:_lastError session:sessionInfo];
|
|
self.status = SCManagedVideoCapturerStatusIdle;
|
|
[_capturerLogger logEventIfStartingTooSlow];
|
|
}
|
|
}
|
|
|
|
- (void)stopRecordingAsynchronously
|
|
{
|
|
SCTraceStart();
|
|
NSTimeInterval stopTime = CACurrentMediaTime();
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
_stopTime = stopTime;
|
|
NSInteger stopSession = _stopSession;
|
|
[self _willStopRecording];
|
|
[_performer perform:^{
|
|
// If we haven't stopped yet, call the stop now nevertheless.
|
|
if (stopSession == _stopSession) {
|
|
[self _stopRecording];
|
|
}
|
|
}
|
|
after:kSCManagedVideoCapturerStopRecordingDeadline];
|
|
}];
|
|
}
|
|
|
|
- (void)cancelRecordingAsynchronously
|
|
{
|
|
SCTraceStart();
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
SCTraceStart();
|
|
SCLogVideoCapturerInfo(@"Cancel recording. status: %lu", (unsigned long)self.status);
|
|
if (self.status == SCManagedVideoCapturerStatusRecording) {
|
|
self.status = SCManagedVideoCapturerStatusIdle;
|
|
[self _disposeAudioRecording];
|
|
[_videoWriter cancelWriting];
|
|
SCVideoCaptureSessionInfo sessionInfo = self.activeSession;
|
|
[self _cleanup];
|
|
_placeholderImage = nil;
|
|
[_delegate managedVideoCapturer:self didCancelVideoRecording:sessionInfo];
|
|
} else if ((self.status == SCManagedVideoCapturerStatusPrepareToRecord) ||
|
|
(self.status == SCManagedVideoCapturerStatusReadyForRecording)) {
|
|
SCVideoCaptureSessionInfo sessionInfo = self.activeSession;
|
|
[self _cleanup];
|
|
self.status = SCManagedVideoCapturerStatusIdle;
|
|
_placeholderImage = nil;
|
|
if (_audioConfiguration) {
|
|
[SCAudioSessionExperimentAdapter relinquishConfiguration:_audioConfiguration
|
|
performer:nil
|
|
completion:nil];
|
|
_audioConfiguration = nil;
|
|
}
|
|
[_delegate managedVideoCapturer:self didCancelVideoRecording:sessionInfo];
|
|
}
|
|
[_capturerLogger logEventIfStartingTooSlow];
|
|
}];
|
|
}
|
|
|
|
- (void)addTimedTask:(SCTimedTask *)task
|
|
{
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
// Only allow to add observers when we are not recording.
|
|
if (!self->_timeObserver) {
|
|
self->_timeObserver = [SCManagedVideoCapturerTimeObserver new];
|
|
}
|
|
[self->_timeObserver addTimedTask:task];
|
|
SCLogVideoCapturerInfo(@"Added timetask: %@", task);
|
|
}];
|
|
}
|
|
|
|
- (void)clearTimedTasks
|
|
{
|
|
// _timeObserver will be initialized lazily when adding timed tasks
|
|
SCLogVideoCapturerInfo(@"Clearing time observer");
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
if (self->_timeObserver) {
|
|
self->_timeObserver = nil;
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)_cleanup
|
|
{
|
|
[_videoWriter cleanUp];
|
|
_timeObserver = nil;
|
|
|
|
SCLogVideoCapturerInfo(@"SCVideoCaptureSessionInfo before cleanup: %@",
|
|
SCVideoCaptureSessionInfoGetDebugDescription(self.activeSession));
|
|
|
|
_startSessionTime = kCMTimeInvalid;
|
|
_endSessionTime = kCMTimeInvalid;
|
|
_firstWrittenAudioBufferDelay = kCMTimeInvalid;
|
|
_sessionId = 0;
|
|
_captureSessionID = nil;
|
|
_audioQueueStarted = NO;
|
|
}
|
|
|
|
- (void)_disposeAudioRecording
|
|
{
|
|
SCLogVideoCapturerInfo(@"Disposing audio recording");
|
|
SCAssert([_performer isCurrentPerformer], @"");
|
|
// Setup the audio session token correctly
|
|
SCAudioConfigurationToken *audioConfiguration = _audioConfiguration;
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraMetricsAudioDelay
|
|
uniqueId:_captureSessionID
|
|
stepName:@"audio_queue_stop_begin"];
|
|
NSString *captureSessionID = _captureSessionID;
|
|
[_audioCaptureSession disposeAudioRecordingSynchronouslyWithCompletionHandler:^{
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraMetricsAudioDelay
|
|
uniqueId:captureSessionID
|
|
stepName:@"audio_queue_stop_end"];
|
|
SCLogVideoCapturerInfo(@"Did dispose audio recording");
|
|
if (audioConfiguration) {
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraMetricsAudioDelay
|
|
uniqueId:captureSessionID
|
|
stepName:@"audio_session_stop_begin"];
|
|
[SCAudioSessionExperimentAdapter
|
|
relinquishConfiguration:audioConfiguration
|
|
performer:_performer
|
|
completion:^(NSError *_Nullable error) {
|
|
[[SCLogger sharedInstance] logStepToEvent:kSCCameraMetricsAudioDelay
|
|
uniqueId:captureSessionID
|
|
stepName:@"audio_session_stop_end"];
|
|
[[SCLogger sharedInstance] logTimedEventEnd:kSCCameraMetricsAudioDelay
|
|
uniqueId:captureSessionID
|
|
parameters:nil];
|
|
}];
|
|
}
|
|
}];
|
|
_audioConfiguration = nil;
|
|
}
|
|
|
|
- (CIContext *)ciContext
|
|
{
|
|
if (!_ciContext) {
|
|
_ciContext = [CIContext contextWithOptions:nil];
|
|
}
|
|
return _ciContext;
|
|
}
|
|
|
|
#pragma mark - SCAudioCaptureSessionDelegate
|
|
|
|
- (void)audioCaptureSession:(SCAudioCaptureSession *)audioCaptureSession
|
|
didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
|
|
{
|
|
SCTraceStart();
|
|
if (self.status != SCManagedVideoCapturerStatusRecording) {
|
|
return;
|
|
}
|
|
CFRetain(sampleBuffer);
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
if (self.status == SCManagedVideoCapturerStatusRecording) {
|
|
// Audio always follows video, there is no other way around this :)
|
|
if (_hasWritten && CACurrentMediaTime() - _recordStartTime <= _maxDuration) {
|
|
[self _processAudioSampleBuffer:sampleBuffer];
|
|
[_videoWriter appendAudioSampleBuffer:sampleBuffer];
|
|
}
|
|
}
|
|
CFRelease(sampleBuffer);
|
|
}];
|
|
}
|
|
|
|
#pragma mark - SCManagedVideoDataSourceListener
|
|
|
|
- (void)managedVideoDataSource:(id<SCManagedVideoDataSource>)managedVideoDataSource
|
|
didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
|
|
devicePosition:(SCManagedCaptureDevicePosition)devicePosition
|
|
{
|
|
SCTraceStart();
|
|
if (self.status != SCManagedVideoCapturerStatusRecording) {
|
|
return;
|
|
}
|
|
CFRetain(sampleBuffer);
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
// the following check will allow the capture pipeline to drain
|
|
if (CMTimeGetSeconds(CMSampleBufferGetPresentationTimeStamp(sampleBuffer)) > _stopTime) {
|
|
[self _stopRecording];
|
|
} else {
|
|
if (self.status == SCManagedVideoCapturerStatusRecording) {
|
|
_isFrontFacingCamera = (devicePosition == SCManagedCaptureDevicePositionFront);
|
|
CMTime presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
|
|
if (CMTIME_IS_VALID(presentationTime)) {
|
|
SCLogVideoCapturerInfo(@"Obtained video data source at time %lld", presentationTime.value);
|
|
} else {
|
|
SCLogVideoCapturerInfo(@"Obtained video data source with an invalid time");
|
|
}
|
|
if (!_hasWritten) {
|
|
// Start writing!
|
|
[_videoWriter startWritingAtSourceTime:presentationTime];
|
|
[_capturerLogger endLoggingForStarting];
|
|
_startSessionTime = presentationTime;
|
|
_startSessionRealTime = CACurrentMediaTime();
|
|
SCLogVideoCapturerInfo(@"First frame processed %f seconds after presentation Time",
|
|
_startSessionRealTime - CMTimeGetSeconds(presentationTime));
|
|
_hasWritten = YES;
|
|
[[SCLogger sharedInstance] logPreCaptureOperationFinishedAt:CMTimeGetSeconds(presentationTime)];
|
|
[[SCCoreCameraLogger sharedInstance]
|
|
logCameraCreationDelaySplitPointPreCaptureOperationFinishedAt:CMTimeGetSeconds(
|
|
presentationTime)];
|
|
SCLogVideoCapturerInfo(@"SCVideoCaptureSessionInfo after first frame: %@",
|
|
SCVideoCaptureSessionInfoGetDebugDescription(self.activeSession));
|
|
}
|
|
// Only respect video end session time, audio can be cut off, not video,
|
|
// not video
|
|
if (CMTIME_IS_INVALID(_endSessionTime)) {
|
|
_endSessionTime = presentationTime;
|
|
} else {
|
|
_endSessionTime = CMTimeMaximum(_endSessionTime, presentationTime);
|
|
}
|
|
if (CACurrentMediaTime() - _recordStartTime <= _maxDuration) {
|
|
[_videoWriter appendVideoSampleBuffer:sampleBuffer];
|
|
[self _processVideoSampleBuffer:sampleBuffer];
|
|
}
|
|
if (_timeObserver) {
|
|
[_timeObserver processTime:CMTimeSubtract(presentationTime, _startSessionTime)
|
|
sessionStartTimeDelayInSecond:_startSessionRealTime - CMTimeGetSeconds(_startSessionTime)];
|
|
}
|
|
}
|
|
}
|
|
CFRelease(sampleBuffer);
|
|
}];
|
|
}
|
|
|
|
- (void)_generatePlaceholderImageWithPixelBuffer:(CVImageBufferRef)pixelBuffer metaData:(NSDictionary *)metadata
|
|
{
|
|
SCTraceStart();
|
|
CVImageBufferRef imageBuffer = CVPixelBufferRetain(pixelBuffer);
|
|
if (imageBuffer) {
|
|
dispatch_async(SCPlaceholderImageGenerationQueue(), ^{
|
|
UIImage *placeholderImage = [UIImage imageWithPixelBufferRef:imageBuffer
|
|
backingType:UIImageBackingTypeCGImage
|
|
orientation:UIImageOrientationRight
|
|
context:[self ciContext]];
|
|
placeholderImage =
|
|
SCCropImageToTargetAspectRatio(placeholderImage, SCManagedCapturedImageAndVideoAspectRatio());
|
|
[_performer performImmediatelyIfCurrentPerformer:^{
|
|
// After processing, assign it back.
|
|
if (self.status == SCManagedVideoCapturerStatusRecording) {
|
|
_placeholderImage = placeholderImage;
|
|
// Check video frame health by placeholder image
|
|
[[SCManagedFrameHealthChecker sharedInstance]
|
|
checkVideoHealthForCaptureFrameImage:placeholderImage
|
|
metedata:metadata
|
|
captureSessionID:_captureSessionID];
|
|
}
|
|
CVPixelBufferRelease(imageBuffer);
|
|
}];
|
|
});
|
|
}
|
|
}
|
|
|
|
#pragma mark - Pixel Buffer methods
|
|
|
|
- (void)_processVideoSampleBuffer:(CMSampleBufferRef)sampleBuffer
|
|
{
|
|
SC_GUARD_ELSE_RETURN(sampleBuffer);
|
|
CMTime presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
|
|
BOOL shouldGeneratePlaceholderImage = CMTimeCompare(presentationTime, _startSessionTime) == 0;
|
|
|
|
CVImageBufferRef outputPixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
|
|
if (outputPixelBuffer) {
|
|
[self _addVideoRawDataWithPixelBuffer:outputPixelBuffer];
|
|
if (shouldGeneratePlaceholderImage) {
|
|
NSDictionary *extraInfo = [_delegate managedVideoCapturerGetExtraFrameHealthInfo:self];
|
|
NSDictionary *metadata =
|
|
[[[SCManagedFrameHealthChecker sharedInstance] metadataForSampleBuffer:sampleBuffer extraInfo:extraInfo]
|
|
copy];
|
|
[self _generatePlaceholderImageWithPixelBuffer:outputPixelBuffer metaData:metadata];
|
|
}
|
|
}
|
|
|
|
[_delegate managedVideoCapturer:self
|
|
didAppendVideoSampleBuffer:sampleBuffer
|
|
presentationTimestamp:CMTimeSubtract(presentationTime, _startSessionTime)];
|
|
}
|
|
|
|
- (void)_processAudioSampleBuffer:(CMSampleBufferRef)sampleBuffer
|
|
{
|
|
[_announcer managedAudioDataSource:self didOutputSampleBuffer:sampleBuffer];
|
|
if (!CMTIME_IS_VALID(self.firstWrittenAudioBufferDelay)) {
|
|
self.firstWrittenAudioBufferDelay =
|
|
CMTimeSubtract(CMSampleBufferGetPresentationTimeStamp(sampleBuffer), _startSessionTime);
|
|
}
|
|
}
|
|
|
|
- (void)_addVideoRawDataWithPixelBuffer:(CVImageBufferRef)pixelBuffer
|
|
{
|
|
if (_videoFrameRawDataCollector && [SnapVideoMetadata deviceMeetsRequirementsForContentAdaptiveVideoEncoding] &&
|
|
((_rawDataFrameNum % kSCVideoContentComplexitySamplingRate) == 0) && (_rawDataFrameNum > 0)) {
|
|
if (_videoFrameRawDataCollector) {
|
|
CVImageBufferRef imageBuffer = CVPixelBufferRetain(pixelBuffer);
|
|
[_videoFrameRawDataCollector collectVideoFrameRawDataWithImageBuffer:imageBuffer
|
|
frameNum:_rawDataFrameNum
|
|
completion:^{
|
|
CVPixelBufferRelease(imageBuffer);
|
|
}];
|
|
}
|
|
}
|
|
_rawDataFrameNum++;
|
|
}
|
|
|
|
#pragma mark - SCManagedAudioDataSource
|
|
|
|
- (void)addListener:(id<SCManagedAudioDataSourceListener>)listener
|
|
{
|
|
[_announcer addListener:listener];
|
|
}
|
|
|
|
- (void)removeListener:(id<SCManagedAudioDataSourceListener>)listener
|
|
{
|
|
[_announcer removeListener:listener];
|
|
}
|
|
|
|
- (void)startStreamingWithAudioConfiguration:(SCAudioConfiguration *)configuration
|
|
{
|
|
SCAssertFail(@"Controlled by recorder");
|
|
}
|
|
|
|
- (void)stopStreaming
|
|
{
|
|
SCAssertFail(@"Controlled by recorder");
|
|
}
|
|
|
|
- (BOOL)isStreaming
|
|
{
|
|
return self.status == SCManagedVideoCapturerStatusRecording;
|
|
}
|
|
|
|
@end
|