diff --git a/src/ir_decoder/include/ir_ac_parse_frame_info.h b/src/ir_decoder/include/ir_ac_parse_frame_info.h
index c443546..a80a035 100644
--- a/src/ir_decoder/include/ir_ac_parse_frame_info.h
+++ b/src/ir_decoder/include/ir_ac_parse_frame_info.h
@@ -19,15 +19,15 @@ extern "C"
 
 #include "ir_decode.h"
 
-extern INT8 parse_bootcode(struct tag_head *tag);
+extern INT8 parse_boot_code(struct tag_head *tag);
 
 extern INT8 parse_zero(struct tag_head *tag);
 
 extern INT8 parse_one(struct tag_head *tag);
 
-extern INT8 parse_delaycode(struct tag_head *tag);
+extern INT8 parse_delay_code(struct tag_head *tag);
 
-extern INT8 parse_framelen(struct tag_head *tag, UINT16 len);
+extern INT8 parse_frame_len(struct tag_head *tag, UINT16 len);
 
 extern INT8 parse_endian(struct tag_head *tag);
 
@@ -35,7 +35,7 @@ extern INT8 parse_lastbit(struct tag_head *tag);
 
 extern INT8 parse_repeat_times(struct tag_head *tag);
 
-extern INT8 parse_bitnum(struct tag_head *tag);
+extern INT8 parse_bit_num(struct tag_head *tag);
 
 #ifdef __cplusplus
 	}
diff --git a/src/ir_decoder/src/ir_ac_build_frame.c b/src/ir_decoder/src/ir_ac_build_frame.c
index 145396f..8a65d9a 100644
--- a/src/ir_decoder/src/ir_ac_build_frame.c
+++ b/src/ir_decoder/src/ir_ac_build_frame.c
@@ -9,8 +9,6 @@ Revision log:
 * 2016-10-01: created by strawmanbobi
 **************************************************************************************************/
 
-#include <stdio.h>
-
 #include "../include/ir_ac_build_frame.h"
 #include "../include/ir_decode.h"
 
@@ -98,7 +96,7 @@ UINT16 create_ir_frame()
 
     context->code_cnt = 0;
 
