Make ToxAV stateless

11 files changed, 133 insertions, 126 deletions

diff --git a/toxav/audio.c b/toxav/audio.c
index 59d1554e..3fb0985e 100644
--- a/toxav/audio.c
+++ b/toxav/audio.c
@@ -43,7 +43,7 @@ bool reconfigure_audio_decoder(ACSession *ac, int32_t sampling_rate, int8_t chan
 
 
 
-ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb, void *cb_data)
+ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb)
 {
     ACSession *ac = calloc(sizeof(ACSession), 1);
 
@@ -97,8 +97,7 @@ ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_re
 
     ac->av = av;
     ac->friend_number = friend_number;
-    ac->acb.first = cb;
-    ac->acb.second = cb_data;
+    ac->on_audio_frame = cb;
 
     return ac;
 
@@ -125,7 +124,7 @@ void ac_kill(ACSession *ac)
     LOGGER_DEBUG(ac->log, "Terminated audio handler: %p", ac);
     free(ac);
 }
-void ac_iterate(ACSession *ac)
+void ac_iterate(ACSession *ac, void *userdata)
 {
     if (!ac) {
         return;
@@ -186,11 +185,11 @@ void ac_iterate(ACSession *ac)
 
         if (rc < 0) {
             LOGGER_WARNING(ac->log, "Decoding error: %s", opus_strerror(rc));
-        } else if (ac->acb.first) {
+        } else if (ac->on_audio_frame) {
             ac->lp_frame_duration = (rc * 1000) / ac->lp_sampling_rate;
 
-            ac->acb.first(ac->av, ac->friend_number, tmp, rc, ac->lp_channel_count,
-                          ac->lp_sampling_rate, ac->acb.second);
+            ac->on_audio_frame(ac->av, ac->friend_number, tmp, rc, ac->lp_channel_count,
+                               ac->lp_sampling_rate, userdata);
         }
 
         return;
diff --git a/toxav/audio.h b/toxav/audio.h
index 5f9d7f7d..60bad163 100644
--- a/toxav/audio.h
+++ b/toxav/audio.h
@@ -55,12 +55,12 @@ typedef struct ACSession_s {
 
     ToxAV *av;
     uint32_t friend_number;
-    PAIR(toxav_audio_receive_frame_cb *, void *) acb; /* Audio frame receive callback */
+    toxav_audio_receive_frame_cb *on_audio_frame; /* Audio frame receive callback */
 } ACSession;
 
-ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb, void *cb_data);
+ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb);
 void ac_kill(ACSession *ac);
-void ac_iterate(ACSession *ac);
+void ac_iterate(ACSession *ac, void *userdata);
 int ac_queue_message(void *acp, struct RTPMessage *msg);
 int ac_reconfigure_encoder(ACSession *ac, int32_t bit_rate, int32_t sampling_rate, uint8_t channels);
 
diff --git a/toxav/bwcontroller.c b/toxav/bwcontroller.c
index b97135d6..63350f17 100644
--- a/toxav/bwcontroller.c
+++ b/toxav/bwcontroller.c
@@ -40,7 +40,7 @@
  */
 
 struct BWController_s {
-    void (*mcb)(BWController *, uint32_t, float, void *);
+    void (*mcb)(BWController *, uint32_t, float, void *, void *);
     void *mcb_data;
 
     Messenger *m;
@@ -61,17 +61,18 @@ struct BWController_s {
     } rcvpkt; /* To calculate average received packet */
 };
 
-int bwc_handle_data(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object);
+int bwc_handle_data(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object,
+                    void *userdata);
 void send_update(BWController *bwc);
 
 BWController *bwc_new(Messenger *m, uint32_t friendnumber,
-                      void (*mcb)(BWController *, uint32_t, float, void *),
-                      void *udata)
+                      void (*mcb)(BWController *, uint32_t, float, void *, void *),
+                      void *call_data)
 {
     BWController *retu = calloc(sizeof(struct BWController_s), 1);
 
     retu->mcb = mcb;
-    retu->mcb_data = udata;
+    retu->mcb_data = call_data;
     retu->m = m;
     retu->friend_number = friendnumber;
     retu->cycle.lsu = retu->cycle.lfu = current_time_monotonic();
@@ -179,7 +180,7 @@ void send_update(BWController *bwc)
         bwc->cycle.lsu = current_time_monotonic();
     }
 }
