Add braces to all if statements.

7 files changed, 262 insertions, 136 deletions

diff --git a/toxav/audio.c b/toxav/audio.c
index 9fd8f6f1..eaa1f6d0 100644
--- a/toxav/audio.c
+++ b/toxav/audio.c
@@ -76,8 +76,9 @@ ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_re
     /* Initialize encoders with default values */
     ac->encoder = create_audio_encoder(log, 48000, 48000, 2);
 
-    if (ac->encoder == NULL)
+    if (ac->encoder == NULL) {
         goto DECODER_CLEANUP;
+    }
 
     ac->le_bit_rate = 48000;
     ac->le_sample_rate = 48000;
@@ -110,8 +111,9 @@ BASE_CLEANUP:
 }
 void ac_kill(ACSession *ac)
 {
-    if (!ac)
+    if (!ac) {
         return;
+    }
 
     opus_encoder_destroy(ac->encoder);
     opus_decoder_destroy(ac->decoder);
@@ -124,8 +126,9 @@ void ac_kill(ACSession *ac)
 }
 void ac_iterate(ACSession *ac)
 {
-    if (!ac)
+    if (!ac) {
         return;
+    }
 
     /* TODO fix this and jitter buffering */
 
@@ -196,8 +199,9 @@ void ac_iterate(ACSession *ac)
 }
 int ac_queue_message(void *acp, struct RTPMessage *msg)
 {
-    if (!acp || !msg)
+    if (!acp || !msg) {
         return -1;
+    }
 
     ACSession *ac = acp;
 
@@ -231,8 +235,9 @@ int ac_reconfigure_encoder(ACSession *ac, int32_t bit_rate, int32_t sampling_rat
                                           sampling_rate, channels,
                                           &ac->le_bit_rate,
                                           &ac->le_sample_rate,
-                                          &ac->le_channel_count))
+                                          &ac->le_channel_count)) {
         return -1;
+    }
 
     return 0;
 }
@@ -257,7 +262,9 @@ static struct JitterBuffer *jbuf_new(uint32_t capacity)
 
     struct JitterBuffer *q;
 
-    if (!(q = calloc(sizeof(struct JitterBuffer), 1))) return NULL;
+    if (!(q = calloc(sizeof(struct JitterBuffer), 1))) {
+        return NULL;
+    }
 
     if (!(q->queue = calloc(sizeof(struct RTPMessage *), size))) {
         free(q);
@@ -279,7 +286,9 @@ static void jbuf_clear(struct JitterBuffer *q)
 }
 static void jbuf_free(struct JitterBuffer *q)
 {
-    if (!q) return;
+    if (!q) {
+        return;
+    }
 
     jbuf_clear(q);
     free(q->queue);
@@ -301,13 +310,15 @@ static int jbuf_write(Logger *log, struct JitterBuffer *q, struct RTPMessage *m)
         return 0;
     }
 
-    if (q->queue[num])
+    if (q->queue[num]) {
         return -1;
+    }
 
     q->queue[num] = m;
 
-    if ((sequnum - q->bottom) >= (q->top - q->bottom))
+    if ((sequnum - q->bottom) >= (q->top - q->bottom)) {
         q->top = sequnum + 1;
+    }
 
     return 0;
 }