-    //bootcode
+    // boot code
     for (i = 0; i < context->bootcode.len; i++)
     {
         context->time[context->code_cnt++] = context->bootcode.data[i];
@@ -108,13 +106,12 @@ UINT16 create_ir_frame()
     for (i = 0; i < ir_hex_len; i++)
     {
         bitnum = bits_per_byte((UINT8)i);
-        //IR_PRINTF("bitnum:%d\n", bitnum);
         for (j = 0; j < bitnum; j++)
         {
-            if (context->endian == 0) //BIg Endian
-                mask = (1 << (bitnum - 1)) >> j;
+            if (context->endian == 0)
+                mask = (UINT8)((1 << (bitnum - 1)) >> j);
             else
-                mask = 1 << j; //Little Endian
+                mask = (UINT8)(1 << j);
 
             if (irdata[i] & mask)
             {
diff --git a/src/ir_decoder/src/ir_ac_control.c b/src/ir_decoder/src/ir_ac_control.c
index 3d6f6e3..6e9c0c5 100644
--- a/src/ir_decoder/src/ir_ac_control.c
+++ b/src/ir_decoder/src/ir_ac_control.c
@@ -200,7 +200,7 @@ INT8 ir_ac_lib_parse() {
                 return IR_DECODE_FAILED;
             }
         } else if (tags[i].tag == TAG_AC_FRAME_LENGTH) {
-            if (IR_DECODE_FAILED == parse_framelen(&tags[i], tags[i].len)) {
+            if (IR_DECODE_FAILED == parse_frame_len(&tags[i], tags[i].len)) {
                 return IR_DECODE_FAILED;
             }
         } else if (tags[i].tag == TAG_AC_ZERO) {
@@ -212,7 +212,7 @@ INT8 ir_ac_lib_parse() {
                 return IR_DECODE_FAILED;
             }
         } else if (tags[i].tag == TAG_AC_BOOT_CODE) {
-            if (IR_DECODE_FAILED == parse_bootcode(&tags[i])) {
+            if (IR_DECODE_FAILED == parse_boot_code(&tags[i])) {
                 return IR_DECODE_FAILED;
             }
         } else if (tags[i].tag == TAG_AC_REPEAT_TIMES) {
@@ -220,7 +220,7 @@ INT8 ir_ac_lib_parse() {
                 return IR_DECODE_FAILED;
             }
         } else if (tags[i].tag == TAG_AC_BITNUM) {
-            if (IR_DECODE_FAILED == parse_bitnum(&tags[i])) {
+            if (IR_DECODE_FAILED == parse_bit_num(&tags[i])) {
                 return IR_DECODE_FAILED;
             }
         } else if (tags[i].tag == TAG_AC_ENDIAN) {
@@ -255,7 +255,7 @@ INT8 ir_ac_lib_parse() {
             continue;
         }
         if (tags[i].tag == TAG_AC_DELAY_CODE) {
-            if (IR_DECODE_FAILED == parse_delaycode(&tags[i])) {
+            if (IR_DECODE_FAILED == parse_delay_code(&tags[i])) {
                 return IR_DECODE_FAILED;
             }
         }
diff --git a/src/ir_decoder/src/ir_ac_parse_forbidden_info.c b/src/ir_decoder/src/ir_ac_parse_forbidden_info.c
index be608cd..7070595 100644
--- a/src/ir_decoder/src/ir_ac_parse_forbidden_info.c
+++ b/src/ir_decoder/src/ir_ac_parse_forbidden_info.c
@@ -20,7 +20,6 @@ Revision log:
 extern protocol* context;
 
 
-
 INT8 parse_nmode_data_speed(char *pdata, ac_n_mode seq)
 {
     char buf[16] = {0};
@@ -35,9 +34,9 @@ INT8 parse_nmode_data_speed(char *pdata, ac_n_mode seq)
             index++;
         }
         irda_memcpy(buf, pdata + pos, index - pos);
-        pos = index + 1;
+        pos = (UINT16)(index + 1);
         index = pos;
-        context->n_mode[seq].speed[cnt++] = atoi(buf);
+        context->n_mode[seq].speed[cnt++] = (UINT8)atoi(buf);
         context->n_mode[seq].speed_cnt = (UINT8)cnt;
         irda_memset(buf, 0, 16);
     }
@@ -60,9 +59,9 @@ INT8 parse_nmode_data_temp(char *pdata, ac_n_mode seq)
             index++;
         }
         irda_memcpy(buf, pdata + pos, index - pos);
-        pos = index + 1;
+        pos = (UINT16)(index + 1);
         index = pos;
-        context->n_mode[seq].temp[cnt++] = atoi(buf) - 16;
+        context->n_mode[seq].temp[cnt++] = (UINT8)(atoi(buf) - 16);
         context->n_mode[seq].temp_cnt = (UINT8)cnt;
         irda_memset(buf, 0, 16);
     }
@@ -131,7 +130,7 @@ INT8 parse_nmode(struct tag_head *tag, ac_n_mode index)
         if (tag->pdata[i] == '|')
         {
             irda_memcpy(buf, tag->pdata + preindex, i - preindex);
-            preindex = i + 1;
+            preindex = (UINT16)(i + 1);
             parse_nmode_pos(buf, index);
             irda_memset(buf, 0, 64);
         }
diff --git a/src/ir_decoder/src/ir_ac_parse_frame_info.c b/src/ir_decoder/src/ir_ac_parse_frame_info.c
index ade2f90..0f0fae1 100644
--- a/src/ir_decoder/src/ir_ac_parse_frame_info.c
+++ b/src/ir_decoder/src/ir_ac_parse_frame_info.c
@@ -17,7 +17,7 @@ Revision log:
 #include "../include/ir_ac_parse_frame_info.h"
 
 
-INT8 parse_bootcode(struct tag_head *tag)
+INT8 parse_boot_code(struct tag_head *tag)
 {
     UINT8 buf[16] = {0};
     UINT8 *p = NULL;
@@ -42,9 +42,9 @@ INT8 parse_bootcode(struct tag_head *tag)
             index++;
         }
         irda_memcpy(buf, tag->pdata + pos, index - pos);
-        pos = index + 1;
+        pos = (UINT16)(index + 1);
         index = pos;
-        context->bootcode.data[cnt++] = atoi((char *) buf);
+        context->bootcode.data[cnt++] = (UINT16)(atoi((char *) buf));
         irda_memset(buf, 0, 16);
     }
     context->bootcode.len = cnt;
@@ -75,10 +75,10 @@ INT8 parse_zero(struct tag_head *tag)
     }
 
     irda_memcpy(low, tag->pdata, index);
-    irda_memcpy(high, tag->pdata + index + 1, tag->len - index - 1);
+    irda_memcpy(high, tag->pdata + index + 1, (size_t)(tag->len - index - 1));
 
-    context->zero.low = atoi((char *) low);
-    context->zero.high = atoi((char *) high);
+    context->zero.low = (UINT16)(atoi((char *) low));
+    context->zero.high = (UINT16)(atoi((char *) high));
     return IR_DECODE_SUCCEEDED;
 }
 
@@ -105,15 +105,15 @@ INT8 parse_one(struct tag_head *tag)
         index++;
     }
     irda_memcpy(low, tag->pdata, index);
-    irda_memcpy(high, tag->pdata + index + 1, tag->len - index - 1);
+    irda_memcpy(high, tag->pdata + index + 1, (size_t)(tag->len - index - 1));
 
-    context->one.low = atoi((char *) low);
-    context->one.high = atoi((char *) high);
+    context->one.low = (UINT16)(atoi((char *) low));
+    context->one.high = (UINT16)(atoi((char *) high));
 
     return IR_DECODE_SUCCEEDED;
 }
 
