/* put packet into reorder buffer, sequence is the packet's sequnce number */
void video_rtp_reorder_put_pkt(kal_uint8 *data, kal_uint32 size, kal_uint32 sequence)
{
kal_uint32 index;
kal_uint32 match_index;
kal_uint8 *p_buffer = NULL;
/* free previous got buffer memory */
if(g_video_rtp_reorder_buff_info.p_free_addr !=NULL)
{
kal_adm_free(g_video_rtp_reorder_buff_info.adm_id, g_video_rtp_reorder_buff_info.p_free_addr);
g_video_rtp_reorder_buff_info.p_free_addr = NULL;
}
if(g_video_rtp_reorder_buff_info.total_pkt >= VIDEO_RTP_MAX_REORDER_NUM)
{
#ifdef STREAM_REORDER_BUFFER_DBG_TRACE
video_dbg_trace(STREAM_REORDER_BUFFER_DROP_SEQ, sequence);
#endif
/* re-order buffer is full, drop the packet */
VIDEO_ASSERT(0);
return;
}
p_buffer = kal_adm_internal_alloc(g_video_rtp_reorder_buff_info.adm_id, size, __FILE__, __LINE__);
if(p_buffer==NULL)
{
#ifdef STREAM_REORDER_BUFFER_DBG_TRACE
video_dbg_trace(STREAM_REORDER_BUFFER_DROP_SEQ, sequence);
#endif
/* re-order buffer is full, drop the packet */
VIDEO_ASSERT(0);
g_video_rtp_reorder_buff_info.b_buffer_full = KAL_TRUE;
return;
}
/* search for the matched sequnce index*/
for(index=0; index<g_video_rtp_reorder_buff_info.total_pkt; index++)
{
if(g_video_rtp_reorder_buff_info.sequence[index] > sequence)
{
break;
}
}
/* shift the items that has larger sequnce than the input item */
match_index = index;
for(index = 0; index < (g_video_rtp_reorder_buff_info.total_pkt-match_index); index++)
{
g_video_rtp_reorder_buff_info.sequence[g_video_rtp_reorder_buff_info.total_pkt - index] = g_video_rtp_reorder_buff_info.sequence[g_video_rtp_reorder_buff_info.total_pkt - index - 1];
g_video_rtp_reorder_buff_info.start_addr[g_video_rtp_reorder_buff_info.total_pkt - index] = g_video_rtp_reorder_buff_info.start_addr[g_video_rtp_reorder_buff_info.total_pkt - index - 1];
g_video_rtp_reorder_buff_info.buffer_size[g_video_rtp_reorder_buff_info.total_pkt - index] = g_video_rtp_reorder_buff_info.buffer_size[g_video_rtp_reorder_buff_info.total_pkt - index - 1];
}
/* add the input packet */
g_video_rtp_reorder_buff_info.sequence[match_index] = sequence;
g_video_rtp_reorder_buff_info.start_addr[match_index] = (kal_uint32)p_buffer;
g_video_rtp_reorder_buff_info.buffer_size[match_index] = size;
kal_mem_cpy(p_buffer, data, size);
g_video_rtp_reorder_buff_info.total_pkt++;
}
void FtFreeExtMemory(void* ptr)
{
if(ft_ext_mem_pool_id > 0)
{
kal_adm_free(ft_ext_mem_pool_id, ptr);
}
}
/*------------------------------------------------------------------------------
Function name: H264SwDecFree
Purpose:
Example implementation of H264SwDecFree function. Prototype of this
function is given in H264SwDecApi.h. This implementation uses
library function free for freeing of memory.
------------------------------------------------------------------------------*/
static void VideoH264DecFree(void *ptr)
{
drv_trace1(TRACE_GROUP_10,OPEN_API_SW_FREEMEMORY,(kal_uint32)ptr);
if (rH264SwCtrl.pAdmId == NULL)
{
ASSERT(0);
}
if (ptr != NULL)
{
kal_adm_free(rH264SwCtrl.pAdmId, (kal_uint8*)ptr);
}
}
/* if buffer is full, also pop up the first packet */
kal_uint8* video_rtp_reorder_get_pkt(kal_uint32 sequence, kal_uint32 *p_size, kal_uint32 *p_sequnce)
{
kal_uint8 *p_data;
kal_uint32 index;
/* free previous got buffer memory */
if(g_video_rtp_reorder_buff_info.p_free_addr !=NULL)
{
kal_adm_free(g_video_rtp_reorder_buff_info.adm_id, g_video_rtp_reorder_buff_info.p_free_addr);
g_video_rtp_reorder_buff_info.p_free_addr = NULL;
}
kal_prompt_trace(MOD_MED, "video_rtp_reorder_get_pkt: totalPkt(%d), seq(%d), seq[0](%d), bufferFull(%d)\n",
g_video_rtp_reorder_buff_info.total_pkt, sequence, g_video_rtp_reorder_buff_info.sequence[0], g_video_rtp_reorder_buff_info.b_buffer_full);
/* check whether it is needed to dequeue the first item from re-order buffer */
if((g_video_rtp_reorder_buff_info.total_pkt == VIDEO_RTP_MAX_REORDER_NUM)
|| ((g_video_rtp_reorder_buff_info.total_pkt > 0 ) && ((g_video_rtp_reorder_buff_info.sequence[0] == sequence)||(sequence == 0xffffffff)||(g_video_rtp_reorder_buff_info.b_buffer_full == KAL_TRUE)))
)
{
/* retrun the first packet from queue */
g_video_rtp_reorder_buff_info.p_free_addr = (kal_uint8*)g_video_rtp_reorder_buff_info.start_addr[0];
p_data = (kal_uint8*)g_video_rtp_reorder_buff_info.start_addr[0];
*p_size = g_video_rtp_reorder_buff_info.buffer_size[0];
*p_sequnce = g_video_rtp_reorder_buff_info.sequence[0];
g_video_rtp_reorder_buff_info.total_pkt--;
if(g_video_rtp_reorder_buff_info.total_pkt >= VIDEO_RTP_MAX_REORDER_NUM)
ASSERT(0);
g_video_rtp_reorder_buff_info.b_buffer_full = KAL_FALSE;
for(index = 0; index < g_video_rtp_reorder_buff_info.total_pkt; index++)
{
g_video_rtp_reorder_buff_info.sequence[index] = g_video_rtp_reorder_buff_info.sequence[index+1];
g_video_rtp_reorder_buff_info.start_addr[index] = g_video_rtp_reorder_buff_info.start_addr[index+1];
g_video_rtp_reorder_buff_info.buffer_size[index] = g_video_rtp_reorder_buff_info.buffer_size[index+1];
}
return g_video_rtp_reorder_buff_info.p_free_addr;
}
else
{
/* no packet is dequeded */
*p_size = 0;
*p_sequnce = 0;
return NULL;
}
}
/*****************************************************************************
* FUNCTION
* med_aud_sfree
* DESCRIPTION
*
* PARAMETERS
* ptr [IN]
* RETURNS
* void
*****************************************************************************/
void med_aud_sfree(address_t ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (ptr!=NULL)
{
kal_adm_free(g_med_ext_mem_cntx.aud_mem_pool_id, ptr);
g_med_ext_mem_cntx.aud_mem_alloc_count--;
g_med_ext_mem_cntx.aud_mem_left_size = kal_adm_get_total_left_size(g_med_ext_mem_cntx.aud_mem_pool_id);
MED_FREE_MEM_INFO_AUD(g_med_ext_mem_cntx.aud_mem_left_size, ptr, g_med_ext_mem_cntx.aud_mem_alloc_count );
}
}
/* the pkts in reorder buffer is valid or not. (invalid pkts are from previous sessions */
kal_uint32 video_rtp_reorder_check_pkt(kal_uint32 start_seq, kal_uint32 thre)
{
kal_uint32 i,j,diff, framecnt=0;
kal_prompt_trace(MOD_MED, "video_rtp_reorder_check_pkts: %d, %d\n", start_seq, thre);
#ifdef __STREAM_TRACE_ON__
{
extern kal_int32 video_dec_show_buffer_trace(kal_int32 mode);
framecnt = video_dec_show_buffer_trace(0); // 0 for streaming
//if (framecnt !=0) {
// kal_prompt_trace(MOD_MED, "video_rtp_clr_buffer_before_chk_pkts: %d\n", framecnt);
// video_dec_clr_buffer(0, 0xffff);
//}
}
#endif
for (i = 0; i < g_video_rtp_reorder_buff_info.total_pkt; i++)
{
if (start_seq > g_video_rtp_reorder_buff_info.sequence[i])
diff = start_seq - g_video_rtp_reorder_buff_info.sequence[i];
else
diff = g_video_rtp_reorder_buff_info.sequence[i] - start_seq;
if (diff > thre) {
kal_prompt_trace(MOD_MED, "video_rtp_reorder_check_pkts: Beyond Thre %d\n", g_video_rtp_reorder_buff_info.sequence[i]);
g_video_rtp_reorder_buff_info.sequence[i] = 0xfffffffe;
} else {
kal_prompt_trace(MOD_MED, "video_rtp_reorder_check_pkts: Within Thre %d\n", g_video_rtp_reorder_buff_info.sequence[i]);
}
}
i = 0;
while (i<g_video_rtp_reorder_buff_info.total_pkt)
{
if (g_video_rtp_reorder_buff_info.sequence[i] == 0xfffffffe)
{
kal_uint8 *p = (kal_uint8*)g_video_rtp_reorder_buff_info.start_addr[i];
if(p !=NULL)
{
kal_adm_free(g_video_rtp_reorder_buff_info.adm_id, p);
}
for (j = i+1; j < g_video_rtp_reorder_buff_info.total_pkt; j++)
{
if (g_video_rtp_reorder_buff_info.sequence[i] != 0xfffffffe)
break;
}
if (j<g_video_rtp_reorder_buff_info.total_pkt)
{
g_video_rtp_reorder_buff_info.sequence[i] = g_video_rtp_reorder_buff_info.sequence[j];
g_video_rtp_reorder_buff_info.start_addr[i] = g_video_rtp_reorder_buff_info.start_addr[j];
g_video_rtp_reorder_buff_info.buffer_size[i] = g_video_rtp_reorder_buff_info.buffer_size[j];
g_video_rtp_reorder_buff_info.sequence[j] = 0xfffffffe;
g_video_rtp_reorder_buff_info.start_addr[j] = 0;
g_video_rtp_reorder_buff_info.buffer_size[j] = 0;
} else {
g_video_rtp_reorder_buff_info.total_pkt = i;
break;
}
}
i++;
}
g_video_rtp_reorder_buff_info.b_init_done = KAL_TRUE;
return i;
}
/*****************************************************************************
* FUNCTION
* jbt_cmd_check_device_in_queue
* DESCRIPTION
*
* PARAMETERS
* cmd_opcode [IN]
* RETURNS
*
*****************************************************************************/
kal_bool jbt_cmd_check_device_in_queue(kal_uint8 cmd_opcode)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
JBT_cmd_node *node = 0;
kal_bool status = KAL_FALSE;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_JBT_RESULT, 0xB1);
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_CHECK_DEVICE_IN_QUEUE_CMD_OPCODExD, cmd_opcode);
node = jbt_cmd_check_and_remove_in_queue(cmd_opcode);
if (node != 0)
{
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_CHECK_DEVICE_IN_QUEUE_NODE_NOT_0);
switch (cmd_opcode)
{
case JBT_CMDCODE_DEVICE_DISCOVERY_CMD:
{
bt_bm_discovery_cancel_cnf_struct *msg;
msg = (bt_bm_discovery_cancel_cnf_struct*)
construct_local_para(sizeof(bt_bm_discovery_cancel_cnf_struct), TD_UL);
msg->result = BTBM_ADP_SUCCESS;
msg->total_number = 0;
jbt_send_msg(
MSG_ID_BT_BM_DISCOVERY_CANCEL_CNF,
MOD_JASYN,
MOD_JASYN,
BT_APP_SAP,
(local_para_struct*) msg,
NULL);
}
break;
case JBT_CMDCODE_GET_REMOTE_NAME:
{
bt_bm_read_remote_name_cnf_struct *msg;
jbt_gap_get_remote_name *info;
info = (jbt_gap_get_remote_name*) node->parms;
msg = (bt_bm_read_remote_name_cnf_struct*)
construct_local_para(sizeof(bt_bm_read_remote_name_cnf_struct), TD_UL);
msg->result = BTBM_ADP_FAILED;
msg->name_len = 0;
memset(msg->name, 0, BTBM_ADP_MAX_NAME_LEN);
msg->cod = 0;
jbt_ConvertToBdAddr(&(msg->bd_addr), info->addr);
jbt_send_msg(
MSG_ID_BT_BM_READ_REMOTE_NAME_CNF,
MOD_JASYN,
MOD_JASYN,
BT_APP_SAP,
(local_para_struct*) msg,
NULL);
}
break;
case JBT_CMDCODE_SET_LOCAL_COD:
{
bt_bm_write_local_cod_cnf_struct *msg;
msg = (bt_bm_write_local_cod_cnf_struct*)
construct_local_para(sizeof(bt_bm_write_local_cod_cnf_struct), TD_UL);
msg->result = BTBM_ADP_FAILED;
jbt_send_msg(
MSG_ID_BT_BM_WRITE_LOCAL_COD_CNF,
MOD_JASYN,
MOD_JASYN,
BT_APP_SAP,
(local_para_struct*) msg,
NULL);
}
break;
case JBT_CMDCODE_SET_ACL_SECURITY_INFO:
{
bt_jsr82_set_acl_security_cnf_struct *msg;
jbt_gap_set_security *info = (jbt_gap_set_security*) node->parms;
msg = (bt_jsr82_set_acl_security_cnf_struct*)
construct_local_para(sizeof(bt_jsr82_set_acl_security_cnf_struct), TD_UL);
msg->result = BTBM_ADP_FAILED;
msg->transaction_id = info->transaction_id;
memcpy(msg->bdAddr, info->addr, 6);
jbt_send_msg(
MSG_ID_BT_JSR82_SET_ACL_SECURITY_CNF,
MOD_JASYN,
MOD_JASYN,
BT_APP_SAP,
(local_para_struct*) msg,
NULL);
}
break;
default:
ASSERT(0);
}
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_CHECK_DEVICE_IN_QUEUE_NODEPARMS_08X, node->parms);
if (node->parms != 0)
{
jbt_free_record(node->parms);
#ifndef JBT_SUPPORT_ADM_MEM
jvm_free(node->parms);
#else
kal_adm_free(jbt_get_mem_pool_id(),node->parms);
#endif
}
node->parms = 0;
node->cmd_code = 0;
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_CHECK_DEVICE_IN_QUEUE_JBT_CMD_LIST_INIT);
jbt_cmd_list_init(node);
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_CHECK_DEVICE_IN_QUEUE_JBT_CMD_LIST_INSERT_TAIL);
jbt_cmd_list_insert_tail(&jbt_cmd_queue_context.empty_list, node);
status = KAL_TRUE;
}
return status;
}
/*****************************************************************************
* FUNCTION
* jbt_cmd_queue_nonconcurrent_processing
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void jbt_cmd_queue_nonconcurrent_processing(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
JBT_cmd_node *node;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_take_sem(jbt_cmd_process_sem, KAL_INFINITE_WAIT);
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_QUEUE_NONCONCURRENT_PROCESSING);
if (jbt_cmd_queue_context.cmd_run_no < JBT_MAX_COMMAND_NO)
{
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_LIST_REMOVE_HEAD);
node = jbt_cmd_list_remove_head(&jbt_cmd_queue_context.cmd_list);
jbt_cmd_queue_context.cmd_run_no++;
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_QUEUE_CONTEXTCMD_RUN_NOxD, jbt_cmd_queue_context.cmd_run_no);
kal_trace(TRACE_JBT_GROUP, JBT_NODECMD_CODExD, node->cmd_code);
switch (node->cmd_code)
{
case JBT_CMDCODE_DEVICE_RESTORE_COD:
jbt_set_local_cod_cmd_body(node->parms, BTBM_WRITE_COD_RESTORE);
break;
case JBT_CMDCODE_DEVICE_RESTORE_MMI:
break;
case JBT_CMDCODE_SET_LOCAL_COD:
jbt_set_local_cod_cmd_body(node->parms, BTBM_WRITE_COD_MASK);
break;
case JBT_CMDCODE_GET_REMOTE_NAME:
jbt_get_remote_name_cmd_body(node->parms);
break;
case JBT_CMDCODE_DEVICE_DISCOVERY_CMD:
jbt_device_discovery_cmd_body(node->parms);
break;
/* Add 2007-1119 */
case JBT_CMDCODE_SET_ACL_SECURITY_INFO:
jbt_set_acl_security_cmd_body(node->parms);
break;
default:
ASSERT(0);
break;
}
if (node->parms != 0)
{
jbt_free_record(node->parms);
#ifndef JBT_SUPPORT_ADM_MEM
jvm_free(node->parms);
#else
kal_adm_free(jbt_get_mem_pool_id(),node->parms);
#endif
}
node->parms = 0;
node->cmd_code = 0;
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_LIST_INIT);
jbt_cmd_list_init(node);
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_LIST_INSERT_TAIL);
jbt_cmd_list_insert_tail(&jbt_cmd_queue_context.empty_list, node);
}
kal_give_sem(jbt_cmd_process_sem);
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_QUEUE_NONCONCURRENT_PROCESSING_END);
}
/*****************************************************************************
* FUNCTION
* jbt_cmd_handle_restore
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void jbt_cmd_handle_restore(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint8 i = 0;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_JBT_RESULT, 0xA1);
/* TODO the check range may be furthur optimized. we only need to check specific non-concurrent commands */
for (i = JBT_CMDCODE_GET_LOCAL_NAME; i < JBT_CMDCODE_DEVICE_DISCOVERY_CMD_CANCEL; i++)
{
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_HANDLE_RESTORE_INDEXx02X, i);
jbt_cmd_check_device_in_queue(i);
}
kal_trace(
TRACE_JBT_GROUP,
JBT_JBT_CMD_HANDLE_RESTORE_JBT_CMD_QUEUE_CONTEXTCMD_RUN_NOx02X,
jbt_cmd_queue_context.cmd_run_no);
if (jbt_cmd_queue_context.cmd_run_no == 0)
{
jbt_restore_procedure(JBT_CMD_SUCCESS);
}
else
{
/* Add check: If JBT is in POWER_OTHERS state (caused by VM finalize), if there is an inquiry ongoing, just cancels it */
if (jbt_gap_power_state() == JBT_POWER_OTHERS)
{
jbt_op_info *discovery_operation = jbt_gap_obtain_operation(JBT_CMDCODE_DEVICE_DISCOVERY_CMD);
if (discovery_operation->operation_state == JBT_OPERATION_DISCOVERY_SEARCHING)
{
/* Existing an ongoing discovery operation, sends discovery cancel cmd to btstack to speed the process of VM termination */
jbt_gap_device_discovery_cancel *parms;
kal_uint32 jbt_gap_device_discovery_cancel_size = sizeof(jbt_gap_device_discovery_cancel);
kal_uint8 block_inx = 0;
/*
* DONT invoke the function jbt_device_discovery_cancel_cmd() directly:
* Because JBT is not power_on status during VM termination, if invoking this function will return failure
*/
block_inx = jbt_malloc_block(jbt_gap_device_discovery_cancel_size);
#ifndef JBT_SUPPORT_ADM_MEM
parms = (jbt_gap_device_discovery_cancel*) jvm_malloc(jbt_gap_device_discovery_cancel_size);
#else
parms = (jbt_gap_device_discovery_cancel*) kal_adm_alloc(jbt_get_mem_pool_id(),jbt_gap_device_discovery_cancel_size);
#endif
if (parms != 0)
{
kal_trace(TRACE_JBT_GROUP, FUNC_JBT_CANCEL_INQUIRY_DUE_TO_VM_TERMINATE);
jbt_malloc_record(block_inx, (kal_uint8*)parms, jbt_gap_device_discovery_cancel_size);
parms->transaction_id = discovery_operation->transaction_id;
kal_trace(TRACE_JBT_GROUP, JBT_JBT_CMD_INSERT_QUEUE);
jbt_cmd_insert_queue(
JBT_CMDCODE_DEVICE_DISCOVERY_CMD_CANCEL,
JBT_STACK_CMD_CONCURRENT,
(kal_uint8*) parms);
jbt_free_record((kal_uint8*) parms);
#ifndef JBT_SUPPORT_ADM_MEM
jvm_free((kal_uint8*) parms);
#else
kal_adm_free(jbt_get_mem_pool_id(),(kal_uint8*) parms);
#endif
}
else
{
/* Failed of jvm_malloc() */
jbt_free_block(block_inx);
kal_trace(TRACE_JBT_GROUP, FUNC_JBT_CANCEL_INQUIRY_FAILED_WHILE_VM_TERMINATE);
}
}
}
}
}
