/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: Capability Manager to query capabilities from different

 *              adaptations and store it in a linked list.

 *

 */

#include "xacapabilitiesmgr.h"

#include "xammfcapabilitiesmgr.h"

#include "xagstcapabilitiesmgr.h"

#include <stdio.h>

#include <string.h>

        XACapabilities **ppNode);

static XAresult XACapabilitiesMgr_GetAudioOutputDeviceCapabilities(

        XACapabilities **ppNode);

/* XAresult XAGSTCapabilitiesMgr_UpdateAudioIOCapabilitieList

 */

XAresult XACapabilitiesMgr_UpdateAudioIOCapabilitieList(

        FrameworkMap *frameworkMap, XACapabilities **ppListHead)

    {

    XAresult res = XA_RESULT_SUCCESS;

    XACapabilities *newNode = NULL;

    if (!frameworkMap || !ppListHead)

        {

        return res;

        }

        {

        }

    if (res != XA_RESULT_SUCCESS)

        {

        return res;

        }

        {

        lastNode->next = newNode;

        }

        lastNode = newNode;

        }

    res = XACapabilitiesMgr_GetAudioOutputDeviceCapabilities(&newNode);

    if (res != XA_RESULT_SUCCESS)

        {

        return res;

        }

        {

        lastNode->next = newNode;

        lastNode = newNode;

        }

        {

        }

    DEBUG_API("<-XACapabilitiesMgr_UpdateAudioIOCapabilitieList");

    return res;

    }

XAresult XACapabilitiesMgr_CreateCapabilitieList(FrameworkMap* frameworkMap,

        XACapabilities** ppListHead)

    {

    XACapabilities* list = NULL;

    XAresult res = XA_RESULT_SUCCESS;

        {

        }

    *ppListHead = NULL;

    res = XACapabilitiesMgr_UpdateAudioIOCapabilitieList(frameworkMap, &list);

    if (res != XA_RESULT_SUCCESS)

        {

        XACapabilitiesMgr_DeleteCapabilitieList(&list);

        return res;

        }

    res = XAGSTCapabilitiesMgr_UpdateCapabilitieList(frameworkMap, &list);

    if (res != XA_RESULT_SUCCESS)

        {

        XACapabilitiesMgr_DeleteCapabilitieList(&list);

        return res;

        }

    res = XAMMFCapabilitiesMgr_UpdateCapabilitieList(frameworkMap, &list);

    if (res != XA_RESULT_SUCCESS)

        {

        XACapabilitiesMgr_DeleteCapabilitieList(&list);

        return res;

        }

    *ppListHead = list;

    return res;

    }

XAresult XACapabilitiesMgr_DeleteCapabilitieList(XACapabilities** ppListHead)

    {

    XACapabilities* currNode = NULL;

    XACapabilities* nextNode = NULL;

    XAresult res = XA_RESULT_SUCCESS;

    if (!ppListHead)

        {

        }

    currNode = *ppListHead;

    while (currNode)

        {

        if (currNode->capsType == AUD_I)

            {

            XAAudioInputDescriptor* entries =

                    (XAAudioInputDescriptor*) currNode->pEntry;

            XAint32 i;

            for (i = 0; i < currNode->noOfEntries; i++)

                {

                free(entries[i].samplingRatesSupported);

                free(entries[i].deviceName);

                }

            free(entries);

            }

        else if (currNode->capsType == AUD_O)

            {

            XAAudioOutputDescriptor* entries =

                    (XAAudioOutputDescriptor*) currNode->pEntry;

            XAint32 i;

            for (i = 0; i < currNode->noOfEntries; i++)

                {

                free(entries[i].samplingRatesSupported);

                free(entries[i].pDeviceName);

                }

            free(entries);

            }

        else if (currNode->capsType == AUD_E)

            {

            XAAudioCodecDescriptor* entries =

                    (XAAudioCodecDescriptor*) currNode->pEntry;

            XAint32 i;

            for (i = 0; i < currNode->noOfEntries; i++)

                {

                free(entries[i].pSampleRatesSupported);

                free(entries[i].pBitratesSupported);

                }

            free(entries);

            }

        if (currNode->adaptId)

            {

            free(currNode->adaptId);

            }

        nextNode = currNode->next;

        free(currNode);

        currNode = nextNode;

        }

    *ppListHead = NULL;

    return res;

    }

/* XAresult XACapabilitiesMgr_GetCapsCount

 * Description: Count capabilities of certain type. Filter is specified by

 *              bitmasking XACapsType values.

 */

