自学教程：C++ DDL_MSG_LOW函数代码示例

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 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_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 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 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 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);}

void ddl_set_core_start_time(const char *func_name, u32 index){	u32 act_time;	struct timeval ddl_tv;	struct time_data *time_data = &proc_time[index];	do_gettimeofday(&ddl_tv);	act_time = (ddl_tv.tv_sec * 1000) + (ddl_tv.tv_usec / 1000);	if (!time_data->ddl_t1) {		time_data->ddl_t1 = act_time;		DDL_MSG_LOW("/n%s(): Start Time (%u)", func_name, act_time);	} else if (vidc_msg_timing) {		DDL_MSG_LOW("/n%s(): Timer already started! St(%u) Act(%u)",			func_name, time_data->ddl_t1, act_time);	}}

u32 ddl_fw_init(struct ddl_buf_addr *dram_base){	u8 *dest_addr;	dest_addr = DDL_GET_ALIGNED_VITUAL(*dram_base);	DDL_MSG_LOW("FW Addr / FW Size : %x/%d", (u32)vidc_video_codec_fw,		vidc_video_codec_fw_size);	if (res_trk_check_for_sec_session() && res_trk_is_cp_enabled()) {		if (res_trk_enable_footswitch()) {			pr_err("Failed to enable footswitch");			return false;		}		if (res_trk_enable_iommu_clocks()) {			res_trk_disable_footswitch();			pr_err("Failed to enable iommu clocks/n");			return false;		}		dram_base->pil_cookie = pil_get("vidc");		if (res_trk_disable_iommu_clocks())			pr_err("Failed to disable iommu clocks/n");		if (IS_ERR_OR_NULL(dram_base->pil_cookie)) {			res_trk_disable_footswitch();			pr_err("pil_get failed/n");			return false;		}	} else {		if (vidc_video_codec_fw_size > dram_base->buffer_size ||				!vidc_video_codec_fw)			return false;		memcpy(dest_addr, vidc_video_codec_fw,				vidc_video_codec_fw_size);	}	return true;}

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_sys_init_done_callback(struct ddl_context *ddl_context,	u32 fw_size){	u32 vcd_status = VCD_S_SUCCESS;	u8 *fw_ver;	DDL_MSG_MED("ddl_sys_init_done_callback");	if (!DDLCOMMAND_STATE_IS(ddl_context, DDL_CMD_DMA_INIT)) {		DDL_MSG_ERROR("UNKNOWN_SYS_INIT_DONE");	} else {		ddl_context->cmd_state = DDL_CMD_INVALID;		DDL_MSG_LOW("SYS_INIT_DONE");		vidc_1080p_get_fw_version(&ddl_context->fw_version);		fw_ver = (u8 *)&ddl_context->fw_version;		DDL_MSG_ERROR("fw_version %x:%x:20%x",			fw_ver[1]&0xFF, fw_ver[0]&0xFF, fw_ver[2]&0xFF);		if (ddl_context->fw_memory_size >= fw_size) {			ddl_context->device_state = DDL_DEVICE_INITED;			vcd_status = VCD_S_SUCCESS;		} else			vcd_status = VCD_ERR_FAIL;		ddl_context->ddl_callback(VCD_EVT_RESP_DEVICE_INIT,			vcd_status, NULL, 0, NULL,			ddl_context->client_data);		DDL_IDLE(ddl_context);	}}

static void ddl_print_buffer_port(struct ddl_context *ddl_context,	struct ddl_buf_addr *buf, u32 idx, u8 *str){	DDL_MSG_LOW("/n");	ddl_print_buffer(ddl_context, buf, idx, str);	ddl_print_port(ddl_context, buf);}

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_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 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 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;}

void ddl_update_core_start_time(const char *func_name, u32 index){	u32 act_time;	struct timeval ddl_tv;	struct time_data *time_data = &proc_time[index];	do_gettimeofday(&ddl_tv);	act_time = (ddl_tv.tv_sec * 1000) + (ddl_tv.tv_usec / 1000);	time_data->ddl_t1 = act_time;	DDL_MSG_LOW("/n%s(): Start time updated Act(%u)",				func_name, act_time);}

