static u32 ddl_header_done_callback(struct ddl_context *ddl_context) { struct ddl_client_context *ddl = ddl_context->current_ddl; struct ddl_decoder_data *decoder; struct vidc_720p_seq_hdr_info seq_hdr_info; u32 process_further = true; u32 seq_hdr_only_frame = false; u32 need_reconfig = true; struct vcd_frame_data *input_vcd_frm; struct ddl_frame_data_tag *reconfig_payload = NULL; u32 reconfig_payload_size = 0; if (!ddl || !ddl->decoding || !DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODECDONE) ) { VIDC_LOG_STRING("STATE-CRITICAL-HDDONE"); ddl_client_fatal_cb(ddl_context); return true; } if (vidc_msg_timing) ddl_calc_core_proc_time(__func__, DEC_OP_TIME); ddl_move_command_state(ddl_context, DDL_CMD_INVALID); ddl_move_client_state(ddl, DDL_CLIENT_WAIT_FOR_DPB); VIDC_LOG_STRING("HEADER_DONE"); VIDC_DEBUG_REGISTER_LOG; vidc_720p_decode_get_seq_hdr_info(&seq_hdr_info); decoder = &(ddl->codec_data.decoder); decoder->frame_size.width = seq_hdr_info.img_size_x; decoder->frame_size.height = seq_hdr_info.img_size_y; decoder->min_dpb_num = seq_hdr_info.min_num_dpb; decoder->y_cb_cr_size = seq_hdr_info.min_dpb_size; decoder->progressive_only = 1 - seq_hdr_info.progressive; if (!seq_hdr_info.img_size_x || !seq_hdr_info.img_size_y) { VIDC_LOGERR_STRING("FATAL: ZeroImageSize"); ddl_client_fatal_cb(ddl_context); return process_further; } if (seq_hdr_info.data_partitioned == 0x1 && decoder->codec.codec == VCD_CODEC_MPEG4 && seq_hdr_info.img_size_x > DDL_MAX_DP_FRAME_WIDTH && seq_hdr_info.img_size_y > DDL_MAX_DP_FRAME_HEIGHT) { ddl_client_fatal_cb(ddl_context); return process_further; } ddl_getdec_profilelevel(decoder, seq_hdr_info.profile, seq_hdr_info.level); ddl_calculate_stride(&decoder->frame_size, !decoder->progressive_only, decoder->codec.codec); if (seq_hdr_info.crop_exists) { decoder->frame_size.width -= (seq_hdr_info.crop_right_offset + seq_hdr_info.crop_left_offset); decoder->frame_size.height -= (seq_hdr_info.crop_top_offset + seq_hdr_info.crop_bottom_offset); } ddl_set_default_decoder_buffer_req(decoder, false); if (decoder->header_in_start) { decoder->client_frame_size = decoder->frame_size; decoder->client_output_buf_req = decoder->actual_output_buf_req; decoder->client_input_buf_req = decoder->actual_input_buf_req; ddl_context->ddl_callback(VCD_EVT_RESP_START, VCD_S_SUCCESS, NULL, 0, (u32 *) ddl, ddl_context->client_data); DDL_IDLE(ddl_context); } else { DBG("%s(): Client data: WxH(%u x %u) SxSL(%u x %u) Sz(%u)\n", __func__, decoder->client_frame_size.width, decoder->client_frame_size.height, decoder->client_frame_size.stride, decoder->client_frame_size.scan_lines, decoder->client_output_buf_req.sz); DBG("%s(): DDL data: WxH(%u x %u) SxSL(%u x %u) Sz(%u)\n", __func__, decoder->frame_size.width, decoder->frame_size.height, decoder->frame_size.stride, decoder->frame_size.scan_lines, decoder->actual_output_buf_req.sz); DBG("%s(): min_dpb_num = %d actual_count = %d\n", __func__, decoder->min_dpb_num, decoder->client_output_buf_req.actual_count); input_vcd_frm = &(ddl->input_frame.vcd_frm); if (decoder->frame_size.width == decoder->client_frame_size.width && decoder->frame_size.height == decoder->client_frame_size.height && decoder->frame_size.stride == decoder->client_frame_size.stride && decoder->frame_size.scan_lines == decoder->client_frame_size.scan_lines && decoder->actual_output_buf_req.sz <= decoder->client_output_buf_req.sz && decoder->actual_output_buf_req.actual_count <= decoder->client_output_buf_req.actual_count && decoder->progressive_only) need_reconfig = false; if ((input_vcd_frm->data_len == seq_hdr_info.dec_frm_size || (input_vcd_frm->flags & VCD_FRAME_FLAG_CODECCONFIG)) && (!need_reconfig || !(input_vcd_frm->flags & VCD_FRAME_FLAG_EOS))) { input_vcd_frm->flags |= VCD_FRAME_FLAG_CODECCONFIG; seq_hdr_only_frame = true; ddl->input_frame.frm_trans_end = !need_reconfig; ddl_context->ddl_callback( VCD_EVT_RESP_INPUT_DONE, VCD_S_SUCCESS, &ddl->input_frame, sizeof(struct ddl_frame_data_tag), (u32 *) ddl, ddl->ddl_context->client_data); } else if (decoder->codec.codec != VCD_CODEC_H263) { input_vcd_frm->offset += seq_hdr_info.dec_frm_size; input_vcd_frm->data_len -= seq_hdr_info.dec_frm_size; } if (need_reconfig) { decoder->client_frame_size = decoder->frame_size; decoder->client_output_buf_req = decoder->actual_output_buf_req; decoder->client_input_buf_req = decoder->actual_input_buf_req; if (!seq_hdr_only_frame) { reconfig_payload = &ddl->input_frame; reconfig_payload_size = sizeof(struct ddl_frame_data_tag); } ddl_context->ddl_callback(VCD_EVT_IND_OUTPUT_RECONFIG, VCD_S_SUCCESS, reconfig_payload, reconfig_payload_size, (u32 *) ddl, ddl_context->client_data); } if (!need_reconfig && !seq_hdr_only_frame) { if (ddl_decode_set_buffers(ddl) == VCD_S_SUCCESS) process_further = false; else ddl_client_fatal_cb(ddl_context); } else DDL_IDLE(ddl_context); } return process_further; }
static u32 ddl_header_done_callback(struct ddl_context_type *p_ddl_context) { struct ddl_client_context_type *p_ddl = p_ddl_context->p_current_ddl; struct ddl_decoder_data_type *p_decoder; struct vidc_720p_seq_hdr_info_type seq_hdr_info; u32 b_process_further = TRUE; u32 b_seq_hdr_only_frame = FALSE; u32 b_need_reconfig = TRUE; struct vcd_frame_data_type *p_input_vcd_frm; struct ddl_frame_data_type_tag *p_reconfig_payload; u32 reconfig_payload_size; if (!p_ddl || !p_ddl->b_decoding || !DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_INITCODECDONE) ) { VIDC_LOG_STRING("STATE-CRITICAL-HDDONE"); ddl_client_fatal_cb(p_ddl_context); return TRUE; } ddl_move_command_state(p_ddl_context, DDL_CMD_INVALID); ddl_move_client_state(p_ddl, DDL_CLIENT_WAIT_FOR_DPB); VIDC_LOG_STRING("HEADER_DONE"); VIDC_DEBUG_REGISTER_LOG; vidc_720p_decode_get_seq_hdr_info(&seq_hdr_info); p_decoder = &(p_ddl->codec_data.decoder); p_decoder->frame_size.n_width = seq_hdr_info.n_img_size_x; p_decoder->frame_size.n_height = seq_hdr_info.n_img_size_y; p_decoder->n_min_dpb_num = seq_hdr_info.n_min_num_dpb; p_decoder->n_y_cb_cr_size = seq_hdr_info.n_min_dpb_size; p_decoder->n_progressive_only = 1 - seq_hdr_info.n_progressive; if (!seq_hdr_info.n_img_size_x || !seq_hdr_info.n_img_size_y) { VIDC_LOGERR_STRING("FATAL: ZeroImageSize"); ddl_client_fatal_cb(p_ddl_context); return b_process_further; } if (seq_hdr_info.n_data_partitioned == 0x1 && p_decoder->codec_type.e_codec == VCD_CODEC_MPEG4 && seq_hdr_info.n_img_size_x > DDL_MAX_DP_FRAME_WIDTH && seq_hdr_info.n_img_size_y > DDL_MAX_DP_FRAME_HEIGHT) { ddl_client_fatal_cb(p_ddl_context); return b_process_further; } ddl_getdec_profilelevel(p_decoder, seq_hdr_info.n_profile, seq_hdr_info.n_level); ddl_calculate_stride(&p_decoder->frame_size, !p_decoder->n_progressive_only); if (seq_hdr_info.n_crop_exists) { p_decoder->frame_size.n_width -= (seq_hdr_info.n_crop_right_offset + seq_hdr_info.n_crop_left_offset); p_decoder->frame_size.n_height -= (seq_hdr_info.n_crop_top_offset + seq_hdr_info.n_crop_bottom_offset); } ddl_set_default_decoder_buffer_req(p_decoder, FALSE); if (p_decoder->b_header_in_start) { p_decoder->client_frame_size = p_decoder->frame_size; p_decoder->client_output_buf_req = p_decoder->actual_output_buf_req; p_decoder->client_input_buf_req = p_decoder->actual_input_buf_req; p_ddl_context->ddl_callback(VCD_EVT_RESP_START, VCD_S_SUCCESS, NULL, 0, (u32 *) p_ddl, p_ddl_context->p_client_data); DDL_IDLE(p_ddl_context); } else { DBG("%s(): n_width = %d client_frame_size.n_width = %d\n", __func__, p_decoder->frame_size.n_width, p_decoder->client_frame_size.n_width); DBG("%s(): n_height = %d client_frame_size.n_height = %d\n", __func__, p_decoder->frame_size.n_height, p_decoder->client_frame_size.n_height); DBG("%s(): n_size = %d client_frame_size n_size = %d\n", __func__, p_decoder->actual_output_buf_req.n_size, p_decoder->client_output_buf_req.n_size); DBG("%s(): n_min_dpb_num = %d n_actual_count = %d\n", __func__, p_decoder->n_min_dpb_num, p_decoder->client_output_buf_req.n_actual_count); p_input_vcd_frm = &(p_ddl->input_frame.vcd_frm); if (p_decoder->frame_size.n_width == p_decoder->client_frame_size.n_width && p_decoder->frame_size.n_height == p_decoder->client_frame_size.n_height && p_decoder->actual_output_buf_req.n_size <= p_decoder->client_output_buf_req.n_size && p_decoder->n_min_dpb_num <= p_decoder->client_output_buf_req.n_actual_count) b_need_reconfig = FALSE; if ((p_input_vcd_frm->n_flags & VCD_FRAME_FLAG_CODECCONFIG) || p_input_vcd_frm->n_data_len == seq_hdr_info.n_dec_frm_size) { b_seq_hdr_only_frame = TRUE; p_input_vcd_frm->n_offset += seq_hdr_info.n_dec_frm_size; p_input_vcd_frm->n_data_len -= seq_hdr_info.n_dec_frm_size; p_input_vcd_frm->n_flags |= VCD_FRAME_FLAG_CODECCONFIG; p_ddl->input_frame.b_frm_trans_end = !b_need_reconfig; p_ddl_context->ddl_callback(VCD_EVT_RESP_INPUT_DONE, VCD_S_SUCCESS, &p_ddl->input_frame, sizeof(struct ddl_frame_data_type_tag), (u32 *) p_ddl, p_ddl->p_ddl_context->p_client_data); } if (b_need_reconfig) { p_reconfig_payload = &p_ddl->input_frame; reconfig_payload_size = sizeof(struct ddl_frame_data_type_tag); p_decoder->client_frame_size = p_decoder->frame_size; p_decoder->client_output_buf_req = p_decoder->actual_output_buf_req; p_decoder->client_input_buf_req = p_decoder->actual_input_buf_req; if (b_seq_hdr_only_frame) { p_reconfig_payload = NULL; reconfig_payload_size = 0; } p_ddl_context->ddl_callback(VCD_EVT_IND_OUTPUT_RECONFIG, VCD_S_SUCCESS, p_reconfig_payload, reconfig_payload_size, (u32 *) p_ddl, p_ddl_context->p_client_data); } if (!b_need_reconfig && !b_seq_hdr_only_frame) { if (ddl_decode_set_buffers(p_ddl) == VCD_S_SUCCESS) b_process_further = FALSE; else ddl_client_fatal_cb(p_ddl_context); } else DDL_IDLE(p_ddl_context); } return b_process_further; }
u32 ddl_decode_frame(u32 *ddl_handle, struct ddl_frame_data_tag *input_bits, void *client_data) { u32 vcd_status = VCD_S_SUCCESS; struct ddl_client_context *ddl = (struct ddl_client_context *)ddl_handle; struct ddl_context *ddl_context = ddl_get_context(); if (!DDL_IS_INITIALIZED(ddl_context)) { VIDC_LOGERR_STRING("ddl_dec_frame:Not_inited"); return VCD_ERR_ILLEGAL_OP; } if (DDL_IS_BUSY(ddl_context)) { VIDC_LOGERR_STRING("ddl_dec_frame:Ddl_busy"); return VCD_ERR_BUSY; } if (!ddl || !ddl->decoding) { VIDC_LOGERR_STRING("ddl_dec_frame:Bad_handle"); return VCD_ERR_BAD_HANDLE; } if (!input_bits || ((!input_bits->vcd_frm.physical || !input_bits->vcd_frm.data_len) && (!(VCD_FRAME_FLAG_EOS & input_bits->vcd_frm.flags)) ) ) { VIDC_LOGERR_STRING("ddl_dec_frame:Bad_input_param"); return VCD_ERR_ILLEGAL_PARM; } DDL_BUSY(ddl_context); ddl_context->current_ddl = ddl; ddl_context->client_data = client_data; ddl->input_frame = *input_bits; if (DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_FRAME)) { ddl_decode_frame_run(ddl); } else { if (!ddl->codec_data.decoder.dp_buf.no_of_dec_pic_buf) { VIDC_LOGERR_STRING("ddl_dec_frame:Dpbs_requied"); vcd_status = VCD_ERR_ILLEGAL_OP; } else if (DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_DPB)) { vcd_status = ddl_decode_set_buffers(ddl); } else if (DDLCLIENT_STATE_IS (ddl, DDL_CLIENT_WAIT_FOR_INITCODEC)) { ddl->codec_data.decoder.decode_config. sequence_header = ddl->input_frame.vcd_frm.physical; ddl->codec_data.decoder.decode_config. sequence_header_len = ddl->input_frame.vcd_frm.data_len; ddl_decode_init_codec(ddl); } else { VIDC_LOGERR_STRING("Dec_frame:Wrong_state"); vcd_status = VCD_ERR_ILLEGAL_OP; } if (vcd_status) DDL_IDLE(ddl_context); } return vcd_status; }
u32 ddl_decode_frame(u32 *ddl_handle, struct ddl_frame_data_type_tag *p_input_bits, void *p_client_data) { u32 vcd_status = VCD_S_SUCCESS; struct ddl_client_context_type *p_ddl = (struct ddl_client_context_type *)ddl_handle; struct ddl_context_type *p_ddl_context = ddl_get_context(); #ifdef CORE_TIMING_INFO ddl_get_core_start_time(0); #endif if (!DDL_IS_INITIALIZED(p_ddl_context)) { VIDC_LOGERR_STRING("ddl_dec_frame:Not_inited"); return VCD_ERR_ILLEGAL_OP; } if (DDL_IS_BUSY(p_ddl_context)) { VIDC_LOGERR_STRING("ddl_dec_frame:Ddl_busy"); return VCD_ERR_BUSY; } if (NULL == p_ddl || FALSE == p_ddl->b_decoding) { VIDC_LOGERR_STRING("ddl_dec_frame:Bad_handle"); return VCD_ERR_BAD_HANDLE; } if (NULL == p_input_bits || ((0 == p_input_bits->vcd_frm.p_physical || 0 == p_input_bits->vcd_frm.n_data_len) && (0 == (VCD_FRAME_FLAG_EOS & p_input_bits->vcd_frm.n_flags)) ) ) { VIDC_LOGERR_STRING("ddl_dec_frame:Bad_input_param"); return VCD_ERR_ILLEGAL_PARM; } DDL_BUSY(p_ddl_context); p_ddl_context->p_current_ddl = p_ddl; p_ddl_context->p_client_data = p_client_data; p_ddl->input_frame = *p_input_bits; if (DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_FRAME)) { ddl_decode_frame_run(p_ddl); } else { if (0 == p_ddl->codec_data.decoder.dp_buf.n_no_of_dec_pic_buf) { VIDC_LOGERR_STRING("ddl_dec_frame:Dpbs_requied"); vcd_status = VCD_ERR_ILLEGAL_OP; } else if (DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_DPB)) { vcd_status = ddl_decode_set_buffers(p_ddl); } else if (DDLCLIENT_STATE_IS (p_ddl, DDL_CLIENT_WAIT_FOR_INITCODEC)) { p_ddl->codec_data.decoder.decode_config. p_sequence_header = p_ddl->input_frame.vcd_frm.p_physical; p_ddl->codec_data.decoder.decode_config. n_sequence_header_len = p_ddl->input_frame.vcd_frm.n_data_len; ddl_decode_init_codec(p_ddl); } else { VIDC_LOGERR_STRING("Dec_frame:Wrong_state"); vcd_status = VCD_ERR_ILLEGAL_OP; } if (VCD_S_SUCCESS != vcd_status) DDL_IDLE(p_ddl_context); } return vcd_status; }