Example #1
0
static void ddl_input_failed_cb(struct ddl_client_context_type *p_ddl,
	u32 vcd_event, u32 vcd_status)
{
	struct ddl_context_type *p_ddl_context = p_ddl->p_ddl_context;
	u32 n_payload_size = sizeof(struct ddl_frame_data_type_tag);

	p_ddl->e_cmd_state = DDL_CMD_INVALID;
	if (p_ddl->b_decoding)
		ddl_vidc_decode_dynamic_property(p_ddl, FALSE);
	else
		ddl_vidc_encode_dynamic_property(p_ddl, FALSE);
	if (p_ddl->e_client_state == DDL_CLIENT_WAIT_FOR_INITCODECDONE) {
		n_payload_size = 0;
		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;
	} else {
		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;
	}
	p_ddl_context->ddl_callback(vcd_event, vcd_status, &p_ddl->input_frame,
		n_payload_size, (u32 *)p_ddl, p_ddl->p_client_data);
}
Example #2
0
void ddl_client_fatal_cb(struct ddl_client_context_type *p_ddl)
{
	struct ddl_context_type *p_ddl_context = p_ddl->p_ddl_context;

	if (p_ddl->e_cmd_state == DDL_CMD_DECODE_FRAME)
		ddl_vidc_decode_dynamic_property(p_ddl, FALSE);
	else if (p_ddl->e_cmd_state == DDL_CMD_ENCODE_FRAME)
		ddl_vidc_encode_dynamic_property(p_ddl, FALSE);
	p_ddl->e_cmd_state = DDL_CMD_INVALID;
	DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_FAVIDC_ERROR",
		ddl_get_state_string(p_ddl->e_client_state));
	p_ddl->e_client_state = DDL_CLIENT_FAVIDC_ERROR;
	p_ddl_context->ddl_callback(VCD_EVT_IND_HWERRFATAL,
		VCD_ERR_CLIENT_FATAL, NULL, 0, (u32 *)p_ddl,
		p_ddl->p_client_data);
	ddl_release_command_channel(p_ddl_context, p_ddl->n_command_channel);
}
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 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);
		}
	}
}