-static int on_update(BWController *bwc, const struct BWCMessage *msg)
+static int on_update(BWController *bwc, const struct BWCMessage *msg, void *userdata)
 {
     LOGGER_DEBUG(bwc->m->log, "%p Got update from peer", bwc);
 
@@ -199,16 +200,18 @@ static int on_update(BWController *bwc, const struct BWCMessage *msg)
     if (lost && bwc->mcb) {
         bwc->mcb(bwc, bwc->friend_number,
                  ((float) lost / (recv + lost)),
-                 bwc->mcb_data);
+                 bwc->mcb_data,
+                 userdata);
     }
 
     return 0;
 }
-int bwc_handle_data(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object)
+int bwc_handle_data(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object,
+                    void *userdata)
 {
     if (length - 1 != sizeof(struct BWCMessage)) {
         return -1;
     }
 
-    return on_update(object, (const struct BWCMessage *)(data + 1));
+    return on_update(object, (const struct BWCMessage *)(data + 1), userdata);
 }
diff --git a/toxav/bwcontroller.h b/toxav/bwcontroller.h
index 9542cde5..e2a7229b 100644
--- a/toxav/bwcontroller.h
+++ b/toxav/bwcontroller.h
@@ -27,8 +27,8 @@
 typedef struct BWController_s BWController;
 
 BWController *bwc_new(Messenger *m, uint32_t friendnumber,
-                      void (*mcb)(BWController *, uint32_t, float, void *),
-                      void *udata);
+                      void (*mcb)(BWController *, uint32_t, float, void *, void *),
+                      void *call_data);
 void bwc_kill(BWController *bwc);
 
 void bwc_feed_avg(BWController *bwc, uint32_t bytes);
diff --git a/toxav/msi.c b/toxav/msi.c
index d80d7c76..be467512 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -81,15 +81,16 @@ int msg_parse_in(Logger *log, MSIMessage *dest, const uint8_t *data, uint16_t le
 uint8_t *msg_parse_header_out(MSIHeaderID id, uint8_t *dest, const void *value, uint8_t value_len, uint16_t *length);
 static int send_message(Messenger *m, uint32_t friend_number, const MSIMessage *msg);
 int send_error(Messenger *m, uint32_t friend_number, MSIError error);
-static int invoke_callback(MSICall *call, MSICallbackID cb);
+static int invoke_callback(MSICall *call, MSICallbackID cb, void *userdata);
 static MSICall *get_call(MSISession *session, uint32_t friend_number);
 MSICall *new_call(MSISession *session, uint32_t friend_number);
 void kill_call(MSICall *call);
-void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *data);
-void handle_init(MSICall *call, const MSIMessage *msg);
-void handle_push(MSICall *call, const MSIMessage *msg);
-void handle_pop(MSICall *call, const MSIMessage *msg);
-void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data, uint16_t length, void *object);
+void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *data, void *userdata);
+void handle_init(MSICall *call, const MSIMessage *msg, void *userdata);
+void handle_push(MSICall *call, const MSIMessage *msg, void *userdata);
+void handle_pop(MSICall *call, const MSIMessage *msg, void *userdata);
+void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data, uint16_t length, void *object,
+                       void *userdata);
 
 
 /**
@@ -479,14 +480,14 @@ int send_error(Messenger *m, uint32_t friend_number, MSIError error)
     send_message(m, friend_number, &msg);
     return 0;
 }
-int invoke_callback(MSICall *call, MSICallbackID cb)
+int invoke_callback(MSICall *call, MSICallbackID cb, void *userdata)
 {
     assert(call);
 
     if (call->session->callbacks[cb]) {
         LOGGER_DEBUG(call->session->messenger->log, "Invoking callback function: %d", cb);
 
-        if (call->session->callbacks[cb](call->session->av, call) != 0) {
+        if (call->session->callbacks[cb](call->session->av, call, userdata) != 0) {
             LOGGER_WARNING(call->session->messenger->log,
                            "Callback state handling failed, sending error");
             goto FAILURE;
@@ -608,7 +609,7 @@ CLEAR_CONTAINER:
     free(call);
     session->calls = NULL;
 }
-void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *data)
+void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *data, void *userdata)
 {
     (void)m;
     MSISession *session = data;
@@ -625,7 +626,7 @@ void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *
                 return;
             }
 
-            invoke_callback(call, msi_OnPeerTimeout); /* Failure is ignored */
+            invoke_callback(call, msi_OnPeerTimeout, userdata); /* Failure is ignored */
             kill_call(call);
             pthread_mutex_unlock(session->mutex);
         }
