Added test

auto_tests/Makefile.inc

@@ -1,9 +1,9 @@
 if BUILD_TESTS
 
 TESTS = messenger_autotest crypto_test network_test assoc_test onion_test tox_test
-
 check_PROGRAMS = messenger_autotest crypto_test network_test assoc_test onion_test tox_test
 
+
 AUTOTEST_CFLAGS = \
                          $(LIBSODIUM_CFLAGS) \
                          $(NACL_CFLAGS) \
@@ -17,6 +17,13 @@ AUTOTEST_LDADD = \
                         $(NACL_LIBS) \
                         $(CHECK_LIBS)
 
+
+if BUILD_AV
+TESTS += toxav_basic_test
+check_PROGRAMS += toxav_basic_test
+AUTOTEST_LDADD += libtoxav.la
+endif
+
 messenger_autotest_SOURCES = ../auto_tests/messenger_test.c
 
 messenger_autotest_CFLAGS = $(AUTOTEST_CFLAGS)
@@ -61,6 +68,14 @@ tox_test_CFLAGS = $(AUTOTEST_CFLAGS)
 tox_test_LDADD = $(AUTOTEST_LDADD)
 
 
+if BUILD_AV
+toxav_basic_test_SOURCES = ../auto_tests/toxav_basic_test.c
+
+toxav_basic_test_CFLAGS = $(AUTOTEST_CFLAGS)
+
+toxav_basic_test_LDADD = $(AUTOTEST_LDADD)
+endif
+
 endif
 
 EXTRA_DIST +=           $(top_srcdir)/auto_tests/friends_test.c

auto_tests/toxav_basic_test.c

