Improved protocol and cleaned code a bit

1 files changed, 72 insertions, 74 deletions

diff --git a/auto_tests/toxav_many_test.c b/auto_tests/toxav_many_test.c
index 2a931cb0..b64caf10 100644
--- a/auto_tests/toxav_many_test.c
+++ b/auto_tests/toxav_many_test.c
@@ -24,6 +24,7 @@
 #define c_sleep(x) usleep(1000*x)
 #endif
 
+pthread_mutex_t muhmutex;
 
 typedef enum _CallStatus {
     none,
@@ -43,6 +44,7 @@ typedef struct _Party {
 
 typedef struct _ACall {
     pthread_t tid;
+    int idx;
 
     Party Caller;
     Party Callee;
@@ -52,6 +54,8 @@ typedef struct _Status {
     ACall calls[3]; /* Make 3 calls for this test */
 } Status;
 
+Status status_control;
+
 void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata)
 {
     if (length == 7 && memcmp("gentoo", data, 7) == 0) {
@@ -61,58 +65,49 @@ void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *dat
 
 
 /******************************************************************************/
-void callback_recv_invite ( int32_t call_index, void *_arg )
+void callback_recv_invite ( void* av, int32_t call_index, void *_arg )
 {
     /*
        Status *cast = _arg;
 
        cast->calls[call_index].Callee.status = Ringing;*/
 }
-void callback_recv_ringing ( int32_t call_index, void *_arg )
+void callback_recv_ringing ( void* av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
-
     cast->calls[call_index].Caller.status = Ringing;
 }
-void callback_recv_starting ( int32_t call_index, void *_arg )
+void callback_recv_starting ( void* av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
-
     cast->calls[call_index].Caller.status = InCall;
 }
-void callback_recv_ending ( int32_t call_index, void *_arg )
+void callback_recv_ending ( void* av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
-
     cast->calls[call_index].Caller.status = Ended;
 }
 
-void callback_recv_error ( int32_t call_index, void *_arg )
-{
-    ck_assert_msg(0, "AV internal error");
-}
-
-void callback_call_started ( int32_t call_index, void *_arg )
+void callback_call_started ( void* av, int32_t call_index, void *_arg )
 {
     /*
        Status *cast = _arg;
 
        cast->calls[call_index].Callee.status = InCall;*/
 }
-void callback_call_canceled ( int32_t call_index, void *_arg )
+void callback_call_canceled ( void* av, int32_t call_index, void *_arg )
 {
     /*
        Status *cast = _arg;
 
        cast->calls[call_index].Callee.status = Cancel;*/
 }
-void callback_call_rejected ( int32_t call_index, void *_arg )
+void callback_call_rejected ( void* av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
-
     cast->calls[call_index].Caller.status = Rejected;
 }
-void callback_call_ended ( int32_t call_index, void *_arg )
+void callback_call_ended ( void* av, int32_t call_index, void *_arg )
 {
     /*
        Status *cast = _arg;
@@ -120,12 +115,40 @@ void callback_call_ended ( int32_t call_index, void *_arg )
        cast->calls[call_index].Callee.status = Ended;*/
 }
 
-void callback_requ_timeout ( int32_t call_index, void *_arg )
+void callback_requ_timeout ( void* av, int32_t call_index, void *_arg )
 {
     ck_assert_msg(0, "No answer!");
 }
+
+static void callback_audio(ToxAv *av, int32_t call_index, int16_t *data, int length)
+{
+}
+
+static void callback_video(ToxAv *av, int32_t call_index, vpx_image_t *img)
+{
+}
+
+void register_callbacks(ToxAv* av, void* data)
+{
+    toxav_register_callstate_callback(av, callback_call_started, av_OnStart, data);
+    toxav_register_callstate_callback(av, callback_call_canceled, av_OnCancel, data);
+    toxav_register_callstate_callback(av, callback_call_rejected, av_OnReject, data);
+    toxav_register_callstate_callback(av, callback_call_ended, av_OnEnd, data);
+    toxav_register_callstate_callback(av, callback_recv_invite, av_OnInvite, data);
+    
+    toxav_register_callstate_callback(av, callback_recv_ringing, av_OnRinging, data);
+    toxav_register_callstate_callback(av, callback_recv_starting, av_OnStarting, data);
+    toxav_register_callstate_callback(av, callback_recv_ending, av_OnEnding, data);
+    
+    toxav_register_callstate_callback(av, callback_requ_timeout, av_OnRequestTimeout, data);
+    
+    
+    toxav_register_audio_recv_callback(av, callback_audio);
+    toxav_register_video_recv_callback(av, callback_video);
+}
 /*************************************************************************************************/
 
+int call_running[3];
 
 void *in_thread_call (void *arg)
 {
@@ -133,18 +156,22 @@ void *in_thread_call (void *arg)
 
     ACall *this_call = arg;
     uint64_t start = 0;
-    int step = 0, running = 1;
+    int step = 0;
     int call_idx;
-
+    
+    call_running[this_call->idx] = 1;
+    
     const int frame_size = (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000);
     int16_t sample_payload[frame_size];
     randombytes((uint8_t *)sample_payload, sizeof(int16_t) * frame_size);
 
     uint8_t prepared_payload[RTP_PAYLOAD_SIZE];
 
-
+    register_callbacks(this_call->Caller.av, &status_control);
+    register_callbacks(this_call->Callee.av, arg);
+    
     /* NOTE: CALLEE WILL ALWAHYS NEED CALL_IDX == 0 */
-    while (running) {
+    while (call_running[this_call->idx]) {
 
         switch ( step ) {
             case 0: /* CALLER */
@@ -191,27 +218,15 @@ void *in_thread_call (void *arg)
                         int16_t storage[RTP_PAYLOAD_SIZE];
                         int recved;
 
-                        /* Payload from CALLER */
-                        recved = toxav_recv_audio(this_call->Callee.av, 0, frame_size, storage);
-
-                        if ( recved ) {
-                            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from CALLER is invalid");*/
-                        }
-
-                        /* Payload from CALLEE */
-                        recved = toxav_recv_audio(this_call->Caller.av, call_idx, frame_size, storage);
-
-                        if ( recved ) {
-                            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from CALLEE is invalid");*/
-                        }
-
                         c_sleep(20);
                     }
 
                     step++; /* This terminates the loop */
 
+                    pthread_mutex_lock(&muhmutex);
                     toxav_kill_transmission(this_call->Callee.av, 0);
                     toxav_kill_transmission(this_call->Caller.av, call_idx);
+                    pthread_mutex_unlock(&muhmutex);
 
                     /* Call over CALLER hangs up */
                     toxav_hangup(this_call->Caller.av, call_idx);
@@ -224,7 +239,7 @@ void *in_thread_call (void *arg)
                 if (this_call->Caller.status == Ended) {
                     c_sleep(1000); /* race condition */
                     this_call->Callee.status = Ended;
-                    running = 0;
+                    call_running[this_call->idx] = 0;
                 }
 
                 break;
@@ -306,55 +321,38 @@ START_TEST(test_AV_three_calls)
 
     ToxAv *uniqcallerav = toxav_new(caller, 3);
 
-    Status status_control = {
-        0,
-        {none, uniqcallerav, 0},
-        {none, toxav_new(callees[0], 1), 0},
-
-        0,
-        {none, uniqcallerav},
-        {none, toxav_new(callees[1], 1), 1},
-
-        0,
-        {none, uniqcallerav},
-        {none, toxav_new(callees[2], 1), 2}
-    };
-
-
-    toxav_register_callstate_callback(callback_call_started, av_OnStart, &status_control);
-    toxav_register_callstate_callback(callback_call_canceled, av_OnCancel, &status_control);
-    toxav_register_callstate_callback(callback_call_rejected, av_OnReject, &status_control);
-    toxav_register_callstate_callback(callback_call_ended, av_OnEnd, &status_control);
-    toxav_register_callstate_callback(callback_recv_invite, av_OnInvite, &status_control);
-
-    toxav_register_callstate_callback(callback_recv_ringing, av_OnRinging, &status_control);
-    toxav_register_callstate_callback(callback_recv_starting, av_OnStarting, &status_control);
-    toxav_register_callstate_callback(callback_recv_ending, av_OnEnding, &status_control);
-
-    toxav_register_callstate_callback(callback_recv_error, av_OnError, &status_control);
-    toxav_register_callstate_callback(callback_requ_timeout, av_OnRequestTimeout, &status_control);
-
-
+    for (i = 0; i < 3; i ++) {
+        status_control.calls[i].idx = i;
+        
+        status_control.calls[i].Caller.av = uniqcallerav;
+        status_control.calls[i].Caller.id = 0;
+        status_control.calls[i].Caller.status= none;
+        
+        status_control.calls[i].Callee.av = toxav_new(callees[i], 1);
+        status_control.calls[i].Callee.id = i;
+        status_control.calls[i].Callee.status= none;
+    }
+        
+    pthread_mutex_init(&muhmutex, NULL);
 
-    for ( i = 0; i < 3; i++ )
+    for ( i = 0; i < 3; i++ ) 
         pthread_create(&status_control.calls[i].tid, NULL, in_thread_call, &status_control.calls[i]);
 
-
     /* Now start 3 calls and they'll run for 10 s */
 
     for ( i = 0; i < 3; i++ )
         pthread_detach(status_control.calls[i].tid);
 
-    while (
-        status_control.calls[0].Callee.status != Ended && status_control.calls[0].Caller.status != Ended &&
-        status_control.calls[1].Callee.status != Ended && status_control.calls[1].Caller.status != Ended &&
-        status_control.calls[2].Callee.status != Ended && status_control.calls[2].Caller.status != Ended
-    ) {
+    while (call_running[0] || call_running[1] || call_running[2]) {
+        pthread_mutex_lock(&muhmutex);
+
         tox_do(bootstrap_node);
         tox_do(caller);
         tox_do(callees[0]);
         tox_do(callees[1]);
         tox_do(callees[2]);
+
+        pthread_mutex_unlock(&muhmutex);
         c_sleep(20);
     }
 
@@ -403,4 +401,4 @@ int main(int argc, char *argv[])
 //     test_AV_three_calls();
 //
 //     return 0;
-}
\ No newline at end of file
+}