@@ -635,7 +636,7 @@ void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *
             break;
     }
 }
-void handle_init(MSICall *call, const MSIMessage *msg)
+void handle_init(MSICall *call, const MSIMessage *msg, void *userdata)
 {
     assert(call);
     LOGGER_DEBUG(call->session->messenger->log,
@@ -653,7 +654,7 @@ void handle_init(MSICall *call, const MSIMessage *msg)
             call->peer_capabilities = msg->capabilities.value;
             call->state = msi_CallRequested;
 
-            if (invoke_callback(call, msi_OnInvite) == -1) {
+            if (invoke_callback(call, msi_OnInvite, userdata) == -1) {
                 goto FAILURE;
             }
         }
@@ -697,7 +698,7 @@ FAILURE:
     send_error(call->session->messenger, call->friend_number, call->error);
     kill_call(call);
 }
-void handle_push(MSICall *call, const MSIMessage *msg)
+void handle_push(MSICall *call, const MSIMessage *msg, void *userdata)
 {
     assert(call);
 
@@ -718,7 +719,7 @@ void handle_push(MSICall *call, const MSIMessage *msg)
 
                 call->peer_capabilities = msg->capabilities.value;
 
-                if (invoke_callback(call, msi_OnCapabilities) == -1) {
+                if (invoke_callback(call, msi_OnCapabilities, userdata) == -1) {
                     goto FAILURE;
                 }
             }
@@ -732,7 +733,7 @@ void handle_push(MSICall *call, const MSIMessage *msg)
             call->peer_capabilities = msg->capabilities.value;
             call->state = msi_CallActive;
 
-            if (invoke_callback(call, msi_OnStart) == -1) {
+            if (invoke_callback(call, msi_OnStart, userdata) == -1) {
                 goto FAILURE;
             }
         }
@@ -752,7 +753,7 @@ FAILURE:
     send_error(call->session->messenger, call->friend_number, call->error);
     kill_call(call);
 }
-void handle_pop(MSICall *call, const MSIMessage *msg)
+void handle_pop(MSICall *call, const MSIMessage *msg, void *userdata)
 {
     assert(call);
 
@@ -764,7 +765,7 @@ void handle_pop(MSICall *call, const MSIMessage *msg)
     if (msg->error.exists) {
         LOGGER_WARNING(call->session->messenger->log, "Friend detected an error: %d", msg->error.value);
         call->error = msg->error.value;
-        invoke_callback(call, msi_OnError);
+        invoke_callback(call, msi_OnError, userdata);
     } else {
         switch (call->state) {
             case msi_CallInactive: {
@@ -776,21 +777,21 @@ void handle_pop(MSICall *call, const MSIMessage *msg)
             case msi_CallActive: {
                 /* Hangup */
                 LOGGER_INFO(call->session->messenger->log, "Friend hung up on us");
-                invoke_callback(call, msi_OnEnd);
+                invoke_callback(call, msi_OnEnd, userdata);
             }
             break;
 
             case msi_CallRequesting: {
                 /* Reject */
                 LOGGER_INFO(call->session->messenger->log, "Friend rejected our call");
-                invoke_callback(call, msi_OnEnd);
+                invoke_callback(call, msi_OnEnd, userdata);
             }
             break;
 
             case msi_CallRequested: {
                 /* Cancel */
                 LOGGER_INFO(call->session->messenger->log, "Friend canceled call invite");
-                invoke_callback(call, msi_OnEnd);
+                invoke_callback(call, msi_OnEnd, userdata);
             }
             break;
         }
@@ -798,7 +799,8 @@ void handle_pop(MSICall *call, const MSIMessage *msg)
 
     kill_call(call);
 }
-void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data, uint16_t length, void *object)
+void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data, uint16_t length, void *object,
+                       void *userdata)
 {
     LOGGER_DEBUG(m->log, "Got msi message");
 
@@ -834,15 +836,15 @@ void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data
 
     switch (msg.request.value) {
         case requ_init:
-            handle_init(call, &msg);
+            handle_init(call, &msg, userdata);
             break;
 
         case requ_push:
-            handle_push(call, &msg);
+            handle_push(call, &msg, userdata);
             break;
 
         case requ_pop:
-            handle_pop(call, &msg); /* always kills the call */
+            handle_pop(call, &msg, userdata); /* always kills the call */
             break;
     }
 
diff --git a/toxav/msi.h b/toxav/msi.h
index bf611d34..05583239 100644
--- a/toxav/msi.h
+++ b/toxav/msi.h
@@ -102,7 +102,7 @@ typedef struct MSICall_s {
  * returned the call is considered errored and will be handled
  * as such which means it will be terminated without any notice.
  */
-typedef int msi_action_cb(void *av, MSICall *call);
+typedef int msi_action_cb(void *av, MSICall *call, void *userdata);
 
 /**
  * Control session struct. Please do not modify outside msi.c
diff --git a/toxav/rtp.c b/toxav/rtp.c
index 534efc1a..8c5f0dfb 100644
--- a/toxav/rtp.c
+++ b/toxav/rtp.c
@@ -35,7 +35,8 @@
 #include <stdlib.h>
 
 
-int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object);
+int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object,
+                      void *userdata);
 
 
 RTPSession *rtp_new(int payload_type, Messenger *m, uint32_t friendnumber,
@@ -233,7 +234,8 @@ static struct RTPMessage *new_message(size_t allocate_len, const uint8_t *data,
 
     return msg;
 }
-int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object)
+int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object,
+                      void *userdata)
 {
     (void) m;
     (void) friendnumber;
diff --git a/toxav/toxav.c b/toxav/toxav.c
index 1ae914e8..29046265 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -42,10 +42,16 @@ typedef struct ToxAVCall_s {
     ToxAV *av;
 
     pthread_mutex_t mutex_audio[1];
-    PAIR(RTPSession *, ACSession *) audio;
+    struct {
+        RTPSession *first;
+        ACSession *second;
+    } audio;
 
     pthread_mutex_t mutex_video[1];
-    PAIR(RTPSession *, VCSession *) video;
+    struct {
+        RTPSession *first;
+        VCSession *second;
+    } video;
 
     BWController *bwc;
 
@@ -75,11 +81,12 @@ struct ToxAV {
     uint32_t calls_head;
     pthread_mutex_t mutex[1];
 
-    PAIR(toxav_call_cb *, void *) ccb; /* Call callback */
-    PAIR(toxav_call_state_cb *, void *) scb; /* Call state callback */
-    PAIR(toxav_audio_receive_frame_cb *, void *) acb; /* Audio frame receive callback */
-    PAIR(toxav_video_receive_frame_cb *, void *) vcb; /* Video frame receive callback */
-    PAIR(toxav_bit_rate_status_cb *, void *) bcb; /* Bit rate control callback */
+    toxav_call_cb *on_call;
+    toxav_call_state_cb *on_call_state;
+    toxav_bit_rate_status_cb *on_bit_rate_status_change;
+
+    toxav_audio_receive_frame_cb *on_audio_frame;
+    toxav_video_receive_frame_cb *on_video_frame;
 
     /** Decode time measures */
     int32_t dmssc; /** Measure count */
@@ -89,17 +96,17 @@ struct ToxAV {
     uint32_t interval; /** Calculated interval */
 };
 
-void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *user_data);
+void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *call_data, void *userdata);
 
-int callback_invite(void *toxav_inst, MSICall *call);
-int callback_start(void *toxav_inst, MSICall *call);
-int callback_end(void *toxav_inst, MSICall *call);
-int callback_error(void *toxav_inst, MSICall *call);
-int callback_capabilites(void *toxav_inst, MSICall *call);
+int callback_invite(void *toxav_inst, MSICall *call, void *userdata);
+int callback_start(void *toxav_inst, MSICall *call, void *userdata);
+int callback_end(void *toxav_inst, MSICall *call, void *userdata);
+int callback_error(void *toxav_inst, MSICall *call, void *userdata);
+int callback_capabilites(void *toxav_inst, MSICall *call, void *userdata);
 
 bool audio_bit_rate_invalid(uint32_t bit_rate);
 bool video_bit_rate_invalid(uint32_t bit_rate);
-bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state);
+bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state, void *userdata);
 ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, TOXAV_ERR_CALL *error);
 ToxAVCall *call_get(ToxAV *av, uint32_t friend_number);
 ToxAVCall *call_remove(ToxAVCall *call);