-INT8 parse_delaycode_data(UINT8 *pdata)
+INT8 parse_delay_code_data(UINT8 *pdata)
 {
     UINT8 buf[16] = {0};
     UINT8 *p = NULL;
@@ -133,9 +133,9 @@ INT8 parse_delaycode_data(UINT8 *pdata)
             index++;
         }
         irda_memcpy(buf, pdata + pos, index - pos);
-        pos = index + 1;
+        pos = (UINT16)(index + 1);
         index = pos;
-        context->dc[context->dc_cnt].time[cnt++] = atoi((char *) buf);
+        context->dc[context->dc_cnt].time[cnt++] = (UINT16)(atoi((char *) buf));
         context->dc[context->dc_cnt].time_cnt = cnt;
         irda_memset(buf, 0, 16);
     }
@@ -143,7 +143,7 @@ INT8 parse_delaycode_data(UINT8 *pdata)
     return IR_DECODE_SUCCEEDED;
 }
 
-INT8 parse_delaycode_pos(UINT8 *buf)
+INT8 parse_delay_code_pos(UINT8 *buf)
 {
     UINT16 i = 0;
     UINT8 data[64] = {0}, start[8] = {0};
@@ -162,14 +162,14 @@ INT8 parse_delaycode_pos(UINT8 *buf)
             break;
         }
     }
-    parse_delaycode_data(data);
-    context->dc[context->dc_cnt].pos = atoi((char *) start);
+    parse_delay_code_data(data);
+    context->dc[context->dc_cnt].pos = (UINT16)(atoi((char *) start));
 
     context->dc_cnt++;
     return IR_DECODE_SUCCEEDED;
 }
 
-INT8 parse_delaycode(struct tag_head *tag)
+INT8 parse_delay_code(struct tag_head *tag)
 {
     UINT8 buf[64] = {0};
     UINT16 i = 0;
@@ -186,20 +186,20 @@ INT8 parse_delaycode(struct tag_head *tag)
         if (tag->pdata[i] == '|')
         {
             irda_memcpy(buf, tag->pdata + preindex, i - preindex);
-            preindex = i + 1;
-            parse_delaycode_pos(buf);
+            preindex = (UINT16)(i + 1);
+            parse_delay_code_pos(buf);
             irda_memset(buf, 0, 64);
         }
 
     }
     irda_memcpy(buf, tag->pdata + preindex, i - preindex);
-    parse_delaycode_pos(buf);
+    parse_delay_code_pos(buf);
     irda_memset(buf, 0, 64);
 
     return IR_DECODE_SUCCEEDED;
 }
 
-INT8 parse_framelen(struct tag_head *tag, UINT16 len)
+INT8 parse_frame_len(struct tag_head *tag, UINT16 len)
 {
     UINT8 *temp = NULL;
 
@@ -220,10 +220,9 @@ INT8 parse_framelen(struct tag_head *tag, UINT16 len)
     irda_memcpy(temp, tag->pdata, len);
     temp[len] = '\0';
 
-    context->frame_length = atoi((char *) temp);
+    context->frame_length = (UINT16)(atoi((char *) temp));
 
     irda_free(temp);
-    temp = NULL;
     return IR_DECODE_SUCCEEDED;
 }
 
@@ -236,7 +235,7 @@ INT8 parse_endian(struct tag_head *tag)
         return IR_DECODE_FAILED;
     }
     irda_memcpy(buf, tag->pdata, tag->len);
-    context->endian = atoi((char *) buf);
+    context->endian = (UINT8)(atoi((char *) buf));
     return IR_DECODE_SUCCEEDED;
 }
 
@@ -249,7 +248,7 @@ INT8 parse_lastbit(struct tag_head *tag)
         return IR_DECODE_FAILED;
     }
     irda_memcpy(buf, tag->pdata, tag->len);
