khronosfws/openmax_al/src/engine/xaaudiodecodercapabilitiesitf.c
changeset 16 43d09473c595
parent 12 5a06f39ad45b
child 25 6f7ceef7b1d1
equal deleted inserted replaced
14:80975da52420 16:43d09473c595
    19 #include <stdlib.h>
    19 #include <stdlib.h>
    20 #include <assert.h>
    20 #include <assert.h>
    21 #include <string.h>
    21 #include <string.h>
    22 
    22 
    23 #include "xaglobals.h"
    23 #include "xaglobals.h"
       
    24 #include "xaadptbasectx.h"
    24 #include "xaaudiodecodercapabilitiesitf.h"
    25 #include "xaaudiodecodercapabilitiesitf.h"
    25 #ifdef _GSTREAMER_BACKEND_  
    26 #include "xacapabilitiesmgr.h"
    26 #include "XAStaticCapsAdaptation.h"
       
    27 #endif
       
    28 /* XAAudioDecoderCapabilitiesItfImpl* GetImpl
    27 /* XAAudioDecoderCapabilitiesItfImpl* GetImpl
    29  * Description: Validate interface pointer and cast it to implementation pointer.
    28  * Description: Validate interface pointer and cast it to implementation pointer.
    30  */
    29  */
    31 static XAAudioDecoderCapabilitiesItfImpl* GetImpl(XAAudioDecoderCapabilitiesItf self)
    30 static XAAudioDecoderCapabilitiesItfImpl* GetImpl(XAAudioDecoderCapabilitiesItf self)
    32 {
    31 {
    72                 DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");
    71                 DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");
    73                 res = XA_RESULT_BUFFER_INSUFFICIENT;
    72                 res = XA_RESULT_BUFFER_INSUFFICIENT;
    74             }
    73             }
    75             else
    74             else
    76             {
    75             {
    77 #ifdef _GSTREAMER_BACKEND_  
    76  
    78             XAuint32 i = 0;
    77             XAuint32 i = 0;
    79             XAStaticCapsData temp;
    78             XACapabilities temp;
    80                 for( i=0; i<impl->numCodecs; i++ )
    79                 for( i=0; i<impl->numCodecs; i++ )
    81                 {
    80                 {
    82                     /* query decoder id from adaptation using index value */
    81                     /* query decoder id from adaptation using index value */
    83                     XAStaticCapsAdapt_GetCapsByIdx(XACAP_DECODER|XACAP_AUDIO, i, &temp);
    82                     XACapabilitiesMgr_GetCapsByIdx(NULL, (XACapsType)(XACAP_DECODER|XACAP_AUDIO), i, &temp);
    84                     pDecoderIds[i] = temp.xaid;
    83                     pDecoderIds[i] = temp.xaid;
    85                 }
    84                 }
    86 #endif
    85 
    87             }
    86             }
    88         }
    87         }
    89         /* return number of decoders */
    88         /* return number of decoders */
    90         *pNumDecoders = impl->numCodecs;
    89         *pNumDecoders = impl->numCodecs;
    91     }
    90     }
   125                 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   124                 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   126                 res = XA_RESULT_PARAMETER_INVALID;
   125                 res = XA_RESULT_PARAMETER_INVALID;
   127             }
   126             }
   128             else
   127             else
   129             {
   128             {
   130 #ifdef _GSTREAMER_BACKEND_  
   129  
   131                 /* query capabilities from adaptation using codec id */
   130                 /* query capabilities from adaptation using codec id */
   132                 XAStaticCapsData temp;
   131                 XACapabilities temp;
   133                 memset(pDescriptor,0,sizeof(XAAudioCodecDescriptor));
   132                 memset(pDescriptor,0,sizeof(XAAudioCodecDescriptor));
   134                 res = XAStaticCapsAdapt_GetCapsById(XACAP_DECODER|XACAP_AUDIO, decoderId, &temp);
   133                 res = XACapabilitiesMgr_GetCapsById(NULL, (XACapsType)(XACAP_DECODER|XACAP_AUDIO), decoderId, &temp);
   135                 if( res == XA_RESULT_SUCCESS )
   134                 if( res == XA_RESULT_SUCCESS )
   136                 {
   135                 {
       
   136                     XAAudioCodecDescriptor* desc = ((XAAudioCodecDescriptor*)(temp.pEntry));
   137                     /* map applicable values to XAAudioCodecCapabilities */
   137                     /* map applicable values to XAAudioCodecCapabilities */
   138                     pDescriptor->maxChannels=temp.maxCh;
   138                     pDescriptor->maxChannels = desc->maxChannels;
   139                     pDescriptor->minSampleRate=temp.minSR*1000; /* milliHz */
   139                     pDescriptor->minSampleRate= desc->minSampleRate*1000; /* milliHz */
   140                     if (temp.maxSR < (0xFFFFFFFF / 1000))
   140                     if (desc->maxSampleRate < (0xFFFFFFFF / 1000))
   141                     {
   141                     {
   142                         pDescriptor->maxSampleRate = temp.maxSR*1000;
   142                         pDescriptor->maxSampleRate = desc->maxSampleRate*1000;
   143                     }
   143                     }
   144                     else
   144                     else
   145                     {
   145                     {
   146                         pDescriptor->maxSampleRate = 0xFFFFFFFF;
   146                         pDescriptor->maxSampleRate = 0xFFFFFFFF;
   147                     }
   147                     }
   148                     pDescriptor->minBitsPerSample=temp.minBPS;
   148                     pDescriptor->minBitsPerSample=desc->minBitsPerSample;
   149                     pDescriptor->maxBitsPerSample=temp.maxBPS;
   149                     pDescriptor->maxBitsPerSample=desc->maxBitsPerSample;
   150                     pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_TRUE;
   150                     pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_TRUE;
   151                     pDescriptor->minBitRate=temp.minBR;
   151                     pDescriptor->minBitRate=desc->minBitRate;
   152                     pDescriptor->maxBitRate=temp.maxBR;
   152                     pDescriptor->maxBitRate=desc->maxBitRate;
   153                     pDescriptor->numBitratesSupported = temp.numBitrates;
   153                     pDescriptor->numBitratesSupported = desc->numBitratesSupported;
   154                     pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_TRUE;
   154                     pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_TRUE;
   155                     if (temp.xaid == XA_AUDIOCODEC_PCM )
   155                     if (temp.xaid == XA_AUDIOCODEC_PCM )
   156                     {
   156                     {
   157                         pDescriptor->profileSetting=XA_AUDIOPROFILE_PCM;
   157                         pDescriptor->profileSetting=XA_AUDIOPROFILE_PCM;
   158                         pDescriptor->modeSetting=0; /* no chanmode for pcm defined */
   158                         pDescriptor->modeSetting=0; /* no chanmode for pcm defined */
   159                     }
   159                     }
   160                     else if (temp.xaid == XA_ADAPTID_VORBIS) /* for ogg */
   160                     else if (temp.xaid == XA_ADAPTID_VORBIS) /* for ogg */
   161                     {
   161                     {
   162                         if (temp.maxCh == 1)
   162                         if (desc->maxChannels == 1)
   163                         {
   163                         {
   164                             pDescriptor->profileSetting=XA_AUDIOPROFILE_MPEG1_L3;
   164                             pDescriptor->profileSetting=XA_AUDIOPROFILE_MPEG1_L3;
   165                             pDescriptor->modeSetting=XA_AUDIOCHANMODE_MP3_MONO;
   165                             pDescriptor->modeSetting=XA_AUDIOCHANMODE_MP3_MONO;
   166                         }
   166                         }
   167                         else
   167                         else
   174                     {
   174                     {
   175                         /* do nothing */
   175                         /* do nothing */
   176                     }
   176                     }
   177                     /*other caps undefined*/
   177                     /*other caps undefined*/
   178                 }
   178                 }
   179 #endif                
   179                 
   180             }
   180             }
   181         }
   181         }
   182     }
   182     }
   183 
   183 
   184     DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities");
   184     DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities");
   207             XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders;
   207             XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders;
   208         self->itf.GetAudioDecoderCapabilities =
   208         self->itf.GetAudioDecoderCapabilities =
   209             XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities;
   209             XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities;
   210 
   210 
   211         /* init variables */
   211         /* init variables */
   212 #ifdef _GSTREAMER_BACKEND_  
   212  
   213         assert( XAStaticCapsAdapt_GetCapsCount( XACAP_DECODER|XACAP_AUDIO,
   213         assert( XACapabilitiesMgr_GetCapsCount(NULL, (XACapsType)(XACAP_DECODER|XACAP_AUDIO),
   214                                   &(self->numCodecs) ) == XA_RESULT_SUCCESS );
   214                                   &(self->numCodecs) ) == XA_RESULT_SUCCESS );
   215 #endif
   215 
   216         self->self = self;
   216         self->self = self;
   217     }
   217     }
   218     DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_Create");
   218     DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_Create");
   219     return self;
   219     return self;
   220 }
   220 }