@@ -230,7 +237,7 @@ uint32_t toxav_iteration_interval(const ToxAV *av)
     /* If no call is active interval is 200 */
     return av->calls ? av->interval : 200;
 }
-void toxav_iterate(ToxAV *av)
+void toxav_iterate(ToxAV *av, void *userdata)
 {
     pthread_mutex_lock(av->mutex);
 
@@ -249,8 +256,8 @@ void toxav_iterate(ToxAV *av)
             pthread_mutex_lock(i->mutex);
             pthread_mutex_unlock(av->mutex);
 
-            ac_iterate(i->audio.second);
-            vc_iterate(i->video.second);
+            ac_iterate(i->audio.second, userdata);
+            vc_iterate(i->video.second, userdata);
 
             if (i->msi_call->self_capabilities & msi_CapRAudio &&
                     i->msi_call->peer_capabilities & msi_CapSAudio) {
@@ -329,11 +336,10 @@ END:
 
     return rc == TOXAV_ERR_CALL_OK;
 }
-void toxav_callback_call(ToxAV *av, toxav_call_cb *callback, void *user_data)
+void toxav_callback_call(ToxAV *av, toxav_call_cb *callback)
 {
     pthread_mutex_lock(av->mutex);
-    av->ccb.first = callback;
-    av->ccb.second = user_data;
+    av->on_call = callback;
     pthread_mutex_unlock(av->mutex);
 }
 bool toxav_answer(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate,
@@ -388,11 +394,10 @@ END:
 
     return rc == TOXAV_ERR_ANSWER_OK;
 }
-void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback, void *user_data)
+void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback)
 {
     pthread_mutex_lock(av->mutex);
-    av->scb.first = callback;
-    av->scb.second = user_data;
+    av->on_call_state = callback;
     pthread_mutex_unlock(av->mutex);
 }
 bool toxav_call_control(ToxAV *av, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL *error)
