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

#include "xacapabilitiesmgr.h"
#include "xammfcapabilitiesmgr.h"
#include "xagstcapabilitiesmgr.h"
#include <stdio.h>
#include <string.h>

static XAresult XACapabilitiesMgr_GetAudioInputDeviceCapabilities(XACapabilities **ppNode);
static XAresult XACapabilitiesMgr_GetAudioOutputDeviceCapabilities(XACapabilities **ppNode);

/* XAresult XAGSTCapabilitiesMgr_UpdateAudioIOCapabilitieList
 * Description: Update the capabilities list supported by GStreamer framework.
 */
XAresult XACapabilitiesMgr_UpdateAudioIOCapabilitieList(
                FrameworkMap *frameworkMap,
                XACapabilities **ppListHead)

{
    XAresult res = XA_RESULT_SUCCESS;
    XACapabilities *lastNode;
    XACapabilities *firstNode ;
    XACapabilities *newNode = NULL;
    
    if(!frameworkMap || !ppListHead)
    {
        res = XA_RESULT_PARAMETER_INVALID;
        return res;
    }
    
     lastNode = *ppListHead;
     firstNode = *ppListHead;
     

    DEBUG_API("->XACapabilitiesMgr_UpdateAudioIOCapabilitieList");



    /* traverse and point to the last node in the list */
    while(lastNode && lastNode->next)
    {
        lastNode = lastNode->next;
    }

    /* If no input devices are supported, the function returns
     * XA_RESULT_SUCCESS and newNode will be NULL*/
    newNode = NULL;
    res = XACapabilitiesMgr_GetAudioInputDeviceCapabilities(&newNode);
    if (res != XA_RESULT_SUCCESS)
        {
        return res;
        }
    
    if (lastNode)
    {
        lastNode->next = newNode;
    }
    if (newNode)
    { /* if a new node is created move lastNode to the new item */
        if (!firstNode)
            firstNode = newNode;
        lastNode = newNode;
    }
    
    /* If no input devices are supported, the function returns
     * XA_RESULT_SUCCESS and newNode will be NULL*/
    newNode = NULL;
    res = XACapabilitiesMgr_GetAudioOutputDeviceCapabilities(&newNode);
    if (res != XA_RESULT_SUCCESS)
        {
        return res;
        }
    
    if (lastNode)
    {
        lastNode->next = newNode;
    }
    if (newNode)
    { /* if a new node is created move lastNode to the new item */
        if (!firstNode)
            firstNode = newNode;
        lastNode = newNode;
    }
    /* if empty list, then append first node as the head */
    if (!(*ppListHead))
        {
        *ppListHead = firstNode;
        }
    DEBUG_API("<-XACapabilitiesMgr_UpdateAudioIOCapabilitieList");
    return res;
}

