irext/core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed CLion warnings

Browse Source
This commit is contained in:
strawmanbobi
2017-01-02 19:54:10 +08:00
parent 22a8773a25
commit 1c3763ae8f
9 changed files with 83 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/ir_decoder/include/ir_ac_parse_frame_info.h
View File

@@ -19,15 +19,15 @@ extern "C"
#include "ir_decode.h" #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_zero(struct tag_head *tag);
extern INT8 parse_one(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); 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_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 #ifdef __cplusplus
} }

11
src/ir_decoder/src/ir_ac_build_frame.c
View File

@@ -9,8 +9,6 @@ Revision log:
* 2016-10-01: created by strawmanbobi * 2016-10-01: created by strawmanbobi
**************************************************************************************************/ **************************************************************************************************/
#include <stdio.h>
#include "../include/ir_ac_build_frame.h" #include "../include/ir_ac_build_frame.h"
#include "../include/ir_decode.h" #include "../include/ir_decode.h"
@@ -98,7 +96,7 @@ UINT16 create_ir_frame()
context->code_cnt = 0; context->code_cnt = 0;
//bootcode // boot code
for (i = 0; i < context->bootcode.len; i++) for (i = 0; i < context->bootcode.len; i++)
{ {
context->time[context->code_cnt++] = context->bootcode.data[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++) for (i = 0; i < ir_hex_len; i++)
{ {
bitnum = bits_per_byte((UINT8)i); bitnum = bits_per_byte((UINT8)i);
//IR_PRINTF("bitnum:%d\n", bitnum);
for (j = 0; j < bitnum; j++) for (j = 0; j < bitnum; j++)
{ {
if (context->endian == 0) //BIg Endian if (context->endian == 0)
mask = (1 << (bitnum - 1)) >> j; mask = (UINT8)((1 << (bitnum - 1)) >> j);
else else
mask = 1 << j; //Little Endian mask = (UINT8)(1 << j);
if (irdata[i] & mask) if (irdata[i] & mask)
{ {

8
src/ir_decoder/src/ir_ac_control.c
View File

@@ -200,7 +200,7 @@ INT8 ir_ac_lib_parse() {
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
} else if (tags[i].tag == TAG_AC_FRAME_LENGTH) { } 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; return IR_DECODE_FAILED;
} }
} else if (tags[i].tag == TAG_AC_ZERO) { } else if (tags[i].tag == TAG_AC_ZERO) {
@@ -212,7 +212,7 @@ INT8 ir_ac_lib_parse() {
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
} else if (tags[i].tag == TAG_AC_BOOT_CODE) { } 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; return IR_DECODE_FAILED;
} }
} else if (tags[i].tag == TAG_AC_REPEAT_TIMES) { } else if (tags[i].tag == TAG_AC_REPEAT_TIMES) {
@@ -220,7 +220,7 @@ INT8 ir_ac_lib_parse() {
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
} else if (tags[i].tag == TAG_AC_BITNUM) { } 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; return IR_DECODE_FAILED;
} }
} else if (tags[i].tag == TAG_AC_ENDIAN) { } else if (tags[i].tag == TAG_AC_ENDIAN) {
@@ -255,7 +255,7 @@ INT8 ir_ac_lib_parse() {
continue; continue;
} }
if (tags[i].tag == TAG_AC_DELAY_CODE) { 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; return IR_DECODE_FAILED;
} }
} }

11
src/ir_decoder/src/ir_ac_parse_forbidden_info.c
View File

@@ -20,7 +20,6 @@ Revision log:
extern protocol* context; extern protocol* context;
INT8 parse_nmode_data_speed(char *pdata, ac_n_mode seq) INT8 parse_nmode_data_speed(char *pdata, ac_n_mode seq)
{ {
char buf[16] = {0}; char buf[16] = {0};
@@ -35,9 +34,9 @@ INT8 parse_nmode_data_speed(char *pdata, ac_n_mode seq)
index++; index++;
} }
irda_memcpy(buf, pdata + pos, index - pos); irda_memcpy(buf, pdata + pos, index - pos);
pos = index + 1; pos = (UINT16)(index + 1);
index = pos; 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; context->n_mode[seq].speed_cnt = (UINT8)cnt;
irda_memset(buf, 0, 16); irda_memset(buf, 0, 16);
} }
@@ -60,9 +59,9 @@ INT8 parse_nmode_data_temp(char *pdata, ac_n_mode seq)
index++; index++;
} }
irda_memcpy(buf, pdata + pos, index - pos); irda_memcpy(buf, pdata + pos, index - pos);
pos = index + 1; pos = (UINT16)(index + 1);
index = pos; 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; context->n_mode[seq].temp_cnt = (UINT8)cnt;
irda_memset(buf, 0, 16); irda_memset(buf, 0, 16);
} }
@@ -131,7 +130,7 @@ INT8 parse_nmode(struct tag_head *tag, ac_n_mode index)
if (tag->pdata[i] == '|') if (tag->pdata[i] == '|')
{ {
irda_memcpy(buf, tag->pdata + preindex, i - preindex); irda_memcpy(buf, tag->pdata + preindex, i - preindex);
preindex = i + 1; preindex = (UINT16)(i + 1);
parse_nmode_pos(buf, index); parse_nmode_pos(buf, index);
irda_memset(buf, 0, 64); irda_memset(buf, 0, 64);
} }

