diff --git a/src/ir_decoder/include/ir_decode.h b/src/ir_decoder/include/ir_decode.h index e72c47a..b464060 100644 --- a/src/ir_decoder/include/ir_decode.h +++ b/src/ir_decoder/include/ir_decode.h @@ -513,7 +513,7 @@ INT8 ir_tv_lib_open(UINT8 *binary, UINT16 binary_length); * * return: IR_DECODE_SUCCEEDED / IR_DECODE_FAILED */ -extern INT8 ir_tv_lib_parse(UINT8 irda_hex_encode); +extern INT8 ir_tv_lib_parse(UINT8 ir_hex_encode); /* * function ir_tv_lib_control @@ -587,7 +587,7 @@ extern INT8 get_supported_wind_direction(UINT8* supported_wind_direction); // private extern function #if (defined BOARD_PC || defined BOARD_PC_DLL) -extern void irda_lib_free_inner_buffer(); +extern void ir_lib_free_inner_buffer(); #endif ///////////////////////////////////////////////// Utils End ///////////////////////////////////////////////// diff --git a/src/ir_decoder/include/ir_defs.h b/src/ir_decoder/include/ir_defs.h index c1d006f..01051a3 100644 --- a/src/ir_decoder/include/ir_defs.h +++ b/src/ir_decoder/include/ir_defs.h @@ -19,7 +19,7 @@ extern "C" #if defined BOARD_ANDROID #include -#define LOG_TAG "irda_decode" +#define LOG_TAG "ir_decode" #endif #define TRUE 1 @@ -33,12 +33,12 @@ typedef signed int INT; typedef unsigned int UINT; typedef int BOOL; -#define irda_malloc(A) malloc(A) -#define irda_free(A) free(A) -#define irda_memcpy(A, B, C) memcpy(A, B, C) -#define irda_memset(A, B, C) memset(A, B, C) -#define irda_strlen(A) strlen(A) -#define IR_PRINTF printf +#define ir_malloc(A) malloc(A) +#define ir_free(A) free(A) +#define ir_memcpy(A, B, C) memcpy(A, B, C) +#define ir_memset(A, B, C) memset(A, B, C) +#define ir_strlen(A) strlen(A) +#define ir_printf printf #define USER_DATA_SIZE 2048 #ifdef __cplusplus diff --git a/src/ir_decoder/include/ir_tv_control.h b/src/ir_decoder/include/ir_tv_control.h index 1367229..6eb0140 100644 --- a/src/ir_decoder/include/ir_tv_control.h +++ b/src/ir_decoder/include/ir_tv_control.h @@ -40,7 +40,7 @@ enum /* * global type definitions */ -typedef enum irda_flags +typedef enum ir_flags { IRDA_BOOT = 0, IRDA_STOP, @@ -63,25 +63,25 @@ typedef enum irda_flags IRDA_E, IRDA_F, IRDA_MAX = 20, -} irda_flags_t; +} ir_flags_t; -typedef struct irda_data +typedef struct ir_data { UINT8 bits; UINT8 lsb; UINT8 mode; UINT8 index; -} irda_data_t; +} ir_data_t; #if !defined BOARD_51 #pragma pack(1) #endif -typedef struct irda_cycles +typedef struct ir_cycles { UINT8 flag; UINT16 mask; UINT16 space; -} irda_cycles_t; +} ir_cycles_t; #if !defined BOARD_51 #pragma pack() #endif @@ -191,11 +191,11 @@ typedef enum cm_key_value CM_KEY_MAX, } cm_key_value_t; -typedef struct irda_data_tv +typedef struct ir_data_tv { char magic[4]; UINT8 per_keycode_bytes; -} irda_data_tv_t; +} ir_data_tv_t; extern INT8 tv_lib_open(UINT8* binary, UINT16 binary_length); diff --git a/src/ir_decoder/src/ir_ac_apply.c b/src/ir_decoder/src/ir_ac_apply.c index 54793ab..b5a7a25 100644 --- a/src/ir_decoder/src/ir_ac_apply.c +++ b/src/ir_decoder/src/ir_ac_apply.c @@ -371,9 +371,9 @@ static INT8 apply_checksum_byte(UINT8 *ac_code, tag_checksum_data cs, BOOL inver // apply checksum ac_code[cs.checksum_byte_pos] = checksum; - IR_PRINTF("checksum value = %02X\n", checksum); - IR_PRINTF("checksum byte pos = %d\n", cs.checksum_byte_pos); - IR_PRINTF("\n"); + ir_printf("checksum value = %02X\n", checksum); + ir_printf("checksum byte pos = %d\n", cs.checksum_byte_pos); + ir_printf("\n"); return IR_DECODE_SUCCEEDED; } @@ -403,9 +403,9 @@ static INT8 apply_checksum_halfbyte(UINT8 *ac_code, tag_checksum_data cs, BOOL i // apply checksum ac_code[cs.checksum_byte_pos] = checksum; - IR_PRINTF("checksum value = %02X\n", checksum & 0x0F); - IR_PRINTF("checksum byte pos = %d\n", cs.checksum_byte_pos); - IR_PRINTF("\n"); + ir_printf("checksum value = %02X\n", checksum & 0x0F); + ir_printf("checksum byte pos = %d\n", cs.checksum_byte_pos); + ir_printf("\n"); return IR_DECODE_SUCCEEDED; } @@ -458,8 +458,8 @@ static INT8 apply_checksum_spec_byte(UINT8 *ac_code, tag_checksum_data cs, BOOL ac_code[apply_byte_pos] = (ac_code[apply_byte_pos] & 0xF0) | (checksum & 0x0F); } - IR_PRINTF("checksum value = %02X\n", checksum & 0x0F); - IR_PRINTF("checksum byte pos = %d\n", apply_byte_pos); + ir_printf("checksum value = %02X\n", checksum & 0x0F); + ir_printf("checksum byte pos = %d\n", apply_byte_pos); return IR_DECODE_SUCCEEDED; } @@ -503,8 +503,8 @@ static INT8 apply_checksum_spec_byte_onebyte(UINT8 *ac_code, tag_checksum_data c apply_byte_pos = cs.checksum_byte_pos >> 1; ac_code[apply_byte_pos] = checksum; - IR_PRINTF("checksum value = %02X\n", checksum); - IR_PRINTF("checksum byte pos = %d\n", apply_byte_pos); + ir_printf("checksum value = %02X\n", checksum); + ir_printf("checksum byte pos = %d\n", apply_byte_pos); return IR_DECODE_SUCCEEDED; } @@ -584,14 +584,14 @@ INT8 apply_checksum(struct ac_protocol *protocol) } // have some debug - IR_PRINTF("\napply checksum :\n"); - IR_PRINTF("checksum num = %d\n", protocol->checksum.count); + ir_printf("\napply checksum :\n"); + ir_printf("checksum num = %d\n", protocol->checksum.count); for(i = 0; i < protocol->checksum.count; i++) { // have some debug - IR_PRINTF("num : %d\n", i + 1); - IR_PRINTF("checksum type = %02X\n", protocol->checksum.checksum_data[i].type); + ir_printf("num : %d\n", i + 1); + ir_printf("checksum type = %02X\n", protocol->checksum.checksum_data[i].type); switch (protocol->checksum.checksum_data[i].type) { diff --git a/src/ir_decoder/src/ir_ac_binary_parse.c b/src/ir_decoder/src/ir_ac_binary_parse.c index 2c4ee44..8bbb16e 100644 --- a/src/ir_decoder/src/ir_ac_binary_parse.c +++ b/src/ir_decoder/src/ir_ac_binary_parse.c @@ -40,7 +40,7 @@ INT8 binary_parse_offset() tag_head_offset = (UINT16)((tag_count << 1) + 1); - tags = (t_tag_head *) irda_malloc(tag_count * sizeof(t_tag_head)); + tags = (t_tag_head *) ir_malloc(tag_count * sizeof(t_tag_head)); if (NULL == tags) { return IR_DECODE_FAILED; @@ -103,7 +103,7 @@ void binary_tags_info() { continue; } - IR_PRINTF("tag(%d).len = %d\n", tags[i].tag, tags[i].len); + ir_printf("tag(%d).len = %d\n", tags[i].tag, tags[i].len); } #endif } diff --git a/src/ir_decoder/src/ir_ac_build_frame.c b/src/ir_decoder/src/ir_ac_build_frame.c index 3e9bf62..f605537 100644 --- a/src/ir_decoder/src/ir_ac_build_frame.c +++ b/src/ir_decoder/src/ir_ac_build_frame.c @@ -115,13 +115,13 @@ UINT16 create_ir_frame() if (irdata[i] & mask) { - //IR_PRINTF("%d,%d,", context->one.low, context->one.high); + //ir_printf("%d,%d,", context->one.low, context->one.high); context->time[context->code_cnt++] = context->one.low; context->time[context->code_cnt++] = context->one.high; } else { - //IR_PRINTF("%d,%d,", context->zero.low, context->zero.high); + //ir_printf("%d,%d,", context->zero.low, context->zero.high); context->time[context->code_cnt++] = context->zero.low; context->time[context->code_cnt++] = context->zero.high; } diff --git a/src/ir_decoder/src/ir_ac_control.c b/src/ir_decoder/src/ir_ac_control.c index c132542..7bf5a68 100644 --- a/src/ir_decoder/src/ir_ac_control.c +++ b/src/ir_decoder/src/ir_ac_control.c @@ -30,7 +30,7 @@ static INT8 ir_context_init(); static INT8 ir_context_init() { - irda_memset(context, 0, sizeof(protocol)); + ir_memset(context, 0, sizeof(protocol)); return IR_DECODE_SUCCEEDED; } @@ -62,9 +62,9 @@ INT8 ir_ac_lib_parse() { context->n_mode[i].enable = TRUE; context->n_mode[i].allspeed = FALSE; context->n_mode[i].alltemp = FALSE; - irda_memset(context->n_mode[i].speed, 0x00, AC_WS_MAX); + ir_memset(context->n_mode[i].speed, 0x00, AC_WS_MAX); context->n_mode[i].speed_cnt = 0; - irda_memset(context->n_mode[i].temp, 0x00, AC_TEMP_MAX); + ir_memset(context->n_mode[i].temp, 0x00, AC_TEMP_MAX); context->n_mode[i].temp_cnt = 0; } @@ -92,12 +92,12 @@ INT8 ir_ac_lib_parse() { context->swing1.count = context->si.mode_count; context->swing1.len = (UINT8) tags[i].len >> 1; swing_space_size = sizeof(tag_comp) * context->si.mode_count; - context->swing1.comp_data = (tag_comp *) irda_malloc(swing_space_size); + context->swing1.comp_data = (tag_comp *) ir_malloc(swing_space_size); if (NULL == context->swing1.comp_data) { return IR_DECODE_FAILED; } - irda_memset(context->swing1.comp_data, 0x00, swing_space_size); + ir_memset(context->swing1.comp_data, 0x00, swing_space_size); if (IR_DECODE_FAILED == parse_common_ac_parameter(&tags[i], context->swing1.comp_data, context->si.mode_count, @@ -108,11 +108,11 @@ INT8 ir_ac_lib_parse() { context->swing2.count = context->si.mode_count; context->swing2.len = (UINT8) tags[i].len >> 1; swing_space_size = sizeof(tag_comp) * context->si.mode_count; - context->swing2.comp_data = (tag_comp *) irda_malloc(swing_space_size); + context->swing2.comp_data = (tag_comp *) ir_malloc(swing_space_size); if (NULL == context->swing2.comp_data) { return IR_DECODE_FAILED; } - irda_memset(context->swing2.comp_data, 0x00, swing_space_size); + ir_memset(context->swing2.comp_data, 0x00, swing_space_size); if (IR_DECODE_FAILED == parse_common_ac_parameter(&tags[i], context->swing2.comp_data, context->si.mode_count, @@ -124,7 +124,7 @@ INT8 ir_ac_lib_parse() { if (tags[i].tag == TAG_AC_DEFAULT_CODE) // default code TAG { - context->default_code.data = (UINT8 *) irda_malloc(((size_t)tags[i].len - 2) >> 1); + context->default_code.data = (UINT8 *) ir_malloc(((size_t)tags[i].len - 2) >> 1); if (NULL == context->default_code.data) { return IR_DECODE_FAILED; } @@ -192,7 +192,7 @@ INT8 ir_ac_lib_parse() { context->solo_function_mark = 1; } else if (tags[i].tag == TAG_AC_FUNCTION_1) { if (IR_DECODE_FAILED == parse_function_1_tag29(&tags[i], &(context->function1))) { - IR_PRINTF("\nfunction code parse error\n"); + ir_printf("\nfunction code parse error\n"); return IR_DECODE_FAILED; } } else if (tags[i].tag == TAG_AC_FUNCTION_2) { @@ -267,18 +267,18 @@ INT8 ir_ac_lib_parse() { } if (NULL != tags) { - irda_free(tags); + ir_free(tags); tags = NULL; } - ir_hex_code = (UINT8 *) irda_malloc(context->default_code.len); + ir_hex_code = (UINT8 *) ir_malloc(context->default_code.len); if (NULL == ir_hex_code) { // warning: this AC bin contains no default code return IR_DECODE_FAILED; } ir_hex_len = context->default_code.len; - irda_memset(ir_hex_code, 0x00, ir_hex_len); + ir_memset(ir_hex_code, 0x00, ir_hex_len); // pre-calculate solo function status after parse phase if (1 == context->solo_function_mark) { @@ -295,7 +295,7 @@ INT8 ir_ac_lib_parse() { // or make global buffer shared in extreme memory case /* in case of running with test - begin */ #if (defined BOARD_PC || defined BOARD_PC_DLL) - irda_lib_free_inner_buffer(); + ir_lib_free_inner_buffer(); #endif /* in case of running with test - end */ @@ -309,14 +309,14 @@ INT8 free_ac_context() if (ir_hex_code != NULL) { - irda_free(ir_hex_code); + ir_free(ir_hex_code); ir_hex_code = NULL; } ir_hex_len = 0; if (context->default_code.data != NULL) { - irda_free(context->default_code.data); + ir_free(context->default_code.data); context->default_code.data = NULL; context->default_code.len = 0; } @@ -325,7 +325,7 @@ INT8 free_ac_context() { if (context->power1.comp_data[i].segment != NULL) { - irda_free(context->power1.comp_data[i].segment); + ir_free(context->power1.comp_data[i].segment); context->power1.comp_data[i].segment = NULL; context->power1.comp_data[i].seg_len = 0; } @@ -335,13 +335,13 @@ INT8 free_ac_context() { if (context->temp1.comp_data[i].segment != NULL) { - irda_free(context->temp1.comp_data[i].segment); + ir_free(context->temp1.comp_data[i].segment); context->temp1.comp_data[i].segment = NULL; context->temp1.comp_data[i].seg_len = 0; } if (context->temp2.comp_data[i].segment != NULL) { - irda_free(context->temp2.comp_data[i].segment); + ir_free(context->temp2.comp_data[i].segment); context->temp2.comp_data[i].segment = NULL; context->temp2.comp_data[i].seg_len = 0; } @@ -351,13 +351,13 @@ INT8 free_ac_context() { if (context->mode1.comp_data[i].segment != NULL) { - irda_free(context->mode1.comp_data[i].segment); + ir_free(context->mode1.comp_data[i].segment); context->mode1.comp_data[i].segment = NULL; context->mode1.comp_data[i].seg_len = 0; } if (context->mode2.comp_data[i].segment != NULL) { - irda_free(context->mode2.comp_data[i].segment); + ir_free(context->mode2.comp_data[i].segment); context->mode2.comp_data[i].segment = NULL; context->mode2.comp_data[i].seg_len = 0; } @@ -366,13 +366,13 @@ INT8 free_ac_context() { if (context->speed1.comp_data[i].segment != NULL) { - irda_free(context->speed1.comp_data[i].segment); + ir_free(context->speed1.comp_data[i].segment); context->speed1.comp_data[i].segment = NULL; context->speed1.comp_data[i].seg_len = 0; } if (context->speed2.comp_data[i].segment != NULL) { - irda_free(context->speed2.comp_data[i].segment); + ir_free(context->speed2.comp_data[i].segment); context->speed2.comp_data[i].segment = NULL; context->speed2.comp_data[i].seg_len = 0; } @@ -383,14 +383,14 @@ INT8 free_ac_context() if (context->swing1.comp_data != NULL && context->swing1.comp_data[i].segment != NULL) { - irda_free(context->swing1.comp_data[i].segment); + ir_free(context->swing1.comp_data[i].segment); context->swing1.comp_data[i].segment = NULL; context->swing1.comp_data[i].seg_len = 0; } if (context->swing2.comp_data != NULL && context->swing2.comp_data[i].segment != NULL) { - irda_free(context->swing2.comp_data[i].segment); + ir_free(context->swing2.comp_data[i].segment); context->swing2.comp_data[i].segment = NULL; context->swing2.comp_data[i].seg_len = 0; } @@ -400,13 +400,13 @@ INT8 free_ac_context() { if (context->function1.comp_data[i].segment != NULL) { - irda_free(context->function1.comp_data[i].segment); + ir_free(context->function1.comp_data[i].segment); context->function1.comp_data[i].segment = NULL; context->function1.comp_data[i].seg_len = 0; } if (context->function2.comp_data[i].segment != NULL) { - irda_free(context->function2.comp_data[i].segment); + ir_free(context->function2.comp_data[i].segment); context->function2.comp_data[i].segment = NULL; context->function2.comp_data[i].seg_len = 0; } @@ -415,12 +415,12 @@ INT8 free_ac_context() // free composite data for swing1 and swing 2 if(context->swing1.comp_data != NULL) { - irda_free(context->swing1.comp_data); + ir_free(context->swing1.comp_data); context->swing1.comp_data = NULL; } if(context->swing2.comp_data != NULL) { - irda_free(context->swing2.comp_data); + ir_free(context->swing2.comp_data); context->swing2.comp_data = NULL; } @@ -429,14 +429,14 @@ INT8 free_ac_context() if(context->checksum.checksum_data != NULL && context->checksum.checksum_data[i].spec_pos != NULL) { - irda_free(context->checksum.checksum_data[i].spec_pos); + ir_free(context->checksum.checksum_data[i].spec_pos); context->checksum.checksum_data[i].len = 0; context->checksum.checksum_data[i].spec_pos = NULL; } } if(context->checksum.checksum_data != NULL) { - irda_free(context->checksum.checksum_data); + ir_free(context->checksum.checksum_data); context->checksum.checksum_data = NULL; } 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 c349d27..70dc561 100644 --- a/src/ir_decoder/src/ir_ac_parse_forbidden_info.c +++ b/src/ir_decoder/src/ir_ac_parse_forbidden_info.c @@ -27,18 +27,18 @@ INT8 parse_nmode_data_speed(char *pdata, ac_n_mode seq) UINT16 pos = 0; UINT16 cnt = 0, index = 0; - while (index <= irda_strlen(pdata)) + while (index <= ir_strlen(pdata)) { - while ((index != irda_strlen(pdata)) && (*(p++) != ',')) + while ((index != ir_strlen(pdata)) && (*(p++) != ',')) { index++; } - irda_memcpy(buf, pdata + pos, index - pos); + ir_memcpy(buf, pdata + pos, index - pos); pos = (UINT16)(index + 1); index = pos; context->n_mode[seq].speed[cnt++] = (UINT8)atoi(buf); context->n_mode[seq].speed_cnt = (UINT8)cnt; - irda_memset(buf, 0, 16); + ir_memset(buf, 0, 16); } return IR_DECODE_SUCCEEDED; @@ -52,18 +52,18 @@ INT8 parse_nmode_data_temp(char *pdata, ac_n_mode seq) UINT16 pos = 0; UINT16 cnt = 0, index = 0; - while (index <= irda_strlen(pdata)) + while (index <= ir_strlen(pdata)) { - while ((index != irda_strlen(pdata)) && (*(p++) != ',')) + while ((index != ir_strlen(pdata)) && (*(p++) != ',')) { index++; } - irda_memcpy(buf, pdata + pos, index - pos); + ir_memcpy(buf, pdata + pos, index - pos); pos = (UINT16)(index + 1); index = pos; context->n_mode[seq].temp[cnt++] = (UINT8)(atoi(buf) - 16); context->n_mode[seq].temp_cnt = (UINT8)cnt; - irda_memset(buf, 0, 16); + ir_memset(buf, 0, 16); } return IR_DECODE_SUCCEEDED; } @@ -73,7 +73,7 @@ INT8 parse_nmode_pos(char *buf, ac_n_mode index) UINT16 i = 0; char data[64] = {0}; // char start[8] = {0}; - if (irda_strlen(buf) == 1) + if (ir_strlen(buf) == 1) { if (buf[0] == 'S' || buf[0] == 's') { @@ -86,11 +86,11 @@ INT8 parse_nmode_pos(char *buf, ac_n_mode index) return IR_DECODE_SUCCEEDED; } - for (i = 0; i < irda_strlen(buf); i++) + for (i = 0; i < ir_strlen(buf); i++) { if (buf[i] == '&') { - irda_memcpy(data, buf + i + 1, irda_strlen(buf) - i - 1); + ir_memcpy(data, buf + i + 1, ir_strlen(buf) - i - 1); break; } } @@ -129,15 +129,15 @@ INT8 parse_nmode(struct tag_head *tag, ac_n_mode index) { if (tag->pdata[i] == '|') { - irda_memcpy(buf, tag->pdata + preindex, i - preindex); + ir_memcpy(buf, tag->pdata + preindex, i - preindex); preindex = (UINT16)(i + 1); parse_nmode_pos(buf, index); - irda_memset(buf, 0, 64); + ir_memset(buf, 0, 64); } } - irda_memcpy(buf, tag->pdata + preindex, i - preindex); + ir_memcpy(buf, tag->pdata + preindex, i - preindex); parse_nmode_pos(buf, index); - irda_memset(buf, 0, 64); + ir_memset(buf, 0, 64); return IR_DECODE_SUCCEEDED; } 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 a763a43..5310dd8 100644 --- a/src/ir_decoder/src/ir_ac_parse_frame_info.c +++ b/src/ir_decoder/src/ir_ac_parse_frame_info.c @@ -41,11 +41,11 @@ INT8 parse_boot_code(struct tag_head *tag) { index++; } - irda_memcpy(buf, tag->pdata + pos, index - pos); + ir_memcpy(buf, tag->pdata + pos, index - pos); pos = (UINT16)(index + 1); index = pos; context->bootcode.data[cnt++] = (UINT16)(atoi((char *) buf)); - irda_memset(buf, 0, 16); + ir_memset(buf, 0, 16); } context->bootcode.len = cnt; return IR_DECODE_SUCCEEDED; @@ -74,8 +74,8 @@ INT8 parse_zero(struct tag_head *tag) index++; } - irda_memcpy(low, tag->pdata, index); - irda_memcpy(high, tag->pdata + index + 1, (size_t)(tag->len - index - 1)); + ir_memcpy(low, tag->pdata, index); + ir_memcpy(high, tag->pdata + index + 1, (size_t)(tag->len - index - 1)); context->zero.low = (UINT16)(atoi((char *) low)); context->zero.high = (UINT16)(atoi((char *) high)); @@ -104,8 +104,8 @@ INT8 parse_one(struct tag_head *tag) { index++; } - irda_memcpy(low, tag->pdata, index); - irda_memcpy(high, tag->pdata + index + 1, (size_t)(tag->len - index - 1)); + ir_memcpy(low, tag->pdata, index); + ir_memcpy(high, tag->pdata + index + 1, (size_t)(tag->len - index - 1)); context->one.low = (UINT16)(atoi((char *) low)); context->one.high = (UINT16)(atoi((char *) high)); @@ -126,18 +126,18 @@ INT8 parse_delay_code_data(UINT8 *pdata) } p = pdata; - while (index <= irda_strlen((char *) pdata)) + while (index <= ir_strlen((char *) pdata)) { - while ((index != irda_strlen((char *) pdata)) && (*(p++) != ',')) + while ((index != ir_strlen((char *) pdata)) && (*(p++) != ',')) { index++; } - irda_memcpy(buf, pdata + pos, index - pos); + ir_memcpy(buf, pdata + pos, index - pos); pos = (UINT16)(index + 1); index = pos; context->dc[context->dc_cnt].time[cnt++] = (UINT16)(atoi((char *) buf)); context->dc[context->dc_cnt].time_cnt = cnt; - irda_memset(buf, 0, 16); + ir_memset(buf, 0, 16); } return IR_DECODE_SUCCEEDED; @@ -153,12 +153,12 @@ INT8 parse_delay_code_pos(UINT8 *buf) return IR_DECODE_FAILED; } - for (i = 0; i < irda_strlen((char *) buf); i++) + for (i = 0; i < ir_strlen((char *) buf); i++) { if (buf[i] == '&') { - irda_memcpy(start, buf, i); - irda_memcpy(data, buf + i + 1, irda_strlen((char *) buf) - i - 1); + ir_memcpy(start, buf, i); + ir_memcpy(data, buf + i + 1, ir_strlen((char *) buf) - i - 1); break; } } @@ -185,16 +185,16 @@ INT8 parse_delay_code(struct tag_head *tag) { if (tag->pdata[i] == '|') { - irda_memcpy(buf, tag->pdata + preindex, i - preindex); + ir_memcpy(buf, tag->pdata + preindex, i - preindex); preindex = (UINT16)(i + 1); parse_delay_code_pos(buf); - irda_memset(buf, 0, 64); + ir_memset(buf, 0, 64); } } - irda_memcpy(buf, tag->pdata + preindex, i - preindex); + ir_memcpy(buf, tag->pdata + preindex, i - preindex); parse_delay_code_pos(buf); - irda_memset(buf, 0, 64); + ir_memset(buf, 0, 64); return IR_DECODE_SUCCEEDED; } @@ -208,21 +208,21 @@ INT8 parse_frame_len(struct tag_head *tag, UINT16 len) return IR_DECODE_FAILED; } - temp = (UINT8 *)irda_malloc(len + 1); + temp = (UINT8 *)ir_malloc(len + 1); if (NULL == temp) { return IR_DECODE_FAILED; } - irda_memset(temp, 0x00, len + 1); + ir_memset(temp, 0x00, len + 1); - irda_memcpy(temp, tag->pdata, len); + ir_memcpy(temp, tag->pdata, len); temp[len] = '\0'; context->frame_length = (UINT16)(atoi((char *) temp)); - irda_free(temp); + ir_free(temp); return IR_DECODE_SUCCEEDED; } @@ -234,7 +234,7 @@ INT8 parse_endian(struct tag_head *tag) { return IR_DECODE_FAILED; } - irda_memcpy(buf, tag->pdata, tag->len); + ir_memcpy(buf, tag->pdata, tag->len); context->endian = (UINT8)(atoi((char *) buf)); return IR_DECODE_SUCCEEDED; } @@ -247,7 +247,7 @@ INT8 parse_lastbit(struct tag_head *tag) { return IR_DECODE_FAILED; } - irda_memcpy(buf, tag->pdata, tag->len); + ir_memcpy(buf, tag->pdata, tag->len); context->lastbit = (UINT8)(atoi((char *) buf)); return IR_DECODE_SUCCEEDED; } @@ -260,7 +260,7 @@ INT8 parse_repeat_times(struct tag_head *tag) return IR_DECODE_FAILED; } - irda_memcpy(asc_code, tag->pdata, tag->len); + ir_memcpy(asc_code, tag->pdata, tag->len); context->repeat_times = (UINT16)(atoi((char *) asc_code)); @@ -277,12 +277,12 @@ INT8 parse_delay_code_tag48_pos(UINT8 *buf) return IR_DECODE_FAILED; } - for (i = 0; i < irda_strlen((char *) buf); i++) + for (i = 0; i < ir_strlen((char *) buf); i++) { if (buf[i] == '&') { - irda_memcpy(start, buf, i); - irda_memcpy(data, buf + i + 1, irda_strlen((char *) buf) - i - 1); + ir_memcpy(start, buf, i); + ir_memcpy(data, buf + i + 1, ir_strlen((char *) buf) - i - 1); break; } } @@ -309,16 +309,16 @@ INT8 parse_bit_num(struct tag_head *tag) { if (tag->pdata[i] == '|') { - irda_memcpy(buf, tag->pdata + preindex, i - preindex); + ir_memcpy(buf, tag->pdata + preindex, i - preindex); preindex = (UINT16)(i + 1); parse_delay_code_tag48_pos(buf); - irda_memset(buf, 0, 64); + ir_memset(buf, 0, 64); } } - irda_memcpy(buf, tag->pdata + preindex, i - preindex); + ir_memcpy(buf, tag->pdata + preindex, i - preindex); parse_delay_code_tag48_pos(buf); - irda_memset(buf, 0, 64); + ir_memset(buf, 0, 64); for (i = 0; i < context->bitnum_cnt; i++) { diff --git a/src/ir_decoder/src/ir_ac_parse_parameter.c b/src/ir_decoder/src/ir_ac_parse_parameter.c index 5d4ddb7..c5041ec 100644 --- a/src/ir_decoder/src/ir_ac_parse_parameter.c +++ b/src/ir_decoder/src/ir_ac_parse_parameter.c @@ -31,13 +31,13 @@ INT8 parse_comp_data_type_1(UINT8 *data, UINT16 *trav_offset, tag_comp *comp) } comp->seg_len = seg_len; - comp->segment = (UINT8 *) irda_malloc(seg_len); + comp->segment = (UINT8 *) ir_malloc(seg_len); if (NULL == comp->segment) { return IR_DECODE_FAILED; } - irda_memcpy(comp->segment, &data[*trav_offset], seg_len); + ir_memcpy(comp->segment, &data[*trav_offset], seg_len); *trav_offset += seg_len; return IR_DECODE_SUCCEEDED; @@ -57,13 +57,13 @@ INT8 parse_comp_data_type_2(UINT8 *data, UINT16 *trav_offset, tag_comp *comp) } comp->seg_len = seg_len; - comp->segment = (UINT8 *) irda_malloc(seg_len); + comp->segment = (UINT8 *) ir_malloc(seg_len); if (NULL == comp->segment) { return IR_DECODE_FAILED; } - irda_memcpy(comp->segment, &data[*trav_offset], seg_len); + ir_memcpy(comp->segment, &data[*trav_offset], seg_len); *trav_offset += seg_len; return IR_DECODE_SUCCEEDED; @@ -87,7 +87,7 @@ INT8 parse_common_ac_parameter(t_tag_head *tag, tag_comp *comp_data, UINT8 with_ } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { return IR_DECODE_FAILED; @@ -104,7 +104,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -120,7 +120,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -131,7 +131,7 @@ INT8 parse_common_ac_parameter(t_tag_head *tag, tag_comp *comp_data, UINT8 with_ } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -169,7 +169,7 @@ INT8 parse_power_1(struct tag_head *tag, power_1 *power1) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -185,7 +185,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -196,7 +196,7 @@ INT8 parse_power_1(struct tag_head *tag, power_1 *power1) } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -215,7 +215,7 @@ INT8 parse_temp_1(struct tag_head *tag, temp_1 *temp1) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -236,10 +236,10 @@ INT8 parse_temp_1(struct tag_head *tag, temp_1 *temp1) { // 020210 indicates set the 02nd byte to [default] +10, +11, +12, +... temp1->comp_data[seg_index].seg_len = seg_len; - temp1->comp_data[seg_index].segment = (UINT8 *) irda_malloc(seg_len); + temp1->comp_data[seg_index].segment = (UINT8 *) ir_malloc(seg_len); if (NULL == temp1->comp_data[seg_index].segment) { - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -261,7 +261,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -271,7 +271,7 @@ INT8 parse_temp_1(struct tag_head *tag, temp_1 *temp1) } } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -289,7 +289,7 @@ INT8 parse_mode_1(struct tag_head *tag, mode_1 *mode1) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -305,7 +305,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -315,7 +315,7 @@ INT8 parse_mode_1(struct tag_head *tag, mode_1 *mode1) } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -333,7 +333,7 @@ INT8 parse_speed_1(struct tag_head *tag, speed_1 *speed1) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -349,7 +349,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -359,7 +359,7 @@ INT8 parse_speed_1(struct tag_head *tag, speed_1 *speed1) } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -377,7 +377,7 @@ INT8 parse_swing_1(struct tag_head *tag, swing_1 *swing1, UINT16 swing_count) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -389,10 +389,10 @@ INT8 parse_swing_1(struct tag_head *tag, swing_1 *swing1, UINT16 swing_count) // parse hex data to swing1 data structure swing1->count = swing_count; swing1->len = (UINT8)hex_len; - swing1->comp_data = (tag_comp *) irda_malloc(sizeof(tag_comp) * swing_count); + swing1->comp_data = (tag_comp *) ir_malloc(sizeof(tag_comp) * swing_count); if (NULL == swing1->comp_data) { - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -400,7 +400,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -410,7 +410,7 @@ INT8 parse_swing_1(struct tag_head *tag, swing_1 *swing1, UINT16 swing_count) } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -468,12 +468,12 @@ INT8 parse_checksum_spec_half_byte_typed(UINT8 *csdata, tag_checksum_data *check checksum->checksum_plus = csdata[3]; checksum->start_byte_pos = 0; checksum->end_byte_pos = 0; - checksum->spec_pos = (UINT8 *) irda_malloc(spec_pos_size); + checksum->spec_pos = (UINT8 *) ir_malloc(spec_pos_size); if (NULL == checksum->spec_pos) { return IR_DECODE_FAILED; } - irda_memcpy(checksum->spec_pos, &csdata[4], spec_pos_size); + ir_memcpy(checksum->spec_pos, &csdata[4], spec_pos_size); return IR_DECODE_SUCCEEDED; } @@ -493,13 +493,13 @@ INT8 parse_checksum_malloc(struct tag_head *tag, tchecksum *checksum) 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); + checksum->checksum_data = (tag_checksum_data*) ir_malloc(sizeof(tag_checksum_data) * checksum->count); if (NULL == checksum->checksum_data) { return IR_DECODE_FAILED; } - irda_memset(checksum->checksum_data, 0x00, sizeof(tag_checksum_data) * checksum->count); + ir_memset(checksum->checksum_data, 0x00, sizeof(tag_checksum_data) * checksum->count); return IR_DECODE_SUCCEEDED; } @@ -520,7 +520,7 @@ INT8 parse_checksum_data(UINT8 *buf, tag_checksum_data *checksum, UINT8 length) } hex_len = length; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -531,7 +531,7 @@ INT8 parse_checksum_data(UINT8 *buf, tag_checksum_data *checksum, UINT8 length) if (length != hex_data[0] + 1) { - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -543,7 +543,7 @@ INT8 parse_checksum_data(UINT8 *buf, tag_checksum_data *checksum, UINT8 length) case CHECKSUM_TYPE_BYTE_INVERSE: if (IR_DECODE_FAILED == parse_checksum_byte_typed(hex_data, checksum, hex_len)) { - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_FAILED; } break; @@ -551,7 +551,7 @@ INT8 parse_checksum_data(UINT8 *buf, tag_checksum_data *checksum, UINT8 length) case CHECKSUM_TYPE_HALF_BYTE_INVERSE: if (IR_DECODE_FAILED == parse_checksum_half_byte_typed(hex_data, checksum, hex_len)) { - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_FAILED; } break; @@ -561,16 +561,16 @@ INT8 parse_checksum_data(UINT8 *buf, tag_checksum_data *checksum, UINT8 length) case CHECKSUM_TYPE_SPEC_HALF_BYTE_INVERSE_ONE_BYTE: if (IR_DECODE_FAILED == parse_checksum_spec_half_byte_typed(hex_data, checksum, hex_len)) { - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_FAILED; } break; default: - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_FAILED; } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -649,7 +649,7 @@ INT8 parse_function_1(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg) if (function_id > AC_FUNCTION_MAX - 1) { // ignore unsupported function ID - IR_PRINTF("\nunsupported function id : %d\n", function_id); + ir_printf("\nunsupported function id : %d\n", function_id); valid_function_id = FALSE; } @@ -664,7 +664,7 @@ INT8 parse_function_1(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg) if (NULL != mode_seg[function_id].segment) { - irda_free(mode_seg[function_id].segment); + ir_free(mode_seg[function_id].segment); mode_seg[function_id].segment = NULL; } } @@ -675,12 +675,12 @@ INT8 parse_function_1(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg) if (TRUE == valid_function_id) { mode_seg[function_id].seg_len = (UINT8)(seg_len - 1); - mode_seg[function_id].segment = (UINT8 *) irda_malloc((size_t)(seg_len - 1)); + mode_seg[function_id].segment = (UINT8 *) ir_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], (size_t)(seg_len - 1)); + ir_memcpy(mode_seg[function_id].segment, &data[*trav_offset], (size_t)(seg_len - 1)); } *trav_offset += seg_len - 1; @@ -705,7 +705,7 @@ INT8 parse_function_1_tag29(struct tag_head *tag, function_1 *function1) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -738,7 +738,7 @@ INT8 parse_function_1_tag29(struct tag_head *tag, function_1 *function1) } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -762,7 +762,7 @@ INT8 parse_temp_2(struct tag_head *tag, temp_2 *temp2) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -783,10 +783,10 @@ INT8 parse_temp_2(struct tag_head *tag, temp_2 *temp2) { // 020210 indicates set the 02nd byte to [default] +10, +11, +12, +... temp2->comp_data[seg_index].seg_len = seg_len; - temp2->comp_data[seg_index].segment = (UINT8 *) irda_malloc(seg_len); + temp2->comp_data[seg_index].segment = (UINT8 *) ir_malloc(seg_len); if (NULL == temp2->comp_data[seg_index].segment) { - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_FAILED; } for (i = 2; i < seg_len; i += 3) @@ -808,7 +808,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -818,7 +818,7 @@ INT8 parse_temp_2(struct tag_head *tag, temp_2 *temp2) } } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -841,7 +841,7 @@ INT8 parse_mode_2(struct tag_head *tag, mode_2 *mode2) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -857,7 +857,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -867,7 +867,7 @@ INT8 parse_mode_2(struct tag_head *tag, mode_2 *mode2) } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -890,7 +890,7 @@ INT8 parse_speed_2(struct tag_head *tag, speed_2 *speed2) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -906,7 +906,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -916,7 +916,7 @@ INT8 parse_speed_2(struct tag_head *tag, speed_2 *speed2) } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -939,7 +939,7 @@ INT8 parse_swing_2(struct tag_head *tag, swing_2 *swing2, UINT16 swing_count) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -951,10 +951,10 @@ INT8 parse_swing_2(struct tag_head *tag, swing_2 *swing2, UINT16 swing_count) // parse hex data to swing2 data structure swing2->count = swing_count; swing2->len = (UINT8)hex_len; - swing2->comp_data = (tag_comp *) irda_malloc(sizeof(tag_comp) * swing_count); + swing2->comp_data = (tag_comp *) ir_malloc(sizeof(tag_comp) * swing_count); if (NULL == swing2->comp_data) { - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -962,7 +962,7 @@ 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); + ir_free(hex_data); return IR_DECODE_FAILED; } @@ -972,7 +972,7 @@ INT8 parse_swing_2(struct tag_head *tag, swing_2 *swing2, UINT16 swing_count) } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -1005,7 +1005,7 @@ INT8 parse_function_2(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg) if (function_id > AC_FUNCTION_MAX - 1) { // ignore unsupported function ID - IR_PRINTF("\nunsupported function id : %d\n", function_id); + ir_printf("\nunsupported function id : %d\n", function_id); valid_function_id = FALSE; } @@ -1020,7 +1020,7 @@ INT8 parse_function_2(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg) if (NULL != mode_seg[function_id].segment) { - irda_free(mode_seg[function_id].segment); + ir_free(mode_seg[function_id].segment); mode_seg[function_id].segment = NULL; } } @@ -1031,14 +1031,14 @@ INT8 parse_function_2(UINT8 *data, UINT16 *trav_offset, tag_comp *mode_seg) if (TRUE == valid_function_id) { mode_seg[function_id].seg_len = (UINT8)(seg_len - 1); - mode_seg[function_id].segment = (UINT8 *) irda_malloc((size_t)(seg_len - 1)); + mode_seg[function_id].segment = (UINT8 *) ir_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], (size_t)(seg_len - 1)); + ir_memcpy(mode_seg[function_id].segment, &data[*trav_offset], (size_t)(seg_len - 1)); } *trav_offset += seg_len - 1; @@ -1063,7 +1063,7 @@ INT8 parse_function_2_tag34(struct tag_head *tag, function_2 *function2) } hex_len = tag->len >> 1; - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -1096,7 +1096,7 @@ INT8 parse_function_2_tag34(struct tag_head *tag, function_2 *function2) } } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } @@ -1165,11 +1165,11 @@ INT8 parse_solo_code(struct tag_head *tag, solo_code *sc) if(hex_len > AC_FUNCTION_MAX) { - IR_PRINTF("\nsolo function code exceeded!!\n"); + ir_printf("\nsolo function code exceeded!!\n"); return IR_DECODE_FAILED; } - hex_data = (UINT8 *) irda_malloc(hex_len); + hex_data = (UINT8 *) ir_malloc(hex_len); if (NULL == hex_data) { @@ -1188,6 +1188,6 @@ INT8 parse_solo_code(struct tag_head *tag, solo_code *sc) sc->solo_function_codes[i - 1] = hex_data[i]; } - irda_free(hex_data); + ir_free(hex_data); return IR_DECODE_SUCCEEDED; } \ No newline at end of file diff --git a/src/ir_decoder/src/ir_decode.c b/src/ir_decoder/src/ir_decode.c index c3d9318..87227d5 100644 --- a/src/ir_decoder/src/ir_decode.c +++ b/src/ir_decoder/src/ir_decode.c @@ -50,7 +50,7 @@ lp_apply_ac_parameter apply_table[AC_APPLY_MAX] = }; #if (defined BOARD_PC || defined BOARD_PC_DLL) -void irda_lib_free_inner_buffer(); +void ir_lib_free_inner_buffer(); #endif @@ -67,17 +67,17 @@ INT8 ir_ac_file_open(const char *file_name) #endif if (NULL == stream) { - IR_PRINTF("\nfile open failed\n"); + ir_printf("\nfile open failed\n"); return IR_DECODE_FAILED; } fseek(stream, 0, SEEK_END); binary_length = (size_t) ftell(stream); - binary_content = (UINT8*) irda_malloc(binary_length); + binary_content = (UINT8*) ir_malloc(binary_length); if (NULL == binary_content) { - IR_PRINTF("\nfailed to alloc memory for binary\n"); + ir_printf("\nfailed to alloc memory for binary\n"); fclose(stream); return IR_DECODE_FAILED; } @@ -88,7 +88,7 @@ INT8 ir_ac_file_open(const char *file_name) if (ret <= 0) { fclose(stream); - irda_free(binary_content); + ir_free(binary_content); binary_length = 0; return IR_DECODE_FAILED; } @@ -97,7 +97,7 @@ INT8 ir_ac_file_open(const char *file_name) if (IR_DECODE_FAILED == ir_ac_lib_open(binary_content, (UINT16) binary_length)) { - irda_free(binary_content); + ir_free(binary_content); binary_length = 0; return IR_DECODE_FAILED; } @@ -125,7 +125,7 @@ UINT16 ir_ac_lib_control(remote_ac_status_t ac_status, UINT16 *user_data, UINT8 if (0 == context->default_code.len) { - IR_PRINTF("\ndefault code is empty\n"); + ir_printf("\ndefault code is empty\n"); return 0; } @@ -135,7 +135,7 @@ UINT16 ir_ac_lib_control(remote_ac_status_t ac_status, UINT16 *user_data, UINT8 context->time = user_data; // generate temp buffer for frame calculation - irda_memcpy(ir_hex_code, context->default_code.data, context->default_code.len); + ir_memcpy(ir_hex_code, context->default_code.data, context->default_code.len); #if defined USE_APPLY_TABLE if(ac_status.acPower != AC_POWER_OFF) @@ -218,9 +218,9 @@ UINT16 ir_ac_lib_control(remote_ac_status_t ac_status, UINT16 *user_data, UINT8 #if defined BOARD_PC for (i = 0; i < context->code_cnt; i++) { - IR_PRINTF("%d,", context->time[i]); + ir_printf("%d,", context->time[i]); } - IR_PRINTF("\n"); + ir_printf("\n"); #endif return time_length; @@ -231,7 +231,7 @@ void ir_ac_lib_close() // free context if (NULL != tags) { - irda_free(tags); + ir_free(tags); tags = NULL; } free_ac_context(); @@ -398,17 +398,17 @@ INT8 ir_tv_file_open(const char *file_name) if (stream == NULL) { - IR_PRINTF("\nfile open failed\n"); + ir_printf("\nfile open failed\n"); return IR_DECODE_FAILED; } fseek(stream, 0, SEEK_END); binary_length = (size_t)ftell(stream); - binary_content = (UINT8*) irda_malloc(binary_length); + binary_content = (UINT8*) ir_malloc(binary_length); if (NULL == binary_content) { - IR_PRINTF("\nfailed to alloc memory for binary\n"); + ir_printf("\nfailed to alloc memory for binary\n"); fclose(stream); return IR_DECODE_FAILED; } @@ -418,7 +418,7 @@ INT8 ir_tv_file_open(const char *file_name) if (ret <= 0) { fclose(stream); - irda_free(binary_content); + ir_free(binary_content); binary_length = 0; return IR_DECODE_FAILED; } @@ -427,7 +427,7 @@ INT8 ir_tv_file_open(const char *file_name) if (IR_DECODE_FAILED == ir_tv_lib_open(binary_content, (UINT16) binary_length)) { - irda_free(binary_content); + ir_free(binary_content); binary_length = 0; return IR_DECODE_FAILED; } @@ -440,11 +440,11 @@ INT8 ir_tv_lib_open(UINT8 *binary, UINT16 binary_length) return tv_lib_open(binary, binary_length); } -INT8 ir_tv_lib_parse(UINT8 irda_hex_encode) +INT8 ir_tv_lib_parse(UINT8 ir_hex_encode) { - if (FALSE == tv_lib_parse(irda_hex_encode)) + if (FALSE == tv_lib_parse(ir_hex_encode)) { - IR_PRINTF("parse irda binary failed\n"); + ir_printf("parse irda binary failed\n"); memset(tv_bin, 0x00, EXPECTED_MEM_SIZE); return IR_DECODE_FAILED; } @@ -456,28 +456,28 @@ UINT16 ir_tv_lib_control(UINT8 key, UINT16 *l_user_data) #if defined BOARD_PC UINT16 print_index = 0; #endif - UINT16 irda_code_length = 0; + UINT16 ir_code_length = 0; memset(l_user_data, 0x00, USER_DATA_SIZE); - irda_code_length = tv_lib_control(key, l_user_data); + ir_code_length = tv_lib_control(key, l_user_data); #if defined BOARD_PC // have some debug - IR_PRINTF("=============================\n"); - IR_PRINTF("length of IRDA code = %d\n", irda_code_length); - for(print_index = 0; print_index < irda_code_length; print_index++) + ir_printf("=============================\n"); + ir_printf("length of IRDA code = %d\n", ir_code_length); + for(print_index = 0; print_index < ir_code_length; print_index++) { - IR_PRINTF("%d ", l_user_data[print_index]); + ir_printf("%d ", l_user_data[print_index]); } - IR_PRINTF("\n=============================\n\n"); + ir_printf("\n=============================\n\n"); #endif - return irda_code_length; + return ir_code_length; } INT8 ir_tv_lib_close() { #if (defined BOARD_PC || defined BOARD_PC_DLL) - irda_lib_free_inner_buffer(); + ir_lib_free_inner_buffer(); #endif return IR_DECODE_SUCCEEDED; } @@ -485,10 +485,10 @@ INT8 ir_tv_lib_close() #if (defined BOARD_PC || defined BOARD_PC_DLL) -void irda_lib_free_inner_buffer() +void ir_lib_free_inner_buffer() { if (NULL != binary_content) { - irda_free(binary_content); + ir_free(binary_content); binary_content = NULL; } } diff --git a/src/ir_decoder/src/ir_test_main.c b/src/ir_decoder/src/ir_test_main.c index b697958..bbbd30d 100644 --- a/src/ir_decoder/src/ir_test_main.c +++ b/src/ir_decoder/src/ir_test_main.c @@ -57,7 +57,7 @@ INT8 decode_as_ac(char* file_name) if (IR_DECODE_FAILED == ir_ac_lib_parse()) { - IR_PRINTF("\nac lib parse failed\n"); + ir_printf("\nac lib parse failed\n"); ir_ac_lib_close(); return IR_DECODE_FAILED; } @@ -113,7 +113,7 @@ INT8 decode_as_ac(char* file_name) case '3': if (IR_DECODE_SUCCEEDED == get_supported_mode(&supported_mode)) { - IR_PRINTF("\nsupported mode = %02X\n", supported_mode); + ir_printf("\nsupported mode = %02X\n", supported_mode); } need_control = FALSE; break; @@ -121,14 +121,14 @@ INT8 decode_as_ac(char* file_name) case '4': if (IR_DECODE_SUCCEEDED == get_supported_swing(ac_status.acMode, &supported_swing)) { - IR_PRINTF("\nsupported swing in %d = %02X\n", ac_status.acMode, supported_swing); + ir_printf("\nsupported swing in %d = %02X\n", ac_status.acMode, supported_swing); } need_control = FALSE; break; case '5': if (IR_DECODE_SUCCEEDED == get_supported_wind_speed(ac_status.acMode, &supported_speed)) { - IR_PRINTF("\nsupported wind speed in %d = %02X\n", ac_status.acMode, supported_speed); + ir_printf("\nsupported wind speed in %d = %02X\n", ac_status.acMode, supported_speed); } need_control = FALSE; break; @@ -136,7 +136,7 @@ INT8 decode_as_ac(char* file_name) case '6': if (IR_DECODE_SUCCEEDED == get_temperature_range(ac_status.acMode, &min_temperature, &max_temperature)) { - IR_PRINTF("\nsupported temperature range in mode %d = %d, %d\n", + ir_printf("\nsupported temperature range in mode %d = %d, %d\n", ac_status.acMode, min_temperature, max_temperature); } need_control = FALSE; @@ -145,7 +145,7 @@ INT8 decode_as_ac(char* file_name) case '7': if (IR_DECODE_SUCCEEDED == get_supported_wind_direction(&supported_wind_direction)) { - IR_PRINTF("\nsupported wind direction = %02X\n", supported_wind_direction); + ir_printf("\nsupported wind direction = %02X\n", supported_wind_direction); } need_control = FALSE; break; @@ -157,7 +157,7 @@ INT8 decode_as_ac(char* file_name) if(TRUE == op_match && TRUE == need_control) { - IR_PRINTF("switch AC to power = %d, mode = %d, temp = %d, speed = %d, swing = %d\n", + ir_printf("switch AC to power = %d, mode = %d, temp = %d, speed = %d, swing = %d\n", ac_status.acPower, ac_status.acMode, ac_status.acTemp, @@ -174,7 +174,7 @@ INT8 decode_as_ac(char* file_name) return IR_DECODE_SUCCEEDED; } -INT8 decode_as_tv(char *file_name, UINT8 irda_hex_encode) +INT8 decode_as_tv(char *file_name, UINT8 ir_hex_encode) { // keyboard input int in_char = 0; @@ -185,7 +185,7 @@ INT8 decode_as_tv(char *file_name, UINT8 irda_hex_encode) return IR_DECODE_FAILED; } - if (IR_DECODE_FAILED == ir_tv_lib_parse(irda_hex_encode)) + if (IR_DECODE_FAILED == ir_tv_lib_parse(ir_hex_encode)) { return IR_DECODE_FAILED; } @@ -218,32 +218,32 @@ INT8 decode_as_tv(char *file_name, UINT8 irda_hex_encode) int main(int argc, char *argv[]) { char function = '0'; - UINT8 irda_hex_encode = 0; + UINT8 ir_hex_encode = 0; if (4 != argc) { - IR_PRINTF("number of args error !\n"); + ir_printf("number of args error !\n"); return -1; } function = argv[1][0]; - irda_hex_encode = (UINT8)(argv[3][0] - '0'); - IR_PRINTF("decode functionality = %c\n", function); + ir_hex_encode = (UINT8)(argv[3][0] - '0'); + ir_printf("decode functionality = %c\n", function); switch (function) { case '0': - IR_PRINTF("decode binary file as AC\n"); + ir_printf("decode binary file as AC\n"); decode_as_ac(argv[2]); break; case '1': - IR_PRINTF("decode binary file as TV : %d\n", irda_hex_encode); - decode_as_tv(argv[2], irda_hex_encode); + ir_printf("decode binary file as TV : %d\n", ir_hex_encode); + decode_as_tv(argv[2], ir_hex_encode); break; default: - IR_PRINTF("decode functionality error !\n"); + ir_printf("decode functionality error !\n"); break; } } \ No newline at end of file diff --git a/src/ir_decoder/src/ir_tv_control.c b/src/ir_decoder/src/ir_tv_control.c index 41c9065..720ab88 100644 --- a/src/ir_decoder/src/ir_tv_control.c +++ b/src/ir_decoder/src/ir_tv_control.c @@ -21,32 +21,32 @@ struct buffer UINT8 *data; UINT16 len; UINT16 offset; -} irda_file; +} ir_file; -static struct buffer *pbuffer = &irda_file; +static struct buffer *pbuffer = &ir_file; //static UINT8 *prot_name = NULL; static UINT8 *prot_cycles_num = NULL; -static irda_cycles_t *prot_cycles_data[IRDA_MAX]; +static ir_cycles_t *prot_cycles_data[IRDA_MAX]; static UINT8 prot_items_cnt = 0; -static irda_data_t *prot_items_data = NULL; -static irda_data_tv_t *remote_p; +static ir_data_t *prot_items_data = NULL; +static ir_data_tv_t *remote_p; static UINT8 *remote_pdata = NULL; static UINT16 time_index = 0; -static UINT8 irda_level = IRDA_LEVEL_LOW; -static UINT8 irda_toggle_bit = FALSE; -static UINT8 irda_decode_flag = IRDA_DECODE_1_BIT; +static UINT8 ir_level = IRDA_LEVEL_LOW; +static UINT8 ir_toggle_bit = FALSE; +static UINT8 ir_decode_flag = IRDA_DECODE_1_BIT; static UINT8 cycles_num_size = 0; -static BOOL get_irda_protocol(UINT8 encode_type); -static BOOL get_irda_keymap(void); -static void print_irda_time(irda_data_t *data, UINT8 keyindex, UINT16 *irda_time); -static void process_decode_number(UINT8 keycode, irda_data_t *data, UINT8 valid_bits, UINT16 *irda_time); -static void convert_to_irda_time(UINT8 value, UINT16 *irda_time); -static void replace_with(irda_cycles_t *pcycles_num, UINT16 *irda_time); +static BOOL get_ir_protocol(UINT8 encode_type); +static BOOL get_ir_keymap(void); +static void print_ir_time(ir_data_t *data, UINT8 keyindex, UINT16 *ir_time); +static void process_decode_number(UINT8 keycode, ir_data_t *data, UINT8 valid_bits, UINT16 *ir_time); +static void convert_to_ir_time(UINT8 value, UINT16 *ir_time); +static void replace_with(ir_cycles_t *pcycles_num, UINT16 *ir_time); INT8 tv_lib_open(UINT8 *binary, UINT16 binary_length) @@ -60,12 +60,12 @@ INT8 tv_lib_open(UINT8 *binary, UINT16 binary_length) BOOL tv_lib_parse(UINT8 encode_type) { - if (FALSE == get_irda_protocol(encode_type)) + if (FALSE == get_ir_protocol(encode_type)) { return FALSE; } - return get_irda_keymap(); + return get_ir_keymap(); } UINT16 tv_lib_control(UINT8 key, UINT16 *user_data) @@ -73,24 +73,24 @@ UINT16 tv_lib_control(UINT8 key, UINT16 *user_data) UINT16 i = 0; time_index = 0; - irda_level = IRDA_LEVEL_LOW; + ir_level = IRDA_LEVEL_LOW; for (i = 0; i < prot_items_cnt; i++) { - print_irda_time(&prot_items_data[i], key, user_data); + print_ir_time(&prot_items_data[i], key, user_data); } // next flip if (2 == prot_cycles_num[IRDA_FLIP]) { - irda_toggle_bit = (irda_toggle_bit == FALSE) ? TRUE : FALSE; + ir_toggle_bit = (ir_toggle_bit == FALSE) ? TRUE : FALSE; } return time_index; } -static BOOL get_irda_protocol(UINT8 encode_type) +static BOOL get_ir_protocol(UINT8 encode_type) { UINT8 i = 0; UINT8 name_size = 20; @@ -115,17 +115,17 @@ static BOOL get_irda_protocol(UINT8 encode_type) cycles_num_size = 8; /* "BOOT", "STOP", "SEP", "ONE", "ZERO", "FLIP", "TWO", "THREE" */ if (prot_cycles_num[IRDA_TWO] == 0 && prot_cycles_num[IRDA_THREE] == 0) { - irda_decode_flag = IRDA_DECODE_1_BIT; + ir_decode_flag = IRDA_DECODE_1_BIT; } else { - irda_decode_flag = IRDA_DECODE_2_BITS; + ir_decode_flag = IRDA_DECODE_2_BITS; } } else if (encode_type == 1) { cycles_num_size = IRDA_MAX; - irda_decode_flag = IRDA_DECODE_4_BITS; + ir_decode_flag = IRDA_DECODE_4_BITS; } else { @@ -139,7 +139,7 @@ static BOOL get_irda_protocol(UINT8 encode_type) { if (0 != prot_cycles_num[i]) { - prot_cycles_data[i] = (irda_cycles_t *) (&prot_cycles[sizeof(irda_cycles_t) * cycles_sum]); + prot_cycles_data[i] = (ir_cycles_t *) (&prot_cycles[sizeof(ir_cycles_t) * cycles_sum]); } else { @@ -147,25 +147,25 @@ static BOOL get_irda_protocol(UINT8 encode_type) } cycles_sum += prot_cycles_num[i]; } - pbuffer->offset += sizeof(irda_cycles_t) * cycles_sum; + pbuffer->offset += sizeof(ir_cycles_t) * cycles_sum; /* items count */ prot_items_cnt = pbuffer->data[pbuffer->offset]; pbuffer->offset += sizeof(UINT8); /* items data */ - prot_items_data = (irda_data_t *) (pbuffer->data + pbuffer->offset); - pbuffer->offset += prot_items_cnt * sizeof(irda_data_t); + prot_items_data = (ir_data_t *) (pbuffer->data + pbuffer->offset); + pbuffer->offset += prot_items_cnt * sizeof(ir_data_t); - irda_toggle_bit = FALSE; + ir_toggle_bit = FALSE; return TRUE; } -static BOOL get_irda_keymap(void) +static BOOL get_ir_keymap(void) { - remote_p = (irda_data_tv_t *) (pbuffer->data + pbuffer->offset); - pbuffer->offset += sizeof(irda_data_tv_t); + remote_p = (ir_data_tv_t *) (pbuffer->data + pbuffer->offset); + pbuffer->offset += sizeof(ir_data_tv_t); if (strncmp(remote_p->magic, "irda", 4) == 0) { @@ -176,14 +176,14 @@ static BOOL get_irda_keymap(void) return FALSE; } -static void print_irda_time(irda_data_t *data, UINT8 keyindex, UINT16 *irda_time) +static void print_ir_time(ir_data_t *data, UINT8 keyindex, UINT16 *ir_time) { UINT8 i = 0; UINT8 cycles_num = 0; - irda_cycles_t *pcycles = NULL; + ir_cycles_t *pcycles = NULL; UINT8 keycode = 0; - if (NULL == data || NULL == irda_time) + if (NULL == data || NULL == ir_time) { return; } @@ -218,7 +218,7 @@ static void print_irda_time(irda_data_t *data, UINT8 keyindex, UINT16 *irda_time { if (cycles_num == 2 && data->index == IRDA_FLIP) { - if (irda_toggle_bit == TRUE) + if (ir_toggle_bit == TRUE) { pcycles += 1; } @@ -228,58 +228,58 @@ static void print_irda_time(irda_data_t *data, UINT8 keyindex, UINT16 *irda_time { if (pcycles->flag == IRDA_FLAG_NORMAL) { - if (irda_level == IRDA_LEVEL_HIGH && time_index != 0) + if (ir_level == IRDA_LEVEL_HIGH && time_index != 0) { time_index--; - irda_time[time_index++] += pcycles->mask; + ir_time[time_index++] += pcycles->mask; } - else if (irda_level == IRDA_LEVEL_LOW) + else if (ir_level == IRDA_LEVEL_LOW) { - irda_time[time_index++] = pcycles->mask; + ir_time[time_index++] = pcycles->mask; } - irda_time[time_index++] = pcycles->space; - irda_level = IRDA_LEVEL_LOW; + ir_time[time_index++] = pcycles->space; + ir_level = IRDA_LEVEL_LOW; } else if (pcycles->flag == IRDA_FLAG_INVERSE) { - if (irda_level == IRDA_LEVEL_LOW && time_index != 0) + if (ir_level == IRDA_LEVEL_LOW && time_index != 0) { time_index--; - irda_time[time_index++] += pcycles->space; + ir_time[time_index++] += pcycles->space; } - else if (irda_level == IRDA_LEVEL_HIGH) + else if (ir_level == IRDA_LEVEL_HIGH) { - irda_time[time_index++] = pcycles->space; + ir_time[time_index++] = pcycles->space; } - irda_time[time_index++] = pcycles->mask; - irda_level = IRDA_LEVEL_HIGH; + ir_time[time_index++] = pcycles->mask; + ir_level = IRDA_LEVEL_HIGH; } } else if (0 == pcycles->mask && 0 != pcycles->space) { - if (irda_level == IRDA_LEVEL_LOW && time_index != 0) + if (ir_level == IRDA_LEVEL_LOW && time_index != 0) { time_index--; - irda_time[time_index++] += pcycles->space; + ir_time[time_index++] += pcycles->space; } - else if (irda_level == IRDA_LEVEL_HIGH) + else if (ir_level == IRDA_LEVEL_HIGH) { - irda_time[time_index++] = pcycles->space; + ir_time[time_index++] = pcycles->space; } - irda_level = IRDA_LEVEL_LOW; + ir_level = IRDA_LEVEL_LOW; } else if (0 == pcycles->space && 0 != pcycles->mask) { - if (irda_level == IRDA_LEVEL_HIGH && time_index != 0) + if (ir_level == IRDA_LEVEL_HIGH && time_index != 0) { time_index--; - irda_time[time_index++] += pcycles->mask; + ir_time[time_index++] += pcycles->mask; } - else if (irda_level == IRDA_LEVEL_LOW) + else if (ir_level == IRDA_LEVEL_LOW) { - irda_time[time_index++] = pcycles->mask; + ir_time[time_index++] = pcycles->mask; } - irda_level = IRDA_LEVEL_HIGH; + ir_level = IRDA_LEVEL_HIGH; } else { @@ -302,25 +302,25 @@ static void print_irda_time(irda_data_t *data, UINT8 keyindex, UINT16 *irda_time if (data->mode == 1) keycode = ~keycode; - if (irda_decode_flag == IRDA_DECODE_1_BIT) + if (ir_decode_flag == IRDA_DECODE_1_BIT) { // for binary formatted code - process_decode_number(keycode, data, 1, irda_time); + process_decode_number(keycode, data, 1, ir_time); } - else if (irda_decode_flag == IRDA_DECODE_2_BITS) + else if (ir_decode_flag == IRDA_DECODE_2_BITS) { // for quanternary formatted code - process_decode_number(keycode, data, 2, irda_time); + process_decode_number(keycode, data, 2, ir_time); } - else if (irda_decode_flag == IRDA_DECODE_4_BITS) + else if (ir_decode_flag == IRDA_DECODE_4_BITS) { // for hexadecimal formatted code - process_decode_number(keycode, data, 4, irda_time); + process_decode_number(keycode, data, 4, ir_time); } } } -static void process_decode_number(UINT8 keycode, irda_data_t *data, UINT8 valid_bits, UINT16 *irda_time) +static void process_decode_number(UINT8 keycode, ir_data_t *data, UINT8 valid_bits, UINT16 *ir_time) { UINT8 i = 0; UINT8 value = 0; @@ -334,7 +334,7 @@ static void process_decode_number(UINT8 keycode, irda_data_t *data, UINT8 valid_ for (i = 0; i < bit_num; i++) { value = (keycode >> (valid_bits * i)) & valid_value; - convert_to_irda_time(value, irda_time); + convert_to_ir_time(value, ir_time); } } else if (data->lsb == IRDA_MSB) @@ -342,101 +342,101 @@ static void process_decode_number(UINT8 keycode, irda_data_t *data, UINT8 valid_ for (i = 0; i < bit_num; i++) { value = (keycode >> (data->bits - valid_bits * (i + 1))) & valid_value; - convert_to_irda_time(value, irda_time); + convert_to_ir_time(value, ir_time); } } } -static void convert_to_irda_time(UINT8 value, UINT16 *irda_time) +static void convert_to_ir_time(UINT8 value, UINT16 *ir_time) { switch (value) { case 0: - replace_with(prot_cycles_data[IRDA_ZERO], irda_time); + replace_with(prot_cycles_data[IRDA_ZERO], ir_time); break; case 1: - replace_with(prot_cycles_data[IRDA_ONE], irda_time); + replace_with(prot_cycles_data[IRDA_ONE], ir_time); break; case 2: - replace_with(prot_cycles_data[IRDA_TWO], irda_time); + replace_with(prot_cycles_data[IRDA_TWO], ir_time); break; case 3: - replace_with(prot_cycles_data[IRDA_THREE], irda_time); + replace_with(prot_cycles_data[IRDA_THREE], ir_time); break; case 4: - replace_with(prot_cycles_data[IRDA_FOUR], irda_time); + replace_with(prot_cycles_data[IRDA_FOUR], ir_time); break; case 5: - replace_with(prot_cycles_data[IRDA_FIVE], irda_time); + replace_with(prot_cycles_data[IRDA_FIVE], ir_time); break; case 6: - replace_with(prot_cycles_data[IRDA_SIX], irda_time); + replace_with(prot_cycles_data[IRDA_SIX], ir_time); break; case 7: - replace_with(prot_cycles_data[IRDA_SEVEN], irda_time); + replace_with(prot_cycles_data[IRDA_SEVEN], ir_time); break; case 8: - replace_with(prot_cycles_data[IRDA_EIGHT], irda_time); + replace_with(prot_cycles_data[IRDA_EIGHT], ir_time); break; case 9: - replace_with(prot_cycles_data[IRDA_NINE], irda_time); + replace_with(prot_cycles_data[IRDA_NINE], ir_time); break; case 0x0A: - replace_with(prot_cycles_data[IRDA_A], irda_time); + replace_with(prot_cycles_data[IRDA_A], ir_time); break; case 0x0B: - replace_with(prot_cycles_data[IRDA_B], irda_time); + replace_with(prot_cycles_data[IRDA_B], ir_time); break; case 0x0C: - replace_with(prot_cycles_data[IRDA_C], irda_time); + replace_with(prot_cycles_data[IRDA_C], ir_time); break; case 0x0D: - replace_with(prot_cycles_data[IRDA_D], irda_time); + replace_with(prot_cycles_data[IRDA_D], ir_time); break; case 0x0E: - replace_with(prot_cycles_data[IRDA_E], irda_time); + replace_with(prot_cycles_data[IRDA_E], ir_time); break; case 0x0F: - replace_with(prot_cycles_data[IRDA_F], irda_time); + replace_with(prot_cycles_data[IRDA_F], ir_time); break; default: break; } } -static void replace_with(irda_cycles_t *pcycles_num, UINT16 *irda_time) +static void replace_with(ir_cycles_t *pcycles_num, UINT16 *ir_time) { - if (NULL == pcycles_num || NULL == irda_time) + if (NULL == pcycles_num || NULL == ir_time) { return; } if (pcycles_num->flag == IRDA_FLAG_NORMAL) { - if (irda_level == IRDA_LEVEL_HIGH && time_index != 0) + if (ir_level == IRDA_LEVEL_HIGH && time_index != 0) { time_index--; - irda_time[time_index++] += pcycles_num->mask; + ir_time[time_index++] += pcycles_num->mask; } - else if (irda_level == IRDA_LEVEL_LOW) + else if (ir_level == IRDA_LEVEL_LOW) { - irda_time[time_index++] = pcycles_num->mask; + ir_time[time_index++] = pcycles_num->mask; } - irda_time[time_index++] = pcycles_num->space; - irda_level = IRDA_LEVEL_LOW; + ir_time[time_index++] = pcycles_num->space; + ir_level = IRDA_LEVEL_LOW; } else if (pcycles_num->flag == IRDA_FLAG_INVERSE) { - if (irda_level == IRDA_LEVEL_LOW && time_index != 0) + if (ir_level == IRDA_LEVEL_LOW && time_index != 0) { time_index--; - irda_time[time_index++] += pcycles_num->space; + ir_time[time_index++] += pcycles_num->space; } - else if (irda_level == IRDA_LEVEL_HIGH) + else if (ir_level == IRDA_LEVEL_HIGH) { - irda_time[time_index++] = pcycles_num->space; + ir_time[time_index++] = pcycles_num->space; } - irda_time[time_index++] = pcycles_num->mask; - irda_level = IRDA_LEVEL_HIGH; + ir_time[time_index++] = pcycles_num->mask; + ir_level = IRDA_LEVEL_HIGH; } } \ No newline at end of file diff --git a/src/ir_decoder/src/ir_utils.c b/src/ir_decoder/src/ir_utils.c index 62e95d5..2dfc71e 100644 --- a/src/ir_decoder/src/ir_utils.c +++ b/src/ir_decoder/src/ir_utils.c @@ -44,7 +44,7 @@ void string_to_hex(UINT8 *p, ac_hex *pac_hex, UINT16 len) { UINT8 i = 0; - IR_PRINTF("string to hex"); + ir_printf("string to hex"); pac_hex->len = chars_to_hex(p); p = p + 2; for (i = 0; i < pac_hex->len; i++)