6 files changed, 256 insertions, 1035 deletions
diff --git a/toxav/Makefile.inc b/toxav/Makefile.inc
index 6458260d..b61c1ea0 100644
--- a/toxav/Makefile.inc
+++ b/toxav/Makefile.inc
@@ -49,6 +49,7 @@ av_test_LDADD =       $(LIBSODIUM_LDFLAGS) \
                      libtoxcore.la \
                      $(LIBSODIUM_LIBS) \
                      $(NACL_OBJECTS) \
+                      -lopenal \
                      $(NACL_LIBS)
diff --git a/toxav/av_test.c b/toxav/av_test.c
index bb79eedc..01484249 100644
--- a/toxav/av_test.c
+++ b/toxav/av_test.c
@@ -1,6 +1,18 @@
 #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>
@@ -14,6 +26,16 @@
 #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;
@@ -134,9 +156,201 @@ void iterate(Tox* Bsn, ToxAV* AliceAV, ToxAV* 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);
@@ -163,7 +377,7 @@ int main (int argc, char** argv)
    
 #define REGULAR_CALL_FLOW(A_BR, V_BR) \
-    { \
+        do { \
        memset(&AliceCC, 0, sizeof(CallControl)); \
        memset(&BobCC, 0, sizeof(CallControl)); \
        \
@@ -208,20 +422,26 @@ int main (int argc, char** argv)
            iterate(Bsn, AliceAV, BobAV); \
        } \
        printf("Success!\n");\
-    }
+    } while(0)
-    
-    printf("\nTrying regular call (Audio and Video)...\n");
-    REGULAR_CALL_FLOW(48, 4000);
-    
-    printf("\nTrying regular call (Audio only)...\n");
-    REGULAR_CALL_FLOW(48, 0);
-    
-    printf("\nTrying regular call (Video only)...\n");
-    REGULAR_CALL_FLOW(0, 4000);
    
+    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
    
