mm-image-codec/qomx_core/qomx_core.c

/*Copyright (c) 2012-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.*/

#define LOG_NDEBUG 0
#define LOG_NIDEBUG 0
#define LOG_TAG "qomx_image_core"

// System dependencies
#include <dlfcn.h>
#include <malloc.h>
#include <string.h>
#include <log/log.h>

// OpenMAX dependencies
#include "qomx_core.h"

#define BUFF_SIZE 255

static omx_core_t *g_omxcore;
static pthread_mutex_t g_omxcore_lock = PTHREAD_MUTEX_INITIALIZER;
static int g_omxcore_cnt = 0;

//Map the library name with the component name
static const comp_info_t g_comp_info[] =
{
  { "OMX.qcom.image.jpeg.encoder", "libqomx_jpegenc.so" },
  { "OMX.qcom.image.jpeg.decoder", "libqomx_jpegdec.so" },
  { "OMX.qcom.image.jpeg.encoder_pipeline", "libqomx_jpegenc_pipe.so" }
};

static int get_idx_from_handle(OMX_IN OMX_HANDLETYPE *ahComp, int *acompIndex,
  int *ainstanceIndex);

/*==============================================================================
* Function : OMX_Init
* Parameters: None
* Description: This is the first call that is made to the OMX Core
* and initializes the OMX IL core
==============================================================================*/
OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Init()
{
  OMX_ERRORTYPE rc = OMX_ErrorNone;
  int i = 0;
  int comp_cnt = sizeof(g_comp_info)/sizeof(g_comp_info[0]);

  pthread_mutex_lock(&g_omxcore_lock);

  /* check if core is created */
  if (g_omxcore) {
    g_omxcore_cnt++;
    pthread_mutex_unlock(&g_omxcore_lock);
    return rc;
  }

  if (comp_cnt > OMX_COMP_MAX_NUM) {
    ALOGE("%s:%d] cannot exceed max number of components",
      __func__, __LINE__);
    pthread_mutex_unlock(&g_omxcore_lock);
    return OMX_ErrorUndefined;
  }
  /* create new global object */
  g_omxcore = malloc(sizeof(omx_core_t));
  if (g_omxcore) {
    memset(g_omxcore, 0x0, sizeof(omx_core_t));

    /* populate the library name and component name */
    for (i = 0; i < comp_cnt; i++) {
      g_omxcore->component[i].comp_name = g_comp_info[i].comp_name;
      g_omxcore->component[i].lib_name = g_comp_info[i].lib_name;
    }
    g_omxcore->comp_cnt = comp_cnt;
    g_omxcore_cnt++;
  } else {
    rc = OMX_ErrorInsufficientResources;
  }
  pthread_mutex_unlock(&g_omxcore_lock);
  ALOGI("%s:%d] Complete %d", __func__, __LINE__, comp_cnt);
  return rc;
}

/*==============================================================================
* Function : OMX_Deinit
* Parameters: None
* Return Value : OMX_ERRORTYPE
* Description: Deinit all the OMX components
==============================================================================*/
OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Deinit()
{
  pthread_mutex_lock(&g_omxcore_lock);

  if (g_omxcore_cnt == 1) {
    if (g_omxcore) {
      free(g_omxcore);
      g_omxcore = NULL;
    }
  }
  if (g_omxcore_cnt) {
    g_omxcore_cnt--;
  }

  ALOGI("%s:%d] Complete", __func__, __LINE__);
  pthread_mutex_unlock(&g_omxcore_lock);
  return OMX_ErrorNone;
}

/*==============================================================================
* Function : get_comp_from_list
* Parameters: componentName
* Return Value : component_index
* Description: If the componnt is already present in the list, return the
* component index. If not return the next index to create the component.
==============================================================================*/
static int get_comp_from_list(char *comp_name)
{
  int index = -1, i = 0;

  if (NULL == comp_name)
    return -1;

  for (i = 0; i < g_omxcore->comp_cnt; i++) {
    if (!strcmp(g_omxcore->component[i].comp_name, comp_name)) {
      index = i;
      break;
    }
  }
  return index;
}

