void win_satfav_set_display(void)
{
UINT32 i;
UINT16 top,cnt,page,idx;
OBJLIST* ol = &satfav_item_list;
BITMAP* bmp;
TEXT_FIELD* txt;
CONTAINER* item;
UINT32 valid_idx;
UINT16 unistr[50];
UINT8 group_type,group_idx,av_flag;
av_flag = sys_data_get_cur_chan_mode();
cnt = OSD_GetObjListCount(ol);
page = OSD_GetObjListPage(ol);
top = OSD_GetObjListTop(ol);
for(i=0;i<page;i++)
{
item = (CONTAINER*)satfav_items[i];
idx = top + i;
group_idx = (UINT8)(idx);
if(sat_fav_list_flag == 1)
{
group_idx += sys_data_get_sate_group_num(av_flag);
group_idx ++;
}
if(idx< cnt)
valid_idx = 1;
else
valid_idx = 0;
if(valid_idx)
get_chan_group_name((UINT8*)unistr,group_idx,&group_type);
/*IDX */
txt = (TEXT_FIELD*)OSD_GetContainerNextObj(item);//bmp->head.pNext;
if(valid_idx)
OSD_SetTextFieldContent(txt,STRING_NUMBER, idx + 1);
else
OSD_SetTextFieldContent(txt,STRING_ANSI,(UINT32)"");
/*Name*/
txt = (TEXT_FIELD*)OSD_GetObjpNext(txt);//txt->head.pNext;
if(valid_idx)
{
OSD_SetTextFieldContent(txt, STRING_UNICODE, (UINT32)unistr);
}
else
OSD_SetTextFieldContent(txt,STRING_ANSI,(UINT32)"");
}
}
static PRESULT win_progname_message_proc(UINT32 msg_type, UINT32 msg_code)
{
PRESULT ret = PROC_LOOP;
switch(msg_type)
{
case CTRL_MSG_SUBTYPE_CMD_EPG_PF_UPDATED:
event_update=TRUE;
osal_flag_clear(epg_flag, EPG_MSG_FLAG_PF);
case CTRL_MSG_SUBTYPE_CMD_EPG_SCH_UPDATED:
case CTRL_MSG_SUBTYPE_CMD_TIMEDISPLAYUPDATE:
case CTRL_MSG_SUBTYPE_STATUS_SIGNAL:
win_progname_redraw();
event_update=FALSE;
if(msg_type==CTRL_MSG_SUBTYPE_STATUS_SIGNAL)
{
ret = PROC_PASS;
}
else if(msg_type==CTRL_MSG_SUBTYPE_CMD_EPG_SCH_UPDATED)
{
osal_flag_clear(epg_flag, EPG_MSG_FLAG_SCH);
}
break;
case CTRL_MSG_SUBTYPE_CMD_EXIT:
if(sys_data_get_cur_chan_mode() == TV_CHAN)
ret = PROC_LEAVE;
break;
default:
ret = PROC_PASS;
}
return ret;
}
/* change group and recreate program view with current channel mode, then play it
* this function does too many things, should be changed later..
*/
void change_group(INT32 shift)
{
UINT16 cur_channel, max_channel;
P_NODE p_node;
UINT32 n;
SYSTEM_DATA *sys_data;
UINT8 cur_chan_mode;
BOOL b_ret;
sys_data = sys_data_get();
sys_data_change_group(0);
cur_chan_mode = sys_data_get_cur_chan_mode();
cur_channel = sys_data_get_cur_group_cur_mode_channel();
max_channel = get_prog_num(VIEW_ALL | cur_chan_mode, 0);
if (cur_channel >= max_channel)
cur_channel = 0;
n = 0;
get_prog_at(cur_channel, &p_node);
while ( ( p_node.skip_flag
|| ( sys_data->chan_sw == CHAN_SWITCH_FREE && p_node.ca_mode )
|| ( sys_data->chan_sw == CHAN_SWITCH_SCRAMBLED && !p_node.ca_mode ) )
&& n != max_channel )
{
cur_channel = (cur_channel + 1+max_channel) % max_channel;
get_prog_at(cur_channel, &p_node);
n++;
};
// if (show_and_playchannel)
// {
// sys_data_set_cur_group_channel(cur_channel);
//win_progname_redraw();
// }
#ifdef MULTI_CAS
#if(CAS_TYPE==CAS_CONAX)
/*clean msg*/
clean_mmi_msg(1, TRUE);
clean_mmi_msg(3, TRUE);
clean_mmi_msg(4, TRUE);
clean_mmi_msg(6, TRUE);
if(get_mmi_showed()==1||get_mmi_showed()==6)
win_mmipopup_close();
if(get_mmi_showed()!=5)
set_mmi_showed(10);
#endif
#endif
api_play_channel(cur_channel, TRUE, TRUE, FALSE);
#ifdef AD_SANZHOU
szxc_ad_hide_txt();
szxc_ad_show_txt(p_node.prog_number);
szxc_ad_hide_pic(AD_BANNER);
szxc_ad_show_banner(p_node.prog_number,banner_pic_rt);
#endif
}
void change_group(INT32 shift)
{
UINT8 cur_group,max_group;
UINT16 cur_channel,max_channel;
UINT8 group_type, group_pos;
S_NODE s_node;
P_NODE p_node;
UINT32 n;
SYSTEM_DATA* sys_data;
UINT8 cur_chan_mode;
sys_data = sys_data_get();
max_group = sys_data_get_group_num();
cur_group = sys_data_get_cur_group_index();
cur_group = (cur_group + shift + max_group) % max_group;
sys_data_set_cur_group_index(cur_group);
sys_data_get_cur_mode_group_infor(cur_group, &group_type, &group_pos,&cur_channel);
cur_chan_mode = sys_data_get_cur_chan_mode();
if(group_type==ALL_SATE_GROUP_TYPE)
{
PRINTF("========Change to ALL_SATE_GROUP_TYPE\n");
recreate_prog_view(VIEW_ALL|cur_chan_mode,0);
}
else if(group_type==SATE_GROUP_TYPE)
{
get_sat_at(group_pos,VIEW_ALL,&s_node);
recreate_prog_view(VIEW_SINGLE_SAT|cur_chan_mode,s_node.sat_id);
PRINTF("========Change to SATE_GROUP_TYPE(%d,%s)\n",group_pos,s_node.sat_name);
}
else
{
PRINTF("========Change to FAV_GROUP_TYPE(%d)\n",group_pos);
recreate_prog_view(VIEW_FAV_GROUP|cur_chan_mode,group_pos);
}
max_channel = get_prog_num(VIEW_ALL|cur_chan_mode,0);
if(cur_channel>= max_channel)
cur_channel = 0;
n = 0;
get_prog_at(cur_channel, &p_node);
while( (p_node.skip_flag
|| (sys_data->chan_sw==CHAN_SWITCH_FREE && p_node.ca_mode)
|| (sys_data->chan_sw==CHAN_SWITCH_SCRAMBLED && !p_node.ca_mode) )
&& n!=max_channel)
{
cur_channel = (cur_channel + 1 + max_channel) % max_channel;
get_prog_at(cur_channel, &p_node);
n++;
};
api_play_channel(cur_channel, TRUE, TRUE,FALSE);
}
void win_satfav_load_groupcount(void)
{
UINT8 av_flag;
OBJLIST *ol;
UINT16 group_cnt,group_idx;
UINT8 group_type, group_pos;
UINT16 channel,select,page;
UINT16 title_id;
TEXT_FIELD* txt;
ol = &satfav_item_list;
select = INVALID_POS_NUM;
av_flag = sys_data_get_cur_chan_mode();
group_idx = sys_data_get_cur_group_index();
sys_data_get_cur_mode_group_infor( group_idx, &group_type,&group_pos, &channel);
if(sat_fav_list_flag == 0) /* SAT */
{
group_cnt = sys_data_get_sate_group_num(av_flag);
group_cnt ++;
if(group_type == FAV_GROUP_TYPE)
group_idx = 0;
else
select = group_idx;
}
else /* FAV */
{
group_cnt = sys_data_get_fav_group_num(av_flag);
if(group_type != FAV_GROUP_TYPE)
group_idx = 0;
else
{
group_idx -= sys_data_get_sate_group_num(av_flag);
group_idx --;
select = group_idx;
}
}
page = OSD_GetObjListPage(ol);
OSD_SetObjListCount(ol, group_cnt);
OSD_SetObjListCurPoint(ol, group_idx);
OSD_SetObjListNewPoint(ol, group_idx);
OSD_SetObjListTop(ol,group_idx / page*page);
OSD_SetObjListSingleSelect(ol, select);
title_id = (sat_fav_list_flag == 0)? RS_INFO_SATELLITE : RS_FAVORITE;
txt = &satfav_title;
OSD_SetTextFieldContent(txt, STRING_ID,title_id);
}
static VACTION win_progname_keymap(POBJECT_HEAD pObj, UINT32 key)
{
VACTION act = VACT_PASS;
switch (key)
{
case V_KEY_UP:
case V_KEY_C_UP:
act = VACT_CH_UP;
break;
case V_KEY_DOWN:
case V_KEY_C_DOWN:
act = VACT_CH_DOWN;
break;
case V_KEY_P_UP:
act = VACT_GRP_UP;
break;
case V_KEY_P_DOWN:
act = VACT_GRP_DOWN;
break;
case V_KEY_F_UP:
act = VACT_FCH_UP;
break;
case V_KEY_F_DOWN:
act = VACT_FCH_DOWN;
break;
case V_KEY_TVRADIO:
act = VACT_TV_RADIO_SW;
break;
case V_KEY_RECALL:
act = VACT_RECALL;
break;
case V_KEY_INFOR:
act = VACT_SCHEDULE;
break;
/*
case V_KEY_0: case V_KEY_1: case V_KEY_2: case V_KEY_3:
case V_KEY_4: case V_KEY_5: case V_KEY_6: case V_KEY_7:
case V_KEY_8: case V_KEY_9:
act = key - V_KEY_0 + VACT_NUM_0;
break;
*/
case V_KEY_EXIT:
if (sys_data_get_cur_chan_mode() == TV_CHAN)
act = VACT_CLOSE;
break;
default:
act = VACT_PASS;
}
return act;
}
static PRESULT win_progname_message_proc(UINT32 msg_type, UINT32 msg_code)
{
PRESULT ret = PROC_LOOP;
switch (msg_type)
{
case CTRL_MSG_SUBTYPE_CMD_EPG_PF_UPDATED:
// case CTRL_MSG_SUBTYPE_CMD_EPG_SCH_UPDATED:
case CTRL_MSG_SUBTYPE_CMD_TIMEDISPLAYUPDATE:
case CTRL_MSG_SUBTYPE_STATUS_SIGNAL:
if (msg_type == CTRL_MSG_SUBTYPE_CMD_EPG_PF_UPDATED)
{
event_update = TRUE;
win_progname_redraw(TRUE);
}
else
event_update = FALSE;
if (msg_type == CTRL_MSG_SUBTYPE_STATUS_SIGNAL)
ret = PROC_PASS;
break;
case CTRL_MSG_SUBTYPE_CMD_EXIT:
if (sys_data_get_cur_chan_mode() == TV_CHAN)
ret = PROC_LEAVE;
else if(sys_data_get_cur_chan_mode() == RADIO_CHAN)
{
//to avoid the temporary stop when fast change Radio program channel
sys_data_save(1);
}
break;
case CTRL_MSG_SUBTYPE_STATUS_SCROLL_STRING:
win_progname_scroll_string();
break;
default:
ret = PROC_PASS;
}
return ret;
}
static PRESULT otaset_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
PRESULT ret = PROC_PASS;
UINT32 sat_cnt;
POBJECT_HEAD submenu;
switch(event)
{
case EVN_PRE_OPEN:
ota_presat_id = 0xFFFF;
//wincom_open_title(pObj,RS_UPGRADE_MODE_SAT, 0);
wincom_open_subtitle(pObj,RS_TOOLS_SW_UPGRADE_BY_OTA, 0);
#ifdef _BUILD_OTA_E_
ota_load_parameter();
#else
win_otaset_load_default_setting(0);
#endif
win_otaset_load_FreqSymbPid_display();
break;
case EVN_POST_DRAW:
//win_signal_open(pObj);
win_signal_open_ex(pObj,pObj->frame.uLeft+30,pObj->frame.uTop + LIST_ITEMCNT*(CON_H + CON_GAP) +20);
win_otaset_turn_frntend();
wincom_open_commen_help(pObj);
//win_signal_refresh();
//win_signal_update();
break;
case EVN_PRE_CLOSE:
/* Make OSD not flickering */
*((UINT32*)param2) &= ~C_CLOSE_CLRBACK_FLG;
break;
case EVN_POST_CLOSE:
wincom_close_subtitle();
OSD_ClearScreen();
if((sys_data_get_sate_group_num(sys_data_get_cur_chan_mode())==0))
OSD_DrawObject((POBJECT_HEAD)&g_win_mainmenu,C_UPDATE_ALL);
win_open_submenu_title(submenu,sub_menu_desc->title_id, 0); //guop
break;
case EVN_MSG_GOT:
if(param1 == CTRL_MSG_SUBTYPE_STATUS_SIGNAL)
win_signal_refresh();
//win_signal_update();
break;
}
return ret;
}
static PRESULT av_con_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
PRESULT ret = PROC_PASS;
VACTION unact;
POBJECT_HEAD submenu;
switch(event)
{
case EVN_PRE_OPEN:
wincom_open_subtitle((POBJECT_HEAD)&win_av_con,RS_SYSTEM_TV_SYSTEM, 0);
win_av_load_setting();
win_av_set_vcrloop_action(FALSE);
win_av_init_items();
#ifdef NEW_DEMO_FRAME
remove_menu_item((POBJECT_HEAD)&win_av_con, (OBJECT_HEAD *)&av_item_con5, CON_H + CON_GAP);
remove_menu_item((POBJECT_HEAD)&win_av_con, (OBJECT_HEAD *)&av_item_con6, CON_H + CON_GAP);
remove_menu_item((POBJECT_HEAD)&win_av_con, (OBJECT_HEAD *)&av_item_con7, CON_H + CON_GAP);
#endif
break;
case EVN_POST_OPEN:
wincom_open_commen_help(pObj);
wincom_open_help(pObj,0,0);
break;
case EVN_PRE_CLOSE:
sys_data_save(1);
/* Make OSD not flickering */
*((UINT32*)param2) &= ~C_CLOSE_CLRBACK_FLG;
break;
case EVN_POST_CLOSE:
wincom_close_subtitle();
OSD_ClearScreen();
if((sys_data_get_sate_group_num(sys_data_get_cur_chan_mode())==0))
OSD_DrawObject((POBJECT_HEAD)&g_win_mainmenu,C_UPDATE_ALL);
win_open_submenu_title(submenu,sub_menu_desc->title_id, 0); //guop
break;
case EVN_MSG_GOT:
if(param1 == CTRL_MSG_SUBTYPE_CMD_TVSAT_SWITCH)
{
win_av_load_tv_mode_setting(TRUE);
ret = PROC_LOOP;
}
break;
default:
break;
}
return ret;
}
static PRESULT satfav_item_lst_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
PRESULT ret = PROC_PASS;
VACTION unact;
OBJLIST* ol = (OBJLIST*)pObj;
UINT16 sel;
UINT8 group_idx;
UINT8 av_flag;
switch(event)
{
case EVN_PRE_DRAW:
win_satfav_set_display();
break;
case EVN_PRE_CHANGE:
break;
case EVN_ITEM_POST_CHANGE:
break;
case EVN_POST_CHANGE:
sel = OSD_GetObjListSingleSelect(ol);
if(sel < sys_data_get_group_num() )
{
av_flag = sys_data_get_cur_chan_mode();
group_idx = (UINT8)sel;
if(sat_fav_list_flag == 1)
{
group_idx += sys_data_get_sate_group_num(av_flag);
group_idx ++;
}
sys_data_change_group(group_idx);
#if defined(ORDER_GZ1010001)||defined(ORDER_GZ1104006)
ap_send_msg(CTRL_MSG_SUBTYPE_CMD_ENTER_ROOT, (UINT32)&g_win_light_chanlist_1, TRUE);
#else
ap_send_msg(CTRL_MSG_SUBTYPE_CMD_ENTER_ROOT, (UINT32)&g_win_light_chanlist, TRUE);
#endif
ret = PROC_LEAVE;
}
break;
default:
break;
}
return ret;
}
static PRESULT timerlst_item_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
PRESULT ret = PROC_PASS;
VACTION unact;
UINT8 bID;
TIMER_SET_CONTENT rettimer,*timer;
SYSTEM_DATA* sys_data;
P_NODE p_node;
UINT16 curview_index = 0;
bID = OSD_GetObjID(pObj);
sys_data = sys_data_get();
switch(event)
{
case EVN_PRE_DRAW:
break;
case EVN_UNKNOWN_ACTION:
unact = (VACTION)(param1>>16);
if(unact == VACT_ENTER)
{
sys_data->timer_set.common_timer_num = bID;
timer = &sys_data->timer_set.TimerContent[bID - 1];
if(timer->timer_mode==TIMER_MODE_OFF)
{
timer->wakeup_chan_mode = sys_data_get_cur_chan_mode();
curview_index = sys_data_get_cur_group_cur_mode_channel();
get_prog_at(curview_index,&p_node);
timer->wakeup_channel = p_node.prog_id;
}/*if the timer if off,set the default channel as current playing one.*/
if(win_timerset_open(timer,&rettimer,timer->timer_mode==TIMER_MODE_OFF))
MEMCPY(timer,&rettimer,sizeof(TIMER_SET_CONTENT));
OSD_TrackObject((POBJECT_HEAD)&g_win_timerlist, C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
}
break;
default:
;
}
return ret;
}
static PRESULT win_progname_unkown_act_proc(VACTION act)
{
PRESULT ret = PROC_LOOP;
INT32 shift;
UINT8 av_mode, back_saved;
UINT16 channel;
UINT16 strID;
#ifdef AD_SANZHOU
P_NODE pnode;
#endif
api_stop_timer(&progname_timer);
#ifdef MULTI_CAS
#if(CAS_TYPE==CAS_IRDETO)
if(getStopChannelChange()&&(act!=VACT_RECALL&&act!=VACT_SCHEDULE))//check whether stop channel change
return ret;
#endif
#endif
shift = - 1;
switch (act)
{
case VACT_CH_UP:
shift = 1;
case VACT_CH_DOWN:
change_channel(shift);
#ifdef MIS_AD
MIS_ShowEpgAdv(0);
#endif
break;
case VACT_GRP_UP:
shift = 1;
case VACT_GRP_DOWN:
change_group(shift);
break;
case VACT_FCH_UP:
shift = 1;
case VACT_FCH_DOWN:
change_fav_channel(shift);
break;
case VACT_TV_RADIO_SW:
av_mode = sys_data_get_cur_chan_mode();
av_mode = (av_mode == TV_CHAN) ? RADIO_CHAN : TV_CHAN;
//sys_data_set_cur_intgroup_index(0); /*force to return all group*/
sys_data_get_group_channel(0, &channel, av_mode);
if (channel == P_INVALID_ID)
{
/* If the opposite mode has no channel */
win_compopup_init(WIN_POPUP_TYPE_SMSG);
if(av_mode == TV_CHAN)
{
win_compopup_set_msg(NULL, NULL, RS_MSG_NO_PROGRAM_TV);
}
else
{
win_compopup_set_msg(NULL, NULL, RS_MSG_NO_RADIO_CHANNEL);
}
win_compopup_open_ext(&back_saved);
osal_task_sleep(1000);
win_compopup_smsg_restoreback();
#ifdef MULTI_CAS
#if(CAS_TYPE==CAS_CONAX)
if(get_mmi_msg_cnt()>0)
{
ap_send_msg(CTRL_MSG_SUBTYPE_STATUS_MCAS, 0, FALSE);
MMI_PRINTF("CTRL_MSG_SUBTYPE_STATUS_MCAS: tv/radio; code:%d\n",0);
set_mmi_showed(10);
}
#endif
#endif
}
else
{
sys_data_set_cur_chan_mode(av_mode);
change_group(0);
}
break;
case VACT_RECALL:
channel = recall_play_channel(0);
if (channel != P_INVALID_ID)
{
#ifdef MULTI_CAS
#if(CAS_TYPE==CAS_CONAX)
/*clean msg*/
clean_mmi_msg(1, TRUE);
clean_mmi_msg(3, TRUE);
clean_mmi_msg(4, TRUE);
clean_mmi_msg(6, TRUE);
if(get_mmi_showed()==1||get_mmi_showed()==6)
win_mmipopup_close();
if(get_mmi_showed()!=5)
set_mmi_showed(10);
#endif
#endif
api_play_channel(channel, TRUE, TRUE, FALSE);
#ifdef AD_SANZHOU
if(get_prog_at(channel, &pnode) == SUCCESS)
{
szxc_ad_hide_txt();
szxc_ad_show_txt(pnode.prog_number);
szxc_ad_hide_pic(AD_BANNER);
szxc_ad_show_banner(pnode.prog_number,banner_pic_rt);
}
#endif
}
#ifdef MULTI_CAS
#if(CAS_TYPE==CAS_CONAX)
else if(get_mmi_msg_cnt()>0)
{
ap_send_msg(CTRL_MSG_SUBTYPE_STATUS_MCAS, 0, FALSE);
MMI_PRINTF("CTRL_MSG_SUBTYPE_STATUS_MCAS: recall; code:%d\n",0);
set_mmi_showed(10);
}
#endif
#endif
#ifdef MIS_AD
MIS_ShowEpgAdv(0);
#endif
break;
case VACT_SCHEDULE:
api_stop_timer(&progname_timer);
//close the mini_epg
ap_send_msg(CTRL_MSG_SUBTYPE_CMD_EXIT, 1, TRUE);
//open the schedule
// ap_send_msg(CTRL_MSG_SUBTYPE_CMD_ENTER_ROOT, (UINT32)(POBJECT_HEAD)&g_win_schedule, TRUE);
break;
default:
;
}
#ifdef MULTI_CAS
#if(CAS_TYPE==CAS_CDCA)
show_finger_print(0, 0);
#elif(CAS_TYPE==CAS_DVT)
ap_cas_fingerprint_proc(0, 1);
#endif
#endif
win_progname_redraw(TRUE);
progname_timer = api_start_timer(PROGNAME_TIMER_NAME, PROGNAME_TIMER_TIME, progname_timer_func);
#ifdef MIS_AD
Mis_Set_SameChan_AdvShowOnce(TRUE);
Mis_Set_EnterAutoShow(FALSE);
#endif
return ret;
}
static PRESULT win_progname_unkown_act_proc(VACTION act)
{
PRESULT ret = PROC_LOOP;
INT32 shift;
UINT8 av_mode,back_saved;
UINT16 channel;
UINT16 strID;
#ifdef DVR_PVR_SUPPORT
if(api_pvr_is_recording())
{
if( act != VACT_CH_UP && act != VACT_CH_DOWN)
{
return ret;
}
}
#endif
api_stop_timer(&progname_timer);
shift = -1;
switch(act)
{
case VACT_CH_UP:
shift = 1;
case VACT_CH_DOWN:
change_channel(shift);
break;
case VACT_GRP_UP:
shift = 1;
case VACT_GRP_DOWN:
change_group(shift);
break;
case VACT_FCH_UP:
shift = 1;
case VACT_FCH_DOWN:
change_fav_channel(shift);
break;
case VACT_TV_RADIO_SW:
av_mode = sys_data_get_cur_chan_mode();
av_mode = (av_mode==TV_CHAN)? RADIO_CHAN : TV_CHAN;
sys_data_get_cur_group_channel(&channel, av_mode);
if(channel==P_INVALID_ID) /* If the opposite mode has no channel */
{
if(av_mode==RADIO_CHAN)
strID = RS_MSG_NO_RADIO_CHANNEL;
else
strID = RS_MSG_NO_TV_CHANNEL;
win_compopup_init(WIN_POPUP_TYPE_SMSG);
win_compopup_set_msg(NULL, NULL,strID);
win_compopup_open_ext(&back_saved);
osal_task_sleep(500);
win_compopup_smsg_restoreback();
}
else
{
#ifndef NEW_DEMO_FRAME
UIChChgStopProg(TRUE);
#endif
sys_data_set_cur_chan_mode(av_mode);
change_group(0);
}
break;
case VACT_RECALL:
channel = recall_play_channel(0);
if(channel != P_INVALID_ID)
api_play_channel(channel, TRUE, TRUE,FALSE);
break;
case VACT_POP_DETAIL:
b_popdetail = TRUE;
ret = PROC_LEAVE;
break;
default:
break;
}
win_progname_redraw();
progname_timer = api_start_timer(PROGNAME_TIMER_NAME,PROGNAME_TIMER_TIME,progname_timer_func);
return ret;
}
void win_progname_draw_infor(void)
{
UINT16 group_name[MAX_SERVICE_NAME_LENGTH + 1 + 10];
UINT8 group_type,av_mode;
UINT16 cur_channel;
P_NODE p_node;
S_NODE s_node;
// T_NODE t_node;
char string[100];
char prog_name[MAX_SERVICE_NAME_LENGTH + 1];
INT32 ret,len;
UINT32 i,j;
BITMAP* bmp;
TEXT_FIELD* txt;
UINT16 icon;
date_time dt;
prog_txt_t* p_prog_txt;
prog_bmp_t* p_prog_bmp;
eit_event_info_t *pe=NULL,*fe=NULL;
UINT8 *s1=NULL,*s2=NULL;
INT32 strlen;
struct ACTIVE_SERVICE_INFO service;
struct t_ttx_lang *ttx_lang_list;
UINT8 ttx_lang_num;
struct t_subt_lang* sub_lang_list;
UINT8 sub_lang_num;
bmp = &prog_bmp;
txt = &prog_text;
UINT32 fav_mask;
fav_mask = 0;
for(i=0;i<MAX_FAVGROUP_NUM;i++)
fav_mask |= (0x01<<i);
av_mode = sys_data_get_cur_chan_mode();
cur_channel = sys_data_get_cur_group_cur_mode_channel();
ret = get_prog_at(cur_channel,&p_node);
get_sat_by_id(p_node.sat_id, &s_node);
get_cur_group_name((char*)group_name,&group_type);
get_local_time(&dt);
/*
#ifdef _EPG_MULTI_SERVICE
#ifdef EPG_FAST_PARSE
epg_fast_pasrse_set(FALSE,NULL,NULL);
#endif
get_tp_by_id(p_node.tp_id, &t_node);
api_epg_parse(p_node.tp_id, t_node.network_id, t_node.t_s_id, p_node.prog_number, epg_type_pf);
struct active_service_t service;
service.tp_id = p_node.tp_id;
service.orig_network_id = t_node.network_id;
service.ts_id = t_node.t_s_id;
service.service_id = p_node.prog_number;
api_epg_set_active_service(&service, 1);
api_epg_parse(p_node.tp_id, t_node.network_id, t_node.t_s_id, p_node.prog_number, epg_type_pf);
#endif
*/
service.tp_id = p_node.tp_id;
service.service_id = p_node.prog_number;
epg_set_active_service(&service, 1);
/*current next epg info */
pe=epg_get_cur_service_event((INT32)cur_channel, PRESENT_EVENT, NULL,NULL,NULL, /*event_update*/TRUE);
fe=epg_get_cur_service_event((INT32)cur_channel, FOLLOWING_EVENT, NULL,NULL,NULL, event_update);
if(event_update==FALSE)
{
if(pe==NULL || fe==NULL)
{
event_update = TRUE;
}
}
else
{
if(pe!=NULL && fe!=NULL)
{
event_update = FALSE;
}
}
s1=epg_get_event_name(pe, &len);
// s1=(UINT8*)epg_get_event_name(pe, present_name, 32);
s2=epg_get_event_name(fe, &len);
// s2=(UINT8*)epg_get_event_name(fe, following_name, 32);
TTXEng_GetInitLang(&ttx_lang_list, &ttx_lang_num);
subt_get_language(&sub_lang_list ,&sub_lang_num);
if(sub_lang_num == 0)
TTXEng_GetSubtLang(&ttx_lang_list,&sub_lang_num);
for(i=0;i<PROG_BMP_NUM;i++)
{
p_prog_bmp = &prog_bmps[i];
icon = INVALID_ID;
switch(p_prog_bmp->bmp_type)
{
case PROG_BMP_STATIC:
icon = prog_bmps[i].icon;
break;
#ifndef MODIFY_FOR_EGYPT_CUSTOMER
case PROG_BMP_AV_TYPE:
if(av_mode==TV_CHAN)
icon = IM_INFO_BAR_TV;
else
icon = IM_INFO_BAR_RADIO;
break;
#endif
case PROG_BMP_EPG:
if( (s1||s2) )
icon = prog_bmps[i].icon;
break;
case PROG_BMP_TTX:
if(ttx_lang_num>0)
icon = prog_bmps[i].icon;
break;
case PROG_BMP_SUBT:
if(sub_lang_num>0)
icon = prog_bmps[i].icon;
break;
case PROG_BMP_LOCK:
if(p_node.lock_flag)
icon = prog_bmps[i].icon;
break;
case PROG_BMP_FAV:
if(p_node.fav_group[0] & fav_mask)
icon = prog_bmps[i].icon;
break;
case PROG_BMP_CA:
{
#if 0
BOOL b,bFlag;
INT8 level,quality,lock;
signal_lock_status lock_flag;
signal_scramble_status scramble_flag;
signal_lnbshort_status lnbshort_flag;
signal_parentlock_status parrentlock_flag;
bFlag = GetSignalStatus(&lock_flag, &scramble_flag,&lnbshort_flag,&parrentlock_flag);
if(bFlag && lock_flag== SIGNAL_STATUS_LOCK
&& lnbshort_flag==SIGNAL_STATUS_LNBNORMAL
&& parrentlock_flag==SIGNAL_STATUS_PARENT_UNLOCK
&& scramble_flag == SIGNAL_STATUS_SCRAMBLED)
icon = prog_bmps[i].icon;
#else
if(p_node.ca_mode)
icon = prog_bmps[i].icon;
#endif
}
break;
default:
break;
}
OSD_SetBitmapContent(bmp, icon);
OSD_SetRect(&bmp->head.frame, p_prog_bmp->left, p_prog_bmp->top, p_prog_bmp->width,p_prog_bmp->height);
OSD_DrawObject( (OBJECT_HEAD*) bmp, C_UPDATE_ALL);
}
for(i=0;i<PROG_TXT_NUM;i++)
{
p_prog_txt = &prog_txts[i];
string[0] = '\0';
switch(p_prog_txt->txt_type)
{
case PROG_TXT_PROG_NAME:
#ifndef DB_USE_UNICODE_STRING
STRCPY(prog_name,p_node.service_name);
for(j=0;j<STRLEN(prog_name);j++)
if(prog_name[j] >= 0x80)
{
prog_name[j] = '\0';
break;
}
if(p_node.ca_mode==0)
sprintf(string,"%s(%s)",prog_name,s_node.sat_name);
else
sprintf(string,"$%s(%s)",prog_name,s_node.sat_name);
#else
if(p_node.ca_mode==0)
STRCPY(string,"");
else
STRCPY(string,"$");
ComAscStr2Uni(string,len_display_str);
strlen = ComUniStrLen( len_display_str);
//strcpy_uni(&len_display_str[strlen],p_node.service_name);
ComUniStrCopyChar((UINT8 * )&len_display_str[strlen],p_node.service_name);
strlen = ComUniStrLen( len_display_str);
ComAscStr2Uni("(",&len_display_str[strlen]);
strlen = ComUniStrLen( len_display_str);
ComUniStrCopyChar((UINT8 * )&len_display_str[strlen],s_node.sat_name);
strlen = ComUniStrLen( len_display_str);
ComAscStr2Uni(")",&len_display_str[strlen]);
#endif
break;
case PROG_TXT_DATE:
sprintf(string,"%02d/%02d",dt.month,dt.day);
ComAscStr2Uni(string, (UINT16 *)len_display_str);
break;
case PROG_TXT_TIME:
sprintf(string,"%02d:%02d",dt.hour,dt.min);
ComAscStr2Uni(string, (UINT16 *)len_display_str);
break;
case PROG_TXT_PROG_NUM:
sprintf(string,"%04d",cur_channel + 1);
ComAscStr2Uni(string, (UINT16 *)len_display_str);
break;
case PROG_TXT_EPG_NOW:
if (s1 )
{
sprintf(string,"Now: ");
ComAscStr2Uni(string, (UINT16 *)len_display_str);
len =ComUniStrLen(len_display_str);
ComUniStrCopyChar((UINT8*)&len_display_str[len],s1);
}
else
{
OSD_SetTextFieldStrPoint(txt,NULL);
OSD_SetTextFieldContent(txt,STRING_ID,RS_EPG_NO_INFORMATION);
}
break;
case PROG_TXT_EPG_NEXT:
if (s2)
{
sprintf(string,"Next: ");
ComAscStr2Uni(string, (UINT16 *)len_display_str);
len =ComUniStrLen(len_display_str);
ComUniStrCopyChar((UINT8*)&len_display_str[len],s2);
}
else
{
sprintf(string," ");
ComAscStr2Uni(string, (UINT16 *)len_display_str);
}
break;
case PROG_TXT_PROG_GROUP:
#ifndef DB_USE_UNICODE_STRING
sprintf(string,"%s",group_name);
#else
ComUniStrCopy(len_display_str, group_name);
#endif
break;
default:
;
}
#ifndef DB_USE_UNICODE_STRING
ComAscStr2Uni(string, (UINT16 *)len_display_str);
#else
/*
if(p_prog_txt->txt_type != PROG_TXT_PROG_NAME
&& p_prog_txt->txt_type != PROG_TXT_PROG_GROUP
&&p_prog_txt->txt_type != PROG_TXT_EPG_NOW
&&p_prog_txt->txt_type != PROG_TXT_EPG_NEXT)
ComAscStr2Uni(string, (UINT16 *)len_display_str);
*/
if(p_prog_txt->txt_type == PROG_TXT_PROG_NUM)
txt->head.bFont = 2;
else
txt->head.bFont = 0;
#endif
OSD_SetRect(&txt->head.frame, p_prog_txt->left, p_prog_txt->top, p_prog_txt->width,p_prog_txt->height);
//txt->pText = (UINT8*)len_display_str;
txt->head.style.bShowIdx = p_prog_txt->shidx;
OSD_DrawObject( (OBJECT_HEAD *)txt, C_UPDATE_ALL);
OSD_SetTextFieldContent(txt,STRING_ID,0);
OSD_SetTextFieldStrPoint(txt,len_display_str);
}
#ifdef MODIFY_FOR_EGYPT_CUSTOMER
progname_signal_refresh(TRUE);
#endif
}
UINT16 recall_play_channel(UINT8 index)
{
UINT8 group_type,group_pos = 0;
UINT8 cur_mode,new_mode,cur_group_idx,cur_group_type,cur_group_pos;
UINT8 int_group_idx;
UINT16 cur_channel,playing_channel;
S_NODE s_node;
P_NODE *pnode;
BOOL exit = FALSE;
INT32 n;
UINT8 mode_changed;
playing_channel= sys_data_get_cur_group_cur_mode_channel();
cur_group_idx = sys_data_get_cur_group_index();
sys_data_get_cur_mode_group_infor(cur_group_idx,&cur_group_type, &cur_group_pos, &cur_channel);
index = 0;
cur_mode = sys_data_get_cur_chan_mode();
if(cur_mode != recent_channels[index].mode)
{
sys_data_set_cur_chan_mode(recent_channels[index].mode);
mode_changed = 1;
}
else
mode_changed = 0;
int_group_idx = recent_channels[index].internal_group_idx;
if(int_group_idx==0)
{
group_type = ALL_SATE_GROUP_TYPE;
group_pos = 0;
}
else if( int_group_idx<= MAX_SAT_NUM )
{
group_type = SATE_GROUP_TYPE;
group_pos = int_group_idx - 1;
}
else
{
group_type = FAV_GROUP_TYPE;
group_pos = int_group_idx - 1 - MAX_SAT_NUM;
}
cur_group_idx = sys_data_get_cur_group_index();
new_mode = sys_data_get_cur_chan_mode();
//printf("%d,%d,%d\n",cur_group_type,cur_group_pos,cur_channel);
if(mode_changed || group_type != cur_group_type || (group_pos!=cur_group_pos && group_type!=ALL_SATE_GROUP_TYPE))
{
RECREATE_PROG_VIEW:
if(group_type==ALL_SATE_GROUP_TYPE)
recreate_prog_view(VIEW_ALL | new_mode, 0);
else if(group_type==SATE_GROUP_TYPE)
{
if( get_sat_at(group_pos,VIEW_ALL,&s_node) != SUCCESS)
return P_INVALID_ID;
recreate_prog_view(VIEW_SINGLE_SAT|new_mode,s_node.sat_id);
}
else
recreate_prog_view(VIEW_FAV_GROUP|new_mode,group_pos);
if(exit)
{
//printf("No this group,exit to previous group,int_group_idx%d\n",int_group_idx);
return P_INVALID_ID;
}
if( get_prog_num(VIEW_ALL | new_mode, 0) >0 )
sys_data_set_cur_intgroup_index(int_group_idx);
else
{
exit = TRUE;
group_type = cur_group_type;
group_pos = cur_group_pos;
new_mode = cur_mode;
sys_data_set_cur_chan_mode(cur_mode);
goto RECREATE_PROG_VIEW;
}
mode_changed = 1;// re-using this variable
}else
{
mode_changed = 0;// re-using this variable
}
cur_mode = sys_data_get_cur_chan_mode();
//cur_channel = get_prog_pos(&recent_channels[index].p_node);
pnode = &recent_channels[index].p_node;
cur_channel = get_prog_pos(pnode->prog_id);
n= get_prog_num(VIEW_ALL | cur_mode, 0);
if(cur_channel>= n)
{
if(n>0)
cur_channel = n - 1;
/*
else
{
exit = TRUE;
group_type = cur_group_type;
group_pos = cur_group_pos;
sys_data_set_cur_chan_mode(cur_mode);
goto RECREATE_PROG_VIEW;
}
*/
}
if(0 == mode_changed && playing_channel == cur_channel)
{
cur_channel = P_INVALID_ID;
}
return cur_channel;
}
static void newcamd_draw_progname(BOOL update)
{
UINT8 av_mode,j;
UINT16 cur_channel,strlen;
P_NODE p_node;
UINT32 ret;
char prog_name[50];
char string[100];
UINT16 uni_string[100];
av_mode = sys_data_get_cur_chan_mode();
if( sys_data_get_group_num() == 0 )
{
sys_data_set_cur_chan_mode(av_mode==TV_CHAN? RADIO_CHAN : TV_CHAN);
if( sys_data_get_group_num() == 0 )
{
sys_data_set_cur_chan_mode(av_mode);
ComUniStrCopyChar((UINT8 *)uni_string, OSD_GetUnicodeString(RS_MSG_NO_CHANNELS));
goto set_progname;
}
}
cur_channel = sys_data_get_cur_group_cur_mode_channel();
ret = get_prog_at(cur_channel,&p_node);
#ifndef DB_USE_UNICODE_STRING
MEMSET(prog_name,0,sizeof(prog_name));
STRCPY(prog_name,p_node.service_name);
for(j=0;j<STRLEN(prog_name);j++)
{
if(prog_name[j] >= 0x80)
{
prog_name[j] = '\0';
break;
}
}
if(p_node.ca_mode==0)
sprintf(string,"%d.%s",cur_channel+1,prog_name);
else
sprintf(string,"$%d.%s",cur_channel+1,prog_name);
ComAscStr2Uni(string, (UINT16 *)uni_string)
#else
if(p_node.ca_mode==0)
sprintf(string,"%d.",cur_channel+1);
else
sprintf(string,"$%d.",cur_channel+1);
ComAscStr2Uni(string,uni_string);
strlen = ComUniStrLen( uni_string);
ComUniStrCopyChar( (UINT8 *)&uni_string[strlen],p_node.service_name);
strlen = ComUniStrLen( uni_string);
#endif
set_progname:
OSD_SetTextFieldContent(&newcamd_txt_chn, STRING_UNICODE, (UINT32)uni_string);
if(update)
{
OSD_DrawObject((POBJECT_HEAD)&newcamd_txt_chn,C_DRAW_SIGN_EVN_FLG |C_UPDATE_ALL);
}
}
static PRESULT srch_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
PRESULT ret = PROC_PASS;
UINT16 title_id;
POBJECT_HEAD mainmenu;
UINT8 av_flag;
UINT16 cur_chan;
UINT8 back_saved;
switch(event)
{
case EVN_PRE_OPEN:
system_state = SYS_STATE_SEARCH_PROG;
if(win_search_param.as_method == AS_METHOD_TP
|| win_search_param.as_method == AS_METHOD_NIT_TP) // tp scan
title_id = RS_INSTALLATION_TP_SCAN;
else if(win_search_param.as_method == AS_METHOD_FFT
|| win_search_param.as_method == AS_METHOD_MULTI_FFT)//auto scan
title_id = RS_INSTALLATION_AUTO_SCAN;
else if(win_search_param.as_method == AS_METHOD_SAT_TP
||win_search_param.as_method == AS_METHOD_MULTI_TP
|| win_search_param.as_method == AS_METHOD_NIT
|| win_search_param.as_method == AS_METHOD_MULTI_NIT)//preset scan
title_id = RS_INSTALLATION_PRESET_SCAN;
else
title_id = RS_INSTALLATION_AUTO_SCAN;
wincom_open_subtitle(pObj,title_id,0);
/*Remove progress bar when search type is AS_METHOD_NIT_TP/AS_METHOD_NIT/AS_METHOD_MULTI_NIT*/
if(win_search_param.as_method == AS_METHOD_NIT_TP ||
win_search_param.as_method == AS_METHOD_NIT||
win_search_param.as_method == AS_METHOD_MULTI_NIT)
{
OSD_SetAttr(&srch_progress_txt, C_ATTR_HIDDEN);
OSD_SetAttr(&srch_progress_bar, C_ATTR_HIDDEN);
}
else
{
OSD_SetAttr(&srch_progress_txt, C_ATTR_ACTIVE);
OSD_SetAttr(&srch_progress_bar, C_ATTR_ACTIVE);
}
key_pan_display("srch", 4);
epg_off();
stop_tdt();
#ifdef AUTOSCAN_BYPASS_CI
// Before Autoscan, DMX0 bypass CI
if(win_search_param.as_method == AS_METHOD_FFT
|| win_search_param.as_method == AS_METHOD_MULTI_FFT)//auto scan
{
tsi_dmx_src_select(TSI_DMX_0, TSI_TS_B);
tsi_para_src_select(TSI_SPI_1,0);
api_set_nim_ts_type(2, 0x03);
}
#endif
#ifdef HW_SS830C
tsi_dmx_src_select(TSI_DMX_0, TSI_TS_B);
api_set_nim_ts_type(2, 0x03);
#endif
break;
case EVN_POST_OPEN:
win_search_init();
break;
case EVN_PRE_CLOSE:
win_search_pre_close = 1;
osal_task_dispatch_off();
moving_disk = 0;/*Clear moving dish flag*/
win_search_stop_signal = 1;
osal_task_dispatch_on();
as_service_stop();
db_search_exit();
//api_stop_timer(&win_search_tmr_id);
/* Make OSD not flickering */
*((UINT32*)param2) &= ~C_CLOSE_CLRBACK_FLG;
prog_callback_unregister();
pid_search_flg = 0;
break;
case EVN_POST_CLOSE:
if((srch_ch_cnt[0] != 0x0)
|| (srch_ch_cnt[1] != 0x0))
{
win_search_last_tp_ok_failed(srch_tp_cnt);
win_compopup_init(WIN_POPUP_TYPE_SMSG);
win_compopup_set_msg(NULL, NULL, RS_MSG_WAIT_FOR_SAVING);
//win_compopup_open();
win_compopup_open_ext(&back_saved);
update_data();
win_compopup_smsg_restoreback();
win_compopup_init(WIN_POPUP_TYPE_OK);
win_compopup_set_msg("Search End", NULL, 0);
win_compopup_open_ext(&back_saved);
/* Change to all satellite group */
UINT32 grp_idx = sys_data_get_cur_group_index();
sys_data_check_channel_groups();
sys_data_set_cur_group_index(grp_idx);
av_flag = sys_data_get_cur_chan_mode();
if(sys_data_get_sate_group_num(av_flag) == 0)
{
av_flag = (av_flag == TV_CHAN)? RADIO_CHAN : TV_CHAN;
sys_data_set_cur_chan_mode(av_flag);
}
if(av_flag == RADIO_CHAN && (srch_ch_cnt[1] != 0x0)) //guop add 20101231
{
av_flag = TV_CHAN;
sys_data_set_cur_chan_mode(av_flag);
}
sys_data_change_group(grp_idx);
if(srch_ch_cnt[av_flag] > 0)
{
cur_chan = get_prog_pos(win_search_cur_prog[av_flag].prog_id);
if(cur_chan == 0xFFFF)
{
grp_idx = get_sat_pos(cur_sat_id) + 1;
sys_data_change_group(grp_idx);
cur_chan = get_prog_pos(win_search_cur_prog[av_flag].prog_id);
if (cur_chan == 0xFFFF)
{
sys_data_change_group(0);
cur_chan = get_prog_pos(win_search_cur_prog[av_flag].prog_id);
if (cur_chan == 0xffff)
cur_chan = 0;
}
}
sys_data_set_cur_group_channel(cur_chan);
}
else if(sys_data_get_sate_group_num(av_flag))
key_pan_display("noCH", 4);
else
key_pan_display("----", 4);
sys_data_save(1);
epg_reset();
}
OSD_ClearObject( (POBJECT_HEAD)&srch_progress_bar, C_UPDATE_ALL);
OSD_ClearObject( (POBJECT_HEAD)&srch_progress_txt, C_UPDATE_ALL);
mainmenu = (POBJECT_HEAD)&g_win_mainmenu;
OSD_TrackObject(mainmenu,C_UPDATE_ALL);
#ifdef AUTOSCAN_BYPASS_CI
// After Autoscan, DMX0 NOT bypass CI
if(win_search_param.as_method == AS_METHOD_FFT
|| win_search_param.as_method == AS_METHOD_MULTI_FFT)//auto scan
{
tsi_dmx_src_select(TSI_DMX_0, TSI_TS_A);
tsi_para_src_select(TSI_SPI_1,0);
}
#endif
start_tdt();
system_state = SYS_STATE_NORMAL;
break;
case EVN_MSG_GOT:
ret = win_search_message_proc(param1,param2);
break;
}
return ret;
}
UINT8 sys_data_group_inc_dec(UINT8 grp_idx, BOOL inc, UINT32 flag)
{
UINT8 group_type, group_pos;
UINT8 av_mode;
UINT16 channel = P_INVALID_ID;
SYSTEM_DATA * psys_data = sys_data_get();
BOOL b = sys_data_get_cur_mode_group_infor(grp_idx, &group_type, &group_pos, &channel);
if (!b)
return ALL_GROUP_TYPE;
av_mode = sys_data_get_cur_chan_mode();
if (inc)
{
if (grp_idx == psys_data->local_group_cnt)
{
grp_idx = DATA_GROUP_TYPE;
sys_data_get_group_channel(grp_idx, &channel, av_mode);
if ((flag & GRP_WITH_DATA) && (channel != P_INVALID_ID))
return grp_idx;
}
if (grp_idx == DATA_GROUP_TYPE)
{
grp_idx = NVOD_GROUP_TYPE;
sys_data_get_group_channel(grp_idx, &channel, av_mode);
if ((flag & GRP_WITH_NVOD) && (channel != P_INVALID_ID))
return grp_idx;
}
if (grp_idx == NVOD_GROUP_TYPE)
{
grp_idx = FAV_GROUP_TYPE;
sys_data_get_group_channel(grp_idx, &channel, av_mode);
if ((flag & GRP_WITH_FAV) && (channel != P_INVALID_ID))
return grp_idx;
}
if (grp_idx == FAV_GROUP_TYPE)
{
return ALL_GROUP_TYPE;
}
if (psys_data->local_group_cnt != 0)
{
grp_idx++;
return grp_idx;
}
else
return ALL_GROUP_TYPE;
}
else
{
if (grp_idx == ALL_GROUP_TYPE)
{
grp_idx = FAV_GROUP_TYPE;
sys_data_get_group_channel(grp_idx, &channel, av_mode);
if ((flag & GRP_WITH_FAV) && (channel != P_INVALID_ID))
return grp_idx;
}
if (grp_idx == FAV_GROUP_TYPE)
{
grp_idx = NVOD_GROUP_TYPE;
sys_data_get_group_channel(grp_idx, &channel, av_mode);
if ((flag & GRP_WITH_NVOD) && (channel != P_INVALID_ID))
return grp_idx;
}
if (grp_idx == NVOD_GROUP_TYPE)
{
grp_idx = DATA_GROUP_TYPE;
sys_data_get_group_channel(grp_idx, &channel, av_mode);
if ((flag & GRP_WITH_DATA) && (channel != P_INVALID_ID))
return grp_idx;
}
if (grp_idx == DATA_GROUP_TYPE)
{
return psys_data->local_group_cnt;
}
if (psys_data->local_group_cnt != 0)
{
grp_idx--;
return grp_idx;
}
else
return ALL_GROUP_TYPE;
}
}
/* 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();
}
}
static PRESULT satfav_con_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
PRESULT ret = PROC_PASS;
CONTAINER* cont = (CONTAINER*)pObj;
OBJLIST* ol= &satfav_item_list;
UINT8 vkey = 0xFF;
UINT8 av_flag,grp_cnt,back_saved;
switch(event)
{
case EVN_PRE_OPEN:
api_inc_wnd_count();
if( (param2 & MENU_OPEN_TYPE_MASK) == MENU_OPEN_TYPE_KEY)
vkey = param2 & MENU_OPEN_PARAM_MASK;
//if(vkey == V_KEY_SAT || vkey == V_KEY_FAV)
if(vkey == V_KEY_BLUE || vkey == V_KEY_FAV)
{
av_flag = sys_data_get_cur_chan_mode();
// sat_fav_list_flag = (vkey == V_KEY_SAT)? 0 : 1;
sat_fav_list_flag = (vkey == V_KEY_BLUE)? 0 : 1;
if(sat_fav_list_flag == 0)
grp_cnt = sys_data_get_sate_group_num(av_flag);
else
grp_cnt = sys_data_get_fav_group_num(av_flag);
if(grp_cnt == 0)
{
win_compopup_init(WIN_POPUP_TYPE_SMSG);
win_compopup_set_msg("No FAV Channels", NULL, 0);
win_compopup_open_ext(&back_saved);
osal_task_sleep(1000);
win_compopup_smsg_restoreback();
ret = PROC_LEAVE;
api_dec_wnd_count();
break;
}
}
else
{
ret = PROC_LEAVE;
api_dec_wnd_count();
break;
}
win_satfav_load_groupcount();
break;
case EVN_POST_OPEN:
break;
case EVN_PRE_CLOSE:
break;
case EVN_POST_CLOSE:
api_dec_wnd_count();
break;
case EVN_UNKNOWN_ACTION:
break;
default:
break;
}
return ret;
}
INT32 win_progname_set_info(void)
{
UINT16 group_name[MAX_SERVICE_NAME_LENGTH + 1+10];
UINT8 group_type, av_mode;
UINT16 cur_channel;
P_NODE p_node;
S_NODE s_node;
char string[100];
char prog_name[MAX_SERVICE_NAME_LENGTH + 1];
INT32 ret, len;
UINT32 i, j;
UINT16 icon;
date_time dt;
eit_event_info_t *pe = NULL, *fe = NULL;
UINT8 *s1 = NULL, *s2 = NULL;
INT32 strlen;
struct ACTIVE_SERVICE_INFO service;
UINT8 *src;
UINT8 *src8;
date_time start_time, end_time, local_time;
INT32 day, h, m, sec, timeLen, timePassed, progProcessLen;
UINT32 fav_mask;
struct t_ttx_lang *ttx_lang_list;
UINT8 ttx_lang_num;
struct t_subt_lang* sub_lang_list;
UINT8 sub_lang_num;
fav_mask = 0;
for (i = 0; i < MAX_FAVGROUP_NUM; i++)
fav_mask |= (0x01 << i);
get_STC_offset(&h, &m, &sec);
av_mode = sys_data_get_cur_chan_mode();
cur_channel = sys_data_get_cur_group_cur_mode_channel();
ret = get_prog_at(cur_channel, &p_node);
if(ret != SUCCESS)
return -1;
get_sat_by_id(p_node.sat_id, &s_node);
get_cur_group_name((char*)group_name, &group_type);
get_local_time(&dt);
service.tp_id = p_node.tp_id;
service.service_id = p_node.prog_number;
epg_set_active_service(&service, 1);
/* Get current next epg info */
pe = epg_get_cur_service_event((INT32)cur_channel, PRESENT_EVENT, NULL, NULL, NULL, event_update);
fe = epg_get_cur_service_event((INT32)cur_channel, FOLLOWING_EVENT, NULL, NULL, NULL, FALSE);
s1 = (UINT8*)epg_get_event_name(pe, present_name, 32);
s2 = (UINT8*)epg_get_event_name(fe, following_name, 32);
#ifdef TTX_ON
TTXEng_GetInitLang(&ttx_lang_list, &ttx_lang_num);
#endif
#ifdef SUBTITLE_ON
subt_get_language(&sub_lang_list ,&sub_lang_num);
#endif
#ifdef TTX_ON
if(sub_lang_num == 0)
TTXEng_GetSubtLang(&ttx_lang_list,&sub_lang_num);
#endif
/* Set bmp content */
if (av_mode == TV_CHAN)
icon = IM_PAY;
else
icon = IM_INFORMATION_RADIO;
OSD_SetBitmapContent(&prog_bmp, icon);
#ifdef TTX_ON
if(ttx_lang_num>0)
icon = IM_INFORMATION_ICON_TTX;
else
icon = INVALID_ID;
//soc_printf("ttx icon id:%x, ", icon);
OSD_SetBitmapContent(&prog_name_ttx, icon);
//OSD_SetRect(&bmp->head.frame, p_prog_bmp->left, p_prog_bmp->top, p_prog_bmp->width,p_prog_bmp->height);
OSD_DrawObject( (OBJECT_HEAD*) (&prog_name_ttx), C_UPDATE_ALL);
#endif
#ifdef SUBTITLE_ON
if(sub_lang_num>0)
icon = IM_INFORMATION_ICON_SUBTITLE;
else
icon = INVALID_ID;
//soc_printf("subt icon id:%x\n", icon);
OSD_SetBitmapContent(&prog_name_subt, icon);
OSD_DrawObject( (OBJECT_HEAD*) (&prog_name_subt), C_UPDATE_ALL);
#endif
/* Init display strings */
for (i=0; i<7; i++)
MEMSET(display_strs[20+i], 0, 2*MAX_DISP_STR_LEN);
/* Set prog_name content */
MEMSET(string, 0, sizeof(string));
if (p_node.ca_mode == 0)
STRCPY(string, "");
else
STRCPY(string, "$");
ComAscStr2Uni(string, display_strs[20]);
strlen = ComUniStrLen(display_strs[20]);
ComUniStrCopyChar((UINT8*) &display_strs[20][strlen], p_node.service_name);
/* Set prog_time content */
MEMSET(string, 0, sizeof(string));
sprintf(string, "%4d.%02d.%02d ", dt.year, dt.month, dt.day);
ComAscStr2Uni(string, display_strs[21]);
strlen = ComUniStrLen(display_strs[21]);
src = OSD_GetUnicodeString(weekday_id[dt.weekday%7]);
ComUniStrCopyChar((UINT8*) &display_strs[21][strlen], src);
/* Set prog_num content */
MEMSET(string, 0, sizeof(string));
sprintf(string, "%03d", cur_channel + 1);
ComAscStr2Uni(string, display_strs[22]);
/* Set epg_time_now, epg_now, prog_process content */
if (s1)
{
MEMSET(string, 0, sizeof(string));
get_STC_offset(&h, &m, &sec);
get_event_start_time(pe, &start_time);
get_event_end_time(pe, &end_time);
convert_time_by_offset(&start_time, &start_time, h, m);
convert_time_by_offset(&end_time, &end_time, h, m);
sprintf(string, "%02d:%02d~%02d:%02d ", start_time.hour, start_time.min, \
end_time.hour, end_time.min);
ComAscStr2Uni(string, (UINT16*)display_strs[23]);
ComUniStrCopyChar((UINT8*) &display_strs[24][0], s1);
//draw prog process
get_local_time(&local_time);
get_time_offset(&start_time, &end_time, &day, &h, &m, &sec);
timeLen = day * 24 * 60+h * 60+m;
get_time_offset(&start_time, &local_time, &day, &h, &m, &sec);
timePassed = day * 24 * 60+h * 60+m;
if ((timeLen <= 0) || (timePassed <= 0))
progProcessLen = 0;
else
progProcessLen = timePassed * PROG_PROCESS_W / timeLen;
if (progProcessLen > PROG_PROCESS_W)
progProcessLen = PROG_PROCESS_W;
///prog_process.head.frame.uWidth = progProcessLen;
}
else
{
MEMSET(string, 0, sizeof(string));
src8 = OSD_GetUnicodeString(RS_EPG_NO_INFORMATION);
ComUniStrCopyChar((UINT8*) &display_strs[23][0], src8);
sprintf(string, " ");
ComAscStr2Uni(string, (UINT16*)display_strs[24]);
}
/* Set epg_time_next, epg_next content */
if (s2)
{
MEMSET(string, 0, sizeof(string));
get_STC_offset(&h, &m, &sec);
get_event_start_time(fe, &start_time);
get_event_end_time(fe, &end_time);
convert_time_by_offset(&start_time, &start_time, h, m);
convert_time_by_offset(&end_time, &end_time, h, m);
sprintf(string, "%02d:%02d~%02d:%02d ", start_time.hour, start_time.min, \
end_time.hour, end_time.min);
ComAscStr2Uni(string, display_strs[25]);
ComUniStrCopyChar((UINT8*) &display_strs[26][0], s2);
}
else
{
MEMSET(string, 0, sizeof(string));
sprintf(string, " ");
ComAscStr2Uni(string, (UINT16*)display_strs[25]);
ComAscStr2Uni(string, (UINT16*)display_strs[26]);
}
return 0;
}
static PRESULT favgrplst_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
PRESULT ret = PROC_PASS;
switch(event)
{
case EVN_PRE_OPEN:
#ifdef EXIT_KEY_EXIT_ALL_MENU
exit_key_flag = FALSE;
#endif
#ifdef PREVIEW_SUBMENU
#if 1//def OSD_BLACKBERRY
api_full_screen_play();
//mm_enter_stop_mode(FALSE);
if(RADIO_CHAN==sys_data_get_cur_chan_mode())
{
//api_show_menu_logo();
api_play_channel(get_prog_pos(play_chan_id), TRUE, TRUE/*edit_group== NOMAL_GRP*/,FALSE);
}
#else
api_full_screen_play();
mm_enter_stop_mode(FALSE);
api_show_menu_logo();
#endif
if((param2 & MENU_OPEN_TYPE_MASK) == MENU_OPEN_TYPE_OTHER)
preview_menu=1;
else
preview_menu=0;
#endif
wincom_open_subtitle(pObj,RS_FAVORITE,0);
break;
case EVN_POST_OPEN:
#if ((defined(OSD_BLACKBERRY))||(defined(OSD_GOLDENMEDIA))||(defined(OSD_OCEANBLUE))||(defined(OSD_15))||(defined(OSD_12)))
wincom_open_commen_help(pObj);
//wincom_open_help(pObj,fav_group_helpinfo, HELP_CNT);
#else
//wincom_open_commen_help(pObj);
wincom_open_help(pObj,fav_group_helpinfo, HELP_CNT);
#endif
break;
case EVN_PRE_CLOSE:
/* Make OSD not flickering */
*((UINT32*)param2) &= ~C_CLOSE_CLRBACK_FLG;
sys_data_save(1);
break;
case EVN_POST_CLOSE:
wincom_close_subtitle();
//OSD_ClearObject((POBJECT_HEAD)&g_win_favgrplst,C_UPDATE_ALL);//albert.li add
//OSD_TrackObject( (POBJECT_HEAD) &g_win_submenu/*g_win_mainmenu*/, C_UPDATE_ALL);//albert.li
#ifdef EXIT_KEY_EXIT_ALL_MENU
if( exit_key_flag == TRUE)
{
exit_key_flag =FALSE;
mm_leave_all_menu();
}
#endif
break;
}
return ret;
}
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;
}
}
BOOL win_timerset_open(TIMER_SET_CONTENT* settimer,TIMER_SET_CONTENT* rettimer,BOOL check_starttime)
{
POBJECT_HEAD pObj = (POBJECT_HEAD)&g_win_timerset;
PRESULT bResult = PROC_LOOP;
UINT32 hkey;
UINT8 cur_mode,mode;
UINT8 group_idx;
date_time dt,dt1;
BOOL old_value = ap_enable_key_task_get_key(TRUE);
sys_data_check_channel_groups();
cur_mode = sys_data_get_cur_chan_mode();
group_idx = sys_data_get_cur_group_index();
timer_set_ok_cancel_flag = 0;
MEMSET(&timer_set,0,sizeof(TIMER_SET_CONTENT));
if(settimer != NULL)
MEMCPY(&timer_set,settimer,sizeof(TIMER_SET_CONTENT));
if(timer_set.timer_mode != TIMER_MODE_OFF
&& timer_set.timer_service !=TIMER_SERVICE_MESSAGE)
{
if(timer_set.wakeup_chan_mode>1)
timer_set.wakeup_chan_mode = 1;
mode = timer_set.wakeup_chan_mode;
}
else
{
mode = cur_mode;
timer_set.wakeup_chan_mode = cur_mode;
}
if(timer_set.timer_mode == TIMER_MODE_OFF)
{
timer_set_modify_add_flag = TIMER_ADD;
timer_set_check_starttime_flag = 1;
}
else
{
timer_set_modify_add_flag = TIMER_MODIFY;
timer_set_check_starttime_flag = 1;
}
get_local_time(&dt1);
dt1.min = dt1.min/10*10;
dt1.sec = 0;
convert_time_by_offset(&dt,&dt1,0,10);
if(timer_set_modify_add_flag == TIMER_ADD)
{
timer_set.wakeup_year = dt.year;
timer_set.wakeup_month = dt.month;
timer_set.wakeup_day = dt.day;
timer_set.wakeup_time = dt.hour * 60 + dt.min;
timer_set.wakeup_state = TIMER_STATE_READY;
}
if(timer_set.timer_service == TIMER_SERVICE_MESSAGE)
timer_set.wakeup_duration_time = 0;
sys_data_set_cur_chan_mode(mode);
sys_data_change_group(0);
OSD_SetContainerFocus(&g_win_timerset, TIMER_MODE_ID);
OSD_ObjOpen(pObj, MENU_OPEN_TYPE_OTHER);
while(bResult != PROC_LEAVE)
{
hkey = ap_get_key_msg();
if(hkey == INVALID_HK || hkey == INVALID_MSG)
{
win_timerset_set_currenttime(TRUE);
continue;
}
bResult = OSD_ObjProc(pObj, (MSG_TYPE_KEY<<16),hkey, 0);
}
if(timer_set_ok_cancel_flag)
MEMCPY(rettimer,&timer_set,sizeof(TIMER_SET_CONTENT));
sys_data_set_cur_chan_mode(cur_mode);
sys_data_change_group(group_idx);
sys_data_save(1);
ap_enable_key_task_get_key(old_value);
return timer_set_ok_cancel_flag;
}
/**************************************************************
*CAS Main message process entry.
*msg_code has different meaning for different msg_type, check the
*tf_catask.c for detailed info.
**************************************************************/
PRESULT ap_cas_smc_info_proc( UINT32 msg_type, UINT32 msg_code)
{
cas_sc_t card_info;
UINT16 cur_chan = 0;
UINT8 scramble = 0;
P_NODE p_node;
POBJECT_HEAD p_top_menu = NULL,p_newtop_menu=NULL;
PRESULT ret;
p_top_menu = menu_stack_get_top();
if(p_top_menu == (POBJECT_HEAD)&g_win_cti_cardinfo
|| p_top_menu == (POBJECT_HEAD)&g_win_cti_set_maturity
|| p_top_menu == (POBJECT_HEAD)&g_win_cti_PPID
|| p_top_menu == (POBJECT_HEAD)&g_win_cti_PPID_info
|| p_top_menu == (POBJECT_HEAD)&g_win_cti_pin)
{
ret = OSD_ObjProc(p_top_menu, (MSG_TYPE_MSG << 16) | msg_type, msg_code, 0);
while( ret == PROC_LEAVE)
{
menu_stack_pop();
p_newtop_menu = menu_stack_get_top();
if(NULL != p_newtop_menu)
{
ret = OSD_ObjOpen(p_newtop_menu, MENU_OPEN_TYPE_STACK) ;
}
}
}
cas_get_sc_info_req(&card_info);
sys_data_get_cur_group_channel(&cur_chan, sys_data_get_cur_chan_mode());
get_prog_at(cur_chan, &p_node);
//get_prog_scramble_type(p_node.prog_number, &scramble);
if(card_info.sc_status==0) //smart card ok
{
//win_popup_msg("Smartcart is in!",NULL,0);
}
else if(card_info.sc_status==1) //smart card out
{
if(GetScrollStopFlag()!=SCROLL_STOP)
{
SetScrollStopFlag(SCROLL_STOP);
}
cas_sub_clear();
subtitle_clear_all_message(); //clean subtitle msg buffer when the card is out.
ap_cas_fingerprint_proc(3);// to clear finger print buf and area
if( p_top_menu == (POBJECT_HEAD)&g_win_ippv_popup)
{
OSD_ClearObject((POBJECT_HEAD)&g_win_ippv_popup, C_UPDATE_ALL);
menu_stack_pop();
}
//win_popup_msg("Smartcart is out!",NULL,0);
}
else if(card_info.sc_status==2||card_info.sc_status==3)
{
//win_popup_msg(NULL,NULL,RS_CTI_READ_SMC_ERROR);
}
}
static PRESULT factoryset_btn_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
PRESULT ret = PROC_PASS;
VACTION unact;
UINT8 bID,back_saved;
S_NODE s_node;
P_NODE p_node;
T_NODE t_node;
bID = OSD_GetObjID(pObj);
INT16 i=0;
INT16 n =0;
UINT16 prog_num =0;
UINT8 av_flag = 0;
switch(event)
{
case EVN_UNKNOWN_ACTION:
unact = (VACTION)(param1>>16);
if(unact == VACT_ENTER)
{
switch(bID)
{
case IDC_CON1:
win_compopup_init(WIN_POPUP_TYPE_SMSG);
win_compopup_set_msg(NULL,NULL, RS_MSG_SAVING_DATA);
win_compopup_open_ext(&back_saved);
osal_task_sleep(1500);
si_monitor_off(0xFFFFFFFF);
n = get_sat_num(VIEW_ALL);
recreate_prog_view(VIEW_ALL | PROG_TV_MODE,0);
for(i=0;i<n;i++)
{
get_sat_at(i, VIEW_ALL,&s_node);
del_child_prog(TYPE_SAT_NODE, s_node.sat_id);
}
update_data();
sys_data_check_channel_groups();
win_compopup_smsg_restoreback();
break;
case IDC_CON2:
win_compopup_init(WIN_POPUP_TYPE_SMSG);
win_compopup_set_msg(NULL,NULL, RS_MSG_SAVING_DATA);
win_compopup_open_ext(&back_saved);
osal_task_sleep(1500);
si_monitor_off(0xFFFFFFFF);
n = get_sat_num(VIEW_ALL);
recreate_prog_view(VIEW_ALL | PROG_RADIO_MODE,0);
for(i=0;i<n;i++)
{
get_sat_at(i, VIEW_ALL,&s_node);
del_child_prog(TYPE_SAT_NODE, s_node.sat_id);
}
update_data();
sys_data_check_channel_groups();
win_compopup_smsg_restoreback();
break;
case IDC_CON3:
win_compopup_init(WIN_POPUP_TYPE_SMSG);
win_compopup_set_msg(NULL,NULL, RS_MSG_SAVING_DATA);
win_compopup_open_ext(&back_saved);
osal_task_sleep(1500);
sort_prog_node(PROG_FTA_SORT);
av_flag = sys_data_get_cur_chan_mode();
prog_num = get_prog_num(VIEW_ALL | av_flag, 0);
libc_printf("prog_num11111111==%d\n",prog_num);
for(i=prog_num-1;i>=0;i--)
{
get_prog_at(i,&p_node);
get_tp_by_id(p_node.tp_id, &t_node);
get_sat_by_id(t_node.sat_id, &s_node);
if(p_node.ca_mode == 0)
{
libc_printf("iiiiiiiiiiiiiiiiii====%d\n",i);
del_prog_at((UINT16)i);
}
}
update_data();
sys_data_check_channel_groups();
win_compopup_smsg_restoreback();
break;
case IDC_CON4:
win_compopup_init(WIN_POPUP_TYPE_SMSG);
win_compopup_set_msg(NULL,NULL, RS_MSG_SAVING_DATA);
win_compopup_open_ext(&back_saved);
osal_task_sleep(1500);
sort_prog_node(PROG_FTA_SORT_EXT);
av_flag = sys_data_get_cur_chan_mode();
prog_num = get_prog_num(VIEW_ALL | av_flag, 0);
libc_printf("prog_num222222222==%d\n",prog_num);
for(i=prog_num-1;i>=0;i--)
{
get_prog_at(i,&p_node);
get_tp_by_id(p_node.tp_id, &t_node);
get_sat_by_id(t_node.sat_id, &s_node);
if(p_node.ca_mode)
{
libc_printf("i===============%d\n",i);
del_prog_at((UINT16)i);
}
}
update_data();
sys_data_check_channel_groups();
win_compopup_smsg_restoreback();
break;
default:
break;
}
}
break;
}
return ret;
}