-    context->lastbit = atoi((char *) buf);
+    context->lastbit = (UINT8)(atoi((char *) buf));
     return IR_DECODE_SUCCEEDED;
 }
 
@@ -263,12 +262,12 @@ INT8 parse_repeat_times(struct tag_head *tag)
 
     irda_memcpy(asc_code, tag->pdata, tag->len);
 
-    context->repeat_times = atoi((char *) asc_code);
+    context->repeat_times = (UINT16)(atoi((char *) asc_code));
 
     return IR_DECODE_SUCCEEDED;
 }
 
-INT8 parse_delaycode_tag48_pos(UINT8 *buf)
+INT8 parse_delay_code_tag48_pos(UINT8 *buf)
 {
     UINT16 i = 0;
     UINT8 data[64] = {0}, start[8] = {0};
@@ -288,13 +287,13 @@ INT8 parse_delaycode_tag48_pos(UINT8 *buf)
         }
     }
 
-    context->bitnum[context->bitnum_cnt].pos = atoi((char *) start);
-    context->bitnum[context->bitnum_cnt].bits = atoi((char *) data);
+    context->bitnum[context->bitnum_cnt].pos = (UINT16)(atoi((char *) start));
+    context->bitnum[context->bitnum_cnt].bits = (UINT16)(atoi((char *) data));
     context->bitnum_cnt++;
     return IR_DECODE_SUCCEEDED;
 }
 
-INT8 parse_bitnum(struct tag_head *tag)
+INT8 parse_bit_num(struct tag_head *tag)
 {
     UINT16 i = 0;
     UINT16 preindex = 0;
@@ -311,20 +310,20 @@ INT8 parse_bitnum(struct tag_head *tag)
         if (tag->pdata[i] == '|')
         {
             irda_memcpy(buf, tag->pdata + preindex, i - preindex);
-            preindex = i + 1;
-            parse_delaycode_tag48_pos(buf);
+            preindex = (UINT16)(i + 1);
+            parse_delay_code_tag48_pos(buf);
             irda_memset(buf, 0, 64);
         }
 
     }
     irda_memcpy(buf, tag->pdata + preindex, i - preindex);
-    parse_delaycode_tag48_pos(buf);
+    parse_delay_code_tag48_pos(buf);
     irda_memset(buf, 0, 64);
 
     for (i = 0; i < context->bitnum_cnt; i++)
     {
         if (context->bitnum[i].pos == -1)
-            context->bitnum[i].pos = (context->default_code.len - 1); //convert -1 to last data pos
+            context->bitnum[i].pos = (UINT16)(context->default_code.len - 1); //convert -1 to last data pos
     }
     return IR_DECODE_SUCCEEDED;
 }
diff --git a/src/ir_decoder/src/ir_ac_parse_parameter.c b/src/ir_decoder/src/ir_ac_parse_parameter.c
index 63b7775..e297dac 100644
--- a/src/ir_decoder/src/ir_ac_parse_parameter.c
+++ b/src/ir_decoder/src/ir_ac_parse_parameter.c
@@ -72,7 +72,6 @@ INT8 parse_comp_data_type_2(UINT8 *data, UINT16 *trav_offset, tag_comp *comp)
 INT8 parse_common_ac_parameter(t_tag_head *tag, tag_comp *comp_data, UINT8 with_end, UINT8 type)
 {
     UINT16 hex_len = 0;
-    UINT16 i = 0;
     UINT16 trav_offset = 0;
     UINT16 seg_index = 0;
     UINT8 *hex_data = NULL;
@@ -106,7 +105,6 @@ INT8 parse_common_ac_parameter(t_tag_head *tag, tag_comp *comp_data, UINT8 with_
             if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &comp_data[seg_index]))
             {
                 irda_free(hex_data);
-                hex_data = NULL;
                 return IR_DECODE_FAILED;
             }
 
@@ -123,7 +121,6 @@ INT8 parse_common_ac_parameter(t_tag_head *tag, tag_comp *comp_data, UINT8 with_
             if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &comp_data[seg_index]))
             {
                 irda_free(hex_data);
-                hex_data = NULL;
                 return IR_DECODE_FAILED;
             }
 
@@ -135,7 +132,6 @@ INT8 parse_common_ac_parameter(t_tag_head *tag, tag_comp *comp_data, UINT8 with_
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -190,7 +186,6 @@ INT8 parse_power_1(struct tag_head *tag, power_1 *power1)
         if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &power1->comp_data[seg_index]))
         {
             irda_free(hex_data);
-            hex_data = NULL;
             return IR_DECODE_FAILED;
         }
 
