// blocking function kal_int32 API IMGPROC_WaitComplete(MMDI_SCENERIO_ID owner) { kal_uint32 flags; kal_status status; #if (defined(DRV_IDP_6219_SERIES)) ASSERT(owner == imgproc_dcb.owner); ASSERT(imgproc_dcb.mask != FILTER_NONE); status = kal_retrieve_eg_events(IMGPROC_Events,IMGPROC_EVENT ,KAL_AND_CONSUME,&flags,KAL_SUSPEND); ASSERT(status == KAL_SUCCESS); #elif (defined(DRV_IDP_6228_SERIES)) status = kal_retrieve_eg_events(IMGPROC_Events,IMGPROC_EVENT ,KAL_AND_CONSUME,&flags,KAL_SUSPEND); if (status!=KAL_SUCCESS) ASSERT(0); #endif return NO_ERROR; }
void IspWaitOneFrameDone(ISP_VSYNC_TIME_OUT_UNIT TimeOut) { kal_uint32 EventGroup; if(TimeOut ==0 || TimeOut > IspVsyncTimeOut500MS) TimeOut = IspVsyncTimeOut500MS; _IspVsyncTimeOutReportStart(TimeOut); kal_set_eg_events(IspEventId,0,KAL_AND); kal_retrieve_eg_events(IspEventId,CAMERA_ISP_FRAME_READY_EVENT,KAL_OR_CONSUME,&EventGroup,KAL_SUSPEND); _IspVsyncTimeOutReportRelease(); }
void L1Audio_FreeAudioID( uint16 aud_id ) { uint32 savedMask; uint32 retrieved_events; kal_retrieve_eg_events(l1audio.aud_events,(1<<aud_id),KAL_OR_CONSUME,&retrieved_events,0); ASSERT( (l1audio.runningState & (1 << aud_id)) == 0 ); ASSERT( l1audio.id_flag & (1<<aud_id) ); savedMask = SaveAndSetIRQMask(); l1audio.id_flag &= ~(1<<aud_id); l1audio.retrieved_events &= ~(1<<aud_id); RestoreIRQMask( savedMask ); }
/***************************************************************************** * FUNCTION * srv_cbm_lock * DESCRIPTION * * PARAMETERS * * RETURNS * void *****************************************************************************/ void srv_cbm_lock(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_uint32 retrieved_events; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ kal_retrieve_eg_events(g_cbm_srv_cxt_ptr->nwk_srv.wait_event, CBM_NWK_DISALLOW_EVENT, KAL_OR_CONSUME, &retrieved_events, KAL_SUSPEND); }
kal_bool IC_USB_POWER_ON(kal_uint8 iccd_index,kal_bool blocking) { kal_uint8 index; kal_uint32 event_group; if(g_UsbHostIccd[iccd_index].start_event_id == 0) { g_UsbHostIccd[iccd_index].start_event_id = kal_create_event_group("ICUSB_ENUMERATION"); } else { /* Receive all events that may exist after previous detatch */ kal_retrieve_eg_events(g_UsbHostIccd[iccd_index].start_event_id, EVENT_ICUSB_ENUMERATION_DONE|EVENT_ICUSB_ENUMERATION_FAIL, KAL_OR_CONSUME, &event_group, KAL_NO_SUSPEND); } // for (index = USB_EXT_IP_NUM; index< USB_IP_NUM; index++) // only enable ICUSB Drive for (index = 0; index< USB_IP_NUM; index++) USBD_Init(index); ICUSB_Drv_Init(); if (blocking == KAL_TRUE) { kal_retrieve_eg_events(g_UsbHostIccd[iccd_index].start_event_id, EVENT_ICUSB_ENUMERATION_DONE|EVENT_ICUSB_ENUMERATION_FAIL, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); if (event_group & EVENT_ICUSB_ENUMERATION_FAIL) return KAL_FALSE; else return KAL_TRUE; } else { return KAL_TRUE; } }
kal_bool IC_USB_Reset_Card(kal_uint8 iccd_index) { kal_uint32 event_group; // SIM Driver reset level : 1. ICCD Reset 2. USB Reset USB_Host_ICCD_Reset_Card(iccd_index); kal_retrieve_eg_events(g_UsbHostIccd[iccd_index].start_event_id, EVENT_ICUSB_ENUMERATION_DONE|EVENT_ICUSB_ENUMERATION_FAIL, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); if (event_group & EVENT_ICUSB_ENUMERATION_FAIL) return KAL_FALSE; else return KAL_TRUE; }
/************************************************************************* * FUNCTION * ec_task_main * * DESCRIPTION * This function implements xyz task's entry function * * PARAMETERS * * RETURNS * None * * GLOBALS AFFECTED * *************************************************************************/ void ec_task_main( task_entry_struct * task_entry_ptr ) { kal_uint32 event_group; /*initialize function*/ if (e_compass_sensor_data.event == NULL) e_compass_sensor_data.event = kal_create_event_group("ECEVT"); e_compass_init(); while (1) { kal_retrieve_eg_events(e_compass_sensor_data.event,1,KAL_OR_CONSUME,&event_group,KAL_SUSPEND); e_compass_main_hdr(); } /* Do component task's processing here */ }
/***************************************************************************** * FUNCTION * jpim_evtdb_upddateEntry * DESCRIPTION * This function updates an entry in the event database. * The index (physical storage index) must refer to a valid entry * in the database, otherwise an "invalid index" error is returned. * If the sort index changes after the update, a new sort index is assigned * PARAMETERS * entry [IN/OUT] * RETURNS * jpim_error_code_enum *****************************************************************************/ kal_int32 jpim_evtdb_upddateEntry_ext(mmi_evtdb_java_entry_struct *entry, kal_uint8 db_type, kal_int32 vm_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_uint32 event_group; mmi_evtdb_java_set_entry_req_struct *p = (mmi_evtdb_java_set_entry_req_struct*) construct_local_para( sizeof(mmi_evtdb_java_set_entry_req_struct), TD_CTRL | TD_RESET); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_UPDDATEENTRY); jpim_evtdb_adjustEntry(entry, db_type); #ifdef JSR_75_PIM_EXTRA_ALARM_TIME_USER_DEFINE jpim_evtdb_adjustAlarmTime(entry, db_type, KAL_TRUE); #endif p->entry_ptr = entry; p->index = entry->handle; p->sort_type = MMI_EVTDB_SORT_BY_TIME; p->db_index = jpim_evtdb_transfer_tdl_db(db_type); jpim_evtdb_result = MMI_EVTDB_JAVA_ERROR; jpim_evtdb_state = JPIM_EVTDB_STATE_UPDATE_ENTRY; jpim_evtdb_index = 0xffff; jpim_evtdb_handle = 0xffff; if (jpim_check_vm_state(1, vm_id)) { jpim_send_ilm(p, MSG_ID_MMI_EVTDB_JAVA_SET_ENTRY_REQ); kal_retrieve_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_UPDATE_ENTRY, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); entry->index = jpim_evtdb_index; entry->handle = jpim_evtdb_handle; } else { free_local_para((local_para_struct*) p); } return jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result); }
/***************************************************************************** * FUNCTION * jpim_evtdb_getCount * DESCRIPTION * The function retrieves the total count of event database entries. * PARAMETERS * void * RETURNS * 0~n, -1 means database error *****************************************************************************/ kal_int32 jpim_evtdb_getCount(kal_uint8 db_type, kal_int32 vm_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_uint32 event_group; mmi_evtdb_java_get_entry_req_struct *p = (mmi_evtdb_java_get_entry_req_struct*) construct_local_para( sizeof(mmi_evtdb_java_get_entry_req_struct), TD_CTRL | TD_RESET); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_GETCOUNT); p->count = 0; p->entry_ptr = NULL; p->index = 1; p->sort_type = MMI_EVTDB_SORT_BY_TIME; p->db_index = jpim_evtdb_transfer_tdl_db(db_type); /* set cmccphk_state before send message!! */ jpim_evtdb_state = JPIM_EVTDB_STATE_GET_COUNT; jpim_evtdb_result = MMI_EVTDB_JAVA_ERROR; jpim_evtdb_count = -1; if (jpim_check_vm_state(0, vm_id)) { jpim_send_ilm(p, MSG_ID_MMI_EVTDB_JAVA_GET_ENTRY_REQ); kal_retrieve_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_GETCOUNT, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); } else { free_local_para((local_para_struct*) p); } if (jpim_evtdb_result != MMI_EVTDB_JAVA_SUCCESS) { return -1; } else { return jpim_evtdb_count; } }
void IspWaitNVsync(ISP_VSYNC_TIME_OUT_UNIT TimeOut, kal_int32 Num) { kal_uint32 EventGroup; if(TimeOut ==0 || TimeOut > IspVsyncTimeOut500MS) TimeOut = IspVsyncTimeOut500MS; if(Num == 0) return; while(Num>0) { _IspVsyncTimeOutReportStart(TimeOut); kal_set_eg_events(IspEventId,0,KAL_AND); kal_retrieve_eg_events(IspEventId,CAMERA_ISP_VD_READY_EVENT,KAL_OR_CONSUME,&EventGroup,KAL_SUSPEND); _IspVsyncTimeOutReportRelease(); Num--; } }
/***************************************************************************** * FUNCTION * jpim_evtdb_deleteEntry * DESCRIPTION * This function deletes an entry from the event database. * PARAMETERS * handle [IN] * RETURNS * jpim_error_code_enum *****************************************************************************/ kal_int32 jpim_evtdb_deleteEntry(kal_uint16 handle, kal_uint8 db_type, kal_int32 vm_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_uint32 event_group; mmi_evtdb_java_set_entry_req_struct *p = (mmi_evtdb_java_set_entry_req_struct*) construct_local_para( sizeof(mmi_evtdb_java_set_entry_req_struct), TD_CTRL | TD_RESET); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_DELETEENTRY); p->entry_ptr = NULL; p->index = handle; p->sort_type = MMI_EVTDB_SORT_BY_TIME; p->db_index = jpim_evtdb_transfer_tdl_db(db_type); jpim_evtdb_result = MMI_EVTDB_JAVA_ERROR; jpim_evtdb_state = JPIM_EVTDB_STATE_DELETE_ENTRY; if (jpim_check_vm_state(1, vm_id)) { jpim_send_ilm(p, MSG_ID_MMI_EVTDB_JAVA_SET_ENTRY_REQ); kal_retrieve_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_DELETE_ENTRY, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); } else { free_local_para((local_para_struct*) p); } return jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result); }
/************************************************************************* * FUNCTION * ccci_ipc_send_msg * * DESCRIPTION * This function is the internal api to send message * * PARAMETERS * ipc_task_id - * buffer_ptr - * msg_size - * wait_mode - * message_to_head - * * RETURNS * status - success/fail * *************************************************************************/ kal_bool ccci_ipc_send_msg(kal_uint32 ipc_task_id, void *buffer_ptr, kal_uint16 msg_size, kal_wait_mode wait_mode, kal_bool message_to_head) { kal_uint32 i, j ; kal_uint32 retrieved_events = 0, orig_local_addr = 0 , orig_peer_addr = 0, update_buff_addr=0; kal_int32 result = CCCI_SUCCESS; ipc_ilm_t *temp_ipc_ilm = (ipc_ilm_t *)buffer_ptr; ccci_io_request_t ior = {0}; CCCI_BUFF_T *p_ccci_buff; kal_uint32 len = 0; ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_TRA); ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_TRA_ILM, temp_ipc_ilm, temp_ipc_ilm->src_mod_id, temp_ipc_ilm->dest_mod_id, temp_ipc_ilm->sap_id, temp_ipc_ilm->msg_id, temp_ipc_ilm->local_para_ptr, temp_ipc_ilm->peer_buff_ptr); /* get ext queue id from mapping table of task id - destnation*/ for (i = 0; i < MAX_CCCI_IPC_TASKS; i++) { if ( ccci_ipc_maptbl[i].task_id == ipc_task_id ) { break; } } /* get ext queue id from mapping table of task id - source*/ for (j = 0; j < MAX_CCCI_IPC_TASKS; j++) { if ( ccci_ipc_maptbl[j].task_id == temp_ipc_ilm->src_mod_id ) { break; } } /* check src mod id, if it's not defined in CCCI IPC, don't set used bit */ if(j >= MAX_CCCI_IPC_TASKS) { ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_TASKID_ERROR, ipc_task_id, temp_ipc_ilm->src_mod_id); return KAL_FALSE; } /* check if the extquque id can not be found */ if (i >= MAX_CCCI_IPC_TASKS) { ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_TASKID_ERROR, ipc_task_id, temp_ipc_ilm->src_mod_id); ((CCCI_IPC_ILM_T*)buffer_ptr)->used = 0; return KAL_FALSE; } /* check if the extquque id is to AP */ if ((ccci_ipc_maptbl[i].extq_id & AP_UINFY_ID_FLAG) == 0) { ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_DESTID_ERROR, ipc_task_id); ((CCCI_IPC_ILM_T*)buffer_ptr)->used = 0; return KAL_FALSE; } /* check if the ilm buffer is from ipc_msgsvc_allocate_ilm or not */ if (buffer_ptr != &ccci_ipc_ilm_arr[j].ipc_ilm){ ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_ILM_ERROR); return KAL_FALSE; } len = sizeof(CCCI_BUFF_T) + sizeof(ipc_ilm_t); if (temp_ipc_ilm->local_para_ptr != NULL){ len+= temp_ipc_ilm->local_para_ptr->msg_len ; } if( temp_ipc_ilm->peer_buff_ptr != NULL){ len+= sizeof(peer_buff_struct) + temp_ipc_ilm->peer_buff_ptr->pdu_len + temp_ipc_ilm->peer_buff_ptr->free_header_space + temp_ipc_ilm->peer_buff_ptr->free_tail_space; } //assert if ilm size > CCCI_IPC_GPD size EXT_ASSERT(len < CCCI_IPC_GPD_SIZE, len, CCCI_IPC_GPD_SIZE, 0); /* Use critical section to protect ENTER */ CCCI_IPC_ENTER_CRITICAL_SECTION if (KAL_TRUE == kal_query_systemInit()){ // polling mode ior.first_gpd = ccci_ipc_ch.p_polling_gpd; ior.last_gpd = ccci_ipc_ch.p_polling_gpd; } else{ #ifdef __SDIOC_PULL_Q_ENH_DL__ ior.num_gpd = #endif qbmt_alloc_q_no_tail( CCCI_IPC_GPD_TYPE, /* type */ 1, /* buff_num */ (void **)(&ior.first_gpd), /* pp_head */ (void **)(&ior.last_gpd)); /* pp_tail */ if(ior.first_gpd == NULL){ ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_ALLOC_GPD_ERROR); return KAL_FALSE; } } //initialize GPD CCCI_Header content p_ccci_buff = CCCIDEV_GET_QBM_DATAPTR(ior.first_gpd); p_ccci_buff->data[1] = (kal_uint32)len; p_ccci_buff->channel = (kal_uint32)ccci_ipc_ch.send_channel; p_ccci_buff->reserved = (kal_uint32)ccci_ipc_maptbl[i].extq_id; ccci_debug_add_seq(p_ccci_buff, CCCI_DEBUG_ASSERT_BIT); // add ccci seq QBM_DES_SET_DATALEN(ior.first_gpd, p_ccci_buff->data[1]); QBM_DES_SET_DATALEN(ior.first_gpd->p_data_tbd, p_ccci_buff->data[1]); qbm_cal_set_checksum((kal_uint8 *)ior.first_gpd); qbm_cal_set_checksum((kal_uint8 *)ior.first_gpd->p_data_tbd); QBM_CACHE_FLUSH(ior.first_gpd, sizeof(qbm_gpd)); QBM_CACHE_FLUSH(ior.first_gpd->p_data_tbd, sizeof(qbm_gpd)); //copy ilm to GPD temp_ipc_ilm->src_mod_id = ccci_ipc_maptbl[j].extq_id; update_buff_addr = (kal_uint32)p_ccci_buff; update_buff_addr += sizeof(CCCI_BUFF_T); CCCI_KAL_MSG_TO_AP_MSG(temp_ipc_ilm->msg_id, temp_ipc_ilm->msg_id); kal_mem_cpy((kal_uint8 *)update_buff_addr ,(kal_uint8 *)temp_ipc_ilm, sizeof(ipc_ilm_t)); if (temp_ipc_ilm->local_para_ptr != NULL){ //copy loca_para_struct to GPD update_buff_addr += sizeof(ipc_ilm_t); //24 bytes orig_local_addr = update_buff_addr; kal_mem_cpy((kal_uint8 *)update_buff_addr,(kal_uint8 *)temp_ipc_ilm->local_para_ptr, temp_ipc_ilm->local_para_ptr->msg_len); } if( temp_ipc_ilm->peer_buff_ptr != NULL){ //copy peer buff_struct to GPD if (temp_ipc_ilm->local_para_ptr != NULL){ update_buff_addr += temp_ipc_ilm->local_para_ptr->msg_len;//should be 4 bytes alignment?? } else{ update_buff_addr += sizeof(ipc_ilm_t); //24 bytes } orig_peer_addr = update_buff_addr; kal_mem_cpy((kal_uint8 *)update_buff_addr,(kal_uint8 *)temp_ipc_ilm->peer_buff_ptr, sizeof(peer_buff_struct) + temp_ipc_ilm->peer_buff_ptr->pdu_len + temp_ipc_ilm->peer_buff_ptr->free_header_space + temp_ipc_ilm->peer_buff_ptr->free_tail_space); } free_local_para(temp_ipc_ilm->local_para_ptr); temp_ipc_ilm->local_para_ptr = (local_para_struct *)orig_local_addr;//assign not NULL ptr to indicate there have content free_peer_buff(temp_ipc_ilm->peer_buff_ptr); temp_ipc_ilm->peer_buff_ptr = (peer_buff_struct *)orig_peer_addr;//assign not NULL ptr to indicate there have content QBM_CACHE_FLUSH(p_ccci_buff, len); if (KAL_TRUE == kal_query_systemInit()){ // polling mode result = ccci_polling_io(ccci_ipc_ch.send_channel, ccci_ipc_ch.p_polling_gpd, KAL_TRUE); CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_ipc_ch.p_polling_gpd,ccci_ipc_ch.p_polling_gpd); } else{ result = ccci_ipc_ch.ccci_write_gpd(ccci_ipc_ch.send_channel, &ior, NULL); if (KAL_INFINITE_WAIT == wait_mode && CCCI_SUCCESS == result){ /* Wait for feedabck by retrieve event */ kal_retrieve_eg_events(ccci_ipc_ch.event, 1 << i, KAL_AND_CONSUME, &retrieved_events, KAL_SUSPEND); } } /* Exit critical section */ CCCI_IPC_EXIT_CRITICAL_SECTION ((CCCI_IPC_ILM_T*)buffer_ptr)->used = 0; ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_TRA_CCCI, p_ccci_buff->data[0], p_ccci_buff->data[1], p_ccci_buff->channel, p_ccci_buff->reserved); ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_PASS_TRA); /* Finish */ if (result == CCCI_SUCCESS){ return KAL_TRUE; } else{ return KAL_FALSE; } }
/***************************************************************************** * FUNCTION * media_player_do_recover * DESCRIPTION * The function is to do recover * PARAMETERS * void * RETURNS * void *****************************************************************************/ media_error_t media_player_do_recover(media_player_t* mp, media_time_t key_frame_time) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ media_player_cntx_struct* self = SELF(mp, media_player_cntx_struct, itf); VIDEO_DECODER_QUERY_I_FRM_T query; VIDEO_ERROR_TYPE_T error; kal_bool found; kal_uint64 decode_time, diff; media_data_t *node = NULL, *head = NULL, *found_node = NULL; VIDEO_COMPONENT_TYPE_T *dec_handle = self->decoder_handle; kal_uint32 event_group, format_index; media_codec_type_t codec_type; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ kal_trace(TRACE_FUNC, VID_TRC_MEDIA_PLAYER_JUMP_TO_I_FRAME, self->state, (kal_uint32)key_frame_time); if (self->state == MPLY_STATE_CLOSED || self->state == MPLY_STATE_OPENED || self->state == MPLY_STATE_PREPARED || self->state == MPLY_STATE_SEEKING || self->state == MPLY_STATE_SEEK_DONE) { return MED_E_WRONG_STATE; } ASSERT(self->vid_stream_index != MEDIA_PLAYER_INVALID_INDEX); kal_take_mutex(media_player_mutex); /************************************************** ** Jump to I frame in file **************************************************/ if (key_frame_time > 0) { /* Flush frame */ error = dec_handle->pfnSetParameter(VIDEO_PARAM_FLUSH_FRM, NULL); ASSERT(error == VIDEO_ERROR_NONE || error == VIDEO_ERROR_NO_FRAME_TO_FLUSH); /* Wait until flush frame is done */ if (error == VIDEO_ERROR_NONE) { /* release mutex for decoder to release frame */ kal_give_mutex(media_player_mutex); MPLY_SET_FLAG(MPLY_FLAG_WAIT_FLUSH_FRAME); kal_retrieve_eg_events(media_player_comp_eg, MEDIA_PLAYER_EG_DECODER_FLUSH_FRAME_DONE, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); MPLY_UNSET_FLAG(MPLY_FLAG_WAIT_FLUSH_FRAME); kal_take_mutex(media_player_mutex); } /* Flush frame in queue */ media_player_reset_queue(mp, MPLY_QUEUE_VIDEO_WRITTEN); media_player_reset_queue(mp, MPLY_QUEUE_VIDEO); self->vid_life_cycle_id ++; self->vid_queue_num = 0; MPLY_UNSET_FLAG(MPLY_FLAG_VID_BUFF_FULL); /* Enable skip non-I frame */ MPLY_SET_FLAG(MPLY_FLAG_SKIP_NON_I_FRAME); self->key_frame_time = key_frame_time; goto finish; } /************************************************** ** Jump to I frame in queue **************************************************/ codec_type = self->vid_stream.dec_config.codec; format_index = mpl_get_vid_custom_format_index(codec_type); diff = mply_custom_get_cust(format_index, 2); ASSERT(diff > 0); error = self->decoder_handle->pfnGetParameter(VIDEO_PARAM_QUERY_DECODE_TIME, &decode_time); decode_time = MEDIA_PLAYER_COMPTIME_TO_TIME(decode_time); found = KAL_FALSE; /* Search I frame with max T from queue's head */ if (self->video_queue) { node = head = self->video_queue->next; do { if ((node->flags & MEDIA_DATA_FLAG_KEY_FRAME) && (node->display_time <= decode_time + diff)) { found = KAL_TRUE; found_node = node; } node = node->next; } while (node != head); } kal_trace(TRACE_FUNC, VID_TRC_MEDIA_PLAYER_JUMP_INFO, found, (kal_uint32)decode_time, (kal_uint32)diff); /* If I frame is found, drop P, B frame */ if (found && found_node != NULL) { /* Flush all the frame in decoder */ error = dec_handle->pfnSetParameter(VIDEO_PARAM_FLUSH_FRM, NULL); ASSERT(error == VIDEO_ERROR_NONE || error == VIDEO_ERROR_NO_FRAME_TO_FLUSH); /* Wait until flush frame is done */ if (error == VIDEO_ERROR_NONE) { kal_give_mutex(media_player_mutex); MPLY_SET_FLAG(MPLY_FLAG_WAIT_FLUSH_FRAME); kal_retrieve_eg_events(media_player_comp_eg, MEDIA_PLAYER_EG_DECODER_FLUSH_FRAME_DONE, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); MPLY_UNSET_FLAG(MPLY_FLAG_WAIT_FLUSH_FRAME); kal_take_mutex(media_player_mutex); } /* Flush frame in queue */ media_player_reset_queue(mp, MPLY_QUEUE_VIDEO_WRITTEN); self->vid_life_cycle_id ++; self->vid_queue_num = 0; MPLY_UNSET_FLAG(MPLY_FLAG_VID_BUFF_FULL); /* Flush P, B frame in queue */ head = self->video_queue->next; while(head != found_node) { media_player_remove_from_queue(&self->video_queue, head); head->release(head); self->vid_queue_num --; head = self->video_queue->next; } goto finish; } /************************************************** ** Jump to I frame in decoder **************************************************/ /* Check if decoder input queue has I frame */ query.u8TimeDifference = MEDIA_PLAYER_TIME_TO_COMPTIME(diff); query.fgRet = KAL_FALSE; error = self->decoder_handle->pfnGetParameter(VIDEO_PARAM_IS_I_FRM_IN_QUEUE, &query); ASSERT(error == VIDEO_ERROR_NONE); if (query.fgRet) { error = self->decoder_handle->pfnSetParameter(VIDEO_PARAM_FLUSH_FRM_BEFORE_I, NULL); goto finish; } finish: mpl_start_timer( MPL_PLAYER_RECOVER_TIMER, MPLY_RESET_RECOVER_ELAPSE, media_player_reset_recover, self); kal_give_mutex(media_player_mutex); return MED_S_OK; }
uint32 L1Audio_GetEventGroup( void ) { uint32 retrieved_events; kal_retrieve_eg_events( l1audio.aud_events, 0xFFFF, KAL_OR_CONSUME, &retrieved_events, KAL_SUSPEND ); return retrieved_events; }
/* ------------------------------------------------------------------------------ */ void L1Audio_Task(unsigned argc, void *argv) { uint32 retrieved_events; uint32 I; uint16 tempID; l1audio.aud_events = kal_create_event_group("L1Audio"); l1audio.hisr = kal_init_hisr(L1AUDIO_HISR); GET_SLEEP_HANDLE(); #if ( defined( __CENTRALIZED_SLEEP_MANAGER__ ) && defined(MTK_SLEEP_ENABLE) && !defined(__AUDIO_POWERON_RESET_DSP__) ) l1audio.md2g_pdn_handle = L1D_MD2G_PWD_GetHandle(); l1audio.l1sm_handle = L1SM_IntGetHandle(); #endif l1audio.runningState = 0; l1audio.disallowSleepState = 0; l1audio.dsp_slow_idle_counter = 0; l1audio.event_flag = 0; l1audio.id_flag = 0; l1audio.media_flag = 0; l1audio.postHisrHandler = (L1Audio_EventHandler)0; l1audio.sema = kal_create_sem( "Aud_Sema", 1 ); l1audio.hisrMagicFlag = 0; for( I = 0; I < MAX_HISR_HANDLER; I++ ) l1audio.hisrMagicNo[I] = 0; tempID = L1Audio_GetAudioID(); L1Audio_SetFlag(tempID); DSP_DynamicDownload_Init(); #ifndef L1D_TEST /// Dynamic download for A/V sync #if defined( DSP_WT_SYN ) && !defined(__AUDIO_COMPONENT_SUPPORT__) DSP_DynamicDownload( DDID_WAVETABLE ); #endif #endif AM_Init(); #if APM_SUPPORT APM_Init(); #endif /// AFE_Init will invoke L1Audio_GetAudioID /// and expect to get the id 0 to make sure /// it has the highest priority in the event group AFE_Init(); #if !defined(__SMART_PHONE_MODEM__) && !defined(__L1_STANDALONE__) && !defined( MED_MODEM ) AVsync_Init(); #endif #if defined(__AUDIO_POWERON_RESET_DSP__) { uint32 _savedMask; _savedMask = SaveAndSetIRQMask(); AFE_Init_status(KAL_TRUE); AFE_RegisterBackup(); RestoreIRQMask(_savedMask); } #endif L1SP_Init(); ktInit( L1Audio_GetAudioID() ); toneInit( L1Audio_GetAudioID() ); mediaInit( L1Audio_GetAudioID() ); #if defined(VR_CYBERON) vrsdInit(); #elif defined(VRSI_CYBERON) vrsiInit(); #endif toneLoopbackRecInit(); #if ( defined(__BT_A2DP_PROFILE__) || defined(SBC_UNIT_TEST) ) //&& !(APM_SUPPORT) SBC_Init(); #endif #if defined(__BES_TS_SUPPORT__) AudioPP_TS_Init(); #endif #ifdef __CTM_SUPPORT__ l1ctm_init(); #endif #ifdef __TWOMICNR_SUPPORT__ Two_Mic_NR_chip_Init(); #endif #if VMI_SUPPORT || defined(VORTP_UNIT_TEST) VMI_Init(); #endif #if VORTP_SUPPORT || defined(VORTP_UNIT_TEST) VoRTP_Init(); #endif #if defined(CYBERON_DIC_TTS) || defined(IFLY_TTS) || defined(SINOVOICE_TTS) ttsInit(); #endif #if defined( DSP_WT_SYN ) && !defined(__AUDIO_COMPONENT_SUPPORT__) DSPSYN_HW_Init(); #endif #if defined( __I2S_INPUT_MODE_SUPPORT__ ) I2S_init(); #endif #if defined(__VOICE_CHANGER_SUPPORT__) VCHG_Initialize(); #endif #if defined(__AUDIO_COMPONENT_SUPPORT__) && !defined(__L1_STANDALONE__) && !defined(MED_MODEM) // KH : for audio component ACU_Init(); #endif #if defined(__CVSD_CODEC_SUPPORT__) { extern void BT_SCO_Init(void); BT_SCO_Init(); } #endif memset( &(l1audio.debug_info), 0, sizeof(l1audio.debug_info) ); AFE_TurnOnFIR( L1SP_SPEECH ); AFE_TurnOnFIR( L1SP_VOICE ); L1Audio_ClearFlag(tempID); L1Audio_FreeAudioID(tempID); l1audio.isInitiated = KAL_TRUE; while( 1 ) { #if VERIFY_DATA_TO_DSP VERIFY_DATA_TO_DSP_SAVE_DATA(); #endif kal_retrieve_eg_events(l1audio.aud_events,0xFFFF,KAL_OR_CONSUME,&retrieved_events,KAL_SUSPEND); l1audio.retrieved_events = retrieved_events; l1audio.events_l1FN = L1I_GetTimeStamp(); for( I = 0; I < MAX_AUDIO_FUNCTIONS; I++ ) { if ( l1audio.retrieved_events & (1<<I) ) { l1audio.evHandler[I]( l1audio.evData[I] ); } } //if( (l1audio.runningState & l1audio.disallowSleepState) == 0 ) if( l1audio.runningState == 0 ) SLEEP_UNLOCK(); } }
/************************************************************************* * FUNCTION * mdci_read * * DESCRIPTION * This function reads data through either mailbox channel or stream * channel. * * PARAMETERS * channel - logical channel * buff - pointer to channel buffer * * RETURNS * MDIF error code. * *************************************************************************/ kal_int32 mdci_read(MDCI_CHANNEL_T channel, MDCI_BUFF_T *buff) { kal_uint32 owner, mask, ret, event; kal_char event_name[20]; #ifdef __IVP__ dbg_print("Error.... can not use mdci_read in IVP\n\r"); while(1); #endif /* check if a LISR is running */ if (kal_if_lisr()) return MDCI_IN_LISR; /* check parameters */ if (channel >= MDCI_MAX_CHANNEL) return MDCI_INVALID_PARAM; if (buff == NULL) return MDCI_INVALID_PARAM; /* get the current task */ owner = (kal_uint32)kal_get_current_thread_ID(); /* check owner */ if (mdci_ctrl_pool[channel].owner != owner && mdci_is_chanel_need_check_owner(channel)) { return MDCI_NOT_OWNER; } /* create an event for the first use */ if (mdci_ctrl_pool[channel].event == NULL) { sprintf(event_name, "MDIF%d event", channel); mdci_ctrl_pool[channel].event = kal_create_event_group(event_name); if (mdci_ctrl_pool[channel].event == NULL) ASSERT(0); } /* check state */ ret = MDCI_SUCCESS; mask = SaveAndSetIRQMask(); if (mdci_ctrl_pool[channel].state != MDCI_IDLE) { ret = MDCI_IN_USE; } else { /* set ACTIVE_WRITE */ mdci_ctrl_pool[channel].state = MDCI_ACTIVE_READ; } RestoreIRQMask(mask); if (ret != MDCI_SUCCESS) return ret; #ifndef __IVP__ /* wait for the event */ kal_retrieve_eg_events(mdci_ctrl_pool[channel].event, 1, KAL_OR_CONSUME, &event, KAL_SUSPEND); #endif if (event != 1) { ASSERT(0); } /* read channel buffer */ memcpy(buff, &(mdci_ctrl_pool[channel].buff), sizeof(MDCI_BUFF_T)); /* set ACTIVE_IDLE */ mdci_ctrl_pool[channel].state = MDCI_IDLE; return MDCI_SUCCESS; }
/***************************************************************************** * FUNCTION * jpim_evtdb_fetchByIndex * DESCRIPTION * This function retrieves an entry from the event database. The data is filled into "entry" parameter. * PARAMETERS * entry [OUT] * index [IN] 0~n-1 * sort_type [IN] jpim_evtdb_sort_enum * db_type [IN] jpim_evtdb_db_enum * RETURNS * jpim_error_code_enum *****************************************************************************/ kal_int32 jpim_evtdb_fetchByIndex(mmi_evtdb_java_entry_struct *entry, kal_uint16 index, kal_uint8 sort_type, kal_uint8 db_type, kal_int32 vm_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_uint32 event_group; mmi_evtdb_java_get_entry_req_struct *p = (mmi_evtdb_java_get_entry_req_struct*) construct_local_para( sizeof(mmi_evtdb_java_get_entry_req_struct), TD_CTRL | TD_RESET); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ p->entry_ptr = entry; p->index = index; p->sort_type = MMI_EVTDB_SORT_BY_TIME; p->db_index = jpim_evtdb_transfer_tdl_db(db_type); p->count = 1; jpim_evtdb_result = MMI_EVTDB_JAVA_ERROR; jpim_evtdb_state = JPIM_EVTDB_STATE_GET_ENTRY; if (jpim_check_vm_state(0, vm_id)) { jpim_send_ilm(p, MSG_ID_MMI_EVTDB_JAVA_GET_ENTRY_REQ); kal_retrieve_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_FETCH_INDEX, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_FETCHBYINDEX, entry->handle, entry->index); } else { free_local_para((local_para_struct*) p); } if(jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result) == JPIM_SUCCESS) { #ifdef JSR_75_PIM_EXTRA_ALARM_TIME_USER_DEFINE jpim_evtdb_adjustAlarmTime(entry, db_type, KAL_FALSE); #endif #ifndef __COSMOS_MMI_PACKAGE__ if (db_type == JPIM_EVTDB_REMINDER || db_type == JPIM_EVTDB_MEETING || db_type == JPIM_EVTDB_COURSE || db_type == JPIM_EVTDB_DATE || db_type == JPIM_EVTDB_CALL|| db_type == JPIM_EVTDB_ANNIVERSARY || db_type == JPIM_EVTDB_ALL) #else if (db_type == JPIM_EVTDB_PERSONAL || db_type == JPIM_EVTDB_MEETING || db_type == JPIM_EVTDB_SPECIALDAY || db_type == JPIM_EVTDB_BIRTHDAY || db_type == JPIM_EVTDB_OTHERS || db_type == JPIM_EVTDB_ALL) #endif { if (applib_dt_compare_time(&(entry->endTime), &(entry->startTime), NULL) == DT_TIME_LESS) { memcpy(&(entry->endTime), &(entry->startTime), sizeof(applib_time_struct)); } } if (db_type == JPIM_EVTDB_TASK) { #ifdef JSR_75_PIM_EXTRA_TODO if (entry->status == SRV_TDL_STATUS_UNDONE) { entry->complete_time.nYear = 0; entry->complete_time.nMonth = 0; entry->complete_time.nDay = 0; } #endif } } return jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result); }
HIF_RESULT hif_dma_read_internal(HIF_HANDLE handle, HIF_TYPE type, kal_uint32 addr, kal_uint32 size, HIF_CALLBACK fCB) { HIF_RESULT result = HIF_RESULT_OK; HIF_INTERNAL_HANDLE_T* pHandle = (HIF_INTERNAL_HANDLE_T*) handle; kal_uint32 retrieved_events; // Enable HIF interrupt. ENABLE_HIF_INTR(pHandle->engine_id); pHandle->DMA_BUSY = KAL_TRUE; #ifdef MTK_SLEEP_ENABLE L1SM_SleepDisable(hif_sleepMode_handle[pHandle->engine_id]);//unlock MD sleep mode #endif if (fCB == NULL) { if(!(kal_if_lisr()||kal_if_hisr())) { //Clear the evnet for pHandle->engine_id HIF for task level kal_set_eg_events(hif_events, ~(1 << pHandle->engine_id), KAL_AND); } else ASSERT(0); //HIF DMA blocking mode is not allowed in LISR or HISR } // Setup HIF. //SET_HIF_BUS_WIDTH(pHandle->engine_id, pHandle->config.hif_bus_width); SET_HIF_READ(pHandle->engine_id); if(type == HIF_TYPE_A0H_DMA) { SET_HIF_A0_HIGH(pHandle->engine_id); } else if(type == HIF_TYPE_A0L_DMA) { SET_HIF_A0_LOW(pHandle->engine_id); } SET_HIF_DAMOUNT(pHandle->engine_id, size); /* // Set DMA address. PDMA_SET_BUF_ADDR(pHandle->engine_id, addr); PDMA_SET_RW_DIRECTION(pHandle->engine_id, 1); // 1:read; 0: write PDMA_SET_BUF_LEN(pHandle->engine_id, size); PDMA_SET_BURST_LEN(pHandle->engine_id, 7); PDMA_START(pHandle->engine_id); //Start DMA */ //dma config SLA_CustomLogging("HDM",1);//set for debug #if (defined(MT6752) && !defined(__ANDROID_MODEM__)) hif_dma_menu[pHandle->engine_id].addr = addr + 0x80000000; #else hif_dma_menu[pHandle->engine_id].addr = addr; #endif hif_dma_input[pHandle->engine_id].count = (pHandle->config.hif_bus_width == 16) ? (size >> 1) : size; hif_dma_input[pHandle->engine_id].type = DMA_HWRX; hif_dma_input[pHandle->engine_id].size = (pHandle->config.hif_bus_width == 16) ? DMA_SHORT : DMA_BYTE; hif_dma_input[pHandle->engine_id].callback = NULL; hif_dma_input[pHandle->engine_id].menu = (void*) &hif_dma_menu[pHandle->engine_id]; DMA_Config(hif_sysdma_id[pHandle->engine_id], &hif_dma_input[pHandle->engine_id], KAL_TRUE); // Set fCB as HIF interrupt callback. hif_cb[pHandle->engine_id] = fCB; // Start HIF START_HIF(pHandle->engine_id); if (fCB == NULL) { if(!(kal_if_lisr()||kal_if_hisr())) { kal_retrieve_eg_events(hif_events, (1<<pHandle->engine_id), KAL_OR_CONSUME, &retrieved_events, KAL_SUSPEND); pHandle->DMA_BUSY = KAL_FALSE; } else ASSERT(0); //HIF DMA blocking mode is not allowed in LISR or HISR } return result; }