void SG_Do_Call(){
unsigned char buf[2];
int ret =0;
if(g_set_info.bAutoAnswerDisable == 1 && CallInListen == 0)
{
//使用手柄通话，不自动接听
SCI_TRACE_LOW("--------------------------------------------NOT AUTO ANS------------------------");
return;
}
if((g_state_info.user_type == 2) && (g_set_info.GpsAutoCall == 0))// 导航屏是否自动接听
{
return;
}
ConnectPhoneTimer = 0;
// 10s之后接听电话，接听电话之前要stop铃声
AUD_StopRing();
AUD_SetVolume(AUD_DEV_MODE_HANDFREE, AUD_TYPE_VOICE, g_set_info.speaker_vol); // 设置音量为免提时音量
#ifndef _TRACK
GPIO_SetValue(HF_MUTE,SCI_FALSE);
#endif
AUD_EnableVoiceCodec( 1 );
ret = MNCALL_ConnectCall(CurrCallId,PNULL);
SCI_TRACE_LOW("----MNCALL_ConnectCall:RET %d",ret);
buf[0] = 1;
SG_Uart_Send_Msg(buf, 1, RTN_AUTO_REV);
}
uint32_t JPEGDEC_Poll_MEA_BSM(uint32_t time, uint32_t buf_len, jpegdec_callback callback)
{
uint32_t value;
uint32_t vsp_time_out_cnt = 0;
SCI_TRACE_LOW("JPEGDEC_Poll_MEA_BSM E.\n");
while (1)
{
value = VSP_READ_REG(VSP_DCAM_REG_BASE + DCAM_INT_RAW_OFF, "read the interrupt register.");
if(value & 0x80){ //for BSM done
JPEGDEC_Handle_BSM_INT(callback);
}
if(value & 0x4000){ //for MEA done
JPEG_HWUpdateMEABufInfo();
JPEG_HWSet_MEA_Buf_ReadOnly(1);
JPGEDEC_Clear_INT(0x4000);
SCI_TRACE_LOW("JPEGDEC_Poll_MEA_BSM X.\n");
return 1;
}
if (vsp_time_out_cnt > time)
{
SCI_TRACE_LOW("JPEGDEC_Poll_MEA_BSM X, fail..\n");
return 1;
}
vsp_time_out_cnt++;
usleep(1000);
}
}
/****************************************************************
函数名： CC_CallAlertingInd
功 能 ：收到振铃提示事件的处理函数
输入参数：DPARAM param
输出参数：无
编写者 ：陈海华
修改记录：创建 2007/8/15
****************************************************************/
void CC_CallAlertingInd(DPARAM param)
{
APP_MN_ALERTING_IND_T *pSig = (APP_MN_ALERTING_IND_T*)param;
unsigned char buf[2];
//check the param
SCI_TRACE_LOW("<<<<<<ccapp.c:enter function CC_CallAlertingInd(), call_id = %d, alerting_type = %d", pSig->call_id, pSig->alerting_type);
SCI_PASSERT(PNULL != pSig, ("<<<<<<ccapp.c: CC_CallAlertingInd() pSig == PNULL"));
CurrCallId = pSig->call_id;
buf[0] = 0;
SG_Uart_Send_Msg(buf, 1, RTN_AUTO_REV);
switch( pSig->alerting_type )
{
case MN_CALL_IN_BAND_AVAILABLE:
break;
//MO,收到对端发送来的ALERT消息
case MN_CALL_REMOTE_USER_ALERTING:
break;
//MT,indicate alerting
case MN_CALL_LOCAL_USER_ALERTING:
SCI_TRACE_LOW("<<<<<<MN_CALL_LOCAL_USER_ALERTING<<<<<<");
MNCALL_IndicateAlert( pSig->call_id, PNULL );
break;
default:
SCI_TRACE_LOW("<<<<<<ccapp.c:CC_CallAlertingInd() alerting_type = %d", pSig->alerting_type);
break;
}
}
//poll VLC done and BSM done
uint32_t JPEGENC_Poll_VLC_BSM(uint32_t time, uint32_t buf_len, jpegenc_callback callback)
{
uint32_t value;
uint32_t vsp_time_out_cnt = 0;
SCI_TRACE_LOW("JPEGENC_Poll_VLC_BSM E.\n");
while (1)
{
value = VSP_READ_REG(VSP_DCAM_REG_BASE + DCAM_INT_RAW_OFF, "read the interrupt register.");
if(value & 0x100){ //for VLC done
JPGEENC_Clear_INT(0x100);
SCI_TRACE_LOW("JPEGENC_Poll_VLC_BSM X.\n");
return 1;
}
if(value & 0x80){ //for BSM done
JPEGENC_Handle_BSM_INT(callback);
}
if (vsp_time_out_cnt > time)
{
SCI_TRACE_LOW("JPEGENC_Poll_VLC_BSM X, fail.\n");
return 1;
}
vsp_time_out_cnt++;
usleep(1000);
}
}
static uint32_t poll_ahb_idle(uint32_t time)
{
uint32_t vsp_time_out_cnt = 0;
while (1)
{
uint32 ahb_idle = 0;
ahb_idle = ((*(volatile uint32*)(VSP_AHBM_REG_BASE+AHBM_STS_OFFSET-VSP_DCAM_BASE+g_vsp_Vaddr_base) & 0x1));
if (ahb_idle) //busy
{
usleep(1000);
SCI_TRACE_LOW("JPEGDEC_Poll_MEA_BSM X, AHB IS BUSY.\n");
}else
{
break;
}
vsp_time_out_cnt++;
if (vsp_time_out_cnt > time)
{
SCI_TRACE_LOW("JPEGDEC_Poll_MEA_BSM X, fail 2.\n");
dbg_print_vsp_reg();
return 1;
}
}
return 0;
}
/****************************************************************
函数名： MMI_GenPartyNumber
功 能 ：由str格式的电话号码处理成为bcd格式的处理函数
输入参数：uint8 *tele_num_ptr str格式的电话号码的首地址
int16 tele_len str格式的电话号码的长度
MMI_PARTY_NUMBER_T *party_num 生成的bcd码及类型存储的结构体首地址
输出参数：无
编写者 ：郭碧莲
修改记录：创建 2007/8/25
****************************************************************/
BOOLEAN MMI_GenPartyNumber(
uint8 *tele_num_ptr,
int16 tele_len,
MMI_PARTY_NUMBER_T *party_num
)
{
uint8 offset = 0;
uint8* tele_num = PNULL;
SCI_TRACE_LOW("<<<<<<MMI_GenPartyNumber<<<<<<");
//check the param
SCI_ASSERT( NULL != tele_num_ptr );
SCI_ASSERT( NULL != party_num );
if (0 == tele_len)
{
party_num->num_len = 0;
SCI_TRACE_LOW("<<<<<<MMI_GenPartyNumber length = 0\n");
return FALSE;
}
tele_num = (uint8*)SCI_ALLOC(tele_len + 1);
SCI_MEMSET(tele_num, 0, (tele_len + 1));
MMI_MEMCPY(
tele_num,
tele_len + 1,
tele_num_ptr,
tele_len,
tele_len);
if('+' == tele_num[0])
{
party_num->number_type = MN_NUM_TYPE_INTERNATIONAL;
offset++;
}
else
{
party_num->number_type = MN_NUM_TYPE_UNKNOW;
}
party_num->num_len = ( tele_len - offset + 1 ) /2;
SCI_ASSERT( party_num->num_len <= MN_MAX_ADDR_BCD_LEN);
MMI_StrToBcd( PACKED_LSB_FIRST,
(char*)( tele_num + offset),
(uint8 *)&(party_num->bcd_num) );
SCI_FREE(tele_num);
return TRUE;
}
PUBLIC JPEG_RET_E JPEGENC_stop_encode(JPEGENC_PARAMS_T *jpegenc_params)
{
JPEG_RET_E jpeg_ret_value = JPEG_FAILED;
SCI_PASSERT(jpegenc_params, ("[JPEG_6600L_StopEncode], context_ptr is NULL"));
jpeg_ret_value = JPEG_HWWriteTail();
if( JPEG_SUCCESS == jpeg_ret_value)
{
jpegenc_params->stream_size = JPEG_HWGetSize( );
/*if (jpegenc_params->stream_size > jpegenc_params->stream_buf_len)
{
SCI_TRACE_LOW("[JPEG_StopEncode] jpeg stream buffer is not enough, stream size = %d, target buffer size = %d",
jpegenc_params->stream_size, jpegenc_params->stream_buf_len);
return JPEG_MEMORY_NOT_ENOUGH;
}*/
#if 0
{
FILE *fp = NULL;
fp = fopen("/data/out_enc.jpeg", "wb");
fwrite(jpegenc_params->stream_virt_buf[0], 1, jpegenc_params->stream_size, fp);
fclose(fp);
}
#endif
}
SCI_TRACE_LOW("[JPEG_6600L_StopEncode] stop enc, stream_size = %d", jpegenc_params->stream_size);
return jpeg_ret_value;
}
void JPEGENC_Handle_BSM_INT(jpegenc_callback callback)
{
//uint32_t tmp = g_stream_buf_id;
JPGEENC_Clear_INT(0x80);
if(0 == g_stream_buf_id){
g_stream_buf_id = 1;
}
else{
g_stream_buf_id = 0;
}
JPEG_HWSet_BSM_Buf_WriteOnly(g_stream_buf_id);
SCI_TRACE_LOW("JPEGENC_Poll_MEA_BSM JPEG_HWSet_BSM_Buf_WriteOnly after.g_stream_buf_id: %d.\n", g_stream_buf_id);
callback(g_stream_buf_id, g_stream_buf_size, 0);
SCI_TRACE_LOW("JPEGENC_Poll_MEA_BSM callback after.\n");
}
LOCAL ERR_LCD_E HX8309_EnterSleep(
BOOLEAN is_sleep //SCI_TRUE: exter sleep mode;SCI_FALSE:exit sleep mode.
)
{
SCI_TRACE_LOW("HX8309_EnterSleep,%d", is_sleep);
if ( is_sleep ) // enter sleep mode.
{
//HX8309_sendcommand1(0x0007, 0x0000); //DTE=0, D1-0=0, GON=0
//HX8309_sendcommand1(0x0003, 0x0002); //SLP=1
//Delayms(40);
HX8309_GoSleep();
}
else // out sleep mode
{
HX8309_reset();
//HX8309_ExitSleep();
HX8309_Invalidate();
}
/*
if( !GetUdiskState())
DC_EnterSleep(is_sleep);
*/
return ERR_LCD_NONE;
}
void SG_Call_Listen()
{
if(CC_RESULT_SUCCESS != CC_ConnectCall(g_state_info.sListenOutNo))
{
SCI_TRACE_LOW("<<<<<<CC_ConnectCall connect ListenNo Failure!!");
}
else
{
SCI_TRACE_LOW("<<<<<<CC_ConnectCall connect ListenNo Successful!!");
}
SCI_TRACE_LOW( "<<<<<<SG_Rcv_Safety_Listen: %s", g_state_info.sListenOutNo);
memset(g_state_info.sListenOutNo,0,sizeof(g_state_info.sListenOutNo));
}
PUBLIC BOOLEAN HX8309_Probe(void)
{
uint32 i, adc_val = 0, adc_sum = 0;
/*Delayms(500);
for(i=0; i<ADC_NUM; i++)
{
adc_val = ADC_GetResultDirectly(ADIN_1, FALSE);
adc_sum += adc_val;
SCI_TRACE_LOW("adc_rlt[%d]: %d", i, adc_val);
Delayms(50);
}
adc_val = adc_sum / ADC_NUM;*/
adc_val = LCD_GetADCValue(ADIN_1);//added by lipengyu.
SCI_TRACE_LOW("average adc_val: %d", adc_val);
if((adc_val >= ADC_HX8309_LOW) && (adc_val <= ADC_HX8309_HIGH)) //Á¦Ê¤ 8309
{
return SCI_TRUE;
}
return SCI_FALSE;
}
/****************************************************************
函数名： MMI_GenDispNumber
功 能 ：产生显示的电话号码(bcd to str)
输入参数：MN_NUMBER_TYPE_E number_type // 号码的类型
uint8 party_len // 待转换的bcd数组的长度
uint8 *party_num // 待转换的bcd数组的首地址
uint8 *tele_num // 转换完毕存储str的首地址
uint8 max_tele_len //!!!!!!!!!可显示的号码的最大长度 + 2(/0 字符串结束符号)
输出参数：无
编写者 ：郭碧莲
修改记录：创建 2007/8/15
****************************************************************/
uint8 MMI_GenDispNumber(
MN_NUMBER_TYPE_E number_type,
uint8 party_len,
uint8 *party_num,
uint8 *tele_num,
uint8 max_tele_len//!!!!!!!!!可显示的号码的最大长度 + 2(/0 字符串结束符号)
)
{
uint8 offset = 0;
uint8 len = 0;
//check the param
SCI_TRACE_LOW("<<<<<<enter function MMI_GenDispNumber()");
SCI_PASSERT(NULL != tele_num, ("<<<<<<MMI_GenDispNumber() tele_num == NULL"));
SCI_PASSERT(NULL != party_num, ("<<<<<<MMI_GenDispNumber() party_num == NULL"));
SCI_ASSERT( max_tele_len > 2 );
if(MN_NUM_TYPE_ALPHANUMERIC == number_type)
{
MMI_MEMCPY(tele_num, max_tele_len, party_num, party_len, party_len);
return MIN(max_tele_len, party_len);
}
//check the tele_num is internation tele
if( MN_NUM_TYPE_INTERNATIONAL == number_type )
{
offset = 1;
tele_num[0] = '+';
}
if( 0 == party_len )
{
SCI_TRACE_LOW("<<<<<<MMI_GenDispNumber: called_num->num_len = 0");
return (offset);
}
len = party_len << 1;
SCI_ASSERT( len <= (max_tele_len - offset - 1));
MMI_BcdToStr(PACKED_LSB_FIRST ,party_num, len, (char*)( tele_num + offset ) );
return (uint8)strlen((char*)tele_num);
}
void JPGEENC_Clear_INT(uint32_t mask)
{
uint32_t value;
value = VSP_READ_REG(VSP_DCAM_REG_BASE + DCAM_INT_RAW_OFF, "");
SCI_TRACE_LOW("JPEGENC DCAM_INT_RAW_OFF: 0x%x.", value);
value = VSP_READ_REG(VSP_DCAM_REG_BASE + DCAM_INT_CLR_OFF, "read the interrupt clear bits.");
value |= mask;
VSP_WRITE_REG(VSP_DCAM_REG_BASE + DCAM_INT_CLR_OFF, value, "clear the VLC interrupt.");
}
void dbg_print_vsp_reg(void)
{
uint32_t i, regvalue;
uint32_t regaddr[] = { 0x20c00000, 0x20c0000c, 0x20c00014, 0x20c00020, 0x20c00024, 0x20c00028, 0x20c0002c,
0x20c00040, 0x20c00044, 0x20c00048, 0x20c0004c, 0x20c00050, 0x20c00054, 0x20c00058,
0x20c10400, 0x20c10404, 0x20c10408, 0x20c1040c, 0x20c10410, 0x20c10414, 0x20c10418,
0x20c1041c, 0x20c10420, 0x20c10424, 0x20c10428, 0x20c10800, 0x20c10870, 0x20c10874,
0x20c10878, 0x20c1087c, 0x20c10880, 0x20c10884, 0x20c10888, 0x20c11c00, 0x20c11c04,
0x20c11c08, 0x20c11c0c, 0x20c11c10, 0x20c11c14, 0x20c11c18, 0x20c11c1c};
SCI_TRACE_LOW("dbg_print_vsp_reg print start \n");
for(i=0; i<sizeof(regaddr)/sizeof(uint32_t); i++)
{
regvalue = (*(volatile uint32 *)(regaddr[i]-VSP_DCAM_BASE+g_vsp_Vaddr_base));
SCI_TRACE_LOW("addr=0x%08x, value=0x%08x \n",regaddr[i], regvalue);
}
SCI_TRACE_LOW("dbg_print_vsp_reg print end \n");
}
//回拨坐席电话
void SG_Call_Back_To()
{
SG_Set_Cal_CheckSum();
g_set_info.bAutoAnswerDisable = 0; //设置为免提通话
g_set_info.speaker_vol = 6;
SG_Set_Save();
if(CC_RESULT_SUCCESS != CC_ConnectCall(g_state_info.sCallBackToNo))
{
SCI_TRACE_LOW("<<<<<<CC_ConnectCall connect CallBackNo Failure!!");
}
else
{
SCI_TRACE_LOW("<<<<<<CC_ConnectCall connect CallBackNo Successful!!");
}
SCI_TRACE_LOW( "<<<<<<SG_Call_Back_To: %s", g_state_info.sCallBackToNo);
memset(g_state_info.sCallBackToNo,0,sizeof(g_state_info.sCallBackToNo));
}
void get_regs(void)
{
int i, value;
for(i = 0; i < 6; i++)
{
value = VSP_READ_REG(VSP_GLB_REG_BASE + i * 4,"");
SCI_TRACE_LOW("GLB 0x%x : 0x%x", VSP_GLB_REG_BASE + i * 4, value);
}
for(i = 0; i < 3; i++)
{
value = VSP_READ_REG(VSP_AHBM_REG_BASE + i * 4,"");
SCI_TRACE_LOW("AHBM 0x%x : 0x%x", VSP_AHBM_REG_BASE + i * 4, value);
}
for(i = 0; i < 12; i++)
{
value = VSP_READ_REG(VSP_BSM_REG_BASE + i * 4,"");
SCI_TRACE_LOW("BSM 0x%x : 0x%x", VSP_BSM_REG_BASE + i * 4, value);
}
for(i = 0; i < 3; i++)
{
value = VSP_READ_REG(VSP_VLC_REG_BASE + i * 4,"");
SCI_TRACE_LOW("VLC 0x%x : 0x%x", VSP_VLC_REG_BASE + i * 4, value);
}
for(i = 0; i < 12; i++)
{
value = VSP_READ_REG(VSP_DCAM_REG_BASE + i * 4,"");
SCI_TRACE_LOW("DCAM 0x%x : 0x%x", VSP_DCAM_REG_BASE + i * 4, value);
}
for(i = 0; i < 19; i++)
{
value = VSP_READ_REG(VSP_MEA_REG_BASE + i * 4,"");
SCI_TRACE_LOW("MEA 0x%x : 0x%x", VSP_MEA_REG_BASE + i * 4, value);
}
}
PUBLIC JPEG_RET_E JPEGDEC_stop_decode(JPEGDEC_PARAMS_T *jpegdec_params)
{
JPEG_RET_E jpeg_ret_value = JPEG_SUCCESS;//JPEG_FAILED;
SCI_PASSERT(jpegdec_params, ("[JPEG_6600L_StopDecode], context_ptr is NULL"));
if( JPEG_SUCCESS == jpeg_ret_value)
{
}
#if 0
JPEG_Mem_Copy( jpegdec_params , 1 );
#endif
SCI_TRACE_LOW("[JPEG_6600L_StopDecode] start dec, stream_size = %d", jpegdec_params->stream_size);
return jpeg_ret_value;
}
/****************************************************************
函数名： CC_OpenAudioTunnel
功 能 ：open speaker and microphone
输入参数：BOOLEAN is_input_on
BOOLEAN is_output_on
输出参数：无
编写者 ：陈海华
修改记录：创建 2007/8/15
****************************************************************/
void CC_OpenAudioTunnel(
BOOLEAN is_input_on,
BOOLEAN is_output_on
)
{
uint8 volume = 0;
AUD_DEV_MODE_E mode = AUD_DEV_MODE_HANDFREE;
SCI_TRACE_LOW("<<<<<<ccapp.c: CC_OpenAudioTunnel() is_input_on = %d, is_output_on = %d",is_input_on,is_output_on);
//check the current state of microphone and speaker
volume = 5;
AUD_SetVolume(mode, AUD_TYPE_VOICE, (uint32)volume); // set the volume
AUD_EnableVoiceCodec( 1 ); // set voice codec enable
}
LOCAL JPEG_RET_E JPEG_Mem_Copy( JPEGDEC_PARAMS_T *jpegdec_params , int mem_direct )
{
SCI_TRACE_LOW("enter [JPEG_Mem_Copy] header_len = %d ,bitstream_len = %d",jpegdec_params->header_len , jpegdec_params->stream_size);
uint32_t data_len = jpegdec_params->stream_size - jpegdec_params->header_len ;
if ( 0 == mem_direct)
{
SCI_MEMCPY( jpegdec_params->temp_buf_addr , (uint8_t *)jpegdec_params->stream_virt_buf[0] , jpegdec_params->stream_size );
SCI_MEMCPY( (uint8_t *)jpegdec_params->stream_virt_buf[0] , jpegdec_params->temp_buf_addr +jpegdec_params->header_len ,data_len);
}
else
{
SCI_MEMCPY( (uint8_t *)jpegdec_params->stream_virt_buf[0] , jpegdec_params->temp_buf_addr , jpegdec_params->stream_size );
}
return 0;
}
PUBLIC void JpegEnc_HwTopUpdateYUVAddr(uint32 y_phy_addr,uint32_t u_phy_addr,uint32_t v_phy_addr)
{
JPEG_CODEC_T *jpeg_fw_codec = Get_JPEGEncCodec();
// uint32 pTableAddr = (uint32)VSP_MEMO10_ADDR;
jpeg_fw_codec->YUV_Info_0.y_data_ptr = (unsigned char*)y_phy_addr;
jpeg_fw_codec->YUV_Info_1.y_data_ptr = (unsigned char*)y_phy_addr;
jpeg_fw_codec->YUV_Info_0.u_data_ptr = (unsigned char*)u_phy_addr;
jpeg_fw_codec->YUV_Info_1.u_data_ptr = (unsigned char*)u_phy_addr;
//Source Buffer0 and Buffer1 Addr Init
JPG_WRITE_REG(JPG_GLB_REG_BASE+GLB_FRM_ADDR0_OFFSET, (uint32)(jpeg_fw_codec->YUV_Info_0.y_data_ptr), "Source Y0 Frame buffer ");
JPG_WRITE_REG(JPG_GLB_REG_BASE+GLB_FRM_ADDR1_OFFSET, (uint32)(jpeg_fw_codec->YUV_Info_0.u_data_ptr), "Source U0 Frame buffer ");
JPG_WRITE_REG(JPG_GLB_REG_BASE+GLB_FRM_ADDR6_OFFSET, (uint32)(jpeg_fw_codec->YUV_Info_0.v_data_ptr), "Source V0 Frame buffer ");
JPG_WRITE_REG(JPG_GLB_REG_BASE+GLB_FRM_ADDR2_OFFSET, (uint32)(jpeg_fw_codec->YUV_Info_1.y_data_ptr), "Source Y1 Frame buffer ");
JPG_WRITE_REG(JPG_GLB_REG_BASE+GLB_FRM_ADDR3_OFFSET, (uint32)(jpeg_fw_codec->YUV_Info_1.u_data_ptr), "Source U1 Frame buffer ");
JPG_WRITE_REG(JPG_GLB_REG_BASE+GLB_FRM_ADDR7_OFFSET, (uint32)(jpeg_fw_codec->YUV_Info_1.v_data_ptr), "Source V1 Frame buffer ");
SCI_TRACE_LOW("jpeg, update yu addr,0x%x,0x%x.\n",y_phy_addr,u_phy_addr);
}
/****************************************************************
函数名： SG_Call_In_Judge
功 能 ：呼入限制的判断
输入参数：tele_num 电话号码 call_id 电话ID
输出参数：无
编写者 ：郭碧莲
修改记录：创建 2008/9/02
****************************************************************/
static int SG_Call_In_Judge(char *tele_num,int call_id)
{
// 没有呼入限制，直接退出函数
if(g_set_info.bCallInDisable == 0)
{
SCI_TRACE_LOW("<<<<<<SG_Call_In_Judge:No Call in disable!! %s",tele_num);
return 1;
}
// 呼入限制列表为空，所有电话都拒绝
if((0 == strcmp(g_state_info.sAllowAnswer,"")) || (&tele_num == 0))
{
SCI_TRACE_LOW("<<<<<<SG_Call_In_Judge:All The Number is been reject:%s",tele_num);
// 直接挂断
if(MN_RETURN_SUCCESS != MNCALL_DisconnectCall(call_id, PNULL))
{
SCI_TRACE_LOW("<<<<<<SG_Call_In_Judge: MNCALL_DisconnectCall return failure");
}
return 0;
}
// 呼入的号码在列表中，则允许接通，否则直接挂断
if(NULL == strstr(g_state_info.sAllowAnswer,(char*)tele_num) || (char *)tele_num == "")
{
SCI_TRACE_LOW("<<<<<<SG_Call_In_Judge:The Number is been reject:%s",tele_num);
// 直接挂断
if(MN_RETURN_SUCCESS != MNCALL_DisconnectCall(call_id, PNULL))
{
SCI_TRACE_LOW("<<<<<<SG_Call_In_Judge: MNCALL_DisconnectCall return failure");
}
return 0;
}
else
{
SCI_TRACE_LOW("<<<<<<SG_Call_In_Judge:The Number is allow to answer!! %s",tele_num);
return 1;
}
}
LOCAL void HX8309_reset(void)
{
SCI_TRACE_LOW("HX8309_reset: 7370 HX8309.");
//delay 10ms
Delayms(10);
//R10H<-0000H
HX8309_sendcommand1(0x0010,0x0);
//R11H<-0000H
HX8309_sendcommand1(0x0011,0x0);
//R12H<-0000H
HX8309_sendcommand1(0x0012,0x0);
//R13H<-0000H
HX8309_sendcommand1(0x0013,0x0);
//R00H<-0001H
HX8309_sendcommand1(0x0,0x01);
//delay 30ms
Delayms(30);
//R11H<-0001H
HX8309_sendcommand1(0x0011,0x01);
//R12H<-0004H
HX8309_sendcommand1(0x0012,0x04);
//R13H<-141CH
HX8309_sendcommand1(0x0013,0x141c);
//R10H<-0044H
HX8309_sendcommand1(0x0010,0x0044);
//R12H<-0018H
HX8309_sendcommand1(0x0012,0x0018);
//delay 100ms
Delayms(100);
//R10H<-0040H
HX8309_sendcommand1(0x0010,0x0040);
//R13H<-3413H
HX8309_sendcommand1(0x0013,0x3413);
//HX8309_sendcommand1(0x0013,0x3518);
//R08H<-0202H
HX8309_sendcommand1(0x0008,0x0202);
//R09H<-0000H
HX8309_sendcommand1(0x0009,0x0);
//R0BH<-0000H
HX8309_sendcommand1(0x000B,0x0);
//R21H<-0000H
HX8309_sendcommand1(0x0021,0x0);
//R23H<-0000H
HX8309_sendcommand1(0x0023,0x0);
//R24H<-0000H
HX8309_sendcommand1(0x0024,0x0);
//R30H<-0000H
HX8309_sendcommand1(0x0030,0x0);
//R31H<-0000H
HX8309_sendcommand1(0x0031,0x0);
//R32H<-0007H
HX8309_sendcommand1(0x0032,0x07);
//R33H<-0007H
HX8309_sendcommand1(0x0033,0x07);
//R34H<-0000H
HX8309_sendcommand1(0x0034,0x0);
//R35H<-0000H
HX8309_sendcommand1(0x0035,0x0);
//R36H<-0000H
HX8309_sendcommand1(0x0036,0x0);
//R37H<-0000H
HX8309_sendcommand1(0x0037,0x0);
//R38H<-0000H
HX8309_sendcommand1(0x0038,0x0);
//R39H<-0000H
HX8309_sendcommand1(0x0039,0x0);
//R40H<-0000H
HX8309_sendcommand1(0x0040,0x0);
//R01H<-011BH
HX8309_sendcommand1(0x0001,0x011B);
//R02H<-0700H
HX8309_sendcommand1(0x0002,0x0700);
//R03H<-1030H
HX8309_sendcommand1(0x0003,0x1030);
//R04H<-0000H
HX8309_sendcommand1(0x0004,0x0);
//R05H<-0000H
HX8309_sendcommand1(0x0005,0x0);
//R41H<-0000H
HX8309_sendcommand1(0x0041,0x0);
//R42H<-DB00H
HX8309_sendcommand1(0x0042,0xDB00);
//R43H<-DB00H
HX8309_sendcommand1(0x0043,0xDB00);
//R44H<-AF00H
HX8309_sendcommand1(0x0044,0xAF00);
//R45H<-DB00H
HX8309_sendcommand1(0x0045,0xDB00);
//R10H<-4040H
HX8309_sendcommand1(0x0010,0x4040);
//delay 100ms
Delayms(100);
//R07H<-0005H
HX8309_sendcommand1(0x0007,0x0005);
//delay 20ms
Delayms(20);
//R07H<-0025H
HX8309_sendcommand1(0x0007,0x0025);
//R07H<-0027H
HX8309_sendcommand1(0x0007,0x0027);
//delay 20ms
Delayms(20);
//R07H<-0037H
HX8309_sendcommand1(0x0007,0x0037);
//R22H<-Display Data Write
HX8309_SEND_COMMAND(0x0022);
/* HX8309_sendcommand1(0x0001,0x011B);
HX8309_sendcommand1(0x0002,0x0700);
HX8309_sendcommand1(0x0003,0x6030); //0x6020
HX8309_sendcommand1(0x0004,0x0000);
HX8309_sendcommand1(0x0005,0x0000);
HX8309_sendcommand1(0x0007,0x0003);
HX8309_sendcommand1(0x0008,0x0202);
HX8309_sendcommand1(0x0009,0x0000);
HX8309_sendcommand1(0x000B,0x0004);
HX8309_sendcommand1(0x000C,0x0003);
HX8309_sendcommand1(0x0040,0x0000);
HX8309_sendcommand1(0x0041,0x00EF);
HX8309_sendcommand1(0x0042,0xDB00);
HX8309_sendcommand1(0x0043,0xDB00);
HX8309_sendcommand1(0x0044,0xAF00);
HX8309_sendcommand1(0x0045,0xDB00);
Delayms(100);
//############# void Power_Set(void) ################//
HX8309_sendcommand1(0x0000,0x0001);
Delayms(1);
HX8309_sendcommand1(0x0010,0x0000);
HX8309_sendcommand1(0x0011,0x0000);
HX8309_sendcommand1(0x0012,0x0000);
HX8309_sendcommand1(0x0013,0x0000);
HX8309_sendcommand1(0x0011,0x0000);
HX8309_sendcommand1(0x0013,0x1517);
HX8309_sendcommand1(0x0012,0x0008);
HX8309_sendcommand1(0x0010,0x4040);
Delayms(1);
HX8309_sendcommand1(0x0011,0x0000);
HX8309_sendcommand1(0x0010,0x0054);
HX8309_sendcommand1(0x0012,0x0014);
Delayms(10);
HX8309_sendcommand1(0x0010,0x4040);
Delayms(10);
HX8309_sendcommand1(0x0013,0x3413); //0x3A1B
Delayms(100);
//################# void Gamma_Set(void) ####################//
HX8309_sendcommand1(0x0030,0x0406);
HX8309_sendcommand1(0x0031,0x0306);
HX8309_sendcommand1(0x0032,0x0000);
HX8309_sendcommand1(0x0033,0x0003);
HX8309_sendcommand1(0x0034,0x0406);
HX8309_sendcommand1(0x0035,0x0306);
HX8309_sendcommand1(0x0036,0x0000);
HX8309_sendcommand1(0x0037,0x0003);
HX8309_sendcommand1(0x0038,0x0000);
HX8309_sendcommand1(0x0039,0x0000);
//################# void Gamma_Set(void) ####################//
HX8309_sendcommand1(0x0030,0x0300);
HX8309_sendcommand1(0x0031,0x0001);
HX8309_sendcommand1(0x0032,0x0700);
HX8309_sendcommand1(0x0033,0x0100);
HX8309_sendcommand1(0x0034,0x0700);
HX8309_sendcommand1(0x0035,0x0607);
HX8309_sendcommand1(0x0036,0x0704);
HX8309_sendcommand1(0x0037,0x0202);
HX8309_sendcommand1(0x0038,0x0006);
HX8309_sendcommand1(0x0039,0x0404);
//################## void Display_ON(void) ####################//
HX8309_sendcommand1(0x0007,0x0045);
Delayms(40);
HX8309_sendcommand1(0x0007,0x0065);
HX8309_sendcommand1(0x0007,0x0067);
Delayms(40);
HX8309_sendcommand1(0x0007,0x0077);
Delayms(10);
HX8309_SEND_COMMAND(0x0022); // Set to index R22h for transmission data to SRAM.
*/
}
LOCAL void JPEGENC_init_fw_param(JPEGENC_PARAMS_T *jpegenc_params,
JPEG_ENC_INPUT_PARA_T *enc_fw_info_ptr)
{
uint32_t slice_height;
enc_fw_info_ptr->is_first_slice = TRUE;
if(jpegenc_params->height > SLICE_HEIGHT){
enc_fw_info_ptr->is_last_slice = FALSE;
slice_height = SLICE_HEIGHT;
}
else{
enc_fw_info_ptr->is_last_slice = TRUE;
slice_height = jpegenc_params->height;
}
enc_fw_info_ptr->width = jpegenc_params->width;
enc_fw_info_ptr->height = jpegenc_params->height;
enc_fw_info_ptr->quant_level = (JPEG_QUALITY_E)((jpegenc_params->quality >= JPEG_QUALITY_MAX) ? JPEG_QUALITY_HIGH
: jpegenc_params->quality);
enc_fw_info_ptr->yuv_0_info.input_mcu_info = jpegenc_params->format;
enc_fw_info_ptr->yuv_1_info.input_mcu_info = jpegenc_params->format;
enc_fw_info_ptr->yuv_0_info.y_data_ptr = (uint8_t *)jpegenc_params->yuv_phy_buf;
enc_fw_info_ptr->yuv_0_info.u_data_ptr = enc_fw_info_ptr->yuv_0_info.y_data_ptr + jpegenc_params->width * jpegenc_params->height;
enc_fw_info_ptr->yuv_0_info.v_data_ptr = PNULL;
enc_fw_info_ptr->yuv_0_info.out_mcu_info = jpegenc_params->format;
enc_fw_info_ptr->yuv_0_info.input_endian = 1;
if(jpegenc_params->height > SLICE_HEIGHT){
enc_fw_info_ptr->yuv_1_info.y_data_ptr = (uint8_t *)jpegenc_params->yuv_phy_buf + jpegenc_params->width * slice_height; //fro YUV420
enc_fw_info_ptr->yuv_1_info.u_data_ptr = (uint8_t *)jpegenc_params->yuv_phy_buf + jpegenc_params->width * jpegenc_params->height + jpegenc_params->width * slice_height / 2;
enc_fw_info_ptr->yuv_1_info.v_data_ptr = PNULL;
enc_fw_info_ptr->yuv_1_info.out_mcu_info = jpegenc_params->format;
enc_fw_info_ptr->yuv_1_info.input_endian = 1;
}
else{
enc_fw_info_ptr->yuv_1_info.y_data_ptr = PNULL;
enc_fw_info_ptr->yuv_1_info.u_data_ptr = PNULL;
enc_fw_info_ptr->yuv_1_info.v_data_ptr = PNULL;
enc_fw_info_ptr->yuv_1_info.out_mcu_info = jpegenc_params->format;
enc_fw_info_ptr->yuv_1_info.input_endian = 1;
}
enc_fw_info_ptr->bitstream_buf_len = jpegenc_params->stream_buf_len;
g_stream_buf_size = enc_fw_info_ptr->bitstream_buf_len;
enc_fw_info_ptr->stream_buf0 = (uint8_t *)jpegenc_params->stream_phy_buf[0];
enc_fw_info_ptr->stream_buf1 = (uint8_t *)jpegenc_params->stream_phy_buf[1];
enc_fw_info_ptr->enc_buf.buf_size = 0;
enc_fw_info_ptr->enc_buf.buf_ptr = NULL;
enc_fw_info_ptr->mea_bfr0_valid = TRUE;
enc_fw_info_ptr->mea_bfr1_valid = FALSE;
enc_fw_info_ptr->stream_buf0_valid = TRUE;
enc_fw_info_ptr->stream_buf1_valid = FALSE;
enc_fw_info_ptr->work_mode = ALONE_MODE;
enc_fw_info_ptr->restart_interval = 0;
SCI_TRACE_LOW("[JPEG_EncInitFwParam] jpeg fw info, len = %d, ping addr = 0x%x, pong addr = 0x%x, encode size = %d, encode addr = 0x%x",
enc_fw_info_ptr->bitstream_buf_len, (uint32_t)enc_fw_info_ptr->stream_buf0, (uint32_t)enc_fw_info_ptr->stream_buf1,
(uint32_t)enc_fw_info_ptr->enc_buf.buf_ptr, enc_fw_info_ptr->enc_buf.buf_size);
SCI_TRACE_LOW("[JPEG_EncInitFwParam] ping mcu info = %d, pong mcu info = %d, width = %d, height = %d",
enc_fw_info_ptr->yuv_0_info.input_mcu_info, enc_fw_info_ptr->yuv_1_info.input_mcu_info, enc_fw_info_ptr->width,
enc_fw_info_ptr->height);
}
uint32_t JPEGENC_encode_one_pic(JPEGENC_PARAMS_T *jpegenc_params, jpegenc_callback callback)
{
int32_t vsp_fd = -1;
void *vsp_addr = NULL;
uint32_t ret = 0;
uint32 value = 0, int_val = 0, temp = 0;
JPEG_ENC_INPUT_PARA_T input_para_ptr;
if(0 > (vsp_fd = open(VSP_DRIVER,O_RDWR)))
{
SCI_TRACE_LOW("JPEGENC open vsp error, vsp_fd: %d.\n", vsp_fd);
return -1;
}
else
{
vsp_addr = mmap(NULL,MAP_SIZE,PROT_READ|PROT_WRITE,MAP_SHARED,vsp_fd,0);
SCI_TRACE_LOW("JPEGENC vsp addr 0x%x\n",(uint32_t)vsp_addr);
}
ret = ioctl(vsp_fd,VSP_ACQUAIRE,NULL);
if(ret){
SCI_TRACE_LOW("VSP hardware timeout try again %d\n",ret);
ret = ioctl(vsp_fd,VSP_ACQUAIRE,NULL);
if(ret){
SCI_TRACE_LOW("VSP hardware timeout give up %d\n",ret);
ret = -1;
goto error;
}
}
ioctl(vsp_fd,VSP_ENABLE,NULL);
VSP_SetVirtualBaseAddr((uint32)vsp_addr);
VSP_reg_reset_callback(VSP_reset_cb,vsp_fd);
if(JPEG_SUCCESS != JPEGENC_start_encode(jpegenc_params))
//if(JPEG_SUCCESS != JPEGENC_start_encode_thumbnail(jpegenc_params))
{
SCI_TRACE_LOW("JPEGENC fail to JPEGENC_start_encode.");
ret = -1;
goto error;
}
if(jpegenc_params->height > SLICE_HEIGHT)
{
JPEGENC_Poll_MEA_BSM(0xFFFFFFFF, jpegenc_params->stream_buf_len, callback);
}
g_stream_buf_id = 1;
//poll the end of jpeg encoder
JPEGENC_Poll_VLC_BSM(0xFFFFFFFF, jpegenc_params->stream_buf_len, callback);
if(JPEG_SUCCESS != JPEGENC_stop_encode(jpegenc_params))
{
SCI_TRACE_LOW("JPEGENC fail to JPEGENC_stop_encode.");
ret = -1;
goto error;
}
if(1 == g_stream_buf_id){
callback(0, JPEG_HWGetSize(), 1);
}
else{
callback(1, JPEG_HWGetSize(), 1);
}
error:
ioctl(vsp_fd,VSP_DISABLE,NULL);
ioctl(vsp_fd,VSP_RELEASE,NULL);
if(vsp_fd >= 0){
close(vsp_fd);
}
return ret;
}
/****************************************************************
函数名： CC_CallAlertingInd
功 能 ：CC模块的初始化函数
输入参数：无
输出参数：无
编写者 ：陈海华
修改记录：创建 2007/8/15
****************************************************************/
void CC_Init_Global(void)
{
SCI_TRACE_LOW("<<<<<<ccapp.c:enter function CC_Init_Global<<<<<<");
// 待扩展中
}
/****************************************************************
函数名： CC_ConnectCall
功 能 ：向外拨打电话的处理函数
输入参数：char* src_tele_num-----str格式的电话号码
输出参数：无
编写者 ：郭碧莲
修改记录：创建 2007/8/20
****************************************************************/
CC_RESULT_E CC_ConnectCall(char* src_tele_num)
{
MN_CALL_TYPE_E call_type = MN_CALL_TYPE_NORMAL;
MMI_PARTY_NUMBER_T party_num;
MN_CALLED_NUMBER_T want_to_call_num;
// uint8 i =0;//,*ptr;//,*p;
//check the param
SCI_PASSERT(PNULL != src_tele_num, ("<<<<<<ccapp.c: CC_ConnectCall() tele_num == PNULL"));
SCI_TRACE_LOW("<<<<<<ccapp.c:CC_ConnectCall() tele_num= %s\n", src_tele_num);
// 监听呼出时，关闭 HF_MUTE 端口
if(0 == strcmp(src_tele_num,g_state_info.sListenOutNo))
{
SCI_TRACE_LOW("<<<<<<We are connecting the listen number:%s",g_state_info.sListenOutNo);
#ifndef _TRACK
GPIO_SetValue(HF_MUTE,SCI_TRUE);
#endif
listen = 1;
// memset(g_state_info.sListenOutNo,0,sizeof(g_state_info.sListenOutNo));
}
else// 拨打普通电话，打开 HF_MUTE 端口
{
#ifndef _TRACK
GPIO_SetValue(HF_MUTE,SCI_FALSE);
#endif
}
//convert str to BCD
if( TRUE != MMI_GenPartyNumber((uint8*)src_tele_num, strlen(src_tele_num), &party_num) )
{
#ifdef _TRACK
if(g_state_info.TestFlag == 1)
{
SG_PC_CallOff(0);
}
#endif /* _TRACK */
SCI_TRACE_LOW("<<<<<<ccapp.c: CC_GenPartyNumber return failure");
if(g_set_info.bNewUart4Alarm & UT_GPS && g_set_info.GpsDevType == 1)
{
SG_ZBGPS_ACK(CMD_CALL_OUT, 0x30);
}
return CC_RESULT_ERROR;
}
SCI_MEMCPY(
want_to_call_num.party_num,
party_num.bcd_num,
6
);
want_to_call_num.number_plan=0;
want_to_call_num.number_type=0;
want_to_call_num.num_len = party_num.num_len;
// connect the call
if (MN_RETURN_FAILURE == MNCALL_StartCall( MN_CALL_TYPE_NORMAL,
&want_to_call_num,
PNULL,
MN_CALL_CLIR_NETWORK_DECIDE,
PNULL ))
{
#ifdef _TRACK
if(g_state_info.TestFlag == 1)
{
SG_PC_CallOff(0);
}
#endif /* _TRACK */
if(g_set_info.bNewUart4Alarm & UT_GPS && g_set_info.GpsDevType == 1)
{
SG_ZBGPS_ACK(CMD_CALL_OUT, 0x30);
}
SCI_TRACE_LOW("<<<<<<ccapp.c:CC_ConnectCall() MNCALL_StartCall return failure");
return CC_RESULT_ERROR;
}
else
{
SCI_TRACE_LOW("<<<<<<ccapp.c:CC_ConnectCall():success");
SG_Send_CallStatus(CALL_OUT);
return CC_RESULT_SUCCESS;
}
return CC_RESULT_SUCCESS;
}
LOCAL JPEG_RET_E JPEGENC_start_encode(JPEGENC_PARAMS_T *jpegenc_params)
{
JPEG_RET_E ret_value = JPEG_FAILED;
JPEG_ENC_OUTPUT_PARA_T jpeg_enc_out_param;
JPEG_ENC_INPUT_PARA_T jpeg_enc_fw_info;
APP1_T app1_param;
SCI_MEMSET(&app1_param, 0, sizeof(APP1_T));
if((0 == jpegenc_params->thumb_width) && (0 == jpegenc_params->thumb_height)){
jpegenc_params->stream_size = 0;
}
else{
if(JPEG_SUCCESS != JPEGENC_start_encode_thumbnail(jpegenc_params))
{
SCI_TRACE_LOW("JPEGENC fail to JPEGENC_start_encode_thumbnail.");
return ret_value;
}
}
app1_param.thumb_width = jpegenc_params->thumb_width;
app1_param.thumb_height = jpegenc_params->thumb_height;
app1_param.thumbnail_virt_addr = jpegenc_params->stream_virt_buf[1];
app1_param.thumbnail_len = jpegenc_params->stream_size;
app1_param.Latitude_dd.numerator = jpegenc_params->Latitude_dd.numerator;
app1_param.Latitude_dd.denominator = jpegenc_params->Latitude_dd.denominator;
app1_param.Latitude_mm.numerator = jpegenc_params->Latitude_mm.numerator;
app1_param.Latitude_mm.denominator = jpegenc_params->Latitude_mm.denominator;
app1_param.Latitude_ss.numerator = jpegenc_params->Latitude_ss.numerator;
app1_param.Latitude_ss.denominator = jpegenc_params->Latitude_ss.denominator;
app1_param.Latitude_ref = jpegenc_params->Latitude_ref;
app1_param.Longitude_dd.numerator = jpegenc_params->Longitude_dd.numerator;
app1_param.Longitude_dd.denominator = jpegenc_params->Longitude_dd.denominator;
app1_param.Longitude_mm.numerator = jpegenc_params->Longitude_mm.numerator;
app1_param.Longitude_mm.denominator = jpegenc_params->Longitude_mm.denominator;
app1_param.Longitude_ss.numerator = jpegenc_params->Longitude_ss.numerator;
app1_param.Longitude_ss.denominator = jpegenc_params->Longitude_ss.denominator;
app1_param.Longitude_ref = jpegenc_params->Longitude_ref;
app1_param.image_description = jpegenc_params->image_description;
app1_param.make = jpegenc_params->make;
app1_param.model = jpegenc_params->model;
app1_param.copyright = jpegenc_params->copyright;
app1_param.orientation = jpegenc_params->orientation;
app1_param.datetime = jpegenc_params->datetime;
app1_param.gps_date = jpegenc_params->gps_date;
app1_param.gps_process_method = jpegenc_params->gps_process_method;
app1_param.gps_hour = jpegenc_params->gps_hour;
app1_param.gps_minuter = jpegenc_params->gps_minuter;
app1_param.gps_second = jpegenc_params->gps_second;
app1_param.image_width = jpegenc_params->width;
app1_param.image_height = jpegenc_params->height;
app1_param.focal_length.numerator = jpegenc_params->focal_length.numerator;
app1_param.focal_length.denominator = jpegenc_params->focal_length.denominator;
jpegenc_params->stream_size = 0;
SCI_TRACE_LOW("JPEGENC ok to JPEGENC_start_encode_thumbnail.addr: 0x%x, len: 0x%x.", (uint32_t)app1_param.thumbnail_virt_addr, app1_param.thumbnail_len);
SCI_PASSERT(jpegenc_params, ("[JPEG_6600L_StartEncode], context_ptr is NULL"));
SCI_MEMSET(&jpeg_enc_out_param, 0, sizeof(JPEG_ENC_OUTPUT_PARA_T));
SCI_MEMSET(&jpeg_enc_fw_info, 0, sizeof(JPEG_ENC_INPUT_PARA_T));
JPEGENC_init_fw_param(jpegenc_params, &jpeg_enc_fw_info);
ret_value = JPEG_HWEncInit(&jpeg_enc_fw_info);
if(JPEG_SUCCESS != ret_value)
{
SCI_TRACE_LOW("JPEG_HWEncInit failed = %d", ret_value);
return ret_value;
}
ret_value = JPEG_HWWriteHead(&app1_param);
//ret_value = JPEG_HWWriteHead();
if(JPEG_SUCCESS != ret_value)
{
SCI_TRACE_LOW("JPEG_HWWriteHead failed = %d", ret_value);
return ret_value;
}
SCI_TRACE_LOW("[JPEG_6600L_StartEncode] hardware write head done");
/*the input width must be mcu aligned width*/
if(jpegenc_params->height > SLICE_HEIGHT){//wxz:????
ret_value = JPEG_HWEncStart(jpegenc_params->width, SLICE_HEIGHT, &jpeg_enc_out_param);
}
else{
ret_value = JPEG_HWEncStart(jpegenc_params->width, jpegenc_params->height, &jpeg_enc_out_param);
}
SCI_TRACE_LOW("[JPEG_6600L_StartEncode] start enc, src_aligned_width = %d, slice height = %d",
jpegenc_params->width, jpegenc_params->height);
return ret_value;
}
LOCAL JPEG_RET_E JPEGENC_start_encode_thumbnail(JPEGENC_PARAMS_T *jpegenc_params)
{
JPEG_RET_E ret_value = JPEG_FAILED;
JPEG_ENC_OUTPUT_PARA_T jpeg_enc_out_param;
JPEG_ENC_INPUT_PARA_T jpeg_enc_fw_info;
SCALE_PARAM_T scale_param;
JPEGENC_PARAMS_T jpegenc_params_tmp;
SCI_PASSERT(jpegenc_params, ("[JPEG_6600L_StartEncodeThumbnail], context_ptr is NULL"));
//scale down the original yuv data to 176x144 size.
SCI_MEMSET(&scale_param, 0, sizeof(SCALE_PARAM_T));
scale_param.in_addr.yaddr = jpegenc_params->yuv_phy_buf;
scale_param.in_addr.uaddr = scale_param.in_addr.yaddr + jpegenc_params->width * jpegenc_params->height;
scale_param.in_addr.vaddr = 0;
scale_param.in_fmt = jpegenc_params->format;
scale_param.in_size.w = jpegenc_params->width;
scale_param.in_size.h = jpegenc_params->height;
scale_param.in_rect.x = 0;
scale_param.in_rect.y = 0;
scale_param.in_rect.w = jpegenc_params->width;
scale_param.in_rect.h = jpegenc_params->height;
scale_param.out_size.w = jpegenc_params->thumb_width;
scale_param.out_size.h = jpegenc_params->thumb_height;
//use the second stream bufffer as the scale output buffer.
scale_param.out_addr.yaddr = jpegenc_params->stream_phy_buf[0];
scale_param.out_addr.uaddr = scale_param.out_addr.yaddr + scale_param.out_size.w * scale_param.out_size.h;
scale_param.out_addr.vaddr = 0;
scale_param.out_fmt = jpegenc_params->format;
ret_value = JPEGENC_Scale_For_Thumbnail(&scale_param);
if(JPEG_SUCCESS != ret_value)
{
SCI_TRACE_LOW("JPEGENC_Scale_For_Thumbnail = %d", ret_value);
return ret_value;
}
#if 0
{
FILE *fp = NULL;
SCI_TRACE_LOW("cap yuv420: width: %d, hei: %d.", scale_param.out_size.w, scale_param.out_size.h);
fp = fopen("/data/out_enc_yuv420.yuv", "wb");
fwrite(jpegenc_params->stream_virt_buf[1], 1, scale_param.out_size.w * scale_param.out_size.h * 3 / 2, fp);
fclose(fp);
}
#endif
SCI_MEMSET(&jpeg_enc_out_param, 0, sizeof(JPEG_ENC_OUTPUT_PARA_T));
SCI_MEMSET(&jpeg_enc_fw_info, 0, sizeof(JPEG_ENC_INPUT_PARA_T));
SCI_MEMCPY(&jpegenc_params_tmp, jpegenc_params, sizeof(JPEGENC_PARAMS_T));
//update the jpegenc_params_tmp
jpegenc_params_tmp.width = scale_param.out_size.w;
jpegenc_params_tmp.height = scale_param.out_size.h;
jpegenc_params_tmp.yuv_phy_buf = scale_param.out_addr.yaddr;
jpegenc_params_tmp.stream_phy_buf[0] = jpegenc_params->stream_phy_buf[1];
jpegenc_params_tmp.quality = jpegenc_params->thumb_quality;
JPEGENC_init_fw_param(&jpegenc_params_tmp, &jpeg_enc_fw_info);
ret_value = JPEG_HWEncInit(&jpeg_enc_fw_info);
if(JPEG_SUCCESS != ret_value)
{
SCI_TRACE_LOW("JPEG_HWEncInit failed for thubmnail = %d", ret_value);
return ret_value;
}
ret_value = JPEG_HWWriteHeadForThumbnail();
if(JPEG_SUCCESS != ret_value)
{
SCI_TRACE_LOW("JPEG_HWWriteHead for thumbnail failed = %d", ret_value);
return ret_value;
}
//jpegenc_params->stream_size = JPEG_HWGetSize();
#if 0
{
FILE *fp = NULL;
SCI_TRACE_LOW("thumb size head: %d.", jpegenc_params->stream_size);
fp = fopen("/data/out_thumb_head.jpg", "wb");
fwrite(jpegenc_params->stream_virt_buf[1], 1, jpegenc_params->stream_size, fp);
fclose(fp);
}
#endif
/*ret_value = JPEG_HWWriteHead( );
if(JPEG_SUCCESS != ret_value)
{
SCI_TRACE_LOW("JPEG_HWWriteHead failed for thumbnail = %d", ret_value);
return ret_value;
}*/
/*the input width must be mcu aligned width*/
//wxz20110922: the thumbnail height must less than SLICE_HEIGHT(1024).
ret_value = JPEG_HWEncStart(jpegenc_params_tmp.width, jpegenc_params_tmp.height, &jpeg_enc_out_param);
SCI_TRACE_LOW("[JPEG_6600L_StartEncode for thumbnail] start enc, src_aligned_width = %d, slice height = %d",
jpegenc_params_tmp.width, jpegenc_params_tmp.height);
//poll the end of jpeg encoder
JPEGENC_Poll_VLC_BSM(0xFFFFFFFF, jpegenc_params_tmp.stream_buf_len, NULL);
/*if(JPEG_SUCCESS != JPEGENC_stop_encode(&jpegenc_params_tmp))
{
SCI_TRACE_LOW("JPEGENC fail to JPEGENC_stop_encode for thumbnail.");
return ret_value;
}*/
ret_value = JPEG_HWWriteTail();
if(JPEG_SUCCESS != ret_value)
{
SCI_TRACE_LOW("JPEG_HWWriteTail for thumbnail failed = %d", ret_value);
return ret_value;
}
jpegenc_params->stream_size = JPEG_HWGetSize();
#if 0
{
FILE *fp = NULL;
SCI_TRACE_LOW("thumb size: %d.", jpegenc_params->stream_size);
fp = fopen("/data/out_thumb.jpg", "wb");
fwrite(jpegenc_params->stream_virt_buf[1], 1, jpegenc_params->stream_size, fp);
fclose(fp);
}
#endif
return ret_value;
}
LOCAL JPEG_RET_E JPEGENC_Scale_For_Thumbnail(SCALE_PARAM_T *scale_param)
{
static int fd = -1;
SCALE_CONFIG_T scale_config;
SCALE_MODE_E scale_mode;
uint32_t enable = 0, endian_mode;
fd = open("/dev/sc8800g_scale", O_RDONLY);//O_RDWR /* required */, 0);
if (-1 == fd)
{
SCI_TRACE_LOW("Fail to open scale device.");
return JPEG_FAILED;
}
//set mode
scale_config.id = SCALE_PATH_MODE;
scale_mode = SCALE_MODE_SCALE;
scale_config.param = &scale_mode;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
//set input data format
scale_config.id = SCALE_PATH_INPUT_FORMAT;
scale_config.param = &scale_param->in_fmt;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
//set output data format
scale_config.id = SCALE_PATH_OUTPUT_FORMAT;
scale_config.param = &scale_param->out_fmt;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
//set input size
scale_config.id = SCALE_PATH_INPUT_SIZE;
scale_config.param = &scale_param->in_size;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
//set output size
scale_config.id = SCALE_PATH_OUTPUT_SIZE;
scale_config.param = &scale_param->out_size;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
//set input size
scale_config.id = SCALE_PATH_INPUT_RECT;
scale_config.param = &scale_param->in_rect;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
//set input address
scale_config.id = SCALE_PATH_INPUT_ADDR;
scale_config.param = &scale_param->in_addr;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
//set output address
scale_config.id = SCALE_PATH_OUTPUT_ADDR;
scale_config.param = &scale_param->out_addr;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
if((scale_param->in_rect.w > scale_param->out_size.w * 4) ||
(scale_param->in_rect.h > scale_param->out_size.h * 4))
{
//set sub sample mode
uint32_t mode = 0; //0: 1/2 1:1/4 2:1/8 3:1/16
uint32_t enable = 1;
if((scale_param->in_rect.w <= scale_param->out_size.w * 4 * 2) &&
(scale_param->in_rect.h <= scale_param->out_size.h * 4 * 2)){
mode = 0;
}
else if((scale_param->in_rect.w <= scale_param->out_size.w * 4 * 4) &&
(scale_param->in_rect.h <= scale_param->out_size.h * 4 * 4)){
mode = 1;
}
else if((scale_param->in_rect.w <= scale_param->out_size.w * 4 * 8) &&
(scale_param->in_rect.h <= scale_param->out_size.h * 4 * 8)){
mode = 2;
}
else if((scale_param->in_rect.w <= scale_param->out_size.w * 4 * 16) &&
(scale_param->in_rect.h <= scale_param->out_size.h * 4 * 16)){
mode = 3;
}
scale_config.id = SCALE_PATH_SUB_SAMPLE_EN;
scale_config.param = &enable;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
scale_config.id = SCALE_PATH_SUB_SAMPLE_MOD;
scale_config.param = &mode;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
}
//set input endian
scale_config.id = SCALE_PATH_INPUT_ENDIAN;
endian_mode = 1;
scale_config.param = &endian_mode;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
//set output endian
scale_config.id = SCALE_PATH_OUTPUT_ENDIAN;
endian_mode = 1;
scale_config.param = &endian_mode;
if (-1 == xioctl(fd, SCALE_IOC_CONFIG, &scale_config))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_CONFIG: id=%d", scale_config.id);
return JPEG_FAILED;
}
//done
if (-1 == xioctl(fd, SCALE_IOC_DONE, 0))
{
SCI_TRACE_LOW("Fail to SCALE_IOC_DONE");
return JPEG_FAILED;
}
if(-1 == close(fd))
{
SCI_TRACE_LOW("Fail to close scale device.");
return JPEG_FAILED;
}
fd = -1;
return JPEG_SUCCESS;
}
/****************************************************************
函数名： MnCall_EventCallback
功 能 ：电话相关业务的callback函数
输入参数：uint32 event_id 事件的id
uint32 task_id
void* param_ptr
输出参数：无
编写者 ：陈海华
修改记录：创建 2007/8/15
****************************************************************/
void MnCall_EventCallback(
uint32 task_id, //task ID
uint32 event_id, //event ID
void* param_ptr
)
{
SCI_ASSERT(PNULL != param_ptr);
if( PNULL == param_ptr )
{
SCI_TRACE_HIGH("<<<<<<MnCall_EventCallback: the ponit of param is empty");
return;
}
switch(event_id)
{
/*
EV_MN_APP_CALL_START_IND_F = (MN_APP_CALL_SERVICE << 8),
EV_MN_APP_ALERTING_IND_F,
EV_MN_APP_SETUP_COMPLETE_IND_F,
EV_MN_APP_SETUP_COMPLETE_CNF_F,
EV_MN_APP_CALL_DISCONNECTED_IND_F,
EV_MN_APP_CALL_ERR_IND_F,
EV_MN_APP_SETUP_IND_F,
EV_MN_APP_HELD_CNF_F,
EV_MN_APP_HELD_IND_F,
EV_MN_APP_START_DTMF_CNF_F,
EV_MN_APP_STOP_DTMF_CNF_F,
EV_MN_APP_SYNC_IND_F,
EV_MN_APP_RETRIEVED_CNF_F,
EV_MN_APP_RETRIEVED_IND_F,
EV_MN_APP_ACMMAX_IND_F,
EV_MN_APP_PROGRESS_IND_F,
EV_MN_APP_USERTOUSER_IND_F,
EV_MN_APP_MODIFY_CNF_F,
EV_MN_APP_MODIFY_IND_F,
EV_MN_APP_FORWARD_IND_F,
EV_MN_APP_CALL_WAIT_IND_F,
EV_MN_APP_CALL_BARRY_IND_F,
EV_MN_APP_BUILD_MPTY_CNF_F,
EV_MN_APP_BUILD_MPTY_IND_F,
EV_MN_APP_SPLIT_MPTY_CNF_F,
EV_MN_APP_SPLIT_MPTY_IND_F,
EV_MN_APP_FORWARD_STATUS_IND_F,
EV_MN_APP_CONNECTING_IND_F,
EV_MN_APP_DISCONNECTING_IND_F,
EV_MN_APP_HOLDING_IND_F,
EV_MN_APP_RETRIEVING_IND_F,
EV_MN_APP_BUILDING_MPTY_IND_F,
EV_MN_APP_SPLITTING_MPTY_IND_F,
EV_MN_APP_CALL_READY_IND_F,
EV_MN_APP_DISC_INFO_IND_F,
MAX_MN_APP_CALL_EVENTS_NUM,
*/
case EV_MN_APP_CALL_START_IND_F:
//收到分配CALL ID事件的处理，判断是否在允许接入列表中
SCI_TRACE_LOW("<<<<<<EV_MN_APP_CALL_START_IND_F<<<<<<");
if(PhoneAllow==1)
{
PhoneAllow = 0;
SG_Send_CallStatus(CAll_OFF);
PhoneFlag = 0;
if(g_set_info.bNewUart4Alarm & UT_GPS && g_set_info.GpsDevType == 1)
{
SG_ZBGPS_ACK(CMD_CALL_OUT, 0x01);
}
return;
}
PhoneFlag = 1;
g_state_info.SendSMSFlag = 1;
if(listen == 1)
{
listen = 0;
AUD_SetDevMode(AUD_DEV_MODE_HANDFREE);
AUD_SetVolume(AUD_DEV_MODE_HANDFREE, AUD_TYPE_VOICE, g_set_info.speaker_vol); // 设置音量为免提时音量
}
else if(g_set_info.bAutoAnswerDisable) // 禁止自动接听
{
AUD_SetDevMode(AUD_DEV_MODE_HANDHOLD);
AUD_SetVolume(AUD_DEV_MODE_HANDHOLD, AUD_TYPE_VOICE, g_set_info.speaker_vol); // 设置音量为免提时音量
}
else
{
AUD_SetDevMode(AUD_DEV_MODE_HANDFREE);
AUD_SetVolume(AUD_DEV_MODE_HANDFREE, AUD_TYPE_VOICE, g_set_info.speaker_vol); // 设置音量为免提时音量
}
if(g_set_info.bNewUart4Alarm & UT_GPS && g_set_info.GpsDevType == 1)
{
SG_ZBGPS_ACK(CMD_CALL_OUT, 0x00);
}
AUD_EnableVoiceCodec( 1 );
break;
case EV_MN_APP_ALERTING_IND_F:
//收到振铃提示事件的处理
SCI_TRACE_LOW("<<<<<<EV_MN_APP_ALERTING_IND_F<<<<<<");
CC_CallAlertingInd(param_ptr);
break;
case EV_MN_APP_SETUP_COMPLETE_IND_F:
//收到建立连接完成事件（MT）的处理
SCI_TRACE_LOW("<<<<<<EV_MN_APP_SETUP_COMPLETE_IND_F<<<<<<");
if (CallInListen == 1) // 呼入监听
{
CallInListen = 0;
AUD_SetDevMode(AUD_DEV_MODE_HANDFREE);
AUD_SetVolume(AUD_DEV_MODE_HANDFREE, AUD_TYPE_VOICE, g_set_info.speaker_vol); // 设置音量为免提时音量
PhoneFlag = 2;
break;
}
else if(g_set_info.bAutoAnswerDisable) // 禁止自动接听
{
AUD_SetDevMode(AUD_DEV_MODE_HANDHOLD);
AUD_SetVolume(AUD_DEV_MODE_HANDHOLD, AUD_TYPE_VOICE, g_set_info.speaker_vol); // 设置音量为免提时音量
}
else
{
AUD_SetDevMode(AUD_DEV_MODE_HANDFREE);
AUD_SetVolume(AUD_DEV_MODE_HANDFREE, AUD_TYPE_VOICE, g_set_info.speaker_vol); // 设置音量为免提时音量
}
if(g_set_info.bNewUart4Alarm & UT_GPS && g_set_info.GpsDevType == 2)
{
GpsDev_SendAnsCall();
}
SG_Send_CallStatus(CALL_SPEAK);
if(g_set_info.bNewUart4Alarm & UT_GPS && g_set_info.GpsDevType == 1)
{
ZBGpsDev_SendAnsCall();
}
PhoneFlag = 2;
break;
case EV_MN_APP_SYNC_IND_F:
//收到信道分配事件的处理
SCI_TRACE_LOW("<<<<<<EV_MN_APP_SYNC_IND_F<<<<<<");
break;
case EV_MN_APP_SETUP_COMPLETE_CNF_F:
//收到建立连接完成事件（MO）的处理
SCI_TRACE_LOW("<<<<<<EV_MN_APP_SETUP_COMPLETE_CNF_F<<<<<<");
SG_Send_CallStatus(CALL_SPEAK); // 向手柄发送正在通话中的状态
PhoneFlag = 2;
if(g_set_info.bNewUart4Alarm & UT_GPS && g_set_info.GpsDevType == 2)
{
GpsDev_SendAnsCall();
}
if(g_set_info.bNewUart4Alarm & UT_GPS && g_set_info.GpsDevType == 1)
{
ZBGpsDev_SendAnsCall();
}
break;
case EV_MN_APP_CALL_DISCONNECTED_IND_F:
//收到CALL中断事件的处理
SCI_TRACE_LOW("<<<<<<EV_MN_APP_CALL_DISCONNECTED_IND_F<<<<<<");
Call_Discon_Handle();
g_state_info.SendSMSFlag = 0;
break;
case EV_MN_APP_CALL_ERR_IND_F:
//收到网络错误事件的处理
SCI_TRACE_LOW("<<<<<<EV_MN_APP_CALL_ERR_IND_F<<<<<<");
Call_Err_Handle();
g_state_info.SendSMSFlag = 0;
break;
case EV_MN_APP_SETUP_IND_F:
//收到来电事件的处理
SCI_TRACE_LOW("<<<<<<<EV_MN_APP_SETUP_IND_F<<<<<<");
ConnectPhoneTimer = 1;
PhoneFlag = 1;
g_state_info.SendSMSFlag = 1;
CC_CallSetupInd(param_ptr);
break;
case EV_MN_APP_HELD_CNF_F:
//receive the cofirm about hold call
SCI_TRACE_LOW("<<<<<<EV_MN_APP_HELD_CNF_F<<<<<<");
break;
default:
SCI_TRACE_LOW("<<<<<<ccapp.c: CC_HandlePsMsg() CC isn't process, msg_id = %d", event_id);
break;
}
}