@@ -394,14 +405,15 @@ bool reconfigure_audio_encoder(Logger *log, OpusEncoder **e, int32_t new_br, int
     if (*old_sr != new_sr || *old_ch != new_ch) {
         OpusEncoder *new_encoder = create_audio_encoder(log, new_br, new_sr, new_ch);
 
-        if (new_encoder == NULL)
+        if (new_encoder == NULL) {
             return false;
+        }
 
         opus_encoder_destroy(*e);
         *e = new_encoder;
-    } else if (*old_br == new_br)
+    } else if (*old_br == new_br) {
         return true; /* Nothing changed */
-    else {
+    } else {
         int status = opus_encoder_ctl(*e, OPUS_SET_BITRATE(new_br));
 
         if (status != OPUS_OK) {
@@ -420,8 +432,9 @@ bool reconfigure_audio_encoder(Logger *log, OpusEncoder **e, int32_t new_br, int
 bool reconfigure_audio_decoder(ACSession *ac, int32_t sampling_rate, int8_t channels)
 {
     if (sampling_rate != ac->ld_sample_rate || channels != ac->ld_channel_count) {
-        if (current_time_monotonic() - ac->ldrts < 500)
+        if (current_time_monotonic() - ac->ldrts < 500) {
             return false;
+        }
 
         int status;
         OpusDecoder *new_dec = opus_decoder_create(sampling_rate, channels, &status);
diff --git a/toxav/bwcontroller.c b/toxav/bwcontroller.c
index cd574266..4d3b7f7d 100644
--- a/toxav/bwcontroller.c
+++ b/toxav/bwcontroller.c
@@ -78,8 +78,9 @@ BWController *bwc_new(Messenger *m, uint32_t friendnumber,
     /* Fill with zeros */
     int i = 0;
 
-    for (; i < BWC_AVG_PKT_COUNT; i ++)
+    for (; i < BWC_AVG_PKT_COUNT; i ++) {
         rb_write(retu->rcvpkt.rb, retu->rcvpkt.rb_s + i);
+    }
 
     m_callback_rtp_packet(m, friendnumber, BWC_PACKET_ID, bwc_handle_data, retu);
 
@@ -87,8 +88,9 @@ BWController *bwc_new(Messenger *m, uint32_t friendnumber,
 }
 void bwc_kill(BWController *bwc)
 {
-    if (!bwc)
+    if (!bwc) {
         return;
+    }
 
     m_callback_rtp_packet(bwc->m, bwc->friend_number, BWC_PACKET_ID, NULL, NULL);
 
@@ -106,8 +108,9 @@ void bwc_feed_avg(BWController *bwc, uint32_t bytes)
 }
 void bwc_add_lost(BWController *bwc, uint32_t bytes)
 {
-    if (!bwc)
+    if (!bwc) {
         return;
+    }
 
     if (!bytes) {
         uint32_t *t_avg[BWC_AVG_PKT_COUNT], c = 1;
@@ -119,8 +122,9 @@ void bwc_add_lost(BWController *bwc, uint32_t bytes)
         for (; i < BWC_AVG_PKT_COUNT; i ++) {
             bytes += *(t_avg[i]);
 
-            if (*(t_avg[i]))
+            if (*(t_avg[i])) {
                 c++;
+            }
         }
 
         bytes /= c;
@@ -131,8 +135,9 @@ void bwc_add_lost(BWController *bwc, uint32_t bytes)
 }
 void bwc_add_recv(BWController *bwc, uint32_t bytes)
 {
-    if (!bwc || !bytes)
+    if (!bwc || !bytes) {
         return;
+    }
 
     bwc->cycle.recv += bytes;
     send_update(bwc);
@@ -164,8 +169,9 @@ void send_update(BWController *bwc)
             b_msg->lost = htonl(bwc->cycle.lost);
             b_msg->recv = htonl(bwc->cycle.recv);
 
-            if (-1 == send_custom_lossy_packet(bwc->m, bwc->friend_number, p_msg, sizeof(p_msg)))
+            if (-1 == send_custom_lossy_packet(bwc->m, bwc->friend_number, p_msg, sizeof(p_msg))) {
                 LOGGER_WARNING(bwc->m->log, "BWC send failed (len: %d)! std error: %s", sizeof(p_msg), strerror(errno));
+            }
         }
 
         bwc->cycle.lsu = current_time_monotonic();
@@ -188,17 +194,19 @@ int on_update (BWController *bwc, struct BWCMessage *msg)
 
     LOGGER_DEBUG(bwc->m->log, "recved: %u lost: %u", msg->recv, msg->lost);
 
-    if (msg->lost && bwc->mcb)
+    if (msg->lost && bwc->mcb) {
         bwc->mcb(bwc, bwc->friend_number,
                  ((float) (msg->lost) / (msg->recv + msg->lost)),
                  bwc->mcb_data);
+    }
 
     return 0;
 }
 int bwc_handle_data(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length, void *object)
 {
-    if (length - 1 != sizeof(struct BWCMessage))
+    if (length - 1 != sizeof(struct BWCMessage)) {
         return -1;
+    }
 
     /* NOTE the data is mutable */
     return on_update(object, (struct BWCMessage *) (data + 1));
diff --git a/toxav/group.c b/toxav/group.c
index 1d083444..88d9bd5a 100644
--- a/toxav/group.c
+++ b/toxav/group.c
@@ -54,7 +54,9 @@ static Group_JitterBuffer *create_queue(unsigned int capacity)
 
     Group_JitterBuffer *q;
 
-    if (!(q = calloc(sizeof(Group_JitterBuffer), 1))) return NULL;
+    if (!(q = calloc(sizeof(Group_JitterBuffer), 1))) {
+        return NULL;
+    }
 
     if (!(q->queue = calloc(sizeof(Group_Audio_Packet *), size))) {
         free(q);
@@ -78,7 +80,9 @@ static void clear_queue(Group_JitterBuffer *q)
 
 static void terminate_queue(Group_JitterBuffer *q)
 {
-    if (!q) return;
+    if (!q) {
+        return;
+    }
 
     clear_queue(q);
     free(q->queue);
@@ -109,13 +113,15 @@ static int queue(Group_JitterBuffer *q, Group_Audio_Packet *pk)
         return 0;
     }
 
-    if (q->queue[num])
+    if (q->queue[num]) {
         return -1;
+    }
 
     q->queue[num] = pk;
 
-    if ((sequnum - q->bottom) >= (q->top - q->bottom))
+    if ((sequnum - q->bottom) >= (q->top - q->bottom)) {
         q->top = sequnum + 1;
+    }
 
     q->last_queued_time = unix_time();
     return 0;
@@ -222,13 +228,15 @@ static Group_AV *new_group_av(Logger *log, Group_Chats *g_c, void (*audio_callba
                               const int16_t *,
                               unsigned int, uint8_t, unsigned int, void *), void *userdata)
 {
-    if (!g_c)
+    if (!g_c) {
         return NULL;
+    }
 
     Group_AV *group_av = calloc(1, sizeof(Group_AV));
 
-    if (!group_av)
+    if (!group_av) {
         return NULL;
+    }
 
     group_av->log = log;
     group_av->g_c = g_c;
@@ -244,8 +252,9 @@ static void group_av_peer_new(void *object, int groupnumber, int friendgroupnumb
     Group_AV *group_av = object;
     Group_Peer_AV *peer_av = calloc(1, sizeof(Group_Peer_AV));
 
-    if (!peer_av)
+    if (!peer_av) {
         return;
+    }
 
     peer_av->buffer = create_queue(GROUP_JBUF_SIZE);
     group_peer_set_object(group_av->g_c, groupnumber, friendgroupnumber, peer_av);
@@ -255,11 +264,13 @@ static void group_av_peer_delete(void *object, int groupnumber, int friendgroupn
 {
     Group_Peer_AV *peer_av = peer_object;
 
-    if (!peer_av)
+    if (!peer_av) {
         return;
+    }
 
-    if (peer_av->audio_decoder)
+    if (peer_av->audio_decoder) {
         opus_decoder_destroy(peer_av->audio_decoder);
+    }
 
     terminate_queue(peer_av->buffer);
     free(peer_object);
@@ -267,20 +278,23 @@ static void group_av_peer_delete(void *object, int groupnumber, int friendgroupn
 
 static void group_av_groupchat_delete(void *object, int groupnumber)
 {
-    if (object)
+    if (object) {
         kill_group_av(object);
+    }
 }
 
 static int decode_audio_packet(Group_AV *group_av, Group_Peer_AV *peer_av, int groupnumber, int friendgroupnumber)
 {
-    if (!group_av || !peer_av)
+    if (!group_av || !peer_av) {
         return -1;
+    }
 
     int success;
     Group_Audio_Packet *pk = dequeue(peer_av->buffer, &success);
 
-    if (success == 0)
+    if (success == 0) {
         return -1;
+    }
 
     int16_t *out_audio = NULL;
     int out_audio_samples = 0;
@@ -330,16 +344,19 @@ static int decode_audio_packet(Group_AV *group_av, Group_Peer_AV *peer_av, int g
         out_audio_samples = opus_decode(peer_av->audio_decoder, pk->data, pk->length, out_audio, num_samples, 0);
         free(pk);
 
-        if (out_audio_samples <= 0)
+        if (out_audio_samples <= 0) {
             return -1;
+        }
 
         peer_av->last_packet_samples = out_audio_samples;
     } else {
-        if (!peer_av->audio_decoder)
+        if (!peer_av->audio_decoder) {
             return -1;
+        }
 
-        if (!peer_av->last_packet_samples)
+        if (!peer_av->last_packet_samples) {
             return -1;
+        }
 
         out_audio = malloc(peer_av->last_packet_samples * peer_av->decoder_channels * sizeof(int16_t));
 
@@ -350,16 +367,18 @@ static int decode_audio_packet(Group_AV *group_av, Group_Peer_AV *peer_av, int g
 
         out_audio_samples = opus_decode(peer_av->audio_decoder, NULL, 0, out_audio, peer_av->last_packet_samples, 1);
 
-        if (out_audio_samples <= 0)
+        if (out_audio_samples <= 0) {
             return -1;
+        }
 
     }
 
     if (out_audio) {
 
-        if (group_av->audio_data)
+        if (group_av->audio_data) {
             group_av->audio_data(group_av->g_c->m, groupnumber, friendgroupnumber, out_audio, out_audio_samples,
                                  peer_av->decoder_channels, sample_rate, group_av->userdata);
+        }
 
         free(out_audio);
         return 0;
@@ -394,7 +413,9 @@ static int handle_group_audio_packet(void *object, int groupnumber, int friendgr
         return -1;
     }
 
-    while (decode_audio_packet(object, peer_av, groupnumber, friendgroupnumber) == 0);
+    while (decode_audio_packet(object, peer_av, groupnumber, friendgroupnumber) == 0) {
+        ;
+    }
 
     return 0;
 }
@@ -408,13 +429,15 @@ static int groupchat_enable_av(Logger *log, Group_Chats *g_c, int groupnumber, v
                                int,
                                const int16_t *, unsigned int, uint8_t, unsigned int, void *), void *userdata)
 {
-    if (groupnumber == -1)
+    if (groupnumber == -1) {
         return -1;
+    }
 
     Group_AV *group_av = new_group_av(log, g_c, audio_callback, userdata);
 
-    if (group_av == NULL)
+    if (group_av == NULL) {
         return -1;
+    }
 
     if (group_set_object(g_c, groupnumber, group_av) == -1
             || callback_groupchat_peer_new(g_c, groupnumber, group_av_peer_new) == -1
@@ -481,8 +504,9 @@ int join_av_groupchat(Logger *log, Group_Chats *g_c, int32_t friendnumber, const
  */
 static int send_audio_packet(Group_Chats *g_c, int groupnumber, uint8_t *packet, uint16_t length)
 {
-    if (!length)
+    if (!length) {
         return -1;
+    }
 
     Group_AV *group_av = group_get_object(g_c, groupnumber);
     uint8_t data[1 + sizeof(uint16_t) + length];
@@ -492,8 +516,9 @@ static int send_audio_packet(Group_Chats *g_c, int groupnumber, uint8_t *packet,
     memcpy(data + 1, &sequnum, sizeof(sequnum));
     memcpy(data + 1 + sizeof(sequnum), packet, length);
 
-    if (send_group_lossy_packet(g_c, groupnumber, data, sizeof(data)) == -1)
+    if (send_group_lossy_packet(g_c, groupnumber, data, sizeof(data)) == -1) {
         return -1;
+    }
 
     ++group_av->audio_sequnum;
     return 0;
@@ -509,14 +534,18 @@ int group_send_audio(Group_Chats *g_c, int groupnumber, const int16_t *pcm, unsi
 {
     Group_AV *group_av = group_get_object(g_c, groupnumber);
 
-    if (!group_av)
+    if (!group_av) {
         return -1;
+    }
 
-    if (channels != 1 && channels != 2)
+    if (channels != 1 && channels != 2) {
         return -1;
+    }
 
-    if (sample_rate != 8000 && sample_rate != 12000 && sample_rate != 16000 && sample_rate != 24000 && sample_rate != 48000)
+    if (sample_rate != 8000 && sample_rate != 12000 && sample_rate != 16000 && sample_rate != 24000
+            && sample_rate != 48000) {
         return -1;
+    }
 
     if (!group_av->audio_encoder || group_av->audio_channels != channels || group_av->audio_sample_rate != sample_rate) {
         group_av->audio_channels = channels;
@@ -528,15 +557,17 @@ int group_send_audio(Group_Chats *g_c, int groupnumber, const int16_t *pcm, unsi
             group_av->audio_bitrate = 64000; //TODO: add way of adjusting bitrate
         }
 
-        if (recreate_encoder(group_av) == -1)
+        if (recreate_encoder(group_av) == -1) {
             return -1;
+        }
     }
 
     uint8_t encoded[1024];
     int32_t size = opus_encode(group_av->audio_encoder, pcm, samples, encoded, sizeof(encoded));
 
-    if (size <= 0)
+    if (size <= 0) {
         return -1;
+    }
 
     return send_audio_packet(g_c, groupnumber, encoded, size);
 }
diff --git a/toxav/msi.c b/toxav/msi.c
index b98c58de..cdc3c879 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -97,8 +97,9 @@ void handle_msi_packet (Messenger *m, uint32_t friend_number, const uint8_t *dat
  */
 void msi_register_callback (MSISession *session, msi_action_cb *callback, MSICallbackID id)
 {
-    if (!session)
+    if (!session) {
         return;
+    }
 
     pthread_mutex_lock(session->mutex);
     session->callbacks[id] = callback;
@@ -170,8 +171,9 @@ int msi_kill (MSISession *session)
 }
 int msi_invite (MSISession *session, MSICall **call, uint32_t friend_number, uint8_t capabilities)
 {
-    if (!session)
+    if (!session) {
         return -1;
+    }
 
     LOGGER_DEBUG(session->messenger->log, "Session: %p Inviting friend: %u", session, friend_number);
 
@@ -211,8 +213,9 @@ int msi_invite (MSISession *session, MSICall **call, uint32_t friend_number, uin
 }
 int msi_hangup (MSICall *call)
 {
-    if (!call || !call->session)
+    if (!call || !call->session) {
         return -1;
+    }
 
     MSISession *session = call->session;
 
@@ -241,8 +244,9 @@ int msi_hangup (MSICall *call)
 }
 int msi_answer (MSICall *call, uint8_t capabilities)
 {
-    if (!call || !call->session)
+    if (!call || !call->session) {
         return -1;
+    }
 
     MSISession *session = call->session;
 
@@ -278,8 +282,9 @@ int msi_answer (MSICall *call, uint8_t capabilities)
 }
 int msi_change_capabilities(MSICall *call, uint8_t capabilities)
 {
-    if (!call || !call->session)
+    if (!call || !call->session) {
         return -1;
+    }
 
     MSISession *session = call->session;
 
@@ -495,8 +500,9 @@ FAILURE:
      * an error message will be sent to friend
      */
 
-    if (call->error == msi_ENone)
+    if (call->error == msi_ENone) {
         call->error = msi_EHandle;
+    }
 
     return -1;
 }
@@ -504,8 +510,9 @@ static MSICall *get_call (MSISession *session, uint32_t friend_number)
 {
     assert(session);
 
-    if (session->calls == NULL || session->calls_tail < friend_number)
+    if (session->calls == NULL || session->calls_tail < friend_number) {
         return NULL;
+    }
 
     return session->calls[friend_number];
 }
@@ -515,8 +522,9 @@ MSICall *new_call (MSISession *session, uint32_t friend_number)
 
     MSICall *rc = calloc(sizeof(MSICall), 1);
 
-    if (rc == NULL)
+    if (rc == NULL) {
         return NULL;
+    }
 
     rc->session = session;
     rc->friend_number = friend_number;
@@ -544,8 +552,9 @@ MSICall *new_call (MSISession *session, uint32_t friend_number)
         /* Set fields in between to null */
         uint32_t i = session->calls_tail + 1;
 
-        for (; i < friend_number; i ++)
+        for (; i < friend_number; i ++) {
             session->calls[i] = NULL;
+        }
 
         rc->prev = session->calls[session->calls_tail];
         session->calls[session->calls_tail]->next = rc;
@@ -564,8 +573,9 @@ MSICall *new_call (MSISession *session, uint32_t friend_number)
 void kill_call (MSICall *call)
 {
     /* Assume that session mutex is locked */
-    if (call == NULL)
+    if (call == NULL) {
         return;
+    }
 
     MSISession *session = call->session;
 
@@ -574,17 +584,21 @@ void kill_call (MSICall *call)
     MSICall *prev = call->prev;
     MSICall *next = call->next;
 
-    if (prev)
+    if (prev) {
         prev->next = next;
-    else if (next)
+    } else if (next) {
         session->calls_head = next->friend_number;
-    else goto CLEAR_CONTAINER;
+    } else {
+        goto CLEAR_CONTAINER;
+    }
 
-    if (next)
+    if (next) {
         next->prev = prev;
-    else if (prev)
+    } else if (prev) {
         session->calls_tail = prev->friend_number;
-    else goto CLEAR_CONTAINER;
+    } else {
+        goto CLEAR_CONTAINER;
+    }
 
     session->calls[call->friend_number] = NULL;
     free(call);
@@ -641,8 +655,9 @@ 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) == -1) {
                 goto FAILURE;
+            }
         }
         break;
 
@@ -704,8 +719,9 @@ 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) == -1) {
                     goto FAILURE;
+                }
             }
         }
         break;
@@ -717,8 +733,9 @@ 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) == -1) {
                 goto FAILURE;
+            }
 
         }
         break;
@@ -751,7 +768,8 @@ void handle_pop (MSICall *call, const MSIMessage *msg)
         call->error = msg->error.value;
         invoke_callback(call, msi_OnError);
 
-    } else switch (call->state) {
+    } else {
+        switch (call->state) {
             case msi_CallInactive: {
                 LOGGER_ERROR(call->session->messenger->log, "Handling what should be impossible case");
                 abort();
@@ -779,6 +797,7 @@ void handle_pop (MSICall *call, const MSIMessage *msg)
             }
             break;
         }
+    }
 
     kill_call (call);
 }
diff --git a/toxav/rtp.c b/toxav/rtp.c
index 5fe37021..a226f3ff 100644
--- a/toxav/rtp.c
+++ b/toxav/rtp.c
@@ -73,8 +73,9 @@ RTPSession *rtp_new (int payload_type, Messenger *m, uint32_t friendnumber,
 }
 void rtp_kill (RTPSession *session)
 {
-    if (!session)
+    if (!session) {
         return;
+    }
 
     LOGGER_DEBUG(session->m->log, "Terminated RTP session: %p", session);
 
@@ -83,8 +84,9 @@ void rtp_kill (RTPSession *session)
 }
 int rtp_allow_receiving(RTPSession *session)
 {
-    if (session == NULL)
+    if (session == NULL) {
         return -1;
+    }
 
     if (m_callback_rtp_packet(session->m, session->friend_number, session->payload_type,
                               handle_rtp_packet, session) == -1) {
@@ -97,8 +99,9 @@ int rtp_allow_receiving(RTPSession *session)
 }
 int rtp_stop_receiving(RTPSession *session)
 {
-    if (session == NULL)
+    if (session == NULL) {
         return -1;
+    }
 
     m_callback_rtp_packet(session->m, session->friend_number, session->payload_type, NULL, NULL);
 
@@ -143,8 +146,9 @@ int rtp_send_data (RTPSession *session, const uint8_t *data, uint16_t length)
 
         memcpy(rdata + 1 + sizeof(struct RTPHeader), data, length);
 
-        if (-1 == send_custom_lossy_packet(session->m, session->friend_number, rdata, sizeof(rdata)))
+        if (-1 == send_custom_lossy_packet(session->m, session->friend_number, rdata, sizeof(rdata))) {
             LOGGER_WARNING(session->m->log, "RTP send failed (len: %d)! std error: %s", sizeof(rdata), strerror(errno));
+        }
     } else {
 
         /**
@@ -159,9 +163,10 @@ int rtp_send_data (RTPSession *session, const uint8_t *data, uint16_t length)
             memcpy(rdata + 1 + sizeof(struct RTPHeader), data + sent, piece);
 
             if (-1 == send_custom_lossy_packet(session->m, session->friend_number,
-                                               rdata, piece + sizeof(struct RTPHeader) + 1))
+                                               rdata, piece + sizeof(struct RTPHeader) + 1)) {
                 LOGGER_WARNING(session->m->log, "RTP send failed (len: %d)! std error: %s",
                                piece + sizeof(struct RTPHeader) + 1, strerror(errno));
+            }
 
             sent += piece;
             header->cpart = htons(sent);
@@ -174,9 +179,10 @@ int rtp_send_data (RTPSession *session, const uint8_t *data, uint16_t length)
             memcpy(rdata + 1 + sizeof(struct RTPHeader), data + sent, piece);
 
             if (-1 == send_custom_lossy_packet(session->m, session->friend_number, rdata,
-                                               piece + sizeof(struct RTPHeader) + 1))
+                                               piece + sizeof(struct RTPHeader) + 1)) {
                 LOGGER_WARNING(session->m->log, "RTP send failed (len: %d)! std error: %s",
                                piece + sizeof(struct RTPHeader) + 1, strerror(errno));
+            }
         }
     }
 
@@ -198,8 +204,9 @@ bool chloss (const RTPSession *session, const struct RTPHeader *header)
 
         fprintf (stderr, "Lost packet\n");
 
-        while (lost --)
+        while (lost --) {
             bwc_add_lost(session->bwc , 0);
+        }
 
         return true;
     }
@@ -271,10 +278,11 @@ int handle_rtp_packet (Messenger *m, uint32_t friendnumber, const uint8_t *data,
 
         /* Invoke processing of active multiparted message */
         if (session->mp) {
-            if (session->mcb)
+            if (session->mcb) {
                 session->mcb (session->cs, session->mp);
-            else
+            } else {
                 free(session->mp);
+            }
 
             session->mp = NULL;
         }
@@ -283,8 +291,9 @@ int handle_rtp_packet (Messenger *m, uint32_t friendnumber, const uint8_t *data,
          * process it only if handler for the session is present.
          */
 
-        if (!session->mcb)
+        if (!session->mcb) {
             return 0;
+        }
 
         return session->mcb (session->cs, new_message(length, data, length));
     } else {
@@ -323,21 +332,23 @@ int handle_rtp_packet (Messenger *m, uint32_t friendnumber, const uint8_t *data,
                     /* Received a full message; now push it for the further
                      * processing.
                      */
-                    if (session->mcb)
+                    if (session->mcb) {
                         session->mcb (session->cs, session->mp);
-                    else
+                    } else {
                         free(session->mp);
+                    }
 
                     session->mp = NULL;
                 }
             } else {
                 /* Second case */
 
-                if (session->mp->header.timestamp > ntohl(header->timestamp))
+                if (session->mp->header.timestamp > ntohl(header->timestamp)) {
                     /* The received message part is from the old message;
                      * discard it.
                      */
                     return 0;
+                }
 
                 /* Measure missing parts of the old message */
                 bwc_add_lost(session->bwc,
@@ -348,10 +359,11 @@ int handle_rtp_packet (Messenger *m, uint32_t friendnumber, const uint8_t *data,
                               MAX_CRYPTO_DATA_SIZE) * sizeof(struct RTPHeader) );
 
                 /* Push the previous message for processing */
-                if (session->mcb)
+                if (session->mcb) {
                     session->mcb (session->cs, session->mp);
-                else
+                } else {
                     free(session->mp);
+                }
 
                 session->mp = NULL;
                 goto NEW_MULTIPARTED;
@@ -382,8 +394,9 @@ NEW_MULTIPARTED:
                 session->mp = new_message(ntohs(header->tlen) + sizeof(struct RTPHeader), data, length);
 
                 /* Reposition data if necessary */
-                if (ntohs(header->cpart))
+                if (ntohs(header->cpart)) {
                     ;
+                }
 
                 memmove(session->mp->data + ntohs(header->cpart), session->mp->data, session->mp->len);
             }
diff --git a/toxav/toxav.c b/toxav/toxav.c
index 4ef5d2b3..d7b367f7 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -179,8 +179,9 @@ ToxAV *toxav_new(Tox *tox, TOXAV_ERR_NEW *error)
 
 END:
 
-    if (error)
+    if (error) {
         *error = rc;
+    }
 
     if (rc != TOXAV_ERR_NEW_OK) {
         free(av);
@@ -191,8 +192,9 @@ END:
 }
 void toxav_kill(ToxAV *av)
 {
-    if (av == NULL)
+    if (av == NULL) {
         return;
+    }
 
     pthread_mutex_lock(av->mutex);
 
@@ -249,12 +251,14 @@ void toxav_iterate(ToxAV *av)
             vc_iterate(i->video.second);
 
             if (i->msi_call->self_capabilities & msi_CapRAudio &&
-                    i->msi_call->peer_capabilities & msi_CapSAudio)
+                    i->msi_call->peer_capabilities & msi_CapSAudio) {
                 rc = MIN(i->audio.second->lp_frame_duration, rc);
+            }
 
             if (i->msi_call->self_capabilities & msi_CapRVideo &&
-                    i->msi_call->peer_capabilities & msi_CapSVideo)
+                    i->msi_call->peer_capabilities & msi_CapSVideo) {
                 rc = MIN(i->video.second->lcfd, (uint32_t) rc);
+            }
 
             uint32_t fid = i->friend_number;
 
@@ -262,8 +266,9 @@ void toxav_iterate(ToxAV *av)
             pthread_mutex_lock(av->mutex);
 
             /* In case this call is popped from container stop iteration */
-            if (call_get(av, fid) != i)
+            if (call_get(av, fid) != i) {
                 break;
+            }
         }
     }
 
@@ -293,8 +298,9 @@ bool toxav_call(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint
 
     ToxAVCall *call = call_new(av, friend_number, &rc);
 
-    if (call == NULL)
+    if (call == NULL) {
         goto END;
+    }
 
     call->audio_bit_rate = audio_bit_rate;
     call->video_bit_rate = video_bit_rate;
@@ -315,8 +321,9 @@ bool toxav_call(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint
 END:
     pthread_mutex_unlock(av->mutex);
 
-    if (error)
+    if (error) {
         *error = rc;
+    }
 
     return rc == TOXAV_ERR_CALL_OK;
 }
@@ -366,14 +373,16 @@ bool toxav_answer(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, ui
     call->previous_self_capabilities |= audio_bit_rate > 0 ? msi_CapSAudio : 0;
     call->previous_self_capabilities |= video_bit_rate > 0 ? msi_CapSVideo : 0;
 
-    if (msi_answer(call->msi_call, call->previous_self_capabilities) != 0)
+    if (msi_answer(call->msi_call, call->previous_self_capabilities) != 0) {
         rc = TOXAV_ERR_ANSWER_SYNC;
+    }
 
 END:
     pthread_mutex_unlock(av->mutex);
 
-    if (error)
+    if (error) {
         *error = rc;
+    }
 
     return rc == TOXAV_ERR_ANSWER_OK;
 }
@@ -528,8 +537,9 @@ bool toxav_call_control(ToxAV *av, uint32_t friend_number, TOXAV_CALL_CONTROL co
 END:
     pthread_mutex_unlock(av->mutex);
 
-    if (error)
+    if (error) {
         *error = rc;
+    }
 
     return rc == TOXAV_ERR_CALL_CONTROL_OK;
 }
@@ -594,8 +604,9 @@ bool toxav_bit_rate_set(ToxAV *av, uint32_t friend_number, int32_t audio_bit_rat
                     rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
                     goto END;
                 }
-            } else
+            } else {
                 LOGGER_DEBUG(av->m->log, "Set new audio bit rate %d", audio_bit_rate);
+            }
 
             call->audio_bit_rate = audio_bit_rate;
             pthread_mutex_unlock(call->mutex);
@@ -633,8 +644,9 @@ bool toxav_bit_rate_set(ToxAV *av, uint32_t friend_number, int32_t audio_bit_rat
                     rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
                     goto END;
                 }
-            } else
+            } else {
                 LOGGER_DEBUG(av->m->log, "Set new video bit rate %d", video_bit_rate);
+            }
 
             call->video_bit_rate = video_bit_rate;
             pthread_mutex_unlock(call->mutex);
@@ -644,8 +656,9 @@ bool toxav_bit_rate_set(ToxAV *av, uint32_t friend_number, int32_t audio_bit_rat
     pthread_mutex_unlock(av->mutex);
 END:
 
-    if (error)
+    if (error) {
         *error = rc;
+    }
 
     return rc == TOXAV_ERR_BIT_RATE_SET_OK;
 }
@@ -735,8 +748,9 @@ bool toxav_audio_send_frame(ToxAV *av, uint32_t friend_number, const int16_t *pc
 
 END:
 
-    if (error)
+    if (error) {
         *error = rc;
+    }
 
     return rc == TOXAV_ERR_SEND_FRAME_OK;
 }
@@ -834,8 +848,9 @@ bool toxav_video_send_frame(ToxAV *av, uint32_t friend_number, uint16_t width, u
 
 END:
 
-    if (error)
+    if (error) {
         *error = rc;
+    }
 
     return rc == TOXAV_ERR_SEND_FRAME_OK;
 }
@@ -874,8 +889,9 @@ void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *u
 
     LOGGER_DEBUG(call->av->m->log, "Reported loss of %f%%", loss * 100);
 
-    if (loss < .01f)
+    if (loss < .01f) {
         return;
+    }
 
     pthread_mutex_lock(call->av->mutex);
 
@@ -885,14 +901,15 @@ void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *u
         return;
     }
 
-    if (call->video_bit_rate)
+    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);
-    else if (call->audio_bit_rate)
+    } 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);
+    }
 
     pthread_mutex_unlock(call->av->mutex);
 }
@@ -912,10 +929,10 @@ int callback_invite(void *toxav_inst, MSICall *call)
     call->av_call = av_call;
     av_call->msi_call = call;
 
-    if (toxav->ccb.first)
+    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 {
+    } else {
         /* No handler to capture the call request, send failure */
         pthread_mutex_unlock(toxav->mutex);
         return -1;
@@ -987,15 +1004,17 @@ int callback_capabilites(void *toxav_inst, MSICall *call)
     ToxAV *toxav = toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
-    if (call->peer_capabilities & msi_CapSAudio)
+    if (call->peer_capabilities & msi_CapSAudio) {
         rtp_allow_receiving(((ToxAVCall *)call->av_call)->audio.first);
-    else
+    } else {
         rtp_stop_receiving(((ToxAVCall *)call->av_call)->audio.first);
+    }
 
-    if (call->peer_capabilities & msi_CapSVideo)
+    if (call->peer_capabilities & msi_CapSVideo) {
         rtp_allow_receiving(((ToxAVCall *)call->av_call)->video.first);
-    else
+    } else {
         rtp_stop_receiving(((ToxAVCall *)call->av_call)->video.first);
+    }
 
     invoke_call_state_callback(toxav, call->friend_number, call->peer_capabilities);
 
@@ -1017,10 +1036,11 @@ bool video_bit_rate_invalid(uint32_t bit_rate)
 }
 bool invoke_call_state_callback(ToxAV *av, uint32_t friend_number, uint32_t state)
 {
-    if (av->scb.first)
+    if (av->scb.first) {
         av->scb.first(av, friend_number, state, av->scb.second);
-    else
+    } else {
         return false;
+    }
 
     return true;
 }
@@ -1083,8 +1103,9 @@ ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, TOXAV_ERR_CALL *error)
         /* Set fields in between to null */
         uint32_t i = av->calls_tail + 1;
 
-        for (; i < friend_number; i ++)
+        for (; i < friend_number; i ++) {
             av->calls[i] = NULL;
+        }
 
         call->prev = av->calls[av->calls_tail];
         av->calls[av->calls_tail]->next = call;
@@ -1101,23 +1122,26 @@ ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, TOXAV_ERR_CALL *error)
 
 END:
 
