msmcobalt/QCamera2/stack/mm-jpeg-interface/src/mm_jpegdec.c

/* Copyright (c) 2013-2014, 2016, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *     * Neither the name of The Linux Foundation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

// System dependencies
#include <pthread.h>

// JPEG dependencies
#include "mm_jpeg_dbg.h"
#include "mm_jpeg_interface.h"
#include "mm_jpeg.h"
#include "mm_jpeg_inlines.h"

OMX_ERRORTYPE mm_jpegdec_ebd(OMX_HANDLETYPE hComponent,
  OMX_PTR pAppData,
  OMX_BUFFERHEADERTYPE *pBuffer);
OMX_ERRORTYPE mm_jpegdec_fbd(OMX_HANDLETYPE hComponent,
    OMX_PTR pAppData,
    OMX_BUFFERHEADERTYPE* pBuffer);
OMX_ERRORTYPE mm_jpegdec_event_handler(OMX_HANDLETYPE hComponent,
    OMX_PTR pAppData,
    OMX_EVENTTYPE eEvent,
    OMX_U32 nData1,
    OMX_U32 nData2,
    OMX_PTR pEventData);


/** mm_jpegdec_destroy_job
 *
 *  Arguments:
 *    @p_session: Session obj
 *
 *  Return:
 *       0 for success else failure
 *
 *  Description:
 *       Destroy the job based paramenters
 *
 **/
static int32_t mm_jpegdec_destroy_job(mm_jpeg_job_session_t *p_session)
{
  int32_t rc = 0;

  return rc;
}

/** 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_session_send_buffers:
 *
 *  Arguments:
 *    @data: job session
 *
 *  Return:
 *       OMX error values
 *
 *  Description:
 *       Send the buffers to OMX layer
 *
 **/
OMX_ERRORTYPE mm_jpegdec_session_send_buffers(void *data)
{
  uint32_t i = 0;
  mm_jpeg_job_session_t* p_session = (mm_jpeg_job_session_t *)data;
  OMX_ERRORTYPE ret = OMX_ErrorNone;
  QOMX_BUFFER_INFO lbuffer_info;
  mm_jpeg_decode_params_t *p_params = &p_session->dec_params;

  memset(&lbuffer_info, 0x0, sizeof(QOMX_BUFFER_INFO));
  for (i = 0; i < p_params->num_src_bufs; i++) {
    LOGD("Source buffer %d", i);
    lbuffer_info.fd = (OMX_U32)p_params->src_main_buf[i].fd;
    ret = OMX_UseBuffer(p_session->omx_handle, &(p_session->p_in_omx_buf[i]), 0,
      &lbuffer_info, p_params->src_main_buf[i].buf_size,
      p_params->src_main_buf[i].buf_vaddr);
    if (ret) {
      LOGE("Error %d", ret);
      return ret;
    }
  }

  LOGD("Exit");
  return ret;
}

/** mm_jpeg_session_free_buffers:
 *
 *  Arguments:
 *    @data: job session
 *
 *  Return:
 *       OMX error values
 *
 *  Description:
 *       Free the buffers from OMX layer
 *
 **/
OMX_ERRORTYPE mm_jpegdec_session_free_buffers(void *data)
{
  OMX_ERRORTYPE ret = OMX_ErrorNone;
  uint32_t i = 0;
  mm_jpeg_job_session_t* p_session = (mm_jpeg_job_session_t *)data;
  mm_jpeg_decode_params_t *p_params = &p_session->dec_params;

  for (i = 0; i < p_params->num_src_bufs; i++) {
    LOGD("Source buffer %d", i);
    ret = OMX_FreeBuffer(p_session->omx_handle, 0, p_session->p_in_omx_buf[i]);
    if (ret) {
      LOGE("Error %d", ret);
      return ret;
    }
  }

  for (i = 0; i < p_params->num_dst_bufs; i++) {
    LOGD("Dest buffer %d", i);
    ret = OMX_FreeBuffer(p_session->omx_handle, 1, p_session->p_out_omx_buf[i]);
    if (ret) {
      LOGE("Error");
      return ret;
    }
  }
  LOGD("Exit");
  return ret;
}

