Revert "Make ToxAV stateless"

This reverts commit 21f8db12c45bd56293262cd4abfb73cd9abec821.

It is currently broken. Incoming call callbacks are not invoked, and
instead the client goes offline immediately.

21 files changed, 232 insertions, 310 deletions

diff --git a/auto_tests/toxav_basic_test.c b/auto_tests/toxav_basic_test.c
index 3904141f..da874849 100644
--- a/auto_tests/toxav_basic_test.c
+++ b/auto_tests/toxav_basic_test.c
@@ -133,12 +133,12 @@ static void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const
 /**
  * Iterate helper
  */
-static int iterate_tox(Tox *bootstrap, Tox *Alice, void *ACC, Tox *Bob, void *BCC)
+static int iterate_tox(Tox *bootstrap, Tox *Alice, Tox *Bob)
 {
     c_sleep(100);
     tox_iterate(bootstrap, NULL);
-    tox_iterate(Alice, ACC);
-    tox_iterate(Bob, BCC);
+    tox_iterate(Alice, NULL);
+    tox_iterate(Bob, NULL);
 
     return MIN(tox_iteration_interval(Alice), tox_iteration_interval(Bob));
 }
@@ -181,7 +181,7 @@ START_TEST(test_AV_flows)
     uint8_t off = 1;
 
     while (1) {
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
 
         if (tox_self_get_connection_status(bootstrap) &&
                 tox_self_get_connection_status(Alice) &&
@@ -208,15 +208,15 @@ START_TEST(test_AV_flows)
         ck_assert(error == TOXAV_ERR_NEW_OK);
     }
 
-    toxav_callback_call(AliceAV, t_toxav_call_cb);
-    toxav_callback_call_state(AliceAV, t_toxav_call_state_cb);
-    toxav_callback_video_receive_frame(AliceAV, t_toxav_receive_video_frame_cb);
-    toxav_callback_audio_receive_frame(AliceAV, t_toxav_receive_audio_frame_cb);
+    toxav_callback_call(AliceAV, t_toxav_call_cb, &AliceCC);
+    toxav_callback_call_state(AliceAV, t_toxav_call_state_cb, &AliceCC);
+    toxav_callback_video_receive_frame(AliceAV, t_toxav_receive_video_frame_cb, &AliceCC);
+    toxav_callback_audio_receive_frame(AliceAV, t_toxav_receive_audio_frame_cb, &AliceCC);
 
-    toxav_callback_call(BobAV, t_toxav_call_cb);
-    toxav_callback_call_state(BobAV, t_toxav_call_state_cb);
-    toxav_callback_video_receive_frame(BobAV, t_toxav_receive_video_frame_cb);
-    toxav_callback_audio_receive_frame(BobAV, t_toxav_receive_audio_frame_cb);
+    toxav_callback_call(BobAV, t_toxav_call_cb, &BobCC);
+    toxav_callback_call_state(BobAV, t_toxav_call_state_cb, &BobCC);
+    toxav_callback_video_receive_frame(BobAV, t_toxav_receive_video_frame_cb, &BobCC);
+    toxav_callback_audio_receive_frame(BobAV, t_toxav_receive_audio_frame_cb, &BobCC);
 
     printf("Created 2 instances of ToxAV\n");
     printf("All set after %llu seconds!\n", time(NULL) - cur_time);
@@ -265,7 +265,7 @@ START_TEST(test_AV_flows)
                 } \
             } \
              \
-            iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC); \
+            iterate_tox(bootstrap, Alice, Bob); \
         } \
         printf("Success!\n");\
     } while(0)
@@ -304,7 +304,7 @@ START_TEST(test_AV_flows)
         }
 
         while (!BobCC.incoming) {
-            iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+            iterate_tox(bootstrap, Alice, Bob);
         }
 
         /* Reject */
@@ -319,7 +319,7 @@ START_TEST(test_AV_flows)
         }
 
         while (AliceCC.state != TOXAV_FRIEND_CALL_STATE_FINISHED) {
-            iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+            iterate_tox(bootstrap, Alice, Bob);
         }
 
         printf("Success!\n");
@@ -342,7 +342,7 @@ START_TEST(test_AV_flows)
         }
 
         while (!BobCC.incoming) {
-            iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+            iterate_tox(bootstrap, Alice, Bob);
         }
 
         /* Cancel */
@@ -358,7 +358,7 @@ START_TEST(test_AV_flows)
 
         /* Alice will not receive end state */
         while (BobCC.state != TOXAV_FRIEND_CALL_STATE_FINISHED) {
-            iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+            iterate_tox(bootstrap, Alice, Bob);
         }
 
         printf("Success!\n");
@@ -382,7 +382,7 @@ START_TEST(test_AV_flows)
         }
 
         while (!BobCC.incoming) {
-            iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+            iterate_tox(bootstrap, Alice, Bob);
         }
 
         /* At first try all stuff while in invalid state */
@@ -403,39 +403,39 @@ START_TEST(test_AV_flows)
             }
         }
 
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
 
         /* Pause and Resume */
         printf("Pause and Resume\n");
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state == 0);
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state & (TOXAV_FRIEND_CALL_STATE_SENDING_A | TOXAV_FRIEND_CALL_STATE_SENDING_V));
 
         /* Mute/Unmute single */
         printf("Mute/Unmute single\n");
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state ^ TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
 
         /* Mute/Unmute both */
         printf("Mute/Unmute both\n");
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state ^ TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_HIDE_VIDEO);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state ^ TOXAV_FRIEND_CALL_STATE_ACCEPTING_V);
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_V);
 
         {
@@ -448,7 +448,7 @@ START_TEST(test_AV_flows)
             }
         }
 
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         printf("Success!\n");
@@ -472,7 +472,7 @@ START_TEST(test_AV_flows)
         }
 
         while (!BobCC.incoming) {
-            iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+            iterate_tox(bootstrap, Alice, Bob);
         }
 
         {
@@ -485,25 +485,25 @@ START_TEST(test_AV_flows)
             }
         }
 
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
 
         printf("Call started as audio only\n");
         printf("Turning on video for Alice...\n");
         ck_assert(toxav_bit_rate_set(AliceAV, 0, -1, 1000, NULL));
 
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_SENDING_V);
 
         printf("Turning off video for Alice...\n");
         ck_assert(toxav_bit_rate_set(AliceAV, 0, -1, 0, NULL));
 
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(!(BobCC.state & TOXAV_FRIEND_CALL_STATE_SENDING_V));
 
         printf("Turning off audio for Alice...\n");
         ck_assert(toxav_bit_rate_set(AliceAV, 0, 0, -1, NULL));
 
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(!(BobCC.state & TOXAV_FRIEND_CALL_STATE_SENDING_A));
 
         {
@@ -516,7 +516,7 @@ START_TEST(test_AV_flows)
             }
         }
 
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         printf("Success!\n");
@@ -540,7 +540,7 @@ START_TEST(test_AV_flows)
         }
 
         while (!BobCC.incoming) {
-            iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+            iterate_tox(bootstrap, Alice, Bob);
         }
 
         {
@@ -555,16 +555,16 @@ START_TEST(test_AV_flows)
 
         int16_t PCM[5670];
 
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(!toxav_audio_send_frame(AliceAV, 0, PCM, 960, 1, 48000, NULL));
         ck_assert(!toxav_audio_send_frame(BobAV, 0, PCM, 960, 1, 48000, NULL));
         ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME);
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(toxav_audio_send_frame(AliceAV, 0, PCM, 960, 1, 48000, NULL));
         ck_assert(toxav_audio_send_frame(BobAV, 0, PCM, 960, 1, 48000, NULL));
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
 
         {
             TOXAV_ERR_CALL_CONTROL rc;
@@ -576,7 +576,7 @@ START_TEST(test_AV_flows)
             }
         }
 
