Merge remote-tracking branch 'upstream/master' into rm-files

1 files changed, 1039 insertions, 468 deletions

diff --git a/toxav/toxav.c b/toxav/toxav.c
index a51ec5e3..9eda3412 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -1,6 +1,6 @@
 /**  toxav.c
  *
- *   Copyright (C) 2013 Tox project All Rights Reserved.
+ *   Copyright (C) 2013-2015 Tox project All Rights Reserved.
  *
  *   This file is part of Tox.
  *
@@ -23,15 +23,10 @@
 #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 "rtp.h"
 
+#include "../toxcore/Messenger.h"
 #include "../toxcore/logger.h"
 #include "../toxcore/util.h"
 
@@ -39,659 +34,1235 @@ typedef struct Messenger Tox;
 #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)
+typedef struct ToxAVCall_s {
+    ToxAV *av;
 
-const ToxAvCSettings av_DefaultSettings = {
-    av_TypeAudio,
+    pthread_mutex_t mutex_audio[1];
+    PAIR(RTPSession *, ACSession *) audio;
 
-    500,
-    1280,
-    720,
+    pthread_mutex_t mutex_video[1];
+    PAIR(RTPSession *, VCSession *) video;
 
-    32000,
-    20,
-    48000,
-    1
-};
+    BWControler *bwc;
+
+    bool active;
+    MSICall *msi_call;
+    uint32_t friend_number;
+
+    uint32_t audio_bit_rate; /* Sending audio bit rate */
+    uint32_t video_bit_rate; /* Sending video bit rate */
 
-static const uint32_t jbuf_capacity = 6;
-static const uint8_t audio_index = 0, video_index = 1;
+    /** Required for monitoring changes in states */
+    uint8_t previous_self_capabilities;
 
-typedef struct _ToxAvCall {
     pthread_mutex_t mutex[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 */
+
+    struct ToxAVCall_s *prev;
+    struct ToxAVCall_s *next;
+} ToxAVCall;
+
+struct ToxAV {
+    Messenger *m;
+    MSISession *msi;
+
+    /* Two-way storage: first is array of calls and second is list of calls with head and tail */
+    ToxAVCall **calls;
+    uint32_t calls_tail;
+    uint32_t calls_head;
+    pthread_mutex_t mutex[1];
+
+    PAIR(toxav_call_cb *, void *) ccb; /* Call callback */
+    PAIR(toxav_call_state_cb *, void *) scb; /* Call state callback */
+    PAIR(toxav_audio_receive_frame_cb *, void *) acb; /* Audio frame receive callback */
+    PAIR(toxav_video_receive_frame_cb *, void *) vcb; /* Video frame receive callback */
+    PAIR(toxav_bit_rate_status_cb *, void *) bcb; /* Bit rate control callback */
+
+    /** Decode time measures */
+    int32_t dmssc; /** Measure count */
+    int32_t dmsst; /** Last cycle total */
+    int32_t dmssa; /** Average decoding time in ms */
+
+    uint32_t interval; /** Calculated interval */
 };
 
-static const MSICSettings *msicsettings_cast (const ToxAvCSettings *from)
+void callback_bwc (BWControler *bwc, uint32_t friend_number, float loss, void *user_data);
+
+int callback_invite(void *toxav_inst, MSICall *call);
+int callback_start(void *toxav_inst, MSICall *call);
+int callback_end(void *toxav_inst, MSICall *call);
+int callback_error(void *toxav_inst, MSICall *call);
+int callback_capabilites(void *toxav_inst, MSICall *call);
+
+bool audio_bit_rate_invalid(uint32_t bit_rate);
+bool video_bit_rate_invalid(uint32_t bit_rate);
+bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state);
+ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, TOXAV_ERR_CALL *error);
+ToxAVCall *call_get(ToxAV *av, uint32_t friend_number);
+ToxAVCall *call_remove(ToxAVCall *call);
+bool call_prepare_transmission(ToxAVCall *call);
+void call_kill_transmission(ToxAVCall *call);
+
+uint32_t toxav_version_major(void)
 {
-    assert(sizeof(MSICSettings) == sizeof(ToxAvCSettings));
-    return (const MSICSettings *) from;
+    return 0;
 }
-
-static const ToxAvCSettings *toxavcsettings_cast (const MSICSettings *from)
+uint32_t toxav_version_minor(void)
 {
-    assert(sizeof(MSICSettings) == sizeof(ToxAvCSettings));
-    return (const ToxAvCSettings *) from;
-
+    return 0;
+}
+uint32_t toxav_version_patch(void)
+{
+    return 0;
 }
+bool toxav_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch)
+{
+    (void)major;
+    (void)minor;
+    (void)patch;
 
-ToxAv *toxav_new( Tox *messenger, int32_t max_calls)
+    return 1;
+}
+ToxAV *toxav_new(Tox *tox, TOXAV_ERR_NEW *error)
 {
-    ToxAv *av = calloc ( sizeof(ToxAv), 1);
+    TOXAV_ERR_NEW rc = TOXAV_ERR_NEW_OK;
+    ToxAV *av = NULL;
+
+    if (tox == NULL) {
+        rc = TOXAV_ERR_NEW_NULL;
+        goto END;
+    }
+
+    if (((Messenger *)tox)->msi_packet) {
+        rc = TOXAV_ERR_NEW_MULTIPLE;
+        goto END;
+    }
+
+    av = calloc (sizeof(ToxAV), 1);
 
     if (av == NULL) {
         LOGGER_WARNING("Allocation failed!");
-        return NULL;
+        rc = TOXAV_ERR_NEW_MALLOC;
+        goto END;
+    }
+
+    if (create_recursive_mutex(av->mutex) != 0) {
+        LOGGER_WARNING("Mutex creation failed!");
+        rc = TOXAV_ERR_NEW_MALLOC;
+        goto END;
     }
 
-    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;
+    av->m = (Messenger *)tox;
+    av->msi = msi_new(av->m);
 
-    unsigned int i;
+    if (av->msi == NULL) {
+        pthread_mutex_destroy(av->mutex);
+        rc = TOXAV_ERR_NEW_MALLOC;
+        goto END;
+    }
 
-    for (i = 0; i < max_calls; ++i) {
-        if (create_recursive_mutex(av->calls[i].mutex) != 0 ) {
-            LOGGER_WARNING("Failed to init call(%u) mutex!", i);
-            msi_kill(av->msi_session);
+    av->interval = 200;
+    av->msi->av = av;
 
-            free(av->calls);
-            free(av);
-            return NULL;
-        }
+    msi_register_callback(av->msi, callback_invite, msi_OnInvite);
+    msi_register_callback(av->msi, callback_start, msi_OnStart);
+    msi_register_callback(av->msi, callback_end, msi_OnEnd);
+    msi_register_callback(av->msi, callback_error, msi_OnError);
+    msi_register_callback(av->msi, callback_error, msi_OnPeerTimeout);
+    msi_register_callback(av->msi, callback_capabilites, msi_OnCapabilities);
+
+END:
+
+    if (error)
+        *error = rc;
+
+    if (rc != TOXAV_ERR_NEW_OK) {
+        free(av);
+        av = NULL;
     }
 
     return av;
 }
-
-void toxav_kill ( ToxAv *av )
+void toxav_kill(ToxAV *av)
 {
-    uint32_t i;
+    if (av == NULL)
+        return;
 
-    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);
+    pthread_mutex_lock(av->mutex);
 
+    /* To avoid possible deadlocks */
+    while (av->msi && msi_kill(av->msi) != 0) {
+        pthread_mutex_unlock(av->mutex);
+        pthread_mutex_lock(av->mutex);
+    }
 
-        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);
+    /* Msi kill will hang up all calls so just clean these calls */
+    if (av->calls) {
+        ToxAVCall *it = call_get(av, av->calls_head);
 
-        pthread_mutex_destroy(av->calls[i].mutex);
+        while (it) {
+            call_kill_transmission(it);
+            it = call_remove(it); /* This will eventually free av->calls */
+        }
     }
 
