/*****************************************************************************
* FUNCTION
* l4c_nw_reg_state_mind
* DESCRIPTION
*
* PARAMETERS
*
* RETURNS
* void
*****************************************************************************/
void l4c_nw_reg_state_mind(kal_uint8 gsm_state, kal_uint8 gprs_state, kal_uint32 cause)
{
kal_uint16 infBuffSize = 0;
kal_uint8 *infBuff = NULL;
mbci_context_struct *mbci_ptr = MBCI_PTR;
mbci_ptr->NwError = cause;
if (MBCI_PTR->state != MBCI_STATE_OPEN)
{
return;
}
// CS registration state
if (mbci_ptr->gsm_state != gsm_state)
{
infBuff = (kal_uint8*)get_ctrl_buffer(sizeof(mbim_registration_state_info_struct) + 64); // 64 byte reserve for ProviderId and ProviderName
infBuffSize = mbci_get_registration_state_info(MBCI_SRC, (kal_uint8*)infBuff);
mbci_status_ind(MBIM_CID_REGISTER_STATE, MBIM_UUID_BASIC_CONNECT, infBuffSize, infBuff);
free_ctrl_buffer(infBuff);
}
// PS packet service state
if (mbci_ptr->gprs_state != gprs_state)
{
infBuff = (kal_uint8*)get_ctrl_buffer(sizeof(mbim_packet_service_info_struct));
infBuffSize = mbci_get_packet_service_info(MBCI_SRC, (kal_uint8*)infBuff);
mbci_status_ind(MBIM_CID_PACKET_SERVICE, MBIM_UUID_BASIC_CONNECT, infBuffSize, infBuff);
free_ctrl_buffer(infBuff);
}
mbci_ptr->gsm_state = gsm_state;
mbci_ptr->gprs_state = gprs_state;
}
S32 btmtk_goep_fs_findend(void *ptr) {
bt_ftp_find_struct *pfind;
pfind = (bt_ftp_find_struct *) ptr;
#if defined(BTMTK_ON_WISE)
if( NULL != pfind ) {
FS_FindClose( (FS_HANDLE) pfind->hFile);
pfind->hFile = 0;
free_ctrl_buffer( pfind );
}
#endif
#ifdef BTMTK_GOEP_USE_WIN32_FS
_findclose(pfind->hFile);
_wchdir( (const U16 *) g_oldcwd );
if( NULL != ptr )
free( ptr );
#endif
#ifdef BTMTK_ON_LINUX
closedir(g_opened_dir);
#endif
return EXT_FS_OK;
}
/*****************************************************************************
* FUNCTION
* format_asking_string
* DESCRIPTION
* Add mid_name and "?" into string.
* PARAMETERS
* string_id [IN] String ID
* RETURNS
*
*****************************************************************************/
static PU8 format_asking_string(U16 string_id)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int32 string_len = mmi_ucs2strlen(GetString(string_id));
kal_wchar *mid_name = get_running_mid_name();
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (mid_name == NULL)
{
mid_name = (kal_wchar*) GetString(STR_SCR_JAVA_CAPTION);
}
if (asking_string_buffer != NULL)
{
free_ctrl_buffer(asking_string_buffer);
}
asking_string_buffer = (kal_wchar*) get_ctrl_buffer((string_len + mmi_ucs2strlen((S8*) mid_name) + 2) << 1);
mmi_ucs2cpy((S8*) asking_string_buffer, GetString(string_id));
mmi_ucs2cpy((S8*) (asking_string_buffer + string_len), (S8*) mid_name);
string_len += mmi_ucs2strlen((S8*) mid_name);
asking_string_buffer[string_len] = '?';
asking_string_buffer[string_len + 1] = 0;
return (PU8) asking_string_buffer;
}
/**
* Get Path for requested size
*/
kal_int16 FT_GetAvailableDrive(kal_int32 size)
{
#if !defined(__LOW_COST_SUPPORT_ULC__)
kal_int16 drv_letter = -1;
kal_int16 i = 0;
kal_uint32 dev[4] = {FS_DRIVE_I_SYSTEM, FS_DRIVE_V_NORMAL, FS_DRIVE_V_REMOVABLE, FS_DRIVE_V_EXTERNAL};
kal_wchar *pathname = NULL;
pathname = (kal_wchar*)get_ctrl_buffer(FT_FAT_MAX_FULLPATH);
if(pathname)
{
for(i=0;i<4;i++)
{
drv_letter = FS_GetDrive(dev[i], 1, FS_NO_ALT_DRIVE);
if(drv_letter > 0)
{
kal_wsprintf(pathname, "%c:\\", drv_letter);
if(size < FT_GetDiskFreeSpace(pathname))
{
break;
}
}
}
}
else
{
ASSERT(0);
}
free_ctrl_buffer(pathname);
return drv_letter;
#else // #if !defined(__LOW_COST_SUPPORT_ULC__)
return -1;
#endif // #if defined(__LOW_COST_SUPPORT_ULC__)
}
/*****************************************************************************
* FUNCTION
* tcm_config_packets_trim
* DESCRIPTION
* This procedure trims config options.
*
* PARAMETERS
* si_db_ptr IN Pointer to SIB
* trim_after_nodes IN nodes
* RETURNS
* void
* GLOBALS AFFECTED
* N/A
*****************************************************************************/
void tcm_config_packets_trim ( SESSION_INFO_PTR si_db_ptr,
kal_uint8 trim_after_nodes
)
{
tcm_protocol_config_packet_struct *head_node_ptr = NULL;
tcm_protocol_config_packet_struct *node_to_delete_ptr = NULL;
tcm_protocol_config_packet_struct *first_node = NULL;
kal_uint8 nodes_count = 1;
head_node_ptr = &si_db_ptr->prot_options_struct;
while (nodes_count < trim_after_nodes)
{
nodes_count = nodes_count + 1;
head_node_ptr = head_node_ptr->next_ptr;
}
/* Add 03.08.05 for memory leak */
first_node = head_node_ptr;
head_node_ptr = head_node_ptr->next_ptr;
while ( head_node_ptr != NULL )
{
node_to_delete_ptr = head_node_ptr;
head_node_ptr = head_node_ptr->next_ptr;
// kal_prompt_trace(MOD_TCM, "tcm_config_packets_trim free: %x", node_to_delete_ptr);// Carlson temp add, can remove this
free_ctrl_buffer(node_to_delete_ptr);
}
first_node->next_ptr = NULL;
return;
}
kal_int32 init_gt818_download_module( kal_uint16 cur_ver, kal_uint8 *firmware_ptr )
{
kal_int32 ret = 0;
outbuf = (kal_uint8 *)get_ctrl_buffer( MAX_BUFFER_LEN );
inbuf = (kal_uint8 *)get_ctrl_buffer( MAX_BUFFER_LEN );
dbgbuf = (kal_char *)get_ctrl_buffer( MAX_BUFFER_LEN );
if ( ( outbuf == NULL ) ||
( inbuf == NULL ) ||
( dbgbuf == NULL ) )
{
EXT_ASSERT(0, (kal_uint32)outbuf, (kal_uint32)inbuf, (kal_uint32)dbgbuf);
return 0;
}
CTP_DWN_DEBUG_LINE_TRACE();
//rst_handle = DclGPIO_Open(DCL_GPIO, GPIO_CTP_SHUTDN_PIN);
//int_handle = DclGPIO_Open(DCL_GPIO, GPIO_CTP_INT_PIN);
int_handle = DclGPIO_Open(DCL_GPIO, gpio_ctp_eint_pin);
rst_handle = DclGPIO_Open(DCL_GPIO, gpio_ctp_reset_pin);
DclGPIO_Control(rst_handle, GPIO_CMD_SET_MODE_0, NULL);
DclGPIO_Control(int_handle, GPIO_CMD_SET_MODE_0, NULL);
DclGPIO_Control(int_handle, GPIO_CMD_SET_DIR_OUT, NULL);
ret = gt818_downloader_probe( cur_ver, firmware_ptr );
//DclGPIO_Control(int_handle, GPIO_CMD_SET_DIR_IN, NULL);
//DclGPIO_Control(int_handle, GPIO_CMD_SET_MODE_1, NULL);
DclGPIO_Control(int_handle, GPIO_CMD_WRITE_HIGH, NULL);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);
kal_sleep_task(5);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_LOW, NULL);
kal_sleep_task(5);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);
kal_sleep_task(120);
free_ctrl_buffer( outbuf );
free_ctrl_buffer( inbuf );
free_ctrl_buffer( dbgbuf );
if ( downloader_errno )
EXT_ASSERT( 0, downloader_errno, 0, 0 );
return ret;
}
/*****************************************************************************
* FUNCTION
* tp_ps_handling_at_indication
* DESCRIPTION
* This function is used to handle the response/URC data from MOD_ATCI
*
* PARAMETERS
* channelId [IN]
* buf [IN]
* iDataLen [IN]
*
* RETURNS
* void
*****************************************************************************/
static void tp_ps_handling_at_indication(kal_uint8 channelId, kal_char *buf, kal_uint16 iDataLen)
{
kal_char *data;
if (tp_callback == NULL || tp_port_begin == -1)
{
if (tp_callback == NULL)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] ERROR: havn't register TP callback function");
}
else if (tp_port_begin == -1)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] ERROR: havn't start PS, please call tp_ps_start first");
}
// buffer the URC
if (channelId == RMMI_MSG_BASED_URC_CHANNEL)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] Buffer the URC: %s", buf);
if ( (tp_urc_buffer_len + iDataLen) > MAX_TP_URC_BUFFER_LENGTH)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] URC buffer is full, clean the buffer", buf);
tp_urc_buffer_len = 0;
}
if (iDataLen > MAX_TP_URC_BUFFER_LENGTH)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] ERROR: the URC is too large, please increase the URC buffer");
}
else
{
kal_mem_cpy(tp_urc_buffer+tp_urc_buffer_len, buf, iDataLen);
tp_urc_buffer_len += iDataLen;
}
}
}
else
{
data = get_ctrl_buffer(iDataLen);
kal_mem_cpy(data, buf, iDataLen);
tp_callback(channelId, data, iDataLen, 1);
free_ctrl_buffer(data);
}
}
/*****************************************************************************
* FUNCTION
* jpush_alarm_del
* DESCRIPTION
* Delete one entry from the alarm registry.
* If the entry can not be found, return -1.
* On succesful deletion, write a new copy of the file to disk.
* PARAMETERS
* del_alarm [?]
* RETURNS
*
*****************************************************************************/
kal_int32 jpush_alarm_del(alarmentry_struct *del_alarm)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
alarmentry_struct *alarmp = g_jpush_alarmlist_ptr;
alarmentry_struct *lastp;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* Check if the entry already exists? */
kal_trace(TRACE_FUNC, JPUSH_ALARM_DEL);
jpush_timer_mutex_lock();
for (lastp = alarmp; alarmp != NULL; alarmp = alarmp->next)
{
if (del_alarm == alarmp)
{
/* Remove an entry. */
if (alarmp == g_jpush_alarmlist_ptr)
{
g_jpush_alarmlist_ptr = alarmp->next;
}
else
{
lastp->next = alarmp->next;
}
alarmp->next = NULL;
free_ctrl_buffer(alarmp->midlet);
alarmp->midlet = NULL;
free_ctrl_buffer(alarmp->storagename);
alarmp->storagename = NULL;
alarmp->event_id = NULL;
free_ctrl_buffer(alarmp);
jpush_alarm_save();
jpush_timer_mutex_unlock();
return (0);
}
lastp = alarmp;
}
jpush_timer_mutex_unlock();
return (-1);
}
static Media_Status GenCompRecClose( MHdl *hdl )
{
MHPB_Internal *ihdl = (MHPB_Internal *)hdl;
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_CLOSE, hdl->mediaType, hdl, hdl->state,0,0,0,0,0);
ASSERT( hdl != 0 );
if (hdl->state == COMPONENT_STATE_PLAY) {
hdl->Stop(hdl);
}
// Deinit component
{
AcHdlNode *pNode = ihdl->pNodeStart;
while (pNode) {
pNode->curHdl->Deinit( pNode->curHdl );
if (pNode->pAllocBuf) {
audio_free_mem( (void **) &pNode->pAllocBuf);
}
pNode = pNode->pNextNode;
}
}
// Wav only
if (ihdl->pPublicInfo) {
free_ctrl_buffer( ihdl->pPublicInfo );
}
// Free memory
if (ihdl->pAllocBuf) {
if (ihdl->fIspAllocBufOnMED) {
audio_free_mem( (void **) &ihdl->pAllocBuf);
} else {
free_ctrl_buffer(ihdl->pAllocBuf);
ihdl->pAllocBuf = NULL;
}
}
mhdlFinalize(hdl, NULL);
free_ctrl_buffer( hdl );
return MEDIA_SUCCESS;
}
void SP_Strm_Disable( void )
{
#if !defined(SS_UNIT_TEST)
UART_CTRL_CLOSE_T data;
data.u4OwenrId = MOD_MED;
DclSerialPort_Control( intSStrmControl->cmux_handle, SIO_CMD_CLOSE, (DCL_CTRL_DATA_T*)&data);
#endif
free_ctrl_buffer(intSStrmControl);
intSStrmControl = NULL;
L1SP_UnRegister_Strm_Handler();
}
/*****************************************************************************
* FUNCTION
* jpush_alarm_free
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void jpush_alarm_free()
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
alarmentry_struct *alarmp, *alarmtmp;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* clean up the list */
jpush_timer_mutex_lock();
for (alarmp = g_jpush_alarmlist_ptr; alarmp != NULL; alarmp = alarmtmp)
{
alarmtmp = alarmp->next;
free_ctrl_buffer(alarmp->midlet);
free_ctrl_buffer(alarmp->storagename);
free_ctrl_buffer(alarmp);
}
jpush_timer_mutex_unlock();
}
static BOOL mmi_da_wps_send_set_channel_req(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
wps_set_channel_req_struct *set_channel_req;
peer_buff_struct *peer_buff_ptr = NULL;
wps_set_channel_req_var_struct set_channel_req_var;
U16 len, pdu_length;
U16 msg_len, ref_count;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_SET_CHANNEL_REQ);
set_channel_req = (wps_set_channel_req_struct *) construct_local_para(sizeof(wps_set_channel_req_struct), TD_CTRL);
msg_len = set_channel_req->msg_len;
ref_count = set_channel_req->ref_count;
memset(set_channel_req, 0 , sizeof(wps_set_channel_req_struct));
set_channel_req->msg_len = msg_len;
set_channel_req->ref_count = ref_count;
set_channel_req->use_default = KAL_TRUE;
set_channel_req_var.static_header_len = len =
strlen("User-Agent: ")+
strlen((S8*)da_wps_context.user_agent)+
strlen("\r\n")+
strlen(STATIC_HEADER);
set_channel_req_var.static_header = get_ctrl_buffer((len+1));
sprintf((S8*)set_channel_req_var.static_header,"User-Agent: %s\r\n%s",
da_wps_context.user_agent, STATIC_HEADER);
pdu_length= wps_pun_var_part(WPS_PUN_SIZE,MSG_ID_WPS_SET_CHANNEL_REQ,&set_channel_req_var,NULL);
if( pdu_length > 0)
{
peer_buff_ptr = construct_peer_buff(pdu_length, 0, 0, TD_RESET);
if (wps_pun_var_part(WPS_PUN_PACK, MSG_ID_WPS_SET_CHANNEL_REQ, &set_channel_req_var, get_pdu_ptr(peer_buff_ptr, &len)) !=
pdu_length)
{
free_peer_buff(peer_buff_ptr);
peer_buff_ptr = NULL;
}
}
free_ctrl_buffer(set_channel_req_var.static_header);
mmi_da_send_ilm(set_channel_req, peer_buff_ptr, MSG_ID_WPS_SET_CHANNEL_REQ, MOD_WPS);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_set_channel_rsp, MSG_ID_WPS_SET_CHANNEL_RSP);
return MMI_TRUE;
}
/*****************************************************************************
* FUNCTION
* _aud_trim_close
* DESCRIPTION
* This function is to release all the allocated resources for the opened
* trim handler.
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
static void _aud_trim_close(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
Media_Status drv_result;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* Directly return if the trim handle is not opened */
if (!g_is_trim_opened)
{
return;
}
/* Close MHdl handler */
if (g_trim_ctx.mhdl_handle_p)
{
/* Close MHdl handler */
drv_result = g_trim_ctx.mhdl_handle_p->Close(g_trim_ctx.mhdl_handle_p);
_AUD_TRIM_TRACE(drv_result, g_trim_ctx.mhdl_handle_p, -1);
g_trim_ctx.mhdl_handle_p = NULL;
}
/* Free FSAL resources */
if (g_trim_ctx.is_fsal_opened)
{
/* Free buffer */
if (g_trim_ctx.fsal_handle.bBuffering && g_trim_ctx.fsal_handle.pbBuf != NULL)
{
free_ctrl_buffer(g_trim_ctx.fsal_handle.pbBuf);
}
/* Close FSAL handler */
FSAL_Close(&g_trim_ctx.fsal_handle);
g_trim_ctx.is_fsal_opened = KAL_FALSE;
}
/* Close file output handle */
if (g_trim_ctx.file_output >= 0)
{
FS_Close(g_trim_ctx.file_output);
g_trim_ctx.file_output = -1;
}
g_is_trim_opened = KAL_FALSE;
}
void BleServiceDbUnloadRecord(void)
{
if (BleDbCtx(loadCount) == 1)
{
BT_GattUnregisterConnectedEvent(&BleDbCtx(gattHandler));
ATTDB_UnRegisterBondStatus(&BleDbCtx(bondingHandler));
while (!IsListEmpty(&BleDbCtx(servicedbList)))
{
free_ctrl_buffer(RemoveHeadList(&BleDbCtx(servicedbList)));
}
}
BleDbCtx(loadCount)--;
}
/*****************************************************************************
* FUNCTION
* l4c_sms_new_msg_pdu_mind
* DESCRIPTION
*
* PARAMETERS
*
* RETURNS
* void
*****************************************************************************/
void l4c_sms_new_msg_pdu_mind(kal_uint8 mti, void *data, kal_uint16 packed_peer_buff_len)
{
if (MBCI_PTR->state != MBCI_STATE_OPEN)
{
return;
}
if (mti == SMSAL_MTI_DELIVER)
{
kal_uint16 infBuffSize = 0;
kal_uint8 *infBuff = NULL;
mbim_sms_read_info_struct ind;
MBIM_OL_PAIR_LIST SmsRefList;
mbim_sms_pdu_record_struct pdu;
infBuffSize = sizeof(ind) + sizeof(SmsRefList) + sizeof(pdu);
infBuff = (kal_uint8*)get_ctrl_buffer(infBuffSize);
ind.Format = MBIMSmsFormatPdu;
ind.ElementCount = 1;
SmsRefList.offset = sizeof(ind);
SmsRefList.size = sizeof(pdu);
pdu.MessageIndex = MBIM_MESSAGE_INDEX_NONE;
pdu.MessageStatus = MBIMSmsStatusNew;
pdu.PduDataOffset = 16;
if (packed_peer_buff_len <= 183)
{
pdu.PduDataSize = packed_peer_buff_len;
}
else
{
DEBUG_ASSERT(0);
pdu.PduDataSize = 183;
}
kal_mem_cpy((void*)pdu.DataBuffer, data, pdu.PduDataSize);
// Copy to infBuff
mbci_infBuff_cpy(infBuff, 0, sizeof(ind), (void*)&ind);
mbci_infBuff_cpy(infBuff, sizeof(ind), sizeof(SmsRefList), (void*)&SmsRefList);
mbci_infBuff_cpy(infBuff, sizeof(ind) + sizeof(SmsRefList), sizeof(pdu), (void*)&pdu);
mbci_status_ind(MBIM_CID_SMS_READ, MBIM_UUID_SMS, infBuffSize, infBuff);
free_ctrl_buffer(infBuff);
}
}
//=============== local buffer process =========================
void ft_misc_cal_data_free_alloc_buf(void)
{
if(p_ft_misc_buf) // free the buffer
{
if(b_ft_misc_buf_from_med) // free the buffer we borrow from MED task
{
FtFreeExtMemory(p_ft_misc_buf);
}
else // free the control buffer
{
free_ctrl_buffer(p_ft_misc_buf);
}
p_ft_misc_buf = NULL;
}
}
static Media_Status GenCompClose( MHdl *hdl )
{
MHPB_Internal *ihdl = (MHPB_Internal *)hdl;
kal_int32 I;
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_CLOSE, hdl->mediaType, hdl, hdl->state,0,0,0,0,0);
ASSERT( hdl != 0 );
if(hdl->state == COMPONENT_STATE_PLAY)
{
hdl->Stop(hdl);
}
// Deinit component
for (I=ihdl->numComp-1; I>=0; I--)
{
ihdl->NodeArray[I].curHdl->Deinit(ihdl->NodeArray[I].curHdl);
}
// Wav only
if (ihdl->pPublicInfo) {
free_ctrl_buffer( ihdl->pPublicInfo );
}
// Free memory
if (ihdl->pAllocBuf) {
if (ihdl->fIspAllocBufOnMED) {
audio_free_mem( (void **) &ihdl->pAllocBuf);
} else {
free_ctrl_buffer(ihdl->pAllocBuf);
ihdl->pAllocBuf = NULL;
}
}
mhdlFinalize(hdl, NULL);
free_ctrl_buffer( hdl );
return MEDIA_SUCCESS;
}
extern void asnMemFree(void ** ppBuffer)
{
/**
* For MCDDLL, malloc() from C Standard Library is used;
* otherwise, memory allocation from KAL is used.
*/
if(NULL == *ppBuffer)
return;
#ifdef MCD_DLL_EXPORT
free(*ppBuffer);
#else
free_ctrl_buffer(*ppBuffer);
#endif
*ppBuffer = NULL;
}
/*****************************************************************************
* FUNCTION
* free_asking_string
* DESCRIPTION
* Free the memory of asking string
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
static void free_asking_string(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (asking_string_buffer != NULL)
{
free_ctrl_buffer(asking_string_buffer);
}
asking_string_buffer = NULL;
}
/*****************************************************************************
* FUNCTION
* l4c_sim_status_update_mind
* DESCRIPTION
*
* PARAMETERS
*
* RETURNS
* void
*****************************************************************************/
void l4c_sim_status_update_mind()
{
kal_uint16 infBuffSize;
kal_uint8 *infBuff = NULL;
if (MBCI_PTR->state != MBCI_STATE_OPEN)
{
return;
}
infBuff = (kal_uint8*)get_ctrl_buffer(sizeof(mbim_subscriber_ready_info_struct) + sizeof(mbim_subscriber_ready_info_databuffer_struct));
infBuffSize = mbci_get_subscriber_ready_info(MBCI_SRC, infBuff, sizeof(mbim_subscriber_ready_info_struct) + sizeof(mbim_subscriber_ready_info_databuffer_struct));
mbci_status_ind(MBIM_CID_SUBSCRIBER_READY_STATUS, MBIM_UUID_BASIC_CONNECT, infBuffSize, infBuff);
free_ctrl_buffer(infBuff);
}
void BleServiceDbUpdateRecord(ble_service_db *servicedb)
{
S32 fd;
S32 pos_current;
S32 pos_end;
U32 mode = BTMTK_FS_READ_WRITE;
U8 *db_buff;
if (!btmtk_fs_is_dir_exist((const U8*)BLE_SERVICE_DATABASE_FILE))
{
mode |= BTMTK_FS_CREATE;
}
fd = btmtk_fs_open((const U8*)BLE_SERVICE_DATABASE_FILE, mode);
if (fd < 0)
{
return;
}
pos_end = btmtk_fs_seek(fd, 0, BTMTK_FS_SEEK_END);
pos_current = btmtk_fs_seek(fd, 0, BTMTK_FS_SEEK_BEGIN);
db_buff = (U8 *)get_ctrl_buffer(sizeof(ble_service_db) - sizeof(ListEntry));
while (pos_current < pos_end)
{
btmtk_fs_read(fd, db_buff, sizeof(ble_service_db) - sizeof(ListEntry));
if (OS_MemCmp(db_buff, 6, servicedb->bdAddr.addr, 6))
{
btmtk_fs_seek(fd, pos_current, BTMTK_FS_SEEK_BEGIN);
break;
}
pos_current += (sizeof(ble_service_db) - sizeof(ListEntry));
}
free_ctrl_buffer(db_buff);
Report(("[BleDB] Update record in file, seek offset: %d", pos_current));
// kal_trace(BT_TRACE_BLE_PROFILES, BLEDB_UPDATERECORD_OFFSET, pos_current);
btmtk_fs_write(fd, ((U8 *)servicedb) + sizeof(ListEntry), sizeof(ble_service_db) - sizeof(ListEntry));
btmtk_fs_close(fd);
}
static Media_Status pcmStrmMFClose( MHdl *hdl )
{
pcmStrmMediaHdl *ihdl = (pcmStrmMediaHdl *)hdl;
if (ihdl->pcmStrm.isPlayback) {
ASSERT( hdl != 0 && hdl->state != WAV_STATE_PLAYING);
mhdlFinalize( hdl, 0 );
} else {
ASSERT( hdl != 0 && hdl->state != WAV_STATE_RECORDING);
mhdlFinalize( hdl, 0 );
}
L1SP_PCMPlayback_ClearFlag();
free_ctrl_buffer( hdl );
kal_trace( TRACE_FUNC, L1AUDIO_CLOSE, MEDIA_FORMAT_PCM_8K );
return MEDIA_SUCCESS;
}
/*****************************************************************************
* FUNCTION
* custom_nvram_get_database_key
* DESCRIPTION
* to get the custom database key
* PARAMETERS
* key_buffer [OUT] the output buffer to save key
* buffer_size [IN] the size of key buffer
* RETURNS
* 0: Fail
* n: the lenghth of database key
*****************************************************************************/
kal_int32 custom_nvram_get_database_key(kal_uint8 *key_buffer, kal_uint32 buffer_size)
{
#ifdef __NVRAM_SECRET_DATA__
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
CUST_SECRET_DATA_ST* tmp_buffer;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (buffer_size < NVRAM_DATABASE_KEY_SIZE)
{
return 0;
}
buffer_size = sizeof(custom_secret_data);
tmp_buffer = (CUST_SECRET_DATA_ST*) get_ctrl_buffer(buffer_size);
#ifdef __MTK_TARGET__
if (SST_Get_NVRAM_Key((kal_uint32*)&custom_secret_data, (kal_uint32*) tmp_buffer, &buffer_size))
{
memcpy(key_buffer, tmp_buffer->m_custom_database_key, NVRAM_DATABASE_KEY_SIZE);
buffer_size = NVRAM_DATABASE_KEY_SIZE;
}
else
{
buffer_size = 0;
}
#else
memcpy(key_buffer, custom_secret_data.m_custom_database_key, NVRAM_DATABASE_KEY_SIZE);
#endif /* __MTK_TARGET__ */
free_ctrl_buffer((kal_uint8*)tmp_buffer);
return buffer_size;
#else
return 0;
#endif
}
/*****************************************************************************
* FUNCTION
* nvram_send_ilm
* DESCRIPTION
* This is nvram_send_ilm function of NVRAM module.
* PARAMETERS
* dest_id [IN]
* msg_id [IN]
* local_param_ptr [?]
* peer_buf_ptr [?]
* ilm_ptr(?) [IN] The primitives
* RETURNS
* void
*****************************************************************************/
void nvram_send_ilm(module_type dest_id, msg_type msg_id, void *local_param_ptr, void *peer_buf_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
ilm_struct *ilm_ptr = NULL;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (dest_id == MOD_RTC_HISR || dest_id == MOD_SIM)
{
if (local_param_ptr)
free_ctrl_buffer(local_param_ptr);
if (peer_buf_ptr)
free_peer_buff(peer_buf_ptr);
return;
}
ilm_ptr = allocate_ilm(MOD_NVRAM);
ASSERT(ilm_ptr != NULL);
ilm_ptr->src_mod_id = MOD_NVRAM;
ilm_ptr->msg_id = msg_id;
ilm_ptr->local_para_ptr = (local_para_struct*) local_param_ptr;
ilm_ptr->peer_buff_ptr = (peer_buff_struct*) peer_buf_ptr;
ilm_ptr->dest_mod_id = dest_id;
ilm_ptr->sap_id = PS_NVRAM_SAP;
/**
* Sigh, since SEND_ILM is a macro uses ## directive,
* the formal parameter of dest_mod_id must be hardcoded.
* So NVRAM DOES NOT use it. >=P
*/
msg_send_ext_queue(ilm_ptr);
} /* End of nvram_send_ilm */
Media_Status wavRecordAppendable( Media_Format format, FS_HANDLE fs, Media_Record_File_Info *info )
{
uint8 *pBuf;
Media_Status status;
uint32 len;
// To initialize info
memset(info, 0, sizeof(Media_Record_File_Info));
// Get the file size
if (FS_NO_ERROR != FS_GetFileSize(fs, &info->fileSize) )
return MEDIA_READ_FAIL;
// To get the enough wav header which is supported by MediaTek
pBuf = (uint8*)get_ctrl_buffer( 60*sizeof(uint8) );
memset(pBuf, 0, 60*sizeof(uint8));
if ( FS_NO_ERROR != FS_Read(fs, pBuf, 60, &len) ) {
status = MEDIA_READ_FAIL;
} else {
// Parse the wav header
status = wavParseRecordFile(pBuf, len, info);
}
free_ctrl_buffer( pBuf );
// Compare the file information and wav format
if (status == MEDIA_SUCCESS)
{
// Type mismatch
if (format != info->format)
return MEDIA_FAIL;
}
return status;
}
static kal_bool process_gt818_ctp_cmd( kal_uint8 action, kal_uint32 data_len, kal_uint8 *data_str )
{
kal_uint16 ret_len = 0;
kal_uint16 i;
kal_uint16 inlen;
kal_uint16 offset;
STS_CTRL_COMMAND_T cmd;
DCL_HANDLE handle;
kal_uint8 *ctp_buffer = NULL;
kal_uint8 *result = NULL;
ctp_buffer = (kal_uint8 *)get_ctrl_buffer( 1024 );
if ( ctp_buffer == NULL )
EXT_ASSERT(0, (int)ctp_buffer, 0, 0);
cmd.u4Command = action;
cmd.pVoid1 = (void *)data_str;
cmd.pVoid2 = (void *)&result;
handle = DclSTS_Open( DCL_TS, 0 );
DclSTS_Control( handle, STS_CMD_COMMAND, (DCL_CTRL_DATA_T *)&cmd );
DclSTS_Close(handle);
if ( action == DCL_CTP_COMMAND_GET_VERSION )
ret_len = 6;
if ( action == DCL_CTP_COMMAND_GET_CONFIG )
ret_len = 106;
if ( action == DCL_CTP_COMMAND_GET_DIFF_DATA )
ret_len = 162;
if ( action == DCL_CTP_COMMAND_GET_FW_BUFFER )
{
offset = data_str[0]*256 + data_str[1];
inlen = data_str[2];
memcpy( &result[offset], &data_str[3], inlen);
if ( inlen != 128 )
{
#define GT818_FW_STRING "ctp_firmware_rusklmeoxkwjadfjnklruo3"
kal_int16 drv_letter;
FS_HANDLE fs_handle;
UINT writen;
kal_wchar CTP_FIRMWARE_PATH[64];
drv_letter = FS_GetDrive(FS_DRIVE_V_NORMAL, 2, FS_DRIVE_I_SYSTEM | FS_DRIVE_V_NORMAL);
kal_wsprintf( CTP_FIRMWARE_PATH, "%c:\\%s", drv_letter, GT818_FW_STRING );
fs_handle = FS_Open( CTP_FIRMWARE_PATH, FS_CREATE_ALWAYS | FS_READ_WRITE );
FS_Write(fs_handle, (kal_uint8 *) result , offset+inlen, &writen);
FS_Close( fs_handle );
}
}
kal_sprintf( (kal_char *)ctp_buffer, "+EGCMD: " );
for ( i = 0 ; i < ret_len ; i++ )
kal_sprintf( (kal_char *)&ctp_buffer[strlen((char *)(ctp_buffer))], "%02X", result[i] );
rmmi_write_unsolicitedResultCode( ctp_buffer, strlen((kal_char *)(ctp_buffer)), KAL_TRUE, 1, NULL );
free_ctrl_buffer( ctp_buffer );
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* phb_search_confirm
* DESCRIPTION
* This is phb_search_confirm function of PHB module.
* PARAMETERS
* result [IN]
* actual_count [IN]
* src_id [IN]
* cnf_msg_id [IN]
* control_block [?]
* ilm_ptr(?) [IN] The primitives
* RETURNS
* void
*****************************************************************************/
static void phb_search_confirm(
phb_errno_enum result,
kal_uint16 actual_count,
kal_uint8 src_id,
msg_type cnf_msg_id,
control_block_type *control_block)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
local_para_struct *local_param_ptr = NULL;
peer_buff_struct *peer_buf_ptr = NULL;
kal_uint16 msg_id = 0;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_PHB_SEARCH_CNF, result, actual_count, src_id, cnf_msg_id);
/* First we release local parameter. */
if ((result != PHB_ERRNO_BUSY) && (control_block->local_param_ptr != NULL))
{
free_ctrl_buffer(control_block->local_param_ptr);
}
if ((result == PHB_ERRNO_BUSY) || (control_block->cnf_msg_id == MSG_ID_L4CPHB_SEARCH_REQ))
{
l4cphb_search_cnf_struct *l4cphb_search_cnf;
l4cphb_search_cnf = (l4cphb_search_cnf_struct*) construct_local_para(
sizeof(l4cphb_search_cnf_struct),
TD_CTRL);
l4cphb_search_cnf->total = actual_count;
l4cphb_search_cnf->src_id = src_id;
l4cphb_search_cnf->result = result;
/* Field `cause' is meaningful when I/O occured by using control blocks */
l4cphb_search_cnf->cause = control_block->cause;
if (result == PHB_ERRNO_BUSY)
{
phb_send_ilm(MOD_L4C, MSG_ID_L4CPHB_SEARCH_CNF, (local_para_struct*) l4cphb_search_cnf, NULL);
return;
}
local_param_ptr = (local_para_struct*) l4cphb_search_cnf;
msg_id = MSG_ID_L4CPHB_SEARCH_CNF;
}
/**
* Under ADN mode, only when is_retrieve is true and searching into
* physical storage device is required will call search_continue(), which
* in consequence results in this search_confirm() is invoked.
*
* Since it is ADN mode, no matter the search result is,
* the approval result is ALWAYS success!!
*/
else if (control_block->cnf_msg_id == MSG_ID_L4CPHB_APPROVE_REQ)
{
l4cphb_approve_cnf_struct *l4cphb_approve_cnf;
l4cphb_approve_cnf = (l4cphb_approve_cnf_struct*) construct_local_para(
sizeof(l4cphb_approve_cnf_struct),
TD_CTRL);
l4cphb_approve_cnf->result = PHB_ERRNO_SUCCESS;
/* Field `cause' is meaningful when I/O occured by using control blocks */
l4cphb_approve_cnf->cause = control_block->cause;
l4cphb_approve_cnf->type = control_block->type;
l4cphb_approve_cnf->src_id = control_block->src_id;
local_param_ptr = (local_para_struct*) l4cphb_approve_cnf;
msg_id = MSG_ID_L4CPHB_APPROVE_CNF;
}
/* EXCEPTION cannot reach here */
if (control_block->peer_buf_ptr != NULL)
{
if (control_block->actual_count > 0)
{
peer_buf_ptr = (peer_buff_struct*) control_block->peer_buf_ptr;
control_block->peer_buf_ptr = NULL;
}
else
{
free_ctrl_buffer(control_block->peer_buf_ptr);
peer_buf_ptr = NULL;
}
control_block->need_free_peer = KAL_FALSE;
}
phb_free_control_block(control_block);
phb_send_ilm(MOD_L4C, msg_id, local_param_ptr, peer_buf_ptr);
} /* end of phb_search_confirm */
/*****************************************************************************
* FUNCTION
* aud_media_get_audio_format_in_video
* DESCRIPTION
* This function is to get the audio format in video
* PARAMETERS
*
* RETURNS
* kal_uint8 result
*****************************************************************************/
kal_uint8 aud_stretch_is_aduio_in_video_PP_support(kal_wchar *file_name, kal_uint8 *data, kal_uint32 data_len, kal_int16 data_format)
{
#if defined(MED_PURE_AUDIO)
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
MP4_Parser_Status eMp4ParserRet;
FSAL_Status eFSALRet;
kal_uint8 result;
kal_bool is_file_opened = KAL_FALSE;
kal_bool has_aud_track;
kal_bool is_PP_support = KAL_FALSE;
Media_Format audio_format;
kal_uint32 filesize;
kal_uint32 index;
kal_uint64 temp;
STFSAL stFSAL_ROM;
kal_uint8 *fsal_rom_buf;
STMp4Parser *stMp4Parser_aud;
STFSAL *stFSAL_aud;
STFSAL *stFSAL_aud_stsz;
STFSAL *stFSAL_aud_stco;
STFSAL *stFSAL_aud_aud_data;
kal_uint32 *mp4_aud_buf;
kal_uint32 *mp4_aud_data_buf;
kal_uint32 *mp4_aud_stco_buf;
kal_uint32 *mp4_aud_stsz_buf;
kal_uint32 *mp4_aud_stbl_buf;
FS_FileLocationHint *aud_seek_hint;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* Open file for playing */
stFSAL_aud = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL));
eFSALRet = FSAL_Open(stFSAL_aud, (void*)file_name, FSAL_READ);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
is_file_opened = KAL_TRUE;
/* Allocate working buffer for operation */
stMp4Parser_aud = (STMp4Parser*)get_ctrl_buffer(sizeof(STMp4Parser));
stFSAL_aud_stsz = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL));
stFSAL_aud_stco = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL));
stFSAL_aud_aud_data = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL));
mp4_aud_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_FSAL_BUF_SIZE*sizeof(kal_uint32) );
mp4_aud_data_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_FSAL_BUF_SIZE*sizeof(kal_uint32) );
mp4_aud_stco_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_STCO_BUF_SIZE*sizeof(kal_uint32) );
mp4_aud_stsz_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_STSZ_BUF_SIZE*sizeof(kal_uint32) );
mp4_aud_stbl_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_STBL_BUF_SIZE*sizeof(kal_uint32) );
aud_seek_hint = (FS_FileLocationHint*)med_alloc_ext_mem( AUD_DEC_SEEK_HINT_SIZE*sizeof(FS_FileLocationHint) );
/* Set buffer for FSAL */
FSAL_SetBuffer(stFSAL_aud, AUD_MP4_FSAL_BUF_SIZE, (kal_uint8*)mp4_aud_buf);
/* Set seek hint */
eFSALRet = FSAL_GetFileSize(stFSAL_aud, &filesize);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
for (index = 0; index < AUD_DEC_SEEK_HINT_SIZE; index++)
{
temp = ((kal_uint64) filesize * (kal_uint64) (index + 1)) / (kal_uint64) (AUD_DEC_SEEK_HINT_SIZE + 1);
aud_seek_hint[index].Index = (kal_uint32) temp;
}
DRM_set_seek_hint(stFSAL_aud->hFile, AUD_DEC_SEEK_HINT_SIZE, aud_seek_hint);
/* Creat MP4 parser */
eMp4ParserRet = MP4_Parse(stMp4Parser_aud, stFSAL_aud);
if (eMp4ParserRet != MP4_PARSER_OK && eMp4ParserRet != MP4_PARSER_WARNING_TRAILING_GARBAGE)
{
result = MED_RES_BAD_FORMAT;
goto pure_audio_error_out;
}
/* Check if there's audio track */
MP4_MetaHasAudioTrack(stMp4Parser_aud, &has_aud_track);
if (!has_aud_track)
{
result = MED_RES_MP4_NO_AUDIO_TRACK;
goto pure_audio_error_out;
}
/* Prepare cache table */
eMp4ParserRet = MP4_STBL_CacheTablePreprocess(
stMp4Parser_aud,
mp4_aud_stbl_buf,
AUD_MP4_STBL_BUF_SIZE);
if (eMp4ParserRet != MP4_PARSER_OK)
{
result = MED_RES_BAD_FORMAT;
goto pure_audio_error_out;
}
/* FSAL aud data */
eFSALRet = FSAL_Open_Attach(stFSAL_aud_aud_data, stFSAL_aud);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
FSAL_SetBuffer(stFSAL_aud_aud_data, AUD_MP4_FSAL_BUF_SIZE, (kal_uint8*)mp4_aud_data_buf);
/* FASL stco */
eFSALRet = FSAL_Open_Attach(stFSAL_aud_stco, stFSAL_aud);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
FSAL_SetBuffer(stFSAL_aud_stco, AUD_MP4_STCO_BUF_SIZE, (kal_uint8*)mp4_aud_stco_buf);
/* FSAL stsz */
eFSALRet = FSAL_Open_Attach(stFSAL_aud_stsz, stFSAL_aud);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
FSAL_SetBuffer(stFSAL_aud_stsz, AUD_MP4_STSZ_BUF_SIZE, (kal_uint8*)mp4_aud_stsz_buf);
/* Set FSAL to MP4 Parser */
MP4_Audio_SetFSAL(stMp4Parser_aud, stFSAL_aud_aud_data);
MP4_SetFSAL_STCO(stMp4Parser_aud, MP4_TRACK_AUDIO, stFSAL_aud_stco);
MP4_SetFSAL_STSZ(stMp4Parser_aud, MP4_TRACK_AUDIO, stFSAL_aud_stsz);
MP4_UpdateSampleCount(stMp4Parser_aud, MP4_TRACK_AUDIO);
/* Get Audio Type */
audio_format = MP4_Audio_Type_To_Media_Format(MP4_GetAudioType(stMp4Parser_aud));
AUD_VALUE_TRACE(audio_format, -1, __LINE__);
/* The audio format in 3GP/MP4 file */
switch (audio_format)
{
/* Check AMR / AMR-WB by format enum directly */
#ifdef AMR_DECODE
case MEDIA_FORMAT_AMR:
#ifdef AMRWB_DECODE
case MEDIA_FORMAT_AMR_WB:
#endif
is_PP_support = AudioPP_TS_IsSupport((Media_Format) audio_format, NULL);
break;
#endif /*AMR_DECODE*/
/* Need to wrap audio data in FSAL ROM file for check function */
#if defined(AAC_DECODE)
case MEDIA_FORMAT_AAC:
{
kal_uint32 uSampleNo;
kal_uint32 num_bytes;
/* Seek to front and read a small range of data */
eMp4ParserRet = MP4_Audio_TimeToSampleNo(stMp4Parser_aud, 0, &uSampleNo );
if(eMp4ParserRet != MP4_PARSER_OK)
{
result = MED_RES_FAIL;
goto pure_audio_error_out;
}
eMp4ParserRet = MP4_Audio_Seek(stMp4Parser_aud, uSampleNo);
if(eMp4ParserRet != MP4_PARSER_OK)
{
result = MED_RES_FAIL;
goto pure_audio_error_out;
}
/* Read audio data into buffer and set it to FSAL ROM file */
fsal_rom_buf = (kal_uint8*)med_alloc_ext_mem( AUD_STRETCH_FSAL_ROM_SIZE*sizeof(kal_uint8) );
eMp4ParserRet = MP4_Audio_Read(stMp4Parser_aud, fsal_rom_buf, AUD_STRETCH_FSAL_ROM_SIZE, &num_bytes);
if((eMp4ParserRet != MP4_PARSER_OK) && (eMp4ParserRet != MP4_PARSER_READ_EOF))
{
med_free_ext_mem((void**)&fsal_rom_buf);
result = MED_RES_FAIL;
goto pure_audio_error_out;
}
FSAL_Direct_SetRamFileSize(&stFSAL_ROM, num_bytes);
eFSALRet = FSAL_Open(&stFSAL_ROM, (void*)fsal_rom_buf, FSAL_ROMFILE);
if (eFSALRet != FSAL_OK)
{
med_free_ext_mem((void**)&fsal_rom_buf);
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
/* check time stretch support by using extract audio data in FSAL ROM file */
is_PP_support = AudioPP_TS_IsSupport((Media_Format) audio_format, &stFSAL_ROM);
med_free_ext_mem((void**)&fsal_rom_buf);
break;
}
#endif /*AAC_DECODE*/
default:
result = MED_RES_INVALID_FORMAT;
goto pure_audio_error_out;
break;
}
if (is_PP_support)
{
result = MED_RES_OK;
}
else
{
result = MED_RES_UNSUPPORTED_SPEED;
}
pure_audio_error_out:
if (is_file_opened)
{
FSAL_Close(stFSAL_aud);
free_ctrl_buffer(stMp4Parser_aud);
free_ctrl_buffer(stFSAL_aud_stsz);
free_ctrl_buffer(stFSAL_aud_stco);
free_ctrl_buffer(stFSAL_aud_aud_data);
med_free_ext_mem((void**)&mp4_aud_buf);
med_free_ext_mem((void**)&mp4_aud_data_buf);
med_free_ext_mem((void**)&mp4_aud_stco_buf);
med_free_ext_mem((void**)&mp4_aud_stsz_buf);
med_free_ext_mem((void**)&mp4_aud_stbl_buf);
med_free_ext_mem((void**)&aud_seek_hint);
}
free_ctrl_buffer(stFSAL_aud);
return result;
#else
return MED_RES_INVALID_FORMAT;
#endif /* #if defined(MED_PURE_AUDIO) */
}
U32 bpp_compose_vcard_to_xhtml(BTMTK_FS_HANDLE fh, U16* vcard_file)
{
btmtk_vcard_data_struct *p_vcard = NULL;
S32 parse_rst;
U8* cdata;
int data_len, write_len;
S32 ret;
U32 total_len = 0;
BT_BPP_FUNC_ENTRY(BPP_COMPOSE_VCARD2XHTML);
/* Parsing */
p_vcard = get_ctrl_buffer(sizeof(btmtk_vcard_data_struct));
OS_MemSet((U8*)p_vcard, 0, sizeof(btmtk_vcard_data_struct));
parse_rst = btmtk_vcard_parse_file_to_struct(vcard_file, p_vcard);
BT_BPP_TRACE_INFO_ARG1(BPP_PARSE_VCARD_FILE2STRUCT_RETURN, parse_rst);
if (parse_rst != BTMTK_VCD_ERR_OK)
{
/* failed */
free_ctrl_buffer(p_vcard);
return 0;
}
/* Composing */
/* 1. prologue */
cdata = bpp_get_xhtml_prologue();
data_len = strlen((char*)cdata);
ret = bpp_fs_write(fh, cdata, data_len, &write_len);
total_len += write_len;
/* 2. head */
cdata = (U8* )vcard_xhtml_head_template;
data_len = strlen((char*)cdata);
ret = bpp_fs_write(fh, cdata, data_len, &write_len);
total_len += write_len;
/* 3. body start */
cdata = (U8* )vcard_xhtml_body_start;
data_len = strlen((char*)cdata);
ret = bpp_fs_write(fh, cdata, data_len, &write_len);
total_len += write_len;
/* 4. vCard attributes */
write_len = bpp_compose_vcard_attr_to_xhtml(fh, p_vcard);
total_len += write_len;
/* 5. body end */
cdata = (U8* )vcard_xhtml_body_end;
data_len = strlen((char*)cdata);
ret = bpp_fs_write(fh, cdata, data_len, &write_len);
total_len += write_len;
if (p_vcard)
free_ctrl_buffer(p_vcard);
return total_len;
}
static U32 bpp_compose_vcard_attr_to_xhtml(BTMTK_FS_HANDLE fh, btmtk_vcard_data_struct *p_vcard)
{
U32 total_len = 0;
//U32 data_len, write_len;
int data_len, write_len;
S8* pbuf = NULL;
U8* pvalue = NULL;
U8* pname = NULL;
U8 field;
int ret;
#define BPP_TMP_BUF_LEN 512
pbuf = get_ctrl_buffer(BPP_TMP_BUF_LEN);
for (field = 0; field < BPP_VCARD_FIELD_TOTAL; field++)
{
/* get value */
switch (field)
{
case BPP_VCARD_FIELD_NAME:
{
int fnlen, lnlen;
fnlen = strlen((char*)p_vcard->first_name);
lnlen = strlen((char*)p_vcard->second_name);
if ((fnlen > 0) && (lnlen > 0))
{
pname = get_ctrl_buffer(fnlen + lnlen + 2);
strcpy((char*)pname, (char*)p_vcard->first_name);
strcat((char*)pname, (char*)p_vcard->second_name);
pvalue = pname;
}
else
{
pvalue = fnlen > 0 ? p_vcard->first_name : p_vcard->second_name;
}
/* compose */
sprintf(pbuf, vcard_xhtml_attr_template, bpp_vcard_field_str[field], pvalue);
/* write to file */
data_len = strlen((char*)pbuf);
ret = bpp_fs_write(fh, pbuf, data_len, &write_len);
total_len += write_len;
if (pname)
{
free_ctrl_buffer(pname);
pname = NULL;
}
}
/* get the next item */
continue;
case BPP_VCARD_FIELD_TEL_CELL:
pvalue = p_vcard->cell_num;
break;
case BPP_VCARD_FIELD_TEL_HOME:
pvalue = p_vcard->home_num;
break;
case BPP_VCARD_FIELD_CMPNY:
pvalue = p_vcard->company;
break;
case BPP_VCARD_FIELD_EMAIL:
pvalue = p_vcard->email;
break;
case BPP_VCARD_FIELD_TEL_WORK:
pvalue = p_vcard->office_num;
break;
case BPP_VCARD_FIELD_TEL_FAX:
pvalue = p_vcard->fax_num;
break;
case BPP_VCARD_FIELD_BIRTHDAY:
pvalue = p_vcard->birthday;
break;
case BPP_VCARD_FIELD_TITLE:
pvalue = p_vcard->title;
break;
case BPP_VCARD_FIELD_URL:
pvalue = p_vcard->url;
break;
case BPP_VCARD_FIELD_ADR_POBOX:
pvalue = p_vcard->postbox;
break;
case BPP_VCARD_FIELD_ADR_EXTENSION:
pvalue = p_vcard->extension;
break;
case BPP_VCARD_FIELD_ADR_STREET:
pvalue = p_vcard->street;
break;
case BPP_VCARD_FIELD_ADR_CITY:
pvalue = p_vcard->city;
break;
case BPP_VCARD_FIELD_ADR_STATE:
pvalue = p_vcard->state;
break;
case BPP_VCARD_FIELD_ADR_POSTALCODE:
pvalue = p_vcard->postcode;
break;
case BPP_VCARD_FIELD_ADR_COUNTRY:
pvalue = p_vcard->country;
break;
case BPP_VCARD_FIELD_NOTE:
pvalue = p_vcard->note;
break;
default:
pvalue = NULL;
break;
}
if (pvalue && (strlen((char*)pvalue) > 0))
{
/* compose */
sprintf(pbuf, vcard_xhtml_attr_template, bpp_vcard_field_str[field], pvalue);
/* write to file */
data_len = strlen((char*)pbuf);
ret = bpp_fs_write(fh, pbuf, data_len, &write_len);
total_len += write_len;
}
}
if (pbuf)
free_ctrl_buffer(pbuf);
#undef BPP_TMP_BUF_LEN
return total_len;
}