-        iterate_tox(bootstrap, Alice, &AliceCC, Bob, &BobCC);
+        iterate_tox(bootstrap, Alice, Bob);
         ck_assert(BobCC.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         printf("Success!\n");
diff --git a/auto_tests/toxav_many_test.c b/auto_tests/toxav_many_test.c
index a1688ac8..bdb5445b 100644
--- a/auto_tests/toxav_many_test.c
+++ b/auto_tests/toxav_many_test.c
@@ -113,17 +113,17 @@ static void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const
 /**
  * Iterate helper
  */
-static ToxAV *setup_av_instance(Tox *tox)
+static ToxAV *setup_av_instance(Tox *tox, CallControl *CC)
 {
     TOXAV_ERR_NEW error;
 
     ToxAV *av = toxav_new(tox, &error);
     ck_assert(error == TOXAV_ERR_NEW_OK);
 
-    toxav_callback_call(av, t_toxav_call_cb);
-    toxav_callback_call_state(av, t_toxav_call_state_cb);
-    toxav_callback_video_receive_frame(av, t_toxav_receive_video_frame_cb);
-    toxav_callback_audio_receive_frame(av, t_toxav_receive_audio_frame_cb);
+    toxav_callback_call(av, t_toxav_call_cb, CC);
+    toxav_callback_call_state(av, t_toxav_call_state_cb, CC);
+    toxav_callback_video_receive_frame(av, t_toxav_receive_video_frame_cb, CC);
+    toxav_callback_audio_receive_frame(av, t_toxav_receive_audio_frame_cb, CC);
 
     return av;
 }
@@ -172,8 +172,8 @@ static void *call_thread(void *pd)
     time_t start_time = time(NULL);
 
     while (time(NULL) - start_time < 4) {
-        toxav_iterate(AliceAV, &AliceCC);
-        toxav_iterate(BobAV, &BobCC);
+        toxav_iterate(AliceAV);
+        toxav_iterate(BobAV);
 
         toxav_audio_send_frame(AliceAV, friend_number, PCM, 960, 1, 48000, NULL);
         toxav_audio_send_frame(BobAV, 0, PCM, 960, 1, 48000, NULL);
@@ -250,10 +250,10 @@ START_TEST(test_AV_three_calls)
 
     while (1) {
         tox_iterate(bootstrap, NULL);
-        tox_iterate(Alice, &AliceCC);
-        tox_iterate(Bobs[0], &BobsCC[0]);
-        tox_iterate(Bobs[1], &BobsCC[1]);
-        tox_iterate(Bobs[2], &BobsCC[2]);
+        tox_iterate(Alice, NULL);
+        tox_iterate(Bobs[0], NULL);
+        tox_iterate(Bobs[1], NULL);
+        tox_iterate(Bobs[2], NULL);
 
         if (tox_self_get_connection_status(bootstrap) &&
                 tox_self_get_connection_status(Alice) &&
@@ -276,10 +276,10 @@ START_TEST(test_AV_three_calls)
         c_sleep(20);
     }
 
-    AliceAV = setup_av_instance(Alice);
-    BobsAV[0] = setup_av_instance(Bobs[0]);
-    BobsAV[1] = setup_av_instance(Bobs[1]);
-    BobsAV[2] = setup_av_instance(Bobs[2]);
+    AliceAV = setup_av_instance(Alice, AliceCC);
+    BobsAV[0] = setup_av_instance(Bobs[0], BobsCC + 0);
+    BobsAV[1] = setup_av_instance(Bobs[1], BobsCC + 1);
+    BobsAV[2] = setup_av_instance(Bobs[2], BobsCC + 2);
 
     printf("Created 4 instances of ToxAV\n");
     printf("All set after %llu seconds!\n", time(NULL) - cur_time);
@@ -315,10 +315,10 @@ START_TEST(test_AV_three_calls)
     time_t start_time = time(NULL);
 
     while (time(NULL) - start_time < 5) {
-        tox_iterate(Alice, AliceCC);
-        tox_iterate(Bobs[0], &BobsCC[0]);
-        tox_iterate(Bobs[1], &BobsCC[1]);
-        tox_iterate(Bobs[2], &BobsCC[2]);
+        tox_iterate(Alice, NULL);
+        tox_iterate(Bobs[0], NULL);
+        tox_iterate(Bobs[1], NULL);
+        tox_iterate(Bobs[2], NULL);
         c_sleep(20);
     }
 
diff --git a/other/apidsl/tox.in.h b/other/apidsl/tox.in.h
index b35dc38a..f3a06623 100644
--- a/other/apidsl/tox.in.h
+++ b/other/apidsl/tox.in.h
@@ -1089,10 +1089,6 @@ namespace friend {
    * function, this client will appear offline to the friend and no communication
    * can occur between the two.
    *
-   * WARNING, calling ${friend.delete} while there's an active ToxAV call will
-   * result in undefined behavior. It's the client's responsibility to end all
-   * ToxAV calls before deleting a friend.
-   *
    * @param friend_number Friend number for the friend to be deleted.
    *
    * @return true on success.
diff --git a/other/apidsl/toxav.in.h b/other/apidsl/toxav.in.h
index 67b670dc..8a7d5358 100644
--- a/other/apidsl/toxav.in.h
+++ b/other/apidsl/toxav.in.h
@@ -216,7 +216,7 @@ const uint32_t iteration_interval();
  * toxav_iteration_interval() milliseconds. It is best called in the separate
  * thread from tox_iterate.
  */
-void iterate(any userdata);
+void iterate();
 
 
 /*******************************************************************************
@@ -269,7 +269,7 @@ bool call(uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_ra
   INVALID_BIT_RATE,
 }
 
-event call const {
+event call {
   /**
    * The function type for the ${event call} callback.
    *
@@ -359,7 +359,7 @@ bitmask FRIEND_CALL_STATE {
   ACCEPTING_V,
 }
 
-event call_state const {
+event call_state {
  /**
   * The function type for the ${event call_state} callback.
   *
@@ -490,7 +490,7 @@ namespace bit_rate {
     FRIEND_NOT_IN_CALL,
   }
 
-  event status const {
+  event status {
     /**
      * The function type for the ${event status} callback. The event is triggered
      * when the network becomes too saturated for current bit rates at which
@@ -601,7 +601,7 @@ namespace video {
 
 
 namespace audio {
-  event receive_frame const {
+  event receive_frame {
     /**
      * The function type for the ${event receive_frame} callback. The callback can be
      * called multiple times per single iteration depending on the amount of queued
@@ -620,7 +620,7 @@ namespace audio {
 }
 
 namespace video {
-  event receive_frame const {
+  event receive_frame {
     /**
      * The function type for the ${event receive_frame} callback.
      *
diff --git a/other/toktok-rebase b/other/toktok-rebase
deleted file mode 100644
index c6f9f38a..00000000
--- a/other/toktok-rebase
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/usr/bin/zsh
-
-if [[ $1 == '-v' ]]; then
-    set -u -x
-fi
-
-PREHEAD=`git rev-parse --abbrev-ref HEAD`
-TRGT=`git show-ref toktok/master --hash`
-EXCLD=`git branch --contains $TRGT`
-
-FAILED=()
-SUCCESS=()
-EXCLUDED=()
-
-echo "Auto Rebaseing!"
-git fetch --all > /dev/null 2>&1
-
-if [[ $1 == '-v' ]]; then
-    git branch --no-merged=toktok/master
-fi
-
-for i in `git branch --no-merged=toktok/master`; do
-    each=`echo $i | sed 's/*//'`
-
-    # quick exclude
-    if [[ ${EXCLD[(i)${each}]} -le ${#EXCLD} ]]; then
-        EXCLUDED+=$each
-        continue
-    fi
-
-    git checkout $each > /dev/null 2>&1
-    git rebase toktok/master > /dev/null 2>&1
-    if [[ $? != 0 ]]; then
-        git rebase --abort > /dev/null 2>&1
-        FAILED+=($each)
-    else
-        SUCCESS+=($each)
-    fi
-done
-
-echo "Was able to rebase (Don't forget to git push --force)"
-echo "\t $SUCCESS"
-echo "These branches failed"
-echo "\t $FAILED"
-echo "These branches were skipped without changes"
-echo "\t $EXCLUDED"
-
-git checkout $PREHEAD > /dev/null 2>&1
diff --git a/testing/av_test.c b/testing/av_test.c
index 46212255..28796abb 100644
--- a/testing/av_test.c
+++ b/testing/av_test.c
@@ -80,9 +80,7 @@ typedef struct {
 
 struct toxav_thread_data {
     ToxAV  *AliceAV;
-    void   *AliceCC;
     ToxAV  *BobAV;
-    void   *BobCC;
     int32_t sig;
 };
 
@@ -272,32 +270,31 @@ static void initialize_tox(Tox **bootstrap, ToxAV **AliceAV, CallControl *AliceC
 
 
     /* Alice */
-    toxav_callback_call(*AliceAV, t_toxav_call_cb);
-    toxav_callback_call_state(*AliceAV, t_toxav_call_state_cb);
-    toxav_callback_bit_rate_status(*AliceAV, t_toxav_bit_rate_status_cb);
-    toxav_callback_video_receive_frame(*AliceAV, t_toxav_receive_video_frame_cb);
-    toxav_callback_audio_receive_frame(*AliceAV, t_toxav_receive_audio_frame_cb);
+    toxav_callback_call(*AliceAV, t_toxav_call_cb, AliceCC);
+    toxav_callback_call_state(*AliceAV, t_toxav_call_state_cb, AliceCC);
+    toxav_callback_bit_rate_status(*AliceAV, t_toxav_bit_rate_status_cb, AliceCC);
+    toxav_callback_video_receive_frame(*AliceAV, t_toxav_receive_video_frame_cb, AliceCC);
+    toxav_callback_audio_receive_frame(*AliceAV, t_toxav_receive_audio_frame_cb, AliceCC);
 
     /* Bob */
-    toxav_callback_call(*BobAV, t_toxav_call_cb);
-    toxav_callback_call_state(*BobAV, t_toxav_call_state_cb);
-    toxav_callback_bit_rate_status(*BobAV, t_toxav_bit_rate_status_cb);
-    toxav_callback_video_receive_frame(*BobAV, t_toxav_receive_video_frame_cb);
-    toxav_callback_audio_receive_frame(*BobAV, t_toxav_receive_audio_frame_cb);
+    toxav_callback_call(*BobAV, t_toxav_call_cb, BobCC);
+    toxav_callback_call_state(*BobAV, t_toxav_call_state_cb, BobCC);
+    toxav_callback_bit_rate_status(*BobAV, t_toxav_bit_rate_status_cb, BobCC);
+    toxav_callback_video_receive_frame(*BobAV, t_toxav_receive_video_frame_cb, BobCC);
+    toxav_callback_audio_receive_frame(*BobAV, t_toxav_receive_audio_frame_cb, BobCC);
 
 
     printf("Created 2 instances of ToxAV\n");
     printf("All set after %llu seconds!\n", time(NULL) - cur_time);
 }
-static int iterate_tox(Tox *bootstrap, ToxAV *AliceAV, void *aCC, ToxAV *BobAV, void *bCC)
+static int iterate_tox(Tox *bootstrap, ToxAV *AliceAV, ToxAV *BobAV, void *userdata)
 {
-    tox_iterate(bootstrap, NULL);
-    tox_iterate(toxav_get_tox(AliceAV), aCC);
-    tox_iterate(toxav_get_tox(BobAV), bCC);
+    tox_iterate(bootstrap, userdata);
+    tox_iterate(toxav_get_tox(AliceAV), userdata);
+    tox_iterate(toxav_get_tox(BobAV), userdata);
 
     return MIN(tox_iteration_interval(toxav_get_tox(AliceAV)), tox_iteration_interval(toxav_get_tox(BobAV)));
 }
-
 static void *iterate_toxav(void *data)
 {
     struct toxav_thread_data *data_cast = data;
@@ -306,8 +303,8 @@ static void *iterate_toxav(void *data)
 #endif
 
     while (data_cast->sig == 0) {
-        toxav_iterate(data_cast->AliceAV, data_cast->AliceCC);
-        toxav_iterate(data_cast->BobAV, data_cast->BobCC);
+        toxav_iterate(data_cast->AliceAV);
+        toxav_iterate(data_cast->BobAV);
         int rc = MIN(toxav_iteration_interval(data_cast->AliceAV), toxav_iteration_interval(data_cast->BobAV));
 
         printf("\rIteration interval: %d            ", rc);
@@ -552,7 +549,7 @@ CHECK_ARG:
         }
 
         while (!BobCC.incoming) {
-            iterate_tox(bootstrap, AliceAV, &AliceCC, BobAV, &BobCC);
+            iterate_tox(bootstrap, AliceAV, BobAV, NULL);
         }
 
         { /* Answer */
@@ -566,7 +563,7 @@ CHECK_ARG:
         }
 
         while (AliceCC.state == 0) {
-            iterate_tox(bootstrap, AliceAV, &AliceCC, BobAV, &BobCC);
+            iterate_tox(bootstrap, AliceAV, BobAV, NULL);
         }
 
         /* Open audio file */
@@ -631,7 +628,7 @@ CHECK_ARG:
                 }
             }
 
-            iterate_tox(bootstrap, AliceAV, &AliceCC, BobAV, &BobCC);
+            iterate_tox(bootstrap, AliceAV, BobAV, NULL);
             c_sleep((audio_frame_duration - (current_time_monotonic() - enc_start_time) - 1));
         }
 
@@ -650,7 +647,7 @@ CHECK_ARG:
             }
         }
 
-        iterate_tox(bootstrap, AliceAV, &AliceCC, BobAV, &BobCC);
+        iterate_tox(bootstrap, AliceAV, BobAV, NULL);
         assert(BobCC.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         /* Stop decode thread */
@@ -693,7 +690,7 @@ CHECK_ARG:
         }
 
         while (!BobCC.incoming) {
-            iterate_tox(bootstrap, AliceAV, &AliceCC, BobAV, &BobCC);
+            iterate_tox(bootstrap, AliceAV, BobAV, NULL);
         }
 
         { /* Answer */
@@ -706,14 +703,12 @@ CHECK_ARG:
             }
         }
 
-        iterate_tox(bootstrap, AliceAV, &AliceCC, BobAV, &BobCC);
+        iterate_tox(bootstrap, AliceAV, BobAV, NULL);
 
         /* Start decode thread */
         struct toxav_thread_data data = {
             .AliceAV = AliceAV,
-            .AliceCC = &AliceCC,
             .BobAV = BobAV,
-            .BobCC = &BobCC,
             .sig = 0
         };
 
@@ -740,7 +735,7 @@ CHECK_ARG:
             }
 
             send_opencv_img(AliceAV, 0, frame);
-            iterate_tox(bootstrap, AliceAV, &AliceCC, BobAV, &BobCC);
+            iterate_tox(bootstrap, AliceAV, BobAV, NULL);
             c_sleep(10);
         }
 
@@ -756,7 +751,7 @@ CHECK_ARG:
             }
         }
 
