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

u32 vcd_init_device_context(struct vcd_drv_ctxt *drv_ctxt,		u32 ev_code){	struct vcd_dev_ctxt *dev_ctxt = &drv_ctxt->dev_ctxt;	u32 rc;	struct ddl_init_config ddl_init;	VCD_MSG_LOW("vcd_init_device_context:");	dev_ctxt->pending_cmd = VCD_CMD_NONE;	rc = vcd_power_event(dev_ctxt, NULL, VCD_EVT_PWR_DEV_INIT_BEGIN);	VCD_FAILED_RETURN(rc, "VCD_EVT_PWR_DEV_INIT_BEGIN failed");	VCD_MSG_HIGH("Device powered ON and clocked");	rc = vcd_sched_create(&dev_ctxt->sched_clnt_list);	if (VCD_FAILED(rc)) {		VCD_MSG_ERROR("rc = 0x%x. Failed: vcd_sched_create", rc);		(void)vcd_power_event(dev_ctxt, NULL,					  VCD_EVT_PWR_DEV_INIT_FAIL);		return rc;	}	VCD_MSG_HIGH("Created scheduler instance.");	ddl_init.core_virtual_base_addr = dev_ctxt->device_base_addr;	ddl_init.interrupt_clr = dev_ctxt->config.interrupt_clr;	ddl_init.ddl_callback = vcd_ddl_callback;	rc = ddl_device_init(&ddl_init, NULL);	if (VCD_FAILED(rc)) {		VCD_MSG_ERROR("rc = 0x%x. Failed: ddl_device_init", rc);		vcd_sched_destroy(&dev_ctxt->sched_clnt_list);		(void)vcd_power_event(dev_ctxt, NULL,					  VCD_EVT_PWR_DEV_INIT_FAIL);	} else {		vcd_device_timer_start(dev_ctxt);		vcd_do_device_state_transition(drv_ctxt,						   VCD_DEVICE_STATE_INITING,						   ev_code);	}    #if 0// FEATURE_PANTECH_MMP_QCOM_CR, QC_Case#01099598, bump clock to turbo mode for clip which's macroblock count per second goes beyond 1080p 30fps  	dev_ctxt->turbo_mode_set = 0;    #endif	return rc;}

u32 vcd_init_device_context(struct vcd_drv_ctxt *drv_ctxt,		u32 ev_code){	struct vcd_dev_ctxt *dev_ctxt = &drv_ctxt->dev_ctxt;	u32 rc;	struct ddl_init_config ddl_init;	VCD_MSG_LOW("vcd_init_device_context:");	dev_ctxt->pending_cmd = VCD_CMD_NONE;	rc = vcd_power_event(dev_ctxt, NULL, VCD_EVT_PWR_DEV_INIT_BEGIN);	VCD_FAILED_RETURN(rc, "VCD_EVT_PWR_DEV_INIT_BEGIN failed");	VCD_MSG_HIGH("Device powered ON and clocked");	rc = vcd_sched_create(&dev_ctxt->sched_clnt_list);	if (VCD_FAILED(rc)) {		VCD_MSG_ERROR("rc = 0x%x. Failed: vcd_sched_create", rc);		(void)vcd_power_event(dev_ctxt, NULL,					  VCD_EVT_PWR_DEV_INIT_FAIL);		return rc;	}	VCD_MSG_HIGH("Created scheduler instance.");	ddl_init.core_virtual_base_addr = dev_ctxt->device_base_addr;	ddl_init.interrupt_clr = dev_ctxt->config.interrupt_clr;	ddl_init.ddl_callback = vcd_ddl_callback;	rc = ddl_device_init(&ddl_init, NULL);	if (VCD_FAILED(rc)) {		VCD_MSG_ERROR("rc = 0x%x. Failed: ddl_device_init", rc);		vcd_sched_destroy(&dev_ctxt->sched_clnt_list);		(void)vcd_power_event(dev_ctxt, NULL,					  VCD_EVT_PWR_DEV_INIT_FAIL);	} else {		vcd_device_timer_start(dev_ctxt);		vcd_do_device_state_transition(drv_ctxt,						   VCD_DEVICE_STATE_INITING,						   ev_code);	}	dev_ctxt->turbo_mode_set = 0;	return rc;}

void vcd_handle_device_init_failed(struct vcd_drv_ctxt_type_t *p_drv_ctxt,                                   u32 status){    struct vcd_clnt_ctxt_type_t *p_client;    struct vcd_clnt_ctxt_type_t *p_tmp_client;    VCD_MSG_ERROR("Device init failed. status = %d", status);    p_client = p_drv_ctxt->dev_ctxt.p_cctxt_list_head;    while (p_client) {        p_client->callback(VCD_EVT_RESP_OPEN,                           status, NULL, 0, 0, p_client->p_client_data);        p_tmp_client = p_client;        p_client = p_client->p_next;        vcd_destroy_client_context(p_tmp_client);    }    if (ddl_device_release(NULL))        VCD_MSG_ERROR("Failed: ddl_device_release");    (void)sched_destroy(p_drv_ctxt->dev_ctxt.sched_hdl);    p_drv_ctxt->dev_ctxt.sched_hdl = NULL;    if (vcd_power_event(&p_drv_ctxt->dev_ctxt,                        NULL, VCD_EVT_PWR_DEV_INIT_FAIL))        VCD_MSG_ERROR("VCD_EVT_PWR_DEV_INIT_FAIL failed");    vcd_do_device_state_transition(p_drv_ctxt,                                   VCD_DEVICE_STATE_NOT_INIT,                                   DEVICE_STATE_EVENT_NUMBER(pf_dev_cb));}

static u32 vcd_stop_in_run(struct vcd_clnt_ctxt *cctxt){	u32 rc = VCD_S_SUCCESS;	VCD_MSG_LOW("vcd_stop_in_run:");	rc = vcd_stop_cmn(cctxt);	if (!VCD_FAILED(rc) &&		(cctxt->status.mask & VCD_FIRST_IP_RCVD)) {		rc = vcd_power_event(cctxt->dev_ctxt,				     cctxt, VCD_EVT_PWR_CLNT_LAST_FRAME);	}	return rc;}

static u32 vcd_stop_in_run(struct vcd_clnt_ctxt_type_t *p_cctxt){	u32 rc = VCD_S_SUCCESS;	VCD_MSG_LOW("vcd_stop_in_run:");	rc = vcd_stop_cmn(p_cctxt);	if (!VCD_FAILED(rc) && p_cctxt->status.b_first_ip_frame_recvd) {		rc = vcd_power_event(p_cctxt->p_dev_ctxt,				     p_cctxt, VCD_EVT_PWR_CLNT_LAST_FRAME);	}	return rc;}

static u32 vcd_stop_in_eos(struct vcd_clnt_ctxt *cctxt){	u32 rc = VCD_S_SUCCESS;	VCD_MSG_LOW("vcd_stop_in_eos:");	if (cctxt->status.mask & VCD_EOS_WAIT_OP_BUF) {		rc = vcd_stop_cmn(cctxt);		if (!VCD_FAILED(rc)) {			rc = vcd_power_event(cctxt->dev_ctxt,				cctxt, VCD_EVT_PWR_CLNT_LAST_FRAME);			cctxt->status.mask &= ~VCD_EOS_WAIT_OP_BUF;		}	} else		cctxt->status.mask |= VCD_STOP_PENDING;	return rc;}

static u32 vcd_pause_in_run(struct vcd_clnt_ctxt_type_t *p_cctxt){    u32 rc = VCD_S_SUCCESS;    VCD_MSG_LOW("vcd_pause_in_run:");    if (p_cctxt->b_sched_clnt_valid) {        rc = vcd_map_sched_status(sched_suspend_resume_client                                  (p_cctxt->p_dev_ctxt->sched_hdl,                                   p_cctxt->sched_clnt_hdl, FALSE));    }    VCD_FAILED_RETURN(rc, "Failed: sched_suspend_resume_client");    if (p_cctxt->status.n_frame_submitted > 0) {        vcd_do_client_state_transition(p_cctxt,                                       VCD_CLIENT_STATE_PAUSING,                                       CLIENT_STATE_EVENT_NUMBER                                       (pf_pause));    } else {        VCD_MSG_HIGH("No client frames are currently being processed");        vcd_do_client_state_transition(p_cctxt,                                       VCD_CLIENT_STATE_PAUSED,                                       CLIENT_STATE_EVENT_NUMBER                                       (pf_pause));        p_cctxt->callback(VCD_EVT_RESP_PAUSE,                          VCD_S_SUCCESS,                          NULL, 0, p_cctxt, p_cctxt->p_client_data);        rc = vcd_power_event(p_cctxt->p_dev_ctxt, p_cctxt,                             VCD_EVT_PWR_CLNT_PAUSE);        if (VCD_FAILED(rc))            VCD_MSG_ERROR("VCD_EVT_PWR_CLNT_PAUSE_END failed");    }    return VCD_S_SUCCESS;}

static u32 vcd_resume_in_paused(struct vcd_clnt_ctxt_type_t *p_cctxt){    struct vcd_dev_ctxt_type *p_dev_ctxt = p_cctxt->p_dev_ctxt;    u32 rc = VCD_S_SUCCESS;    VCD_MSG_LOW("vcd_resume_in_paused:");    if (p_cctxt->b_sched_clnt_valid) {        rc = vcd_power_event(p_cctxt->p_dev_ctxt,                             p_cctxt, VCD_EVT_PWR_CLNT_RESUME);        if (VCD_FAILED(rc)) {            VCD_MSG_ERROR("VCD_EVT_PWR_CLNT_RESUME failed");        } else {            rc = vcd_map_sched_status(sched_suspend_resume_client                                      (p_cctxt->p_dev_ctxt->                                       sched_hdl,                                       p_cctxt->sched_clnt_hdl,                                       TRUE));            if (VCD_FAILED(rc)) {                VCD_MSG_ERROR                ("rc = 0x%x. Failed: "                 "sched_suspend_resume_client",                 rc);            }        }        if (!VCD_FAILED(rc))            vcd_try_submit_frame(p_dev_ctxt);    }    if (!VCD_FAILED(rc)) {        vcd_do_client_state_transition(p_cctxt,                                       VCD_CLIENT_STATE_RUN,                                       CLIENT_STATE_EVENT_NUMBER                                       (pf_resume));    }    return rc;}

static u32 vcd_resume_in_paused(struct vcd_clnt_ctxt *cctxt){	struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;	u32 rc = VCD_S_SUCCESS;	VCD_MSG_LOW("vcd_resume_in_paused:");	if (cctxt->sched_clnt_hdl) {		rc = vcd_power_event(cctxt->dev_ctxt,				     cctxt, VCD_EVT_PWR_CLNT_RESUME);		if (VCD_FAILED(rc)) {			VCD_MSG_ERROR("VCD_EVT_PWR_CLNT_RESUME failed");		} else {			rc = vcd_sched_suspend_resume_clnt(cctxt, true);			if (VCD_FAILED(rc)) {				VCD_MSG_ERROR				    ("rc = 0x%x. Failed: "				     "vcd_sched_suspend_resume_clnt",				     rc);			}		}		if (!VCD_FAILED(rc)) {			vcd_do_client_state_transition(cctxt,						       VCD_CLIENT_STATE_RUN,						       CLIENT_STATE_EVENT_NUMBER						       (resume));			vcd_try_submit_frame(dev_ctxt);		}	} else {		vcd_do_client_state_transition(cctxt,					       VCD_CLIENT_STATE_RUN,					       CLIENT_STATE_EVENT_NUMBER					       (resume));	}	return rc;}

static void vcd_clnt_cb_in_pausing    (struct vcd_clnt_ctxt *cctxt,     u32 event,     u32 status,     void *payload, size_t sz, u32 *ddl_handle, void *const client_data){	struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;	u32 rc = VCD_S_SUCCESS;	u32 frm_trans_end = false;	VCD_MSG_LOW("vcd_clnt_cb_in_pausing:");	if (cctxt->ddl_handle != ddl_handle) {		VCD_MSG_ERROR("ddl_handle mismatch");		return;	}	switch (event) {	case VCD_EVT_RESP_INPUT_DONE:		{			rc = vcd_handle_input_done(cctxt, payload, event,						   status);			break;		}	case VCD_EVT_RESP_OUTPUT_DONE:		{			rc = vcd_handle_frame_done(cctxt, payload, event,						   status);			break;		}	case VCD_EVT_RESP_OUTPUT_REQ:		{			rc = vcd_handle_output_required(cctxt, payload,				status);			break;		}	case VCD_EVT_IND_OUTPUT_RECONFIG:		{			rc = vcd_handle_ind_output_reconfig(cctxt,				payload, status);			if (!VCD_FAILED(rc)) {				frm_trans_end = true;				payload = NULL;			}			break;		}	case VCD_EVT_IND_HWERRFATAL:		{			vcd_handle_ind_hw_err_fatal(cctxt,				VCD_EVT_RESP_PAUSE,	status);			rc = VCD_ERR_FAIL;			break;		}	default:		{			VCD_MSG_ERROR			    ("Unexpected callback event=%d status=%d from DDL",			     event, status);			dev_ctxt->command_continue = false;			break;		}	}	if (!VCD_FAILED(rc)) {		if (payload &&			((struct ddl_frame_data_tag *)/			payload)->frm_trans_end) {			vcd_mark_frame_channel(cctxt->dev_ctxt);			frm_trans_end = true;		}		if (frm_trans_end && !cctxt->status.frame_submitted) {			VCD_MSG_HIGH			    ("All pending frames recvd from DDL");			cctxt->callback(VCD_EVT_RESP_PAUSE,					  VCD_S_SUCCESS,					  NULL,					  0,					  cctxt,					  cctxt->client_data);			vcd_do_client_state_transition(cctxt,					VCD_CLIENT_STATE_PAUSED,					CLIENT_STATE_EVENT_NUMBER						       (clnt_cb));			rc = vcd_power_event(cctxt->dev_ctxt,					     cctxt,					     VCD_EVT_PWR_CLNT_PAUSE);			if (VCD_FAILED(rc)) {				VCD_MSG_ERROR//.........这里部分代码省略.........

static void vcd_clnt_cb_in_pausing    (struct vcd_clnt_ctxt_type_t *p_cctxt,     u32 event,     u32 status,     void *p_payload, u32 size, u32 *ddl_handle, void *const p_client_data){	struct vcd_dev_ctxt_type *p_dev_ctxt = p_cctxt->p_dev_ctxt;	u32 rc = VCD_S_SUCCESS;	u32 b_frm_trans_end = FALSE;	VCD_MSG_LOW("vcd_clnt_cb_in_pausing:");	if (p_cctxt->ddl_handle != ddl_handle) {		VCD_MSG_ERROR("ddl_handle mismatch");		return;	}	switch (event) {	case VCD_EVT_RESP_INPUT_DONE:		{			rc = vcd_handle_input_done(p_cctxt, p_payload, event,						   status);			break;		}	case VCD_EVT_RESP_OUTPUT_DONE:		{			rc = vcd_handle_frame_done(p_cctxt, p_payload, event,						   status);			break;		}	case VCD_EVT_RESP_OUTPUT_REQ:		{			rc = vcd_handle_output_required(p_cctxt, p_payload,				status);			break;		}	case VCD_EVT_IND_OUTPUT_RECONFIG:		{			(void) vcd_handle_ind_output_reconfig(p_cctxt,				p_payload, status);			b_frm_trans_end = TRUE;			p_payload = NULL;			break;		}	case VCD_EVT_IND_HWERRFATAL:		{			vcd_handle_ind_hw_err_fatal(p_cctxt,				VCD_EVT_RESP_PAUSE,	status);			rc = VCD_ERR_FAIL;			break;		}	default:		{			VCD_MSG_ERROR			    ("Unexpected callback event=%d status=%d from DDL",			     event, status);			p_dev_ctxt->b_continue = FALSE;			break;		}	}	if (!VCD_FAILED(rc)) {		if (p_payload &&			((struct ddl_frame_data_type_tag *)/			p_payload)->b_frm_trans_end) {			vcd_mark_frame_channel(p_cctxt->p_dev_ctxt);			b_frm_trans_end = TRUE;		}		if (b_frm_trans_end && !p_cctxt->status.n_frame_submitted) {			VCD_MSG_HIGH			    ("All pending frames recvd from DDL");			p_cctxt->callback(VCD_EVT_RESP_PAUSE,					  VCD_S_SUCCESS,					  NULL,					  0,					  p_cctxt,					  p_cctxt->p_client_data);			vcd_do_client_state_transition(p_cctxt,					VCD_CLIENT_STATE_PAUSED,					CLIENT_STATE_EVENT_NUMBER						       (pf_clnt_cb));			rc = vcd_power_event(p_cctxt->p_dev_ctxt,					     p_cctxt,					     VCD_EVT_PWR_CLNT_PAUSE);			if (VCD_FAILED(rc)) {				VCD_MSG_ERROR//.........这里部分代码省略.........

void vcd_continue(void){    struct vcd_drv_ctxt_type_t *p_drv_ctxt;    struct vcd_dev_ctxt_type *p_dev_ctxt;    u32 b_continue;    struct vcd_transc_type *p_transc;    u32 rc;    VCD_MSG_LOW("vcd_continue:");    p_drv_ctxt = vcd_get_drv_context();    p_dev_ctxt = &p_drv_ctxt->dev_ctxt;    p_dev_ctxt->b_continue = FALSE;    if (p_dev_ctxt->e_pending_cmd == VCD_CMD_DEVICE_INIT) {        VCD_MSG_HIGH("VCD_CMD_DEVICE_INIT is pending");        p_dev_ctxt->e_pending_cmd = VCD_CMD_NONE;        (void)vcd_init_device_context(p_drv_ctxt,                                      DEVICE_STATE_EVENT_NUMBER(pf_open));    } else if (p_dev_ctxt->e_pending_cmd == VCD_CMD_DEVICE_TERM) {        VCD_MSG_HIGH("VCD_CMD_DEVICE_TERM is pending");        p_dev_ctxt->e_pending_cmd = VCD_CMD_NONE;        (void)vcd_deinit_device_context(p_drv_ctxt,                                        DEVICE_STATE_EVENT_NUMBER(pf_close));    } else if (p_dev_ctxt->e_pending_cmd == VCD_CMD_DEVICE_RESET) {        VCD_MSG_HIGH("VCD_CMD_DEVICE_RESET is pending");        p_dev_ctxt->e_pending_cmd = VCD_CMD_NONE;        (void)vcd_reset_device_context(p_drv_ctxt,                                       DEVICE_STATE_EVENT_NUMBER(pf_dev_cb));    } else {        if (p_dev_ctxt->b_set_perf_lvl_pending) {            rc = vcd_power_event(p_dev_ctxt, NULL,                                 VCD_EVT_PWR_DEV_SET_PERFLVL);            if (VCD_FAILED(rc)) {                VCD_MSG_ERROR                ("VCD_EVT_PWR_CLNT_SET_PERFLVL failed");                VCD_MSG_HIGH                ("Not running at desired perf level."                 "curr=%d, reqd=%d",                 p_dev_ctxt->n_curr_perf_lvl,                 p_dev_ctxt->n_reqd_perf_lvl);            } else {                p_dev_ctxt->b_set_perf_lvl_pending = FALSE;            }        }        do {            b_continue = FALSE;            if (vcd_get_command_channel_in_loop                    (p_dev_ctxt, &p_transc)) {                if (vcd_submit_command_in_continue(p_dev_ctxt,                                                   p_transc))                    b_continue = TRUE;                else {                    VCD_MSG_MED                    ("No more commands to submit");                    vcd_release_command_channel(p_dev_ctxt,                                                p_transc);                    vcd_release_interim_command_channels                    (p_dev_ctxt);                }            }        } while (b_continue);        do {            b_continue = FALSE;            if (vcd_get_frame_channel_in_loop                    (p_dev_ctxt, &p_transc)) {                if (vcd_try_submit_frame_in_continue(p_dev_ctxt,                                                     p_transc)) {                    b_continue = TRUE;                } else {                    VCD_MSG_MED("No more frames to submit");                    vcd_release_frame_channel(p_dev_ctxt,                                              p_transc);                    vcd_release_interim_frame_channels                    (p_dev_ctxt);                }            }        } while (b_continue);        if (!vcd_core_is_busy(p_dev_ctxt)) {            rc = vcd_power_event(p_dev_ctxt, NULL,                                 VCD_EVT_PWR_CLNT_CMD_END);            if (VCD_FAILED(rc))                VCD_MSG_ERROR("Failed:"                              "VCD_EVT_PWR_CLNT_CMD_END");//.........这里部分代码省略.........

static void vcd_dev_cb_in_initing(struct vcd_drv_ctxt_type_t *p_drv_ctxt, u32 event, u32 status, void *p_payload, u32 size, u32 *ddl_handle, void *const p_client_data){    struct vcd_dev_ctxt_type *p_dev_ctxt;    struct vcd_clnt_ctxt_type_t *p_client;    struct vcd_clnt_ctxt_type_t *p_tmp_client;    struct vcd_handle_container_type container;    u32 rc = VCD_S_SUCCESS;    u32 b_client_inited = FALSE;    u32 b_fail_all_open = FALSE;    VCD_MSG_LOW("vcd_dev_cb_in_initing:");    if (event != VCD_EVT_RESP_DEVICE_INIT) {        VCD_MSG_ERROR("vcd_dev_cb_in_initing: Unexpected event %d",                      (int)event);        return;    }    p_dev_ctxt = &p_drv_ctxt->dev_ctxt;    p_dev_ctxt->b_continue = FALSE;    if (VCD_FAILED(status)) {        vcd_handle_device_init_failed(p_drv_ctxt, status);        return;    }    vcd_do_device_state_transition(p_drv_ctxt,                                   VCD_DEVICE_STATE_READY,                                   DEVICE_STATE_EVENT_NUMBER(pf_open));    if (!p_dev_ctxt->p_cctxt_list_head) {        VCD_MSG_HIGH("All clients are closed");        p_dev_ctxt->e_pending_cmd = VCD_CMD_DEVICE_TERM;        return;    }    if (!p_dev_ctxt->n_ddl_cmd_ch_depth            || !p_dev_ctxt->a_trans_tbl)        rc = vcd_setup_with_ddl_capabilities(p_dev_ctxt);    if (VCD_FAILED(rc)) {        VCD_MSG_ERROR        ("rc = 0x%x: Failed vcd_setup_with_ddl_capabilities",         rc);        b_fail_all_open = TRUE;    }    p_client = p_dev_ctxt->p_cctxt_list_head;    while (p_client) {        if (!b_fail_all_open)            rc = vcd_init_client_context(p_client);        if (!VCD_FAILED(rc)) {            container.handle = (void *)p_client;            p_client->callback(VCD_EVT_RESP_OPEN,                               VCD_S_SUCCESS,                               &container,                               sizeof(container),                               container.handle,                               p_client->p_client_data);            p_client = p_client->p_next;            b_client_inited = TRUE;        } else {            VCD_MSG_ERROR            ("rc = 0x%x, Failed: vcd_init_client_context",             rc);            p_client->callback(VCD_EVT_RESP_OPEN,                               rc,                               NULL, 0, 0, p_client->p_client_data);            p_tmp_client = p_client;            p_client = p_client->p_next;            vcd_destroy_client_context(p_tmp_client);        }    }    if (!b_client_inited || b_fail_all_open) {        VCD_MSG_ERROR("All client open requests failed");        p_dev_ctxt->e_pending_cmd = VCD_CMD_DEVICE_TERM;    } else {        if (vcd_power_event(p_dev_ctxt, NULL,                            VCD_EVT_PWR_DEV_INIT_END)) {            VCD_MSG_ERROR("VCD_EVT_PWR_DEV_INIT_END failed");        }//.........这里部分代码省略.........