-    msi_kill(av->msi_session);
+    pthread_mutex_unlock(av->mutex);
+    pthread_mutex_destroy(av->mutex);
 
-    free(av->calls);
     free(av);
 }
-
-uint32_t toxav_do_interval(ToxAv *av)
+Tox *toxav_get_tox(const ToxAV *av)
+{
+    return (Tox *) av->m;
+}
+uint32_t toxav_iteration_interval(const ToxAV *av)
 {
-    int i = 0;
-    uint32_t rc = 200 + av->avgdectms; /* Return 200 if no call is active */
+    /* If no call is active interval is 200 */
+    return av->calls ? av->interval : 200;
+}
+void toxav_iterate(ToxAV *av)
+{
+    pthread_mutex_lock(av->mutex);
 
-    for (; i < av->max_calls; i ++) {
-        pthread_mutex_lock(av->calls[i].mutex);
+    if (av->calls == NULL) {
+        pthread_mutex_unlock(av->mutex);
+        return;
+    }
 
-        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);
-        }
+    uint64_t start = current_time_monotonic();
+    int32_t rc = 500;
 
-        pthread_mutex_unlock(av->calls[i].mutex);
-    }
+    ToxAVCall *i = av->calls[av->calls_head];
 
-    return rc < av->avgdectms ? 0 : rc - av->avgdectms;
-}
+    for (; i; i = i->next) {
+        if (i->active) {
+            pthread_mutex_lock(i->mutex);
+            pthread_mutex_unlock(av->mutex);
 
-void toxav_do(ToxAv *av)
-{
-    msi_do(av->msi_session);
+            ac_iterate(i->audio.second);
+            vc_iterate(i->video.second);
 
-    uint64_t start = current_time_monotonic();
+            if (i->msi_call->self_capabilities & msi_CapRAudio &&
+                    i->msi_call->peer_capabilities & msi_CapSAudio)
+                rc = MIN(i->audio.second->lp_frame_duration, rc);
 
-    uint32_t i = 0;
+            if (i->msi_call->self_capabilities & msi_CapRVideo &&
+                    i->msi_call->peer_capabilities & msi_CapSVideo)
+                rc = MIN(i->video.second->lcfd, (uint32_t) rc);
 
-    for (; i < av->max_calls; i ++) {
-        pthread_mutex_lock(av->calls[i].mutex);
+            uint32_t fid = i->friend_number;
 
-        if (av->calls[i].active) {
-            pthread_mutex_lock(av->calls[i].mutex_do);
-            pthread_mutex_unlock(av->calls[i].mutex);
-            cs_do(av->calls[i].cs);
-            pthread_mutex_unlock(av->calls[i].mutex_do);
-        } else {
-            pthread_mutex_unlock(av->calls[i].mutex);
+            pthread_mutex_unlock(i->mutex);
+            pthread_mutex_lock(av->mutex);
+
+            /* In case this call is popped from container stop iteration */
+            if (call_get(av, fid) != i)
+                break;
         }
     }
 
-    uint64_t end = current_time_monotonic();
+    pthread_mutex_unlock(av->mutex);
 
-    /* TODO maybe use variable for sizes */
-    av->dectmsstotal += end - start;
+    av->interval = rc < av->dmssa ? 0 : (rc - av->dmssa);
+    av->dmsst += current_time_monotonic() - start;
 
-    if (++av->dectmsscount == 3) {
-        av->avgdectms = av->dectmsstotal / 3 + 2 /* NOTE Magic Offset */;
-        av->dectmsscount = 0;
-        av->dectmsstotal = 0;
+    if (++av->dmssc == 3) {
+        av->dmssa = av->dmsst / 3 + 5 /* NOTE Magic Offset for precission */;
+        av->dmssc = 0;
+        av->dmsst = 0;
     }
 }
-
-void toxav_register_callstate_callback ( ToxAv *av, ToxAVCallback cb, ToxAvCallbackID id, void *userdata )
+bool toxav_call(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate,
+                TOXAV_ERR_CALL *error)
 {
-    msi_register_callback(av->msi_session, (MSICallbackType)cb, (MSICallbackID) id, userdata);
-}
+    TOXAV_ERR_CALL rc = TOXAV_ERR_CALL_OK;
 
-void toxav_register_audio_callback(ToxAv *av, ToxAvAudioCallback cb, void *userdata)
-{
-    av->acb.first = cb;
-    av->acb.second = userdata;
-}
+    pthread_mutex_lock(av->mutex);
 
-void toxav_register_video_callback(ToxAv *av, ToxAvVideoCallback cb, void *userdata)
-{
-    av->vcb.first = cb;
-    av->vcb.second = userdata;
-}
+    if ((audio_bit_rate && audio_bit_rate_invalid(audio_bit_rate))
+            || (video_bit_rate && video_bit_rate_invalid(video_bit_rate))) {
+        rc = TOXAV_ERR_CALL_INVALID_BIT_RATE;
+        goto END;
+    }
 
-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);
-}
+    ToxAVCall *call = call_new(av, friend_number, error);
 
-int toxav_hangup ( ToxAv *av, int32_t call_index )
-{
-    return msi_hangup(av->msi_session, call_index);
-}
+    if (call == NULL) {
+        rc = TOXAV_ERR_CALL_MALLOC;
+        goto END;
+    }
 
-int toxav_answer ( ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings )
-{
-    return msi_answer(av->msi_session, call_index, msicsettings_cast(csettings));
-}
+    call->audio_bit_rate = audio_bit_rate;
+    call->video_bit_rate = video_bit_rate;
 
-int toxav_reject ( ToxAv *av, int32_t call_index, const char *reason )
-{
-    return msi_reject(av->msi_session, call_index, reason);
-}
+    call->previous_self_capabilities = msi_CapRAudio | msi_CapRVideo;
 
-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);
-}
+    call->previous_self_capabilities |= audio_bit_rate > 0 ? msi_CapSAudio : 0;
+    call->previous_self_capabilities |= video_bit_rate > 0 ? msi_CapSVideo : 0;
 
