Finished refactoring

1 files changed, 182 insertions, 189 deletions

diff --git a/toxav/toxav.c b/toxav/toxav.c
index 6f712af9..5cb614d4 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -23,7 +23,8 @@
 #include "config.h"
 #endif /* HAVE_CONFIG_H */
 
-#include "msi.h" /* Includes codec.h, rtp.h and toxav.h */
+#include "msi.h"
+#include "rtp.h"
 
 #include "../toxcore/Messenger.h"
 #include "../toxcore/logger.h"
@@ -35,20 +36,17 @@
 
 #define MAX_ENCODE_TIME_US ((1000 / 24) * 1000)
 
-enum {
-    audio_index,
-    video_index,
-};
 
 typedef struct ToxAVCall_s {
     ToxAV* av;
-    RTPSession *rtps[2]; /* Audio is first and video is second */
-    CSession *cs;
     
-    pthread_mutex_t mutex_audio_sending[1];
-    pthread_mutex_t mutex_video_sending[1];
-    /* Only audio or video can be decoded at the time */
-    pthread_mutex_t mutex_decoding[1];
+    pthread_mutex_t mutex_audio[1];
+    PAIR(RTPSession *, ACSession *) audio;
+    
+    pthread_mutex_t mutex_video[1];
+    PAIR(RTPSession *, VCSession *) video;
+    
+    pthread_mutex_t mutex[1];
     
     bool active;
     MSICall* msi_call;
@@ -57,8 +55,8 @@ typedef struct ToxAVCall_s {
     uint32_t audio_bit_rate; /* Sending audio bitrate */
     uint32_t video_bit_rate; /* Sending video bitrate */
     
-    uint8_t last_self_capabilities;
-    uint8_t last_peer_capabilities;
+    /** Required for monitoring  */
+    uint8_t previous_self_capabilities;
     
     /** Quality control */
     uint64_t time_audio_good;
@@ -181,7 +179,7 @@ void toxav_kill(ToxAV* av)
 {
     if (av == NULL)
         return;
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     
     msi_kill(av->msi);
     
@@ -194,7 +192,7 @@ void toxav_kill(ToxAV* av)
         }
     }
     
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
     pthread_mutex_destroy(av->mutex);
     free(av);
 }
@@ -212,9 +210,9 @@ uint32_t toxav_iteration_interval(const ToxAV* av)
 
 void toxav_iterate(ToxAV* av)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     if (av->calls == NULL) {
-        LOGGED_UNLOCK(av->mutex);
+        pthread_mutex_unlock(av->mutex);
         return;
     }
     
@@ -224,30 +222,36 @@ void toxav_iterate(ToxAV* av)
     ToxAVCall* i = av->calls[av->calls_head];
     for (; i; i = i->next) {
         if (i->active) {
-            LOGGED_LOCK(i->mutex_decoding);
-            LOGGED_UNLOCK(av->mutex);
+            pthread_mutex_lock(i->mutex);
+            pthread_mutex_unlock(av->mutex);
+            
+            rtp_do(i->audio.first);
+            ac_do(i->audio.second);
+            
+            rtp_do(i->video.first);
+            vc_do(i->video.second);
             
-            cs_do(i->cs);
-            rtp_do(i->rtps[audio_index]);
-            rtp_do(i->rtps[video_index]);
             qc_do(i);
             
-            if (i->last_self_capabilities & msi_CapRAudio) /* Receiving audio */
-                rc = MIN(i->cs->last_packet_frame_duration, rc);
-            if (i->last_self_capabilities & msi_CapRVideo) /* Receiving video */
-                rc = MIN(i->cs->lcfd, rc); /* TODO handle on/off */
+            if (i->msi_call->self_capabilities & msi_CapRAudio && 
+                i->msi_call->peer_capabilities & msi_CapSAudio)
+                rc = MIN(i->audio.second->last_packet_frame_duration, rc);
+            
+            if (i->msi_call->self_capabilities & msi_CapRVideo && 
+                i->msi_call->peer_capabilities & msi_CapSVideo)
+                rc = MIN(i->video.second->lcfd, rc);
             
             uint32_t fid = i->friend_id;
             
-            LOGGED_UNLOCK(i->mutex_decoding);
-            LOGGED_LOCK(av->mutex);
+            pthread_mutex_unlock(i->mutex);
+            pthread_mutex_lock(av->mutex);
             
             /* In case this call is popped from container stop iteration */
             if (call_get(av, fid) != i)
                 break;
         }
     }
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
     
     av->interval = rc < av->dmssa ? 0 : (rc - av->dmssa);
     av->dmsst += current_time_monotonic() - start;