/** mm_jpegdec_session_create:
 *
 *  Arguments:
 *    @p_session: job session
 *
 *  Return:
 *       OMX error types
 *
 *  Description:
 *       Create a jpeg encode session
 *
 **/
OMX_ERRORTYPE mm_jpegdec_session_create(mm_jpeg_job_session_t* p_session)
{
  OMX_ERRORTYPE rc = OMX_ErrorNone;

  pthread_mutex_init(&p_session->lock, NULL);
  pthread_cond_init(&p_session->cond, NULL);
  cirq_reset(&p_session->cb_q);
  p_session->state_change_pending = OMX_FALSE;
  p_session->abort_state = MM_JPEG_ABORT_NONE;
  p_session->error_flag = OMX_ErrorNone;
  p_session->ebd_count = 0;
  p_session->fbd_count = 0;
  p_session->encode_pid = -1;
  p_session->config = OMX_FALSE;

  p_session->omx_callbacks.EmptyBufferDone = mm_jpegdec_ebd;
  p_session->omx_callbacks.FillBufferDone = mm_jpegdec_fbd;
  p_session->omx_callbacks.EventHandler = mm_jpegdec_event_handler;
  p_session->exif_count_local = 0;

  rc = OMX_GetHandle(&p_session->omx_handle,
    "OMX.qcom.image.jpeg.decoder",
    (void *)p_session,
    &p_session->omx_callbacks);

  if (OMX_ErrorNone != rc) {
    LOGE("OMX_GetHandle failed (%d)", rc);
    return rc;
  }
  return rc;
}

/** mm_jpegdec_session_destroy:
 *
 *  Arguments:
 *    @p_session: job session
 *
 *  Return:
 *       none
 *
 *  Description:
 *       Destroy a jpeg encode session
 *
 **/
void mm_jpegdec_session_destroy(mm_jpeg_job_session_t* p_session)
{
  OMX_ERRORTYPE rc = OMX_ErrorNone;

  LOGD("E");
  if (NULL == p_session->omx_handle) {
    LOGE("invalid handle");
    return;
  }

  rc = mm_jpeg_session_change_state(p_session, OMX_StateIdle, NULL);
  if (rc) {
    LOGE("Error");
  }

  rc = mm_jpeg_session_change_state(p_session, OMX_StateLoaded,
    mm_jpegdec_session_free_buffers);
  if (rc) {
    LOGE("Error");
  }

  rc = OMX_FreeHandle(p_session->omx_handle);
  if (0 != rc) {
    LOGE("OMX_FreeHandle failed (%d)", rc);
  }
  p_session->omx_handle = NULL;


  pthread_mutex_destroy(&p_session->lock);
  pthread_cond_destroy(&p_session->cond);
  LOGD("X");
}

/** mm_jpeg_session_config_port:
 *
 *  Arguments:
 *    @p_session: job session
 *
 *  Return:
 *       OMX error values
 *
 *  Description:
 *       Configure OMX ports
 *
 **/
OMX_ERRORTYPE mm_jpegdec_session_config_ports(mm_jpeg_job_session_t* p_session)
{
  OMX_ERRORTYPE ret = OMX_ErrorNone;
  mm_jpeg_decode_params_t *p_params = &p_session->dec_params;
  mm_jpeg_decode_job_t *p_jobparams = &p_session->decode_job;

  mm_jpeg_buf_t *p_src_buf =
    &p_params->src_main_buf[p_jobparams->src_index];

  p_session->inputPort.nPortIndex = 0;
  p_session->outputPort.nPortIndex = 1;


  ret = OMX_GetParameter(p_session->omx_handle, OMX_IndexParamPortDefinition,
    &p_session->inputPort);
  if (ret) {
    LOGE("failed");
    return ret;
  }

  ret = OMX_GetParameter(p_session->omx_handle, OMX_IndexParamPortDefinition,
    &p_session->outputPort);
  if (ret) {
    LOGE("failed");
    return ret;
  }

  p_session->inputPort.format.image.nFrameWidth =
    (OMX_U32)p_jobparams->main_dim.src_dim.width;
  p_session->inputPort.format.image.nFrameHeight =
    (OMX_U32)p_jobparams->main_dim.src_dim.height;
  p_session->inputPort.format.image.nStride =
    p_src_buf->offset.mp[0].stride;
  p_session->inputPort.format.image.nSliceHeight =
    (OMX_U32)p_src_buf->offset.mp[0].scanline;
  p_session->inputPort.format.image.eColorFormat =
    map_jpeg_format(p_params->color_format);
  p_session->inputPort.nBufferSize =
    p_params->src_main_buf[p_jobparams->src_index].buf_size;
  p_session->inputPort.nBufferCountActual = (OMX_U32)p_params->num_src_bufs;
  ret = OMX_SetParameter(p_session->omx_handle, OMX_IndexParamPortDefinition,
    &p_session->inputPort);
  if (ret) {
    LOGE("failed");
    return ret;
  }

  return ret;
}


