Current progress

1 files changed, 710 insertions, 0 deletions

diff --git a/toxav/toxav_new.c b/toxav/toxav_new.c
new file mode 100644
index 00000000..d6c1872c
--- /dev/null
+++ b/toxav/toxav_new.c
@@ -0,0 +1,710 @@
+/**  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 */
+
+#include "toxav_new.h"
+#include "msi.h" /* Includes codec.h and rtp.h */
+
+#include "../toxcore/Messenger.h"
+#include "../toxcore/logger.h"
+#include "../toxcore/util.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+enum {
+    audio_index,
+    video_index,
+};
+
+typedef struct iToxAVCall
+{
+    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 *rtps[2]; /** Audio is first and video is second */
+    CSSession *cs;
+    bool active;
+    int32_t friend_number;
+    int32_t call_idx; /* FIXME msi compat, remove */
+    
+    struct iToxAVCall *prev;
+    struct iToxAVCall *next;
+} IToxAVCall;
+
+struct toxAV
+{
+    Messenger* m;
+    MSISession* msi;
+    
+    /* Two-way storage: first is array of calls and second is list of calls with head and tail */
+    IToxAVCall** calls;
+    uint32_t calls_tail;
+    uint32_t calls_head;
+    
+    PAIR(toxav_call_cb *, void*) ccb; /* Call callback */
+    PAIR(toxav_call_state_cb *, void *) scb; /* Call state callback */
+    PAIR(toxav_receive_audio_frame_cb *, void *) acb; /* Audio frame receive callback */
+    PAIR(toxav_receive_video_frame_cb *, void *) vcb; /* Video frame receive callback */
+    
+    /** Decode time measures */
+    int32_t dmssc; /** Measure count */
+    int32_t dmsst; /** Last cycle total */
+    int32_t dmssa; /** Average decoding time in ms */
+};
+
+
+void i_toxav_msi_callback_invite(void* toxav_inst, int32_t call_idx, void *data);
+void i_toxav_msi_callback_ringing(void* toxav_inst, int32_t call_idx, void *data);
+void i_toxav_msi_callback_start(void* toxav_inst, int32_t call_idx, void *data);
+void i_toxav_msi_callback_cancel(void* toxav_inst, int32_t call_idx, void *data);
+void i_toxav_msi_callback_reject(void* toxav_inst, int32_t call_idx, void *data);
+void i_toxav_msi_callback_end(void* toxav_inst, int32_t call_idx, void *data);
+void i_toxav_msi_callback_request_to(void* toxav_inst, int32_t call_idx, void *data); /* TODO remove */
+void i_toxav_msi_callback_peer_to(void* toxav_inst, int32_t call_idx, void *data);
+void i_toxav_msi_callback_state_change(void* toxav_inst, int32_t call_idx, void *data);
+
+IToxAVCall* i_toxav_get_call(ToxAV* av, uint32_t friend_number);
+IToxAVCall* i_toxav_add_call(ToxAV* av, uint32_t friend_number);
+void i_toxav_remove_call(ToxAV* av, uint32_t friend_number);
+bool i_toxav_audio_bitrate_invalid(uint32_t bitrate);
+bool i_toxav_video_bitrate_invalid(uint32_t bitrate);
+IToxAVCall* i_toxav_init_call(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL* error);
+bool i_toxav_prepare_transmission(ToxAV* av, IToxAVCall* call);
+void i_toxav_kill_transmission(ToxAV* av, IToxAVCall* call);
+
+
+
+ToxAV* toxav_new(Tox* tox, TOXAV_ERR_NEW* error)
+{
+    TOXAV_ERR_NEW rc = TOXAV_ERR_NEW_OK;
+    ToxAV *av = NULL;
+    
+    if (tox == NULL) {
+        rc = TOXAV_ERR_NEW_NULL;
+        goto FAILURE;
+    }
+    
+    if (((Messenger*)tox)->msi_packet) {
+        rc = TOXAV_ERR_NEW_MULTIPLE;
+        goto FAILURE;
+    }
+    
+    av = calloc ( sizeof(ToxAV), 1);
+    
+    if (av == NULL) {
+        LOGGER_WARNING("Allocation failed!");
+        rc = TOXAV_ERR_NEW_MALLOC;
+        goto FAILURE;
+    }
+    
+    av->m = (Messenger *)tox;
+    av->msi = msi_new(av->m, 100); /* TODO remove max calls */
+    
+    if (av->msi == NULL) {
+        rc = TOXAV_ERR_NEW_MALLOC;
+        goto FAILURE;
+    }
+    
+    av->msi->agent_handler = av;
+    
+    msi_register_callback(av->msi, i_toxav_msi_callback_invite, msi_OnInvite, NULL);
+    msi_register_callback(av->msi, i_toxav_msi_callback_ringing, msi_OnRinging, NULL);
+    msi_register_callback(av->msi, i_toxav_msi_callback_start, msi_OnStart, NULL);
+    msi_register_callback(av->msi, i_toxav_msi_callback_cancel, msi_OnCancel, NULL);
+    msi_register_callback(av->msi, i_toxav_msi_callback_reject, msi_OnReject, NULL);
+    msi_register_callback(av->msi, i_toxav_msi_callback_end, msi_OnEnd, NULL);
+    msi_register_callback(av->msi, i_toxav_msi_callback_request_to, msi_OnRequestTimeout, NULL);
+    msi_register_callback(av->msi, i_toxav_msi_callback_peer_to, msi_OnPeerTimeout, NULL);
+    msi_register_callback(av->msi, i_toxav_msi_callback_state_change, msi_OnPeerCSChange, NULL);
+    msi_register_callback(av->msi, i_toxav_msi_callback_state_change, msi_OnSelfCSChange, NULL);
+    
+    
+    if (error) 
+        *error = rc;
+    
+    return av;
+    
+FAILURE:
+    if (error) 
+        *error = rc;
+    
+    free(av);
+    
+    return NULL;
+}
+
+void toxav_kill(ToxAV* av)
+{
+    if (av == NULL)
+        return;
+    
+    msi_kill(av->msi);
+    /* TODO iterate over calls */
+    free(av);
+}
+
+Tox* toxav_get_tox(ToxAV* av)
+{
+    return (Tox*) av->m;
+}
+
+uint32_t toxav_iteration_interval(const ToxAV* av)
+{
+
+}
+
+void toxav_iteration(ToxAV* av)
+{
+
+}
+
+bool toxav_call(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL* error)
+{
+    IToxAVCall* call = i_toxav_init_call(av, friend_number, audio_bit_rate, video_bit_rate, error);
+    if (call == NULL) {
+        return false;
+    }
+    
+    /* TODO remove csettings */
+    MSICSettings csets;
+    csets.audio_bitrate = audio_bit_rate;
+    csets.video_bitrate = video_bit_rate;
+    
+    csets.call_type = video_bit_rate ? msi_TypeVideo : msi_TypeAudio;
+    
+    if (msi_invite(av->msi, &call->call_idx, &csets, 1000, friend_number) != 0) {
+        i_toxav_remove_call(av, friend_number);
+        if (error)
+            *error = TOXAV_ERR_CALL_MALLOC; /* FIXME: this should be the only reason to fail */
+        return false;
+    }
+    
+    return true;
+}
+
+void toxav_callback_call(ToxAV* av, toxav_call_cb* function, void* user_data)
+{
+    av->ccb.first = function;
+    av->ccb.second = user_data;
+}
+
+bool toxav_answer(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_ANSWER* error)
+{
+    TOXAV_ERR_ANSWER rc = TOXAV_ERR_ANSWER_OK;
+    if (m_friend_exists(av->m, friend_number)) {
+        rc = TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND;
+        goto END;
+    }
+    
+    if ((audio_bit_rate && i_toxav_audio_bitrate_invalid(audio_bit_rate))
+      ||(video_bit_rate && i_toxav_video_bitrate_invalid(video_bit_rate))
+    ) {
+        rc = TOXAV_ERR_CALL_INVALID_BIT_RATE;
+        goto END;
+    }
+    
+    IToxAVCall* call = i_toxav_get_call(av, friend_number);
+    if (call == NULL || av->msi->calls[call->call_idx]->state != msi_CallRequested) {
+        rc = TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING;
+        goto END;
+    }
+    
+    /* TODO remove csettings */
+    MSICSettings csets;
+    csets.audio_bitrate = audio_bit_rate;
+    csets.video_bitrate = video_bit_rate;
+    
+    csets.call_type = video_bit_rate ? msi_TypeVideo : msi_TypeAudio;
+    
+    if (msi_answer(av->msi, call->call_idx, &csets) != 0) {
+        rc = TOXAV_ERR_ANSWER_MALLOC; /* TODO Some error here */
+        /* TODO Reject call? */
+    }
+    
+END:
+    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)
+{
+    av->scb.first = function;
+    av->scb.second = user_data;
+}
+
+bool toxav_call_control(ToxAV* av, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL* error)
+{
+
+}
+
+bool toxav_set_audio_bit_rate(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, TOXAV_ERR_BIT_RATE* error)
+{
+
+}
+
+bool toxav_set_video_bit_rate(ToxAV* av, uint32_t friend_number, uint32_t video_bit_rate, TOXAV_ERR_BIT_RATE* error)
+{
+
+}
+
+void toxav_callback_request_video_frame(ToxAV* av, toxav_request_video_frame_cb* function, void* user_data)
+{
+
+}
+
+bool toxav_send_video_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, const uint8_t* a, TOXAV_ERR_SEND_FRAME* error)
+{
+
+}
+
+void toxav_callback_request_audio_frame(ToxAV* av, toxav_request_audio_frame_cb* function, void* user_data)
+{
+
+}
+
+bool toxav_send_audio_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)
+{
+
+}
+
+void toxav_callback_receive_video_frame(ToxAV* av, toxav_receive_video_frame_cb* function, void* user_data)
+{
+
+}
+
+void toxav_callback_receive_audio_frame(ToxAV* av, toxav_receive_audio_frame_cb* function, void* user_data)
+{
+
+}
+
+
+/*******************************************************************************
+ * 
+ * :: Internal
+ *
+ ******************************************************************************/
+/** TODO: 
+ * - In msi call_idx can be the same as friend id 
+ * - If crutial callback not present send error
+ * - Remove *data from msi
+ * - Remove CSettings from msi
+ */
+void i_toxav_msi_callback_invite(void* toxav_inst, int32_t call_idx, void* data)
+{
+    ToxAV* toxav = toxav_inst;
+    
+    uint32_t ab = toxav->msi->calls[call_idx]->csettings_peer[0].audio_bitrate;
+    uint32_t vb = toxav->msi->calls[call_idx]->csettings_peer[0].video_bitrate;
+    
+    IToxAVCall* call = i_toxav_init_call(toxav, toxav->msi->calls[call_idx]->peers[0], ab, vb, NULL);
+    if (call == NULL) {
+        msi_reject(toxav->msi, call_idx, NULL);
+        return false;
+    }
+    
+    call->call_idx = call_idx;
+    
+    if (toxav->ccb.first)
+        toxav->ccb.first(toxav, toxav->msi->calls[call_idx]->peers[0], true, true, toxav->ccb.second);
+}
+
+void i_toxav_msi_callback_ringing(void* toxav_inst, int32_t call_idx, void* data)
+{
+    ToxAV* toxav = toxav_inst;
+    if (toxav->scb.first)
+        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
+                         TOXAV_CALL_STATE_RINGING, toxav->scb.second);
+}
+
+void i_toxav_msi_callback_start(void* toxav_inst, int32_t call_idx, void* data)
+{
+    ToxAV* toxav = toxav_inst;
+    
+    IToxAVCall* call = i_toxav_get_call(toxav, toxav->msi->calls[call_idx]->peers[0]);
+    
+    if (call == NULL || !i_toxav_prepare_transmission(toxav, call)) {
+        /* TODO send error */
+        i_toxav_remove_call(toxav, toxav->msi->calls[call_idx]->peers[0]);
+        return;
+    }
+    
+    TOXAV_CALL_STATE state;
+    const MSICSettings* csets = toxav->msi->calls[call_idx]->csettings_peer[0];
+    
+    if (csets->audio_bitrate && csets->video_bitrate)
+        state = TOXAV_CALL_STATE_SENDING_AV;
+    else if (csets->video_bitrate == 0)
+        state = TOXAV_CALL_STATE_SENDING_A;
+    else
+        state = TOXAV_CALL_STATE_SENDING_V;
+    
+    if (toxav->scb.first) /* TODO this */
+        toxav->scb.first(toxav, call->friend_number, state, toxav->scb.second);
+}
+
+void i_toxav_msi_callback_cancel(void* toxav_inst, int32_t call_idx, void* data)
+{
+    ToxAV* toxav = toxav_inst;
+    if (toxav->scb.first)
+        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
+                         TOXAV_CALL_STATE_END, toxav->scb.second);
+}
+
+void i_toxav_msi_callback_reject(void* toxav_inst, int32_t call_idx, void* data)
+{
+    ToxAV* toxav = toxav_inst;
+    if (toxav->scb.first)
+        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
+                         TOXAV_CALL_STATE_END, toxav->scb.second);
+}
+
+void i_toxav_msi_callback_end(void* toxav_inst, int32_t call_idx, void* data)
+{
+    ToxAV* toxav = toxav_inst;
+    if (toxav->scb.first)
+        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
+                         TOXAV_CALL_STATE_END, toxav->scb.second);
+}
+
+void i_toxav_msi_callback_request_to(void* toxav_inst, int32_t call_idx, void* data)
+{
+    /* TODO remove */
+    ToxAV* toxav = toxav_inst;
+    if (toxav->scb.first)
+        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
+                         TOXAV_CALL_STATE_ERROR, toxav->scb.second);
+}
+
+void i_toxav_msi_callback_peer_to(void* toxav_inst, int32_t call_idx, void* data)
+{
+    ToxAV* toxav = toxav_inst;
+    if (toxav->scb.first)
+        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
+                         TOXAV_CALL_STATE_ERROR, toxav->scb.second);
+}
+
+void i_toxav_msi_callback_state_change(void* toxav_inst, int32_t call_idx, void* data)
+{
+    ToxAV* toxav = toxav_inst;
+    /* TODO something something msi */
+}
+
+IToxAVCall* i_toxav_get_call(ToxAV* av, uint32_t friend_number)
+{
+    if (av->calls_tail < friend_number)
+        return NULL;
+    
+    return av->calls[friend_number];
+}
+
+IToxAVCall* i_toxav_add_call(ToxAV* av, uint32_t friend_number)
+{
+    IToxAVCall* rc = calloc(sizeof(IToxAVCall), 1);
+    
+    if (rc == NULL)
+        return NULL;
+    
+    rc->friend_number = friend_number;
+    
+    if (create_recursive_mutex(rc->mutex_control) != 0) {
+        free(rc);
+        return NULL;
+    }
+    
+    if (create_recursive_mutex(rc->mutex_do) != 0) {
+        pthread_mutex_destroy(rc->mutex_control);
+        free(rc);
+        return NULL;
+    }
+    
+    
+    if (av->calls == NULL) { /* Creating */
+        av->calls = calloc (sizeof(IToxAVCall*), friend_number + 1);
+        
+        if (av->calls == NULL) {
+            pthread_mutex_destroy(rc->mutex_control);
+            pthread_mutex_destroy(rc->mutex_do);
+            free(rc);
+            return NULL;
+        }
+        
+        av->calls_tail = av->calls_head = friend_number;
+        
+    } else if (av->calls_tail < friend_number) { /* Appending */
+        void* tmp = realloc(av->calls, sizeof(IToxAVCall*) * friend_number + 1);
+        
+        if (tmp == NULL) {
+            pthread_mutex_destroy(rc->mutex_control);
+            pthread_mutex_destroy(rc->mutex_do);
+            free(rc);
+            return NULL;
+        }
+        
+        av->calls = tmp;
+        
+        /* Set fields in between to null */
+        int32_t i = av->calls_tail;
+        for (; i < friend_number; i ++)
+            av->calls[i] = NULL;
+        
+        rc->prev = av->calls[av->calls_tail];
+        av->calls[av->calls_tail]->next = rc;
+        
+        av->calls_tail = friend_number;
+        
+    } else if (av->calls_head > friend_number) { /* Inserting at front */
+        rc->next = av->calls[av->calls_head];
+        av->calls[av->calls_head]->prev = rc;
+        av->calls_head = friend_number;
+    }
+    
+    av->calls[friend_number] = rc;
+    return rc;
+}
+
+void i_toxav_remove_call(ToxAV* av, uint32_t friend_number)
+{
+    IToxAVCall* tc = i_toxav_get_call(av, friend_number);
+    
+    if (tc == NULL)
+        return;
+    
+    IToxAVCall* prev = tc->prev;
+    IToxAVCall* next = tc->next;
+    
+    pthread_mutex_destroy(tc->mutex_control);
+    pthread_mutex_destroy(tc->mutex_do);
+    
+    free(tc);
+    
+    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;
+    
+CLEAR:
+    av->calls_head = av->calls_tail = 0;
+    free(av->calls);
+    av->calls = NULL;
+}
+
+bool i_toxav_audio_bitrate_invalid(uint32_t bitrate)
+{
+    /* Opus RFC 6716 section-2.1.1 dictates the following:
+    * Opus supports all bitrates from 6 kbit/s to 510 kbit/s.
+    */
+    return bitrate < 6 || bitrate > 510;
+}
+
+bool i_toxav_video_bitrate_invalid(uint32_t bitrate)
+{
+    /* TODO: If anyone knows the answer to this one please fill it up */
+    return false;
+}
+
+IToxAVCall* i_toxav_init_call(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL* error)
+{
+    TOXAV_ERR_CALL rc = TOXAV_ERR_CALL_OK;
+    IToxAVCall* call = NULL;
+    
+    if (m_friend_exists(av->m, friend_number)) {
+        rc = TOXAV_ERR_CALL_FRIEND_NOT_FOUND;
+        goto END;
+    }
+    
+    if (m_get_friend_connectionstatus(av->m, friend_number) != 1) {
+        rc = TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED;
+        goto END;
+    }
+    
+    if (i_toxav_get_call(av, friend_number) != NULL) {
+        rc = TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL;
+        goto END;
+    }
+    
+    if ((audio_bit_rate && i_toxav_audio_bitrate_invalid(audio_bit_rate))
+      ||(video_bit_rate && i_toxav_video_bitrate_invalid(video_bit_rate))
+    ) {
+        rc = TOXAV_ERR_CALL_INVALID_BIT_RATE;
+        goto END;
+    }
+    
+    IToxAVCall* call = i_toxav_add_call(av, friend_number);
+    if (call == NULL) {
+        rc = TOXAV_ERR_CALL_MALLOC;
+    }
+    
+END:
+    if (error)
+        *error = rc;
+    
+    return call;
+}
+
+bool i_toxav_prepare_transmission(ToxAV* av, IToxAVCall* call)
+{
+    pthread_mutex_lock(call->mutex_control);
+    
+    if (call->active) {
+        pthread_mutex_unlock(call->mutex_control);
+        LOGGER_WARNING("Call already active!\n");
+        return true;
+    }
+    
+    if (pthread_mutex_init(call->mutex_encoding_audio, NULL) != 0)
+        goto MUTEX_INIT_ERROR;
+    
+    if (pthread_mutex_init(call->mutex_encoding_video, NULL) != 0) {
+        pthread_mutex_destroy(call->mutex_encoding_audio);
+        goto MUTEX_INIT_ERROR;
+    }
+    
+    if (pthread_mutex_init(call->mutex_do, NULL) != 0) {
+        pthread_mutex_destroy(call->mutex_encoding_audio);
+        pthread_mutex_destroy(call->mutex_encoding_video);
+        goto MUTEX_INIT_ERROR;
+    }
+    
+    const MSICSettings *c_peer = &av->msi->calls[call->call_idx]->csettings_peer[0];
+    const MSICSettings *c_self = &av->msi->calls[call->call_idx]->csettings_local;
+    
+    call->cs = cs_new(c_self->audio_bitrate, c_peer->audio_bitrate, 
+                      c_self->video_bitrate, c_peer->video_bitrate);
+    
+    if ( !call->cs ) {
+        LOGGER_ERROR("Error while starting Codec State!\n");
+        goto FAILURE;
+    }
+    
+    call->cs->agent = av;
+    call->cs->call_idx = call->call_idx;
+    
+    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;
+    
+    
+    if (c_self->audio_bitrate > 0 || c_peer->audio_bitrate > 0) { /* Prepare audio rtp */
+        call->rtps[audio_index] = rtp_new(msi_TypeAudio, av->m, av->msi->calls[call->call_idx]->peers[0]);
+        
+        if ( !call->rtps[audio_index] ) {
+            LOGGER_ERROR("Error while starting audio RTP session!\n");
+            goto FAILURE;
+        }
+        
+        call->rtps[audio_index]->cs = call->cs;
+        
+        if (c_peer->audio_bitrate > 0)
+            rtp_register_for_receiving(call->rtps[audio_index]);
+    }
+    
+    if (c_self->video_bitrate > 0 || c_peer->video_bitrate > 0) { /* Prepare video rtp */
+        call->rtps[video_index] = rtp_new(msi_TypeVideo, av->m, av->msi->calls[call->call_idx]->peers[0]);
+        
+        if ( !call->rtps[video_index] ) {
+            LOGGER_ERROR("Error while starting video RTP session!\n");
+            goto FAILURE;
+        }
+        
+        call->rtps[video_index]->cs = call->cs;
+        
+        if (c_peer->video_bitrate > 0)
+            rtp_register_for_receiving(call->rtps[audio_index]);
+    }
+    
+    call->active = 1;
+    pthread_mutex_unlock(call->mutex_control);
+    return true;
+    
+FAILURE:
+    rtp_kill(call->rtps[audio_index]);
+    call->rtps[audio_index] = NULL;
+    rtp_kill(call->rtps[video_index]);
+    call->rtps[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 false;
+    
+MUTEX_INIT_ERROR:
+    pthread_mutex_unlock(call->mutex_control);
+    LOGGER_ERROR("Mutex initialization failed!\n");
+    return false;
+}
+
+void i_toxav_kill_transmission(ToxAV* av, IToxAVCall* call)
+{
+    pthread_mutex_lock(call->mutex_control);
+    
+    if (!call->active) {
+        pthread_mutex_unlock(call->mutex_control);
+        LOGGER_WARNING("Action on inactive call: %d", call->call_idx);
+        return;
+    }
+    
+    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->rtps[audio_index]);
+    call->rtps[audio_index] = NULL;
+    rtp_kill(call->rtps[video_index]);
+    call->rtps[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);
+}