u32 ddl_encode_end(u32 *ddl_handle, void *client_data)
{
struct ddl_client_context *ddl =
(struct ddl_client_context *) ddl_handle;
struct ddl_context *ddl_context;
DDL_MSG_HIGH("ddl_encode_end");
ddl_reset_core_time_variables(ENC_OP_TIME);
ddl_context = ddl_get_context();
if (!DDL_IS_INITIALIZED(ddl_context)) {
DDL_MSG_ERROR("ddl_enc_end:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(ddl_context)) {
DDL_MSG_ERROR("ddl_enc_end:Ddl_busy");
return VCD_ERR_BUSY;
}
if (!ddl || ddl->decoding) {
DDL_MSG_ERROR("ddl_enc_end:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_FRAME) &&
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODEC) &&
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_FAVIDC_ERROR)) {
DDL_MSG_ERROR("ddl_enc_end:Wrong_state");
return VCD_ERR_ILLEGAL_OP;
}
if (!ddl_take_command_channel(ddl_context, ddl, client_data))
return VCD_ERR_BUSY;
ddl_vidc_channel_end(ddl);
return VCD_S_SUCCESS;
}
static u32 ddl_eos_frame_done_callback(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl = ddl_context->current_ddl;
struct ddl_decoder_data *decoder = &(ddl->codec_data.decoder);
struct vidc_720p_dec_disp_info *dec_disp_info =
&(decoder->dec_disp_info);
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE)) {
VIDC_LOGERR_STRING("STATE-CRITICAL-EOSFRMRUN");
ddl_client_fatal_cb(ddl_context);
return true;
}
VIDC_LOG_STRING("EOS_FRM_RUN_DONE");
ddl_move_command_state(ddl_context, DDL_CMD_INVALID);
vidc_720p_decode_display_info(dec_disp_info);
ddl_decode_dynamic_property(ddl, false);
if (dec_disp_info->disp_status == VIDC_720P_DISPLAY_ONLY) {
if (ddl_decoder_output_done_callback(ddl, false)
!= VCD_S_SUCCESS)
return true;
} else
VIDC_LOG_STRING("STATE-CRITICAL-WRONG-DISP-STATUS");
ddl_decoder_dpb_transact(decoder, NULL, DDL_DPB_OP_SET_MASK);
ddl_move_command_state(ddl_context, DDL_CMD_EOS);
vidc_720p_submit_command(ddl->channel_id,
VIDC_720P_CMD_FRAMERUN);
return false;
}
u32 ddl_handle_seqhdr_fail_error(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl = ddl_context->current_ddl;
struct ddl_decoder_data *decoder = &ddl->codec_data.decoder;
u32 status = false;
if (ddl_context->cmd_state == DDL_CMD_HEADER_PARSE &&
DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODECDONE)) {
switch (ddl_context->cmd_err_status) {
case UNSUPPORTED_FEATURE_IN_PROFILE:
case HEADER_NOT_FOUND:
case INVALID_SPS_ID:
case INVALID_PPS_ID:
case RESOLUTION_NOT_SUPPORTED:
ERR("SEQ-HDR-FAILED!!!");
if ((ddl_context->cmd_err_status ==
RESOLUTION_NOT_SUPPORTED) &&
(decoder->codec.codec == VCD_CODEC_H264 ||
decoder->codec.codec == VCD_CODEC_H263 ||
decoder->codec.codec == VCD_CODEC_MPEG4 ||
decoder->codec.codec == VCD_CODEC_VC1_RCV ||
decoder->codec.codec == VCD_CODEC_VC1)) {
ddl_client_fatal_cb(ddl_context);
status = true;
break;
}
if (decoder->header_in_start) {
decoder->header_in_start = false;
ddl_context->ddl_callback(VCD_EVT_RESP_START,
VCD_ERR_SEQHDR_PARSE_FAIL,
NULL, 0, (void *)ddl,
ddl_context->client_data);
} else {
if (ddl->input_frame.vcd_frm.flags &
VCD_FRAME_FLAG_EOS)
ddl->input_frame.frm_trans_end = false;
else
ddl->input_frame.frm_trans_end = true;
ddl_decode_dynamic_property(ddl, false);
ddl_context->ddl_callback(
VCD_EVT_RESP_INPUT_DONE,
VCD_ERR_SEQHDR_PARSE_FAIL,
&ddl->input_frame,
sizeof(struct ddl_frame_data_tag),
(void *)ddl, ddl_context->client_data);
if (ddl->input_frame.vcd_frm.flags &
VCD_FRAME_FLAG_EOS)
ddl_context->ddl_callback(
VCD_EVT_RESP_EOS_DONE,
VCD_S_SUCCESS, NULL,
0, (void *)ddl,
ddl_context->client_data);
}
ddl_move_client_state(ddl,
DDL_CLIENT_WAIT_FOR_INITCODEC);
DDL_IDLE(ddl_context);
status = true;
}
}
return status;
}
static u32 ddl_eos_frame_done_callback(
struct ddl_client_context *ddl)
{
struct ddl_context *ddl_context = ddl->ddl_context;
struct ddl_decoder_data *decoder = &ddl->codec_data.decoder;
struct ddl_mask *dpb_mask = &decoder->dpb_mask;
u32 ret_status = true, rsl_chg;
enum vidc_1080p_display_status disp_status;
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE)) {
DDL_MSG_ERROR("STATE-CRITICAL-EOSFRMRUN");
ddl_client_fatal_cb(ddl);
} else {
DDL_MSG_LOW("EOS_FRM_RUN_DONE");
ddl->cmd_state = DDL_CMD_INVALID;
get_dec_status(&ddl->codec_data.decoder.dec_disp_info,
ddl->codec_data.decoder.output_order,
&disp_status, &rsl_chg);
ddl_vidc_decode_dynamic_property(ddl, false);
if (disp_status ==
VIDC_1080P_DISPLAY_STATUS_DPB_EMPTY) {
ddl_decoder_eos_done_callback(ddl);
} else {
struct vidc_1080p_dec_frame_start_param dec_param;
ret_status = false;
if (disp_status ==
VIDC_1080P_DISPLAY_STATUS_DISPLAY_ONLY) {
if (ddl_decoder_output_done_callback(
ddl, false))
ret_status = true;
} else if (disp_status !=
VIDC_1080P_DISPLAY_STATUS_NOOP)
DDL_MSG_ERROR("EOS-STATE-CRITICAL-"
"WRONG-DISP-STATUS");
if (!ret_status) {
ddl_decoder_dpb_transact(decoder, NULL,
DDL_DPB_OP_SET_MASK);
ddl->cmd_state = DDL_CMD_EOS;
memset(&dec_param, 0, sizeof(dec_param));
dec_param.cmd_seq_num =
++ddl_context->cmd_seq_num;
dec_param.inst_id = ddl->instance_id;
dec_param.shared_mem_addr_offset =
DDL_ADDR_OFFSET(
ddl_context->dram_base_a,
ddl->shared_mem[ddl->command_channel]);
dec_param.release_dpb_bit_mask =
dpb_mask->hw_mask;
dec_param.decode =
VIDC_1080P_DEC_TYPE_LAST_FRAME_DATA;
ddl_context->vidc_decode_frame_start[ddl->\
command_channel](&dec_param);
}
}
}
return ret_status;
}
u32 ddl_decode_start(u32 *ddl_handle, struct vcd_sequence_hdr *header,
void *client_data)
{
struct ddl_client_context *ddl =
(struct ddl_client_context *) ddl_handle;
struct ddl_context *ddl_context;
struct ddl_decoder_data *decoder;
u32 status = VCD_S_SUCCESS;
DDL_MSG_HIGH("ddl_decode_start");
if (vidc_msg_timing) {
ddl_reset_core_time_variables(DEC_OP_TIME);
ddl_reset_core_time_variables(DEC_IP_TIME);
}
ddl_context = ddl_get_context();
if (!DDL_IS_INITIALIZED(ddl_context)) {
DDL_MSG_ERROR("ddl_dec_start:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(ddl_context)) {
DDL_MSG_ERROR("ddl_dec_start:Ddl_busy");
return VCD_ERR_BUSY;
}
if (!ddl || !ddl->decoding) {
DDL_MSG_ERROR("ddl_dec_start:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_OPEN)) {
DDL_MSG_ERROR("ddl_dec_start:Not_in_opened_state");
return VCD_ERR_ILLEGAL_OP;
}
if ((header) && ((!header->sequence_header_len) ||
(!header->sequence_header))) {
DDL_MSG_ERROR("ddl_dec_start:Bad_param_seq_header");
return VCD_ERR_ILLEGAL_PARM;
}
if (!ddl_decoder_ready_to_start(ddl, header)) {
DDL_MSG_ERROR("ddl_dec_start:Err_param_settings");
return VCD_ERR_ILLEGAL_OP;
}
decoder = &ddl->codec_data.decoder;
status = ddl_allocate_dec_hw_buffers(ddl);
if (status)
return status;
#ifdef DDL_BUF_LOG
ddl_list_buffers(ddl);
#endif
if (!ddl_take_command_channel(ddl_context, ddl, client_data))
return VCD_ERR_BUSY;
if (header) {
decoder->header_in_start = true;
decoder->decode_config = *header;
} else {
decoder->header_in_start = false;
decoder->decode_config.sequence_header_len = 0;
}
ddl_vidc_channel_set(ddl);
return status;
}
u32 ddl_close(u32 **p_ddl_handle)
{
struct ddl_context_type *p_ddl_context;
struct ddl_client_context_type **pp_ddl =
(struct ddl_client_context_type **)p_ddl_handle;
if (NULL == pp_ddl || NULL == *pp_ddl) {
VIDC_LOGERR_STRING("ddl_close:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
p_ddl_context = ddl_get_context();
if (!DDL_IS_INITIALIZED(p_ddl_context)) {
VIDC_LOGERR_STRING("ddl_close:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (!DDLCLIENT_STATE_IS(*pp_ddl, DDL_CLIENT_OPEN)) {
VIDC_LOGERR_STRING("ddl_close:Not_in_open_state");
return VCD_ERR_ILLEGAL_OP;
}
ddl_move_client_state(*pp_ddl, DDL_CLIENT_INVALID);
if ((*pp_ddl)->b_decoding) {
vcd_fw_transact(FALSE, TRUE,
(*pp_ddl)->codec_data.decoder.codec_type.e_codec);
} else {
vcd_fw_transact(FALSE, FALSE,
(*pp_ddl)->codec_data.encoder.codec_type.e_codec);
}
ddl_client_transact(DDL_FREE_CLIENT, pp_ddl);
return VCD_S_SUCCESS;
}
u32 ddl_close(u32 **ddl_handle)
{
struct ddl_context *ddl_context;
struct ddl_client_context **pp_ddl =
(struct ddl_client_context **)ddl_handle;
DDL_MSG_HIGH("ddl_close");
if (!pp_ddl || !*pp_ddl) {
DDL_MSG_ERROR("ddl_close:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
ddl_context = ddl_get_context();
if (!DDL_IS_INITIALIZED(ddl_context)) {
DDL_MSG_ERROR("ddl_close:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (!DDLCLIENT_STATE_IS(*pp_ddl, DDL_CLIENT_OPEN)) {
DDL_MSG_ERROR("ddl_close:Not_in_open_state");
return VCD_ERR_ILLEGAL_OP;
}
ddl_pmem_free(&(*pp_ddl)->shared_mem[0]);
if (ddl_context->frame_channel_depth ==
VCD_DUAL_FRAME_COMMAND_CHANNEL)
ddl_pmem_free(&(*pp_ddl)->shared_mem[1]);
DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_INVALID",
ddl_get_state_string((*pp_ddl)->client_state));
(*pp_ddl)->client_state = DDL_CLIENT_INVALID;
ddl_codec_type_transact(*pp_ddl, true, (enum vcd_codec)0);
ddl_client_transact(DDL_FREE_CLIENT, pp_ddl);
return VCD_S_SUCCESS;
}
static u32 ddl_encoder_seq_done_callback(struct ddl_context_type *p_ddl_context,
struct ddl_client_context_type *p_ddl)
{
struct ddl_encoder_data_type *p_encoder;
DDL_MSG_MED("ddl_encoder_seq_done_callback");
if (!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_INITCODECDONE)) {
DDL_MSG_ERROR("STATE-CRITICAL-INITCODEC");
ddl_client_fatal_cb(p_ddl);
return TRUE;
}
p_ddl->e_cmd_state = DDL_CMD_INVALID;
DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_WAIT_FOR_FRAME",
ddl_get_state_string(p_ddl->e_client_state));
p_ddl->e_client_state = DDL_CLIENT_WAIT_FOR_FRAME;
DDL_MSG_LOW("INIT_CODEC_DONE");
p_encoder = &p_ddl->codec_data.encoder;
vidc_1080p_get_encoder_sequence_header_size(
&p_encoder->n_seq_header_length);
p_ddl_context->ddl_callback(VCD_EVT_RESP_START, VCD_S_SUCCESS,
NULL, 0, (u32 *) p_ddl, p_ddl->p_client_data);
ddl_release_command_channel(p_ddl_context,
p_ddl->n_command_channel);
return TRUE;
}
static void ddl_channel_end_callback(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl;
DDL_MSG_MED("ddl_channel_end_callback");
ddl = ddl_get_current_ddl_client_for_command(ddl_context,
DDL_CMD_CHANNEL_END);
if (ddl) {
ddl->cmd_state = DDL_CMD_INVALID;
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_CHEND)) {
DDL_MSG_LOW("STATE-CRITICAL-CHEND");
} else {
DDL_MSG_LOW("CH_END_DONE");
ddl_release_client_internal_buffers(ddl);
ddl_context->ddl_callback(VCD_EVT_RESP_STOP,
VCD_S_SUCCESS, NULL, 0, (u32 *)ddl,
ddl->client_data);
DDL_MSG_LOW("ddl_state_transition: %s ~~>"
"DDL_CLIENT_OPEN",
ddl_get_state_string(ddl->client_state));
ddl->client_state = DDL_CLIENT_OPEN;
}
ddl_release_command_channel(ddl_context,
ddl->command_channel);
}
}
static void ddl_encoder_eos_done(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl;
u32 channel_inst_id;
vidc_1080p_get_returned_channel_inst_id(&channel_inst_id);
vidc_1080p_clear_returned_channel_inst_id();
ddl = ddl_get_current_ddl_client_for_channel_id(ddl_context,
ddl_context->response_cmd_ch_id);
if (!ddl || (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE))) {
DDL_MSG_ERROR("STATE-CRITICAL-EOSFRMDONE");
ddl_client_fatal_cb(ddl);
} else {
struct ddl_encoder_data *encoder = &(ddl->codec_data.encoder);
vidc_1080p_get_encode_frame_info(&encoder->enc_frame_info);
ddl_handle_enc_frame_done(ddl);
DDL_MSG_LOW("encoder_eos_done");
ddl->cmd_state = DDL_CMD_INVALID;
DDL_MSG_LOW("ddl_state_transition: %s ~~>"
"DDL_CLIENT_WAIT_FOR_FRAME",
ddl_get_state_string(ddl->client_state));
ddl->client_state = DDL_CLIENT_WAIT_FOR_FRAME;
DDL_MSG_LOW("eos_done");
ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE,
VCD_S_SUCCESS, NULL, 0,
(u32 *)ddl, ddl->client_data);
ddl_release_command_channel(ddl_context,
ddl->command_channel);
}
}
static void ddl_encoder_eos_done(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl;
u32 channel_inst_id;
DDL_MSG_LOW("encoder_eos_done");
vidc_1080p_get_returned_channel_inst_id(&channel_inst_id);
vidc_1080p_clear_returned_channel_inst_id();
ddl = ddl_get_current_ddl_client_for_channel_id(ddl_context,
ddl_context->response_cmd_ch_id);
if (ddl) {
if (DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE)) {
DDL_MSG_LOW("ENC_EOS_DONE");
ddl->cmd_state = DDL_CMD_INVALID;
DDL_MSG_LOW("ddl_state_transition: %s ~~>"
"DDL_CLIENT_WAIT_FOR_FRAME",
ddl_get_state_string(ddl->client_state));
ddl->client_state = DDL_CLIENT_WAIT_FOR_FRAME;
DDL_MSG_LOW("EOS_DONE");
ddl->output_frame.frm_trans_end = true;
ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE,
VCD_S_SUCCESS, &(ddl->output_frame),
sizeof(struct ddl_frame_data_tag),
(u32 *)ddl, ddl->client_data);
} else {
DDL_MSG_LOW("STATE-CRITICAL-EOSDONE");
}
ddl_release_command_channel(ddl_context,
ddl->command_channel);
} else {
DDL_MSG_LOW("Invalid Client DDL context");
}
}
static u32 ddl_dpb_buffers_set_done_callback(
struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl;
u32 channel_inst_id, ret_status = true;
DDL_MSG_MED("ddl_dpb_buffers_set_done_callback");
vidc_1080p_get_returned_channel_inst_id(&channel_inst_id);
vidc_1080p_clear_returned_channel_inst_id();
ddl = ddl_get_current_ddl_client_for_command(ddl_context,
DDL_CMD_DECODE_SET_DPB);
if (ddl) {
ddl->cmd_state = DDL_CMD_INVALID;
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_DPBDONE)) {
DDL_MSG_ERROR("STATE-CRITICAL-DPBDONE");
ddl_client_fatal_cb(ddl);
} else {
DDL_MSG_LOW("INTR_DPBDONE");
DDL_MSG_LOW("ddl_state_transition: %s ~~>"
"DDL_CLIENT_WAIT_FOR_FRAME",
ddl_get_state_string(ddl->client_state));
if (vidc_msg_timing) {
ddl_calc_core_proc_time(__func__, DEC_OP_TIME);
ddl_reset_core_time_variables(DEC_OP_TIME);
}
ddl->client_state = DDL_CLIENT_WAIT_FOR_FRAME;
ddl_vidc_decode_frame_run(ddl);
ret_status = false;
}
}
return ret_status;
}
static void ddl_eos_done_callback(struct ddl_context_type *p_ddl_context)
{
struct ddl_client_context_type *p_ddl = p_ddl_context->p_current_ddl;
u32 n_displaystatus;
if (!DDLCOMMAND_STATE_IS(p_ddl_context, DDL_CMD_EOS)) {
VIDC_LOGERR_STRING("UNKWN_EOSDONE");
ddl_client_fatal_cb(p_ddl_context);
return;
}
if (!p_ddl ||
!p_ddl->b_decoding ||
!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE)
) {
VIDC_LOG_STRING("STATE-CRITICAL-EOSDONE");
ddl_client_fatal_cb(p_ddl_context);
return;
}
ddl_move_command_state(p_ddl_context, DDL_CMD_INVALID);
vidc_720p_eos_info(&n_displaystatus);
if ((enum vidc_720p_display_status_type)n_displaystatus
!= VIDC_720P_EMPTY_BUFFER) {
VIDC_LOG_STRING("EOSDONE-EMPTYBUF-ISSUE");
}
ddl_decode_dynamic_property(p_ddl, FALSE);
ddl_move_client_state(p_ddl, DDL_CLIENT_WAIT_FOR_FRAME);
VIDC_LOG_STRING("EOS_DONE");
p_ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE, VCD_S_SUCCESS,
NULL, 0, (u32 *) p_ddl, p_ddl_context->p_client_data);
DDL_IDLE(p_ddl_context);
}
static u32 ddl_encoder_seq_done_callback(struct ddl_context *ddl_context,
struct ddl_client_context *ddl)
{
struct ddl_encoder_data *encoder;
DDL_MSG_MED("ddl_encoder_seq_done_callback");
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODECDONE)) {
DDL_MSG_ERROR("STATE-CRITICAL-INITCODEC");
ddl_client_fatal_cb(ddl);
return true;
}
if (vidc_msg_timing)
ddl_calc_core_proc_time(__func__, ENC_OP_TIME);
ddl->cmd_state = DDL_CMD_INVALID;
DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_WAIT_FOR_FRAME",
ddl_get_state_string(ddl->client_state));
ddl->client_state = DDL_CLIENT_WAIT_FOR_FRAME;
DDL_MSG_LOW("INIT_CODEC_DONE");
encoder = &ddl->codec_data.encoder;
vidc_1080p_get_encoder_sequence_header_size(
&encoder->seq_header_length);
if ((encoder->codec.codec == VCD_CODEC_H264) &&
(encoder->profile.profile == VCD_PROFILE_H264_BASELINE))
if ((encoder->seq_header.align_virtual_addr) &&
(encoder->seq_header_length > 6))
encoder->seq_header.align_virtual_addr[6] = 0xC0;
ddl_context->ddl_callback(VCD_EVT_RESP_START, VCD_S_SUCCESS,
NULL, 0, (u32 *) ddl, ddl->client_data);
ddl_release_command_channel(ddl_context,
ddl->command_channel);
return true;
}
static u32 ddl_channel_set_callback(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl = ddl_context->current_ddl;
u32 return_status = false;
ddl_move_command_state(ddl_context, DDL_CMD_INVALID);
VIDC_DEBUG_REGISTER_LOG;
if (!ddl ||
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_CHDONE)
) {
VIDC_LOG_STRING("STATE-CRITICAL-CHSET");
DDL_IDLE(ddl_context);
return return_status;
}
VIDC_LOG_STRING("Channel-set");
ddl_move_client_state(ddl, DDL_CLIENT_WAIT_FOR_INITCODEC);
if (ddl->decoding) {
if (ddl->codec_data.decoder.header_in_start) {
ddl_decode_init_codec(ddl);
} else {
ddl_context->ddl_callback(VCD_EVT_RESP_START,
VCD_S_SUCCESS, NULL,
0, (u32 *) ddl,
ddl_context->client_data);
DDL_IDLE(ddl_context);
return_status = true;
}
} else {
ddl_encode_init_codec(ddl);
}
return return_status;
}
static void ddl_init_codec_done_callback(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl = ddl_context->current_ddl;
struct ddl_encoder_data *encoder;
if (!ddl ||
ddl->decoding ||
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODECDONE)
) {
VIDC_LOG_STRING("STATE-CRITICAL-INITCODEC");
ddl_client_fatal_cb(ddl_context);
return;
}
ddl_move_command_state(ddl_context, DDL_CMD_INVALID);
ddl_move_client_state(ddl, DDL_CLIENT_WAIT_FOR_FRAME);
VIDC_LOG_STRING("INIT_CODEC_DONE");
encoder = &ddl->codec_data.encoder;
if (encoder->seq_header.virtual_base_addr) {
vidc_720p_encode_get_header(&encoder->seq_header.
buffer_size);
}
ddl_context->ddl_callback(VCD_EVT_RESP_START, VCD_S_SUCCESS, NULL,
0, (u32 *) ddl, ddl_context->client_data);
DDL_IDLE(ddl_context);
}
u32 ddl_close(u32 **ddl_handle)
{
struct ddl_context *ddl_context;
struct ddl_client_context **ddl =
(struct ddl_client_context **)ddl_handle;
if (!ddl || !*ddl) {
VIDC_LOGERR_STRING("ddl_close:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
ddl_context = ddl_get_context();
if (!DDL_IS_INITIALIZED(ddl_context)) {
VIDC_LOGERR_STRING("ddl_close:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (!DDLCLIENT_STATE_IS(*ddl, DDL_CLIENT_OPEN)) {
VIDC_LOGERR_STRING("ddl_close:Not_in_open_state");
return VCD_ERR_ILLEGAL_OP;
}
ddl_move_client_state(*ddl, DDL_CLIENT_INVALID);
if ((*ddl)->decoding) {
vcd_fw_transact(false, true,
(*ddl)->codec_data.decoder.codec.codec);
} else {
vcd_fw_transact(false, false,
(*ddl)->codec_data.encoder.codec.codec);
}
ddl_client_transact(DDL_FREE_CLIENT, ddl);
return VCD_S_SUCCESS;
}
u32 ddl_encode_start(u32 *ddl_handle, void *client_data)
{
struct ddl_client_context *ddl =
(struct ddl_client_context *) ddl_handle;
struct ddl_context *ddl_context;
struct ddl_encoder_data *encoder;
void *ptr;
u32 status = VCD_S_SUCCESS;
DDL_MSG_HIGH("ddl_encode_start");
#ifdef DDL_PROFILE
if (first_time < 2) {
ddl_reset_time_variables(1);
first_time++;
}
ddl_get_core_start_time(1);
#endif
ddl_context = ddl_get_context();
if (!DDL_IS_INITIALIZED(ddl_context)) {
DDL_MSG_ERROR("ddl_enc_start:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(ddl_context)) {
DDL_MSG_ERROR("ddl_enc_start:Ddl_busy");
return VCD_ERR_BUSY;
}
if (!ddl || ddl->decoding) {
DDL_MSG_ERROR("ddl_enc_start:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_OPEN)) {
DDL_MSG_ERROR("ddl_enc_start:Not_opened");
return VCD_ERR_ILLEGAL_OP;
}
if (!ddl_encoder_ready_to_start(ddl)) {
DDL_MSG_ERROR("ddl_enc_start:Err_param_settings");
return VCD_ERR_ILLEGAL_OP;
}
encoder = &ddl->codec_data.encoder;
status = ddl_allocate_enc_hw_buffers(ddl);
if (status)
return status;
#ifdef DDL_BUF_LOG
ddl_list_buffers(ddl);
#endif
ptr = ddl_pmem_alloc(&encoder->seq_header,
DDL_ENC_SEQHEADER_SIZE, DDL_LINEAR_BUFFER_ALIGN_BYTES);
if (!ptr) {
ddl_free_enc_hw_buffers(ddl);
DDL_MSG_ERROR("ddl_enc_start:Seq_hdr_alloc_failed");
return VCD_ERR_ALLOC_FAIL;
}
if (!ddl_take_command_channel(ddl_context, ddl, client_data))
return VCD_ERR_BUSY;
ddl_vidc_channel_set(ddl);
return status;
}
static void ddl_encoder_frame_run_callback(struct ddl_context
*ddl_context)
{
struct ddl_client_context *ddl = ddl_context->current_ddl;
struct ddl_encoder_data *encoder = &(ddl->codec_data.encoder);
u32 eos_present = false;
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_FRAME_DONE)
) {
VIDC_LOG_STRING("STATE-CRITICAL-ENCFRMRUN");
ddl_client_fatal_cb(ddl_context);
return;
}
VIDC_LOG_STRING("ENC_FRM_RUN_DONE");
ddl_move_command_state(ddl_context, DDL_CMD_INVALID);
vidc_720p_enc_frame_info(&encoder->enc_frame_info);
ddl->output_frame.vcd_frm.ip_frm_tag =
ddl->input_frame.vcd_frm.ip_frm_tag;
ddl->output_frame.vcd_frm.data_len =
encoder->enc_frame_info.enc_size;
ddl->output_frame.vcd_frm.flags |= VCD_FRAME_FLAG_ENDOFFRAME;
ddl_get_frame
(&(ddl->output_frame.vcd_frm),
encoder->enc_frame_info.frame);
ddl_process_encoder_metadata(ddl);
ddl_encode_dynamic_property(ddl, false);
ddl->input_frame.frm_trans_end = false;
ddl_context->ddl_callback(VCD_EVT_RESP_INPUT_DONE, VCD_S_SUCCESS,
&(ddl->input_frame), sizeof(struct ddl_frame_data_tag),
(u32 *) ddl, ddl_context->client_data);
if (vidc_msg_timing)
ddl_calc_core_proc_time(__func__, ENC_OP_TIME);
/* check the presence of EOS */
eos_present =
((VCD_FRAME_FLAG_EOS & ddl->input_frame.vcd_frm.flags));
ddl->output_frame.frm_trans_end = !eos_present;
ddl_context->ddl_callback(VCD_EVT_RESP_OUTPUT_DONE, VCD_S_SUCCESS,
&(ddl->output_frame), sizeof(struct ddl_frame_data_tag),
(u32 *) ddl, ddl_context->client_data);
if (eos_present) {
VIDC_LOG_STRING("ENC-EOS_DONE");
ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE,
VCD_S_SUCCESS, NULL, 0, (u32 *)ddl,
ddl_context->client_data);
}
ddl_move_client_state(ddl, DDL_CLIENT_WAIT_FOR_FRAME);
DDL_IDLE(ddl_context);
}
static void ddl_encoder_frame_run_callback(struct ddl_context_type
*p_ddl_context)
{
struct ddl_client_context_type *p_ddl = p_ddl_context->p_current_ddl;
struct ddl_encoder_data_type *p_encoder = &(p_ddl->codec_data.encoder);
u32 b_eos_present = FALSE;
if (!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_FRAME_DONE)
) {
VIDC_LOG_STRING("STATE-CRITICAL-ENCFRMRUN");
ddl_client_fatal_cb(p_ddl_context);
return;
}
VIDC_LOG_STRING("ENC_FRM_RUN_DONE");
ddl_move_command_state(p_ddl_context, DDL_CMD_INVALID);
vidc_720p_enc_frame_info(&p_encoder->enc_frame_info);
p_ddl->output_frame.vcd_frm.n_ip_frm_tag =
p_ddl->input_frame.vcd_frm.n_ip_frm_tag;
p_ddl->output_frame.vcd_frm.n_data_len =
p_encoder->enc_frame_info.n_enc_size;
p_ddl->output_frame.vcd_frm.n_flags |= VCD_FRAME_FLAG_ENDOFFRAME;
ddl_get_frame_type
(&(p_ddl->output_frame.vcd_frm),
p_encoder->enc_frame_info.n_frame_type);
ddl_process_encoder_metadata(p_ddl);
ddl_encode_dynamic_property(p_ddl, FALSE);
p_ddl->input_frame.b_frm_trans_end = FALSE;
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_context->p_client_data);
#ifdef CORE_TIMING_INFO
ddl_calc_core_time(1);
#endif
b_eos_present =
((VCD_FRAME_FLAG_EOS & p_ddl->input_frame.vcd_frm.n_flags));
p_ddl->output_frame.b_frm_trans_end = !b_eos_present;
p_ddl_context->ddl_callback(VCD_EVT_RESP_OUTPUT_DONE, VCD_S_SUCCESS,
&(p_ddl->output_frame), sizeof(struct ddl_frame_data_type_tag),
(u32 *) p_ddl, p_ddl_context->p_client_data);
if (b_eos_present) {
VIDC_LOG_STRING("ENC-EOS_DONE");
p_ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE,
VCD_S_SUCCESS, NULL, 0, (u32 *)p_ddl,
p_ddl_context->p_client_data);
}
ddl_move_client_state(p_ddl, DDL_CLIENT_WAIT_FOR_FRAME);
DDL_IDLE(p_ddl_context);
}
u32 ddl_decode_end(u32 *ddl_handle, void *client_data)
{
struct ddl_client_context *ddl =
(struct ddl_client_context *)ddl_handle;
struct ddl_context *ddl_context;
ddl_context = ddl_get_context();
if (vidc_msg_timing) {
ddl_reset_core_time_variables(DEC_OP_TIME);
ddl_reset_core_time_variables(DEC_IP_TIME);
}
if (!DDL_IS_INITIALIZED(ddl_context)) {
VIDC_LOGERR_STRING("ddl_dec_end:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(ddl_context)) {
VIDC_LOGERR_STRING("ddl_dec_end:Ddl_busy");
return VCD_ERR_BUSY;
}
if (!ddl || !ddl->decoding) {
VIDC_LOGERR_STRING("ddl_dec_end:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_FRAME) &&
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODEC) &&
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_DPB) &&
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_FATAL_ERROR)
) {
VIDC_LOGERR_STRING("ddl_dec_end:Wrong_state");
return VCD_ERR_ILLEGAL_OP;
}
DDL_BUSY(ddl_context);
ddl_context->current_ddl = ddl;
ddl_context->client_data = client_data;
ddl_channel_end(ddl);
return VCD_S_SUCCESS;
}
static void ddl_channel_end_callback(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl;
ddl_move_command_state(ddl_context, DDL_CMD_INVALID);
VIDC_LOG_STRING("CH_END_DONE");
ddl = ddl_context->current_ddl;
if (!ddl ||
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_CHEND)
) {
VIDC_LOG_STRING("STATE-CRITIC
u32 ddl_decode_end(u32 *ddl_handle, void *p_client_data)
{
struct ddl_client_context_type *p_ddl =
(struct ddl_client_context_type *)ddl_handle;
struct ddl_context_type *p_ddl_context;
p_ddl_context = ddl_get_context();
#ifdef CORE_TIMING_INFO
ddl_reset_time_variables(0);
#endif
if (!DDL_IS_INITIALIZED(p_ddl_context)) {
VIDC_LOGERR_STRING("ddl_dec_end:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(p_ddl_context)) {
VIDC_LOGERR_STRING("ddl_dec_end:Ddl_busy");
return VCD_ERR_BUSY;
}
if (NULL == p_ddl || FALSE == p_ddl->b_decoding) {
VIDC_LOGERR_STRING("ddl_dec_end:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_FRAME) &&
!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_INITCODEC) &&
!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_DPB) &&
!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_FATAL_ERROR)
) {
VIDC_LOGERR_STRING("ddl_dec_end:Wrong_state");
return VCD_ERR_ILLEGAL_OP;
}
DDL_BUSY(p_ddl_context);
p_ddl_context->p_current_ddl = p_ddl;
p_ddl_context->p_client_data = p_client_data;
ddl_channel_end(p_ddl);
return VCD_S_SUCCESS;
}
static u32 ddl_channel_set_callback(struct ddl_context *ddl_context,
u32 instance_id)
{
struct ddl_client_context *ddl;
u32 ret = false;
DDL_MSG_MED("ddl_channel_open_callback");
ddl = ddl_get_current_ddl_client_for_command(ddl_context,
DDL_CMD_CHANNEL_SET);
if (ddl) {
ddl->cmd_state = DDL_CMD_INVALID;
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_CHDONE)) {
DDL_MSG_ERROR("STATE-CRITICAL-CHSET");
ddl_release_command_channel(ddl_context,
ddl->command_channel);
} else {
DDL_MSG_LOW("CH_SET_DONE");
DDL_MSG_LOW("ddl_state_transition: %s ~~>"
"DDL_CLIENT_WAIT_FOR_INITCODEC",
ddl_get_state_string(ddl->client_state));
ddl->client_state = DDL_CLIENT_WAIT_FOR_INITCODEC;
ddl->instance_id = instance_id;
if (ddl->decoding) {
if (vidc_msg_timing)
ddl_calc_core_proc_time(__func__,
DEC_OP_TIME);
if (ddl->codec_data.decoder.header_in_start)
ddl_vidc_decode_init_codec(ddl);
else {
ddl_context->ddl_callback(
VCD_EVT_RESP_START,
VCD_S_SUCCESS, NULL, 0,
(u32 *)ddl,
ddl->client_data);
ddl_release_command_channel(
ddl_context,
ddl->command_channel);
ret = true;
}
} else
ddl_vidc_encode_init_codec(ddl);
}
}
return ret;
}
static u32 ddl_eos_done_callback(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl = ddl_context->current_ddl;
u32 displaystatus, resl_change;
if (!DDLCOMMAND_STATE_IS(ddl_context, DDL_CMD_EOS)) {
VIDC_LOGERR_STRING("UNKWN_EOSDONE");
ddl_client_fatal_cb(ddl_context);
return true;
}
if (!ddl ||
!ddl->decoding ||
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE)
) {
VIDC_LOG_STRING("STATE-CRITICAL-EOSDONE");
ddl_client_fatal_cb(ddl_context);
return true;
}
ddl_move_command_state(ddl_context, DDL_CMD_INVALID);
vidc_720p_eos_info(&displaystatus, &resl_change);
if ((enum vidc_720p_display_status)displaystatus
!= VIDC_720P_EMPTY_BUFFER) {
VIDC_LOG_STRING("EOSDONE-EMPTYBUF-ISSUE");
}
ddl_decode_dynamic_property(ddl, false);
if (resl_change == 0x1) {
ddl->codec_data.decoder.header_in_start = false;
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);
return false;
}
ddl_move_client_state(ddl, DDL_CLIENT_WAIT_FOR_FRAME);
VIDC_LOG_STRING("EOS_DONE");
ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE, VCD_S_SUCCESS,
NULL, 0, (u32 *) ddl, ddl_context->client_data);
DDL_IDLE(ddl_context);
return true;
}
static u32 ddl_channel_set_callback(struct ddl_context_type *p_ddl_context,
u32 n_instance_id)
{
struct ddl_client_context_type *p_ddl;
u32 b_ret = FALSE;
DDL_MSG_MED("ddl_channel_open_callback");
p_ddl = ddl_get_current_ddl_client_for_command(p_ddl_context,
DDL_CMD_CHANNEL_SET);
if (p_ddl) {
p_ddl->e_cmd_state = DDL_CMD_INVALID;
if (!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_CHDONE)) {
DDL_MSG_ERROR("STATE-CRITICAL-CHSET");
ddl_release_command_channel(p_ddl_context,
p_ddl->n_command_channel);
} else {
DDL_MSG_LOW("CH_SET_DONE");
DDL_MSG_LOW("ddl_state_transition: %s ~~>\
DDL_CLIENT_WAIT_FOR_INITCODEC",
ddl_get_state_string(p_ddl->e_client_state));
p_ddl->e_client_state = DDL_CLIENT_WAIT_FOR_INITCODEC;
p_ddl->n_channel_id = n_instance_id;
if (p_ddl->b_decoding) {
if (p_ddl->codec_data.decoder.b_header_in_start)
ddl_vidc_decode_init_codec(p_ddl);
else {
p_ddl_context->ddl_callback(
VCD_EVT_RESP_START,
VCD_S_SUCCESS, NULL, 0,
(u32 *)p_ddl,
p_ddl->p_client_data);
ddl_release_command_channel(
p_ddl_context,
p_ddl->n_command_channel);
b_ret = TRUE;
}
} else
ddl_vidc_encode_init_codec(p_ddl);
}
}
return b_ret;
}
static u32 ddl_dpb_buffers_set_done_callback(struct ddl_context
*ddl_context)
{
struct ddl_client_context *ddl = ddl_context->current_ddl;
ddl_move_command_state(ddl_context, DDL_CMD_INVALID);
if (!ddl ||
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_DPBDONE)
) {
VIDC_LOG_STRING("STATE-CRITICAL-DPBDONE");
ddl_client_fatal_cb(ddl_context);
return true;
}
VIDC_LOG_STRING("INTR_DPBDONE");
ddl_move_client_state(ddl, DDL_CLIENT_WAIT_FOR_FRAME);
ddl->codec_data.decoder.dec_disp_info.img_size_x = 0;
ddl->codec_data.decoder.dec_disp_info.img_size_y = 0;
ddl_decode_frame_run(ddl);
return false;
}
static void ddl_channel_end_callback(struct ddl_context *ddl_context)
{
struct ddl_client_context *ddl;
ddl_move_command_state(ddl_context, DDL_CMD_INVALID);
VIDC_LOG_STRING("CH_END_DONE");
ddl = ddl_context->current_ddl;
if (!ddl ||
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_CHEND)
) {
VIDC_LOG_STRING("STATE-CRITICAL-CHEND");
DDL_IDLE(ddl_context);
return;
}
ddl_release_client_internal_buffers(ddl);
ddl_context->ddl_callback(VCD_EVT_RESP_STOP, VCD_S_SUCCESS,
NULL, 0, (u32 *) ddl, ddl_context->client_data);
ddl_move_client_state(ddl, DDL_CLIENT_OPEN);
DDL_IDLE(ddl_context);
}
static void ddl_handle_enc_frame_done(struct ddl_client_context *ddl)
{
struct ddl_context *ddl_context = ddl->ddl_context;
struct ddl_encoder_data *encoder = &(ddl->codec_data.encoder);
struct vcd_frame_data *output_frame = &(ddl->output_frame.vcd_frm);
u32 bottom_frame_tag;
u8 *input_buffer_address = NULL;
vidc_sm_get_frame_tags(&ddl->shared_mem[ddl->command_channel],
&output_frame->ip_frm_tag, &bottom_frame_tag);
output_frame->data_len = encoder->enc_frame_info.enc_frame_size;
output_frame->flags |= VCD_FRAME_FLAG_ENDOFFRAME;
(void)ddl_get_encoded_frame(output_frame,
encoder->codec.codec, encoder->enc_frame_info.enc_frame);
ddl_process_encoder_metadata(ddl);
ddl_vidc_encode_dynamic_property(ddl, false);
ddl->input_frame.frm_trans_end = false;
input_buffer_address = ddl_context->dram_base_a.align_physical_addr +
encoder->enc_frame_info.enc_luma_address;
ddl_get_input_frame_from_pool(ddl, input_buffer_address);
ddl_context->ddl_callback(VCD_EVT_RESP_INPUT_DONE,
VCD_S_SUCCESS, &(ddl->input_frame),
sizeof(struct ddl_frame_data_tag),
(u32 *) ddl, ddl->client_data);
ddl->output_frame.frm_trans_end =
DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE)
? false : true;
ddl_context->ddl_callback(VCD_EVT_RESP_OUTPUT_DONE,
VCD_S_SUCCESS, &(ddl->output_frame),
sizeof(struct ddl_frame_data_tag),
(u32 *) ddl, ddl->client_data);
}
static u32 ddl_decoder_frame_run_callback(struct ddl_context
*ddl_context)
{
struct ddl_client_context *ddl = ddl_context->current_ddl;
struct vidc_720p_dec_disp_info *dec_disp_info =
&(ddl->codec_data.decoder.dec_disp_info);
u32 callback_end = false;
u32 status = true, eos_present = false;;
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_FRAME_DONE)) {
VIDC_LOG_STRING("STATE-CRITICAL-DECFRMRUN");
ddl_client_fatal_cb(ddl_context);
return true;
}
VIDC_LOG_STRING("DEC_FRM_RUN_DONE");
ddl_move_command_state(ddl_context, DDL_CMD_INVALID);
vidc_720p_decode_display_info(dec_disp_info);
ddl_decode_dynamic_property(ddl, false);
if (dec_disp_info->resl_change) {
VIDC_LOG_STRING
("DEC_FRM_RUN_DONE: RECONFIG");
ddl_move_client_state(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE);
ddl_move_command_state(ddl_context, DDL_CMD_EOS);
vidc_720p_submit_command(ddl->channel_id,
VIDC_720P_CMD_FRAMERUN_REALLOCATE);
return false;
}
if ((VCD_FRAME_FLAG_EOS & ddl->input_frame.vcd_frm.flags)) {
callback_end = false;
eos_present = true;
}
if (dec_disp_info->disp_status == VIDC_720P_DECODE_ONLY ||
dec_disp_info->disp_status
== VIDC_720P_DECODE_AND_DISPLAY) {
if (!eos_present)
callback_end = (dec_disp_info->disp_status
== VIDC_720P_DECODE_ONLY);
ddl_decoder_input_done_callback(ddl, callback_end);
}
if (dec_disp_info->disp_status == VIDC_720P_DECODE_AND_DISPLAY
|| dec_disp_info->disp_status == VIDC_720P_DISPLAY_ONLY) {
if (!eos_present)
callback_end =
(dec_disp_info->disp_status
== VIDC_720P_DECODE_AND_DISPLAY);
if (ddl_decoder_output_done_callback(ddl, callback_end)
!= VCD_S_SUCCESS)
return true;
}
if (dec_disp_info->disp_status == VIDC_720P_DISPLAY_ONLY ||
dec_disp_info->disp_status == VIDC_720P_EMPTY_BUFFER) {
/* send the same input once again for decoding */
ddl_decode_frame_run(ddl);
/* client need to ignore the interrupt */
status = false;
} else if (eos_present) {
/* send EOS command to HW */
ddl_decode_eos_run(ddl);
/* client need to ignore the interrupt */
status = false;
} else {
ddl_move_client_state(ddl, DDL_CLIENT_WAIT_FOR_FRAME);
/* move to Idle */
DDL_IDLE(ddl_context);
}
return status;
}
