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"
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
}

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

@@ -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)
{

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

@@ -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;
}
}

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

@@ -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);
}

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"
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;
}

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)
{
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;
}

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

@@ -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"

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 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)
{

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

@@ -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);