1 files changed, 632 insertions, 0 deletions

diff --git a/toxav/av_test.c b/toxav/av_test.c
new file mode 100644
index 00000000..01484249
--- /dev/null
+++ b/toxav/av_test.c
@@ -0,0 +1,632 @@
+#include "toxav.h"
+#include "../toxcore/tox.h"
+
+#ifdef __APPLE__
+#       include <OpenAL/al.h>
+#       include <OpenAL/alc.h>
+#else
+#       include <AL/al.h>
+#       include <AL/alc.h>
+/* compatibility with older versions of OpenAL */
+#       ifndef ALC_ALL_DEVICES_SPECIFIER
+#               include <AL/alext.h>
+#       endif  /* ALC_ALL_DEVICES_SPECIFIER */
+#endif  /* __APPLE__ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.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
+
+/* Enable/disable tests */
+#define TEST_REGULAR_AV 0
+#define TEST_REGULAR_A 0
+#define TEST_REGULAR_V 0
+#define TEST_REJECT 0
+#define TEST_CANCEL 0
+#define TEST_MUTE_UNMUTE 0
+#define TEST_TRANSFER_A 1
+
+
+typedef struct {
+    bool incoming;
+    uint32_t state;
+} CallControl;
+
+const char* stringify_state(TOXAV_CALL_STATE s)
+{
+    static const char* strings[] =
+    {
+        "NOT SENDING",
+        "SENDING AUDIO",
+        "SENDING VIDEO",
+        "SENDING AUDIO AND VIDEO",
+        "PAUSED",
+        "END",
+        "ERROR"
+    };
+    
+    return strings [s];
+};
+
+
+/** 
+ * Callbacks 
+ */
+void t_toxav_call_cb(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled, void *user_data)
+{
+    printf("Handling CALL callback\n");
+    ((CallControl*)user_data)->incoming = true;
+}
+void t_toxav_call_state_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data)
+{
+    printf("Handling CALL STATE callback: %d\n", state);
+    
+    ((CallControl*)user_data)->state = state;
+}
+void t_toxav_receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
+                                    uint16_t width, uint16_t height,
+                                    uint8_t const *planes[], int32_t const stride[],
+                                    void *user_data)
+{
+    printf("Handling VIDEO FRAME callback\n");
+}
+void t_toxav_receive_audio_frame_cb(ToxAV *av, uint32_t friend_number,
+                                    int16_t const *pcm,
+                                    size_t sample_count,
+                                    uint8_t channels,
+                                    uint32_t sampling_rate,
+                                    void *user_data)
+{
+    printf("Handling AUDIO FRAME callback\n");
+}
+void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata)
+{
+    if (length == 7 && memcmp("gentoo", data, 7) == 0) {
+        tox_add_friend_norequest(m, public_key);
+    }
+}
+
+
+/**
+ */
+void prepare(Tox* Bsn, Tox* Alice, Tox* Bob)
+{
+    long long unsigned int cur_time = time(NULL);
+    
+    uint32_t to_compare = 974536;
+    uint8_t address[TOX_FRIEND_ADDRESS_SIZE];
+    
+    tox_callback_friend_request(Alice, t_accept_friend_request_cb, &to_compare);
+    tox_get_address(Alice, address);
+    
+    assert(tox_add_friend(Bob, address, (uint8_t *)"gentoo", 7) >= 0);
+    
+    uint8_t off = 1;
+    
+    while (1) {
+        tox_do(Bsn);
+        tox_do(Alice);
+        tox_do(Bob);
+        
+        if (tox_isconnected(Bsn) && 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!\n", time(NULL) - cur_time);
+}
+void prepareAV(ToxAV* AliceAV, void* AliceUD, ToxAV* BobAV, void* BobUD)
+{
+    /* Alice */
+    toxav_callback_call(AliceAV, t_toxav_call_cb, AliceUD);
+    toxav_callback_call_state(AliceAV, t_toxav_call_state_cb, AliceUD);
+    toxav_callback_receive_video_frame(AliceAV, t_toxav_receive_video_frame_cb, AliceUD);
+    toxav_callback_receive_audio_frame(AliceAV, t_toxav_receive_audio_frame_cb, AliceUD);
+    
+    /* Bob */
+    toxav_callback_call(BobAV, t_toxav_call_cb, BobUD);
+    toxav_callback_call_state(BobAV, t_toxav_call_state_cb, BobUD);
+    toxav_callback_receive_video_frame(BobAV, t_toxav_receive_video_frame_cb, BobUD);
+    toxav_callback_receive_audio_frame(BobAV, t_toxav_receive_audio_frame_cb, BobUD);
+}
+void iterate(Tox* Bsn, ToxAV* AliceAV, ToxAV* BobAV)
+{
+    tox_do(Bsn);
+    tox_do(toxav_get_tox(AliceAV));
+    tox_do(toxav_get_tox(BobAV));
+    
+    toxav_iteration(AliceAV);
+    toxav_iteration(BobAV);
+    
+    c_sleep(20);
+}
+
+int device_read_frame(ALCdevice* device, int32_t frame_dur, int16_t* PCM, size_t max_size)
+{
+        int f_size = (48000 * frame_dur / 1000);
+        
+        if (max_size < f_size)
+                return -1;
+
+        /* Don't block if not enough data */
+        int32_t samples;
+        alcGetIntegerv(device, ALC_CAPTURE_SAMPLES, sizeof(int32_t), &samples);
+        if (samples < f_size) 
+                return 0;
+        
+        alcCaptureSamples(device, PCM, f_size);
+        return f_size;
+}
+
+int device_play_frame(uint32_t source, int16_t* PCM, size_t size)
+{
+        uint32_t bufid;
+    int32_t processed, queued;
+    alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
+    alGetSourcei(source, AL_BUFFERS_QUEUED, &queued);
+
+    if(processed) {
+        uint32_t bufids[processed];
+        alSourceUnqueueBuffers(source, processed, bufids);
+        alDeleteBuffers(processed - 1, bufids + 1);
+        bufid = bufids[0];
+    }
+    else if(queued < 16)
+                alGenBuffers(1, &bufid);
+    else
+        return 0;
+    
+
+    alBufferData(bufid, AL_FORMAT_STEREO16, PCM, size * 2 * 2, 48000);
+    alSourceQueueBuffers(source, 1, &bufid);
+
+    int32_t state;
+    alGetSourcei(source, AL_SOURCE_STATE, &state);
+
+    if(state != AL_PLAYING) 
+                alSourcePlay(source);
+        return 1;
+}
+
+int print_devices()
+{
+        const char* default_input;
+        const char* default_output;
+        
+        const char *device;
+
+        printf("Default input device: %s\n", alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER));
+        printf("Default output device: %s\n", alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER));
+        
+        printf("\n");
+        
+        printf("Input devices:\n");
+        
+        int i = 0;
+        for(device = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER); *device; 
+                device += strlen( device ) + 1, ++i) {
+                printf("%d) %s\n", i, device);
+        }
+        
+        printf("\n");
+        printf("Output devices:\n");
+        
+        i = 0;
+        for(device = alcGetString(NULL, ALC_DEVICE_SPECIFIER); *device; 
+                device += strlen( device ) + 1, ++i) {
+                printf("%d) %s\n", i, device);
+        }
+        
+        return 0;
+}
+
+int print_help(const char* name, int rc)
+{
+        fprintf(stderr, "Usage: %s [-h] <in device> <out device>\n", name);
+        return rc;
+}
+
+long get_device_idx(const char* arg)
+{
+        if (strcmp(arg, "-") == 0)
+                return -1; /* Default */
+        
+        char *p;
+        long res = strtol(arg, &p, 10);
+        
+        if (*p) {
+                fprintf(stderr, "Invalid device!");
+                exit(1);
+        }
+        
+        return res;
+}
+
+int main (int argc, char** argv)
+{
+        if (argc == 2) {
+                if (strcmp(argv[1], "-d") == 0 || strcmp(argv[1], "--devices") == 0) {
+                        return print_devices();
+                }
+                if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
+                        return print_help(argv[0], 0);
+                }
+        }
+        
+        if (argc != 3) {
+                fprintf(stderr, "Invalid input!\n");
+                return print_help(argv[0], 1);
+        }
+        
+        int i;
+        
+        const char* in_device_name = "";
+        const char* out_device_name = "";
+        
+        {
+                long dev = get_device_idx(argv[1]);
+                if (dev == -1)
+                        in_device_name = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
+                else
+                {
+                        const char* tmp;
+                        i = -1;
+                        for(tmp = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER); *tmp && i != dev;
+                                tmp += strlen( tmp ) + 1, ++i)
+                                in_device_name = tmp;
+                }
+                
+                printf("Input device: %s\n", in_device_name);
+        }
+        
+        {
+                long dev = get_device_idx(argv[1]);
+                if (dev == -1)
+                        out_device_name = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
+                else
+                {
+                        const char* tmp;
+                        i = -1;
+                        for(tmp = alcGetString(NULL, ALC_DEVICE_SPECIFIER); *tmp && i != dev;
+                                tmp += strlen( tmp ) + 1, ++i)
+                                out_device_name = tmp;
+                }
+                
+                printf("Output device: %s\n", out_device_name);
+        }
+        
+        ALCdevice* out_device;
+        ALCcontext* out_ctx;
+        uint32_t source;
+        uint32_t buffers[5];
+        
+        { /* Open output device */
+                out_device = alcOpenDevice(out_device_name);
+                if ( !out_device ) {
+                        fprintf(stderr, "Failed to open playback device: %s: %d\n", out_device_name, alGetError());
+                        return 1;
+                }
+                
+                out_ctx = alcCreateContext(out_device, NULL);
+        alcMakeContextCurrent(out_ctx);
+                
+                alGenBuffers(5, buffers);
+                alGenSources((uint32_t)1, &source);
+                alSourcei(source, AL_LOOPING, AL_FALSE);
+                
+                uint16_t zeros[10000];
+                memset(zeros, 0, 10000);
+                
+                for ( i = 0; i < 5; ++i ) 
+                        alBufferData(buffers[i], AL_FORMAT_STEREO16, zeros, 10000, 48000);
+                
+                alSourceQueueBuffers(source, 5, buffers);
+                alSourcePlay(source);
+        }
+        
+        ALCdevice* in_device;
+        
+        { /* Open input device */
+                in_device = alcCaptureOpenDevice(in_device_name, 48000, AL_FORMAT_STEREO16, 10000);
+                if ( !in_device ) {
+                        fprintf(stderr, "Failed to open capture device: %s: %d\n", in_device_name, alGetError());
+                        return 1;
+                }
+                
+                alcCaptureStart(in_device);
+        }
+        
+    Tox *Bsn = tox_new(0);
+    Tox *Alice = tox_new(0);
+    Tox *Bob = tox_new(0);
+    
+    assert(Bsn && Alice && Bob);
+    
+    prepare(Bsn, Alice, Bob);
+    
+    
+    ToxAV *AliceAV, *BobAV;
+    CallControl AliceCC, BobCC;
+    
+    {
+        TOXAV_ERR_NEW rc;
+        AliceAV = toxav_new(Alice, &rc);
+        assert(rc == TOXAV_ERR_NEW_OK);
+        
+        BobAV = toxav_new(Bob, &rc);
+        assert(rc == TOXAV_ERR_NEW_OK);
+        
+        prepareAV(AliceAV, &AliceCC, BobAV, &BobCC);
+        printf("Created 2 instances of ToxAV\n");
+    }
+    
+
+#define REGULAR_CALL_FLOW(A_BR, V_BR) \
+        do { \
+        memset(&AliceCC, 0, sizeof(CallControl)); \
+        memset(&BobCC, 0, sizeof(CallControl)); \
+        \
+        TOXAV_ERR_CALL rc; \
+        toxav_call(AliceAV, 0, A_BR, V_BR, &rc); \
+        \
+        if (rc != TOXAV_ERR_CALL_OK) { \
+            printf("toxav_call failed: %d\n", rc); \
+            exit(1); \
+        } \
+        \
+        \
+        long long unsigned int start_time = time(NULL); \
+        \
+        \
+        while (BobCC.state != TOXAV_CALL_STATE_END) { \
+            \
+            if (BobCC.incoming) { \
+                TOXAV_ERR_ANSWER rc; \
+                toxav_answer(BobAV, 0, A_BR, V_BR, &rc); \
+                \
+                if (rc != TOXAV_ERR_ANSWER_OK) { \
+                    printf("toxav_answer failed: %d\n", rc); \
+                    exit(1); \
+                } \
+                BobCC.incoming = false; \
+            } else { \
+                /* TODO rtp */ \
+                \
+                if (time(NULL) - start_time == 5) { \
+                    \
+                    TOXAV_ERR_CALL_CONTROL rc; \
+                    toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc); \
+                    \
+                    if (rc != TOXAV_ERR_CALL_CONTROL_OK) { \
+                        printf("toxav_call_control failed: %d\n", rc); \
+                        exit(1); \
+                    } \
+                } \
+            } \
+             \
+            iterate(Bsn, AliceAV, BobAV); \
+        } \
+        printf("Success!\n");\
+    } while(0)
+    
+    if (TEST_REGULAR_AV) {
+                printf("\nTrying regular call (Audio and Video)...\n");
+                REGULAR_CALL_FLOW(48, 4000);
+        }
+        
+    if (TEST_REGULAR_A) {
+                printf("\nTrying regular call (Audio only)...\n");
+                REGULAR_CALL_FLOW(48, 0);
+        }
+        
+        if (TEST_REGULAR_V) {
+                printf("\nTrying regular call (Video only)...\n");
+                REGULAR_CALL_FLOW(0, 4000);
+        }
+        
+#undef REGULAR_CALL_FLOW
+    
+    if (TEST_REJECT) { /* Alice calls; Bob rejects */
+        printf("\nTrying reject flow...\n");
+        
+        memset(&AliceCC, 0, sizeof(CallControl));
+        memset(&BobCC, 0, sizeof(CallControl));
+        
+        {
+            TOXAV_ERR_CALL rc;
+            toxav_call(AliceAV, 0, 48, 0, &rc);
+            
+            if (rc != TOXAV_ERR_CALL_OK) {
+                printf("toxav_call failed: %d\n", rc);
+                exit(1);
+            }
+        }
+        
+        while (!BobCC.incoming)
+            iterate(Bsn, AliceAV, BobAV);
+        
+        /* Reject */
+        {
+            TOXAV_ERR_CALL_CONTROL rc;
+            toxav_call_control(BobAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
+            
+            if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
+                printf("toxav_call_control failed: %d\n", rc);
+                exit(1);
+            }
+        }
+        
+        while (AliceCC.state != TOXAV_CALL_STATE_END)
+            iterate(Bsn, AliceAV, BobAV);
+        
+        printf("Success!\n");
+    }
+    
+    if (TEST_CANCEL) { /* Alice calls; Alice cancels while ringing */
+        printf("\nTrying cancel (while ringing) flow...\n");
+        
+        memset(&AliceCC, 0, sizeof(CallControl));
+        memset(&BobCC, 0, sizeof(CallControl));
+        
+        {
+            TOXAV_ERR_CALL rc;
+            toxav_call(AliceAV, 0, 48, 0, &rc);
+            
+            if (rc != TOXAV_ERR_CALL_OK) {
+                printf("toxav_call failed: %d\n", rc);
+                exit(1);
+            }
+        }
+        
+        while (!BobCC.incoming)
+            iterate(Bsn, AliceAV, BobAV);
+        
+        /* Cancel */
+        {
+            TOXAV_ERR_CALL_CONTROL rc;
+            toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
+            
+            if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
+                printf("toxav_call_control failed: %d\n", rc);
+                exit(1);
+            }
+        }
+        
+        /* Alice will not receive end state */
+        while (BobCC.state != TOXAV_CALL_STATE_END)
+            iterate(Bsn, AliceAV, BobAV);
+        
+        printf("Success!\n");
+    }
+    
+    if (TEST_MUTE_UNMUTE) { /* Check Mute-Unmute etc */
+        printf("\nTrying mute functionality...\n");
+        
+        memset(&AliceCC, 0, sizeof(CallControl));
+        memset(&BobCC, 0, sizeof(CallControl));
+        
+        /* Assume sending audio and video */
+        {
+            TOXAV_ERR_CALL rc;
+            toxav_call(AliceAV, 0, 48, 1000, &rc);
+            
+            if (rc != TOXAV_ERR_CALL_OK) {
+                printf("toxav_call failed: %d\n", rc);
+                exit(1);
+            }
+        }
+        
+        while (!BobCC.incoming)
+            iterate(Bsn, AliceAV, BobAV);
+        
+        /* At first try all stuff while in invalid state */
+        assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE, NULL));
+        assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME, NULL));
+        assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_TOGGLE_MUTE_AUDIO, NULL));
+        assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_TOGGLE_MUTE_VIDEO, NULL));
+        
+        {
+            TOXAV_ERR_ANSWER rc;
+            toxav_answer(BobAV, 0, 48, 4000, &rc);
+            
+            if (rc != TOXAV_ERR_ANSWER_OK) {
+                printf("toxav_answer failed: %d\n", rc);
+                exit(1);
+            }
+        }
+        
+        iterate(Bsn, AliceAV, BobAV);
+        
+        /* Pause and Resume */
+        printf("Pause and Resume\n");
+        assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE, NULL));
+        iterate(Bsn, AliceAV, BobAV);
+        assert(BobCC.state == TOXAV_CALL_STATE_PAUSED);
+        assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME, NULL));
+        iterate(Bsn, AliceAV, BobAV);
+        assert(BobCC.state & (TOXAV_CALL_STATE_SENDING_A | TOXAV_CALL_STATE_SENDING_V));
+        
+        /* Mute/Unmute single */
+        printf("Mute/Unmute single\n");
+        assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_TOGGLE_MUTE_AUDIO, NULL));
+        iterate(Bsn, AliceAV, BobAV);
+        assert(BobCC.state ^ TOXAV_CALL_STATE_RECEIVING_A);
+        assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_TOGGLE_MUTE_AUDIO, NULL));
+        iterate(Bsn, AliceAV, BobAV);
+        assert(BobCC.state & TOXAV_CALL_STATE_RECEIVING_A);
+        
+        /* Mute/Unmute both */
+        printf("Mute/Unmute both\n");
+        assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_TOGGLE_MUTE_AUDIO, NULL));
+        iterate(Bsn, AliceAV, BobAV);
+        assert(BobCC.state ^ TOXAV_CALL_STATE_RECEIVING_A);
+        assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_TOGGLE_MUTE_VIDEO, NULL));
+        iterate(Bsn, AliceAV, BobAV);
+        assert(BobCC.state ^ TOXAV_CALL_STATE_RECEIVING_V);
+        assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_TOGGLE_MUTE_AUDIO, NULL));
+        iterate(Bsn, AliceAV, BobAV);
+        assert(BobCC.state & TOXAV_CALL_STATE_RECEIVING_A);
+        assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_TOGGLE_MUTE_VIDEO, NULL));
+        iterate(Bsn, AliceAV, BobAV);
+        assert(BobCC.state & TOXAV_CALL_STATE_RECEIVING_V);
+        
+        {
+            TOXAV_ERR_CALL_CONTROL rc;
+            toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
+            
+            if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
+                printf("toxav_call_control failed: %d\n", rc);
+                exit(1);
+            }
+        }
+        
+        iterate(Bsn, AliceAV, BobAV);
+        assert(BobCC.state == TOXAV_CALL_STATE_END);
+        
+        printf("Success!\n");
+    }
+    
+    if (TEST_TRANSFER_A) { /* Audio encoding/decoding and transfer */
+                printf("\nTrying audio enc/dec...\n");
+                
+                int16_t PCM[10000];
+                time_t start_time = time(NULL);
+                
+                /* Run for 5 seconds */
+                while ( start_time + 10 > time(NULL) ) {
+                        int frame_size = device_read_frame(in_device, 20, PCM, sizeof(PCM));
+                        if (frame_size > 0)
+                                device_play_frame(source, PCM, frame_size);
+//                      c_sleep(20);
+                }
+                
+                printf("Success!");
+        }
+        
+    toxav_kill(BobAV);
+    toxav_kill(AliceAV);
+    tox_kill(Bob);
+    tox_kill(Alice);
+    tox_kill(Bsn);
+    
+    printf("\nTest successful!\n");
+        
+        alcCloseDevice(out_device);
+        alcCaptureCloseDevice(in_device);
+    return 0;
+}
\ No newline at end of file