@@ -202,7 +197,6 @@ INT8 parse_power_1(struct tag_head *tag, power_1 *power1)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -246,7 +240,6 @@ INT8 parse_temp_1(struct tag_head *tag, temp_1 *temp1)
             if (NULL == temp1->comp_data[seg_index].segment)
             {
                 irda_free(hex_data);
-                hex_data = NULL;
                 return IR_DECODE_FAILED;
             }
 
@@ -255,7 +248,7 @@ INT8 parse_temp_1(struct tag_head *tag, temp_1 *temp1)
                 temp1->comp_data[seg_index].segment[i - 1] = hex_data[i];
 
                 // get the default value of temperature
-                temp1->comp_data[seg_index].segment[i] = hex_data[i + 1] * seg_index;
+                temp1->comp_data[seg_index].segment[i] = (UINT8)(hex_data[i + 1] * seg_index);
             }
         }
     }
@@ -269,7 +262,6 @@ INT8 parse_temp_1(struct tag_head *tag, temp_1 *temp1)
             if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &temp1->comp_data[seg_index]))
             {
                 irda_free(hex_data);
-                hex_data = NULL;
                 return IR_DECODE_FAILED;
             }
 
@@ -280,7 +272,6 @@ INT8 parse_temp_1(struct tag_head *tag, temp_1 *temp1)
         }
     }
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -315,7 +306,6 @@ INT8 parse_mode_1(struct tag_head *tag, mode_1 *mode1)
         if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &mode1->comp_data[seg_index]))
         {
             irda_free(hex_data);
-            hex_data = NULL;
             return IR_DECODE_FAILED;
         }
 
@@ -326,7 +316,6 @@ INT8 parse_mode_1(struct tag_head *tag, mode_1 *mode1)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -361,7 +350,6 @@ INT8 parse_speed_1(struct tag_head *tag, speed_1 *speed1)
         if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &speed1->comp_data[seg_index]))
         {
             irda_free(hex_data);
-            hex_data = NULL;
             return IR_DECODE_FAILED;
         }
 
@@ -372,7 +360,6 @@ INT8 parse_speed_1(struct tag_head *tag, speed_1 *speed1)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -406,7 +393,6 @@ INT8 parse_swing_1(struct tag_head *tag, swing_1 *swing1, UINT16 swing_count)
     if (NULL == swing1->comp_data)
     {
         irda_free(hex_data);
-        hex_data = NULL;
         return IR_DECODE_FAILED;
     }
 
@@ -415,7 +401,6 @@ INT8 parse_swing_1(struct tag_head *tag, swing_1 *swing1, UINT16 swing_count)
         if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &swing1->comp_data[seg_index]))
         {
             irda_free(hex_data);
-            hex_data = NULL;
             return IR_DECODE_FAILED;
         }
 
@@ -426,7 +411,6 @@ INT8 parse_swing_1(struct tag_head *tag, swing_1 *swing1, UINT16 swing_count)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -478,7 +462,7 @@ INT8 parse_checksum_spec_half_byte_typed(UINT8 *csdata, tag_checksum_data *check
      * Thus the specified half byte checksum only affects 4 bits of a position
      * of half byte specified by check_sum_byte_pos property.
      */
-    UINT16 spec_pos_size = len - 4;
+    UINT16 spec_pos_size = (UINT16)(len - 4);
 
     checksum->checksum_byte_pos = csdata[2];
     checksum->checksum_plus = csdata[3];
@@ -507,8 +491,8 @@ INT8 parse_checksum_malloc(struct tag_head *tag, tchecksum *checksum)
         }
     }
 
-    checksum->len = (tag->len - cnt) >> 1;
-    checksum->count = cnt + 1;
+    checksum->len = (UINT8)((tag->len - cnt) >> 1);
+    checksum->count = (UINT16)(cnt + 1);
     checksum->checksum_data = (tag_checksum_data*) irda_malloc(sizeof(tag_checksum_data) * checksum->count);
 
     if (NULL == checksum->checksum_data)
@@ -548,7 +532,6 @@ INT8 parse_checksum_data(UINT8 *buf, tag_checksum_data *checksum, UINT8 length)
     if (length != hex_data[0] + 1)
     {
         irda_free(hex_data);
-        hex_data = NULL;
         return IR_DECODE_FAILED;
     }
 
