omxcore.c

Go to the documentation of this file.

#ifndef __SYMBIAN32__
#define _GNU_SOURCE
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <strings.h>
#include <errno.h>
#include <assert.h>

#include <OMX_Types.h>
#include <OMX_Core.h>
#include <OMX_Component.h>

#include "omxcore.h"
#include "omx_create_loaders.h"

static int initialized;

static int bosa_loaders;

BOSA_COMPONENTLOADER **loadersList = NULL;

OMX_ERRORTYPE BOSA_AddComponentLoader(BOSA_COMPONENTLOADER *pLoader) 
{
    BOSA_COMPONENTLOADER **newLoadersList = NULL;
    assert(pLoader);
    
    bosa_loaders++;
    newLoadersList = (BOSA_COMPONENTLOADER **) realloc(loadersList, bosa_loaders * sizeof(BOSA_COMPONENTLOADER *));
    
    if (!newLoadersList)
        return OMX_ErrorInsufficientResources;

    loadersList = newLoadersList;
    
    loadersList[bosa_loaders - 1] = pLoader;
    
    DEBUG(DEB_LEV_SIMPLE_SEQ, "Loader added at index %d\n", bosa_loaders - 1);
    
    return OMX_ErrorNone;   
}

OMX_ERRORTYPE OMX_Init() {
    int i = 0;
    OMX_ERRORTYPE err;

    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n", __func__);
    if(initialized == 0) {
        initialized = 1;

        createComponentLoaders();
        
        for (i = 0; i < bosa_loaders; i++) 
        {
            err = loadersList[i]->BOSA_InitComponentLoader(loadersList[i]);
            if (err != OMX_ErrorNone) 
            {
                DEBUG(DEB_LEV_ERR, "A Component loader constructor fails. Exiting\n");
                return OMX_ErrorInsufficientResources;
            }
        }       
    }

    DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
    return OMX_ErrorNone;
}

OMX_ERRORTYPE OMX_Deinit() {
    int i = 0;
    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
    if(initialized == 1) {
        for (i = 0; i < bosa_loaders; i++) {
            loadersList[i]->BOSA_DeInitComponentLoader(loadersList[i]);
            free(loadersList[i]);
            loadersList[i] = 0;
        }
    }   
    free(loadersList);
    loadersList = 0;
    initialized = 0;
    bosa_loaders = 0;
    DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
    return OMX_ErrorNone;
}

OMX_ERRORTYPE OMX_GetHandle(OMX_OUT OMX_HANDLETYPE* pHandle,
    OMX_IN  OMX_STRING cComponentName,
    OMX_IN  OMX_PTR pAppData,
    OMX_IN  OMX_CALLBACKTYPE* pCallBacks) {
    
    int i;
    OMX_ERRORTYPE err;
    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);

    for (i = 0; i < bosa_loaders; i++) {
        err = loadersList[i]->BOSA_CreateComponent(
                    loadersList[i],
                    pHandle,
                    cComponentName,
                    pAppData,
                    pCallBacks);
        if (err == OMX_ErrorNone) {
            // the component has been found
            return OMX_ErrorNone;
        }
    }
    DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
    return OMX_ErrorComponentNotFound;
}

OMX_ERRORTYPE OMX_FreeHandle(OMX_IN OMX_HANDLETYPE pHandle) 
{
    int i;
    OMX_ERRORTYPE err;

    for (i = 0; i < bosa_loaders; i++) 
    {
        err = loadersList[i]->BOSA_DestroyComponent(
                    loadersList[i],
                    pHandle);

        if (err == OMX_ErrorNone) 
        {
            // the component has been found and destroyed
            return OMX_ErrorNone;
        }
    }

    return OMX_ErrorComponentNotFound;
}

OMX_ERRORTYPE 
OMX_ComponentNameEnum(OMX_OUT OMX_STRING cComponentName,
                        OMX_IN OMX_U32 nNameLength,
                        OMX_IN OMX_U32 nIndex) 
{
    OMX_ERRORTYPE err = OMX_ErrorNone;
    int i = 0; 
    int index = 0;
    int offset = 0;
    
    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);

    for (i = 0; i < bosa_loaders; i++) 
    {
        offset = 0;

        while((err = loadersList[i]->BOSA_ComponentNameEnum(loadersList[i],
                cComponentName,
                nNameLength,
                offset)) != OMX_ErrorNoMore)
        {
            if (index == nIndex)
            {
                return err;
            }
            offset++;
            index++;       
        }
    }

    DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
    return OMX_ErrorNoMore;
}