@@ -664,11 +669,10 @@ END:
 
     return rc == TOXAV_ERR_BIT_RATE_SET_OK;
 }
-void toxav_callback_bit_rate_status(ToxAV *av, toxav_bit_rate_status_cb *callback, void *user_data)
+void toxav_callback_bit_rate_status(ToxAV *av, toxav_bit_rate_status_cb *callback)
 {
     pthread_mutex_lock(av->mutex);
-    av->bcb.first = callback;
-    av->bcb.second = user_data;
+    av->on_bit_rate_status_change = callback;
     pthread_mutex_unlock(av->mutex);
 }
 bool toxav_audio_send_frame(ToxAV *av, uint32_t friend_number, const int16_t *pcm, size_t sample_count,
@@ -856,18 +860,16 @@ END:
 
     return rc == TOXAV_ERR_SEND_FRAME_OK;
 }
-void toxav_callback_audio_receive_frame(ToxAV *av, toxav_audio_receive_frame_cb *callback, void *user_data)
+void toxav_callback_audio_receive_frame(ToxAV *av, toxav_audio_receive_frame_cb *callback)
 {
     pthread_mutex_lock(av->mutex);
-    av->acb.first = callback;
-    av->acb.second = user_data;
+    av->on_audio_frame = callback;
     pthread_mutex_unlock(av->mutex);
 }
-void toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb *callback, void *user_data)
+void toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb *callback)
 {
     pthread_mutex_lock(av->mutex);
-    av->vcb.first = callback;
-    av->vcb.second = user_data;
+    av->on_video_frame = callback;
     pthread_mutex_unlock(av->mutex);
 }
 
@@ -877,7 +879,7 @@ void toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb
  * :: Internal
  *
  ******************************************************************************/
