1 files changed, 130 insertions, 139 deletions

diff --git a/auto_tests/toxav_basic_test.c b/auto_tests/toxav_basic_test.c
index bf130ecb..1361edd3 100644
--- a/auto_tests/toxav_basic_test.c
+++ b/auto_tests/toxav_basic_test.c
@@ -31,7 +31,8 @@ typedef enum _CallStatus {
     Ringing,
     Ended,
     Rejected,
-    Cancel
+    Cancel,
+    TimedOut
 
 } CallStatus;
 
@@ -59,7 +60,7 @@ 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;
 
@@ -67,23 +68,23 @@ void callback_recv_invite ( int32_t call_index, void *_arg )
     cast->Bob.status = Ringing;
     cast->Bob.call_index = call_index;
 }
-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;
 
     /* Alice always sends invite */
     cast->Alice.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;
 
     /* Alice always sends invite */
     printf("Call started on Alice side...\n");
     cast->Alice.status = InCall;
-    toxav_prepare_transmission(cast->Alice.av, call_index, &muhcaps, 1);
+    toxav_prepare_transmission(av, call_index, &muhcaps, 1);
 }
-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;
 
@@ -96,28 +97,24 @@ void callback_recv_ending ( int32_t call_index, void *_arg )
     }
 }
 
-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;
 
     /* Alice always sends invite */
     printf("Call started on Bob side...\n");
     cast->Bob.status = InCall;
-    toxav_prepare_transmission(cast->Bob.av, call_index, &muhcaps, 1);
+    toxav_prepare_transmission(av, call_index, &muhcaps, 1);
 }
-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;
 
     printf ( "Call Canceled for Bob!\n" );
     cast->Bob.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;
 
@@ -126,17 +123,25 @@ void callback_call_rejected ( int32_t call_index, void *_arg )
     /* If Bob rejects, call is ended for alice and she sends ending */
     cast->Alice.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;
-
+    
     printf ( "Call ended for Bob!\n" );
     cast->Bob.status = Ended;
 }
 
-void callback_requ_timeout ( int32_t call_index, void *_arg )
+void callback_call_type_change ( void *av, int32_t call_index, void *_arg )
+{
+    printf("Call type changed; new type: %s!\n", toxav_get_peer_transmission_type
+          (av, call_index, 0) == TypeAudio ? "audio" : "video");
+}
+
+void callback_requ_timeout ( void *av, int32_t call_index, void *_arg )
 {
-    ck_assert_msg(0, "No answer!");
+    Status *cast = _arg;
+    printf("Call timed-out!");
+    cast->Alice.status = TimedOut;
 }
 
 static void callback_audio(ToxAv *av, int32_t call_index, int16_t *data, int length)
@@ -147,10 +152,31 @@ 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_callstate_callback(av, callback_call_type_change, av_OnMediaChange, data);
+    
+    
+    toxav_register_audio_recv_callback(av, callback_audio);
+    toxav_register_video_recv_callback(av, callback_video);
+}
+
+
 /*************************************************************************************************/
 
 /* Alice calls bob and the call starts.
- * What happens in the call is defined after. To quit the loop use: step++;
+ * What happens during the call is defined after. To quit the loop use: step++;
  */
 #define CALL_AND_START_LOOP(AliceCallType, BobCallType) \
 { int step = 0, running = 1; while (running) {\
@@ -218,23 +244,8 @@ START_TEST(test_AV_flows)
     ck_assert_msg(status_control.Alice.av || status_control.Bob.av, "Failed to create 2 toxav instances");
 
 
-    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);
-
-    toxav_register_audio_recv_callback(status_control.Alice.av, callback_audio);
-    toxav_register_video_recv_callback(status_control.Alice.av, callback_video);
-    toxav_register_audio_recv_callback(status_control.Bob.av, callback_audio);
-    toxav_register_video_recv_callback(status_control.Bob.av, callback_video);
+    register_callbacks(status_control.Alice.av, &status_control);
+    register_callbacks(status_control.Bob.av, &status_control);
 
     const int frame_size = (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000);
     int16_t sample_payload[frame_size];
@@ -279,24 +290,6 @@ START_TEST(test_AV_flows)
 
         toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size);
 
