--- a/media/mtransport/third_party/nrappkit/src/registry/c2ru.c
+++ b/media/mtransport/third_party/nrappkit/src/registry/c2ru.c
@@ -215,18 +215,17 @@ abort:
   return (_status);
 }
 
 int
 nr_c2ru_get_children(NR_registry parent, char *child, void *ptr, size_t size, int (*get)(NR_registry, void*))
 {
   int r, _status;
   NR_registry registry;
-  unsigned int count;
-  int i;
+  unsigned int i, count;
   NR_registry name;
   struct entry { TAILQ_ENTRY(entry) entries; } *entry;
   TAILQ_HEAD(, entry) *tailq = (void*)ptr;
 
   TAILQ_INIT(tailq);
 
   if ((r=nr_c2ru_make_registry(parent, child, registry)))
     ABORT(r);

--- a/media/mtransport/third_party/nrappkit/src/registry/registry.c
+++ b/media/mtransport/third_party/nrappkit/src/registry/registry.c
@@ -336,17 +336,17 @@ nr_reg_type_name(int type)
 
     return(typenames[type]);
 }
 
 int
 nr_reg_compute_type(char *typename, int *type)
 {
     int _status;
-    int i;
+    unsigned int i;
 
 #ifdef SANITY_CHECKS
     assert(!strcasecmp(typenames[NR_REG_TYPE_CHAR],     "char"));
     assert(!strcasecmp(typenames[NR_REG_TYPE_UCHAR],    "UCHAR"));
     assert(!strcasecmp(typenames[NR_REG_TYPE_INT2],     "INT2"));
     assert(!strcasecmp(typenames[NR_REG_TYPE_UINT2],    "UINT2"));
     assert(!strcasecmp(typenames[NR_REG_TYPE_INT4],     "INT4"));
     assert(!strcasecmp(typenames[NR_REG_TYPE_UINT4],    "UINT4"));
@@ -556,20 +556,18 @@ NR_reg_get2_child_registry(NR_registry b
   }
 
 
 /* requires parent already in legal form */
 int
 NR_reg_make_registry(NR_registry parent, char *child, NR_registry out)
 {
     int r, _status;
-    int plen;
-    int clen;
+    size_t i, clen, plen;
     char *c;
-    int i;
 
     if ((r=nr_reg_is_valid(parent)))
         ABORT(r);
 
     if (*child == '.')
         ABORT(R_BAD_ARGS);
 
     clen = strlen(child);

--- a/media/mtransport/third_party/nrappkit/src/registry/registry_local.c
+++ b/media/mtransport/third_party/nrappkit/src/registry/registry_local.c
@@ -877,32 +877,32 @@ nr_reg_local_init(nr_registry_module *me
           ABORT(r);
     }
 
     _status=0;
   abort:
     return(_status);
 }
 
-#define NRREGGET(func, TYPE, type)                                  \
+#define NRREGLOCALGET(func, TYPE, type)                             \
 int                                                                 \
 func(NR_registry name, type *out)                                   \
 {                                                                   \
     return nr_reg_get(name, TYPE, out);                             \
 }
 
-NRREGGET(nr_reg_local_get_char,     NR_REG_TYPE_CHAR,     char)
-NRREGGET(nr_reg_local_get_uchar,    NR_REG_TYPE_UCHAR,    UCHAR)
-NRREGGET(nr_reg_local_get_int2,     NR_REG_TYPE_INT2,     INT2)
-NRREGGET(nr_reg_local_get_uint2,    NR_REG_TYPE_UINT2,    UINT2)
-NRREGGET(nr_reg_local_get_int4,     NR_REG_TYPE_INT4,     INT4)
-NRREGGET(nr_reg_local_get_uint4,    NR_REG_TYPE_UINT4,    UINT4)
-NRREGGET(nr_reg_local_get_int8,     NR_REG_TYPE_INT8,     INT8)
-NRREGGET(nr_reg_local_get_uint8,    NR_REG_TYPE_UINT8,    UINT8)
-NRREGGET(nr_reg_local_get_double,   NR_REG_TYPE_DOUBLE,   double)
+NRREGLOCALGET(nr_reg_local_get_char,     NR_REG_TYPE_CHAR,     char)
+NRREGLOCALGET(nr_reg_local_get_uchar,    NR_REG_TYPE_UCHAR,    UCHAR)
+NRREGLOCALGET(nr_reg_local_get_int2,     NR_REG_TYPE_INT2,     INT2)
+NRREGLOCALGET(nr_reg_local_get_uint2,    NR_REG_TYPE_UINT2,    UINT2)
+NRREGLOCALGET(nr_reg_local_get_int4,     NR_REG_TYPE_INT4,     INT4)
+NRREGLOCALGET(nr_reg_local_get_uint4,    NR_REG_TYPE_UINT4,    UINT4)
+NRREGLOCALGET(nr_reg_local_get_int8,     NR_REG_TYPE_INT8,     INT8)
+NRREGLOCALGET(nr_reg_local_get_uint8,    NR_REG_TYPE_UINT8,    UINT8)
+NRREGLOCALGET(nr_reg_local_get_double,   NR_REG_TYPE_DOUBLE,   double)
 
 int
 nr_reg_local_get_registry(NR_registry name, NR_registry out)
 {
     int r, _status;
     nr_scalar_registry_node *node = 0;
     int free_node = 0;
 
@@ -970,32 +970,32 @@ nr_reg_local_get_type(NR_registry name, 
     strncpy(type, str, sizeof(NR_registry_type));
 
     _status=0;
   abort:
     return(_status);
 }
 
 
-#define NRREGSET(func, TYPE, type)                              \
+#define NRREGLOCALSET(func, TYPE, type)                         \
 int                                                             \
 func(NR_registry name, type data)                               \
 {                                                               \
     return nr_reg_set(name, TYPE, &data);                       \
 }
 
-NRREGSET(nr_reg_local_set_char,     NR_REG_TYPE_CHAR,     char)
-NRREGSET(nr_reg_local_set_uchar,    NR_REG_TYPE_UCHAR,    UCHAR)
-NRREGSET(nr_reg_local_set_int2,     NR_REG_TYPE_INT2,     INT2)
-NRREGSET(nr_reg_local_set_uint2,    NR_REG_TYPE_UINT2,    UINT2)
-NRREGSET(nr_reg_local_set_int4,     NR_REG_TYPE_INT4,     INT4)
-NRREGSET(nr_reg_local_set_uint4,    NR_REG_TYPE_UINT4,    UINT4)
-NRREGSET(nr_reg_local_set_int8,     NR_REG_TYPE_INT8,     INT8)
-NRREGSET(nr_reg_local_set_uint8,    NR_REG_TYPE_UINT8,    UINT8)
-NRREGSET(nr_reg_local_set_double,   NR_REG_TYPE_DOUBLE,   double)
+NRREGLOCALSET(nr_reg_local_set_char,     NR_REG_TYPE_CHAR,     char)
+NRREGLOCALSET(nr_reg_local_set_uchar,    NR_REG_TYPE_UCHAR,    UCHAR)
+NRREGLOCALSET(nr_reg_local_set_int2,     NR_REG_TYPE_INT2,     INT2)
+NRREGLOCALSET(nr_reg_local_set_uint2,    NR_REG_TYPE_UINT2,    UINT2)
+NRREGLOCALSET(nr_reg_local_set_int4,     NR_REG_TYPE_INT4,     INT4)
+NRREGLOCALSET(nr_reg_local_set_uint4,    NR_REG_TYPE_UINT4,    UINT4)
+NRREGLOCALSET(nr_reg_local_set_int8,     NR_REG_TYPE_INT8,     INT8)
+NRREGLOCALSET(nr_reg_local_set_uint8,    NR_REG_TYPE_UINT8,    UINT8)
+NRREGLOCALSET(nr_reg_local_set_double,   NR_REG_TYPE_DOUBLE,   double)
 
 int
 nr_reg_local_set_registry(NR_registry name)
 {
     return nr_reg_set(name, NR_REG_TYPE_REGISTRY, 0);
 }
 
 int

--- a/media/mtransport/third_party/nrappkit/src/registry/registrycb.c
+++ b/media/mtransport/third_party/nrappkit/src/registry/registrycb.c
@@ -96,17 +96,17 @@ nr_reg_cb_init()
     }
     return(_status);
 }
 
 int
 nr_reg_validate_action(char action)
 {
     int _status;
-    int i;
+    unsigned int i;
 
     for (i = 0; i < sizeof(CB_ACTIONS); ++i) {
         if (action == CB_ACTIONS[i])
             return 0;
     }
     ABORT(R_BAD_ARGS);
 
     _status=0;
@@ -392,17 +392,17 @@ nr_reg_raise_event(char *name, int actio
 
 
 /* PUBLIC METHODS */
 
 int
 NR_reg_register_callback(NR_registry name, char action, void (*cb)(void *cb_arg, char action, NR_registry name), void *cb_arg)
 {
     int r, _status;
-    int i;
+    unsigned int i;
 
     for (i = 0; i < sizeof(CB_ACTIONS); ++i) {
         if (action & CB_ACTIONS[i]) {
             if ((r=nr_reg_register_callback(name, CB_ACTIONS[i], cb, cb_arg)))
                 ABORT(r);
 
             action &= ~(CB_ACTIONS[i]);
         }
@@ -415,17 +415,17 @@ NR_reg_register_callback(NR_registry nam
   abort:
     return(_status);
 }
 
 int
 NR_reg_unregister_callback(char *name, char action, void (*cb)(void *cb_arg, char action, NR_registry name))
 {
     int r, _status;
-    int i;
+    unsigned int i;
 
     for (i = 0; i < sizeof(CB_ACTIONS); ++i) {
         if (action & CB_ACTIONS[i]) {
             if ((r=nr_reg_unregister_callback(name, CB_ACTIONS[i], cb)))
                 ABORT(r);
 
             action &= ~(CB_ACTIONS[i]);
         }

--- a/media/mtransport/third_party/nrappkit/src/util/hex.c
+++ b/media/mtransport/third_party/nrappkit/src/util/hex.c
@@ -74,20 +74,19 @@ nr_nbin2hex(UCHAR *bin, int binlen, char
     return(_status);
 }
 
 
 int
 nr_nhex2bin(char *hex, int hexlen, UCHAR bin[], size_t size, int *len)
 {
     int _status;
-    int binlen;
+    size_t i, binlen;
     int h1;
     int h2;
-    int i;
 
     if (hexlen % 2)
         ABORT(R_BAD_ARGS);
 
     binlen = hexlen/2;
 
     if (size < binlen)
         ABORT(R_BAD_ARGS);

--- a/media/mtransport/third_party/nrappkit/src/util/libekr/r_errors.c
+++ b/media/mtransport/third_party/nrappkit/src/util/libekr/r_errors.c
@@ -106,17 +106,17 @@ int nr_verr_exit(char *fmt,...)
 
     exit(1);
   }
 
 char *
 nr_strerror(int errnum)
 {
     static char unknown_error[256];
-    int i;
+    size_t i;
     char *error = 0;
 
     for (i = 0; i < sizeof(errors)/sizeof(*errors); ++i) {
         if (errnum == errors[i].errnum) {
             error = errors[i].str;
             break;
         }
     }