/*==============================================================================
* Function : get_free_inst_idx
* Parameters: p_comp
* Return Value : The next instance index if available
* Description: Get the next available index for to store the new instance of the
*            component being created.
*============================================================================*/
static int get_free_inst_idx(omx_core_component_t *p_comp)
{
  int idx = -1, i = 0;

  for (i = 0; i < OMX_COMP_MAX_INSTANCES; i++) {
    if (NULL == p_comp->handle[i]) {
      idx = i;
      break;
    }
  }
  return idx;
}

/*==============================================================================
* Function : OMX_GetHandle
* Parameters: handle, componentName, appData, callbacks
* Return Value : OMX_ERRORTYPE
* Description: Construct and load the requested omx library
==============================================================================*/
OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_GetHandle(
  OMX_OUT OMX_HANDLETYPE* handle,
  OMX_IN OMX_STRING componentName,
  OMX_IN OMX_PTR appData,
  OMX_IN OMX_CALLBACKTYPE* callBacks)
{
  OMX_ERRORTYPE rc = OMX_ErrorNone;
  int comp_idx = 0, inst_idx = 0;
  char libName[BUFF_SIZE] = {0};
  void *p_obj = NULL;
  OMX_COMPONENTTYPE *p_comp = NULL;
  omx_core_component_t *p_core_comp = NULL;
  OMX_BOOL close_handle = OMX_FALSE;

  if (NULL == handle) {
    ALOGE("%s:%d] Error invalid input ", __func__, __LINE__);
    return OMX_ErrorBadParameter;
  }

  pthread_mutex_lock(&g_omxcore_lock);

  comp_idx = get_comp_from_list(componentName);
  if (comp_idx < 0) {
    ALOGE("%s:%d] Cannot find the component", __func__, __LINE__);
    pthread_mutex_unlock(&g_omxcore_lock);
    return OMX_ErrorInvalidComponent;
  }
  p_core_comp = &g_omxcore->component[comp_idx];

  *handle = NULL;

  //If component already present get the instance index
  inst_idx = get_free_inst_idx(p_core_comp);
  if (inst_idx < 0) {
    ALOGE("%s:%d] Cannot alloc new instance", __func__, __LINE__);
    rc = OMX_ErrorInvalidComponent;
    goto error;
  }

  if (FALSE == p_core_comp->open) {
    /* load the library */
    p_core_comp->lib_handle = dlopen(p_core_comp->lib_name, RTLD_NOW);
    if (NULL == p_core_comp->lib_handle) {
      ALOGE("%s:%d] Cannot load the library", __func__, __LINE__);
      rc = OMX_ErrorInvalidComponent;
      goto error;
    }

    p_core_comp->open = TRUE;
    /* Init the component and get component functions */
    p_core_comp->create_comp_func = dlsym(p_core_comp->lib_handle,
      "create_component_fns");
    p_core_comp->get_instance = dlsym(p_core_comp->lib_handle, "getInstance");

    close_handle = OMX_TRUE;
    if (!p_core_comp->create_comp_func || !p_core_comp->get_instance) {
      ALOGE("%s:%d] Cannot maps the symbols", __func__, __LINE__);
      rc = OMX_ErrorInvalidComponent;
      goto error;
    }
  }

  /* Call the function from the address to create the obj */
  p_obj = (*p_core_comp->get_instance)();
  ALOGI("%s:%d] get instance pts is %p", __func__, __LINE__, p_obj);
  if (NULL == p_obj) {
    ALOGE("%s:%d] Error cannot create object", __func__, __LINE__);
    rc = OMX_ErrorInvalidComponent;
    goto error;
  }

  /* Call the function from the address to get the func ptrs */
  p_comp = (*p_core_comp->create_comp_func)(p_obj);
  if (NULL == p_comp) {
    ALOGE("%s:%d] Error cannot create component", __func__, __LINE__);
    rc = OMX_ErrorInvalidComponent;
    goto error;
  }

  *handle = p_core_comp->handle[inst_idx] = (OMX_HANDLETYPE)p_comp;

  ALOGD("%s:%d] handle = %p Instanceindex = %d,"
    "comp_idx %d g_ptr %p", __func__, __LINE__,
    p_core_comp->handle[inst_idx], inst_idx,
    comp_idx, g_omxcore);

  p_comp->SetCallbacks(p_comp, callBacks, appData);
  pthread_mutex_unlock(&g_omxcore_lock);
  ALOGI("%s:%d] Success", __func__, __LINE__);
  return OMX_ErrorNone;

error:

  if (OMX_TRUE == close_handle) {
    dlclose(p_core_comp->lib_handle);
    p_core_comp->lib_handle = NULL;
  }
  pthread_mutex_unlock(&g_omxcore_lock);
  ALOGE("%s:%d] Error %d", __func__, __LINE__, rc);
  return rc;
}

