Mercurial Mercurial > oss > FCL > sf > mw > mmmw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
khronosfws/openmax_al/src/engine/xaaudioencodercapabilitiesitf.c
changeset 53 eabc8c503852
parent 33 5e8b14bae8c3
equal deleted inserted replaced
48:a493a607b5bf 53:eabc8c503852 
    15  *
 
    15  *
 
    16  */
 
    16  */
 
    17 
    17 
    18 #include <stdio.h>
 
    18 #include <stdio.h>
 
    19 #include <stdlib.h>
 
    19 #include <stdlib.h>
 
    20 #include <assert.h>
 
       
    21 #include <string.h>
 
    20 #include <string.h>
 
    22 
    21 
    23 #include "xaglobals.h"
 
    22 #include "xaglobals.h"
 
    24 #include "xaadptbasectx.h"
 
    23 #include "xaadptbasectx.h"
 
    25 #include "xaaudioencodercapabilitiesitf.h"
 
    24 #include "xaaudioencodercapabilitiesitf.h"
 
    67         {
 
    66         {
 
    68         if (pEncoderIds)
 
    67         if (pEncoderIds)
 
    69             { /* query array of encoders */
 
    68             { /* query array of encoders */
 
    70             if (*pNumEncoders < impl->numCodecs)
 
    69             if (*pNumEncoders < impl->numCodecs)
 
    71                 {
 
    70                 {
 
    72                 DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");
 
    71                 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
    73                 res = XA_RESULT_BUFFER_INSUFFICIENT;
 
    72                 res = XA_RESULT_PARAMETER_INVALID;
 
    74                 }
 
    73                 }
 
    75             else
 
    74             else
 
    76                 {
 
    75                 {
 
    77 
    76 
    78                 XAuint32 i = 0;
 
    77                 XAuint32 i = 0;
 
    83                     XACapabilitiesMgr_GetCapsByIdx(impl->capslist,
 
    82                     XACapabilitiesMgr_GetCapsByIdx(impl->capslist,
 
    84                             (XACapsType) (XACAP_ENCODER | XACAP_AUDIO), i,
 
    83                             (XACapsType) (XACAP_ENCODER | XACAP_AUDIO), i,
 
    85                             &temp);
 
    84                             &temp);
 
    86                     pEncoderIds[i] = temp.xaid;
 
    85                     pEncoderIds[i] = temp.xaid;
 
    87                     }
 
    86                     }
 
    88 
       
    89                 pEncoderIds[0] = XA_AUDIOCODEC_AMR;
 
       
    90                 pEncoderIds[1] = XA_AUDIOCODEC_AAC;
 
       
    91                 pEncoderIds[2] = XA_AUDIOCODEC_PCM;
 
       
    92                 }
 
    87                 }
 
    93             }
 
    88             }
 
    94 
    89 
    95         /* return number of encoders */
 
    90         /* return number of encoders */
 
    96         *pNumEncoders = impl->numCodecs;
 
    91         *pNumEncoders = impl->numCodecs;
 
   109     XAAudioEncoderCapabilitiesItfImpl* impl = GetImpl(self);
 
   104     XAAudioEncoderCapabilitiesItfImpl* impl = GetImpl(self);
 
   110     XAresult res = XA_RESULT_SUCCESS;
 
   105     XAresult res = XA_RESULT_SUCCESS;
 
   111 
   106 
   112     XACapabilities temp;
 
   107     XACapabilities temp;
 
   113 
   108 
       
   109     XAint16 index;
 
   114     DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities");
 
   110     DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities");
 
   115 
   111 
   116     /*if( !impl || !pIndex || !pDescriptor )*/
 
   112     /*if( !impl || !pIndex || !pDescriptor )*/
 
   117     /*Removing the pDescriptor because the client can pass
 
   113     /*Removing the pDescriptor because the client can pass
 
   118      * it as NULL to query the pIndex for number of Codec/Mode
 
   114      * it as NULL to query the pIndex for number of Codec/Mode
 
   121         {
 
   117         {
 
   122         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   118         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   123         res = XA_RESULT_PARAMETER_INVALID;
 
   119         res = XA_RESULT_PARAMETER_INVALID;
 
   124         return res;
 
   120         return res;
 
   125         }
 
   121         }
 
   126     else
 
   122     else if(!pDescriptor)
 
   127         {
 
   123         {
 
   128         *pIndex = 1;
 
   124         res = XACapabilitiesMgr_GetCapsById(impl->capslist,
 
   129         if (!pDescriptor)
 
   125                 (XACapsType) (XACAP_ENCODER | XACAP_AUDIO), encoderId, &temp);
 
   130             {
 
   126         
   131             return res;
 
   127         *pIndex = temp.noOfEntries;
 
   132             }
 
   128 
   133         }
 
   129         return res;
 
   134 
   130 
       
   131         }
 
       
   132     
       
   133     index = *pIndex;
 
       
   134     
   135     /* query capabilities from adaptation using codec id */
 
   135     /* query capabilities from adaptation using codec id */
 
   136     memset(pDescriptor, 0, sizeof(XAAudioCodecDescriptor));
 
   136     memset(pDescriptor, 0, sizeof(XAAudioCodecDescriptor));
 
   137  
   137  
   138     res = XACapabilitiesMgr_GetCapsById(impl->capslist,
 
   138     res = XACapabilitiesMgr_GetCapsById(impl->capslist,
 
   139             (XACapsType) (XACAP_ENCODER | XACAP_AUDIO), encoderId, &temp);
 
   139             (XACapsType) (XACAP_ENCODER | XACAP_AUDIO), encoderId, &temp);
 
   140     if (res == XA_RESULT_SUCCESS)
 
   140     if (res == XA_RESULT_SUCCESS)
 
   141         {
 
   141         {
 
   142         XAAudioCodecDescriptor* desc =
 
   142         XAAudioCodecDescriptor* desc =
 
   143                 ((XAAudioCodecDescriptor*) (temp.pEntry));
 
   143                 ((XAAudioCodecDescriptor*) (temp.pEntry));
 
       
   144         if(index >= temp.noOfEntries)
 
       
   145             {
 
       
   146             DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
       
   147             res = XA_RESULT_PARAMETER_INVALID;
 
       
   148             return res;
 
       
   149         
       
   150             }
 
       
   151         else
 
       
   152             {
 
       
   153             //indexing
 
       
   154             desc = desc+index;
 
       
   155             }
 
       
   156 
   144         /* map applicable values to XAAudioCodecCapabilities */
 
   157         /* map applicable values to XAAudioCodecCapabilities */
 
   145         pDescriptor->maxChannels = desc->maxChannels;
 
   158         pDescriptor->maxChannels = desc->maxChannels;
 
       
   159         pDescriptor->minBitsPerSample = desc->minBitsPerSample;
 
       
   160         pDescriptor->maxBitsPerSample = desc->maxBitsPerSample;
 
   146         pDescriptor->minSampleRate = desc->minSampleRate ; /* milliHz */
 
   161         pDescriptor->minSampleRate = desc->minSampleRate ; /* milliHz */
 
   147         if (desc->maxSampleRate < (0xFFFFFFFF))
 
   162         if (desc->maxSampleRate < (0xFFFFFFFF))
 
   148             {
 
   163             {
 
   149             pDescriptor->maxSampleRate = desc->maxSampleRate;
 
   164             pDescriptor->maxSampleRate = desc->maxSampleRate;
 
   150             }
 
   165             }
 
   151         else
 
   166         else
 
   152             {
 
   167             {
 
   153             pDescriptor->maxSampleRate = 0xFFFFFFFF;
 
   168             pDescriptor->maxSampleRate = 0xFFFFFFFF;
 
   154             }
 
   169             }
 
   155         pDescriptor->minBitsPerSample = desc->minBitsPerSample;
 
   170 
   156         pDescriptor->maxBitsPerSample = desc->maxBitsPerSample;
 
       
   157       pDescriptor->isFreqRangeContinuous=desc->isFreqRangeContinuous;
 
   171       pDescriptor->isFreqRangeContinuous=desc->isFreqRangeContinuous;
 
   158         pDescriptor->minBitRate = desc->minBitRate;
 
   172       pDescriptor->pSampleRatesSupported = desc->pSampleRatesSupported;
 
   159         pDescriptor->maxBitRate = desc->maxBitRate;
 
   173       pDescriptor->numSampleRatesSupported = desc->numSampleRatesSupported;
 
   160         pDescriptor->numBitratesSupported = desc->numBitratesSupported;
 
   174       pDescriptor->minBitRate = desc->minBitRate;
 
       
   175       pDescriptor->maxBitRate = desc->maxBitRate;
 
   161       pDescriptor->isBitrateRangeContinuous=desc->isBitrateRangeContinuous;
 
   176       pDescriptor->isBitrateRangeContinuous=desc->isBitrateRangeContinuous;
 
       
   177       pDescriptor->pBitratesSupported = desc->pBitratesSupported;
 
       
   178       pDescriptor->numBitratesSupported = desc->numBitratesSupported;
 
   162       pDescriptor->profileSetting=desc->profileSetting;
 
   179       pDescriptor->profileSetting=desc->profileSetting;
 
   163       pDescriptor->modeSetting=desc->modeSetting; /* no chanmode for pcm defined */
 
   180       pDescriptor->modeSetting=desc->modeSetting; /* no chanmode for pcm defined */
 
   164     }
 
   181     }
 
   165       else
 
   182       else
 
   166       {
 
   183       {
 
   197         self->itf.GetAudioEncoderCapabilities
 
   214         self->itf.GetAudioEncoderCapabilities
 
   198                 = XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities;
 
   215                 = XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities;
 
   199         self->capslist = caps;
 
   216         self->capslist = caps;
 
   200 
   217 
   201         /* init variables */
 
   218         /* init variables */
 
   202         assert( XACapabilitiesMgr_GetCapsCount( caps, (XACapsType)((XACapsType)(XACAP_ENCODER|XACAP_AUDIO)),
 
   219         XACapabilitiesMgr_GetCapsCount( caps, (XACapsType)((XACapsType)(XACAP_ENCODER|XACAP_AUDIO)),
 
   203                         &(self->numCodecs) ) == XA_RESULT_SUCCESS );
 
   220                         &(self->numCodecs) );
 
   204 
   221 
   205         /*self->mmfEngine = (void*)mmf_capability_engine_init();*/
 
   222         /*self->mmfEngine = (void*)mmf_capability_engine_init();*/
 
   206         self->numCodecs = 3;
 
   223         
       
   224         //self->numCodecs = 3;
 
   207         self->self = self;
 
   225         self->self = self;
 
   208 
   226 
   209         }
 
   227         }
 
   210     DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Create");
 
   228     DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Create");
 
   211     return self;
 
   229     return self;
 
   216  */
 
   234  */
 
   217 void XAAudioEncoderCapabilitiesItfImpl_Free(
 
   235 void XAAudioEncoderCapabilitiesItfImpl_Free(
 
   218         XAAudioEncoderCapabilitiesItfImpl* self)
 
   236         XAAudioEncoderCapabilitiesItfImpl* self)
 
   219     {
 
   237     {
 
   220     DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_Free");
 
   238     DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_Free");
 
   221     assert(self==self->self);
 
       
   222     free(self);
 
   239     free(self);
 
   223     DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Free");
 
   240     DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Free");
 
   224     }
 
   241     }
FCL/sf/mw/mmmw