Skip to content

Commit

Permalink
Refactor toxav_call_control
Browse files Browse the repository at this point in the history 
Control logic is now placed in control-specific helper functions
instead of having one giant confusing function that does everything
  • Loading branch information
@JFreegman
JFreegman committed Jan 13, 2022
1 parent 28b5e51 commit dfa7a01
Showing 1 changed file with 130 additions and 123 deletions.
253 changes: 130 additions & 123 deletions toxav/toxav.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -473,156 +473,163 @@ void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback, void *u
av->scb_user_data = user_data;
pthread_mutex_unlock(av->mutex);
}
bool toxav_call_control(ToxAV *av, uint32_t friend_number, Toxav_Call_Control control, Toxav_Err_Call_Control *error)
static Toxav_Err_Call_Control call_control_handle_resume(const ToxAVCall *call)
{
pthread_mutex_lock(av->mutex);
Toxav_Err_Call_Control rc = TOXAV_ERR_CALL_CONTROL_OK;
ToxAVCall *call;
/* Only act if paused and had media transfer active before */
if (call->msi_call->self_capabilities != 0 || call->previous_self_capabilities == 0) {
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
}

if (m_friend_exists(av->m, friend_number) == 0) {
rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND;
goto RETURN;
if (msi_change_capabilities(call->msi_call, call->previous_self_capabilities) == -1) {
return TOXAV_ERR_CALL_CONTROL_SYNC;
}

call = call_get(av, friend_number);
rtp_allow_receiving(call->audio_rtp);
rtp_allow_receiving(call->video_rtp);

if (call == nullptr || (!call->active && control != TOXAV_CALL_CONTROL_CANCEL)) {
rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL;
goto RETURN;
return TOXAV_ERR_CALL_CONTROL_OK;
}
static Toxav_Err_Call_Control call_control_handle_pause(ToxAVCall *call)
{
/* Only act if not already paused */
if (!call->msi_call->self_capabilities) {
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
}

switch (control) {
case TOXAV_CALL_CONTROL_RESUME: {
/* Only act if paused and had media transfer active before */
if (call->msi_call->self_capabilities == 0 &&
call->previous_self_capabilities) {

if (msi_change_capabilities(call->msi_call,
call->previous_self_capabilities) == -1) {
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
goto RETURN;
}

rtp_allow_receiving(call->audio_rtp);
rtp_allow_receiving(call->video_rtp);
} else {
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
goto RETURN;
}
call->previous_self_capabilities = call->msi_call->self_capabilities;

break;
}
if (msi_change_capabilities(call->msi_call, 0) == -1) {
return TOXAV_ERR_CALL_CONTROL_SYNC;
}

case TOXAV_CALL_CONTROL_PAUSE: {
/* Only act if not already paused */
if (call->msi_call->self_capabilities) {
call->previous_self_capabilities = call->msi_call->self_capabilities;
rtp_stop_receiving(call->audio_rtp);
rtp_stop_receiving(call->video_rtp);

if (msi_change_capabilities(call->msi_call, 0) == -1) {
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
goto RETURN;
}
return TOXAV_ERR_CALL_CONTROL_OK;
}
static Toxav_Err_Call_Control call_control_handle_cancel(ToxAVCall *call)
{
/* Hang up */
pthread_mutex_lock(call->toxav_call_mutex);

rtp_stop_receiving(call->audio_rtp);
rtp_stop_receiving(call->video_rtp);
} else {
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
goto RETURN;
}
if (msi_hangup(call->msi_call) != 0) {
pthread_mutex_unlock(call->toxav_call_mutex);
return TOXAV_ERR_CALL_CONTROL_SYNC;
}

break;
}
call->msi_call = nullptr;
pthread_mutex_unlock(call->toxav_call_mutex);

case TOXAV_CALL_CONTROL_CANCEL: {
/* Hang up */
pthread_mutex_lock(call->toxav_call_mutex);
/* No matter the case, terminate the call */
call_kill_transmission(call);
call_remove(call);

if (msi_hangup(call->msi_call) != 0) {
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
pthread_mutex_unlock(call->toxav_call_mutex);
goto RETURN;
}
return TOXAV_ERR_CALL_CONTROL_OK;
}
static Toxav_Err_Call_Control call_control_handle_mute_audio(const ToxAVCall *call)
{
if (!(call->msi_call->self_capabilities & MSI_CAP_R_AUDIO)) {
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
}

call->msi_call = nullptr;
pthread_mutex_unlock(call->toxav_call_mutex);
if (msi_change_capabilities(call->msi_call, call->
msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) == -1) {
return TOXAV_ERR_CALL_CONTROL_SYNC;

/* No mather the case, terminate the call */
call_kill_transmission(call);
call_remove(call);
}

break;
}
rtp_stop_receiving(call->audio_rtp);
return TOXAV_ERR_CALL_CONTROL_OK;
}
static Toxav_Err_Call_Control call_control_handle_unmute_audio(const ToxAVCall *call)
{
if (!(call->msi_call->self_capabilities ^ MSI_CAP_R_AUDIO)) {
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
}

case TOXAV_CALL_CONTROL_MUTE_AUDIO: {
if (call->msi_call->self_capabilities & MSI_CAP_R_AUDIO) {
if (msi_change_capabilities(call->msi_call, call->
msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) == -1) {
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
goto RETURN;
}

rtp_stop_receiving(call->audio_rtp);
} else {
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
goto RETURN;
}
if (msi_change_capabilities(call->msi_call, call->
msi_call->self_capabilities | MSI_CAP_R_AUDIO) == -1) {
return TOXAV_ERR_CALL_CONTROL_SYNC;
}

break;
}
rtp_allow_receiving(call->audio_rtp);
return TOXAV_ERR_CALL_CONTROL_OK;
}
static Toxav_Err_Call_Control call_control_handle_hide_video(const ToxAVCall *call)
{
if (!(call->msi_call->self_capabilities & MSI_CAP_R_VIDEO)) {
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
}

case TOXAV_CALL_CONTROL_UNMUTE_AUDIO: {
if (call->msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) {
if (msi_change_capabilities(call->msi_call, call->
msi_call->self_capabilities | MSI_CAP_R_AUDIO) == -1) {
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
goto RETURN;
}

rtp_allow_receiving(call->audio_rtp);
} else {
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
goto RETURN;
}
if (msi_change_capabilities(call->msi_call, call->
msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) == -1) {
return TOXAV_ERR_CALL_CONTROL_SYNC;
}

break;
}
rtp_stop_receiving(call->video_rtp);
return TOXAV_ERR_CALL_CONTROL_OK;
}
static Toxav_Err_Call_Control call_control_handle_show_video(const ToxAVCall *call)
{
if (!(call->msi_call->self_capabilities ^ MSI_CAP_R_VIDEO)) {
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
}

case TOXAV_CALL_CONTROL_HIDE_VIDEO: {
if (call->msi_call->self_capabilities & MSI_CAP_R_VIDEO) {
if (msi_change_capabilities(call->msi_call, call->
msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) == -1) {
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
goto RETURN;
}

rtp_stop_receiving(call->video_rtp);
} else {
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
goto RETURN;
}
if (msi_change_capabilities(call->msi_call, call->
msi_call->self_capabilities | MSI_CAP_R_VIDEO) == -1) {
return TOXAV_ERR_CALL_CONTROL_SYNC;
}

break;
}
rtp_allow_receiving(call->video_rtp);
return TOXAV_ERR_CALL_CONTROL_OK;
}
static Toxav_Err_Call_Control call_control_handle(ToxAVCall *call, Toxav_Call_Control control)
{
switch (control) {
case TOXAV_CALL_CONTROL_RESUME:
return call_control_handle_resume(call);

case TOXAV_CALL_CONTROL_SHOW_VIDEO: {
if (call->msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) {
if (msi_change_capabilities(call->msi_call, call->
msi_call->self_capabilities | MSI_CAP_R_VIDEO) == -1) {
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
goto RETURN;
}

rtp_allow_receiving(call->video_rtp);
} else {
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
goto RETURN;
}
case TOXAV_CALL_CONTROL_PAUSE:
return call_control_handle_pause(call);

break;
}
case TOXAV_CALL_CONTROL_CANCEL:
return call_control_handle_cancel(call);

case TOXAV_CALL_CONTROL_MUTE_AUDIO:
return call_control_handle_mute_audio(call);

case TOXAV_CALL_CONTROL_UNMUTE_AUDIO:
return call_control_handle_unmute_audio(call);

case TOXAV_CALL_CONTROL_HIDE_VIDEO:
return call_control_handle_hide_video(call);

case TOXAV_CALL_CONTROL_SHOW_VIDEO:
return call_control_handle_show_video(call);
}

RETURN:
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
}
static Toxav_Err_Call_Control call_control(ToxAV *av, uint32_t friend_number, Toxav_Call_Control control)
{
if (m_friend_exists(av->m, friend_number) == 0) {
return TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND;
}

ToxAVCall *call = call_get(av, friend_number);

if (call == nullptr || (!call->active && control != TOXAV_CALL_CONTROL_CANCEL)) {
return TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL;
}

return call_control_handle(call, control);
}
bool toxav_call_control(ToxAV *av, uint32_t friend_number, Toxav_Call_Control control, Toxav_Err_Call_Control *error)
{
pthread_mutex_lock(av->mutex);

Toxav_Err_Call_Control rc = call_control(av, friend_number, control);

pthread_mutex_unlock(av->mutex);

if (error) {
Expand Down

0 comments on commit dfa7a01

Please sign in to comment.