-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));
-}
+    if (msi_invite(av->msi, &call->msi_call, friend_number, call->previous_self_capabilities) != 0) {
+        call_remove(call);
+        rc = TOXAV_ERR_CALL_SYNC;
+        goto END;
+    }
 
-int toxav_stop_call ( ToxAv *av, int32_t call_index )
+    call->msi_call->av_call = call;
+
+END:
+    pthread_mutex_unlock(av->mutex);
+
+    if (error)
+        *error = rc;
+
+    return rc == TOXAV_ERR_CALL_OK;
+}
+void toxav_callback_call(ToxAV *av, toxav_call_cb *function, void *user_data)
 {
-    return msi_stopcall(av->msi_session, call_index);
+    pthread_mutex_lock(av->mutex);
+    av->ccb.first = function;
+    av->ccb.second = user_data;
+    pthread_mutex_unlock(av->mutex);
 }
-
-int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, int support_video )
+bool toxav_answer(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate,
+                  TOXAV_ERR_ANSWER *error)
 {
-    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(av->mutex);
 
-    pthread_mutex_lock(call->mutex);
+    TOXAV_ERR_ANSWER rc = TOXAV_ERR_ANSWER_OK;
 
-    if (call->active) {
-        pthread_mutex_unlock(call->mutex);
-        LOGGER_ERROR("Error while starting RTP session: call already active!\n");
-        return av_ErrorAlreadyInCallWithPeer;
+    if (m_friend_exists(av->m, friend_number) == 0) {
+        rc = TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND;
+        goto END;
     }
 
-    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);
-        LOGGER_ERROR("Error while starting RTP session: mutex initializing failed!\n");
-        return av_ErrorUnknown;
+    if ((audio_bit_rate && audio_bit_rate_invalid(audio_bit_rate))
+            || (video_bit_rate && video_bit_rate_invalid(video_bit_rate))
+       ) {
+        rc = TOXAV_ERR_ANSWER_INVALID_BIT_RATE;
+        goto END;
     }
 
-    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);
+    ToxAVCall *call = call_get(av, friend_number);
 
-    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 == NULL) {
+        rc = TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING;
+        goto END;
+    }
 
-    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);
-        return av_ErrorInitializingCodecs;
+    if (!call_prepare_transmission(call)) {
+        rc = TOXAV_ERR_ANSWER_CODEC_INITIALIZATION;
+        goto END;
     }
 
-    call->cs->agent = av;
-    call->cs->call_idx = call_index;
+    call->audio_bit_rate = audio_bit_rate;
+    call->video_bit_rate = video_bit_rate;
 
-    call->cs->acb.first = av->acb.first;
-    call->cs->acb.second = av->acb.second;
+    call->previous_self_capabilities = msi_CapRAudio | msi_CapRVideo;
 
-    call->cs->vcb.first = av->vcb.first;
-    call->cs->vcb.second = av->vcb.second;
+    call->previous_self_capabilities |= audio_bit_rate > 0 ? msi_CapSAudio : 0;
+    call->previous_self_capabilities |= video_bit_rate > 0 ? msi_CapSVideo : 0;
 
+    if (msi_answer(call->msi_call, call->previous_self_capabilities) != 0)
+        rc = TOXAV_ERR_ANSWER_SYNC;
 
-    call->crtps[audio_index] =
-        rtp_new(msi_TypeAudio, av->messenger, av->msi_session->calls[call_index]->peers[0]);
+END:
+    pthread_mutex_unlock(av->mutex);
 
