static void show_startup_iFram()
{
RET_CODE ret = SUCCESS;
void * p_video_dev = dev_find_identifier(NULL, DEV_IDT_TYPE,SYS_DEV_TYPE_VDEC_VSB);
void * p_disp_dev = dev_find_identifier(NULL, DEV_IDT_TYPE,SYS_DEV_TYPE_DISPLAY);
u32 size = dm_get_block_size(class_get_handle_by_id(DM_CLASS_ID),START_LOGO_BLOCK_ID);
u8 *addr = (u8 *)(dm_get_block_addr(class_get_handle_by_id(DM_CLASS_ID), START_LOGO_BLOCK_ID));
OS_PRINTF("$$$$$$$$$$ %s,%d,addr==%0x,size==%d\n\n",__FUNCTION__,__LINE__,addr,size);
dmx_av_reset(dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_PTI));
disp_layer_show(p_disp_dev, DISP_LAYER_ID_VIDEO_SD, FALSE);
disp_layer_show(p_disp_dev, DISP_LAYER_ID_VIDEO_HD, FALSE);
vdec_set_data_input(p_video_dev,1);
ret = vdec_start(p_video_dev, VIDEO_MPEG, VID_UNBLANK_STABLE);
ret = vdec_dec_one_frame(p_video_dev, (u8 *)addr, size);
MT_ASSERT(SUCCESS == ret);
disp_layer_show(p_disp_dev, DISP_LAYER_ID_VIDEO_SD, TRUE);
disp_layer_show(p_disp_dev, DISP_LAYER_ID_VIDEO_HD, TRUE);
vdec_set_data_input(p_video_dev,0);
}
void ui_ads_show_logo(void)
{
u32 cmd;
ads_info_t ads_info = {0};
memset(g_ad_data_buf, 0, 64*KBYTES);
ads_info.p_priv = g_ad_data_buf;
ads_dvbad_set_type(ADS_AD_TYPE_LOGO,&cmd,&ads_info);
ads_io_ctrl(g_adm_id,cmd,&ads_info);
DEBUG(ADS,INFO,"ads_data_len=%d\n", ads_info.ads_data_len);
DEBUG(ADS,INFO,"start show picture tickets2=%d\n", mtos_ticks_get());
if(ads_info.ads_data_len == 0)
{
DEBUG(ADS,INFO,"ads_show_logo no ad logo or logo is not mpeg\n");
return ;
}
else
{
RET_CODE ret = SUCCESS;
void * p_video_dev = dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_VDEC_VSB);
void * p_disp_dev = dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_DISPLAY);
vdec_stop(p_video_dev);
disp_layer_show(p_disp_dev, DISP_LAYER_ID_SUBTITL, FALSE);
vdec_set_data_input(p_video_dev,1);
ret = vdec_start(p_video_dev, VIDEO_MPEG, VID_UNBLANK_STABLE);
MT_ASSERT(SUCCESS == ret);
ret = vdec_dec_one_frame(p_video_dev, (u8 *)ads_info.p_priv, ads_info.ads_data_len);
MT_ASSERT(SUCCESS == ret);
ret = disp_layer_show(p_disp_dev, DISP_LAYER_ID_SUBTITL, TRUE);
MT_ASSERT(SUCCESS == ret);
}
}
void ui_show_logo(u8 block_id)
{
RET_CODE ret = SUCCESS;
void * p_video_dev = dev_find_identifier(NULL, DEV_IDT_TYPE,
SYS_DEV_TYPE_VDEC_VSB);
void * p_disp_dev = dev_find_identifier(NULL, DEV_IDT_TYPE,
SYS_DEV_TYPE_DISPLAY);
u32 size = dm_get_block_size(class_get_handle_by_id(DM_CLASS_ID), block_id);
u8 *p_logo = mtos_malloc(size);
MT_ASSERT(p_logo != NULL);
dm_read(class_get_handle_by_id(DM_CLASS_ID), block_id, 0, 0, size, p_logo);
#ifndef WIN32
#endif
ret = vdec_start(p_video_dev, VIDEO_MPEG, VID_UNBLANK_STABLE);
MT_ASSERT(SUCCESS == ret);
ret = vdec_dec_one_frame(p_video_dev, (u8 *)p_logo, size);
MT_ASSERT(SUCCESS == ret);
ret = disp_layer_show(p_disp_dev, DISP_LAYER_ID_VIDEO_SD, TRUE);
MT_ASSERT(SUCCESS == ret);
mtos_free(p_logo);
}
BOOL avc_av_start(void *p_data, video_param_t *p_video,
audio_param_t *p_audio, av_start_type_t type)
{
RET_CODE ret = SUCCESS;
avc_var_t *p_avc_data = (avc_var_t *)p_data;
if(type == AV_AUDIO_START || type == AV_START_ALL)
{
ret = aud_start_vsb(p_avc_data->p_audio_dev, p_audio->type, p_audio->file_type);
CHECK_FAIL_RET_FALSE(ret == SUCCESS);
}
OS_PRINTF("---------->>avc av start %d\n",p_video->format);
if(type == AV_VIDEO_START || type == AV_START_ALL)
{
ret |= vdec_set_data_input(p_avc_data->p_video_dev, p_video->file_play);
CHECK_FAIL_RET_FALSE(ret == SUCCESS);
ret |= vdec_start(p_avc_data->p_video_dev, p_video->format, p_video->mode);
CHECK_FAIL_RET_FALSE(ret == SUCCESS);
}
return ret == SUCCESS ? TRUE : FALSE;
}
void ui_show_logo_by_data(u32 size, u8 *p_logo_addr)
{
RET_CODE ret = SUCCESS;
void * p_video_dev = dev_find_identifier(NULL, DEV_IDT_TYPE,
SYS_DEV_TYPE_VDEC_VSB);
void * p_disp_dev = dev_find_identifier(NULL, DEV_IDT_TYPE,
SYS_DEV_TYPE_DISPLAY);
u8 *p_logo = mtos_malloc(size);
MT_ASSERT(p_logo != NULL);
memcpy(p_logo, p_logo_addr, size);
ret = vdec_start(p_video_dev, VIDEO_MPEG, VID_UNBLANK_STABLE);
MT_ASSERT(SUCCESS == ret);
ret = vdec_dec_one_frame(p_video_dev, (u8 *)p_logo, size);
MT_ASSERT(SUCCESS == ret);
ret = disp_layer_show(p_disp_dev, DISP_LAYER_ID_VIDEO_SD, TRUE);
MT_ASSERT(SUCCESS == ret);
mtos_free(p_logo);
}
void win_ci_on_transport_connect(UINT8 slot)
{
UINT8 i;
struct nim_device *nim_dev;
struct dmx_device *dmx_dev;
struct vdec_device *vdec_dev;
UINT32 scrm_flag;
UINT8 dmx_id, nim_id, slot_id;
#ifdef CI_BYPASS_ENABLE
BOOL ci_bypass = FALSE;
UINT8 lock = 0;
#endif
#ifdef NEW_DEMO_FRAME
struct ts_route_info ts_route;
INT32 ts_route_id;
#endif
static UINT8 m_ci_inited;
if (!m_ci_inited)
{
api_ci_set_mode(SYS_CI_MODE);
api_ci_set_dev(g_nim_dev, g_dmx_dev, 0);
#if (CI_SLOT_NS > 1)
api_ci_set_dev(g_nim_dev, g_dmx_dev, 1);
#endif
api_set_nim_ts_type(2, 0xff);
m_ci_inited = 1;
}
if (CAM_STACK_ATTACH == api_ci_check_status(slot))
{
#ifdef DVR_PVR_SUPPORT
#ifdef CI_SLOT_DYNAMIC_DETECT
api_set_ci_slot_attached(slot, TRUE);
#endif
#endif
extern UINT8 g_ca_prog_reset_flag;
g_ca_prog_reset_flag = 0;
nim_id = 0;
dmx_id = 0;
#ifdef NEW_DEMO_FRAME
ts_route_id = ts_route_check_ci(slot);
if((ts_route_id >= 0) && (ts_route_get_by_id(ts_route_id, &ts_route) != RET_FAILURE))
{
nim_id = ts_route.nim_id;
dmx_id = ts_route.dmx_id;
}
#endif
nim_dev = (struct nim_device*)dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id);
dmx_dev = (struct dmx_device*)dev_get_by_id(HLD_DEV_TYPE_DMX, dmx_id);
api_ci_set_mode(sys_data_get_ci_mode());
api_ci_set_dev(nim_dev, dmx_dev, slot);
#ifdef CI_BYPASS_ENABLE
//for not scrambled program, bypass cam!
if ((screen_back_state != SCREEN_BACK_MENU/*play tv/radio*/)
#ifdef DVR_PVR_SUPPORT
|| (api_pvr_check_tsg_state()/*tsg*/)
#endif
)
{
#ifdef DVR_PVR_SUPPORT
if (api_pvr_check_tsg_state())
{
;
}
else
#endif
{
nim_get_lock(nim_dev, &lock);
//!scrambled program
if (lock
&& dmx_dev != NULL
&& SUCCESS != dmx_io_control(dmx_dev, IS_AV_SCRAMBLED, (UINT32)&scrm_flag))
{
ci_bypass = TRUE;
}
}
}
if (!ci_bypass)
{
api_set_nim_ts_type(3, 1<<slot);
api_send_ca_pmt(slot);
}
#else //CI_BYPASS_ENABLE
//always pass cam!
api_set_nim_ts_type(3, 1<<slot);
//fix BUG15594
api_send_ca_pmt(slot);
#endif //CI_BYPASS_ENABLE
#ifdef NEW_DEMO_FRAME
if((1)
#else
if((get_cc_crnt_state() != 0)
#endif
#ifdef DVR_PVR_SUPPORT
|| (api_pvr_check_tsg_state())
#endif
) // CC_STATE_STOP
{
//when card in, need stop vdec to avoid masic.
vdec_dev = (struct vdec_device*)dev_get_by_id(HLD_DEV_TYPE_DECV, 0);
if (vdec_dev != NULL
&& dmx_dev != NULL
&& SUCCESS == dmx_io_control(dmx_dev, IS_AV_SCRAMBLED, (UINT32)&scrm_flag))
{
//libc_printf("%s: reset vdec!!!\n",__FUNCTION__);
//to avoid mosaic
#ifdef NEW_DEMO_FRAME
vdec_io_control(vdec_dev,VDEC_IO_REST_VBV_BUF,0);
#else
vdec_stop(vdec_dev, FALSE, FALSE);
vdec_start(vdec_dev);
#endif
}
}
}
/* Set the View Mode of VPO Window */
void hde_set_mode(UINT32 mode)
{
struct MPSource_CallBack MPCallBack;
struct PIPSource_CallBack PIPCallBack;
struct VDec_StatusInfo vdec_info;
struct VDecPIPInfo tInitInfo;
UINT32 waittime=0, wait_total_time = 0;
struct vdec_device *pDecvDevice = (struct vdec_device *)get_selected_decoder();
BOOL need_to_wait = FALSE;
BOOL need_to_set_output = FALSE;
UINT8 ulock = 0;
struct nim_device *nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, 0);
struct vpo_device *pDisDevice = (struct vpo_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_DIS);
#ifdef DUAL_VIDEO_OUTPUT
struct vpo_device *pDisDevice_O = (struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 1);
#endif
struct vpo_io_get_info dis_info;
switch(mode)
{
case VIEW_MODE_PREVIEW:
if ((l_hde_mode != mode) || (l_hde_uIsPreviewResize == 1))
{
ENTER_CCHDE_API();
#if( VDEC27_PREVIEW_SOLUTION == VDEC27_PREVIEW_VE_SCALE)
#ifdef HDTV_SUPPORT
/* Check Frame Size, If Input Frame is HD, Set VE to Dview Mode */
vpo_ioctl(pDisDevice, VPO_IO_GET_INFO, (UINT32) &dis_info);
#ifdef DUAL_VIDEO_OUTPUT
vpo_ioctl(pDisDevice_O, VPO_IO_GET_INFO, (UINT32) &dis_info);
#endif
if(is_cur_decoder_avc())
{
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
if(vdec_info.pic_width > 720 || vdec_info.pic_height > 576)
{
need_to_wait = TRUE;
}
else
need_to_wait = FALSE;
}
else
{
need_to_wait = TRUE;
vdec_stop(pDecvDevice,TRUE,TRUE);
}
if(need_to_wait)
{
tInitInfo.adv_setting.init_mode = 1;
tInitInfo.adv_setting.out_sys = dis_info.tvsys;
tInitInfo.adv_setting.bprogressive = dis_info.bprogressive;
#ifdef DUAL_VIDEO_OUTPUT
if(is_cur_decoder_avc())
#else
if(0)
#endif
{
vdec_set_output(pDecvDevice,DUAL_PREVIEW_MODE, &tInitInfo, &MPCallBack, &PIPCallBack);
}
else
{
vdec_set_output(pDecvDevice, DUAL_PREVIEW_MODE, &tInitInfo, &MPCallBack, &PIPCallBack);
}
}
if(!is_cur_decoder_avc())
{
vdec_start(pDecvDevice);
}
if(is_cur_decoder_avc() && need_to_wait)
{
struct dmx_device *dmx = (struct dmx_device *)dev_get_by_id(HLD_DEV_TYPE_DMX, 0);
//For H264, we have to wait for 1st picture decoded, then call vpo_zoom, otherwise, it could cause below issue:
//1. DE under run, because DE can scale down HD full size picture to preview size
//2. In full screen mode, VE mapping is H264 mapping mode, in preview mode, VE mapping is MPEG2 mapping mode
//--Michael Xie 2007/8/29
wait_total_time = VE_MODE_SWITCH_TIME;
while(waittime<wait_total_time)
{
nim_get_lock(nim, &ulock);
if(!ulock)
break;
if(RET_SUCCESS == dmx_io_control(dmx, IS_AV_SCRAMBLED, 0))
break;
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
if(vdec_info.uFirstPicShowed)
{
wait_total_time = H264_VE_MODE_SWITCH_TIME;
}
if(vdec_info.output_mode == PREVIEW_MODE)
{
osal_task_sleep(100);
break;
}
osal_task_sleep(1);
waittime++;
}
}
vpo_zoom(pDisDevice, &l_hde_rectSrcFull_adjusted, &l_hde_rectScrnPreview);
#ifdef DUAL_VIDEO_OUTPUT
vpo_zoom(pDisDevice_O, &l_hde_rectSrcFull_adjusted, &l_hde_rectScrnPreview);
#endif
#else
//Set Video Decoder Output Mode (PREVIEW_MODE)
tInitInfo.src_rect.uStartX = l_hde_rectSrcFull_adjusted.uStartX>>1;
tInitInfo.src_rect.uStartY= l_hde_rectSrcFull_adjusted.uStartY>>1;
tInitInfo.src_rect.uWidth = PICTURE_WIDTH - 2*tInitInfo.src_rect.uStartX;
tInitInfo.src_rect.uHeight = PICTURE_HEIGHT - 2*tInitInfo.src_rect.uStartY;
tInitInfo.dst_rect.uStartX = l_hde_rectScrnPreview.uStartX;
tInitInfo.dst_rect.uStartY= l_hde_rectScrnPreview.uStartY;
tInitInfo.dst_rect.uWidth = l_hde_rectScrnPreview.uWidth;
tInitInfo.dst_rect.uHeight = l_hde_rectScrnPreview.uHeight;
vdec_set_output(pDecvDevice,PREVIEW_MODE, &tInitInfo, &MPCallBack,&PIPCallBack);
//Wait Video Decoder Output Mode Switch to PREVIEW_MODE
vdec_info.output_mode = VIEW_MODE_FULL;
while((vdec_info.output_mode != PREVIEW_MODE)&&(waittime<VE_MODE_SWITCH_TIME))
{
nim_get_lock(nim, &ulock);
if(!ulock)
break;
osal_task_sleep(1);
waittime++;
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
}
//Switch Video Decoder Output Mode to PREVIEW_MODE Forcely
if(vdec_info.output_mode != PREVIEW_MODE)
{
PRINTF("switch to preview forcely\n");
vdec_stop(pDecvDevice,sys_data_get_cur_chan_mode() == PROG_TV_MODE,FALSE);
vdec_set_output(pDecvDevice,PREVIEW_MODE, &tInitInfo, &MPCallBack,&PIPCallBack);
vdec_start(pDecvDevice);
}
#endif
#elif(VDEC27_PREVIEW_SOLUTION == VDEC27_PREVIEW_DE_SCALE)
//If is DE Scale Operation, then adjust VPO Full Srceen to Preview Screen directly
if(0 == l_hde_preview_method)
vpo_zoom(pDisDevice, &l_hde_rectSrcFull_adjusted, &l_hde_rectScrnPreview);
//If is VE Scale Operation, first set Video Decoder Output Mode(PIP_MODE),
//then adjust VPO Full Srceen to Preview Screen
else if(1 == l_hde_preview_method)
{
if(l_hde_mode == VIEW_MODE_PREVIEW)
{
vpo_zoom(pDisDevice, &l_hde_rectSrcFull_adjusted, &l_hde_rectScrnPreview);
}
else
{
//Set Video Decoder Output Mode (IND_PIP_MODE)
tInitInfo.src_rect.uStartX = l_hde_rectSrcFull_adjusted.uStartX>>1;
tInitInfo.src_rect.uStartY= l_hde_rectSrcFull_adjusted.uStartY>>1;
tInitInfo.src_rect.uWidth = PICTURE_WIDTH - 2*tInitInfo.src_rect.uStartX;
tInitInfo.src_rect.uHeight = PICTURE_HEIGHT - 2*tInitInfo.src_rect.uStartY;
tInitInfo.dst_rect.uStartX = l_hde_rectScrnPreview.uStartX;
tInitInfo.dst_rect.uStartY= l_hde_rectScrnPreview.uStartY;
tInitInfo.dst_rect.uWidth = l_hde_rectScrnPreview.uWidth;
tInitInfo.dst_rect.uHeight = l_hde_rectScrnPreview.uHeight;
tInitInfo.pipSize.uWidth=l_hde_rectScrnPreview.uWidth;
tInitInfo.pipSize.uHeight=l_hde_rectScrnPreview.uHeight/5;
vdec_set_output(pDecvDevice,IND_PIP_MODE, &tInitInfo, &MPCallBack,&PIPCallBack);
//After Video Decoder Output Mode switch to PIP_MODE, then adjust VPO
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
if(VDEC27_STOPPED == vdec_info.uCurStatus)
{
vpo_zoom(pDisDevice, &l_hde_rectSrcFull_adjusted, &l_hde_rectScrnPreview);
}
else
{
waittime = 0;
while((vdec_info.output_mode != PIP_MODE)&&(waittime<VE_MODE_SWITCH_TIME_29E))
{
nim_get_lock(nim, &ulock);
if(!ulock)
break;
osal_task_sleep(20);
waittime += 20;
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
}
if(vdec_info.output_mode != PIP_MODE)
{
vdec_stop(pDecvDevice,TRUE,FALSE);
vdec_set_output(pDecvDevice,IND_PIP_MODE, &tInitInfo, &MPCallBack,&PIPCallBack);
vdec_start(pDecvDevice);
vpo_zoom(pDisDevice, &l_hde_rectSrcFull_adjusted, &l_hde_rectScrnPreview);
}
else
{
vpo_zoom(pDisDevice, &l_hde_rectSrcFull_adjusted, &l_hde_rectScrnPreview);
}
}
vpo_ioctl(pDisDevice, VPO_IO_ADJUST_LM_IN_PREVIEW, 1);
}
}
#endif
}
l_hde_uIsPreviewResize = 0;
LEAVE_CCHDE_API();
break;
case VIEW_MODE_MULTI:
break;
case VIEW_MODE_FULL:
default:
if (l_hde_mode != mode)
{
ENTER_CCHDE_API();
#if( VDEC27_PREVIEW_SOLUTION == VDEC27_PREVIEW_VE_SCALE)
#ifdef HDTV_SUPPORT
// convert VE to MP mode
vpo_ioctl(pDisDevice, VPO_IO_GET_INFO, (UINT32) &dis_info);
#ifdef DUAL_VIDEO_OUTPUT
vpo_ioctl(pDisDevice_O, VPO_IO_GET_INFO, (UINT32) &dis_info);
#endif
need_to_set_output = FALSE;
if(is_cur_decoder_avc())
{
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
if(vdec_info.pic_width > 720 || vdec_info.pic_height > 576)
{
need_to_wait = TRUE;
}
else if(vdec_info.pic_width == 0 || vdec_info.pic_height == 0)
{
need_to_set_output = TRUE;
}
else
need_to_wait = FALSE;
}
else
{
need_to_wait = TRUE;
vdec_stop(pDecvDevice,TRUE,TRUE);
}
if(need_to_wait || need_to_set_output)
{
tInitInfo.adv_setting.init_mode = 0;
tInitInfo.adv_setting.out_sys = dis_info.tvsys;
tInitInfo.adv_setting.bprogressive = dis_info.bprogressive;
#ifdef DUAL_VIDEO_OUTPUT
if(is_cur_decoder_avc())
#else
if(0)
#endif
{
vdec_set_output(pDecvDevice,DUAL_MODE, &tInitInfo, &MPCallBack, &PIPCallBack);
}
else
{
vdec_set_output(pDecvDevice,DUAL_MODE, &tInitInfo, &MPCallBack, &PIPCallBack);
}
}
if(!is_cur_decoder_avc())
{
vdec_start(pDecvDevice);
}
vpo_zoom(pDisDevice, &l_hde_rectSrcFull, &l_hde_rectScrnFull);
#ifdef DUAL_VIDEO_OUTPUT
vpo_zoom(pDisDevice_O, &l_hde_rectSrcFull, &l_hde_rectScrnFull);
#endif
osal_task_sleep(50);
if(is_cur_decoder_avc() && need_to_wait)
{
struct dmx_device *dmx = (struct dmx_device *)dev_get_by_id(HLD_DEV_TYPE_DMX, 0);
wait_total_time = VE_MODE_SWITCH_TIME;
while(waittime<wait_total_time)
{
nim_get_lock(nim, &ulock);
if(!ulock)
break;
if(RET_SUCCESS == dmx_io_control(dmx, IS_AV_SCRAMBLED, 0))
break;
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
if(vdec_info.uFirstPicShowed)
{
wait_total_time = H264_VE_MODE_SWITCH_TIME;
}
if(vdec_info.output_mode == MP_MODE)
{
break;
}
osal_task_sleep(1);
waittime++;
}
}
#else
//Set Video Decoder Output Mode (MP_MODE)
tInitInfo.buse_sml_buf = FALSE;
tInitInfo.src_rect.uStartX = l_hde_rectSrcFull.uStartX;
tInitInfo.src_rect.uStartY= l_hde_rectSrcFull.uStartY;
tInitInfo.src_rect.uWidth = l_hde_rectSrcFull.uWidth;
tInitInfo.src_rect.uHeight = l_hde_rectSrcFull.uHeight;
tInitInfo.dst_rect.uStartX = l_hde_rectScrnFull.uStartX;
tInitInfo.dst_rect.uStartY= l_hde_rectScrnFull.uStartY;
tInitInfo.dst_rect.uWidth = l_hde_rectScrnFull.uWidth;
tInitInfo.dst_rect.uHeight = l_hde_rectScrnFull.uHeight;
vdec_set_output(pDecvDevice,MP_MODE, &tInitInfo, &MPCallBack,&PIPCallBack);
//Wait Video Decoder Output Mode Switch to MP_MODE
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
while(((vdec_info.output_mode != MP_MODE)||(vdec_info.use_sml_buf))&&(waittime<VE_MODE_SWITCH_TIME))
{
nim_get_lock(nim, &ulock);
if(!ulock)
break;
osal_task_sleep(1);
waittime++;
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
}
//Switch Video Decoder Output Mode to MP_MODE Forcely
if((vdec_info.output_mode != MP_MODE)||(vdec_info.use_sml_buf))
{
PRINTF("switch to mp forcely\n");
vdec_stop(pDecvDevice,TRUE,FALSE);
vdec_set_output(pDecvDevice,MP_MODE, &tInitInfo, &MPCallBack,&PIPCallBack);
vdec_start(pDecvDevice);
}
#endif
#elif(VDEC27_PREVIEW_SOLUTION == VDEC27_PREVIEW_DE_SCALE)
//If is DE Scale Operation, then adjust VPO to Full Srceen directly
if(0 == l_hde_preview_method)
vpo_zoom(pDisDevice, &l_hde_rectSrcFull, &l_hde_rectScrnFull);
//If is VE Scale Operation, first set Video Decoder Output Mode(MP_MODE),
//then adjust VPO to Full Srceen
else if(1 == l_hde_preview_method)
{
//Set Video Decoder Output Mode (MP_MODE)
tInitInfo.src_rect.uStartX = l_hde_rectSrcFull.uStartX;
tInitInfo.src_rect.uStartY= l_hde_rectSrcFull.uStartY;
tInitInfo.src_rect.uWidth = l_hde_rectSrcFull.uWidth;
tInitInfo.src_rect.uHeight = l_hde_rectSrcFull.uHeight;
tInitInfo.dst_rect.uStartX = l_hde_rectScrnFull.uStartX;
tInitInfo.dst_rect.uStartY= l_hde_rectScrnFull.uStartY;
tInitInfo.dst_rect.uWidth = l_hde_rectScrnFull.uWidth;
tInitInfo.dst_rect.uHeight = l_hde_rectScrnFull.uHeight;
vdec_set_output(pDecvDevice,MP_MODE, &tInitInfo, &MPCallBack,&PIPCallBack);
//After Video Decoder Output Mode switch to MP_MODE, then adjust VPO
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
if(VDEC27_STOPPED == vdec_info.uCurStatus)
{
vpo_zoom(pDisDevice, &l_hde_rectSrcFull, &l_hde_rectScrnFull);
}
else
{
waittime = 0;
while((vdec_info.output_mode != MP_MODE)&&(waittime<VE_MODE_SWITCH_TIME_29E))
{
nim_get_lock(nim, &ulock);
if(!ulock)
break;
osal_task_sleep(20);
waittime += 20;
vdec_io_control(pDecvDevice, VDEC_IO_GET_STATUS, (UINT32)&vdec_info);
}
if(vdec_info.output_mode != MP_MODE)
{
vdec_stop(pDecvDevice,TRUE,FALSE);
vdec_set_output(pDecvDevice,MP_MODE, &tInitInfo, &MPCallBack,&PIPCallBack);
vdec_start(pDecvDevice);
vpo_zoom(pDisDevice, &l_hde_rectSrcFull, &l_hde_rectScrnFull);
}
else
{
vpo_zoom(pDisDevice, &l_hde_rectSrcFull, &l_hde_rectScrnFull);
}
}
vpo_ioctl(pDisDevice, VPO_IO_ADJUST_LM_IN_PREVIEW, 0);
}
#endif
LEAVE_CCHDE_API();
}
}
int ipanel_porting_dvb_select_av(int pcr_pid, int emm_pid, int vpid, int apid, int audio_ecm_pid, int video_ecm_pid,int servicetype)
{
RET_CODE ret_code = 0;
Service_Info tmp_service;
dprintf("[ipanel_porting_dvb_select_av] V/A/Pcr = %d/%d/%d video_status = %d \n",vpid,apid,pcr_pid, video_status);
//return 0;
if((apid==0)&&(vpid==0)&&(pcr_pid==0))
{
return -1;
}
if((audioPid==apid) && (videoPid==vpid) && (pcrPid==pcr_pid))
{
return 0;
}
else if((audioPid||videoPid||pcrPid)&&(video_status==1))
{
ipanel_porting_av_stop();
}
/*here the program PID, audio PID video PID were fixed , so this demo code was banded with a specified ts.
just modify these related marco when you use this demo code. */
io_parameter.io_buff_in = (UINT8 *)PID_list;
PID_list[0] = vpid;//pCmd->pids.video_id;
PID_list[1] = apid;//pCmd->pids.audio_id;
PID_list[2] = pcr_pid;//pCmd->pids.pcr_id;
pcrPid = pcr_pid;
//if(ipanel_get_run_mode()==1) //if mode is flash mode,search by vid or aid
{
int ret=0;
tmp_service.video_pid = vpid;
tmp_service.audio_pid = apid;
tmp_service.pcr_pid=pcr_pid;
tmp_service.service_type=servicetype;
if(ipanel_get_run_mode()!=1)
{
*((volatile UINT8 *)0xb800002C) &= ~0x10; //set pin-mux to S-Flash
osal_task_sleep(2000);
}
ret = ipanel_get_service_ByPID(&tmp_service);
if(ipanel_get_run_mode()!=1)
{
*((volatile UINT8 *)0xb800002C) |= 0x10; //set pin-mux to Ethernet
osal_task_sleep(2000); //for not crash quickly
}
if(ret == SUCCESS)
{
PID_list[2] = pcrPid = tmp_service.pcr_pid;
if(tmp_service.frequency != cur_freq )
{
my_ts_id = tmp_service.ts_id;
ipanel_porting_delivery_tune(tmp_service.frequency*100,tmp_service.symbol_rate*10,(tmp_service.modulation-3));
osal_task_sleep(300);
ipanel_porting_dprintf("[ipanel_porting_dvb_select_av] ts_id : 0x%x ,tune %d.\n",tmp_service.ts_id,tmp_service.frequency);
}
}
else
{
ipanel_porting_dprintf("[ipanel_porting_dvb_select_av] can't get the service.but still play av by pid\n");
//return -1;
}
}
UINT32 create_stream = 0;
UINT32 enable_stream = 0;
if(vpid && apid)
{
create_stream = IO_CREATE_AV_STREAM;
enable_stream = IO_STREAM_ENABLE;
}
else if((vpid==0) && apid)
{
create_stream = IO_CREATE_AUDIO_STREAM;
enable_stream = AUDIO_STREAM_ENABLE;
}
else if((apid==0) && vpid)
{
create_stream = IO_CREATE_VIDEO_STREAM;
enable_stream = VIDEO_STREAM_ENABLE;
}
if(create_stream!=0)
ret_code = dmx_io_control(g_dmx_dev,create_stream,(UINT32)&io_parameter);
if(ret_code != RET_SUCCESS)
{
dprintf("[ipanel_porting_av_start] dmx create stream fail\n");
return -1;
}
if(vpid)
{
ret_code = vdec_start(g_decv_dev);
if(ret_code != RET_SUCCESS)
{
dprintf("[ipanel_porting_av_start] cc2: VDec_Decode() fail\n");
return -1;
}
else
{
dprintf("[ipanel_porting_av_start] cc2: vdec_start() OK\n");
}
videoPid = vpid;
}
if(apid)
{
deca_io_control(g_deca_dev, DECA_SET_STR_TYPE, AUDIO_MPEG2);
ret_code = deca_start(g_deca_dev,0); /* open the audio device */
if(ret_code != RET_SUCCESS)
{
dprintf("[ipanel_porting_av_start] cc2: deca_start() fail \n");
return -1;
}
else
{
dprintf("[ipanel_porting_av_start] cc2: deca_start() OK \n");
}
audioPid = apid;
}
if(enable_stream!=0)
ret_code = dmx_io_control(g_dmx_dev,enable_stream,(UINT32)&io_parameter);
if(ret_code != RET_SUCCESS)
{
dprintf("[ipanel_porting_av_start] cc2: dmx enable stream fail\n");
return -1;
}
else
{
dprintf("[ipanel_porting_av_start] cc2: dmx enable stream OK\n");
}
video_status = 1;
if(progpos!=0xffff){
api_mcas_start_service(0);
api_mcas_start_transponder();
si_monitor_on(progpos);
}
dprintf("[ipanel_porting_av_start] cc2: V/A/Pcr = %d/%d/%d\n",PID_list[0],PID_list[1],PID_list[2]);
return 0;
}
