1 files changed, 606 insertions, 98 deletions

diff --git a/toxav/phone.c b/toxav/phone.c
index 6d4b5e6b..8a0a3162 100755
--- a/toxav/phone.c
+++ b/toxav/phone.c
@@ -35,18 +35,25 @@
 #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 <math.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 "../toxcore/network.h"
+#include "toxmsi.h"
+#include "toxrtp.h"
+#include "toxmedia.h"
 #include "../toxcore/event.h"
 #include "../toxcore/tox.h"
 
@@ -54,6 +61,14 @@
 #define _USERAGENT "v.0.3.0"
 
 
+struct SDL_Surface *screen;
+
+typedef struct {
+    struct SDL_Overlay *bmp;
+    int width, height;
+} VideoPicture;
+
+
 typedef struct av_friend_s {
     int _id;
     int _active; /* 0=false; 1=true; */
@@ -61,16 +76,30 @@ typedef struct av_friend_s {
 
 typedef struct av_session_s {
     MSISession* _msi;
-
     RTPSession* _rtp_audio;
     RTPSession* _rtp_video;
 
+    /* Encoding/decoding/capturing/playing */
+    
+    codec_state* cs;
+    VideoPicture    video_picture;    
+    struct ALCdevice *audio_capture_device;
+    
+    /* 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;
+    
+    /**/
+    
+    
     pthread_mutex_t _mutex;
     
     Tox* _messenger;
     av_friend_t*  _friends;
     int _friend_cout;
-    uint8_t _my_public_id[200];
+    char _my_public_id[200];
 } av_session_t;
 
 
@@ -86,7 +115,7 @@ void av_allocate_friend(av_session_t* _phone, int _id, int _active)
         _phone->_friends = realloc(_phone->_friends, sizeof(av_friend_t) * _phone->_friend_cout);
     }
     
-    if ( _id = -1 ) {
+    if ( _id == -1 ) {
         _phone->_friends->_id = _new_id;
         _new_id ++;
     } else _phone->_friends->_id = _id;
@@ -174,7 +203,7 @@ char* trim_spaces ( char* buff )
 
 static void fraddr_to_str(uint8_t *id_bin, char *id_str)
 {    
-    uint i, delta = 0, pos_extra, sum_extra = 0;
+    uint i, delta = 0, pos_extra = 0, sum_extra = 0;
     
     for (i = 0; i < TOX_FRIEND_ADDRESS_SIZE; i++) {
         sprintf(&id_str[2 * i + delta], "%02hhX", id_bin[i]);
@@ -197,127 +226,526 @@ static void fraddr_to_str(uint8_t *id_bin, char *id_str)
         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;
+/* 
+ * How av stuff _should_ look like 
+ */
+
+int display_received_frame(av_session_t* _phone, AVFrame *r_video_frame)
+{
+    codec_state* cs = _phone->cs;
+    AVPicture pict;
+    SDL_LockYUVOverlay(_phone->video_picture.bmp);
+    
+    pict.data[0] = _phone->video_picture.bmp->pixels[0];
+    pict.data[1] = _phone->video_picture.bmp->pixels[2];
+    pict.data[2] = _phone->video_picture.bmp->pixels[1];
+    pict.linesize[0] = _phone->video_picture.bmp->pitches[0];
+    pict.linesize[1] = _phone->video_picture.bmp->pitches[2];
+    pict.linesize[2] = _phone->video_picture.bmp->pitches[1];
     
+    /* Convert the image into YUV format that SDL uses */
+    sws_scale(_phone->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 );
     
-    while ( _session->call ) {
+    SDL_UnlockYUVOverlay(_phone->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(_phone->video_picture.bmp, &rect);
+    return 1;
+}
 
-        _audio_msg = rtp_recv_msg ( _rtp_audio );
-        _video_msg = rtp_recv_msg ( _rtp_video );
+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;
+}
 
-        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 );
-        }
+int video_decoder_refresh(av_session_t* _phone, int width, int height)
+{
+    printf("need to refresh\n");
+    screen = SDL_SetVideoMode(width, height, 0, 0);
+    
+    if (_phone->video_picture.bmp)
+        SDL_FreeYUVOverlay(_phone->video_picture.bmp);
+    
+    _phone->video_picture.bmp = SDL_CreateYUVOverlay(width, height, SDL_YV12_OVERLAY, screen);
+    _phone->sws_SDL_r_ctx = sws_getContext(width, height, _phone->cs->video_decoder_ctx->pix_fmt, width, height, PIX_FMT_YUV420P,
+                                       SWS_BILINEAR, NULL, NULL, NULL);
+    return 1;
+}
 
-        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 );
+void *encode_video_thread(void *arg)
+{
+    av_session_t* _phone = arg;
+    
+    codec_state *cs = _phone->cs;
+    AVPacket pkt1, *packet = &pkt1;
+    int p = 0;
+    int got_packet;
+    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);
+    _phone->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(_phone->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) {
+                
+                if (avcodec_encode_video2(cs->video_encoder_ctx, &enc_video_packet, s_video_frame, &got_packet) < 0) {
+                    printf("could not encode video frame\n");
+                    continue;
+                }
+                
+                if (!got_packet) {
+                    continue;
+                }
+                                
+                if (!enc_video_packet.data) fprintf(stderr, "video packet data is NULL\n");
+                
+                if ( 0 > rtp_send_msg ( _phone->_rtp_video, _phone->_messenger, enc_video_packet.data, enc_video_packet.size) ) {
+                    printf("Failed sending message\n");
+                }
+                
+                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(_phone->sws_ctx);
+    avcodec_close(cs->webcam_decoder_ctx);
+    avcodec_close(cs->video_encoder_ctx);
+    pthread_mutex_unlock(&cs->avcodec_mutex_lock);
+    pthread_exit ( NULL );
+}
 
-        /*
-         * 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 );
+void *encode_audio_thread(void *arg)
+{
+    av_session_t* _phone = arg;
+    
+    codec_state *cs = _phone->cs;
+    unsigned char encoded_data[4096];
+    int encoded_size = 0;
+    int16_t frame[4096];
+    int frame_size = AUDIO_FRAME_SIZE;
+    ALint sample = 0;
+    alcCaptureStart((ALCdevice*)_phone->audio_capture_device);
+    
+    while (!cs->quit && cs->send_audio) {
+        alcGetIntegerv((ALCdevice*)_phone->audio_capture_device, ALC_CAPTURE_SAMPLES, (ALCsizei)sizeof(ALint), &sample);
+        
+        if (sample >= frame_size) {
+            alcCaptureSamples((ALCdevice*)_phone->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 {
+                rtp_send_msg ( _phone->_rtp_audio, _phone->_messenger, encoded_data, encoded_size );
+            }
+        } else {
+            usleep(1000);
         }
+    }
+    
+    /* clean up codecs */
+    pthread_mutex_lock(&cs->avcodec_mutex_lock);
+    alcCaptureStop((ALCdevice*)_phone->audio_capture_device);
+    alcCaptureCloseDevice((ALCdevice*)_phone->audio_capture_device);
+    
+    pthread_mutex_unlock(&cs->avcodec_mutex_lock);
+    pthread_exit ( NULL );
+}
 
-        _audio_msg = _video_msg = NULL;
+void *decode_video_thread(void *arg)
+{
+    av_session_t* _phone = arg;
+    
+    codec_state *cs = _phone->cs;
+    cs->video_stream = 0;
+    RTPMessage *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 ( _phone->_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(_phone, width, height);
+                }
+                
+                display_received_frame(_phone, r_video_frame);
+            } else {
+                /* TODO: request the sender to create a new i-frame immediatly */
+                printf("Bad video packet\n");
+            }
+            
+            rtp_free_msg(NULL, r_msg);
+        }
         