XAresult XACapabilitiesMgr_CreateCapabilitieList(
            FrameworkMap* frameworkMap,
            XACapabilities** ppListHead)
{
    XACapabilities* list = NULL;
    XAresult res = XA_RESULT_SUCCESS;
    if(!ppListHead)
    {
        res = XA_RESULT_PARAMETER_INVALID;
        return res;
    }

    *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)
    {
        res = XA_RESULT_PARAMETER_INVALID;
        return res;
    }

    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)
    {
        res = XA_RESULT_PARAMETER_INVALID;
        return res;
    }

    (*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)
    {
        res = XA_RESULT_PARAMETER_INVALID;
        return res;
    }

    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)
    {
       res = XA_RESULT_FEATURE_UNSUPPORTED;
       return res;
    }

    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)
    {
        res = XA_RESULT_PARAMETER_INVALID;
        return res;
    }


    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)
    {
       res = XA_RESULT_PARAMETER_INVALID;
       return res;
    }

    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 )
    {
        DEBUG_ERR("illegal NULL parameter");
        res = XA_RESULT_PARAMETER_INVALID;
        return res;
    }

    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 */
            {
                DEBUG_ERR("index parameter invalid");
                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 */
XAresult XACapabilitiesMgr_GetAudioInputDeviceCapabilities(XACapabilities** ppNode)
{
    XAresult res = XA_RESULT_SUCCESS;
    XACapabilities *newNode = NULL;
    XAAudioInputDescriptor *entries = NULL;
/*    XAAudioInputDescriptor *entries = NULL;*/
    XAchar micDeviceName[] = "Default Mic";
    int strLen = 0;

    newNode = (XACapabilities *)calloc(1, sizeof(XACapabilities));
    if (!newNode)
    {
        res = XA_RESULT_MEMORY_FAILURE;
        return res;
    }

    newNode->capsType = AUD_I;
    newNode->xaid = 0xAD7E5001;
    newNode->noOfEntries = 1;

    /* Allocate array */
    entries = (XAAudioInputDescriptor*) calloc(1 , sizeof(XAAudioInputDescriptor));
    if (!entries)
    {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
    }

    newNode->pEntry = (void*)entries;
 
    strLen = strlen((char*)micDeviceName);
    entries->deviceName = (XAchar *)calloc(strLen + 1, sizeof(XAchar));
    if (!entries->deviceName)
    {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
    }

    strncpy((char*)entries->deviceName, (char*)micDeviceName, strLen);
    entries->deviceName[strLen] = '\0'; /*Null terminate it*/
    entries->deviceConnection = XA_DEVCONNECTION_INTEGRATED;
    entries->deviceScope = XA_DEVSCOPE_ENVIRONMENT;
    entries->deviceLocation = XA_DEVLOCATION_HANDSET;
    entries->isForTelephony = XA_BOOLEAN_FALSE;
    entries->minSampleRate=8000000; /* milliHz */
    entries->maxSampleRate = 96000000; /* milliHz */
    entries->isFreqRangeContinuous=XA_BOOLEAN_FALSE;
    entries->numOfSamplingRatesSupported = 12;
    entries->samplingRatesSupported = (XAmilliHertz*)calloc(entries->numOfSamplingRatesSupported, sizeof(XAmilliHertz));
    if (!entries->samplingRatesSupported)
    {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
    }
    /* entries in milliHz */
    entries->samplingRatesSupported[0] = 8000000;
    entries->samplingRatesSupported[1] = 11025000;
    entries->samplingRatesSupported[2] = 12000000;
    entries->samplingRatesSupported[3] = 16000000;
    entries->samplingRatesSupported[4] = 22050000;
    entries->samplingRatesSupported[5] = 24000000;
    entries->samplingRatesSupported[6] = 32000000;
    entries->samplingRatesSupported[7] = 44100000;
    entries->samplingRatesSupported[8] = 48000000;
    entries->samplingRatesSupported[9] = 64000000;
    entries->samplingRatesSupported[10] = 88200000;
    entries->samplingRatesSupported[11] = 96000000;
    entries->maxChannels = 2;

    newNode->pEntry = (void*)entries;

    *ppNode = newNode;
    return res;
}

XAresult XACapabilitiesMgr_GetAudioOutputDeviceCapabilities(XACapabilities **ppNode)
{
    XAresult res = XA_RESULT_SUCCESS;
    XACapabilities *newNode = NULL;
    XAAudioOutputDescriptor *entries = NULL;
/*    XAAudioOutputDescriptor *entries = NULL;*/
    XAchar outputDeviceName[] = "Default Speaker";
    int strLen = 0;

    newNode = (XACapabilities *)calloc(1, sizeof(XACapabilities));
    if (!newNode)
    {
        res = XA_RESULT_MEMORY_FAILURE;
        return res;
    }

    newNode->capsType = AUD_O;
    newNode->xaid = 0xAD7E5002;
    newNode->noOfEntries = 1;

    /* Allocate array */
    entries = (XAAudioOutputDescriptor*)calloc(1, sizeof(XAAudioOutputDescriptor));
    if (!entries)
    {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
    }

    newNode->pEntry = (void*)entries;

    strLen = strlen((char*)outputDeviceName);
    entries->pDeviceName = (XAchar *)calloc(strLen + 1, sizeof(XAchar));
    if (!entries->pDeviceName)
    {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
    }
    strncpy((char*)entries->pDeviceName, (char*)outputDeviceName, strLen);
    entries->pDeviceName[strLen] = '\0'; /*Null terminate it*/
    entries->deviceConnection = XA_DEVCONNECTION_INTEGRATED;
    entries->deviceScope = XA_DEVSCOPE_ENVIRONMENT;
    entries->deviceLocation = XA_DEVLOCATION_HANDSET;
    entries->isForTelephony = XA_BOOLEAN_FALSE;
    entries->minSampleRate = 8000000; /* milliHz */
    entries->maxSampleRate = 96000000; /* milliHz */
    entries->isFreqRangeContinuous = XA_BOOLEAN_FALSE;
    entries->numOfSamplingRatesSupported = 12;
    entries->samplingRatesSupported = (XAmilliHertz*)calloc(entries->numOfSamplingRatesSupported, sizeof(XAmilliHertz));
    if (!entries->samplingRatesSupported)
    {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
    }
    /* entries in milliHz */
    entries->samplingRatesSupported[0] = 8000000;
    entries->samplingRatesSupported[1] = 11025000;
    entries->samplingRatesSupported[2] = 12000000;
    entries->samplingRatesSupported[3] = 16000000;
    entries->samplingRatesSupported[4] = 22050000;
    entries->samplingRatesSupported[5] = 24000000;
    entries->samplingRatesSupported[6] = 32000000;
    entries->samplingRatesSupported[7] = 44100000;
    entries->samplingRatesSupported[8] = 48000000;
    entries->samplingRatesSupported[9] = 64000000;
    entries->samplingRatesSupported[10] = 88200000;
    entries->samplingRatesSupported[11] = 96000000;
    entries->maxChannels = 2;

    newNode->pEntry = (void*)entries;

    *ppNode = newNode;
    return res;
}