1 files changed, 332 insertions, 230 deletions

diff --git a/toxav/toxav.c b/toxav/toxav.c
index a042b9dd..a301e007 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -17,8 +17,6 @@
  *   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 at #tox-dev @ freenode.net:6667
  */
 
 #ifdef HAVE_CONFIG_H
@@ -29,19 +27,22 @@
 #define _GNU_SOURCE /* implicit declaration warning */
 
 #include "rtp.h"
-#include "media.h"
+#include "codec.h"
 #include "msi.h"
 #include "toxav.h"
 
 #include "../toxcore/logger.h"
 
-
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
 /* Assume 60 fps*/
-#define MAX_ENCODE_TIME_US ((1000 / 60) * 1000)
+#define MAX_ENCODE_TIME_US ((1000 / 24) * 1000)
+
+#define MAX_VIDEOFRAME_SIZE 0x40000 /* 256KiB */
+#define VIDEOFRAME_PIECE_SIZE 0x500 /* 1.25 KiB*/
+#define VIDEOFRAME_HEADER_SIZE 0x2
 
 
 #define inline__ inline __attribute__((always_inline))
@@ -61,6 +62,13 @@ typedef struct _CallSpecific {
                      * reuse them really.
                      */
     JitterBuffer *j_buf; /** Jitter buffer for audio */
+
+    uint32_t frame_limit; /* largest address written to in frame_buf for current input frame*/
+    uint8_t frame_id, frame_outid; /* id of input and output video frame */
+    void *frame_buf; /* buffer for split video payloads */
+
+    _Bool call_active;
+    pthread_mutex_t mutex;
 } CallSpecific;
 
 
@@ -68,19 +76,25 @@ struct _ToxAv {
     Messenger *messenger;
     MSISession *msi_session; /** Main msi session */
     CallSpecific *calls; /** Per-call params */
+
+    void (*audio_callback)(ToxAv *, int32_t, int16_t *, int);
+    void (*video_callback)(ToxAv *, int32_t, vpx_image_t *);
+
     uint32_t max_calls;
 };
 
 const ToxAvCodecSettings av_DefaultSettings = {
-    1000000,
-    800,
-    600,
+    500,
+    1280,
+    720,
 
     64000,
     20,
     48000,
     1,
-    20
+    600,
+
+    6
 };
 
 
@@ -123,8 +137,6 @@ ToxAv *toxav_new( Tox *messenger, int32_t max_calls)
  */
 void toxav_kill ( ToxAv *av )
 {
-    msi_terminate_session(av->msi_session);
-
     int i = 0;
 
     for (; i < av->max_calls; i ++) {
@@ -142,6 +154,8 @@ void toxav_kill ( ToxAv *av )
         if ( av->calls[i].cs ) codec_terminate_session(av->calls[i].cs);
     }
 
+    msi_terminate_session(av->msi_session);
+
     free(av->calls);
     free(av);
 }