-        /* Send ~1k messages per second 
-         * That _should_ be enough for both Audio and Video
-         */
-        usleep ( 1000 );
-        /* -------------------- */
+        usleep(1000);
     }
     
-    if ( _audio_msg ) rtp_free_msg(_rtp_audio, _audio_msg);
-    rtp_release_session_recv(_rtp_audio);
-    rtp_terminate_session(_rtp_audio, _messenger);
+    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)
+{
+    av_session_t* _phone = arg;
     
-    if ( _video_msg ) rtp_free_msg(_rtp_video, _video_msg);
-    rtp_release_session_recv(_rtp_video);
-    rtp_terminate_session(_rtp_video, _messenger);
+    codec_state *cs = _phone->cs;
+    RTPMessage *r_msg;
     
-    INFO("Media thread finished!");
-
+    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;
+    
+    uint16_t zeros[frame_size];
+    memset(zeros, 0, frame_size);
+    
+    int i;
+    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 = 0;
+    
+    opus_int16 PCM[frame_size];
+    
+    while (!cs->quit && cs->receive_audio) {
+        
+        r_msg = rtp_recv_msg ( _phone->_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(NULL, 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);
+                
+                
+            }
+        }
+        
+        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 );
 }
 
+
+
+
+
 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
-        );
+    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) )
+    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
+    );
+    
+    _phone->cs->quit = 0;
+    
+    init_encoder(_phone->cs);
+    init_decoder(_phone->cs);
+    
+    /* 
+     * Rise all threads
+     */
+    
+    /* Only checks for last peer */
+    if ( _phone->_msi->call->type_peer[0] == type_video && 0 > event.rise(encode_video_thread, _phone) )
+    {
+        INFO("Error while starting encode_video_thread()");
+        return -1;
+    }
+    
+    /* Always send audio */
+    if ( 0 > event.rise(encode_audio_thread, _phone) )
+    {
+        INFO("Error while starting encode_audio_thread()");
+        return -1;
+    }
+    
+    if ( _phone->_msi->call->type_peer[0] == type_video && 0 > event.rise(decode_video_thread, _phone) )
+    {
+        INFO("Error while starting decode_video_thread()");
+        return -1;
+    }
+    
+    if ( 0 > event.rise(decode_audio_thread, _phone) )
     {
-        printf("Error while starting phone_handle_media_transport_poll()\n");
+        INFO("Error while starting decode_audio_thread()");
         return -1;
     }
