/*

* 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: Audio IO Device capabilities Itf

*

*/

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <string.h>

#include "xaglobals.h"

#include "xaaudioiodevicecapabilitiesitf.h"

#include "xacapabilitiesmgr.h"

/* XAAudIODevCapaItfImpl* GetImpl

 * Description: Validate interface pointer and cast it to implementation pointer.

 */

static XAAudIODevCapaItfImpl* GetImpl(XAAudioIODeviceCapabilitiesItf self)

{

    if( self )

    {

        XAAudIODevCapaItfImpl* impl = (XAAudIODevCapaItfImpl*)(*self);

        if( impl && (impl == impl->self) )

        {

            return impl;

        }

    }

    return NULL;

}

/**

 * Base interface XAAudioIODeviceCapabilitiesItf implementation

 **/

/* XAresult XAAudIODevCapaItfImpl_GetAvailableAudioInputs

 * Description: Gets the number and IDs of audio input devices currently available.

 */

XAresult XAAudIODevCapaItfImpl_GetAvailableAudioInputs(

                                            XAAudioIODeviceCapabilitiesItf self,

                                            XAint32* pNumInputs,

                                            XAuint32* pInputDeviceIDs)

{

    XAAudIODevCapaItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAudIODevCapaItfImpl_GetAvailableAudioInputs");

    if( !impl || !pNumInputs )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        if( pInputDeviceIDs )

        {   /* query array of input devices */

            if( *pNumInputs < impl->numInputDevices )

            {

                DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");

                res = XA_RESULT_BUFFER_INSUFFICIENT;

            }

            else

            {

                XAuint32 i;

                XACapabilities temp;

                for( i=0; i<impl->numInputDevices; i++ )

                {

                    /* query device id from adaptation using index value */

                    res = XACapabilitiesMgr_GetCapsByIdx(impl->capslist, (XACapsType)(XACAP_DEVSRC|XACAP_AUDIO), i, &temp);

                    pInputDeviceIDs[i] = temp.xaid;

                }

                pInputDeviceIDs[0] = 0xAD7E5001;

            }

        }

        *pNumInputs = impl->numInputDevices;

    }

    DEBUG_API("<-XAAudIODevCapaItfImpl_GetAvailableAudioInputs");

    return res;

}

/* XAresult XAAudIODevCapaItfImpl_QueryAudioInputCapabilities

 * Description: Gets the capabilities of the specified audio input device.

 */

XAresult XAAudIODevCapaItfImpl_QueryAudioInputCapabilities(

                                            XAAudioIODeviceCapabilitiesItf self,

                                            XAuint32 deviceId,

                                            XAAudioInputDescriptor* pDescriptor)

{

    XAAudIODevCapaItfImpl* impl = GetImpl(self);

    XACapabilities temp;

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAudIODevCapaItfImpl_QueryAudioInputCapabilities");

    if( !impl || !pDescriptor )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        memset(pDescriptor,0,sizeof(XAAudioInputDescriptor));

        /* query capabilities from adaptation using device id */

        res = XACapabilitiesMgr_GetCapsById(impl->capslist, (XACapsType)(XACAP_DEVSRC|XACAP_AUDIO), deviceId, &temp);

        if( res == XA_RESULT_SUCCESS )

        {

            XAAudioInputDescriptor* desc = ((XAAudioInputDescriptor*)(temp.pEntry));

            /* map applicable values to XAAudioCodecCapabilities */

            pDescriptor->maxChannels=desc->maxChannels;

            {

            }

            else

            {

                pDescriptor->maxSampleRate = 0xFFFFFFFF;

            }

            /* other caps undefined */

    }

    DEBUG_API("<-XAAudIODevCapaItfImpl_QueryAudioInputCapabilities");

    return res;

}

/* XAresult XAAudIODevCapaItfImpl_RegisterAvailableAudioInputsChangedCallback

 * Description: Sets or clears xaAvailableAudioInputsChangedCallback().

 */

XAresult XAAudIODevCapaItfImpl_RegisterAvailableAudioInputsChangedCallback(

                                            XAAudioIODeviceCapabilitiesItf self,

                                            xaAvailableAudioInputsChangedCallback callback,

                                            void* pContext)

{

    XAAudIODevCapaItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAudIODevCapaItfImpl_RegisterAvailableAudioInputsChangedCallback");

    if( !impl )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        impl->inputCb = callback;

        impl->inputCbCtx = pContext;

        impl->inputCbPtrToSelf = self;

    }

    DEBUG_API("<-XAAudIODevCapaItfImpl_RegisterAvailableAudioInputsChangedCallback");

    return res;

}

/* XAresult XAAudIODevCapaItfImpl_GetAvailableAudioOutputs

 * Description: Gets the number and IDs of audio output devices currently available.

 */

XAresult XAAudIODevCapaItfImpl_GetAvailableAudioOutputs(

                                            XAAudioIODeviceCapabilitiesItf self,

                                            XAint32* pNumOutputs,

                                            XAuint32* pOutputDeviceIDs)

