mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-15 06:40:43 +01:00
7e04281870
When injecting video codec factories in the Obj-C SDK, use the new
peer connection API that uses webrtc::Video{De,En}CoderFactory classes
and does not automatically add internal software codecs. Instead the
injected factory can support internal VP8 and VP9 codecs through the
included Obj-C classes RTCVideo{De,En}coderVP{8,9}.
When not explicitly injecting any video codec factory, the old code
path is still used and injects only H264 as an external codec and
the internal codec factory is used.
Bug: webrtc:7925
Change-Id: I657d30dfde71da9c0be341e213ab9f97a04caa58
Reviewed-on: https://webrtc-review.googlesource.com/3620
Commit-Queue: Anders Carlsson <andersc@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20175}
115 lines
4.1 KiB
Text
115 lines
4.1 KiB
Text
/*
|
|
* 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 "RTCVideoFrame+Private.h"
|
|
|
|
#import "WebRTC/RTCVideoFrame.h"
|
|
#import "WebRTC/RTCVideoFrameBuffer.h"
|
|
|
|
#include "api/video/video_frame.h"
|
|
#include "rtc_base/timeutils.h"
|
|
|
|
id<RTCVideoFrameBuffer> nativeToRtcFrameBuffer(
|
|
const rtc::scoped_refptr<webrtc::VideoFrameBuffer> &buffer) {
|
|
return buffer->type() == webrtc::VideoFrameBuffer::Type::kNative ?
|
|
static_cast<webrtc::ObjCFrameBuffer *>(buffer.get())->wrapped_frame_buffer() :
|
|
[[RTCI420Buffer alloc] initWithFrameBuffer:buffer->ToI420()];
|
|
}
|
|
|
|
@implementation RTCVideoFrame {
|
|
RTCVideoRotation _rotation;
|
|
int64_t _timeStampNs;
|
|
}
|
|
|
|
@synthesize buffer = _buffer;
|
|
@synthesize timeStamp;
|
|
|
|
- (int)width {
|
|
return _buffer.width;
|
|
}
|
|
|
|
- (int)height {
|
|
return _buffer.height;
|
|
}
|
|
|
|
- (RTCVideoRotation)rotation {
|
|
return _rotation;
|
|
}
|
|
|
|
- (int64_t)timeStampNs {
|
|
return _timeStampNs;
|
|
}
|
|
|
|
- (RTCVideoFrame *)newI420VideoFrame {
|
|
return [[RTCVideoFrame alloc] initWithBuffer:[_buffer toI420]
|
|
rotation:_rotation
|
|
timeStampNs:_timeStampNs];
|
|
}
|
|
|
|
- (instancetype)initWithPixelBuffer:(CVPixelBufferRef)pixelBuffer
|
|
rotation:(RTCVideoRotation)rotation
|
|
timeStampNs:(int64_t)timeStampNs {
|
|
return [self initWithBuffer:[[RTCCVPixelBuffer alloc] initWithPixelBuffer:pixelBuffer]
|
|
rotation:rotation
|
|
timeStampNs:timeStampNs];
|
|
}
|
|
|
|
- (instancetype)initWithPixelBuffer:(CVPixelBufferRef)pixelBuffer
|
|
scaledWidth:(int)scaledWidth
|
|
scaledHeight:(int)scaledHeight
|
|
cropWidth:(int)cropWidth
|
|
cropHeight:(int)cropHeight
|
|
cropX:(int)cropX
|
|
cropY:(int)cropY
|
|
rotation:(RTCVideoRotation)rotation
|
|
timeStampNs:(int64_t)timeStampNs {
|
|
RTCCVPixelBuffer *rtcPixelBuffer = [[RTCCVPixelBuffer alloc] initWithPixelBuffer:pixelBuffer
|
|
adaptedWidth:scaledWidth
|
|
adaptedHeight:scaledHeight
|
|
cropWidth:cropWidth
|
|
cropHeight:cropHeight
|
|
cropX:cropX
|
|
cropY:cropY];
|
|
return [self initWithBuffer:rtcPixelBuffer rotation:rotation timeStampNs:timeStampNs];
|
|
}
|
|
|
|
- (instancetype)initWithBuffer:(id<RTCVideoFrameBuffer>)buffer
|
|
rotation:(RTCVideoRotation)rotation
|
|
timeStampNs:(int64_t)timeStampNs {
|
|
if (self = [super init]) {
|
|
_buffer = buffer;
|
|
_rotation = rotation;
|
|
_timeStampNs = timeStampNs;
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (instancetype)initWithNativeVideoFrame:(const webrtc::VideoFrame &)frame {
|
|
if (self = [self initWithBuffer:nativeToRtcFrameBuffer(frame.video_frame_buffer())
|
|
rotation:RTCVideoRotation(frame.rotation())
|
|
timeStampNs:frame.timestamp_us() * rtc::kNumNanosecsPerMicrosec]) {
|
|
self.timeStamp = frame.timestamp();
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (webrtc::VideoFrame)nativeVideoFrame {
|
|
rtc::scoped_refptr<webrtc::VideoFrameBuffer> frameBuffer =
|
|
new rtc::RefCountedObject<webrtc::ObjCFrameBuffer>(self.buffer);
|
|
webrtc::VideoFrame videoFrame(frameBuffer,
|
|
(webrtc::VideoRotation)self.rotation,
|
|
self.timeStampNs / rtc::kNumNanosecsPerMicrosec);
|
|
videoFrame.set_timestamp(self.timeStamp);
|
|
return videoFrame;
|
|
}
|
|
|
|
@end
|