static INT32 as_select_nim(S_NODE *snode)
{
INT32 res = SUCCESS;
UINT8 nim_id = 0; //0 or 1
if(snode->tuner1_valid == 1)
{
nim_id = 0;
tsi_select(TSI_DMX_0, ts_route_get_nim_tsiid(nim_id));
as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id);
}
else if(snode->tuner2_valid == 1)
{
nim_id = 1;
tsi_select(TSI_DMX_0, ts_route_get_nim_tsiid(nim_id));
as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id);
}
else
{
nim_id = 0;
as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id);
return res;
}
return res;
}
static void pcm_play_demo(void)
{
struct deca_feature_config deca_config;
struct snd_feature_config snd_config;
UINT32 i, j;
struct pcm_output pcm;
INT32 *p_pcm_sp;
g_decv_dev = dev_get_by_id(HLD_DEV_TYPE_DECV, 0);
g_deca_dev = dev_get_by_id(HLD_DEV_TYPE_DECA, 0);
if (RET_SUCCESS != deca_open(g_deca_dev, 0, 0, 0, 0, 0))
{
PRINTF("deca_open failed!!\n");
ASSERT(0);
}
if (RET_SUCCESS != snd_open(g_snd_dev))
{
PRINTF("snd_open failed!!\n");
ASSERT(0);
}
MEMSET(&pcm, 0, sizeof(struct pcm_output));
pcm.ch_num = 2;
pcm.ch_mod = DUAL_CHANNEL;
pcm.ch_left = pcm_left_ch;
pcm.ch_right = pcm_right_ch;
pcm.samp_num = 1152;
snd_set_spdif_type(g_snd_dev, SND_OUT_SPDIF_PCM);
snd_set_volume(g_snd_dev, SND_SUB_OUT, 100);
snd_set_duplicate(g_snd_dev, SND_DUP_NONE);
/*assumes PCM data is in address __MM_AUDIO_PATTERN_ADDR, 400*4608 samples,
Preset PCM sample rate is 48000, each sample occupy 1 double word (32 bits)*/
while (1)
{
p_pcm_sp = (INT32 *)__MM_AUDIO_PATTERN_ADDR;
for (i = 0;i < PCM_FRM_NUM;i++)
{
for (j = 0;j < pcm.samp_num;j++)
{
/*for dual channel mode, 2 channels should have different samples,
herel fills the same samples to 2 channels for demo.
If only have 1 channel PCM, you can only fill 1 channel (left or right), but you should call
snd_set_duplicate(g_snd_dev, SND_DUP_L); or snd_set_duplicate(g_snd_dev, SND_DUP_R);
before play.*/
pcm_left_ch[j] = (*p_pcm_sp) << 5;
pcm_right_ch[j] = (*p_pcm_sp) << 5;
p_pcm_sp++;
}
libc_demo_pcm_output(&pcm);
}
}
}
struct osd_device* lib_subt_atsc_get_osd_handle(void)
{
#ifdef SHOW_BY_CPU
struct osd_device* ret = (struct osd_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, 1);
#else
struct osd_device* ret = (struct osd_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, g_subt_config_par.osd_layer_id);
#endif
//struct osd_device* ret = (struct osd_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, 0);
return ret;
}
static INT32 pic_gif_draw(gif_file fh, struct OSDRect *rect, BOOL animation)
{
struct gif_dec_par par;
struct ge_device* ge_dev;
ge_dev = (struct ge_device *)dev_get_by_id(HLD_DEV_TYPE_GE, 0);
if (ge_dev == NULL)
{
AD_GIF_PRINTF("%s() ge device find failed!\n", __FUNCTION__);
return !SUCCESS;
}
#ifdef DUAL_ENABLE
struct osd_device* osd_dev;
osd_dev = (struct ge_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, 0);
if (osd_dev == NULL)
{
AD_GIF_PRINTF("%s() osd device find failed!\n", __FUNCTION__);
return !SUCCESS;
}
#endif
//if (SUCCESS != ad_gif_file_add(fh))
// return !SUCCESS;
//gif_file_init(fh, file, file_len);
if (animation)
gif_io_ctrl(gif, GIF_IO_CMD_DEC_FIRST_PIC, GIF_FALSE);
else
gif_io_ctrl(gif, GIF_IO_CMD_DEC_FIRST_PIC, GIF_TRUE);
MEMSET((void *)&par, 0, sizeof(struct gif_dec_par));
par.in_par.file = fh;
par.in_par.fread_callback = gif_read_data;
par.in_par.fseek_callback = gif_seek_data;
par.in_par.ftell_callback = gif_tell_pos;
par.out_par.dev = (gif_ge_dev)ge_dev;
#ifdef DUAL_ENABLE
par.out_par.dev = (gif_ge_dev)osd_dev;
#endif
par.out_par.handle = 0;//(gif_surface_handle)ad_get_ge_surface(AD_DST_SURFACE);
par.out_par.region = 0;
par.out_par.pos.x = rect->uLeft;
par.out_par.pos.y = rect->uTop;
par.out_par.area.x = par.out_par.area.y = 0;
par.out_par.area.w = rect->uWidth;
par.out_par.area.h = rect->uHeight;
gif_dec(gif, &par);
return SUCCESS;
}
void sys_data_set_display_mode(AV_Set *av_set)
{
enum TVMode eTVAspect;
enum DisplayMode e169DisplayMode;
if (av_set->tv_ratio == TV_ASPECT_RATIO_169)
eTVAspect = TV_16_9;
else
// if(av_set->tv_ratio==TV_ASPECT_RATIO_43)
eTVAspect = TV_4_3;
if (av_set->tv_ratio == TV_ASPECT_RATIO_AUTO)
e169DisplayMode = NORMAL_SCALE;
else if (av_set->display_mode == DISPLAY_MODE_LETTERBOX)
e169DisplayMode = LETTERBOX;
else if (av_set->display_mode == DISPLAY_MODE_PANSCAN)
e169DisplayMode = PANSCAN;
else
e169DisplayMode = NORMAL_SCALE;
//if(eTVAspect == TV_16_9)
if (av_set->tv_ratio == TV_ASPECT_RATIO_169)
e169DisplayMode = PILLBOX;
vpo_aspect_mode((struct vpo_device*)dev_get_by_id(HLD_DEV_TYPE_DIS, 0), \
eTVAspect, e169DisplayMode);
}
/**********************************************
* enter usb logo test from here by ui
*
*********************************************/
RET_CODE usb_test_enter()
{
struct usb_hc_device *hc_dev = (struct usb_hc_device *)dev_get_by_type(NULL,HLD_DEV_TYPE_USB_HOST);
if (hc_dev->usbd_flg_id != NULL)
{
usbd_notify_dynamic_removerd(hc_dev);
enable_usb_intf_int(hc_dev->base_addr,0);
en_host_int_flag1(hc_dev->base_addr,0);
en_host_int_flag2(hc_dev->base_addr,0);
en_host_int_flag3(hc_dev->base_addr,0);
// hc_dev->bdev_callback(0);
// hc_dev->usb_dev->release(hc_dev->usb_dev);
// hc_dev->usb_dev = NULL;
}
if(sys_ic_get_chip_id() == ALI_S3602F)
{
if(0!=(hc_dev= (pUSBD_BUS)dev_get_by_id(HLD_DEV_TYPE_USB_HOST, 1)))
{
usbd_notify_dynamic_removerd(hc_dev);
enable_usb_intf_int(hc_dev->base_addr,0);
en_host_int_flag1(hc_dev->base_addr,0);
en_host_int_flag2(hc_dev->base_addr,0);
en_host_int_flag3(hc_dev->base_addr,0);
}
}
osal_task_sleep(1);
usb_if_test_flag = IF_TEST_ENTER;
return RET_SUCCESS ;
}
void win_otaset_turn_frntend(void)
{
UINT8 back_saved;
S_NODE s_node;
T_NODE t_node;
struct nim_device *nim;
union ft_xpond xpond;
nim = dev_get_by_id(HLD_DEV_TYPE_NIM, 0);
t_node.frq = ota_freq;
t_node.sym = ota_symb;
t_node.pol = ota_pol;
t_node.FEC_inner = ota_modulation;
MEMCPY(&m_ota_cfg.t_node, &t_node, sizeof(t_node));
m_ota_cfg.pid = ota_pid;
win_otaset_get_FreqSymbPid_display();
if(NULL != nim)
{
MEMSET(&xpond, 0, sizeof(xpond));
xpond.c_info.type = FRONTEND_TYPE_C;
xpond.c_info.frq = ota_freq;
xpond.c_info.sym = ota_symb;
xpond.c_info.modulation = ota_modulation;
//frontend_set_nim(nim, NULL, &xpond, 1);
frontend_tuning(nim, NULL, &xpond, 1);
}
RET_CODE sys_get_host_key(UINT8 *key, UINT32 *len, UINT32 type)
{
unsigned long addr;
CIPLUS_KEY_HDR hdr;
UINT8 aes_key[16];
UINT8 *encryped_data;
struct sto_device *dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0);
libc_printf("%s - type %d\n",__FUNCTION__,type);
if(RET_SUCCESS != find_key(CIPLUS_KEY_AES_KEY, &addr, &hdr))
return RET_FAILURE;
sto_get_data(dev, aes_key, addr, 16);
if(RET_SUCCESS != find_key(type, &addr, &hdr))
return RET_FAILURE;
encryped_data = (UINT8 *)MALLOC(hdr.size);
//encryped_data = g_ci_tmp_buff;
sto_get_data(dev, encryped_data, addr, hdr.size);
decrypt_key(encryped_data, key, aes_key, hdr.size);
if(len)
*len = hdr.size;
FREE(encryped_data);
return RET_SUCCESS;
}
static void pic_gif_init(void)
{
struct osd_device *osd_layer2_dev;
struct gif_cfg init;
osd_layer2_dev =(struct osd_device*)dev_get_by_id(HLD_DEV_TYPE_OSD, 0);
if (osd_layer2_dev == NULL)
{
AD_GIF_PRINTF("%s() OSD_layer2 is not be opened!\n", __FUNCTION__);
}
else
{
OSDDrv_Close((HANDLE)osd_layer2_dev);
AD_GIF_PRINTF("%s() OSD_layer2 is closed!\n", __FUNCTION__);
}
#ifdef DUAL_ENABLE
osd_output_init();
#endif
MEMSET((void *)&init,0,sizeof(struct gif_cfg));
init.bit_buf_start = (UINT8 *)((__MM_MP_BUFFER_ADDR +0x800000)& ~(7<<28));//(UINT8 *)(GIF_BIT_BUF& ~(7<<28));//
init.bit_buf_size = 0x200000;//GIF_BIT_SIZE;//
init.dec_buf_start = (UINT8 *)((__MM_MP_BUFFER_ADDR +0xa00000)& ~(7<<28));//(UINT8 *)(GIF_DEC_BUF& ~(7<<28));//
init.dec_buf_size = (__MM_PVR_VOB_BUFFER_LEN -0xa00000 );//GIF_DEC_SIZE;//__MM_PVR_VOB_BUFFER_ADDR
init.fread_callback = gif_read_data;
init.fseek_callback = gif_seek_data;
init.ftell_callback = gif_tell_pos;
init.max_width = 800; //400;
init.max_height = 600; //300;
gif_init(&init);
//gif_list_init();
gif = gif_open();
}
static void ca_info_displayinfo(unsigned char CardSlot)
{
UINT8 i=0;
//mcas_card_t stcard_info;
#if 1
McasDisplayStrByCardSlot(CardSlot);/*---added by vachel--*/
#else
mcas_card_get_info((struct smc_device *)dev_get_by_id(HLD_DEV_TYPE_SMC, 0),&stcard_info);
switch(stcard_info.ca_system_id)
{
case CAS_SYS_CONAX:
{
Conax_Info_t *pstConax_info;
pstConax_info = &conax;
ca_info_text_display("Conax card",pstConax_info->iCardNumber,pstConax_info->stParam.MatRat,\
NULL,NULL);
}
break;
case CAS_SYS_SECA:
case CAS_SYS_VIACCESS:
case CAS_SYS_IRDETO:
case CAS_SYS_BISS:
break;
default://Unknown card
break;
}
#endif
}
static INT8 stb_hwinfo_load(STB_HWINFO *hwinfo)
{
INT8 ret = 0, i;
UINT32 check_data;
UINT8 data[STB_HWINFO_LEN];
BOOL old2new = FALSE;
struct sto_device *sto = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0);
if(NULL == sto)
{
ret = -1;
goto RETURN;
}
MEMSET(data,0,STB_HWINFO_LEN);
sto_get_data(sto, data, STB_HWINFO_BASE_ADDR, sizeof(STB_HWINFO));
#if 0
check_data = ((data[0]<<24) |(data[1]<<16) |(data[2]<<8) |(data[3]));
if(check_data == 0xffffffff)
{
ret = -1;
goto RETURN;
}
#endif
MEMCPY(hwinfo, data, sizeof(STB_HWINFO));
//libc_printf("load oui = %d, hwmode = %d, hwversion = %d\n", hwinfo->stb_oui, hwinfo->stb_hw_model, hwinfo->stb_hw_version);
RETURN:
return ret;
}
static UINT8 gyca_writemaill_all_to_flash(UINT32 addr, UINT32 mail_head_size)
{
struct sto_device *flash_dev = NULL;
UINT32 mailaddr;
mailaddr=addr + mail_head_size;
//flash_dev = (struct sto_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_STO);
flash_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0);
if(NULL == flash_dev)
{
GYCAS_PRINTF("gyca_writemaill_all_to_flash: dev_get_by_name failed!\n");
return 1;
}
if(gyca_delmail_all_from_flash(addr)!= 0)
return 2;
gyca_write_flash_mail_head(addr);
gyca_mutex_lock();
if(sizeof(gycamail)*GYCA_EMAIL_MAX_CNT != sto_put_data(flash_dev, mailaddr, flashbuf, sizeof(gycamail)*GYCA_EMAIL_MAX_CNT))
{
gyca_mutex_unlock();
GYCAS_PRINTF("%s: sto_put_data failed!\n", __FUNCTION__);
return 3;
}
gyca_mutex_unlock();
return 0;
}
static void config_deo_frm_buf(void)
{
struct vpo_device *gpvpo_sd;
Imagedec_frm deo_frm_buf[4];
gpvpo_sd = gpvpo_sd = (struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 1);
if(NULL != gpvpo_sd)
{
deo_frm_buf[0].frm_y_addr = (UINT8 *)__MM_FB3_Y_START_ADDR;
deo_frm_buf[0].frm_y_len = __MM_FB3_Y_LEN;
deo_frm_buf[0].frm_c_addr = (UINT8 *)__MM_FB3_C_START_ADDR;
deo_frm_buf[0].frm_c_len = __MM_FB3_C_LEN;
deo_frm_buf[0].busy = 0;
deo_frm_buf[1].frm_y_addr = (UINT8 *)__MM_FB4_Y_START_ADDR;
deo_frm_buf[1].frm_y_len = __MM_FB4_Y_LEN;
deo_frm_buf[1].frm_c_addr = (UINT8 *)__MM_FB4_C_START_ADDR;
deo_frm_buf[1].frm_c_len = __MM_FB4_C_LEN;
deo_frm_buf[1].busy = 0;
deo_frm_buf[2].frm_y_addr = (UINT8 *)__MM_FB5_Y_START_ADDR;
deo_frm_buf[2].frm_y_len = __MM_FB5_Y_LEN;
deo_frm_buf[2].frm_c_addr = (UINT8 *)__MM_FB5_C_START_ADDR;
deo_frm_buf[2].frm_c_len = __MM_FB5_C_LEN;
deo_frm_buf[2].busy = 0;
deo_frm_buf[3].frm_y_addr = (UINT8 *)__MM_FB6_Y_START_ADDR;
deo_frm_buf[3].frm_y_len = __MM_FB6_Y_LEN;
deo_frm_buf[3].frm_c_addr = (UINT8 *)__MM_FB6_C_START_ADDR;
deo_frm_buf[3].frm_c_len = __MM_FB6_C_LEN;
deo_frm_buf[3].busy = 0;
imagedec_ioctl(1, IMAGEDEC_IO_CMD_CFG_DEO_FRM, (UINT32)(&deo_frm_buf));
}
}
static UINT8 gyca_check_flash_mail_head(UINT32 addr)
{
struct sto_device *flash_dev = NULL;
UINT32 mailaddr = addr;
UINT8 mail_head[GYCA_MAIL_HEAD_SIZE];
//flash_dev = (struct sto_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_STO);
flash_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0);
if(NULL == flash_dev)
{
GYCAS_PRINTF("%s: dev_get_by_name failed!\n", __FUNCTION__);
return 1;
}
//if (SUCCESS != flash_dev->get_data(flash_dev, mail_head, mailaddr, GYCA_MAIL_HEAD_SIZE))
if (GYCA_MAIL_HEAD_SIZE != sto_get_data(flash_dev, mail_head, mailaddr, GYCA_MAIL_HEAD_SIZE))
{
GYCAS_PRINTF("%s: sto_get_data failed!\n", __FUNCTION__);
return 2;
}
gyca_mutex_lock();
if(MEMCMP(mail_head,gyca_mail_head, GYCA_MAIL_HEAD_SIZE))
{
gyca_mutex_unlock();
return 3;
}
gyca_mutex_unlock();
return 0;
}
static int GetLock(unsigned int argc, unsigned char *argv[])
{
INT32 ret;
UINT8 lock;
if (argc != 1)
{
SH_PRINTF("Usage: GetLock\n");
return -1;
}
struct nim_device *nim_dev = dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id);
if ((ret = nim_get_lock(nim_dev, &lock)) != SUCCESS)
{
SH_PRINTF("api_nim_get_lock: operation error! %d\n", ret);
return -1;
}
//LIB_ASH_OC('\r');
//LIB_ASH_OC('\n');
if(!lock)
{
LIB_ASH_OC('U');
LIB_ASH_OC('N');
}
LIB_ASH_OC('L');
LIB_ASH_OC('O');
LIB_ASH_OC('C');
LIB_ASH_OC('K');
LIB_ASH_OC('\r');
LIB_ASH_OC('\n');
}
static void osd_output_init(void)
{
struct osd_device *osd_dev;
UINT32 region_id =0;
UINT32 trans_color;
struct OSDRect region_rect;
struct OSDPara OpenPara;
UINT8 *p_pallette;
region_rect.uLeft = 0;
region_rect.uTop = 0;
region_rect.uWidth = 800;//OSD_MAX_WIDTH;//608;
region_rect.uHeight = 500;//OSD_MAX_HEIGHT;//430;
OpenPara.eMode = OSD_256_COLOR;
OpenPara.uGAlpha = 0x0f;
OpenPara.uGAlphaEnable = 0;
OpenPara.uPalletteSel = 0;
osd_dev = (struct osd_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, 0);
OSDDrv_Open((HANDLE)osd_dev, &OpenPara);
osal_task_sleep(20);
//trans_color = OSD_GetTransColor(OpenPara.eMode,FALSE);
OSDDrv_IoCtl((HANDLE)osd_dev, OSD_IO_SET_TRANS_COLOR, 0x00);
OSDDrv_CreateRegion((HANDLE)osd_dev, region_id, ®ion_rect, NULL);
//p_pallette = OSD_GetRscPallette(0x4080 | 0);
//OSD_SetPallette(p_pallette,256);
//OSDDrv_RegionFill((HANDLE)osd_dev,region_id,®ion_rect,0xff);
//OSDDrv_ShowOnOff((HANDLE)osd_dev, TRUE);
}
/*
* Class: com_dvb_DvbSystemSetting
* Method: setAspect
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL Java_DvbSystemSetting_setAspect
(JNIEnv *env, jclass cls, jint value) {
LOGD("%s,%d value = %d ",__FUNCTION__,__LINE__, value);
enum TVMode eTVAspect;
enum DisplayMode e169DisplayMode;
if (value == 2) {
eTVAspect = TV_16_9;
e169DisplayMode = NORMAL_SCALE;
}
else if( value == 1 ) {
e169DisplayMode = VERTICALCUT;
eTVAspect = TV_4_3;
}
else {
e169DisplayMode = PILLBOX;
eTVAspect = TV_4_3;
}
if(vpo_aspect_mode( (struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 0), eTVAspect, e169DisplayMode) == 0)
return 1;
else
return 0;
}
static int GetPER(unsigned int argc, unsigned char *argv[])
{
INT32 ret;
UINT32 per;
if (argc != 1)
{
SH_PRINTF("Usage: GetPER\n");
return -1;
}
struct nim_device *nim_dev = dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id);
if ((ret = nim_io_control(nim_dev, NIM_DRIVER_READ_RSUB, &per)) != SUCCESS)
{
if(ret != ERR_TIME_OUT)
{
SH_PRINTF("api_nim_get_PER: operation error! %d\n", ret);
return -1;
}
else
{
per = 0;
}
}
//LIB_ASH_OC('\r');
//LIB_ASH_OC('\n');
IntPrintf(per);
LIB_ASH_OC('\r');
LIB_ASH_OC('\n');
}
static int GetBER(unsigned int argc, unsigned char *argv[])
{
INT32 ret;
UINT32 ber;
if (argc != 1)
{
SH_PRINTF("Usage: GetBER\n");
return -1;
}
struct nim_device *nim_dev = dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id);
if ((ret = nim_get_BER(nim_dev, &ber)) != SUCCESS)
{
SH_PRINTF("api_nim_get_BER: operation error! %d\n", ret);
return -1;
}
//LIB_ASH_OC('\r');
//LIB_ASH_OC('\n');
IntPrintf(ber);
LIB_ASH_OC('\r');
LIB_ASH_OC('\n');
}
void ap_osd_layer2_init()
{
UINT8 *p_pallette;
struct OSDPara tOpenPara;
struct OSDRect region1, region2, rc1, rc2;
cas_osd_dev = (struct osd_device*)dev_get_by_id(HLD_DEV_TYPE_OSD, 0);
tOpenPara.eMode = OSD_256_COLOR;
tOpenPara.uGAlphaEnable = 0;
tOpenPara.uGAlpha = 0x0F;
tOpenPara.uPalletteSel = 0;
OSDDrv_Open((HANDLE)cas_osd_dev, &tOpenPara);
osal_task_sleep(20);
OSDDrv_IoCtl((HANDLE)cas_osd_dev, OSD_IO_SET_TRANS_COLOR, OSD_TRANSPARENT_COLOR);
//create region for bottom osd msg
region2.uLeft = 0;
region2.uTop = 530;
region2.uWidth = 720;
region2.uHeight = 28;
rc2.uLeft = 0;
rc2.uTop = 0;
rc2.uWidth = region2.uWidth;
rc2.uHeight = region2.uHeight;
OSDDrv_CreateRegion((HANDLE)cas_osd_dev, OSDMSG_REGION_BTM, ®ion2, NULL);
p_pallette = OSD_GetRscPallette(0x4080 | 0);
OSDDrv_SetPallette((HANDLE)cas_osd_dev, p_pallette, COLOR_N, OSDDRV_YCBCR);
OSDDrv_RegionFill((HANDLE)cas_osd_dev,OSDMSG_REGION_BTM,&rc2,OSD_TRANSPARENT_COLOR);
OSDDrv_ShowOnOff((HANDLE)cas_osd_dev,OSDDRV_ON);
}
/*
* Class: com_dvb_DvbSystemSetting
* Method: setBrightness
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL Java_DvbSystemSetting_setBrightness
(JNIEnv *env, jclass cls, jint value) {
LOGD("%s,%d value = %d ",__FUNCTION__,__LINE__, value);
struct vpo_io_video_enhance vp_ve_par;
struct vpo_device * vp_dev;
vp_dev= (struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 0);
if(value > 100)
value = 100;
else if(value < 0)
value =50;
vp_ve_par.grade=value ;//42+2*value;
vp_ve_par.changed_flag=VPO_IO_SET_ENHANCE_BRIGHTNESS;
if(NULL==vp_dev)
{
return 0;
}
else if( vpo_ioctl(vp_dev,VPO_IO_VIDEO_ENHANCE, (UINT32)&vp_ve_par) == 0)
{
return 1;
}
else
return 0;
}
BOOL keyupg_burnflash(UINT32 chunk_id, char *buffer_adr,UINT32 buffer_size)
{
UINT32 chunk_len,chunk_addr;
UINT32 param;
struct sto_device *f_dev;
UINT32 sector_count=0;
api_get_chuck_addlen(chunk_id, &chunk_addr, &chunk_len);//chunk_addr is the real data addr not include header
if ((f_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0)) == NULL)
{
libc_printf("ERROR: Not found Flash device!\n");
return FALSE;
}
if(chunk_id==HDCPKEY_CHUNK_ID)
{
//hdcp key,need rewrite bootloader
UINT8 *bootloader_sector = NULL;
CHUNK_HEADER bloader_chuck_hdr;
sto_get_chunk_header(BLOADER_CHUNK_ID,&bloader_chuck_hdr);
bootloader_sector = (UINT8 *)MALLOC(sizeof(UINT8)*(bloader_chuck_hdr.offset));
sto_lseek(f_dev, 0x00, STO_LSEEK_SET);
sto_read(f_dev, bootloader_sector, bloader_chuck_hdr.offset);
/*
param = 0x00;
param = param << 10;
param +=( (SECTOR_SIZE*(bloader_chuck_hdr.offset/SECTOR_SIZE+1)) >> 10);
sto_io_control(f_dev, STO_DRIVER_SECTOR_ERASE, param);
*/
for(sector_count=0;sector_count< ((bloader_chuck_hdr.offset-1)/SECTOR_SIZE+1);sector_count++)
{
param = 0x00+sector_count*SECTOR_SIZE;
param = param << 10; /* Lower 10 bits of LSB is length in K bytes*/
param += SECTOR_SIZE >> 10;
sto_io_control(f_dev, STO_DRIVER_SECTOR_ERASE_EXT, param);
}
sto_lseek(f_dev, 0x00, STO_LSEEK_SET);
sto_write(f_dev, bootloader_sector, bloader_chuck_hdr.offset);
CHUNK_HEADER hdcp_chuck_hdr;
//sto_get_chunk_header(chunk_id,&hdcp_chuck_hdr);
hdcp_chuck_hdr.id = data_change_for_sto(chunk_id);
hdcp_chuck_hdr.len = data_change_for_sto(buffer_size);
hdcp_chuck_hdr.offset = data_change_for_sto(0x200);
hdcp_chuck_hdr.crc = data_change_for_sto(0x4e435243);
strcpy(hdcp_chuck_hdr.name,"HDCPKey");
strcpy(hdcp_chuck_hdr.version,"Encrypted");
strcpy(hdcp_chuck_hdr.time,"2010.09.01");
sto_write(f_dev,&hdcp_chuck_hdr,sizeof(CHUNK_HEADER));
sto_write(f_dev,buffer_adr, buffer_size);
FREE(bootloader_sector);
}
//for tuner to select the nim device
static INT32 as_select_nim(S_NODE *snode)
{
INT32 res = SUCCESS;
if(2 > lib_nimng_get_lnb_ns())
{
#ifdef SYS_TS_INPUT_INTERFACE
tsi_select(TSI_DMX_0, SYS_TS_INPUT_INTERFACE);
#else
tsi_select(TSI_DMX_0, TSI_SPI_0);
#endif
as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, 0);
return res;
}
if(snode->tuner1_valid == 1)
{
#ifdef SYS_TS_INPUT_INTERFACE
tsi_select(TSI_DMX_0, SYS_TS_INPUT_INTERFACE);
#else
tsi_select(TSI_DMX_0, TSI_SPI_0);
#endif
as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, 0);
}
else if(snode->tuner2_valid == 1)
{
//modified for 29e tuner2 ts select
#if (SYS_CHIP_MODULE == ALI_M3329E)
tsi_select(TSI_DMX_0, TSI_SSI_0);
#else
#ifdef SYS_TS_INPUT_INTERFACE
tsi_select(TSI_DMX_0, SYS_TS_INPUT_INTERFACE);
#else
tsi_select(TSI_DMX_0, TSI_SPI_1);
#endif
#endif
as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, 1);
}
else
{
res = ERR_FAILUE;
}
return res;
}
void lib_subt_atsc_stop_filter(UINT16 dmx_id)
{
if(SI_SUCCESS != sie_abort_ext((struct dmx_device *)dev_get_by_id(HLD_DEV_TYPE_DMX, dmx_id),NULL, lib_subt_atac_pid,NULL))
{
ASSERT(FALSE);
}
lib_subt_atac_pid = 0x1fff;
return;
}
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;
}
/*
* request the NIT from stream
* and find given tp's information
*/
static INT32 find_tp_in_nit(UINT16 network_id, UINT16 ts_id, T_NODE *t_node)
{
INT32 ret;
UINT8 section_num = 0;
UINT8 last_section_num;
struct dmx_device * dmx_dev;
if((dmx_dev = (struct dmx_device *)dev_get_by_id(HLD_DEV_TYPE_DMX, 0)) == NULL)
{
return MULTIFEED_FAILURE;
}
struct get_section_param sr_request;
struct restrict sr_restrict;
MEMSET(&sr_request, 0, sizeof(struct get_section_param));
MEMSET(&sr_restrict, 0, sizeof(struct restrict));
sr_request.buff = multifeed_table_buff;
sr_request.buff_len = 1024;
sr_request.crc_flag = 1;
sr_request.pid = PSI_NIT_PID;
sr_request.mask_value = &sr_restrict;
sr_request.wai_flg_dly = 6000;
sr_restrict.mask_len = 7;
sr_restrict.value_num = 1;
sr_restrict.mask[0] = 0xff;
sr_restrict.mask[1] = 0x80;
sr_restrict.mask[6] = 0xff;
sr_restrict.value[0][0] = PSI_NIT_TABLE_ID;
sr_restrict.value[0][1] = 0x80;
section_num =0;
do{
sr_restrict.value[0][6] = section_num;
if(dmx_req_section(dmx_dev, &sr_request)!= SUCCESS)
{
return MULTIFEED_FAILURE;
}
last_section_num = multifeed_table_buff[7];
ret = search_node(multifeed_table_buff, 1024, network_id, ts_id, t_node);
if(ret == MULTIFEED_SUCCESS)
break;
section_num++;
}while(section_num<=last_section_num);
return ret;
}
static void win_tplist_set_capture(S_NODE *s_node, T_NODE *t_node)
{
INT32 tuning_frq = 0;
UINT8 pol;
struct nim_device *nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, (s_node->tuner1_valid ? 0 : (s_node->tuner2_valid ? 1 : 0)));
SYSTEM_DATA* sys_data = sys_data_get();
switch(s_node->lnb_type)
{
case LNB_CTRL_22K:
if(t_node->frq > KU_LNB_22K_EDGE_FREQUENCY)
{
api_diseqc_set_22k(nim, 1);
tuning_frq = t_node->frq - ((s_node->lnb_high > s_node->lnb_low) ? s_node->lnb_high : s_node->lnb_low);
}
else
{
api_diseqc_set_22k(nim, 0);
tuning_frq = t_node->frq - ((s_node->lnb_high > s_node->lnb_low) ? s_node->lnb_low : s_node->lnb_high);
}
break;
case LNB_CTRL_POL:
pol = ((s_node->pol == 0) || (s_node->pol == 3)) ? (s_node->pol + 1) : (s_node->pol);
if(pol == 1)
{
tuning_frq = s_node->lnb_low - t_node->frq;
}
else
{
tuning_frq = s_node->lnb_high - t_node->frq;
}
break;
case LNB_CTRL_UNICABLE:
// frontend_set_unicable(nim,antenna,xpond);
tuning_frq = sys_data->tuner_lnb_antenna[cur_tuner_idx].unicable_freq;;
break;
case LNB_CTRL_STD:
default:
tuning_frq = (((s_node->lnb_low != 0) ? s_node->lnb_low : s_node->lnb_high)) - t_node->frq;
break;
}
if(tuning_frq < 0)
{
tuning_frq = -tuning_frq;
}
UINT32 cap_param[3];
cap_param[0] = tuning_frq;
cap_param[1] = (UINT32)NULL;
cap_param[2] = t_node->sym;
libc_printf("win start capture freq = %d\n", tuning_frq);
//nim_ioctl_ext(nim, NIM_DRIVER_START_CAPTURE, &cap_param);
set_capture_freq(nim, tuning_frq);
}
static void init_upgrade_param()
{
#if (SYS_SDRAM_SIZE != 2) || defined(_MHEG5_ENABLE_)
struct sto_device* sto_local_flash_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0);
m_UpgradeParam.binary_len = (UINT32)(sto_local_flash_dev->totol_size);
#endif
if(UPGRADE_MULTI == upgrade_mode)
m_UpgradeParam.upgrade_mode = UPGRADE_MODE_MUL_NORMAL;
else
m_UpgradeParam.upgrade_mode = UPGRADE_MODE_One2One | (UART_DOWNLOAD_SPEED<<8);
}
/* Set Background Color of VPO for Single Color Background */
void hde_back_color(UINT8 bY, UINT8 bCb, UINT8 bCr)
{
struct YCbCrColor color;
color.uY = bY;
color.uCb = bCb;
color.uCr = bCr;
vpo_ioctl((struct vpo_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_DIS), VPO_IO_SET_BG_COLOR, (UINT32)(&color));
#ifdef DUAL_VIDEO_OUTPUT
vpo_ioctl((struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 1), VPO_IO_SET_BG_COLOR, (UINT32)&color);
#endif
}
static void osdmsg_updatevscr(VSCR* pVscr,UINT8 regionID)
{
if(pVscr->lpbScr!=NULL)
{
if(pVscr->updatePending)
{
cas_osd_dev = (struct osd_device*)dev_get_by_id(HLD_DEV_TYPE_OSD, 0);
OSDDrv_RegionWrite((HANDLE)cas_osd_dev, regionID, pVscr,&pVscr->vR);
pVscr->updatePending = 0;
}
}
}
