492 lines
16 KiB
Plaintext
492 lines
16 KiB
Plaintext
/*
|
|
* 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.
|
|
*/
|
|
|
|
#import "GLVideoViewMac.h"
|
|
|
|
#import "TGRTCCVPixelBuffer.h"
|
|
|
|
#import <GLKit/GLKit.h>
|
|
|
|
#import "RTCDefaultShader.h"
|
|
#import "RTCDisplayLinkTimer.h"
|
|
#import "RTCI420TextureCache.h"
|
|
#import "base/RTCLogging.h"
|
|
#import "base/RTCVideoFrame.h"
|
|
#import "base/RTCVideoFrameBuffer.h"
|
|
#import "components/video_frame_buffer/RTCCVPixelBuffer.h"
|
|
#include "sdk/objc/native/api/video_frame.h"
|
|
#import "rtc_base/time_utils.h"
|
|
#include "sdk/objc/native/src/objc_frame_buffer.h"
|
|
|
|
namespace {
|
|
|
|
static RTCVideoFrame *customToObjCVideoFrame(const webrtc::VideoFrame &frame, RTCVideoRotation &rotation) {
|
|
rotation = RTCVideoRotation(frame.rotation());
|
|
RTCVideoFrame *videoFrame =
|
|
[[RTCVideoFrame alloc] initWithBuffer:webrtc::ToObjCVideoFrameBuffer(frame.video_frame_buffer())
|
|
rotation:rotation
|
|
timeStampNs:frame.timestamp_us() * rtc::kNumNanosecsPerMicrosec];
|
|
videoFrame.timeStamp = frame.timestamp();
|
|
|
|
return videoFrame;
|
|
}
|
|
|
|
class VideoRendererAdapterImpl : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
|
|
public:
|
|
VideoRendererAdapterImpl(void (^frameReceived)(CGSize, RTCVideoFrame *, RTCVideoRotation)) {
|
|
_frameReceived = [frameReceived copy];
|
|
}
|
|
|
|
void OnFrame(const webrtc::VideoFrame& nativeVideoFrame) override {
|
|
RTCVideoRotation rotation = RTCVideoRotation_0;
|
|
RTCVideoFrame* videoFrame = customToObjCVideoFrame(nativeVideoFrame, rotation);
|
|
|
|
CGSize currentSize = (videoFrame.rotation % 180 == 0) ? CGSizeMake(videoFrame.width, videoFrame.height) : CGSizeMake(videoFrame.height, videoFrame.width);
|
|
|
|
if (_frameReceived) {
|
|
_frameReceived(currentSize, videoFrame, rotation);
|
|
}
|
|
}
|
|
|
|
private:
|
|
void (^_frameReceived)(CGSize, RTCVideoFrame *, RTCVideoRotation);
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
static CGSize scaleToFillSize(CGSize size, CGSize maxSize) {
|
|
if (size.width < 1.0f) {
|
|
size.width = 1.0f;
|
|
}
|
|
if (size.height < 1.0f) {
|
|
size.height = 1.0f;
|
|
}
|
|
if (size.width < maxSize.width) {
|
|
size.height = floor(maxSize.width * size.height / MAX(1.0f, size.width));
|
|
size.width = maxSize.width;
|
|
}
|
|
if (size.height < maxSize.height) {
|
|
size.width = floor(maxSize.height * size.width / MAX(1.0f, size.height));
|
|
size.height = maxSize.height;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
static CGSize aspectFilled(CGSize from, CGSize to) {
|
|
CGFloat scale = MAX(from.width / MAX(1.0, to.width), from.height / MAX(1.0, to.height));
|
|
return NSMakeSize(ceil(to.width * scale), ceil(to.height * scale));
|
|
}
|
|
static CGSize aspectFitted(CGSize from, CGSize to) {
|
|
CGFloat scale = MAX(from.width / MAX(1.0, to.width), from.height / MAX(1.0, to.height));
|
|
return NSMakeSize(ceil(to.width * scale), ceil(to.height * scale));
|
|
}
|
|
|
|
/*
|
|
|
|
func aspectFilled(_ size: CGSize) -> CGSize {
|
|
let scale = max(size.width / max(1.0, self.width), size.height / max(1.0, self.height))
|
|
return CGSize(width: ceil(self.width * scale), height: ceil(self.height * scale))
|
|
}
|
|
func fittedToWidthOrSmaller(_ width: CGFloat) -> CGSize {
|
|
let scale = min(1.0, width / max(1.0, self.width))
|
|
return CGSize(width: floor(self.width * scale), height: floor(self.height * scale))
|
|
}
|
|
|
|
func aspectFitted(_ size: CGSize) -> CGSize {
|
|
let scale = min(size.width / max(1.0, self.width), size.height / max(1.0, self.height))
|
|
return CGSize(width: ceil(self.width * scale), height: ceil(self.height * scale))
|
|
}
|
|
*/
|
|
|
|
|
|
#if !TARGET_OS_IPHONE
|
|
|
|
@interface OpenGLVideoView : NSOpenGLView
|
|
@property(atomic, strong) RTCVideoFrame *videoFrame;
|
|
@property(atomic, strong) RTCI420TextureCache *i420TextureCache;
|
|
|
|
- (void)drawFrame;
|
|
- (instancetype)initWithFrame:(NSRect)frame
|
|
pixelFormat:(NSOpenGLPixelFormat *)format
|
|
shader:(id<RTCVideoViewShading>)shader;
|
|
@end
|
|
|
|
static CVReturn OnDisplayLinkFired(CVDisplayLinkRef displayLink,
|
|
const CVTimeStamp *now,
|
|
const CVTimeStamp *outputTime,
|
|
CVOptionFlags flagsIn,
|
|
CVOptionFlags *flagsOut,
|
|
void *displayLinkContext) {
|
|
OpenGLVideoView *view =
|
|
(__bridge OpenGLVideoView *)displayLinkContext;
|
|
[view drawFrame];
|
|
return kCVReturnSuccess;
|
|
}
|
|
|
|
|
|
@implementation OpenGLVideoView {
|
|
CVDisplayLinkRef _displayLink;
|
|
RTCVideoFrame * _lastDrawnFrame;
|
|
id<RTCVideoViewShading> _shader;
|
|
|
|
int64_t _lastDrawnFrameTimeStampNs;
|
|
void (^_onFirstFrameReceived)(float);
|
|
bool _firstFrameReceivedReported;
|
|
}
|
|
|
|
@synthesize videoFrame = _videoFrame;
|
|
@synthesize i420TextureCache = _i420TextureCache;
|
|
|
|
- (instancetype)initWithFrame:(NSRect)frame
|
|
pixelFormat:(NSOpenGLPixelFormat *)format
|
|
shader:(id<RTCVideoViewShading>)shader {
|
|
if (self = [super initWithFrame:frame pixelFormat:format]) {
|
|
self->_shader = shader;
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (void)reshape {
|
|
[super reshape];
|
|
NSRect frame = [self frame];
|
|
[self ensureGLContext];
|
|
CGLLockContext([[self openGLContext] CGLContextObj]);
|
|
glViewport(0, 0, frame.size.width, frame.size.height);
|
|
CGLUnlockContext([[self openGLContext] CGLContextObj]);
|
|
}
|
|
|
|
- (void)lockFocus {
|
|
NSOpenGLContext *context = [self openGLContext];
|
|
[super lockFocus];
|
|
if ([context view] != self) {
|
|
[context setView:self];
|
|
}
|
|
[context makeCurrentContext];
|
|
}
|
|
|
|
- (void)prepareOpenGL {
|
|
[super prepareOpenGL];
|
|
[self ensureGLContext];
|
|
glDisable(GL_DITHER);
|
|
[self setupDisplayLink];
|
|
}
|
|
|
|
- (void)clearGLContext {
|
|
[self ensureGLContext];
|
|
self.i420TextureCache = nil;
|
|
[super clearGLContext];
|
|
}
|
|
|
|
- (void)drawRect:(NSRect)rect {
|
|
[self drawFrame];
|
|
}
|
|
|
|
- (void)drawFrame {
|
|
RTCVideoFrame *frame = self.videoFrame;
|
|
if (!frame || frame == _lastDrawnFrame) {
|
|
return;
|
|
}
|
|
// This method may be called from CVDisplayLink callback which isn't on the
|
|
// main thread so we have to lock the GL context before drawing.
|
|
NSOpenGLContext *context = [self openGLContext];
|
|
CGLLockContext([context CGLContextObj]);
|
|
|
|
[self ensureGLContext];
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
|
|
// Rendering native CVPixelBuffer is not supported on OS X.
|
|
// TODO(magjed): Add support for NV12 texture cache on OS X.
|
|
frame = [frame newI420VideoFrame];
|
|
if (!self.i420TextureCache) {
|
|
self.i420TextureCache = [[RTCI420TextureCache alloc] initWithContext:context];
|
|
}
|
|
RTCVideoRotation rotation = frame.rotation;
|
|
|
|
RTCI420TextureCache *i420TextureCache = self.i420TextureCache;
|
|
if (i420TextureCache) {
|
|
[i420TextureCache uploadFrameToTextures:frame];
|
|
[_shader applyShadingForFrameWithWidth:frame.width
|
|
height:frame.height
|
|
rotation:rotation
|
|
yPlane:i420TextureCache.yTexture
|
|
uPlane:i420TextureCache.uTexture
|
|
vPlane:i420TextureCache.vTexture];
|
|
[context flushBuffer];
|
|
_lastDrawnFrame = frame;
|
|
}
|
|
CGLUnlockContext([context CGLContextObj]);
|
|
|
|
if (!_firstFrameReceivedReported && _onFirstFrameReceived) {
|
|
_firstFrameReceivedReported = true;
|
|
float aspectRatio = (float)frame.width / (float)frame.height;
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
self->_onFirstFrameReceived(aspectRatio);
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
|
|
- (void)setupDisplayLink {
|
|
if (_displayLink) {
|
|
return;
|
|
}
|
|
// Synchronize buffer swaps with vertical refresh rate.
|
|
GLint swapInt = 1;
|
|
[[self openGLContext] setValues:&swapInt forParameter:NSOpenGLCPSwapInterval];
|
|
|
|
// Create display link.
|
|
CVDisplayLinkCreateWithActiveCGDisplays(&_displayLink);
|
|
CVDisplayLinkSetOutputCallback(_displayLink,
|
|
&OnDisplayLinkFired,
|
|
(__bridge void *)self);
|
|
// Set the display link for the current renderer.
|
|
CGLContextObj cglContext = [[self openGLContext] CGLContextObj];
|
|
CGLPixelFormatObj cglPixelFormat = [[self pixelFormat] CGLPixelFormatObj];
|
|
CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(
|
|
_displayLink, cglContext, cglPixelFormat);
|
|
CVDisplayLinkStart(_displayLink);
|
|
}
|
|
|
|
-(void)setFrameOrigin:(NSPoint)newOrigin {
|
|
[super setFrameOrigin:newOrigin];
|
|
}
|
|
|
|
- (void)teardownDisplayLink {
|
|
if (!_displayLink) {
|
|
return;
|
|
}
|
|
CVDisplayLinkRelease(_displayLink);
|
|
_displayLink = NULL;
|
|
}
|
|
|
|
- (void)ensureGLContext {
|
|
NSOpenGLContext* context = [self openGLContext];
|
|
NSAssert(context, @"context shouldn't be nil");
|
|
if ([NSOpenGLContext currentContext] != context) {
|
|
[context makeCurrentContext];
|
|
}
|
|
}
|
|
|
|
- (void)dealloc {
|
|
[self teardownDisplayLink];
|
|
}
|
|
|
|
- (void)setOnFirstFrameReceived:(void (^ _Nullable)(float))onFirstFrameReceived {
|
|
_onFirstFrameReceived = [onFirstFrameReceived copy];
|
|
_firstFrameReceivedReported = false;
|
|
}
|
|
|
|
|
|
@end
|
|
|
|
|
|
|
|
|
|
@interface GLVideoView ()
|
|
@property(nonatomic, strong) OpenGLVideoView *glView;
|
|
@end
|
|
|
|
@implementation GLVideoView {
|
|
|
|
CGSize _currentSize;
|
|
|
|
std::shared_ptr<VideoRendererAdapterImpl> _sink;
|
|
|
|
void (^_onOrientationUpdated)(int);
|
|
void (^_onIsMirroredUpdated)(bool);
|
|
|
|
bool _didSetShouldBeMirrored;
|
|
bool _shouldBeMirrored;
|
|
bool _forceMirrored;
|
|
|
|
}
|
|
|
|
@synthesize delegate = _delegate;
|
|
|
|
-(instancetype)initWithFrame:(NSRect)frameRect {
|
|
NSOpenGLPixelFormatAttribute attributes[] = {
|
|
NSOpenGLPFADoubleBuffer,
|
|
NSOpenGLPFADepthSize, 24,
|
|
NSOpenGLPFAOpenGLProfile,
|
|
NSOpenGLProfileVersion3_2Core,
|
|
0
|
|
};
|
|
NSOpenGLPixelFormat* pixelFormat =
|
|
[[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
|
|
return [self initWithFrame:frameRect pixelFormat: pixelFormat];
|
|
}
|
|
|
|
- (instancetype)initWithFrame:(NSRect)frame pixelFormat:(NSOpenGLPixelFormat *)format {
|
|
return [self initWithFrame:frame pixelFormat:format shader:[[RTCDefaultShader alloc] init]];
|
|
}
|
|
|
|
- (instancetype)initWithFrame:(NSRect)frame
|
|
pixelFormat:(NSOpenGLPixelFormat *)format
|
|
shader:(id<RTCVideoViewShading>)shader {
|
|
if (self = [super initWithFrame:frame]) {
|
|
|
|
_glView = [[OpenGLVideoView alloc] initWithFrame:frame pixelFormat:format shader:shader];
|
|
_glView.wantsLayer = YES;
|
|
self.layerContentsRedrawPolicy = NSViewLayerContentsRedrawDuringViewResize;
|
|
_glView.layerContentsRedrawPolicy = NSViewLayerContentsRedrawDuringViewResize;
|
|
|
|
[self addSubview:_glView];
|
|
|
|
__weak GLVideoView *weakSelf = self;
|
|
|
|
self.wantsLayer = YES;
|
|
|
|
_sink.reset(new VideoRendererAdapterImpl(^(CGSize size, RTCVideoFrame *videoFrame, RTCVideoRotation rotation) {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
__strong GLVideoView *strongSelf = weakSelf;
|
|
if (strongSelf == nil) {
|
|
return;
|
|
}
|
|
if (!CGSizeEqualToSize(size, strongSelf->_currentSize)) {
|
|
strongSelf->_currentSize = size;
|
|
[strongSelf setSize:size];
|
|
}
|
|
|
|
int mappedValue = 0;
|
|
switch (rotation) {
|
|
case RTCVideoRotation_90:
|
|
mappedValue = 0;
|
|
break;
|
|
case RTCVideoRotation_180:
|
|
mappedValue = 1;
|
|
break;
|
|
case RTCVideoRotation_270:
|
|
mappedValue = 2;
|
|
break;
|
|
default:
|
|
mappedValue = 0;
|
|
break;
|
|
}
|
|
[strongSelf setInternalOrientation:mappedValue];
|
|
|
|
[strongSelf renderFrame:videoFrame];
|
|
});
|
|
}));
|
|
}
|
|
return self;
|
|
}
|
|
|
|
|
|
|
|
- (CALayerContentsGravity)videoContentMode {
|
|
return self.glView.layer.contentsGravity;
|
|
}
|
|
|
|
- (void)setVideoContentMode:(CALayerContentsGravity)mode {
|
|
self.glView.layer.contentsGravity = mode;
|
|
[self setNeedsLayout:YES];
|
|
}
|
|
|
|
-(void)layout {
|
|
[super layout];
|
|
|
|
if (self.bounds.size.width > 0.0f && _currentSize.width > 0) {
|
|
|
|
NSSize size = _currentSize;
|
|
NSSize frameSize = self.frame.size;
|
|
if ( self.glView.layer.contentsGravity == kCAGravityResizeAspectFill) {
|
|
size = aspectFitted(frameSize, _currentSize);
|
|
} else {
|
|
size = aspectFilled(frameSize, _currentSize);
|
|
}
|
|
_glView.frame = CGRectMake(floor((self.bounds.size.width - size.width) / 2.0), floor((self.bounds.size.height - size.height) / 2.0), size.width, size.height);
|
|
}
|
|
|
|
if (_shouldBeMirrored || _forceMirrored) {
|
|
self.glView.layer.anchorPoint = NSMakePoint(1, 0);
|
|
self.glView.layer.affineTransform = CGAffineTransformMakeScale(-1, 1);
|
|
} else {
|
|
self.glView.layer.anchorPoint = NSMakePoint(0, 0);
|
|
self.glView.layer.affineTransform = CGAffineTransformIdentity;
|
|
}
|
|
}
|
|
|
|
- (void)setSize:(CGSize)size {
|
|
[self.delegate videoView:self didChangeVideoSize:size];
|
|
[self setNeedsLayout:YES];
|
|
}
|
|
|
|
- (void)renderFrame:(RTCVideoFrame *)videoFrame {
|
|
self.glView.videoFrame = videoFrame;
|
|
|
|
if ([videoFrame.buffer isKindOfClass:[RTCCVPixelBuffer class]]) {
|
|
RTCCVPixelBuffer *buffer = (RTCCVPixelBuffer*)videoFrame.buffer;
|
|
if ([buffer isKindOfClass:[TGRTCCVPixelBuffer class]]) {
|
|
bool shouldBeMirrored = ((TGRTCCVPixelBuffer *)buffer).shouldBeMirrored;
|
|
if (shouldBeMirrored != _shouldBeMirrored) {
|
|
_shouldBeMirrored = shouldBeMirrored;
|
|
if (shouldBeMirrored || _forceMirrored) {
|
|
self.glView.layer.anchorPoint = NSMakePoint(1, 0);
|
|
self.glView.layer.affineTransform = CGAffineTransformMakeScale(-1, 1);
|
|
} else {
|
|
self.glView.layer.anchorPoint = NSMakePoint(0, 0);
|
|
self.glView.layer.affineTransform = CGAffineTransformIdentity;
|
|
}
|
|
}
|
|
|
|
if (shouldBeMirrored != _shouldBeMirrored) {
|
|
if (_didSetShouldBeMirrored) {
|
|
if (_onIsMirroredUpdated) {
|
|
_onIsMirroredUpdated(_shouldBeMirrored);
|
|
}
|
|
} else {
|
|
_didSetShouldBeMirrored = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#pragma mark - Private
|
|
|
|
|
|
|
|
- (std::shared_ptr<rtc::VideoSinkInterface<webrtc::VideoFrame>>)getSink {
|
|
assert([NSThread isMainThread]);
|
|
|
|
return _sink;
|
|
}
|
|
|
|
- (void)setOnFirstFrameReceived:(void (^ _Nullable)(float))onFirstFrameReceived {
|
|
[self.glView setOnFirstFrameReceived:onFirstFrameReceived];
|
|
}
|
|
|
|
- (void)setInternalOrientation:(int)internalOrientation {
|
|
_internalOrientation = internalOrientation;
|
|
if (_onOrientationUpdated) {
|
|
_onOrientationUpdated(internalOrientation);
|
|
}
|
|
}
|
|
|
|
- (void)internalSetOnOrientationUpdated:(void (^ _Nullable)(int))onOrientationUpdated {
|
|
_onOrientationUpdated = [onOrientationUpdated copy];
|
|
}
|
|
|
|
- (void)internalSetOnIsMirroredUpdated:(void (^ _Nullable)(bool))onIsMirroredUpdated {
|
|
}
|
|
|
|
- (void)setIsForceMirrored:(BOOL)forceMirrored {
|
|
_forceMirrored = forceMirrored;
|
|
[self setNeedsLayout:YES];
|
|
}
|
|
|
|
@end
|
|
|
|
#endif // !TARGET_OS_IPHONE
|