@@ -561,7 +544,6 @@ INT8 parse_checksum_data(UINT8 *buf, tag_checksum_data *checksum, UINT8 length)
             if (IR_DECODE_FAILED == parse_checksum_byte_typed(hex_data, checksum, hex_len))
             {
                 irda_free(hex_data);
-                hex_data = NULL;
                 return IR_DECODE_FAILED;
             }
             break;
@@ -570,7 +552,6 @@ INT8 parse_checksum_data(UINT8 *buf, tag_checksum_data *checksum, UINT8 length)
             if (IR_DECODE_FAILED == parse_checksum_half_byte_typed(hex_data, checksum, hex_len))
             {
                 irda_free(hex_data);
-                hex_data = NULL;
                 return IR_DECODE_FAILED;
             }
             break;
@@ -581,19 +562,15 @@ INT8 parse_checksum_data(UINT8 *buf, tag_checksum_data *checksum, UINT8 length)
             if (IR_DECODE_FAILED == parse_checksum_spec_half_byte_typed(hex_data, checksum, hex_len))
             {
                 irda_free(hex_data);
-                hex_data = NULL;
                 return IR_DECODE_FAILED;
             }
             break;
         default:
             irda_free(hex_data);
-            hex_data = NULL;
             return IR_DECODE_FAILED;
-            break;
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
     return IR_DECODE_SUCCEEDED;
 }
 
@@ -624,18 +601,18 @@ INT8 parse_checksum(struct tag_head *tag, tchecksum *checksum)
         {
             if(IR_DECODE_FAILED == parse_checksum_data(tag->pdata + preindex,
                                                        checksum->checksum_data + num,
-                                                       (i - preindex) >> 1))
+                                                       (UINT8)(i - preindex) >> 1))
             {
                 return IR_DECODE_FAILED;
             }
-            preindex = i + 1;
+            preindex = (UINT16)(i + 1);
             num++;
         }
     }
 
     if(IR_DECODE_FAILED == parse_checksum_data(tag->pdata + preindex,
                                                checksum->checksum_data + num,
-                                               (i - preindex) >> 1))
+                                               (UINT8)(i - preindex) >> 1))
     {
         return IR_DECODE_FAILED;
     }
@@ -667,7 +644,7 @@ INT8 parse_function_1(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg)
     (*trav_offset)++;
 
     // function id starts from 1 (POWER)
-    UINT8 function_id = data[*trav_offset] - 1;
+    UINT8 function_id = (UINT8)(data[*trav_offset] - 1);
 
     if (function_id > AC_FUNCTION_MAX - 1)
     {
@@ -697,13 +674,13 @@ INT8 parse_function_1(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg)
 
     if (TRUE == valid_function_id)
     {
-        mode_seg[function_id].seg_len = seg_len - 1;
-        mode_seg[function_id].segment = (UINT8 *) irda_malloc(seg_len - 1);
+        mode_seg[function_id].seg_len = (UINT8)(seg_len - 1);
+        mode_seg[function_id].segment = (UINT8 *) irda_malloc((size_t)(seg_len - 1));
         if (NULL == mode_seg[function_id].segment)
         {
             return IR_DECODE_FAILED;
         }
-        irda_memcpy(mode_seg[function_id].segment, &data[*trav_offset], seg_len - 1);
+        irda_memcpy(mode_seg[function_id].segment, &data[*trav_offset], (size_t)(seg_len - 1));
     }
     *trav_offset += seg_len - 1;
 
@@ -743,16 +720,17 @@ INT8 parse_function_1_tag29(struct tag_head *tag, function_1 *function1)
     // seg_index in TAG only refers to functional count
     for (seg_index = AC_FUNCTION_POWER; seg_index < AC_FUNCTION_MAX; seg_index++)
     {
-        int fid = parse_function_1(hex_data, &trav_offset, &function1->comp_data[0]);
+        INT8 fid = parse_function_1(hex_data, &trav_offset, &function1->comp_data[0]);
 
-        /*
+        /** WARNING: for strict mode only **/
+        /**
         if (fid > AC_FUNCTION_MAX - 1)
         {
             irda_free(hex_data);
             hex_data = NULL;
             return IR_DECODE_FAILED;
         }
-        */
+        **/
 
         if (trav_offset >= hex_len)
         {
@@ -761,7 +739,6 @@ INT8 parse_function_1_tag29(struct tag_head *tag, function_1 *function1)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -810,7 +787,6 @@ INT8 parse_temp_2(struct tag_head *tag, temp_2 *temp2)
             if (NULL == temp2->comp_data[seg_index].segment)
             {
                 irda_free(hex_data);
-                hex_data = NULL;
                 return IR_DECODE_FAILED;
             }
             for (i = 2; i < seg_len; i += 3)
@@ -819,7 +795,7 @@ INT8 parse_temp_2(struct tag_head *tag, temp_2 *temp2)
                 temp2->comp_data[seg_index].segment[i - 1] = hex_data[i];
 
                 // for this second type (TAG 30) temperature update, apply the change in run time.
-                temp2->comp_data[seg_index].segment[i] = hex_data[i + 1] * seg_index;
+                temp2->comp_data[seg_index].segment[i] = (UINT8)(hex_data[i + 1] * seg_index);
             }
         }
     }