static void ddl_fw_status_done_callback(struct ddl_context_type *p_ddl_context){	DDL_MSG_MED("ddl_fw_status_done_callback");	if (!DDLCOMMAND_STATE_IS(p_ddl_context, DDL_CMD_DMA_INIT)) {		DDL_MSG_ERROR("UNKWN_DMADONE");	} else {		DDL_MSG_LOW("FW_STATUS_DONE");		vidc_1080p_set_host2risc_cmd(VIDC_1080P_HOST2RISC_CMD_SYS_INIT,			p_ddl_context->n_fw_ctxt_memory_size, 0, 0, 0);	}}

void *ddl_pmem_alloc(struct ddl_buf_addr *addr, size_t sz, u32 alignment){	u32 alloc_size, offset = 0;	DBG_PMEM("/n%s() IN: Requested alloc size(%u)", __func__, (u32)sz);	alloc_size = (sz + alignment);	addr->physical_base_addr = (u8 *) pmem_kalloc(alloc_size,		PMEM_MEMTYPE_SMI | PMEM_ALIGNMENT_4K);	if (!addr->physical_base_addr) {		DDL_MSG_ERROR("%s() : pmem alloc failed (%d)/n", __func__,			alloc_size);		return NULL;	}	DDL_MSG_LOW("%s() : pmem alloc physical base addr/sz 0x%x / %d/n",/		__func__, (u32)addr->physical_base_addr, alloc_size);	addr->virtual_base_addr = (u8 *)ioremap((unsigned long)		addr->physical_base_addr, alloc_size);	if (!addr->virtual_base_addr) {		DDL_MSG_ERROR("%s() : ioremap failed, virtual(%x)/n", __func__,			(u32)addr->virtual_base_addr);		return NULL;	}	DDL_MSG_LOW("%s() : pmem alloc virtual base addr/sz 0x%x / %d/n",/		__func__, (u32)addr->virtual_base_addr, alloc_size);	addr->align_physical_addr = (u8 *) DDL_ALIGN((u32)		addr->physical_base_addr, alignment);	offset = (u32)(addr->align_physical_addr -			addr->physical_base_addr);	addr->align_virtual_addr = addr->virtual_base_addr + offset;	addr->buffer_size = sz;	DDL_MSG_LOW("/n%s() : alig_phy_addr(%p) alig_vir_addr(%p)",		__func__, addr->align_physical_addr, addr->align_virtual_addr);	DBG_PMEM("/n%s() OUT: phy_addr(%p) vir_addr(%p) size(%u)",		__func__, addr->physical_base_addr, addr->virtual_base_addr,		addr->buffer_size);	return addr->virtual_base_addr;}

u32 ddl_fw_init(struct ddl_buf_addr *dram_base){	u8 *dest_addr;	dest_addr = DDL_GET_ALIGNED_VITUAL(*dram_base);	if (vidc_video_codec_fw_size > dram_base->buffer_size ||		!vidc_video_codec_fw)		return false;	DDL_MSG_LOW("FW Addr / FW Size : %x/%d", (u32)vidc_video_codec_fw,		vidc_video_codec_fw_size);	memcpy(dest_addr, vidc_video_codec_fw,		vidc_video_codec_fw_size);	return true;}

static void ddl_edfu_callback(struct ddl_context *ddl_context){	struct ddl_client_context *ddl;	u32 channel_inst_id;	DDL_MSG_MED("ddl_edfu_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_channel_id(ddl_context,			ddl_context->response_cmd_ch_id);	if (ddl) {		if (ddl->cmd_state != DDL_CMD_ENCODE_FRAME)			DDL_MSG_LOW("UNKWN_EDFU");	}}

static void get_dec_op_done_crop(u32 output_order,	struct vidc_1080p_dec_disp_info *dec_disp_info,	struct vcd_frame_rect *crop_data,	struct vcd_property_frame_size *op_frame_sz,	struct vcd_property_frame_size *frame_sz,	struct ddl_buf_addr *shared_mem){	u32 crop_exists =		(output_order == VCD_DEC_ORDER_DECODE) ?		dec_disp_info->dec_crop_exists :		dec_disp_info->disp_crop_exists;	crop_data->left = 0;	crop_data->top = 0;	crop_data->right = dec_disp_info->img_size_x;	crop_data->bottom = dec_disp_info->img_size_y;	op_frame_sz->width = dec_disp_info->img_size_x;	op_frame_sz->height = dec_disp_info->img_size_y;	ddl_calculate_stride(op_frame_sz, false);	op_frame_sz->stride = DDL_ALIGN(op_frame_sz->width,				DDL_TILE_ALIGN_WIDTH);	op_frame_sz->scan_lines = DDL_ALIGN(op_frame_sz->height,					DDL_TILE_ALIGN_HEIGHT);	DDL_MSG_LOW("%s img_size_x = %u img_size_y = %u/n",				__func__, dec_disp_info->img_size_x,				dec_disp_info->img_size_y);	if (crop_exists) {		if (output_order == VCD_DEC_ORDER_DECODE)			vidc_sm_get_dec_order_crop_info(shared_mem,				&dec_disp_info->crop_left_offset,				&dec_disp_info->crop_right_offset,				&dec_disp_info->crop_top_offset,				&dec_disp_info->crop_bottom_offset);		else			vidc_sm_get_crop_info(shared_mem,				&dec_disp_info->crop_left_offset,				&dec_disp_info->crop_right_offset,				&dec_disp_info->crop_top_offset,				&dec_disp_info->crop_bottom_offset);		crop_data->left = dec_disp_info->crop_left_offset;		crop_data->top = dec_disp_info->crop_top_offset;		crop_data->right -= dec_disp_info->crop_right_offset;		crop_data->bottom -= dec_disp_info->crop_bottom_offset;		op_frame_sz->width = crop_data->right - crop_data->left;		op_frame_sz->height = crop_data->bottom - crop_data->top;	}}

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);}

