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 JPEGDEC_start_decode(JPEGDEC_PARAMS_T *jpegdec_params)
{
JPEG_RET_E ret_value = JPEG_FAILED;
JPEG_DEC_OUTPUT_PARA_T jpeg_dec_out_param;
JPEG_DEC_INPUT_PARA_T jpeg_dec_fw_info;
uint32_t slice_height = SLICE_HEIGHT;
if(0 != jpegdec_params->set_slice_height)
{
slice_height = jpegdec_params->set_slice_height;
}
SCI_TRACE_LOW("enter [JPEG_StartDecode] ---1 ");
SCI_PASSERT(jpegdec_params, ("[JPEG_6600L_StartDecode], context_ptr is NULL"));
SCI_TRACE_LOW("enter [JPEG_StartDecode] ---2 ");
SCI_MEMSET(&jpeg_dec_out_param, 0, sizeof(JPEG_DEC_OUTPUT_PARA_T));
SCI_MEMSET(&jpeg_dec_fw_info, 0, sizeof(JPEG_DEC_INPUT_PARA_T));
JPEGDEC_init_fw_param(jpegdec_params, &jpeg_dec_fw_info);
ret_value = JPEG_FWParseHead(&jpeg_dec_fw_info);
if(JPEG_SUCCESS != ret_value)
{
JPEG_PRINT(("[JPEG_StartDecode] JPEG_HWParseHead failed = %d", ret_value));
return ret_value;
}
jpegdec_params->header_len = jpeg_dec_fw_info.header_len;
#if 0
JPEG_Mem_Copy( jpegdec_params , 0 );
#endif
SCI_TRACE_LOW("enter [JPEG_FWInitDecInput] ");
ret_value = JPEG_FWInitDecInput(&jpeg_dec_fw_info);
if(JPEG_SUCCESS != ret_value)
{
SCI_TRACE_LOW("JPEG_HWDecInit failed = %d", ret_value);
return ret_value;
}
SCI_TRACE_LOW("enter [JPEG_HWDecInit] ");
ret_value = JPEG_HWDecInit(&jpeg_dec_fw_info);
if(JPEG_SUCCESS != ret_value)
{
SCI_TRACE_LOW("JPEG_HWWriteHead failed = %d", ret_value);
return ret_value;
}
SCI_TRACE_LOW("[JPEG_6600L_StartDecode] hardware write head done,hear_len=%d",jpeg_dec_fw_info.header_len);
/*the input width must be mcu aligned width*/
SCI_TRACE_LOW("enter [JPEG_HWDecStart] ");
if(jpegdec_params->height > SLICE_HEIGHT){
ret_value = JPEG_HWDecStart(slice_height, &jpeg_dec_out_param);
}
else{
ret_value = JPEG_HWDecStart(jpegdec_params->height,&jpeg_dec_out_param);
}
SCI_TRACE_LOW("[JPEG_6600L_StartDecode] start dec, src_aligned_width = %d, slice height = %d",
jpegdec_params->width, jpegdec_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;
}
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;
}