-void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *user_data)
+void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *call_data, void *userdata)
 {
     /* Callback which is called when the internal measure mechanism reported packet loss.
      * We report suggested lowered bitrate to an app. If app is sending both audio and video,
@@ -886,7 +888,7 @@ void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *u
      * The application may choose to disable video totally if the stream is too bad.
      */
 
-    ToxAVCall *call = user_data;
+    ToxAVCall *call = call_data;
     assert(call);
 
     LOGGER_DEBUG(call->av->m->log, "Reported loss of %f%%", loss * 100);
@@ -897,25 +899,25 @@ void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *u
 
     pthread_mutex_lock(call->av->mutex);
 
-    if (!call->av->bcb.first) {
+    if (!call->av->on_bit_rate_status_change) {
         pthread_mutex_unlock(call->av->mutex);
         LOGGER_WARNING(call->av->m->log, "No callback to report loss on");
         return;
     }
 
     if (call->video_bit_rate) {
-        (*call->av->bcb.first)(call->av, friend_number, call->audio_bit_rate,
-                               call->video_bit_rate - (call->video_bit_rate * loss),
-                               call->av->bcb.second);
+        (*call->av->on_bit_rate_status_change)(call->av, friend_number, call->audio_bit_rate,
+                                               call->video_bit_rate - (call->video_bit_rate * loss),
+                                               userdata);
     } else if (call->audio_bit_rate) {
-        (*call->av->bcb.first)(call->av, friend_number,
-                               call->audio_bit_rate - (call->audio_bit_rate * loss),
-                               0, call->av->bcb.second);
+        (*call->av->on_bit_rate_status_change)(call->av, friend_number,
+                                               call->audio_bit_rate - (call->audio_bit_rate * loss),
+                                               0, userdata);
     }
 
     pthread_mutex_unlock(call->av->mutex);
 }
-int callback_invite(void *toxav_inst, MSICall *call)
+int callback_invite(void *toxav_inst, MSICall *call, void *userdata)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
@@ -931,9 +933,9 @@ int callback_invite(void *toxav_inst, MSICall *call)
     call->av_call = av_call;
     av_call->msi_call = call;
 
-    if (toxav->ccb.first) {
-        toxav->ccb.first(toxav, call->friend_number, call->peer_capabilities & msi_CapSAudio,
-                         call->peer_capabilities & msi_CapSVideo, toxav->ccb.second);
+    if (toxav->on_call) {
+        toxav->on_call(toxav, call->friend_number, call->peer_capabilities & msi_CapSAudio,
+                       call->peer_capabilities & msi_CapSVideo, userdata);
     } else {
         /* No handler to capture the call request, send failure */
         pthread_mutex_unlock(toxav->mutex);
@@ -943,7 +945,7 @@ int callback_invite(void *toxav_inst, MSICall *call)
     pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
-int callback_start(void *toxav_inst, MSICall *call)
+int callback_start(void *toxav_inst, MSICall *call, void *userdata)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
@@ -957,13 +959,13 @@ int callback_start(void *toxav_inst, MSICall *call)
     }
 
     if (!call_prepare_transmission(av_call)) {
-        callback_error(toxav_inst, call);
+        callback_error(toxav_inst, call, userdata);
         pthread_mutex_unlock(toxav->mutex);
         return -1;
     }
 
-    if (!invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities)) {
-        callback_error(toxav_inst, call);
+    if (!invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities, userdata)) {
+        callback_error(toxav_inst, call, userdata);
         pthread_mutex_unlock(toxav->mutex);
         return -1;
     }
@@ -971,12 +973,12 @@ int callback_start(void *toxav_inst, MSICall *call)
     pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
-int callback_end(void *toxav_inst, MSICall *call)
+int callback_end(void *toxav_inst, MSICall *call, void *userdata)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
-    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_FINISHED);
+    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_FINISHED, userdata);
 
     if (call->av_call) {
         call_kill_transmission(call->av_call);
@@ -986,12 +988,12 @@ int callback_end(void *toxav_inst, MSICall *call)
     pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
-int callback_error(void *toxav_inst, MSICall *call)
+int callback_error(void *toxav_inst, MSICall *call, void *userdata)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
-    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_ERROR);
+    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_ERROR, userdata);
 
     if (call->av_call) {
         call_kill_transmission(call->av_call);
@@ -1001,7 +1003,7 @@ int callback_error(void *toxav_inst, MSICall *call)
     pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
-int callback_capabilites(void *toxav_inst, MSICall *call)
+int callback_capabilites(void *toxav_inst, MSICall *call, void *userdata)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
@@ -1018,7 +1020,7 @@ int callback_capabilites(void *toxav_inst, MSICall *call)
         rtp_stop_receiving(((ToxAVCall *)call->av_call)->video.first);
     }
 