-    else return 0;
+    
+    
+    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";
+        INFO( "Incoming audio call!");
         break;
     case type_video:
-        _call_type = "video";
+        INFO( "Incoming video call!");
         break;
     }
 
-    INFO( "Incoming %s call!", _call_type );
-
+    pthread_exit(NULL);
 }
 void* callback_recv_ringing ( void* _arg )
 {
     INFO ( "Ringing!" );
+    pthread_exit(NULL);
 }
 void* callback_recv_starting ( void* _arg )
 {
@@ -327,10 +755,22 @@ void* callback_recv_starting ( void* _arg )
     } else {
         INFO ("Call started! ( press h to hangup )");
     }
+    pthread_exit(NULL);
 }
 void* callback_recv_ending ( void* _arg )
 {
+    av_session_t* _phone = ((MSISession*)_arg)->agent_handler;
+    
+    _phone->cs->send_audio = 0;
+    _phone->cs->send_video = 0;
+    _phone->cs->receive_audio = 0;
+    _phone->cs->receive_video = 0;
+    
+    /* Wait until all threads are done */
+    usleep(10000000);
+    
     INFO ( "Call ended!" );
+    pthread_exit(NULL);
 }
 
 void* callback_recv_error ( void* _arg )
@@ -338,6 +778,7 @@ void* callback_recv_error ( void* _arg )
     MSISession* _session = _arg;
 
     INFO( "Error: %s", _session->last_error_str );
+    pthread_exit(NULL);
 }
 
 void* callback_call_started ( void* _arg )
@@ -348,43 +789,45 @@ void* callback_call_started ( void* _arg )
     } else {
         INFO ("Call started! ( press h to hangup )");
     }