/** mm_jpegdec_session_config_main:
 *
 *  Arguments:
 *    @p_session: job session
 *
 *  Return:
 *       OMX error values
 *
 *  Description:
 *       Configure main image
 *
 **/
OMX_ERRORTYPE mm_jpegdec_session_config_main(mm_jpeg_job_session_t *p_session)
{
  OMX_ERRORTYPE rc = OMX_ErrorNone;

  /* config port */
  LOGD("config port");
  rc = mm_jpegdec_session_config_ports(p_session);
  if (OMX_ErrorNone != rc) {
    LOGE("config port failed");
    return rc;
  }


  /* TODO: config crop */

  return rc;
}

/** mm_jpeg_session_configure:
 *
 *  Arguments:
 *    @data: encode session
 *
 *  Return:
 *       none
 *
 *  Description:
 *       Configure the session
 *
 **/
static OMX_ERRORTYPE mm_jpegdec_session_configure(mm_jpeg_job_session_t *p_session)
{
  OMX_ERRORTYPE ret = OMX_ErrorNone;

  LOGD("E ");

  MM_JPEG_CHK_ABORT(p_session, ret, error);

  /* config main img */
  ret = mm_jpegdec_session_config_main(p_session);
  if (OMX_ErrorNone != ret) {
    LOGE("config main img failed");
    goto error;
  }

  /* TODO: common config (if needed) */

  ret = mm_jpeg_session_change_state(p_session, OMX_StateIdle,
    mm_jpegdec_session_send_buffers);
  if (ret) {
    LOGE("change state to idle failed %d", ret);
    goto error;
  }

  ret = mm_jpeg_session_change_state(p_session, OMX_StateExecuting,
    NULL);
  if (ret) {
    LOGE("change state to executing failed %d", ret);
    goto error;
  }

error:
  LOGD("X ret %d", ret);
  return ret;
}

static OMX_ERRORTYPE mm_jpeg_session_port_enable(
    mm_jpeg_job_session_t *p_session,
    OMX_U32 nPortIndex,
    OMX_BOOL wait)
{
  OMX_ERRORTYPE ret = OMX_ErrorNone;
  OMX_EVENTTYPE lEvent;

  pthread_mutex_lock(&p_session->lock);
  p_session->event_pending = OMX_TRUE;
  pthread_mutex_unlock(&p_session->lock);

  ret = OMX_SendCommand(p_session->omx_handle, OMX_CommandPortEnable,
      nPortIndex, NULL);

  if (ret) {
    LOGE("failed");
    return ret;
  }

  if (wait == OMX_TRUE) {
    // Wait for cmd complete
    pthread_mutex_lock(&p_session->lock);
    if (p_session->event_pending == OMX_TRUE) {
      LOGD("before wait");
      pthread_cond_wait(&p_session->cond, &p_session->lock);
      lEvent = p_session->omxEvent;
      LOGD("after wait");
    }
    lEvent = p_session->omxEvent;
    pthread_mutex_unlock(&p_session->lock);

    if (lEvent != OMX_EventCmdComplete) {
      LOGD("Unexpected event %d",lEvent);
      return OMX_ErrorUndefined;
    }
  }
  return OMX_ErrorNone;
}