OMX_ERRORTYPE OMX_SetupTunnel(
    OMX_IN  OMX_HANDLETYPE hOutput,
    OMX_IN  OMX_U32 nPortOutput,
    OMX_IN  OMX_HANDLETYPE hInput,
    OMX_IN  OMX_U32 nPortInput) {

    OMX_ERRORTYPE err;
    OMX_COMPONENTTYPE* component;
    OMX_TUNNELSETUPTYPE* tunnelSetup;
    
    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
    tunnelSetup = malloc(sizeof(OMX_TUNNELSETUPTYPE));
    component = (OMX_COMPONENTTYPE*)hOutput;
    tunnelSetup->nTunnelFlags = 0;
    tunnelSetup->eSupplier = OMX_BufferSupplyUnspecified;

    if (hOutput == NULL && hInput == NULL)
        return OMX_ErrorBadParameter;
    if (hOutput){
        err = (component->ComponentTunnelRequest)(hOutput, nPortOutput, hInput, nPortInput, tunnelSetup);
        if (err != OMX_ErrorNone) {
        DEBUG(DEB_LEV_ERR, "Tunneling failed: output port rejects it - err = %i\n", err);
        free(tunnelSetup);
        tunnelSetup = NULL;
        return err;
        }
    }
    DEBUG(DEB_LEV_PARAMS, "First stage of tunneling acheived:\n");
    DEBUG(DEB_LEV_PARAMS, "       - supplier proposed = %i\n", (int)tunnelSetup->eSupplier);
    DEBUG(DEB_LEV_PARAMS, "       - flags             = %i\n", (int)tunnelSetup->nTunnelFlags);
    
    component = (OMX_COMPONENTTYPE*)hInput;
    if (hInput) {
        err = (component->ComponentTunnelRequest)(hInput, nPortInput, hOutput, nPortOutput, tunnelSetup);
        if (err != OMX_ErrorNone) {
            DEBUG(DEB_LEV_ERR, "Tunneling failed: input port rejects it - err = %08x\n", err);
            // the second stage fails. the tunnel on poutput port has to be removed
            component = (OMX_COMPONENTTYPE*)hOutput;
            err = (component->ComponentTunnelRequest)(hOutput, nPortOutput, NULL, 0, tunnelSetup);
            if (err != OMX_ErrorNone) {
                // This error should never happen. It is critical, and not recoverable
                free(tunnelSetup);
                tunnelSetup = NULL;
                DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s with OMX_ErrorUndefined\n", __func__);
                return OMX_ErrorUndefined;
            }
            free(tunnelSetup);
            tunnelSetup = NULL;
            DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s with OMX_ErrorPortsNotCompatible\n", __func__);
            return OMX_ErrorPortsNotCompatible;
        }
    }
    DEBUG(DEB_LEV_PARAMS, "Second stage of tunneling acheived:\n");
    DEBUG(DEB_LEV_PARAMS, "       - supplier proposed = %i\n", (int)tunnelSetup->eSupplier);
    DEBUG(DEB_LEV_PARAMS, "       - flags             = %i\n", (int)tunnelSetup->nTunnelFlags);
    free(tunnelSetup);
    tunnelSetup = NULL;
    DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
    return OMX_ErrorNone;
}

OMX_ERRORTYPE OMX_GetRolesOfComponent ( 
  OMX_IN      OMX_STRING CompName, 
  OMX_INOUT   OMX_U32 *pNumRoles,
  OMX_OUT     OMX_U8 **roles) {
    OMX_ERRORTYPE err = OMX_ErrorNone;
    int i;
    
    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
    for (i = 0; i < bosa_loaders; i++) {
        err = loadersList[i]->BOSA_GetRolesOfComponent(
                    loadersList[i],
                    CompName,
                    pNumRoles,
                    roles);
        if (err == OMX_ErrorNone) {
            return OMX_ErrorNone;
        }
    }
    DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
    return OMX_ErrorComponentNotFound;
}

OMX_ERRORTYPE OMX_GetComponentsOfRole ( 
  OMX_IN      OMX_STRING role,
  OMX_INOUT   OMX_U32 *pNumComps,
  OMX_INOUT   OMX_U8  **compNames) {
  OMX_ERRORTYPE err = OMX_ErrorNone;
    int i,j;
    int only_number_requested = 0, full_number=0;
    OMX_U32 temp_num_comp = 0;
    
    OMX_U8 **tempCompNames;
    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
    if (compNames == NULL) {
        only_number_requested = 1;
    } else {
        only_number_requested = 0;
    }
    for (i = 0; i < bosa_loaders; i++) {
        temp_num_comp = *pNumComps;
        err = loadersList[i]->BOSA_GetComponentsOfRole(
                    loadersList[i],
                    role,
                    &temp_num_comp,
                    NULL);
        if (err != OMX_ErrorNone) {
            DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
            return OMX_ErrorComponentNotFound;
        }
        if (only_number_requested == 0) {
            tempCompNames = malloc(temp_num_comp * sizeof(OMX_STRING));
            for (j=0; j<temp_num_comp; j++) {
                tempCompNames[j] = malloc(OMX_MAX_STRINGNAME_SIZE * sizeof(char));
            }
            err = loadersList[i]->BOSA_GetComponentsOfRole(
                    loadersList[i],
                    role,
                    &temp_num_comp,
                    tempCompNames);
            if (err != OMX_ErrorNone) {
                DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
                return OMX_ErrorComponentNotFound;
            }
            
            for (j = 0; j<temp_num_comp; j++) {
                if (full_number + j < *pNumComps) {
                    strncpy((char *)compNames[full_number + j], (const char *)tempCompNames[j], 128);
                }
            }
        }
        full_number += temp_num_comp;
    }
    *pNumComps = full_number;
    DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
    return OMX_ErrorNone;
}


OMX_API OMX_ERRORTYPE   OMX_GetContentPipe(
    OMX_OUT OMX_HANDLETYPE *hPipe,
    OMX_IN OMX_STRING szURI) {
    (void)hPipe;
    (void)szURI;
    return OMX_ErrorUndefined;      
}

---

Generated for OpenMAX Bellagio rel. 0.3.5-svn by  1.5.1