-
+    
+    pthread_exit(NULL);
 }
 void* callback_call_canceled ( void* _arg )
 {
     INFO ( "Call canceled!" );
+    pthread_exit(NULL);
 }
 void* callback_call_rejected ( void* _arg )
 {
     INFO ( "Call rejected!" );
+    pthread_exit(NULL);
 }
 void* callback_call_ended ( void* _arg )
 {
+    av_session_t* _phone = ((MSISession*)_arg)->agent_handler;
+    
+    _phone->cs->send_audio = 0;
+    _phone->cs->send_video = 0;
+    _phone->cs->receive_audio = 0;
+    _phone->cs->receive_video = 0;
+    
+    /* Wait until all threads are done */
+    usleep(10000000);
+    
     INFO ( "Call ended!" );
+    pthread_exit(NULL);
 }
 
 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;
+    pthread_exit(NULL);
 }
 
 av_session_t* av_init_session()
 {
     av_session_t* _retu = malloc(sizeof(av_session_t));
-
+    
     /* Initialize our mutex */
     pthread_mutex_init ( &_retu->_mutex, NULL );
 
@@ -400,13 +843,61 @@ av_session_t* av_init_session()
     _retu->_rtp_audio = NULL;
     _retu->_rtp_video = NULL;
     
+    
+    const ALchar *_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
+    int i = 0;
+    const ALchar *device_names[20];
+    
+    if ( _device_list ) {
+        INFO("\nAvailable Capture Devices are:");
+        
+        while (*_device_list ) {
+            device_names[i] = _device_list;
+            INFO("%d) %s", i, device_names[i]);
+            _device_list += strlen( _device_list ) + 1;
+            ++i;
+        }
+    }
+    
+    INFO("Enter capture device number");
+    
+    char dev[2]; char* left;
+    fgets(dev, 2, stdin);
+    long selection = strtol(dev, &left, 10);
+    
+    if ( *left ) {
+        printf("'%s' is not a number!", dev);
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+    else {
+        INFO("Selected: %d ( %s )", selection, device_names[selection]);
+    }
+    
+    _retu->cs = av_calloc(sizeof(codec_state), 1);
+    
+    _retu->audio_capture_device = 
+        (struct ALCdevice*)alcCaptureOpenDevice(
+            device_names[selection], AUDIO_SAMPLE_RATE, AL_FORMAT_MONO16, AUDIO_FRAME_SIZE * 4);
+    
+        
+    if (alcGetError((ALCdevice*)_retu->audio_capture_device) != AL_NO_ERROR) {
+        printf("Could not start capture device! %d\n", alcGetError((ALCdevice*)_retu->audio_capture_device));
+        return 0;
+    }
+    
+    
+    init_encoder(_retu->cs);
+    init_decoder(_retu->cs);
+    
+    
     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 );
+    _retu->_msi = msi_init_session ( _retu->_messenger, (const uint8_t*)_USERAGENT );
 
     if ( !_retu->_msi ) {
         fprintf ( stderr, "msi_init_session() failed\n" );
@@ -498,6 +989,20 @@ int av_add_friend(av_session_t* _phone, char* _friend_hash)
     
     return _number;
 }
+
+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;
+}
+
 /*********************************/
 
 void do_phone ( av_session_t* _phone )
@@ -512,7 +1017,7 @@ void do_phone ( av_session_t* _phone )
          "q (quit)\n"
          "================================================================================"
          );
-
+    
     while ( 1 )
     {        
         char _line [ 1500 ];
@@ -613,6 +1118,9 @@ void do_phone ( av_session_t* _phone )
             INFO("Quitting!");
             return;
         }
+        case '\n':
+        {
+        }
         default:
         {
             INFO("Invalid command!");
@@ -670,6 +1178,7 @@ int print_help ( const char* _name )
              "\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;
 }
@@ -681,13 +1190,12 @@ int main ( int argc, char* argv [] )
     
     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 ){
+    if ( *_convertable ) {
         printf("Invalid port: cannot convert string to long: %s", _convertable);
         return 1;
     }
@@ -697,7 +1205,6 @@ int main ( int argc, char* argv [] )
     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"
@@ -711,6 +1218,7 @@ int main ( int argc, char* argv [] )
     fflush(stdout);
     
     int _r;
+    int _wait_seconds = 5;
     for ( _r = 0; _r == 0; _r = av_wait_dht(_phone, _wait_seconds, _ip, _key, _port) ) _wait_seconds --;