static OMX_ERRORTYPE mm_jpeg_session_port_disable(
    mm_jpeg_job_session_t *p_session,
    OMX_U32 nPortIndex,
    OMX_BOOL wait)
{
  OMX_ERRORTYPE ret = OMX_ErrorNone;
  OMX_EVENTTYPE lEvent;

  pthread_mutex_lock(&p_session->lock);
  p_session->event_pending = OMX_TRUE;
  pthread_mutex_unlock(&p_session->lock);

  ret = OMX_SendCommand(p_session->omx_handle, OMX_CommandPortDisable,
      nPortIndex, NULL);

  if (ret) {
    LOGE("failed");
    return ret;
  }
  if (wait == OMX_TRUE) {
    // Wait for cmd complete
    pthread_mutex_lock(&p_session->lock);
    if (p_session->event_pending == OMX_TRUE) {
      LOGD("before wait");
      pthread_cond_wait(&p_session->cond, &p_session->lock);

      LOGD("after wait");
    }
    lEvent = p_session->omxEvent;
    pthread_mutex_unlock(&p_session->lock);

    if (lEvent != OMX_EventCmdComplete) {
      LOGD("Unexpected event %d",lEvent);
      return OMX_ErrorUndefined;
    }
  }
  return OMX_ErrorNone;
}


/** mm_jpegdec_session_decode:
 *
 *  Arguments:
 *    @p_session: encode session
 *
 *  Return:
 *       OMX_ERRORTYPE
 *
 *  Description:
 *       Start the encoding
 *
 **/