{

    XAAudIODevCapaItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAudIODevCapaItfImpl_GetAvailableAudioOutputs");

    /* NOTE: only default speaker supported by this impl */

    if( !impl || !pNumOutputs )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        if( pOutputDeviceIDs )

        {   /* query array of output devices */

            if( *pNumOutputs < impl->numOutputDevices )

            {

                DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");

                res = XA_RESULT_BUFFER_INSUFFICIENT;

            }

            else

            {

                XAuint32 i = 0;

                XACapabilities temp;

                for( i=0; i<impl->numOutputDevices; i++ )

                {

                    /* query device id from adaptation using index value */

                    res = XACapabilitiesMgr_GetCapsByIdx(impl->capslist, (XACapsType)(XACAP_DEVSNK|XACAP_AUDIO), i, &temp);

                    pOutputDeviceIDs[i] = temp.xaid;

                }

                pOutputDeviceIDs[0] = 0xAD7E5002;

            }

        }

        *pNumOutputs = impl->numOutputDevices;

    }

    DEBUG_API("<-XAAudIODevCapaItfImpl_GetAvailableAudioOutputs");

    return res;

}

/* XAresult XAAudIODevCapaItfImpl_QueryAudioOutputCapabilities

 * Description: Gets the capabilities of the specified audio output device.

 */

XAresult XAAudIODevCapaItfImpl_QueryAudioOutputCapabilities(

                                        XAAudioIODeviceCapabilitiesItf self,

                                        XAuint32 deviceId,

                                        XAAudioOutputDescriptor* pDescriptor)

{

    XAAudIODevCapaItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

    XACapabilities temp;

    DEBUG_API("->XAAudIODevCapaItfImpl_QueryAudioOutputCapabilities");

    if( !impl || !pDescriptor )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        memset(pDescriptor,0,sizeof(XAAudioOutputDescriptor));

        /* query capabilities from adaptation using device id */

        res = XACapabilitiesMgr_GetCapsById(impl->capslist, (XACapsType)(XACAP_DEVSNK|XACAP_AUDIO), deviceId, &temp);

        if( res == XA_RESULT_SUCCESS )

        {

            XAAudioOutputDescriptor* desc = ((XAAudioOutputDescriptor*)(temp.pEntry));

            /* map applicable values to XAAudioCodecCapabilities */

            pDescriptor->maxChannels=desc->maxChannels;

            {

            }

            else

            {

                pDescriptor->maxSampleRate = 0xFFFFFFFF;

            }

            /* other caps undefined */

    }

    DEBUG_API("<-XAAudIODevCapaItfImpl_QueryAudioOutputCapabilities");

    return res;

}

/* XAresult XAAudIODevCapaItfImpl_RegisterAvailableAudioOutputsChangedCallback

 * Description: Sets or clears xaAvailableAudioOutputsChangedCallback().

 */

XAresult XAAudIODevCapaItfImpl_RegisterAvailableAudioOutputsChangedCallback(

                                            XAAudioIODeviceCapabilitiesItf self,

                                            xaAvailableAudioOutputsChangedCallback callback,

                                            void* pContext)

{

    XAAudIODevCapaItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAudIODevCapaItfImpl_RegisterAvailableAudioOutputsChangedCallback");

    if( !impl )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        impl->outputCb = callback;

        impl->outputCbCtx = pContext;

        impl->outputCbPtrToSelf = self;

    }

    DEBUG_API("<-XAAudIODevCapaItfImpl_RegisterAvailableAudioOutputsChangedCallback");

    return res;

}

/* XAresult XAAudIODevCapaItfImpl_RegisterDefaultDeviceIDMapChangedCallback

 * Description: Sets or clears xaDefaultDeviceIDMapChangedCallback().

 */

XAresult XAAudIODevCapaItfImpl_RegisterDefaultDeviceIDMapChangedCallback(

                                            XAAudioIODeviceCapabilitiesItf self,

                                            xaDefaultDeviceIDMapChangedCallback callback,

                                            void* pContext)

{

    XAAudIODevCapaItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAudIODevCapaItfImpl_RegisterDefaultDeviceIDMapChangedCallback");

    if( !impl )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        impl->deviceMapCb = callback;

        impl->deviceMapCtx = pContext;

        impl->deviceMapCbPtrToSelf = self;

    }

    DEBUG_API("<-XAAudIODevCapaItfImpl_RegisterDefaultDeviceIDMapChangedCallback");

    return res;

}

/* XAresult XAAudIODevCapaItfImpl_GetAssociatedAudioInputs

 * Description: This method returns an array of audio input devices physically

 * associated with this audio I/O device.

 */

XAresult XAAudIODevCapaItfImpl_GetAssociatedAudioInputs(

                                                XAAudioIODeviceCapabilitiesItf self,

                                                XAuint32 deviceId,

                                                XAint32* pNumAudioInputs,

                                                XAuint32* pAudioInputDeviceIDs)