@@ -0,0 +1,485 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <check.h>
+#include <stdlib.h>
+#include <time.h>
+#include <assert.h>
+
+#include "../toxcore/tox.h"
+#include "../toxav/toxav.h"
+
+#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#define c_sleep(x) Sleep(1*x)
+#else
+#include <unistd.h>
+#define c_sleep(x) usleep(1000*x)
+#endif
+
+
+typedef enum _CallStatus
+{
+    none,
+    InCall,
+    Ringing,
+    Ended,
+    Rejected,
+    Cancel
+    
+} CallStatus;
+
+typedef struct _Party
+{
+    CallStatus status;
+    ToxAv* av;
+    time_t* CallStarted;
+} Party;
+
+typedef struct _Status {
+    Party Alice;
+    Party Bob;
+} Status;
+
+void accept_friend_request(Tox *m, uint8_t *public_key, uint8_t *data, uint16_t length, void *userdata)
+{    
+    if (length == 15 && memcmp("ILIKESMALLTITS", data, 15) == 0) {
+        tox_add_friend_norequest(m, public_key);
+    }
+}
+
+
+/******************************************************************************/
+void callback_recv_invite ( void *_arg )
+{
+    Status* cast = _arg;
+    
+    /* Bob always receives invite */
+    cast->Bob.status= Ringing;
+}
+void callback_recv_ringing ( void *_arg )
+{
+    Status* cast = _arg;
+    
+    /* Alice always sends invite */
+    cast->Alice.status= Ringing;
+}
+void callback_recv_starting ( 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, 1);
+}
+void callback_recv_ending ( void *_arg )
+{
+    Status* cast = _arg;
+    
+    
+    
+    if ( cast->Alice.status == Rejected) {
+        printf ( "Call ended for Bob!\n" );
+        cast->Bob.status = Ended;
+    }
+    else {
+        printf ( "Call ended for Alice!\n" );
+        cast->Alice.status = Ended;
+    }
+}
+
+void callback_recv_error ( void *_arg )
+{
+    ck_assert_msg(0, "AV internal error");
+}
+
+void callback_call_started ( 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, 1);
+}
+void callback_call_canceled ( void *_arg )
+{
+    Status* cast = _arg;
+    
+    printf ( "Call Canceled for Bob!\n" );
+    cast->Bob.status = Cancel;
+}
+void callback_call_rejected ( void *_arg )
+{
+    Status* cast = _arg;
+    
+    printf ( "Call rejected by Bob!\n"
+             "Call ended for Alice!\n" );
+    /* If Bob rejects, call is ended for alice and she sends ending */
+    cast->Alice.status = Rejected;
+}
+void callback_call_ended ( void *_arg )
+{
+    Status* cast = _arg;
+    
+    printf ( "Call ended for Bob!\n" );
+    cast->Bob.status = Ended;
+}
+
+void callback_requ_timeout ( void *_arg )
+{
+    ck_assert_msg(0, "No answer!");
+}
+/*************************************************************************************************/
+
+/* Alice calls bob and the call starts.
+ * What happens in 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) {\
+    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, 0, AliceCallType, 10); step++; break;\
+        case 1: /* Bob */ if (status_control.Bob.status == Ringing) { printf("Bob answers...\n");\
+            cur_time = time(NULL); toxav_answer(status_control.Bob.av, BobCallType); step++; } break; \
+        case 2: /* Rtp transmission */ \
+            if (status_control.Bob.status == InCall && status_control.Alice.status == InCall)
+
+
+#define TERMINATE_SCOPE() break;\
+case 3: /* Wait for Both to have status ended */\
+if (status_control.Alice.status == Ended && status_control.Bob.status == Ended) running = 0; break; } c_sleep(20); } } printf("\n");
+                
+START_TEST(test_AV)
+{       
+    long long unsigned int cur_time = time(NULL);
+    Tox *bootstrap_node = tox_new(0);
+    Tox *Alice = tox_new(0);
+    Tox *Bob = tox_new(0);
+    
+    ck_assert_msg(bootstrap_node || Alice || Bob, "Failed to create 3 tox instances");
+    
+    uint32_t to_compare = 974536;
+    tox_callback_friend_request(Alice, accept_friend_request, &to_compare);
+    uint8_t address[TOX_FRIEND_ADDRESS_SIZE];
+    tox_get_address(Alice, address);
+    int test = tox_add_friend(Bob, address, (uint8_t *)"ILIKESMALLTITS", 15);
+    
+    ck_assert_msg(test == 0, "Failed to add friend error code: %i", test);
+    
+    uint8_t off = 1;
+    while (1) {
+        tox_do(bootstrap_node);
+        tox_do(Alice);
+        tox_do(Bob);
+        
+        if (tox_isconnected(bootstrap_node) && tox_isconnected(Alice) && tox_isconnected(Bob) && off) {
+            printf("Toxes are online, took %llu seconds\n", time(NULL) - cur_time);
+            off = 0;
+        }
+        
+        
+        if (tox_get_friend_connection_status(Alice, 0) == 1 && tox_get_friend_connection_status(Bob, 0) == 1)
+            break;
+        
+        c_sleep(20);
+    }
+    
+    printf("All set after %llu seconds! Starting call...\n", time(NULL) - cur_time);
+    
+    
+    Status status_control =
+    {
+        {none, toxav_new(Alice, 128, 128), NULL},
+        {none, toxav_new(Bob, 128, 128), NULL},
+    };
+    
+    
+    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);
+    
+    
+    
+    int16_t sample_payload[10] = {0,1,2,3,4,5,6,7,8,9};
+    vpx_image_t* sample_image = vpx_img_alloc(NULL, VPX_IMG_FMT_I420, 128, 128, 1);
+    
+    memcpy(sample_image->planes[VPX_PLANE_Y], sample_payload, 10);
+    memcpy(sample_image->planes[VPX_PLANE_U], sample_payload, 10);
+    memcpy(sample_image->planes[VPX_PLANE_V], sample_payload, 10);
+    
+    
+    /*************************************************************************************************
+     * Successful flows (when call starts)
+     */
+    
+    /* 
+     * Call with audio only on both sides. Alice calls Bob.
+     */
+    CALL_AND_START_LOOP(TypeAudio, TypeAudio)
+    {
+        /* Both send */
+        toxav_send_audio(status_control.Alice.av, sample_payload, 10);
+        toxav_send_audio(status_control.Bob.av, sample_payload, 10);
+        
+        /* Both receive */
+        int16_t storage[10];
+        int recved;
+        
+        /* Payload from Alice */
+        recved = toxav_recv_audio(status_control.Alice.av, 10, storage);
+        if ( recved ) {
+            ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");
+            memset(storage, 0, 10);
+        }
+        
+        /* Payload from Bob */
+        recved = toxav_recv_audio(status_control.Bob.av, 10, 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);
+            toxav_kill_transmission(status_control.Bob.av);
+            
+            /* Call over Alice hangs up */
+            toxav_hangup(status_control.Alice.av);
+        }
+    }
+    TERMINATE_SCOPE()
+    
+    
+    /* 
+     * Call with audio on both sides and video on one side. Alice calls Bob.
+     */
+    CALL_AND_START_LOOP(TypeAudio, TypeVideo)
+    {
+        /* Both send */
+        toxav_send_audio(status_control.Alice.av, sample_payload, 10);
+        
+        toxav_send_audio(status_control.Bob.av, sample_payload, 10);
+        toxav_send_video(status_control.Bob.av, sample_image);
+        
+        /* Both receive */
+        int16_t storage[10];
+        vpx_image_t* video_storage;
+        int recved;
+        
+        /* Payload from Bob */
+        recved = toxav_recv_audio(status_control.Alice.av, 10, storage);
+        if ( recved ) {
+            ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");
+            memset(storage, 0, 10);
+        }
+        /* Video payload */
+        toxav_recv_video(status_control.Alice.av, &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");
+        }
+        
+        
+        
+        
+        /* Payload from Alice */
+        recved = toxav_recv_audio(status_control.Bob.av, 10, 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);
+            toxav_kill_transmission(status_control.Bob.av);
+            
+            /* Call over Alice hangs up */
+            toxav_hangup(status_control.Alice.av);
+        }
+    }
+    TERMINATE_SCOPE()
+    
+    
+    /* 
+     * Call with audio and video on both sides. Alice calls Bob.
+     */
+    CALL_AND_START_LOOP(TypeVideo, TypeVideo)
+    {
+        /* Both send */
+        toxav_send_audio(status_control.Alice.av, sample_payload, 10);
+        toxav_send_video(status_control.Alice.av, sample_image);
+        
+        toxav_send_audio(status_control.Bob.av, sample_payload, 10);
+        toxav_send_video(status_control.Bob.av, sample_image);
+        
+        /* Both receive */
+        int16_t storage[10];
+        vpx_image_t* video_storage;
+        int recved;
+        
+        /* Payload from Bob */
+        recved = toxav_recv_audio(status_control.Alice.av, 10, storage);
+        if ( recved ) {
+            ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");
+            memset(storage, 0, 10);
+        }
+        /* Video payload */
+        toxav_recv_video(status_control.Alice.av, &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");
+        }
+        
+        
+        
+        
+        /* Payload from Alice */
+        recved = toxav_recv_audio(status_control.Bob.av, 10, 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, &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");
+        }
+        
+        
+        if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
+            step++; /* This terminates the loop */
+            toxav_kill_transmission(status_control.Alice.av);
+            toxav_kill_transmission(status_control.Bob.av);
+            
+            /* Call over Alice hangs up */
+            toxav_hangup(status_control.Alice.av);
+        }
+    }
+    TERMINATE_SCOPE()
+    
+    
+    
+    /*************************************************************************************************
+     * Other flows
+     */
+    
+    /*
+     * Call and reject
+     */
+    { 
+        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, 0, TypeAudio, 10); 
+                    step++; 
+                    break;\
+                case 1: /* Bob */ 
+                    if (status_control.Bob.status == Ringing) { 
+                        printf("Bob rejects...\n");                        
+                        toxav_reject(status_control.Bob.av, "Who likes D's anyway?");
+                        step++; 
+                    } break;
+                case 2:  /* Wait for Both to have status ended */
+                    if (status_control.Alice.status == Rejected && status_control.Bob.status == Ended) running = 0; break; 
+            } 
+            c_sleep(20); 
+        } 
+        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, 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, 0, "Who likes D's anyway?");
+                        step++; 
+                    } break;
+                case 2:  /* Wait for Both to have status ended */
+                    if (status_control.Alice.status == Ended && status_control.Bob.status == Cancel) running = 0; break;
+            } 
+            c_sleep(20); 
+        } 
+        printf("\n");
+    }
+    
+    
+    printf("Calls ended!\n");
+}
+END_TEST
+
+/*************************************************************************************************/
+
+
+
+Suite *tox_suite(void)
+{
+    Suite *s = suite_create("Tox");
+    
+    TCase *tc_av = tcase_create("A/V");
+    tcase_add_test(tc_av, test_AV);
+    tcase_set_timeout(tc_av, 100); /* Timeout on 100 too much? */
+    suite_add_tcase(s, tc_av);
+    
+    return s;
+}
+int main(int argc, char *argv[])
+{
+    Suite *tox = tox_suite();
+    SRunner *test_runner = srunner_create(tox);
+    
+    setbuf(stdout, NULL);
+    
+    srunner_run_all(test_runner, CK_NORMAL);
+    int number_failed = srunner_ntests_failed(test_runner);
+    
+    srunner_free(test_runner);
+    
+    return number_failed;
+}