-        iterate_tox(bootstrap, AliceAV, &AliceCC, BobAV, &BobCC);
+        iterate_tox(bootstrap, AliceAV, BobAV, NULL);
         assert(BobCC.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         /* Stop decode thread */
diff --git a/toxav/audio.c b/toxav/audio.c
index 3fb0985e..59d1554e 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)
+ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb, void *cb_data)
 {
     ACSession *ac = calloc(sizeof(ACSession), 1);
 
@@ -97,7 +97,8 @@ ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_re
 
     ac->av = av;
     ac->friend_number = friend_number;
-    ac->on_audio_frame = cb;
+    ac->acb.first = cb;
+    ac->acb.second = cb_data;
 
     return ac;
 
@@ -124,7 +125,7 @@ void ac_kill(ACSession *ac)
     LOGGER_DEBUG(ac->log, "Terminated audio handler: %p", ac);
     free(ac);
 }
-void ac_iterate(ACSession *ac, void *userdata)
+void ac_iterate(ACSession *ac)
 {
     if (!ac) {
         return;
@@ -185,11 +186,11 @@ void ac_iterate(ACSession *ac, void *userdata)
 
         if (rc < 0) {
             LOGGER_WARNING(ac->log, "Decoding error: %s", opus_strerror(rc));
-        } else if (ac->on_audio_frame) {
+        } else if (ac->acb.first) {
             ac->lp_frame_duration = (rc * 1000) / ac->lp_sampling_rate;
 
-            ac->on_audio_frame(ac->av, ac->friend_number, tmp, rc, ac->lp_channel_count,
-                               ac->lp_sampling_rate, userdata);
+            ac->acb.first(ac->av, ac->friend_number, tmp, rc, ac->lp_channel_count,
+                          ac->lp_sampling_rate, ac->acb.second);
         }
 
         return;
diff --git a/toxav/audio.h b/toxav/audio.h
index 60bad163..5f9d7f7d 100644
--- a/toxav/audio.h
+++ b/toxav/audio.h
@@ -55,12 +55,12 @@ typedef struct ACSession_s {
 
     ToxAV *av;
     uint32_t friend_number;
-    toxav_audio_receive_frame_cb *on_audio_frame; /* Audio frame receive callback */
+    PAIR(toxav_audio_receive_frame_cb *, void *) acb; /* Audio frame receive callback */
 } ACSession;
 
-ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb);
+ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb, void *cb_data);
 void ac_kill(ACSession *ac);