-    if ( !call->crtps[audio_index] ) {
-        LOGGER_ERROR("Error while starting audio RTP session!\n");
-        goto error;
+    if (error)
+        *error = rc;
+
+    return rc == TOXAV_ERR_ANSWER_OK;
+}
+void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *function, void *user_data)
+{
+    pthread_mutex_lock(av->mutex);
+    av->scb.first = function;
+    av->scb.second = user_data;
+    pthread_mutex_unlock(av->mutex);
+}
+bool toxav_call_control(ToxAV *av, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL *error)
+{
+    pthread_mutex_lock(av->mutex);
+    TOXAV_ERR_CALL_CONTROL rc = TOXAV_ERR_CALL_CONTROL_OK;
+
+    if (m_friend_exists(av->m, friend_number) == 0) {
+        rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND;
+        goto END;
     }
 
-    call->crtps[audio_index]->cs = call->cs;
+    ToxAVCall *call = call_get(av, friend_number);
 
-    if ( support_video ) {
-        call->crtps[video_index] =
-            rtp_new(msi_TypeVideo, av->messenger, av->msi_session->calls[call_index]->peers[0]);
+    if (call == NULL || (!call->active && control != TOXAV_CALL_CONTROL_CANCEL)) {
+        rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL;
+        goto END;
+    }
 
-        if ( !call->crtps[video_index] ) {
-            LOGGER_ERROR("Error while starting video RTP session!\n");
-            goto error;
+    switch (control) {
+        case TOXAV_CALL_CONTROL_RESUME: {
+            /* Only act if paused and had media transfer active before */
+            if (call->msi_call->self_capabilities == 0 &&
+                    call->previous_self_capabilities) {
+
+                if (msi_change_capabilities(call->msi_call,
+                                            call->previous_self_capabilities) == -1) {
+                    rc = TOXAV_ERR_CALL_CONTROL_SYNC;
+                    goto END;
+                }
+
+                rtp_allow_receiving(call->audio.first);
+                rtp_allow_receiving(call->video.first);
+            } else {
+                rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
+                goto END;
+            }
         }
+        break;
+
+        case TOXAV_CALL_CONTROL_PAUSE: {
+            /* Only act if not already paused */
+            if (call->msi_call->self_capabilities) {
+                call->previous_self_capabilities = call->msi_call->self_capabilities;
+
+                if (msi_change_capabilities(call->msi_call, 0) == -1) {
+                    rc = TOXAV_ERR_CALL_CONTROL_SYNC;
+                    goto END;
+                }
+
+                rtp_stop_receiving(call->audio.first);
+                rtp_stop_receiving(call->video.first);
+            } else {
+                rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
+                goto END;
+            }
+        }
+        break;
+
+        case TOXAV_CALL_CONTROL_CANCEL: {
+            /* Hang up */
+            pthread_mutex_lock(call->mutex);
+
+            if (msi_hangup(call->msi_call) != 0) {
+                rc = TOXAV_ERR_CALL_CONTROL_SYNC;
+                pthread_mutex_unlock(call->mutex);
+                goto END;
+            }
+
+            call->msi_call = NULL;
+            pthread_mutex_unlock(call->mutex);
 
-        call->crtps[video_index]->cs = call->cs;
+            /* No mather the case, terminate the call */
+            call_kill_transmission(call);
+            call_remove(call);
+        }
+        break;
+
+        case TOXAV_CALL_CONTROL_MUTE_AUDIO: {
+            if (call->msi_call->self_capabilities & msi_CapRAudio) {
+                if (msi_change_capabilities(call->msi_call, call->
+                                            msi_call->self_capabilities ^ msi_CapRAudio) == -1) {
+                    rc = TOXAV_ERR_CALL_CONTROL_SYNC;
+                    goto END;
+                }
+
+                rtp_stop_receiving(call->audio.first);
+            } else {
+                rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
+                goto END;
+            }
+        }
+        break;
+
+        case TOXAV_CALL_CONTROL_UNMUTE_AUDIO: {
+            if (call->msi_call->self_capabilities ^ msi_CapRAudio) {
+                if (msi_change_capabilities(call->msi_call, call->
+                                            msi_call->self_capabilities | msi_CapRAudio) == -1) {
+                    rc = TOXAV_ERR_CALL_CONTROL_SYNC;
+                    goto END;
+                }
+
+                rtp_allow_receiving(call->audio.first);
+            } else {
+                rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
+                goto END;
+            }
+        }
+        break;
+
+        case TOXAV_CALL_CONTROL_HIDE_VIDEO: {
+            if (call->msi_call->self_capabilities & msi_CapRVideo) {
+                if (msi_change_capabilities(call->msi_call, call->
+                                            msi_call->self_capabilities ^ msi_CapRVideo) == -1) {
+                    rc = TOXAV_ERR_CALL_CONTROL_SYNC;
+                    goto END;
+                }
+
+                rtp_stop_receiving(call->video.first);
+            } else {
+                rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
+                goto END;
+            }
+        }
+        break;
+
+        case TOXAV_CALL_CONTROL_SHOW_VIDEO: {
+            if (call->msi_call->self_capabilities ^ msi_CapRVideo) {
+                if (msi_change_capabilities(call->msi_call, call->
+                                            msi_call->self_capabilities | msi_CapRVideo) == -1) {
+                    rc = TOXAV_ERR_CALL_CONTROL_SYNC;
+                    goto END;
+                }
+
+                rtp_allow_receiving(call->audio.first);
+            } else {
+                rc = TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION;
+                goto END;
+            }
+        }
+        break;
     }
 
-    call->active = 1;
-    pthread_mutex_unlock(call->mutex);
-    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);
+END:
+    pthread_mutex_unlock(av->mutex);
 
-    pthread_mutex_unlock(call->mutex);
-    return av_ErrorCreatingRtpSessions;
-}
+    if (error)
+        *error = rc;
 
-int toxav_kill_transmission ( ToxAv *av, int32_t call_index )
+    return rc == TOXAV_ERR_CALL_CONTROL_OK;
+}
+bool toxav_bit_rate_set(ToxAV *av, uint32_t friend_number, int32_t audio_bit_rate,
+                        int32_t video_bit_rate, TOXAV_ERR_BIT_RATE_SET *error)
 {
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return av_ErrorNoCall;
+    TOXAV_ERR_BIT_RATE_SET rc = TOXAV_ERR_BIT_RATE_SET_OK;
+    ToxAVCall *call;
+
+    if (m_friend_exists(av->m, friend_number) == 0) {
+        rc = TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_FOUND;
+        goto END;
     }
 
-    ToxAvCall *call = &av->calls[call_index];
+    if (audio_bit_rate > 0 && audio_bit_rate_invalid(audio_bit_rate)) {
+        rc = TOXAV_ERR_BIT_RATE_SET_INVALID_AUDIO_BIT_RATE;
+        goto END;
+    }
 
-    pthread_mutex_lock(call->mutex);
+    if (video_bit_rate > 0 && video_bit_rate_invalid(video_bit_rate)) {
+        rc = TOXAV_ERR_BIT_RATE_SET_INVALID_VIDEO_BIT_RATE;
+        goto END;
+    }
+
+    pthread_mutex_lock(av->mutex);
+    call = call_get(av, friend_number);
 
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
+    if (call == NULL || !call->active || call->msi_call->state != msi_CallActive) {
+        pthread_mutex_unlock(av->mutex);
+        rc = TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL;
+        goto END;
     }
 
-    call->active = 0;
+    if (audio_bit_rate >= 0) {
+        LOGGER_DEBUG("Setting new audio bitrate to: %d", audio_bit_rate);
 
-    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);
+        if (call->audio_bit_rate == audio_bit_rate) {
+            LOGGER_DEBUG("Audio bitrate already set to: %d", audio_bit_rate);
+        } else if (audio_bit_rate == 0) {
+            LOGGER_DEBUG("Turned off audio sending");
 
-    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;
+            if (msi_change_capabilities(call->msi_call, call->msi_call->
+                                        self_capabilities ^ msi_CapSAudio) != 0) {
+                pthread_mutex_unlock(av->mutex);
+                rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
+                goto END;
+            }
 
-    pthread_mutex_destroy(call->mutex_encoding_audio);
-    pthread_mutex_destroy(call->mutex_encoding_video);
-    pthread_mutex_destroy(call->mutex_do);
+            /* Audio sending is turned off; notify peer */
+            call->audio_bit_rate = 0;
+        } else {
+            pthread_mutex_lock(call->mutex);
+
+            if (call->audio_bit_rate == 0) {
+                LOGGER_DEBUG("Turned on audio sending");
+
+                /* The audio has been turned off before this */
+                if (msi_change_capabilities(call->msi_call, call->
+                                            msi_call->self_capabilities | msi_CapSAudio) != 0) {
+                    pthread_mutex_unlock(call->mutex);
+                    pthread_mutex_unlock(av->mutex);
+                    rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
+                    goto END;
+                }
+            } else
+                LOGGER_DEBUG("Set new audio bit rate %d", audio_bit_rate);
+
+            call->audio_bit_rate = audio_bit_rate;
+            pthread_mutex_unlock(call->mutex);
+        }
+    }
 
