/*===========================================================================
* FUNCTION : sendCmd
*
* DESCRIPTION: send a command to the Cmd Thread
*
* PARAMETERS :
* @cmd : command to be executed.
* @sync_cmd: flag to indicate if this is a synchorinzed cmd. If true, this call
* will wait until signal is set after the command is completed.
* @priority: flag to indicate if this is a cmd with priority. If true, the cmd
* will be enqueued to the head with priority.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraCmdThread::sendCmd(camera_cmd_type_t cmd, uint8_t sync_cmd, uint8_t priority)
{
camera_cmd_t *node = (camera_cmd_t *)malloc(sizeof(camera_cmd_t));
if (NULL == node) {
ALOGE("%s: No memory for camera_cmd_t", __func__);
return NO_MEMORY;
}
memset(node, 0, sizeof(camera_cmd_t));
node->cmd = cmd;
if (priority) {
if (!cmd_queue.enqueueWithPriority((void *)node)) {
free(node);
node = NULL;
}
} else {
if (!cmd_queue.enqueue((void *)node)) {
free(node);
node = NULL;
}
}
cam_sem_post(&cmd_sem);
/* if is a sync call, need to wait until it returns */
if (sync_cmd) {
cam_sem_wait(&sync_sem);
}
return NO_ERROR;
}
/** mm_jpeg_job_done:
*
* Arguments:
* @p_session: decode session
*
* Return:
* OMX_ERRORTYPE
*
* Description:
* Finalize the job
*
**/
static void mm_jpegdec_job_done(mm_jpeg_job_session_t *p_session)
{
mm_jpeg_obj *my_obj = (mm_jpeg_obj *)p_session->jpeg_obj;
mm_jpeg_job_q_node_t *node = NULL;
/*Destroy job related params*/
mm_jpegdec_destroy_job(p_session);
/*remove the job*/
node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->ongoing_job_q,
p_session->jobId);
if (node) {
free(node);
}
p_session->encoding = OMX_FALSE;
/* wake up jobMgr thread to work on new job if there is any */
cam_sem_post(&my_obj->job_mgr.job_sem);
}
/** mm_jpegdec_destroy_session:
*
* Arguments:
* @my_obj: jpeg object
* @session_id: session index
*
* Return:
* 0 for success else failure
*
* Description:
* Destroy the encoding session
*
**/
int32_t mm_jpegdec_destroy_session(mm_jpeg_obj *my_obj,
mm_jpeg_job_session_t *p_session)
{
int32_t rc = 0;
mm_jpeg_job_q_node_t *node = NULL;
uint32_t session_id = p_session->sessionId;
if (NULL == p_session) {
CDBG_ERROR("%s:%d] invalid session", __func__, __LINE__);
return rc;
}
pthread_mutex_lock(&my_obj->job_lock);
/* abort job if in todo queue */
CDBG("%s:%d] abort todo jobs", __func__, __LINE__);
node = mm_jpeg_queue_remove_job_by_session_id(&my_obj->job_mgr.job_queue, session_id);
while (NULL != node) {
free(node);
node = mm_jpeg_queue_remove_job_by_session_id(&my_obj->job_mgr.job_queue, session_id);
}
/* abort job if in ongoing queue */
CDBG("%s:%d] abort ongoing jobs", __func__, __LINE__);
node = mm_jpeg_queue_remove_job_by_session_id(&my_obj->ongoing_job_q, session_id);
while (NULL != node) {
free(node);
node = mm_jpeg_queue_remove_job_by_session_id(&my_obj->ongoing_job_q, session_id);
}
/* abort the current session */
mm_jpeg_session_abort(p_session);
mm_jpegdec_session_destroy(p_session);
mm_jpeg_remove_session_idx(my_obj, session_id);
pthread_mutex_unlock(&my_obj->job_lock);
/* wake up jobMgr thread to work on new job if there is any */
cam_sem_post(&my_obj->job_mgr.job_sem);
CDBG("%s:%d] X", __func__, __LINE__);
return rc;
}
int32_t mm_camera_cmd_thread_stop(mm_camera_cmd_thread_t * cmd_thread)
{
int32_t rc = 0;
mm_camera_cmdcb_t* node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
if (NULL == node) {
CDBG_ERROR("%s: No memory for mm_camera_cmdcb_t", __func__);
return -1;
}
memset(node, 0, sizeof(mm_camera_cmdcb_t));
node->cmd_type = MM_CAMERA_CMD_TYPE_EXIT;
cam_queue_enq(&cmd_thread->cmd_queue, node);
cam_sem_post(&cmd_thread->cmd_sem);
/* wait until cmd thread exits */
if (pthread_join(cmd_thread->cmd_pid, NULL) != 0) {
CDBG("%s: pthread dead already\n", __func__);
}
return rc;
}
/** mm_jpeg_start_decode_job:
*
* Arguments:
* @my_obj: jpeg object
* @client_hdl: client handle
* @job: pointer to encode job
* @jobId: job id
*
* Return:
* 0 for success else failure
*
* Description:
* Start the encoding job
*
**/
int32_t mm_jpegdec_start_decode_job(mm_jpeg_obj *my_obj,
mm_jpeg_job_t *job,
uint32_t *job_id)
{
mm_jpeg_q_data_t qdata;
int32_t rc = -1;
uint8_t session_idx = 0;
uint8_t client_idx = 0;
mm_jpeg_job_q_node_t* node = NULL;
mm_jpeg_job_session_t *p_session = NULL;
mm_jpeg_decode_job_t *p_jobparams = &job->decode_job;
*job_id = 0;
/* check if valid session */
session_idx = GET_SESSION_IDX(p_jobparams->session_id);
client_idx = GET_CLIENT_IDX(p_jobparams->session_id);
CDBG("%s:%d] session_idx %d client idx %d", __func__, __LINE__,
session_idx, client_idx);
if ((session_idx >= MM_JPEG_MAX_SESSION) ||
(client_idx >= MAX_JPEG_CLIENT_NUM)) {
CDBG_ERROR("%s:%d] invalid session id %x", __func__, __LINE__,
job->decode_job.session_id);
return rc;
}
p_session = &my_obj->clnt_mgr[client_idx].session[session_idx];
if (OMX_FALSE == p_session->active) {
CDBG_ERROR("%s:%d] session not active %x", __func__, __LINE__,
job->decode_job.session_id);
return rc;
}
if ((p_jobparams->src_index >= (int32_t)p_session->dec_params.num_src_bufs) ||
(p_jobparams->dst_index >= (int32_t)p_session->dec_params.num_dst_bufs)) {
CDBG_ERROR("%s:%d] invalid buffer indices", __func__, __LINE__);
return rc;
}
/* enqueue new job into todo job queue */
node = (mm_jpeg_job_q_node_t *)malloc(sizeof(mm_jpeg_job_q_node_t));
if (NULL == node) {
CDBG_ERROR("%s: No memory for mm_jpeg_job_q_node_t", __func__);
return -1;
}
*job_id = job->decode_job.session_id |
((p_session->job_hist++ % JOB_HIST_MAX) << 16);
memset(node, 0, sizeof(mm_jpeg_job_q_node_t));
node->dec_info.decode_job = job->decode_job;
node->dec_info.job_id = *job_id;
node->dec_info.client_handle = p_session->client_hdl;
node->type = MM_JPEG_CMD_TYPE_DECODE_JOB;
qdata.p = node;
rc = mm_jpeg_queue_enq(&my_obj->job_mgr.job_queue, qdata);
if (0 == rc) {
cam_sem_post(&my_obj->job_mgr.job_sem);
}
return rc;
}