-    if (error)
+    if (error) {
         *error = rc;
+    }
 
     return call;
 }
 ToxAVCall *call_get(ToxAV *av, uint32_t friend_number)
 {
     /* Assumes mutex locked */
-    if (av->calls == NULL || av->calls_tail < friend_number)
+    if (av->calls == NULL || av->calls_tail < friend_number) {
         return NULL;
+    }
 
     return av->calls[friend_number];
 }
 ToxAVCall *call_remove(ToxAVCall *call)
 {
-    if (call == NULL)
+    if (call == NULL) {
         return NULL;
+    }
 
     uint32_t friend_number = call->friend_number;
     ToxAV *av = call->av;
@@ -1134,17 +1158,21 @@ ToxAVCall *call_remove(ToxAVCall *call)
 
     free(call);
 
-    if (prev)
+    if (prev) {
         prev->next = next;
-    else if (next)
+    } else if (next) {
         av->calls_head = next->friend_number;
-    else goto CLEAR;
+    } else {
+        goto CLEAR;
+    }
 
-    if (next)
+    if (next) {
         next->prev = prev;
-    else if (prev)
+    } else if (prev) {
         av->calls_tail = prev->friend_number;
-    else goto CLEAR;
+    } else {
+        goto CLEAR;
+    }
 
     av->calls[friend_number] = NULL;
     return next;
@@ -1160,28 +1188,33 @@ bool call_prepare_transmission(ToxAVCall *call)
 {
     /* Assumes mutex locked */
 
-    if (call == NULL)
+    if (call == NULL) {
         return false;
+    }
 
     ToxAV *av = call->av;
 
-    if (!av->acb.first && !av->vcb.first)
+    if (!av->acb.first && !av->vcb.first) {
         /* It makes no sense to have CSession without callbacks */
         return false;
+    }
 
     if (call->active) {
         LOGGER_WARNING(av->m->log, "Call already active!\n");
         return true;
     }
 
-    if (create_recursive_mutex(call->mutex_audio) != 0)
+    if (create_recursive_mutex(call->mutex_audio) != 0) {
         return false;
+    }
 
-    if (create_recursive_mutex(call->mutex_video) != 0)
+    if (create_recursive_mutex(call->mutex_video) != 0) {
         goto FAILURE_3;
+    }
 
-    if (create_recursive_mutex(call->mutex) != 0)
+    if (create_recursive_mutex(call->mutex) != 0) {
         goto FAILURE_2;
+    }
 
     /* Prepare bwc */
     call->bwc = bwc_new(av->m, call->friend_number, callback_bwc, call);
@@ -1241,8 +1274,9 @@ FAILURE_3:
 }
 void call_kill_transmission(ToxAVCall *call)
 {
-    if (call == NULL || call->active == 0)
+    if (call == NULL || call->active == 0) {
         return;
+    }
 
     call->active = 0;
 
diff --git a/toxav/video.c b/toxav/video.c
index 300eb377..c94579a6 100644
--- a/toxav/video.c
+++ b/toxav/video.c
@@ -51,8 +51,9 @@ VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_re
         return NULL;
     }
 
-    if (!(vc->vbuf_raw = rb_new(VIDEO_DECODE_BUFFER_SIZE)))
+    if (!(vc->vbuf_raw = rb_new(VIDEO_DECODE_BUFFER_SIZE))) {
         goto BASE_CLEANUP;
+    }
 
     int rc = vpx_codec_dec_init(vc->decoder, VIDEO_CODEC_DECODER_INTERFACE, NULL, 0);
 
@@ -118,16 +119,18 @@ BASE_CLEANUP:
 }
 void vc_kill(VCSession *vc)
 {
-    if (!vc)
+    if (!vc) {
         return;
+    }
 
     vpx_codec_destroy(vc->encoder);
     vpx_codec_destroy(vc->decoder);
 
     void *p;
 
-    while (rb_read(vc->vbuf_raw, (void **)&p))
+    while (rb_read(vc->vbuf_raw, (void **)&p)) {
         free(p);
+    }
 
     rb_kill(vc->vbuf_raw);
 
@@ -138,8 +141,9 @@ void vc_kill(VCSession *vc)
 }
 void vc_iterate(VCSession *vc)
 {
-    if (!vc)
+    if (!vc) {
         return;
+    }
 
     struct RTPMessage *p;
     int rc;
@@ -152,18 +156,19 @@ void vc_iterate(VCSession *vc)
         rc = vpx_codec_decode(vc->decoder, p->data, p->len, NULL, MAX_DECODE_TIME_US);
         free(p);
 
-        if (rc != VPX_CODEC_OK)
+        if (rc != VPX_CODEC_OK) {
             LOGGER_ERROR(vc->log, "Error decoding video: %s", vpx_codec_err_to_string(rc));
-        else {
+        } else {
             vpx_codec_iter_t iter = NULL;
             vpx_image_t *dest = vpx_codec_get_frame(vc->decoder, &iter);
 
             /* Play decoded images */
             for (; dest; dest = vpx_codec_get_frame(vc->decoder, &iter)) {
-                if (vc->vcb.first)
+                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);
             }
@@ -179,8 +184,9 @@ int vc_queue_message(void *vcp, struct RTPMessage *msg)
     /* This function does the reconstruction of video packets.
      * See more info about video splitting in docs
      */
-    if (!vcp || !msg)
+    if (!vcp || !msg) {
         return -1;
+    }
 
     VCSession *vc = vcp;
 
@@ -210,14 +216,16 @@ 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)
 {
-    if (!vc)
+    if (!vc) {
         return -1;
+    }
 
     vpx_codec_enc_cfg_t cfg = *vc->encoder->config.enc;
     int rc;
 
-    if (cfg.rc_target_bitrate == bit_rate && cfg.g_w == width && cfg.g_h == height)
+    if (cfg.rc_target_bitrate == bit_rate && cfg.g_w == width && cfg.g_h == height) {
         return 0; /* Nothing changed */
+    }
 
     if (cfg.g_w == width && cfg.g_h == height) {
         /* Only bit rate changed */