static Media_Event pcmStrmMFProcess( MHdl *hdl, Media_Event event )
{
pcmStrmMediaHdl *ihdl = (pcmStrmMediaHdl *)hdl;
ASSERT(ihdl != NULL);
kal_trace( TRACE_GROUP_AUD_PROCESS, L1AUDIO_PROCESS, MEDIA_FORMAT_PCM_8K );
switch(event)
{
case MEDIA_END:
if (ihdl->pcmStrm.isPlayback) {
if ( hdl->state == WAV_STATE_PLAYING )
pcmStrmCloseDevice( hdl );
} else {
if ( hdl->state == WAV_STATE_RECORDING )
pcmStrmRecCloseDevice( hdl );
}
hdl->state = WAV_STATE_IDLE;
return event;
case MEDIA_DATA_REQUEST:
return MEDIA_DATA_REQUEST;
case MEDIA_DATA_NOTIFICATION:
return MEDIA_DATA_NOTIFICATION;
default:
ASSERT(0); // should never reach here
}
return MEDIA_NONE; // no use (only for compile)
}
void voc_tst_handler(kal_char *string)
{
commonPara_0 = atoi(string);
if ((commonPara_0 < 0) || (commonPara_0 > 16))
{
setCommonPara = KAL_FALSE;
commonPara_0 = 0;
kal_trace(TRACE_GROUP_EPL, EPL_PARA_ERROR);
}
else
{
setCommonPara = KAL_TRUE;
kal_trace(TRACE_GROUP_EPL, SET_EPL_PARA, commonPara_0);
}
}
/*****************************************************************************
* FUNCTION
* phb_det_delete
* DESCRIPTION
* Delete `position'th element of table of det
* PARAMETERS
* det [IN] The data-entry-table
* position [IN] The position
* RETURNS
* KAL_TRUE if success, KAL_FALSE else.
*****************************************************************************/
kal_bool phb_det_delete(data_entry_table_type *det, kal_uint16 position)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_INFO, FUNC_PHB_DET_DELETE, position, det->used_count);
ASSERT(det != NULL);
if (position > (det->used_count - 1))
{
return KAL_FALSE;
}
table_shift(
&det->used_count,
&det->slots,
det->table,
sizeof(data_entry_struct),
shift_up,
(kal_uint16) (position + 1));
kal_mem_set(&det->table[--det->used_count], (kal_uint8) PHB_INVALID_VALUE, sizeof(data_entry_struct));
return KAL_TRUE;
} /* end of phb_pindex_delete */
void fmp_adp_callback(FmpChannel *channel, FmpCallbackParms *parms)
{
kal_trace(BT_TRACE_BLE_PROFILES, FMP_INTADP_CALLBACK, parms->event, parms->status);
switch (parms->event)
{
case FMPEVENT_OPEN:
fmp_handle_connected(channel, parms->parm.rem_dev, parms->status);
break;
case FMPEVENT_CLOSED:
fmp_handle_disconnected(channel, parms->parm.rem_dev, parms->status);
break;
case FMPEVENT_GATT_QUERY_CNF:
fmp_handle_gatt_query_cnf(channel, parms->status);
break;
case FMPEVENT_SET_ALERT_LEVEL_CNF:
fmp_handle_set_alert_level_cnf(channel, parms->parm.level, parms->status);
break;
case FMPEVENT_SET_ALERT_LEVEL_REQ:
fmp_handle_set_alert_level_ind(channel, parms->parm.level);
break;
default:
break;
}
}
/*****************************************************************************
* FUNCTION
* phb_det_append
* DESCRIPTION
* Append to data-entry-table.
* PARAMETERS
* det [IN] The det
* alpha_id [?]
* storage [IN]
* record_index [IN]
* signature [IN]
* tel_num [IN]
* ext_index [IN]
* RETURNS
* Position where new data is appended if success, PHB_INVALID_VALUE else.
* Lower bound is 0.
*****************************************************************************/
kal_uint16 phb_det_append(
data_entry_table_type *det,
alpha_id_type *alpha_id,
phb_storage_enum storage,
kal_uint16 record_index,
kal_uint8 signature,
kal_uint8 tel_num,
kal_uint8 ext_index)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint16 position;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_PHB_DET_APPEND, det->used_count, det->slots);
ASSERT(det != NULL);
if (det->used_count >= det->slots)
{
return (kal_uint16) PHB_INVALID_VALUE;
}
phb_det_set(det, det->used_count, alpha_id, storage, record_index, signature, tel_num, ext_index);
position = det->used_count++;
return position;
} /* end of phb_det_reset */
/*****************************************************************************
* FUNCTION
* vis_send_play_finish_ind
* DESCRIPTION
* This function is to send visual play finish indication message.
* PARAMETERS
* result [IN]
* RETURNS
* void
*****************************************************************************/
void vis_send_play_finish_ind(kal_int16 result)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
media_visual_play_finish_ind_struct *ind_p;
ilm_struct *ilm_ptr = NULL;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_GROUP_4, VIS_TRC_SEND_PLAY_FINISH_IND);
med_debug_print_result(result);
ind_p = (media_visual_play_finish_ind_struct*)
construct_local_para(sizeof(media_visual_play_finish_ind_struct), TD_CTRL);
ind_p->result = result;
ilm_ptr = allocate_ilm(MOD_MED_V);
ilm_ptr->src_mod_id = MOD_MED_V;
ilm_ptr->dest_mod_id = MOD_MED;
ilm_ptr->sap_id = MED_SAP;
ilm_ptr->msg_id = (msg_type) MSG_ID_MEDIA_VISUAL_PLAY_FINISH_IND;
ilm_ptr->local_para_ptr = (local_para_struct*) ind_p;
ilm_ptr->peer_buff_ptr = NULL;
msg_send_ext_queue(ilm_ptr);
}
static HWND InitAsyncCallback(void)
{
WNDCLASS wc;
WSADATA wsaData;
BOOL registered;
HWND hWnd = 0;
/* Init the Winsock Layer */
if (WSAStartup( 0x0101, &wsaData))
ASSERT(0);
OS_MemSet((U8 *)&wc, 0, sizeof(WNDCLASS));
wc.lpfnWndProc = (WNDPROC)AsyncEventHandler;
wc.lpszClassName = "OBEX TCP Class";
wc.cbWndExtra = sizeof(LONG);
registered = RegisterClass(&wc);
if (!registered) {
kal_trace(BT_TRACE_G6_OBEX,OBEX_SELECT_WINDOW_REGISTRATION_FAILED_xX , GetLastError());
return 0;
}
hWnd = CreateWindow("OBEX TCP Class", NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
return hWnd;
}
void KT_StopAndWait(void)
{
kal_trace( TRACE_INFO, KT_STOP_AND_WAIT );
keytone.isBlocking = true;
ktStop( (void *)0 );
keytone.isBlocking = false;
}
MHdl *PCM_Strm_Rec_Open(void(*handler)( MHdl *handle, Media_Event event ), void *param)
{
MHdl *hdl;
pcmStrmMediaHdl *ihdl;
ihdl = (pcmStrmMediaHdl*)get_ctrl_buffer( sizeof(pcmStrmMediaHdl) );
memset(ihdl, 0, sizeof(pcmStrmMediaHdl));
hdl = (MHdl *) ihdl;
ihdl->pcmStrm.dedicated_mode = AM_IsSpeechOn();
mhdlInit( hdl, 0, NULL );
hdl->handler = handler;
hdl->state = WAV_STATE_IDLE;
ihdl->pcmStrm.isPlayback = false;
hdl->Close = pcmStrmMFClose;
hdl->Pause = pcmStrmMFPause;
hdl->Stop = pcmStrmMFStop;
hdl->Process = pcmStrmMFProcess;
hdl->Record = pcmStrmMFRecord;
hdl->Resume = pcmStrmMFResume;
kal_trace( TRACE_FUNC, L1AUDIO_OPEN_STREAM, MEDIA_FORMAT_PCM_8K );
return hdl;
}
void btmtk_adp_fmp_handle_message(void *msg)
{
ilm_struct *ilm_ptr = (ilm_struct *)msg;
kal_trace(BT_TRACE_BLE_PROFILES, FMP_INTADP_HANDLE_MESSAGE, ilm_ptr->msg_id);
switch (ilm_ptr->msg_id)
{
case MSG_ID_BT_FMP_ACTIVATE_REQ:
btmtk_adp_fmp_handle_activate_req(ilm_ptr);
break;
case MSG_ID_BT_FMP_DEACTIVATE_REQ:
btmtk_adp_fmp_handle_deactivate_req(ilm_ptr);
break;
case MSG_ID_BT_FMP_CONNECT_REQ:
btmtk_adp_fmp_handle_connect_req(ilm_ptr);
break;
case MSG_ID_BT_FMP_SEARCH_ATTRIBUTE_REQ:
btmtk_adp_fmp_handle_search_attribute_req(ilm_ptr);
break;
case MSG_ID_BT_FMP_DISCONNECT_REQ:
btmtk_adp_fmp_handle_disconnect_req(ilm_ptr);
break;
case MSG_ID_BT_FMP_SET_ALERT_LEVEL_REQ:
btmtk_adp_fmp_handle_set_alert_level_req(ilm_ptr);
break;
case MSG_ID_BT_FMP_REMOVE_DEV_REQ:
//btmtk_adp_fmp_handle_remove_dev_req(ilm_ptr);
break;
default:
break;
}
}
static void dtmf_mcu_Init(kal_uint16 uSampleRate)
{
kal_uint32 uIntBufSize=0, uPcmBufSize=0, uTotalBufferSize=0;
kal_uint8 *pAllocBuf;
DTMF_SR uSr=0;
memset(&DTMF_SW, 0, sizeof(DTMF_SW));
DTMF_SW.uSampleRate = uSampleRate;
switch (DTMF_SW.uSampleRate)
{
case 8000:
uSr = DTMF_8K;
break;
case 11025:
uSr = DTMF_11K;
break;
case 12000:
uSr = DTMF_12K;
break;
case 16000:
uSr = DTMF_16K;
break;
case 22050:
uSr = DTMF_22K;
break;
case 24000:
uSr = DTMF_24K;
break;
case 32000:
uSr = DTMF_32K;
break;
case 44100:
uSr = DTMF_44K;
break;
case 48000:
uSr = DTMF_48K;
break;
default:
ASSERT(0);
break;
}
DTMF_GetBufferSize(&uIntBufSize, &uPcmBufSize, uSr, DTMF_MONO);
uTotalBufferSize = uIntBufSize + uPcmBufSize * DTMF_BUFFERED_FRAME_NUMBER;
kal_trace( TRACE_GROUP_AUD_PLAYBACK, MCU_DTMF_INIT, uSampleRate, uPcmBufSize, uTotalBufferSize);
pAllocBuf = (kal_uint8 *)audio_alloc_mem(uTotalBufferSize);
ASSERT(pAllocBuf);
ASSERT(uIntBufSize);
ASSERT(uPcmBufSize);
DTMF_SW.uFrameByte = uPcmBufSize;
DTMF_SW.RingBuffer.rb_base = (kal_uint8*)pAllocBuf;
DTMF_SW.RingBuffer.rb_size = uPcmBufSize * DTMF_BUFFERED_FRAME_NUMBER;
DTMF_SW.RingBuffer.write = uPcmBufSize * uPreSilenceLength; //fill a silence to prevent pop up noise
DTMF_SW.RingBuffer.read=0;
pAllocBuf += uPcmBufSize * DTMF_BUFFERED_FRAME_NUMBER;
DTMF_SW.pHandle = DTMF_Init( (void *)pAllocBuf, DTMF_CONTINUOUS, uSr, DTMF_MONO);
ASSERT(DTMF_SW.pHandle);
DTMF_SW.uAudId = L1Audio_GetAudioID();
L1Audio_SetFlag( DTMF_SW.uAudId );
L1Audio_SetEventHandler( DTMF_SW.uAudId, dtmf_mcu_Process );
}
static void dtmf_mcu_ActivatNewKey()
{
DTMF_KEY uKey1, uKey2;
kal_uint32 uPreIndex1, uPreIndex2;
kal_uint32 uCurrentDur;
DTMF_SW.uCurIdx++;
if(DTMF_SW.uCurIdx > 2)
{
DTMF_SW.uCurIdx = 0;
}
dtmf_mcu_GetPreIndex(DTMF_SW.uCurIdx, &uPreIndex1, &uPreIndex2);
dtmf_mcu_GetKeyID(DTMF_SW.uCurIdx, &uKey1, &uKey2);
DTMF_SetKey( DTMF_SW.pHandle, uKey1, (kal_int32)DTMF_SW.pCurrQTMF->freq1, (kal_int32)DTMF_SW.pCurrQTMF->freq2);
DTMF_SetKey( DTMF_SW.pHandle, uKey2, (kal_int32)DTMF_SW.pCurrQTMF->freq3, (kal_int32)DTMF_SW.pCurrQTMF->freq4);
uCurrentDur = dtmf_mcu_CheckDuration(DTMF_SW.pCurrQTMF->on_duration);
DTMF_SW.uRemainDuration[DTMF_SW.uCurIdx] = DTMF_SW.uTotalDuration[DTMF_SW.uCurIdx] = uCurrentDur;
DTMF_SW.fIsQTMF[DTMF_SW.uCurIdx] = DTMF_SW.fIsToneListQTMF;
DTMF_SW.fEnable[DTMF_SW.uCurIdx] = KAL_TRUE;
DTMF_SW.fIsOn[DTMF_SW.uCurIdx] = KAL_TRUE;
if(DTMF_SW.fEnable[uPreIndex2])
{
kal_trace( TRACE_GROUP_AUD_PLAYBACK, MCU_DTMF_NEWKEY_FORCE_END_2, uPreIndex2, DTMF_SW.uRemainDuration[uPreIndex2], DTMF_SW.uTotalDuration[uPreIndex2]);
DTMF_SW.uRemainDuration[uPreIndex2] = 1;
}
if(DTMF_SW.fEnable[uPreIndex1])
{
kal_trace( TRACE_GROUP_AUD_PLAYBACK, MCU_DTMF_NEWKEY_FORCE_END_1, uPreIndex1, DTMF_SW.uRemainDuration[uPreIndex1], DTMF_SW.uTotalDuration[uPreIndex1]);
if(DTMF_SW.uTotalDuration[uPreIndex1] > DTMF_MIN_FRAME)
{
kal_uint32 uPlayedDur = DTMF_SW.uTotalDuration[uPreIndex1]-DTMF_SW.uRemainDuration[uPreIndex1];
if(uPlayedDur >= DTMF_MIN_FRAME )
{
DTMF_SW.uRemainDuration[uPreIndex1] = 1;
}
else
{
DTMF_SW.uRemainDuration[uPreIndex1] = DTMF_MIN_FRAME - uPlayedDur;
}
}
if(DTMF_SW.uRemainDuration[uPreIndex1] > uCurrentDur)
{
DTMF_SW.uRemainDuration[uPreIndex1] = uCurrentDur;
}
}
kal_trace( TRACE_GROUP_AUD_PLAYBACK, MCU_DTMF_NEWKEY, DTMF_SW.uCurIdx, uCurrentDur, DTMF_SW.fIsToneListQTMF, DTMF_SW.pCurrQTMF->freq1, DTMF_SW.pCurrQTMF->freq2, DTMF_SW.pCurrQTMF->freq3, DTMF_SW.pCurrQTMF->freq4);
}
/*****************************************************************************
* FUNCTION
* BTAppHandleDeRegisterRecord
* DESCRIPTION
*
* PARAMETERS
* ptr [IN]
* RETURNS
* void
*****************************************************************************/
void BTAppHandleDeRegisterRecord(bt_app_sdpdb_deregister_req_struct *ptr)
{
U8 i = 0;
BtStatus status = BT_STATUS_FAILED;
U32 handle = 0;
handle = ptr->handle;
for (i = 0; i < BT_SDPDB_MAX_SERVICE_RECORD_NO; i++)
{
if ((bt_app_sdpdb_context.db[i].used != 0) && (bt_app_sdpdb_context.db[i].AppRecordHandler == handle))
{
/* Find matched service record */
kal_trace(BT_TRACE_JSR82_GROUP, BT_JSR82_DEREG_RECORD_FIND_INDEX_I_TO_UNREGISTERx02X, i);
bt_app_sdpdb_context.db[i].used = 0;
#ifdef BTMTK_ON_LINUX /* android no shared memory management yet */
OS_MemSet(bt_app_sdpdb_context.db[i].attribute_value, 0, BT_APP_MAX_RECORD_SIZE);
OS_MemSet(bt_app_sdpdb_context.db[i].raw_data, 0, BT_APP_MAX_RECORD_SIZE);
#else
bt_app_sdpdb_context.db[i].attribute_value = 0;
#endif
status = SDP_RemoveRecord(&(bt_app_sdpdb_context.db[i].AppSdpRecord));
kal_trace(BT_TRACE_JSR82_GROUP, BT_JSR82_DEREG_RECORD_STATUSx02X, status);
break;
}
}
if (i == BT_SDPDB_MAX_SERVICE_RECORD_NO)
{
kal_trace(BT_TRACE_JSR82_GROUP, BT_JSR82_DEREG_RECORD_NO_REGISTERED_SERVICE_RECORD);
BTAppHandleDeRegisterRecordResult(BTSDPDBAPP_INVALID_HANDLE, handle);
return;
}
if (status == BT_STATUS_INVALID_PARM)
{
BTAppHandleDeRegisterRecordResult(BTSDPDBAPP_FAILED, handle);
}
else if (status == BT_STATUS_FAILED)
{
BTAppHandleDeRegisterRecordResult(BTSDPDBAPP_SDP_DEREGISTER_FAILED, handle);
}
else
{
BTAppHandleDeRegisterRecordResult(BTSDPDBAPP_SUCCESS, handle);
}
}
void BesTS_FreeAudioHandle()
{
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_DRAIN_FREE_TS_HANDLE, pBesTS_AudComHdl,0,0,0,0,0);
pBesTS_AudComHdl = NULL;
BesTS_Param.uChannelNumber = 0;
BesTS_Param.uSamplingFreq = 0;
uBesTsCurrentTime = 0;
}
void idp_internal_crz_usel_dsel(kal_uint32 scenario, kal_uint32 source_w, kal_uint32 source_h, kal_uint32 target_w, kal_uint32 target_h, kal_uint32* usel, kal_uint32* dsel)
{
idp_custom_crz_usel_dsel(((CUSTOM_SCENARIO_ID)scenario), (source_w), (source_h), (target_w), (target_h), (usel), (dsel));
if ((INT_QueryExceptionStatus() == KAL_FALSE) && (kal_if_hisr() == KAL_FALSE) && (kal_if_lisr() == KAL_FALSE))
{
kal_trace(TRACE_INFO, IDP_CUSTOM_CRZ_U_D, (scenario), (source_w), (source_h), (target_w), (target_h), *(usel), *(dsel));
}
}
OMX_ERRORTYPE AudioRoute2Drain_Free(MHPB_Internal *ihdl)
{
ihdl->mh.Close( (MHdl *)ihdl );
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_ROUTE2DRAIN_FREE, ihdl, 0,0,0,0,0);
return OMX_ErrorNone;
}
/*
* FUNCTION
* bmt_stop_stoptimer
*
* DESCRIPTION
* This function is to stop the bmt_stop timer in bmt task.
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_stop_stoptimer(void)
{
#ifdef BMT_KAL_DEBUG
kal_trace(TRACE_FUNC, BMT_STOP_TIMER_STOP_TRC);
#endif
drv_trace0(TRACE_GROUP_10, BMT_STOP_TIMER_STOP_TRC);
stack_stop_timer(timer_stopcharge);
}
/*
* FUNCTION
* bmt_set_guardtimer
*
* DESCRIPTION
* This function is to initialize the bmt_stop timer in bmt task.
*
* CALLS
*
* PARAMETERS
* tick: timer tick(1 tick=4.615ms)
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_set_guardtimer(kal_uint32 tick)
{
#ifdef BMT_KAL_DEBUG
kal_trace(TRACE_FUNC, BMT_STOP_TIMER_START_TRC);
#endif
drv_trace0(TRACE_GROUP_10, BMT_STOP_TIMER_START_TRC);
stack_start_timer(timer_guardcharge, 0, tick);
}
BtStatus FMP_Open(FmpChannel **channel, BD_ADDR *addr)
{
BtStatus status = BT_STATUS_FAILED;
FmpChannel *ch;
CheckUnlockedParm(BT_STATUS_INVALID_PARM, addr != 0);
OS_LockStack();
kal_trace(BT_TRACE_BLE_PROFILES, FMP_OPENCONNECTION);
if ((*channel != NULL) && IsNodeOnList(&FMP(dev_list), &((*channel)->node)))
{
ch = *channel;
}
else
{
ch = FmpNewChannel();
if (ch == NULL)
{
return BT_STATUS_NO_RESOURCES;
}
}
if (ch->state == FMP_STATE_CLOSED)
{
status = CMGR_CreateDataLink(&ch->cmgr_handler, addr);
kal_trace(BT_TRACE_BLE_PROFILES, FMP_CREATEDATALINK_STATUS, status);
if (status == BT_STATUS_SUCCESS)
{
status = GattClientConnect(ch->cmgr_handler.remDev);
}
if (status != BT_STATUS_SUCCESS && status != BT_STATUS_PENDING)
{
FmpFreeChannel(ch);
return status;
}
ch->state = FMP_STATE_OPENING;
*channel = ch;
}
OS_UnlockStack();
return status;
}
/**
Run on AUDIO task
*/
void bgsndEventHandler(void)
{
kal_trace(TRACE_STATE, L1SND_ENTER_EVENT_HANDLER, bgSnd.state);
switch (bgSnd.state)
{
case BGSND_STATE_STOP:
{
// int32 I = 0;
// Flush and Disable DSP.
//while( I++ >= 0 ){
while(bgSnd.endCount++ >=0){
int32 count = bgsndGetDataCount();
// if( I >=40 ){
if(bgSnd.endCount >=20) {
kal_trace(TRACE_STATE, L1SND_STOP_FLUSH_LEAVE, count);
break;
}
if( count > BGSND_BUF_PTR_DIFF ){
kal_trace(TRACE_STATE, L1SND_STOP_FLUSH_COUNT, count);
// kal_sleep_task(1);
kal_set_timer(bgSnd.timer, (kal_timer_func_ptr)(bgsndTimerCallback), NULL, 2, 0);
return;
}
}
//if ( *DSP_SOUND_EFFECT_CTRL == DP_BGSND_STATE_PLAYING ) {
// *DSP_SOUND_EFFECT_CTRL = DP_BGSND_STATE_STOP; /* give ABORT command to the DSP */
//}
kal_cancel_timer(bgSnd.timer);
bgsndOffHandler();
if(NULL != bgSnd.bgSnd_offHandler){
bgSnd.bgSnd_offHandler();
}
}
break;
default:
break;
}
}
/*****************************************************************************
* FUNCTION
* BTAppHandleRetrieveRecordCnf
* DESCRIPTION
*
* PARAMETERS
* ptr [IN]
* RETURNS
* void
*****************************************************************************/
void BTAppHandleRetrieveRecordCnf(bt_app_sdpdb_retrieve_record_cnf_struct *ptr)
{
U16 i = 0;
kal_trace(BT_TRACE_JSR82_GROUP, BT_JSR82_RETRIEVERECORDCNF_RESULTx02X, ptr->result);
kal_trace(BT_TRACE_JSR82_GROUP, BT_JSR82_RETRIEVERECORDCNF_HANDLEx08X, ptr->handle);
kal_trace(BT_TRACE_JSR82_GROUP, BT_JSR82_RETRIEVERECORDCNF_RECORD_SIZExDX, ptr->record_size);
for (i = 0; i < ptr->record_size; i += 4)
{
kal_trace(
BT_TRACE_JSR82_GROUP,
BT_JSR82_RETRIEVERECORDCNF_RAW_DATAx02Xx02X_x02Xx02X,
ptr->record[i],
ptr->record[i + 1],
ptr->record[i + 2],
ptr->record[i + 3]);
}
}
void dt_main(ilm_struct *ilm_ptr)
{
switch (ilm_ptr->msg_id)
{
case MSG_ID_L4CDT_DOWNLOAD_REQ:
l4cdt_download_req_hdlr((local_para_struct*)ilm_ptr->local_para_ptr,
ilm_ptr->peer_buff_ptr);
break;
case MSG_ID_L4CDT_UPLOAD_REQ:
l4cdt_upload_req_hdlr((local_para_struct*)ilm_ptr->local_para_ptr,
ilm_ptr->peer_buff_ptr);
break;
case MSG_ID_L4CDT_FILELIST_REQ:
l4cdt_filelist_req_hdlr((local_para_struct*)ilm_ptr->local_para_ptr,
ilm_ptr->peer_buff_ptr);
break;
case MSG_ID_L4CDT_UART_TRANSFER_REQ:
l4cdt_uart_transfer_req_hdlr((local_para_struct*)ilm_ptr->local_para_ptr,
ilm_ptr->peer_buff_ptr);
break;
case MSG_ID_UART_READY_TO_READ_IND:
dt_uart_ready_to_read_ind_hdlr((local_para_struct*)ilm_ptr->local_para_ptr,
ilm_ptr->peer_buff_ptr);
break;
case MSG_ID_UART_READY_TO_WRITE_IND:
dt_uart_ready_to_write_ind_hdlr((local_para_struct*)ilm_ptr->local_para_ptr,
ilm_ptr->peer_buff_ptr);
break;
case MSG_ID_UART_PLUGOUT_IND:
dt_usb_plugout_ind_hdlr((local_para_struct*)ilm_ptr->local_para_ptr,
ilm_ptr->peer_buff_ptr);
break;
case MSG_ID_TIMER_EXPIRY:
dt_timer_expiry_hdlr(ilm_ptr);
break;
default:
/* Inform that Unknow Message is received */
kal_trace(TRACE_ERROR,ERROR_DT_INVALID_MSG);
break;
}
if (DT_PTR->uart_input_queue.length > 0)
{
dt_process_one_cmd();
}
} /* End of dt_main */
/*****************************************************************************
* FUNCTION
* phb_det_set
* DESCRIPTION
* Set `position'th element of det with new values.
* PARAMETERS
* det [IN] The data-entry-table
* position [IN] The position, start from 0.
* alpha_id [?]
* storage [IN]
* record_index [IN]
* signature [IN]
* tel_num [IN]
* ext_index [IN]
* RETURNS
* KAL_TRUE if success, KAL_FALSE else.
*****************************************************************************/
kal_bool phb_det_set(
data_entry_table_type *det,
kal_uint16 position,
alpha_id_type *alpha_id,
phb_storage_enum storage,
kal_uint16 record_index,
kal_uint8 signature,
kal_uint8 tel_num,
kal_uint8 ext_index)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
data_entry_struct *data_entry;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_PHB_DET_SET);
ASSERT(det != NULL);
if (position > det->slots)
{
return KAL_FALSE;
}
data_entry = &det->table[position];
kal_mem_cpy(&data_entry->alpha_id, (void const*)alpha_id, sizeof(alpha_id_type));
if (alpha_id->length > PHB_ALPHA_ID_DEPTH)
{
data_entry->alpha_id.length = PHB_ALPHA_ID_DEPTH;
}
data_entry->storage = storage;
data_entry->record_index = record_index;
data_entry->tel_num_sig = signature;
data_entry->tel_num = tel_num;
data_entry->ext_index = ext_index;
kal_trace(TRACE_INFO, PHB_TRC_DET_SET_DETAILS, position, storage, record_index, signature, tel_num, ext_index);
return KAL_TRUE;
} /* end of phb_pindex_insert */
/*****************************************************************************
* FUNCTION
* jma_audio_recorder_set_record_size_limit
* DESCRIPTION
* This function set the size limit of recorded data
* PARAMETERS
* mma_type [IN] Int recorder
* java_recorder [IN]
* limit_size [IN]
* RETURNS
* int - limit_size set
*****************************************************************************/
kal_int32 jma_mvm_audio_recorder_set_record_size_limit(kal_int32 vm_id, kal_int32 java_recorder, kal_int32 limit_size)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int32 ticks = kal_milli_secs_to_ticks(200); /* 200 ms */
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_MVM_AUDIO_RECORDER_SET_RECORD_SIZE_LIMIT, vm_id, java_recorder, audio_recorder[vm_id].state, limit_size);
JMA_CS_ENTER(vm_id, 0);
if (audio_recorder[vm_id].id != java_recorder)
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_RESOURCE_ERROR, audio_recorder[vm_id].id);
JMA_CS_LEAVE(0);
}
/* Save parameter */
audio_recorder[vm_id].record_size_limit = limit_size;
if (vm_id != jam_mvm_get_current_vm_id())
{
JMA_CS_LEAVE(limit_size);
}
//#ifdef __MMI_BACKGROUND_CALL__
if (jma_media_player_is_in_background_call())
{
JMA_CS_LEAVE(limit_size);
}
//#endif /* __MMI_BACKGROUND_CALL__ */
/* start timer */
if (audio_recorder[vm_id].state == JAVA_MEDIA_STATE_RECORDING)
{
if(audio_recorder[vm_id].record_size_limit != -1)
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_STACK_START_TIMER);
stack_start_timer(&java_media_timer, JAVA_MEDIA_TIMER_AUDIO_RECORDER + vm_id, ticks);
}
}
JMA_CS_LEAVE(limit_size);
}
/*****************************************************************************
* FUNCTION
* AvctpMsgHandleCommand
* DESCRIPTION
* Handle a command.
* PARAMETERS
* chnl [IN]
* parms [IN]
* RETURNS
* void
*****************************************************************************/
static void AvctpMsgHandleCommand(AvctpChannel *chnl, AvcCallbackParms *parms)
{
AvctpCallbackParms info;
kal_trace( BT_TRACE_G8_AVRCP, BT_AVCTP_MSG_HANDLE_COMMAND, parms->pktType, parms->rxId);
if (parms->rxId != SC_AV_REMOTE_CONTROL)
{
bt_trace(TRACE_GROUP_1, AVCTP_INVALID_PROFILE_ID);
chnl->rspPacket.msgType = AVC_MSG_TYPE_REJECT;
chnl->rspPacket.txId = parms->rxId;
chnl->rspPacket.txIdSize = 2;
chnl->rspPacket.txData = 0;
chnl->rspPacket.txDataLen = 0;
chnl->rspPacket.useMsgHdr = FALSE;
/*
* There's no frame to send along; completion of this message
* should not be indicated back to the app
*/
chnl->curFrame = 0;
chnl->rxState = AVCTP_MSG_RXSTATE_IGNORE;
AssertEval(AVC_SendStart(&chnl->avcChnl, &chnl->rspPacket) == BT_STATUS_PENDING);
return;
}
if (parms->pktType == AVC_PACKET_TYPE_START || parms->pktType == AVC_PACKET_TYPE_SINGLE)
{
if ( BT_PSM_AVCTP== chnl->channelType && parms->len < 3) // AV13 channeltype is AVCTP psm
{
bt_trace(TRACE_GROUP_1, AVCTP_MISSING_PARAMETERS_DISCONNECTING);
(void)AvctpDisconnect(&chnl->conn);
return;
}
if( BT_PSM_AVCTP_BROWSING != chnl->channelType ){
// Parse the av/c header
/* Move channel state into COMMAND-processing */
chnl->state = AVCTP_CHAN_STATE_COMMAND;
/* Decode parameters buffer AV/C header */
chnl->rx.cmdFrame.ctype = parms->data[0] & 0x0f;
chnl->rx.cmdFrame.subunitType = parms->data[1] >> 3;
chnl->rx.cmdFrame.subunitId = parms->data[1] & 0x07;
chnl->rx.cmdFrame.opcode = parms->data[2];
chnl->rx.cmdFrame.operands = parms->data + 3;
chnl->rx.cmdFrame.operandLen = parms->len - 3;
chnl->rx.cmdFrame.more = (parms->pktType == AVC_PACKET_TYPE_START);
chnl->rx.cmdFrame.transId = parms->transid;
#ifdef __AVCTP_TESTER_
chnl->rxRawData = parms->data;
chnl->rxRawLength = parms->len;
chnl->rxRawType = parms->pktType;
#endif /* __AVCTP_TESTER_ */
}else{
OMX_ERRORTYPE AudioRoute2Drain_Stop(MHPB_Internal *ihdl)
{
ihdl->mh.Stop( (MHdl *)ihdl );
PcmRut_UnregPutComponent(ihdl->SinkNode.curHdl);
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_ROUTE2DRAIN_STOP, ihdl, 0,0,0,0,0);
return OMX_ErrorNone;
}
void BesTS_SetAudioHandle(AudComHdl *pCurHdl, kal_uint32 uSampleRate, kal_uint32 uChannelNum)
{
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_DRAIN_SET_TS_HANDLE, pCurHdl,uSampleRate,uChannelNum,0,0,0);
pBesTS_AudComHdl = pCurHdl;
BesTS_Param.uChannelNumber = uChannelNum;
BesTS_Param.uSamplingFreq = uSampleRate;
BesTS_Param.uEnabled = KAL_FALSE;
uBesTsCurrentTime = 0;
AudioDrain_SetTSParam_Internal();
}
/*****************************************************************************
* FUNCTION
* jam_listmem_free
* DESCRIPTION
*
* PARAMETERS
* ptr [?] [?]
* RETURNS
* void
*****************************************************************************/
void jam_listmem_free(void *ptr)
{
#ifndef J2ME_SLIM_REMOVE_LIST_MEMORY_SUPPORT
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
listmem_hdr header;
char *mem_pool_start = g_jam_midslist_mem_start_p;
char *mem_pool_end = g_jam_midslist_mem_end_p;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (ptr == NULL)
{
kal_trace(TRACE_INFO, FUNC_JAM_LIST_FREE_NULL);
}
else if (((char*)ptr > mem_pool_end) || ((char*)ptr < mem_pool_start))
{
kal_trace(TRACE_INFO, FUNC_JAM_LIST_FREE_OUT_OF_SCOPE, (kal_int32) ptr);
}
else
{
header = (listmem_hdr) ((char*)ptr - sizeof(listmem_struct));
if (header->magic != MAGIC)
{
kal_trace(TRACE_INFO, FUNC_JAM_LIST_FREE_CORRUPTED_MEM, (kal_int32) ptr);
}
else if (header->free != 0)
{
kal_trace(TRACE_INFO, FUNC_JAM_LIST_FREE_TWICE, (kal_int32) ptr);
}
else
{
header->free = 1;
}
}
#else
kal_prompt_trace(MOD_JAM, "Here used to be list memory free.");
jvm_free(ptr);
#endif
}
static Media_Status GenCompPause( MHdl *hdl )
{
ASSERT( hdl->state == COMPONENT_STATE_PLAY );
hdl->Stop(hdl);
hdl->bIsPause = KAL_TRUE;
hdl->start_time = hdl->current_time;
hdl->state = COMPONENT_STATE_PAUSE;
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_PAUSE, hdl->mediaType, hdl->start_time,0,0,0,0,0);
return MEDIA_SUCCESS;
}
/*
* FUNCTION
* bmt_charge_start
*
* DESCRIPTION
* This function is to start charging algorithm.
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_charge_start(void)
{
kal_uint8 index;
BMT_Charge(KAL_FALSE);
BMT.pmictrl_state = PMIC_CHARGEOFF;
BMT.bat_state = CHR_PRE;
BMT.VBAT_UEM= VBAT_UEM_CHR_IN_FISRT;
bmt_charge_time_value = 10;
low_charger_count = 0;
low_current_count = 0;
low_temper_count = 0;
over_temper_count = 0;
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepDisable(bmt_sm_handle);
#endif
for(index=0;index<BMT_MAX_CHANNEL;index++)
{
adc_sche_modify_parameters(bmt_bmtid_adcscheid[index],1,1);
adc_sche_add_item(bmt_bmtid_adcscheid[index],bmt_measure_complete1[index], bmt_adc_sche_measure);
}
adc_sche_set_timer_page_align(KAL_FALSE);
stack_start_timer(&ChargeTimeout_timer, 0, KAL_TICKS_1_MIN*60*6);
#ifdef BMT_KAL_DEBUG
kal_trace(TRACE_FUNC, BMT_SAFETY_TIMER_START_TRC);
#endif
SaftyTimer_Flag = BMT_SaftyTimer_On;
#if defined(MT6318)
#if !defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)
if(pmic_is_chr_det(AC_CHR))
pmic_charging_currnet_ctrl(pmic_return_current(AC_CHR));
#ifdef __USB_MULTI_CHARGE_CURRENT__
else if (bmt_support_usb_charge()) /* If not support, charging current is not set here. */
pmic_charging_currnet_ctrl(pmic_return_current(USB_CHR));
#else /* __USB_MULTI_CHARGE_CURRENT__ */
else
pmic_charging_currnet_ctrl(pmic_return_current(USB_CHR));
#endif /* __USB_MULTI_CHARGE_CURRENT__ */
#else/*defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)*/
if(chr_usb_detect.chr_usb_present == CHARGER_PRESENT)
pmic_charging_currnet_ctrl(pmic_return_current(AC_CHR));
else if(chr_usb_detect.chr_usb_present == USB_PRESENT)
{
#ifdef __USB_MULTI_CHARGE_CURRENT__
if (bmt_support_usb_charge()) /* If not support, charging current is not set here. */
pmic_charging_currnet_ctrl(pmic_return_current(USB_CHR));
#else /* __USB_MULTI_CHARGE_CURRENT__ */
pmic_charging_currnet_ctrl(pmic_return_current(USB_CHR));
#endif /* __USB_MULTI_CHARGE_CURRENT__ */
}
#endif
#endif /* defined(MT6318) */
}