@@ -833,7 +809,6 @@ INT8 parse_temp_2(struct tag_head *tag, temp_2 *temp2)
             if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &temp2->comp_data[seg_index]))
             {
                 irda_free(hex_data);
-                hex_data = NULL;
                 return IR_DECODE_FAILED;
             }
 
@@ -844,7 +819,6 @@ INT8 parse_temp_2(struct tag_head *tag, temp_2 *temp2)
         }
     }
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -884,7 +858,6 @@ INT8 parse_mode_2(struct tag_head *tag, mode_2 *mode2)
         if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &mode2->comp_data[seg_index]))
         {
             irda_free(hex_data);
-            hex_data = NULL;
             return IR_DECODE_FAILED;
         }
 
@@ -895,7 +868,6 @@ INT8 parse_mode_2(struct tag_head *tag, mode_2 *mode2)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -935,7 +907,6 @@ INT8 parse_speed_2(struct tag_head *tag, speed_2 *speed2)
         if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &speed2->comp_data[seg_index]))
         {
             irda_free(hex_data);
-            hex_data = NULL;
             return IR_DECODE_FAILED;
         }
 
@@ -946,7 +917,6 @@ INT8 parse_speed_2(struct tag_head *tag, speed_2 *speed2)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -985,7 +955,6 @@ INT8 parse_swing_2(struct tag_head *tag, swing_2 *swing2, UINT16 swing_count)
     if (NULL == swing2->comp_data)
     {
         irda_free(hex_data);
-        hex_data = NULL;
         return IR_DECODE_FAILED;
     }
 
@@ -994,7 +963,6 @@ INT8 parse_swing_2(struct tag_head *tag, swing_2 *swing2, UINT16 swing_count)
         if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &swing2->comp_data[seg_index]))
         {
             irda_free(hex_data);
-            hex_data = NULL;
             return IR_DECODE_FAILED;
         }
 
@@ -1005,7 +973,6 @@ INT8 parse_swing_2(struct tag_head *tag, swing_2 *swing2, UINT16 swing_count)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -1034,7 +1001,7 @@ INT8 parse_function_2(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg)
     (*trav_offset)++;
 
     // function id starts from 1 (POWER)
-    UINT8 function_id = data[*trav_offset] - 1;
+    UINT8 function_id = (UINT8)(data[*trav_offset] - 1);
     if (function_id > AC_FUNCTION_MAX - 1)
     {
         // ignore unsupported function ID
@@ -1063,15 +1030,15 @@ INT8 parse_function_2(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg)
 
     if (TRUE == valid_function_id)
     {
-        mode_seg[function_id].seg_len = seg_len - 1;
-        mode_seg[function_id].segment = (UINT8 *) irda_malloc(seg_len - 1);
+        mode_seg[function_id].seg_len = (UINT8)(seg_len - 1);
+        mode_seg[function_id].segment = (UINT8 *) irda_malloc((size_t)(seg_len - 1));
 
         if (NULL == mode_seg[function_id].segment)
         {
             return IR_DECODE_FAILED;
         }
 
-        irda_memcpy(mode_seg[function_id].segment, &data[*trav_offset], seg_len - 1);
+        irda_memcpy(mode_seg[function_id].segment, &data[*trav_offset], (size_t)(seg_len - 1));
     }
     *trav_offset += seg_len - 1;
 
@@ -1111,16 +1078,17 @@ INT8 parse_function_2_tag34(struct tag_head *tag, function_2 *function2)
     // seg_index in TAG only refers to functional count
     for (seg_index = AC_FUNCTION_POWER; seg_index < AC_FUNCTION_MAX; seg_index++)
     {
-        UINT8 fid = parse_function_2(hex_data, &trav_offset, &function2->comp_data[0]);
+        INT8 fid = parse_function_2(hex_data, &trav_offset, &function2->comp_data[0]);
 
-        /*
+        /** WARNING: for strict mode only **/
+        /**
         if (fid > AC_FUNCTION_MAX - 1)
         {
             irda_free(hex_data);
             hex_data = NULL;
             return IR_DECODE_FAILED;
         }
-        */
+        **/
 
         if (trav_offset >= hex_len)
         {
@@ -1129,7 +1097,6 @@ INT8 parse_function_2_tag34(struct tag_head *tag, function_2 *function2)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -1173,7 +1140,7 @@ INT8 parse_swing_info(struct tag_head *tag, swing_info *si)
      */
     // count how many swing types are there
     si->type = SWING_TYPE_NORMAL;
-    si->mode_count = (tag->len + 1) >> 1;
+    si->mode_count = (UINT8)((tag->len + 1) >> 1);
 
     return IR_DECODE_SUCCEEDED;
 }
@@ -1212,7 +1179,7 @@ INT8 parse_solo_code(struct tag_head *tag, solo_code *sc)
 
     // parse hex data to mode1 data structure
     sc->len = (UINT8)hex_len;
-    sc->solo_func_count = hex_len - 1;
+    sc->solo_func_count = (UINT8)(hex_len - 1);
 
     // per each function takes just 1 byte of length
     sc->solo_func_count = hex_data[0];
@@ -1222,6 +1189,5 @@ INT8 parse_solo_code(struct tag_head *tag, solo_code *sc)
     }
 
     irda_free(hex_data);
-    hex_data = NULL;
     return IR_DECODE_SUCCEEDED;
 }