65
src/ir_decoder/src/ir_ac_parse_frame_info.c
View File

@@ -17,7 +17,7 @@ Revision log:
#include "../include/ir_ac_parse_frame_info.h" #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 buf[16] = {0};
UINT8 *p = NULL; UINT8 *p = NULL;
@@ -42,9 +42,9 @@ INT8 parse_bootcode(struct tag_head *tag)
index++; index++;
} }
irda_memcpy(buf, tag->pdata + pos, index - pos); irda_memcpy(buf, tag->pdata + pos, index - pos);
pos = index + 1; pos = (UINT16)(index + 1);
index = pos; index = pos;
context->bootcode.data[cnt++] = atoi((char *) buf); context->bootcode.data[cnt++] = (UINT16)(atoi((char *) buf));
irda_memset(buf, 0, 16); irda_memset(buf, 0, 16);
} }
context->bootcode.len = cnt; context->bootcode.len = cnt;
@@ -75,10 +75,10 @@ INT8 parse_zero(struct tag_head *tag)
} }
irda_memcpy(low, tag->pdata, 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->zero.low = atoi((char *) low); context->zero.low = (UINT16)(atoi((char *) low));
context->zero.high = atoi((char *) high); context->zero.high = (UINT16)(atoi((char *) high));
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }
@@ -105,15 +105,15 @@ INT8 parse_one(struct tag_head *tag)
index++; index++;
} }
irda_memcpy(low, tag->pdata, 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.low = (UINT16)(atoi((char *) low));
context->one.high = atoi((char *) high); context->one.high = (UINT16)(atoi((char *) high));
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }
INT8 parse_delaycode_data(UINT8 *pdata) INT8 parse_delay_code_data(UINT8 *pdata)
{ {
UINT8 buf[16] = {0}; UINT8 buf[16] = {0};
UINT8 *p = NULL; UINT8 *p = NULL;
@@ -133,9 +133,9 @@ INT8 parse_delaycode_data(UINT8 *pdata)
index++; index++;
} }
irda_memcpy(buf, pdata + pos, index - pos); irda_memcpy(buf, pdata + pos, index - pos);
pos = index + 1; pos = (UINT16)(index + 1);
index = pos; 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; context->dc[context->dc_cnt].time_cnt = cnt;
irda_memset(buf, 0, 16); irda_memset(buf, 0, 16);
} }
@@ -143,7 +143,7 @@ INT8 parse_delaycode_data(UINT8 *pdata)
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }
INT8 parse_delaycode_pos(UINT8 *buf) INT8 parse_delay_code_pos(UINT8 *buf)
{ {
UINT16 i = 0; UINT16 i = 0;
UINT8 data[64] = {0}, start[8] = {0}; UINT8 data[64] = {0}, start[8] = {0};
@@ -162,14 +162,14 @@ INT8 parse_delaycode_pos(UINT8 *buf)
break; break;
} }
} }
parse_delaycode_data(data); parse_delay_code_data(data);
context->dc[context->dc_cnt].pos = atoi((char *) start); context->dc[context->dc_cnt].pos = (UINT16)(atoi((char *) start));
context->dc_cnt++; context->dc_cnt++;
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }
INT8 parse_delaycode(struct tag_head *tag) INT8 parse_delay_code(struct tag_head *tag)
{ {
UINT8 buf[64] = {0}; UINT8 buf[64] = {0};
UINT16 i = 0; UINT16 i = 0;
@@ -186,20 +186,20 @@ INT8 parse_delaycode(struct tag_head *tag)
if (tag->pdata[i] == '|') if (tag->pdata[i] == '|')
{ {
irda_memcpy(buf, tag->pdata + preindex, i - preindex); irda_memcpy(buf, tag->pdata + preindex, i - preindex);
preindex = i + 1; preindex = (UINT16)(i + 1);
parse_delaycode_pos(buf); parse_delay_code_pos(buf);
irda_memset(buf, 0, 64); irda_memset(buf, 0, 64);
} }
} }
irda_memcpy(buf, tag->pdata + preindex, i - preindex); irda_memcpy(buf, tag->pdata + preindex, i - preindex);
parse_delaycode_pos(buf); parse_delay_code_pos(buf);
irda_memset(buf, 0, 64); irda_memset(buf, 0, 64);
return IR_DECODE_SUCCEEDED; 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; UINT8 *temp = NULL;
@@ -220,10 +220,9 @@ INT8 parse_framelen(struct tag_head *tag, UINT16 len)
irda_memcpy(temp, tag->pdata, len); irda_memcpy(temp, tag->pdata, len);
temp[len] = '\0'; temp[len] = '\0';
context->frame_length = atoi((char *) temp); context->frame_length = (UINT16)(atoi((char *) temp));
irda_free(temp); irda_free(temp);
temp = NULL;
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }
@@ -236,7 +235,7 @@ INT8 parse_endian(struct tag_head *tag)
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
irda_memcpy(buf, tag->pdata, tag->len); irda_memcpy(buf, tag->pdata, tag->len);
context->endian = atoi((char *) buf); context->endian = (UINT8)(atoi((char *) buf));
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }
@@ -249,7 +248,7 @@ INT8 parse_lastbit(struct tag_head *tag)
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
irda_memcpy(buf, tag->pdata, tag->len); irda_memcpy(buf, tag->pdata, tag->len);
context->lastbit = atoi((char *) buf); context->lastbit = (UINT8)(atoi((char *) buf));
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }
@@ -263,12 +262,12 @@ INT8 parse_repeat_times(struct tag_head *tag)
irda_memcpy(asc_code, tag->pdata, tag->len); 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; return IR_DECODE_SUCCEEDED;
} }
INT8 parse_delaycode_tag48_pos(UINT8 *buf) INT8 parse_delay_code_tag48_pos(UINT8 *buf)
{ {
UINT16 i = 0; UINT16 i = 0;
UINT8 data[64] = {0}, start[8] = {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].pos = (UINT16)(atoi((char *) start));
context->bitnum[context->bitnum_cnt].bits = atoi((char *) data); context->bitnum[context->bitnum_cnt].bits = (UINT16)(atoi((char *) data));
context->bitnum_cnt++; context->bitnum_cnt++;
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }
INT8 parse_bitnum(struct tag_head *tag) INT8 parse_bit_num(struct tag_head *tag)
{ {
UINT16 i = 0; UINT16 i = 0;
UINT16 preindex = 0; UINT16 preindex = 0;
@@ -311,20 +310,20 @@ INT8 parse_bitnum(struct tag_head *tag)
if (tag->pdata[i] == '|') if (tag->pdata[i] == '|')
{ {
irda_memcpy(buf, tag->pdata + preindex, i - preindex); irda_memcpy(buf, tag->pdata + preindex, i - preindex);
preindex = i + 1; preindex = (UINT16)(i + 1);
parse_delaycode_tag48_pos(buf); parse_delay_code_tag48_pos(buf);
irda_memset(buf, 0, 64); irda_memset(buf, 0, 64);
} }
} }
irda_memcpy(buf, tag->pdata + preindex, i - preindex); irda_memcpy(buf, tag->pdata + preindex, i - preindex);
parse_delaycode_tag48_pos(buf); parse_delay_code_tag48_pos(buf);
irda_memset(buf, 0, 64); irda_memset(buf, 0, 64);
for (i = 0; i < context->bitnum_cnt; i++) for (i = 0; i < context->bitnum_cnt; i++)
{ {
if (context->bitnum[i].pos == -1) 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; return IR_DECODE_SUCCEEDED;
} }

86
src/ir_decoder/src/ir_ac_parse_parameter.c
View File

@@ -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) INT8 parse_common_ac_parameter(t_tag_head *tag, tag_comp *comp_data, UINT8 with_end, UINT8 type)
{ {
UINT16 hex_len = 0; UINT16 hex_len = 0;
UINT16 i = 0;
UINT16 trav_offset = 0; UINT16 trav_offset = 0;
UINT16 seg_index = 0; UINT16 seg_index = 0;
UINT8 *hex_data = NULL; 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])) if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; 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])) if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; 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); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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])) if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &power1->comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
@@ -202,7 +197,6 @@ INT8 parse_power_1(struct tag_head *tag, power_1 *power1)
} }
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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) if (NULL == temp1->comp_data[seg_index].segment)
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; 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]; temp1->comp_data[seg_index].segment[i - 1] = hex_data[i];
// get the default value of temperature // 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])) if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &temp1->comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
@@ -280,7 +272,6 @@ INT8 parse_temp_1(struct tag_head *tag, temp_1 *temp1)
} }
} }
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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])) if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &mode1->comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
@@ -326,7 +316,6 @@ INT8 parse_mode_1(struct tag_head *tag, mode_1 *mode1)
} }
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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])) if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &speed1->comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
@@ -372,7 +360,6 @@ INT8 parse_speed_1(struct tag_head *tag, speed_1 *speed1)
} }
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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) if (NULL == swing1->comp_data)
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; 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])) if (IR_DECODE_FAILED == parse_comp_data_type_1(hex_data, &trav_offset, &swing1->comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; 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); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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 * Thus the specified half byte checksum only affects 4 bits of a position
* of half byte specified by check_sum_byte_pos property. * 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_byte_pos = csdata[2];
checksum->checksum_plus = csdata[3]; 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->len = (UINT8)((tag->len - cnt) >> 1);
checksum->count = cnt + 1; checksum->count = (UINT16)(cnt + 1);
checksum->checksum_data = (tag_checksum_data*) irda_malloc(sizeof(tag_checksum_data) * checksum->count); checksum->checksum_data = (tag_checksum_data*) irda_malloc(sizeof(tag_checksum_data) * checksum->count);
if (NULL == checksum->checksum_data) 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) if (length != hex_data[0] + 1)
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; 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)) if (IR_DECODE_FAILED == parse_checksum_byte_typed(hex_data, checksum, hex_len))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
break; 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)) if (IR_DECODE_FAILED == parse_checksum_half_byte_typed(hex_data, checksum, hex_len))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
break; 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)) if (IR_DECODE_FAILED == parse_checksum_spec_half_byte_typed(hex_data, checksum, hex_len))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
break; break;
default: default:
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
break;
} }
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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, if(IR_DECODE_FAILED == parse_checksum_data(tag->pdata + preindex,
checksum->checksum_data + num, checksum->checksum_data + num,
(i - preindex) >> 1)) (UINT8)(i - preindex) >> 1))
{ {
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
preindex = i + 1; preindex = (UINT16)(i + 1);
num++; num++;
} }
} }
if(IR_DECODE_FAILED == parse_checksum_data(tag->pdata + preindex, if(IR_DECODE_FAILED == parse_checksum_data(tag->pdata + preindex,
checksum->checksum_data + num, checksum->checksum_data + num,
(i - preindex) >> 1)) (UINT8)(i - preindex) >> 1))
{ {
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
@@ -667,7 +644,7 @@ INT8 parse_function_1(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg)
(*trav_offset)++; (*trav_offset)++;
// function id starts from 1 (POWER) // 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) 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) if (TRUE == valid_function_id)
{ {
mode_seg[function_id].seg_len = seg_len - 1; mode_seg[function_id].seg_len = (UINT8)(seg_len - 1);
mode_seg[function_id].segment = (UINT8 *) irda_malloc(seg_len - 1); mode_seg[function_id].segment = (UINT8 *) irda_malloc((size_t)(seg_len - 1));
if (NULL == mode_seg[function_id].segment) if (NULL == mode_seg[function_id].segment)
{ {
return IR_DECODE_FAILED; 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; *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 // seg_index in TAG only refers to functional count
for (seg_index = AC_FUNCTION_POWER; seg_index < AC_FUNCTION_MAX; seg_index++) 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) if (fid > AC_FUNCTION_MAX - 1)
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL; hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
*/ **/
if (trav_offset >= hex_len) 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); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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) if (NULL == temp2->comp_data[seg_index].segment)
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
for (i = 2; i < seg_len; i += 3) 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]; 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. // 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])) if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &temp2->comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
@@ -844,7 +819,6 @@ INT8 parse_temp_2(struct tag_head *tag, temp_2 *temp2)
} }
} }
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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])) if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &mode2->comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
@@ -895,7 +868,6 @@ INT8 parse_mode_2(struct tag_head *tag, mode_2 *mode2)
} }
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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])) if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &speed2->comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
@@ -946,7 +917,6 @@ INT8 parse_speed_2(struct tag_head *tag, speed_2 *speed2)
} }
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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) if (NULL == swing2->comp_data)
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; 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])) if (IR_DECODE_FAILED == parse_comp_data_type_2(hex_data, &trav_offset, &swing2->comp_data[seg_index]))
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_FAILED; 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); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }
@@ -1034,7 +1001,7 @@ INT8 parse_function_2(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg)
(*trav_offset)++; (*trav_offset)++;
// function id starts from 1 (POWER) // 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) if (function_id > AC_FUNCTION_MAX - 1)
{ {
// ignore unsupported function ID // 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) if (TRUE == valid_function_id)
{ {
mode_seg[function_id].seg_len = seg_len - 1; mode_seg[function_id].seg_len = (UINT8)(seg_len - 1);
mode_seg[function_id].segment = (UINT8 *) irda_malloc(seg_len - 1); mode_seg[function_id].segment = (UINT8 *) irda_malloc((size_t)(seg_len - 1));
if (NULL == mode_seg[function_id].segment) if (NULL == mode_seg[function_id].segment)
{ {
return IR_DECODE_FAILED; 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; *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 // seg_index in TAG only refers to functional count
for (seg_index = AC_FUNCTION_POWER; seg_index < AC_FUNCTION_MAX; seg_index++) 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) if (fid > AC_FUNCTION_MAX - 1)
{ {
irda_free(hex_data); irda_free(hex_data);
hex_data = NULL; hex_data = NULL;
return IR_DECODE_FAILED; return IR_DECODE_FAILED;
} }
*/ **/
if (trav_offset >= hex_len) 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); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; 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 // count how many swing types are there
si->type = SWING_TYPE_NORMAL; si->type = SWING_TYPE_NORMAL;
si->mode_count = (tag->len + 1) >> 1; si->mode_count = (UINT8)((tag->len + 1) >> 1);
return IR_DECODE_SUCCEEDED; 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 // parse hex data to mode1 data structure
sc->len = (UINT8)hex_len; 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 // per each function takes just 1 byte of length
sc->solo_func_count = hex_data[0]; 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); irda_free(hex_data);
hex_data = NULL;
return IR_DECODE_SUCCEEDED; return IR_DECODE_SUCCEEDED;
} }

4
src/ir_decoder/src/ir_test_main.c
View File

@@ -11,10 +11,6 @@ Revision log:
#include <stdio.h> #include <stdio.h>
#if !defined WIN32
#include <unistd.h>
#endif
#include "../include/ir_defs.h" #include "../include/ir_defs.h"
#include "../include/ir_decode.h" #include "../include/ir_decode.h"

2
src/ir_decoder/src/ir_tv_control.c
View File

@@ -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 bit_num = data->bits / valid_bits;
UINT8 valid_value = 0; 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) if (data->lsb == IRDA_LSB)
{ {

14
src/ir_decoder/src/ir_utils.c
View File

@@ -15,11 +15,11 @@ UINT8 char_to_hex(char chr)
{ {
UINT8 value = 0; UINT8 value = 0;
if (chr >= '0' && chr <= '9') if (chr >= '0' && chr <= '9')
value = chr - '0'; value = (UINT8)(chr - '0');
if (chr >= 'a' && chr <= 'f') if (chr >= 'a' && chr <= 'f')
value = chr - 'a' + 10; value = (UINT8)(chr - 'a' + 10);
if (chr >= 'A' && chr <= 'F') if (chr >= 'A' && chr <= 'F')
value = chr - 'A' + 10; value = (UINT8)(chr - 'A' + 10);
return value; 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) if (half_byte >= 10 && half_byte < 16)
{ {
return (half_byte - 10 + 0x41); return (char)(half_byte - 10 + 0x41);
} }
else 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; return;
} }
hi_num = (src >> 4) & 0x0F; hi_num = (UINT8)((src >> 4) & 0x0F);
lo_num = src & 0x0F; lo_num = (UINT8)(src & 0x0F);
dest[0] = hex_half_byte_to_single_char(1, hi_num); dest[0] = hex_half_byte_to_single_char(1, hi_num);
dest[1] = hex_half_byte_to_single_char(1, lo_num); dest[1] = hex_half_byte_to_single_char(1, lo_num);