static OMX_ERRORTYPE mm_jpegdec_session_decode(mm_jpeg_job_session_t *p_session)
{
  OMX_ERRORTYPE ret = OMX_ErrorNone;
  mm_jpeg_decode_params_t *p_params = &p_session->dec_params;
  mm_jpeg_decode_job_t *p_jobparams = &p_session->decode_job;
  OMX_EVENTTYPE lEvent;
  uint32_t i;
  QOMX_BUFFER_INFO lbuffer_info;

  pthread_mutex_lock(&p_session->lock);
  p_session->abort_state = MM_JPEG_ABORT_NONE;
  p_session->encoding = OMX_FALSE;
  pthread_mutex_unlock(&p_session->lock);

  if (OMX_FALSE == p_session->config) {
    ret = mm_jpegdec_session_configure(p_session);
    if (ret) {
      LOGE("Error");
      goto error;
    }
    p_session->config = OMX_TRUE;
  }

  pthread_mutex_lock(&p_session->lock);
  p_session->encoding = OMX_TRUE;
  pthread_mutex_unlock(&p_session->lock);

  MM_JPEG_CHK_ABORT(p_session, ret, error);

  p_session->event_pending = OMX_TRUE;

  ret = OMX_EmptyThisBuffer(p_session->omx_handle,
    p_session->p_in_omx_buf[p_jobparams->src_index]);
  if (ret) {
    LOGE("Error");
    goto error;
  }

  // Wait for port settings changed
  pthread_mutex_lock(&p_session->lock);
  if (p_session->event_pending == OMX_TRUE) {
    LOGD("before wait");
    pthread_cond_wait(&p_session->cond, &p_session->lock);
  }
  lEvent = p_session->omxEvent;
  LOGD("after wait");
  pthread_mutex_unlock(&p_session->lock);

  if (lEvent != OMX_EventPortSettingsChanged) {
    LOGD("Unexpected event %d",lEvent);
    goto error;
  }

  // Disable output port (wait)
  mm_jpeg_session_port_disable(p_session,
      p_session->outputPort.nPortIndex,
      OMX_TRUE);

  // Get port definition
  ret = OMX_GetParameter(p_session->omx_handle, OMX_IndexParamPortDefinition,
      &p_session->outputPort);
  if (ret) {
    LOGE("failed");
    return ret;
  }

  // Set port definition
  p_session->outputPort.format.image.nFrameWidth =
    (OMX_U32)p_jobparams->main_dim.dst_dim.width;
  p_session->outputPort.format.image.nFrameHeight =
    (OMX_U32)p_jobparams->main_dim.dst_dim.height;
  p_session->outputPort.format.image.eColorFormat =
    map_jpeg_format(p_params->color_format);

  p_session->outputPort.nBufferSize =
     p_params->dest_buf[p_jobparams->dst_index].buf_size;
   p_session->outputPort.nBufferCountActual = (OMX_U32)p_params->num_dst_bufs;

   p_session->outputPort.format.image.nSliceHeight =
       (OMX_U32)
       p_params->dest_buf[p_jobparams->dst_index].offset.mp[0].scanline;
   p_session->outputPort.format.image.nStride =
       p_params->dest_buf[p_jobparams->dst_index].offset.mp[0].stride;

   ret = OMX_SetParameter(p_session->omx_handle, OMX_IndexParamPortDefinition,
     &p_session->outputPort);
   if (ret) {
     LOGE("failed");
     return ret;
   }

  // Enable port (no wait)
  mm_jpeg_session_port_enable(p_session,
      p_session->outputPort.nPortIndex,
      OMX_FALSE);

  memset(&lbuffer_info, 0x0, sizeof(QOMX_BUFFER_INFO));
  // Use buffers
  for (i = 0; i < p_params->num_dst_bufs; i++) {
    lbuffer_info.fd = (OMX_U32)p_params->dest_buf[i].fd;
    LOGD("Dest buffer %d", (unsigned int)i);
    ret = OMX_UseBuffer(p_session->omx_handle, &(p_session->p_out_omx_buf[i]),
        1, &lbuffer_info, p_params->dest_buf[i].buf_size,
        p_params->dest_buf[i].buf_vaddr);
    if (ret) {
      LOGE("Error");
      return ret;
    }
  }

  // Wait for port enable completion
  pthread_mutex_lock(&p_session->lock);
  if (p_session->event_pending == OMX_TRUE) {
    LOGD("before wait");
    pthread_cond_wait(&p_session->cond, &p_session->lock);
    lEvent = p_session->omxEvent;
    LOGD("after wait");
  }
  lEvent = p_session->omxEvent;
  pthread_mutex_unlock(&p_session->lock);

  if (lEvent != OMX_EventCmdComplete) {
    LOGD("Unexpected event %d",lEvent);
    goto error;
  }

  ret = OMX_FillThisBuffer(p_session->omx_handle,
    p_session->p_out_omx_buf[p_jobparams->dst_index]);
  if (ret) {
    LOGE("Error");
    goto error;
  }

  MM_JPEG_CHK_ABORT(p_session, ret, error);

error:

  LOGD("X ");
  return ret;
}

/** mm_jpegdec_process_decoding_job:
 *
 *  Arguments:
 *    @my_obj: jpeg client
 *    @job_node: job node
 *
 *  Return:
 *       0 for success -1 otherwise
 *
 *  Description:
 *       Start the encoding job
 *
 **/