-    invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities);
+    invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities, userdata);
 
     pthread_mutex_unlock(toxav->mutex);
     return 0;
@@ -1036,10 +1038,10 @@ bool video_bit_rate_invalid(uint32_t bit_rate)
     /* TODO(mannol): If anyone knows the answer to this one please fill it up */
     return false;
 }
-bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state)
+bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state, void *userdata)
 {
-    if (av->scb.first) {
-        av->scb.first(av, friend_number, state, av->scb.second);
+    if (av->on_call_state) {
+        av->on_call_state(av, friend_number, state, userdata);
     } else {
         return false;
     }
@@ -1194,7 +1196,7 @@ bool call_prepare_transmission(ToxAVCall *call)
 
     ToxAV *av = call->av;
 
-    if (!av->acb.first && !av->vcb.first) {
+    if (!av->on_audio_frame && !av->on_video_frame) {
         /* It makes no sense to have CSession without callbacks */
         return false;
     }
@@ -1220,7 +1222,7 @@ bool call_prepare_transmission(ToxAVCall *call)
     call->bwc = bwc_new(av->m, call->friend_number, callback_bwc, call);
 
     { /* Prepare audio */
-        call->audio.second = ac_new(av->m->log, av, call->friend_number, av->acb.first, av->acb.second);
+        call->audio.second = ac_new(av->m->log, av, call->friend_number, av->on_audio_frame);
 
         if (!call->audio.second) {
             LOGGER_ERROR(av->m->log, "Failed to create audio codec session");
@@ -1236,7 +1238,7 @@ bool call_prepare_transmission(ToxAVCall *call)
         }
     }
     { /* Prepare video */
-        call->video.second = vc_new(av->m->log, av, call->friend_number, av->vcb.first, av->vcb.second);
+        call->video.second = vc_new(av->m->log, av, call->friend_number, av->on_video_frame);
 
         if (!call->video.second) {
             LOGGER_ERROR(av->m->log, "Failed to create video codec session");
diff --git a/toxav/toxav.h b/toxav/toxav.h
index 38ba354e..da0c4c35 100644
--- a/toxav/toxav.h
+++ b/toxav/toxav.h
@@ -232,7 +232,7 @@ uint32_t toxav_iteration_interval(const ToxAV *av);
  * toxav_iteration_interval() milliseconds. It is best called in the separate
  * thread from tox_iterate.
  */
-void toxav_iterate(ToxAV *av);
+void toxav_iterate(ToxAV *av, void *userdata);
 
 
 /*******************************************************************************
@@ -316,7 +316,7 @@ typedef void toxav_call_cb(ToxAV *av, uint32_t friend_number, bool audio_enabled
  * Set the callback for the `call` event. Pass NULL to unset.
  *
  */
-void toxav_callback_call(ToxAV *av, toxav_call_cb *callback, void *user_data);
+void toxav_callback_call(ToxAV *av, toxav_call_cb *callback);
 
 typedef enum TOXAV_ERR_ANSWER {
 
@@ -437,7 +437,7 @@ typedef void toxav_call_state_cb(ToxAV *av, uint32_t friend_number, uint32_t sta
  * Set the callback for the `call_state` event. Pass NULL to unset.
  *
  */
-void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback, void *user_data);
+void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback);
 
 
 /*******************************************************************************
@@ -613,7 +613,7 @@ typedef void toxav_bit_rate_status_cb(ToxAV *av, uint32_t friend_number, uint32_
  * Set the callback for the `bit_rate_status` event. Pass NULL to unset.
  *
  */
-void toxav_callback_bit_rate_status(ToxAV *av, toxav_bit_rate_status_cb *callback, void *user_data);
+void toxav_callback_bit_rate_status(ToxAV *av, toxav_bit_rate_status_cb *callback);
 
 
 /*******************************************************************************
@@ -742,7 +742,7 @@ typedef void toxav_audio_receive_frame_cb(ToxAV *av, uint32_t friend_number, con
  * Set the callback for the `audio_receive_frame` event. Pass NULL to unset.
  *
  */
-void toxav_callback_audio_receive_frame(ToxAV *av, toxav_audio_receive_frame_cb *callback, void *user_data);
+void toxav_callback_audio_receive_frame(ToxAV *av, toxav_audio_receive_frame_cb *callback);
 
 /**
  * The function type for the video_receive_frame callback.
@@ -774,7 +774,7 @@ typedef void toxav_video_receive_frame_cb(ToxAV *av, uint32_t friend_number, uin
  * Set the callback for the `video_receive_frame` event. Pass NULL to unset.
  *
  */
-void toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb *callback, void *user_data);
+void toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb *callback);
 
 /**
  * NOTE Compatibility with old toxav group calls. TODO(iphydf): remove
diff --git a/toxav/video.c b/toxav/video.c
index de028c7c..e786bc4c 100644
--- a/toxav/video.c
+++ b/toxav/video.c
@@ -37,7 +37,7 @@
 #define MAX_DECODE_TIME_US 0 /* Good quality encode. */
 #define VIDEO_DECODE_BUFFER_SIZE 20
 
-VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_receive_frame_cb *cb, void *cb_data)
+VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_receive_frame_cb *cb)
 {
     VCSession *vc = calloc(sizeof(VCSession), 1);
 
@@ -104,8 +104,7 @@ VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_re
 
     vc->linfts = current_time_monotonic();
     vc->lcfd = 60;
-    vc->vcb.first = cb;
-    vc->vcb.second = cb_data;
+    vc->on_video_frame = cb;
     vc->friend_number = friend_number;
     vc->av = av;
     vc->log = log;
@@ -142,7 +141,7 @@ void vc_kill(VCSession *vc)
     LOGGER_DEBUG(vc->log, "Terminated video handler: %p", vc);
     free(vc);
 }
-void vc_iterate(VCSession *vc)
+void vc_iterate(VCSession *vc, void *userdata)
 {
     if (!vc) {
         return;
@@ -168,10 +167,10 @@ void vc_iterate(VCSession *vc)
 
             /* Play decoded images */
             for (; dest; dest = vpx_codec_get_frame(vc->decoder, &iter)) {
-                if (vc->vcb.first) {
-                    vc->vcb.first(vc->av, vc->friend_number, dest->d_w, dest->d_h,
-                                  (const uint8_t *)dest->planes[0], (const uint8_t *)dest->planes[1], (const uint8_t *)dest->planes[2],
-                                  dest->stride[0], dest->stride[1], dest->stride[2], vc->vcb.second);
+                if (vc->on_video_frame) {
+                    vc->on_video_frame(vc->av, vc->friend_number, dest->d_w, dest->d_h,
+                                       (const uint8_t *)dest->planes[0], (const uint8_t *)dest->planes[1], (const uint8_t *)dest->planes[2],
+                                       dest->stride[0], dest->stride[1], dest->stride[2], userdata);
                 }
 
                 vpx_img_free(dest);
diff --git a/toxav/video.h b/toxav/video.h
index 335240c7..e24d98c9 100644
--- a/toxav/video.h
+++ b/toxav/video.h
@@ -56,14 +56,14 @@ typedef struct VCSession_s {
     ToxAV *av;
     uint32_t friend_number;
 
-    PAIR(toxav_video_receive_frame_cb *, void *) vcb; /* Video frame receive callback */
+    toxav_video_receive_frame_cb *on_video_frame; /* Video frame receive callback */
 
     pthread_mutex_t queue_mutex[1];
 } VCSession;
 
-VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_receive_frame_cb *cb, void *cb_data);
+VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_receive_frame_cb *cb);
 void vc_kill(VCSession *vc);
-void vc_iterate(VCSession *vc);
+void vc_iterate(VCSession *vc, void *userdata);
 int vc_queue_message(void *vcp, struct RTPMessage *msg);
 int vc_reconfigure_encoder(VCSession *vc, uint32_t bit_rate, uint16_t width, uint16_t height);