-    pthread_mutex_unlock(call->mutex);
+    if (video_bit_rate >= 0) {
+        LOGGER_DEBUG("Setting new video bitrate to: %d", video_bit_rate);
 
-    return av_ErrorNone;
-}
+        if (call->video_bit_rate == video_bit_rate) {
+            LOGGER_DEBUG("Video bitrate already set to: %d", video_bit_rate);
+        } else if (video_bit_rate == 0) {
+            LOGGER_DEBUG("Turned off video sending");
 
-static int toxav_send_rtp_payload(ToxAv *av,
-                                  ToxAvCall *call,
-                                  ToxAvCallType type,
-                                  const uint8_t *payload,
-                                  unsigned int length)
+            /* Video sending is turned off; notify peer */
+            if (msi_change_capabilities(call->msi_call, call->msi_call->
+                                        self_capabilities ^ msi_CapSVideo) != 0) {
+                pthread_mutex_unlock(av->mutex);
+                rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
+                goto END;
+            }
+
+            call->video_bit_rate = 0;
+        } else {
+            pthread_mutex_lock(call->mutex);
+
+            if (call->video_bit_rate == 0) {
+                LOGGER_DEBUG("Turned on video sending");
+
+                /* The video has been turned off before this */
+                if (msi_change_capabilities(call->msi_call, call->
+                                            msi_call->self_capabilities | msi_CapSVideo) != 0) {
+                    pthread_mutex_unlock(call->mutex);
+                    pthread_mutex_unlock(av->mutex);
+                    rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
+                    goto END;
+                }
+            } else
+                LOGGER_DEBUG("Set new video bit rate %d", video_bit_rate);
+
+            call->video_bit_rate = video_bit_rate;
+            pthread_mutex_unlock(call->mutex);
+        }
+    }
+
+    pthread_mutex_unlock(av->mutex);
+END:
+
+    if (error)
+        *error = rc;
+
+    return rc == TOXAV_ERR_BIT_RATE_SET_OK;
+}
+void toxav_callback_bit_rate_status(ToxAV *av, toxav_bit_rate_status_cb *function, void *user_data)
 {
-    if (call->crtps[type - av_TypeAudio]) {
+    pthread_mutex_lock(av->mutex);
+    av->bcb.first = function;
+    av->bcb.second = user_data;
+    pthread_mutex_unlock(av->mutex);
+}
+bool toxav_audio_send_frame(ToxAV *av, uint32_t friend_number, const int16_t *pcm, size_t sample_count,
+                            uint8_t channels, uint32_t sampling_rate, TOXAV_ERR_SEND_FRAME *error)
+{
+    TOXAV_ERR_SEND_FRAME rc = TOXAV_ERR_SEND_FRAME_OK;
+    ToxAVCall *call;
+
+    if (m_friend_exists(av->m, friend_number) == 0) {
+        rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_FOUND;
+        goto END;
+    }
+
+    if (pthread_mutex_trylock(av->mutex) != 0) {
+        rc = TOXAV_ERR_SEND_FRAME_SYNC;
+        goto END;
+    }
 
-        /* Audio */
-        if (type == av_TypeAudio)
-            return rtp_send_msg(call->crtps[audio_index], av->messenger, payload, length);
+    call = call_get(av, friend_number);
 
-        /* Video */
-        int parts = cs_split_video_payload(call->cs, payload, length);
+    if (call == NULL || !call->active || call->msi_call->state != msi_CallActive) {
+        pthread_mutex_unlock(av->mutex);
+        rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL;
+        goto END;
+    }
 
-        if (parts < 0) return parts;
+    if (call->audio_bit_rate == 0 ||
+            !(call->msi_call->self_capabilities & msi_CapSAudio) ||
+            !(call->msi_call->peer_capabilities & msi_CapRAudio)) {
+        pthread_mutex_unlock(av->mutex);
+        rc = TOXAV_ERR_SEND_FRAME_PAYLOAD_TYPE_DISABLED;
+        goto END;
+    }
 
-        uint16_t part_size;
-        const uint8_t *iter;
+    pthread_mutex_lock(call->mutex_audio);
+    pthread_mutex_unlock(av->mutex);
 
-        int i;
+    if (pcm == NULL) {
+        pthread_mutex_unlock(call->mutex_audio);
+        rc = TOXAV_ERR_SEND_FRAME_NULL;
+        goto END;
+    }
 
-        for (i = 0; i < parts; i++) {
-            iter = cs_get_split_video_frame(call->cs, &part_size);
+    if (channels > 2) {
+        pthread_mutex_unlock(call->mutex_audio);
+        rc = TOXAV_ERR_SEND_FRAME_INVALID;
+        goto END;
+    }
 
-            if (rtp_send_msg(call->crtps[video_index], av->messenger, iter, part_size) < 0)
-                return av_ErrorSendingPayload;
+    { /* Encode and send */
+        if (ac_reconfigure_encoder(call->audio.second, call->audio_bit_rate * 1000, sampling_rate, channels) != 0) {
+            pthread_mutex_unlock(call->mutex_audio);
+            rc = TOXAV_ERR_SEND_FRAME_INVALID;
+            goto END;
         }
 
-        return av_ErrorNone;
+        uint8_t dest[sample_count + sizeof(sampling_rate)]; /* This is more than enough always */
 
-    } else return av_ErrorNoRtpSession;
-}
+        sampling_rate = htonl(sampling_rate);
+        memcpy(dest, &sampling_rate, sizeof(sampling_rate));
+        int vrc = opus_encode(call->audio.second->encoder, pcm, sample_count,
+                              dest + sizeof(sampling_rate), sizeof(dest) - sizeof(sampling_rate));
+
+        if (vrc < 0) {
+            LOGGER_WARNING("Failed to encode frame %s", opus_strerror(vrc));
+            pthread_mutex_unlock(call->mutex_audio);
+            rc = TOXAV_ERR_SEND_FRAME_INVALID;
+            goto END;
+        }
 
-int toxav_prepare_video_frame ( ToxAv *av, int32_t call_index, uint8_t *dest, int dest_max, vpx_image_t *input)
+        if (rtp_send_data(call->audio.first, dest, vrc + sizeof(sampling_rate)) != 0) {
+            LOGGER_WARNING("Failed to send audio packet");
+            rc = TOXAV_ERR_SEND_FRAME_RTP_FAILED;
+        }
+    }
+
+
+    pthread_mutex_unlock(call->mutex_audio);
+
+END:
+
+    if (error)
+        *error = rc;
+
+    return rc == TOXAV_ERR_SEND_FRAME_OK;
+}
+bool toxav_video_send_frame(ToxAV *av, uint32_t friend_number, uint16_t width, uint16_t height, const uint8_t *y,
+                            const uint8_t *u, const uint8_t *v, TOXAV_ERR_SEND_FRAME *error)
 {
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return av_ErrorNoCall;
+    TOXAV_ERR_SEND_FRAME rc = TOXAV_ERR_SEND_FRAME_OK;
+    ToxAVCall *call;
+
+    if (m_friend_exists(av->m, friend_number) == 0) {
+        rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_FOUND;
+        goto END;
     }
 
+    if (pthread_mutex_trylock(av->mutex) != 0) {
+        rc = TOXAV_ERR_SEND_FRAME_SYNC;
+        goto END;
+    }
 
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex);
+    call = call_get(av, friend_number);
 
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
+    if (call == NULL || !call->active || call->msi_call->state != msi_CallActive) {
+        pthread_mutex_unlock(av->mutex);
+        rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL;
+        goto END;
     }
 
