Antidote/local_pod_repo/objcTox/Classes/Private/Wrapper/OCTToxAV.m
2024-02-22 21:43:11 +02:00

649 lines
23 KiB
Objective-C

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#import "OCTTox+Private.h"
#import "OCTToxAV+Private.h"
#import "OCTLogging.h"
ToxAV *(*_toxav_new)(Tox *tox, TOXAV_ERR_NEW *error);
uint32_t (*_toxav_iteration_interval)(const ToxAV *toxAV);
void (*_toxav_iterate)(ToxAV *toxAV);
void (*_toxav_kill)(ToxAV *toxAV);
bool (*_toxav_call)(ToxAV *toxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL *error);
bool (*_toxav_answer)(ToxAV *toxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_ANSWER *error);
bool (*_toxav_call_control)(ToxAV *toxAV, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL *error);
bool (*_toxav_audio_set_bit_rate)(ToxAV *av, uint32_t friend_number, uint32_t bit_rate, TOXAV_ERR_BIT_RATE_SET *error);
bool (*_toxav_video_set_bit_rate)(ToxAV *av, uint32_t friend_number, uint32_t bit_rate, TOXAV_ERR_BIT_RATE_SET *error);
bool (*_toxav_audio_send_frame)(ToxAV *toxAV, uint32_t friend_number, const int16_t *pcm, size_t sample_count, uint8_t channels, uint32_t sampling_rate, TOXAV_ERR_SEND_FRAME *error);
bool (*_toxav_video_send_frame)(ToxAV *toxAV, uint32_t friend_number, uint16_t width, uint16_t height, const uint8_t *y, const uint8_t *u, const uint8_t *v, TOXAV_ERR_SEND_FRAME *error);
@interface OCTToxAV ()
@property (assign, nonatomic) ToxAV *toxAV;
@property (strong, nonatomic) dispatch_source_t timer;
@property (assign, nonatomic) uint64_t previousIterate;
@end
@implementation OCTToxAV
#pragma mark - Lifecycle
- (instancetype)initWithTox:(OCTTox *)tox error:(NSError **)error
{
self = [super init];
if (! self) {
return nil;
}
OCTLogVerbose(@"init called");
[self setupCFunctions];
TOXAV_ERR_NEW cError;
_toxAV = _toxav_new(tox.tox, &cError);
[self fillError:error withCErrorInit:cError];
[self setupCallbacks];
return self;
}
- (void)start
{
OCTLogVerbose(@"start method called");
@synchronized(self) {
if (self.timer) {
OCTLogWarn(@"already started");
return;
}
dispatch_queue_t queue = dispatch_queue_create("me.dvor.objcTox.OCTToxAVQueue", NULL);
self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
[self updateTimerIntervalIfNeeded];
__weak OCTToxAV *weakSelf = self;
dispatch_source_set_event_handler(self.timer, ^{
OCTToxAV *strongSelf = weakSelf;
if (! strongSelf) {
return;
}
_toxav_iterate(strongSelf.toxAV);
[strongSelf updateTimerIntervalIfNeeded];
});
dispatch_resume(self.timer);
}
OCTLogInfo(@"started");
}
- (void)stop
{
OCTLogVerbose(@"stop method called");
@synchronized(self) {
if (! self.timer) {
OCTLogWarn(@"toxav isn't running, nothing to stop");
return;
}
dispatch_source_cancel(self.timer);
self.timer = nil;
}
OCTLogInfo(@"stopped");
}
- (void)dealloc
{
[self stop];
_toxav_kill(self.toxAV);
OCTLogVerbose(@"dealloc called, toxav killed");
}
#pragma mark - Call Methods
- (BOOL)callFriendNumber:(OCTToxFriendNumber)friendNumber audioBitRate:(OCTToxAVAudioBitRate)audioBitRate videoBitRate:(OCTToxAVVideoBitRate)videoBitRate error:(NSError **)error
{
TOXAV_ERR_CALL cError;
BOOL status = _toxav_call(self.toxAV, friendNumber, audioBitRate, videoBitRate, &cError);
[self fillError:error withCErrorCall:cError];
return status;
}
- (BOOL)answerIncomingCallFromFriend:(OCTToxFriendNumber)friendNumber audioBitRate:(OCTToxAVAudioBitRate)audioBitRate videoBitRate:(OCTToxAVVideoBitRate)videoBitrate error:(NSError **)error
{
TOXAV_ERR_ANSWER cError;
BOOL status = _toxav_answer(self.toxAV, friendNumber, audioBitRate, videoBitrate, &cError);
[self fillError:error withCErrorAnswer:cError];
return status;
}
- (BOOL)sendCallControl:(OCTToxAVCallControl)control toFriendNumber:(OCTToxFriendNumber)friendNumber error:(NSError **)error
{
TOXAV_CALL_CONTROL cControl;
switch (control) {
case OCTToxAVCallControlResume:
cControl = TOXAV_CALL_CONTROL_RESUME;
break;
case OCTToxAVCallControlPause:
cControl = TOXAV_CALL_CONTROL_PAUSE;
break;
case OCTToxAVCallControlCancel:
cControl = TOXAV_CALL_CONTROL_CANCEL;
break;
case OCTToxAVCallControlMuteAudio:
cControl = TOXAV_CALL_CONTROL_MUTE_AUDIO;
break;
case OCTToxAVCallControlUnmuteAudio:
cControl = TOXAV_CALL_CONTROL_UNMUTE_AUDIO;
break;
case OCTToxAVCallControlHideVideo:
cControl = TOXAV_CALL_CONTROL_HIDE_VIDEO;
break;
case OCTToxAVCallControlShowVideo:
cControl = TOXAV_CALL_CONTROL_SHOW_VIDEO;
break;
}
TOXAV_ERR_CALL_CONTROL cError;
BOOL status = _toxav_call_control(self.toxAV, friendNumber, cControl, &cError);
[self fillError:error withCErrorControl:cError];
return status;
}
#pragma mark - Controlling bit rates
- (BOOL)setAudioBitRate:(OCTToxAVAudioBitRate)bitRate force:(BOOL)force forFriend:(OCTToxFriendNumber)friendNumber error:(NSError **)error
{
TOXAV_ERR_BIT_RATE_SET cError;
BOOL status = _toxav_audio_set_bit_rate(self.toxAV, friendNumber, bitRate, &cError);
[self fillError:error withCErrorSetBitRate:cError];
OCTLogVerbose(@"setAudioBitRate:%lu, force:%d, friend:%d", (long)bitRate, force, friendNumber);
return status;
}
- (BOOL)setVideoBitRate:(OCTToxAVVideoBitRate)bitRate force:(BOOL)force forFriend:(OCTToxFriendNumber)friendNumber error:(NSError **)error
{
TOXAV_ERR_BIT_RATE_SET cError;
BOOL status = _toxav_video_set_bit_rate(self.toxAV, friendNumber, bitRate, &cError);
[self fillError:error withCErrorSetBitRate:cError];
return status;
}
#pragma mark - Sending frames
- (BOOL)sendAudioFrame:(OCTToxAVPCMData *)pcm sampleCount:(OCTToxAVSampleCount)sampleCount
channels:(OCTToxAVChannels)channels sampleRate:(OCTToxAVSampleRate)sampleRate
toFriend:(OCTToxFriendNumber)friendNumber error:(NSError **)error
{
// TOXAUDIO: -outgoing-audio-
TOXAV_ERR_SEND_FRAME cError;
BOOL status = _toxav_audio_send_frame(self.toxAV, friendNumber,
pcm, sampleCount,
channels, sampleRate, &cError);
[self fillError:error withCErrorSendFrame:cError];
return status;
}
- (BOOL)sendVideoFrametoFriend:(OCTToxFriendNumber)friendNumber
width:(OCTToxAVVideoWidth)width height:(OCTToxAVVideoHeight)height
yPlane:(OCTToxAVPlaneData *)yPlane uPlane:(OCTToxAVPlaneData *)uPlane
vPlane:(OCTToxAVPlaneData *)vPlane
error:(NSError **)error
{
TOXAV_ERR_SEND_FRAME cError;
BOOL status = _toxav_video_send_frame(self.toxAV, friendNumber, width, height, yPlane, uPlane, vPlane, &cError);
[self fillError:error withCErrorSendFrame:cError];
return status;
}
#pragma mark - Private
- (void)setupCFunctions
{
_toxav_new = toxav_new;
_toxav_iteration_interval = toxav_iteration_interval;
_toxav_iterate = toxav_iterate;
_toxav_kill = toxav_kill;
_toxav_call = toxav_call;
_toxav_answer = toxav_answer;
_toxav_call_control = toxav_call_control;
_toxav_audio_set_bit_rate = toxav_audio_set_bit_rate;
_toxav_video_set_bit_rate = toxav_video_set_bit_rate;
_toxav_audio_send_frame = toxav_audio_send_frame;
_toxav_video_send_frame = toxav_video_send_frame;
}
- (void)setupCallbacks
{
toxav_callback_call(_toxAV, callIncomingCallback, (__bridge void *)(self));
toxav_callback_call_state(_toxAV, callStateCallback, (__bridge void *)(self));
toxav_callback_audio_bit_rate(_toxAV, audioBitRateStatusCallback, (__bridge void *)(self));
toxav_callback_video_bit_rate(_toxAV, videoBitRateStatusCallback, (__bridge void *)(self));
toxav_callback_audio_receive_frame(_toxAV, receiveAudioFrameCallback, (__bridge void *)(self));
toxav_callback_video_receive_frame(_toxAV, receiveVideoFrameCallback, (__bridge void *)(self));
}
- (BOOL)fillError:(NSError **)error withCErrorInit:(TOXAV_ERR_NEW)cError
{
if (! error || (cError == TOXAV_ERR_NEW_OK)) {
return NO;
}
OCTToxAVErrorInitCode code = OCTToxAVErrorInitCodeUnknown;
NSString *description = @"Cannot initialize ToxAV";
NSString *failureReason = nil;
switch (cError) {
case TOXAV_ERR_NEW_OK:
NSAssert(NO, @"We shouldn't be here!");
break;
case TOXAV_ERR_NEW_NULL:
code = OCTToxAVErrorInitNULL;
failureReason = @"One of the arguments to the function was NULL when it was not expected.";
break;
case TOXAV_ERR_NEW_MALLOC:
code = OCTToxAVErrorInitCodeMemoryError;
failureReason = @"Memory allocation failure while trying to allocate structures required for the A/V session.";
break;
case TOXAV_ERR_NEW_MULTIPLE:
code = OCTToxAVErrorInitMultiple;
failureReason = @"Attempted to create a second session for the same Tox instance.";
break;
}
*error = [self createErrorWithCode:code description:description failureReason:failureReason];
return YES;
}
- (BOOL)fillError:(NSError **)error withCErrorCall:(TOXAV_ERR_CALL)cError
{
if (! error || (cError == TOXAV_ERR_CALL_OK)) {
return NO;
}
OCTToxAVErrorCall code = OCTToxAVErrorCallUnknown;
NSString *description = @"Could not make call";
NSString *failureReason = nil;
switch (cError) {
case TOXAV_ERR_CALL_OK:
NSAssert(NO, @"We shouldn't be here!");
break;
case TOXAV_ERR_CALL_MALLOC:
code = OCTToxAVErrorCallMalloc;
failureReason = @"A resource allocation error occured while trying to create the structures required for the call.";
break;
case TOXAV_ERR_CALL_SYNC:
code = OCTToxAVErrorCallSync;
failureReason = @"Synchronization error occurred.";
break;
case TOXAV_ERR_CALL_FRIEND_NOT_FOUND:
code = OCTToxAVErrorCallFriendNotFound;
failureReason = @"The friend number did not designate a valid friend.";
break;
case TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED:
code = OCTToxAVErrorCallFriendNotConnected;
failureReason = @"The friend was valid, but not currently connected";
break;
case TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL:
code = OCTToxAVErrorCallAlreadyInCall;
failureReason = @"Attempted to call a friend while already in an audio or video call with them.";
break;
case TOXAV_ERR_CALL_INVALID_BIT_RATE:
code = OCTToxAVErrorCallInvalidBitRate;
failureReason = @"Audio or video bit rate is invalid";
break;
}
*error = [self createErrorWithCode:code description:description failureReason:failureReason];
return YES;
}
- (BOOL)fillError:(NSError **)error withCErrorAnswer:(TOXAV_ERR_ANSWER)cError
{
if (! error || (cError == TOXAV_ERR_ANSWER_OK)) {
return NO;
}
OCTToxAVErrorAnswer code = OCTToxAVErrorAnswerUnknown;
NSString *description = @"Could not answer call";
NSString *failureReason = nil;
switch (cError) {
case TOXAV_ERR_ANSWER_OK:
NSAssert(NO, @"We shouldn't be here!");
break;
case TOXAV_ERR_ANSWER_SYNC:
code = OCTToxAVErrorAnswerSync;
break;
case TOXAV_ERR_ANSWER_CODEC_INITIALIZATION:
code = OCTToxAVErrorAnswerCodecInitialization;
break;
case TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING:
code = OCTToxAVErrorAnswerFriendNotCalling;
break;
case TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND:
code = OCTToxAVErrorAnswerFriendNotFound;
break;
case TOXAV_ERR_ANSWER_INVALID_BIT_RATE:
code = OCTToxAVErrorAnswerInvalidBitRate;
break;
}
*error = [self createErrorWithCode:code description:description failureReason:failureReason];
return YES;
}
- (BOOL)fillError:(NSError **)error withCErrorControl:(TOXAV_ERR_CALL_CONTROL)cError
{
if (! error || (cError == TOXAV_ERR_CALL_CONTROL_OK)) {
return NO;
}
OCTToxErrorCallControl code = OCTToxAVErrorControlUnknown;
NSString *description = @"Unable set control";
NSString *failureReason = nil;
switch (cError) {
case TOXAV_ERR_CALL_CONTROL_OK:
NSAssert(NO, @"We shouldn't be here!");
break;
case TOXAV_ERR_CALL_CONTROL_SYNC:
code = OCTToxAVErrorControlSync;
failureReason = @"Synchronization error occurred.";
break;
case TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND:
code = OCTToxAVErrorControlFriendNotFound;
failureReason = @"The friend number passed did not designate a valid friend.";
break;
case TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL:
code = OCTToxAVErrorControlFriendNotInCall;
failureReason = @"This client is currently not in a call with the friend. Before the call is answered, only CANCEL is a valid control.";
break;
case TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION:
code = OCTToxAVErrorControlInvaldTransition;
failureReason = @"Happens if user tried to pause an already paused call or if trying to resume a call that is not paused.";
break;
}
*error = [self createErrorWithCode:code description:description failureReason:failureReason];
return YES;
}
- (BOOL)fillError:(NSError **)error withCErrorSetBitRate:(TOXAV_ERR_BIT_RATE_SET)cError
{
if (! error || (cError == TOXAV_ERR_BIT_RATE_SET_OK)) {
return NO;
}
OCTToxAVErrorSetBitRate code = OCTToxAVErrorSetBitRateUnknown;
NSString *description = @"Unable to set audio/video bitrate";
NSString *failureReason = nil;
switch (cError) {
case TOXAV_ERR_BIT_RATE_SET_OK:
NSAssert(NO, @"We shouldn't be here!");
break;
case TOXAV_ERR_BIT_RATE_SET_SYNC:
code = OCTToxAVErrorSetBitRateSync;
failureReason = @"Synchronization error occurred.";
break;
case TOXAV_ERR_BIT_RATE_SET_INVALID_BIT_RATE:
code = OCTToxAVErrorSetBitRateInvalidBitRate;
failureReason = @"The bit rate passed was not one of the supported values.";
break;
case TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_FOUND:
code = OCTToxAVErrorSetBitRateFriendNotFound;
failureReason = @"The friend number passed did not designate a valid friend";
break;
case TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL:
code = OCTToxAVErrorSetBitRateFriendNotInCall;
failureReason = @"This client is currently not in a call with the friend";
break;
}
*error = [self createErrorWithCode:code description:description failureReason:failureReason];
return YES;
}
- (BOOL)fillError:(NSError **)error withCErrorSendFrame:(TOXAV_ERR_SEND_FRAME)cError
{
if (! error || (cError == TOXAV_ERR_SEND_FRAME_OK)) {
return NO;
}
OCTToxAVErrorSendFrame code = OCTToxAVErrorSendFrameUnknown;
NSString *description = @"Failed to send audio/video frame";
NSString *failureReason = @"Unable to sending audio/video frame";
switch (cError) {
case TOXAV_ERR_SEND_FRAME_OK:
NSAssert(NO, @"We shouldn't be here!");
break;
case TOXAV_ERR_SEND_FRAME_NULL:
code = OCTToxAVErrorSendFrameNull;
failureReason = @"In case of video, one of Y, U, or V was NULL. In case of audio, the samples data pointer was NULL.";
break;
case TOXAV_ERR_SEND_FRAME_FRIEND_NOT_FOUND:
code = OCTToxAVErrorSendFrameFriendNotFound;
failureReason = @"The friend number passed did not designate a valid friend.";
break;
case TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL:
code = OCTToxAVErrorSendFrameFriendNotInCall;
failureReason = @"This client is currently not in a call with the friend";
break;
case TOXAV_ERR_SEND_FRAME_SYNC:
code = OCTToxAVErrorSendFrameSync;
failureReason = @"Synchronization error occurred";
break;
case TOXAV_ERR_SEND_FRAME_INVALID:
code = OCTToxAVErrorSendFrameInvalid;
failureReason = @"One of the frame parameters was invalid. E.g. the resolution may be too small or too large, or the audio sampling rate may be unsupported";
break;
case TOXAV_ERR_SEND_FRAME_PAYLOAD_TYPE_DISABLED:
code = OCTToxAVErrorSendFramePayloadTypeDisabled;
failureReason = @"Either friend turned off audio/video receiving or we turned off sending for the said payload.";
break;
case TOXAV_ERR_SEND_FRAME_RTP_FAILED:
code = OCTToxAVErrorSendFrameRTPFailed;
failureReason = @"Failed to push frame through rtp interface";
break;
}
*error = [self createErrorWithCode:code description:description failureReason:failureReason];
return YES;
}
- (NSError *)createErrorWithCode:(NSUInteger)code
description:(NSString *)description
failureReason:(NSString *)failureReason
{
NSMutableDictionary *userInfo = [NSMutableDictionary new];
if (description) {
userInfo[NSLocalizedDescriptionKey] = description;
}
if (failureReason) {
userInfo[NSLocalizedFailureReasonErrorKey] = failureReason;
}
return [NSError errorWithDomain:kOCTToxAVErrorDomain code:code userInfo:userInfo];
}
- (void)updateTimerIntervalIfNeeded
{
uint64_t nextIterate = _toxav_iteration_interval(self.toxAV) * (NSEC_PER_SEC / 1000);
if (self.previousIterate == nextIterate) {
return;
}
self.previousIterate = nextIterate;
dispatch_source_set_timer(self.timer, dispatch_walltime(NULL, nextIterate), nextIterate, nextIterate / 5);
}
@end
#pragma mark - Callbacks
void callIncomingCallback(ToxAV *cToxAV,
uint32_t friendNumber,
bool audioEnabled,
bool videoEnabled,
void *userData)
{
OCTToxAV *toxAV = (__bridge OCTToxAV *)userData;
dispatch_async(dispatch_get_main_queue(), ^{
OCTLogCInfo(@"callIncomingCallback from friend %lu with audio:%d with video:%d", toxAV, (unsigned long)friendNumber, audioEnabled, videoEnabled);
if ([toxAV.delegate respondsToSelector:@selector(toxAV:receiveCallAudioEnabled:videoEnabled:friendNumber:)]) {
[toxAV.delegate toxAV:toxAV receiveCallAudioEnabled:audioEnabled videoEnabled:videoEnabled friendNumber:friendNumber];
}
});
}
void callStateCallback(ToxAV *cToxAV,
uint32_t friendNumber,
TOXAV_FRIEND_CALL_STATE cState,
void *userData)
{
OCTToxAV *toxAV = (__bridge OCTToxAV *)userData;
dispatch_async(dispatch_get_main_queue(), ^{
OCTLogCInfo(@"callStateCallback from friend %d with state: %d", toxAV, friendNumber, cState);
OCTToxAVCallState state = 0;
if (cState & TOXAV_FRIEND_CALL_STATE_ERROR) {
state |= OCTToxAVFriendCallStateError;
}
if (cState & TOXAV_FRIEND_CALL_STATE_FINISHED) {
state |= OCTToxAVFriendCallStateFinished;
}
if (cState & TOXAV_FRIEND_CALL_STATE_SENDING_A) {
state |= OCTToxAVFriendCallStateSendingAudio;
}
if (cState & TOXAV_FRIEND_CALL_STATE_SENDING_V) {
state |= OCTToxAVFriendCallStateSendingVideo;
}
if (cState & TOXAV_FRIEND_CALL_STATE_ACCEPTING_A) {
state |= OCTToxAVFriendCallStateAcceptingAudio;
}
if (cState & TOXAV_FRIEND_CALL_STATE_ACCEPTING_V) {
state |= OCTToxAVFriendCallStateAcceptingVideo;
}
if ([toxAV.delegate respondsToSelector:@selector(toxAV:callStateChanged:friendNumber:)]) {
[toxAV.delegate toxAV:toxAV callStateChanged:state friendNumber:friendNumber];
}
});
}
void audioBitRateStatusCallback(ToxAV *cToxAV,
uint32_t friendNumber,
uint32_t bit_rate,
void *userData)
{
OCTToxAV *toxAV = (__bridge OCTToxAV *)userData;
dispatch_async(dispatch_get_main_queue(), ^{
OCTLogCInfo(@"audioBitRateStatusCallback from friend %d bitRate: %d", toxAV, friendNumber, bit_rate);
if ([toxAV.delegate respondsToSelector:@selector(toxAV:audioBitRateStatus:forFriendNumber:)]) {
[toxAV.delegate toxAV:toxAV audioBitRateStatus:bit_rate forFriendNumber:friendNumber];
}
});
}
void videoBitRateStatusCallback(ToxAV *cToxAV,
uint32_t friendNumber,
uint32_t bit_rate,
void *userData)
{
OCTToxAV *toxAV = (__bridge OCTToxAV *)userData;
dispatch_async(dispatch_get_main_queue(), ^{
OCTLogCInfo(@"videoBitRateStatusCallback from friend %d bitRate: %d", toxAV, friendNumber, bit_rate);
if ([toxAV.delegate respondsToSelector:@selector(toxAV:videoBitRateStatus:forFriendNumber:)]) {
[toxAV.delegate toxAV:toxAV videoBitRateStatus:bit_rate forFriendNumber:friendNumber];
}
});
}
void receiveAudioFrameCallback(ToxAV *cToxAV,
uint32_t friendNumber,
OCTToxAVPCMData *pcm,
OCTToxAVSampleCount sampleCount,
OCTToxAVChannels channels,
OCTToxAVSampleRate sampleRate,
void *userData)
{
OCTToxAV *toxAV = (__bridge OCTToxAV *)userData;
// TOXAUDIO: -incoming-audio-
if ([toxAV.delegate respondsToSelector:@selector(toxAV:receiveAudio:sampleCount:channels:sampleRate:friendNumber:)]) {
[toxAV.delegate toxAV:toxAV receiveAudio:pcm sampleCount:sampleCount channels:channels sampleRate:sampleRate friendNumber:friendNumber];
}
}
void receiveVideoFrameCallback(ToxAV *cToxAV,
uint32_t friendNumber,
OCTToxAVVideoWidth width,
OCTToxAVVideoHeight height,
OCTToxAVPlaneData *yPlane, OCTToxAVPlaneData *uPlane, OCTToxAVPlaneData *vPlane,
OCTToxAVStrideData yStride, OCTToxAVStrideData uStride, OCTToxAVStrideData vStride,
void *userData)
{
OCTToxAV *toxAV = (__bridge OCTToxAV *)userData;
if ([toxAV.delegate respondsToSelector:@selector(toxAV:receiveVideoFrameWithWidth:height:yPlane:uPlane:vPlane:yStride:uStride:vStride:friendNumber:)]) {
[toxAV.delegate toxAV:toxAV
receiveVideoFrameWithWidth:width height:height
yPlane:yPlane uPlane:uPlane vPlane:vPlane
yStride:yStride uStride:uStride vStride:vStride
friendNumber:friendNumber];
}
}