-        /* Both receive */
-        /*int16_t storage[frame_size];
-        int recved;
-
-        /* Payload from Bob */
-
-        /*recved = toxav_recv_audio(status_control.Alice.av, status_control.Alice.call_index, frame_size, storage);
-
-        if ( recved ) {
-            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");
-        }
-
-        recved = toxav_recv_audio(status_control.Bob.av, status_control.Bob.call_index, frame_size, storage);
-
-        if ( recved ) {
-            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Alice is invalid");
-        }*/
-
         if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
             step++; /* This terminates the loop */
             toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index);
@@ -334,38 +327,6 @@ START_TEST(test_AV_flows)
 
 //         toxav_send_video(status_control.Bob.av, status_control.Bob.call_index, sample_image);
 
-        /* Both receive */
-        int16_t storage[frame_size];
-        vpx_image_t *video_storage;
-        int recved;
-
-        /* Payload from Bob */
-        /*recved = toxav_recv_audio(status_control.Alice.av, status_control.Alice.call_index, frame_size, storage);
-
-        if ( recved ) {
-            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");
-        }*/
-
-        /* Video payload */
-//         toxav_recv_video(status_control.Alice.av, status_control.Alice.call_index, &video_storage);
-//
-//         if ( video_storage ) {
-//             /*ck_assert_msg( memcmp(video_storage->planes[VPX_PLANE_Y], sample_payload, 10) == 0 ||
-//                            memcmp(video_storage->planes[VPX_PLANE_U], sample_payload, 10) == 0 ||
-//                            memcmp(video_storage->planes[VPX_PLANE_V], sample_payload, 10) == 0 , "Payload from Bob is invalid");*/
-//             vpx_img_free(video_storage);
-//         }
-
-
-
-
-        /* Payload from Alice */
-        /*recved = toxav_recv_audio(status_control.Bob.av, status_control.Bob.call_index, frame_size, storage);
-
-        if ( recved ) {
-            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Alice is invalid");
-        }*/
-
         if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
             step++; /* This terminates the loop */
             toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index);
@@ -405,48 +366,6 @@ START_TEST(test_AV_flows)
 //         toxav_send_video(status_control.Alice.av, status_control.Alice.call_index, sample_image);
 //         toxav_send_video(status_control.Bob.av, status_control.Bob.call_index, sample_image);
 
-        /* Both receive */
-        int16_t storage[frame_size];
-        vpx_image_t *video_storage;
-        int recved;
-
-        /* Payload from Bob */
-        /*recved = toxav_recv_audio(status_control.Alice.av, status_control.Alice.call_index, frame_size, storage);
-
-        if ( recved ) {
-            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");
-        }*/
-
-        /* Video payload */
-//         toxav_recv_video(status_control.Alice.av, status_control.Alice.call_index, &video_storage);
-//
-//         if ( video_storage ) {
-//             /*ck_assert_msg( memcmp(video_storage->planes[VPX_PLANE_Y], sample_payload, 10) == 0 ||
-//             memcmp(video_storage->planes[VPX_PLANE_U], sample_payload, 10) == 0 ||
-//             memcmp(video_storage->planes[VPX_PLANE_V], sample_payload, 10) == 0 , "Payload from Bob is invalid");*/
-//             vpx_img_free(video_storage);
-//         }
-
-
-
-
-        /* Payload from Alice */
-        /*recved = toxav_recv_audio(status_control.Bob.av, status_control.Bob.call_index, frame_size, storage);
-
-        if ( recved ) {
-            ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Alice is invalid");
-        }*/
-
-        /* Video payload */
-//         toxav_recv_video(status_control.Bob.av, status_control.Bob.call_index, &video_storage);
-//
-//         if ( video_storage ) {
-//             /*ck_assert_msg( memcmp(video_storage->planes[VPX_PLANE_Y], sample_payload, 10) == 0 ||
-//             memcmp(video_storage->planes[VPX_PLANE_U], sample_payload, 10) == 0 ||
-//             memcmp(video_storage->planes[VPX_PLANE_V], sample_payload, 10) == 0 , "Payload from Alice is invalid");*/
-//             vpx_img_free(video_storage);
-//         }
-
 
         if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
             step++; /* This terminates the loop */