\ No newline at end of file
diff --git a/src/ir_decoder/src/ir_test_main.c b/src/ir_decoder/src/ir_test_main.c
index cd02dd2..79d8171 100644
--- a/src/ir_decoder/src/ir_test_main.c
+++ b/src/ir_decoder/src/ir_test_main.c
@@ -11,10 +11,6 @@ Revision log:
 
 #include <stdio.h>
 
-#if !defined WIN32
-#include <unistd.h>
-#endif
-
 #include "../include/ir_defs.h"
 #include "../include/ir_decode.h"
 
diff --git a/src/ir_decoder/src/ir_tv_control.c b/src/ir_decoder/src/ir_tv_control.c
index baf86c7..f4da326 100644
--- a/src/ir_decoder/src/ir_tv_control.c
+++ b/src/ir_decoder/src/ir_tv_control.c
@@ -327,7 +327,7 @@ static void process_decode_number(UINT8 keycode, irda_data_t *data, UINT8 valid_
     UINT8 bit_num = data->bits / valid_bits;
     UINT8 valid_value = 0;
 
-    valid_value = (valid_bits == 1) ? 1 : (valid_bits * valid_bits - 1);
+    valid_value = (UINT8)((valid_bits == 1) ? 1 : (valid_bits * valid_bits - 1));
 
     if (data->lsb == IRDA_LSB)
     {
diff --git a/src/ir_decoder/src/ir_utils.c b/src/ir_decoder/src/ir_utils.c
index a85b85b..63bab1b 100644
--- a/src/ir_decoder/src/ir_utils.c
+++ b/src/ir_decoder/src/ir_utils.c
@@ -15,11 +15,11 @@ UINT8 char_to_hex(char chr)
 {
     UINT8 value = 0;
     if (chr >= '0' && chr <= '9')
-        value = chr - '0';
+        value = (UINT8)(chr - '0');
     if (chr >= 'a' && chr <= 'f')
-        value = chr - 'a' + 10;
+        value = (UINT8)(chr - 'a' + 10);
     if (chr >= 'A' && chr <= 'F')
-        value = chr - 'A' + 10;
+        value = (UINT8)(chr - 'A' + 10);
     return value;
 }
 
@@ -61,11 +61,11 @@ char hex_half_byte_to_single_char(UINT8 length, UINT8 half_byte)
     }
     if (half_byte >= 10 && half_byte < 16)
     {
-        return (half_byte - 10 + 0x41);
+        return (char)(half_byte - 10 + 0x41);
     }
     else
     {
-        return half_byte + 0x30;
+        return (char)(half_byte + 0x30);
     }
 }
 
@@ -77,8 +77,8 @@ void hex_byte_to_double_char(char* dest, UINT8 length, UINT8 src)
     {
         return;
     }
-    hi_num = (src >> 4) & 0x0F;
-    lo_num = src & 0x0F;
+    hi_num = (UINT8)((src >> 4) & 0x0F);
+    lo_num = (UINT8)(src & 0x0F);
 
     dest[0] = hex_half_byte_to_single_char(1, hi_num);
     dest[1] = hex_half_byte_to_single_char(1, lo_num);