@@ -261,46 +265,46 @@ void toxav_iterate(ToxAV* av)
 
 bool toxav_call(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL* error)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     ToxAVCall* call = call_new(av, friend_number, error);
     if (call == NULL) {
-        LOGGED_UNLOCK(av->mutex);
+        pthread_mutex_unlock(av->mutex);
         return false;
     }
     
     call->audio_bit_rate = audio_bit_rate;
     call->video_bit_rate = video_bit_rate;
     
-    call->last_self_capabilities = msi_CapRAudio | msi_CapRVideo;
+    call->previous_self_capabilities = msi_CapRAudio | msi_CapRVideo;
     
-    call->last_self_capabilities |= audio_bit_rate > 0 ? msi_CapSAudio : 0;
-    call->last_self_capabilities |= video_bit_rate > 0 ? msi_CapSVideo : 0;
+    call->previous_self_capabilities |= audio_bit_rate > 0 ? msi_CapSAudio : 0;
+    call->previous_self_capabilities |= video_bit_rate > 0 ? msi_CapSVideo : 0;
     
-    if (msi_invite(av->msi, &call->msi_call, friend_number, call->last_self_capabilities) != 0) {
+    if (msi_invite(av->msi, &call->msi_call, friend_number, call->previous_self_capabilities) != 0) {
         call_remove(call);
         if (error)
             *error = TOXAV_ERR_CALL_MALLOC;
-        LOGGED_UNLOCK(av->mutex);
+        pthread_mutex_unlock(av->mutex);
         return false;
     }
     
     call->msi_call->av_call = call;
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
     
     return true;
 }
 
 void toxav_callback_call(ToxAV* av, toxav_call_cb* function, void* user_data)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     av->ccb.first = function;
     av->ccb.second = user_data;
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
 }
 
 bool toxav_answer(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_ANSWER* error)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     
     TOXAV_ERR_ANSWER rc = TOXAV_ERR_ANSWER_OK;
     if (m_friend_exists(av->m, friend_number) == 0) {
@@ -329,17 +333,17 @@ bool toxav_answer(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, ui
     call->audio_bit_rate = audio_bit_rate;
     call->video_bit_rate = video_bit_rate;
     
-    call->last_self_capabilities = msi_CapRAudio | msi_CapRVideo;
+    call->previous_self_capabilities = msi_CapRAudio | msi_CapRVideo;
     
-    call->last_self_capabilities |= audio_bit_rate > 0 ? msi_CapSAudio : 0;
-    call->last_self_capabilities |= video_bit_rate > 0 ? msi_CapSVideo : 0;
+    call->previous_self_capabilities |= audio_bit_rate > 0 ? msi_CapSAudio : 0;
+    call->previous_self_capabilities |= video_bit_rate > 0 ? msi_CapSVideo : 0;
     
-    if (msi_answer(call->msi_call, call->last_self_capabilities) != 0)
+    if (msi_answer(call->msi_call, call->previous_self_capabilities) != 0)
         rc = TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING; /* the only reason for msi_answer to fail */
     
     
 END:
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
     
     if (error)
         *error = rc;
@@ -349,15 +353,15 @@ END:
 
 void toxav_callback_call_state(ToxAV* av, toxav_call_state_cb* function, void* user_data)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     av->scb.first = function;
     av->scb.second = user_data;
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
 }
 
 bool toxav_call_control(ToxAV* av, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL* error)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     TOXAV_ERR_CALL_CONTROL rc = TOXAV_ERR_CALL_CONTROL_OK;
     
     if (m_friend_exists(av->m, friend_number) == 0) {
@@ -381,18 +385,18 @@ bool toxav_call_control(ToxAV* av, uint32_t friend_number, TOXAV_CALL_CONTROL co
             
             /* Only act if paused and had media transfer active before */
             if (call->msi_call->self_capabilities == 0 && 
-                call->last_self_capabilities ) {
+                call->previous_self_capabilities ) {
                 
                 if (msi_change_capabilities(call->msi_call, 
-                    call->last_self_capabilities) == -1) {
+                    call->previous_self_capabilities) == -1) {
                     /* The only reason for this function to fail is invalid state 
                      * ( not active ) */
                     rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL;
                     goto END;
                 }
                 
-                rtp_start_receiving(call->rtps[audio_index]);
-                rtp_start_receiving(call->rtps[video_index]);
+                rtp_start_receiving(call->audio.first);
+                rtp_start_receiving(call->video.first);
             }
         } break;
         
@@ -404,7 +408,7 @@ bool toxav_call_control(ToxAV* av, uint32_t friend_number, TOXAV_CALL_CONTROL co
             
             /* Only act if not already paused */
             if (call->msi_call->self_capabilities) {
-                call->last_self_capabilities = call->msi_call->self_capabilities;
+                call->previous_self_capabilities = call->msi_call->self_capabilities;
                 
                 if (msi_change_capabilities(call->msi_call, 0) == -1 ) {
                     /* The only reason for this function to fail is invalid state 
@@ -413,8 +417,8 @@ bool toxav_call_control(ToxAV* av, uint32_t friend_number, TOXAV_CALL_CONTROL co
                     goto END;
                 }
                 
-                rtp_stop_receiving(call->rtps[audio_index]);
-                rtp_stop_receiving(call->rtps[video_index]);
+                rtp_stop_receiving(call->audio.first);
+                rtp_stop_receiving(call->video.first);
             }
         } break;
         
@@ -442,7 +446,7 @@ bool toxav_call_control(ToxAV* av, uint32_t friend_number, TOXAV_CALL_CONTROL co
                     goto END;
                 }
                 
-                rtp_stop_receiving(call->rtps[audio_index]);
+                rtp_stop_receiving(call->audio.first);
             } else {
                 /* This call was already muted so notify the friend that he can
                  * start sending audio again
@@ -455,7 +459,7 @@ bool toxav_call_control(ToxAV* av, uint32_t friend_number, TOXAV_CALL_CONTROL co
                     goto END;
                 }
                 
-                rtp_start_receiving(call->rtps[audio_index]);
+                rtp_start_receiving(call->audio.first);
             }
         } break;
         
@@ -474,7 +478,7 @@ bool toxav_call_control(ToxAV* av, uint32_t friend_number, TOXAV_CALL_CONTROL co
                     goto END;
                 }
                 
-                rtp_stop_receiving(call->rtps[video_index]);
+                rtp_stop_receiving(call->video.first);
             } else {
                 /* This call was already muted so notify the friend that he can
                  * start sending video again
@@ -487,13 +491,13 @@ bool toxav_call_control(ToxAV* av, uint32_t friend_number, TOXAV_CALL_CONTROL co
                     goto END;
                 }
                 
-                rtp_start_receiving(call->rtps[video_index]);
+                rtp_start_receiving(call->video.first);
             }
         } break;
     }
     
 END:
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
     
     if (error)
         *error = rc;
@@ -516,19 +520,19 @@ bool toxav_set_audio_bit_rate(ToxAV* av, uint32_t friend_number, uint32_t audio_
         goto END;
     }
     
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     call = call_get(av, friend_number);
     if (call == NULL || !call->active || call->msi_call->state != msi_CallActive) {
-        LOGGED_UNLOCK(av->mutex);
+        pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_BIT_RATE_FRIEND_NOT_IN_CALL;
         goto END;
     }
     
     /* Decoding mutex is locked because of quality control */
-    LOGGED_LOCK(call->mutex_decoding);
+    pthread_mutex_lock(call->mutex);
     call->audio_bit_rate = audio_bit_rate;
-    LOGGED_UNLOCK(call->mutex_decoding);
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(call->mutex);
+    pthread_mutex_unlock(av->mutex);
     
 END:
     if (error)
@@ -552,19 +556,19 @@ bool toxav_set_video_bit_rate(ToxAV* av, uint32_t friend_number, uint32_t video_
         goto END;
     }
     
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     call = call_get(av, friend_number);
     if (call == NULL || !call->active || call->msi_call->state != msi_CallActive) {
-        LOGGED_UNLOCK(av->mutex);
+        pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_BIT_RATE_FRIEND_NOT_IN_CALL;
         goto END;
     }
     
     /* Decoding mutex is locked because of quality control */
-    LOGGED_LOCK(call->mutex_decoding);
+    pthread_mutex_lock(call->mutex);
     call->video_bit_rate = video_bit_rate;
-    LOGGED_UNLOCK(call->mutex_decoding);
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(call->mutex);
+    pthread_mutex_unlock(av->mutex);
     
 END:
     if (error)
@@ -575,10 +579,10 @@ END:
 
 void toxav_callback_video_frame_request(ToxAV* av, toxav_video_frame_request_cb* function, void* user_data)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     av->rvcb.first = function;
     av->rvcb.second = user_data;
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
 }
 
 bool toxav_send_video_frame(ToxAV* av, uint32_t friend_number, uint16_t width, uint16_t height, const uint8_t* y, const uint8_t* u, const uint8_t* v, TOXAV_ERR_SEND_FRAME* error)
@@ -591,25 +595,25 @@ bool toxav_send_video_frame(ToxAV* av, uint32_t friend_number, uint16_t width, u
         goto END;
     }
     
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     call = call_get(av, friend_number);
     if (call == NULL || !call->active || call->msi_call->state != msi_CallActive) {
-        LOGGED_UNLOCK(av->mutex);
+        pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL;
         goto END;
     }
     
-    LOGGED_LOCK(call->mutex_video_sending);
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_lock(call->mutex_video);
+    pthread_mutex_unlock(av->mutex);
     
     if ( y == NULL || u == NULL || v == NULL ) {
-        LOGGED_UNLOCK(call->mutex_video_sending);
+        pthread_mutex_unlock(call->mutex_video);
         rc = TOXAV_ERR_SEND_FRAME_NULL;
         goto END;
     }
     
-    if ( cs_reconfigure_video_encoder(call->cs, call->video_bit_rate, width, height) != 0 ) {
-        LOGGED_UNLOCK(call->mutex_video_sending);
+    if ( vc_reconfigure_encoder(call->video.second, call->video_bit_rate, width, height) != 0 ) {
+        pthread_mutex_unlock(call->mutex_video);
         rc = TOXAV_ERR_SEND_FRAME_INVALID;
         goto END;
     }
@@ -626,29 +630,29 @@ bool toxav_send_video_frame(ToxAV* av, uint32_t friend_number, uint16_t width, u
         memcpy(img.planes[VPX_PLANE_U], u, (width/2) * (height/2));
         memcpy(img.planes[VPX_PLANE_V], v, (width/2) * (height/2));
         
-        int vrc = vpx_codec_encode(call->cs->v_encoder, &img, 
-                                   call->cs->frame_counter, 1, 0, MAX_ENCODE_TIME_US);
+        int vrc = vpx_codec_encode(call->video.second->v_encoder, &img, 
+                                   call->video.second->frame_counter, 1, 0, MAX_ENCODE_TIME_US);
         
         vpx_img_free(&img);
         if ( vrc != VPX_CODEC_OK) {
-            LOGGED_UNLOCK(call->mutex_video_sending);
+            pthread_mutex_unlock(call->mutex_video);
             LOGGER_ERROR("Could not encode video frame: %s\n", vpx_codec_err_to_string(vrc));
             rc = TOXAV_ERR_SEND_FRAME_INVALID;
             goto END;
         }
     }
     
-    ++call->cs->frame_counter;
+    ++call->video.second->frame_counter;
     
     { /* Split and send */
         vpx_codec_iter_t iter = NULL;
         const vpx_codec_cx_pkt_t *pkt;
         
-        cs_init_video_splitter_cycle(call->cs);
+        vc_init_video_splitter_cycle(call->video.second);
         
-        while ( (pkt = vpx_codec_get_cx_data(call->cs->v_encoder, &iter)) ) {
+        while ( (pkt = vpx_codec_get_cx_data(call->video.second->v_encoder, &iter)) ) {
             if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
-                int parts = cs_update_video_splitter_cycle(call->cs, pkt->data.frame.buf, 
+                int parts = vc_update_video_splitter_cycle(call->video.second, pkt->data.frame.buf, 
                                                            pkt->data.frame.sz);
                 
                 if (parts < 0) /* Should never happen though */
@@ -659,10 +663,10 @@ bool toxav_send_video_frame(ToxAV* av, uint32_t friend_number, uint16_t width, u
                 
                 int i;
                 for (i = 0; i < parts; i++) {
-                    iter = cs_iterate_split_video_frame(call->cs, &part_size);
+                    iter = vc_iterate_split_video_frame(call->video.second, &part_size);
                     
-                    if (rtp_send_msg(call->rtps[video_index], iter, part_size) < 0) {
-                        LOGGED_UNLOCK(call->mutex_video_sending);
+                    if (rtp_send_msg(call->video.first, iter, part_size) < 0) {
+                        pthread_mutex_unlock(call->mutex_video);
                         LOGGER_WARNING("Could not send video frame: %s\n", strerror(errno));
                         goto END;
                     }
@@ -671,7 +675,7 @@ bool toxav_send_video_frame(ToxAV* av, uint32_t friend_number, uint16_t width, u
         }
     }
     
-    LOGGED_UNLOCK(call->mutex_video_sending);
+    pthread_mutex_unlock(call->mutex_video);
     
 END:
     if (error)
@@ -682,10 +686,10 @@ END:
 
 void toxav_callback_audio_frame_request(ToxAV* av, toxav_audio_frame_request_cb* function, void* user_data)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     av->racb.first = function;
     av->racb.second = user_data;
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
 }
 
 bool toxav_send_audio_frame(ToxAV* av, uint32_t friend_number, const int16_t* pcm, size_t sample_count, uint8_t channels, uint32_t sampling_rate, TOXAV_ERR_SEND_FRAME* error)
@@ -698,32 +702,32 @@ bool toxav_send_audio_frame(ToxAV* av, uint32_t friend_number, const int16_t* pc
         goto END;
     }
     
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     call = call_get(av, friend_number);
     if (call == NULL || !call->active || call->msi_call->state != msi_CallActive) {
-        LOGGED_UNLOCK(av->mutex);
+        pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL;
         goto END;
     }
     
-    LOGGED_LOCK(call->mutex_audio_sending);
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_lock(call->mutex_audio);
+    pthread_mutex_unlock(av->mutex);
     
     if ( pcm == NULL ) {
-        LOGGED_UNLOCK(call->mutex_audio_sending);
+        pthread_mutex_unlock(call->mutex_audio);
         rc = TOXAV_ERR_SEND_FRAME_NULL;
         goto END;
     }
     
     if ( channels > 2 ) {
-        LOGGED_UNLOCK(call->mutex_audio_sending);
+        pthread_mutex_unlock(call->mutex_audio);
         rc = TOXAV_ERR_SEND_FRAME_INVALID;
         goto END;
     }
     
     { /* Encode and send */
-        if (cs_reconfigure_audio_encoder(call->cs, call->audio_bit_rate * 1000, sampling_rate, channels) != 0) {
-            LOGGED_UNLOCK(call->mutex_audio_sending);
+        if (ac_reconfigure_encoder(call->audio.second, call->audio_bit_rate * 1000, sampling_rate, channels) != 0) {
+            pthread_mutex_unlock(call->mutex_audio);
             rc = TOXAV_ERR_SEND_FRAME_INVALID;
             goto END;
         }
@@ -732,12 +736,12 @@ bool toxav_send_audio_frame(ToxAV* av, uint32_t friend_number, const int16_t* pc
         
         sampling_rate = htonl(sampling_rate);
         memcpy(dest, &sampling_rate, sizeof(sampling_rate));
-        int vrc = opus_encode(call->cs->audio_encoder, pcm, sample_count,
+        int vrc = opus_encode(call->audio.second->encoder, pcm, sample_count,
                               dest + sizeof(sampling_rate), sizeof(dest) - sizeof(sampling_rate));
         
         if (vrc < 0) {
             LOGGER_WARNING("Failed to encode frame %s", opus_strerror(vrc));
-            LOGGED_UNLOCK(call->mutex_audio_sending);
+            pthread_mutex_unlock(call->mutex_audio);
             rc = TOXAV_ERR_SEND_FRAME_INVALID;
             goto END;
         }
@@ -745,13 +749,13 @@ bool toxav_send_audio_frame(ToxAV* av, uint32_t friend_number, const int16_t* pc
 //         LOGGER_DEBUG("Sending encoded audio frame size: %d; channels: %d; srate: %d", vrc, channels,
 //                      ntohl(sampling_rate));
         
-                if (rtp_send_msg(call->rtps[audio_index], dest, vrc + sizeof(sampling_rate)) != 0) {
+                if (rtp_send_msg(call->audio.first, dest, vrc + sizeof(sampling_rate)) != 0) {
                         LOGGER_WARNING("Failed to send audio packet");
                         rc = TOXAV_ERR_SEND_FRAME_RTP_FAILED;
                 }
     }
     
-    LOGGED_UNLOCK(call->mutex_audio_sending);
+    pthread_mutex_unlock(call->mutex_audio);
     
 END:
     if (error)
@@ -762,18 +766,18 @@ END:
 
 void toxav_callback_receive_video_frame(ToxAV* av, toxav_receive_video_frame_cb* function, void* user_data)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     av->vcb.first = function;
     av->vcb.second = user_data;
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
 }
 
 void toxav_callback_receive_audio_frame(ToxAV* av, toxav_receive_audio_frame_cb* function, void* user_data)
 {
-    LOGGED_LOCK(av->mutex);
+    pthread_mutex_lock(av->mutex);
     av->acb.first = function;
     av->acb.second = user_data;
-    LOGGED_UNLOCK(av->mutex);
+    pthread_mutex_unlock(av->mutex);
 }
 
 
@@ -785,12 +789,12 @@ void toxav_callback_receive_audio_frame(ToxAV* av, toxav_receive_audio_frame_cb*
 int callback_invite(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
-    LOGGED_LOCK(toxav->mutex);
+    pthread_mutex_lock(toxav->mutex);
     
     ToxAVCall* av_call = call_new(toxav, call->friend_id, NULL);
     if (av_call == NULL) {
         LOGGER_WARNING("Failed to initialize call...");
-        LOGGED_UNLOCK(toxav->mutex);
+        pthread_mutex_unlock(toxav->mutex);
         return -1;
     }
     
@@ -801,72 +805,72 @@ int callback_invite(void* toxav_inst, MSICall* call)
         toxav->ccb.first(toxav, call->friend_id, call->peer_capabilities & msi_CapSAudio, 
                          call->peer_capabilities & msi_CapSVideo, toxav->ccb.second);
     
-    LOGGED_UNLOCK(toxav->mutex);
+    pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
 
 int callback_start(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
-    LOGGED_LOCK(toxav->mutex);
+    pthread_mutex_lock(toxav->mutex);
     
     ToxAVCall* av_call = call_get(toxav, call->friend_id);
     
     if (av_call == NULL) {
         /* Should this ever happen? */
-        LOGGED_UNLOCK(toxav->mutex);
+        pthread_mutex_unlock(toxav->mutex);
         return -1;
     }
     
     if (!call_prepare_transmission(av_call)) {
         callback_error(toxav_inst, call);
         call_remove(av_call);
-        LOGGED_UNLOCK(toxav->mutex);
+        pthread_mutex_unlock(toxav->mutex);
         return -1;
     }
     
     invoke_call_state(toxav, call->friend_id, call->peer_capabilities);
     
-    LOGGED_UNLOCK(toxav->mutex);
+    pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
 
 int callback_end(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
-    LOGGED_LOCK(toxav->mutex);
+    pthread_mutex_lock(toxav->mutex);
     
     invoke_call_state(toxav, call->friend_id, TOXAV_CALL_STATE_END);
     
     call_kill_transmission(call->av_call);
     call_remove(call->av_call);
     
-    LOGGED_UNLOCK(toxav->mutex);
+    pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
 
 int callback_error(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
-    LOGGED_LOCK(toxav->mutex);
+    pthread_mutex_lock(toxav->mutex);
     
     invoke_call_state(toxav, call->friend_id, TOXAV_CALL_STATE_ERROR);
     
     call_kill_transmission(call->av_call);
     call_remove(call->av_call);
     
-    LOGGED_UNLOCK(toxav->mutex);
+    pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
 
 int callback_capabilites(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
-    LOGGED_LOCK(toxav->mutex);
+    pthread_mutex_lock(toxav->mutex);
     
     invoke_call_state(toxav, call->friend_id, call->peer_capabilities);
     
-    LOGGED_UNLOCK(toxav->mutex);
+    pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
 
@@ -982,10 +986,8 @@ ToxAVCall* call_get(ToxAV* av, uint32_t friend_number)
 
 void qc_do(ToxAVCall* call)
 {
-    /* Please NOTE: The quality control is rather basic,
-     * advanced algorithms will be applied in the future
-     */
-    switch(call->rtps[audio_index]->tstate) {
+    /*
+    switch(call->audio.first->tstate) {
     case rtp_StateBad:
         LOGGER_DEBUG("Suggesting lower bitrate for audio...");
         call->time_audio_good = 0;
@@ -1007,9 +1009,9 @@ void qc_do(ToxAVCall* call)
     case rtp_StateNormal:
         call->time_audio_good = 0;
         break;
-    }
-    
-    switch(call->rtps[video_index]->tstate) {
+    }*/
+    /*
+    switch(call->video.first->tstate) {
     case rtp_StateBad:
         LOGGER_DEBUG("Suggesting lower bitrate for video...");
         call->time_video_good = 0;
@@ -1030,8 +1032,7 @@ void qc_do(ToxAVCall* call)
     case rtp_StateNormal:
         call->time_video_good = 0;
         break;
-    }
-    
+    }*/
 }
 
 void call_remove(ToxAVCall* call)
@@ -1086,61 +1087,50 @@ bool call_prepare_transmission(ToxAVCall* call)
         return true;
     }
     
-    if (create_recursive_mutex(call->mutex_audio_sending) != 0)
+    if (create_recursive_mutex(call->mutex_audio) != 0)
         return false;
     
-    if (create_recursive_mutex(call->mutex_video_sending) != 0) {
+    if (create_recursive_mutex(call->mutex_video) != 0) {
         goto AUDIO_SENDING_MUTEX_CLEANUP;
     }
     
-    if (create_recursive_mutex(call->mutex_decoding) != 0) {
+    if (create_recursive_mutex(call->mutex) != 0) {
         goto VIDEO_SENDING_MUTEX_CLEANUP;
     }
     
-    /* Creates both audio and video encoders and decoders with some default values.
-     * Make sure to reconfigure encoders dynamically when sending data
-     */
-    call->cs = cs_new(call->msi_call->peer_vfpsz);
-    
-    if ( !call->cs ) {
-        LOGGER_ERROR("Error while starting Codec State!\n");
-        goto FAILURE;
-    }
-    
-    call->cs->av = av;
-    call->cs->friend_id = call->friend_id;
-    
-    memcpy(&call->cs->acb, &av->acb, sizeof(av->acb));
-    memcpy(&call->cs->vcb, &av->vcb, sizeof(av->vcb));
     
-    { /* Prepare audio RTP */
-        call->rtps[audio_index] = rtp_new(rtp_TypeAudio, av->m, call->friend_id);
+    { /* Prepare audio */
+        call->audio.first = rtp_new(rtp_TypeAudio, av->m, call->friend_id);
+        call->audio.second = ac_new(av, call->friend_id, av->acb.first, av->acb.second);
         
-        if ( !call->rtps[audio_index] ) {
-            LOGGER_ERROR("Error while starting audio RTP session!\n");
+        if ( !call->audio.first || !call->audio.second ) {
+            LOGGER_ERROR("Error while starting audio!\n");
             goto FAILURE;
         }
         
-        call->rtps[audio_index]->cs = call->cs;
+        call->audio.first->cs = call->audio.second;
+        call->audio.first->mcb = ac_queue_message;
         
-        if (rtp_start_receiving(call->rtps[audio_index]) != 0) {
+        if (rtp_start_receiving(call->audio.first) != 0) {
             LOGGER_WARNING("Failed to enable audio receiving!");
             goto FAILURE;
         }
     }
     
-    { /* Prepare video RTP */
-        call->rtps[video_index] = rtp_new(rtp_TypeVideo, av->m, call->friend_id);
+    { /* Prepare video */
+        call->video.first = rtp_new(rtp_TypeVideo, av->m, call->friend_id);
+        call->video.second = vc_new(av, call->friend_id, av->vcb.first, av->vcb.second, call->msi_call->peer_vfpsz);
         
-        if ( !call->rtps[video_index] ) {
-            LOGGER_ERROR("Error while starting video RTP session!\n");
+        if ( !call->video.first || !call->video.second ) {
+            LOGGER_ERROR("Error while starting video!\n");
             goto FAILURE;
         }
         
-        call->rtps[video_index]->cs = call->cs;
+        call->video.first->cs = call->video.second;
+        call->video.first->mcb = vc_queue_message;
         
-        if (rtp_start_receiving(call->rtps[video_index]) != 0) {
-            LOGGER_WARNING("Failed to enable audio receiving!");
+        if (rtp_start_receiving(call->video.first) != 0) {
+            LOGGER_WARNING("Failed to enable video receiving!");
             goto FAILURE;
         }
     }
@@ -1149,17 +1139,19 @@ bool call_prepare_transmission(ToxAVCall* call)
     return true;
     
 FAILURE:
-    rtp_kill(call->rtps[audio_index]);
-    call->rtps[audio_index] = NULL;
-    rtp_kill(call->rtps[video_index]);
-    call->rtps[video_index] = NULL;
-    cs_kill(call->cs);
-    call->cs = NULL;
-    pthread_mutex_destroy(call->mutex_decoding);
+    rtp_kill(call->audio.first);
+    ac_kill(call->audio.second);
+    call->audio.first = NULL;
+    call->audio.second = NULL;
+    rtp_kill(call->video.first);
+    vc_kill(call->video.second);
+    call->video.first = NULL;
+    call->video.second = NULL;
+    pthread_mutex_destroy(call->mutex);
 VIDEO_SENDING_MUTEX_CLEANUP:
-    pthread_mutex_destroy(call->mutex_video_sending);
+    pthread_mutex_destroy(call->mutex_video);
 AUDIO_SENDING_MUTEX_CLEANUP:
-    pthread_mutex_destroy(call->mutex_audio_sending);
+    pthread_mutex_destroy(call->mutex_audio);
     return false;
 }
 
@@ -1170,23 +1162,24 @@ void call_kill_transmission(ToxAVCall* call)
     
     call->active = 0;
     
-    LOGGED_LOCK(call->mutex_audio_sending);
-    LOGGED_UNLOCK(call->mutex_audio_sending);
-    LOGGED_LOCK(call->mutex_video_sending);
-    LOGGED_UNLOCK(call->mutex_video_sending);
-    LOGGED_LOCK(call->mutex_decoding);
-    LOGGED_UNLOCK(call->mutex_decoding);
-    
-    
-    rtp_kill(call->rtps[audio_index]);
-    call->rtps[audio_index] = NULL;
-    rtp_kill(call->rtps[video_index]);
-    call->rtps[video_index] = NULL;
-    
-    cs_kill(call->cs);
-    call->cs = NULL;
-    
-    pthread_mutex_destroy(call->mutex_audio_sending);
-    pthread_mutex_destroy(call->mutex_video_sending);
-    pthread_mutex_destroy(call->mutex_decoding);
+    pthread_mutex_lock(call->mutex_audio);
+    pthread_mutex_unlock(call->mutex_audio);
+    pthread_mutex_lock(call->mutex_video);
+    pthread_mutex_unlock(call->mutex_video);
+    pthread_mutex_lock(call->mutex);
+    pthread_mutex_unlock(call->mutex);
+    
+    rtp_kill(call->audio.first);
+    ac_kill(call->audio.second);
+    call->audio.first = NULL;
+    call->audio.second = NULL;
+    
+    rtp_kill(call->video.first);
+    vc_kill(call->video.second);
+    call->video.first = NULL;
+    call->video.second = NULL;
+    
+    pthread_mutex_destroy(call->mutex_audio);
+    pthread_mutex_destroy(call->mutex_video);
+    pthread_mutex_destroy(call->mutex);
 }