Revert of Split iOS sdk in to separate targets (patchset #13 id:280001 of https://codereview.webrtc.org/2862543002/ )
Reason for revert:
Breaking downstream projects.
Original issue's description:
> Split iOS sdk in to separate targets
>
> This CL splits the iOS sdk into separate static libraries for video,
> audio, ui, common, and peerconnection-related code. This will in the
> future make it easier to compile WebRTC without unneeded components.
>
> BUG=webrtc:4867
>
> Review-Url: https://codereview.webrtc.org/2862543002
> Cr-Commit-Position: refs/heads/master@{#18166}
> Committed: 52c83fe710
TBR=magjed@webrtc.org,denicija@webrtc.org,tkchin@webrtc.org,henrika@webrtc.org,kthelgason@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=webrtc:4867
Review-Url: https://codereview.webrtc.org/2890513002
Cr-Commit-Position: refs/heads/master@{#18170}
This commit is contained in:
charujain
@ -1,49 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import <AVFoundation/AVFoundation.h>
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
#include "avfoundationvideocapturer.h"
|
||||
#endif
|
||||
|
||||
NS_ASSUME_NONNULL_BEGIN
|
||||
// This class is an implementation detail of AVFoundationVideoCapturer and handles
|
||||
// the ObjC integration with the AVFoundation APIs.
|
||||
// It is meant to be owned by an instance of AVFoundationVideoCapturer.
|
||||
// The reason for this is because other webrtc objects own cricket::VideoCapturer, which is not
|
||||
// ref counted. To prevent bad behavior we do not expose this class directly.
|
||||
@interface RTCAVFoundationVideoCapturerInternal
|
||||
: NSObject <AVCaptureVideoDataOutputSampleBufferDelegate>
|
||||
|
||||
@property(nonatomic, readonly) AVCaptureSession *captureSession;
|
||||
@property(nonatomic, readonly) dispatch_queue_t frameQueue;
|
||||
@property(nonatomic, readonly) BOOL canUseBackCamera;
|
||||
@property(nonatomic, assign) BOOL useBackCamera; // Defaults to NO.
|
||||
@property(atomic, assign) BOOL isRunning; // Whether the capture session is running.
|
||||
@property(atomic, assign) BOOL hasStarted; // Whether we have an unmatched start.
|
||||
|
||||
// We keep a pointer back to AVFoundationVideoCapturer to make callbacks on it
|
||||
// when we receive frames. This is safe because this object should be owned by
|
||||
// it.
|
||||
- (instancetype)initWithCapturer:(webrtc::AVFoundationVideoCapturer *)capturer;
|
||||
- (AVCaptureDevice *)getActiveCaptureDevice;
|
||||
|
||||
- (nullable AVCaptureDevice *)frontCaptureDevice;
|
||||
- (nullable AVCaptureDevice *)backCaptureDevice;
|
||||
|
||||
// Starts and stops the capture session asynchronously. We cannot do this
|
||||
// synchronously without blocking a WebRTC thread.
|
||||
- (void)start;
|
||||
- (void)stop;
|
||||
|
||||
@end
|
||||
NS_ASSUME_NONNULL_END
|
||||
@ -1,503 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import "RTCAVFoundationVideoCapturerInternal.h"
|
||||
|
||||
#import <Foundation/Foundation.h>
|
||||
#if TARGET_OS_IPHONE
|
||||
#import <UIKit/UIKit.h>
|
||||
#import "WebRTC/UIDevice+RTCDevice.h"
|
||||
#endif
|
||||
|
||||
#import "RTCDispatcher+Private.h"
|
||||
#import "WebRTC/RTCLogging.h"
|
||||
|
||||
#include "avfoundationformatmapper.h"
|
||||
|
||||
@implementation RTCAVFoundationVideoCapturerInternal {
|
||||
// Keep pointers to inputs for convenience.
|
||||
AVCaptureDeviceInput *_frontCameraInput;
|
||||
AVCaptureDeviceInput *_backCameraInput;
|
||||
AVCaptureVideoDataOutput *_videoDataOutput;
|
||||
// The cricket::VideoCapturer that owns this class. Should never be NULL.
|
||||
webrtc::AVFoundationVideoCapturer *_capturer;
|
||||
webrtc::VideoRotation _rotation;
|
||||
BOOL _hasRetriedOnFatalError;
|
||||
BOOL _isRunning;
|
||||
BOOL _hasStarted;
|
||||
rtc::CriticalSection _crit;
|
||||
}
|
||||
|
||||
@synthesize captureSession = _captureSession;
|
||||
@synthesize frameQueue = _frameQueue;
|
||||
@synthesize useBackCamera = _useBackCamera;
|
||||
|
||||
@synthesize isRunning = _isRunning;
|
||||
@synthesize hasStarted = _hasStarted;
|
||||
|
||||
// This is called from the thread that creates the video source, which is likely
|
||||
// the main thread.
|
||||
- (instancetype)initWithCapturer:(webrtc::AVFoundationVideoCapturer *)capturer {
|
||||
RTC_DCHECK(capturer);
|
||||
if (self = [super init]) {
|
||||
_capturer = capturer;
|
||||
// Create the capture session and all relevant inputs and outputs. We need
|
||||
// to do this in init because the application may want the capture session
|
||||
// before we start the capturer for e.g. AVCapturePreviewLayer. All objects
|
||||
// created here are retained until dealloc and never recreated.
|
||||
if (![self setupCaptureSession]) {
|
||||
return nil;
|
||||
}
|
||||
NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
|
||||
#if TARGET_OS_IPHONE
|
||||
[center addObserver:self
|
||||
selector:@selector(deviceOrientationDidChange:)
|
||||
name:UIDeviceOrientationDidChangeNotification
|
||||
object:nil];
|
||||
[center addObserver:self
|
||||
selector:@selector(handleCaptureSessionInterruption:)
|
||||
name:AVCaptureSessionWasInterruptedNotification
|
||||
object:_captureSession];
|
||||
[center addObserver:self
|
||||
selector:@selector(handleCaptureSessionInterruptionEnded:)
|
||||
name:AVCaptureSessionInterruptionEndedNotification
|
||||
object:_captureSession];
|
||||
[center addObserver:self
|
||||
selector:@selector(handleApplicationDidBecomeActive:)
|
||||
name:UIApplicationDidBecomeActiveNotification
|
||||
object:[UIApplication sharedApplication]];
|
||||
#endif
|
||||
[center addObserver:self
|
||||
selector:@selector(handleCaptureSessionRuntimeError:)
|
||||
name:AVCaptureSessionRuntimeErrorNotification
|
||||
object:_captureSession];
|
||||
[center addObserver:self
|
||||
selector:@selector(handleCaptureSessionDidStartRunning:)
|
||||
name:AVCaptureSessionDidStartRunningNotification
|
||||
object:_captureSession];
|
||||
[center addObserver:self
|
||||
selector:@selector(handleCaptureSessionDidStopRunning:)
|
||||
name:AVCaptureSessionDidStopRunningNotification
|
||||
object:_captureSession];
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
- (void)dealloc {
|
||||
RTC_DCHECK(!self.hasStarted);
|
||||
[[NSNotificationCenter defaultCenter] removeObserver:self];
|
||||
_capturer = nullptr;
|
||||
}
|
||||
|
||||
- (AVCaptureSession *)captureSession {
|
||||
return _captureSession;
|
||||
}
|
||||
|
||||
- (AVCaptureDevice *)getActiveCaptureDevice {
|
||||
return self.useBackCamera ? _backCameraInput.device : _frontCameraInput.device;
|
||||
}
|
||||
|
||||
- (nullable AVCaptureDevice *)frontCaptureDevice {
|
||||
return _frontCameraInput.device;
|
||||
}
|
||||
|
||||
- (nullable AVCaptureDevice *)backCaptureDevice {
|
||||
return _backCameraInput.device;
|
||||
}
|
||||
|
||||
- (dispatch_queue_t)frameQueue {
|
||||
if (!_frameQueue) {
|
||||
_frameQueue =
|
||||
dispatch_queue_create("org.webrtc.avfoundationvideocapturer.video", DISPATCH_QUEUE_SERIAL);
|
||||
dispatch_set_target_queue(_frameQueue,
|
||||
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0));
|
||||
}
|
||||
return _frameQueue;
|
||||
}
|
||||
|
||||
// Called from any thread (likely main thread).
|
||||
- (BOOL)canUseBackCamera {
|
||||
return _backCameraInput != nil;
|
||||
}
|
||||
|
||||
// Called from any thread (likely main thread).
|
||||
- (BOOL)useBackCamera {
|
||||
@synchronized(self) {
|
||||
return _useBackCamera;
|
||||
}
|
||||
}
|
||||
|
||||
// Called from any thread (likely main thread).
|
||||
- (void)setUseBackCamera:(BOOL)useBackCamera {
|
||||
if (!self.canUseBackCamera) {
|
||||
if (useBackCamera) {
|
||||
RTCLogWarning(@"No rear-facing camera exists or it cannot be used;"
|
||||
"not switching.");
|
||||
}
|
||||
return;
|
||||
}
|
||||
@synchronized(self) {
|
||||
if (_useBackCamera == useBackCamera) {
|
||||
return;
|
||||
}
|
||||
_useBackCamera = useBackCamera;
|
||||
[self updateSessionInputForUseBackCamera:useBackCamera];
|
||||
}
|
||||
}
|
||||
|
||||
// Called from WebRTC thread.
|
||||
- (void)start {
|
||||
if (self.hasStarted) {
|
||||
return;
|
||||
}
|
||||
self.hasStarted = YES;
|
||||
[RTCDispatcher
|
||||
dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
|
||||
block:^{
|
||||
#if TARGET_OS_IPHONE
|
||||
// Default to portrait orientation on iPhone. This will be reset in
|
||||
// updateOrientation unless orientation is unknown/faceup/facedown.
|
||||
_rotation = webrtc::kVideoRotation_90;
|
||||
#else
|
||||
// No rotation on Mac.
|
||||
_rotation = webrtc::kVideoRotation_0;
|
||||
#endif
|
||||
[self updateOrientation];
|
||||
#if TARGET_OS_IPHONE
|
||||
[[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications];
|
||||
#endif
|
||||
AVCaptureSession *captureSession = self.captureSession;
|
||||
[captureSession startRunning];
|
||||
}];
|
||||
}
|
||||
|
||||
// Called from same thread as start.
|
||||
- (void)stop {
|
||||
if (!self.hasStarted) {
|
||||
return;
|
||||
}
|
||||
self.hasStarted = NO;
|
||||
// Due to this async block, it's possible that the ObjC object outlives the
|
||||
// C++ one. In order to not invoke functions on the C++ object, we set
|
||||
// hasStarted immediately instead of dispatching it async.
|
||||
[RTCDispatcher
|
||||
dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
|
||||
block:^{
|
||||
[_videoDataOutput setSampleBufferDelegate:nil queue:nullptr];
|
||||
[_captureSession stopRunning];
|
||||
#if TARGET_OS_IPHONE
|
||||
[[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications];
|
||||
#endif
|
||||
}];
|
||||
}
|
||||
|
||||
#pragma mark iOS notifications
|
||||
|
||||
#if TARGET_OS_IPHONE
|
||||
- (void)deviceOrientationDidChange:(NSNotification *)notification {
|
||||
[RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
|
||||
block:^{
|
||||
[self updateOrientation];
|
||||
}];
|
||||
}
|
||||
#endif
|
||||
|
||||
#pragma mark AVCaptureVideoDataOutputSampleBufferDelegate
|
||||
|
||||
- (void)captureOutput:(AVCaptureOutput *)captureOutput
|
||||
didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
|
||||
fromConnection:(AVCaptureConnection *)connection {
|
||||
NSParameterAssert(captureOutput == _videoDataOutput);
|
||||
if (!self.hasStarted) {
|
||||
return;
|
||||
}
|
||||
_capturer->CaptureSampleBuffer(sampleBuffer, _rotation);
|
||||
}
|
||||
|
||||
- (void)captureOutput:(AVCaptureOutput *)captureOutput
|
||||
didDropSampleBuffer:(CMSampleBufferRef)sampleBuffer
|
||||
fromConnection:(AVCaptureConnection *)connection {
|
||||
RTCLogError(@"Dropped sample buffer.");
|
||||
}
|
||||
|
||||
#pragma mark - AVCaptureSession notifications
|
||||
|
||||
- (void)handleCaptureSessionInterruption:(NSNotification *)notification {
|
||||
NSString *reasonString = nil;
|
||||
#if defined(__IPHONE_9_0) && defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && \
|
||||
__IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_9_0
|
||||
if ([UIDevice isIOS9OrLater]) {
|
||||
NSNumber *reason = notification.userInfo[AVCaptureSessionInterruptionReasonKey];
|
||||
if (reason) {
|
||||
switch (reason.intValue) {
|
||||
case AVCaptureSessionInterruptionReasonVideoDeviceNotAvailableInBackground:
|
||||
reasonString = @"VideoDeviceNotAvailableInBackground";
|
||||
break;
|
||||
case AVCaptureSessionInterruptionReasonAudioDeviceInUseByAnotherClient:
|
||||
reasonString = @"AudioDeviceInUseByAnotherClient";
|
||||
break;
|
||||
case AVCaptureSessionInterruptionReasonVideoDeviceInUseByAnotherClient:
|
||||
reasonString = @"VideoDeviceInUseByAnotherClient";
|
||||
break;
|
||||
case AVCaptureSessionInterruptionReasonVideoDeviceNotAvailableWithMultipleForegroundApps:
|
||||
reasonString = @"VideoDeviceNotAvailableWithMultipleForegroundApps";
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
RTCLog(@"Capture session interrupted: %@", reasonString);
|
||||
// TODO(tkchin): Handle this case.
|
||||
}
|
||||
|
||||
- (void)handleCaptureSessionInterruptionEnded:(NSNotification *)notification {
|
||||
RTCLog(@"Capture session interruption ended.");
|
||||
// TODO(tkchin): Handle this case.
|
||||
}
|
||||
|
||||
- (void)handleCaptureSessionRuntimeError:(NSNotification *)notification {
|
||||
NSError *error = [notification.userInfo objectForKey:AVCaptureSessionErrorKey];
|
||||
RTCLogError(@"Capture session runtime error: %@", error);
|
||||
|
||||
[RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
|
||||
block:^{
|
||||
#if TARGET_OS_IPHONE
|
||||
if (error.code == AVErrorMediaServicesWereReset) {
|
||||
[self handleNonFatalError];
|
||||
} else {
|
||||
[self handleFatalError];
|
||||
}
|
||||
#else
|
||||
[self handleFatalError];
|
||||
#endif
|
||||
}];
|
||||
}
|
||||
|
||||
- (void)handleCaptureSessionDidStartRunning:(NSNotification *)notification {
|
||||
RTCLog(@"Capture session started.");
|
||||
|
||||
self.isRunning = YES;
|
||||
[RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
|
||||
block:^{
|
||||
// If we successfully restarted after an unknown error,
|
||||
// allow future retries on fatal errors.
|
||||
_hasRetriedOnFatalError = NO;
|
||||
}];
|
||||
}
|
||||
|
||||
- (void)handleCaptureSessionDidStopRunning:(NSNotification *)notification {
|
||||
RTCLog(@"Capture session stopped.");
|
||||
self.isRunning = NO;
|
||||
}
|
||||
|
||||
- (void)handleFatalError {
|
||||
[RTCDispatcher
|
||||
dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
|
||||
block:^{
|
||||
if (!_hasRetriedOnFatalError) {
|
||||
RTCLogWarning(@"Attempting to recover from fatal capture error.");
|
||||
[self handleNonFatalError];
|
||||
_hasRetriedOnFatalError = YES;
|
||||
} else {
|
||||
RTCLogError(@"Previous fatal error recovery failed.");
|
||||
}
|
||||
}];
|
||||
}
|
||||
|
||||
- (void)handleNonFatalError {
|
||||
[RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
|
||||
block:^{
|
||||
if (self.hasStarted) {
|
||||
RTCLog(@"Restarting capture session after error.");
|
||||
[self.captureSession startRunning];
|
||||
}
|
||||
}];
|
||||
}
|
||||
|
||||
#if TARGET_OS_IPHONE
|
||||
|
||||
#pragma mark - UIApplication notifications
|
||||
|
||||
- (void)handleApplicationDidBecomeActive:(NSNotification *)notification {
|
||||
[RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
|
||||
block:^{
|
||||
if (self.hasStarted && !self.captureSession.isRunning) {
|
||||
RTCLog(@"Restarting capture session on active.");
|
||||
[self.captureSession startRunning];
|
||||
}
|
||||
}];
|
||||
}
|
||||
|
||||
#endif // TARGET_OS_IPHONE
|
||||
|
||||
#pragma mark - Private
|
||||
|
||||
- (BOOL)setupCaptureSession {
|
||||
AVCaptureSession *captureSession = [[AVCaptureSession alloc] init];
|
||||
#if defined(WEBRTC_IOS)
|
||||
captureSession.usesApplicationAudioSession = NO;
|
||||
#endif
|
||||
// Add the output.
|
||||
AVCaptureVideoDataOutput *videoDataOutput = [self videoDataOutput];
|
||||
if (![captureSession canAddOutput:videoDataOutput]) {
|
||||
RTCLogError(@"Video data output unsupported.");
|
||||
return NO;
|
||||
}
|
||||
[captureSession addOutput:videoDataOutput];
|
||||
|
||||
// Get the front and back cameras. If there isn't a front camera
|
||||
// give up.
|
||||
AVCaptureDeviceInput *frontCameraInput = [self frontCameraInput];
|
||||
AVCaptureDeviceInput *backCameraInput = [self backCameraInput];
|
||||
if (!frontCameraInput) {
|
||||
RTCLogError(@"No front camera for capture session.");
|
||||
return NO;
|
||||
}
|
||||
|
||||
// Add the inputs.
|
||||
if (![captureSession canAddInput:frontCameraInput] ||
|
||||
(backCameraInput && ![captureSession canAddInput:backCameraInput])) {
|
||||
RTCLogError(@"Session does not support capture inputs.");
|
||||
return NO;
|
||||
}
|
||||
AVCaptureDeviceInput *input = self.useBackCamera ? backCameraInput : frontCameraInput;
|
||||
[captureSession addInput:input];
|
||||
|
||||
_captureSession = captureSession;
|
||||
return YES;
|
||||
}
|
||||
|
||||
- (AVCaptureVideoDataOutput *)videoDataOutput {
|
||||
if (!_videoDataOutput) {
|
||||
// Make the capturer output NV12. Ideally we want I420 but that's not
|
||||
// currently supported on iPhone / iPad.
|
||||
AVCaptureVideoDataOutput *videoDataOutput = [[AVCaptureVideoDataOutput alloc] init];
|
||||
videoDataOutput.videoSettings = @{
|
||||
(NSString *)
|
||||
// TODO(denicija): Remove this color conversion and use the original capture format directly.
|
||||
kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
|
||||
};
|
||||
videoDataOutput.alwaysDiscardsLateVideoFrames = NO;
|
||||
[videoDataOutput setSampleBufferDelegate:self queue:self.frameQueue];
|
||||
_videoDataOutput = videoDataOutput;
|
||||
}
|
||||
return _videoDataOutput;
|
||||
}
|
||||
|
||||
- (AVCaptureDevice *)videoCaptureDeviceForPosition:(AVCaptureDevicePosition)position {
|
||||
for (AVCaptureDevice *captureDevice in [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo]) {
|
||||
if (captureDevice.position == position) {
|
||||
return captureDevice;
|
||||
}
|
||||
}
|
||||
return nil;
|
||||
}
|
||||
|
||||
- (AVCaptureDeviceInput *)frontCameraInput {
|
||||
if (!_frontCameraInput) {
|
||||
#if TARGET_OS_IPHONE
|
||||
AVCaptureDevice *frontCameraDevice =
|
||||
[self videoCaptureDeviceForPosition:AVCaptureDevicePositionFront];
|
||||
#else
|
||||
AVCaptureDevice *frontCameraDevice =
|
||||
[AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
|
||||
#endif
|
||||
if (!frontCameraDevice) {
|
||||
RTCLogWarning(@"Failed to find front capture device.");
|
||||
return nil;
|
||||
}
|
||||
NSError *error = nil;
|
||||
AVCaptureDeviceInput *frontCameraInput =
|
||||
[AVCaptureDeviceInput deviceInputWithDevice:frontCameraDevice error:&error];
|
||||
if (!frontCameraInput) {
|
||||
RTCLogError(@"Failed to create front camera input: %@", error.localizedDescription);
|
||||
return nil;
|
||||
}
|
||||
_frontCameraInput = frontCameraInput;
|
||||
}
|
||||
return _frontCameraInput;
|
||||
}
|
||||
|
||||
- (AVCaptureDeviceInput *)backCameraInput {
|
||||
if (!_backCameraInput) {
|
||||
AVCaptureDevice *backCameraDevice =
|
||||
[self videoCaptureDeviceForPosition:AVCaptureDevicePositionBack];
|
||||
if (!backCameraDevice) {
|
||||
RTCLogWarning(@"Failed to find front capture device.");
|
||||
return nil;
|
||||
}
|
||||
NSError *error = nil;
|
||||
AVCaptureDeviceInput *backCameraInput =
|
||||
[AVCaptureDeviceInput deviceInputWithDevice:backCameraDevice error:&error];
|
||||
if (!backCameraInput) {
|
||||
RTCLogError(@"Failed to create front camera input: %@", error.localizedDescription);
|
||||
return nil;
|
||||
}
|
||||
_backCameraInput = backCameraInput;
|
||||
}
|
||||
return _backCameraInput;
|
||||
}
|
||||
|
||||
// Called from capture session queue.
|
||||
- (void)updateOrientation {
|
||||
#if TARGET_OS_IPHONE
|
||||
switch ([UIDevice currentDevice].orientation) {
|
||||
case UIDeviceOrientationPortrait:
|
||||
_rotation = webrtc::kVideoRotation_90;
|
||||
break;
|
||||
case UIDeviceOrientationPortraitUpsideDown:
|
||||
_rotation = webrtc::kVideoRotation_270;
|
||||
break;
|
||||
case UIDeviceOrientationLandscapeLeft:
|
||||
_rotation =
|
||||
_capturer->GetUseBackCamera() ? webrtc::kVideoRotation_0 : webrtc::kVideoRotation_180;
|
||||
break;
|
||||
case UIDeviceOrientationLandscapeRight:
|
||||
_rotation =
|
||||
_capturer->GetUseBackCamera() ? webrtc::kVideoRotation_180 : webrtc::kVideoRotation_0;
|
||||
break;
|
||||
case UIDeviceOrientationFaceUp:
|
||||
case UIDeviceOrientationFaceDown:
|
||||
case UIDeviceOrientationUnknown:
|
||||
// Ignore.
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// Update the current session input to match what's stored in _useBackCamera.
|
||||
- (void)updateSessionInputForUseBackCamera:(BOOL)useBackCamera {
|
||||
[RTCDispatcher dispatchAsyncOnType:RTCDispatcherTypeCaptureSession
|
||||
block:^{
|
||||
[_captureSession beginConfiguration];
|
||||
AVCaptureDeviceInput *oldInput = _backCameraInput;
|
||||
AVCaptureDeviceInput *newInput = _frontCameraInput;
|
||||
if (useBackCamera) {
|
||||
oldInput = _frontCameraInput;
|
||||
newInput = _backCameraInput;
|
||||
}
|
||||
if (oldInput) {
|
||||
// Ok to remove this even if it's not attached. Will be no-op.
|
||||
[_captureSession removeInput:oldInput];
|
||||
}
|
||||
if (newInput) {
|
||||
[_captureSession addInput:newInput];
|
||||
}
|
||||
[self updateOrientation];
|
||||
AVCaptureDevice *newDevice = newInput.device;
|
||||
const cricket::VideoFormat *format =
|
||||
_capturer->GetCaptureFormat();
|
||||
webrtc::SetFormatForCaptureDevice(
|
||||
newDevice, _captureSession, *format);
|
||||
[_captureSession commitConfiguration];
|
||||
}];
|
||||
}
|
||||
|
||||
@end
|
||||
@ -1,119 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import "RTCShader.h"
|
||||
|
||||
#import "RTCI420TextureCache.h"
|
||||
#import "RTCShader+Private.h"
|
||||
#import "WebRTC/RTCLogging.h"
|
||||
#import "WebRTC/RTCVideoFrame.h"
|
||||
|
||||
#include "webrtc/base/optional.h"
|
||||
|
||||
// Fragment shader converts YUV values from input textures into a final RGB
|
||||
// pixel. The conversion formula is from http://www.fourcc.org/fccyvrgb.php.
|
||||
static const char kI420FragmentShaderSource[] =
|
||||
SHADER_VERSION
|
||||
"precision highp float;"
|
||||
FRAGMENT_SHADER_IN " vec2 v_texcoord;\n"
|
||||
"uniform lowp sampler2D s_textureY;\n"
|
||||
"uniform lowp sampler2D s_textureU;\n"
|
||||
"uniform lowp sampler2D s_textureV;\n"
|
||||
FRAGMENT_SHADER_OUT
|
||||
"void main() {\n"
|
||||
" float y, u, v, r, g, b;\n"
|
||||
" y = " FRAGMENT_SHADER_TEXTURE "(s_textureY, v_texcoord).r;\n"
|
||||
" u = " FRAGMENT_SHADER_TEXTURE "(s_textureU, v_texcoord).r;\n"
|
||||
" v = " FRAGMENT_SHADER_TEXTURE "(s_textureV, v_texcoord).r;\n"
|
||||
" u = u - 0.5;\n"
|
||||
" v = v - 0.5;\n"
|
||||
" r = y + 1.403 * v;\n"
|
||||
" g = y - 0.344 * u - 0.714 * v;\n"
|
||||
" b = y + 1.770 * u;\n"
|
||||
" " FRAGMENT_SHADER_COLOR " = vec4(r, g, b, 1.0);\n"
|
||||
" }\n";
|
||||
|
||||
@implementation RTCI420Shader {
|
||||
RTCI420TextureCache* textureCache;
|
||||
// Handles for OpenGL constructs.
|
||||
GLuint _i420Program;
|
||||
GLuint _vertexArray;
|
||||
GLuint _vertexBuffer;
|
||||
GLint _ySampler;
|
||||
GLint _uSampler;
|
||||
GLint _vSampler;
|
||||
// Store current rotation and only upload new vertex data when rotation
|
||||
// changes.
|
||||
rtc::Optional<RTCVideoRotation> _currentRotation;
|
||||
}
|
||||
|
||||
- (instancetype)initWithContext:(GlContextType *)context {
|
||||
if (self = [super init]) {
|
||||
textureCache = [[RTCI420TextureCache alloc] initWithContext:context];
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
if (![self setupI420Program] ||
|
||||
!RTCSetupVerticesForProgram(_i420Program, &_vertexBuffer, &_vertexArray)) {
|
||||
RTCLog(@"Failed to initialize RTCI420Shader.");
|
||||
self = nil;
|
||||
}
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
- (void)dealloc {
|
||||
glDeleteProgram(_i420Program);
|
||||
glDeleteBuffers(1, &_vertexBuffer);
|
||||
glDeleteVertexArrays(1, &_vertexArray);
|
||||
}
|
||||
|
||||
- (BOOL)setupI420Program {
|
||||
_i420Program = RTCCreateProgramFromFragmentSource(kI420FragmentShaderSource);
|
||||
if (!_i420Program) {
|
||||
return NO;
|
||||
}
|
||||
_ySampler = glGetUniformLocation(_i420Program, "s_textureY");
|
||||
_uSampler = glGetUniformLocation(_i420Program, "s_textureU");
|
||||
_vSampler = glGetUniformLocation(_i420Program, "s_textureV");
|
||||
|
||||
return (_ySampler >= 0 && _uSampler >= 0 && _vSampler >= 0);
|
||||
}
|
||||
|
||||
- (BOOL)drawFrame:(RTCVideoFrame*)frame {
|
||||
glUseProgram(_i420Program);
|
||||
|
||||
[textureCache uploadFrameToTextures:frame];
|
||||
|
||||
#if !TARGET_OS_IPHONE
|
||||
glBindVertexArray(_vertexArray);
|
||||
#endif
|
||||
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glBindTexture(GL_TEXTURE_2D, textureCache.yTexture);
|
||||
glUniform1i(_ySampler, 0);
|
||||
|
||||
glActiveTexture(GL_TEXTURE1);
|
||||
glBindTexture(GL_TEXTURE_2D, textureCache.uTexture);
|
||||
glUniform1i(_uSampler, 1);
|
||||
|
||||
glActiveTexture(GL_TEXTURE2);
|
||||
glBindTexture(GL_TEXTURE_2D, textureCache.vTexture);
|
||||
glUniform1i(_vSampler, 2);
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
|
||||
if (!_currentRotation || frame.rotation != *_currentRotation) {
|
||||
_currentRotation = rtc::Optional<RTCVideoRotation>(frame.rotation);
|
||||
RTCSetVertexData(*_currentRotation);
|
||||
}
|
||||
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
||||
|
||||
return YES;
|
||||
}
|
||||
|
||||
@end
|
||||
@ -1,24 +0,0 @@
|
||||
/*
|
||||
* Copyright 2017 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import "RTCOpenGLDefines.h"
|
||||
#import "WebRTC/RTCVideoFrame.h"
|
||||
|
||||
@interface RTCI420TextureCache : NSObject
|
||||
|
||||
@property(nonatomic, readonly) GLuint yTexture;
|
||||
@property(nonatomic, readonly) GLuint uTexture;
|
||||
@property(nonatomic, readonly) GLuint vTexture;
|
||||
|
||||
- (instancetype)initWithContext:(GlContextType *)context;
|
||||
|
||||
- (void)uploadFrameToTextures:(RTCVideoFrame *)frame;
|
||||
|
||||
@end
|
||||
@ -1,149 +0,0 @@
|
||||
/*
|
||||
* Copyright 2017 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import "RTCI420TextureCache.h"
|
||||
|
||||
#import "RTCShader+Private.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
// Two sets of 3 textures are used here, one for each of the Y, U and V planes. Having two sets
|
||||
// alleviates CPU blockage in the event that the GPU is asked to render to a texture that is already
|
||||
// in use.
|
||||
static const GLsizei kNumTextureSets = 2;
|
||||
static const GLsizei kNumTexturesPerSet = 3;
|
||||
static const GLsizei kNumTextures = kNumTexturesPerSet * kNumTextureSets;
|
||||
|
||||
@implementation RTCI420TextureCache {
|
||||
BOOL _hasUnpackRowLength;
|
||||
GLint _currentTextureSet;
|
||||
// Handles for OpenGL constructs.
|
||||
GLuint _textures[kNumTextures];
|
||||
// Used to create a non-padded plane for GPU upload when we receive padded frames.
|
||||
std::vector<uint8_t> _planeBuffer;
|
||||
}
|
||||
|
||||
- (GLuint)yTexture {
|
||||
return _textures[_currentTextureSet * kNumTexturesPerSet];
|
||||
}
|
||||
|
||||
- (GLuint)uTexture {
|
||||
return _textures[_currentTextureSet * kNumTexturesPerSet + 1];
|
||||
}
|
||||
|
||||
- (GLuint)vTexture {
|
||||
return _textures[_currentTextureSet * kNumTexturesPerSet + 2];
|
||||
}
|
||||
|
||||
- (instancetype)initWithContext:(GlContextType *)context {
|
||||
if (self = [super init]) {
|
||||
#if TARGET_OS_IPHONE
|
||||
_hasUnpackRowLength = (context.API == kEAGLRenderingAPIOpenGLES3);
|
||||
#else
|
||||
_hasUnpackRowLength = YES;
|
||||
#endif
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
|
||||
[self setupTextures];
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
- (void)dealloc {
|
||||
glDeleteTextures(kNumTextures, _textures);
|
||||
}
|
||||
|
||||
- (void)setupTextures {
|
||||
glGenTextures(kNumTextures, _textures);
|
||||
// Set parameters for each of the textures we created.
|
||||
for (GLsizei i = 0; i < kNumTextures; i++) {
|
||||
glBindTexture(GL_TEXTURE_2D, _textures[i]);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
}
|
||||
}
|
||||
|
||||
- (void)uploadPlane:(const uint8_t *)plane
|
||||
texture:(GLuint)texture
|
||||
width:(size_t)width
|
||||
height:(size_t)height
|
||||
stride:(int32_t)stride {
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
|
||||
const uint8_t *uploadPlane = plane;
|
||||
if ((size_t)stride != width) {
|
||||
if (_hasUnpackRowLength) {
|
||||
// GLES3 allows us to specify stride.
|
||||
glPixelStorei(GL_UNPACK_ROW_LENGTH, stride);
|
||||
glTexImage2D(GL_TEXTURE_2D,
|
||||
0,
|
||||
RTC_PIXEL_FORMAT,
|
||||
static_cast<GLsizei>(width),
|
||||
static_cast<GLsizei>(height),
|
||||
0,
|
||||
RTC_PIXEL_FORMAT,
|
||||
GL_UNSIGNED_BYTE,
|
||||
uploadPlane);
|
||||
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
||||
return;
|
||||
} else {
|
||||
// Make an unpadded copy and upload that instead. Quick profiling showed
|
||||
// that this is faster than uploading row by row using glTexSubImage2D.
|
||||
uint8_t *unpaddedPlane = _planeBuffer.data();
|
||||
for (size_t y = 0; y < height; ++y) {
|
||||
memcpy(unpaddedPlane + y * width, plane + y * stride, width);
|
||||
}
|
||||
uploadPlane = unpaddedPlane;
|
||||
}
|
||||
}
|
||||
glTexImage2D(GL_TEXTURE_2D,
|
||||
0,
|
||||
RTC_PIXEL_FORMAT,
|
||||
static_cast<GLsizei>(width),
|
||||
static_cast<GLsizei>(height),
|
||||
0,
|
||||
RTC_PIXEL_FORMAT,
|
||||
GL_UNSIGNED_BYTE,
|
||||
uploadPlane);
|
||||
}
|
||||
|
||||
- (void)uploadFrameToTextures:(RTCVideoFrame *)frame {
|
||||
_currentTextureSet = (_currentTextureSet + 1) % kNumTextureSets;
|
||||
|
||||
const int chromaWidth = (frame.width + 1) / 2;
|
||||
const int chromaHeight = (frame.height + 1) / 2;
|
||||
if (frame.strideY != frame.width ||
|
||||
frame.strideU != chromaWidth ||
|
||||
frame.strideV != chromaWidth) {
|
||||
_planeBuffer.resize(frame.width * frame.height);
|
||||
}
|
||||
|
||||
[self uploadPlane:frame.dataY
|
||||
texture:self.yTexture
|
||||
width:frame.width
|
||||
height:frame.height
|
||||
stride:frame.strideY];
|
||||
|
||||
[self uploadPlane:frame.dataU
|
||||
texture:self.uTexture
|
||||
width:chromaWidth
|
||||
height:chromaHeight
|
||||
stride:frame.strideU];
|
||||
|
||||
[self uploadPlane:frame.dataV
|
||||
texture:self.vTexture
|
||||
width:chromaWidth
|
||||
height:chromaHeight
|
||||
stride:frame.strideV];
|
||||
}
|
||||
|
||||
@end
|
||||
@ -1,30 +0,0 @@
|
||||
/*
|
||||
* Copyright 2017 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import <GLKit/GLKit.h>
|
||||
|
||||
@class RTCVideoFrame;
|
||||
|
||||
NS_ASSUME_NONNULL_BEGIN
|
||||
|
||||
@interface RTCNV12TextureCache : NSObject
|
||||
|
||||
@property(nonatomic, readonly) GLuint yTexture;
|
||||
@property(nonatomic, readonly) GLuint uvTexture;
|
||||
|
||||
- (nullable instancetype)initWithContext:(EAGLContext *)context;
|
||||
|
||||
- (BOOL)uploadFrameToTextures:(RTCVideoFrame *)frame;
|
||||
|
||||
- (void)releaseTextures;
|
||||
|
||||
@end
|
||||
|
||||
NS_ASSUME_NONNULL_END
|
||||
@ -1,108 +0,0 @@
|
||||
/*
|
||||
* Copyright 2017 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import "RTCNV12TextureCache.h"
|
||||
|
||||
#import "WebRTC/RTCVideoFrame.h"
|
||||
|
||||
@implementation RTCNV12TextureCache {
|
||||
CVOpenGLESTextureCacheRef _textureCache;
|
||||
CVOpenGLESTextureRef _yTextureRef;
|
||||
CVOpenGLESTextureRef _uvTextureRef;
|
||||
}
|
||||
|
||||
- (GLuint)yTexture {
|
||||
return CVOpenGLESTextureGetName(_yTextureRef);
|
||||
}
|
||||
|
||||
- (GLuint)uvTexture {
|
||||
return CVOpenGLESTextureGetName(_uvTextureRef);
|
||||
}
|
||||
|
||||
- (instancetype)initWithContext:(EAGLContext *)context {
|
||||
if (self = [super init]) {
|
||||
CVReturn ret = CVOpenGLESTextureCacheCreate(
|
||||
kCFAllocatorDefault, NULL,
|
||||
#if COREVIDEO_USE_EAGLCONTEXT_CLASS_IN_API
|
||||
context,
|
||||
#else
|
||||
(__bridge void *)context,
|
||||
#endif
|
||||
NULL, &_textureCache);
|
||||
if (ret != kCVReturnSuccess) {
|
||||
self = nil;
|
||||
}
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
- (BOOL)loadTexture:(CVOpenGLESTextureRef *)textureOut
|
||||
pixelBuffer:(CVPixelBufferRef)pixelBuffer
|
||||
planeIndex:(int)planeIndex
|
||||
pixelFormat:(GLenum)pixelFormat {
|
||||
const int width = CVPixelBufferGetWidthOfPlane(pixelBuffer, planeIndex);
|
||||
const int height = CVPixelBufferGetHeightOfPlane(pixelBuffer, planeIndex);
|
||||
|
||||
if (*textureOut) {
|
||||
CFRelease(*textureOut);
|
||||
*textureOut = nil;
|
||||
}
|
||||
CVReturn ret = CVOpenGLESTextureCacheCreateTextureFromImage(
|
||||
kCFAllocatorDefault, _textureCache, pixelBuffer, NULL, GL_TEXTURE_2D, pixelFormat, width,
|
||||
height, pixelFormat, GL_UNSIGNED_BYTE, planeIndex, textureOut);
|
||||
if (ret != kCVReturnSuccess) {
|
||||
CFRelease(*textureOut);
|
||||
*textureOut = nil;
|
||||
return NO;
|
||||
}
|
||||
NSAssert(CVOpenGLESTextureGetTarget(*textureOut) == GL_TEXTURE_2D,
|
||||
@"Unexpected GLES texture target");
|
||||
glBindTexture(GL_TEXTURE_2D, CVOpenGLESTextureGetName(*textureOut));
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
return YES;
|
||||
}
|
||||
|
||||
- (BOOL)uploadFrameToTextures:(RTCVideoFrame *)frame {
|
||||
CVPixelBufferRef pixelBuffer = frame.nativeHandle;
|
||||
NSParameterAssert(pixelBuffer);
|
||||
return [self loadTexture:&_yTextureRef
|
||||
pixelBuffer:pixelBuffer
|
||||
planeIndex:0
|
||||
pixelFormat:GL_LUMINANCE] &&
|
||||
[self loadTexture:&_uvTextureRef
|
||||
pixelBuffer:pixelBuffer
|
||||
planeIndex:1
|
||||
pixelFormat:GL_LUMINANCE_ALPHA];
|
||||
}
|
||||
|
||||
- (void)releaseTextures {
|
||||
if (_uvTextureRef) {
|
||||
CFRelease(_uvTextureRef);
|
||||
_uvTextureRef = nil;
|
||||
}
|
||||
if (_yTextureRef) {
|
||||
CFRelease(_yTextureRef);
|
||||
_yTextureRef = nil;
|
||||
}
|
||||
}
|
||||
|
||||
- (void)dealloc {
|
||||
[self releaseTextures];
|
||||
if (_textureCache) {
|
||||
CFRelease(_textureCache);
|
||||
_textureCache = nil;
|
||||
}
|
||||
}
|
||||
|
||||
@end
|
||||
|
||||
@ -1,107 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import "RTCShader.h"
|
||||
|
||||
#import "RTCNV12TextureCache.h"
|
||||
#import "RTCShader+Private.h"
|
||||
#import "WebRTC/RTCLogging.h"
|
||||
#import "WebRTC/RTCVideoFrame.h"
|
||||
|
||||
#include "webrtc/base/checks.h"
|
||||
#include "webrtc/base/optional.h"
|
||||
|
||||
static const char kNV12FragmentShaderSource[] =
|
||||
SHADER_VERSION
|
||||
"precision mediump float;"
|
||||
FRAGMENT_SHADER_IN " vec2 v_texcoord;\n"
|
||||
"uniform lowp sampler2D s_textureY;\n"
|
||||
"uniform lowp sampler2D s_textureUV;\n"
|
||||
FRAGMENT_SHADER_OUT
|
||||
"void main() {\n"
|
||||
" mediump float y;\n"
|
||||
" mediump vec2 uv;\n"
|
||||
" y = " FRAGMENT_SHADER_TEXTURE "(s_textureY, v_texcoord).r;\n"
|
||||
" uv = " FRAGMENT_SHADER_TEXTURE "(s_textureUV, v_texcoord).ra -\n"
|
||||
" vec2(0.5, 0.5);\n"
|
||||
" " FRAGMENT_SHADER_COLOR " = vec4(y + 1.403 * uv.y,\n"
|
||||
" y - 0.344 * uv.x - 0.714 * uv.y,\n"
|
||||
" y + 1.770 * uv.x,\n"
|
||||
" 1.0);\n"
|
||||
" }\n";
|
||||
|
||||
@implementation RTCNativeNV12Shader {
|
||||
GLuint _vertexBuffer;
|
||||
GLuint _nv12Program;
|
||||
GLint _ySampler;
|
||||
GLint _uvSampler;
|
||||
RTCNV12TextureCache *_textureCache;
|
||||
// Store current rotation and only upload new vertex data when rotation
|
||||
// changes.
|
||||
rtc::Optional<RTCVideoRotation> _currentRotation;
|
||||
}
|
||||
|
||||
- (instancetype)initWithContext:(GlContextType *)context {
|
||||
if (self = [super init]) {
|
||||
_textureCache = [[RTCNV12TextureCache alloc] initWithContext:context];
|
||||
if (!_textureCache || ![self setupNV12Program] ||
|
||||
!RTCSetupVerticesForProgram(_nv12Program, &_vertexBuffer, nullptr)) {
|
||||
RTCLog(@"Failed to initialize RTCNativeNV12Shader.");
|
||||
self = nil;
|
||||
}
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
- (void)dealloc {
|
||||
glDeleteProgram(_nv12Program);
|
||||
glDeleteBuffers(1, &_vertexBuffer);
|
||||
}
|
||||
|
||||
- (BOOL)setupNV12Program {
|
||||
_nv12Program = RTCCreateProgramFromFragmentSource(kNV12FragmentShaderSource);
|
||||
if (!_nv12Program) {
|
||||
return NO;
|
||||
}
|
||||
_ySampler = glGetUniformLocation(_nv12Program, "s_textureY");
|
||||
_uvSampler = glGetUniformLocation(_nv12Program, "s_textureUV");
|
||||
|
||||
return (_ySampler >= 0 && _uvSampler >= 0);
|
||||
}
|
||||
|
||||
- (BOOL)drawFrame:(RTCVideoFrame *)frame {
|
||||
glUseProgram(_nv12Program);
|
||||
if (![_textureCache uploadFrameToTextures:frame]) {
|
||||
return NO;
|
||||
}
|
||||
|
||||
// Y-plane.
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glUniform1i(_ySampler, 0);
|
||||
glBindTexture(GL_TEXTURE_2D, _textureCache.yTexture);
|
||||
|
||||
// UV-plane.
|
||||
glActiveTexture(GL_TEXTURE1);
|
||||
glUniform1i(_uvSampler, 1);
|
||||
glBindTexture(GL_TEXTURE_2D, _textureCache.uvTexture);
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
|
||||
if (!_currentRotation || frame.rotation != *_currentRotation) {
|
||||
_currentRotation = rtc::Optional<RTCVideoRotation>(frame.rotation);
|
||||
RTCSetVertexData(*_currentRotation);
|
||||
}
|
||||
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
||||
|
||||
[_textureCache releaseTextures];
|
||||
|
||||
return YES;
|
||||
}
|
||||
|
||||
@end
|
||||
@ -1,37 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
#if TARGET_OS_IPHONE
|
||||
#define RTC_PIXEL_FORMAT GL_LUMINANCE
|
||||
#define SHADER_VERSION
|
||||
#define VERTEX_SHADER_IN "attribute"
|
||||
#define VERTEX_SHADER_OUT "varying"
|
||||
#define FRAGMENT_SHADER_IN "varying"
|
||||
#define FRAGMENT_SHADER_OUT
|
||||
#define FRAGMENT_SHADER_COLOR "gl_FragColor"
|
||||
#define FRAGMENT_SHADER_TEXTURE "texture2D"
|
||||
|
||||
@class EAGLContext;
|
||||
typedef EAGLContext GlContextType;
|
||||
#else
|
||||
#define RTC_PIXEL_FORMAT GL_RED
|
||||
#define SHADER_VERSION "#version 150\n"
|
||||
#define VERTEX_SHADER_IN "in"
|
||||
#define VERTEX_SHADER_OUT "out"
|
||||
#define FRAGMENT_SHADER_IN "in"
|
||||
#define FRAGMENT_SHADER_OUT "out vec4 fragColor;\n"
|
||||
#define FRAGMENT_SHADER_COLOR "fragColor"
|
||||
#define FRAGMENT_SHADER_TEXTURE "texture"
|
||||
|
||||
@class NSOpenGLContext;
|
||||
typedef NSOpenGLContext GlContextType;
|
||||
#endif
|
||||
@ -1,29 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import "RTCShader.h"
|
||||
|
||||
#import "WebRTC/RTCMacros.h"
|
||||
#import "WebRTC/RTCVideoFrame.h"
|
||||
|
||||
#if TARGET_OS_IPHONE
|
||||
#import <OpenGLES/ES3/gl.h>
|
||||
#else
|
||||
#import <OpenGL/gl3.h>
|
||||
#endif
|
||||
|
||||
RTC_EXTERN const char kRTCVertexShaderSource[];
|
||||
|
||||
RTC_EXTERN GLuint RTCCreateShader(GLenum type, const GLchar *source);
|
||||
RTC_EXTERN GLuint RTCCreateProgram(GLuint vertexShader, GLuint fragmentShader);
|
||||
RTC_EXTERN GLuint RTCCreateProgramFromFragmentSource(const char fragmentShaderSource[]);
|
||||
RTC_EXTERN BOOL RTCSetupVerticesForProgram(
|
||||
GLuint program, GLuint* vertexBuffer, GLuint* vertexArray);
|
||||
RTC_EXTERN void RTCSetVertexData(RTCVideoRotation rotation);
|
||||
@ -1,45 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
#import "RTCOpenGLDefines.h"
|
||||
|
||||
@class RTCVideoFrame;
|
||||
|
||||
@protocol RTCShader <NSObject>
|
||||
|
||||
- (BOOL)drawFrame:(RTCVideoFrame *)frame;
|
||||
|
||||
@end
|
||||
|
||||
// Shader for non-native I420 frames.
|
||||
@interface RTCI420Shader : NSObject <RTCShader>
|
||||
|
||||
- (instancetype)init NS_UNAVAILABLE;
|
||||
- (instancetype)initWithContext:(GlContextType *)context NS_DESIGNATED_INITIALIZER;
|
||||
- (BOOL)drawFrame:(RTCVideoFrame *)frame;
|
||||
|
||||
@end
|
||||
|
||||
// Native CVPixelBufferRef rendering is only supported on iPhone because it
|
||||
// depends on CVOpenGLESTextureCacheCreate.
|
||||
#if TARGET_OS_IPHONE
|
||||
|
||||
// Shader for native NV12 frames.
|
||||
@interface RTCNativeNV12Shader : NSObject <RTCShader>
|
||||
|
||||
- (instancetype)init NS_UNAVAILABLE;
|
||||
- (instancetype)initWithContext:(GlContextType *)context NS_DESIGNATED_INITIALIZER;
|
||||
- (BOOL)drawFrame:(RTCVideoFrame *)frame;
|
||||
|
||||
@end
|
||||
|
||||
#endif // TARGET_OS_IPHONE
|
||||
@ -1,184 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#import "RTCShader.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <memory>
|
||||
|
||||
#import "RTCShader+Private.h"
|
||||
|
||||
#include "webrtc/base/checks.h"
|
||||
#include "webrtc/base/logging.h"
|
||||
|
||||
// Vertex shader doesn't do anything except pass coordinates through.
|
||||
const char kRTCVertexShaderSource[] =
|
||||
SHADER_VERSION
|
||||
VERTEX_SHADER_IN " vec2 position;\n"
|
||||
VERTEX_SHADER_IN " vec2 texcoord;\n"
|
||||
VERTEX_SHADER_OUT " vec2 v_texcoord;\n"
|
||||
"void main() {\n"
|
||||
" gl_Position = vec4(position.x, position.y, 0.0, 1.0);\n"
|
||||
" v_texcoord = texcoord;\n"
|
||||
"}\n";
|
||||
|
||||
// Compiles a shader of the given |type| with GLSL source |source| and returns
|
||||
// the shader handle or 0 on error.
|
||||
GLuint RTCCreateShader(GLenum type, const GLchar *source) {
|
||||
GLuint shader = glCreateShader(type);
|
||||
if (!shader) {
|
||||
return 0;
|
||||
}
|
||||
glShaderSource(shader, 1, &source, NULL);
|
||||
glCompileShader(shader);
|
||||
GLint compileStatus = GL_FALSE;
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
|
||||
if (compileStatus == GL_FALSE) {
|
||||
GLint logLength = 0;
|
||||
// The null termination character is included in the returned log length.
|
||||
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
|
||||
if (logLength > 0) {
|
||||
std::unique_ptr<char[]> compileLog(new char[logLength]);
|
||||
// The returned string is null terminated.
|
||||
glGetShaderInfoLog(shader, logLength, NULL, compileLog.get());
|
||||
LOG(LS_ERROR) << "Shader compile error: " << compileLog.get();
|
||||
}
|
||||
glDeleteShader(shader);
|
||||
shader = 0;
|
||||
}
|
||||
return shader;
|
||||
}
|
||||
|
||||
// Links a shader program with the given vertex and fragment shaders and
|
||||
// returns the program handle or 0 on error.
|
||||
GLuint RTCCreateProgram(GLuint vertexShader, GLuint fragmentShader) {
|
||||
if (vertexShader == 0 || fragmentShader == 0) {
|
||||
return 0;
|
||||
}
|
||||
GLuint program = glCreateProgram();
|
||||
if (!program) {
|
||||
return 0;
|
||||
}
|
||||
glAttachShader(program, vertexShader);
|
||||
glAttachShader(program, fragmentShader);
|
||||
glLinkProgram(program);
|
||||
GLint linkStatus = GL_FALSE;
|
||||
glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
|
||||
if (linkStatus == GL_FALSE) {
|
||||
glDeleteProgram(program);
|
||||
program = 0;
|
||||
}
|
||||
return program;
|
||||
}
|
||||
|
||||
// Creates and links a shader program with the given fragment shader source and
|
||||
// a plain vertex shader. Returns the program handle or 0 on error.
|
||||
GLuint RTCCreateProgramFromFragmentSource(const char fragmentShaderSource[]) {
|
||||
GLuint vertexShader = RTCCreateShader(GL_VERTEX_SHADER, kRTCVertexShaderSource);
|
||||
RTC_CHECK(vertexShader) << "failed to create vertex shader";
|
||||
GLuint fragmentShader =
|
||||
RTCCreateShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
|
||||
RTC_CHECK(fragmentShader) << "failed to create fragment shader";
|
||||
GLuint program = RTCCreateProgram(vertexShader, fragmentShader);
|
||||
// Shaders are created only to generate program.
|
||||
if (vertexShader) {
|
||||
glDeleteShader(vertexShader);
|
||||
}
|
||||
if (fragmentShader) {
|
||||
glDeleteShader(fragmentShader);
|
||||
}
|
||||
return program;
|
||||
}
|
||||
|
||||
// Set vertex shader variables 'position' and 'texcoord' in |program| to use
|
||||
// |vertexBuffer| and |vertexArray| to store the vertex data.
|
||||
BOOL RTCSetupVerticesForProgram(GLuint program, GLuint* vertexBuffer, GLuint* vertexArray) {
|
||||
GLint position = glGetAttribLocation(program, "position");
|
||||
GLint texcoord = glGetAttribLocation(program, "texcoord");
|
||||
if (position < 0 || texcoord < 0) {
|
||||
return NO;
|
||||
}
|
||||
#if !TARGET_OS_IPHONE
|
||||
glGenVertexArrays(1, vertexArray);
|
||||
if (*vertexArray == 0) {
|
||||
return NO;
|
||||
}
|
||||
glBindVertexArray(*vertexArray);
|
||||
#endif
|
||||
glGenBuffers(1, vertexBuffer);
|
||||
if (*vertexBuffer == 0) {
|
||||
return NO;
|
||||
}
|
||||
glBindBuffer(GL_ARRAY_BUFFER, *vertexBuffer);
|
||||
glBufferData(GL_ARRAY_BUFFER, 4 * 4 * sizeof(GLfloat), NULL, GL_DYNAMIC_DRAW);
|
||||
|
||||
// Read position attribute with size of 2 and stride of 4 beginning at the
|
||||
// start of the array. The last argument indicates offset of data within the
|
||||
// vertex buffer.
|
||||
glVertexAttribPointer(position, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat),
|
||||
(void *)0);
|
||||
glEnableVertexAttribArray(position);
|
||||
|
||||
// Read texcoord attribute from |gVertices| with size of 2 and stride of 4
|
||||
// beginning at the first texcoord in the array. The last argument indicates
|
||||
// offset of data within |gVertices| as supplied to the vertex buffer.
|
||||
glVertexAttribPointer(texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat),
|
||||
(void *)(2 * sizeof(GLfloat)));
|
||||
glEnableVertexAttribArray(texcoord);
|
||||
|
||||
return YES;
|
||||
}
|
||||
|
||||
// Set vertex data to the currently bound vertex buffer.
|
||||
void RTCSetVertexData(RTCVideoRotation rotation) {
|
||||
// When modelview and projection matrices are identity (default) the world is
|
||||
// contained in the square around origin with unit size 2. Drawing to these
|
||||
// coordinates is equivalent to drawing to the entire screen. The texture is
|
||||
// stretched over that square using texture coordinates (u, v) that range
|
||||
// from (0, 0) to (1, 1) inclusive. Texture coordinates are flipped vertically
|
||||
// here because the incoming frame has origin in upper left hand corner but
|
||||
// OpenGL expects origin in bottom left corner.
|
||||
std::array<std::array<GLfloat, 2>, 4> UVCoords = {{
|
||||
{{0, 1}}, // Lower left.
|
||||
{{1, 1}}, // Lower right.
|
||||
{{1, 0}}, // Upper right.
|
||||
{{0, 0}}, // Upper left.
|
||||
}};
|
||||
|
||||
// Rotate the UV coordinates.
|
||||
int rotation_offset;
|
||||
switch (rotation) {
|
||||
case RTCVideoRotation_0:
|
||||
rotation_offset = 0;
|
||||
break;
|
||||
case RTCVideoRotation_90:
|
||||
rotation_offset = 1;
|
||||
break;
|
||||
case RTCVideoRotation_180:
|
||||
rotation_offset = 2;
|
||||
break;
|
||||
case RTCVideoRotation_270:
|
||||
rotation_offset = 3;
|
||||
break;
|
||||
}
|
||||
std::rotate(UVCoords.begin(), UVCoords.begin() + rotation_offset,
|
||||
UVCoords.end());
|
||||
|
||||
const GLfloat gVertices[] = {
|
||||
// X, Y, U, V.
|
||||
-1, -1, UVCoords[0][0], UVCoords[0][1],
|
||||
1, -1, UVCoords[1][0], UVCoords[1][1],
|
||||
1, 1, UVCoords[2][0], UVCoords[2][1],
|
||||
-1, 1, UVCoords[3][0], UVCoords[3][1],
|
||||
};
|
||||
|
||||
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(gVertices), gVertices);
|
||||
}
|
||||
@ -1,29 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include <set>
|
||||
|
||||
#import <AVFoundation/AVFoundation.h>
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
#include "webrtc/media/base/videocapturer.h"
|
||||
|
||||
namespace webrtc {
|
||||
// Mapping from AVCaptureDeviceFormat to cricket::VideoFormat for given input
|
||||
// device.
|
||||
std::set<cricket::VideoFormat> GetSupportedVideoFormatsForDevice(
|
||||
AVCaptureDevice* device);
|
||||
|
||||
// Sets device format for the provided capture device. Returns YES/NO depending
|
||||
// on success.
|
||||
bool SetFormatForCaptureDevice(AVCaptureDevice* device,
|
||||
AVCaptureSession* session,
|
||||
const cricket::VideoFormat& format);
|
||||
}
|
||||
@ -1,135 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include "avfoundationformatmapper.h"
|
||||
|
||||
#import "WebRTC/RTCLogging.h"
|
||||
|
||||
// TODO(denicija): add support for higher frame rates.
|
||||
// See http://crbug/webrtc/6355 for more info.
|
||||
static const int kFramesPerSecond = 30;
|
||||
|
||||
static inline BOOL IsMediaSubTypeSupported(FourCharCode mediaSubType) {
|
||||
return (mediaSubType == kCVPixelFormatType_420YpCbCr8PlanarFullRange ||
|
||||
mediaSubType == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange);
|
||||
}
|
||||
|
||||
static inline BOOL IsFrameRateWithinRange(int fps, AVFrameRateRange* range) {
|
||||
return range.minFrameRate <= fps && range.maxFrameRate >= fps;
|
||||
}
|
||||
|
||||
// Returns filtered array of device formats based on predefined constraints our
|
||||
// stack imposes.
|
||||
static NSArray<AVCaptureDeviceFormat*>* GetEligibleDeviceFormats(
|
||||
const AVCaptureDevice* device,
|
||||
int supportedFps) {
|
||||
NSMutableArray<AVCaptureDeviceFormat*>* eligibleDeviceFormats =
|
||||
[NSMutableArray array];
|
||||
|
||||
for (AVCaptureDeviceFormat* format in device.formats) {
|
||||
// Filter out subTypes that we currently don't support in the stack
|
||||
FourCharCode mediaSubType =
|
||||
CMFormatDescriptionGetMediaSubType(format.formatDescription);
|
||||
if (!IsMediaSubTypeSupported(mediaSubType)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Filter out frame rate ranges that we currently don't support in the stack
|
||||
for (AVFrameRateRange* frameRateRange in format.videoSupportedFrameRateRanges) {
|
||||
if (IsFrameRateWithinRange(supportedFps, frameRateRange)) {
|
||||
[eligibleDeviceFormats addObject:format];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return [eligibleDeviceFormats copy];
|
||||
}
|
||||
|
||||
// Mapping from cricket::VideoFormat to AVCaptureDeviceFormat.
|
||||
static AVCaptureDeviceFormat* GetDeviceFormatForVideoFormat(
|
||||
const AVCaptureDevice* device,
|
||||
const cricket::VideoFormat& videoFormat) {
|
||||
AVCaptureDeviceFormat* desiredDeviceFormat = nil;
|
||||
NSArray<AVCaptureDeviceFormat*>* eligibleFormats =
|
||||
GetEligibleDeviceFormats(device, videoFormat.framerate());
|
||||
|
||||
for (AVCaptureDeviceFormat* deviceFormat in eligibleFormats) {
|
||||
CMVideoDimensions dimension =
|
||||
CMVideoFormatDescriptionGetDimensions(deviceFormat.formatDescription);
|
||||
FourCharCode mediaSubType =
|
||||
CMFormatDescriptionGetMediaSubType(deviceFormat.formatDescription);
|
||||
|
||||
if (videoFormat.width == dimension.width &&
|
||||
videoFormat.height == dimension.height) {
|
||||
if (mediaSubType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange) {
|
||||
// This is the preferred format so no need to wait for better option.
|
||||
return deviceFormat;
|
||||
} else {
|
||||
// This is good candidate, but let's wait for something better.
|
||||
desiredDeviceFormat = deviceFormat;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return desiredDeviceFormat;
|
||||
}
|
||||
namespace webrtc {
|
||||
std::set<cricket::VideoFormat> GetSupportedVideoFormatsForDevice(
|
||||
AVCaptureDevice* device) {
|
||||
std::set<cricket::VideoFormat> supportedFormats;
|
||||
|
||||
NSArray<AVCaptureDeviceFormat*>* eligibleFormats =
|
||||
GetEligibleDeviceFormats(device, kFramesPerSecond);
|
||||
|
||||
for (AVCaptureDeviceFormat* deviceFormat in eligibleFormats) {
|
||||
CMVideoDimensions dimension =
|
||||
CMVideoFormatDescriptionGetDimensions(deviceFormat.formatDescription);
|
||||
cricket::VideoFormat format = cricket::VideoFormat(
|
||||
dimension.width, dimension.height,
|
||||
cricket::VideoFormat::FpsToInterval(kFramesPerSecond),
|
||||
cricket::FOURCC_NV12);
|
||||
supportedFormats.insert(format);
|
||||
}
|
||||
|
||||
return supportedFormats;
|
||||
}
|
||||
|
||||
bool SetFormatForCaptureDevice(AVCaptureDevice* device,
|
||||
AVCaptureSession* session,
|
||||
const cricket::VideoFormat& format) {
|
||||
AVCaptureDeviceFormat* deviceFormat =
|
||||
GetDeviceFormatForVideoFormat(device, format);
|
||||
const int fps = cricket::VideoFormat::IntervalToFps(format.interval);
|
||||
|
||||
NSError* error = nil;
|
||||
bool success = true;
|
||||
[session beginConfiguration];
|
||||
if ([device lockForConfiguration:&error]) {
|
||||
@try {
|
||||
device.activeFormat = deviceFormat;
|
||||
device.activeVideoMinFrameDuration = CMTimeMake(1, fps);
|
||||
} @catch (NSException* exception) {
|
||||
RTCLogError(@"Failed to set active format!\n User info:%@",
|
||||
exception.userInfo);
|
||||
success = false;
|
||||
}
|
||||
|
||||
[device unlockForConfiguration];
|
||||
} else {
|
||||
RTCLogError(@"Failed to lock device %@. Error: %@", device, error.userInfo);
|
||||
success = false;
|
||||
}
|
||||
[session commitConfiguration];
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
@ -1,72 +0,0 @@
|
||||
/*
|
||||
* Copyright 2015 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#ifndef WEBRTC_SDK_OBJC_FRAMEWORK_CLASSES_VIDEO_AVFOUNDATIONVIDEOCAPTURER_H_
|
||||
#define WEBRTC_SDK_OBJC_FRAMEWORK_CLASSES_VIDEO_AVFOUNDATIONVIDEOCAPTURER_H_
|
||||
|
||||
#import <AVFoundation/AVFoundation.h>
|
||||
|
||||
#include "webrtc/api/video/video_frame.h"
|
||||
#include "webrtc/common_video/include/i420_buffer_pool.h"
|
||||
#include "webrtc/media/base/videocapturer.h"
|
||||
|
||||
@class RTCAVFoundationVideoCapturerInternal;
|
||||
|
||||
namespace rtc {
|
||||
class Thread;
|
||||
} // namespace rtc
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
class AVFoundationVideoCapturer : public cricket::VideoCapturer {
|
||||
public:
|
||||
AVFoundationVideoCapturer();
|
||||
~AVFoundationVideoCapturer();
|
||||
|
||||
cricket::CaptureState Start(const cricket::VideoFormat& format) override;
|
||||
void Stop() override;
|
||||
bool IsRunning() override;
|
||||
bool IsScreencast() const override {
|
||||
return false;
|
||||
}
|
||||
bool GetPreferredFourccs(std::vector<uint32_t> *fourccs) override {
|
||||
fourccs->push_back(cricket::FOURCC_NV12);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Returns the active capture session. Calls to the capture session should
|
||||
// occur on the RTCDispatcherTypeCaptureSession queue in RTCDispatcher.
|
||||
AVCaptureSession* GetCaptureSession();
|
||||
|
||||
// Returns whether the rear-facing camera can be used.
|
||||
// e.g. It can't be used because it doesn't exist.
|
||||
bool CanUseBackCamera() const;
|
||||
|
||||
// Switches the camera being used (either front or back).
|
||||
void SetUseBackCamera(bool useBackCamera);
|
||||
bool GetUseBackCamera() const;
|
||||
|
||||
// Converts the sample buffer into a cricket::CapturedFrame and signals the
|
||||
// frame for capture.
|
||||
void CaptureSampleBuffer(CMSampleBufferRef sample_buffer,
|
||||
webrtc::VideoRotation rotation);
|
||||
|
||||
// Called to adjust the size of output frames to supplied |width| and
|
||||
// |height|. Also drops frames to make the output match |fps|.
|
||||
void AdaptOutputFormat(int width, int height, int fps);
|
||||
|
||||
private:
|
||||
RTCAVFoundationVideoCapturerInternal *_capturer;
|
||||
webrtc::I420BufferPool _buffer_pool;
|
||||
}; // AVFoundationVideoCapturer
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // WEBRTC_SDK_OBJC_FRAMEWORK_CLASSES_VIDEO_AVFOUNDATIONVIDEOCAPTURER_H_
|
||||
@ -1,176 +0,0 @@
|
||||
/*
|
||||
* Copyright 2015 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include "avfoundationvideocapturer.h"
|
||||
|
||||
#import <AVFoundation/AVFoundation.h>
|
||||
|
||||
#import "RTCAVFoundationVideoCapturerInternal.h"
|
||||
#import "RTCDispatcher+Private.h"
|
||||
#import "WebRTC/RTCLogging.h"
|
||||
|
||||
#include "avfoundationformatmapper.h"
|
||||
|
||||
#include "webrtc/api/video/video_rotation.h"
|
||||
#include "webrtc/base/bind.h"
|
||||
#include "webrtc/base/checks.h"
|
||||
#include "webrtc/base/logging.h"
|
||||
#include "webrtc/base/thread.h"
|
||||
#include "webrtc/sdk/objc/Framework/Classes/Video/corevideo_frame_buffer.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
enum AVFoundationVideoCapturerMessageType : uint32_t {
|
||||
kMessageTypeFrame,
|
||||
};
|
||||
|
||||
AVFoundationVideoCapturer::AVFoundationVideoCapturer() : _capturer(nil) {
|
||||
_capturer =
|
||||
[[RTCAVFoundationVideoCapturerInternal alloc] initWithCapturer:this];
|
||||
|
||||
std::set<cricket::VideoFormat> front_camera_video_formats =
|
||||
GetSupportedVideoFormatsForDevice([_capturer frontCaptureDevice]);
|
||||
std::set<cricket::VideoFormat> back_camera_video_formats =
|
||||
GetSupportedVideoFormatsForDevice([_capturer backCaptureDevice]);
|
||||
std::vector<cricket::VideoFormat> intersection_video_formats;
|
||||
if (back_camera_video_formats.empty()) {
|
||||
intersection_video_formats.assign(front_camera_video_formats.begin(),
|
||||
front_camera_video_formats.end());
|
||||
|
||||
} else if (front_camera_video_formats.empty()) {
|
||||
intersection_video_formats.assign(back_camera_video_formats.begin(),
|
||||
back_camera_video_formats.end());
|
||||
} else {
|
||||
std::set_intersection(
|
||||
front_camera_video_formats.begin(), front_camera_video_formats.end(),
|
||||
back_camera_video_formats.begin(), back_camera_video_formats.end(),
|
||||
std::back_inserter(intersection_video_formats));
|
||||
}
|
||||
SetSupportedFormats(intersection_video_formats);
|
||||
}
|
||||
|
||||
AVFoundationVideoCapturer::~AVFoundationVideoCapturer() {
|
||||
_capturer = nil;
|
||||
}
|
||||
|
||||
cricket::CaptureState AVFoundationVideoCapturer::Start(
|
||||
const cricket::VideoFormat& format) {
|
||||
if (!_capturer) {
|
||||
LOG(LS_ERROR) << "Failed to create AVFoundation capturer.";
|
||||
return cricket::CaptureState::CS_FAILED;
|
||||
}
|
||||
if (_capturer.isRunning) {
|
||||
LOG(LS_ERROR) << "The capturer is already running.";
|
||||
return cricket::CaptureState::CS_FAILED;
|
||||
}
|
||||
|
||||
AVCaptureDevice* device = [_capturer getActiveCaptureDevice];
|
||||
AVCaptureSession* session = _capturer.captureSession;
|
||||
|
||||
if (!SetFormatForCaptureDevice(device, session, format)) {
|
||||
return cricket::CaptureState::CS_FAILED;
|
||||
}
|
||||
|
||||
SetCaptureFormat(&format);
|
||||
// This isn't super accurate because it takes a while for the AVCaptureSession
|
||||
// to spin up, and this call returns async.
|
||||
// TODO(tkchin): make this better.
|
||||
[_capturer start];
|
||||
SetCaptureState(cricket::CaptureState::CS_RUNNING);
|
||||
|
||||
return cricket::CaptureState::CS_STARTING;
|
||||
}
|
||||
|
||||
void AVFoundationVideoCapturer::Stop() {
|
||||
[_capturer stop];
|
||||
SetCaptureFormat(NULL);
|
||||
}
|
||||
|
||||
bool AVFoundationVideoCapturer::IsRunning() {
|
||||
return _capturer.isRunning;
|
||||
}
|
||||
|
||||
AVCaptureSession* AVFoundationVideoCapturer::GetCaptureSession() {
|
||||
return _capturer.captureSession;
|
||||
}
|
||||
|
||||
bool AVFoundationVideoCapturer::CanUseBackCamera() const {
|
||||
return _capturer.canUseBackCamera;
|
||||
}
|
||||
|
||||
void AVFoundationVideoCapturer::SetUseBackCamera(bool useBackCamera) {
|
||||
_capturer.useBackCamera = useBackCamera;
|
||||
}
|
||||
|
||||
bool AVFoundationVideoCapturer::GetUseBackCamera() const {
|
||||
return _capturer.useBackCamera;
|
||||
}
|
||||
|
||||
void AVFoundationVideoCapturer::AdaptOutputFormat(int width, int height, int fps) {
|
||||
cricket::VideoFormat format(width, height, cricket::VideoFormat::FpsToInterval(fps), 0);
|
||||
video_adapter()->OnOutputFormatRequest(format);
|
||||
}
|
||||
|
||||
void AVFoundationVideoCapturer::CaptureSampleBuffer(
|
||||
CMSampleBufferRef sample_buffer, VideoRotation rotation) {
|
||||
if (CMSampleBufferGetNumSamples(sample_buffer) != 1 ||
|
||||
!CMSampleBufferIsValid(sample_buffer) ||
|
||||
!CMSampleBufferDataIsReady(sample_buffer)) {
|
||||
return;
|
||||
}
|
||||
|
||||
CVImageBufferRef image_buffer = CMSampleBufferGetImageBuffer(sample_buffer);
|
||||
if (image_buffer == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
int captured_width = CVPixelBufferGetWidth(image_buffer);
|
||||
int captured_height = CVPixelBufferGetHeight(image_buffer);
|
||||
|
||||
int adapted_width;
|
||||
int adapted_height;
|
||||
int crop_width;
|
||||
int crop_height;
|
||||
int crop_x;
|
||||
int crop_y;
|
||||
int64_t translated_camera_time_us;
|
||||
|
||||
if (!AdaptFrame(captured_width, captured_height,
|
||||
rtc::TimeNanos() / rtc::kNumNanosecsPerMicrosec,
|
||||
rtc::TimeMicros(), &adapted_width, &adapted_height,
|
||||
&crop_width, &crop_height, &crop_x, &crop_y,
|
||||
&translated_camera_time_us)) {
|
||||
return;
|
||||
}
|
||||
|
||||
rtc::scoped_refptr<VideoFrameBuffer> buffer =
|
||||
new rtc::RefCountedObject<CoreVideoFrameBuffer>(
|
||||
image_buffer,
|
||||
adapted_width, adapted_height,
|
||||
crop_width, crop_height,
|
||||
crop_x, crop_y);
|
||||
|
||||
// Applying rotation is only supported for legacy reasons and performance is
|
||||
// not critical here.
|
||||
if (apply_rotation() && rotation != kVideoRotation_0) {
|
||||
buffer = I420Buffer::Rotate(*buffer->NativeToI420Buffer(),
|
||||
rotation);
|
||||
if (rotation == kVideoRotation_90 || rotation == kVideoRotation_270) {
|
||||
std::swap(captured_width, captured_height);
|
||||
}
|
||||
|
||||
rotation = kVideoRotation_0;
|
||||
}
|
||||
|
||||
OnFrame(webrtc::VideoFrame(buffer, rotation, translated_camera_time_us),
|
||||
captured_width, captured_height);
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
@ -1,149 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include "webrtc/sdk/objc/Framework/Classes/Video/corevideo_frame_buffer.h"
|
||||
|
||||
#include "libyuv/convert.h"
|
||||
#include "webrtc/api/video/i420_buffer.h"
|
||||
#include "webrtc/base/checks.h"
|
||||
#include "webrtc/base/logging.h"
|
||||
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
CoreVideoFrameBuffer::CoreVideoFrameBuffer(CVPixelBufferRef pixel_buffer,
|
||||
int adapted_width,
|
||||
int adapted_height,
|
||||
int crop_width,
|
||||
int crop_height,
|
||||
int crop_x,
|
||||
int crop_y)
|
||||
: NativeHandleBuffer(pixel_buffer, adapted_width, adapted_height),
|
||||
pixel_buffer_(pixel_buffer),
|
||||
buffer_width_(CVPixelBufferGetWidth(pixel_buffer)),
|
||||
buffer_height_(CVPixelBufferGetHeight(pixel_buffer)),
|
||||
crop_width_(crop_width), crop_height_(crop_height),
|
||||
// Can only crop at even pixels.
|
||||
crop_x_(crop_x & ~1), crop_y_(crop_y & ~1) {
|
||||
CVBufferRetain(pixel_buffer_);
|
||||
}
|
||||
|
||||
CoreVideoFrameBuffer::CoreVideoFrameBuffer(CVPixelBufferRef pixel_buffer)
|
||||
: NativeHandleBuffer(pixel_buffer,
|
||||
CVPixelBufferGetWidth(pixel_buffer),
|
||||
CVPixelBufferGetHeight(pixel_buffer)),
|
||||
pixel_buffer_(pixel_buffer),
|
||||
buffer_width_(width_), buffer_height_(height_),
|
||||
crop_width_(width_), crop_height_(height_),
|
||||
crop_x_(0), crop_y_(0) {
|
||||
CVBufferRetain(pixel_buffer_);
|
||||
}
|
||||
|
||||
CoreVideoFrameBuffer::~CoreVideoFrameBuffer() {
|
||||
CVBufferRelease(pixel_buffer_);
|
||||
}
|
||||
|
||||
rtc::scoped_refptr<VideoFrameBuffer>
|
||||
CoreVideoFrameBuffer::NativeToI420Buffer() {
|
||||
const OSType pixel_format = CVPixelBufferGetPixelFormatType(pixel_buffer_);
|
||||
RTC_DCHECK(pixel_format == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange ||
|
||||
pixel_format == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange);
|
||||
|
||||
CVPixelBufferLockBaseAddress(pixel_buffer_, kCVPixelBufferLock_ReadOnly);
|
||||
const uint8_t* src_y = static_cast<const uint8_t*>(
|
||||
CVPixelBufferGetBaseAddressOfPlane(pixel_buffer_, 0));
|
||||
const int src_y_stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer_, 0);
|
||||
const uint8_t* src_uv = static_cast<const uint8_t*>(
|
||||
CVPixelBufferGetBaseAddressOfPlane(pixel_buffer_, 1));
|
||||
const int src_uv_stride =
|
||||
CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer_, 1);
|
||||
|
||||
// Crop just by modifying pointers.
|
||||
src_y += src_y_stride * crop_y_ + crop_x_;
|
||||
src_uv += src_uv_stride * (crop_y_ / 2) + crop_x_;
|
||||
|
||||
// TODO(magjed): Use a frame buffer pool.
|
||||
NV12ToI420Scaler nv12_to_i420_scaler;
|
||||
rtc::scoped_refptr<I420Buffer> buffer =
|
||||
new rtc::RefCountedObject<I420Buffer>(width_, height_);
|
||||
nv12_to_i420_scaler.NV12ToI420Scale(
|
||||
src_y, src_y_stride,
|
||||
src_uv, src_uv_stride,
|
||||
crop_width_, crop_height_,
|
||||
buffer->MutableDataY(), buffer->StrideY(),
|
||||
buffer->MutableDataU(), buffer->StrideU(),
|
||||
buffer->MutableDataV(), buffer->StrideV(),
|
||||
buffer->width(), buffer->height());
|
||||
|
||||
CVPixelBufferUnlockBaseAddress(pixel_buffer_, kCVPixelBufferLock_ReadOnly);
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
bool CoreVideoFrameBuffer::RequiresCropping() const {
|
||||
return crop_width_ != buffer_width_ || crop_height_ != buffer_height_;
|
||||
}
|
||||
|
||||
bool CoreVideoFrameBuffer::CropAndScaleTo(
|
||||
std::vector<uint8_t>* tmp_buffer,
|
||||
CVPixelBufferRef output_pixel_buffer) const {
|
||||
// Prepare output pointers.
|
||||
RTC_DCHECK_EQ(CVPixelBufferGetPixelFormatType(output_pixel_buffer),
|
||||
kCVPixelFormatType_420YpCbCr8BiPlanarFullRange);
|
||||
CVReturn cv_ret = CVPixelBufferLockBaseAddress(output_pixel_buffer, 0);
|
||||
if (cv_ret != kCVReturnSuccess) {
|
||||
LOG(LS_ERROR) << "Failed to lock base address: " << cv_ret;
|
||||
return false;
|
||||
}
|
||||
const int dst_width = CVPixelBufferGetWidth(output_pixel_buffer);
|
||||
const int dst_height = CVPixelBufferGetHeight(output_pixel_buffer);
|
||||
uint8_t* dst_y = reinterpret_cast<uint8_t*>(
|
||||
CVPixelBufferGetBaseAddressOfPlane(output_pixel_buffer, 0));
|
||||
const int dst_y_stride =
|
||||
CVPixelBufferGetBytesPerRowOfPlane(output_pixel_buffer, 0);
|
||||
uint8_t* dst_uv = reinterpret_cast<uint8_t*>(
|
||||
CVPixelBufferGetBaseAddressOfPlane(output_pixel_buffer, 1));
|
||||
const int dst_uv_stride =
|
||||
CVPixelBufferGetBytesPerRowOfPlane(output_pixel_buffer, 1);
|
||||
|
||||
// Prepare source pointers.
|
||||
const OSType src_pixel_format =
|
||||
CVPixelBufferGetPixelFormatType(pixel_buffer_);
|
||||
RTC_DCHECK(
|
||||
src_pixel_format == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange ||
|
||||
src_pixel_format == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange);
|
||||
CVPixelBufferLockBaseAddress(pixel_buffer_, kCVPixelBufferLock_ReadOnly);
|
||||
const uint8_t* src_y = static_cast<const uint8_t*>(
|
||||
CVPixelBufferGetBaseAddressOfPlane(pixel_buffer_, 0));
|
||||
const int src_y_stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer_, 0);
|
||||
const uint8_t* src_uv = static_cast<const uint8_t*>(
|
||||
CVPixelBufferGetBaseAddressOfPlane(pixel_buffer_, 1));
|
||||
const int src_uv_stride =
|
||||
CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer_, 1);
|
||||
|
||||
// Crop just by modifying pointers.
|
||||
src_y += src_y_stride * crop_y_ + crop_x_;
|
||||
src_uv += src_uv_stride * (crop_y_ / 2) + crop_x_;
|
||||
|
||||
NV12Scale(tmp_buffer,
|
||||
src_y, src_y_stride,
|
||||
src_uv, src_uv_stride,
|
||||
crop_width_, crop_height_,
|
||||
dst_y, dst_y_stride,
|
||||
dst_uv, dst_uv_stride,
|
||||
dst_width, dst_height);
|
||||
|
||||
CVPixelBufferUnlockBaseAddress(pixel_buffer_, kCVPixelBufferLock_ReadOnly);
|
||||
CVPixelBufferUnlockBaseAddress(output_pixel_buffer, 0);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
@ -1,59 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#ifndef WEBRTC_SDK_OBJC_FRAMEWORK_CLASSES_VIDEO_COREVIDEO_FRAME_BUFFER_H_
|
||||
#define WEBRTC_SDK_OBJC_FRAMEWORK_CLASSES_VIDEO_COREVIDEO_FRAME_BUFFER_H_
|
||||
|
||||
#include <CoreVideo/CoreVideo.h>
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "webrtc/common_video/include/video_frame_buffer.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
class CoreVideoFrameBuffer : public NativeHandleBuffer {
|
||||
public:
|
||||
explicit CoreVideoFrameBuffer(CVPixelBufferRef pixel_buffer);
|
||||
CoreVideoFrameBuffer(CVPixelBufferRef pixel_buffer,
|
||||
int adapted_width,
|
||||
int adapted_height,
|
||||
int crop_width,
|
||||
int crop_height,
|
||||
int crop_x,
|
||||
int crop_y);
|
||||
~CoreVideoFrameBuffer() override;
|
||||
|
||||
rtc::scoped_refptr<VideoFrameBuffer> NativeToI420Buffer() override;
|
||||
// Returns true if the internal pixel buffer needs to be cropped.
|
||||
bool RequiresCropping() const;
|
||||
// Crop and scales the internal pixel buffer to the output pixel buffer. The
|
||||
// tmp buffer is used for intermediary splitting the UV channels. This
|
||||
// function returns true if successful.
|
||||
bool CropAndScaleTo(std::vector<uint8_t>* tmp_buffer,
|
||||
CVPixelBufferRef output_pixel_buffer) const;
|
||||
|
||||
private:
|
||||
CVPixelBufferRef pixel_buffer_;
|
||||
// buffer_width/height is the actual pixel buffer resolution. The width/height
|
||||
// in NativeHandleBuffer, i.e. width()/height(), is the resolution we will
|
||||
// scale to in NativeToI420Buffer(). Cropping happens before scaling, so:
|
||||
// buffer_width >= crop_width >= width().
|
||||
const int buffer_width_;
|
||||
const int buffer_height_;
|
||||
const int crop_width_;
|
||||
const int crop_height_;
|
||||
const int crop_x_;
|
||||
const int crop_y_;
|
||||
};
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // WEBRTC_SDK_OBJC_FRAMEWORK_CLASSES_VIDEO_COREVIDEO_FRAME_BUFFER_H_
|
||||
@ -1,52 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#ifndef WEBRTC_SDK_OBJC_FRAMEWORK_CLASSES_VIDEO_OBJCVIDEOTRACKSOURCE_H_
|
||||
#define WEBRTC_SDK_OBJC_FRAMEWORK_CLASSES_VIDEO_OBJCVIDEOTRACKSOURCE_H_
|
||||
|
||||
#include "WebRTC/RTCMacros.h"
|
||||
#include "webrtc/base/timestampaligner.h"
|
||||
#include "webrtc/media/base/adaptedvideotracksource.h"
|
||||
|
||||
RTC_FWD_DECL_OBJC_CLASS(RTCVideoFrame);
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
class ObjcVideoTrackSource : public rtc::AdaptedVideoTrackSource {
|
||||
public:
|
||||
ObjcVideoTrackSource();
|
||||
|
||||
// This class can not be used for implementing screen casting. Hopefully, this
|
||||
// function will be removed before we add that to iOS/Mac.
|
||||
bool is_screencast() const override { return false; }
|
||||
|
||||
// Indicates that the encoder should denoise video before encoding it.
|
||||
// If it is not set, the default configuration is used which is different
|
||||
// depending on video codec.
|
||||
rtc::Optional<bool> needs_denoising() const override {
|
||||
return rtc::Optional<bool>(false);
|
||||
}
|
||||
|
||||
SourceState state() const override { return SourceState::kLive; }
|
||||
|
||||
bool remote() const override { return false; }
|
||||
|
||||
// Called by RTCVideoSource.
|
||||
void OnCapturedFrame(RTCVideoFrame* frame);
|
||||
void OnOutputFormatRequest(int width, int height, int fps);
|
||||
|
||||
private:
|
||||
rtc::VideoBroadcaster broadcaster_;
|
||||
rtc::TimestampAligner timestamp_aligner_;
|
||||
};
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // WEBRTC_SDK_OBJC_FRAMEWORK_CLASSES_VIDEO_OBJCVIDEOTRACKSOURCE_H_
|
||||
@ -1,71 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include "webrtc/sdk/objc/Framework/Classes/Video/objcvideotracksource.h"
|
||||
|
||||
#import "RTCVideoFrame+Private.h"
|
||||
|
||||
#include "webrtc/api/video/i420_buffer.h"
|
||||
#include "webrtc/sdk/objc/Framework/Classes/Video/corevideo_frame_buffer.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
ObjcVideoTrackSource::ObjcVideoTrackSource() {}
|
||||
|
||||
void ObjcVideoTrackSource::OnOutputFormatRequest(int width, int height, int fps) {
|
||||
cricket::VideoFormat format(width, height, cricket::VideoFormat::FpsToInterval(fps), 0);
|
||||
video_adapter()->OnOutputFormatRequest(format);
|
||||
}
|
||||
|
||||
void ObjcVideoTrackSource::OnCapturedFrame(RTCVideoFrame* frame) {
|
||||
const int64_t timestamp_us = frame.timeStampNs / rtc::kNumNanosecsPerMicrosec;
|
||||
const int64_t translated_timestamp_us =
|
||||
timestamp_aligner_.TranslateTimestamp(timestamp_us, rtc::TimeMicros());
|
||||
|
||||
int adapted_width;
|
||||
int adapted_height;
|
||||
int crop_width;
|
||||
int crop_height;
|
||||
int crop_x;
|
||||
int crop_y;
|
||||
if (!AdaptFrame(frame.width, frame.height, timestamp_us, &adapted_width, &adapted_height,
|
||||
&crop_width, &crop_height, &crop_x, &crop_y)) {
|
||||
return;
|
||||
}
|
||||
|
||||
rtc::scoped_refptr<VideoFrameBuffer> buffer;
|
||||
if (adapted_width == frame.width && adapted_height == frame.height) {
|
||||
// No adaption - optimized path.
|
||||
buffer = frame.videoBuffer;
|
||||
} else if (frame.nativeHandle) {
|
||||
// Adapted CVPixelBuffer frame.
|
||||
buffer = new rtc::RefCountedObject<CoreVideoFrameBuffer>(
|
||||
static_cast<CVPixelBufferRef>(frame.nativeHandle), adapted_width, adapted_height,
|
||||
crop_width, crop_height, crop_x, crop_y);
|
||||
} else {
|
||||
// Adapted I420 frame.
|
||||
// TODO(magjed): Optimize this I420 path.
|
||||
rtc::scoped_refptr<I420Buffer> i420_buffer = I420Buffer::Create(adapted_width, adapted_height);
|
||||
i420_buffer->CropAndScaleFrom(*frame.videoBuffer, crop_x, crop_y, crop_width, crop_height);
|
||||
buffer = i420_buffer;
|
||||
}
|
||||
|
||||
// Applying rotation is only supported for legacy reasons and performance is
|
||||
// not critical here.
|
||||
webrtc::VideoRotation rotation = static_cast<webrtc::VideoRotation>(frame.rotation);
|
||||
if (apply_rotation() && rotation != kVideoRotation_0) {
|
||||
buffer = I420Buffer::Rotate(*buffer->NativeToI420Buffer(), rotation);
|
||||
rotation = kVideoRotation_0;
|
||||
}
|
||||
|
||||
OnFrame(webrtc::VideoFrame(buffer, rotation, translated_timestamp_us));
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
Reference in New Issue
Block a user