/*****************************************************************************
* Interal functions
******************************************************************************/
INT32 cas_demux_init(void (*dmx_cb)(UINT8 req_id, BOOL bOK, UINT16 pid, UINT8* sec_data, UINT16 length))
{
UINT8 i;
struct cas_channel *tmp_channel;
CAS_DMX_MUTEX_INIT();
#if (SYS_CHIP_MODULE == ALI_S3601 || SYS_CHIP_MODULE == ALI_S3602)
cas_dmx_dev = (struct dmx_device *)dev_get_by_name("DMX_S3601_0");
#else
cas_dmx_dev = (struct dmx_device*)dev_get_by_name("DMX_M3327_0");
#endif
dmx_io_control(cas_dmx_dev, DMX_BYPASS_CSA, 0);
for(i=0; i<CAS_MAX_CHAN_NUM; i++)
{
tmp_channel = (struct cas_channel*) MALLOC(sizeof(struct cas_channel));
if(tmp_channel == NULL)
{
CAS_DMXERR_PRINTF("cas_demux_request: malloc error!\n");
return CDCA_FALSE;
}
MEMSET(tmp_channel, 0, sizeof(struct cas_channel));
tmp_channel->get_sec_param.pid = INVALID_PID;
channel_array[i] = tmp_channel;
}
cas_demux_callback = dmx_cb;
return CDCA_TRUE;
}
int ipanel_av_init(void)
{
struct pes_retrieve_param pes_service;
struct VDecPIPInfo vInitInfo;
struct MPSource_CallBack vMPCallBack;
struct PIPSource_CallBack vPIPCallBack;
MEMSET((UINT8 *)&io_parameter, 0, sizeof(struct io_param));
PID_list[0]=0;
PID_list[1]=0;
PID_list[2]=0;
video_status = 0;
audioPid = 0;
videoPid = 0;
pcrPid = 0;
vdec_set_output ( g_decv_dev, MP_MODE, &vInitInfo, &vMPCallBack, &vPIPCallBack );
//if(RET_SUCCESS!= VDec_Decode(0,ALL_PIC, FALSE,0,FALSE,FALSE,FALSE))
// ASSERT(0);
vpo_win_mode ( g_vpo_dev, VPO_MAINWIN, &vMPCallBack, &vPIPCallBack );
#ifdef VDEC_AV_SYNC
vdec_sync_mode ( g_decv_dev, 0x00, VDEC_SYNC_I | VDEC_SYNC_P | VDEC_SYNC_B );
deca_set_sync_mode ( g_deca_dev, ADEC_SYNC_PTS );
#endif
//Binding Video Decoder to DMX
pes_service.device = g_decv_dev;
pes_service.filter_idx = 0;
pes_service.retrieve_fmt = PES_HEADER_DISCARDED;
pes_service.str_type = VIDEO_STR;
pes_service.request_write = vdec_vbv_request ;
pes_service.update_write = vdec_vbv_update ;
dmx_io_control ( g_dmx_dev, DMX_BINDING_PES_RETRIEVE, ( UINT32 ) ( &pes_service ) );
//Binding Audio Decoder to DMX
pes_service.device = g_deca_dev;
pes_service.filter_idx = 1;
pes_service.retrieve_fmt = PES_HEADER_DISCARDED;
pes_service.str_type = AUDIO_STR;
pes_service.request_write = deca_request_write;
pes_service.update_write = deca_update_write ;
dmx_io_control ( g_dmx_dev, DMX_BINDING_PES_RETRIEVE, ( UINT32 ) ( &pes_service ) );
return 0;
}
BOOL as_prog_pid_search(struct dmx_device *dmx,UINT8 av_mode,
UINT16 v_pid, UINT16 a_pid,UINT16 pcr_pid)
{
UINT16 pid_list[3];
struct io_param io_param;
BOOL ret = FALSE;
if(av_mode != 1)
{
return FALSE;
}
if(dmx == NULL)
{
return FALSE;
}
pid_list[0] = v_pid;
pid_list[1] = a_pid;
pid_list[2] = pcr_pid;
io_param.io_buff_in = (UINT8 *)pid_list;
io_param.buff_in_len = sizeof(pid_list);
if(dmx_io_control(dmx, IO_CREATE_AV_STREAM, (UINT32)&io_param) == RET_SUCCESS)
{
if(dmx_io_control(dmx, IO_STREAM_ENABLE, (UINT32)&io_param) == RET_SUCCESS)
{
UINT32 tmo = 6;
while(tmo)
{
osal_task_sleep(100);
tmo--;
if(dmx_io_control(dmx, IS_PROGRAM_LEGAL, (UINT32)&io_param) == RET_SUCCESS)
{
ret = TRUE;
break;
}
}
}
}
dmx_io_control(dmx, IO_STREAM_DISABLE, (UINT32)&io_param);
return ret;
}
INT32 ali_ipanel_exit_mw()
{
INT32 ret = SUCCESS;
UINT32 flag_value = 0;
struct dmx_device *dmx = (struct dmx_device*)dev_get_by_id(HLD_DEV_TYPE_DMX, 0);
struct vpo_device *vpo_dev = (struct vpo_device*)dev_get_by_id(HLD_DEV_TYPE_DIS, 0);
if (ali_ipanel_flag_id == OSAL_INVALID_ID)
{
IPANEL_PRINTF("%s() ali_ipanel_flag_id invalid! \n", __FUNCTION__);
return - 1;
}
//start dmx, ipanel porting stopped dmx and changed buff mode
dmx_io_control(dmx, DMX_SWITCH_TO_UNI_BUF, 0);
dmx_io_control(dmx, DMX_CHANGE_THLD, (0 << 16) | (16));
dmx_start(dmx);
//open vpo
vpo_win_onoff(vpo_dev, TRUE);
//open sie
/* if (SUCCESS != sie_open(dmx, PSI_MODULE_CONCURRENT_FILTER, NULL, 0))
{
IPANEL_PRINTF("%s() sie_open failed! \n", __FUNCTION__);
return - 1;
}*/
//resum key task
key_task_resume();
//suspend ota task
ota_task_resume();
//start tdt
start_tdt();
sdt_monitor_on(0);
//set flag to enable ali application
ALI_IPANEL_LEAVE_MUTEX(ALI_IPANEL_FLAG_EXIT_MW);
return ret;
}
BOOL api_is_stream_scrambled(void)
{
UINT8 scrabled = 0, scrable_typ = 0;
if (dmx_io_control(g_dmx_dev, IS_AV_SCRAMBLED,(UINT32)(&scrable_typ)) == RET_SUCCESS )
{
if(scrable_typ & (VDE_TS_SCRBL|VDE_PES_SCRBL))
scrabled = 1;
}
return scrabled;
}
static int GetDmxPER(unsigned int argc, unsigned char * argv [ ])
{
INT32 ret=0;
UINT32 per;
#if 0
if (argc != 1)
{
SH_PRINTF("Usage: GetDmxPER\n");
return -1;
}
struct dmx_device *dmx_dev = dev_get_by_id(HLD_DEV_TYPE_DMX, nim_id);
if(NULL != dmx_dev)
{
//struct dmx_private *prv = (struct dmx_private *)dmx_dev->priv;
if(0 != bperflag)
{
dmx_io_control(dmx_dev,IO_GET_DISCONTINUE_COUNT,(UINT32)&per);//prv->disconti_counter;
}
else
{
per = 0;
bperflag = 1;
}
//prv->disconti_counter = 0;
dmx_io_control(dmx_dev,IO_ClEAR_DISCONTINUE_COUNT,0);
}
else
{
SH_PRINTF("GetDmxPER: operation error! %d\n", ret);
return -1;
}
IntPrintf(per);
LIB_ASH_OC('\r');
LIB_ASH_OC('\n');
#endif
return ret;
}
void cas_demxu_free_channel(UINT8 req_id)
{
UINT8 i;
UINT8 j;
struct cas_channel *tmp_channel;
CAS_DMX_MUTEX_LOCK();
for(i=0; i<CAS_MAX_CHAN_NUM; i++)
{
tmp_channel = channel_array[i];
for(j=0; j<MAX_MV_NUM; j++)
{
if(tmp_channel->req_id[j] == req_id)
{
CAS_DMX_PRINTF("cas_dmx_free: req_id:0x%02x, flt_id:0x%02x\n", req_id, tmp_channel->flt_id);
dmx_io_control(cas_dmx_dev, IO_ASYNC_CLOSE, tmp_channel->flt_id);
MEMSET(tmp_channel, 0, sizeof(struct cas_channel));
tmp_channel->get_sec_param.pid = INVALID_PID;
break;
}
}
}
CAS_DMX_MUTEX_UNLOCK();
}
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
}
}
}
/* description : auto scan main routine for command parsing and switching.*/
static void as_main(struct libpub_cmd *cmd)
{
INT32 i, j;
INT32 ret;
INT32 method;
INT32 tp_nr;
INT32 as_method;
UINT16 sat_id;
UINT8 dmx_mode_need_resume = 0;
UINT32 dmx_dma_mode;
as_update_event_t event_handler;
struct dmx_device *dmx = NULL;
T_NODE *tp = &as_info->cur_tp;;
S_NODE *sat = &as_info->cur_sat;
struct ft_antenna *antenna = &as_info->antenna;
AS_PRINTF("start time stamp = %d\n", osal_get_tick());
as_method = as_info->param.as_method;
event_handler = as_info->param.as_handler;
if(event_handler!=NULL)
{
event_handler(ASM_TYPE_PROGRESS, AS_PROGRESS_SCANSTART);
}
//Select DMX
dmx = dev_get_by_id(HLD_DEV_TYPE_DMX, 0);
if(dmx == NULL)
{
AS_PRINTF("%s(): select dmx failed!\n");
return;
}
as_info->dmx = dmx;
//fix BUG20874: init psi info to avoid dmx changed by video playing
psi_info_init(as_info->dmx, as_info->nim, (void *)__MM_PSI_START_ADDR, 180*1024);
//Check and Switch Buffer Mode of Dmx (From Divided Buffer To Union Buffer)
dmx_io_control(as_info->dmx, DMX_CHK_BUF_MODE, (UINT32)&dmx_dma_mode);
if(dmx_dma_mode == DMX_DIVIDED_BUFF_MODE)
{
dmx_io_control(as_info->dmx, DMX_SWITCH_TO_UNI_BUF, 0);
dmx_mode_need_resume = 1;
}
for(i = 0; i<as_info->sat_nr; i++)
{
//For Each Satellite, Create its TP View, Set Antenna
sat_id = as_info->sat_id[i];
db_search_create_tp_view(sat_id);
if(event_handler != NULL)
{
event_handler(ASM_TYPE_SATELLITE, sat_id);
}
//Set Antenna Information according to Satellite Information
MEMSET(sat, 0, sizeof(S_NODE));
get_sat_by_id(sat_id, sat);
AS_DUMP_SAT(sat);
MEMSET(antenna, 0, sizeof(struct ft_antenna));
sat2antenna(sat, antenna);
as_info->dual_LNB = (antenna->lnb_high>0) && (antenna->lnb_low>0) && (antenna->lnb_high != antenna->lnb_low);
as_info->voltage_ctrl = (antenna->pol==LNB_POL_H)||(antenna->pol==LNB_POL_V);
//>>> Unicable begin
if(antenna->lnb_type == LNB_CTRL_UNICABLE)
{
as_info->nim_para.unicable = 1;
as_info->nim_para.Fub = antenna->unicable_freq;
}
else
as_info->nim_para.unicable = 0;
//<<< Unicable end
//select right nim and dmx
as_select_nim(sat);
if(as_info->nim ==NULL)
{
AS_PRINTF("%s(): select nim failed!\n");
continue;
}
//for 29E 2-Tuner the dmx path may not same as default!!
tsi_dmx_src_select(TSI_DMX_0, TSI_TS_A);
//blind scan
if((AS_METHOD_FFT==as_method)||(AS_METHOD_MULTI_FFT==as_method))
{
method = AS_METHOD_FFT;
}
else
{
as_info->tp_nr = 0;
MEMSET(as_info->tp_nit, 0,AS_MODULE_MAX_T_NUM*sizeof(UINT8));
//single tp scan
if((AS_METHOD_TP==as_method)||(AS_METHOD_TP_PID==as_method)
||(AS_METHOD_NIT_TP==as_method)||(AS_METHOD_NVOD==as_method))
{
as_info->tp_nr = 1;
as_info->tp_id[0] = as_info->param.as_from;
if ((AS_METHOD_NIT_TP==as_method)&&(event_handler!=NULL))
{
event_handler(ASM_TYPE_INC_TRANSPONDER, 0);
}
}
//multi tp scan
else if((AS_METHOD_SAT_TP==as_method)||(AS_METHOD_NIT==as_method)
||(AS_METHOD_MULTI_TP==as_method)||(AS_METHOD_MULTI_NIT==as_method)
||(AS_METHOD_NVOD_MULTI_TP==as_method))
{
tp_nr = get_tp_num_sat(sat_id);
for(j=0; j<tp_nr; j++)
{
get_tp_at(sat_id, j, tp);
if(as_info->param.as_frontend_type==FRONTEND_TYPE_S)
{
if(dvbs_tp_sanity_check(as_info->voltage_ctrl,tp, sat)==FALSE)
{
continue;
}
}
else if(as_info->param.as_frontend_type == FRONTEND_TYPE_C)
{
if(dvbc_tp_sanity_check(FALSE, tp, NULL) == FALSE)
{
continue;
}
}
AS_DUMP_TP(tp);
#ifdef NVOD_FEATURE
if((AS_METHOD_NVOD_MULTI_TP == as_method) && (tp->nvod_flg == 1))
#endif
{
as_info->tp_id[as_info->tp_nr++] = tp->tp_id;
}
if (AS_MODULE_MAX_T_NUM == as_info->tp_nr)
{
AS_PRINTF("%s: tp exceed AS_MODULE_MAX_T_NUM!\n", __FUNCTION__);
}
}
}
if((AS_METHOD_NIT==as_method)||(AS_METHOD_NIT_TP==as_method)
||(AS_METHOD_MULTI_NIT==as_method))
{
MEMSET(as_info->tp_nit, 1, as_info->tp_nr);
}
method = AS_METHOD_TP;
}
ret = as_scan(sat_id, sat, method, 0);
update_data( );
if (ret || as_info->stop_scan_signal)
{
break;
}
}
//Show Scan Over by Upper Layer
if(event_handler != NULL)
{
event_handler(ASM_TYPE_PROGRESS, AS_PROGRESS_SCANOVER);
}
dmx_io_control(as_info->dmx, CLEAR_STOP_GET_SECTION, 0);
//Switch Buffer Mode of Dmx (From Union Buffer to Divided Buffer)
if(dmx_mode_need_resume)
{
dmx_io_control(as_info->dmx, DMX_SWITCH_TO_DVI_BUF, 0);
}
sie_open(as_info->dmx, MAX_FILTER_NUMBER, NULL, 0);
osal_task_dispatch_off();
nim_io_control(as_info->nim, NIM_DRIVER_STOP_ATUOSCAN, 0);
as_info = NULL;
AS_PRINTF("end time stamp = %d\n", osal_get_tick());
osal_task_dispatch_on();
}
extern void CDSTBCA_ScrSetCW(CDCA_U16 wEcmPID, const CDCA_U8* pbyOddKey, const CDCA_U8* pbyEvenKey, CDCA_U8 byKeyLen, CDCA_BOOL bTapingEnabled)
{
UINT8 i;
UINT16 ret;
UINT8 rating;
UINT8 pin[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
struct dmx_device *dmx_dev;
#ifdef CHCHG_TICK_PRINTF
libc_printf("####CHCHG %s():line%d, ecmPID0x%x, tick=%d\n", __FUNCTION__,__LINE__, wEcmPID,osal_get_tick());
#endif
CAS_DMX_PRINTF("STBCA_ScrSetCW:ecmPID:%04x @%d\n", wEcmPID,osal_get_tick());
dmx_dev = (struct dmx_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_DMX);
if(dmx_dev == NULL)
{
CAS_DMXERR_PRINTF("STBCA_ScrSetCW: Dev_get_by_type error!\n");
return;
}
if(RET_SUCCESS!=dmx_io_control(dmx_dev, DMX_IS_TS_ENTER_CSA, 0))
dmx_io_control(dmx_dev, DMX_BYPASS_CSA, 0);
// CAS_DMX_PRINTF("Odd : ");
// CAS_DMX_DUMP(pbyOddKey, byKeyLen);
// CAS_DMX_PRINTF("Even: ");
// CAS_DMX_DUMP(pbyEvenKey, byKeyLen);
for(i=0; i<2;i++)
{
if(cas_ecm_pid.uniform_ecm_pid == wEcmPID)
{
dmx_cfg_cw(dmx_dev, DES_VIDEO, 2, (UINT32 *)pbyEvenKey);
dmx_cfg_cw(dmx_dev, DES_VIDEO, 3, (UINT32 *)pbyOddKey);
dmx_cfg_cw(dmx_dev, DES_AUDIO, 2, (UINT32 *)pbyEvenKey);
dmx_cfg_cw(dmx_dev, DES_AUDIO, 3, (UINT32 *)pbyOddKey);
dmx_cfg_cw(dmx_dev, DES_TTX, 2, (UINT32 *)pbyEvenKey);
dmx_cfg_cw(dmx_dev, DES_TTX, 3, (UINT32 *)pbyOddKey);
dmx_cfg_cw(dmx_dev, DES_SUP, 2, (UINT32 *)pbyEvenKey);
dmx_cfg_cw(dmx_dev, DES_SUP, 3, (UINT32 *)pbyOddKey);
}
else if(cas_ecm_pid.video_ecm_pid == wEcmPID)
{
dmx_cfg_cw(dmx_dev, DES_VIDEO, 2, (UINT32 *)pbyEvenKey);
dmx_cfg_cw(dmx_dev, DES_VIDEO, 3, (UINT32 *)pbyOddKey);
}
else if(cas_ecm_pid.audio_ecm_pid == wEcmPID)
{
dmx_cfg_cw(dmx_dev, DES_AUDIO, 2, (UINT32 *)pbyEvenKey);
dmx_cfg_cw(dmx_dev, DES_AUDIO, 3, (UINT32 *)pbyOddKey);
}
else if(cas_ecm_pid.ttx_ecm_pid == wEcmPID)
{
dmx_cfg_cw(dmx_dev, DES_TTX, 2, (UINT32 *)pbyEvenKey);
dmx_cfg_cw(dmx_dev, DES_TTX, 3, (UINT32 *)pbyOddKey);
}
else if(cas_ecm_pid.subt_ecm_pid == wEcmPID)
{
dmx_cfg_cw(dmx_dev, DES_SUP, 2, (UINT32 *)pbyEvenKey);
dmx_cfg_cw(dmx_dev, DES_SUP, 3, (UINT32 *)pbyOddKey);
}
}
return;
}
/* description : auto scan main routine for command parsing and switching.*/
static void as_main(struct mid27_cmd *cmd)
{
INT32 i;
INT32 j;
INT32 ret;
INT32 method;
INT32 tp_nr;
INT32 as_method;
UINT16 sat_id;
T_NODE *tp;
S_NODE *sat;
UINT8 dmx_mode_need_resume = 0;
UINT32 dmx_dma_mode;
as_update_event_t event_handler;
extern BOOL cc_stop_channel(BOOL, BOOL);
#ifdef BASE_TP_HALF_SCAN_SUPPORT
if(cmd->cmd_type == MID27_CMD_AS_HL_START)
{
as_bastp_halfscan(cmd);
return;
}
#endif
AS_PRINTF("start time stamp = %d\n", osal_get_tick());
cc_stop_channel(0, 0);
/*get default nim, for dual nim projects, will get correct nim later below*/
as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, 0);
as_info->dmx = (struct dmx_device *)dev_get_by_id(HLD_DEV_TYPE_DMX, 0);
//fix BUG20874: init psi info to avoid dmx changed by video playing
#ifdef BASE_TP_HALF_SCAN_SUPPORT
psi_info_init(as_info->dmx, as_info->nim, (void *)__MM_PSI_START_ADDR, 280*1024);
#else
psi_info_init(as_info->dmx, as_info->nim,(void *)__MM_PSI_START_ADDR, 180*1024);
#endif
dmx_io_control(as_info->dmx, DMX_CHK_BUF_MODE, (UINT32)&dmx_dma_mode);
if(dmx_dma_mode == DMX_DIVIDED_BUFF_MODE)
{
dmx_io_control(as_info->dmx, DMX_SWITCH_TO_UNI_BUF, 0);
dmx_mode_need_resume = 1;
}
tp = &as_info->cur_tp;
sat = &as_info->cur_sat;
as_method = as_info->param.as_method;
event_handler = as_info->param.as_handler;
event_handler(ASM_TYPE_PROGRESS, AS_PROGRESS_SCANSTART);
for(i = 0; i<as_info->sat_nr; i++)
{
sat_id = as_info->sat_id[i];
db_search_create_tp_view(sat_id);
#if (SYS_PROJECT_FE == PROJECT_FE_DVBS||SYS_PROJECT_FE == PROJECT_FE_DVBS2)
event_handler(ASM_TYPE_SATELLITE, sat_id);
get_sat_by_id(sat_id, sat);
/*get correct nim*/
as_select_nim(sat);
#endif
AS_DUMP_SAT(sat);
if ((AS_METHOD_FFT == as_method)||(AS_METHOD_MULTI_FFT == as_method))
{
method = AS_METHOD_FFT;
}
else
{
as_info->tp_nr = 0;
MEMSET(as_info->tp_nit, 0,AS_MODULE_MAX_T_NUM*sizeof(UINT8));
if ((AS_METHOD_TP == as_method)||(AS_METHOD_TP_PID == as_method)
||(AS_METHOD_NIT_TP== as_method)||(AS_METHOD_NVOD == as_method))
{
as_info->tp_nr = 1;
as_info->tp_id[0] = as_info->param.as_from;
if (AS_METHOD_NIT_TP == as_method)
event_handler(ASM_TYPE_INC_TRANSPONDER, 0);
}
else if ((AS_METHOD_SAT_TP == as_method)||(AS_METHOD_NIT == as_method)
||(AS_METHOD_MULTI_TP == as_method)||(AS_METHOD_MULTI_NIT == as_method)
||(AS_METHOD_NVOD_MULTI_TP==as_method))
{
tp_nr = get_tp_num_sat(sat_id);
for(j=0; j<tp_nr; j++)
{
get_tp_at(sat_id, j, tp);
if (FALSE == tp_sanity_check(as_info,tp, sat))
continue;
AS_DUMP_TP(tp);
#ifdef NVOD_FEATURE
if(tp->nvod_flg==1)
#endif
as_info->tp_id[as_info->tp_nr++] = tp->tp_id;
if (AS_MODULE_MAX_T_NUM == as_info->tp_nr)
AS_PRINTF("%s: tp exceed AS_MODULE_MAX_T_NUM!\n", __FUNCTION__);
}
}
if ((AS_METHOD_NIT == as_method)||(AS_METHOD_NIT_TP == as_method)
||(AS_METHOD_MULTI_NIT == as_method))
{
MEMSET(as_info->tp_nit, 1, as_info->tp_nr);
}
method = AS_METHOD_TP;
}
ret = as_scan(sat_id, sat, method, as_method != AS_METHOD_NVOD);
update_data( );
if (ret||as_info->stop_scan_signal)
break;
}
#ifdef KAON_SAVE_USE
event_handler(ASM_TYPE_PROGRESS, AS_PROGRESS_SCANOVER|(prog_num << 16));
#else
event_handler(ASM_TYPE_PROGRESS, AS_PROGRESS_SCANOVER);
#endif
dmx_io_control(as_info->dmx, CLEAR_STOP_GET_SECTION, 0);
if(dmx_mode_need_resume)
dmx_io_control(as_info->dmx, DMX_SWITCH_TO_DVI_BUF, 0);
sie_open(as_info->dmx, MAX_FILTER_NUMBER, NULL, 0);
osal_task_dispatch_off();
if ((as_info->param.as_method == AS_METHOD_NVOD)
||(as_info->param.as_method==AS_METHOD_NVOD_MULTI_TP))
{
nim_io_control(as_info->nim, NIM_DRIVER_STOP_ATUOSCAN, 0);
as_info = NULL;
AS_PRINTF("end time stamp = %d\n", osal_get_tick());
mid27_declare_cmd_finish(MID27_FLG_AS_NVOD);
}
else
{
nim_io_control(as_info->nim, NIM_DRIVER_STOP_ATUOSCAN, 0);
as_info = NULL;
AS_PRINTF("end time stamp = %d\n", osal_get_tick());
}
osal_task_dispatch_on();
}
BOOL GetSignalStatus( signal_lock_status* lock_flag,
signal_scramble_status* scramble_flag,
signal_lnbshort_status* lnbshort_flag,
signal_parentlock_status* parrentlock_flag)
{
UINT8 lock;
struct dmx_device * dmx_dev;
signal_lnbshort_status lnbshort;
SYSTEM_DATA* sys_data;
sys_data = sys_data_get();
UINT8 scrabled,scrable_typ;
P_NODE p_node;
UINT16 cur_channel;
struct VDec_StatusInfo curStatus;
static UINT16 prechan;
static UINT32 descDetTime = 0;
struct nim_device* nim_dev;
#ifdef NEW_DEMO_FRAME
static UINT32 unlock_times;
INT32 ts_route_id;
struct ts_route_info ts_route;
struct nim_config nim_config;
#endif
if(cur_tuner_idx == 0)
nim_dev = g_nim_dev;
else
nim_dev = g_nim_dev2;
#ifdef NEW_DEMO_FRAME
MEMSET(&ts_route, 0, sizeof(struct ts_route_info));
if(ts_route_get_by_type(TS_ROUTE_MAIN_PLAY, &ts_route_id, &ts_route) != RET_FAILURE)
{
nim_dev = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, ts_route.nim_id);
}
else
{
nim_dev = (cur_tuner_idx == 0) ? g_nim_dev : g_nim_dev2;
}
#endif
lnbshort = SIGNAL_STATUS_LNBNORMAL;
#if(SYS_LNB_SHORT_DET == SYS_FUNC_ON)
/*
if(sys_data->bLNB_power == LNB_POWER_ON)
{
if(LNB_state() == 1)//short
{
lnbshort = SIGNAL_STATUS_LNBSHORT;
}
}
*/
lnbshort = lnb_power_short;
#elif(SYS_12V_SHORT_DET == SYS_FUNC_ON)
lnbshort = v12_power_short;
#endif
if(lnbshort_flag != NULL)
*lnbshort_flag = lnbshort;
SetSignalLNBShortStatus(lnbshort);
// if(*lnbshort_flag == SIGNAL_STATUS_LNBSHORT)
// return TRUE;
#ifdef NEW_DEMO_FRAME
dmx_dev = (struct dmx_device *)dev_get_by_id(HLD_DEV_TYPE_DMX, ts_route.dmx_id);
#else
dmx_dev = g_dmx_dev;
#endif
#ifdef DVR_PVR_SUPPORT
if(singal_play_chan_nim_busy)
lock = SIGNAL_STATUS_UNLOCK;
else
#endif
nim_get_lock(nim_dev,&lock);
#if 0//def NEW_DEMO_FRAME //reset diseqc, but it may hold this process, if attached to UI flow maybe cause bug!
if(!lock)
unlock_times++;
else
unlock_times = 0;
if((unlock_times > 10)&& sys_data->bLNB_power)
{
dev_get_nim_config(nim_dev, FRONTEND_TYPE_S, &nim_config);
frontend_set_antenna(nim_dev, &nim_config.antenna, &nim_config.xpond, 1);
if(frontend_lnb_22k_ctl(&nim_config.antenna) || (nim_dev == g_nim_dev2))
frontend_set_nim(nim_dev, &nim_config.antenna,&nim_config.xpond,1);
nim_get_lock(nim_dev,&lock);
unlock_times = 0;
}
#endif
if (parrentlock_flag == NULL)
lv_lock_status = lock? SIGNAL_STATUS_LOCK : SIGNAL_STATUS_UNLOCK;
else
SetSignalLockStatus( lock? SIGNAL_STATUS_LOCK : SIGNAL_STATUS_UNLOCK);
cur_channel = sys_data_get_cur_group_cur_mode_channel();
get_prog_at(cur_channel,&p_node);
#if 0
scrabled = 0;
if(dmx_io_control(dmx_dev,IS_AV_SCRAMBLED,(UINT32)(&scrable_typ)) == RET_SUCCESS )
{
if(scrable_typ & (VDE_TS_SCRBL|VDE_PES_SCRBL))
scrabled = 1;
else
{
scrabled = 0;
}
}
#else
scrabled = key_get_dmx0_scramble(NULL);
#endif
#ifdef CI_SUPPORT2
if ((parrentlock_flag == NULL) && (p_node.ca_mode) && (!scrabled) && lock && (screen_back_state == SCREEN_BACK_VIDEO) && (VIEW_MODE_FULL == hde_get_mode())
#ifdef DVR_PVR_SUPPORT
&& !freeze_for_pvr //black screen result in pvr state trans!
&& api_pvr_is_live_playing()
#endif
)
{
vdec_io_control(get_selected_decoder(), VDEC_IO_GET_STATUS, (UINT32)&curStatus);
UINT32 freeze_flag = curStatus.display_idx;
if((curStatus.uFirstPicShowed) && (curStatus.uCurStatus == VDEC_DECODING)) //for scramble prog and freeze screen (show black screen and scramble osd)
{
osal_task_sleep(100);
//vdec_io_control(g_decv_dev, VDEC_IO_GET_STATUS, (UINT32)&curStatus);
vdec_io_control(get_selected_decoder(), VDEC_IO_GET_STATUS, (UINT32)&curStatus);
if(freeze_flag == curStatus.display_idx)
{
osal_task_sleep(100);
//vdec_io_control(g_decv_dev, VDEC_IO_GET_STATUS, (UINT32)&curStatus);
vdec_io_control(get_selected_decoder(), VDEC_IO_GET_STATUS, (UINT32)&curStatus);
if(freeze_flag == curStatus.display_idx) // freeze screen state!
{
scrabled = 1;
#ifdef DVR_PVR_SUPPORT //add to simulate monitor's function for video hold state because monitor is off under DVR project!
if((!last_ca_pmt_cmd_time) || (last_ca_pmt_cmd_time && (osal_get_tick() > last_ca_pmt_cmd_time + 6000)))
{
if(ca_pmt_cmd_cnt >= 2)
{
UIChChgPlayProg(0,CC_CMD_RESET_CRNT_CH);
ca_pmt_cmd_cnt = 0;
}
else
{
//cc_send_ca_pmt();
cc_send_ca_pmt(p_node.prog_id);
ca_pmt_cmd_cnt++;
}
last_ca_pmt_cmd_time = osal_get_tick();
}
#endif
}
else
{
ca_pmt_cmd_cnt = 0;
}
}
else
{
ca_pmt_cmd_cnt = 0;
}
}
else if(!curStatus.uFirstPicShowed) //for scramble prog and black screen
{
scrabled = 1;
ca_pmt_cmd_cnt = 0;
}
}
#endif
#ifdef CTI_CA
{
UINT32 freeze_flag = curStatus.display_idx;
vdec_io_control(get_selected_decoder(), VDEC_IO_GET_STATUS, (UINT32)&curStatus);
freeze_flag = curStatus.display_idx;
if((curStatus.uFirstPicShowed) && (curStatus.uCurStatus == VDEC_DECODING)) //for scramble prog and freeze screen (show black screen and scramble osd)
{
osal_task_sleep(100);
vdec_io_control(get_selected_decoder(), VDEC_IO_GET_STATUS, (UINT32)&curStatus);
if(freeze_flag == curStatus.display_idx)
{
osal_task_sleep(100);
vdec_io_control(get_selected_decoder(), VDEC_IO_GET_STATUS, (UINT32)&curStatus);
if(freeze_flag == curStatus.display_idx) // freeze screen state!
{
scrabled = 1;
}
}
}
else if(!curStatus.uFirstPicShowed) //for scramble prog and black screen
{
scrabled = 1;
}
/*qjzheng 2010.5.7 BUG2003 不能播放加锁节目时, 有时提示是CA错误*/
if( !lv_lock_status )
{
scrabled = 0;
}
}
#endif
if (parrentlock_flag)
{
if (scrabled)
{
if (lv_scramble_fake)
scrabled = 0;
}
SetSignalScrambleStatus(scrabled? SIGNAL_STATUS_SCRAMBLED : SIGNAL_STATUS_UNSCRAMBLED);
}
else
{
lv_scramble_status = scrabled? SIGNAL_STATUS_SCRAMBLED : SIGNAL_STATUS_UNSCRAMBLED;
}
/*Never in In multi-view mode*/
if(lock && !scrabled && hde_get_mode()!=VIEW_MODE_MULTI)
{
if(p_node.ca_mode && sys_data_get_cur_chan_mode() == TV_CHAN)
{
if(!curStatus.uFirstPicShowed && curStatus.uCurStatus!=VDEC_PAUSED)
{
descDetTime ++;
if(descDetTime == 1)
prechan = cur_channel;
if(descDetTime >=3 && prechan == cur_channel)
scrabled = 1;
else
descDetTime = 0;
}
else
descDetTime = 0;
}
}
if(lock_flag != NULL)
*lock_flag = lv_lock_status;
if(scramble_flag != NULL)
*scramble_flag = lv_scramble_status;
if(parrentlock_flag != NULL)
*parrentlock_flag = lv_parrentlock_status;
if(lv_lock_status == SIGNAL_STATUS_LOCK
&& lv_scramble_status == SIGNAL_STATUS_UNSCRAMBLED
&& lv_lnbshort_status == SIGNAL_STATUS_LNBNORMAL
&& lv_parrentlock_status == SIGNAL_STATUS_PARENT_UNLOCK)
return FALSE;
else
{
return TRUE;
}
}
/* 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();
}
}
void ipanel_porting_av_stop(void)
{
RET_CODE ret_code;
if(video_status == 1)
{
if(audioPid)
{
ret_code = deca_stop(g_deca_dev,0,ADEC_STOP_IMM);
if (ret_code != RET_SUCCESS)
{
dprintf("[ipanel_porting_av_stop] cc2: deca_stop() fail..\n");
}
else
{
dprintf("[ipanel_porting_av_stop] cc2: deca_stop() ok..\n");
audioPid = 0;
}
}
if(videoPid)
{
ret_code = vdec_stop(g_decv_dev,TRUE,TRUE);
if (ret_code == RET_BUSY)
{
ret_code = vdec_stop(g_decv_dev,TRUE,TRUE);
}
if (ret_code != RET_SUCCESS)
{
dprintf("[ipanel_porting_av_stop] cc2: Vdec_Stop() fail \n");
}
else
{
dprintf("[ipanel_porting_av_stop] cc2: Vdec_Stop() ok \n");
videoPid = 0;
}
}
pcrPid = 0;
ret_code = dmx_io_control(g_dmx_dev,IO_STREAM_DISABLE,(UINT32)&io_parameter);
if (ret_code != RET_SUCCESS)
{
dprintf("[ipanel_porting_av_stop] cc2: Dmx disable stream fail \n");
return;
}
else
{
dprintf("[ipanel_porting_av_stop] cc2: Dmx disable stream OK \n");
}
ret_code = dmx_io_control(g_dmx_dev,IO_DELETE_AV_STREAM,(UINT32)&io_parameter);
if(ret_code != RET_SUCCESS)
{
dprintf("[ipanel_porting_av_stop] dmx delete stream fail..\n");
}
else
{
dprintf("[ipanel_porting_av_stop] dmx delete stream ok..\n");
}
video_status = 0;
if( progpos!=0xffff)
{
api_mcas_stop_transponder();
api_mcas_stop_service();
si_monitor_off(progpos);
progpos=0xffff;
}
}
}
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;
}