XAresult XACapabilitiesMgr_GetCapsCount(XACapabilities* pListHead,

        XACapsType filter, XAuint32* count)

    {

    XAresult res = XA_RESULT_SUCCESS;

    XACapabilities* currNode = pListHead;

    DEBUG_API("->XACapabilitiesMgr_GetCapsCount");

    if (!currNode || !count)

        {

        }

    (*count) = 0;

    while (currNode)

        {

        if ((currNode->capsType & filter) == filter)

            {

            (*count)++;

            }

        currNode = currNode->next;

        }

    DEBUG_API("<-XACapabilitiesMgr_GetCapsCount");

    return res;

    }

/* XAresult XACapabilitiesMgr_GetCapsById

 * Description: Get capabilities of type XACapsType and matching id

 */

XAresult XACapabilitiesMgr_GetCapsById(XACapabilities* pListHead,

        XACapsType filter, XAuint32 maxId, XACapabilities* data)

    {

    XAresult res = XA_RESULT_SUCCESS;

    XACapabilities* currNode = pListHead;

    XAboolean found = XA_BOOLEAN_FALSE;

    DEBUG_API("->XACapabilitiesMgr_GetCapsById");

    if (!currNode)

        {

        }

    while (currNode)

        {

        if (((currNode->capsType & filter) == filter) && (maxId

                == currNode->xaid))

            {

            memcpy(data, currNode, sizeof(XACapabilities));

            found = XA_BOOLEAN_TRUE;

            break;

            }

        currNode = currNode->next;

        }

    if (!found)

        {

        }

    DEBUG_API("<-XACapabilitiesMgr_GetCapsById");

    return res;

    }

/* XAresult XACapabilitiesMgr_GetCapsByIdx

 * Description: Get n'th capabilities of type XACapsType

 */

XAresult XACapabilitiesMgr_GetCapsByIdx(XACapabilities* pListHead,

        XACapsType filter, XAuint32 idx, XACapabilities* data)

    {

    XAresult res = XA_RESULT_SUCCESS;

    XACapabilities* currNode = pListHead;

    XAboolean found = XA_BOOLEAN_FALSE;

    XAuint32 j = 0;

    DEBUG_API("->XACapabilitiesMgr_GetCapsByIdx");

    if (!currNode)

        {

        }

    while (currNode)

        {

        if ((currNode->capsType & filter) == filter)

            {

            if (idx == j++)

                {

                memcpy(data, currNode, sizeof(XACapabilities));

                found = XA_BOOLEAN_TRUE;

                break;

                }

            }

        currNode = currNode->next;

        }

    if (!found)

        {

        }

    DEBUG_API("<-XACapabilitiesMgr_GetCapsByIdx");

    return res;

    }

/* XAresult XACapabilitiesMgr_QueryColorFormats

 * Description: Get color formats associated with the XA_IMAGECODEC_RAW codec.

 */

XAresult XACapabilitiesMgr_QueryColorFormats(XACapabilities* pListHead,

        XAuint32* pIndex, XAuint32* pColorFormats)

    {

    XAresult res = XA_RESULT_SUCCESS;

    XACapabilities temp;

    DEBUG_API("->XACapabilitiesMgr_QueryColorFormats");

    if (!pIndex)

        {

        }

    res = XACapabilitiesMgr_GetCapsById(pListHead,

            (XACapsType) ((XACapsType) (XACAP_ENCODER | XACAP_IMAGE)),

            XA_IMAGECODEC_RAW, &temp);

    if (res == XA_RESULT_SUCCESS)

        {

        if (!pColorFormats)

            { /* query number of color formats */

            *pIndex = 1; /* one used by camera context */

            }

        else

            { /* query color format */

            if (*pIndex >= 1) /* one used by camera context */

                {

                res = XA_RESULT_PARAMETER_INVALID;

                }

            else

                { /* internal format used by pipeline, look camera context for details  */

                *pColorFormats = XA_COLORFORMAT_YUV420PLANAR;

                }

            }

        }

    else

        {

        *pIndex = 0;

        }

    DEBUG_API("<-XACapabilitiesMgr_QueryColorFormats");

    return res;

    }

/* Add AudioInputDeviceCaps */

        XACapabilities** ppNode)

    {

    XAresult res = XA_RESULT_SUCCESS;

    XACapabilities *newNode = NULL;

    XAAudioInputDescriptor *entries = NULL;

    int strLen = 0;

    newNode = (XACapabilities *) calloc(1, sizeof(XACapabilities));

    if (!newNode)

        {

        }

    newNode->capsType = AUD_I;