u32 ddl_process_core_response(void){	struct ddl_context *ddl_context;	struct ddl_hw_interface *ddl_hw_response;	u32 status = false;	ddl_context = ddl_get_context();	if (!ddl_context->core_virtual_base_addr) {		DDL_MSG_LOW("SPURIOUS_INTERRUPT");		return status;	}	ddl_hw_response = &ddl_context->ddl_hw_response;	status = ddl_process_intr_status(ddl_context, ddl_hw_response->cmd);	if (ddl_context->interrupt_clr)		(*ddl_context->interrupt_clr)();	return status;}

static u32 ddl_process_intr_status(struct ddl_context *ddl_context,	u32 intr_status){	u32 return_status = true;	switch (intr_status) {	case VIDC_1080P_RISC2HOST_CMD_OPEN_CH_RET:		return_status = ddl_channel_set_callback(ddl_context,			ddl_context->response_cmd_ch_id);	break;	case VIDC_1080P_RISC2HOST_CMD_CLOSE_CH_RET:		ddl_channel_end_callback(ddl_context);	break;	case VIDC_1080P_RISC2HOST_CMD_SEQ_DONE_RET:		return_status = ddl_sequence_done_callback(ddl_context);	break;	case VIDC_1080P_RISC2HOST_CMD_FRAME_DONE_RET:		return_status = ddl_frame_run_callback(ddl_context);	break;	case VIDC_1080P_RISC2HOST_CMD_SYS_INIT_RET:		ddl_sys_init_done_callback(ddl_context,			ddl_context->response_cmd_ch_id);	break;	case VIDC_1080P_RISC2HOST_CMD_FW_STATUS_RET:		ddl_fw_status_done_callback(ddl_context);	break;	case VIDC_1080P_RISC2HOST_CMD_EDFU_INT_RET:		ddl_edfu_callback(ddl_context);	break;	case VIDC_1080P_RISC2HOST_CMD_ENC_COMPLETE_RET:		ddl_encoder_eos_done(ddl_context);	break;	case VIDC_1080P_RISC2HOST_CMD_ERROR_RET:		DDL_MSG_ERROR("CMD_ERROR_INTR");		return_status = ddl_handle_core_errors(ddl_context);	break;	case VIDC_1080P_RISC2HOST_CMD_INIT_BUFFERS_RET:		return_status =			ddl_dpb_buffers_set_done_callback(ddl_context);	break;	default:		DDL_MSG_LOW("UNKWN_INTR");	break;	}	return return_status;}

static void ddl_decoder_eos_done_callback(	struct ddl_client_context_type *p_ddl){	struct ddl_context_type *p_ddl_context = p_ddl->p_ddl_context;	if (!p_ddl->b_decoding) {		DDL_MSG_ERROR("STATE-CRITICAL-EOSDONE");		ddl_client_fatal_cb(p_ddl);	} else {		p_ddl->e_client_state = DDL_CLIENT_WAIT_FOR_FRAME;		DDL_MSG_LOW("EOS_DONE");		p_ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE,			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);	}}