@@ -159,6 +173,28 @@ void toxav_register_callstate_callback ( ToxAVCallback callback, ToxAvCallbackID
 }
 
 /**
+ * @brief Register callback for recieving audio data
+ *
+ * @param callback The callback
+ * @return void
+ */
+void toxav_register_audio_recv_callback (ToxAv *av, void (*callback)(ToxAv *, int32_t, int16_t *, int))
+{
+    av->audio_callback = callback;
+}
+
+/**
+ * @brief Register callback for recieving video data
+ *
+ * @param callback The callback
+ * @return void
+ */
+void toxav_register_video_recv_callback (ToxAv *av, void (*callback)(ToxAv *, int32_t, vpx_image_t *))
+{
+    av->video_callback = callback;
+}
+
+/**
  * @brief Call user. Use its friend_id.
  *
  * @param av Handler.
@@ -255,6 +291,10 @@ int toxav_cancel ( ToxAv *av, int32_t call_index, int peer_id, const char *reaso
         return ErrorNoCall;
     }
 
+    if ( av->msi_session->calls[call_index]->state != call_inviting ) {
+        return ErrorInvalidState;
+    }
+
     return msi_cancel(av->msi_session, call_index, peer_id, reason);
 }
 
@@ -285,59 +325,80 @@ int toxav_stop_call ( ToxAv *av, int32_t call_index )
  */
 int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, ToxAvCodecSettings *codec_settings, int support_video )
 {
-    if ( !av->msi_session || cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) {
-        LOGGER_ERROR("Error while starting audio RTP session: invalid call!\n");
+    if ( !av->msi_session || cii(call_index, av->msi_session) ||
+            !av->msi_session->calls[call_index] || av->calls[call_index].call_active) {
+        LOGGER_ERROR("Error while starting RTP session: invalid call!\n");
         return ErrorInternal;
     }
 
     CallSpecific *call = &av->calls[call_index];
 
     call->crtps[audio_index] =
-        rtp_init_session(
-            type_audio,
-            av->messenger,
-            av->msi_session->calls[call_index]->peers[0],
-            av->msi_session->calls[call_index]->key_peer,
-            av->msi_session->calls[call_index]->key_local,
-            av->msi_session->calls[call_index]->nonce_peer,
-            av->msi_session->calls[call_index]->nonce_local);
+        rtp_init_session(type_audio, av->messenger, av->msi_session->calls[call_index]->peers[0]);
 
 
     if ( !call->crtps[audio_index] ) {
         LOGGER_ERROR("Error while starting audio RTP session!\n");
-        return ErrorStartingAudioRtp;
+        return ErrorInternal;
     }
 
+    call->crtps[audio_index]->call_index = call_index;
+    call->crtps[audio_index]->av = av;
 
     if ( support_video ) {
         call->crtps[video_index] =
-            rtp_init_session (
-                type_video,
-                av->messenger,
-                av->msi_session->calls[call_index]->peers[0],
-                av->msi_session->calls[call_index]->key_peer,
-                av->msi_session->calls[call_index]->key_local,
-                av->msi_session->calls[call_index]->nonce_peer,
-                av->msi_session->calls[call_index]->nonce_local);
-
+            rtp_init_session(type_video, av->messenger, av->msi_session->calls[call_index]->peers[0]);
 
         if ( !call->crtps[video_index] ) {
             LOGGER_ERROR("Error while starting video RTP session!\n");
-            return ErrorStartingVideoRtp;
+            goto error;
+        }
+
+        call->crtps[video_index]->call_index = call_index;
+        call->crtps[video_index]->av = av;
+
+        call->frame_limit = 0;
+        call->frame_id = 0;
+        call->frame_outid = 0;
+
+        call->frame_buf = calloc(MAX_VIDEOFRAME_SIZE, 1);
+
+        if (!call->frame_buf) {
+            LOGGER_WARNING("Frame buffer allocation failed!");
+            goto error;
         }
+
+    }
+
+    if ( !(call->j_buf = create_queue(codec_settings->jbuf_capacity)) ) {
+        LOGGER_WARNING("Jitter buffer creaton failed!");
+        goto error;
     }
 
-    if ( !(call->j_buf = create_queue(codec_settings->jbuf_capacity)) ) return ErrorInternal;
+    if ( (call->cs = codec_init_session(codec_settings->audio_bitrate,
+                                        codec_settings->audio_frame_duration,
+                                        codec_settings->audio_sample_rate,
+                                        codec_settings->audio_channels,
+                                        codec_settings->audio_VAD_tolerance,
+                                        codec_settings->max_video_width,
+                                        codec_settings->max_video_height,
+                                        codec_settings->video_bitrate) )) {
 
-    call->cs = codec_init_session(codec_settings->audio_bitrate,
-                                  codec_settings->audio_frame_duration,
-                                  codec_settings->audio_sample_rate,
-                                  codec_settings->audio_channels,
-                                  codec_settings->video_width,
-                                  codec_settings->video_height,
-                                  codec_settings->video_bitrate);
+        if ( pthread_mutex_init(&call->mutex, NULL) != 0 ) goto error;
+
+        call->call_active = 1;
+
+        return ErrorNone;
+    }
 
-    return call->cs ? ErrorNone : ErrorInternal;
+error:
+    rtp_terminate_session(call->crtps[audio_index], av->messenger);
+    rtp_terminate_session(call->crtps[video_index], av->messenger);
+    free(call->frame_buf);
+    terminate_queue(call->j_buf);
+    codec_terminate_session(call->cs);
+
+    return ErrorInternal;
 }
 
 /**
@@ -350,34 +411,35 @@ int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, ToxAvCodecSettin
  */
 int toxav_kill_transmission ( ToxAv *av, int32_t call_index )
 {
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    if (cii(call_index, av->msi_session)) {
+        LOGGER_WARNING("Invalid call index: %d", call_index);
+        return ErrorNoCall;
+    }
 
     CallSpecific *call = &av->calls[call_index];
 
-    if ( call->crtps[audio_index] && -1 == rtp_terminate_session(call->crtps[audio_index], av->messenger) ) {
-        LOGGER_ERROR("Error while terminating audio RTP session!\n");
-        return ErrorTerminatingAudioRtp;
-    }
+    pthread_mutex_lock(&call->mutex);
 
-    if ( call->crtps[video_index] && -1 == rtp_terminate_session(call->crtps[video_index], av->messenger) ) {
-        LOGGER_ERROR("Error while terminating video RTP session!\n");
-        return ErrorTerminatingVideoRtp;
+    if (!call->call_active) {
+        pthread_mutex_unlock(&call->mutex);
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
     }
 
+
+    call->call_active = 0;
+
+    rtp_terminate_session(call->crtps[audio_index], av->messenger);
     call->crtps[audio_index] = NULL;
+    rtp_terminate_session(call->crtps[video_index], av->messenger);
     call->crtps[video_index] = NULL;
+    terminate_queue(call->j_buf);
+    call->j_buf = NULL;
+    codec_terminate_session(call->cs);
+    call->cs = NULL;
 
-    if ( call->j_buf ) {
-        terminate_queue(call->j_buf);
-        call->j_buf = NULL;
-        LOGGER_DEBUG("Terminated j queue");
-    } else LOGGER_DEBUG("No j queue");
-
-    if ( call->cs ) {
-        codec_terminate_session(call->cs);
-        call->cs = NULL;
-        LOGGER_DEBUG("Terminated codec session");
-    } else LOGGER_DEBUG("No codec session");
+    pthread_mutex_unlock(&call->mutex);
+    pthread_mutex_destroy(&call->mutex);
 
     return ErrorNone;
 }
@@ -395,122 +457,83 @@ int toxav_kill_transmission ( ToxAv *av, int32_t call_index )
  * @retval -1 Failure.
  */
 inline__ int toxav_send_rtp_payload ( ToxAv *av, int32_t call_index, ToxAvCallType type, const uint8_t *payload,
-                                      uint16_t length )
+                                      unsigned int length )
 {
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    CallSpecific *call = &av->calls[call_index];
 
-    if ( av->calls[call_index].crtps[type - TypeAudio] )
-        return rtp_send_msg ( av->calls[call_index].crtps[type - TypeAudio], av->msi_session->messenger_handle, payload,
-                              length );
-    else return -1;
-}
+    if (call->crtps[type - TypeAudio]) {
 
-/**
- * @brief Receive RTP payload.
- *
- * @param av Handler.
- * @param type Type of the payload.
- * @param dest Storage.
- * @return int
- * @retval ToxAvError On Error.
- * @retval >=0 Size of received payload.
- */
-inline__ int toxav_recv_rtp_payload ( ToxAv *av, int32_t call_index, ToxAvCallType type, uint8_t *dest )
-{
-    if ( !dest ) return ErrorInternal;
+        if (type == TypeAudio) {
+            return rtp_send_msg(call->crtps[type - TypeAudio], av->messenger, payload, length);
+        } else {
+            if (length == 0 || length > MAX_VIDEOFRAME_SIZE) {
+                LOGGER_ERROR("Invalid video frame size: %u\n", length);
+                return ErrorInternal;
+            }
 
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+            /* number of pieces - 1*/
+            uint8_t numparts = (length - 1) / VIDEOFRAME_PIECE_SIZE;
 
-    CallSpecific *call = &av->calls[call_index];
+            uint8_t load[2 + VIDEOFRAME_PIECE_SIZE];
+            load[0] = call->frame_outid++;
+            load[1] = 0;
 
-    if ( !call->crtps[type - TypeAudio] ) return ErrorNoRtpSession;
+            int i;
 
-    RTPMessage *message;
+            for (i = 0; i < numparts; i++) {
+                memcpy(load + VIDEOFRAME_HEADER_SIZE, payload, VIDEOFRAME_PIECE_SIZE);
+                payload += VIDEOFRAME_PIECE_SIZE;
 
-    if ( type == TypeAudio ) {
+                if (rtp_send_msg(call->crtps[type - TypeAudio], av->messenger,
+                                 load, VIDEOFRAME_HEADER_SIZE + VIDEOFRAME_PIECE_SIZE) != 0) {
 
-        do {
-            message = rtp_recv_msg(call->crtps[audio_index]);
+                    return ErrorInternal;
+                }
 
-            if (message) {
-                /* push the packet into the queue */
-                queue(call->j_buf, message);
+                load[1]++;
             }
-        } while (message);
 
-        int success = 0;
-        message = dequeue(call->j_buf, &success);
+            /* remainder = length % VIDEOFRAME_PIECE_SIZE, VIDEOFRAME_PIECE_SIZE if = 0 */
+            length = ((length - 1) % VIDEOFRAME_PIECE_SIZE) + 1;
+            memcpy(load + VIDEOFRAME_HEADER_SIZE, payload, length);
 
-        if ( success == 2) return ErrorAudioPacketLost;
+            return rtp_send_msg(call->crtps[type - TypeAudio], av->messenger, load, VIDEOFRAME_HEADER_SIZE + length);
+        }
     } else {
-        message = rtp_recv_msg(call->crtps[video_index]);
-    }
-
-    if ( message ) {
-        memcpy(dest, message->data, message->length);
-
-        int length = message->length;
-
-        rtp_free_msg(NULL, message);
-
-        return length;
+        return ErrorNoRtpSession;
     }
-
-    return 0;
 }
 
 /**
- * @brief Receive decoded video packet.
+ * @brief Encode and send video packet.
  *
  * @param av Handler.
- * @param output Storage.
+ * @param input The packet.
  * @return int
  * @retval 0 Success.
- * @retval ToxAvError On Error.
+ * @retval ToxAvError On error.
  */
-inline__ int toxav_recv_video ( ToxAv *av, int32_t call_index, vpx_image_t **output)
+inline__ int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, int frame_size)
 {
-    if ( !output ) return ErrorInternal;
-
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    if (cii(call_index, av->msi_session)) {
+        LOGGER_WARNING("Invalid call index: %d", call_index);
+        return ErrorNoCall;
+    }
 
-    uint8_t packet [RTP_PAYLOAD_SIZE];
-    int recved_size = 0;
-    int rc;
     CallSpecific *call = &av->calls[call_index];
+    pthread_mutex_lock(&call->mutex);
 
-    do {
-        recved_size = toxav_recv_rtp_payload(av, call_index, TypeVideo, packet);
-
-        if (recved_size > 0 && ( rc = vpx_codec_decode(&call->cs->v_decoder, packet, recved_size, NULL, 0) ) != VPX_CODEC_OK) {
-            LOGGER_ERROR("Error decoding video: %s\n", vpx_codec_err_to_string(rc));
-            return ErrorInternal;
-        }
-
-    } while (recved_size > 0);
 
-    vpx_codec_iter_t iter = NULL;
-    vpx_image_t *img;
-    img = vpx_codec_get_frame(&call->cs->v_decoder, &iter);
-
-    *output = img;
-    return 0;
-}
+    if (!call->call_active) {
+        pthread_mutex_unlock(&call->mutex);
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
 
-/**
- * @brief Encode and send video packet.
- *
- * @param av Handler.
- * @param input The packet.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
-inline__ int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, int frame_size)
-{
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    int rc = toxav_send_rtp_payload(av, call_index, TypeVideo, frame, frame_size);
+    pthread_mutex_unlock(&call->mutex);
 
-    return toxav_send_rtp_payload(av, call_index, TypeVideo, frame, frame_size);
+    return rc;
 }
 
 /**
@@ -526,14 +549,31 @@ inline__ int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *fr
  */
 inline__ int toxav_prepare_video_frame(ToxAv *av, int32_t call_index, uint8_t *dest, int dest_max, vpx_image_t *input)
 {
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    if (cii(call_index, av->msi_session)) {
+        LOGGER_WARNING("Invalid call index: %d", call_index);
+        return ErrorNoCall;
+    }
+
 
     CallSpecific *call = &av->calls[call_index];
+    pthread_mutex_lock(&call->mutex);
+
+    if (!call->call_active) {
+        pthread_mutex_unlock(&call->mutex);
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
+
+    if (reconfigure_video_encoder_resolution(call->cs, input->d_w, input->d_h) != 0) {
+        pthread_mutex_unlock(&call->mutex);
+        return ErrorInternal;
+    }
 
     int rc = vpx_codec_encode(&call->cs->v_encoder, input, call->cs->frame_counter, 1, 0, MAX_ENCODE_TIME_US);
 
     if ( rc != VPX_CODEC_OK) {
         LOGGER_ERROR("Could not encode video frame: %s\n", vpx_codec_err_to_string(rc));
+        pthread_mutex_unlock(&call->mutex);
         return ErrorInternal;
     }
 
@@ -545,61 +585,21 @@ inline__ int toxav_prepare_video_frame(ToxAv *av, int32_t call_index, uint8_t *d
 
     while ( (pkt = vpx_codec_get_cx_data(&call->cs->v_encoder, &iter)) ) {
         if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
-            if ( copied + pkt->data.frame.sz > dest_max ) return ErrorPacketTooLarge;
+            if ( copied + pkt->data.frame.sz > dest_max ) {
+                pthread_mutex_unlock(&call->mutex);
+                return ErrorPacketTooLarge;
+            }
 
             memcpy(dest + copied, pkt->data.frame.buf, pkt->data.frame.sz);
             copied += pkt->data.frame.sz;
         }
     }
 
+    pthread_mutex_unlock(&call->mutex);
     return copied;
 }
 
 /**
- * @brief Receive decoded audio frame.
- *
- * @param av Handler.
- * @param frame_size The size of dest in frames/samples (one frame/sample is 16 bits or 2 bytes
- *                   and corresponds to one sample of audio.)
- * @param dest Destination of the raw audio (16 bit signed pcm with AUDIO_CHANNELS channels).
- *             Make sure it has enough space for frame_size frames/samples.
- * @return int
- * @retval >=0 Size of received data in frames/samples.
- * @retval ToxAvError On error.
- */
-inline__ int toxav_recv_audio ( ToxAv *av, int32_t call_index, int frame_size, int16_t *dest )
-{
-    if ( !dest ) return ErrorInternal;
-
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
-
-    CallSpecific *call = &av->calls[call_index];
-
-    uint8_t packet [RTP_PAYLOAD_SIZE];
-
-    int recved_size = toxav_recv_rtp_payload(av, call_index, TypeAudio, packet);
-
-    if ( recved_size == ErrorAudioPacketLost ) {
-        int dec_size = opus_decode(call->cs->audio_decoder, NULL, 0, dest, frame_size, 1);
-
-        if ( dec_size < 0 ) {
-            LOGGER_WARNING("Decoding error: %s", opus_strerror(dec_size));
-            return ErrorInternal;
-        } else return dec_size;
-
-    } else if ( recved_size ) {
-        int dec_size = opus_decode(call->cs->audio_decoder, packet, recved_size, dest, frame_size, 0);
-
-        if ( dec_size < 0 ) {
-            LOGGER_WARNING("Decoding error: %s", opus_strerror(dec_size));
-            return ErrorInternal;
-        } else return dec_size;
-    } else {
-        return 0; /* Nothing received */
-    }
-}
-
-/**
  * @brief Send audio frame.
  *
  * @param av Handler.
@@ -612,9 +612,25 @@ inline__ int toxav_recv_audio ( ToxAv *av, int32_t call_index, int frame_size, i
  */
 inline__ int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *frame, int frame_size)
 {
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    if (cii(call_index, av->msi_session) || !av->calls[call_index].call_active) {
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
+
+    CallSpecific *call = &av->calls[call_index];
+    pthread_mutex_lock(&call->mutex);
+
+
+    if (!call->call_active) {
+        pthread_mutex_unlock(&call->mutex);
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
 
-    return toxav_send_rtp_payload(av, call_index, TypeAudio, frame, frame_size);
+    int rc = toxav_send_rtp_payload(av, call_index, TypeAudio, frame, frame_size);
+    pthread_mutex_unlock(&call->mutex);
+
+    return rc;
 }
 
 /**
@@ -632,9 +648,23 @@ inline__ int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *fr
 inline__ int toxav_prepare_audio_frame ( ToxAv *av, int32_t call_index, uint8_t *dest, int dest_max,
         const int16_t *frame, int frame_size)
 {
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    if (cii(call_index, av->msi_session) || !av->calls[call_index].call_active) {
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
+
+    CallSpecific *call = &av->calls[call_index];
+    pthread_mutex_lock(&call->mutex);
 
-    int32_t rc = opus_encode(av->calls[call_index].cs->audio_encoder, frame, frame_size, dest, dest_max);
+
+    if (!call->call_active) {
+        pthread_mutex_unlock(&call->mutex);
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
+
+    int32_t rc = opus_encode(call->cs->audio_encoder, frame, frame_size, dest, dest_max);
+    pthread_mutex_unlock(&call->mutex);
 
     if (rc < 0) {
         LOGGER_ERROR("Failed to encode payload: %s\n", opus_strerror(rc));
@@ -672,8 +702,6 @@ int toxav_get_peer_transmission_type ( ToxAv *av, int32_t call_index, int peer )
  */
 int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int peer )
 {
-    assert(av->msi_session);
-
     if ( peer < 0 || cii(call_index, av->msi_session) || !av->msi_session->calls[call_index]
             || av->msi_session->calls[call_index]->peer_count <= peer )
         return ErrorInternal;
@@ -682,6 +710,23 @@ int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int peer )
 }
 
 /**
+ * @brief Get id of peer participating in conversation
+ *
+ * @param av Handler
+ * @param peer peer index
+ * @return int
+ * @retval ToxAvError No peer id
+ */
+ToxAvCallState toxav_get_call_state(ToxAv *av, int32_t call_index)
+{
+    if ( cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] )
+        return av_CallNonExistant;
+
+    return av->msi_session->calls[call_index]->state;
+
+}
+
+/**
  * @brief Is certain capability supported
  *
  * @param av Handler
@@ -695,43 +740,100 @@ inline__ int toxav_capability_supported ( ToxAv *av, int32_t call_index, ToxAvCa
     /* 0 is error here */
 }
 
-/**
- * @brief Set queue limit
- *
- * @param av Handler
- * @param call_index index
- * @param limit the limit
- * @return void
- */
-inline__ int toxav_set_audio_queue_limit(ToxAv *av, int32_t call_index, uint64_t limit)
+inline__ Tox *toxav_get_tox(ToxAv *av)
 {
-    if ( av->calls[call_index].crtps[audio_index] )
-        rtp_queue_adjust_limit(av->calls[call_index].crtps[audio_index], limit);
-    else
-        return ErrorNoRtpSession;
-
-    return ErrorNone;
+    return (Tox *)av->messenger;
 }
 
-/**
- * @brief Set queue limit
- *
- * @param av Handler
- * @param call_index index
- * @param limit the limit
- * @return void
- */
-inline__ int toxav_set_video_queue_limit(ToxAv *av, int32_t call_index, uint64_t limit)
+int toxav_has_activity(ToxAv *av, int32_t call_index, int16_t *PCM, uint16_t frame_size, float ref_energy)
 {
-    if ( av->calls[call_index].crtps[video_index] )
-        rtp_queue_adjust_limit(av->calls[call_index].crtps[video_index], limit);
-    else
-        return ErrorNoRtpSession;
+    if ( !av->calls[call_index].cs ) return ErrorInvalidCodecState;
 
-    return ErrorNone;
+    return energy_VAD(av->calls[call_index].cs, PCM, frame_size, ref_energy);
 }
 
-inline__ Tox *toxav_get_tox(ToxAv *av)
+void toxav_handle_packet(RTPSession *_session, RTPMessage *_msg)
 {
-    return (Tox *)av->messenger;
-}
\ No newline at end of file
+    ToxAv *av = _session->av;
+    int32_t call_index = _session->call_index;
+    CallSpecific *call = &av->calls[call_index];
+
+    if (_session->payload_type == type_audio % 128) {
+        queue(call->j_buf, _msg);
+
+        int success = 0, dec_size;
+        int frame_size = 960;
+        int16_t dest[frame_size];
+
+        while ((_msg = dequeue(call->j_buf, &success)) || success == 2) {
+            if (success == 2) {
+                dec_size = opus_decode(call->cs->audio_decoder, NULL, 0, dest, frame_size, 1);
+            } else {
+                dec_size = opus_decode(call->cs->audio_decoder, _msg->data, _msg->length, dest, frame_size, 0);
+                rtp_free_msg(NULL, _msg);
+            }
+
+            if (dec_size < 0) {
+                LOGGER_WARNING("Decoding error: %s", opus_strerror(dec_size));
+                continue;
+            }
+
+            av->audio_callback(av, call_index, dest, frame_size);
+        }
+    } else {
+        uint8_t *packet = _msg->data;
+        int recved_size = _msg->length;
+
+        if (recved_size < VIDEOFRAME_HEADER_SIZE) {
+            goto end;
+        }
+
+        uint8_t i = packet[0] - call->frame_id;
+
+        if (i == 0) {
+            /* piece of current frame */
+        } else if (i > 0 && i < 128) {
+            /* recieved a piece of a frame ahead, flush current frame and start reading this new frame */
+            int rc = vpx_codec_decode(&call->cs->v_decoder, call->frame_buf, call->frame_limit, NULL, 0);
+            call->frame_id = packet[0];
+            memset(call->frame_buf, 0, call->frame_limit);
+            call->frame_limit = 0;
+
+            if (rc != VPX_CODEC_OK) {
+                LOGGER_ERROR("Error decoding video: %u %s\n", i, vpx_codec_err_to_string(rc));
+            }
+        } else {
+            /* old packet, dont read */
+            LOGGER_DEBUG("Old packet: %u\n", i);
+            goto end;
+        }
+
+        if (packet[1] > (MAX_VIDEOFRAME_SIZE - VIDEOFRAME_PIECE_SIZE + 1) /
+                VIDEOFRAME_PIECE_SIZE) { //TODO, fix this check? not sure
+            /* packet out of buffer range */
+            goto end;
+        }
+
+        LOGGER_DEBUG("Video Packet: %u %u\n", packet[0], packet[1]);
+        memcpy(call->frame_buf + packet[1] * VIDEOFRAME_PIECE_SIZE, packet + VIDEOFRAME_HEADER_SIZE,
+               recved_size - VIDEOFRAME_HEADER_SIZE);
+        uint32_t limit = packet[1] * VIDEOFRAME_PIECE_SIZE + recved_size - VIDEOFRAME_HEADER_SIZE;
+
+        if (limit > call->frame_limit) {
+            call->frame_limit = limit;
+            LOGGER_DEBUG("Limit: %u\n", call->frame_limit);
+        }
+
+end:
+        ;
+        vpx_codec_iter_t iter = NULL;
+        vpx_image_t *img;
+        img = vpx_codec_get_frame(&call->cs->v_decoder, &iter);
+
+        if (img) {
+            av->video_callback(av, call_index, img);
+        }
+
+        rtp_free_msg(NULL, _msg);
+    }
+}