@@ -459,8 +378,49 @@ START_TEST(test_AV_flows)
     }
     TERMINATE_SCOPE()
 
+    
+    uint64_t times_they_are_a_changin = time(NULL);
+    /* Media change */
+    CALL_AND_START_LOOP(TypeAudio, TypeAudio) {
+        /* Both send */
+        payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload,
+                                                 1000, sample_payload, frame_size);
+        
+        if ( payload_size < 0 ) {
+            ck_assert_msg ( 0, "Failed to encode payload" );
+        }
+        
+        toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size);
+        
+        payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000,
+                                                 sample_payload, frame_size);
+        
+        if ( payload_size < 0 ) {
+            ck_assert_msg ( 0, "Failed to encode payload" );
+        }
+        
+        toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size);
+        
+        /* Wait 2 seconds and change transmission type */
+        if (time(NULL) - times_they_are_a_changin > 2) {
+            times_they_are_a_changin = time(NULL);
+            toxav_change_type(status_control.Alice.av, status_control.Alice.call_index, 
+                              toxav_get_peer_transmission_type(status_control.Bob.av, status_control.Bob.call_index, 0)
+                              == TypeAudio ? TypeVideo : TypeAudio);
+        }
+        
+        if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
+            step++; /* This terminates the loop */
+            toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index);
+            toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index);
+            
+            /* Call over Alice hangs up */
+            toxav_hangup(status_control.Alice.av, status_control.Alice.call_index);
+        }
+    }
+    TERMINATE_SCOPE()
 
-
+    
     /*************************************************************************************************
      * Other flows
      */
@@ -505,47 +465,78 @@ START_TEST(test_AV_flows)
         printf("\n");
     }
 
-
+    
     /*
      * Call and cancel
      */
     {
         int step = 0;
         int running = 1;
-
+        
         while (running) {
             tox_do(bootstrap_node);
             tox_do(Alice);
             tox_do(Bob);
-
+            
             switch ( step ) {
                 case 0: /* Alice */
                     printf("Alice is calling...\n");
                     toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, TypeAudio, 10);
                     step++;
                     break;
-                    \
-
+                    
+                    
                 case 1: /* Alice again */
                     if (status_control.Bob.status == Ringing) {
                         printf("Alice cancels...\n");
                         toxav_cancel(status_control.Alice.av, status_control.Alice.call_index, 0, "Who likes D's anyway?");
                         step++;
                     }
-
+                    
                     break;
-
+                    
                 case 2:  /* Wait for Both to have status ended */
                     if (status_control.Bob.status == Cancel) running = 0;
-
+                    
                     break;
             }
-
+            
             c_sleep(20);
         }
-
+        
+        printf("\n");
+    }
+        
+    /*
+        * Timeout
+        */
+    {
+        int step = 0;
+        int running = 1;
+        while (running) {
+            tox_do(bootstrap_node);
+            tox_do(Alice);
+            tox_do(Bob);
+            
+            switch ( step ) {
+                case 0:
+                    printf("Alice is calling...\n");
+                    toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, TypeAudio, 10);
+                    step++;
+                    break;
+                    
+                case 1:
+                    if (status_control.Alice.status == TimedOut) running = 0;
+                    break;
+            }
+            
+            c_sleep(20);
+        }            
+        
         printf("\n");
     }
+        
+    
 
 
     printf("Calls ended!\n");