7 files changed, 135 insertions, 135 deletions

diff --git a/toxav/audio.c b/toxav/audio.c
index 99bb7c97..729a4922 100644
--- a/toxav/audio.c
+++ b/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;
diff --git a/toxav/msi.c b/toxav/msi.c
index f1242228..dd9f5fba 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -41,16 +41,16 @@
  */
 
 typedef enum {
-    IDRequest = 1,
-    IDError,
-    IDCapabilities,
+    ID_REQUEST = 1,
+    ID_ERROR,
+    ID_CAPABILITIES,
 } MSIHeaderID;
 
 
 typedef enum {
-    requ_init,
-    requ_push,
-    requ_pop,
+    REQU_INIT,
+    REQU_PUSH,
+    REQU_POP,
 } MSIRequest;
 
 
@@ -147,7 +147,7 @@ int msi_kill(MSISession *session, const Logger *log)
 
     if (session->calls) {
         MSIMessage msg;
-        msg_init(&msg, requ_pop);
+        msg_init(&msg, REQU_POP);
 
         MSICall *it = get_call(session, session->calls_head);
 
@@ -195,14 +195,14 @@ int msi_invite(MSISession *session, MSICall **call, uint32_t friend_number, uint
     (*call)->self_capabilities = capabilities;
 
     MSIMessage msg;
-    msg_init(&msg, requ_init);
+    msg_init(&msg, REQU_INIT);
 
     msg.capabilities.exists = true;
     msg.capabilities.value = capabilities;
 
     send_message((*call)->session->messenger, (*call)->friend_number, &msg);
 
-    (*call)->state = msi_CallRequesting;
+    (*call)->state = MSI_CALL_REQUESTING;
 
     LOGGER_DEBUG(session->messenger->log, "Invite sent");
     pthread_mutex_unlock(session->mutex);
@@ -224,14 +224,14 @@ int msi_hangup(MSICall *call)
         return -1;
     }
 
-    if (call->state == msi_CallInactive) {
+    if (call->state == MSI_CALL_INACTIVE) {
         LOGGER_ERROR(session->messenger->log, "Call is in invalid state!");
         pthread_mutex_unlock(session->mutex);
         return -1;
     }
 
     MSIMessage msg;
-    msg_init(&msg, requ_pop);
+    msg_init(&msg, REQU_POP);
 
     send_message(session->messenger, call->friend_number, &msg);
 
@@ -255,7 +255,7 @@ int msi_answer(MSICall *call, uint8_t capabilities)
         return -1;
     }
 
-    if (call->state != msi_CallRequested) {
+    if (call->state != MSI_CALL_REQUESTED) {
         /* Though sending in invalid state will not cause anything weird
          * Its better to not do it like a maniac */
         LOGGER_ERROR(session->messenger->log, "Call is in invalid state!");
@@ -266,14 +266,14 @@ int msi_answer(MSICall *call, uint8_t capabilities)
     call->self_capabilities = capabilities;
 
     MSIMessage msg;
-    msg_init(&msg, requ_push);
+    msg_init(&msg, REQU_PUSH);
 
     msg.capabilities.exists = true;
     msg.capabilities.value = capabilities;
 
     send_message(session->messenger, call->friend_number, &msg);
 
-    call->state = msi_CallActive;
+    call->state = MSI_CALL_ACTIVE;
     pthread_mutex_unlock(session->mutex);
 
     return 0;
@@ -294,7 +294,7 @@ int msi_change_capabilities(MSICall *call, uint8_t capabilities)
         return -1;
     }
 
-    if (call->state != msi_CallActive) {
+    if (call->state != MSI_CALL_ACTIVE) {
         LOGGER_ERROR(session->messenger->log, "Call is in invalid state!");
         pthread_mutex_unlock(session->mutex);
         return -1;
@@ -303,7 +303,7 @@ int msi_change_capabilities(MSICall *call, uint8_t capabilities)
     call->self_capabilities = capabilities;
 
     MSIMessage msg;
-    msg_init(&msg, requ_push);
+    msg_init(&msg, REQU_PUSH);
 
     msg.capabilities.exists = true;
     msg.capabilities.value = capabilities;
@@ -355,19 +355,19 @@ int msg_parse_in(const Logger *log, MSIMessage *dest, const uint8_t *data, uint1
 
     while (*it) {/* until end byte is hit */
         switch (*it) {
-            case IDRequest:
+            case ID_REQUEST:
                 CHECK_SIZE(it, size_constraint, 1);
-                CHECK_ENUM_HIGH(it, requ_pop);
+                CHECK_ENUM_HIGH(it, REQU_POP);
                 SET_UINT8(MSIRequest, it, dest->request);
                 break;
 
-            case IDError:
+            case ID_ERROR:
                 CHECK_SIZE(it, size_constraint, 1);
-                CHECK_ENUM_HIGH(it, msi_EUndisclosed);
+                CHECK_ENUM_HIGH(it, MSI_E_UNDISCLOSED);
                 SET_UINT8(MSIError, it, dest->error);
                 break;
 
-            case IDCapabilities:
+            case ID_CAPABILITIES:
                 CHECK_SIZE(it, size_constraint, 1);
                 SET_UINT8(uint8_t, it, dest->capabilities);
                 break;
@@ -419,7 +419,7 @@ int send_message(Messenger *m, uint32_t friend_number, const MSIMessage *msg)
 
     if (msg->request.exists) {
         uint8_t cast = msg->request.value;
-        it = msg_parse_header_out(IDRequest, it, &cast,
+        it = msg_parse_header_out(ID_REQUEST, it, &cast,
                                   sizeof(cast), &size);
     } else {
         LOGGER_DEBUG(m->log, "Must have request field");
@@ -428,12 +428,12 @@ int send_message(Messenger *m, uint32_t friend_number, const MSIMessage *msg)
 
     if (msg->error.exists) {
         uint8_t cast = msg->error.value;
-        it = msg_parse_header_out(IDError, it, &cast,
+        it = msg_parse_header_out(ID_ERROR, it, &cast,
                                   sizeof(cast), &size);
     }
 
     if (msg->capabilities.exists) {
-        it = msg_parse_header_out(IDCapabilities, it, &msg->capabilities.value,
+        it = msg_parse_header_out(ID_CAPABILITIES, it, &msg->capabilities.value,
                                   sizeof(msg->capabilities.value), &size);
     }
 
@@ -460,7 +460,7 @@ int send_error(Messenger *m, uint32_t friend_number, MSIError error)
     LOGGER_DEBUG(m->log, "Sending error: %d to friend: %d", error, friend_number);
 
     MSIMessage msg;
-    msg_init(&msg, requ_pop);
+    msg_init(&msg, REQU_POP);
 
     msg.error.exists = true;
     msg.error.value = error;
@@ -489,8 +489,8 @@ FAILURE:
      * an error message will be sent to friend
      */
 
-    if (call->error == msi_ENone) {
-        call->error = msi_EHandle;
+    if (call->error == MSI_E_NONE) {
+        call->error = MSI_E_HANDLE;
     }
 
     return -1;
@@ -614,7 +614,7 @@ void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *
                 return;
             }
 
-            invoke_callback(call, msi_OnPeerTimeout); /* Failure is ignored */
+            invoke_callback(call, MSI_ON_PEERTIMEOUT); /* Failure is ignored */
             kill_call(call);
             pthread_mutex_unlock(session->mutex);
         }
@@ -632,23 +632,23 @@ void handle_init(MSICall *call, const MSIMessage *msg)
 
     if (!msg->capabilities.exists) {
         LOGGER_WARNING(call->session->messenger->log, "Session: %p Invalid capabilities on 'init'", (void *)call->session);
-        call->error = msi_EInvalidMessage;
+        call->error = MSI_E_INVALID_MESSAGE;
         goto FAILURE;
     }
 
     switch (call->state) {
-        case msi_CallInactive: {
+        case MSI_CALL_INACTIVE: {
             /* Call requested */
             call->peer_capabilities = msg->capabilities.value;
-            call->state = msi_CallRequested;
+            call->state = MSI_CALL_REQUESTED;
 
-            if (invoke_callback(call, msi_OnInvite) == -1) {
+            if (invoke_callback(call, MSI_ON_INVITE) == -1) {
                 goto FAILURE;
             }
         }
         break;
 
-        case msi_CallActive: {
+        case MSI_CALL_ACTIVE: {
             /* If peer sent init while the call is already
              * active it's probable that he is trying to
              * re-call us while the call is not terminated
@@ -659,7 +659,7 @@ void handle_init(MSICall *call, const MSIMessage *msg)
             LOGGER_INFO(call->session->messenger->log, "Friend is recalling us");
 
             MSIMessage out_msg;
-            msg_init(&out_msg, requ_push);
+            msg_init(&out_msg, REQU_PUSH);
 
             out_msg.capabilities.exists = true;
             out_msg.capabilities.value = call->self_capabilities;
@@ -672,10 +672,10 @@ void handle_init(MSICall *call, const MSIMessage *msg)
         }
         break;
 
-        case msi_CallRequested: // fall-through
-        case msi_CallRequesting: {
+        case MSI_CALL_REQUESTED: // fall-through
+        case MSI_CALL_REQUESTING: {
             LOGGER_WARNING(call->session->messenger->log, "Session: %p Invalid state on 'init'", (void *)call->session);
-            call->error = msi_EInvalidState;
+            call->error = MSI_E_INVALID_STATE;
             goto FAILURE;
         }
     }
@@ -694,41 +694,41 @@ void handle_push(MSICall *call, const MSIMessage *msg)
 
     if (!msg->capabilities.exists) {
         LOGGER_WARNING(call->session->messenger->log, "Session: %p Invalid capabilities on 'push'", (void *)call->session);
-        call->error = msi_EInvalidMessage;
+        call->error = MSI_E_INVALID_MESSAGE;
         goto FAILURE;
     }
 
     switch (call->state) {
-        case msi_CallActive: {
+        case MSI_CALL_ACTIVE: {
             /* Only act if capabilities changed */
             if (call->peer_capabilities != msg->capabilities.value) {
                 LOGGER_INFO(call->session->messenger->log, "Friend is changing capabilities to: %u", msg->capabilities.value);
 
                 call->peer_capabilities = msg->capabilities.value;
 
-                if (invoke_callback(call, msi_OnCapabilities) == -1) {
+                if (invoke_callback(call, MSI_ON_CAPABILITIES) == -1) {
                     goto FAILURE;
                 }
             }
         }
         break;
 
-        case msi_CallRequesting: {
+        case MSI_CALL_REQUESTING: {
             LOGGER_INFO(call->session->messenger->log, "Friend answered our call");
 
             /* Call started */
             call->peer_capabilities = msg->capabilities.value;
-            call->state = msi_CallActive;
+            call->state = MSI_CALL_ACTIVE;
 
-            if (invoke_callback(call, msi_OnStart) == -1) {
+            if (invoke_callback(call, MSI_ON_START) == -1) {
                 goto FAILURE;
             }
         }
         break;
 
         /* Pushes during initialization state are ignored */
-        case msi_CallInactive: // fall-through
-        case msi_CallRequested: {
+        case MSI_CALL_INACTIVE: // fall-through
+        case MSI_CALL_REQUESTED: {
             LOGGER_WARNING(call->session->messenger->log, "Ignoring invalid push");
         }
         break;
@@ -752,32 +752,32 @@ void handle_pop(MSICall *call, const MSIMessage *msg)
     if (msg->error.exists) {
         LOGGER_WARNING(call->session->messenger->log, "Friend detected an error: %d", msg->error.value);
         call->error = msg->error.value;
-        invoke_callback(call, msi_OnError);
+        invoke_callback(call, MSI_ON_ERROR);
     } else {
         switch (call->state) {
-            case msi_CallInactive: {
+            case MSI_CALL_INACTIVE: {
                 LOGGER_ERROR(call->session->messenger->log, "Handling what should be impossible case");
                 abort();
             }
 
-            case msi_CallActive: {
+            case MSI_CALL_ACTIVE: {
                 /* Hangup */
                 LOGGER_INFO(call->session->messenger->log, "Friend hung up on us");
-                invoke_callback(call, msi_OnEnd);
+                invoke_callback(call, MSI_ON_END);
             }
             break;
 
-            case msi_CallRequesting: {
+            case MSI_CALL_REQUESTING: {
                 /* Reject */
                 LOGGER_INFO(call->session->messenger->log, "Friend rejected our call");
-                invoke_callback(call, msi_OnEnd);
+                invoke_callback(call, MSI_ON_END);
             }
             break;
 
-            case msi_CallRequested: {
+            case MSI_CALL_REQUESTED: {
                 /* Cancel */
                 LOGGER_INFO(call->session->messenger->log, "Friend canceled call invite");
-                invoke_callback(call, msi_OnEnd);
+                invoke_callback(call, MSI_ON_END);
             }
             break;
         }
@@ -794,7 +794,7 @@ void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data
 
     if (msg_parse_in(m->log, &msg, data, length) == -1) {
         LOGGER_WARNING(m->log, "Error parsing message");
-        send_error(m, friend_number, msi_EInvalidMessage);
+        send_error(m, friend_number, MSI_E_INVALID_MESSAGE);
         return;
     }
 
@@ -804,8 +804,8 @@ void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data
     MSICall *call = get_call(session, friend_number);
 
     if (call == nullptr) {
-        if (msg.request.value != requ_init) {
-            send_error(m, friend_number, msi_EStrayMessage);
+        if (msg.request.value != REQU_INIT) {
+            send_error(m, friend_number, MSI_E_STRAY_MESSAGE);
             pthread_mutex_unlock(session->mutex);
             return;
         }
@@ -813,22 +813,22 @@ void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data
         call = new_call(session, friend_number);
 
         if (call == nullptr) {
-            send_error(m, friend_number, msi_ESystem);
+            send_error(m, friend_number, MSI_E_SYSTEM);
             pthread_mutex_unlock(session->mutex);
             return;
         }
     }
 
     switch (msg.request.value) {
-        case requ_init:
+        case REQU_INIT:
             handle_init(call, &msg);
             break;
 
-        case requ_push:
+        case REQU_PUSH:
             handle_push(call, &msg);
             break;
 
-        case requ_pop:
+        case REQU_POP:
             handle_pop(call, &msg); /* always kills the call */
             break;
     }
diff --git a/toxav/msi.h b/toxav/msi.h
index b2c15567..bf3218e0 100644
--- a/toxav/msi.h
+++ b/toxav/msi.h
@@ -33,24 +33,24 @@
  * Error codes.
  */
 typedef enum {
-    msi_ENone,
-    msi_EInvalidMessage,
-    msi_EInvalidParam,
-    msi_EInvalidState,
-    msi_EStrayMessage,
-    msi_ESystem,
-    msi_EHandle,
-    msi_EUndisclosed, /* NOTE: must be last enum otherwise parsing will not work */
+    MSI_E_NONE,
+    MSI_E_INVALID_MESSAGE,
+    MSI_E_INVALID_PARAM,
+    MSI_E_INVALID_STATE,
+    MSI_E_STRAY_MESSAGE,
+    MSI_E_SYSTEM,
+    MSI_E_HANDLE,
+    MSI_E_UNDISCLOSED, /* NOTE: must be last enum otherwise parsing will not work */
 } MSIError;
 
 /**
  * Supported capabilities
  */
 typedef enum {
-    msi_CapSAudio = 4,  /* sending audio */
-    msi_CapSVideo = 8,  /* sending video */
-    msi_CapRAudio = 16, /* receiving audio */
-    msi_CapRVideo = 32, /* receiving video */
+    MSI_CAP_S_AUDIO = 4,  /* sending audio */
+    MSI_CAP_S_VIDEO = 8,  /* sending video */
+    MSI_CAP_R_AUDIO = 16, /* receiving audio */
+    MSI_CAP_R_VIDEO = 32, /* receiving video */
 } MSICapabilities;
 
 
@@ -58,22 +58,22 @@ typedef enum {
  * Call state identifiers.
  */
 typedef enum {
-    msi_CallInactive, /* Default */
-    msi_CallActive,
-    msi_CallRequesting, /* when sending call invite */
-    msi_CallRequested, /* when getting call invite */
+    MSI_CALL_INACTIVE, /* Default */
+    MSI_CALL_ACTIVE,
+    MSI_CALL_REQUESTING, /* when sending call invite */
+    MSI_CALL_REQUESTED, /* when getting call invite */
 } MSICallState;
 
 /**
  * Callbacks ids that handle the states
  */
 typedef enum {
-    msi_OnInvite, /* Incoming call */
-    msi_OnStart, /* Call (RTP transmission) started */
-    msi_OnEnd, /* Call that was active ended */
-    msi_OnError, /* On protocol error */
-    msi_OnPeerTimeout, /* Peer timed out; stop the call */
-    msi_OnCapabilities, /* Peer requested capabilities change */
+    MSI_ON_INVITE, /* Incoming call */
+    MSI_ON_START, /* Call (RTP transmission) started */
+    MSI_ON_END, /* Call that was active ended */
+    MSI_ON_ERROR, /* On protocol error */
+    MSI_ON_PEERTIMEOUT, /* Peer timed out; stop the call */
+    MSI_ON_CAPABILITIES, /* Peer requested capabilities change */
 } MSICallbackID;
 
 /**
diff --git a/toxav/rtp.c b/toxav/rtp.c
index 3d563a1f..ca4a4a7b 100644
--- a/toxav/rtp.c
+++ b/toxav/rtp.c
@@ -482,11 +482,11 @@ static int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t
         return -1;
     }
 
-    LOGGER_DEBUG(m->log, "header.pt %d, video %d", (uint8_t)header.pt, (rtp_TypeVideo % 128));
+    LOGGER_DEBUG(m->log, "header.pt %d, video %d", (uint8_t)header.pt, (RTP_TYPE_VIDEO % 128));
 
     // The sender uses the new large-frame capable protocol and is sending a
     // video packet.
-    if ((header.flags & RTP_LARGE_FRAME) && header.pt == (rtp_TypeVideo % 128)) {
+    if ((header.flags & RTP_LARGE_FRAME) && header.pt == (RTP_TYPE_VIDEO % 128)) {
         return handle_video_packet(session, &header, data + RTP_HEADER_SIZE, length - RTP_HEADER_SIZE, m->log);
     }
 
@@ -667,7 +667,7 @@ RTPSession *rtp_new(int payload_type, Messenger *m, uint32_t friendnumber,
     // First entry is free.
     session->work_buffer_list->next_free_entry = 0;
 
-    session->ssrc = payload_type == rtp_TypeVideo ? 0 : random_u32();
+    session->ssrc = payload_type == RTP_TYPE_VIDEO ? 0 : random_u32();
     session->payload_type = payload_type;
     session->m = m;
     session->friend_number = friendnumber;
@@ -772,7 +772,7 @@ int rtp_send_data(RTPSession *session, const uint8_t *data, uint32_t length,
     // here the highest bits gets stripped anyway, no need to do keyframe bit magic here!
     header.data_length_lower = length;
 
-    if (session->payload_type == rtp_TypeVideo) {
+    if (session->payload_type == RTP_TYPE_VIDEO) {
         header.flags = RTP_LARGE_FRAME;
     }
 
diff --git a/toxav/rtp.h b/toxav/rtp.h
index d7fc5560..e1cf7950 100644
--- a/toxav/rtp.h
+++ b/toxav/rtp.h
@@ -46,8 +46,8 @@ extern "C" {
  * Payload type identifier. Also used as rtp callback prefix.
  */
 enum {
-    rtp_TypeAudio = 192,
-    rtp_TypeVideo = 193,
+    RTP_TYPE_AUDIO = 192,
+    RTP_TYPE_VIDEO = 193,
 };
 
 /**
diff --git a/toxav/toxav.c b/toxav/toxav.c
index 302657ce..ad2976d6 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -178,12 +178,12 @@ ToxAV *toxav_new(Tox *tox, TOXAV_ERR_NEW *error)
     av->interval = 200;
     av->msi->av = av;
 
-    msi_register_callback(av->msi, callback_invite, msi_OnInvite);
-    msi_register_callback(av->msi, callback_start, msi_OnStart);
-    msi_register_callback(av->msi, callback_end, msi_OnEnd);
-    msi_register_callback(av->msi, callback_error, msi_OnError);
-    msi_register_callback(av->msi, callback_error, msi_OnPeerTimeout);
-    msi_register_callback(av->msi, callback_capabilites, msi_OnCapabilities);
+    msi_register_callback(av->msi, callback_invite, MSI_ON_INVITE);
+    msi_register_callback(av->msi, callback_start, MSI_ON_START);
+    msi_register_callback(av->msi, callback_end, MSI_ON_END);
+    msi_register_callback(av->msi, callback_error, MSI_ON_ERROR);
+    msi_register_callback(av->msi, callback_error, MSI_ON_PEERTIMEOUT);
+    msi_register_callback(av->msi, callback_capabilites, MSI_ON_CAPABILITIES);
 
 END:
 
@@ -259,13 +259,13 @@ void toxav_iterate(ToxAV *av)
             ac_iterate(i->audio);
             vc_iterate(i->video);
 
-            if (i->msi_call->self_capabilities & msi_CapRAudio &&
-                    i->msi_call->peer_capabilities & msi_CapSAudio) {
+            if (i->msi_call->self_capabilities & MSI_CAP_R_AUDIO &&
+                    i->msi_call->peer_capabilities & MSI_CAP_S_AUDIO) {
                 rc = min_s32(i->audio->lp_frame_duration, rc);
             }
 
-            if (i->msi_call->self_capabilities & msi_CapRVideo &&
-                    i->msi_call->peer_capabilities & msi_CapSVideo) {
+            if (i->msi_call->self_capabilities & MSI_CAP_R_VIDEO &&
+                    i->msi_call->peer_capabilities & MSI_CAP_S_VIDEO) {
                 rc = min_u32(i->video->lcfd, (uint32_t) rc);
             }
 
@@ -315,10 +315,10 @@ bool toxav_call(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint
     call->audio_bit_rate = audio_bit_rate;
     call->video_bit_rate = video_bit_rate;
 
-    call->previous_self_capabilities = msi_CapRAudio | msi_CapRVideo;
+    call->previous_self_capabilities = MSI_CAP_R_AUDIO | MSI_CAP_R_VIDEO;
 
-    call->previous_self_capabilities |= audio_bit_rate > 0 ? msi_CapSAudio : 0;
-    call->previous_self_capabilities |= video_bit_rate > 0 ? msi_CapSVideo : 0;
+    call->previous_self_capabilities |= audio_bit_rate > 0 ? MSI_CAP_S_AUDIO : 0;
+    call->previous_self_capabilities |= video_bit_rate > 0 ? MSI_CAP_S_VIDEO : 0;
 
     if (msi_invite(av->msi, &call->msi_call, friend_number, call->previous_self_capabilities) != 0) {
         call_remove(call);
@@ -379,10 +379,10 @@ bool toxav_answer(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, ui
     call->audio_bit_rate = audio_bit_rate;
     call->video_bit_rate = video_bit_rate;
 
-    call->previous_self_capabilities = msi_CapRAudio | msi_CapRVideo;
+    call->previous_self_capabilities = MSI_CAP_R_AUDIO | MSI_CAP_R_VIDEO;
 
-    call->previous_self_capabilities |= audio_bit_rate > 0 ? msi_CapSAudio : 0;
-    call->previous_self_capabilities |= video_bit_rate > 0 ? msi_CapSVideo : 0;
+    call->previous_self_capabilities |= audio_bit_rate > 0 ? MSI_CAP_S_AUDIO : 0;
+    call->previous_self_capabilities |= video_bit_rate > 0 ? MSI_CAP_S_VIDEO : 0;
 
     if (msi_answer(call->msi_call, call->previous_self_capabilities) != 0) {
         rc = TOXAV_ERR_ANSWER_SYNC;
@@ -482,9 +482,9 @@ bool toxav_call_control(ToxAV *av, uint32_t friend_number, TOXAV_CALL_CONTROL co
         break;
 
         case TOXAV_CALL_CONTROL_MUTE_AUDIO: {
-            if (call->msi_call->self_capabilities & msi_CapRAudio) {
+            if (call->msi_call->self_capabilities & MSI_CAP_R_AUDIO) {
                 if (msi_change_capabilities(call->msi_call, call->
-                                            msi_call->self_capabilities ^ msi_CapRAudio) == -1) {
+                                            msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) == -1) {
                     rc = TOXAV_ERR_CALL_CONTROL_SYNC;
                     goto END;
                 }
@@ -498,9 +498,9 @@ bool toxav_call_control(ToxAV *av, uint32_t friend_number, TOXAV_CALL_CONTROL co
         break;
 
         case TOXAV_CALL_CONTROL_UNMUTE_AUDIO: {
-            if (call->msi_call->self_capabilities ^ msi_CapRAudio) {
+            if (call->msi_call->self_capabilities ^ MSI_CAP_R_AUDIO) {
                 if (msi_change_capabilities(call->msi_call, call->
-                                            msi_call->self_capabilities | msi_CapRAudio) == -1) {
+                                            msi_call->self_capabilities | MSI_CAP_R_AUDIO) == -1) {
                     rc = TOXAV_ERR_CALL_CONTROL_SYNC;
                     goto END;
                 }
@@ -514,9 +514,9 @@ bool toxav_call_control(ToxAV *av, uint32_t friend_number, TOXAV_CALL_CONTROL co
         break;
 
         case TOXAV_CALL_CONTROL_HIDE_VIDEO: {
-            if (call->msi_call->self_capabilities & msi_CapRVideo) {
+            if (call->msi_call->self_capabilities & MSI_CAP_R_VIDEO) {
                 if (msi_change_capabilities(call->msi_call, call->
-                                            msi_call->self_capabilities ^ msi_CapRVideo) == -1) {
+                                            msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) == -1) {
                     rc = TOXAV_ERR_CALL_CONTROL_SYNC;
                     goto END;
                 }
@@ -530,9 +530,9 @@ bool toxav_call_control(ToxAV *av, uint32_t friend_number, TOXAV_CALL_CONTROL co
         break;
 
         case TOXAV_CALL_CONTROL_SHOW_VIDEO: {
-            if (call->msi_call->self_capabilities ^ msi_CapRVideo) {
+            if (call->msi_call->self_capabilities ^ MSI_CAP_R_VIDEO) {
                 if (msi_change_capabilities(call->msi_call, call->
-                                            msi_call->self_capabilities | msi_CapRVideo) == -1) {
+                                            msi_call->self_capabilities | MSI_CAP_R_VIDEO) == -1) {
                     rc = TOXAV_ERR_CALL_CONTROL_SYNC;
                     goto END;
                 }
@@ -574,7 +574,7 @@ bool toxav_audio_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t audio_
     pthread_mutex_lock(av->mutex);
     call = call_get(av, friend_number);
 
-    if (call == nullptr || !call->active || call->msi_call->state != msi_CallActive) {
+    if (call == nullptr || !call->active || call->msi_call->state != MSI_CALL_ACTIVE) {
         pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL;
         goto END;
@@ -588,7 +588,7 @@ bool toxav_audio_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t audio_
         LOGGER_DEBUG(av->m->log, "Turned off audio sending");
 
         if (msi_change_capabilities(call->msi_call, call->msi_call->
-                                    self_capabilities ^ msi_CapSAudio) != 0) {
+                                    self_capabilities ^ MSI_CAP_S_AUDIO) != 0) {
             pthread_mutex_unlock(av->mutex);
             rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
             goto END;
@@ -604,7 +604,7 @@ bool toxav_audio_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t audio_
 
             /* The audio has been turned off before this */
             if (msi_change_capabilities(call->msi_call, call->
-                                        msi_call->self_capabilities | msi_CapSAudio) != 0) {
+                                        msi_call->self_capabilities | MSI_CAP_S_AUDIO) != 0) {
                 pthread_mutex_unlock(call->mutex);
                 pthread_mutex_unlock(av->mutex);
                 rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
@@ -646,7 +646,7 @@ bool toxav_video_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t video_
     pthread_mutex_lock(av->mutex);
     call = call_get(av, friend_number);
 
-    if (call == nullptr || !call->active || call->msi_call->state != msi_CallActive) {
+    if (call == nullptr || !call->active || call->msi_call->state != MSI_CALL_ACTIVE) {
         pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL;
         goto END;
@@ -661,7 +661,7 @@ bool toxav_video_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t video_
 
         /* Video sending is turned off; notify peer */
         if (msi_change_capabilities(call->msi_call, call->msi_call->
-                                    self_capabilities ^ msi_CapSVideo) != 0) {
+                                    self_capabilities ^ MSI_CAP_S_VIDEO) != 0) {
             pthread_mutex_unlock(av->mutex);
             rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
             goto END;
@@ -676,7 +676,7 @@ bool toxav_video_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t video_
 
             /* The video has been turned off before this */
             if (msi_change_capabilities(call->msi_call, call->
-                                        msi_call->self_capabilities | msi_CapSVideo) != 0) {
+                                        msi_call->self_capabilities | MSI_CAP_S_VIDEO) != 0) {
                 pthread_mutex_unlock(call->mutex);
                 pthread_mutex_unlock(av->mutex);
                 rc = TOXAV_ERR_BIT_RATE_SET_SYNC;
@@ -731,15 +731,15 @@ bool toxav_audio_send_frame(ToxAV *av, uint32_t friend_number, const int16_t *pc
 
     call = call_get(av, friend_number);
 
-    if (call == nullptr || !call->active || call->msi_call->state != msi_CallActive) {
+    if (call == nullptr || !call->active || call->msi_call->state != MSI_CALL_ACTIVE) {
         pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL;
         goto END;
     }
 
     if (call->audio_bit_rate == 0 ||
-            !(call->msi_call->self_capabilities & msi_CapSAudio) ||
-            !(call->msi_call->peer_capabilities & msi_CapRAudio)) {
+            !(call->msi_call->self_capabilities & MSI_CAP_S_AUDIO) ||
+            !(call->msi_call->peer_capabilities & MSI_CAP_R_AUDIO)) {
         pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_SEND_FRAME_PAYLOAD_TYPE_DISABLED;
         goto END;
@@ -818,15 +818,15 @@ bool toxav_video_send_frame(ToxAV *av, uint32_t friend_number, uint16_t width, u
 
     call = call_get(av, friend_number);
 
-    if (call == nullptr || !call->active || call->msi_call->state != msi_CallActive) {
+    if (call == nullptr || !call->active || call->msi_call->state != MSI_CALL_ACTIVE) {
         pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL;
         goto END;
     }
 
     if (call->video_bit_rate == 0 ||
-            !(call->msi_call->self_capabilities & msi_CapSVideo) ||
-            !(call->msi_call->peer_capabilities & msi_CapRVideo)) {
+            !(call->msi_call->self_capabilities & MSI_CAP_S_VIDEO) ||
+            !(call->msi_call->peer_capabilities & MSI_CAP_R_VIDEO)) {
         pthread_mutex_unlock(av->mutex);
         rc = TOXAV_ERR_SEND_FRAME_PAYLOAD_TYPE_DISABLED;
         goto END;
@@ -1018,8 +1018,8 @@ int callback_invite(void *toxav_inst, MSICall *call)
     av_call->msi_call = call;
 
     if (toxav->ccb) {
-        toxav->ccb(toxav, call->friend_number, call->peer_capabilities & msi_CapSAudio,
-                   call->peer_capabilities & msi_CapSVideo, toxav->ccb_user_data);
+        toxav->ccb(toxav, call->friend_number, call->peer_capabilities & MSI_CAP_S_AUDIO,
+                   call->peer_capabilities & MSI_CAP_S_VIDEO, toxav->ccb_user_data);
     } else {
         /* No handler to capture the call request, send failure */
         pthread_mutex_unlock(toxav->mutex);
@@ -1092,13 +1092,13 @@ int callback_capabilites(void *toxav_inst, MSICall *call)
     ToxAV *toxav = (ToxAV *)toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
-    if (call->peer_capabilities & msi_CapSAudio) {
+    if (call->peer_capabilities & MSI_CAP_S_AUDIO) {
         rtp_allow_receiving(((ToxAVCall *)call->av_call)->audio_rtp);
     } else {
         rtp_stop_receiving(((ToxAVCall *)call->av_call)->audio_rtp);
     }
 
-    if (call->peer_capabilities & msi_CapSVideo) {
+    if (call->peer_capabilities & MSI_CAP_S_VIDEO) {
         rtp_allow_receiving(((ToxAVCall *)call->av_call)->video_rtp);
     } else {
         rtp_stop_receiving(((ToxAVCall *)call->av_call)->video_rtp);
@@ -1321,7 +1321,7 @@ bool call_prepare_transmission(ToxAVCall *call)
             goto FAILURE;
         }
 
-        call->audio_rtp = rtp_new(rtp_TypeAudio, av->m, call->friend_number, call->bwc,
+        call->audio_rtp = rtp_new(RTP_TYPE_AUDIO, av->m, call->friend_number, call->bwc,
                                   call->audio, ac_queue_message);
 
         if (!call->audio_rtp) {
@@ -1337,7 +1337,7 @@ bool call_prepare_transmission(ToxAVCall *call)
             goto FAILURE;
         }
 
-        call->video_rtp = rtp_new(rtp_TypeVideo, av->m, call->friend_number, call->bwc,
+        call->video_rtp = rtp_new(RTP_TYPE_VIDEO, av->m, call->friend_number, call->bwc,
                                   call->video, vc_queue_message);
 
         if (!call->video_rtp) {
diff --git a/toxav/video.c b/toxav/video.c
index 034a8b56..d31df42b 100644
--- a/toxav/video.c
+++ b/toxav/video.c
@@ -360,13 +360,13 @@ int vc_queue_message(void *vcp, struct RTPMessage *msg)
     VCSession *vc = (VCSession *)vcp;
     const struct RTPHeader *const header = &msg->header;
 
-    if (msg->header.pt == (rtp_TypeVideo + 2) % 128) {
+    if (msg->header.pt == (RTP_TYPE_VIDEO + 2) % 128) {
         LOGGER_WARNING(vc->log, "Got dummy!");
         free(msg);
         return 0;
     }
 
-    if (msg->header.pt != rtp_TypeVideo % 128) {
+    if (msg->header.pt != RTP_TYPE_VIDEO % 128) {
         LOGGER_WARNING(vc->log, "Invalid payload type! pt=%d", (int)msg->header.pt);
         free(msg);
         return -1;
@@ -374,7 +374,7 @@ int vc_queue_message(void *vcp, struct RTPMessage *msg)
 
     pthread_mutex_lock(vc->queue_mutex);
 
-    if ((header->flags & RTP_LARGE_FRAME) && header->pt == rtp_TypeVideo % 128) {
+    if ((header->flags & RTP_LARGE_FRAME) && header->pt == RTP_TYPE_VIDEO % 128) {
         LOGGER_DEBUG(vc->log, "rb_write msg->len=%d b0=%d b1=%d", (int)msg->len, (int)msg->data[0], (int)msg->data[1]);
     }