-void ac_iterate(ACSession *ac, void *userdata);
+void ac_iterate(ACSession *ac);
 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 63350f17..b97135d6 100644
--- a/toxav/bwcontroller.c
+++ b/toxav/bwcontroller.c
@@ -40,7 +40,7 @@
  */
 
 struct BWController_s {
-    void (*mcb)(BWController *, uint32_t, float, void *, void *);
+    void (*mcb)(BWController *, uint32_t, float, void *);
     void *mcb_data;
 
     Messenger *m;
@@ -61,18 +61,17 @@ 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,
-                    void *userdata);
+int bwc_handle_data(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object);
 void send_update(BWController *bwc);
 
 BWController *bwc_new(Messenger *m, uint32_t friendnumber,
-                      void (*mcb)(BWController *, uint32_t, float, void *, void *),
-                      void *call_data)
+                      void (*mcb)(BWController *, uint32_t, float, void *),
+                      void *udata)
 {
     BWController *retu = calloc(sizeof(struct BWController_s), 1);
 
     retu->mcb = mcb;
-    retu->mcb_data = call_data;
+    retu->mcb_data = udata;
     retu->m = m;
     retu->friend_number = friendnumber;
     retu->cycle.lsu = retu->cycle.lfu = current_time_monotonic();
@@ -180,7 +179,7 @@ void send_update(BWController *bwc)
         bwc->cycle.lsu = current_time_monotonic();
     }
 }
-static int on_update(BWController *bwc, const struct BWCMessage *msg, void *userdata)
+static int on_update(BWController *bwc, const struct BWCMessage *msg)
 {
     LOGGER_DEBUG(bwc->m->log, "%p Got update from peer", bwc);
 
@@ -200,18 +199,16 @@ static int on_update(BWController *bwc, const struct BWCMessage *msg, void *user
     if (lost && bwc->mcb) {
         bwc->mcb(bwc, bwc->friend_number,
                  ((float) lost / (recv + lost)),
-                 bwc->mcb_data,
-                 userdata);
+                 bwc->mcb_data);
     }
 
     return 0;
 }
-int bwc_handle_data(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object,
-                    void *userdata)
+int bwc_handle_data(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object)
 {
     if (length - 1 != sizeof(struct BWCMessage)) {
         return -1;
     }
 
-    return on_update(object, (const struct BWCMessage *)(data + 1), userdata);
+    return on_update(object, (const struct BWCMessage *)(data + 1));
 }
diff --git a/toxav/bwcontroller.h b/toxav/bwcontroller.h
index e2a7229b..9542cde5 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 *),
-                      void *call_data);
+                      void (*mcb)(BWController *, uint32_t, float, void *),
+                      void *udata);
 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 be467512..d80d7c76 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -81,16 +81,15 @@ 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, void *userdata);
+static int invoke_callback(MSICall *call, MSICallbackID cb);
 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 *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);
+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);
 
 
 /**
@@ -480,14 +479,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, void *userdata)
+int invoke_callback(MSICall *call, MSICallbackID cb)
 {
     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, userdata) != 0) {
+        if (call->session->callbacks[cb](call->session->av, call) != 0) {
             LOGGER_WARNING(call->session->messenger->log,
                            "Callback state handling failed, sending error");
             goto FAILURE;
@@ -609,7 +608,7 @@ CLEAR_CONTAINER:
     free(call);
     session->calls = NULL;
 }
-void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *data, void *userdata)
+void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *data)
 {
     (void)m;
     MSISession *session = data;
@@ -626,7 +625,7 @@ void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *
                 return;
             }
 
-            invoke_callback(call, msi_OnPeerTimeout, userdata); /* Failure is ignored */
+            invoke_callback(call, msi_OnPeerTimeout); /* Failure is ignored */
             kill_call(call);
             pthread_mutex_unlock(session->mutex);
         }
@@ -636,7 +635,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 *userdata)
+void handle_init(MSICall *call, const MSIMessage *msg)
 {
     assert(call);
     LOGGER_DEBUG(call->session->messenger->log,
@@ -654,7 +653,7 @@ void handle_init(MSICall *call, const MSIMessage *msg, void *userdata)
             call->peer_capabilities = msg->capabilities.value;
             call->state = msi_CallRequested;
 
-            if (invoke_callback(call, msi_OnInvite, userdata) == -1) {
+            if (invoke_callback(call, msi_OnInvite) == -1) {
                 goto FAILURE;
             }
         }
@@ -698,7 +697,7 @@ FAILURE:
     send_error(call->session->messenger, call->friend_number, call->error);
     kill_call(call);
 }
-void handle_push(MSICall *call, const MSIMessage *msg, void *userdata)
+void handle_push(MSICall *call, const MSIMessage *msg)
 {
     assert(call);
 
@@ -719,7 +718,7 @@ void handle_push(MSICall *call, const MSIMessage *msg, void *userdata)
 
                 call->peer_capabilities = msg->capabilities.value;
 
-                if (invoke_callback(call, msi_OnCapabilities, userdata) == -1) {
+                if (invoke_callback(call, msi_OnCapabilities) == -1) {
                     goto FAILURE;
                 }
             }
@@ -733,7 +732,7 @@ void handle_push(MSICall *call, const MSIMessage *msg, void *userdata)
             call->peer_capabilities = msg->capabilities.value;
             call->state = msi_CallActive;
 
-            if (invoke_callback(call, msi_OnStart, userdata) == -1) {
+            if (invoke_callback(call, msi_OnStart) == -1) {
                 goto FAILURE;
             }
         }
@@ -753,7 +752,7 @@ FAILURE:
     send_error(call->session->messenger, call->friend_number, call->error);
     kill_call(call);
 }
-void handle_pop(MSICall *call, const MSIMessage *msg, void *userdata)
+void handle_pop(MSICall *call, const MSIMessage *msg)
 {
     assert(call);
 
@@ -765,7 +764,7 @@ void handle_pop(MSICall *call, const MSIMessage *msg, void *userdata)
     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, userdata);
+        invoke_callback(call, msi_OnError);
     } else {
         switch (call->state) {
             case msi_CallInactive: {
@@ -777,21 +776,21 @@ void handle_pop(MSICall *call, const MSIMessage *msg, void *userdata)
             case msi_CallActive: {
                 /* Hangup */
                 LOGGER_INFO(call->session->messenger->log, "Friend hung up on us");
-                invoke_callback(call, msi_OnEnd, userdata);
+                invoke_callback(call, msi_OnEnd);
             }
             break;
 
             case msi_CallRequesting: {
                 /* Reject */
                 LOGGER_INFO(call->session->messenger->log, "Friend rejected our call");
-                invoke_callback(call, msi_OnEnd, userdata);
+                invoke_callback(call, msi_OnEnd);
             }
             break;
 
             case msi_CallRequested: {
                 /* Cancel */
                 LOGGER_INFO(call->session->messenger->log, "Friend canceled call invite");
-                invoke_callback(call, msi_OnEnd, userdata);
+                invoke_callback(call, msi_OnEnd);
             }
             break;
         }
@@ -799,8 +798,7 @@ void handle_pop(MSICall *call, const MSIMessage *msg, void *userdata)
 
     kill_call(call);
 }
-void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data, uint16_t length, void *object,
-                       void *userdata)
+void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data, uint16_t length, void *object)
 {
     LOGGER_DEBUG(m->log, "Got msi message");
 
@@ -836,15 +834,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, userdata);
+            handle_init(call, &msg);
             break;
 
         case requ_push:
-            handle_push(call, &msg, userdata);
+            handle_push(call, &msg);
             break;
 
         case requ_pop:
-            handle_pop(call, &msg, userdata); /* always kills the call */
+            handle_pop(call, &msg); /* always kills the call */
             break;
     }
 
diff --git a/toxav/msi.h b/toxav/msi.h
index 05583239..bf611d34 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, void *userdata);
+typedef int msi_action_cb(void *av, MSICall *call);
 
 /**
  * Control session struct. Please do not modify outside msi.c
diff --git a/toxav/rtp.c b/toxav/rtp.c
index 8c5f0dfb..534efc1a 100644
--- a/toxav/rtp.c
+++ b/toxav/rtp.c
@@ -35,8 +35,7 @@
 #include <stdlib.h>
 
 
-int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object,
-                      void *userdata);
+int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object);
 
 
 RTPSession *rtp_new(int payload_type, Messenger *m, uint32_t friendnumber,
@@ -234,8 +233,7 @@ 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,
-                      void *userdata)
+int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object)
 {
     (void) m;
     (void) friendnumber;
diff --git a/toxav/toxav.c b/toxav/toxav.c
index 29046265..1ae914e8 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -42,16 +42,10 @@ typedef struct ToxAVCall_s {
     ToxAV *av;
 
     pthread_mutex_t mutex_audio[1];
-    struct {
-        RTPSession *first;
-        ACSession *second;
-    } audio;
+    PAIR(RTPSession *, ACSession *) audio;
 
     pthread_mutex_t mutex_video[1];
-    struct {
-        RTPSession *first;
-        VCSession *second;
-    } video;
+    PAIR(RTPSession *, VCSession *) video;
 
     BWController *bwc;
 
@@ -81,12 +75,11 @@ struct ToxAV {
     uint32_t calls_head;
     pthread_mutex_t mutex[1];
 
-    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;
+    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 */
 
     /** Decode time measures */
     int32_t dmssc; /** Measure count */
@@ -96,17 +89,17 @@ struct ToxAV {
     uint32_t interval; /** Calculated interval */
 };
 
-void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *call_data, void *userdata);
+void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *user_data);
 
-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);
+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);
 
 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, void *userdata);
+bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state);
 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);
@@ -237,7 +230,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 *userdata)
+void toxav_iterate(ToxAV *av)
 {
     pthread_mutex_lock(av->mutex);
 
@@ -256,8 +249,8 @@ void toxav_iterate(ToxAV *av, void *userdata)
             pthread_mutex_lock(i->mutex);
             pthread_mutex_unlock(av->mutex);
 
-            ac_iterate(i->audio.second, userdata);
-            vc_iterate(i->video.second, userdata);
+            ac_iterate(i->audio.second);
+            vc_iterate(i->video.second);
 
             if (i->msi_call->self_capabilities & msi_CapRAudio &&
                     i->msi_call->peer_capabilities & msi_CapSAudio) {
@@ -336,10 +329,11 @@ END:
 
     return rc == TOXAV_ERR_CALL_OK;
 }
-void toxav_callback_call(ToxAV *av, toxav_call_cb *callback)
+void toxav_callback_call(ToxAV *av, toxav_call_cb *callback, void *user_data)
 {
     pthread_mutex_lock(av->mutex);
-    av->on_call = callback;
+    av->ccb.first = callback;
+    av->ccb.second = user_data;
     pthread_mutex_unlock(av->mutex);
 }
 bool toxav_answer(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate,
@@ -394,10 +388,11 @@ END:
 
     return rc == TOXAV_ERR_ANSWER_OK;
 }
-void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback)
+void toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback, void *user_data)
 {
     pthread_mutex_lock(av->mutex);
-    av->on_call_state = callback;
+    av->scb.first = callback;
+    av->scb.second = user_data;
     pthread_mutex_unlock(av->mutex);
 }
 bool toxav_call_control(ToxAV *av, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL *error)
@@ -669,10 +664,11 @@ END:
 
     return rc == TOXAV_ERR_BIT_RATE_SET_OK;
 }
-void toxav_callback_bit_rate_status(ToxAV *av, toxav_bit_rate_status_cb *callback)
+void toxav_callback_bit_rate_status(ToxAV *av, toxav_bit_rate_status_cb *callback, void *user_data)
 {
     pthread_mutex_lock(av->mutex);
-    av->on_bit_rate_status_change = callback;
+    av->bcb.first = callback;
+    av->bcb.second = user_data;
     pthread_mutex_unlock(av->mutex);
 }
 bool toxav_audio_send_frame(ToxAV *av, uint32_t friend_number, const int16_t *pcm, size_t sample_count,
@@ -860,16 +856,18 @@ END:
 
     return rc == TOXAV_ERR_SEND_FRAME_OK;
 }
-void toxav_callback_audio_receive_frame(ToxAV *av, toxav_audio_receive_frame_cb *callback)
+void toxav_callback_audio_receive_frame(ToxAV *av, toxav_audio_receive_frame_cb *callback, void *user_data)
 {
     pthread_mutex_lock(av->mutex);
-    av->on_audio_frame = callback;
+    av->acb.first = callback;
+    av->acb.second = user_data;
     pthread_mutex_unlock(av->mutex);
 }
-void toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb *callback)
+void toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb *callback, void *user_data)
 {
     pthread_mutex_lock(av->mutex);
-    av->on_video_frame = callback;
+    av->vcb.first = callback;
+    av->vcb.second = user_data;
     pthread_mutex_unlock(av->mutex);
 }
 
@@ -879,7 +877,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 *call_data, void *userdata)
+void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *user_data)
 {
     /* 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,
@@ -888,7 +886,7 @@ void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *c
      * The application may choose to disable video totally if the stream is too bad.
      */
 
-    ToxAVCall *call = call_data;
+    ToxAVCall *call = user_data;
     assert(call);
 
     LOGGER_DEBUG(call->av->m->log, "Reported loss of %f%%", loss * 100);
@@ -899,25 +897,25 @@ void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *c
 
     pthread_mutex_lock(call->av->mutex);
 
-    if (!call->av->on_bit_rate_status_change) {
+    if (!call->av->bcb.first) {
         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->on_bit_rate_status_change)(call->av, friend_number, call->audio_bit_rate,
-                                               call->video_bit_rate - (call->video_bit_rate * loss),
-                                               userdata);
+        (*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);
     } else if (call->audio_bit_rate) {
-        (*call->av->on_bit_rate_status_change)(call->av, friend_number,
-                                               call->audio_bit_rate - (call->audio_bit_rate * loss),
-                                               0, userdata);
+        (*call->av->bcb.first)(call->av, friend_number,
+                               call->audio_bit_rate - (call->audio_bit_rate * loss),
+                               0, call->av->bcb.second);
     }
 
     pthread_mutex_unlock(call->av->mutex);
 }
-int callback_invite(void *toxav_inst, MSICall *call, void *userdata)
+int callback_invite(void *toxav_inst, MSICall *call)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
@@ -933,9 +931,9 @@ int callback_invite(void *toxav_inst, MSICall *call, void *userdata)
     call->av_call = av_call;
     av_call->msi_call = call;
 
-    if (toxav->on_call) {
-        toxav->on_call(toxav, call->friend_number, call->peer_capabilities & msi_CapSAudio,
-                       call->peer_capabilities & msi_CapSVideo, userdata);
+    if (toxav->ccb.first) {
+        toxav->ccb.first(toxav, call->friend_number, call->peer_capabilities & msi_CapSAudio,
+                         call->peer_capabilities & msi_CapSVideo, toxav->ccb.second);
     } else {
         /* No handler to capture the call request, send failure */
         pthread_mutex_unlock(toxav->mutex);
@@ -945,7 +943,7 @@ int callback_invite(void *toxav_inst, MSICall *call, void *userdata)
     pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
-int callback_start(void *toxav_inst, MSICall *call, void *userdata)
+int callback_start(void *toxav_inst, MSICall *call)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
@@ -959,13 +957,13 @@ int callback_start(void *toxav_inst, MSICall *call, void *userdata)
     }
 
     if (!call_prepare_transmission(av_call)) {
-        callback_error(toxav_inst, call, userdata);
+        callback_error(toxav_inst, call);
         pthread_mutex_unlock(toxav->mutex);
         return -1;
     }
 
-    if (!invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities, userdata)) {
-        callback_error(toxav_inst, call, userdata);
+    if (!invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities)) {
+        callback_error(toxav_inst, call);
         pthread_mutex_unlock(toxav->mutex);
         return -1;
     }
@@ -973,12 +971,12 @@ int callback_start(void *toxav_inst, MSICall *call, void *userdata)
     pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
-int callback_end(void *toxav_inst, MSICall *call, void *userdata)
+int callback_end(void *toxav_inst, MSICall *call)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
-    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_FINISHED, userdata);
+    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_FINISHED);
 
     if (call->av_call) {
         call_kill_transmission(call->av_call);
@@ -988,12 +986,12 @@ int callback_end(void *toxav_inst, MSICall *call, void *userdata)
     pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
-int callback_error(void *toxav_inst, MSICall *call, void *userdata)
+int callback_error(void *toxav_inst, MSICall *call)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
-    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_ERROR, userdata);
+    invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_ERROR);
 
     if (call->av_call) {
         call_kill_transmission(call->av_call);
@@ -1003,7 +1001,7 @@ int callback_error(void *toxav_inst, MSICall *call, void *userdata)
     pthread_mutex_unlock(toxav->mutex);
     return 0;
 }
-int callback_capabilites(void *toxav_inst, MSICall *call, void *userdata)
+int callback_capabilites(void *toxav_inst, MSICall *call)
 {
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
@@ -1020,7 +1018,7 @@ int callback_capabilites(void *toxav_inst, MSICall *call, void *userdata)
         rtp_stop_receiving(((ToxAVCall *)call->av_call)->video.first);
     }
 
-    invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities, userdata);
+    invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities);
 
     pthread_mutex_unlock(toxav->mutex);
     return 0;
@@ -1038,10 +1036,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, void *userdata)
+bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state)
 {
-    if (av->on_call_state) {
-        av->on_call_state(av, friend_number, state, userdata);
+    if (av->scb.first) {
+        av->scb.first(av, friend_number, state, av->scb.second);
     } else {
         return false;
     }
@@ -1196,7 +1194,7 @@ bool call_prepare_transmission(ToxAVCall *call)
 
     ToxAV *av = call->av;
 
-    if (!av->on_audio_frame && !av->on_video_frame) {
+    if (!av->acb.first && !av->vcb.first) {
         /* It makes no sense to have CSession without callbacks */
         return false;
     }
@@ -1222,7 +1220,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->on_audio_frame);
+        call->audio.second = ac_new(av->m->log, av, call->friend_number, av->acb.first, av->acb.second);
 
         if (!call->audio.second) {
             LOGGER_ERROR(av->m->log, "Failed to create audio codec session");
@@ -1238,7 +1236,7 @@ bool call_prepare_transmission(ToxAVCall *call)
         }
     }
     { /* Prepare video */
-        call->video.second = vc_new(av->m->log, av, call->friend_number, av->on_video_frame);
+        call->video.second = vc_new(av->m->log, av, call->friend_number, av->vcb.first, av->vcb.second);
 
         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 da0c4c35..38ba354e 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 *userdata);
+void toxav_iterate(ToxAV *av);
 
 
 /*******************************************************************************
@@ -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 toxav_callback_call(ToxAV *av, toxav_call_cb *callback, void *user_data);
 
 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 toxav_callback_call_state(ToxAV *av, toxav_call_state_cb *callback, void *user_data);
 
 
 /*******************************************************************************
@@ -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 toxav_callback_bit_rate_status(ToxAV *av, toxav_bit_rate_status_cb *callback, void *user_data);
 
 
 /*******************************************************************************
@@ -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 toxav_callback_audio_receive_frame(ToxAV *av, toxav_audio_receive_frame_cb *callback, void *user_data);
 
 /**
  * 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 toxav_callback_video_receive_frame(ToxAV *av, toxav_video_receive_frame_cb *callback, void *user_data);
 
 /**
  * NOTE Compatibility with old toxav group calls. TODO(iphydf): remove
diff --git a/toxav/video.c b/toxav/video.c
index e786bc4c..de028c7c 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)
+VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_receive_frame_cb *cb, void *cb_data)
 {
     VCSession *vc = calloc(sizeof(VCSession), 1);
 
@@ -104,7 +104,8 @@ VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_re
 
     vc->linfts = current_time_monotonic();
     vc->lcfd = 60;
-    vc->on_video_frame = cb;
+    vc->vcb.first = cb;
+    vc->vcb.second = cb_data;
     vc->friend_number = friend_number;
     vc->av = av;
     vc->log = log;
@@ -141,7 +142,7 @@ void vc_kill(VCSession *vc)
     LOGGER_DEBUG(vc->log, "Terminated video handler: %p", vc);
     free(vc);
 }
-void vc_iterate(VCSession *vc, void *userdata)
+void vc_iterate(VCSession *vc)
 {
     if (!vc) {
         return;
@@ -167,10 +168,10 @@ void vc_iterate(VCSession *vc, void *userdata)
 
             /* Play decoded images */
             for (; dest; dest = vpx_codec_get_frame(vc->decoder, &iter)) {
-                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);
+                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);
                 }
 
                 vpx_img_free(dest);
diff --git a/toxav/video.h b/toxav/video.h
index e24d98c9..335240c7 100644
--- a/toxav/video.h
+++ b/toxav/video.h
@@ -56,14 +56,14 @@ typedef struct VCSession_s {
     ToxAV *av;
     uint32_t friend_number;
 
-    toxav_video_receive_frame_cb *on_video_frame; /* Video frame receive callback */
+    PAIR(toxav_video_receive_frame_cb *, void *) vcb; /* 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);
+VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_receive_frame_cb *cb, void *cb_data);
 void vc_kill(VCSession *vc);
-void vc_iterate(VCSession *vc, void *userdata);
+void vc_iterate(VCSession *vc);
 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);
 
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 9edf2132..def05449 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -413,12 +413,7 @@ int m_delfriend(Messenger *m, int32_t friendnumber)
     }
 
     if (m->friend_connectionstatuschange_internal) {
-        // This is a direct callback to tell ToxAV that the friend has disconnected.
-        // The userdata in this callback is set to NULL, which will be passed back
-        // to the user if there is an active call. This behavior is expected, as the
-        // plan as of this commit is to update toxcore to ONLY send callbacks with
-        // tox_iterate().
-        m->friend_connectionstatuschange_internal(m, friendnumber, 0, m->friend_connectionstatuschange_internal_userdata, NULL);
+        m->friend_connectionstatuschange_internal(m, friendnumber, 0, m->friend_connectionstatuschange_internal_userdata);
     }
 
     clear_receipts(m, friendnumber);
@@ -890,8 +885,7 @@ void m_callback_core_connection(Messenger *m, void (*function)(Messenger *m, uns
     m->core_connection_change = function;
 }
 
-void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *,
-        void *),
+void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *),
         void *userdata)
 {
     m->friend_connectionstatuschange_internal = function;
@@ -952,7 +946,7 @@ static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, ui
 
         if (m->friend_connectionstatuschange_internal) {
             m->friend_connectionstatuschange_internal(m, friendnumber, is_online,
-                    m->friend_connectionstatuschange_internal_userdata, userdata);
+                    m->friend_connectionstatuschange_internal_userdata);
         }
     }
 }
@@ -1717,11 +1711,11 @@ static int handle_filecontrol(Messenger *m, int32_t friendnumber, uint8_t receiv
  *
  *  Function(Messenger *m, int friendnumber, uint8_t *data, uint16_t length, void *userdata)
  */
-void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t, void *,
-                           void *), void *object)
+void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t, void *),
+                           void *userdata)
 {
     m->msi_packet = function;
-    m->msi_packet_userdata = object;
+    m->msi_packet_userdata = userdata;
 }
 
 /* Send an msi packet.
@@ -1747,7 +1741,7 @@ static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_
         if (m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] % PACKET_LOSSY_AV_RESERVED].function) {
             return m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] % PACKET_LOSSY_AV_RESERVED].function(
                        m, friend_num, packet, length, m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] %
-                               PACKET_LOSSY_AV_RESERVED].object, userdata);
+                               PACKET_LOSSY_AV_RESERVED].object);
         }
 
         return 1;
@@ -1767,7 +1761,7 @@ void custom_lossy_packet_registerhandler(Messenger *m, void (*packet_handler_cal
 }
 
 int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int (*packet_handler_callback)(Messenger *m,
-                          uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object, void *userdata), void *object)
+                          uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object), void *object)
 {
     if (friend_not_valid(m, friendnumber)) {
         return -1;
@@ -2339,7 +2333,7 @@ static int handle_packet(void *object, int i, const uint8_t *temp, uint16_t len,
             }
 
             if (m->msi_packet) {
-                (*m->msi_packet)(m, i, data, data_length, m->msi_packet_userdata, userdata);
+                (*m->msi_packet)(m, i, data, data_length, m->msi_packet_userdata);
             }
 
             break;
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index 6f99f15b..2317eb8b 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -200,11 +200,8 @@ typedef struct {
     unsigned int num_sending_files;
     struct File_Transfers file_receiving[MAX_CONCURRENT_FILE_PIPES];
 
-    /* ToxAV, *object is the internal session data for the active call, userdata is the *pointer provided in
-     * tox_iterate()
-     */
     struct {
-        int (*function)(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object, void *userdata);
+        int (*function)(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object);
         void *object;
     } lossy_rtp_packethandlers[PACKET_LOSSY_AV_RESERVED];
 
@@ -248,8 +245,7 @@ struct Messenger {
     void (*friend_typingchange)(struct Messenger *m, uint32_t, bool, void *);
     void (*read_receipt)(struct Messenger *m, uint32_t, uint32_t, void *);
     void (*friend_connectionstatuschange)(struct Messenger *m, uint32_t, unsigned int, void *);
-    void (*friend_connectionstatuschange_internal)(struct Messenger *m, uint32_t, uint8_t, void *, void *);
-    /* ToxAV internal session data */
+    void (*friend_connectionstatuschange_internal)(struct Messenger *m, uint32_t, uint8_t, void *);
     void *friend_connectionstatuschange_internal_userdata;
 
     void *group_chat_object; /* Set by new_groupchats()*/
@@ -262,7 +258,7 @@ struct Messenger {
     void (*file_filedata)(struct Messenger *m, uint32_t, uint32_t, uint64_t, const uint8_t *, size_t, void *);
     void (*file_reqchunk)(struct Messenger *m, uint32_t, uint32_t, uint64_t, size_t, void *);
 
-    void (*msi_packet)(struct Messenger *m, uint32_t, const uint8_t *, uint16_t, void *, void *);
+    void (*msi_packet)(struct Messenger *m, uint32_t, const uint8_t *, uint16_t, void *);
     void *msi_packet_userdata;
 
     void (*lossy_packethandler)(struct Messenger *m, uint32_t, const uint8_t *, size_t, void *);
@@ -527,8 +523,7 @@ void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, uint32
 void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *));
 
 /* Same as previous but for internal A/V core usage only */
-void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *,
-        void *),
+void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *),
         void *userdata);
 
 
@@ -662,8 +657,8 @@ uint64_t file_dataremaining(const Messenger *m, int32_t friendnumber, uint8_t fi
  *
  *  Function(Messenger *m, uint32_t friendnumber, uint8_t *data, uint16_t length, void *userdata)
  */
-void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t, void *,
-                           void *), void *toxav_session);
+void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t, void *),
+                           void *userdata);
 
 /* Send an msi packet.
  *
@@ -678,7 +673,7 @@ int m_msi_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data,
  * return 0 on success.
  */
 int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int (*packet_handler_callback)(Messenger *m,
-                          uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object, void *userdata), void *object);
+                          uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object), void *object);
 
 /**********************************************/
 
diff --git a/toxcore/tox.h b/toxcore/tox.h
index 268ae779..47573302 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -1237,10 +1237,6 @@ typedef enum TOX_ERR_FRIEND_DELETE {
  * function, this client will appear offline to the friend and no communication
  * can occur between the two.
  *
- * WARNING, calling tox_friend_delete while there's an active ToxAV call will
- * result in undefined behavior. It's the client's responsibility to end all
- * ToxAV calls before deleting a friend.
- *
  * @param friend_number Friend number for the friend to be deleted.
  *
  * @return true on success.
diff --git a/toxcore/util.h b/toxcore/util.h
index d7ad7beb..840f0a3e 100644
--- a/toxcore/util.h
+++ b/toxcore/util.h
@@ -30,6 +30,7 @@
 #include <stdint.h>
 
 #define MIN(a,b) (((a)<(b))?(a):(b))
+#define PAIR(TYPE1__, TYPE2__) struct { TYPE1__ first; TYPE2__ second; }
 
 void unix_time_update(void);
 uint64_t unix_time(void);