Fix ToxAv's use of struct Tox.

* Fix `toxav_get_tox` to return tox, not messenger.
* Fix the casts from Tox* to Messenger* in toxav_old.c.
* Pass Tox instead of Messenger to public group AV callbacks.

toxav/BUILD.bazel

@@ -99,7 +99,7 @@ cc_library(
     srcs = ["groupav.c"],
     hdrs = ["groupav.h"],
     deps = [
-        "//c-toxcore/toxcore:group",
+        "//c-toxcore/toxcore:toxcore",
         "@opus",
     ],
 )

toxav/audio.c

@@ -222,13 +222,13 @@ int ac_queue_message(void *acp, struct RTPMessage *msg)
 
     ACSession *ac = (ACSession *)acp;
 
-    if ((msg->header.pt & 0x7f) == (rtp_TypeAudio + 2) % 128) {
+    if ((msg->header.pt & 0x7f) == (RTP_TYPE_AUDIO + 2) % 128) {
         LOGGER_WARNING(ac->log, "Got dummy!");
         free(msg);
         return 0;
     }
 
-    if ((msg->header.pt & 0x7f) != rtp_TypeAudio % 128) {
+    if ((msg->header.pt & 0x7f) != RTP_TYPE_AUDIO % 128) {
         LOGGER_WARNING(ac->log, "Invalid payload type!");
         free(msg);
         return -1;

toxav/audio.h

@@ -24,6 +24,7 @@
 
 #include "../toxcore/logger.h"
 #include "../toxcore/util.h"
+#include "rtp.h"
 
 #include <opus.h>
 #include <pthread.h>
@@ -48,8 +49,6 @@
 #define AUDIO_MAX_BUFFER_SIZE_PCM16 ((AUDIO_MAX_SAMPLE_RATE * AUDIO_MAX_FRAME_DURATION_MS) / 1000)
 #define AUDIO_MAX_BUFFER_SIZE_BYTES (AUDIO_MAX_BUFFER_SIZE_PCM16 * 2)
 
-struct RTPMessage;
-
 typedef struct ACSession_s {
     const Logger *log;
 

toxav/bwcontroller.c

@@ -35,30 +35,34 @@
 #include "../toxcore/util.h"
 
 #define BWC_PACKET_ID 196
-#define BWC_SEND_INTERVAL_MS 950     /* 0.95s  */
+#define BWC_SEND_INTERVAL_MS 950     // 0.95s
 #define BWC_AVG_PKT_COUNT 20
 #define BWC_AVG_LOSS_OVER_CYCLES_COUNT 30
 
+typedef struct BWCCycle {
+    uint32_t last_recv_timestamp; /* Last recv update time stamp */
+    uint32_t last_sent_timestamp; /* Last sent update time stamp */
+    uint32_t last_refresh_timestamp; /* Last refresh time stamp */
+
+    uint32_t lost;
+    uint32_t recv;
+} BWCCycle;
+
+typedef struct BWCRcvPkt {
+    uint32_t packet_length_array[BWC_AVG_PKT_COUNT];
+    RingBuffer *rb;
+} BWCRcvPkt;
+
 struct BWController_s {
-    void (*mcb)(BWController *, uint32_t, float, void *);
-    void *mcb_data;
+    m_cb *mcb;
+    void *mcb_user_data;
 
     Messenger *m;
     uint32_t friend_number;
 
-    struct {
-        uint32_t last_recv_timestamp; /* Last recv update time stamp */
-        uint32_t last_sent_timestamp; /* Last sent update time stamp */
-        uint32_t last_refresh_timestamp; /* Last refresh time stamp */
-
-        uint32_t lost;
-        uint32_t recv;
-    } cycle;
+    BWCCycle cycle;
 
-    struct {
-        uint32_t packet_length_array[BWC_AVG_PKT_COUNT];
-        RingBuffer *rb;
-    } rcvpkt; /* To calculate average received packet (this means split parts, not the full message!) */
+    BWCRcvPkt rcvpkt; /* To calculate average received packet (this means split parts, not the full message!) */
 
     uint32_t packet_loss_counted_cycles;
 };
@@ -71,24 +75,24 @@ struct BWCMessage {
 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 *udata)
+BWController *bwc_new(Messenger *m, uint32_t friendnumber, m_cb *mcb, void *mcb_user_data)
 {
     BWController *retu = (BWController *)calloc(sizeof(struct BWController_s), 1);
     LOGGER_DEBUG(m->log, "Creating bandwidth controller");
     retu->mcb = mcb;
-    retu->mcb_data = udata;
+    retu->mcb_user_data = mcb_user_data;
     retu->m = m;
     retu->friend_number = friendnumber;
-    retu->cycle.last_sent_timestamp = retu->cycle.last_refresh_timestamp = current_time_monotonic();
+    uint64_t now = current_time_monotonic();
+    retu->cycle.last_sent_timestamp = now;
+    retu->cycle.last_refresh_timestamp = now;
     retu->rcvpkt.rb = rb_new(BWC_AVG_PKT_COUNT);
     retu->cycle.lost = 0;
     retu->cycle.recv = 0;
     retu->packet_loss_counted_cycles = 0;
 
     /* Fill with zeros */
-    for (int i = 0; i < BWC_AVG_PKT_COUNT; i++) {
+    for (int i = 0; i < BWC_AVG_PKT_COUNT; ++i) {
         rb_write(retu->rcvpkt.rb, &retu->rcvpkt.packet_length_array[i]);
     }
 
@@ -126,7 +130,7 @@ void bwc_add_recv(BWController *bwc, uint32_t recv_bytes)
         return;
     }
 
-    bwc->packet_loss_counted_cycles++;
+    ++bwc->packet_loss_counted_cycles;
     bwc->cycle.recv += recv_bytes;
     send_update(bwc);
 }
@@ -181,7 +185,7 @@ static int on_update(BWController *bwc, const struct BWCMessage *msg)
                      (((double) lost / (recv + lost)) * 100.0));
         bwc->mcb(bwc, bwc->friend_number,
                  ((float) lost / (recv + lost)),
-                 bwc->mcb_data);
+                 bwc->mcb_user_data);
     }
 
     return 0;

toxav/bwcontroller.h

@@ -24,9 +24,9 @@
 
 typedef struct BWController_s BWController;
 
-BWController *bwc_new(Messenger *m, uint32_t friendnumber,
-                      void (*mcb)(BWController *, uint32_t, float, void *),
-                      void *udata);
+typedef void m_cb(BWController *bwc, uint32_t friend_number, float todo, void *user_data);
+
+BWController *bwc_new(Messenger *m, uint32_t friendnumber, m_cb *mcb, void *mcb_user_data);
 
 void bwc_kill(BWController *bwc);
 

toxav/groupav.c

@@ -33,13 +33,13 @@
 #define GROUP_JBUF_SIZE 6
 #define GROUP_JBUF_DEAD_SECONDS 4
 
-typedef struct {
+typedef struct Group_Audio_Packet {
     uint16_t sequnum;
     uint16_t length;
     uint8_t data[];
 } Group_Audio_Packet;
 
-typedef struct {
+typedef struct Group_JitterBuffer {
     Group_Audio_Packet **queue;
     uint32_t size;
     uint32_t capacity;
@@ -56,13 +56,15 @@ static Group_JitterBuffer *create_queue(unsigned int capacity)
         size *= 2;
     }
 
-    Group_JitterBuffer *q;
+    Group_JitterBuffer *q = (Group_JitterBuffer *)calloc(sizeof(Group_JitterBuffer), 1);
 
-    if (!(q = (Group_JitterBuffer *)calloc(sizeof(Group_JitterBuffer), 1))) {
+    if (!q) {
         return nullptr;
     }
 
-    if (!(q->queue = (Group_Audio_Packet **)calloc(sizeof(Group_Audio_Packet *), size))) {
+    q->queue = (Group_Audio_Packet **)calloc(sizeof(Group_Audio_Packet *), size);
+
+    if (!q->queue) {
         free(q);
         return nullptr;
     }
@@ -159,21 +161,23 @@ static Group_Audio_Packet *dequeue(Group_JitterBuffer *q, int *success)
     return nullptr;
 }
 
-typedef struct {
+typedef struct Group_AV {
     const Logger *log;
+    Tox *tox;
     Group_Chats *g_c;
     OpusEncoder *audio_encoder;
 
-    unsigned int audio_channels, audio_sample_rate, audio_bitrate;
+    unsigned int audio_channels;
+    unsigned int audio_sample_rate;
+    unsigned int audio_bitrate;
 
     uint16_t audio_sequnum;
 
-    void (*audio_data)(Messenger *m, uint32_t groupnumber, uint32_t peernumber, const int16_t *pcm, uint32_t samples,
-                       uint8_t channels, unsigned int sample_rate, void *userdata);
+    audio_data_cb *audio_data;
     void *userdata;
 } Group_AV;
 
-typedef struct {
+typedef struct Group_Peer_AV {
     Group_JitterBuffer *buffer;
 
     OpusDecoder *audio_decoder;
@@ -228,8 +232,8 @@ static int recreate_encoder(Group_AV *group_av)
     return 0;
 }
 
-static Group_AV *new_group_av(const Logger *log, Group_Chats *g_c, void (*audio_callback)(Messenger *, uint32_t,
-                              uint32_t, const int16_t *, unsigned int, uint8_t, uint32_t, void *), void *userdata)
+static Group_AV *new_group_av(const Logger *log, Tox *tox, Group_Chats *g_c, audio_data_cb *audio_callback,
+                              void *userdata)
 {
     if (!g_c) {
         return nullptr;
@@ -242,6 +246,7 @@ static Group_AV *new_group_av(const Logger *log, Group_Chats *g_c, void (*audio_
     }
 
     group_av->log = log;
+    group_av->tox = tox;
     group_av->g_c = g_c;
 
     group_av->audio_data = audio_callback;
@@ -381,7 +386,7 @@ static int decode_audio_packet(Group_AV *group_av, Group_Peer_AV *peer_av, uint3
     if (out_audio) {
 
         if (group_av->audio_data) {
-            group_av->audio_data(group_av->g_c->m, groupnumber, friendgroupnumber, out_audio, out_audio_samples,
+            group_av->audio_data(group_av->tox, groupnumber, friendgroupnumber, out_audio, out_audio_samples,
                                  peer_av->decoder_channels, sample_rate, group_av->userdata);
         }
 
@@ -417,7 +422,7 @@ static int handle_group_audio_packet(void *object, uint32_t groupnumber, uint32_
     }
 
     while (decode_audio_packet((Group_AV *)object, peer_av, groupnumber, friendgroupnumber) == 0) {
-        ;
+        continue;
     }
 
     return 0;
@@ -428,11 +433,10 @@ static int handle_group_audio_packet(void *object, uint32_t groupnumber, uint32_
  * return 0 on success.
  * return -1 on failure.
  */
-static int groupchat_enable_av(const Logger *log, Group_Chats *g_c, uint32_t groupnumber,
-                               void (*audio_callback)(Messenger *,
-                                       uint32_t, uint32_t, const int16_t *, unsigned int, uint8_t, uint32_t, void *), void *userdata)
+static int groupchat_enable_av(const Logger *log, Tox *tox, Group_Chats *g_c, uint32_t groupnumber,
+                               audio_data_cb *audio_callback, void *userdata)
 {
-    Group_AV *group_av = new_group_av(log, g_c, audio_callback, userdata);
+    Group_AV *group_av = new_group_av(log, tox, g_c, audio_callback, userdata);
 
     if (group_av == nullptr) {
         return -1;
@@ -455,16 +459,15 @@ static int groupchat_enable_av(const Logger *log, Group_Chats *g_c, uint32_t gro
  * return group number on success.
  * return -1 on failure.
  */
-int add_av_groupchat(const Logger *log, Group_Chats *g_c, void (*audio_callback)(Messenger *, uint32_t, uint32_t,
-                     const int16_t *, unsigned int, uint8_t, uint32_t, void *), void *userdata)
+int add_av_groupchat(const Logger *log, Tox *tox, Group_Chats *g_c, audio_data_cb *audio_callback, void *userdata)
 {
     int groupnumber = add_groupchat(g_c, GROUPCHAT_TYPE_AV);
 
     if (groupnumber == -1) {
         return -1;
     }
 
-    if (groupchat_enable_av(log, g_c, groupnumber, audio_callback, userdata) == -1) {
+    if (groupchat_enable_av(log, tox, g_c, groupnumber, audio_callback, userdata) == -1) {
         del_groupchat(g_c, groupnumber);
         return -1;
     }
@@ -477,17 +480,16 @@ int add_av_groupchat(const Logger *log, Group_Chats *g_c, void (*audio_callback)
  * returns group number on success
  * returns -1 on failure.
  */
-int join_av_groupchat(const Logger *log, Group_Chats *g_c, uint32_t friendnumber, const uint8_t *data, uint16_t length,
-                      void (*audio_callback)(Messenger *, uint32_t, uint32_t, const int16_t *, unsigned int, uint8_t, uint32_t, void *),
-                      void *userdata)
+int join_av_groupchat(const Logger *log, Tox *tox, Group_Chats *g_c, uint32_t friendnumber, const uint8_t *data,
+                      uint16_t length, audio_data_cb *audio_callback, void *userdata)
 {
     int groupnumber = join_groupchat(g_c, friendnumber, GROUPCHAT_TYPE_AV, data, length);
 
     if (groupnumber == -1) {
         return -1;
     }
 
-    if (groupchat_enable_av(log, g_c, groupnumber, audio_callback, userdata) == -1) {
+    if (groupchat_enable_av(log, tox, g_c, groupnumber, audio_callback, userdata) == -1) {
         del_groupchat(g_c, groupnumber);
         return -1;
     }
@@ -516,7 +518,8 @@ static int send_audio_packet(Group_Chats *g_c, uint32_t groupnumber, uint8_t *pa
 
     uint8_t data[MAX_CRYPTO_DATA_SIZE];
     uint8_t *ptr = data;
-    *ptr++ = GROUP_AUDIO_PACKET_ID;
+    *ptr = GROUP_AUDIO_PACKET_ID;
+    ++ptr;
 
     ptr += net_pack_u16(ptr, group_av->audio_sequnum);
     memcpy(ptr, packet, length);

toxav/groupav.h

@@ -21,28 +21,34 @@
 #define C_TOXCORE_TOXAV_GROUPAV_H
 
 #include "../toxcore/group.h"
+#include "../toxcore/tox.h"
 
 /* Audio encoding/decoding */
 #include <opus.h>
 
 #define GROUP_AUDIO_PACKET_ID 192
 
+// TODO(iphydf): Use this better typed one instead of the void-pointer one below.
+// typedef void audio_data_cb(Tox *tox, uint32_t groupnumber, uint32_t peernumber, const int16_t *pcm,
+//                            uint32_t samples, uint8_t channels, uint32_t sample_rate, void *userdata);
+typedef void audio_data_cb(void *tox, uint32_t groupnumber, uint32_t peernumber, const int16_t *pcm,
+                           uint32_t samples, uint8_t channels, uint32_t sample_rate, void *userdata);
+
 /* Create a new toxav group.
  *
  * return group number on success.
  * return -1 on failure.
  */
-int add_av_groupchat(const Logger *log, Group_Chats *g_c, void (*audio_callback)(Messenger *, uint32_t, uint32_t,
-                     const int16_t *, unsigned int, uint8_t, uint32_t, void *), void *userdata);
+int add_av_groupchat(const Logger *log, Tox *tox, Group_Chats *g_c, audio_data_cb *audio_callback, void *userdata);
 
 /* Join a AV group (you need to have been invited first.)
  *
  * returns group number on success
  * returns -1 on failure.
  */
-int join_av_groupchat(const Logger *log, Group_Chats *g_c, uint32_t friendnumber, const uint8_t *data, uint16_t length,
-                      void (*audio_callback)(Messenger *, uint32_t, uint32_t, const int16_t *, unsigned int, uint8_t, uint32_t, void *),
-                      void *userdata);
+int join_av_groupchat(const Logger *log, Tox *tox, Group_Chats *g_c, uint32_t friendnumber, const uint8_t *data,
+                      uint16_t length,
+                      audio_data_cb *audio_callback, void *userdata);
 
 
 /* Send audio to the group chat.