Skip to content

Commit dfa7a01

Browse files
JFreegmanJFreegman
committed
Refactor toxav_call_control
Control logic is now placed in control-specific helper functions instead of having one giant confusing function that does everything
1 parent 28b5e51 commit dfa7a01

File tree

1 file changed

+130
-123
lines changed

1 file changed

+130
-123
lines changed

‎toxav/toxav.c‎

Lines changed: 130 additions & 123 deletions
Original file line numberDiff line numberDiff line change
@@ -473,156 +473,163 @@ void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback, void *u
473473
av->scb_user_data = user_data;
474474
pthread_mutex_unlock(av->mutex);
475475
}
476-
bool toxav_call_control(ToxAV *av, uint32_t friend_number, Toxav_Call_Control control, Toxav_Err_Call_Control *error)
476+
static Toxav_Err_Call_Control call_control_handle_resume(const ToxAVCall *call)
477477
{
478-
pthread_mutex_lock(av->mutex);
479-
Toxav_Err_Call_Control rc = TOXAV_ERR_CALL_CONTROL_OK;
480-
ToxAVCall *call;
478+
/* Only act if paused and had media transfer active before */
479+
if (call->msi_call->self_capabilities != 0 || call->previous_self_capabilities == 0) {
480+
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
481+
}
481482

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

487-
call = call_get(av, friend_number);
487+
rtp_allow_receiving(call->audio_rtp);
488+
rtp_allow_receiving(call->video_rtp);
488489

489-
if (call == nullptr || (!call->active && control != TOXAV_CALL_CONTROL_CANCEL)) {
490-
rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL;
491-
goto RETURN;
490+
return TOXAV_ERR_CALL_CONTROL_OK;
491+
}
492+
static Toxav_Err_Call_Control call_control_handle_pause(ToxAVCall *call)
493+
{
494+
/* Only act if not already paused */
495+
if (!call->msi_call->self_capabilities) {
496+
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
492497
}
493498

494-
switch (control) {
495-
case TOXAV_CALL_CONTROL_RESUME: {
496-
/* Only act if paused and had media transfer active before */
497-
if (call->msi_call->self_capabilities == 0 &&
498-
call->previous_self_capabilities) {
499-
500-
if (msi_change_capabilities(call->msi_call,
501-
call->previous_self_capabilities) == -1) {
502-
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
503-
goto RETURN;
504-
}
505-
506-
rtp_allow_receiving(call->audio_rtp);
507-
rtp_allow_receiving(call->video_rtp);
508-
} else {
509-
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
510-
goto RETURN;
511-
}
499+
call->previous_self_capabilities = call->msi_call->self_capabilities;
512500

513-
break;
514-
}
501+
if (msi_change_capabilities(call->msi_call, 0) == -1) {
502+
return TOXAV_ERR_CALL_CONTROL_SYNC;
503+
}
515504

516-
case TOXAV_CALL_CONTROL_PAUSE: {
517-
/* Only act if not already paused */
518-
if (call->msi_call->self_capabilities) {
519-
call->previous_self_capabilities = call->msi_call->self_capabilities;
505+
rtp_stop_receiving(call->audio_rtp);
506+
rtp_stop_receiving(call->video_rtp);
520507

521-
if (msi_change_capabilities(call->msi_call, 0) == -1) {
522-
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
523-
goto RETURN;
524-
}
508+
return TOXAV_ERR_CALL_CONTROL_OK;
509+
}
510+
static Toxav_Err_Call_Control call_control_handle_cancel(ToxAVCall *call)
511+
{
512+
/* Hang up */
513+
pthread_mutex_lock(call->toxav_call_mutex);
525514

526-
rtp_stop_receiving(call->audio_rtp);
527-
rtp_stop_receiving(call->video_rtp);
528-
} else {
529-
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
530-
goto RETURN;
531-
}
515+
if (msi_hangup(call->msi_call) != 0) {
516+
pthread_mutex_unlock(call->toxav_call_mutex);
517+
return TOXAV_ERR_CALL_CONTROL_SYNC;
518+
}
532519

533-
break;
534-
}
520+
call->msi_call = nullptr;
521+
pthread_mutex_unlock(call->toxav_call_mutex);
535522

536-
case TOXAV_CALL_CONTROL_CANCEL: {
537-
/* Hang up */
538-
pthread_mutex_lock(call->toxav_call_mutex);
523+
/* No matter the case, terminate the call */
524+
call_kill_transmission(call);
525+
call_remove(call);
539526

540-
if (msi_hangup(call->msi_call) != 0) {
541-
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
542-
pthread_mutex_unlock(call->toxav_call_mutex);
543-
goto RETURN;
544-
}
527+
return TOXAV_ERR_CALL_CONTROL_OK;
528+
}
529+
static Toxav_Err_Call_Control call_control_handle_mute_audio(const ToxAVCall *call)
530+
{
531+
if (!(call->msi_call->self_capabilities & MSI_CAP_R_AUDIO)) {
532+
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
533+
}
545534

546-
call->msi_call = nullptr;
547-
pthread_mutex_unlock(call->toxav_call_mutex);
535+
if (msi_change_capabilities(call->msi_call, call->
536+
msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) == -1) {
537+
return TOXAV_ERR_CALL_CONTROL_SYNC;
548538

549-
/* No mather the case, terminate the call */
550-
call_kill_transmission(call);
551-
call_remove(call);
539+
}
552540

553-
break;
554-
}
541+
rtp_stop_receiving(call->audio_rtp);
542+
return TOXAV_ERR_CALL_CONTROL_OK;
543+
}
544+
static Toxav_Err_Call_Control call_control_handle_unmute_audio(const ToxAVCall *call)
545+
{
546+
if (!(call->msi_call->self_capabilities ^ MSI_CAP_R_AUDIO)) {
547+
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
548+
}
555549

556-
case TOXAV_CALL_CONTROL_MUTE_AUDIO: {
557-
if (call->msi_call->self_capabilities & MSI_CAP_R_AUDIO) {
558-
if (msi_change_capabilities(call->msi_call, call->
559-
msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) == -1) {
560-
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
561-
goto RETURN;
562-
}
563-
564-
rtp_stop_receiving(call->audio_rtp);
565-
} else {
566-
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
567-
goto RETURN;
568-
}
550+
if (msi_change_capabilities(call->msi_call, call->
551+
msi_call->self_capabilities | MSI_CAP_R_AUDIO) == -1) {
552+
return TOXAV_ERR_CALL_CONTROL_SYNC;
553+
}
569554

570-
break;
571-
}
555+
rtp_allow_receiving(call->audio_rtp);
556+
return TOXAV_ERR_CALL_CONTROL_OK;
557+
}
558+
static Toxav_Err_Call_Control call_control_handle_hide_video(const ToxAVCall *call)
559+
{
560+
if (!(call->msi_call->self_capabilities & MSI_CAP_R_VIDEO)) {
561+
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
562+
}
572563

573-
case TOXAV_CALL_CONTROL_UNMUTE_AUDIO: {
574-
if (call->msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) {
575-
if (msi_change_capabilities(call->msi_call, call->
576-
msi_call->self_capabilities | MSI_CAP_R_AUDIO) == -1) {
577-
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
578-
goto RETURN;
579-
}
580-
581-
rtp_allow_receiving(call->audio_rtp);
582-
} else {
583-
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
584-
goto RETURN;
585-
}
564+
if (msi_change_capabilities(call->msi_call, call->
565+
msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) == -1) {
566+
return TOXAV_ERR_CALL_CONTROL_SYNC;
567+
}
586568

587-
break;
588-
}
569+
rtp_stop_receiving(call->video_rtp);
570+
return TOXAV_ERR_CALL_CONTROL_OK;
571+
}
572+
static Toxav_Err_Call_Control call_control_handle_show_video(const ToxAVCall *call)
573+
{
574+
if (!(call->msi_call->self_capabilities ^ MSI_CAP_R_VIDEO)) {
575+
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
576+
}
589577

590-
case TOXAV_CALL_CONTROL_HIDE_VIDEO: {
591-
if (call->msi_call->self_capabilities & MSI_CAP_R_VIDEO) {
592-
if (msi_change_capabilities(call->msi_call, call->
593-
msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) == -1) {
594-
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
595-
goto RETURN;
596-
}
597-
598-
rtp_stop_receiving(call->video_rtp);
599-
} else {
600-
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
601-
goto RETURN;
602-
}
578+
if (msi_change_capabilities(call->msi_call, call->
579+
msi_call->self_capabilities | MSI_CAP_R_VIDEO) == -1) {
580+
return TOXAV_ERR_CALL_CONTROL_SYNC;
581+
}
603582

604-
break;
605-
}
583+
rtp_allow_receiving(call->video_rtp);
584+
return TOXAV_ERR_CALL_CONTROL_OK;
585+
}
586+
static Toxav_Err_Call_Control call_control_handle(ToxAVCall *call, Toxav_Call_Control control)
587+
{
588+
switch (control) {
589+
case TOXAV_CALL_CONTROL_RESUME:
590+
return call_control_handle_resume(call);
606591

607-
case TOXAV_CALL_CONTROL_SHOW_VIDEO: {
608-
if (call->msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) {
609-
if (msi_change_capabilities(call->msi_call, call->
610-
msi_call->self_capabilities | MSI_CAP_R_VIDEO) == -1) {
611-
rc = TOXAV_ERR_CALL_CONTROL_SYNC;
612-
goto RETURN;
613-
}
614-
615-
rtp_allow_receiving(call->video_rtp);
616-
} else {
617-
rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
618-
goto RETURN;
619-
}
592+
case TOXAV_CALL_CONTROL_PAUSE:
593+
return call_control_handle_pause(call);
620594

621-
break;
622-
}
595+
case TOXAV_CALL_CONTROL_CANCEL:
596+
return call_control_handle_cancel(call);
597+
598+
case TOXAV_CALL_CONTROL_MUTE_AUDIO:
599+
return call_control_handle_mute_audio(call);
600+
601+
case TOXAV_CALL_CONTROL_UNMUTE_AUDIO:
602+
return call_control_handle_unmute_audio(call);
603+
604+
case TOXAV_CALL_CONTROL_HIDE_VIDEO:
605+
return call_control_handle_hide_video(call);
606+
607+
case TOXAV_CALL_CONTROL_SHOW_VIDEO:
608+
return call_control_handle_show_video(call);
623609
}
624610

625-
RETURN:
611+
return TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
612+
}
613+
static Toxav_Err_Call_Control call_control(ToxAV *av, uint32_t friend_number, Toxav_Call_Control control)
614+
{
615+
if (m_friend_exists(av->m, friend_number) == 0) {
616+
return TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND;
617+
}
618+
619+
ToxAVCall *call = call_get(av, friend_number);
620+
621+
if (call == nullptr || (!call->active && control != TOXAV_CALL_CONTROL_CANCEL)) {
622+
return TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL;
623+
}
624+
625+
return call_control_handle(call, control);
626+
}
627+
bool toxav_call_control(ToxAV *av, uint32_t friend_number, Toxav_Call_Control control, Toxav_Err_Call_Control *error)
628+
{
629+
pthread_mutex_lock(av->mutex);
630+
631+
Toxav_Err_Call_Control rc = call_control(av, friend_number, control);
632+
626633
pthread_mutex_unlock(av->mutex);
627634

628635
if (error) {

0 commit comments

Comments
 (0)