{

    XAAudIODevCapaItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAudIODevCapaItfImpl_GetAssociatedAudioInputs");

    if( !impl || !pNumAudioInputs )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        XACapabilities temp;

        XAuint32 associatedCount = 0;

        XAuint32 i = 0;

        for( i=0; i<impl->numInputDevices; i++ )

        {

            /* query device id from adaptation using index value */

            res = XACapabilitiesMgr_GetCapsByIdx(impl->capslist, (XACapsType)(XACAP_DEVSRC|XACAP_AUDIO), i, &temp);

            if (temp.xaid != deviceId)

            {

                associatedCount++;

            }

        }

        if (pAudioInputDeviceIDs)

        {

            if( *pNumAudioInputs < associatedCount )

            {

                DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");

                DEBUG_API("<-XAAudIODevCapaItfImpl_GetAssociatedAudioInputs");

                return XA_RESULT_BUFFER_INSUFFICIENT;

            }

            for( i=0, associatedCount = 0; i<impl->numInputDevices; i++ )

            {

                /* query device id from adaptation using index value */

                res = XACapabilitiesMgr_GetCapsByIdx(impl->capslist, (XACapsType)(XACAP_DEVSRC|XACAP_AUDIO), i, &temp);

                if (temp.xaid != deviceId)

                {

                    pAudioInputDeviceIDs[associatedCount++] = temp.xaid;

                }

            }

        }

        *pNumAudioInputs = associatedCount;

    if(!pAudioInputDeviceIDs)

        {

        switch(deviceId)

            {

            case 0xAD7E5001:

                *pNumAudioInputs = 0;

                break;

            case 0xAD7E5002:

                *pNumAudioInputs = 1;

                break;

            default:

                res = XA_RESULT_PARAMETER_INVALID;

                break;

            }

        }

    else

        {

        switch(deviceId)

            {

            case 0xAD7E5001:

                res = XA_RESULT_PARAMETER_INVALID;

                break;

            case 0xAD7E5002:

                pAudioInputDeviceIDs[*pNumAudioInputs - 1] = 0xAD7E5001;

                break;

            default:

                res = XA_RESULT_PARAMETER_INVALID;

                break;

            }

        }

    }

    DEBUG_API("<-XAAudIODevCapaItfImpl_GetAssociatedAudioInputs");

    return res;

}

/* XAresult XAAudIODevCapaItfImpl_GetAssociatedAudioOutputs

 * Description: This method returns an array of audio output devices physically

 * associated with this audio I/O device.

 */

XAresult XAAudIODevCapaItfImpl_GetAssociatedAudioOutputs(

                                                XAAudioIODeviceCapabilitiesItf self,

                                                XAuint32 deviceId,

                                                XAint32* pNumAudioOutputs,

                                                XAuint32* pAudioOutputDeviceIDs)

{

    XAAudIODevCapaItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAudIODevCapaItfImpl_GetAssociatedAudioOutputs");

    if( !impl || !pNumAudioOutputs )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        XACapabilities temp;

        XAuint32 associatedCount = 0;

        XAuint32 i = 0;

        for( i=0; i<impl->numOutputDevices; i++ )

        {

            /* query device id from adaptation using index value */

            res = XACapabilitiesMgr_GetCapsByIdx(impl->capslist, (XACapsType)(XACAP_DEVSNK|XACAP_AUDIO), i, &temp);

            if (temp.xaid != deviceId)

            {

                associatedCount++;

            }

        }

        if (pAudioOutputDeviceIDs)

        {

            if( *pNumAudioOutputs < associatedCount )

            {

                DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");

                DEBUG_API("<-XAAudIODevCapaItfImpl_GetAssociatedAudioOutputs");

                return XA_RESULT_BUFFER_INSUFFICIENT;

            }

            for( i=0, associatedCount = 0; i<impl->numOutputDevices; i++ )

            {

                /* query device id from adaptation using index value */

                res = XACapabilitiesMgr_GetCapsByIdx(impl->capslist, (XACapsType)(XACAP_DEVSNK|XACAP_AUDIO), i, &temp);

                if (temp.xaid != deviceId)

                {

                    pAudioOutputDeviceIDs[associatedCount++] = temp.xaid;

                }

            }

        }

        *pNumAudioOutputs = associatedCount;

        if(!pAudioOutputDeviceIDs)

            {

            switch(deviceId)

                {

                case 0xAD7E5002:

                    *pNumAudioOutputs = 0;

                    break;

                case 0xAD7E5001:

                    *pNumAudioOutputs = 1;

                    break;

                default:

                    res = XA_RESULT_PARAMETER_INVALID;

                    break;

                }

            }

        else

            {

            switch(deviceId)

                {

                case 0xAD7E5002:

                    res = XA_RESULT_PARAMETER_INVALID;

                    break;

                case 0xAD7E5001: