static void ddl_print_buffer(struct ddl_context *ddl_context,
struct ddl_buf_addr *buf, u32 idx, u8 *str)
{
struct ddl_buf_addr *base_ram;
s32 offset;
size_t sz, KB = 0;
base_ram = &ddl_context->dram_base_a;
offset = (s32) DDL_ADDR_OFFSET(*base_ram, *buf);
sz = buf->buffer_size;
if (sz > 0) {
if (!(sz % 1024)) {
sz /= 1024;
KB++;
if (!(sz % 1024)) {
sz /= 1024;
KB++;
}
}
}
DDL_MSG_LOW("\n%12s [%2d]: 0x%08x [0x%04x], 0x%08x(%d%s), %s",
str, idx, (u32) buf->align_physical_addr,
(offset > 0) ? offset : 0, buf->buffer_size, sz,
((2 == KB) ? "MB" : (1 == KB) ? "KB" : ""),
(((u32) buf->virtual_base_addr) ? "Alloc" : ""));
}
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;
}
static void ddl_print_port(struct ddl_context *ddl_context,
struct ddl_buf_addr *buf)
{
struct ddl_buf_addr *a = &ddl_context->dram_base_a;
struct ddl_buf_addr *b = &ddl_context->dram_base_b;
if (!buf->align_physical_addr || !buf->buffer_size)
return;
if (buf->align_physical_addr >= a->align_physical_addr &&
buf->align_physical_addr + buf->buffer_size <=
a->align_physical_addr + a->buffer_size)
DDL_MSG_LOW(" -A [0x%x]-", DDL_ADDR_OFFSET(*a, *buf));
else if (buf->align_physical_addr >= b->align_physical_addr &&
buf->align_physical_addr + buf->buffer_size <=
b->align_physical_addr + b->buffer_size)
DDL_MSG_LOW(" -B [0x%x]-", DDL_ADDR_OFFSET(*b, *buf));
else
DDL_MSG_LOW(" -?-");
}
static void ddl_encoder_frame_run_callback(
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;
DDL_MSG_MED("ddl_encoder_frame_run_callback");
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_FRAME_DONE) &&
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE)) {
DDL_MSG_ERROR("STATE-CRITICAL-ENCFRMRUN");
ddl_client_fatal_cb(ddl);
} else {
if (vidc_msg_timing)
ddl_calc_core_proc_time(__func__, ENC_OP_TIME);
DDL_MSG_LOW("ENC_FRM_RUN_DONE");
ddl->cmd_state = DDL_CMD_INVALID;
vidc_1080p_get_encode_frame_info(&encoder->enc_frame_info);
vidc_sm_get_frame_tags(&ddl->shared_mem
[ddl->command_channel],
&output_frame->ip_frm_tag, &bottom_frame_tag);
if (encoder->meta_data_enable_flag)
vidc_sm_get_metadata_status(&ddl->shared_mem
[ddl->command_channel],
&encoder->enc_frame_info.meta_data_exists);
if (encoder->enc_frame_info.enc_frame_size ||
(encoder->enc_frame_info.enc_frame ==
VIDC_1080P_ENCODE_FRAMETYPE_SKIPPED) ||
DDLCLIENT_STATE_IS(ddl,
DDL_CLIENT_WAIT_FOR_EOS_DONE)) {
u8 *input_buffer_address = NULL;
output_frame->data_len =
encoder->enc_frame_info.enc_frame_size;
output_frame->flags |= VCD_FRAME_FLAG_ENDOFFRAME;
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);
if (DDLCLIENT_STATE_IS(ddl,
DDL_CLIENT_WAIT_FOR_EOS_DONE) &&
encoder->i_period.b_frames) {
if ((ddl->extra_output_buf_count < 0) ||
(ddl->extra_output_buf_count >
encoder->i_period.b_frames)) {
DDL_MSG_ERROR("Invalid B frame output"
"buffer index");
} else {
struct vidc_1080p_enc_frame_start_param
enc_param;
ddl->output_frame = ddl->\
extra_output_frame[ddl->\
extra_output_buf_count];
ddl->\
extra_output_buf_count--;
output_frame =
&ddl->output_frame.\
vcd_frm;
memset(&enc_param, 0,
sizeof(enc_param));
enc_param.cmd_seq_num =
++ddl_context->cmd_seq_num;
enc_param.inst_id = ddl->instance_id;
enc_param.shared_mem_addr_offset =
DDL_ADDR_OFFSET(ddl_context->\
dram_base_a, ddl->shared_mem
[ddl->command_channel]);
enc_param.stream_buffer_addr_offset =
DDL_OFFSET(ddl_context->\
dram_base_a.\
align_physical_addr,
output_frame->physical);
enc_param.stream_buffer_size =
encoder->client_output_buf_req.sz;
enc_param.encode =
VIDC_1080P_ENC_TYPE_LAST_FRAME_DATA;
ddl->cmd_state = DDL_CMD_ENCODE_FRAME;
ddl_context->vidc_encode_frame_start
[ddl->command_channel]
(&enc_param);
} } else {
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_release_command_channel(ddl_context,
ddl->command_channel);
}
} else {
ddl_context->ddl_callback(
VCD_EVT_RESP_TRANSACTION_PENDING,
VCD_S_SUCCESS, NULL, 0, (u32 *)ddl,
ddl->client_data);
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_release_command_channel(ddl_context,
ddl->command_channel);
}
}
}