diff options
Diffstat (limited to 'drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c')
-rw-r--r-- | drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c | 532 |
1 files changed, 276 insertions, 256 deletions
diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c b/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c index db55f3d..229bcc1 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c @@ -27,8 +27,8 @@ #include "tcbd_stream_parser.h" #define SIZE_MSC_CACHE_BUFF (188*20) -#define SIZE_FIC_CACHE_BUFF (388*4) -#define SIZE_STATUS_CACHE_BUFF (32*4) +#define SIZE_FIC_CACHE_BUFF (388*2) +#define SIZE_STATUS_CACHE_BUFF (32*2) #if defined(__MERGE_EACH_TYPEOF_STREAM__) #define SIZE_MSC_STACK_BUFF (1024*16) @@ -39,12 +39,12 @@ #define MAX_SUBCH_ID (0x1<<6) enum tcbd_split_stream_state { STATE_NO_SYNC = 0, - STATE_READ_NEXT, STATE_OTHER, STATE_STATUS, STATE_MSC, STATE_FIC, STATE_GARBAGE, + STATE_ERROR }; #define HEADER_SIZE 4 @@ -66,6 +66,8 @@ struct merged_stream_info { #endif /* __MERGE_EACH_TYPEOF_STREAM__ */ struct tcbd_split_stream_data { + s32 dev_idx; + s32 header_err[2]; enum tcbd_split_stream_state state; s32 header_cnt; s32 remain; @@ -82,7 +84,7 @@ struct tcbd_split_stream_data { tcbd_stream_callback stream_callback; }; -static struct tcbd_split_stream_data tcbd_stream_spliter; +static struct tcbd_split_stream_data tcbd_stream_spliter[2]; static inline u8 tcbd_parity_check(u8 *parity) { @@ -94,139 +96,106 @@ static inline u8 tcbd_parity_check(u8 *parity) p = (p + ((parity[i] >> k) & 1)) & 1; } - if (p == 0) - tcbd_debug(DEBUG_ERROR, "Odd parity error\n"); - return p; } -static s32 tcbd_find_sync(struct tcbd_split_stream_data *_parser) -{ - s32 i; - s32 next_hdr, size = _parser->remain; - u8 *stream = _parser->buffer; - -#if defined(__FIND_HEADER_MORE__) - s32 j, first = 0, num_found = 0, data_size; -#endif /*__FIND_HEADER_MORE__ */ - - /* 1. SYNC_BYTE must exist at stream[3] */ - if ((stream[3] == SYNC_BYTE) && - (tcbd_parity_check(stream) == 1)) - return 0; - - /* 2. if SYNC_BYTE doesn't exist at stream[3] - then search SYNC_BYTE at whole stream*/ - for (i = 0; i < size; i++) { - if ((i < 3) || (stream[i] != SYNC_BYTE)) - continue; - - if (tcbd_parity_check(&stream[i - 3]) != 1) { - next_hdr = SWAP32(*((u32 *)&stream[i-3])); - tcbd_debug(DEBUG_ERROR, - "parity error!! find next byte, " - "offset:%d, header:0x%08X\n", - i, next_hdr); - continue; - } -#if !defined(__FIND_HEADER_MORE__) - tcbd_debug(DEBUG_STREAM_PARSER, - "found header offset %d\n", i-3); - return i - 3; -#else /* __FIND_HEADER_MORE__ */ - num_found = 1; - first = j = i - 3; - do { - data_size = - (stream[j + 1] << 7 | (stream[j+0] >> 1)) << 2; - j += (data_size + 4); - if (j >= size) - break; - - if ((stream[j + 3] == SYNC_BYTE) && - (tcbd_parity_check(stream + j) == 1)) { - tcbd_debug(DEBUG_STREAM_PARSER, - "header ok pos:%d," - "remain:%d\n", j, size); - num_found++; - } else { - next_hdr = - SWAP32(*((u32 *)(stream + j))); - tcbd_debug(DEBUG_ERROR, - "Header ERR!! [%02X] j = %d," - " size=%d, data_size:%d\n", - next_hdr, j, size, data_size); - num_found--; - break; - } - } while (j < size); - - if (num_found > 1) { - next_hdr = SWAP32(*((u32 *)(stream+first))); - tcbd_debug(DEBUG_STREAM_PARSER, - "offset:%d, header ok count : %d, 0x%08X\n", - first, num_found, next_hdr); - return first; - } -#endif /*__FIND_HEADER_MORE__*/ - } - return -i; -} +#define FIC_ID 0x00 +#define STATUS_ID 0x3F +#define GARBAGE_ID 0x04 +#define OTHER_CHIP_ID 0x3D -static inline s32 tcbd_parse_header(struct tcbd_split_stream_data *_parser) +static inline void tcbd_change_parser_state(struct op_header *header, + struct tcbd_split_stream_data *_parser) { - u8 *stream = _parser->buffer; - struct op_header *header = &_parser->header; + s32 size_limit[] = { -1, 4096, 32, 4096, 388, 4096}; + s8 *type[] = {NULL, "other", "status", "msc", "fic", "garbage"}; - if ((stream[3] != SYNC_BYTE) || - (tcbd_parity_check(stream) != 1)) { - tcbd_debug(DEBUG_ERROR, "wrong header! header:0x%08X\n", - SWAP32(*(u32 *)stream)); - memset(header, 0, sizeof(struct op_header)); - return HEADER_SIZE; - } - _parser->header_cnt++; - - header->sync = stream[3]; - header->type = (stream[2] & 0xC0) >> 6; - header->data_size = ((stream[1]<<7) | (stream[0]>>1)) << 2; - header->subch = stream[2] & 0x3F; - - _parser->state = STATE_NO_SYNC; switch ((enum DATA_TYPE)header->type) { case DATA_TYPE_MSC: - if (header->data_size != TCBD_FIC_SIZE) + if (header->data_size == 388) { + _parser->state = STATE_FIC; + header->type = DATA_TYPE_FIC; + } else _parser->state = STATE_MSC; break; case DATA_TYPE_FIC: - if (header->subch) + if (header->subch == GARBAGE_ID) _parser->state = STATE_GARBAGE; - else + else if (header->subch == FIC_ID) _parser->state = STATE_FIC; + else + _parser->state = STATE_ERROR; break; case DATA_TYPE_STATUS: - _parser->state = STATE_STATUS; + if (header->subch == STATUS_ID) + _parser->state = STATE_STATUS; + else + _parser->state = STATE_ERROR; break; case DATA_TYPE_OTHER: - _parser->state = STATE_OTHER; + if (header->subch == OTHER_CHIP_ID) + _parser->state = STATE_OTHER; + else + _parser->state = STATE_ERROR; break; default: + tcbd_debug(DEBUG_ERROR, "unknown data type!!"); + _parser->state = STATE_ERROR; + break; + } + switch (_parser->state) { + case STATE_ERROR: + _parser->header_err[1]++; + _parser->state = STATE_NO_SYNC; + break; + default: + if (size_limit[_parser->state] < header->data_size) { + tcbd_debug(DEBUG_ERROR, "wrong data size %s:%d!\n", + type[_parser->state], header->data_size); + _parser->header_err[1]++; + _parser->state = STATE_NO_SYNC; + + } else + _parser->header_cnt++; break; } - return HEADER_SIZE; } -static inline void tcbd_stack_chunk( - struct tcbd_split_stream_data *_parser, u8 *_buffer) +static s32 tcbd_parse_header(struct tcbd_split_stream_data *_parser) { - u8 *chunk_buff = (_buffer) ? _buffer : _parser->buffer; + u8 *stream = _parser->buffer; struct op_header *header = &_parser->header; + _parser->state = STATE_NO_SYNC; + if ((stream[3] != SYNC_BYTE) || (tcbd_parity_check(stream) != 1)) { + _parser->header_err[0]++; + return HEADER_SIZE; + } + + header->sync = stream[3]; + header->type = (stream[2] & 0xC0) >> 6; + header->data_size = ((stream[1]<<7) | (stream[0]>>1)) << 2; + header->subch = stream[2] & 0x3F; + + tcbd_debug(DEBUG_PARSE_HEADER, "sync:0x%02X, type:%d, size:%d\n", + header->sync, header->type, + header->data_size); + tcbd_change_parser_state(header, _parser); + + return HEADER_SIZE; +} + #if defined(__MERGE_EACH_TYPEOF_STREAM__) +static void tcbd_merge_each_stream(struct tcbd_split_stream_data *_parser, + u8 *chunk_buff) +{ static u8 msc_buff[TCBD_MAX_NUM_SERVICE][SIZE_MSC_STACK_BUFF]; static u8 fic_buff[SIZE_FIC_STACK_BUFF]; static u8 status_buff[SIZE_STATUS_STACK_BUFF]; + struct merged_stream_info *merged; + struct op_header *header = &_parser->header; + s32 sz_stack_buff[] = { SIZE_MSC_STACK_BUFF, SIZE_FIC_STACK_BUFF, @@ -236,7 +205,7 @@ static inline void tcbd_stack_chunk( switch (header->type) { case DATA_TYPE_MSC: if (_parser->num_subch >= TCBD_MAX_NUM_SERVICE) { - tcbd_debug(DEBUG_ERROR, "error!\n"); + tcbd_debug(DEBUG_ERROR, "exceeded max num service!\n"); return; } if (_parser->quick_msc_idx[header->subch] == 0xFF) @@ -245,10 +214,8 @@ static inline void tcbd_stack_chunk( quick_msc_idx = _parser->quick_msc_idx[header->subch]; if (quick_msc_idx >= TCBD_MAX_NUM_SERVICE) - tcbd_debug(DEBUG_ERROR, "quick_msc_idx:%d, " - "header->subch:%d\n", - quick_msc_idx, - header->subch); + tcbd_debug(DEBUG_ERROR, "quick_msc_idx:%d, header->" + "subch:%d\n", quick_msc_idx, header->subch); merged = &_parser->merged_msc[quick_msc_idx]; merged->buffer = msc_buff[quick_msc_idx]; @@ -267,114 +234,29 @@ static inline void tcbd_stack_chunk( return; } - if (merged->curr_pos + header->data_size > - sz_stack_buff[header->type]) { + if (merged->curr_pos+header->data_size > sz_stack_buff[header->type]) { tcbd_debug(DEBUG_ERROR, "overflow stack buffer!!\n"); return; } - tcbd_debug(DEBUG_STREAM_STACK, - "type:%d, subchid:%d, buffer:%p currpos:%d, size:%d\n", - header->type, - header->subch, - merged->buffer, - merged->curr_pos, + tcbd_debug(DEBUG_STREAM_STACK, "type:%d, subchid:%u, buffer:%p " + "currpos:%d, size:%d\n", header->type, header->subch, + merged->buffer, merged->curr_pos, header->data_size); + memcpy(merged->buffer + merged->curr_pos, chunk_buff, header->data_size); - memcpy(merged->buffer + merged->curr_pos, - chunk_buff, header->data_size); merged->curr_pos += header->data_size; - -#else /* __MERGE_EACH_TYPEOF_STREAM__ */ - if (_parser->stream_callback) { - _parser->stream_callback( - chunk_buff, - header->data_size, - header->subch, - header->type); - } -#endif /* !__MERGE_EACH_TYPEOF_STREAM__ */ } -static s32 tcbd_push_chunk( - struct tcbd_split_stream_data *_parser, u8 *_cached_buff) -{ - s32 move, pre_copied; - u8 *buffer = _parser->buffer; - s8 *type[] = {"msc", "fic", "status", "other"}; - s32 size_cache_buff[] = { - SIZE_MSC_CACHE_BUFF, - SIZE_FIC_CACHE_BUFF, - SIZE_STATUS_CACHE_BUFF}; - struct op_header *header = &_parser->header; - - if (_parser->next_read) { - if (_parser->state != STATE_GARBAGE) { - pre_copied = header->data_size - _parser->next_read; - - tcbd_debug(DEBUG_PARSING_PROC, - "send %s data %d bytes, pre:%d," - " curr:%d, buffer:%p\n", - type[header->type], - header->data_size, - pre_copied, - _parser->next_read, - _cached_buff); - - if (header->data_size > size_cache_buff[header->type]) - tcbd_debug(DEBUG_ERROR, - "overflow %s cache buffer!!\n", - type[header->type]); - memcpy(_cached_buff + pre_copied, buffer, - _parser->next_read); - tcbd_stack_chunk(_parser, _cached_buff); - } - move = _parser->next_read; - _parser->state = STATE_NO_SYNC; - _parser->next_read = 0; - } else if (_parser->remain >= header->data_size) { - if (_parser->state != STATE_GARBAGE) { - tcbd_debug(DEBUG_PARSING_PROC, - "send %s data %d bytes\n", - type[header->type], - header->data_size); - tcbd_stack_chunk(_parser, NULL); - } - _parser->state = STATE_NO_SYNC; - move = header->data_size; - } else { - if (_parser->state != STATE_GARBAGE) { - tcbd_debug(DEBUG_PARSING_PROC, - "keep %s data %d bytes buff:%p\n", - type[header->type], - _parser->remain, - _cached_buff); - - if (header->data_size > size_cache_buff[header->type]) - tcbd_debug(DEBUG_ERROR, - "overflow %s cache buffer!!\n", - type[header->type]); - memcpy(_cached_buff, buffer, _parser->remain); - } - _parser->next_read = header->data_size - _parser->remain; - move = _parser->remain; - } - return move; -} - -#if defined(__MERGE_EACH_TYPEOF_STREAM__) -static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) +static s32 tcbd_push_merged_stream(struct tcbd_split_stream_data *_parser) { register s32 i; struct merged_stream_info *merged = NULL; struct merged_stream_info *list_stream[] = { - NULL, - &_parser->merged_fic, - &_parser->merged_status, - NULL + NULL, &_parser->merged_fic, &_parser->merged_status, NULL }; tcbd_debug(DEBUG_STREAM_STACK, "header num:%d, num subch :%d\n", - tcbd_stream_spliter.header_cnt, _parser->num_subch); + _parser->header_cnt, _parser->num_subch); for (i = 0; i < _parser->num_subch; i++) { merged = &_parser->merged_msc[i]; if (!merged->buffer || !merged->curr_pos) @@ -382,10 +264,9 @@ static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) /* send merged data to user space */ if (_parser->stream_callback) { - _parser->stream_callback(merged->buffer, - merged->curr_pos, - merged->subch_id, - DATA_TYPE_MSC); + _parser->stream_callback(_parser->dev_idx, + merged->buffer, merged->curr_pos, + merged->subch_id, DATA_TYPE_MSC); merged->buffer = NULL; merged->curr_pos = 0; } @@ -398,7 +279,7 @@ static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) /* send merged data to user space */ if (_parser->stream_callback) { - _parser->stream_callback( + _parser->stream_callback(_parser->dev_idx, merged->buffer, merged->curr_pos, merged->subch_id, i); merged->buffer = NULL; @@ -409,97 +290,236 @@ static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) } #endif /*__MERGE_EACH_TYPEOF_STREAM__ */ -s32 tcbd_split_stream(u8 *_stream, s32 _size) +static void tcbd_stack_chunk(struct tcbd_split_stream_data *_parser, + u8 *_buffer) +{ + u8 *chunk_buff = (_buffer) ? _buffer : _parser->buffer; +#if defined(__MERGE_EACH_TYPEOF_STREAM__) + tcbd_merge_each_stream(_parser, chunk_buff); +#else /* __MERGE_EACH_TYPEOF_STREAM__ */ + struct op_header *header = &_parser->header; + if (_parser->stream_callback) { + _parser->stream_callback(_parser->dev_idx, chunk_buff, + header->data_size, header->subch, header->type); + } +#endif /* !__MERGE_EACH_TYPEOF_STREAM__ */ +} + +static inline s32 tcbd_push_concat(struct tcbd_split_stream_data *_parser, + u8 *_cache_buff) +{ + s32 pre_copied, ret; + u8 *buffer = _parser->buffer; + struct op_header *header = &_parser->header; + + s8 *type[] = {"msc", "fic", "status", "other"}; + s32 size_cache_buff[] = { + SIZE_MSC_CACHE_BUFF, + SIZE_FIC_CACHE_BUFF, + SIZE_STATUS_CACHE_BUFF}; + + if (header->data_size > size_cache_buff[header->type]) { + tcbd_debug(DEBUG_ERROR, "overflow %s cache buffer!! size:%d\n", + type[header->type], header->data_size); + _parser->state = STATE_ERROR; + ret = HEADER_SIZE; + goto exit_func; + } + + pre_copied = header->data_size - _parser->next_read; + if (_parser->next_read > _parser->remain) { + memcpy(_cache_buff + pre_copied, buffer, _parser->remain); + _parser->next_read -= _parser->remain; + ret = _parser->remain; + tcbd_debug(DEBUG_PARSING_PROC, "keep %s data %d bytes, pre:%d," + "next:%d, buffer:%p\n", type[header->type], + _parser->remain, pre_copied, _parser->next_read, + _cache_buff); + } else { + memcpy(_cache_buff + pre_copied, buffer, _parser->next_read); + tcbd_stack_chunk(_parser, _cache_buff); + ret = _parser->next_read; + tcbd_debug(DEBUG_PARSING_PROC, "send %s data %d bytes, pre:%d," + "curr:%d, buffer:%p\n", type[header->type], + header->data_size, pre_copied, + _parser->next_read, _cache_buff); + _parser->state = STATE_NO_SYNC; + } + +exit_func: + return ret; +} + +static inline void tcbd_push_medium(struct tcbd_split_stream_data *_parser) +{ + struct op_header *header = &_parser->header; + s8 *type[] = {"msc", "fic", "status", "other"}; + + tcbd_debug(DEBUG_PARSING_PROC, "send %s data %d bytes\n", + type[header->type], header->data_size); + tcbd_stack_chunk(_parser, NULL); +} + +static inline s32 tcbd_cache_ramnant(struct tcbd_split_stream_data *_parser, + u8 *_cache_buff) +{ + struct op_header *header = &_parser->header; + u8 *buffer = _parser->buffer; + s8 *type[] = {"msc", "fic", "status", "other"}; + s32 size_cache_buff[] = { + SIZE_MSC_CACHE_BUFF, + SIZE_FIC_CACHE_BUFF, + SIZE_STATUS_CACHE_BUFF}; + + tcbd_debug(DEBUG_PARSING_PROC, "keep %s data %d bytes buff:%p\n", + type[header->type], _parser->remain, _cache_buff); + + if (header->data_size > size_cache_buff[header->type]) { + tcbd_debug(DEBUG_ERROR, "overflow %s cache buffer!! size:%d\n", + type[header->type], header->data_size); + _parser->state = STATE_ERROR; + return HEADER_SIZE; + } else { + memcpy(_cache_buff, buffer, _parser->remain); + return _parser->remain; + } +} + +static s32 tcbd_push_chunk(struct tcbd_split_stream_data *_parser, + u8 *_cached_buff) +{ + s32 move; + struct op_header *header = &_parser->header; + + if (_parser->next_read) { + if (_parser->state != STATE_GARBAGE) + move = tcbd_push_concat(_parser, _cached_buff); + else { + if (_parser->next_read > _parser->remain) { + _parser->next_read -= _parser->remain; + move = _parser->remain; + } else { + move = _parser->next_read; + _parser->state = STATE_NO_SYNC; + } + } + } else if (_parser->remain >= header->data_size) { + if (_parser->state != STATE_GARBAGE) + tcbd_push_medium(_parser); + + _parser->state = STATE_NO_SYNC; + move = header->data_size; + } else { + if (_parser->state != STATE_GARBAGE) + move = tcbd_cache_ramnant(_parser, _cached_buff); + else + move = _parser->remain; + + _parser->next_read = header->data_size - _parser->remain; + } + + switch (_parser->state) { + case STATE_NO_SYNC: +#if defined(__USING_TS_IF__) + if (_parser->next_read == 0) + move += 188 - ((move + SIZE_BUFF_HEADER) % 188); + else + move += 188 - (move % 188); +#endif /*__USING_TS_IF__*/ + case STATE_ERROR: + _parser->state = STATE_NO_SYNC; + _parser->next_read = 0; + default: + break; + } + + return move; +} + +s32 tcbd_split_stream(s32 _dev_idx, u8 *_stream, s32 _size) { s32 ret = 0; register s32 point, move; - /* buffer for un-handled spare data of each interrupt */ static u8 cache_buff_msc[SIZE_MSC_CACHE_BUFF]; static u8 cache_buff_fic[SIZE_FIC_CACHE_BUFF]; static u8 buff_cache_status[SIZE_STATUS_CACHE_BUFF]; - u64 time; + struct tcbd_split_stream_data *spliter = &tcbd_stream_spliter[_dev_idx]; + u64 time = 0; point = move = 0; - tcbd_stream_spliter.remain = _size; - tcbd_stream_spliter.header_cnt = 0; + spliter->remain = _size; + spliter->header_cnt = 0; + memset(spliter->header_err, 0, sizeof(spliter->header_err)); time = tcpal_get_time(); - while (tcbd_stream_spliter.remain > 0) { - tcbd_stream_spliter.buffer = _stream + point; - switch (tcbd_stream_spliter.state) { + while (spliter->remain > 0) { + spliter->buffer = _stream + point; + switch (spliter->state) { case STATE_NO_SYNC: - ret = tcbd_find_sync(&tcbd_stream_spliter); - if (ret < 0) { - tcbd_debug(DEBUG_STREAM_PARSER, - "could not find sync byte!! %d\n", ret); - tcbd_init_parser(NULL); - return ret; - } else if (ret > 0) { - point += ret; - tcbd_stream_spliter.buffer += ret; - tcbd_stream_spliter.remain -= ret; - } - move = tcbd_parse_header(&tcbd_stream_spliter); + move = tcbd_parse_header(spliter); break; case STATE_OTHER: - move = tcbd_parse_header(&tcbd_stream_spliter); + move = tcbd_parse_header(spliter); tcbd_debug(DEBUG_ERROR, "State Other!! size:%d\n", - tcbd_stream_spliter.header.data_size); + spliter->header.data_size); break; case STATE_MSC: - move = tcbd_push_chunk( - &tcbd_stream_spliter, - cache_buff_msc); + move = tcbd_push_chunk(spliter, cache_buff_msc); break; case STATE_FIC: - move = tcbd_push_chunk( - &tcbd_stream_spliter, - cache_buff_fic); + move = tcbd_push_chunk(spliter, cache_buff_fic); break; case STATE_STATUS: - move = tcbd_push_chunk( - &tcbd_stream_spliter, - buff_cache_status); + move = tcbd_push_chunk(spliter, buff_cache_status); break; + case STATE_GARBAGE: - move = tcbd_push_chunk(&tcbd_stream_spliter, NULL); + move = tcbd_push_chunk(spliter, NULL); tcbd_debug(DEBUG_STREAM_PARSER, "State Garbage!:%d\n", - tcbd_stream_spliter.header.data_size); + spliter->header.data_size); break; default: move = 0; point = 0; + spliter->state = STATE_NO_SYNC; + spliter->next_read = 0; tcbd_debug(DEBUG_ERROR, "something wrong!\n"); - break; + goto exit_func; } - tcbd_stream_spliter.remain -= move; + spliter->remain -= move; point += move; tcbd_debug(0, "remain:%d, point:%d, move:%d\n", - tcbd_stream_spliter.remain, point, move); + spliter->remain, point, move); } +exit_func: #if defined(__MERGE_EACH_TYPEOF_STREAM__) - ret = tcbd_push_stream(&tcbd_stream_spliter); + ret = tcbd_push_merged_stream(spliter); #endif /*__MERGE_EACH_TYPEOF_STREAM__*/ - tcbd_debug(DEBUG_PARSING_TIME, - "%lldms elapsed!\n", tcpal_diff_time(time)); + tcbd_debug(DEBUG_PARSING_TIME, "%lldms elapsed to parse!\n", + tcpal_diff_time(time)); + + if (spliter->header_err[0] || spliter->header_err[1]) + tcbd_debug(DEBUG_ERROR, "header err, parity:%d, state:%d\n", + spliter->header_err[0], spliter->header_err[1]); return ret; } -void tcbd_init_parser(tcbd_stream_callback _stream_callback) +void tcbd_init_parser(s32 _dev_idx, tcbd_stream_callback _stream_callback) { tcbd_stream_callback bak = NULL; + struct tcbd_split_stream_data *spliter = &tcbd_stream_spliter[_dev_idx]; - if (tcbd_stream_spliter.stream_callback) - bak = tcbd_stream_spliter.stream_callback; + if (spliter->stream_callback) + bak = spliter->stream_callback; - memset(&tcbd_stream_spliter, 0, sizeof(tcbd_stream_spliter)); + memset(spliter, 0, sizeof(struct tcbd_split_stream_data)); + spliter->dev_idx = _dev_idx; #if defined(__MERGE_EACH_TYPEOF_STREAM__) - memset(tcbd_stream_spliter.quick_msc_idx, 0xFF, - sizeof(tcbd_stream_spliter.quick_msc_idx)); + memset(spliter->quick_msc_idx, 0xFF, sizeof(spliter->quick_msc_idx)); #endif /*__MERGE_EACH_TYPEOF_STREAM__*/ if (_stream_callback) - tcbd_stream_spliter.stream_callback = _stream_callback; + spliter->stream_callback = _stream_callback; else if (bak) - tcbd_stream_spliter.stream_callback = bak; + spliter->stream_callback = bak; } |