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;
}
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;
}
/****************************************************************
函数名： 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;
}
PUBLIC JPEG_RET_E JpegEnc_InitParam(JPEG_ENC_INPUT_PARA_T *input_para_ptr)
{
int32 h_ratio_max, v_ratio_max;
JPEG_CODEC_T *jpeg_fw_codec = Get_JPEGEncCodec();
SCI_ASSERT(jpeg_fw_codec != PNULL);
SCI_ASSERT(input_para_ptr != PNULL);
//check the input parameter!
if((input_para_ptr->yuv_0_info.input_mcu_info != JPEG_FW_YUV422) &&(input_para_ptr->yuv_0_info.input_mcu_info != JPEG_FW_YUV420) &&
(input_para_ptr->yuv_1_info.input_mcu_info != JPEG_FW_YUV422) &&(input_para_ptr->yuv_1_info.input_mcu_info != JPEG_FW_YUV420) )
{
JPEG_TRACE("mcu information is not valid, only supported yuv422 or yuv420\n");
return JPEG_FAILED;
}
if(jpeg_fw_codec->compress_level > JPEG_QUALITY_MAX)
{
JPEG_TRACE("Quant level is not valid, please set right value from [0,4]\n");
return JPEG_FAILED;
}
if((input_para_ptr->width < 1)||(input_para_ptr->height < 1))
{
JPEG_TRACE("Too small image size!\n");
return JPEG_FAILED;
}
SCI_MEMSET(jpeg_fw_codec, 0, (sizeof(JPEG_CODEC_T)));
jpeg_fw_codec->RST_Count = M_RST0;
jpeg_fw_codec->mbio_bfr0_valid = TRUE;
jpeg_fw_codec->mbio_bfr1_valid = FALSE;
//Load parameter into JPEG Codec
jpeg_fw_codec->work_mode = (uint8)input_para_ptr->work_mode;
jpeg_fw_codec->is_first_slice = input_para_ptr->is_first_slice;
jpeg_fw_codec->is_last_slice = input_para_ptr->is_last_slice;
jpeg_fw_codec->input_mcu_info = (uint8)(input_para_ptr->yuv_0_info.input_mcu_info);
jpeg_fw_codec->width = (uint16)input_para_ptr->width;
jpeg_fw_codec->height = (uint16)input_para_ptr->height;
jpeg_fw_codec->compress_level = input_para_ptr->quant_level;
SCI_MEMCPY(&(jpeg_fw_codec->YUV_Info_0), &(input_para_ptr->yuv_0_info), (sizeof(YUV_FORMAT_T)));
SCI_MEMCPY(&(jpeg_fw_codec->YUV_Info_1), &(input_para_ptr->yuv_1_info), (sizeof(YUV_FORMAT_T)));
jpeg_fw_codec->stream_0 = input_para_ptr->stream_buf0;
jpeg_fw_codec->stream_1 = input_para_ptr->stream_buf1;
jpeg_fw_codec->pingpang_buf_len = input_para_ptr->bitstream_buf_len;
//.....
jpeg_fw_codec->dc_huff_tbl[JPEG_FW_LUM_ID].bits = &jpeg_fw_lum_dc_bits_default[0];
jpeg_fw_codec->dc_huff_tbl[JPEG_FW_LUM_ID].huffval = &jpeg_fw_lum_dc_huffvalue_default[0];
jpeg_fw_codec->ac_huff_tbl[JPEG_FW_LUM_ID].bits = &jpeg_fw_lum_ac_bits_default[0];
jpeg_fw_codec->ac_huff_tbl[JPEG_FW_LUM_ID].huffval = &jpeg_fw_lum_ac_huffvalue_default[0];
jpeg_fw_codec->dc_huff_tbl[JPEG_FW_CHR_ID].bits = &jpeg_fw_chr_dc_bits_default[0];
jpeg_fw_codec->dc_huff_tbl[JPEG_FW_CHR_ID].huffval = &jpeg_fw_chr_dc_huffvalue_default[0];
jpeg_fw_codec->ac_huff_tbl[JPEG_FW_CHR_ID].bits = &jpeg_fw_chr_ac_bits_default[0];
jpeg_fw_codec->ac_huff_tbl[JPEG_FW_CHR_ID].huffval = &jpeg_fw_chr_ac_huffvalue_default[0];
jpeg_fw_codec->restart_interval = input_para_ptr->restart_interval;
jpeg_fw_codec->restart_to_go = 0;
jpeg_fw_codec->next_restart_num = 0;
/*init sample ratio*/
switch(jpeg_fw_codec->input_mcu_info)
{
case JPEG_FW_YUV420:
jpeg_fw_codec->ratio[JPEG_FW_Y_ID].h_ratio = 2;
jpeg_fw_codec->ratio[JPEG_FW_Y_ID].v_ratio = 2;
jpeg_fw_codec->ratio[JPEG_FW_U_ID].h_ratio = 1;
jpeg_fw_codec->ratio[JPEG_FW_U_ID].v_ratio = 1;
jpeg_fw_codec->ratio[JPEG_FW_V_ID].h_ratio = 1;
jpeg_fw_codec->ratio[JPEG_FW_V_ID].v_ratio = 1;
break;
case JPEG_FW_YUV422:
jpeg_fw_codec->ratio[JPEG_FW_Y_ID].h_ratio = 2;
jpeg_fw_codec->ratio[JPEG_FW_Y_ID].v_ratio = 1;
jpeg_fw_codec->ratio[JPEG_FW_U_ID].h_ratio = 1;
jpeg_fw_codec->ratio[JPEG_FW_U_ID].v_ratio = 1;
jpeg_fw_codec->ratio[JPEG_FW_V_ID].h_ratio = 1;
jpeg_fw_codec->ratio[JPEG_FW_V_ID].v_ratio = 1;
break;
default:
return JPEG_FAILED;
}
/*get the mcu size*/
v_ratio_max = JPEG_FW_MAX3(jpeg_fw_codec->ratio[JPEG_FW_Y_ID].v_ratio, jpeg_fw_codec->ratio[JPEG_FW_U_ID].v_ratio, jpeg_fw_codec->ratio[JPEG_FW_V_ID].v_ratio);
h_ratio_max = JPEG_FW_MAX3(jpeg_fw_codec->ratio[JPEG_FW_Y_ID].h_ratio, jpeg_fw_codec->ratio[JPEG_FW_U_ID].h_ratio, jpeg_fw_codec->ratio[JPEG_FW_V_ID].h_ratio);
jpeg_fw_codec->mcu_height = 8 * v_ratio_max;
jpeg_fw_codec->mcu_width = 8 * h_ratio_max;
jpeg_fw_codec->mcu_num_x = (jpeg_fw_codec->width + jpeg_fw_codec->mcu_width -1)/jpeg_fw_codec->mcu_width;
jpeg_fw_codec->mcu_num_y = (jpeg_fw_codec->height + jpeg_fw_codec->mcu_height -1)/jpeg_fw_codec->mcu_height;
//Adjusted image width and height
jpeg_fw_codec->c_width = jpeg_fw_codec->mcu_num_x * jpeg_fw_codec->mcu_width;
jpeg_fw_codec->c_height = jpeg_fw_codec->mcu_num_y * jpeg_fw_codec->mcu_height;
return JPEG_SUCCESS;
}
