7 files changed, 4387 insertions, 0 deletions

diff --git a/toxav/phone.c b/toxav/phone.c
new file mode 100755
index 00000000..b55a072c
--- /dev/null
+++ b/toxav/phone.c
@@ -0,0 +1,737 @@
+/**  phone.c
+ *
+ *   NOTE NOTE NOTE NOTE NOTE NOTE 
+ * 
+ *   This file is for testing/reference purposes only, hence
+ *   it is _poorly_ designed and it does not fully reflect the 
+ *   quaility of msi nor rtp. Although toxmsi* and toxrtp* are tested 
+ *   there is always possiblity of crashes. If crash occures, 
+ *   contact me ( mannol ) on either irc channel #tox-dev @ freenode.net:6667 
+ *   or eniz_vukovic@hotmail.com
+ * 
+ *   NOTE NOTE NOTE NOTE NOTE NOTE 
+ * 
+ *   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 _BSD_SOURCE
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "toxmsi.h"
+#include "toxrtp.h"
+#include <stdarg.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include "../toxcore/network.h"
+#include "../toxcore/event.h"
+#include "../toxcore/tox.h"
+
+/* Define client version */
+#define _USERAGENT "v.0.3.0"
+
+
+typedef struct av_friend_s {
+    int _id;
+    int _active; /* 0=false; 1=true; */
+} av_friend_t;
+
+typedef struct av_session_s {
+    MSISession* _msi;
+
+    RTPSession* _rtp_audio;
+    RTPSession* _rtp_video;
+
+    pthread_mutex_t _mutex;
+    
+    Tox* _messenger;
+    av_friend_t*  _friends;
+    int _friend_cout;
+    uint8_t _my_public_id[200];
+} av_session_t;
+
+
+void av_allocate_friend(av_session_t* _phone, int _id, int _active)
+{
+    static int _new_id = 0;
+    
+    if ( !_phone->_friends ) {
+        _phone->_friends = calloc(sizeof(av_friend_t), 1);
+        _phone->_friend_cout = 1;
+    } else{
+        _phone->_friend_cout ++;
+        _phone->_friends = realloc(_phone->_friends, sizeof(av_friend_t) * _phone->_friend_cout);
+    }
+    
+    if ( _id = -1 ) {
+        _phone->_friends->_id = _new_id;
+        _new_id ++;
+    } else _phone->_friends->_id = _id;
+    
+    _phone->_friends->_active = _active;
+}
+av_friend_t* av_get_friend(av_session_t* _phone, int _id)
+{
+    av_friend_t* _friends = _phone->_friends;
+    
+    if ( !_friends ) return NULL;
+    
+    int _it = 0;
+    for (; _it < _phone->_friend_cout; _it ++)
+        if ( _friends[_it]._id == _id ) 
+            return _friends + _it;
+    
+    return NULL;
+}
+
+
+/***************** MISC *****************/
+
+void INFO (const char* _format, ...)
+{
+    printf("\r[!] ");
+    va_list _arg;
+    va_start (_arg, _format);
+    vfprintf (stdout, _format, _arg);
+    va_end (_arg);
+    printf("\n\r >> ");
+    fflush(stdout);
+}
+
+unsigned char *hex_string_to_bin(char hex_string[])
+{
+    size_t i, len = strlen(hex_string);
+    unsigned char *val = calloc(sizeof(char), len);
+    char *pos = hex_string;
+    
+    for (i = 0; i < len; ++i, pos += 2)
+        sscanf(pos, "%2hhx", &val[i]);
+    
+    return val;
+}
+
+int getinput( char* _buff, size_t _limit, int* _len )
+{
+    if ( fgets(_buff, _limit, stdin) == NULL )
+        return -1;
+    
+    *_len = strlen(_buff) - 1;
+    
+    /* Get rid of newline */
+    _buff[*_len] = '\0';
+    
+    return 0;
+}
+
+char* trim_spaces ( char* buff )
+{
+    
+    int _i = 0, _len = strlen(buff);
+    
+    char* container = calloc(sizeof(char), _len);
+    int _ci = 0;
+    
+    for ( ; _i < _len; _i++ ) {
+        while ( _i < _len && buff[_i] == ' ' )
+            _i++;
+        
+        if ( _i < _len ){
+            container[_ci] = buff[_i];
+            _ci ++;
+        }
+    }
+    
+    memcpy( buff, container, _ci );
+    buff[_ci] = '\0';
+    free(container);
+    return buff;
+}
+
+#define FRADDR_TOSTR_CHUNK_LEN 8
+
+static void fraddr_to_str(uint8_t *id_bin, char *id_str)
+{    
+    uint i, delta = 0, pos_extra, sum_extra = 0;
+    
+    for (i = 0; i < TOX_FRIEND_ADDRESS_SIZE; i++) {
+        sprintf(&id_str[2 * i + delta], "%02hhX", id_bin[i]);
+        
+        if ((i + 1) == TOX_CLIENT_ID_SIZE)
+            pos_extra = 2 * (i + 1) + delta;
+        
+        if (i >= TOX_CLIENT_ID_SIZE)
+            sum_extra |= id_bin[i];
+        
+        if (!((i + 1) % FRADDR_TOSTR_CHUNK_LEN)) {
+            id_str[2 * (i + 1) + delta] = ' ';
+            delta++;
+        }
+    }
+    
+    id_str[2 * i + delta] = 0;
+    
+    if (!sum_extra)
+        id_str[pos_extra] = 0;
+}
+
+void* phone_handle_media_transport_poll ( void* _hmtc_args_p )
+{
+    RTPMessage* _audio_msg, * _video_msg;
+    av_session_t* _phone = _hmtc_args_p;
+    MSISession* _session = _phone->_msi;
+
+    RTPSession* _rtp_audio = _phone->_rtp_audio;
+    RTPSession* _rtp_video = _phone->_rtp_video;
+
+        
+    Tox* _messenger = _phone->_messenger;
+    
+    
+    while ( _session->call ) {
+
+        _audio_msg = rtp_recv_msg ( _rtp_audio );
+        _video_msg = rtp_recv_msg ( _rtp_video );
+
+        if ( _audio_msg ) {
+            /* Do whatever with msg
+            printf("%d - %s\n", _audio_msg->header->sequnum, _audio_msg->data);*/
+            rtp_free_msg ( _rtp_audio, _audio_msg );
+        }
+
+        if ( _video_msg ) {
+            /* Do whatever with msg
+             p rintf("%d - %s\n", _video_msg->header->sequnum, _video_msg->data);*/
+            rtp_free_msg ( _rtp_video, _video_msg );
+        }
+
+        /*
+         * Send test message to the 'remote'
+         */
+        rtp_send_msg ( _rtp_audio, _messenger, (const uint8_t*)"audio\0", 6 );
+
+        if ( _session->call->type_local == type_video ){ /* if local call send video */
+            rtp_send_msg ( _rtp_video, _messenger, (const uint8_t*)"video\0", 6 );
+        }
+
+        _audio_msg = _video_msg = NULL;
+        
+        
+        /* Send ~1k messages per second 
+         * That _should_ be enough for both Audio and Video
+         */
+        usleep ( 1000 );
+        /* -------------------- */
+    }
+    
+    if ( _audio_msg ) rtp_free_msg(_rtp_audio, _audio_msg);
+    rtp_release_session_recv(_rtp_audio);
+    rtp_terminate_session(_rtp_audio, _messenger);
+    
+    if ( _video_msg ) rtp_free_msg(_rtp_video, _video_msg);
+    rtp_release_session_recv(_rtp_video);
+    rtp_terminate_session(_rtp_video, _messenger);
+    
+    INFO("Media thread finished!");
+
+    pthread_exit ( NULL );
+}
+
+int phone_startmedia_loop ( av_session_t* _phone )
+{
+    if ( !_phone ){
+        return -1;
+    }
+
+    _phone->_rtp_audio = rtp_init_session ( 
+        type_audio,
+        _phone->_messenger, 
+        _phone->_msi->call->peers[0],
+        _phone->_msi->call->key_peer,
+        _phone->_msi->call->key_local,
+        _phone->_msi->call->nonce_peer,
+        _phone->_msi->call->nonce_local
+        );
+    
+    _phone->_rtp_audio = rtp_init_session ( 
+        type_video,
+        _phone->_messenger, 
+        _phone->_msi->call->peers[0],
+        _phone->_msi->call->key_peer,
+        _phone->_msi->call->key_local,
+        _phone->_msi->call->nonce_peer,
+        _phone->_msi->call->nonce_local
+        );
+
+
+    if ( 0 > event.rise(phone_handle_media_transport_poll, _phone) )
+    {
+        printf("Error while starting phone_handle_media_transport_poll()\n");
+        return -1;
+    }
+    else return 0;
+}
+
+
+/* Some example callbacks */
+
+void* callback_recv_invite ( void* _arg )
+{
+    const char* _call_type;
+
+    MSISession* _msi = _arg;
+
+    switch ( _msi->call->type_peer[_msi->call->peer_count - 1] ){
+    case type_audio:
+        _call_type = "audio";
+        break;
+    case type_video:
+        _call_type = "video";
+        break;
+    }
+
+    INFO( "Incoming %s call!", _call_type );
+
+}
+void* callback_recv_ringing ( void* _arg )
+{
+    INFO ( "Ringing!" );
+}
+void* callback_recv_starting ( void* _arg )
+{
+    MSISession* _session = _arg;
+    if ( 0 != phone_startmedia_loop(_session->agent_handler) ){
+        INFO("Starting call failed!");
+    } else {
+        INFO ("Call started! ( press h to hangup )");
+    }
+}
+void* callback_recv_ending ( void* _arg )
+{
+    INFO ( "Call ended!" );
+}
+
+void* callback_recv_error ( void* _arg )
+{
+    MSISession* _session = _arg;
+
+    INFO( "Error: %s", _session->last_error_str );
+}
+
+void* callback_call_started ( void* _arg )
+{
+    MSISession* _session = _arg;
+    if ( 0 != phone_startmedia_loop(_session->agent_handler) ){
+        INFO("Starting call failed!");
+    } else {
+        INFO ("Call started! ( press h to hangup )");
+    }
+
+}
+void* callback_call_canceled ( void* _arg )
+{
+    INFO ( "Call canceled!" );
+}
+void* callback_call_rejected ( void* _arg )
+{
+    INFO ( "Call rejected!" );
+}
+void* callback_call_ended ( void* _arg )
+{
+    INFO ( "Call ended!" );
+}
+
+void* callback_requ_timeout ( void* _arg )
+{
+    INFO( "No answer! " );
+}
+
+int av_connect_to_dht(av_session_t* _phone, char* _dht_key, const char* _dht_addr, unsigned short _dht_port)
+{
+    unsigned char *_binary_string = hex_string_to_bin(_dht_key);
+       
+    uint16_t _port = htons(_dht_port);
+    
+    int _if = tox_bootstrap_from_address(_phone->_messenger, _dht_addr, 1, _port, _binary_string );
+    
+    free(_binary_string);
+    
+    return _if ? 0 : -1;
+}
+
+av_session_t* av_init_session()
+{
+    av_session_t* _retu = malloc(sizeof(av_session_t));
+
+    /* Initialize our mutex */
+    pthread_mutex_init ( &_retu->_mutex, NULL );
+
+    _retu->_messenger = tox_new(1);
+    
+    if ( !_retu->_messenger ) {
+        fprintf ( stderr, "tox_new() failed!\n" );
+        return NULL;
+    }
+
+    _retu->_friends = NULL;
+    
+    _retu->_rtp_audio = NULL;
+    _retu->_rtp_video = NULL;
+    
+    uint8_t _byte_address[TOX_FRIEND_ADDRESS_SIZE];
+    tox_get_address(_retu->_messenger, _byte_address );
+    fraddr_to_str( _byte_address, _retu->_my_public_id );
+    
+    
+    /* Initialize msi */
+    _retu->_msi = msi_init_session ( _retu->_messenger, _USERAGENT );
+
+    if ( !_retu->_msi ) {
+        fprintf ( stderr, "msi_init_session() failed\n" );
+        return NULL;
+    }
+
+    _retu->_msi->agent_handler = _retu;
+
+    /* ------------------ */
+    msi_register_callback(callback_call_started, cb_onstart);
+    msi_register_callback(callback_call_canceled, cb_oncancel);
+    msi_register_callback(callback_call_rejected, cb_onreject);
+    msi_register_callback(callback_call_ended, cb_onend);
+    msi_register_callback(callback_recv_invite, cb_oninvite);
+
+    msi_register_callback(callback_recv_ringing, cb_ringing);
+    msi_register_callback(callback_recv_starting, cb_starting);
+    msi_register_callback(callback_recv_ending, cb_ending);
+
+    msi_register_callback(callback_recv_error, cb_error);
+    msi_register_callback(callback_requ_timeout, cb_timeout);
+    /* ------------------ */
+
+    return _retu;
+}
+
+int av_terminate_session(av_session_t* _phone)
+{
+    if ( _phone->_msi->call ){
+        msi_hangup(_phone->_msi); /* Hangup the phone first */
+    }
+    
+    free(_phone->_friends);
+    msi_terminate_session(_phone->_msi);
+    pthread_mutex_destroy ( &_phone->_mutex );
+    
+    Tox* _p = _phone->_messenger;
+    _phone->_messenger = NULL; usleep(100000); /* Wait for tox_pool to end */
+    tox_kill(_p);
+    
+    printf("\r[i] Quit!\n");
+    return 0;
+}
+
+/****** AV HELPER FUNCTIONS ******/
+
+/* Auto accept friend request */
+void av_friend_requ(uint8_t *_public_key, uint8_t *_data, uint16_t _length, void *_userdata)
+{
+    av_session_t* _phone = _userdata;
+    av_allocate_friend (_phone, -1, 0);
+    
+    INFO("Got friend request with message: %s", _data);
+    
+    tox_add_friend_norequest(_phone->_messenger, _public_key);
+    
+    INFO("Auto-accepted! Friend id: %d",  _phone->_friends->_id );
+}
+
+void av_friend_active(Tox *_messenger, int _friendnumber, uint8_t *_string, uint16_t _length, void *_userdata)
+{
+    av_session_t* _phone = _userdata;
+    INFO("Friend no. %d is online", _friendnumber);
+    
+    av_friend_t* _this_friend = av_get_friend(_phone, _friendnumber);
+    
+    if ( !_this_friend ) {
+        INFO("But it's not registered!");
+        return;
+    }
+    
+    (*_this_friend)._active = 1;
+}
+
+int av_add_friend(av_session_t* _phone, char* _friend_hash)
+{    
+    trim_spaces(_friend_hash);
+    
+    unsigned char *_bin_string = hex_string_to_bin(_friend_hash);
+    int _number = tox_add_friend(_phone->_messenger, _bin_string, (uint8_t *)"Tox phone "_USERAGENT, sizeof("Tox phone "_USERAGENT));
+    free(_bin_string);
+    
+    if ( _number >= 0) {
+        INFO("Added friend as %d", _number );
+        av_allocate_friend(_phone, _number, 0);
+    }
+    else
+        INFO("Unknown error %i", _number );
+    
+    return _number;
+}
+/*********************************/
+
+void do_phone ( av_session_t* _phone )
+{
+    INFO("Welcome to tox_phone version: " _USERAGENT "\n"
+         "Usage: \n"
+         "f [pubkey] (add friend)\n"
+         "c [a/v] (type) [friend] (friend id) (calls friend if online)\n"
+         "h (if call is active hang up)\n"
+         "a [a/v] (answer incoming call: a - audio / v - audio + video (audio is default))\n"
+         "r (reject incoming call)\n"
+         "q (quit)\n"
+         "================================================================================"
+         );
+
+    while ( 1 )
+    {        
+        char _line [ 1500 ];
+        int _len;
+        
+        if ( -1 == getinput(_line, 1500, &_len) ){
+            printf(" >> "); 
+            fflush(stdout);
+            continue;
+        }
+        
+        if ( _len > 1 && _line[1] != ' ' && _line[1] != '\n' ){
+            INFO("Invalid input!");
+            continue;
+        }
+
+        switch (_line[0]){
+
+        case 'f':
+        {
+            char _id [128];
+            strncpy(_id, _line + 2, 128);            
+            
+            av_add_friend(_phone, _id);
+                    
+        } break;
+        case 'c':
+        {
+            if ( _phone->_msi->call ){
+                INFO("Already in a call");
+                break;
+            }
+            
+            MSICallType _ctype;
+            
+            if ( _len < 5 ){
+                INFO("Invalid input; usage: c a/v [friend]");
+                break;
+            }
+            else if ( _line[2] == 'a' || _line[2] != 'v' ){ /* default and audio */
+                _ctype = type_audio;
+            }
+            else { /* video */
+                _ctype = type_video;
+            }
+            
+            char* _end;
+            int _friend = strtol(_line + 4, &_end, 10);
+            
+            if ( *_end ){
+                INFO("Friend num has to be numerical value");
+                break;
+            }
+            
+            /* Set timeout */
+            msi_invite ( _phone->_msi, _ctype, 10 * 1000, _friend );
+            INFO("Calling friend: %d!", _friend);
+
+        } break;
+        case 'h':
+        {
+            if ( !_phone->_msi->call ){
+                INFO("No call!");
+                break;
+            }
+
+            msi_hangup(_phone->_msi);
+
+            INFO("Hung up...");
+
+        } break;
+        case 'a':
+        {
+
+            if ( _phone->_msi->call && _phone->_msi->call->state != call_starting ) {
+                break;
+            }
+
+            if ( _len > 1 && _line[2] == 'v' )
+                msi_answer(_phone->_msi, type_video);
+            else
+                msi_answer(_phone->_msi, type_audio);
+
+        } break;
+        case 'r':
+        {
+            if ( _phone->_msi->call && _phone->_msi->call->state != call_starting ){
+                break;
+            }
+
+            msi_reject(_phone->_msi);
+
+            INFO("Call Rejected...");
+
+        } break;
+        case 'q':
+        {
+            INFO("Quitting!");
+            return;
+        }
+        default:
+        {
+            INFO("Invalid command!");
+        } break;
+
+        }
+
+    }
+}
+
+void* tox_poll (void* _messenger_p)
+{
+    Tox** _messenger = _messenger_p;
+    while( *_messenger ) { 
+        tox_do(*_messenger); 
+        usleep(10000);
+    }
+        
+    pthread_exit(NULL);
+}
+
+int av_wait_dht(av_session_t* _phone, int _wait_seconds, const char* _ip, char* _key, unsigned short _port)
+{
+    if ( !_wait_seconds )
+        return -1;
+    
+    int _waited = 0;
+    
+    while( !tox_isconnected(_phone->_messenger) ) {
+        
+        if ( -1 == av_connect_to_dht(_phone, _key, _ip, _port) )
+        {
+            INFO("Could not connect to: %s", _ip);
+            av_terminate_session(_phone);
+            return -1;
+        }
+        
+        if ( _waited >= _wait_seconds ) return 0;
+        
+        printf(".");
+        fflush(stdout);
+        
+        _waited ++;
+        usleep(1000000);
+    }
+    
+    int _r = _wait_seconds - _waited;
+    return _r ? _r : 1;
+}
+/* ---------------------- */
+
+int print_help ( const char* _name )
+{
+    printf ( "Usage: %s [IP] [PORT] [KEY]\n" 
+             "\t[IP] (DHT ip)\n"
+             "\t[PORT] (DHT port)\n"
+             "\t[KEY] (DHT public key)\n"
+             "P.S. Friends and key are stored in ./tox_phone.conf\n"
+             ,_name );
+    return 1;
+}
+
+int main ( int argc, char* argv [] )
+{
+    if ( argc < 1 || argc < 4 )
+        return print_help(argv[0]);
+    
+    char* _convertable;
+    
+    int _wait_seconds = 5;
+    
+    const char* _ip = argv[1];
+    char* _key = argv[3];
+    unsigned short _port = strtol(argv[2], &_convertable, 10);
+    
+    if ( *_convertable ){
+        printf("Invalid port: cannot convert string to long: %s", _convertable);
+        return 1;
+    }
+    
+    av_session_t* _phone = av_init_session();
+    
+    tox_callback_friend_request(_phone->_messenger, av_friend_requ, _phone);
+    tox_callback_status_message(_phone->_messenger, av_friend_active, _phone);
+
+    system("clear");
+    
+    INFO("\r================================================================================\n"
+         "[!] Trying dht@%s:%d"
+         , _ip, _port);
+    
+    /* Start tox protocol */
+    event.rise( tox_poll, &_phone->_messenger );
+    
+    /* Just clean one line */
+    printf("\r       \r");
+    fflush(stdout);
+    
+    int _r;
+    for ( _r = 0; _r == 0; _r = av_wait_dht(_phone, _wait_seconds, _ip, _key, _port) ) _wait_seconds --;
+    
+        
+    if ( -1 == _r ) {
+        INFO("Error while connecting to dht: %s:%d", _ip, _port);
+        av_terminate_session(_phone);
+        return 1;
+    }
+    
+    INFO("CONNECTED!\n"
+         "================================================================================\n"
+         "%s\n"
+         "================================================================================"
+         , _phone->_my_public_id );
+
+    
+    do_phone (_phone);
+    
+    av_terminate_session(_phone);
+    
+    return 0;
+}
diff --git a/toxav/toxmedia.c b/toxav/toxmedia.c
new file mode 100644
index 00000000..4c9f5261
--- /dev/null
+++ b/toxav/toxmedia.c
@@ -0,0 +1,825 @@
+/* AV_codec.c
+//  *
+ * Audio and video codec intitialisation, encoding/decoding and playback
+ *
+ *  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 <stdio.h>
+#include <math.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libswscale/swscale.h>
+#include <libavdevice/avdevice.h>
+#include <libavutil/opt.h>
+#include <AL/al.h>
+#include <AL/alc.h>
+#include <SDL/SDL.h>
+#include <SDL/SDL_thread.h>
+#include <pthread.h>
+#include <opus/opus.h>
+
+#include "toxmsi.h"
+#include "toxmsi_message.h"
+#include "../toxrtp/toxrtp_message.h"
+#include "../toxrtp/tests/test_helper.h"
+#include "phone.h"
+#include "toxmedia.h"
+
+SDL_Surface *screen;
+
+int display_received_frame(codec_state *cs, AVFrame *r_video_frame)
+{
+    AVPicture pict;
+    SDL_LockYUVOverlay(cs->video_picture.bmp);
+
+    pict.data[0] = cs->video_picture.bmp->pixels[0];
+    pict.data[1] = cs->video_picture.bmp->pixels[2];
+    pict.data[2] = cs->video_picture.bmp->pixels[1];
+    pict.linesize[0] = cs->video_picture.bmp->pitches[0];
+    pict.linesize[1] = cs->video_picture.bmp->pitches[2];
+    pict.linesize[2] = cs->video_picture.bmp->pitches[1];
+
+    /* Convert the image into YUV format that SDL uses */
+    sws_scale(cs->sws_SDL_r_ctx, (uint8_t const * const *)r_video_frame->data, r_video_frame->linesize, 0,
+              cs->video_decoder_ctx->height, pict.data, pict.linesize );
+
+    SDL_UnlockYUVOverlay(cs->video_picture.bmp);
+    SDL_Rect rect;
+    rect.x = 0;
+    rect.y = 0;
+    rect.w = cs->video_decoder_ctx->width;
+    rect.h = cs->video_decoder_ctx->height;
+    SDL_DisplayYUVOverlay(cs->video_picture.bmp, &rect);
+    return 1;
+}
+
+struct jitter_buffer {
+    rtp_msg_t **queue;
+    uint16_t capacity;
+    uint16_t size;
+    uint16_t front;
+    uint16_t rear;
+    uint8_t queue_ready;
+    uint16_t current_id;
+    uint32_t current_ts;
+    uint8_t id_set;
+};
+
+struct jitter_buffer *create_queue(int capacity)
+{
+    struct jitter_buffer *q;
+    q = (struct jitter_buffer *)calloc(sizeof(struct jitter_buffer),1);
+    q->queue = (rtp_msg_t **)calloc((sizeof(rtp_msg_t) * capacity),1);
+    int i = 0;
+
+    for (i = 0; i < capacity; ++i) {
+        q->queue[i] = NULL;
+    }
+
+    q->size = 0;
+    q->capacity = capacity;
+    q->front = 0;
+    q->rear = -1;
+    q->queue_ready = 0;
+    q->current_id = 0;
+    q->current_ts = 0;
+    q->id_set = 0;
+    return q;
+}
+
+/* returns 1 if 'a' has a higher sequence number than 'b' */
+uint8_t sequence_number_older(uint16_t sn_a, uint16_t sn_b, uint32_t ts_a, uint32_t ts_b)
+{
+    /* should be stable enough */
+    return (sn_a > sn_b || ts_a > ts_b);
+}
+
+/* success is 0 when there is nothing to dequeue, 1 when there's a good packet, 2 when there's a lost packet */
+rtp_msg_t *dequeue(struct jitter_buffer *q, int *success)
+{
+    if (q->size == 0 || q->queue_ready == 0) {
+        q->queue_ready = 0;
+        *success = 0;
+        return NULL;
+    }
+
+    int front = q->front;
+
+    if (q->id_set == 0) {
+        q->current_id = q->queue[front]->_header->_sequence_number;
+        q->current_ts = q->queue[front]->_header->_timestamp;
+        q->id_set = 1;
+    } else {
+        int next_id = q->queue[front]->_header->_sequence_number;
+        int next_ts = q->queue[front]->_header->_timestamp;
+
+        /* if this packet is indeed the expected packet */
+        if (next_id == (q->current_id + 1) % _MAX_SEQU_NUM) {
+            q->current_id = next_id;
+            q->current_ts = next_ts;
+        } else {
+            if (sequence_number_older(next_id, q->current_id, next_ts, q->current_ts)) {
+                printf("nextid: %d current: %d\n", next_id, q->current_id);
+                q->current_id = (q->current_id + 1) % _MAX_SEQU_NUM;
+                *success = 2; /* tell the decoder the packet is lost */
+                return NULL;
+            } else {
+                /* packet too old */
+                printf("packet too old\n");
+                *success = 0;
+                return NULL;
+            }
+        }
+    }
+
+    q->size--;
+    q->front++;
+
+    if (q->front == q->capacity)
+        q->front = 0;
+
+    *success = 1;
+    q->current_id = q->queue[front]->_header->_sequence_number;
+    q->current_ts = q->queue[front]->_header->_timestamp;
+    return q->queue[front];
+}
+
+int empty_queue(struct jitter_buffer *q)
+{
+    while (q->size > 0) {
+        q->size--;
+        /* FIXME: */
+        /* rtp_free_msg(cs->_rtp_video, q->queue[q->front]); */
+        q->front++;
+
+        if (q->front == q->capacity)
+            q->front = 0;
+    }
+
+    q->id_set = 0;
+    q->queue_ready = 0;
+    return 0;
+}
+
+int queue(struct jitter_buffer *q, rtp_msg_t *pk)
+{
+    if (q->size == q->capacity) {
+        printf("buffer full, emptying buffer...\n");
+        empty_queue(q);
+        return 0;
+    }
+
+    if (q->size > 8)
+        q->queue_ready = 1;
+
+    ++q->size;
+    ++q->rear;
+
+    if (q->rear == q->capacity)
+        q->rear = 0;
+
+    q->queue[q->rear] = pk;
+
+    int a;
+    int b;
+    int j;
+    a = q->rear;
+
+    for (j = 0; j < q->size - 1; ++j) {
+        b = a - 1;
+
+        if (b < 0)
+            b += q->capacity;
+
+        if (sequence_number_older(q->queue[b]->_header->_sequence_number, q->queue[a]->_header->_sequence_number,
+                                  q->queue[b]->_header->_timestamp, q->queue[a]->_header->_timestamp)) {
+            rtp_msg_t *temp;
+            temp = q->queue[a];
+            q->queue[a] = q->queue[b];
+            q->queue[b] = temp;
+            printf("had to swap\n");
+        } else {
+            break;
+        }
+
+        a -= 1;
+
+        if (a < 0)
+            a += q->capacity;
+    }
+
+    if (pk)
+        return 1;
+
+    return 0;
+}
+
+int init_receive_audio(codec_state *cs)
+{
+    int err = OPUS_OK;
+    cs->audio_decoder = opus_decoder_create(48000, 1, &err);
+    opus_decoder_init(cs->audio_decoder, 48000, 1);
+    printf("init audio decoder successful\n");
+    return 1;
+}
+
+int init_receive_video(codec_state *cs)
+{
+    cs->video_decoder = avcodec_find_decoder(VIDEO_CODEC);
+
+    if (!cs->video_decoder) {
+        printf("init video_decoder failed\n");
+        return 0;
+    }
+
+    cs->video_decoder_ctx = avcodec_alloc_context3(cs->video_decoder);
+
+    if (!cs->video_decoder_ctx) {
+        printf("init video_decoder_ctx failed\n");
+        return 0;
+    }
+
+    if (avcodec_open2(cs->video_decoder_ctx, cs->video_decoder, NULL) < 0) {
+        printf("opening video decoder failed\n");
+        return 0;
+    }
+
+    printf("init video decoder successful\n");
+    return 1;
+}
+
+int init_send_video(codec_state *cs)
+{
+    cs->video_input_format = av_find_input_format(VIDEO_DRIVER);
+
+    if (avformat_open_input(&cs->video_format_ctx, DEFAULT_WEBCAM, cs->video_input_format, NULL) != 0) {
+        printf("opening video_input_format failed\n");
+        return 0;
+    }
+
+    avformat_find_stream_info(cs->video_format_ctx, NULL);
+    av_dump_format(cs->video_format_ctx, 0, DEFAULT_WEBCAM, 0);
+
+    int i;
+
+    for (i = 0; i < cs->video_format_ctx->nb_streams; ++i) {
+        if (cs->video_format_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+            cs->video_stream = i;
+            break;
+        }
+    }
+
+    cs->webcam_decoder_ctx = cs->video_format_ctx->streams[cs->video_stream]->codec;
+    cs->webcam_decoder = avcodec_find_decoder(cs->webcam_decoder_ctx->codec_id);
+
+    if (cs->webcam_decoder == NULL) {
+        printf("Unsupported codec\n");
+        return 0;
+    }
+
+    if (cs->webcam_decoder_ctx == NULL) {
+        printf("init webcam_decoder_ctx failed\n");
+        return 0;
+    }
+
+    if (avcodec_open2(cs->webcam_decoder_ctx, cs->webcam_decoder, NULL) < 0) {
+        printf("opening webcam decoder failed\n");
+        return 0;
+    }
+
+    cs->video_encoder = avcodec_find_encoder(VIDEO_CODEC);
+
+    if (!cs->video_encoder) {
+        printf("init video_encoder failed\n");
+        return 0;
+    }
+
+    cs->video_encoder_ctx = avcodec_alloc_context3(cs->video_encoder);
+
+    if (!cs->video_encoder_ctx) {
+        printf("init video_encoder_ctx failed\n");
+        return 0;
+    }
+
+    cs->video_encoder_ctx->bit_rate = VIDEO_BITRATE;
+    cs->video_encoder_ctx->rc_min_rate = cs->video_encoder_ctx->rc_max_rate = cs->video_encoder_ctx->bit_rate;
+    av_opt_set_double(cs->video_encoder_ctx->priv_data, "max-intra-rate", 90, 0);
+    av_opt_set(cs->video_encoder_ctx->priv_data, "quality", "realtime", 0);
+
+    cs->video_encoder_ctx->thread_count = 4;
+    cs->video_encoder_ctx->rc_buffer_aggressivity = 0.95;
+    cs->video_encoder_ctx->rc_buffer_size = VIDEO_BITRATE * 6;
+    cs->video_encoder_ctx->profile = 3;
+    cs->video_encoder_ctx->qmax = 54;
+    cs->video_encoder_ctx->qmin = 4;
+    AVRational myrational = {1, 25};
+    cs->video_encoder_ctx->time_base = myrational;
+    cs->video_encoder_ctx->gop_size = 99999;
+    cs->video_encoder_ctx->pix_fmt = PIX_FMT_YUV420P;
+    cs->video_encoder_ctx->width = cs->webcam_decoder_ctx->width;
+    cs->video_encoder_ctx->height = cs->webcam_decoder_ctx->height;
+
+    if (avcodec_open2(cs->video_encoder_ctx, cs->video_encoder, NULL) < 0) {
+        printf("opening video encoder failed\n");
+        return 0;
+    }
+
+    printf("init video encoder successful\n");
+    return 1;
+}
+
+int init_send_audio(codec_state *cs)
+{
+    cs->support_send_audio = 0;
+
+    const ALchar *pDeviceList = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
+    int i = 0;
+    const ALchar *device_names[20];
+
+    if (pDeviceList) {
+        printf("\nAvailable Capture Devices are:\n");
+
+        while (*pDeviceList) {
+            device_names[i] = pDeviceList;
+            printf("%d) %s\n", i, device_names[i]);
+            pDeviceList += strlen(pDeviceList) + 1;
+            ++i;
+        }
+    }
+
+    printf("enter capture device number: \n");
+    char dev[2];
+    fgets(dev, sizeof(dev), stdin);
+    cs->audio_capture_device = alcCaptureOpenDevice(device_names[dev[0] - 48], AUDIO_SAMPLE_RATE, AL_FORMAT_MONO16,
+                               AUDIO_FRAME_SIZE * 4);
+
+    if (alcGetError(cs->audio_capture_device) != AL_NO_ERROR) {
+        printf("could not start capture device! %d\n", alcGetError(cs->audio_capture_device));
+        return 0;
+    }
+
+    int err = OPUS_OK;
+    cs->audio_bitrate = AUDIO_BITRATE;
+    cs->audio_encoder = opus_encoder_create(AUDIO_SAMPLE_RATE, 1, OPUS_APPLICATION_VOIP, &err);
+    err = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_BITRATE(cs->audio_bitrate));
+    err = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_COMPLEXITY(10));
+    err = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_SIGNAL(OPUS_SIGNAL_VOICE));
+
+    opus_encoder_init(cs->audio_encoder, AUDIO_SAMPLE_RATE, 1, OPUS_APPLICATION_VOIP);
+
+    int nfo;
+    err = opus_encoder_ctl(cs->audio_encoder, OPUS_GET_LOOKAHEAD(&nfo));
+    /* printf("Encoder lookahead delay : %d\n", nfo); */
+    printf("init audio encoder successful\n");
+
+    return 1;
+}
+
+int init_encoder(codec_state *cs)
+{
+    avdevice_register_all();
+    avcodec_register_all();
+    avdevice_register_all();
+    av_register_all();
+
+    pthread_mutex_init(&cs->rtp_msg_mutex_lock, NULL);
+    pthread_mutex_init(&cs->avcodec_mutex_lock, NULL);
+
+    cs->support_send_video = init_send_video(cs);
+    cs->support_send_audio = init_send_audio(cs);
+
+    cs->send_audio = 1;
+    cs->send_video = 1;
+
+    return 1;
+}
+
+int init_decoder(codec_state *cs)
+{
+    avdevice_register_all();
+    avcodec_register_all();
+    avdevice_register_all();
+    av_register_all();
+
+    cs->receive_video = 0;
+    cs->receive_audio = 0;
+
+    cs->support_receive_video = init_receive_video(cs);
+    cs->support_receive_audio = init_receive_audio(cs);
+
+    cs->receive_audio = 1;
+    cs->receive_video = 1;
+
+    return 1;
+}
+
+int video_encoder_refresh(codec_state *cs, int bps)
+{
+    if (cs->video_encoder_ctx)
+        avcodec_close(cs->video_encoder_ctx);
+
+    cs->video_encoder = avcodec_find_encoder(VIDEO_CODEC);
+
+    if (!cs->video_encoder) {
+        printf("init video_encoder failed\n");
+        return -1;
+    }
+
+    cs->video_encoder_ctx = avcodec_alloc_context3(cs->video_encoder);
+
+    if (!cs->video_encoder_ctx) {
+        printf("init video_encoder_ctx failed\n");
+        return -1;
+    }
+
+    cs->video_encoder_ctx->bit_rate = bps;
+    cs->video_encoder_ctx->rc_min_rate = cs->video_encoder_ctx->rc_max_rate = cs->video_encoder_ctx->bit_rate;
+    av_opt_set_double(cs->video_encoder_ctx->priv_data, "max-intra-rate", 90, 0);
+    av_opt_set(cs->video_encoder_ctx->priv_data, "quality", "realtime", 0);
+
+    cs->video_encoder_ctx->thread_count = 4;
+    cs->video_encoder_ctx->rc_buffer_aggressivity = 0.95;
+    cs->video_encoder_ctx->rc_buffer_size = bps * 6;
+    cs->video_encoder_ctx->profile = 0;
+    cs->video_encoder_ctx->qmax = 54;
+    cs->video_encoder_ctx->qmin = 4;
+    AVRational myrational = {1, 25};
+    cs->video_encoder_ctx->time_base = myrational;
+    cs->video_encoder_ctx->gop_size = 99999;
+    cs->video_encoder_ctx->pix_fmt = PIX_FMT_YUV420P;
+    cs->video_encoder_ctx->width = cs->webcam_decoder_ctx->width;
+    cs->video_encoder_ctx->height = cs->webcam_decoder_ctx->height;
+
+    if (avcodec_open2(cs->video_encoder_ctx, cs->video_encoder, NULL) < 0) {
+        printf("opening video encoder failed\n");
+        return -1;
+    }
+    return 0;
+}
+
+void *encode_video_thread(void *arg)
+{
+    codec_state *cs = (codec_state *)arg;
+    AVPacket pkt1, *packet = &pkt1;
+    int p = 0;
+    int err;
+    int got_packet;
+    rtp_msg_t *s_video_msg;
+    int video_frame_finished;
+    AVFrame *s_video_frame;
+    AVFrame *webcam_frame;
+    s_video_frame = avcodec_alloc_frame();
+    webcam_frame = avcodec_alloc_frame();
+    AVPacket enc_video_packet;
+
+    uint8_t *buffer;
+    int numBytes;
+    /* Determine required buffer size and allocate buffer */
+    numBytes = avpicture_get_size(PIX_FMT_YUV420P, cs->webcam_decoder_ctx->width, cs->webcam_decoder_ctx->height);
+    buffer = (uint8_t *)av_calloc(numBytes * sizeof(uint8_t),1);
+    avpicture_fill((AVPicture *)s_video_frame, buffer, PIX_FMT_YUV420P, cs->webcam_decoder_ctx->width,
+                   cs->webcam_decoder_ctx->height);
+    cs->sws_ctx = sws_getContext(cs->webcam_decoder_ctx->width, cs->webcam_decoder_ctx->height,
+                                 cs->webcam_decoder_ctx->pix_fmt, cs->webcam_decoder_ctx->width, cs->webcam_decoder_ctx->height, PIX_FMT_YUV420P,
+                                 SWS_BILINEAR, NULL, NULL, NULL);
+
+    while (!cs->quit && cs->send_video) {
+
+        if (av_read_frame(cs->video_format_ctx, packet) < 0) {
+            printf("error reading frame\n");
+
+            if (cs->video_format_ctx->pb->error != 0)
+                break;
+
+            continue;
+        }
+
+        if (packet->stream_index == cs->video_stream) {
+            if (avcodec_decode_video2(cs->webcam_decoder_ctx, webcam_frame, &video_frame_finished, packet) < 0) {
+                printf("couldn't decode\n");
+                continue;
+            }
+
+            av_free_packet(packet);
+            sws_scale(cs->sws_ctx, (uint8_t const * const *)webcam_frame->data, webcam_frame->linesize, 0,
+                      cs->webcam_decoder_ctx->height, s_video_frame->data, s_video_frame->linesize);
+            /* create a new I-frame every 60 frames */
+            ++p;
+
+            if (p == 60) {
+
+                s_video_frame->pict_type = AV_PICTURE_TYPE_BI ;
+            } else if (p == 61) {
+                s_video_frame->pict_type = AV_PICTURE_TYPE_I ;
+                p = 0;
+            } else {
+                s_video_frame->pict_type = AV_PICTURE_TYPE_P ;
+            }
+
+            if (video_frame_finished) {
+                err = avcodec_encode_video2(cs->video_encoder_ctx, &enc_video_packet, s_video_frame, &got_packet);
+
+                if (err < 0) {
+                    printf("could not encode video frame\n");
+                    continue;
+                }
+
+                if (!got_packet) {
+                    continue;
+                }
+
+                pthread_mutex_lock(&cs->rtp_msg_mutex_lock);
+                THREADLOCK()
+
+                if (!enc_video_packet.data) fprintf(stderr, "video packet data is NULL\n");
+
+                s_video_msg = rtp_msg_new ( cs->_rtp_video, enc_video_packet.data, enc_video_packet.size ) ;
+
+                if (!s_video_msg) {
+                    printf("invalid message\n");
+                }
+
+                rtp_send_msg ( cs->_rtp_video, s_video_msg, cs->_networking );
+                THREADUNLOCK()
+                pthread_mutex_unlock(&cs->rtp_msg_mutex_lock);
+                av_free_packet(&enc_video_packet);
+            }
+        } else {
+            av_free_packet(packet);
+        }
+    }
+
+    /* clean up codecs */
+    pthread_mutex_lock(&cs->avcodec_mutex_lock);
+    av_free(buffer);
+    av_free(webcam_frame);
+    av_free(s_video_frame);
+    sws_freeContext(cs->sws_ctx);
+    avcodec_close(cs->webcam_decoder_ctx);
+    avcodec_close(cs->video_encoder_ctx);
+    pthread_mutex_unlock(&cs->avcodec_mutex_lock);
+    pthread_exit ( NULL );
+}
+
+void *encode_audio_thread(void *arg)
+{
+    codec_state *cs = (codec_state *)arg;
+    rtp_msg_t *s_audio_msg;
+    unsigned char encoded_data[4096];
+    int encoded_size = 0;
+    int16_t frame[4096];
+    int frame_size = AUDIO_FRAME_SIZE;
+    ALint sample = 0;
+    alcCaptureStart(cs->audio_capture_device);
+
+    while (!cs->quit && cs->send_audio) {
+        alcGetIntegerv(cs->audio_capture_device, ALC_CAPTURE_SAMPLES, (ALCsizei)sizeof(ALint), &sample);
+
+        if (sample >= frame_size) {
+            alcCaptureSamples(cs->audio_capture_device, frame, frame_size);
+            encoded_size = opus_encode(cs->audio_encoder, frame, frame_size, encoded_data, 480);
+
+            if (encoded_size <= 0) {
+                printf("Could not encode audio packet\n");
+            } else {
+                pthread_mutex_lock(&cs->rtp_msg_mutex_lock);
+                THREADLOCK()
+                rtp_set_payload_type(cs->_rtp_audio, 96);
+                s_audio_msg = rtp_msg_new (cs->_rtp_audio, encoded_data, encoded_size) ;
+                rtp_send_msg ( cs->_rtp_audio, s_audio_msg, cs->_networking );
+                pthread_mutex_unlock(&cs->rtp_msg_mutex_lock);
+                THREADUNLOCK()
+            }
+        } else {
+            usleep(1000);
+        }
+    }
+
+    /* clean up codecs */
+    pthread_mutex_lock(&cs->avcodec_mutex_lock);
+    alcCaptureStop(cs->audio_capture_device);
+    alcCaptureCloseDevice(cs->audio_capture_device);
+
+    pthread_mutex_unlock(&cs->avcodec_mutex_lock);
+    pthread_exit ( NULL );
+}
+
+
+int video_decoder_refresh(codec_state *cs, int width, int height)
+{
+    printf("need to refresh\n");
+    screen = SDL_SetVideoMode(width, height, 0, 0);
+
+    if (cs->video_picture.bmp)
+        SDL_FreeYUVOverlay(cs->video_picture.bmp);
+
+    cs->video_picture.bmp = SDL_CreateYUVOverlay(width, height, SDL_YV12_OVERLAY, screen);
+    cs->sws_SDL_r_ctx = sws_getContext(width, height, cs->video_decoder_ctx->pix_fmt, width, height, PIX_FMT_YUV420P,
+                                       SWS_BILINEAR, NULL, NULL, NULL);
+    return 1;
+}
+
+void *decode_video_thread(void *arg)
+{
+    codec_state *cs = (codec_state *)arg;
+    cs->video_stream = 0;
+    rtp_msg_t *r_msg;
+    int dec_frame_finished;
+    AVFrame *r_video_frame;
+    r_video_frame = avcodec_alloc_frame();
+    AVPacket dec_video_packet;
+    av_new_packet (&dec_video_packet, 65536);
+    int width = 0;
+    int height = 0;
+
+    while (!cs->quit && cs->receive_video) {
+        r_msg = rtp_recv_msg ( cs->_rtp_video );
+
+        if (r_msg) {
+            memcpy(dec_video_packet.data, r_msg->_data, r_msg->_length);
+            dec_video_packet.size = r_msg->_length;
+            avcodec_decode_video2(cs->video_decoder_ctx, r_video_frame, &dec_frame_finished, &dec_video_packet);
+
+            if (dec_frame_finished) {
+                if (cs->video_decoder_ctx->width != width || cs->video_decoder_ctx->height != height) {
+                    width = cs->video_decoder_ctx->width;
+                    height = cs->video_decoder_ctx->height;
+                    printf("w: %d h%d \n", width, height);
+                    video_decoder_refresh(cs, width, height);
+                }
+
+                display_received_frame(cs, r_video_frame);
+            } else {
+                /* TODO: request the sender to create a new i-frame immediatly */
+                printf("bad video packet\n");
+            }
+
+            rtp_free_msg(cs->_rtp_video, r_msg);
+        }
+
+        usleep(1000);
+    }
+
+    printf("vend\n");
+    /* clean up codecs */
+    pthread_mutex_lock(&cs->avcodec_mutex_lock);
+    av_free(r_video_frame);
+    avcodec_close(cs->video_decoder_ctx);
+    pthread_mutex_unlock(&cs->avcodec_mutex_lock);
+    pthread_exit ( NULL );
+}
+
+void *decode_audio_thread(void *arg)
+{
+    codec_state *cs = (codec_state *)arg;
+    rtp_msg_t *r_msg;
+
+    int frame_size = AUDIO_FRAME_SIZE;
+    int data_size;
+
+    ALCdevice *dev;
+    ALCcontext *ctx;
+    ALuint source, *buffers;
+    dev = alcOpenDevice(NULL);
+    ctx = alcCreateContext(dev, NULL);
+    alcMakeContextCurrent(ctx);
+    int openal_buffers = 5;
+
+    buffers = calloc(sizeof(ALuint) * openal_buffers,1);
+    alGenBuffers(openal_buffers, buffers);
+    alGenSources((ALuint)1, &source);
+    alSourcei(source, AL_LOOPING, AL_FALSE);
+
+    ALuint buffer;
+    ALint val;
+
+    ALenum error;
+    uint16_t zeros[frame_size];
+    int i;
+
+    for (i = 0; i < frame_size; i++) {
+        zeros[i] = 0;
+    }
+
+    for (i = 0; i < openal_buffers; ++i) {
+        alBufferData(buffers[i], AL_FORMAT_MONO16, zeros, frame_size, 48000);
+    }
+
+    alSourceQueueBuffers(source, openal_buffers, buffers);
+    alSourcePlay(source);
+
+    if (alGetError() != AL_NO_ERROR) {
+        fprintf(stderr, "Error starting audio\n");
+        cs->quit = 1;
+    }
+
+    struct jitter_buffer *j_buf = NULL;
+
+    j_buf = create_queue(20);
+
+    int success = 0;
+
+    int dec_frame_len;
+
+    opus_int16 PCM[frame_size];
+
+    while (!cs->quit && cs->receive_audio) {
+        THREADLOCK()
+        r_msg = rtp_recv_msg ( cs->_rtp_audio );
+
+        if (r_msg) {
+            /* push the packet into the queue */
+            queue(j_buf, r_msg);
+        }
+
+        /* grab a packet from the queue */
+        success = 0;
+        alGetSourcei(source, AL_BUFFERS_PROCESSED, &val);
+
+        if (val > 0)
+            r_msg = dequeue(j_buf, &success);
+
+        if (success > 0) {
+            /* good packet */
+            if (success == 1) {
+                dec_frame_len = opus_decode(cs->audio_decoder, r_msg->_data, r_msg->_length, PCM, frame_size, 0);
+                rtp_free_msg(cs->_rtp_audio, r_msg);
+            }
+
+            /* lost packet  */
+            if (success == 2) {
+                printf("lost packet\n");
+                dec_frame_len = opus_decode(cs->audio_decoder, NULL, 0, PCM, frame_size, 1);
+            }
+
+            if (dec_frame_len > 0) {
+                alGetSourcei(source, AL_BUFFERS_PROCESSED, &val);
+
+                if (val <= 0)
+                    continue;
+
+                alSourceUnqueueBuffers(source, 1, &buffer);
+                data_size = av_samples_get_buffer_size(NULL, 1, dec_frame_len, AV_SAMPLE_FMT_S16, 1);
+                alBufferData(buffer, AL_FORMAT_MONO16, PCM, data_size, 48000);
+                int error = alGetError();
+
+                if (error != AL_NO_ERROR) {
+                    fprintf(stderr, "Error setting buffer %d\n", error);
+                    break;
+                }
+
+                alSourceQueueBuffers(source, 1, &buffer);
+
+                if (alGetError() != AL_NO_ERROR) {
+                    fprintf(stderr, "error: could not buffer audio\n");
+                    break;
+                }
+
+                alGetSourcei(source, AL_SOURCE_STATE, &val);
+
+                if (val != AL_PLAYING)
+                    alSourcePlay(source);
+
+
+            }
+        }
+
+        THREADUNLOCK()
+        usleep(1000);
+    }
+
+    /* clean up codecs */
+    pthread_mutex_lock(&cs->avcodec_mutex_lock);
+
+    /* clean up openal */
+    alDeleteSources(1, &source);
+    alDeleteBuffers(openal_buffers, buffers);
+    alcMakeContextCurrent(NULL);
+    alcDestroyContext(ctx);
+    alcCloseDevice(dev);
+    pthread_mutex_unlock(&cs->avcodec_mutex_lock);
+    pthread_exit ( NULL );
+}
diff --git a/toxav/toxmedia.h b/toxav/toxmedia.h
new file mode 100644
index 00000000..7eea39ae
--- /dev/null
+++ b/toxav/toxmedia.h
@@ -0,0 +1,168 @@
+/* AV_codec.h
+ *
+ * Audio and video codec intitialisation, encoding/decoding and playback
+ *
+ *  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 _AVCODEC_H_
+#define _AVCODEC_H_
+
+#include <stdio.h>
+#include <math.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libswscale/swscale.h>
+#include <libavdevice/avdevice.h>
+#include <libavutil/opt.h>
+#include <pthread.h>
+#include <AL/al.h>
+#include <AL/alc.h>
+#include "toxrtp.h"
+#include "tox.h"
+
+#include <SDL/SDL.h>
+#include <opus/opus.h>
+
+/* ffmpeg VP8 codec ID */
+#define VIDEO_CODEC         AV_CODEC_ID_VP8
+
+/* ffmpeg Opus codec ID */
+#define AUDIO_CODEC         AV_CODEC_ID_OPUS
+
+/* default video bitrate in bytes/s */
+#define VIDEO_BITRATE   10*1000
+
+/* default audio bitrate in bytes/s */
+#define AUDIO_BITRATE   64000
+
+/* audio frame duration in miliseconds */
+#define AUDIO_FRAME_DURATION    20
+
+/* audio sample rate recommended to be 48kHz for Opus */
+#define AUDIO_SAMPLE_RATE   48000
+
+/* the amount of samples in one audio frame */
+#define AUDIO_FRAME_SIZE    AUDIO_SAMPLE_RATE*AUDIO_FRAME_DURATION/1000
+
+/* the quit event for SDL */
+#define FF_QUIT_EVENT (SDL_USEREVENT + 2)
+
+#ifdef __linux__
+#define VIDEO_DRIVER "video4linux2"
+#define DEFAULT_WEBCAM "/dev/video0"
+#endif
+
+#ifdef WIN32
+#define VIDEO_DRIVER "vfwcap"
+#define DEFAULT_WEBCAM "0"
+#endif
+
+extern SDL_Surface *screen;
+
+typedef struct {
+    SDL_Overlay *bmp;
+    int width, height;
+} VideoPicture;
+
+
+typedef struct {
+    uint8_t send_audio;
+    uint8_t receive_audio;
+    uint8_t send_video;
+    uint8_t receive_video;
+
+    uint8_t support_send_audio;
+    uint8_t support_send_video;
+    uint8_t support_receive_audio;
+    uint8_t support_receive_video;
+
+    /* video encoding */
+    AVInputFormat       *video_input_format;
+    AVFormatContext     *video_format_ctx;
+    uint8_t              video_stream;
+    AVCodecContext      *webcam_decoder_ctx;
+    AVCodec             *webcam_decoder;
+    AVCodecContext      *video_encoder_ctx;
+    AVCodec             *video_encoder;
+
+    /* video decoding */
+    AVCodecContext      *video_decoder_ctx;
+    AVCodec             *video_decoder;
+
+    /* audio encoding */
+    ALCdevice       *audio_capture_device;
+    OpusEncoder     *audio_encoder;
+    int         audio_bitrate;
+
+    /* audio decoding */
+    OpusDecoder     *audio_decoder;
+
+    uint8_t req_video_refresh;
+
+    /* context for converting image format to something SDL can use*/
+    struct SwsContext   *sws_SDL_r_ctx;
+
+    /* context for converting webcam image format to something the video encoder can use */
+    struct SwsContext   *sws_ctx;
+
+    /* rendered video picture, ready for display */
+    VideoPicture    video_picture;
+
+    rtp_session_t *_rtp_video;
+    rtp_session_t *_rtp_audio;
+    int socket;
+    Networking_Core *_networking;
+
+    pthread_t encode_audio_thread;
+    pthread_t encode_video_thread;
+
+    pthread_t decode_audio_thread;
+    pthread_t decode_video_thread;
+
+    pthread_mutex_t rtp_msg_mutex_lock;
+    pthread_mutex_t avcodec_mutex_lock;
+
+    uint8_t             quit;
+    SDL_Event           SDL_event;
+
+    msi_session_t *_msi;
+    uint32_t _frame_rate;
+    uint16_t _send_port, _recv_port;
+    int _tox_sock;
+    //pthread_id _medialoop_id;
+
+} codec_state;
+
+int display_received_frame(codec_state *cs, AVFrame *r_video_frame);
+int init_receive_audio(codec_state *cs);
+int init_decoder(codec_state *cs);
+int init_send_video(codec_state *cs);
+int init_send_audio(codec_state *cs);
+int init_encoder(codec_state *cs);
+int video_encoder_refresh(codec_state *cs, int bps);
+void *encode_video_thread(void *arg);
+void *encode_audio_thread(void *arg);
+int video_decoder_refresh(codec_state *cs, int width, int height);
+int handle_rtp_video_packet(codec_state *cs, rtp_msg_t *r_msg);
+void *decode_video_thread(void *arg);
+void *decode_audio_thread(void *arg);
+
+#endif
diff --git a/toxav/toxmsi.c b/toxav/toxmsi.c
new file mode 100755
index 00000000..cf0914ab
--- /dev/null
+++ b/toxav/toxmsi.c
@@ -0,0 +1,1337 @@
+/**  toxmsi.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/>.
+ *
+ * 
+ *   Report bugs/suggestions to me ( mannol ) at either #tox-dev @ freenode.net:6667 or
+ *   my email: eniz_vukovic@hotmail.com
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#define _BSD_SOURCE
+
+#include "toxmsi.h"
+#include "../toxcore/util.h"
+#include "../toxcore/network.h"
+#include "../toxcore/event.h"
+#include "../toxcore/Messenger.h"
+
+#include <assert.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define same(x, y) strcmp((const char*) x, (const char*) y) == 0
+
+#define MSI_MAXMSG_SIZE 1024
+
+#define TYPE_REQUEST 1
+#define TYPE_RESPONSE 2
+
+#define VERSION_STRING "0.3.1"
+#define VERSION_STRLEN 5
+
+#define CT_AUDIO_HEADER_VALUE "AUDIO"
+#define CT_VIDEO_HEADER_VALUE "VIDEO"
+
+
+/* Define default timeout for a request.
+ * There is no behavior specified by the msi on what will
+ * client do on timeout, but to call timeout callback.
+ */
+#define m_deftout 10000 /* in milliseconds */
+
+/**
+ * Protocol:
+ *
+ * | desc. ( 1 byte ) | length ( 2 bytes ) | value ( length bytes ) |
+ *
+ * ie.
+ *
+ * | 0x1 | 0x0 0x7 | "version"
+ *
+ * Means: it's field value with length of 7 bytes and value of "version"
+ * It's similar to amp protocol
+ */
+
+
+#define GENERIC_HEADER(header) \
+typedef struct _MSIHeader##header { \
+uint8_t* header_value; \
+uint16_t size; \
+} MSIHeader##header;
+
+
+GENERIC_HEADER ( Version )
+GENERIC_HEADER ( Request )
+GENERIC_HEADER ( Response )
+GENERIC_HEADER ( CallType )
+GENERIC_HEADER ( UserAgent )
+GENERIC_HEADER ( CallId )
+GENERIC_HEADER ( Info )
+GENERIC_HEADER ( Reason )
+GENERIC_HEADER ( CryptoKey )
+GENERIC_HEADER ( Nonce )
+
+
+/**
+ * @brief This is the message structure. It contains all of the headers and
+ *        destination/source of the message stored in friend_id.
+ * 
+ */
+typedef struct _MSIMessage {
+    
+    MSIHeaderVersion   version;
+    MSIHeaderRequest   request;
+    MSIHeaderResponse  response;
+    MSIHeaderCallType  calltype;
+    MSIHeaderUserAgent useragent;
+    MSIHeaderInfo      info;
+    MSIHeaderReason    reason;
+    MSIHeaderCallId    callid;
+    MSIHeaderCryptoKey cryptokey;
+    MSIHeaderNonce     nonce;
+    
+    struct _MSIMessage* next;
+    
+    int friend_id; 
+    
+} MSIMessage;
+
+
+
+static MSICallback callbacks[9] = {0};
+
+
+/* define strings for the identifiers */
+#define VERSION_FIELD      "Version"
+#define REQUEST_FIELD      "Request"
+#define RESPONSE_FIELD     "Response"
+#define INFO_FIELD         "INFO"
+#define REASON_FIELD       "Reason"
+#define CALLTYPE_FIELD     "Call-type"
+#define USERAGENT_FIELD    "User-agent"
+#define CALLID_FIELD       "Call-id"
+#define CRYPTOKEY_FIELD    "Crypto-key"
+#define NONCE_FIELD        "Nonce"
+
+/* protocol descriptors */
+#define end_byte    0x0
+#define field_byte  0x1
+#define value_byte  0x2
+
+
+typedef enum {
+    invite,
+    start,
+    cancel,
+    reject,
+    end,
+    
+} MSIRequest;
+
+
+/**
+ * @brief Get string value for request.
+ * 
+ * @param request The request.
+ * @return const uint8_t* The string
+ */
+static inline const uint8_t *stringify_request ( MSIRequest request ) {
+    static const uint8_t* strings[] = {
+        ( uint8_t* ) "INVITE",
+        ( uint8_t* ) "START",
+        ( uint8_t* ) "CANCEL",
+        ( uint8_t* ) "REJECT",
+        ( uint8_t* ) "END"
+    };
+
+    return strings[request];
+}
+
+
+typedef enum {
+    ringing,
+    starting,
+    ending,
+    error
+
+} MSIResponse;
+
+
+/**
+ * @brief Get string value for response.
+ * 
+ * @param response The response.
+ * @return const uint8_t* The string
+ */
+static inline const uint8_t *stringify_response ( MSIResponse response ) {
+    static const uint8_t* strings[] = {
+        ( uint8_t* ) "ringing",
+        ( uint8_t* ) "starting",
+        ( uint8_t* ) "ending",
+        ( uint8_t* ) "error"
+    };
+
+    return strings[response];
+}
+
+
+#define ON_HEADER(iterator, header, descriptor, size_const) \
+( memcmp(iterator, descriptor, size_const) == 0){ /* Okay */ \
+    iterator += size_const; /* Set iterator at begining of value part */ \
+    if ( *iterator != value_byte ) { assert(0); return -1; }\
+    iterator ++;\
+    uint16_t _value_size = (uint16_t) *(iterator ) << 8 | \
+    (uint16_t) *(iterator + 1); \
+    header.header_value = calloc(sizeof(uint8_t), _value_size); \
+    header.size = _value_size; \
+    memcpy(header.header_value, iterator + 2, _value_size);\
+    iterator = iterator + 2 + _value_size; /* set iterator at new header or end_byte */ \
+}
+
+/**
+ * @brief Parse raw 'data' received from socket into MSIMessage struct.
+ *        Every message has to have end value of 'end_byte' or _undefined_ behavior
+ *        occures. The best practice is to check the end of the message at the handle_packet.
+ * 
+ * @param msg Container.
+ * @param data The data.
+ * @return int
+ * @retval -1 Error occured.
+ * @retval 0 Success.
+ */
+int parse_raw_data ( MSIMessage* msg, const uint8_t* data ) {
+    assert ( msg );
+
+    const uint8_t* _it = data;
+
+    while ( *_it ) {/* until end_byte is hit */
+
+        if ( *_it == field_byte ) {
+            uint16_t _size = ( uint16_t ) * ( _it + 1 ) << 8 |
+                             ( uint16_t ) * ( _it + 2 );
+
+            _it += 3; /*place it at the field value beginning*/
+
+            switch ( _size ) { /* Compare the size of the hardcoded values ( vary fast and convenient ) */
+
+            case 4: { /* INFO header */
+                if ON_HEADER ( _it, msg->info, INFO_FIELD, 4 )
+                }
+            break;
+
+            case 5: { /* NONCE header */
+                if ON_HEADER ( _it, msg->nonce, NONCE_FIELD, 5 )
+                }
+            break;
+
+            case 6: { /* Reason header */
+                if ON_HEADER ( _it, msg->reason, REASON_FIELD, 6 )
+                }
+            break;
+
+            case 7: { /* Version, Request, Call-id headers */
+                if ON_HEADER ( _it, msg->version, VERSION_FIELD, 7 )
+                    else if ON_HEADER ( _it, msg->request, REQUEST_FIELD, 7 )
+                        else if ON_HEADER ( _it, msg->callid, CALLID_FIELD, 7 )
+                        }
+            break;
+
+            case 8: { /* Response header */
+                if ON_HEADER ( _it, msg->response, RESPONSE_FIELD, 8 )
+                }
+            break;
+
+            case 9: { /* Call-type header */
+                if ON_HEADER ( _it, msg->calltype, CALLTYPE_FIELD, 9 )
+                }
+            break;
+
+            case 10: { /* User-agent, Crypto-key headers */
+                if ON_HEADER ( _it, msg->useragent, USERAGENT_FIELD, 10 )
+                    else if ON_HEADER ( _it, msg->cryptokey, CRYPTOKEY_FIELD, 10 )
+                    }
+            break;
+
+            default:
+                return -1;
+            }
+        } else return -1;
+        /* If it's anything else return failure as the message is invalid */
+
+    }
+
+    return 0;
+}
+
+
+#define ALLOCATE_HEADER( var, mheader_value, t_size) \
+var.header_value = calloc(sizeof *mheader_value, t_size); \
+memcpy(var.header_value, mheader_value, t_size); \
+var.size = t_size;
+
+
+/**
+ * @brief Speaks for it self.
+ * 
+ * @param msg The message.
+ * @return void
+ */
+void free_message ( MSIMessage* msg ) {
+    assert ( msg );
+
+    free ( msg->calltype.header_value );
+    free ( msg->request.header_value );
+    free ( msg->response.header_value );
+    free ( msg->useragent.header_value );
+    free ( msg->version.header_value );
+    free ( msg->info.header_value );
+    free ( msg->cryptokey.header_value );
+    free ( msg->nonce.header_value );
+    free ( msg->reason.header_value );
+    free ( msg->callid.header_value );
+
+    free ( msg );
+}
+
+
+/**
+ * @brief Create the message. 
+ * 
+ * @param type Request or response.
+ * @param type_id Type of request/response.
+ * @return MSIMessage* Created message.
+ * @retval NULL Error occured.
+ */
+MSIMessage* msi_new_message ( uint8_t type, const uint8_t* type_id ) {
+    MSIMessage* _retu = calloc ( sizeof ( MSIMessage ), 1 );
+    assert ( _retu );
+
+    memset ( _retu, 0, sizeof ( MSIMessage ) );
+
+    if ( type == TYPE_REQUEST ) {
+        ALLOCATE_HEADER ( _retu->request, type_id, strlen ( type_id ) )
+
+    } else if ( type == TYPE_RESPONSE ) {
+        ALLOCATE_HEADER ( _retu->response, type_id, strlen ( type_id ) )
+
+    } else {
+        free_message ( _retu );
+        return NULL;
+    }
+
+    ALLOCATE_HEADER ( _retu->version, VERSION_STRING, strlen ( VERSION_STRING ) )
+
+    return _retu;
+}
+
+
+/**
+ * @brief Parse data from handle_packet.
+ * 
+ * @param data The data.
+ * @return MSIMessage* Parsed message.
+ * @retval NULL Error occured.
+ */
+MSIMessage* parse_message ( const uint8_t* data ) {
+    assert ( data );
+
+    MSIMessage* _retu = calloc ( sizeof ( MSIMessage ), 1 );
+    assert ( _retu );
+
+    memset ( _retu, 0, sizeof ( MSIMessage ) );
+
+    if ( parse_raw_data ( _retu, data ) == -1 ) {
+
+        free_message ( _retu );
+        return NULL;
+    }
+
+    if ( !_retu->version.header_value || VERSION_STRLEN != _retu->version.size ||
+            memcmp ( _retu->version.header_value, VERSION_STRING, VERSION_STRLEN ) != 0 ) {
+
+        free_message ( _retu );
+        return NULL;
+    }
+
+    return _retu;
+}
+
+
+
+/**
+ * @brief Speaks for it self.
+ * 
+ * @param dest Container.
+ * @param header_field Field.
+ * @param header_value Field value.
+ * @param value_len Length of field value.
+ * @param length Pointer to container length.
+ * @return uint8_t* Iterated container.
+ */
+uint8_t* append_header_to_string (
+    uint8_t* dest,
+    const uint8_t* header_field,
+    const uint8_t* header_value,
+    uint16_t value_len,
+    uint16_t* length ) 
+{
+    assert ( dest );
+    assert ( header_value );
+    assert ( header_field );
+
+    const uint8_t* _hvit = header_value;
+    uint16_t _total = 6 + value_len; /* 6 is known plus header value len + field len*/
+
+    *dest = field_byte; /* Set the first byte */
+
+    uint8_t* _getback_byte = dest + 1; /* remeber the byte we were on */
+    dest += 3; /* swith to 4th byte where field value starts */
+
+    /* Now set the field value and calculate it's length */
+    uint16_t _i = 0;
+    for ( ; header_field[_i]; ++_i ) {
+        *dest = header_field[_i];
+        ++dest;
+    };
+    _total += _i;
+
+    /* Now set the length of the field byte */
+    *_getback_byte = ( uint8_t ) _i >> 8;
+    _getback_byte++;
+    *_getback_byte = ( uint8_t ) _i;
+
+    /* for value part do it regulary */
+    *dest = value_byte;
+    dest++;
+
+    *dest = ( uint8_t ) value_len >> 8;
+    dest++;
+    *dest = ( uint8_t ) value_len;
+    dest++;
+
+    for ( _i = value_len; _i; --_i ) {
+        *dest = *_hvit;
+        ++_hvit;
+        ++dest;
+    }
+
+    *length += _total;
+    return dest;
+}
+
+
+#define CLEAN_ASSIGN(added, var, field, header)\
+if ( header.header_value ) { var = append_header_to_string(var, (const uint8_t*)field, header.header_value, header.size, &added); }
+
+
+/**
+ * @brief Convert MSIMessage struct to _sendable_ string.
+ * 
+ * @param msg The message.
+ * @param dest Destination.
+ * @return uint16_t It's final size.
+ */
+uint16_t message_to_string ( MSIMessage* msg, uint8_t* dest ) {
+    assert ( msg );
+    assert ( dest );
+
+    uint8_t* _iterated = dest;
+    uint16_t _size = 0;
+
+    CLEAN_ASSIGN ( _size, _iterated, VERSION_FIELD, msg->version );
+    CLEAN_ASSIGN ( _size, _iterated, REQUEST_FIELD, msg->request );
+    CLEAN_ASSIGN ( _size, _iterated, RESPONSE_FIELD, msg->response );
+    CLEAN_ASSIGN ( _size, _iterated, CALLTYPE_FIELD, msg->calltype );
+    CLEAN_ASSIGN ( _size, _iterated, USERAGENT_FIELD, msg->useragent );
+    CLEAN_ASSIGN ( _size, _iterated, INFO_FIELD, msg->info );
+    CLEAN_ASSIGN ( _size, _iterated, CALLID_FIELD, msg->callid );
+    CLEAN_ASSIGN ( _size, _iterated, REASON_FIELD, msg->reason );
+    CLEAN_ASSIGN ( _size, _iterated, CRYPTOKEY_FIELD, msg->cryptokey );
+    CLEAN_ASSIGN ( _size, _iterated, NONCE_FIELD, msg->nonce );
+
+    *_iterated = end_byte;
+    _size ++;
+
+    return _size;
+}
+
+
+#define GENERIC_SETTER_DEFINITION(header) \
+void msi_msg_set_##header ( MSIMessage* _msg, const uint8_t* header_value, uint16_t _size ) \
+{ assert(_msg); assert(header_value); \
+  free(_msg->header.header_value); \
+  ALLOCATE_HEADER( _msg->header, header_value, _size )}
+
+GENERIC_SETTER_DEFINITION ( calltype )
+GENERIC_SETTER_DEFINITION ( useragent )
+GENERIC_SETTER_DEFINITION ( reason )
+GENERIC_SETTER_DEFINITION ( info )
+GENERIC_SETTER_DEFINITION ( callid )
+GENERIC_SETTER_DEFINITION ( cryptokey )
+GENERIC_SETTER_DEFINITION ( nonce )
+
+
+/**
+ * @brief Generate _random_ alphanumerical string.
+ * 
+ * @param str Destination.
+ * @param size Size of string.
+ * @return void
+ */
+void t_randomstr ( uint8_t* str, size_t size ) {
+    assert ( str );
+
+    static const uint8_t _bytes[] =
+        "0123456789"
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "abcdefghijklmnopqrstuvwxyz";
+
+    int _it = 0;
+
+    for ( ; _it < size; _it++ ) {
+        str[_it] = _bytes[ randombytes_random() % 61 ];
+    }
+}
+
+
+typedef enum {
+    error_deadcall = 1,  /* has call id but it's from old call */
+    error_id_mismatch,   /* non-existing call */
+
+    error_no_callid,     /* not having call id */
+    error_no_call,       /* no call in session */
+    error_no_crypto_key, /* no crypto key */
+
+    error_busy,
+
+} MSICallError;          /* Error codes */
+
+
+/**
+ * @brief Stringify error code.
+ * 
+ * @param error_code The code.
+ * @return const uint8_t* The string.
+ */
+static inline const uint8_t *stringify_error ( MSICallError error_code ) {
+    static const uint8_t* strings[] = {
+        ( uint8_t* ) "",
+        ( uint8_t* ) "Using dead call",
+        ( uint8_t* ) "Call id not set to any call",
+        ( uint8_t* ) "Call id not available",
+        ( uint8_t* ) "No active call in session",
+        ( uint8_t* ) "No Crypto-key set",
+        ( uint8_t* ) "Callee busy"
+    };
+
+    return strings[error_code];
+}
+
+
+/**
+ * @brief Convert error_code into string.
+ * 
+ * @param error_code The code.
+ * @return const uint8_t* The string.
+ */
+static inline const uint8_t *stringify_error_code ( MSICallError error_code ) {
+    static const uint8_t* strings[] = {
+        ( uint8_t* ) "",
+        ( uint8_t* ) "1",
+        ( uint8_t* ) "2",
+        ( uint8_t* ) "3",
+        ( uint8_t* ) "4",
+        ( uint8_t* ) "5",
+        ( uint8_t* ) "6"
+    };
+
+    return strings[error_code];
+}
+
+
+/**
+ * @brief Speaks for it self.
+ * 
+ * @param session Control session.
+ * @param msg The message.
+ * @param to Where to.
+ * @return int
+ * @retval -1 Error occured.
+ * @retval 0 Success.
+ */
+int send_message ( MSISession* session, MSIMessage* msg, uint32_t to ) 
+{
+    msi_msg_set_callid ( msg, session->call->id, CALL_ID_LEN );
+    
+    uint8_t _msg_string_final [MSI_MAXMSG_SIZE];
+    uint16_t _length = message_to_string ( msg, _msg_string_final );
+    
+    return m_msi_packet((struct Messenger*) session->messenger_handle, to, _msg_string_final, _length) ? 0 : -1;
+}
+
+
+/**
+ * @brief Speaks for it self.
+ * 
+ * @param session Control session.
+ * @param msg The message.
+ * @param peer_id The peer.
+ * @return void
+ */
+void flush_peer_type ( MSISession* session, MSIMessage* msg, int peer_id ) {
+    if ( msg->calltype.header_value ) {
+        if ( strcmp ( ( const char* ) msg->calltype.header_value, CT_AUDIO_HEADER_VALUE ) == 0 ) {
+            session->call->type_peer[peer_id] = type_audio;
+
+        } else if ( strcmp ( ( const char* ) msg->calltype.header_value, CT_VIDEO_HEADER_VALUE ) == 0 ) {
+            session->call->type_peer[peer_id] = type_video;
+        } else {} /* Error */
+    } else {} /* Error */
+}
+
+
+
+/**
+ * @brief Sends error response to peer.
+ * 
+ * @param session The session.
+ * @param errid The id.
+ * @param to Where to?
+ * @return int
+ * @retval 0 It's always success.
+ */
+int handle_error ( MSISession* session, MSICallError errid, uint32_t to ) {
+    MSIMessage* _msg_error = msi_new_message ( TYPE_RESPONSE, stringify_response ( error ) );
+
+    const uint8_t* _error_code_str = stringify_error_code ( errid );
+
+    msi_msg_set_reason ( _msg_error, _error_code_str, strlen ( ( const char* ) _error_code_str ) );
+    send_message ( session, _msg_error, to );
+    free_message ( _msg_error );
+
+    session->last_error_id = errid;
+    session->last_error_str = stringify_error ( errid );
+
+    event.rise ( callbacks[cb_error], session );
+
+    return 0;
+}
+
+
+/**
+ * @brief Determine the error if any.
+ * 
+ * @param session Control session.
+ * @param msg The message.
+ * @return int
+ * @retval -1 No error.
+ * @retval 0 Error occured and response sent.
+ */
+int has_call_error ( MSISession* session, MSIMessage* msg ) {
+    if ( !msg->callid.header_value ) {
+        return handle_error ( session, error_no_callid, msg->friend_id );
+
+    } else if ( !session->call ) {
+        return handle_error ( session, error_no_call, msg->friend_id );
+
+    } else if ( memcmp ( session->call->id, msg->callid.header_value, CALL_ID_LEN ) != 0 ) {
+        return handle_error ( session, error_id_mismatch, msg->friend_id );
+
+    }
+
+    return -1;
+}
+
+
+/**
+ * @brief Function called at request timeout.
+ * 
+ * @param arg Control session
+ * @return void*
+ */
+void* handle_timeout ( void* arg ) 
+{
+    /* Send hangup either way */
+    MSISession* _session = arg;
+    
+    uint32_t* _peers = _session->call->peers;
+    uint16_t  _peer_count = _session->call->peer_count;
+    
+    
+    /* Cancel all? */
+    uint16_t _it = 0;
+    for ( ; _it < _peer_count; _it++ )
+        msi_cancel ( arg, _peers[_it] );
+    
+    
+    ( *callbacks[cb_timeout] ) ( arg );
+    ( *callbacks[cb_ending ] ) ( arg );
+
+    return NULL;
+}
+
+
+/**
+ * @brief Add peer to peer list.
+ * 
+ * @param call What call.
+ * @param peer_id Its id.
+ * @return void
+ */
+void add_peer( MSICall* call, int peer_id )
+{
+    if ( !call->peers ) {
+        call->peers = calloc(sizeof(int), 1);
+        call->peer_count = 1;
+    } else{
+        call->peer_count ++;
+        call->peers = realloc( call->peers, sizeof(int) * call->peer_count);
+    }    
+    
+    call->peers[call->peer_count - 1] = peer_id;
+}
+
+
+/**
+ * @brief BASIC call flow:
+ *
+ *    ALICE                    BOB
+ *      | invite -->            |
+ *      |                       |
+ *      |           <-- ringing |
+ *      |                       |
+ *      |          <-- starting |
+ *      |                       |
+ *      | start -->             |
+ *      |                       |
+ *      |  <-- MEDIA TRANS -->  |
+ *      |                       |
+ *      | end -->               |
+ *      |                       |
+ *      |            <-- ending |
+ *
+ * Alice calls Bob by sending invite packet.
+ * Bob recvs the packet and sends an ringing packet;
+ * which notifies Alice that her invite is acknowledged.
+ * Ringing screen shown on both sides.
+ * Bob accepts the invite for a call by sending starting packet.
+ * Alice recvs the starting packet and sends the started packet to
+ * inform Bob that she recved the starting packet.
+ * Now the media transmission is established ( i.e. RTP transmission ).
+ * Alice hangs up and sends end packet.
+ * Bob recves the end packet and sends ending packet
+ * as the acknowledgement that the call is ending.
+ *
+ *
+ */
+void msi_handle_packet ( Messenger* messenger, int source, uint8_t* data, uint16_t length, void* object ) 
+{
+    MSISession* _session = object;
+    MSIMessage* _msg;
+    
+    _msg = parse_message ( data );
+    
+    if ( !_msg ) return;
+    
+    _msg->friend_id = source;
+    
+    
+    /* Now handle message */
+    
+    if ( _msg->request.header_value ) { /* Handle request */
+        
+        const uint8_t* _request_value = _msg->request.header_value;
+        
+        if ( same ( _request_value, stringify_request ( invite ) ) ) {
+            handle_recv_invite ( _session, _msg );
+            
+        } else if ( same ( _request_value, stringify_request ( start ) ) ) {
+            handle_recv_start ( _session, _msg );
+            
+        } else if ( same ( _request_value, stringify_request ( cancel ) ) ) {
+            handle_recv_cancel ( _session, _msg );
+            
+        } else if ( same ( _request_value, stringify_request ( reject ) ) ) {
+            handle_recv_reject ( _session, _msg );
+            
+        } else if ( same ( _request_value, stringify_request ( end ) ) ) {
+            handle_recv_end ( _session, _msg );
+        }
+        
+        else {
+            free_message ( _msg );
+            return;
+        }
+        
+    } else if ( _msg->response.header_value ) { /* Handle response */
+        
+        const uint8_t* _response_value = _msg->response.header_value;
+        
+        if ( same ( _response_value, stringify_response ( ringing ) ) ) {
+            handle_recv_ringing ( _session, _msg );
+            
+        } else if ( same ( _response_value, stringify_response ( starting ) ) ) {
+            handle_recv_starting ( _session, _msg );
+            
+        } else if ( same ( _response_value, stringify_response ( ending ) ) ) {
+            handle_recv_ending ( _session, _msg );
+            
+        } else if ( same ( _response_value, stringify_response ( error ) ) ) {
+            handle_recv_error ( _session, _msg );
+        } else {
+            free_message ( _msg );
+            return;
+        }
+        
+        /* Got response so cancel timer */
+        if ( _session->call )
+            event.timer_release ( _session->call->request_timer_id );
+        
+    }
+    
+    free_message ( _msg );
+}
+
+
+/**
+ * @brief Speaks for it self.
+ * 
+ * @param session Control session.
+ * @param peers Amount of peers. (Currently it only supports 1)
+ * @param ringing_timeout Ringing timeout.
+ * @return MSICall* The created call.
+ */
+MSICall* init_call ( MSISession* session, int peers, int ringing_timeout ) {
+    assert ( session );
+    assert ( peers );
+
+    MSICall* _call = calloc ( sizeof ( MSICall ), 1 );
+    _call->type_peer = calloc ( sizeof ( MSICallType ), peers );
+
+    assert ( _call );
+    assert ( _call->type_peer );
+
+    /*_call->_participant_count = _peers;*/
+
+    _call->request_timer_id = 0;
+    _call->ringing_timer_id = 0;
+
+    _call->key_local = NULL;
+    _call->key_peer = NULL;
+    _call->nonce_local = NULL;
+    _call->nonce_peer = NULL;
+
+    _call->ringing_tout_ms = ringing_timeout;
+
+    pthread_mutex_init ( &_call->mutex, NULL );
+
+    return _call;
+}
+
+
+/**
+ * @brief Terminate the call.
+ * 
+ * @param session Control session.
+ * @return int
+ * @retval -1 Error occured.
+ * @retval 0 Success.
+ */
+int terminate_call ( MSISession* session ) {
+    assert ( session );
+
+    if ( !session->call )
+        return -1;
+
+
+    /* Check event loop and cancel timed events if there are any
+     * Notice: This has to be done before possibly
+     * locking the mutex the second time
+     */
+    event.timer_release ( session->call->request_timer_id );
+    event.timer_release ( session->call->ringing_timer_id );
+
+    /* Get a handle */
+    pthread_mutex_lock ( &session->call->mutex );
+
+    MSICall* _call = session->call;
+    session->call = NULL;
+
+    free ( _call->type_peer );
+    free ( _call->key_local );
+    free ( _call->key_peer );
+    free ( _call->peers);
+
+    /* Release handle */
+    pthread_mutex_unlock ( &_call->mutex );
+
+    pthread_mutex_destroy ( &_call->mutex );
+
+    free ( _call );
+
+    return 0;
+}
+
+
+/********** Request handlers **********/
+int handle_recv_invite ( MSISession* session, MSIMessage* msg ) {
+    assert ( session );
+
+    if ( session->call ) {
+        handle_error ( session, error_busy, msg->friend_id );
+        return 0;
+    }
+    if ( !msg->callid.header_value ) {
+        handle_error ( session, error_no_callid, msg->friend_id );
+        return 0;
+    }
+
+    session->call = init_call ( session, 1, 0 );
+    memcpy ( session->call->id, msg->callid.header_value, CALL_ID_LEN );
+    session->call->state = call_starting;
+    
+    add_peer( session->call, msg->friend_id);
+    
+    flush_peer_type ( session, msg, 0 );
+
+    MSIMessage* _msg_ringing = msi_new_message ( TYPE_RESPONSE, stringify_response ( ringing ) );
+    send_message ( session, _msg_ringing, msg->friend_id );
+    free_message ( _msg_ringing );
+
+    event.rise ( callbacks[cb_oninvite], session );
+
+    return 1;
+}
+int handle_recv_start ( MSISession* session, MSIMessage* msg ) {
+    assert ( session );
+
+    if ( has_call_error ( session, msg ) == 0 )
+        return 0;
+
+    if ( !msg->cryptokey.header_value )
+        return handle_error ( session, error_no_crypto_key, msg->friend_id );
+
+    session->call->state = call_active;
+
+    session->call->key_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
+    memcpy ( session->call->key_peer, msg->cryptokey.header_value, crypto_secretbox_KEYBYTES );
+
+    session->call->nonce_peer = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES );
+    memcpy ( session->call->nonce_peer, msg->nonce.header_value,  crypto_box_NONCEBYTES );
+
+    flush_peer_type ( session, msg, 0 );
+
+    event.rise ( callbacks[cb_onstart], session );
+
+    return 1;
+}
+int handle_recv_reject ( MSISession* session, MSIMessage* msg ) {
+    assert ( session );
+
+    if ( has_call_error ( session, msg ) == 0 )
+        return 0;
+
+
+    MSIMessage* _msg_end = msi_new_message ( TYPE_REQUEST, stringify_request ( end ) );
+    send_message ( session, _msg_end, msg->friend_id );
+    free_message ( _msg_end );
+
+    event.timer_release ( session->call->request_timer_id );
+    event.rise ( callbacks[cb_onreject], session );
+    session->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
+
+    return 1;
+}
+int handle_recv_cancel ( MSISession* session, MSIMessage* msg ) {
+    assert ( session );
+
+    if ( has_call_error ( session, msg ) == 0 )
+        return 0;
+
+
+    terminate_call ( session );
+
+    event.rise ( callbacks[cb_oncancel], session );
+
+    return 1;
+}
+int handle_recv_end ( MSISession* session, MSIMessage* msg ) {
+    assert ( session );
+
+    if ( has_call_error ( session, msg ) == 0 )
+        return 0;
+
+
+    MSIMessage* _msg_ending = msi_new_message ( TYPE_RESPONSE, stringify_response ( ending ) );
+    send_message ( session, _msg_ending, msg->friend_id );
+    free_message ( _msg_ending );
+
+    terminate_call ( session );
+
+    event.rise ( callbacks[cb_onend], session );
+
+    return 1;
+}
+
+/********** Response handlers **********/
+int handle_recv_ringing ( MSISession* session, MSIMessage* msg ) {
+    assert ( session );
+
+    if ( has_call_error ( session, msg ) == 0 )
+        return 0;
+
+    session->call->ringing_timer_id = event.timer_alloc ( handle_timeout, session, session->call->ringing_tout_ms );
+    event.rise ( callbacks[cb_ringing], session );
+
+    return 1;
+}
+int handle_recv_starting ( MSISession* session, MSIMessage* msg ) {
+    assert ( session );
+
+    if ( has_call_error ( session, msg ) == 0 )
+        return 0;
+
+    if ( !msg->cryptokey.header_value ) {
+        return handle_error ( session, error_no_crypto_key, msg->friend_id );
+    }
+
+    /* Generate local key/nonce to send */
+    session->call->key_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
+    new_symmetric_key ( session->call->key_local );
+
+    session->call->nonce_local = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES );
+    new_nonce ( session->call->nonce_local );
+
+    /* Save peer key/nonce */
+    session->call->key_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
+    memcpy ( session->call->key_peer, msg->cryptokey.header_value, crypto_secretbox_KEYBYTES );
+
+    session->call->nonce_peer = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES );
+    memcpy ( session->call->nonce_peer, msg->nonce.header_value,  crypto_box_NONCEBYTES );
+
+    session->call->state = call_active;
+
+    MSIMessage* _msg_start = msi_new_message ( TYPE_REQUEST, stringify_request ( start ) );
+    msi_msg_set_cryptokey ( _msg_start, session->call->key_local, crypto_secretbox_KEYBYTES );
+    msi_msg_set_nonce ( _msg_start, session->call->nonce_local, crypto_box_NONCEBYTES );
+    send_message ( session, _msg_start, msg->friend_id );
+    free_message ( _msg_start );
+
+    flush_peer_type ( session, msg, 0 );
+
+    event.rise ( callbacks[cb_starting], session );
+    event.timer_release ( session->call->ringing_timer_id );
+
+    return 1;
+}
+int handle_recv_ending ( MSISession* session, MSIMessage* msg ) {
+    assert ( session );
+
+    if ( has_call_error ( session, msg ) == 0 )
+        return 0;
+
+
+    terminate_call ( session );
+
+    event.rise ( callbacks[cb_ending], session );
+
+    return 1;
+}
+int handle_recv_error ( MSISession* session, MSIMessage* msg ) {
+    assert ( session );
+    assert ( session->call );
+
+    /* Handle error accordingly */
+    if ( msg->reason.header_value ) {
+        session->last_error_id = atoi ( ( const char* ) msg->reason.header_value );
+        session->last_error_str = stringify_error ( session->last_error_id );
+    }
+
+    terminate_call ( session );
+
+    event.rise ( callbacks[cb_ending], session );
+
+    return 1;
+}
+
+
+/********************************************************************************************************************  
+ * *******************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ * 
+ * 
+ * 
+ * PUBLIC API FUNCTIONS IMPLEMENTATIONS
+ * 
+ * 
+ * 
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************/
+
+
+
+
+
+
+
+
+/**
+ * @brief Callback setter.
+ * 
+ * @param callback The callback.
+ * @param id The id.
+ * @return void
+ */
+void msi_register_callback ( MSICallback callback, MSICallbackID id ) 
+{
+    callbacks[id] = callback;
+}
+
+
+/**
+ * @brief Start the control session.
+ * 
+ * @param messenger Tox* object.
+ * @param user_agent User agent, i.e. 'Venom'; 'QT-gui'
+ * @return MSISession* The created session.
+ * @retval NULL Error occured.
+ */
+MSISession* msi_init_session ( Tox* messenger, const uint8_t* user_agent ) {
+    assert ( messenger );
+    assert ( user_agent );
+    
+    MSISession* _retu = calloc ( sizeof ( MSISession ), 1 );
+    assert ( _retu );
+    
+    _retu->user_agent = user_agent;
+    _retu->messenger_handle = messenger;
+    _retu->agent_handler = NULL;
+    
+    _retu->call = NULL;
+    
+    _retu->frequ = 10000; /* default value? */
+    _retu->call_timeout = 30000; /* default value? */
+    
+    
+    m_callback_msi_packet((struct Messenger*) messenger, msi_handle_packet, _retu );
+    
+    
+    return _retu;
+}
+
+
+/**
+ * @brief Terminate control session.
+ * 
+ * @param session The session
+ * @return int
+ */
+int msi_terminate_session ( MSISession* session ) {
+    assert ( session );
+    
+    int _status = 0;
+    
+    terminate_call ( session );
+    
+    /* TODO: Clean it up more? */
+    
+    free ( session );
+    return _status;
+}
+
+
+/**
+ * @brief Send invite request to friend_id.
+ * 
+ * @param session Control session.
+ * @param call_type Type of the call. Audio or Video(both audio and video)
+ * @param rngsec Ringing timeout.
+ * @param friend_id The friend.
+ * @return int
+ */
+int msi_invite ( MSISession* session, MSICallType call_type, uint32_t rngsec, uint32_t friend_id ) {
+    assert ( session );
+
+    MSIMessage* _msg_invite = msi_new_message ( TYPE_REQUEST, stringify_request ( invite ) );
+
+    session->call = init_call ( session, 1, rngsec ); /* Just one for now */
+    t_randomstr ( session->call->id, CALL_ID_LEN );
+    
+    add_peer(session->call, friend_id );
+    
+    session->call->type_local = call_type;
+    /* Do whatever with message */
+
+    if ( call_type == type_audio ) {
+        msi_msg_set_calltype
+        ( _msg_invite, ( const uint8_t* ) CT_AUDIO_HEADER_VALUE, strlen ( CT_AUDIO_HEADER_VALUE ) );
+    } else {
+        msi_msg_set_calltype
+        ( _msg_invite, ( const uint8_t* ) CT_VIDEO_HEADER_VALUE, strlen ( CT_VIDEO_HEADER_VALUE ) );
+    }
+
+    send_message ( session, _msg_invite, friend_id );
+    free_message ( _msg_invite );
+
+    session->call->state = call_inviting;
+
+    session->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
+
+    return 0;
+}
+
+
+/**
+ * @brief Hangup active call.
+ * 
+ * @param session Control session.
+ * @return int 
+ * @retval -1 Error occured.
+ * @retval 0 Success.
+ */
+int msi_hangup ( MSISession* session ) {
+    assert ( session );
+
+    if ( !session->call && session->call->state != call_active )
+        return -1;
+
+    MSIMessage* _msg_ending = msi_new_message ( TYPE_REQUEST, stringify_request ( end ) );
+    
+    /* hangup for each peer */
+    int _it = 0;
+    for ( ; _it < session->call->peer_count; _it ++ )
+        send_message ( session, _msg_ending, session->call->peers[_it] );
+    
+    
+    free_message ( _msg_ending );
+
+    session->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
+
+    return 0;
+}
+
+
+/**
+ * @brief Answer active call request.
+ * 
+ * @param session Control session.
+ * @param call_type Answer with Audio or Video(both).
+ * @return int
+ */
+int msi_answer ( MSISession* session, MSICallType call_type ) {
+    assert ( session );
+
+    MSIMessage* _msg_starting = msi_new_message ( TYPE_RESPONSE, stringify_response ( starting ) );
+    session->call->type_local = call_type;
+
+    if ( call_type == type_audio ) {
+        msi_msg_set_calltype
+        ( _msg_starting, ( const uint8_t* ) CT_AUDIO_HEADER_VALUE, strlen ( CT_AUDIO_HEADER_VALUE ) );
+    } else {
+        msi_msg_set_calltype
+        ( _msg_starting, ( const uint8_t* ) CT_VIDEO_HEADER_VALUE, strlen ( CT_VIDEO_HEADER_VALUE ) );
+    }
+
+    /* Now set the local encryption key and pass it with STARTING message */
+
+    session->call->key_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
+    new_symmetric_key ( session->call->key_local );
+
+    session->call->nonce_local = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES );
+    new_nonce ( session->call->nonce_local );
+
+    msi_msg_set_cryptokey ( _msg_starting, session->call->key_local, crypto_secretbox_KEYBYTES );
+    msi_msg_set_nonce ( _msg_starting, session->call->nonce_local, crypto_box_NONCEBYTES );
+
+    send_message ( session, _msg_starting, session->call->peers[session->call->peer_count - 1] );
+    free_message ( _msg_starting );
+
+    session->call->state = call_active;
+
+    return 0;
+}
+
+
+/**
+ * @brief Cancel request.
+ * 
+ * @param session Control session.
+ * @param friend_id The friend.
+ * @return int
+ */
+int msi_cancel ( MSISession* session, int friend_id ) {
+    assert ( session );
+
+    MSIMessage* _msg_cancel = msi_new_message ( TYPE_REQUEST, stringify_request ( cancel ) );
+    send_message ( session, _msg_cancel, friend_id );
+    free_message ( _msg_cancel );
+
+    terminate_call ( session );
+
+    return 0;
+}
+
+
+/**
+ * @brief Reject request.
+ * 
+ * @param session Control session.
+ * @return int
+ */
+int msi_reject ( MSISession* session ) {
+    assert ( session );
+
+    MSIMessage* _msg_reject = msi_new_message ( TYPE_REQUEST, stringify_request ( reject ) );
+    send_message ( session, _msg_reject, session->call->peers[session->call->peer_count - 1] );
+    free_message ( _msg_reject );
+
+    session->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
+
+    return 0;
+}
+
+
+/**
+ * @brief Terminate the current call.
+ * 
+ * @param session Control session.
+ * @return int
+ */
+int msi_stopcall ( MSISession* session ) {
+    assert ( session );
+
+    if ( !session->call )
+        return -1;
+
+    /* just terminate it */
+
+    terminate_call ( session );
+
+    return 0;
+}
\ No newline at end of file
diff --git a/toxav/toxmsi.h b/toxav/toxmsi.h
new file mode 100755
index 00000000..c45662a6
--- /dev/null
+++ b/toxav/toxmsi.h
@@ -0,0 +1,231 @@
+/**  toxmsi.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/>.
+ *
+ * 
+ *   Report bugs/suggestions to me ( mannol ) at either #tox-dev @ freenode.net:6667 or
+ *   my email: eniz_vukovic@hotmail.com
+ */
+
+#ifndef __TOXMSI
+#define __TOXMSI
+
+#include <inttypes.h>
+#include "../toxcore/tox.h"
+#include <pthread.h>
+
+/* define size for call_id */
+#define CALL_ID_LEN 12
+
+
+typedef void* ( *MSICallback ) ( void* arg );
+
+
+/**
+ * @brief Call type identifier. Also used as rtp callback prefix.
+ */
+typedef enum {
+    type_audio = 70,
+    type_video,
+} MSICallType;
+
+
+/**
+ * @brief Call state identifiers.
+ */
+typedef enum {
+    call_inviting, /* when sending call invite */
+    call_starting, /* when getting call invite */
+    call_active,
+    call_hold
+
+} MSICallState;
+
+
+
+/**
+ * @brief The call struct.
+ * 
+ */
+typedef struct _MSICall {             /* Call info structure */
+    MSICallState    state;
+
+    MSICallType     type_local;        /* Type of payload user is ending */
+    MSICallType*    type_peer;         /* Type of payload others are sending */
+
+    uint8_t         id[CALL_ID_LEN];  /* Random value identifying the call */
+
+    uint8_t*        key_local;         /* The key for encryption */
+    uint8_t*        key_peer;          /* The key for decryption */
+
+    uint8_t*        nonce_local;       /* Local nonce */
+    uint8_t*        nonce_peer;        /* Peer nonce  */
+
+    int             ringing_tout_ms;   /* Ringing timeout in ms */
+
+    int             request_timer_id;  /* Timer id for outgoing request/action */
+    int             ringing_timer_id;  /* Timer id for ringing timeout */
+
+    pthread_mutex_t mutex;             /* It's to be assumed that call will have
+                                         * seperate thread so add mutex
+                                         */
+    uint32_t*       peers;
+    uint16_t        peer_count;
+    
+    
+} MSICall;
+
+
+/**
+ * @brief Control session struct
+ * 
+ */
+typedef struct _MSISession {
+
+    /* Call handler */
+    struct _MSICall* call;
+
+    int            last_error_id; /* Determine the last error */
+    const uint8_t* last_error_str;
+
+    const uint8_t* user_agent;
+
+    void* agent_handler; /* Pointer to an object that is handling msi */
+    Tox*  messenger_handle;
+    
+    uint32_t frequ;
+    uint32_t call_timeout; /* Time of the timeout for some action to end; 0 if infinite */
+    
+
+} MSISession;
+
+
+/** 
+ * @brief Callbacks ids that handle the states 
+ */
+typedef enum {
+    /* Requests */
+    cb_oninvite,
+    cb_onstart,
+    cb_oncancel,
+    cb_onreject,
+    cb_onend,
+
+    /* Responses */
+    cb_ringing,
+    cb_starting,
+    cb_ending,
+
+    /* Protocol */
+    cb_error,
+    cb_timeout,
+
+} MSICallbackID;
+
+
+/**
+ * @brief Callback setter.
+ * 
+ * @param callback The callback.
+ * @param id The id.
+ * @return void
+ */
+void msi_register_callback(MSICallback callback, MSICallbackID id);
+
+
+/**
+ * @brief Start the control session.
+ * 
+ * @param messenger Tox* object.
+ * @param user_agent User agent, i.e. 'Venom'; 'QT-gui'
+ * @return MSISession* The created session.
+ * @retval NULL Error occured.
+ */
+MSISession* msi_init_session ( Tox* messenger, const uint8_t* user_agent );
+
+
+/**
+ * @brief Terminate control session.
+ * 
+ * @param session The session
+ * @return int
+ */
+int msi_terminate_session ( MSISession* session );
+
+
+/**
+ * @brief Send invite request to friend_id.
+ * 
+ * @param session Control session.
+ * @param call_type Type of the call. Audio or Video(both audio and video)
+ * @param rngsec Ringing timeout.
+ * @param friend_id The friend.
+ * @return int
+ */
+int msi_invite ( MSISession* session, MSICallType call_type, uint32_t rngsec, uint32_t friend_id );
+
+
+/**
+ * @brief Hangup active call.
+ * 
+ * @param session Control session.
+ * @return int 
+ * @retval -1 Error occured.
+ * @retval 0 Success.
+ */
+int msi_hangup ( MSISession* session );
+
+
+/**
+ * @brief Answer active call request.
+ * 
+ * @param session Control session.
+ * @param call_type Answer with Audio or Video(both).
+ * @return int
+ */
+int msi_answer ( MSISession* session, MSICallType call_type );
+
+
+/**
+ * @brief Cancel request.
+ * 
+ * @param session Control session.
+ * @param friend_id The friend.
+ * @return int
+ */
+int msi_cancel ( MSISession* session, int friend_id );
+
+
+/**
+ * @brief Reject request.
+ * 
+ * @param session Control session.
+ * @return int
+ */
+int msi_reject ( MSISession* session );
+
+
+/**
+ * @brief Terminate the current call.
+ * 
+ * @param session Control session.
+ * @return int
+ */
+int msi_stopcall ( MSISession* session );
+
+#endif /* __TOXMSI */
diff --git a/toxav/toxrtp.c b/toxav/toxrtp.c
new file mode 100755
index 00000000..2363deea
--- /dev/null
+++ b/toxav/toxrtp.c
@@ -0,0 +1,878 @@
+/**  toxrtp.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/>.
+ *
+ * 
+ *   Report bugs/suggestions to me ( mannol ) at either #tox-dev @ freenode.net:6667 or
+ *   my email: eniz_vukovic@hotmail.com
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include "toxrtp.h"
+#include <assert.h>
+#include <limits.h>
+#include <pthread.h>
+
+#include "../toxcore/util.h"
+#include "../toxcore/network.h"
+#include "../toxcore/net_crypto.h"
+#include "../toxcore/Messenger.h"
+
+#define PAYLOAD_ID_VALUE_OPUS 1
+#define PAYLOAD_ID_VALUE_VP8  2
+
+#define MAX_SEQU_NUM 65535
+
+#define size_32 4
+
+#define inline__ inline __attribute__((always_inline))
+
+
+#define ADD_FLAG_VERSION(_h, _v) do { ( _h->flags ) &= 0x3F; ( _h->flags ) |= ( ( ( _v ) << 6 ) & 0xC0 ); } while(0)
+#define ADD_FLAG_PADDING(_h, _v) do { if ( _v > 0 ) _v = 1; ( _h->flags ) &= 0xDF; ( _h->flags ) |= ( ( ( _v ) << 5 ) & 0x20 ); } while(0)
+#define ADD_FLAG_EXTENSION(_h, _v) do { if ( _v > 0 ) _v = 1; ( _h->flags ) &= 0xEF;( _h->flags ) |= ( ( ( _v ) << 4 ) & 0x10 ); } while(0)
+#define ADD_FLAG_CSRCC(_h, _v) do { ( _h->flags ) &= 0xF0; ( _h->flags ) |= ( ( _v ) & 0x0F ); } while(0)
+#define ADD_SETTING_MARKER(_h, _v) do { if ( _v > 1 ) _v = 1; ( _h->marker_payloadt ) &= 0x7F; ( _h->marker_payloadt ) |= ( ( ( _v ) << 7 ) /*& 0x80 */ ); } while(0)
+#define ADD_SETTING_PAYLOAD(_h, _v) do { if ( _v > 127 ) _v = 127; ( _h->marker_payloadt ) &= 0x80; ( _h->marker_payloadt ) |= ( ( _v ) /* & 0x7F */ ); } while(0)
+
+#define GET_FLAG_VERSION(_h) (( _h->flags & 0xd0 ) >> 6)
+#define GET_FLAG_PADDING(_h) (( _h->flags & 0x20 ) >> 5)
+#define GET_FLAG_EXTENSION(_h) (( _h->flags & 0x10 ) >> 4)
+#define GET_FLAG_CSRCC(_h) ( _h->flags & 0x0f )
+#define GET_SETTING_MARKER(_h) (( _h->marker_payloadt ) >> 7)
+#define GET_SETTING_PAYLOAD(_h) ((_h->marker_payloadt) & 0x7f)
+
+
+
+/**
+ * @brief Checks if message came in late.
+ * 
+ * @param session Control session.
+ * @param msg The message.
+ * @return int
+ * @retval -1 The message came in order.
+ * @retval 0 The message came late.
+ */
+inline__ int check_late_message (RTPSession* session, RTPMessage* msg)
+{
+    /*
+     * Check Sequence number. If this new msg has lesser number then the session->rsequnum
+     * it shows that the message came in late. Also check timestamp to be 100% certain.
+     * 
+     */
+    return ( msg->header->sequnum < session->rsequnum && msg->header->timestamp < session->timestamp ) ? 0 : -1;
+}
+
+
+/**
+ * @brief Increases nonce value by 'target'
+ * 
+ * @param nonce The nonce
+ * @param target The target
+ * @return void
+ */
+inline__ void increase_nonce(uint8_t* nonce, uint16_t target)
+{
+    uint16_t _nonce_counter = ((uint16_t)(
+        (((uint16_t) nonce [crypto_box_NONCEBYTES - 1]) << 8 ) |
+        (((uint16_t) nonce [crypto_box_NONCEBYTES - 2])      )));
+    
+    /* Check overflow */
+    if (_nonce_counter > USHRT_MAX - target ) { /* 2 bytes are not long enough */
+        int _it = 3;
+        while ( _it <= crypto_box_NONCEBYTES ) _it += ++nonce[crypto_box_NONCEBYTES - _it] ? crypto_box_NONCEBYTES : 1;
+        
+        _nonce_counter = _nonce_counter - (USHRT_MAX - target ); /* Assign the rest of it */
+    } else { /* Increase nonce */
+        
+        _nonce_counter+= target;
+    }
+    
+    /* Assign the 8 last bytes */
+    
+    nonce [crypto_box_NONCEBYTES - 1] = (uint8_t) (_nonce_counter >> 8);
+    nonce [crypto_box_NONCEBYTES - 2] = (uint8_t) (_nonce_counter);
+}
+
+
+/**
+ * @brief Speaks for it self.
+ * 
+ */
+static const uint32_t payload_table[] =
+{
+    8000, 8000, 8000, 8000, 8000, 8000, 16000, 8000, 8000, 8000,        /*    0-9    */
+    44100, 44100, 0, 0, 90000, 8000, 11025, 22050, 0, 0,                /*   10-19   */
+    0, 0, 0, 0, 0, 90000, 90000, 0, 90000, 0,                           /*   20-29   */
+    0, 90000, 90000, 90000, 90000, 0, 0, 0, 0, 0,                       /*   30-39   */
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   40-49   */
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   50-59   */
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   60-69   */
+    PAYLOAD_ID_VALUE_OPUS, PAYLOAD_ID_VALUE_VP8, 0, 0, 0, 0, 0, 0, 0, 0,/*   70-79   */
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   80-89   */
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   90-99   */
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*  100-109  */
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*  110-119  */
+    0, 0, 0, 0, 0, 0, 0, 0                                              /*  120-127  */
+};
+
+
+/**
+ * @brief Extracts header from payload.
+ * 
+ * @param payload The payload.
+ * @param length The size of payload.
+ * @return RTPHeader* Extracted header.
+ * @retval NULL Error occurred while extracting header.
+ */
+RTPHeader* extract_header ( const uint8_t* payload, size_t length )
+{
+    if ( !payload ) {
+        return NULL;
+    }
+    
+    const uint8_t* _it = payload;
+    
+    RTPHeader* _retu = calloc(sizeof(RTPHeader), 1);
+    assert(_retu);
+    
+    _retu->flags = *_it; ++_it;
+    
+    /* This indicates if the first 2 bytes are valid.
+     * Now it my happen that this is out of order but
+     * it cuts down chances of parsing some invalid value
+     */
+    if ( GET_FLAG_VERSION(_retu) != RTP_VERSION ){
+        /* Deallocate */
+        free(_retu);
+        return NULL;
+    }
+    
+    /*
+     * Added a check for the size of the header little sooner so
+     * I don't need to parse the other stuff if it's bad
+     */
+    uint8_t _cc = GET_FLAG_CSRCC ( _retu );
+    uint32_t _length = 12 /* Minimum header len */ + ( _cc * 4 );
+    
+    if ( length < _length ) {
+        /* Deallocate */
+        free(_retu);
+        return NULL;
+    }
+    
+    if ( _cc > 0 ) {
+        _retu->csrc = calloc ( sizeof ( uint32_t ), _cc );
+        assert(_retu->csrc);
+        
+    } else { /* But this should not happen ever */
+        /* Deallocate */
+        free(_retu);
+        return NULL;
+    }
+    
+    
+    _retu->marker_payloadt = *_it; ++_it;
+    _retu->length = _length;
+    
+    _retu->timestamp = ( ( uint32_t ) * _it         << 24 ) |
+    ( ( uint32_t ) * ( _it + 1 ) << 16 ) |
+    ( ( uint32_t ) * ( _it + 2 ) << 8 )  |
+    (              * ( _it + 3 ) ) ;
+    
+    _it += 4;
+    
+    _retu->ssrc = ( ( uint32_t ) * _it         << 24 ) |
+    ( ( uint32_t ) * ( _it + 1 ) << 16 ) |
+    ( ( uint32_t ) * ( _it + 2 ) << 8 )  |
+    ( ( uint32_t ) * ( _it + 3 ) ) ;
+    
+    
+    size_t _x;
+    for ( _x = 0; _x < _cc; _x++ ) {
+        _it += 4;
+        _retu->csrc[_x] = ( ( uint32_t ) * _it          << 24 ) |
+        ( ( uint32_t ) * ( _it + 1 )  << 16 ) |
+        ( ( uint32_t ) * ( _it + 2 )  << 8 )  |
+        ( ( uint32_t ) * ( _it + 3 ) ) ;
+    }
+    
+    return _retu;
+}
+
+/**
+ * @brief Extracts external header from payload. Must be called AFTER extract_header()!
+ * 
+ * @param payload The ITERATED payload.
+ * @param length The size of payload.
+ * @return RTPExtHeader* Extracted extension header.
+ * @retval NULL Error occurred while extracting extension header.
+ */
+RTPExtHeader* extract_ext_header ( const uint8_t* payload, size_t length )
+{
+    const uint8_t* _it = payload;
+    
+    RTPExtHeader* _retu = calloc(sizeof(RTPExtHeader), 1);
+    assert(_retu);
+    
+    uint16_t _ext_length = ( ( uint16_t ) * _it << 8 ) | * ( _it + 1 ); _it += 2;
+    
+    if ( length < ( _ext_length * sizeof(uint32_t) ) ) {
+        return NULL;
+    }
+    
+    _retu->length  = _ext_length;
+    _retu->type = ( ( uint16_t ) * _it << 8 ) | * ( _it + 1 ); _it -= 2;
+    
+    _retu->table = calloc(sizeof(uint32_t), _ext_length );
+    assert(_retu->table);
+    
+    uint32_t* _table = _retu->table;
+    size_t _i;
+    for ( _i = 0; _i < _ext_length; _i++ ) {
+        _it += 4;
+        _table[_i] = ( ( uint32_t ) * _it         << 24 ) |
+        ( ( uint32_t ) * ( _it + 1 ) << 16 ) |
+        ( ( uint32_t ) * ( _it + 2 ) << 8 )  |
+        ( ( uint32_t ) * ( _it + 3 ) ) ;
+    }
+    
+    return _retu;
+}
+
+/**
+ * @brief Adds header to payload. Make sure _payload_ has enough space.
+ * 
+ * @param header The header.
+ * @param payload The payload.
+ * @return uint8_t* Iterated position.
+ */
+uint8_t* add_header ( RTPHeader* header, uint8_t* payload )
+{
+    uint8_t _cc = GET_FLAG_CSRCC ( header );
+    
+    uint8_t* _it = payload;
+    
+    
+    /* Add sequence number first */
+    *_it = ( header->sequnum >> 8 ); ++_it;
+    *_it = ( header->sequnum ); ++_it;
+     
+    *_it = header->flags; ++_it;
+    *_it = header->marker_payloadt; ++_it;
+     
+     
+    uint32_t _timestamp = header->timestamp;
+    *_it = ( _timestamp >> 24 ); ++_it;
+    *_it = ( _timestamp >> 16 ); ++_it;
+    *_it = ( _timestamp >> 8 ); ++_it;
+    *_it = ( _timestamp ); ++_it;
+    
+    uint32_t _ssrc = header->ssrc;
+    *_it = ( _ssrc >> 24 ); ++_it;
+    *_it = ( _ssrc >> 16 ); ++_it;
+    *_it = ( _ssrc >> 8 ); ++_it;
+    *_it = ( _ssrc );
+    
+    uint32_t *_csrc = header->csrc;
+    size_t _x;
+    for ( _x = 0; _x < _cc; _x++ ) {
+        ++_it;
+        *_it = ( _csrc[_x] >> 24 );  ++_it;
+        *_it = ( _csrc[_x] >> 16 );  ++_it;
+        *_it = ( _csrc[_x] >> 8 );   ++_it;
+        *_it = ( _csrc[_x] );
+    }
+    
+    return _it;
+}
+
+/**
+ * @brief Adds extension header to payload. Make sure _payload_ has enough space.
+ * 
+ * @param header The header.
+ * @param payload The payload.
+ * @return uint8_t* Iterated position.
+ */
+uint8_t* add_ext_header ( RTPExtHeader* header, uint8_t* payload )
+{
+    uint8_t* _it = payload;
+    
+    *_it = ( header->length >> 8 ); _it++;
+    *_it = ( header->length ); _it++;
+    
+    *_it = ( header->type >> 8 ); ++_it;
+    *_it = ( header->type );
+    
+    size_t x;
+    
+    uint32_t* _hd_ext = header->table;
+    for ( x = 0; x < header->length; x++ ) {
+        ++_it;
+        *_it = ( _hd_ext[x] >> 24 );  ++_it;
+        *_it = ( _hd_ext[x] >> 16 );  ++_it;
+        *_it = ( _hd_ext[x] >> 8 );  ++_it;
+        *_it = ( _hd_ext[x] );
+    }
+    
+    return _it;
+}
+
+/**
+ * @brief Builds header from control session values.
+ * 
+ * @param session Control session.
+ * @return RTPHeader* Created header.
+ */
+RTPHeader* build_header ( RTPSession* session )
+{
+    RTPHeader* _retu;
+    _retu = calloc ( sizeof * _retu, 1 );
+    assert(_retu);
+    
+    ADD_FLAG_VERSION ( _retu, session->version );
+    ADD_FLAG_PADDING ( _retu, session->padding );
+    ADD_FLAG_EXTENSION ( _retu, session->extension );
+    ADD_FLAG_CSRCC ( _retu, session->cc );
+    ADD_SETTING_MARKER ( _retu, session->marker );
+    ADD_SETTING_PAYLOAD ( _retu, session->payload_type );
+    
+    _retu->sequnum = session->sequnum;
+    _retu->timestamp = ((uint32_t)(current_time() / 1000)); /* micro to milli */
+    _retu->ssrc = session->ssrc;
+    
+    if ( session->cc > 0 ) {
+        _retu->csrc = calloc(sizeof(uint32_t), session->cc);
+        assert(_retu->csrc);
+        
+        int i;
+        
+        for ( i = 0; i < session->cc; i++ ) {
+            _retu->csrc[i] = session->csrc[i];
+        }
+    } else {
+        _retu->csrc = NULL;
+    }
+    
+    _retu->length = 12 /* Minimum header len */ + ( session->cc * size_32 );
+    
+    return _retu;
+}
+
+
+/**
+ * @brief Parses data into RTPMessage struct. Stores headers separately from the payload data
+ *        and so the length variable is set accordingly. _sequnum_ argument is
+ *        passed by the handle_packet() since it's parsed already.
+ * 
+ * @param session Control session.
+ * @param sequnum Sequence number that's parsed from payload in handle_packet()
+ * @param data Payload data.
+ * @param length Payload size.
+ * @return RTPMessage*
+ * @retval NULL Error occurred.
+ */
+RTPMessage* msg_parse ( RTPSession* session, uint16_t sequnum, const uint8_t* data, uint32_t length )
+{
+    assert( length != -1);
+    
+    RTPMessage* _retu = calloc(sizeof(RTPMessage), 1);
+    assert(_retu);
+    
+    _retu->header = extract_header ( data, length ); /* It allocates memory and all */
+    
+    if ( !_retu->header ){
+        free(_retu);
+        return NULL;
+    }
+    _retu->header->sequnum = sequnum;
+    
+    _retu->length = length - _retu->header->length;
+    
+    uint16_t _from_pos = _retu->header->length - 2 /* Since sequ num is excluded */ ;
+    
+    
+    if ( GET_FLAG_EXTENSION ( _retu->header ) ) {
+        _retu->ext_header = extract_ext_header ( data + _from_pos, length );
+        if ( _retu->ext_header ){
+            _retu->length -= ( 4 /* Minimum ext header len */ + _retu->ext_header->length * size_32 );
+            _from_pos += ( 4 /* Minimum ext header len */ + _retu->ext_header->length * size_32 );
+        } else {
+            free (_retu->ext_header);
+            free (_retu->header);
+            free (_retu);
+            return NULL;
+        }
+    } else {
+        _retu->ext_header = NULL;
+    }
+    
+    /* Get the payload */
+    _retu->data = calloc ( sizeof ( uint8_t ), _retu->length );
+    assert(_retu->data);
+    
+    memcpy ( _retu->data, data + _from_pos, length - _from_pos );
+    
+    _retu->next = NULL;
+    
+    
+    if ( session && check_late_message ( session, _retu) < 0 ){
+        session->rsequnum = _retu->header->sequnum;
+        session->timestamp = _retu->header->timestamp;
+    }
+    
+    return _retu;
+}
+
+/**
+ * @brief Callback for networking core.
+ * 
+ * @param object RTPSession object.
+ * @param ip_port Where the message comes from.
+ * @param data Message data.
+ * @param length Message length.
+ * @return int
+ * @retval -1 Error occurred.
+ * @retval 0 Success.
+ */
+int rtp_handle_packet ( void* object, IP_Port ip_port, uint8_t* data, uint32_t length )
+{
+    RTPSession* _session = object;
+    RTPMessage* _msg;
+    
+    if ( !_session )
+        return -1;
+    
+    uint8_t _plain[MAX_UDP_PACKET_SIZE];
+    
+    uint16_t _sequnum = ( ( uint16_t ) data[1] << 8 ) | data[2];
+        
+    /* Clculate the right nonce */
+    uint8_t _calculated[crypto_box_NONCEBYTES];
+    memcpy(_calculated, _session->decrypt_nonce, crypto_box_NONCEBYTES);
+    increase_nonce ( _calculated, _sequnum );
+    
+    /* Decrypt message */
+    int _decrypted_length = decrypt_data_symmetric(
+        (uint8_t*)_session->decrypt_key, _calculated, data + 3, length - 3, _plain );
+    
+    /* This packet is either not encrypted properly or late 
+     */
+    if ( -1 == _decrypted_length ){
+        
+        /* If this is the case, then the packet is most likely late. 
+         * Try with old nonce cycle.
+         */
+        if ( _session->rsequnum < _sequnum ) {
+            _decrypted_length = decrypt_data_symmetric(
+                (uint8_t*)_session->decrypt_key, _session->nonce_cycle, data + 3, length - 3, _plain );
+            
+            if ( !_decrypted_length ) return -1; /* This packet is not encrypted properly */
+        
+        /* Otherwise, if decryption is ok with new cycle, set new cycle
+         */
+        } else {        
+            increase_nonce ( _calculated, MAX_SEQU_NUM );
+            _decrypted_length = decrypt_data_symmetric(
+                (uint8_t*)_session->decrypt_key, _calculated, data + 3, length - 3, _plain );
+            
+            if ( !_decrypted_length ) return -1; /* This is just an error */
+                
+            /* A new cycle setting. */
+            memcpy(_session->nonce_cycle, _session->decrypt_nonce, crypto_box_NONCEBYTES);
+            memcpy(_session->decrypt_nonce, _calculated, crypto_box_NONCEBYTES);
+        }
+    }
+    
+    _msg = msg_parse ( NULL, _sequnum, _plain, _decrypted_length );
+    
+    if ( !_msg )
+        return -1;
+    
+    /* Hopefully this goes well 
+     * NOTE: Is this even used?
+     */
+    memcpy(&_msg->from, &ip_port, sizeof(tox_IP_Port));
+    
+    /* Check if message came in late */
+    if ( check_late_message(_session, _msg) < 0 ) { /* Not late */
+        _session->rsequnum = _msg->header->sequnum;
+        _session->timestamp = _msg->header->timestamp;
+    }
+    
+    pthread_mutex_lock(&_session->mutex);
+    
+    if ( _session->last_msg ) {
+        _session->last_msg->next = _msg;
+        _session->last_msg = _msg;
+    } else {
+        _session->last_msg = _session->oldest_msg = _msg;
+    }
+    
+    pthread_mutex_unlock(&_session->mutex);
+    
+    return 0;
+}
+
+
+
+/**
+ * @brief Stores headers and payload data in one container ( data )
+ *        and the length is set accordingly. Returned message is used for sending _only_.
+ * 
+ * @param session The control session.
+ * @param data Payload data to send ( This is what you pass ).
+ * @param length Size of the payload data.
+ * @return RTPMessage* Created message.
+ * @retval NULL Error occurred.
+ */
+RTPMessage* rtp_new_message ( RTPSession* session, const uint8_t* data, uint32_t length )
+{
+    if ( !session )
+        return NULL;
+    
+    uint8_t* _from_pos;
+    RTPMessage* _retu = calloc(sizeof(RTPMessage), 1);
+    assert(_retu);
+    
+    /* Sets header values and copies the extension header in _retu */
+    _retu->header = build_header ( session ); /* It allocates memory and all */
+    _retu->ext_header = session->ext_header;
+    
+    
+    uint32_t _total_length = length + _retu->header->length;
+    
+    if ( _retu->ext_header ) {
+        _total_length += ( 4 /* Minimum ext header len */ + _retu->ext_header->length * size_32 );
+        /* Allocate Memory for _retu->_data */
+        _retu->data = calloc ( sizeof _retu->data, _total_length );
+        assert(_retu->data);
+        
+        _from_pos = add_header ( _retu->header, _retu->data );
+        _from_pos = add_ext_header ( _retu->ext_header, _from_pos + 1 );
+    } else {
+        /* Allocate Memory for _retu->_data */
+        _retu->data = calloc ( sizeof _retu->data, _total_length );
+        assert(_retu->data);
+        
+        _from_pos = add_header ( _retu->header, _retu->data );
+    }
+    
+    /*
+     * Parses the extension header into the message
+     * Of course if any
+     */
+    
+    /* Appends _data on to _retu->_data */
+    memcpy ( _from_pos + 1, data, length );
+    
+    _retu->length = _total_length;
+    
+    _retu->next = NULL;
+    
+    return _retu;
+}
+
+
+/********************************************************************************************************************  
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ * 
+ * 
+ * 
+ * PUBLIC API FUNCTIONS IMPLEMENTATIONS
+ * 
+ * 
+ * 
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************
+ ********************************************************************************************************************/
+
+
+
+
+
+
+
+
+
+/**
+ * @brief Release all messages held by session.
+ * 
+ * @param session The session.
+ * @return int
+ * @retval -1 Error occurred.
+ * @retval 0 Success.
+ */
+int rtp_release_session_recv ( RTPSession* session )
+{
+    if ( !session ){
+        return -1;
+    }
+    
+    RTPMessage* _tmp,* _it;
+    
+    pthread_mutex_lock(&session->mutex);
+    
+    for ( _it = session->oldest_msg; _it; _it = _tmp ){
+        _tmp = _it->next;
+        rtp_free_msg( session, _it);
+    }
+    
+    session->last_msg = session->oldest_msg = NULL;
+    
+    pthread_mutex_unlock(&session->mutex);
+    
+    return 0;
+}
+
+
+/**
+ * @brief Get's oldes message in the list.
+ * 
+ * @param session Where the list is.
+ * @return RTPMessage* The message. You _must_ call rtp_msg_free() to free it.
+ * @retval NULL No messages in the list, or no list.
+ */
+RTPMessage* rtp_recv_msg ( RTPSession* session )
+{
+    if ( !session )
+        return NULL;
+    
+    RTPMessage* _retu = session->oldest_msg;
+    
+    pthread_mutex_lock(&session->mutex);
+    
+    if ( _retu )
+        session->oldest_msg = _retu->next;
+    
+    if ( !session->oldest_msg )
+        session->last_msg = NULL;
+    
+    pthread_mutex_unlock(&session->mutex);
+    
+    return _retu;
+}
+
+
+/**
+ * @brief Sends data to _RTPSession::dest
+ * 
+ * @param session The session.
+ * @param messenger Tox* object.
+ * @param data The payload.
+ * @param length Size of the payload.
+ * @return int
+ * @retval -1 On error.
+ * @retval 0 On success.
+ */
+int rtp_send_msg ( RTPSession* session, Tox* messenger, const uint8_t* data, uint16_t length )
+{
+    RTPMessage* msg = rtp_new_message (session, data, length);
+    
+    if ( !msg ) return -1;    
+    
+    uint8_t _send_data [ MAX_UDP_PACKET_SIZE ];
+    
+    _send_data[0] = session->prefix;
+    
+    /* Generate the right nonce */
+    uint8_t _calculated[crypto_box_NONCEBYTES];
+    memcpy(_calculated, session->encrypt_nonce, crypto_box_NONCEBYTES);
+    increase_nonce ( _calculated, msg->header->sequnum );
+    
+    /* Need to skip 2 bytes that are for sequnum */
+    int encrypted_length = encrypt_data_symmetric(
+        (uint8_t*) session->encrypt_key, _calculated, msg->data + 2, msg->length - 2, _send_data + 3 );
+    
+    int full_length = encrypted_length + 3;
+    
+    _send_data[1] = msg->data[0];
+    _send_data[2] = msg->data[1];
+    
+    
+    if ( full_length != sendpacket ( ((Messenger*)messenger)->net, *((IP_Port*) &session->dest), _send_data, full_length) ) {
+        printf("Rtp error: %s\n", strerror(errno));
+        return -1;
+    }
+    
+    
+    /* Set sequ number */
+    if ( session->sequnum >= MAX_SEQU_NUM ) {
+        session->sequnum = 0;
+        memcpy(session->encrypt_nonce, _calculated, crypto_box_NONCEBYTES);
+    } else {
+        session->sequnum++;
+    }
+    
+    rtp_free_msg ( session, msg );
+    return 0;
+}
+
+
+/**
+ * @brief Speaks for it self.
+ * 
+ * @param session The control session msg belongs to. It can be NULL.
+ * @param msg The message.
+ * @return void
+ */
+void rtp_free_msg ( RTPSession* session, RTPMessage* msg )
+{
+    free ( msg->data );
+    
+    if ( !session ){
+        free ( msg->header->csrc );
+        if ( msg->ext_header ){
+            free ( msg->ext_header->table );
+            free ( msg->ext_header );
+        }
+    } else {
+        if ( session->csrc != msg->header->csrc )
+            free ( msg->header->csrc );
+        if ( msg->ext_header && session->ext_header != msg->ext_header ) {
+            free ( msg->ext_header->table );
+            free ( msg->ext_header );
+        }
+    }
+    
+    free ( msg->header );
+    free ( msg );
+}
+
+
+/**
+ * @brief Must be called before calling any other rtp function. It's used
+ *        to initialize RTP control session.
+ * 
+ * @param payload_type Type of payload used to send. You can use values in toxmsi.h::MSICallType
+ * @param messenger Tox* object.
+ * @param friend_num Friend id.
+ * @param encrypt_key Speaks for it self.
+ * @param decrypt_key Speaks for it self.
+ * @param encrypt_nonce Speaks for it self.
+ * @param decrypt_nonce Speaks for it self.
+ * @return RTPSession* Created control session.
+ * @retval NULL Error occurred.
+ */
+RTPSession* rtp_init_session ( int            payload_type, 
+                               Tox*           messenger, 
+                               int            friend_num, 
+                               const uint8_t* encrypt_key, 
+                               const uint8_t* decrypt_key, 
+                               const uint8_t* encrypt_nonce, 
+                               const uint8_t* decrypt_nonce 
+)
+{    
+    Messenger* _messenger_casted = (Messenger*) messenger;
+    
+    IP_Port _dest = get_friend_ipport(_messenger_casted, friend_num );
+    
+    /* This should be enough eh? */
+    if ( _dest.port == 0) {
+        return NULL;
+    }
+    
+    RTPSession* _retu = calloc(sizeof(RTPSession), 1);
+    assert(_retu);
+    
+    networking_registerhandler(_messenger_casted->net, payload_type, rtp_handle_packet, _retu);
+    
+    _retu->version = RTP_VERSION;   /* It's always 2 */
+    _retu->padding = 0;             /* If some additional data is needed about the packet */
+    _retu->extension = 0;           /* If extension to header is needed */
+    _retu->cc        = 1;           /* Amount of contributors */
+    _retu->csrc      = NULL;        /* Container */
+    _retu->ssrc      = randombytes_random();
+    _retu->marker    = 0;
+    _retu->payload_type = payload_table[payload_type];        
+    
+    _retu->dest = *((tox_IP_Port*)&_dest);
+    
+    _retu->rsequnum = _retu->sequnum = 1;
+    
+    _retu->ext_header = NULL; /* When needed allocate */
+    _retu->framerate = -1;
+    _retu->resolution = -1;
+    
+    _retu->encrypt_key = encrypt_key;
+    _retu->decrypt_key = decrypt_key;
+    
+    /* Need to allocate new memory */
+    _retu->encrypt_nonce = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES ); assert(_retu->encrypt_nonce);
+    _retu->decrypt_nonce = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES ); assert(_retu->decrypt_nonce);
+    _retu->nonce_cycle   = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES ); assert(_retu->nonce_cycle);
+    
+    memcpy(_retu->encrypt_nonce, encrypt_nonce, crypto_box_NONCEBYTES);    
+    memcpy(_retu->decrypt_nonce, decrypt_nonce, crypto_box_NONCEBYTES);
+    memcpy(_retu->nonce_cycle  , decrypt_nonce, crypto_box_NONCEBYTES);
+    
+    _retu->csrc = calloc(sizeof(uint32_t), 1);
+    assert(_retu->csrc);
+    
+    _retu->csrc[0] = _retu->ssrc; /* Set my ssrc to the list receive */
+    
+    /* Also set payload type as prefix */
+    _retu->prefix = payload_type;
+    
+    _retu->oldest_msg = _retu->last_msg = NULL;
+    
+    pthread_mutex_init(&_retu->mutex, NULL);
+    /*
+     * 
+     */
+    return _retu;
+}
+
+
+/**
+ * @brief Terminate the session.
+ * 
+ * @param session The session.
+ * @param messenger The messenger who owns the session
+ * @return int
+ * @retval -1 Error occurred.
+ * @retval 0 Success.
+ */
+int rtp_terminate_session ( RTPSession* session, Tox* messenger )
+{
+    if ( !session )
+        return -1;
+    
+    networking_registerhandler(((Messenger*)messenger)->net, session->prefix, NULL, NULL);
+    
+    free ( session->ext_header );
+    free ( session->csrc );
+    free ( session->decrypt_nonce );
+    free ( session->encrypt_nonce );
+    free ( session->nonce_cycle );
+    
+    pthread_mutex_destroy(&session->mutex);
+    
+    /* And finally free session */
+    free ( session );
+    
+    return 0;
+}
\ No newline at end of file
diff --git a/toxav/toxrtp.h b/toxav/toxrtp.h
new file mode 100755
index 00000000..b4275aba
--- /dev/null
+++ b/toxav/toxrtp.h
@@ -0,0 +1,211 @@
+/**  toxrtp.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/>.
+ *
+ * 
+ *   Report bugs/suggestions to me ( mannol ) at either #tox-dev @ freenode.net:6667 or
+ *   my email: eniz_vukovic@hotmail.com
+ */
+
+#ifndef __TOXRTP
+#define __TOXRTP
+
+#define RTP_VERSION 2
+#include <inttypes.h>
+#include "../toxcore/tox.h"
+
+/**
+ * Standard rtp header
+ */
+
+typedef struct _RTPHeader {
+    uint8_t   flags;             /* Version(2),Padding(1), Ext(1), Cc(4) */
+    uint8_t   marker_payloadt;   /* Marker(1), PlayLoad Type(7) */
+    uint16_t  sequnum;           /* Sequence Number */
+    uint32_t  timestamp;         /* Timestamp */
+    uint32_t  ssrc;              /* SSRC */
+    uint32_t* csrc;              /* CSRC's table */
+    uint32_t  length;            /* Length of the header in payload string. */
+
+} RTPHeader;
+
+
+/**
+ * @brief Standard rtp extension header.
+ * 
+ */
+typedef struct _RTPExtHeader {
+    uint16_t  type;          /* Extension profile */
+    uint16_t  length;        /* Number of extensions */
+    uint32_t* table;         /* Extension's table */
+    
+} RTPExtHeader;
+
+
+/**
+ * @brief Standard rtp message.
+ * 
+ */
+typedef struct _RTPMessage {
+    RTPHeader*    header;
+    RTPExtHeader* ext_header;
+
+    uint8_t*      data;
+    uint32_t      length;
+    tox_IP_Port   from;
+
+    struct _RTPMessage*   next;
+} RTPMessage;
+
+
+/**
+ * @brief Our main session descriptor.
+ *        It measures the session variables and controls
+ *        the entire session. There are functions for manipulating
+ *        the session so tend to use those instead of directly modifying
+ *        session parameters.
+ * 
+ */
+typedef struct _RTPSession {
+    uint8_t         version;
+    uint8_t         padding;
+    uint8_t         extension;
+    uint8_t         cc;
+    uint8_t         marker;
+    uint8_t         payload_type;
+    uint16_t        sequnum;   /* Set when sending */
+    uint16_t        rsequnum;  /* Check when recving msg */
+    uint32_t        timestamp;
+    uint32_t        ssrc;
+    uint32_t*       csrc;
+
+    /* If some additional data must be sent via message
+     * apply it here. Only by allocating this member you will be
+     * automatically placing it within a message.
+     */
+    RTPExtHeader*   ext_header;
+    
+    /* External header identifiers */
+    int             resolution;
+    int             framerate;
+
+
+    /* Since these are only references of the
+     * call structure don't allocate or free
+     */
+
+    const uint8_t*  encrypt_key;
+    const uint8_t*  decrypt_key;
+    uint8_t*        encrypt_nonce;
+    uint8_t*        decrypt_nonce;
+
+    uint8_t*        nonce_cycle;
+
+    RTPMessage*     oldest_msg;
+    RTPMessage*     last_msg; /* tail */
+
+    /* Msg prefix for core to know when recving */
+    uint8_t         prefix;
+
+    pthread_mutex_t mutex;
+    tox_IP_Port     dest;
+
+} RTPSession;
+
+
+/**
+ * @brief Release all messages held by session.
+ * 
+ * @param session The session.
+ * @return int
+ * @retval -1 Error occurred.
+ * @retval 0 Success.
+ */
+int rtp_release_session_recv ( RTPSession* session );
+
+
+/**
+ * @brief Get's oldest message in the list.
+ * 
+ * @param session Where the list is.
+ * @return RTPMessage* The message. You need to call rtp_msg_free() to free it.
+ * @retval NULL No messages in the list, or no list.
+ */
+RTPMessage* rtp_recv_msg ( RTPSession* session );
+
+
+/**
+ * @brief Sends msg to _RTPSession::dest
+ * 
+ * @param session The session.
+ * @param msg The message
+ * @param messenger Tox* object.
+ * @return int
+ * @retval -1 On error.
+ * @retval 0 On success.
+ */
+int rtp_send_msg ( RTPSession* session, Tox* messenger, const uint8_t* data, uint16_t length );
+
+
+/**
+ * @brief Speaks for it self.
+ * 
+ * @param session The control session msg belongs to. It can be NULL.
+ * @param msg The message.
+ * @return void
+ */
+void rtp_free_msg ( RTPSession* session, RTPMessage* msg );
+
+
+/**
+ * @brief Must be called before calling any other rtp function. It's used
+ *        to initialize RTP control session.
+ * 
+ * @param payload_type Type of payload used to send. You can use values in toxmsi.h::MSICallType
+ * @param messenger Tox* object.
+ * @param friend_num Friend id.
+ * @param encrypt_key Speaks for it self.
+ * @param decrypt_key Speaks for it self.
+ * @param encrypt_nonce Speaks for it self.
+ * @param decrypt_nonce Speaks for it self.
+ * @return RTPSession* Created control session.
+ * @retval NULL Error occurred.
+ */
+RTPSession* rtp_init_session ( int            payload_type, 
+                               Tox*           messenger, 
+                               int            friend_num, 
+                               const uint8_t* encrypt_key, 
+                               const uint8_t* decrypt_key, 
+                               const uint8_t* encrypt_nonce, 
+                               const uint8_t* decrypt_nonce );
+
+
+/**
+ * @brief Terminate the session.
+ * 
+ * @param session The session.
+ * @param messenger The messenger who owns the session
+ * @return int
+ * @retval -1 Error occurred.
+ * @retval 0 Success.
+ */
+int rtp_terminate_session ( RTPSession* session, Tox* messenger );
+
+
+
+#endif /* __TOXRTP */