toxav/msi.c

@@ -1066,9 +1066,7 @@ int handle_recv_ending ( MSISession *session, MSIMessage *msg )
     if ( has_call_error ( session, msg ) == 0 )
         return 0;
     
-    /* Stop timer */
+    /* Stop timer */    
-    invoke_callback(MSI_OnEnding);
-    
     event.timer_release ( session->call->request_timer_id );
     
     invoke_callback(MSI_OnEnding);

toxav/toxav.c

@@ -427,7 +427,7 @@ inline__ int toxav_recv_video ( ToxAv *av, vpx_image_t **output)
     do {
         recved_size = toxav_recv_rtp_payload(av, TypeVideo, packet);
 
-        if (recved_size > 0) 
+        if (recved_size < 0) 
             fprintf(stderr, "Error decoding: %s\n", vpx_codec_err_to_string(vpx_codec_decode(&av->cs->v_decoder, packet, recved_size, NULL, 0)));
         
     } while (recved_size > 0);
@@ -436,11 +436,10 @@ inline__ int toxav_recv_video ( ToxAv *av, vpx_image_t **output)
     vpx_image_t *img;
     img = vpx_codec_get_frame(&av->cs->v_decoder, &iter);
 
-    if (img == NULL)
-        return ErrorInternal;
-
     *output = img;
     return 0;
+    /* Yeah, i set output to be NULL if nothing received
+     */
 }
 
 /**