int32_t mm_jpegdec_process_decoding_job(mm_jpeg_obj *my_obj, mm_jpeg_job_q_node_t* job_node)
{
  mm_jpeg_q_data_t qdata;
  int32_t rc = 0;
  OMX_ERRORTYPE ret = OMX_ErrorNone;
  mm_jpeg_job_session_t *p_session = NULL;

  /* check if valid session */
  p_session = mm_jpeg_get_session(my_obj, job_node->dec_info.job_id);
  if (NULL == p_session) {
    LOGE("invalid job id %x",
      job_node->dec_info.job_id);
    return -1;
  }

  /* sent encode cmd to OMX, queue job into ongoing queue */
  qdata.p = job_node;
  rc = mm_jpeg_queue_enq(&my_obj->ongoing_job_q, qdata);
  if (rc) {
    LOGE("jpeg enqueue failed %d", ret);
    goto error;
  }

  p_session->decode_job = job_node->dec_info.decode_job;
  p_session->jobId = job_node->dec_info.job_id;
  ret = mm_jpegdec_session_decode(p_session);
  if (ret) {
    LOGE("encode session failed");
    goto error;
  }

  LOGD("Success X ");
  return rc;

error:

  if ((OMX_ErrorNone != ret) &&
    (NULL != p_session->dec_params.jpeg_cb)) {
    p_session->job_status = JPEG_JOB_STATUS_ERROR;
    LOGD("send jpeg error callback %d",
      p_session->job_status);
    p_session->dec_params.jpeg_cb(p_session->job_status,
      p_session->client_hdl,
      p_session->jobId,
      NULL,
      p_session->dec_params.userdata);
  }

  /*remove the job*/
  mm_jpegdec_job_done(p_session);
  LOGD("Error X ");

  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);
  LOGD("session_idx %d client idx %d",
    session_idx, client_idx);

  if ((session_idx >= MM_JPEG_MAX_SESSION) ||
    (client_idx >= MAX_JPEG_CLIENT_NUM)) {
    LOGE("invalid session id %x",
      job->decode_job.session_id);
    return rc;
  }

  p_session = &my_obj->clnt_mgr[client_idx].session[session_idx];
  if (OMX_FALSE == p_session->active) {
    LOGE("session not active %x",
      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)) {
    LOGE("invalid buffer indices");
    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) {
    LOGE("No memory for mm_jpeg_job_q_node_t");
    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;
}

/** mm_jpegdec_create_session:
 *
 *  Arguments:
 *    @my_obj: jpeg object
 *    @client_hdl: client handle
 *    @p_params: pointer to encode params
 *    @p_session_id: session id
 *
 *  Return:
 *       0 for success else failure
 *
 *  Description:
 *       Start the encoding session
 *
 **/
int32_t mm_jpegdec_create_session(mm_jpeg_obj *my_obj,
  uint32_t client_hdl,
  mm_jpeg_decode_params_t *p_params,
  uint32_t* p_session_id)
{
  int32_t rc = 0;
  OMX_ERRORTYPE ret = OMX_ErrorNone;
  uint8_t clnt_idx = 0;
  int session_idx = -1;
  mm_jpeg_job_session_t *p_session = NULL;
  *p_session_id = 0;

  /* validate the parameters */
  if ((p_params->num_src_bufs > MM_JPEG_MAX_BUF)
    || (p_params->num_dst_bufs > MM_JPEG_MAX_BUF)) {
    LOGE("invalid num buffers");
    return rc;
  }

  /* check if valid client */
  clnt_idx = mm_jpeg_util_get_index_by_handler(client_hdl);
  if (clnt_idx >= MAX_JPEG_CLIENT_NUM) {
    LOGE("invalid client with handler (%d)", client_hdl);
    return rc;
  }

  session_idx = mm_jpeg_get_new_session_idx(my_obj, clnt_idx, &p_session);
  if (session_idx < 0) {
    LOGE("invalid session id (%d)", session_idx);
    return rc;
  }

  ret = mm_jpegdec_session_create(p_session);
  if (OMX_ErrorNone != ret) {
    p_session->active = OMX_FALSE;
    LOGE("jpeg session create failed");
    return rc;
  }

  *p_session_id = (JOB_ID_MAGICVAL << 24) |
    ((unsigned)session_idx << 8) | clnt_idx;

  /*copy the params*/
  p_session->dec_params = *p_params;
  p_session->client_hdl = client_hdl;
  p_session->sessionId = *p_session_id;
  p_session->jpeg_obj = (void*)my_obj; /* save a ptr to jpeg_obj */
  LOGD("session id %x", *p_session_id);

  return rc;
}

/** 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;

  if (NULL == p_session) {
    LOGE("invalid session");
    return rc;
  }
  uint32_t session_id = p_session->sessionId;
  pthread_mutex_lock(&my_obj->job_lock);

  /* abort job if in todo queue */
  LOGD("abort todo jobs");
  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 */
  LOGD("abort ongoing jobs");
  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);
  LOGD("X");

  return rc;
}