-    { /* Alice calls; Bob rejects */
+    if (TEST_REJECT) { /* Alice calls; Bob rejects */
        printf("\nTrying reject flow...\n");
        
        memset(&AliceCC, 0, sizeof(CallControl));
@@ -257,7 +477,7 @@ int main (int argc, char** argv)
        printf("Success!\n");
    }
    
-    { /* Alice calls; Alice cancels while ringing */
+    if (TEST_CANCEL) { /* Alice calls; Alice cancels while ringing */
        printf("\nTrying cancel (while ringing) flow...\n");
        
        memset(&AliceCC, 0, sizeof(CallControl));
@@ -294,10 +514,9 @@ int main (int argc, char** argv)
        printf("Success!\n");
    }
    
-    { /* Check Mute-Unmute etc */
+    if (TEST_MUTE_UNMUTE) { /* Check Mute-Unmute etc */
        printf("\nTrying mute functionality...\n");
        
-        
        memset(&AliceCC, 0, sizeof(CallControl));
        memset(&BobCC, 0, sizeof(CallControl));
        
@@ -382,7 +601,23 @@ int main (int argc, char** argv)
        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);
@@ -390,5 +625,8 @@ int main (int argc, char** argv)
    tox_kill(Bsn);
    
    printf("\nTest successful!\n");
+        
+        alcCloseDevice(out_device);
+        alcCaptureCloseDevice(in_device);
    return 0;
 }
 \ No newline at end of file
diff --git a/toxav/codec.c b/toxav/codec.c
index 95e0beb4..bf94115e 100644
--- a/toxav/codec.c
+++ b/toxav/codec.c
@@ -41,7 +41,6 @@
 #define DEFAULT_JBUF 6
 /* Good quality encode. */
-#define MAX_ENCODE_TIME_US VPX_DL_GOOD_QUALITY
 #define MAX_DECODE_TIME_US 0
 #define MAX_VIDEOFRAME_SIZE 0x40000 /* 256KiB */
diff --git a/toxav/msi.c b/toxav/msi.c
index ac900dac..e21ec948 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -783,4 +783,4 @@ void handle_msi_packet ( Messenger *m, int friend_id, const uint8_t *data, uint1
        handle_pop(call, &msg); /* always kills the call */
    
    pthread_mutex_unlock(session->mutex);
-}
-\ No newline at end of file
+}
diff --git a/toxav/toxav_new_1.c b/toxav/toxav_new_1.c
deleted file mode 100644
index 145dcf48..00000000
--- a/toxav/toxav_new_1.c
+++ /dev/null
@@ -1,688 +0,0 @@
-/**  toxav.c
- *
- *   Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *   This file is part of Tox.
- *
- *   Tox is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   Tox is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif /* HAVE_CONFIG_H */
-#define __TOX_DEFINED__
-typedef struct Messenger Tox;
-#define _GNU_SOURCE /* implicit declaration warning */
-#include "codec.h"
-#include "msi.h"
-#include "group.h"
-#include "../toxcore/logger.h"
-#include "../toxcore/util.h"
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-/* Assume 24 fps*/
-#define MAX_ENCODE_TIME_US ((1000 / 24) * 1000)
-/* true if invalid call index */
-#define CALL_INVALID_INDEX(idx, max) (idx < 0 || idx >= max)
-const ToxAvCSettings av_DefaultSettings = {
-    av_TypeAudio,
-    500,
-    1280,
-    720,
-    32000,
-    20,
-    48000,
-    1
-};
-static const uint32_t jbuf_capacity = 6;
-static const uint8_t audio_index = 0, video_index = 1;
-typedef struct _ToxAvCall {
-    pthread_mutex_t mutex_control[1];
-    pthread_mutex_t mutex_encoding_audio[1];
-    pthread_mutex_t mutex_encoding_video[1];
-    pthread_mutex_t mutex_do[1];
-    RTPSession *crtps[2]; /** Audio is first and video is second */
-    CSSession *cs;
-    _Bool active;
-} ToxAvCall;
-struct _ToxAv {
-    Messenger *messenger;
-    MSISession *msi_session; /** Main msi session */
-    ToxAvCall *calls; /** Per-call params */
-    uint32_t max_calls;
-    PAIR(ToxAvAudioCallback, void *) acb;
-    PAIR(ToxAvVideoCallback, void *) vcb;
-    /* Decode time measure */
-    int32_t dectmsscount; /** Measure count */
-    int32_t dectmsstotal; /** Last cycle total */
-    int32_t avgdectms; /** Average decoding time in ms */
-};
-static const MSICSettings *msicsettings_cast (const ToxAvCSettings *from)
-{
-    assert(sizeof(MSICSettings) == sizeof(ToxAvCSettings));
-    return (const MSICSettings *) from;
-}
-static const ToxAvCSettings *toxavcsettings_cast (const MSICSettings *from)
-{
-    assert(sizeof(MSICSettings) == sizeof(ToxAvCSettings));
-    return (const ToxAvCSettings *) from;
-}
-ToxAv *toxav_new( Tox *messenger, int32_t max_calls)
-{
-    ToxAv *av = calloc ( sizeof(ToxAv), 1);
-    if (av == NULL) {
-        LOGGER_WARNING("Allocation failed!");
-        return NULL;
-    }
-    av->messenger = (Messenger *)messenger;
-    av->msi_session = msi_new(av->messenger, max_calls);
-    av->msi_session->agent_handler = av;
-    av->calls = calloc(sizeof(ToxAvCall), max_calls);
-    av->max_calls = max_calls;
-    unsigned int i;
-    for (i = 0; i < max_calls; ++i) {
-        if (create_recursive_mutex(av->calls[i].mutex_control) != 0 ) {
-            LOGGER_WARNING("Failed to init call(%u) mutex!", i);
-            msi_kill(av->msi_session);
-            free(av->calls);
-            free(av);
-            return NULL;
-        }
-    }
-    return av;
-}
-void toxav_kill ( ToxAv *av )
-{
-    uint32_t i;
-    for (i = 0; i < av->max_calls; i ++) {
-        if ( av->calls[i].crtps[audio_index] )
-            rtp_kill(av->calls[i].crtps[audio_index], av->msi_session->messenger_handle);
-        if ( av->calls[i].crtps[video_index] )
-            rtp_kill(av->calls[i].crtps[video_index], av->msi_session->messenger_handle);
-        if ( av->calls[i].cs )
-            cs_kill(av->calls[i].cs);
-        pthread_mutex_destroy(av->calls[i].mutex_control);
-    }
-    msi_kill(av->msi_session);
-    free(av->calls);
-    free(av);
-}
-uint32_t toxav_do_interval(ToxAv *av)
-{
-    int i = 0;
-    uint32_t rc = 200 + av->avgdectms; /* Return 200 if no call is active */
-    for (; i < av->max_calls; i ++) {
-        pthread_mutex_lock(av->calls[i].mutex_control);
-        if (av->calls[i].active) {
-            /* This should work. Video payload will always come in greater intervals */
-            rc = MIN(av->calls[i].cs->audio_decoder_frame_duration, rc);
-        }
-        pthread_mutex_unlock(av->calls[i].mutex_control);
-    }
-    return rc < av->avgdectms ? 0 : rc - av->avgdectms;
-}
-void toxav_do(ToxAv *av)
-{
-    msi_do(av->msi_session);
-    
-    uint64_t start = current_time_monotonic();
-    
-    uint32_t i = 0;
-    
-    for (; i < av->max_calls; i ++) {
-        pthread_mutex_lock(av->calls[i].mutex_control);
-        
-        if (av->calls[i].active) {
-            pthread_mutex_lock(av->calls[i].mutex_do);
-            pthread_mutex_unlock(av->calls[i].mutex_control);
-            cs_do(av->calls[i].cs);
-            pthread_mutex_unlock(av->calls[i].mutex_do);
-        } else {
-            pthread_mutex_unlock(av->calls[i].mutex_control);
-        }
-    }
-    
-    uint64_t end = current_time_monotonic();
-    
-    /* TODO maybe use variable for sizes */
-    av->dectmsstotal += end - start;
-    
-    if (++av->dectmsscount == 3) {
-        av->avgdectms = av->dectmsstotal / 3 + 2 /* NOTE Magic Offset */;
-        av->dectmsscount = 0;
-        av->dectmsstotal = 0;
-    }
-}
-void toxav_register_callstate_callback ( ToxAv *av, ToxAVCallback cb, ToxAvCallbackID id, void *userdata )
-{
-    msi_register_callback(av->msi_session, (MSICallbackType)cb, (MSICallbackID) id, userdata);
-}
-void toxav_register_audio_callback(ToxAv *av, ToxAvAudioCallback cb, void *userdata)
-{
-    av->acb.first = cb;
-    av->acb.second = userdata;
-}
-void toxav_register_video_callback(ToxAv *av, ToxAvVideoCallback cb, void *userdata)
-{
-    av->vcb.first = cb;
-    av->vcb.second = userdata;
-}
-int toxav_call (ToxAv *av,
-                int32_t *call_index,
-                int user,
-                const ToxAvCSettings *csettings,
-                int ringing_seconds )
-{
-    return msi_invite(av->msi_session, call_index, msicsettings_cast(csettings), ringing_seconds * 1000, user);
-}
-int toxav_hangup ( ToxAv *av, int32_t call_index )
-{
-    return msi_hangup(av->msi_session, call_index);
-}
-int toxav_answer ( ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings )
-{
-    return msi_answer(av->msi_session, call_index, msicsettings_cast(csettings));
-}
-int toxav_reject ( ToxAv *av, int32_t call_index, const char *reason )
-{
-    return msi_reject(av->msi_session, call_index, reason);
-}
-int toxav_cancel ( ToxAv *av, int32_t call_index, int peer_id, const char *reason )
-{
-    return msi_cancel(av->msi_session, call_index, peer_id, reason);
-}
-int toxav_change_settings(ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings)
-{
-    return msi_change_csettings(av->msi_session, call_index, msicsettings_cast(csettings));
-}
-int toxav_stop_call ( ToxAv *av, int32_t call_index )
-{
-    return msi_stopcall(av->msi_session, call_index);
-}
-int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, int support_video )
-{
-    if ( !av->msi_session || CALL_INVALID_INDEX(call_index, av->msi_session->max_calls) ||
-            !av->msi_session->calls[call_index] || !av->msi_session->calls[call_index]->csettings_peer) {
-        LOGGER_ERROR("Error while starting RTP session: invalid call!\n");
-        return av_ErrorNoCall;
-    }
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-    if (call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_ERROR("Error while starting RTP session: call already active!\n");
-        return av_ErrorAlreadyInCallWithPeer;
-    }
-    if (pthread_mutex_init(call->mutex_encoding_audio, NULL) != 0
-            || pthread_mutex_init(call->mutex_encoding_video, NULL) != 0 || pthread_mutex_init(call->mutex_do, NULL) != 0) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_ERROR("Error while starting RTP session: mutex initializing failed!\n");
-        return av_ErrorUnknown;
-    }
-    const ToxAvCSettings *c_peer = toxavcsettings_cast
-                                   (&av->msi_session->calls[call_index]->csettings_peer[0]);
-    const ToxAvCSettings *c_self = toxavcsettings_cast
-                                   (&av->msi_session->calls[call_index]->csettings_local);
-    LOGGER_DEBUG(
-        "Type: %u(s) %u(p)\n"
-        "Video bitrate: %u(s) %u(p)\n"
-        "Video height: %u(s) %u(p)\n"
-        "Video width: %u(s) %u(p)\n"
-        "Audio bitrate: %u(s) %u(p)\n"
-        "Audio framedur: %u(s) %u(p)\n"
-        "Audio sample rate: %u(s) %u(p)\n"
-        "Audio channels: %u(s) %u(p)\n",
-        c_self->call_type,              c_peer->call_type,
-        c_self->video_bitrate,          c_peer->video_bitrate,
-        c_self->max_video_height,       c_peer->max_video_height,
-        c_self->max_video_width,        c_peer->max_video_width,
-        c_self->audio_bitrate,          c_peer->audio_bitrate,
-        c_self->audio_frame_duration,   c_peer->audio_frame_duration,
-        c_self->audio_sample_rate,      c_peer->audio_sample_rate,
-        c_self->audio_channels,         c_peer->audio_channels );
-    if ( !(call->cs = cs_new(c_self, c_peer, jbuf_capacity, support_video)) ) {
-        LOGGER_ERROR("Error while starting Codec State!\n");
-        pthread_mutex_unlock(call->mutex_control);
-        return av_ErrorInitializingCodecs;
-    }
-    call->cs->agent = av;
-    call->cs->acb.first = av->acb.first;
-    call->cs->acb.second = av->acb.second;
-    call->cs->vcb.first = av->vcb.first;
-    call->cs->vcb.second = av->vcb.second;
-    call->crtps[audio_index] =
-        rtp_new(msi_TypeAudio, av->messenger, av->msi_session->calls[call_index]->peers[0]);
-    if ( !call->crtps[audio_index] ) {
-        LOGGER_ERROR("Error while starting audio RTP session!\n");
-        goto error;
-    }
-    call->crtps[audio_index]->cs = call->cs;
-    if ( support_video ) {
-        call->crtps[video_index] =
-            rtp_new(msi_TypeVideo, av->messenger, av->msi_session->calls[call_index]->peers[0]);
-        if ( !call->crtps[video_index] ) {
-            LOGGER_ERROR("Error while starting video RTP session!\n");
-            goto error;
-        }
-        call->crtps[video_index]->cs = call->cs;
-    }
-    call->active = 1;
-    pthread_mutex_unlock(call->mutex_control);
-    return av_ErrorNone;
-error:
-    rtp_kill(call->crtps[audio_index], av->messenger);
-    call->crtps[audio_index] = NULL;
-    rtp_kill(call->crtps[video_index], av->messenger);
-    call->crtps[video_index] = NULL;
-    cs_kill(call->cs);
-    call->cs = NULL;
-    call->active = 0;
-    pthread_mutex_destroy(call->mutex_encoding_audio);
-    pthread_mutex_destroy(call->mutex_encoding_video);
-    pthread_mutex_destroy(call->mutex_do);
-    pthread_mutex_unlock(call->mutex_control);
-    return av_ErrorCreatingRtpSessions;
-}
-int toxav_kill_transmission ( ToxAv *av, int32_t call_index )
-{
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return av_ErrorNoCall;
-    }
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-    call->active = 0;
-    pthread_mutex_lock(call->mutex_encoding_audio);
-    pthread_mutex_unlock(call->mutex_encoding_audio);
-    pthread_mutex_lock(call->mutex_encoding_video);
-    pthread_mutex_unlock(call->mutex_encoding_video);
-    pthread_mutex_lock(call->mutex_do);
-    pthread_mutex_unlock(call->mutex_do);
-    rtp_kill(call->crtps[audio_index], av->messenger);
-    call->crtps[audio_index] = NULL;
-    rtp_kill(call->crtps[video_index], av->messenger);
-    call->crtps[video_index] = NULL;
-    cs_kill(call->cs);
-    call->cs = NULL;
-    pthread_mutex_destroy(call->mutex_encoding_audio);
-    pthread_mutex_destroy(call->mutex_encoding_video);
-    pthread_mutex_destroy(call->mutex_do);
-    pthread_mutex_unlock(call->mutex_control);
-    return av_ErrorNone;
-}
-static int toxav_send_rtp_payload(ToxAv *av,
-                                  ToxAvCall *call,
-                                  ToxAvCallType type,
-                                  const uint8_t *payload,
-                                  unsigned int length)
-{
-    if (call->crtps[type - av_TypeAudio]) {
-        /* Audio */
-        if (type == av_TypeAudio)
-            return rtp_send_msg(call->crtps[audio_index], av->messenger, payload, length);
-        /* Video */
-        int parts = cs_split_video_payload(call->cs, payload, length);
-        if (parts < 0) return parts;
-        uint16_t part_size;
-        const uint8_t *iter;
-        int i;
-        for (i = 0; i < parts; i++) {
-            iter = cs_iterate_split_video_frame(call->cs, &part_size);
-            if (rtp_send_msg(call->crtps[video_index], av->messenger, iter, part_size) < 0)
-                return av_ErrorSendingPayload;
-        }
-        return av_ErrorNone;
-    } else return av_ErrorNoRtpSession;
-}
-int toxav_prepare_video_frame ( ToxAv *av, int32_t call_index, uint8_t *dest, int dest_max, vpx_image_t *input)
-{
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return av_ErrorNoCall;
-    }
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-    if (cs_set_sending_video_resolution(call->cs, input->d_w, input->d_h) < 0) {
-        pthread_mutex_unlock(call->mutex_control);
-        return av_ErrorSettingVideoResolution;
-    }
-    pthread_mutex_lock(call->mutex_encoding_video);
-    pthread_mutex_unlock(call->mutex_control);
-    int rc = vpx_codec_encode(call->cs->v_encoder, input, call->cs->frame_counter, 1, 0, MAX_ENCODE_TIME_US);
-    if ( rc != VPX_CODEC_OK) {
-        LOGGER_ERROR("Could not encode video frame: %s\n", vpx_codec_err_to_string(rc));
-        pthread_mutex_unlock(call->mutex_encoding_video);
-        return av_ErrorEncodingVideo;
-    }
-    ++call->cs->frame_counter;
-    vpx_codec_iter_t iter = NULL;
-    const vpx_codec_cx_pkt_t *pkt;
-    int copied = 0;
-    while ( (pkt = vpx_codec_get_cx_data(call->cs->v_encoder, &iter)) ) {
-        if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
-            if ( copied + pkt->data.frame.sz > dest_max ) {
-                pthread_mutex_unlock(call->mutex_encoding_video);
-                return av_ErrorPacketTooLarge;
-            }
-            memcpy(dest + copied, pkt->data.frame.buf, pkt->data.frame.sz);
-            copied += pkt->data.frame.sz;
-        }
-    }
-    pthread_mutex_unlock(call->mutex_encoding_video);
-    return copied;
-}
-int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, unsigned int frame_size)
-{
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return av_ErrorNoCall;
-    }
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-    int rc = toxav_send_rtp_payload(av, call, av_TypeVideo, frame, frame_size);
-    pthread_mutex_unlock(call->mutex_control);
-    return rc;
-}
-int toxav_prepare_audio_frame ( ToxAv *av,
-                                int32_t call_index,
-                                uint8_t *dest,
-                                int dest_max,
-                                const int16_t *frame,
-                                int frame_size)
-{
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Action on nonexisting call: %d", call_index);
-        return av_ErrorNoCall;
-    }
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-    pthread_mutex_lock(call->mutex_encoding_audio);
-    pthread_mutex_unlock(call->mutex_control);
-    int32_t rc = opus_encode(call->cs->audio_encoder, frame, frame_size, dest, dest_max);
-    pthread_mutex_unlock(call->mutex_encoding_audio);
-    if (rc < 0) {
-        LOGGER_ERROR("Failed to encode payload: %s\n", opus_strerror(rc));
-        return av_ErrorEncodingAudio;
-    }
-    return rc;
-}
-int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *data, unsigned int size)
-{
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Action on nonexisting call: %d", call_index);
-        return av_ErrorNoCall;
-    }
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-    int rc = toxav_send_rtp_payload(av, call, av_TypeAudio, data, size);
-    pthread_mutex_unlock(call->mutex_control);
-    return rc;
-}
-int toxav_get_peer_csettings ( ToxAv *av, int32_t call_index, int peer, ToxAvCSettings *dest )
-{
-    if ( peer < 0 || CALL_INVALID_INDEX(call_index, av->msi_session->max_calls) ||
-            !av->msi_session->calls[call_index] || av->msi_session->calls[call_index]->peer_count <= peer )
-        return av_ErrorNoCall;
-    *dest = *toxavcsettings_cast(&av->msi_session->calls[call_index]->csettings_peer[peer]);
-    return av_ErrorNone;
-}
-int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int peer )
-{
-    if ( peer < 0 || CALL_INVALID_INDEX(call_index, av->msi_session->max_calls) || !av->msi_session->calls[call_index]
-            || av->msi_session->calls[call_index]->peer_count <= peer )
-        return av_ErrorNoCall;
-    return av->msi_session->calls[call_index]->peers[peer];
-}
-ToxAvCallState toxav_get_call_state(ToxAv *av, int32_t call_index)
-{
-    if ( CALL_INVALID_INDEX(call_index, av->msi_session->max_calls) || !av->msi_session->calls[call_index] )
-        return av_CallNonExistent;
-    return av->msi_session->calls[call_index]->state;
-}
-int toxav_capability_supported ( ToxAv *av, int32_t call_index, ToxAvCapabilities capability )
-{
-}
-Tox *toxav_get_tox(ToxAv *av)
-{
-    return (Tox *)av->messenger;
-}
-int toxav_get_active_count(ToxAv *av)
-{
-    if (!av) return -1;
-    int rc = 0, i = 0;
-    for (; i < av->max_calls; i++) {
-        pthread_mutex_lock(av->calls[i].mutex_control);
-        if (av->calls[i].active) rc++;
-        pthread_mutex_unlock(av->calls[i].mutex_control);
-    }
-    return rc;
-}
-/* Create a new toxav group.
- *
- * return group number on success.
- * return -1 on failure.
- *
- * Audio data callback format:
- *   audio_callback(Tox *tox, int groupnumber, int peernumber, const int16_t *pcm, unsigned int samples, uint8_t channels, unsigned int sample_rate, void *userdata)
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- */
-int toxav_add_av_groupchat(Tox *tox, void (*audio_callback)(Messenger *, int, int, const int16_t *, unsigned int,
-                           uint8_t, unsigned int, void *), void *userdata)
-{
-    Messenger *m = tox;
-    return add_av_groupchat(m->group_chat_object, audio_callback, userdata);
-}
-/* Join a AV group (you need to have been invited first.)
- *
- * returns group number on success
- * returns -1 on failure.
- *
- * Audio data callback format (same as the one for toxav_add_av_groupchat()):
- *   audio_callback(Tox *tox, int groupnumber, int peernumber, const int16_t *pcm, unsigned int samples, uint8_t channels, unsigned int sample_rate, void *userdata)
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- */
-int toxav_join_av_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *data, uint16_t length,
-                            void (*audio_callback)(Messenger *, int, int, const int16_t *, unsigned int, uint8_t, unsigned int, void *),
-                            void *userdata)
-{
-    Messenger *m = tox;
-    return join_av_groupchat(m->group_chat_object, friendnumber, data, length, audio_callback, userdata);
-}
-/* Send audio to the group chat.
- *
- * return 0 on success.
- * return -1 on failure.
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- *
- * Valid number of samples are ((sample rate) * (audio length (Valid ones are: 2.5, 5, 10, 20, 40 or 60 ms)) / 1000)
- * Valid number of channels are 1 or 2.
- * Valid sample rates are 8000, 12000, 16000, 24000, or 48000.
- *
- * Recommended values are: samples = 960, channels = 1, sample_rate = 48000
- */
-int toxav_group_send_audio(Tox *tox, int groupnumber, const int16_t *pcm, unsigned int samples, uint8_t channels,
-                           unsigned int sample_rate)
-{
-    Messenger *m = tox;
-    return group_send_audio(m->group_chat_object, groupnumber, pcm, samples, channels, sample_rate);
-}
diff --git a/toxav/toxav_new_1.h b/toxav/toxav_new_1.h
deleted file mode 100644
index 3696f961..00000000
--- a/toxav/toxav_new_1.h
+++ /dev/null
@@ -1,329 +0,0 @@
-/**  toxav.h
- *
- *   Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *   This file is part of Tox.
- *
- *   Tox is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   Tox is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#ifndef __TOXAV
-#define __TOXAV
-#include <inttypes.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-typedef struct _ToxAv ToxAv;
-/* vpx_image_t */
-#include <vpx/vpx_image.h>
-typedef void ( *ToxAVCallback ) ( void *agent, int32_t call_idx, void *arg );
-typedef void ( *ToxAvAudioCallback ) (void *agent, int32_t call_idx, const int16_t *PCM, uint16_t size, void *data);
-typedef void ( *ToxAvVideoCallback ) (void *agent, int32_t call_idx, const vpx_image_t *img, void *data);
-#ifndef __TOX_DEFINED__
-#define __TOX_DEFINED__
-typedef struct Tox Tox;
-#endif
-#define RTP_PAYLOAD_SIZE 65535
-/**
- * Callbacks ids that handle the call states.
- */
-typedef enum {
-    av_OnInvite, /* Incoming call */
-    av_OnRinging, /* When peer is ready to accept/reject the call */
-    av_OnStart, /* Call (RTP transmission) started */
-    av_OnCancel, /* The side that initiated call canceled invite */
-    av_OnReject, /* The side that was invited rejected the call */
-    av_OnEnd, /* Call that was active ended */
-    av_OnRequestTimeout, /* When the requested action didn't get response in specified time */
-    av_OnPeerTimeout, /* Peer timed out; stop the call */
-    av_OnPeerCSChange, /* Peer changing Csettings. Prepare for changed AV */
-    av_OnSelfCSChange /* Csettings change confirmation. Once triggered peer is ready to recv changed AV */
-} ToxAvCallbackID;
-/**
- * Call type identifier.
- */
-typedef enum {
-    av_TypeAudio = 192,
-    av_TypeVideo
-} ToxAvCallType;
-typedef enum {
-    av_CallNonExistent = -1,
-    av_CallInviting, /* when sending call invite */
-    av_CallStarting, /* when getting call invite */
-    av_CallActive,
-    av_CallHold,
-    av_CallHungUp
-} ToxAvCallState;
-/**
- * Error indicators. Values under -20 are reserved for toxcore.
- */
-typedef enum {
-    av_ErrorNone = 0,
-    av_ErrorUnknown = -1, /* Unknown error */
-    av_ErrorNoCall = -20, /* Trying to perform call action while not in a call */
-    av_ErrorInvalidState = -21, /* Trying to perform call action while in invalid state*/
-    av_ErrorAlreadyInCallWithPeer = -22, /* Trying to call peer when already in a call with peer */
-    av_ErrorReachedCallLimit = -23, /* Cannot handle more calls */
-    av_ErrorInitializingCodecs = -30, /* Failed creating CSSession */
-    av_ErrorSettingVideoResolution = -31, /* Error setting resolution */
-    av_ErrorSettingVideoBitrate = -32, /* Error setting bitrate */
-    av_ErrorSplittingVideoPayload = -33, /* Error splitting video payload */
-    av_ErrorEncodingVideo = -34, /* vpx_codec_encode failed */
-    av_ErrorEncodingAudio = -35, /* opus_encode failed */
-    av_ErrorSendingPayload = -40, /* Sending lossy packet failed */
-    av_ErrorCreatingRtpSessions = -41, /* One of the rtp sessions failed to initialize */
-    av_ErrorNoRtpSession = -50, /* Trying to perform rtp action on invalid session */
-    av_ErrorInvalidCodecState = -51, /* Codec state not initialized */
-    av_ErrorPacketTooLarge = -52, /* Split packet exceeds it's limit */
-} ToxAvError;
-/**
- * Locally supported capabilities.
- */
-typedef enum {
-    av_AudioEncoding = 1 << 0,
-    av_AudioDecoding = 1 << 1,
-    av_VideoEncoding = 1 << 2,
-    av_VideoDecoding = 1 << 3
-} ToxAvCapabilities;
-/**
- * Encoding settings.
- */
-typedef struct _ToxAvCSettings {
-    ToxAvCallType call_type;
-    uint32_t video_bitrate; /* In kbits/s */
-    uint16_t max_video_width; /* In px */
-    uint16_t max_video_height; /* In px */
-    uint32_t audio_bitrate; /* In bits/s */
-    uint16_t audio_frame_duration; /* In ms */
-    uint32_t audio_sample_rate; /* In Hz */
-    uint32_t audio_channels;
-} ToxAvCSettings;
-extern const ToxAvCSettings av_DefaultSettings;
-/**
- * Start new A/V session. There can only be one session at the time.
- */
-ToxAv *toxav_new(Tox *messenger, int32_t max_calls);
-/**
- * Remove A/V session.
- */
-void toxav_kill(ToxAv *av);
-/**
- * Returns the interval in milliseconds when the next toxav_do() should be called.
- * If no call is active at the moment returns 200.
- */
-uint32_t toxav_do_interval(ToxAv *av);
-/**
- * Main loop for the session. Best called right after tox_do();
- */
-void toxav_do(ToxAv *av);
-/**
- * Register callback for call state.
- */
-void toxav_register_callstate_callback (ToxAv *av, ToxAVCallback cb, ToxAvCallbackID id, void *userdata);
-/**
- * Register callback for audio data.
- */
-void toxav_register_audio_callback (ToxAv *av, ToxAvAudioCallback cb, void *userdata);
-/**
- * Register callback for video data.
- */
-void toxav_register_video_callback (ToxAv *av, ToxAvVideoCallback cb, void *userdata);
-/**
- * Call user. Use its friend_id.
- */
-int toxav_call(ToxAv *av,
-               int32_t *call_index,
-               int friend_id,
-               const ToxAvCSettings *csettings,
-               int ringing_seconds);
-/**
- * Hangup active call.
- */
-int toxav_hangup(ToxAv *av, int32_t call_index);
-/**
- * Answer incoming call. Pass the csettings that you will use.
- */
-int toxav_answer(ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings );
-/**
- * Reject incoming call.
- */
-int toxav_reject(ToxAv *av, int32_t call_index, const char *reason);
-/**
- * Cancel outgoing request.
- */
-int toxav_cancel(ToxAv *av, int32_t call_index, int peer_id, const char *reason);
-/**
- * Notify peer that we are changing codec settings.
- */
-int toxav_change_settings(ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings);
-/**
- * Terminate transmission. Note that transmission will be
- * terminated without informing remote peer. Usually called when we can't inform peer.
- */
-int toxav_stop_call(ToxAv *av, int32_t call_index);
-/**
- * Allocates transmission data. Must be call before calling toxav_prepare_* and toxav_send_*.
- * Also, it must be called when call is started
- */
-int toxav_prepare_transmission(ToxAv *av, int32_t call_index, int support_video);
-/**
- * Clears transmission data. Call this at the end of the transmission.
- */
-int toxav_kill_transmission(ToxAv *av, int32_t call_index);
-/**
- * Encode video frame.
- */
-int toxav_prepare_video_frame ( ToxAv *av,
-                                int32_t call_index,
-                                uint8_t *dest,
-                                int dest_max,
-                                vpx_image_t *input);
-/**
- * Send encoded video packet.
- */
-int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, uint32_t frame_size);
-/**
- * Encode audio frame.
- */
-int toxav_prepare_audio_frame ( ToxAv *av,
-                                int32_t call_index,
-                                uint8_t *dest,
-                                int dest_max,
-                                const int16_t *frame,
-                                int frame_size);
-/**
- * Send encoded audio frame.
- */
-int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *frame, unsigned int size);
-/**
- * Get codec settings from the peer. These were exchanged during call initialization
- * or when peer send us new csettings.
- */
-int toxav_get_peer_csettings ( ToxAv *av, int32_t call_index, int peer, ToxAvCSettings *dest );
-/**
- * Get friend id of peer participating in conversation.
- */
-int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int peer );
-/**
- * Get current call state.
- */
-ToxAvCallState toxav_get_call_state ( ToxAv *av, int32_t call_index );
-/**
- * Is certain capability supported. Used to determine if encoding/decoding is ready.
- */
-int toxav_capability_supported ( ToxAv *av, int32_t call_index, ToxAvCapabilities capability );
-/**
- * Returns tox reference.
- */
-Tox *toxav_get_tox (ToxAv *av);
-/**
- * Returns number of active calls or -1 on error.
- */
-int toxav_get_active_count (ToxAv *av);
-/* Create a new toxav group.
- *
- * return group number on success.
- * return -1 on failure.
- *
- * Audio data callback format:
- *   audio_callback(Tox *tox, int groupnumber, int peernumber, const int16_t *pcm, unsigned int samples, uint8_t channels, unsigned int sample_rate, void *userdata)
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- */
-int toxav_add_av_groupchat(Tox *tox, void (*audio_callback)(Tox *, int, int, const int16_t *, unsigned int, uint8_t,
-                           unsigned int, void *), void *userdata);
-/* Join a AV group (you need to have been invited first.)
- *
- * returns group number on success
- * returns -1 on failure.
- *
- * Audio data callback format (same as the one for toxav_add_av_groupchat()):
- *   audio_callback(Tox *tox, int groupnumber, int peernumber, const int16_t *pcm, unsigned int samples, uint8_t channels, unsigned int sample_rate, void *userdata)
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- */
-int toxav_join_av_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *data, uint16_t length,
-                            void (*audio_callback)(Tox *, int, int, const int16_t *, unsigned int, uint8_t, unsigned int, void *), void *userdata);
-/* Send audio to the group chat.
- *
- * return 0 on success.
- * return -1 on failure.
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- *
- * Valid number of samples are ((sample rate) * (audio length (Valid ones are: 2.5, 5, 10, 20, 40 or 60 ms)) / 1000)
- * Valid number of channels are 1 or 2.
- * Valid sample rates are 8000, 12000, 16000, 24000, or 48000.
- *
- * Recommended values are: samples = 960, channels = 1, sample_rate = 48000
- */
-int toxav_group_send_audio(Tox *tox, int groupnumber, const int16_t *pcm, unsigned int samples, uint8_t channels,
-                           unsigned int sample_rate);
-#ifdef __cplusplus
-}
-#endif
-#endif /* __TOXAV */