/*

* 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 <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <string.h>

#include "xaglobals.h"

#include "xaaudioencodercapabilitiesitf.h"

#ifdef _GSTREAMER_BACKEND_  

#include "XAStaticCapsAdaptation.h"

#endif

/* XAAudioEncoderCapabilitiesItfImpl* GetImpl

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

 */

static XAAudioEncoderCapabilitiesItfImpl* GetImpl(XAAudioEncoderCapabilitiesItf self)

{

    if( self )

    {

        XAAudioEncoderCapabilitiesItfImpl* impl = (XAAudioEncoderCapabilitiesItfImpl*)(*self);

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

        {

            return impl;

        }

    }

    return NULL;

}

/*****************************************************************************

 * Base interface XAAudioEncoderCapabilitiesItf implementation

 *****************************************************************************/

/* XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders

 * Description: Retrieves the available audio encoders.

 */

XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders(

                            XAAudioEncoderCapabilitiesItf self,

                            XAuint32* pNumEncoders,

                            XAuint32* pEncoderIds)

{

    XAAudioEncoderCapabilitiesItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders");

    if( !impl || !pNumEncoders )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

    }

    else

    {

        if( pEncoderIds )

        {   /* query array of encoders */

            if( *pNumEncoders < impl->numCodecs )

            {

                DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");

                res = XA_RESULT_BUFFER_INSUFFICIENT;

            }

            else

            {

#ifdef _GSTREAMER_BACKEND_  

                XAuint32 i = 0;

                XAStaticCapsData temp;

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

                {

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

                    XAStaticCapsAdapt_GetCapsByIdx(XACAP_ENCODER|XACAP_AUDIO, i, &temp);

                    pEncoderIds[i] = temp.xaid;

                }

#endif

            pEncoderIds[0] = XA_AUDIOCODEC_AMR;

            pEncoderIds[1] = XA_AUDIOCODEC_AAC;

            pEncoderIds[2] = XA_AUDIOCODEC_PCM;

            }

        }

    /* return number of encoders */

    *pNumEncoders = impl->numCodecs;

    }

    DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders");

    return res;

}

/* XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities

 * Description: Queries for the audio encoders capabilities.

 */

XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities(

                            XAAudioEncoderCapabilitiesItf self,

                            XAuint32 encoderId,

                            XAuint32 *pIndex,

                            XAAudioCodecDescriptor *pDescriptor)

{

    XAAudioEncoderCapabilitiesItfImpl* impl = GetImpl(self);

    XAresult res = XA_RESULT_SUCCESS;

#ifdef _GSTREAMER_BACKEND_  

    XAStaticCapsData temp;

#endif

    DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities");

    /*if( !impl || !pIndex || !pDescriptor )*/

    /*Removing the pDescriptor because the client can pass

     * it as NULL to query the pIndex for number of Codec/Mode

     * pair capabilities for each encoder */

    if( !impl || !pIndex )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        res = XA_RESULT_PARAMETER_INVALID;

        return res;

    }

    else

    {

    	*pIndex = 1;

        if(!pDescriptor)

            {

            return res;

            }

  	}

  	/* query capabilities from adaptation using codec id */

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

    switch (encoderId)

        {

        case XA_AUDIOCODEC_AMR: 

            {

            impl->sampleRateArray[0] = 8000000;

            impl->bitRateArray[0] = 4750;

            impl->bitRateArray[1] = 5150;

            impl->bitRateArray[2] = 5900;

            impl->bitRateArray[3] = 6700;

            impl->bitRateArray[4] = 7400;

            impl->bitRateArray[5] = 7950;

            impl->bitRateArray[6] = 10200;            

            impl->bitRateArray[7] = 12200;

            pDescriptor->maxChannels = 1;

            pDescriptor->minBitsPerSample = 8;

            pDescriptor->maxBitsPerSample = 8;

            pDescriptor->minSampleRate = 8000000;  /*milliHz*/ 

            pDescriptor->maxSampleRate = 8000000;

            pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_FALSE;

            pDescriptor->pSampleRatesSupported = (XAmilliHertz*)(&(impl->sampleRateArray));

            pDescriptor->numSampleRatesSupported = 1;

            pDescriptor->minBitRate=4750;

            pDescriptor->maxBitRate=12200;

            pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_FALSE;

            pDescriptor->pBitratesSupported = (XAuint32*)(&(impl->bitRateArray));

            pDescriptor->numBitratesSupported = 8;

            pDescriptor->profileSetting = XA_AUDIOPROFILE_AMR;

            pDescriptor->modeSetting = 0;

            }

            break;

        case XA_AUDIOCODEC_AAC: 

            {

            impl->sampleRateArray[0] = 8000000;

            impl->sampleRateArray[1] = 11025000;

            impl->sampleRateArray[2] = 16000000;

            impl->sampleRateArray[3] = 22050000;

            impl->sampleRateArray[4] = 32000000;

            impl->sampleRateArray[5] = 44100000;

            impl->sampleRateArray[6] = 48000000;

            impl->bitRateArray[0] = 32000;

            impl->bitRateArray[1] = 64000;

            impl->bitRateArray[2] = 96000;

            impl->bitRateArray[3] = 128000;

            impl->bitRateArray[4] = 160000;

            impl->bitRateArray[5] = 192000;

            impl->bitRateArray[6] = 224000;            

            impl->bitRateArray[7] = 256000;    

            pDescriptor->maxChannels = 2;

            pDescriptor->minBitsPerSample = 16;

            pDescriptor->maxBitsPerSample = 16;

            pDescriptor->minSampleRate = 8000*1000;  /*milliHz*/ 

            pDescriptor->maxSampleRate = 48000 * 1000;

            pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_FALSE;

            pDescriptor->pSampleRatesSupported = (XAmilliHertz*)(&(impl->sampleRateArray));

            pDescriptor->numSampleRatesSupported = 7;

            pDescriptor->minBitRate=32000;

            pDescriptor->maxBitRate=256000;

            pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_FALSE;

            pDescriptor->pBitratesSupported = (XAuint32*)(&(impl->bitRateArray));

            pDescriptor->numBitratesSupported = 8;

            pDescriptor->profileSetting = XA_AUDIOPROFILE_AAC_AAC;

            pDescriptor->modeSetting = XA_AUDIOMODE_AAC_LC;

            }

            break;

        case XA_AUDIOCODEC_PCM: 

            {

            impl->sampleRateArray[0] = 12000000;

            impl->sampleRateArray[1] = 16000000;

            impl->sampleRateArray[2] = 22050000;

            impl->sampleRateArray[3] = 24000000;

            impl->sampleRateArray[4] = 32000000;

            impl->sampleRateArray[5] = 44100000;

            impl->sampleRateArray[6] = 48000000;

            impl->sampleRateArray[7] = 64000000;

            impl->sampleRateArray[8] = 88200000;

            impl->sampleRateArray[9] = 96000000;

            pDescriptor->maxChannels = 2;

            pDescriptor->minBitsPerSample = 16;

            pDescriptor->maxBitsPerSample = 16;

            pDescriptor->minSampleRate = 8000000;  /*milliHz*/ 

            pDescriptor->maxSampleRate = 96000000;

            pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_FALSE;

            pDescriptor->pSampleRatesSupported = (XAmilliHertz*)(&(impl->sampleRateArray));

            pDescriptor->numSampleRatesSupported = 10;

            pDescriptor->minBitRate= 0;

            pDescriptor->maxBitRate= 0;

            pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_FALSE;

            pDescriptor->pBitratesSupported = NULL;

            pDescriptor->numBitratesSupported = 0;

            pDescriptor->profileSetting = XA_AUDIOPROFILE_PCM        ;

            pDescriptor->modeSetting = 0;            

            }

            break;

        }