/** mm_jpegdec_destroy_session_by_id:
 *
 *  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_by_id(mm_jpeg_obj *my_obj, uint32_t session_id)
{
  int32_t rc = 0;
  mm_jpeg_job_session_t *p_session = mm_jpeg_get_session(my_obj, session_id);

  if (NULL == p_session) {
    LOGE("session is not valid");
    return rc;
  }

  return mm_jpegdec_destroy_session(my_obj, p_session);
}



OMX_ERRORTYPE mm_jpegdec_ebd(OMX_HANDLETYPE hComponent,
  OMX_PTR pAppData,
  OMX_BUFFERHEADERTYPE *pBuffer)
{
  mm_jpeg_job_session_t *p_session = (mm_jpeg_job_session_t *) pAppData;

  LOGD("count %d ", p_session->ebd_count);
  pthread_mutex_lock(&p_session->lock);
  p_session->ebd_count++;
  pthread_mutex_unlock(&p_session->lock);
  return 0;
}

OMX_ERRORTYPE mm_jpegdec_fbd(OMX_HANDLETYPE hComponent,
  OMX_PTR pAppData,
  OMX_BUFFERHEADERTYPE *pBuffer)
{
  OMX_ERRORTYPE ret = OMX_ErrorNone;
  mm_jpeg_job_session_t *p_session = (mm_jpeg_job_session_t *) pAppData;
  mm_jpeg_output_t output_buf;

  LOGD("count %d ", p_session->fbd_count);

  pthread_mutex_lock(&p_session->lock);

  if (MM_JPEG_ABORT_NONE != p_session->abort_state) {
    pthread_mutex_unlock(&p_session->lock);
    return ret;
  }

  p_session->fbd_count++;
  if (NULL != p_session->dec_params.jpeg_cb) {
    p_session->job_status = JPEG_JOB_STATUS_DONE;
    output_buf.buf_filled_len = (uint32_t)pBuffer->nFilledLen;
    output_buf.buf_vaddr = pBuffer->pBuffer;
    output_buf.fd = -1;
    LOGD("send jpeg callback %d",
      p_session->job_status);
    p_session->dec_params.jpeg_cb(p_session->job_status,
      p_session->client_hdl,
      p_session->jobId,
      &output_buf,
      p_session->dec_params.userdata);

    /* remove from ready queue */
    mm_jpegdec_job_done(p_session);
  }
  pthread_mutex_unlock(&p_session->lock);
  LOGD("Exit");

  return ret;
}

OMX_ERRORTYPE mm_jpegdec_event_handler(OMX_HANDLETYPE hComponent,
  OMX_PTR pAppData,
  OMX_EVENTTYPE eEvent,
  OMX_U32 nData1,
  OMX_U32 nData2,
  OMX_PTR pEventData)
{
  mm_jpeg_job_session_t *p_session = (mm_jpeg_job_session_t *) pAppData;

  LOGD("%d %d %d state %d", eEvent, (int)nData1,
    (int)nData2, p_session->abort_state);

  LOGD("AppData=%p ", pAppData);

  pthread_mutex_lock(&p_session->lock);
  p_session->omxEvent = eEvent;
  if (MM_JPEG_ABORT_INIT == p_session->abort_state) {
    p_session->abort_state = MM_JPEG_ABORT_DONE;
    pthread_cond_signal(&p_session->cond);
    pthread_mutex_unlock(&p_session->lock);
    return OMX_ErrorNone;
  }

  if (eEvent == OMX_EventError) {
    if (p_session->encoding == OMX_TRUE) {
      LOGD("Error during encoding");

      /* send jpeg callback */
      if (NULL != p_session->dec_params.jpeg_cb) {
        p_session->job_status = JPEG_JOB_STATUS_ERROR;
        LOGD("send jpeg error callback %d",
          p_session->job_status);
        p_session->dec_params.jpeg_cb(p_session->job_status,
          p_session->client_hdl,
          p_session->jobId,
          NULL,
          p_session->dec_params.userdata);
      }

      /* remove from ready queue */
      mm_jpegdec_job_done(p_session);
    }
    pthread_cond_signal(&p_session->cond);
  } else if (eEvent == OMX_EventCmdComplete) {
    p_session->state_change_pending = OMX_FALSE;
    p_session->event_pending = OMX_FALSE;
    pthread_cond_signal(&p_session->cond);
  }  else if (eEvent == OMX_EventPortSettingsChanged) {
    p_session->event_pending = OMX_FALSE;
    pthread_cond_signal(&p_session->cond);
  }

  pthread_mutex_unlock(&p_session->lock);
  LOGD("Exit");
  return OMX_ErrorNone;
}