-    if (!(call->cs->capabilities & cs_VideoEncoding)) {
-        pthread_mutex_unlock(call->mutex);
-        LOGGER_WARNING("Call doesn't support encoding video: %d", call_index);
-        return av_ErrorInvalidState;
+    if (call->video_bit_rate == 0 ||
+            !(call->msi_call->self_capabilities & msi_CapSVideo) ||
+            !(call->msi_call->peer_capabilities & msi_CapRVideo)) {
+        pthread_mutex_unlock(av->mutex);
+        rc = TOXAV_ERR_SEND_FRAME_PAYLOAD_TYPE_DISABLED;
+        goto END;
     }
 
-    if (cs_set_video_encoder_resolution(call->cs, input->w, input->h) < 0) {
-        pthread_mutex_unlock(call->mutex);
-        return av_ErrorSettingVideoResolution;
+    pthread_mutex_lock(call->mutex_video);
+    pthread_mutex_unlock(av->mutex);
+
+    if (y == NULL || u == NULL || v == NULL) {
+        pthread_mutex_unlock(call->mutex_video);
+        rc = TOXAV_ERR_SEND_FRAME_NULL;
+        goto END;
     }
 
-    pthread_mutex_lock(call->mutex_encoding_video);
-    pthread_mutex_unlock(call->mutex);
+    if (vc_reconfigure_encoder(call->video.second, call->video_bit_rate * 1000, width, height) != 0) {
+        pthread_mutex_unlock(call->mutex_video);
+        rc = TOXAV_ERR_SEND_FRAME_INVALID;
+        goto END;
+    }
+
+    { /* Encode */
+        vpx_image_t img;
+        img.w = img.h = img.d_w = img.d_h = 0;
+        vpx_img_alloc(&img, VPX_IMG_FMT_I420, width, height, 0);
+
+        /* I420 "It comprises an NxM Y plane followed by (N/2)x(M/2) V and U planes."
+         * http://fourcc.org/yuv.php#IYUV
+         */
+        memcpy(img.planes[VPX_PLANE_Y], y, width * height);
+        memcpy(img.planes[VPX_PLANE_U], u, (width / 2) * (height / 2));
+        memcpy(img.planes[VPX_PLANE_V], v, (width / 2) * (height / 2));
 
-    int rc = vpx_codec_encode(&call->cs->v_encoder, input, call->cs->frame_counter, 1, 0, MAX_ENCODE_TIME_US);
+        int vrc = vpx_codec_encode(call->video.second->encoder, &img,
+                                   call->video.second->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;
+        vpx_img_free(&img);
+
+        if (vrc != VPX_CODEC_OK) {
+            pthread_mutex_unlock(call->mutex_video);
+            LOGGER_ERROR("Could not encode video frame: %s\n", vpx_codec_err_to_string(vrc));
+            rc = TOXAV_ERR_SEND_FRAME_INVALID;
+            goto END;
+        }
     }
 
-    ++call->cs->frame_counter;
+    ++call->video.second->frame_counter;
 
-    vpx_codec_iter_t iter = NULL;
-    const vpx_codec_cx_pkt_t *pkt;
-    int copied = 0;
+    { /* Send frames */
+        vpx_codec_iter_t iter = NULL;
+        const vpx_codec_cx_pkt_t *pkt;
 
-    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;
-            }
+        while ((pkt = vpx_codec_get_cx_data(call->video.second->encoder, &iter))) {
+            if (pkt->kind == VPX_CODEC_CX_FRAME_PKT &&
+                    rtp_send_data(call->video.first, pkt->data.frame.buf, pkt->data.frame.sz) < 0) {
 
-            memcpy(dest + copied, pkt->data.frame.buf, pkt->data.frame.sz);
-            copied += pkt->data.frame.sz;
+                pthread_mutex_unlock(call->mutex_video);
+                LOGGER_WARNING("Could not send video frame: %s\n", strerror(errno));
+                rc = TOXAV_ERR_SEND_FRAME_RTP_FAILED;
+                goto END;
+            }
         }
     }
 
-    pthread_mutex_unlock(call->mutex_encoding_video);
-    return copied;
+    pthread_mutex_unlock(call->mutex_video);
+
+END:
+
+    if (error)
+        *error = rc;
+
+    return rc == TOXAV_ERR_SEND_FRAME_OK;
+}
+void toxav_callback_audio_receive_frame(ToxAV *av, toxav_audio_receive_frame_cb *function, void *user_data)
+{
+    pthread_mutex_lock(av->mutex);
+    av->acb.first = function;
+    av->acb.second = user_data;
+    pthread_mutex_unlock(av->mutex);
+}
+void toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb *function, void *user_data)
+{
+    pthread_mutex_lock(av->mutex);
+    av->vcb.first = function;
+    av->vcb.second = user_data;
+    pthread_mutex_unlock(av->mutex);
 }
 
-int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, unsigned int frame_size)
+
+/*******************************************************************************
+ *
+ * :: Internal
+ *
+ ******************************************************************************/
+void callback_bwc(BWControler *bwc, uint32_t friend_number, float loss, void *user_data)
 {
+    /* Callback which is called when the internal measure mechanism reported packet loss.
+     * We report suggested lowered bitrate to an app. If app is sending both audio and video,
+     * we will report lowered bitrate for video only because in that case video probably
+     * takes more than 90% bandwidth. Otherwise, we report lowered bitrate on audio.
+     * The application may choose to disable video totally if the stream is too bad.
+     */
 
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return av_ErrorNoCall;
-    }
+    ToxAVCall *call = user_data;
+    assert(call);
 
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex);
+    LOGGER_DEBUG("Reported loss of %f%%", loss * 100);
 
+    if (loss < .01f)
+        return;
 
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
+    pthread_mutex_lock(call->av->mutex);
+
+    if (!call->av->bcb.first) {
+        pthread_mutex_unlock(call->av->mutex);
+        LOGGER_WARNING("No callback to report loss on");
+        return;
     }
 
-    int rc = toxav_send_rtp_payload(av, call, av_TypeVideo, frame, frame_size);
-    pthread_mutex_unlock(call->mutex);
+    if (call->video_bit_rate)
+        (*call->av->bcb.first) (call->av, friend_number, call->audio_bit_rate,
+                                call->video_bit_rate - (call->video_bit_rate * loss),
+                                call->av->bcb.second);
+    else if (call->audio_bit_rate)
+        (*call->av->bcb.first) (call->av, friend_number,
+                                call->audio_bit_rate - (call->audio_bit_rate * loss),
+                                0, call->av->bcb.second);
 
-    return rc;
+    pthread_mutex_unlock(call->av->mutex);
 }
-
-int toxav_prepare_audio_frame ( ToxAv *av,
-                                int32_t call_index,
-                                uint8_t *dest,
-                                int dest_max,
-                                const int16_t *frame,
-                                int frame_size)
+int callback_invite(void *toxav_inst, MSICall *call)
 {
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Action on nonexisting call: %d", call_index);
-        return av_ErrorNoCall;
-    }
+    ToxAV *toxav = toxav_inst;
+    pthread_mutex_lock(toxav->mutex);
 
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex);
+    ToxAVCall *av_call = call_new(toxav, call->friend_number, NULL);
 
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
+    if (av_call == NULL) {
+        LOGGER_WARNING("Failed to initialize call...");
+        pthread_mutex_unlock(toxav->mutex);
+        return -1;
     }
 
