Source code
Revision control
Copy as Markdown
Other Tools
/*
* Copyright 2018 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 "base/RTCVideoDecoderFactory.h"
#import "base/RTCVideoEncoderFactory.h"
#import "api/peerconnection/RTCAudioSource.h"
#import "api/peerconnection/RTCConfiguration.h"
#import "api/peerconnection/RTCDataChannel.h"
#import "api/peerconnection/RTCDataChannelConfiguration.h"
#import "api/peerconnection/RTCMediaConstraints.h"
#import "api/peerconnection/RTCMediaStreamTrack.h"
#import "api/peerconnection/RTCPeerConnection.h"
#import "api/peerconnection/RTCPeerConnectionFactory.h"
#import "api/peerconnection/RTCRtpCapabilities.h"
#import "api/peerconnection/RTCRtpCodecCapability.h"
#import "api/peerconnection/RTCRtpReceiver.h"
#import "api/peerconnection/RTCRtpSender.h"
#import "api/peerconnection/RTCRtpTransceiver.h"
#import "api/peerconnection/RTCSessionDescription.h"
#import "api/peerconnection/RTCVideoSource.h"
#import "rtc_base/system/unused.h"
#import <XCTest/XCTest.h>
@interface MockVideoEncoderDecoderFactory
: NSObject <RTC_OBJC_TYPE (RTCVideoEncoderFactory), RTC_OBJC_TYPE (RTCVideoDecoderFactory)>
- (instancetype)initWithSupportedCodecs:
(nonnull NSArray<RTC_OBJC_TYPE(RTCVideoCodecInfo) *> *)supportedCodecs;
@end
@implementation MockVideoEncoderDecoderFactory {
NSArray<RTC_OBJC_TYPE(RTCVideoCodecInfo) *> *_supportedCodecs;
}
- (instancetype)initWithSupportedCodecs:
(nonnull NSArray<RTC_OBJC_TYPE(RTCVideoCodecInfo) *> *)supportedCodecs {
self = [super init];
if (self) {
_supportedCodecs = supportedCodecs;
}
return self;
}
- (nullable id<RTC_OBJC_TYPE(RTCVideoEncoder)>)createEncoder:
(nonnull RTC_OBJC_TYPE(RTCVideoCodecInfo) *)info {
return nil;
}
- (nullable id<RTC_OBJC_TYPE(RTCVideoDecoder)>)createDecoder:
(nonnull RTC_OBJC_TYPE(RTCVideoCodecInfo) *)info {
return nil;
}
- (nonnull NSArray<RTC_OBJC_TYPE(RTCVideoCodecInfo) *> *)supportedCodecs {
return _supportedCodecs;
}
@end
@interface RTCPeerConnectionFactoryTests : XCTestCase
@end
@implementation RTCPeerConnectionFactoryTests
- (void)testPeerConnectionLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCConfiguration) *config = [[RTC_OBJC_TYPE(RTCConfiguration) alloc] init];
RTC_OBJC_TYPE(RTCMediaConstraints) *constraints =
[[RTC_OBJC_TYPE(RTCMediaConstraints) alloc] initWithMandatoryConstraints:@{}
optionalConstraints:nil];
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCPeerConnection) * peerConnection;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
peerConnection =
[factory peerConnectionWithConfiguration:config constraints:constraints delegate:nil];
[peerConnection close];
factory = nil;
}
peerConnection = nil;
}
XCTAssertTrue(true, @"Expect test does not crash");
}
- (void)testMediaStreamLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCMediaStream) * mediaStream;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
mediaStream = [factory mediaStreamWithStreamId:@"mediaStream"];
factory = nil;
}
mediaStream = nil;
RTC_UNUSED(mediaStream);
}
XCTAssertTrue(true, "Expect test does not crash");
}
- (void)testDataChannelLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCConfiguration) *config = [[RTC_OBJC_TYPE(RTCConfiguration) alloc] init];
RTC_OBJC_TYPE(RTCMediaConstraints) *constraints =
[[RTC_OBJC_TYPE(RTCMediaConstraints) alloc] initWithMandatoryConstraints:@{}
optionalConstraints:nil];
RTC_OBJC_TYPE(RTCDataChannelConfiguration) *dataChannelConfig =
[[RTC_OBJC_TYPE(RTCDataChannelConfiguration) alloc] init];
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCPeerConnection) * peerConnection;
RTC_OBJC_TYPE(RTCDataChannel) * dataChannel;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
peerConnection =
[factory peerConnectionWithConfiguration:config constraints:constraints delegate:nil];
dataChannel =
[peerConnection dataChannelForLabel:@"test_channel" configuration:dataChannelConfig];
XCTAssertNotNil(dataChannel);
[peerConnection close];
peerConnection = nil;
factory = nil;
}
dataChannel = nil;
}
XCTAssertTrue(true, "Expect test does not crash");
}
- (void)testRTCRtpTransceiverLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCConfiguration) *config = [[RTC_OBJC_TYPE(RTCConfiguration) alloc] init];
config.sdpSemantics = RTCSdpSemanticsUnifiedPlan;
RTC_OBJC_TYPE(RTCMediaConstraints) *contraints =
[[RTC_OBJC_TYPE(RTCMediaConstraints) alloc] initWithMandatoryConstraints:@{}
optionalConstraints:nil];
RTC_OBJC_TYPE(RTCRtpTransceiverInit) *init =
[[RTC_OBJC_TYPE(RTCRtpTransceiverInit) alloc] init];
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCPeerConnection) * peerConnection;
RTC_OBJC_TYPE(RTCRtpTransceiver) * tranceiver;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
peerConnection =
[factory peerConnectionWithConfiguration:config constraints:contraints delegate:nil];
tranceiver = [peerConnection addTransceiverOfType:RTCRtpMediaTypeAudio init:init];
XCTAssertNotNil(tranceiver);
[peerConnection close];
peerConnection = nil;
factory = nil;
}
tranceiver = nil;
}
XCTAssertTrue(true, "Expect test does not crash");
}
- (void)testRTCRtpSenderLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCConfiguration) *config = [[RTC_OBJC_TYPE(RTCConfiguration) alloc] init];
config.sdpSemantics = RTCSdpSemanticsPlanB;
RTC_OBJC_TYPE(RTCMediaConstraints) *constraints =
[[RTC_OBJC_TYPE(RTCMediaConstraints) alloc] initWithMandatoryConstraints:@{}
optionalConstraints:nil];
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCPeerConnection) * peerConnection;
RTC_OBJC_TYPE(RTCRtpSender) * sender;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
peerConnection =
[factory peerConnectionWithConfiguration:config constraints:constraints delegate:nil];
sender = [peerConnection senderWithKind:kRTCMediaStreamTrackKindVideo streamId:@"stream"];
XCTAssertNotNil(sender);
[peerConnection close];
peerConnection = nil;
factory = nil;
}
sender = nil;
}
XCTAssertTrue(true, "Expect test does not crash");
}
- (void)testRTCRtpReceiverLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCConfiguration) *config = [[RTC_OBJC_TYPE(RTCConfiguration) alloc] init];
config.sdpSemantics = RTCSdpSemanticsPlanB;
RTC_OBJC_TYPE(RTCMediaConstraints) *constraints =
[[RTC_OBJC_TYPE(RTCMediaConstraints) alloc] initWithMandatoryConstraints:@{}
optionalConstraints:nil];
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCPeerConnection) * pc1;
RTC_OBJC_TYPE(RTCPeerConnection) * pc2;
NSArray<RTC_OBJC_TYPE(RTCRtpReceiver) *> *receivers1;
NSArray<RTC_OBJC_TYPE(RTCRtpReceiver) *> *receivers2;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
pc1 = [factory peerConnectionWithConfiguration:config constraints:constraints delegate:nil];
[pc1 senderWithKind:kRTCMediaStreamTrackKindAudio streamId:@"stream"];
pc2 = [factory peerConnectionWithConfiguration:config constraints:constraints delegate:nil];
[pc2 senderWithKind:kRTCMediaStreamTrackKindAudio streamId:@"stream"];
NSTimeInterval negotiationTimeout = 15;
XCTAssertTrue([self negotiatePeerConnection:pc1
withPeerConnection:pc2
negotiationTimeout:negotiationTimeout]);
XCTAssertEqual(pc1.signalingState, RTCSignalingStateStable);
XCTAssertEqual(pc2.signalingState, RTCSignalingStateStable);
receivers1 = pc1.receivers;
receivers2 = pc2.receivers;
XCTAssertTrue(receivers1.count > 0);
XCTAssertTrue(receivers2.count > 0);
[pc1 close];
[pc2 close];
pc1 = nil;
pc2 = nil;
factory = nil;
}
receivers1 = nil;
receivers2 = nil;
}
XCTAssertTrue(true, "Expect test does not crash");
}
- (void)testAudioSourceLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCAudioSource) * audioSource;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
audioSource = [factory audioSourceWithConstraints:nil];
XCTAssertNotNil(audioSource);
factory = nil;
}
audioSource = nil;
}
XCTAssertTrue(true, "Expect test does not crash");
}
- (void)testVideoSourceLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCVideoSource) * videoSource;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
videoSource = [factory videoSource];
XCTAssertNotNil(videoSource);
factory = nil;
}
videoSource = nil;
}
XCTAssertTrue(true, "Expect test does not crash");
}
- (void)testAudioTrackLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCAudioTrack) * audioTrack;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
audioTrack = [factory audioTrackWithTrackId:@"audioTrack"];
XCTAssertNotNil(audioTrack);
factory = nil;
}
audioTrack = nil;
}
XCTAssertTrue(true, "Expect test does not crash");
}
- (void)testVideoTrackLifetime {
@autoreleasepool {
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCVideoTrack) * videoTrack;
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
videoTrack = [factory videoTrackWithSource:[factory videoSource] trackId:@"videoTrack"];
XCTAssertNotNil(videoTrack);
factory = nil;
}
videoTrack = nil;
}
XCTAssertTrue(true, "Expect test does not crash");
}
- (void)testRollback {
@autoreleasepool {
RTC_OBJC_TYPE(RTCConfiguration) *config = [[RTC_OBJC_TYPE(RTCConfiguration) alloc] init];
config.sdpSemantics = RTCSdpSemanticsUnifiedPlan;
RTC_OBJC_TYPE(RTCMediaConstraints) *constraints =
[[RTC_OBJC_TYPE(RTCMediaConstraints) alloc] initWithMandatoryConstraints:@{
kRTCMediaConstraintsOfferToReceiveAudio : kRTCMediaConstraintsValueTrue
}
optionalConstraints:nil];
__block RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
__block RTC_OBJC_TYPE(RTCPeerConnection) * pc1;
RTC_OBJC_TYPE(RTCSessionDescription) *rollback =
[[RTC_OBJC_TYPE(RTCSessionDescription) alloc] initWithType:RTCSdpTypeRollback sdp:@""];
@autoreleasepool {
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] init];
pc1 = [factory peerConnectionWithConfiguration:config constraints:constraints delegate:nil];
dispatch_semaphore_t negotiatedSem = dispatch_semaphore_create(0);
[pc1 offerForConstraints:constraints
completionHandler:^(RTC_OBJC_TYPE(RTCSessionDescription) * offer, NSError * error) {
XCTAssertNil(error);
XCTAssertNotNil(offer);
__weak RTC_OBJC_TYPE(RTCPeerConnection) *weakPC1 = pc1;
[pc1 setLocalDescription:offer
completionHandler:^(NSError *error) {
XCTAssertNil(error);
[weakPC1 setLocalDescription:rollback
completionHandler:^(NSError *error) {
XCTAssertNil(error);
}];
}];
NSTimeInterval negotiationTimeout = 15;
dispatch_semaphore_wait(
negotiatedSem,
dispatch_time(DISPATCH_TIME_NOW, (int64_t)(negotiationTimeout * NSEC_PER_SEC)));
XCTAssertEqual(pc1.signalingState, RTCSignalingStateStable);
[pc1 close];
pc1 = nil;
factory = nil;
}];
}
XCTAssertTrue(true, "Expect test does not crash");
}
}
- (void)testSenderCapabilities {
@autoreleasepool {
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
MockVideoEncoderDecoderFactory *encoder;
MockVideoEncoderDecoderFactory *decoder;
NSArray<RTC_OBJC_TYPE(RTCVideoCodecInfo) *> *supportedCodecs = @[
[[RTC_OBJC_TYPE(RTCVideoCodecInfo) alloc] initWithName:@"VP8"],
[[RTC_OBJC_TYPE(RTCVideoCodecInfo) alloc] initWithName:@"H264"]
];
encoder = [[MockVideoEncoderDecoderFactory alloc] initWithSupportedCodecs:supportedCodecs];
decoder = [[MockVideoEncoderDecoderFactory alloc] initWithSupportedCodecs:supportedCodecs];
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] initWithEncoderFactory:encoder
decoderFactory:decoder];
RTC_OBJC_TYPE(RTCRtpCapabilities) *capabilities =
[factory rtpSenderCapabilitiesForKind:kRTCMediaStreamTrackKindVideo];
NSMutableArray<NSString *> *codecNames = [NSMutableArray new];
for (RTC_OBJC_TYPE(RTCRtpCodecCapability) * codec in capabilities.codecs) {
[codecNames addObject:codec.name];
}
XCTAssertTrue([codecNames containsObject:@"VP8"]);
XCTAssertTrue([codecNames containsObject:@"H264"]);
factory = nil;
}
}
- (void)testReceiverCapabilities {
@autoreleasepool {
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
MockVideoEncoderDecoderFactory *encoder;
MockVideoEncoderDecoderFactory *decoder;
NSArray<RTC_OBJC_TYPE(RTCVideoCodecInfo) *> *supportedCodecs = @[
[[RTC_OBJC_TYPE(RTCVideoCodecInfo) alloc] initWithName:@"VP8"],
[[RTC_OBJC_TYPE(RTCVideoCodecInfo) alloc] initWithName:@"H264"]
];
encoder = [[MockVideoEncoderDecoderFactory alloc] initWithSupportedCodecs:supportedCodecs];
decoder = [[MockVideoEncoderDecoderFactory alloc] initWithSupportedCodecs:supportedCodecs];
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] initWithEncoderFactory:encoder
decoderFactory:decoder];
RTC_OBJC_TYPE(RTCRtpCapabilities) *capabilities =
[factory rtpReceiverCapabilitiesForKind:kRTCMediaStreamTrackKindVideo];
NSMutableArray<NSString *> *codecNames = [NSMutableArray new];
for (RTC_OBJC_TYPE(RTCRtpCodecCapability) * codec in capabilities.codecs) {
[codecNames addObject:codec.name];
}
XCTAssertTrue([codecNames containsObject:@"VP8"]);
XCTAssertTrue([codecNames containsObject:@"H264"]);
factory = nil;
}
}
- (void)testSetCodecPreferences {
@autoreleasepool {
RTC_OBJC_TYPE(RTCConfiguration) *config = [[RTC_OBJC_TYPE(RTCConfiguration) alloc] init];
RTC_OBJC_TYPE(RTCMediaConstraints) *constraints =
[[RTC_OBJC_TYPE(RTCMediaConstraints) alloc] initWithMandatoryConstraints:nil
optionalConstraints:nil];
RTC_OBJC_TYPE(RTCRtpTransceiverInit) *init =
[[RTC_OBJC_TYPE(RTCRtpTransceiverInit) alloc] init];
NSArray<RTC_OBJC_TYPE(RTCVideoCodecInfo) *> *supportedCodecs = @[
[[RTC_OBJC_TYPE(RTCVideoCodecInfo) alloc] initWithName:@"VP8"],
[[RTC_OBJC_TYPE(RTCVideoCodecInfo) alloc] initWithName:@"H264"]
];
MockVideoEncoderDecoderFactory *encoder =
[[MockVideoEncoderDecoderFactory alloc] initWithSupportedCodecs:supportedCodecs];
MockVideoEncoderDecoderFactory *decoder =
[[MockVideoEncoderDecoderFactory alloc] initWithSupportedCodecs:supportedCodecs];
RTC_OBJC_TYPE(RTCPeerConnectionFactory) * factory;
RTC_OBJC_TYPE(RTCPeerConnection) * peerConnection;
RTC_OBJC_TYPE(RTCRtpTransceiver) * tranceiver;
factory = [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc] initWithEncoderFactory:encoder
decoderFactory:decoder];
peerConnection = [factory peerConnectionWithConfiguration:config
constraints:constraints
delegate:nil];
tranceiver = [peerConnection addTransceiverOfType:RTCRtpMediaTypeVideo init:init];
XCTAssertNotNil(tranceiver);
RTC_OBJC_TYPE(RTCRtpCapabilities) *capabilities =
[factory rtpReceiverCapabilitiesForKind:kRTCMediaStreamTrackKindVideo];
RTC_OBJC_TYPE(RTCRtpCodecCapability) * targetCodec;
for (RTC_OBJC_TYPE(RTCRtpCodecCapability) * codec in capabilities.codecs) {
if ([codec.name isEqual:@"VP8"]) {
targetCodec = codec;
break;
}
}
XCTAssertNotNil(targetCodec);
NSError *error = nil;
BOOL result = [tranceiver setCodecPreferences:@[ targetCodec ] error:&error];
XCTAssertTrue(result);
XCTAssertNil(error);
@autoreleasepool {
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
__block BOOL completed = NO;
[peerConnection
offerForConstraints:constraints
completionHandler:^(RTC_OBJC_TYPE(RTCSessionDescription) *_Nullable sdp,
NSError *_Nullable error) {
XCTAssertNil(error);
XCTAssertNotNil(sdp);
NSArray<NSString *> *rtpMaps = [self rtpMapsFromSDP:sdp.sdp];
XCTAssertEqual(1, rtpMaps.count);
XCTAssertNotNil(targetCodec.preferredPayloadType);
XCTAssertNotNil(targetCodec.clockRate);
NSString *expected =
[NSString stringWithFormat:@"a=rtpmap:%i VP8/%i",
targetCodec.preferredPayloadType.intValue,
targetCodec.clockRate.intValue];
XCTAssertTrue([expected isEqualToString:rtpMaps[0]]);
completed = YES;
dispatch_semaphore_signal(semaphore);
}];
[peerConnection close];
peerConnection = nil;
factory = nil;
tranceiver = nil;
dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 15.0 * NSEC_PER_SEC));
XCTAssertTrue(completed);
}
}
}
- (bool)negotiatePeerConnection:(RTC_OBJC_TYPE(RTCPeerConnection) *)pc1
withPeerConnection:(RTC_OBJC_TYPE(RTCPeerConnection) *)pc2
negotiationTimeout:(NSTimeInterval)timeout {
__weak RTC_OBJC_TYPE(RTCPeerConnection) *weakPC1 = pc1;
__weak RTC_OBJC_TYPE(RTCPeerConnection) *weakPC2 = pc2;
RTC_OBJC_TYPE(RTCMediaConstraints) *sdpConstraints =
[[RTC_OBJC_TYPE(RTCMediaConstraints) alloc] initWithMandatoryConstraints:@{
kRTCMediaConstraintsOfferToReceiveAudio : kRTCMediaConstraintsValueTrue
}
optionalConstraints:nil];
dispatch_semaphore_t negotiatedSem = dispatch_semaphore_create(0);
[weakPC1 offerForConstraints:sdpConstraints
completionHandler:^(RTC_OBJC_TYPE(RTCSessionDescription) * offer, NSError * error) {
XCTAssertNil(error);
XCTAssertNotNil(offer);
[weakPC1
setLocalDescription:offer
completionHandler:^(NSError *error) {
XCTAssertNil(error);
[weakPC2
setRemoteDescription:offer
completionHandler:^(NSError *error) {
XCTAssertNil(error);
[weakPC2
answerForConstraints:sdpConstraints
completionHandler:^(
RTC_OBJC_TYPE(RTCSessionDescription) * answer,
NSError * error) {
XCTAssertNil(error);
XCTAssertNotNil(answer);
[weakPC2
setLocalDescription:answer
completionHandler:^(NSError *error) {
XCTAssertNil(error);
[weakPC1
setRemoteDescription:answer
completionHandler:^(NSError *error) {
XCTAssertNil(error);
dispatch_semaphore_signal(negotiatedSem);
}];
}];
}];
}];
}];
}];
return 0 ==
dispatch_semaphore_wait(negotiatedSem,
dispatch_time(DISPATCH_TIME_NOW, (int64_t)(timeout * NSEC_PER_SEC)));
}
- (NSArray<NSString *> *)rtpMapsFromSDP:(NSString *)sdp {
NSMutableArray<NSString *> *rtpMaps = [NSMutableArray new];
NSArray *sdpLines =
[sdp componentsSeparatedByCharactersInSet:[NSCharacterSet newlineCharacterSet]];
for (NSString *line in sdpLines) {
if ([line hasPrefix:@"a=rtpmap"]) {
[rtpMaps addObject:line];
}
}
return rtpMaps;
}
@end