/** mm_jpegdec_abort_job:
 *
 *  Arguments:
 *    @my_obj: jpeg object
 *    @client_hdl: client handle
 *    @jobId: job id
 *
 *  Return:
 *       0 for success else failure
 *
 *  Description:
 *       Abort the encoding session
 *
 **/
int32_t mm_jpegdec_abort_job(mm_jpeg_obj *my_obj,
  uint32_t jobId)
{
  int32_t rc = -1;
  mm_jpeg_job_q_node_t *node = NULL;
  mm_jpeg_job_session_t *p_session = NULL;

  LOGD("Enter");
  pthread_mutex_lock(&my_obj->job_lock);

  /* abort job if in todo queue */
  node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->job_mgr.job_queue, jobId);
  if (NULL != node) {
    free(node);
    goto abort_done;
  }

  /* abort job if in ongoing queue */
  node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->ongoing_job_q, jobId);
  if (NULL != node) {
    /* find job that is OMX ongoing, ask OMX to abort the job */
    p_session = mm_jpeg_get_session(my_obj, node->dec_info.job_id);
    if (p_session) {
      mm_jpeg_session_abort(p_session);
    } else {
      LOGE("Invalid job id 0x%x",
        node->dec_info.job_id);
    }
    free(node);
    goto abort_done;
  }

abort_done:
  pthread_mutex_unlock(&my_obj->job_lock);

  return rc;
}
/** mm_jpegdec_init:
 *
 *  Arguments:
 *    @my_obj: jpeg object
 *
 *  Return:
 *       0 for success else failure
 *
 *  Description:
 *       Initializes the jpeg client
 *
 **/
int32_t mm_jpegdec_init(mm_jpeg_obj *my_obj)
{
  int32_t rc = 0;

  /* init locks */
  pthread_mutex_init(&my_obj->job_lock, NULL);

  /* init ongoing job queue */
  rc = mm_jpeg_queue_init(&my_obj->ongoing_job_q);
  if (0 != rc) {
    LOGE("Error");
    return -1;
  }

  /* init job semaphore and launch jobmgr thread */
  LOGD("Launch jobmgr thread rc %d", rc);
  rc = mm_jpeg_jobmgr_thread_launch(my_obj);
  if (0 != rc) {
    LOGE("Error");
    return -1;
  }

  /* load OMX */
  if (OMX_ErrorNone != OMX_Init()) {
    /* roll back in error case */
    LOGE("OMX_Init failed (%d)", rc);
    mm_jpeg_jobmgr_thread_release(my_obj);
    mm_jpeg_queue_deinit(&my_obj->ongoing_job_q);
    pthread_mutex_destroy(&my_obj->job_lock);
  }

  return rc;
}

/** mm_jpegdec_deinit:
 *
 *  Arguments:
 *    @my_obj: jpeg object
 *
 *  Return:
 *       0 for success else failure
 *
 *  Description:
 *       Deinits the jpeg client
 *
 **/
int32_t mm_jpegdec_deinit(mm_jpeg_obj *my_obj)
{
  int32_t rc = 0;

  /* release jobmgr thread */
  rc = mm_jpeg_jobmgr_thread_release(my_obj);
  if (0 != rc) {
    LOGE("Error");
  }

  /* unload OMX engine */
  OMX_Deinit();

  /* deinit ongoing job and cb queue */
  rc = mm_jpeg_queue_deinit(&my_obj->ongoing_job_q);
  if (0 != rc) {
    LOGE("Error");
  }

  /* destroy locks */
  pthread_mutex_destroy(&my_obj->job_lock);

  return rc;
}