#ifdef _GSTREAMER_BACKEND_  

    res = XAStaticCapsAdapt_GetCapsById(XACAP_ENCODER|XACAP_AUDIO, encoderId, &temp);

   	if( res == XA_RESULT_SUCCESS )

    {

   		/* map applicable values to XAAudioCodecCapabilities */

      pDescriptor->maxChannels=temp.maxCh;

      pDescriptor->minSampleRate=temp.minSR*1000; /* milliHz */

      if (temp.maxSR < (0xFFFFFFFF / 1000))

      {

      	pDescriptor->maxSampleRate = temp.maxSR*1000;

      }

      else

      {

    		pDescriptor->maxSampleRate = 0xFFFFFFFF;

   		}

      pDescriptor->minBitsPerSample=temp.minBPS;

      pDescriptor->maxBitsPerSample=temp.maxBPS;

      pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_TRUE;

      pDescriptor->minBitRate=temp.minBR;

    	pDescriptor->maxBitRate=temp.maxBR;

      pDescriptor->numBitratesSupported = temp.numBitrates;

      pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_TRUE;

      if (temp.xaid == XA_AUDIOCODEC_PCM )

      {

     		pDescriptor->profileSetting=XA_AUDIOPROFILE_PCM;

        pDescriptor->modeSetting=0;

      }

    	else if (temp.xaid == XA_ADAPTID_VORBIS) /* for ogg */

      {

      	if (temp.maxCh == 1)

        {

        	pDescriptor->profileSetting=XA_AUDIOPROFILE_MPEG1_L3;

          pDescriptor->modeSetting=XA_AUDIOCHANMODE_MP3_MONO;

       	}

        else

        {

       		pDescriptor->profileSetting=XA_AUDIOPROFILE_MPEG2_L3;

          pDescriptor->modeSetting=XA_AUDIOCHANMODE_MP3_STEREO;

        }

      }

      else

      {

     		/* Do nothing */

      }

    }

#endif   	

    DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities");

    return res;

}

/*****************************************************************************

 * XAAudioEncoderCapabilitiesItfImpl -specific methods

 *****************************************************************************/

/* XAAudioEncoderCapabilitiesItfImpl_Create

 * Description: Allocate and initialize XAAudioEncoderCapabilitiesItfImpl

 */

XAAudioEncoderCapabilitiesItfImpl* XAAudioEncoderCapabilitiesItfImpl_Create()

{

    XAAudioEncoderCapabilitiesItfImpl* self = (XAAudioEncoderCapabilitiesItfImpl*)

        calloc(1,sizeof(XAAudioEncoderCapabilitiesItfImpl));

    DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_Create");

    if( self )

    {

        /* init itf default implementation */

        self->itf.GetAudioEncoders =

            XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders;

        self->itf.GetAudioEncoderCapabilities =

            XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities;

#ifdef _GSTREAMER_BACKEND_  

        /* init variables */

        assert( XAStaticCapsAdapt_GetCapsCount( XACAP_ENCODER|XACAP_AUDIO,

                                  &(self->numCodecs) ) == XA_RESULT_SUCCESS );

#endif

        /*self->mmfEngine = (void*)mmf_capability_engine_init();*/

        self->numCodecs = 3;

        self->self = self;

    }

    DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Create");

    return self;

}

/* void XAAudioEncoderCapabilitiesItfImpl_Free

 * Description: Free all resources reserved at XAAudioEncoderCapabilitiesItfImpl_Create

 */

void XAAudioEncoderCapabilitiesItfImpl_Free(XAAudioEncoderCapabilitiesItfImpl* self)

{

    DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_Free");

    assert(self==self->self);

    free(self);

    DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Free");

}