/*==============================================================================
* Function : getIndexFromComponent
* Parameters: handle,
* Return Value : Component present - true or false, Instance Index, Component
* Index
* Description: Check if the handle is present in the list and get the component
* index and instance index for the component handle.
==============================================================================*/
static int get_idx_from_handle(OMX_IN OMX_HANDLETYPE *ahComp, int *aCompIdx,
  int *aInstIdx)
{
  int i = 0, j = 0;
  for (i = 0; i < g_omxcore->comp_cnt; i++) {
    for (j = 0; j < OMX_COMP_MAX_INSTANCES; j++) {
      if ((OMX_COMPONENTTYPE *)g_omxcore->component[i].handle[j] ==
        (OMX_COMPONENTTYPE *)ahComp) {
        ALOGD("%s:%d] comp_idx %d inst_idx %d", __func__, __LINE__, i, j);
        *aCompIdx = i;
        *aInstIdx = j;
        return TRUE;
      }
    }
  }
  return FALSE;
}

/*==============================================================================
* Function : is_comp_active
* Parameters: p_core_comp
* Return Value : int
* Description: Check if the component has any active instances
==============================================================================*/
static uint8_t is_comp_active(omx_core_component_t *p_core_comp)
{
  uint8_t i = 0;
  for (i = 0; i < OMX_COMP_MAX_INSTANCES; i++) {
    if (NULL != p_core_comp->handle[i]) {
      return TRUE;
    }
  }
  return FALSE;
}

/*==============================================================================
* Function : OMX_FreeHandle
* Parameters: hComp
* Return Value : OMX_ERRORTYPE
* Description: Deinit the omx component and remove it from the global list
==============================================================================*/
OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_FreeHandle(
  OMX_IN OMX_HANDLETYPE hComp)
{
  OMX_ERRORTYPE rc = OMX_ErrorNone;
  int comp_idx, inst_idx;
  OMX_COMPONENTTYPE *p_comp = NULL;
  omx_core_component_t *p_core_comp = NULL;

  ALOGV("%s:%d] ", __func__, __LINE__);
  if (hComp == NULL) {
    return OMX_ErrorBadParameter;
  }

  pthread_mutex_lock(&g_omxcore_lock);

  p_comp = (OMX_COMPONENTTYPE *)hComp;
  if (FALSE == get_idx_from_handle(hComp, &comp_idx, &inst_idx)) {
    ALOGE("%s:%d] Error invalid component", __func__, __LINE__);
    pthread_mutex_unlock(&g_omxcore_lock);
    return OMX_ErrorInvalidComponent;
  }


  //Deinit the component;
  rc = p_comp->ComponentDeInit(hComp);
  if (rc != OMX_ErrorNone) {
    /* Remove the handle from the comp structure */
    ALOGE("%s:%d] Error comp deinit failed", __func__, __LINE__);
    pthread_mutex_unlock(&g_omxcore_lock);
    return OMX_ErrorInvalidComponent;
  }
  p_core_comp = &g_omxcore->component[comp_idx];
  p_core_comp->handle[inst_idx] = NULL;
  if (!is_comp_active(p_core_comp)) {
    rc = dlclose(p_core_comp->lib_handle);
    p_core_comp->lib_handle = NULL;
    p_core_comp->get_instance = NULL;
    p_core_comp->create_comp_func = NULL;
    p_core_comp->open = FALSE;
  } else {
    ALOGI("%s:%d] Error Component is still Active", __func__, __LINE__);
  }
  pthread_mutex_unlock(&g_omxcore_lock);
  ALOGV("%s:%d] Success", __func__, __LINE__);
  return rc;
}