-    pthread_mutex_lock(call->mutex_encoding_audio);
-    pthread_mutex_unlock(call->mutex);
-    int32_t rc = opus_encode(call->cs->audio_encoder, frame, frame_size, dest, dest_max);
-    pthread_mutex_unlock(call->mutex_encoding_audio);
+    call->av_call = av_call;
+    av_call->msi_call = call;
 
-    if (rc < 0) {
-        LOGGER_ERROR("Failed to encode payload: %s\n", opus_strerror(rc));
-        return av_ErrorEncodingAudio;
+    if (toxav->ccb.first)
+        toxav->ccb.first(toxav, call->friend_number, call->peer_capabilities & msi_CapSAudio,
+                         call->peer_capabilities & msi_CapSVideo, toxav->ccb.second);
+    else {
+        /* No handler to capture the call request, send failure */
+        pthread_mutex_unlock(toxav->mutex);
+        return -1;
     }
 
-    return rc;
+    pthread_mutex_unlock(toxav->mutex);
+    return 0;
 }
-
-int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *data, unsigned int size)
+int callback_start(void *toxav_inst, MSICall *call)
 {
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Action on nonexisting call: %d", call_index);
-        return av_ErrorNoCall;
-    }
+    ToxAV *toxav = toxav_inst;
+    pthread_mutex_lock(toxav->mutex);
 
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex);
+    ToxAVCall *av_call = call_get(toxav, call->friend_number);
 
+    if (av_call == NULL) {
+        /* Should this ever happen? */
+        pthread_mutex_unlock(toxav->mutex);
+        return -1;
+    }
 
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
+    if (!call_prepare_transmission(av_call)) {
+        callback_error(toxav_inst, call);
+        pthread_mutex_unlock(toxav->mutex);
+        return -1;
     }
 
-    int rc = toxav_send_rtp_payload(av, call, av_TypeAudio, data, size);
-    pthread_mutex_unlock(call->mutex);
-    return rc;
-}
+    if (!invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities)) {
+        callback_error(toxav_inst, call);
+        pthread_mutex_unlock(toxav->mutex);
+        return -1;
+    }
 
-int toxav_get_peer_csettings ( ToxAv *av, int32_t call_index, int peer, ToxAvCSettings *dest )
+    pthread_mutex_unlock(toxav->mutex);
+    return 0;
+}
+int callback_end(void *toxav_inst, MSICall *call)
 {
-    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;
+    ToxAV *toxav = toxav_inst;
+    pthread_mutex_lock(toxav->mutex);
 
-    *dest = *toxavcsettings_cast(&av->msi_session->calls[call_index]->csettings_peer[peer]);
-    return av_ErrorNone;
-}
+    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_FINISHED);
 
-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;
+    if (call->av_call) {
+        call_kill_transmission(call->av_call);
+        call_remove(call->av_call);
+    }
 
-    return av->msi_session->calls[call_index]->peers[peer];
+    pthread_mutex_unlock(toxav->mutex);
+    return 0;
 }
-
-ToxAvCallState toxav_get_call_state(ToxAv *av, int32_t call_index)
+int callback_error(void *toxav_inst, MSICall *call)
 {
-    if ( CALL_INVALID_INDEX(call_index, av->msi_session->max_calls) || !av->msi_session->calls[call_index] )
-        return av_CallNonExistent;
+    ToxAV *toxav = toxav_inst;
+    pthread_mutex_lock(toxav->mutex);
 
-    return av->msi_session->calls[call_index]->state;
+    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_ERROR);
 
+    if (call->av_call) {
+        call_kill_transmission(call->av_call);
+        call_remove(call->av_call);
+    }
+
+    pthread_mutex_unlock(toxav->mutex);
+    return 0;
 }
+int callback_capabilites(void *toxav_inst, MSICall *call)
+{
+    ToxAV *toxav = toxav_inst;
+    pthread_mutex_lock(toxav->mutex);
 
-int toxav_capability_supported ( ToxAv *av, int32_t call_index, ToxAvCapabilities capability )
+    if (call->peer_capabilities & msi_CapSAudio)
+        rtp_allow_receiving(((ToxAVCall *)call->av_call)->audio.first);
+    else
+        rtp_stop_receiving(((ToxAVCall *)call->av_call)->audio.first);
+
+    if (call->peer_capabilities & msi_CapSVideo)
+        rtp_allow_receiving(((ToxAVCall *)call->av_call)->video.first);
+    else
+        rtp_stop_receiving(((ToxAVCall *)call->av_call)->video.first);
+
+    invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities);
+
+    pthread_mutex_unlock(toxav->mutex);
+    return 0;
+}
+bool audio_bit_rate_invalid(uint32_t bit_rate)
 {
-    return av->calls[call_index].cs ? av->calls[call_index].cs->capabilities & (CSCapabilities) capability : 0;
-    /* 0 is error here */
+    /* Opus RFC 6716 section-2.1.1 dictates the following:
+     * Opus supports all bit rates from 6 kbit/s to 510 kbit/s.
+     */
+    return bit_rate < 6 || bit_rate > 510;
 }
-
-Tox *toxav_get_tox(ToxAv *av)
+bool video_bit_rate_invalid(uint32_t bit_rate)
 {
-    return (Tox *)av->messenger;
+    (void) bit_rate;
+    /* TODO: If anyone knows the answer to this one please fill it up */
+    return false;
 }
+bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state)
+{
+    if (av->scb.first)
+        av->scb.first(av, friend_number, state, av->scb.second);
+    else
+        return false;
 
-int toxav_get_active_count(ToxAv *av)
+    return true;
+}
+ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, TOXAV_ERR_CALL *error)
 {
-    if (!av) return -1;
+    /* Assumes mutex locked */
+    TOXAV_ERR_CALL rc = TOXAV_ERR_CALL_OK;
+    ToxAVCall *call = NULL;
 
-    int rc = 0, i = 0;
+    if (m_friend_exists(av->m, friend_number) == 0) {
+        rc = TOXAV_ERR_CALL_FRIEND_NOT_FOUND;
+        goto END;
+    }
 
-    for (; i < av->max_calls; i++) {
-        pthread_mutex_lock(av->calls[i].mutex);
+    if (m_get_friend_connectionstatus(av->m, friend_number) < 1) {
+        rc = TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED;
+        goto END;
+    }
+
+    if (call_get(av, friend_number) != NULL) {
+        rc = TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL;
+        goto END;
+    }
 
-        if (av->calls[i].active) rc++;
 
-        pthread_mutex_unlock(av->calls[i].mutex);
+    call = calloc(sizeof(ToxAVCall), 1);
+
+    if (call == NULL) {
+        rc = TOXAV_ERR_CALL_MALLOC;
+        goto END;
     }
 
-    return rc;
-}
+    call->av = av;
+    call->friend_number = friend_number;
 
-/* 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);
-}
+    if (av->calls == NULL) { /* Creating */
+        av->calls = calloc (sizeof(ToxAVCall *), friend_number + 1);
 
-/* 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)
+        if (av->calls == NULL) {
+            free(call);
+            call = NULL;
+            rc = TOXAV_ERR_CALL_MALLOC;
+            goto END;
+        }
+
+        av->calls_tail = av->calls_head = friend_number;
+
+    } else if (av->calls_tail < friend_number) { /* Appending */
+        void *tmp = realloc(av->calls, sizeof(ToxAVCall *) * (friend_number + 1));
+
+        if (tmp == NULL) {
+            free(call);
+            call = NULL;
+            rc = TOXAV_ERR_CALL_MALLOC;
+            goto END;
+        }
+
+        av->calls = tmp;
+
+        /* Set fields in between to null */
+        uint32_t i = av->calls_tail + 1;
+
+        for (; i < friend_number; i ++)
+            av->calls[i] = NULL;
+
+        call->prev = av->calls[av->calls_tail];
+        av->calls[av->calls_tail]->next = call;
+
+        av->calls_tail = friend_number;
+
+    } else if (av->calls_head > friend_number) { /* Inserting at front */
+        call->next = av->calls[av->calls_head];
+        av->calls[av->calls_head]->prev = call;
+        av->calls_head = friend_number;
+    }
+
+    av->calls[friend_number] = call;
+
+END:
+
+    if (error)
+        *error = rc;
+
+    return call;
+}
+ToxAVCall *call_get(ToxAV *av, uint32_t friend_number)
 {
-    Messenger *m = tox;
-    return join_av_groupchat(m->group_chat_object, friendnumber, data, length, audio_callback, userdata);
+    /* Assumes mutex locked */
+    if (av->calls == NULL || av->calls_tail < friend_number)
+        return NULL;
+
+    return av->calls[friend_number];
 }
+ToxAVCall *call_remove(ToxAVCall *call)
+{
+    if (call == NULL)
+        return NULL;
 
-/* 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)
+    uint32_t friend_number = call->friend_number;
+    ToxAV *av = call->av;
+
+    ToxAVCall *prev = call->prev;
+    ToxAVCall *next = call->next;
+
+    /* Set av call in msi to NULL in order to know if call if ToxAVCall is
+     * removed from the msi call.
+     */
+    if (call->msi_call) {
+        call->msi_call->av_call = NULL;
+    }
+
+    free(call);
+
+    if (prev)
+        prev->next = next;
+    else if (next)
+        av->calls_head = next->friend_number;
+    else goto CLEAR;
+
+    if (next)
+        next->prev = prev;
+    else if (prev)
+        av->calls_tail = prev->friend_number;
+    else goto CLEAR;
+
+    av->calls[friend_number] = NULL;
+    return next;
+
+CLEAR:
+    av->calls_head = av->calls_tail = 0;
+    free(av->calls);
+    av->calls = NULL;
+
+    return NULL;
+}
+bool call_prepare_transmission(ToxAVCall *call)
 {
-    Messenger *m = tox;
-    return group_send_audio(m->group_chat_object, groupnumber, pcm, samples, channels, sample_rate);
+    /* Assumes mutex locked */
+
+    if (call == NULL)
+        return false;
+
+    ToxAV *av = call->av;
+
+    if (!av->acb.first && !av->vcb.first)
+        /* It makes no sense to have CSession without callbacks */
+        return false;
+
+    if (call->active) {
+        LOGGER_WARNING("Call already active!\n");
+        return true;
+    }
+
+    if (create_recursive_mutex(call->mutex_audio) != 0)
+        return false;
+
+    if (create_recursive_mutex(call->mutex_video) != 0)
+        goto FAILURE_3;
+
+    if (create_recursive_mutex(call->mutex) != 0)
+        goto FAILURE_2;
+
+    /* Prepare bwc */
+    call->bwc = bwc_new(av->m, call->friend_number, callback_bwc, call);
+
+    { /* Prepare audio */
+        call->audio.second = ac_new(av, call->friend_number, av->acb.first, av->acb.second);
+
+        if (!call->audio.second) {
+            LOGGER_ERROR("Failed to create audio codec session");
+            goto FAILURE;
+        }
+
+        call->audio.first = rtp_new(rtp_TypeAudio, av->m, call->friend_number, call->bwc,
+                                    call->audio.second, ac_queue_message);
+
+        if (!call->audio.first) {
+            LOGGER_ERROR("Failed to create audio rtp session");;
+            goto FAILURE;
+        }
+    }
+    { /* Prepare video */
+        call->video.second = vc_new(av, call->friend_number, av->vcb.first, av->vcb.second);
+
+        if (!call->video.second) {
+            LOGGER_ERROR("Failed to create video codec session");
+            goto FAILURE;
+        }
+
+        call->video.first = rtp_new(rtp_TypeVideo, av->m, call->friend_number, call->bwc,
+                                    call->video.second, vc_queue_message);
+
+        if (!call->video.first) {
+            LOGGER_ERROR("Failed to create video rtp session");
+            goto FAILURE;
+        }
+    }
+
+    call->active = 1;
+    return true;
+
+FAILURE:
+    bwc_kill(call->bwc);
+    rtp_kill(call->audio.first);
+    ac_kill(call->audio.second);
+    call->audio.first = NULL;
+    call->audio.second = NULL;
+    rtp_kill(call->video.first);
+    vc_kill(call->video.second);
+    call->video.first = NULL;
+    call->video.second = NULL;
+    pthread_mutex_destroy(call->mutex);
+FAILURE_2:
+    pthread_mutex_destroy(call->mutex_video);
+FAILURE_3:
+    pthread_mutex_destroy(call->mutex_audio);
+    return false;
 }
+void call_kill_transmission(ToxAVCall *call)
+{
+    if (call == NULL || call->active == 0)
+        return;
 
+    call->active = 0;
+
+    pthread_mutex_lock(call->mutex_audio);
+    pthread_mutex_unlock(call->mutex_audio);
+    pthread_mutex_lock(call->mutex_video);
+    pthread_mutex_unlock(call->mutex_video);
+    pthread_mutex_lock(call->mutex);
+    pthread_mutex_unlock(call->mutex);
+
+    bwc_kill(call->bwc);
+
+    rtp_kill(call->audio.first);
+    ac_kill(call->audio.second);
+    call->audio.first = NULL;
+    call->audio.second = NULL;
+
+    rtp_kill(call->video.first);
+    vc_kill(call->video.second);
+    call->video.first = NULL;
+    call->video.second = NULL;
+
+    pthread_mutex_destroy(call->mutex_audio);
+    pthread_mutex_destroy(call->mutex_video);
+    pthread_mutex_destroy(call->mutex);
+}