/*****************************************************************************
* FUNCTION
* vid_init
* DESCRIPTION
* This function is used to init video module of media task.
* PARAMETERS
* void
* RETURNS
*
*****************************************************************************/
kal_bool vid_init(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
vid_context_p->state = VID_IDLE;
vid_context_p->aud_state = VID_AUD_IDLE;
vid_context_p->vid_event = kal_create_event_group("vid_events");
vid_context_p->vid_event_ext = kal_create_event_group("vid_events_ext");
vid_context_p->image_path_open = KAL_FALSE;
vid_context_p->em_mode = VID_EM_MODE_DISABLED;
#ifdef __MED_VID_MOD__
vid_context_p->audio_frame_num = 0;
vid_context_p->total_frame_num = 0;
vid_context_p->current_time = 0;
vid_context_p->total_time = 0;
vid_context_p->display_width = 0;
vid_context_p->display_height = 0;
vid_context_p->image_width = 0;
vid_context_p->image_height = 0;
vid_context_p->file_size = 0;
vid_context_p->storing_path[0] = 0;
vid_context_p->handle = NULL;
vid_context_p->data_idx = -1;
vid_context_p->play_speed = 100;
vid_context_p->vid_get_time_mutex = kal_create_mutex("VID_GET_TIME");
#endif /* __MED_VID_MOD__ */
#if defined(__MED_MJPG_MOD__)
vid_context_p->total_frame_num = 0;
vid_context_p->current_time = 0;
vid_context_p->total_time = 0;
vid_context_p->display_width = 0;
vid_context_p->display_height = 0;
vid_context_p->image_width = 0;
vid_context_p->image_height = 0;
vid_context_p->file_size = 0;
vid_context_p->storing_path[0] = 0;
vid_context_p->mjpeg_mutex = kal_create_mutex("VID_MJPEG");
vid_context_p->mjpeg_insert_frame_count = 1;
vid_context_p->mjpeg_is_jpg_encoding = KAL_FALSE;
/* init avi kernel */
med_avi_init();
#endif /* defined(__MED_MJPG_MOD__) */
#ifdef __MED_VID_EDT_MOD__
vid_context_p->edt_video_buff_p = NULL;
#endif /*__MED_VID_EDT_MOD__*/
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* aud_bt_a2dp_init
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void aud_bt_a2dp_init(void)
{
codec = NULL;
need_open_codec = KAL_FALSE;
mute_phone = KAL_FALSE;
codec_mutex = kal_create_mutex("a2dp_codec_mutex");
}
G2D_STATUS_ENUM g2dInit(void)
{
#if (defined(G2D_HW_SUPPORT) || defined(G2D_HW_SHARE_WITH_GOVL_SUPPORT))
#if defined(__MTK_TARGET__)
if (NULL == g2d_state_mutex)
{
g2d_state_mutex = kal_create_mutex("G2D State");
ASSERT(g2d_state_mutex != NULL);
g2d_mutex_init(&g2d_mutex);
}
#endif
/// we can't call mutex before task being initialized
/// kal_take_mutex(g2d_state_mutex);
/// kal_give_mutex(g2d_state_mutex);
#if defined(__MTK_TARGET__) || defined(G2D_FPGA)
g2d_drv_power_on();
g2d_drv_init();
g2d_drv_power_off();
#endif
#endif
#if defined(__MTK_TARGET__)
/* register bb reg dump */
g2d_dump.regions = (kal_uint32*)g2d_dump_regions;
g2d_dump.num = sizeof(g2d_dump_regions) / (sizeof(kal_uint32) * 3);
g2d_dump.bbreg_dump_callback = NULL;
EX_REGISTER_BBREG_DUMP(&g2d_dump);
#endif /* __MTK_TARGET__ */
return G2D_STATUS_OK;
}
/*****************************************************************************
* FUNCTION
* aud_vr_mutex_init
* DESCRIPTION
* init mutex for vr
* PARAMETERS
* M [?]
* name [?]
* RETURNS
* void
*****************************************************************************/
void aud_vr_mutex_init(aud_vr_mutex_struct *M, kal_char *name)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
M->mutex = kal_create_mutex(name);
M->cnt = 0;
M->tid = MOD_NIL;
}
void ICUSB_ICCD_Init(kal_uint8 iccd_index)
{
/* Initailize the information, Cannot create Event on HISR */
if(g_UsbHostIccd[iccd_index].event_id == 0)
g_UsbHostIccd[iccd_index].event_id = kal_create_event_group("USB_ICCD_EVEVT");
if(g_UsbHostIccd[iccd_index].mutex_id == 0)
g_UsbHostIccd[iccd_index].mutex_id = kal_create_mutex("USB_ICCD_MUTEX");
USB_GPTI_GetHandle(&(g_UsbHostIccd[iccd_index].sleep_timer_handle));// DclSGPT_Open(DCL_GPT_CB, 0);
// if (g_UsbHostIccd[iccd_index].sleep_timer_handle == 0)
// g_UsbHostIccd[iccd_index].sleep_timer_handle = USB_GPTI_GetHandle();// DclSGPT_Open(DCL_GPT_CB, 0);
// GPTI_GetHandle(&g_UsbHostIccd[iccd_index].sleep_timer_handle);
}
srv_ies_result srv_ies_job_init(srv_ies_app_session_handle hApp)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint32 taskID;
kal_int32 index;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (0 == g_srv_ies_hdl_mutex)
{
g_srv_ies_hdl_mutex = kal_create_mutex("IESHDLMX");
ASSERT(0 != g_srv_ies_hdl_mutex);
}
kal_take_mutex(g_srv_ies_hdl_mutex);
if (0 == g_srv_ies_job_user)
{
kal_get_my_task_index(&taskID);
if(INDX_MMI == taskID)
{
mmi_frm_set_protocol_event_handler(MSG_ID_IES_JOB_RSP,
&_srv_ies_job_response_handler,
MMI_FALSE);
}
memset(g_srv_ies_curr_job, 0x0, sizeof(srv_ies_job*) * SRV_IES_JOB_MAX_JOB_COUNT);
for (index = 0; index < SRV_IES_JOB_MAX_JOB_COUNT; index++)
{
g_srv_ies_job_pool[index].jobID = index;
}
}
hApp->appState |= SRV_IES_APP_STATE_JOB_INITED;
g_srv_ies_job_user++;
kal_give_mutex(g_srv_ies_hdl_mutex);
g_srv_ies_job_deinit = KAL_FALSE;
return SRV_IES_OK;
}
/*****************************************************************************
* FUNCTION
* ies_task_init
* DESCRIPTION
* image viewer daemon task init function
* PARAMETERS
* *task_indx [IN] task index
* RETURNS
* KAL_TRUE init OK
*****************************************************************************/
static kal_bool ies_task_init(task_indx_type task_indx)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
stack_set_active_module_id(INDX_IES, MOD_IES);
g_ies_task_context.pJob = NULL;
LIST_INIT(&(g_ies_task_context.normal));
LIST_INIT(&(g_ies_task_context.lowest));
g_srv_ies_job_mutex = kal_create_mutex("IESJOBMX");
g_srv_ies_job_event = kal_create_event_group("ies_evt");
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* med_utility_init
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
*
*****************************************************************************/
kal_bool med_utility_init(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
Media_Func_Reg_Type media_func;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
med_mem_mutex = kal_create_mutex("MED MEM");
/* Register callback functions to L1audio */
media_func.alloc_mem = med_util_alloc_aud_mem;
media_func.alloc_mem_cacheable = med_util_alloc_aud_cacheable_mem;
media_func.free_mem = med_util_free_aud_mem;
media_func.set_path_volume = NULL;
media_func.get_active_mode = NULL;
#if defined(__VOLTE_SUPPORT__)
media_func.send_proc_call = aud_send_in_proc_call_req; // is only used in VoLTE DTMF MCU destroy functions
#else
media_func.send_proc_call = NULL;
#endif
media_func.send_proc_call2 = NULL;
media_func.get_meta_file = NULL;
media_func.get_meta_array = NULL;
#if !defined(L1_NOT_PRESENT)
Audio_MedFuncReg(&media_func);
#endif
/* init audio memory */
med_set_aud_memory_pool((unsigned char*)med_context_p->aud_mem_p, MED_AUD_MEM_SIZE);
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* widget_show_view_handler
* DESCRIPTION
* Phonebook launch proc function
* PARAMETERS
* evt
* RETURNS
* void
*****************************************************************************/
void widget_show_view_handler(void *param)
{
widget_show_view_ind_struct *p = (widget_show_view_ind_struct *)param;
send_message(NULL, NULL, MSG_ID_WIDGET_SHOW_VIEW_CNF, MOD_GADGET);
if (!g_widget_view_lock)
{
g_widget_view_lock = kal_create_mutex("widget_view_lock");
}
if (g_widget_view_cntx)
{
ASSERT(mmi_frm_group_is_present(GRP_ID_WIDGET_VIEW));
mmi_frm_group_close(GRP_ID_WIDGET_VIEW);
}
g_widget_view_cntx = OslMalloc(sizeof(widget_view_context_struct));
ASSERT(g_widget_view_cntx);
memset(g_widget_view_cntx, 0, sizeof(widget_view_context_struct));
g_widget_view_cntx->widget_id = p->instance_id;
g_widget_view_cntx->view_handle = p->view_handle;
g_widget_view_cntx->view_width = p->width;
g_widget_view_cntx->view_height = p->height;
g_widget_view_cntx->view_type = p->type;
g_widget_view_cntx->view_flags = p->flags;
if (p->caption[0])
{
mmi_chset_utf8_to_ucs2_string(
(U8*) g_widget_view_cntx->view_caption,
sizeof(g_widget_view_cntx->view_caption),
(U8*) p->caption);
}
gdi_lcd_get_dimension(&g_widget_view_cntx->lcd_width, &g_widget_view_cntx->lcd_height);
if (g_confirm_dialog_gid)
{
mmi_frm_node_struct group_info;
group_info.id = GRP_ID_WIDGET_VIEW;
group_info.entry_proc = mmi_widget_view_event_handler_proc;
mmi_frm_group_insert(mmi_idle_get_group_id(), g_confirm_dialog_gid, &group_info, MMI_FRM_NODE_BEFORE_FLAG);
//mmi_frm_group_insert(GRP_ID_ROOT, g_confirm_dialog_gid, &group_info, MMI_FRM_NODE_BEFORE_FLAG);
mmi_frm_group_set_attribute (GRP_ID_WIDGET_VIEW, MMI_FRM_NODE_SMART_CLOSE_FLAG);
}
else
{
/*mmi_frm_group_create(
mmi_idle_get_group_id(),
GRP_ID_WIDGET_VIEW,
mmi_widget_view_event_handler_proc,
g_widget_view_cntx);*/
mmi_frm_node_struct group_info;
group_info.id = GRP_ID_WIDGET_VIEW;
group_info.entry_proc = mmi_widget_view_event_handler_proc;
group_info.user_data = g_widget_view_cntx;
mmi_frm_group_insert(GRP_ID_ROOT, mmi_idle_get_group_id(), &group_info, MMI_FRM_NODE_AFTER_FLAG);
mmi_frm_group_enter(GRP_ID_WIDGET_VIEW, MMI_FRM_NODE_SMART_CLOSE_FLAG);
}
mmi_widget_entry_view();
}
void BitCopy(const kal_uint8 *src, kal_uint16 srcOffset, kal_uint8 *dest, kal_uint16 *destOffset, kal_uint16 length)
{
kal_uint32 Input32Temp, BC_it;
kal_uint32 srcStartAddr, dstStartAddr;
kal_uint16 destOffsetTemp = *destOffset;
srcStartAddr = (kal_uint32) (src + ( srcOffset / 8 ));
srcOffset = srcOffset % 8;
dstStartAddr = (kal_uint32) (dest + ( (*destOffset) / 8 ));
(*destOffset) = (*destOffset) % 8;
if (!BC_mutex){
BC_mutex = kal_create_mutex("BC_mutex");}
kal_take_mutex(BC_mutex);
//reset all register
DRV_WriteReg32(BC_REG_START,0);
//input source addr
DRV_WriteReg32(BC_REG_SRC, ((kal_uint32)(srcStartAddr)));
//output destination addr
DRV_WriteReg32(BC_REG_DST, ((kal_uint32)(dstStartAddr)));
//output destination last byte addr
Input32Temp = ((length - (8 - (*destOffset))) > 0) ? (kal_uint32)(dstStartAddr + ((length - (8 - (*destOffset)) + 7) / 8)) : (kal_uint32)dstStartAddr;
DRV_WriteReg32(BC_REG_LDST, ((kal_uint32)Input32Temp));
//input copy length
Input32Temp = 0;
Input32Temp = length & 0x0000FFFF;
DRV_WriteReg32(BC_REG_SIZE, ((kal_uint32)Input32Temp));
//set wo and ro(also reset all)
Input32Temp = 0;
Input32Temp = (kal_uint32)(( ((kal_uint32)(*destOffset))<<4) | ((kal_uint32)srcOffset) | (0x00030000));
DRV_WriteReg32(BC_REG_CON, (kal_uint32)Input32Temp);
//start the BC engine
DRV_WriteReg32(BC_REG_START, 0x00008000);
//polling completed interrupt
while(1){
BC_it = DRV_Reg32(BC_REG_STA);
if((BC_it&0x00000002)!=0)
break;
}
kal_give_mutex(BC_mutex);
(*destOffset) = destOffsetTemp + length;
}
/*****************************************************************************
* FUNCTION
* _aud_build_cache_start
* DESCRIPTION
* This function is to start a building cache process
* PARAMETERS
* file_name [IN] The file to be built.
* cache_p [IN] Cache data.
* cache_size [IN] The size of cache data.
* proc_buf_p [IN] FS buffer.
* proc_buf_size [IN] The size of FS buffer.
* seek_pos [IN] The position to seek to.
* cb_fct [IN] Callback function.
* cb_param [IN] Callback parameter.
* progress_p [OUT] Build cache progress.
* RETURNS
* MED_RES_OK Successfully.
* Others Failed.
*****************************************************************************/
static kal_int32 _aud_build_cache_start(kal_wchar* file_name,
void* cache_p,
kal_int32 cache_size,
void* proc_buf_p,
kal_int32 proc_buf_size,
kal_uint32 seek_pos,
medv_audio_seek_cb_fct cb_fct,
void* cb_param,
kal_uint32* progress_p)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int32 result = MED_RES_OK;
med_aud_player_cfg_t player_cfg;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* Create build cache mutex */
if (g_build_cache_mutex == 0)
{
g_build_cache_mutex = kal_create_mutex("build_cache_mutex");
}
if (g_player_p == NULL)
{
/* Construct a media player */
g_player_p = aud_player_media_construct();
if (g_player_p != NULL)
{
/* Configure the player */
player_cfg.file_name = file_name;
player_cfg.data_p = NULL;
player_cfg.data_len = 0;
player_cfg.format = 0; /* Don't care */
player_cfg.repeat = 0; /* Don't care */
player_cfg.audio_path = 0; /* Don't care */
player_cfg.fast_pass = KAL_FALSE;
player_cfg.cb_fct = NULL; /* DO NOT hook callback */
player_cfg.cb_param = NULL; /* Don't care since no callback */
/* Open a player */
result = g_player_p->open(g_player_p, &player_cfg);
_AUD_MODULE_BUILD_CACHE1_TRACE(result);
if (result == MED_RES_OK) /* Open successful */
{
/* Set cache table */
med_aud_player_set_cache_t set_cache;
med_aud_player_set_buffer_t set_buf;
set_cache.cache_p = cache_p;
set_cache.cache_size = cache_size;
result = g_player_p->set(g_player_p, AUD_PLAYER_SET_CACHE_TABLE, (void*)&set_cache);
_AUD_MODULE_BUILD_CACHE1_TRACE(result);
if (proc_buf_p != NULL)
{
/* Use input buffer */
set_buf.buffer_p = proc_buf_p;
set_buf.buffer_size = proc_buf_size;
}
else
{
kal_uint32 mem_size;
/* Allocate buffer from topmost to avoid memory fragementation */
if(AUD_IN_STATE(AUD_MEDIA_IDLE)
#ifdef __MED_MMA_MOD__
&& !aud_mma_is_playing(AUD_MMA_CHECK_MODE_SINGLE)
#endif
)
{
mem_size = AUD_MED_BUILD_CACHE_NORMAL_BUF_SIZE;
}
else
{
mem_size = AUD_MED_BUILD_CACHE_BUF_SIZE;
}
g_proc_buf_p = (void*)med_alloc_aud_mem_topmost(mem_size);
MED_ASSERT(g_proc_buf_p != NULL);
set_buf.buffer_p = g_proc_buf_p;
set_buf.buffer_size = mem_size;
}
result = g_player_p->set(g_player_p, AUD_PLAYER_SET_BUFFER, (void*)&set_buf);
_AUD_MODULE_BUILD_CACHE1_TRACE(result);
}
else /* Open failed */
{
/* Close the player */
g_player_p->close(g_player_p);
g_player_p->destroy(g_player_p);
g_player_p = NULL;
}
}
}
/* Start building cache */
if (g_player_p && (!g_is_running))
{
g_build_cache_req.counter = g_counter;
g_build_cache_req.progress_p = progress_p;
g_build_cache_req.seek_pos = seek_pos;
g_build_cache_req.cb_fct = cb_fct;
g_build_cache_req.cb_param = cb_param;
aud_util_proc_in_med_v_ext(MOD_MED_V,
_aud_build_cache_process_func,
(void*)&g_build_cache_req,
sizeof(aud_build_cache_req_struct_t));
/* Turn on flag indicating the building cache process is running */
g_is_running = KAL_TRUE;
}
return result;
}
/* Note that this function should be called when first detect ms device*/
void USB_Host_Ms_State_Start(kal_uint8 ms_index)
{
kal_uint32 index;
kal_bool result;
// SGPT_CTRL_START_T start;
/* Initailize the information */
if(g_UsbHostMs[ms_index].event_id == 0)
g_UsbHostMs[ms_index].event_id = kal_create_event_group("USB_MS_EVEVT");
if(g_UsbHostMs[ms_index].mutex_id == 0)
g_UsbHostMs[ms_index].mutex_id = kal_create_mutex("USB_MS_MUTEX");
USB_GPTI_GetHandle(&(g_UsbHostMs[ms_index].gpt_handle));//DclSGPT_Open(DCL_GPT_CB, 0);//GPTI_GetHandle(&g_UsbHostMs.gpt_handle);
// if (g_UsbHostMs[ms_index].gpt_handle == 0)
// g_UsbHostMs[ms_index].gpt_handle = USB_GPTI_GetHandle();//DclSGPT_Open(DCL_GPT_CB, 0);//GPTI_GetHandle(&g_UsbHostMs.gpt_handle);
USB_GPTI_GetHandle(&(g_UsbHostMs[ms_index].sleep_timer_handle));//DclSGPT_Open(DCL_GPT_CB, 0);//GPTI_GetHandle(&g_UsbHostMs.gpt_handle);
// if (g_UsbHostMs[ms_index].sleep_timer_handle== 0)
// g_UsbHostMs[ms_index].sleep_timer_handle = USB_GPTI_GetHandle();//DclSGPT_Open(DCL_GPT_CB, 0);//GPTI_GetHandle(&g_UsbHostMs.gpt_handle);
/* Get LUN, it contains the error handling */
result = USB_Host_Ms_Comp_Get_LUN(ms_index);
if(result == KAL_TRUE)
{
/* The got LUN is total lun - 1 */
g_UsbHostMs[ms_index].total_lun++;
/* If LUN number is larger than we can support, onlt the first N can be detected */
if(g_UsbHostMs[ms_index].total_lun > USB_HOST_MS_SUPPORT_LUN)
g_UsbHostMs[ms_index].total_lun = USB_HOST_MS_SUPPORT_LUN;
}
else
{
/* when device not implement this command, it is only one LUN */
g_UsbHostMs[ms_index].dev_error_count = 0;
g_UsbHostMs[ms_index].total_lun = 1;
}
/* Reset all the LUN state to absent state */
for(index = 0; index < g_UsbHostMs[ms_index].total_lun; index++)
{
g_UsbHostMs[ms_index].media_info[index].state = USB_HOST_MS_MEDIA_STATE_ABSENT;
}
/* Get LUN is success, continue to query each LUN info */
result = USB_Host_Ms_Query_All_Media(ms_index);
/* If result is fail, ms has been detached */
if(result == KAL_TRUE)
{
/* Query each LUN is success, continue to check whether each LUN is in card slot or not */
result = USB_Host_Ms_Check_All_Media(ms_index);
/* If result is fail, ms has been detached */
}
drv_trace1(TRACE_FUNC, (kal_uint32)USB_HOST_MS_CHECK_MEDIA_STATE, g_UsbHostMs[ms_index].media_state_change);
USB_Dbg_Trace(USB_HOST_MS_REPORT_MEDIA_STATE, g_UsbHostMs[ms_index].media_state_change, (kal_uint32)g_UsbHostMs[ms_index].b_sending_change_ilm);
if(result == KAL_TRUE)
{
/* To prevent USB disconn intr coming during this moment */
IRQMask(USB_IRQ_MAP[g_UsbHostMs[ms_index].common_info.usb_ip_port]);
if((g_UsbHostMs[ms_index].media_state_change != 0)&&(g_UsbHostMs[ms_index].b_sending_change_ilm == KAL_FALSE))
{
USB_Host_Ms_Check_Media_State(ms_index);
}
/* If device is plugged out, do not send this message */
if(g_UsbHostMs[ms_index].dev_attatch == KAL_TRUE)
{
/* Start timer to query device state */
USB_GPTI_StartItem(g_UsbHostMs[ms_index].gpt_handle, USB_HOST_MS_QUERY_PERIOD,USB_Host_Ms_State_Timeout, &g_UsbHostMs);
// start.u2Tick =USB_HOST_MS_QUERY_PERIOD;
// start.pfCallback = USB_Host_Ms_State_Timeout;
// start.vPara = &g_UsbHostMs[ms_index];
// DclSGPT_Control((DCL_HANDLE)(g_UsbHostMs[ms_index].gpt_handle), SGPT_CMD_START, (DCL_CTRL_DATA_T*)&start);
}
if(USBD_Get_UnMask_Irq(g_UsbHostMs[ms_index].common_info) == KAL_TRUE)
IRQUnmask(USB_IRQ_MAP[g_UsbHostMs[ms_index].common_info.usb_ip_port]);
}
else
{
drv_trace0(TRACE_FUNC, (kal_uint32)USB_HOST_MS_STATE_START_FAIL);
}
}
